@akagilnc/pi-workflow-roles 0.1.3652 → 0.1.3663

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

@@ -163,10 +163,11 @@ function resumeRereadInstruction(materialPath: string, handbook: boolean): strin
 }
 
 /**
- * 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(
@@ -188,9 +189,19 @@ export function instructResumeHandbookRead(
     .join("\n");
 }
 
+/** Append a live-path reread instruction when the pointer is not already on the continuation. */
+export function appendResumeMaterialReread(
+  prompt: string,
+  materialPath: string,
+): string {
+  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,
@@ -1128,6 +1139,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 +1182,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 +1205,6 @@ function parsePersistedTicketIdentity(
 ): {
   correlationId?: string;
   ticketNumber?: number;
-  ticketResolution?: "true-unbound";
 } {
   const correlationId =
     typeof record.correlationId === "string" && record.correlationId.trim() !== ""
@@ -1180,26 +1216,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 +1278,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 +1437,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 +1466,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 +1505,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;
 }
 
 /**

package/dist/diarist-ticket-resolution.js

@@ -1,177 +0,0 @@
-/**
- * 起居郎 pre-court ticket resolution (#582 / diarist-resolves-ticket-llm-layer).
- * Unbound countersign: LLM typed assertion over accepted instruction, then two
- * mechanical checks on N (complete decimal number in instruction; live GitHub issue).
- * Verification failure is controlled failure — never washed to true-unbound.
- */
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { createGhApiRunner, projectGhIssueBody, } from "./collector-github.js";
-import { ENGINE_DETOUR_STAGED_PROMPT_TOKEN, runEngineDetourOnce, } from "./engine-detour.js";
-export const DIARIST_RESOLVE_TICKET_METHOD_RELATIVE = "resources/diarist-resolve-ticket.md";
-export class DiaristTicketResolutionError extends Error {
-    code = "diarist-ticket-resolution";
-    reason;
-    constructor(reason, message, options) {
-        super(message, options);
-        this.name = "DiaristTicketResolutionError";
-        this.reason = reason;
-    }
-}
-export function resolveDiaristResolveTicketMethodPath(packageRoot = fileURLToPath(new URL("..", import.meta.url))) {
-    return join(packageRoot, DIARIST_RESOLVE_TICKET_METHOD_RELATIVE);
-}
-/**
- * Decision-key exact identity: complete decimal number N appears in instruction.
- * A longer number's digit substring (e.g. 82 inside #582) is not N.
- */
-export function instructionContainsTicketNumber(instruction, ticketNumber) {
-    if (!Number.isSafeInteger(ticketNumber) || ticketNumber < 1)
-        return false;
-    // Complete number token: not preceded or followed by another digit.
-    return new RegExp(`(?<!\\d)${String(ticketNumber)}(?!\\d)`).test(instruction);
-}
-/** Sole stdout shapes: {assertion:"ticket",ticketNumber:N} | {assertion:"true-unbound"}. */
-export function parseDiaristTicketResolverStdout(stdout) {
-    const trimmed = stdout.trim();
-    if (trimmed.length === 0) {
-        throw new DiaristTicketResolutionError("empty-stdout", "diarist ticket resolver stdout is empty");
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(trimmed);
-    }
-    catch (error) {
-        throw new DiaristTicketResolutionError("unparseable-json", "diarist ticket resolver stdout is not JSON", { cause: error });
-    }
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-        throw new DiaristTicketResolutionError("not-object", "diarist ticket resolver stdout must be one JSON object");
-    }
-    const record = parsed;
-    if (!Object.prototype.hasOwnProperty.call(record, "assertion")) {
-        throw new DiaristTicketResolutionError("assertion-missing", "diarist ticket resolver stdout missing assertion");
-    }
-    if (record.assertion === "true-unbound")
-        return { kind: "true-unbound" };
-    const n = record.ticketNumber;
-    if (record.assertion === "ticket" &&
-        typeof n === "number" &&
-        Number.isSafeInteger(n) &&
-        n >= 1) {
-        return { kind: "ticket", ticketNumber: n };
-    }
-    throw new DiaristTicketResolutionError("assertion-uninterpretable", "diarist ticket resolver assertion is not ticket|true-unbound with safe ticketNumber");
-}
-const HERMES_RESOLVER_TOOLSET = "context_engine";
-/** Hermes resolver: method bytes + instruction only; empty toolset; staged prompt. */
-export function createHermesDiaristTicketResolver(options = {}) {
-    const methodPath = resolveDiaristResolveTicketMethodPath(options.packageRoot);
-    if (!existsSync(methodPath)) {
-        throw new Error(`diarist resolve-ticket method material missing (${methodPath})`);
-    }
-    const method = readFileSync(methodPath, "utf8");
-    if (method.trim().length === 0) {
-        throw new Error(`diarist resolve-ticket method material is empty (${methodPath})`);
-    }
-    const executable = options.executable ?? "hermes";
-    return async (input) => {
-        const argv = [
-            executable,
-            "chat",
-            "--query-file",
-            ENGINE_DETOUR_STAGED_PROMPT_TOKEN,
-            "-Q",
-            "--no-restore-cwd",
-            "--ignore-rules",
-            "-t",
-            HERMES_RESOLVER_TOOLSET,
-        ];
-        let result;
-        try {
-            result = await runEngineDetourOnce({
-                argv,
-                stagedPrompt: JSON.stringify({ method, instruction: input.instruction }),
-                cwd: options.cwd ?? process.cwd(),
-                ...(options.env === undefined ? {} : { env: options.env }),
-                ...(input.signal === undefined ? {} : { signal: input.signal }),
-            });
-        }
-        catch (error) {
-            throw new DiaristTicketResolutionError("engine-failed", "diarist ticket resolver engine failed to launch", { cause: error });
-        }
-        if (result.code !== 0) {
-            throw new DiaristTicketResolutionError("engine-failed", `diarist ticket resolver engine exited ${result.code}: ${result.stderr.slice(0, 500)}`);
-        }
-        return parseDiaristTicketResolverStdout(result.stdout);
-    };
-}
-/** Live ticket check over shared gh issue-body projection. */
-export function createGhTicketExistenceChecker(options) {
-    const runner = options?.runner ?? createGhApiRunner();
-    return async (input) => {
-        const projected = await projectGhIssueBody(runner, {
-            owner: input.owner,
-            repo: input.repo,
-            ticketNumber: input.ticketNumber,
-            ...(input.signal === undefined ? {} : { signal: input.signal }),
-        });
-        if (projected.status === "available")
-            return true;
-        if (projected.status === "unavailable"
-            && projected.reason === "http-non-2xx"
-            && projected.httpStatus === 404) {
-            return false;
-        }
-        if (projected.status === "unavailable" && projected.reason === "pull-request") {
-            throw new DiaristTicketResolutionError("ticket-is-pull-request", `ticket #${input.ticketNumber} resolves to a pull request, not an issue`, { cause: projected });
-        }
-        if (projected.status === "unavailable") {
-            throw new DiaristTicketResolutionError("ticket-unavailable", `ticket verification unavailable for ${input.owner}/${input.repo}#${input.ticketNumber}`, { cause: projected });
-        }
-        throw new DiaristTicketResolutionError("ticket-invalid", `ticket verification returned an invalid issue payload for ${input.owner}/${input.repo}#${input.ticketNumber}`, { cause: projected });
-    };
-}
-/** Mechanical verify after LLM assertion. true-unbound passes; ticket needs both checks. */
-export async function verifyDiaristTicketAssertion(input) {
-    if (input.assertion.kind === "true-unbound")
-        return input.assertion;
-    const n = input.assertion.ticketNumber;
-    if (!instructionContainsTicketNumber(input.instruction, n)) {
-        throw new DiaristTicketResolutionError("number-not-in-instruction", `diarist ticket assertion #${n} complete decimal number does not appear in accepted instruction`);
-    }
-    if (input.origin === undefined) {
-        throw new DiaristTicketResolutionError("origin-unresolved", `diarist ticket assertion #${n} requires a resolvable github.com origin remote`);
-    }
-    let exists;
-    try {
-        exists = await input.checkExistence({
-            owner: input.origin.owner,
-            repo: input.origin.repo,
-            ticketNumber: n,
-            ...(input.signal === undefined ? {} : { signal: input.signal }),
-        });
-    }
-    catch (error) {
-        if (error instanceof DiaristTicketResolutionError)
-            throw error;
-        throw new DiaristTicketResolutionError("ticket-unavailable", `diarist ticket assertion #${n} live verification failed`, { cause: error });
-    }
-    if (!exists) {
-        throw new DiaristTicketResolutionError("ticket-missing", `diarist ticket assertion #${n} does not exist as a live issue on ${input.origin.owner}/${input.origin.repo}`);
-    }
-    return input.assertion;
-}
-export async function resolveDiaristTicketFromInstruction(input) {
-    const assertion = await input.resolver({
-        instruction: input.instruction,
-        ...(input.signal === undefined ? {} : { signal: input.signal }),
-    });
-    return verifyDiaristTicketAssertion({
-        assertion,
-        instruction: input.instruction,
-        origin: input.origin,
-        checkExistence: input.checkExistence,
-        ...(input.signal === undefined ? {} : { signal: input.signal }),
-    });
-}

