omnius 1.0.571 → 1.0.572

package/dist/index.js

@@ -567847,6 +567847,36 @@ function clip2(value2, max = 500) {
 function listLines(items, empty2 = "- none observed") {
   return items.length > 0 ? items.map((item) => `- ${item}`) : [empty2];
 }
+function formatWorkspaceInventorySummary(inventory) {
+  if (!inventory)
+    return ["- no bounded workspace inventory was provided"];
+  const files = (inventory.files ?? []).slice(0, 40).map((file) => `${file.path}${file.bytes !== void 0 ? ` (bytes=${file.bytes}` : ""}${file.mtimeMs !== void 0 ? `${file.bytes !== void 0 ? ", " : " ("}mtimeMs=${file.mtimeMs})` : file.bytes !== void 0 ? ")" : ""}`);
+  const dirs = (inventory.dirs ?? []).slice(0, 40).map((dir) => `dir:${dir}`);
+  const summary = [
+    `workspace_root=${inventory.root}`,
+    `files=${inventory.files.length}${inventory.truncated ? "+" : ""}`,
+    `dirs=${(inventory.dirs ?? []).length}`,
+    `requested_max=${inventory.maxFiles}x${inventory.maxDirs}`
+  ];
+  if (!inventory.truncated)
+    summary.push(`inventory_complete=${inventory.files.length > 0 || (inventory.dirs ?? []).length > 0 ? "yes" : "no"}`);
+  const out = [
+    `Generated at: ${inventory.generatedAtIso}`,
+    summary.join("; ")
+  ];
+  if (files.length > 0) {
+    out.push("Representative files:");
+    out.push(...files.map((item) => `- ${item}`));
+  }
+  if (dirs.length > 0) {
+    out.push("Representative directories:");
+    out.push(...dirs.map((item) => `- ${item}`));
+  }
+  if (inventory.truncated) {
+    out.push("- inventory_truncated: run a fresh scan with higher limits to inspect additional paths");
+  }
+  return out;
+}
 function formatEvidenceEntry(entry) {
   const parts = [
     entry.success === true ? "ok" : entry.success === false ? "failed" : "unknown",
@@ -567892,6 +567922,7 @@ ${String(input.answerText).trim()}` : ""
     ].filter(Boolean).join(" ");
     return `${clip2(file.path, 220)}${meta ? ` (${meta})` : ""}`;
   });
+  const workspaceInventory = formatWorkspaceInventorySummary(input.workspaceInventory);
   const scenarioSeed = deriveScenarioSeed(input);
   const lines = [];
   lines.push(`[COMPLETION META-DECOMPOSITION]`);
@@ -567903,11 +567934,14 @@ ${String(input.answerText).trim()}` : ""
   lines.push(`Proposed completion claim text:`);
   lines.push(proposedClaimText || "(no proposed completion text yet)");
   lines.push(``);
+  lines.push(`Open loops and remaining blockers:`);
+  lines.push(...listLines(unresolvedSignals, "- no open loop / blocker signals currently reported"));
+  lines.push(``);
   lines.push(`Observed run evidence:`);
   lines.push(...listLines(observedEvidence, "- no tool evidence recorded"));
   lines.push(``);
-  lines.push(`Unresolved or caution signals:`);
-  lines.push(...listLines(unresolvedSignals, "- none recorded"));
+  lines.push(`Workspace inventory (bounded to prevent scan drift):`);
+  lines.push(...workspaceInventory);
   lines.push(``);
   lines.push(`Modified artifact digest:`);
   lines.push(...listLines(modifiedFiles, "- no modified artifacts listed"));
@@ -567953,6 +567987,52 @@ var init_completionContract = __esm({
 // packages/orchestrator/dist/completionLedger.js
 import { mkdirSync as mkdirSync51, readFileSync as readFileSync66, writeFileSync as writeFileSync42 } from "node:fs";
 import { dirname as dirname29 } from "node:path";
+function setClaimDiscoveryState(ledger, state) {
+  return {
+    ...ledger,
+    claimDiscovery: {
+      ...state,
+      generatedAtIso: nowIso3(),
+      resolvedEvidenceHandles: state.resolvedEvidenceHandles ?? []
+    },
+    updatedAtIso: nowIso3()
+  };
+}
+function claimDiscoveryStateFromSurvey(input) {
+  const normalizedInventory = input.boundedInventory;
+  const paths = [...new Set((Array.isArray(input.candidatePaths) ? input.candidatePaths : []).map((value2) => normalizeEvidencePath(value2)).filter(Boolean).slice(0, 16))];
+  const reasons = /* @__PURE__ */ Object.create(null);
+  for (const [rawPath, rawReason] of Object.entries(input.pathReasons ?? {})) {
+    const path16 = normalizeEvidencePath(rawPath);
+    const reason = cleanText(rawReason, 220);
+    if (path16)
+      reasons[path16] = reason || "candidate selected from bounded workspace inventory";
+  }
+  const openDeltas = paths.map((path16) => ({
+    path: path16,
+    reason: reasons[path16] || "candidate selected from bounded workspace inventory"
+  }));
+  const unresolved = Array.isArray(input.unresolvedQuestions) ? input.unresolvedQuestions.map((item) => cleanText(item, 260)).filter(Boolean) : [];
+  const blockers = Array.isArray(input.survivingBlockers) ? input.survivingBlockers.map((item) => cleanText(item, 220)).filter(Boolean) : [];
+  const hasBlockers = blockers.length > 0;
+  const hasQuestions = unresolved.length > 0;
+  const resolvedStatus = paths.length === 0 ? hasBlockers || hasQuestions ? "blocked" : "skipped" : hasBlockers || hasQuestions ? "blocked" : "active";
+  return {
+    status: resolvedStatus,
+    generatedAtIso: nowIso3(),
+    request: cleanText(input.request, 600),
+    context: cleanText(input.context, 480),
+    boundedInventory: normalizedInventory,
+    candidatePaths: paths,
+    pathReasons: reasons,
+    unresolvedQuestions: unresolved.slice(0, 10),
+    openDeltas,
+    survivingBlockers: blockers.slice(0, 8),
+    evidenceHandles: [...new Set(paths.map((path16) => `workspace:${path16}`))],
+    resolvedEvidenceHandles: [],
+    requiresEvidence: typeof input.requiresEvidence === "boolean" ? input.requiresEvidence : true
+  };
+}
 function nowIso3(now2 = /* @__PURE__ */ new Date()) {
   return now2 instanceof Date ? now2.toISOString() : new Date(now2).toISOString();
 }
@@ -568002,6 +568082,180 @@ function formatEvidenceSummary(summary) {
 function nextId2(prefix, count) {
   return `${prefix}_${String(count + 1).padStart(4, "0")}`;
 }
+function extractWorkspaceTokens(text2) {
+  const raw = String(text2 ?? "").toLowerCase().replace(/["'`]/g, " ").replace(/[^\w./@-]+/g, " ");
+  return raw.split(/\s+/).filter((value2) => value2.length >= 4);
+}
+function extractPathFragments(text2) {
+  const out = [];
+  const pathPattern = /(?:[\w.-]+\/[\w./-]+\.[A-Za-z0-9]+|[\w.-]+\.(?:ts|tsx|js|jsx|mjs|cjs|py|go|rs|cpp|c|h|hpp|java|kt|json|yml|yaml|toml|md|mdx|sh|bash|cxx|swift|rb|php)|[\w./-]+\.[A-Za-z0-9]+)/g;
+  for (const hit of text2.matchAll(pathPattern)) {
+    const value2 = String(hit[0] ?? "").trim();
+    if (!value2)
+      continue;
+    const normalized = value2.replace(/^\.\/+/, "");
+    if (normalized.length > 2)
+      out.push(normalized);
+  }
+  return [...new Set(out)].slice(0, 12);
+}
+function tokenizeClaims(text2) {
+  return String(text2 ?? "").split(/[.\n\r!?;]+/).map((item) => item.trim()).filter((item) => item.length > 6).filter((item) => item.length < 260).slice(0, 30);
+}
+function estimateClaimMateriality(text2) {
+  const normalized = text2.toLowerCase();
+  if (/\b(blocker|critical|security|production|release|deploy|migrate|migration|regression|customer|public)\b/.test(normalized)) {
+    return "high";
+  }
+  if (/\b(implement|fix|refactor|resolve|wire|integrat|add|remove|change|update)\b/.test(normalized)) {
+    return "medium";
+  }
+  return "low";
+}
+function classifyClaimAttainedState(text2) {
+  const normalized = text2.toLowerCase();
+  if (/\b(block|blocked|blocker|cannot verify|unverified|not verified|hold)\b/.test(normalized)) {
+    return "blocked";
+  }
+  if (/\b(simulat|dry.?run|mock|unit test|paper|offline|software.?in.?loop)\b/.test(normalized)) {
+    return "simulation_only";
+  }
+  if (/\b(hil|hardware.?in.?the.?loop|hardware.?test|on.?device|real.?hardware|physical)\b/.test(normalized)) {
+    return "hardware_verified";
+  }
+  if (/\b(integrat|integrated|bridge|transport|serial|can|hardware|device|physical)\b/.test(normalized)) {
+    return "hardware_integrated";
+  }
+  return "unproven";
+}
+function deriveClaimRisks(text2) {
+  const normalized = text2.toLowerCase();
+  if (/\b(start|running|daemon|process|service|alive|ready)\b/.test(normalized)) {
+    return {
+      riskCategory: "process_liveness",
+      requiresIndependentEvidence: true,
+      requiredCheck: "Independent runtime state/health check with process or endpoint probe."
+    };
+  }
+  if (/\b(instal|pip|npm|pnpm|apt|brew|cargo|go install|pip install|docker pull)\b/.test(normalized)) {
+    return {
+      riskCategory: "installation",
+      requiresIndependentEvidence: true,
+      requiredCheck: "Independent command query/inspection proving the toolchain exists after the installation claim."
+    };
+  }
+  if (/\b(fixed|repair|resolved|passed|test pass|fix|bug|regression)\b/.test(normalized)) {
+    return {
+      riskCategory: "fix_confirmation",
+      requiresIndependentEvidence: true,
+      requiredCheck: "Re-run the same failure path or equivalent check and capture the successful evidence."
+    };
+  }
+  if (/\b(simulat|dry.?run|mock|fake|virtual)\b/.test(normalized)) {
+    return {
+      riskCategory: "reality",
+      requiresIndependentEvidence: false,
+      requiredCheck: "Label and preserve as simulation-only unless hardware-path evidence exists."
+    };
+  }
+  return {
+    riskCategory: "coverage",
+    requiresIndependentEvidence: false,
+    requiredCheck: "Collect evidence per claim from supported tool outputs and source observations."
+  };
+}
+function claimEvidenceNeeds(text2) {
+  const normalized = text2.toLowerCase();
+  const needs = [];
+  const kind = /\b(test|verify|validate|coverage|run|build|lint|check|execute)\b/.test(normalized) ? "tool_result" : /\b(create|write|modify|edit|delete|remove|add|updated|implemented|fix)\b/.test(normalized) ? "file_change" : "runtime_observation";
+  needs.push({
+    handle: `${kind}:in_scope`,
+    evidenceKind: kind,
+    rationale: `Evidence supporting the in-scope portion of: ${cleanText(text2, 120)}`
+  });
+  if (/\b(runtime|process|service|daemon|endpoint|server)\b/.test(normalized)) {
+    needs.push({
+      handle: "verification:post-change",
+      evidenceKind: "runtime_observation",
+      rationale: "Observed runtime confirmation after the claimed change."
+    });
+  }
+  if (/\b(serial|hardware|device|controller|transport)\b/.test(normalized)) {
+    needs.push({
+      handle: "delivery:hardware-path",
+      evidenceKind: "delivery",
+      rationale: "Hardware-path or transport evidence that clarifies simulation/hardware status."
+    });
+  }
+  return needs;
+}
+function findInventoryMatches(statement, workspaceInventory) {
+  if (!workspaceInventory)
+    return [];
+  const tokens = extractWorkspaceTokens(statement);
+  const candidatePaths = workspaceInventory.files.map((entry) => entry.path);
+  const seen = /* @__PURE__ */ new Set();
+  const matches = [];
+  const literalPathHints = extractPathFragments(statement);
+  for (const hint of literalPathHints) {
+    const normalized = hint.toLowerCase();
+    const exact = candidatePaths.find((path16) => path16.toLowerCase() === normalized);
+    if (exact)
+      seen.add(exact);
+  }
+  for (const path16 of candidatePaths) {
+    if (matches.length >= 5 || seen.size >= 8)
+      break;
+    const lower = path16.toLowerCase();
+    const tokenHits = tokens.filter((token) => lower.includes(token));
+    if (tokenHits.length >= 2 || tokenHits.length >= 1 && literalPathHints.length === 0) {
+      if (!seen.has(path16)) {
+        seen.add(path16);
+      }
+    }
+  }
+  for (const path16 of seen)
+    matches.push(path16);
+  if (literalPathHints.length > 0 && matches.length === 0) {
+    for (const path16 of candidatePaths) {
+      for (const hint of literalPathHints) {
+        if (path16.toLowerCase().includes(hint.toLowerCase())) {
+          matches.push(path16);
+          break;
+        }
+      }
+      if (matches.length >= 6)
+        break;
+    }
+  }
+  return matches.slice(0, 6);
+}
+function claimDiscoveryControllerSignals(stage2) {
+  if (!stage2)
+    return [];
+  const openDeltas = (stage2.openDeltas ?? []).slice(0, 10);
+  const evidenceHandles = stage2.evidenceHandles ?? [];
+  const resolvedEvidenceHandles = stage2.resolvedEvidenceHandles ?? [];
+  const survivingBlockers = stage2.survivingBlockers ?? [];
+  const unresolvedQuestions = stage2.unresolvedQuestions ?? [];
+  const boundedInventory = stage2.boundedInventory;
+  const boundedDirs = boundedInventory?.dirs ?? [];
+  const resolvedCount = Math.min(evidenceHandles.length, new Set(resolvedEvidenceHandles).size);
+  const unresolvedEvidenceCount = Math.max(evidenceHandles.length - resolvedCount, 0);
+  return [
+    "[COMPLETION CLAIM DISCOVERY]",
+    `status=${stage2.status ?? "skipped"} generated_at=${stage2.generatedAtIso ?? ""}`,
+    `requires_evidence=${stage2.requiresEvidence ? "true" : "false"}`,
+    `bounded_inventory=${boundedInventory ? `${boundedInventory.root}|files=${boundedInventory.files.length}|dirs=${boundedDirs.length}|truncated=${Boolean(boundedInventory.truncated)}` : "none"}`,
+    `candidate_paths=${(stage2.candidatePaths ?? []).join(",") || "none"}`,
+    `open_deltas=${openDeltas.map((delta) => `${delta.path} :: ${delta.reason}`.replace(/\s+/g, " ")).join(" | ") || "none"}`,
+    `open_delta_count=${openDeltas.length} unresolved_evidence_count=${unresolvedEvidenceCount}`,
+    `surviving_blockers=${survivingBlockers.join(" | ") || "none"}`,
+    `unresolved_questions=${unresolvedQuestions.join(" | ") || "none"}`,
+    `evidence_handles=${evidenceHandles.join(",") || "none"}`,
+    `resolved_evidence_handles=${resolvedEvidenceHandles.join(",") || "none"}`
+  ];
+}
 function createCompletionLedger(input) {
   const ts = nowIso3(input.now);
   return {
@@ -568018,28 +568272,68 @@ function createCompletionLedger(input) {
   };
 }
 function deriveClaimsFromProposedText(input) {
-  const raw = String(input.text ?? "").trim();
-  if (!raw)
+  return deriveStructuredClaims({
+    taskText: input.taskText,
+    proposedSummary: input.text,
+    source: input.source,
+    existing: input.existing,
+    workspaceInventory: input.workspaceInventory,
+    maxClaims: 12
+  });
+}
+function deriveStructuredClaims(input) {
+  const proposed = String(input.proposedSummary ?? "").trim();
+  const task = String(input.taskText ?? "").trim();
+  const baseText = [proposed, task].filter(Boolean).join("\n");
+  const statements = tokenizeClaims(baseText);
+  if (statements.length === 0)
     return [];
   const existingIds = new Set((input.existing ?? []).map((claim) => claim.id));
-  const text2 = cleanText(raw, 1200);
-  const base3 = normalizeCompletionKey(text2, "claim").slice(0, 64);
-  let id2 = base3 || "claim";
-  let suffix = 2;
-  while (existingIds.has(id2)) {
-    id2 = `${base3}_${suffix++}`;
-  }
-  return [
-    {
+  const maxClaims = Math.max(1, Math.min(32, input.maxClaims ?? 12));
+  const seen = /* @__PURE__ */ new Set();
+  const claims = [];
+  for (const statementRaw of statements) {
+    if (claims.length >= maxClaims)
+      break;
+    const text2 = cleanText(statementRaw, 220);
+    if (!text2)
+      continue;
+    const base3 = normalizeCompletionKey(text2, "claim").slice(0, 64) || "claim";
+    let id2 = base3;
+    let suffix = 2;
+    while (existingIds.has(id2) || seen.has(id2)) {
+      id2 = `${base3}_${suffix++}`;
+    }
+    const risk = deriveClaimRisks(text2);
+    const needs = claimEvidenceNeeds(text2);
+    const evidenceHandles = [
+      ...needs.map((need) => need.handle),
+      ...findInventoryMatches(text2, input.workspaceInventory).map((path16) => `workspace:${path16}`)
+    ];
+    const workspaceSignals = findInventoryMatches(text2, input.workspaceInventory);
+    const sourceSignals = [
+      input.taskText ? "task" : "proposed_text",
+      ...extractPathFragments(statementRaw).slice(0, 2)
+    ].filter(Boolean);
+    claims.push({
       id: id2,
       text: text2,
-      source: input.source,
-      materiality: "high",
-      evidenceRequirement: "Explicit evidenceIds must be attached by the caller, or the claim remains unverified for critic review.",
+      source: input.source ?? "derived",
+      materiality: estimateClaimMateriality(statementRaw),
+      evidenceRequirement: "Attach explicit evidenceIds that match the listed evidence handles and state.",
+      attainedState: classifyClaimAttainedState(text2),
+      riskCategory: risk.riskCategory,
+      requiresIndependentEvidence: risk.requiresIndependentEvidence,
+      requiredCheck: risk.requiredCheck,
+      evidenceNeeds: needs,
+      sourceSignals,
+      workspaceSignals,
       evidenceIds: [],
       status: "unverified"
-    }
-  ];
+    });
+    seen.add(id2);
+  }
+  return claims;
 }
 function recordCompletionEvidence(ledger, evidence) {
   const targetPaths = cleanTargetPaths(evidence.targetPaths);
@@ -568138,14 +568432,42 @@ function buildCriticPacketFromLedger(ledger) {
   lines.push(`Run: ${ledger.runId}`);
   lines.push(`Goal: ${ledger.goal || "(not recorded)"}`);
   lines.push(`Status: ${ledger.status}`);
+  lines.push(`Claims discovered: ${ledger.proposedClaims.length}`);
+  if (ledger.claimDiscovery) {
+    lines.push("");
+    lines.push("Claim Discovery:");
+    lines.push(`  status=${ledger.claimDiscovery.status}`);
+    lines.push(`  generated_at=${ledger.claimDiscovery.generatedAtIso}`);
+    lines.push(`  candidate_paths=${ledger.claimDiscovery.candidatePaths.join(",") || "none"}`);
+    lines.push(`  open_deltas=${ledger.claimDiscovery.openDeltas.map((delta) => `${delta.path} :: ${delta.reason}`).slice(0, 10).join(" | ") || "none"}`);
+    lines.push(`  surviving_blockers=${ledger.claimDiscovery.survivingBlockers.join(" | ") || "none"}`);
+    lines.push(`  unresolved_questions=${ledger.claimDiscovery.unresolvedQuestions.join(" | ") || "none"}`);
+    lines.push(`  evidence_handles=${ledger.claimDiscovery.evidenceHandles.join(",") || "none"}`);
+    lines.push(`  resolved_evidence_handles=${ledger.claimDiscovery.resolvedEvidenceHandles.join(",") || "none"}`);
+  }
   lines.push("");
   lines.push("Claims:");
   if (ledger.proposedClaims.length === 0)
     lines.push("- none recorded");
   for (const claim of ledger.proposedClaims) {
-    lines.push(`- [${claim.status}] ${claim.id}: ${claim.text}`);
+    const handles = claim.evidenceNeeds.length === 0 ? "none" : claim.evidenceNeeds.map((need) => need.handle).join(", ");
+    lines.push(`- [${claim.status}] ${claim.id} (${claim.attainedState}): ${claim.text}`);
+    lines.push(`  source: ${claim.source} materiality:${claim.materiality}`);
     lines.push(`  evidence: ${claim.evidenceIds.length > 0 ? claim.evidenceIds.join(", ") : "none"}`);
-    lines.push(`  requirement: ${claim.evidenceRequirement}`);
+    lines.push(`  evidence_handles: ${handles}`);
+    if (claim.workspaceSignals.length > 0) {
+      lines.push(`  workspace_signals: ${claim.workspaceSignals.join(", ")}`);
+    }
+    if (claim.sourceSignals.length > 0) {
+      lines.push(`  source_signals: ${claim.sourceSignals.join(", ")}`);
+    }
+    lines.push(`  requirement: ${claim.evidenceRequirement} ${claim.requiresIndependentEvidence ? "[independent evidence required]" : ""}`);
+    if (claim.riskCategory && claim.riskCategory !== "unknown") {
+      lines.push(`  risk: ${claim.riskCategory}`);
+      if (claim.requiredCheck) {
+        lines.push(`  required_check: ${claim.requiredCheck}`);
+      }
+    }
   }
   lines.push("");
   lines.push("Evidence:");
@@ -568232,6 +568554,27 @@ function evidenceTargetPaths(entry) {
   }
   return cleanTargetPaths(paths);
 }
+function claimDiscoveryResolvedHandles(ledger, state) {
+  if (!state)
+    return [];
+  const inspected = /* @__PURE__ */ new Set();
+  const candidatePaths = [...state.candidatePaths].map((value2) => normalizeEvidencePath(value2)).filter(Boolean).map((path16) => path16.replace(/^\/+/, ""));
+  for (const entry of ledger.evidence) {
+    if (entry.success !== true)
+      continue;
+    for (const rawPath of evidenceTargetPaths(entry)) {
+      const path16 = normalizeEvidencePath(rawPath);
+      if (!path16)
+        continue;
+      const normalized = path16.replace(/^\/+/, "");
+      const matched = candidatePaths.find((candidate) => pathsEquivalent(candidate, normalized));
+      if (matched) {
+        inspected.add(`workspace:${matched}`);
+      }
+    }
+  }
+  return [...inspected];
+}
 function pathsEquivalent(a2, b) {
   const left = normalizeEvidencePath(a2);
   const right = normalizeEvidencePath(b);
@@ -568803,18 +569146,41 @@ function clean3(value2, max) {
   return String(value2 ?? "").replace(/\s+/g, " ").trim().slice(0, max);
 }
 function selectedEvidence(ledger) {
-  if (!ledger)
-    return { evidenceIds: [], artifactHashes: [] };
+  if (!ledger) {
+    return {
+      evidenceIds: [],
+      commandReceipts: [],
+      artifactHashes: []
+    };
+  }
   const candidates = ledger.evidence.filter((entry) => entry.success === true && (entry.role === "verification" || entry.role === "mutation")).slice(-16);
   const artifacts = /* @__PURE__ */ new Map();
+  const commandReceipts = [];
   for (const entry of candidates) {
     for (const item of entry.receipt?.artifactHashes ?? []) {
       if (item.path && item.sha256)
         artifacts.set(item.path, item.sha256);
     }
+    if (entry.receipt) {
+      const receipt = entry.receipt;
+      commandReceipts.push({
+        evidenceId: entry.id,
+        toolName: entry.toolName ?? "unknown",
+        role: entry.role ?? "unknown",
+        command: receipt.command ?? "",
+        canonicalCommand: receipt.canonicalCommand ?? "",
+        cwd: receipt.cwd ?? "",
+        exitCode: receipt.exitCode ?? null,
+        timedOut: Boolean(receipt.timedOut),
+        startedAtIso: receipt.startedAtIso ?? "",
+        finishedAtIso: receipt.finishedAtIso ?? "",
+        artifactHashes: entry.receipt.artifactHashes?.length ? entry.receipt.artifactHashes : []
+      });
+    }
   }
   return {
     evidenceIds: candidates.map((entry) => entry.id),
+    commandReceipts,
     artifactHashes: [...artifacts.entries()].map(([path16, sha2567]) => ({
       path: path16,
       sha256: sha2567
@@ -568842,6 +569208,7 @@ function buildCompletionFinalizationRecord(input) {
     summary: clean3(input.summary, 4e3),
     committedAtIso,
     evidenceIds: evidence.evidenceIds,
+    commandReceipts: evidence.commandReceipts,
     artifactHashes: evidence.artifactHashes,
     projections: {
       ledger: "pending",
@@ -577895,16 +578262,90 @@ var init_consolidation_runtime = __esm({
 });
 
 // packages/orchestrator/dist/completion-evidence-gate.js
+function normalizedEvidenceText(text2) {
+  return String(text2 ?? "").toLowerCase();
+}
 function classifyCompletionClaim(text2) {
-  void text2;
+  const normalized = normalizedEvidenceText(text2);
+  if (!normalized) {
+    return {
+      category: null,
+      requiresIndependentEvidence: false,
+      requiredCheck: ""
+    };
+  }
+  const processLiveness = /\b(daemon|service|process|server|port|listener|runtime|pid|socket|endpoint)\b/.test(normalized) && /\b(start(ed|ing)?|run(ning)?|up|ready|alive|online|boot(ed|ing)?|initialized|listening)\b/.test(normalized);
+  if (processLiveness) {
+    return {
+      category: "process_liveness",
+      requiresIndependentEvidence: true,
+      requiredCheck: "Independent runtime verification (process/pid/health/port check) after the claimed state change."
+    };
+  }
+  if (/\b(instal|npm|pnpm|yarn|pip\s+install|go\s+install|cargo\s+install|apt\s+get|brew\s+install|dnf|yum|apk add|make\s+install)\b/.test(normalized)) {
+    return {
+      category: "installation",
+      requiresIndependentEvidence: true,
+      requiredCheck: "Independent command-level availability check for the installed artifact after change."
+    };
+  }
+  const fixHint = /(fix|fixed|resolved|repair|patched|correct|address|addressed)\b/.test(normalized);
+  const fixTarget = /(bug|regression|failure|error|issue|test|build|lint|crash|exception|pass|coverage)\b/.test(normalized);
+  if (fixHint && fixTarget) {
+    return {
+      category: "fix_confirmation",
+      requiresIndependentEvidence: true,
+      requiredCheck: "Rerun the original failing command path and capture a passing result as evidence."
+    };
+  }
+  if (/(simulat|dry.?run|mock|mocked|virtual|paper|emulat)\b/.test(normalized)) {
+    return {
+      category: "reality",
+      requiresIndependentEvidence: false,
+      requiredCheck: "Mark as simulation-only unless paired with a grounded hardware/live execution claim."
+    };
+  }
   return {
     category: null,
     requiresIndependentEvidence: false,
     requiredCheck: ""
   };
 }
-function detectExitCodeMisread(text2) {
-  void text2;
+function detectExitCodeMisread(input) {
+  const source = typeof input === "string" ? {
+    statement: input,
+    command: "",
+    output: "",
+    exitCode: null,
+    canonicalCommand: ""
+  } : {
+    statement: input.statement ?? "",
+    command: input.command ?? input.canonicalCommand ?? "",
+    output: input.output ?? "",
+    exitCode: typeof input.exitCode === "number" && Number.isFinite(input.exitCode) ? input.exitCode : null,
+    canonicalCommand: ""
+  };
+  const statement = normalizedEvidenceText(source.statement);
+  const command = normalizedEvidenceText(source.command);
+  const output = normalizedEvidenceText(source.output);
+  const exitCode = source.exitCode;
+  if (exitCode !== null && exitCode !== 0 && /\b(success|pass(?:ed|es)?|succeed(?:ed|s)?|ok|completed|done|finished|verified)\b/.test(statement)) {
+    return true;
+  }
+  if (/\|\|\s*(true|:|exit\s+0)/.test(command))
+    return true;
+  if (/\bset\s*\+e\b/.test(command))
+    return true;
+  if (/;\s*\(\s*/.test(command))
+    return true;
+  if (command.includes("|") && !/\bset\s+-o\s+pipefail\b/.test(statement + " " + command)) {
+    return true;
+  }
+  if (/\b\S+\s&\s*$/.test(command.trim()))
+    return true;
+  if (/\bexit(ed|ion)?\s+code\s*[1-9]\d*/.test(statement + " " + output)) {
+    return true;
+  }
   return false;
 }
 function auditCompletionClaims(claims) {
@@ -581059,8 +581500,8 @@ var init_evidenceLedger = __esm({
       }
       /**
        * Return a bounded, read-only projection for components that need to make a
-       * routing decision from observed workspace state (for example Feature Loop
-       * survey grounding).  Callers cannot mutate ledger entries through this
+       * routing decision from observed workspace state (for example claim-discovery
+       * grounding).  Callers cannot mutate ledger entries through this
        * result, preserving the ledger as the single freshness authority.
        */
       snapshot(maxEntries = 24) {
@@ -586977,7 +587418,7 @@ var init_longhaul_integration = __esm({
       }
       /**
        * WO-6 (spec §2.5): seed the locked contract from the planner's
-       * `LockedContract` at PLAN time. The Feature Loop calls this after the
+       * `LockedContract` at PLAN time. The claim-discovery planner path calls this after the
        * planner emits its artefact, so the breaker's "regenerate from the locked
        * contract" guidance has a real target from the first boundary unit — without
        * waiting for coherent code to accumulate one. Idempotent + fault-tolerant.
@@ -589248,515 +589689,6 @@ var init_git_progress = __esm({
   }
 });
 
-// packages/orchestrator/dist/featurePlanner.js
-import fs7 from "node:fs";
-import path9 from "node:path";
-function classifyKind(survey) {
-  const files = survey.files ?? [];
-  const newSym = (survey.newSymbols ?? []).length;
-  const req3 = survey.request.toLowerCase();
-  if (/\b(investigat|why does|how does|trace|understand|root cause|diagnos|explain)\b/.test(req3) && newSym === 0 && files.length <= 2) {
-    return "investigation";
-  }
-  if (/\b(bug|fix|broken|regression|crash|incorrect|fails?|misbehav)/.test(req3) && newSym === 0) {
-    return "bugfix";
-  }
-  if (/\b(refactor|restructure|rename|clean up|simplif|migrate|consolidate)\b/.test(req3) && newSym === 0) {
-    return "refactor";
-  }
-  if (/\b(wir|connect|integrate|hook up|plumb|bridge|glue)\b/.test(req3) && files.length >= 2) {
-    return "wiring";
-  }
-  if (newSym > 0 || /\b(new|create|add|implement|build|introduce|scaffold)\b/.test(req3)) {
-    return "new-module";
-  }
-  return "new-module";
-}
-function guessKind(name10) {
-  if (/^(I[A-Z]|.*Interface|.*Contract|.*Spec|.*Event|.*Meta|.*Config|.*State)$/.test(name10)) {
-    return "interface";
-  }
-  if (/^(T|Type|.*Type)$/.test(name10))
-    return "type";
-  if (/^(E|Enum|.*Kind|.*Status|.*Mode)$/.test(name10))
-    return "enum";
-  if (/^[A-Z]/.test(name10))
-    return "class";
-  return "function";
-}
-function buildLockedContract(kind, survey) {
-  const symbols = [];
-  if (kind === "refactor") {
-    for (const name10 of survey.existingSymbols ?? []) {
-      symbols.push({ name: name10, kind: guessKind(name10), fields: [] });
-    }
-  } else if (kind === "new-module") {
-    for (const name10 of survey.newSymbols ?? []) {
-      symbols.push({ name: name10, kind: guessKind(name10), fields: [] });
-    }
-  }
-  return { symbols };
-}
-function decomposeFeature(survey, kind) {
-  const units = [];
-  const evidenceRefs = featureEvidenceRefs(survey);
-  const unresolvedQuestion = survey.unresolvedQuestions?.[0] ?? (evidenceRefs.length === 0 ? "Which current files, symbols, and tests govern this unit? Inspect them before proposing a mutation." : void 0);
-  const returnContract = "Return the direct result with cited observations, relevant/changed paths, verification or blocker, and the next parent decision.";
-  const withGrounding = (unit) => ({
-    ...unit,
-    evidenceRefs,
-    ...unresolvedQuestion ? { unresolvedQuestion } : {},
-    returnContract
-  });
-  if (kind === "new-module") {
-    const syms = survey.newSymbols ?? [];
-    if (syms.length === 0) {
-      units.push(withGrounding({
-        label: "Establish the module boundary and implement the evidenced unit",
-        size: "large",
-        detail: "Do not scaffold from the request alone. First identify the owning entry point, adjacent contract, and test surface from current evidence."
-      }));
-    } else {
-      for (const name10 of syms) {
-        units.push({
-          ...withGrounding({
-            label: `Implement ${name10} within its evidenced owner`,
-            size: "small",
-            detail: "Confirm the symbol's owning module and contract before editing; do not infer a file path from the feature label."
-          }),
-          expectedSymbols: [name10]
-        });
-      }
-    }
-  } else if (kind === "refactor") {
-    units.push(withGrounding({
-      label: "Refactor only the evidenced public surface",
-      size: survey.files.length > 1 ? "large" : "small"
-    }));
-  } else if (kind === "bugfix") {
-    units.push(withGrounding({
-      label: "Reproduce the evidenced failure, make the smallest justified fix, and verify it",
-      size: "small"
-    }));
-  } else if (kind === "wiring") {
-    units.push(withGrounding({
-      label: "Connect the evidenced module boundaries",
-      size: survey.files.length > 2 ? "large" : "small"
-    }));
-  } else {
-    units.push(withGrounding({
-      label: "Investigate the evidence gap and report the next justified action",
-      size: "small"
-    }));
-  }
-  return units;
-}
-function featureEvidenceRefs(survey) {
-  const declared = (survey.evidence ?? []).map((item) => item.ref.trim()).filter(Boolean).slice(0, 6);
-  if (declared.length > 0)
-    return declared;
-  return survey.files.map((file) => `survey:file:${file.path}`).filter(Boolean).slice(0, 6);
-}
-function buildFeatureUnitRequest(input) {
-  const evidence = (input.survey.evidence ?? []).filter((item) => !input.unit.evidenceRefs?.length || input.unit.evidenceRefs.includes(item.ref)).slice(0, 6);
-  const fallbackEvidence = evidence.length > 0 ? evidence : input.survey.files.slice(0, 6).map((file) => ({
-    ref: `survey:file:${file.path}`,
-    detail: `${file.path}${file.role ? ` — ${file.role}` : ""}`,
-    freshness: "unknown"
-  }));
-  const lines = [
-    "[FEATURE UNIT EVIDENCE BRIEF]",
-    `Parent request: ${input.parentRequest.slice(0, 900)}`,
-    `Requested unit: ${input.unit.label}`,
-    `Why now: this unit was selected from the current feature survey, not from a task label alone.`,
-    "Evidence:",
-    ...fallbackEvidence.length > 0 ? fallbackEvidence.map((item) => `- [${item.freshness ?? "unknown"}] ${item.ref}: ${item.detail.slice(0, 360)}`) : ["- No current code observation is available; discovery is required before mutation."],
-    input.unit.unresolvedQuestion ? `Open question: ${input.unit.unresolvedQuestion}` : null,
-    "Scope: stay within this unit and directly implicated code; do not broaden the feature without returning to the parent.",
-    `Return contract: ${input.unit.returnContract ?? "Return evidence, verification or blocker, and the next parent decision."}`,
-    "",
-    "Work protocol: inspect the cited files/contracts first. Only mutate after a fresh observation identifies the exact target; if the evidence does not support a target, report the gap instead of fabricating one."
-  ];
-  return lines.filter((line) => Boolean(line)).join("\n");
-}
-function renderSpecMarkdown(input) {
-  const { kind, survey, lockedContract, completionContract, decomposition, prose } = input;
-  const lines = [];
-  lines.push(`# Feature Plan — ${kind}`);
-  lines.push("");
-  lines.push(`**Request:** ${survey.request}`);
-  lines.push("");
-  lines.push(`**Node kind:** \`${kind}\` (selected by CLASSIFY over the survey signals)`);
-  lines.push("");
-  if (prose) {
-    lines.push(`## 1. Intent`);
-    lines.push("");
-    lines.push(prose.trim());
-    lines.push("");
-  }
-  lines.push(`## 2. Survey (codebase as-is)`);
-  lines.push("");
-  if (survey.files.length > 0) {
-    for (const f2 of survey.files) {
-      const refs = f2.lineRefs?.length ? `:${f2.lineRefs.join(",")}` : "";
-      lines.push(`- \`${f2.path}${refs}\`${f2.role ? ` — ${f2.role}` : ""}`);
-    }
-  } else {
-    lines.push("- (no files enumerated in survey)");
-  }
-  if (survey.evidence?.length) {
-    for (const item of survey.evidence.slice(0, 8)) {
-      lines.push(`- evidence [${item.freshness ?? "unknown"}] ${item.ref}: ${item.detail}`);
-    }
-  }
-  if (survey.unresolvedQuestions?.length) {
-    lines.push(`- unresolved: ${survey.unresolvedQuestions.join("; ")}`);
-  }
-  lines.push(`- new symbols: ${(survey.newSymbols ?? []).join(", ") || "none"}`);
-  lines.push(`- public surface changes: ${survey.publicSurfaceChanges ? "yes" : "no"}`);
-  lines.push(`- tests exist: ${survey.testsExist ? "yes" : "no"}`);
-  lines.push("");
-  lines.push(`## 3. Locked contract (executable gate)`);
-  lines.push("");
-  if (lockedContract.symbols.length === 0) {
-    lines.push("- (no locked symbols for this kind — disciplined but permissive)");
-  } else {
-    for (const s2 of lockedContract.symbols) {
-      lines.push(`- \`${s2.kind} ${s2.name}\``);
-    }
-  }
-  lines.push("");
-  lines.push(`## 4. Definition of done (CompletionContract)`);
-  lines.push("");
-  lines.push(`- goal: ${completionContract.goalSummary || "(none)"}`);
-  for (const p2 of completionContract.phases ?? []) {
-    lines.push(`- phase: ${p2.label}`);
-  }
-  lines.push("");
-  lines.push(`## 5. Decomposition (SPLIT seed)`);
-  lines.push("");
-  for (const u of decomposition) {
-    lines.push(`- [${u.size}] ${u.label}${u.expectedSymbols?.length ? ` (symbols: ${u.expectedSymbols.join(", ")})` : ""}${u.evidenceRefs?.length ? ` [evidence: ${u.evidenceRefs.join(", ")}]` : ""}`);
-  }
-  lines.push("");
-  lines.push(`## 6. Verification bar`);
-  lines.push("");
-  lines.push("- planner emits real artefacts (this file + locked contract + completion contract)");
-  lines.push("- approval gate blocks before any source edit");
-  lines.push("- WO-6 executor gate activates on locked symbols");
-  lines.push("- recursion + eviction keep context bounded");
-  lines.push("- scope token re-prompts on out-of-scope work");
-  lines.push("");
-  lines.push(`## 7. Handoff notes`);
-  lines.push("");
-  lines.push("- Compose, do not rebuild: this plan reuses spec-gate + completionContract primitives.");
-  lines.push("- Fail-closed: if planning errors, the run falls back to the general agentic loop.");
-  lines.push("");
-  return lines.join("\n");
-}
-async function planFeature(survey, options2 = {}) {
-  const kind = classifyKind(survey);
-  const lockedContract = buildLockedContract(kind, survey);
-  const completionContract = inferCompletionContractFromTexts([survey.request, ...survey.rawTexts ?? [], ...survey.signals ?? []], survey.request);
-  const decomposition = decomposeFeature(survey, kind);
-  let prose = "";
-  try {
-    if (options2.proseGenerator) {
-      prose = await options2.proseGenerator({ request: survey.request, kind, survey });
-    }
-  } catch {
-    prose = "";
-  }
-  const specMarkdown = renderSpecMarkdown({
-    kind,
-    survey,
-    lockedContract,
-    completionContract,
-    decomposition,
-    prose
-  });
-  return { kind, specMarkdown, lockedContract, completionContract, decomposition };
-}
-function persistPlannerArtefacts(rootId, artefact, stateDir) {
-  try {
-    const dir = path9.join(stateDir, "feature-tree", rootId);
-    fs7.mkdirSync(dir, { recursive: true });
-    fs7.writeFileSync(path9.join(dir, "spec.md"), artefact.specMarkdown, "utf8");
-    fs7.writeFileSync(path9.join(dir, "locked-contract.json"), JSON.stringify(artefact.lockedContract, null, 2), "utf8");
-    fs7.writeFileSync(path9.join(dir, "completion-contract.json"), JSON.stringify(artefact.completionContract, null, 2), "utf8");
-  } catch {
-  }
-}
-var init_featurePlanner = __esm({
-  "packages/orchestrator/dist/featurePlanner.js"() {
-    "use strict";
-    init_completionContract();
-  }
-});
-
-// packages/orchestrator/dist/featureApprovalGate.js
-function mintScopeToken(input) {
-  return {
-    rootId: input.rootId,
-    files: [...input.files ?? []],
-    symbols: input.lockedContract.symbols.map((s2) => s2.name),
-    nodeKinds: input.nodeKinds ?? ["new-module", "refactor", "bugfix", "wiring", "investigation"],
-    depthCap: input.depthCap
-  };
-}
-function isWithinScope(input) {
-  const { token } = input;
-  if (typeof input.depth === "number" && input.depth > token.depthCap) {
-    return false;
-  }
-  if (input.nodeKind && !token.nodeKinds.includes(input.nodeKind)) {
-    return false;
-  }
-  if (input.newSymbol && !token.symbols.includes(input.newSymbol)) {
-    return false;
-  }
-  if (input.file) {
-    const file = input.file;
-    const allowed = token.files.some((f2) => {
-      if (f2 === file)
-        return true;
-      if (f2.endsWith("/") && file.startsWith(f2))
-        return true;
-      if (f2.includes("*") && globMatch(f2, file))
-        return true;
-      return false;
-    });
-    if (!allowed)
-      return false;
-  }
-  return true;
-}
-function globMatch(pattern, value2) {
-  const re = new RegExp("^" + pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*") + "$");
-  return re.test(value2);
-}
-async function requestApproval(req3, ask2, options2 = {}) {
-  let decision2;
-  try {
-    const raw = await ask2(req3);
-    decision2 = raw === "approve" || raw === "edit" || raw === "reject" ? raw : "reject";
-  } catch {
-    decision2 = "reject";
-  }
-  if (decision2 === "approve") {
-    const token = mintScopeToken({
-      rootId: req3.rootId,
-      lockedContract: req3.lockedContract,
-      decomposition: req3.decomposition,
-      depthCap: req3.depthCap,
-      files: options2.files,
-      nodeKinds: options2.nodeKinds
-    });
-    return { decision: decision2, token };
-  }
-  return { decision: decision2 };
-}
-var init_featureApprovalGate = __esm({
-  "packages/orchestrator/dist/featureApprovalGate.js"() {
-    "use strict";
-  }
-});
-
-// packages/orchestrator/dist/featureNode.js
-import fs8 from "node:fs";
-import path10 from "node:path";
-function treePath(stateDir, rootId) {
-  return path10.join(stateDir, "feature-tree", `${rootId}.json`);
-}
-function saveFeatureTree(stateDir, rootId, nodes) {
-  try {
-    const file = treePath(stateDir, rootId);
-    fs8.mkdirSync(path10.dirname(file), { recursive: true });
-    fs8.writeFileSync(file, JSON.stringify(nodes, null, 2), "utf8");
-  } catch {
-  }
-}
-function loadFeatureTree(stateDir, rootId) {
-  try {
-    const file = treePath(stateDir, rootId);
-    if (!fs8.existsSync(file))
-      return null;
-    const raw = JSON.parse(fs8.readFileSync(file, "utf8"));
-    return raw && typeof raw === "object" ? raw : null;
-  } catch {
-    return null;
-  }
-}
-function newNodeId(depth, seed) {
-  const h = String(Math.abs(hashString2(seed)) % 1e9).padStart(9, "0");
-  return `fn-d${depth}-${h}`;
-}
-function hashString2(s2) {
-  let h = 0;
-  for (let i2 = 0; i2 < s2.length; i2++)
-    h = h * 31 + s2.charCodeAt(i2) | 0;
-  return h;
-}
-async function evictNode(node, ctx3, transcript) {
-  try {
-    await runTodoChunker({
-      inputs: {
-        todoId: node.id,
-        todoContent: node.request,
-        turnRange: [0, 0],
-        transcript: transcript || node.request,
-        toolCalls: [],
-        workingDirectory: ctx3.workingDirectory,
-        sessionId: ctx3.sessionId
-      },
-      callable: ctx3.summarizer ?? (async () => "")
-    });
-  } catch {
-  }
-}
-async function execUnit(unit, node, ctx3, contract, maxRegenerate) {
-  let result = await ctx3.executeUnit(unit, node);
-  if (!result.ok)
-    return false;
-  const expected = unit.expectedSymbols ?? [];
-  if (expected.length === 0) {
-    return true;
-  }
-  for (let attempt = 0; attempt <= maxRegenerate; attempt++) {
-    if (!result.path || result.source === void 0)
-      return false;
-    const verdict = evaluateExecutorStep({
-      unit: { path: result.path, source: result.source },
-      contract,
-      expectedSymbols: expected
-    });
-    if (verdict.decision === "accept")
-      return true;
-    if (verdict.decision === "replan")
-      return false;
-    result = await ctx3.executeUnit(unit, node);
-    if (!result.ok)
-      return false;
-  }
-  return false;
-}
-async function runFeatureNode(node, ctx3, options2, tree2 = {}) {
-  const maxRegenerate = options2.maxRegenerate ?? 2;
-  tree2[node.id] = node;
-  try {
-    const artefact = await planFeature(options2.survey, {
-      proseGenerator: options2.proseGenerator
-    });
-    node.kind = artefact.kind;
-    if (ctx3.onPlan) {
-      try {
-        await ctx3.onPlan(artefact);
-      } catch {
-      }
-    }
-    persistPlannerArtefacts(ctx3.rootId, artefact, ctx3.stateDir);
-    const mustAsk = node.depth === 0 || !node.scopeToken;
-    if (mustAsk && ctx3.askApproval) {
-      node.status = "awaiting_approval";
-      const outcome = await requestApproval({
-        rootId: ctx3.rootId,
-        request: node.request,
-        specMarkdown: artefact.specMarkdown,
-        lockedContract: artefact.lockedContract,
-        decomposition: artefact.decomposition,
-        depthCap: ctx3.depthCap
-      }, ctx3.askApproval, { files: options2.survey.files.map((f2) => f2.path) });
-      if (outcome.decision !== "approve") {
-        node.status = outcome.decision === "edit" ? "planned" : "rejected";
-        saveFeatureTree(ctx3.stateDir, ctx3.rootId, tree2);
-        return node;
-      }
-      node.scopeToken = outcome.token;
-    }
-    node.status = "approved";
-    node.status = "executing";
-    let allOk = true;
-    for (const unit of artefact.decomposition) {
-      if (unit.size === "large" && node.depth < ctx3.depthCap) {
-        const childId = newNodeId(node.depth + 1, unit.label + node.id);
-        const childRequest = buildFeatureUnitRequest({
-          unit,
-          parentRequest: node.request,
-          survey: options2.survey
-        });
-        const child = {
-          id: childId,
-          parentId: node.id,
-          depth: node.depth + 1,
-          request: childRequest,
-          kind: artefact.kind,
-          status: "planned",
-          scopeToken: node.scopeToken,
-          children: []
-        };
-        node.children.push(childId);
-        const childSurvey = {
-          ...options2.survey,
-          request: child.request
-        };
-        const childCtx = {
-          ...ctx3,
-          // children inherit the token; re-prompt only if they exceed scope
-          askApproval: (req3) => isWithinScope({
-            token: node.scopeToken,
-            depth: node.depth + 1,
-            nodeKind: artefact.kind
-          }) ? "approve" : ctx3.askApproval(req3)
-        };
-        const res = await runFeatureNode(child, childCtx, { ...options2, survey: childSurvey }, tree2);
-        if (res.status !== "completed")
-          allOk = false;
-        await evictNode(child, ctx3, child.request);
-      } else {
-        const ok3 = await execUnit(unit, node, ctx3, artefact.lockedContract, maxRegenerate);
-        if (!ok3)
-          allOk = false;
-      }
-    }
-    if (allOk) {
-      node.status = "completed";
-    } else {
-      node.status = "failed";
-    }
-    saveFeatureTree(ctx3.stateDir, ctx3.rootId, tree2);
-    return node;
-  } catch {
-    if (ctx3.runGeneralLoop) {
-      await ctx3.runGeneralLoop(node.request);
-      node.status = "completed";
-    } else {
-      node.status = "failed";
-    }
-    saveFeatureTree(ctx3.stateDir, ctx3.rootId, tree2);
-    return node;
-  }
-}
-function createRootFeatureNode(request) {
-  return {
-    id: newNodeId(0, request),
-    parentId: null,
-    depth: 0,
-    request,
-    kind: "new-module",
-    status: "planned",
-    children: []
-  };
-}
-var init_featureNode = __esm({
-  "packages/orchestrator/dist/featureNode.js"() {
-    "use strict";
-    init_featurePlanner();
-    init_featureApprovalGate();
-    init_spec_gate();
-    init_todo_context_chunker();
-  }
-});
-
 // packages/orchestrator/dist/preflightSnapshot.js
 var preflightSnapshot_exports = {};
 __export(preflightSnapshot_exports, {
@@ -590875,6 +590807,142 @@ function stripShellQuotedSegments(command) {
   }
   return out;
 }
+function extractClaimPathFragments(text2) {
+  const out = [];
+  const pathPattern = /\b(?:[\w.-]+\/[\w./-]+(?:\.[A-Za-z0-9]+)?|[\w.-]+\.[A-Za-z0-9]+)\b/g;
+  for (const match of text2.matchAll(pathPattern)) {
+    const value2 = sanitizeDelegationText(String(match[0] ?? ""), 260).trim();
+    if (!value2)
+      continue;
+    out.push(value2);
+  }
+  return [...new Set(out)];
+}
+function normalizeClaimPathSignal(raw) {
+  const normalized = raw.replace(/["'`]+/g, "").replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+/g, "/").trim().toLowerCase();
+  if (!normalized)
+    return "";
+  if (normalized.length < 4)
+    return "";
+  if (normalized.includes(".."))
+    return "";
+  if (/[\\s]/.test(normalized))
+    return "";
+  return normalized;
+}
+function isLikelyPathSignal(value2) {
+  if (!value2)
+    return false;
+  return value2.includes("/") || /\.[a-z0-9]+$/i.test(value2);
+}
+function collectClaimPathSignals(text2) {
+  const direct = extractClaimPathFragments(text2).map((value2) => normalizeClaimPathSignal(value2)).filter(isLikelyPathSignal);
+  const quoted = [...text2.matchAll(/["'`](.*?)["'`]/g)].map((match) => normalizeClaimPathSignal(String(match[1] ?? ""))).filter((value2) => isLikelyPathSignal(value2));
+  return [.../* @__PURE__ */ new Set([...direct, ...quoted])];
+}
+function matchHintToInventoryPath(path16, hint) {
+  const normalizedPath = normalizeClaimPathSignal(path16);
+  const normalizedHint = normalizeClaimPathSignal(hint);
+  if (!normalizedPath || !normalizedHint)
+    return false;
+  if (normalizedPath === normalizedHint)
+    return true;
+  if (normalizedPath.endsWith(`/${normalizedHint}`))
+    return true;
+  if (normalizedPath.endsWith(normalizedHint))
+    return true;
+  if (normalizedHint.includes("/") && normalizedPath.includes(normalizedHint))
+    return true;
+  const base3 = normalizedPath.split("/").at(-1) ?? "";
+  return base3 === normalizedHint;
+}
+function claimDiscoveryFallbackCandidates(files, maxCandidates) {
+  const ranked = [];
+  const nowMs = Date.now();
+  const maxAgeMs = 30 * 24 * 60 * 60 * 1e3;
+  for (const raw of files) {
+    const rawPath = String(raw.path ?? "").trim();
+    if (!rawPath || rawPath.startsWith(".omnius/"))
+      continue;
+    const normalized = rawPath.replace(/\s+/g, " ").trim().replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+/g, "/").toLowerCase();
+    if (normalized.length < 4 || normalized.includes(".."))
+      continue;
+    const chunks = normalized.split("/").filter(Boolean);
+    const depth = chunks.length || 1;
+    const reasons = [];
+    let score = 0;
+    score += Math.max(1, 12 - Math.min(depth, 10));
+    reasons.push("generic workspace proximity");
+    if (raw.bytes !== void 0) {
+      if (raw.bytes > 5e5)
+        score -= 3;
+      else if (raw.bytes > 8e4)
+        score -= 1;
+      if (raw.bytes > 5e5)
+        reasons.push("large artifact");
+      else if (raw.bytes > 8e4)
+        reasons.push("moderate artifact");
+      else
+        reasons.push("light payload");
+    }
+    if (raw.mtimeMs !== void 0 && raw.mtimeMs > 0) {
+      const age = nowMs - raw.mtimeMs;
+      if (age >= 0 && age < maxAgeMs) {
+        score += 2;
+        reasons.push("recently modified");
+      } else if (age < 0) {
+        score += 1;
+        reasons.push("fresh metadata");
+      } else {
+        reasons.push("older artifact");
+      }
+    }
+    const pathSignal = chunks.join("/");
+    if (!pathSignal)
+      continue;
+    ranked.push({
+      path: pathSignal,
+      score,
+      reasons: [...new Set(reasons)].slice(0, 3)
+    });
+  }
+  ranked.sort((left, right) => right.score !== left.score ? right.score - left.score : left.path.localeCompare(right.path));
+  const fallback = [];
+  for (const entry of ranked) {
+    if (fallback.length >= maxCandidates)
+      break;
+    const canonical2 = entry.path.replace(/\\/g, "/").replace(/\/+/g, "/").replace(/^\.\//, "").trim().toLowerCase();
+    if (canonical2.length < 4 || canonical2.includes(".."))
+      continue;
+    if (fallback.some((candidate) => candidate.path === canonical2))
+      continue;
+    fallback.push({
+      path: canonical2,
+      reasons: entry.reasons.length > 0 ? entry.reasons : ["generic workspace candidate"]
+    });
+  }
+  return fallback;
+}
+function extractClaimTaskTokens(text2) {
+  return String(text2 ?? "").toLowerCase().replace(/["'`]/g, " ").replace(/[^\w./-]+/g, " ").split(/\s+/).map((value2) => value2.trim()).filter((value2) => value2.length >= 4 && value2.length <= 80 && /[a-z0-9]/i.test(value2)).slice(0, 80);
+}
+function isMeaningfulClaimTaskToken(token) {
+  if (!token)
+    return false;
+  const normalized = token.toLowerCase();
+  if (normalized.length < 4 || normalized.length > 80)
+    return false;
+  if (!/[a-z0-9]/i.test(normalized))
+    return false;
+  if (CLAIM_TASK_STOPWORDS.has(normalized))
+    return false;
+  return true;
+}
+function chunkHasSymbolMatch(token, text2) {
+  const haystack = text2.toLowerCase().replace(/[^a-z0-9]+/g, " ");
+  const tokens = haystack.split(" ").filter(Boolean);
+  return tokens.includes(token);
+}
 function isCompilerLikeVerifierCommand(command) {
   const normalized = command.toLowerCase();
   return /\b(?:pio|platformio|tsc|gcc|g\+\+|clang\+\+?|clang|cargo\s+(?:build|check)|go\s+(?:build|test)|javac|gradle|mvn|msbuild|dotnet\s+build|python(?:3)?\s+-m\s+(?:py_compile|compileall)|mypy|pyright)\b/.test(normalized);
@@ -591617,7 +591685,7 @@ function classifyThinkOutcome(raw) {
   }
   return null;
 }
-var PRESERVE_MODEL_VISIBLE_HISTORY, TOOL_SUBSETS, TOOL_AUTO_DEMOTE_TURNS, LEGACY_ACTION_REASON_KEYS, SYSTEM_PROMPT, SYSTEM_PROMPT_MEDIUM, SYSTEM_PROMPT_SMALL, VISUAL_TOOLS, AUDIO_TOOLS, SOCIAL_TOOLS, SPATIAL_TOOLS, CODE_TOOLS, AgenticRunner, OllamaAgenticBackend;
+var PRESERVE_MODEL_VISIBLE_HISTORY, TOOL_SUBSETS, TOOL_AUTO_DEMOTE_TURNS, LEGACY_ACTION_REASON_KEYS, CLAIM_TASK_STOPWORDS, SYSTEM_PROMPT, SYSTEM_PROMPT_MEDIUM, SYSTEM_PROMPT_SMALL, VISUAL_TOOLS, AUDIO_TOOLS, SOCIAL_TOOLS, SPATIAL_TOOLS, CODE_TOOLS, AgenticRunner, OllamaAgenticBackend;
 var init_agenticRunner = __esm({
   "packages/orchestrator/dist/agenticRunner.js"() {
     "use strict";
@@ -591699,8 +591767,6 @@ var init_agenticRunner = __esm({
     init_prompt_cache();
     init_compile_error_fix_loop();
     init_git_progress();
-    init_featurePlanner();
-    init_featureNode();
     PRESERVE_MODEL_VISIBLE_HISTORY = /* @__PURE__ */ Symbol("omnius.preserveModelVisibleHistory");
     TOOL_SUBSETS = {
       web: ["web_search", "web_fetch", "web_crawl"],
@@ -591727,6 +591793,79 @@ var init_agenticRunner = __esm({
     };
     TOOL_AUTO_DEMOTE_TURNS = 10;
     LEGACY_ACTION_REASON_KEYS = /* @__PURE__ */ new Set(["action_reason", "actionReason"]);
+    CLAIM_TASK_STOPWORDS = /* @__PURE__ */ new Set([
+      "this",
+      "that",
+      "these",
+      "those",
+      "there",
+      "where",
+      "from",
+      "with",
+      "what",
+      "when",
+      "then",
+      "help",
+      "please",
+      "request",
+      "about",
+      "their",
+      "would",
+      "could",
+      "should",
+      "might",
+      "issue",
+      "issues",
+      "bug",
+      "problem",
+      "problems",
+      "task",
+      "tasks",
+      "run",
+      "build",
+      "make",
+      "need",
+      "needs",
+      "also",
+      "only",
+      "same",
+      "other",
+      "code",
+      "file",
+      "files",
+      "repo",
+      "project",
+      "workspace",
+      "read",
+      "fix",
+      "add",
+      "remove",
+      "create",
+      "review",
+      "check",
+      "report",
+      "inspect",
+      "update",
+      "implement",
+      "setup",
+      "install",
+      "deploy",
+      "run",
+      "get",
+      "set",
+      "open",
+      "close",
+      "start",
+      "stop",
+      "turn",
+      "off",
+      "on",
+      "enable",
+      "disable",
+      "add",
+      "new",
+      "old"
+    ]);
     SYSTEM_PROMPT = loadPrompt("agentic/system-large.md");
     SYSTEM_PROMPT_MEDIUM = loadPrompt("agentic/system-medium.md");
     SYSTEM_PROMPT_SMALL = loadPrompt("agentic/system-small.md");
@@ -592024,8 +592163,6 @@ var init_agenticRunner = __esm({
       _wideExplorationCooldownUntilTurn = -1;
       /** REG-44: how many times the stuck detector has fired (for adaptive cooldown). */
       _reg44FireCount = 0;
-      /** Guard against re-entering the feature loop. */
-      _inFeatureLoop = false;
       // REG-45: sticky cross-turn escalation. The dispatch-time reflection
       // surface (REG-26) only fires when the agent re-emits the exact same
       // failed stem. If the agent thrashes on OTHER tools (wide-exploration
@@ -592145,6 +592282,7 @@ var init_agenticRunner = __esm({
        */
       _completionCaveat = null;
       _completionLedger = null;
+      _claimDiscoveryInitialized = false;
       _staleEditFamilies = /* @__PURE__ */ new Map();
       /** Semantic retry counter for blocked full-file writes (payload-independent). */
       _blockedFullWriteAttempts = /* @__PURE__ */ new Map();
@@ -593518,7 +593656,9 @@ ${parts.join("\n")}
             success: input.status === "completed",
             output: `terminal_receipt=${record.id}
 marker=${markerPath}
-evidence=${record.evidenceIds.join(",") || "none"}`
+evidence=${record.evidenceIds.join(",") || "none"}
+command_receipts=${record.commandReceipts.length}
+` + (record.commandReceipts.length > 0 ? `command_receipts_summary=${record.commandReceipts.map((entry) => `${entry.canonicalCommand || entry.command || "n/a"}:${entry.exitCode}`).join(" | ")}` : "command_receipts_summary=none")
           });
           commitTerminalTrajectoryProjection(stateDir, record, input.trajectoryPayload);
           const committed = {
@@ -593610,6 +593750,7 @@ evidence=${record.evidenceIds.join(",") || "none"}`
           disableAdversaryCritic,
           disableStepCritic: disableAdversaryCritic,
           modelTier: options2?.modelTier ?? "large",
+          claimDiscovery: options2?.claimDiscovery,
           referenceContractModules: options2?.referenceContractModules ?? [],
           contextWindowSize: options2?.contextWindowSize ?? 0,
           recursionDepth: options2?.recursionDepth ?? 0,
@@ -597037,7 +597178,7 @@ ${extras.join("\n")}`;
           const paths = args["edits"].map((edit) => edit && typeof edit === "object" ? edit["path"] : null).filter((p3) => typeof p3 === "string" && p3.trim().length > 0);
           return [...new Set(paths)];
         }
-        const p2 = args?.["path"] ?? args?.["file_path"] ?? args?.["file"] ?? args?.["filename"] ?? args?.["filepath"] ?? args?.["filePath"];
+        const p2 = args?.["path"] ?? args?.["file_path"] ?? args?.["file"] ?? args?.["filename"] ?? args?.["filepath"] ?? args?.["filePath"] ?? args?.["input"] ?? args?.["target"];
         return typeof p2 === "string" && p2.trim().length > 0 ? [p2.trim()] : [];
       }
       _isRealProjectMutation(toolName, result) {
@@ -597178,6 +597319,9 @@ ${modelVisible}` : modelVisible || result.error || displayOutput || "";
           metrics: input.result.completionEvidenceMetrics,
           receipt
         });
+        if (this._completionLedger?.claimDiscovery) {
+          this._refreshClaimDiscoveryStateFromEvidence();
+        }
         if (realFileMutation && realMutationPaths.length > 0) {
           for (const filePath of realMutationPaths) {
             this._completionLedger = recordCompletionEvidence(this._completionLedger, {
@@ -597194,6 +597338,50 @@ ${modelVisible}` : modelVisible || result.error || displayOutput || "";
         }
         this._saveCompletionLedgerSafe();
       }
+      _refreshClaimDiscoveryStateFromEvidence() {
+        if (!this._completionLedger?.claimDiscovery)
+          return;
+        const state = this._completionLedger.claimDiscovery;
+        const evidenceHandles = state.evidenceHandles ?? [];
+        const survivingBlockers = state.survivingBlockers ?? [];
+        const unresolvedQuestions = state.unresolvedQuestions ?? [];
+        const openDeltas = state.openDeltas ?? [];
+        const resolved = claimDiscoveryResolvedHandles(this._completionLedger, state);
+        const unresolvedEvidence = evidenceHandles.filter((handle2) => !resolved.includes(handle2));
+        const unresolvedHandleSet = new Set(unresolvedEvidence);
+        const unresolvedOpenDeltas = openDeltas.filter((delta) => {
+          const normalizedDeltaPath = this._normalizeEvidencePath(delta.path).replace(/^\/+/, "");
+          const handle2 = `workspace:${normalizedDeltaPath}`;
+          return unresolvedHandleSet.has(handle2);
+        });
+        const hasBlockers = survivingBlockers.length > 0;
+        const hasCandidates = state.candidatePaths.length > 0;
+        const hasOpenQuestions = unresolvedQuestions.length > 0;
+        const hasOpenEvidence = unresolvedEvidence.length > 0;
+        let status;
+        if (!hasCandidates) {
+          status = hasBlockers || hasOpenQuestions ? "blocked" : "skipped";
+        } else if (hasOpenEvidence || hasOpenQuestions || hasBlockers) {
+          status = hasOpenQuestions || hasBlockers ? "blocked" : "active";
+        } else {
+          status = "complete";
+        }
+        const updated = {
+          ...this._completionLedger,
+          claimDiscovery: {
+            ...state,
+            openDeltas: unresolvedOpenDeltas,
+            resolvedEvidenceHandles: resolved,
+            evidenceHandles,
+            survivingBlockers,
+            unresolvedQuestions,
+            status
+          }
+        };
+        this._completionLedger = updated;
+        this._saveCompletionLedgerSafe();
+        return updated.claimDiscovery;
+      }
       _completionArtifactHashes(paths) {
         const unique3 = [...new Set(paths.map((path16) => this._normalizeEvidencePath(path16)).filter(Boolean))].slice(0, 20);
         const out = [];
@@ -597946,15 +598134,18 @@ ${readOnlyLines.join("\n")}` : "Successful read-only evidence: none"
         }
         const timeoutMs = parseInt(process.env["OMNIUS_COMPLETION_VERIFY_TIMEOUT_MS"] || "180000", 10) || 18e4;
         const wd = this._workingDirectory || process.cwd();
+        const hasPipe = cmd.includes("|");
+        const startedAtIso = (/* @__PURE__ */ new Date()).toISOString();
         this.emit({
           type: "status",
           content: `completion verify gate: running '${cmd}' (cwd=${wd})`,
           turn,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         });
-        const { exitCode, outTail } = await new Promise((resolve84) => {
+        const { exitCode, outTail, timedOut, finishedAtIso } = await new Promise((resolve84) => {
           const chunks = [];
           let settled = false;
+          let hitTimeout = false;
           const child = _spawn(cmd, {
             cwd: wd,
             shell: true,
@@ -597970,6 +598161,7 @@ ${readOnlyLines.join("\n")}` : "Successful read-only evidence: none"
           child.stderr?.on("data", onData);
           const killTimer = setTimeout(() => {
             try {
+              hitTimeout = true;
               child.kill("SIGKILL");
             } catch {
             }
@@ -597980,11 +598172,31 @@ ${readOnlyLines.join("\n")}` : "Successful read-only evidence: none"
               return;
             settled = true;
             clearTimeout(killTimer);
-            resolve84({ exitCode: code8, outTail: chunks.join("").slice(-4e3) });
+            resolve84({
+              exitCode: code8,
+              outTail: chunks.join("").slice(-4e3),
+              timedOut: hitTimeout,
+              finishedAtIso: (/* @__PURE__ */ new Date()).toISOString()
+            });
           };
           child.on("error", () => finish(1));
           child.on("close", (code8) => finish(code8 ?? 1));
         });
+        const commandReceipt = {
+          schema: "omnius.command-evidence-receipt.v1",
+          command: cmd,
+          canonicalCommand: "",
+          cwd: wd,
+          exitCode,
+          pipefail: hasPipe,
+          timedOut,
+          startedAtIso,
+          finishedAtIso,
+          artifactHashes: this._completionArtifactHashes([
+            ...this._taskState.modifiedFiles.keys()
+          ])
+        };
+        commandReceipt.canonicalCommand = canonicalVerificationIdentity(cmd, commandReceipt) ?? normalizeShellCommand(cmd) ?? cmd;
         if (this._completionLedger) {
           this._completionLedger = recordCompletionEvidence(this._completionLedger, {
             kind: "tool_result",
@@ -597992,9 +598204,11 @@ ${readOnlyLines.join("\n")}` : "Successful read-only evidence: none"
             success: exitCode === 0,
             summary: `completion verify command exited ${exitCode}: ${cmd}
 ${outTail || "(no output captured)"}`,
+            receipt: commandReceipt,
             role: "verification",
             family: "completion_verify"
           });
+          this._refreshClaimDiscoveryResolvedHandles();
           this._saveCompletionLedgerSafe();
         }
         const compileGuidance = this._observeCompileVerifierResult({
@@ -598052,7 +598266,8 @@ ${compileGuidance}` : ""
           const _newClaims = deriveClaimsFromProposedText({
             text: proposedSummary,
             source: "task_complete_summary",
-            existing: this._completionLedger.proposedClaims
+            existing: this._completionLedger.proposedClaims,
+            workspaceInventory: this._completionLedger.claimDiscovery?.boundedInventory
           });
           if (_newClaims.length > 0) {
             this._completionLedger = addCompletionClaims(this._completionLedger, _newClaims);
@@ -598062,7 +598277,10 @@ ${compileGuidance}` : ""
           try {
             const _audit = auditCompletionClaims(this._completionLedger.proposedClaims.map((c9) => ({
               text: c9.text,
-              status: c9.status
+              status: c9.status,
+              riskCategory: c9.riskCategory === "unknown" || c9.riskCategory === "coverage" ? null : c9.riskCategory,
+              requiresIndependentEvidence: c9.requiresIndependentEvidence,
+              requiredCheck: c9.requiredCheck
             })));
             if (!_audit.ok) {
               const _checks = _audit.blockers.map((b) => `• [${b.category}] "${b.claim}" → ${b.requiredCheck}`).join("\n");
@@ -598286,8 +598504,9 @@ ${_checks}`
               verdict: "approve",
               rationale: result.verdict.rationale
             });
-            this._saveCompletionLedgerSafe();
           }
+          this._saveCompletionLedgerSafe();
+          this._refreshClaimDiscoveryResolvedHandles();
           this._lastBackwardPassCritique = null;
           return { proceed: true };
         }
@@ -598357,6 +598576,9 @@ ${_checks}`
         }
         return { proceed: false, feedback };
       }
+      _refreshClaimDiscoveryResolvedHandles() {
+        this._refreshClaimDiscoveryStateFromEvidence();
+      }
       /**
        * WO-META-TRACK — Hannover-style turn-counter reminder.
        *
@@ -602241,6 +602463,7 @@ ${notice}`;
           runId: this.currentArtifactRunId(),
           goal: record.content
         }) : null;
+        this._claimDiscoveryInitialized = false;
         if (this._completionLedger) {
           this._completionLedger.taskEpoch = this._taskEpoch;
         }
@@ -603270,111 +603493,210 @@ ${rawTask}`;
         return next;
       }
       /**
-       * Feature Loop used to classify and split from the raw user sentence.  Build
-       * a small, model-selected survey first instead: the model sees only an
-       * inventory of paths (not invented contents), chooses candidate files, and
-       * names the facts that still require file_read before any unit can mutate.
-       * Returning null deliberately falls back to the ordinary tool loop rather
-       * than recreating the old task-label-only Feature Loop.
+       * Claim-discovery uses task + bounded workspace inventory before any mutation.
+       * It remains task-centered and product-agnostic: no protocol-specific
+       * heuristics, no model-inferred domain taxonomy, no filename-category
+       * inference. Candidate grounding is deterministic from task + bounded inventory
+       * signals only.
        */
-      async _resolveFeatureSurvey(task, context2, turn) {
-        if (process.env["OMNIUS_FEATURE_SURVEY_GROUNDING"] === "0")
-          return null;
+      async _resolveClaimDiscoverySurvey(task, turn) {
+        if (process.env["OMNIUS_FEATURE_SURVEY_GROUNDING"] === "0") {
+          return claimDiscoveryStateFromSurvey({
+            request: task,
+            boundedInventory: {
+              root: this.authoritativeWorkingDirectory(),
+              files: [],
+              dirs: [],
+              truncated: true,
+              maxFiles: 0,
+              maxDirs: 0,
+              generatedAtIso: (/* @__PURE__ */ new Date()).toISOString()
+            },
+            candidatePaths: [],
+            pathReasons: {},
+            unresolvedQuestions: [],
+            survivingBlockers: [
+              "Claim discovery is currently disabled by OMNIUS_FEATURE_SURVEY_GROUNDING=0."
+            ],
+            requiresEvidence: false
+          });
+        }
         const root = this.authoritativeWorkingDirectory();
-        let workspaceFiles = [];
-        try {
-          workspaceFiles = scanWorkspace({ root, maxFiles: 320, maxDirs: 800 }).files.map((file) => ({ rel: file.rel, bytes: file.bytes }));
+        const maxFiles = Math.max(80, Math.min(420, Number.parseInt(process.env["OMNIUS_CLAIM_DISCOVERY_MAX_FILES"] || "240", 10) || 240));
+        const maxDirs = Math.max(60, Math.min(1200, Number.parseInt(process.env["OMNIUS_CLAIM_DISCOVERY_MAX_DIRS"] || "300", 10) || 300));
+        let boundedInventory = null;
+        try {
+          const workspace = scanWorkspace({ root, maxFiles, maxDirs });
+          const files = workspace.files.slice(0, maxFiles).map((file) => ({
+            path: file.rel,
+            bytes: file.bytes,
+            mtimeMs: file.mtimeMs
+          })).filter((file) => !file.path.startsWith(".omnius/"));
+          boundedInventory = {
+            root,
+            files,
+            dirs: workspace.dirs.slice(0, maxDirs).map((dir) => dir.rel),
+            truncated: workspace.truncated,
+            maxFiles,
+            maxDirs,
+            generatedAtIso: (/* @__PURE__ */ new Date()).toISOString()
+          };
         } catch {
-          return null;
-        }
-        if (workspaceFiles.length === 0)
-          return null;
-        const allowedPaths = new Set(workspaceFiles.map((file) => file.rel));
-        const ledgerEvidence = this._evidenceLedger.snapshot(12).map((entry) => ({
-          ref: `read:${entry.path}`,
-          detail: `${entry.path} was read at turn ${entry.lastReadTurn}${entry.stale ? " and is now stale" : ""}.`,
-          freshness: entry.stale ? "stale" : "fresh"
-        }));
-        const inventory = workspaceFiles.slice(0, 320).map((file) => `${file.rel} (${file.bytes} bytes)`).join("\n");
-        const prompt = [
-          "You are Omnius's feature survey grounder. Return JSON only; do not provide chain-of-thought.",
-          "You have file-existence metadata, not source contents. Select only candidate paths from the provided inventory and state what must be inspected before any mutation. Do not claim code behavior, APIs, or test results from a filename.",
-          "Schema:",
-          JSON.stringify({
-            candidate_paths: ["exact allowed relative path, 1-8 items"],
-            path_reasons: { "path": "why this is a candidate, based only on request/inventory" },
-            unresolved_questions: ["specific source fact to inspect before edit"],
-            new_symbols: ["only explicitly requested symbols, if any"],
-            existing_symbols: ["only symbols named in supplied context, if any"],
-            tests_exist: false,
-            public_surface_changes: false
-          }),
-          `Task:
-${sanitizeDelegationText(task, 1400)}`,
-          context2 ? `Parent context (may be stale; verify):
-${sanitizeDelegationText(context2, 1200)}` : "",
-          ledgerEvidence.length ? `Fresh/stale reads already observed:
-${ledgerEvidence.map((item) => `- [${item.freshness}] ${item.ref}: ${item.detail}`).join("\n")}` : "No source files have been read in this run yet.",
-          `Allowed workspace inventory:
-${inventory}`
-        ].filter(Boolean).join("\n\n");
-        try {
-          this._emitModelResolutionTelemetry("feature_survey_grounding", turn);
-          const backend = this._auxInferenceBackend({
-            dumpStage: "feature_survey_grounding"
-          });
-          const response = await backend.chatCompletion({
-            messages: [
-              {
-                role: "system",
-                content: "Return only valid JSON matching the requested schema. Never invent a path or infer file content from its name."
-              },
-              { role: "user", content: prompt }
+          return claimDiscoveryStateFromSurvey({
+            request: task,
+            boundedInventory: {
+              root,
+              files: [],
+              dirs: [],
+              truncated: true,
+              maxFiles,
+              maxDirs,
+              generatedAtIso: (/* @__PURE__ */ new Date()).toISOString()
+            },
+            candidatePaths: [],
+            pathReasons: {},
+            unresolvedQuestions: [
+              "Workspace scan failed for bounded inventory grounding; retry with explicit target paths."
             ],
-            tools: [],
-            temperature: 0.1,
-            maxTokens: 900,
-            timeoutMs: Math.max(5e3, Math.min(this.options.requestTimeoutMs, 25e3)),
-            think: false
+            survivingBlockers: [
+              "Claim discovery cannot anchor evidence without a successful workspace inventory scan."
+            ],
+            requiresEvidence: false
           });
-          const raw = response.choices?.[0]?.message?.content ?? "";
-          const json = raw.match(/```(?:json)?\s*([\s\S]*?)```/)?.[1] ?? raw.match(/\{[\s\S]*\}/)?.[0] ?? "";
-          const parsed = JSON.parse(json);
-          const requestedPaths = Array.isArray(parsed["candidate_paths"]) ? parsed["candidate_paths"].map((value2) => String(value2).trim()).filter((value2) => allowedPaths.has(value2)).slice(0, 8) : [];
-          if (requestedPaths.length === 0)
-            return null;
-          const reasons = parsed["path_reasons"] && typeof parsed["path_reasons"] === "object" ? parsed["path_reasons"] : {};
-          const stringList3 = (value2, cap, maxChars) => Array.isArray(value2) ? value2.map((item) => sanitizeDelegationText(item, maxChars)).filter(Boolean).slice(0, cap) : [];
-          const selectedEvidence2 = requestedPaths.map((file) => ({
-            ref: `workspace:${file}`,
-            detail: sanitizeDelegationText(reasons[file], 280) || "Selected from the workspace inventory; source contents remain uninspected.",
-            freshness: "unknown"
-          }));
-          const unresolvedQuestions = stringList3(parsed["unresolved_questions"], 6, 260);
-          if (unresolvedQuestions.length === 0) {
-            unresolvedQuestions.push("Read the selected source and its nearest tests/callers to establish the exact implementation contract before editing.");
-          }
-          return {
+        }
+        if (!boundedInventory || boundedInventory.files.length === 0) {
+          return claimDiscoveryStateFromSurvey({
             request: task,
-            files: requestedPaths.map((path16) => ({
-              path: path16,
-              role: sanitizeDelegationText(reasons[path16], 180) || "candidate selected from workspace inventory"
-            })),
-            signals: [
-              "Feature survey candidates were generated from the current workspace inventory.",
-              ...unresolvedQuestions
+            boundedInventory: boundedInventory ?? {
+              root,
+              files: [],
+              dirs: [],
+              truncated: true,
+              maxFiles,
+              maxDirs,
+              generatedAtIso: (/* @__PURE__ */ new Date()).toISOString()
+            },
+            candidatePaths: [],
+            pathReasons: {},
+            unresolvedQuestions: [
+              "Bounded workspace inventory was empty; provide concrete target artifacts before claiming completion."
             ],
-            rawTexts: [task, context2 ?? ""],
-            evidence: [...ledgerEvidence, ...selectedEvidence2].slice(0, 14),
-            unresolvedQuestions,
-            newSymbols: stringList3(parsed["new_symbols"], 8, 120),
-            existingSymbols: stringList3(parsed["existing_symbols"], 8, 120),
-            testsExist: parsed["tests_exist"] === true,
-            publicSurfaceChanges: parsed["public_surface_changes"] === true
-          };
-        } catch {
-          return null;
+            survivingBlockers: ["No bounded inventory files were discoverable."],
+            requiresEvidence: false
+          });
+        }
+        const boundedInventoryPaths = boundedInventory.files.map((file) => file.path);
+        const allowedPaths = new Set(boundedInventoryPaths);
+        const pathReasons = /* @__PURE__ */ Object.create(null);
+        const normalizedTask = sanitizeDelegationText(task, 1500);
+        const taskTokens = extractClaimTaskTokens(task);
+        const meaningfulTaskTokens = taskTokens.filter(isMeaningfulClaimTaskToken);
+        const explicitPathHints = collectClaimPathSignals(task).map((token) => token.toLowerCase()).slice(0, 80);
+        const unmatchedHints = new Set(explicitPathHints);
+        const scored = [];
+        for (const path16 of boundedInventoryPaths) {
+          const lowerPath = path16.toLowerCase();
+          const lowerBase = (path16.split("/").at(-1) ?? "").toLowerCase();
+          const chunks = lowerPath.split("/").filter(Boolean);
+          let score = 0;
+          const reasons = [];
+          for (const hint of explicitPathHints) {
+            if (!matchHintToInventoryPath(path16, hint))
+              continue;
+            unmatchedHints.delete(hint);
+            score += 120;
+            reasons.push(`explicit path hint "${hint}" matches path`);
+          }
+          for (const token of meaningfulTaskTokens) {
+            const lowerToken = token.toLowerCase();
+            if (lowerToken.length < 4)
+              continue;
+            if (chunks.some((chunk) => chunk === lowerToken)) {
+              score += 40;
+              reasons.push(`segment token match (${lowerToken})`);
+            } else if (lowerPath.includes(lowerToken)) {
+              score += 14;
+              reasons.push(`path includes task token (${lowerToken})`);
+            } else if (chunkHasSymbolMatch(lowerToken, lowerBase)) {
+              score += 6;
+              reasons.push(`base symbol overlap (${lowerToken})`);
+            }
+          }
+          if (score > 0) {
+            scored.push({
+              path: path16,
+              score,
+              reasons: [...new Set(reasons)].slice(0, 3)
+            });
+          }
+        }
+        scored.sort((left, right) => right.score !== left.score ? right.score - left.score : left.path.localeCompare(right.path));
+        const rankedCandidates = scored.filter((entry) => entry.score > 0).map((entry) => entry.path).slice(0, 12);
+        const explicitCandidates = explicitPathHints.flatMap((token) => boundedInventoryPaths.filter((path16) => matchHintToInventoryPath(path16, token))).filter((path16) => allowedPaths.has(path16)).slice(0, 12);
+        const candidateSeeds = explicitCandidates.length > 0 ? explicitCandidates : rankedCandidates;
+        const candidatePaths = [.../* @__PURE__ */ new Set([...candidateSeeds, ...rankedCandidates])].slice(0, 8);
+        const shouldUseFallbackCandidates = explicitPathHints.length === 0 && candidatePaths.length === 0;
+        const fallbackCandidates = shouldUseFallbackCandidates ? claimDiscoveryFallbackCandidates(boundedInventory.files, Math.max(4, Math.min(8, maxFiles ? Math.min(8, maxFiles) : 8))) : [];
+        let finalCandidatePaths = candidatePaths.length > 0 ? candidatePaths : fallbackCandidates.map((entry) => entry.path);
+        if (candidatePaths.length === 0 && fallbackCandidates.length > 0) {
+          for (const candidate of fallbackCandidates) {
+            if (!pathReasons[candidate.path]) {
+              pathReasons[candidate.path] = candidate.reasons.join("; ");
+            }
+          }
+        }
+        if (finalCandidatePaths.length === 0 && boundedInventory.files.length > 0) {
+          const boundedPaths = boundedInventory.files.map((file) => String(file.path ?? "")).map((path16) => path16.trim()).filter((path16) => path16.length >= 4 && path16.length <= 800).filter((path16) => !path16.startsWith(".omnius/"));
+          const candidateWithDir = boundedPaths.filter((path16) => path16.includes("/")).slice(0, 4);
+          finalCandidatePaths = (candidateWithDir.length > 0 ? candidateWithDir : boundedPaths).slice(0, 4);
+          for (const candidate of finalCandidatePaths) {
+            if (!pathReasons[candidate]) {
+              pathReasons[candidate] = "selected from bounded inventory fallback";
+            }
+          }
         }
+        if (finalCandidatePaths.length === 0) {
+          const hasUnmatchedHints = unmatchedHints.size > 0;
+          const unresolvedQuestions2 = hasUnmatchedHints ? [
+            normalizedTask.length < 5 ? "Task text is too short to anchor evidence safely." : `No grounded candidate source path was identified for explicit task hints (${[...unmatchedHints].slice(0, 4).join(", ")}).`,
+            "Read from declared artifacts before claiming completion."
+          ] : [];
+          const survivingBlockers2 = unmatchedHints.size > 0 ? [
+            `No bounded inventory artifact matched explicit task hints: ${[...unmatchedHints].slice(0, 4).join(", ")}`
+          ] : [];
+          return claimDiscoveryStateFromSurvey({
+            request: task,
+            boundedInventory,
+            candidatePaths: [],
+            pathReasons: {},
+            unresolvedQuestions: unresolvedQuestions2,
+            survivingBlockers: survivingBlockers2,
+            requiresEvidence: explicitPathHints.length > 0
+          });
+        }
+        for (const candidate of finalCandidatePaths) {
+          const details = scored.find((entry) => entry.path === candidate);
+          if (!pathReasons[candidate]) {
+            pathReasons[candidate] = details && details.reasons.length > 0 ? details.reasons.join("; ") : unmatchedHints.size > 0 ? "selected from explicit task hints plus inventory" : meaningfulTaskTokens.length === 0 ? "selected from bounded inventory fallback" : "selected from bounded request signals and inventory";
+          }
+        }
+        const unresolvedQuestions = unmatchedHints.size > 0 ? [
+          `Unresolved explicit task hints remain unmatched: ${[...unmatchedHints].slice(0, 3).join(", ")}.`,
+          "If task intent changed, restate target artifacts in the user message."
+        ] : [];
+        const survivingBlockers = unmatchedHints.size > 0 ? [
+          `Unmatched explicit task hints: ${[...unmatchedHints].slice(0, 3).join(", ")}`
+        ] : [];
+        const shouldRequireEvidence = finalCandidatePaths.length > 0 && (explicitPathHints.length > 0 || rankedCandidates.length > 0);
+        return claimDiscoveryStateFromSurvey({
+          request: task,
+          boundedInventory,
+          candidatePaths: finalCandidatePaths,
+          pathReasons,
+          unresolvedQuestions,
+          survivingBlockers,
+          requiresEvidence: shouldRequireEvidence
+        });
       }
       /**
        * Rebuild the one current checkpoint at the context boundary. This shared
@@ -603701,6 +604023,7 @@ Respond with the assessment and take the selected evidence-backed action.`;
         this._completionIncompleteVerification = null;
         this._completionCaveat = null;
         this._completionLedger = null;
+        this._claimDiscoveryInitialized = false;
         this._focusTerminalLedgerRecorded = false;
         this._resetTaskScopedVerifierState();
         this._staleEditFamilies.clear();
@@ -604001,6 +604324,7 @@ Respond with the assessment and take the selected evidence-backed action.`;
             runId: this._activeRunId || this._sessionId,
             goal: userGoal
           });
+          this._claimDiscoveryInitialized = false;
           this._completionLedger.taskEpoch = this._taskEpoch;
         } else {
           this._completionContract = null;
@@ -604685,6 +605009,44 @@ ${dynamicProjectContext}`
           });
           return true;
         };
+        const holdClaimDiscoveryTaskComplete = (turn) => {
+          const ledger = this._completionLedger;
+          if (!ledger?.claimDiscovery)
+            return false;
+          this._refreshClaimDiscoveryStateFromEvidence();
+          const state = this._completionLedger?.claimDiscovery;
+          if (!state)
+            return false;
+          const evidenceHandles = state.evidenceHandles ?? [];
+          const unresolvedQuestions = state.unresolvedQuestions ?? [];
+          const resolved = claimDiscoveryResolvedHandles(ledger, state);
+          const unresolved = evidenceHandles.filter((handle2) => !resolved.includes(handle2));
+          const blockers = state.survivingBlockers ?? [];
+          const openDeltas = state.openDeltas ?? [];
+          const hasOpenDiscoveryWork = unresolved.length > 0 || blockers.length > 0 || unresolvedQuestions.length > 0;
+          const shouldHold = (state.status === "active" || state.status === "blocked") && hasOpenDiscoveryWork && state.requiresEvidence !== false;
+          if (!shouldHold) {
+            return false;
+          }
+          const feedback = [
+            "[COMPLETION BLOCKED — evidence discovery incomplete]",
+            `Open claim-discovery deltas: ${openDeltas.map((item) => `${item.path} :: ${item.reason}`).join(" | ") || "none"}`,
+            `Outstanding evidence handles: ${unresolved.join(" | ") || "none"}`,
+            ...blockers.length > 0 ? [`Surviving blockers: ${blockers.join(" | ")}`] : [],
+            state.unresolvedQuestions.length > 0 ? `Outstanding question(s): ${state.unresolvedQuestions.slice(0, 4).join(" | ")}` : ""
+          ].filter(Boolean).join("\n");
+          lastCompletionGateReason = unresolved.length > 0 ? `claim discovery evidence pending (${unresolved.length})` : "claim discovery is still waiting on blockers/questions";
+          lastCompletionGateFeedback = feedback;
+          lastCompletionGateCode = "claim_discovery";
+          messages2.push({ role: "system", content: feedback });
+          this.emit({
+            type: "status",
+            content: `task_complete held by claim discovery gate: ${lastCompletionGateReason}`,
+            turn,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          return true;
+        };
         const completionHoldEscapeMax = (() => {
           const raw = Number(process.env["OMNIUS_COMPLETION_HOLD_MAX"]);
           return Number.isFinite(raw) && raw >= 1 ? Math.floor(raw) : 3;
@@ -604733,7 +605095,7 @@ ${lastCompletionGateFeedback.trim().slice(0, 4e3)}` : ""
             lastCompletionGateCode = "";
             return true;
           }
-          const held = holdDeliveryCoverageTaskComplete(turn) || holdCompileFixLoopTaskComplete(turn) || holdUnresolvedVerificationTaskComplete(turn) || holdNoProgressTaskComplete(args, turn) || holdProvenanceTaskComplete(args, turn);
+          const held = holdDeliveryCoverageTaskComplete(turn) || holdCompileFixLoopTaskComplete(turn) || holdUnresolvedVerificationTaskComplete(turn) || holdNoProgressTaskComplete(args, turn) || holdProvenanceTaskComplete(args, turn) || holdClaimDiscoveryTaskComplete(turn);
           if (!held) {
             this._completionHoldState.count = 0;
             this._completionHoldState.lastKey = "";
@@ -604828,94 +605190,41 @@ ${lastCompletionGateFeedback.trim().slice(0, 4e3)}` : ""
         };
         let executeSingle = async () => null;
         const turnCap = this.options.maxTurns && this.options.maxTurns > 0 ? this.options.maxTurns : Number.MAX_SAFE_INTEGER;
-        const _featureLoopHandled = process.env["OMNIUS_FEATURE_LOOP"] === "1" && !this._inFeatureLoop && !this.options.subAgent;
-        if (_featureLoopHandled) {
-          try {
-            const _survey = await this._resolveFeatureSurvey(task, context2, 0);
-            if (!_survey) {
-              this.emit({
-                type: "status",
-                content: "[FEATURE LOOP] deferred: no model-grounded workspace survey was available; continuing with the normal discovery loop",
-                timestamp: (/* @__PURE__ */ new Date()).toISOString()
-              });
-            } else {
-              const _kind = classifyKind(_survey);
-              if (_kind === "investigation") {
-                this.emit({
-                  type: "status",
-                  content: "[FEATURE LOOP] survey classified this as investigation; continuing with the normal evidence-gathering loop",
-                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
-                });
-              } else {
-                this._inFeatureLoop = true;
-                this.emit({
-                  type: "status",
-                  content: `[FEATURE LOOP] evidence-grounded survey classified "${_kind}" – entering recursive driver...`,
-                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
-                });
-                const _root = createRootFeatureNode(task);
-                const _startMs = Date.now();
-                const _resultNode = await runFeatureNode(_root, {
-                  rootId: _root.id,
-                  stateDir: this.omniusStateDir(),
-                  workingDirectory: this.authoritativeWorkingDirectory() || process.cwd(),
-                  sessionId: this._sessionId,
-                  depthCap: 4,
-                  askApproval: async () => "approve",
-                  executeUnit: async (unit, node) => {
-                    const _unitRequest = buildFeatureUnitRequest({
-                      unit,
-                      parentRequest: node.request,
-                      survey: _survey
-                    });
-                    const _sub = await this.run(_unitRequest, unit.detail || "Feature unit request is grounded in the parent survey; verify the cited source before mutation.", unit.label);
-                    return { ok: _sub.status === "completed" };
-                  },
-                  runGeneralLoop: async (request) => {
-                    await this.run(request, void 0, request);
-                  },
-                  onPlan: async (artefact) => {
-                    if (this._longHaul && artefact.lockedContract?.symbols?.length) {
-                      this._longHaul.seedLockedContract(artefact.lockedContract);
-                      this.emit({
-                        type: "status",
-                        content: `[FEATURE LOOP] seeded ${artefact.lockedContract.symbols.length} locked symbols into WO-6 contract`,
-                        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-                      });
-                    }
-                  }
-                }, { survey: _survey });
-                this._inFeatureLoop = false;
-                const _completed = _resultNode.status === "completed";
-                const _durMs = Date.now() - _startMs;
-                this.emit({
-                  type: _completed ? "complete" : "error",
-                  content: `[FEATURE LOOP] ${_completed ? "completed" : "failed"} after ${_durMs}ms — ${_resultNode.children.length} child nodes`,
-                  success: _completed,
-                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
-                });
-                return {
-                  status: _completed ? "completed" : "incomplete",
-                  completed: _completed,
-                  turns: 0,
-                  toolCalls: 0,
-                  totalTokens: 0,
-                  promptTokens: 0,
-                  completionTokens: 0,
-                  estimatedTokens: 0,
-                  summary: `[FEATURE LOOP] ${_completed ? "completed" : "failed"}: ${task.slice(0, 200)}`,
-                  durationMs: _durMs
-                };
-              }
-            }
-          } catch (e2) {
-            this._inFeatureLoop = false;
-            this.emit({
-              type: "status",
-              content: `[FEATURE LOOP] error, falling back to general loop: ${e2}`,
-              timestamp: (/* @__PURE__ */ new Date()).toISOString()
-            });
+        const _claimDiscoveryEnabled = (() => {
+          if (typeof this.options.claimDiscovery === "boolean") {
+            return this.options.claimDiscovery;
           }
+          const parse3 = (raw) => {
+            if (raw === void 0)
+              return void 0;
+            const lowered = raw.toLowerCase();
+            if (raw === "1" || lowered === "true" || lowered === "on")
+              return true;
+            if (raw === "0" || lowered === "false" || lowered === "off")
+              return false;
+            return void 0;
+          };
+          const explicit = parse3(process.env["OMNIUS_CLAIM_DISCOVERY"]);
+          if (explicit !== void 0)
+            return explicit;
+          const legacy = parse3(process.env["OMNIUS_FEATURE_LOOP"]);
+          return legacy ?? true;
+        })();
+        const _claimDiscoveryNeedsInit = _claimDiscoveryEnabled && !this._claimDiscoveryInitialized && !this.options.subAgent && this._completionLedger !== null;
+        if (_claimDiscoveryNeedsInit && this._completionLedger) {
+          this._claimDiscoveryInitialized = true;
+          const _survey = await this._resolveClaimDiscoverySurvey(task, 0);
+          this._completionLedger = setClaimDiscoveryState(this._completionLedger, _survey);
+          messages2.push({
+            role: "system",
+            content: "[CLAIM DISCOVERY] Grounding signals (compact):\n" + claimDiscoveryControllerSignals(this._completionLedger.claimDiscovery).join("\n")
+          });
+          this.emit({
+            type: "status",
+            content: `[CLAIM DISCOVERY] initialized from bounded inventory: ${this._completionLedger.claimDiscovery?.candidatePaths.length ?? 0} candidate path(s), status=${this._completionLedger.claimDiscovery?.status ?? "skipped"}`,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          this._saveCompletionLedgerSafe();
         }
         if (process.env["OMNIUS_DISABLE_TEXT_ECHO_GUARD"] !== "1") {
           const restoredCollapsed = this._textEchoGuard.collapseEchoes(messages2);
@@ -615134,6 +615443,9 @@ ${trimmedNew}`;
           `next_claim_inspection=${coverage?.nextInspection?.replace(/\s+/g, " ").slice(0, 420) || "none"}`,
           `evidence_handles=${evidenceHandles.join(",") || "none"}`
         ];
+        if (this._completionLedger?.claimDiscovery) {
+          lines.push(...claimDiscoveryControllerSignals(this._completionLedger.claimDiscovery));
+        }
         const tier = this.options.modelTier ?? "large";
         const directive = this._focusSupervisor?.snapshot().directive;
         if (directive && tier === "small") {
@@ -622530,8 +622842,8 @@ var init_skill_fork = __esm({
 });
 
 // packages/orchestrator/dist/missionArtifacts.js
-import * as fs9 from "node:fs";
-import * as path11 from "node:path";
+import * as fs7 from "node:fs";
+import * as path9 from "node:path";
 function createValidationContract(missionId, assertions) {
   return {
     missionId,
@@ -622711,33 +623023,33 @@ function checkMilestoneComplete(state, manifest, milestoneId) {
   return true;
 }
 function writeFeaturesManifest(missionDir, manifest) {
-  fs9.mkdirSync(missionDir, { recursive: true });
-  const filePath = path11.join(missionDir, "features.json");
-  fs9.writeFileSync(filePath, JSON.stringify(manifest, null, 2), "utf-8");
+  fs7.mkdirSync(missionDir, { recursive: true });
+  const filePath = path9.join(missionDir, "features.json");
+  fs7.writeFileSync(filePath, JSON.stringify(manifest, null, 2), "utf-8");
 }
 function writeValidationContract(missionDir, contract) {
-  fs9.mkdirSync(missionDir, { recursive: true });
-  const filePath = path11.join(missionDir, "validation-contract.md");
-  fs9.writeFileSync(filePath, renderValidationContract(contract), "utf-8");
+  fs7.mkdirSync(missionDir, { recursive: true });
+  const filePath = path9.join(missionDir, "validation-contract.md");
+  fs7.writeFileSync(filePath, renderValidationContract(contract), "utf-8");
 }
 function writeValidationState(missionDir, state) {
-  fs9.mkdirSync(missionDir, { recursive: true });
-  const filePath = path11.join(missionDir, "validation-state.json");
-  fs9.writeFileSync(filePath, JSON.stringify(state, null, 2), "utf-8");
+  fs7.mkdirSync(missionDir, { recursive: true });
+  const filePath = path9.join(missionDir, "validation-state.json");
+  fs7.writeFileSync(filePath, JSON.stringify(state, null, 2), "utf-8");
 }
 function readFeaturesManifest(missionDir) {
-  const filePath = path11.join(missionDir, "features.json");
-  const content = fs9.readFileSync(filePath, "utf-8");
+  const filePath = path9.join(missionDir, "features.json");
+  const content = fs7.readFileSync(filePath, "utf-8");
   return JSON.parse(content);
 }
 function readValidationState(missionDir) {
-  const filePath = path11.join(missionDir, "validation-state.json");
-  const content = fs9.readFileSync(filePath, "utf-8");
+  const filePath = path9.join(missionDir, "validation-state.json");
+  const content = fs7.readFileSync(filePath, "utf-8");
   return JSON.parse(content);
 }
 function readValidationContract(missionDir) {
-  const filePath = path11.join(missionDir, "validation-contract.md");
-  const content = fs9.readFileSync(filePath, "utf-8");
+  const filePath = path9.join(missionDir, "validation-contract.md");
+  const content = fs7.readFileSync(filePath, "utf-8");
   const assertions = [];
   const lines = content.split("\n");
   let inTable = false;
@@ -623075,8 +623387,8 @@ var init_adversarialHandoffs = __esm({
 });
 
 // packages/orchestrator/dist/autoValidators.js
-import * as fs10 from "node:fs";
-import * as path12 from "node:path";
+import * as fs8 from "node:fs";
+import * as path10 from "node:path";
 function generateScrutinyValidatorSkill() {
   return `# Scrutiny Validator
 
@@ -623193,22 +623505,22 @@ function combineValidatorResults(missionId, milestoneId, scrutiny, userTesting)
   };
 }
 function writeValidatorResults(missionDir, results) {
-  fs10.mkdirSync(missionDir, { recursive: true });
-  const filePath = path12.join(missionDir, "validator-results.json");
-  fs10.writeFileSync(filePath, JSON.stringify(results, null, 2), "utf-8");
+  fs8.mkdirSync(missionDir, { recursive: true });
+  const filePath = path10.join(missionDir, "validator-results.json");
+  fs8.writeFileSync(filePath, JSON.stringify(results, null, 2), "utf-8");
 }
 function readValidatorResults(missionDir) {
-  const filePath = path12.join(missionDir, "validator-results.json");
-  const content = fs10.readFileSync(filePath, "utf-8");
+  const filePath = path10.join(missionDir, "validator-results.json");
+  const content = fs8.readFileSync(filePath, "utf-8");
   return JSON.parse(content);
 }
 function writeValidatorSkill(missionDir, skillName, content) {
-  const dir = path12.join(missionDir, "skills", "auto-injected");
-  if (!fs10.existsSync(dir)) {
-    fs10.mkdirSync(dir, { recursive: true });
+  const dir = path10.join(missionDir, "skills", "auto-injected");
+  if (!fs8.existsSync(dir)) {
+    fs8.mkdirSync(dir, { recursive: true });
   }
-  const filePath = path12.join(dir, `${skillName}.md`);
-  fs10.writeFileSync(filePath, content, "utf-8");
+  const filePath = path10.join(dir, `${skillName}.md`);
+  fs8.writeFileSync(filePath, content, "utf-8");
 }
 var init_autoValidators = __esm({
   "packages/orchestrator/dist/autoValidators.js"() {
@@ -623217,8 +623529,8 @@ var init_autoValidators = __esm({
 });
 
 // packages/orchestrator/dist/serviceManifest.js
-import * as fs11 from "node:fs";
-import * as path13 from "node:path";
+import * as fs9 from "node:fs";
+import * as path11 from "node:path";
 function quoteScalar(value2) {
   return JSON.stringify(value2);
 }
@@ -623349,8 +623661,8 @@ function getCommand(manifest, name10) {
   return cmd.command;
 }
 function writeServicesManifest(missionDir, manifest) {
-  fs11.mkdirSync(missionDir, { recursive: true });
-  const filePath = path13.join(missionDir, "services.yaml");
+  fs9.mkdirSync(missionDir, { recursive: true });
+  const filePath = path11.join(missionDir, "services.yaml");
   const lines = [
     `missionId: ${manifest.missionId}`,
     `createdAt: ${manifest.createdAt}`,
@@ -623398,11 +623710,11 @@ function writeServicesManifest(missionDir, manifest) {
   lines.push(`    min: ${manifest.ports.range.min}`);
   lines.push(`    max: ${manifest.ports.range.max}`);
   lines.push(`  offLimits: [${manifest.ports.offLimits.join(", ")}]`);
-  fs11.writeFileSync(filePath, lines.join("\n"), "utf-8");
+  fs9.writeFileSync(filePath, lines.join("\n"), "utf-8");
 }
 function readServicesManifest(missionDir) {
-  const filePath = path13.join(missionDir, "services.yaml");
-  const content = fs11.readFileSync(filePath, "utf-8");
+  const filePath = path11.join(missionDir, "services.yaml");
+  const content = fs9.readFileSync(filePath, "utf-8");
   const services = [];
   const commands = [];
   let missionId = "";
@@ -624839,6 +625151,549 @@ var init_conversational_scrutiny = __esm({
   }
 });
 
+// packages/orchestrator/dist/featurePlanner.js
+import fs10 from "node:fs";
+import path12 from "node:path";
+function classifyKind(survey) {
+  const files = survey.files ?? [];
+  const newSym = (survey.newSymbols ?? []).length;
+  const req3 = survey.request.toLowerCase();
+  if (/\b(investigat|why does|how does|trace|understand|root cause|diagnos|explain)\b/.test(req3) && newSym === 0 && files.length <= 2) {
+    return "investigation";
+  }
+  if (/\b(bug|fix|broken|regression|crash|incorrect|fails?|misbehav)/.test(req3) && newSym === 0) {
+    return "bugfix";
+  }
+  if (/\b(refactor|restructure|rename|clean up|simplif|migrate|consolidate)\b/.test(req3) && newSym === 0) {
+    return "refactor";
+  }
+  if (/\b(wir|connect|integrate|hook up|plumb|bridge|glue)\b/.test(req3) && files.length >= 2) {
+    return "wiring";
+  }
+  if (newSym > 0 || /\b(new|create|add|implement|build|introduce|scaffold)\b/.test(req3)) {
+    return "new-module";
+  }
+  return "new-module";
+}
+function guessKind(name10) {
+  if (/^(I[A-Z]|.*Interface|.*Contract|.*Spec|.*Event|.*Meta|.*Config|.*State)$/.test(name10)) {
+    return "interface";
+  }
+  if (/^(T|Type|.*Type)$/.test(name10))
+    return "type";
+  if (/^(E|Enum|.*Kind|.*Status|.*Mode)$/.test(name10))
+    return "enum";
+  if (/^[A-Z]/.test(name10))
+    return "class";
+  return "function";
+}
+function buildLockedContract(kind, survey) {
+  const symbols = [];
+  if (kind === "refactor") {
+    for (const name10 of survey.existingSymbols ?? []) {
+      symbols.push({ name: name10, kind: guessKind(name10), fields: [] });
+    }
+  } else if (kind === "new-module") {
+    for (const name10 of survey.newSymbols ?? []) {
+      symbols.push({ name: name10, kind: guessKind(name10), fields: [] });
+    }
+  }
+  return { symbols };
+}
+function decomposeFeature(survey, kind) {
+  const units = [];
+  const evidenceRefs = claimEvidenceRefs(survey);
+  const unresolvedQuestion = survey.unresolvedQuestions?.[0] ?? (evidenceRefs.length === 0 ? "Which current files, symbols, and tests govern this unit? Inspect them before proposing a mutation." : void 0);
+  const returnContract = "Return the direct result with cited observations, relevant/changed paths, verification or blocker, and the next parent decision.";
+  const withGrounding = (unit) => ({
+    ...unit,
+    evidenceRefs,
+    ...unresolvedQuestion ? { unresolvedQuestion } : {},
+    returnContract
+  });
+  if (kind === "new-module") {
+    const syms = survey.newSymbols ?? [];
+    if (syms.length === 0) {
+      units.push(withGrounding({
+        label: "Establish the module boundary and implement the evidenced unit",
+        size: "large",
+        detail: "Do not scaffold from the request alone. First identify the owning entry point, adjacent contract, and test surface from current evidence."
+      }));
+    } else {
+      for (const name10 of syms) {
+        units.push({
+          ...withGrounding({
+            label: `Implement ${name10} within its evidenced owner`,
+            size: "small",
+            detail: "Confirm the symbol's owning module and contract before editing; do not infer a file path from the request label."
+          }),
+          expectedSymbols: [name10]
+        });
+      }
+    }
+  } else if (kind === "refactor") {
+    units.push(withGrounding({
+      label: "Refactor only the evidenced public surface",
+      size: survey.files.length > 1 ? "large" : "small"
+    }));
+  } else if (kind === "bugfix") {
+    units.push(withGrounding({
+      label: "Reproduce the evidenced failure, make the smallest justified fix, and verify it",
+      size: "small"
+    }));
+  } else if (kind === "wiring") {
+    units.push(withGrounding({
+      label: "Connect the evidenced module boundaries",
+      size: survey.files.length > 2 ? "large" : "small"
+    }));
+  } else {
+    units.push(withGrounding({
+      label: "Investigate the evidence gap and report the next justified action",
+      size: "small"
+    }));
+  }
+  return units;
+}
+function claimEvidenceRefs(survey) {
+  const declared = (survey.evidence ?? []).map((item) => item.ref.trim()).filter(Boolean).slice(0, 6);
+  if (declared.length > 0)
+    return declared;
+  return survey.files.map((file) => `survey:file:${file.path}`).filter(Boolean).slice(0, 6);
+}
+function buildFeatureUnitRequest(input) {
+  const evidence = (input.survey.evidence ?? []).filter((item) => !input.unit.evidenceRefs?.length || input.unit.evidenceRefs.includes(item.ref)).slice(0, 6);
+  const fallbackEvidence = evidence.length > 0 ? evidence : input.survey.files.slice(0, 6).map((file) => ({
+    ref: `survey:file:${file.path}`,
+    detail: `${file.path}${file.role ? ` — ${file.role}` : ""}`,
+    freshness: "unknown"
+  }));
+  const explicitOpenDeltas = [
+    ...input.unit.unresolvedQuestion ? [input.unit.unresolvedQuestion] : [],
+    ...input.survey.unresolvedQuestions ?? []
+  ].slice(0, 6);
+  const lines = [
+    "[CLAIM UNIT EVIDENCE BRIEF]",
+    `Parent request: ${input.parentRequest.slice(0, 900)}`,
+    `Requested unit: ${input.unit.label}`,
+    `Why now: this unit was selected from the current claim discovery survey, not from a task label alone.`,
+    `Open deltas: ${explicitOpenDeltas.length > 0 ? explicitOpenDeltas.join(" | ") : "none"}`,
+    `Surviving blockers: ${input.unit.unresolvedQuestion ? "blocker carried from planner: open question" : "none"}`,
+    `Evidence handles: ${fallbackEvidence.map((item) => item.ref).join(", ")}`,
+    "Evidence:",
+    ...fallbackEvidence.length > 0 ? fallbackEvidence.map((item) => `- [${item.freshness ?? "unknown"}] ${item.ref}: ${item.detail.slice(0, 360)}`) : ["- No current code observation is available; discovery is required before mutation."],
+    `Open question: ${input.unit.unresolvedQuestion ?? "none"}`,
+    "Scope: stay within this unit and directly implicated code; do not broaden the claim without returning to the parent.",
+    `Return contract: ${input.unit.returnContract ?? "Return evidence, verification or blocker, and the next parent decision."}`,
+    "",
+    "Work protocol: inspect the cited files/contracts first. Only mutate after a fresh observation identifies the exact target; if the evidence does not support a target, report the gap instead of fabricating one."
+  ];
+  return lines.filter((line) => Boolean(line)).join("\n");
+}
+function renderSpecMarkdown(input) {
+  const { kind, survey, lockedContract, completionContract, decomposition, prose } = input;
+  const lines = [];
+  lines.push(`# Claim Discovery Plan — ${kind}`);
+  lines.push("");
+  lines.push(`**Request:** ${survey.request}`);
+  lines.push("");
+  lines.push(`**Node kind:** \`${kind}\` (selected by CLASSIFY over the survey signals)`);
+  lines.push("");
+  if (prose) {
+    lines.push(`## 1. Intent`);
+    lines.push("");
+    lines.push(prose.trim());
+    lines.push("");
+  }
+  lines.push(`## 2. Survey (codebase as-is)`);
+  lines.push("");
+  if (survey.files.length > 0) {
+    for (const f2 of survey.files) {
+      const refs = f2.lineRefs?.length ? `:${f2.lineRefs.join(",")}` : "";
+      lines.push(`- \`${f2.path}${refs}\`${f2.role ? ` — ${f2.role}` : ""}`);
+    }
+  } else {
+    lines.push("- (no files enumerated in survey)");
+  }
+  if (survey.evidence?.length) {
+    for (const item of survey.evidence.slice(0, 8)) {
+      lines.push(`- evidence [${item.freshness ?? "unknown"}] ${item.ref}: ${item.detail}`);
+    }
+  }
+  if (survey.unresolvedQuestions?.length) {
+    lines.push(`- unresolved: ${survey.unresolvedQuestions.join("; ")}`);
+  }
+  lines.push(`- new symbols: ${(survey.newSymbols ?? []).join(", ") || "none"}`);
+  lines.push(`- public surface changes: ${survey.publicSurfaceChanges ? "yes" : "no"}`);
+  lines.push(`- tests exist: ${survey.testsExist ? "yes" : "no"}`);
+  lines.push("");
+  lines.push(`## 3. Locked contract (executable gate)`);
+  lines.push("");
+  if (lockedContract.symbols.length === 0) {
+    lines.push("- (no locked symbols for this kind — disciplined but permissive)");
+  } else {
+    for (const s2 of lockedContract.symbols) {
+      lines.push(`- \`${s2.kind} ${s2.name}\``);
+    }
+  }
+  lines.push("");
+  lines.push(`## 4. Definition of done (CompletionContract)`);
+  lines.push("");
+  lines.push(`- goal: ${completionContract.goalSummary || "(none)"}`);
+  for (const p2 of completionContract.phases ?? []) {
+    lines.push(`- phase: ${p2.label}`);
+  }
+  lines.push("");
+  lines.push(`## 5. Decomposition (SPLIT seed)`);
+  lines.push("");
+  for (const u of decomposition) {
+    lines.push(`- [${u.size}] ${u.label}${u.expectedSymbols?.length ? ` (symbols: ${u.expectedSymbols.join(", ")})` : ""}${u.evidenceRefs?.length ? ` [evidence: ${u.evidenceRefs.join(", ")}]` : ""}`);
+  }
+  lines.push("");
+  lines.push(`## 6. Verification bar`);
+  lines.push("");
+  lines.push("- planner emits real artefacts (this file + locked contract + completion contract)");
+  lines.push("- approval gate blocks before any source edit");
+  lines.push("- WO-6 executor gate activates on locked symbols");
+  lines.push("- recursion + eviction keep context bounded");
+  lines.push("- scope token re-prompts on out-of-scope work");
+  lines.push("");
+  lines.push(`## 7. Handoff notes`);
+  lines.push("");
+  lines.push("- Compose, do not rebuild: this plan reuses spec-gate + completionContract primitives.");
+  lines.push("- Fail-closed: if planning errors, the run falls back to the general agentic loop.");
+  lines.push("");
+  return lines.join("\n");
+}
+async function planFeature(survey, options2 = {}) {
+  const kind = classifyKind(survey);
+  const lockedContract = buildLockedContract(kind, survey);
+  const completionContract = inferCompletionContractFromTexts([survey.request, ...survey.rawTexts ?? [], ...survey.signals ?? []], survey.request);
+  const decomposition = decomposeFeature(survey, kind);
+  let prose = "";
+  try {
+    if (options2.proseGenerator) {
+      prose = await options2.proseGenerator({ request: survey.request, kind, survey });
+    }
+  } catch {
+    prose = "";
+  }
+  const specMarkdown = renderSpecMarkdown({
+    kind,
+    survey,
+    lockedContract,
+    completionContract,
+    decomposition,
+    prose
+  });
+  return { kind, specMarkdown, lockedContract, completionContract, decomposition };
+}
+function persistPlannerArtefacts(rootId, artefact, stateDir, survey) {
+  try {
+    const dir = path12.join(stateDir, "feature-tree", rootId);
+    fs10.mkdirSync(dir, { recursive: true });
+    fs10.writeFileSync(path12.join(dir, "spec.md"), artefact.specMarkdown, "utf8");
+    fs10.writeFileSync(path12.join(dir, "locked-contract.json"), JSON.stringify(artefact.lockedContract, null, 2), "utf8");
+    fs10.writeFileSync(path12.join(dir, "completion-contract.json"), JSON.stringify(artefact.completionContract, null, 2), "utf8");
+    if (survey) {
+      fs10.writeFileSync(path12.join(dir, "claim-discovery-survey.json"), JSON.stringify({
+        request: survey.request,
+        requestSource: "bound_workspace_inventory",
+        files: survey.files,
+        unresolvedQuestions: survey.unresolvedQuestions ?? [],
+        evidenceRefs: survey.evidence?.map((item) => item.ref) ?? [],
+        signals: survey.signals ?? [],
+        requiredVerificationCommands: survey.requiredVerificationCommands ?? [],
+        testsExist: survey.testsExist ?? false,
+        publicSurfaceChanges: survey.publicSurfaceChanges ?? false,
+        newSymbols: survey.newSymbols ?? [],
+        existingSymbols: survey.existingSymbols ?? []
+      }, null, 2), "utf8");
+    }
+  } catch {
+  }
+}
+var classifyClaimKind, buildClaimPlan, buildClaimUnitRequest, buildClaimLockedContract;
+var init_featurePlanner = __esm({
+  "packages/orchestrator/dist/featurePlanner.js"() {
+    "use strict";
+    init_completionContract();
+    classifyClaimKind = classifyKind;
+    buildClaimPlan = planFeature;
+    buildClaimUnitRequest = buildFeatureUnitRequest;
+    buildClaimLockedContract = buildLockedContract;
+  }
+});
+
+// packages/orchestrator/dist/featureApprovalGate.js
+function mintScopeToken(input) {
+  return {
+    rootId: input.rootId,
+    files: [...input.files ?? []],
+    symbols: input.lockedContract.symbols.map((s2) => s2.name),
+    nodeKinds: input.nodeKinds ?? ["new-module", "refactor", "bugfix", "wiring", "investigation"],
+    depthCap: input.depthCap
+  };
+}
+function isWithinScope(input) {
+  const { token } = input;
+  if (typeof input.depth === "number" && input.depth > token.depthCap) {
+    return false;
+  }
+  if (input.nodeKind && !token.nodeKinds.includes(input.nodeKind)) {
+    return false;
+  }
+  if (input.newSymbol && !token.symbols.includes(input.newSymbol)) {
+    return false;
+  }
+  if (input.file) {
+    const file = input.file;
+    const allowed = token.files.some((f2) => {
+      if (f2 === file)
+        return true;
+      if (f2.endsWith("/") && file.startsWith(f2))
+        return true;
+      if (f2.includes("*") && globMatch(f2, file))
+        return true;
+      return false;
+    });
+    if (!allowed)
+      return false;
+  }
+  return true;
+}
+function globMatch(pattern, value2) {
+  const re = new RegExp("^" + pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*") + "$");
+  return re.test(value2);
+}
+async function requestApproval(req3, ask2, options2 = {}) {
+  let decision2;
+  try {
+    const raw = await ask2(req3);
+    decision2 = raw === "approve" || raw === "edit" || raw === "reject" ? raw : "reject";
+  } catch {
+    decision2 = "reject";
+  }
+  if (decision2 === "approve") {
+    const token = mintScopeToken({
+      rootId: req3.rootId,
+      lockedContract: req3.lockedContract,
+      decomposition: req3.decomposition,
+      depthCap: req3.depthCap,
+      files: options2.files,
+      nodeKinds: options2.nodeKinds
+    });
+    return { decision: decision2, token };
+  }
+  return { decision: decision2 };
+}
+var mintClaimScopeToken, isWithinClaimScope, requestClaimApproval;
+var init_featureApprovalGate = __esm({
+  "packages/orchestrator/dist/featureApprovalGate.js"() {
+    "use strict";
+    mintClaimScopeToken = mintScopeToken;
+    isWithinClaimScope = isWithinScope;
+    requestClaimApproval = requestApproval;
+  }
+});
+
+// packages/orchestrator/dist/featureNode.js
+import fs11 from "node:fs";
+import path13 from "node:path";
+function treePath(stateDir, rootId) {
+  return path13.join(stateDir, "feature-tree", `${rootId}.json`);
+}
+function saveFeatureTree(stateDir, rootId, nodes) {
+  try {
+    const file = treePath(stateDir, rootId);
+    fs11.mkdirSync(path13.dirname(file), { recursive: true });
+    fs11.writeFileSync(file, JSON.stringify(nodes, null, 2), "utf8");
+  } catch {
+  }
+}
+function loadFeatureTree(stateDir, rootId) {
+  try {
+    const file = treePath(stateDir, rootId);
+    if (!fs11.existsSync(file))
+      return null;
+    const raw = JSON.parse(fs11.readFileSync(file, "utf8"));
+    return raw && typeof raw === "object" ? raw : null;
+  } catch {
+    return null;
+  }
+}
+function newNodeId(depth, seed) {
+  const h = String(Math.abs(hashString2(seed)) % 1e9).padStart(9, "0");
+  return `fn-d${depth}-${h}`;
+}
+function hashString2(s2) {
+  let h = 0;
+  for (let i2 = 0; i2 < s2.length; i2++)
+    h = h * 31 + s2.charCodeAt(i2) | 0;
+  return h;
+}
+async function evictNode(node, ctx3, transcript) {
+  try {
+    await runTodoChunker({
+      inputs: {
+        todoId: node.id,
+        todoContent: node.request,
+        turnRange: [0, 0],
+        transcript: transcript || node.request,
+        toolCalls: [],
+        workingDirectory: ctx3.workingDirectory,
+        sessionId: ctx3.sessionId
+      },
+      callable: ctx3.summarizer ?? (async () => "")
+    });
+  } catch {
+  }
+}
+async function execUnit(unit, node, ctx3, contract, maxRegenerate) {
+  let result = await ctx3.executeUnit(unit, node);
+  if (!result.ok)
+    return false;
+  const expected = unit.expectedSymbols ?? [];
+  if (expected.length === 0) {
+    return true;
+  }
+  for (let attempt = 0; attempt <= maxRegenerate; attempt++) {
+    if (!result.path || result.source === void 0)
+      return false;
+    const verdict = evaluateExecutorStep({
+      unit: { path: result.path, source: result.source },
+      contract,
+      expectedSymbols: expected
+    });
+    if (verdict.decision === "accept")
+      return true;
+    if (verdict.decision === "replan")
+      return false;
+    result = await ctx3.executeUnit(unit, node);
+    if (!result.ok)
+      return false;
+  }
+  return false;
+}
+async function runFeatureNode(node, ctx3, options2, tree2 = {}) {
+  const maxRegenerate = options2.maxRegenerate ?? 2;
+  tree2[node.id] = node;
+  try {
+    const artefact = await planFeature(options2.survey, {
+      proseGenerator: options2.proseGenerator
+    });
+    node.kind = artefact.kind;
+    if (ctx3.onPlan) {
+      try {
+        await ctx3.onPlan(artefact);
+      } catch {
+      }
+    }
+    persistPlannerArtefacts(ctx3.rootId, artefact, ctx3.stateDir, options2.survey);
+    const mustAsk = node.depth === 0 || !node.scopeToken;
+    if (mustAsk && ctx3.askApproval) {
+      node.status = "awaiting_approval";
+      const outcome = await requestApproval({
+        rootId: ctx3.rootId,
+        request: node.request,
+        specMarkdown: artefact.specMarkdown,
+        lockedContract: artefact.lockedContract,
+        decomposition: artefact.decomposition,
+        depthCap: ctx3.depthCap
+      }, ctx3.askApproval, { files: options2.survey.files.map((f2) => f2.path) });
+      if (outcome.decision !== "approve") {
+        node.status = outcome.decision === "edit" ? "planned" : "rejected";
+        saveFeatureTree(ctx3.stateDir, ctx3.rootId, tree2);
+        return node;
+      }
+      node.scopeToken = outcome.token;
+    }
+    node.status = "approved";
+    node.status = "executing";
+    let allOk = true;
+    for (const unit of artefact.decomposition) {
+      if (unit.size === "large" && node.depth < ctx3.depthCap) {
+        const childId = newNodeId(node.depth + 1, unit.label + node.id);
+        const childRequest = buildFeatureUnitRequest({
+          unit,
+          parentRequest: node.request,
+          survey: options2.survey
+        });
+        const child = {
+          id: childId,
+          parentId: node.id,
+          depth: node.depth + 1,
+          request: childRequest,
+          kind: artefact.kind,
+          status: "planned",
+          scopeToken: node.scopeToken,
+          children: []
+        };
+        node.children.push(childId);
+        const childSurvey = {
+          ...options2.survey,
+          request: child.request
+        };
+        const childCtx = {
+          ...ctx3,
+          // children inherit the token; re-prompt only if they exceed scope
+          askApproval: (req3) => isWithinScope({
+            token: node.scopeToken,
+            depth: node.depth + 1,
+            nodeKind: artefact.kind
+          }) ? "approve" : ctx3.askApproval(req3)
+        };
+        const res = await runFeatureNode(child, childCtx, { ...options2, survey: childSurvey }, tree2);
+        if (res.status !== "completed")
+          allOk = false;
+        await evictNode(child, ctx3, child.request);
+      } else {
+        const ok3 = await execUnit(unit, node, ctx3, artefact.lockedContract, maxRegenerate);
+        if (!ok3)
+          allOk = false;
+      }
+    }
+    if (allOk) {
+      node.status = "completed";
+    } else {
+      node.status = "failed";
+    }
+    saveFeatureTree(ctx3.stateDir, ctx3.rootId, tree2);
+    return node;
+  } catch {
+    if (ctx3.runGeneralLoop) {
+      await ctx3.runGeneralLoop(node.request);
+      node.status = "completed";
+    } else {
+      node.status = "failed";
+    }
+    saveFeatureTree(ctx3.stateDir, ctx3.rootId, tree2);
+    return node;
+  }
+}
+function createRootFeatureNode(request) {
+  return {
+    id: newNodeId(0, request),
+    parentId: null,
+    depth: 0,
+    request,
+    kind: "new-module",
+    status: "planned",
+    children: []
+  };
+}
+var runClaimNode, createClaimRootNode;
+var init_featureNode = __esm({
+  "packages/orchestrator/dist/featureNode.js"() {
+    "use strict";
+    init_featurePlanner();
+    init_featureApprovalGate();
+    init_spec_gate();
+    init_todo_context_chunker();
+    runClaimNode = runFeatureNode;
+    createClaimRootNode = createRootFeatureNode;
+  }
+});
+
 // packages/orchestrator/dist/causalAblation.js
 function _identifyAblationTargets(messages2, dimension) {
   const targets = [];
@@ -625364,6 +626219,9 @@ __export(dist_exports3, {
   buildAgentDeploymentPatternSummary: () => buildAgentDeploymentPatternSummary,
   buildAgentNotification: () => buildAgentNotification,
   buildAgentTypeSummary: () => buildAgentTypeSummary,
+  buildClaimLockedContract: () => buildClaimLockedContract,
+  buildClaimPlan: () => buildClaimPlan,
+  buildClaimUnitRequest: () => buildClaimUnitRequest,
   buildCompletionFinalizationRecord: () => buildCompletionFinalizationRecord,
   buildCompletionScenarioDecomposition: () => buildCompletionScenarioDecomposition,
   buildCoordinatorPrompt: () => buildCoordinatorPrompt,
@@ -625390,6 +626248,7 @@ __export(dist_exports3, {
   chooseCheapModelRoute: () => chooseCheapModelRoute,
   claimAssertion: () => claimAssertion,
   classifyBreadth: () => classifyBreadth,
+  classifyClaimKind: () => classifyClaimKind,
   classifyCompletionClaim: () => classifyCompletionClaim,
   classifyHandoff: () => classifyHandoff,
   classifyKind: () => classifyKind,
@@ -625424,6 +626283,7 @@ __export(dist_exports3, {
   countDefinitions: () => countDefinitions,
   createAppState: () => createAppState,
   createChildAbortController: () => createChildAbortController,
+  createClaimRootNode: () => createClaimRootNode,
   createCompletionLedger: () => createCompletionLedger,
   createDefaultContextEngine: () => createDefaultContextEngine,
   createFeaturesManifest: () => createFeaturesManifest,
@@ -625517,6 +626377,7 @@ __export(dist_exports3, {
   isSuccessfulRunFinished: () => isSuccessfulRunFinished,
   isTerminalRunEvent: () => isTerminalRunEvent,
   isTerminalTaskStatus: () => isTerminalTaskStatus,
+  isWithinClaimScope: () => isWithinClaimScope,
   isWithinScope: () => isWithinScope,
   legacyAgenticEventToRunEvent: () => legacyAgenticEventToRunEvent,
   listContextWindowDumps: () => listContextWindowDumps,
@@ -625533,6 +626394,7 @@ __export(dist_exports3, {
   measureContextSNR: () => measureContextSNR,
   memoryCosine: () => cosine4,
   mergeDigests: () => mergeDigests,
+  mintClaimScopeToken: () => mintClaimScopeToken,
   mintScopeToken: () => mintScopeToken,
   normalizeCompletionKey: () => normalizeCompletionKey,
   normalizeMemoryCompilationPlanAudit: () => normalizeMemoryCompilationPlanAudit,
@@ -625551,6 +626413,7 @@ __export(dist_exports3, {
   persistAgentTaskSidecar: () => persistAgentTaskSidecar,
   persistPlannerArtefacts: () => persistPlannerArtefacts,
   planAgentDeploymentPattern: () => planAgentDeploymentPattern,
+  planClaim: () => buildClaimPlan,
   planConsolidation: () => planConsolidation,
   planFeature: () => planFeature,
   prepareCompletionFinalization: () => prepareCompletionFinalization,
@@ -625598,6 +626461,7 @@ __export(dist_exports3, {
   renderValidationContract: () => renderValidationContract,
   renderWorkerSkill: () => renderWorkerSkill,
   requestApproval: () => requestApproval,
+  requestClaimApproval: () => requestClaimApproval,
   resetPluginRegistry: () => resetPluginRegistry,
   resolveAgentTools: () => resolveAgentTools,
   resolveDefaultPoolConfig: () => resolveDefaultPoolConfig,
@@ -625605,6 +626469,7 @@ __export(dist_exports3, {
   resolveModelProfile: () => resolveModelProfile,
   restoreAgentTasks: () => restoreAgentTasks,
   retentionStrength: () => retentionStrength,
+  runClaimNode: () => runClaimNode,
   runFeatureNode: () => runFeatureNode,
   runMemoryCompilerReplay: () => runMemoryCompilerReplay,
   runMemoryCompilerReplaySuite: () => runMemoryCompilerReplaySuite,
@@ -772018,6 +772883,8 @@ async function runCommand2(opts, config) {
       await runBackground(opts.task, mergedConfig, opts);
     } else if (opts.json) {
       await runJson(opts.task, mergedConfig, opts.repoPath);
+    } else if (opts.verbose) {
+      await runConsole(opts.task, mergedConfig, opts.repoPath);
     } else {
       await runWithTUI(opts.task, mergedConfig, opts.repoPath);
       if (shouldForceSingleRunExit()) process.exit(0);
@@ -772117,6 +772984,95 @@ async function runJson(task, config, repoPath2) {
   if (result.exitCode !== 0) process.exit(result.exitCode);
   if (shouldForceJsonExit()) process.exit(0);
 }
+async function runConsole(task, config, repoPath2) {
+  const startTime = Date.now();
+  const origWrite = process.stdout.write.bind(process.stdout);
+  const origStderr = process.stderr.write.bind(process.stderr);
+  process.stdout.write = (() => true);
+  process.stderr.write = (() => true);
+  let runnerResult = null;
+  let toolCount = 0;
+  const fmtArgs = (args) => {
+    if (args === void 0 || args === null) return "";
+    if (typeof args !== "object") return ` (${String(args)})`;
+    const entries = Object.entries(args);
+    if (entries.length === 0) return "";
+    const parts = entries.map(([k, v]) => {
+      let s2;
+      if (typeof v === "string") {
+        s2 = v.length > 200 ? `${v.slice(0, 197)}…` : v;
+      } else if (v === void 0 || v === null) {
+        s2 = String(v);
+      } else {
+        try {
+          s2 = JSON.stringify(v);
+        } catch {
+          s2 = String(v);
+        }
+        if (s2.length > 200) s2 = `${s2.slice(0, 197)}…`;
+      }
+      return `${k}=${s2}`;
+    });
+    return ` (${parts.join(", ")})`;
+  };
+  const emit2 = (line) => {
+    origWrite(line + "\n");
+  };
+  try {
+    emit2(`▶ Task: ${task}`);
+    await runWithTUI(task, config, repoPath2, {
+      onToolCall: (tool, args) => {
+        toolCount += 1;
+        emit2(`[${toolCount}] 🔧 ${tool}${fmtArgs(args)}`);
+      },
+      onToolResult: (tool, output, success) => {
+        const redacted = getSecretRedactor().redactText(output || "");
+        const capped = redacted && redacted.length > 400 ? redacted.slice(0, 380) + `… [+${redacted.length - 380} chars]` : redacted;
+        const mark = success ? "✓" : "✗";
+        emit2(`    ${mark} ${tool} → ${capped || "(no output)"}`);
+      },
+      onStatus: (content) => {
+        if (content && content.trim()) {
+          emit2(`ℹ ${content.trim()}`);
+        }
+      },
+      onAssistantText: (text2) => {
+        const clean6 = sanitizeAgentOutputForUser(text2).trim();
+        if (clean6) emit2(`💬 ${clean6.replace(/\n/g, "\n   ")}`);
+      },
+      onRunResult: (result) => {
+        runnerResult = {
+          status: result.status,
+          completed: result.completed,
+          summary: result.summary,
+          turns: result.turns,
+          toolCalls: result.toolCalls
+        };
+      }
+    });
+  } catch (err) {
+    process.stdout.write = origWrite;
+    process.stderr.write = origStderr;
+    emit2(`✗ Error: ${err instanceof Error ? err.message : String(err)}`);
+    if (config.verbose && err instanceof Error && err.stack) {
+      emit2(err.stack);
+    }
+    process.exit(1);
+  }
+  process.stdout.write = origWrite;
+  process.stderr.write = origStderr;
+  const durationMs = Date.now() - startTime;
+  const rr = runnerResult;
+  const status = rr?.completed ? "completed" : rr?.status ?? "completed";
+  emit2("");
+  emit2(
+    `✓ Done — status: ${status} | ${rr?.turns ?? "?"} turns | ${toolCount} tool calls | ${(durationMs / 1e3).toFixed(1)}s`
+  );
+  if (rr?.summary) {
+    emit2(`Summary: ${rr.summary.slice(0, 400)}`);
+  }
+  if (shouldForceSingleRunExit()) process.exit(0);
+}
 function shouldForceJsonExit() {
   if (process.env["OMNIUS_JSON_NO_FORCE_EXIT"] === "1") return false;
   if (process.env["VITEST"] === "true" || process.env["NODE_ENV"] === "test")
@@ -773408,7 +774364,7 @@ Flags:
       --dry-run              Validate patches, don't write to disk
       --offline              Use FakeBackend, no backend connection needed
   -l, --local                Save settings to .omnius/settings.json (project-local)
-  -v, --verbose              Verbose output
+  -v, --verbose              Lightweight console mode: print each tool call, result, and reasoning step as plain text (no TUI)
       --max-retries <n>      Max retries per model request
       --timeout-ms <ms>      Overall task timeout
       --suite <name>         Eval suite: basic (default) or full