@akagilnc/pi-workflow-roles 0.1.3652 → 0.1.3661

package/src/public-cli/instruction-seat-run.ts

@@ -36,11 +36,9 @@ import {
   type SameTicketSummonsMaterials,
 } from "./run-lifecycle.ts";
 import {
-  applyInstructionTicketProbe,
-  probeInstructionTicket,
-  ticketNumberFromProbe,
+  bindReusedTicketNumber,
+  resolveKnownTicketNumber,
   tryResumeSameTicketSeatRun,
-  type InstructionTicketProbe,
 } from "./seat-ticket-binding.ts";
 import {
   presentStructuralRejection,
@@ -248,11 +246,11 @@ export async function runPublicInstructionSeat(
   let auditorSubject: "judge" | "doctor" | undefined;
   let auditorSourceRun: string | undefined;
   let auditorSourceTicket: number | undefined;
-  let ticketProbe: InstructionTicketProbe | undefined;
+  let reusedTicketNumber: number | undefined;
 
   // #637 / #747: resume prior seat run with this summons' materials.
   // Auditor (#747): parent --source-run path is the lookup key.
-  // Other instruction seats: ticket probe (inspector face). No bare catch→fresh.
+  // Other instruction seats: reuse known ticket (#709). No bare catch→fresh.
   const projectRoot = parsed.project ?? env.cwd;
   if (role === "auditor") {
     if (parsed.subject !== "judge" && parsed.subject !== "doctor") {
@@ -288,12 +286,11 @@ export async function runPublicInstructionSeat(
       return { exitCode: 2 };
     }
   } else {
-    // Inspector face: unconditional probe (same seam as inspector-run.ts).
-    ticketProbe = await probeInstructionTicket(
-      parsed.instruction,
+    reusedTicketNumber = await resolveKnownTicketNumber({
+      instruction: parsed.instruction,
       projectRoot,
-      env,
-    );
+      home: env.home,
+    });
   }
 
   const summons: SameTicketSummonsMaterials = {
@@ -322,26 +319,22 @@ export async function runPublicInstructionSeat(
         }),
     });
     if (resumed !== undefined) return resumed;
-  } else {
-    const probedTicketNumber =
-      ticketProbe === undefined ? undefined : ticketNumberFromProbe(ticketProbe);
-    if (probedTicketNumber !== undefined) {
-      const resumed = await tryResumeSameTicketSeatRun({
-        home: env.home,
-        projectRoot,
-        role,
-        ticketNumber: probedTicketNumber,
-        freshSummons: env.freshSummons,
-        summons,
-        resume: (runId, materials) =>
-          runPublicInstructionSeatResume(
-            { runId, ...(materials === undefined ? {} : { summons: materials }) },
-            env,
-            io,
-          ),
-      });
-      if (resumed !== undefined) return resumed;
-    }
+  } else if (reusedTicketNumber !== undefined) {
+    const resumed = await tryResumeSameTicketSeatRun({
+      home: env.home,
+      projectRoot,
+      role,
+      ticketNumber: reusedTicketNumber,
+      freshSummons: env.freshSummons,
+      summons,
+      resume: (runId, materials) =>
+        runPublicInstructionSeatResume(
+          { runId, ...(materials === undefined ? {} : { summons: materials }) },
+          env,
+          io,
+        ),
+    });
+    if (resumed !== undefined) return resumed;
   }
 
   let admitted: AdmittedInstructionSeatInvocation;
