voidmachine 5.0.6 → 5.0.8

package/core-assets/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "harness",
-  "version": "5.0.6",
+  "version": "5.0.8",
   "description": "VoidCorp universal craftsman skills (void-tdd, void-typescript-strict, void-hexagonal-architecture, void-domain-driven-design, void-functional, void-code-review, void-api-and-interface-design, void-source-driven-development, void-context, void-learn, void-decide, void-claude-md, void-observability, void-security-guidance, ...) plus 12 PreToolUse enforcement hooks (tdd-guard, no-any, protect-sensitive-files, block-dangerous-bash, no-ai-design-slop, ...) and PostToolUse/SessionStart lifecycle hooks (incl. trim-large-output token frugality), five read-only critics including doctrine-critic, native architecture/security/QA specialists, and the void-graph, void-doctor and void-audit gestures, which are skills like everything else.",
   "author": {
     "name": "VoidCorp",

package/core-assets/data/catalog.v3.json

@@ -5,7 +5,7 @@
   "source": {
     "kind": "adapter",
     "version": "3.0.0-alpha.1",
-    "rootHash": "sha256:e38546e5aa7fcb09bddd3c33954b340026d7d92ae9d74b0272191043b98cd706"
+    "rootHash": "sha256:7a824dcd695bae061ba5ee2b9e797032682dd8ace6a2957015c8a1949248d5d7"
   },
   "nodes": [
     {
@@ -4331,7 +4331,7 @@
             }
           ],
           "id": "skill:void-implement",
-          "lines": 192,
+          "lines": 193,
           "name": "void-implement",
           "owner": "folpe",
           "pack": null,
@@ -4340,7 +4340,7 @@
             "codex"
           ],
           "source": "packages/core/skills/void-implement/SKILL.md",
-          "staticTokens": 5800,
+          "staticTokens": 5864,
           "type": "skill"
         }
       },

package/core-assets/data/certification.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "harnessVersion": "5.0.6",
+  "harnessVersion": "5.0.8",
   "capabilities": [
     {
       "id": "skill:pack-mobile/void-eas-build-profile",

package/core-assets/data/model.json

@@ -2195,7 +2195,7 @@
         }
       ],
       "id": "skill:void-implement",
-      "lines": 192,
+      "lines": 193,
       "name": "void-implement",
       "owner": "folpe",
       "pack": null,
@@ -2204,7 +2204,7 @@
         "codex"
       ],
       "source": "packages/core/skills/void-implement/SKILL.md",
