voidmachine 5.0.4 → 5.0.6

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

@@ -1,6 +1,6 @@
 {
   "name": "harness",
-  "version": "5.0.4",
+  "version": "5.0.6",
   "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:56012433234f5e7d537066868543df205e92f817003384489c7e698778a49ab2"
+    "rootHash": "sha256:e38546e5aa7fcb09bddd3c33954b340026d7d92ae9d74b0272191043b98cd706"
   },
   "nodes": [
     {
@@ -4677,7 +4677,7 @@
             }
           ],
           "id": "skill:void-orchestrate",
-          "lines": 327,
+          "lines": 328,
           "name": "void-orchestrate",
           "owner": "folpe",
           "pack": null,
@@ -4686,7 +4686,7 @@
             "codex"
           ],
           "source": "packages/core/skills/void-orchestrate/SKILL.md",
-          "staticTokens": 4673,
+          "staticTokens": 4684,
           "type": "skill"
         }
       },

package/core-assets/data/certification.json

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

package/core-assets/data/model.json

@@ -2415,7 +2415,7 @@
         }
       ],
       "id": "skill:void-orchestrate",
-      "lines": 327,
+      "lines": 328,
       "name": "void-orchestrate",
       "owner": "folpe",
       "pack": null,
@@ -2424,7 +2424,7 @@
         "codex"
       ],
       "source": "packages/core/skills/void-orchestrate/SKILL.md",
