@akagilnc/pi-workflow-roles 0.1.3652 → 0.1.3663

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

@@ -1,10 +1,18 @@
+/**
+ * Public Notary Role run: admit source-run locator → shared post-admission coordinator
+ * → settle Terminal result (#448 / #517). Zero caller prompt/attachment. Lifecycle is
+ * the shared post-admission seam; this module keeps only Notary adapters.
+ * #637 / #747: same-parent (--source-run) re-summons resume the seat's previous run.
+ */
+import { existsSync } from "node:fs";
+import { gateSubmissionCandidatePath } from "../auditor-dossier-tool.js";
 import { NotarySourceRunError, resolveNotarySourceRunLocator, } from "../notary-source-run.js";
 import { engineSessionMaterialFromOptions } from "../package-resources/engine-material.js";
 import { CliUsageError } from "./cli-errors.js";
 import { admitNotaryInvocation, buildNotaryTransportPrompt, } from "./invocation.js";
 import { tryResumeSameTicketSeatRun } from "./seat-ticket-binding.js";
 import { runPostAdmissionOneShot, runPostAdmissionSeatResume, resumeTurnRequestProjectionOptions, } from "./post-admission.js";
-import { loadResumableNotaryRun, markRunAdmitted, } from "./run-lifecycle.js";
+import { appendResumeMaterialReread, loadResumableNotaryRun, markRunAdmitted, } from "./run-lifecycle.js";
 import { presentStructuralRejection, trySettleNotaryTerminalResult, } from "./settlement.js";
 import { projectRoleTurnRequest, } from "./turn-request.js";
 /** Project admitted invocation onto the host-neutral turn request. */
@@ -153,10 +161,17 @@ export async function runPublicNotaryResume(request, env, io) {
             }
             return loaded;
         },
-        buildTurnRequest: (admitted, effective) => 
-        // #755: review continuation is plain dialogue / resume envelope — no
-        //「重新读」candidate line, no engine handbook packaging.
-        buildNotaryTurnRequest(admitted, resumeTurnRequestProjectionOptions(admitted, effective, env)),
+        buildTurnRequest: (admitted, effective) => {
+            const projection = resumeTurnRequestProjectionOptions(admitted, effective, env);
+            const candidatePath = gateSubmissionCandidatePath(admitted.sourceRunPath);
+            const prompt = existsSync(candidatePath)
+                ? appendResumeMaterialReread(projection.continuation.prompt, candidatePath)
+                : projection.continuation.prompt;
+            return buildNotaryTurnRequest(admitted, {
+                ...projection,
+                continuation: { kind: "resume", prompt },
+            });
+        },
         adapters: notaryAdapters(),
         ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
     });

package/dist/public-cli/post-admission.js

@@ -8,10 +8,19 @@
 import { randomUUID } from "node:crypto";
 import { readFile, writeFile } from "node:fs/promises";
 import { isAbsolute, join, resolve } from "node:path";
-import { buildResumeContinuationPrompt, RESUME_TRANSPORT_ENVELOPE, } from "./run-lifecycle.js";
+import { buildResumeContinuationPrompt, instructResumeHandbookRead, } from "./run-lifecycle.js";
 import { CliUsageError } from "./cli-errors.js";
 import { buildInstructionTransportPrompt, freezeAttachmentsIntoRun, } from "./invocation.js";
 import { pathContainedIn } from "../activation-ledger-topology.js";
+import { engineSessionMaterialFromOptions } from "../package-resources/engine-material.js";
+import { projectCaseDossierPointerSection } from "./case-dossier-delivery.js";
+/** Append one system section to a continuation prompt, keeping its kind. */
+function appendContinuationSection(continuation, section) {
+    const prompt = `${continuation.prompt}\n\n${section}`;
+    return continuation.kind === "initial"
+        ? { kind: "initial", prompt }
+        : { kind: "resume", prompt };
+}
 import { projectHostTransitionPriorNative } from "../host-transition-prior-native.js";
 import { missingCredentialPreDispatchFailure, postRunMissingCredentialFailure, } from "./public-run-credentials.js";
 import { acquireRunWriterLease, clearCurrentCourt, clearTypedProviderHttpObservation, markRunResumable, markRunRunning, markRunTerminal, readCurrentCourt, recordCurrentCourt, renderResumeCommand, RunWriterLeaseHeldError, } from "./run-lifecycle.js";
