@event4u/agent-config 10.1.0 → 10.3.0

package/dist/cli-delegate/cmd_conformance.js

@@ -18,8 +18,9 @@ import {
   comparePair,
   frontmatterPaths,
   proseEqual,
+  resolveSessionRole,
   splitFrontmatter
-} from "./chunk-2H5SE7DU.js";
+} from "./chunk-FV34EGEX.js";
 import "./chunk-FTAISGDQ.js";
 import {
   atomic_write_json,
@@ -27,7 +28,9 @@ import {
   is_replay_mode
 } from "./chunk-EJITJBJX.js";
 import "./chunk-Q26HT4QT.js";
-import "./chunk-XT2YTJCZ.js";
+import {
+  projectStoreSlug
+} from "./chunk-AYKQGIBG.js";
 import "./chunk-PZWRPRWP.js";
 import "./chunk-M2DPGFZ4.js";
 import {
@@ -37,7 +40,9 @@ import {
 } from "./chunk-63WSP6YZ.js";
 import "./chunk-GRRPEPRN.js";
 import "./chunk-NXFWFAYV.js";
-import "./chunk-XTC5ARB6.js";
+import {
+  load_agent_settings
+} from "./chunk-IR3IVRVC.js";
 import "./chunk-NDJLNC6Q.js";
 import {
   detectToolPresence
@@ -54,12 +59,12 @@ import {
 
 // src/scripts/_cli/cmd_conformance.ts
 var YAML = __toESM(require_dist(), 1);
-import * as fs13 from "node:fs";
+import * as fs14 from "node:fs";
 import * as os7 from "node:os";
-import * as path13 from "node:path";
-import process5 from "node:process";
+import * as path14 from "node:path";
+import process6 from "node:process";
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { fileURLToPath as fileURLToPath13, pathToFileURL as pathToFileURL13 } from "node:url";
+import { fileURLToPath as fileURLToPath14, pathToFileURL as pathToFileURL14 } from "node:url";
 
 // src/install/txlog.ts
 import { createReadStream, createWriteStream, existsSync, readFileSync, renameSync, statSync, unlinkSync } from "node:fs";
@@ -120,18 +125,18 @@ function routeTargetPathsPosix(target) {
 }
 
 // src/scripts/report_conformance_funnel.ts
-import * as fs12 from "node:fs";
+import * as fs13 from "node:fs";
 import * as os6 from "node:os";
-import * as path12 from "node:path";
-import process4 from "node:process";
-import { fileURLToPath as fileURLToPath12, pathToFileURL as pathToFileURL12 } from "node:url";
+import * as path13 from "node:path";
+import process5 from "node:process";
+import { fileURLToPath as fileURLToPath13, pathToFileURL as pathToFileURL13 } from "node:url";
 
 // src/scripts/conformance_scan.ts
 import { createHash as createHash3 } from "node:crypto";
-import fs8 from "node:fs";
+import fs9 from "node:fs";
 import os2 from "node:os";
-import path8 from "node:path";
-import { fileURLToPath as fileURLToPath8, pathToFileURL as pathToFileURL8 } from "node:url";
+import path9 from "node:path";
+import { fileURLToPath as fileURLToPath9, pathToFileURL as pathToFileURL9 } from "node:url";
 
 // src/scripts/_lib/transcript_entry.ts
 function _isObject(v) {
@@ -683,21 +688,37 @@ var WARN_OPS = /* @__PURE__ */ new Set([
   "branch"
 ]);
 var G = "(?:-[A-Za-z-]+(?:=\\S+)?(?:\\s+\\S+)?\\s+)*";
+var P = "^(?:\\S*\\/)?";
+function ghApiWrite(pathRe) {
+  return new RegExp(
+    `${P}gh\\s+api\\b(?=[^\\n]*${pathRe})(?=[^\\n]*(?:-X|--method)\\s+(?:POST|PATCH|PUT|DELETE)\\b)`,
+    "i"
+  );
+}
 var COMMAND_OPS = [
-  { op: "publish", re: new RegExp(`\\b(npm|pnpm|yarn)\\s+${G}publish\\b`, "i") },
-  { op: "release", re: /\bgh\s+release\s+create\b|\bgh\s+api\b[^\n]*\/releases\b/i },
+  { op: "publish", re: new RegExp(`${P}(npm|pnpm|yarn)\\s+${G}publish\\b`, "i") },
+  {
+    op: "release",
+    re: new RegExp(`${P}gh\\s+release\\s+create\\b|${ghApiWrite("\\/releases\\b").source}`, "i")
+  },
   {
     op: "tag",
+    re: new RegExp(`${P}git\\s+${G}push\\b[^\\n;|&]*(--tags|--follow-tags|refs\\/tags\\/)`, "i")
+  },
+  {
+    op: "pr-merge",
     re: new RegExp(
-      `\\bgit\\s+${G}push\\b[^\\n;|&]*(--tags|--follow-tags|refs\\/tags\\/)`,
+      `${P}gh\\s+pr\\s+merge\\b|${ghApiWrite("\\/pulls\\/\\d+\\/merge\\b").source}`,
       "i"
     )
   },
-  { op: "pr-merge", re: /\bgh\s+pr\s+merge\b|\bgh\s+api\b[^\n]*\/pulls\/\d+\/merge\b/i },
-  { op: "pr-create", re: /\bgh\s+pr\s+create\b|\bgh\s+api\b[^\n]*-X\s+POST[^\n]*\/pulls\b/i },
-  { op: "push", re: new RegExp(`\\bgit\\s+${G}push\\b`, "i") },
-  { op: "commit", re: new RegExp(`\\bgit\\s+${G}commit\\b`, "i") },
-  { op: "branch", re: new RegExp(`\\bgit\\s+${G}(checkout\\s+-b|switch\\s+-c)\\b`, "i") }
+  {
+    op: "pr-create",
+    re: new RegExp(`${P}gh\\s+pr\\s+create\\b|${ghApiWrite("\\/pulls\\b").source}`, "i")
+  },
+  { op: "push", re: new RegExp(`${P}git\\s+${G}push\\b`, "i") },
+  { op: "commit", re: new RegExp(`${P}git\\s+${G}commit\\b`, "i") },
+  { op: "branch", re: new RegExp(`${P}git\\s+${G}(checkout\\s+-b|switch\\s+-c)\\b`, "i") }
 ];
 var COMMAND_TOOLS = /* @__PURE__ */ new Set([
   "launch-process",
@@ -1808,12 +1829,19 @@ function readCiSettled(workspaceRoot) {
   return { seen: false, settled: false };
 }
 var _COMPLETION_RE = /(^|\n)\s*(?:\*\*)?(?:fertig\b|damit ist alles erledigt|aufgabe erledigt|alles erledigt\b|komplett(?:er)? (?:auftrag|abgearbeitet)|der komplette auftrag ist durch|done[.!]|all done\b|task complete)/i;
+var _NEGATED_CLAIM_RE = /\b(noch nicht|nicht fertig|nicht durch|wäre verfrüht|ist verfrüht|not yet|not done|isn'?t done|nein)\b/i;
+function _lineAround(prose, at) {
+  const start = prose.lastIndexOf("\n", at) + 1;
+  const end = prose.indexOf("\n", at);
+  return prose.slice(start, end === -1 ? prose.length : end);
+}
 function detectCompletionClaim(reply, ci) {
   if (!ci.seen || ci.settled) return null;
   const prose = visibleProse(reply);
   const m = _COMPLETION_RE.exec(prose);
   if (!m) return null;
   const at = m.index;
+  if (_NEGATED_CLAIM_RE.test(_lineAround(prose, at))) return null;
   return {
     detector: "completion",
     evidence: prose.slice(at, at + 120).trim(),
@@ -2107,7 +2135,7 @@ function isDispatchTool(tool) {
 function isEvaluationPrompt(prompt) {
   return EVALUATION_RE.test(prompt);
 }
-var SELF_SCOPE_RE = /\b(my (work|change|diff|implementation|code|fix|patch|branch|pr)|this (diff|change|branch|pr|delta|implementation|patch)|the delta|the change i|what i (wrote|built|changed|implemented)|i just (wrote|built|changed|implemented))\b/i;
+var SELF_SCOPE_RE = /\b(my (work|change|diff|implementation|code|fix|patch|branch|pr)|this (diff|change|pr|delta|implementation|patch)|the delta|the change i|what i (wrote|built|changed|implemented)|i just (wrote|built|changed|implemented))\b/i;
 function isSelfScoped(prompt) {
   return SELF_SCOPE_RE.test(prompt);
 }
@@ -2175,11 +2203,14 @@ function decide2(tool, prompt, priorEvaluations) {
   }
   if (priorEvaluations >= 1) {
     return {
-      exit: EXIT_BLOCK3,
-      stdout: "",
-      stderr: `Blocked: second evaluation dispatch of your own work in this turn (verdict shopping). One evaluation has already run; commissioning another with a different prompt or scope selects the answer instead of measuring it. Report what the first pass returned, then re-plan.
+      exit: EXIT_ALLOW5,
+      stdout: `${JSON.stringify({
+        decision: "warn",
+        reason: `Second evaluation dispatch of your own work in this turn. If both passes judge the SAME subject, that is verdict shopping \u2014 commissioning another with a different prompt or scope selects the answer instead of measuring it. Report what the first pass returned, then re-plan. If this is an implementation fan-out rather than a second review, carry on: this check reads prose and cannot tell the two apart with certainty.`
+      })}
 `,
-      evaluations: priorEvaluations
+      stderr: "",
+      evaluations: priorEvaluations + 1
     };
   }
   return {
@@ -2269,8 +2300,561 @@ if (_isCliEntry7()) {
   process.exit(main7());
 }
 
+// src/scripts/hooks/delegation_nudge_hook.ts
+import fs8 from "node:fs";
+import path8 from "node:path";
+import { fileURLToPath as fileURLToPath8, pathToFileURL as pathToFileURL8 } from "node:url";
+
+// src/scripts/_lib/host_capability.ts
+import process2 from "node:process";
+var SAFE_DEFAULT = {
+  schema_version: 1,
+  subagent_spawn: false,
+  parallel_spawn: false,
+  status_polling: false,
+  separate_quota_pool: false,
+  agent_teams: false,
+  worker_respawn: false
+};
+function asBool(value) {
+  return value === true;
+}
+function normalizeHostManifest(input) {
+  if (input === null || typeof input !== "object") {
+    return { ...SAFE_DEFAULT };
+  }
+  const src = input;
+  return {
+    schema_version: 1,
+    subagent_spawn: asBool(src.subagent_spawn),
+    parallel_spawn: asBool(src.parallel_spawn),
+    status_polling: asBool(src.status_polling),
+    separate_quota_pool: asBool(src.separate_quota_pool),
+    agent_teams: asBool(src.agent_teams),
+    worker_respawn: asBool(src.worker_respawn)
+  };
+}
+var HOST_CAPABILITY_REGISTRY = {
+  claude: { subagent_spawn: true, parallel_spawn: true }
+};
+function resolveHostCapabilities(hostId, override) {
+  if (override !== void 0 && override !== null && typeof override === "object" && !Array.isArray(override)) {
+    return normalizeHostManifest(override);
+  }
+  const row = hostId !== null && hostId !== void 0 ? HOST_CAPABILITY_REGISTRY[hostId] : void 0;
+  if (row === void 0) {
+    return { ...SAFE_DEFAULT };
+  }
+  return { ...SAFE_DEFAULT, ...row, schema_version: 1 };
+}
+function probeHostCapabilities(hostId) {
+  const base = resolveHostCapabilities(hostId);
+  const flag = process2.env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS;
+  const probedAgentTeams = typeof flag === "string" && flag !== "";
+  return { ...base, agent_teams: base.agent_teams || probedAgentTeams };
+}
+
+// src/scripts/_lib/auto_dispatch.ts
+var SIZE_FLOOR = 1;
+function inSession(reason) {
+  return { delegable: false, action: "in-session", mode: null, reason };
+}
+function classifyTask(signals, activation) {
+  if (activation.halted) return inSession("emergency.orchestration_halt is set");
+  if (!activation.subagent_spawn) return inSession("host has no subagent_spawn primitive");
+  if (!(signals.size_estimate > SIZE_FLOOR)) {
+    return inSession(`task below size floor (${signals.size_estimate} <= ${SIZE_FLOOR})`);
+  }
+  const slices = signals.independent_slices ?? 0;
+  let mode = null;
+  let reason = "";
+  if (signals.parallelizable === "steps" || signals.ordered_plan === true) {
+    mode = "do-in-steps";
+    reason = signals.parallelizable === "steps" ? "declared parallelizable: steps" : "ordered-plan structure";
+  } else if (signals.parallelizable === "files" || signals.parallelizable === "independent" || slices >= 2) {
+    mode = "do-in-parallel";
+    reason = signals.parallelizable ? `declared parallelizable: ${signals.parallelizable}` : `independent slices (${slices})`;
+  }
+  if (mode === null) {
+    return { delegable: false, action: "ask", mode: null, reason: "no delegable signal \u2014 borderline, ask" };
+  }
+  return { delegable: true, action: "dispatch", mode, reason };
+}
+var LOOKUP_PATTERNS = [
+  {
+    cls: "definition",
+    primitive: "code-graph-query",
+    re: /\b(where\s+is\s+\S+\s+defined|definition\s+(location|of|site)|find\s+the\s+definition|locate\s+the\s+(class|enum|function|type|interface|symbol)|confirm\w*\s+\S+\s+definition)\b/i
+  },
+  {
+    cls: "references",
+    primitive: "code-graph-query",
+    re: /\b(who\s+(calls|imports|uses|references)|call\s*sites?|import\s+(call\s*)?sites?|reverse\s+references|where\s+is\s+\S+\s+(used|imported|referenced|called)|all\s+(callers|usages|references)\s+of)\b/i
+  },
+  {
+    cls: "string-existence",
+    primitive: "fts-or-capped-grep",
+    re: /\b(does\s+(the\s+)?string\s+.*\bexist|is\s+(the\s+)?string\s+.*\b(present|used)\b|prob\w+\s+(candidate\s+)?strings?|search\s+for\s+the\s+(exact\s+)?string|(grep|check)\s+(for\s+)?(the\s+)?(literal|string)\b|does\s+\S+\s+appear\s+anywhere)/i
+  },
+  {
+    cls: "report-run",
+    primitive: "script-run-rtk",
+    re: /\b(run(ning)?\s+(the\s+)?\S*(report|check|lint\w*|coverage)\b|run(ning)?\s+(check|lint|report)_\w+|regenerate\s+the\s+\S+\s+report)/i
+  }
+];
+function classifyLookup(taskText) {
+  for (const p of LOOKUP_PATTERNS) {
+    if (p.re.test(taskText)) {
+      return {
+        lookup_class: p.cls,
+        route: "primitive",
+        primitive: p.primitive,
+        reason: `lookup-class ${p.cls} \u2014 deterministic primitive, no spawn`
+      };
+    }
+  }
+  return {
+    lookup_class: null,
+    route: "escalate",
+    primitive: null,
+    reason: "not lookup-shaped \u2014 regular classification path (never down-guessed)"
+  };
+}
+
+// src/scripts/_lib/judgment_ladder.ts
+var RENAME_RE = /\brename\s+\S+\s+to\s+\S+\b/i;
+var CODEMOD_RE = /\bcodemod\b/i;
+var FORMATTER_RUN_RE = /\bauto-?format(?:ting)?\b|\breformat(?:ting)?\b|\brun(?:ning)?\s+prettier\b|\brun(?:ning)?\s+eslint\s*--fix\b|\bapply\s+eslint\s*--fix\b/i;
+var SEARCH_REPLACE_RE = /\bsearch-and-replace\b|\bfind-and-replace\b|\bbulk\s+rename\b/i;
+function detectMechanicalTransform(text) {
+  const rename = RENAME_RE.exec(text);
+  if (rename) {
+    return { matched: true, reason: `rename signal ("${rename[0]}") \u2014 deterministic script, no spawn` };
+  }
+  const codemod = CODEMOD_RE.exec(text);
+  if (codemod) {
+    return { matched: true, reason: `codemod signal ("${codemod[0]}") \u2014 deterministic script, no spawn` };
+  }
+  const formatter = FORMATTER_RUN_RE.exec(text);
+  if (formatter) {
+    return { matched: true, reason: `formatter-run signal ("${formatter[0]}") \u2014 deterministic script, no spawn` };
+  }
+  const searchReplace = SEARCH_REPLACE_RE.exec(text);
+  if (searchReplace) {
+    return {
+      matched: true,
+      reason: `search-and-replace/bulk-rename signal ("${searchReplace[0]}") \u2014 deterministic script, no spawn`
+    };
+  }
+  return { matched: false, reason: "no mechanical-transform signal" };
+}
+var SINGLE_SLICE_READHEAVY_RE = /\b(?:read|review|summarize|summarise|inventory|audit|investigate|research|inspect|dig into|look into)\b[^.!?\n]{0,80}\b(?:this file|the file|this codebase|the codebase|this transcript|the transcript|this log|the log|this document|the document|this diff|the diff)\b/i;
+function detectBoundedReadHeavySlice(text) {
+  const m = SINGLE_SLICE_READHEAVY_RE.exec(text);
+  return m ? {
+    matched: true,
+    reason: `single bounded read-heavy slice ("${m[0]}") \u2014 one lite-tier subagent instead of session-context burn`
+  } : { matched: false, reason: "no single-slice read-heavy signal" };
+}
+var CROSS_LAYER_RE = /\bcross[- ]layer\b|\bcross[- ]cutting\b|\bback[- ]?end\s+and\s+front[- ]?end\b|\bfront[- ]?end\s+and\s+back[- ]?end\b/i;
+var REVIEW_WITH_CHALLENGE_RE = /\breview[- ]with[- ]challenge\b|\bchallenge[- ]and[- ]implement\b|\bimplementer\s+and\s+(?:a\s+)?(?:judge|reviewer)\s+(?:working\s+)?together\b|\bsecond\s+opinion\s+while\s+(?:building|implementing)\b/i;
+var SHARED_TASK_LIST_RE = /\bshared\s+(?:task\s+list|todo\s+list|backlog)\b|\bcoordinat(?:e|ed|ing)\s+(?:with|between|across)\s+(?:multiple\s+|several\s+)?(?:agents|workers|subagents|teammates)\b/i;
+function detectCommunicationNeed(text) {
+  const crossLayer = CROSS_LAYER_RE.exec(text);
+  if (crossLayer) {
+    return { matched: true, reason: `cross-layer communication signal ("${crossLayer[0]}")` };
+  }
+  const reviewChallenge = REVIEW_WITH_CHALLENGE_RE.exec(text);
+  if (reviewChallenge) {
+    return { matched: true, reason: `review-with-challenge signal ("${reviewChallenge[0]}")` };
+  }
+  const sharedList = SHARED_TASK_LIST_RE.exec(text);
+  if (sharedList) {
+    return { matched: true, reason: `shared-task-list signal ("${sharedList[0]}")` };
+  }
+  return { matched: false, reason: "no communication-need signal" };
+}
+var DESIGN_DECISION_RE = /\bdesign\s+decision\b|\barchitectur(?:e|al)\s+decision\b|\b(?:record(?:ing)?|decide|deciding|decision|accept(?:ed|ing)?|approv(?:e|ed|ing|al)|challeng(?:e|ed|ing)|choos(?:e|ing)|reject(?:ed|ing)?)\b[^.!?\n]{0,40}\bADR\b|\bADR\b[^.!?\n]{0,40}\b(?:record(?:ing)?|decide|deciding|decision|accept(?:ed|ing)?|approv(?:e|ed|ing|al)|challeng(?:e|ed|ing)|choos(?:e|ing)|reject(?:ed|ing)?)\b/i;
+var SECURITY_DOWNGRADE_RE = /\bsecurity\s+downgrade\b|\bdowngrade\s+(?:the\s+)?security\b|\bsecurity\s+exception\b/i;
+var RELEASE_GATE_ESCALATION_RE = /\bgate\s+escalation\b|\bescalat(?:e|ion)\s+to\s+(?:the\s+)?council\b|\b(?:escalat(?:e|ing|ion)|contest(?:ed|ing)?|dispute|disputing|override|overriding|waiv(?:e|ing)|bypass(?:ed|ing)?|challeng(?:e|ed|ing))\b[^.!?\n]{0,40}\brelease[- ]gate\b|\brelease[- ]gate\b[^.!?\n]{0,40}\b(?:escalat(?:e|ing|ion)|contest(?:ed|ing)?|dispute|disputing|override|overriding|waiv(?:e|ing)|bypass(?:ed|ing)?|challeng(?:e|ed|ing))\b/i;
+function detectContestedJudgment(text) {
+  const design = DESIGN_DECISION_RE.exec(text);
+  if (design) {
+    return { matched: true, reason: `design-decision signal ("${design[0]}")` };
+  }
+  const security = SECURITY_DOWNGRADE_RE.exec(text);
+  if (security) {
+    return { matched: true, reason: `security-downgrade signal ("${security[0]}")` };
+  }
+  const releaseGate = RELEASE_GATE_ESCALATION_RE.exec(text);
+  if (releaseGate) {
+    return { matched: true, reason: `release-gate-escalation signal ("${releaseGate[0]}")` };
+  }
+  return { matched: false, reason: "no contested-judgment signal" };
+}
+var _QUESTION_IMPERATIVE_RE = /\b(fix|implement|refactor|build|create|write|add|update|delete|remove|rename|migrate|install|deploy|commit|push|merge|run|execute|generate|erstelle|baue|implementiere|schreibe|behebe)\b/i;
+var _QUESTION_LEAD_RE = /^(is|are|does|do|did|can|could|should|would|will|which|what|why|how|when|where|who|whose|ist|sind|hat|haben|kann|welche[rs]?|was|warum|wie|wann|wo|wer)\b/i;
+var _CLASSIFY_LEAD_RE = /^(classify|categori[sz]e|klassifiziere)\b/i;
+var _QUESTION_MAX_LEN = 240;
+var _NEEDS_TOOLS_RE = /\b(this|the|that|my|our)\s+(?:[\w-]+\s+){0,2}?(file|files|codebase|repo|repository|transcript|log|logs|diff|document|branch|pr|route|routes|schema|module|class|function|endpoint|test|tests)\b|[\w.-]+\/[\w.-]+|\b[\w-]+\.(ts|js|py|php|md|json|yaml|yml|sh|go|rs)\b/i;
+function detectBoundedQuestion(taskText) {
+  const text = taskText.trim();
+  if (!text || text.length > _QUESTION_MAX_LEN || text.includes("\n")) {
+    return { matched: false, reason: "not-bounded" };
+  }
+  if (_NEEDS_TOOLS_RE.test(text)) {
+    return { matched: false, reason: "references-tool-requiring-objects" };
+  }
+  if (_CLASSIFY_LEAD_RE.test(text)) {
+    return {
+      matched: true,
+      reason: "bounded-question (classification) \u2014 rung-0.5 single completion via ask_transport, no session"
+    };
+  }
+  if (_QUESTION_IMPERATIVE_RE.test(text)) {
+    return { matched: false, reason: "imperative-work-verb" };
+  }
+  if (_QUESTION_LEAD_RE.test(text) && text.endsWith("?")) {
+    return {
+      matched: true,
+      reason: "bounded-question \u2014 rung-0.5 single completion via ask_transport, no session"
+    };
+  }
+  return { matched: false, reason: "no-interrogative-shape" };
+}
+function classifyLadder(inp) {
+  if (inp.interactiveApprovalRequired === true) {
+    return {
+      rung: null,
+      verdict: "in-session",
+      reason: "interactive-approval-required \u2014 caller-stated, needs a human decision before anything may run"
+    };
+  }
+  const lookup = classifyLookup(inp.taskText);
+  if (lookup.route === "primitive") {
+    return { rung: 0, verdict: "script", reason: `lookup-class ${lookup.lookup_class} \u2014 ${lookup.reason}` };
+  }
+  const mechanical = detectMechanicalTransform(inp.taskText);
+  if (mechanical.matched) {
+    return { rung: 0, verdict: "script", reason: mechanical.reason };
+  }
+  if (inp.insideSubagentSession === true) {
+    return {
+      rung: null,
+      verdict: "in-session",
+      reason: "recursive-dispatch guard: this classification runs inside a subagent/teammate session \u2014 rungs 1-4 resolve in-session"
+    };
+  }
+  if (inp.activation.halted) {
+    return { rung: null, verdict: "in-session", reason: "emergency.orchestration_halt is set" };
+  }
+  if (!inp.activation.subagent_spawn) {
+    return { rung: null, verdict: "in-session", reason: "host has no subagent_spawn primitive" };
+  }
+  const contested = detectContestedJudgment(inp.taskText);
+  if (contested.matched) {
+    return { rung: 4, verdict: "council", reason: contested.reason };
+  }
+  const communication = detectCommunicationNeed(inp.taskText);
+  if (communication.matched) {
+    if (inp.agentTeams) {
+      return { rung: 3, verdict: "team", reason: communication.reason };
+    }
+    const fallback = classifyTask(inp.signals, inp.activation);
+    if (fallback.action === "dispatch" && fallback.mode !== null) {
+      return {
+        rung: 2,
+        verdict: "subagent",
+        mode: fallback.mode,
+        degraded_from: 3,
+        reason: `${communication.reason} \u2014 no agent_teams host capability, degraded to rung 2 (${fallback.reason})`
+      };
+    }
+    return {
+      rung: null,
+      verdict: fallback.action === "ask" ? "ask" : "in-session",
+      degraded_from: 3,
+      reason: `${communication.reason} \u2014 no agent_teams host capability, degraded below rung 2 (${fallback.reason})`
+    };
+  }
+  const classification = classifyTask(inp.signals, inp.activation);
+  if (classification.action === "dispatch" && classification.mode !== null) {
+    return { rung: 2, verdict: "subagent", mode: classification.mode, reason: classification.reason };
+  }
+  if (inp.signals.size_estimate <= SIZE_FLOOR) {
+    const question = detectBoundedQuestion(inp.taskText);
+    if (question.matched) {
+      return { rung: 0.5, verdict: "ask", reason: question.reason };
+    }
+    return {
+      rung: null,
+      verdict: classification.action === "ask" ? "ask" : "in-session",
+      reason: classification.reason
+    };
+  }
+  const single = detectBoundedReadHeavySlice(inp.taskText);
+  if (single.matched) {
+    return { rung: 1, verdict: "subagent", mode: null, reason: single.reason };
+  }
+  return {
+    rung: null,
+    verdict: classification.action === "ask" ? "ask" : "in-session",
+    reason: classification.reason
+  };
+}
+
+// src/scripts/_lib/subagent_routing.ts
+function modelForTier(tier, map) {
+  if (tier === "lite") return map.lite ?? "";
+  if (tier === "medium") return map.medium ?? "";
+  if (tier === "high") return map.high ?? "";
+  return "";
+}
+function resolveSubagentRouting(inp) {
+  const tier = !inp.downshift || inp.task_tier === "inherit" ? inp.session_tier : inp.task_tier;
+  const downshifted = inp.downshift && inp.task_tier !== "inherit" && tier !== inp.session_tier;
+  const applied = inp.downshift && inp.task_tier !== "inherit";
+  const tier_source = applied ? inp.task_tier_origin ?? "static" : "inherit";
+  const useSeparate = inp.quota_arbitrage && inp.separate_quota_pool;
+  const quota_pool = useSeparate ? "separate" : "shared";
+  const reasonParts = [];
+  reasonParts.push(downshifted ? `downshift to ${tier}` : `session tier ${tier}`);
+  reasonParts.push(useSeparate ? "separate quota pool (bonus)" : "shared quota pool");
+  return {
+    tier,
+    model: modelForTier(tier, inp.model_map),
+    quota_pool,
+    tier_source,
+    reason: reasonParts.join(" \xB7 ")
+  };
+}
+
+// src/scripts/hooks/delegation_nudge_hook.ts
+var EXIT_ALLOW6 = 0;
+var EXIT_WARN3 = 2;
+function _isObject7(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+var FILE_TOKEN_RE = /`?\b[\w][\w.\-]{0,80}\.(ts|tsx|js|jsx|mjs|cjs|py|php|rb|go|rs|java|kt|swift|md|mdx|json|ya?ml|css|scss|less|html|vue|svelte|sql|sh|bash|c|cpp|h|hpp|cs|toml|xml)\b`?/gi;
+var FILE_SIGNAL_FLOOR = 3;
+function enumeratedFileTokens(text) {
+  const matches = text.match(FILE_TOKEN_RE) ?? [];
+  return [...new Set(matches.map((m) => m.replace(/`/g, "").toLowerCase()))];
+}
+function detectEnumeratedFiles(text) {
+  return enumeratedFileTokens(text).length;
+}
+var EXPLICIT_COUNT_RE = /\b(\d+)\s+(files?|modules?|components?|endpoints?|scripts?|skills?|rules?|tickets?|tests?|screens?|pages?|repos?|services?|classes?|functions?|methods?|slices?|tasks?|items?|targets?|routes?|controllers?|Dateien|Module|Tests|Komponenten|Skripte|Regeln|Tickets|Aufgaben|Klassen|Funktionen|Endpunkte)\b/i;
+function detectExplicitSliceCount(text) {
+  const m = EXPLICIT_COUNT_RE.exec(text);
+  if (!m) return null;
+  const n = Number.parseInt(m[1] ?? "", 10);
+  return Number.isFinite(n) && n > 0 ? n : null;
+}
+var FOR_EACH_RE = /\bfor\s+each\b|\bfor\s+every\b|\beach\s+of\s+the\b|\bevery\s+one\s+of\b|\ball(?:e|en)\b|\bjed(?:e|er|es|en)\b|\bjeweils\b/i;
+function detectForEachShape(text) {
+  return FOR_EACH_RE.test(text);
+}
+function detectMultiDeliverableConjunction(text) {
+  for (const sentence of text.split(/[.!?\n]+/)) {
+    const commaCount = (sentence.match(/,/g) ?? []).length;
+    if (commaCount < 2) continue;
+    const tail = sentence.slice(sentence.lastIndexOf(",") + 1);
+    if (/^\s*(and|und)\b/i.test(tail)) {
+      return commaCount + 1;
+    }
+  }
+  return 0;
+}
+var STEP_WORD_RE = /\b(?:step|schritt)\s*\d+\b/gi;
+var STEP_LINE_RE = /^\s*\d+[.)]\s+\S/gm;
+var ORDERED_LINE_FLOOR = 3;
+var ORDERED_WORD_FLOOR = 2;
+function detectOrderedPlan(text) {
+  const wordMatches = text.match(STEP_WORD_RE) ?? [];
+  const lineMatches = text.match(STEP_LINE_RE) ?? [];
+  const ordered = wordMatches.length >= ORDERED_WORD_FLOOR || lineMatches.length >= ORDERED_LINE_FLOOR;
+  const count = Math.max(wordMatches.length, lineMatches.length);
+  return { ordered, stepCount: count };
+}
+function extractTaskSignals(text) {
+  const ordered = detectOrderedPlan(text);
+  if (ordered.ordered) {
+    return {
+      signals: {
+        parallelizable: null,
+        ordered_plan: true,
+        independent_slices: 0,
+        size_estimate: Math.max(ordered.stepCount, 2)
+      },
+      sliceCountForLine: ordered.stepCount
+    };
+  }
+  const fileCount = detectEnumeratedFiles(text);
+  const explicit = detectExplicitSliceCount(text) ?? 0;
+  const conjunction = detectMultiDeliverableConjunction(text);
+  const forEach = detectForEachShape(text);
+  const fileSignal = fileCount >= FILE_SIGNAL_FLOOR ? fileCount : 0;
+  let slices = Math.max(fileSignal, explicit, conjunction);
+  if (slices === 0 && forEach) {
+    slices = 2;
+  }
+  const parallelizable = fileSignal >= 3 ? "files" : forEach ? "independent" : null;
+  return {
+    signals: {
+      parallelizable,
+      ordered_plan: false,
+      independent_slices: slices,
+      size_estimate: slices > 0 ? Math.max(slices, 2) : 0
+    },
+    sliceCountForLine: slices
+  };
+}
+function resolveActivation(workspace_root, hostId) {
+  const settings = load_agent_settings({ cwd: workspace_root });
+  const emergency = settings["emergency"] ?? {};
+  const halted = emergency["orchestration_halt"] === true;
+  const host_manifest = probeHostCapabilities(hostId);
+  const sub = settings["subagents"] ?? {};
+  const downshift = sub["downshift"] !== false;
+  return {
+    activation: { halted, subagent_spawn: host_manifest.subagent_spawn },
+    downshift,
+    separate_quota_pool: host_manifest.separate_quota_pool,
+    agentTeams: host_manifest.agent_teams
+  };
+}
+function recommendSliceTier(downshift, separate_quota_pool) {
+  const decision = resolveSubagentRouting({
+    task_tier: "lite",
+    session_tier: "high",
+    downshift,
+    quota_arbitrage: false,
+    model_map: {},
+    separate_quota_pool
+  });
+  return decision.tier;
+}
+function buildNudgeLine(rung, classification, sliceCount, tier) {
+  const unit = sliceCount === 1 ? "slice" : "slices";
+  const rungLabel = rung === null ? "rung-?" : `rung-${rung}`;
+  if (rung === 0.5) {
+    return `<delegation-nudge>rung-0.5: ask, est. <1k tokens. This is a single bounded question \u2014 answer it via ONE completion (\`./scripts-run src/scripts/ask_transport "<question>"\`) instead of a subagent spawn (measured spawn floor: ~251k tokens) \u2014 ${classification.reason}.</delegation-nudge>`;
+  }
+  const modeLabel = classification.mode ?? "single-slice";
+  return `<delegation-nudge>${rungLabel}: dispatch ${modeLabel} (${sliceCount} ${unit}, ${tier} tier recommended). Consider dispatching via subagent-orchestration instead of doing every slice in-session \u2014 ${classification.reason}.</delegation-nudge>`;
+}
+function classifyPrompt(prompt, workspace_root, hostId) {
+  try {
+    const { signals, sliceCountForLine } = extractTaskSignals(prompt);
+    const { activation, downshift, separate_quota_pool, agentTeams } = resolveActivation(
+      workspace_root,
+      hostId
+    );
+    const sessionRole = resolveSessionRole(process.env);
+    const ladder = classifyLadder({
+      taskText: prompt,
+      signals,
+      activation,
+      agentTeams,
+      insideSubagentSession: sessionRole !== "orchestrator"
+    });
+    if (ladder.verdict !== "subagent") {
+      return null;
+    }
+    const tier = recommendSliceTier(downshift, separate_quota_pool);
+    const sliceCount = ladder.rung === 1 ? 1 : sliceCountForLine;
+    const classification = {
+      delegable: true,
+      action: "dispatch",
+      mode: ladder.mode ?? null,
+      reason: ladder.reason
+    };
+    return { classification, sliceCount, tier, rung: ladder.rung };
+  } catch {
+    return null;
+  }
+}
+function _extractPrompt2(payload) {
+  for (const key of ["prompt", "userPrompt", "user_prompt", "message", "text"]) {
+    const v = payload[key];
+    if (typeof v === "string" && v.trim()) {
+      return v;
+    }
+  }
+  return "";
+}
+function _workspaceRoot(envelope) {
+  const v = envelope["workspace_root"];
+  if (typeof v === "string" && v) {
+    return v;
+  }
+  return process.cwd();
+}
+function main8() {
+  let envelope = {};
+  try {
+    const raw = readHookStdin();
+    envelope = raw.trim() ? JSON.parse(raw) : {};
+  } catch {
+    return EXIT_ALLOW6;
+  }
+  const env = _isObject7(envelope) ? envelope : {};
+  const event = env["event"];
+  const slot = typeof event === "string" && event !== "" ? event : "user_prompt_submit";
+  if (slot !== "user_prompt_submit") {
+    return EXIT_ALLOW6;
+  }
+  const payload = _isObject7(env["payload"]) ? env["payload"] : env;
+  const prompt = _extractPrompt2(payload);
+  if (!prompt) {
+    return EXIT_ALLOW6;
+  }
+  if (isSyntheticPrompt(prompt)) {
+    return EXIT_ALLOW6;
+  }
+  const root = _workspaceRoot(env);
+  const platform = env["platform"];
+  const hostId = typeof platform === "string" && platform ? platform : null;
+  const result = classifyPrompt(prompt, root, hostId);
+  if (!result) {
+    return EXIT_ALLOW6;
+  }
+  process.stdout.write(
+    `${JSON.stringify({
+      decision: "warn",
+      reason: `delegation-nudge: rung-${result.rung} verdict (${result.sliceCount} slices, ${result.tier} tier)`,
+      additional_context: buildNudgeLine(result.rung, result.classification, result.sliceCount, result.tier)
+    })}
+`
+  );
+  return EXIT_WARN3;
+}
+function _isCliEntry8() {
+  if (true) {
+    return false;
+  }
+  if (process.argv[1] === void 0) {
+    return false;
+  }
+  const argvUrl = pathToFileURL8(path8.resolve(process.argv[1])).href;
+  if (import.meta.url === argvUrl) {
+    return true;
+  }
+  try {
+    const here = fs8.realpathSync(fileURLToPath8(import.meta.url));
+    const argv = fs8.realpathSync(path8.resolve(process.argv[1]));
+    return here === argv;
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry8()) {
+  process.exit(main8());
+}
+
 // src/scripts/conformance_scan.ts
-var REPO_ROOT = path8.resolve(path8.dirname(fileURLToPath8(import.meta.url)), "..", "..");
+var REPO_ROOT = path9.resolve(path9.dirname(fileURLToPath9(import.meta.url)), "..", "..");
 var OBSERVED_BAND = { low: 9.1, high: 39.2 };
 var BAND_MIN_TURNS = 1978;
 var CARRIER_CHANGES = [
@@ -2304,14 +2888,19 @@ var CHECK_IDS = [
   "git-authorization",
   "vacuous-evidence",
   "evidence-steering",
-  "completion-claim"
+  "completion-claim",
+  "task-completeness"
 ];
 var CHECK_MEANINGS = {
   "language-pin": "An assistant turn whose user-visible prose is not in the language that turn's own pin named. Carries provenance (turns_since_prompt, compaction_since_prompt) so a pin that was ABSENT because compaction removed it stays distinguishable from one that was present and ignored.",
   "git-authorization": "A gated git operation performed in a session where no authorization for that operation was observed. Authorization is per-operation and never carries from one to the next.",
   "vacuous-evidence": "A CI poll read as settled without ever observing an in-flight run \u2014 the poll gap that reports a green settle over a window in which nothing was pending yet.",
   "evidence-steering": "A self-commissioned evaluation whose prompt pre-loaded its own verdict, or a second self-scoped evaluation of the same subject within one turn.",
-  "completion-claim": "An assistant turn claiming the work is complete while the last CI read in that session was NOT settled. Round 7 measured 14 instances by reading, each followed by the user handing the work back; this is the same predicate `turn-end-gate`'s completion detector refuses on, so the rate and the gate cannot disagree. A session that never polled CI can never hit."
+  "completion-claim": "An assistant turn claiming the work is complete while the last CI read in that session was NOT settled. Round 7 measured 14 instances by reading, each followed by the user handing the work back; this is the same predicate `turn-end-gate`'s completion detector refuses on, so the rate and the gate cannot disagree. A session that never polled CI can never hit.",
+  "task-completeness": `A reply window that left at least one file the prompt ENUMERATED untouched \u2014 the token appears in neither any tool-call input nor any assistant prose before the next user prompt. Scope is deliberately narrow: only prompts naming >= ${FILE_SIGNAL_FLOOR} distinct file tokens are measured, the same floor \`delegation_nudge_hook\` uses for its FILE shape, and the token list comes from that module rather than a second regex.
+    What distinguishes a hit from a false read: a hit is EVIDENCE OF AN OMISSION, not proof of one. Four legitimate shapes produce the same signature and are NOT excluded here \u2014 a blocking question, a hand-back, a user-fenced scope, and an explicitly deferred item all address fewer files than the prompt named, correctly. That is why every hit is hand-validated and a precision is published beside the rate; an unvalidated count from this check means nothing.
+    What it cannot see, stated so a zero is not misread as health: the ordered-plan, explicit-count, for-each and conjunction shapes name a COUNT of deliverables but not their identities, so this check is blind to them by construction \u2014 it does not score them complete, it does not score them at all. A prose deliverable that is not a filename is invisible to it.
+    MEASURED PRECISION: 0 of 3 hits, over 4 eligible windows in 28 sessions (2026-08-12). All three were false positives from ONE extraction defect: the token list is taken from the whole prompt, so files quoted inside material the user PASTED \u2014 a review, a log, an example \u2014 read as deliverables. In all three, the user's own ask contributed zero tokens. \`isInjectedBody\` did not filter them because it only excludes long ENGLISH text, and this corpus is mostly German (12 295 and 7 656 chars, both classified \`de\`, both passed); the one English case missed the 2 500-char cut by 12. So a hit here is not evidence of anything until the ask is separated from the pasted material. Detector D was NOT built on this result \u2014 see \`agents/evidence/analysis/task-completeness-measurement.md\`.`
 };
 function renderWhy(report, id) {
   const hits = report.per_session.flatMap((s) => s.violations.filter((v) => v.check === id));
@@ -2338,10 +2927,18 @@ function renderWhy(report, id) {
         `      provenance: turns_since_prompt=${since ?? "\u2014"} \xB7 compaction_since_prompt=${compacted ?? "\u2014"}`
       );
     }
+    const missed = v.missed;
+    if (missed !== void 0) {
+      const enumerated = v.enumerated;
+      const addressed = v.addressed;
+      lines.push(
+        `      provenance: enumerated=${enumerated ?? "\u2014"} \xB7 addressed=${addressed ?? "\u2014"} \xB7 missed=[${missed.join(", ")}]`
+      );
+    }
   }
   return lines.join("\n");
 }
-function _isObject7(v) {
+function _isObject8(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 function userText(entry) {
@@ -2365,15 +2962,15 @@ function assistantText(entry) {
 }
 function toolUses2(entry) {
   const msg = entry["message"];
-  const content = _isObject7(msg) ? msg["content"] : void 0;
+  const content = _isObject8(msg) ? msg["content"] : void 0;
   if (!Array.isArray(content)) {
     return [];
   }
-  return content.filter((b) => _isObject7(b) && b["type"] === "tool_use").map((b) => {
+  return content.filter((b) => _isObject8(b) && b["type"] === "tool_use").map((b) => {
     const o = b;
     return {
       name: String(o["name"] ?? ""),
-      input: _isObject7(o["input"]) ? o["input"] : {}
+      input: _isObject8(o["input"]) ? o["input"] : {}
     };
   });
 }
@@ -2385,6 +2982,24 @@ function isInjectedBody(text) {
 }
 var HARNESS_TEXT = /^(API Error:|Request (timed out|was aborted)|\[Request interrupted|Error: |Credit balance is too low|You've hit your|Prompt is too long)/i;
 var EN_OPENER = /^(let me|i'?ll |i'?m |found it|ok[,. ]|okay|alright|here'?s|now[,. ]|looking|checking|reading|running|the |this |that |there |we |you |good |right[,. ]|perfect|done[.,]|all |confirmed|correct)/i;
+function markAddressed(text, w) {
+  if (w.tokens.length === 0) {
+    return;
+  }
+  const hay = text.toLowerCase();
+  for (const t of w.tokens) {
+    if (!w.addressed.has(t) && hay.includes(t)) {
+      w.addressed.add(t);
+    }
+  }
+}
+function evaluateWindow(w) {
+  if (!w.worked || w.tokens.length === 0) {
+    return null;
+  }
+  const missed = w.tokens.filter((t) => !w.addressed.has(t));
+  return missed.length > 0 ? { missed } : null;
+}
 function scanSession(sessionId, lines) {
   const report = {
     session: sessionId,
@@ -2392,7 +3007,8 @@ function scanSession(sessionId, lines) {
     assistant_turns: 0,
     violations: [],
     de_pin_turns: 0,
-    first_at: ""
+    first_at: "",
+    completeness_windows: 0
   };
   let pinned = null;
   let pendingPoll = null;
@@ -2403,6 +3019,29 @@ function scanSession(sessionId, lines) {
   let compactionSincePrompt = false;
   let ciSeen = false;
   let ciSettled = false;
+  let openWindow = null;
+  const closeWindow = () => {
+    if (openWindow === null) {
+      return;
+    }
+    if (openWindow.worked) {
+      report.completeness_windows += 1;
+    }
+    const verdict = evaluateWindow(openWindow);
+    if (verdict !== null) {
+      const addressed = openWindow.tokens.length - verdict.missed.length;
+      report.violations.push({
+        check: "task-completeness",
+        session: sessionId,
+        at: openWindow.at,
+        detail: `prompt enumerated ${openWindow.tokens.length} file(s), reply window touched ${addressed}; untouched: ${verdict.missed.join(", ").slice(0, 160)}`,
+        enumerated: openWindow.tokens.length,
+        addressed,
+        missed: verdict.missed
+      });
+    }
+    openWindow = null;
+  };
   for (const line of lines) {
     if (!line.trim()) {
       continue;
@@ -2451,6 +3090,16 @@ function scanSession(sessionId, lines) {
         continue;
       }
       report.user_turns += 1;
+      closeWindow();
+      const deliverables = enumeratedFileTokens(ut);
+      if (deliverables.length >= FILE_SIGNAL_FLOOR) {
+        openWindow = {
+          at: String(entry["timestamp"] ?? ""),
+          tokens: deliverables,
+          addressed: /* @__PURE__ */ new Set(),
+          worked: false
+        };
+      }
       turnsSincePrompt = 0;
       compactionSincePrompt = false;
       const c = classify(ut);
@@ -2471,6 +3120,11 @@ function scanSession(sessionId, lines) {
     if (prose !== null) {
       report.assistant_turns += 1;
       turnsSincePrompt += 1;
+      const firstLine = (prose.split("\n").find((l) => l.trim()) ?? "").trim();
+      if (openWindow !== null && !HARNESS_TEXT.test(firstLine)) {
+        openWindow.worked = true;
+        markAddressed(prose, openWindow);
+      }
       if (pinned === "de") {
         report.de_pin_turns += 1;
       }
@@ -2504,6 +3158,10 @@ function scanSession(sessionId, lines) {
       }
     }
     for (const tu of toolUses2(entry)) {
+      if (openWindow !== null) {
+        openWindow.worked = true;
+        markAddressed(`${tu.name} ${JSON.stringify(tu.input)}`, openWindow);
+      }
       const cmd = typeof tu.input["command"] === "string" ? tu.input["command"] : null;
       if (cmd !== null) {
         const op = commandOp(cmd);
@@ -2543,9 +3201,10 @@ function scanSession(sessionId, lines) {
       }
     }
   }
+  closeWindow();
   return report;
 }
-var DEFAULT_RATE_SERIES = path8.join(
+var DEFAULT_RATE_SERIES = path9.join(
   REPO_ROOT,
   "agents",
   "runtime",
@@ -2553,8 +3212,8 @@ var DEFAULT_RATE_SERIES = path8.join(
   "conformance-rates.jsonl"
 );
 function defaultStore(projectDir) {
-  const slug = projectDir.replace(/[/.]/g, "-");
-  return path8.join(process.env["HOME"] ?? "", ".claude", "projects", slug);
+  const slug = projectStoreSlug(projectDir);
+  return path9.join(process.env["HOME"] ?? "", ".claude", "projects", slug);
 }
 function _tokens(chars) {
   return Math.round(chars / 4);
@@ -2565,13 +3224,13 @@ function measureDelivered(projectRulesDir, globalRulesDir) {
   return {
     project: {
       dir: projectRulesDir,
-      present: fs8.existsSync(projectRulesDir),
+      present: fs9.existsSync(projectRulesDir),
       files: p.files,
       tokens: _tokens(p.chars)
     },
     global: {
       dir: globalRulesDir,
-      present: fs8.existsSync(globalRulesDir),
+      present: fs9.existsSync(globalRulesDir),
       files: g.files,
       tokens: _tokens(g.chars)
     },
@@ -2579,13 +3238,13 @@ function measureDelivered(projectRulesDir, globalRulesDir) {
   };
 }
 function storeKey(store) {
-  return createHash3("sha256").update(path8.resolve(store)).digest("hex").slice(0, 12);
+  return createHash3("sha256").update(path9.resolve(store)).digest("hex").slice(0, 12);
 }
 function scanStore(store, limit) {
-  const files = fs8.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => ({ f, m: fs8.statSync(path8.join(store, f)).mtimeMs })).sort((a, b) => b.m - a.m).slice(0, limit).map((x) => x.f);
+  const files = fs9.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => ({ f, m: fs9.statSync(path9.join(store, f)).mtimeMs })).sort((a, b) => b.m - a.m).slice(0, limit).map((x) => x.f);
   const per_session = [];
   for (const f of files) {
-    const lines = fs8.readFileSync(path8.join(store, f), "utf8").split("\n");
+    const lines = fs9.readFileSync(path9.join(store, f), "utf8").split("\n");
     const r = scanSession(f.replace(/\.jsonl$/, "").slice(0, 8), lines);
     if (r.assistant_turns > 0) {
       per_session.push(r);
@@ -2608,12 +3267,15 @@ function scanStore(store, limit) {
   const rate_pct = assistant_turns === 0 ? 0 : Number((100 * language_pin / assistant_turns).toFixed(1));
   const de_pin_turns = per_session.reduce((n, s) => n + s.de_pin_turns, 0);
   const rate_pct_de_pin = de_pin_turns === 0 ? 0 : Number((100 * language_pin / de_pin_turns).toFixed(1));
+  const completeness_windows = per_session.reduce((n, s) => n + s.completeness_windows, 0);
+  const task_completeness = totals["task-completeness"] ?? 0;
+  const task_completeness_rate_pct = completeness_windows === 0 ? 0 : Number((100 * task_completeness / completeness_windows).toFixed(1));
   const era = spansCarrierChange(per_session.map((s) => s.first_at));
   const delivered = measureDelivered(
-    path8.join(REPO_ROOT, ".claude", "rules"),
-    path8.join(process.env["HOME"] ?? os2.homedir(), ".claude", "rules")
+    path9.join(REPO_ROOT, ".claude", "rules"),
+    path9.join(process.env["HOME"] ?? os2.homedir(), ".claude", "rules")
   );
-  const ownStore = path8.resolve(store) === path8.resolve(defaultStore(REPO_ROOT));
+  const ownStore = path9.resolve(store) === path9.resolve(defaultStore(REPO_ROOT));
   return {
     scanned_at: (/* @__PURE__ */ new Date()).toISOString(),
     store,
@@ -2629,6 +3291,9 @@ function scanStore(store, limit) {
       rate_pct,
       de_pin_turns,
       rate_pct_de_pin,
+      completeness_windows,
+      task_completeness,
+      task_completeness_rate_pct,
       era_spanning: era.spans,
       era_reason: era.what,
       band: bandVerdict(rate_pct, assistant_turns, { spansCarrier: era.spans }),
@@ -2640,8 +3305,8 @@ function scanStore(store, limit) {
   };
 }
 function recordRate(file, scanned_at, rate) {
-  fs8.mkdirSync(path8.dirname(file), { recursive: true });
-  fs8.appendFileSync(file, `${JSON.stringify({ measured_at: scanned_at, ...rate })}
+  fs9.mkdirSync(path9.dirname(file), { recursive: true });
+  fs9.appendFileSync(file, `${JSON.stringify({ measured_at: scanned_at, ...rate })}
 `, "utf8");
 }
 function render(report) {
@@ -2683,6 +3348,18 @@ function render(report) {
     );
     lines.push("    is the comparable one and the second is the honest one. Both are printed.");
   }
+  const cWindows = report.rate.completeness_windows;
+  const cRate = report.rate.task_completeness_rate_pct;
+  if (typeof cWindows === "number" && typeof cRate === "number") {
+    lines.push("");
+    lines.push(
+      `  task-completeness  ${cRate.toFixed(1)}%  (${report.rate.task_completeness ?? 0} of ${cWindows} eligible reply windows)`
+    );
+    lines.push("    A hit is EVIDENCE of an omission, never proof: a blocking question, a");
+    lines.push("    hand-back, a fenced scope and a deferred item all produce this signature");
+    lines.push("    correctly. Read the hand-validated precision beside this figure or not");
+    lines.push("    at all \u2014 `--why task-completeness` lists every hit with its missed tokens.");
+  }
   if (report.rate.band === "era-spanning") {
     lines.push(
       `    Not compared: the corpus SPANS a carrier landing \u2014 ${report.rate.era_reason || "see CARRIER_CHANGES"}.`
@@ -2728,7 +3405,7 @@ function render(report) {
   lines.push("    checkbox batching                     \u2014 measured NOWHERE. ~5 low-severity findings.");
   return lines.join("\n");
 }
-function main8(argv) {
+function main9(argv) {
   const args = argv ?? process.argv.slice(2);
   let store = null;
   let limit = 30;
@@ -2760,14 +3437,14 @@ function main8(argv) {
     return 2;
   }
   const resolved = store ?? defaultStore(process.cwd());
-  if (!fs8.existsSync(resolved)) {
+  if (!fs9.existsSync(resolved)) {
     process.stderr.write(`conformance:behavior: no transcript store at ${resolved}
 `);
     return 1;
   }
   const report = scanStore(resolved, Number.isFinite(limit) && limit > 0 ? limit : 30);
   if (out) {
-    fs8.writeFileSync(out, `${JSON.stringify(report, null, 2)}
+    fs9.writeFileSync(out, `${JSON.stringify(report, null, 2)}
 `, "utf8");
   }
   if (record) {
@@ -2775,7 +3452,7 @@ function main8(argv) {
   }
   if (why !== null) {
     const id = why;
-    fs8.writeSync(
+    fs9.writeSync(
       1,
       json ? `${JSON.stringify(
         {
@@ -2795,48 +3472,48 @@ function main8(argv) {
     );
     return 0;
   }
-  fs8.writeSync(1, json ? `${JSON.stringify(report, null, 2)}
+  fs9.writeSync(1, json ? `${JSON.stringify(report, null, 2)}
 ` : `${render(report)}
 `);
   return 0;
 }
-function _isCliEntry8() {
+function _isCliEntry9() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL8(path8.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL9(path9.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs8.realpathSync(fileURLToPath8(import.meta.url));
-    const argv = fs8.realpathSync(path8.resolve(process.argv[1]));
+    const here = fs9.realpathSync(fileURLToPath9(import.meta.url));
+    const argv = fs9.realpathSync(path9.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry8()) {
-  process.exit(main8());
+if (_isCliEntry9()) {
+  process.exit(main9());
 }
 
 // src/scripts/report_carrier_divergence.ts
-import * as fs9 from "node:fs";
+import * as fs10 from "node:fs";
 import * as os3 from "node:os";
-import * as path9 from "node:path";
-import process2 from "node:process";
-import { fileURLToPath as fileURLToPath9, pathToFileURL as pathToFileURL9 } from "node:url";
-var _HERE = fileURLToPath9(import.meta.url);
-var REPO_ROOT2 = path9.resolve(path9.dirname(_HERE), "..", "..");
-var PROJECT_RULES = path9.join(".claude", "rules");
-var PROJECTION_SOURCE = path9.join("dist", "agent-src", "rules");
-var GLOBAL_RULES = path9.join(".claude", "rules");
+import * as path10 from "node:path";
+import process3 from "node:process";
+import { fileURLToPath as fileURLToPath10, pathToFileURL as pathToFileURL10 } from "node:url";
+var _HERE = fileURLToPath10(import.meta.url);
+var REPO_ROOT2 = path10.resolve(path10.dirname(_HERE), "..", "..");
+var PROJECT_RULES = path10.join(".claude", "rules");
+var PROJECTION_SOURCE = path10.join("dist", "agent-src", "rules");
+var GLOBAL_RULES = path10.join(".claude", "rules");
 function _listRules(dir) {
   try {
-    return fs9.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
+    return fs10.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
   } catch {
     return [];
   }
@@ -2844,7 +3521,7 @@ function _listRules(dir) {
 function _ruleType(file) {
   let text;
   try {
-    text = fs9.readFileSync(file, "utf-8");
+    text = fs10.readFileSync(file, "utf-8");
   } catch {
     return "";
   }
@@ -2855,8 +3532,8 @@ function compareCarriers(projectDir, globalDir, sourceDir) {
   const out = {
     projectDir,
     globalDir,
-    globalPresent: fs9.existsSync(globalDir),
-    projectPresent: fs9.existsSync(projectDir),
+    globalPresent: fs10.existsSync(globalDir),
+    projectPresent: fs10.existsSync(projectDir),
     shared: 0,
     identical: [],
     provenanceOnly: [],
@@ -2879,7 +3556,7 @@ function compareCarriers(projectDir, globalDir, sourceDir) {
     }
     if (!inP && inG) {
       out.globalOnly.push(rule);
-      if (sourceDir !== void 0 && _ruleType(path9.join(sourceDir, rule)) === "manual") {
+      if (sourceDir !== void 0 && _ruleType(path10.join(sourceDir, rule)) === "manual") {
         out.manualOnlyGlobal.push(rule);
       }
       continue;
@@ -2889,8 +3566,8 @@ function compareCarriers(projectDir, globalDir, sourceDir) {
     let projectCopy;
     let globalCopy;
     try {
-      projectCopy = fs9.readFileSync(path9.join(projectDir, rule));
-      globalCopy = fs9.readFileSync(path9.join(globalDir, rule));
+      projectCopy = fs10.readFileSync(path10.join(projectDir, rule));
+      globalCopy = fs10.readFileSync(path10.join(globalDir, rule));
       verdict = comparePair(projectCopy, globalCopy);
     } catch {
       out.shared -= 1;
@@ -3035,11 +3712,11 @@ function render2(d) {
   }
   return lines.join("\n");
 }
-function main9(argv) {
-  const args = argv ?? process2.argv.slice(2);
-  let projectDir = path9.join(REPO_ROOT2, PROJECT_RULES);
-  let globalDir = path9.join(os3.homedir(), GLOBAL_RULES);
-  let sourceDir = path9.join(REPO_ROOT2, PROJECTION_SOURCE);
+function main10(argv) {
+  const args = argv ?? process3.argv.slice(2);
+  let projectDir = path10.join(REPO_ROOT2, PROJECT_RULES);
+  let globalDir = path10.join(os3.homedir(), GLOBAL_RULES);
+  let sourceDir = path10.join(REPO_ROOT2, PROJECTION_SOURCE);
   const value = (i) => {
     const v = args[i + 1];
     return v === void 0 || v.startsWith("-") ? null : v;
@@ -3049,68 +3726,68 @@ function main9(argv) {
     if (a === "--project" || a === "--global" || a === "--source") {
       const v = value(i);
       if (v === null) {
-        process2.stderr.write(`report_carrier_divergence: ${a} needs a directory
+        process3.stderr.write(`report_carrier_divergence: ${a} needs a directory
 `);
         return 1;
       }
-      const resolved = path9.resolve(v);
+      const resolved = path10.resolve(v);
       if (a === "--project") projectDir = resolved;
       else if (a === "--global") globalDir = resolved;
       else sourceDir = resolved;
       i += 1;
     } else if (a === "--help" || a === "-h") {
-      process2.stdout.write(
+      process3.stdout.write(
         "usage: report_carrier_divergence [--project DIR] [--global DIR] [--source DIR]\n"
       );
       return 0;
     } else if (a !== void 0 && a.startsWith("--") && a !== "--quiet") {
-      process2.stderr.write(`report_carrier_divergence: unknown flag ${a}
+      process3.stderr.write(`report_carrier_divergence: unknown flag ${a}
 `);
       return 1;
     }
   }
-  process2.stdout.write(`${render2(compareCarriers(projectDir, globalDir, sourceDir))}
+  process3.stdout.write(`${render2(compareCarriers(projectDir, globalDir, sourceDir))}
 `);
   return 0;
 }
-function _isCliEntry9() {
-  if (process2.argv[1] === void 0) return false;
-  if (import.meta.url === pathToFileURL9(path9.resolve(process2.argv[1])).href) return true;
+function _isCliEntry10() {
+  if (process3.argv[1] === void 0) return false;
+  if (import.meta.url === pathToFileURL10(path10.resolve(process3.argv[1])).href) return true;
   try {
-    return fs9.realpathSync(_HERE) === fs9.realpathSync(path9.resolve(process2.argv[1]));
+    return fs10.realpathSync(_HERE) === fs10.realpathSync(path10.resolve(process3.argv[1]));
   } catch {
     return false;
   }
 }
-if (_isCliEntry9()) {
-  process2.exit(main9());
+if (_isCliEntry10()) {
+  process3.exit(main10());
 }
 
 // src/scripts/report_skill_activation.ts
-import * as fs10 from "node:fs";
+import * as fs11 from "node:fs";
 import * as os4 from "node:os";
-import * as path10 from "node:path";
-import { fileURLToPath as fileURLToPath10, pathToFileURL as pathToFileURL10 } from "node:url";
-var _HERE2 = fileURLToPath10(import.meta.url);
-var REPO_ROOT3 = path10.resolve(path10.dirname(_HERE2), "..", "..");
+import * as path11 from "node:path";
+import { fileURLToPath as fileURLToPath11, pathToFileURL as pathToFileURL11 } from "node:url";
+var _HERE2 = fileURLToPath11(import.meta.url);
+var REPO_ROOT3 = path11.resolve(path11.dirname(_HERE2), "..", "..");
 var SKILLS_ROOT = "src/skills";
 var TRIGGER_KEYS = ["triggers:", "trigger_description:", "file_pattern:", "path_prefix:"];
 var DETERMINISTIC_RE = /^\s*(?:[-*]\s*)?(?:\*\*)?(MUST|NEVER|ALWAYS)\b/m;
 function censusSkills(root) {
   const out = { total: 0, withTriggerKey: [], withDeterministicObligation: [] };
-  if (!fs10.existsSync(root)) {
+  if (!fs11.existsSync(root)) {
     return out;
   }
-  for (const entry of fs10.readdirSync(root, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+  for (const entry of fs11.readdirSync(root, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
     if (!entry.isDirectory()) {
       continue;
     }
-    const file = path10.join(root, entry.name, "SKILL.md");
-    if (!fs10.existsSync(file)) {
+    const file = path11.join(root, entry.name, "SKILL.md");
+    if (!fs11.existsSync(file)) {
       continue;
     }
     out.total += 1;
-    const text = fs10.readFileSync(file, "utf8");
+    const text = fs11.readFileSync(file, "utf8");
     const fmEnd = text.startsWith("---") ? text.indexOf("\n---", 3) : -1;
     const fm = fmEnd === -1 ? "" : text.slice(0, fmEnd);
     if (TRIGGER_KEYS.some((k) => new RegExp(`^${k}`, "m").test(fm))) {
@@ -3124,17 +3801,17 @@ function censusSkills(root) {
   return out;
 }
 function defaultStore2(cwd) {
-  return path10.join(os4.homedir(), ".claude", "projects", cwd.replace(/[/.]/g, "-"));
+  return path11.join(os4.homedir(), ".claude", "projects", projectStoreSlug(cwd));
 }
 function measureUsage(store, limit) {
   const rep = { store, sessions: 0, assistantTurns: 0, invocations: 0, bySkill: {} };
-  if (!fs10.existsSync(store)) {
+  if (!fs11.existsSync(store)) {
     return rep;
   }
-  const files = fs10.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => path10.join(store, f)).sort((a, b) => fs10.statSync(b).mtimeMs - fs10.statSync(a).mtimeMs).slice(0, limit);
+  const files = fs11.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => path11.join(store, f)).sort((a, b) => fs11.statSync(b).mtimeMs - fs11.statSync(a).mtimeMs).slice(0, limit);
   rep.sessions = files.length;
   for (const file of files) {
-    for (const line of fs10.readFileSync(file, "utf8").split("\n")) {
+    for (const line of fs11.readFileSync(file, "utf8").split("\n")) {
       if (!line.trim()) {
         continue;
       }
@@ -3197,7 +3874,7 @@ function render3(census, usage) {
     }
     totalInv += u.invocations;
     lines.push(
-      `  ${path10.basename(u.store).slice(-38).padEnd(38)} sessions=${String(u.sessions).padStart(3)} asst=${String(u.assistantTurns).padStart(6)} Skill calls=${String(u.invocations).padStart(3)}`
+      `  ${path11.basename(u.store).slice(-38).padEnd(38)} sessions=${String(u.sessions).padStart(3)} asst=${String(u.assistantTurns).padStart(6)} Skill calls=${String(u.invocations).padStart(3)}`
     );
   }
   lines.push("");
@@ -3222,7 +3899,7 @@ function render3(census, usage) {
   lines.push("  catalogue once per session, then count descriptions against bare names.");
   return lines.join("\n");
 }
-function main10(argv) {
+function main11(argv) {
   let limit = 30;
   const stores = [];
   for (let i = 0; i < argv.length; i += 1) {
@@ -3245,24 +3922,24 @@ function main10(argv) {
   if (stores.length === 0) {
     stores.push(defaultStore2(REPO_ROOT3));
   }
-  const census = censusSkills(path10.join(REPO_ROOT3, SKILLS_ROOT));
+  const census = censusSkills(path11.join(REPO_ROOT3, SKILLS_ROOT));
   const usage = stores.map((s) => measureUsage(s, limit));
   process.stdout.write(`${render3(census, usage)}
 `);
   return 0;
 }
-if (process.argv[1] !== void 0 && import.meta.url === pathToFileURL10(path10.resolve(process.argv[1])).href) {
-  process.exit(main10(process.argv.slice(2)));
+if (process.argv[1] !== void 0 && import.meta.url === pathToFileURL11(path11.resolve(process.argv[1])).href) {
+  process.exit(main11(process.argv.slice(2)));
 }
 
 // src/scripts/report_skill_obligation_violations.ts
-import * as fs11 from "node:fs";
+import * as fs12 from "node:fs";
 import * as os5 from "node:os";
-import * as path11 from "node:path";
-import process3 from "node:process";
-import { fileURLToPath as fileURLToPath11, pathToFileURL as pathToFileURL11 } from "node:url";
-var _HERE3 = fileURLToPath11(import.meta.url);
-var REPO_ROOT4 = path11.resolve(path11.dirname(_HERE3), "..", "..");
+import * as path12 from "node:path";
+import process4 from "node:process";
+import { fileURLToPath as fileURLToPath12, pathToFileURL as pathToFileURL12 } from "node:url";
+var _HERE3 = fileURLToPath12(import.meta.url);
+var REPO_ROOT4 = path12.resolve(path12.dirname(_HERE3), "..", "..");
 var OBLIGATION_LINE_RE = new RegExp(`${DETERMINISTIC_RE.source}.*`, "gm");
 var PATH_RE = /`([A-Za-z0-9_./-]*\/[A-Za-z0-9_.-]+\.[a-z]{2,6})`/g;
 var CMD_RE = /`([a-z][a-z0-9-]*(?: [a-z][a-z0-9:._-]*){1,3})`/g;
@@ -3300,7 +3977,7 @@ function _artefacts(line) {
   return out;
 }
 function extractObligations(repoRoot) {
-  const skillsRoot = path11.join(repoRoot, SKILLS_ROOT);
+  const skillsRoot = path12.join(repoRoot, SKILLS_ROOT);
   const census = censusSkills(skillsRoot);
   const out = {
     skills: census.withDeterministicObligation,
@@ -3314,7 +3991,7 @@ function extractObligations(repoRoot) {
   for (const skill of census.withDeterministicObligation) {
     let text;
     try {
-      text = fs11.readFileSync(path11.join(skillsRoot, skill, "SKILL.md"), "utf-8");
+      text = fs12.readFileSync(path12.join(skillsRoot, skill, "SKILL.md"), "utf-8");
     } catch {
       continue;
     }
@@ -3430,7 +4107,7 @@ function scanSessionForViolations(session, lines, forbidden, parsed) {
   return flags;
 }
 function defaultStore3(cwd) {
-  return path11.join(os5.homedir(), ".claude", "projects", cwd.replace(/[/.]/g, "-"));
+  return path12.join(os5.homedir(), ".claude", "projects", projectStoreSlug(cwd));
 }
 function scanStore2(repoRoot, store, limit) {
   const census = extractObligations(repoRoot);
@@ -3443,14 +4120,14 @@ function scanStore2(repoRoot, store, limit) {
   };
   let files;
   try {
-    files = fs11.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => ({ p: path11.join(store, f), m: fs11.statSync(path11.join(store, f)).mtimeMs })).sort((a, b) => b.m - a.m).slice(0, limit).map((x) => x.p);
+    files = fs12.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => ({ p: path12.join(store, f), m: fs12.statSync(path12.join(store, f)).mtimeMs })).sort((a, b) => b.m - a.m).slice(0, limit).map((x) => x.p);
   } catch {
     return report;
   }
   report.sessions = files.length;
   for (const file of files) {
-    const lines = fs11.readFileSync(file, "utf-8").split("\n");
-    const id = path11.basename(file).replace(/\.jsonl$/, "").slice(0, 8);
+    const lines = fs12.readFileSync(file, "utf-8").split("\n");
+    const id = path12.basename(file).replace(/\.jsonl$/, "").slice(0, 8);
     const entries = _parseSession(lines);
     if (loadedSkillsFrom(entries).size > 0) report.sessionsWithASkill += 1;
     report.flags.push(...scanSessionForViolations(id, lines, census.forbidden, entries));
@@ -3520,8 +4197,8 @@ function render4(r) {
   lines.push("  ships as detection-only, and this one says so.");
   return lines.join("\n");
 }
-function main11(argv) {
-  const args = argv ?? process3.argv.slice(2);
+function main12(argv) {
+  const args = argv ?? process4.argv.slice(2);
   let limit = 30;
   let json = false;
   const stores = [];
@@ -3534,7 +4211,7 @@ function main11(argv) {
     if (a === "--limit") {
       const v = value(i);
       if (v === null) {
-        process3.stderr.write("report_skill_obligation_violations: --limit needs a number\n");
+        process4.stderr.write("report_skill_obligation_violations: --limit needs a number\n");
         return 1;
       }
       limit = Number.parseInt(v, 10);
@@ -3542,7 +4219,7 @@ function main11(argv) {
     } else if (a === "--store") {
       const v = value(i);
       if (v === null) {
-        process3.stderr.write("report_skill_obligation_violations: --store needs a path\n");
+        process4.stderr.write("report_skill_obligation_violations: --store needs a path\n");
         return 1;
       }
       stores.push(v);
@@ -3550,58 +4227,58 @@ function main11(argv) {
     } else if (a === "--json") {
       json = true;
     } else if (a === "--help" || a === "-h") {
-      process3.stdout.write(
+      process4.stdout.write(
         "usage: report_skill_obligation_violations [--limit N] [--store PATH]... [--json]\n"
       );
       return 0;
     } else if (a !== void 0 && a.startsWith("--") && a !== "--quiet") {
-      process3.stderr.write(`report_skill_obligation_violations: unknown flag ${a}
+      process4.stderr.write(`report_skill_obligation_violations: unknown flag ${a}
 `);
       return 1;
     }
   }
   if (!Number.isFinite(limit) || limit <= 0) {
-    process3.stderr.write("report_skill_obligation_violations: --limit must be a positive integer\n");
+    process4.stderr.write("report_skill_obligation_violations: --limit must be a positive integer\n");
     return 1;
   }
   if (stores.length === 0) stores.push(defaultStore3(REPO_ROOT4));
   for (const store of stores) {
     const r = scanStore2(REPO_ROOT4, store, limit);
-    process3.stdout.write(json ? `${JSON.stringify(r, null, 2)}
+    process4.stdout.write(json ? `${JSON.stringify(r, null, 2)}
 ` : `${render4(r)}
 `);
   }
   return 0;
 }
-function _isCliEntry10() {
-  if (process3.argv[1] === void 0) return false;
-  if (import.meta.url === pathToFileURL11(path11.resolve(process3.argv[1])).href) return true;
+function _isCliEntry11() {
+  if (process4.argv[1] === void 0) return false;
+  if (import.meta.url === pathToFileURL12(path12.resolve(process4.argv[1])).href) return true;
   try {
-    return fs11.realpathSync(_HERE3) === fs11.realpathSync(path11.resolve(process3.argv[1]));
+    return fs12.realpathSync(_HERE3) === fs12.realpathSync(path12.resolve(process4.argv[1]));
   } catch {
     return false;
   }
 }
-if (_isCliEntry10()) {
-  process3.exit(main11());
+if (_isCliEntry11()) {
+  process4.exit(main12());
 }
 
 // src/scripts/report_conformance_funnel.ts
-var _HERE4 = fileURLToPath12(import.meta.url);
-var REPO_ROOT5 = path12.resolve(path12.dirname(_HERE4), "..", "..");
+var _HERE4 = fileURLToPath13(import.meta.url);
+var REPO_ROOT5 = path13.resolve(path13.dirname(_HERE4), "..", "..");
 function buildFunnel(opts = {}) {
   const repoRoot = opts.repoRoot ?? REPO_ROOT5;
-  const projectRulesDir = opts.projectRulesDir ?? path12.join(repoRoot, PROJECT_RULES);
-  const globalRulesDir = opts.globalRulesDir ?? path12.join(os6.homedir(), GLOBAL_RULES);
-  const sourceDir = opts.sourceDir ?? path12.join(repoRoot, PROJECTION_SOURCE);
+  const projectRulesDir = opts.projectRulesDir ?? path13.join(repoRoot, PROJECT_RULES);
+  const globalRulesDir = opts.globalRulesDir ?? path13.join(os6.homedir(), GLOBAL_RULES);
+  const sourceDir = opts.sourceDir ?? path13.join(repoRoot, PROJECTION_SOURCE);
   const store = opts.store ?? defaultStore(repoRoot);
   const limit = opts.limit ?? 30;
   return {
     delivered: measureDelivered(projectRulesDir, globalRulesDir),
     divergence: compareCarriers(projectRulesDir, globalRulesDir, sourceDir),
-    skills: censusSkills(path12.join(repoRoot, SKILLS_ROOT)),
+    skills: censusSkills(path13.join(repoRoot, SKILLS_ROOT)),
     usage: measureUsage(store, limit),
-    storePresent: fs12.existsSync(store),
+    storePresent: fs13.existsSync(store),
     sk2: scanStore2(repoRoot, store, limit)
   };
 }
@@ -3726,8 +4403,8 @@ function render5(r) {
   lines.push("workflow without a measured false-positive rate first (locked policy).");
   return lines.join("\n");
 }
-function main12(argv) {
-  const args = argv ?? process4.argv.slice(2);
+function main13(argv) {
+  const args = argv ?? process5.argv.slice(2);
   const opts = {};
   const value = (i) => {
     const v = args[i + 1];
@@ -3738,11 +4415,11 @@ function main12(argv) {
     if (a === "--store" || a === "--project" || a === "--global" || a === "--source") {
       const v = value(i);
       if (v === null) {
-        process4.stderr.write(`report_conformance_funnel: ${a} needs a value
+        process5.stderr.write(`report_conformance_funnel: ${a} needs a value
 `);
         return 1;
       }
-      const resolved = path12.resolve(v);
+      const resolved = path13.resolve(v);
       if (a === "--store") opts.store = resolved;
       else if (a === "--project") opts.projectRulesDir = resolved;
       else if (a === "--global") opts.globalRulesDir = resolved;
@@ -3752,41 +4429,41 @@ function main12(argv) {
       const v = value(i);
       const n = v === null ? Number.NaN : Number.parseInt(v, 10);
       if (!Number.isFinite(n) || n <= 0) {
-        process4.stderr.write("report_conformance_funnel: --limit must be a positive integer\n");
+        process5.stderr.write("report_conformance_funnel: --limit must be a positive integer\n");
         return 1;
       }
       opts.limit = n;
       i += 1;
     } else if (a === "--help" || a === "-h") {
-      process4.stdout.write(
+      process5.stdout.write(
         "usage: report_conformance_funnel [--store PATH] [--limit N]\n                                 [--project DIR] [--global DIR] [--source DIR]\n"
       );
       return 0;
     } else if (a !== void 0 && a.startsWith("--") && a !== "--quiet") {
-      process4.stderr.write(`report_conformance_funnel: unknown flag ${a}
+      process5.stderr.write(`report_conformance_funnel: unknown flag ${a}
 `);
       return 1;
     }
   }
-  process4.stdout.write(`${render5(buildFunnel(opts))}
+  process5.stdout.write(`${render5(buildFunnel(opts))}
 `);
   return 0;
 }
-function _isCliEntry11() {
-  if (process4.argv[1] === void 0) return false;
-  if (import.meta.url === pathToFileURL12(path12.resolve(process4.argv[1])).href) return true;
+function _isCliEntry12() {
+  if (process5.argv[1] === void 0) return false;
+  if (import.meta.url === pathToFileURL13(path13.resolve(process5.argv[1])).href) return true;
   try {
-    return fs12.realpathSync(_HERE4) === fs12.realpathSync(path12.resolve(process4.argv[1]));
+    return fs13.realpathSync(_HERE4) === fs13.realpathSync(path13.resolve(process5.argv[1]));
   } catch {
     return false;
   }
 }
-if (_isCliEntry11()) {
-  process4.exit(main12());
+if (_isCliEntry12()) {
+  process5.exit(main13());
 }
 
 // src/scripts/_cli/cmd_conformance.ts
-var _HERE5 = fileURLToPath13(import.meta.url);
+var _HERE5 = fileURLToPath14(import.meta.url);
 var PACKAGE_ROOT = resolvePackageRoot(import.meta.url);
 var CONFORMANCE_CHECK_IDS = [
   "txlog-clean",
@@ -3797,29 +4474,29 @@ var CONFORMANCE_CHECK_IDS = [
 ];
 var THIN_STUB_MARKER = "Routed rule \u2014 load the body on trigger-match";
 function print(s = "") {
-  process5.stdout.write(`${s}
+  process6.stdout.write(`${s}
 `);
 }
 function eprint(s = "") {
-  process5.stderr.write(`${s}
+  process6.stderr.write(`${s}
 `);
 }
 function conformanceLogPath() {
-  const override = process5.env["AGENT_CONFIG_CONFORMANCE_LOG"];
+  const override = process6.env["AGENT_CONFIG_CONFORMANCE_LOG"];
   if (override && override.trim().length > 0) {
     return override;
   }
-  return path13.join(os7.homedir(), ".event4u", "agent-config", "conformance-log.jsonl");
+  return path14.join(os7.homedir(), ".event4u", "agent-config", "conformance-log.jsonl");
 }
 function installLogPath() {
-  const override = process5.env["AGENT_CONFIG_INSTALL_LOG"];
+  const override = process6.env["AGENT_CONFIG_INSTALL_LOG"];
   if (override && override.trim().length > 0) {
     return override;
   }
-  return path13.join(os7.homedir(), ".event4u", "agent-config", "install-log.jsonl");
+  return path14.join(os7.homedir(), ".event4u", "agent-config", "install-log.jsonl");
 }
 function _check_txlog_clean(logPath = installLogPath()) {
-  if (!fs13.existsSync(logPath)) {
+  if (!fs14.existsSync(logPath)) {
     return {
       id: "txlog-clean",
       status: "ok",
@@ -3853,11 +4530,11 @@ function _check_txlog_clean(logPath = installLogPath()) {
   };
 }
 function routeTargetPaths(target) {
-  return routeTargetPathsPosix(target).map((rel) => path13.join(...rel.split("/")));
+  return routeTargetPathsPosix(target).map((rel) => path14.join(...rel.split("/")));
 }
 function _check_router_pointers(packageRoot = PACKAGE_ROOT) {
-  const routerPath = path13.join(packageRoot, "dist", "router.json");
-  if (!fs13.existsSync(routerPath)) {
+  const routerPath = path14.join(packageRoot, "dist", "router.json");
+  if (!fs14.existsSync(routerPath)) {
     return {
       id: "router-pointers",
       status: "fail",
@@ -3867,7 +4544,7 @@ function _check_router_pointers(packageRoot = PACKAGE_ROOT) {
   }
   let router;
   try {
-    router = JSON.parse(fs13.readFileSync(routerPath, "utf8"));
+    router = JSON.parse(fs14.readFileSync(routerPath, "utf8"));
   } catch (exc) {
     return {
       id: "router-pointers",
@@ -3876,13 +4553,13 @@ function _check_router_pointers(packageRoot = PACKAGE_ROOT) {
       remedy: "reinstall the package \u2014 dist/router.json is corrupt"
     };
   }
-  const rulesDir = path13.join(packageRoot, "dist", "agent-src", "rules");
+  const rulesDir = path14.join(packageRoot, "dist", "agent-src", "rules");
   const broken = [];
   let ids = 0;
   let targets = 0;
   for (const kernelId of router["kernel"] ?? []) {
     ids += 1;
-    if (!fs13.existsSync(path13.join(rulesDir, `${kernelId}.md`))) {
+    if (!fs14.existsSync(path14.join(rulesDir, `${kernelId}.md`))) {
       broken.push(`kernel:${kernelId} \u2192 rules/${kernelId}.md missing`);
     }
   }
@@ -3890,7 +4567,7 @@ function _check_router_pointers(packageRoot = PACKAGE_ROOT) {
     for (const entry of router[tier] ?? []) {
       const ruleId = String(entry["id"] ?? "");
       ids += 1;
-      if (!fs13.existsSync(path13.join(rulesDir, `${ruleId}.md`))) {
+      if (!fs14.existsSync(path14.join(rulesDir, `${ruleId}.md`))) {
         broken.push(`${tier}:${ruleId} \u2192 rules/${ruleId}.md missing`);
       }
       for (const target of entry["routes_to"] ?? []) {
@@ -3900,7 +4577,7 @@ function _check_router_pointers(packageRoot = PACKAGE_ROOT) {
           broken.push(`${ruleId} \u2192 unparseable routes_to ${JSON.stringify(target)}`);
           continue;
         }
-        if (!candidates.some((rel) => fs13.existsSync(path13.join(packageRoot, rel)))) {
+        if (!candidates.some((rel) => fs14.existsSync(path14.join(packageRoot, rel)))) {
           broken.push(`${ruleId} \u2192 ${target} (${candidates[0]} missing)`);
         }
       }
@@ -3932,9 +4609,9 @@ function detectSmokePlatform(projectRoot) {
   return "claude";
 }
 function dispatcherRunner(packageRoot) {
-  const localTsx = path13.join(packageRoot, "node_modules", ".bin", "tsx");
-  const script = path13.join(packageRoot, "src", "scripts", "hooks", "dispatch_hook.ts");
-  if (fs13.existsSync(localTsx)) {
+  const localTsx = path14.join(packageRoot, "node_modules", ".bin", "tsx");
+  const script = path14.join(packageRoot, "src", "scripts", "hooks", "dispatch_hook.ts");
+  if (fs14.existsSync(localTsx)) {
     return [localTsx, script];
   }
   return ["npx", "tsx", script];
@@ -3984,12 +4661,12 @@ function _check_hook_dispatcher(projectRoot, packageRoot = PACKAGE_ROOT, opts =
   };
 }
 function readSettingsMode(projectRoot) {
-  const settingsPath = path13.join(projectRoot, ".agent-settings.yml");
-  if (!fs13.existsSync(settingsPath)) {
+  const settingsPath = path14.join(projectRoot, ".agent-settings.yml");
+  if (!fs14.existsSync(settingsPath)) {
     return "eager-all";
   }
   try {
-    const parsed = YAML.parse(fs13.readFileSync(settingsPath, "utf8"));
+    const parsed = YAML.parse(fs14.readFileSync(settingsPath, "utf8"));
     const lean = parsed?.["lean_projection"] ?? null;
     const mode = lean?.["mode"];
     return typeof mode === "string" && mode.length > 0 ? mode : "eager-all";
@@ -4000,7 +4677,7 @@ function readSettingsMode(projectRoot) {
 function kernelIdsFromRouter(packageRoot) {
   try {
     const router = JSON.parse(
-      fs13.readFileSync(path13.join(packageRoot, "dist", "router.json"), "utf8")
+      fs14.readFileSync(path14.join(packageRoot, "dist", "router.json"), "utf8")
     );
     return new Set((router["kernel"] ?? []).map(String));
   } catch {
@@ -4017,8 +4694,8 @@ function _check_lean_projection(projectRoot, packageRoot = PACKAGE_ROOT, project
       remedy: "set lean_projection.mode to 'eager-all' or 'thin' in .agent-settings.yml"
     };
   }
-  const rulesDir = projectedRulesDir ?? path13.join(projectRoot, ".augment", "rules");
-  if (!fs13.existsSync(rulesDir)) {
+  const rulesDir = projectedRulesDir ?? path14.join(projectRoot, ".augment", "rules");
+  if (!fs14.existsSync(rulesDir)) {
     return {
       id: "lean-projection",
       status: "skipped",
@@ -4027,7 +4704,7 @@ function _check_lean_projection(projectRoot, packageRoot = PACKAGE_ROOT, project
     };
   }
   const kernel = kernelIdsFromRouter(packageRoot);
-  const files = fs13.readdirSync(rulesDir).filter((f) => f.endsWith(".md") && f !== "INDEX.md").sort();
+  const files = fs14.readdirSync(rulesDir).filter((f) => f.endsWith(".md") && f !== "INDEX.md").sort();
   const nonKernel = files.filter((f) => !kernel.has(f.replace(/\.md$/, "")));
   if (nonKernel.length === 0) {
     return {
@@ -4041,7 +4718,7 @@ function _check_lean_projection(projectRoot, packageRoot = PACKAGE_ROOT, project
   for (const f of nonKernel) {
     let text = "";
     try {
-      text = fs13.readFileSync(path13.join(rulesDir, f), "utf8");
+      text = fs14.readFileSync(path14.join(rulesDir, f), "utf8");
     } catch {
       continue;
     }
@@ -4072,8 +4749,8 @@ function _check_lean_projection(projectRoot, packageRoot = PACKAGE_ROOT, project
 function _check_host_manifest(projectRoot) {
   const detected = Object.entries(detectToolPresence(projectRoot)).filter(([, v]) => v === true).map(([k]) => k);
   const detectedNote = detected.length > 0 ? `detected surfaces: ${detected.join(", ")}` : "no surfaces detected";
-  const settingsPath = path13.join(projectRoot, ".agent-settings.yml");
-  if (!fs13.existsSync(settingsPath)) {
+  const settingsPath = path14.join(projectRoot, ".agent-settings.yml");
+  if (!fs14.existsSync(settingsPath)) {
     return {
       id: "host-manifest",
       status: "ok",
@@ -4083,7 +4760,7 @@ function _check_host_manifest(projectRoot) {
   }
   let parsed = null;
   try {
-    parsed = YAML.parse(fs13.readFileSync(settingsPath, "utf8"));
+    parsed = YAML.parse(fs14.readFileSync(settingsPath, "utf8"));
   } catch (exc) {
     return {
       id: "host-manifest",
@@ -4110,7 +4787,7 @@ function _check_host_manifest(projectRoot) {
   };
 }
 function runConformanceChecks(opts = {}) {
-  const projectRoot = opts.projectRoot ?? process5.cwd();
+  const projectRoot = opts.projectRoot ?? process6.cwd();
   const packageRoot = opts.packageRoot ?? PACKAGE_ROOT;
   const checks = [];
   checks.push(_check_txlog_clean());
@@ -4151,7 +4828,7 @@ function _parse(argv) {
   while (i < argv.length) {
     const a = argv[i];
     if (a === "-h" || a === "--help") {
-      process5.stdout.write(USAGE);
+      process6.stdout.write(USAGE);
       throw new ArgparseExit(0);
     }
     if (a === "--json") {
@@ -4165,16 +4842,16 @@ function _parse(argv) {
         opts.project = a.slice(a.indexOf("=") + 1);
       } else {
         if (i + 1 >= argv.length) {
-          process5.stderr.write(USAGE);
-          process5.stderr.write("agent-config conformance: error: --project expects a value\n");
+          process6.stderr.write(USAGE);
+          process6.stderr.write("agent-config conformance: error: --project expects a value\n");
           throw new ArgparseExit(2);
         }
         opts.project = argv[i + 1];
         i += 1;
       }
     } else {
-      process5.stderr.write(USAGE);
-      process5.stderr.write(`agent-config conformance: error: unrecognized argument ${a}
+      process6.stderr.write(USAGE);
+      process6.stderr.write(`agent-config conformance: error: unrecognized argument ${a}
 `);
       throw new ArgparseExit(2);
     }
@@ -4182,8 +4859,8 @@ function _parse(argv) {
   }
   return opts;
 }
-function main13(argv = null) {
-  const opts = _parse(argv !== null ? Array.from(argv) : process5.argv.slice(2));
+function main14(argv = null) {
+  const opts = _parse(argv !== null ? Array.from(argv) : process6.argv.slice(2));
   if (opts.funnel) {
     print(render5(buildFunnel()));
     return 0;
@@ -4253,28 +4930,28 @@ function main13(argv = null) {
   }
   return failed ? 1 : 0;
 }
-function _isCliEntry12() {
-  if (process5.argv[1] === void 0) {
+function _isCliEntry13() {
+  if (process6.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL13(path13.resolve(process5.argv[1])).href;
+  const argvUrl = pathToFileURL14(path14.resolve(process6.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs13.realpathSync(fileURLToPath13(import.meta.url));
-    const argv = fs13.realpathSync(path13.resolve(process5.argv[1]));
+    const here = fs14.realpathSync(fileURLToPath14(import.meta.url));
+    const argv = fs14.realpathSync(path14.resolve(process6.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry12() || process5.argv[1] === _HERE5) {
+if (_isCliEntry13() || process6.argv[1] === _HERE5) {
   try {
-    process5.exitCode = main13(process5.argv.slice(2));
+    process6.exitCode = main14(process6.argv.slice(2));
   } catch (e) {
     if (e instanceof ArgparseExit) {
-      process5.exitCode = e.code;
+      process6.exitCode = e.code;
     } else {
       throw e;
     }
@@ -4294,7 +4971,7 @@ export {
   conformanceLogPath,
   detectSmokePlatform,
   installLogPath,
-  main13 as main,
+  main14 as main,
   routeTargetPaths,
   runConformanceChecks
 };