@akagilnc/pi-workflow-roles 0.1.4291 → 0.1.4321

package/src/ticket-provenance.ts

@@ -1,15 +1,20 @@
 /**
- * 起居录 volume helpers — ADR 0075「2026-09-14 修订」/ #901。
- * 一册＝一个文件：首行册子头，其后裸对话行。每轮按当前区间重投影是唯一机制；
- * 无 append 水位、无 SitianRecord 外壳。目的地解析与读写经司天台唯一入口
- * （ADR 0065 records-owner / record-entry；ADR 0081 入录经司天台）。
+ * 起居录 volume helpers — ADR 0075「2026-09-14 修订」/ #901 / #918。
+ * 一册＝一个追加式 records.jsonl。每轮新投影经司天台 appender 追加为不可变提交；
+ * 读取时折叠全部提交得到累计 sessions 与对话视图。既有首行册子头＋裸对话行的
+ * snapshot 继续可读，但后续不为升级回写旧卷。
  */
+import { createHash } from "node:crypto";
+import { appendFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import { basename, dirname, join, resolve } from "node:path";
 
 import { resolveBookKeyFromGit } from "./activation-ledger-git.ts";
 import {
+  ensureRealDirectoryTree,
   errnoCode,
   packageMachineHome,
+  physicalPathIdentity,
   physicallyContainedIn,
   resolveActivationLedgerHome,
 } from "./activation-ledger-topology.ts";
@@ -20,16 +25,15 @@ import {
 import { isSafePositiveTicketNumber } from "./run-ticket-number.ts";
 import { adaptSessionDialogue, nativeEventId } from "./session-dialogue.ts";
 import {
-  ensureSitianVolume,
-  readSitianVolumeText,
-  resolveSitianVolume,
-  rewriteSitianVolume,
+  appendSitianRecord,
+  resolveSitianRecordPath,
   type SitianRecordInput,
 } from "./sitian-facade.ts";
 import {
   TICKET_PROVENANCE_KIND,
   projectTicketProvenanceHeader,
   projectTicketProvenanceLine,
+  projectTicketProvenanceSessions,
   type TicketProvenanceAmendment,
   type TicketProvenanceBound,
   type TicketProvenanceHeader,
@@ -59,7 +63,9 @@ export class TicketProvenanceInputError extends Error {
  */
 export function dialogueSessionSourceRoots(home?: string): readonly string[] {
   const machineHome =
-    typeof home === "string" && home.trim() !== "" ? home : packageMachineHome();
+    typeof home === "string" && home.trim() !== ""
+      ? home
+      : packageMachineHome();
   return [
     join(machineHome, ".claude", "projects"),
     join(machineHome, ".codex", "sessions"),
@@ -73,10 +79,15 @@ export function dialogueSessionSourceRoots(home?: string): readonly string[] {
  */
 function isLedgerRoleSessionFile(absolute: string, home?: string): boolean {
   const machineHome =
-    typeof home === "string" && home.trim() !== "" ? home : packageMachineHome();
+    typeof home === "string" && home.trim() !== ""
+      ? home
+      : packageMachineHome();
   const ledgerHome = resolveActivationLedgerHome(machineHome);
   if (!physicallyContainedIn(ledgerHome, absolute)) return false;
-  return basename(absolute) === "session.jsonl" && basename(dirname(absolute)) === "session";
+  return (
+    basename(absolute) === "session.jsonl" &&
+    basename(dirname(absolute)) === "session"
+  );
 }
 
 /** Real I/O seam gate: only host session stores or sitian role-run session.jsonl. */
@@ -127,12 +138,47 @@ export function resolveTicketProvenanceVolume(
   cwd: string,
   home?: string,
 ): TicketProvenanceVolumePath {
-  return resolveSitianVolume(ticketProvenanceRecordInput(ticketNumber, cwd, home));
+  const path = resolveSitianRecordPath(
+    ticketProvenanceRecordInput(ticketNumber, cwd, home),
+  );
+  return { recordFile: path.recordFile, volumeDir: path.sessionDir };
+}
+
+type TicketProvenanceCommit = {
+  readonly timestamp: string;
+  readonly sessions: readonly TicketProvenanceSession[];
+  readonly lines: readonly TicketProvenanceLine[];
+};
+
+function projectTicketProvenanceCommit(value: unknown): TicketProvenanceCommit | undefined {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return undefined;
+  const record = value as Record<string, unknown>;
+  if (record.kind !== TICKET_PROVENANCE_KIND || typeof record.timestamp !== "string") {
+    return undefined;
+  }
+  const payload = record.payload;
+  if (typeof payload !== "object" || payload === null || Array.isArray(payload)) return undefined;
+  const body = payload as Record<string, unknown>;
+  if (body.type !== "ticket-provenance-append") return undefined;
+  const sessions = projectTicketProvenanceSessions(body.sessions);
+  if (sessions === undefined || !Array.isArray(body.lines)) return undefined;
+  const lines: TicketProvenanceLine[] = [];
+  for (const raw of body.lines) {
+    const line = projectTicketProvenanceLine(raw);
+    if (line === undefined) return undefined;
+    lines.push(line);
+  }
+  return { timestamp: record.timestamp, sessions, lines };
 }
 
 export type ReadTicketProvenanceResult = {
   readonly header: TicketProvenanceHeader | undefined;
   readonly lines: readonly TicketProvenanceLine[];
+  /**
+   * Body rows that could not be projected (bad JSON or unusable shape).
+   * Kept byte-stable across lawful rewrites — 证不出的原样留存 (#918 / G8).
+   */
+  readonly unprojectedRaw: readonly string[];
   readonly recordFile: string;
 };
 
@@ -142,15 +188,20 @@ export async function readTicketProvenance(
   cwd: string,
   home?: string,
 ): Promise<ReadTicketProvenanceResult> {
-  const { recordFile, text } = await readSitianVolumeText(
-    ticketProvenanceRecordInput(ticketNumber, cwd, home),
-  );
-  if (text === undefined) {
-    return { header: undefined, lines: [], recordFile };
+  const { recordFile } = resolveTicketProvenanceVolume(ticketNumber, cwd, home);
+  let text: string;
+  try {
+    text = await readFile(recordFile, "utf8");
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+      return { header: undefined, lines: [], unprojectedRaw: [], recordFile };
+    }
+    throw error;
   }
   const physical = text.split("\n");
   let header: TicketProvenanceHeader | undefined;
   const lines: TicketProvenanceLine[] = [];
+  const unprojectedRaw: string[] = [];
   let sawFirst = false;
   for (let index = 0; index < physical.length; index += 1) {
     const raw = physical[index]!;
@@ -159,19 +210,47 @@ export async function readTicketProvenance(
     try {
       parsed = JSON.parse(raw);
     } catch {
-      // Stock / damaged rows stay unprojected — no backfill, no guess.
+      // Stock / damaged rows stay unprojected — keep raw bytes on rewrite.
+      unprojectedRaw.push(raw);
       continue;
     }
     if (!sawFirst) {
       sawFirst = true;
       header = projectTicketProvenanceHeader(parsed);
-      // First line that is not a header is treated as a body line (stock shapes).
+      // Legacy snapshot: first line header followed by bare dialogue rows.
       if (header !== undefined) continue;
     }
     const line = projectTicketProvenanceLine(parsed);
-    if (line !== undefined) lines.push(line);
+    if (line !== undefined) {
+      lines.push(line);
+      continue;
+    }
+    const commit = projectTicketProvenanceCommit(parsed);
+    if (commit !== undefined) {
+      const merged = mergeSessionBounds(header?.sessions, commit.sessions);
+      const remapped = commit.lines.map((entry) => ({
+        ...entry,
+        s: merged.incomingIndexes[entry.s] ?? entry.s,
+      }));
+      const now = commit.timestamp;
+      header = {
+        repo: header?.repo ?? resolveBookKeyFromGit(cwd),
+        ticket: ticketNumber,
+        createdAt: header?.createdAt ?? now,
+        updatedAt: now,
+        sessions: merged.sessions,
+      };
+      const carried = lines.map((entry) => ({
+        ...entry,
+        s: merged.priorIndexes[entry.s] ?? entry.s,
+      }));
+      lines.splice(0, lines.length, ...mergeFreshIntoCarried(carried, remapped));
+      continue;
+    }
+    // Unknown stock / damaged rows remain readable and are never upgraded in place.
+    unprojectedRaw.push(raw);
   }
-  return { header, lines, recordFile };
+  return { header, lines, unprojectedRaw, recordFile };
 }
 
 /**
@@ -183,7 +262,11 @@ export function ensureTicketProvenanceVolume(
   cwd: string,
   home?: string,
 ): TicketProvenanceVolumePath {
-  return ensureSitianVolume(ticketProvenanceRecordInput(ticketNumber, cwd, home));
+  const input = ticketProvenanceRecordInput(ticketNumber, cwd, home);
+  const path = resolveSitianRecordPath(input);
+  ensureRealDirectoryTree(path.ledgerHome, path.sessionDir);
+  appendFileSync(path.recordFile, "", "utf8");
+  return { recordFile: path.recordFile, volumeDir: path.sessionDir };
 }
 
 /** One session line the mechanical projector could not enter. */
@@ -231,6 +314,149 @@ function amendmentKey(s: number, line: number): string {
   return `${s}:${line}`;
 }
 
+/** Exact range identity for cumulative header dedupe (idempotent resubmit). */
+function rangeDeclarationKey(range: TicketProvenanceRange): string {
+  return JSON.stringify({
+    from: range.from,
+    to: range.to,
+  });
+}
+
+/**
+ * #918 甲案：prior ranges ∪ 本轮 ranges。按 path 合并；先保 prior 序，再追加新 path。
+ * path identity 与 I/O 接缝同用 `physicalPathIdentity`（symlink-stable），故
+ * `p` / `p/./` / 经 symlink 祖先的别名合为一条；保留首见 path 字面与累计 ranges。
+ * 即使 prior 缺失 / sessions=[]，incoming 自身也必须按 identity 归并——首轮同一
+ * 物理卷不得铸出多个 s（#918 C5）。遗漏不代表删除。
+ */
+function mergeSessionBounds(
+  prior: readonly TicketProvenanceSession[] | undefined,
+  incoming: readonly TicketProvenanceSession[],
+): {
+  readonly sessions: readonly TicketProvenanceSession[];
+  readonly priorIndexes: readonly number[];
+  readonly incomingIndexes: readonly number[];
+} {
+  const merged: { path: string; ranges: TicketProvenanceRange[] }[] = [];
+  const indexByIdentity = new Map<string, number>();
+
+  const absorb = (sessions: readonly TicketProvenanceSession[]): number[] => {
+    const indexes: number[] = [];
+    for (const session of sessions) {
+      const identity = physicalPathIdentity(session.path);
+      let targetIndex = indexByIdentity.get(identity);
+      if (targetIndex === undefined) {
+        targetIndex = merged.length;
+        indexByIdentity.set(identity, targetIndex);
+        merged.push({ path: session.path, ranges: [] });
+      }
+      indexes.push(targetIndex);
+      const target = merged[targetIndex]!;
+      const seen = new Set(target.ranges.map(rangeDeclarationKey));
+      for (const range of session.ranges) {
+        const key = rangeDeclarationKey(range);
+        if (seen.has(key)) continue;
+        seen.add(key);
+        target.ranges.push({ from: { ...range.from }, to: { ...range.to } });
+      }
+    }
+    return indexes;
+  };
+
+  const priorIndexes = absorb(prior ?? []);
+  const incomingIndexes = absorb(incoming);
+  return { sessions: merged, priorIndexes, incomingIndexes };
+}
+
+/**
+ * #918 第一节：已投影行即卷宗。只对 prior 未声明的 range（按 path identity + 精确
+ * from/to）读源；已声明的按 s,line 结转，不重读历史源。
+ */
+function undeclaredSessionRanges(
+  prior: readonly TicketProvenanceSession[] | undefined,
+  merged: readonly TicketProvenanceSession[],
+): readonly {
+  readonly s: number;
+  readonly session: TicketProvenanceSession;
+}[] {
+  const priorKeys = new Map<string, Set<string>>();
+  for (const session of prior ?? []) {
+    const identity = physicalPathIdentity(session.path);
+    let keys = priorKeys.get(identity);
+    if (keys === undefined) {
+      keys = new Set();
+      priorKeys.set(identity, keys);
+    }
+    for (const range of session.ranges) keys.add(rangeDeclarationKey(range));
+  }
+  const out: { s: number; session: TicketProvenanceSession }[] = [];
+  for (let s = 0; s < merged.length; s += 1) {
+    const session = merged[s]!;
+    const declared =
+      priorKeys.get(physicalPathIdentity(session.path)) ?? new Set();
+    const fresh = session.ranges.filter(
+      (range) => !declared.has(rangeDeclarationKey(range)),
+    );
+    if (fresh.length === 0) continue;
+    out.push({
+      s,
+      session: {
+        path: session.path,
+        ranges: fresh.map((range) => ({
+          from: { ...range.from },
+          to: { ...range.to },
+        })),
+      },
+    });
+  }
+  return out;
+}
+
+/** Sort archive rows by session index then source line (stable within equal keys). */
+function compareLinePosition(
+  left: TicketProvenanceLine,
+  right: TicketProvenanceLine,
+): number {
+  if (left.s !== right.s) return left.s - right.s;
+  const leftLine = left.line ?? Number.MAX_SAFE_INTEGER;
+  const rightLine = right.line ?? Number.MAX_SAFE_INTEGER;
+  return leftLine - rightLine;
+}
+
+/**
+ * Merge newly projected rows into the carried archive.
+ * 既有卷宗按 (s,line) 优先；fresh 不得复制无 id 行（#918 C2/G1）。
+ * id 去重仍保留（跨 path 同 id 首见胜）。
+ */
+function mergeFreshIntoCarried(
+  carried: readonly TicketProvenanceLine[],
+  fresh: readonly TicketProvenanceLine[],
+): TicketProvenanceLine[] {
+  const seenIds = new Set<string>();
+  const seenPositions = new Set<string>();
+  const out: TicketProvenanceLine[] = [];
+  for (const line of carried) {
+    if (line.id !== undefined) seenIds.add(line.id);
+    if (line.line !== undefined)
+      seenPositions.add(amendmentKey(line.s, line.line));
+    out.push(line);
+  }
+  for (const line of fresh) {
+    if (line.id !== undefined) {
+      if (seenIds.has(line.id)) continue;
+      seenIds.add(line.id);
+    }
+    if (line.line !== undefined) {
+      const position = amendmentKey(line.s, line.line);
+      if (seenPositions.has(position)) continue;
+      seenPositions.add(position);
+    }
+    out.push(line);
+  }
+  out.sort(compareLinePosition);
+  return out;
+}
+
 /**
  * Resolve submitted ranges against the session, then sort by source position and
  * merge overlaps so each physical row is visited once (#901 source order).
@@ -354,10 +580,12 @@ async function projectSessionRanges(input: {
 }
 
 /**
- * Reproject the unique diary file from the submitted bounds + optional amendments.
- * Header + locating fields may change; dialogue text is taken from the source
- * (or from a typed amendment). Does not append; the whole file is the projection.
- * Persistence goes through the Sitian volume seam (rewriteSitianVolume).
+ * Reproject the unique diary from cumulative bounds + optional amendments.
+ * #918：已投影行即卷宗——按 s,line 结转；本轮只读 prior 未声明的 range（或新
+ * session 区间）。精确重复提交＝幂等 no-op，不因历史源不可读而失败。
+ * amendments 只在本轮读取的新范围确有对应坏行时生效；空 sessions 保持 no-op。
+ * 证不出的 body 原字节经 unprojectedRaw 原样留存。
+ * Persistence appends one immutable commit through the Sitian appender seam.
  */
 export async function reprojectTicketProvenance(input: {
   readonly ticketNumber: number;
@@ -366,96 +594,107 @@ export async function reprojectTicketProvenance(input: {
   readonly sessions: readonly TicketProvenanceSession[];
   readonly amendments?: readonly TicketProvenanceAmendment[];
 }): Promise<ReprojectTicketProvenanceResult> {
-  const recordInput = ticketProvenanceRecordInput(
-    input.ticketNumber,
-    input.cwd,
-    input.home,
-  );
   const prior = await readTicketProvenance(input.ticketNumber, input.cwd, input.home);
-  const priorRaw = await readSitianVolumeText(recordInput);
-  const priorNonEmpty =
-    priorRaw.text !== undefined && priorRaw.text.trim() !== "";
-
-  const amendments = input.amendments ?? [];
-  // Empty sessions: pure empty selection preserves non-empty volume. Amendments-only
-  // continuation reuses prior header sessions — never wash into accepted no-op.
-  let sessions = input.sessions;
-  if (sessions.length === 0) {
-    if (amendments.length > 0) {
-      const priorSessions = prior.header?.sessions;
-      if (priorSessions === undefined || priorSessions.length === 0) {
-        throw new TicketProvenanceInputError(
-          "amendments require sessions bounds (none submitted and no prior header sessions)",
-        );
-      }
-      sessions = priorSessions;
-    } else if (priorNonEmpty) {
-      const now = new Date().toISOString();
-      const header: TicketProvenanceHeader =
-        prior.header ??
-        ({
-          repo: resolveBookKeyFromGit(input.cwd),
-          ticket: input.ticketNumber,
-          createdAt: now,
-          updatedAt: now,
-          sessions: [],
-        } satisfies TicketProvenanceHeader);
-      return {
-        recordFile: prior.recordFile,
-        header,
-        lines: prior.lines,
-        unparsable: [],
-      };
-    }
+  if (input.sessions.length === 0) {
+    const now = new Date().toISOString();
+    return {
+      recordFile: prior.recordFile,
+      header: prior.header ?? {
+        repo: resolveBookKeyFromGit(input.cwd),
+        ticket: input.ticketNumber,
+        createdAt: now,
+        updatedAt: now,
+        sessions: [],
+      },
+      lines: prior.lines,
+      unparsable: [],
+    };
+  }
+
+  const merged = mergeSessionBounds(prior.header?.sessions, input.sessions);
+  const deltas = undeclaredSessionRanges(prior.header?.sessions, merged.sessions);
+  if (deltas.length === 0) {
+    const now = new Date().toISOString();
+    return {
+      recordFile: prior.recordFile,
+      header: prior.header ?? {
+        repo: resolveBookKeyFromGit(input.cwd),
+        ticket: input.ticketNumber,
+        createdAt: now,
+        updatedAt: now,
+        sessions: merged.sessions,
+      },
+      lines: prior.lines,
+      unparsable: [],
+    };
   }
 
   const amendmentsByKey = new Map<string, TicketProvenanceAmendment>();
-  for (const amendment of amendments) {
-    amendmentsByKey.set(amendmentKey(amendment.s, amendment.line), amendment);
+  for (const amendment of input.amendments ?? []) {
+    const cumulativeIndex = merged.incomingIndexes[amendment.s];
+    if (cumulativeIndex === undefined) continue;
+    amendmentsByKey.set(amendmentKey(cumulativeIndex, amendment.line), {
+      ...amendment,
+      s: cumulativeIndex,
+    });
   }
 
-  const lines: TicketProvenanceLine[] = [];
+  const seenIds = new Set(
+    prior.lines.flatMap((line) => line.id === undefined ? [] : [line.id]),
+  );
+  const fresh: TicketProvenanceLine[] = [];
   const unparsable: UnparsableSessionLine[] = [];
-  // First-seen native id across the whole reproject (rewritten session copies).
-  const seenIds = new Set<string>();
-  for (let s = 0; s < sessions.length; s += 1) {
+  for (const delta of deltas) {
     const projected = await projectSessionRanges({
-      s,
-      session: sessions[s]!,
+      s: delta.s,
+      session: delta.session,
       amendmentsByKey,
       seenIds,
       ...(input.home === undefined ? {} : { home: input.home }),
     });
-    lines.push(...projected.lines);
+    fresh.push(...projected.lines);
     unparsable.push(...projected.unparsable);
   }
-
+  const lines = mergeFreshIntoCarried(prior.lines, fresh);
   const now = new Date().toISOString();
   const header: TicketProvenanceHeader = {
-    repo: resolveBookKeyFromGit(input.cwd),
+    repo: prior.header?.repo ?? resolveBookKeyFromGit(input.cwd),
     ticket: input.ticketNumber,
     createdAt: prior.header?.createdAt ?? now,
     updatedAt: now,
-    sessions,
+    sessions: merged.sessions,
   };
-
-  // Still-open gaps → reask without publishing a partial/rejected projection.
   if (unparsable.length > 0) {
-    return {
-      recordFile: prior.recordFile,
-      header,
-      lines,
-      unparsable,
-    };
+    return { recordFile: prior.recordFile, header, lines, unparsable };
   }
 
-  const body = `${[JSON.stringify(header), ...lines.map((line) => JSON.stringify(line))].join("\n")}\n`;
-  const volume = await rewriteSitianVolume({ ...recordInput, body });
-
+  // One immutable projection commit. Its deterministic identity makes retries of
+  // the same logical increment converge, while unrelated concurrent increments
+  // append independently and are folded by readTicketProvenance.
+  const identityMaterial = JSON.stringify({
+    ticket: input.ticketNumber,
+    deltas: deltas.map(({ s, session }) => ({
+      s,
+      path: physicalPathIdentity(session.path),
+      ranges: session.ranges,
+    })),
+    lines: fresh,
+  });
+  const identity = `ticket-provenance:${createHash("sha256").update(identityMaterial).digest("hex")}`;
+  const pointer = appendSitianRecord({
+    ...ticketProvenanceRecordInput(input.ticketNumber, input.cwd, input.home),
+    identity,
+    payload: {
+      type: "ticket-provenance-append",
+      sessions: merged.sessions,
+      lines: fresh,
+    },
+  });
+  const folded = await readTicketProvenance(input.ticketNumber, input.cwd, input.home);
   return {
-    recordFile: volume.recordFile,
-    header,
-    lines,
-    unparsable,
+    recordFile: pointer.recordFile,
+    header: folded.header ?? header,
+    lines: folded.lines,
+    unparsable: [],
   };
 }

package/dist/atomic-write.js

@@ -1,23 +0,0 @@
-/**
- * Same-directory temp + rename atomic file replace.
- * Shared primitive for ledger-adjacent typed pages (analyst metrics, etc.).
- * Does not open/truncate an existing destination inode, so hard-linked twins
- * keep prior bytes until the directory entry is swapped.
- * Parent directory must already exist — callers that write under the package
- * ledger home own confinement via ensureRealDirectoryTree (ADR 0038).
- */
-import { randomUUID } from "node:crypto";
-import { rename, rm, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
-export async function writeFileAtomically(destination, contents) {
-    const parent = dirname(destination);
-    const temporary = join(parent, `.atomic-write-${randomUUID()}.tmp`);
-    try {
-        await writeFile(temporary, contents);
-        await rename(temporary, destination);
-    }
-    catch (error) {
-        await rm(temporary, { force: true }).catch(() => undefined);
-        throw error;
-    }
-}

package/dist/sitian-volume.js

@@ -1,67 +0,0 @@
-/**
- * Sitian whole-file volume I/O (ADR 0065 records-owner / record-entry).
- *
- * Owns destination resolution, create, raw read, and whole-file rewrite for
- * kinds whose persistence shape is not the appender SitianRecord row
- * (ticket-provenance header + bare dialogue lines, #901). Appender kernel
- * stays append-only; this module does not restore append watermarks.
- */
-import { appendFileSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-import { ensureRealDirectoryTree, errorText, } from "./activation-ledger-topology.js";
-import { writeFileAtomically } from "./atomic-write.js";
-import { resolveSitianRecordPath } from "./sitian-appender.js";
-import { SitianInfrastructureError, } from "./sitian-contracts.js";
-/** Resolve a volume path from ambient topology — callers never pick the destination. */
-export function resolveSitianVolume(input) {
-    const path = resolveSitianRecordPath(input);
-    return { recordFile: path.recordFile, volumeDir: path.sessionDir };
-}
-/**
- * Ensure the volume directory + file exist.
- * Append-open creates an absent volume without truncating concurrent first writers.
- */
-export function ensureSitianVolume(input) {
-    try {
-        const { sessionDir, recordFile, ledgerHome } = resolveSitianRecordPath(input);
-        ensureRealDirectoryTree(ledgerHome, sessionDir);
-        appendFileSync(recordFile, "", "utf8");
-        return { recordFile, volumeDir: sessionDir };
-    }
-    catch (error) {
-        if (error instanceof SitianInfrastructureError)
-            throw error;
-        throw new SitianInfrastructureError(`Sitian volume ensure failure: ${errorText(error)}`, { cause: error });
-    }
-}
-/** Raw volume text. Absent file → text undefined (not an error). */
-export async function readSitianVolumeText(input) {
-    const { recordFile } = resolveSitianVolume(input);
-    try {
-        return { recordFile, text: await readFile(recordFile, "utf8") };
-    }
-    catch (error) {
-        if (error.code === "ENOENT") {
-            return { recordFile, text: undefined };
-        }
-        throw new SitianInfrastructureError(`Sitian volume read failure: ${errorText(error)}`, { cause: error });
-    }
-}
-/**
- * Replace the entire volume body (whole-file reproject).
- * Same-directory temp + rename — never truncate the live inode in place
- * (#901 sole diary; reuse atomic-write, no parallel persist mechanism).
- * Not append; no identity claim / torn-tail watermark — those stay on appender.
- */
-export async function rewriteSitianVolume(input) {
-    try {
-        const volume = ensureSitianVolume(input);
-        await writeFileAtomically(volume.recordFile, input.body);
-        return volume;
-    }
-    catch (error) {
-        if (error instanceof SitianInfrastructureError)
-            throw error;
-        throw new SitianInfrastructureError(`Sitian volume rewrite failure: ${errorText(error)}`, { cause: error });
-    }
-}