@akagilnc/pi-workflow-roles 0.1.3412 → 0.1.3439

package/dist/sitian-appender.js

@@ -1,237 +1,231 @@
-/**
- * Sitian Appender kernel (ADR 0065).
- * Computes destination automatically from ledger topology without destination parameters.
- * Owns volume open, torn-tail recovery, entry-level idempotency, and commit boundary.
- */
 import { createHash, randomUUID } from "node:crypto";
-import { appendFileSync, existsSync, readFileSync, unlinkSync, writeFileSync, } from "node:fs";
+import {
+  appendFileSync,
+  existsSync,
+  readFileSync,
+  unlinkSync,
+  writeFileSync
+} from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
 import { resolveBookKeyFromGit } from "./activation-ledger-git.js";
-import { activationBookDirectory, ensureRealDirectoryTree, errorText, physicallyContainedIn, resolveActivationLedgerHome, resolveActivationLedgerHomeForPath, } from "./activation-ledger-topology.js";
-import { SitianInfrastructureError, } from "./sitian-contracts.js";
+import {
+  activationBookDirectory,
+  ensureRealDirectoryTree,
+  errorText,
+  physicallyContainedIn,
+  resolveActivationLedgerHome,
+  resolveActivationLedgerHomeForPath
+} from "./activation-ledger-topology.js";
+import {
+  SitianInfrastructureError
+} from "./sitian-contracts.js";
 function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function errorCodeOf(error) {
-    return error.code;
+  return error.code;
 }
 function identityClaimPath(recordFile, identity) {
-    const digest = createHash("sha256").update(identity, "utf8").digest("hex");
-    return `${recordFile}.id-${digest}`;
+  const digest = createHash("sha256").update(identity, "utf8").digest("hex");
+  return `${recordFile}.id-${digest}`;
 }
-/**
- * Exclusive create at `path` exactly once across processes.
- * Reuses the package's existing `wx` / O_EXCL zero-content occupancy primitive
- * (same shape as activation-ledger-session / archivist-record-entry).
- */
 function createExclusiveFile(path, contents) {
-    writeFileSync(path, contents, { encoding: "utf8", flag: "wx" });
+  writeFileSync(path, contents, { encoding: "utf8", flag: "wx" });
 }
 function sealTornTail(recordFile) {
-    if (!existsSync(recordFile))
-        return;
-    const buffer = readFileSync(recordFile);
-    if (buffer.length > 0 && buffer[buffer.length - 1] !== 0x0a) {
-        appendFileSync(recordFile, "\n", "utf8");
-    }
+  if (!existsSync(recordFile)) return;
+  const buffer = readFileSync(recordFile);
+  if (buffer.length > 0 && buffer[buffer.length - 1] !== 10) {
+    appendFileSync(recordFile, "\n", "utf8");
+  }
 }
 function findIdentityPointer(recordFile, identity, kind, level) {
-    if (!existsSync(recordFile))
-        return undefined;
-    const text = readFileSync(recordFile, "utf8");
-    for (const line of text.split("\n")) {
-        const trimmed = line.trim();
-        if (!trimmed)
-            continue;
-        try {
-            const parsed = JSON.parse(trimmed);
-            if (isRecord(parsed) && parsed.identity === identity) {
-                return { identity, recordFile, kind, level };
-            }
-        }
-        catch {
-            // Malformed lines (including substate b preserved bad lines) are ignored during self-check
-        }
-    }
-    return undefined;
+  if (!existsSync(recordFile)) return void 0;
+  const text = readFileSync(recordFile, "utf8");
+  for (const line of text.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (isRecord(parsed) && parsed.identity === identity) {
+        return { identity, recordFile, kind, level };
+      }
+    } catch {
+    }
+  }
+  return void 0;
 }
 function unlinkAbsentOk(path) {
-    try {
-        unlinkSync(path);
-        return undefined;
-    }
-    catch (error) {
-        if (errorCodeOf(error) === "ENOENT")
-            return undefined;
-        return error instanceof Error ? error : new Error(errorText(error));
-    }
+  try {
+    unlinkSync(path);
+    return void 0;
+  } catch (error) {
+    if (errorCodeOf(error) === "ENOENT") return void 0;
+    return error instanceof Error ? error : new Error(errorText(error));
+  }
 }
