voidmachine 5.0.7 → 5.0.8

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

@@ -1,6 +1,6 @@
 {
   "name": "harness",
-  "version": "5.0.7",
+  "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/certification.json

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

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 = [];
@@ -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",
@@ -36592,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;
@@ -36867,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)) {
@@ -36944,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 });
@@ -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");
   }
+  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,
@@ -36981,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");
@@ -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))
@@ -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,
@@ -67259,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") {
@@ -67872,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 {
@@ -67904,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");
       }
     }
@@ -68062,7 +68159,7 @@ async function recordSpecialistRequests(root, missionId, envelopes, planHash) {
 init_esm_shims();
 
 // package.json
-var version2 = "5.0.7";
+var version2 = "5.0.8";
 
 // src/lib/runs/verify.ts
 var MAX_CAPTURE_BYTES = 64 * 1024;
@@ -68633,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");
   }
@@ -68686,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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "voidmachine",
-  "version": "5.0.7",
+  "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,9 +58,9 @@
     "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/harness-graph": "5.0.7",
     "@voidcorp/void-machine": "0.0.0"
   },
   "scripts": {