@akagilnc/pi-workflow-roles 0.1.5504 → 0.1.5575

package/dist/migrate-book-topology.js

@@ -499,6 +499,10 @@ function errorText(error) {
 function isEnoent(error) {
   return error instanceof Error && errnoCode(error) === "ENOENT";
 }
+function isMissingPathError(error) {
+  const code = errnoCode(error);
+  return error instanceof Error && (code === "ENOENT" || code === "ENOTDIR");
+}
 var init_unknown_value = __esm({
   "src/unknown-value.ts"() {
     "use strict";
@@ -513,7 +517,37 @@ import {
   realpathSync,
   statSync
 } from "node:fs";
+import { userInfo } from "node:os";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+function packageMachineHome() {
+  return resolve(userInfo().homedir);
+}
+function tryHomeFromAkRolesPath(path8) {
+  const match3 = /(^|[\\/])\.ak-roles(?=[\\/]|$)/.exec(path8);
+  if (!match3) return void 0;
+  if (match3.index === 0) {
+    return match3[1] === "" ? "" : match3[1];
+  }
+  return path8.slice(0, match3.index);
+}
+function resolveActivationLedgerHome(home) {
+  const processHome = typeof home === "string" ? home : packageMachineHome();
+  if (typeof processHome !== "string" || processHome.length === 0 || !isAbsolute(processHome)) {
+    throw new ActivationLedgerError(
+      `activation ledger process home must be absolute, got ${JSON.stringify(processHome)}`
+    );
+  }
+  return resolve(processHome, ".ak-roles");
+}
+function resolveActivationLedgerHomeForPath(path8) {
+  if (typeof path8 === "string" && path8.length > 0) {
+    const derived = tryHomeFromAkRolesPath(path8);
+    if (derived !== void 0 && derived.length > 0) {
+      return resolveActivationLedgerHome(derived);
+    }
+  }
+  return resolveActivationLedgerHome();
+}
 function activationBookDirectory(ledgerHome, bookKey) {
   return join(ledgerHome, "books", bookKey);
 }
@@ -543,16 +577,640 @@ function physicalPathIdentity(path8) {
 function physicallyContainedIn(root, candidate) {
   return pathContainedIn(physicalPathIdentity(root), physicalPathIdentity(candidate));
 }
+function assertPhysicalLedgerRoot(absoluteRoot) {
+  let st2;
+  try {
+    st2 = lstatSync(absoluteRoot);
+  } catch (error) {
+    if (errnoCode(error) !== "ENOENT") {
+      throw new ActivationLedgerError(
+        `activation ledger failed to stat home (${absoluteRoot}): ${errorText(error)}`,
+        { cause: error }
+      );
+    }
+  }
+  if (st2 === void 0) {
+    try {
+      mkdirSync(absoluteRoot, { recursive: true });
+    } catch (error) {
+      if (errnoCode(error) !== "EEXIST") {
+        throw new ActivationLedgerError(
+          `activation ledger failed to create home (${absoluteRoot}): ${errorText(error)}`,
+          { cause: error }
+        );
+      }
+    }
+    try {
+      st2 = lstatSync(absoluteRoot);
+    } catch (error) {
+      throw new ActivationLedgerError(
+        `activation ledger failed to stat home (${absoluteRoot}): ${errorText(error)}`,
+        { cause: error }
+      );
+    }
+  }
+  if (st2.isSymbolicLink()) {
+    throw new ActivationLedgerError(
+      `activation ledger home is a symbolic link: ${absoluteRoot}`
+    );
+  }
+  if (!st2.isDirectory()) {
+    throw new ActivationLedgerError(`activation ledger home is not a directory: ${absoluteRoot}`);
+  }
+}
+function ensureRealDirectoryTree(root, targetDir) {
+  if (!isAbsolute(root)) {
+    throw new ActivationLedgerError(`activation ledger home must be absolute: ${root}`);
+  }
+  const absoluteRoot = resolve(root);
+  const absoluteTarget = resolve(targetDir);
+  if (absoluteTarget !== absoluteRoot && !pathContainedIn(absoluteRoot, absoluteTarget)) {
+    throw new ActivationLedgerError(
+      `activation ledger path escapes ledger home (${absoluteRoot}): ${absoluteTarget}`
+    );
+  }
+  assertPhysicalLedgerRoot(absoluteRoot);
+  let realRoot;
+  try {
+    realRoot = realpathSync(absoluteRoot);
+  } catch (error) {
+    throw new ActivationLedgerError(
+      `activation ledger home is not resolvable (${absoluteRoot}): ${errorText(error)}`,
+      { cause: error }
+    );
+  }
+  if (!statSync(realRoot).isDirectory()) {
+    throw new ActivationLedgerError(`activation ledger home is not a directory: ${realRoot}`);
+  }
+  const rel = absoluteTarget === absoluteRoot ? "" : relative(absoluteRoot, absoluteTarget);
+  if (rel === "") return realRoot;
+  if (isAbsolute(rel) || rel === ".." || rel.startsWith(`..${sep}`)) {
+    throw new ActivationLedgerError(
+      `activation ledger path escapes ledger home (${absoluteRoot}): ${absoluteTarget}`
+    );
+  }
+  let lexicalCursor = absoluteRoot;
+  for (const part of rel.split(sep)) {
+    if (part === "" || part === ".") continue;
+    if (part === "..") {
+      throw new ActivationLedgerError(`activation ledger path contains '..': ${absoluteTarget}`);
+    }
+    lexicalCursor = join(lexicalCursor, part);
+    let st2;
+    try {
+      st2 = lstatSync(lexicalCursor);
+    } catch (error) {
+      if (errnoCode(error) !== "ENOENT") {
+        throw new ActivationLedgerError(
+          `activation ledger failed to stat path component (${lexicalCursor}): ${errorText(error)}`,
+          { cause: error }
+        );
+      }
+      try {
+        mkdirSync(lexicalCursor);
+      } catch (mkdirError) {
+        if (errnoCode(mkdirError) !== "EEXIST") {
+          throw new ActivationLedgerError(
+            `activation ledger failed to create directory (${lexicalCursor}): ${errorText(mkdirError)}`,
+            { cause: mkdirError }
+          );
+        }
+      }
+      try {
+        st2 = lstatSync(lexicalCursor);
+      } catch (statError) {
+        throw new ActivationLedgerError(
+          `activation ledger failed to stat path component (${lexicalCursor}): ${errorText(statError)}`,
+          { cause: statError }
+        );
+      }
+    }
+    if (st2.isSymbolicLink()) {
+      throw new ActivationLedgerError(
+        `activation ledger path component is a symbolic link: ${lexicalCursor}`
+      );
+    }
+    if (!st2.isDirectory()) {
+      throw new ActivationLedgerError(`activation ledger path component is not a directory: ${lexicalCursor}`);
+    }
+    let realCursor;
+    try {
+      realCursor = realpathSync(lexicalCursor);
+    } catch (error) {
+      throw new ActivationLedgerError(
+        `activation ledger path component is not resolvable (${lexicalCursor}): ${errorText(error)}`,
+        { cause: error }
+      );
+    }
+    if (realCursor !== realRoot && !pathContainedIn(realRoot, realCursor)) {
+      throw new ActivationLedgerError(
+        `activation ledger path component escapes ledger home (${lexicalCursor} -> ${realCursor})`
+      );
+    }
+  }
+  try {
+    return realpathSync(absoluteTarget);
+  } catch (error) {
+    throw new ActivationLedgerError(
+      `activation ledger directory is not resolvable (${absoluteTarget}): ${errorText(error)}`,
+      { cause: error }
+    );
+  }
+}
+var ActivationLedgerError;
 var init_activation_ledger_topology = __esm({
   "src/activation-ledger-topology.ts"() {
     "use strict";
     init_unknown_value();
+    ActivationLedgerError = class extends Error {
+      code = "AK_ACTIVATION_LEDGER";
+      constructor(message, options) {
+        super(
+          message,
+          options?.cause === void 0 ? void 0 : { cause: options.cause }
+        );
+        this.name = "ActivationLedgerError";
+      }
+    };
+  }
+});
+
+// src/run-dossier-files.ts
+var RUN_CURRENT_FILE, RUN_HISTORY_FILE, RUN_LOG_FILE, RUN_STATE_FILE, RUN_HISTORY_KINDS, OFFICER_POINTER_RECORD_KIND, RUN_STATE_KINDS;
+var init_run_dossier_files = __esm({
+  "src/run-dossier-files.ts"() {
+    "use strict";
+    RUN_CURRENT_FILE = "current.json";
+    RUN_HISTORY_FILE = "history.jsonl";
+    RUN_LOG_FILE = "log.jsonl";
+    RUN_STATE_FILE = "state.jsonl";
+    RUN_HISTORY_KINDS = /* @__PURE__ */ new Set([
+      "candidate",
+      "roundContext",
+      "outcome",
+      "sealed",
+      "post-seal-anomaly",
+      "attempt-history",
+      "turn-delivery",
+      "officer-pointer"
+    ]);
+    OFFICER_POINTER_RECORD_KIND = "officer-pointer";
+    RUN_STATE_KINDS = /* @__PURE__ */ new Set([
+      "invocation",
+      "admitted-request",
+      "run-state",
+      "terminal",
+      "host-session-id"
+    ]);
+  }
+});
+
+// src/activation-ledger-git.ts
+import { execFileSync } from "node:child_process";
+import { basename as basename2, dirname as dirname2, isAbsolute as isAbsolute2, resolve as resolve2 } from "node:path";
+function envWithoutGitDiscovery(base = process.env) {
+  const env2 = { ...base, LC_ALL: "C" };
+  for (const key of GIT_DISCOVERY_ENV_KEYS) {
+    delete env2[key];
+  }
+  return env2;
+}
+function isConfirmedNonRepositoryStderr(stderr) {
+  return CONFIRMED_NON_REPOSITORY_STDERR.test(stderr);
+}
+function isGitSpawnInfrastructureError(error) {
+  const code = errnoCode(error);
+  return code === "ENOENT" || code === "EACCES" || code === "EPERM";
+}
+function gitChildExitedNonzero(error) {
+  if (error === null || typeof error !== "object" || !("status" in error)) return false;
+  const status = error.status;
+  return typeof status === "number" && status !== 0;
+}
+function resolveBookKeyFromGit(cwd) {
+  let commonDir;
+  try {
+    commonDir = execFileSync("git", ["rev-parse", "--git-common-dir"], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+      env: envWithoutGitDiscovery()
+    }).trim();
+  } catch (error) {
+    if (isGitSpawnInfrastructureError(error) || !gitChildExitedNonzero(error)) {
+      throw error;
+    }
+    const err2 = error;
+    const detail = typeof err2.stderr === "string" ? err2.stderr.trim() : Buffer.isBuffer(err2.stderr) ? err2.stderr.toString("utf8").trim() : typeof err2.message === "string" ? err2.message : "";
+    throw new ActivationGitRepositoryRequiredError(detail || "unknown git error", {
+      cause: error,
+      confirmedNonRepository: isConfirmedNonRepositoryStderr(detail)
+    });
+  }
+  if (commonDir.length === 0) {
+    throw new Error("git rev-parse --git-common-dir returned an empty path");
+  }
+  const absoluteCommon = isAbsolute2(commonDir) ? commonDir : resolve2(cwd, commonDir);
+  const hostDirectory = basename2(absoluteCommon) === ".git" ? dirname2(absoluteCommon) : absoluteCommon;
+  const bookKey = basename2(hostDirectory);
+  if (bookKey.length === 0 || bookKey === "." || bookKey === "/") {
+    throw new Error(`Unable to derive activation book key from git common dir: ${absoluteCommon}`);
+  }
+  return bookKey;
+}
+var GIT_DISCOVERY_ENV_KEYS, CONFIRMED_NON_REPOSITORY_STDERR, ActivationGitRepositoryRequiredError;
+var init_activation_ledger_git = __esm({
+  "src/activation-ledger-git.ts"() {
+    "use strict";
+    init_unknown_value();
+    GIT_DISCOVERY_ENV_KEYS = [
+      "GIT_DIR",
+      "GIT_COMMON_DIR",
+      "GIT_WORK_TREE",
+      "GIT_CEILING_DIRECTORIES",
+      "GIT_DISCOVERY_ACROSS_FILESYSTEM"
+    ];
+    CONFIRMED_NON_REPOSITORY_STDERR = /^fatal:\s*not a git repository/i;
+    ActivationGitRepositoryRequiredError = class extends Error {
+      code = "AK_ACTIVATION_GIT_REPOSITORY_REQUIRED";
+      confirmedNonRepository;
+      constructor(detail, options) {
+        super(
+          `Workflow role activation requires a git repository cwd (git rev-parse --git-common-dir failed): ${detail || "unknown git error"}`,
+          options?.cause === void 0 ? void 0 : { cause: options.cause }
+        );
+        this.name = "ActivationGitRepositoryRequiredError";
+        this.confirmedNonRepository = options?.confirmedNonRepository ?? false;
+      }
+    };
+  }
+});
+
+// src/sitian-contracts.ts
+function attachDirectErrnoCode(error, cause) {
+  if (cause === null || typeof cause !== "object" || !("code" in cause)) return;
+  const code = cause.code;
+  if (typeof code === "string") error.code = code;
+}
+var SitianInfrastructureError;
+var init_sitian_contracts = __esm({
+  "src/sitian-contracts.ts"() {
+    "use strict";
+    SitianInfrastructureError = class extends Error {
+      knownCause = "session";
+      constructor(message, options) {
+        super(message, options);
+        this.name = "SitianInfrastructureError";
+        attachDirectErrnoCode(this, options?.cause);
+      }
+    };
+  }
+});
+
+// src/sitian-appender.ts
+import { randomUUID } from "node:crypto";
+import { appendFileSync } from "node:fs";
+import { basename as basename3, dirname as dirname3, join as join2 } from "node:path";
+function resolveSitianVolumeCategory(kind) {
+  return kind;
+}
+function sitianVolumeDirectory(sessionDirectory, category) {
+  return join2(sessionDirectory, category);
+}
+function sitianVolumeRecordsFile(volumeDirectory) {
+  return join2(volumeDirectory, SITIAN_RECORDS_LEAF);
+}
+function ticketProvenanceUnderBookPaths(ledgerHome, bookKey, ticketId) {
+  const sessionDir = join2(activationBookDirectory(ledgerHome, bookKey), ticketId);
+  return { sessionDir, recordFile: sitianVolumeRecordsFile(sessionDir) };
+}
+function resolveSitianRecordPathInLedger(input, ledgerHome) {
+  const category = resolveSitianVolumeCategory(input.kind);
+  const ticketNumber = category === "ticket-provenance" ? ticketNumberFromSitianSubject(input.subject) : void 0;
+  let sessionDir;
+  let recordFile;
+  if (ticketNumber !== void 0) {
+    const paths = ticketProvenanceUnderBookPaths(
+      ledgerHome,
+      resolveBookKeyFromGit(input.cwd ?? process.cwd()),
+      ticketNumber
+    );
+    sessionDir = paths.sessionDir;
+    recordFile = paths.recordFile;
+  } else if (category === "ticket-provenance" && input.runDirectory !== void 0) {
+    sessionDir = input.runDirectory;
+    recordFile = join2(sessionDir, RUN_HISTORY_FILE);
+  } else {
+    if (input.sessionParent === void 0 || input.sessionParent.length === 0 || !physicallyContainedIn(ledgerHome, input.sessionParent)) {
+      throw new Error("Sitian record ownership requires a parent session inside the ledger home");
+    }
+    const sessionParentDir = dirname3(input.sessionParent);
+    const runDirectory = dirname3(sessionParentDir);
+    if (basename3(sessionParentDir) === "session" && parseRunLeaf(basename3(runDirectory)) !== void 0) {
+      sessionDir = runDirectory;
+      recordFile = join2(runDirectory, RUN_HISTORY_KINDS.has(input.kind) ? RUN_HISTORY_FILE : RUN_STATE_KINDS.has(input.kind) ? RUN_STATE_FILE : RUN_LOG_FILE);
+    } else {
+      sessionDir = sitianVolumeDirectory(sessionParentDir, category);
+      recordFile = sitianVolumeRecordsFile(sessionDir);
+    }
+  }
+  if (!physicallyContainedIn(ledgerHome, sessionDir)) {
+    throw new Error("Sitian record ownership requires a directory inside the ledger home");
+  }
+  return { sessionDir, recordFile, ledgerHome };
+}
+function resolveSitianRecordPath(input) {
+  const ledgerHome = input.home !== void 0 && input.home.length > 0 ? resolveActivationLedgerHome(input.home) : resolveActivationLedgerHomeForPath(input.runDirectory ?? input.sessionParent);
+  return resolveSitianRecordPathInLedger(input, ledgerHome);
+}
+function appendSitianRecord(input) {
+  try {
+    const { sessionDir, recordFile, ledgerHome } = resolveSitianRecordPath(input);
+    ensureRealDirectoryTree(ledgerHome, sessionDir);
+    const identity = input.identity ?? randomUUID();
+    const timestamp = input.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
+    const host = input.host ?? "pi";
+    const record = {
+      level: input.level,
+      kind: input.kind,
+      identity,
+      ...input.subject === void 0 ? {} : { subject: input.subject },
+      ...input.sessionParent === void 0 ? {} : { sessionParent: input.sessionParent },
+      timestamp,
+      host,
+      ...input.source === void 0 ? {} : { source: input.source },
+      ...input.payload === void 0 ? {} : { payload: input.payload },
+      ...input.raw === void 0 ? {} : { raw: input.raw },
+      ...input.usage === void 0 ? {} : { usage: input.usage }
+    };
+    const row = `${JSON.stringify(record)}
+`;
+    appendFileSync(recordFile, row, "utf8");
+    return {
+      identity: record.identity,
+      recordFile,
+      kind: record.kind,
+      level: record.level
+    };
+  } catch (error) {
+    if (error instanceof SitianInfrastructureError) throw error;
+    throw new SitianInfrastructureError(
+      `Sitian appender persistence failure: ${errorText(error)}`,
+      { cause: error }
+    );
+  }
+}
+var SITIAN_RECORDS_LEAF;
+var init_sitian_appender = __esm({
+  "src/sitian-appender.ts"() {
+    "use strict";
+    init_role_run_placement();
+    init_run_dossier_files();
+    init_run_ticket_number();
+    init_activation_ledger_git();
+    init_activation_ledger_topology();
+    init_sitian_contracts();
+    SITIAN_RECORDS_LEAF = "records.jsonl";
+  }
+});
+
+// src/sitian-reader.ts
+function decodeSitianRecordLine(line, lineNumber) {
+  if (!line.trim()) return void 0;
+  try {
+    const parsed2 = JSON.parse(line);
+    if (isRecord(parsed2)) {
+      return { ok: true, record: parsed2 };
+    }
+    const typeDesc = parsed2 === null ? "null" : Array.isArray(parsed2) ? "array" : typeof parsed2;
+    return {
+      ok: false,
+      diagnostic: {
+        kind: "malformed",
+        line: lineNumber,
+        raw: line,
+        error: `expected JSON object, got ${typeDesc}`
+      }
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      diagnostic: {
+        kind: "malformed",
+        line: lineNumber,
+        raw: line,
+        error: errorText(error)
+      }
+    };
+  }
+}
+function parseSitianRecordText(text) {
+  const lines = text.split("\n");
+  const records = [];
+  const diagnostics = [];
+  for (let index3 = 0; index3 < lines.length; index3 += 1) {
+    const decoded = decodeSitianRecordLine(lines[index3], index3 + 1);
+    if (decoded === void 0) continue;
+    if (decoded.ok) records.push(decoded.record);
+    else diagnostics.push(decoded.diagnostic);
+  }
+  return { records, diagnostics };
+}
+var init_sitian_reader = __esm({
+  "src/sitian-reader.ts"() {
+    "use strict";
+    init_unknown_value();
+  }
+});
+
+// src/run-dossier.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { readFileSync, renameSync, rmSync, statSync as statSync2, writeFileSync } from "node:fs";
+import { basename as basename4, join as join3 } from "node:path";
+function runCurrentPath(runDirectory) {
+  return join3(runDirectory, RUN_CURRENT_FILE);
+}
+function readRowFile(path8) {
+  let buffer;
+  try {
+    buffer = readFileSync(path8);
+  } catch (error) {
+    if (isMissingPathError(error)) return { rows: [], bytes: 0 };
+    return { rows: [], bytes: 0, fault: String(error.code ?? error.name) };
+  }
+  const { records, diagnostics } = parseSitianRecordText(buffer.toString("utf8"));
+  return {
+    rows: [...records],
+    bytes: buffer.length,
+    ...diagnostics.length > 0 ? { diagnostics: diagnostics.map((d) => ({ line: d.line, error: d.error })) } : {}
+  };
+}
+function fileBytes(path8) {
+  try {
+    return statSync2(path8).size;
+  } catch (error) {
+    return isMissingPathError(error) ? 0 : void 0;
+  }
+}
+function lastPayloadOfKind(rows, kind) {
+  for (let index3 = rows.length - 1; index3 >= 0; index3 -= 1) {
+    const row = rows[index3];
+    if (row.kind === kind) return row.payload;
+  }
+  return void 0;
+}
+function lastPagePayload(rows, kind, runDirectory) {
+  const payload = lastPayloadOfKind(rows, kind);
+  if (payload === void 0) return void 0;
+  if (!isRecord(payload)) {
+    throw new TypeError(`${RUN_STATE_FILE} ${kind} payload is not an object: ${runDirectory}`);
+  }
+  return payload;
+}
+function latestOfficerPointersFromRecords(records) {
+  const latest = {};
+  for (const record of records) {
+    if (record.kind !== OFFICER_POINTER_RECORD_KIND) continue;
+    if (!isRecord(record.payload) || typeof record.payload.officer !== "string") {
+      throw new TypeError("officer-pointer payload is not a record with string officer");
+    }
+    latest[record.payload.officer] = record.payload;
+  }
+  return latest;
+}
+function render(runDirectory, history, state3, log, unreadable) {
+  const whole = {};
+  for (const section of ["invocation", "admitted", "runState", "terminal"]) {
+    const page = lastPayloadOfKind(state3, PAGE_ROW_KIND[section]);
+    if (page !== void 0) whole[section] = page;
+  }
+  let latest;
+  for (const row of history) {
+    const payload = isRecord(row.payload) ? row.payload : void 0;
+    if (row.kind === "sealed" && payload !== void 0) {
+      latest = { toolCallId: payload.toolCallId, role: payload.role, accepted: payload.accepted, at: row.timestamp };
+    }
+  }
+  let officers = {};
+  try {
+    officers = latestOfficerPointersFromRecords(history);
+  } catch (error) {
+    if (!(error instanceof TypeError)) throw error;
+    if (unreadable[RUN_HISTORY_FILE] === void 0) unreadable[RUN_HISTORY_FILE] = "malformed";
+  }
+  const sessions = {};
+  for (const row of state3) {
+    const payload = isRecord(row.payload) ? row.payload : void 0;
+    if (row.kind === "host-session-id" && payload !== void 0 && typeof payload.host === "string") {
+      sessions[payload.host] = payload.sessionId;
+    }
+  }
+  let original;
+  for (const row of log) {
+    const payload = isRecord(row.payload) ? row.payload : void 0;
+    if (row.kind === "host-session" && payload?.type === "native-session-copy" && typeof payload.landingPath === "string") {
+      original = payload.landingPath;
+    }
+  }
+  if (typeof original === "string") original = join3(runDirectory, "session", basename4(original));
+  whole.host = { sessions, ...original === void 0 ? {} : { original } };
+  whole.submission = latest === void 0 ? {} : { latest };
+  whole.officers = officers;
+  if (Object.keys(unreadable).length > 0) whole.unreadable = unreadable;
+  return whole;
+}
+function writeWhole(runDirectory, whole) {
+  const destination = runCurrentPath(runDirectory);
+  const body = `${JSON.stringify(whole, null, 2)}
+`;
+  const temporary = join3(runDirectory, `.${RUN_CURRENT_FILE}-${randomUUID2()}.tmp`);
+  try {
+    writeFileSync(temporary, body, "utf8");
+    renameSync(temporary, destination);
+  } catch (error) {
+    rmSync(temporary, { force: true });
+    const code = error.code;
+    if (code !== "EACCES" && code !== "EPERM" && code !== "EROFS") throw error;
+    writeFileSync(destination, body, "utf8");
+  }
+}
+function renderCurrentSync(runDirectory) {
+  const paths = [RUN_HISTORY_FILE, RUN_STATE_FILE, RUN_LOG_FILE].map((name) => join3(runDirectory, name));
+  for (; ; ) {
+    const [history, state3, log] = paths.map(readRowFile);
+    const unreadable = {};
+    for (const [name, file] of [[RUN_HISTORY_FILE, history], [RUN_STATE_FILE, state3], [RUN_LOG_FILE, log]]) {
+      if (file.fault !== void 0) unreadable[name] = file.fault;
+      else if (file.diagnostics !== void 0 && file.diagnostics.length > 0) unreadable[name] = "malformed";
+    }
+    const whole = render(runDirectory, history.rows, state3.rows, log.rows, unreadable);
+    for (const [name, code] of Object.entries(unreadable)) {
+      const key = `${runDirectory}\0${name}`;
+      if (declaredUnreadable.get(key) === code) continue;
+      const detail = code === "malformed" ? `${name} has malformed row(s); current.json keeps reachable rows and retains the diagnostic` : `${name} cannot be read (${code}); current.json is rendered without it`;
+      process.stderr.write(`[run-dossier] ${detail}: ${runDirectory}
+`);
+      declaredUnreadable.set(key, code);
+    }
+    writeWhole(runDirectory, whole);
+    const grew = [history, state3, log].some((file, index3) => file.fault === void 0 && fileBytes(paths[index3]) !== file.bytes);
+    if (!grew) return;
+  }
+}
+function appendPageRow(runDirectory, section, page) {
+  appendSitianRecord({
+    level: "event",
+    kind: PAGE_ROW_KIND[section],
+    sessionParent: sessionFileOf(runDirectory),
+    source: "run-dossier",
+    payload: page
+  });
+}
+function readPageSync(runDirectory, section) {
+  const state3 = readRowFile(join3(runDirectory, RUN_STATE_FILE));
+  if (state3.fault !== void 0) throw new Error(`${RUN_STATE_FILE} is unreadable (${state3.fault}): ${runDirectory}`);
+  if (state3.diagnostics !== void 0 && state3.diagnostics.length > 0) {
+    throw new Error(
+      `${RUN_STATE_FILE} has malformed row(s); refusing stale control-plane page: ${runDirectory}`
+    );
+  }
+  return lastPagePayload(state3.rows, PAGE_ROW_KIND[section], runDirectory);
+}
+function writeSectionSync(runDirectory, section, value2) {
+  appendPageRow(runDirectory, section, value2);
+  renderCurrentSync(runDirectory);
+}
+function updateSectionSync(runDirectory, section, update) {
+  const current = readPageSync(runDirectory, section);
+  if (current === void 0) {
+    throw new Error(`${RUN_STATE_FILE} has no ${PAGE_ROW_KIND[section]} row: ${runDirectory}`);
+  }
+  const next = update(current);
+  if (next === void 0) return;
+  writeSectionSync(runDirectory, section, next);
+}
+var PAGE_ROW_KIND, declaredUnreadable;
+var init_run_dossier = __esm({
+  "src/run-dossier.ts"() {
+    "use strict";
+    init_role_run_placement();
+    init_run_dossier_files();
+    init_sitian_appender();
+    init_sitian_reader();
+    init_unknown_value();
+    PAGE_ROW_KIND = {
+      invocation: "invocation",
+      admitted: "admitted-request",
+      runState: "run-state",
+      terminal: "terminal"
+    };
+    declaredUnreadable = /* @__PURE__ */ new Map();
   }
 });
 
 // src/run-ticket-number.ts
 import { readFile } from "node:fs/promises";
-import { join as join2 } from "node:path";
+import { join as join4 } from "node:path";
 function isPositiveTicketNumber(value2) {
   return typeof value2 === "number" && Number.isInteger(value2) && value2 >= 1;
 }
@@ -568,6 +1226,19 @@ function parseTicketNumber(value2) {
   const parsed2 = Number(value2);
   return isSafePositiveTicketNumber(parsed2) ? parsed2 : void 0;
 }
+function sitianSubjectTicketNumber(subject) {
+  if (typeof subject === "string" || typeof subject === "number") {
+    return parseTicketNumber(subject);
+  }
+  if (subject !== null && typeof subject === "object" && !Array.isArray(subject)) {
+    return parseTicketNumber(subject.ticketNumber);
+  }
+  return void 0;
+}
+function ticketNumberFromSitianSubject(subject) {
+  const parsed2 = sitianSubjectTicketNumber(subject);
+  return parsed2 === void 0 ? void 0 : String(parsed2);
+}
 function requireSafePositiveTicketNumber(ticketNumber, context = "ticketNumber") {
   if (!isSafePositiveTicketNumber(ticketNumber)) {
     throw new Error(
@@ -591,42 +1262,62 @@ async function readJsonObject(path8) {
     throw error;
   }
 }
-async function readBoardPageTicketNumber(runDirectory, page) {
-  const record = await readJsonObject(join2(runDirectory, page));
+function readBoardPageTicketNumberFromRows(runDirectory, section) {
+  const fromRows = readPageSync(runDirectory, section);
+  return fromRows === void 0 ? void 0 : ticketFromRecord(fromRows);
+}
+async function readBoardPageTicketNumberFromLegacy(runDirectory, section) {
+  const record = await readJsonObject(join4(runDirectory, LEGACY_BOARD_PAGE[section]));
   if (record === void 0) return void 0;
   return ticketFromRecord(record);
 }
 async function readBoardTicketNumber(runDirectory) {
-  return await readBoardPageTicketNumber(runDirectory, "admitted-request.json") ?? await readBoardPageTicketNumber(runDirectory, "invocation.json");
+  return readBoardPageTicketNumberFromRows(runDirectory, "admitted") ?? readBoardPageTicketNumberFromRows(runDirectory, "invocation");
+}
+async function readMigrationBoardTicketNumber(runDirectory) {
+  return await readBoardTicketNumber(runDirectory) ?? await readBoardPageTicketNumberFromLegacy(runDirectory, "admitted") ?? await readBoardPageTicketNumberFromLegacy(runDirectory, "invocation");
 }
 async function readMigrationDerivedTicketNumber(runDirectory) {
   const record = await readJsonObject(
-    join2(runDirectory, MIGRATION_TICKET_DERIVATION_PAGE)
+    join4(runDirectory, MIGRATION_TICKET_DERIVATION_PAGE)
   );
   if (record === void 0) return void 0;
   if (record.derivation !== "worktree-path-basename") return void 0;
   return ticketFromRecord(record);
 }
-var MIGRATION_TICKET_DERIVATION_PAGE;
+var MIGRATION_TICKET_DERIVATION_PAGE, LEGACY_BOARD_PAGE;
 var init_run_ticket_number = __esm({
   "src/run-ticket-number.ts"() {
     "use strict";
+    init_run_dossier();
     init_unknown_value();
     MIGRATION_TICKET_DERIVATION_PAGE = "migration-ticket-derivation.json";
+    LEGACY_BOARD_PAGE = {
+      admitted: "admitted-request.json",
+      invocation: "invocation.json"
+    };
   }
 });
 
 // src/role-run-placement.ts
 import { readdir } from "node:fs/promises";
-import { basename as basename2, dirname as dirname2, join as join3 } from "node:path";
+import { basename as basename5, dirname as dirname4, join as join5 } from "node:path";
 function formatRunLeaf(runId, role) {
   return `${runId}@${role}`;
 }
+function parseRunLeaf(name) {
+  const at2 = name.lastIndexOf("@");
+  if (at2 <= 0 || at2 === name.length - 1) return void 0;
+  return { runId: name.slice(0, at2), role: name.slice(at2 + 1) };
+}
 function sessionDirectoryOf(runDirectory) {
-  return join3(runDirectory, "session");
+  return join5(runDirectory, "session");
 }
 function sessionFileIn(sessionDirectory) {
-  return join3(sessionDirectory, ROLE_RUN_SESSION_FILENAME);
+  return join5(sessionDirectory, ROLE_RUN_SESSION_FILENAME);
+}
+function sessionFileOf(runDirectory) {
+  return sessionFileIn(sessionDirectoryOf(runDirectory));
 }
 async function listBookRunDirectories(bookDir) {
   const out = [];
@@ -641,13 +1332,13 @@ async function listBookRunDirectories(bookDir) {
     }
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const runDir = join3(runsDir, entry.name);
+      const runDir = join5(runsDir, entry.name);
       if (seen.has(runDir)) continue;
       seen.add(runDir);
       out.push(runDir);
     }
   };
-  await collect(join3(bookDir, "runs"));
+  await collect(join5(bookDir, "runs"));
   let subjects;
   try {
     subjects = await readdir(bookDir, { withFileTypes: true });
@@ -657,7 +1348,7 @@ async function listBookRunDirectories(bookDir) {
   }
   for (const subject of subjects) {
     if (!subject.isDirectory() || subject.name === "runs") continue;
-    await collect(join3(bookDir, subject.name, "runs"));
+    await collect(join5(bookDir, subject.name, "runs"));
   }
   return out.sort();
 }
@@ -666,7 +1357,7 @@ function roleRunPlacement(ledgerHome, input) {
     input.subject.ticketNumber,
     "roleRunPlacement subject.ticketNumber"
   )) : "unbound";
-  const runDirectory = join3(
+  const runDirectory = join5(
     activationBookDirectory(ledgerHome, input.bookKey),
     subjectDirectory,
     "runs",
@@ -677,13 +1368,9 @@ function roleRunPlacement(ledgerHome, input) {
     runDirectory,
     sessionDirectory,
     sessionFile: sessionFileIn(sessionDirectory),
-    artifactsDirectory: roleRunArtifactsDirectory(runDirectory),
-    attachmentsDirectory: join3(runDirectory, "attachments")
+    attachmentsDirectory: join5(runDirectory, "attachments")
   };
 }
-function roleRunArtifactsDirectory(runDirectory) {
-  return join3(runDirectory, "artifacts");
-}
 function isUnboundRunDirectory(runDirectory) {
   return runDirectory.replaceAll("\\", "/").includes("/unbound/runs/");
 }
@@ -8038,6 +8725,7 @@ var init_build = __esm({
 var init_auditor_dossier_tool = __esm({
   "src/auditor-dossier-tool.ts"() {
     "use strict";
+    init_run_dossier();
     init_role_run_placement();
     init_build();
   }
@@ -14098,14 +14786,7 @@ var init_packaged_role_registry = __esm({
         outputTool: FIXER_OUTPUT_TOOL_NAME,
         settlement: "sealed",
         artifactFace: {
-          reportPhase: true,
-          evidenceRole: true,
-          leaves: [
-            { key: "phase" },
-            { key: "packetPath" },
-            { key: "prerequisitesPath", omitUndefined: true },
-            { key: "prerequisites" }
-          ]
+          reportPhase: true
         },
         boardPlacement: "marshal",
         activationFlags: [
@@ -14136,12 +14817,7 @@ var init_packaged_role_registry = __esm({
         outputTool: CODER_OUTPUT_TOOL_NAME,
         settlement: "sealed",
         artifactFace: {
-          reportPhase: true,
-          evidenceRole: true,
-          leaves: [
-            { key: "phase" },
-            { key: "taskPath" }
-          ]
+          reportPhase: true
         },
         activationFlags: [
           { field: "taskPath", flag: "ak-coder-task", binds: "input" },
@@ -14175,15 +14851,7 @@ var init_packaged_role_registry = __esm({
         settlement: "sealed",
         /** Publish only an accepted ledger outcome; audit escalation stays unsettled here. */
         sealedAcceptedOnly: true,
-        artifactFace: {
-          evidenceRole: true,
-          leaves: [
-            { key: "baseRevision" },
-            { key: "lens" },
-            { key: "authorityRefs", copyArray: true },
-            { key: "callerProvenance", callerProvenance: true }
-          ]
-        },
+        artifactFace: {},
         /** Frozen base/lens/authority become the initial prompt; instruction follows. */
         transportPrompt: "skill-args",
         boardPlacement: "marshal",
@@ -14214,14 +14882,7 @@ var init_packaged_role_registry = __esm({
         bareCommand: false,
         outputTool: COLLECTOR_OUTPUT_TOOL,
         settlement: "sealed",
-        artifactFace: {
-          evidenceRole: true,
-          leaves: [
-            { key: "prNumber", omitUndefined: true },
-            { key: "repository", from: "repository.canonical" },
-            { key: "manifestDigest" }
-          ]
-        },
+        artifactFace: {},
         boardPlacement: "collector",
         /** Taishi acceptance is a typed groups array, not a status leaf. */
         analystTerminal: "groups",
@@ -14250,12 +14911,6 @@ var init_packaged_role_registry = __esm({
         auditTool: DOCTOR_AUDIT_TOOL_NAME,
         settlement: "sealed",
         artifactFace: {
-          evidenceRole: true,
-          leaves: [
-            { key: "issueNumber" },
-            { key: "caseRunsPath" },
-            { key: "caseIdentity" }
-          ],
           doctorReportFacts: true
         },
         /** Navigator subject is the doctor case, not the case-path file bytes. */
@@ -14281,13 +14936,7 @@ var init_packaged_role_registry = __esm({
         phases: [null],
         outputTool: MERGER_OUTPUT_TOOL_NAME,
         settlement: "sealed",
-        artifactFace: {
-          evidenceRole: true,
-          leaves: [
-            { key: "mergerInputPath" },
-            { key: "derived" }
-          ]
-        },
+        artifactFace: {},
         activationFlags: [
           { field: "inputPath", from: "mergerInputPath", flag: "ak-merger-input", binds: "input" }
         ],
@@ -14704,22 +15353,12 @@ var init_terminal = __esm({
 });
 
 // src/run-terminal-artifacts.ts
-var RUN_TERMINAL_ERROR_SETTLEMENT_FILE, RUN_TERMINAL_ERROR_FALLBACK_RELATIVE_PATHS, UNIQUE_ERROR_FALLBACK_STEM, UNIQUE_ERROR_FALLBACK_NAME;
 var init_run_terminal_artifacts = __esm({
   "src/run-terminal-artifacts.ts"() {
     "use strict";
     init_role_run_placement();
+    init_run_dossier();
     init_unknown_value();
-    RUN_TERMINAL_ERROR_SETTLEMENT_FILE = "error.settlement.json";
-    RUN_TERMINAL_ERROR_FALLBACK_RELATIVE_PATHS = [
-      `artifacts/${RUN_TERMINAL_ERROR_SETTLEMENT_FILE}`,
-      RUN_TERMINAL_ERROR_SETTLEMENT_FILE
-    ];
-    UNIQUE_ERROR_FALLBACK_STEM = "error";
-    UNIQUE_ERROR_FALLBACK_NAME = new RegExp(
-      `^${UNIQUE_ERROR_FALLBACK_STEM}\\.[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\\.json$`,
-      "i"
-    );
   }
 });
 
@@ -14762,8 +15401,7 @@ var init_host_descriptions = __esm({
           suffix: Object.freeze(["stdio"])
         }),
         modelPassing: "set_model",
-        setModelId: "bare",
-        sessionBindingFile: "grok-acp-session.json"
+        setModelId: "bare"
       }),
       /**
        * Operator home `~/.hermes`, native session/load resume, `acp` subcommand.
@@ -14781,7 +15419,6 @@ var init_host_descriptions = __esm({
         }),
         modelPassing: "set_model",
         setModelId: "provider:model",
-        sessionBindingFile: "hermes-acp-session.json",
         seatProfileSoul: Object.freeze({
           flag: "-p",
           namePrefix: "ak-",
@@ -14794,7 +15431,6 @@ var init_host_descriptions = __esm({
       "claude": Object.freeze({
         protocol: "claude-print",
         binaryFromHome: Object.freeze([".local", "bin", "claude"]),
-        sessionBindingFile: "claude-headless-session.json",
         fixedArgs: Object.freeze([
           // Live NDJSON events → sitian host-session records (#811); last line is the result receipt.
           "--output-format",
@@ -14820,8 +15456,7 @@ var init_host_descriptions = __esm({
        */
       "codex": Object.freeze({
         protocol: "codex-exec",
-        binaryFromHome: Object.freeze([".local", "bin", "codex"]),
-        sessionBindingFile: "codex-headless-session.json"
+        binaryFromHome: Object.freeze([".local", "bin", "codex"])
       })
     });
   }
@@ -14902,9 +15537,8 @@ var init_compliance_transport = __esm({
 });
 
 // src/role-run-relocation.ts
-import { existsSync } from "node:fs";
 import { readdir as readdir2, readFile as readFile2, writeFile } from "node:fs/promises";
-import { dirname as dirname3, join as join4, sep as sep2 } from "node:path";
+import { dirname as dirname5, join as join6, sep as sep2 } from "node:path";
 function rewriteRunDirectoryPathValue(value2, oldRunDirectory, newRunDirectory) {
   if (typeof value2 !== "string") return value2;
   if (value2 === oldRunDirectory) return newRunDirectory;
@@ -14998,25 +15632,22 @@ function rewriteAdmittedRoleRunPage(page, rewrites) {
     );
   }
 }
-async function rewriteOfficerPointerFile(path8, rewrites) {
-  if (!existsSync(path8)) return;
+async function rewriteLegacyOfficerPointerFile(path8, rewrites) {
   const page = JSON.parse(await readFile2(path8, "utf8"));
-  if (!isRecord(page)) return;
-  if (page.kind !== "direct-officer-run-pointer") return;
+  if (!isRecord(page) || page.kind !== "direct-officer-run-pointer") return;
   const before = JSON.stringify(page);
-  rewriteRunDirectoryPathFieldsAgainstRewrites(
-    page,
-    OFFICER_POINTER_FIELDS,
-    rewrites
-  );
-  if (JSON.stringify(page) !== before) {
-    await writeFile(path8, `${JSON.stringify(page)}
+  rewriteRunDirectoryPathFieldsAgainstRewrites(page, OFFICER_POINTER_FIELDS, rewrites);
+  if (JSON.stringify(page) !== before) await writeFile(path8, `${JSON.stringify(page)}
 `, "utf8");
-  }
 }
 async function rewriteSitianRecordsJsonl(path8, rewrites) {
-  if (!existsSync(path8)) return;
-  const raw = await readFile2(path8, "utf8");
+  let raw;
+  try {
+    raw = await readFile2(path8, "utf8");
+  } catch (error) {
+    if (isEnoent(error)) return;
+    throw error;
+  }
   if (raw.length === 0) return;
   const endsWithNewline = raw.endsWith("\n");
   const lines = raw.split("\n");
@@ -15066,8 +15697,13 @@ async function rewriteSitianRecordsJsonl(path8, rewrites) {
   );
 }
 async function rewriteSessionTranscriptBindings(path8, rewrites) {
-  if (!existsSync(path8)) return;
-  const raw = await readFile2(path8, "utf8");
+  let raw;
+  try {
+    raw = await readFile2(path8, "utf8");
+  } catch (error) {
+    if (isEnoent(error)) return;
+    throw error;
+  }
   if (raw.length === 0) return;
   const endsWithNewline = raw.endsWith("\n");
   const lines = raw.split("\n");
@@ -15126,7 +15762,7 @@ async function rewriteSessionTranscriptBindings(path8, rewrites) {
   );
 }
 async function rewriteNestedMachinePathPages(pagesDirectory, rewrites) {
-  const sessionRoot = join4(pagesDirectory, "session");
+  const sessionRoot = join6(pagesDirectory, "session");
   async function walk3(directory) {
     let entries;
     try {
@@ -15136,14 +15772,14 @@ async function rewriteNestedMachinePathPages(pagesDirectory, rewrites) {
       throw error;
     }
     for (const entry of entries) {
-      const path8 = join4(directory, entry.name);
+      const path8 = join6(directory, entry.name);
       if (entry.isDirectory()) {
         await walk3(path8);
         continue;
       }
       if (!entry.isFile()) continue;
       if (entry.name.endsWith(".pointer.json")) {
-        await rewriteOfficerPointerFile(path8, rewrites);
+        await rewriteLegacyOfficerPointerFile(path8, rewrites);
       } else if (entry.name === "records.jsonl") {
         await rewriteSitianRecordsJsonl(path8, rewrites);
       } else if (entry.name.endsWith(".jsonl")) {
@@ -15156,47 +15792,49 @@ async function rewriteNestedMachinePathPages(pagesDirectory, rewrites) {
 async function rewriteRoleRunDurablePages(input) {
   const { pagesDirectory } = input;
   const rewrites = collectRewrites(input);
-  const admittedPath = join4(pagesDirectory, "admitted-request.json");
-  if (existsSync(admittedPath)) {
-    const page = JSON.parse(await readFile2(admittedPath, "utf8"));
-    const before = JSON.stringify(page);
-    rewriteAdmittedRoleRunPage(page, rewrites);
-    if (JSON.stringify(page) !== before) {
-      await writeFile(admittedPath, `${JSON.stringify(page, null, 2)}
-`, "utf8");
+  const pageRewriters = {
+    admitted: (page) => rewriteAdmittedRoleRunPage(page, rewrites),
+    invocation: (page) => rewriteRunDirectoryPathFieldsAgainstRewrites(page, INVOCATION_PAGE_FIELDS, rewrites),
+    runState: (page) => {
+      rewriteRunDirectoryPathFieldsAgainstRewrites(page, RUN_STATE_PAGE_FIELDS, rewrites);
+      if (isRecord(page.principal)) {
+        rewriteRunDirectoryPathFieldsAgainstRewrites(
+          page.principal,
+          ["sessionDirectory", "sessionFile"],
+          rewrites
+        );
+      }
+      if (isRecord(page.currentCourt)) {
+        rewriteSummonsMaterials(page.currentCourt.summons, rewrites);
+      }
     }
+  };
+  for (const [section, rewrite] of Object.entries(pageRewriters)) {
+    if (readPageSync(pagesDirectory, section) === void 0) continue;
+    updateSectionSync(pagesDirectory, section, (current) => {
+      const page = structuredClone(current);
+      rewrite(page);
+      return JSON.stringify(page) === JSON.stringify(current) ? void 0 : page;
+    });
   }
-  const invocationPath = join4(pagesDirectory, "invocation.json");
-  if (existsSync(invocationPath)) {
-    const page = JSON.parse(await readFile2(invocationPath, "utf8"));
-    const before = JSON.stringify(page);
-    rewriteRunDirectoryPathFieldsAgainstRewrites(page, INVOCATION_PAGE_FIELDS, rewrites);
-    if (JSON.stringify(page) !== before) {
-      await writeFile(invocationPath, `${JSON.stringify(page, null, 2)}
-`, "utf8");
+  for (const [file, rewrite] of [
+    ["admitted-request.json", pageRewriters.admitted],
+    ["invocation.json", pageRewriters.invocation],
+    ["run-state.json", pageRewriters.runState]
+  ]) {
+    const path8 = join6(pagesDirectory, file);
+    let raw;
+    try {
+      raw = await readFile2(path8, "utf8");
+    } catch (error) {
+      if (isEnoent(error)) continue;
+      throw error;
     }
-  }
-  const statePath = join4(pagesDirectory, "run-state.json");
-  if (existsSync(statePath)) {
-    const page = JSON.parse(await readFile2(statePath, "utf8"));
+    const page = JSON.parse(raw);
     const before = JSON.stringify(page);
-    rewriteRunDirectoryPathFieldsAgainstRewrites(
-      page,
-      RUN_STATE_PAGE_FIELDS,
-      rewrites
-    );
-    if (isRecord(page.principal)) {
-      rewriteRunDirectoryPathFieldsAgainstRewrites(
-        page.principal,
-        ["sessionDirectory", "sessionFile"],
-        rewrites
-      );
-    }
-    if (isRecord(page.currentCourt)) {
-      rewriteSummonsMaterials(page.currentCourt.summons, rewrites);
-    }
+    rewrite(page);
     if (JSON.stringify(page) !== before) {
-      await writeFile(statePath, `${JSON.stringify(page, null, 2)}
+      await writeFile(path8, `${JSON.stringify(page, null, 2)}
 `, "utf8");
     }
   }
@@ -15210,10 +15848,12 @@ var init_role_run_relocation = __esm({
     init_run_lifecycle();
     init_role_run_placement();
     init_compliance_transport();
+    init_run_dossier();
     init_unknown_value();
     ADMITTED_PAGE_FIELDS = [
       "runDirectory",
       "admittedRequestPath",
+      // pre-#1161 pages only
       "sessionDirectory",
       "sessionFile",
       "taskPath",
@@ -15231,6 +15871,7 @@ var init_role_run_relocation = __esm({
     RUN_STATE_PAGE_FIELDS = [
       "runDirectory",
       "admittedRequestPath",
+      // pre-#1161 pages only
       "sessionDirectory",
       "sessionFile"
     ];
@@ -15243,14 +15884,6 @@ var init_role_run_relocation = __esm({
   }
 });
 
-// src/activation-ledger-git.ts
-var init_activation_ledger_git = __esm({
-  "src/activation-ledger-git.ts"() {
-    "use strict";
-    init_unknown_value();
-  }
-});
-
 // src/submission-correctable-error.ts
 var correctableSubmissionErrorBrand, CorrectableSubmissionError;
 var init_submission_correctable_error = __esm({
@@ -15341,33 +15974,6 @@ var init_ledger_session_read = __esm({
   }
 });
 
-// src/sitian-contracts.ts
-var init_sitian_contracts = __esm({
-  "src/sitian-contracts.ts"() {
-    "use strict";
-  }
-});
-
-// src/sitian-appender.ts
-var S4_SUBMISSION_LEDGER_KINDS;
-var init_sitian_appender = __esm({
-  "src/sitian-appender.ts"() {
-    "use strict";
-    init_role_run_placement();
-    init_run_ticket_number();
-    init_activation_ledger_git();
-    init_activation_ledger_topology();
-    init_sitian_contracts();
-    S4_SUBMISSION_LEDGER_KINDS = /* @__PURE__ */ new Set([
-      "candidate",
-      "roundContext",
-      "outcome",
-      "sealed",
-      "post-seal-anomaly"
-    ]);
-  }
-});
-
 // src/session-dialogue.ts
 var init_session_dialogue = __esm({
   "src/session-dialogue.ts"() {
@@ -15376,18 +15982,11 @@ var init_session_dialogue = __esm({
   }
 });
 
-// src/sitian-reader.ts
-var init_sitian_reader = __esm({
-  "src/sitian-reader.ts"() {
-    "use strict";
-    init_unknown_value();
-  }
-});
-
 // src/sitian-facade.ts
 var init_sitian_facade = __esm({
   "src/sitian-facade.ts"() {
     "use strict";
+    init_role_run_placement();
     init_sitian_appender();
     init_sitian_contracts();
     init_sitian_appender();
@@ -15403,9 +16002,10 @@ var init_ticket_provenance = __esm({
     init_ledger_session_read();
     init_run_ticket_number();
     init_role_run_placement();
-    init_sitian_appender();
+    init_run_dossier_files();
     init_session_dialogue();
     init_sitian_facade();
+    init_sitian_reader();
     init_ticket_provenance_contracts();
     init_unknown_value();
   }
@@ -16190,6 +16790,7 @@ var init_invocation = __esm({
     init_packaged_role_registry();
     init_run_ticket_number();
     init_role_run_relocation();
+    init_run_dossier();
     init_doctor_evidence();
     init_collector_config();
     init_github_remote();
@@ -16209,7 +16810,7 @@ var init_invocation = __esm({
 });
 
 // src/public-cli/run-lifecycle.ts
-import { chmod, lstat, open, readdir as readdir3, readFile as readFile3, unlink, writeFile as writeFile2 } from "node:fs/promises";
+import { chmod, lstat, open, readdir as readdir3, readFile as readFile3, unlink } from "node:fs/promises";
 function describeErrorIdentity(error) {
   const candidate = error;
   const name = typeof candidate?.name === "string" && candidate.name !== "" ? candidate.name : typeof error;
@@ -16258,6 +16859,7 @@ var init_run_lifecycle = __esm({
     init_engine_material();
     init_packaged_role_registry();
     init_invocation();
+    init_run_dossier();
     init_unknown_value();
   }
 });
@@ -16356,12 +16958,12 @@ var require_isexe = __commonJS({
         if (typeof Promise !== "function") {
           throw new TypeError("callback not provided");
         }
-        return new Promise(function(resolve12, reject) {
+        return new Promise(function(resolve13, reject) {
           isexe(path8, options || {}, function(er, is) {
             if (er) {
               reject(er);
             } else {
-              resolve12(is);
+              resolve13(is);
             }
           });
         });
@@ -16427,27 +17029,27 @@ var require_which = __commonJS({
         opt = {};
       const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
       const found = [];
-      const step = (i2) => new Promise((resolve12, reject) => {
+      const step = (i2) => new Promise((resolve13, reject) => {
         if (i2 === pathEnv.length)
-          return opt.all && found.length ? resolve12(found) : reject(getNotFoundError(cmd));
+          return opt.all && found.length ? resolve13(found) : reject(getNotFoundError(cmd));
         const ppRaw = pathEnv[i2];
         const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
         const pCmd = path8.join(pathPart, cmd);
         const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
-        resolve12(subStep(p, i2, 0));
+        resolve13(subStep(p, i2, 0));
       });
-      const subStep = (p, i2, ii) => new Promise((resolve12, reject) => {
+      const subStep = (p, i2, ii) => new Promise((resolve13, reject) => {
         if (ii === pathExt.length)
-          return resolve12(step(i2 + 1));
+          return resolve13(step(i2 + 1));
         const ext2 = pathExt[ii];
         isexe(p + ext2, { pathExt: pathExtExe }, (er, is) => {
           if (!er && is) {
             if (opt.all)
               found.push(p + ext2);
             else
-              return resolve12(p + ext2);
+              return resolve13(p + ext2);
           }
-          return resolve12(subStep(p, i2, ii + 1));
+          return resolve13(subStep(p, i2, ii + 1));
         });
       });
       return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
@@ -16769,7 +17371,7 @@ var init_child_process = __esm({
 
 // node_modules/.pnpm/@earendil-works+pi-coding-agent@0.99.1_@aws-sdk+credential-provider-node@3.972.83_@smit_1f563b9fb7db4619e2913cc40d230799/node_modules/@earendil-works/pi-coding-agent/dist/utils/paths.js
 import { homedir as homedir2 } from "node:os";
-import { isAbsolute as isAbsolute2, join as join6, resolve as nodeResolvePath, relative as relative2, sep as sep3 } from "node:path";
+import { isAbsolute as isAbsolute3, join as join8, resolve as nodeResolvePath, relative as relative2, sep as sep3 } from "node:path";
 import { fileURLToPath } from "node:url";
 function normalizeWindowsShellPath(filePath) {
   if (!filePath.startsWith("/") || filePath.startsWith("//") || filePath.includes("\\"))
@@ -16796,7 +17398,7 @@ function normalizePath(input, options = {}) {
     if (normalized === "~")
       return home;
     if (normalized.startsWith("~/") || process.platform === "win32" && normalized.startsWith("~\\")) {
-      return join6(home, normalized.slice(2));
+      return join8(home, normalized.slice(2));
     }
   }
   if (/^file:\/\//.test(normalized)) {
@@ -16825,22 +17427,22 @@ var init_text = __esm({
 });
 
 // node_modules/.pnpm/@earendil-works+pi-coding-agent@0.99.1_@aws-sdk+credential-provider-node@3.972.83_@smit_1f563b9fb7db4619e2913cc40d230799/node_modules/@earendil-works/pi-coding-agent/dist/config.js
-import { accessSync, constants, existsSync as existsSync2, readFileSync, realpathSync as realpathSync2 } from "fs";
+import { accessSync, constants, existsSync, readFileSync as readFileSync2, realpathSync as realpathSync2 } from "fs";
 import { createRequire } from "module";
 import { homedir as homedir3 } from "os";
-import { basename as basename4, dirname as dirname5, join as join7, resolve as resolve3, sep as sep4, win32 } from "path";
+import { basename as basename7, dirname as dirname7, join as join9, resolve as resolve4, sep as sep4, win32 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function findNodePackageDir(startDir) {
   let dir = startDir;
-  while (dir !== dirname5(dir)) {
-    if (existsSync2(join7(dir, "package.json"))) {
-      const parent = dirname5(dir);
-      if (basename4(dir) === "dist" && existsSync2(join7(parent, "package.json"))) {
+  while (dir !== dirname7(dir)) {
+    if (existsSync(join9(dir, "package.json"))) {
+      const parent = dirname7(dir);
+      if (basename7(dir) === "dist" && existsSync(join9(parent, "package.json"))) {
         return parent;
       }
       return dir;
     }
-    dir = dirname5(dir);
+    dir = dirname7(dir);
   }
   return startDir;
 }
@@ -16850,12 +17452,12 @@ function getPackageDir() {
     return normalizePath(envDir);
   }
   if (isBunBinary) {
-    return dirname5(process.execPath);
+    return dirname7(process.execPath);
   }
   return findNodePackageDir(__dirname);
 }
 function getPackageJsonPath() {
-  return join7(getPackageDir(), "package.json");
+  return join9(getPackageDir(), "package.json");
 }
 function getQuickJSWasmPath() {
   return embeddedQuickJSWasmPath ?? createRequire(import.meta.url).resolve("quickjs-wasi/quickjs.wasm");
@@ -16875,10 +17477,10 @@ function getAgentDir() {
   if (envDir) {
     return expandTildePath(envDir);
   }
-  return join7(homedir3(), CONFIG_DIR_NAME, "agent");
+  return join9(homedir3(), CONFIG_DIR_NAME, "agent");
 }
 function getBinDir() {
-  return join7(getAgentDir(), "bin");
+  return join9(getAgentDir(), "bin");
 }
 var __filename2, __dirname, isBunBinary, isBunRuntime, isBundledNode, embeddedQuickJSWasmPath, pkg, piConfigName, PACKAGE_NAME, APP_NAME, CONFIG_DIR_NAME, VERSION, ENV_AGENT_DIR, ENV_SESSION_DIR;
 var init_config3 = __esm({
@@ -16887,13 +17489,13 @@ var init_config3 = __esm({
     init_paths();
     init_text();
     __filename2 = fileURLToPath2(import.meta.url);
-    __dirname = dirname5(__filename2);
+    __dirname = dirname7(__filename2);
     isBunBinary = import.meta.url.includes("$bunfs") || import.meta.url.includes("~BUN") || import.meta.url.includes("%7EBUN");
     isBunRuntime = !!process.versions.bun;
     isBundledNode = typeof PI_BUNDLED_NODE !== "undefined" && PI_BUNDLED_NODE;
     pkg = {};
     try {
-      pkg = JSON.parse(stripBom(readFileSync(getPackageJsonPath(), "utf-8")));
+      pkg = JSON.parse(stripBom(readFileSync2(getPackageJsonPath(), "utf-8")));
     } catch (e2) {
       const err2 = e2;
       if (err2.code !== "ENOENT")
@@ -24931,8 +25533,8 @@ var init_event_stream = __esm({
       constructor(isComplete, extractResult) {
         this.isComplete = isComplete;
         this.extractResult = extractResult;
-        this.finalResultPromise = new Promise((resolve12) => {
-          this.resolveFinalResult = resolve12;
+        this.finalResultPromise = new Promise((resolve13) => {
+          this.resolveFinalResult = resolve13;
         });
       }
       push(event) {
@@ -24966,7 +25568,7 @@ var init_event_stream = __esm({
           } else if (this.done) {
             return;
           } else {
-            const result = await new Promise((resolve12) => this.waiting.enqueue(resolve12));
+            const result = await new Promise((resolve13) => this.waiting.enqueue(resolve13));
             if (result.done)
               return;
             yield result.value;
@@ -25119,7 +25721,7 @@ function raceWithAbortSignal(operation, signal) {
     });
     return Promise.reject(abortReason(signal));
   }
-  return new Promise((resolve12, reject) => {
+  return new Promise((resolve13, reject) => {
     let settled = false;
     const cleanup = () => signal.removeEventListener("abort", onAbort);
     const onAbort = () => {
@@ -25135,7 +25737,7 @@ function raceWithAbortSignal(operation, signal) {
         return;
       settled = true;
       cleanup();
-      resolve12(value2);
+      resolve13(value2);
     }, (error) => {
       if (settled)
         return;
@@ -26168,8 +26770,8 @@ var init_models = __esm({
         const credential = await raceWithAbortSignal(loginOperation, signal);
         let mutationStarted = false;
         let markMutationStarted;
-        const started = new Promise((resolve12) => {
-          markMutationStarted = resolve12;
+        const started = new Promise((resolve13) => {
+          markMutationStarted = resolve13;
         });
         const mutation = this.credentials.modify(providerId, async () => {
           mutationStarted = true;
@@ -26179,7 +26781,7 @@ var init_models = __esm({
         void mutation.catch(() => {
         });
         try {
-          await new Promise((resolve12, reject) => {
+          await new Promise((resolve13, reject) => {
             const onAbort = () => {
               if (!mutationStarted)
                 reject(signal.reason);
@@ -26187,7 +26789,7 @@ var init_models = __esm({
             signal.addEventListener("abort", onAbort, { once: true });
             void Promise.race([started, mutation]).then(() => {
               signal.removeEventListener("abort", onAbort);
-              resolve12();
+              resolve13();
             }, (error) => {
               signal.removeEventListener("abort", onAbort);
               reject(error);
@@ -42111,13 +42713,13 @@ var require_ignore = __commonJS({
         const rules = this._rules;
         const { length } = rules;
         const shortcut = this._basenameCount * 2 >= length;
-        const basename12 = shortcut ? basenameOf(path8) : path8;
+        const basename15 = shortcut ? basenameOf(path8) : path8;
         for (let index3 = 0; index3 < length; index3++) {
           const rule = rules[index3];
           const { negative } = rule;
           const skip = unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored;
           if (!skip && rule[mode].test(
-            shortcut && rule._basenameOnly ? basename12 : path8
+            shortcut && rule._basenameOnly ? basename15 : path8
           )) {
             ignored = !negative;
             unignored = negative;
@@ -43080,16 +43682,16 @@ var init_values2 = __esm({
 var sleep;
 var init_sleep = __esm({
   "node_modules/.pnpm/@anthropic-ai+sdk@0.124.0_zod@4.4.3/node_modules/@anthropic-ai/sdk/internal/utils/sleep.mjs"() {
-    sleep = (ms, signal) => new Promise((resolve12) => {
+    sleep = (ms, signal) => new Promise((resolve13) => {
       if (signal?.aborted)
-        return resolve12();
+        return resolve13();
       const onAbort = () => {
         clearTimeout(timer);
-        resolve12();
+        resolve13();
       };
       const timer = setTimeout(() => {
         signal?.removeEventListener("abort", onAbort);
-        resolve12();
+        resolve13();
       }, ms);
       signal?.addEventListener("abort", onAbort, { once: true });
     });
@@ -45261,8 +45863,8 @@ var init_api_promise = __esm({
     init_parse7();
     APIPromise = class _APIPromise extends Promise {
       constructor(client, responsePromise, parseResponse2 = defaultParseResponse) {
-        super((resolve12) => {
-          resolve12(null);
+        super((resolve13) => {
+          resolve13(null);
         });
         this.responsePromise = responsePromise;
         this.parseResponse = parseResponse2;
@@ -47901,16 +48503,16 @@ var init_async_queue = __esm({
         if (__classPrivateFieldGet3(this, _AsyncQueue_closed, "f") || signal?.aborted) {
           return Promise.resolve({ done: true, value: void 0 });
         }
-        return new Promise((resolve12) => {
+        return new Promise((resolve13) => {
           const waiter = (r2) => {
             signal?.removeEventListener("abort", onAbort);
-            resolve12(r2);
+            resolve13(r2);
           };
           const onAbort = () => {
             const idx = __classPrivateFieldGet3(this, _AsyncQueue_waiters, "f").indexOf(waiter);
             if (idx >= 0)
               __classPrivateFieldGet3(this, _AsyncQueue_waiters, "f").splice(idx, 1);
-            resolve12({ done: true, value: void 0 });
+            resolve13({ done: true, value: void 0 });
           };
           __classPrivateFieldGet3(this, _AsyncQueue_waiters, "f").push(waiter);
           signal?.addEventListener("abort", onAbort, { once: true });
@@ -48544,13 +49146,13 @@ var init_json_schema = __esm({
 
 // node_modules/.pnpm/@anthropic-ai+sdk@0.124.0_zod@4.4.3/node_modules/@anthropic-ai/sdk/internal/utils/promise.mjs
 function promiseWithResolvers() {
-  let resolve12;
+  let resolve13;
   let reject;
   const promise = new Promise((res, rej) => {
-    resolve12 = res;
+    resolve13 = res;
     reject = rej;
   });
-  return { promise, resolve: resolve12, reject };
+  return { promise, resolve: resolve13, reject };
 }
 var init_promise = __esm({
   "node_modules/.pnpm/@anthropic-ai+sdk@0.124.0_zod@4.4.3/node_modules/@anthropic-ai/sdk/internal/utils/promise.mjs"() {
@@ -48702,10 +49304,10 @@ async function setupSkills(ctx) {
   for (const skill of session.agent.skills) {
     try {
       const version = await client.beta.skills.versions.retrieve(skill.version, { skill_id: skill.skill_id });
-      let dirname16 = path.basename(version.name.trim());
-      if (dirname16 === "" || dirname16 === "." || dirname16 === "..")
-        dirname16 = skill.skill_id;
-      const dest = path.resolve(skillsRoot, dirname16);
+      let dirname18 = path.basename(version.name.trim());
+      if (dirname18 === "" || dirname18 === "." || dirname18 === "..")
+        dirname18 = skill.skill_id;
+      const dest = path.resolve(skillsRoot, dirname18);
       if (dest !== skillsRoot && !dest.startsWith(skillsRoot + path.sep)) {
         log.warn("skill name escapes the skills dir; skipping", {
           component: "agent-tool-context",
@@ -49339,10 +49941,10 @@ async function settledOrAborted(p, signal) {
     return;
   }
   let onAbort;
-  const aborted = new Promise((resolve12) => {
-    onAbort = resolve12;
+  const aborted = new Promise((resolve13) => {
+    onAbort = resolve13;
     if (signal.aborted)
-      resolve12();
+      resolve13();
   });
   signal.addEventListener("abort", onAbort, { once: true });
   try {
@@ -50406,7 +51008,7 @@ function betaGrepTool(ctx) {
   });
 }
 function runRipgrep(rg, pattern, searchPath, signal) {
-  return new Promise((resolve12, reject) => {
+  return new Promise((resolve13, reject) => {
     const proc = cp.spawn(rg, ["-n", "--no-heading", "-e", pattern, "--", searchPath], {
       ...signal ? { signal } : {}
     });
@@ -50428,12 +51030,12 @@ function runRipgrep(rg, pattern, searchPath, signal) {
       if (signal?.aborted)
         return reject(new ToolError("grep: aborted"));
       if (truncated)
-        return resolve12(out + `
+        return resolve13(out + `
 [output truncated at ${GREP_OUTPUT_LIMIT} bytes]`);
       if (code === 0)
-        return resolve12(out);
+        return resolve13(out);
       if (code === 1)
-        return resolve12("no matches");
+        return resolve13("no matches");
       reject(new ToolError(`grep: rg failed: ${errOut || `exit ${code}`}`));
     });
     proc.on("error", (e2) => {
@@ -50614,8 +51216,8 @@ var init_node2 = __esm({
 `;
         __classPrivateFieldGet3(this, _BashSession_proc, "f").stdin.write(wrapped);
         if (__classPrivateFieldGet3(this, _BashSession_buf, "f").indexOf(sentinel3) < 0) {
-          const { promise: sentinelSeen, resolve: resolve12 } = promiseWithResolvers();
-          __classPrivateFieldSet(this, _BashSession_waiting, { sentinel: sentinel3, resolve: resolve12 }, "f");
+          const { promise: sentinelSeen, resolve: resolve13 } = promiseWithResolvers();
+          __classPrivateFieldSet(this, _BashSession_waiting, { sentinel: sentinel3, resolve: resolve13 }, "f");
           let timer;
           let onAbort;
           try {
@@ -50772,8 +51374,8 @@ async function withTimeout(p, ms) {
   try {
     return await Promise.race([
       p.then(() => false, () => false),
-      new Promise((resolve12) => {
-        timer = setTimeout(() => resolve12(true), ms);
+      new Promise((resolve13) => {
+        timer = setTimeout(() => resolve13(true), ms);
       })
     ]);
   } finally {
@@ -52677,12 +53279,12 @@ var init_BetaMessageStream = __esm({
           }
           return this._emit("error", new AnthropicError(String(error)));
         });
-        __classPrivateFieldSet(this, _BetaMessageStream_connectedPromise, new Promise((resolve12, reject) => {
-          __classPrivateFieldSet(this, _BetaMessageStream_resolveConnectedPromise, resolve12, "f");
+        __classPrivateFieldSet(this, _BetaMessageStream_connectedPromise, new Promise((resolve13, reject) => {
+          __classPrivateFieldSet(this, _BetaMessageStream_resolveConnectedPromise, resolve13, "f");
           __classPrivateFieldSet(this, _BetaMessageStream_rejectConnectedPromise, reject, "f");
         }), "f");
-        __classPrivateFieldSet(this, _BetaMessageStream_endPromise, new Promise((resolve12, reject) => {
-          __classPrivateFieldSet(this, _BetaMessageStream_resolveEndPromise, resolve12, "f");
+        __classPrivateFieldSet(this, _BetaMessageStream_endPromise, new Promise((resolve13, reject) => {
+          __classPrivateFieldSet(this, _BetaMessageStream_resolveEndPromise, resolve13, "f");
           __classPrivateFieldSet(this, _BetaMessageStream_rejectEndPromise, reject, "f");
         }), "f");
         __classPrivateFieldGet3(this, _BetaMessageStream_connectedPromise, "f").catch(() => {
@@ -52857,11 +53459,11 @@ var init_BetaMessageStream = __esm({
        *   const message = await stream.emitted('message') // rejects if the stream errors
        */
       emitted(event) {
-        return new Promise((resolve12, reject) => {
+        return new Promise((resolve13, reject) => {
           __classPrivateFieldSet(this, _BetaMessageStream_catchingPromiseCreated, true, "f");
           if (event !== "error")
             this.once("error", reject);
-          this.once(event, resolve12);
+          this.once(event, resolve13);
         });
       }
       async done() {
@@ -53234,7 +53836,7 @@ var init_BetaMessageStream = __esm({
               if (done) {
                 return { value: void 0, done: true };
               }
-              return new Promise((resolve12, reject) => readQueue.push({ resolve: resolve12, reject })).then((chunk2) => chunk2 ? { value: chunk2, done: false } : { value: void 0, done: true });
+              return new Promise((resolve13, reject) => readQueue.push({ resolve: resolve13, reject })).then((chunk2) => chunk2 ? { value: chunk2, done: false } : { value: void 0, done: true });
             }
             const chunk = pushQueue.shift();
             return { value: chunk, done: false };
@@ -57515,12 +58117,12 @@ var init_MessageStream = __esm({
           }
           return this._emit("error", new AnthropicError(String(error)));
         });
-        __classPrivateFieldSet(this, _MessageStream_connectedPromise, new Promise((resolve12, reject) => {
-          __classPrivateFieldSet(this, _MessageStream_resolveConnectedPromise, resolve12, "f");
+        __classPrivateFieldSet(this, _MessageStream_connectedPromise, new Promise((resolve13, reject) => {
+          __classPrivateFieldSet(this, _MessageStream_resolveConnectedPromise, resolve13, "f");
           __classPrivateFieldSet(this, _MessageStream_rejectConnectedPromise, reject, "f");
         }), "f");
-        __classPrivateFieldSet(this, _MessageStream_endPromise, new Promise((resolve12, reject) => {
-          __classPrivateFieldSet(this, _MessageStream_resolveEndPromise, resolve12, "f");
+        __classPrivateFieldSet(this, _MessageStream_endPromise, new Promise((resolve13, reject) => {
+          __classPrivateFieldSet(this, _MessageStream_resolveEndPromise, resolve13, "f");
           __classPrivateFieldSet(this, _MessageStream_rejectEndPromise, reject, "f");
         }), "f");
         __classPrivateFieldGet3(this, _MessageStream_connectedPromise, "f").catch(() => {
@@ -57695,11 +58297,11 @@ var init_MessageStream = __esm({
        *   const message = await stream.emitted('message') // rejects if the stream errors
        */
       emitted(event) {
-        return new Promise((resolve12, reject) => {
+        return new Promise((resolve13, reject) => {
           __classPrivateFieldSet(this, _MessageStream_catchingPromiseCreated, true, "f");
           if (event !== "error")
             this.once("error", reject);
-          this.once(event, resolve12);
+          this.once(event, resolve13);
         });
       }
       async done() {
@@ -58024,7 +58626,7 @@ var init_MessageStream = __esm({
               if (done) {
                 return { value: void 0, done: true };
               }
-              return new Promise((resolve12, reject) => readQueue.push({ resolve: resolve12, reject })).then((chunk2) => chunk2 ? { value: chunk2, done: false } : { value: void 0, done: true });
+              return new Promise((resolve13, reject) => readQueue.push({ resolve: resolve13, reject })).then((chunk2) => chunk2 ? { value: chunk2, done: false } : { value: void 0, done: true });
             }
             const chunk = pushQueue.shift();
             return { value: chunk, done: false };
@@ -59530,8 +60132,8 @@ function getBunSandboxEnvValue(name) {
   if (procEnvCache === null) {
     procEnvCache = /* @__PURE__ */ new Map();
     try {
-      const { readFileSync: readFileSync4 } = __require("node:fs");
-      const data = readFileSync4("/proc/self/environ", "utf-8");
+      const { readFileSync: readFileSync5 } = __require("node:fs");
+      const data = readFileSync5("/proc/self/environ", "utf-8");
       for (const entry of data.split("\0")) {
         const idx = entry.indexOf("=");
         if (idx > 0) {
@@ -59598,7 +60200,7 @@ function createAbortError() {
   return error;
 }
 function abortableSleep(ms, signal) {
-  return new Promise((resolve12, reject) => {
+  return new Promise((resolve13, reject) => {
     if (signal?.aborted) {
       reject(createAbortError());
       return;
@@ -59609,7 +60211,7 @@ function abortableSleep(ms, signal) {
     };
     const timeout = setTimeout(() => {
       signal?.removeEventListener("abort", onAbort);
-      resolve12();
+      resolve13();
     }, Math.max(0, ms));
     signal?.addEventListener("abort", onAbort, { once: true });
   });
@@ -61582,7 +62184,7 @@ var init_values3 = __esm({
 var sleep2;
 var init_sleep2 = __esm({
   "node_modules/.pnpm/openai@7.19.0_@aws-sdk+credential-provider-node@3.972.83_@smithy+signature-v4@5.7.3_undici@8.10.2_ws@8.21.1_zod@4.4.3/node_modules/openai/internal/utils/sleep.mjs"() {
-    sleep2 = (ms, ...signals) => new Promise((resolve12, reject) => {
+    sleep2 = (ms, ...signals) => new Promise((resolve13, reject) => {
       const activeSignals = [...new Set(signals.filter((signal) => signal != null))];
       let timeout;
       let settled = false;
@@ -61614,7 +62216,7 @@ var init_sleep2 = __esm({
         return;
       }
       timeout = setTimeout(() => {
-        settle(resolve12);
+        settle(resolve13);
       }, ms);
       for (const signal of activeSignals) {
         if (settled) {
@@ -62156,8 +62758,8 @@ function createAbortableSSESource(body, signal) {
   let interrupt;
   const waitForAbort = () => (
     // oxlint-disable-next-line promise/avoid-new -- AbortSignal callbacks need a portable Promise bridge.
-    new Promise((resolve12) => {
-      interrupt = resolve12;
+    new Promise((resolve13) => {
+      interrupt = resolve13;
     })
   );
   const cancel = () => {
@@ -63429,8 +64031,8 @@ var init_api_promise2 = __esm({
     init_parse8();
     APIPromise2 = class _APIPromise extends Promise {
       constructor(client, responsePromise, parseResponse2 = defaultParseResponse2) {
-        super((resolve12) => {
-          resolve12(null);
+        super((resolve13) => {
+          resolve13(null);
         });
         this.responsePromise = responsePromise;
         this.parseResponse = parseResponse2;
@@ -64954,20 +65556,20 @@ function getName2(value2, options) {
   const name = "name" in value2 ? value2.name : void 0;
   const explicitName = name && String(name) || "filename" in value2 && value2.filename && String(value2.filename);
   if (explicitName) {
-    return options?.stripFilename === false ? normalizeFilenamePath(explicitName) : basename5(explicitName);
+    return options?.stripFilename === false ? normalizeFilenamePath(explicitName) : basename8(explicitName);
   }
   const url = "url" in value2 && value2.url && String(value2.url);
   if (url) {
     try {
-      return basename5(new URL(url).pathname);
+      return basename8(new URL(url).pathname);
     } catch {
-      return basename5(url);
+      return basename8(url);
     }
   }
   const path8 = "path" in value2 && value2.path && String(value2.path);
-  return path8 ? basename5(path8) : void 0;
+  return path8 ? basename8(path8) : void 0;
 }
-function basename5(value2) {
+function basename8(value2) {
   return value2.split(/[\\/]/).pop() || void 0;
 }
 function normalizeFilenamePath(value2) {
@@ -65071,7 +65673,7 @@ function getStreamingFileName(value2, options) {
     if (typeof name !== "string" || !name) {
       throw new TypeError("Streaming upload file name must be a non-empty string");
     }
-    return options.stripFilenames === false ? normalizeFilenamePath(name) : basename5(name) ?? "unknown_file";
+    return options.stripFilenames === false ? normalizeFilenamePath(name) : basename8(name) ?? "unknown_file";
   }
   return getName2(value2, { stripFilename: options.stripFilenames }) ?? "unknown_file";
 }
@@ -66524,12 +67126,12 @@ var init_EventStream = __esm({
         _EventStream_aborted.set(this, false);
         _EventStream_catchingPromiseCreated.set(this, false);
         _EventStream_terminalFailure.set(this, void 0);
-        __classPrivateFieldSet2(this, _EventStream_connectedPromise, new Promise((resolve12, reject) => {
-          __classPrivateFieldSet2(this, _EventStream_resolveConnectedPromise, resolve12, "f");
+        __classPrivateFieldSet2(this, _EventStream_connectedPromise, new Promise((resolve13, reject) => {
+          __classPrivateFieldSet2(this, _EventStream_resolveConnectedPromise, resolve13, "f");
           __classPrivateFieldSet2(this, _EventStream_rejectConnectedPromise, reject, "f");
         }), "f");
-        __classPrivateFieldSet2(this, _EventStream_endPromise, new Promise((resolve12, reject) => {
-          __classPrivateFieldSet2(this, _EventStream_resolveEndPromise, resolve12, "f");
+        __classPrivateFieldSet2(this, _EventStream_endPromise, new Promise((resolve13, reject) => {
+          __classPrivateFieldSet2(this, _EventStream_resolveEndPromise, resolve13, "f");
           __classPrivateFieldSet2(this, _EventStream_rejectEndPromise, reject, "f");
         }), "f");
         __classPrivateFieldGet4(this, _EventStream_connectedPromise, "f").catch(() => void 0);
@@ -66667,7 +67269,7 @@ var init_EventStream = __esm({
        *   const message = await stream.emitted('message') // rejects if the stream errors
        */
       emitted(event) {
-        return new Promise((resolve12, reject) => {
+        return new Promise((resolve13, reject) => {
           __classPrivateFieldSet2(this, _EventStream_catchingPromiseCreated, true, "f");
           const onError = (error) => {
             this.off(event, onEvent);
@@ -66677,7 +67279,7 @@ var init_EventStream = __esm({
             if (event !== "error") {
               this.off("error", onError);
             }
-            resolve12(values.length > 1 ? values : values[0]);
+            resolve13(values.length > 1 ? values : values[0]);
           };
           if (event !== "error") {
             __classPrivateFieldGet4(this, _EventStream_instances, "m", _EventStream_onceForEmitted).call(this, "error", onError);
@@ -66893,8 +67495,8 @@ var init_EventStream = __esm({
             if (ended) {
               return Promise.resolve(doneResult());
             }
-            return new Promise((resolve12, reject) => {
-              readQueue.enqueue({ resolve: resolve12, reject });
+            return new Promise((resolve13, reject) => {
+              readQueue.enqueue({ resolve: resolve13, reject });
             });
           },
           return: () => {
@@ -73046,8 +73648,8 @@ var init_agent_session_stream = __esm({
         try {
           await __classPrivateFieldGet4(this, _AgentSessionStream_instances, "m", _AgentSessionStream_wait).call(this, () => (
             // oxlint-disable-next-line promise/avoid-new -- Own the registration timer so cancellation clears it promptly.
-            new Promise((resolve12) => {
-              timer = setTimeout(resolve12, delay2);
+            new Promise((resolve13) => {
+              timer = setTimeout(resolve13, delay2);
             })
           ));
         } finally {
@@ -75530,7 +76132,7 @@ var init_AssistantStream = __esm({
 
 // node_modules/.pnpm/openai@7.19.0_@aws-sdk+credential-provider-node@3.972.83_@smithy+signature-v4@5.7.3_undici@8.10.2_ws@8.21.1_zod@4.4.3/node_modules/openai/lib/polling.mjs
 function sleepUntilAborted(milliseconds, signal) {
-  return new Promise((resolve12, reject) => {
+  return new Promise((resolve13, reject) => {
     let timer;
     let registered;
     let settled = false;
@@ -75579,7 +76181,7 @@ function sleepUntilAborted(milliseconds, signal) {
       }
       settled = true;
       cleanup();
-      resolve12();
+      resolve13();
     }, milliseconds);
     registered = abort;
     try {
@@ -82842,7 +83444,7 @@ var require_p_retry = __commonJS({
       return error;
     };
     var isNetworkError = (errorMessage5) => networkErrorMsgs.includes(errorMessage5);
-    var pRetry2 = (input, options) => new Promise((resolve12, reject) => {
+    var pRetry2 = (input, options) => new Promise((resolve13, reject) => {
       options = {
         onFailedAttempt: () => {
         },
@@ -82852,7 +83454,7 @@ var require_p_retry = __commonJS({
       const operation = retry2.operation(options);
       operation.attempt(async (attemptNumber) => {
         try {
-          resolve12(await input(attemptNumber));
+          resolve13(await input(attemptNumber));
         } catch (error) {
           if (!(error instanceof Error)) {
             reject(new TypeError(`Non-error was thrown: "${error}". You should only throw errors.`));
@@ -83386,8 +83988,8 @@ var require_retry3 = __commonJS({
       }
       const delay2 = getNextRetryDelay(config);
       err2.config.retryConfig.currentRetryAttempt += 1;
-      const backoff3 = config.retryBackoff ? config.retryBackoff(err2, delay2) : new Promise((resolve12) => {
-        setTimeout(resolve12, delay2);
+      const backoff3 = config.retryBackoff ? config.retryBackoff(err2, delay2) : new Promise((resolve13) => {
+        setTimeout(resolve13, delay2);
       });
       if (config.onRetryAttempt) {
         await config.onRetryAttempt(err2);
@@ -84163,8 +84765,8 @@ var require_helpers = __commonJS({
     function req(url, opts = {}) {
       const href = typeof url === "string" ? url : url.href;
       const req2 = (href.startsWith("https:") ? https2 : http3).request(url, opts);
-      const promise = new Promise((resolve12, reject) => {
-        req2.once("response", resolve12).once("error", reject).end();
+      const promise = new Promise((resolve13, reject) => {
+        req2.once("response", resolve13).once("error", reject).end();
       });
       req2.then = promise.then.bind(promise);
       return req2;
@@ -84341,7 +84943,7 @@ var require_parse_proxy_response = __commonJS({
     var debug_1 = __importDefault(require_src());
     var debug = (0, debug_1.default)("https-proxy-agent:parse-proxy-response");
     function parseProxyResponse(socket) {
-      return new Promise((resolve12, reject) => {
+      return new Promise((resolve13, reject) => {
         let buffersLength = 0;
         const buffers = [];
         function read() {
@@ -84407,7 +85009,7 @@ var require_parse_proxy_response = __commonJS({
           }
           debug("got proxy server response: %o %o", firstLine2, headers);
           cleanup();
-          resolve12({
+          resolve13({
             connect: {
               statusCode,
               statusText,
@@ -84649,7 +85251,7 @@ var require_ponyfill_es2018 = __commonJS({
         return new originalPromise(executor);
       }
       function promiseResolvedWith(value2) {
-        return newPromise((resolve12) => resolve12(value2));
+        return newPromise((resolve13) => resolve13(value2));
       }
       function promiseRejectedWith(reason) {
         return originalPromiseReject(reason);
@@ -84819,8 +85421,8 @@ var require_ponyfill_es2018 = __commonJS({
         return new TypeError("Cannot " + name + " a stream using a released reader");
       }
       function defaultReaderClosedPromiseInitialize(reader) {
-        reader._closedPromise = newPromise((resolve12, reject) => {
-          reader._closedPromise_resolve = resolve12;
+        reader._closedPromise = newPromise((resolve13, reject) => {
+          reader._closedPromise_resolve = resolve13;
           reader._closedPromise_reject = reject;
         });
       }
@@ -84994,8 +85596,8 @@ var require_ponyfill_es2018 = __commonJS({
           }
           let resolvePromise;
           let rejectPromise;
-          const promise = newPromise((resolve12, reject) => {
-            resolvePromise = resolve12;
+          const promise = newPromise((resolve13, reject) => {
+            resolvePromise = resolve13;
             rejectPromise = reject;
           });
           const readRequest = {
@@ -85100,8 +85702,8 @@ var require_ponyfill_es2018 = __commonJS({
           const reader = this._reader;
           let resolvePromise;
           let rejectPromise;
-          const promise = newPromise((resolve12, reject) => {
-            resolvePromise = resolve12;
+          const promise = newPromise((resolve13, reject) => {
+            resolvePromise = resolve13;
             rejectPromise = reject;
           });
           const readRequest = {
@@ -86120,8 +86722,8 @@ var require_ponyfill_es2018 = __commonJS({
           }
           let resolvePromise;
           let rejectPromise;
-          const promise = newPromise((resolve12, reject) => {
-            resolvePromise = resolve12;
+          const promise = newPromise((resolve13, reject) => {
+            resolvePromise = resolve13;
             rejectPromise = reject;
           });
           const readIntoRequest = {
@@ -86433,10 +87035,10 @@ var require_ponyfill_es2018 = __commonJS({
           wasAlreadyErroring = true;
           reason = void 0;
         }
-        const promise = newPromise((resolve12, reject) => {
+        const promise = newPromise((resolve13, reject) => {
           stream12._pendingAbortRequest = {
             _promise: void 0,
-            _resolve: resolve12,
+            _resolve: resolve13,
             _reject: reject,
             _reason: reason,
             _wasAlreadyErroring: wasAlreadyErroring
@@ -86453,9 +87055,9 @@ var require_ponyfill_es2018 = __commonJS({
         if (state3 === "closed" || state3 === "errored") {
           return promiseRejectedWith(new TypeError(`The stream (in ${state3} state) is not in the writable state and cannot be closed`));
         }
-        const promise = newPromise((resolve12, reject) => {
+        const promise = newPromise((resolve13, reject) => {
           const closeRequest = {
-            _resolve: resolve12,
+            _resolve: resolve13,
             _reject: reject
           };
           stream12._closeRequest = closeRequest;
@@ -86468,9 +87070,9 @@ var require_ponyfill_es2018 = __commonJS({
         return promise;
       }
       function WritableStreamAddWriteRequest(stream12) {
-        const promise = newPromise((resolve12, reject) => {
+        const promise = newPromise((resolve13, reject) => {
           const writeRequest = {
-            _resolve: resolve12,
+            _resolve: resolve13,
             _reject: reject
           };
           stream12._writeRequests.push(writeRequest);
@@ -87086,8 +87688,8 @@ var require_ponyfill_es2018 = __commonJS({
         return new TypeError("Cannot " + name + " a stream using a released writer");
       }
       function defaultWriterClosedPromiseInitialize(writer) {
-        writer._closedPromise = newPromise((resolve12, reject) => {
-          writer._closedPromise_resolve = resolve12;
+        writer._closedPromise = newPromise((resolve13, reject) => {
+          writer._closedPromise_resolve = resolve13;
           writer._closedPromise_reject = reject;
           writer._closedPromiseState = "pending";
         });
@@ -87123,8 +87725,8 @@ var require_ponyfill_es2018 = __commonJS({
         writer._closedPromiseState = "resolved";
       }
       function defaultWriterReadyPromiseInitialize(writer) {
-        writer._readyPromise = newPromise((resolve12, reject) => {
-          writer._readyPromise_resolve = resolve12;
+        writer._readyPromise = newPromise((resolve13, reject) => {
+          writer._readyPromise_resolve = resolve13;
           writer._readyPromise_reject = reject;
         });
         writer._readyPromiseState = "pending";
@@ -87211,7 +87813,7 @@ var require_ponyfill_es2018 = __commonJS({
         source._disturbed = true;
         let shuttingDown = false;
         let currentWrite = promiseResolvedWith(void 0);
-        return newPromise((resolve12, reject) => {
+        return newPromise((resolve13, reject) => {
           let abortAlgorithm;
           if (signal !== void 0) {
             abortAlgorithm = () => {
@@ -87356,7 +87958,7 @@ var require_ponyfill_es2018 = __commonJS({
             if (isError) {
               reject(error);
             } else {
-              resolve12(void 0);
+              resolve13(void 0);
             }
             return null;
           }
@@ -87637,8 +88239,8 @@ var require_ponyfill_es2018 = __commonJS({
         let branch1;
         let branch2;
         let resolveCancelPromise;
-        const cancelPromise = newPromise((resolve12) => {
-          resolveCancelPromise = resolve12;
+        const cancelPromise = newPromise((resolve13) => {
+          resolveCancelPromise = resolve13;
         });
         function pullAlgorithm() {
           if (reading) {
@@ -87729,8 +88331,8 @@ var require_ponyfill_es2018 = __commonJS({
         let branch1;
         let branch2;
         let resolveCancelPromise;
-        const cancelPromise = newPromise((resolve12) => {
-          resolveCancelPromise = resolve12;
+        const cancelPromise = newPromise((resolve13) => {
+          resolveCancelPromise = resolve13;
         });
         function forwardReaderError(thisReader) {
           uponRejection(thisReader._closedPromise, (r2) => {
@@ -88510,8 +89112,8 @@ var require_ponyfill_es2018 = __commonJS({
           const writableHighWaterMark = ExtractHighWaterMark(writableStrategy, 1);
           const writableSizeAlgorithm = ExtractSizeAlgorithm(writableStrategy);
           let startPromise_resolve;
-          const startPromise = newPromise((resolve12) => {
-            startPromise_resolve = resolve12;
+          const startPromise = newPromise((resolve13) => {
+            startPromise_resolve = resolve13;
           });
           InitializeTransformStream(this, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark, readableSizeAlgorithm);
           SetUpTransformStreamDefaultControllerFromTransformer(this, transformer);
@@ -88604,8 +89206,8 @@ var require_ponyfill_es2018 = __commonJS({
         if (stream12._backpressureChangePromise !== void 0) {
           stream12._backpressureChangePromise_resolve();
         }
-        stream12._backpressureChangePromise = newPromise((resolve12) => {
-          stream12._backpressureChangePromise_resolve = resolve12;
+        stream12._backpressureChangePromise = newPromise((resolve13) => {
+          stream12._backpressureChangePromise_resolve = resolve13;
         });
         stream12._backpressure = backpressure;
       }
@@ -88773,8 +89375,8 @@ var require_ponyfill_es2018 = __commonJS({
           return controller._finishPromise;
         }
         const readable = stream12._readable;
-        controller._finishPromise = newPromise((resolve12, reject) => {
-          controller._finishPromise_resolve = resolve12;
+        controller._finishPromise = newPromise((resolve13, reject) => {
+          controller._finishPromise_resolve = resolve13;
           controller._finishPromise_reject = reject;
         });
         const cancelPromise = controller._cancelAlgorithm(reason);
@@ -88800,8 +89402,8 @@ var require_ponyfill_es2018 = __commonJS({
           return controller._finishPromise;
         }
         const readable = stream12._readable;
-        controller._finishPromise = newPromise((resolve12, reject) => {
-          controller._finishPromise_resolve = resolve12;
+        controller._finishPromise = newPromise((resolve13, reject) => {
+          controller._finishPromise_resolve = resolve13;
           controller._finishPromise_reject = reject;
         });
         const flushPromise = controller._flushAlgorithm();
@@ -88831,8 +89433,8 @@ var require_ponyfill_es2018 = __commonJS({
           return controller._finishPromise;
         }
         const writable = stream12._writable;
-        controller._finishPromise = newPromise((resolve12, reject) => {
-          controller._finishPromise_resolve = resolve12;
+        controller._finishPromise = newPromise((resolve13, reject) => {
+          controller._finishPromise_resolve = resolve13;
           controller._finishPromise_reject = reject;
         });
         const cancelPromise = controller._cancelAlgorithm(reason);
@@ -89370,8 +89972,8 @@ var require_node_domexception = __commonJS({
 });
 
 // node_modules/.pnpm/fetch-blob@3.2.0/node_modules/fetch-blob/from.js
-import { statSync as statSync2, createReadStream as createReadStream2, promises as fs5 } from "node:fs";
-import { basename as basename6 } from "node:path";
+import { statSync as statSync3, createReadStream as createReadStream2, promises as fs5 } from "node:fs";
+import { basename as basename9 } from "node:path";
 var import_node_domexception, stat2, blobFromSync, blobFrom, fileFrom, fileFromSync, fromBlob, fromFile, BlobDataItem;
 var init_from = __esm({
   "node_modules/.pnpm/fetch-blob@3.2.0/node_modules/fetch-blob/from.js"() {
@@ -89379,10 +89981,10 @@ var init_from = __esm({
     init_file();
     init_fetch_blob();
     ({ stat: stat2 } = fs5);
-    blobFromSync = (path8, type) => fromBlob(statSync2(path8), path8, type);
+    blobFromSync = (path8, type) => fromBlob(statSync3(path8), path8, type);
     blobFrom = (path8, type) => stat2(path8).then((stat7) => fromBlob(stat7, path8, type));
     fileFrom = (path8, type) => stat2(path8).then((stat7) => fromFile(stat7, path8, type));
-    fileFromSync = (path8, type) => fromFile(statSync2(path8), path8, type);
+    fileFromSync = (path8, type) => fromFile(statSync3(path8), path8, type);
     fromBlob = (stat7, path8, type = "") => new fetch_blob_default([new BlobDataItem({
       path: path8,
       size: stat7.size,
@@ -89394,7 +89996,7 @@ var init_from = __esm({
       size: stat7.size,
       lastModified: stat7.mtimeMs,
       start: 0
-    })], basename6(path8), { type, lastModified: stat7.mtimeMs });
+    })], basename9(path8), { type, lastModified: stat7.mtimeMs });
     BlobDataItem = class _BlobDataItem {
       #path;
       #start;
@@ -90783,7 +91385,7 @@ import zlib from "node:zlib";
 import Stream4, { PassThrough as PassThrough2, pipeline as pump } from "node:stream";
 import { Buffer as Buffer3 } from "node:buffer";
 async function fetch2(url, options_) {
-  return new Promise((resolve12, reject) => {
+  return new Promise((resolve13, reject) => {
     const request = new Request2(url, options_);
     const { parsedURL, options } = getNodeRequestOptions(request);
     if (!supportedSchemas.has(parsedURL.protocol)) {
@@ -90792,7 +91394,7 @@ async function fetch2(url, options_) {
     if (parsedURL.protocol === "data:") {
       const data = dist_default(request.url);
       const response2 = new Response2(data, { headers: { "Content-Type": data.typeFull } });
-      resolve12(response2);
+      resolve13(response2);
       return;
     }
     const send = (parsedURL.protocol === "https:" ? https : http2).request;
@@ -90914,7 +91516,7 @@ async function fetch2(url, options_) {
             if (responseReferrerPolicy) {
               requestOptions.referrerPolicy = responseReferrerPolicy;
             }
-            resolve12(fetch2(new Request2(locationURL, requestOptions)));
+            resolve13(fetch2(new Request2(locationURL, requestOptions)));
             finalize();
             return;
           }
@@ -90947,7 +91549,7 @@ async function fetch2(url, options_) {
       const codings = headers.get("Content-Encoding");
       if (!request.compress || request.method === "HEAD" || codings === null || response_.statusCode === 204 || response_.statusCode === 304) {
         response = new Response2(body, responseOptions);
-        resolve12(response);
+        resolve13(response);
         return;
       }
       const zlibOptions = {
@@ -90961,7 +91563,7 @@ async function fetch2(url, options_) {
           }
         });
         response = new Response2(body, responseOptions);
-        resolve12(response);
+        resolve13(response);
         return;
       }
       if (codings === "deflate" || codings === "x-deflate") {
@@ -90985,12 +91587,12 @@ async function fetch2(url, options_) {
             });
           }
           response = new Response2(body, responseOptions);
-          resolve12(response);
+          resolve13(response);
         });
         raw.once("end", () => {
           if (!response) {
             response = new Response2(body, responseOptions);
-            resolve12(response);
+            resolve13(response);
           }
         });
         return;
@@ -91002,11 +91604,11 @@ async function fetch2(url, options_) {
           }
         });
         response = new Response2(body, responseOptions);
-        resolve12(response);
+        resolve13(response);
         return;
       }
       response = new Response2(body, responseOptions);
-      resolve12(response);
+      resolve13(response);
     });
     writeToStream(request_, request).catch(reject);
   });
@@ -91078,7 +91680,7 @@ var require_gaxios = __commonJS({
     var retry_js_1 = require_retry3();
     var stream_1 = __require("stream");
     var interceptor_js_1 = require_interceptor();
-    var randomUUID2 = async () => globalThis.crypto?.randomUUID() || (await import("crypto")).randomUUID();
+    var randomUUID4 = async () => globalThis.crypto?.randomUUID() || (await import("crypto")).randomUUID();
     var HTTP_STATUS_NO_CONTENT = 204;
     var Gaxios = class {
       agentCache = /* @__PURE__ */ new Map();
@@ -91351,7 +91953,7 @@ var require_gaxios = __commonJS({
          */
         ["Blob", "File", "FormData"].includes(opts.data?.constructor?.name || "");
         if (opts.multipart?.length) {
-          const boundary = await randomUUID2();
+          const boundary = await randomUUID4();
           preparedHeaders.set("content-type", `multipart/related; boundary=${boundary}`);
           opts.body = stream_1.Readable.from(this.getMultipartRequest(opts.multipart, boundary));
         } else if (shouldDirectlyPassData) {
@@ -97074,7 +97676,7 @@ var require_jwtaccess = __commonJS({
         }
       }
       fromStreamAsync(inputStream) {
-        return new Promise((resolve12, reject) => {
+        return new Promise((resolve13, reject) => {
           if (!inputStream) {
             reject(new Error("Must pass in a stream containing the service account auth settings."));
           }
@@ -97083,7 +97685,7 @@ var require_jwtaccess = __commonJS({
             try {
               const data = JSON.parse(s2);
               this.fromJSON(data);
-              resolve12();
+              resolve13();
             } catch (err2) {
               reject(err2);
             }
@@ -97322,7 +97924,7 @@ var require_jwtclient = __commonJS({
         }
       }
       fromStreamAsync(inputStream) {
-        return new Promise((resolve12, reject) => {
+        return new Promise((resolve13, reject) => {
           if (!inputStream) {
             throw new Error("Must pass in a stream containing the service account auth settings.");
           }
@@ -97331,7 +97933,7 @@ var require_jwtclient = __commonJS({
             try {
               const data = JSON.parse(s2);
               this.fromJSON(data);
-              resolve12();
+              resolve13();
             } catch (e2) {
               reject(e2);
             }
@@ -97464,7 +98066,7 @@ var require_refreshclient = __commonJS({
         }
       }
       async fromStreamAsync(inputStream) {
-        return new Promise((resolve12, reject) => {
+        return new Promise((resolve13, reject) => {
           if (!inputStream) {
             return reject(new Error("Must pass in a stream containing the user refresh token."));
           }
@@ -97473,7 +98075,7 @@ var require_refreshclient = __commonJS({
             try {
               const data = JSON.parse(s2);
               this.fromJSON(data);
-              return resolve12();
+              return resolve13();
             } catch (err2) {
               return reject(err2);
             }
@@ -99306,7 +99908,7 @@ var require_pluggable_auth_handler = __commonJS({
        * @return A promise that resolves with the executable response.
        */
       retrieveResponseFromExecutable(envMap) {
-        return new Promise((resolve12, reject) => {
+        return new Promise((resolve13, reject) => {
           const child = childProcess.spawn(this.commandComponents[0], this.commandComponents.slice(1), {
             env: { ...process.env, ...Object.fromEntries(envMap) }
           });
@@ -99328,7 +99930,7 @@ var require_pluggable_auth_handler = __commonJS({
               try {
                 const responseJson = JSON.parse(output);
                 const response = new executable_response_1.ExecutableResponse(responseJson);
-                return resolve12(response);
+                return resolve13(response);
               } catch (error) {
                 if (error instanceof executable_response_1.ExecutableResponseError) {
                   return reject(error);
@@ -100520,7 +101122,7 @@ var require_googleauth = __commonJS({
         }
       }
       fromStreamAsync(inputStream, options) {
-        return new Promise((resolve12, reject) => {
+        return new Promise((resolve13, reject) => {
           if (!inputStream) {
             throw new Error("Must pass in a stream containing the Google auth settings.");
           }
@@ -100530,7 +101132,7 @@ var require_googleauth = __commonJS({
               try {
                 const data = JSON.parse(chunks.join(""));
                 const r2 = this._cacheClientFromJSON(data, options);
-                return resolve12(r2);
+                return resolve13(r2);
               } catch (err2) {
                 if (!this.keyFilename)
                   throw err2;
@@ -100540,7 +101142,7 @@ var require_googleauth = __commonJS({
                 });
                 this.cachedCredential = client;
                 this.setGapicJWTValues(client);
-                return resolve12(client);
+                return resolve13(client);
               }
             } catch (err2) {
               return reject(err2);
@@ -100576,17 +101178,17 @@ var require_googleauth = __commonJS({
        * Run the Google Cloud SDK command that prints the default project ID
        */
       async getDefaultServiceProjectId() {
-        return new Promise((resolve12) => {
+        return new Promise((resolve13) => {
           (0, child_process_1.exec)("gcloud config config-helper --format json", (err2, stdout) => {
             if (!err2 && stdout) {
               try {
                 const projectId = JSON.parse(stdout).configuration.properties.core.project;
-                resolve12(projectId);
+                resolve13(projectId);
                 return;
               } catch (e2) {
               }
             }
-            resolve12(null);
+            resolve13(null);
           });
         });
       }
@@ -108311,14 +108913,14 @@ function __asyncValues(o) {
   }, i2);
   function verb(n) {
     i2[n] = o[n] && function(v2) {
-      return new Promise(function(resolve12, reject) {
-        v2 = o[n](v2), settle(resolve12, reject, v2.done, v2.value);
+      return new Promise(function(resolve13, reject) {
+        v2 = o[n](v2), settle(resolve13, reject, v2.done, v2.value);
       });
     };
   }
-  function settle(resolve12, reject, d, v2) {
+  function settle(resolve13, reject, d, v2) {
     Promise.resolve(v2).then(function(v3) {
-      resolve12({ value: v3, done: d });
+      resolve13({ value: v3, done: d });
     }, reject);
   }
 }
@@ -115238,7 +115840,7 @@ function retryIntervalFromResponse(res) {
   return 0;
 }
 async function delay(delay2) {
-  return new Promise((resolve12) => setTimeout(resolve12, delay2));
+  return new Promise((resolve13) => setTimeout(resolve13, delay2));
 }
 async function logRequest(logger, req) {
   if (!logger) {
@@ -122560,8 +123162,8 @@ var init_node3 = __esm({
         const url = `${websocketBaseUrl}/ws/google.ai.generativelanguage.${apiVersion}.GenerativeService.BidiGenerateMusic?key=${apiKey}`;
         let onopenResolve = () => {
         };
-        const onopenPromise = new Promise((resolve12) => {
-          onopenResolve = resolve12;
+        const onopenPromise = new Promise((resolve13) => {
+          onopenResolve = resolve13;
         });
         const callbacks = params.callbacks;
         const onopenAwaitedCallback = function() {
@@ -122767,8 +123369,8 @@ var init_node3 = __esm({
         }
         let onopenResolve = () => {
         };
-        const onopenPromise = new Promise((resolve12) => {
-          onopenResolve = resolve12;
+        const onopenPromise = new Promise((resolve13) => {
+          onopenResolve = resolve13;
         });
         const callbacks = params.callbacks;
         const onopenAwaitedCallback = function() {
@@ -122781,8 +123383,8 @@ var init_node3 = __esm({
         const messageQueue = [];
         let setupCompleteResolve = () => {
         };
-        const setupCompletePromise = new Promise((resolve12) => {
-          setupCompleteResolve = resolve12;
+        const setupCompletePromise = new Promise((resolve13) => {
+          setupCompleteResolve = resolve13;
         });
         const websocketCallbacks = {
           onopen: onopenAwaitedCallback,
@@ -129143,12 +129745,12 @@ function validateRetryDelayMs(delayMs, options) {
   return delayMs;
 }
 function sleep4(ms, signal) {
-  return new Promise((resolve12, reject) => {
+  return new Promise((resolve13, reject) => {
     if (signal?.aborted) {
       reject(new Error("Request was aborted"));
       return;
     }
-    const timeout = setTimeout(resolve12, ms);
+    const timeout = setTimeout(resolve13, ms);
     signal?.addEventListener("abort", () => {
       clearTimeout(timeout);
       reject(new Error("Request was aborted"));
@@ -129536,7 +130138,7 @@ async function connectWebSocket(url, headers, signal, connectTimeoutMs = DEFAULT
   }
   const wsHeaders = headersToRecord(headers);
   delete wsHeaders["OpenAI-Beta"];
-  return new Promise((resolve12, reject) => {
+  return new Promise((resolve13, reject) => {
     let settled = false;
     let timeout;
     let socket;
@@ -129571,7 +130173,7 @@ async function connectWebSocket(url, headers, signal, connectTimeoutMs = DEFAULT
         return;
       settled = true;
       cleanup();
-      resolve12(socket);
+      resolve13(socket);
     };
     const onError = (event) => {
       fail2(extractWebSocketError(event));
@@ -129747,9 +130349,9 @@ async function* parseWebSocket(socket, signal, idleTimeoutMs) {
   const wake = () => {
     if (!pending)
       return;
-    const resolve12 = pending;
+    const resolve13 = pending;
     pending = null;
-    resolve12();
+    resolve13();
   };
   const onMessage = (event) => {
     void (async () => {
@@ -129816,8 +130418,8 @@ async function* parseWebSocket(socket, signal, idleTimeoutMs) {
       if (done)
         break;
       let timeout;
-      await new Promise((resolve12, reject) => {
-        pending = resolve12;
+      await new Promise((resolve13, reject) => {
+        pending = resolve13;
         if (idleTimeoutMs !== void 0 && idleTimeoutMs > 0) {
           timeout = setTimeout(() => {
             const error = new Error(`WebSocket idle timeout after ${idleTimeoutMs}ms`);
@@ -133927,7 +134529,7 @@ function timeoutError(timeoutMs) {
   error.body = "";
   return error;
 }
-function isRecord2(value2) {
+function isRecord3(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
 }
 function requiredNumber(label, value2, field2) {
@@ -133937,7 +134539,7 @@ function requiredNumber(label, value2, field2) {
   return value2;
 }
 function probabilities(label, value2, id) {
-  if (!isRecord2(value2))
+  if (!isRecord3(value2))
     throw new Error(`${label} returned invalid probabilities for ${id}`);
   return Object.fromEntries(Object.entries(value2).map(([key, probability]) => [
     key,
@@ -133945,12 +134547,12 @@ function probabilities(label, value2, id) {
   ]));
 }
 function parseAnswers(label, value2, context) {
-  if (!isRecord2(value2))
+  if (!isRecord3(value2))
     throw new Error(`${label} returned an unexpected response`);
   const answers = [];
   for (const [id, question] of Object.entries(context.questions)) {
     const answer = value2[id];
-    if (!isRecord2(answer))
+    if (!isRecord3(answer))
       throw new Error(`${label} did not return an answer for ${id}`);
     if (question.type === "choice") {
       if (answer.type !== "choice" || typeof answer.choice !== "string") {
@@ -133994,7 +134596,7 @@ function tokenCount(value2) {
   return typeof value2 === "number" && Number.isFinite(value2) && value2 > 0 ? value2 : 0;
 }
 function parseUsage2(value2, model) {
-  if (!isRecord2(value2) || value2.input_tokens === void 0 && value2.output_tokens === void 0)
+  if (!isRecord3(value2) || value2.input_tokens === void 0 && value2.output_tokens === void 0)
     return void 0;
   const input = tokenCount(value2.input_tokens);
   const output = tokenCount(value2.output_tokens);
@@ -134093,7 +134695,7 @@ __export(cloudflare_workers_ai_system_one_exports, {
 });
 function cloudflareErrorMessage(errors) {
   if (Array.isArray(errors)) {
-    const messages = errors.map((error) => isRecord2(error) && typeof error.message === "string" ? error.message : void 0).filter((message) => message !== void 0);
+    const messages = errors.map((error) => isRecord3(error) && typeof error.message === "string" ? error.message : void 0).filter((message) => message !== void 0);
     if (messages.length > 0)
       return `${LABEL} error: ${messages.join("; ")}`;
   }
@@ -134110,17 +134712,17 @@ var init_cloudflare_workers_ai_system_one = __esm({
       url: (model) => new URL("run", `${model.baseUrl.replace(/\/+$/u, "")}/`),
       payload: (model, request) => ({ model: model.id, input: request }),
       output: (body) => {
-        if (!isRecord2(body))
+        if (!isRecord3(body))
           throw new Error(`${LABEL} returned an unexpected response`);
         if (body.success === false)
           throw new Error(cloudflareErrorMessage(body.errors));
         const run = body.result;
-        if (!isRecord2(run))
+        if (!isRecord3(run))
           throw new Error(`${LABEL} returned an unexpected response`);
         if (run.state !== "Completed") {
           throw new Error(`${LABEL} run did not complete (state: ${String(run.state)})`);
         }
-        if (!isRecord2(run.result))
+        if (!isRecord3(run.result))
           throw new Error(`${LABEL} returned an unexpected response`);
         return run.result;
       }
@@ -134650,7 +135252,7 @@ var init_typesafe_system_one = __esm({
       url: (model) => new URL("systemone", `${model.baseUrl.replace(/\/+$/u, "")}/`),
       payload: (model, request) => ({ model: model.id, ...request }),
       output: (body) => {
-        if (!isRecord2(body))
+        if (!isRecord3(body))
           throw new Error("System One API returned an unexpected response");
         return body;
       }
@@ -138769,7 +139371,7 @@ var init_terminal_colors = __esm({
 // node_modules/.pnpm/@earendil-works+pi-tui@0.99.1/node_modules/@earendil-works/pi-tui/dist/terminal-image.js
 import { execSync } from "node:child_process";
 import { homedir as homedir4 } from "node:os";
-import { isAbsolute as isAbsolute4 } from "node:path";
+import { isAbsolute as isAbsolute5 } from "node:path";
 import { pathToFileURL } from "node:url";
 function setCellDimensions(dims) {
   cellDimensions = dims;
@@ -139074,7 +139676,7 @@ function imageFallback(mimeType, dimensions, filename) {
   const parts = [];
   if (filename) {
     const display = shortenImagePath(filename);
-    if (getCapabilities().hyperlinks && isAbsolute4(filename)) {
+    if (getCapabilities().hyperlinks && isAbsolute5(filename)) {
       parts.push(hyperlink(display, pathToFileURL(filename).href));
     } else {
       parts.push(display);
@@ -140043,16 +140645,16 @@ var init_tui = __esm({
        * @param onLateReply Receives the replies if the query completes after the timeout, e.g. over slow links.
        */
       queryTerminalColors({ timeoutMs, onLateReply }) {
-        return new Promise((resolve12) => {
+        return new Promise((resolve13) => {
           const query = {
             palette: Array.from({ length: TERMINAL_PALETTE_SIZE }, () => void 0),
             replied: /* @__PURE__ */ new Set(),
-            deliver: resolve12,
+            deliver: resolve13,
             timer: void 0
           };
           query.timer = setTimeout(() => {
             query.deliver = onLateReply;
-            resolve12(this.terminalColorQueryResult(query));
+            resolve13(this.terminalColorQueryResult(query));
           }, timeoutMs);
           this.pendingTerminalColorQueries.push(query);
           this.terminal.write(TERMINAL_COLOR_QUERY);
@@ -143074,10 +143676,10 @@ var init_tui_alt_screen = __esm({
             this.mousePressMoved = true;
             this.lastComponentClick = void 0;
           }
-          let render = false;
+          let render2 = false;
           const targetResult = this.dispatchMouseToTarget(event, target);
           if (targetResult)
-            render = this.applyMouseDispatchResult(event, targetResult);
+            render2 = this.applyMouseDispatchResult(event, targetResult);
           if (raw.release) {
             if (!this.mousePressMoved && this.mousePressPoint?.x === raw.x && this.mousePressPoint.y === raw.y) {
               const clickEvent = this.createMouseEvent("click", raw.button, raw.x, raw.y, {
@@ -143085,11 +143687,11 @@ var init_tui_alt_screen = __esm({
               });
               const clickResult = this.dispatchMouseToTarget(clickEvent, target);
               if (clickResult)
-                render = this.applyMouseDispatchResult(clickEvent, clickResult) || render;
+                render2 = this.applyMouseDispatchResult(clickEvent, clickResult) || render2;
             }
             this.clearComponentMouseGesture();
           }
-          if (render)
+          if (render2)
             this.requestRender();
           return;
         }
@@ -143109,14 +143711,14 @@ var init_tui_alt_screen = __esm({
         }
         const result = overlay.result ?? (overlay.hit ? void 0 : this.dispatchMouseToLayout(event));
         if (result) {
-          const render = this.applyMouseDispatchResult(event, result);
+          const render2 = this.applyMouseDispatchResult(event, result);
           if (type === "press") {
             this.clearTextSelection();
             this.mousePressTarget = result.target;
             this.mousePressPoint = { x: raw.x, y: raw.y };
             this.mousePressMoved = false;
           }
-          if (render)
+          if (render2)
             this.requestRender();
           return;
         }
@@ -143459,9 +144061,9 @@ var init_tui_alt_screen = __esm({
             const overlay = this.dispatchMouseToOverlay(clickEvent);
             const result = overlay.result ?? (overlay.hit ? void 0 : this.dispatchMouseToLayout(clickEvent));
             if (result) {
-              const render = this.applyMouseDispatchResult(clickEvent, result);
+              const render2 = this.applyMouseDispatchResult(clickEvent, result);
               this.clearTextSelection();
-              if (render)
+              if (render2)
                 this.requestRender();
               return;
             }
@@ -144134,7 +144736,7 @@ var require_core = __commonJS({
       return match3 && match3.index === 0;
     }
     var BACKREF_RE = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./;
-    function join23(regexps, separator = "|") {
+    function join25(regexps, separator = "|") {
       let numCaptures = 0;
       return regexps.map((regex2) => {
         numCaptures += 1;
@@ -144438,7 +145040,7 @@ var require_core = __commonJS({
             this.exec = () => null;
           }
           const terminators = this.regexes.map((el) => el[1]);
-          this.matcherRe = langRe(join23(terminators), true);
+          this.matcherRe = langRe(join25(terminators), true);
           this.lastIndex = 0;
         }
         /** @param {string} s */
@@ -144733,7 +145335,7 @@ var require_core = __commonJS({
       function close(node) {
         result += "</" + tag(node) + ">";
       }
-      function render(event) {
+      function render2(event) {
         (event.event === "start" ? open3 : close)(event.node);
       }
       while (original.length || highlighted.length) {
@@ -144743,7 +145345,7 @@ var require_core = __commonJS({
         if (stream12 === original) {
           nodeStack.reverse().forEach(close);
           do {
-            render(stream12.splice(0, 1)[0]);
+            render2(stream12.splice(0, 1)[0]);
             stream12 = selectStream();
           } while (stream12 === original && stream12.length && stream12[0].offset === processed);
           nodeStack.reverse().forEach(open3);
@@ -144753,7 +145355,7 @@ var require_core = __commonJS({
           } else {
             nodeStack.pop();
           }
-          render(stream12.splice(0, 1)[0]);
+          render2(stream12.splice(0, 1)[0]);
         }
       }
       return result + escapeHTML(value2.substr(processed));
@@ -151766,7 +152368,7 @@ var init_ansi = __esm({
 });
 
 // node_modules/.pnpm/@earendil-works+pi-coding-agent@0.99.1_@aws-sdk+credential-provider-node@3.972.83_@smit_1f563b9fb7db4619e2913cc40d230799/node_modules/@earendil-works/pi-coding-agent/dist/utils/shell.js
-import { existsSync as existsSync3 } from "node:fs";
+import { existsSync as existsSync2 } from "node:fs";
 import { spawn as spawn2, spawnSync } from "child_process";
 function isLegacyWslBashPath(path8) {
   const normalized = path8.replace(/\//g, "\\").toLowerCase();
@@ -151785,7 +152387,7 @@ function findExecutableOnPath(executable) {
       });
       if (result.status === 0 && result.stdout) {
         const firstMatch = result.stdout.trim().split(/\r?\n/)[0];
-        if (firstMatch && existsSync3(firstMatch)) {
+        if (firstMatch && existsSync2(firstMatch)) {
           return firstMatch;
         }
       }
@@ -151807,7 +152409,7 @@ function findExecutableOnPath(executable) {
 }
 function getShellConfig(customShellPath) {
   if (customShellPath) {
-    if (existsSync3(customShellPath)) {
+    if (existsSync2(customShellPath)) {
       return getBashShellConfig(customShellPath);
     }
     throw new Error(`Custom shell path not found: ${customShellPath}`);
@@ -151823,7 +152425,7 @@ function getShellConfig(customShellPath) {
       paths.push(`${programFilesX86}\\Git\\bin\\bash.exe`);
     }
     for (const path8 of paths) {
-      if (existsSync3(path8)) {
+      if (existsSync2(path8)) {
         return getBashShellConfig(path8);
       }
     }
@@ -151839,7 +152441,7 @@ function getShellConfig(customShellPath) {
 Searched Git Bash in:
 ${paths.map((p) => `  ${p}`).join("\n")}`);
   }
-  if (existsSync3("/bin/bash")) {
+  if (existsSync2("/bin/bash")) {
     return getBashShellConfig("/bin/bash");
   }
   const bashOnPath = findExecutableOnPath("bash");
@@ -152107,16 +152709,16 @@ function isLoopbackRedirectUri(value2) {
   const url = new URL(value2);
   return url.protocol === "http:" && LOOPBACK_HOSTS.includes(url.hostname) && url.search === "" && url.hash === "";
 }
-function isRecord3(value2) {
+function isRecord4(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
 }
 function isStringRecord(value2) {
-  return isRecord3(value2) && Object.values(value2).every((entry) => typeof entry === "string");
+  return isRecord4(value2) && Object.values(value2).every((entry) => typeof entry === "string");
 }
 function validateOAuth(value2) {
   if (value2 === void 0)
     return void 0;
-  if (!isRecord3(value2))
+  if (!isRecord4(value2))
     return "oauth must be an object";
   if (value2.clientId !== void 0 && typeof value2.clientId !== "string")
     return "oauth.clientId must be a string";
@@ -152161,7 +152763,7 @@ function getMcpToolExposure(config, toolName2) {
 function validateMcpServerConfig(name, value2) {
   if (!SERVER_NAME.test(name))
     return `invalid server name "${name}" (use letters, digits, "_" and "-")`;
-  if (!isRecord3(value2))
+  if (!isRecord4(value2))
     return `server "${name}" must be an object`;
   const { type, exposure, enabled, timeout, toolExposure } = value2;
   const exposures = MCP_EXPOSURES.map((value3) => `"${value3}"`).join(", ");
@@ -152169,7 +152771,7 @@ function validateMcpServerConfig(name, value2) {
     return `server "${name}": exposure must be one of ${exposures}`;
   }
   if (toolExposure !== void 0) {
-    if (!isRecord3(toolExposure))
+    if (!isRecord4(toolExposure))
       return `server "${name}": toolExposure must map tool names to exposures`;
     for (const [tool, value3] of Object.entries(toolExposure)) {
       if (!isExposure(value3))
@@ -154531,12 +155133,12 @@ var require_adapter = __commonJS({
       return newFs;
     }
     function toPromise(method) {
-      return (...args) => new Promise((resolve12, reject) => {
+      return (...args) => new Promise((resolve13, reject) => {
         args.push((err2, result) => {
           if (err2) {
             reject(err2);
           } else {
-            resolve12(result);
+            resolve13(result);
           }
         });
         method(...args);
@@ -154625,7 +155227,7 @@ function raceWithAbortSignal2(operation, signal) {
     });
     return Promise.reject(abortReason2(signal));
   }
-  return new Promise((resolve12, reject) => {
+  return new Promise((resolve13, reject) => {
     let settled = false;
     const cleanup = () => signal.removeEventListener("abort", onAbort);
     const onAbort = () => {
@@ -154641,7 +155243,7 @@ function raceWithAbortSignal2(operation, signal) {
         return;
       settled = true;
       cleanup();
-      resolve12(value2);
+      resolve13(value2);
     }, (error) => {
       if (settled)
         return;
@@ -154659,8 +155261,8 @@ var init_abort4 = __esm({
 });
 
 // node_modules/.pnpm/@earendil-works+pi-coding-agent@0.99.1_@aws-sdk+credential-provider-node@3.972.83_@smit_1f563b9fb7db4619e2913cc40d230799/node_modules/@earendil-works/pi-coding-agent/dist/core/auth-storage.js
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
-import { dirname as dirname8, join as join10 } from "path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname10, join as join12 } from "path";
 import { setTimeout as sleep6 } from "timers/promises";
 var import_proper_lockfile, AUTH_FILE_WRITE_OPTIONS, FileAuthStorageBackend;
 var init_auth_storage = __esm({
@@ -154674,18 +155276,18 @@ var init_auth_storage = __esm({
     AUTH_FILE_WRITE_OPTIONS = { encoding: "utf-8", mode: 384 };
     FileAuthStorageBackend = class {
       authPath;
-      constructor(authPath = join10(getAgentDir(), "auth.json")) {
+      constructor(authPath = join12(getAgentDir(), "auth.json")) {
         this.authPath = normalizePath(authPath);
       }
       ensureParentDir() {
-        const dir = dirname8(this.authPath);
-        if (!existsSync4(dir)) {
+        const dir = dirname10(this.authPath);
+        if (!existsSync3(dir)) {
           mkdirSync2(dir, { recursive: true, mode: 448 });
         }
       }
       ensureFileExists() {
-        if (!existsSync4(this.authPath)) {
-          writeFileSync(this.authPath, "{}", AUTH_FILE_WRITE_OPTIONS);
+        if (!existsSync3(this.authPath)) {
+          writeFileSync2(this.authPath, "{}", AUTH_FILE_WRITE_OPTIONS);
         }
       }
       acquireLockSyncWithRetry(path8) {
@@ -154714,10 +155316,10 @@ var init_auth_storage = __esm({
         let release;
         try {
           release = this.acquireLockSyncWithRetry(this.authPath);
-          const current = existsSync4(this.authPath) ? readFileSync2(this.authPath, "utf-8") : void 0;
+          const current = existsSync3(this.authPath) ? readFileSync3(this.authPath, "utf-8") : void 0;
           const { result, next } = fn(current);
           if (next !== void 0) {
-            writeFileSync(this.authPath, next, AUTH_FILE_WRITE_OPTIONS);
+            writeFileSync2(this.authPath, next, AUTH_FILE_WRITE_OPTIONS);
           }
           return result;
         } finally {
@@ -154782,12 +155384,12 @@ var init_auth_storage = __esm({
           });
           throwIfCompromised();
           options?.signal?.throwIfAborted();
-          const current = existsSync4(this.authPath) ? readFileSync2(this.authPath, "utf-8") : void 0;
+          const current = existsSync3(this.authPath) ? readFileSync3(this.authPath, "utf-8") : void 0;
           const { result, next } = await fn(current);
           throwIfCompromised();
           options?.signal?.throwIfAborted();
           if (next !== void 0) {
-            writeFileSync(this.authPath, next, AUTH_FILE_WRITE_OPTIONS);
+            writeFileSync2(this.authPath, next, AUTH_FILE_WRITE_OPTIONS);
           }
           throwIfCompromised();
           return result;
@@ -162782,9 +163384,9 @@ var require_dispatcher_base = __commonJS({
       }
       close(callback) {
         if (callback === void 0) {
-          return new Promise((resolve12, reject) => {
+          return new Promise((resolve13, reject) => {
             this.close((err2, data) => {
-              return err2 ? reject(err2) : resolve12(data);
+              return err2 ? reject(err2) : resolve13(data);
             });
           });
         }
@@ -162822,9 +163424,9 @@ var require_dispatcher_base = __commonJS({
           err2 = null;
         }
         if (callback === void 0) {
-          return new Promise((resolve12, reject) => {
+          return new Promise((resolve13, reject) => {
             this.destroy(err2, (err3, data) => {
-              return err3 ? reject(err3) : resolve12(data);
+              return err3 ? reject(err3) : resolve13(data);
             });
           });
         }
@@ -167781,12 +168383,12 @@ upgrade: ${upgrade}\r
           cb();
         }
       }
-      const waitForDrain = () => new Promise((resolve12, reject) => {
+      const waitForDrain = () => new Promise((resolve13, reject) => {
         assert(callback === null);
         if (socket[kError]) {
           reject(socket[kError]);
         } else {
-          callback = resolve12;
+          callback = resolve13;
         }
       });
       socket.on("close", onDrain).on("drain", onDrain);
@@ -169169,12 +169771,12 @@ var require_client_h2 = __commonJS({
           cb();
         }
       }
-      const waitForDrain = () => new Promise((resolve12, reject) => {
+      const waitForDrain = () => new Promise((resolve13, reject) => {
         assert(callback === null);
         if (socket[kError]) {
           reject(socket[kError]);
         } else {
-          callback = resolve12;
+          callback = resolve13;
         }
       });
       h2stream.on("close", onDrain).on("drain", onDrain);
@@ -169543,16 +170145,16 @@ var require_client = __commonJS({
         return this[kNeedDrain] < 2;
       }
       [kClose]() {
-        return new Promise((resolve12) => {
+        return new Promise((resolve13) => {
           if (this[kSize]) {
-            this[kClosedResolve] = resolve12;
+            this[kClosedResolve] = resolve13;
           } else {
-            resolve12(null);
+            resolve13(null);
           }
         });
       }
       [kDestroy](err2) {
-        return new Promise((resolve12) => {
+        return new Promise((resolve13) => {
           const requests = this[kQueue].splice(this[kPendingIdx]);
           for (let i2 = 0; i2 < requests.length; i2++) {
             const request = requests[i2];
@@ -169565,7 +170167,7 @@ var require_client = __commonJS({
               this[kClosedResolve]();
               this[kClosedResolve] = null;
             }
-            resolve12(null);
+            resolve13(null);
           };
           if (this[kHTTPContext]) {
             this[kHTTPContext].destroy(err2, callback);
@@ -169978,8 +170580,8 @@ var require_pool_base = __commonJS({
           }
           return Promise.all(closeAll);
         } else {
-          return new Promise((resolve12) => {
-            this[kClosedResolve] = resolve12;
+          return new Promise((resolve13) => {
+            this[kClosedResolve] = resolve13;
           });
         }
       }
@@ -172642,7 +173244,7 @@ var require_readable = __commonJS({
         if (this._readableState.closeEmitted) {
           return Promise.resolve(null);
         }
-        return new Promise((resolve12, reject) => {
+        return new Promise((resolve13, reject) => {
           if (this[kContentLength] && this[kContentLength] > limit3 || this[kBytesRead] > limit3) {
             this.destroy(new AbortError2());
           }
@@ -172656,11 +173258,11 @@ var require_readable = __commonJS({
               if (signal.aborted) {
                 reject(signal.reason ?? new AbortError2());
               } else {
-                resolve12(null);
+                resolve13(null);
               }
             });
           } else {
-            this.on("close", resolve12);
+            this.on("close", resolve13);
           }
           this.on("error", noop4).on("data", () => {
             if (this[kBytesRead] > limit3) {
@@ -172688,7 +173290,7 @@ var require_readable = __commonJS({
     }
     function consume(stream12, type) {
       assert(!stream12[kConsume]);
-      return new Promise((resolve12, reject) => {
+      return new Promise((resolve13, reject) => {
         if (isUnusable(stream12)) {
           const rState = stream12._readableState;
           if (rState.destroyed && rState.closeEmitted === false) {
@@ -172703,7 +173305,7 @@ var require_readable = __commonJS({
             stream12[kConsume] = {
               type,
               stream: stream12,
-              resolve: resolve12,
+              resolve: resolve13,
               reject,
               length: 0,
               body: []
@@ -172781,18 +173383,18 @@ var require_readable = __commonJS({
       return buffer;
     }
     function consumeEnd(consume2, encoding) {
-      const { type, body, resolve: resolve12, stream: stream12, length } = consume2;
+      const { type, body, resolve: resolve13, stream: stream12, length } = consume2;
       try {
         if (type === "text") {
-          resolve12(chunksDecode(body, length, encoding));
+          resolve13(chunksDecode(body, length, encoding));
         } else if (type === "json") {
-          resolve12(JSON.parse(chunksDecode(body, length, encoding)));
+          resolve13(JSON.parse(chunksDecode(body, length, encoding)));
         } else if (type === "arrayBuffer") {
-          resolve12(chunksConcat(body, length).buffer);
+          resolve13(chunksConcat(body, length).buffer);
         } else if (type === "blob") {
-          resolve12(new Blob(body, { type: stream12[kContentType] }));
+          resolve13(new Blob(body, { type: stream12[kContentType] }));
         } else if (type === "bytes") {
-          resolve12(chunksConcat(body, length));
+          resolve13(chunksConcat(body, length));
         }
         consumeFinish(consume2);
       } catch (err2) {
@@ -173011,9 +173613,9 @@ var require_api_request = __commonJS({
     };
     function request(opts, callback) {
       if (callback === void 0) {
-        return new Promise((resolve12, reject) => {
+        return new Promise((resolve13, reject) => {
           request.call(this, opts, (err2, data) => {
-            return err2 ? reject(err2) : resolve12(data);
+            return err2 ? reject(err2) : resolve13(data);
           });
         });
       }
@@ -173274,9 +173876,9 @@ var require_api_stream = __commonJS({
     };
     function stream12(opts, factory, callback) {
       if (callback === void 0) {
-        return new Promise((resolve12, reject) => {
+        return new Promise((resolve13, reject) => {
           stream12.call(this, opts, factory, (err2, data) => {
-            return err2 ? reject(err2) : resolve12(data);
+            return err2 ? reject(err2) : resolve13(data);
           });
         });
       }
@@ -173576,9 +174178,9 @@ var require_api_upgrade = __commonJS({
     };
     function upgrade(opts, callback) {
       if (callback === void 0) {
-        return new Promise((resolve12, reject) => {
+        return new Promise((resolve13, reject) => {
           upgrade.call(this, opts, (err2, data) => {
-            return err2 ? reject(err2) : resolve12(data);
+            return err2 ? reject(err2) : resolve13(data);
           });
         });
       }
@@ -173672,9 +174274,9 @@ var require_api_connect = __commonJS({
     };
     function connect(opts, callback) {
       if (callback === void 0) {
-        return new Promise((resolve12, reject) => {
+        return new Promise((resolve13, reject) => {
           connect.call(this, opts, (err2, data) => {
-            return err2 ? reject(err2) : resolve12(data);
+            return err2 ? reject(err2) : resolve13(data);
           });
         });
       }
@@ -175141,7 +175743,7 @@ var require_snapshot_recorder = __commonJS({
   "node_modules/.pnpm/undici@8.10.2/node_modules/undici/lib/mock/snapshot-recorder.js"(exports, module) {
     "use strict";
     var { writeFile: writeFile10, readFile: readFile10, mkdir: mkdir7 } = __require("node:fs/promises");
-    var { dirname: dirname16, resolve: resolve12 } = __require("node:path");
+    var { dirname: dirname18, resolve: resolve13 } = __require("node:path");
     var { setTimeout: setTimeout2, clearTimeout: clearTimeout2 } = __require("node:timers");
     var { InvalidArgumentError, UndiciError } = require_errors2();
     var { hashId, isUrlExcludedFactory, normalizeHeaders, createHeaderFilters } = require_snapshot_utils();
@@ -175357,7 +175959,7 @@ var require_snapshot_recorder = __commonJS({
           throw new InvalidArgumentError("Snapshot path is required");
         }
         try {
-          const data = await readFile10(resolve12(path8), "utf8");
+          const data = await readFile10(resolve13(path8), "utf8");
           const parsed2 = JSON.parse(data);
           if (Array.isArray(parsed2)) {
             this.#snapshots.clear();
@@ -175386,8 +175988,8 @@ var require_snapshot_recorder = __commonJS({
         if (!path8) {
           throw new InvalidArgumentError("Snapshot path is required");
         }
-        const resolvedPath = resolve12(path8);
-        await mkdir7(dirname16(resolvedPath), { recursive: true });
+        const resolvedPath = resolve13(path8);
+        await mkdir7(dirname18(resolvedPath), { recursive: true });
         const data = Array.from(this.#snapshots.entries()).map(([hash, snapshot]) => ({
           hash,
           snapshot
@@ -183050,7 +183652,7 @@ var require_fetch = __commonJS({
         const hasTrailingQuestionMark = url.search.length === 0 && url.href[url.href.length - url.hash.length - 1] === "?";
         return dispatchWithProtocolPreference(body);
         function dispatchWithProtocolPreference(body2, allowH2) {
-          return new Promise((resolve12, reject) => agent.dispatch(
+          return new Promise((resolve13, reject) => agent.dispatch(
             {
               path: hasTrailingQuestionMark ? `${path8}?` : path8,
               origin: url.origin,
@@ -183133,7 +183735,7 @@ var require_fetch = __commonJS({
                   }
                 }
                 const onError = (err2) => this.onResponseError(controller, err2);
-                resolve12({
+                resolve13({
                   status,
                   statusText,
                   headersList,
@@ -183166,7 +183768,7 @@ var require_fetch = __commonJS({
                   fetchParams.controller.off("terminated", this.abort);
                 }
                 if (request.mode === "websocket" && allowH2 !== false && error?.code === "UND_ERR_INFO" && error?.message === "HTTP/2: Extended CONNECT protocol not supported by server") {
-                  resolve12(dispatchWithProtocolPreference(body2, false));
+                  resolve13(dispatchWithProtocolPreference(body2, false));
                   return;
                 }
                 this.body?.destroy(error);
@@ -183183,7 +183785,7 @@ var require_fetch = __commonJS({
                 const rawHeaders = controller?.rawHeaders ?? [];
                 const headersList = new HeadersList();
                 appendHeadersListFromResponseHeaders(headersList, headers, rawHeaders);
-                resolve12({
+                resolve13({
                   status,
                   statusText: STATUS_CODES[status],
                   headersList,
@@ -188111,8 +188713,8 @@ var init_host = __esm({
       pending = /* @__PURE__ */ new Map();
       finished = false;
       constructor(options) {
-        this.promise = new Promise((resolve12) => {
-          this.resolveResult = resolve12;
+        this.promise = new Promise((resolve13) => {
+          this.resolveResult = resolve13;
         });
         this.tools = options.tools;
         this.globals = options.globals;
@@ -188851,7 +189453,7 @@ __export(execute_exports, {
 import { randomBytes } from "node:crypto";
 import { writeFile as writeFile4 } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join as join11 } from "node:path";
+import { join as join13 } from "node:path";
 function truncateText(text, maxChars) {
   return text.length > maxChars ? `${text.slice(0, maxChars - 3)}...` : text;
 }
@@ -188889,7 +189491,7 @@ function createLimiter(limit3) {
   const waiting = [];
   return async (run) => {
     if (active >= limit3)
-      await new Promise((resolve12) => waiting.push(resolve12));
+      await new Promise((resolve13) => waiting.push(resolve13));
     active++;
     try {
       return await run();
@@ -188936,7 +189538,7 @@ function formatError(result, calls) {
 ${formatCallSummary(calls)}`;
 }
 async function spillOutput(text) {
-  const path8 = join11(tmpdir(), `pi-codemode-${randomBytes(8).toString("hex")}.txt`);
+  const path8 = join13(tmpdir(), `pi-codemode-${randomBytes(8).toString("hex")}.txt`);
   try {
     await writeFile4(path8, text);
     return { path: path8 };
@@ -189612,23 +190214,23 @@ var init_open_browser = __esm({
 });
 
 // node_modules/.pnpm/@earendil-works+pi-coding-agent@0.99.1_@aws-sdk+credential-provider-node@3.972.83_@smit_1f563b9fb7db4619e2913cc40d230799/node_modules/@earendil-works/pi-coding-agent/dist/extensions/mcp/config.js
-import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname9, join as join12 } from "node:path";
-function isRecord4(value2) {
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname11, join as join14 } from "node:path";
+function isRecord5(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
 }
 function readConfigFile(path8, scope, state3) {
   const { servers, errors } = state3;
-  if (!existsSync5(path8))
+  if (!existsSync4(path8))
     return;
   let parsed2;
   try {
-    parsed2 = JSON.parse(readFileSync3(path8, "utf8"));
+    parsed2 = JSON.parse(readFileSync4(path8, "utf8"));
   } catch (error) {
     errors.push(`${path8}: ${error instanceof Error ? error.message : String(error)}`);
     return;
   }
-  if (!isRecord4(parsed2) || parsed2.mcpServers !== void 0 && !isRecord4(parsed2.mcpServers)) {
+  if (!isRecord5(parsed2) || parsed2.mcpServers !== void 0 && !isRecord5(parsed2.mcpServers)) {
     errors.push(`${path8}: expected an object with an "mcpServers" object`);
     return;
   }
@@ -189647,9 +190249,9 @@ function readConfigFile(path8, scope, state3) {
 }
 function loadMcpConfig(options) {
   const state3 = { servers: /* @__PURE__ */ new Map(), errors: [] };
-  readConfigFile(join12(options.agentDir, "mcp.json"), "global", state3);
+  readConfigFile(join14(options.agentDir, "mcp.json"), "global", state3);
   if (options.projectTrusted)
-    readConfigFile(join12(options.cwd, CONFIG_DIR_NAME, "mcp.json"), "project", state3);
+    readConfigFile(join14(options.cwd, CONFIG_DIR_NAME, "mcp.json"), "project", state3);
   return {
     servers: [...state3.servers.values()],
     ...state3.autoEnableCodemode === void 0 ? {} : { autoEnableCodemode: state3.autoEnableCodemode },
@@ -189659,7 +190261,7 @@ function loadMcpConfig(options) {
 function updateMcpServerConfig(path8, name, patch) {
   editMcpServers(path8, (servers) => {
     const server = servers?.[name];
-    if (!isRecord4(server))
+    if (!isRecord5(server))
       throw new Error(`${path8} does not define MCP server "${name}"`);
     if (patch.enabled !== void 0) {
       if (patch.enabled)
@@ -189677,17 +190279,17 @@ function updateMcpServerConfig(path8, name, patch) {
   });
 }
 function editMcpServers(path8, edit) {
-  const text = existsSync5(path8) ? readFileSync3(path8, "utf8") : void 0;
+  const text = existsSync4(path8) ? readFileSync4(path8, "utf8") : void 0;
   const parsed2 = text === void 0 ? {} : JSON.parse(text);
-  if (!isRecord4(parsed2) || parsed2.mcpServers !== void 0 && !isRecord4(parsed2.mcpServers)) {
+  if (!isRecord5(parsed2) || parsed2.mcpServers !== void 0 && !isRecord5(parsed2.mcpServers)) {
     throw new Error(`${path8}: expected an object with an "mcpServers" object`);
   }
-  const servers = isRecord4(parsed2.mcpServers) ? parsed2.mcpServers : void 0;
+  const servers = isRecord5(parsed2.mcpServers) ? parsed2.mcpServers : void 0;
   if (!edit(servers, parsed2))
     return;
   const indent = text && /^([ \t]+)\S/m.exec(text)?.[1] || "  ";
-  mkdirSync3(dirname9(path8), { recursive: true });
-  writeFileSync2(path8, `${JSON.stringify(parsed2, null, indent)}
+  mkdirSync3(dirname11(path8), { recursive: true });
+  writeFileSync3(path8, `${JSON.stringify(parsed2, null, indent)}
 `);
 }
 var init_config6 = __esm({
@@ -190028,9 +190630,9 @@ var init_client3 = __esm({
           method,
           ...requestParams === void 0 ? {} : { params: requestParams }
         };
-        return new Promise((resolve12, reject) => {
+        return new Promise((resolve13, reject) => {
           const entry = {
-            resolve: resolve12,
+            resolve: resolve13,
             reject,
             timeoutMs: options.timeoutMs ?? this.options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS,
             timer: void 0,
@@ -190402,10 +191004,10 @@ var init_stdio = __esm({
           this.stdoutBuffer = Buffer.alloc(0);
           this.emitClose();
         });
-        await new Promise((resolve12, reject) => {
+        await new Promise((resolve13, reject) => {
           const onSpawn = () => {
             child.off("error", onError);
-            resolve12();
+            resolve13();
           };
           const onError = (error) => {
             child.off("spawn", onSpawn);
@@ -190425,8 +191027,8 @@ var init_stdio = __esm({
           throw new McpConnectionClosedError();
         const payload = `${JSON.stringify(message)}
 `;
-        await new Promise((resolve12, reject) => {
-          stdin.write(payload, (error) => error ? reject(error) : resolve12());
+        await new Promise((resolve13, reject) => {
+          stdin.write(payload, (error) => error ? reject(error) : resolve13());
         });
       }
       async close() {
@@ -190443,13 +191045,13 @@ var init_stdio = __esm({
           return;
         }
         const closeTimeoutMs = this.options.closeTimeoutMs ?? DEFAULT_CLOSE_TIMEOUT_MS;
-        await new Promise((resolve12) => {
+        await new Promise((resolve13) => {
           const timers = [];
           child.once("close", () => {
             for (const timer of timers)
               clearTimeout(timer);
             killProcessTree2(child, "SIGTERM");
-            resolve12();
+            resolve13();
           });
           const grace = Math.min(STDIN_CLOSE_GRACE_MS, closeTimeoutMs);
           timers.push(setTimeout(() => killProcessTree2(child, "SIGTERM"), grace));
@@ -190917,14 +191519,14 @@ var init_streamable_http = __esm({
         const signal = this.controller.signal;
         if (signal.aborted)
           return Promise.resolve(false);
-        return new Promise((resolve12) => {
+        return new Promise((resolve13) => {
           const onAbort = () => {
             clearTimeout(timer);
-            resolve12(false);
+            resolve13(false);
           };
           const timer = setTimeout(() => {
             signal.removeEventListener("abort", onAbort);
-            resolve12(true);
+            resolve13(true);
           }, ms);
           timer.unref?.();
           signal.addEventListener("abort", onAbort, { once: true });
@@ -190949,12 +191551,12 @@ var init_dist7 = __esm({
 import { createHash as createHash2, randomBytes as randomBytes2 } from "node:crypto";
 import { writeFile as writeFile5 } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join13 } from "node:path";
+import { join as join15 } from "node:path";
 function toToolExposure(exposure) {
   return exposure === "codemode-deferred" ? "deferred" : exposure;
 }
 async function saveToTempFile(data, extension2) {
-  const path8 = join13(tmpdir2(), `pi-mcp-${randomBytes2(8).toString("hex")}${extension2}`);
+  const path8 = join15(tmpdir2(), `pi-mcp-${randomBytes2(8).toString("hex")}${extension2}`);
   await writeFile5(path8, data, { mode: 384 });
   return path8;
 }
@@ -191422,11 +192024,11 @@ var init_callback3 = __esm({
         const path8 = options.path ?? "/callback";
         let instance;
         const server = createServer((request, response) => instance?.handle(request.url ?? "/", response));
-        await new Promise((resolve12, reject) => {
+        await new Promise((resolve13, reject) => {
           server.once("error", reject);
           server.listen(options.port ?? 0, host, () => {
             server.off("error", reject);
-            resolve12();
+            resolve13();
           });
         });
         const address = server.address();
@@ -191438,12 +192040,12 @@ var init_callback3 = __esm({
       waitForCallback(state3) {
         if (this.pending.has(state3))
           throw new Error("OAuth state is already pending");
-        return new Promise((resolve12, reject) => {
+        return new Promise((resolve13, reject) => {
           const timer = setTimeout(() => {
             this.pending.delete(state3);
             reject(new Error("OAuth callback timed out"));
           }, this.timeoutMs);
-          this.pending.set(state3, { resolve: resolve12, reject, timer });
+          this.pending.set(state3, { resolve: resolve13, reject, timer });
         });
       }
       async close() {
@@ -191452,8 +192054,8 @@ var init_callback3 = __esm({
           pending.reject(new Error("OAuth callback server closed"));
         }
         this.pending.clear();
-        await new Promise((resolve12, reject) => {
-          this.server.close((error) => error ? reject(error) : resolve12());
+        await new Promise((resolve13, reject) => {
+          this.server.close((error) => error ? reject(error) : resolve13());
         });
       }
       reply(response, status, page) {
@@ -192254,7 +192856,7 @@ var init_oauth_page = __esm({
 // node_modules/.pnpm/@earendil-works+pi-coding-agent@0.99.1_@aws-sdk+credential-provider-node@3.972.83_@smit_1f563b9fb7db4619e2913cc40d230799/node_modules/@earendil-works/pi-coding-agent/dist/extensions/mcp/oauth.js
 import { createHash as createHash3 } from "node:crypto";
 import { mkdirSync as mkdirSync4 } from "node:fs";
-import { join as join14 } from "node:path";
+import { join as join16 } from "node:path";
 function callbackSettings(settings3) {
   const url = new URL(settings3.callbackUrl ?? `http://${CALLBACK_HOST}${CALLBACK_PATH}`);
   const address = url.hostname.replace(/^\[|\]$/g, "");
@@ -192460,7 +193062,7 @@ var init_oauth2 = __esm({
       /** Directory for the refresh lock files. Without one, refreshes are only serialized in this process. */
       lockDir;
       constructor(backend, lockDir) {
-        this.backend = backend ?? new FileAuthStorageBackend(join14(getAgentDir(), "mcp-auth.json"));
+        this.backend = backend ?? new FileAuthStorageBackend(join16(getAgentDir(), "mcp-auth.json"));
         this.lockDir = backend ? lockDir : getAgentDir();
       }
       forServer(serverUrl) {
@@ -192482,7 +193084,7 @@ var init_oauth2 = __esm({
           return fn();
         mkdirSync4(this.lockDir, { recursive: true, mode: 448 });
         const hash = createHash3("sha256").update(key).digest("hex").slice(0, 16);
-        const release = await import_proper_lockfile4.default.lock(join14(this.lockDir, `mcp-auth-refresh-${hash}`), {
+        const release = await import_proper_lockfile4.default.lock(join16(this.lockDir, `mcp-auth-refresh-${hash}`), {
           realpath: false,
           stale: REFRESH_LOCK_STALE_MS,
           retries: {
@@ -192537,9 +193139,9 @@ var init_oauth2 = __esm({
 });
 
 // node_modules/.pnpm/@earendil-works+pi-coding-agent@0.99.1_@aws-sdk+credential-provider-node@3.972.83_@smit_1f563b9fb7db4619e2913cc40d230799/node_modules/@earendil-works/pi-coding-agent/dist/extensions/mcp/log.js
-import { appendFileSync, mkdirSync as mkdirSync5, renameSync, statSync as statSync3 } from "node:fs";
-import { dirname as dirname10 } from "node:path";
-function isRecord5(value2) {
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync5, renameSync as renameSync2, statSync as statSync4 } from "node:fs";
+import { dirname as dirname12 } from "node:path";
+function isRecord6(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
 }
 function formatData(data) {
@@ -192552,7 +193154,7 @@ function formatData(data) {
   }
 }
 function formatMcpLogMessage(server, params, now = /* @__PURE__ */ new Date()) {
-  const message = isRecord5(params) ? params : { data: params };
+  const message = isRecord6(params) ? params : { data: params };
   const level = typeof message.level === "string" ? message.level : "info";
   const logger = typeof message.logger === "string" && message.logger ? ` ${message.logger}:` : "";
   const text = formatData(message.data).replace(/\r?\n/g, "\n    ");
@@ -192573,22 +193175,22 @@ var init_log3 = __esm({
         const line = formatMcpLogMessage(server, params);
         try {
           if (this.size === void 0) {
-            mkdirSync5(dirname10(this.path), { recursive: true });
+            mkdirSync5(dirname12(this.path), { recursive: true });
             this.size = this.currentSize();
           }
           if (this.size > MAX_LOG_BYTES) {
             if (this.currentSize() > MAX_LOG_BYTES)
-              renameSync(this.path, `${this.path}.1`);
+              renameSync2(this.path, `${this.path}.1`);
             this.size = this.currentSize();
           }
-          appendFileSync(this.path, line);
+          appendFileSync2(this.path, line);
           this.size += Buffer.byteLength(line);
         } catch {
         }
       }
       currentSize() {
         try {
-          return statSync3(this.path).size;
+          return statSync4(this.path).size;
         } catch {
           return 0;
         }
@@ -192608,7 +193210,7 @@ __export(runtime_exports, {
   signInMcpServer: () => signInMcpServer
 });
 import { homedir as homedir5 } from "node:os";
-import { basename as basename8, join as join15, resolve as resolve6 } from "node:path";
+import { basename as basename11, join as join17, resolve as resolve7 } from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 function errorMessage3(error) {
   return error instanceof Error ? error.message : String(error);
@@ -192632,7 +193234,7 @@ function expandHome(value2) {
   if (value2 === "~")
     return homedir5();
   if (value2.startsWith("~/") || process.platform === "win32" && value2.startsWith("~\\")) {
-    return join15(homedir5(), value2.slice(2));
+    return join17(homedir5(), value2.slice(2));
   }
   return value2;
 }
@@ -192652,7 +193254,7 @@ function createDefaultTransport(entry, cwd, authProvider) {
   return new StdioTransport({
     command: expandHome(config.command),
     args: config.args?.map(expandHome),
-    cwd: resolve6(cwd, expandHome(config.cwd ?? ".")),
+    cwd: resolve7(cwd, expandHome(config.cwd ?? ".")),
     env: env2,
     stderr: "pipe"
   });
@@ -192798,7 +193400,7 @@ var init_runtime = __esm({
             return await run(client);
           } catch (error) {
             if (readOnly && attempt === 1 && error instanceof McpHttpError && isTransientError(error)) {
-              await new Promise((resolve12) => setTimeout(resolve12, CONNECT_RETRY_DELAYS_MS[0]));
+              await new Promise((resolve13) => setTimeout(resolve13, CONNECT_RETRY_DELAYS_MS[0]));
               continue;
             }
             if (error instanceof McpSessionExpiredError && attempt === 1) {
@@ -192859,7 +193461,7 @@ var init_runtime = __esm({
             if (this.closed || delay2 === void 0 || !isTransientError(error)) {
               throw this.connectFailed(error);
             }
-            await new Promise((resolve12) => setTimeout(resolve12, delay2));
+            await new Promise((resolve13) => setTimeout(resolve13, delay2));
             if (this.closed)
               throw this.connectFailed(error);
           }
@@ -192870,7 +193472,7 @@ var init_runtime = __esm({
           name: "pi",
           version: VERSION,
           requestTimeoutMs: this.timeoutMs,
-          roots: [{ uri: pathToFileURL2(this.cwd).href, name: basename8(this.cwd) }]
+          roots: [{ uri: pathToFileURL2(this.cwd).href, name: basename11(this.cwd) }]
         });
         const log = this.log;
         if (log)
@@ -193063,7 +193665,7 @@ var init_ui = __esm({
         this.tui.requestRender();
       }
       menu(build, subscribe) {
-        return new Promise((resolve12) => {
+        return new Promise((resolve13) => {
           let unsubscribe;
           let settled = false;
           const finish = (value2) => {
@@ -193071,10 +193673,10 @@ var init_ui = __esm({
               return;
             settled = true;
             unsubscribe?.();
-            resolve12(value2);
+            resolve13(value2);
           };
           let selected;
-          const render = () => {
+          const render2 = () => {
             const menu = build();
             const wanted = selected ?? menu.selected;
             const body = [];
@@ -193105,10 +193707,10 @@ var init_ui = __esm({
             body.push(list2);
             this.setContent(frame(this.theme, menu.title, body, footer), (data) => list2.handleInput(data));
           };
-          render();
+          render2();
           unsubscribe = subscribe?.(() => {
             if (!settled)
-              render();
+              render2();
           });
         });
       }
@@ -193116,14 +193718,14 @@ var init_ui = __esm({
         this.setContent(frame(this.theme, title, [new Spacer(1), new Text(this.theme.fg("muted", message), 1, 0)]));
       }
       redirectUrl(title, authorizationUrl, signal) {
-        return new Promise((resolve12) => {
+        return new Promise((resolve13) => {
           let settled = false;
           const finish = (value2) => {
             if (settled)
               return;
             settled = true;
             signal.removeEventListener("abort", onAbort);
-            resolve12(value2);
+            resolve13(value2);
           };
           const onAbort = () => finish(void 0);
           if (signal.aborted) {
@@ -193170,7 +193772,7 @@ var init_ui = __esm({
 });
 
 // node_modules/.pnpm/@earendil-works+pi-coding-agent@0.99.1_@aws-sdk+credential-provider-node@3.972.83_@smit_1f563b9fb7db4619e2913cc40d230799/node_modules/@earendil-works/pi-coding-agent/dist/extensions/mcp/index.js
-import { join as join16, resolve as resolve7 } from "node:path";
+import { join as join18, resolve as resolve8 } from "node:path";
 function errorMessage4(error) {
   return error instanceof Error ? error.message : String(error);
 }
@@ -193280,7 +193882,7 @@ function createMcpExtension(options = {}) {
       return credentials;
     };
     const getServerLog = (runtime) => {
-      serverLog ??= new runtime.McpServerLog(options.logPath ?? join16(getAgentDir(), "mcp.log"));
+      serverLog ??= new runtime.McpServerLog(options.logPath ?? join18(getAgentDir(), "mcp.log"));
       return serverLog;
     };
     const toolOwners = /* @__PURE__ */ new Map();
@@ -193541,7 +194143,7 @@ Run /mcp to fix.`, "warning");
         label: server.entry.name,
         description: `${describeState(server)} \xB7 ${exposureOf(server.entry)} \xB7 ${server.entry.scope ?? server.entry.source}`
       })),
-      empty: `No MCP servers configured. Add them to ${resolve7(getAgentDir(), "mcp.json")} or .pi/mcp.json.`,
+      empty: `No MCP servers configured. Add them to ${resolve8(getAgentDir(), "mcp.json")} or .pi/mcp.json.`,
       confirmLabel: "manage",
       cancelLabel: "close"
     });
@@ -193691,7 +194293,7 @@ Run /mcp to fix.`, "warning");
     };
     const formatStatus = () => {
       if (servers.length === 0 && configErrors.length === 0 && overridden.length === 0) {
-        return `No MCP servers configured. Add them to ${resolve7(getAgentDir(), "mcp.json")} or .pi/mcp.json.`;
+        return `No MCP servers configured. Add them to ${resolve8(getAgentDir(), "mcp.json")} or .pi/mcp.json.`;
       }
       const lines = servers.map((server) => {
         const { name } = server.entry;
@@ -193779,7 +194381,7 @@ ${url.href}`, "info");
         reportProblems(ctx);
         return;
       }
-      pending = new Promise((resolve12) => setImmediate(resolve12)).then(() => loadMcpRuntime()).then(async () => {
+      pending = new Promise((resolve13) => setImmediate(resolve13)).then(() => loadMcpRuntime()).then(async () => {
         if (current !== generation)
           return;
         const started = await Promise.all(enabled.map((server) => createConnection(server)));
@@ -193805,8 +194407,8 @@ ${url.href}`, "info");
       let timer;
       const finished2 = await Promise.race([
         startup.then(() => true),
-        new Promise((resolve12) => {
-          timer = setTimeout(() => resolve12(false), startupWaitMs);
+        new Promise((resolve13) => {
+          timer = setTimeout(() => resolve13(false), startupWaitMs);
         })
       ]);
       clearTimeout(timer);
@@ -195351,24 +195953,26 @@ var init_archivist_record_pointer = __esm({
   "src/archivist-record-pointer.ts"() {
     "use strict";
     init_unknown_value();
+    init_run_dossier();
+    init_run_dossier_files();
+    init_sitian_facade();
     init_activation_ledger_topology();
     init_run_lifecycle();
     init_role_run_relocation();
     init_role_run_placement();
-    init_sitian_appender();
   }
 });
 
 // scripts/migrate-book-topology.ts
 import { homedir as homedir6 } from "node:os";
-import { join as join22, resolve as resolve11 } from "node:path";
+import { join as join24, resolve as resolve12 } from "node:path";
 
 // src/book-topology-migration.ts
 init_activation_ledger_topology();
 init_run_lifecycle();
 import { mkdir, readdir as readdir4, rename } from "node:fs/promises";
 import { homedir } from "node:os";
-import { basename as basename3, dirname as dirname4, join as join5, resolve as resolve2 } from "node:path";
+import { basename as basename6, dirname as dirname6, join as join7, resolve as resolve3 } from "node:path";
 function reconcileMigrationPartition(partition3, unit, outcomes) {
   let placed = 0;
   let unbound = 0;
@@ -195396,7 +196000,7 @@ async function findWriterLocks(root) {
   const locks = [];
   async function walk3(directory) {
     for (const entry of await readdir4(directory, { withFileTypes: true })) {
-      const path8 = join5(directory, entry.name);
+      const path8 = join7(directory, entry.name);
       if (entry.name === "writer.lock") {
         const kind = entry.isFile() ? "file" : entry.isDirectory() ? "directory" : entry.isSymbolicLink() ? "symbolic link" : entry.isFIFO() ? "FIFO" : entry.isSocket() ? "socket" : entry.isCharacterDevice() ? "character device" : entry.isBlockDevice() ? "block device" : "unknown filesystem object";
         locks.push({ path: path8, regularFile: entry.isFile(), kind });
@@ -195438,7 +196042,7 @@ ${active.join("\n")}`);
 }
 function datedBooksBackupDirectory(booksDirectory, now = /* @__PURE__ */ new Date()) {
   const date = now.toISOString().slice(0, 10);
-  return join5(dirname4(booksDirectory), `${basename3(booksDirectory)}-${date}`);
+  return join7(dirname6(booksDirectory), `${basename6(booksDirectory)}-${date}`);
 }
 async function renameBooksToDatedBackup(booksDirectory, now = /* @__PURE__ */ new Date()) {
   const backup = datedBooksBackupDirectory(booksDirectory, now);
@@ -195449,8 +196053,8 @@ async function migrateBookTopology(input) {
   if (input.migrators.length === 0) {
     throw new Error("book topology migration has no partition migrators");
   }
-  const ledgerHome = resolve2(input.ledgerHome ?? join5(homedir(), ".ak-roles"));
-  const booksDirectory = join5(ledgerHome, "books");
+  const ledgerHome = resolve3(input.ledgerHome ?? join7(homedir(), ".ak-roles"));
+  const booksDirectory = join7(ledgerHome, "books");
   await assertBookTopologyMigrationPrerequisites(booksDirectory, input.env);
   const backupBooksDirectory = await renameBooksToDatedBackup(booksDirectory, input.now);
   await mkdir(booksDirectory);
@@ -195474,7 +196078,7 @@ async function migrateBookTopology(input) {
 
 // src/book-topology-mixed-volume-migrators.ts
 import { appendFile, cp as cp2, lstat as lstat2, mkdir as mkdir3, readFile as readFile7, writeFile as writeFile6 } from "node:fs/promises";
-import { dirname as dirname12, join as join18, relative as relative4, resolve as resolve9, sep as sep7 } from "node:path";
+import { dirname as dirname14, join as join20, relative as relative4, resolve as resolve10, sep as sep7 } from "node:path";
 
 // src/archivist-record-entry.ts
 init_activation_ledger_topology();
@@ -195497,9 +196101,10 @@ var WORKER_SUBMISSION_GATE_KIND = "worker-submission-gate";
 init_activation_ledger_topology();
 init_role_run_placement();
 init_run_ticket_number();
+init_run_dossier();
 init_unknown_value();
 import { readdir as readdir6, readFile as readFile6 } from "node:fs/promises";
-import { basename as basename9, dirname as dirname11, isAbsolute as isAbsolute5, join as join17, relative as relative3, resolve as resolve8, sep as sep6 } from "node:path";
+import { basename as basename12, dirname as dirname13, isAbsolute as isAbsolute6, join as join19, relative as relative3, resolve as resolve9, sep as sep6 } from "node:path";
 var TICKET_NUMBER_RE = /^[1-9][0-9]*$/;
 var RUN_DIR_NAME_RE = /^([^@]+)@([^@]+)$/;
 async function listMigrationBookKeys(booksDirectory) {
@@ -195538,8 +196143,19 @@ function ticketNumberFromWorktreeBasename(pathBasename) {
   return ticketNumber;
 }
 async function readProjectRootFromRun(runDirectory) {
+  for (const section of ["admitted", "invocation", "runState"]) {
+    try {
+      const page = readPageSync(runDirectory, section);
+      const projectRoot = page?.projectRoot;
+      if (typeof projectRoot === "string" && projectRoot.length > 0) {
+        return { projectRoot, sourcePage: `state.jsonl:${section}` };
+      }
+    } catch (error) {
+      if (!isEnoent(error)) throw error;
+    }
+  }
   for (const page of ["admitted-request.json", "invocation.json", "run-state.json"]) {
-    const path8 = join17(runDirectory, page);
+    const path8 = join19(runDirectory, page);
     try {
       const raw = JSON.parse(await readFile6(path8, "utf8"));
       if (!isRecord(raw)) continue;
@@ -195555,7 +196171,7 @@ async function readProjectRootFromRun(runDirectory) {
   return void 0;
 }
 async function resolveMigratingRunTicket(runDirectory) {
-  const boardTicket = await readBoardTicketNumber(runDirectory);
+  const boardTicket = await readMigrationBoardTicketNumber(runDirectory);
   if (boardTicket !== void 0) {
     return {
       ticketNumber: boardTicket,
@@ -195575,7 +196191,7 @@ async function resolveMigratingRunTicket(runDirectory) {
   }
   const project = await readProjectRootFromRun(runDirectory);
   if (project === void 0) return { ticketNumber: void 0, derivation: void 0 };
-  const leaf = basename9(project.projectRoot.replace(/\\/g, "/"));
+  const leaf = basename12(project.projectRoot.replace(/\\/g, "/"));
   const ticketNumber = ticketNumberFromWorktreeBasename(leaf);
   if (ticketNumber === void 0) return { ticketNumber: void 0, derivation: void 0 };
   return {
@@ -195588,7 +196204,7 @@ async function resolveMigratingRunTicket(runDirectory) {
   };
 }
 function bookHistoricalRoots(booksDirectory, backupBooksDirectory, bookKey) {
-  return [join17(booksDirectory, bookKey), join17(backupBooksDirectory, bookKey)];
+  return [join19(booksDirectory, bookKey), join19(backupBooksDirectory, bookKey)];
 }
 function runLeafFromRelative(path8) {
   const segments = path8.replaceAll("\\", "/").split("/").filter((segment) => segment.length > 0);
@@ -195600,8 +196216,8 @@ function runLeafFromRelative(path8) {
 }
 function runRefFromBoundPath(path8, bookRoots) {
   for (const root of bookRoots) {
-    const rootResolved = resolve8(root);
-    const candidate = isAbsolute5(path8) ? resolve8(path8) : resolve8(rootResolved, path8);
+    const rootResolved = resolve9(root);
+    const candidate = isAbsolute6(path8) ? resolve9(path8) : resolve9(rootResolved, path8);
     if (candidate === rootResolved || !pathContainedIn(rootResolved, candidate)) continue;
     const rel = relative3(rootResolved, candidate).split(sep6).join("/");
     const leaf = runLeafFromRelative(rel);
@@ -195623,11 +196239,11 @@ async function listRunLeafEntries(runsDirectory) {
 async function listBackupRunLeaves(backupBookDirectory) {
   const leaves = [];
   const collect = async (relativeDir, layout) => {
-    const runsDirectory = join17(backupBookDirectory, ...relativeDir.split("/"));
+    const runsDirectory = join19(backupBookDirectory, ...relativeDir.split("/"));
     for (const entry of await listRunLeafEntries(runsDirectory)) {
       leaves.push({
         relativePath: `${relativeDir}/${entry.name}`,
-        sourcePath: join17(runsDirectory, entry.name),
+        sourcePath: join19(runsDirectory, entry.name),
         leafName: entry.name,
         isDirectory: entry.isDirectory,
         layout
@@ -195640,7 +196256,7 @@ async function listBackupRunLeaves(backupBookDirectory) {
     if (!subject.isDirectory() || !isTicketNumberString2(subject.name)) continue;
     await collect(`${subject.name}/runs`, "ticket");
   }
-  for (const issue of await listMigrationDirents(join17(backupBookDirectory, "issues"))) {
+  for (const issue of await listMigrationDirents(join19(backupBookDirectory, "issues"))) {
     if (!issue.isDirectory() || !isTicketNumberString2(issue.name)) continue;
     await collect(`issues/${issue.name}/runs`, "issues");
   }
@@ -195650,13 +196266,13 @@ async function listExactPlacedRunPaths(bookDir, leafName) {
   const matches = [];
   const subjectEntries = await listMigrationDirents(bookDir);
   const runsDirs = [
-    join17(bookDir, "runs"),
-    ...subjectEntries.filter((entry) => entry.isDirectory()).map((entry) => join17(bookDir, entry.name, "runs"))
+    join19(bookDir, "runs"),
+    ...subjectEntries.filter((entry) => entry.isDirectory()).map((entry) => join19(bookDir, entry.name, "runs"))
   ];
   for (const runsDir of runsDirs) {
     const entries = await listMigrationDirents(runsDir);
     if (entries.some((entry) => entry.name === leafName)) {
-      matches.push(join17(runsDir, leafName));
+      matches.push(join19(runsDir, leafName));
     }
   }
   return matches;
@@ -195669,13 +196285,13 @@ function destPathFromSourceRelative(booksDirectory, bookKey, sourceRelative2) {
   const before = parts.slice(0, runsIndex);
   if (leaf === void 0) return void 0;
   if (before.length === 2 && before[0] === "issues" && before[1] !== void 0 && isTicketNumberString2(before[1])) {
-    return join17(booksDirectory, bookKey, before[1], "runs", leaf);
+    return join19(booksDirectory, bookKey, before[1], "runs", leaf);
   }
   if (before.length !== 1) return void 0;
   const subject = before[0];
   if (subject === void 0) return void 0;
   if (subject !== "unbound" && !isTicketNumberString2(subject)) return void 0;
-  return join17(booksDirectory, bookKey, subject, "runs", leaf);
+  return join19(booksDirectory, bookKey, subject, "runs", leaf);
 }
 function placedRunFromPath(runDirectory) {
   return {
@@ -195687,15 +196303,15 @@ async function listPrincipalPlacedRunPaths(bookDir, runId) {
   const matches = [...await listExactPlacedRunPaths(bookDir, runId)];
   const subjectEntries = await listMigrationDirents(bookDir);
   const runsDirs = [
-    join17(bookDir, "runs"),
-    ...subjectEntries.filter((entry) => entry.isDirectory()).map((entry) => join17(bookDir, entry.name, "runs"))
+    join19(bookDir, "runs"),
+    ...subjectEntries.filter((entry) => entry.isDirectory()).map((entry) => join19(bookDir, entry.name, "runs"))
   ];
   const prefix = `${runId}@`;
   for (const runsDir of runsDirs) {
     for (const entry of await listMigrationDirents(runsDir)) {
       const name = entry.name;
       if (!name.startsWith(prefix) || name.slice(runId.length + 1).includes("@")) continue;
-      const path8 = join17(runsDir, name);
+      const path8 = join19(runsDir, name);
       if (!matches.includes(path8)) matches.push(path8);
     }
   }
@@ -195723,7 +196339,7 @@ function isFlatRunsRelative(sourceRelative2, leafName) {
 }
 async function findPlacedMigratingRun(booksDirectory, bookKey, leafName, sourceRelative2) {
   if (leafName.trim() === "") return void 0;
-  const bookDir = join17(booksDirectory, bookKey);
+  const bookDir = join19(booksDirectory, bookKey);
   const matches = await listExactPlacedRunPaths(bookDir, leafName);
   if (sourceRelative2 !== void 0 && sourceRelative2.length > 0) {
     const preferred = destPathFromSourceRelative(booksDirectory, bookKey, sourceRelative2);
@@ -195749,12 +196365,12 @@ async function uniqueRunLeafExistsInBook(bookDir, leafName) {
 }
 async function findUniquePrincipalPlacedRun(booksDirectory, bookKey, runId) {
   if (runId.trim() === "") return void 0;
-  const matches = await listPrincipalPlacedRunPaths(join17(booksDirectory, bookKey), runId);
+  const matches = await listPrincipalPlacedRunPaths(join19(booksDirectory, bookKey), runId);
   if (matches.length !== 1) return void 0;
   return placedRunFromPath(matches[0]);
 }
 function destinationRunDirectory(booksDirectory, bookKey, ticketNumber, runId, role) {
-  const ledgerHome = dirname11(booksDirectory);
+  const ledgerHome = dirname13(booksDirectory);
   const subject = ticketNumber !== void 0 ? { ticketNumber } : { unbound: true };
   return roleRunPlacement(ledgerHome, {
     bookKey,
@@ -195891,9 +196507,9 @@ function inspectWorkerSubmissionGateVolume(text, bookRoots) {
 }
 function volumeDestinationFile(booksDirectory, bookKey, destRun, kind, fileName) {
   if (destRun === void 0) {
-    return join18(booksDirectory, bookKey, "unbound", kind, fileName);
+    return join20(booksDirectory, bookKey, "unbound", kind, fileName);
   }
-  return join18(destRun.runDirectory, "session", kind, fileName);
+  return join20(destRun.runDirectory, "session", kind, fileName);
 }
 async function placedRunForLeaf(cache, booksDirectory, bookKey, leaf, sourceRelative2) {
   const cacheKey = `${bookKey}\0${sourceRelative2 ?? ""}\0${leaf}`;
@@ -195908,7 +196524,7 @@ async function placedRunForLeaf(cache, booksDirectory, bookKey, leaf, sourceRela
   return placed;
 }
 async function appendRawLine(file, raw) {
-  await mkdir3(dirname12(file), { recursive: true });
+  await mkdir3(dirname14(file), { recursive: true });
   await appendFile(file, `${raw}
 `, "utf8");
 }
@@ -195924,7 +196540,7 @@ function jsonlRows(text) {
   return rows;
 }
 async function migrateCurrentSessionPointer(input) {
-  const sourceFile = join18(input.sourceDir, CURRENT_SESSION_LEDGER);
+  const sourceFile = join20(input.sourceDir, CURRENT_SESSION_LEDGER);
   const raw = await readRegularBackupFile(sourceFile);
   if (raw === void 0) return;
   let sessionFile;
@@ -195938,11 +196554,11 @@ async function migrateCurrentSessionPointer(input) {
   }
   let destinationSessionFile;
   if (sessionFile !== void 0) {
-    const pointed = resolve9(input.sourceDir, sessionFile);
+    const pointed = resolve10(input.sourceDir, sessionFile);
     destinationSessionFile = input.volumeDestinations.get(pointed) ?? input.volumeDestinations.get(sessionFile);
   }
   if (destinationSessionFile === void 0) {
-    await mkdir3(dirname12(input.unboundPointerFile), { recursive: true });
+    await mkdir3(dirname14(input.unboundPointerFile), { recursive: true });
     await writeFile6(
       input.unboundPointerFile,
       raw.endsWith("\n") ? raw : `${raw}
@@ -195951,8 +196567,8 @@ async function migrateCurrentSessionPointer(input) {
     );
     return;
   }
-  const pointerFile = join18(dirname12(destinationSessionFile), CURRENT_SESSION_LEDGER);
-  await mkdir3(dirname12(pointerFile), { recursive: true });
+  const pointerFile = join20(dirname14(destinationSessionFile), CURRENT_SESSION_LEDGER);
+  await mkdir3(dirname14(pointerFile), { recursive: true });
   await writeFile6(
     pointerFile,
     `${JSON.stringify({ sessionFile: destinationSessionFile })}
@@ -195965,15 +196581,15 @@ async function migrateSitianMixedVolume(partition3, context) {
   const placedCache = /* @__PURE__ */ new Map();
   const { backupBooksDirectory, booksDirectory } = context;
   for (const bookKey of await listMigrationBookKeys(backupBooksDirectory)) {
-    const sourceDir = join18(backupBooksDirectory, bookKey, partition3);
-    const recordsFile = join18(sourceDir, "records.jsonl");
+    const sourceDir = join20(backupBooksDirectory, bookKey, partition3);
+    const recordsFile = join20(sourceDir, "records.jsonl");
     const bookRoots = bookHistoricalRoots(booksDirectory, backupBooksDirectory, bookKey);
     const text = await readRegularBackupFile(recordsFile);
     if (text === void 0) {
       await migrateCurrentSessionPointer({
         sourceDir,
         volumeDestinations: /* @__PURE__ */ new Map(),
-        unboundPointerFile: join18(
+        unboundPointerFile: join20(
           booksDirectory,
           bookKey,
           "unbound",
@@ -196051,16 +196667,16 @@ async function migrateSitianMixedVolume(partition3, context) {
     const volumeDestinations = /* @__PURE__ */ new Map();
     if (placedDests.size === 1) {
       const onlyDest = placedDests.values().next().value;
-      volumeDestinations.set(resolve9(recordsFile), onlyDest);
+      volumeDestinations.set(resolve10(recordsFile), onlyDest);
       volumeDestinations.set(
-        resolve9(join18(booksDirectory, bookKey, partition3, "records.jsonl")),
+        resolve10(join20(booksDirectory, bookKey, partition3, "records.jsonl")),
         onlyDest
       );
     }
     await migrateCurrentSessionPointer({
       sourceDir,
       volumeDestinations,
-      unboundPointerFile: join18(
+      unboundPointerFile: join20(
         booksDirectory,
         bookKey,
         "unbound",
@@ -196078,13 +196694,13 @@ async function migrateWorkerSubmissionGate(context) {
   const { backupBooksDirectory, booksDirectory } = context;
   const kind = WORKER_SUBMISSION_GATE_KIND;
   for (const bookKey of await listMigrationBookKeys(backupBooksDirectory)) {
-    const sourceDir = join18(backupBooksDirectory, bookKey, kind);
+    const sourceDir = join20(backupBooksDirectory, bookKey, kind);
     const entries = await listMigrationDirents(sourceDir);
     if (entries.length === 0) continue;
     const bookRoots = bookHistoricalRoots(booksDirectory, backupBooksDirectory, bookKey);
     const volumes = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl")).map((entry) => entry.name).sort();
     for (const name of volumes) {
-      const sourcePath = join18(sourceDir, name);
+      const sourcePath = join20(sourceDir, name);
       const source = posixRelative(backupBooksDirectory, sourcePath);
       const text = await readRegularBackupFile(sourcePath);
       if (text === void 0) continue;
@@ -196103,7 +196719,7 @@ async function migrateWorkerSubmissionGate(context) {
         kind,
         name
       );
-      await mkdir3(dirname12(dest), { recursive: true });
+      await mkdir3(dirname14(dest), { recursive: true });
       await cp2(sourcePath, dest, { preserveTimestamps: true });
       outcomes.push({
         disposition: destRun?.disposition === "placed" ? "placed" : "unbound",
@@ -196140,7 +196756,7 @@ var BOOK_TOPOLOGY_MIXED_VOLUME_MIGRATORS = [
 // src/book-topology-migrators-t11.ts
 init_activation_ledger_topology();
 import { cp as cp3, lstat as lstat3, mkdir as mkdir4, readFile as readFile8, stat as stat4, unlink as unlink2, utimes, writeFile as writeFile7 } from "node:fs/promises";
-import { basename as basename10, dirname as dirname13, join as join19, relative as relative5, resolve as resolve10, sep as sep8 } from "node:path";
+import { basename as basename13, dirname as dirname15, join as join21, relative as relative5, resolve as resolve11, sep as sep8 } from "node:path";
 init_role_run_relocation();
 init_unknown_value();
 var AUDITOR_ROLES_PARTITION = "auditor-roles";
@@ -196192,7 +196808,7 @@ async function directoryExists(path8) {
 }
 async function hasAnyFileRecursive(directory) {
   for (const entry of await listMigrationDirents(directory)) {
-    const path8 = join19(directory, entry.name);
+    const path8 = join21(directory, entry.name);
     if (entry.isDirectory()) {
       if (await hasAnyFileRecursive(path8)) return true;
     } else {
@@ -196202,14 +196818,14 @@ async function hasAnyFileRecursive(directory) {
   return false;
 }
 function mapBooksPathToBackup(booksDirectory, backupBooksDirectory, absolutePath) {
-  const booksRoot = resolve10(booksDirectory);
-  const resolved = resolve10(absolutePath);
+  const booksRoot = resolve11(booksDirectory);
+  const resolved = resolve11(absolutePath);
   if (resolved !== booksRoot && !pathContainedIn(booksRoot, resolved)) return void 0;
-  return join19(backupBooksDirectory, relative5(booksRoot, resolved));
+  return join21(backupBooksDirectory, relative5(booksRoot, resolved));
 }
 function resolveVolumeSessionFile(booksDirectory, backupBooksDirectory, volumeDirectory, sessionFileField) {
-  const resolvedVolume = resolve10(volumeDirectory);
-  const resolvedSession = resolve10(sessionFileField);
+  const resolvedVolume = resolve11(volumeDirectory);
+  const resolvedSession = resolve11(sessionFileField);
   if (physicallyContainedIn(resolvedVolume, resolvedSession)) return resolvedSession;
   const mapped = mapBooksPathToBackup(
     booksDirectory,
@@ -196217,13 +196833,13 @@ function resolveVolumeSessionFile(booksDirectory, backupBooksDirectory, volumeDi
     sessionFileField
   );
   if (mapped === void 0) return void 0;
-  const resolvedMapped = resolve10(mapped);
+  const resolvedMapped = resolve11(mapped);
   return physicallyContainedIn(resolvedVolume, resolvedMapped) ? resolvedMapped : void 0;
 }
 function parseParentRunBoundToMigration(booksDirectory, backupBooksDirectory, parentSession) {
-  const resolved = resolve10(parentSession);
-  const booksRoot = resolve10(booksDirectory);
-  const backupRoot = resolve10(backupBooksDirectory);
+  const resolved = resolve11(parentSession);
+  const booksRoot = resolve11(booksDirectory);
+  const backupRoot = resolve11(backupBooksDirectory);
   let rel;
   if (resolved === booksRoot || pathContainedIn(booksRoot, resolved)) {
     rel = relative5(booksRoot, resolved).split(sep8).join("/");
@@ -196280,15 +196896,15 @@ async function readJsonlParentSession(path8) {
   }
 }
 async function backupParentRunExists(backupBooksDirectory, parent) {
-  const backupBook = join19(backupBooksDirectory, parent.bookKey);
-  if (await directoryExists(join19(backupBook, parent.sourceRelative))) return true;
+  const backupBook = join21(backupBooksDirectory, parent.bookKey);
+  if (await directoryExists(join21(backupBook, parent.sourceRelative))) return true;
   if (!isFlatRunsRelative(parent.sourceRelative, parent.leafName)) return false;
   return uniqueRunLeafExistsInBook(backupBook, parent.leafName);
 }
 async function findTrueVolumeParent(backupBooksDirectory, booksDirectory, volumeDirectory) {
   let ledgerRaw;
   try {
-    ledgerRaw = await readFile8(join19(volumeDirectory, CURRENT_SESSION_LEDGER2), "utf8");
+    ledgerRaw = await readFile8(join21(volumeDirectory, CURRENT_SESSION_LEDGER2), "utf8");
   } catch (error) {
     if (isEnoent(error)) return void 0;
     throw error;
@@ -196339,22 +196955,22 @@ async function collectPlacedRunRewrites(booksDirectory, backupBooksDirectory) {
     rewrites.push({ oldRunDirectory, newRunDirectory });
   };
   for (const bookKey of await listMigrationBookKeys(booksDirectory)) {
-    for (const subject of await listMigrationDirents(join19(booksDirectory, bookKey))) {
+    for (const subject of await listMigrationDirents(join21(booksDirectory, bookKey))) {
       if (!subject.isDirectory()) continue;
-      const runsRoot = join19(booksDirectory, bookKey, subject.name, "runs");
+      const runsRoot = join21(booksDirectory, bookKey, subject.name, "runs");
       for (const run of await listMigrationDirents(runsRoot)) {
         if (!run.isDirectory()) continue;
-        const finalPath = join19(runsRoot, run.name);
-        push(join19(booksDirectory, bookKey, "runs", run.name), finalPath);
-        push(join19(backupBooksDirectory, bookKey, "runs", run.name), finalPath);
-        push(join19(backupBooksDirectory, bookKey, subject.name, "runs", run.name), finalPath);
+        const finalPath = join21(runsRoot, run.name);
+        push(join21(booksDirectory, bookKey, "runs", run.name), finalPath);
+        push(join21(backupBooksDirectory, bookKey, "runs", run.name), finalPath);
+        push(join21(backupBooksDirectory, bookKey, subject.name, "runs", run.name), finalPath);
         if (isTicketNumberString2(subject.name)) {
           push(
-            join19(booksDirectory, bookKey, "issues", subject.name, "runs", run.name),
+            join21(booksDirectory, bookKey, "issues", subject.name, "runs", run.name),
             finalPath
           );
           push(
-            join19(backupBooksDirectory, bookKey, "issues", subject.name, "runs", run.name),
+            join21(backupBooksDirectory, bookKey, "issues", subject.name, "runs", run.name),
             finalPath
           );
         }
@@ -196365,12 +196981,12 @@ async function collectPlacedRunRewrites(booksDirectory, backupBooksDirectory) {
 }
 function historicalRunDirectoriesFor(booksDirectory, backupBooksDirectory, parent) {
   const out = [
-    join19(booksDirectory, parent.bookKey, parent.sourceRelative),
-    join19(backupBooksDirectory, parent.bookKey, parent.sourceRelative)
+    join21(booksDirectory, parent.bookKey, parent.sourceRelative),
+    join21(backupBooksDirectory, parent.bookKey, parent.sourceRelative)
   ];
   if (!parent.sourceRelative.startsWith("runs/")) {
-    out.push(join19(booksDirectory, parent.bookKey, "runs", parent.leafName));
-    out.push(join19(backupBooksDirectory, parent.bookKey, "runs", parent.leafName));
+    out.push(join21(booksDirectory, parent.bookKey, "runs", parent.leafName));
+    out.push(join21(backupBooksDirectory, parent.bookKey, "runs", parent.leafName));
   }
   return out;
 }
@@ -196383,11 +196999,11 @@ async function resolveDestinationRun(context, parent) {
   );
 }
 function rewritePathIntoDestination(sessionFile, sourceRoots, destRoot) {
-  const resolved = resolve10(sessionFile);
+  const resolved = resolve11(sessionFile);
   for (const root of sourceRoots) {
-    const resolvedRoot = resolve10(root);
+    const resolvedRoot = resolve11(root);
     if (pathContainedIn(resolvedRoot, resolved)) {
-      return join19(destRoot, relative5(resolvedRoot, resolved));
+      return join21(destRoot, relative5(resolvedRoot, resolved));
     }
   }
   return sessionFile;
@@ -196432,8 +197048,8 @@ async function writeWinningCurrentSession(destPath, srcStat, destStat, nextRaw,
           `book topology migration cannot compare current-session pointer at ${destPath}: file disappeared during tie-break`
         );
       }
-      const srcName = basename10(nextSessionFile ?? "");
-      const destName = basename10(destSessionFile);
+      const srcName = basename13(nextSessionFile ?? "");
+      const destName = basename13(destSessionFile);
       if (destName >= srcName) return;
     }
   }
@@ -196441,7 +197057,7 @@ async function writeWinningCurrentSession(destPath, srcStat, destStat, nextRaw,
   await utimes(destPath, srcStat.atime, srcStat.mtime);
 }
 async function mergeRewrittenCurrentSession(volumeDirectory, historicalVolume, destNest) {
-  const srcPath = join19(volumeDirectory, CURRENT_SESSION_LEDGER2);
+  const srcPath = join21(volumeDirectory, CURRENT_SESSION_LEDGER2);
   let srcRaw;
   let srcStat;
   try {
@@ -196473,7 +197089,7 @@ async function mergeRewrittenCurrentSession(volumeDirectory, historicalVolume, d
   } catch {
     nextSessionFile = void 0;
   }
-  const destPath = join19(destNest, CURRENT_SESSION_LEDGER2);
+  const destPath = join21(destNest, CURRENT_SESSION_LEDGER2);
   let destStat;
   try {
     destStat = await stat4(destPath);
@@ -196492,8 +197108,8 @@ async function copyDirSkippingCurrentSession(from, to) {
   await mkdir4(to, { recursive: true });
   for (const entry of await listMigrationDirents(from)) {
     if (entry.name === CURRENT_SESSION_LEDGER2 && entry.isFile()) continue;
-    const src = join19(from, entry.name);
-    const dest = join19(to, entry.name);
+    const src = join21(from, entry.name);
+    const dest = join21(to, entry.name);
     if (entry.isDirectory()) {
       await copyDirSkippingCurrentSession(src, dest);
     } else if (entry.isFile()) {
@@ -196506,7 +197122,7 @@ async function copyVolumeIntoNest(volumeDirectory, historicalVolume, destNest) {
   await mergeRewrittenCurrentSession(volumeDirectory, historicalVolume, destNest);
 }
 async function copyTree(source, destination) {
-  await mkdir4(dirname13(destination), { recursive: true });
+  await mkdir4(dirname15(destination), { recursive: true });
   await cp3(source, destination, { recursive: true, preserveTimestamps: true });
 }
 var bookTopologyAuditorRolesMigrator = {
@@ -196520,9 +197136,9 @@ var bookTopologyAuditorRolesMigrator = {
     );
     const rewriteSeen = new Set(crossRunRewrites.map((r2) => r2.oldRunDirectory));
     for (const bookKey of await listMigrationBookKeys(backupBooksDirectory)) {
-      const auditorRoot = join19(backupBooksDirectory, bookKey, AUDITOR_ROLES_PARTITION);
+      const auditorRoot = join21(backupBooksDirectory, bookKey, AUDITOR_ROLES_PARTITION);
       for (const entry of await listMigrationDirents(auditorRoot)) {
-        const sourcePath = join19(auditorRoot, entry.name);
+        const sourcePath = join21(auditorRoot, entry.name);
         if (entry.isFile() && entry.name === T10_MISFILED_NAME) {
           continue;
         }
@@ -196541,14 +197157,14 @@ var bookTopologyAuditorRolesMigrator = {
           continue;
         }
         const destination = await resolveDestinationRun(context, parent);
-        const historicalVolume = join19(
+        const historicalVolume = join21(
           booksDirectory,
           bookKey,
           AUDITOR_ROLES_PARTITION,
           entry.name
         );
         if (destination === void 0) {
-          const destNest2 = join19(
+          const destNest2 = join21(
             booksDirectory,
             bookKey,
             "unbound",
@@ -196559,7 +197175,7 @@ var bookTopologyAuditorRolesMigrator = {
           outcomes.push({ disposition: "unbound", source });
           continue;
         }
-        const destNest = join19(destination.runDirectory, "session", AUDITOR_ROLES_PARTITION);
+        const destNest = join21(destination.runDirectory, "session", AUDITOR_ROLES_PARTITION);
         await copyVolumeIntoNest(sourcePath, historicalVolume, destNest);
         const historicalParents = historicalRunDirectoriesFor(
           booksDirectory,
@@ -196590,8 +197206,8 @@ async function copyIssuesNonRunTree(source, destination) {
   await mkdir4(destination, { recursive: true });
   for (const entry of await listMigrationDirents(source)) {
     if (entry.name === "runs") continue;
-    const from = join19(source, entry.name);
-    const to = join19(destination, entry.name);
+    const from = join21(source, entry.name);
+    const to = join21(destination, entry.name);
     if (entry.isDirectory()) {
       await copyIssuesNonRunTree(from, to);
       continue;
@@ -196614,9 +197230,9 @@ var bookTopologyIssuesMigrator = {
     const outcomes = [];
     const { backupBooksDirectory, booksDirectory } = context;
     for (const bookKey of await listMigrationBookKeys(backupBooksDirectory)) {
-      const issuesRoot = join19(backupBooksDirectory, bookKey, ISSUES_PARTITION);
+      const issuesRoot = join21(backupBooksDirectory, bookKey, ISSUES_PARTITION);
       for (const entry of await listMigrationDirents(issuesRoot)) {
-        const sourcePath = join19(issuesRoot, entry.name);
+        const sourcePath = join21(issuesRoot, entry.name);
         const source = sourceIdentity(backupBooksDirectory, sourcePath);
         const isTicketDir = entry.isDirectory() && TICKET_NUMBER_NAME.test(entry.name);
         if (!isTicketDir || !await hasAnyFileRecursive(sourcePath)) {
@@ -196625,7 +197241,7 @@ var bookTopologyIssuesMigrator = {
         }
         await copyIssuesNonRunTree(
           sourcePath,
-          join19(booksDirectory, bookKey, entry.name)
+          join21(booksDirectory, bookKey, entry.name)
         );
         outcomes.push({ disposition: "placed", source });
       }
@@ -196640,11 +197256,11 @@ var bookTopologyDeprecatedKindsMigrator = {
     const { backupBooksDirectory } = context;
     for (const bookKey of await listMigrationBookKeys(backupBooksDirectory)) {
       for (const kind of DEPRECATED_KIND_DIRECTORIES) {
-        const kindRoot = join19(backupBooksDirectory, bookKey, kind);
+        const kindRoot = join21(backupBooksDirectory, bookKey, kind);
         for (const entry of await listMigrationDirents(kindRoot)) {
           outcomes.push({
             disposition: "discarded",
-            source: sourceIdentity(backupBooksDirectory, join19(kindRoot, entry.name))
+            source: sourceIdentity(backupBooksDirectory, join21(kindRoot, entry.name))
           });
         }
       }
@@ -196666,11 +197282,11 @@ async function discardDeprecatedPagesFromRunSource(input) {
       disposition: "discarded",
       source: sourceIdentity(
         input.backupBooksDirectory,
-        join19(input.sourceRunDirectory, page.name)
+        join21(input.sourceRunDirectory, page.name)
       )
     });
     if (input.destinationRunDirectory !== void 0) {
-      await unlinkIfPresent(join19(input.destinationRunDirectory, page.name));
+      await unlinkIfPresent(join21(input.destinationRunDirectory, page.name));
     }
   }
 }
@@ -196680,7 +197296,7 @@ var bookTopologyDeprecatedRunPagesMigrator = {
     const outcomes = [];
     const { backupBooksDirectory, booksDirectory } = context;
     for (const bookKey of await listMigrationBookKeys(backupBooksDirectory)) {
-      for (const leaf of await listBackupRunLeaves(join19(backupBooksDirectory, bookKey))) {
+      for (const leaf of await listBackupRunLeaves(join21(backupBooksDirectory, bookKey))) {
         if (!leaf.isDirectory) continue;
         const placed = await findPlacedMigratingRun(
           booksDirectory,
@@ -196701,15 +197317,15 @@ var bookTopologyDeprecatedRunPagesMigrator = {
 };
 async function copyBookTopLevelPartition(context, partition3, outcomes) {
   for (const bookKey of await listMigrationBookKeys(context.backupBooksDirectory)) {
-    const sourceDir = join19(context.backupBooksDirectory, bookKey, partition3);
+    const sourceDir = join21(context.backupBooksDirectory, bookKey, partition3);
     if (!await directoryExists(sourceDir)) continue;
-    await copyTree(sourceDir, join19(context.booksDirectory, bookKey, partition3));
+    await copyTree(sourceDir, join21(context.booksDirectory, bookKey, partition3));
     for (const entry of await listMigrationDirents(sourceDir)) {
       outcomes.push({
         disposition: "placed",
         source: sourceIdentity(
           context.backupBooksDirectory,
-          join19(sourceDir, entry.name)
+          join21(sourceDir, entry.name)
         )
       });
     }
@@ -196736,12 +197352,12 @@ var bookTopologyManualArchivesMigrator = {
   async migrate(context) {
     const outcomes = [];
     const { backupBooksDirectory, booksDirectory } = context;
-    const archivesRoot = join19(dirname13(booksDirectory), MANUAL_ARCHIVES_PARTITION);
+    const archivesRoot = join21(dirname15(booksDirectory), MANUAL_ARCHIVES_PARTITION);
     for (const bookKey of await listMigrationBookKeys(backupBooksDirectory)) {
       for (const dirName of MANUAL_ARCHIVE_DIRECTORIES) {
-        const sourceDir = join19(backupBooksDirectory, bookKey, dirName);
+        const sourceDir = join21(backupBooksDirectory, bookKey, dirName);
         if (!await directoryExists(sourceDir)) continue;
-        await copyTree(sourceDir, join19(archivesRoot, bookKey, dirName));
+        await copyTree(sourceDir, join21(archivesRoot, bookKey, dirName));
         outcomes.push({
           disposition: "placed",
           source: sourceIdentity(backupBooksDirectory, sourceDir)
@@ -196763,11 +197379,11 @@ var BOOK_TOPOLOGY_T11_MIGRATORS = [
 
 // src/book-topology-record-class-migrators.ts
 import { appendFile as appendFile2, mkdir as mkdir5, readFile as readFile9, stat as stat5, writeFile as writeFile8 } from "node:fs/promises";
-import { dirname as dirname14, join as join20, relative as relative6, sep as sep9 } from "node:path";
-init_sitian_appender();
+import { dirname as dirname16, join as join22, relative as relative6, sep as sep9 } from "node:path";
 init_ticket_provenance_contracts();
 init_sha256();
 init_unknown_value();
+var LEGACY_SUBMISSION_LEDGER_KINDS = /* @__PURE__ */ new Set(["candidate", "roundContext", "outcome", "sealed", "post-seal-anomaly"]);
 var TICKET_PROVENANCE = "ticket-provenance";
 var SUBMISSION_LEDGER = "submission-ledger";
 var ATTEMPT_HISTORY = "attempt-history";
@@ -196856,14 +197472,14 @@ var RecordWriteCache = class {
       }
     }
     this.destPlacements.delete(recordFile);
-    await ensureDir(dirname14(recordFile));
+    await ensureDir(dirname16(recordFile));
     const text = body.endsWith("\n") ? body : `${body}
 `;
     await writeFile8(recordFile, text, "utf8");
     this.markBareVolume(recordFile);
   }
   async append(recordFile, raw, options) {
-    await ensureDir(dirname14(recordFile));
+    await ensureDir(dirname16(recordFile));
     const line = raw.endsWith("\n") ? raw : `${raw}
 `;
     const parsed2 = parseJsonlLine(raw);
@@ -196898,14 +197514,14 @@ function runIdFromPayload(payload) {
 function recordClassOfKind(kind) {
   if (kind === TICKET_PROVENANCE) return TICKET_PROVENANCE;
   if (kind === ATTEMPT_HISTORY) return ATTEMPT_HISTORY;
-  if (typeof kind === "string" && S4_SUBMISSION_LEDGER_KINDS.has(kind)) return SUBMISSION_LEDGER;
+  if (typeof kind === "string" && LEGACY_SUBMISSION_LEDGER_KINDS.has(kind)) return SUBMISSION_LEDGER;
   return void 0;
 }
 async function listFilesRecursive(root, predicate) {
   const out = [];
   async function walk3(directory) {
     for (const entry of await listMigrationDirents(directory)) {
-      const path8 = join20(directory, entry.name);
+      const path8 = join22(directory, entry.name);
       if (entry.isDirectory()) await walk3(path8);
       else if (entry.isFile() && predicate(entry.name)) out.push(path8);
     }
@@ -196914,10 +197530,10 @@ async function listFilesRecursive(root, predicate) {
   return out;
 }
 async function listVolumeRecordFiles(partitionDir) {
-  const files = [join20(partitionDir, "records.jsonl")];
+  const files = [join22(partitionDir, "records.jsonl")];
   for (const entry of await listMigrationDirents(partitionDir)) {
     if (!entry.isDirectory()) continue;
-    files.push(join20(partitionDir, entry.name, "records.jsonl"));
+    files.push(join22(partitionDir, entry.name, "records.jsonl"));
   }
   return files;
 }
@@ -196963,7 +197579,7 @@ function relativePathWithinRun(relPosix) {
   return parts.slice(runsIndex + 2).join("/");
 }
 function unboundCategoryFile(booksDirectory, bookKey, category, key) {
-  return join20(booksDirectory, bookKey, "unbound", category, key, "records.jsonl");
+  return join22(booksDirectory, bookKey, "unbound", category, key, "records.jsonl");
 }
 async function resolveRunDestination(context, bookKey, runId, hints) {
   const hasSessionParent = typeof hints.sessionParent === "string" && hints.sessionParent.length > 0;
@@ -197029,7 +197645,7 @@ async function placeTicketProvenanceLine(context, bookKey, writes, source, raw,
     await writes.append(unboundCategoryFile(context.booksDirectory, bookKey, TICKET_PROVENANCE, stableKey(raw)), raw);
     return { disposition: "unbound", source };
   }
-  const dest = join20(
+  const dest = join22(
     context.booksDirectory,
     bookKey,
     String(ticketNumber),
@@ -197074,7 +197690,7 @@ async function placeRunOwnedLine(context, bookKey, writes, category, source, raw
     await writes.append(unboundCategoryFile(context.booksDirectory, bookKey, category, target.key), raw);
     return { disposition: "unbound", source };
   }
-  await writes.append(join20(target.runDirectory, "session", category, "records.jsonl"), raw);
+  await writes.append(join22(target.runDirectory, "session", category, "records.jsonl"), raw);
   return { disposition: target.disposition, source };
 }
 async function placeRecordClassLine(context, bookKey, writes, source, raw, value2, fallbackCategory, outcomeIndex) {
@@ -197106,7 +197722,7 @@ function tryBareTicketProvenanceVolume(lines) {
   return { ticket: header.ticket, body };
 }
 async function placeBareTicketProvenanceVolume(context, bookKey, writes, filePath, bare, outcomes) {
-  const dest = join20(
+  const dest = join22(
     context.booksDirectory,
     bookKey,
     String(bare.ticket),
@@ -197177,7 +197793,7 @@ async function migrateJsonlFileByKind(context, bookKey, writes, filePath, fallba
 }
 var OFFERED_IDENTITIES = "offered-identities.jsonl";
 async function mergeOfferedIdentities(destDir, volumeDir, writes) {
-  const from = join20(volumeDir, OFFERED_IDENTITIES);
+  const from = join22(volumeDir, OFFERED_IDENTITIES);
   let lines;
   try {
     await stat5(from);
@@ -197186,14 +197802,14 @@ async function mergeOfferedIdentities(destDir, volumeDir, writes) {
     if (isEnoent(error)) return;
     throw error;
   }
-  const destFile = join20(destDir, OFFERED_IDENTITIES);
+  const destFile = join22(destDir, OFFERED_IDENTITIES);
   for (const raw of lines) {
     if (raw.trim() === "") continue;
     await writes.append(destFile, raw);
   }
 }
 async function ticketNumbersInVolume(volumeDir) {
-  const lines = await readJsonlLines(join20(volumeDir, "records.jsonl"));
+  const lines = await readJsonlLines(join22(volumeDir, "records.jsonl"));
   const bare = tryBareTicketProvenanceVolume(lines);
   if (bare !== void 0) return [bare.ticket];
   const out = [];
@@ -197212,29 +197828,29 @@ async function ticketNumbersInVolume(volumeDir) {
 }
 async function mergeCompanionsFromVolume(context, bookKey, volumeDir, writes) {
   for (const ticketNumber of await ticketNumbersInVolume(volumeDir)) {
-    const destDir = join20(context.booksDirectory, bookKey, String(ticketNumber));
+    const destDir = join22(context.booksDirectory, bookKey, String(ticketNumber));
     await ensureDir(destDir);
     await mergeOfferedIdentities(destDir, volumeDir, writes);
   }
 }
 async function migrateHomePartitionBook(context, bookKey, writes, category, outcomes) {
-  const backupBook = join20(context.backupBooksDirectory, bookKey);
-  const rootFiles = await listVolumeRecordFiles(join20(backupBook, category));
+  const backupBook = join22(context.backupBooksDirectory, bookKey);
+  const rootFiles = await listVolumeRecordFiles(join22(backupBook, category));
   for (const filePath of rootFiles) {
     await migrateJsonlFileByKind(context, bookKey, writes, filePath, category, outcomes);
     if (category === TICKET_PROVENANCE) {
-      await mergeCompanionsFromVolume(context, bookKey, dirname14(filePath), writes);
+      await mergeCompanionsFromVolume(context, bookKey, dirname16(filePath), writes);
     }
   }
   if (category !== TICKET_PROVENANCE) return;
   for (const entry of await listMigrationDirents(backupBook)) {
     if (!entry.isDirectory() || !isTicketNumberString2(entry.name)) continue;
-    const ticketDir = join20(backupBook, entry.name);
+    const ticketDir = join22(backupBook, entry.name);
     for (const volumeDir of [
-      join20(ticketDir, TICKET_PROVENANCE),
+      join22(ticketDir, TICKET_PROVENANCE),
       ticketDir
     ]) {
-      const recordsFile = join20(volumeDir, "records.jsonl");
+      const recordsFile = join22(volumeDir, "records.jsonl");
       try {
         await stat5(recordsFile);
       } catch (error) {
@@ -197266,11 +197882,11 @@ async function scrubRawLinesFromFile(recordFile, rawLines) {
     kept.push(normalized);
   }
   if (!changed) return;
-  await ensureDir(dirname14(recordFile));
+  await ensureDir(dirname16(recordFile));
   await writeFile8(recordFile, kept.join(""), "utf8");
 }
 async function migrateMisplacedBook(context, bookKey, writes, outcomes) {
-  const backupBook = join20(context.backupBooksDirectory, bookKey);
+  const backupBook = join22(context.backupBooksDirectory, bookKey);
   const files = await listFilesRecursive(backupBook, (name) => name.endsWith(".jsonl"));
   const scrubPlans = /* @__PURE__ */ new Map();
   for (const filePath of files) {
@@ -197319,12 +197935,12 @@ async function migrateMisplacedBook(context, bookKey, writes, outcomes) {
     const withinRun = relativePathWithinRun(withinBook);
     if (coords === void 0 || withinRun === void 0) continue;
     const destRun = await findBookRunDirectory(
-      join20(context.booksDirectory, bookKey),
+      join22(context.booksDirectory, bookKey),
       coords.runId,
       coords.role
     );
     if (destRun === void 0) continue;
-    await scrubRawLinesFromFile(join20(destRun.runDirectory, withinRun), rawLines);
+    await scrubRawLinesFromFile(join22(destRun.runDirectory, withinRun), rawLines);
   }
 }
 async function forEachBook(context, body) {
@@ -197373,9 +197989,10 @@ var BOOK_TOPOLOGY_RECORD_CLASS_MIGRATORS = [
 
 // src/book-topology-runs-migrator.ts
 import { cp as cp4, mkdir as mkdir6, rename as rename2, readdir as readdir7, stat as stat6, writeFile as writeFile9 } from "node:fs/promises";
-import { basename as basename11, dirname as dirname15, join as join21, relative as relative7, sep as sep10 } from "node:path";
+import { basename as basename14, dirname as dirname17, join as join23, relative as relative7, sep as sep10 } from "node:path";
 init_role_run_placement();
 init_role_run_relocation();
+init_run_dossier();
 init_run_ticket_number();
 init_unknown_value();
 var RUNS_PARTITION = "runs";
@@ -197402,18 +198019,18 @@ async function writeDerivationPage(targetRunDirectory, derivation) {
       page: derivation.sourcePage,
       field: "projectRoot",
       path: derivation.projectRoot,
-      basename: basename11(derivation.projectRoot)
+      basename: basename14(derivation.projectRoot)
     }
   };
   await writeFile9(
-    join21(targetRunDirectory, MIGRATION_TICKET_DERIVATION_PAGE),
+    join23(targetRunDirectory, MIGRATION_TICKET_DERIVATION_PAGE),
     `${JSON.stringify(page, null, 2)}
 `,
     "utf8"
   );
 }
 async function copyRunTree(source, target, isDirectory) {
-  await mkdir6(dirname15(target), { recursive: true });
+  await mkdir6(dirname17(target), { recursive: true });
   if (isDirectory) {
     await cp4(source, target, { recursive: true, preserveTimestamps: true });
     return;
@@ -197421,7 +198038,7 @@ async function copyRunTree(source, target, isDirectory) {
   await cp4(source, target, { preserveTimestamps: true });
 }
 async function planBookMoves(backupBooksDirectory, booksDirectory, bookKey) {
-  const backupBook = join21(backupBooksDirectory, bookKey);
+  const backupBook = join23(backupBooksDirectory, bookKey);
   const claimed = /* @__PURE__ */ new Map();
   const planned = [];
   for (const leaf of await listBackupRunLeaves(backupBook)) {
@@ -197435,9 +198052,9 @@ async function planBookMoves(backupBooksDirectory, booksDirectory, bookKey) {
       const parts = leaf.relativePath.replaceAll("\\", "/").split("/");
       const ticketStr = parts[1];
       if (ticketStr !== void 0 && isTicketNumberString2(ticketStr)) {
-        targetPath = join21(booksDirectory, bookKey, ticketStr, "runs", leaf.leafName);
+        targetPath = join23(booksDirectory, bookKey, ticketStr, "runs", leaf.leafName);
         disposition = "placed";
-        historicalRunDirectory = join21(
+        historicalRunDirectory = join23(
           booksDirectory,
           bookKey,
           "issues",
@@ -197446,13 +198063,13 @@ async function planBookMoves(backupBooksDirectory, booksDirectory, bookKey) {
           leaf.leafName
         );
       } else {
-        targetPath = join21(booksDirectory, bookKey, "unbound", "runs", leaf.leafName);
+        targetPath = join23(booksDirectory, bookKey, "unbound", "runs", leaf.leafName);
         disposition = "unbound";
-        historicalRunDirectory = join21(booksDirectory, bookKey, leaf.relativePath);
+        historicalRunDirectory = join23(booksDirectory, bookKey, leaf.relativePath);
       }
       derivation = void 0;
     } else if (leaf.layout === "unbound") {
-      const boardTicket = leaf.isDirectory ? await readBoardTicketNumber(leaf.sourcePath) : void 0;
+      const boardTicket = leaf.isDirectory ? await readMigrationBoardTicketNumber(leaf.sourcePath) : void 0;
       if (parsed2 !== void 0 && boardTicket !== void 0) {
         targetPath = destinationRunDirectory(
           booksDirectory,
@@ -197462,7 +198079,7 @@ async function planBookMoves(backupBooksDirectory, booksDirectory, bookKey) {
           parsed2.role
         );
         disposition = "placed";
-        historicalRunDirectory = join21(
+        historicalRunDirectory = join23(
           booksDirectory,
           bookKey,
           "unbound",
@@ -197470,20 +198087,20 @@ async function planBookMoves(backupBooksDirectory, booksDirectory, bookKey) {
           leaf.leafName
         );
       } else {
-        targetPath = join21(booksDirectory, bookKey, leaf.relativePath);
+        targetPath = join23(booksDirectory, bookKey, leaf.relativePath);
         disposition = "unbound";
         historicalRunDirectory = void 0;
       }
       derivation = void 0;
     } else if (leaf.layout !== "flat") {
-      targetPath = join21(booksDirectory, bookKey, leaf.relativePath);
+      targetPath = join23(booksDirectory, bookKey, leaf.relativePath);
       disposition = "placed";
       historicalRunDirectory = void 0;
       derivation = void 0;
     } else if (parsed2 === void 0) {
-      targetPath = join21(booksDirectory, bookKey, "unbound", "runs", leaf.leafName);
+      targetPath = join23(booksDirectory, bookKey, "unbound", "runs", leaf.leafName);
       disposition = "unbound";
-      historicalRunDirectory = join21(booksDirectory, bookKey, "runs", leaf.leafName);
+      historicalRunDirectory = join23(booksDirectory, bookKey, "runs", leaf.leafName);
       derivation = void 0;
     } else {
       const ticket = await resolveMigratingRunTicket(leaf.sourcePath);
@@ -197495,7 +198112,7 @@ async function planBookMoves(backupBooksDirectory, booksDirectory, bookKey) {
         parsed2.role
       );
       disposition = ticket.ticketNumber === void 0 ? "unbound" : "placed";
-      historicalRunDirectory = join21(booksDirectory, bookKey, "runs", leaf.leafName);
+      historicalRunDirectory = join23(booksDirectory, bookKey, "runs", leaf.leafName);
       derivation = ticket.derivation?.method === "project-root-basename" && ticket.ticketNumber !== void 0 ? {
         ticketNumber: ticket.ticketNumber,
         projectRoot: ticket.derivation.source,
@@ -197564,9 +198181,9 @@ var bookTopologyRunsMigrator = {
   }
 };
 async function relocateBoardBoundUnboundRunsInBook(bookDirectory) {
-  const bookKey = basename11(bookDirectory);
-  const booksDirectory = dirname15(bookDirectory);
-  const unboundRuns = join21(bookDirectory, "unbound", "runs");
+  const bookKey = basename14(bookDirectory);
+  const booksDirectory = dirname17(bookDirectory);
+  const unboundRuns = join23(bookDirectory, "unbound", "runs");
   let entries;
   try {
     entries = await readdir7(unboundRuns, { withFileTypes: true });
@@ -197579,8 +198196,8 @@ async function relocateBoardBoundUnboundRunsInBook(bookDirectory) {
     if (!entry.isDirectory()) continue;
     const parsed2 = parseRunLeaf3(entry.name);
     if (parsed2 === void 0) continue;
-    const sourcePath = join21(unboundRuns, entry.name);
-    const boardTicket = await readBoardTicketNumber(sourcePath);
+    const sourcePath = join23(unboundRuns, entry.name);
+    const boardTicket = await readMigrationBoardTicketNumber(sourcePath);
     if (boardTicket === void 0) continue;
     const targetPath = destinationRunDirectory(
       booksDirectory,
@@ -197620,8 +198237,9 @@ async function relocateBoardBoundUnboundRunsInBook(bookDirectory) {
     });
   }
   for (const move of planned) {
-    await mkdir6(dirname15(move.targetPath), { recursive: true });
+    await mkdir6(dirname17(move.targetPath), { recursive: true });
     await rename2(move.sourcePath, move.targetPath);
+    renderCurrentSync(move.targetPath);
   }
   return planned.map((move) => ({
     from: move.sourcePath,
@@ -197633,7 +198251,7 @@ async function relocateBoardBoundUnboundRunsInBooks(booksDirectory) {
   const relocated = [];
   for (const bookKey of await listMigrationBookKeys(booksDirectory)) {
     const batch = await relocateBoardBoundUnboundRunsInBook(
-      join21(booksDirectory, bookKey)
+      join23(booksDirectory, bookKey)
     );
     relocated.push(...batch);
   }
@@ -197662,7 +198280,7 @@ function parseMigrateArgv(argv) {
     if (arg === "--ledger-home") {
       const value2 = argv[i2 + 1];
       if (value2 === void 0) throw new Error(USAGE);
-      ledgerHome = resolve11(value2);
+      ledgerHome = resolve12(value2);
       i2 += 1;
       continue;
     }
@@ -197672,9 +198290,9 @@ function parseMigrateArgv(argv) {
 }
 var parsed = parseMigrateArgv(process.argv.slice(2));
 if (parsed.relocateBoardBoundUnbound) {
-  const ledgerHome = parsed.ledgerHome ?? join22(homedir6(), ".ak-roles");
+  const ledgerHome = parsed.ledgerHome ?? join24(homedir6(), ".ak-roles");
   const relocated = await relocateBoardBoundUnboundRunsInBooks(
-    join22(ledgerHome, "books")
+    join24(ledgerHome, "books")
   );
   process.stdout.write(
     `${JSON.stringify({ ledgerHome, relocatedCount: relocated.length, relocated }, null, 2)}