@akagilnc/pi-workflow-roles 0.1.5483 → 0.1.5571

package/dist/analyst-gate-cycles-read.js

@@ -1,18 +1,15 @@
 /**
- * Sole nested-volume reader for gate-cycle facts under session/auditor-roles/.
+ * Sole reader for gate-cycle facts of the officers pointed at from current.json `officers`.
  *
- * Consumers: Analyst sole ledger scan (classifyScopedRun) and Terminal gate
- * projection (#478). Metric families must not open a second disk scan — they
- * consume retained facts. Terminal settlement reuses this same pairing seam
- * (no second auditor-roles scanner).
+ * Consumer: Analyst sole ledger scan (classifyScopedRun). Metric families must
+ * not open a second disk scan — they consume retained facts.
  *
  * Naming: records may carry pre-#440 menxia/jishizhong/fubaolang tool faces or
  * the current gatekeeper/inspector/notary English face. Projection always uses
  * the current English officer identity (inspector | notary).
  *
- * Missing auditor-roles directory (ENOENT only) → empty rounds (lawful zero).
- * Path present but not a directory (ENOTDIR) and discovered nested JSONL that
- * fails canonical read/parse must fail loudly (never silently under-count).
+ * Absent `officers` section → empty rounds (lawful zero). A pointer whose
+ * officer session fails canonical read/parse must fail loudly (never silently under-count).
  * An accepted gate terminating receipt (isError:false pair on dispatch/officer
  * tool) whose required typed facts are unusable — status, dispatch officer, or
  * first/last span missing/unknown/unparseable/inverted — also fails loudly via
@@ -25,11 +22,12 @@
  * `ak_auditor_parent_attempt_binding.parent.attemptEntryId` — never seat/time guessing.
  * An orphan accepted dispatch must not consume a later same-seat direct officer.
  */
-import { readdir } from "node:fs/promises";
-import { join } from "node:path";
 import { AUDITOR_PARENT_ATTEMPT_BINDING_ENTRY_TYPE, } from "./compliance-transport.js";
 import { extractSessionTimestampSpan, intervalRowsAroundAnchor, readLedgerSessionJsonl, } from "./ledger-session-read.js";