-      "staticTokens": 4673,
+      "staticTokens": 4684,
       "type": "skill"
     },
     {

package/core-assets/hooks/_void-hook.mjs

@@ -13035,7 +13035,7 @@ var selectionSchema = strictObject({
   mission: identifier,
   coordinator: strictObject({ label: identifier, worktree: path })
 });
-var instant = iso_exports.datetime();
+var instant = iso_exports.datetime({ offset: true });
 var status = _enum(["planned", "running", "blocked", "done", "failed"]);
 var workerSchema = strictObject({
   label: identifier,

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

@@ -161,7 +161,8 @@ mission bytes; exceeding a bound is incomplete, never a unique match.
 See the shipped technical contract `docs/ORCHESTRA.md` in the harness source for
 schemas; the operational fields are listed here so an installed skill is sufficient.
 
-- mission.md: schema, mission, project, status, updated_at (UTC ISO), repository
+- mission.md: schema, mission, project, status, updated_at
+  (ISO with `Z` or `+HH:MM`/`-HH:MM`; prefer UTC `Z`), repository
   (canonical Git common path), coordinator {label, worktree, workspace?}, workers.
 - Worker entries: label, agent (codex or claude), worktree, branch, ticket, status,
   attempt; optional pane_id and session are hints only. At most four workers.

package/dist/main.js

@@ -35954,7 +35954,7 @@ function collectCompletions(events, stage, expectedSource, stageStartSeqExclusiv
   }
   const validAccepted = accepted.filter((envelope) => !invalidRoundEvents.has(envelope.event.eventId) && !(contractMigration !== void 0 && stage === "post-implementation" && envelope.completion.specialistId === contractMigration.specialistId && envelope.event.seq < contractMigration.afterSeq));
   const highestRound = Math.max(historicalHighestRound, activeRound ?? 0);
-  const pendingFailureRounds = [...failedRoundBySpecialist.entries()].filter(([id3]) => !completedInWindow.has(id3)).map(([, round]) => round + 1);
+  const pendingFailureRounds = [...failedRoundBySpecialist.entries()].filter(([id3]) => !validAccepted.some((item) => item.completion.specialistId === id3)).map(([, round]) => round + 1);
   const nextRound = Math.max(firstCurrentRound, highestRound, ...pendingFailureRounds);
   return { accepted: [...retained, ...validAccepted], history, issues, highestRound, nextRound };
 }
@@ -36778,6 +36778,55 @@ function pendingPreparationClarification(input2, previousRecovery) {
   const completionEventIds = request.disposition.completionEventIds;
   return obligations.issues.length === 0 && obligations.obligations.some((item) => blocking.has(item.obligationId) && completionEventIds.includes(item.completionEventId));
 }
+function pendingStoppedEvidenceRequest(events, requestEventId, contextId) {
+  const lifecycle = projectMissionLifecycle(events);
+  if (lifecycle.status !== "closed" || lifecycle.closure.source !== "void-harness:mission.dispatch" || field4(lifecycle.closure, "reason") !== "controller-stop" || ambiguousEffects(events))
+    return false;
+  const request = events.find((event) => event.eventId === requestEventId);
+  const runtime2 = events[0] === void 0 ? void 0 : field4(events[0], "runtime");
+  if (runtime2 !== "codex" && runtime2 !== "claude" || events[0] === void 0 || field4(events[0], "runtimeAttested") !== true || !request || request.kind !== "specialist.evidence-discharge-requested" || request.source !== "void-harness:mission.dispatch" || request.seq >= lifecycle.closure.seq || field4(request, "nativeContextId") !== contextId || !validNativeContextId(contextId))
+    return false;
+  return events.some((event) => event.kind === "specialist.evidence-started" && event.source === `runtime:${String(runtime2)}` && event.subject === request.subject && event.causationId === request.eventId && event.seq > request.seq && event.seq < lifecycle.closure.seq && [
+    "completionEventId",
+    "completionHash",
+    "specialistId",
+    "nativeContextId",
+    "requestId"
+  ].every((key) => field4(event, key) === field4(request, key)));
+}
+function validEvidenceDispositionRecovery(input2) {
+  const { events } = input2.stream;
+  const { disposition } = input2.request;
+  if (disposition.kind !== "evidence-disposition" || disposition.responseEventIds.length < 1 || disposition.responseEventIds.length > 64 || new Set(disposition.responseEventIds).size !== disposition.responseEventIds.length)
+    return false;
+  const closure = events.find((event) => event.eventId === input2.request.closureEventId);
+  if (!closure)
+    return false;
+  const proofs = events.flatMap((event) => {
+    const parsed = event.kind === "evidence.recorded" ? parseEvidence(field4(event, "evidence")) : void 0;
+    return parsed?.ok ? [{ eventId: event.eventId, evidence: parsed.value }] : [];
+  });
+  const reduction = {
+    expectedSource: input2.observation.expectedSource,
+    phase: "completion",
+    evidenceContext: { missionId: closure.missionId, dependencies: input2.observation.evidenceDependencies ?? {} },
+    proofs
+  };
+  const before = reduceEvidenceObligations({ ...reduction, events: events.filter((event) => event.seq <= closure.seq) });
+  const after = reduceEvidenceObligations({ ...reduction, events });
+  if (before.issues.length > 0 || after.issues.length > 0)
+    return false;
+  return disposition.responseEventIds.every((id3) => {
+    const response = events.find((event) => event.eventId === id3);
+    if (response?.kind !== "specialist.evidence-discharged" || response.seq <= closure.seq || response.source !== input2.observation.expectedSource || !response.causationId || typeof field4(response, "nativeContextId") !== "string" || !pendingStoppedEvidenceRequest(events.filter((event) => event.seq < response.seq), response.causationId, String(field4(response, "nativeContextId"))))
+      return false;
+    const origin = completions(events).find((item) => item.event.eventId === field4(response, "completionEventId"));
+    if (!origin || origin.completion.contractVersion !== input2.observation.contractVersions[origin.event.subject])
+      return false;
+    const items = field4(response, "items");
+    return Array.isArray(items) && items.length > 0 && items.every((item) => record10(item) && Array.isArray(item["proofEventIds"]) && item["proofEventIds"].every((id4) => proofs.some((proof4) => proof4.eventId === id4 && proof4.evidence.dependencies.some((dependency) => dependency.key === "git:working-tree" && dependency.hash === input2.observation.evidenceDependencies?.["git:working-tree"]))) && before.obligations.some((value) => value.obligationId === item["obligationId"] && !value.discharged) && after.obligations.some((value) => value.obligationId === item["obligationId"] && value.discharged));
+  });
+}
 function admitStoppedMission(input2, projectedHistory = input2.stream.events) {
   const { stream: stream2, request, observation: observation2 } = input2;
   const events = stream2.events;
@@ -36796,9 +36845,12 @@ function admitStoppedMission(input2, projectedHistory = input2.stream.events) {
     return refuse2("stale-journal", "Re-observe the journal before requesting recovery");
   if (ambiguousEffects(events))
     return refuse2("ambiguous-effect", "Reconcile the unfinished external effect; recovery cannot replay it");
+  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 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) && !validProvenanceRecovery(input2, existing, previousRecovery.seq)) {
+  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;
@@ -36921,7 +36973,7 @@ function admitStoppedMission(input2, projectedHistory = input2.stream.events) {
       consumedCorrectionBatches,
       remainingCorrectionBatches: 2 - consumedCorrectionBatches
     },
-    nextAction: replacement || 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 || 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");
@@ -36938,6 +36990,10 @@ function recoveryRequest(value) {
   if (value === void 0 || !record10(value) || !exactKeys2(value, ["schemaVersion", "closureEventId", "expectedJournalHash", "disposition"]) || value["schemaVersion"] !== 1 || typeof value["closureEventId"] !== "string" || typeof value["expectedJournalHash"] !== "string" || !/^sha256:[a-f0-9]{64}$/.test(value["expectedJournalHash"]) || value["disposition"] === void 0 || !record10(value["disposition"]))
     return false;
   const disposition = value["disposition"];
+  if (disposition["kind"] === "evidence-disposition") {
+    const ids = disposition["responseEventIds"];
+    return exactKeys2(disposition, ["kind", "responseEventIds"]) && Array.isArray(ids) && ids.length > 0 && ids.length <= 64 && new Set(ids).size === ids.length && ids.every((id3) => typeof id3 === "string" && /^evt_[A-Za-z0-9_-]{8,100}$/.test(id3));
+  }
   if (disposition["kind"] === "preparation-invocation") {
     return exactKeys2(disposition, ["kind", "completionEventIds"]) && Array.isArray(disposition["completionEventIds"]) && disposition["completionEventIds"].length > 0 && disposition["completionEventIds"].length <= 64 && disposition["completionEventIds"].every((item) => typeof item === "string" && /^evt_[A-Za-z0-9_-]{8,100}$/.test(item)) && new Set(disposition["completionEventIds"]).size === disposition["completionEventIds"].length;
   }
@@ -38882,7 +38938,7 @@ function evidenceObligations(input2, expectedSource, phase) {
     evidenceContext: input2.evidenceContext
   });
 }
-function obligationStop(state, review, verdict, preparation = false) {
+function obligationStop(state, review, verdict) {
   if (state.issues.length > 0) {
     return stopped("degraded", review, verdict, state.issues.map((issue4) => `Evidence obligation ${issue4.eventId}: ${issue4.detail}`), "Resolve the invalid specialist evidence disposition, then classify or discharge the original obligation through its authorized specialist.");
   }
@@ -38890,7 +38946,7 @@ function obligationStop(state, review, verdict, preparation = false) {
   if (blocking.size === 0)
     return void 0;
   const decision = stopped("blocked", review, verdict, state.obligations.filter((item) => blocking.has(item.obligationId)).map((item) => `Evidence obligation ${item.obligationId} (${item.due}): ${item.requestText}`), "Use mission evidence-request, then record the authorized author response with mission evidence-event to classify or discharge the obligation; a writer completion does not replace the required proof.");
-  return preparation ? { ...decision, action: { kind: "await-evidence", reasons: decision.reasons } } : decision;
+  return { ...decision, action: { kind: "await-evidence", reasons: decision.reasons } };
 }
 function orchestrateMissionTeam(originalInput) {
   const migrated = validatedSpecialistContractMigrations(originalInput.stream.events, originalInput.plan);
@@ -38986,7 +39042,10 @@ 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"]);
   }
-  const pendingEvidence = obligationStop(obligations, preReview, baseVerdict, firstImplementationSeq === void 0);
+  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 pendingEvidence = obligationStop(obligations, preReview, baseVerdict);
   const migration = migrated.migration;
   if (migration !== void 0) {
     const receipt2 = migration.receipt;
@@ -39012,6 +39071,33 @@ function orchestrateMissionTeam(originalInput) {
       }, input2.specialistRuntime);
     }
   }
+  const postReview = firstImplementationSeq === void 0 || lastWriterSeq === void 0 ? void 0 : reduceReviewLoop({
+    stage: "post-implementation",
+    expectedSource,
+    stageStartSeqExclusive: firstImplementationSeq,
+    afterSeqExclusive: lastWriterSeq,
+    events: reviewEvents,
+    requiredSpecialists: requiredSpecialists(input2.plan, "post-implementation", start.boundedReview),
+    contractVersions: contractVersions(input2.plan),
+    currentInputHashes: input2.currentInputHashesByStage["post-implementation"],
+    ...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] : [];
+    }),
+    ...migration === void 0 ? {} : { contractMigration: {
+      specialistId: migration.receipt.specialistId,
+      afterSeq: migration.seq,
+      reviewRound: migration.receipt.reviewRound
+    } }
+  });
+  if (postReview?.status === "blocked" || postReview?.status === "degraded") {
+    return applyRuntimeCertification(decideReviewPhase(start, postReview, baseVerdict, "post-implementation"), input2.specialistRuntime);
+  }
   const correctiveFindingIds = pendingRecoveredCorrectionFindingIds(input2.stream.events);
   const correctiveContinuation = pendingEvidence !== void 0 && obligations.issues.length === 0 && firstImplementationSeq !== void 0 && correctiveFindingIds.length > 0;
   if (pendingEvidence !== void 0 && !correctiveContinuation) {
@@ -39060,32 +39146,9 @@ function orchestrateMissionTeam(originalInput) {
       reasons
     }, input2.specialistRuntime);
   }
