@akagilnc/pi-workflow-roles 0.1.5756 → 0.1.5775

package/dist/public-cli/instruction-seat-run.js

@@ -29,7 +29,7 @@ import { CliUsageError } from "./cli-errors.js";
 import { admitPublicRole, admittedSourceRunPath, bindAdmittedTicketNumber, appendCallerFileFlagPaths, buildInstructionTransportPrompt, materializeCountersignInvocation, persistAdmittedAuditedSubmissionToolCallId, persistAdmittedSourceRunPath, readAdmittedAuditedSubmissionToolCallId, recordAdmittedCorrelation, recordChildDiaristRun, relocateAdmittedRunToTicket, } from "./invocation.js";
 import { bindDiaristAssertedTicketNumber, presentControlledFailure, packageFaultNoteFor, prepareSummonsResumeMaterials, roleTurnOptions, runPostAdmissionOneShot, runPostAdmissionResumable, runPostAdmissionSeatResume, showResumeErrorPointer, resumeTurnRequestProjectionOptions, } from "./post-admission.js";
 import { presentTerminal } from "./auto-resume.js";
-import { buildAutoResumeContinuationPrompt, loadResumablePublicRole, markRunAdmitted, readCurrentCourt, } from "./run-lifecycle.js";
+import { loadResumablePublicRole, markRunAdmitted, readCurrentCourt, } from "./run-lifecycle.js";
 import { tryResumeSameTicketSeatRun } from "./seat-ticket-binding.js";
 import { presentStructuralRejection, readBoundSessionEntries, trySettlePublicSeat, } from "./settlement.js";
 import { warnMissingMethodSkills } from "./machine-method-skills.js";