@@ -115,20 +124,17 @@ export async function dispatchPostAdmissionTurn(input) {
         const principalCoordinates = admitted.principal === undefined
             ? undefined
             : env.principalAuthority.decode(admitted.principal);
-        let turnRequest;
+        let hostTransition;
         try {
             previousHost = await readInvocationHost(admitted.runDirectory);
-            const hostTransition = previousHost !== undefined && liveHost !== undefined && principalCoordinates !== undefined
-                ? await projectHostTransitionPriorNative({
-                    previousHost,
-                    liveHost,
-                    piSessionFile: principalCoordinates.sessionFile,
-                })
-                : undefined;
-            turnRequest = env.signal === undefined ? request : { ...request, signal: env.signal };
-            if (hostTransition !== undefined) {
-                turnRequest = { ...turnRequest, hostTransition };
-            }
+            hostTransition =
+                previousHost !== undefined && liveHost !== undefined && principalCoordinates !== undefined
+                    ? await projectHostTransitionPriorNative({
+                        previousHost,
+                        liveHost,
+                        piSessionFile: principalCoordinates.sessionFile,
+                    })
+                    : undefined;
         }
         catch (error) {
             // prior-native IO is on the public one-shot path — controlled failure, not bare throw.
@@ -156,6 +162,27 @@ export async function dispatchPostAdmissionTurn(input) {
                 }, adapters, env.principalAuthority, io));
             }
         }
