//! Workbench M00–M06 contract gate (offline). //! Spec: doc/design/qdagent-workbench-runtime-and-view-2026-10-25.md use serde_json::Value; use std::path::PathBuf; fn fixture(name: &str) -> Value { let root = PathBuf::from(env!("CARGO_MANIFEST_DIR")); let path = root.join("tests/workbench/fixtures").join(name); let raw = std::fs::read_to_string(&path).unwrap_or_else(|e| panic!("read {}: {e}", path.display())); serde_json::from_str(&raw).expect("fixture json") } fn schema(name: &str) -> Value { let root = PathBuf::from(env!("CARGO_MANIFEST_DIR")); let path = root.join("tests/workbench/schemas").join(name); let raw = std::fs::read_to_string(&path).unwrap_or_else(|e| panic!("read {}: {e}", path.display())); serde_json::from_str(&raw).expect("schema json") } /// Lightweight required-field check against our JSON Schema documents (no jsonschema crate). fn assert_required(instance: &Value, schema_doc: &Value, label: &str) { let required = schema_doc["required"].as_array().expect("schema.required"); for key in required { let k = key.as_str().unwrap(); assert!( instance.get(k).is_some(), "{label}: missing required field {k} in {instance}" ); } } fn mlsp(method: &str, params: Value) -> Value { let req = serde_json::json!({"id": 1, "method": method, "params": params}); let line = marqdo::mlsp::handle_line(&req.to_string()); serde_json::from_str(&line).expect("mlsp response json") } #[test] fn m00_fixtures_consume_and_capabilities() { let sel = fixture("model_selection_ok.json"); assert_required(&sel, &schema("ModelSelectionV1.schema.json"), "selection"); assert_eq!(sel["schema"], "ModelSelectionV1"); let parsed = marqdo::workbench::parse_model_selection(&sel, true).expect("strict ok"); assert_eq!(parsed.selection_id, "sel-1"); let snap = parsed.public_snapshot(); assert!(snap.get("api_key").is_none()); let usage = fixture("model_call_usage_unknown.json"); assert_required(&usage, &schema("ModelCallUsageV1.schema.json"), "usage"); assert!(usage["input_tokens"].is_null()); assert_ne!(usage["input_tokens"], 0); assert_eq!(usage["usage_state"], "unknown"); let cancelled = fixture("model_call_usage_cancelled.json"); assert_eq!(cancelled["status"], "cancelled"); assert_eq!(cancelled["usage_state"], "partial"); let doc = fixture("document_view_partial.json"); assert_required(&doc, &schema("DocumentViewV1.schema.json"), "document_view"); assert_eq!(doc["execution"]["state"], "not_run"); let stale = fixture("locator_stale.json"); assert_eq!(stale["resolution"], "stale"); let loc = &stale["locator"]; assert_required(loc, &schema("KnowledgeLocatorV1.schema.json"), "locator"); let unavail = fixture("locator_version_unavailable.json"); assert_eq!(unavail["resolution"], "version_unavailable"); let ev = fixture("runtime_event_cancelled.json"); assert_required(&ev, &schema("RuntimeEventV1.schema.json"), "runtime_event"); assert_eq!(ev["type"], "run.cancelled"); let _ = fixture("model_selection_error.json"); let _ = fixture("document_view_unsupported.json"); let caps = mlsp("capabilities", serde_json::json!({})); assert_eq!(caps["ok"], true, "{caps}"); let features = &caps["result"]["features"]; assert_eq!(features["view.document"], 1); assert_eq!(features["view.reference_resolve"], 1); assert!(caps["result"]["contracts"] .as_array() .unwrap() .iter() .any(|c| c.as_str() == Some("DocumentViewV1"))); // F16 honesty: unloaded plugins + forced-off stream/cancel → 0 let down = mlsp( "capabilities", serde_json::json!({ "force_unloaded": true, "force_stream_off": true, "force_cancel_off": true }), ); assert_eq!(down["result"]["features"]["llm.messages"], 0); assert_eq!(down["result"]["features"]["runtime.event_stream"], 0); assert_eq!(down["result"]["features"]["runtime.cancel"], 0); } #[test] fn m00_strict_selection_rejects_missing() { let bad = serde_json::json!({"schema_version": 1, "model_id": "x"}); let err = marqdo::workbench::parse_model_selection(&bad, true).unwrap_err(); assert!(err.contains("selection_missing"), "{err}"); } #[test] fn m02_usage_null_not_zero() { let usage = marqdo::workbench::model_call_usage_from_provider( "c1", "a1", "r1", &serde_json::json!({"selection_id": "s", "provider_id": "p", "model_id": "m"}), &serde_json::Value::Null, "succeeded", ); assert!(usage["input_tokens"].is_null()); assert_eq!(usage["measurement_source"], "none"); assert_eq!(usage["usage_state"], "unknown"); } #[test] fn m03_view_document_no_exec() { let root = PathBuf::from(env!("CARGO_MANIFEST_DIR")) .join("tests/executable_knowledge/baseline/02-extract"); let resp = mlsp( "view.document", serde_json::json!({ "project": root.to_string_lossy(), "document": "main.mq.md", "mode": "read", "include": ["fragment", "outline", "nodes", "diagnostics"] }), ); assert_eq!(resp["ok"], true, "{resp}"); let doc = &resp["result"]; assert_eq!(doc["schema"], "DocumentViewV1"); assert_eq!(doc["execution"]["state"], "not_run"); assert_eq!(doc["capabilities"]["read_only"], true); assert_eq!(doc["capabilities"]["executed"], false); let fragment = doc["render"]["fragment"].as_str().unwrap_or(""); assert!(fragment.contains("mq-document"), "{fragment}"); assert!(!fragment.contains("= 1, "hits={hits} misses={misses} merges={merges}"); assert!( merges > 0 || hits > 0, "expected coalesce or reuse: hits={hits} misses={misses} merges={merges}" ); } #[test] fn m04_snapshot_manifest_on_document_view() { let root = PathBuf::from(env!("CARGO_MANIFEST_DIR")) .join("tests/executable_knowledge/baseline/02-extract"); let resp = mlsp( "view.document", serde_json::json!({ "project": root.to_string_lossy(), "document": "main.mq.md", "mode": "read", "include": ["fragment"] }), ); assert_eq!(resp["ok"], true, "{resp}"); let snap = &resp["result"]["snapshot"]; assert_eq!(snap["schema"], "SnapshotManifestV1"); assert_eq!(snap["retention"]["owner"], "application"); assert!(snap["source_revision"].as_str().unwrap().starts_with("sha256:")); assert_eq!( snap["source_revision"], resp["result"]["document"]["source_revision"] ); } #[test] fn m01_f02_run_context_three_level_inherit() { let root = marqdo::workbench::RunContext::from_value(&serde_json::json!({ "run_id": "run-root", "turn_id": "turn-1", "workspace_scope": "ws-1", "selection_context": { "selection_id": "sel-1", "upstream_model_id": "model-fixed", "base_url": "http://127.0.0.1:7700" }, "cancellation_token": "/tmp/mq-cancel-f02" })) .unwrap(); let child = root.spawn_child("run-child"); let grand = child.spawn_child("run-grand"); assert_eq!(grand.parent_run_id.as_deref(), Some("run-child")); assert_eq!( grand.selection_context["upstream_model_id"], "model-fixed" ); assert_eq!(grand.turn_id.as_deref(), Some("turn-1")); assert_eq!( grand.cancellation_token.as_deref(), Some("/tmp/mq-cancel-f02") ); let env = grand.selection_env(); assert!(env.iter().any(|(k, v)| k == "OPENAI_MODEL" && v == "model-fixed")); // Root selection must not be mutated by descendants. assert_eq!(root.selection_context["upstream_model_id"], "model-fixed"); assert_eq!(root.run_id, "run-root"); } #[test] fn m03_f08_side_effect_marker_not_created_by_view() { let root = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/workbench/fixtures"); let marker = root.join(".workbench-f08-marker"); let _ = std::fs::remove_file(&marker); let resp = mlsp( "view.document", serde_json::json!({ "project": root.to_string_lossy(), "document": "f08_write_side_effect.mq.md", "mode": "read", "include": ["fragment", "diagnostics"] }), ); assert_eq!(resp["ok"], true, "{resp}"); assert_eq!(resp["result"]["execution"]["state"], "not_run"); assert!( !marker.exists(), "view.document must not execute file.write side effects" ); } #[test] fn m03_f09_step_kinds_baseline_projects_nodes() { let root = PathBuf::from(env!("CARGO_MANIFEST_DIR")) .join("tests/executable_knowledge/baseline/07-step-kinds"); let resp = mlsp( "view.document", serde_json::json!({ "project": root.to_string_lossy(), "document": "main.mq.md", "mode": "read", "include": ["outline", "nodes", "fragment"] }), ); assert_eq!(resp["ok"], true, "{resp}"); let outline = resp["result"]["outline"].as_array().unwrap(); assert!( outline.iter().any(|o| o["kind"] == "heading"), "expected heading outline: {outline:?}" ); let nodes = resp["result"]["nodes"].as_array().unwrap(); assert!(nodes.len() >= 2, "expected artifact+step nodes: {nodes:?}"); let kinds: std::collections::HashSet<&str> = nodes .iter() .filter_map(|n| n["kind"].as_str()) .collect(); assert!( kinds.iter().any(|k| matches!( *k, "observe" | "derive" | "call" | "iterate" | "narrate" | "type" | "function" )), "expected step/artifact kinds in read model: {kinds:?}" ); // Evidence statuses must not be silently upgraded to verified by the read path. for n in nodes { if let Some(ev) = n.get("evidence").and_then(|v| v.as_str()) { assert_ne!(ev, "verified", "read path must not invent verified: {n}"); } } let fragment = resp["result"]["render"]["fragment"].as_str().unwrap_or(""); assert!(fragment.contains("mq-document")); assert!(!fragment.contains("= '\u{4e00}'), "expected CJK in outline/nodes for 02-extract: {blob}" ); let fragment = doc["render"]["fragment"].as_str().unwrap_or(""); // F12 static HTML subset (full browser → qdagent): semantic article, no script, mq namespace. assert!(fragment.starts_with("= 2, "{resp}"); } /// F02: agent.step + resume with explicit llm.create selection against a local mock. /// Env poison model must not appear in the upstream request body. #[test] fn m01_f02_agent_step_selection_and_resume() { use std::io::{Read, Write}; use std::net::TcpListener; use std::process::Command; use std::sync::{Arc, Mutex}; use std::thread; let root = PathBuf::from(env!("CARGO_MANIFEST_DIR")); let ext = root.join("ext"); let status = Command::new("cargo") .args(["build", "-p", "marqdo_plugin_llm", "-p", "marqdo_plugin_agent", "--locked"]) .current_dir(&root) .status() .expect("build plugins"); assert!(status.success(), "plugin build failed"); let llm_so = root.join("target/debug/libllm.so"); let agent_so = root.join("target/debug/libagent.so"); assert!(llm_so.is_file(), "missing {llm_so:?}"); assert!(agent_so.is_file(), "missing {agent_so:?}"); let seen = Arc::new(Mutex::new(Vec::new())); let listener = TcpListener::bind("127.0.0.1:0").unwrap(); let addr = listener.local_addr().unwrap(); let seen_bg = seen.clone(); thread::spawn(move || { // Agent may deepen once (READ) then answer — accept a few requests. for _ in 0..4 { let Ok((mut stream, _)) = listener.accept() else { break; }; let mut raw = Vec::new(); let mut buf = [0u8; 4096]; loop { let n = stream.read(&mut buf).unwrap_or(0); if n == 0 { break; } raw.extend_from_slice(&buf[..n]); if let Some(pos) = raw.windows(4).position(|w| w == b"\r\n\r\n") { let header = String::from_utf8_lossy(&raw[..pos]); let cl = header .lines() .find_map(|l| l.strip_prefix("Content-Length:")) .and_then(|v| v.trim().parse::().ok()) .unwrap_or(0); let body_start = pos + 4; while raw.len() < body_start + cl { let n = stream.read(&mut buf).unwrap_or(0); if n == 0 { break; } raw.extend_from_slice(&buf[..n]); } break; } } let req = String::from_utf8_lossy(&raw).to_string(); seen_bg.lock().unwrap().push(req); let body = r#"{"choices":[{"message":{"content":"pong"},"finish_reason":"stop"}],"usage":{"prompt_tokens":3,"completion_tokens":1,"total_tokens":4}}"#; let resp = format!( "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}", body.len(), body ); let _ = stream.write_all(resp.as_bytes()); } }); let base = format!("http://{addr}/v1"); let output = Command::new(env!("CARGO_BIN_EXE_marqdo")) .args(["run", "tests/ext/workbench-agent-selection.mq.md"]) .current_dir(&root) .env("MARQDO_EXT", &ext) .env("MARQDO_LLM_PLUGIN", &llm_so) .env("MARQDO_AGENT_PLUGIN", &agent_so) .env("OPENAI_BASE_URL", &base) .env("OPENAI_API_KEY", "f02-key") .env("OPENAI_MODEL", "f02-selected-model") .output() .expect("run workbench-agent-selection"); let stdout = String::from_utf8_lossy(&output.stdout); let stderr = String::from_utf8_lossy(&output.stderr); assert_eq!( output.status.code().unwrap_or(1), 0, "stderr={stderr}\nstdout={stdout}" ); assert!( stdout.contains("f02-agent-selection-ok"), "stdout={stdout}" ); assert!(stdout.contains("resume-save-ok") && stdout.contains("resume-load-ok")); let captured = seen.lock().unwrap().join("\n"); assert!( !captured.is_empty(), "mock received no HTTP; stdout={stdout}" ); // Body may embed the .mq.md source (which mentions the poison string in prose). // Assert the OpenAI `model` field itself — not a raw substring of the whole HTTP dump. let model_field = captured .split("\r\n\r\n") .nth(1) .unwrap_or("") .lines() .next() .unwrap_or(""); let body: Value = serde_json::from_str(model_field).unwrap_or_else(|_| { // Some captures concatenate multiple HTTP messages; take last `{...}` blob. let start = captured.rfind('{').expect("json body"); serde_json::from_str(&captured[start..]).expect("parse chat body") }); assert_eq!( body["model"].as_str(), Some("f02-selected-model"), "upstream model field: {body}" ); assert_ne!(body["model"].as_str(), Some("env-poison-model")); }