@tekyzinc/gsd-t 4.6.11 → 4.7.11

package/templates/workflows/gsd-t-quick.workflow.js

@@ -2,16 +2,30 @@
 //
 // Runtime: Anthropic native Workflow tool only.
 // Quick — small one-shot task with contract awareness.
-// preflight + brief + agent(task) + verify-gate (light)
+// preflight + brief + agent(task) + research (M89 Stated-Claims) + verify-gate (light)
+//
+// M89: Stated-Claims→classify→research wiring (auto-research-contract v1.2.0 §6.5/§1/§2/§3/§4/§7).
+// The task agent embeds the Stated-Claims snippet (§6.5) and tags load-bearing claims KNOWN|GUESSED.
+// After the Execute phase, the Research phase iterates GUESSED entries through
+// bin/gsd-t-research-gate.cjs: external → write §7 marker (status=uncited) → research agent
+// (model:"fable") → cite → flip marker (status=cited). Internal → grep/Read; grep-empty →
+// escalate to external (§5.1). Idempotent per §4.1 (exact normalized claim-key match only).
+//
+// M90 §2 D4-T4: Architectural-trigger wiring (protocol-class path, R-ARCH-2 "everywhere" feed).
+// After the Research phase, compute the extend-existing-code signal from result.filesEdited:
+// any file that already existed on disk → extend-class → fire the arch trigger (R-ARCH-2).
+// NAMED PRODUCER: signal comes from result.filesEdited + on-disk existence check, never seeded.
+// Contract: unproven-assumption-doctrine-contract.md §2 (R-ARCH-2, protocol-class path).
 //
 // args: { task, projectDir?, model? }
 
 export const meta = {
   name: "gsd-t-quick",
-  description: "Fast single-task execution with brief, preflight, and verify-gate",
+  description: "Fast single-task execution with brief, preflight, Stated-Claims research, and verify-gate",
   phases: [
     { title: "Preflight", detail: "preflight + brief" },
     { title: "Execute",   detail: "single-agent task" },
+    { title: "Research",  detail: "classify GUESSED claims + cite external (M89 §6.5/§1/§2/§7)" },
     { title: "Verify",    detail: "verify-gate" },
   ],
 };
@@ -81,9 +95,77 @@ const QUICK_SCHEMA = {
     status:      { type: "string", enum: ["complete", "partial", "blocked", "failed"] },
     filesEdited: { type: "array", items: { type: "string" } },
     summary:     { type: "string" },
+    // M89 §6.5 — Stated Claims: raw [GUESSED:*] lines emitted by the task agent
+    statedClaims: { type: "array", items: { type: "string" } },
+    // Primary artifact path for §7 marker writes (optional)
+    artifactPath: { type: "string" },
   },
 };
 