-      "staticTokens": 5800,
+      "staticTokens": 5864,
       "type": "skill"
     },
     {

package/core-assets/skills/void-implement/SKILL.md

@@ -36,11 +36,12 @@ materializes its runtime-neutral specialist envelopes from the current plan.
 1. Keep one `leadWriterId` for implementation and every correction. The implementer owns
    the worktree and code; specialists and the independent reviewer never edit.
 2. Start with `mission start --ticket <ticket>` and follow `mission dispatch --id <mission>
-   --json`. The frozen task and controller own routing, state and correction budget. Before
-   implementation, launch only the risk-relevant preparation specialists returned by dispatch,
-   each envelope through `void-orchestrate` using the native runtime (pass 5). Collect each result without
-   inventing a completion. Record each actual start and completion with `mission specialist-event
-   --id <mission>`. A missing response resumes the run it already has, never another cycle.
+   --json`. The frozen task and controller own routing, state and correction budget. Normal
+   dispatch starts the writer without a compulsory preparation panel. Consult a targeted native
+   specialist only when a concrete risk or unresolved question warrants advice (pass 5).
+   For canonical `invoke-specialists` actions, pass each envelope unchanged through
+   `void-orchestrate` and record actual starts/results with `mission specialist-event --id <mission>`.
+   Reconcile any existing invocation; a missing response resumes its run, never another cycle.
 3. The implementer implements and verifies, then commits the candidate. Record the pending
    writer receipt with `mission writer-event --id <mission>`. Review must bind an exact
    `reviewedCommit`, `baseCommit` and `acceptanceCriteriaHash`; a mutable worktree is insufficient.
@@ -101,7 +102,7 @@ Run in order. Each pass names the skill it composes and the predicate that fires
 2. **Architecture pass** (IF it touches structure, a module boundary, the data model, or public types). Compose `void-hexagonal-architecture`, `void-domain-driven-design`, agents `type-design-analyzer` + `doctrine-critic`. Confirm the applicable ADR is honored.
 3. **Source grounding** (ALWAYS; the source depends on what the change touches). Read the relevant sources before the first line, per the Anti-rustine section of `PHILOSOPHY.md`. For a third-party configuration, schema or call signature, compose `void-source-driven-development`: official documentation **of the installed version**, never an upgrade by default. For internal code, read the owning contract, types, source and project docs of what you are about to change. Assumed semantics produce bugs that cost hours to find, and the assumption is invisible in the diff — which is why this runs before the writing rather than at review. Cite a source briefly when it helps understand or record a choice; a missing citation never blocks on its own.
 4. **Migration safety** (IF it changes a DB schema or ships a migration). Compose `void-migrations` (and `void-drizzle-migration-safe` on a Drizzle/Postgres stack): zero-downtime, two-phase, batched backfill, locking analysis. **Once the migration is generated and safety-reviewed, apply it to the dev/local database before the TDD and E2E passes run** — otherwise those tests execute against a stale schema and prove nothing about the new shape. **This cycle only ever applies to dev/local; production migrations run through CI / GitHub Actions on merge, never from a worker or this session** (see the `void-migrations` anti-rule). A schema change must never reach the rest of the cycle without this pass.
-5. **Convene the panel** (ALWAYS once, in `team` mode). With `panel.provider: orchestrator`, consume ORCH's supplied panel and never launch another. Otherwise call `mission dispatch --json`: its first `invoke-specialists` action is at `stage: 'pre-implementation'`, before code. Compose `void-orchestrate` for native invocation. Pass the envelope's runtime, agentName, missionId, contextPack, reviewSubject and reviewScope unchanged; record actual starts and complete results using `mission specialist-event`. Reconcile an existing invocation before dispatch; uncertain identity means no launch. Keep at most four simultaneous agents, wait in bounded slices, and never fail an agent merely because a wait timed out. Findings brief the single writer; a concrete blocked verdict is resolved before implementation. Later controller stages reuse this transport and never replay preparation. Missing required capability is diagnosed, never fabricated.
+5. **Targeted preparation advice** (IF a concrete risk or unresolved question warrants a specialist). Use the existing professional passes and `void-orchestrate` to consult only the relevant native specialist. Bind the question to the actual brief, cited artifacts, boundary or risk being examined; revisit only the affected advice when those materially change. Baseline/profile applicability alone does not require a panel, and advice is not an automatic canonical gate. With `panel.provider: orchestrator`, consume its supplied advice without launching a duplicate. For canonical `invoke-specialists` actions, preserve runtime, agentName, missionId, contextPack, reviewSubject and reviewScope; record actual starts/results, never invented receipts. Reconcile uncertain invocations before launching, keep at most four simultaneous agents, and never fail one on a wait timeout. Preserve real unresolved findings and author-owned evidence obligations. Already-started preparation may finish as advice after writer admission; it cannot satisfy final code review or authorize a new preparation invocation after implementation starts.
 6. **TDD implementation** (ALWAYS). During development, the coordinator may create or reuse a draft pull request for the branch. Keep work-in-progress PRs in draft and run focused local checks; do not wait for full remote CI per iteration. `void-verify` owns the transition to complete integration checks and its portable CI template. The single lead writer composes `void-tdd` + `void-testing`. Red, green, refactor. Unit tests for the behavior, green before moving on. Review specialists remain read-only.
 7. **Async + idempotency** (IF it sends email, calls an external side-effecting API, enqueues a job, or mints a single-use token). Compose `void-async-safety`: idempotency keys, replay/dedup window, bounded retries, single-use enforcement.
 8. **End-to-end tests** (IF it touches a user-facing flow). Write/extend the E2E suite (Playwright). The path a user actually walks, not just the unit.

package/dist/main.js

@@ -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 = [];
@@ -35813,7 +35896,19 @@ function collectCompletions(events, stage, expectedSource, stageStartSeqExclusiv
   const contextIds = /* @__PURE__ */ new Set();
   const currentFailedRounds = [];
   let historicalHighestRound = 0;
-  const inStageWindow = (event) => (afterSeqExclusive === void 0 || event.seq > afterSeqExclusive) && (beforeSeqExclusive === void 0 || event.seq < beforeSeqExclusive);
+  const inStageWindow = (event) => {
+    let seq = event.seq;
+    if (stage === "pre-implementation" && event.kind === "specialist.completed") {
+      const payload = record7(event.payload);
+      const mission2 = events.find((candidate) => candidate.kind === "mission.started" && candidate.missionId === event.missionId && candidate.seq < event.seq);
+      const planHash = record7(mission2?.payload)?.["planHash"];
+      const matches = (candidate) => candidate.missionId === event.missionId && candidate.subject === event.subject && ["stage", "reviewRound", "inputHash", "contractVersion"].every((key) => record7(candidate.payload)?.[key] === payload?.[key]);
+      const invocation = events.find((candidate) => candidate.seq < event.seq && candidate.kind === "specialist.started" && candidate.source === expectedSource && matches(candidate) && typeof payload?.contextId === "string" && record7(candidate.payload)?.contextId === payload.contextId);
+      if (invocation !== void 0 && events.some((candidate) => candidate.seq < invocation.seq && candidate.kind === "specialist.requested" && candidate.source === "void-harness:mission.dispatch" && typeof planHash === "string" && SHA256.test(planHash) && record7(candidate.payload)?.["planHash"] === planHash && `runtime:${record7(candidate.payload)?.["runtime"]}` === expectedSource && matches(candidate)))
+        seq = invocation.seq;
+    }
+    return (afterSeqExclusive === void 0 || seq > afterSeqExclusive) && (beforeSeqExclusive === void 0 || seq < beforeSeqExclusive);
+  };
   for (const event of events) {
     const payload = record7(event.payload);
     if (event.kind === "specialist.failed") {
@@ -35861,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",
@@ -36580,6 +36675,17 @@ 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: observation2 } = 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 || observation2.stage !== "post-implementation" || observation2.reviewPolicy !== "bounded-corrections-v1" || !observation2.reviewSubject || !current || !receipt2 || !sameReviewSubject(receipt2, observation2.reviewSubject) || current.completion.verdict !== "pass" || current.event.source !== observation2.expectedSource || field4(current.event, "inputHash") !== observation2.currentInputHashes[current.event.subject] || current.completion.contractVersion !== observation2.contractVersions[current.event.subject])
+    return false;
+  return validNativeReviewContinuation(events, current.event);
+}
 function preparationInvocationReplacement(input2) {
   const { events } = input2.stream;
   const { observation: observation2, request } = input2;
@@ -36855,12 +36961,13 @@ function admitStoppedMission(input2, projectedHistory = input2.stream.events) {
   }
   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)) {
@@ -36932,6 +37039,9 @@ function admitStoppedMission(input2, projectedHistory = input2.stream.events) {
     requiredSpecialists: required2,
     contractVersions: observation2.contractVersions,
     currentInputHashes: observation2.currentInputHashes,
+    ...targetedContext ? { validProofIds: freshReviewProofIds(projected, {
+      dependencies: observation2.evidenceDependencies ?? {}
+    }) } : {},
     ...observation2.reviewPolicy === "bounded-corrections-v1" ? BOUNDED_REVIEW_BUDGET : { maxRounds: observation2.maxRounds }
   };
   const originalReview = reduceReviewLoop({ ...reviewInput, events: projectedHistory });
@@ -36945,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");
   }
+  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") === observation2.stage).map((event) => Number(field4(event, "reviewRound"))));
-  if (!replacement && disposition.kind !== "review-provenance" && consumedRounds >= reviewInput.maxRounds)
+  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 === observation2.contractVersions[item.event.subject] && field4(item.event, "inputHash") === observation2.currentInputHashes[item.event.subject]);
   const preservedIds = new Set(preserved.map((item) => item.event.eventId));
   const receipt2 = {
     schemaVersion: 1,
@@ -36969,11 +37082,11 @@ function admitStoppedMission(input2, projectedHistory = input2.stream.events) {
     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");
@@ -37000,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))
@@ -38739,10 +38852,10 @@ function lifecycleField(event, key) {
 function sameSpecialistDispatch(left, right) {
   return left.missionId === right.missionId && left.subject === right.subject && lifecycleField(left, "contractVersion") === lifecycleField(right, "contractVersion") && lifecycleField(left, "stage") === lifecycleField(right, "stage") && lifecycleField(left, "reviewRound") === lifecycleField(right, "reviewRound") && lifecycleField(left, "inputHash") === lifecycleField(right, "inputHash");
 }
-function unboundCompletionReasons(input2, runtime2) {
+function unboundCompletionReasons(input2, runtime2, completions2 = input2.stream.events.filter((event) => event.kind === "specialist.completed"), invocationBeforeSeq) {
   const reasons = [];
-  for (const completion of input2.stream.events.filter((event) => event.kind === "specialist.completed")) {
-    const started = input2.stream.events.find((event) => event.seq < completion.seq && event.kind === "specialist.started" && event.source === `runtime:${runtime2 ?? "invalid"}` && sameSpecialistDispatch(event, completion) && (lifecycleField(completion, "reviewInvocationEventId") === void 0 ? lifecycleField(event, "contextId") === lifecycleField(completion, "contextId") : event.eventId === lifecycleField(completion, "reviewInvocationEventId") && lifecycleField(event, "reviewerId") === parseSpecialistCompletionValue(lifecycleField(completion, "completion"))?.review?.reviewerId));
+  for (const completion of completions2) {
+    const started = input2.stream.events.find((event) => event.seq < completion.seq && (invocationBeforeSeq === void 0 || event.seq < invocationBeforeSeq) && event.kind === "specialist.started" && event.source === `runtime:${runtime2 ?? "invalid"}` && sameSpecialistDispatch(event, completion) && (lifecycleField(completion, "reviewInvocationEventId") === void 0 ? lifecycleField(event, "contextId") === lifecycleField(completion, "contextId") : event.eventId === lifecycleField(completion, "reviewInvocationEventId") && lifecycleField(event, "reviewerId") === parseSpecialistCompletionValue(lifecycleField(completion, "completion"))?.review?.reviewerId));
     const requested = started === void 0 ? void 0 : input2.stream.events.find((event) => event.seq < started.seq && event.kind === "specialist.requested" && event.source === "void-harness:mission.dispatch" && sameSpecialistDispatch(event, completion) && lifecycleField(event, "planHash") === input2.plan.planHash && lifecycleField(event, "runtime") === runtime2);
     if (requested === void 0 || started === void 0) {
       reasons.push(`specialist lifecycle is unbound: ${completion.subject}`);
@@ -38816,7 +38929,7 @@ function decideReviewPhase(start, review, baseVerdict, stage) {
       action: stage === "pre-implementation" ? {
         kind: "run-preparation-correction",
         writerId: start.leadWriterId,
-        findingIds: review.findings.filter((finding) => !start.boundedReview || finding.classification === "blocking").map((finding) => finding.findingId)
+        findingIds: review.findings.filter((finding) => finding.classification !== "advisory").map((finding) => finding.findingId)
       } : {
         kind: "run-correction",
         writerId: start.leadWriterId,
@@ -38897,15 +39010,6 @@ function retainedPreparationSpecialists(input2, events, boundary, targets) {
     return result?.["verdict"] === "pass" && result["contractVersion"] === contractVersions(input2.plan)[id3] && lifecycleField(latest, "inputHash") === input2.currentInputHashesByStage["pre-implementation"][id3];
   });
 }
-function preparationHasMissingOrStaleReviews(input2, events, boundary) {
-  return requiredSpecialists(input2.plan, "pre-implementation").some((id3) => {
-    const latest = events.filter((item) => item.kind === "specialist.completed" && item.subject === id3 && item.seq < boundary && lifecycleField(item, "stage") === "pre-implementation").at(-1);
-    if (latest === void 0)
-      return true;
-    const result = record15(lifecycleField(latest, "completion") ?? null);
-    return result?.["contractVersion"] !== contractVersions(input2.plan)[id3] || lifecycleField(latest, "inputHash") !== input2.currentInputHashesByStage["pre-implementation"][id3];
-  });
-}
 function pendingRecoveredCorrectionFindingIds(events) {
   const recovery = events.filter((event) => event.kind === "mission.recovered").at(-1);
   if (recovery === void 0 || events.some((event) => event.seq > recovery.seq && event.kind === "lead-writer.completed"))
@@ -38962,14 +39066,18 @@ function orchestrateMissionTeam(originalInput) {
   const firstWriterSeq = completions2.length === 0 ? void 0 : Math.min(...completions2.map((event) => event.seq));
   const implementationCompletions = completions2.filter((event) => leadWriterActionKind(event) !== "run-preparation-correction");
   const firstImplementationSeq = implementationCompletions.length === 0 ? void 0 : Math.min(...implementationCompletions.map((event) => event.seq));
-  const preparationCorrectionCompleted = preparationCorrections.length > 0;
-  const preparationFollowupRequired = preparationRecovery !== void 0 || lastPreparationSeq !== void 0 && preparationHasMissingOrStaleReviews(input2, reviewEvents, lastPreparationSeq);
-  const latePreparationCompletion = lastPreparationSeq !== void 0 && input2.stream.events.some((event) => event.seq > lastPreparationSeq && event.kind === "specialist.completed" && lifecycleField(event, "stage") === "pre-implementation");
+  const preparationFollowupRequired = preparationRecovery !== void 0;
   const lastWriterSeq = completions2.length === 0 ? void 0 : Math.max(...completions2.map((event) => event.seq));
   const missionStartSeq = input2.stream.events.find((event) => event.kind === "mission.started")?.seq;
   const expectedSource = start.runtime === "claude" ? "runtime:claude" : "runtime:codex";
   const obligations = evidenceObligations(input2, expectedSource, firstImplementationSeq === void 0 ? "pre-implementation" : "post-implementation");
   const preparationObligationIds = new Set(obligations.obligations.filter((obligation) => input2.stream.events.some((event) => event.eventId === obligation.completionEventId && lifecycleField(event, "stage") === "pre-implementation")).map((obligation) => obligation.obligationId));
+  const preparationBoundary = Math.max(lastPreparationSeq ?? 0, ...completions2.filter((event) => leadWriterActionKind(event) === "run-correction").map((event) => event.seq));
+  const observedPreparation = reviewEvents.filter((event) => event.kind === "specialist.completed" && lifecycleField(event, "stage") === "pre-implementation");
+  const unresolvedPreparation = [...new Map(observedPreparation.filter((event) => event.seq > preparationBoundary).map((event) => [event.subject, event])).values()].filter((event) => {
+    const completion = parseSpecialistCompletionValue(lifecycleField(event, "completion"));
+    return completion !== void 0 && completion.verdict !== "pass" && (completion.verdict !== "changes-requested" || completion.findings.length === 0 || completion.findings.some((finding) => finding.classification !== "advisory"));
+  });
   const preReview = reduceReviewLoop({
     stage: "pre-implementation",
     expectedSource,
@@ -38977,21 +39085,29 @@ function orchestrateMissionTeam(originalInput) {
       stageStartSeqExclusive: missionStartSeq,
       afterSeqExclusive: lastPreparationSeq
     },
-    ...firstWriterSeq === void 0 ? {} : { beforeSeqExclusive: firstWriterSeq },
     events: reviewEvents,
-    requiredSpecialists: requiredSpecialists(input2.plan, "pre-implementation"),
+    // Historical advice is inspected, but the frozen plan is no longer a
+    // compulsory preparation quorum. Explicit admitted recoveries retain theirs.
+    requiredSpecialists: requiredSpecialists(input2.plan, "pre-implementation").filter((id3) => preparationRecovery !== void 0 || (unresolvedPreparation.length > 0 ? unresolvedPreparation : observedPreparation).some((event) => event.subject === id3)),
     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))
     },
+    ...preparationRecovery === void 0 && lastPreparationSeq !== void 0 && missionStartSeq !== void 0 ? {
+      retainedSpecialists: requiredSpecialists(input2.plan, "pre-implementation").filter((id3) => unresolvedPreparation.some((event) => event.subject === id3))
+    } : {},
     ...!preparationFollowupRequired || lastPreparationSeq === void 0 || preparationRecovery !== void 0 && lastPreparationSeq <= preparationRecovery.recoverySeq ? {} : {
       retainedSpecialists: retainedPreparationSpecialists(input2, reviewEvents, lastPreparationSeq, preparationRecovery?.specialistIds ?? [])
     }
   });
   const baseVerdict = deriveMissionVerdict(input2.stream, input2.evidenceContext);
+  if (baseVerdict.status === "degraded") {
+    return stopped("degraded", preReview, baseVerdict, baseVerdict.reasons);
+  }
   const invalidRuntime = input2.specialistRuntime === void 0 || !Array.isArray(input2.specialistRuntime.limitations) || input2.specialistRuntime.limitations.some((item) => typeof item !== "string" || item.trim() === "") || !["available", "degraded", "unavailable"].includes(input2.specialistRuntime.status);
   if (invalidRuntime) {
     return stopped("degraded", preReview, baseVerdict, [
@@ -39042,8 +39158,17 @@ function orchestrateMissionTeam(originalInput) {
   if (preparationRecovery?.replacement && firstImplementationSeq === void 0 && requiredSpecialists(input2.plan, "pre-implementation").some((id3) => input2.currentInputHashesByStage["pre-implementation"][id3] !== preparationRecovery.inputHashes[id3] || contractVersions(input2.plan)[id3] !== preparationRecovery.contractVersions[id3])) {
     return stopped("blocked", preReview, baseVerdict, ["Preparation replacement inputs or contracts changed; reconcile the admitted subject before dispatch"]);
   }
-  if (firstImplementationSeq !== void 0 && input2.stream.events.some((event) => event.kind === "specialist.completed" && event.seq > firstImplementationSeq && lifecycleField(event, "stage") === "pre-implementation")) {
-    return stopped("blocked", preReview, baseVerdict, ["pre-implementation review was replayed after implementation"]);
+  const implementationBoundary = input2.stream.events.find((event) => event.kind === "lead-writer.requested" && leadWriterActionKind(event) === "run-lead-writer")?.seq ?? firstImplementationSeq;
+  if (implementationBoundary !== void 0) {
+    const latePreparation = observedPreparation.filter((event) => event.seq > implementationBoundary);
+    const lifecycleReasons = unboundCompletionReasons(input2, start.runtime, latePreparation, implementationBoundary);
+    const replayed = input2.stream.events.some((event) => event.seq > implementationBoundary && event.kind === "specialist.started" && lifecycleField(event, "stage") === "pre-implementation");
+    if (replayed || lifecycleReasons.length > 0) {
+      return stopped("blocked", preReview, baseVerdict, ["pre-implementation review was replayed after implementation", ...lifecycleReasons]);
+    }
+  }
+  if (preReview.issues.length > 0) {
+    return decideReviewPhase(start, preReview, baseVerdict, "pre-implementation");
   }
   const pendingEvidence = obligationStop(obligations, preReview, baseVerdict);
   const migration = migrated.migration;
@@ -39054,7 +39179,7 @@ function orchestrateMissionTeam(originalInput) {
     }
     const terminal = input2.stream.events.some((event) => event.seq > migration.seq && event.subject === receipt2.specialistId && ["specialist.completed", "specialist.failed"].includes(event.kind));
     const onlyAuthorObligations = obligations.issues.length === 0 && obligations.blockingObligationIds.every((id3) => receipt2.pendingAuthorObligationIds.includes(id3));
-    const preparationAdmitted = preReview.readyForVerdict || preparationCorrectionCompleted && !preparationFollowupRequired && firstImplementationSeq !== void 0;
+    const preparationAdmitted = firstImplementationSeq !== void 0;
     if (!terminal && onlyAuthorObligations && preparationAdmitted) {
       const reasons = ["Explicit contract migration requires one fresh visual assessment; historical evidence obligations remain due"];
       return applyRuntimeCertification({
@@ -39083,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,
@@ -39120,22 +39240,30 @@ function orchestrateMissionTeam(originalInput) {
       reasons
     }, input2.specialistRuntime);
   }
-  if (!preparationFollowupRequired && preparationCorrectionCompleted && latePreparationCompletion) {
-    return applyRuntimeCertification(stopped("blocked", preReview, baseVerdict, ["pre-implementation review was replayed after preparation correction"]), input2.specialistRuntime);
+  if (preparationFollowupRequired && !preReview.readyForVerdict) {
+    return applyRuntimeCertification(decideReviewPhase(start, preReview, baseVerdict, "pre-implementation"), input2.specialistRuntime);
   }
-  if (!preparationFollowupRequired && preparationCorrectionCompleted && firstImplementationSeq === void 0) {
-    const reasons = ["preparation correction completed; implementation is pending"];
+  if (unresolvedPreparation.length > 0) {
+    const reasons = unresolvedPreparation.flatMap((event) => {
+      const completion = parseSpecialistCompletionValue(lifecycleField(event, "completion"));
+      return completion === void 0 ? [] : [
+        ...completion.findings.map((finding) => finding.summary),
+        ...completion.limitations
+      ];
+    });
+    if (preReview.staleSpecialists.some((id3) => unresolvedPreparation.some((event) => event.subject === id3))) {
+      return stopped("blocked", preReview, baseVerdict, ["Existing preparation findings require reconciliation against changed inputs.", ...reasons]);
+    }
+    const decision = decideReviewPhase(start, preReview, baseVerdict, "pre-implementation");
+    if (decision.action.kind === "run-preparation-correction" && decision.action.findingIds.length === 0) {
+      return stopped("blocked", preReview, baseVerdict, ["Preparation requested changes without an actionable finding.", ...reasons]);
+    }
     return applyRuntimeCertification({
-      phase: "implementation",
-      action: { kind: "run-lead-writer", writerId: start.leadWriterId },
-      review: preReview,
-      verdict: overrideVerdict(baseVerdict, "unverified", reasons),
-      reasons
+      ...decision,
+      reasons: [...decision.reasons, ...reasons],
+      ...firstImplementationSeq !== void 0 && decision.action.kind === "run-preparation-correction" ? { action: { ...decision.action, kind: "run-correction" } } : {}
     }, input2.specialistRuntime);
   }
-  if (!preReview.readyForVerdict && (!preparationCorrectionCompleted || preparationFollowupRequired)) {
-    return applyRuntimeCertification(decideReviewPhase(start, preReview, baseVerdict, "pre-implementation"), input2.specialistRuntime);
-  }
   if (completions2.length === 0) {
     const reasons = ["lead writer implementation is incomplete"];
     return applyRuntimeCertification({
@@ -56469,7 +56597,7 @@ async function missionReviewBase(root) {
     throw new Error("MISSION_REVIEW_BASE_INVALID: a committed Git baseline is required");
   }
 }
-async function captureMissionReviewSubject(root, baseCommit, committed = false, hashFormat = committed ? "committed" : "legacy") {
+async function validateMissionReviewBase(root, baseCommit) {
   if (baseCommit === void 0) {
     throw new Error(
       "MISSION_REVIEW_BASE_MISSING: legacy mission has no review baseline; preserve its history and start a new mission"
@@ -56479,8 +56607,13 @@ async function captureMissionReviewSubject(root, baseCommit, committed = false,
   try {
     await execFile2("git", ["merge-base", "--is-ancestor", baseCommit, "HEAD"], options2);
   } catch {
-    throw new Error("MISSION_REVIEW_BASE_INVALID: baseline is missing or is not an ancestor of HEAD");
+    throw new Error("MISSION_REVIEW_BASE_INVALID: baseline is missing or is not an ancestor of HEAD; return to the mission worktree with a checkout descended from its bound base; preserve the journal");
   }
+  return baseCommit;
+}
+async function captureMissionReviewSubject(root, baseCommit, committed = false, hashFormat = committed ? "committed" : "legacy") {
+  const validatedBase = await validateMissionReviewBase(root, baseCommit);
+  const options2 = { cwd: root, encoding: "utf8", timeout: 1e4, maxBuffer: 4e6 };
   try {
     const paths = ["--", ".", ":(exclude).void/machine/**"];
     const reviewedCommit = committed ? await missionReviewBase(root) : void 0;
@@ -56497,7 +56630,7 @@ async function captureMissionReviewSubject(root, baseCommit, committed = false,
         throw new Error("MISSION_REVIEW_UNCOMMITTED: commit the implementation before independent review");
       }
     }
-    const range = reviewedCommit === void 0 ? [baseCommit] : [baseCommit, reviewedCommit];
+    const range = reviewedCommit === void 0 ? [validatedBase] : [validatedBase, reviewedCommit];
     const [patch, names, untracked] = await Promise.all([
       execFile2("git", [
         "diff",
@@ -56547,11 +56680,11 @@ async function captureMissionReviewSubject(root, baseCommit, committed = false,
       throw new Error("MISSION_REVIEW_CHANGED: HEAD changed while capturing the review subject");
     }
     return Object.freeze({
-      ...reviewedCommit === void 0 ? {} : { baseCommit, reviewedCommit },
+      ...reviewedCommit === void 0 ? {} : { baseCommit: validatedBase, reviewedCommit },
       diff: patch.stdout,
       files,
       hash: canonicalJsonHash({
-        baseCommit,
+        baseCommit: validatedBase,
         ...hashFormat === "legacy" ? {} : { reviewedCommit },
         diff: patch.stdout,
         files: files.files
@@ -67223,7 +67356,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") {
@@ -67836,7 +67969,7 @@ async function recordSpecialistLifecycle(root, missionId, input2, artifactRoot =
       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 (!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" && field8(event.payload, "contextId") === input2.contextId) && !canContinueNativeReview(events, requested, input2.contextId)) {
       invalid14("contextId was already used by a previous dispatch");
     }
   } else {
@@ -67868,7 +68001,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" && field8(event.payload, "contextId") === input2.contextId && event.eventId !== eventId3) && !canContinueNativeReview(current, requested, input2.contextId)) {
         invalid14("contextId was already used by a previous dispatch");
       }
     }
@@ -68026,7 +68159,7 @@ async function recordSpecialistRequests(root, missionId, envelopes, planHash) {
 init_esm_shims();
 
 // package.json
-var version2 = "5.0.6";
+var version2 = "5.0.8";
 
 // src/lib/runs/verify.ts
 var MAX_CAPTURE_BYTES = 64 * 1024;
@@ -68597,6 +68730,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");
   }
@@ -68650,10 +68784,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 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 observation2 = {
-    ...provenance4 === void 0 || subject?.baseCommit === void 0 || subject.reviewedCommit === void 0 ? {} : {
-      reviewBindings: provenance4.bindings,
+    ...provenance4 === void 0 && !targetedContextRecovery || subject?.baseCommit === void 0 || subject.reviewedCommit === void 0 ? {} : {
+      ...provenance4 === void 0 ? {} : { reviewBindings: provenance4.bindings },
       reviewSubject: {
         taskId: missionId,
         baseCommit: subject.baseCommit,
@@ -68725,6 +68859,9 @@ async function dispatchMissionSpecialists(roots, input2, generatedAt = (/* @__PU
   const inspected = current?.inspected ?? initialInspection;
   requireOpenMission(inspected.stream.events);
   const implemented = inspected.stream.events.some((event) => event.kind === "lead-writer.completed" && isUnknownRecord(event.payload) && event.payload.actionKind !== "run-preparation-correction");
+  if (!implemented && stored.baseCommit !== void 0) {
+    await validateMissionReviewBase(workRoot, stored.baseCommit);
+  }
   const reviewSubject = implemented ? await captureControllerReviewSubject(workRoot, stored.baseCommit, inspected.stream.events) : void 0;
   const live = await planBoundMission(
     workRoot,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "voidmachine",
-  "version": "5.0.6",
+  "version": "5.0.8",
   "description": "void-machine CLI — install an opinionated engineering doctrine on any project; render deterministic project health. Run via `npx voidmachine`; command: void-machine (alias vm).",
   "license": "MIT",
   "author": "Folpe @ VoidCorp",
@@ -58,10 +58,10 @@
     "ws": "8.21.0",
     "yaml": "^2.5.0",
     "zod": "^4.6.5",
+    "@voidcorp/harness-graph": "5.0.8",
+    "@voidcorp/hook-runner": "0.0.0",
     "@voidcorp/mission-engine": "0.0.0",
-    "@voidcorp/void-machine": "0.0.0",
-    "@voidcorp/harness-graph": "5.0.6",
-    "@voidcorp/hook-runner": "0.0.0"
+    "@voidcorp/void-machine": "0.0.0"
   },
   "scripts": {
     "build": "tsup",