@akagilnc/pi-workflow-roles 0.1.5504 → 0.1.5575

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

@@ -1,5 +1,5 @@
 /**
- * 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`.
  *
  * Consumer: Analyst sole ledger scan (classifyScopedRun). Metric families must
  * not open a second disk scan — they consume retained facts.
@@ -8,9 +8,8 @@
  * 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
@@ -23,14 +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, isEnoent } from "./unknown-value.js";
 import { retainedRunPathsMatch } from "./role-run-relocation.js";
 import { runDirectoryOfSessionFile } from "./role-run-placement.js";
-import { resolveOfficerSessionFromPointerFile } from "./archivist-record-pointer.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 = {
@@ -311,61 +308,32 @@ function pairGateRounds(volumes) {
         .map((round, index) => ({ ...round, roundIndex: index + 1 }));
 }
 /**
- * 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 gate-cycle statistics (#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 officer = pointer?.officer === "inspector" || pointer?.officer === "notary"
-                ? pointer.officer : undefined;
-            const classified = await classifyAuditorVolume(sessionPath, officer);
-            for (const volume of classified) {
-                if (options.parentSessionFile !== undefined &&
-                    volume.parentSessionFile !== undefined &&
-                    !await retainedRunPathsMatch(volume.parentSessionFile, options.parentSessionFile, runDirectoryOfSessionFile(options.parentSessionFile))) {
-                    continue;
-                }
-                volumes.push(volume);
             }
+            volumes.push(volume);
         }
     }
     return pairGateRounds(volumes);

package/dist/analyst-ledger.js

@@ -12,23 +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, parseRunLeaf, sessionFileOf, } from "./role-run-placement.js";
-import { sitianRunVolumeDirectory } from "./sitian-appender.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) {
@@ -79,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;
@@ -126,20 +117,11 @@ 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 typeof parsed.runDirectory === "string"
-                ? rewriteRunDirectoryPathValue(parsed.sessionFile, parsed.runDirectory, runDirectory)
-                : 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 sessionFileOf(runDirectory);
 }
@@ -331,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") {
@@ -349,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,
             };
@@ -387,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 = sessionFileOf(input.runDirectory);
-        gateCycles = await readAnalystGateCyclesFromAuditorRoles(sitianRunVolumeDirectory(input.runDirectory, "auditor-roles"), { parentSessionFile });
+        gateCycles = await readAnalystGateCyclesFromOfficers(input.runDirectory, { parentSessionFile });
     }
     catch (error) {
         return {

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-pointer.js

@@ -1,29 +1,26 @@
-import { mkdirSync, writeFileSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-import { basename, dirname, join } from "node:path";
-import { isRecord, errorText } from "./unknown-value.js";
+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, runDirectoryFromSessionDirectory } from "./role-run-placement.js";
-import { sitianVolumeDirectory } from "./sitian-appender.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";
-function directOfficerRunPointerFile(parentSessionFile, officer) {
-    return join(sitianVolumeDirectory(dirname(parentSessionFile), "auditor-roles"), `${officer}.pointer.json`);
-}
+/** 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 gate-cycle 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 pointerFile = directOfficerRunPointerFile(options.parentSessionFile, options.officer);
-    mkdirSync(dirname(pointerFile), { recursive: true });
     const submissionToolCallId = options.submissionToolCallId?.trim() ?? "";
     const pointer = {
         version: 1,
@@ -35,23 +32,17 @@ export function bookDirectOfficerRunPointer(options) {
             : {}),
         ...(submissionToolCallId === "" ? {} : { submissionToolCallId }),
     };
-    writeFileSync(pointerFile, `${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 resolveOfficerSessionFromPointerFile(pointerPath) {
-    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 });
-    }
+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 ${pointerPath}`);
+        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 ${pointerPath}`);
+        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;
@@ -60,7 +51,6 @@ export async function resolveOfficerSessionFromPointerFile(pointerPath) {
     let sessionFile = raw.sessionFile;
     const recordedRunDirectory = runDirectory ?? runDirectoryOfSessionFile(sessionFile);
     const leaf = parseRunLeaf(basename(recordedRunDirectory));
-    const parentRunDirectory = runDirectoryFromSessionDirectory(dirname(dirname(pointerPath)));
     const parentIdentity = await readRoleRunIdentity(parentRunDirectory);
     if (leaf !== undefined && parentIdentity !== undefined) {
         const currentRunDirectory = await findRunDirectoryById(homeFromRunDirectory(parentRunDirectory), leaf.runId, parentIdentity.bookKey, leaf.role);
@@ -79,10 +69,28 @@ export async function resolveOfficerSessionFromPointerFile(pointerPath) {
         ...(submissionToolCallId === undefined ? {} : { submissionToolCallId }),
     };
 }
+/**
+ * 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 pointer = await resolveOfficerSessionFromPointerFile(directOfficerRunPointerFile(parentSessionFile, officer));
+        const parentRunDirectory = runDirectoryOfSessionFile(parentSessionFile);
+        const pointer = await resolveOfficerPointer((await readBookedOfficerPointers(parentRunDirectory))[officer], parentRunDirectory);
         if (pointer.officer !== officer)
             return undefined;
         return { ...pointer, officer, version: 1, kind: DIRECT_OFFICER_RUN_POINTER_KIND };

package/dist/auditor-dossier-tool.js

@@ -1,6 +1,6 @@
 import { join, resolve } from "node:path";
+import { RUN_HISTORY_FILE, RUN_LOG_FILE, runCurrentPath } from "./run-dossier.js";
 import {
-  roleRunArtifactsDirectory,
   runDirectoryOfSessionFile,
   sessionFileOf
 } from "./role-run-placement.js";
@@ -27,10 +27,11 @@ function createAuditorDossierTool(runDirectory) {
       }
       const details = {
         runDirectory,
-        admittedRequest: join(runDirectory, "admitted-request.json"),
+        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,4 +1,5 @@
 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";
@@ -93,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/doctor-evidence.js

@@ -9,7 +9,7 @@ async function discoverCaseFiles(root) { const found = []; async function walk(d
     if (item.isDirectory()) {
         await walk(path, depth + 1);
     }
-    else if (item.isFile() && (item.name.endsWith(".jsonl") || (item.name === "stderr.log" && depth === 1)))
+    else if (item.isFile() && ((item.name.endsWith(".jsonl") && item.name !== "state.jsonl" && !(item.name === "log.jsonl" && depth === 1)) || (item.name === "log.jsonl" && depth === 1)))
         found.push(path);
 } } await walk(root, 0); return found.sort(); }
 function sourceList(count, sources) { return { count, sources: [...new Set(sources)].sort() }; }
@@ -122,9 +122,9 @@ export async function loadDoctorCase(runsPath, projectRoot) {
         const id = relative(root, path).split(sep).join("/");
         const bytes = await readFile(path);
         const content = bytes.toString("utf8");
-        const kind = id.endsWith(".jsonl") ? "session" : "stderr";
+        const kind = id.split("/").length === 2 && id.endsWith("/log.jsonl") ? "log" : "session";
         evidence.push({ id, kind, byteLength: bytes.byteLength, contentLength: content.length, sha256: sha256Hex(bytes), content });
-        if (kind === "stderr")
+        if (kind === "log")
             continue;
         const result = deriveSession(content, id);
         sessions.push(result.session);

package/dist/engine-detour-usage.js

@@ -15,12 +15,12 @@
  * `ak-role resume`) mints a new one. Never courtAttemptId, never Pi session
  * toolResult join keys, and never a detour-owned sidecar file.
  */
