@akagilnc/pi-workflow-roles 0.1.5593 → 0.1.5614

package/dist/public-cli/invocation.js

@@ -16,7 +16,6 @@ import { readPageSync, renderCurrentSync, updateSectionSync, writeSectionSync }
 import { loadDoctorCase, } from "../doctor-evidence.js";
 import { parseCollectorPrNumber, parseCollectorRepository, } from "../collector-config.js";
 import { ownerRepoFromGitHubRemoteUrl } from "./github-remote.js";
-import { FixerPacketValidationError, parseFixerPrerequisites, } from "../package-contracts/fixer-packet.js";
 import { createProductionMergerGitState } from "../merger-git-state.js";
 import { validateMergerInput, } from "../merger-contracts.js";
 import { sha256Hex } from "../sha256.js";
@@ -271,12 +270,10 @@ export async function relocateAdmittedRunToTicket(admitted, authority, heldLease
     const admittedRecord = admitted;
     rewriteRunDirectoryPathFields(admittedRecord, [
         "runDirectory",
-        "taskPath",
-        "packetPath",
-        "prerequisitesPath",
         "mergerInputPath",
     ], oldRunDirectory, target.runDirectory);
-    // #1165: caller --attach / --request-manifest paths stay as given; do not rewrite.
+    // #1165/#1168: caller file-flag paths stay as given. Obsolete copy fields
+    // (taskPath/packetPath) are not rewritten — stock volumes keep their bytes.
     admitted.principal = principal;
     // current.json projects host.original from this run directory. Ownership is
     // already transferred; a refuse still carries the true cause to the caller
@@ -428,7 +425,8 @@ function assignPublicSeatOption(owner, taken, fields) {
             fields.authorityRefs.push(requireAuthorityRef(value));
             return;
         case "prerequisites":
-            fields.prerequisitesPath = requireOptionPath(taken.def.canonical, value);
+            // #1168: same opaque file-flag rule as --attach.
+            fields.prerequisitesPath = requireProvidedOptionValue(taken.def.canonical, value);
             return;
         case "pr":
             fields.prNumber = parsePositivePrOption(value);
@@ -716,16 +714,13 @@ export async function admitPublicRole(role, parsed, env, override) {
             if (!record.phases.some((item) => item === phase)) {
                 throw new CliUsageError("coder phase must be plan or apply");
             }
+            // #1168: dispatch text is the first message only — no task.md copy.
             return admitStandardMaterialInvocation("coder", {
                 ...shared,
                 instruction,
                 attachmentPaths,
                 ...project,
-                placedFields: async (placed) => {
-                    const taskPath = join(placed.runDirectory, "task.md");
-                    await writeFile(taskPath, instruction, "utf8");
-                    return { phase, taskPath };
-                },
+                placedFields: async () => ({ phase }),
             });
         }
         case "worker-packet": {
@@ -736,48 +731,18 @@ export 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 !== undefined) {
-                const absolutePrereq = isAbsolute(parsed.prerequisitesPath)
-                    ? parsed.prerequisitesPath
-                    : resolve(parsed.prerequisitesPath);
-                try {
-                    prerequisitesSource = await readFile(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;
-                }
-            }
+            // #1168: dispatch once as first message; --prerequisites path as-is.
             return admitStandardMaterialInvocation("fixer", {
                 ...shared,
                 instruction,
                 attachmentPaths,
                 ...project,
-                placedFields: async (placed) => {
-                    let prerequisitesPath;
-                    if (prerequisitesSource !== undefined) {
-                        prerequisitesPath = join(placed.runDirectory, "prerequisites.json");
-                        await writeFile(prerequisitesPath, `${JSON.stringify(prerequisites, null, 2)}\n`, "utf8");
-                    }
-                    const packetPath = join(placed.runDirectory, "fix-packet.md");
-                    await writeFile(packetPath, instruction, "utf8");
-                    return {
-                        phase,
-                        packetPath,
-                        prerequisites,
-                        ...(prerequisitesPath === undefined ? {} : { prerequisitesPath }),
-                    };
-                },
+                placedFields: async () => ({
+                    phase,
+                    ...(parsed.prerequisitesPath === undefined
+                        ? {}
+                        : { prerequisitesPath: parsed.prerequisitesPath }),
+                }),
             });
         }
         case "collect-target": {
@@ -960,13 +925,12 @@ export async function admitPublicRole(role, parsed, env, override) {
                 placedFields: async (placed) => {
                     const targetLabel = derived.targetObjectId === "" ? "(none observed)" : derived.targetObjectId;
                     const sourceLabel = derived.sourceObjectId === "" ? "(none observed)" : derived.sourceObjectId;
+                    // #1168: git facts stay; do not encode dispatch text as task/authority copies.
                     const mergerInput = validateMergerInput({
                         attemptId: placed.runId,
                         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.`),
                             sourceIntent: mergerMaterialFromUtf8(`Investigate primary sources for source parent ${sourceLabel}. Do not invent intent.`),
                         },
@@ -1051,7 +1015,7 @@ async function persistPlacedAdmission(admitted, placed, model) {
  * before materializeCountersignInvocation writes the page.
  * Seats whose extra facts are known before placement pass them as admittedFields.
  * Seats whose extra facts depend on the placed run pass placedFields
- * (coder writes task.md; fixer writes fix-packet.md; merger writes merger-input.json).
+ * (merger writes merger-input.json with git facts; coder/fixer dispatch is first-message only, #1168).
  */
 async function admitStandardMaterialInvocation(role, options) {
     const defer = options.deferPersistence === true;
@@ -1120,19 +1084,35 @@ function admittedTransportPromptKind(admitted) {
         return record.transportPrompt;
     return "instruction";
 }
+/** Append opaque caller file-flag paths after dialogue (#1165 / #1166 J11 / #1168). */
+export function appendCallerFileFlagPaths(body, attachments, requestManifestPath, prerequisitesPath) {
+    const flaggedPaths = [
+        ...attachments.map((attachment) => `--attach ${attachment.path}`),
+        ...(requestManifestPath === undefined
+            ? []
+            : [`--request-manifest ${requestManifestPath}`]),
+        ...(prerequisitesPath === undefined
+            ? []
+            : [`--prerequisites ${prerequisitesPath}`]),
+    ];
+    if (flaggedPaths.length === 0)
+        return body;
+    // ADR 0087 / #1165 / #1166 J13: after caller words, only necessary file flags
+    // and original paths — no package-authored title or list wrapper.
+    return [body, "", ...flaggedPaths].join("\n");
+}
 /**
  * One initial prompt transport. The registry `transportPrompt` leaf selects
- * a fixed kickoff, a bound baseline, or frozen skill args. Absent means the
- * caller instruction plus caller attachment paths as-is (#1165).
+ * a fixed kickoff, a bound baseline, or skill args. Absent means the caller
+ * instruction plus caller file-flag paths (ADR 0087).
  * Engine / outsourcing material rides startup readingMaterial (#1167), not here.
  */
 export function buildInstructionTransportPrompt(admitted) {
     const kind = admittedTransportPromptKind(admitted);
     if (kind === "fixed-kickoff") {
-        if (admitted.sourceRunPath === undefined || admitted.sourceRunPath.trim() === "") {
-            throw new Error("fixed-kickoff transport prompt is missing the source run pointer");
-        }
-        return admitted.sourceRunPath;
+        // #1166 / ADR 0087: audited-run identity rides startup materials; dialogue
+        // prompt is peer body / reask only — never a package-computed directory path.
+        return "";
     }
     if (kind === "baseline") {
         if (admitted.baseRevision === undefined) {
@@ -1162,23 +1142,7 @@ export function buildInstructionTransportPrompt(admitted) {
         }
         return lines.join("\n");
     }
-    // #1165 J3: assemble from the admitted instruction bytes themselves.
-    const lines = [admitted.instruction];
-    // #1164/#1165: each caller path keeps its file-flag provenance.
-    const flaggedPaths = [
-        ...admitted.attachments.map((attachment) => `--attach ${attachment.path}`),
-        ...(admitted.requestManifestPath === undefined
-            ? []
-            : [`--request-manifest ${admitted.requestManifestPath}`]),
-    ];
-    if (flaggedPaths.length > 0) {
-        lines.push("");
-        lines.push("已受理附件：");
-        for (const entry of flaggedPaths) {
-            lines.push(`- ${entry}`);
-        }
-    }
-    return lines.join("\n");
+    return appendCallerFileFlagPaths(admitted.instruction, admitted.attachments, admitted.requestManifestPath, admitted.prerequisitesPath);
 }
 /** Persist a deferred Countersign admission after same-ticket lookup found no retained run. */
 export async function materializeCountersignInvocation(admitted, options) {