Files
marqdo/tests/workbench_contracts.rs
T
cflmyandCursor c7c329341b feat(workbench): live selection smoke, F02 agent e2e, DocumentView CLI
Hoist llm.ask prompt binding to avoid elevated `p`; prefer reasoning_content
when content is empty; point live/tests at in-tree MARQDO_EXT; add USTC live
gates and mock agent.step selection+resume evidence; view document --out for
read-only browser embed checks. Design stays Partial (not Verified).

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-10-25 23:05:28 +08:00

816 lines
30 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! 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("<script"), "must not embed scripts");
let outline = doc["outline"].as_array().unwrap();
assert!(
outline.iter().any(|o| o["kind"] == "heading"),
"expected heading outline from # lines: {outline:?}"
);
}
#[test]
fn m03_view_document_revision_mismatch_refuses_downgrade() {
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",
"revision": "sha256:deadbeef",
"mode": "read"
}),
);
assert_eq!(resp["ok"], false, "{resp}");
assert_eq!(resp["error"]["code"], "view.revision_mismatch");
}
#[test]
fn m04_reference_resolve_unresolved() {
let root = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.join("tests/executable_knowledge/baseline/02-extract");
let resp = mlsp(
"view.reference_resolve",
serde_json::json!({
"project": root.to_string_lossy(),
"project_id": root.to_string_lossy(),
"document_id": "main.mq.md",
"artifact_id": "does-not-exist-xyz"
}),
);
assert_eq!(resp["ok"], true, "{resp}");
assert_eq!(resp["result"]["resolution"], "unresolved");
}
#[test]
fn m04_generation_mismatch_version_unavailable() {
let root = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.join("tests/executable_knowledge/baseline/02-extract");
let resp = mlsp(
"view.reference_resolve",
serde_json::json!({
"project": root.to_string_lossy(),
"project_id": root.to_string_lossy(),
"document_id": "main.mq.md",
"generation_id": "not-a-real-generation",
"artifact_id": "商品小计"
}),
);
assert_eq!(resp["ok"], true, "{resp}");
assert_eq!(resp["result"]["resolution"], "version_unavailable");
}
#[test]
fn m04_source_revision_mismatch_stale() {
let root = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.join("tests/executable_knowledge/baseline/02-extract");
let resp = mlsp(
"view.reference_resolve",
serde_json::json!({
"project": root.to_string_lossy(),
"project_id": root.to_string_lossy(),
"document_id": "main.mq.md",
"source_revision": "sha256:deadbeef",
"artifact_id": "商品小计"
}),
);
assert_eq!(resp["ok"], true, "{resp}");
assert_eq!(resp["result"]["resolution"], "stale");
assert_eq!(
resp["result"]["diagnostics"][0]["code"],
"source_revision_mismatch"
);
}
#[test]
fn m04_artifact_inspect_version_mismatch() {
let root = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.join("tests/executable_knowledge/baseline/02-extract");
let ok = mlsp(
"artifact.inspect",
serde_json::json!({
"project": root.to_string_lossy(),
"artifact_id": "商品小计"
}),
);
assert_eq!(ok["ok"], true, "{ok}");
let bad_rev = mlsp(
"artifact.inspect",
serde_json::json!({
"project": root.to_string_lossy(),
"artifact_id": "商品小计",
"expected_source_revision": "sha256:deadbeef"
}),
);
assert_eq!(bad_rev["ok"], false, "{bad_rev}");
assert_eq!(bad_rev["error"]["code"], "artifact.version_mismatch");
let bad_gen = mlsp(
"artifact.inspect",
serde_json::json!({
"project": root.to_string_lossy(),
"artifact_id": "商品小计",
"expected_generation": "not-a-real-generation"
}),
);
assert_eq!(bad_gen["ok"], false, "{bad_gen}");
assert_eq!(bad_gen["error"]["code"], "artifact.version_mismatch");
}
#[test]
fn m05_extract_segment_byte_locator() {
let root = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
let path = root.join("tests/executable_knowledge/baseline/02-extract/main.mq.md");
let doc = marqdo::document_extract::extract_path(&path);
assert!(doc.status == "ok" || doc.status == "partial", "{:?}", doc.status);
assert!(
doc.segments.iter().any(|s| s.locator.contains(":B")),
"expected byte offset in locator: {:?}",
doc.segments
);
}
#[test]
fn m06_capabilities_lists_adapters_honestly() {
let caps = mlsp("capabilities", serde_json::json!({}));
let adapters = caps["result"]["adapters"].as_array().unwrap();
let native = adapters
.iter()
.find(|a| a["id"] == "anthropic-native")
.unwrap();
assert_eq!(native["available"], false);
}
#[test]
fn m01_run_context_spawn_child_inherits_selection() {
let parent = marqdo::workbench::RunContext::from_value(&serde_json::json!({
"run_id": "run-parent",
"turn_id": "turn-1",
"workspace_scope": "ws-a",
"selection_context": {
"selection_id": "sel-1",
"upstream_model_id": "model-a",
"base_url": "http://127.0.0.1:9"
},
"cancellation_token": "/tmp/mq-cancel-test"
}))
.unwrap();
let child = parent.spawn_child("run-child");
assert_eq!(child.parent_run_id.as_deref(), Some("run-parent"));
assert_eq!(child.selection_context["upstream_model_id"], "model-a");
let env = child.selection_env();
assert!(env.iter().any(|(k, v)| k == "OPENAI_MODEL" && v == "model-a"));
assert!(env.iter().any(|(k, _)| k == "MARQDO_CANCEL_TOKEN"));
// Public JSON must not invent api_key.
assert!(child.to_json().get("api_key").is_none());
}
#[test]
fn m01_f01_parallel_selections_do_not_cross() {
let a = marqdo::workbench::RunContext::from_value(&serde_json::json!({
"run_id": "run-a",
"selection_context": {
"upstream_model_id": "model-a",
"base_url": "http://127.0.0.1:7001"
}
}))
.unwrap();
let b = marqdo::workbench::RunContext::from_value(&serde_json::json!({
"run_id": "run-b",
"selection_context": {
"upstream_model_id": "model-b",
"base_url": "http://127.0.0.1:7002"
}
}))
.unwrap();
let ea = a.selection_env();
let eb = b.selection_env();
let model_a = ea.iter().find(|(k, _)| k == "OPENAI_MODEL").map(|(_, v)| v.as_str());
let model_b = eb.iter().find(|(k, _)| k == "OPENAI_MODEL").map(|(_, v)| v.as_str());
let base_a = ea.iter().find(|(k, _)| k == "OPENAI_BASE_URL").map(|(_, v)| v.as_str());
let base_b = eb.iter().find(|(k, _)| k == "OPENAI_BASE_URL").map(|(_, v)| v.as_str());
assert_eq!(model_a, Some("model-a"));
assert_eq!(model_b, Some("model-b"));
assert_ne!(base_a, base_b);
assert_ne!(a.run_id, b.run_id);
}
#[test]
fn m02_usage_revision_and_cancel_token() {
let u1 = marqdo::workbench::model_call_usage_from_provider(
"c1",
"a1",
"r1",
&serde_json::json!({"selection_id": "s"}),
&serde_json::json!({"prompt_tokens": 10, "completion_tokens": 2, "total_tokens": 12}),
"succeeded",
);
assert_eq!(u1["usage_state"], "final");
assert_eq!(u1["input_tokens"], 10);
assert_eq!(u1["revision"], 1);
let dir = std::env::temp_dir().join(format!("mq-cancel-{}", std::process::id()));
let _ = std::fs::remove_file(&dir);
std::fs::write(&dir, "cancelled").unwrap();
assert!(marqdo::workbench::cancel_requested(Some(dir.to_str().unwrap())));
let _ = std::fs::remove_file(&dir);
assert!(!marqdo::workbench::cancel_requested(Some("/no/such/cancel/token")));
}
#[test]
fn m02_f05_usage_revision_replaces_same_attempt_not_sum() {
let sel = serde_json::json!({"selection_id": "s"});
let partial = marqdo::workbench::model_call_usage_from_provider_rev(
"c1",
"a1",
"r1",
&sel,
&serde_json::json!({"prompt_tokens": 10, "completion_tokens": 1, "total_tokens": 11}),
"started",
1,
);
let final_u = marqdo::workbench::model_call_usage_from_provider_rev(
"c1",
"a1",
"r1",
&sel,
&serde_json::json!({"prompt_tokens": 10, "completion_tokens": 5, "total_tokens": 15}),
"succeeded",
2,
);
let won = marqdo::workbench::replace_usage_if_newer(&partial, &final_u);
assert_eq!(won["revision"], 2);
assert_eq!(won["total_tokens"], 15);
// Older revision must not overwrite.
let kept = marqdo::workbench::replace_usage_if_newer(&final_u, &partial);
assert_eq!(kept["revision"], 2);
assert_eq!(kept["total_tokens"], 15);
// New attempt is a distinct identity (caller must not merge).
let retry = marqdo::workbench::model_call_usage_from_provider_rev(
"c1",
"a2",
"r1",
&sel,
&serde_json::json!({"prompt_tokens": 3, "completion_tokens": 1, "total_tokens": 4}),
"succeeded",
1,
);
assert_ne!(retry["attempt_id"], final_u["attempt_id"]);
}
#[test]
fn m02_f07_cancel_does_not_undo_external_write() {
let marker = std::env::temp_dir().join(format!("mq-f07-{}", std::process::id()));
std::fs::write(&marker, "already-written").unwrap();
let tok = std::env::temp_dir().join(format!("mq-f07-cancel-{}", std::process::id()));
std::fs::write(&tok, "cancelled").unwrap();
assert!(marqdo::workbench::cancel_requested(Some(tok.to_str().unwrap())));
// Cancel must not claim or perform undo of prior external writes.
assert_eq!(
std::fs::read_to_string(&marker).unwrap(),
"already-written"
);
let _ = std::fs::remove_file(&marker);
let _ = std::fs::remove_file(&tok);
}
#[test]
fn m02_event_sink_emits_runtime_event() {
let path = std::env::temp_dir().join(format!("mq-evt-{}.ndjson", std::process::id()));
let _ = std::fs::remove_file(&path);
marqdo::workbench::bind_event_sink(&path);
let ev = marqdo::workbench::emit_message_delta("run-evt", "hello");
assert_eq!(ev["schema"], "RuntimeEventV1");
assert_eq!(ev["type"], "message.delta");
marqdo::workbench::clear_event_sink();
let body = std::fs::read_to_string(&path).unwrap_or_default();
assert!(body.contains("message.delta"), "{body}");
let _ = std::fs::remove_file(&path);
}
#[test]
fn m03_view_document_path_escape_rejected() {
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": "../Cargo.toml",
"mode": "read"
}),
);
assert_eq!(resp["ok"], false, "{resp}");
let code = resp["error"]["code"].as_str().unwrap_or("");
assert!(
code.contains("path") || code.contains("not_found") || code.contains("escape"),
"{resp}"
);
}
#[test]
fn m05_project_cache_isolation_f14() {
marqdo::workbench::reset_cache_for_tests();
let a = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.join("tests/executable_knowledge/baseline/02-extract");
let b = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.join("tests/executable_knowledge/baseline/01-inline");
assert!(
marqdo::workbench::analysis_cache::cache_keys_isolated(&a, &b),
"distinct project roots must not share cache keys"
);
let _ = marqdo::workbench::analysis_cache::note_analysis(&a);
let hit = marqdo::workbench::analysis_cache::note_analysis(&a);
assert!(hit, "second analysis of same snapshot should hit cache");
let _ = marqdo::workbench::analysis_cache::note_analysis(&b);
}
#[test]
fn m05_f14_concurrent_100_same_snapshot() {
use std::sync::{Arc, Barrier};
use std::thread;
marqdo::workbench::reset_cache_for_tests();
let root = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.join("tests/executable_knowledge/baseline/02-extract");
let root_s = root.to_string_lossy().to_string();
let n = 100usize;
let barrier = Arc::new(Barrier::new(n));
let mut handles = Vec::with_capacity(n);
for _ in 0..n {
let barrier = Arc::clone(&barrier);
let root_s = root_s.clone();
handles.push(thread::spawn(move || {
barrier.wait();
let resp = mlsp(
"view.document",
serde_json::json!({
"project": root_s,
"document": "main.mq.md",
"mode": "read",
"include": ["fragment"]
}),
);
assert_eq!(resp["ok"], true, "{resp}");
resp["result"]["document"]["source_revision"]
.as_str()
.unwrap_or("")
.to_string()
}));
}
let mut revs = Vec::new();
for h in handles {
revs.push(h.join().expect("thread"));
}
assert!(revs.iter().all(|r| r == &revs[0]), "all reads same revision");
assert!(revs[0].starts_with("sha256:"));
let (hits, misses, merges) = marqdo::workbench::cache_stats();
// At least one miss (leader) and either merges (coalesce) or subsequent hits.
assert!(misses >= 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("<script"));
}
#[test]
fn m03_f09_outline_nodes_chinese_and_static_a11y_subset() {
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", "refs"]
}),
);
assert_eq!(resp["ok"], true, "{resp}");
let doc = &resp["result"];
let outline = doc["outline"].as_array().unwrap();
assert!(outline.iter().any(|o| o["kind"] == "heading"));
let nodes = doc["nodes"].as_array().unwrap();
assert!(!nodes.is_empty(), "expected semantic nodes");
// Chinese / CJK labels should round-trip in outline or nodes when present in source.
let blob = format!("{outline:?}{nodes:?}");
assert!(
blob.chars().any(|c| c >= '\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("<article") || fragment.contains("mq-document"));
assert!(!fragment.contains("<script"));
assert!(!fragment.contains("javascript:"));
}
#[test]
fn m04_f11_ambiguous_same_name() {
let root = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.join("tests/executable_knowledge/baseline/08-same-name");
assert!(root.is_dir(), "missing 08-same-name fixture");
// a.mq.md and b.mq.md both define 商品小计 — omit document_id so both stay in scope.
let resp = mlsp(
"view.reference_resolve",
serde_json::json!({
"project": root.to_string_lossy(),
"project_id": root.to_string_lossy(),
"artifact_id": "商品小计"
}),
);
assert_eq!(resp["ok"], true, "{resp}");
assert_eq!(resp["result"]["resolution"], "ambiguous", "{resp}");
let cands = resp["result"]["candidates"].as_array().unwrap();
assert!(cands.len() >= 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::<usize>().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"));
}