voidmachine 5.0.7 → 6.0.0

package/dist/main.js

@@ -5605,8 +5605,8 @@ var require_cst_visit = __commonJS({
     visit3.REMOVE = REMOVE;
     visit3.itemAtPath = (cst, path3) => {
       let item = cst;
-      for (const [field9, index] of path3) {
-        const tok = item?.[field9];
+      for (const [field11, index] of path3) {
+        const tok = item?.[field11];
         if (tok && "items" in tok) {
           item = tok.items[index];
         } else
@@ -5616,8 +5616,8 @@ var require_cst_visit = __commonJS({
     };
     visit3.parentCollection = (cst, path3) => {
       const parent = visit3.itemAtPath(cst, path3.slice(0, -1));
-      const field9 = path3[path3.length - 1][0];
-      const coll = parent?.[field9];
+      const field11 = path3[path3.length - 1][0];
+      const coll = parent?.[field11];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
@@ -5626,11 +5626,11 @@ var require_cst_visit = __commonJS({
       let ctrl = visitor(item, path3);
       if (typeof ctrl === "symbol")
         return ctrl;
-      for (const field9 of ["key", "value"]) {
-        const token = item[field9];
+      for (const field11 of ["key", "value"]) {
+        const token = item[field11];
         if (token && "items" in token) {
           for (let i = 0; i < token.items.length; ++i) {
-            const ci = _visit(Object.freeze(path3.concat([[field9, i]])), token.items[i], visitor);
+            const ci = _visit(Object.freeze(path3.concat([[field11, i]])), token.items[i], visitor);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -5640,7 +5640,7 @@ var require_cst_visit = __commonJS({
               i -= 1;
             }
           }
-          if (typeof ctrl === "function" && field9 === "key")
+          if (typeof ctrl === "function" && field11 === "key")
             ctrl = ctrl(item, path3);
         }
       }
@@ -16438,14 +16438,14 @@ var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
     const shape = zod.def.shape;
     const propValues = {};
     for (const key in shape) {
-      const field9 = shape[key]._zod;
-      if (field9.values) {
+      const field11 = shape[key]._zod;
+      if (field11.values) {
         if (!Object.prototype.hasOwnProperty.call(propValues, key)) {
           assignProp(propValues, key, /* @__PURE__ */ new Set());
         }
-        for (const v2 of field9.values)
+        for (const v2 of field11.values)
           propValues[key].add(v2);
-        if (field9.optin !== void 0)
+        if (field11.optin !== void 0)
           propValues[key].add(void 0);
       }
     }
@@ -29437,8 +29437,8 @@ var objectProcessor = (schema, ctx, _json, params) => {
   }
   const requiredKeys = [];
   for (const key of Object.keys(shape)) {
-    const field9 = def.shape[key];
-    if (ctx.io === "input" ? inputOptin(field9) === void 0 : field9._zod.optout === void 0) {
+    const field11 = def.shape[key];
+    if (ctx.io === "input" ? inputOptin(field11) === void 0 : field11._zod.optout === void 0) {
       requiredKeys.push(key);
     }
   }
@@ -32864,7 +32864,7 @@ var COMMAND_CATALOG = {
     "help": [
       {
         "signature": "mission <sub>",
-        "description": "Plan a deterministic DAG, then start, resume, verify, inspect, archive, or explicitly prune an auditable local mission run."
+        "description": "Plan a deterministic DAG, then start, resume, verify, inspect, archive, or explicitly prune an auditable local mission run. Inspect --usage adds local skill, hook and specialist counts."
       }
     ]
   },
@@ -32996,15 +32996,15 @@ var SEGMENT = /^[a-z0-9][a-z0-9._-]*$/;
 function isRecord(value) {
   return typeof value === "object" && value !== void 0 && value !== null && !Array.isArray(value);
 }
-function segment(value, field9) {
+function segment(value, field11) {
   if (typeof value !== "string" || !SEGMENT.test(value)) {
-    throw new Error(`product identity: ${field9} must be a lowercase name without separators`);
+    throw new Error(`product identity: ${field11} must be a lowercase name without separators`);
   }
   return value;
 }
-function segments(value, field9) {
-  if (!Array.isArray(value)) throw new Error(`product identity: ${field9} must be a list`);
-  return value.map((entry, index) => segment(entry, `${field9}[${index}]`));
+function segments(value, field11) {
+  if (!Array.isArray(value)) throw new Error(`product identity: ${field11} must be a list`);
+  return value.map((entry, index) => segment(entry, `${field11}[${index}]`));
 }
 function formerPackages(value) {
   if (value === void 0) return [];
@@ -33020,16 +33020,16 @@ function formerPackages(value) {
 }
 var NAMESPACE = SEGMENT;
 var PREFIX = /^[A-Z][A-Z0-9_]*_$/;
-function exclusive(current, deprecated, field9) {
-  if (deprecated.includes(current)) throw new Error(`product identity: ${current} is both current and deprecated (${field9})`);
+function exclusive(current, deprecated, field11) {
+  if (deprecated.includes(current)) throw new Error(`product identity: ${current} is both current and deprecated (${field11})`);
 }
-function pattern(value, shape, field9, rule) {
-  if (typeof value !== "string" || !shape.test(value)) throw new Error(`product identity: ${field9} must be ${rule}`);
+function pattern(value, shape, field11, rule) {
+  if (typeof value !== "string" || !shape.test(value)) throw new Error(`product identity: ${field11} must be ${rule}`);
   return value;
 }
-function patterns(value, shape, field9, rule) {
-  if (!Array.isArray(value)) throw new Error(`product identity: ${field9} must be a list`);
-  return value.map((entry, index) => pattern(entry, shape, `${field9}[${index}]`, rule));
+function patterns(value, shape, field11, rule) {
+  if (!Array.isArray(value)) throw new Error(`product identity: ${field11} must be a list`);
+  return value.map((entry, index) => pattern(entry, shape, `${field11}[${index}]`, rule));
 }
 function managed(namespaces, pair) {
   const recognized = namespaces.map(pair);
@@ -35804,6 +35804,89 @@ function parseEnvelope(event) {
     completion
   };
 }
+function freshReviewProofIds(events, context2) {
+  return events.flatMap((event) => {
+    if (event.kind !== "evidence.recorded")
+      return [];
+    const parsed = parseEvidence(record7(event.payload)?.["evidence"]);
+    return parsed.ok && parsed.value.evidenceId === event.subject && parsed.value.missionId === event.missionId && parsed.value.status === "passed" && assessEvidence(parsed.value, context2).status === "fresh" ? [parsed.value.evidenceId] : [];
+  });
+}
+function reviewField(event, key) {
+  return record7(event?.payload)?.[key];
+}
+function sameNativeDispatch(left, right) {
+  return left.missionId === right.missionId && left.subject === right.subject && ["stage", "reviewRound", "inputHash", "contractVersion", "reviewSubject", "reviewScope"].every((key) => reviewField(left, key) !== void 0 && reviewField(right, key) !== void 0 && canonicalJsonHash(reviewField(left, key)) === canonicalJsonHash(reviewField(right, key)));
+}
+function boundNativeRequest(events, envelope) {
+  const { event, completion, contextId } = envelope;
+  const receipt2 = completion.review;
+  const subject = reviewField(event, "reviewSubject");
+  const scope = reviewField(event, "reviewScope");
+  const start = events[0];
+  if (!start || !receipt2 || !isReviewSubject(subject) || !isReviewScope(scope) || !sameReviewSubject(receipt2, subject) || canonicalJsonHash(receipt2.scope) !== canonicalJsonHash(scope) || receipt2.taskId !== event.missionId || receipt2.writerId !== reviewField(start, "leadWriterId") || receipt2.provenance.kind !== "native-context" || receipt2.provenance.contextId !== contextId || contextId === receipt2.writerId || event.source !== `runtime:${String(reviewField(start, "runtime"))}` || event.subject !== completion.specialistId || reviewField(event, "contractVersion") !== completion.contractVersion)
+    return void 0;
+  const requests = events.filter((candidate) => candidate.kind === "specialist.requested" && candidate.seq < event.seq && candidate.source === "void-harness:mission.dispatch" && sameNativeDispatch(candidate, event) && reviewField(candidate, "planHash") === reviewField(start, "planHash") && reviewField(candidate, "runtime") === reviewField(start, "runtime"));
+  const request = requests[0];
+  if (requests.length !== 1 || !request)
+    return void 0;
+  const started = events.filter((candidate) => candidate.kind === "specialist.started" && candidate.seq > request.seq && candidate.seq < event.seq && candidate.source === event.source && sameNativeDispatch(candidate, event) && reviewField(candidate, "contextId") === contextId && (candidate.causationId === void 0 || candidate.causationId === request.eventId));
+  return started.length === 1 && (event.causationId === void 0 || event.causationId === request.eventId) && (reviewField(event, "reviewInvocationEventId") === void 0 || reviewField(event, "reviewInvocationEventId") === started[0]?.eventId) ? request : void 0;
+}
+function sameMembers(actual, expected) {
+  return Array.isArray(actual) && actual.length === new Set(expected).size && new Set(actual).size === actual.length && actual.every((value) => expected.includes(value));
+}
+function authorizedTargetedRequest(events, request, history) {
+  const original = history[0]?.completion.review;
+  const previous = history.at(-1);
+  const subject = reviewField(request, "reviewSubject");
+  const scope = reviewField(request, "reviewScope");
+  if (!original || !previous || !isReviewSubject(subject) || !isReviewScope(scope) || scope.kind !== "targeted" || subject.taskId !== original.taskId || subject.baseCommit !== original.baseCommit || subject.acceptanceCriteriaHash !== original.acceptanceCriteriaHash || reviewField(request, "contractVersion") !== previous.completion.contractVersion)
+    return false;
+  const blockers = history.flatMap((item) => item.completion.findings).filter((item) => item.classification === "blocking");
+  if (blockers.length === 0 || !sameMembers(scope.findingIds, blockers.map((item) => item.id)) || !sameMembers(scope.affectedPaths, blockers.flatMap((item) => item.evidence.map((proof4) => proof4.path))))
+    return false;
+  const writers = events.filter((event) => event.kind === "lead-writer.completed" && event.seq > previous.event.seq && event.seq < request.seq);
+  const writer = writers[0];
+  const correction = events.find((event) => event.eventId === reviewField(writer ?? request, "requestEventId"));
+  const count = events.filter((event) => event.kind === "lead-writer.completed" && event.seq < request.seq && reviewField(event, "actionKind") === "run-correction").length;
+  if (writers.length !== 1 || !writer || !correction || count < 1 || count > 2 || reviewField(request, "reviewRound") !== count + 1 || correction.kind !== "lead-writer.requested" || correction.source !== "void-harness:mission.dispatch" || correction.seq <= previous.event.seq || correction.seq >= writer.seq || correction.subject !== original.writerId || writer.subject !== original.writerId || writer.source !== original.writerId || writer.causationId !== correction.eventId || reviewField(writer, "actionKind") !== "run-correction" || reviewField(writer, "planHash") !== reviewField(events[0], "planHash") || reviewField(writer, "implementationRound") !== count + 1 || !["actionKind", "planHash", "writerId", "implementationRound"].every((key) => reviewField(writer, key) === reviewField(correction, key)))
+    return false;
+  const open11 = reconcileReviewFindings(history, freshReviewProofIds(events.filter((event) => event.seq < correction.seq), { dependencies: {} })).filter((finding) => finding.classification === "blocking");
+  return open11.length > 0 && sameMembers(reviewField(correction, "findingIds"), open11.map((finding) => finding.findingId));
+}
+function canContinueNativeReview(events, request, contextId) {
+  const start = events[0];
+  if (!start || start.kind !== "mission.started" || reviewField(request, "planHash") !== reviewField(start, "planHash") || reviewField(request, "runtime") !== reviewField(start, "runtime") || request.kind !== "specialist.requested" || request.source !== "void-harness:mission.dispatch" || request.subject !== "core:independent-code-reviewer" || reviewField(request, "stage") !== "post-implementation" || !validNativeContextId(contextId) || events.some((event) => event.missionId !== request.missionId))
+    return false;
+  const history = events.filter((event) => event.kind === "specialist.completed" && event.seq < request.seq && reviewField(event, "contextId") === contextId).map(parseEnvelope);
+  if (history.length === 0 || history.some((item) => !item))
+    return false;
+  const prior = history.filter((item) => item !== void 0);
+  const first = prior[0];
+  if (!first || first.completion.review?.scope.kind !== "general" || first.completion.verdict !== "changes-requested" || new Set(prior.map((item) => item.completion.completionId)).size !== prior.length || events.some((event) => event.seq < request.seq && ["specialist.started", "specialist.completed"].includes(event.kind) && reviewField(event, "contextId") === contextId && (event.subject !== request.subject || reviewField(event, "stage") !== "post-implementation")) || events.filter((event) => event.kind === "specialist.completed" && event.subject === request.subject && reviewField(event, "stage") === "post-implementation" && event.seq < request.seq).at(-1)?.eventId !== prior.at(-1)?.event.eventId)
+    return false;
+  for (const [index, item] of prior.entries()) {
+    const bound = boundNativeRequest(events, item);
+    if (!bound || item.completion.review?.reviewerId !== first.completion.review.reviewerId || index > 0 && !authorizedTargetedRequest(events, bound, prior.slice(0, index)))
+      return false;
+  }
+  return authorizedTargetedRequest(events, request, prior);
+}
+function validNativeReviewContinuation(events, completion) {
+  const envelope = parseEnvelope(completion);
+  if (!envelope || !envelope.contextId)
+    return false;
+  const request = boundNativeRequest(events, envelope);
+  const receipt2 = envelope.completion.review;
+  if (!request || !receipt2 || !canContinueNativeReview(events, request, envelope.contextId) || receipt2.scope.kind !== "targeted")
+    return false;
+  const previous = events.filter((event) => event.kind === "specialist.completed" && event.seq < request.seq && reviewField(event, "contextId") === envelope.contextId).at(-1);
+  const previousReceipt = previous && parseEnvelope(previous)?.completion.review;
+  const correction = events.filter((event) => event.kind === "lead-writer.requested" && event.seq < request.seq && reviewField(event, "actionKind") === "run-correction").at(-1);
+  const historicalProofIds = freshReviewProofIds(events.filter((event) => event.seq < completion.seq), { dependencies: {} });
+  return receipt2.reviewerId === previousReceipt?.reviewerId && correction !== void 0 && receipt2.resolutions.every((resolution) => receipt2.scope.kind === "targeted" && receipt2.scope.findingIds.includes(resolution.findingId) && (resolution.status !== "resolved" || resolution.proofIds.every((id3) => historicalProofIds.includes(id3) && receipt2.proofIds.includes(id3) && events.some((event) => event.kind === "evidence.recorded" && event.subject === id3 && event.seq > correction.seq && event.seq < completion.seq))));
+}
 function collectCompletions(events, stage, expectedSource, stageStartSeqExclusive, afterSeqExclusive, beforeSeqExclusive, maxRounds, retainedSpecialists, contractMigration, correctionBatches) {
   const accepted = [];
   const retained = [];
@@ -35873,7 +35956,7 @@ function collectCompletions(events, stage, expectedSource, stageStartSeqExclusiv
     }
     const duplicateCompletion = completionIds.has(envelope.completion.completionId);
     const contextKey = envelope.contextId ?? (envelope.completion.review?.provenance.kind === "review-artifact" ? `artifact:${envelope.completion.review.provenance.sha256}` : void 0);
-    const reusedContext = contextKey !== void 0 && contextIds.has(contextKey);
+    const reusedContext = contextKey !== void 0 && contextIds.has(contextKey) && !(envelope.stage === "post-implementation" && validNativeReviewContinuation(events, event));
     if (duplicateCompletion) {
       issues.push({
         code: "duplicate-completion",
@@ -36385,9 +36468,9 @@ function sameInvocation(left, right) {
   return left.subject === right.subject && ["stage", "reviewRound", "inputHash"].every((key) => field3(left, key) === field3(right, key));
 }
 function admit(input2) {
-  const { request, observation: observation2, stream: journal } = input2;
+  const { request, observation: observation3, stream: journal } = input2;
   const events = journal.events;
-  if (!requestValue(request) || !observationValue(observation2))
+  if (!requestValue(request) || !observationValue(observation3))
     return refuse("invalid-migration", "Use the declared bounded migration request and observed inputs");
   const lifecycle = projectMissionLifecycle(events);
   if (journal.continuity !== "complete" || journal.invalidLines > 0 || journal.duplicateEventIds > 0 || lifecycle.status === "invalid")
@@ -36406,9 +36489,9 @@ function admit(input2) {
   const recovered = validatedRecoveredReviewEvents(events);
   if (!recovered.ok)
     return refuse("invalid-recovery", recovered.reasons.join("; "));
-  const declaration = observation2.declaration;
-  const selected = observation2.plan.specialists.find((x3) => x3.specialistId === VISUAL);
-  if (request.migrationId !== declaration.id || selected?.contractVersion !== 2 || selected.state !== "applicable" || !selected.stages.includes("post-implementation") || observation2.plan.context.status !== "complete" || observation2.plan.specialists.some((x3) => x3.state === "degraded") || field3(events[0], "planHash") !== observation2.plan.planHash || `runtime:${String(field3(events[0], "runtime"))}` !== observation2.expectedSource || observation2.observedFromContractSha256 !== declaration.fromContractSha256 || observation2.observedToContractSha256 !== declaration.toContractSha256 || observation2.nativeContractVersion !== 3)
+  const declaration = observation3.declaration;
+  const selected = observation3.plan.specialists.find((x3) => x3.specialistId === VISUAL);
+  if (request.migrationId !== declaration.id || selected?.contractVersion !== 2 || selected.state !== "applicable" || !selected.stages.includes("post-implementation") || observation3.plan.context.status !== "complete" || observation3.plan.specialists.some((x3) => x3.state === "degraded") || field3(events[0], "planHash") !== observation3.plan.planHash || `runtime:${String(field3(events[0], "runtime"))}` !== observation3.expectedSource || observation3.observedFromContractSha256 !== declaration.fromContractSha256 || observation3.observedToContractSha256 !== declaration.toContractSha256 || observation3.nativeContractVersion !== 3)
     return refuse("migration-contract-mismatch", "Observe the original v2 plan and declared v3 assets/native specialist");
   const requested = events.filter((x3) => x3.kind === "specialist.requested" && x3.subject === VISUAL);
   const episodeStart = events.find((x3) => x3.eventId === lifecycle.episodeId);
@@ -36422,23 +36505,23 @@ function admit(input2) {
   const last = writers.at(-1);
   if (!first || !last)
     return refuse("missing-implementation", "Migration applies only to an implemented post-review subject");
-  const contracts = Object.fromEntries(observation2.plan.specialists.map((x3) => [x3.specialistId, x3.contractVersion]));
+  const contracts = Object.fromEntries(observation3.plan.specialists.map((x3) => [x3.specialistId, x3.contractVersion]));
   const review = reduceReviewLoop({
     events: recovered.events,
     stage: "post-implementation",
-    expectedSource: observation2.expectedSource,
+    expectedSource: observation3.expectedSource,
     stageStartSeqExclusive: first.seq,
     afterSeqExclusive: last.seq,
-    requiredSpecialists: observation2.plan.specialists.filter((x3) => x3.state === "applicable" && x3.stages.includes("post-implementation")).map((x3) => x3.specialistId),
+    requiredSpecialists: observation3.plan.specialists.filter((x3) => x3.state === "applicable" && x3.stages.includes("post-implementation")).map((x3) => x3.specialistId),
     contractVersions: contracts,
-    currentInputHashes: observation2.currentInputHashes,
-    maxRounds: observation2.maxRounds
+    currentInputHashes: observation3.currentInputHashes,
+    maxRounds: observation3.maxRounds
   });
   if (review.issues.length > 0)
     return refuse("invalid-review", review.issues.map((x3) => x3.detail).join("; "));
   const previous = recovered.events.filter((x3) => x3.subject === VISUAL && x3.kind === "specialist.completed" && field3(x3, "stage") === "post-implementation");
   const reviewRound = review.reviewRound + (previous.some((x3) => x3.seq > last.seq) ? 1 : 0);
-  if (reviewRound > observation2.maxRounds)
+  if (reviewRound > observation3.maxRounds)
     return refuse("review-budget-exhausted", "Migration grants no additional review round");
   const proofs = events.flatMap((event) => {
     if (event.kind !== "evidence.recorded")
@@ -36448,10 +36531,10 @@ function admit(input2) {
   });
   const obligations = reduceEvidenceObligations({
     events,
-    expectedSource: observation2.expectedSource,
+    expectedSource: observation3.expectedSource,
     phase: "post-implementation",
     proofs,
-    evidenceContext: { dependencies: observation2.evidenceDependencies ?? {} }
+    evidenceContext: { dependencies: observation3.evidenceDependencies ?? {} }
   });
   if (obligations.issues.length > 0)
     return refuse("invalid-evidence", obligations.issues.map((x3) => x3.detail).join("; "));
@@ -36459,7 +36542,7 @@ function admit(input2) {
     schemaVersion: 1,
     request,
     requestHash: canonicalJsonHash(request),
-    observation: observation2,
+    observation: observation3,
     ...lifecycle.status === "closed" ? { recovery: {
       closureEventId: lifecycle.closure.eventId,
       previousEpisodeId: lifecycle.episodeId
@@ -36474,11 +36557,11 @@ function admit(input2) {
     toVersion: 3,
     fromContractSha256: declaration.fromContractSha256,
     toContractSha256: declaration.toContractSha256,
-    reviewSubjectHash: observation2.reviewSubjectHash,
-    targetInputHash: observation2.targetInputHash,
-    nativeAgentSha256: observation2.nativeAgentSha256,
+    reviewSubjectHash: observation3.reviewSubjectHash,
+    targetInputHash: observation3.targetInputHash,
+    nativeAgentSha256: observation3.nativeAgentSha256,
     reviewRound,
-    remainingRounds: observation2.maxRounds - reviewRound + 1,
+    remainingRounds: observation3.maxRounds - reviewRound + 1,
     supersededRequestEventIds: requested.filter((x3) => !starts.some((start) => sameInvocation(start, x3))).map((x3) => x3.eventId),
     supersededCompletionEventIds: events.filter((x3) => x3.kind === "specialist.completed" && x3.subject === VISUAL).map((x3) => x3.eventId),
     pendingAuthorObligationIds: obligations.obligations.filter((x3) => x3.specialistId === VISUAL && x3.due === "current-review" && !x3.discharged).map((x3) => x3.obligationId),
@@ -36494,10 +36577,10 @@ function validatedSpecialistContractMigrations(events, plan2) {
     return { ok: true, plan: plan2, events };
   const migration = migrations[0];
   const request = field3(migration, "request");
-  const observation2 = field3(migration, "observation");
-  if (migrations.length !== 1 || projectMissionLifecycle(events).status === "invalid" || migration.source !== "void-harness:mission.migrate-specialist" || migration.subject !== VISUAL || !requestValue(request) || !observationValue(observation2) || canonicalJsonHash(observation2.plan) !== canonicalJsonHash(plan2))
+  const observation3 = field3(migration, "observation");
+  if (migrations.length !== 1 || projectMissionLifecycle(events).status === "invalid" || migration.source !== "void-harness:mission.migrate-specialist" || migration.subject !== VISUAL || !requestValue(request) || !observationValue(observation3) || canonicalJsonHash(observation3.plan) !== canonicalJsonHash(plan2))
     return { ok: false, reasons: ["Migration receipt does not match its original plan or producer"] };
-  const decision = admit({ stream: stream(events.slice(0, migration.seq - 1)), request, observation: observation2 });
+  const decision = admit({ stream: stream(events.slice(0, migration.seq - 1)), request, observation: observation3 });
   if (decision.kind !== "migrate" || canonicalJsonHash(decision.receipt) !== canonicalJsonHash(migration.payload)) {
     return { ok: false, reasons: ["Migration receipt does not reproduce admission from its journal prefix"] };
   }
@@ -36533,10 +36616,10 @@ function validatedSpecialistContractMigrationBoundary(events) {
   const migration = events.find((event) => event.kind === "specialist.contract-migrated");
   if (migration === void 0)
     return { ok: true };
-  const observation2 = field3(migration, "observation");
-  if (!observationValue(observation2))
+  const observation3 = field3(migration, "observation");
+  if (!observationValue(observation3))
     return { ok: false, reasons: ["Migration observation is invalid"] };
-  const validated = validatedSpecialistContractMigrations(events, observation2.plan);
+  const validated = validatedSpecialistContractMigrations(events, observation3.plan);
   if (!validated.ok)
     return validated;
   return { ok: true, ...validated.migration === void 0 ? {} : { migration: validated.migration } };
@@ -36565,10 +36648,10 @@ function matchesRequest(completion, request) {
 }
 function opaqueNativeContextDefect(input2) {
   const { events } = input2.stream;
-  const { observation: observation2 } = input2;
+  const { observation: observation3 } = input2;
   const start = events[0];
   const closure = events.at(-1);
-  if (start === void 0 || closure?.kind !== "mission.closed" || closure.source !== "void-harness:mission.dispatch" || start.source !== "void-harness:mission" || field4(start, "mode") !== "team" || field4(start, "runtime") !== "codex" || field4(start, "runtimeAttested") !== true || observation2.expectedSource !== "runtime:codex" || observation2.stage !== "pre-implementation" || !/^sha256:[a-f0-9]{64}$/.test(String(field4(start, "planHash"))))
+  if (start === void 0 || closure?.kind !== "mission.closed" || closure.source !== "void-harness:mission.dispatch" || start.source !== "void-harness:mission" || field4(start, "mode") !== "team" || field4(start, "runtime") !== "codex" || field4(start, "runtimeAttested") !== true || observation3.expectedSource !== "runtime:codex" || observation3.stage !== "pre-implementation" || !/^sha256:[a-f0-9]{64}$/.test(String(field4(start, "planHash"))))
     return false;
   const panel = events.slice(1, -1);
   if (panel.some((event) => !["specialist.requested", "specialist.started", "specialist.completed"].includes(event.kind) || field4(event, "stage") !== "pre-implementation" || field4(event, "reviewRound") !== 1))
@@ -36582,7 +36665,7 @@ function opaqueNativeContextDefect(input2) {
     return false;
   return completed.every(({ event, completion }) => {
     const context2 = field4(event, "contextId");
-    if (!validNativeContextId(context2) || event.source !== observation2.expectedSource || completion.verdict !== "pass" || completion.findings.length > 0 || completion.evidenceRequests.length > 0 || completion.limitations.length > 0 || completion.specialistId !== event.subject || completion.contractVersion !== observation2.contractVersions[event.subject] || field4(event, "contractVersion") !== completion.contractVersion || field4(event, "inputHash") !== observation2.currentInputHashes[event.subject])
+    if (!validNativeContextId(context2) || event.source !== observation3.expectedSource || completion.verdict !== "pass" || completion.findings.length > 0 || completion.evidenceRequests.length > 0 || completion.limitations.length > 0 || completion.specialistId !== event.subject || completion.contractVersion !== observation3.contractVersions[event.subject] || field4(event, "contractVersion") !== completion.contractVersion || field4(event, "inputHash") !== observation3.currentInputHashes[event.subject])
       return false;
     const requested = requests.find((request) => matchesRequest(event, request) && request.seq < event.seq && field4(request, "planHash") === field4(start, "planHash") && field4(request, "runtime") === "codex" && field4(request, "contractVersion") === completion.contractVersion);
     if (requested === void 0)
@@ -36592,9 +36675,20 @@ function opaqueNativeContextDefect(input2) {
     return starts.length === 1 && started !== void 0 && started.source === event.source && started.seq > requested.seq && started.seq < event.seq && ["stage", "reviewRound", "inputHash", "contractVersion", "contextId"].every((key) => field4(started, key) === field4(event, key));
   });
 }
+function targetedReviewContextDefect(input2) {
+  const { events } = input2.stream;
+  const { observation: observation3 } = input2;
+  const start = events[0];
+  const closure = events.at(-1);
+  const current = completions(events).filter((item) => field4(item.event, "stage") === "post-implementation").at(-1);
+  const receipt2 = current?.completion.review;
+  if (!start || closure?.kind !== "mission.closed" || closure.source !== "void-harness:mission.dispatch" || start.kind !== "mission.started" || start.source !== "void-harness:mission" || field4(start, "runtimeAttested") !== true || observation3.stage !== "post-implementation" || observation3.reviewPolicy !== "bounded-corrections-v1" || !observation3.reviewSubject || !current || !receipt2 || !sameReviewSubject(receipt2, observation3.reviewSubject) || current.completion.verdict !== "pass" || current.event.source !== observation3.expectedSource || field4(current.event, "inputHash") !== observation3.currentInputHashes[current.event.subject] || current.completion.contractVersion !== observation3.contractVersions[current.event.subject])
+    return false;
+  return validNativeReviewContinuation(events, current.event);
+}
 function preparationInvocationReplacement(input2) {
   const { events } = input2.stream;
-  const { observation: observation2, request } = input2;
+  const { observation: observation3, request } = input2;
   if (request.disposition.kind !== "preparation-invocation")
     return false;
   const start = events[0];
@@ -36603,7 +36697,7 @@ function preparationInvocationReplacement(input2) {
   const writers = events.filter((event) => event.kind === "lead-writer.completed");
   const writer = writers[0];
   const writerRequest = writerRequests[0];
-  if (start === void 0 || start.kind !== "mission.started" || start.source !== "void-harness:mission" || !["team", "fortress"].includes(String(field4(start, "mode"))) || field4(start, "runtimeAttested") !== true || `runtime:${String(field4(start, "runtime"))}` !== observation2.expectedSource || !/^sha256:[a-f0-9]{64}$/.test(String(field4(start, "planHash"))) || observation2.stage !== "pre-implementation" || observation2.maxRounds !== 2 || closure?.source !== "void-harness:mission.dispatch" || writer === void 0 || writerRequest === void 0 || writers.length !== 1 || writerRequests.length !== 1 || writerRequest.seq >= writer.seq || writerRequest.source !== "void-harness:mission.dispatch" || writer.subject !== field4(start, "leadWriterId") || writer.source !== writer.subject || writerRequest.subject !== writer.subject || writer.causationId !== writerRequest.eventId || field4(writer, "requestEventId") !== writerRequest.eventId || field4(writer, "actionKind") !== "run-preparation-correction" || field4(writer, "planHash") !== field4(start, "planHash") || field4(writer, "writerId") !== writer.subject || field4(writer, "implementationRound") !== 1 || !["actionKind", "planHash", "writerId", "implementationRound"].every((key) => field4(writer, key) === field4(writerRequest, key)))
+  if (start === void 0 || start.kind !== "mission.started" || start.source !== "void-harness:mission" || !["team", "fortress"].includes(String(field4(start, "mode"))) || field4(start, "runtimeAttested") !== true || `runtime:${String(field4(start, "runtime"))}` !== observation3.expectedSource || !/^sha256:[a-f0-9]{64}$/.test(String(field4(start, "planHash"))) || observation3.stage !== "pre-implementation" || observation3.maxRounds !== 2 || closure?.source !== "void-harness:mission.dispatch" || writer === void 0 || writerRequest === void 0 || writers.length !== 1 || writerRequests.length !== 1 || writerRequest.seq >= writer.seq || writerRequest.source !== "void-harness:mission.dispatch" || writer.subject !== field4(start, "leadWriterId") || writer.source !== writer.subject || writerRequest.subject !== writer.subject || writer.causationId !== writerRequest.eventId || field4(writer, "requestEventId") !== writerRequest.eventId || field4(writer, "actionKind") !== "run-preparation-correction" || field4(writer, "planHash") !== field4(start, "planHash") || field4(writer, "writerId") !== writer.subject || field4(writer, "implementationRound") !== 1 || !["actionKind", "planHash", "writerId", "implementationRound"].every((key) => field4(writer, key) === field4(writerRequest, key)))
     return false;
   const allowed = [
     "mission.started",
@@ -36622,7 +36716,7 @@ function preparationInvocationReplacement(input2) {
   ];
   if (events.some((event) => !allowed.includes(event.kind)))
     return false;
-  const required2 = Object.keys(observation2.contractVersions);
+  const required2 = Object.keys(observation3.contractVersions);
   const panel = completions(events);
   const invocations = events.filter((event) => ["specialist.requested", "specialist.started", "specialist.completed"].includes(event.kind));
   if (required2.length === 0 || panel.length !== required2.length * 2 || invocations.length !== panel.length * 3)
@@ -36637,13 +36731,13 @@ function preparationInvocationReplacement(input2) {
       if (matching.length !== 1 || item === void 0)
         return false;
       const { event, completion } = item;
-      if (event.source !== observation2.expectedSource || field4(event, "stage") !== "pre-implementation" || completion.specialistId !== specialist || completion.contractVersion !== observation2.contractVersions[specialist] || field4(event, "contractVersion") !== completion.contractVersion || !validNativeContextId(field4(event, "contextId")) || completion.verdict !== "pass" || completion.findings.length > 0 || round === 2 && (event.seq <= writer.seq || completion.evidenceRequests.length > 0 || field4(event, "inputHash") !== observation2.currentInputHashes[specialist]) || round === 1 && event.seq >= writerRequest.seq)
+      if (event.source !== observation3.expectedSource || field4(event, "stage") !== "pre-implementation" || completion.specialistId !== specialist || completion.contractVersion !== observation3.contractVersions[specialist] || field4(event, "contractVersion") !== completion.contractVersion || !validNativeContextId(field4(event, "contextId")) || completion.verdict !== "pass" || completion.findings.length > 0 || round === 2 && (event.seq <= writer.seq || completion.evidenceRequests.length > 0 || field4(event, "inputHash") !== observation3.currentInputHashes[specialist]) || round === 1 && event.seq >= writerRequest.seq)
         return false;
       const requests = invocations.filter((candidate) => matchesRequest(event, candidate));
       const requested = requests[0];
       const starts = invocations.filter((candidate) => candidate.kind === "specialist.started" && candidate.subject === specialist && field4(candidate, "reviewRound") === round);
       const started = starts[0];
-      if (requests.length !== 1 || starts.length !== 1 || requested === void 0 || started === void 0 || requested.seq >= started.seq || started.seq >= event.seq || round === 2 && requested.seq <= writer.seq || started.source !== observation2.expectedSource || field4(requested, "planHash") !== field4(start, "planHash") || field4(requested, "runtime") !== field4(start, "runtime") || field4(requested, "contractVersion") !== completion.contractVersion || !["stage", "reviewRound", "inputHash", "contractVersion", "contextId"].every((key) => field4(started, key) === field4(event, key)))
+      if (requests.length !== 1 || starts.length !== 1 || requested === void 0 || started === void 0 || requested.seq >= started.seq || started.seq >= event.seq || round === 2 && requested.seq <= writer.seq || started.source !== observation3.expectedSource || field4(requested, "planHash") !== field4(start, "planHash") || field4(requested, "runtime") !== field4(start, "runtime") || field4(requested, "contractVersion") !== completion.contractVersion || !["stage", "reviewRound", "inputHash", "contractVersion", "contextId"].every((key) => field4(started, key) === field4(event, key)))
         return false;
     }
   }
@@ -36655,12 +36749,12 @@ function preparationInvocationReplacement(input2) {
   });
   const obligations = reduceEvidenceObligations({
     events,
-    expectedSource: observation2.expectedSource,
+    expectedSource: observation3.expectedSource,
     phase: "pre-implementation",
     proofs,
     evidenceContext: {
       missionId: start.missionId,
-      dependencies: observation2.evidenceDependencies ?? {}
+      dependencies: observation3.evidenceDependencies ?? {}
     }
   });
   if (obligations.issues.length > 0 || obligations.blockingObligationIds.length > 0)
@@ -36668,13 +36762,13 @@ function preparationInvocationReplacement(input2) {
   const review = reduceReviewLoop({
     events,
     stage: "pre-implementation",
-    expectedSource: observation2.expectedSource,
+    expectedSource: observation3.expectedSource,
     stageStartSeqExclusive: start.seq,
     afterSeqExclusive: writer.seq,
     requiredSpecialists: required2.filter(specialistId2),
-    contractVersions: observation2.contractVersions,
-    currentInputHashes: observation2.currentInputHashes,
-    maxRounds: observation2.maxRounds
+    contractVersions: observation3.contractVersions,
+    currentInputHashes: observation3.currentInputHashes,
+    maxRounds: observation3.maxRounds
   });
   return review.issues.length === ids.length && review.issues.every((issue4) => issue4.code === "reused-context" && ids.includes(issue4.eventId) && events.some((event) => event.eventId === issue4.eventId && event.seq > writer.seq));
 }
@@ -36742,33 +36836,33 @@ function specialistId2(value) {
 }
 function validProvenanceRecovery(input2, existing, afterSeqExclusive = 0) {
   const disposition = input2.request.disposition;
-  const observation2 = input2.observation;
-  const bindings = observation2.reviewBindings;
-  if (disposition.kind !== "review-provenance" || observation2.stage !== "post-implementation" || observation2.reviewSubject === void 0 || bindings === void 0 || bindings.length === 0 || bindings.length !== disposition.completionEventIds.length || new Set(disposition.completionEventIds).size !== bindings.length || observation2.resolutionArtifact?.path !== disposition.resolutionArtifact.path || observation2.resolutionArtifact.sha256 !== disposition.resolutionArtifact.sha256)
+  const observation3 = input2.observation;
+  const bindings = observation3.reviewBindings;
+  if (disposition.kind !== "review-provenance" || observation3.stage !== "post-implementation" || observation3.reviewSubject === void 0 || bindings === void 0 || bindings.length === 0 || bindings.length !== disposition.completionEventIds.length || new Set(disposition.completionEventIds).size !== bindings.length || observation3.resolutionArtifact?.path !== disposition.resolutionArtifact.path || observation3.resolutionArtifact.sha256 !== disposition.resolutionArtifact.sha256)
     return false;
   const events = input2.stream.events;
   const start = events[0];
   if (start === void 0)
     return false;
   const writerId = field4(start, "leadWriterId");
-  const observedSubject = observation2.reviewSubject;
+  const observedSubject = observation3.reviewSubject;
   return bindings.every((binding3) => {
     const original = existing.find((item) => item.event.eventId === binding3.completionEventId);
-    if (parseReviewReceipt(binding3.review) === void 0 || original === void 0 || original.event.seq <= afterSeqExclusive || !disposition.completionEventIds.includes(binding3.completionEventId) || original.event.subject !== "core:independent-code-reviewer" || original.event.source !== observation2.expectedSource || original.completion.verdict !== "pass" || original.completion.findings.some((finding) => finding.classification !== "advisory") || original.completion.contractVersion !== observation2.contractVersions[original.event.subject] || field4(original.event, "inputHash") !== observation2.currentInputHashes[original.event.subject] || canonicalJsonHash(original.completion) !== binding3.completionHash || !sameReviewSubject(binding3.review, observedSubject) || binding3.review.taskId !== original.event.missionId || binding3.review.writerId !== writerId || binding3.review.provenance.kind !== "native-context" || binding3.review.provenance.contextId !== field4(original.event, "contextId"))
+    if (parseReviewReceipt(binding3.review) === void 0 || original === void 0 || original.event.seq <= afterSeqExclusive || !disposition.completionEventIds.includes(binding3.completionEventId) || original.event.subject !== "core:independent-code-reviewer" || original.event.source !== observation3.expectedSource || original.completion.verdict !== "pass" || original.completion.findings.some((finding) => finding.classification !== "advisory") || original.completion.contractVersion !== observation3.contractVersions[original.event.subject] || field4(original.event, "inputHash") !== observation3.currentInputHashes[original.event.subject] || canonicalJsonHash(original.completion) !== binding3.completionHash || !sameReviewSubject(binding3.review, observedSubject) || binding3.review.taskId !== original.event.missionId || binding3.review.writerId !== writerId || binding3.review.provenance.kind !== "native-context" || binding3.review.provenance.contextId !== field4(original.event, "contextId"))
       return false;
-    const requested = events.find((event) => event.seq > afterSeqExclusive && event.seq < original.event.seq && matchesRequest(original.event, event) && field4(event, "contractVersion") === original.completion.contractVersion && `runtime:${String(field4(event, "runtime"))}` === observation2.expectedSource);
-    return requested !== void 0 && events.some((event) => event.kind === "specialist.started" && event.source === observation2.expectedSource && event.subject === original.event.subject && event.seq > requested.seq && event.seq < original.event.seq && ["stage", "reviewRound", "inputHash", "contractVersion", "contextId"].every((key) => field4(event, key) === field4(original.event, key)));
+    const requested = events.find((event) => event.seq > afterSeqExclusive && event.seq < original.event.seq && matchesRequest(original.event, event) && field4(event, "contractVersion") === original.completion.contractVersion && `runtime:${String(field4(event, "runtime"))}` === observation3.expectedSource);
+    return requested !== void 0 && events.some((event) => event.kind === "specialist.started" && event.source === observation3.expectedSource && event.subject === original.event.subject && event.seq > requested.seq && event.seq < original.event.seq && ["stage", "reviewRound", "inputHash", "contractVersion", "contextId"].every((key) => field4(event, key) === field4(original.event, key)));
   });
 }
 function pendingPreparationClarification(input2, previousRecovery) {
-  const { stream: stream2, request, observation: observation2 } = input2;
+  const { stream: stream2, request, observation: observation3 } = input2;
   const precedingRecovery = stream2.events.filter((event) => event.kind === "mission.recovered" && event.seq < previousRecovery.seq).at(-1);
   if (precedingRecovery !== void 0 && !stream2.events.some((event) => event.kind === "lead-writer.completed" && event.seq > precedingRecovery.seq && event.seq < previousRecovery.seq))
     return false;
   const priorRequest = field4(previousRecovery, "request");
   const priorDisposition = priorRequest !== void 0 && record10(priorRequest) ? priorRequest["disposition"] : void 0;
   const priorObservation = field4(previousRecovery, "observation");
-  if (observation2.stage !== "pre-implementation" || request.disposition.kind !== "review-blocker" || field4(previousRecovery, "nextAction") !== "clarification" || priorObservation === void 0 || !record10(priorObservation) || priorObservation["stage"] !== "pre-implementation" || priorDisposition === void 0 || !record10(priorDisposition) || priorDisposition["kind"] !== "review-blocker" || canonicalJsonHash(priorDisposition["completionEventIds"]) !== canonicalJsonHash(request.disposition.completionEventIds))
+  if (observation3.stage !== "pre-implementation" || request.disposition.kind !== "review-blocker" || field4(previousRecovery, "nextAction") !== "clarification" || priorObservation === void 0 || !record10(priorObservation) || priorObservation["stage"] !== "pre-implementation" || priorDisposition === void 0 || !record10(priorDisposition) || priorDisposition["kind"] !== "review-blocker" || canonicalJsonHash(priorDisposition["completionEventIds"]) !== canonicalJsonHash(request.disposition.completionEventIds))
     return false;
   const intervening = stream2.events.filter((event) => event.seq > previousRecovery.seq);
   if (intervening.length !== 1 || intervening[0]?.kind !== "mission.closed" || intervening[0].source !== "void-harness:mission.dispatch")
@@ -36781,10 +36875,10 @@ function pendingPreparationClarification(input2, previousRecovery) {
   });
   const obligations = reduceEvidenceObligations({
     events: stream2.events,
-    expectedSource: observation2.expectedSource,
+    expectedSource: observation3.expectedSource,
     phase: "pre-implementation",
     proofs,
-    evidenceContext: { dependencies: observation2.evidenceDependencies ?? {} }
+    evidenceContext: { dependencies: observation3.evidenceDependencies ?? {} }
   });
   const blocking = new Set(obligations.blockingObligationIds);
   const completionEventIds = request.disposition.completionEventIds;
@@ -36840,7 +36934,7 @@ function validEvidenceDispositionRecovery(input2) {
   });
 }
 function admitStoppedMission(input2, projectedHistory = input2.stream.events) {
-  const { stream: stream2, request, observation: observation2 } = input2;
+  const { stream: stream2, request, observation: observation3 } = input2;
   const events = stream2.events;
   if (stream2.continuity !== "complete" || stream2.duplicateEventIds > 0 || stream2.invalidLines > 0) {
     return refuse2("invalid-journal", "Restore a complete unambiguous original journal before recovery");
@@ -36860,35 +36954,36 @@ function admitStoppedMission(input2, projectedHistory = input2.stream.events) {
   if (request.disposition.kind === "evidence-disposition" && !validEvidenceDispositionRecovery(input2)) {
     return refuse2("invalid-evidence-disposition", "Complete a pending pre-stop author invocation with fresh canonical proofs; an old or unstarted response cannot reopen this episode");
   }
-  const existing = completions(events).filter((item) => field4(item.event, "stage") === observation2.stage);
+  const existing = completions(events).filter((item) => field4(item.event, "stage") === observation3.stage);
   const previousRecovery = events.filter((event) => event.kind === "mission.recovered").at(-1);
   if (previousRecovery !== void 0 && !events.some((event) => event.seq > previousRecovery.seq && event.kind === "lead-writer.completed") && !pendingPreparationClarification(input2, previousRecovery) && !validEvidenceDispositionRecovery(input2) && !validProvenanceRecovery(input2, existing, previousRecovery.seq)) {
     return refuse2("no-recovery-progress", "Record actual corrective progress before reopening another stopped episode");
   }
   const disposition = request.disposition;
   const replacement = disposition.kind === "preparation-invocation";
+  const targetedContext = disposition.kind === "controller-defect" && disposition.defect === "targeted-review-context";
   if (replacement && !preparationInvocationReplacement(input2)) {
     return refuse2("invalid-preparation-invocation", "Name exactly the reused-context preparation completions with intact invocation bindings; replacement is one-time and retains round two");
   }
-  const roundCorrections = replacement ? [] : partialFanoutCorrections(projectedHistory);
-  const inadmissible = replacement ? disposition.completionEventIds : staleDispatchCompletions(projectedHistory);
-  if (disposition.kind === "controller-defect" && (disposition.defect === "partial-fanout-round" ? roundCorrections.length === 0 : disposition.defect === "stale-input-dispatch" ? inadmissible.length === 0 : !opaqueNativeContextDefect(input2))) {
+  const roundCorrections = replacement || targetedContext ? [] : partialFanoutCorrections(projectedHistory);
+  const inadmissible = replacement ? disposition.completionEventIds : targetedContext ? [] : staleDispatchCompletions(projectedHistory);
+  if (disposition.kind === "controller-defect" && (disposition.defect === "partial-fanout-round" ? roundCorrections.length === 0 : disposition.defect === "stale-input-dispatch" ? inadmissible.length === 0 : targetedContext ? !targetedReviewContextDefect(input2) : !opaqueNativeContextDefect(input2))) {
     return refuse2("unproven-controller-defect", "The journal must prove the requested controller defect; do not reset its budget");
   }
   if (disposition.kind === "review-provenance" && !validProvenanceRecovery(input2, existing)) {
     return refuse2("invalid-review-provenance", "Preserve the actual independent invocation, exact subject, original passing result and contract; provenance cannot upgrade degraded evidence");
   }
   if (disposition.kind === "command-correction") {
-    if (observation2.resolutionArtifact?.path !== disposition.resolutionArtifact.path || observation2.resolutionArtifact.sha256 !== disposition.resolutionArtifact.sha256) {
+    if (observation3.resolutionArtifact?.path !== disposition.resolutionArtifact.path || observation3.resolutionArtifact.sha256 !== disposition.resolutionArtifact.sha256) {
       return refuse2("stale-resolution-artifact", "Read and hash the command correction artifact again before recovery");
     }
-    if (!validCommandEvidenceCorrections(events, disposition.pairs, observation2.evidenceDependencies ?? {})) {
+    if (!validCommandEvidenceCorrections(events, disposition.pairs, observation3.evidenceDependencies ?? {})) {
       return refuse2("invalid-command-correction", "Name intact fresh command proofs with exact argv correspondence; exit 127 or a matching basename cannot authorize replacement");
     }
   }
   if (disposition.kind === "review-blocker") {
     let eligible = existing;
-    if (observation2.stage === "post-implementation" && disposition.completionEventIds.some((id3) => !existing.some((item) => item.event.eventId === id3))) {
+    if (observation3.stage === "post-implementation" && disposition.completionEventIds.some((id3) => !existing.some((item) => item.event.eventId === id3))) {
       const proofs = events.flatMap((event) => {
         if (event.kind !== "evidence.recorded")
           return [];
@@ -36897,43 +36992,43 @@ function admitStoppedMission(input2, projectedHistory = input2.stream.events) {
       });
       const obligations = reduceEvidenceObligations({
         events,
-        expectedSource: observation2.expectedSource,
-        phase: observation2.stage,
+        expectedSource: observation3.expectedSource,
+        phase: observation3.stage,
         proofs,
         evidenceContext: {
           missionId: events[0].missionId,
-          dependencies: observation2.evidenceDependencies ?? {}
+          dependencies: observation3.evidenceDependencies ?? {}
         }
       });
       if (obligations.issues.length > 0)
         return refuse2("invalid-evidence", "Resolve invalid author dispositions before requesting recovery");
       const blocking = new Set(obligations.blockingObligationIds);
       const owners = new Set(obligations.obligations.filter((item) => blocking.has(item.obligationId)).map((item) => item.completionEventId));
-      eligible = [...existing, ...completions(events).filter((item) => field4(item.event, "stage") === "pre-implementation" && owners.has(item.event.eventId) && observation2.contractVersions[item.event.subject] !== void 0)];
+      eligible = [...existing, ...completions(events).filter((item) => field4(item.event, "stage") === "pre-implementation" && owners.has(item.event.eventId) && observation3.contractVersions[item.event.subject] !== void 0)];
     }
     const blockers = eligible.filter(({ event, completion }) => disposition.completionEventIds.includes(event.eventId) && (completion.verdict !== "pass" || completion.findings.length > 0 || completion.evidenceRequests.length > 0 || completion.limitations.length > 0));
     if (blockers.length !== disposition.completionEventIds.length || blockers.length === 0 || new Set(disposition.completionEventIds).size !== blockers.length) {
       return refuse2("missing-review-blocker", "Name existing unresolved review completions before requesting clarification");
     }
-    if (observation2.resolutionArtifact?.path !== disposition.resolutionArtifact.path || observation2.resolutionArtifact.sha256 !== disposition.resolutionArtifact.sha256) {
+    if (observation3.resolutionArtifact?.path !== disposition.resolutionArtifact.path || observation3.resolutionArtifact.sha256 !== disposition.resolutionArtifact.sha256) {
       return refuse2("stale-resolution-artifact", "Read and hash the resolution artifact again before recovery");
     }
   }
   const projected = applyRoundCorrections(projectedHistory, roundCorrections).filter((event) => !inadmissible.includes(event.eventId));
-  const required2 = Object.keys(observation2.contractVersions).filter(specialistId2);
+  const required2 = Object.keys(observation3.contractVersions).filter(specialistId2);
   const writers = projected.filter((event) => event.kind === "lead-writer.completed");
-  const stageStart = observation2.stage === "post-implementation" ? writers.find((event) => field4(event, "actionKind") !== "run-preparation-correction")?.seq : replacement ? events[0]?.seq : void 0;
-  const lastWriter = observation2.stage === "post-implementation" || replacement ? writers.at(-1)?.seq : void 0;
+  const stageStart = observation3.stage === "post-implementation" ? writers.find((event) => field4(event, "actionKind") !== "run-preparation-correction")?.seq : replacement ? events[0]?.seq : void 0;
+  const lastWriter = observation3.stage === "post-implementation" || replacement ? writers.at(-1)?.seq : void 0;
   const migration = validatedSpecialistContractMigrationBoundary(events);
   if (!migration.ok)
     return refuse2("invalid-migration-receipt", migration.reasons.join("; "));
-  const boundary = observation2.stage === "post-implementation" ? migration.migration : void 0;
-  if (boundary !== void 0 && observation2.contractVersions[boundary.receipt.specialistId] !== boundary.receipt.toVersion) {
+  const boundary = observation3.stage === "post-implementation" ? migration.migration : void 0;
+  if (boundary !== void 0 && observation3.contractVersions[boundary.receipt.specialistId] !== boundary.receipt.toVersion) {
     return refuse2("inconsistent-review", "Recovery must observe the authenticated effective specialist contract");
   }
   const reviewInput = {
-    stage: observation2.stage,
-    expectedSource: observation2.expectedSource,
+    stage: observation3.stage,
+    expectedSource: observation3.expectedSource,
     ...boundary === void 0 ? {} : { contractMigration: {
       specialistId: boundary.receipt.specialistId,
       afterSeq: boundary.seq,
@@ -36942,9 +37037,12 @@ function admitStoppedMission(input2, projectedHistory = input2.stream.events) {
     ...stageStart === void 0 ? {} : { stageStartSeqExclusive: stageStart },
     ...lastWriter === void 0 ? {} : { afterSeqExclusive: lastWriter },
     requiredSpecialists: required2,
-    contractVersions: observation2.contractVersions,
-    currentInputHashes: observation2.currentInputHashes,
-    ...observation2.reviewPolicy === "bounded-corrections-v1" ? BOUNDED_REVIEW_BUDGET : { maxRounds: observation2.maxRounds }
+    contractVersions: observation3.contractVersions,
+    currentInputHashes: observation3.currentInputHashes,
+    ...targetedContext ? { validProofIds: freshReviewProofIds(projected, {
+      dependencies: observation3.evidenceDependencies ?? {}
+    }) } : {},
+    ...observation3.reviewPolicy === "bounded-corrections-v1" ? BOUNDED_REVIEW_BUDGET : { maxRounds: observation3.maxRounds }
   };
   const originalReview = reduceReviewLoop({ ...reviewInput, events: projectedHistory });
   if (originalReview.issues.some((issue4) => replacement ? issue4.code !== "reused-context" || !inadmissible.includes(issue4.eventId) : issue4.code !== "wrong-review-round")) {
@@ -36957,14 +37055,17 @@ function admitStoppedMission(input2, projectedHistory = input2.stream.events) {
   if (disposition.kind === "controller-defect" && disposition.defect === "opaque-native-context" && (!review.readyForVerdict || existing.length !== required2.length || required2.some((id3) => !existing.some((item) => item.event.subject === id3)))) {
     return refuse2("incomplete-required-panel", "Every required preparation specialist must have its original matching PASS triplet before recovery");
   }
-  const consumedRounds = Math.max(0, ...(replacement ? projectedHistory : projected).filter((event) => ["specialist.completed", "specialist.failed"].includes(event.kind) && field4(event, "stage") === observation2.stage).map((event) => Number(field4(event, "reviewRound"))));
-  if (!replacement && disposition.kind !== "review-provenance" && consumedRounds >= reviewInput.maxRounds)
+  if (targetedContext && !review.readyForVerdict) {
+    return refuse2("unproven-controller-defect", "The retained targeted review must resolve every blocking finding with current evidence before verification");
+  }
+  const consumedRounds = Math.max(0, ...(replacement ? projectedHistory : projected).filter((event) => ["specialist.completed", "specialist.failed"].includes(event.kind) && field4(event, "stage") === observation3.stage).map((event) => Number(field4(event, "reviewRound"))));
+  if (!replacement && !targetedContext && disposition.kind !== "review-provenance" && consumedRounds >= reviewInput.maxRounds)
     return refuse2("review-budget-exhausted", "The real review budget is exhausted; recovery cannot reset it");
   const consumedCorrectionBatches = projected.filter((event) => event.kind === "lead-writer.completed" && field4(event, "actionKind") === "run-correction").length;
-  if (disposition.kind === "review-provenance" && consumedCorrectionBatches > 2) {
+  if ((targetedContext || disposition.kind === "review-provenance") && consumedCorrectionBatches > 2) {
     return refuse2("review-budget-exhausted", "The real correction budget is exhausted; recovery cannot reset it");
   }
-  const preserved = existing.filter((item) => !inadmissible.includes(item.event.eventId) && item.completion.contractVersion === observation2.contractVersions[item.event.subject] && field4(item.event, "inputHash") === observation2.currentInputHashes[item.event.subject]);
+  const preserved = targetedContext ? existing : existing.filter((item) => !inadmissible.includes(item.event.eventId) && item.completion.contractVersion === observation3.contractVersions[item.event.subject] && field4(item.event, "inputHash") === observation3.currentInputHashes[item.event.subject]);
   const preservedIds = new Set(preserved.map((item) => item.event.eventId));
   const receipt2 = {
     schemaVersion: 1,
@@ -36974,18 +37075,18 @@ function admitStoppedMission(input2, projectedHistory = input2.stream.events) {
     priorJournalLastSeq: stream2.lastSeq,
     requestHash: canonicalJsonHash(request),
     request,
-    observation: observation2,
+    observation: observation3,
     preservedCompletionEventIds: [...preservedIds],
     invalidatedCompletionEventIds: existing.filter((item) => !preservedIds.has(item.event.eventId)).map((item) => item.event.eventId),
     inadmissibleCompletionEventIds: inadmissible,
     roundCorrections,
     consumedRounds,
     remainingRounds: Math.max(0, reviewInput.maxRounds - consumedRounds),
-    ...!replacement && disposition.kind !== "review-provenance" ? {} : {
+    ...!replacement && !targetedContext && disposition.kind !== "review-provenance" ? {} : {
       consumedCorrectionBatches,
       remainingCorrectionBatches: 2 - consumedCorrectionBatches
     },
-    nextAction: replacement || disposition.kind === "evidence-disposition" || disposition.kind === "review-provenance" || disposition.kind === "command-correction" || disposition.kind === "controller-defect" && disposition.defect === "opaque-native-context" ? "verification" : disposition.kind === "review-blocker" ? "clarification" : "correction"
+    nextAction: replacement || targetedContext || disposition.kind === "evidence-disposition" || disposition.kind === "review-provenance" || disposition.kind === "command-correction" || disposition.kind === "controller-defect" && disposition.defect === "opaque-native-context" ? "verification" : disposition.kind === "review-blocker" ? "clarification" : "correction"
   };
   if (new TextEncoder().encode(canonicalJson(receipt2)).length > 16384) {
     return refuse2("recovery-receipt-too-large", "Narrow the recovery scope to the supported bounded incident");
@@ -37012,7 +37113,7 @@ function recoveryRequest(value) {
   if (disposition["kind"] === "command-correction") {
     return exactKeys2(disposition, ["kind", "pairs", "resolutionArtifact"]) && isCommandEvidenceCorrections(disposition["pairs"]) && artifact(disposition["resolutionArtifact"]);
   }
-  return disposition["kind"] === "controller-defect" ? exactKeys2(disposition, ["kind", "defect"]) && ["partial-fanout-round", "stale-input-dispatch", "opaque-native-context"].includes(String(disposition["defect"])) : (disposition["kind"] === "review-blocker" || disposition["kind"] === "review-provenance") && exactKeys2(disposition, ["kind", "completionEventIds", "resolutionArtifact"]) && Array.isArray(disposition["completionEventIds"]) && disposition["completionEventIds"].length <= 64 && disposition["completionEventIds"].every((item) => typeof item === "string") && artifact(disposition["resolutionArtifact"]);
+  return disposition["kind"] === "controller-defect" ? exactKeys2(disposition, ["kind", "defect"]) && ["partial-fanout-round", "stale-input-dispatch", "opaque-native-context", "targeted-review-context"].includes(String(disposition["defect"])) : (disposition["kind"] === "review-blocker" || disposition["kind"] === "review-provenance") && exactKeys2(disposition, ["kind", "completionEventIds", "resolutionArtifact"]) && Array.isArray(disposition["completionEventIds"]) && disposition["completionEventIds"].length <= 64 && disposition["completionEventIds"].every((item) => typeof item === "string") && artifact(disposition["resolutionArtifact"]);
 }
 function reviewBinding(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value))
@@ -37062,11 +37163,11 @@ function validateRecoveries(events) {
     if (event.kind !== "mission.recovered")
       continue;
     const request = field4(event, "request");
-    const observation2 = field4(event, "observation");
-    if (event.source !== "void-harness:mission.recover" || !recoveryRequest(request) || !recoveryObservation(observation2))
+    const observation3 = field4(event, "observation");
+    if (event.source !== "void-harness:mission.recover" || !recoveryRequest(request) || !recoveryObservation(observation3))
       return void 0;
     const prefix = events.slice(0, index);
-    const decision = admitStoppedMission({ stream: streamFrom(prefix), request, observation: observation2 }, projectRecoveries(prefix, validated));
+    const decision = admitStoppedMission({ stream: streamFrom(prefix), request, observation: observation3 }, projectRecoveries(prefix, validated));
     if (decision.kind !== "recover" || canonicalJsonHash(decision.receipt) !== canonicalJsonHash(event.payload))
       return void 0;
     validated.push({ event, receipt: decision.receipt });
@@ -37350,18 +37451,18 @@ function label3(value, min, max) {
   }
   return true;
 }
-function stringList2(value, field9) {
+function stringList2(value, field11) {
   if (value === void 0)
     return Object.freeze([]);
   if (!Array.isArray(value) || value.length > MAX_POLICY_SIGNALS) {
-    return `${field9} must be an array of at most ${MAX_POLICY_SIGNALS} signals`;
+    return `${field11} must be an array of at most ${MAX_POLICY_SIGNALS} signals`;
   }
   if (!value.every((item) => label3(item, 1, 64) && SIGNAL_ID.test(item))) {
-    return `${field9} contains an invalid signal`;
+    return `${field11} contains an invalid signal`;
   }
   const values = [...value].sort();
   if (new Set(values).size !== values.length) {
-    return `${field9} contains duplicate signals`;
+    return `${field11} contains duplicate signals`;
   }
   return Object.freeze(values);
 }
@@ -37465,9 +37566,9 @@ function parseWaiver(value, index) {
     expiresAt: raw["expiresAt"]
   });
 }
-function parseItems(value, maximum, field9, parser) {
+function parseItems(value, maximum, field11, parser) {
   if (!Array.isArray(value) || value.length === 0 || value.length > maximum) {
-    return `${field9} must contain 1 to ${maximum} entries`;
+    return `${field11} must contain 1 to ${maximum} entries`;
   }
   const parsed = [];
   for (const [index, item] of value.entries()) {
@@ -37864,12 +37965,12 @@ var MAX_RISK_STACK_ITEMS = 64;
 function utf8Bytes3(value) {
   return new TextEncoder().encode(value).byteLength;
 }
-function assertBoundedList(values, maximum, field9) {
+function assertBoundedList(values, maximum, field11) {
   if (values.length > maximum) {
-    throw new Error(`RISK_INPUT_TOO_LARGE: ${field9} exceeds ${maximum} entries`);
+    throw new Error(`RISK_INPUT_TOO_LARGE: ${field11} exceeds ${maximum} entries`);
   }
   if (values.some((value) => utf8Bytes3(value) > 512)) {
-    throw new Error(`RISK_INPUT_TOO_LARGE: ${field9} contains an entry over 512 bytes`);
+    throw new Error(`RISK_INPUT_TOO_LARGE: ${field11} contains an entry over 512 bytes`);
   }
 }
 function assertBounded(input2) {
@@ -38469,9 +38570,9 @@ function bounded(value, minimum, maximum) {
   }
   return true;
 }
-function normalizeList(values, maximum, field9) {
+function normalizeList(values, maximum, field11) {
   if (values.length > maximum || values.some((value) => !bounded(value, 1, 512))) {
-    throw new Error(`MISSION_INPUT_INVALID: ${field9} is not bounded`);
+    throw new Error(`MISSION_INPUT_INVALID: ${field11} is not bounded`);
   }
   return Object.freeze([...new Set(values)].sort());
 }
@@ -38884,17 +38985,17 @@ function recoveredPreparationTargets(events) {
   if (recovery === void 0)
     return void 0;
   const payload = record15(recovery.payload);
-  const observation2 = record15(payload?.["observation"] ?? null);
+  const observation3 = record15(payload?.["observation"] ?? null);
   const request = record15(payload?.["request"] ?? null);
   const disposition = record15(request?.["disposition"] ?? null);
   const ids = disposition?.["completionEventIds"];
-  if (observation2?.["stage"] !== "pre-implementation" || !["review-blocker", "preparation-invocation"].includes(String(disposition?.["kind"])) || !Array.isArray(ids))
+  if (observation3?.["stage"] !== "pre-implementation" || !["review-blocker", "preparation-invocation"].includes(String(disposition?.["kind"])) || !Array.isArray(ids))
     return void 0;
   return {
     recoverySeq: recovery.seq,
     replacement: disposition?.["kind"] === "preparation-invocation",
-    inputHashes: record15(observation2["currentInputHashes"] ?? {}) ?? {},
-    contractVersions: record15(observation2["contractVersions"] ?? {}) ?? {},
+    inputHashes: record15(observation3["currentInputHashes"] ?? {}) ?? {},
+    contractVersions: record15(observation3["contractVersions"] ?? {}) ?? {},
     specialistIds: events.filter((item) => item.kind === "specialist.completed" && ids.includes(item.eventId)).map((item) => item.subject)
   };
 }
@@ -38914,10 +39015,10 @@ function pendingRecoveredCorrectionFindingIds(events) {
   if (recovery === void 0 || events.some((event) => event.seq > recovery.seq && event.kind === "lead-writer.completed"))
     return [];
   const payload = record15(recovery.payload);
-  const observation2 = record15(payload?.["observation"] ?? null);
+  const observation3 = record15(payload?.["observation"] ?? null);
   const invalidated = payload?.["invalidatedCompletionEventIds"];
   const remaining = payload?.["remainingRounds"];
-  if (payload?.["nextAction"] !== "correction" || observation2?.["stage"] !== "post-implementation" || typeof remaining !== "number" || remaining < 1 || !Array.isArray(invalidated))
+  if (payload?.["nextAction"] !== "correction" || observation3?.["stage"] !== "post-implementation" || typeof remaining !== "number" || remaining < 1 || !Array.isArray(invalidated))
     return [];
   return [...new Set(events.flatMap((event) => {
     if (event.kind !== "specialist.completed" || event.seq >= recovery.seq || !invalidated.includes(event.eventId) || lifecycleField(event, "stage") !== "post-implementation")
@@ -38991,6 +39092,7 @@ function orchestrateMissionTeam(originalInput) {
     contractVersions: contractVersions(input2.plan),
     currentInputHashes: input2.currentInputHashesByStage["pre-implementation"],
     maxRounds: input2.maxReviewRounds,
+    validProofIds: freshReviewProofIds(input2.stream.events, input2.evidenceContext),
     evidenceObligations: {
       ...obligations,
       blockingObligationIds: obligations.blockingObligationIds.filter((id3) => preparationObligationIds.has(id3))
@@ -39106,12 +39208,7 @@ function orchestrateMissionTeam(originalInput) {
     ...start.boundedReview ? BOUNDED_REVIEW_BUDGET : { maxRounds: input2.maxReviewRounds },
     // Pending proofs are handled by obligationStop; they must not mask failed reviews.
     evidenceObligations: { ...obligations, blockingObligationIds: [] },
-    validProofIds: input2.stream.events.flatMap((event) => {
-      if (event.kind !== "evidence.recorded")
-        return [];
-      const parsed = parseEvidence(lifecycleField(event, "evidence"));
-      return parsed.ok && parsed.value.evidenceId === event.subject && parsed.value.missionId === event.missionId && parsed.value.status === "passed" && assessEvidence(parsed.value, input2.evidenceContext).status === "fresh" ? [parsed.value.evidenceId] : [];
-    }),
+    validProofIds: freshReviewProofIds(input2.stream.events, input2.evidenceContext),
     ...migration === void 0 ? {} : { contractMigration: {
       specialistId: migration.receipt.specialistId,
       afterSeq: migration.seq,
@@ -40272,9 +40369,9 @@ var LOGICAL = /^[A-Za-z0-9._~:/-]{1,256}$/;
 function isGraphRelationKind(value) {
   return SEGMENT2.test(value) || value === "decided_by" || value === "constrained_by" || value === "verified_by";
 }
-function segment2(value, field9) {
+function segment2(value, field11) {
   if (!SEGMENT2.test(value)) {
-    throw new Error(`GRAPH_ID_INVALID: ${field9} must be a lower-case namespace segment`);
+    throw new Error(`GRAPH_ID_INVALID: ${field11} must be a lower-case namespace segment`);
   }
   return value;
 }
@@ -42588,8 +42685,11 @@ var manifestSchema = external_exports.object({ hooks: external_exports.record(ex
   matcher: external_exports.string().max(500).optional(),
   hooks: external_exports.array(external_exports.object({ type: external_exports.string(), command: external_exports.string().max(2e3) })).max(100)
 })).max(100)) });
+function hookRunnerCommand(wrapper) {
+  return /^\s*(?:exec "\$NODE_BIN"|node) "(?:\$HOOK_DIR\/_void-hook\.mjs|\$RUNNER)" ((?:enforce|lifecycle) [a-z-]+|activation|outcome)(?:\s|$)/m.exec(wrapper)?.[1];
+}
 function hookWiring(name, wrapper, manifests) {
-  const runner2 = /^\s*(?:exec "\$NODE_BIN"|node) "(?:\$HOOK_DIR\/_void-hook\.mjs|\$RUNNER)" ((?:enforce|lifecycle) [a-z-]+|activation|outcome)(?:\s|$)/m.exec(wrapper)?.[1];
+  const runner2 = hookRunnerCommand(wrapper);
   return manifests.flatMap(({ runtime: runtime2, value }) => Object.entries(manifestSchema.parse(value).hooks).flatMap(([event, groups]) => groups.filter((group) => group.hooks.some((hook) => {
     if (hook.type !== "command") return false;
     const nodeCall = /^node "\$\{(?:CLAUDE_PLUGIN_ROOT|VOID_HOOKS_DIR)\}\/(?:hooks\/)?_void-hook\.mjs" ([a-z-]+(?: [a-z-]+)*)$/.exec(hook.command)?.[1];
@@ -42598,7 +42698,7 @@ function hookWiring(name, wrapper, manifests) {
   })).map((group) => ({ name, runtime: runtime2, trigger: `${event} (${group.matcher ?? "*"})` }))));
 }
 async function loadCatalog(sourceRoot) {
-  const core = await findCoreSource();
+  const core = sourceRoot ?? await findCoreSource();
   const input2 = JSON.parse(await requireData(core, "data/model.json", 4 * 1024 * 1024));
   const specialistDirectory = await lstat(join(core, "specialists"));
   if (!specialistDirectory.isDirectory() || specialistDirectory.isSymbolicLink()) throw new Error("SPECIALIST_SOURCE_INVALID");
@@ -43166,8 +43266,8 @@ init_esm_shims();
 function remedyPrefix(roots) {
   return roots.workRoot === roots.installRoot ? "" : `in ${roots.installRoot}: `;
 }
-function installedPath(roots, relative30) {
-  return roots.workRoot === roots.installRoot ? relative30 : join(roots.installRoot, relative30);
+function installedPath(roots, relative31) {
+  return roots.workRoot === roots.installRoot ? relative31 : join(roots.installRoot, relative31);
 }
 
 // src/lib/cheatsheet/render.ts
@@ -43545,8 +43645,8 @@ function keptTrackedCandidates() {
 }
 var FIX = "a project rule wins over the managed block; run git check-ignore -v <path> to see which, then narrow it so these paths stay visible and git add them";
 function judgeKeptTracked(observations) {
-  const reportable = observations.filter((observation2) => observation2.present);
-  const hidden = reportable.filter((observation2) => observation2.ignored === true).map((observation2) => `${observation2.path} (${observation2.rule ?? "rule unknown"})`).sort();
+  const reportable = observations.filter((observation3) => observation3.present);
+  const hidden = reportable.filter((observation3) => observation3.ignored === true).map((observation3) => `${observation3.path} (${observation3.rule ?? "rule unknown"})`).sort();
   if (hidden.length > 0) {
     return {
       name: CHECK_NAME,
@@ -43556,7 +43656,7 @@ function judgeKeptTracked(observations) {
       fix: FIX
     };
   }
-  const unmeasured = reportable.filter((observation2) => observation2.ignored === void 0).map((observation2) => observation2.path).sort();
+  const unmeasured = reportable.filter((observation3) => observation3.ignored === void 0).map((observation3) => observation3.path).sort();
   if (unmeasured.length > 0) {
     return {
       name: CHECK_NAME,
@@ -47574,12 +47674,12 @@ init_esm_shims();
 
 // src/lib/autopilot/preflight.ts
 init_esm_shims();
-function malformedProgram(observation2) {
-  const program = observation2.program;
+function malformedProgram(observation3) {
+  const program = observation3.program;
   return program !== void 0 && "malformed" in program ? program.malformed : void 0;
 }
-function parsedProgram(observation2) {
-  const program = observation2.program;
+function parsedProgram(observation3) {
+  const program = observation3.program;
   return program === void 0 || "malformed" in program ? void 0 : program;
 }
 var RUNTIME_ADAPTERS = ["claude", "codex"];
@@ -47595,13 +47695,13 @@ function unknown2(name, message2, fix) {
 function unprobed(name, message2) {
   return { name, ok: false, status: "unprobed", message: message2 };
 }
-function programCheck(observation2) {
+function programCheck(observation3) {
   const name = "autopilot program";
-  const broken = malformedProgram(observation2);
+  const broken = malformedProgram(observation3);
   if (broken !== void 0) {
     return fail2(name, `.void/program.md could not be parsed: ${broken.problem}`, broken.fix);
   }
-  const program = parsedProgram(observation2);
+  const program = parsedProgram(observation3);
   if (program === void 0) {
     return unknown2(
       name,
@@ -47634,10 +47734,10 @@ function programCheck(observation2) {
 }
 var UNPARSED = "not judged: .void/program.md could not be parsed";
 var UNPARSED_FIX = "fix the frontmatter reported by the program check above, then run doctor again";
-function mergeModeCheck(observation2) {
+function mergeModeCheck(observation3) {
   const name = "autopilot merge";
-  if (malformedProgram(observation2) !== void 0) return unknown2(name, UNPARSED, UNPARSED_FIX);
-  const block2 = parsedProgram(observation2)?.autopilot;
+  if (malformedProgram(observation3) !== void 0) return unknown2(name, UNPARSED, UNPARSED_FIX);
+  const block2 = parsedProgram(observation3)?.autopilot;
   const gate = block2?.legacyMergeGate;
   if (gate !== void 0) {
     return fail2(
@@ -47653,10 +47753,10 @@ function mergeModeCheck(observation2) {
     `the loop merges into ${base} on a clean local verdict, never into ${deploying}; \`${PRODUCT_COMMAND} autopilot merges --by-human\` hands every reviewed pull request to a person`
   );
 }
-function verifyCommandsCheck(observation2) {
+function verifyCommandsCheck(observation3) {
   const name = "autopilot verify";
-  if (malformedProgram(observation2) !== void 0) return unknown2(name, UNPARSED, UNPARSED_FIX);
-  const commands = parsedProgram(observation2)?.autopilot?.verifyCommands ?? [];
+  if (malformedProgram(observation3) !== void 0) return unknown2(name, UNPARSED, UNPARSED_FIX);
+  const commands = parsedProgram(observation3)?.autopilot?.verifyCommands ?? [];
   if (commands.length === 0) {
     return fail2(
       name,
@@ -47676,9 +47776,9 @@ function verifyCommandsCheck(observation2) {
   }
   return pass(name, `${commands.length} verify command(s)`);
 }
-function adapterCheck(observation2) {
+function adapterCheck(observation3) {
   const name = "autopilot runtime";
-  const usable = observation2.adapters.filter((adapter) => RUNTIME_ADAPTERS.includes(adapter));
+  const usable = observation3.adapters.filter((adapter) => RUNTIME_ADAPTERS.includes(adapter));
   if (usable.length === 0) {
     return fail2(
       name,
@@ -47688,24 +47788,24 @@ function adapterCheck(observation2) {
   }
   return pass(name, `${usable.join(", ")} adapter(s)`);
 }
-function connectorCheck(observation2) {
+function connectorCheck(observation3) {
   const name = "autopilot tracker";
   {
     return unprobed(name, "not probed here; autopilot proves the connector at preflight, before it claims a lease");
   }
 }
-function worktreeCheck(observation2) {
+function worktreeCheck(observation3) {
   const name = "autopilot worktrees";
-  if (observation2.worktreesUsable === null) {
+  if (observation3.worktreesUsable === null) {
     return unknown2(name, "worktree support could not be determined", "run this inside the git repository autopilot would work in");
   }
-  return observation2.worktreesUsable ? pass(name, "worktrees usable") : fail2(
+  return observation3.worktreesUsable ? pass(name, "worktrees usable") : fail2(
     name,
     "worktrees cannot be created here, and a worker never works in the main checkout",
     "run autopilot from a git repository where `git worktree add` succeeds"
   );
 }
-function protectionCheck(observation2) {
+function protectionCheck(observation3) {
   const name = "autopilot base";
   {
     return unprobed(
@@ -47714,14 +47814,14 @@ function protectionCheck(observation2) {
     );
   }
 }
-function autopilotPreflight(observation2) {
+function autopilotPreflight(observation3) {
   return Object.freeze([
-    programCheck(observation2),
-    mergeModeCheck(observation2),
-    verifyCommandsCheck(observation2),
-    adapterCheck(observation2),
+    programCheck(observation3),
+    mergeModeCheck(observation3),
+    verifyCommandsCheck(observation3),
+    adapterCheck(observation3),
     connectorCheck(),
-    worktreeCheck(observation2),
+    worktreeCheck(observation3),
     protectionCheck()
   ]);
 }
@@ -47796,57 +47896,57 @@ function frontmatterOf(text7) {
   }
   return match[1];
 }
-function record19(value, field9) {
+function record19(value, field11) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     invalid8(
-      `the program descriptor has no usable \`${field9}\` block`,
-      `\`${field9}\` is ${Array.isArray(value) ? "a list" : String(value)}, not a mapping`,
-      `declare \`${field9}:\` as a mapping of its documented fields`
+      `the program descriptor has no usable \`${field11}\` block`,
+      `\`${field11}\` is ${Array.isArray(value) ? "a list" : String(value)}, not a mapping`,
+      `declare \`${field11}:\` as a mapping of its documented fields`
     );
   }
   return value;
 }
-function requiredString(source2, field9, context2) {
-  const value = source2[field9];
+function requiredString(source2, field11, context2) {
+  const value = source2[field11];
   if (typeof value !== "string" || value.trim().length === 0) {
     invalid8(
-      `the program descriptor is missing \`${context2}.${field9}\``,
-      value === void 0 ? `\`${field9}\` is absent` : `\`${field9}\` is not a non-empty string`,
-      `set \`${field9}\` in the \`${context2}\` block to the value it names`
+      `the program descriptor is missing \`${context2}.${field11}\``,
+      value === void 0 ? `\`${field11}\` is absent` : `\`${field11}\` is not a non-empty string`,
+      `set \`${field11}\` in the \`${context2}\` block to the value it names`
     );
   }
   return value;
 }
-function nonEmptyStringList(value, field9) {
+function nonEmptyStringList(value, field11) {
   if (!Array.isArray(value) || value.length === 0 || value.some((entry) => typeof entry !== "string" || entry.trim().length === 0)) {
     invalid8(
-      `the program descriptor has no usable \`${field9}\``,
-      `\`${field9}\` must be a non-empty list of non-empty strings`,
-      `declare \`${field9}\` as a YAML list naming the provider values actually used`
+      `the program descriptor has no usable \`${field11}\``,
+      `\`${field11}\` must be a non-empty list of non-empty strings`,
+      `declare \`${field11}\` as a YAML list naming the provider values actually used`
     );
   }
   return value;
 }
-function confinedPath(value, field9) {
+function confinedPath(value, field11) {
   if (isAbsolute(value) || value.split(/[\\/]/).includes("..")) {
     invalid8(
-      `the program descriptor \`${field9}\` leaves the repository`,
+      `the program descriptor \`${field11}\` leaves the repository`,
       `\`${value}\` is absolute or walks up out of the project root`,
-      `set \`${field9}\` to a path relative to the repository root, without \`..\``
+      `set \`${field11}\` to a path relative to the repository root, without \`..\``
     );
   }
   return value;
 }
-function pathList2(value, field9) {
+function pathList2(value, field11) {
   if (value === void 0) return [];
   if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string" || entry.trim().length === 0)) {
     invalid8(
-      `the program descriptor \`${field9}\` is not a list of paths`,
-      `\`${field9}\` must be a list of non-empty strings`,
-      `declare \`${field9}\` as a YAML list of repo-relative path patterns`
+      `the program descriptor \`${field11}\` is not a list of paths`,
+      `\`${field11}\` must be a list of non-empty strings`,
+      `declare \`${field11}\` as a YAML list of repo-relative path patterns`
     );
   }
-  return value.map((entry) => confinedPath(entry, field9));
+  return value.map((entry) => confinedPath(entry, field11));
 }
 function verifyCommands(value) {
   if (value === void 0) return [];
@@ -48481,37 +48581,37 @@ function settledRenames(resolution) {
   if (settled2.length === 0) return "";
   return `; ${String(settled2.length)} settled rename(s): ${settled2.map(withSuccessor).join(", ")}`;
 }
-function evidence(observation2) {
-  const { liveness } = observation2;
+function evidence(observation3) {
+  const { liveness } = observation3;
   const unseen = liveness.unobservable.map(
     ({ source: source2, toolCalls }) => `skill usage not observable for ${source2} (${toolCalls} tool calls); activation count unknown`
   ).join("; ");
   if (liveness.missions === 0 && unseen !== "") {
-    return `${observation2.installedSkills} skill(s) installed; ${unseen}`;
+    return `${observation3.installedSkills} skill(s) installed; ${unseen}`;
   }
   if (liveness.missions === 0) {
-    return `${observation2.installedSkills} skill(s) installed, no working mission recorded yet`;
+    return `${observation3.installedSkills} skill(s) installed, no working mission recorded yet`;
   }
-  return `${observation2.installedSkills} skill(s) installed, ${liveness.skillCalls} activation(s) across ${liveness.toolCalls} tool calls (${ratio2(liveness)}) over ${liveness.missions} observable Claude working mission(s)` + (unseen === "" ? "" : `; ${unseen}`);
+  return `${observation3.installedSkills} skill(s) installed, ${liveness.skillCalls} activation(s) across ${liveness.toolCalls} tool calls (${ratio2(liveness)}) over ${liveness.missions} observable Claude working mission(s)` + (unseen === "" ? "" : `; ${unseen}`);
 }
-function judgeInvocation(observation2) {
+function judgeInvocation(observation3) {
   const faults = [];
-  if (!observation2.resolution.ok) {
+  if (!observation3.resolution.ok) {
     faults.push(
-      `${observation2.resolution.unresolved.length} retired name(s) recorded: ` + observation2.resolution.unresolved.map(withSuccessor).join(", ")
+      `${observation3.resolution.unresolved.length} retired name(s) recorded: ` + observation3.resolution.unresolved.map(withSuccessor).join(", ")
     );
   }
-  if (!observation2.liveness.ok) {
+  if (!observation3.liveness.ok) {
     faults.push(
-      `no skill fired across ${observation2.liveness.missions} working mission(s) and ${observation2.liveness.toolCalls} tool calls (runtime:claude)`
+      `no skill fired across ${observation3.liveness.missions} working mission(s) and ${observation3.liveness.toolCalls} tool calls (runtime:claude)`
     );
   }
   if (faults.length === 0) {
     return {
       name: NAME3,
-      ok: observation2.liveness.unobservable.length === 0,
-      status: observation2.liveness.unobservable.length === 0 ? "pass" : "unknown",
-      message: `${evidence(observation2)}${settledRenames(observation2.resolution)}`
+      ok: observation3.liveness.unobservable.length === 0,
+      status: observation3.liveness.unobservable.length === 0 ? "pass" : "unknown",
+      message: `${evidence(observation3)}${settledRenames(observation3.resolution)}`
     };
   }
   return {
@@ -48520,11 +48620,11 @@ function judgeInvocation(observation2) {
     status: "fail",
     // Both faults, never the first alone: they have different causes, and fixing
     // one would otherwise reveal the other only on the next run.
-    message: `${faults.join("; ")}; ${evidence(observation2)}`,
+    message: `${faults.join("; ")}; ${evidence(observation3)}`,
     // Never "reinstall": the file is not missing, the name moved. What the reader
     // has to change is whatever still calls the old name -- a saved command, a
     // habit, another skill's text.
-    fix: !observation2.resolution.ok ? "invoke each successor named above instead, and update whatever still calls the old name" : "inspect the Claude Skill invocation path and activation collector for the silent missions"
+    fix: !observation3.resolution.ok ? "invoke each successor named above instead, and update whatever still calls the old name" : "inspect the Claude Skill invocation path and activation collector for the silent missions"
   };
 }
 
@@ -48553,9 +48653,9 @@ var CHECK_NAME2 = "void observed";
 var FIX2 = `${PRODUCT_COMMAND} update \u2014 it moves observed state under .void/machine/, which the managed block ignores; a path that must stay where it is needs its own .gitignore line`;
 function judgeObservedIgnore(observations) {
   const reportable = observations.filter(
-    (observation2) => observation2.present && !isDeliberatelyTracked(observation2.path)
+    (observation3) => observation3.present && !isDeliberatelyTracked(observation3.path)
   );
-  const leaking = reportable.filter((observation2) => observation2.ignored === false).map((observation2) => observation2.path).sort();
+  const leaking = reportable.filter((observation3) => observation3.ignored === false).map((observation3) => observation3.path).sort();
   if (leaking.length > 0) {
     return {
       name: CHECK_NAME2,
@@ -48565,7 +48665,7 @@ function judgeObservedIgnore(observations) {
       fix: FIX2
     };
   }
-  const unmeasured = reportable.filter((observation2) => observation2.ignored === void 0).map((observation2) => observation2.path).sort();
+  const unmeasured = reportable.filter((observation3) => observation3.ignored === void 0).map((observation3) => observation3.path).sort();
   if (unmeasured.length > 0) {
     return {
       name: CHECK_NAME2,
@@ -48653,38 +48753,38 @@ function fail3(name, message2, fix) {
 function unknown3(name, message2, fix) {
   return { name, ok: false, status: "unknown", message: message2, fix };
 }
-function layoutCheck(observation2) {
+function layoutCheck(observation3) {
   const name = "void layout";
-  if (observation2.pending.length === 0) return pass2(name, "observed state is under .void/machine/");
+  if (observation3.pending.length === 0) return pass2(name, "observed state is under .void/machine/");
   return fail3(
     name,
-    `${observation2.pending.length} observed path(s) still at the old location: ${observation2.pending.join(", ")}`,
+    `${observation3.pending.length} observed path(s) still at the old location: ${observation3.pending.join(", ")}`,
     `${PRODUCT_COMMAND} update \u2014 it moves them under .void/machine/ and never overwrites`
   );
 }
-function ignoreCheck(observation2) {
+function ignoreCheck(observation3) {
   const name = "void ignore";
-  if (observation2.localIgnored === null) {
+  if (observation3.localIgnored === null) {
     return unknown3(name, "not a git repository, so nothing ignores anything here", "run this inside the repository the project ships from");
   }
-  return observation2.localIgnored ? pass2(name, ".void/machine/ is ignored") : fail3(
+  return observation3.localIgnored ? pass2(name, ".void/machine/ is ignored") : fail3(
     name,
     ".void/machine/ is NOT ignored, so telemetry and run journals would be committed",
     `${PRODUCT_COMMAND} update \u2014 it writes the managed block; check no later rule re-includes .void/`
   );
 }
-function trackedCheck(observation2) {
+function trackedCheck(observation3) {
   const name = "void tracked";
-  if (observation2.trackedObserved.length === 0) return pass2(name, "no observed state in the index");
+  if (observation3.trackedObserved.length === 0) return pass2(name, "no observed state in the index");
   return fail3(
     name,
-    `git tracks ${observation2.trackedObserved.length} observed path(s): ${observation2.trackedObserved.join(", ")}`,
-    `git rm --cached -r ${observation2.trackedObserved.join(" ")} \u2014 the ignore rule cannot untrack what is already in the index`
+    `git tracks ${observation3.trackedObserved.length} observed path(s): ${observation3.trackedObserved.join(", ")}`,
+    `git rm --cached -r ${observation3.trackedObserved.join(" ")} \u2014 the ignore rule cannot untrack what is already in the index`
   );
 }
-function orphanCheck(observation2) {
+function orphanCheck(observation3) {
   const name = "void orphans";
-  const orphans2 = observation2.orphanedAssets;
+  const orphans2 = observation3.orphanedAssets;
   if (orphans2.length === 0) {
     return { name, ok: true, message: "no harness asset on disk that the manifest lost track of" };
   }
@@ -48696,9 +48796,9 @@ function orphanCheck(observation2) {
     fix: "they were edited locally, so update kept them; delete them to stop loading two versions"
   };
 }
-function manifestCheck(observation2) {
+function manifestCheck(observation3) {
   const name = "void manifest";
-  const manifest = observation2.manifest;
+  const manifest = observation3.manifest;
   if (manifest.kind === "absent") {
     return {
       name,
@@ -48727,9 +48827,9 @@ function manifestCheck(observation2) {
     coEdited === 0 ? `assets match manifest ${version3}` : `assets match manifest ${version3}; ${String(coEdited)} co-owned file(s) carry project edits`
   );
 }
-function receiptCheck(observation2) {
+function receiptCheck(observation3) {
   const name = "void receipt";
-  const receipt2 = observation2.receipt;
+  const receipt2 = observation3.receipt;
   if (receipt2.kind === "absent") {
     return {
       name,
@@ -48748,7 +48848,7 @@ function receiptCheck(observation2) {
   if (missingTotal === 0) return pass2(name, `every file receipt ${version3} recorded is on disk`);
   const example2 = receipt2.missing?.[0];
   const shown = example2 === void 0 ? "" : `, for example ${example2}`;
-  const manifest = observation2.manifest;
+  const manifest = observation3.manifest;
   const rolledBack = manifest.kind === "present" && manifest.version !== void 0 && manifest.version !== version3;
   if (rolledBack) {
     return fail3(
@@ -48759,14 +48859,14 @@ function receiptCheck(observation2) {
   }
   return fail3(name, `receipt ${version3} records ${String(missingTotal)} file(s) that are not on disk${shown}`, fix);
 }
-function derivedCheck(observation2) {
+function derivedCheck(observation3) {
   const name = "void derived";
-  if (observation2.trackedDerivedCount === 0) return pass2(name, "no regenerated content in the index");
+  if (observation3.trackedDerivedCount === 0) return pass2(name, "no regenerated content in the index");
   return {
     name,
     ok: true,
     status: "advisory",
-    message: `git tracks ${observation2.trackedDerivedCount} file(s) that \`hydrate\` restores from the manifest`,
+    message: `git tracks ${observation3.trackedDerivedCount} file(s) that \`hydrate\` restores from the manifest`,
     fix: `${PRODUCT_COMMAND} update --untrack-derived (keeps the files on disk, drops them from the index)`
   };
 }
@@ -48784,24 +48884,24 @@ function judgeProjectSkills(ignored) {
     fix
   };
 }
-function judgeLayout(observation2) {
+function judgeLayout(observation3) {
   return Object.freeze([
-    layoutCheck(observation2),
-    ignoreCheck(observation2),
+    layoutCheck(observation3),
+    ignoreCheck(observation3),
     // Generalizes the check above from the one declared path to every path the
     // harness can write observed state to, legacy locations included.
-    judgeObservedIgnore(observation2.observedPaths),
+    judgeObservedIgnore(observation3.observedPaths),
     // The same question the other way round: a declaration that a path stays
     // TRACKED is no more a proof than one that a path is ignored.
-    judgeKeptTracked(observation2.keptTracked),
-    orphanCheck(observation2),
-    trackedCheck(observation2),
-    manifestCheck(observation2),
+    judgeKeptTracked(observation3.keptTracked),
+    orphanCheck(observation3),
+    trackedCheck(observation3),
+    manifestCheck(observation3),
     // After the manifest, deliberately: when the assets were rolled back the
     // manifest reads green, and the reader needs the two lines side by side to
     // see that the green one is answering about the wrong version.
-    receiptCheck(observation2),
-    derivedCheck(observation2)
+    receiptCheck(observation3),
+    derivedCheck(observation3)
   ]);
 }
 
@@ -50119,9 +50219,9 @@ async function observeLayout(root) {
   const listed = git4(["ls-files", "-z", "--", ".void"]) ?? "";
   const tracked = listed.split("\0").filter((path3) => path3 !== "");
   const trackedObserved = tracked.filter((path3) => {
-    const relative30 = path3.startsWith(".void/") ? path3.slice(".void/".length) : path3;
-    if (relative30.startsWith(`${VOID_MACHINE_DIR}/`)) return true;
-    return isMachineEntry(relative30.split("/")[0] ?? "");
+    const relative31 = path3.startsWith(".void/") ? path3.slice(".void/".length) : path3;
+    if (relative31.startsWith(`${VOID_MACHINE_DIR}/`)) return true;
+    return isMachineEntry(relative31.split("/")[0] ?? "");
   });
   const materialized = git4(["ls-files", "-z", "--", ".void", ".claude", ".agents", ".codex"]) ?? "";
   const trackedDerivedCount = owned === void 0 ? 0 : materialized.split("\0").filter((path3) => path3 !== "" && owned.has(path3.split("\\").join("/"))).length;
@@ -50158,15 +50258,15 @@ function observeOrphanedAssets(root) {
     return [];
   }
   const discovered = [];
-  const walk = (relative30) => {
+  const walk = (relative31) => {
     let entries;
     try {
-      entries = readdirSync(join(root, relative30));
+      entries = readdirSync(join(root, relative31));
     } catch {
       return;
     }
     for (const entry of entries) {
-      const child = `${relative30}/${entry}`;
+      const child = `${relative31}/${entry}`;
       const absolute2 = join(root, child);
       let isDirectory = false;
       try {
@@ -50261,14 +50361,14 @@ function observeIgnoredProjectSkills(root) {
     }
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const relative30 = `${home}/${entry.name}`;
-      if ([...owned].some((path3) => path3.startsWith(`${relative30}/`))) continue;
+      const relative31 = `${home}/${entry.name}`;
+      if ([...owned].some((path3) => path3.startsWith(`${relative31}/`))) continue;
       try {
-        execFileSync("git", ["check-ignore", "-q", `${relative30}/`], {
+        execFileSync("git", ["check-ignore", "-q", `${relative31}/`], {
           cwd: root,
           stdio: ["ignore", "ignore", "ignore"]
         });
-        ignored.push(relative30);
+        ignored.push(relative31);
       } catch {
       }
     }
@@ -51358,32 +51458,32 @@ function observedDone(view, input2) {
   return { transition: next(view, input2.now, "turn-ended", "result-missing", "the agent ended its turn but the delegation-result hook recorded no final message", "send a message asking for the final result: void-machine agents send <runId>") };
 }
 function endedByResult(view, input2) {
-  const { observation: observation2, result, now } = input2;
-  if (observation2.kind !== "present" || observation2.status === "busy")
+  const { observation: observation3, result, now } = input2;
+  if (observation3.kind !== "present" || observation3.status === "busy")
     return void 0;
-  if (observation2.state === "failed" || observation2.state === "stopped")
+  if (observation3.state === "failed" || observation3.state === "stopped")
     return void 0;
   if (result === void 0 || result.recordedAt < view.turnStartedAt || result.pendingWork > 0)
     return void 0;
   if (view.state === "turn-ended")
     return {};
-  const question = observation2.state === "blocked";
+  const question = observation3.state === "blocked";
   return { transition: next(view, now, "turn-ended", "turn-ended", question ? "the agent ended its turn with a question; its final message is collected" : "the agent ended its turn and its final message is collected", question ? "answer with void-machine agents send <runId>, or accept the result" : "read it with void-machine agents status <runId>, then accept or send") };
 }
 function observeRun(view, input2) {
-  const { observation: observation2, now } = input2;
-  if (!isOpen(view.state) || observation2.kind === "unreadable")
+  const { observation: observation3, now } = input2;
+  if (!isOpen(view.state) || observation3.kind === "unreadable")
     return {};
-  if (observation2.kind === "absent")
+  if (observation3.kind === "absent")
     return observedAbsent(view, now);
   const ended = endedByResult(view, input2);
   if (ended !== void 0)
     return ended;
-  switch (observation2.state) {
+  switch (observation3.state) {
     case "working":
       return view.state === "working" ? {} : { transition: next(view, now, "working", "observed", "the agent is working", "wait with void-machine agents wait <runId>") };
     case "blocked": {
-      const waitingFor = observation2.waitingFor ?? "input needed";
+      const waitingFor = observation3.waitingFor ?? "input needed";
       if (view.state === "waiting-human" && view.last.waitingFor === waitingFor)
         return {};
       return { transition: next(view, now, "waiting-human", "observed", `the agent waits for a person: ${waitingFor}`, "decide in the agent session: void-machine agents attach <runId>", waitingFor) };
@@ -51395,7 +51495,7 @@ function observeRun(view, input2) {
     case "stopped":
       return { transition: next(view, now, "stopped", "observed", "the session was stopped", "dispatch a new run if the work is still needed") };
     default: {
-      const unknown4 = observation2.state;
+      const unknown4 = observation3.state;
       return unknown4;
     }
   }
@@ -51458,9 +51558,9 @@ function remoteReference(value, depth = 0) {
   }
   if (!isObject3(value))
     return void 0;
-  const reference = value["$ref"];
-  if (typeof reference === "string" && !reference.startsWith("#")) {
-    return `the schema names a $ref outside itself (${reference.slice(0, 100)})`;
+  const reference2 = value["$ref"];
+  if (typeof reference2 === "string" && !reference2.startsWith("#")) {
+    return `the schema names a $ref outside itself (${reference2.slice(0, 100)})`;
   }
   for (const child of Object.values(value)) {
     const found = remoteReference(child, depth + 1);
@@ -54285,8 +54385,8 @@ var localReviewSchema = external_exports.strictObject({
   }
 });
 function describeIssue(issue4) {
-  const field9 = issue4.path.length === 0 ? "(root)" : issue4.path.map(String).join(".");
-  return `${field9}: ${issue4.message}`;
+  const field11 = issue4.path.length === 0 ? "(root)" : issue4.path.map(String).join(".");
+  return `${field11}: ${issue4.message}`;
 }
 function admit2(what, schema, value) {
   const parsed = schema.safeParse(value);
@@ -54526,13 +54626,10 @@ var TRACKED_TICKETS_MAX = 256;
 var HUMAN_WAIT_LABEL = "void:human-wait";
 var PROTECTED_PATHS_FLOOR = [
   ".github/**",
-  "scripts/independent-review-check.mjs",
-  "scripts/independent-review-run.mjs",
-  // What a judging workflow runs from outside `.github`: the promotion audit
-  // runs develop's own copy, void-enforce replays the auto-merge contract and
+  // What a judging workflow runs from outside `.github`: void-enforce
+  // replays the auto-merge contract and
   // the enforcement floor from the pull request, and ci.yml's required verdict
   // is aggregated by verify.mjs.
-  "scripts/promotion-authority.mjs",
   "scripts/auto-merge-contract.mjs",
   "scripts/verify.mjs",
   "packages/core/enforce/**",
@@ -54681,8 +54778,8 @@ function admitLoopTracker(value) {
   const parsed = loopTrackerSchema.safeParse(value);
   if (parsed.success) return { ok: true, value: parsed.data };
   const issues = parsed.error.issues.map((issue4) => {
-    const field9 = issue4.path.length === 0 ? "(root)" : issue4.path.join(".");
-    return `${field9}: ${issue4.message}`;
+    const field11 = issue4.path.length === 0 ? "(root)" : issue4.path.join(".");
+    return `${field11}: ${issue4.message}`;
   }).join("; ");
   return { ok: false, reason: `tracker observation refused: ${issues}` };
 }
@@ -55169,8 +55266,8 @@ var COMMIT_SHA = /^[0-9a-f]{40}$/;
 function blocked(reason2, detail) {
   return { kind: "blocked", reason: reason2, detail };
 }
-function selectBase(observation2) {
-  const branches = observation2.branches;
+function selectBase(observation3) {
+  const branches = observation3.branches;
   if (!Array.isArray(branches) || branches.length === 0) {
     return blocked("no-conventional-base", "the observation lists no branch on the remote");
   }
@@ -55187,7 +55284,7 @@ function selectBase(observation2) {
     }
     names.add(branch.name);
   }
-  const requested = observation2.requested;
+  const requested = observation3.requested;
   if (typeof requested !== "string" || requested.trim().length === 0) {
     return blocked(
       "requested-base-missing",
@@ -56155,7 +56252,7 @@ async function inspectMission(root, missionId, context2, options2 = {}) {
   }
   const text7 = await readFile(log, "utf8");
   const stream2 = replayEventLog(text7);
-  const quarantineFiles = await quarantineInvalidLines(
+  const quarantineFiles = options2.quarantine === false ? [] : await quarantineInvalidLines(
     run2,
     text7,
     options2.secrets ?? collectKnownSecrets()
@@ -58172,29 +58269,29 @@ init_esm_shims();
 var import_yaml8 = __toESM(require_dist());
 var import_yaml9 = __toESM(require_dist());
 var import_picomatch4 = __toESM(require_picomatch2());
-function invalid9(field9) {
-  throw new Error(`invalid declaration field: ${field9}`);
+function invalid9(field11) {
+  throw new Error(`invalid declaration field: ${field11}`);
 }
-function text4(value, field9, max = 512) {
+function text4(value, field11, max = 512) {
   if (typeof value !== "string" || value.length === 0 || value.length > max)
-    invalid9(field9);
+    invalid9(field11);
   if ([...value].some((c2) => {
     const n = c2.codePointAt(0) ?? 0;
     return n < 32 || n >= 127 && n <= 159;
   }))
-    invalid9(field9);
+    invalid9(field11);
   return value;
 }
-function list3(value, field9, optional2 = false) {
+function list3(value, field11, optional2 = false) {
   if (optional2 && value === void 0) return Object.freeze([]);
-  if (!Array.isArray(value) || value.length > 256) invalid9(field9);
+  if (!Array.isArray(value) || value.length > 256) invalid9(field11);
   return Object.freeze(
-    [...new Set(value.map((v2) => text4(v2, field9, 1024)))].sort()
+    [...new Set(value.map((v2) => text4(v2, field11, 1024)))].sort()
   );
 }
-function choice(value, field9, choices) {
-  const parsed = text4(value, field9, 32);
-  if (!choices.includes(parsed)) invalid9(field9);
+function choice(value, field11, choices) {
+  const parsed = text4(value, field11, 32);
+  if (!choices.includes(parsed)) invalid9(field11);
   return parsed;
 }
 function validateProjectDeclaration(value, kind2) {
@@ -59131,9 +59228,9 @@ function createTypeScriptExtractor(api) {
 function configError(message2) {
   throw new Error(`PROJECT_TYPESCRIPT_CONFIG_INVALID: ${message2}`);
 }
-function jsonRecord2(value, field9) {
+function jsonRecord2(value, field11) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    return configError(`${field9} must be an object`);
+    return configError(`${field11} must be an object`);
   }
   return value;
 }
@@ -59340,9 +59437,9 @@ function resolveTypeScriptConfigInheritance(api, configs, caseSensitive) {
 function workspaceError(message2) {
   throw new Error(`PROJECT_WORKSPACE_INVALID: ${message2}`);
 }
-function record21(value, field9) {
+function record21(value, field11) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    return workspaceError(`${field9} must be an object`);
+    return workspaceError(`${field11} must be an object`);
   }
   return value;
 }
@@ -59355,13 +59452,13 @@ function containsControl(value) {
 function dependencyNames(input2) {
   const names = /* @__PURE__ */ new Set();
   const fields = ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"];
-  for (const field9 of fields) {
-    const value = input2[field9];
+  for (const field11 of fields) {
+    const value = input2[field11];
     if (value === void 0) continue;
-    for (const name of Object.keys(record21(value, field9))) {
+    for (const name of Object.keys(record21(value, field11))) {
       if (names.size >= 1e4) workspaceError("dependency declarations exceed their limit");
       if (name.length === 0 || name.length > 214 || containsControl(name)) {
-        workspaceError(`${field9} contains an invalid package name`);
+        workspaceError(`${field11} contains an invalid package name`);
       }
       names.add(name);
     }
@@ -59465,8 +59562,8 @@ function workspaceExports(input2, workspacePath) {
 }
 function workspaceEntrypoints(input2, workspacePath, exports) {
   const raw = [];
-  for (const field9 of ["source", "main", "module", "types", "typings"]) {
-    entrypointStrings(input2[field9], raw);
+  for (const field11 of ["source", "main", "module", "types", "typings"]) {
+    entrypointStrings(input2[field11], raw);
   }
   const exported2 = exports["."] ?? [];
   if (exported2.length === 0 && raw.length === 0) {
@@ -60616,6 +60713,9 @@ function executableCandidates() {
       join(programFiles, "Git", "bin", "git.exe")
     ];
   }
+  if (process.platform === "darwin") {
+    return ["/opt/homebrew/bin/git", "/usr/local/bin/git", "/usr/bin/git", "/bin/git"];
+  }
   return ["/usr/bin/git", "/bin/git", "/usr/local/bin/git", "/opt/homebrew/bin/git"];
 }
 async function trustedGitPath(explicit) {
@@ -63358,15 +63458,15 @@ function ownersOf(snapshot2, id3) {
 function testsFor(snapshot2, id3) {
   return relatedThrough(snapshot2, id3, TEST_KINDS, true, `no test coverage was extracted for ${id3}`);
 }
-function stalenessOf(snapshot2, observation2) {
-  if (snapshot2.source.rootHash !== observation2.rootHash) {
+function stalenessOf(snapshot2, observation22) {
+  if (snapshot2.source.rootHash !== observation22.rootHash) {
     return {
       stale: true,
       fallback: "source",
-      reason: `the root hash moved (${snapshot2.source.rootHash} -> ${observation2.rootHash}); read source instead`
+      reason: `the root hash moved (${snapshot2.source.rootHash} -> ${observation22.rootHash}); read source instead`
     };
   }
-  if (!observation2.complete) {
+  if (!observation22.complete) {
     return {
       stale: false,
       fallback: "source",
@@ -65943,8 +66043,8 @@ function enclosingProject2(from) {
   }
 }
 function readCheckpointFile(root) {
-  for (const relative30 of CHECKPOINT_PATHS) {
-    const path3 = join(root, relative30);
+  for (const relative31 of CHECKPOINT_PATHS) {
+    const path3 = join(root, relative31);
     try {
       if (!existsSync(path3)) continue;
       return {
@@ -67162,16 +67262,588 @@ async function pruneMissions(root, olderThanDays, apply, now = /* @__PURE__ */ n
   return candidates;
 }
 
+// src/commands/mission-usage.ts
+init_esm_shims();
+
+// src/lib/runs/usage-sessions.ts
+init_esm_shims();
+
+// src/lib/runs/usage-session-contract.ts
+init_esm_shims();
+var usageMissionId = external_exports.string().regex(/^mis_[A-Za-z0-9_-]{8,100}$/);
+var anchorSchema = external_exports.strictObject({
+  seq: external_exports.number().int().nonnegative(),
+  eventId: external_exports.string().regex(/^(?:origin|evt_[A-Za-z0-9_-]{8,100})$/),
+  digest: external_exports.string().regex(/^sha256:[a-f0-9]{64}$/)
+});
+var openingSchema = external_exports.strictObject({ targetMissionId: usageMissionId, previous: anchorSchema });
+var closingSchema2 = openingSchema.extend({ opening: anchorSchema });
+var usageReferenceSchema = external_exports.strictObject({ sourceMissionId: usageMissionId, opening: anchorSchema });
+var USAGE_SOURCE = `${PRODUCT_COMMAND}:usage`;
+var isUsageSource = (source2) => [PRODUCT_COMMAND, ...PRODUCT_IDENTITY.commands.deprecated].some((command2) => source2 === `${command2}:usage`);
+var MAX_USAGE_LINKS = 32;
+var usageEventId = (...parts) => `evt_usage_${canonicalJsonHash(parts).slice(7)}`;
+var sameUsageAnchor = (left, right) => left.seq === right.seq && left.eventId === right.eventId && left.digest === right.digest;
+function scanUsageSource(events, sourceMissionId) {
+  let prefix = { seq: 0, eventId: "origin", digest: canonicalJsonHash([]) };
+  let active;
+  const intervals = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Set();
+  for (const event of events) {
+    if (event.seq !== prefix.seq + 1 || event.missionId !== sourceMissionId || event.correlationId !== sourceMissionId || seen.has(event.eventId)) {
+      throw new Error("USAGE_SOURCE_INTEGRITY: inconsistent source journal");
+    }
+    seen.add(event.eventId);
+    const next2 = {
+      seq: event.seq,
+      eventId: event.eventId,
+      digest: canonicalJsonHash([prefix.digest, event])
+    };
+    if (event.kind === "usage.session.opened" || event.kind === "usage.session.closed") {
+      const parsed = (event.kind === "usage.session.opened" ? openingSchema : closingSchema2).safeParse(event.payload);
+      if (!parsed.success || !isUsageSource(event.source) || event.subject !== parsed.data.targetMissionId || !sameUsageAnchor(parsed.data.previous, prefix)) {
+        throw new Error("USAGE_BOUNDARY_INVALID: source prefix or receipt changed");
+      }
+      if (event.kind === "usage.session.opened") {
+        if (active !== void 0 || intervals.has(parsed.data.targetMissionId)) {
+          throw new Error("USAGE_BOUNDARY_INVALID: overlapping or reopened interval");
+        }
+        active = { targetMissionId: parsed.data.targetMissionId, opening: next2 };
+        intervals.set(active.targetMissionId, active);
+      } else {
+        const closed = closingSchema2.parse(event.payload);
+        if (active === void 0 || active.targetMissionId !== closed.targetMissionId || !sameUsageAnchor(active.opening, closed.opening)) {
+          throw new Error("USAGE_BOUNDARY_INVALID: closure does not match the active interval");
+        }
+        intervals.set(active.targetMissionId, { ...active, closing: next2 });
+        active = void 0;
+      }
+    }
+    prefix = next2;
+  }
+  return { prefix, intervals, ...active === void 0 ? {} : { active } };
+}
+
+// src/lib/runs/usage-sessions.ts
+var requestSchema = external_exports.strictObject({
+  root: external_exports.string().min(1),
+  missionId: usageMissionId,
+  sourceMissionId: usageMissionId,
+  action: external_exports.enum(["bind", "unbind"])
+});
+async function readUsageJournal(root, missionId) {
+  const path3 = await eventLogPath(root, usageMissionId.parse(missionId));
+  const stream2 = replayEventLog(await requireData(root, relative(root, path3), MAX_EVENT_LOG_BYTES));
+  if (stream2.continuity !== "complete" || stream2.duplicateEventIds > 0 || stream2.events.some((event) => event.missionId !== missionId || event.correlationId !== missionId)) {
+    throw new Error("USAGE_SOURCE_INTEGRITY: unreadable, duplicate or mixed journal; no usage attributed");
+  }
+  return stream2.events;
+}
+async function reference(root, target, source2, interval, write3) {
+  try {
+    const eventId3 = usageEventId("reference", target, source2);
+    const existing = (await readUsageJournal(root, target)).find((event) => event.eventId === eventId3);
+    const persistedSource = existing !== void 0 && isUsageSource(existing.source) ? existing.source : USAGE_SOURCE;
+    await write3({
+      root,
+      missionId: target,
+      eventId: eventId3,
+      draft: {
+        source: persistedSource,
+        kind: "usage.session.linked",
+        subject: source2,
+        correlationId: target,
+        payload: { sourceMissionId: source2, opening: interval.opening }
+      },
+      validate: (events) => {
+        observedMissionLifecycle(events);
+        if (events.filter((event) => event.kind === "usage.session.linked").length >= MAX_USAGE_LINKS) {
+          throw new Error("USAGE_LINK_LIMIT: at most 32 source journals per mission");
+        }
+      }
+    });
+  } catch (error62) {
+    if (error62 instanceof Error && error62.message.startsWith("USAGE_LINK_LIMIT:")) throw error62;
+    throw new Error("USAGE_REFERENCE_PENDING: source receipt is durable; retry the same command to repair the target reference");
+  }
+}
+async function changeUsageSession(input2, write3 = writeSequencedEventOnce) {
+  const request = requestSchema.parse(input2);
+  const { root, missionId, sourceMissionId } = request;
+  if (sourceMissionId === missionId) throw new Error("USAGE_SELF_LINK: source and target must differ");
+  const targetEvents = await readUsageJournal(root, missionId);
+  observedMissionLifecycle(targetEvents);
+  const interval = await changeSourceInterval(request, targetEvents, write3);
+  try {
+    await reference(root, missionId, sourceMissionId, interval, write3);
+  } catch (error62) {
+    if (!(error62 instanceof Error) || !error62.message.startsWith("USAGE_LINK_LIMIT:")) throw error62;
+    try {
+      await changeSourceInterval({ ...request, action: "unbind" }, targetEvents, write3);
+    } catch {
+      throw new Error(`USAGE_CAPACITY_CLEANUP_PENDING: target is full; source closure is unconfirmed. Restore source access and run mission usage-unbind --id ${missionId} --source ${sourceMissionId}; the full target cannot accept this reference`);
+    }
+    throw new Error("USAGE_LINK_LIMIT: target is full; excess source interval is closed; no reference can be added");
+  }
+  return { sourceMissionId, status: interval.closing === void 0 ? "open" : "closed", interval };
+}
+async function changeSourceInterval(request, targetEvents, write3) {
+  const { root, missionId, sourceMissionId, action } = request;
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    const scanned = scanUsageSource(await readUsageJournal(root, sourceMissionId), sourceMissionId);
+    const interval = scanned.intervals.get(missionId);
+    if (interval !== void 0 && (action === "bind" || interval.closing !== void 0)) {
+      return interval;
+    }
+    if (action === "unbind" && interval === void 0) throw new Error("USAGE_NOT_BOUND: no prospective interval exists");
+    if (action === "bind") {
+      requireOpenMission(targetEvents);
+      if (scanned.active !== void 0) throw new Error("USAGE_SOURCE_BUSY: close the active target before binding another");
+      if (targetEvents.filter((event) => event.kind === "usage.session.linked").length >= MAX_USAGE_LINKS) {
+        throw new Error("USAGE_LINK_LIMIT: at most 32 source journals per mission");
+      }
+    }
+    try {
+      await write3({
+        root,
+        missionId: sourceMissionId,
+        eventId: usageEventId(action, missionId, sourceMissionId),
+        draft: {
+          source: USAGE_SOURCE,
+          kind: action === "bind" ? "usage.session.opened" : "usage.session.closed",
+          subject: missionId,
+          correlationId: sourceMissionId,
+          payload: {
+            targetMissionId: missionId,
+            previous: scanned.prefix,
+            ...interval === void 0 ? {} : { opening: interval.opening }
+          }
+        },
+        validate: (events) => {
+          if (!sameUsageAnchor(scanUsageSource(events, sourceMissionId).prefix, scanned.prefix)) {
+            throw new Error("USAGE_SOURCE_CHANGED: source appended during binding; retry");
+          }
+        }
+      });
+    } catch (error62) {
+      if (error62 instanceof Error && (error62.message.startsWith("USAGE_SOURCE_CHANGED:") || error62.message.startsWith("HOOK_EVENT_ID_CONFLICT:"))) continue;
+      throw error62;
+    }
+    const updated = scanUsageSource(await readUsageJournal(root, sourceMissionId), sourceMissionId).intervals.get(missionId);
+    if (updated === void 0) throw new Error("USAGE_BOUNDARY_INVALID: written interval is missing");
+    return updated;
+  }
+  throw new Error("USAGE_SOURCE_CHANGED: concurrent writes prevented a stable boundary; retry the same command");
+}
+async function readUsageSessions(root, missionId, events) {
+  const references = events.filter((event) => event.missionId === missionId && event.kind === "usage.session.linked");
+  const scopes = [];
+  const links = [];
+  const notes = [];
+  if (references.length > MAX_USAGE_LINKS) return {
+    scopes,
+    links,
+    notes: ["Linked usage unavailable: source reference limit exceeded."]
+  };
+  const seen = /* @__PURE__ */ new Set();
+  const sourceCounts = /* @__PURE__ */ new Map();
+  for (const event of references) {
+    const parsed = usageReferenceSchema.safeParse(event.payload);
+    if (parsed.success) sourceCounts.set(
+      parsed.data.sourceMissionId,
+      (sourceCounts.get(parsed.data.sourceMissionId) ?? 0) + 1
+    );
+  }
+  for (const event of references) {
+    const parsed = usageReferenceSchema.safeParse(event.payload);
+    const source2 = parsed.success ? parsed.data.sourceMissionId : "unknown";
+    if (seen.has(source2)) continue;
+    seen.add(source2);
+    try {
+      if (!parsed.success || !isUsageSource(event.source) || event.subject !== source2 || event.correlationId !== missionId || source2 === missionId || sourceCounts.get(source2) !== 1) {
+        throw new Error("USAGE_REFERENCE_INVALID");
+      }
+      const sourceEvents = await readUsageJournal(root, source2);
+      const interval = scanUsageSource(sourceEvents, source2).intervals.get(missionId);
+      if (interval === void 0 || !sameUsageAnchor(interval.opening, parsed.data.opening)) {
+        throw new Error("USAGE_BOUNDARY_INVALID");
+      }
+      scopes.push({ missionId: source2, events: sourceEvents.filter((candidate) => candidate.seq > interval.opening.seq && (interval.closing === void 0 || candidate.seq < interval.closing.seq)) });
+      links.push({ sourceMissionId: source2, status: interval.closing === void 0 ? "open" : "closed", interval });
+      notes.push(`${source2}: ${interval.closing === void 0 ? "provisional/shared-session" : "closed shared-session interval"}; explicit attribution, not worker isolation or authentication.`);
+    } catch {
+      links.push({ sourceMissionId: source2, status: "unavailable" });
+      notes.push(`${source2}: linked usage unavailable; no counts attributed from this source.`);
+    }
+  }
+  return { scopes, links, notes };
+}
+
+// src/lib/runs/usage-advisory.ts
+init_esm_shims();
+var advisorySchema = external_exports.strictObject({
+  root: external_exports.string().min(1),
+  missionId: usageMissionId,
+  specialistId: external_exports.string().regex(/^core:[a-z0-9]+(?:-[a-z0-9]+)*$/),
+  runtime: external_exports.enum(["claude", "codex"]),
+  contextId: external_exports.string().refine(validNativeContextId)
+});
+async function recordUsageAdvisory(input2) {
+  const request = advisorySchema.parse(input2);
+  const specialists = await loadSpecialists(await findCoreSource());
+  if (!specialists.some((specialist) => specialist.id === request.specialistId)) {
+    throw new Error("USAGE_SPECIALIST_UNKNOWN: use a canonical specialist role from the catalogue");
+  }
+  await readUsageJournal(request.root, request.missionId);
+  const recorded = await writeSequencedEventOnce({
+    root: request.root,
+    missionId: request.missionId,
+    eventId: usageEventId("advisory", request.missionId, request.runtime, request.contextId),
+    draft: {
+      source: "coordinator-observed",
+      kind: "usage.advisory.started",
+      subject: request.specialistId,
+      correlationId: request.missionId,
+      payload: { runtime: request.runtime, contextId: request.contextId }
+    },
+    validate: requireOpenMission
+  });
+  return { eventId: recorded.event.eventId, provenance: "coordinator-observed" };
+}
+
+// src/commands/mission-usage.ts
+var MISSION_ID10 = /^mis_[A-Za-z0-9_-]{8,100}$/;
+function parseUsageCommand(input2, helpers) {
+  const { subcommand, options: options2, divider: divider2 } = input2;
+  const { invalid: invalid17, valueAfter: valueAfter4, missionIdFrom: missionIdFrom2, validateOptions: validateOptions3 } = helpers;
+  if (subcommand === "usage-bind" || subcommand === "usage-unbind" || subcommand === "advisory-start") {
+    if (divider2 !== -1) return invalid17("usage commands do not accept a command", "remove --");
+    const names = options2.filter((value) => value.startsWith("--"));
+    if (new Set(names).size !== names.length) return invalid17("duplicate usage option", "provide each option once");
+    const error62 = validateOptions3(options2, subcommand === "advisory-start" ? ["--id", "--specialist", "--runtime", "--context"] : ["--id", "--source"], ["--json"]);
+    if (error62 !== void 0) return invalid17(error62, `${PRODUCT_COMMAND} mission --help`);
+    const missionId = missionIdFrom2(options2);
+    if (typeof missionId !== "string") return missionId;
+    if (subcommand !== "advisory-start") {
+      const sourceMissionId = valueAfter4(options2, "--source");
+      if (sourceMissionId === void 0 || !MISSION_ID10.test(sourceMissionId)) return invalid17("invalid source ID", "pass --source mis_<exact-session-journal>");
+      return { kind: subcommand, missionId, sourceMissionId, json: options2.includes("--json") };
+    }
+    const specialistId3 = valueAfter4(options2, "--specialist");
+    const runtime2 = valueAfter4(options2, "--runtime");
+    const contextId = valueAfter4(options2, "--context");
+    if (specialistId3 === void 0 || !/^core:[a-z0-9]+(?:-[a-z0-9]+)*$/.test(specialistId3) || runtime2 !== "claude" && runtime2 !== "codex" || contextId === void 0 || contextId.trim() === "") {
+      return invalid17("advisory start needs a role, runtime and actual native context", "pass --specialist core:<role> --runtime claude|codex --context <successful-native-context>");
+    }
+    return { kind: "advisory-start", missionId, specialistId: specialistId3, runtime: runtime2, contextId, json: options2.includes("--json") };
+  }
+  return void 0;
+}
+async function runUsageCommand(parsed, journal) {
+  if (parsed.kind === "usage-bind" || parsed.kind === "usage-unbind") {
+    const result2 = await changeUsageSession({
+      root: journal,
+      missionId: parsed.missionId,
+      sourceMissionId: parsed.sourceMissionId,
+      action: parsed.kind === "usage-bind" ? "bind" : "unbind"
+    });
+    return parsed.json ? `${JSON.stringify(result2)}
+` : `${result2.sourceMissionId}: ${result2.status}
+`;
+  }
+  const result = await recordUsageAdvisory({
+    root: journal,
+    missionId: parsed.missionId,
+    specialistId: parsed.specialistId,
+    runtime: parsed.runtime,
+    contextId: parsed.contextId
+  });
+  return parsed.json ? `${JSON.stringify(result)}
+` : `${result.eventId}: coordinator-observed advisory start
+`;
+}
+
+// src/lib/runs/usage-report.ts
+init_esm_shims();
+
+// src/lib/runs/usage.ts
+init_esm_shims();
+
+// src/lib/runs/usage-activity.ts
+init_esm_shims();
+var MAX_ACTIVITY_ROWS = 200;
+var MAX_TEXT_ROWS = 20;
+function field7(event, name) {
+  const value = event.payload;
+  return value && typeof value === "object" && !Array.isArray(value) ? Object.entries(value).find(([key]) => key === name)?.[1] : void 0;
+}
+function dispatchIdentity(event) {
+  const stage = field7(event, "stage");
+  const round = field7(event, "reviewRound");
+  const version3 = field7(event, "contractVersion");
+  const hash7 = field7(event, "inputHash");
+  if (!["pre-implementation", "post-implementation"].includes(String(stage)) || typeof round !== "number" || !Number.isSafeInteger(round) || round < 1 || typeof version3 !== "number" || !Number.isSafeInteger(version3) || version3 < 1 || typeof hash7 !== "string" || !/^sha256:[a-f0-9]{64}$/.test(hash7)) return void 0;
+  return canonicalJsonHash([
+    event.missionId,
+    event.source,
+    event.subject,
+    event.causationId ?? "",
+    stage ?? "",
+    round,
+    version3,
+    hash7,
+    field7(event, "reviewSubject") ?? "",
+    field7(event, "reviewScope") ?? ""
+  ]);
+}
+function task(event, advisory) {
+  if (advisory) return "advisory";
+  const stage = field7(event, "stage");
+  const round = field7(event, "reviewRound");
+  return ["pre-implementation", "post-implementation"].includes(String(stage)) && typeof round === "number" && Number.isSafeInteger(round) && round > 0 ? `${stage} / round ${round}` : "specialist work (task unknown)";
+}
+function projectSpecialistActivity(input2) {
+  const observations = [];
+  const starts = /* @__PURE__ */ new Map();
+  const invocationEvents = /* @__PURE__ */ new Map();
+  const ended = new Set(input2.endedScopes ?? []);
+  for (const event of input2.events) {
+    if (event.kind === "mission.closed") ended.add(event.missionId);
+    const advisory = event.kind === "usage.advisory.started" && event.source === "coordinator-observed";
+    if (!advisory && !["specialist.started", "specialist.completed", "specialist.failed"].includes(event.kind)) continue;
+    const specialist = /^core:([a-z0-9]+(?:-[a-z0-9]+)*)$/.exec(event.subject)?.[1];
+    if (specialist === void 0) continue;
+    const rawRuntime = advisory ? field7(event, "runtime") : /^runtime:(claude|codex)$/.exec(event.source)?.[1];
+    const runtime2 = rawRuntime === "claude" || rawRuntime === "codex" ? rawRuntime : "unknown";
+    if (advisory && runtime2 === "unknown") continue;
+    const context2 = field7(event, "contextId");
+    const nativeContextId = validNativeContextId(context2) ? context2 : "unknown";
+    const dispatch2 = advisory ? void 0 : dispatchIdentity(event);
+    const key = dispatch2 !== void 0 && nativeContextId !== "unknown" ? canonicalJsonHash([dispatch2, nativeContextId]) : void 0;
+    const reference2 = field7(event, "reviewInvocationEventId");
+    const referenced = typeof reference2 === "string" ? invocationEvents.get(`${event.missionId}:${reference2}`) : void 0;
+    const previous = reference2 !== void 0 ? referenced !== void 0 && referenced.dispatch === dispatch2 && (nativeContextId === "unknown" || referenced.row.nativeContextId === nativeContextId) ? referenced : void 0 : key === void 0 ? void 0 : starts.get(key);
+    const terminal = event.kind === "specialist.completed" ? "completed" : event.kind === "specialist.failed" ? "failed" : void 0;
+    if (terminal !== void 0 && previous?.started && dispatch2 !== void 0 && runtime2 !== "unknown") {
+      previous.row = {
+        ...previous.row,
+        observedState: terminal,
+        outcome: terminal,
+        lastEventId: event.eventId,
+        lastObservedAt: event.ts
+      };
+      continue;
+    }
+    const started = !advisory && event.kind === "specialist.started";
+    const reason2 = advisory ? "start observed; no advisory completion telemetry" : terminal !== void 0 ? "terminal without matching start" : dispatch2 === void 0 || runtime2 === "unknown" ? "dispatch metadata unavailable" : void 0;
+    const observation3 = { started, ...dispatch2 === void 0 ? {} : { dispatch: dispatch2 }, row: {
+      kind: advisory ? "advisory" : "specialist",
+      specialist,
+      sourceMissionId: event.missionId,
+      attribution: event.missionId === input2.missionId ? "mission" : "shared-session",
+      runtime: runtime2,
+      nativeContextId,
+      task: task(event, advisory),
+      observedState: reason2 === void 0 ? "running" : "unknown",
+      provenance: advisory ? "coordinator-observed" : "runtime-receipt",
+      lastEventId: event.eventId,
+      lastObservedAt: event.ts,
+      ...terminal === void 0 ? {} : { outcome: terminal },
+      ...reason2 === void 0 ? {} : { reason: reason2 }
+    } };
+    observations.push(observation3);
+    if (started) {
+      invocationEvents.set(`${event.missionId}:${event.eventId}`, observation3);
+      if (key !== void 0) starts.set(key, observation3);
+    }
+  }
+  const activity = observations.slice(0, MAX_ACTIVITY_ROWS).map(({ row: row2 }) => {
+    if (row2.observedState !== "running") return row2;
+    const reason2 = input2.incomplete ? "journal incomplete" : ended.has(input2.missionId) || ended.has(row2.sourceMissionId) ? "observation ended without a terminal receipt" : void 0;
+    return reason2 === void 0 ? row2 : { ...row2, observedState: "unknown", reason: reason2 };
+  });
+  return { activity, activityOmitted: Math.max(0, observations.length - activity.length) };
+}
+var cell = (value) => value.replace(/[\\|[\]`<>]/g, "\\$&");
+function renderSpecialistActivity(report) {
+  if (report.activity.length === 0) return ["Specialist activity unknown: no linked execution observations."];
+  const visible = report.activity.slice(0, MAX_TEXT_ROWS);
+  const omitted = report.activityOmitted + report.activity.length - visible.length;
+  return [
+    "Specialist activity (last recorded observation, not live presence)",
+    "| Kind / provenance | Specialist | Task | Observed state | Native identity | Source scope |",
+    "| --- | --- | --- | --- | --- | --- |",
+    ...visible.map((row2) => `| ${row2.kind} / ${row2.provenance} | ${row2.specialist} | ${cell(row2.task)} | ${row2.observedState}${row2.reason === void 0 ? "" : ` (${row2.reason})`} | ${row2.runtime}:${cell(row2.nativeContextId)} | ${row2.attribution}:${cell(row2.sourceMissionId)} |`),
+    ...omitted > 0 ? [`${omitted} activity observation(s) omitted; JSON includes up to ${MAX_ACTIVITY_ROWS} rows.`] : []
+  ];
+}
+
+// src/lib/runs/usage.ts
+function field8(payload, key) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) return void 0;
+  const value = Object.entries(payload).find(([name]) => name === key)?.[1];
+  return typeof value === "string" ? value : void 0;
+}
+function observation2(event) {
+  if (event.subject.startsWith("skill:") && event.source === "runtime:claude") {
+    if (event.kind === "runtime.tool.started" && field8(event.payload, "category") === "skill") {
+      return { type: "skill", hit: true };
+    }
+    if (event.kind === "runtime.tool.completed") {
+      return { type: "skill", hit: false, outcome: field8(event.payload, "status") ?? "unknown" };
+    }
+  }
+  if (event.subject.startsWith("hook:") && event.kind === "hook.completed") {
+    return { type: "hook", hit: true, outcome: field8(event.payload, "status") ?? "unknown" };
+  }
+  if (event.kind === "usage.advisory.started" && event.source === "coordinator-observed" && event.subject.startsWith("core:") && ["claude", "codex"].includes(field8(event.payload, "runtime") ?? "")) {
+    return { type: "advisory", hit: true };
+  }
+  if (event.subject.startsWith("core:") && event.kind === "specialist.started") {
+    return { type: "specialist", hit: true };
+  }
+  if (event.subject.startsWith("core:") && ["specialist.completed", "specialist.failed"].includes(event.kind)) {
+    return { type: "specialist", hit: false, outcome: event.kind.slice("specialist.".length) };
+  }
+  return void 0;
+}
+function projectMissionUsage(input2) {
+  const rows = /* @__PURE__ */ new Map();
+  for (const entry of input2.catalog) {
+    if (entry.type !== "skill" && entry.type !== "hook" && entry.type !== "specialist") continue;
+    rows.set(`${entry.type}:${entry.name}`, {
+      type: entry.type,
+      name: entry.name,
+      catalogued: true,
+      observedHits: 0,
+      outcomes: {},
+      runtimeHits: {}
+    });
+  }
+  const channels = /* @__PURE__ */ new Set();
+  const seen = /* @__PURE__ */ new Set();
+  const runtimeChannels = /* @__PURE__ */ new Set();
+  const scopes = [{ missionId: input2.missionId, events: input2.events }, ...input2.linkedScopes ?? []];
+  const events = scopes.flatMap((scope) => scope.events.filter((item) => item.missionId === scope.missionId)).filter((event) => {
+    const identity2 = `${event.missionId}:${event.eventId}`;
+    if (seen.has(identity2)) return false;
+    seen.add(identity2);
+    return true;
+  });
+  for (const event of events) {
+    const observed2 = observation2(event);
+    if (observed2 === void 0) continue;
+    const rawName = event.subject.slice(event.subject.indexOf(":") + 1);
+    const name = observed2.type === "skill" ? activationName("skill", rawName.startsWith("core/") ? rawName.slice(5) : rawName) : input2.hookSubjects[event.subject] ?? rawName;
+    if (!/^[a-zA-Z0-9]+(?:[-:/][a-zA-Z0-9]+)*$/.test(name)) continue;
+    const runtime2 = observed2.type === "advisory" ? field8(event.payload, "runtime") ?? "unknown" : /^runtime:(claude|codex|unknown)$/.test(event.source) ? event.source.slice("runtime:".length) : "unattributed";
+    runtimeChannels.add(`${observed2.type}:${runtime2}`);
+    channels.add(observed2.type);
+    const key = `${observed2.type}:${name}`;
+    const row2 = rows.get(key) ?? {
+      type: observed2.type,
+      name,
+      catalogued: observed2.type === "advisory" && input2.catalog.some((entry) => entry.type === "specialist" && entry.name === name),
+      observedHits: 0,
+      outcomes: {},
+      runtimeHits: {}
+    };
+    if (observed2.hit) {
+      row2.observedHits += 1;
+      row2.runtimeHits[runtime2] = (row2.runtimeHits[runtime2] ?? 0) + 1;
+    }
+    if (observed2.outcome !== void 0) {
+      const outcome = ["ok", "error", "skipped", "degraded", "blocked", "completed", "failed"].includes(observed2.outcome) ? observed2.outcome : "unknown";
+      row2.outcomes[outcome] = (row2.outcomes[outcome] ?? 0) + 1;
+    }
+    rows.set(key, row2);
+  }
+  return {
+    missionId: input2.missionId,
+    ...projectSpecialistActivity({
+      missionId: input2.missionId,
+      events,
+      ...input2.endedScopes === void 0 ? {} : { endedScopes: input2.endedScopes },
+      ...input2.incomplete === void 0 ? {} : { incomplete: input2.incomplete }
+    }),
+    rows: [...rows.values()].map((row2) => ({
+      ...row2,
+      observedHits: channels.has(row2.type) ? row2.observedHits : "unknown",
+      runtimeHits: Object.fromEntries([.../* @__PURE__ */ new Set(["claude", "codex", ...Object.keys(row2.runtimeHits)])].map((runtime2) => [runtime2, runtimeChannels.has(`${row2.type}:${runtime2}`) ? row2.runtimeHits[runtime2] ?? 0 : "unknown"]))
+    })).sort((a, b2) => `${a.type}:${a.name}`.localeCompare(`${b2.type}:${b2.name}`, "en")),
+    notes: [
+      ...!channels.has("hook") && !channels.has("skill") ? ["hook/skill telemetry not linked to this mission."] : [],
+      ...["skill", "hook", "specialist", "advisory"].filter((kind2) => !channels.has(kind2)).map((kind2) => `${kind2}: unknown; no linked execution telemetry.`),
+      "Hits are observed lower bounds. Zero means no recorded hit, not proof of non-use; gaps remain possible.",
+      "Codex SKILL.md reads are loads, not observable native skill invocations; no skill hits are inferred from them.",
+      ...channels.has("advisory") ? ["Advisory starts are coordinator-observed declarations, separate from formal specialist dispatch; no completion or verdict claimed."] : [],
+      "Counts do not prove applicability, instruction compliance, TDD or code quality. Missing telemetry is not a delivery gate."
+    ]
+  };
+}
+function renderMissionUsage(report) {
+  const observed2 = report.rows.filter((row2) => typeof row2.observedHits === "number" && row2.observedHits > 0 || Object.keys(row2.outcomes).length > 0);
+  return [
+    ...renderSpecialistActivity(report),
+    "",
+    "Usage recap (explicit mission linkage only)",
+    ...report.notes.map((note) => `- ${note}`),
+    ...["skill", "hook", "specialist", "advisory"].map((kind2) => {
+      const rows = report.rows.filter((row2) => row2.type === kind2);
+      return `${kind2}: ${rows.filter((row2) => row2.observedHits === 0).length} zero observed, ${rows.filter((row2) => row2.observedHits === "unknown").length} unknown catalogue entries.`;
+    }),
+    ...observed2.length === 0 ? ["No linked execution observations. Full inventory: void-machine cheatsheet --format markdown."] : [
+      "| Kind | Name | Observed hits | Outcomes | Telemetry |",
+      "| --- | --- | --- | --- | --- |",
+      ...observed2.map((row2) => `| ${row2.type} | ${row2.name} | ${row2.observedHits} | ${Object.entries(row2.outcomes).map(([status3, count]) => `${status3}=${count}`).join(", ") || "-"} | ${Object.entries(row2.runtimeHits).map(([runtime2, hits]) => `${runtime2}=${hits}`).join(", ")}${row2.catalogued ? "" : "; outside current catalogue"} |`)
+    ]
+  ].join("\n");
+}
+
+// src/lib/runs/usage-report.ts
+async function loadMissionUsage(root, missionId, stream2) {
+  const core = await findCoreSource();
+  const catalog = await loadCatalog(core);
+  const hookSubjects = {};
+  for (const entry of catalog.filter((item) => item.type === "hook")) {
+    const command2 = hookRunnerCommand(await requireData(core, `hooks/${entry.name}.sh`, 64 * 1024));
+    if (command2 !== void 0) hookSubjects[`hook:${command2.split(" ").at(-1)}`] = entry.name;
+  }
+  const linked = await readUsageSessions(root, missionId, stream2.events);
+  const incomplete = stream2.continuity !== "complete" || stream2.events.some((event) => event.missionId !== missionId);
+  const report = projectMissionUsage({
+    missionId,
+    events: stream2.events,
+    catalog,
+    hookSubjects,
+    linkedScopes: linked.scopes,
+    incomplete,
+    endedScopes: linked.links.filter((link3) => link3.status !== "open").map((link3) => link3.sourceMissionId)
+  });
+  const notes = [...linked.notes, ...report.notes];
+  if (incomplete) {
+    notes.unshift("Journal incomplete or mixed: counts cover readable linked events only, never complete usage.");
+  }
+  try {
+    const stored = await loadMissionControllerPlan(root, missionId);
+    const bound = stream2.events.some((event) => event.missionId === missionId && event.kind === "mission.started" && event.payload && typeof event.payload === "object" && !Array.isArray(event.payload) && Object.entries(event.payload).some(([key, value]) => key === "routingHash" && value === stored.routingHash));
+    notes.unshift(bound ? `Ticket binding: ${JSON.stringify(stored.ticket.path)} (${stored.ticket.contentHash}).` : "Ticket binding unverified; scope is this mission journal, not a proven ticket.");
+  } catch {
+    notes.unshift("Ticket binding unavailable; scope is this mission/session journal, not a proven ticket.");
+  }
+  return { ...report, notes, links: linked.links };
+}
+
 // src/lib/runs/inspect-current.ts
 init_esm_shims();
-async function inspectCurrentMission(roots, missionId, secrets) {
+async function inspectCurrentMission(roots, missionId, secrets, options2 = {}) {
   for (let attempt = 0; attempt < 2; attempt += 1) {
     const before = await computeProjectState2(roots.workRoot);
     const inspected = await inspectMission(
       roots.installRoot,
       missionId,
       { dependencies: { "git:working-tree": before.diffHash } },
-      { secrets }
+      { secrets, ...options2 }
     );
     const after = await computeProjectState2(roots.workRoot);
     if (before.diffHash === after.diffHash) {
@@ -67185,9 +67857,9 @@ async function inspectCurrentMission(roots, missionId, secrets) {
 
 // src/lib/runs/mission-recovery.ts
 init_esm_shims();
-async function recordStoppedMissionRecovery(root, missionId, request, observation2) {
+async function recordStoppedMissionRecovery(root, missionId, request, observation3) {
   const inspected = await inspectMission(root, missionId, { dependencies: {} });
-  const decision = planStoppedMissionRecovery({ stream: inspected.stream, request, observation: observation2 });
+  const decision = planStoppedMissionRecovery({ stream: inspected.stream, request, observation: observation3 });
   if (decision.kind === "refused") {
     throw new Error(`MISSION_RECOVERY_REFUSED: ${decision.code}: ${decision.reasons.join("; ")}`);
   }
@@ -67259,7 +67931,7 @@ function parseMissionRecoveryRequest(value) {
   };
   if (disposition["kind"] === "controller-defect") {
     const defect = disposition["defect"];
-    if (!exact2(disposition, ["kind", "defect"]) || defect !== "partial-fanout-round" && defect !== "stale-input-dispatch" && defect !== "opaque-native-context") invalid11();
+    if (!exact2(disposition, ["kind", "defect"]) || defect !== "partial-fanout-round" && defect !== "stale-input-dispatch" && defect !== "opaque-native-context" && defect !== "targeted-review-context") invalid11();
     return { ...base, disposition: { kind: "controller-defect", defect } };
   }
   if (disposition["kind"] === "evidence-disposition") {
@@ -67383,15 +68055,15 @@ async function observeSpecialistMigrationAssets(coreRoot, installRoot, runtime2)
     nativeContractVersion: target.version
   };
 }
-async function recordSpecialistContractMigration(root, missionId, request, observation2) {
+async function recordSpecialistContractMigration(root, missionId, request, observation3) {
   const [inspected, stored] = await Promise.all([
     inspectMission(root, missionId, { dependencies: {} }),
     loadMissionControllerPlan(root, missionId)
   ]);
-  if (canonicalJsonHash(stored.plan) !== canonicalJsonHash(observation2.plan)) {
+  if (canonicalJsonHash(stored.plan) !== canonicalJsonHash(observation3.plan)) {
     invalid12("migration observation does not match the immutable controller plan");
   }
-  const decision = planSpecialistContractMigration({ stream: inspected.stream, request, observation: observation2 });
+  const decision = planSpecialistContractMigration({ stream: inspected.stream, request, observation: observation3 });
   if (decision.kind === "refused") {
     const code2 = decision.code === "stale-migration" && canonicalJsonHash(inspected.stream.events) !== request.expectedJournalHash ? "stale-journal" : decision.code;
     throw new Error(`SPECIALIST_CONTRACT_MIGRATION_REFUSED: ${code2}: ${decision.reasons.join("; ")}`);
@@ -67451,7 +68123,7 @@ init_esm_shims();
 function record25(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function field7(value, key) {
+function field9(value, key) {
   return record25(value) ? value[key] : void 0;
 }
 function invalid13(detail) {
@@ -67459,12 +68131,12 @@ function invalid13(detail) {
 }
 function identity(events) {
   const start = events.find((event) => event.kind === "mission.started");
-  const runtime2 = start ? field7(start.payload, "runtime") : void 0;
-  if (!start || field7(start.payload, "runtimeAttested") !== true || runtime2 !== "codex" && runtime2 !== "claude") invalid13("native mission runtime is not attested");
+  const runtime2 = start ? field9(start.payload, "runtime") : void 0;
+  if (!start || field9(start.payload, "runtimeAttested") !== true || runtime2 !== "codex" && runtime2 !== "claude") invalid13("native mission runtime is not attested");
   return runtime2 === "codex" ? "runtime:codex" : "runtime:claude";
 }
 function freshContext(events, contextId) {
-  if (!validNativeContextId(contextId) || events.some((event) => field7(event.payload, "contextId") === contextId || field7(event.payload, "nativeContextId") === contextId)) invalid13("provide a fresh native author context");
+  if (!validNativeContextId(contextId) || events.some((event) => field9(event.payload, "contextId") === contextId || field9(event.payload, "nativeContextId") === contextId)) invalid13("provide a fresh native author context");
 }
 function eventId2(value) {
   return `evt_${createHash("sha256").update(canonicalJsonHash(value)).digest("hex")}`;
@@ -67484,9 +68156,9 @@ async function requestSpecialistEvidence(roots, missionId, input2) {
   requireOpenMission(events);
   const source2 = identity(events);
   const original = events.find((event) => event.eventId === input2.completionEventId);
-  const completion = original ? parseSpecialistCompletionValue(field7(original.payload, "completion")) : void 0;
+  const completion = original ? parseSpecialistCompletionValue(field9(original.payload, "completion")) : void 0;
   if (!original || original.kind !== "specialist.completed" || !completion || original.source !== source2 || original.subject !== completion.specialistId || completion.evidenceRequests.length === 0) invalid13("original author completion with evidence requests is required");
-  const requestId = eventId2({ missionId, ...input2, completionHash: canonicalJsonHash(field7(original.payload, "completion")) });
+  const requestId = eventId2({ missionId, ...input2, completionHash: canonicalJsonHash(field9(original.payload, "completion")) });
   const existing = events.find((event) => event.eventId === requestId);
   if (existing) return existing;
   freshContext(events, input2.contextId);
@@ -67502,7 +68174,7 @@ async function requestSpecialistEvidence(roots, missionId, input2) {
     correlationId: missionId,
     payload: {
       completionEventId: original.eventId,
-      completionHash: canonicalJsonHash(field7(original.payload, "completion")),
+      completionHash: canonicalJsonHash(field9(original.payload, "completion")),
       specialistId: completion.specialistId,
       nativeContextId: input2.contextId,
       requestId,
@@ -67524,7 +68196,7 @@ async function requestSpecialistEvidence(roots, missionId, input2) {
 }
 function exactRequest(events, input2) {
   const request = events.find((event) => event.eventId === input2.requestEventId);
-  if (!request || request.source !== "void-harness:mission.dispatch" || !["specialist.evidence-classification-requested", "specialist.evidence-discharge-requested"].includes(request.kind) || field7(request.payload, "nativeContextId") !== input2.contextId || !record25(request.payload)) {
+  if (!request || request.source !== "void-harness:mission.dispatch" || !["specialist.evidence-classification-requested", "specialist.evidence-discharge-requested"].includes(request.kind) || field9(request.payload, "nativeContextId") !== input2.contextId || !record25(request.payload)) {
     invalid13("response must match its controller request and native context");
   }
   return request;
@@ -67532,7 +68204,7 @@ function exactRequest(events, input2) {
 async function validateCompletion(events, candidate, roots, expectedSource) {
   const proofs = events.flatMap((event) => {
     if (event.kind !== "evidence.recorded") return [];
-    const parsed = parseEvidence(field7(event.payload, "evidence"));
+    const parsed = parseEvidence(field9(event.payload, "evidence"));
     return parsed.ok ? [{ eventId: event.eventId, evidence: parsed.value }] : [];
   });
   const discharge2 = candidate.kind === "specialist.evidence-discharged";
@@ -67546,7 +68218,7 @@ async function validateCompletion(events, candidate, roots, expectedSource) {
   });
   if (state.issues.length > 0) invalid13(state.issues.map((value) => value.detail).join("; "));
   if (discharge2) {
-    const items = field7(candidate.payload, "items");
+    const items = field9(candidate.payload, "items");
     if (!Array.isArray(items) || items.some((item) => !record25(item) || !state.obligations.some((value) => value.obligationId === item["obligationId"] && value.discharged))) {
       invalid13(`requested obligations need fresh successful canonical proofs; observed git:working-tree ${dependencies["git:working-tree"]} at ${roots.workRoot}; run from the proof worktree and inspect its commit/diff binding`);
     }
@@ -67590,7 +68262,7 @@ async function recordSpecialistEvidence(roots, missionId, status3, input2) {
       requireResponseAdmission(current, status3, input2);
       exactRequest(current, input2);
       if (status3 === "completed") {
-        const started = current.find((event) => event.kind === "specialist.evidence-started" && event.source === source2 && event.subject === request.subject && event.causationId === request.eventId && field7(event.payload, "nativeContextId") === input2.contextId);
+        const started = current.find((event) => event.kind === "specialist.evidence-started" && event.source === source2 && event.subject === request.subject && event.causationId === request.eventId && field9(event.payload, "nativeContextId") === input2.contextId);
         if (!started) invalid13("author response needs its observed native started receipt");
         await validateCompletion(current, {
           schemaVersion: 1,
@@ -67662,7 +68334,7 @@ function parseSpecialistEvidenceResponse(status3, value) {
 
 // src/lib/runs/specialist-lifecycle.ts
 init_esm_shims();
-var MISSION_ID10 = /^mis_[A-Za-z0-9_-]{8,100}$/;
+var MISSION_ID11 = /^mis_[A-Za-z0-9_-]{8,100}$/;
 var SPECIALIST_ID4 = /^core:[a-z0-9]+(?:-[a-z0-9]+)*$/;
 var AGENT_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 var HASH7 = /^sha256:[a-f0-9]{64}$/;
@@ -67698,7 +68370,7 @@ function parseEnvelope2(value) {
     ...ENVELOPE_KEYS,
     ...value["reviewSubject"] === void 0 ? [] : ["reviewSubject"],
     ...value["reviewScope"] === void 0 ? [] : ["reviewScope"]
-  ]) || value["reviewSubject"] !== void 0 && !isReviewSubject(value["reviewSubject"]) || value["reviewScope"] !== void 0 && !isReviewScope(value["reviewScope"]) || value.schemaVersion !== 1 || typeof value.missionId !== "string" || !MISSION_ID10.test(value.missionId) || value.runtime !== "claude" && value.runtime !== "codex" || !isSpecialistId(value.specialistId) || typeof value.agentName !== "string" || !AGENT_NAME.test(value.agentName) || value.agentName !== value.specialistId.slice("core:".length) || !Number.isSafeInteger(value.contractVersion) || Number(value.contractVersion) < 1 || Number(value.contractVersion) > 1e4 || value.stage !== "pre-implementation" && value.stage !== "post-implementation" || !Number.isSafeInteger(value.reviewRound) || Number(value.reviewRound) < 1 || Number(value.reviewRound) > 8 || typeof value.inputHash !== "string" || !HASH7.test(value.inputHash)) {
+  ]) || value["reviewSubject"] !== void 0 && !isReviewSubject(value["reviewSubject"]) || value["reviewScope"] !== void 0 && !isReviewScope(value["reviewScope"]) || value.schemaVersion !== 1 || typeof value.missionId !== "string" || !MISSION_ID11.test(value.missionId) || value.runtime !== "claude" && value.runtime !== "codex" || !isSpecialistId(value.specialistId) || typeof value.agentName !== "string" || !AGENT_NAME.test(value.agentName) || value.agentName !== value.specialistId.slice("core:".length) || !Number.isSafeInteger(value.contractVersion) || Number(value.contractVersion) < 1 || Number(value.contractVersion) > 1e4 || value.stage !== "pre-implementation" && value.stage !== "post-implementation" || !Number.isSafeInteger(value.reviewRound) || Number(value.reviewRound) < 1 || Number(value.reviewRound) > 8 || typeof value.inputHash !== "string" || !HASH7.test(value.inputHash)) {
     invalid14("dispatch envelope is malformed");
   }
   const contextPack = parseContextPackValue(value.contextPack, {
@@ -67844,7 +68516,7 @@ async function recordSpecialistLifecycle(root, missionId, input2, artifactRoot =
   if (lifecycle.status === "closed") invalid14("mission is closed");
   await rejectSupersededSpecialistContract(root, missionId, events, input2.envelope, input2.contextId);
   const recovery = events.filter((event) => event.kind === "mission.recovered").at(-1);
-  const requested = events.filter((event) => event.kind === "specialist.requested" && (recovery === void 0 || event.seq > recovery.seq) && sameDispatch(event, input2.envelope) && field8(event.payload, "runtime") === input2.envelope.runtime).at(-1);
+  const requested = events.filter((event) => event.kind === "specialist.requested" && (recovery === void 0 || event.seq > recovery.seq) && sameDispatch(event, input2.envelope) && field10(event.payload, "runtime") === input2.envelope.runtime).at(-1);
   if (requested === void 0) invalid14("no matching specialist.requested event exists");
   const invocationId = await checkedReviewArtifact(artifactRoot, input2, events, requested);
   if (invocationId !== void 0 && input2.status === "completed") {
@@ -67868,17 +68540,17 @@ async function recordSpecialistLifecycle(root, missionId, input2, artifactRoot =
   if (input2.status === "started") {
     const existing = starts.at(-1);
     if (existing !== void 0) {
-      if (field8(existing.payload, "contextId") === input2.contextId && field8(existing.payload, "reviewerId") === input2.reviewerId) return;
-      const failed2 = input2.envelope.reviewSubject !== void 0 && dispatchEvents.some((event) => event.kind === "specialist.failed" && event.seq > existing.seq && sameDispatch(event, input2.envelope) && field8(event.payload, "contextId") === field8(existing.payload, "contextId"));
+      if (field10(existing.payload, "contextId") === input2.contextId && field10(existing.payload, "reviewerId") === input2.reviewerId) return;
+      const failed2 = input2.envelope.reviewSubject !== void 0 && dispatchEvents.some((event) => event.kind === "specialist.failed" && event.seq > existing.seq && sameDispatch(event, input2.envelope) && field10(event.payload, "contextId") === field10(existing.payload, "contextId"));
       if (!failed2) invalid14("dispatch already started with another contextId");
     }
-    if (recovery !== void 0 && input2.contextId !== void 0 && events.some((event) => event.kind === "specialist.started" && field8(event.payload, "contextId") === input2.contextId)) {
+    if (recovery !== void 0 && input2.contextId !== void 0 && events.some((event) => event.kind === "specialist.started" && field10(event.payload, "contextId") === input2.contextId) && !canContinueNativeReview(events, requested, input2.contextId)) {
       invalid14("contextId was already used by a previous dispatch");
     }
   } else {
-    const started = starts.find((event) => input2.contextId === void 0 ? event.eventId === invocationId : field8(event.payload, "contextId") === input2.contextId);
+    const started = starts.find((event) => input2.contextId === void 0 ? event.eventId === invocationId : field10(event.payload, "contextId") === input2.contextId);
     if (started === void 0) invalid14("no matching independent invocation specialist.started event exists");
-    const terminal = dispatchEvents.find((event) => sameDispatch(event, input2.envelope) && (event.kind === "specialist.completed" || event.kind === "specialist.failed" && (input2.envelope.reviewSubject === void 0 || field8(event.payload, "contextId") === input2.contextId)));
+    const terminal = dispatchEvents.find((event) => sameDispatch(event, input2.envelope) && (event.kind === "specialist.completed" || event.kind === "specialist.failed" && (input2.envelope.reviewSubject === void 0 || field10(event.payload, "contextId") === input2.contextId)));
     if (terminal !== void 0) {
       if (sameDraft2(terminal, draft)) return;
       if (input2.envelope.reviewSubject === void 0 || terminal.kind === "specialist.completed" || input2.status !== "completed") invalid14("dispatch already has a different terminal event");
@@ -67904,7 +68576,7 @@ async function recordSpecialistLifecycle(root, missionId, input2, artifactRoot =
       if (observedMissionLifecycle(current).episodeId !== lifecycle.episodeId) {
         invalid14("mission episode changed before recording lifecycle");
       }
-      if (recovery !== void 0 && input2.status === "started" && input2.contextId !== void 0 && current.some((event) => event.kind === "specialist.started" && field8(event.payload, "contextId") === input2.contextId && event.eventId !== eventId3)) {
+      if (recovery !== void 0 && input2.status === "started" && input2.contextId !== void 0 && current.some((event) => event.kind === "specialist.started" && field10(event.payload, "contextId") === input2.contextId && event.eventId !== eventId3) && !canContinueNativeReview(current, requested, input2.contextId)) {
         invalid14("contextId was already used by a previous dispatch");
       }
     }
@@ -67918,7 +68590,7 @@ async function checkedReviewArtifact(root, input2, events, requested) {
   const review = input2.completion.review;
   const provenance4 = review.provenance;
   if (provenance4.kind !== "review-artifact") return void 0;
-  const invocation = events.find((event) => event.kind === "specialist.started" && event.source === `runtime:${input2.envelope.runtime}` && event.seq > requested.seq && sameDispatch(event, input2.envelope) && (field8(event.payload, "reviewerId") === review.reviewerId || input2.contextId !== void 0 && field8(event.payload, "contextId") === input2.contextId));
+  const invocation = events.find((event) => event.kind === "specialist.started" && event.source === `runtime:${input2.envelope.runtime}` && event.seq > requested.seq && sameDispatch(event, input2.envelope) && (field10(event.payload, "reviewerId") === review.reviewerId || input2.contextId !== void 0 && field10(event.payload, "contextId") === input2.contextId));
   if (invocation === void 0) invalid14("review artifact has no matching independent invocation");
   const loaded = await readBoundedProjectFile({
     root,
@@ -67953,15 +68625,15 @@ async function rejectSupersededSpecialistContract(root, missionId, events, envel
   if (envelope.contractVersion !== migration.receipt.toVersion || envelope.stage !== "post-implementation" || envelope.reviewRound !== migration.receipt.reviewRound || envelope.inputHash !== migration.receipt.targetInputHash) {
     invalid14("dispatch is superseded by the authenticated specialist contract migration");
   }
-  if (contextId !== void 0 && events.some((event) => event.seq < migration.seq && field8(event.payload, "contextId") === contextId)) {
+  if (contextId !== void 0 && events.some((event) => event.seq < migration.seq && field10(event.payload, "contextId") === contextId)) {
     invalid14("migrated specialist requires a fresh native context");
   }
 }
-function field8(value, key) {
+function field10(value, key) {
   return isRecord11(value) ? value[key] : void 0;
 }
 function sameDispatch(event, envelope) {
-  return event.missionId === envelope.missionId && event.subject === envelope.specialistId && field8(event.payload, "stage") === envelope.stage && field8(event.payload, "reviewRound") === envelope.reviewRound && field8(event.payload, "inputHash") === envelope.inputHash && field8(event.payload, "contractVersion") === envelope.contractVersion && (envelope.reviewSubject === void 0 || field8(event.payload, "reviewSubject") !== void 0 && canonicalJsonHash(field8(event.payload, "reviewSubject")) === canonicalJsonHash(envelope.reviewSubject)) && (envelope.reviewScope === void 0 || field8(event.payload, "reviewScope") !== void 0 && canonicalJsonHash(field8(event.payload, "reviewScope")) === canonicalJsonHash(envelope.reviewScope));
+  return event.missionId === envelope.missionId && event.subject === envelope.specialistId && field10(event.payload, "stage") === envelope.stage && field10(event.payload, "reviewRound") === envelope.reviewRound && field10(event.payload, "inputHash") === envelope.inputHash && field10(event.payload, "contractVersion") === envelope.contractVersion && (envelope.reviewSubject === void 0 || field10(event.payload, "reviewSubject") !== void 0 && canonicalJsonHash(field10(event.payload, "reviewSubject")) === canonicalJsonHash(envelope.reviewSubject)) && (envelope.reviewScope === void 0 || field10(event.payload, "reviewScope") !== void 0 && canonicalJsonHash(field10(event.payload, "reviewScope")) === canonicalJsonHash(envelope.reviewScope));
 }
 function sameDraft2(event, draft) {
   return event.source === draft.source && event.kind === draft.kind && event.subject === draft.subject && event.correlationId === draft.correlationId && event.causationId === draft.causationId && JSON.stringify(event.payload) === JSON.stringify(draft.payload);
@@ -68062,7 +68734,7 @@ async function recordSpecialistRequests(root, missionId, envelopes, planHash) {
 init_esm_shims();
 
 // package.json
-var version2 = "5.0.7";
+var version2 = "6.0.0";
 
 // src/lib/runs/verify.ts
 var MAX_CAPTURE_BYTES = 64 * 1024;
@@ -68189,7 +68861,7 @@ async function verifyMissionCommand(options2) {
 }
 
 // src/commands/mission.ts
-var MISSION_ID11 = /^mis_[A-Za-z0-9_-]{8,100}$/;
+var MISSION_ID12 = /^mis_[A-Za-z0-9_-]{8,100}$/;
 var MAX_TICKET_BYTES2 = 1e5;
 function coordinatorRuntimeIdentity(environment2) {
   const codex = [
@@ -68241,7 +68913,7 @@ function missionIdFrom(options2) {
   if (missionId === void 0) {
     return invalid15("missing required option --id", "pass --id mis_<opaque-id>");
   }
-  if (!MISSION_ID11.test(missionId)) {
+  if (!MISSION_ID12.test(missionId)) {
     return invalid15("invalid mission ID", "pass the ID returned by mission start");
   }
   return missionId;
@@ -68254,6 +68926,11 @@ function parseMissionArgs(args) {
     return { kind: "help" };
   }
   const command2 = divider2 === -1 ? [] : args.slice(divider2 + 1);
+  const usageCommand = parseUsageCommand(
+    { subcommand, options: options2, divider: divider2 },
+    { invalid: invalid15, valueAfter: valueAfter2, missionIdFrom, validateOptions: validateOptions2 }
+  );
+  if (usageCommand !== void 0) return usageCommand;
   if (subcommand === "evidence-request" || subcommand === "evidence-event") {
     if (divider2 !== -1) return invalid15("evidence commands do not accept a command", "remove --");
     const names = options2.filter((value) => value.startsWith("--"));
@@ -68493,7 +69170,7 @@ function parseMissionArgs(args) {
         `${PRODUCT_COMMAND} mission ${subcommand} --id <id>`
       );
     }
-    const optionError = validateOptions2(options2, ["--id"], ["--json"]);
+    const optionError = validateOptions2(options2, ["--id"], subcommand === "inspect" ? ["--json", "--usage"] : ["--json"]);
     if (optionError !== void 0) {
       return invalid15(optionError, `${PRODUCT_COMMAND} mission ${subcommand} --help`);
     }
@@ -68501,6 +69178,7 @@ function parseMissionArgs(args) {
     if (typeof missionId !== "string") return missionId;
     return {
       kind: subcommand,
+      ...subcommand === "inspect" && options2.includes("--usage") ? { usage: true } : {},
       missionId,
       json: options2.includes("--json")
     };
@@ -68633,6 +69311,7 @@ async function recoverStoppedMission(roots, missionId, request) {
   const identity2 = missionRuntimeIdentity(inspected.stream.events);
   const coordinator = coordinatorRuntimeIdentity(process.env);
   const provenanceRecovery = request.disposition.kind === "review-provenance";
+  const targetedContextRecovery = request.disposition.kind === "controller-defect" && request.disposition.defect === "targeted-review-context";
   if (identity2 === void 0 || coordinator.attested && coordinator.runtime !== identity2.runtime || !provenanceRecovery && (!identity2.attested || !coordinator.attested)) {
     throw new Error("MISSION_RECOVERY_RUNTIME: observe the original native runtime before recovery");
   }
@@ -68686,10 +69365,10 @@ async function recoverStoppedMission(roots, missionId, request) {
   const provenance4 = request.disposition.kind !== "review-provenance" ? void 0 : await readRecoveryReviewBindings(workRoot, request.disposition.resolutionArtifact.path);
   const resolutionArtifact = provenance4?.artifact ?? (request.disposition.kind === "review-blocker" || request.disposition.kind === "command-correction" ? await recoveryResolutionArtifact(workRoot, request.disposition.resolutionArtifact.path) : void 0);
   const opaqueContextRecovery = request.disposition.kind === "controller-defect" && request.disposition.defect === "opaque-native-context";
-  const recoverySpecialists = opaqueContextRecovery || request.disposition.kind === "preparation-invocation" ? migration.plan.specialists.filter((value) => value.state === "applicable" && value.stages?.includes("pre-implementation")) : migration.plan.specialists;
-  const observation2 = {
-    ...provenance4 === void 0 || subject?.baseCommit === void 0 || subject.reviewedCommit === void 0 ? {} : {
-      reviewBindings: provenance4.bindings,
+  const recoverySpecialists = targetedContextRecovery ? migration.plan.specialists.filter((value) => value.specialistId === "core:independent-code-reviewer") : opaqueContextRecovery || request.disposition.kind === "preparation-invocation" ? migration.plan.specialists.filter((value) => value.state === "applicable" && value.stages?.includes("pre-implementation")) : migration.plan.specialists;
+  const observation3 = {
+    ...provenance4 === void 0 && !targetedContextRecovery || subject?.baseCommit === void 0 || subject.reviewedCommit === void 0 ? {} : {
+      ...provenance4 === void 0 ? {} : { reviewBindings: provenance4.bindings },
       reviewSubject: {
         taskId: missionId,
         baseCommit: subject.baseCommit,
@@ -68706,7 +69385,7 @@ async function recoverStoppedMission(roots, missionId, request) {
     contractVersions: Object.fromEntries(recoverySpecialists.map((value) => [value.specialistId, value.contractVersion])),
     ...resolutionArtifact === void 0 ? {} : { resolutionArtifact }
   };
-  const result = await recordStoppedMissionRecovery(installRoot, missionId, request, observation2);
+  const result = await recordStoppedMissionRecovery(installRoot, missionId, request, observation3);
   return { ...result, provenance: {
     coreRoot,
     catalogHash: canonicalJsonHash(catalog),
@@ -69101,7 +69780,10 @@ function usage() {
   mission close --id <id> --reason interrupted|abandoned [--json]
   mission verify --id <id> [--shell] [--json] -- <command...>
   mission resume --id <id> [--json]
-  mission inspect --id <id> [--json]
+  mission inspect --id <id> [--usage] [--json]
+  mission usage-bind --id <id> --source <session-journal-id> [--json]
+  mission usage-unbind --id <id> --source <session-journal-id> [--json]
+  mission advisory-start --id <id> --specialist core:<role> --runtime claude|codex --context <native-id> [--json]
   mission archive --id <id> [--json]
   mission prune --older-than <days> [--apply] [--json]
 
@@ -69159,6 +69841,10 @@ Fix: ${parsed.fix}
   const root = roots.workRoot;
   const journal = roots.installRoot;
   try {
+    if (parsed.kind === "usage-bind" || parsed.kind === "usage-unbind" || parsed.kind === "advisory-start") {
+      process.stdout.write(await runUsageCommand(parsed, journal));
+      return;
+    }
     if (parsed.kind === "plan") {
       const plan2 = await planMission(root, parsed.ticketPath, void 0, "project-v1");
       process.stdout.write(parsed.json ? `${JSON.stringify(plan2)}
@@ -69337,11 +70023,15 @@ ${selection.promotion === void 0 ? "" : `mode ${selection.requestedMode} -> ${se
       const { inspected } = await inspectCurrentMission(
         roots,
         parsed.missionId,
-        collectKnownSecrets()
+        collectKnownSecrets(),
+        parsed.usage ? { quarantine: false } : {}
       );
+      const usageReport = parsed.usage ? await loadMissionUsage(roots.installRoot, parsed.missionId, inspected.stream) : void 0;
       process.stdout.write(
-        parsed.json ? `${JSON.stringify(inspected.verdict)}
-` : `${renderInspection(inspected)}
+        parsed.json ? `${JSON.stringify(usageReport === void 0 ? inspected.verdict : { ...inspected.verdict, usage: usageReport })}
+` : `${renderInspection(inspected)}${usageReport === void 0 ? "" : `
+
+${renderMissionUsage(usageReport)}`}
 `
       );
       process.exitCode = missionVerdictExitCode(inspected.verdict.status);
@@ -69854,14 +70544,14 @@ function fromZap(payload) {
     const alerts = Array.isArray(site["alerts"]) ? site["alerts"] : [];
     for (const alert of alerts) {
       const name = text6(alert["name"], "unnamed alert");
-      const reference = text6(alert["alertRef"], "unknown");
+      const reference2 = text6(alert["alertRef"], "unknown");
       findings.push({
         adapter: "zap-baseline",
         securityClass: "misconfiguration",
         reportedSeverity: ZAP_SEVERITY[text6(alert["riskcode"], "0")] ?? "info",
-        rule: reference,
+        rule: reference2,
         summary: `${name}${host === "" ? "" : ` on ${host}`}`,
-        reproduction: `zap-baseline raised alert ${reference} (${name})${host === "" ? "" : ` against ${host}`}`,
+        reproduction: `zap-baseline raised alert ${reference2} (${name})${host === "" ? "" : ` against ${host}`}`,
         remediation: text6(alert["solution"], "Read the ZAP alert reference and fix the response the scan describes.")
       });
     }