-import { isRecord, errorText, isEnoent } from "./unknown-value.js";
+import { isRecord, isEnoent } from "./unknown-value.js";
+import { retainedRunPathsMatch } from "./role-run-relocation.js";
+import { runDirectoryOfSessionFile } from "./role-run-placement.js";
+import { readOfficerPointers } from "./archivist-record-pointer.js";
 const DISPATCH_TOOLS = new Set(["ak_menxia_output", "ak_gatekeeper_output"]);
 /** Officer terminating tool → current English officer identity. */
 const OFFICER_TOOL_TO_FACE = {
@@ -309,81 +307,33 @@ function pairGateRounds(volumes) {
         .sort((a, b) => a.officerStartedAt.localeCompare(b.officerStartedAt))
         .map((round, index) => ({ ...round, roundIndex: index + 1 }));
 }
-/** Resolve a direct-officer-run-pointer file to the officer session 正本 path. */
-async function resolveOfficerSessionFromPointerFile(pointerPath) {
-    const { readFile } = await import("node:fs/promises");
-    let raw;
-    try {
-        raw = JSON.parse(await readFile(pointerPath, "utf8"));
-    }
-    catch (error) {
-        throw new Error(`direct officer run pointer unreadable in ${pointerPath}: ${errorText(error)}`, { cause: error });
-    }
-    if (!isRecord(raw) || raw.kind !== "direct-officer-run-pointer" || raw.version !== 1) {
-        throw new Error(`direct officer run pointer has unknown shape in ${pointerPath}`);
-    }
-    const sessionFile = raw.sessionFile;
-    if (typeof sessionFile !== "string" || sessionFile.trim() === "") {
-        throw new Error(`direct officer run pointer missing sessionFile in ${pointerPath}`);
-    }
-    const officer = raw.officer === "inspector" || raw.officer === "notary"
-        ? raw.officer : undefined;
-    return { sessionFile, ...(officer === undefined ? {} : { officer }) };
-}
 /**
- * Read and pair gate-cycle rounds from one or more auditor-roles directories.
- * Accepts historical nested JSONL volumes and #675 direct-officer-run-pointer
- * files that name the independent officer session 正本.
- * ENOENT (directory truly absent) → []. ENOTDIR and other errors propagate
- * (failure honesty — damaged topology must not wash to zero rounds).
+ * Read and pair gate-cycle rounds from the officer pointers booked in one
+ * run's current.json `officers` section; each pointer names the independent
+ * officer session 正本. Absent section → [] (lawful zero). A damaged pointer or
+ * officer session propagates — damaged topology must not wash to zero rounds.
  *
  * Pass `parentSessionFile` to keep only rounds whose attempt binding names that parent.
  */
-export async function readAnalystGateCyclesFromAuditorRoles(auditorRolesDirectory, options = {}) {
-    const directories = typeof auditorRolesDirectory === "string"
-        ? [auditorRolesDirectory]
-        : auditorRolesDirectory;
+export async function readAnalystGateCyclesFromOfficers(parentRunDirectory, options = {}) {
     const volumes = [];
-    // Same officer session pointed at N times (historical multi-mint pointers, or
-    // one parent booking many leaves) must classify once — else each accepted
-    // seal is counted ×N in terminal gate-round (#753 acceptance A).
+    // Same officer session pointed at N times must classify once — else each
+    // accepted seal is counted ×N in gate-cycle statistics (#753 acceptance A).
     const classifiedOfficerSessions = new Set();
-    for (const directory of directories) {
-        let names;
-        try {
-            const entries = await readdir(directory, { withFileTypes: true });
-            names = entries
-                .filter((e) => e.isFile()
-                && (e.name.endsWith(".jsonl") || e.name.endsWith(".pointer.json")))
-                .map((e) => e.name)
-                .sort();
-        }
-        catch (error) {
-            if (isEnoent(error))
+    for (const pointer of await readOfficerPointers(parentRunDirectory)) {
+        if (classifiedOfficerSessions.has(pointer.sessionFile))
+            continue;
+        classifiedOfficerSessions.add(pointer.sessionFile);
+        const officer = pointer.officer === "inspector" || pointer.officer === "notary"
+            ? pointer.officer : undefined;
+        const classified = await classifyAuditorVolume(pointer.sessionFile, officer);
+        for (const volume of classified) {
+            if (options.parentSessionFile !== undefined &&
+                volume.parentSessionFile !== undefined &&
+                !await retainedRunPathsMatch(volume.parentSessionFile, options.parentSessionFile, runDirectoryOfSessionFile(options.parentSessionFile))) {
                 continue;
-            throw error;
-        }
-        for (const name of names) {
-            const path = join(directory, name);
-            const fromPointer = name.endsWith(".pointer.json");
-            const pointer = fromPointer
-                ? await resolveOfficerSessionFromPointerFile(path)
-                : undefined;
-            const sessionPath = pointer?.sessionFile ?? path;
-            if (fromPointer) {
-                if (classifiedOfficerSessions.has(sessionPath))
-                    continue;
-                classifiedOfficerSessions.add(sessionPath);
-            }
-            const classified = await classifyAuditorVolume(sessionPath, pointer?.officer);
-            for (const volume of classified) {
-                if (options.parentSessionFile !== undefined &&
-                    volume.parentSessionFile !== undefined &&
-                    volume.parentSessionFile !== options.parentSessionFile) {
-                    continue;
-                }
-                volumes.push(volume);
             }
+            volumes.push(volume);
         }
     }
     return pairGateRounds(volumes);

package/dist/analyst-ledger.js

@@ -12,21 +12,23 @@
  * A2: classifyScopedRun retains typed per-run facts (frame span, tool intervals,
  * terminal face) for metric-family modules — no longer discarded after checks.
  */
+import { readSectionSync } from "./run-dossier.js";
 import { readdir, readFile } from "node:fs/promises";
 import { basename, join } from "node:path";
 import { isSyntheticAnalystBookKey, resolveAnalystBookKey } from "./analyst-book-key.js";
 import { pathContainedIn, physicalPathIdentity, resolveActivationLedgerHome, } from "./activation-ledger-topology.js";
-import { listBookRunDirectories } from "./role-run-placement.js";
+import { listBookRunDirectories, parseRunLeaf, sessionFileOf, } from "./role-run-placement.js";
 import { autopsyWriterLock, readRoleRunIdentity } from "./public-cli/run-lifecycle.js";
 import { readRunTicketNumber } from "./run-ticket-number.js";
+import { rewriteRunDirectoryPathValue } from "./role-run-relocation.js";
 import { extractSessionModelSequence, extractSessionTimestampSpan, extractSessionToolIntervals, LedgerSessionJsonlError, readLedgerSessionJsonl, } from "./ledger-session-read.js";
-import { readRunTerminalArtifact, } from "./run-terminal-artifacts.js";
-import { readAnalystGateCyclesFromAuditorRoles, } from "./analyst-gate-cycles-read.js";
+import { readRunTerminal, } from "./run-terminal-artifacts.js";
+import { readAnalystGateCyclesFromOfficers, } from "./analyst-gate-cycles-read.js";
 import { isRecord, errorText, isMissingPathError } from "./unknown-value.js";
 /** Existing public-cli run-state live phases — not a new state machine. */
 const LIVE_RUN_STATES = new Set(["admitted", "running", "resumable"]);
 /**
- * Read lifecycle state from the existing run-state.json face.
+ * Read lifecycle state from the state.jsonl run-state fact row.
  * Used only to distinguish live in-flight runs from terminal no-receipt.
  */
 async function readExistingRunLifecycleState(runDirectory) {
@@ -65,12 +67,6 @@ async function classifyGhostCandidate(input) {
         },
     };
 }
-function parseRunDirectoryName(name) {
-    const at = name.lastIndexOf("@");
-    if (at <= 0 || at === name.length - 1)
-        return undefined;
-    return { runId: name.slice(0, at), role: name.slice(at + 1) };
-}
 async function listLedgerBookNames(booksRoot) {
     try {
         const entries = await readdir(booksRoot, { withFileTypes: true });
@@ -83,17 +79,8 @@ async function listLedgerBookNames(booksRoot) {
     }
 }
 async function readInvocationScopeFields(runDirectory) {
-    let raw;
-    try {
-        raw = await readFile(join(runDirectory, "invocation.json"), "utf8");
-    }
-    catch (error) {
-        if (isMissingPathError(error))
-            return undefined;
-        throw error;
-    }
-    const parsed = JSON.parse(raw);
-    if (!isRecord(parsed))
+    const parsed = readSectionSync(runDirectory, "invocation");
+    if (parsed === undefined)
         return undefined;
     if (typeof parsed.projectRoot !== "string" || parsed.projectRoot.trim() === "") {
         return undefined;
@@ -130,20 +117,13 @@ function decideIssueScope(input) {
 }
 async function resolveSessionFile(runDirectory) {
     // Prefer invocation.sessionFile when present; fall back to S-family principal.
-    try {
-        const raw = await readFile(join(runDirectory, "invocation.json"), "utf8");
-        const parsed = JSON.parse(raw);
-        if (isRecord(parsed)
-            && typeof parsed.sessionFile === "string"
-            && parsed.sessionFile.trim() !== "") {
-            return parsed.sessionFile;
-        }
-    }
-    catch (error) {
-        if (!isMissingPathError(error))
-            throw error;
+    const parsed = readSectionSync(runDirectory, "invocation");
+    if (parsed !== undefined && typeof parsed.sessionFile === "string" && parsed.sessionFile.trim() !== "") {
+        return typeof parsed.runDirectory === "string"
+            ? rewriteRunDirectoryPathValue(parsed.sessionFile, parsed.runDirectory, runDirectory)
+            : parsed.sessionFile;
     }
-    return join(runDirectory, "session", "session.jsonl");
+    return sessionFileOf(runDirectory);
 }
 /**
  * Attribute session rows to one run.
@@ -333,10 +313,14 @@ async function classifyScopedRun(input) {
             ghostLeg = ghost.leg;
     }
     try {
-        const artifact = await readRunTerminalArtifact(input.runDirectory);
+        const read = readRunTerminal(input.runDirectory);
+        // A no_receipt terminal is the explicit form of "no accepted receipt".
+        const artifact = read.status === "present" && read.face === "no_receipt"
+            ? { status: "absent" }
+            : read;
         if (artifact.status === "unreadable") {
             missingSources.push("terminal-artifact");
-            reasons.push(`${artifact.file}: ${artifact.reason}`);
+            reasons.push(`terminal: ${artifact.reason}`);
         }
         else if (artifact.status === "absent") {
             if (lifecycle === "admitted" || lifecycle === "running") {
@@ -351,10 +335,10 @@ async function classifyScopedRun(input) {
             terminal = { status: "absent" };
         }
         else {
-            // role already required nonblank by readRunTerminalArtifact (single owner).
+            // role already required nonblank by readRunTerminal (single owner).
             terminal = {
                 status: "present",
-                file: artifact.file,
+                face: artifact.face,
                 body: artifact.body,
                 role: artifact.body.role,
             };
@@ -389,13 +373,13 @@ async function classifyScopedRun(input) {
     if (frameSpan === undefined || toolIntervals === undefined || terminal === undefined) {
         throw new Error(`classifyScopedRun internal invariant: missing retained facts for ${input.runId}`);
     }
-    // Nested auditor-roles gate pairs stay inside the sole scan (families must
+    // Officer gate pairs stay inside the sole scan (families must
     // not readdir this tree again). Missing directory → []. Damaged discovered
     // nested JSONL is page-local unreadable — never silently under-count rounds.
     let gateCycles;
     try {
-        const parentSessionFile = join(input.runDirectory, "session", "session.jsonl");
-        gateCycles = await readAnalystGateCyclesFromAuditorRoles(join(input.runDirectory, "session", "auditor-roles"), { parentSessionFile });
+        const parentSessionFile = sessionFileOf(input.runDirectory);
+        gateCycles = await readAnalystGateCyclesFromOfficers(input.runDirectory, { parentSessionFile });
     }
     catch (error) {
         return {
@@ -497,7 +481,7 @@ export async function scanAnalystIssueRuns(input) {
         }
         for (const runDirectory of runDirectories) {
             const runName = basename(runDirectory);
-            const parsed = parseRunDirectoryName(runName);
+            const parsed = parseRunLeaf(runName);
             if (parsed === undefined)
                 continue;
             let scopeFields;

package/dist/analyst-metric-families/acceptance-success-rework.js

@@ -33,7 +33,10 @@ const SUCCESS_STATUS = {
     doctor: new Set(["completed"]),
     merger: new Set(["completed"]),
 };
-/** Locate collector groups array: receipt.groups or top-level groups. */
+/**
+ * Locate collector groups array from the canonical typed receipt faces.
+ * Same leaf order as extractStatus: body / receipt / decisiveFacts / payloads.
+ */
 function findCollectorGroups(body) {
     if (Array.isArray(body.groups))
         return body.groups;
@@ -45,6 +48,16 @@ function findCollectorGroups(body) {
         const facts = outcome.decisiveFacts;
         if (isRecord(facts) && Array.isArray(facts.groups))
             return facts.groups;
+        // Typed sealed receipt: settlement keeps payloads on attempt-history; the
+        // terminal reader rehydrates them via attemptHistoryIdentity. Groups are the
+        // collector leaf on that receipt — never invent a second discriminator.
+        if (Array.isArray(outcome.payloads)) {
+            for (let index = outcome.payloads.length - 1; index >= 0; index -= 1) {
+                const payload = outcome.payloads[index];
+                if (isRecord(payload) && Array.isArray(payload.groups))
+                    return payload.groups;
+            }
+        }
     }
     return undefined;
 }
@@ -54,6 +67,17 @@ export function extractStatus(body) {
     if (isRecord(outcome) && typeof outcome.status === "string" && outcome.status.trim() !== "") {
         return outcome.status;
     }
+    // Typed sealed receipt: settlement keeps payloads on attempt-history; the
+    // terminal reader rehydrates them via attemptHistoryIdentity. Status is the role's
+    // own leaf on that receipt — never invent a second mapping.
+    if (isRecord(outcome) && Array.isArray(outcome.payloads)) {
+        for (let index = outcome.payloads.length - 1; index >= 0; index -= 1) {
+            const payload = outcome.payloads[index];
+            if (isRecord(payload) && typeof payload.status === "string" && payload.status.trim() !== "") {
+                return payload.status;
+            }
+        }
+    }
     const receipt = body.receipt;
     if (isRecord(receipt) && typeof receipt.status === "string" && receipt.status.trim() !== "") {
         return receipt.status;

package/dist/analyst-metric-families/round-timeline.js

@@ -15,13 +15,10 @@ function projectTerminal(facts) {
     if (facts.terminal.status === "absent") {
         return { kind: "death", channel: "no-receipt" };
     }
-    if (facts.terminal.file === "error.json") {
+    if (facts.terminal.face === "error") {
         return { kind: "death", channel: "error" };
     }
-    if (facts.terminal.file === "audit-incomplete.json") {
-        return { kind: "death", channel: "audit-incomplete" };
-    }
-    // report.json — receipt face; classCount only when producer wrote a number.
+    // report face — receipt; classCount only when producer wrote a number.
     const status = extractStatus(facts.terminal.body);
     const classCount = readClassCount(facts.terminal.body);
     const receiptStatus = status ?? "unparsed";

package/dist/archivist-record-entry.js

@@ -25,6 +25,7 @@ import {
   resolveNavigatorWorkSubjectPlacement
 } from "./archivist-record-topology.js";
 import { piRecordSessionHost } from "./pi/record-session-host.js";
+import { sitianVolumeDirectory } from "./sitian-appender.js";
 import {
   DIRECT_OFFICER_RUN_POINTER_KIND,
   bookDirectOfficerRunPointer
@@ -35,7 +36,7 @@ import {
 } from "./archivist-record-topology.js";
 const CURRENT_SESSION_LEDGER = "current-session.json";
 function readCurrentSession(sessionDir) {
-  const ledger = join(sessionDir, CURRENT_SESSION_LEDGER);
+  const ledger = currentSessionLedgerPath(sessionDir);
   try {
     const value = JSON.parse(readFileSync(ledger, "utf8"));
     if (typeof value !== "object" || value === null || typeof value.sessionFile !== "string" || value.sessionFile.length === 0) {
@@ -50,7 +51,7 @@ function readCurrentSession(sessionDir) {
   }
 }
 function writeCurrentSession(sessionDir, sessionFile) {
-  const ledger = join(sessionDir, CURRENT_SESSION_LEDGER);
+  const ledger = currentSessionLedgerPath(sessionDir);
   try {
     writeFileSync(ledger, `${JSON.stringify({ sessionFile })}
 `, { flag: "wx" });
@@ -268,7 +269,7 @@ function createRecordSessionOpen(options, host = piRecordSessionHost) {
     if (!physicallyContainedIn(ledgerHome, parentResolved)) {
       throw new Error("Durable record ownership requires a parent session inside the ledger home");
     }
-    sessionDir = join(dirname(parentResolved), options.kind);
+    sessionDir = sitianVolumeDirectory(dirname(parentResolved), options.kind);
     parentSession = parentFile;
     mayResumeSameNest = options.kind === WORKER_SUBMISSION_GATE_KIND;
   }

package/dist/archivist-record-pointer.js

@@ -1,21 +1,26 @@
-import { mkdirSync, writeFileSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
+import { basename, join } from "node:path";
 import { isRecord } from "./unknown-value.js";
+import { latestOfficerPointersFromRecords, RUN_HISTORY_FILE } from "./run-dossier.js";
+import { OFFICER_POINTER_RECORD_KIND } from "./run-dossier-files.js";
+import { readSitianRecords, reportRunRecord } from "./sitian-facade.js";
+import { homeFromRunDirectory } from "./activation-ledger-topology.js";
+import { findRunDirectoryById, readRoleRunIdentity } from "./public-cli/run-lifecycle.js";
+import { rewriteRunDirectoryPathValue } from "./role-run-relocation.js";
+import { parseRunLeaf, runDirectoryOfSessionFile } from "./role-run-placement.js";
 /** Typed parent-side pointer to an independent officer run 正本 (ADR 0079 / #675). */
 export const DIRECT_OFFICER_RUN_POINTER_KIND = "direct-officer-run-pointer";
+/** History record kind of a booked officer pointer (appender routes it to history.jsonl). */
+export { OFFICER_POINTER_RECORD_KIND };
 /**
- * Book a typed pointer under parent session/auditor-roles (same nest owner as
- * createRecordSession). Never fabricates user/assistant/toolResult rows (#675).
- * Directory placement stays with the archivist record entry (ADR 0018 / 0065).
+ * Book a typed pointer as one history record of the parent run; the settlement
+ * seam projects the latest per officer into current.json `officers`.
+ * Never fabricates user/assistant/toolResult rows (#675).
  *
- * Stable leaf per officer under one parent (#753 gate-round accounting):
- * same-parent re-summons upsert the same pointer instead of minting N files that
- * each re-scan the full officer session and multiply terminal gate-round counts.
+ * Latest record wins per officer under one parent (#753 gate-round accounting):
+ * a same-parent re-summons supersedes the earlier pointer instead of adding a
+ * second one that re-scans the full officer session and multiplies gate-cycle counts.
  */
 export function bookDirectOfficerRunPointer(options) {
-    const nest = join(dirname(options.parentSessionFile), "auditor-roles");
-    mkdirSync(nest, { recursive: true });
     const submissionToolCallId = options.submissionToolCallId?.trim() ?? "";
     const pointer = {
         version: 1,
@@ -27,38 +32,68 @@ export function bookDirectOfficerRunPointer(options) {
             : {}),
         ...(submissionToolCallId === "" ? {} : { submissionToolCallId }),
     };
-    writeFileSync(join(nest, `${options.officer}.pointer.json`), `${JSON.stringify(pointer)}\n`, "utf8");
+    reportRunRecord(runDirectoryOfSessionFile(options.parentSessionFile), OFFICER_POINTER_RECORD_KIND, pointer, "submission-gate");
     return pointer;
 }
+/** Shared strict pointer IO; internal audit wraps unreadability as a re-summons. */
+export async function resolveOfficerPointer(raw, parentRunDirectory) {
+    const where = `${parentRunDirectory} officers`;
+    if (!isRecord(raw) || raw.kind !== DIRECT_OFFICER_RUN_POINTER_KIND || raw.version !== 1) {
+        throw new Error(`direct officer run pointer has unknown shape in ${where}`);
+    }
+    if (typeof raw.sessionFile !== "string" || raw.sessionFile.trim() === "") {
+        throw new Error(`direct officer run pointer missing sessionFile in ${where}`);
+    }
+    const officer = raw.officer === "inspector" || raw.officer === "notary"
+        || raw.officer === "auditor" || raw.officer === "countersign" ? raw.officer : undefined;
+    let runDirectory = typeof raw.runDirectory === "string" && raw.runDirectory.trim() !== ""
+        ? raw.runDirectory : undefined;
+    let sessionFile = raw.sessionFile;
+    const recordedRunDirectory = runDirectory ?? runDirectoryOfSessionFile(sessionFile);
+    const leaf = parseRunLeaf(basename(recordedRunDirectory));
+    const parentIdentity = await readRoleRunIdentity(parentRunDirectory);
+    if (leaf !== undefined && parentIdentity !== undefined) {
+        const currentRunDirectory = await findRunDirectoryById(homeFromRunDirectory(parentRunDirectory), leaf.runId, parentIdentity.bookKey, leaf.role);
+        if (currentRunDirectory !== undefined) {
+            sessionFile = rewriteRunDirectoryPathValue(sessionFile, recordedRunDirectory, currentRunDirectory);
+            if (runDirectory !== undefined)
+                runDirectory = currentRunDirectory;
+        }
+    }
+    const submissionToolCallId = typeof raw.submissionToolCallId === "string"
+        && raw.submissionToolCallId.trim() !== "" ? raw.submissionToolCallId : undefined;
+    return {
+        sessionFile,
+        ...(officer === undefined ? {} : { officer }),
+        ...(runDirectory === undefined ? {} : { runDirectory }),
+        ...(submissionToolCallId === undefined ? {} : { submissionToolCallId }),
+    };
+}
 /**
- * Read the one officer pointer. Missing or unreadable is not a pass:
- * the caller re-runs the gate.
+ * The latest pointer booked per officer on one run, as stored. History absent → empty.
+ * Canonical malformed diagnostics are not discarded: a damaged officer source must
+ * not wash into lawful zero rounds (#1161 O1).
  */
+export async function readBookedOfficerPointers(parentRunDirectory) {
+    const { records, diagnostics } = await readSitianRecords(join(parentRunDirectory, RUN_HISTORY_FILE));
+    if (diagnostics.length > 0) {
+        throw new Error(`${RUN_HISTORY_FILE} has ${diagnostics.length} malformed row(s); officer pointers unreadable: ${parentRunDirectory}`);
+    }
+    return latestOfficerPointersFromRecords(records);
+}
+/** Every pointer booked on one run, in officer-name order. No pointers → []. */
+export async function readOfficerPointers(parentRunDirectory) {
+    const officers = await readBookedOfficerPointers(parentRunDirectory);
+    return Promise.all(Object.keys(officers).sort().map((name) => resolveOfficerPointer(officers[name], parentRunDirectory)));
+}
+/** Missing or unreadable is not a pass: the internal audit caller re-runs the gate. */
 export async function readDirectOfficerRunPointer(parentSessionFile, officer) {
     try {
-        const raw = JSON.parse(await readFile(join(dirname(parentSessionFile), "auditor-roles", `${officer}.pointer.json`), "utf8"));
-        if (!isRecord(raw) || raw.kind !== DIRECT_OFFICER_RUN_POINTER_KIND || raw.version !== 1) {
-            return undefined;
-        }
-        if (raw.officer !== officer)
-            return undefined;
-        if (typeof raw.sessionFile !== "string" || raw.sessionFile.trim() === "")
+        const parentRunDirectory = runDirectoryOfSessionFile(parentSessionFile);
+        const pointer = await resolveOfficerPointer((await readBookedOfficerPointers(parentRunDirectory))[officer], parentRunDirectory);
+        if (pointer.officer !== officer)
             return undefined;
-        const runDirectory = typeof raw.runDirectory === "string" && raw.runDirectory.trim() !== ""
-            ? raw.runDirectory
-            : undefined;
-        const submissionToolCallId = typeof raw.submissionToolCallId === "string"
-            && raw.submissionToolCallId.trim() !== ""
-            ? raw.submissionToolCallId
-            : undefined;
-        return {
-            version: 1,
-            kind: DIRECT_OFFICER_RUN_POINTER_KIND,
-            officer,
-            sessionFile: raw.sessionFile,
-            ...(runDirectory === undefined ? {} : { runDirectory }),
-            ...(submissionToolCallId === undefined ? {} : { submissionToolCallId }),
-        };
+        return { ...pointer, officer, version: 1, kind: DIRECT_OFFICER_RUN_POINTER_KIND };
     }
     catch {
         return undefined;

package/dist/atomic-write.js

@@ -1,11 +1,11 @@
 import { randomUUID } from "node:crypto";
 import { rename, rm, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
-async function writeFileAtomically(destination, contents) {
+async function writeFileAtomically(destination, contents, options) {
   const parent = dirname(destination);
   const temporary = join(parent, `.atomic-write-${randomUUID()}.tmp`);
   try {
-    await writeFile(temporary, contents);
+    await writeFile(temporary, contents, options);
     await rename(temporary, destination);
   } catch (error) {
     await rm(temporary, { force: true }).catch(() => void 0);

package/dist/auditor-dossier-tool.js

@@ -1,11 +1,15 @@
-import { dirname, join, resolve } from "node:path";
-import { roleRunArtifactsDirectory } from "./role-run-placement.js";
+import { join, resolve } from "node:path";
+import { RUN_HISTORY_FILE, RUN_LOG_FILE, runCurrentPath } from "./run-dossier.js";
+import {
+  runDirectoryOfSessionFile,
+  sessionFileOf
+} from "./role-run-placement.js";
 import { Type } from "typebox";
 const AUDITOR_DOSSIER_TOOL_NAME = "ak_get_run_dossier";
 function auditorRunDirectory(context) {
   const sessionFile = context.sessionManager?.getSessionFile?.();
   if (sessionFile === void 0) return void 0;
-  return resolve(dirname(dirname(sessionFile)));
+  return resolve(runDirectoryOfSessionFile(sessionFile));
 }
 function createAuditorDossierTool(runDirectory) {
   return {
@@ -23,10 +27,11 @@ function createAuditorDossierTool(runDirectory) {
       }
       const details = {
         runDirectory,
-        admittedRequest: join(runDirectory, "admitted-request.json"),
-        parentSessionCandidate: join(runDirectory, "session", "session.jsonl"),
+        current: runCurrentPath(runDirectory),
+        parentSessionCandidate: sessionFileOf(runDirectory),
         attachments: join(runDirectory, "attachments"),
-        artifacts: roleRunArtifactsDirectory(runDirectory)
+        log: join(runDirectory, RUN_LOG_FILE),
+        history: join(runDirectory, RUN_HISTORY_FILE)
       };
       return {
         content: [{ type: "text", text: JSON.stringify(details) }],

package/dist/auditor-soul.js

@@ -1,5 +1,7 @@
 import { readFile } from "node:fs/promises";
+import { readPageSync } from "./run-dossier.js";
 import { basename, join } from "node:path";
+import { parseRunLeaf } from "./role-run-placement.js";
 import { isRecord } from "./unknown-value.js";
 import { joinPackageMaterials, readPackageMaterial, } from "./session-opening-materials.js";
 /**
@@ -84,7 +86,7 @@ export function loadAuditorReferenceMaterialsFromSubjectInput(raw) {
     return loadAuditorReferenceMaterials(resolveAuditorSubject(raw));
 }
 function subjectFromSourceDirectory(sourceRunDirectory) {
-    const role = basename(sourceRunDirectory).split("@")[1];
+    const role = parseRunLeaf(basename(sourceRunDirectory))?.role;
     return isAuditorSoulRole(role) ? role : undefined;
 }
 /**
@@ -92,18 +94,9 @@ function subjectFromSourceDirectory(sourceRunDirectory) {
  * Explicit subject wins; otherwise the source-run role is the audited object.
  */
 export async function readAuditorResumeBinding(runDirectory) {
-    let raw;
-    try {
-        raw = JSON.parse(await readFile(join(runDirectory, "admitted-request.json"), "utf8"));
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return undefined;
-        throw error;
-    }
-    if (!isRecord(raw))
+    const record = readPageSync(runDirectory, "admitted");
+    if (record === undefined)
         return undefined;
-    const record = raw;
     if (typeof record.sourceRunPath !== "string" || record.sourceRunPath.trim() === "")
         return undefined;
     const subject = isAuditorSoulRole(record.auditorSubject)

package/dist/collector-config.js

@@ -1,6 +1,7 @@
 import { readFile } from "node:fs/promises";
 import { sha256Hex } from "./sha256.js";
 import { isRecord } from "./unknown-value.js";
+import { isTicketNumberString, parseTicketNumber } from "./run-ticket-number.js";
 export const COLLECTOR_OWNER_PATTERN = /^[A-Za-z0-9](?:[A-Za-z0-9-]{0,37}[A-Za-z0-9])?$/;
 export const COLLECTOR_REPO_PATTERN = /^[A-Za-z0-9](?:[A-Za-z0-9._-]{0,98}[A-Za-z0-9])?$/;
 function fail(message, cause) {
@@ -30,13 +31,13 @@ export function parseCollectorRepository(raw) {
     return { display: raw, canonical: `${owner}/${repo}`, owner, repo };
 }
 export function parseCollectorPrNumber(raw) {
-    if (typeof raw === "string" && !/^[1-9][0-9]*$/.test(raw))
-        fail("Collector pull request number must be a positive safe integer string");
     if (typeof raw !== "string" && typeof raw !== "number")
         fail("Collector pull request number is required");
-    const value = Number(raw);
-    if (!Number.isSafeInteger(value) || value < 1)
-        fail("Collector pull request number must be a positive safe integer");
+    const value = parseTicketNumber(raw);
+    if (value === undefined)
+        fail(typeof raw === "string" && !isTicketNumberString(raw)
+            ? "Collector pull request number must be a positive safe integer string"
+            : "Collector pull request number must be a positive safe integer");
     return value;
 }
 function canonicalManifest(requests) {