voidmachine 7.0.1 → 7.0.2

package/dist/main.js

@@ -7395,62 +7395,6 @@ var require_dist = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/sisteransi@1.0.5/node_modules/sisteransi/src/index.js
-var require_src = __commonJS({
-  "../../node_modules/.pnpm/sisteransi@1.0.5/node_modules/sisteransi/src/index.js"(exports, module) {
-    init_esm_shims();
-    var ESC2 = "\x1B";
-    var CSI2 = `${ESC2}[`;
-    var beep = "\x07";
-    var cursor = {
-      to(x3, y) {
-        if (!y) return `${CSI2}${x3 + 1}G`;
-        return `${CSI2}${y + 1};${x3 + 1}H`;
-      },
-      move(x3, y) {
-        let ret = "";
-        if (x3 < 0) ret += `${CSI2}${-x3}D`;
-        else if (x3 > 0) ret += `${CSI2}${x3}C`;
-        if (y < 0) ret += `${CSI2}${-y}A`;
-        else if (y > 0) ret += `${CSI2}${y}B`;
-        return ret;
-      },
-      up: (count = 1) => `${CSI2}${count}A`,
-      down: (count = 1) => `${CSI2}${count}B`,
-      forward: (count = 1) => `${CSI2}${count}C`,
-      backward: (count = 1) => `${CSI2}${count}D`,
-      nextLine: (count = 1) => `${CSI2}E`.repeat(count),
-      prevLine: (count = 1) => `${CSI2}F`.repeat(count),
-      left: `${CSI2}G`,
-      hide: `${CSI2}?25l`,
-      show: `${CSI2}?25h`,
-      save: `${ESC2}7`,
-      restore: `${ESC2}8`
-    };
-    var scroll = {
-      up: (count = 1) => `${CSI2}S`.repeat(count),
-      down: (count = 1) => `${CSI2}T`.repeat(count)
-    };
-    var erase = {
-      screen: `${CSI2}2J`,
-      up: (count = 1) => `${CSI2}1J`.repeat(count),
-      down: (count = 1) => `${CSI2}J`.repeat(count),
-      line: `${CSI2}2K`,
-      lineEnd: `${CSI2}K`,
-      lineStart: `${CSI2}1K`,
-      lines(count) {
-        let clear = "";
-        for (let i = 0; i < count; i++)
-          clear += this.line + (i < count - 1 ? cursor.up() : "");
-        if (count)
-          clear += cursor.left;
-        return clear;
-      }
-    };
-    module.exports = { cursor, scroll, erase, beep };
-  }
-});
-
 // ../../node_modules/.pnpm/picomatch@4.0.5/node_modules/picomatch/lib/constants.js
 var require_constants = __commonJS({
   "../../node_modules/.pnpm/picomatch@4.0.5/node_modules/picomatch/lib/constants.js"(exports, module) {
@@ -9218,6 +9162,62 @@ var require_picomatch2 = __commonJS({
   }
 });
 
+// ../../node_modules/.pnpm/sisteransi@1.0.5/node_modules/sisteransi/src/index.js
+var require_src = __commonJS({
+  "../../node_modules/.pnpm/sisteransi@1.0.5/node_modules/sisteransi/src/index.js"(exports, module) {
+    init_esm_shims();
+    var ESC2 = "\x1B";
+    var CSI2 = `${ESC2}[`;
+    var beep = "\x07";
+    var cursor = {
+      to(x3, y) {
+        if (!y) return `${CSI2}${x3 + 1}G`;
+        return `${CSI2}${y + 1};${x3 + 1}H`;
+      },
+      move(x3, y) {
+        let ret = "";
+        if (x3 < 0) ret += `${CSI2}${-x3}D`;
+        else if (x3 > 0) ret += `${CSI2}${x3}C`;
+        if (y < 0) ret += `${CSI2}${-y}A`;
+        else if (y > 0) ret += `${CSI2}${y}B`;
+        return ret;
+      },
+      up: (count = 1) => `${CSI2}${count}A`,
+      down: (count = 1) => `${CSI2}${count}B`,
+      forward: (count = 1) => `${CSI2}${count}C`,
+      backward: (count = 1) => `${CSI2}${count}D`,
+      nextLine: (count = 1) => `${CSI2}E`.repeat(count),
+      prevLine: (count = 1) => `${CSI2}F`.repeat(count),
+      left: `${CSI2}G`,
+      hide: `${CSI2}?25l`,
+      show: `${CSI2}?25h`,
+      save: `${ESC2}7`,
+      restore: `${ESC2}8`
+    };
+    var scroll = {
+      up: (count = 1) => `${CSI2}S`.repeat(count),
+      down: (count = 1) => `${CSI2}T`.repeat(count)
+    };
+    var erase = {
+      screen: `${CSI2}2J`,
+      up: (count = 1) => `${CSI2}1J`.repeat(count),
+      down: (count = 1) => `${CSI2}J`.repeat(count),
+      line: `${CSI2}2K`,
+      lineEnd: `${CSI2}K`,
+      lineStart: `${CSI2}1K`,
+      lines(count) {
+        let clear = "";
+        for (let i = 0; i < count; i++)
+          clear += this.line + (i < count - 1 ? cursor.up() : "");
+        if (count)
+          clear += cursor.left;
+        return clear;
+      }
+    };
+    module.exports = { cursor, scroll, erase, beep };
+  }
+});
+
 // ../../node_modules/.pnpm/ws@8.21.0/node_modules/ws/lib/constants.js
 var require_constants2 = __commonJS({
   "../../node_modules/.pnpm/ws@8.21.0/node_modules/ws/lib/constants.js"(exports, module) {
@@ -17955,7 +17955,7 @@ var recursive = /* @__PURE__ */ new WeakMap();
 var NONE = 0;
 var ASSUMED = 1;
 var PROVEN = 2;
-function isRecursive(inst, stack, resolve43) {
+function isRecursive(inst, stack, resolve45) {
   const cached2 = recursive.get(inst);
   if (cached2 !== void 0)
     return cached2 ? PROVEN : NONE;
@@ -17965,7 +17965,7 @@ function isRecursive(inst, stack, resolve43) {
   let result = NONE;
   const check3 = (child) => {
     if (result !== PROVEN && child?._zod) {
-      const answer2 = isRecursive(child, stack, resolve43);
+      const answer2 = isRecursive(child, stack, resolve45);
       if (answer2 > result)
         result = answer2;
     }
@@ -17976,7 +17976,7 @@ function isRecursive(inst, stack, resolve43) {
       const desc = Object.getOwnPropertyDescriptor(sh, key);
       if (!desc.enumerable)
         continue;
-      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve43) : NONE;
+      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve45) : NONE;
       if (child > answer2)
         answer2 = child;
     }
@@ -18040,7 +18040,7 @@ function isRecursive(inst, stack, resolve43) {
       break;
     // `$ZodLazy` caches its inner on the def, so a resolved edge is followed exactly
     case "lazy": {
-      const inner = def._cachedInner ?? (resolve43 ? inst._zod.innerType : void 0);
+      const inner = def._cachedInner ?? (resolve45 ? inst._zod.innerType : void 0);
       merge2(inner ? isRecursive(inner, stack, false) : ASSUMED);
       break;
     }
@@ -33518,6 +33518,12 @@ init_esm_shims();
 // ../hook-runner/src/enforcement/shell-writes.ts
 init_esm_shims();
 
+// ../hook-runner/src/enforcement/shell-reads.ts
+init_esm_shims();
+
+// ../hook-runner/src/enforcement/secret-read.ts
+init_esm_shims();
+
 // ../hook-runner/src/enforcement/original-source.ts
 init_esm_shims();
 
@@ -33564,6 +33570,14 @@ function discoverProjectRoot(start) {
     current2 = parent;
   }
 }
+var DEFAULT_PROJECT_PATHS = {
+  business: ["src/**", "apps/*/src/**"],
+  tests: ["src/**/*.test.{ts,tsx}", "apps/*/src/**/*.test.{ts,tsx}"],
+  spikes: ["scripts/spike-*", "apps/*/scripts/spike-*"],
+  serverActions: ["src/app/(api|actions)/**", "apps/*/src/app/(api|actions)/**"],
+  contracts: ["src/lib/contracts/**", "apps/*/src/lib/contracts/**"],
+  e2e: ["tests/e2e/**", "apps/*/tests/e2e/**"]
+};
 
 // ../hook-runner/src/project-roots.ts
 var GIT_TIMEOUT_MS = 5e3;
@@ -36142,6 +36156,9 @@ function authorizedTargetedRequest(events, request, history) {
   const recoveredBlockers = writerBindingCorrectionFindings(events);
   return recovery !== void 0 && correction.seq > recovery.seq && count === 1 && reviewField(writer, "writerId") === original.writerId && binding3 !== void 0 && typeof binding3 === "object" && binding3 !== null && "completionEventId" in binding3 && binding3.completionEventId === previous.event.eventId && history.length === 1 && recoveredBlockers.length > 0 && sameMembers(recoveredBlockers.map((finding) => finding.findingId), knownBlockers.map((finding) => finding.findingId)) && events.filter((event) => event.kind === "lead-writer.requested" && reviewField(event, "actionKind") === "run-correction").length === 1 && events.filter((event) => event.kind === "specialist.requested" && event.subject === request.subject && event.seq > recovery.seq && event.seq <= request.seq).length === 1;
 }
+function hasBlockingReview(completion) {
+  return completion.review !== void 0 && completion.findings.some((finding) => finding.classification === "blocking") && completion.findings.every((finding) => finding.classification !== void 0);
+}
 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))
@@ -36152,7 +36169,7 @@ function canContinueNativeReview(events, request, contextId) {
   const prior = history.filter((item) => item !== void 0);
   const first = prior[0];
   const amendment = writerBindingRecovery(events);
-  if (!first || first.completion.review?.scope.kind !== "general" || first.completion.verdict !== "changes-requested" && !(first.completion.verdict === "degraded" && amendment && prior.length === 1) || amendment !== void 0 && prior.length !== 1 || 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)
+  if (!first || first.completion.review?.scope.kind !== "general" || !hasBlockingReview(first.completion) || amendment !== void 0 && prior.length !== 1 || 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);
@@ -36415,7 +36432,7 @@ function mergeFindings(completions2) {
 function decideStatus(input2) {
   if (input2.issues.length > 0)
     return "degraded";
-  if (input2.current.some((item) => item.completion.verdict === "degraded")) {
+  if (input2.current.some((item) => item.completion.verdict === "degraded" && (input2.correctionBatches === void 0 || !hasBlockingReview(item.completion) || !input2.findings.some((finding) => finding.classification === "blocking")))) {
     return "degraded";
   }
   if (input2.stale.length > 0) {
@@ -37266,17 +37283,17 @@ function admitStoppedMission(input2, projectedHistory = input2.stream.events) {
   const migration = validatedSpecialistContractMigrationBoundary(events);
   if (!migration.ok)
     return refuse3("invalid-migration-receipt", migration.reasons.join("; "));
-  const boundary = observation3.stage === "post-implementation" ? migration.migration : void 0;
-  if (boundary !== void 0 && observation3.contractVersions[boundary.receipt.specialistId] !== boundary.receipt.toVersion) {
+  const boundary2 = observation3.stage === "post-implementation" ? migration.migration : void 0;
+  if (boundary2 !== void 0 && observation3.contractVersions[boundary2.receipt.specialistId] !== boundary2.receipt.toVersion) {
     return refuse3("inconsistent-review", "Recovery must observe the authenticated effective specialist contract");
   }
   const reviewInput = {
     stage: observation3.stage,
     expectedSource: observation3.expectedSource,
-    ...boundary === void 0 ? {} : { contractMigration: {
-      specialistId: boundary.receipt.specialistId,
-      afterSeq: boundary.seq,
-      reviewRound: boundary.receipt.reviewRound
+    ...boundary2 === void 0 ? {} : { contractMigration: {
+      specialistId: boundary2.receipt.specialistId,
+      afterSeq: boundary2.seq,
+      reviewRound: boundary2.receipt.reviewRound
     } },
     ...stageStart === void 0 ? {} : { stageStartSeqExclusive: stageStart },
     ...lastWriter === void 0 ? {} : { afterSeqExclusive: lastWriter },
@@ -39210,13 +39227,16 @@ function decideReviewPhase(start, review, baseVerdict, stage) {
 }
 function boundedReceiptReasons(input2, start, events) {
   const lastWriter = writerCompletions(input2).at(-1)?.seq ?? 0;
+  const recovery = writerBindingRecovery(events);
+  const binding3 = recovery && record15(lifecycleField(recovery, "writerBinding"));
   return events.filter((event) => event.kind === "specialist.completed" && event.seq > lastWriter && event.subject === "core:independent-code-reviewer" && lifecycleField(event, "stage") === "post-implementation").flatMap((event) => {
     const result = parseSpecialistCompletionValue(lifecycleField(event, "completion"));
     const receipt2 = result?.review;
     if (result === void 0 || receipt2 === void 0 || input2.reviewSubject === void 0) {
       return ["Independent review requires its durable committed subject and reviewer receipt"];
     }
-    if (!sameReviewSubject(receipt2, input2.reviewSubject) || receipt2.taskId !== event.missionId || receipt2.writerId !== start.leadWriterId || receipt2.reviewerId === start.leadWriterId) {
+    const subject = binding3?.["completionEventId"] === event.eventId ? lifecycleField(event, "reviewSubject") : input2.reviewSubject;
+    if (!isReviewSubject(subject) || !sameReviewSubject(receipt2, subject) || receipt2.taskId !== event.missionId || receipt2.writerId !== start.leadWriterId || receipt2.reviewerId === start.leadWriterId) {
       return ["Independent review receipt does not match the observed task, commit, base, or writer"];
     }
     if (receipt2.provenance.kind === "native-context" && receipt2.provenance.contextId !== lifecycleField(event, "contextId")) {
@@ -39225,7 +39245,7 @@ function boundedReceiptReasons(input2, start, events) {
     if (result.findings.some((finding) => finding.classification === void 0)) {
       return ["Bounded findings require an explicit consequence classification"];
     }
-    return [];
+    return unboundCompletionReasons(input2, start.runtime, [event]);
   });
 }
 function recoveredPreparationTargets(events) {
@@ -39247,11 +39267,11 @@ function recoveredPreparationTargets(events) {
     specialistIds: events.filter((item) => item.kind === "specialist.completed" && ids.includes(item.eventId)).map((item) => item.subject)
   };
 }
-function retainedPreparationSpecialists(input2, events, boundary, targets) {
+function retainedPreparationSpecialists(input2, events, boundary2, targets) {
   return requiredSpecialists(input2.plan, "pre-implementation").filter((id4) => {
     if (targets.includes(id4))
       return false;
-    const latest = events.filter((item) => item.kind === "specialist.completed" && item.subject === id4 && item.seq < boundary && lifecycleField(item, "stage") === "pre-implementation").at(-1);
+    const latest = events.filter((item) => item.kind === "specialist.completed" && item.subject === id4 && item.seq < boundary2 && lifecycleField(item, "stage") === "pre-implementation").at(-1);
     if (latest === void 0)
       return false;
     const result = record15(lifecycleField(latest, "completion") ?? null);
@@ -39444,7 +39464,7 @@ function orchestrateMissionTeam(originalInput) {
       }, input2.specialistRuntime);
     }
   }
-  const postReview = firstImplementationSeq === void 0 || lastWriterSeq === void 0 ? void 0 : reduceReviewLoop({
+  let postReview = firstImplementationSeq === void 0 || lastWriterSeq === void 0 ? void 0 : reduceReviewLoop({
     stage: "post-implementation",
     expectedSource,
     stageStartSeqExclusive: firstImplementationSeq,
@@ -39470,27 +39490,26 @@ function orchestrateMissionTeam(originalInput) {
     if (canonicalJsonHash(subject) !== canonicalJsonHash(input2.reviewSubject) || canonicalJsonHash(observation3?.["currentInputHashes"]) !== canonicalJsonHash(Object.fromEntries(Object.keys(record15(observation3?.["currentInputHashes"] ?? null) ?? {}).map((id4) => [id4, input2.currentInputHashesByStage["post-implementation"][id4]])))) {
       return stopped("blocked", postReview, baseVerdict, ["Writer binding recovery observations changed before correction"]);
     }
-    const reasons = ["Author-confirmed writer binding permits one correction and one targeted continuation; original review remains degraded"];
-    return applyRuntimeCertification({
-      phase: "correction",
-      action: {
-        kind: "run-correction",
-        writerId: start.leadWriterId,
-        findingIds: writerBindingCorrectionFindings(reviewEvents).map((finding) => finding.findingId)
-      },
-      review: postReview,
-      verdict: overrideVerdict(baseVerdict, "blocked", reasons),
-      reasons
-    }, input2.specialistRuntime);
+    postReview = {
+      ...postReview,
+      status: "correction-required",
+      readyForVerdict: false,
+      findings: writerBindingCorrectionFindings(reviewEvents)
+    };
   }
   if (bindingRecovery && postReview && input2.stream.events.some((event) => event.seq > bindingRecovery.seq && event.kind === "specialist.completed") && !postReview.readyForVerdict) {
     return stopped("blocked", postReview, baseVerdict, ["The single targeted continuation is spent; retain the original review budget"]);
   }
+  if (start.boundedReview && postReview) {
+    const receiptReasons = boundedReceiptReasons(input2, start, reviewEvents);
+    if (receiptReasons.length > 0)
+      return stopped("degraded", postReview, baseVerdict, receiptReasons);
+  }
   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;
+  const correctiveContinuation = pendingEvidence !== void 0 && obligations.issues.length === 0 && firstImplementationSeq !== void 0 && (correctiveFindingIds.length > 0 || postReview?.status === "correction-required" && postReview.findings.some((finding) => finding.classification === "blocking"));
   if (pendingEvidence !== void 0 && !correctiveContinuation) {
     return applyRuntimeCertification(pendingEvidence, input2.specialistRuntime);
   }
@@ -39548,11 +39567,6 @@ function orchestrateMissionTeam(originalInput) {
   if (firstWriterSeq === void 0 || firstImplementationSeq === void 0 || lastWriterSeq === void 0 || postReview === void 0) {
     throw new Error("MISSION_TEAM_INVARIANT: writer completion boundary is missing");
   }
-  if (start.boundedReview && postReview.missingSpecialists.length === 0) {
-    const receiptReasons = boundedReceiptReasons(input2, start, reviewEvents);
-    if (receiptReasons.length > 0)
-      return stopped("degraded", postReview, baseVerdict, receiptReasons);
-  }
   if (postReview.readyForVerdict) {
     const completionEvidence = obligationStop(evidenceObligations(input2, expectedSource, "completion"), postReview, baseVerdict);
     if (completionEvidence !== void 0) {
@@ -41355,13 +41369,13 @@ function estimateTokens2(text8) {
 }
 var MAX_SOURCE_BYTES2 = 1024 * 1024;
 var MAX_DIRECTORY_ENTRIES = 1e4;
-function within2(boundary, target) {
-  const path3 = relative(boundary, target);
+function within2(boundary2, target) {
+  const path3 = relative(boundary2, target);
   return path3 === "" || !path3.startsWith("..") && !isAbsolute(path3);
 }
-function sourceNames(boundary, directory) {
+function sourceNames(boundary2, directory) {
   if (!existsSync(directory)) return [];
-  const canonicalBoundary = realpathSync(boundary);
+  const canonicalBoundary = realpathSync(boundary2);
   const metadata2 = lstatSync(directory);
   if (metadata2.isSymbolicLink()) {
     throw new Error(`GRAPH_SOURCE_PATH_ESCAPE: directory is a symlink: ${directory}`);
@@ -41376,13 +41390,13 @@ function sourceNames(boundary, directory) {
   }
   return names;
 }
-function sourceText(boundary, path3) {
+function sourceText(boundary2, path3) {
   if (!existsSync(path3)) return void 0;
   const metadata2 = lstatSync(path3);
   if (metadata2.isSymbolicLink()) {
     throw new Error(`GRAPH_SOURCE_PATH_ESCAPE: source is a symlink: ${path3}`);
   }
-  const canonicalBoundary = realpathSync(boundary);
+  const canonicalBoundary = realpathSync(boundary2);
   const canonicalPath = realpathSync(path3);
   if (!metadata2.isFile() || !within2(canonicalBoundary, canonicalPath)) {
     throw new Error(`GRAPH_SOURCE_PATH_ESCAPE: source leaves its declared root: ${path3}`);
@@ -41490,14 +41504,14 @@ function scanSourceTree(coreDir, packsDir) {
   }
   return { skills, agents: agents2, hooks, commands, packs, profiles, workflowDefs };
 }
-function readMdDir(boundary, dir, rel) {
-  return readDir(boundary, dir, ".md", rel);
+function readMdDir(boundary2, dir, rel) {
+  return readDir(boundary2, dir, ".md", rel);
 }
-function readDir(boundary, dir, ext, rel) {
+function readDir(boundary2, dir, ext, rel) {
   if (!existsSync(dir)) return [];
-  return sourceNames(boundary, dir).filter((f2) => f2.endsWith(ext)).flatMap((f2) => {
+  return sourceNames(boundary2, dir).filter((f2) => f2.endsWith(ext)).flatMap((f2) => {
     const full = join(dir, f2);
-    const text8 = sourceText(boundary, full);
+    const text8 = sourceText(boundary2, full);
     return text8 === void 0 ? [] : [{ name: f2.slice(0, -ext.length), source: rel(full), text: text8 }];
   });
 }
@@ -44011,6 +44025,432 @@ function observeKeptTracked(projectRoot2) {
   });
 }
 
+// src/lib/lint-exclusion.ts
+init_esm_shims();
+var import_picomatch = __toESM(require_picomatch2());
+
+// src/lib/void-migration.ts
+init_esm_shims();
+var EMPTY = Object.freeze({
+  moved: [],
+  conflicts: [],
+  parked: [],
+  gitignoreBlockRemoved: false
+});
+async function freeParkedName(target) {
+  if (!existsSync(`${target}.legacy`)) return `${target}.legacy`;
+  for (let attempt = 2; attempt < 100; attempt += 1) {
+    const candidate = `${target}.legacy.${String(attempt)}`;
+    if (!existsSync(candidate)) return candidate;
+  }
+  return `${target}.legacy.overflow`;
+}
+async function mergeInto(source2, destination) {
+  const info = await stat(source2);
+  if (!info.isDirectory()) {
+    if (!existsSync(destination)) {
+      await mkdir(join(destination, ".."), { recursive: true });
+      await rename(source2, destination);
+      return false;
+    }
+    await rename(source2, await freeParkedName(destination));
+    return true;
+  }
+  await mkdir(destination, { recursive: true });
+  let parked = false;
+  for (const entry of await readdir(source2)) {
+    if (await mergeInto(join(source2, entry), join(destination, entry))) parked = true;
+  }
+  await rm(source2, { recursive: true, force: true });
+  return parked;
+}
+function planVoidMigration(root) {
+  const movable = [];
+  const conflicts = [];
+  for (const entry of pendingMigrations(root)) {
+    if (existsSync(voidMachinePath(root, entry))) conflicts.push(entry);
+    else movable.push(entry);
+  }
+  return { movable, conflicts };
+}
+async function ownedInstallPaths(root) {
+  const manifestPath = join(root, ...INSTALL_MANIFEST_PATH.split("/"));
+  if (existsSync(manifestPath)) {
+    try {
+      const manifest = parseInstallManifest(await readFile(manifestPath, "utf8"));
+      if (manifest !== void 0) {
+        return new Set(manifest.files.map((file2) => file2.path));
+      }
+    } catch {
+    }
+  }
+  const receipt2 = await readInstallReceipt(root);
+  if (receipt2 === void 0) return void 0;
+  return new Set(receipt2.files.map((file2) => file2.path));
+}
+async function ownedDerivedPaths(root) {
+  const paths = await ownedInstallPaths(root);
+  return paths === void 0 ? void 0 : new Set([...paths].filter(isOwnedDerived));
+}
+async function untrackDerived(root, dryRun = false) {
+  const owned = await ownedDerivedPaths(root);
+  if (owned === void 0) {
+    return { untracked: [], error: "no readable install manifest or receipt \u2014 nothing here can be proven harness-owned" };
+  }
+  let listed;
+  try {
+    listed = execFileSync("git", ["ls-files", "-z", "--", ".void", ".claude", ".agents", ".codex"], {
+      cwd: root,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+  } catch {
+    return { untracked: [], error: "not a git repository, or git is unavailable" };
+  }
+  const untracked = listed.split("\0").filter((path3) => path3 !== "" && owned.has(path3.split("\\").join("/")));
+  if (untracked.length === 0 || dryRun) return { untracked };
+  try {
+    for (let index = 0; index < untracked.length; index += 200) {
+      execFileSync("git", ["rm", "--cached", "--quiet", "--", ...untracked.slice(index, index + 200)], {
+        cwd: root,
+        stdio: ["ignore", "ignore", "pipe"]
+      });
+    }
+  } catch (error62) {
+    return { untracked: [], error: error62 instanceof Error ? error62.message.split("\n")[0] ?? "git rm failed" : "git rm failed" };
+  }
+  return { untracked };
+}
+async function migrateVoidLayout(root, dryRun = false) {
+  if (!existsSync(join(root, ".void"))) return EMPTY;
+  const { movable, conflicts } = planVoidMigration(root);
+  if (!dryRun) writeExcludeBlock(root, [...await ownedDerivedPaths(root) ?? []]);
+  const gitignorePath = join(root, ".gitignore");
+  const original = existsSync(gitignorePath) ? await readFile(gitignorePath, "utf8") : "";
+  const stripped = stripManagedBlock(original);
+  const gitignoreBlockRemoved = stripped !== original;
+  const pending = [...movable, ...conflicts].sort();
+  const failed2 = [];
+  if (dryRun) return { moved: pending, conflicts: [], parked: [], gitignoreBlockRemoved };
+  if (pending.length > 0) {
+    await mkdir(voidMachineDir(root), { recursive: true });
+    await mkdir(voidInstalledDir(root), { recursive: true });
+  }
+  const moved = [];
+  const parked = [];
+  for (const entry of pending) {
+    try {
+      const sources = [legacyVoidPath(root, entry), previousMachinePath(root, entry)].filter((source2) => existsSync(source2));
+      if (ownershipOf(entry) === "derived") {
+        for (const source2 of sources) await rm(source2, { recursive: true, force: true });
+        if (sources.length > 0) moved.push(entry);
+        continue;
+      }
+      let touched = false;
+      for (const source2 of sources) {
+        if (await mergeInto(source2, voidMachinePath(root, migratedName(entry)))) touched = true;
+      }
+      if (touched) parked.push(entry);
+      moved.push(entry);
+    } catch {
+      failed2.push(entry);
+    }
+  }
+  try {
+    const previous = join(root, ".void", "local");
+    if (existsSync(previous)) {
+      for (const entry of await readdir(previous)) {
+        await mergeInto(join(previous, entry), voidMachinePath(root, entry));
+      }
+    }
+  } catch {
+  }
+  try {
+    const previous = join(root, ".void", "local");
+    if (existsSync(previous) && (await readdir(previous)).length === 0) {
+      await rm(previous, { recursive: true, force: true });
+    }
+  } catch {
+  }
+  if (gitignoreBlockRemoved) await writeFile(gitignorePath, stripped);
+  return { moved, conflicts: failed2.sort(), parked: parked.sort(), gitignoreBlockRemoved };
+}
+
+// src/lib/lint-exclusion.ts
+var BIOME_FILES = ["biome.json", "biome.jsonc"];
+var KNIP_FILES = [
+  "knip.json",
+  "knip.jsonc",
+  ".knip.json",
+  ".knip.jsonc",
+  "knip.ts",
+  "knip.js",
+  "knip.config.ts",
+  "knip.config.js"
+];
+var MAX_BIOME_CONFIG_READS = 32;
+var MAX_EXAMPLES = 5;
+var SCRIPT = /\.[cm]?[jt]sx?$/i;
+var BIOME_ASSET = /\.(?:[cm]?[jt]sx?|jsonc?|css|graphql|gql)$/i;
+var OTHER_LINTERS = [
+  "eslint.config.js",
+  "eslint.config.mjs",
+  "eslint.config.ts",
+  ".eslintrc.json",
+  ".eslintrc.cjs",
+  ".oxlintrc.json"
+];
+async function inspectHarnessLintExclusion(root) {
+  const checks = [];
+  const biome = BIOME_FILES.find((name) => existsSync(join(root, name)));
+  const knip = KNIP_FILES.find((name) => existsSync(join(root, name)));
+  const other = OTHER_LINTERS.find((name) => existsSync(join(root, name)));
+  const packageKnip = knip === void 0 ? await readPackageKnip(root) : void 0;
+  if (biome === void 0 && knip === void 0 && packageKnip === void 0 && other === void 0) {
+    return [{ name: "lint boundary", ok: true, status: "pass", message: "no analyzer config found" }];
+  }
+  const owned = await analyzerPaths(root);
+  if (biome !== void 0) {
+    const scope = await resolveBiomeIncludes(root, biome);
+    checks.push(owned.kind === "failure" ? manual("lint boundary", biome, owned.reason) : scope.kind === "failure" ? manual("lint boundary", biome, scope.reason) : inspectBiome(biome, owned.paths, scope.includes));
+  } else if (other !== void 0) {
+    checks.push(manual("lint boundary", other, "this analyzer configuration needs manual inspection"));
+  }
+  if (knip !== void 0 || packageKnip !== void 0) {
+    const file2 = knip ?? "package.json";
+    checks.push(owned.kind === "failure" ? manual("knip boundary", file2, owned.reason) : await inspectKnip(root, file2, owned.paths.filter((path3) => SCRIPT.test(path3)), packageKnip));
+  }
+  return checks;
+}
+async function analyzerPaths(root) {
+  const owned = await ownedInstallPaths(root);
+  if (owned === void 0) return { kind: "failure", reason: "ownership unknown: no valid manifest or receipt" };
+  const paths = [];
+  try {
+    const canonicalRoot = await realpath(root);
+    for (const path3 of [...owned].sort()) {
+      if (isCoOwned(path3) || classifyMaterialized(path3) !== "derived" || !BIOME_ASSET.test(path3)) continue;
+      const full = join(root, path3);
+      if (!existsSync(full)) continue;
+      if (!isInside(canonicalRoot, await realpath(full))) {
+        return { kind: "failure", reason: `owned path resolves outside the project: ${path3}` };
+      }
+      if ((await lstat(full)).isFile()) paths.push(path3);
+    }
+  } catch {
+    return { kind: "failure", reason: "cannot inspect owned analyzer files" };
+  }
+  return { kind: "paths", paths };
+}
+function inspectBiome(file2, paths, includes) {
+  const exposed = [];
+  for (const path3 of paths) {
+    const scope = harnessCanEnter(path3, includes);
+    if (scope.kind === "failure") return manual("lint boundary", file2, scope.reason);
+    if (scope.included) exposed.push(path3);
+  }
+  return boundary("lint boundary", file2, exposed, "files.includes", true);
+}
+async function readPackageKnip(root) {
+  if (!existsSync(join(root, "package.json"))) return void 0;
+  const parsed = await readAnalyzerConfig(root, "package.json");
+  return parsed.kind === "parsed" && isRecord6(parsed.value) ? parsed.value.knip : void 0;
+}
+async function readAnalyzerConfig(root, file2) {
+  try {
+    const canonicalRoot = await realpath(root);
+    const path3 = await realpath(join(root, file2));
+    if (!isInside(canonicalRoot, path3)) return { kind: "failure", reason: "config resolves outside the project" };
+    return { kind: "parsed", value: JSON.parse(await readFile(path3, "utf8")) };
+  } catch {
+    return { kind: "failure", reason: "config is unreadable or not plain JSON" };
+  }
+}
+async function inspectKnip(root, file2, paths, embedded) {
+  if (!file2.endsWith(".json") && !file2.endsWith(".jsonc")) {
+    return manual("knip boundary", file2, "executable configuration is not evaluated");
+  }
+  const read = embedded === void 0 ? await readAnalyzerConfig(root, file2) : { kind: "parsed", value: embedded };
+  if (read.kind === "failure") return manual("knip boundary", file2, read.reason);
+  if (!isRecord6(read.value)) return manual("knip boundary", file2, "config must be an object");
+  const config2 = read.value;
+  const unsupported = Object.keys(config2).some((key) => !["$schema", "ignore", "ignoreFiles"].includes(key));
+  const ignore = stringArray(config2.ignore);
+  const unused = stringArray(config2.ignoreFiles);
+  if (unsupported || ignore === "invalid" || unused === "invalid" || [...ignore ?? [], ...unused ?? []].some((pattern2) => pattern2.startsWith("!") || pattern2.endsWith("!") || pattern2.trim() === "")) {
+    return manual("knip boundary", file2, "unsupported static config or mode-specific patterns; inspect manually");
+  }
+  try {
+    const matches = (0, import_picomatch.default)([...ignore ?? []], { dot: true });
+    const check3 = boundary(
+      "knip boundary",
+      file2,
+      paths.filter((path3) => !matches(path3)),
+      file2 === "package.json" ? "knip.ignore" : "ignore",
+      false
+    );
+    return unused !== void 0 && check3.status === "advisory" ? { ...check3, message: `${check3.message}; ignoreFiles suppresses unused files only` } : check3;
+  } catch {
+    return manual("knip boundary", file2, "invalid ignore patterns");
+  }
+}
+function boundary(name, file2, exposed, field11, negate) {
+  if (exposed.length === 0) return { name, ok: true, status: "pass", message: `${file2}: no owned analyzer files exposed` };
+  const sample = exposed.slice(0, MAX_EXAMPLES);
+  const patterns2 = sample.map((path3) => `\`${negate ? "!" : ""}${path3}\``).join(", ");
+  const remainder = exposed.length > MAX_EXAMPLES ? `; inspect the remaining ${exposed.length - MAX_EXAMPLES} owned files in the install manifest` : "";
+  return {
+    name,
+    ok: true,
+    status: "advisory",
+    message: `${file2}: ${exposed.length} owned file(s) lack an explicit analyzer exclusion: ${sample.join(", ")}`,
+    fix: `review ${field11} in ${file2}: exclude ${patterns2}${remainder}` + (negate ? " (keep a positive pattern such as `**` before exclusions; a lone negation matches nothing in Biome)" : "") + "; keep project-owned neighbors in scope"
+  };
+}
+async function resolveBiomeIncludes(projectRoot2, configName) {
+  let canonicalRoot;
+  try {
+    canonicalRoot = await realpath(projectRoot2);
+  } catch {
+    return { kind: "failure", reason: "cannot read the project root" };
+  }
+  return readBiomeIncludes(canonicalRoot, join(canonicalRoot, configName), /* @__PURE__ */ new Set(), {
+    remaining: MAX_BIOME_CONFIG_READS
+  });
+}
+async function readBiomeIncludes(projectRoot2, configPath, ancestors, budget) {
+  if (budget.remaining === 0) {
+    return { kind: "failure", reason: `extends chain exceeds ${MAX_BIOME_CONFIG_READS} config reads` };
+  }
+  budget.remaining -= 1;
+  const boundedPath = resolve(configPath);
+  if (!isInside(projectRoot2, boundedPath)) {
+    return { kind: "failure", reason: `extended config is outside the project: ${configPath}` };
+  }
+  let canonicalPath;
+  let text8;
+  try {
+    canonicalPath = await realpath(boundedPath);
+    if (!isInside(projectRoot2, canonicalPath)) {
+      return { kind: "failure", reason: `extended config is outside the project: ${configPath}` };
+    }
+    text8 = await readFile(canonicalPath, "utf8");
+  } catch {
+    return { kind: "failure", reason: `cannot read extended config ${displayPath(projectRoot2, boundedPath)}` };
+  }
+  if (ancestors.has(canonicalPath)) {
+    return { kind: "failure", reason: `extends cycle at ${displayPath(projectRoot2, canonicalPath)}` };
+  }
+  const parsed = parseBiomeConfig(text8, displayPath(projectRoot2, canonicalPath));
+  if (parsed.kind === "failure") return parsed;
+  const nextAncestors = new Set(ancestors);
+  nextAncestors.add(canonicalPath);
+  let inheritedIncludes;
+  for (const extendedConfig of parsed.config.extendedConfigs) {
+    const inherited = await readBiomeIncludes(
+      projectRoot2,
+      resolve(dirname(canonicalPath), extendedConfig),
+      nextAncestors,
+      budget
+    );
+    if (inherited.kind === "failure") return inherited;
+    if (inherited.includes !== void 0) inheritedIncludes = inherited.includes;
+  }
+  return {
+    kind: "resolved",
+    includes: parsed.config.includes ?? inheritedIncludes
+  };
+}
+function parseBiomeConfig(text8, file2) {
+  let value;
+  try {
+    value = JSON.parse(text8);
+  } catch {
+    return { kind: "failure", reason: `${file2} is not plain JSON` };
+  }
+  if (!isRecord6(value)) return { kind: "failure", reason: `${file2} does not contain a JSON object` };
+  const extendedConfigs = extendedConfigList(value.extends);
+  if (extendedConfigs === "invalid") {
+    return { kind: "failure", reason: `${file2} has an invalid extends value` };
+  }
+  const files = value.files;
+  if (!isAbsent(files) && !isRecord6(files)) {
+    return { kind: "failure", reason: `${file2} has an invalid files value` };
+  }
+  const includesValue = isRecord6(files) ? files.includes : void 0;
+  const includes = stringArray(includesValue);
+  if (includes === "invalid") {
+    return { kind: "failure", reason: `${file2} has an invalid files.includes value` };
+  }
+  return {
+    kind: "parsed",
+    config: {
+      extendedConfigs: extendedConfigs ?? [],
+      includes
+    }
+  };
+}
+function extendedConfigList(value) {
+  if (isAbsent(value)) return void 0;
+  if (typeof value === "string") return [value];
+  return stringArray(value);
+}
+function stringArray(value) {
+  if (isAbsent(value)) return void 0;
+  if (!Array.isArray(value) || !value.every((entry) => typeof entry === "string")) return "invalid";
+  return value;
+}
+function harnessCanEnter(path3, includes) {
+  if (includes === void 0) return { kind: "scope", included: true };
+  let included = false;
+  for (const entry of includes) {
+    const parsed = parseInclude(entry);
+    if (parsed === void 0) {
+      return { kind: "failure", reason: `files.includes contains an empty pattern: ${JSON.stringify(entry)}` };
+    }
+    try {
+      const matches = (0, import_picomatch.default)(parsed.pattern, { dot: true });
+      const segments2 = path3.split("/");
+      const candidates = segments2.map((_, index) => segments2.slice(0, index + 1).join("/"));
+      if (candidates.some((candidate) => matches(candidate))) included = !parsed.excluded;
+    } catch {
+      return { kind: "failure", reason: `files.includes contains an invalid pattern: ${entry}` };
+    }
+  }
+  return { kind: "scope", included };
+}
+function parseInclude(entry) {
+  let pattern2 = entry.trim();
+  const excluded = pattern2.startsWith("!");
+  if (pattern2.startsWith("!!")) pattern2 = pattern2.slice(2);
+  else if (excluded) pattern2 = pattern2.slice(1);
+  if (pattern2.startsWith("./")) pattern2 = pattern2.slice(2);
+  return pattern2 === "" ? void 0 : { excluded, pattern: pattern2 };
+}
+function isRecord6(value) {
+  return Object.prototype.toString.call(value) === "[object Object]";
+}
+function isAbsent(value) {
+  return value === void 0 || Object.prototype.toString.call(value) === "[object Null]";
+}
+function isInside(root, candidate) {
+  const path3 = relative(root, candidate);
+  return path3 === "" || !isAbsolute(path3) && path3 !== ".." && !path3.startsWith(`..${sep}`);
+}
+function displayPath(root, path3) {
+  const displayed = relative(root, path3);
+  return displayed === "" ? "." : displayed;
+}
+function manual(name, file2, reason2) {
+  return {
+    name,
+    ok: true,
+    status: "unknown",
+    message: `${file2}: ${reason2}`,
+    fix: "inspect analyzer scope manually for attested harness assets; keep project-owned files in scope"
+  };
+}
+
 // ../../node_modules/.pnpm/@clack+prompts@1.5.0/node_modules/@clack/prompts/dist/index.mjs
 init_esm_shims();
 
@@ -45770,7 +46210,7 @@ async function readOrUndefined2(path3) {
     return void 0;
   }
 }
-function isRecord6(value) {
+function isRecord7(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 async function readHarnessMeta(skillDir) {
@@ -45778,7 +46218,7 @@ async function readHarnessMeta(skillDir) {
   if (text8 === void 0) return {};
   try {
     const parsed = (0, import_yaml4.parse)(text8);
-    if (isRecord6(parsed)) return parsed;
+    if (isRecord7(parsed)) return parsed;
   } catch {
   }
   return {};
@@ -45981,184 +46421,6 @@ async function smokeInstalledHook(hookPath, runtime2) {
   }
 }
 
-// src/lib/lint-exclusion.ts
-init_esm_shims();
-var import_picomatch = __toESM(require_picomatch2());
-var HARNESS_LINT_EXCLUSION = "!.claude";
-var BIOME_FILES = ["biome.json", "biome.jsonc"];
-var HARNESS_PROBES = [".claude", ".claude/workflows/autopilot.workflow.js"];
-var MAX_BIOME_CONFIG_READS = 32;
-var OTHER_LINTERS = [
-  "eslint.config.js",
-  "eslint.config.mjs",
-  "eslint.config.ts",
-  ".eslintrc.json",
-  ".eslintrc.cjs",
-  ".oxlintrc.json"
-];
-async function inspectHarnessLintExclusion(projectRoot2) {
-  const biome = BIOME_FILES.map((name) => join(projectRoot2, name)).find((path3) => existsSync(path3));
-  if (biome !== void 0) {
-    const name = relative(projectRoot2, biome);
-    const scope = await resolveBiomeIncludes(projectRoot2, name);
-    if (scope.kind === "failure") return manual(name, scope.reason);
-    const harnessScope = harnessCanEnter(scope.includes);
-    if (harnessScope.kind === "failure") return manual(name, harnessScope.reason);
-    if (!harnessScope.included) {
-      return { kind: "excluded", file: name };
-    }
-    return {
-      kind: "missing",
-      file: name,
-      instruction: `add \`${HARNESS_LINT_EXCLUSION}\` to files.includes in ${name} (keep a positive pattern such as \`**\` before it \u2014 a lone negation matches nothing in Biome)`
-    };
-  }
-  const other = OTHER_LINTERS.find((name) => existsSync(join(projectRoot2, name)));
-  if (other !== void 0) {
-    return manual(other, "this linter is configured in code");
-  }
-  return { kind: "no-linter" };
-}
-async function resolveBiomeIncludes(projectRoot2, configName) {
-  let canonicalRoot;
-  try {
-    canonicalRoot = await realpath(projectRoot2);
-  } catch {
-    return { kind: "failure", reason: "cannot read the project root" };
-  }
-  return readBiomeIncludes(canonicalRoot, join(canonicalRoot, configName), /* @__PURE__ */ new Set(), {
-    remaining: MAX_BIOME_CONFIG_READS
-  });
-}
-async function readBiomeIncludes(projectRoot2, configPath, ancestors, budget) {
-  if (budget.remaining === 0) {
-    return { kind: "failure", reason: `extends chain exceeds ${MAX_BIOME_CONFIG_READS} config reads` };
-  }
-  budget.remaining -= 1;
-  const boundedPath = resolve(configPath);
-  if (!isInside(projectRoot2, boundedPath)) {
-    return { kind: "failure", reason: `extended config is outside the project: ${configPath}` };
-  }
-  let canonicalPath;
-  let text8;
-  try {
-    canonicalPath = await realpath(boundedPath);
-    if (!isInside(projectRoot2, canonicalPath)) {
-      return { kind: "failure", reason: `extended config is outside the project: ${configPath}` };
-    }
-    text8 = await readFile(canonicalPath, "utf8");
-  } catch {
-    return { kind: "failure", reason: `cannot read extended config ${displayPath(projectRoot2, boundedPath)}` };
-  }
-  if (ancestors.has(canonicalPath)) {
-    return { kind: "failure", reason: `extends cycle at ${displayPath(projectRoot2, canonicalPath)}` };
-  }
-  const parsed = parseBiomeConfig(text8, displayPath(projectRoot2, canonicalPath));
-  if (parsed.kind === "failure") return parsed;
-  const nextAncestors = new Set(ancestors);
-  nextAncestors.add(canonicalPath);
-  let inheritedIncludes;
-  for (const extendedConfig of parsed.config.extendedConfigs) {
-    const inherited = await readBiomeIncludes(
-      projectRoot2,
-      resolve(dirname(canonicalPath), extendedConfig),
-      nextAncestors,
-      budget
-    );
-    if (inherited.kind === "failure") return inherited;
-    if (inherited.includes !== void 0) inheritedIncludes = inherited.includes;
-  }
-  return {
-    kind: "resolved",
-    includes: parsed.config.includes ?? inheritedIncludes
-  };
-}
-function parseBiomeConfig(text8, file2) {
-  let value;
-  try {
-    value = JSON.parse(text8);
-  } catch {
-    return { kind: "failure", reason: `${file2} is not plain JSON` };
-  }
-  if (!isRecord7(value)) return { kind: "failure", reason: `${file2} does not contain a JSON object` };
-  const extendedConfigs = extendedConfigList(value.extends);
-  if (extendedConfigs === "invalid") {
-    return { kind: "failure", reason: `${file2} has an invalid extends value` };
-  }
-  const files = value.files;
-  if (!isAbsent(files) && !isRecord7(files)) {
-    return { kind: "failure", reason: `${file2} has an invalid files value` };
-  }
-  const includesValue = isRecord7(files) ? files.includes : void 0;
-  const includes = stringArray(includesValue);
-  if (includes === "invalid") {
-    return { kind: "failure", reason: `${file2} has an invalid files.includes value` };
-  }
-  return {
-    kind: "parsed",
-    config: {
-      extendedConfigs: extendedConfigs ?? [],
-      includes
-    }
-  };
-}
-function extendedConfigList(value) {
-  if (isAbsent(value)) return void 0;
-  if (typeof value === "string") return [value];
-  return stringArray(value);
-}
-function stringArray(value) {
-  if (isAbsent(value)) return void 0;
-  if (!Array.isArray(value) || !value.every((entry) => typeof entry === "string")) return "invalid";
-  return value;
-}
-function harnessCanEnter(includes) {
-  if (includes === void 0) return { kind: "scope", included: true };
-  let included = false;
-  for (const entry of includes) {
-    const parsed = parseInclude(entry);
-    if (parsed === void 0) {
-      return { kind: "failure", reason: `files.includes contains an empty pattern: ${JSON.stringify(entry)}` };
-    }
-    try {
-      const matches = (0, import_picomatch.default)(parsed.pattern, { dot: true });
-      if (HARNESS_PROBES.some((probe) => matches(probe))) included = !parsed.excluded;
-    } catch {
-      return { kind: "failure", reason: `files.includes contains an invalid pattern: ${entry}` };
-    }
-  }
-  return { kind: "scope", included };
-}
-function parseInclude(entry) {
-  let pattern2 = entry.trim();
-  const excluded = pattern2.startsWith("!");
-  if (pattern2.startsWith("!!")) pattern2 = pattern2.slice(2);
-  else if (excluded) pattern2 = pattern2.slice(1);
-  if (pattern2.startsWith("./")) pattern2 = pattern2.slice(2);
-  return pattern2 === "" ? void 0 : { excluded, pattern: pattern2 };
-}
-function isRecord7(value) {
-  return Object.prototype.toString.call(value) === "[object Object]";
-}
-function isAbsent(value) {
-  return value === void 0 || Object.prototype.toString.call(value) === "[object Null]";
-}
-function isInside(root, candidate) {
-  const path3 = relative(root, candidate);
-  return path3 === "" || !isAbsolute(path3) && path3 !== ".." && !path3.startsWith(`..${sep}`);
-}
-function displayPath(root, path3) {
-  const displayed = relative(root, path3);
-  return displayed === "" ? "." : displayed;
-}
-function manual(file2, why2) {
-  return {
-    kind: "manual",
-    file: file2,
-    instruction: `${why2}: add \`${HARNESS_LINT_EXCLUSION}\` to ${file2} (after a positive pattern such as \`**\`) so the harness is not linted as project source`
-  };
-}
-
 // src/lib/plugin-cache.ts
 init_esm_shims();
 function wiredHooks(manifest) {
@@ -46712,14 +46974,10 @@ var claudeAdapter = {
       enabledPacks: ctx.enabledPacks,
       channel: ctx.source
     });
-    const lint = await inspectHarnessLintExclusion(ctx.installRoot);
-    const lintLine = lint.kind === "excluded" ? `${lint.file}: .claude excluded from lint` : lint.kind === "no-linter" ? "lint: no linter config found, nothing to exclude" : `lint: ${lint.file} lints .claude as project source`;
-    if (lint.kind === "missing" || lint.kind === "manual") nextSteps.push(lint.instruction);
     return {
       statusLines: [
         status3,
-        `CLAUDE.md: ${docResult}`,
-        lintLine
+        `CLAUDE.md: ${docResult}`
       ],
       nextSteps
     };
@@ -47211,14 +47469,7 @@ function buildDefaultConfig(seed) {
   const config2 = {
     packs: {},
     stack: { ...seed.stack },
-    paths: {
-      business: "apps/*/src/**",
-      tests: "apps/*/src/**/*.test.{ts,tsx}",
-      spikes: "apps/*/scripts/spike-*",
-      serverActions: "apps/*/src/app/(api|actions)/**",
-      contracts: "apps/*/src/lib/contracts/**",
-      e2e: "apps/*/tests/e2e/**"
-    },
+    paths: DEFAULT_PROJECT_PATHS,
     commands: commandsFor(seed.stack),
     modes: { tdd: "auto", codeReview: "auto" }
   };
@@ -47361,6 +47612,10 @@ async function init(args) {
     line(`${c.green(glyph.check)}  ${c.dim("transaction".padEnd(18))}${prepared.receipt.files.length} owned files committed + receipt written`);
     claimOwnedPaths(projectRoot2, prepared.receipt.files.map((file2) => file2.path));
     reportHiddenByProject(projectRoot2);
+    for (const check3 of await inspectHarnessLintExclusion(projectRoot2)) {
+      line(`${c.dim(check3.name.padEnd(18))}${check3.message}`);
+      if (check3.fix !== void 0) nextSteps.push(check3.fix);
+    }
     if (keptByProject.length > 0) {
       line(`${c.yellow("!")}  ${c.dim("kept".padEnd(18))}${keptByProject.length} skill(s) the project already had, left untouched`);
       for (const path3 of keptByProject.slice(0, 5)) line(c.dim(`     ${path3}`));
@@ -48483,7 +48738,7 @@ var FROZEN_MARKER = /frozen legacy (?:snapshot|landing page)/i;
 var RECENT_LIMIT = 5;
 var MAX_TITLE = 200;
 var MAX_INPUT2 = 2e6;
-var EMPTY = Object.freeze({
+var EMPTY2 = Object.freeze({
   format: "none",
   count: 0,
   recent: [],
@@ -48539,7 +48794,7 @@ function observeDecisions(input2) {
       liveMonolithEntries
     };
   }
-  if (monolithEntries.length === 0) return EMPTY;
+  if (monolithEntries.length === 0) return EMPTY2;
   return {
     format: frozen ? "frozen-monolith" : "live-monolith",
     count: monolithEntries.length,
@@ -49189,149 +49444,6 @@ function judgeLayout(observation3) {
   ]);
 }
 
-// src/lib/void-migration.ts
-init_esm_shims();
-var EMPTY2 = Object.freeze({
-  moved: [],
-  conflicts: [],
-  parked: [],
-  gitignoreBlockRemoved: false
-});
-async function freeParkedName(target) {
-  if (!existsSync(`${target}.legacy`)) return `${target}.legacy`;
-  for (let attempt = 2; attempt < 100; attempt += 1) {
-    const candidate = `${target}.legacy.${String(attempt)}`;
-    if (!existsSync(candidate)) return candidate;
-  }
-  return `${target}.legacy.overflow`;
-}
-async function mergeInto(source2, destination) {
-  const info = await stat(source2);
-  if (!info.isDirectory()) {
-    if (!existsSync(destination)) {
-      await mkdir(join(destination, ".."), { recursive: true });
-      await rename(source2, destination);
-      return false;
-    }
-    await rename(source2, await freeParkedName(destination));
-    return true;
-  }
-  await mkdir(destination, { recursive: true });
-  let parked = false;
-  for (const entry of await readdir(source2)) {
-    if (await mergeInto(join(source2, entry), join(destination, entry))) parked = true;
-  }
-  await rm(source2, { recursive: true, force: true });
-  return parked;
-}
-function planVoidMigration(root) {
-  const movable = [];
-  const conflicts = [];
-  for (const entry of pendingMigrations(root)) {
-    if (existsSync(voidMachinePath(root, entry))) conflicts.push(entry);
-    else movable.push(entry);
-  }
-  return { movable, conflicts };
-}
-async function ownedDerivedPaths(root) {
-  const manifestPath = join(root, ...INSTALL_MANIFEST_PATH.split("/"));
-  if (existsSync(manifestPath)) {
-    try {
-      const manifest = parseInstallManifest(await readFile(manifestPath, "utf8"));
-      if (manifest !== void 0) {
-        return new Set(manifest.files.map((file2) => file2.path).filter((path3) => isOwnedDerived(path3)));
-      }
-    } catch {
-    }
-  }
-  const receipt2 = await readInstallReceipt(root);
-  if (receipt2 === void 0) return void 0;
-  return new Set(receipt2.files.map((file2) => file2.path).filter((path3) => isOwnedDerived(path3)));
-}
-async function untrackDerived(root, dryRun = false) {
-  const owned = await ownedDerivedPaths(root);
-  if (owned === void 0) {
-    return { untracked: [], error: "no readable install manifest or receipt \u2014 nothing here can be proven harness-owned" };
-  }
-  let listed;
-  try {
-    listed = execFileSync("git", ["ls-files", "-z", "--", ".void", ".claude", ".agents", ".codex"], {
-      cwd: root,
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"]
-    });
-  } catch {
-    return { untracked: [], error: "not a git repository, or git is unavailable" };
-  }
-  const untracked = listed.split("\0").filter((path3) => path3 !== "" && owned.has(path3.split("\\").join("/")));
-  if (untracked.length === 0 || dryRun) return { untracked };
-  try {
-    for (let index = 0; index < untracked.length; index += 200) {
-      execFileSync("git", ["rm", "--cached", "--quiet", "--", ...untracked.slice(index, index + 200)], {
-        cwd: root,
-        stdio: ["ignore", "ignore", "pipe"]
-      });
-    }
-  } catch (error62) {
-    return { untracked: [], error: error62 instanceof Error ? error62.message.split("\n")[0] ?? "git rm failed" : "git rm failed" };
-  }
-  return { untracked };
-}
-async function migrateVoidLayout(root, dryRun = false) {
-  if (!existsSync(join(root, ".void"))) return EMPTY2;
-  const { movable, conflicts } = planVoidMigration(root);
-  if (!dryRun) writeExcludeBlock(root, [...await ownedDerivedPaths(root) ?? []]);
-  const gitignorePath = join(root, ".gitignore");
-  const original = existsSync(gitignorePath) ? await readFile(gitignorePath, "utf8") : "";
-  const stripped = stripManagedBlock(original);
-  const gitignoreBlockRemoved = stripped !== original;
-  const pending = [...movable, ...conflicts].sort();
-  const failed2 = [];
-  if (dryRun) return { moved: pending, conflicts: [], parked: [], gitignoreBlockRemoved };
-  if (pending.length > 0) {
-    await mkdir(voidMachineDir(root), { recursive: true });
-    await mkdir(voidInstalledDir(root), { recursive: true });
-  }
-  const moved = [];
-  const parked = [];
-  for (const entry of pending) {
-    try {
-      const sources = [legacyVoidPath(root, entry), previousMachinePath(root, entry)].filter((source2) => existsSync(source2));
-      if (ownershipOf(entry) === "derived") {
-        for (const source2 of sources) await rm(source2, { recursive: true, force: true });
-        if (sources.length > 0) moved.push(entry);
-        continue;
-      }
-      let touched = false;
-      for (const source2 of sources) {
-        if (await mergeInto(source2, voidMachinePath(root, migratedName(entry)))) touched = true;
-      }
-      if (touched) parked.push(entry);
-      moved.push(entry);
-    } catch {
-      failed2.push(entry);
-    }
-  }
-  try {
-    const previous = join(root, ".void", "local");
-    if (existsSync(previous)) {
-      for (const entry of await readdir(previous)) {
-        await mergeInto(join(previous, entry), voidMachinePath(root, entry));
-      }
-    }
-  } catch {
-  }
-  try {
-    const previous = join(root, ".void", "local");
-    if (existsSync(previous) && (await readdir(previous)).length === 0) {
-      await rm(previous, { recursive: true, force: true });
-    }
-  } catch {
-  }
-  if (gitignoreBlockRemoved) await writeFile(gitignorePath, stripped);
-  return { moved, conflicts: failed2.sort(), parked: parked.sort(), gitignoreBlockRemoved };
-}
-
 // src/commands/self-host.ts
 init_esm_shims();
 
@@ -50268,18 +50380,7 @@ async function doctor(args) {
       });
     }
   }
-  if (claudeDetected) {
-    const lint = await inspectHarnessLintExclusion(root);
-    checks.push(
-      lint.kind === "excluded" ? { name: "lint boundary", ok: true, message: `${lint.file}: .claude excluded from project lint` } : lint.kind === "no-linter" ? { name: "lint boundary", ok: true, message: "no linter config found, nothing to exclude" } : {
-        name: "lint boundary",
-        ok: true,
-        status: "advisory",
-        message: `${lint.file} lints .claude as project source; harness files are written in engine formats a JS parser rejects`,
-        fix: lint.instruction
-      }
-    );
-  }
+  checks.push(...await inspectHarnessLintExclusion(root));
   checks.push(checkEnforceWorkflow(root));
   if (claudeDetected && marketplaceInstall) {
     if (!skipRemote) {
@@ -50765,131 +50866,6 @@ async function hydrate(args) {
 
 // src/commands/check.ts
 init_esm_shims();
-var GH_REMOTE = {
-  fetchRemoteMarketplace,
-  fetchPinnedPluginVersion,
-  fetchRemotePhilosophy
-};
-async function check2(args, options2 = {}) {
-  const doctrine = args.includes("--doctrine");
-  const remote = options2.remote ?? GH_REMOTE;
-  const roots = resolveProjectRoots(options2.cwd);
-  const installRoot = roots.installRoot;
-  const where = remedyPrefix(roots);
-  const repo = await resolveMarketplaceRepo(installRoot);
-  const local = await readLocalConfig(installRoot);
-  banner("check");
-  meta3("marketplace", repo);
-  blank();
-  const marketplace = remote.fetchRemoteMarketplace(repo);
-  if (!marketplace.ok) {
-    status(`could not fetch remote marketplace: ${marketplace.error}`, "err");
-    line(c.dim("verify `gh auth status` and that you have access to the repo."));
-    process.exit(1);
-  }
-  const drift = reportVersionDrift(local, marketplace.value, repo, remote);
-  if (doctrine) {
-    blank();
-    await reportDoctrineDrift(installRoot, where, marketplace.value, repo, remote);
-  }
-  if (drift > 0) {
-    footer(
-      `${c.yellow(`${drift} plugin${drift > 1 ? "s" : ""} behind`)} ${glyph.emdash} run ${where}${c.bold(
-        `${PRODUCT_COMMAND} update`
-      )} ${c.dim("(refreshes the plugin cache + bumps the pins this check measures), then restart Claude Code")}`
-    );
-  } else {
-    footer(c.dim("all up to date"));
-  }
-}
-async function resolveMarketplaceRepo(installRoot) {
-  const settings = await readSettings(settingsPathFor(installRoot));
-  const entry = settings.extraKnownMarketplaces?.[MARKETPLACE_NAME];
-  if (entry && typeof entry === "object") {
-    const source2 = entry.source;
-    if (source2?.repo) return source2.repo;
-  }
-  return MARKETPLACE_REPO;
-}
-async function readLocalConfig(installRoot) {
-  const configPath = join(installRoot, ".void", "config.json");
-  if (!existsSync(configPath)) return {};
-  try {
-    return JSON.parse(await readFile(configPath, "utf8"));
-  } catch {
-    return {};
-  }
-}
-function reportVersionDrift(local, marketplace, marketplaceRepo, remote) {
-  const localVersions = {
-    [CORE_PLUGIN_NAME]: local.core
-  };
-  for (const pack2 of PACKS) {
-    localVersions[pack2.name] = local.packs?.[`@voidcorp/${pack2.name}`];
-  }
-  let drift = 0;
-  for (const plugin of marketplace.plugins) {
-    const declaredRaw = localVersions[plugin.name];
-    const localStr = declaredRaw ? normalizeVersion(declaredRaw) : glyph.emdash;
-    const remoteFetch = remote.fetchPinnedPluginVersion(plugin, marketplaceRepo);
-    if (!remoteFetch.ok) {
-      row({ mark: "info", label: plugin.name, versions: [localStr, glyph.emdash], suffix: c.dim(remoteFetch.error) });
-      continue;
-    }
-    const remoteStr = remoteFetch.value;
-    if (!declaredRaw) {
-      row({
-        mark: "info",
-        label: plugin.name,
-        versions: [localStr, remoteStr],
-        suffix: c.dim("not installed")
-      });
-    } else if (compareVersions(localStr, remoteStr) < 0) {
-      drift += 1;
-      row({
-        mark: "warn",
-        label: plugin.name,
-        versions: [localStr, remoteStr],
-        suffix: c.yellow("update available")
-      });
-    } else {
-      row({
-        mark: "ok",
-        label: plugin.name,
-        versions: [localStr, remoteStr],
-        suffix: c.dim("up to date")
-      });
-    }
-  }
-  return drift;
-}
-async function reportDoctrineDrift(installRoot, where, marketplace, marketplaceRepo, remote) {
-  const migrated = join(installRoot, ".void", "installed", "PHILOSOPHY.md");
-  const localPath = existsSync(migrated) ? migrated : join(installRoot, ".void", "PHILOSOPHY.md");
-  if (!existsSync(localPath)) {
-    status(`PHILOSOPHY.md missing locally \u2014 run ${where}\`${PRODUCT_COMMAND} init\` to install.`, "warn");
-    return;
-  }
-  const localText = await readFile(localPath, "utf8");
-  const fetched = remote.fetchRemotePhilosophy(marketplace, CORE_PLUGIN_NAME, marketplaceRepo);
-  if (!fetched.ok) {
-    status(`could not fetch remote PHILOSOPHY.md: ${fetched.error}`, "warn");
-    return;
-  }
-  if (normalizeNewlines(localText) === normalizeNewlines(fetched.value)) {
-    status(`PHILOSOPHY.md ${c.dim("in sync")}`);
-    return;
-  }
-  const localLines = localText.split("\n").length;
-  const remoteLines = fetched.value.split("\n").length;
-  status(
-    `PHILOSOPHY.md drift (local ${localLines}L, remote ${remoteLines}L) \u2014 run ${where}\`${PRODUCT_COMMAND} init\` to overwrite`,
-    "warn"
-  );
-}
-function normalizeNewlines(s) {
-  return s.replace(/\r\n/g, "\n").trimEnd();
-}
 
 // src/commands/update.ts
 init_esm_shims();
@@ -51149,7 +51125,7 @@ async function update(args) {
   }
   banner("update");
   renderLegacyRegistryNotice(legacyRegistryNotice);
-  const repo = await resolveMarketplaceRepo2(projectRoot2);
+  const repo = await resolveMarketplaceRepo(projectRoot2);
   meta3("marketplace", repo);
   const remote = fetchRemoteMarketplace(repo);
   if (!remote.ok) {
@@ -51505,7 +51481,7 @@ async function bumpPins(projectRoot2, head, dryRun) {
 `);
   return changes.length;
 }
-async function resolveMarketplaceRepo2(projectRoot2) {
+async function resolveMarketplaceRepo(projectRoot2) {
   const settings = await readSettings(settingsPathFor(projectRoot2));
   const entry = settings.extraKnownMarketplaces?.[MARKETPLACE_NAME];
   if (entry && typeof entry === "object") {
@@ -51515,6 +51491,166 @@ async function resolveMarketplaceRepo2(projectRoot2) {
   return MARKETPLACE_REPO;
 }
 
+// src/commands/check.ts
+var GH_REMOTE = {
+  fetchRemoteMarketplace,
+  fetchPinnedPluginVersion,
+  fetchRemotePhilosophy
+};
+async function check2(args, options2 = {}) {
+  const doctrine = args.includes("--doctrine");
+  const remote = options2.remote ?? GH_REMOTE;
+  const roots = resolveProjectRoots(options2.cwd);
+  const installRoot = roots.installRoot;
+  const where = remedyPrefix(roots);
+  const receipt2 = await readInstallReceipt(installRoot);
+  const hasManifest = existsSync(join(installRoot, INSTALL_MANIFEST_PATH));
+  const unknownChannel = receipt2 === void 0 && !hasManifest && await receiptEvidenceExists(installRoot);
+  const route = updateRouteFor(receipt2, hasManifest);
+  banner("check");
+  if (unknownChannel) {
+    status("unknown (install receipt is unreadable or invalid; installation channel cannot be established)", "warn");
+    if (!doctrine) return;
+    blank();
+  } else if (route !== "marketplace") {
+    const installed = receipt2?.version ?? readInstallManifest(installRoot)?.version ?? "unknown";
+    const freshness = await (options2.resolveFreshness ?? resolveFreshness)({
+      installed,
+      env: process.env,
+      now: Date.now(),
+      cwd: installRoot
+    });
+    const published2 = publishedVersionCheck(freshness, "local");
+    meta3("source", "bundled local package");
+    blank();
+    status(published2.message, published2.status === "pass" ? "ok" : "warn");
+    if (published2.fix !== void 0) line(c.dim(`${where}${published2.fix}`));
+    if (!doctrine) return;
+    blank();
+  }
+  const repo = await resolveMarketplaceRepo2(installRoot);
+  const local = await readLocalConfig(installRoot);
+  meta3("marketplace", repo);
+  blank();
+  const marketplace = remote.fetchRemoteMarketplace(repo);
+  if (!marketplace.ok) {
+    status(`could not fetch remote marketplace: ${marketplace.error}`, "err");
+    line(c.dim("verify `gh auth status` and that you have access to the repo."));
+    process.exit(1);
+  }
+  const drift = route === "marketplace" && !unknownChannel ? reportVersionDrift(local, marketplace.value, repo, remote) : 0;
+  if (doctrine) {
+    blank();
+    await reportDoctrineDrift(installRoot, where, marketplace.value, repo, remote);
+  }
+  if (route !== "marketplace" || unknownChannel) return;
+  if (drift > 0) {
+    footer(
+      `${c.yellow(`${drift} plugin${drift > 1 ? "s" : ""} behind`)} ${glyph.emdash} run ${where}${c.bold(
+        `${PRODUCT_COMMAND} update`
+      )} ${c.dim("(refreshes the plugin cache + bumps the pins this check measures), then restart Claude Code")}`
+    );
+  } else {
+    footer(c.dim("all up to date"));
+  }
+}
+async function receiptEvidenceExists(root) {
+  try {
+    await lstat(voidReadPath(root, "receipts", "install-v1.json"));
+    return true;
+  } catch (error62) {
+    return !(error62 instanceof Error && "code" in error62 && error62.code === "ENOENT");
+  }
+}
+async function resolveMarketplaceRepo2(installRoot) {
+  const settings = await readSettings(settingsPathFor(installRoot));
+  const entry = settings.extraKnownMarketplaces?.[MARKETPLACE_NAME];
+  if (entry && typeof entry === "object") {
+    const source2 = entry.source;
+    if (source2?.repo) return source2.repo;
+  }
+  return MARKETPLACE_REPO;
+}
+async function readLocalConfig(installRoot) {
+  const configPath = join(installRoot, ".void", "config.json");
+  if (!existsSync(configPath)) return {};
+  try {
+    return JSON.parse(await readFile(configPath, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function reportVersionDrift(local, marketplace, marketplaceRepo, remote) {
+  const localVersions = {
+    [CORE_PLUGIN_NAME]: local.core
+  };
+  for (const pack2 of PACKS) {
+    localVersions[pack2.name] = local.packs?.[`@voidcorp/${pack2.name}`];
+  }
+  let drift = 0;
+  for (const plugin of marketplace.plugins) {
+    const declaredRaw = localVersions[plugin.name];
+    const localStr = declaredRaw ? normalizeVersion(declaredRaw) : glyph.emdash;
+    const remoteFetch = remote.fetchPinnedPluginVersion(plugin, marketplaceRepo);
+    if (!remoteFetch.ok) {
+      row({ mark: "info", label: plugin.name, versions: [localStr, glyph.emdash], suffix: c.dim(remoteFetch.error) });
+      continue;
+    }
+    const remoteStr = remoteFetch.value;
+    if (!declaredRaw) {
+      row({
+        mark: "info",
+        label: plugin.name,
+        versions: [localStr, remoteStr],
+        suffix: c.dim("not installed")
+      });
+    } else if (compareVersions(localStr, remoteStr) < 0) {
+      drift += 1;
+      row({
+        mark: "warn",
+        label: plugin.name,
+        versions: [localStr, remoteStr],
+        suffix: c.yellow("update available")
+      });
+    } else {
+      row({
+        mark: "ok",
+        label: plugin.name,
+        versions: [localStr, remoteStr],
+        suffix: c.dim("up to date")
+      });
+    }
+  }
+  return drift;
+}
+async function reportDoctrineDrift(installRoot, where, marketplace, marketplaceRepo, remote) {
+  const migrated = join(installRoot, ".void", "installed", "PHILOSOPHY.md");
+  const localPath = existsSync(migrated) ? migrated : join(installRoot, ".void", "PHILOSOPHY.md");
+  if (!existsSync(localPath)) {
+    status(`PHILOSOPHY.md missing locally \u2014 run ${where}\`${PRODUCT_COMMAND} init\` to install.`, "warn");
+    return;
+  }
+  const localText = await readFile(localPath, "utf8");
+  const fetched = remote.fetchRemotePhilosophy(marketplace, CORE_PLUGIN_NAME, marketplaceRepo);
+  if (!fetched.ok) {
+    status(`could not fetch remote PHILOSOPHY.md: ${fetched.error}`, "warn");
+    return;
+  }
+  if (normalizeNewlines(localText) === normalizeNewlines(fetched.value)) {
+    status(`PHILOSOPHY.md ${c.dim("in sync")}`);
+    return;
+  }
+  const localLines = localText.split("\n").length;
+  const remoteLines = fetched.value.split("\n").length;
+  status(
+    `PHILOSOPHY.md drift (local ${localLines}L, remote ${remoteLines}L) \u2014 run ${where}\`${PRODUCT_COMMAND} init\` to overwrite`,
+    "warn"
+  );
+}
+function normalizeNewlines(s) {
+  return s.replace(/\r\n/g, "\n").trimEnd();
+}
+
 // src/commands/autopilot.ts
 init_esm_shims();
 
@@ -52489,9 +52625,9 @@ function resultHookWiring(settings) {
   return document.success ? stopWiring(document.data.hooks) : "missing";
 }
 function collect(stream2, onLimit) {
-  return new Promise((resolve43) => {
+  return new Promise((resolve45) => {
     if (stream2 === null) {
-      resolve43("");
+      resolve45("");
       return;
     }
     const chunks = [];
@@ -52504,18 +52640,18 @@ function collect(stream2, onLimit) {
       else
         chunks.push(bytes);
     });
-    stream2.once("close", () => resolve43(Buffer.concat(chunks).toString("utf8")));
-    stream2.once("error", () => resolve43(Buffer.concat(chunks).toString("utf8")));
+    stream2.once("close", () => resolve45(Buffer.concat(chunks).toString("utf8")));
+    stream2.once("error", () => resolve45(Buffer.concat(chunks).toString("utf8")));
   });
 }
 function runBounded(config2, args, cwd, timeoutMs) {
   const spawn4 = config2.spawn ?? ((executable2, argv, options2) => spawn(executable2, argv, options2));
-  return new Promise((resolve43) => {
+  return new Promise((resolve45) => {
     let child;
     try {
       child = spawn4(config2.executable, args, { cwd, env: config2.env, shell: false, stdio: ["ignore", "pipe", "pipe"] });
     } catch (error62) {
-      resolve43({ kind: "not-started", cause: error62 instanceof Error ? error62.message : String(error62) });
+      resolve45({ kind: "not-started", cause: error62 instanceof Error ? error62.message : String(error62) });
       return;
     }
     let timedOut = false;
@@ -52530,11 +52666,11 @@ function runBounded(config2, args, cwd, timeoutMs) {
     const output2 = Promise.all([collect(child.stdout, terminate), collect(child.stderr, terminate)]);
     child.once("error", (error62) => {
       clearTimeout(timer);
-      resolve43({ kind: "not-started", cause: error62 instanceof Error ? error62.message : String(error62) });
+      resolve45({ kind: "not-started", cause: error62 instanceof Error ? error62.message : String(error62) });
     });
     child.once("close", (code2) => {
       clearTimeout(timer);
-      void output2.then(([stdout, stderr]) => resolve43(timedOut ? { kind: "timed-out" } : { kind: "exited", code: typeof code2 === "number" ? code2 : void 0, stdout, stderr }));
+      void output2.then(([stdout, stderr]) => resolve45(timedOut ? { kind: "timed-out" } : { kind: "exited", code: typeof code2 === "number" ? code2 : void 0, stdout, stderr }));
     });
   });
 }
@@ -52950,7 +53086,7 @@ async function socketRefusal(socket) {
   return void 0;
 }
 function connect(socket, limits) {
-  return new Promise((resolve43) => {
+  return new Promise((resolve45) => {
     const ws = new wrapper_default(`ws+unix://${socket}:/`, {
       perMessageDeflate: false,
       handshakeTimeout: limits.timeouts.callMs,
@@ -52984,13 +53120,13 @@ function connect(socket, limits) {
       if (error62.code === "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH") {
         closeAll(`a reply of the Codex daemon exceeded the ${String(limits.maxFrameBytes)}-byte frame bound`);
       }
-      resolve43({
+      resolve45({
         cause: `the Codex daemon does not answer on ${socket}: ${printable2(error62.message, MESSAGE_MAX)}`,
         action: DAEMON_START
       });
     });
     ws.on("close", () => closeAll("the connection closed"));
-    ws.once("open", () => resolve43({
+    ws.once("open", () => resolve45({
       call(method, params, timeoutMs) {
         if (closed !== void 0)
           return Promise.resolve({ ok: false, kind: "closed", message: closed });
@@ -58250,13 +58386,13 @@ async function autopilotReview(argv, root) {
   }
 }
 function readAllStdin() {
-  return new Promise((resolve43, reject) => {
+  return new Promise((resolve45, reject) => {
     let data2 = "";
     process.stdin.setEncoding("utf8");
     process.stdin.on("data", (chunk) => {
       data2 += chunk;
     });
-    process.stdin.on("end", () => resolve43(data2));
+    process.stdin.on("end", () => resolve45(data2));
     process.stdin.on("error", reject);
   });
 }
@@ -60667,11 +60803,11 @@ function parseUntracked(output2) {
 function parseGitOwnership(output2, knownPaths) {
   const owners = {};
   for (const record32 of output2.split("").slice(1)) {
-    const boundary = record32.indexOf("");
-    if (boundary < 1) continue;
-    const owner = record32.slice(0, boundary);
+    const boundary2 = record32.indexOf("");
+    if (boundary2 < 1) continue;
+    const owner = record32.slice(0, boundary2);
     if (owner.length > 256 || containsControl2(owner)) continue;
-    const paths = record32.slice(boundary + 1).split("\0");
+    const paths = record32.slice(boundary2 + 1).split("\0");
     for (const rawPath of paths) {
       const path3 = rawPath.startsWith("\n") ? rawPath.slice(1) : rawPath;
       if (path3.length === 0) continue;
@@ -65993,7 +66129,7 @@ function requestedPort(args) {
 async function ui(args) {
   const launchToken = randomBytes(32).toString("base64url");
   banner("ui");
-  await new Promise((resolve43) => {
+  await new Promise((resolve45) => {
     const server = startCommandCenter({
       port: requestedPort(args),
       launchToken,
@@ -66011,7 +66147,7 @@ async function ui(args) {
       }
     });
     const stop2 = () => {
-      server.close(() => resolve43());
+      server.close(() => resolve45());
     };
     process.once("SIGINT", stop2);
     process.once("SIGTERM", stop2);
@@ -68908,7 +69044,7 @@ async function recordSpecialistRequests(root, missionId, envelopes, planHash) {
 init_esm_shims();
 
 // package.json
-var version2 = "7.0.1";
+var version2 = "7.0.2";
 
 // src/lib/runs/verify.ts
 var MAX_CAPTURE_BYTES = 64 * 1024;