@akagilnc/pi-workflow-roles 0.1.5714 → 0.1.5753

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

@@ -1,5 +1,6 @@
 /**
- * Sole reader for gate-cycle facts of the officers pointed at from current.json `officers`.
+ * Sole reader for gate-cycle facts of archived officer-pointer history rows
+ * (decoded via readOfficerPointers; parent current.json no longer projects officers — #1195).
  *
  * Consumer: Analyst sole ledger scan (classifyScopedRun). Metric families must
  * not open a second disk scan — they consume retained facts.
@@ -8,7 +9,7 @@
  * the current gatekeeper/inspector/notary English face. Projection always uses
  * the current English officer identity (inspector | notary).
  *
- * Absent `officers` section → empty rounds (lawful zero). A pointer whose
+ * No archived pointers → 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
@@ -308,10 +309,10 @@ function pairGateRounds(volumes) {
         .map((round, index) => ({ ...round, roundIndex: index + 1 }));
 }
 /**
- * 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.
+ * Read and pair gate-cycle rounds from archived officer-pointer history on one
+ * parent run; each pointer names the independent officer session 正本.
+ * No pointers → [] (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.
  */

package/dist/archivist-record-pointer.js

@@ -2,40 +2,20 @@ 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 { readSitianRecords } from "./sitian-facade.js";
 import { homeFromRunDirectory } from "./activation-ledger-topology.js";
-import { findRunDirectoryById, readRoleRunIdentity } from "./public-cli/run-lifecycle.js";
+import { resolveLiveRunDirectoryPath, 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). */
+/**
+ * Historical parent-side pointer shape (ADR 0079 / #675).
+ * Production no longer writes these (#1195); retained only so analysts can read
+ * already-archived officer volumes. New runs leave officers empty (lawful zero).
+ */
 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 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).
- *
- * 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 submissionToolCallId = options.submissionToolCallId?.trim() ?? "";
-    const pointer = {
-        version: 1,
-        kind: DIRECT_OFFICER_RUN_POINTER_KIND,
-        officer: options.officer,
-        sessionFile: options.sessionFile,
-        ...(options.runDirectory !== undefined && options.runDirectory.trim() !== ""
-            ? { runDirectory: options.runDirectory }
-            : {}),
-        ...(submissionToolCallId === "" ? {} : { submissionToolCallId }),
-    };
-    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. */
+/** Decode one archived pointer; relocates session/run paths when the leaf moved. */
 export async function resolveOfficerPointer(raw, parentRunDirectory) {
     const where = `${parentRunDirectory} officers`;
     if (!isRecord(raw) || raw.kind !== DIRECT_OFFICER_RUN_POINTER_KIND || raw.version !== 1) {
@@ -53,20 +33,17 @@ export async function resolveOfficerPointer(raw, parentRunDirectory) {
     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);
+        const currentRunDirectory = await resolveLiveRunDirectoryPath(recordedRunDirectory, homeFromRunDirectory(parentRunDirectory), parentIdentity.bookKey);
         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 }),
     };
 }
 /**
@@ -86,16 +63,3 @@ 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 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 };
-    }
-    catch {
-        return undefined;
-    }
-}

package/dist/auditor-soul.js

@@ -1,5 +1,6 @@
 import { readFile } from "node:fs/promises";
 import { readPageSync } from "./run-dossier.js";
+import { admittedSourceRunPath } from "./public-cli/invocation.js";
 import { basename, join } from "node:path";
 import { parseRunLeaf } from "./role-run-placement.js";
 import { isRecord } from "./unknown-value.js";
@@ -93,16 +94,17 @@ function subjectFromSourceDirectory(sourceRunDirectory) {
  * Resume binding already on the admitted page.
  * Explicit subject wins; otherwise the source-run role is the audited object.
  */
