@akagilnc/pi-workflow-roles 0.1.4782 → 0.1.4802

package/dist/migrate-book-topology.js

@@ -14937,7 +14937,7 @@ var init_option_definitions = __esm({
       },
       resume: {
         command: "resume",
-        summary: "Resume a role run under the live seat table (model/host/engine); session principal must still exist. [message] applies only to seats that accept caller instruction; Notary/\u7B26\u5B9D\u90CE must omit message and derives evidence from the existing source-run/dossier binding. Global --model/--thinking/--host/--engine must be placed before <runId> (either before `resume` or between `resume` and <runId>); the one argv after <runId> is the opaque message, not a flag position (#471).",
+        summary: "Resume a role run under the live seat table (model/host/engine); session principal must still exist. Every callable seat, including Notary/\u7B26\u5B9D\u90CE, accepts the optional caller message and passes it through unchanged as the continuation prompt. Notary explicit new still accepts only its source-run locator, not a caller prompt. Global --model/--thinking/--host/--engine must be placed before <runId> (either before `resume` or between `resume` and <runId>); the one argv after <runId> is the opaque message, not a flag position (#471).",
         usage: ["ak-role resume <runId> [message]"],
         examples: [
           "ak-role resume 01abc\u2026",

package/dist/pi/role-turn-host.js

@@ -134,7 +134,7 @@ function piUserDialogueBody(request) {
             const _exhaustive = request.continuation;
             return _exhaustive;
         })();
-    return request.continuation.kind === "resume" && request.activation.role === "reviewer"
+    return request.continuation.kind === "resume"
         ? rawPrompt
         : applyPiNativeSkillInvocation(request.methods, rawPrompt);
 }

package/dist/public-cli/auto-resume.js

@@ -20,7 +20,7 @@ import { AUTO_RESUME_LIMIT, describeErrorIdentity, acquireRunWriterLease, markRu
 import { parseAutoResumeLimit } from "./config.js";
 import { processCancelSignalName } from "./process-cancel.js";
 import { isLawfulTypedTerminalOutcome, formatTerminalResult } from "./terminal.js";
-import { attachRecordedSubmissions, presentFailureTerminal, presentStructuralRejection, resolveControlledFailureResumeObservation, } from "./settlement.js";
+import { attachRecordedSubmissions, presentFailureTerminal, resolveControlledFailureResumeObservation, } from "./settlement.js";
 const dummyIo = { stdout: () => { }, stderr: () => { } };
 /**
  * Persist run-state after a host-turn result, outside the retried dispatch try.
@@ -352,17 +352,6 @@ export async function runWithAutoResumeLoop(options) {
     let everyAttemptThrew = true;
     const retainedErrorFiles = [];
     while (true) {
-        let lease;
-        try {
-            lease = await acquireRunWriterLease(options.admitted.runDirectory, (diagnostic) => options.io.stderr(diagnostic));
-        }
-        catch (error) {
-            if (error instanceof RunWriterLeaseHeldError) {
-                presentStructuralRejection(error, options.io);
-                return { exitCode: 2 };
-            }
-            throw error;
-        }
         let result;
         // Set only when the caught throw is a TurnDispatchedFailure (#840 r9 判词
         // class 1): the host turn genuinely started this attempt even though
@@ -370,14 +359,19 @@ export async function runWithAutoResumeLoop(options) {
         // not a replay of the initial one.
         let turnStartedBeforeThrow = false;
         try {
+            // #987: guard the initial new turn with the existing lease, but do not
+            // pre-block a real host CLI resume on a package-side live holder.
+            const lease = isFirst
+                ? await acquireRunWriterLease(options.admitted.runDirectory)
+                : undefined;
             result = await options.dispatch(currentPayload, lease, isFirst, dummyIo);
         }
         catch (error) {
             // Owner 2026-08-23: 「出了异常，就原地记录错误信息，然后重试。」
             // Retain the whole exception in place (per-attempt full file + dossier
             // pointer); recording failure must not break the retry path (PR #418
-            // diagnostic-sink-isolation precedent). The dispatcher owns lease release
-            // in its own finally, so the retry round starts with the lock free.
+            // diagnostic-sink-isolation precedent). When a lease is held inside
+            // dispatch, that path owns release in its own finally.
             lastThrownError = error;
             turnStartedBeforeThrow = error instanceof TurnDispatchedFailure;
             const attempt = dispatchOrdinal;
@@ -508,7 +502,7 @@ export async function runWithAutoResumeLoop(options) {
         // throws and beforeDispatch failures retry the initial payload (#840 / #416).
         if (result?.turnDispatched === true || turnStartedBeforeThrow) {
             currentPayload = options.buildResumePayload();
+            isFirst = false;
         }
-        isFirst = false;
     }
 }

package/dist/public-cli/countersign-run.js

@@ -1,9 +1,36 @@
+/**
+ * Public Countersign Role run: admit ticket materials → court-pipeline prior
+ * station (起居郎) → shared post-admission coordinator → settle Terminal result
+ * (#572 / ADR 0074 / ADR 0075 / #742 / #771). #599: manual resume continues the
+ * exact session via explicit package runId. #987 Result 7: public entry no longer
+ * selects a prior run by ticket number; gate same-parent re-summons keep
+ * parentRunPath resume (#747 / ADR 0079 gate face). Explicit `ak-role new` mints
+ * fresh; explicit `ak-role resume <runId>` continues a named run.
+ *
+ * Court admission auto-runs 起居郎 so the 起居郎 LLM asserts the court target;
+ * mechanical layer only verifies; countersign reuses that typed identity for bind
+ * (ADR 0075 / 0081). Code never matches instruction text against book-known
+ * numbers. Who may call 起居郎 and in what order is not written into law
+ * (ADR 0075 不规定谁调用起居郎、顺序归调用者); the present admission effect is what this
+ * seat currently does. 起居录 path delivery is owned once by post-admission
+ * (#709 / ADR 0081). Court refresh may run on resume; it is not a resume
+ * precondition and does not rewrite or reject host resume (#987).
+ *
+ * Wiring (#771 / #863 / #987): gate parentRunPath resume (when present) runs
+ * before identity mint; public path without parentRunPath always materializes a
+ * new run after identity. 起居郎 escalate (认不出) and typed failure terminals
+ * (incl. verification failure) settle as countersign controlled failure — never
+ * wash into 真无票. Only a true missing lawful typed terminal stays unbound and
+ * continues the body (r5 unbound-continue). Bound refresh hands the typed key to
+ * 起居郎 so freeze loads issue face (ADR 0075: 每次过庭都跑是调用者用法 / typed handoff).
+ */
+import { resolve } from "node:path";
 import { engineSessionMaterialFromOptions, pickEngineAxis, } from "../package-resources/engine-material.js";
 import { CliUsageError } from "./cli-errors.js";
 import { projectCourtTicketNumbers } from "../diarist-contracts.js";
 import { readableGateItem } from "../readable-gate-item.js";
 import { isSafePositiveTicketNumber } from "../run-ticket-number.js";
-import { admitCountersignInvocation, bindAdmittedTicketNumber, bindCourtTicketNumbersOnAdmitted, buildCountersignTransportPrompt, freezePreparedAttachmentsIntoRun, materializeCountersignInvocation, relocateAdmittedRunToTicket, withPreparedAttachments, } from "./invocation.js";
+import { admitCountersignInvocation, bindAdmittedTicketNumber, bindCourtTicketNumbersOnAdmitted, buildCountersignTransportPrompt, materializeCountersignInvocation, persistAdmittedSourceRunPath, relocateAdmittedRunToTicket, withPreparedAttachments, } from "./invocation.js";
 import { prepareSummonsResumeMaterials, presentControlledFailure, runPostAdmissionOneShot, runPostAdmissionSeatResume, resumeTurnRequestProjectionOptions, StationChildExhaustedError, } from "./post-admission.js";
 import { loadResumableCountersignRun, markRunAdmitted, } from "./run-lifecycle.js";
 import { tryResumeSameTicketSeatRun } from "./seat-ticket-binding.js";
@@ -275,6 +302,27 @@ export async function runPublicCountersign(argv, env, io, parseCountersignArgv)
         throw error;
     }
     let admitted;
+    const gateParentRunPath = typeof env.parentRunPath === "string" && env.parentRunPath.trim() !== ""
+        ? env.parentRunPath
+        : undefined;
+    if (gateParentRunPath !== undefined) {
+        const resumeInstruction = env.reviewReask ?? env.gateReviewInstruction ?? parsed.instruction;
+        const resumed = await tryResumeSameTicketSeatRun({
+            home: env.home,
+            projectRoot: resolve(parsed.project ?? env.cwd),
+            role: "countersign",
+            parentRunPath: gateParentRunPath,
+            freshSummons: env.freshSummons,
+            summons: {
+                sourceRunPath: gateParentRunPath,
+                instruction: resumeInstruction,
+                instructionEmpty: resumeInstruction.trim() === "",
+            },
+            resume: (runId, materials) => runPublicCountersignResume({ runId, ...(materials === undefined ? {} : { summons: materials }) }, env, io),
+        });
+        if (resumed !== undefined)
+            return resumed;
+    }
     try {
         admitted = await admitCountersignInvocation({
             home: env.home,
@@ -312,27 +360,26 @@ export async function runPublicCountersign(argv, env, io, parseCountersignArgv)
                     ...(env.model === undefined ? {} : { model: env.model }),
                 });
             };
-            // #637 / #771 / ADR 0079: ticket identity is the 起居郎 LLM typed assertion
-            // (never mechanical matching of summons text). Resolve that typed key before
-            // materializing a run: same-ticket re-summons write only to the retained run.
-            // Controlled failures materialize below so they still have a durable page. The test
-            // seam `runCourtDiaristStation` defers identity to beforeDispatch; generic
-            // hook failures stay on the parent call-local budget, exhausted nested
-            // station children still skip parent auto-resume (#840 父子不层叠).
+            // #747 / #987: gate same-parent resume before identity mint. Public entry
+            // without parentRunPath never selects a prior run by ticket number.
+            // #637 / #771: ticket identity is the 起居郎 LLM typed assertion (never
+            // mechanical matching of summons text). Resolve that typed key before
+            // materializing a first-mint run. Controlled failures materialize below so
+            // they still have a durable page. The test seam `runCourtDiaristStation`
+            // defers identity to beforeDispatch; generic hook failures stay on the
+            // parent call-local budget, exhausted nested station children still skip
+            // parent auto-resume (#840 父子不层叠).
             let typedTicket;
             let typedCourtTicketNumbers;
             let identityDiaristRan = false;
             if (env.runCourtDiaristStation === undefined) {
                 let outcome;
                 try {
-                    // The identity child cannot name the newly minted countersign id as parent:
-                    // same-ticket lookup may intentionally never materialize that run. A selected
-                    // retained run receives its normally correlated refresh child during resume.
                     outcome = await invokeCourtDiarist({
                         instruction: parsed.instruction,
                         projectRoot: admitted.projectRoot,
                         failureLabel: "unbound summons",
-                        // #969: parent durable ticket is the resume/bind key (ADR 0079).
+                        // #969: parent durable ticket is the bind key (not a resume lookup).
                         ...(env.boundTicketNumber === undefined
                             ? {}
                             : { boundTicketNumber: env.boundTicketNumber }),
@@ -375,7 +422,7 @@ export async function runPublicCountersign(argv, env, io, parseCountersignArgv)
                 // failure above; bound refresh still fails honest via station.
                 if (outcome.identity.kind === "ticket") {
                     // #969: parent durable handoff wins over 起居郎 re-assert when both
-                    // present (receipt/assert mismatch → parent resume key).
+                    // present (receipt/assert mismatch → parent bind key).
                     typedTicket = isSafePositiveTicketNumber(env.boundTicketNumber)
                         ? env.boundTicketNumber
                         : outcome.identity.ticketNumber;
@@ -384,62 +431,19 @@ export async function runPublicCountersign(argv, env, io, parseCountersignArgv)
                 }
                 else if (isSafePositiveTicketNumber(env.boundTicketNumber)) {
                     // Parent board handoff present; 起居郎 returned true-unbound — still
-                    // resume/bind under the parent key (omitted receipt ticketNumber path).
+                    // bind under the parent key (omitted receipt ticketNumber path).
                     typedTicket = env.boundTicketNumber;
                 }
-                if (typedTicket !== undefined) {
-                    // #969/#879: gate re-ask / parent submission body share summons.instruction
-                    // (reask wins; argv instruction remains the 起居郎 identity face above).
-                    const resumeInstruction = env.reviewReask ?? env.gateReviewInstruction ?? parsed.instruction;
-                    const summons = {
-                        instruction: resumeInstruction,
-                        instructionEmpty: resumeInstruction.trim() === "",
-                    };
-                    const resumed = await tryResumeSameTicketSeatRun({
-                        home: env.home,
-                        projectRoot: admitted.projectRoot,
-                        role: "countersign",
-                        ticketNumber: typedTicket,
-                        freshSummons: env.freshSummons,
-                        summons,
-                        resume: async (runId, materials) => {
-                            // Consume the same pre-identity snapshot into the retained run; never
-                            // reopen caller paths after identity has run.
-                            const retained = await loadResumableCountersignRun(env.home, runId, env.principalAuthority);
-                            if (retained.admitted === undefined) {
-                                throw new Error(`retained countersign run disappeared before resume: ${runId}`);
-                            }
-                            const frozenPaths = (await freezePreparedAttachmentsIntoRun(preparedAttachments, retained.admitted.runDirectory, `s-${Date.now().toString(36)}`)).map((attachment) => attachment.frozenPath);
-                            const preparedMaterials = {
-                                ...(materials ?? {}),
-                                ...(frozenPaths.length === 0
-                                    ? {}
-                                    : { attachmentPaths: frozenPaths }),
-                            };
-                            // Identity 起居郎 asserted unbound (no issue face). Resume still runs
-                            // the bound refresh station under the typed key (ADR 0075: 每次过庭都跑是调用者用法).
-                            // #871: hand the identity set so resume can whole-replace the run fact
-                            // when this summons produced a new typed set (never union).
-                            return await runPublicCountersignResume({
-                                runId,
-                                summons: preparedMaterials,
-                            }, {
-                                ...env,
-                                ...(typedCourtTicketNumbers === undefined
-                                    ? {}
-                                    : { pendingCourtTicketNumbers: typedCourtTicketNumbers }),
-                            }, io);
-                        },
-                    });
-                    if (resumed !== undefined) {
-                        return resumed;
-                    }
-                }
             }
-            // No prior run was selected. Materialize this invocation now; true-unbound,
-            // first-ticket and deferred test-seam paths all retain their own durable page.
+            // No prior same-parent run was selected. Materialize this invocation now;
+            // true-unbound, first-ticket and deferred test-seam paths all retain their
+            // own durable page. Public re-summons without parentRunPath always mint.
             await materializeAdmission();
             await markRunAdmitted(admitted, env.principalAuthority);
+            if (gateParentRunPath !== undefined) {
+                await persistAdmittedSourceRunPath(admitted, gateParentRunPath);
+                admitted = { ...admitted, sourceRunPath: gateParentRunPath };
+            }
             if (identityDiaristRan && typedTicket !== undefined) {
                 try {
                     await bindAdmittedTicketNumber(admitted, typedTicket);
@@ -525,13 +529,12 @@ function countersignAdapters(options) {
     };
 }
 /**
- * Resume a previously admitted Countersign run (#599 / DK-3 / #637).
- * Restores role/ticket/session identity. Bound court re-entry runs the diarist
- * refresh station first (ADR 0075 每次过庭都跑); unbound skips refresh.
- * Same-ticket summons deliver this turn's instruction + frozen attachments on
- * the resume prompt; manual resume keeps package-envelope / caller-message
- * semantics and birth attachments. 起居录 path delivery remains post-admission's
- * single mount (#709).
+ * Resume a previously admitted Countersign run (#599 / DK-3 / #637 / #987).
+ * Restores role/ticket/session identity. Gate
+ * same-parent and explicit `ak-role resume <runId>` share this entry; summons
+ * may carry this turn's instruction. Manual resume forwards only the caller's
+ * message bytes. 起居录 path delivery remains
+ * post-admission's single mount (#709).
  */
 export async function runPublicCountersignResume(request, env, io) {
     return await runPostAdmissionSeatResume({
@@ -543,22 +546,7 @@ export async function runPublicCountersignResume(request, env, io) {
             const summonsPrepared = await prepareSummonsResumeMaterials(admitted.runDirectory, effective.summons);
             return buildCountersignTurnRequest(admitted, resumeTurnRequestProjectionOptions(admitted, effective, env, summonsPrepared));
         },
-        adapters: countersignAdapters({
-            beforeDispatch: async (admitted) => {
-                // #871 B7: durable set damage already identified at load — settle as
-                // station-child exhausted → presentControlledFailure (not structural exit 2).
-                if (admitted.courtTicketNumbersDamage !== undefined) {
-                    throw new StationChildExhaustedError(admitted.courtTicketNumbersDamage);
-                }
-                // #871: same-ticket re-summons may hand a fresh typed set from identity.
-                // Whole-set replace onto this run fact; no new set → keep stored set.
-                // Manual resume (no pending) keeps the durable set and never invents one.
-                if (env.pendingCourtTicketNumbers !== undefined) {
-                    await bindCourtTicketNumbersOnAdmitted(admitted, env.pendingCourtTicketNumbers);
-                }
-                await runCountersignCourtDiaristStation(admitted, env, io);
-            },
-        }),
+        adapters: countersignAdapters(),
         ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
     });
 }

package/dist/public-cli/diarist-run.js

@@ -3,7 +3,6 @@ import { CliUsageError } from "./cli-errors.js";
 import { admitDiaristInvocation, bindAdmittedTicketNumber, buildInstructionTransportPrompt, relocateAdmittedRunToTicket, recordAdmittedCorrelation, } from "./invocation.js";
 import { prepareSummonsResumeMaterials, runPostAdmissionOneShot, runPostAdmissionSeatResume, resumeTurnRequestProjectionOptions, } from "./post-admission.js";
 import { loadResumableDiaristRun, markRunAdmitted, } from "./run-lifecycle.js";
-import { tryResumeSameTicketSeatRun } from "./seat-ticket-binding.js";
 import { presentStructuralRejection, trySettleDiaristTerminalResult, } from "./settlement.js";
 import { projectRoleTurnRequest, } from "./turn-request.js";
 import { readBoardTicketNumber } from "../run-ticket-number.js";
@@ -53,32 +52,13 @@ export async function runPublicDiarist(argv, env, io, parseDiaristArgv) {
         }
         throw error;
     }
-    // #637 / #771 / ADR 0075 / #779: ticket identity is the LLM's typed assertion
-    // on this turn, OR a typed handoff key already held by the caller (countersign
-    // refresh). Code never pre-judges the summons text and never freezes a
-    // candidate catalog. First summons without handoff stays unbound until assert.
-    const projectRoot = parsed.project ?? env.cwd;
+    // #637 / #771 / ADR 0075 / #779 / #987: ticket identity is the LLM's typed
+    // assertion on this turn, OR a typed handoff key already held by the caller
+    // (countersign refresh bind). Code never pre-judges the summons text and never
+    // freezes a candidate catalog. Public same-ticket resume-by-ticketNumber was
+    // deleted (#987 Result 7); callers continue an existing diarist run only via
+    // explicit `ak-role resume <runId>`. Handoff ticket remains a bind key only.
     const handoffTicket = env.boundTicketNumber;
-    if (typeof handoffTicket === "number" &&
-        Number.isSafeInteger(handoffTicket) &&
-        handoffTicket >= 1) {
-        const summons = {
-            instruction: parsed.instruction,
-            instructionEmpty: parsed.instruction.trim() === "",
-            attachmentPaths: parsed.attachmentPaths,
-        };
-        const resumed = await tryResumeSameTicketSeatRun({
-            home: env.home,
-            projectRoot,
-            role: "diarist",
-            ticketNumber: handoffTicket,
-            freshSummons: env.freshSummons,
-            summons,
-            resume: (runId, materials) => runPublicDiaristResume({ runId, ...(materials === undefined ? {} : { summons: materials }) }, env, io),
-        });
-        if (resumed !== undefined)
-            return resumed;
-    }
     let admitted;
     try {
         admitted = await admitDiaristInvocation({

package/dist/public-cli/inspector-run.js

@@ -133,7 +133,7 @@ function inspectorAdapters(options) {
 /**
  * Resume a previously admitted Inspector run (#633 / #637); the session principal reopens.
  * Same-ticket summons deliver this turn's instruction + frozen attachments; manual
- * resume keeps package-envelope / caller-message semantics and birth attachments.
+ * resume forwards only caller-supplied message bytes.
  */
 export async function runPublicInspectorResume(request, env, io) {
     return await runPostAdmissionSeatResume({