@akagilnc/pi-workflow-roles 0.1.3414 → 0.1.3439

package/dist/stream-idle-guard.js

@@ -1,75 +1,67 @@
-/**
- * Stream idle backstop (#102 / #155 a): first-wait + between-event silence only.
- * Not a total wall-clock for long thinking turns.
- *
- * Default silence budget is owner-final 183s (#102 2026-08-04),
- * same numeric value as header timeoutMs but a distinct body-idle clock.
- */
-export const DEFAULT_STREAM_IDLE_TIMEOUT_MS = 183_000;
-export const STREAM_IDLE_TIMEOUT_CODE = "AK_STREAM_IDLE_TIMEOUT";
-export class StreamIdleTimeoutError extends Error {
-    code = STREAM_IDLE_TIMEOUT_CODE;
-    idleTimeoutMs;
-    constructor(idleTimeoutMs, options) {
-        super(`stream idle timeout after ${idleTimeoutMs}ms`, options);
-        this.name = "StreamIdleTimeoutError";
-        this.idleTimeoutMs = idleTimeoutMs;
-    }
+const DEFAULT_STREAM_IDLE_TIMEOUT_MS = 183e3;
+const STREAM_IDLE_TIMEOUT_CODE = "AK_STREAM_IDLE_TIMEOUT";
+class StreamIdleTimeoutError extends Error {
+  code = STREAM_IDLE_TIMEOUT_CODE;
+  idleTimeoutMs;
+  constructor(idleTimeoutMs, options) {
+    super(`stream idle timeout after ${idleTimeoutMs}ms`, options);
+    this.name = "StreamIdleTimeoutError";
+    this.idleTimeoutMs = idleTimeoutMs;
+  }
 }
-export function isStreamIdleTimeoutError(value) {
-    return value instanceof StreamIdleTimeoutError
-        || (typeof value === "object"
-            && value !== null
-            && value.name === "StreamIdleTimeoutError"
-            && value.code === STREAM_IDLE_TIMEOUT_CODE);
+function isStreamIdleTimeoutError(value) {
+  return value instanceof StreamIdleTimeoutError || typeof value === "object" && value !== null && value.name === "StreamIdleTimeoutError" && value.code === STREAM_IDLE_TIMEOUT_CODE;
 }
-export function createStreamIdleGuard(options = {}) {
-    const idleTimeoutMs = options.idleTimeoutMs ?? DEFAULT_STREAM_IDLE_TIMEOUT_MS;
-    const parentSignal = options.parentSignal;
-    const controller = new AbortController();
-    let timer;
-    let disposed = false;
-    const clear = () => {
-        if (timer !== undefined) {
-            clearTimeout(timer);
-            timer = undefined;
-        }
-    };
-    const arm = () => {
-        if (disposed || controller.signal.aborted || idleTimeoutMs <= 0)
-            return;
-        clear();
-        timer = setTimeout(() => {
-            timer = undefined;
-            if (disposed || controller.signal.aborted)
-                return;
-            controller.abort(new StreamIdleTimeoutError(idleTimeoutMs));
-        }, idleTimeoutMs);
-    };
-    const onParentAbort = () => {
-        if (controller.signal.aborted)
-            return;
-        clear();
-        controller.abort(parentSignal?.reason);
-    };
-    if (parentSignal !== undefined) {
-        if (parentSignal.aborted) {
-            controller.abort(parentSignal.reason);
-        }
-        else {
-            parentSignal.addEventListener("abort", onParentAbort);
-        }
+function createStreamIdleGuard(options = {}) {
+  const idleTimeoutMs = options.idleTimeoutMs ?? DEFAULT_STREAM_IDLE_TIMEOUT_MS;
+  const parentSignal = options.parentSignal;
+  const controller = new AbortController();
+  let timer;
+  let disposed = false;
+  const clear = () => {
+    if (timer !== void 0) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+  };
+  const arm = () => {
+    if (disposed || controller.signal.aborted || idleTimeoutMs <= 0) return;
+    clear();
+    timer = setTimeout(() => {
+      timer = void 0;
+      if (disposed || controller.signal.aborted) return;
+      controller.abort(new StreamIdleTimeoutError(idleTimeoutMs));
+    }, idleTimeoutMs);
+  };
+  const onParentAbort = () => {
+    if (controller.signal.aborted) return;
+    clear();
+    controller.abort(parentSignal?.reason);
+  };
+  if (parentSignal !== void 0) {
+    if (parentSignal.aborted) {
+      controller.abort(parentSignal.reason);
+    } else {
+      parentSignal.addEventListener("abort", onParentAbort);
+    }
+  }
+  arm();
+  return {
+    signal: controller.signal,
+    poke() {
+      arm();
+    },
+    dispose() {
+      disposed = true;
+      clear();
+      parentSignal?.removeEventListener("abort", onParentAbort);
     }
-    arm();
-    return {
-        signal: controller.signal,
-        poke() {
-            arm();
-        },
-        dispose() {
-            disposed = true;
-            clear();
-            parentSignal?.removeEventListener("abort", onParentAbort);
-        },
-    };
+  };
 }
+export {
+  DEFAULT_STREAM_IDLE_TIMEOUT_MS,
+  STREAM_IDLE_TIMEOUT_CODE,
+  StreamIdleTimeoutError,
+  createStreamIdleGuard,
+  isStreamIdleTimeoutError
+};

package/dist/ticket-seat-memory.js

@@ -0,0 +1,244 @@
+import { existsSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { homeFromRunDirectory } from "./activation-ledger-topology.js";
+import { subjectKeyedRecordDirectory } from "./archivist-record-topology.js";
+import { resolvePackageRootDir } from "./session-opening-materials.js";
+const TICKET_SEAT_RUN_BINDING_ENTRY_TYPE = "ak_ticket_seat_run_binding";
+function isTicketSeatRunBindingRow(row) {
+  return row.type === "custom" && row.customType === TICKET_SEAT_RUN_BINDING_ENTRY_TYPE;
+}
+function ticketSeatRunBindingRunId(row) {
+  if (!isTicketSeatRunBindingRow(row)) return void 0;
+  if (row.data === null || typeof row.data !== "object" || Array.isArray(row.data)) {
+    return void 0;
+  }
+  const runId = row.data.runId;
+  return typeof runId === "string" && runId.length > 0 ? runId : void 0;
+}
+async function loadCreateRecordSessionOpen() {
+  const packageRoot = resolvePackageRootDir(import.meta.url);
+  const built = join(packageRoot, "dist/archivist-record-entry.js");
+  const source = join(packageRoot, "src/archivist-record-entry.ts");
+  const target = existsSync(built) ? built : source;
+  const mod = await import(pathToFileURL(target).href);
+  return mod.createRecordSessionOpen;
+}
+const TICKET_SEAT_MEMORY_KIND = "auditor-roles";
+const TICKET_SEAT_MEMORY_SEATS = ["inspector", "notary", "auditor"];
+function isTicketSeatMemorySeat(value) {
+  return TICKET_SEAT_MEMORY_SEATS.includes(value);
+}
+function isTicketSeatMemoryBound(input) {
+  return isTicketSeatMemorySeat(input.role) && typeof input.ticketNumber === "number" && Number.isSafeInteger(input.ticketNumber) && input.ticketNumber >= 1;
+}
+function isEnoent(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+function ticketSeatMemorySubject(ticketNumber, seat) {
+  if (!Number.isSafeInteger(ticketNumber) || ticketNumber < 1) {
+    throw new Error(
+      `ticket-seat memory subject requires a positive ticket number, got ${String(ticketNumber)}`
+    );
+  }
+  return `${ticketNumber}:${seat}`;
+}
+function ticketSeatMemorySessionDirectory(input) {
+  return subjectKeyedRecordDirectory({
+    cwd: input.cwd,
+    kind: TICKET_SEAT_MEMORY_KIND,
+    subject: ticketSeatMemorySubject(input.ticketNumber, input.seat),
+    ...input.parentSessionFile === void 0 ? {} : { parentSessionFile: input.parentSessionFile },
+    ...input.home === void 0 ? {} : { home: input.home }
+  });
+}
+async function readRunAdmittedPageFacts(runDirectory) {
+  try {
+    const raw = JSON.parse(
+      await readFile(join(runDirectory, "admitted-request.json"), "utf8")
+    );
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+      return {};
+    }
+    const record = raw;
+    const ticketNumber = record.ticketNumber;
+    const projectRoot = record.projectRoot;
+    return {
+      ...typeof ticketNumber === "number" && Number.isSafeInteger(ticketNumber) && ticketNumber >= 1 ? { ticketNumber } : {},
+      ...typeof projectRoot === "string" ? { projectRoot } : {}
+    };
+  } catch (error) {
+    if (isEnoent(error)) return {};
+    throw error;
+  }
+}
+async function readInvocationTicketNumber(runDirectory) {
+  try {
+    const raw = JSON.parse(
+      await readFile(join(runDirectory, "invocation.json"), "utf8")
+    );
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+      return void 0;
+    }
+    const ticketNumber = raw.ticketNumber;
+    if (typeof ticketNumber === "number" && Number.isSafeInteger(ticketNumber) && ticketNumber >= 1) {
+      return ticketNumber;
+    }
+  } catch (error) {
+    if (isEnoent(error)) return void 0;
+    throw error;
+  }
+  return void 0;
+}
+async function readRunTicketNumber(runDirectory) {
+  const admitted = await readRunAdmittedPageFacts(runDirectory);
+  if (admitted.ticketNumber !== void 0) return admitted.ticketNumber;
+  return readInvocationTicketNumber(runDirectory);
+}
+async function resolveTicketSeatMemoryNestDirectories(input) {
+  if (input.seats.length === 0) return [];
+  const admitted = await readRunAdmittedPageFacts(input.runDirectory);
+  const ticketNumber = admitted.ticketNumber ?? await readInvocationTicketNumber(input.runDirectory);
+  if (ticketNumber === void 0) return [];
+  let home;
+  try {
+    home = homeFromRunDirectory(input.runDirectory);
+  } catch {
+    return [];
+  }
+  const projectRoot = admitted.projectRoot;
+  if (projectRoot === void 0) return [];
+  return input.seats.map(
+    (seat) => ticketSeatMemorySessionDirectory({
+      ticketNumber,
+      seat,
+      cwd: projectRoot,
+      home
+    })
+  );
+}
+async function openTicketSeatMemoryCoordinates(input) {
+  const createRecordSessionOpen = await loadCreateRecordSessionOpen();
+  const opened = createRecordSessionOpen({
+    cwd: input.cwd,
+    kind: TICKET_SEAT_MEMORY_KIND,
+    subject: ticketSeatMemorySubject(input.ticketNumber, input.seat),
+    parent: {
+      getSessionFile: () => input.ledgerAnchorSessionFile
+    }
+  });
+  if (input.runId !== void 0) {
+    const data = { version: 1, runId: input.runId };
+    opened.session.appendCustomEntry(TICKET_SEAT_RUN_BINDING_ENTRY_TYPE, data);
+  }
+  const sessionFile = opened.session.getSessionFile();
+  const sessionDirectory = opened.session.getSessionDir();
+  if (typeof sessionFile !== "string" || sessionFile.length === 0) {
+    throw new Error(
+      `ticket-seat memory principal missing session file for ticket #${input.ticketNumber} seat ${input.seat}`
+    );
+  }
+  if (typeof sessionDirectory !== "string" || sessionDirectory.length === 0) {
+    throw new Error(
+      `ticket-seat memory principal missing session directory for ticket #${input.ticketNumber} seat ${input.seat}`
+    );
+  }
+  return { sessionDirectory, sessionFile, resumed: opened.resumed };
+}
+async function rebindAdmittedToTicketSeatMemory(input) {
+  const ticketNumber = input.admitted.ticketNumber;
+  if (ticketNumber === void 0) return void 0;
+  const anchor = input.principalAuthority.decode(input.admitted.principal);
+  const opened = await openTicketSeatMemoryCoordinates({
+    ticketNumber,
+    seat: input.seat,
+    cwd: input.admitted.projectRoot,
+    ledgerAnchorSessionFile: anchor.sessionFile,
+    // Analyst attributes frame/model/tool to this binding interval only (#636 D).
+    runId: input.admitted.runId
+  });
+  const coordinates = {
+    sessionDirectory: opened.sessionDirectory,
+    sessionFile: opened.sessionFile
+  };
+  const principal = input.principalAuthority.seal(coordinates);
+  input.principalAuthority.decode(principal);
+  input.admitted.principal = principal;
+  for (const page of ["admitted-request.json", "invocation.json"]) {
+    const path = join(input.admitted.runDirectory, page);
+    try {
+      const raw = JSON.parse(await readFile(path, "utf8"));
+      if (raw === null || typeof raw !== "object" || Array.isArray(raw)) continue;
+      const next = {
+        ...raw,
+        sessionDirectory: coordinates.sessionDirectory,
+        sessionFile: coordinates.sessionFile
+      };
+      await writeFile(path, `${JSON.stringify(next, null, 2)}
+`, "utf8");
+    } catch (error) {
+      if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+        continue;
+      }
+      throw error;
+    }
+  }
+  return { coordinates, resumed: opened.resumed };
+}
+const TICKET_SEAT_LAST_HOST_FILE = "last-host.json";
+async function readTicketSeatMemoryLastHost(sessionDirectory) {
+  try {
+    const raw = JSON.parse(
+      await readFile(join(sessionDirectory, TICKET_SEAT_LAST_HOST_FILE), "utf8")
+    );
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw) || typeof raw.host !== "string" || raw.host.length === 0) {
+      throw new Error(
+        `ticket-seat memory last-host page is damaged under ${sessionDirectory}`
+      );
+    }
+    const host = raw.host;
+    const runDirectory = raw.runDirectory;
+    return {
+      host,
+      ...typeof runDirectory === "string" && runDirectory.length > 0 ? { runDirectory } : {}
+    };
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return void 0;
+    }
+    throw error;
+  }
+}
+async function writeTicketSeatMemoryLastHost(sessionDirectory, host, runDirectory) {
+  if (host.trim() === "") {
+    throw new Error("ticket-seat memory last-host requires a non-empty host");
+  }
+  const body = {
+    host,
+    ...runDirectory !== void 0 && runDirectory.length > 0 ? { runDirectory } : {}
+  };
+  await writeFile(
+    join(sessionDirectory, TICKET_SEAT_LAST_HOST_FILE),
+    `${JSON.stringify(body, null, 2)}
+`,
+    "utf8"
+  );
+}
+export {
+  TICKET_SEAT_MEMORY_KIND,
+  TICKET_SEAT_MEMORY_SEATS,
+  TICKET_SEAT_RUN_BINDING_ENTRY_TYPE,
+  isTicketSeatMemoryBound,
+  isTicketSeatMemorySeat,
+  isTicketSeatRunBindingRow,
+  openTicketSeatMemoryCoordinates,
+  readRunTicketNumber,
+  readTicketSeatMemoryLastHost,
+  rebindAdmittedToTicketSeatMemory,
+  resolveTicketSeatMemoryNestDirectories,
+  ticketSeatMemorySessionDirectory,
+  ticketSeatMemorySubject,
+  ticketSeatRunBindingRunId,
+  writeTicketSeatMemoryLastHost
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akagilnc/pi-workflow-roles",
-  "version": "0.1.3414",
+  "version": "0.1.3439",
   "description": "Soul-bound workflow roles for Pi",
   "type": "module",
   "license": "Apache-2.0",

package/scripts/build-package.mjs

@@ -21,6 +21,47 @@ const entries = [
   "activation-ledger-topology",
   "activation-reconciliation",
   "archivist-record-entry",
+  // Pure subject nest topology — cold discovery without SessionManager (#636).
+  "archivist-record-topology",
+  // Officer ticket-seat pure read + deferred open (#636 public-bin cold graph).
+  "ticket-seat-memory",
+  // ticket-seat-memory → session-opening-materials (#636 non-bundle graph closure).
+  "session-opening-materials",
+  // Value-import closure of published non-bundle roots (build-package-only loadable).
+  "auditor-dossier-tool",
+  "canonical-json",
+  "compliance-transport",
+  "countersign-contracts",
+  "doctor-contracts",
+  "engine-detour",
+  "engine-detour-tool",
+  "exact-utf8",
+  "git-object-id",
+  "gleaner-left-contracts",
+  "inspector-contracts",
+  "institutional-resolution",
+  "merger-contracts",
+  "notary-contracts",
+  "open-tool-schema",
+  "package-contracts/collector-output",
+  "package-contracts/fixer-output",
+  "package-contracts/fixer-packet",
+  "package-contracts/gatekeeper-output",
+  "package-contracts/judge-output",
+  "package-contracts/navigator-output",
+  "package-contracts/reviewer-output",
+  "package-contracts/terminating-infrastructure",
+  "package-contracts/worker-output",
+  "package-resources/engine-material",
+  "public-cli/config",
+  "public-cli/registry",
+  "receipt-delivery-policy",
+  "sha256",
+  "sitian-appender",
+  "sitian-contracts",
+  "sitian-facade",
+  "sitian-reader",
+  "stream-idle-guard",
   "typed-provider-http",
   "upstream-error-testimony",
 ];