+// M89 §7 — normalize claim-key (§4.1 exact-match key). Cycle-2 finding #1: collapse
+// EVERY non-word run to a space so the key is marker-syntax-safe; byte-identical across
+// all 4 workflows (m89-normalize-claim-key-parity).
+function normalizeClaimKey(claim) {
+  return claim.toLowerCase().replace(/[^\w]+/g, " ").trim();
+}
+function uncitedMarker(key) { return `<!-- auto-research-claim: class=external key=${key} status=uncited -->`; }
+function citedMarker(key)   { return `<!-- auto-research-claim: class=external key=${key} status=cited -->`; }
+
+// M89 §1 — classify via D1 classifier (bin/gsd-t-research-gate.cjs)
+async function classifyClaim(projectDir, claimText, phaseName) {
+  return runCli(projectDir, "research-gate", ["classify", claimText, "--json"], "gsd-t-research-gate.cjs", "classify-claim", true, phaseName);
+}
+
+// M89 §4.1 — exact key match idempotency check
+function isAlreadyCited(artifactText, claimKey) {
+  return artifactText.includes(`auto-research-claim: class=external key=${claimKey} status=cited`);
+}
+
+// M89 §5.1 — grep repo for internal claim resolution
+async function grepForClaim(projectDir, claimText, phaseName) {
+  const escaped = claimText.replace(/'/g, "'\\''").slice(0, 200);
+  const prompt = [
+    `Decide whether THIS repo's own code/contracts/tests CONFIRM the SPECIFIC claim — not merely`,
+    `share vocabulary with it (Red Team MEDIUM). Project: \`${projectDir}\`. Claim: "${escaped}"`,
+    `Run: \`grep -r --include="*.js" --include="*.ts" --include="*.md" --include="*.cjs" -l "${escaped.slice(0, 60)}" "${projectDir}" 2>/dev/null | head -5\``,
+    `Then Read the candidates and judge: set found=true ONLY IF the repo content actually CONFIRMS`,
+    `the value/shape/behavior the claim asserts. Coincidental keyword overlap = found=false.`,
+    `If the claim is about an EXTERNAL system's behavior (3rd-party API, library, browser, protocol),`,
+    `grep CANNOT confirm it → found=false so it escalates to web research.`,
+    `Return JSON: { "found": <boolean>, "matches": ["<file>", ...] }. No other work.`,
+  ].join("\n");
+  const schema = { type: "object", required: ["found"], additionalProperties: true, properties: { found: { type: "boolean" }, matches: { type: "array", items: { type: "string" } } } };
+  const r = await agent(prompt, { label: "grep-internal-claim", model: "haiku", schema, phase: phaseName })
+    .catch(() => ({ found: false, matches: [] }));
+  return r || { found: false, matches: [] };
+}
+
+// M89 §1.1 — AMBIGUOUS → LLM JUDGE (bare model:"fable"). internal/external/uncertain;
+// uncertain → research (never guess-internal). On error → "uncertain" (fail toward research).
+const CLASSIFY_JUDGE_SCHEMA = {
+  type: "object", required: ["verdict"], additionalProperties: true,
+  properties: { verdict: { type: "string", enum: ["internal", "external", "uncertain"] }, reason: { type: "string" } },
+};
+async function judgeAmbiguous(claimText, phaseName) {
+  const prompt = [
+    `You are the M89 ambiguous-claim JUDGE (auto-research-contract §1.1). The mechanical string-fact`,
+    `classifier could not decide this GUESSED claim. Decide in natural language. Claim: "${claimText}"`,
+    `- "internal"  = about THIS repo's OWN code/contracts/tests — grep/Read can confirm.`,
+    `- "external"  = asserts an OUTSIDE system's behavior/shape/limit — needs web research.`,
+    `- "uncertain" = you cannot CONFIDENTLY place it internal — per M89 doctrine it is RESEARCHED, never guessed.`,
+    `Return JSON: { "verdict": "internal"|"external"|"uncertain", "reason": "<one line>" }. No file/web work in THIS step.`,
+  ].join("\n");
+  const r = await agent(prompt, { label: "classify-judge", model: "fable", schema: CLASSIFY_JUDGE_SCHEMA, phase: phaseName })
+    .catch((e) => ({ verdict: "uncertain", reason: `judge error: ${e && e.message}` }));
+  return (r && r.verdict) || "uncertain";
+}
+
+// M89 §2 — research result schema
+const RESEARCH_RESULT_SCHEMA = {
+  type: "object", required: ["ok", "gapKey"], additionalProperties: true,
+  properties: { ok: { type: "boolean" }, gapKey: { type: "string" }, citedBlock: { type: "string" }, sourceUrls: { type: "array", items: { type: "string" } }, fetchDates: { type: "array", items: { type: "string" } }, reason: { type: "string" } },
+};
+
 if (!task) {
   log("quick: args.task required");
   return { status: "failed", reason: "no-task" };
@@ -107,6 +189,13 @@ const result = await agent(
     `- Update relevant docs in the same commit`,
     ``,
     `Commit with prefix "m61(quick)". Return JSON per the schema.`,
+    ``,
+    `**M89 STATED CLAIMS — REQUIRED (auto-research-contract §6.5):**`,
+    `Read \`${projectDir}/templates/prompts/stated-claims-snippet.md\` for the DETECT protocol.`,
+    `Before returning, emit a \`## Stated Claims\` section tagging every load-bearing claim`,
+    `[KNOWN] or [GUESSED:assumed|unknown|stale]. In your StructuredOutput JSON, include a`,
+    `"statedClaims" array: one entry per [GUESSED:*] line (full bullet text). Include`,
+    `"artifactPath" if you wrote a primary output file (for §7 marker writes).`,
   ].join("\n"),
   { label: "quick", phase: "Execute", schema: QUICK_SCHEMA, model }
 ).catch((e) => ({ status: "failed", filesEdited: [], summary: `agent error: ${e && e.message}` }));
@@ -115,10 +204,191 @@ if (result.status === "failed" || result.status === "blocked") {
   return { status: result.status, result };
 }
 
+// ── M89 Research Phase — Stated-Claims→classify→cite (§6.5/§1/§2/§3/§4/§7) ──
+phase("Research");
+const guessedClaims = [];
+if (Array.isArray(result.statedClaims)) {
+  for (const claimLine of result.statedClaims) {
+    const m = claimLine.match(/^\[GUESSED:[^\]]+\]\s*(.+)$/);
+    if (m) guessedClaims.push({ claimText: m[1].trim(), artifactPath: result.artifactPath || null });
+  }
+}
+
+if (guessedClaims.length === 0) {
+  log("Research: no GUESSED claims — skipping");
+} else {
+  log(`Research: ${guessedClaims.length} GUESSED claim(s) to classify`);
+  const artifactCache = {};
+  async function readArtifact(p) {
+    if (!p) return "";
+    if (artifactCache[p] !== undefined) return artifactCache[p];
+    const r = await agent(`Read \`${p}\` and return JSON: { "text": "<file content>" }. If missing: { "text": "" }.`,
+      { label: "read-artifact", model: "haiku", schema: { type: "object", required: ["text"], properties: { text: { type: "string" } }, additionalProperties: false }, phase: "Research" })
+      .catch(() => ({ text: "" }));
+    const t = (r && r.text) || "";
+    artifactCache[p] = t;
+    return t;
+  }
+
+  for (const { claimText, artifactPath } of guessedClaims) {
+    const claimKey = normalizeClaimKey(claimText);
+
+    // FAIL-CLOSED (Red Team HIGH): artifactPath is self-reported + optional. An EXTERNAL (or
+    // ambiguous→escalated-external) guess MUST get its §7 uncited marker written SOMEWHERE so the
+    // §7 ENFORCE gate has something to fail on. Use a DETERMINISTIC FALLBACK ARTIFACT when none.
+    const claimSlug = claimKey.replace(/\s+/g, "-").slice(0, 80) || "claim";
+    const externalArtifact = artifactPath || `${projectDir}/.gsd-t/research/quick-${claimSlug}.md`;
+
+    // §4.1 idempotency — read the path actually WRITTEN (externalArtifact = real OR fallback)
+    // so a re-run does not re-research a claim already cited in the fallback (Red Team MEDIUM).
+    const at = await readArtifact(externalArtifact);
+    if (isAlreadyCited(at, claimKey)) {
+      log(`Research: skip "${claimKey.slice(0, 50)}" — already cited`);
+      continue;
+    }
+
+    const cls = await classifyClaim(projectDir, claimText, "Research");
+    const envelope = cls.envelope;
+    if (!envelope || !envelope.ok) {
+      log(`Research: classify error — ${cls.stderr || JSON.stringify(envelope)}`);
+      continue;
+    }
+
+    // External-claim handler closure (reused by the ambiguous→judge path).
+    const doExternal = async () => {
+      log(`Research: external → marker + research(fable) for "${claimKey.slice(0, 50)}"${artifactPath ? "" : " (FALLBACK artifact — no reported path)"}`);
+      // §7 write uncited marker to the real OR fallback artifact — ALWAYS (fail-CLOSED)
+      {
+        const m = uncitedMarker(claimKey);
+        const sp = externalArtifact.replace(/'/g, "'\\''");
+        await agent(
+          `Ensure the parent dir exists, then append line \`${m}\` to \`${externalArtifact}\` if not already present. Use Bash: \`mkdir -p "$(dirname '${sp}')" && { grep -qF '${m.replace(/'/g, "'\\''")}' '${sp}' 2>/dev/null || echo '${m.replace(/'/g, "'\\''")}' >> '${sp}'; }\`. Return JSON: { "done": true }.`,
+          { label: "write-uncited-marker", model: "haiku", schema: { type: "object", required: ["done"], properties: { done: { type: "boolean" } }, additionalProperties: true }, phase: "Research" }
+        ).catch(() => {});
+        delete artifactCache[externalArtifact];
+      }
+      // §2 research agent — bare literal model: "fable"
+      const rr = await agent(
+        [
+          `Read \`${projectDir}/templates/prompts/research-subagent.md\` for the research protocol.`,
+          `Verify this external guessed claim: "${claimText}"`,
+          `Gap-key: "${claimKey}"`,
+          `Emit ## Verified Facts (auto-research) block with source URL + fetch date. Append the trailer \`key: ${claimKey}\` on every fact line so the §7 gate matches by claim-key (Red Team MEDIUM #2). Return StructuredOutput JSON.`,
+        ].join("\n"),
+        { label: "research", model: "fable", schema: RESEARCH_RESULT_SCHEMA, phase: "Research" }
+      ).catch((e) => ({ ok: false, gapKey: claimKey, reason: String(e && e.message) }));
+
+      if (rr && rr.ok && rr.citedBlock) {
+        // §7 flip to cited + write cited block (real OR fallback artifact)
+        const um = uncitedMarker(claimKey);
+        const cm = citedMarker(claimKey);
+        await agent(
+          `Ensure the parent dir of \`${externalArtifact}\` exists (Bash: \`mkdir -p "$(dirname '${externalArtifact.replace(/'/g, "'\\''")}')"\`). Then Edit \`${externalArtifact}\`: replace the line \`${um}\` with \`${cm}\`, then append the following block if not already present:\n\`\`\`\n${rr.citedBlock}\n\`\`\`\nUse Read then Edit/Write tools. Return JSON: { "done": true, "action": "cited" }.`,
+          { label: "flip-marker-cite", model: "haiku", schema: { type: "object", required: ["done"], properties: { done: { type: "boolean" }, action: { type: "string" } }, additionalProperties: true }, phase: "Research" }
+        ).catch(() => {});
+        log(`Research: cited "${claimKey.slice(0, 50)}"`);
+      } else {
+        log(`Research: research failed for "${claimKey.slice(0, 50)}" — marker stays uncited`);
+      }
+    };
+
+    // Internal-claim handler closure (grep A3; grep-empty → escalate §5.1).
+    const doInternal = async () => {
+      log(`Research: internal → grep for "${claimText.slice(0, 50)}"`);
+      const gr = await grepForClaim(projectDir, claimText, "Research");
+      if (gr.found) {
+        log(`Research: internal resolved by grep — no research needed`);
+      } else {
+        // §5.1 escalation: grep-empty → escalate to external. Reuse doExternal() (same
+        // marker→research→cite→flip path, incl. the key: trailer) instead of duplicating it.
+        log(`Research: grep empty — escalating to external (§5.1): "${claimText.slice(0, 50)}"${artifactPath ? "" : " (FALLBACK artifact)"}`);
+        await doExternal();
+      }
+    };
+
+    // ── Dispatch by the 3-result classifier verdict (v1.3.0) ──────────────────
+    if (envelope.class === "external") {
+      await doExternal();
+    } else if (envelope.class === "internal") {
+      await doInternal();
+    } else {
+      // class:AMBIGUOUS — no string fact; LLM judge decides. internal→grep; external→research;
+      // UNCERTAIN→research (uncertain = verify, never guess-internal).
+      log(`Research: ambiguous → LLM judge for "${claimText.slice(0, 50)}" (when unsure, research)`);
+      const verdict = await judgeAmbiguous(claimText, "Research");
+      log(`Research: ambiguous "${claimKey.slice(0, 50)}" → judge: ${verdict}`);
+      if (verdict === "internal") {
+        await doInternal();
+      } else {
+        if (verdict === "uncertain") log(`Research: judge UNCERTAIN → "${claimKey.slice(0, 50)}" treated external → research (no silent guess)`);
+        await doExternal();
+      }
+    }
+  }
+}
+
+// ── M90 §2 D4-T4 — Arch-Trigger (protocol-class, extend-existing-code signal) ──
+// Compute the extend-existing-code signal from result.filesEdited: files that already
+// existed on disk before this quick run → extend-class → fire the arch trigger (R-ARCH-2).
+// PRODUCER: signal is computed from real runtime inputs (filesEdited vs. on-disk check).
+// Non-blocking: best-effort; don't halt quick on trigger failure.
+let quickArchTriggerResult = null;
+if (Array.isArray(result.filesEdited) && result.filesEdited.length > 0) {
+  const filesToCheck = result.filesEdited.slice(0, 10);
+  const checkResult = await agent(
+    [
+      `For the project at \`${projectDir}\`, check which of these files existed on disk BEFORE the current quick run.`,
+      `Files to check: ${JSON.stringify(filesToCheck)}`,
+      `For each file, run: \`test -f '${projectDir}/<file>' && echo EXISTS || echo ABSENT\` (substitute the actual path).`,
+      `Return JSON: { "existingFiles": ["<file>", ...] } — list ONLY files that exist (exit 0).`,
+      `Do NOT modify any files. Read-only existence check.`,
+    ].join("\n"),
+    {
+      label: "arch-trigger-exist-check:quick",
+      phase: "Research",
+      model: "haiku",
+      schema: {
+        type: "object", required: ["existingFiles"],
+        properties: { existingFiles: { type: "array", items: { type: "string" } } },
+        additionalProperties: true,
+      },
+    }
+  ).catch(() => ({ existingFiles: [] }));
+
+  const existingFiles = Array.isArray(checkResult && checkResult.existingFiles) ? checkResult.existingFiles : [];
+  if (existingFiles.length > 0) {
+    const triggerInput = JSON.stringify({
+      type: "extend-existing-code",
+      context: `quick-task edited existing files: ${existingFiles.slice(0, 3).join(", ")}`,
+      basis: `Quick task edited existing file(s): ${existingFiles.slice(0, 3).join(", ")}`,
+    });
+    const triggerResult = await runCli(
+      projectDir,
+      "architectural-trigger",
+      ["trigger", triggerInput],
+      "gsd-t-architectural-trigger.cjs",
+      "arch-trigger:quick",
+      true,
+      "Research"
+    );
+    const triggerEnv = triggerResult.envelope || {};
+    log(`M90 arch-trigger quick: fired=${triggerEnv.fired} reason=${triggerEnv.reason || "?"} provenByAdversaryOnly=${triggerEnv.provenByAdversaryOnly || false}`);
+    quickArchTriggerResult = {
+      existingFiles,
+      fired: triggerEnv.fired || false,
+      reason: triggerEnv.reason || null,
+      provenByAdversaryOnly: triggerEnv.provenByAdversaryOnly || false,
+      stopDirective: triggerEnv.stopDirective || false,
+    };
+  }
+}
+
 phase("Verify");
 const vg = await runVerifyGate(projectDir);
 return {
   status: vg.ok ? "complete" : "verify-failed",
   result,
   verifyGate: vg.envelope,
+  // M90 §2: arch-trigger result (surfaced for verify gate R-FAIL-2 check)
+  archTriggerResult: quickArchTriggerResult,
 };

package/templates/workflows/gsd-t-verify.workflow.js

@@ -6,9 +6,22 @@
 // Canonical verify-phase Workflow. Replaces the gsd-t-verify command shell with
 // a deterministic pipeline:
 //   preflight → brief → verify-gate (deterministic, hard-fail) →
+//   M89 §7 ENFORCE gate (auto-research-claim marker scan) →
 //   parallel( /code-review ultra cooperative, Red Team adversarial, QA mechanics ) →
 //   synthesis ( merge findings WITHOUT collapsing categories — see orthogonal-validation-contract.md )
 //
+// M89 §7 ENFORCE gate: an artifact carrying ANY <!-- auto-research-claim: ... status=uncited -->
+// marker FAILs (an external guessed claim proceeded without a cited fact). All markers
+// status=cited with matching ## Verified Facts (auto-research) entries → PASS.
+// Contract: auto-research-contract.md §7 + §5 (A4).
+//
+// M90 §4 Fail-Closed gates (FAIL-blocking, after M89 §7 ENFORCE gate):
+//   R-FAIL-2: arch-trigger proven-by-adversary-only flag unresolved → VERIFY-FAILED.
+//   R-FAIL-3: loop-ledger haltedButNoReExamination state → VERIFY-FAILED.
+//   Both are DOCUMENTED no-op-PASSes when the producing mechanism is de-scoped (R1-EXIT),
+//   distinguishable from wired-but-broken vacuous passes. Never halt on a de-scoped mechanism.
+// Contract: unproven-assumption-doctrine-contract.md §4 (R-FAIL-2, R-FAIL-3).
+//
 // args shape:
 //   {
 //     milestone: "M61",
@@ -19,10 +32,11 @@
 export const meta = {
   name: "gsd-t-verify",
   description:
-    "GSD-T verify phase: preflight → brief → verify-gate → CI-parity gate (M57) → test-data purge gate (M58) → parallel(code-review-ultra, Red Team, QA) → synthesis",
+    "GSD-T verify phase: preflight → brief → verify-gate → M89 §7 ENFORCE gate → CI-parity gate (M57) → test-data purge gate (M58) → parallel(code-review-ultra, Red Team, QA) → synthesis",
   phases: [
     { title: "Preflight",          detail: "preflight + brief" },
     { title: "Verify-Gate",        detail: "deterministic two-track verify-gate" },
+    { title: "Auto-Research Gate", detail: "M89 §7 ENFORCE: scan for status=uncited markers (A4 — no silent guess)" },
     { title: "CI-Parity",          detail: "M57 build-coverage + ci-parity (FAIL-blocking)" },
     { title: "Test-Data Purge",    detail: "M58 test-data --purge (FAIL-blocking)" },
     { title: "Orthogonal Triad",   detail: "code-review ultra ∥ Red Team ∥ QA" },
@@ -221,6 +235,251 @@ if (!vg.ok) {
 }
 log(`verify-gate green`);
 
+// ─── M89 §7 ENFORCE Gate (FAIL-blocking — A4 no-silent-guess) ─────────────
+// Scans all milestone artifacts for STRUCTURAL auto-research-claim markers and FAILs if:
+//   (a) ANY marker is status=uncited (an external guessed claim was never cited), OR
+//   (b) ANY status=cited marker's file lacks a matching `## Verified Facts (auto-research)`
+//       block with a sourced fact line (a "cited" marker with no backing fact — the
+//       hollow-gate defeat the contract §7/§5 A4 require to FAIL).
+//
+// CRITICAL STRUCTURAL RULE (Red Team #1 + code-review #1):
+//   - A marker counts ONLY if the LINE is a COMPLETE HTML comment
+//     `<!-- auto-research-claim: ... status=uncited|cited -->` (has `auto-research-claim:`
+//     AND `status=...` on the SAME line AND the line is the comment `<!-- ... -->`). A bare
+//     substring match would count the marker TEMPLATE string carried in this repo's own
+//     prose/source (CLAUDE-global.md, this contract, the workflows that EMIT the template)
+//     as live markers → spurious VERIFY-FAILED when verify dogfoods on this repo.
+//   - A status=cited marker is only honored if its file ALSO contains a
+//     `## Verified Facts (auto-research)` heading AND ≥1 sourced fact line (`source:` URL).
+//     A cited marker WITHOUT a matching sourced fact is counted as a violation (named by
+//     its claim-key) — same as an uncited marker. This closes the hollow-gate (A4).
+// Contract: auto-research-contract.md §7 + §5 (A4).
+// M81: no fs — delegate to an agent's Bash (grep) + parse result.
+const AUTO_RESEARCH_GATE_SCHEMA = {
+  type: "object",
+  required: ["pass", "uncitedCount", "citedCount"],
+  additionalProperties: true,
+  properties: {
+    pass: { type: "boolean" },
+    uncitedCount: { type: "integer" },
+    citedCount: { type: "integer" },
+    citedWithoutFactsCount: { type: "integer" },
+    uncitedMarkers: { type: "array", items: { type: "string" } },
+    citedWithoutFactsKeys: { type: "array", items: { type: "string" } },
+    internalOnlyArtifacts: { type: "boolean" },
+    notes: { type: "string" },
+  },
+};
+
+phase("Auto-Research Gate");
+const arGate = await agent(
+  [
+    `You are the M89 §7 ENFORCE gate scanner. Scan ALL milestone artifacts in the project at "${projectDir}" for STRUCTURAL auto-research-claim markers and determine pass/fail per contract §7 + §5 (A4 no-silent-guess).`,
+    ``,
+    `A line is a LIVE MARKER ONLY IF it is a COMPLETE HTML comment of this exact structure (all on ONE line):`,
+    `    <!-- auto-research-claim: class=external key=<some-key> status=uncited -->`,
+    `    <!-- auto-research-claim: class=external key=<some-key> status=cited -->`,
+    `STRUCTURAL TEST (do NOT count a bare substring): the line, trimmed, MUST start with "<!--", MUST end with "-->", MUST contain "auto-research-claim:", MUST contain "status=uncited" or "status=cited", AND its key= value MUST be a CONCRETE normalized key (lowercase words/whitespace, NO angle brackets). Lines that merely MENTION the template in prose or source code (a backtick-quoted example, a string literal that emits the template, a contract illustration) are NOT live markers — they are not a standalone "<!-- ... -->" comment line, OR they carry a PLACEHOLDER key like "key=<claim-key>" / "key=<normalized-claim-key>" / "key=<some-key>" / "key=<key>" (any key= value containing "<" or ">"), OR a placeholder status like "status=uncited|cited" / "status=<status>". SKIP all of those — a real marker's key is the normalizeClaimKey output and never contains angle brackets.`,
+    ``,
+    `Steps:`,
+    `1. Find candidate files: \`grep -rl "auto-research-claim" "${projectDir}" --include="*.md" --include="*.js" --include="*.ts" --include="*.tsx" --include="*.jsx" --include="*.cjs" --include="*.mjs" --include="*.py" 2>/dev/null || echo "no-matches"\``,
+    `   NOTE: worker workflows (execute/quick/debug) write §7 markers into their primary OUTPUT artifact, which may be a code file (.js/.ts/.py/...), not only markdown — the include set MUST cover those or an uncited marker in a code artifact escapes the gate (A4).`,
+    `2. For each candidate file, read the lines containing "auto-research-claim". Apply the STRUCTURAL TEST above to each line; discard non-marker lines (template/prose/source illustrations).`,
+    `3. Among the SURVIVING live markers, classify each as uncited (status=uncited) or cited (status=cited), and record its key= value.`,
+    `4. uncitedCount = number of live status=uncited markers. List up to 10 of their full comment lines in "uncitedMarkers".`,
+    `5. For EACH live status=cited marker (with key=K): verify the SAME FILE contains a "## Verified Facts (auto-research)" heading AND a sourced fact line that BACKS this specific marker. A sourced fact line is a list item ("- ...") containing "source:" followed by a URL.`,
+    `   PER-KEY MATCH (preferred — Red Team MEDIUM #2): if any sourced fact line in the file carries a "key: <value>" trailer, match cited markers to facts BY KEY — the cited marker key=K is backed ONLY by a sourced fact line whose "key:" value equals K (exact normalized-key match). A cited marker whose key has NO sourced fact line with a matching "key:" is HOLLOW even if other facts exist. This prevents one fact covering a DISTINCT claim by mere count.`,
+    `   COUNT FALLBACK: if NO sourced fact line in the file carries a "key:" trailer, fall back to the count check — a cited marker is backed iff the file has at least as many sourced fact lines as it has cited markers.`,
+    `   A cited marker in a file with NO Verified-Facts heading, OR with no backing fact under either rule above, is a HOLLOW cited marker — record its key= in "citedWithoutFactsKeys".`,
+    `   citedCount = number of live status=cited markers. citedWithoutFactsCount = number of hollow cited markers (cited with no matching sourced fact).`,
+    `6. pass = true ONLY IF uncitedCount === 0 AND citedWithoutFactsCount === 0 (every external claim is cited AND every cited marker has a matching sourced Verified-Facts entry). pass = false otherwise.`,
+    `7. If no files are found (step 1 returns no-matches) OR no LIVE markers survive the structural test, pass=true, uncitedCount=0, citedCount=0, citedWithoutFactsCount=0.`,
+    ``,
+    `Return JSON per the schema: { "pass": true|false, "uncitedCount": N, "citedCount": N, "citedWithoutFactsCount": N, "uncitedMarkers": [], "citedWithoutFactsKeys": [], "notes": "..." }`,
+    ``,
+    `Contract: auto-research-contract.md §7 (ENFORCE marker — cited REQUIRES a matching Verified-Facts entry, same claim-key) + §5/A4 (uncited or hollow-cited external guess → verify FAILS).`,
+  ].join("\n"),
+  { label: "auto-research-gate", phase: "Auto-Research Gate", schema: AUTO_RESEARCH_GATE_SCHEMA, model: "haiku" }
+).catch((e) => ({
+  pass: false, uncitedCount: -1, citedCount: 0, citedWithoutFactsCount: -1,
+  notes: `auto-research gate agent error: ${e && e.message} — failing closed (A4)`,
+}));
+
+if (!arGate.pass) {
+  const uncited = arGate.uncitedCount >= 0 ? arGate.uncitedCount : "unknown (agent error)";
+  const hollow = arGate.citedWithoutFactsCount >= 0 ? arGate.citedWithoutFactsCount : "unknown (agent error)";
+  log(`M89 auto-research gate FAIL — ${uncited} uncited + ${hollow} hollow-cited external-claim marker(s) (A4: no silent guess)`);
+  if (arGate.uncitedMarkers && arGate.uncitedMarkers.length > 0) {
+    log(`  uncited markers: ${arGate.uncitedMarkers.slice(0, 5).join(" | ")}`);
+  }
+  if (arGate.citedWithoutFactsKeys && arGate.citedWithoutFactsKeys.length > 0) {
+    log(`  hollow cited (no matching sourced fact) keys: ${arGate.citedWithoutFactsKeys.slice(0, 5).join(" | ")}`);
+  }
+  return {
+    status: "auto-research-gate-failed",
+    overallVerdict: "VERIFY-FAILED",
+    autoResearchGate: arGate,
+    reason: `M89 §7 ENFORCE: ${uncited} uncited + ${hollow} hollow-cited external-claim marker(s) — every cited marker needs a matching sourced Verified-Facts entry; run the phase again to cite them`,
+    verifyGate: vg.envelope,
+  };
+}
+log(`M89 auto-research gate: PASS — ${arGate.citedCount} cited marker(s) all backed by sourced facts, 0 uncited`);
+
+// ─── M90 §4 Fail-Closed Gates (FAIL-blocking) ─────────────────────────────
+// R-FAIL-2: arch-trigger produced a proven-by-adversary-only flag that was never resolved.
+// R-FAIL-3: loop-ledger has a halted-but-no-re-examination state (non-convergence).
+//
+// DOCUMENTED no-op-PASS rules (§4 — de-scoped-DOWN vs. wired-but-broken):
+//   - R-FAIL-2 read is a NO-OP-PASS when the arch-trigger is NOT wired (R1-EXIT de-scoped-DOWN).
+//     Documented as "mechanism absent by design" — distinguishable from a wired-but-broken state.
+//   - R-FAIL-3 read is a NO-OP-PASS when the loop-ledger halt is NOT wired (de-scoped).
+//     Documented as "mechanism absent by design" — distinguishable from a wired-but-broken state.
+//
+// The checks FAIL only when the mechanism IS wired AND emits an unresolved flag.
+// They cleanly PASS (with a recorded de-scoped note) when the mechanism is absent.
+// Contract: unproven-assumption-doctrine-contract.md §4 (R-FAIL-2, R-FAIL-3).
+
+// R-FAIL-2: arch-trigger proven-by-adversary-only premise gate (§4).
+// Three DISTINGUISHABLE states (unproven-assumption-doctrine-contract.md §4 + §2.2):
+//   (a) interfaceOnly PASS — NO live producer of the flag wired this milestone (no workflow sets
+//       spikeFeasible), so the flag can't be raised in real operation. DECLARED (M90 decision A),
+//       not a hidden hollow gate.  → grep the workflows for a live producer to detect this.
+//   (b) deScopedPass — R1 exited to factual-only, trigger not wired at all.
+//   (c) FAIL — a live producer exists AND emitted an unresolved proven-by-adversary-only flag.
+// The gate must NEVER vacuously pass a wired-but-broken check. When backlog #42 wires a live
+// spike-feasibility producer, the grep finds it and the gate becomes (c)-capable.
+const M90_ARCH_TRIGGER_SINK = `${projectDir}/.gsd-t/metrics/arch-trigger-events.jsonl`;
+const m90ArchTriggerGate = await agent(
+  [
+    `You are the M90 §4 R-FAIL-2 gate scanner. Determine which of three states holds and return JSON.`,
+    ``,
+    `Sink file: \`${M90_ARCH_TRIGGER_SINK}\``,
+    ``,
+    `Steps:`,
+    `1. LIVE-PRODUCER CHECK: a real producer PASSES a spike-feasibility decision INTO the trigger,`,
+    `   i.e. a workflow constructs \`responseOpts\` / sets \`spikeFeasible\` as an OBJECT KEY in a call.`,
+    `   Run (note: EXCLUDE this verify workflow itself — its prompt text mentions these words but does`,
+    `   NOT produce the flag, the self-match bug being avoided):`,
+    `   \`grep -lE 'spikeFeasible[ ]*:|spikePassed[ ]*:|responseOpts[ ]*[:=]' ${projectDir}/templates/workflows/*.workflow.js 2>/dev/null | grep -v 'gsd-t-verify.workflow.js' | head\`.`,
+    `   If it prints NOTHING → there is NO live producer of the proven-by-adversary-only flag wired`,
+    `   this milestone. Return (INTERFACE-ONLY, declared PASS per §2.2 / decision A):`,
+    `   { "pass": true, "interfaceOnly": true, "deScopedPass": false, "provenByAdversaryOnlyCount": 0,`,
+    `     "note": "R-FAIL-2 interface-only this milestone — no workflow sets spikeFeasible, so proven-by-adversary-only is never raised; DECLARED no-op-PASS (doctrine contract §2.2/§4, backlog #42 wires the live producer)" }`,
+    `2. If a live producer IS found → check the sink: \`test -f '${M90_ARCH_TRIGGER_SINK}' && echo EXISTS || echo ABSENT\`.`,
+    `   - ABSENT → trigger genuinely de-scoped (R1-EXIT). Return:`,
+    `     { "pass": true, "interfaceOnly": false, "deScopedPass": true, "provenByAdversaryOnlyCount": 0, "note": "arch-trigger mechanism absent by design (R1 de-scoped-DOWN) — documented no-op-PASS" }`,
+    `   - EXISTS → read each JSONL line; count records where provenByAdversaryOnly === true → provenByAdversaryOnlyCount.`,
+    `     pass = (provenByAdversaryOnlyCount === 0). Return:`,
+    `     { "pass": boolean, "interfaceOnly": false, "deScopedPass": false, "provenByAdversaryOnlyCount": N, "note": "..." }`,
+    ``,
+    `This gate is R-FAIL-2 per unproven-assumption-doctrine-contract.md §4. The interfaceOnly PASS and`,
+    `deScopedPass are BOTH distinguishable from a wired-but-broken vacuous pass — they are only`,
+    `returned when the producer is provably absent (grep) / de-scoped, never to mask a wired failure.`,
+  ].join("\n"),
+  {
+    label: "m90-r-fail-2-gate",
+    phase: "Auto-Research Gate",
+    model: "haiku",
+    schema: {
+      type: "object",
+      required: ["pass"],
+      additionalProperties: true,
+      properties: {
+        pass: { type: "boolean" },
+        interfaceOnly: { type: "boolean" },
+        deScopedPass: { type: "boolean" },
+        provenByAdversaryOnlyCount: { type: "integer" },
+        note: { type: "string" },
+      },
+    },
+  }
+).catch((e) => ({
+  pass: false,
+  deScopedPass: false,
+  provenByAdversaryOnlyCount: -1,
+  note: `M90 R-FAIL-2 gate agent error: ${e && e.message} — failing closed (§4)`,
+}));
+
+if (!m90ArchTriggerGate.pass) {
+  const count = m90ArchTriggerGate.provenByAdversaryOnlyCount >= 0
+    ? m90ArchTriggerGate.provenByAdversaryOnlyCount
+    : "unknown (agent error)";
+  log(`M90 R-FAIL-2 gate FAIL — ${count} unresolved proven-by-adversary-only flag(s) (§4 fail-closed)`);
+  return {
+    status: "m90-r-fail-2-failed",
+    overallVerdict: "VERIFY-FAILED",
+    m90ArchTriggerGate,
+    reason: `M90 §4 R-FAIL-2: ${count} unresolved proven-by-adversary-only premise(s) — re-examine the premise, then re-verify`,
+    verifyGate: vg.envelope,
+    autoResearchGate: arGate,
+  };
+}
+log(`M90 R-FAIL-2 gate: PASS — ${m90ArchTriggerGate.deScopedPass ? "de-scoped (mechanism absent by design)" : `0 unresolved proven-by-adversary-only flag(s)`}`);
+
+// R-FAIL-3: read loop-ledger exit state (haltedButNoReExamination flag)
+const m90LoopLedgerGate = await runCli(
+  projectDir,
+  "loop-ledger",
+  ["read-exit-state", ...(milestone ? ["--milestone", milestone] : []), "--projectDir", projectDir],
+  "gsd-t-loop-ledger.cjs",
+  "m90-r-fail-3-gate",
+  true,
+  "Auto-Research Gate"
+);
+
+// Determine pass/fail from the loop-ledger exit state. §4 = FAIL-CLOSED.
+//   haltedButNoReExamination=true                  → FAIL (an unresolved non-converging loop)
+//   envelope.ok=false (CORRUPT state file, exit 1) → FAIL (fail-closed: a corrupt ledger must
+//     NEVER pass — the module deliberately raises this; treating it as "de-scoped" was a
+//     fail-OPEN inversion, Red Team HIGH M90 verify fix-cycle 2)
+//   genuinely-absent MODULE (no envelope at all + run/CLI error) → de-scoped NO-OP-PASS
+//   ok=true, haltedButNoReExamination=false        → PASS (clean)
+const exitEnv = m90LoopLedgerGate.envelope || null;
+let m90LoopLedgerPass = true;
+let m90LoopLedgerNote = "";
+if (exitEnv && exitEnv.ok === false) {
+  // The CLI RAN and returned a structured error envelope → the WIRED mechanism is failing
+  // closed (corrupt/unreadable state). FAIL — do NOT convert a deliberate fail-closed into a pass.
+  m90LoopLedgerPass = false;
+  m90LoopLedgerNote = `R-FAIL-3: loop-ledger returned a fail-closed error (${exitEnv.error || "corrupt/unreadable state"}) — a corrupt ledger must block verify, not pass §4`;
+  log(`M90 R-FAIL-3 gate FAIL — loop-ledger fail-closed error (§4): ${exitEnv.error || "corrupt state"}`);
+} else if (!exitEnv && !m90LoopLedgerGate.ok) {
+  // No parseable envelope AND the run errored → the MODULE itself is genuinely absent/unrunnable
+  // (not a corrupt state file). This is the true R1-EXIT de-scoped no-op-PASS.
+  m90LoopLedgerPass = true;
+  m90LoopLedgerNote = "loop-ledger module genuinely absent (no envelope) — R-FAIL-3 de-scoped no-op-PASS";
+  log(`M90 R-FAIL-3 gate: PASS (de-scoped — loop-ledger module absent / not wired)`);
+} else if (exitEnv && exitEnv.ok && exitEnv.haltedButNoReExamination) {
+  m90LoopLedgerPass = false;
+  // RECOVERABILITY (M90 verify decision A): name the exact signature(s) + the one-line clear
+  // command, so a halt is resolvable — never a cryptic count with no remedy (the cross-milestone
+  // brick was unrecoverable because the FAIL note printed only a number).
+  const pend = exitEnv.pendingSignatures || exitEnv.haltedSignatures || [];
+  const clearCmds = pend
+    .map((s) => `gsd-t loop-ledger record-re-examination --signature ${s} --projectDir ${projectDir}`)
+    .join("  |  ");
+  m90LoopLedgerNote =
+    `R-FAIL-3: ${pend.length} unresolved debug-loop halt(s) for this milestone — re-examine the premise per §3.2, then clear: ${clearCmds}`;
+  log(`M90 R-FAIL-3 gate FAIL — unresolved halt(s): ${pend.join(", ")}`);
+  log(`To resolve after re-examination: ${clearCmds}`);
+} else {
+  m90LoopLedgerPass = true;
+  m90LoopLedgerNote = `no halted-but-no-re-examination state (haltedButNoReExamination=${(exitEnv && exitEnv.haltedButNoReExamination) || false})`;
+  log(`M90 R-FAIL-3 gate: PASS — ${m90LoopLedgerNote}`);
+}
+
+if (!m90LoopLedgerPass) {
+  return {
+    status: "m90-r-fail-3-failed",
+    overallVerdict: "VERIFY-FAILED",
+    m90LoopLedgerGate: m90LoopLedgerGate.envelope,
+    reason: m90LoopLedgerNote,
+    verifyGate: vg.envelope,
+    autoResearchGate: arGate,
+    m90ArchTriggerGate,
+  };
+}
+
 // ─── M57 CI-Parity Gate (FAIL-blocking) ───────────────────────────────────
 // Per commands/gsd-t-verify.md Step 2.6 + cli-build-coverage-contract.md +
 // ci-parity-contract.md. NEITHER track is currently inside verify-gate.cjs.
@@ -366,6 +625,7 @@ return {
   status: verdict.overallVerdict === "VERIFY-FAILED" ? "failed" : "complete",
   overallVerdict: verdict.overallVerdict,
   verifyGate: vg.envelope,
+  autoResearchGate: arGate,
   buildCoverage: bc.envelope,
   ciParity: cip.envelope,
   testDataPurge: td.envelope,