@@ -406,13 +399,13 @@ export async function runPublicInstructionSeat(
         request: turnRequest,
         adapters: instructionSeatAdapters({
           beforeDispatch: async (admittedSeat) => {
-            // #635/#637: ticket bind inside controlled-failure boundary.
+            // #635/#709: ticket bind inside controlled-failure boundary.
             // Auditor inherits source-run ticket (notary face).
-            // Other seats: same applyInstructionTicketProbe as inspector-run.
+            // Other seats: reuse known ticket identity.
             if (auditorSourceTicket !== undefined) {
               await bindAdmittedTicketNumber(admittedSeat, auditorSourceTicket);
-            } else if (ticketProbe !== undefined) {
-              await applyInstructionTicketProbe(admittedSeat, ticketProbe);
+            } else {
+              await bindReusedTicketNumber(admittedSeat, reusedTicketNumber);
             }
           },
         }),

package/src/public-cli/invocation.ts

@@ -105,17 +105,10 @@ export type AdmittedRoleInvocationBase = {
    */
   readonly correlationId?: string;
   /**
-   * Typed ticketNumber after seat LLM bind or notary source-run inheritance (#635).
-   * Admission does not bind from CLI flag or attachment frontmatter.
+   * Typed ticketNumber after known-identity reuse or notary source-run inheritance
+   * (#635 / #709). Admission does not bind from CLI flag or attachment frontmatter.
    */
   readonly ticketNumber?: number;
-  /**
-   * Seat LLM ticket resolution settled as true-unbound (#635).
-   * Distinct from unbound-not-yet-resolved (field absent). Mutually exclusive
-   * with ticketNumber; both are durable one-shot conclusions so auto-resume
-   * and manual resume never re-enter hermes resolution.
-   */
-  readonly ticketResolution?: "true-unbound";
   /** Effective model from invocation identity; restored on resume when no CLI model is given. */
   readonly model?: InvocationEffectiveModel;
 };
@@ -464,8 +457,8 @@ export async function persistAdmittedSourceRunPath(
 /**
  * Bind a post-admission resolved ticketNumber onto the in-memory admitted
  * object and both durable pages (invocation.json + admitted-request.json).
- * Used by seat LLM ticket binding when admission was unbound
- * (#635 / #582 diarist-resolves-ticket-llm-layer). Never clears an existing binding.
+ * Used by known-ticket reuse when admission was unbound (#635 / #709).
+ * Never clears an existing binding.
  */
 export async function bindAdmittedTicketNumber(
   admitted: AdmittedRoleInvocation,
@@ -474,11 +467,6 @@ export async function bindAdmittedTicketNumber(
   if (!Number.isSafeInteger(ticketNumber) || ticketNumber < 1) {
     throw new Error(`bindAdmittedTicketNumber requires a safe positive integer, got ${String(ticketNumber)}`);
   }
-  if (admitted.ticketResolution === "true-unbound") {
-    throw new Error(
-      "bindAdmittedTicketNumber refuses to replace durable true-unbound ticket resolution",
-    );
-  }
   if (admitted.ticketNumber !== undefined) {
     if (admitted.ticketNumber === ticketNumber) return;
     throw new Error(
@@ -499,36 +487,6 @@ export async function bindAdmittedTicketNumber(
   );
 }
 
-/**
- * Persist seat LLM true-unbound conclusion onto in-memory admitted + both durable
- * pages so later auto-resume attempts and manual resume never re-enter hermes (#635).
- */
-export async function recordTrueUnboundTicketResolution(
-  admitted: AdmittedRoleInvocation,
-): Promise<void> {
-  if (admitted.ticketNumber !== undefined) {
-    throw new Error(
-      `recordTrueUnboundTicketResolution refuses to overwrite ticket #${admitted.ticketNumber}`,
-    );
-  }
-  if (admitted.ticketResolution === "true-unbound") return;
-  (admitted as { ticketResolution?: "true-unbound" }).ticketResolution =
-    "true-unbound";
-  await mergeInvocationIdentityPage(admitted.runDirectory, {
-    ticketResolution: "true-unbound",
-  });
-  const admittedPath = admitted.admittedRequestPath;
-  const current = JSON.parse(await readFile(admittedPath, "utf8")) as Record<
-    string,
-    unknown
-  >;
-  await writeFile(
-    admittedPath,
-    `${JSON.stringify({ ...current, ticketResolution: "true-unbound" }, null, 2)}\n`,
-    "utf8",
-  );
-}
-
 /** Add the identity returned by the production Pi launch seam to its existing ledger page. */
 export async function recordLaunchedPiIdentity(
   runDirectory: string,

package/src/public-cli/post-admission.ts

@@ -27,12 +27,25 @@ import type {
   ControlledFailureCause,
   DurablePrincipal,
   DurablePrincipalAuthority,
+  RoleTurnContinuation,
   RoleTurnHost,
   RoleTurnKnownFailure,
   RoleTurnRequest,
   RoleTurnResult,
   SessionCustomEntryAppender,
 } from "../host-contracts.ts";
+import { projectCaseDossierPointerSection } from "./case-dossier-delivery.ts";
+
+/** Append one system section to a continuation prompt, keeping its kind. */
+function appendContinuationSection(
+  continuation: RoleTurnContinuation,
+  section: string,
+): RoleTurnContinuation {
+  const prompt = `${continuation.prompt}\n\n${section}`;
+  return continuation.kind === "initial"
+    ? { kind: "initial", prompt }
+    : { kind: "resume", prompt };
+}
 import { projectHostTransitionPriorNative } from "../host-transition-prior-native.ts";
 import type { CredentialProviders, SeatModelConfig } from "./config.ts";
 import {
@@ -297,10 +310,10 @@ export async function dispatchPostAdmissionTurn<
       admitted.principal === undefined
         ? undefined
         : env.principalAuthority.decode(admitted.principal);
-    let turnRequest: RoleTurnRequest;
+    let hostTransition: RoleTurnRequest["hostTransition"];
     try {
       previousHost = await readInvocationHost(admitted.runDirectory);
-      const hostTransition =
+      hostTransition =
         previousHost !== undefined && liveHost !== undefined && principalCoordinates !== undefined
           ? await projectHostTransitionPriorNative({
               previousHost,
@@ -308,10 +321,6 @@ export async function dispatchPostAdmissionTurn<
               piSessionFile: principalCoordinates.sessionFile,
             })
           : undefined;
-      turnRequest = env.signal === undefined ? request : { ...request, signal: env.signal };
-      if (hostTransition !== undefined) {
-        turnRequest = { ...turnRequest, hostTransition };
-      }
     } catch (error) {
       // prior-native IO is on the public one-shot path — controlled failure, not bare throw.
       return (await presentControlledFailure(
@@ -351,6 +360,32 @@ export async function dispatchPostAdmissionTurn<
       }
     }
 
+    // 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: RoleTurnRequest =
+      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: RoleTurnResult;
     try {
       result = await env.roleTurnHost.executeTurn(turnRequest);

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

@@ -1128,6 +1128,34 @@ 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: {
+  readonly home: string;
+  readonly bookKey: string;
+}): Promise<ReadonlySet<number>> {
+  const ledgerHome = resolveActivationLedgerHome(input.home);
+  const runsDir = join(
+    activationBookDirectory(ledgerHome, input.bookKey),
+    "runs",
+  );
+  let entries: string[];
+  try {
+    entries = await readdir(runsDir);
+  } catch (error) {
+    if (errorCodeOf(error) === "ENOENT") return new Set();
+    throw error;
+  }
+  const known = new Set<number>();
+  for (const entry of entries) {
+    const ticketNumber = await readRunTicketNumber(join(runsDir, entry));
+    if (ticketNumber !== undefined) known.add(ticketNumber);
+  }
+  return known;
+}
+
 type LoadedAdmittedRequestFields = {
   readonly instruction: string;
   readonly instructionEmpty: boolean;
@@ -1143,8 +1171,6 @@ type LoadedAdmittedRequestFields = {
   readonly derived?: DerivedMergerEnvelope;
   readonly correlationId?: string;
   readonly ticketNumber?: number;
-  /** Durable seat LLM true-unbound conclusion (#635); restored on resume. */
-  readonly ticketResolution?: "true-unbound";
   /** Collector — admitted repository/PR identity restored on resume (#633). */
   readonly prNumber?: number;
   readonly repository?: string;
@@ -1168,7 +1194,6 @@ function parsePersistedTicketIdentity(
 ): {
   correlationId?: string;
   ticketNumber?: number;
-  ticketResolution?: "true-unbound";
 } {
   const correlationId =
     typeof record.correlationId === "string" && record.correlationId.trim() !== ""
@@ -1180,26 +1205,19 @@ function parsePersistedTicketIdentity(
     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: LoadedAdmittedRequestFields): {
   correlationId?: string;
   ticketNumber?: number;
-  ticketResolution?: "true-unbound";
 } {
   return {
     ...(fields.correlationId === undefined ? {} : { correlationId: fields.correlationId }),
     ...(fields.ticketNumber === undefined ? {} : { ticketNumber: fields.ticketNumber }),
-    ...(fields.ticketResolution === undefined
-      ? {}
-      : { ticketResolution: fields.ticketResolution }),
   };
 }
 
@@ -1249,7 +1267,6 @@ async function loadResumableRunRecord(
   let derived: DerivedMergerEnvelope | undefined;
   let correlationId: string | undefined;
   let ticketNumber: number | undefined;
-  let ticketResolution: "true-unbound" | undefined;
   let prNumber: number | undefined;
   let repository: string | undefined;
   let repositoryDisplay: string | undefined;
@@ -1409,7 +1426,6 @@ async function loadResumableRunRecord(
       const fromAdmitted = parsePersistedTicketIdentity(record);
       correlationId = fromAdmitted.correlationId;
       ticketNumber = fromAdmitted.ticketNumber;
-      ticketResolution = fromAdmitted.ticketResolution;
     }
   } catch (error) {
     // Preserve unique --authority-ref grammar failures; do not collapse to unreadable.
@@ -1439,17 +1455,10 @@ async function loadResumableRunRecord(
             : {}),
         };
       }
-      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;
-        }
       }
     }
   } catch (error) {
@@ -1485,7 +1494,6 @@ async function loadResumableRunRecord(
       ...(derived === undefined ? {} : { derived }),
       ...(correlationId === undefined ? {} : { correlationId }),
       ...(ticketNumber === undefined ? {} : { ticketNumber }),
-      ...(ticketResolution === undefined ? {} : { ticketResolution }),
       ...(prNumber === undefined ? {} : { prNumber }),
       ...(repository === undefined ? {} : { repository }),
       ...(repositoryDisplay === undefined ? {} : { repositoryDisplay }),

package/src/public-cli/seat-ticket-binding.ts

@@ -1,151 +1,155 @@
 /**
- * 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.ts";
+import { existsSync } from "node:fs";
+
 import {
-  createGhTicketExistenceChecker,
-  createHermesDiaristTicketResolver,
-  DiaristTicketResolutionError,
-  resolveDiaristTicketFromInstruction,
-  type DiaristTicketResolution,
-} from "../diarist-ticket-resolution.ts";
-import { resolveDiaristGithubOrigin } from "../diarist.ts";
+  ActivationGitRepositoryRequiredError,
+  resolveBookKeyFromGit,
+} from "../activation-ledger-git.ts";
+import { resolveTicketProvenanceVolume } from "../ticket-provenance.ts";
 import {
   bindAdmittedTicketNumber,
-  recordTrueUnboundTicketResolution,
   type AdmittedRoleInvocation,
 } from "./invocation.ts";
 import {
+  collectBookRunTicketNumbers,
   findLatestRunIdForSeatTicket,
   type RoleRunRecord,
   type SameTicketSummonsMaterials,
 } from "./run-lifecycle.ts";
 
 export type SeatTicketBindingEnv = {
-  readonly packageRoot?: string;
+  readonly home: string;
 };
 
 /**
- * Pre-admit instruction ticket probe (#635 / #637).
- * Success carries the resolution for same-ticket resume + post-admit bind.
- * DiaristTicketResolutionError is captured (not thrown) so the seat can still
- * admit and settle the failure inside the post-admission controlled path —
- * bare throw before admit would skip terminal settlement (失败诚实, no wash).
- */
-export type InstructionTicketProbe =
-  | { readonly kind: "resolved"; readonly resolution: DiaristTicketResolution }
-  | { readonly kind: "failed"; readonly error: DiaristTicketResolutionError };
-
-/**
- * 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(
+export function instructionTicketTokens(
   instruction: string,
-  projectRoot: string,
-  env: SeatTicketBindingEnv = {},
-): Promise<DiaristTicketResolution> {
-  const resolver = createHermesDiaristTicketResolver({
-    ...(env.packageRoot === undefined ? {} : { packageRoot: env.packageRoot }),
-    cwd: projectRoot,
-  });
-  const checkExistence = createGhTicketExistenceChecker();
-  const origin = resolveDiaristGithubOrigin(projectRoot);
-  return resolveDiaristTicketFromInstruction({
-    instruction,
-    origin,
-    resolver,
-    checkExistence,
-  });
+): readonly number[] {
+  const tokens = new Set<number>();
+  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: string,
-  projectRoot: string,
-  env: SeatTicketBindingEnv = {},
-): Promise<InstructionTicketProbe> {
-  try {
-    const resolution = await resolveInstructionTicket(
-      instruction,
-      projectRoot,
-      env,
+export async function resolveKnownTicketNumber(input: {
+  readonly instruction: string;
+  readonly projectRoot: string;
+  readonly home: string;
+  readonly bookKey?: string;
+}): Promise<number | undefined> {
+  const tokens = instructionTicketTokens(input.instruction);
+  if (tokens.length === 0) return undefined;
+  const known: number[] = [];
+  let runTickets: ReadonlySet<number> | undefined;
+  for (const token of tokens) {
+    const volume = resolveTicketProvenanceVolume(
+      token,
+      input.projectRoot,
+      input.home,
     );
-    return { kind: "resolved", resolution };
-  } catch (error) {
-    if (error instanceof DiaristTicketResolutionError) {
-      return { kind: "failed", error };
+    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: InstructionTicketProbe,
-): number | undefined {
-  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: {
+  readonly instruction: string;
+  readonly projectRoot: string;
+  readonly home: string;
+  readonly bookKey?: string;
+}): Promise<number | undefined> {
+  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: AdmittedRoleInvocation,
-  resolution: DiaristTicketResolution,
-): Promise<void> {
-  if (resolution.kind === "ticket") {
-    await bindAdmittedTicketNumber(admitted, resolution.ticketNumber);
-  } else {
-    await recordTrueUnboundTicketResolution(admitted);
+async function readBookRunTickets(input: {
+  readonly projectRoot: string;
+  readonly home: string;
+  readonly bookKey?: string;
+}): Promise<ReadonlySet<number>> {
+  let bookKey: string;
+  try {
+    bookKey = input.bookKey ?? resolveBookKeyFromGit(input.projectRoot);
+  } 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(
+/** Bind a reused ticket number onto an admission that is still unbound. */
+export async function bindReusedTicketNumber(
   admitted: AdmittedRoleInvocation,
-  probe: InstructionTicketProbe,
+  ticketNumber: number | undefined,
 ): Promise<void> {
-  if (probe.kind === "failed") throw probe.error;
-  await applyTicketResolution(admitted, probe.resolution);
+  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: AdmittedRoleInvocation,
-  env: SeatTicketBindingEnv = {},
-): Promise<DiaristTicketResolution | undefined> {
-  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;
+  env: SeatTicketBindingEnv,
+): Promise<number | undefined> {
+  if (admitted.ticketNumber !== undefined) 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;
 }
 
 /**