@akagilnc/pi-workflow-roles 0.1.3652 → 0.1.3661

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

@@ -12,6 +12,14 @@ import { buildResumeContinuationPrompt, RESUME_TRANSPORT_ENVELOPE, } from "./run
 import { CliUsageError } from "./cli-errors.js";
 import { buildInstructionTransportPrompt, freezeAttachmentsIntoRun, } from "./invocation.js";
 import { pathContainedIn } from "../activation-ledger-topology.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 +123,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 +161,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);

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

@@ -819,6 +819,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 +853,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 +899,6 @@ async function loadResumableRunRecord(home, runId, authority) {
     let derived;
     let correlationId;
     let ticketNumber;
-    let ticketResolution;
     let prNumber;
     let repository;
     let repositoryDisplay;
@@ -1016,7 +1034,6 @@ async function loadResumableRunRecord(home, runId, authority) {
             const fromAdmitted = parsePersistedTicketIdentity(record);
             correlationId = fromAdmitted.correlationId;
             ticketNumber = fromAdmitted.ticketNumber;
-            ticketResolution = fromAdmitted.ticketResolution;
         }
     }
     catch (error) {
@@ -1041,17 +1058,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 +1093,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.3661",
   "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),

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

@@ -24,9 +24,8 @@ import {
   type ParseDiaristArgvResult,
 } from "./invocation.ts";
 import {
-  applyInstructionTicketProbe,
-  probeInstructionTicket,
-  ticketNumberFromProbe,
+  bindReusedTicketNumber,
+  resolveDiaristSummonsTicketNumber,
   tryResumeSameTicketSeatRun,
 } from "./seat-ticket-binding.ts";
 import {
@@ -170,16 +169,15 @@ export async function runPublicDiarist(
   }
 
   // #637: same ticket → resume this seat's prior run with this summons' materials.
-  // Probe captures DiaristTicketResolutionError so admit+beforeDispatch can settle
-  // controlled failure (bare pre-admit throw skips terminal settlement).
+  // #709 / ADR 0081: reuse book records, or take the caller's sole dispatch token
+  // on a first summons that has not yet minted a volume — no seat recognizer call.
   const projectRoot = parsed.project ?? env.cwd;
-  const ticketProbe = await probeInstructionTicket(
-    parsed.instruction,
+  const reusedTicketNumber = await resolveDiaristSummonsTicketNumber({
+    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() === "",
@@ -189,7 +187,7 @@ export async function runPublicDiarist(
       home: env.home,
       projectRoot,
       role: "diarist",
-      ticketNumber: probedTicketNumber,
+      ticketNumber: reusedTicketNumber,
       freshSummons: env.freshSummons,
       summons,
       resume: (runId, materials) =>
@@ -256,7 +254,7 @@ export async function runPublicDiarist(
     request: turnRequest,
     adapters: diaristAdapters({
       beforeDispatch: async (admittedSeat) => {
-        await applyInstructionTicketProbe(admittedSeat, ticketProbe);
+        await bindReusedTicketNumber(admittedSeat, reusedTicketNumber);
         const sourcesPath = await freezeDiaristSourceCatalog(admittedSeat, env);
         Object.assign(
           turnRequest,

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

@@ -9,8 +9,8 @@ import type { DurablePrincipalAuthority, RoleTurnRequest } from "../host-contrac
 import { engineSessionMaterialFromOptions } from "../package-resources/engine-material.ts";
 import { CliUsageError } from "./cli-errors.ts";
 import {
-  applyInstructionTicketProbe,
-  probeInstructionTicket,
+  bindReusedTicketNumber,
+  resolveKnownTicketNumber,
   tryResumeSameTicketSeatRun,
 } from "./seat-ticket-binding.ts";
 import {
@@ -88,15 +88,14 @@ export async function runPublicInspector(
   }
 
   // #747: same parent (卷宗指针) → resume prior inspector run with this summons' materials.
-  // Probe captures DiaristTicketResolutionError so admit+beforeDispatch can settle
-  // controlled failure (bare pre-admit throw skips terminal settlement).
+  // #709: ticket 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,
-  );
+    home: env.home,
+  });
   const parentRunPath = parentRunPathFromGatePointerInstruction(parsed.instruction);
   if (parentRunPath !== undefined) {
     const summons: SameTicketSummonsMaterials = {
@@ -171,8 +170,8 @@ export async function runPublicInspector(
     request: turnRequest,
     adapters: inspectorAdapters({
       beforeDispatch: async (admittedSeat) => {
-        // #635/#637: apply pre-admit probe inside controlled-failure boundary.
-        await applyInstructionTicketProbe(admittedSeat, ticketProbe);
+        // #635/#709: bind the reused identity inside the controlled-failure boundary.
+        await bindReusedTicketNumber(admittedSeat, reusedTicketNumber);
       },
     }),
     ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),