package/resources/diarist-resolve-ticket.md

@@ -1,39 +0,0 @@
-# 起居郎认票方法（owner-domain）
-
-本文件是起居郎 LLM 认票推理的语义方法真源（decision key `diarist-resolves-ticket-llm-layer` / #582）。机器经共享 engine 接缝 staged prompt 递送本文件字节与已受理 instruction（不入 argv）；判断以本方法为准。
-
-## 任务
-
-只根据已受理 instruction，断言本庭的票面身份：
-
-- 认出明确票号 N → 断言 `ticket`
-- 真无票（instruction 不指向任何具体票）→ 断言 `true-unbound`
-
-## 何谓认出票号
-
-instruction 明确以本庭任务绑定某一 GitHub issue / 票号时，才断言 `ticket`。常见形态包括但不限于：
-
-- 「票 #582」「#582」「issue 582」
-- 明确写出要审/修/续的票号
-
-拿不准、只是顺带提到他票、或 instruction 本身是无票的一般性问询 → 断言 `true-unbound`。**不得猜测**。
-
-## 边界
-
-- 只读 instruction；不得假设附件、仓库状态或历史 run。
-- 相关性/授权内容不归你管——你只回答「是哪张票 / 真无票」。
-- 不得输出多个票号；若 instruction 含多个候选且无法唯一确定，断言 `true-unbound`。
-
-## 输出
-
-只输出一个 JSON 对象，二者择一：
-
-```json
-{"assertion":"ticket","ticketNumber":582}
-```
-
-```json
-{"assertion":"true-unbound"}
-```
-
-`ticketNumber` 必须是正整数。不要输出 JSON 以外的文字。