+        // Turn request is assembled after beforeDispatch so this turn sees whatever it
+        // settled — the seat's ticket bind re-projection. Case dossier delivery
+        // (ADR 0081) rides here for every public entry: first call, same-ticket
+        // re-summons and manual resume alike. System refs append their own neutral
+        // section; caller frozen attachments and the seat's own prompt bytes are
+        // never rewritten.
+        let turnRequest = env.signal === undefined ? request : { ...request, signal: env.signal };
+        if (hostTransition !== undefined) {
+            turnRequest = { ...turnRequest, hostTransition };
+        }
+        const dossierSection = await projectCaseDossierPointerSection({
+            ticketNumber: admitted.ticketNumber,
+            projectRoot: admitted.projectRoot,
+            home: env.home,
+        });
+        if (dossierSection !== undefined) {
+            turnRequest = {
+                ...turnRequest,
+                continuation: appendContinuationSection(turnRequest.continuation, dossierSection),
+            };
+        }
         let result;
         try {
             result = await env.roleTurnHost.executeTurn(turnRequest);
@@ -232,37 +259,36 @@ export async function dispatchPostAdmissionTurn(input) {
     }
 }
 /**
- * Shared resume continuation projection (#471 / #600 / #633 / #637 / #755):
- * seat-table model/engine/timeout axes, restored correlation, and either
- * - manual resume (no same-ticket summons): package envelope / optional caller
- *   message, with engine-axis handbook via buildResumeContinuationPrompt, or
- * - same-ticket summons (审核循环续话): caller/peer words + optional frozen
- *   attachment paths only — no「重新读」、no engine handbook packaging
- *   (#750/#755), whether or not attachments are present.
- * Caller message wins as prompt base when supplied (bytes unchanged, including
- * blank/whitespace); else summons instruction. Attachment projection must not
- * re-interpret the caller message as instructionEmpty.
+ * Shared resume continuation projection (#471 / #600 / #633 / #637): seat-table
+ * model/engine/timeout axes, restored correlation, and either
+ * - manual resume: package envelope / optional caller message (unchanged), or
+ * - same-ticket summons: this turn's instruction + frozen attachment paths.
+ * Caller message and summons materials each keep their place: a resume message
+ * keeps manual-resume prompt semantics while open-court frozen attachments still
+ * ride; summons instruction is only the prompt base when no caller message.
  * Seats add only their activation projection. Call prepareSummonsResumeMaterials
- * first when request.summons carries instruction or attachment paths.
+ * first when request.summons carries attachment paths.
  */
 export function resumeTurnRequestProjectionOptions(admitted, request, env, summonsPrepared) {
+    const engineMaterial = engineSessionMaterialFromOptions({
+        ...(env.engine === undefined ? {} : { engine: env.engine }),
+        packageRoot: env.packageRoot,
+    });
     let prompt;
     if (request.message !== undefined) {
-        if (summonsPrepared !== undefined) {
-            // #755: same-ticket review / open-court — caller words + optional paths.
-            // Attachments are not a gate: message-only summons must stay plain too.
-            prompt = buildInstructionTransportPrompt({
+        // Manual resume caller-message semantics stay authoritative for the prompt:
+        // message present → base bytes unchanged (including blank/whitespace).
+        // Open-court frozen attachments still continue when present; attachment
+        // projection must not re-interpret the caller message as instructionEmpty.
+        if (summonsPrepared !== undefined &&
+            summonsPrepared.attachments.length > 0) {
+            prompt = instructResumeHandbookRead(buildInstructionTransportPrompt({
                 instruction: request.message,
                 instructionEmpty: false,
                 attachments: summonsPrepared.attachments,
-            });
-        }
-        else if (request.summons !== undefined) {
-            // #755: same-ticket summons without prepared materials — caller words only.
-            prompt = request.message;
+            }, engineMaterial), engineMaterial);
         }
         else {
-            // Bare manual resume — outsourcing engine axis keeps handbook (#600/#736).
             prompt = buildResumeContinuationPrompt({
                 packageRoot: env.packageRoot,
                 ...(env.engine === undefined ? {} : { engine: env.engine }),
@@ -271,16 +297,9 @@ export function resumeTurnRequestProjectionOptions(admitted, request, env, summo
         }
     }
     else if (summonsPrepared !== undefined) {
-        // #755: same-ticket review summons — instruction/attachments only.
-        prompt = buildInstructionTransportPrompt(summonsPrepared);
-    }
-    else if (request.summons !== undefined) {
-        // #755: same-ticket summons with no instruction/attachments (e.g. notary
-        // source-run pointer) — plain resume envelope, no handbook / 重新读.
-        prompt = RESUME_TRANSPORT_ENVELOPE;
+        prompt = instructResumeHandbookRead(buildInstructionTransportPrompt(summonsPrepared, engineMaterial), engineMaterial);
     }
     else {
-        // Bare manual resume — outsourcing engine axis keeps handbook (#600/#736).
         prompt = buildResumeContinuationPrompt({
             packageRoot: env.packageRoot,
             ...(env.engine === undefined ? {} : { engine: env.engine }),

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

@@ -32,10 +32,11 @@ function resumeRereadInstruction(materialPath, handbook) {
         : `重新读 ${materialPath}`;
 }
 /**
- * Engine-axis resume-only material lines (#736 / ADR 0069·0071).
- * #755 withdrew this rewrite from 审核循环续话; review same-ticket resume stays
- * plain dialogue via resumeTurnRequestProjectionOptions. Outsourcing resume
- * still rewrites neutral handbook/path pointers into 重新读 instructions.
+ * Resume-only material lines (#736 ticket exemption to ADR 0073 §3).
+ * Neutral `- <absolute path>` pointers already on the continuation
+ * (handbook from appendEngineSessionMaterial; frozen attachments from
+ * instruction-seat transport) become reread instructions.
+ * Handbook keeps the argv suffix; other materials are path-only.
  * First-round delivery is unchanged; never pastes material body.
  */
 export function instructResumeHandbookRead(prompt, engineMaterial) {
@@ -55,9 +56,16 @@ export function instructResumeHandbookRead(prompt, engineMaterial) {
     })
         .join("\n");
 }
+/** Append a live-path reread instruction when the pointer is not already on the continuation. */
+export function appendResumeMaterialReread(prompt, materialPath) {
+    const instruction = resumeRereadInstruction(materialPath, false);
+    const lines = prompt.split("\n");
+    if (lines.includes(instruction))
+        return prompt;
+    return prompt.length === 0 ? instruction : `${prompt}\n${instruction}`;
+}
 /**
- * Unique continuation-prompt selector for manual/auto engine-axis resume
- * (#471 / #600 / #736). Not used for 审核循环 same-ticket summons (#755).
+ * Unique continuation-prompt selector for manual/auto resume (#471 / #600 / #736).
  * Message present → base bytes unchanged; absent → package transport envelope.
  * When engine material is present, append structured engine coordinates then
  * rewrite absolute material pointer lines into 重新读 instructions. Zero parse,
@@ -819,6 +827,30 @@ export async function findLatestRunIdForSeatTicket(input) {
     }
     return best;
 }
+/**
+ * Ticket identities this book's retained runs already record (#709).
+ * Read-only reuse surface for seat ticket binding — no ticket number is minted here.
+ */
+export async function collectBookRunTicketNumbers(input) {
+    const ledgerHome = resolveActivationLedgerHome(input.home);
+    const runsDir = join(activationBookDirectory(ledgerHome, input.bookKey), "runs");
+    let entries;
+    try {
+        entries = await readdir(runsDir);
+    }
+    catch (error) {
+        if (errorCodeOf(error) === "ENOENT")
+            return new Set();
+        throw error;
+    }
+    const known = new Set();
+    for (const entry of entries) {
+        const ticketNumber = await readRunTicketNumber(join(runsDir, entry));
+        if (ticketNumber !== undefined)
+            known.add(ticketNumber);
+    }
+    return known;
+}
 /** Restore optional correlation + typed ticket identity from a durable admitted page. */
 function parsePersistedTicketIdentity(record) {
     const correlationId = typeof record.correlationId === "string" && record.correlationId.trim() !== ""
@@ -829,20 +861,15 @@ function parsePersistedTicketIdentity(record) {
         record.ticketNumber >= 1
         ? record.ticketNumber
         : undefined;
-    const ticketResolution = record.ticketResolution === "true-unbound" ? "true-unbound" : undefined;
     return {
         ...(correlationId === undefined ? {} : { correlationId }),
         ...(ticketNumber === undefined ? {} : { ticketNumber }),
-        ...(ticketResolution === undefined ? {} : { ticketResolution }),
     };
 }
 function restoredTicketFields(fields) {
     return {
         ...(fields.correlationId === undefined ? {} : { correlationId: fields.correlationId }),
         ...(fields.ticketNumber === undefined ? {} : { ticketNumber: fields.ticketNumber }),
-        ...(fields.ticketResolution === undefined
-            ? {}
-            : { ticketResolution: fields.ticketResolution }),
     };
 }
 async function loadResumableRunRecord(home, runId, authority) {
@@ -880,7 +907,6 @@ async function loadResumableRunRecord(home, runId, authority) {
     let derived;
     let correlationId;
     let ticketNumber;
-    let ticketResolution;
     let prNumber;
     let repository;
     let repositoryDisplay;
@@ -1016,7 +1042,6 @@ async function loadResumableRunRecord(home, runId, authority) {
             const fromAdmitted = parsePersistedTicketIdentity(record);
             correlationId = fromAdmitted.correlationId;
             ticketNumber = fromAdmitted.ticketNumber;
-            ticketResolution = fromAdmitted.ticketResolution;
         }
     }
     catch (error) {
@@ -1041,17 +1066,12 @@ async function loadResumableRunRecord(home, runId, authority) {
                         : {}),
                 };
             }
-            if (correlationId === undefined ||
-                ticketNumber === undefined ||
-                ticketResolution === undefined) {
+            if (correlationId === undefined || ticketNumber === undefined) {
                 const fromInvocation = parsePersistedTicketIdentity(rec);
                 if (correlationId === undefined)
                     correlationId = fromInvocation.correlationId;
                 if (ticketNumber === undefined)
                     ticketNumber = fromInvocation.ticketNumber;
-                if (ticketResolution === undefined) {
-                    ticketResolution = fromInvocation.ticketResolution;
-                }
             }
         }
     }
@@ -1081,7 +1101,6 @@ async function loadResumableRunRecord(home, runId, authority) {
             ...(derived === undefined ? {} : { derived }),
             ...(correlationId === undefined ? {} : { correlationId }),
             ...(ticketNumber === undefined ? {} : { ticketNumber }),
-            ...(ticketResolution === undefined ? {} : { ticketResolution }),
             ...(prNumber === undefined ? {} : { prNumber }),
             ...(repository === undefined ? {} : { repository }),
             ...(repositoryDisplay === undefined ? {} : { repositoryDisplay }),

package/dist/public-cli/seat-ticket-binding.js

@@ -1,94 +1,117 @@
 /**
- * Shared LLM ticket binding for public court seats (#635).
- * One path: unbound admission → diarist instruction assertion → bindAdmittedTicketNumber.
+ * Shared ticket identity seam for public court seats (#635 / #637 / #709 / #747).
+ * One path: unbound admission → reuse a ticket number this book already records
+ * (retained run pages + 起居录 volumes) → bindAdmittedTicketNumber.
+ * ADR 0081 `reuse-case-ticket-without-extra-llm`: no seat-side model call, no
+ * second ticket-number source of truth, no minting a number from human titles.
+ * Nothing matched is not 真无票 — the run simply stays unbound, which is lawful.
  * No CLI --ticket and no attachment frontmatter binding.
- * #637: same-ticket prior-run lookup → resume decision also lives here (shared seam).
+ * #747: officer same-parent resume also lives here (shared seam).
  */
-import { resolveBookKeyFromGit } from "../activation-ledger-git.js";
-import { createGhTicketExistenceChecker, createHermesDiaristTicketResolver, DiaristTicketResolutionError, resolveDiaristTicketFromInstruction, } from "../diarist-ticket-resolution.js";
-import { resolveDiaristGithubOrigin } from "../diarist.js";
-import { bindAdmittedTicketNumber, recordTrueUnboundTicketResolution, } from "./invocation.js";
-import { findLatestRunIdForSeatTicket, } from "./run-lifecycle.js";
+import { existsSync } from "node:fs";
+import { ActivationGitRepositoryRequiredError, resolveBookKeyFromGit, } from "../activation-ledger-git.js";
+import { resolveTicketProvenanceVolume } from "../ticket-provenance.js";
+import { bindAdmittedTicketNumber, } from "./invocation.js";
+import { collectBookRunTicketNumbers, findLatestRunIdForSeatTicket, } from "./run-lifecycle.js";
 /**
- * Instruction → ticket resolution without admission (#635 / #637).
- * Used to locate a prior same-ticket run before minting a new one.
- * Throws on resolution failure — prefer probeInstructionTicket at seat entry.
+ * Complete decimal ticket tokens in an instruction.
+ * A digit run is one token: `82` inside `#582` is not 82, and a leading zero
+ * makes the run a different literal than the ticket number it would parse to.
  */
-export async function resolveInstructionTicket(instruction, projectRoot, env = {}) {
-    const resolver = createHermesDiaristTicketResolver({
-        ...(env.packageRoot === undefined ? {} : { packageRoot: env.packageRoot }),
-        cwd: projectRoot,
-    });
-    const checkExistence = createGhTicketExistenceChecker();
-    const origin = resolveDiaristGithubOrigin(projectRoot);
-    return resolveDiaristTicketFromInstruction({
-        instruction,
-        origin,
-        resolver,
-        checkExistence,
-    });
+export function instructionTicketTokens(instruction) {
+    const tokens = new Set();
+    for (const run of instruction.match(/\d+/g) ?? []) {
+        if (run.startsWith("0"))
+            continue;
+        const parsed = Number(run);
+        if (!Number.isSafeInteger(parsed) || parsed < 1)
+            continue;
+        tokens.add(parsed);
+    }
+    return [...tokens];
 }
 /**
- * Pre-admit probe: resolution success or captured DiaristTicketResolutionError.
- * Other errors still propagate (launch/infrastructure outside this class).
+ * Ticket identity this summons reuses, or undefined when none is unambiguous.
+ * Known identities come only from records this book already holds: 起居录 volume
+ * partitions and ticket numbers on retained run pages. Zero or several known
+ * tokens in the instruction leave the run unbound — never guess, never fail.
  */
-export async function probeInstructionTicket(instruction, projectRoot, env = {}) {
-    try {
-        const resolution = await resolveInstructionTicket(instruction, projectRoot, env);
-        return { kind: "resolved", resolution };
-    }
-    catch (error) {
-        if (error instanceof DiaristTicketResolutionError) {
-            return { kind: "failed", error };
+export async function resolveKnownTicketNumber(input) {
+    const tokens = instructionTicketTokens(input.instruction);
+    if (tokens.length === 0)
+        return undefined;
+    const known = [];
+    let runTickets;
+    for (const token of tokens) {
+        const volume = resolveTicketProvenanceVolume(token, input.projectRoot, input.home);
+        if (existsSync(volume.volumeDir)) {
+            known.push(token);
+            continue;
         }
-        throw error;
+        if (runTickets === undefined) {
+            runTickets = await readBookRunTickets(input);
+        }
+        if (runTickets.has(token))
+            known.push(token);
     }
+    return known.length === 1 ? known[0] : undefined;
 }
-/** Ticket number from a successful ticket probe; undefined for unbound/failed. */
-export function ticketNumberFromProbe(probe) {
-    if (probe.kind !== "resolved")
-        return undefined;
-    if (probe.resolution.kind !== "ticket")
-        return undefined;
-    return probe.resolution.ticketNumber;
+/**
+ * Diarist first-summons identity (ADR 0081 `initial-court-ticket-supplied`).
+ * Prefer a book-known reuse; when the book has no record yet, the sole complete
+ * decimal token in the caller's dispatch is the supplied ticket — the working
+ * 起居郎 round establishes the volume. Several tokens or none stay unbound.
+ * Not a second ticket-number source of truth and not an extra recognizer call.
+ */
+export async function resolveDiaristSummonsTicketNumber(input) {
+    const known = await resolveKnownTicketNumber(input);
+    if (known !== undefined)
+        return known;
+    const tokens = instructionTicketTokens(input.instruction);
+    return tokens.length === 1 ? tokens[0] : undefined;
 }
 /**
- * Sole disposition of a resolved ticket onto an unbound admission (#635 / #637).
- * Countersign / inspector / resolveSeatTicketBinding share this — no parallel branches.
+ * Ticket numbers on this book's retained runs.
+ * A directory with no book (not a git repository) simply holds no run history —
+ * admission owns that rejection face, this lookup does not pre-empt it.
  */
-export async function applyTicketResolution(admitted, resolution) {
-    if (resolution.kind === "ticket") {
-        await bindAdmittedTicketNumber(admitted, resolution.ticketNumber);
+async function readBookRunTickets(input) {
+    let bookKey;
+    try {
+        bookKey = input.bookKey ?? resolveBookKeyFromGit(input.projectRoot);
     }
-    else {
-        await recordTrueUnboundTicketResolution(admitted);
+    catch (error) {
+        if (error instanceof ActivationGitRepositoryRequiredError)
+            return new Set();
+        throw error;
     }
+    return await collectBookRunTicketNumbers({ home: input.home, bookKey });
 }
-/**
- * Apply a pre-admit probe onto an unbound admission.
- * Failed probes rethrow — caller must be inside the controlled-failure boundary
- * (post-admission beforeDispatch), never before admit/markRunning.
- */
-export async function applyInstructionTicketProbe(admitted, probe) {
-    if (probe.kind === "failed")
-        throw probe.error;
-    await applyTicketResolution(admitted, probe.resolution);
+/** Bind a reused ticket number onto an admission that is still unbound. */
+export async function bindReusedTicketNumber(admitted, ticketNumber) {
+    if (ticketNumber === undefined)
+        return;
+    if (admitted.ticketNumber !== undefined)
+        return;
+    await bindAdmittedTicketNumber(admitted, ticketNumber);
 }
 /**
- * Bind ticketNumber onto an unbound admitted seat via LLM instruction recognition.
- * Already-settled admissions (ticketNumber or durable true-unbound) short-circuit —
- * no re-entry into hermes on auto-resume attempts or manual resume (#635).
- * true-unbound is persisted once; failed verification throws.
+ * Sole seat disposition for an unbound admission (#635 / #709).
+ * Already-bound admissions short-circuit — resume keeps the identity it has.
+ * Used by seats that do not pre-resolve for same-ticket resume; the seats that
+ * do (countersign / inspector / diarist) reuse the number they already resolved.
  */
-export async function resolveSeatTicketBinding(admitted, env = {}) {
+export async function resolveSeatTicketBinding(admitted, env) {
     if (admitted.ticketNumber !== undefined)
-        return undefined;
-    if (admitted.ticketResolution === "true-unbound") {
-        return { kind: "true-unbound" };
-    }
-    const resolution = await resolveInstructionTicket(admitted.instruction, admitted.projectRoot, env);
-    await applyTicketResolution(admitted, resolution);
-    return resolution;
+        return admitted.ticketNumber;
+    const ticketNumber = await resolveKnownTicketNumber({
+        instruction: admitted.instruction,
+        projectRoot: admitted.projectRoot,
+        home: env.home,
+        bookKey: admitted.bookKey,
+    });
+    await bindReusedTicketNumber(admitted, ticketNumber);
+    return ticketNumber;
 }
 /**
  * Sole same-seat → resume decision (#637 / #724 / #747).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akagilnc/pi-workflow-roles",
-  "version": "0.1.3652",
+  "version": "0.1.3663",
   "description": "Soul-bound workflow roles for Pi",
   "type": "module",
   "license": "Apache-2.0",

package/src/public-cli/case-dossier-delivery.ts

@@ -0,0 +1,51 @@
+/**
+ * 系统随案递送本票起居录的中立指针段（ADR 0081 `automatic-case-material`；
+ * 指针输入沿 ADR 0079 `summons-pointer-input`，不把卷宗正文塞进提示词）。
+ * 只读已有案卷：不刷新、不生成、不校验内容、不新增拒收或停工条件。
+ * 机器文本仅中立标识材料（ADR 0073），用途说明归角色材料所有。
+ */
+import { stat } from "node:fs/promises";
+
+import { resolveTicketProvenanceVolume } from "../ticket-provenance.ts";
+
+/** Section heading of the system-delivered dossier pointer. */
+export const CASE_DOSSIER_SECTION_HEADING = "## 本票起居录（系统随案提供）" as const;
+
+/** Honest one-line state of one dossier file: present, absent, or unreadable. */
+async function describeDossierFile(path: string): Promise<string> {
+  try {
+    const stats = await stat(path);
+    if (!stats.isFile()) return `不可读（非普通文件）：${path}`;
+    return path;
+  } catch (error) {
+    const code = (error as NodeJS.ErrnoException).code;
+    if (code === "ENOENT") return `尚未生成：${path}`;
+    return `不可读（${code ?? "未知错误"}）：${path}`;
+  }
+}
+
+/**
+ * Pointer section for a bound ticket's existing 起居录, or undefined when the
+ * run carries no ticket identity (unbound calls stay legal and get no dossier).
+ * A bound ticket whose volume is missing or unreadable is stated as such —
+ * the section never claims a dossier that is not there.
+ */
+export async function projectCaseDossierPointerSection(input: {
+  readonly ticketNumber: number | undefined;
+  readonly projectRoot: string;
+  readonly home: string;
+}): Promise<string | undefined> {
+  if (input.ticketNumber === undefined) return undefined;
+  const volume = resolveTicketProvenanceVolume(
+    input.ticketNumber,
+    input.projectRoot,
+    input.home,
+  );
+  return [
+    CASE_DOSSIER_SECTION_HEADING,
+    "",
+    `票号：#${input.ticketNumber}`,
+    `人读视图：${await describeDossierFile(volume.humanViewFile)}`,
+    `记录卷宗：${await describeDossierFile(volume.recordFile)}`,
+  ].join("\n");
+}

package/src/public-cli/countersign-run.ts

@@ -1,9 +1,9 @@
 /**
  * Public Countersign Role run: admit ticket materials → shared post-admission
  * coordinator → settle Terminal result (#572 / ADR 0074). #599: manual resume
- * continues the exact session. Unbound admission resolves its ticket via the
- * shared seat LLM bind (#635). Who runs 起居郎, and when, is the caller's
- * composition (ADR 0010 / ADR 0075 `no-call-rule`) — not this seat's business.
+ * continues the exact session. Unbound admission reuses a known ticket identity
+ * (#709). Who runs 起居郎, and when, is the caller's composition
+ * (ADR 0010 / ADR 0075 `no-call-rule`) — not this seat's business.
  */
 import type { DurablePrincipalAuthority, RoleTurnRequest } from "../host-contracts.ts";
 import { engineSessionMaterialFromOptions } from "../package-resources/engine-material.ts";
@@ -15,9 +15,8 @@ import {
   type ParseCountersignArgvResult,
 } from "./invocation.ts";
 import {
-  applyInstructionTicketProbe,
-  probeInstructionTicket,
-  ticketNumberFromProbe,
+  bindReusedTicketNumber,
+  resolveKnownTicketNumber,
   tryResumeSameTicketSeatRun,
 } from "./seat-ticket-binding.ts";
 import {
@@ -91,17 +90,15 @@ export async function runPublicCountersign(
   }
 
   // #637: same ticket → resume prior countersign run with this summons' materials.
-  // Probe captures DiaristTicketResolutionError so admit+beforeDispatch can settle
-  // controlled failure (bare pre-admit throw skips terminal settlement).
+  // #709: identity is reused from records this book already holds — no seat model call.
   // No bare catch→fresh: lookup/resume failures surface; only true absence mints new.
   const projectRoot = parsed.project ?? env.cwd;
-  const ticketProbe = await probeInstructionTicket(
-    parsed.instruction,
+  const reusedTicketNumber = await resolveKnownTicketNumber({
+    instruction: parsed.instruction,
     projectRoot,
-    env,
-  );
-  const probedTicketNumber = ticketNumberFromProbe(ticketProbe);
-  if (probedTicketNumber !== undefined) {
+    home: env.home,
+  });
+  if (reusedTicketNumber !== undefined) {
     const summons: SameTicketSummonsMaterials = {
       instruction: parsed.instruction,
       instructionEmpty: parsed.instruction.trim() === "",
@@ -111,7 +108,7 @@ export async function runPublicCountersign(
       home: env.home,
       projectRoot,
       role: "countersign",
-      ticketNumber: probedTicketNumber,
+      ticketNumber: reusedTicketNumber,
       freshSummons: env.freshSummons,
       summons,
       resume: (runId, materials) =>
@@ -178,8 +175,8 @@ export async function runPublicCountersign(
     request: turnRequest,
     adapters: countersignAdapters({
       beforeDispatch: async (admitted) => {
-        // #635/#637: apply pre-admit probe inside controlled-failure boundary.
-        await applyInstructionTicketProbe(admitted, ticketProbe);
+        // #635/#709: bind the reused identity inside the controlled-failure boundary.
+        await bindReusedTicketNumber(admitted, reusedTicketNumber);
         Object.assign(
           turnRequest,
           buildCountersignTurnRequest(admitted, turnProjection),