-export async function readAuditorResumeBinding(runDirectory) {
-    const record = readPageSync(runDirectory, "admitted");
+export async function readAuditorResumeBinding(admitted) {
+    const record = readPageSync(admitted.runDirectory, "admitted");
     if (record === undefined)
         return undefined;
-    if (typeof record.sourceRunPath !== "string" || record.sourceRunPath.trim() === "")
+    const sourceRunPath = admittedSourceRunPath(admitted);
+    if (sourceRunPath === undefined)
         return undefined;
     const subject = isAuditorSoulRole(record.auditorSubject)
         ? record.auditorSubject
-        : subjectFromSourceDirectory(record.sourceRunPath);
+        : subjectFromSourceDirectory(sourceRunPath);
     if (subject === undefined)
         return undefined;
-    return { subject, sourceRunDirectory: record.sourceRunPath };
+    return { subject, sourceRunDirectory: sourceRunPath };
 }

package/dist/external-host-turn-loop.js

@@ -5,28 +5,14 @@
  */
 import { existsSync } from "node:fs";
 import { basename } from "node:path";
-import { tryBookKeyFromAkRolesPath } from "./activation-ledger-topology.js";
 import { projectThrownFailureLeaf, retainPackageFault } from "./public-cli/settlement.js";
-import { describeErrorIdentity, findRunDirectoryById } from "./public-cli/run-lifecycle.js";
+import { describeErrorIdentity, resolveLiveRunDirectoryPath } from "./public-cli/run-lifecycle.js";
+export { resolveLiveRunDirectoryPath } from "./public-cli/run-lifecycle.js";
 import { deliveryLimitFromConfig } from "./receipt-delivery-policy.js";
 import { parseRunLeaf } from "./role-run-placement.js";
 import { projectTurnRequestLiveRunDirectory } from "./role-run-relocation.js";
 import { reportRunRecord } from "./sitian-facade.js";
 import { isOneShotWorkerReminderCode } from "./submission-errors.js";
-/**
- * #1171: mid-turn report-ticket may have moved the leg. Prefer the recorded
- * path when it still exists; otherwise re-locate by run id inside the book.
- * Undefined means vanished and unlocatable — callers must not revive the dead leaf.
- */
-export async function resolveLiveRunDirectoryPath(recordedPath, home) {
-    if (existsSync(recordedPath))
-        return recordedPath;
-    const parsed = parseRunLeaf(basename(recordedPath));
-    const bookKey = tryBookKeyFromAkRolesPath(recordedPath);
-    if (parsed === undefined || bookKey === undefined)
-        return undefined;
-    return await findRunDirectoryById(home, parsed.runId, bookKey, parsed.role);
-}
 /**
  * Prefer the request path when it still exists; otherwise re-locate by run id
  * (resolveLiveRunDirectoryPath). Mutates the live request so later turn-record /

package/dist/gatekeeper-role.js

@@ -84,7 +84,7 @@ function projectOfficerPayloads(officer, payloads, fallbackStatus) {
     // Single this-court seal is the common path. Never fold history into an array receipt.
     return projectOfficerDecision(officer, payloads[payloads.length - 1], fallbackStatus);
 }
-/** Nested officer runId from summoned.runDirectory, else terminal.runId (#969). */
+/** Nested officer runId from summoned.runDirectory, else terminal.runId (resume identity). */
 export function officerRunIdFromSummoned(summoned) {
     if (typeof summoned.runDirectory === "string" && summoned.runDirectory.trim() !== "") {
         const fromDir = runIdFromRunDirectory(summoned.runDirectory);
@@ -159,6 +159,19 @@ function projectOfficerTerminal(officer, summoned) {
         }, summoned);
     }
     if (outcome.kind === "accepted") {
+        // Nested / prior incomplete (directionUnsettled) is not a gate pass (ADR 0055).
+        // Receipt stays this-court or retained; runId comes from the summoned volume
+        // (public-role-summons already prefers nested terminal.runId when roles differ).
+        // No parent-side officerPayloads / officerRunId copies (#1195).
+        if (outcome.decisiveFacts?.directionUnsettled === true) {
+            const receipt = thisCourt.length > 0 ? thisCourt[thisCourt.length - 1] : retainedReceipt(outcome);
+            return withOfficerRunId({
+                status: "needs_reask",
+                officer,
+                receipt,
+                receivedStatus: receivedDiscriminator(receipt, "status"),
+            }, summoned);
+        }
         // outcome.status is the fixture/compat leaf: production settlement leaves
         // it undefined once payloads are recorded. It may interpret a receipt
         // lacking its own status, never substitute for a missing receipt.