-/**
- * Same-identity uniqueness under normal concurrent writers.
- *
- * Exclusive per-identity claim (`wx`) makes check+append atomic for one
- * identity. The winner appends under the claim and always releases it on both
- * normal and throwing exits. A loser that already sees the published row
- * returns that pointer; a loser that hits claim EEXIST without a published row
- * fails as SitianInfrastructureError (knownCause session). Crash residue can
- * leave that one identity blocked — identity-scoped, never a volume lock. No
- * wait loop, write-ahead recovery, PID reclaim, or compare-and-unlink.
- */
 function appendWithIdentityClaim(recordFile, record, row) {
+  sealTornTail(recordFile);
+  const claimPath = identityClaimPath(recordFile, record.identity);
+  const existing = findIdentityPointer(
+    recordFile,
+    record.identity,
+    record.kind,
+    record.level
+  );
+  if (existing !== void 0) {
+    unlinkAbsentOk(claimPath);
+    return existing;
+  }
+  try {
+    createExclusiveFile(claimPath, "");
+  } catch (error) {
+    if (errorCodeOf(error) !== "EEXIST") throw error;
     sealTornTail(recordFile);
-    const claimPath = identityClaimPath(recordFile, record.identity);
-    const existing = findIdentityPointer(recordFile, record.identity, record.kind, record.level);
-    if (existing !== undefined) {
-        // Best-effort: drop leftover claim after a prior crash-after-append.
-        unlinkAbsentOk(claimPath);
-        return existing;
-    }
-    try {
-        createExclusiveFile(claimPath, "");
-    }
-    catch (error) {
-        if (errorCodeOf(error) !== "EEXIST")
-            throw error;
-        sealTornTail(recordFile);
-        const published = findIdentityPointer(recordFile, record.identity, record.kind, record.level);
-        if (published !== undefined) {
-            unlinkAbsentOk(claimPath);
-            return published;
-        }
-        throw new SitianInfrastructureError(`Sitian identity claim at ${claimPath} already exists for identity ${record.identity}`, { cause: error });
-    }
-    let primaryFailure;
-    let result;
-    let cleanupFailure;
-    try {
-        sealTornTail(recordFile);
-        const raced = findIdentityPointer(recordFile, record.identity, record.kind, record.level);
-        if (raced !== undefined) {
-            result = raced;
-        }
-        else {
-            appendFileSync(recordFile, row, "utf8");
-            result = {
-                identity: record.identity,
-                recordFile,
-                kind: record.kind,
-                level: record.level,
-            };
-        }
-    }
-    catch (error) {
-        primaryFailure = error;
-    }
-    finally {
-        cleanupFailure = unlinkAbsentOk(claimPath);
-    }
-    if (primaryFailure !== undefined) {
-        if (primaryFailure instanceof SitianInfrastructureError)
-            throw primaryFailure;
-        throw new SitianInfrastructureError(`Sitian appender persistence failure: ${errorText(primaryFailure)}`, { cause: primaryFailure });
-    }
-    if (cleanupFailure !== undefined) {
-        throw new SitianInfrastructureError(`Sitian identity claim at ${claimPath} could not be released after append for identity ${record.identity}: ${errorText(cleanupFailure)}`, { cause: cleanupFailure });
-    }
-    return result;
+    const published = findIdentityPointer(
+      recordFile,
+      record.identity,
+      record.kind,
+      record.level
+    );
+    if (published !== void 0) {
+      unlinkAbsentOk(claimPath);
+      return published;
+    }
+    throw new SitianInfrastructureError(
+      `Sitian identity claim at ${claimPath} already exists for identity ${record.identity}`,
+      { cause: error }
+    );
+  }
+  let primaryFailure;
+  let result;
+  let cleanupFailure;
+  try {
+    sealTornTail(recordFile);
+    const raced = findIdentityPointer(
+      recordFile,
+      record.identity,
+      record.kind,
+      record.level
+    );
+    if (raced !== void 0) {
+      result = raced;
+    } else {
+      appendFileSync(recordFile, row, "utf8");
+      result = {
+        identity: record.identity,
+        recordFile,
+        kind: record.kind,
+        level: record.level
+      };
+    }
+  } catch (error) {
+    primaryFailure = error;
+  } finally {
+    cleanupFailure = unlinkAbsentOk(claimPath);
+  }
+  if (primaryFailure !== void 0) {
+    if (primaryFailure instanceof SitianInfrastructureError) throw primaryFailure;
+    throw new SitianInfrastructureError(
+      `Sitian appender persistence failure: ${errorText(primaryFailure)}`,
+      { cause: primaryFailure }
+    );
+  }
+  if (cleanupFailure !== void 0) {
+    throw new SitianInfrastructureError(
+      `Sitian identity claim at ${claimPath} could not be released after append for identity ${record.identity}: ${errorText(cleanupFailure)}`,
+      { cause: cleanupFailure }
+    );
+  }
+  return result;
 }