+import { readPageSync, RUN_LOG_FILE } from "./run-dossier.js";
 import { randomUUID } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 export { runDirectoryFromSessionDirectory, sessionFileIn as sessionFileFromSessionDirectory, } from "./role-run-placement.js";
 import { ENGINE_DETOUR_TOOL_NAME } from "./engine-detour.js";
-import { sitianRunVolumeDirectory, sitianVolumeRecordsFile } from "./sitian-appender.js";
 import { readSitianRecords, resolveSitianRecordPath, sitianReport, } from "./sitian-facade.js";
 import { isRecord } from "./unknown-value.js";
 /** Sitian event kind for one detour-tool call (volume under session/). */
@@ -28,11 +28,11 @@ export const ENGINE_DETOUR_CALL_KIND = "engine-detour-call";
 /** decisiveFacts key — name states detour-tool scope, not full engine usage. */
 export const ENGINE_DETOUR_TOOL_USAGE_FACT_KEY = "engineDetourToolUsage";
 /**
- * Run-relative sitian volume path for one detour call.
+ * Run-relative path of the log that holds one detour call's record.
  * Openable once the run directory is known from the terminal's run id.
  * Contains no runId bytes itself (#108 + #537).
  */
-export const ENGINE_DETOUR_CALL_RECORD_FILE_RELATIVE = sitianVolumeRecordsFile(sitianRunVolumeDirectory("", ENGINE_DETOUR_CALL_KIND));
+export const ENGINE_DETOUR_CALL_RECORD_FILE_RELATIVE = RUN_LOG_FILE;
 /** stdout UTF-8 byte length (ticket-frozen metric; empty stdout is real 0). */
 export function engineDetourStdoutByteLength(stdout) {
     return Buffer.byteLength(stdout, "utf8");
@@ -182,19 +182,11 @@ export async function readEngineDetourToolUsage(input) {
     const calls = Array.from(callsByToolCallId.values());
     return { callCount: calls.length, calls };
 }
-/** One shared invocation.json reader (ENOENT → undefined; other errors propagate). */
+/** One shared state.jsonl invocation-row reader (absent → undefined; other errors propagate). */
 function readInvocationRecord(runDirectory) {
-    try {
-        const raw = JSON.parse(readFileSync(join(runDirectory, "invocation.json"), "utf8"));
-        return isRecord(raw) ? raw : undefined;
-    }
-    catch (error) {
-        if (error?.code === "ENOENT")
-            return undefined;
-        throw error;
-    }
+    return readPageSync(runDirectory, "invocation");
 }
-/** True when invocation.json carries a non-empty engine axis. */
+/** True when the invocation section carries a non-empty engine axis. */
 export async function readInvocationEngineMounted(runDirectory) {
     const raw = readInvocationRecord(runDirectory);
     if (raw === undefined)