@akagilnc/pi-workflow-roles 0.1.3558 → 0.1.3572

package/dist/{grok → acp-host}/production-host.js

@@ -1238,9 +1238,8 @@ var init_in_process_session = __esm({
   }
 });
 
-// src/grok/production-host.ts
+// src/acp-host/production-host.ts
 import { readFile as readFile15 } from "node:fs/promises";
-import { join as join24 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // src/canonical-skill-binding.ts
@@ -2875,6 +2874,50 @@ function validateRecordedInspectorOutput(value) {
   throw new Error("Inspector output has no execution discriminator");
 }
 
+// src/diarist-contracts.ts
+var DIARIST_OUTPUT_TOOL_NAME = "ak_diarist_output";
+var DIARIST_ACCEPTED_TEXT = "\u8D77\u5C45\u90CE\u56DE\u6267\u5DF2\u63A5\u53D7";
+var DIARIST_SOURCES_FLAG = {
+  name: "ak-diarist-sources",
+  definition: {
+    description: "Frozen per-ticket source catalog the diarist selects from",
+    type: "string"
+  }
+};
+function validateRecordedDiaristOutput(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Diarist output has no execution discriminator");
+  }
+  let status;
+  try {
+    status = value.status;
+  } catch {
+    throw new Error("Diarist output has no execution discriminator");
+  }
+  if (status === "completed") {
+    return value;
+  }
+  throw new Error("Diarist output has no execution discriminator");
+}
+function projectDiaristSelections(value) {
+  const rows = value?.selections;
+  if (!Array.isArray(rows)) return [];
+  const out = [];
+  for (const row of rows) {
+    if (row === null || typeof row !== "object" || Array.isArray(row)) continue;
+    const record4 = row;
+    const index = record4.candidateIndex;
+    if (typeof index !== "number" || !Number.isInteger(index) || index < 0) continue;
+    const quotes = Array.isArray(record4.quotes) ? record4.quotes.filter((q) => typeof q === "string" && q.length > 0) : [];
+    out.push({
+      candidateIndex: index,
+      quotes,
+      ...typeof record4.note === "string" ? { note: record4.note } : {}
+    });
+  }
+  return out;
+}
+
 // src/packaged-role-registry.ts
 var NOTARY_SESSION_MATERIALS = [
   "CLAUDE.md",
@@ -3041,6 +3084,22 @@ var PUBLIC_ROLE_RECORDS = [
     phaseFlag: void 0,
     activationStage: "load-and-install",
     sessionMaterials: ["CLAUDE.md", "souls/navigator.md"]
+  },
+  // #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).
+  {
+    role: "diarist",
+    phases: [null],
+    outputTool: DIARIST_OUTPUT_TOOL_NAME,
+    inputFlag: DIARIST_SOURCES_FLAG.name,
+    phaseFlag: void 0,
+    activationStage: "load-and-install",
+    sessionMaterials: [
+      "CLAUDE.md",
+      "souls/diarist.md",
+      "resources/diarist-collect.md"
+    ]
   }
 ];
 var PACKAGED_ROLE_REGISTRY = PUBLIC_ROLE_RECORDS.map(({ sessionMaterials: _omit, ...metadata }) => metadata);
@@ -3696,6 +3755,29 @@ function appendEngineSessionMaterial(lines, engineMaterial) {
   return out;
 }
 
+// src/host-descriptions.ts
+var PRIVATE_COMPAT_ENV = Object.fromEntries(
+  ["CLAUDE", "CURSOR", "CODEX"].flatMap((vendor) => ["SKILLS", "RULES", "AGENTS", "MCPS", "HOOKS", "SESSIONS"].map((kind) => [`GROK_${vendor}_${kind}_ENABLED`, "false"]))
+);
+var HOST_DESCRIPTIONS = Object.freeze({
+  /** Operator home `~/.grok`, native session/load resume, `agent [--model X] stdio`. */
+  "grok-build": Object.freeze({
+    binaryFromHome: Object.freeze([".grok", "bin", "grok"]),
+    argv: Object.freeze({
+      prefix: Object.freeze(["agent"]),
+      suffix: Object.freeze(["stdio"]),
+      modelFlag: "--model"
+    }),
+    boundResume: "session/load",
+    sessionBindingFile: "grok-acp-session.json",
+    childEnv: Object.freeze({
+      ...PRIVATE_COMPAT_ENV,
+      GROK_MEMORY: "0",
+      GROK_SUBAGENTS: "0"
+    })
+  })
+});
+
 // src/institutional-resolution.ts
 import { readFile as readFile4, writeFile as writeFile2 } from "node:fs/promises";
 import { join as join7 } from "node:path";