-  if (firstWriterSeq === void 0 || firstImplementationSeq === void 0 || lastWriterSeq === void 0) {
+  if (firstWriterSeq === void 0 || firstImplementationSeq === void 0 || lastWriterSeq === void 0 || postReview === void 0) {
     throw new Error("MISSION_TEAM_INVARIANT: writer completion boundary is missing");
   }
-  const postReview = reduceReviewLoop({
-    stage: "post-implementation",
-    expectedSource,
-    stageStartSeqExclusive: firstImplementationSeq,
-    afterSeqExclusive: lastWriterSeq,
-    events: reviewEvents,
-    requiredSpecialists: requiredSpecialists(input2.plan, "post-implementation", start.boundedReview),
-    contractVersions: contractVersions(input2.plan),
-    currentInputHashes: input2.currentInputHashesByStage["post-implementation"],
-    ...start.boundedReview ? BOUNDED_REVIEW_BUDGET : { maxRounds: input2.maxReviewRounds },
-    evidenceObligations: obligations,
-    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] : [];
-    }),
-    ...migration === void 0 ? {} : { contractMigration: {
-      specialistId: migration.receipt.specialistId,
-      afterSeq: migration.seq,
-      reviewRound: migration.receipt.reviewRound
-    } }
-  });
   if (start.boundedReview && postReview.missingSpecialists.length === 0) {
     const receiptReasons = boundedReceiptReasons(input2, start, reviewEvents);
     if (receiptReasons.length > 0)
@@ -67163,6 +67226,11 @@ function parseMissionRecoveryRequest(value) {
     if (!exact2(disposition, ["kind", "defect"]) || defect !== "partial-fanout-round" && defect !== "stale-input-dispatch" && defect !== "opaque-native-context") invalid11();
     return { ...base, disposition: { kind: "controller-defect", defect } };
   }
+  if (disposition["kind"] === "evidence-disposition") {
+    const ids2 = disposition["responseEventIds"];
+    if (!exact2(disposition, ["kind", "responseEventIds"]) || !Array.isArray(ids2) || ids2.length < 1 || ids2.length > 64 || !ids2.every(eventId) || new Set(ids2).size !== ids2.length) invalid11();
+    return { ...base, disposition: { kind: "evidence-disposition", responseEventIds: ids2 } };
+  }
   const commandCorrection = disposition["kind"] === "command-correction";
   const ids = disposition["completionEventIds"];
   if (disposition["kind"] === "preparation-invocation") {
@@ -67444,13 +67512,22 @@ async function validateCompletion(events, candidate, roots, expectedSource) {
   if (discharge2) {
     const items = field7(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");
+      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`);
     }
   }
 }
-async function recordSpecialistEvidence(roots, missionId, status3, input2) {
-  const events = (await inspectMission(roots.installRoot, missionId, { dependencies: {} })).stream.events;
+function requireResponseAdmission(events, status3, input2) {
+  if (observedMissionLifecycle(events).status === "open") return;
+  if (status3 === "completed" && pendingStoppedEvidenceRequest(events, input2.requestEventId, input2.contextId)) return;
   requireOpenMission(events);
+}
+async function recordSpecialistEvidence(roots, missionId, status3, input2) {
+  const { stream: stream2 } = await inspectMission(roots.installRoot, missionId, { dependencies: {} });
+  if (stream2.continuity !== "complete" || stream2.invalidLines > 0 || stream2.duplicateEventIds > 0) {
+    invalid13("complete unaltered journal is required before author response admission");
+  }
+  const events = stream2.events;
+  requireResponseAdmission(events, status3, input2);
   const source2 = identity(events);
   const request = exactRequest(events, input2);
   const kind2 = status3 === "started" ? "specialist.evidence-started" : request.kind === "specialist.evidence-classification-requested" ? "specialist.evidence-classified" : "specialist.evidence-discharged";
@@ -67474,7 +67551,7 @@ async function recordSpecialistEvidence(roots, missionId, status3, input2) {
     eventId: id3,
     draft,
     validate: async (current) => {
-      requireOpenMission(current);
+      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);
@@ -67515,6 +67592,9 @@ function parseSpecialistEvidenceRequest(value) {
   return { ...base, operation: "discharge", obligationIds: ids };
 }
 function responseItem(value) {
+  if (record25(value) && typeof value["reason"] === "string" && value["reason"].length > 1e3) {
+    invalid13(`reason has ${value["reason"].length} characters; maximum is 1000; request a corrected author response`);
+  }
   if (!record25(value) || !text5(value["reason"])) invalid13("an author reason is required for each disposition");
   if ("requestIndex" in value) {
     const due2 = value["due"];
@@ -67946,7 +68026,7 @@ async function recordSpecialistRequests(root, missionId, envelopes, planHash) {
 init_esm_shims();
 
 // package.json
-var version2 = "5.0.4";
+var version2 = "5.0.6";
 
 // src/lib/runs/verify.ts
 var MAX_CAPTURE_BYTES = 64 * 1024;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "voidmachine",
-  "version": "5.0.4",
+  "version": "5.0.6",
   "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.4",
-    "@voidcorp/hook-runner": "0.0.0",
     "@voidcorp/mission-engine": "0.0.0",
-    "@voidcorp/void-machine": "0.0.0"
+    "@voidcorp/void-machine": "0.0.0",
+    "@voidcorp/harness-graph": "5.0.6",
+    "@voidcorp/hook-runner": "0.0.0"
   },
   "scripts": {
     "build": "tsup",