@akagilnc/pi-workflow-roles 0.1.5583 → 0.1.5598

package/dist/acp-host/production-host.js

@@ -1200,7 +1200,7 @@ async function runEngineDetourOnce(input) {
   }
   const command = input.argv[0];
   const args = input.argv.slice(1);
-  return await new Promise((resolve22, reject) => {
+  return await new Promise((resolve21, reject) => {
     let settled = false;
     const signal = input.signal;
     const child = spawn(command, args, {
@@ -1216,7 +1216,7 @@ async function runEngineDetourOnce(input) {
     child.stderr.setEncoding("utf8").on("data", (chunk) => {
       stderr += chunk;
     });
-    const fail4 = (error) => {
+    const fail3 = (error) => {
       if (settled) return;
       settled = true;
       if (signal !== void 0) {
@@ -1230,10 +1230,10 @@ async function runEngineDetourOnce(input) {
       if (signal !== void 0) {
         signal.removeEventListener("abort", onAbort);
       }
-      resolve22(result);
+      resolve21(result);
     };
     const onAbort = () => {
-      fail4(signal !== void 0 ? abortReasonError(signal) : new Error("aborted"));
+      fail3(signal !== void 0 ? abortReasonError(signal) : new Error("aborted"));
       try {
         child.kill("SIGTERM");
       } catch {
@@ -1246,7 +1246,7 @@ async function runEngineDetourOnce(input) {
         signal.addEventListener("abort", onAbort, { once: true });
       }
     }
-    child.on("error", (error) => fail4(error));
+    child.on("error", (error) => fail3(error));
     child.on("close", (code) => {
       succeed({ code: code ?? 1, stdout, stderr });
     });
@@ -1608,85 +1608,8 @@ var init_fixer_output = __esm({
   }
 });
 
-// src/package-contracts/fixer-packet.ts
-import { Type as Type8 } from "typebox";
-import { Value } from "typebox/value";
-function causeMessage(cause) {
-  if (cause instanceof Error) return cause.message;
-  if (typeof cause === "string") return cause;
-  try {
-    return JSON.stringify(cause) ?? String(cause);
-  } catch {
-    return String(cause);
-  }
-}
-function fail(cause) {
-  throw new FixerPacketValidationError(cause);
-}
-function parseFailure(value) {
-  if (!Array.isArray(value)) fail(new Error("Fixer prerequisites must be a JSON array"));
-  for (const entry of value) {
-    if (!isRecord(entry)) {
-      fail(new Error("Fixer prerequisite entry must be an object with id and requirement fields"));
-    }
-    if (typeof entry.id !== "string" || !new RegExp(FIXER_PREREQUISITE_ID_PATTERN).test(entry.id)) {
-      fail(new Error(`Fixer prerequisite id violates pattern ${FIXER_PREREQUISITE_ID_PATTERN}`));
-    }
-    if (typeof entry.requirement !== "string" || !/\S/.test(entry.requirement)) {
-      fail(new Error("Fixer prerequisite requirement must be nonblank"));
-    }
-  }
-  fail(new Error("Fixer prerequisites violate the attachment schema"));
-}
-function validateFixerPrerequisites(value) {
-  if (!Value.Check(fixerPrerequisitesSchema, value)) parseFailure(value);
-  const entries = value;
-  const ids = /* @__PURE__ */ new Set();
-  const prerequisites = entries.map((entry) => {
-    if (ids.has(entry.id)) {
-      fail(new Error(`Fixer prerequisites contain duplicate id: ${entry.id}`));
-    }
-    ids.add(entry.id);
-    return Object.freeze({ id: entry.id, requirement: entry.requirement });
-  });
-  return Object.freeze(prerequisites);
-}
-function parseFixerPrerequisites(source) {
-  let decoded;
-  try {
-    decoded = JSON.parse(source);
-  } catch (error) {
-    fail(error);
-  }
-  return validateFixerPrerequisites(decoded);
-}
-var FIXER_PREREQUISITE_ID_PATTERN, fixerPrerequisiteSchema, fixerPrerequisitesSchema, FixerPacketValidationError;
-var init_fixer_packet = __esm({
-  "src/package-contracts/fixer-packet.ts"() {
-    "use strict";
-    init_unknown_value();
-    FIXER_PREREQUISITE_ID_PATTERN = "^[A-Za-z0-9][A-Za-z0-9._-]*$";
-    fixerPrerequisiteSchema = Type8.Object({
-      id: Type8.String({ pattern: FIXER_PREREQUISITE_ID_PATTERN }),
-      requirement: Type8.String({ pattern: "\\S" })
-    });
-    fixerPrerequisitesSchema = Type8.Array(fixerPrerequisiteSchema);
-    FixerPacketValidationError = class extends Error {
-      code = "AK_INVALID_FIX_PACKET";
-      constructor(cause) {
-        const prefix = "Fixer prerequisites or instructions violate the invocation contract";
-        super(
-          cause === void 0 ? prefix : `${prefix}: ${causeMessage(cause)}`,
-          cause === void 0 ? void 0 : { cause }
-        );
-        this.name = "FixerPacketValidationError";
-      }
-    };
-  }
-});
-
 // src/package-contracts/worker-output.ts
-import { Type as Type9 } from "typebox";
+import { Type as Type8 } from "typebox";
 function validateAcceptedCoderDetails(output) {
   return output;
 }
@@ -1699,15 +1622,14 @@ var init_worker_output = __esm({
     "use strict";
     init_open_tool_schema();
     init_fixer_output();
-    init_fixer_packet();
     init_terminating_infrastructure();
     CODER_OUTPUT_TOOL_NAME = "ak_coder_output";
     CODER_STATUS_DESCRIPTION = `planned | completed | refused | partially_completed | unfinished\u3002unfinished\uFF1A\u7F3A\u524D\u7F6E\u6216\u8FDD\u5BAA\u7EA6\u675F\u81F4\u672C\u5C40\u672A\u5B8C\u6210\u3002${PARTIALLY_COMPLETED_DEFINITION}`;
-    coderOutputObject = Type9.Object({
-      status: Type9.Unknown({ description: CODER_STATUS_DESCRIPTION }),
-      report: Type9.Unknown({ description: "\u5982\u5B9E\u7ED3\u679C\u62A5\u544A" }),
-      remainingScope: Type9.Unknown({ description: "\u672C\u5C40\u540E\u5269\u4F59\u5DE5\u4F5C" }),
-      reason: Type9.Unknown({
+    coderOutputObject = Type8.Object({
+      status: Type8.Unknown({ description: CODER_STATUS_DESCRIPTION }),
+      report: Type8.Unknown({ description: "\u5982\u5B9E\u7ED3\u679C\u62A5\u544A" }),
+      remainingScope: Type8.Unknown({ description: "\u672C\u5C40\u540E\u5269\u4F59\u5DE5\u4F5C" }),
+      reason: Type8.Unknown({
         description: "\u963B\u65AD\u539F\u56E0\uFF1A\u7F3A\u524D\u7F6E\u6216\u8FDD\u5BAA\u7EA6\u675F\u3002\u7F3A\u5F85\u51B3 owner \u51B3\u5B9A\u6216\u7B54\u590D\u5C5E\u7F3A\u524D\u7F6E\u3002"
       })
     });
@@ -1725,7 +1647,7 @@ var init_canonical_json = __esm({
 });
 
 // src/doctor-contracts.ts
-import { Type as Type10 } from "typebox";
+import { Type as Type9 } from "typebox";
 function validateDoctorSubmissionShape(value) {
   return value;
 }
@@ -1751,25 +1673,25 @@ var init_doctor_contracts = __esm({
     biteNone = "noRealBite";
     DOCTOR_BITE_KINDS = [biteActual, biteNone];
     DOCTOR_STATUS_DESCRIPTION = "completed | refused\u3002completed \u5141\u8BB8\u7A7A findings\uFF1Brefused \u4EC5\u5F53\u8BC1\u636E\u4E0D\u8DB3\u4EE5\u652F\u6491\u5982\u5B9E\u6848\u8BC1\u8BCD";
-    doctorSubmissionObject = Type10.Object({
-      status: Type10.Unknown({ description: DOCTOR_STATUS_DESCRIPTION }),
-      case: Type10.Unknown({
+    doctorSubmissionObject = Type9.Object({
+      status: Type9.Unknown({ description: DOCTOR_STATUS_DESCRIPTION }),
+      case: Type9.Unknown({
         description: "\u7559\u5B58\u592A\u533B\u7F72\u6848\u8EAB\u4EFD\uFF0C\u539F\u6837\u7559\u5B58\uFF08\u5982 issueNumber\u3001runsPath\uFF09\u3002\u673A\u68B0\u5C42\u53E6\u6309\u7ED1\u5B9A run \u6295\u5F71\u6848\u8EAB\u4EFD\uFF0C\u4E0D\u5728\u672C\u5B57\u6BB5\u91CD\u5224\u3002"
       }),
-      findings: Type10.Unknown({
+      findings: Type9.Unknown({
         description: `\u9010\u6761\u8D44\u4EA7\u89C2\u5BDF\u4E0E\u5904\u65B9\uFF0C\u539F\u6837\u7559\u5B58\u3002\u4E00\u6761\u53EF\u542B targetKey\u3001targetKind\uFF08${DOCTOR_TARGET_KINDS.join(" | ")}\uFF09\u3001observation\u3001evidenceIds\u3001disposition\uFF08${DOCTOR_DISPOSITIONS.join(" | ")}\uFF09\u3001assetEvidence\uFF08targetKey\u3001targetKind\u3001evidenceId\uFF09\u3001guardrails\uFF08reproducibleFailure\u3001owningSeamOrInvariant\u3001deletionOrSimplificationSuffices\uFF0C\u5404\u9879\u53EF\u542B answer\u3001evidenceIds\u3001explanation\uFF09\u3001prescription\uFF08kind \u4E3A ${DOCTOR_PRESCRIPTION_KINDS.join(" | ")}\uFF0C\u53E6\u53EF\u5199 recommendation\u3001necessityExplanation\uFF09\u3001lastRealBite\uFF08kind \u4E3A ${DOCTOR_BITE_KINDS.join(" | ")}\uFF0C\u53E6\u53EF\u5199 targetKey\u3001evidenceId\u3001eligibleEvidenceIds\uFF09\u3002\u4E0D\u8981\u6C42\u4EFB\u4F55\u5904\u65B9\u6216\u53EF\u590D\u7528 finding\uFF1B\u7F3A\u53EF\u590D\u7528\u8D44\u4EA7\u6216 bounded-bite \u8BC1\u636E\u53EA\u6392\u9664\u5BF9\u5E94\u8D44\u4EA7\u5904\u65B9\u3002\u673A\u5668\u4E0D\u6838\u9A8C\u3002`
       }),
-      reason: Type10.Unknown({
+      reason: Type9.Unknown({
         description: "\u8BC1\u636E\u4E0D\u8DB3\u4EE5\u652F\u6491\u5982\u5B9E\u8BC1\u8BCD\u7684\u539F\u56E0\uFF1B\u4EC5 refused \u65F6\u7528\u3002"
       }),
-      missingEvidence: Type10.Unknown({
+      missingEvidence: Type9.Unknown({
         description: "\u5982\u5B9E\u8BC1\u8BCD\u6240\u9700\u800C\u5C1A\u7F3A\u7684\u8BC1\u636E\uFF0C\u539F\u6837\u7559\u5B58\uFF08\u5982\u6BCF\u9879 need\u3001targetKeys\uFF09\u3002"
       })
     });
     doctorSubmissionSchema = withTerminatingOutputDeclarations(
       openToolObject(doctorSubmissionObject)
     );
-    doctorEvidenceReadSchema = Type10.Object({ evidenceId: Type10.String({ minLength: 1, description: "\u5F85\u8BFB\u7559\u5B58\u8BC1\u636E\u6807\u8BC6" }), offset: Type10.Optional(Type10.Integer({ minimum: 0, description: "\u8D77\u59CB\u5B57\u8282\u504F\u79FB\uFF08\u4ECE 0 \u8BA1\uFF09" })), limit: Type10.Optional(Type10.Integer({ minimum: 1, description: "\u8FD4\u56DE\u5B57\u8282\u6570\uFF08\u65E0\u4E0A\u9650\uFF09" })) }, { additionalProperties: true });
+    doctorEvidenceReadSchema = Type9.Object({ evidenceId: Type9.String({ minLength: 1, description: "\u5F85\u8BFB\u7559\u5B58\u8BC1\u636E\u6807\u8BC6" }), offset: Type9.Optional(Type9.Integer({ minimum: 0, description: "\u8D77\u59CB\u5B57\u8282\u504F\u79FB\uFF08\u4ECE 0 \u8BA1\uFF09" })), limit: Type9.Optional(Type9.Integer({ minimum: 1, description: "\u8FD4\u56DE\u5B57\u8282\u6570\uFF08\u65E0\u4E0A\u9650\uFF09" })) }, { additionalProperties: true });
     DoctorEvidenceStore = class {
       constructor(patient) {
         this.patient = patient;
@@ -1838,8 +1760,8 @@ var init_exact_utf8 = __esm({
 });
 
 // src/merger-contracts.ts
-import { Type as Type11 } from "typebox";
-function fail2(message = "Merger input violates its exact contract") {
+import { Type as Type10 } from "typebox";
+function fail(message = "Merger input violates its exact contract") {
   throw new MergerInputContractError(message);
 }
 function deepFreeze(value) {
@@ -1850,14 +1772,17 @@ function deepFreeze(value) {
   return value;
 }
 function readMaterial(value, label) {
-  if (!isRecord(value) || typeof value.bytesBase64 !== "string") fail2(`Merger ${label} material is malformed`);
+  if (!isRecord(value) || typeof value.bytesBase64 !== "string") fail(`Merger ${label} material is malformed`);
   exactUtf8(Buffer.from(value.bytesBase64, "base64"), `Merger ${label} material`);
   return { bytesBase64: value.bytesBase64, sha256: typeof value.sha256 === "string" ? value.sha256 : "" };
 }
 function validateMergerInput(value) {
-  if (!isRecord(value) || blank(value.attemptId)) fail2("Merger input requires a non-empty attemptId for accounting");
-  if (!isRecord(value.materials)) fail2("Merger materials are missing");
-  const materials = { task: readMaterial(value.materials.task, "task"), authority: readMaterial(value.materials.authority, "authority"), targetIntent: readMaterial(value.materials.targetIntent, "targetIntent"), sourceIntent: readMaterial(value.materials.sourceIntent, "sourceIntent") };
+  if (!isRecord(value) || blank(value.attemptId)) fail("Merger input requires a non-empty attemptId for accounting");
+  if (!isRecord(value.materials)) fail("Merger materials are missing");
+  const materials = {
+    targetIntent: readMaterial(value.materials.targetIntent, "targetIntent"),
+    sourceIntent: readMaterial(value.materials.sourceIntent, "sourceIntent")
+  };
   const authorizedChecks = Array.isArray(value.authorizedChecks) ? value.authorizedChecks.filter((check) => isRecord(check)).map((c) => ({ name: asString(c.name), argv: asStringArray(c.argv).filter((a) => a.trim().length > 0) })).filter((c) => c.name.trim().length > 0 && c.argv.length > 0) : [];
   return deepFreeze(structuredClone({ attemptId: value.attemptId.trim(), targetObjectId: asString(value.targetObjectId), sourceObjectId: asString(value.sourceObjectId), materials, expectedConflictPaths: asStringArray(value.expectedConflictPaths), resolutionScope: asStringArray(value.resolutionScope), authorizedChecks }));
 }
@@ -1869,24 +1794,25 @@ var init_merger_contracts = __esm({
     init_open_tool_schema();
     init_terminating_infrastructure();
     init_unknown_value();
-    materialSchema = Type11.Object({ bytesBase64: Type11.String(), sha256: Type11.String() });
-    checkSchema = Type11.Object({ name: Type11.String({ minLength: 1 }), argv: Type11.Array(Type11.String({ minLength: 1 }), { minItems: 1 }) });
-    mergerInputSchema = Type11.Object({
-      attemptId: Type11.String({ minLength: 1, description: "\u5BF9\u8D26 attempt \u8EAB\u4EFD\uFF08transport\uFF09" }),
-      targetObjectId: Type11.String({ description: "\u6750\u6599\uFF1Atarget parent OID\uFF1B\u53EF\u7A7A" }),
-      sourceObjectId: Type11.String({ description: "\u6750\u6599\uFF1Asource parent OID\uFF1B\u53EF\u7A7A" }),
-      materials: Type11.Object({ task: materialSchema, authority: materialSchema, targetIntent: materialSchema, sourceIntent: materialSchema }),
-      expectedConflictPaths: Type11.Array(Type11.String(), { description: "\u6750\u6599\uFF1A\u5F53\u524D\u672A\u5408\u5E76\u8DEF\u5F84\uFF1B\u53EF\u7A7A" }),
-      resolutionScope: Type11.Array(Type11.String(), { description: "\u6750\u6599\uFF1A\u89E3\u6790\u8303\u56F4\u63D0\u793A\uFF1B\u53EF\u7A7A" }),
-      authorizedChecks: Type11.Array(checkSchema)
+    materialSchema = Type10.Object({ bytesBase64: Type10.String(), sha256: Type10.String() });
+    checkSchema = Type10.Object({ name: Type10.String({ minLength: 1 }), argv: Type10.Array(Type10.String({ minLength: 1 }), { minItems: 1 }) });
+    mergerInputSchema = Type10.Object({
+      attemptId: Type10.String({ minLength: 1, description: "\u5BF9\u8D26 attempt \u8EAB\u4EFD\uFF08transport\uFF09" }),
+      targetObjectId: Type10.String({ description: "\u6750\u6599\uFF1Atarget parent OID\uFF1B\u53EF\u7A7A" }),
+      sourceObjectId: Type10.String({ description: "\u6750\u6599\uFF1Asource parent OID\uFF1B\u53EF\u7A7A" }),
+      // #1168: task/authority dispatch copies removed; git-fact intents remain.
+      materials: Type10.Object({ targetIntent: materialSchema, sourceIntent: materialSchema }),
+      expectedConflictPaths: Type10.Array(Type10.String(), { description: "\u6750\u6599\uFF1A\u5F53\u524D\u672A\u5408\u5E76\u8DEF\u5F84\uFF1B\u53EF\u7A7A" }),
+      resolutionScope: Type10.Array(Type10.String(), { description: "\u6750\u6599\uFF1A\u89E3\u6790\u8303\u56F4\u63D0\u793A\uFF1B\u53EF\u7A7A" }),
+      authorizedChecks: Type10.Array(checkSchema)
     });
     MERGER_STATUS_DESCRIPTION = "completed | escalate";
-    mergerOutputObject = Type11.Object({
-      status: Type11.Unknown({ description: MERGER_STATUS_DESCRIPTION }),
-      attemptId: Type11.Unknown({ description: "\u5DF2\u53D7\u7406\u5408\u5E76 attempt \u8EAB\u4EFD" }),
-      report: Type11.Unknown({ description: "\u5982\u5B9E\u7ED3\u679C\u62A5\u544A" }),
-      mergeCommitId: Type11.Unknown({ description: "\u5B8C\u6210\u5408\u5E76 commit object ID" }),
-      diagnosis: Type11.Unknown({
+    mergerOutputObject = Type10.Object({
+      status: Type10.Unknown({ description: MERGER_STATUS_DESCRIPTION }),
+      attemptId: Type10.Unknown({ description: "\u5DF2\u53D7\u7406\u5408\u5E76 attempt \u8EAB\u4EFD" }),
+      report: Type10.Unknown({ description: "\u5982\u5B9E\u7ED3\u679C\u62A5\u544A" }),
+      mergeCommitId: Type10.Unknown({ description: "\u5B8C\u6210\u5408\u5E76 commit object ID" }),
+      diagnosis: Type10.Unknown({
         description: "\u5408\u5E76\u65E0\u6CD5\u6216\u4E0D\u5E94\u7531\u672C\u5E2D\u5B8C\u6210\u7684\u539F\u56E0\uFF08\u542B\u65E0\u8FDB\u884C\u4E2D\u5408\u5E76\u3001\u65E0\u6D3B\u53EF\u5E72\u3001\u9700\u65B0\u7684\u4EA7\u54C1/\u6743\u529B\u51B3\u5B9A\uFF09"
       })
     });
@@ -1941,7 +1867,7 @@ var init_countersign_contracts = __esm({
 });
 
 // src/gleaner-left-contracts.ts
-import { Type as Type12 } from "typebox";
+import { Type as Type11 } from "typebox";
 var GLEANER_LEFT_OUTPUT_TOOL_NAME, gleanerLeftOutputSchema, GLEANER_LEFT_BASE_FLAG;
 var init_gleaner_left_contracts = __esm({
   "src/gleaner-left-contracts.ts"() {
@@ -1952,11 +1878,11 @@ var init_gleaner_left_contracts = __esm({
     GLEANER_LEFT_OUTPUT_TOOL_NAME = "ak_gleaner_left_output";
     gleanerLeftOutputSchema = withTerminatingOutputDeclarations(
       openToolObject(
-        Type12.Object({
-          status: Type12.Unknown({
+        Type11.Object({
+          status: Type11.Unknown({
             description: "completed"
           }),
-          findings: Type12.Unknown({
+          findings: Type11.Unknown({
             description: "\u5F39\u7AE0\u5217\u8868\uFF1B\u6BCF\u6761\u53EF\u542B pointer\uFF08\u6587\u4EF6/\u884C\u6307\u9488\uFF09\u4E0E statement\uFF08\u7591\u70B9\u9648\u8FF0\uFF09\uFF0C\u539F\u6837\u7559\u5B58\u3002\u7A7A\u5217\u8868\u5408\u6CD5\u5B8C\u5C40\uFF1B\u673A\u5668\u4E0D\u5224\u5F39\u7AE0\u662F\u5426\u6210\u7ACB\u3002"
           })
         })
@@ -2044,7 +1970,7 @@ var init_ticket_provenance_contracts = __esm({
 });
 
 // src/diarist-contracts.ts
-import { Type as Type13 } from "typebox";
+import { Type as Type12 } from "typebox";
 function projectDiaristSessions(value) {
   const raw = value?.sessions;
   if (raw === void 0) return [];
@@ -2077,20 +2003,20 @@ var init_diarist_contracts = __esm({
     DIARIST_SESSIONS_DESCRIPTION = "\u5BF9\u8BDD\u8FB9\u754C\u3002\u6BCF\u5377\u542B path\uFF08\u4F1A\u8BDD\u5377\u7EDD\u5BF9\u6216\u53EF\u8BFB\u8DEF\u5F84\uFF09\u4E0E ranges\uFF08\u672C\u5377\u672C\u8F6E\u5404\u533A\u95F4\uFF09\u3002\u6BCF\u6BB5\u533A\u95F4\u542B from / to\uFF1B\u8D77\u70B9\u4E0E\u7EC8\u70B9\u5404\u5199 id\uFF08\u539F\u751F id\uFF09\u6216 line\uFF08\u672C\u8F6E\u884C\u53F7\uFF09\uFF0C\u4E8C\u9009\u4E00\u3002\u7A7A\u5217\u8868\uFF1D\u672C\u8F6E\u65E0\u5BF9\u8BDD\u53EF\u5212\u3002\u7AEF\u70B9\u65E0\u6CD5\u6307\u540D\u65F6\u8D70 reask\uFF0C\u4E0D\u4E2D\u6B62\u3002";
     diaristOutputSchema = withTerminatingOutputDeclarations(
       openToolObject(
-        Type13.Object({
-          status: Type13.Unknown({
+        Type12.Object({
+          status: Type12.Unknown({
             description: "completed | escalate"
           }),
-          ticketNumber: Type13.Optional(
-            Type13.Unknown({
+          ticketNumber: Type12.Optional(
+            Type12.Unknown({
               description: "\u672C\u5EAD\u5BF9\u8C61\u7968\u53F7\uFF08\u6B63\u6574\u6570\uFF09\u6216 null/\u7701\u7565\uFF1D\u771F\u65E0\u7968\uFF1B\u4E0B\u6E38\u8D70 typed \u952E\uFF1B\u8BA4\u4E0D\u51FA\u7528 status=escalate\uFF0C\u4E0D\u6D17\u6210\u65E0\u5F55\u3002\u673A\u68B0\u5C42\u4E0D\u91CD\u5224\u3002"
             })
           ),
-          reason: Type13.Unknown({
+          reason: Type12.Unknown({
             description: "status \u4E3A escalate \u65F6\uFF1A\u8BA4\u4E0D\u51FA\u672C\u5EAD\u5BF9\u8C61\u7684\u539F\u56E0"
           }),
-          sessions: Type13.Optional(Type13.Unknown({ description: DIARIST_SESSIONS_DESCRIPTION })),
-          ticketSessions: Type13.Unknown({
+          sessions: Type12.Optional(Type12.Unknown({ description: DIARIST_SESSIONS_DESCRIPTION })),
+          ticketSessions: Type12.Unknown({
             description: `\u591A\u7968\u5EAD\u9010\u7968\u5BF9\u8BDD\u8FB9\u754C\uFF1B\u6BCF\u7968\u542B ticketNumber\uFF08\u672C\u6761\u8FB9\u754C\u6240\u5F52\u7968\u53F7\uFF0C\u6B63\u6574\u6570\uFF09\u4E0E sessions\uFF08${DIARIST_SESSIONS_DESCRIPTION}\uFF09\u3002\u4E00\u6B21\u4EA4\u5377\u5404\u7968\u5404\u81EA\u5206\u5F55\u3002\u4E0E\u5355\u7968 sessions \u4E8C\u9009\u4E00\u3002`
           })
         })
@@ -2100,7 +2026,7 @@ var init_diarist_contracts = __esm({
 });
 
 // src/secretariat-contracts.ts
-import { Type as Type14 } from "typebox";
+import { Type as Type13 } from "typebox";
 var SECRETARIAT_OUTPUT_TOOL_NAME, secretariatVerdictSchema, SECRETARIAT_GATE_OFFICER_ENTRY_TYPE, SECRETARIAT_COUNTERSIGN_TERMINAL_FACT_KEY;
 var init_secretariat_contracts = __esm({
   "src/secretariat-contracts.ts"() {
@@ -2108,17 +2034,17 @@ var init_secretariat_contracts = __esm({
     init_terminating_infrastructure();
     SECRETARIAT_OUTPUT_TOOL_NAME = "ak_secretariat_output";
     secretariatVerdictSchema = withTerminatingOutputDeclarations(
-      Type14.Object(
+      Type13.Object(
         {
-          secretariatStatus: Type14.Unknown({
+          secretariatStatus: Type13.Unknown({
             description: "converged | escalate"
           }),
-          ticketNumber: Type14.Optional(
-            Type14.Unknown({ description: "\u672C\u7968\u53F7\uFF1B\u7F72\u65F6\u6307\u5411\u6700\u7EC8\u6B63\u6587\u6240\u5728\u7968" })
+          ticketNumber: Type13.Optional(
+            Type13.Unknown({ description: "\u672C\u7968\u53F7\uFF1B\u7F72\u65F6\u6307\u5411\u6700\u7EC8\u6B63\u6587\u6240\u5728\u7968" })
           ),
-          note: Type14.Unknown({ description: "\u9644\u6CE8" }),
-          evidence: Type14.Optional(Type14.Unknown({ description: "\u7559\u5B58\u8BC1\u636E" })),
-          decisionGate: Type14.Unknown({
+          note: Type13.Unknown({ description: "\u9644\u6CE8" }),
+          evidence: Type13.Optional(Type13.Unknown({ description: "\u7559\u5B58\u8BC1\u636E" })),
+          decisionGate: Type13.Unknown({
             description: "\u9700\u965B\u4E0B\u5904\u7F6E\u7684\u95EE\u9898\u4E0E\u9009\u9879\uFF1B\u53EF\u5199 question \u4E0E options\uFF0C\u539F\u6837\u7559\u5B58\u3002"
           })
         },
@@ -2426,10 +2352,10 @@ var init_packaged_role_registry = __esm({
           reportPhase: true
         },
         boardPlacement: "marshal",
+        /** #1168: dispatch is first message; navigator reads admitted instruction. */
+        navigatorSubject: "public-instruction",
         activationFlags: [
-          { field: "packetPath", flag: "ak-fix-packet", binds: "input" },
-          { field: "phase", flag: "ak-fixer-phase", binds: "phase" },
-          { field: "prerequisitesPath", flag: "ak-fixer-prerequisites" }
+          { field: "phase", flag: "ak-fixer-phase", binds: "phase" }
         ],
         activationStage: "load-and-install",
         sessionMaterials: [
@@ -2456,8 +2382,9 @@ var init_packaged_role_registry = __esm({
         artifactFace: {
           reportPhase: true
         },
+        /** #1168: dispatch is first message; navigator reads admitted instruction. */
+        navigatorSubject: "public-instruction",
         activationFlags: [
-          { field: "taskPath", flag: "ak-coder-task", binds: "input" },
           { field: "phase", flag: "ak-coder-phase", binds: "phase" }
         ],
         activationStage: "load-and-install",
@@ -2825,20 +2752,8 @@ var init_cli_errors = __esm({
   }
 });
 
-// src/sha256.ts
-import { createHash } from "node:crypto";
-function sha256Hex(bytes) {
-  return createHash("sha256").update(bytes).digest("hex");
-}
-var init_sha256 = __esm({
-  "src/sha256.ts"() {
-    "use strict";
-  }
-});
-
 // src/collector-config.ts
-import { readFile as readFile3 } from "node:fs/promises";
-function fail3(message, cause) {
+function fail2(message, cause) {
   throw new Error(message, cause === void 0 ? void 0 : { cause });
 }
 function conservativeAscii(input) {
@@ -2849,63 +2764,26 @@ function conservativeAscii(input) {
   return true;
 }
 function parseCollectorRepository(raw) {
-  if (typeof raw !== "string" || raw.trim() !== raw || raw.length === 0) fail3("Collector repository must be a string owner/repo");
-  if (!conservativeAscii(raw) || raw.includes("://") || /[?#@%\\ ]/.test(raw)) fail3("Collector repository rejects URL syntax and non-identity bytes");
+  if (typeof raw !== "string" || raw.trim() !== raw || raw.length === 0) fail2("Collector repository must be a string owner/repo");
+  if (!conservativeAscii(raw) || raw.includes("://") || /[?#@%\\ ]/.test(raw)) fail2("Collector repository rejects URL syntax and non-identity bytes");
   const parts = raw.split("/");
-  if (parts.length !== 2) fail3("Collector repository must contain exactly one '/' separating owner and repo");
+  if (parts.length !== 2) fail2("Collector repository must contain exactly one '/' separating owner and repo");
   const [ownerDisplay, repoDisplay] = parts;
-  if (!COLLECTOR_OWNER_PATTERN.test(ownerDisplay) || !COLLECTOR_REPO_PATTERN.test(repoDisplay)) fail3("Collector repository does not match the conservative owner/repo grammar");
+  if (!COLLECTOR_OWNER_PATTERN.test(ownerDisplay) || !COLLECTOR_REPO_PATTERN.test(repoDisplay)) fail2("Collector repository does not match the conservative owner/repo grammar");
   const owner = ownerDisplay.toLowerCase();
   const repo = repoDisplay.toLowerCase();
   return { display: raw, canonical: `${owner}/${repo}`, owner, repo };
 }
 function parseCollectorPrNumber(raw) {
-  if (typeof raw !== "string" && typeof raw !== "number") fail3("Collector pull request number is required");
+  if (typeof raw !== "string" && typeof raw !== "number") fail2("Collector pull request number is required");
   const value = parseTicketNumber(raw);
-  if (value === void 0) fail3(typeof raw === "string" && !isTicketNumberString(raw) ? "Collector pull request number must be a positive safe integer string" : "Collector pull request number must be a positive safe integer");
+  if (value === void 0) fail2(typeof raw === "string" && !isTicketNumberString(raw) ? "Collector pull request number must be a positive safe integer string" : "Collector pull request number must be a positive safe integer");
   return value;
 }
-function canonicalManifest(requests) {
-  return `${JSON.stringify({ requests: requests.map((request) => ({ id: request.id, body: request.requestBody })) })}
-`;
-}
-function emptyCollectorManifest() {
-  const canonicalJson2 = canonicalManifest([]);
-  return { requests: [], canonicalJson: canonicalJson2, digest: sha256Hex(canonicalJson2) };
-}
-async function loadCollectorManifest(path) {
-  let bytes;
-  try {
-    bytes = await readFile3(path);
-  } catch (error) {
-    fail3(`Collector request manifest is unreadable at ${path}`, error);
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
-  } catch (error) {
-    fail3("Collector request manifest must be UTF-8 JSON", error);
-  }
-  if (!isRecord(parsed)) fail3("Collector request manifest must be an object");
-  const rawRequests = parsed.requests ?? [];
-  if (!Array.isArray(rawRequests)) fail3("Collector request manifest requests must be an array");
-  const requests = [];
-  const ids = /* @__PURE__ */ new Set();
-  for (const [index, item] of rawRequests.entries()) {
-    if (!isRecord(item) || typeof item.id !== "string" || item.id.length === 0 || typeof item.body !== "string" || item.body.trim() === "") fail3(`Collector request manifest requests[${index}] is invalid`);
-    if (ids.has(item.id)) fail3(`Collector request manifest has duplicate request id "${item.id}"`);
-    ids.add(item.id);
-    requests.push({ id: item.id, requestBody: item.body });
-  }
-  const canonicalJson2 = canonicalManifest(requests);
-  return { requests, canonicalJson: canonicalJson2, digest: sha256Hex(canonicalJson2), sourcePath: path };
-}
 var COLLECTOR_OWNER_PATTERN, COLLECTOR_REPO_PATTERN;
 var init_collector_config = __esm({
   "src/collector-config.ts"() {
     "use strict";
-    init_sha256();
-    init_unknown_value();
     init_run_ticket_number();
     COLLECTOR_OWNER_PATTERN = /^[A-Za-z0-9](?:[A-Za-z0-9-]{0,37}[A-Za-z0-9])?$/;
     COLLECTOR_REPO_PATTERN = /^[A-Za-z0-9](?:[A-Za-z0-9._-]{0,98}[A-Za-z0-9])?$/;
@@ -2920,7 +2798,7 @@ __export(auditor_dossier_tool_exports, {
   createAuditorDossierTool: () => createAuditorDossierTool
 });
 import { join as join7, resolve as resolve3 } from "node:path";
-import { Type as Type15 } from "typebox";
+import { Type as Type14 } from "typebox";
 function auditorRunDirectory(context) {
   const sessionFile = context.sessionManager?.getSessionFile?.();
   if (sessionFile === void 0) return void 0;
@@ -2932,7 +2810,7 @@ function createAuditorDossierTool(runDirectory) {
     description: "\u5B9A\u4F4D\u672C\u5BA1\u8BA1\u5E2D\u7ED1\u5B9A\u7684 run \u5377\u5B97\u53CA\u5176\u8BC1\u636E\u5165\u53E3\u3002",
     // #836 r16 class 3: execute() ignores `_params` entirely — a closed root
     // only rejects the role for saying more.
-    parameters: Type15.Object({}, { additionalProperties: true }),
+    parameters: Type14.Object({}, { additionalProperties: true }),
     async execute(_id, _params) {
       if (runDirectory === void 0) {
         return {
@@ -3056,7 +2934,7 @@ var init_submission_errors = __esm({
 });
 
 // src/collector-tool-schemas.ts
-import { Type as Type16 } from "typebox";
+import { Type as Type15 } from "typebox";
 var collectorOutputBaseSchema, collectorOutputArgsSchema;
 var init_collector_tool_schemas = __esm({
   "src/collector-tool-schemas.ts"() {
@@ -3064,11 +2942,11 @@ var init_collector_tool_schemas = __esm({
     init_open_tool_schema();
     init_terminating_infrastructure();
     collectorOutputBaseSchema = openToolObject(
-      Type16.Object({
-        groups: Type16.Unsafe({
+      Type15.Object({
+        groups: Type15.Unsafe({
           description: "\u6309\u673A\u5668\u8EAB\u4EFD\u5F52\u7EC4\u7684\u51FA\u5E2D\u3001\u6750\u6599\u4E0E\u9010\u6761 findings\uFF08LLM \u81EA\u884C\u4ECE\u5BBF\u4E3B CLI \u53D6\u8BC1\u6574\u7406\uFF1B\u4EE3\u7801\u4E0D\u4EE3\u6536\u4E0D\u5F52\u5E76\uFF09\u3002"
         }),
-        unfinishedReasons: Type16.Unknown({
+        unfinishedReasons: Type15.Unknown({
           description: "\u672A\u5B8C\u6210\u539F\u56E0\uFF1B\u53D6\u8BC1\u53D7\u9650\u65F6\u5982\u5B9E\u62A5\u544A\u3002"
         })
       })
@@ -3578,13 +3456,13 @@ var init_gatekeeper_role = __esm({
 });
 
 // src/ledger-session-read.ts
-import { readFile as readFile4 } from "node:fs/promises";
+import { readFile as readFile3 } from "node:fs/promises";
 async function readStrictPiSessionJsonl(path) {
-  const text = await readFile4(path, "utf8");
+  const text = await readFile3(path, "utf8");
   return text.trim().split("\n").filter(Boolean).map((line2) => JSON.parse(line2));
 }
 async function readLedgerSessionJsonlLines(path) {
-  const text = await readFile4(path, "utf8");
+  const text = await readFile3(path, "utf8");
   const lines = text.split("\n");
   const out = [];
   for (let index = 0; index < lines.length; index += 1) {
@@ -4997,6 +4875,17 @@ var init_dossier_resolution = __esm({
   }
 });
 
+// src/sha256.ts
+import { createHash } from "node:crypto";
+function sha256Hex(bytes) {
+  return createHash("sha256").update(bytes).digest("hex");
+}
+var init_sha256 = __esm({
+  "src/sha256.ts"() {
+    "use strict";
+  }
+});
+
 // src/package-contracts/terminating-tools.ts
 function isTerminatingToolName(name) {
   return TERMINATING_TOOL_NAMES.includes(name);
@@ -5058,7 +4947,7 @@ var init_terminating_tools = __esm({
 });
 
 // src/doctor-evidence.ts
-import { readdir as readdir2, readFile as readFile5, realpath, stat } from "node:fs/promises";
+import { readdir as readdir2, readFile as readFile4, realpath, stat } from "node:fs/promises";
 import { dirname as dirname6, relative as relative2, resolve as resolve5, sep as sep2 } from "node:path";
 async function discoverCaseFiles(root) {
   const found = [];
@@ -5171,7 +5060,7 @@ async function loadDoctorCase(runsPath, projectRoot) {
   const turns = { count: 0, sources: [] }, calls = { count: 0, sources: [] }, tokens = { count: 0, sources: [] };
   for (const path of await discoverCaseFiles(root)) {
     const id = relative2(root, path).split(sep2).join("/");
-    const bytes = await readFile5(path);
+    const bytes = await readFile4(path);
     const content = bytes.toString("utf8");
     const kind = id.split("/").length === 2 && id.endsWith("/log.jsonl") ? "log" : "session";
     evidence.push({ id, kind, byteLength: bytes.byteLength, contentLength: content.length, sha256: sha256Hex(bytes), content });
@@ -5249,7 +5138,7 @@ var init_git_object_id = __esm({
 
 // src/merger-git-state.ts
 import { execFile } from "node:child_process";
-import { access, readFile as readFile6 } from "node:fs/promises";
+import { access, readFile as readFile5 } from "node:fs/promises";
 import { constants as fsConstants } from "node:fs";
 import { isAbsolute as isAbsolute3, resolve as resolve6 } from "node:path";
 import { promisify } from "node:util";
@@ -5319,7 +5208,7 @@ function createProductionMergerGitState(repositoryRoot = process.cwd()) {
       const mergeHeadPath = isAbsolute3(mergeHeadReported) ? mergeHeadReported : resolve6(repositoryRoot, mergeHeadReported);
       let sourceObjectId = "";
       if (await pathExists(mergeHeadPath)) {
-        const raw = exactUtf8(await readFile6(mergeHeadPath), "Git MERGE_HEAD");
+        const raw = exactUtf8(await readFile5(mergeHeadPath), "Git MERGE_HEAD");
         const mergeHeads = raw.trim().split(/\r?\n/).map((row) => row.trim()).filter(Boolean);
         if (mergeHeads.length === 0) throw new Error("Git MERGE_HEAD is empty");
         if (mergeHeads.length !== 1) throw new Error("Assigned repository does not have one ordinary in-progress merge");
@@ -5465,7 +5354,7 @@ var init_session_dialogue = __esm({
 });
 
 // src/ticket-provenance.ts
-import { readFile as readFile7 } from "node:fs/promises";
+import { readFile as readFile6 } from "node:fs/promises";
 import { join as join9, resolve as resolve7 } from "node:path";
 function dialogueSessionSourceRoots(home) {
   const machineHome = typeof home === "string" && home.trim() !== "" ? home : packageMachineHome();
@@ -5513,7 +5402,7 @@ async function rehomeUnboundTicketProvenance(runDirectory, ticketNumber, cwd, ho
   const ticketInput = ticketProvenanceRecordInput(ticketNumber, cwd, home);
   let history;
   try {
-    history = await readFile7(join9(runDirectory, RUN_HISTORY_FILE), "utf8");
+    history = await readFile6(join9(runDirectory, RUN_HISTORY_FILE), "utf8");
   } catch (error) {
     if (errnoCode(error) === "ENOENT") return;
     throw error;
@@ -6356,8 +6245,8 @@ var init_option_definitions = __esm({
       repeatable: true,
       form: "option",
       description: {
-        en: "Attach a regular file; frozen at admission (repeatable).",
-        zh: "\u9644\u52A0\u666E\u901A\u6587\u4EF6\uFF1B\u53D7\u7406\u5373\u51BB\u7ED3\uFF08\u53EF\u91CD\u590D\uFF09\u3002"
+        en: "Caller file path passed as-is to the role (repeatable). Package does not read, copy, or validate; use an absolute path when cwd differs from --project.",
+        zh: "\u8C03\u7528\u65B9\u6587\u4EF6\u8DEF\u5F84\u539F\u6837\u9012\u7ED9\u8859\u95E8\uFF08\u53EF\u91CD\u590D\uFF09\u3002\u5305\u4E0D\u8BFB\u3001\u4E0D\u590D\u5236\u3001\u4E0D\u6821\u9A8C\uFF1B\u8C03\u7528\u65B9\u5F53\u524D\u76EE\u5F55\u4E0E --project \u4E0D\u540C\u65F6\u8BF7\u7ED9\u7EDD\u5BF9\u8DEF\u5F84\u3002"
       }
     };
     SHARED_PHASE_SEMANTICS = {
@@ -6441,8 +6330,8 @@ var init_option_definitions = __esm({
         repeatable: false,
         form: "option",
         description: {
-          en: "JSON array of {id, requirement} prerequisite objects.",
-          zh: "{id, requirement} \u524D\u7F6E\u6761\u4EF6 JSON \u6570\u7EC4\u8DEF\u5F84\u3002"
+          en: "Caller prerequisites path passed as-is to the role. Package does not read, copy, or validate; use an absolute path when cwd differs from --project.",
+          zh: "\u8C03\u7528\u65B9\u524D\u7F6E\u6761\u4EF6\u6587\u4EF6\u8DEF\u5F84\u539F\u6837\u9012\u7ED9\u8859\u95E8\u3002\u5305\u4E0D\u8BFB\u3001\u4E0D\u590D\u5236\u3001\u4E0D\u6821\u9A8C\uFF1B\u8C03\u7528\u65B9\u5F53\u524D\u76EE\u5F55\u4E0E --project \u4E0D\u540C\u65F6\u8BF7\u7ED9\u7EDD\u5BF9\u8DEF\u5F84\u3002"
         }
       }
     ];
@@ -6532,8 +6421,8 @@ var init_option_definitions = __esm({
         repeatable: false,
         form: "option",
         description: {
-          en: "Optional request manifest JSON path ({requests:[{id,body}]}). Parsed for semantics and passed to the Collector as materials \u2014 not a machine collection directive.",
-          zh: "\u53EF\u9009 request manifest JSON \u8DEF\u5F84\uFF08{requests:[{id,body}]}\uFF09\u3002\u6309\u8BED\u4E49\u89E3\u6790\u540E\u4F5C\u4E3A\u6750\u6599\u9012\u7ED9\u901A\u8FDB\u53F8\uFF0C\u4E0D\u662F\u673A\u5668\u4EE3\u6536 finding \u7684\u6307\u4EE4\u3002"
+          en: "Caller path to a request manifest JSON file, passed as-is. Package does not read, copy, or validate; use an absolute path when cwd differs from --project.",
+          zh: "\u8C03\u7528\u65B9 request manifest JSON \u8DEF\u5F84\uFF0C\u539F\u6837\u4F20\u9012\u3002\u5305\u4E0D\u8BFB\u3001\u4E0D\u590D\u5236\u3001\u4E0D\u6821\u9A8C\uFF1B\u8C03\u7528\u65B9\u5F53\u524D\u76EE\u5F55\u4E0E --project \u4E0D\u540C\u65F6\u8BF7\u7ED9\u7EDD\u5BF9\u8DEF\u5F84\u3002"
         }
       }
     ];
@@ -6992,16 +6881,22 @@ var init_option_definitions = __esm({
 import { execFileSync as execFileSync2 } from "node:child_process";
 import { existsSync as existsSync3 } from "node:fs";
 import {
-  lstat as lstat2,
-  mkdtemp,
-  readFile as readFile8,
+  readFile as readFile7,
   realpath as realpath3,
   rename,
-  rm,
   writeFile
 } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { basename as basename8, dirname as dirname8, isAbsolute as isAbsolute5, join as join11, resolve as resolve9 } from "node:path";
+import { dirname as dirname8, isAbsolute as isAbsolute5, join as join11, resolve as resolve9 } from "node:path";
+function normalizeAdmittedAttachment(raw) {
+  if (typeof raw !== "object" || raw === null) return void 0;
+  const record = raw;
+  const path = record.path;
+  if (typeof path === "string") return { path };
+  return void 0;
+}
+function admitCallerAttachments(attachmentPaths) {
+  return attachmentPaths.map((path) => ({ path }));
+}
 function issueAdmissionPlacement(authority, request) {
   const ledgerHome = resolveActivationLedgerHome(request.home);
   const bookKey = resolveBookKeyFromGit(request.cwd);
@@ -7177,22 +7072,11 @@ async function relocateAdmittedRunToTicket(admitted, authority, heldLease) {
     admittedRecord,
     [
       "runDirectory",
-      "taskPath",
-      "packetPath",
-      "prerequisitesPath",
-      "requestManifestPath",
       "mergerInputPath"
     ],
     oldRunDirectory,
     target.runDirectory
   );
-  for (const attachment of admitted.attachments) {
-    attachment.frozenPath = rewriteRunDirectoryPathValue(
-      attachment.frozenPath,
-      oldRunDirectory,
-      target.runDirectory
-    );
-  }
   admitted.principal = principal;
   renderCurrentSync(target.runDirectory);
   return { oldRunDirectory, newRunDirectory: target.runDirectory };
@@ -7229,7 +7113,7 @@ async function recordLaunchedPiIdentity(runDirectory, identity) {
 async function observeLaunchedRolePackageIdentity(packageRoot, selectedRoleEntry) {
   const rolePackageRoot = packageRoot;
   const raw = JSON.parse(
-    await readFile8(join11(rolePackageRoot, "package.json"), "utf8")
+    await readFile7(join11(rolePackageRoot, "package.json"), "utf8")
   );
   if (typeof raw.version !== "string" || raw.version.trim() === "") {
     throw new Error(
@@ -7285,7 +7169,7 @@ function assignPublicSeatOption(owner, taken, fields) {
   const value = taken.value;
   switch (taken.def.id) {
     case "attach":
-      fields.attachmentPaths.push(requireOptionPath(taken.def.canonical, value));
+      fields.attachmentPaths.push(requireProvidedOptionValue(taken.def.canonical, value));
       return;
     case "project":
       fields.project = requireOptionPath(taken.def.canonical, value);
@@ -7320,7 +7204,7 @@ function assignPublicSeatOption(owner, taken, fields) {
       fields.authorityRefs.push(requireAuthorityRef(value));
       return;
     case "prerequisites":
-      fields.prerequisitesPath = requireOptionPath(taken.def.canonical, value);
+      fields.prerequisitesPath = requireProvidedOptionValue(taken.def.canonical, value);
       return;
     case "pr":
       fields.prNumber = parsePositivePrOption(value);
@@ -7329,7 +7213,7 @@ function assignPublicSeatOption(owner, taken, fields) {
       fields.repo = parseRepoOption(value);
       return;
     case "request-manifest":
-      fields.requestManifestPath = requireOptionPath(taken.def.canonical, value);
+      fields.requestManifestPath = requireProvidedOptionValue(taken.def.canonical, value);
       return;
     case "issue": {
       if (value === void 0 || value.trim() === "") {
@@ -7444,6 +7328,12 @@ function requireOptionPath(flag, value) {
   }
   return value;
 }
+function requireProvidedOptionValue(flag, value) {
+  if (value === void 0) {
+    throw new CliUsageError(`${flag} requires a path`);
+  }
+  return value;
+}
 function skillArgTokenFault(value) {
   if (value === void 0 || value.trim() === "") return "empty";
   if (/\s/.test(value)) return "whitespace";
@@ -7496,124 +7386,6 @@ function requireAuthorityRef(value) {
     optionLike: "--authority-ref requires a durable reference, not inline Spec prose"
   });
 }
-async function readRegularFileAttachment(sourcePath) {
-  const absolute = isAbsolute5(sourcePath) ? sourcePath : resolve9(sourcePath);
-  let st;
-  try {
-    st = await lstat2(absolute);
-  } catch (error) {
-    throw new CliUsageError(
-      `attachment is not a readable regular file: ${sourcePath}`,
-      { cause: error }
-    );
-  }
-  if (!st.isFile() || st.isSymbolicLink()) {
-    throw new CliUsageError(
-      `attachment must be a regular file (not a directory or symlink): ${sourcePath}`
-    );
-  }
-  try {
-    return { absolute, bytes: await readFile8(absolute) };
-  } catch (error) {
-    throw new CliUsageError(
-      `attachment is not a readable regular file: ${sourcePath}`,
-      { cause: error }
-    );
-  }
-}
-async function removePreparedAttachmentDirectory(stagingDirectory) {
-  await rm(stagingDirectory, { recursive: true, force: true });
-}
-async function withPreparedAttachments(attachmentPaths, use) {
-  if (attachmentPaths.length === 0) return await use([]);
-  const stagingDirectory = await mkdtemp(join11(tmpdir(), "ak-role-attachments-"));
-  const prepared = [];
-  let result;
-  try {
-    for (let index = 0; index < attachmentPaths.length; index += 1) {
-      const { absolute, bytes } = await readRegularFileAttachment(attachmentPaths[index]);
-      const snapshotPath = join11(stagingDirectory, String(index).padStart(6, "0"));
-      await writeFile(snapshotPath, bytes);
-      prepared.push({ absolute, snapshotPath });
-    }
-    result = await use(prepared);
-  } catch (primary) {
-    try {
-      await removePreparedAttachmentDirectory(stagingDirectory);
-    } catch (cleanup) {
-      throw new AggregateError(
-        [primary, cleanup],
-        "attachment snapshot operation failed and cleanup also failed",
-        { cause: primary }
-      );
-    }
-    throw primary;
-  }
-  await removePreparedAttachmentDirectory(stagingDirectory);
-  return result;
-}
-async function freezeAttachmentBytes(provenancePath, bytes, destinationDir, index) {
-  const frozenPath = join11(
-    destinationDir,
-    `${String(index).padStart(2, "0")}-${basename8(provenancePath)}`
-  );
-  await writeFile(frozenPath, bytes);
-  return {
-    provenancePath,
-    frozenPath,
-    byteLength: bytes.byteLength,
-    sha256: sha256Hex(bytes),
-    mediaKind: "regular-file"
-  };
-}
-async function freezePreparedAttachment(prepared, destinationDir, index) {
-  return freezeAttachmentBytes(
-    prepared.absolute,
-    await readFile8(prepared.snapshotPath),
-    destinationDir,
-    index
-  );
-}
-async function freezeRegularFileAttachment(sourcePath, destinationDir, index) {
-  const { absolute, bytes } = await readRegularFileAttachment(sourcePath);
-  return {
-    attachment: await freezeAttachmentBytes(absolute, bytes, destinationDir, index),
-    body: bytes
-  };
-}
-async function freezeAttachments(ledgerHome, attachmentPaths, attachmentsDirectory) {
-  const attachments = [];
-  if (attachmentPaths.length > 0) {
-    ensureRealDirectoryTree(ledgerHome, attachmentsDirectory);
-  }
-  for (let i = 0; i < attachmentPaths.length; i += 1) {
-    const frozen = await freezeRegularFileAttachment(
-      attachmentPaths[i],
-      attachmentsDirectory,
-      i
-    );
-    attachments.push(frozen.attachment);
-  }
-  return attachments;
-}
-async function freezeAttachmentsIntoRun(attachmentPaths, runDirectory, summonsKey = `s-${Date.now().toString(36)}`) {
-  if (attachmentPaths.length === 0) return [];
-  const ledgerHome = resolveActivationLedgerHome(homeFromRunDirectory(runDirectory));
-  const attachmentsDirectory = join11(runDirectory, "attachments", summonsKey);
-  ensureRealDirectoryTree(ledgerHome, attachmentsDirectory);
-  return freezeAttachments(ledgerHome, attachmentPaths, attachmentsDirectory);
-}
-async function freezePreparedAttachmentsIntoRun(prepared, runDirectory, summonsKey) {
-  if (prepared.length === 0) return [];
-  const ledgerHome = resolveActivationLedgerHome(homeFromRunDirectory(runDirectory));
-  const attachmentsDirectory = summonsKey === void 0 ? join11(runDirectory, "attachments") : join11(runDirectory, "attachments", summonsKey);
-  ensureRealDirectoryTree(ledgerHome, attachmentsDirectory);
-  const attachments = [];
-  for (let index = 0; index < prepared.length; index += 1) {
-    attachments.push(await freezePreparedAttachment(prepared[index], attachmentsDirectory, index));
-  }
-  return attachments;
-}
 function ticketAdmissionFields(ticketNumber) {
   if (ticketNumber === void 0) return {};
   return {
@@ -7682,11 +7454,7 @@ async function admitPublicRole(role, parsed, env, override) {
         instruction,
         attachmentPaths,
         ...project,
-        placedFields: async (placed) => {
-          const taskPath = join11(placed.runDirectory, "task.md");
-          await writeFile(taskPath, instruction, "utf8");
-          return { phase, taskPath };
-        }
+        placedFields: async () => ({ phase })
       });
     }
     case "worker-packet": {
@@ -7697,52 +7465,15 @@ async function admitPublicRole(role, parsed, env, override) {
       if (!record.phases.some((item) => item === phase)) {
         throw new CliUsageError("fixer phase must be plan or apply");
       }
-      let prerequisites = Object.freeze([]);
-      let prerequisitesSource;
-      if (parsed.prerequisitesPath !== void 0) {
-        const absolutePrereq = isAbsolute5(parsed.prerequisitesPath) ? parsed.prerequisitesPath : resolve9(parsed.prerequisitesPath);
-        try {
-          prerequisitesSource = await readFile8(absolutePrereq, "utf8");
-        } catch (error) {
-          throw new CliUsageError(
-            `fixer prerequisites path is unreadable: ${parsed.prerequisitesPath}`,
-            { cause: error }
-          );
-        }
-        try {
-          prerequisites = parseFixerPrerequisites(prerequisitesSource);
-        } catch (error) {
-          if (error instanceof FixerPacketValidationError) {
-            throw new CliUsageError(error.message, { cause: error });
-          }
-          throw error;
-        }
-      }
       return admitStandardMaterialInvocation("fixer", {
         ...shared,
         instruction,
         attachmentPaths,
         ...project,
-        placedFields: async (placed) => {
-          let prerequisitesPath;
-          if (prerequisitesSource !== void 0) {
-            prerequisitesPath = join11(placed.runDirectory, "prerequisites.json");
-            await writeFile(
-              prerequisitesPath,
-              `${JSON.stringify(prerequisites, null, 2)}
-`,
-              "utf8"
-            );
-          }
-          const packetPath = join11(placed.runDirectory, "fix-packet.md");
-          await writeFile(packetPath, instruction, "utf8");
-          return {
-            phase,
-            packetPath,
-            prerequisites,
-            ...prerequisitesPath === void 0 ? {} : { prerequisitesPath }
-          };
-        }
+        placedFields: async () => ({
+          phase,
+          ...parsed.prerequisitesPath === void 0 ? {} : { prerequisitesPath: parsed.prerequisitesPath }
+        })
       });
     }
     case "collect-target": {
@@ -7759,37 +7490,17 @@ async function admitPublicRole(role, parsed, env, override) {
       } else {
         repository = resolveGitHubRemoteRepository(projectRoot);
       }
-      let manifest = emptyCollectorManifest();
-      let manifestCanonicalJson;
-      if (parsed.requestManifestPath !== void 0) {
-        try {
-          manifest = await loadCollectorManifest(parsed.requestManifestPath);
-          manifestCanonicalJson = manifest.canonicalJson;
-        } catch (error) {
-          throw new CliUsageError(
-            errorText(error),
-            { cause: error }
-          );
-        }
-      }
-      const manifestDigest = manifest.digest;
       const admittedCollector = await admitStandardMaterialInvocation("collector", {
         ...shared,
         instruction,
         attachmentPaths,
         ...project,
-        placedFields: async (placed) => {
-          let requestManifestPath;
-          if (manifestCanonicalJson !== void 0) {
-            requestManifestPath = join11(placed.runDirectory, "request-manifest.json");
-            await writeFile(requestManifestPath, manifestCanonicalJson, "utf8");
-          }
+        placedFields: async () => {
           return {
             ...explicitPrNumber === void 0 ? {} : { prNumber: explicitPrNumber },
             repository: repository.canonical,
             repositoryDisplay: repository.display,
-            ...requestManifestPath === void 0 ? {} : { requestManifestPath },
-            manifestDigest
+            ...parsed.requestManifestPath === void 0 ? {} : { requestManifestPath: parsed.requestManifestPath }
           };
         }
       });
@@ -7802,12 +7513,10 @@ async function admitPublicRole(role, parsed, env, override) {
         );
       }
       const issueNumber = parsed.issueNumber;
-      let frozenAttachments = [];
-      const admittedDoctor = await admitStandardMaterialInvocation("doctor", {
+      return admitStandardMaterialInvocation("doctor", {
         ...shared,
         instruction,
-        attachmentPaths: [],
-        freezeAttachments: false,
+        attachmentPaths,
         ...project,
         placedFields: async (placed) => {
           let caseRunsPath;
@@ -7848,16 +7557,13 @@ async function admitPublicRole(role, parsed, env, override) {
               { cause: error }
             );
           }
-          frozenAttachments = await freezeAttachments(placed.ledgerHome, attachmentPaths, placed.attachmentsDirectory);
           return {
             issueNumber,
             caseRunsPath,
-            caseIdentity,
-            attachments: persistedAttachmentRefs(frozenAttachments)
+            caseIdentity
           };
         }
       });
-      return { ...admittedDoctor, attachments: frozenAttachments };
     }
     case "source-locator": {
       const projectRoot = resolve9(parsed.project ?? shared.cwd);
@@ -7884,7 +7590,7 @@ async function admitPublicRole(role, parsed, env, override) {
         instruction: "",
         attachmentPaths: [],
         ...project,
-        freezeAttachments: false,
+        recordAttachments: false,
         admittedFields: {
           sourceRunPath: sourceRun.runDirectory,
           sourceRun
@@ -7901,7 +7607,7 @@ async function admitPublicRole(role, parsed, env, override) {
         instruction,
         attachmentPaths: [],
         ...project,
-        freezeAttachments: false,
+        recordAttachments: false,
         admittedFields: { baseRevision }
       });
     }
@@ -7954,8 +7660,6 @@ async function admitPublicRole(role, parsed, env, override) {
             targetObjectId: derived.targetObjectId,
             sourceObjectId: derived.sourceObjectId,
             materials: {
-              task: mergerMaterialFromUtf8(instruction),
-              authority: mergerMaterialFromUtf8(instruction),
               targetIntent: mergerMaterialFromUtf8(
                 `Investigate primary sources for target parent ${targetLabel}. Do not invent intent.`
               ),
@@ -8013,7 +7717,7 @@ async function placeRoleAdmission(options) {
     home: options.home,
     ...options.materialize === void 0 ? {} : { materialize: options.materialize }
   });
-  const attachments = options.freezeAttachments === false ? [] : await freezeAttachments(ledgerHome, options.attachmentPaths, attachmentsDirectory);
+  const attachments = options.recordAttachments === false ? [] : admitCallerAttachments(options.attachmentPaths);
   return {
     runId,
     bookKey,
@@ -8029,13 +7733,7 @@ async function placeRoleAdmission(options) {
   };
 }
 function persistedAttachmentRefs(attachments) {
-  return attachments.map((attachment) => ({
-    provenancePath: attachment.provenancePath,
-    frozenPath: attachment.frozenPath,
-    byteLength: attachment.byteLength,
-    sha256: attachment.sha256,
-    mediaKind: attachment.mediaKind
-  }));
+  return attachments.map((attachment) => ({ path: attachment.path }));
 }
 async function persistPlacedAdmission(admitted, placed, model) {
   writeAdmittedRequestPersistence(placed.runDirectory, admitted, {
@@ -8054,14 +7752,14 @@ async function persistPlacedAdmission(admitted, placed, model) {
 }
 async function admitStandardMaterialInvocation(role, options) {
   const defer = options.deferPersistence === true;
-  const skipFreeze = defer || options.freezeAttachments === false;
+  const skipAttachments = defer || options.recordAttachments === false;
   const placed = await placeRoleAdmission({
     role,
     home: options.home,
     principalAuthority: options.principalAuthority,
     cwd: options.cwd,
     attachmentPaths: options.attachmentPaths,
-    ...skipFreeze ? { freezeAttachments: false } : {},
+    ...skipAttachments ? { recordAttachments: false } : {},
     ...defer ? { materialize: false } : {},
     ...options.project === void 0 ? {} : { project: options.project },
     ...options.createRunId === void 0 ? {} : { createRunId: options.createRunId },
@@ -8069,7 +7767,7 @@ async function admitStandardMaterialInvocation(role, options) {
   });
   const correlationFields = options.correlationId === void 0 ? {} : { correlationId: options.correlationId };
   const instruction = options.instruction;
-  const instructionEmpty = instruction.trim() === "";
+  const instructionEmpty = instruction.length === 0;
   const placedExtra = options.placedFields === void 0 ? void 0 : await options.placedFields(placed);
   const admittedFields = {
     ...options.admittedFields ?? {},
@@ -8124,7 +7822,7 @@ function buildInstructionTransportPrompt(admitted) {
       throw new Error("baseline transport prompt is missing the bound revision");
     }
     const lines2 = [admitted.baseRevision];
-    if (!admitted.instructionEmpty) {
+    if (admitted.instruction.length > 0) {
       lines2.push("", admitted.instruction);
     }
     return lines2.join("\n");
@@ -8138,17 +7836,22 @@ function buildInstructionTransportPrompt(admitted) {
       lens: admitted.lens,
       authorityRefs: admitted.authorityRefs
     })];
-    if (!admitted.instructionEmpty && admitted.instruction.trim() !== "") {
+    if (admitted.instruction.length > 0) {
       lines2.push("", admitted.instruction);
     }
     return lines2.join("\n");
   }
-  const lines = [admitted.instructionEmpty ? "" : admitted.instruction];
-  if (admitted.attachments.length > 0) {
+  const lines = [admitted.instruction];
+  const flaggedPaths = [
+    ...admitted.attachments.map((attachment) => `--attach ${attachment.path}`),
+    ...admitted.requestManifestPath === void 0 ? [] : [`--request-manifest ${admitted.requestManifestPath}`],
+    ...admitted.prerequisitesPath === void 0 ? [] : [`--prerequisites ${admitted.prerequisitesPath}`]
+  ];
+  if (flaggedPaths.length > 0) {
     lines.push("");
-    lines.push("\u5DF2\u53D7\u7406\u9644\u4EF6\uFF08\u51BB\u7ED3\u5FEB\u7167\u8DEF\u5F84\uFF09\uFF1A");
-    for (const attachment of admitted.attachments) {
-      lines.push(`- ${attachment.frozenPath}`);
+    lines.push("\u5DF2\u53D7\u7406\u9644\u4EF6\uFF1A");
+    for (const entry of flaggedPaths) {
+      lines.push(`- ${entry}`);
     }
   }
   return lines.join("\n");
@@ -8159,8 +7862,7 @@ async function materializeCountersignInvocation(admitted, options) {
     home: options.home,
     principalAuthority: options.principalAuthority,
     cwd: admitted.projectRoot,
-    attachmentPaths: [],
-    freezeAttachments: false,
+    attachmentPaths: options.attachmentPaths,
     runId: admitted.runId,
     ...options.ticketNumber === void 0 ? {} : { assertedTicketNumber: options.ticketNumber }
   });
@@ -8171,11 +7873,7 @@ async function materializeCountersignInvocation(admitted, options) {
   if (ticketFields.ticketNumber !== void 0) {
     admitted.ticketNumber = ticketFields.ticketNumber;
   }
-  const attachments = await freezePreparedAttachmentsIntoRun(
-    options.preparedAttachments,
-    admitted.runDirectory
-  );
-  admitted.attachments = attachments;
+  admitted.attachments = placement.attachments;
   writeAdmittedRequestPersistence(admitted.runDirectory, admitted, {
     sessionDirectory: placement.sessionDirectory,
     sessionFile: placement.sessionFile
@@ -8194,10 +7892,11 @@ async function loadAdmittedJudgeRequest(runDirectory) {
     if (typeof record.instruction !== "string") return void 0;
     if (typeof record.instructionEmpty !== "boolean") return void 0;
     if (!Array.isArray(record.attachments)) return void 0;
+    const attachments = record.attachments.map((item) => normalizeAdmittedAttachment(item)).filter((item) => item !== void 0);
     return {
       instruction: record.instruction,
       instructionEmpty: record.instructionEmpty,
-      attachments: record.attachments
+      attachments
     };
   } catch {
     return void 0;
@@ -8432,7 +8131,7 @@ function parseAnalystArgv(args) {
       if (taken.def.id === "attach") {
         pushValue(
           "attach",
-          requireOptionPath(taken.def.canonical, taken.value)
+          requireProvidedOptionValue(taken.def.canonical, taken.value)
         );
         return;
       }
@@ -8546,7 +8245,6 @@ var init_invocation = __esm({
     init_doctor_evidence();
     init_collector_config();
     init_github_remote();
-    init_fixer_packet();
     init_merger_git_state();
     init_merger_contracts();
     init_sha256();
@@ -9838,10 +9536,10 @@ function presentFailureTerminal(terminal, io) {
 }
 function defaultNavigatorGraceSleep() {
   let timer;
-  const sleep2 = ((ms) => new Promise((resolve22) => {
+  const sleep2 = ((ms) => new Promise((resolve21) => {
     timer = setTimeout(() => {
       timer = void 0;
-      resolve22();
+      resolve21();
     }, ms);
   }));
   sleep2.cancel = () => {
@@ -9853,7 +9551,7 @@ function defaultNavigatorGraceSleep() {
   return sleep2;
 }
 function raceNavigatorGrace(work, graceMs = NAVIGATOR_POST_ROLE_GRACE_MS, sleep2 = defaultNavigatorGraceSleep()) {
-  return new Promise((resolve22, reject) => {
+  return new Promise((resolve21, reject) => {
     let settled = false;
     const finish = (action) => {
       if (settled) return;
@@ -9862,11 +9560,11 @@ function raceNavigatorGrace(work, graceMs = NAVIGATOR_POST_ROLE_GRACE_MS, sleep2
       action();
     };
     void work.then(
-      (value) => finish(() => resolve22({ status: "done", value })),
+      (value) => finish(() => resolve21({ status: "done", value })),
       (error) => finish(() => reject(error))
     );
     void sleep2(graceMs).then(() => {
-      finish(() => resolve22({ status: "timeout" }));
+      finish(() => resolve21({ status: "timeout" }));
     });
   });
 }
@@ -10483,7 +10181,7 @@ __export(config_exports, {
   setPersistentSeatHost: () => setPersistentSeatHost,
   validatePublicCliConfigAxes: () => validatePublicCliConfigAxes
 });
-import { mkdir, readFile as readFile9, writeFile as writeFile2 } from "node:fs/promises";
+import { mkdir, readFile as readFile8, writeFile as writeFile2 } from "node:fs/promises";
 import { dirname as dirname11, join as join15 } from "node:path";
 function isGateOfficerSeat(value) {
   return packagedProvinceConfig(value);
@@ -10497,7 +10195,7 @@ function publicCliConfigPath(home) {
 async function loadPublicCliConfig(home) {
   const path = publicCliConfigPath(home);
   try {
-    const raw = await readFile9(path, "utf8");
+    const raw = await readFile8(path, "utf8");
     return parsePublicCliConfig(JSON.parse(raw));
   } catch (error) {
     if (isEnoent(error)) return { seats: {} };
@@ -10956,7 +10654,7 @@ function resolvePublicAgentDir(explicit, home) {
 }
 async function loadCredentialProviders(agentDir) {
   try {
-    const raw = await readFile9(join15(agentDir, "auth.json"), "utf8");
+    const raw = await readFile8(join15(agentDir, "auth.json"), "utf8");
     return credentialProvidersFromAuthData(JSON.parse(raw));
   } catch (error) {
     if (isEnoent(error)) return { "openai-codex": false, xai: false };
@@ -11340,7 +11038,7 @@ var init_role_seat_runtime = __esm({
 });
 
 // src/archivist-record-pointer.ts
-import { basename as basename9, join as join19 } from "node:path";
+import { basename as basename8, join as join19 } from "node:path";
 function bookDirectOfficerRunPointer(options) {
   const submissionToolCallId = options.submissionToolCallId?.trim() ?? "";
   const pointer = {
@@ -11366,7 +11064,7 @@ async function resolveOfficerPointer(raw, parentRunDirectory) {
   let runDirectory = typeof raw.runDirectory === "string" && raw.runDirectory.trim() !== "" ? raw.runDirectory : void 0;
   let sessionFile = raw.sessionFile;
   const recordedRunDirectory = runDirectory ?? runDirectoryOfSessionFile(sessionFile);
-  const leaf = parseRunLeaf(basename9(recordedRunDirectory));
+  const leaf = parseRunLeaf(basename8(recordedRunDirectory));
   const parentIdentity = await readRoleRunIdentity(parentRunDirectory);
   if (leaf !== void 0 && parentIdentity !== void 0) {
     const currentRunDirectory = await findRunDirectoryById(
@@ -11727,7 +11425,7 @@ var init_submission_gate = __esm({
 
 // src/session-opening-materials.ts
 import { existsSync as existsSync7 } from "node:fs";
-import { readFile as readFile10 } from "node:fs/promises";
+import { readFile as readFile9 } from "node:fs/promises";
 import { dirname as dirname12, join as join20 } from "node:path";
 import { fileURLToPath, pathToFileURL as pathToFileURL3 } from "node:url";
 function resolvePackageRootDir(moduleUrl = import.meta.url) {
@@ -11743,7 +11441,7 @@ function resolvePackageRootDir(moduleUrl = import.meta.url) {
   return fileURLToPath(new URL("..", moduleUrl));
 }
 async function readPackageMaterial(relativePath) {
-  return readFile10(fileURLToPath(new URL(relativePath, packageRootUrl)), "utf8");
+  return readFile9(fileURLToPath(new URL(relativePath, packageRootUrl)), "utf8");
 }
 async function joinPackageMaterials(relativePaths) {
   const chunks = [];
@@ -11801,7 +11499,7 @@ __export(auditor_soul_exports, {
   readAuditorResumeBinding: () => readAuditorResumeBinding,
   resolveAuditorSubject: () => resolveAuditorSubject
 });
-import { basename as basename10 } from "node:path";
+import { basename as basename9 } from "node:path";
 function auditorSoulRelativePath(role) {
   return `souls/${role}-auditor.md`;
 }
@@ -11837,7 +11535,7 @@ function loadAuditorReferenceMaterialsFromSubjectInput(raw) {
   return loadAuditorReferenceMaterials(resolveAuditorSubject(raw));
 }
 function subjectFromSourceDirectory(sourceRunDirectory) {
-  const role = parseRunLeaf(basename10(sourceRunDirectory))?.role;
+  const role = parseRunLeaf(basename9(sourceRunDirectory))?.role;
   return isAuditorSoulRole(role) ? role : void 0;
 }
 async function readAuditorResumeBinding(runDirectory) {
@@ -11877,7 +11575,7 @@ var init_auditor_soul = __esm({
 
 // src/public-cli/machine-method-skills.ts
 import { accessSync, constants as constants2, statSync as statSync5 } from "node:fs";
-import { lstat as lstat3, mkdir as mkdir2, symlink } from "node:fs/promises";
+import { lstat as lstat2, mkdir as mkdir2, symlink } from "node:fs/promises";
 import { join as join22 } from "node:path";
 import { spawnSync as spawnSync2 } from "node:child_process";
 function skillRoot(home) {
@@ -11907,7 +11605,7 @@ function linkedSkillRoot(home, host) {
 }
 async function occupied(path) {
   try {
-    await lstat3(path);
+    await lstat2(path);
     return true;
   } catch (error) {
     if (error.code !== "ENOENT") throw error;
@@ -12404,7 +12102,6 @@ var init_auto_resume = __esm({
 
 // src/public-cli/post-admission.ts
 import { randomUUID as randomUUID5 } from "node:crypto";
-import { isAbsolute as isAbsolute7, join as join23, resolve as resolve12 } from "node:path";
 function describeCaughtError(error) {
   if (error instanceof Error) {
     const code = error.code;
@@ -12426,7 +12123,7 @@ function projectRelocatedTurnIdentity(request, result, admitted, relocation) {
   mutableRequest.principal = admitted.principal;
   const activation = mutableRequest.activation;
   if (isRecord(activation)) {
-    for (const field of ["taskPath", "packetPath", "prerequisitesPath", "inputPath", "requestManifestPath"]) {
+    for (const field of ["inputPath"]) {
       const record = activation;
       if (field in record) record[field] = rewrite(record[field]);
     }
@@ -13159,7 +12856,7 @@ function resumeTurnRequestProjectionOptions(admitted, request, env, summonsPrepa
       prompt = request.message;
     }
   } else if (summonsPrepared !== void 0) {
-    prompt = officerDialogue ? summonsPrepared.instructionEmpty ? "" : summonsPrepared.instruction : buildInstructionTransportPrompt(summonsPrepared);
+    prompt = officerDialogue ? summonsPrepared.instruction : buildInstructionTransportPrompt(summonsPrepared);
   } else if (request.summons !== void 0) {
     prompt = "";
   } else {
@@ -13240,24 +12937,14 @@ async function runSettledAutoResumeLoop(input) {
     })
   });
 }
-function isAlreadyFrozenSummonsAttachment(runDirectory, attachmentPath) {
-  const absolute = isAbsolute7(attachmentPath) ? attachmentPath : resolve12(attachmentPath);
-  return pathContainedIn(join23(runDirectory, "attachments"), absolute);
-}
-async function prepareSummonsResumeMaterials(runDirectory, summons) {
+async function prepareSummonsResumeMaterials(_runDirectory, summons) {
   if (summons === void 0) return void 0;
   if (summons.instruction === void 0 && (summons.attachmentPaths?.length ?? 0) === 0) {
     return void 0;
   }
   const instruction = summons.instruction ?? "";
-  const instructionEmpty = summons.instructionEmpty ?? instruction.trim() === "";
-  let attachments = [];
-  if (summons.attachmentPaths !== void 0 && summons.attachmentPaths.length > 0) {
-    const alreadyFrozen = summons.attachmentPaths.every(
-      (path) => isAlreadyFrozenSummonsAttachment(runDirectory, path)
-    );
-    attachments = alreadyFrozen ? summons.attachmentPaths.map((frozenPath) => ({ frozenPath })) : await freezeAttachmentsIntoRun(summons.attachmentPaths, runDirectory);
-  }
+  const instructionEmpty = summons.instructionEmpty ?? instruction.length === 0;
+  const attachments = (summons.attachmentPaths ?? []).map((path) => ({ path }));
   return { instruction, instructionEmpty, attachments };
 }
 async function runPostAdmissionSeatResume(input) {
@@ -13306,23 +12993,6 @@ async function runPostAdmissionSeatResume(input) {
         openCourtAttemptId = openCourt.courtAttemptId;
       }
     }
-    if (request.summons !== void 0) {
-      const prepared = await prepareSummonsResumeMaterials(
-        admittedForBuild.runDirectory,
-        request.summons
-      );
-      if (prepared !== void 0 && (request.summons.attachmentPaths?.length ?? 0) > 0) {
-        request = {
-          ...request,
-          summons: {
-            ...request.summons,
-            attachmentPaths: prepared.attachments.map(
-              (attachment) => attachment.frozenPath
-            )
-          }
-        };
-      }
-    }
     let turnRequest = await input.buildTurnRequest(admittedForBuild, request);
     if (turnRequest.continuation.kind === "resume" && turnRequest.continuation.hostSessionId === void 0) {
       const hostSessionId = await readStoredHostSessionId(
@@ -13572,7 +13242,6 @@ var init_post_admission = __esm({
     init_invocation();
     init_submission_ledger();
     init_run_ticket_number();
-    init_activation_ledger_topology();
     init_session_identity();
     init_sitian_facade();
     init_receipt_delivery_policy();
@@ -13712,7 +13381,7 @@ __export(instruction_seat_run_exports, {
   runPublicInstructionSeat: () => runPublicInstructionSeat,
   runPublicInstructionSeatResume: () => runPublicInstructionSeatResume
 });
-import { dirname as dirname13, resolve as resolve13 } from "node:path";
+import { dirname as dirname13, resolve as resolve12 } from "node:path";
 function unreadablePostSubmissionStatus(admitted, terminal) {
   if (terminal?.roleOutcome.kind !== "accepted") return void 0;
   const route = POST_SUBMISSION_ROUTING[admitted.role];
@@ -13940,7 +13609,7 @@ async function runOmittedLensBatch(argv, parsed, env, io) {
   const children = await summonParallelReviewerLenses2({
     argv,
     cwd: env.cwd,
-    projectRoot: resolve13(parsed.project ?? env.cwd),
+    projectRoot: resolve12(parsed.project ?? env.cwd),
     baseRevision: parsed.baseRevision ?? "",
     home: env.home,
     agentDir: env.agentDir,
@@ -14022,14 +13691,14 @@ async function runCountersignBody(parsed, env, io) {
     const resumed = await resumeSameParentInstructionSeat({
       env,
       io,
-      projectRoot: resolve13(parsed.project ?? env.cwd),
+      projectRoot: resolve12(parsed.project ?? env.cwd),
       role: "countersign",
       parentRunPath: gateParentRunPath,
       ...isSafePositiveTicketNumber(env.boundTicketNumber) ? { ticketNumber: env.boundTicketNumber } : {},
       summons: {
         sourceRunPath: gateParentRunPath,
         instruction: resumeInstruction,
-        instructionEmpty: resumeInstruction.trim() === ""
+        instructionEmpty: resumeInstruction.length === 0
       }
     });
     if (resumed != null) return resumed;
@@ -14043,12 +13712,12 @@ async function runCountersignBody(parsed, env, io) {
     throw error;
   }
   try {
-    return await withPreparedAttachments(parsed.attachmentPaths ?? [], async (preparedAttachments) => {
+    {
       const materializeAdmission = async (ticketNumber) => {
         await materializeCountersignInvocation(admitted, {
           home: env.home,
           principalAuthority: env.principalAuthority,
-          preparedAttachments,
+          attachmentPaths: parsed.attachmentPaths ?? [],
           ...env.model === void 0 ? {} : { model: env.model },
           ...ticketNumber === void 0 ? {} : { ticketNumber }
         });
@@ -14083,7 +13752,7 @@ async function runCountersignBody(parsed, env, io) {
       });
       await relocateAdmittedRunToTicket(admitted, env.principalAuthority);
       return result;
-    });
+    }
   } catch (error) {
     const rejected = usageExit(error, io);
     if (rejected !== void 0) return rejected;
@@ -14148,7 +13817,7 @@ async function runPublicInstructionSeat(argv, env, io, role, parseArgv2) {
     const summons = {
       ...sameParentInstruction(env, {
         instruction: parsed.instruction ?? "",
-        instructionEmpty: (parsed.instruction ?? "").trim() === ""
+        instructionEmpty: (parsed.instruction ?? "").length === 0
       }),
       attachmentPaths: parsed.attachmentPaths ?? []
     };
@@ -14173,7 +13842,7 @@ async function runPublicInstructionSeat(argv, env, io, role, parseArgv2) {
         sourceRunPath: parentRunPath,
         ...sameParentInstruction(env, {
           instruction: parsed.instruction ?? "",
-          instructionEmpty: (parsed.instruction ?? "").trim() === ""
+          instructionEmpty: (parsed.instruction ?? "").length === 0
         }),
         attachmentPaths: parsed.attachmentPaths ?? []
       };
@@ -14257,7 +13926,7 @@ async function runPublicInstructionSeat(argv, env, io, role, parseArgv2) {
           instruction: parsed.instruction ?? "",
           projectRoot: admitted.projectRoot,
           failureLabel: "secretariat unbound summons",
-          attachmentPaths: admitted.attachments.map((attachment) => attachment.frozenPath),
+          attachmentPaths: admitted.attachments.map((attachment) => attachment.path),
           correlationId: admitted.runId
         }, env, io);
       } catch (error) {
@@ -14816,7 +14485,7 @@ var init_instruction_seat_run = __esm({
 
 // src/analyst-book-key.ts
 import { statSync as statSync6 } from "node:fs";
-import { isAbsolute as isAbsolute8 } from "node:path";
+import { isAbsolute as isAbsolute7 } from "node:path";
 function resolveAnalystBookKey(projectRoot) {
   const identity = physicalPathIdentity(projectRoot);
   let stats;
@@ -14838,7 +14507,7 @@ function resolveAnalystBookKey(projectRoot) {
   }
 }
 function isSyntheticAnalystBookKey(bookKey) {
-  return bookKey.startsWith("root:") && isAbsolute8(bookKey.slice("root:".length));
+  return bookKey.startsWith("root:") && isAbsolute7(bookKey.slice("root:".length));
 }
 var init_analyst_book_key = __esm({
   "src/analyst-book-key.ts"() {
@@ -14850,16 +14519,16 @@ var init_analyst_book_key = __esm({
 
 // src/atomic-write.ts
 import { randomUUID as randomUUID6 } from "node:crypto";
-import { rename as rename2, rm as rm2, writeFile as writeFile3 } from "node:fs/promises";
-import { dirname as dirname14, join as join24 } from "node:path";
+import { rename as rename2, rm, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname as dirname14, join as join23 } from "node:path";
 async function writeFileAtomically(destination, contents, options) {
   const parent = dirname14(destination);
-  const temporary = join24(parent, `.atomic-write-${randomUUID6()}.tmp`);
+  const temporary = join23(parent, `.atomic-write-${randomUUID6()}.tmp`);
   try {
     await writeFile3(temporary, contents, options);
     await rename2(temporary, destination);
   } catch (error) {
-    await rm2(temporary, { force: true }).catch(() => void 0);
+    await rm(temporary, { force: true }).catch(() => void 0);
     throw error;
   }
 }
@@ -14870,13 +14539,13 @@ var init_atomic_write = __esm({
 });
 
 // src/analyst-index.ts
-import { open, readFile as readFile11, unlink } from "node:fs/promises";
-import { dirname as dirname15, join as join25 } from "node:path";
+import { open, readFile as readFile10, unlink } from "node:fs/promises";
+import { dirname as dirname15, join as join24 } from "node:path";
 import { setTimeout as sleep } from "node:timers/promises";
 async function withAnalystLibraryIndexLock(ledgerHome, fn) {
   const indexPath = analystLibraryIndexPath(ledgerHome);
   ensureRealDirectoryTree(ledgerHome, dirname15(indexPath));
-  const lockPath = join25(dirname15(indexPath), LIBRARY_INDEX_LOCK_NAME);
+  const lockPath = join24(dirname15(indexPath), LIBRARY_INDEX_LOCK_NAME);
   assertLedgerFileInsideHome(lockPath, ledgerHome);
   const startedAt = Date.now();
   while (true) {
@@ -14903,7 +14572,7 @@ async function withAnalystLibraryIndexLock(ledgerHome, fn) {
   }
 }
 function analystLibraryIndexPath(ledgerHome) {
-  return join25(ledgerHome, "analyst", "library-index.json");
+  return join24(ledgerHome, "analyst", "library-index.json");
 }
 function rowFromIssueMetricsPage(page) {
   return {
@@ -14994,7 +14663,7 @@ async function readAnalystLibraryIndexPage(ledgerHome) {
   const path = analystLibraryIndexPath(ledgerHome);
   let raw;
   try {
-    raw = await readFile11(path, "utf8");
+    raw = await readFile10(path, "utf8");
   } catch (error) {
     if (isMissingPathError(error)) return void 0;
     throw error;
@@ -15449,7 +15118,7 @@ var init_analyst_gate_cycles_read = __esm({
 
 // src/analyst-ledger.ts
 import { readdir as readdir3 } from "node:fs/promises";
-import { basename as basename11, join as join26 } from "node:path";
+import { basename as basename10, join as join25 } from "node:path";
 async function readExistingRunLifecycleState(runDirectory) {
   return (await readRoleRunIdentity(runDirectory))?.state;
 }
@@ -15469,7 +15138,7 @@ function ghostLeaseCheckFromAutopsy(autopsy) {
   }
 }
 async function classifyGhostCandidate(input) {
-  const autopsy = await autopsyWriterLock(join26(input.runDirectory, "writer.lock"));
+  const autopsy = await autopsyWriterLock(join25(input.runDirectory, "writer.lock"));
   const leaseCheck = ghostLeaseCheckFromAutopsy(autopsy);
   if (leaseCheck === void 0) return { kind: "live" };
   return {
@@ -15759,7 +15428,7 @@ async function classifyScopedRun(input) {
 async function scanAnalystIssueRuns(input) {
   const ledgerHome = resolveActivationLedgerHome(input.home);
   const scopeTicketNumber = input.ticketNumber;
-  const booksRoot = join26(ledgerHome, "books");
+  const booksRoot = join25(ledgerHome, "books");
   let wholeBook = false;
   let scopeRootIdentity;
   let bookNames;
@@ -15792,7 +15461,7 @@ async function scanAnalystIssueRuns(input) {
   const ghostLegs = [];
   const scopeConflicts = [];
   for (const book of bookNames) {
-    const bookDir = join26(booksRoot, book);
+    const bookDir = join25(booksRoot, book);
     let runDirectories;
     try {
       runDirectories = await listBookRunDirectories(bookDir);
@@ -15801,7 +15470,7 @@ async function scanAnalystIssueRuns(input) {
       throw error;
     }
     for (const runDirectory of runDirectories) {
-      const runName = basename11(runDirectory);
+      const runName = basename10(runDirectory);
       const parsed = parseRunLeaf(runName);
       if (parsed === void 0) continue;
       let scopeFields;
@@ -16538,7 +16207,7 @@ var init_analyst_metric_family = __esm({
 });
 
 // src/analyst-page.ts
-import { dirname as dirname16, join as join27 } from "node:path";
+import { dirname as dirname16, join as join26 } from "node:path";
 function analystIssuePageKey(address) {
   const parts = ["book", address.bookKey];
   if (address.issueNumber !== void 0) {
@@ -16549,7 +16218,7 @@ function analystIssuePageKey(address) {
   return sha256Hex(parts.join("\0")).slice(0, 32);
 }
 function analystIssuePagePath(ledgerHome, address) {
-  return join27(ledgerHome, "analyst", "issues", `${analystIssuePageKey(address)}.json`);
+  return join26(ledgerHome, "analyst", "issues", `${analystIssuePageKey(address)}.json`);
 }
 function analystIssuePageAddressFromPage(page) {
   return {
@@ -16785,8 +16454,8 @@ var init_analyst_model_groups = __esm({
 });
 
 // src/analyst-entry.ts
-import { readFile as readFile13 } from "node:fs/promises";
-import { Type as Type17 } from "typebox";
+import { readFile as readFile12 } from "node:fs/promises";
+import { Type as Type16 } from "typebox";
 function cachedPageMatchesRequestedScope(page, input) {
   if (page.bookKey !== input.bookKey) return false;
   const requestedTicket = input.ticketNumber ?? input.issueNumber;
@@ -16813,7 +16482,7 @@ async function readOrComputeAnalystIssuePage(input, options) {
     ...issueNumber === void 0 && input.bookKey === void 0 ? { scopeRootIdentity: projectRoot } : {}
   });
   try {
-    const raw = await readFile13(pagePath, "utf8");
+    const raw = await readFile12(pagePath, "utf8");
     const page = JSON.parse(raw);
     if (cachedPageMatchesRequestedScope(page, { bookKey, ...input })) {
       const ghostScan = await scanAnalystIssueRuns({
@@ -16914,7 +16583,7 @@ async function runAnalystModelGroupsMode(input, home) {
       scopeRootIdentity: projectRoot
     });
     try {
-      const raw = await readFile13(pagePath, "utf8");
+      const raw = await readFile12(pagePath, "utf8");
       JSON.parse(raw);
     } catch (error) {
       if (!isMissingPathError(error)) {
@@ -16991,16 +16660,16 @@ var init_analyst_entry = __esm({
         }
       }
     };
-    analystSweepModeInputSchema = Type17.Object(
+    analystSweepModeInputSchema = Type16.Object(
       {
-        mode: Type17.Literal("sweep"),
-        mergedPullRequests: Type17.Array(
-          Type17.Object(
+        mode: Type16.Literal("sweep"),
+        mergedPullRequests: Type16.Array(
+          Type16.Object(
             {
-              projectRoot: Type17.String(),
+              projectRoot: Type16.String(),
               /** 排除后改动行数 — omit or 0 → typed 空缺; finite ≥ 0 only. */
-              changedLines: Type17.Optional(
-                Type17.Number({ minimum: 0, maximum: Number.MAX_VALUE })
+              changedLines: Type16.Optional(
+                Type16.Number({ minimum: 0, maximum: Number.MAX_VALUE })
               )
             }
           )
@@ -17011,9 +16680,9 @@ var init_analyst_entry = __esm({
 });
 
 // src/public-cli/analyst-run.ts
-import { readFile as readFile14 } from "node:fs/promises";
-import { isAbsolute as isAbsolute9, resolve as resolve14 } from "node:path";
-import { Value as Value2 } from "typebox/value";
+import { readFile as readFile13 } from "node:fs/promises";
+import { isAbsolute as isAbsolute8, resolve as resolve13 } from "node:path";
+import { Value } from "typebox/value";
 function resolveAnalystIssueBookKeyFromCwd(cwd = process.cwd()) {
   try {
     return resolveBookKeyFromGit(cwd);
@@ -17048,7 +16717,7 @@ async function buildAnalystIssueModeInputFromPublicArgv(parsed, _ledgerHome) {
   };
 }
 function parseAnalystSweepModeInputFromJsonValue(value) {
-  if (!Value2.Check(analystSweepModeInputSchema, value)) {
+  if (!Value.Check(analystSweepModeInputSchema, value)) {
     throw new CliUsageError(
       "analyst sweep attachment must match AnalystSweepModeInput"
     );
@@ -17062,10 +16731,10 @@ async function buildAnalystSweepModeInputFromAttachmentPaths(attachmentPaths) {
     );
   }
   const sourcePath = attachmentPaths[0];
-  const absolute = isAbsolute9(sourcePath) ? sourcePath : resolve14(sourcePath);
+  const absolute = isAbsolute8(sourcePath) ? sourcePath : resolve13(sourcePath);
   let bytes;
   try {
-    bytes = await readFile14(absolute);
+    bytes = await readFile13(absolute);
   } catch (error) {
     throw new CliUsageError(
       `analyst sweep attachment is not a readable regular file: ${sourcePath}`,
@@ -18095,7 +17764,7 @@ __export(public_role_summons_exports, {
 import { execFile as execFile3 } from "node:child_process";
 import { existsSync as existsSync8 } from "node:fs";
 import { realpath as realpath6 } from "node:fs/promises";
-import { join as join28 } from "node:path";
+import { join as join27 } from "node:path";
 import { promisify as promisify3 } from "node:util";
 function createCapturingIo() {
   const chunks = [];
@@ -18119,7 +17788,7 @@ function parentDir(path) {
 function walkPackageRoot(start) {
   let dir = start;
   for (let i = 0; i < 12; i += 1) {
-    if (existsSync8(join28(dir, "package.json")) && existsSync8(join28(dir, "souls"))) {
+    if (existsSync8(join27(dir, "package.json")) && existsSync8(join27(dir, "souls"))) {
       return dir;
     }
     const parent = parentDir(dir);
@@ -18339,7 +18008,7 @@ async function summonPublicRole(options) {
         runId: resumeRunId,
         summons: {
           instruction,
-          instructionEmpty: instruction.trim() === ""
+          instructionEmpty: instruction.length === 0
         }
       },
       env,
@@ -18728,7 +18397,7 @@ var init_compliance_transport = __esm({
 });
 
 // src/role-run-relocation.ts
-import { dirname as dirname17, join as join29, sep as sep4 } from "node:path";
+import { dirname as dirname17, join as join28, sep as sep4 } from "node:path";
 function rewriteRunDirectoryPathValue(value, oldRunDirectory, newRunDirectory) {
   if (typeof value !== "string") return value;
   if (value === oldRunDirectory) return newRunDirectory;
@@ -18808,13 +18477,6 @@ function rewriteSourceRunLocator(value, rewrites) {
 function rewriteAdmittedRoleRunPage(page, rewrites) {
   rewriteRunDirectoryPathFieldsAgainstRewrites(page, ADMITTED_PAGE_FIELDS, rewrites);
   rewriteSourceRunLocator(page.sourceRun, rewrites);
-  if (Array.isArray(page.attachments)) {
-    for (const attachment of page.attachments) {
-      if (isRecord(attachment)) {
-        rewriteRunDirectoryPathFieldsAgainstRewrites(attachment, ["frozenPath"], rewrites);
-      }
-    }
-  }
   if (isRecord(page.principal)) {
     rewriteRunDirectoryPathFieldsAgainstRewrites(
       page.principal,
@@ -18839,10 +18501,9 @@ var init_role_run_relocation = __esm({
       // pre-#1161 pages only
       "sessionDirectory",
       "sessionFile",
-      "taskPath",
-      "packetPath",
-      "prerequisitesPath",
-      "requestManifestPath",
+      // #1165/#1168: caller file-flag paths (requestManifestPath, prerequisitesPath)
+      // stay as given. Obsolete copy fields (taskPath/packetPath) are not rewritten —
+      // stock volumes keep their bytes; live relocate no longer maintains them.
       "mergerInputPath",
       "sourceRunPath"
     ];
@@ -18877,8 +18538,8 @@ __export(run_lifecycle_exports, {
   recordCurrentCourt: () => recordCurrentCourt,
   writeRoleRunState: () => writeRoleRunState
 });
-import { chmod, lstat as lstat4, open as open2, readdir as readdir4, readFile as readFile15, unlink as unlink2 } from "node:fs/promises";
-import { basename as basename12, join as join30 } from "node:path";
+import { chmod, lstat as lstat3, open as open2, readdir as readdir4, readFile as readFile14, unlink as unlink2 } from "node:fs/promises";
+import { basename as basename11, join as join29 } from "node:path";
 function buildAutoResumeContinuationPrompt() {
   return RESUME_TRANSPORT_ENVELOPE;
 }
@@ -18891,7 +18552,7 @@ function parseSameTicketSummonsMaterials(raw) {
   const record = raw;
   const instruction = typeof record.instruction === "string" ? record.instruction : void 0;
   const instructionEmpty = typeof record.instructionEmpty === "boolean" ? record.instructionEmpty : void 0;
-  const attachmentPaths = Array.isArray(record.attachmentPaths) ? record.attachmentPaths.filter((p) => typeof p === "string" && p.length > 0) : void 0;
+  const attachmentPaths = Array.isArray(record.attachmentPaths) ? record.attachmentPaths.filter((p) => typeof p === "string") : void 0;
   const sourceRunPath = typeof record.sourceRunPath === "string" && record.sourceRunPath.trim() !== "" ? record.sourceRunPath : void 0;
   let sourceRun;
   if (isRecord(record.sourceRun)) {
@@ -19116,7 +18777,7 @@ function isProcessAlive(pid) {
 async function autopsyWriterLock(lockPath) {
   let content;
   try {
-    content = await readFile15(lockPath, "utf8");
+    content = await readFile14(lockPath, "utf8");
   } catch (error) {
     if (errorCodeOf(error) === "ENOENT") return { verdict: "absent" };
     return { verdict: "unknown", reason: "unreadable", readFailure: error };
@@ -19175,7 +18836,7 @@ async function createWriterLease(lockPath, runDirectory, reportCleanupFailure) {
     },
     relocate(nextRunDirectory) {
       currentRunDirectory = nextRunDirectory;
-      currentLockPath = join30(nextRunDirectory, WRITER_LOCK_FILE);
+      currentLockPath = join29(nextRunDirectory, WRITER_LOCK_FILE);
     },
     async release() {
       if (released) return;
@@ -19214,10 +18875,10 @@ async function acquireRunWriterLease(runDirectory, onCleanupFailure) {
   };
   const reportReadFailure = (error) => {
     reportDiagnostic(
-      `writer lease lock read failed (holder liveness unverifiable; lock left in place) at ${join30(runDirectory, WRITER_LOCK_FILE)}: ${describeErrorIdentity(error)}`
+      `writer lease lock read failed (holder liveness unverifiable; lock left in place) at ${join29(runDirectory, WRITER_LOCK_FILE)}: ${describeErrorIdentity(error)}`
     );
   };
-  const lockPath = join30(runDirectory, WRITER_LOCK_FILE);
+  const lockPath = join29(runDirectory, WRITER_LOCK_FILE);
   let lastAutopsy = { verdict: "absent" };
   let lastReclaimFailure;
   for (let reclaimsLeft = WRITER_LEASE_RECLAIM_ROUNDS; ; reclaimsLeft -= 1) {
@@ -19274,7 +18935,7 @@ async function acquireRunWriterLease(runDirectory, onCleanupFailure) {
 async function findRunDirectoryById(home, runId, onlyBookKey, onlyRole) {
   if (runId.trim() === "") return void 0;
   const ledgerHome = resolveActivationLedgerHome(home);
-  const booksRoot = join30(ledgerHome, "books");
+  const booksRoot = join29(ledgerHome, "books");
   let bookKeys;
   try {
     bookKeys = await readdir4(booksRoot);
@@ -19309,7 +18970,7 @@ async function runHasFormedSessionPrincipal(runDirectory) {
   if (disk === void 0) return false;
   const sessionFile = typeof disk.principalWire.sessionFile === "string" && disk.principalWire.sessionFile.trim() !== "" ? disk.principalWire.sessionFile : sessionFileIn(disk.principalWire.sessionDirectory);
   try {
-    const stat2 = await lstat4(sessionFile);
+    const stat2 = await lstat3(sessionFile);
     return stat2.isFile() && !stat2.isSymbolicLink();
   } catch (error) {
     if (errorCodeOf(error) === "ENOENT") return false;
@@ -19325,7 +18986,7 @@ async function findLatestRunIdForSeatTicket(input) {
   let runDirectories;
   try {
     runDirectories = await listBookRunDirectories(
-      input.ticketNumber === void 0 ? bookDir : join30(bookDir, String(input.ticketNumber))
+      input.ticketNumber === void 0 ? bookDir : join29(bookDir, String(input.ticketNumber))
     );
   } catch (error) {
     if (errorCodeOf(error) === "ENOENT") return void 0;
@@ -19333,7 +18994,7 @@ async function findLatestRunIdForSeatTicket(input) {
   }
   let best;
   for (const runDirectory of runDirectories) {
-    const parsed = parseRunLeaf(basename12(runDirectory));
+    const parsed = parseRunLeaf(basename11(runDirectory));
     if (parsed === void 0 || parsed.role !== input.role) continue;
     const runId = parsed.runId;
     const parentPath = await readRunParentPath(runDirectory);
@@ -19375,10 +19036,7 @@ async function loadResumableRunRecord(home, runId, authority) {
   let instructionEmpty = true;
   let attachments = [];
   let phase;
-  let taskPath;
-  let packetPath;
   let prerequisitesPath;
-  let prerequisites;
   let baseRevision;
   let lens;
   let authorityRefs;
@@ -19390,7 +19048,6 @@ async function loadResumableRunRecord(home, runId, authority) {
   let repository;
   let repositoryDisplay;
   let requestManifestPath;
-  let manifestDigest;
   let waitWindowMs;
   let issueNumber;
   let caseRunsPath;
@@ -19413,23 +19070,14 @@ async function loadResumableRunRecord(home, runId, authority) {
         instructionEmpty = record.instructionEmpty;
       }
       if (Array.isArray(record.attachments)) {
-        attachments = record.attachments;
+        attachments = record.attachments.map((item) => normalizeAdmittedAttachment(item)).filter((item) => item !== void 0);
       }
       if (record.phase === "plan" || record.phase === "apply") {
         phase = record.phase;
       }
-      if (typeof record.taskPath === "string" && record.taskPath.trim() !== "") {
-        taskPath = record.taskPath;
-      }
-      if (typeof record.packetPath === "string" && record.packetPath.trim() !== "") {
-        packetPath = record.packetPath;
-      }
-      if (typeof record.prerequisitesPath === "string" && record.prerequisitesPath.trim() !== "") {
+      if (typeof record.prerequisitesPath === "string") {
         prerequisitesPath = record.prerequisitesPath;
       }
-      if (Array.isArray(record.prerequisites)) {
-        prerequisites = record.prerequisites;
-      }
       if (typeof record.baseRevision === "string" && record.baseRevision.trim() !== "") {
         baseRevision = record.baseRevision;
       }
@@ -19445,12 +19093,9 @@ async function loadResumableRunRecord(home, runId, authority) {
       if (typeof record.repositoryDisplay === "string" && record.repositoryDisplay.trim() !== "") {
         repositoryDisplay = record.repositoryDisplay;
       }
-      if (typeof record.requestManifestPath === "string" && record.requestManifestPath.trim() !== "") {
+      if (typeof record.requestManifestPath === "string") {
         requestManifestPath = record.requestManifestPath;
       }
-      if (typeof record.manifestDigest === "string" && record.manifestDigest.trim() !== "") {
-        manifestDigest = record.manifestDigest;
-      }
       if (typeof record.waitWindowMs === "number" && Number.isSafeInteger(record.waitWindowMs) && record.waitWindowMs >= 1) {
         waitWindowMs = record.waitWindowMs;
       }
@@ -19544,7 +19189,7 @@ async function loadResumableRunRecord(home, runId, authority) {
       );
     }
   }
-  const sourceRunLeaf = parseRunLeaf(basename12(sourceRunPath ?? ""));
+  const sourceRunLeaf = parseRunLeaf(basename11(sourceRunPath ?? ""));
   const referencedRunId = sourceRun?.runId ?? sourceRunLeaf?.runId;
   const referencedRole = sourceRun?.role ?? sourceRunLeaf?.role;
   if (referencedRunId !== void 0 && referencedRunId !== "") {
@@ -19569,10 +19214,7 @@ async function loadResumableRunRecord(home, runId, authority) {
       instructionEmpty,
       attachments,
       ...phase === void 0 ? {} : { phase },
-      ...taskPath === void 0 ? {} : { taskPath },
-      ...packetPath === void 0 ? {} : { packetPath },
       ...prerequisitesPath === void 0 ? {} : { prerequisitesPath },
-      ...prerequisites === void 0 ? {} : { prerequisites },
       ...baseRevision === void 0 ? {} : { baseRevision },
       ...lens === void 0 ? {} : { lens },
       ...authorityRefs === void 0 ? {} : { authorityRefs },
@@ -19584,7 +19226,6 @@ async function loadResumableRunRecord(home, runId, authority) {
       ...repository === void 0 ? {} : { repository },
       ...repositoryDisplay === void 0 ? {} : { repositoryDisplay },
       ...requestManifestPath === void 0 ? {} : { requestManifestPath },
-      ...manifestDigest === void 0 ? {} : { manifestDigest },
       ...waitWindowMs === void 0 ? {} : { waitWindowMs },
       ...issueNumber === void 0 ? {} : { issueNumber },
       ...caseRunsPath === void 0 ? {} : { caseRunsPath },
@@ -19658,12 +19299,6 @@ function admitResumedRole(loaded) {
     }
     case "worker-task": {
       const phase = resumedWorkerPhase(fields.phase ?? loaded.run.phase, record.phases, role, runId);
-      const taskPath = fields.taskPath;
-      if (taskPath === void 0) {
-        throw new CliUsageError(
-          `role run admitted coder task path is missing: ${runId}`
-        );
-      }
       if (fields.instruction.trim() === "") {
         throw new CliUsageError(
           `role run admitted coder task is blank: ${runId}`
@@ -19673,33 +19308,23 @@ function admitResumedRole(loaded) {
         role: "coder",
         phase,
         ...base,
-        instructionEmpty: false,
-        taskPath
+        instructionEmpty: false
       };
       return admitted;
     }
     case "worker-packet": {
       const phase = resumedWorkerPhase(fields.phase ?? loaded.run.phase, record.phases, role, runId);
-      const packetPath = fields.packetPath;
-      if (packetPath === void 0) {
-        throw new CliUsageError(
-          `role run admitted fixer packet path is missing: ${runId}`
-        );
-      }
       if (fields.instruction.trim() === "") {
         throw new CliUsageError(
           `role run admitted fixer instruction is blank: ${runId}`
         );
       }
-      const prerequisites = fields.prerequisites ?? Object.freeze([]);
       const admitted = {
         role: "fixer",
         phase,
         ...base,
         instructionEmpty: false,
-        packetPath,
-        ...fields.prerequisitesPath === void 0 ? {} : { prerequisitesPath: fields.prerequisitesPath },
-        prerequisites
+        ...fields.prerequisitesPath === void 0 ? {} : { prerequisitesPath: fields.prerequisitesPath }
       };
       return admitted;
     }
@@ -19774,8 +19399,8 @@ function admitResumedRole(loaded) {
       return admitted;
     }
     case "collect-target": {
-      const { prNumber, repository, repositoryDisplay, manifestDigest } = fields;
-      if (repository === void 0 || repositoryDisplay === void 0 || manifestDigest === void 0) {
+      const { prNumber, repository, repositoryDisplay } = fields;
+      if (repository === void 0 || repositoryDisplay === void 0) {
         throw new CliUsageError(
           `role run admitted collector repository identity is missing: ${runId}`
         );
@@ -19798,8 +19423,7 @@ function admitResumedRole(loaded) {
         ...prNumber === void 0 ? {} : { prNumber },
         repository: parsedRepository,
         ...fields.requestManifestPath === void 0 ? {} : { requestManifestPath: fields.requestManifestPath },
-        ...fields.waitWindowMs === void 0 ? {} : { waitWindowMs: fields.waitWindowMs },
-        manifestDigest
+        ...fields.waitWindowMs === void 0 ? {} : { waitWindowMs: fields.waitWindowMs }
       };
       return admitted;
     }
@@ -20105,7 +19729,7 @@ var init_receipt_delivery_policy = __esm({
 });
 
 // src/archivist-record-topology.ts
-import { join as join32 } from "node:path";
+import { join as join31 } from "node:path";
 function resolveNavigatorWorkSubjectPlacement(input) {
   let ledgerHome;
   if (input.parentSessionFile !== void 0 && input.parentSessionFile.length > 0) {
@@ -20118,7 +19742,7 @@ function resolveNavigatorWorkSubjectPlacement(input) {
   const digest = sha256Hex(input.subject).slice(0, 32);
   return {
     ledgerHome,
-    sessionDir: join32(
+    sessionDir: join31(
       activationBookDirectory(ledgerHome, resolveBookKeyFromGit(input.cwd)),
       NAVIGATOR_RECORD_KIND,
       digest
@@ -20191,7 +19815,7 @@ import {
   statSync as statSync8,
   writeFileSync as writeFileSync3
 } from "node:fs";
-import { dirname as dirname19, resolve as resolve17, join as join33 } from "node:path";
+import { dirname as dirname19, resolve as resolve16, join as join32 } from "node:path";
 import { StringDecoder } from "node:string_decoder";
 function readCurrentSession(sessionDir) {
   const ledger = currentSessionLedgerPath(sessionDir);
@@ -20225,7 +19849,7 @@ function isCurrentSessionClaimRace(error) {
   return errnoCode(error.cause) === "EEXIST";
 }
 function currentSessionLedgerPath(sessionDir) {
-  return join33(sessionDir, CURRENT_SESSION_LEDGER);
+  return join32(sessionDir, CURRENT_SESSION_LEDGER);
 }
 function readBoundedSessionHeader(filePath) {
   const fd = openSync(filePath, "r");
@@ -20298,8 +19922,8 @@ function parseSessionHeaderLine(line2) {
   };
 }
 function mostRecentNavigatorSessionFile(sessionDir, cwd) {
-  const absoluteSessionDir = resolve17(sessionDir);
-  const absoluteCwd = resolve17(cwd);
+  const absoluteSessionDir = resolve16(sessionDir);
+  const absoluteCwd = resolve16(cwd);
   let names;
   try {
     names = readdirSync3(absoluteSessionDir);
@@ -20312,7 +19936,7 @@ function mostRecentNavigatorSessionFile(sessionDir, cwd) {
   const matched = [];
   for (const name of names) {
     if (!name.endsWith(".jsonl")) continue;
-    const filePath = join33(absoluteSessionDir, name);
+    const filePath = join32(absoluteSessionDir, name);
     let st;
     try {
       st = statSync8(filePath);
@@ -20334,7 +19958,7 @@ function mostRecentNavigatorSessionFile(sessionDir, cwd) {
     }
     if (header === void 0) continue;
     if (typeof header.cwd !== "string" || header.cwd.length === 0) continue;
-    if (resolve17(header.cwd) !== absoluteCwd) continue;
+    if (resolve16(header.cwd) !== absoluteCwd) continue;
     matched.push({ path: filePath, mtimeMs: st.mtimeMs });
   }
   if (matched.length === 0) return void 0;
@@ -20364,8 +19988,8 @@ function resolveNavigatorNestContinuation(sessionDir, cwd) {
   }
 }
 function assertRecentFinalFileUnderSessionDir(sessionDir, recentFile) {
-  const absoluteSessionDir = resolve17(sessionDir);
-  const absoluteFile = resolve17(recentFile);
+  const absoluteSessionDir = resolve16(sessionDir);
+  const absoluteFile = resolve16(recentFile);
   if (absoluteFile !== absoluteSessionDir && !pathContainedIn(absoluteSessionDir, absoluteFile)) {
     throw new ActivationLedgerError(
       `archivist record session must be under the authorized nest (${sessionDir}): ${recentFile}`
@@ -20420,7 +20044,7 @@ function createRecordSessionOpen(options, host = piRecordSessionHost) {
     throw new Error("Durable record ownership requires a parent session inside the ledger home");
   } else {
     ledgerHome = resolveActivationLedgerHomeForPath(parentFile);
-    const parentResolved = resolve17(parentFile);
+    const parentResolved = resolve16(parentFile);
     if (!physicallyContainedIn(ledgerHome, parentResolved)) {
       throw new Error("Durable record ownership requires a parent session inside the ledger home");
     }
@@ -20511,22 +20135,22 @@ init_submission_ledger();
 init_filed_submission();
 import { randomUUID as randomUUID7 } from "node:crypto";
 import { writeSync as writeSync2 } from "node:fs";
-import { join as join35 } from "node:path";
-import { Value as Value4 } from "typebox/value";
+import { join as join34 } from "node:path";
+import { Value as Value3 } from "typebox/value";
 
 // src/activation-trace.ts
-import { Type as Type18 } from "typebox";
-var causeSchema = Type18.Object({
-  identity: Type18.String({ minLength: 1 }),
-  name: Type18.String({ minLength: 1 }),
-  message: Type18.String(),
-  evidenceId: Type18.Optional(Type18.String({ minLength: 1 }))
+import { Type as Type17 } from "typebox";
+var causeSchema = Type17.Object({
+  identity: Type17.String({ minLength: 1 }),
+  name: Type17.String({ minLength: 1 }),
+  message: Type17.String(),
+  evidenceId: Type17.Optional(Type17.String({ minLength: 1 }))
 }, { additionalProperties: false });
-var activationTraceRecordSchema = Type18.Object({
-  role: Type18.String({ minLength: 1 }),
-  stageId: Type18.String({ pattern: "^[a-z][a-z0-9-]*$" }),
-  status: Type18.Literal("failed"),
-  timestamp: Type18.String({ format: "date-time" }),
+var activationTraceRecordSchema = Type17.Object({
+  role: Type17.String({ minLength: 1 }),
+  stageId: Type17.String({ pattern: "^[a-z][a-z0-9-]*$" }),
+  status: Type17.Literal("failed"),
+  timestamp: Type17.String({ format: "date-time" }),
   cause: causeSchema
 }, { additionalProperties: false });
 var activationCauseEvidence = 0;
@@ -20563,7 +20187,7 @@ import {
   statSync as statSync7,
   writeFileSync as writeFileSync2
 } from "node:fs";
-import { isAbsolute as isAbsolute11, resolve as resolve15 } from "node:path";
+import { isAbsolute as isAbsolute10, resolve as resolve14 } from "node:path";
 var ActivationSessionFileMissingError = class extends Error {
   code = "AK_ACTIVATION_SESSION_FILE_MISSING";
   path;
@@ -20603,12 +20227,12 @@ function durableSessionPointer(sessionManager) {
       "Workflow role activation requires a durable Pi session file principal (getSessionFile); directory-only or --no-session invocations are rejected"
     );
   }
-  if (!isAbsolute11(file)) {
+  if (!isAbsolute10(file)) {
     throw new Error(
       `Workflow role activation requires an absolute durable session file path; got relative path: ${file}`
     );
   }
-  const resolvedFile = resolve15(file);
+  const resolvedFile = resolve14(file);
   try {
     lstatSync2(resolvedFile);
   } catch (error) {
@@ -20691,10 +20315,10 @@ init_engine_material();
 init_engine_detour();
 init_engine_detour_usage();
 init_run_terminal_artifacts();
-import { Type as Type19 } from "typebox";
-var engineDetourArgsSchema = Type19.Object(
+import { Type as Type18 } from "typebox";
+var engineDetourArgsSchema = Type18.Object(
   {
-    argv: Type19.Array(Type19.String({ minLength: 1 }), {
+    argv: Type18.Array(Type18.String({ minLength: 1 }), {
       minItems: 1,
       description: "\u9996\u9879\u4E3A PATH \u4E2D\u7684\u53EF\u6267\u884C\u6587\u4EF6\uFF0C\u5176\u4F59\u9879\u4E3A\u53C2\u6570\u3002"
     })
@@ -20852,7 +20476,7 @@ var COLLECTOR_TRANSPORT_FLAGS = Object.freeze([
   Object.freeze({
     name: "ak-collector-request-manifest",
     definition: Object.freeze({
-      description: "Path to the Collector v1 request manifest JSON file (caller guidance; not a machine collection directive).",
+      description: "Caller path to a request manifest JSON file (passed as-is; package does not read or validate).",
       type: "string"
     })
   })
@@ -20863,19 +20487,9 @@ function buildMethodContext(activation) {
     `host: github.com`,
     `repository: ${activation.repository.canonical}`,
     `prNumber: ${activation.prNumber === void 0 ? "\u672A\u7ED1\u5B9A" : String(activation.prNumber)}`,
-    `requests: ${JSON.stringify(activation.manifest.requests.map((request) => ({ id: request.id })))}`,
-    `manifestDigest: ${activation.manifest.digest}`,
+    ...activation.requestManifestPath === void 0 ? [] : [`requestManifestPath: ${activation.requestManifestPath}`],
     "</collector_method>"
   ];
-  if (activation.manifest.requests.length > 0) {
-    const payload = JSON.stringify({
-      requests: activation.manifest.requests.map((request) => ({
-        id: request.id,
-        body: request.requestBody
-      }))
-    }).replaceAll("<", "\\u003c");
-    lines.push("", "<collector_request_manifest>", payload, "</collector_request_manifest>");
-  }
   return lines.join("\n");
 }
 function createCollectorRoleRuntime(pi, dependencies) {
@@ -20897,12 +20511,12 @@ function createCollectorRoleRuntime(pi, dependencies) {
       } else if (typeof prFlag === "number") {
         prNumber = parseCollectorPrNumber(prFlag);
       }
-      const manifest = typeof requestManifestFlag === "string" && requestManifestFlag.trim().length > 0 ? await loadCollectorManifest(requestManifestFlag) : emptyCollectorManifest();
+      const requestManifestPath = typeof requestManifestFlag === "string" ? requestManifestFlag : void 0;
       return {
         soul,
         repository,
         prNumber,
-        manifest
+        ...requestManifestPath === void 0 ? {} : { requestManifestPath }
       };
     },
     assembleMaterials(activation, baseSystemPrompt) {
@@ -21189,19 +20803,19 @@ var AUDITOR_TOOL_SPEC = roleSubmissionDeclaration("auditor");
 init_navigator_invocation_identity();
 init_packaged_role_registry();
 init_activation_ledger_topology();
-import { resolve as resolve18 } from "node:path";
+import { resolve as resolve17 } from "node:path";
 import "@earendil-works/pi-coding-agent";
-import { Type as Type21 } from "typebox";
+import { Type as Type20 } from "typebox";
 
 // src/navigator-public-session.ts
 init_host_session_record();
 import { existsSync as existsSync12 } from "node:fs";
-import { basename as basename14 } from "node:path";
+import { basename as basename13 } from "node:path";
 
 // src/navigator-session-contracts.ts
 init_unknown_value();
-import { Type as Type20 } from "typebox";
-import { Value as Value3 } from "typebox/value";
+import { Type as Type19 } from "typebox";
+import { Value as Value2 } from "typebox/value";
 var NAVIGATOR_PREPARE_TOOL_NAME = "ak_navigator_prepare";
 var NAVIGATOR_UNAVAILABLE_KEYS = /* @__PURE__ */ new Set([
   "context",
@@ -21305,26 +20919,26 @@ function navigatorProviderFailureFromPublicTerminal(outcome) {
   if (typed !== void 0) return { source: typed, cause: typed };
   return { source: "unknown", cause: "unknown" };
 }
-var navigatorProviderFailureSchema = Type20.Object({
-  source: Type20.Union([
-    Type20.Literal("context"),
-    Type20.Literal("session"),
-    Type20.Literal("model"),
-    Type20.Literal("thinking"),
-    Type20.Literal("auth"),
-    Type20.Literal("quota"),
-    Type20.Literal("transport"),
-    Type20.Literal("unknown")
+var navigatorProviderFailureSchema = Type19.Object({
+  source: Type19.Union([
+    Type19.Literal("context"),
+    Type19.Literal("session"),
+    Type19.Literal("model"),
+    Type19.Literal("thinking"),
+    Type19.Literal("auth"),
+    Type19.Literal("quota"),
+    Type19.Literal("transport"),
+    Type19.Literal("unknown")
   ]),
-  cause: Type20.Union([
-    Type20.Literal("context"),
-    Type20.Literal("session"),
-    Type20.Literal("model"),
-    Type20.Literal("thinking"),
-    Type20.Literal("auth"),
-    Type20.Literal("quota"),
-    Type20.Literal("transport"),
-    Type20.Literal("unknown")
+  cause: Type19.Union([
+    Type19.Literal("context"),
+    Type19.Literal("session"),
+    Type19.Literal("model"),
+    Type19.Literal("thinking"),
+    Type19.Literal("auth"),
+    Type19.Literal("quota"),
+    Type19.Literal("transport"),
+    Type19.Literal("unknown")
   ])
 }, { additionalProperties: false });
 function parseNavigatorModelSetting(value) {
@@ -21390,18 +21004,18 @@ init_packaged_role_registry();
 init_atomic_write();
 init_unknown_value();
 import { existsSync as existsSync9, realpathSync as realpathSync3 } from "node:fs";
-import { readFile as readFile16 } from "node:fs/promises";
-import { basename as basename13, dirname as dirname18, join as join31, resolve as resolve16 } from "node:path";
+import { readFile as readFile15 } from "node:fs/promises";
+import { basename as basename12, dirname as dirname18, join as join30, resolve as resolve15 } from "node:path";
 var NAVIGATOR_WORK_CONTEXT_BASENAME = "work-context.json";
 function navigatorWorkContextFile(sessionDir) {
-  return join31(sessionDir, NAVIGATOR_WORK_CONTEXT_BASENAME);
+  return join30(sessionDir, NAVIGATOR_WORK_CONTEXT_BASENAME);
 }
 function isNavigatorWorkContextFile(path) {
-  const resolved = resolve16(path);
-  if (basename13(resolved) !== NAVIGATOR_WORK_CONTEXT_BASENAME) return false;
+  const resolved = resolve15(path);
+  if (basename12(resolved) !== NAVIGATOR_WORK_CONTEXT_BASENAME) return false;
   const nest = dirname18(resolved);
-  if (!/^[0-9a-f]{32}$/.test(basename13(nest))) return false;
-  return basename13(dirname18(nest)) === "navigator";
+  if (!/^[0-9a-f]{32}$/.test(basename12(nest))) return false;
+  return basename12(dirname18(nest)) === "navigator";
 }
 function canonicalNavigatorWorkContextFile(path) {
   if (!isNavigatorWorkContextFile(path)) return void 0;
@@ -21419,7 +21033,7 @@ async function persistNavigatorWorkBase(sessionDir, body) {
   const next = `${JSON.stringify({ subject: body.subject, authority: body.authority })}
 `;
   try {
-    const current = await readFile16(path, "utf8");
+    const current = await readFile15(path, "utf8");
     if (current === next) return path;
   } catch (error) {
     if (!isEnoent(error)) throw error;
@@ -21432,7 +21046,7 @@ async function readNavigatorWorkBase(path) {
   if (canonical === void 0) return void 0;
   let text;
   try {
-    text = await readFile16(canonical, "utf8");
+    text = await readFile15(canonical, "utf8");
   } catch (error) {
     if (isEnoent(error)) return void 0;
     throw error;
@@ -21506,7 +21120,7 @@ async function resolveNavigatorLedgerHome(context) {
 }
 var NAVIGATOR_HOST_RUN_POINTER_ENTRY = "ak-navigator-host-run";
 function runIdFromNavigatorDirectory(runDirectory) {
-  const parsed = parseRunLeaf(basename14(runDirectory));
+  const parsed = parseRunLeaf(basename13(runDirectory));
   if (parsed === void 0 || parsed.role !== "navigator") return void 0;
   return parsed.runId;
 }
@@ -21702,8 +21316,8 @@ function resolveNavigatorAuthorityMaterial(roleInput, fileAuthority) {
   return void 0;
 }
 var NAVIGATOR_TARGETS = PACKAGED_ROLE_REGISTRY.map(({ role, phases }) => ({ role, phases }));
-var prepareSchema = Type21.Object({
-  prose: Type21.Optional(Type21.Unknown({
+var prepareSchema = Type20.Object({
+  prose: Type20.Optional(Type20.Unknown({
     description: "\u6E38\u5955\u4F7F\u6563\u6587\u5EFA\u8BAE\uFF0C\u539F\u6837\u5448\u73B0\u3002\u4E0D\u8981\u6C42 candidates/next \u7ED3\u6784\u3002"
   }))
 }, { additionalProperties: true });
@@ -21743,7 +21357,7 @@ function navigatorSubjectKey(subjectRoot, subject, provenance = "role_input") {
 }
 function navigatorSubjectKeyForInput(subjectRoot, reference, cwd = process.cwd()) {
   if (issueRoot(subjectRoot) !== void 0 || !subjectRoot.includes("/.ak/work/")) return subjectRoot;
-  const resolvedReference = resolve18(cwd, reference);
+  const resolvedReference = resolve17(cwd, reference);
   const marker = "/runs/";
   if (resolvedReference.includes(marker)) {
     return subjectRoot;
@@ -22175,7 +21789,6 @@ init_worker_output();
 init_fixer_output();
 init_filed_submission();
 init_role_submission_declarations();
-init_fixer_packet();
 
 // src/worker-submission-gates.ts
 init_archivist_record_entry();
@@ -22188,7 +21801,7 @@ init_submission_errors();
 init_worker_submission_contracts();
 import { execFileSync as execFileSync3 } from "node:child_process";
 import { existsSync as existsSync13, lstatSync as lstatSync3, readdirSync as readdirSync4, readFileSync as readFileSync5, rmdirSync, rmSync as rmSync3 } from "node:fs";
-import { resolve as resolve19 } from "node:path";
+import { resolve as resolve18 } from "node:path";
 var WORKER_SUBMISSION_GATE_RECORD_KIND = WORKER_SUBMISSION_GATE_KIND;
 var WORKER_COMMIT_BASELINE_ENTRY_TYPE = "commit-baseline";
 var WORKER_COMMIT_REMINDER_BOUNCE_ENTRY_TYPE = "commit-reminder-bounce";
@@ -22236,7 +21849,7 @@ function escapeGitConfigValueRegex(value) {
 function unsetOwnedHooksPath(file) {
   const owned = [];
   for (const value of tryGetAll(file, "core.hooksPath")) {
-    if (!ownedHook(resolve19(value, HOOK_FILE))) continue;
+    if (!ownedHook(resolve18(value, HOOK_FILE))) continue;
     try {
       gitFile(file, [
         "--unset-all",
@@ -22251,15 +21864,15 @@ function unsetOwnedHooksPath(file) {
   return owned;
 }
 function rmOwnedDir(dir) {
-  const hookPath = resolve19(dir, HOOK_FILE);
+  const hookPath = resolve18(dir, HOOK_FILE);
   if (!ownedHook(hookPath)) return;
   rmSync3(hookPath, { force: true });
   if (existsSync13(dir) && readdirSync4(dir).length === 0) rmdirSync(dir);
 }
 function linkedGitDirs(commonDir) {
-  const root = resolve19(commonDir, "worktrees");
+  const root = resolve18(commonDir, "worktrees");
   if (!existsSync13(root)) return [];
-  return readdirSync4(root).map((name) => resolve19(root, name)).filter((dir) => lstatSync3(dir).isDirectory());
+  return readdirSync4(root).map((name) => resolve18(root, name)).filter((dir) => lstatSync3(dir).isDirectory());
 }
 function uninstallPackageWorkerHooks(cwd) {
   let inside;
@@ -22273,14 +21886,14 @@ function uninstallPackageWorkerHooks(cwd) {
   const clear = (configFile) => {
     for (const hooks of unsetOwnedHooksPath(configFile)) rmOwnedDir(hooks);
   };
-  clear(resolve19(commonDir, "config"));
-  clear(resolve19(commonDir, "config.worktree"));
-  rmOwnedDir(resolve19(commonDir, HOOKS_DIR));
-  const legacy = resolve19(commonDir, "hooks", HOOK_FILE);
+  clear(resolve18(commonDir, "config"));
+  clear(resolve18(commonDir, "config.worktree"));
+  rmOwnedDir(resolve18(commonDir, HOOKS_DIR));
+  const legacy = resolve18(commonDir, "hooks", HOOK_FILE);
   if (ownedHook(legacy)) rmSync3(legacy, { force: true });
   for (const gitDir of linkedGitDirs(commonDir)) {
-    clear(resolve19(gitDir, "config.worktree"));
-    rmOwnedDir(resolve19(gitDir, HOOKS_DIR));
+    clear(resolve18(gitDir, "config.worktree"));
+    rmOwnedDir(resolve18(gitDir, HOOKS_DIR));
   }
 }
 function containsWrittenReason(value) {
@@ -22465,20 +22078,6 @@ function fixerBashSeatbeltDenyReason(matched) {
 init_unknown_value();
 init_worker_output();
 var FIXER_FLAG_DEFINITIONS = {
-  packet: {
-    name: "ak-fix-packet",
-    definition: {
-      description: "Path to opaque prose instructions for the Fixer",
-      type: "string"
-    }
-  },
-  prerequisites: {
-    name: "ak-fixer-prerequisites",
-    definition: {
-      description: "Optional path to a JSON array of typed Fixer prerequisites",
-      type: "string"
-    }
-  },
   phase: {
     name: "ak-fixer-phase",
     definition: {
@@ -22537,22 +22136,11 @@ function assertAcceptableThroughHost(submissionGate, status, details, hostAction
 }
 function createFixerRoleRuntime(pi, dependencies, hostActions, options) {
   let soul;
-  let packet;
-  let packetPath;
-  let prerequisitesPath;
   let phase;
   let lifecycleRegistered = false;
   const submissionGate = createWorkerSubmissionGate({
     unfinishedReasonBounceLimit: options?.unfinishedReasonBounceLimit ?? deliveryLimitFromEnv(process.env)
   });
-  pi.registerFlag(
-    FIXER_FLAG_DEFINITIONS.packet.name,
-    FIXER_FLAG_DEFINITIONS.packet.definition
-  );
-  pi.registerFlag(
-    FIXER_FLAG_DEFINITIONS.prerequisites.name,
-    FIXER_FLAG_DEFINITIONS.prerequisites.definition
-  );
   pi.registerFlag(
     FIXER_FLAG_DEFINITIONS.phase.name,
     FIXER_FLAG_DEFINITIONS.phase.definition
@@ -22568,29 +22156,11 @@ function createFixerRoleRuntime(pi, dependencies, hostActions, options) {
         );
       }
       phase = selectedPhase;
-      const resolvedPacketPath = pi.getFlag(FIXER_FLAG_DEFINITIONS.packet.name);
-      if (typeof resolvedPacketPath !== "string" || resolvedPacketPath.trim().length === 0) {
-        throw new Error("Fixer role requires --ak-fix-packet");
-      }
-      packetPath = resolvedPacketPath;
-      const instructions = await dependencies.loadPacket(packetPath);
-      if (instructions.trim().length === 0) {
-        throw new FixerPacketValidationError(
-          new Error("Fixer instructions must be nonblank")
-        );
-      }
-      const resolvedPrerequisitesPath = pi.getFlag(FIXER_FLAG_DEFINITIONS.prerequisites.name);
-      if (resolvedPrerequisitesPath !== void 0 && (typeof resolvedPrerequisitesPath !== "string" || resolvedPrerequisitesPath.trim().length === 0)) {
-        throw new Error("Fixer --ak-fixer-prerequisites path must be nonblank when supplied");
-      }
-      prerequisitesPath = typeof resolvedPrerequisitesPath === "string" ? resolvedPrerequisitesPath : void 0;
-      const prerequisites = prerequisitesPath !== void 0 ? parseFixerPrerequisites(await dependencies.loadPacket(prerequisitesPath)) : Object.freeze([]);
-      packet = Object.freeze({ instructions, prerequisites });
       if (!lifecycleRegistered) {
         lifecycleRegistered = true;
         registerWorkerSubmission(pi, "fixer", {
-          notReady: "\u4FEE\u5185\u53F8\u4FEE\u7406\u5305\u4E0E\u9636\u6BB5\u672A\u88C5\u8F7D",
-          ready: () => packet !== void 0 && phase !== void 0,
+          notReady: "\u4FEE\u5185\u53F8\u9636\u6BB5\u672A\u88C5\u8F7D",
+          ready: () => phase !== void 0,
           phase: () => phase,
           project: (parameters, current) => deepFreeze2(validateFixerOutput(parameters, current)),
           submissionGate,
@@ -22609,12 +22179,6 @@ function createFixerRoleRuntime(pi, dependencies, hostActions, options) {
         });
         pi.on("before_agent_start", (event) => {
           if (soul === void 0) throw new Error("\u4FEE\u5185\u53F8\u804C\u5206\u672A\u88C5\u8F7D");
-          if (packetPath === void 0) throw new Error("\u4FEE\u5185\u53F8\u4FEE\u7406\u5305\u8DEF\u5F84\u672A\u88C5\u8F7D");
-          const prerequisitesBlock = prerequisitesPath === void 0 ? "" : `
-
-<fixer_prerequisites_path>
-${prerequisitesPath}
-</fixer_prerequisites_path>`;
           return {
             systemPrompt: `${event.systemPrompt}
 
@@ -22624,11 +22188,7 @@ ${soul}
 
 <fixer_phase>
 ${phase ?? ""}
-</fixer_phase>
-
-<fix_packet_path>
-${packetPath}
-</fix_packet_path>${prerequisitesBlock}`
+</fixer_phase>`
           };
         });
       }
@@ -22640,22 +22200,17 @@ ${packetPath}
 }
 function createCoderRoleRuntime(pi, dependencies, hostActions, options) {
   let soul;
-  let task;
   let phase;
   let lifecycleRegistered = false;
   const submissionGate = createWorkerSubmissionGate({
     unfinishedReasonBounceLimit: options?.unfinishedReasonBounceLimit ?? deliveryLimitFromEnv(process.env)
   });
-  pi.registerFlag("ak-coder-task", {
-    description: "Markdown task assigned to the coder role",
-    type: "string"
-  });
   pi.registerFlag("ak-coder-phase", {
     description: "Coder phase: plan (inspect and propose an implementation plan; no edits or commits) or apply (execute the approved plan and verify the first implementation)",
     type: "string"
   });
   return {
-    async activate(ctx) {
+    async activate() {
       soul = (await dependencies.loadSoul()).trim();
       if (soul.length === 0) throw new Error("Coder soul is empty");
       const selectedPhase = pi.getFlag("ak-coder-phase");
@@ -22665,23 +22220,17 @@ function createCoderRoleRuntime(pi, dependencies, hostActions, options) {
         );
       }
       phase = selectedPhase;
-      const taskPath = pi.getFlag("ak-coder-task");
-      if (typeof taskPath !== "string" || taskPath.trim().length === 0) {
-        throw new Error("Coder role requires --ak-coder-task");
-      }
-      task = (await dependencies.loadTask(taskPath)).trim();
-      if (task.length === 0) throw new Error("Coder task is empty");
       if (!lifecycleRegistered) {
         lifecycleRegistered = true;
         registerWorkerSubmission(pi, "coder", {
-          notReady: "\u5C06\u4F5C\u76D1\u4EFB\u52A1\u4E0E\u9636\u6BB5\u672A\u88C5\u8F7D",
-          ready: () => task !== void 0 && phase !== void 0,
+          notReady: "\u5C06\u4F5C\u76D1\u9636\u6BB5\u672A\u88C5\u8F7D",
+          ready: () => phase !== void 0,
           phase: () => phase,
           project: (parameters, current) => validateWorkerOutput(parameters, current, "Coder"),
           submissionGate,
           hostActions
         });
-        pi.on("before_agent_start", (event, ctx2) => {
+        pi.on("before_agent_start", (event) => {
           if (soul === void 0) throw new Error("\u5C06\u4F5C\u76D1\u804C\u5206\u672A\u88C5\u8F7D");
           return {
             systemPrompt: `${event.systemPrompt}
@@ -22692,11 +22241,7 @@ ${soul}
 
 <coder_phase>
 ${phase ?? ""}
-</coder_phase>
-
-<coder_task>
-${task ?? ""}
-</coder_task>`
+</coder_phase>`
           };
         });
       }
@@ -22741,7 +22286,16 @@ function createMergerRoleRuntime(pi, dependencies) {
         });
         pi.on("before_agent_start", (event) => {
           if (!activation) throw new Error("\u6821\u4E66\u90CE\u672A\u6FC0\u6D3B");
-          const admitted = { attemptId: activation.input.attemptId, targetObjectId: activation.input.targetObjectId, sourceObjectId: activation.input.sourceObjectId, task: materialText(activation.input, "task"), authority: materialText(activation.input, "authority"), targetIntent: materialText(activation.input, "targetIntent"), sourceIntent: materialText(activation.input, "sourceIntent"), expectedConflictPaths: activation.input.expectedConflictPaths, resolutionScope: activation.input.resolutionScope, authorizedChecks: activation.input.authorizedChecks };
+          const admitted = {
+            attemptId: activation.input.attemptId,
+            targetObjectId: activation.input.targetObjectId,
+            sourceObjectId: activation.input.sourceObjectId,
+            targetIntent: materialText(activation.input, "targetIntent"),
+            sourceIntent: materialText(activation.input, "sourceIntent"),
+            expectedConflictPaths: activation.input.expectedConflictPaths,
+            resolutionScope: activation.input.resolutionScope,
+            authorizedChecks: activation.input.authorizedChecks
+          };
           return { systemPrompt: `${event.systemPrompt}
 
 <merger_soul>
@@ -22772,7 +22326,6 @@ init_doctor_evidence();
 init_judge_role();
 init_engine_detour();
 init_fixer_output();
-init_fixer_packet();
 init_auditor_soul();
 init_judge_auditor();
 init_doctor_auditor();
@@ -22884,7 +22437,7 @@ function activationStage(role, activate) {
   };
 }
 function validateActivationTraceRecord(record) {
-  if (!Value4.Check(activationTraceRecordSchema, record)) {
+  if (!Value3.Check(activationTraceRecordSchema, record)) {
     throw new TypeError("Activation trace record does not match its closed contract");
   }
   return record;
@@ -23152,7 +22705,7 @@ function readRoleRunCoordinates(ctx, label) {
   if (runDirectory === void 0) throw new Error(`${label} requires AK_ROLE_RUN_DIR`);
   const admitted = readPageSync(runDirectory, "admitted");
   if (typeof admitted?.projectRoot !== "string" || admitted.projectRoot.trim() === "") {
-    throw new Error(`${label} state.jsonl admitted-request row missing projectRoot (${join35(runDirectory, RUN_STATE_FILE)})`);
+    throw new Error(`${label} state.jsonl admitted-request row missing projectRoot (${join34(runDirectory, RUN_STATE_FILE)})`);
   }
   return {
     runDirectory,
@@ -23667,13 +23220,7 @@ function createRoleRuntimeExtension(dependencies, deliveryRequestLimit) {
     const fixer = createFixerRoleRuntime(
       roleHost,
       {
-        loadSoul: () => requireRoleSoul("fixer"),
-        async loadPacket(path) {
-          if (dependencies.loadFixPacket === void 0) {
-            throw new Error("Fixer packet loader is not configured");
-          }
-          return dependencies.loadFixPacket(path);
-        }
+        loadSoul: () => requireRoleSoul("fixer")
       },
       hostActions,
       { unfinishedReasonBounceLimit: deliveryLimit }
@@ -23681,13 +23228,7 @@ function createRoleRuntimeExtension(dependencies, deliveryRequestLimit) {
     const coder = createCoderRoleRuntime(
       roleHost,
       {
-        loadSoul: () => requireRoleSoul("coder"),
-        async loadTask(path) {
-          if (dependencies.loadCoderTask === void 0) {
-            throw new Error("Coder task loader is not configured");
-          }
-          return dependencies.loadCoderTask(path);
-        }
+        loadSoul: () => requireRoleSoul("coder")
       },
       hostActions,
       { unfinishedReasonBounceLimit: deliveryLimit }
@@ -23991,11 +23532,11 @@ init_settlement();
 init_run_lifecycle();
 init_unknown_value();
 async function listen(server, path) {
-  await new Promise((resolve22, reject) => {
+  await new Promise((resolve21, reject) => {
     server.once("error", reject);
     server.listen(path, () => {
       server.off("error", reject);
-      resolve22();
+      resolve21();
     });
   });
 }
@@ -24420,8 +23961,8 @@ async function prepareRoleEnvelope(options) {
     try {
       const closeAll = server.closeAllConnections;
       if (typeof closeAll === "function") closeAll.call(server);
-      await new Promise((resolve22, reject) => {
-        server.close((error) => error ? reject(error) : resolve22());
+      await new Promise((resolve21, reject) => {
+        server.close((error) => error ? reject(error) : resolve21());
       });
     } catch (error) {
       await retainPackageFault({
@@ -24554,7 +24095,7 @@ async function prepareRoleEnvelope(options) {
 }
 
 // src/role-runtime-dependencies.ts
-import { readFile as readFile18 } from "node:fs/promises";
+import { readFile as readFile17 } from "node:fs/promises";
 init_doctor_evidence();
 
 // src/navigator-work-context.ts
@@ -24562,8 +24103,8 @@ init_role_run_placement();
 init_doctor_evidence();
 init_unknown_value();
 init_host_contracts();
-import { readFile as readFile17 } from "node:fs/promises";
-import { resolve as resolve20 } from "node:path";
+import { readFile as readFile16 } from "node:fs/promises";
+import { resolve as resolve19 } from "node:path";
 init_notary_source_run();
 init_packaged_role_registry();
 init_invocation();
@@ -24571,12 +24112,12 @@ function navigatorInputReference(getFlag, role) {
   if (getFlag === void 0) return void 0;
   const name = packagedRoleInputFlag(role);
   const value = name === void 0 ? void 0 : getFlag(name);
-  return typeof value === "string" && value !== "" ? resolve20(value) : void 0;
+  return typeof value === "string" && value !== "" ? resolve19(value) : void 0;
 }
 async function loadNavigatorWorkContext(options) {
   const reference = navigatorInputReference(options.getFlag, options.role);
   const subjectMode = packagedNavigatorSubject(options.role);
-  const input = reference === void 0 || subjectMode === "case" || subjectMode === "source-run" ? void 0 : await readFile17(reference, "utf8");
+  const input = reference === void 0 || subjectMode === "case" || subjectMode === "source-run" ? void 0 : await readFile16(reference, "utf8");
   const subjectRoot = subjectPath(reference ?? options.context.sessionManager.getSessionDir(), options.context.cwd);
   let subjectKey = reference === void 0 ? subjectRoot : navigatorSubjectKeyForInput(subjectRoot, reference, options.context.cwd);
   let subject = input ?? `work subject: ${subjectKey}`;
@@ -24593,7 +24134,7 @@ async function loadNavigatorWorkContext(options) {
   }
   const publicRunDir = runDirectoryFromHostContext(options.context);
   const currentSessionDir = options.context.sessionManager.getSessionDir();
-  const isBoundPublicRun = publicRunDir !== void 0 && resolve20(currentSessionDir) === resolve20(sessionDirectoryOf(publicRunDir));
+  const isBoundPublicRun = publicRunDir !== void 0 && resolve19(currentSessionDir) === resolve19(sessionDirectoryOf(publicRunDir));
   if (subjectMode === "public-instruction" && isBoundPublicRun) {
     let admitted;
     try {
@@ -24626,14 +24167,14 @@ async function loadNavigatorWorkContext(options) {
   }
   const workRoot = subjectRoot.includes("/.ak/work/") ? subjectRoot : void 0;
   const authorityFiles = workRoot === void 0 ? [] : [
-    resolve20(workRoot, "authority.md"),
-    resolve20(workRoot, "authority.txt"),
-    resolve20(workRoot, "design-v2/owner-direction.md")
+    resolve19(workRoot, "authority.md"),
+    resolve19(workRoot, "authority.txt"),
+    resolve19(workRoot, "design-v2/owner-direction.md")
   ];
   let authorityMaterial;
   for (const path of authorityFiles) {
     try {
-      const content = await readFile17(path, "utf8");
+      const content = await readFile16(path, "utf8");
       if (content.trim() !== "") {
         authorityMaterial = content;
         break;
@@ -24675,11 +24216,9 @@ function createRoleRuntimeDependencies(packageRoot) {
     packageRoot,
     loadRoleReferenceMaterials: loadPackagedRoleReferenceMaterials,
     loadRoleSoul: loadRegisteredRoleSoul,
-    loadFixPacket: (path) => readFile18(path, "utf8"),
-    loadCoderTask: (path) => readFile18(path, "utf8"),
     loadDoctorCase,
     loadNotarySourceRun: loadNotarySourceRunLocator,
-    loadMergerInput: async (path) => JSON.parse(await readFile18(path, "utf8")),
+    loadMergerInput: async (path) => JSON.parse(await readFile17(path, "utf8")),
     loadNavigatorWorkContext: (options) => loadNavigatorWorkContext({
       context: options.context,
       role: options.role,
@@ -24762,7 +24301,7 @@ function hostAbortedError(message = "host aborted") {
 function raceAgainstHostAbort(work, abortSignal, message = "host aborted") {
   if (abortSignal?.aborted) return Promise.reject(hostAbortedError(message));
   if (abortSignal === void 0) return work;
-  return new Promise((resolve22, reject) => {
+  return new Promise((resolve21, reject) => {
     let settled = false;
     const onAbort = () => {
       if (settled) return;
@@ -24777,7 +24316,7 @@ function raceAgainstHostAbort(work, abortSignal, message = "host aborted") {
         if (settled) return;
         settled = true;
         abortSignal.removeEventListener("abort", onAbort);
-        resolve22(value);
+        resolve21(value);
       },
       (error) => {
         if (settled) return;
@@ -25039,19 +24578,19 @@ function connectAcpStdio(options) {
       terminate(error);
     }
   });
-  const processClosed = new Promise((resolve22) => {
+  const processClosed = new Promise((resolve21) => {
     child.once("close", (code, signal) => {
       if (spawned) nativeExit = { code, timedOut: false, ...signal === null ? {} : { signal } };
       settleClosed(acpError("acp-closed", "ACP process closed"));
-      resolve22();
+      resolve21();
     });
   });
   return Promise.resolve({
     request(method, params) {
       if (closed) return Promise.reject(terminalError);
       const id = ++nextId;
-      return new Promise((resolve22, reject) => {
-        pending.set(id, { resolve: resolve22, reject });
+      return new Promise((resolve21, reject) => {
+        pending.set(id, { resolve: resolve21, reject });
         child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}
 `, (error) => {
           if (error === null || error === void 0) return;
@@ -25332,13 +24871,13 @@ function createAcpRoleTurnHost(config) {
 
 // src/acp-host/seat-profile-soul.ts
 import { constants as constants3 } from "node:fs";
-import { access as access3, copyFile, lstat as lstat5, mkdir as mkdir4, readlink, symlink as symlink2, unlink as unlink3 } from "node:fs/promises";
-import { dirname as dirname22, join as join36, relative as relative3, resolve as resolve21 } from "node:path";
+import { access as access3, copyFile, lstat as lstat4, mkdir as mkdir4, readlink, symlink as symlink2, unlink as unlink3 } from "node:fs/promises";
+import { dirname as dirname22, join as join35, relative as relative3, resolve as resolve20 } from "node:path";
 function seatProfileName(spec, role) {
   return `${spec.namePrefix}${role}`;
 }
 function packageRoleSoulPath(packageRoot, role) {
-  return join36(packageRoot, "souls", `${role}.md`);
+  return join35(packageRoot, "souls", `${role}.md`);
 }
 async function pathExists2(path) {
   try {
@@ -25351,20 +24890,20 @@ async function pathExists2(path) {
 async function ensureSeatProfileSoul(options) {
   const { spec, operatorHome, packageRoot, role } = options;
   const profileName = seatProfileName(spec, role);
-  const soulTarget = resolve21(packageRoleSoulPath(packageRoot, role));
+  const soulTarget = resolve20(packageRoleSoulPath(packageRoot, role));
   if (!await pathExists2(soulTarget)) {
     throw new Error(`packaged role soul missing: ${soulTarget}`);
   }
-  const profilesRoot = join36(operatorHome, ...spec.profilesRootFromHome);
-  const profileDir = join36(profilesRoot, profileName);
+  const profilesRoot = join35(operatorHome, ...spec.profilesRootFromHome);
+  const profileDir = join35(profilesRoot, profileName);
   const hostRoot = dirname22(profilesRoot);
-  const soulPath = join36(profileDir, spec.soulFileName);
+  const soulPath = join35(profileDir, spec.soulFileName);
   if (!await pathExists2(profileDir)) {
     await mkdir4(profileDir, { recursive: true });
     for (const name of ["auth.json", ".env", "config.yaml"]) {
-      const source = join36(hostRoot, name);
+      const source = join35(hostRoot, name);
       if (!await pathExists2(source)) continue;
-      await copyFile(source, join36(profileDir, name));
+      await copyFile(source, join35(profileDir, name));
     }
   } else {
     await mkdir4(profileDir, { recursive: true });
@@ -25372,7 +24911,7 @@ async function ensureSeatProfileSoul(options) {
   const desiredLink = relative3(profileDir, soulTarget);
   let current;
   try {
-    const st = await lstat5(soulPath);
+    const st = await lstat4(soulPath);
     if (st.isSymbolicLink()) {
       current = await readlink(soulPath);
     }