@@ -5166,7 +5248,8 @@ var TERMINATING_TOOL_NAMES = [
   GLEANER_LEFT_OUTPUT_TOOL_NAME,
   INSPECTOR_OUTPUT_TOOL_NAME,
   GATEKEEPER_OUTPUT_TOOL_NAME,
-  NAVIGATOR_OUTPUT_TOOL_NAME
+  NAVIGATOR_OUTPUT_TOOL_NAME,
+  DIARIST_OUTPUT_TOOL_NAME
 ];
 function isTerminatingToolName(name) {
   return TERMINATING_TOOL_NAMES.includes(name);
@@ -5212,7 +5295,8 @@ function validateAcceptedDetails(toolName, details) {
     [GLEANER_LEFT_OUTPUT_TOOL_NAME]: ["completed"],
     [INSPECTOR_OUTPUT_TOOL_NAME]: ["pass", "bounce"],
     [GATEKEEPER_OUTPUT_TOOL_NAME]: ["dispatch", "pass"],
-    [NAVIGATOR_OUTPUT_TOOL_NAME]: ["advice"]
+    [NAVIGATOR_OUTPUT_TOOL_NAME]: ["advice"],
+    [DIARIST_OUTPUT_TOOL_NAME]: ["completed"]
   };
   const collectorDiscriminator = toolName === COLLECTOR_OUTPUT_TOOL && Array.isArray(candidate?.groups);
   const baseDiscriminator = discriminator;
@@ -5248,6 +5332,8 @@ function validateAcceptedDetails(toolName, details) {
         return validateRecordedGatekeeperOutput(details);
       case NAVIGATOR_OUTPUT_TOOL_NAME:
         return validateRecordedNavigatorOutput(details);
+      case DIARIST_OUTPUT_TOOL_NAME:
+        return validateRecordedDiaristOutput(details);
     }
   } catch (error) {
     if (error instanceof Error && error.constructor === Error) throw new AcceptedDetailsContractError(error.message, { cause: error });
@@ -5265,6 +5351,7 @@ function acceptedFacts(toolName, details) {
     case INSPECTOR_OUTPUT_TOOL_NAME:
     case GATEKEEPER_OUTPUT_TOOL_NAME:
     case NAVIGATOR_OUTPUT_TOOL_NAME:
+    case DIARIST_OUTPUT_TOOL_NAME:
       return { status: details.status };
     case JUDGE_OUTPUT_TOOL_NAME:
       return { status: details.judgeStatus };
@@ -6571,6 +6658,10 @@ var COUNTERSIGN_OPTIONS = [
   bindOwner("countersign", SHARED_PROJECT_SEMANTICS),
   bindOwner("countersign", SHARED_ATTACH_SEMANTICS)
 ];
+var DIARIST_OPTIONS = [
+  bindOwner("diarist", SHARED_PROJECT_SEMANTICS),
+  bindOwner("diarist", SHARED_ATTACH_SEMANTICS)
+];
 var CODER_OPTIONS = [
   {
     id: "phase",
@@ -6885,6 +6976,15 @@ var ROLE_COMMAND_HELP = {
       'ak-role navigator "\u521A\u5B8C\u6210 coder apply \u6536\u655B\uFF0C\u4E0B\u4E00\u6B65\uFF1F"'
     ]
   },
+  diarist: {
+    command: "diarist",
+    summary: "Direct Diarist (\u8D77\u5C45\u90CE) pass: gather and organize this case's decision basis into its \u8D77\u5C45\u5F55.",
+    usage: ["ak-role diarist [options] [instruction]"],
+    examples: [
+      'ak-role diarist "\u6574\u7406 #708 \u7684\u672C\u6848\u4F9D\u636E\u3002"',
+      'ak-role diarist --attach ./design.md "\u8865\u5F55\u672C\u8F6E\u8BBE\u8BA1\u4FEE\u8BA2\u3002"'
+    ]
+  },
   notary: {
     command: "notary",
     summary: "Direct Notary document check (quote fidelity + ticket alignment); zero prompt/attachment.",
@@ -7053,7 +7153,7 @@ async function readRoleRunStateDisk(runDirectory) {
   if (typeof record4.runId !== "string" || record4.runId.trim() === "") {
     return void 0;
   }
-  if (record4.role !== "judge" && record4.role !== "coder" && record4.role !== "fixer" && record4.role !== "collector" && record4.role !== "doctor" && record4.role !== "reviewer" && record4.role !== "merger" && record4.role !== "notary" && record4.role !== "countersign" && record4.role !== "gleaner-left" && record4.role !== "inspector" && record4.role !== "gatekeeper" && record4.role !== "navigator") {
+  if (record4.role !== "judge" && record4.role !== "coder" && record4.role !== "fixer" && record4.role !== "collector" && record4.role !== "doctor" && record4.role !== "reviewer" && record4.role !== "merger" && record4.role !== "notary" && record4.role !== "countersign" && record4.role !== "gleaner-left" && record4.role !== "inspector" && record4.role !== "gatekeeper" && record4.role !== "navigator" && record4.role !== "diarist") {
     return void 0;
   }
   if (record4.state !== "admitted" && record4.state !== "running" && record4.state !== "resumable" && record4.state !== "terminal") {
@@ -11275,6 +11375,561 @@ var INSPECTOR_TOOL_SPEC = {
   parameters: inspectorOutputSchema
 };
 
+// src/diarist-role.ts
+import { Type as Type23 } from "typebox";
+var diaristOutputSchema = withInfrastructureFailureDeclaration(
+  openToolObject(
+    Type23.Object({
+      status: Type23.Unknown({
+        description: "completed \u2014 \u5F62\u72B6\u6307\u5F15\uFF0C\u975E schema \u95F8"
+      }),
+      selections: Type23.Array(
+        Type23.Object(
+          {
+            candidateIndex: Type23.Number({ description: "\u5019\u9009\u76EE\u5F55\u4E2D\u7684\u6574\u5757\u5E8F\u53F7" }),
+            quotes: Type23.Array(Type23.String(), {
+              description: "\u8BE5\u5757 transcript \u5185\u7684\u8FDE\u7EED\u539F\u6587\uFF1B\u673A\u68B0\u53CD\u9A8C"
+            }),
+            note: Type23.Optional(
+              Type23.String({ description: "\u8BE5\u6750\u6599\u4E0E\u672C\u6848\u7684\u5173\u7CFB\uFF08\u4EBA\u8BFB\uFF09" })
+            )
+          },
+          { additionalProperties: true, description: "\u4E00\u6761\u5165\u5F55\u9009\u62E9" }
+        ),
+        { description: "\u5165\u5F55\u9009\u62E9\uFF1B\u7A7A\u5217\u8868\u5408\u6CD5\u5B8C\u5C40" }
+      )
+    })
+  )
+);
+var DIARIST_TOOL_SPEC = {
+  name: DIARIST_OUTPUT_TOOL_NAME,
+  label: "\u8D77\u5C45\u90CE\u8F93\u51FA",
+  description: "\u8D77\u5C45\u90CE\u5165\u5F55\u9009\u62E9\u3002",
+  promptSnippet: "\u8D77\u5C45\u90CE\u5165\u5F55\u9009\u62E9",
+  parameters: diaristOutputSchema
+};
+
+// src/diarist.ts
+import { readFileSync as readFileSync4 } from "node:fs";
+
+// src/diarist-mechanical.ts
+init_activation_ledger_topology();
+var DEFAULT_QUOTE_MIN = 6;
+function extractCornerQuotes(text, minLength = DEFAULT_QUOTE_MIN) {
+  const out = [];
+  const re = /「([^」]+)」/g;
+  let match;
+  while ((match = re.exec(text)) !== null) {
+    const q = match[1].trim();
+    if (q.length >= minLength) out.push(q);
+  }
+  return out;
+}
+function buildDiaristAnchors(input) {
+  const fromBody = input.ticketBody === void 0 ? [] : extractCornerQuotes(input.ticketBody);
+  const quotes = [...fromBody, ...input.extraQuotes ?? []];
+  const seen = /* @__PURE__ */ new Set();
+  const uniqueQuotes = [];
+  for (const q of quotes) {
+    if (seen.has(q)) continue;
+    seen.add(q);
+    uniqueQuotes.push(q);
+  }
+  return {
+    ticketNumber: input.ticketNumber,
+    quotes: uniqueQuotes
+  };
+}
+function verifyQuotesVerbatim(sourceText, quotes) {
+  const failed2 = [];
+  for (const q of quotes) {
+    if (q.length === 0) continue;
+    if (!sourceText.includes(q)) failed2.push(q);
+  }
+  if (failed2.length === 0) return { ok: true };
+  return { ok: false, failedQuotes: failed2 };
+}
+function blockToLlmEntry(block, input) {
+  const verify = verifyQuotesVerbatim(block.transcript, input.quotes);
+  if (!verify.ok) {
+    return {
+      ok: false,
+      failedQuotes: verify.failedQuotes,
+      cause: `verbatim verify failed: ${verify.failedQuotes.join(" | ")}`
+    };
+  }
+  const anchorNotes = [`#${input.anchors.ticketNumber}`];
+  const seen = new Set(anchorNotes);
+  for (const q of [...input.anchors.quotes, ...input.quotes]) {
+    if (seen.has(q)) continue;
+    seen.add(q);
+    anchorNotes.push(q);
+    if (anchorNotes.length >= 12) break;
+  }
+  return {
+    ok: true,
+    entry: {
+      basis: {
+        method: "llm-semantic",
+        anchors: anchorNotes,
+        ...input.note === void 0 ? {} : { note: input.note }
+      },
+      sourceKind: block.sourceKind,
+      sourceRef: block.sourceRef,
+      transcript: block.transcript,
+      timestamp: block.timestamp
+    }
+  };
+}
+
+// src/ticket-provenance.ts
+import { createHash as createHash9 } from "node:crypto";
+import { appendFileSync as appendFileSync2, existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync6 } from "node:fs";
+import { join as join22 } from "node:path";
+
+// src/ticket-provenance-contracts.ts
+var TICKET_PROVENANCE_KIND = "ticket-provenance";
+var TICKET_PROVENANCE_HUMAN_VIEW = "\u8D77\u5C45\u5F55.md";
+var TICKET_PROVENANCE_OFFERED_WATERMARK = "offered-identities.jsonl";
+var TICKET_PROVENANCE_RECORD_CLASS_DIAGNOSTIC = "diagnostic";
+function isRecord13(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var SOURCE_KINDS = /* @__PURE__ */ new Set([
+  "cc-session",
+  "issue-body-comment",
+  "adr-decision-key",
+  "ticket-decree-block"
+]);
+var BASIS_METHODS = /* @__PURE__ */ new Set(["llm-semantic"]);
+var DIAGNOSTIC_KINDS = /* @__PURE__ */ new Set([
+  "collector-failed",
+  "issue-source-failed",
+  "quote-verify-failed"
+]);
+function projectTicketProvenanceDiagnostic(value) {
+  if (!isRecord13(value)) return void 0;
+  if (value.recordClass !== TICKET_PROVENANCE_RECORD_CLASS_DIAGNOSTIC) {
+    return void 0;
+  }
+  if (typeof value.diagnosticKind !== "string" || !DIAGNOSTIC_KINDS.has(value.diagnosticKind)) {
+    return void 0;
+  }
+  if (typeof value.cause !== "string" || value.cause.length === 0) {
+    return void 0;
+  }
+  if (typeof value.recordedAt !== "string" || value.recordedAt.length === 0) {
+    return void 0;
+  }
+  return {
+    recordClass: TICKET_PROVENANCE_RECORD_CLASS_DIAGNOSTIC,
+    diagnosticKind: value.diagnosticKind,
+    cause: value.cause,
+    recordedAt: value.recordedAt,
+    ...typeof value.reason === "string" ? { reason: value.reason } : {}
+  };
+}
+function projectTicketProvenanceEntry(value) {
+  if (!isRecord13(value)) return void 0;
+  if (value.recordClass === TICKET_PROVENANCE_RECORD_CLASS_DIAGNOSTIC) {
+    return void 0;
+  }
+  if (!isRecord13(value.basis)) return void 0;
+  if (typeof value.basis.method !== "string" || !BASIS_METHODS.has(value.basis.method)) {
+    return void 0;
+  }
+  if (typeof value.sourceKind !== "string" || !SOURCE_KINDS.has(value.sourceKind)) {
+    return void 0;
+  }
+  if (!isRecord13(value.sourceRef)) return void 0;
+  if (typeof value.transcript !== "string" || value.transcript.length === 0) {
+    return void 0;
+  }
+  if (typeof value.timestamp !== "string" || value.timestamp.length === 0) {
+    return void 0;
+  }
+  const basis = {
+    method: value.basis.method,
+    ...Array.isArray(value.basis.anchors) ? {
+      anchors: value.basis.anchors.filter(
+        (item) => typeof item === "string"
+      )
+    } : {},
+    ...typeof value.basis.note === "string" ? { note: value.basis.note } : {}
+  };
+  const sourceRef = {
+    ...typeof value.sourceRef.sessionFile === "string" ? { sessionFile: value.sourceRef.sessionFile } : {},
+    ...typeof value.sourceRef.entryId === "string" || typeof value.sourceRef.entryId === "number" ? { entryId: value.sourceRef.entryId } : {},
+    ...typeof value.sourceRef.path === "string" ? { path: value.sourceRef.path } : {},
+    ...typeof value.sourceRef.url === "string" ? { url: value.sourceRef.url } : {}
+  };
+  return {
+    basis,
+    sourceKind: value.sourceKind,
+    sourceRef,
+    transcript: value.transcript,
+    timestamp: value.timestamp
+  };
+}
+
+// src/ticket-provenance.ts
+function ticketProvenanceSubject(ticketNumber) {
+  if (!Number.isSafeInteger(ticketNumber) || ticketNumber < 1) {
+    throw new Error(`ticket-provenance subject requires a positive ticket number, got ${String(ticketNumber)}`);
+  }
+  return String(ticketNumber);
+}
+function ticketProvenanceEntryIdentity(input) {
+  const ref = input.sourceRef;
+  const refKey = [
+    ref.sessionFile ?? "",
+    ref.entryId === void 0 ? "" : String(ref.entryId),
+    ref.path ?? "",
+    ref.url ?? ""
+  ].join("
");
+  const material = [
+    String(input.ticketNumber),
+    input.sourceKind,
+    refKey,
+    input.transcript
+  ].join("\0");
+  return createHash9("sha256").update(material, "utf8").digest("hex");
+}
+function appendTicketProvenanceEntry(input) {
+  const subject = ticketProvenanceSubject(input.ticketNumber);
+  const identity = ticketProvenanceEntryIdentity({
+    ticketNumber: input.ticketNumber,
+    sourceKind: input.entry.sourceKind,
+    sourceRef: input.entry.sourceRef,
+    transcript: input.entry.transcript
+  });
+  return sitianReport({
+    level: "event",
+    kind: TICKET_PROVENANCE_KIND,
+    identity,
+    subject,
+    cwd: input.cwd,
+    ...input.home === void 0 ? {} : { home: input.home },
+    host: input.host ?? "diarist",
+    source: input.source ?? "diarist",
+    payload: input.entry,
+    raw: input.entry.sourceRef.sessionFile !== void 0 && input.entry.sourceRef.entryId !== void 0 ? {
+      sessionFile: input.entry.sourceRef.sessionFile,
+      entryId: input.entry.sourceRef.entryId
+    } : void 0
+  });
+}
+function resolveTicketProvenanceVolume(ticketNumber, cwd, home) {
+  const path = resolveSitianRecordPath({
+    level: "event",
+    kind: TICKET_PROVENANCE_KIND,
+    subject: ticketProvenanceSubject(ticketNumber),
+    cwd,
+    ...home === void 0 ? {} : { home }
+  });
+  return {
+    recordFile: path.recordFile,
+    volumeDir: path.sessionDir,
+    humanViewFile: join22(path.sessionDir, TICKET_PROVENANCE_HUMAN_VIEW),
+    offeredWatermarkFile: join22(path.sessionDir, TICKET_PROVENANCE_OFFERED_WATERMARK)
+  };
+}
+var TicketProvenanceWatermarkError = class extends Error {
+  code = "ticket-provenance-watermark";
+  reason;
+  constructor(reason, message, options) {
+    super(message, options);
+    this.name = "TicketProvenanceWatermarkError";
+    this.reason = reason;
+  }
+};
+function readOfferedIdentities(ticketNumber, cwd, home) {
+  const { offeredWatermarkFile } = resolveTicketProvenanceVolume(ticketNumber, cwd, home);
+  if (!existsSync7(offeredWatermarkFile)) return /* @__PURE__ */ new Set();
+  let text;
+  try {
+    text = readFileSync3(offeredWatermarkFile, "utf8");
+  } catch (error) {
+    throw new TicketProvenanceWatermarkError(
+      "unreadable",
+      `ticket-provenance offered watermark unreadable (${offeredWatermarkFile})`,
+      { cause: error }
+    );
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const lines = text.split("\n");
+  for (let index = 0; index < lines.length; index += 1) {
+    const trimmed = lines[index].trim();
+    if (!trimmed) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch (error) {
+      throw new TicketProvenanceWatermarkError(
+        "malformed-json",
+        `ticket-provenance offered watermark malformed JSON at line ${index + 1} (${offeredWatermarkFile})`,
+        { cause: error }
+      );
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed) || typeof parsed.identity !== "string" || parsed.identity.length === 0) {
+      throw new TicketProvenanceWatermarkError(
+        "bad-shape",
+        `ticket-provenance offered watermark bad shape at line ${index + 1} (${offeredWatermarkFile})`
+      );
+    }
+    seen.add(parsed.identity);
+  }
+  return seen;
+}
+function recordOfferedIdentities(input) {
+  if (input.identities.length === 0) return;
+  const { volumeDir, offeredWatermarkFile } = resolveTicketProvenanceVolume(
+    input.ticketNumber,
+    input.cwd,
+    input.home
+  );
+  const already = new Set(readOfferedIdentities(input.ticketNumber, input.cwd, input.home));
+  const rows = [];
+  for (const identity of input.identities) {
+    if (identity.length === 0 || already.has(identity)) continue;
+    rows.push(`${JSON.stringify({ identity })}
+`);
+    already.add(identity);
+  }
+  if (rows.length === 0) return;
+  mkdirSync3(volumeDir, { recursive: true });
+  appendFileSync2(offeredWatermarkFile, rows.join(""), "utf8");
+}
+async function readTicketProvenance(ticketNumber, cwd, home) {
+  const { recordFile } = resolveTicketProvenanceVolume(ticketNumber, cwd, home);
+  const { records: records2 } = await readSitianRecords(recordFile);
+  const entries = [];
+  const diagnostics = [];
+  let skipped = 0;
+  for (const record4 of records2) {
+    if (record4.kind !== TICKET_PROVENANCE_KIND) {
+      skipped += 1;
+      continue;
+    }
+    const diagnostic = projectTicketProvenanceDiagnostic(record4.payload);
+    if (diagnostic !== void 0) {
+      diagnostics.push(diagnostic);
+      continue;
+    }
+    const entry = projectTicketProvenanceEntry(record4.payload);
+    if (entry === void 0) {
+      skipped += 1;
+      continue;
+    }
+    entries.push(entry);
+  }
+  return { entries, diagnostics, records: records2, recordFile, skipped };
+}
+function markdownFenceFor(text) {
+  let longest = 0;
+  const runs = text.match(/`+/g);
+  if (runs !== null) {
+    for (const run of runs) {
+      if (run.length > longest) longest = run.length;
+    }
+  }
+  return "`".repeat(Math.max(3, longest + 1));
+}
+function renderTicketProvenanceMarkdown(input) {
+  const lines = [
+    `# \u8D77\u5C45\u5F55 \xB7 #${input.ticketNumber}`,
+    "",
+    `\u6761\u76EE\u6570\uFF1A${input.entries.length}`,
+    ""
+  ];
+  let index = 0;
+  for (const entry of input.entries) {
+    index += 1;
+    lines.push(`## ${index}. ${entry.sourceKind} \xB7 ${entry.timestamp}`);
+    lines.push("");
+    lines.push(`- basis.method: \`${entry.basis.method}\``);
+    if (entry.basis.anchors !== void 0 && entry.basis.anchors.length > 0) {
+      lines.push(`- anchors: ${entry.basis.anchors.map((a) => `\`${a}\``).join(", ")}`);
+    }
+    if (entry.basis.note !== void 0) {
+      lines.push(`- note: ${entry.basis.note}`);
+    }
+    const refParts = [];
+    if (entry.sourceRef.sessionFile !== void 0) {
+      refParts.push(`sessionFile=${entry.sourceRef.sessionFile}`);
+    }
+    if (entry.sourceRef.entryId !== void 0) {
+      refParts.push(`entryId=${String(entry.sourceRef.entryId)}`);
+    }
+    if (entry.sourceRef.path !== void 0) {
+      refParts.push(`path=${entry.sourceRef.path}`);
+    }
+    if (entry.sourceRef.url !== void 0) {
+      refParts.push(`url=${entry.sourceRef.url}`);
+    }
+    if (refParts.length > 0) {
+      lines.push(`- sourceRef: ${refParts.join(" \xB7 ")}`);
+    }
+    lines.push("");
+    const fence = markdownFenceFor(entry.transcript);
+    lines.push(fence);
+    lines.push(entry.transcript);
+    lines.push(fence);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function ensureTicketProvenanceVolume(ticketNumber, cwd, home) {
+  const volume = resolveTicketProvenanceVolume(ticketNumber, cwd, home);
+  mkdirSync3(volume.volumeDir, { recursive: true });
+  appendFileSync2(volume.recordFile, "", "utf8");
+  return volume;
+}
+function appendTicketProvenanceDiagnostic(input) {
+  const subject = ticketProvenanceSubject(input.ticketNumber);
+  const identityParts = input.diagnostic.diagnosticKind === "quote-verify-failed" ? [
+    subject,
+    input.diagnostic.recordClass,
+    input.diagnostic.diagnosticKind,
+    input.diagnostic.cause,
+    input.diagnostic.reason ?? ""
+  ] : [
+    subject,
+    input.diagnostic.recordClass,
+    input.diagnostic.diagnosticKind,
+    input.diagnostic.recordedAt,
+    input.diagnostic.cause,
+    input.diagnostic.reason ?? ""
+  ];
+  const identity = createHash9("sha256").update(identityParts.join("\0"), "utf8").digest("hex");
+  return sitianReport({
+    level: "event",
+    kind: TICKET_PROVENANCE_KIND,
+    identity,
+    subject,
+    cwd: input.cwd,
+    ...input.home === void 0 ? {} : { home: input.home },
+    host: input.host ?? "diarist",
+    source: input.source ?? "diarist-diagnostic",
+    payload: input.diagnostic
+  });
+}
+function appendQuoteVerifyFailureDiagnostic(input) {
+  const recordedAt = input.recordedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  return appendTicketProvenanceDiagnostic({
+    ticketNumber: input.ticketNumber,
+    cwd: input.cwd,
+    ...input.home === void 0 ? {} : { home: input.home },
+    source: "diarist-quote-verify",
+    diagnostic: {
+      recordClass: TICKET_PROVENANCE_RECORD_CLASS_DIAGNOSTIC,
+      diagnosticKind: "quote-verify-failed",
+      cause: input.cause,
+      recordedAt
+    }
+  });
+}
+function writeTicketProvenanceHumanView(input) {
+  const volume = ensureTicketProvenanceVolume(input.ticketNumber, input.cwd, input.home);
+  const md = renderTicketProvenanceMarkdown({
+    ticketNumber: input.ticketNumber,
+    entries: input.entries
+  });
+  writeFileSync6(volume.humanViewFile, md, "utf8");
+  return volume.humanViewFile;
+}
+
+// src/diarist.ts
+function blockEntryIdentity(ticketNumber, block) {
+  return ticketProvenanceEntryIdentity({
+    ticketNumber,
+    sourceKind: block.sourceKind,
+    sourceRef: block.sourceRef,
+    transcript: block.transcript
+  });
+}
+function loadDiaristSourceCatalog(path) {
+  const parsed = JSON.parse(readFileSync4(path, "utf8"));
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`diarist source catalog is not an object (${path})`);
+  }
+  const record4 = parsed;
+  if (typeof record4.ticketNumber !== "number" || typeof record4.cwd !== "string") {
+    throw new Error(`diarist source catalog is missing ticket coordinates (${path})`);
+  }
+  if (!Array.isArray(record4.candidates)) {
+    throw new Error(`diarist source catalog is missing candidates (${path})`);
+  }
+  return parsed;
+}
+async function commitDiaristSelections(input) {
+  const { ticketNumber, cwd } = input.catalog;
+  const homeOpt = input.catalog.home === void 0 ? {} : { home: input.catalog.home };
+  const volumePaths = ensureTicketProvenanceVolume(ticketNumber, cwd, input.catalog.home);
+  const anchors = buildDiaristAnchors({ ticketNumber });
+  const before = await readTicketProvenance(ticketNumber, cwd, input.catalog.home);
+  let acceptedRows = 0;
+  let rejectedQuotes = 0;
+  let unknownCandidate = false;
+  for (const selection of input.selections) {
+    const block = input.catalog.candidates[selection.candidateIndex];
+    if (block === void 0) {
+      unknownCandidate = true;
+      continue;
+    }
+    const projected = blockToLlmEntry(block, {
+      anchors,
+      quotes: selection.quotes,
+      ...selection.note === void 0 ? {} : { note: selection.note }
+    });
+    if (!projected.ok) {
+      rejectedQuotes += 1;
+      appendQuoteVerifyFailureDiagnostic({
+        ticketNumber,
+        cwd,
+        ...homeOpt,
+        cause: projected.cause
+      });
+      continue;
+    }
+    appendTicketProvenanceEntry({
+      ticketNumber,
+      cwd,
+      ...homeOpt,
+      entry: projected.entry,
+      source: "diarist"
+    });
+    acceptedRows += 1;
+  }
+  const identities = input.catalog.candidates.map(
+    (block) => blockEntryIdentity(ticketNumber, block)
+  );
+  const alreadyWatermarked = readOfferedIdentities(ticketNumber, cwd, input.catalog.home);
+  const watermarked = identities.filter((identity) => !alreadyWatermarked.has(identity)).length;
+  recordOfferedIdentities({ ticketNumber, cwd, ...homeOpt, identities });
+  const volume = await readTicketProvenance(ticketNumber, cwd, input.catalog.home);
+  const humanViewFile = writeTicketProvenanceHumanView({
+    ticketNumber,
+    cwd,
+    ...homeOpt,
+    entries: volume.entries
+  });
+  return {
+    ticketNumber,
+    offered: input.catalog.candidates.length,
+    appended: volume.entries.length - before.entries.length,
+    rejectedQuotes,
+    watermarked,
+    volumeRecordFile: volumePaths.recordFile,
+    humanViewFile,
+    collectorStatus: input.catalog.candidates.length === 0 ? "skipped-no-fresh" : acceptedRows > 0 ? "ok" : input.selections.length === 0 ? "empty-selection" : "nothing-appended",
+    failureCauses: [
+      ...unknownCandidate ? ["unknown-candidate"] : [],
+      ...rejectedQuotes > 0 ? ["quote-verify-rejected"] : []
+    ]
+  };
+}
+
 // src/navigator-role.ts
 var NAVIGATOR_TOOL_SPEC = {
   name: NAVIGATOR_OUTPUT_TOOL_NAME,
@@ -11326,30 +11981,30 @@ function raceNavigatorGrace(work, graceMs = NAVIGATOR_POST_ROLE_GRACE_MS, sleep
 }
 
 // src/judge-role.ts
-import { Type as Type23 } from "typebox";
+import { Type as Type24 } from "typebox";
 var judgeVerdictSchema = withInfrastructureFailureDeclaration(
-  Type23.Object(
+  Type24.Object(
     {
       judgeStatus: stringEnum(["converged", "continue", "escalate"], { description: "converged | continue | escalate \u2014 \u5F62\u72B6\u6307\u5F15\uFF0C\u975E schema \u95F8" }),
-      fix: Type23.Optional(
-        Type23.Object(
-          { summary: Type23.String({ minLength: 1, description: "continue \u65F6\u7684\u8865\u6551\u6458\u8981" }) },
+      fix: Type24.Optional(
+        Type24.Object(
+          { summary: Type24.String({ minLength: 1, description: "continue \u65F6\u7684\u8865\u6551\u6458\u8981" }) },
           { additionalProperties: false, description: "continue \u65F6\u7684\u8865\u6551\u8BF4\u660E" }
         )
       ),
-      classes: Type23.Optional(Type23.Array(Type23.Object({
-        name: Type23.String({ minLength: 1 }),
-        owner: Type23.String({ minLength: 1 }),
-        boundary: Type23.String({ minLength: 1 }),
-        disposition: Type23.String({ minLength: 1 })
+      classes: Type24.Optional(Type24.Array(Type24.Object({
+        name: Type24.String({ minLength: 1 }),
+        owner: Type24.String({ minLength: 1 }),
+        boundary: Type24.String({ minLength: 1 }),
+        disposition: Type24.String({ minLength: 1 })
       }, { additionalProperties: false }), { minItems: 1, description: "\u5DF2\u88C1\u51B3 finding \u7C7B\u53CA\u5176 owner \u4E0E\u4FEE\u7406\u8FB9\u754C" })),
-      note: Type23.Optional(Type23.String({ minLength: 1, description: "\u53EF\u9009\u88C1\u51B3\u9644\u6CE8" })),
-      evidence: Type23.Optional(Type23.Unknown({ description: "\u7559\u5B58\u7684\u88C1\u51B3\u8BC1\u636E" })),
-      decisionGate: Type23.Optional(
-        Type23.Object(
+      note: Type24.Optional(Type24.String({ minLength: 1, description: "\u53EF\u9009\u88C1\u51B3\u9644\u6CE8" })),
+      evidence: Type24.Optional(Type24.Unknown({ description: "\u7559\u5B58\u7684\u88C1\u51B3\u8BC1\u636E" })),
+      decisionGate: Type24.Optional(
+        Type24.Object(
           {
-            question: Type23.String({ minLength: 1 }),
-            options: Type23.Array(Type23.String({ minLength: 1 }), { minItems: 1 })
+            question: Type24.String({ minLength: 1 }),
+            options: Type24.Array(Type24.String({ minLength: 1 }), { minItems: 1 })
           },
           { additionalProperties: false, description: "\u9700\u4EBA\u6743\u5A01\u5904\u7F6E\u7684\u95EE\u9898\u4E0E\u9009\u9879" }
         )
@@ -11439,7 +12094,7 @@ ${soul}
 }
 
 // src/reviewer-role.ts
-import { Type as Type24 } from "typebox";
+import { Type as Type25 } from "typebox";
 
 // src/reviewer-execution-ledger.ts
 function projectAcceptedDispatch(dispatch) {
@@ -11645,19 +12300,19 @@ function assembleRuntimeReviewerReceipt(input) {
 }
 
 // src/reviewer-role.ts
-var reviewerAmendmentsSchema = Type24.Object({
-  standards: Type24.Optional(Type24.String({ description: "\u76F8\u5BF9 Standards \u5B50\u62A5\u544A\u7684\u589E\u91CF\uFF1A\u589E finding\u3001\u64A4\u56DE\u6216\u4E8B\u5B9E\u66F4\u6B63" })),
-  spec: Type24.Optional(Type24.String({ description: "\u76F8\u5BF9 Spec \u5B50\u62A5\u544A\u7684\u589E\u91CF\uFF1A\u589E finding\u3001\u64A4\u56DE\u6216\u4E8B\u5B9E\u66F4\u6B63" }))
+var reviewerAmendmentsSchema = Type25.Object({
+  standards: Type25.Optional(Type25.String({ description: "\u76F8\u5BF9 Standards \u5B50\u62A5\u544A\u7684\u589E\u91CF\uFF1A\u589E finding\u3001\u64A4\u56DE\u6216\u4E8B\u5B9E\u66F4\u6B63" })),
+  spec: Type25.Optional(Type25.String({ description: "\u76F8\u5BF9 Spec \u5B50\u62A5\u544A\u7684\u589E\u91CF\uFF1A\u589E finding\u3001\u64A4\u56DE\u6216\u4E8B\u5B9E\u66F4\u6B63" }))
 }, { additionalProperties: true, description: "\u76F8\u5BF9\u5B50\u62A5\u544A\u7684\u53EF\u9009\u8F74\u589E\u91CF\uFF1B\u975E\u66FF\u4EE3\u62A5\u544A\u3002\u65E0\u589E\u91CF\u7684\u8F74\u53EF\u7701\u7565\u3002" });
-var reviewerOutputVariants = Type24.Union([
-  Type24.Object({
-    status: Type24.Literal("completed", { description: "completed \u2014 \u5F62\u72B6\u6307\u5F15\uFF0C\u975E schema \u95F8" }),
-    amendments: Type24.Optional(reviewerAmendmentsSchema)
+var reviewerOutputVariants = Type25.Union([
+  Type25.Object({
+    status: Type25.Literal("completed", { description: "completed \u2014 \u5F62\u72B6\u6307\u5F15\uFF0C\u975E schema \u95F8" }),
+    amendments: Type25.Optional(reviewerAmendmentsSchema)
   }, { additionalProperties: false }),
-  Type24.Object({
-    status: Type24.Literal("refused", { description: "refused \u2014 \u5F62\u72B6\u6307\u5F15\uFF0C\u975E schema \u95F8" }),
-    diagnostic: Type24.String({ minLength: 1, description: "\u62D2\u7EDD\u8BCA\u65AD\u8BF4\u660E" }),
-    amendments: Type24.Optional(reviewerAmendmentsSchema)
+  Type25.Object({
+    status: Type25.Literal("refused", { description: "refused \u2014 \u5F62\u72B6\u6307\u5F15\uFF0C\u975E schema \u95F8" }),
+    diagnostic: Type25.String({ minLength: 1, description: "\u62D2\u7EDD\u8BCA\u65AD\u8BF4\u660E" }),
+    amendments: Type25.Optional(reviewerAmendmentsSchema)
   }, { additionalProperties: false })
 ]);
 var reviewerOutputSchema = withInfrastructureFailureDeclaration(
@@ -11785,12 +12440,12 @@ function createReviewerRoleRuntime(pi, dependencies, hostActions) {
 }
 
 // src/worker-role.ts
-import { Type as Type25 } from "typebox";
+import { Type as Type26 } from "typebox";
 
 // src/worker-submission-gates.ts
 init_archivist_record_entry();
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { existsSync as existsSync7, lstatSync as lstatSync3, readdirSync as readdirSync2, readFileSync as readFileSync3, rmdirSync, rmSync } from "node:fs";
+import { existsSync as existsSync8, lstatSync as lstatSync3, readdirSync as readdirSync2, readFileSync as readFileSync5, rmdirSync, rmSync } from "node:fs";
 import { resolve as resolve16 } from "node:path";
 var WORKER_SUBMISSION_GATE_RECORD_KIND = WORKER_SUBMISSION_GATE_KIND;
 var WORKER_COMMIT_BASELINE_ENTRY_TYPE = "commit-baseline";
@@ -11821,7 +12476,7 @@ function statusOf(error) {
   return typeof error === "object" && error !== null && "status" in error ? error.status : void 0;
 }
 function tryGetAll(file, key) {
-  if (!existsSync7(file)) return [];
+  if (!existsSync8(file)) return [];
   try {
     const out = gitFile(file, ["--get-all", key]);
     return out.length === 0 ? [] : out.split("\n");
@@ -11831,8 +12486,8 @@ function tryGetAll(file, key) {
   }
 }
 function ownedHook(path) {
-  if (!existsSync7(path)) return false;
-  return readFileSync3(path, "utf8").includes(HOOK_MARKER);
+  if (!existsSync8(path)) return false;
+  return readFileSync5(path, "utf8").includes(HOOK_MARKER);
 }
 function escapeGitConfigValueRegex(value) {
   return value.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
@@ -11858,11 +12513,11 @@ function rmOwnedDir(dir) {
   const hookPath = resolve16(dir, HOOK_FILE);
   if (!ownedHook(hookPath)) return;
   rmSync(hookPath, { force: true });
-  if (existsSync7(dir) && readdirSync2(dir).length === 0) rmdirSync(dir);
+  if (existsSync8(dir) && readdirSync2(dir).length === 0) rmdirSync(dir);
 }
 function linkedGitDirs(commonDir) {
   const root = resolve16(commonDir, "worktrees");
-  if (!existsSync7(root)) return [];
+  if (!existsSync8(root)) return [];
   return readdirSync2(root).map((name) => resolve16(root, name)).filter((dir) => lstatSync3(dir).isDirectory());
 }
 function uninstallPackageWorkerHooks(cwd) {
@@ -11887,7 +12542,7 @@ function uninstallPackageWorkerHooks(cwd) {
     rmOwnedDir(resolve16(gitDir, HOOKS_DIR));
   }
 }
-function isRecord13(value) {
+function isRecord14(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function unfinishedReasonPresent(details) {
@@ -11903,7 +12558,7 @@ function readGateState(session) {
     if (entry.type !== "custom") continue;
     if (entry.customType === WORKER_COMMIT_BASELINE_ENTRY_TYPE) {
       const data = entry.data;
-      if (isRecord13(data) && (data.head === null || typeof data.head === "string")) {
+      if (isRecord14(data) && (data.head === null || typeof data.head === "string")) {
         baseline = data.head;
       }
     } else if (entry.customType === WORKER_COMMIT_REMINDER_BOUNCE_ENTRY_TYPE) {
@@ -12046,24 +12701,24 @@ function fixerBashSeatbeltDenyReason(matched) {
 }
 
 // src/worker-role.ts
-var coderOutputVariants = Type25.Union([
-  Type25.Object({
+var coderOutputVariants = Type26.Union([
+  Type26.Object({
     status: stringEnum(["planned"], { description: "planned \u2014 \u5F62\u72B6\u6307\u5F15\uFF0C\u975E schema \u95F8" }),
-    report: Type25.String({ minLength: 1, description: "\u5982\u5B9E\u7ED3\u679C\u62A5\u544A" })
+    report: Type26.String({ minLength: 1, description: "\u5982\u5B9E\u7ED3\u679C\u62A5\u544A" })
   }, { additionalProperties: false }),
-  Type25.Object({
+  Type26.Object({
     status: stringEnum(["completed", "refused"], {
       description: "completed | refused \u2014 \u5F62\u72B6\u6307\u5F15\uFF0C\u975E schema \u95F8\uFF1Bcompleted \u56DE\u6267\u542B TDD\u3001\u540C\u6A21\u5F0F\u3001\u5F15\u5165\u56DE\u5F52\u3001\u884C\u4E3A\u4E8B\u5B9E\u56DB\u9879\u8BC1\u636E"
     }),
-    report: Type25.String({ minLength: 1, description: "\u5982\u5B9E\u7ED3\u679C\u62A5\u544A" })
+    report: Type26.String({ minLength: 1, description: "\u5982\u5B9E\u7ED3\u679C\u62A5\u544A" })
   }, { additionalProperties: false }),
-  Type25.Object({
+  Type26.Object({
     status: stringEnum(["unfinished"], {
       description: "unfinished \u2014 \u5F62\u72B6\u6307\u5F15\uFF0C\u975E schema \u95F8\uFF1B\u7F3A\u524D\u7F6E\u6216\u8FDD\u5BAA\u7EA6\u675F\u81F4\u672C\u5C40\u672A\u5B8C\u6210\u65F6\u53EF\u7528\u3002\u7F3A\u5F85\u51B3 owner \u51B3\u5B9A\u6216\u7B54\u590D\u5C5E\u7F3A\u524D\u7F6E\u3002"
     }),
-    report: Type25.String({ minLength: 1, description: "\u5982\u5B9E\u7ED3\u679C\u62A5\u544A" }),
-    remainingScope: Type25.String({ minLength: 1, description: "\u672C\u5C40\u540E\u5269\u4F59\u5DE5\u4F5C" }),
-    reason: Type25.Optional(Type25.String({
+    report: Type26.String({ minLength: 1, description: "\u5982\u5B9E\u7ED3\u679C\u62A5\u544A" }),
+    remainingScope: Type26.String({ minLength: 1, description: "\u672C\u5C40\u540E\u5269\u4F59\u5DE5\u4F5C" }),
+    reason: Type26.Optional(Type26.String({
       minLength: 1,
       description: "\u963B\u65AD\u539F\u56E0\uFF1A\u7F3A\u524D\u7F6E\u6216\u8FDD\u5BAA\u7EA6\u675F\u3002\u7F3A\u5F85\u51B3 owner \u51B3\u5B9A\u6216\u7B54\u590D\u5C5E\u7F3A\u524D\u7F6E\u3002"
     }))
@@ -12534,6 +13189,12 @@ var GLEANER_LEFT_TRANSPORT_FLAGS = Object.freeze([
     definition: GLEANER_LEFT_BASE_FLAG.definition
   })
 ]);
+var DIARIST_TRANSPORT_FLAGS = Object.freeze([
+  Object.freeze({
+    name: DIARIST_SOURCES_FLAG.name,
+    definition: DIARIST_SOURCES_FLAG.definition
+  })
+]);
 function decodeReviewerAdmittedInputs(getFlag) {
   let reviewScopeKeys;
   const rawScopeKeys = getFlag("ak-review-scope-keys");
@@ -12651,6 +13312,8 @@ function activationStage(role, runtime) {
       return { id: "load-and-install", run: async () => runtime.gatekeeper.activate() };
     case "navigator":
       return { id: "load-and-install", run: async () => runtime.navigator.activate() };
+    case "diarist":
+      return { id: "load-and-install", run: async () => runtime.diarist.activate() };
     case "merger":
       return { id: "prepare-git-and-install", run: async () => runtime.merger() };
   }
@@ -12788,12 +13451,10 @@ function createFiledOfficerRuntime(roleHost, spec, dependencies) {
           parameters: spec.tool.parameters,
           async execute(toolCallId, parameters, signal, _onUpdate, ctx) {
             if (soul === void 0) throw new Error(`${spec.role} \u804C\u5206\u672A\u88C5\u8F7D`);
-            if (spec.beforeAccept !== void 0) {
-              await spec.beforeAccept({ toolCallId, parameters, signal, ctx });
-            }
+            const projected = spec.beforeAccept === void 0 ? void 0 : await spec.beforeAccept({ toolCallId, parameters, signal, ctx });
             return {
               content: [{ type: "text", text: spec.acceptedText }],
-              details: parameters,
+              details: projected === void 0 ? parameters : projected,
               terminate: true
             };
           }
@@ -12870,6 +13531,47 @@ function createNavigatorRoleRuntime(roleHost, dependencies) {
     dependencies
   );
 }
+function createDiaristRoleRuntime(roleHost, dependencies, getSourcesFlag) {
+  let catalog;
+  const runtime = createFiledOfficerRuntime(
+    roleHost,
+    {
+      role: "diarist",
+      tool: DIARIST_TOOL_SPEC,
+      acceptedText: DIARIST_ACCEPTED_TEXT,
+      soulTag: "diarist",
+      beforeAccept: async ({ parameters }) => {
+        const submitted = parameters !== null && typeof parameters === "object" && !Array.isArray(parameters) ? parameters : void 0;
+        if (catalog === void 0) {
+          if (submitted === void 0 || !("sitian" in submitted)) return void 0;
+          const stripped = { ...submitted };
+          delete stripped.sitian;
+          return stripped;
+        }
+        const facts = await commitDiaristSelections({
+          catalog,
+          selections: projectDiaristSelections(parameters)
+        });
+        return { ...submitted ?? { receipt: parameters }, sitian: facts };
+      }
+    },
+    dependencies
+  );
+  return {
+    async activate() {
+      catalog = loadFrozenDiaristCatalog(getSourcesFlag);
+      return runtime.activate();
+    }
+  };
+}
+function loadFrozenDiaristCatalog(getFlag) {
+  const raw = getFlag();
+  if (raw === void 0) return void 0;
+  if (typeof raw !== "string" || raw.trim() === "") {
+    throw new Error("Diarist source catalog flag must be a nonempty path");
+  }
+  return loadDiaristSourceCatalog(raw);
+}
 function createCountersignRoleRuntime(roleHost, dependencies, hostActions) {
   const beforeAccept = hostActions !== void 0 && roleHost.requireGatekeeperPass !== void 0 ? async ({ toolCallId, signal, ctx }) => {
     await roleHost.requireGatekeeperPass({
@@ -12913,6 +13615,9 @@ function createRoleRuntimeExtension(dependencies) {
     for (const flag of GLEANER_LEFT_TRANSPORT_FLAGS) {
       roleHost.registerFlag(flag.name, flag.definition);
     }
+    for (const flag of DIARIST_TRANSPORT_FLAGS) {
+      roleHost.registerFlag(flag.name, flag.definition);
+    }
     let admitted = false;
     let selectedRole;
     let activeReviewerParent;
@@ -13303,6 +14008,16 @@ function createRoleRuntimeExtension(dependencies) {
         return dependencies.loadNavigatorSoul();
       }
     });
+    const diarist = createDiaristRoleRuntime(
+      roleHost,
+      {
+        async loadSoul() {
+          if (!dependencies.loadDiaristSoul) throw new Error("Diarist runtime dependencies are not configured");
+          return dependencies.loadDiaristSoul();
+        }
+      },
+      () => envelopeHost.host.getFlag(DIARIST_SOURCES_FLAG.name)
+    );
     let sessionMergerGitState = dependencies.mergerGitState;
     const merger = createMergerRoleRuntime(roleHost, {
       async loadSoul() {
@@ -13455,6 +14170,7 @@ function createRoleRuntimeExtension(dependencies) {
         inspector,
         gatekeeper,
         navigator,
+        diarist,
         merger: async () => {
           if (dependencies.mergerGitState === void 0) {
             sessionMergerGitState = dependencies.createMergerGitState?.(ctx.cwd);
@@ -13564,14 +14280,30 @@ function createRoleRuntimeExtension(dependencies) {
   };
 }
 
-// src/grok/role-envelope.ts
+// src/acp-host/description.ts
+import { join as join23 } from "node:path";
+function resolveAcpBinary(description, operatorHome) {
+  return join23(operatorHome, ...description.binaryFromHome);
+}
+function acpStdioArgs(description, model) {
+  const { prefix, suffix, modelFlag, thinkingFlag } = description.argv;
+  const pair = (flag, value) => flag === void 0 || value === void 0 ? [] : [flag, value];
+  return [
+    ...prefix,
+    ...pair(modelFlag, model?.model),
+    ...pair(thinkingFlag, model?.thinking),
+    ...suffix
+  ];
+}
+
+// src/acp-host/role-envelope.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { mkdir as mkdir3, readFile as readFile13, writeFile as writeFile7 } from "node:fs/promises";
 import { createServer } from "node:net";
-import { basename as basename7, dirname as dirname15, join as join22 } from "node:path";
+import { basename as basename7, dirname as dirname15, join as join24 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
-// src/grok/role-turn-host.ts
+// src/acp-host/role-turn-host.ts
 import { spawn as spawn4 } from "node:child_process";
 import { createInterface } from "node:readline";
 
@@ -13581,8 +14313,8 @@ function renderAgentStartMaterials(body, materials) {
   return [body, ...materials.map((material) => JSON.stringify(material))].join("\n\n");
 }
 
-// src/grok/role-turn-host.ts
-function renderGrokSystemPromptOverride(authority) {
+// src/acp-host/role-turn-host.ts
+function renderAcpSystemPromptOverride(authority) {
   return renderAgentStartMaterials(authority.body, authority.materials);
 }
 function failure(cause, name, code, details) {
@@ -13598,19 +14330,13 @@ function failure(cause, name, code, details) {
   };
 }
 function hostAbortedError() {
-  return Object.assign(new Error("Grok host aborted"), { code: "host-aborted" });
+  return Object.assign(new Error("ACP host aborted"), { code: "host-aborted" });
 }
 function acpError(code, message, cause) {
   return Object.assign(new Error(message, cause === void 0 ? void 0 : { cause }), { code });
 }
-function connectGrokAcpStdio(options) {
-  const args = [
-    "agent",
-    ...options.model === void 0 ? [] : ["--model", options.model],
-    "stdio"
-  ];
-  const env = options.toolset === void 0 ? options.env : { ...options.env, GROK_CONFIG: JSON.stringify({ toolset: options.toolset }) };
-  const child = spawn4(options.binary, args, { cwd: options.cwd, env, stdio: ["pipe", "pipe", "pipe"] });
+function connectAcpStdio(options) {
+  const child = spawn4(options.binary, [...options.args], { cwd: options.cwd, env: options.env, stdio: ["pipe", "pipe", "pipe"] });
   const pending = /* @__PURE__ */ new Map();
   const notificationHandlers = [];
   if (options.onNotification !== void 0) notificationHandlers.push(options.onNotification);
@@ -13633,13 +14359,13 @@ function connectGrokAcpStdio(options) {
   child.stderr.setEncoding("utf8").on("data", (chunk) => {
     stderr += chunk;
   });
-  child.on("error", (error) => settleClosed(acpError("acp-process-error", `Grok ACP process error: ${error.message}`, error)));
+  child.on("error", (error) => settleClosed(acpError("acp-process-error", `ACP process error: ${error.message}`, error)));
   createInterface({ input: child.stdout }).on("line", (line2) => {
     let message;
     try {
       message = JSON.parse(line2);
     } catch (error) {
-      terminate(acpError("acp-invalid-json", `Invalid Grok ACP JSON: ${String(error)}`, error));
+      terminate(acpError("acp-invalid-json", `Invalid ACP JSON: ${String(error)}`, error));
       return;
     }
     if (typeof message.method === "string") {
@@ -13647,13 +14373,13 @@ function connectGrokAcpStdio(options) {
       for (const handler of notificationHandlers) handler(message.method, params);
       if (typeof message.id === "number") {
         if (message.method !== "session/request_permission") {
-          terminate(acpError("acp-unsupported-client-request", `Unsupported Grok ACP client request: ${message.method}`));
+          terminate(acpError("acp-unsupported-client-request", `Unsupported ACP client request: ${message.method}`));
           return;
         }
         const choices = Array.isArray(params.options) ? params.options : [];
         const selected = choices.find((value) => typeof value === "object" && value !== null && value.kind === "allow_once");
         if (typeof selected?.optionId !== "string") {
-          terminate(acpError("acp-permission-missing-allow-once", "Grok ACP permission request omitted allow_once"));
+          terminate(acpError("acp-permission-missing-allow-once", "ACP permission request omitted allow_once"));
           return;
         }
         child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id: message.id, result: { outcome: { outcome: "selected", optionId: selected.optionId } } })}
@@ -13665,13 +14391,13 @@ function connectGrokAcpStdio(options) {
     const waiter = pending.get(message.id);
     if (waiter === void 0) return;
     pending.delete(message.id);
-    if (message.error !== void 0) waiter.reject(acpError("acp-upstream-error", `Grok ACP error: ${JSON.stringify(message.error)}`));
+    if (message.error !== void 0) waiter.reject(acpError("acp-upstream-error", `ACP error: ${JSON.stringify(message.error)}`));
     else waiter.resolve(message.result ?? {});
   });
-  child.on("close", (code) => settleClosed(acpError("acp-closed", `Grok ACP closed (${String(code)}): ${stderr}`)));
+  child.on("close", (code) => settleClosed(acpError("acp-closed", `ACP closed (${String(code)}): ${stderr}`)));
   return Promise.resolve({
     request(method, params) {
-      if (closed) return Promise.reject(terminalError ?? acpError("acp-connection-closed", "Grok ACP connection is closed"));
+      if (closed) return Promise.reject(terminalError ?? acpError("acp-connection-closed", "ACP connection is closed"));
       const id = ++nextId;
       return new Promise((resolve17, reject) => {
         pending.set(id, { resolve: resolve17, reject });
@@ -13681,12 +14407,12 @@ function connectGrokAcpStdio(options) {
           const waiter = pending.get(id);
           if (waiter === void 0) return;
           pending.delete(id);
-          waiter.reject(acpError("acp-write-failed", `Grok ACP write failed: ${error.message}`, error));
+          waiter.reject(acpError("acp-write-failed", `ACP write failed: ${error.message}`, error));
         });
       });
     },
     notify(method, params) {
-      if (closed) throw terminalError ?? acpError("acp-connection-closed", "Grok ACP connection is closed");
+      if (closed) throw terminalError ?? acpError("acp-connection-closed", "ACP connection is closed");
       child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method, params })}
 `);
     },
@@ -13695,14 +14421,14 @@ function connectGrokAcpStdio(options) {
     },
     async close() {
       if (closed) return;
-      settleClosed(acpError("acp-connection-closed", "Grok ACP connection is closed"));
+      settleClosed(acpError("acp-connection-closed", "ACP connection is closed"));
       child.stdin.end();
       child.kill("SIGTERM");
       await new Promise((resolve17) => child.once("close", () => resolve17()));
     }
   });
 }
-function createGrokRoleTurnHost(config) {
+function createAcpRoleTurnHost(config) {
   let serial = Promise.resolve();
   return {
     executeTurn(request) {
@@ -13714,7 +14440,7 @@ function createGrokRoleTurnHost(config) {
         let accepted = false;
         try {
           if (prepared.mcpServers.length === 0) {
-            return failure("activation", "UncontrolledGrokSession", "ak-config-missing");
+            return failure("activation", "UncontrolledAcpSession", "ak-config-missing");
           }
           connection = await config.connect(request);
           const initialized = await connection.request("initialize", {
@@ -13725,49 +14451,36 @@ function createGrokRoleTurnHost(config) {
           const modelState = initializeMeta?.modelState;
           const availableModels = Array.isArray(modelState?.availableModels) ? modelState.availableModels : void 0;
           if (request.model !== void 0 && availableModels !== void 0 && !availableModels.some((entry) => typeof entry === "object" && entry !== null && entry.modelId === request.model?.model)) {
-            return failure("activation", "GrokHostModelMismatch", "host-model-mismatch", {
+            return failure("activation", "AcpHostModelMismatch", "host-model-mismatch", {
               provider: request.model.provider,
               model: request.model.model
             });
           }
-          const priorNativePaths = continuation.kind === "resume" && request.hostTransition?.previousHost === "pi" ? request.hostTransition.priorNativePaths : void 0;
-          if (continuation.kind === "resume") {
+          const priorNativePaths = continuation.kind === "resume" ? request.hostTransition?.priorNativePaths : void 0;
+          if (continuation.kind === "resume" && config.boundResume === "session/load") {
             const boundSessionId = await config.sessionIdentity.load(request.principal);
             if (boundSessionId !== void 0 && boundSessionId !== "") {
               const loaded = await connection.request("session/load", {
                 sessionId: boundSessionId,
                 cwd: request.cwd,
                 mcpServers: prepared.mcpServers,
-                _meta: { systemPromptOverride: renderGrokSystemPromptOverride(prepared.systemPrompt), yoloMode: false }
+                _meta: { systemPromptOverride: renderAcpSystemPromptOverride(prepared.systemPrompt), yoloMode: false }
               });
               sessionId = typeof loaded.sessionId === "string" && loaded.sessionId !== "" ? loaded.sessionId : boundSessionId;
-            } else {
-              const session = await connection.request(
-                "session/new",
-                {
-                  cwd: request.cwd,
-                  mcpServers: prepared.mcpServers,
-                  _meta: { systemPromptOverride: renderGrokSystemPromptOverride(prepared.systemPrompt), yoloMode: false }
-                }
-              );
-              sessionId = typeof session.sessionId === "string" ? session.sessionId : void 0;
-              if (sessionId === void 0 || sessionId === "") {
-                return failure("session", "GrokAcpSessionFailure", "session-id-missing");
-              }
-              await config.sessionIdentity.bind(request.principal, sessionId);
             }
-          } else {
+          }
+          if (sessionId === void 0) {
             const session = await connection.request(
               "session/new",
               {
                 cwd: request.cwd,
                 mcpServers: prepared.mcpServers,
-                _meta: { systemPromptOverride: renderGrokSystemPromptOverride(prepared.systemPrompt), yoloMode: false }
+                _meta: { systemPromptOverride: renderAcpSystemPromptOverride(prepared.systemPrompt), yoloMode: false }
               }
             );
             sessionId = typeof session.sessionId === "string" ? session.sessionId : void 0;
             if (sessionId === void 0 || sessionId === "") {
-              return failure("session", "GrokAcpSessionFailure", "session-id-missing");
+              return failure("session", "AcpSessionFailure", "session-id-missing");
             }
             await config.sessionIdentity.bind(request.principal, sessionId);
           }
@@ -13828,7 +14541,7 @@ ${priorNativePaths.join("\n")}` : prepared.prompt;
               throw error;
             }
             if (result2.stopReason === "refusal") {
-              return failure("output", "GrokAcpRefusal", "refusal", { sessionId });
+              return failure("output", "AcpRefusal", "refusal", { sessionId });
             }
             const closure = await prepared.closeRound();
             if (closure.accepted) {
@@ -13841,7 +14554,7 @@ ${priorNativePaths.join("\n")}` : prepared.prompt;
             }
             prompt = `The prior terminal submission was rejected (${closure.retry.code}). Resubmit it as the sole terminal tool call. Rejected call ids: ${closure.retry.toolCallIds.join(", ") || "none"}.`;
           }
-          return failure("output", "GrokAcpRoundLimit", "round-retry-limit", { sessionId });
+          return failure("output", "AcpRoundLimit", "round-retry-limit", { sessionId });
         } finally {
           if (connection !== void 0) {
             if (sessionId !== void 0 && !accepted) {
@@ -13866,25 +14579,14 @@ ${priorNativePaths.join("\n")}` : prepared.prompt;
     }
   };
 }
-var PRIVATE_COMPAT_ENV = Object.fromEntries(
-  ["CLAUDE", "CURSOR", "CODEX"].flatMap((vendor) => ["SKILLS", "RULES", "AGENTS", "MCPS", "HOOKS", "SESSIONS"].map((kind) => [`GROK_${vendor}_${kind}_ENABLED`, "false"]))
-);
-function controlledGrokChildEnv(base) {
-  return {
-    ...base,
-    ...PRIVATE_COMPAT_ENV,
-    GROK_MEMORY: "0",
-    GROK_SUBAGENTS: "0"
-  };
-}
 
-// src/grok/role-envelope.ts
+// src/acp-host/role-envelope.ts
 function parseCanonicalSkillInvocation(prompt) {
   const match = /^\/skill:([A-Za-z0-9_-]+)(?:\s+([\s\S]*))?$/s.exec(prompt.trim());
   if (match === null) return void 0;
   return { name: match[1], userMessage: (match[2] ?? "").trim() };
 }
-function buildGrokSkillExpansion(methodSkills, prompt) {
+function buildAcpSkillExpansion(methodSkills, prompt) {
   const parsed = parseCanonicalSkillInvocation(prompt);
   if (parsed === void 0) return void 0;
   const method = methodSkills.get(parsed.name);
@@ -13898,14 +14600,14 @@ ${method.body}`,
     userMessage: parsed.userMessage
   });
 }
-function projectGrokActivationFlags(request) {
+function projectAcpActivationFlags(request) {
   const activation = request.activation;
   const flags = /* @__PURE__ */ new Map([["ak-role", activation.role]]);
   const inputFlag = packagedRoleInputFlag(activation.role);
   const phaseFlag = packagedRolePhaseFlag(activation.role);
   if ("phase" in activation && phaseFlag !== void 0) flags.set(phaseFlag, activation.phase);
   if (inputFlag !== void 0) {
-    const path = "taskPath" in activation ? activation.taskPath : "packetPath" in activation ? activation.packetPath : "casePath" in activation ? activation.casePath : "inputPath" in activation ? activation.inputPath : "sourceRun" in activation ? activation.sourceRun : void 0;
+    const path = "taskPath" in activation ? activation.taskPath : "packetPath" in activation ? activation.packetPath : "casePath" in activation ? activation.casePath : "inputPath" in activation ? activation.inputPath : "sourceRun" in activation ? activation.sourceRun : "sourcesPath" in activation ? activation.sourcesPath : void 0;
     if (path !== void 0) flags.set(inputFlag, path);
   }
   if (activation.role === "fixer" && activation.prerequisitesPath !== void 0) flags.set("ak-fixer-prerequisites", activation.prerequisitesPath);
@@ -13936,21 +14638,21 @@ async function listen(server, path) {
     });
   });
 }
-function createComposedGrokRoleTurnHost(config) {
-  return createGrokRoleTurnHost({
+function createComposedAcpRoleTurnHost(config) {
+  return createAcpRoleTurnHost({
     ...config,
-    prepare: (request) => prepareGrokRoleEnvelope({
+    prepare: (request) => prepareAcpRoleEnvelope({
       request,
       dependencies: config.roleRuntimeDependencies,
       // Same durable-principal path settlement uses for isAvailable (#617 DK-4 layout).
       sessionFile: config.sessionIdentity.resolveSessionFile(request.principal),
-      socketPath: config.socketPath?.(request) ?? `/tmp/ak-grok-mcp-${randomUUID2()}.sock`
+      socketPath: config.socketPath?.(request) ?? `/tmp/ak-acp-mcp-${randomUUID2()}.sock`
     })
   });
 }
-async function prepareGrokRoleEnvelope(options) {
+async function prepareAcpRoleEnvelope(options) {
   const { request } = options;
-  const flags = projectGrokActivationFlags(request);
+  const flags = projectAcpActivationFlags(request);
   const tools = /* @__PURE__ */ new Map();
   const handlers = /* @__PURE__ */ new Map();
   const calls = [];
@@ -13969,7 +14671,7 @@ async function prepareGrokRoleEnvelope(options) {
     const raw = await readFile13(method.path, "utf8");
     methodSkills.set(name, { path: method.path, body: stripSkillFrontmatter(raw).trim() });
   }
-  let sessionFile = options.sessionFile ?? join22(request.runDirectory, "session", "session.jsonl");
+  let sessionFile = options.sessionFile ?? join24(request.runDirectory, "session", "session.jsonl");
   await mkdir3(dirname15(sessionFile), { recursive: true });
   if (request.continuation.kind !== "resume") {
     try {
@@ -14034,7 +14736,7 @@ async function prepareGrokRoleEnvelope(options) {
     },
     capabilities: {
       skillExpansion(prompt) {
-        return buildGrokSkillExpansion(methodSkills, prompt);
+        return buildAcpSkillExpansion(methodSkills, prompt);
       }
     },
     registerFlag(name, definition) {
@@ -14046,12 +14748,12 @@ async function prepareGrokRoleEnvelope(options) {
     registerTool(tool2) {
       tools.set(tool2.name, tool2);
     },
-    // The real AK-owned surface only; Grok's builtin surface is host-side and
+    // The real AK-owned surface only; the host builtin surface is host-side and
     // observable after session/new, never echoed back into role-requested names.
     getAllTools() {
       return [...tools.keys()].map((name) => ({ name }));
     },
-    // Grok receives tool choice as role guidance; every tool registered for the
+    // The host receives tool choice as role guidance; every tool registered for the
     // seat remains reachable through MCP.
     setActiveTools(names) {
       preferredTools = [...names];
@@ -14333,7 +15035,7 @@ async function prepareGrokRoleEnvelope(options) {
     }
     if (cleanupFailures.length === 1) throw cleanupFailures[0];
     if (cleanupFailures.length > 1) {
-      throw new AggregateError(cleanupFailures, "Grok envelope dispose cleanup failures", {
+      throw new AggregateError(cleanupFailures, "ACP envelope dispose cleanup failures", {
         cause: cleanupFailures[0]
       });
     }
@@ -14410,8 +15112,8 @@ async function prepareGrokRoleEnvelope(options) {
         command: process.execPath,
         args: [relay],
         env: [
-          { name: "AK_GROK_MCP_SOCKET", value: options.socketPath },
-          { name: "AK_GROK_MCP_TOKEN", value: token }
+          { name: "AK_ACP_MCP_SOCKET", value: options.socketPath },
+          { name: "AK_ACP_MCP_TOKEN", value: token }
         ]
       }],
       systemPrompt: { body: systemPromptBody, materials: readingMaterials },
@@ -14426,7 +15128,7 @@ async function prepareGrokRoleEnvelope(options) {
     } catch (cleanupFailure) {
       throw new AggregateError(
         [error, cleanupFailure],
-        "prepareGrokRoleEnvelope activation failed and its dispose cleanup also failed",
+        "prepareAcpRoleEnvelope activation failed and its dispose cleanup also failed",
         { cause: error }
       );
     }
@@ -14434,12 +15136,11 @@ async function prepareGrokRoleEnvelope(options) {
   }
 }
 
-// src/grok/session-identity.ts
+// src/acp-host/session-identity.ts
 import { mkdir as mkdir4, readFile as readFile14, rename, writeFile as writeFile8 } from "node:fs/promises";
-import { dirname as dirname16, join as join23 } from "node:path";
-var GROK_ACP_SESSION_BINDING = "grok-acp-session.json";
-function createGrokSessionIdentityAuthority(authority) {
-  const bindingPath = (principal) => join23(authority.decode(principal).sessionDirectory, GROK_ACP_SESSION_BINDING);
+import { dirname as dirname16, join as join25 } from "node:path";
+function createAcpSessionIdentityAuthority(authority, sessionBindingFile) {
+  const bindingPath = (principal) => join25(authority.decode(principal).sessionDirectory, sessionBindingFile);
   return {
     resolveSessionFile(principal) {
       return authority.decode(principal).sessionFile;
@@ -14448,7 +15149,7 @@ function createGrokSessionIdentityAuthority(authority) {
       try {
         const value = JSON.parse(await readFile14(bindingPath(principal), "utf8"));
         if (typeof value !== "object" || value === null || typeof value.sessionId !== "string") {
-          throw new Error("durable Grok ACP session binding is invalid");
+          throw new Error("durable ACP session binding is invalid");
         }
         return value.sessionId;
       } catch (error) {
@@ -14467,20 +15168,11 @@ function createGrokSessionIdentityAuthority(authority) {
   };
 }
 
-// src/grok/production-host.ts
-function resolveGrokBinary(operatorHome) {
-  return join24(operatorHome, ".grok", "bin", "grok");
-}
-function childEnv(packageRoot) {
-  return {
-    ...controlledGrokChildEnv(process.env),
-    AK_PACKAGE_ROOT: packageRoot
-  };
-}
+// src/acp-host/production-host.ts
 var navigatorRoutePlaybookPath = fileURLToPath3(
   new URL("../../resources/navigator-route-playbook.md", import.meta.url)
 );
-function createGrokRoleRuntimeDependencies(packageRoot) {
+function createAcpRoleRuntimeDependencies(packageRoot) {
   const judgeAuditor = createPiJudgeAuditor();
   const doctorAuditor = createPiDoctorAuditor();
   const reviewerAgent = createPerDispatchReviewerAgent({ packageRoot });
@@ -14504,6 +15196,7 @@ function createGrokRoleRuntimeDependencies(packageRoot) {
     loadNotarySoul: () => loadMainRoleSessionMaterials("notary"),
     loadCountersignSoul: () => loadMainRoleSessionMaterials("countersign"),
     loadGleanerLeftSoul: () => loadMainRoleSessionMaterials("gleaner-left"),
+    loadDiaristSoul: () => loadMainRoleSessionMaterials("diarist"),
     loadNotarySourceRun: loadNotarySourceRunLocator,
     loadMergerSoul: () => loadMainRoleSessionMaterials("merger"),
     loadMergerInput: async (path) => JSON.parse(await readFile15(path, "utf8")),
@@ -14544,23 +15237,28 @@ function createGrokRoleRuntimeDependencies(packageRoot) {
     })
   };
 }
-function createProductionGrokRoleTurnHost(options) {
-  const { packageRoot, principalAuthority } = options;
-  const env = childEnv(packageRoot);
-  return createComposedGrokRoleTurnHost({
-    sessionIdentity: createGrokSessionIdentityAuthority(principalAuthority),
-    roleRuntimeDependencies: createGrokRoleRuntimeDependencies(packageRoot),
+function createProductionAcpRoleTurnHost(options) {
+  const { packageRoot, principalAuthority, description } = options;
+  const env = {
+    ...process.env,
+    ...description.childEnv,
+    AK_PACKAGE_ROOT: packageRoot
+  };
+  return createComposedAcpRoleTurnHost({
+    sessionIdentity: createAcpSessionIdentityAuthority(principalAuthority, description.sessionBindingFile),
+    boundResume: description.boundResume,
+    roleRuntimeDependencies: createAcpRoleRuntimeDependencies(packageRoot),
     async connect(request) {
-      return connectGrokAcpStdio({
-        binary: resolveGrokBinary(request.home),
+      return connectAcpStdio({
+        binary: resolveAcpBinary(description, request.home),
+        args: acpStdioArgs(description, request.model),
         cwd: request.cwd,
-        env,
-        ...request.model === void 0 ? {} : { model: request.model.model }
+        env
       });
     }
   });
 }
 export {
-  createGrokRoleRuntimeDependencies,
-  createProductionGrokRoleTurnHost
+  createAcpRoleRuntimeDependencies,
+  createProductionAcpRoleTurnHost
 };