-/** Authorized S4 submission ledger kinds that share a common run submission volume. */
-export const S4_SUBMISSION_LEDGER_KINDS = new Set([
-    "candidate",
-    "roundContext",
-    "outcome",
-    "sealed",
-    "post-seal-anomaly"
+const S4_SUBMISSION_LEDGER_KINDS = /* @__PURE__ */ new Set([
+  "candidate",
+  "roundContext",
+  "outcome",
+  "sealed",
+  "post-seal-anomaly"
 ]);
-/** Compute the volume partition key for directory placement. */
-export function resolveSitianVolumeCategory(kind) {
-    if (S4_SUBMISSION_LEDGER_KINDS.has(kind)) {
-        return "submission-ledger";
-    }
-    return kind;
+function resolveSitianVolumeCategory(kind) {
+  if (S4_SUBMISSION_LEDGER_KINDS.has(kind)) {
+    return "submission-ledger";
+  }
+  return kind;
 }
 function safeBookKey(cwd) {
-    try {
-        return resolveBookKeyFromGit(cwd);
-    }
-    catch {
-        return basename(resolve(cwd)) || "default";
-    }
+  try {
+    return resolveBookKeyFromGit(cwd);
+  } catch {
+    return basename(resolve(cwd)) || "default";
+  }
 }
-/** Pure topology owner shared by ambient writes and explicit-home submission reads. */
-export function resolveSitianRecordPathInLedger(input, ledgerHome) {
-    const cwd = input.cwd ?? process.cwd();
-    const category = resolveSitianVolumeCategory(input.kind);
-    let sessionDir;
-    if (input.sessionParent !== undefined && input.sessionParent.length > 0 && physicallyContainedIn(ledgerHome, input.sessionParent)) {
-        sessionDir = join(dirname(input.sessionParent), category);
-    }
-    else {
-        const bookKey = safeBookKey(cwd);
-        const bookDir = activationBookDirectory(ledgerHome, bookKey);
-        if (input.subject !== undefined) {
-            let subjectStr;
-            if (typeof input.subject === "string") {
-                subjectStr = input.subject;
-            }
-            else if (typeof input.subject.runId === "string" && input.subject.runId.length > 0) {
-                subjectStr = input.subject.runId;
-            }
-            else {
-                subjectStr = JSON.stringify(input.subject);
-            }
-            const digest = createHash("sha256").update(subjectStr).digest("hex").slice(0, 32);
-            sessionDir = join(bookDir, category, digest);
-        }
-        else {
-            sessionDir = join(bookDir, category);
-        }
-    }
-    const recordFile = join(sessionDir, "records.jsonl");
-    return { sessionDir, recordFile, ledgerHome };
+function resolveSitianRecordPathInLedger(input, ledgerHome) {
+  const cwd = input.cwd ?? process.cwd();
+  const category = resolveSitianVolumeCategory(input.kind);
+  let sessionDir;
+  if (input.sessionParent !== void 0 && input.sessionParent.length > 0 && physicallyContainedIn(ledgerHome, input.sessionParent)) {
+    sessionDir = join(dirname(input.sessionParent), category);
+  } else {
+    const bookKey = safeBookKey(cwd);
+    const bookDir = activationBookDirectory(ledgerHome, bookKey);
+    if (input.subject !== void 0) {
+      let subjectStr;
+      if (typeof input.subject === "string") {
+        subjectStr = input.subject;
+      } else if (typeof input.subject.runId === "string" && input.subject.runId.length > 0) {
+        subjectStr = input.subject.runId;
+      } else {
+        subjectStr = JSON.stringify(input.subject);
+      }
+      const digest = createHash("sha256").update(subjectStr).digest("hex").slice(0, 32);
+      sessionDir = join(bookDir, category, digest);
+    } else {
+      sessionDir = join(bookDir, category);
+    }
+  }
+  const recordFile = join(sessionDir, "records.jsonl");
+  return { sessionDir, recordFile, ledgerHome };
 }
-/** Compute a write destination from ambient ledger topology (ADR 0065). */
-export function resolveSitianRecordPath(input) {
-    const ledgerHome = input.home !== undefined && input.home.length > 0
-        ? resolveActivationLedgerHome(input.home)
-        : resolveActivationLedgerHomeForPath(input.sessionParent);
-    return resolveSitianRecordPathInLedger(input, ledgerHome);
+function resolveSitianRecordPath(input) {
+  const ledgerHome = input.home !== void 0 && input.home.length > 0 ? resolveActivationLedgerHome(input.home) : resolveActivationLedgerHomeForPath(input.sessionParent);
+  return resolveSitianRecordPathInLedger(input, ledgerHome);
 }
-/**
- * Appends a canonical record to its self-computed volume under the Sitian contract.
- * - Idempotency: checks volume by deterministic canonical identity; returns existing pointer on hit.
- * - Torn-tail recovery: checks file tail; un-terminated trailing bytes are sealed with a newline and re-parsed.
- *   Substate a (valid JSON): committed on recovery, returns existing pointer.
- *   Substate b (malformed): preserved as bad line, check misses, appends new row.
- * - Commit point: full JSON string ending with newline.
- */
-export function appendSitianRecord(input) {
-    try {
-        const { sessionDir, recordFile, ledgerHome } = resolveSitianRecordPath(input);
-        ensureRealDirectoryTree(ledgerHome, sessionDir);
-        const identity = input.identity ?? randomUUID();
-        const timestamp = input.timestamp ?? new Date().toISOString();
-        const host = input.host ?? "pi";
-        const record = {
-            level: input.level,
-            kind: input.kind,
-            identity,
-            ...(input.subject === undefined ? {} : { subject: input.subject }),
-            ...(input.sessionParent === undefined ? {} : { sessionParent: input.sessionParent }),
-            ...(input.priorEventId === undefined ? {} : { priorEventId: input.priorEventId }),
-            timestamp,
-            host,
-            ...(input.source === undefined ? {} : { source: input.source }),
-            ...(input.payload === undefined ? {} : { payload: input.payload }),
-            ...(input.raw === undefined ? {} : { raw: input.raw }),
-            ...(input.usage === undefined ? {} : { usage: input.usage }),
-        };
-        const row = `${JSON.stringify(record)}\n`;
-        return appendWithIdentityClaim(recordFile, record, row);
-    }
-    catch (error) {
-        if (error instanceof SitianInfrastructureError)
-            throw error;
-        throw new SitianInfrastructureError(`Sitian appender persistence failure: ${errorText(error)}`, { cause: error });
-    }
+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 },
+      ...input.priorEventId === void 0 ? {} : { priorEventId: input.priorEventId },
+      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)}
+`;
+    return appendWithIdentityClaim(recordFile, record, row);
+  } catch (error) {
+    if (error instanceof SitianInfrastructureError) throw error;
+    throw new SitianInfrastructureError(
+      `Sitian appender persistence failure: ${errorText(error)}`,
+      { cause: error }
+    );
+  }
 }
+export {
+  S4_SUBMISSION_LEDGER_KINDS,
+  appendSitianRecord,
+  resolveSitianRecordPath,
+  resolveSitianRecordPathInLedger,
+  resolveSitianVolumeCategory
+};

package/dist/sitian-contracts.js

@@ -1,21 +1,17 @@
-/**
- * Sitian (司天台) canonical contracts, Layout schema, and pointer definitions.
- * ADR 0065 single record entry + ADR 0068 Taishi analysis.
- */
-/** Lift direct-cause fs errno onto a wrap error (no chain walk). */
-export 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;
+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;
 }
-/** Typed infrastructure error for real ledger persistence / IO failures. */
-export class SitianInfrastructureError extends Error {
-    knownCause = "session";
-    constructor(message, options) {
-        super(message, options);
-        this.name = "SitianInfrastructureError";
-        attachDirectErrnoCode(this, options?.cause);
-    }
+class SitianInfrastructureError extends Error {
+  knownCause = "session";
+  constructor(message, options) {
+    super(message, options);
+    this.name = "SitianInfrastructureError";
+    attachDirectErrnoCode(this, options?.cause);
+  }
 }
+export {
+  SitianInfrastructureError,
+  attachDirectErrnoCode
+};

package/dist/sitian-facade.js

@@ -1,15 +1,10 @@
-/**
- * Sitian Facade (司天门面) — Sole entrypoint for record reporting across all producers.
- * ADR 0065 single record entry, #520 r8.
- */
 import { appendSitianRecord } from "./sitian-appender.js";
 export * from "./sitian-contracts.js";
 export * from "./sitian-appender.js";
 export * from "./sitian-reader.js";
-/**
- * Sole write API for Sitian canonical records.
- * Returns typed RecordPointer with durable record identity and readable file location.
- */
-export function sitianReport(input) {
-    return appendSitianRecord(input);
+function sitianReport(input) {
+  return appendSitianRecord(input);
 }
+export {
+  sitianReport
+};

package/dist/sitian-reader.js

@@ -1,52 +1,43 @@
-/**
- * Sitian Reader kernel (ADR 0068 / #520 r8).
- * Sole authoritative read path for canonical Sitian records.
- * Traversal contract:
- * - Malformed lines are exposed as typed malformed diagnostics and traversal continues.
- * - Zero whitewashing, zero deduplication.
- * - Canonical rows after malformed lines are always reachable.
- */
 import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-/** Read a Sitian record volume with full traversal and non-destructive diagnostics. */
-export async function readSitianRecords(recordFile) {
-    if (!existsSync(recordFile)) {
-        return { records: [], diagnostics: [] };
+async function readSitianRecords(recordFile) {
+  if (!existsSync(recordFile)) {
+    return { records: [], diagnostics: [] };
+  }
+  const text = await readFile(recordFile, "utf8");
+  const lines = text.split("\n");
+  const records = [];
+  const diagnostics = [];
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (!line.trim()) continue;
+    try {
+      const parsed = JSON.parse(line);
+      if (isRecord(parsed)) {
+        records.push(parsed);
+      } else {
+        const typeDesc = parsed === null ? "null" : Array.isArray(parsed) ? "array" : typeof parsed;
+        diagnostics.push({
+          kind: "malformed",
+          line: index + 1,
+          raw: line,
+          error: `expected JSON object, got ${typeDesc}`
+        });
+      }
+    } catch (error) {
+      diagnostics.push({
+        kind: "malformed",
+        line: index + 1,
+        raw: line,
+        error: error instanceof Error ? error.message : String(error)
+      });
     }
-    const text = await readFile(recordFile, "utf8");
-    const lines = text.split("\n");
-    const records = [];
-    const diagnostics = [];
-    for (let index = 0; index < lines.length; index += 1) {
-        const line = lines[index];
-        if (!line.trim())
-            continue;
-        try {
-            const parsed = JSON.parse(line);
-            if (isRecord(parsed)) {
-                records.push(parsed);
-            }
-            else {
-                const typeDesc = parsed === null ? "null" : Array.isArray(parsed) ? "array" : typeof parsed;
-                diagnostics.push({
-                    kind: "malformed",
-                    line: index + 1,
-                    raw: line,
-                    error: `expected JSON object, got ${typeDesc}`,
-                });
-            }
-        }
-        catch (error) {
-            diagnostics.push({
-                kind: "malformed",
-                line: index + 1,
-                raw: line,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-    return { records, diagnostics };
+  }
+  return { records, diagnostics };
 }
+export {
+  readSitianRecords
+};