//! 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);
}
/// M-A0: freeze Agent reliability protocol fixtures; capability bits stay 0.
#[test]
fn ma0_agent_reliability_protocol_freeze() {
let err = fixture("agent_error_v1.json");
assert_required(&err, &schema("AgentErrorV1.schema.json"), "agent_error");
assert_eq!(err["schema"], "AgentErrorV1");
assert_eq!(err["schema_version"], 1);
let degrade = fixture("agent_error_v1_unknown_version.json");
assert_eq!(degrade["schema"], "AgentErrorV1");
assert_eq!(degrade["schema_version"], 99);
assert_eq!(degrade["future_field"], true);
let tool = fixture("tool_spec_v1.json");
assert_required(&tool, &schema("ToolSpecV1.schema.json"), "tool_spec");
assert_required(
&fixture("tool_call_v1.json"),
&schema("ToolCallV1.schema.json"),
"tool_call",
);
assert_required(
&fixture("tool_result_v1.json"),
&schema("ToolResultV1.schema.json"),
"tool_result",
);
let ckpt = fixture("checkpoint_v2.json");
assert_required(&ckpt, &schema("CheckpointV2.schema.json"), "checkpoint");
assert_eq!(ckpt["schema_version"], 2);
let legacy = fixture("checkpoint_legacy_resume.json");
assert!(legacy.get("schema").is_none());
assert!(legacy.get("effect_class").is_none());
assert_eq!(legacy["id"], "legacy_resume_01");
let ledger = fixture("effect_ledger_v1.json");
assert_required(
&ledger,
&schema("EffectLedgerRecordV1.schema.json"),
"effect_ledger",
);
assert_eq!(ledger["schema"], "EffectLedgerRecordV1");
assert_eq!(ledger["state"], "prepared");
assert_eq!(ledger["effect_class"], "write");
let out_ok = fixture("agent_output_v1_succeeded.json");
assert_required(&out_ok, &schema("AgentOutputV1.schema.json"), "agent_output_ok");
assert_eq!(out_ok["status"], "succeeded");
let out_fail = fixture("agent_output_v1_failed.json");
assert_required(
&out_fail,
&schema("AgentOutputV1.schema.json"),
"agent_output_fail",
);
assert_eq!(out_fail["status"], "failed");
let pack = fixture("context_pack_v2.json");
assert_required(&pack, &schema("ContextPackV2.schema.json"), "context_pack");
assert_eq!(pack["schema_version"], 2);
let item = &pack["items"][0];
for key in [
"origin",
"trust",
"resource_ref",
"revision",
"token_estimate",
"priority",
] {
assert!(item.get(key).is_some(), "context item missing {key}");
}
assert_required(
&fixture("resource_ref_v1.json"),
&schema("ResourceRefV1.schema.json"),
"resource_ref",
);
let view = fixture("resource_view_v1.json");
assert_required(&view, &schema("ResourceViewV1.schema.json"), "resource_view");
assert_eq!(view["no_exec"], true);
let tev = fixture("runtime_event_tool_failed.json");
assert_eq!(tev["schema"], "RuntimeEventV2");
assert_eq!(tev["type"], "tool.failed");
assert_eq!(tev["payload"]["schema"], "AgentErrorV1");
let caps = mlsp("capabilities", serde_json::json!({}));
assert_eq!(caps["ok"], true, "{caps}");
let features = &caps["result"]["features"];
// M-A1–M-A4: agent reliability emitters are live.
assert_eq!(features["agent.error_v1"], 1);
assert_eq!(features["agent.checkpoint_v2"], 1);
assert_eq!(features["agent.tool_schema_v1"], 1);
assert_eq!(features["agent.output_channels_v1"], 1);
assert_eq!(features["agent.context_pack_v2"], 1);
assert_eq!(features["resource.view_v1"], 1);
let formats = caps["result"]["extract_formats"]
.as_array()
.expect("extract_formats");
let pdf = formats
.iter()
.find(|f| f["format"] == "pdf")
.expect("pdf row");
assert_eq!(pdf["available"], false);
let json_fmt = formats
.iter()
.find(|f| f["format"] == "json")
.expect("json row");
assert_eq!(json_fmt["available"], true);
let csv_fmt = formats
.iter()
.find(|f| f["format"] == "csv")
.expect("csv row");
assert_eq!(csv_fmt["available"], true);
// Live contracts list still excludes unimplemented agent schemas.
let contracts = caps["result"]["contracts"].as_array().unwrap();
assert!(!contracts.iter().any(|c| c.as_str() == Some("AgentErrorV1")));
let down = mlsp(
"capabilities",
serde_json::json!({
"force_unloaded": true,
"force_stream_off": true,
"force_cancel_off": true
}),
);
assert_eq!(down["result"]["features"]["agent.error_v1"], 1);
assert_eq!(down["result"]["features"]["agent.checkpoint_v2"], 1);
assert_eq!(down["result"]["features"]["agent.tool_schema_v1"], 1);
assert_eq!(down["result"]["features"]["agent.output_channels_v1"], 1);
assert_eq!(down["result"]["features"]["agent.context_pack_v2"], 1);
assert_eq!(down["result"]["features"]["resource.view_v1"], 1);
}
#[test]
fn ma3_resource_view_static_no_exec() {
use std::io::Write;
use std::time::{SystemTime, UNIX_EPOCH};
let nanos = SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap()
.as_nanos();
let dir = std::env::temp_dir().join(format!("marqdo-ma3-rv-{nanos}"));
std::fs::create_dir_all(&dir).unwrap();
let md = dir.join("readme.md");
{
let mut f = std::fs::File::create(&md).unwrap();
writeln!(f, "# Hello\n\n").unwrap();
}
let resp = mlsp(
"resource.view",
serde_json::json!({
"workspace_root": dir.to_string_lossy(),
"path": "readme.md",
"mode": "read"
}),
);
assert_eq!(resp["ok"], true, "{resp}");
let view = &resp["result"];
assert_required(view, &schema("ResourceViewV1.schema.json"), "resource_view_live");
assert_eq!(view["no_exec"], true);
assert_eq!(view["schema"], "ResourceViewV1");
let frag = view["render"]["fragment"].as_str().unwrap();
assert!(frag.contains("Hello"));
assert!(frag.contains("<script>") || !frag.contains("