@akagilnc/pi-workflow-roles 0.1.3708 → 0.1.3716

package/src/host-contracts.ts

@@ -127,11 +127,7 @@ export type RoleTurnActivation =
   | { readonly role: "gatekeeper" }
   | { readonly role: "navigator" }
   | { readonly role: "auditor" }
-  | {
-      readonly role: "diarist";
-      /** Frozen source-catalog path; absent for a true-unbound summons (#708). */
-      readonly sourcesPath?: string;
-    };
+  | { readonly role: "diarist" };
 
 export type RoleTurnContinuation =
   | { readonly kind: "initial"; readonly prompt: string }

package/src/package-contracts/terminating-tools.ts

@@ -303,7 +303,7 @@ export function validateAcceptedLifecycle(
   if (toolName === DIARIST_OUTPUT_TOOL_NAME) {
     // Envelope-owned mechanical sitian facts are runtime-bound on details only
     // (same shape as the Doctor runtime cost); the submitted arguments carry the
-    // role's own selections. Machine facts never come from model self-report.
+    // role's own entries. Machine facts never come from model self-report.
     const { sitian: _mechanical, ...submitted } = details as DiaristOutput & { sitian?: unknown };
     const testimony = validateAcceptedDetails(toolName, argumentsValue);
     if (!deepEqual(testimony, submitted)) throw new Error("accepted tool lifecycle details mismatch");

package/src/packaged-role-registry.ts

@@ -12,10 +12,7 @@ import { COUNTERSIGN_OUTPUT_TOOL_NAME } from "./countersign-contracts.ts";
 import { GLEANER_LEFT_OUTPUT_TOOL_NAME } from "./gleaner-left-contracts.ts";
 import { INSPECTOR_OUTPUT_TOOL_NAME } from "./inspector-contracts.ts";
 import { AUDITOR_OUTPUT_TOOL_NAME } from "./package-contracts/auditor-output.ts";
-import {
-  DIARIST_OUTPUT_TOOL_NAME,
-  DIARIST_SOURCES_FLAG,
-} from "./diarist-contracts.ts";
+import { DIARIST_OUTPUT_TOOL_NAME } from "./diarist-contracts.ts";
 
 /** Shared by public notary and gatekeeper-province notary. */
 export const NOTARY_SESSION_MATERIALS = [
@@ -214,14 +211,13 @@ export const PUBLIC_ROLE_RECORDS = [
     activationStage: "load-and-install",
     sessionMaterials: AUDITOR_PUBLIC_SESSION_MATERIALS,
   },
-  // #708 / ADR 0075 `diarist-is-role`: 起居郎 is a seat like any other. The
-  // frozen source catalog rides the shared input-flag seam; it is absent for a
-  // true-unbound summons (no ticket → no diary).
+  // #708 / ADR 0075 `diarist-is-role` / #779: 起居郎 is a seat like any other.
+  // No input flag — LLM finds materials itself (caller-transparent).
   {
     role: "diarist",
     phases: [null],
     outputTool: DIARIST_OUTPUT_TOOL_NAME,
-    inputFlag: DIARIST_SOURCES_FLAG.name,
+    inputFlag: undefined,
     phaseFlag: undefined,
     activationStage: "load-and-install",
     sessionMaterials: [

package/src/pi/role-turn-host.ts

@@ -149,13 +149,7 @@ function buildActivationFlagArgs(activation: RoleTurnActivation): string[] {
     case "auditor":
       return ["--ak-role", "auditor"];
     case "diarist":
-      return [
-        "--ak-role",
-        "diarist",
-        ...(activation.sourcesPath === undefined
-          ? []
-          : ["--ak-diarist-sources", activation.sourcesPath]),
-      ];
+      return ["--ak-role", "diarist"];
     default: {
       const _exhaustive: never = activation;
       return _exhaustive;

package/src/public-cli/cli.ts

@@ -28,6 +28,8 @@ import {
   setPersistentSeatConfig,
   setPersistentSeatEngine,
   setPersistentSeatHost,
+  setProviderHostAlias,
+  unsetProviderHostAlias,
   validatePublicCliConfigAxes,
   type CredentialProviders,
   type EffectiveSeat,
@@ -769,6 +771,7 @@ function renderHelp(): string {
     "Persistent config: ak-role config set <seat> <provider/model[:thinking]> | unset <gatekeeper|inspector|notary>",
     "Persistent engine (callable roles): ak-role config set-engine <seat> <name> | unset-engine <seat>",
     "Persistent host (callable roles): ak-role config set-host <seat> <name> | unset-host <seat>",
+    "Provider host alias: ak-role config set-provider-alias <provider> <host> <alias> | unset-provider-alias <provider> <host>",
     "Host resolution: --host → persistent seat host → pi (resume uses the same order; #617)",
     "Effective seats: ak-role roles",
   );
@@ -909,6 +912,16 @@ function renderConfig(config: PublicCliConfig): string {
   }
   // #422: show the effective auto-resume ceiling (configured value or default).
   lines.push(`autoResumeLimit\t${config.autoResumeLimit ?? AUTO_RESUME_LIMIT}`);
+  // #778: owner-registered provider→host aliases (disk face; seats stay as written).
+  const aliases = config.providerAliases;
+  if (aliases !== undefined) {
+    for (const provider of Object.keys(aliases).sort()) {
+      const byHost = aliases[provider]!;
+      for (const host of Object.keys(byHost).sort()) {
+        lines.push(`providerAlias\t${provider}\t${host}\t${byHost[host]}`);
+      }
+    }
+  }
   return `${lines.join("\n")}\n`;
 }
 
@@ -1081,6 +1094,47 @@ async function runConfigCommand(
     return 0;
   }
 
+  // #778: owner-registered provider→host alias (opaque strings; no host catalog).
+  if (args[0] === "set-provider-alias") {
+    if (args.length !== 4) {
+      throw new CliUsageError(
+        "usage: ak-role config set-provider-alias <provider> <host> <alias>",
+      );
+    }
+    let config = await loadAndValidateConfig(home, packageRoot);
+    try {
+      config = setProviderHostAlias(config, args[1]!, args[2]!, args[3]!);
+    } catch (error) {
+      throw new CliUsageError(
+        error instanceof Error ? error.message : String(error),
+        { cause: error },
+      );
+    }
+    await savePublicCliConfig(config, home);
+    io.stdout(renderConfig(config));
+    return 0;
+  }
+
+  if (args[0] === "unset-provider-alias") {
+    if (args.length !== 3) {
+      throw new CliUsageError(
+        "usage: ak-role config unset-provider-alias <provider> <host>",
+      );
+    }
+    let config = await loadAndValidateConfig(home, packageRoot);
+    try {
+      config = unsetProviderHostAlias(config, args[1]!, args[2]!);
+    } catch (error) {
+      throw new CliUsageError(
+        error instanceof Error ? error.message : String(error),
+        { cause: error },
+      );
+    }
+    await savePublicCliConfig(config, home);
+    io.stdout(renderConfig(config));
+    return 0;
+  }
+
   throw new CliUsageError(`unknown config subcommand: ${args[0]}`);
 }
 

package/src/public-cli/config.ts

@@ -54,6 +54,15 @@ export type PersistentSeatConfig = {
   host?: string;
 };
 
+/**
+ * #778: owner-registered provider name by host. Keyed seat-table provider →
+ * host → host-facing provider. Package code carries the map only — no built-in
+ * pairs. Unregistered (provider, host) pairs pass the seat provider through.
+ */
+export type ProviderHostAliases = Readonly<
+  Record<string, Readonly<Record<string, string>>>
+>;
+
 export type PublicCliConfig = {
   seats: Partial<Record<PublicConfigurableSeat, PersistentSeatConfig>>;
   /**
@@ -63,6 +72,11 @@ export type PublicCliConfig = {
    * bound (ADR 0035).
    */
   autoResumeLimit?: number;
+  /**
+   * #778: owner-registered provider→host aliases. Sibling of `seats`; never
+   * invents pairs. Absent or empty means pure pass-through.
+   */
+  providerAliases?: ProviderHostAliases;
   /**
    * #592: opaque seat rows this build does not own. Carried through every
    * parse→save cycle so a write never silently erases neighboring-line rows
@@ -293,6 +307,81 @@ export function setAutoResumeLimit(
   return { ...config, autoResumeLimit: parseAutoResumeLimit(limit) };
 }
 
+function requireNonEmptyToken(value: string, label: string): string {
+  const trimmed = value.trim();
+  if (trimmed === "") {
+    throw new Error(`${label} must be a non-empty string`);
+  }
+  return trimmed;
+}
+
+/**
+ * #778: register one owner provider→host alias. Opaque strings only — no host
+ * catalog check and no built-in provider pairs. Sibling keys (seats included)
+ * are preserved.
+ */
+export function setProviderHostAlias(
+  config: PublicCliConfig,
+  provider: string,
+  host: string,
+  alias: string,
+): PublicCliConfig {
+  const from = requireNonEmptyToken(provider, "provider");
+  const hostName = requireNonEmptyToken(host, "host");
+  const to = requireNonEmptyToken(alias, "alias");
+  const previous = config.providerAliases ?? {};
+  return {
+    ...config,
+    providerAliases: {
+      ...previous,
+      [from]: {
+        ...(previous[from] ?? {}),
+        [hostName]: to,
+      },
+    },
+  };
+}
+
+/** #778: drop one owner provider→host alias. Empty map collapses to absent. */
+export function unsetProviderHostAlias(
+  config: PublicCliConfig,
+  provider: string,
+  host: string,
+): PublicCliConfig {
+  const from = requireNonEmptyToken(provider, "provider");
+  const hostName = requireNonEmptyToken(host, "host");
+  const previous = config.providerAliases;
+  if (previous === undefined || previous[from] === undefined) return config;
+  const { [hostName]: _dropped, ...restHosts } = previous[from]!;
+  const nextForProvider =
+    Object.keys(restHosts).length === 0 ? undefined : restHosts;
+  const { [from]: _provider, ...restProviders } = previous;
+  const nextAliases =
+    nextForProvider === undefined
+      ? restProviders
+      : { ...restProviders, [from]: nextForProvider };
+  if (Object.keys(nextAliases).length === 0) {
+    const { providerAliases: _gone, ...rest } = config;
+    return rest;
+  }
+  return { ...config, providerAliases: nextAliases };
+}
+
+/**
+ * #778: project seat-table provider through owner aliases for one host.
+ * Unregistered pairs return the seat selection unchanged (pass-through).
+ */
+export function applyProviderHostAlias(
+  selection: SeatModelConfig | undefined,
+  host: string,
+  aliases: ProviderHostAliases | undefined,
+): SeatModelConfig | undefined {
+  if (selection === undefined || aliases === undefined) return selection;
+  const mapped = aliases[selection.provider]?.[host];
+  if (mapped === undefined) return selection;
+  return { ...selection, provider: mapped };
+}
+
 /**
  * Config-parse seam: persistent call axes belong to PUBLIC_CALLABLE_ROLES;
  * engine names need only path-safety syntax (no closed material catalog;
@@ -387,6 +476,7 @@ export function buildSeatModelCliArgs(model: SeatModelConfig | undefined): strin
 function serializePublicCliConfig(config: PublicCliConfig): {
   seats: Record<string, unknown>;
   autoResumeLimit?: number;
+  providerAliases?: ProviderHostAliases;
 } {
   return {
     // Known seats win on any key clash; by construction the two maps are
@@ -398,9 +488,48 @@ function serializePublicCliConfig(config: PublicCliConfig): {
     ...(config.autoResumeLimit === undefined
       ? {}
       : { autoResumeLimit: config.autoResumeLimit }),
+    ...(config.providerAliases === undefined ||
+    Object.keys(config.providerAliases).length === 0
+      ? {}
+      : { providerAliases: config.providerAliases }),
   };
 }
 
+function parseProviderHostAliases(value: unknown): ProviderHostAliases {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("public CLI config.providerAliases must be an object");
+  }
+  const out: Record<string, Record<string, string>> = {};
+  for (const [provider, byHost] of Object.entries(value as Record<string, unknown>)) {
+    if (provider.trim() === "") {
+      throw new Error("public CLI config.providerAliases provider key must be non-empty");
+    }
+    if (byHost === null || typeof byHost !== "object" || Array.isArray(byHost)) {
+      throw new Error(
+        `public CLI config.providerAliases[${provider}] must be an object`,
+      );
+    }
+    const hosts: Record<string, string> = {};
+    for (const [host, alias] of Object.entries(byHost as Record<string, unknown>)) {
+      if (host.trim() === "") {
+        throw new Error(
+          `public CLI config.providerAliases[${provider}] host key must be non-empty`,
+        );
+      }
+      if (typeof alias !== "string" || alias.trim() === "") {
+        throw new Error(
+          `public CLI config.providerAliases[${provider}][${host}] must be a non-empty string`,
+        );
+      }
+      hosts[host] = alias;
+    }
+    if (Object.keys(hosts).length > 0) {
+      out[provider] = hosts;
+    }
+  }
+  return out;
+}
+
 function parsePublicCliConfig(value: unknown): PublicCliConfig {
   if (value === null || typeof value !== "object" || Array.isArray(value)) {
     throw new Error("public CLI config must be an object");
@@ -408,6 +537,7 @@ function parsePublicCliConfig(value: unknown): PublicCliConfig {
   const record = value as {
     seats?: unknown;
     autoResumeLimit?: unknown;
+    providerAliases?: unknown;
     unknownSeats?: unknown;
   };
   // #422 round-trip preservation: the sibling top-level key must survive every
@@ -416,6 +546,15 @@ function parsePublicCliConfig(value: unknown): PublicCliConfig {
   if (record.autoResumeLimit !== undefined) {
     autoResumeLimit = parseAutoResumeLimit(record.autoResumeLimit);
   }
+  // #778: same survival duty as autoResumeLimit — owner aliases must not vanish
+  // on an unrelated seat write.
+  let providerAliases: ProviderHostAliases | undefined;
+  if (record.providerAliases !== undefined) {
+    const parsed = parseProviderHostAliases(record.providerAliases);
+    if (Object.keys(parsed).length > 0) {
+      providerAliases = parsed;
+    }
+  }
   // #592: opaque bucket may already be present on an in-memory round-trip
   // (load→set→save calls parse again). Carry it before seats iteration so a
   // disk-shaped seats map and a memory-shaped bucket both survive.
@@ -433,6 +572,7 @@ function parsePublicCliConfig(value: unknown): PublicCliConfig {
   const withOpaque = (seats: PublicCliConfig["seats"]): PublicCliConfig => ({
     seats,
     ...(autoResumeLimit === undefined ? {} : { autoResumeLimit }),
+    ...(providerAliases === undefined ? {} : { providerAliases }),
     ...(Object.keys(unknownSeats).length === 0 ? {} : { unknownSeats }),
   });
   if (record.seats === undefined) {
@@ -678,7 +818,23 @@ export function resolveEffectiveSeat(
     }
   }
 
-  return attachHostAxis(attachEngineAxis(modelSeat, config, invocation), config, invocation);
+  const withAxes = attachHostAxis(
+    attachEngineAxis(modelSeat, config, invocation),
+    config,
+    invocation,
+  );
+  // #778: host-facing provider is the seat-table value after owner aliases.
+  // Disk seats stay as written; only the effective selection is projected.
+  const selection = applyProviderHostAlias(
+    withAxes.selection,
+    withAxes.host,
+    config.providerAliases,
+  );
+  if (selection === undefined) {
+    const { selection: _dropped, ...rest } = withAxes;
+    return rest;
+  }
+  return { ...withAxes, selection };
 }
 
 export function effectiveSeatConfigurations(

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

@@ -104,8 +104,7 @@ type CourtDiaristIdentity =
  * Non-zero exit without escalate status is not rethrown here — caller decides
  * whether refresh must fail or first-entry settles controlled failure.
  * When `boundTicketNumber` is set (typed handoff from countersign), diarist
- * freezes under that key so issue face enters the catalog — never mechanical
- * recognition from prose.
+ * binds under that key before the turn — never mechanical recognition from prose.
  */
 async function invokeCourtDiarist(input: {
   readonly instruction: string;
@@ -218,7 +217,7 @@ export async function runCountersignCourtDiaristStation(
       instruction: `整理 #${admitted.ticketNumber} 的本案依据。`,
       projectRoot: admitted.projectRoot,
       failureLabel: `ticket #${admitted.ticketNumber}`,
-      // Refresh holds a typed key — hand it off so freeze loads issue face.
+      // Refresh holds a typed key — hand it off so identity is bound before turn.
       boundTicketNumber: admitted.ticketNumber,
     },
     env,

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

@@ -1,20 +1,11 @@
 /**
- * Public Diarist (起居郎) Role run — #708 / ADR 0075 `diarist-is-role`.
+ * Public Diarist (起居郎) Role run — #708 / ADR 0075 `diarist-is-role` / #779.
  * Same admit → post-admission → settle shape as the other instruction seats.
- * Semantic collection is the role's own turn; this seat only freezes the
- * mechanical source catalog the turn selects from (`diarist-collector-is-own-turn`).
+ * Semantic collection is the role's own turn: LLM finds materials itself
+ * (no frozen candidate catalog, no path/attachment burden on the caller).
  * Who calls it and in what order is the caller's business (ADR 0010 `no-call-rule`).
  */
-import { existsSync } from "node:fs";
-import { writeFile } from "node:fs/promises";
-import { join } from "node:path";
-
 import type { DurablePrincipalAuthority, RoleTurnRequest } from "../host-contracts.ts";
-import {
-  loadDiaristIssueFace,
-  prepareDiaristSourceCatalog,
-  serializeDiaristSourceCatalog,
-} from "../diarist.ts";
 import { engineSessionMaterialFromOptions } from "../package-resources/engine-material.ts";
 import { CliUsageError } from "./cli-errors.ts";
 import {
@@ -35,7 +26,6 @@ import {
 import {
   loadResumableDiaristRun,
   markRunAdmitted,
-  readRoleRunIdentity,
   type PublicResumeRequest,
   type SameTicketSummonsMaterials,
 } from "./run-lifecycle.ts";
@@ -57,107 +47,29 @@ export type DiaristRunEnv = PostAdmissionEnv & {
   /**
    * Typed handoff from a caller that already holds a verified ticket key
    * (countersign refresh / post-assert). Never derived from summons prose.
-   * When set: same-ticket resume under that key, else bind-before-freeze so
-   * issue face enters the catalog (ADR 0075 / 0081).
+   * When set: same-ticket resume under that key, else bind before the turn
+   * so identity is already on the run pages (ADR 0075 / 0081).
    */
   boundTicketNumber?: number;
 };
 
-/** Frozen catalog filename inside the run dossier (durable material, not argv). */
-const DIARIST_SOURCE_CATALOG_FILE = "diarist-sources.json" as const;
-
-/** Neutral path identifier only (ADR 0073) — catalog bytes stay on disk. */
-function withDiaristCatalogPath(
-  prompt: string,
-  sourcesPath: string | undefined,
-): string {
-  if (sourcesPath === undefined || sourcesPath.trim() === "") return prompt;
-  return `${prompt}\n\n已冻结来源文件（路径）：\n- ${sourcesPath}`;
-}
-
 /** Project admitted invocation onto the host-neutral turn request. */
 export function buildDiaristTurnRequest(
   admitted: AdmittedDiaristInvocation,
   options: RoleTurnRequestProjectionOptions,
-  sourcesPath?: string,
 ): RoleTurnRequest {
-  const continuation =
-    sourcesPath === undefined
-      ? options.continuation
-      : {
-          ...options.continuation,
-          prompt: withDiaristCatalogPath(options.continuation.prompt, sourcesPath),
-        };
   return projectRoleTurnRequest(
     admitted,
-    {
-      activation: {
-        role: "diarist" as const,
-        ...(sourcesPath === undefined ? {} : { sourcesPath }),
-      },
-    },
-    { ...options, continuation },
+    { activation: { role: "diarist" as const } },
+    options,
   );
 }
 
-/**
- * Mechanical source enumeration into a frozen catalog for this turn.
- * Bound summons: establish the per-ticket volume and load the issue face.
- * First-summons (unbound): freeze session candidates + summons text so the LLM
- * turn can assert ticketNumber; accept verifies and mints the volume (ADR 0075).
- * True-unbound is decided by the LLM assertion (null/absent ticketNumber), not
- * by skipping the freeze here.
- *
- * A run that has not settled yet (crash-resume, open-court continuation) keeps
- * the catalog its candidateIndexes were minted against — re-enumerating there
- * would rebind the role's indexes to bytes it never saw. Only a settled run
- * re-enumerates on the next same-ticket summons (ADR 0075 增量).
- */
-async function freezeDiaristSourceCatalog(
-  admitted: AdmittedDiaristInvocation,
-  env: Pick<DiaristRunEnv, "cwd" | "home">,
-): Promise<string> {
-  const path = join(admitted.runDirectory, DIARIST_SOURCE_CATALOG_FILE);
-  if (existsSync(path)) {
-    const identity = await readRoleRunIdentity(admitted.runDirectory);
-    if (identity !== undefined && identity.state !== "terminal") return path;
-  }
-  const issueFace =
-    admitted.ticketNumber === undefined
-      ? undefined
-      : await loadDiaristIssueFace({
-          ticketNumber: admitted.ticketNumber,
-          projectRoot: admitted.projectRoot,
-          home: env.home,
-        });
-  const catalog = await prepareDiaristSourceCatalog({
-    ...(admitted.ticketNumber === undefined
-      ? {}
-      : { ticketNumber: admitted.ticketNumber }),
-    instruction: admitted.instruction,
-    runDirectory: admitted.runDirectory,
-    projectRoot: admitted.projectRoot,
-    cwd: admitted.projectRoot,
-    home: env.home,
-    ...(issueFace === undefined ? {} : { issueFace }),
-    sessionCwds: [admitted.projectRoot, env.cwd],
-  });
-  await writeFile(path, serializeDiaristSourceCatalog(catalog), "utf8");
-  return path;
-}
-
-function diaristAdapters(options?: {
-  beforeDispatch?: (
-    admitted: AdmittedDiaristInvocation,
-  ) => void | Promise<void>;
-}): PostAdmissionAdapters<AdmittedDiaristInvocation> {
+function diaristAdapters(): PostAdmissionAdapters<AdmittedDiaristInvocation> {
   return {
     trySettle: (admitted, authority, scope) =>
       trySettleDiaristTerminalResult(admitted, authority, scope),
     shouldPresentSettled: () => true,
-    ...(options?.beforeDispatch === undefined
-      ? {}
-      : { beforeDispatch: options.beforeDispatch }),
   };
 }
 
@@ -182,11 +94,10 @@ export async function runPublicDiarist(
     throw error;
   }
 
-  // #637 / #771 / ADR 0075: ticket identity is the LLM's typed assertion on this
-  // turn (mechanical verify on accept), OR a typed handoff key already held by
-  // the caller (countersign refresh). Code never pre-judges the summons text
-  // against book-known numbers. First summons without handoff stays unbound
-  // until assert.
+  // #637 / #771 / ADR 0075 / #779: ticket identity is the LLM's typed assertion
+  // on this turn, OR a typed handoff key already held by the caller (countersign
+  // refresh). Code never pre-judges the summons text and never freezes a
+  // candidate catalog. First summons without handoff stays unbound until assert.
 
   const projectRoot = parsed.project ?? env.cwd;
   const handoffTicket = env.boundTicketNumber;
@@ -240,7 +151,7 @@ export async function runPublicDiarist(
 
   await markRunAdmitted(admitted, env.principalAuthority);
 
-  // Typed handoff: bind before freeze so issue face enters the catalog.
+  // Typed handoff: bind before the turn so identity is on durable pages.
   if (
     typeof handoffTicket === "number" &&
     Number.isSafeInteger(handoffTicket) &&
@@ -270,7 +181,6 @@ export async function runPublicDiarist(
       ),
     },
   };
-  // Mutable shell: ticket bind + catalog freeze re-project activation before executeTurn.
   const turnRequest = buildDiaristTurnRequest(admitted, turnProjection);
 
   return await runPostAdmissionOneShot({
@@ -278,15 +188,7 @@ export async function runPublicDiarist(
     env,
     io,
     request: turnRequest,
-    adapters: diaristAdapters({
-      beforeDispatch: async (admittedSeat) => {
-        const sourcesPath = await freezeDiaristSourceCatalog(admittedSeat, env);
-        Object.assign(
-          turnRequest,
-          buildDiaristTurnRequest(admittedSeat, turnProjection, sourcesPath),
-        );
-      },
-    }),
+    adapters: diaristAdapters(),
     ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
   }).then(async (result) => {
     // Accept may have bound ticket onto durable pages after LLM assertion.
@@ -323,9 +225,7 @@ export async function runPublicDiarist(
 
 /**
  * Resume a previously admitted Diarist run (#708 / ADR 0079 同票传召 = resume).
- * A re-entry into a settled run re-enumerates fresh sources; the offered
- * watermark keeps the pass incremental so already-seen blocks are not
- * re-offered. An unfinished run keeps its frozen catalog (see freeze above).
+ * LLM re-finds materials; entry identity keeps the volume idempotent.
  */
 export async function runPublicDiaristResume(
   request: PublicResumeRequest,
@@ -347,7 +247,6 @@ export async function runPublicDiaristResume(
         admitted.runDirectory,
         effective.summons,
       );
-      const sourcesPath = await freezeDiaristSourceCatalog(admitted, env);
       return buildDiaristTurnRequest(
         admitted,
         resumeTurnRequestProjectionOptions(
@@ -356,7 +255,6 @@ export async function runPublicDiaristResume(
           env,
           summonsPrepared,
         ),
-        sourcesPath,
       );
     },
     adapters: diaristAdapters(),

package/src/public-cli/option-definitions.ts

@@ -1307,6 +1307,8 @@ const SUPPORT_COMMAND_HELP = {
       "ak-role config set-host <seat> <name>",
       "ak-role config unset-host <seat>",
       "ak-role config set-auto-resume-limit <N>",
+      "ak-role config set-provider-alias <provider> <host> <alias>",
+      "ak-role config unset-provider-alias <provider> <host>",
     ],
     examples: [
       "ak-role config set judge openai-codex/gpt-5.6-sol:high",
@@ -1314,6 +1316,7 @@ const SUPPORT_COMMAND_HELP = {
       "ak-role config set-engine judge opus",
       "ak-role config set-host judge grok-build",
       "ak-role config set-auto-resume-limit 3",
+      "ak-role config set-provider-alias xai hermes xai-oauth",
     ],
   },
   help: {