@@ -49,6 +49,20 @@ const POST_SUBMISSION_ROUTING = {
     judge: {
         statuses: REVIEW_QUEUE_STATUSES,
     },
+    // #1208 C1 / ADR 0055: every review-queue seat uses the shared
+    // unreadable-status seam (officerConclusionReask). Independent public
+    // entry for notary/auditor/inspector was the same miss — route here, do
+    // not invent a parallel loop. Gate summons still own the outer budget
+    // via nestedIncomplete when this seat exhausts unsettled.
+    notary: {
+        statuses: REVIEW_QUEUE_STATUSES,
+    },
+    auditor: {
+        statuses: REVIEW_QUEUE_STATUSES,
+    },
+    inspector: {
+        statuses: REVIEW_QUEUE_STATUSES,
+    },
     coder: {
         statuses: WORKER_ROUTING_STATUSES,
         reask: WORKER_STATUS_REASK,
@@ -160,10 +174,13 @@ async function reaskUnreadablePostSubmissionStatus(admitted, terminal, env, io,
     const next = withUnreadableReask(env);
     if (next === undefined)
         return UNREADABLE_REASK_EXHAUSTED;
+    // Named status-reask: summons opens a new court; message carries the diagnostic
+    // (not arbitrary summons.instruction passthrough through the review resolver).
     return runPublicInstructionSeatResume({
         runId: admitted.runId,
         runDirectory: admitted.runDirectory,
-        summons: { instruction: message },
+        message,
+        summons: { instructionEmpty: true },
     }, next, io);
 }
 /**
@@ -201,10 +218,13 @@ async function reaskMissingTicketOnce(admitted, terminal, env, io) {
         softTicketReaskTurn: true,
         softTicketReaskOwnership,
     };
+    // Named #1171 missing-ticket: summons opens a new court; message carries the
+    // package reask copy (not arbitrary summons.instruction passthrough).
     const result = await runPublicInstructionSeatResume({
         runId: admitted.runId,
         runDirectory: admitted.runDirectory,
-        summons: { instruction },
+        message: instruction,
+        summons: { instructionEmpty: true },
     }, softReaskEnv, io);
     if (softTicketReaskOwnership.sealedSubstitute
         || terminalCarriesSealedSubmission(result.terminal)) {
@@ -323,8 +343,8 @@ export function buildInstructionSeatTurnRequest(admitted, options) {
 }
 /**
  * Direct review-seat call: reconnect ledger peer-body delivery (ADR 0085 / #1166).
- * Gate summons already ride gateReviewInstruction; direct --source-run must not
- * leave a blank fixed-kickoff.
+ * Gate summons already ride gateReviewInstruction; direct --source-run falls
+ * through the shared dialogue resolver (notary: fixed dispatch).
  */
 async function loadLedgerPeerBody(sourceRunDirectory, projectRoot, home) {
     const runId = runIdFromRunDirectory(sourceRunDirectory);
@@ -344,40 +364,47 @@ async function loadLedgerPeerBody(sourceRunDirectory, projectRoot, home) {
         return undefined;
     return readableGateItem(latest.accepted);
 }
-/** Owner-approved fixed Notary dispatch (2026-10-09); never the parent verdict. */
+/** Owner-approved fixed Notary review dispatch (2026-10-09 #1208); never the parent verdict. */
 export const NOTARY_FIXED_DISPATCH = "请审本轮受审对象，按符宝郎职掌交卷。";
 /**
  * One delivery rule for review-seat dialogue on new turns and same-parent resume
- * (#1166 / ADR 0085 / ADR 0087): explicit reask → non-empty caller dispatch →
- * source-only ledger peer body. Identity stays in startup materials.
- * #1195: ticket-court notary skips peer-body preload (countersign source only) and
- * receives the fixed dispatch instead (codex rejects an empty prompt).
+ * (#1166 / ADR 0085 / ADR 0087 / #1208): notary review uses fixed dispatch;
+ * named operational reasks ride reviewReask (first-mint / gate) or the resume
+ * request message seam — never arbitrary non-empty caller/summons passthrough.
+ * Other seats prefer format reask, then gate body, then caller dispatch, then
+ * ledger peer. Identity stays in startup materials. Notary never takes
+ * gate/parent verdict as dialogue (gateReviewInstruction stays unread for notary).
  */
-async function resolveReviewSeatDialogueBody(input) {
-    const reask = input.reask;
-    if (reask !== undefined && reask.length > 0)
-        return reask;
+export async function resolveReviewSeatDialogueBody(input) {
+    // #1208: fixed sentence is the review function only (owner 37bfe80d /
+    // 393daf98). reviewReask is the named operational override; caller/summons
+    // body is not a free passthrough (countersign rejected that prescription).
+    if (input.role === "notary") {
+        if (input.reviewReask !== undefined)
+            return input.reviewReask;
+        return NOTARY_FIXED_DISPATCH;
+    }
+    const preferred = input.reviewReask ?? input.gateReviewInstruction;
+    if (preferred !== undefined && preferred.length > 0)
+        return preferred;
     const caller = input.callerInstruction ?? "";
     if (caller.length > 0)
         return caller;
     const sourceRunPath = admittedSourceRunPath(input)?.trim();
     if (sourceRunPath === undefined)
         return undefined;
-    if (input.role === "notary") {
-        const { isTicketCourtCountersignSource } = await import("../run-terminal-artifacts.js");
-        if (isTicketCourtCountersignSource(sourceRunPath))
-            return NOTARY_FIXED_DISPATCH;
-    }
     return await loadLedgerPeerBody(sourceRunPath, input.projectRoot, input.home);
 }
 async function resolveInitialPrompt(admitted, env) {
     const record = roleRecord(admitted.role);
     if ("reaskPrompt" in record && record.reaskPrompt === true) {
         const sourceRunPath = admittedSourceRunPath(admitted);
-        const reask = env.reviewReask ?? env.gateReviewInstruction;
         const body = await resolveReviewSeatDialogueBody({
             role: admitted.role,
-            ...(reask === undefined ? {} : { reask }),
+            ...(env.reviewReask === undefined ? {} : { reviewReask: env.reviewReask }),
+            ...(env.gateReviewInstruction === undefined
+                ? {}
+                : { gateReviewInstruction: env.gateReviewInstruction }),
             callerInstruction: admitted.instruction,
             ...(sourceRunPath === undefined ? {} : { sourceRunPath }),
             projectRoot: admitted.projectRoot,
@@ -489,6 +516,7 @@ async function dispatchAdmitted(admitted, env, io) {
         const initialPromptText = await resolveInitialPrompt(admitted, activeEnv);
         const auto = "inCallAutoResume" in record && record.inCallAutoResume === true;
         if (auto) {
+            // #1208: auto-resume resends this turn's actual content, never a filler phrase.
             return await runPostAdmissionResumable({
                 admitted,
                 env: activeEnv,
@@ -499,7 +527,7 @@ async function dispatchAdmitted(admitted, env, io) {
                 })),
                 buildResumeRequest: () => buildInstructionSeatTurnRequest(admitted, roleTurnOptions(activeEnv, admitted, {
                     kind: "resume",
-                    prompt: buildAutoResumeContinuationPrompt(),
+                    prompt: initialPromptText,
                 })),
                 adapters,
                 ...(activeEnv.engine === undefined ? {} : { effectiveEngine: activeEnv.engine }),
@@ -607,22 +635,31 @@ function resumeSameParentInstructionSeat(input) {
         ...(input.ticketNumber === undefined ? {} : { ticketNumber: input.ticketNumber }),
         freshSummons: input.env.freshSummons,
         summons: input.summons,
-        resume: (runId, materials, runDirectory) => runPublicInstructionSeatResume({
-            runId,
-            runDirectory,
-            ...(materials === undefined ? {} : { summons: materials }),
-        }, input.env, input.io),
+        resume: (runId, materials, runDirectory) => {
+            // Named operational reask on this summon: explicit message seam.
+            // Review dialogue stays on summons → shared resolver (notary: fixed).
+            // Do not stuff reask into summons.instruction for later passthrough.
+            const reask = input.env.reviewReask;
+            return runPublicInstructionSeatResume({
+                runId,
+                runDirectory,
+                ...(reask === undefined ? {} : { message: reask }),
+                ...(materials === undefined ? {} : { summons: materials }),
+            }, input.env, input.io);
+        },
     });
 }
 /**
  * Same delivery rule as resolveInitialPrompt for same-parent resume summons.
- * Reask / explicit caller text / source-only ledger peer — one authority.
+ * Shared resolver owns the input choice — callers only pass env fields.
  */
 async function sameParentDialogue(env, fallback, sourceRunPath, projectRoot, role) {
-    const reask = env.reviewReask ?? env.gateReviewInstruction;
     const body = await resolveReviewSeatDialogueBody({
         role,
-        ...(reask === undefined ? {} : { reask }),
+        ...(env.reviewReask === undefined ? {} : { reviewReask: env.reviewReask }),
+        ...(env.gateReviewInstruction === undefined
+            ? {}
+            : { gateReviewInstruction: env.gateReviewInstruction }),
         callerInstruction: fallback.instruction,
         sourceRunPath,
         projectRoot,
@@ -638,15 +675,20 @@ async function sameParentDialogue(env, fallback, sourceRunPath, projectRoot, rol
  * then the same one-shot settlement as every other seat.
  */
 async function runCountersignBody(parsed, env, io) {
+    const projectRoot = resolve(parsed.project ?? env.cwd);
     const gateParentRunPath = typeof env.parentRunPath === "string" && env.parentRunPath.trim() !== ""
         ? env.parentRunPath
         : undefined;
     if (gateParentRunPath !== undefined) {
-        const resumeInstruction = env.reviewReask ?? env.gateReviewInstruction ?? parsed.instruction ?? "";
+        // #1208 C1: same shared dialogue resolver as every other same-parent seat.
+        const dialogue = await sameParentDialogue(env, {
+            instruction: parsed.instruction ?? "",
+            instructionEmpty: (parsed.instruction ?? "").length === 0,
+        }, gateParentRunPath, projectRoot, "countersign");
         const resumed = await resumeSameParentInstructionSeat({
             env,
             io,
-            projectRoot: resolve(parsed.project ?? env.cwd),
+            projectRoot,
             role: "countersign",
             parentRunPath: gateParentRunPath,
             ...(isSafePositiveTicketNumber(env.boundTicketNumber)
@@ -654,8 +696,8 @@ async function runCountersignBody(parsed, env, io) {
                 : {}),
             summons: {
                 sourceRunPath: gateParentRunPath,
-                instruction: resumeInstruction,
-                instructionEmpty: resumeInstruction.length === 0,
+                instruction: dialogue.instruction,
+                instructionEmpty: dialogue.instructionEmpty,
                 // #1166 J11: same-parent resume delivers this call's file-flag paths
                 // through the shared summons → appendCallerFileFlagPaths rule.
                 attachmentPaths: parsed.attachmentPaths ?? [],
@@ -691,14 +733,10 @@ async function runCountersignBody(parsed, env, io) {
                 await persistAdmittedSourceRunPath(admitted, gateParentRunPath);
                 admitted = { ...admitted, sourceRunPath: gateParentRunPath };
             }
-            // #1166 J11: review-body branch must merge the same file-flag delivery as
-            // resolveInitialPrompt / resumeTurnRequestProjectionOptions — never body alone.
-            const reviewBody = env.reviewReask ?? env.gateReviewInstruction;
+            // #1208 C1 / #1166 J11: one shared initial-prompt seam (incl. file flags).
             const turnProjection = roleTurnOptions(env, admitted, {
                 kind: "initial",
-                prompt: reviewBody !== undefined
-                    ? appendCallerFileFlagPaths(reviewBody, admitted.attachments)
-                    : buildInstructionTransportPrompt(admitted),
+                prompt: await resolveInitialPrompt(admitted, env),
             });
             const turnRequest = buildInstructionSeatTurnRequest(admitted, turnProjection);
             const result = await runPostAdmissionOneShot({
@@ -902,6 +940,10 @@ export async function runPublicInstructionSeat(argv, env, io, role, parseArgv) {
         await persistAdmittedSourceRunPath(admitted, auditorSource, auditorSubject);
         admitted = { ...admitted, sourceRunPath: auditorSource };
     }
+    // #1208 C2: same helper as resume — known board ticket on the audited
+    // source binds and relocates before the missing-ticket soft reask can
+    // fire. True no-ticket sources stay unbound (#1171 asks once).
+    admitted = await inheritKnownTicketFromSource(admitted, env.principalAuthority);
     const runAdmitted = async () => {
         await markRunAdmitted(admitted, env.principalAuthority);
         if (role === "secretariat") {
@@ -946,6 +988,24 @@ export async function runPublicInstructionSeat(argv, env, io, role, parseArgv) {
     }
     return runAdmitted();
 }
+/**
+ * #1208 C2: same as new source-locator admission — when this leg is still
+ * unbound, inherit the board ticket already on the audited source and relocate.
+ * True no-ticket sources stay unbound so #1171 still asks once.
+ */
+async function inheritKnownTicketFromSource(admitted, authority) {
+    if (admitted.ticketNumber !== undefined)
+        return admitted;
+    const sourcePath = admittedSourceRunPath(admitted);
+    if (sourcePath === undefined)
+        return admitted;
+    const sourceTicket = await readBoardTicketNumber(sourcePath);
+    if (sourceTicket === undefined)
+        return admitted;
+    await bindAdmittedTicketNumber(admitted, sourceTicket);
+    await relocateAdmittedRunToTicket(admitted, authority);
+    return admitted;
+}
 export async function runPublicInstructionSeatResume(request, env, io) {
     let selectedRequest = request;
     const resume = async () => {
@@ -960,24 +1020,48 @@ export async function runPublicInstructionSeatResume(request, env, io) {
             io: turnIo,
             load: async (effective) => {
                 const loaded = await loadResumablePublicRole(env.home, effective.runId, env.principalAuthority, effective.runDirectory === undefined ? undefined : { runDirectory: effective.runDirectory });
-                if (packagedRebindSourceOnResume(loaded.admitted.role)
+                let admitted = loaded.admitted;
+                if (packagedRebindSourceOnResume(admitted.role)
                     && effective.summons?.sourceRunPath !== undefined
                     && effective.summons.sourceRun !== undefined) {
-                    return {
-                        ...loaded,
-                        admitted: {
-                            ...loaded.admitted,
-                            sourceRunPath: effective.summons.sourceRunPath,
-                            sourceRun: effective.summons.sourceRun,
-                        },
+                    // source-locator seats only (notary); sourceRun is on that admission face.
+                    admitted = {
+                        ...admitted,
+                        sourceRunPath: effective.summons.sourceRunPath,
+                        sourceRun: effective.summons.sourceRun,
                     };
                 }
-                return loaded;
+                admitted = await inheritKnownTicketFromSource(admitted, env.principalAuthority);
+                return { ...loaded, admitted };
             },
             buildTurnRequest: async (admitted, effective) => {
                 const summonsPrepared = await prepareSummonsResumeMaterials(admitted.runDirectory, effective.summons);
+                const projection = resumeTurnRequestProjectionOptions(admitted, effective, env, summonsPrepared);
+                // #1208: internal summons only — shared resolver owns review dialogue.
+                // Public bare resume / explicit message keep projection (operational
+                // reasks use the message seam). Do not reselect stale env dialogue over
+                // this-round summons (#1208 R1).
+                if (effective.summons === undefined || effective.message !== undefined) {
+                    return buildInstructionSeatTurnRequest(admitted, { ...projection });
+                }
+                const sourceRunPath = admittedSourceRunPath(admitted);
+                const body = await resolveReviewSeatDialogueBody({
+                    role: admitted.role,
+                    callerInstruction: summonsPrepared?.instruction ?? "",
+                    ...(sourceRunPath === undefined ? {} : { sourceRunPath }),
+                    projectRoot: admitted.projectRoot,
+                    home: env.home,
+                });
+                if (body === undefined) {
+                    return buildInstructionSeatTurnRequest(admitted, { ...projection });
+                }
+                const fileFlags = summonsPrepared?.attachments ?? [];
+                const prompt = fileFlags.length === 0
+                    ? body
+                    : appendCallerFileFlagPaths(body, fileFlags);
                 return buildInstructionSeatTurnRequest(admitted, {
-                    ...resumeTurnRequestProjectionOptions(admitted, effective, env, summonsPrepared),
+                    ...projection,
+                    continuation: { kind: "resume", prompt },
                 });
             },
             adapters: {
@@ -1037,9 +1121,12 @@ async function queueConclusionFromChild(child, env, io) {
         return { stop: { exitCode: 0, ...(terminal === undefined ? {} : { terminal }) } };
     }
     let current = child;
-    // Notary, auditor, and inspector have no seat-local status reask. This loop
-    // is their one budget. The child resume keeps the caller's env so delivery,
-    // failure recovery, and other reask loops stay separate.
+    // #1208: review-queue gate children also have seat-local
+    // POST_SUBMISSION_ROUTING. This parent-side loop remains the
+    // gate/correlation budget; nestedIncomplete from an exhausted seat-local
+    // chain surfaces without a second spend. The child resume keeps the
+    // caller's env so delivery, failure recovery, and other reask loops
+    // stay separate.
     let budgetEnv = envForCourtContinue(env);
     for (;;) {
         const terminal = await trySettlePublicSeat(current, env.principalAuthority, { ...await readCurrentCourt(current.runDirectory), ...packageFaultScope(current, env, io) });
@@ -1177,7 +1264,8 @@ async function auditSubmittedRole(turn, env, io, resumedOfficer, passedReceipt)
         return runPublicInstructionSeatResume({
             runId: admitted.runId,
             runDirectory: admitted.runDirectory,
-            summons: { instruction: SECRETARIAT_STATUS_REASK },
+            message: SECRETARIAT_STATUS_REASK,
+            summons: { instructionEmpty: true },
         }, next, io);
     }
     if (admitted.role === "countersign" && (typeof status !== "string" || !REVIEW_QUEUE_STATUSES.has(status))) {
@@ -1192,7 +1280,8 @@ async function auditSubmittedRole(turn, env, io, resumedOfficer, passedReceipt)
         return runPublicInstructionSeatResume({
             runId: admitted.runId,
             runDirectory: admitted.runDirectory,
-            summons: { instruction: officerConclusionReask(status) },
+            message: officerConclusionReask(status),
+            summons: { instructionEmpty: true },
         }, next, io);
     }
     // Self-escalation is a valid open routing state for these seats only.

package/dist/public-cli/invocation.js

@@ -1131,17 +1131,13 @@ export function appendCallerFileFlagPaths(body, attachments, requestManifestPath
 }
 /**
  * One initial prompt transport. The registry `transportPrompt` leaf selects
- * a fixed kickoff, a bound baseline, or skill args. Absent means the caller
- * instruction plus caller file-flag paths (ADR 0087).
+ * a bound baseline or skill args. Absent means the caller instruction plus
+ * caller file-flag paths (ADR 0087). Notary dialogue is owned by
+ * resolveReviewSeatDialogueBody (review fixed dispatch), not an empty transport leaf.
  * Engine / outsourcing material rides startup readingMaterial (#1167), not here.
  */
 export function buildInstructionTransportPrompt(admitted) {
     const kind = admittedTransportPromptKind(admitted);
-    if (kind === "fixed-kickoff") {
-        // #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) {
             throw new Error("baseline transport prompt is missing the bound revision");