@akagilnc/pi-workflow-roles 0.1.4586 → 0.1.4631

package/src/public-role-summons.ts

@@ -103,6 +103,12 @@ export type PublicSummonRequest = {
   readonly boundTicketNumber?: number;
   /** Caller correlation id for nested leg ledger (ADR 0010 / #924). */
   readonly correlationId?: string;
+  /**
+   * Resume an existing instruction-seat run via public CLI resume (host-native
+   * session continuity). Used by navigator attendance so prior advice stays on
+   * the host session — not a package-built advice ledger.
+   */
+  readonly resumeRunId?: string;
   /**
    * Ephemeral host-turn cwd override (#946 fresh-copy sandbox). Admission keeps
    * the public --project / cwd identity; the host turn runs under this path.
@@ -516,7 +522,7 @@ export async function summonPublicRole(
     case "navigator":
     case "gatekeeper": {
       const seat = options.role;
-      const [{ runPublicInstructionSeat }, invocation] = await Promise.all([
+      const [{ runPublicInstructionSeat, runPublicInstructionSeatResume }, invocation] = await Promise.all([
         import("./public-cli/instruction-seat-run.ts"),
         import("./public-cli/invocation.ts"),
       ]);
@@ -526,10 +532,33 @@ export async function summonPublicRole(
           : seat === "navigator"
             ? invocation.parseNavigatorArgv
             : invocation.parseGatekeeperArgv;
-      const stepped = await runPrepared(parse, (env, once) =>
-        runPublicInstructionSeat(options.argv, env as never, io, seat, once));
-      if ("fail" in stepped) return stepped.fail;
-      result = stepped.ok;
+      const resumeRunId = typeof options.resumeRunId === "string" && options.resumeRunId.trim() !== ""
+        ? options.resumeRunId.trim()
+        : undefined;
+      if (resumeRunId !== undefined) {
+        // Host CLI resume — same face as `ak-role resume <runId> [message]`.
+        // Instruction/materials ride summons.instruction (not package memory).
+        const instruction = options.argv[0] ?? "";
+        const stepped = await runPrepared(parse, (env) =>
+          runPublicInstructionSeatResume(
+            {
+              runId: resumeRunId,
+              summons: {
+                instruction,
+                instructionEmpty: instruction.trim() === "",
+              },
+            },
+            env as never,
+            io,
+          ));
+        if ("fail" in stepped) return stepped.fail;
+        result = stepped.ok;
+      } else {
+        const stepped = await runPrepared(parse, (env, once) =>
+          runPublicInstructionSeat(options.argv, env as never, io, seat, once));
+        if ("fail" in stepped) return stepped.fail;
+        result = stepped.ok;
+      }
       break;
     }
     case "judge": {

package/src/role-envelope.ts

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { mkdir, writeFile } from "node:fs/promises";
+import { appendFile, mkdir, writeFile } from "node:fs/promises";
 import { createServer, type Server, type Socket } from "node:net";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -115,7 +115,11 @@ export async function prepareRoleEnvelope(options: {
   await mkdir(request.runDirectory, { recursive: true });
 
   // Durable principal file for isAvailable / resumable settlement (public-cli).
-  // #617 DK-4: header layout only — never host conversation/tool writeback into Pi JSONL.
+  // #617 DK-4: never host conversation/tool writeback into Pi JSONL.
+  // #959: package-owned custom entries (invocation marker, submission-closure,
+  // navigator attendance, no-receipt) MUST flush so parent settlement can read
+  // them after the headless process ends — memory-only books left extractNavigatorFact
+  // with no durable terminal / attendance on codex/claude/ACP parents.
   let sessionFile = options.sessionFile ?? join(request.runDirectory, "session", "session.jsonl");
   await mkdir(dirname(sessionFile), { recursive: true });
   if (request.continuation.kind !== "resume") {
@@ -135,6 +139,31 @@ export async function prepareRoleEnvelope(options: {
       if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
     }
   }
+  // Settlement reads the durable file after the turn; write must complete before
+  // closeRound returns. Sync-order via chained promise kept on the envelope.
+  // Chain itself never rejects (closeRound/dispose stay orderly). Required package
+  // entry flush failure arms the existing typed infrastructure-failure slot —
+  // never log-and-continue into accepted (#959 失败诚实).
+  let durableWriteChain: Promise<void> = Promise.resolve();
+  /** Filled by rememberInfrastructureFailure; declared later, closed over here. */
+  let armDurableWriteFailure: ((customType: string, diagnostic: string) => void) | undefined;
+  /** Append one package-owned session entry to the durable principal (fire-and-order). */
+  const persistPackageSessionEntry = (entry: Record<string, unknown>): void => {
+    const customType = typeof entry.customType === "string" ? entry.customType : "unknown";
+    const line = `${JSON.stringify({
+      ...entry,
+      id: typeof entry.id === "string" ? entry.id : randomUUID(),
+      timestamp: typeof entry.timestamp === "string" ? entry.timestamp : new Date().toISOString(),
+    })}\n`;
+    durableWriteChain = durableWriteChain.then(async () => {
+      try {
+        await appendFile(sessionFile, line, "utf8");
+      } catch (error) {
+        const diagnostic = error instanceof Error ? error.message : String(error);
+        armDurableWriteFailure?.(customType, diagnostic);
+      }
+    });
+  };
   const context: HostContext = {
     cwd: request.cwd,
     mode: "print",
@@ -155,6 +184,7 @@ export async function prepareRoleEnvelope(options: {
         const entry = { type: "custom", customType, data };
         sessionEntries.push(entry);
         customEntries.push({ customType, data });
+        persistPackageSessionEntry(entry);
       },
     },
     abort() {
@@ -170,6 +200,7 @@ export async function prepareRoleEnvelope(options: {
     const entry = { type: "custom_message", customType, ...payload, message: payload };
     sessionEntries.push(entry);
     customEntries.push({ customType, data: message.details ?? message.content });
+    persistPackageSessionEntry(entry);
   };
 
   const emit = async (event: string, value: unknown): Promise<unknown[]> => {
@@ -304,6 +335,17 @@ export async function prepareRoleEnvelope(options: {
     };
     hostAbort.abort();
   }
+  armDurableWriteFailure = (customType, diagnostic) => {
+    rememberInfrastructureFailure(
+      {
+        cause: "infrastructure",
+        kind: "role_infrastructure_failure",
+        code: "durable-session-write-failed",
+        customType,
+      },
+      [{ type: "text", text: `ak-role: durable session entry flush failed (${customType}): ${diagnostic}` }],
+    );
+  };
   /**
    * One non-correctable infra pathway for execute throws and pre-execution emits:
    * build fact → fill closeRound slot → arm hostAbort. Projection may follow.
@@ -500,15 +542,50 @@ export async function prepareRoleEnvelope(options: {
   let disposed = false;
   // Per-turn run/court identity lives on HostContext (request-scoped). Engine
   // axis is already a RoleHost flag — never process.env (#818 P1 / #879).
+
+  /** True once closeRound returned an infrastructure failure to the host. */
+  let durableFailureHandedToCloseRound = false;
+  /** Drain required package-owned writes; infrastructure outranks every close outcome. */
+  const settleDurableWrites = async (): Promise<
+    | { readonly accepted: false; readonly failure: RoleTurnKnownFailure }
+    | undefined
+  > => {
+    await durableWriteChain;
+    if (infrastructureRoundFailure !== undefined) {
+      durableFailureHandedToCloseRound = true;
+      return { accepted: false as const, failure: infrastructureRoundFailure };
+    }
+    return undefined;
+  };
+
   const dispose = async (): Promise<void> => {
     if (disposed) return;
     disposed = true;
     const cleanupFailures: unknown[] = [];
+    // session_shutdown may still append package durable entries (navigator
+    // attendance when agent_settled was skipped). Drain only after those
+    // handlers — single terminal judgment via settleDurableWrites (#959).
     try {
       await emit("session_shutdown", {});
     } catch (error) {
       cleanupFailures.push(error);
     }
+    try {
+      // Always drain post-shutdown writes. Only throw when the host has not
+      // already received this infrastructure failure via closeRound.
+      const alreadyHanded = durableFailureHandedToCloseRound;
+      const durableFailure = await settleDurableWrites();
+      if (durableFailure !== undefined && !alreadyHanded) {
+        cleanupFailures.push(
+          Object.assign(
+            new Error(durableFailure.failure.diagnostic ?? "durable session entry flush failed"),
+            { code: durableFailure.failure.identity?.code ?? "durable-session-write-failed" },
+          ),
+        );
+      }
+    } catch (error) {
+      cleanupFailures.push(error);
+    }
     try {
       const closeAll = (server as unknown as { closeAllConnections?: () => void }).closeAllConnections;
       if (typeof closeAll === "function") closeAll.call(server);
@@ -532,8 +609,7 @@ export async function prepareRoleEnvelope(options: {
     // duplicate so structured_output + tool-call does not arm non-sole.
     if (calls.some((call) => call.toolName === terminatingToolName)) return;
     await invokeAkTool(terminatingToolName, params ?? {});
-  }
-
+  };
   const closeRound: PreparedRoleTurn["closeRound"] = async () => {
     // Typed round boundary: hand the complete call list to the shared ledger once.
     if (calls.length > 0) {
@@ -543,6 +619,7 @@ export async function prepareRoleEnvelope(options: {
     }
     // Infrastructure failure outranks accepted closure / correctable retry (#593).
     if (infrastructureRoundFailure !== undefined) {
+      durableFailureHandedToCloseRound = true;
       return { accepted: false as const, failure: infrastructureRoundFailure };
     }
     let closure: { customType: string; data: unknown } | undefined;
@@ -553,6 +630,8 @@ export async function prepareRoleEnvelope(options: {
       // Pi flushes navigator attendance on agent_settled; session/prompt
       // resolution is the ACP host equivalent round boundary.
       await emit("agent_settled", {});
+      const durableFailure = await settleDurableWrites();
+      if (durableFailure !== undefined) return durableFailure;
       return { accepted: true as const };
     }
     if (rejection !== undefined) {
@@ -562,11 +641,17 @@ export async function prepareRoleEnvelope(options: {
         message: rejection.message,
       };
       rejection = undefined;
+      // Drain write chain before retry: a package-owned append may still fail after
+      // the correctable rejection was booked; infrastructure outranks retry.
+      const durableFailure = await settleDurableWrites();
+      if (durableFailure !== undefined) return durableFailure;
       return { accepted: false as const, retry };
     }
     // #836: host ended without a recorded submission is not a failure.
     // Settlement presents ledger contents; empty ledger → no_receipt.
     await emit("agent_settled", {});
+    const durableFailure = await settleDurableWrites();
+    if (durableFailure !== undefined) return durableFailure;
     return { accepted: true as const };
   };
 

package/src/role-runtime.ts

@@ -1,3 +1,4 @@
+import { randomUUID } from "node:crypto";
 import { readFileSync, writeSync } from "node:fs";
 import { join } from "node:path";
 import {
@@ -12,24 +13,14 @@ import {
 
 import { Value } from "typebox/value";
 import { sitianReport } from "./sitian-facade.ts";
-import { createSubmissionLedgerHost } from "./submission-ledger.ts";
+import { createSubmissionLedgerHost, sealAcceptedSubmission } from "./submission-ledger.ts";
 import { createCollectorLedger } from "./collector-ledger.ts";
 
 import { activationTraceRecordSchema, namedActivationCause, type ActivationTraceRecord, type ActivationTraceWriter } from "./activation-trace.ts";
+import { homeFromRunDirectory } from "./activation-ledger-topology.ts";
 import {
-  homeFromRunDirectory,
-  resolveActivationLedgerHomeForPath,
-} from "./activation-ledger-topology.ts";
-import {
-  appendAcceptedActivationToBook,
-  buildAcceptedActivationFact,
-  correlationIdentityFromEnv,
   durableSessionPointer,
-  resolveActivationLedgerHome,
   resolveBookKeyFromGit,
-  type AcceptedActivationFact,
-  type ActivationCorrelationIdentity,
-  type ActivationSessionPointer,
 } from "./activation-ledger.ts";
 import { writeStderrJsonlRecord } from "./stderr-jsonl.ts";
 import {
@@ -300,43 +291,18 @@ export {
 export { activationTraceRecordSchema, namedActivationCause } from "./activation-trace.ts";
 export type { ActivationTraceRecord, ActivationTraceWriter } from "./activation-trace.ts";
 export {
-  ACCEPTED_ACTIVATION_EVENT,
-  ACCEPTED_ACTIVATION_FACT_KEYS,
   ActivationGitRepositoryRequiredError,
   ActivationLedgerError,
   ActivationSessionFileMissingError,
   activationBookDirectory,
-  activationWaitingLedgerPath,
-  appendAcceptedActivationFact,
-  appendAcceptedActivationToBook,
-  buildAcceptedActivationFact,
-  correlationIdentityFromEnv,
   durableSessionPointer,
   resolveActivationLedgerHome,
   resolveBookKeyFromGit,
-  serializeAcceptedActivationFact,
 } from "./activation-ledger.ts";
 export type {
-  AcceptedActivationFact,
-  AcceptedActivationFactInput,
-  AcceptedActivationFactKey,
-  ActivationCorrelationIdentity,
   ActivationSessionManager,
   ActivationSessionPointer,
 } from "./activation-ledger.ts";
-export {
-  DISPATCH_STUB_EVENT,
-  buildDispatchStubFact,
-  reconcileInvocation,
-} from "./activation-reconciliation.ts";
-export type {
-  DispatchPointer,
-  DispatchStubFact,
-  DispatchStubFactInput,
-  ProcessLivenessFact,
-  ReconciliationOutcome,
-  ReconciliationSubject,
-} from "./activation-reconciliation.ts";
 export {
   TOOL_EXECUTION_UPDATE_HEARTBEAT,
   TOOL_EXECUTION_UPDATE_THROTTLE_MS,
@@ -1225,6 +1191,28 @@ export function createCountersignRoleRuntime(
   );
 }
 
+/**
+ * #959: last assistant text parts as navigator prose exit.
+ * Tool-call-only messages yield undefined — those already ride the tool path.
+ */
+function lastAssistantProse(
+  messages: readonly { role: string; content?: readonly { type: string; text?: string }[] }[],
+): string | undefined {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (message?.role !== "assistant" || !Array.isArray(message.content)) continue;
+    const texts: string[] = [];
+    for (const part of message.content) {
+      if (part.type === "text" && typeof part.text === "string" && part.text.length > 0) {
+        texts.push(part.text);
+      }
+    }
+    if (texts.length === 0) continue;
+    return texts.join("");
+  }
+  return undefined;
+}
+
 export function createRoleRuntimeExtension(
   dependencies: RoleRuntimeDependencies,
 ): (envelopeHost: RoleEnvelopeHost) => void {
@@ -1299,10 +1287,9 @@ export function createRoleRuntimeExtension(
       if (settlement === undefined || attendance === undefined) return;
       const workContext = navigatorWorkContext;
       const pending = (async () => {
-        if (settlement.kind !== "accepted") {
-          await attendance.settle(settlement);
-          return;
-        }
+        // ADR 0052 / #959: every settlement that starts a post-role feed host round
+        // (accepted, human_decision, role_infrastructure_failure) shares one grace
+        // and the same honest unavailable projection — no unbounded parallel branch.
         const settlePromise = attendance.settle(settlement);
         // Attach catch immediately so a late rejection after grace timeout cannot
         // surface as unhandledRejection / stale-ctx after session dispose (#675).
@@ -1557,18 +1544,12 @@ export function createRoleRuntimeExtension(
         pendingSubmissionNonPassByToolCallId.delete(event.toolCallId);
         return { details: submissionNonPass, isError: true };
       }
-      // Recommendation rides the accepted settlement record's content so the one
-      // mandatory last-ak_*_output extraction surfaces route/next/reason without
-      // a second file, grep, or nesting step. Receipt details stay contract-pure;
-      // unavailable/no-advice leave the settlement untouched.
-      if (event.isError) return;
-      return;
     });
     // Queue receipt delivery before `agent_settled`: that event means Pi has
     // already decided no queued continuation will run, so a triggerTurn there is
     // too late for print/json sessions. `agent_end` is the last production seam
     // whose queued next turn is consumed before settlement.
-    roleHost.on("agent_end", (event, ctx) => {
+    roleHost.on("agent_end", async (event, ctx) => {
       const lastMessage = event.messages.at(-1);
       if (lastMessage?.role === "assistant"
         && (lastMessage.stopReason === "error" || lastMessage.stopReason === "aborted")) {
@@ -1578,6 +1559,50 @@ export function createRoleRuntimeExtension(
         }
         return;
       }
+      const role = selectedRole ?? roleHost.getFlag(ROLE_FLAG.name);
+      // #959: navigator prose exit — final assistant text is the receipt.
+      // No typed-tool 催交; no JSON required. Tool path still wins when already accepted.
+      if (role === "navigator" && receiptDelivery.nextAction() !== "accepted") {
+        const prose = lastAssistantProse(event.messages);
+        if (prose !== undefined && prose.trim() !== "") {
+          const accepted = { prose };
+          await sealAcceptedSubmission({
+            context: ctx,
+            role: "navigator",
+            accepted,
+            toolCallId: `navigator-prose-exit:${randomUUID()}`,
+          });
+          await projectClosedSubmission(
+            { role: "navigator", kind: "accepted", accepted },
+            ctx,
+          );
+          return;
+        }
+        // Attended with neither tool nor prose → honest no_receipt (not typed 催交).
+        // Exhaust delivery budget without sending the typed prompt so facts() stays lawful.
+        if (!noReceiptRecorded) {
+          const runPointer = runDirectoryFromHostContext(ctx);
+          if (runPointer !== undefined) {
+            noReceiptRecorded = true;
+            while (receiptDelivery.nextAction() === "request-delivery") {
+              receiptDelivery.recordDeliveryRequest();
+            }
+            const facts = receiptDelivery.facts({ runPointer, attemptPointer: `current:${runPointer}` });
+            envelopeHost.appendEntry(NO_RECEIPT_LIFECYCLE_ENTRY_TYPE, facts);
+            try {
+              sitianReport({
+                level: "event",
+                kind: "no-receipt-lifecycle",
+                cwd: ctx.cwd,
+                sessionParent: ctx.sessionManager.getSessionFile(),
+                payload: facts,
+                source: "role-runtime",
+              });
+            } catch {}
+          }
+        }
+        return;
+      }
       if (receiptDelivery.nextAction() === "request-delivery") {
         receiptDelivery.recordDeliveryRequest();
         // Keep the package-owned continuation off the public input lifecycle:
@@ -1657,8 +1682,8 @@ export function createRoleRuntimeExtension(
           process.exitCode = 1;
         }
       }
-      // Flush any still-pending affirmative attendance before teardown. Accepted
-      // grace-timeout paths normally emit on agent_settled; abort can skip that hook.
+      // Flush any still-pending affirmative attendance before teardown.
+      // Grace-timeout paths normally emit on agent_settled; abort can skip that hook.
       const presentation = pendingNavigatorPresentation;
       pendingNavigatorPresentation = undefined;
       if (presentation !== undefined) {
@@ -2135,11 +2160,9 @@ export function createRoleRuntimeExtension(
         // Production topology only (ADR 0048/0049): no test-only ledger hooks.
         // Admit durable session file first so lifecycle getEntries/appendEntry are truthful:
         // deferred SM materialization must not wipe an in-memory principal marker.
-        const bookKey = resolveBookKeyFromGit(ctx.cwd);
-        const correlation = correlationIdentityFromEnv();
-        const sessionFile = ctx.sessionManager.getSessionFile?.() || ctx.sessionManager.getSessionDir?.();
-        const ledgerHome = resolveActivationLedgerHomeForPath(sessionFile);
-        const session = durableSessionPointer(ctx.sessionManager);
+        // #855: two-face waiting.jsonl write removed — fail-closed book-key + session only.
+        resolveBookKeyFromGit(ctx.cwd);
+        durableSessionPointer(ctx.sessionManager);
 
         // Station children (court diarist, inner-gate summons) omit navigator sidecar (#840).
         // Top-level public entry legs still attend automatically.
@@ -2254,16 +2277,6 @@ export function createRoleRuntimeExtension(
           if (entry.role === "coder") coder.armSubmissionGate(ctx.cwd, ctx.sessionManager);
           else fixer.armSubmissionGate(ctx.cwd, ctx.sessionManager);
         }
-        appendAcceptedActivationToBook({
-          ledgerHome,
-          fact: buildAcceptedActivationFact({
-            role: entry.role,
-            observedAt: clock(),
-            bookKey,
-            session,
-            correlation,
-          }),
-        });
         admitted = true;
       } catch (error) {
         failInfrastructure(error, ctx);

package/src/submission-ledger.ts

@@ -517,6 +517,65 @@ async function restoreState(cwd: string, runId: string, scope: SubmissionLedgerR
   };
 }
 
+/** Sole HostContext-derived session parent for ledger restore/append (never process.env). */
+function sessionParentFromHostContext(context: HostContext): string | undefined {
+  const runDirectory = runDirectoryFromHostContext(context);
+  if (runDirectory !== undefined) return join(runDirectory, "session", "session.jsonl");
+  const sessionFile = context.sessionManager.getSessionFile?.();
+  if (typeof sessionFile === "string" && sessionFile.length > 0) return sessionFile;
+  const sessionDir = context.sessionManager.getSessionDir?.();
+  if (typeof sessionDir === "string" && sessionDir.length > 0) {
+    return join(sessionDir, "session.jsonl");
+  }
+  return undefined;
+}
+
+function homeFromHostContext(context: HostContext, home?: string): string | undefined {
+  if (home !== undefined) return home;
+  const sessionParent = sessionParentFromHostContext(context);
+  return sessionParent !== undefined ? tryHomeFromAkRolesPath(sessionParent) : undefined;
+}
+
+/**
+ * #959: seal one accepted submission without a model tool call.
+ * Same ledger row shape and priorEventId chain as the terminating-tool wrap.
+ * Used when a prose-exit seat (navigator) harvests the final assistant text.
+ */
+export async function sealAcceptedSubmission(options: {
+  readonly context: HostContext;
+  readonly role: TerminalRoleName;
+  readonly accepted: unknown;
+  readonly toolCallId: string;
+  readonly home?: string;
+}): Promise<void> {
+  const runId = runIdentity(options.context);
+  const attemptId = attemptIdentity(options.context, runId);
+  const sessionParent = sessionParentFromHostContext(options.context);
+  const home = homeFromHostContext(options.context, options.home);
+  const state = await restoreState(options.context.cwd, runId, {
+    ...(home === undefined ? {} : { home }),
+    ...(sessionParent === undefined ? {} : { sessionParent }),
+  });
+  const pointer = sitianReport({
+    level: "event",
+    kind: "sealed",
+    subject: { runId, attemptId },
+    ...(state.prior === undefined ? {} : { priorEventId: state.prior.identity }),
+    payload: {
+      type: "sealed",
+      attemptId,
+      toolCallId: options.toolCallId,
+      role: options.role,
+      accepted: options.accepted,
+    },
+    source: "role-runtime",
+    cwd: options.context.cwd,
+    ...(home !== undefined ? { home } : {}),
+    ...(sessionParent === undefined ? {} : { sessionParent }),
+  });
+  state.prior = pointer;
+}
+
 /**
  * Submission ledger host — record only (#836).
  * Each terminating submission is appended with the role's original payload.
@@ -531,28 +590,11 @@ export function createSubmissionLedgerHost(
   options?: { home?: string },
 ): RoleHost {
   const states = new Map<string, Promise<LedgerState>>();
-  /** Sole HostContext-derived run coordinate for restore and append (never process.env). */
-  const sessionParentFromContext = (context: HostContext): string | undefined => {
-    const runDirectory = runDirectoryFromHostContext(context);
-    if (runDirectory !== undefined) {
-      return join(runDirectory, "session", "session.jsonl");
-    }
-    const sessionFile = context.sessionManager.getSessionFile?.();
-    if (typeof sessionFile === "string" && sessionFile.length > 0) return sessionFile;
-    const sessionDir = context.sessionManager.getSessionDir?.();
-    if (typeof sessionDir === "string" && sessionDir.length > 0) {
-      return join(sessionDir, "session.jsonl");
-    }
-    return undefined;
-  };
-  const resolveHomeFromContext = (context: HostContext): string | undefined => {
-    if (options?.home !== undefined) return options.home;
-    const sessionParent = sessionParentFromContext(context);
-    return sessionParent !== undefined ? tryHomeFromAkRolesPath(sessionParent) : undefined;
-  };
+  const resolveHomeFromContext = (context: HostContext): string | undefined =>
+    homeFromHostContext(context, options?.home);
   const stateFor = (context: HostContext, runId: string) => states.get(runId) ?? (() => {
     const home = resolveHomeFromContext(context);
-    const sessionParent = sessionParentFromContext(context);
+    const sessionParent = sessionParentFromHostContext(context);
     const pending = restoreState(context.cwd, runId, {
       ...(home === undefined ? {} : { home }),
       ...(sessionParent === undefined ? {} : { sessionParent }),
@@ -562,7 +604,7 @@ export function createSubmissionLedgerHost(
   })();
   const appendFor = (state: LedgerState, context: HostContext, runId: string, attemptId: string, event: SubmissionLedgerEvent): RecordPointer => {
     const home = resolveHomeFromContext(context);
-    const sessionParent = sessionParentFromContext(context);
+    const sessionParent = sessionParentFromHostContext(context);
     const pointer = sitianReport({
       level: "event",
       kind: event.type,

package/dist/activation-reconciliation.js

@@ -1,61 +0,0 @@
-const DISPATCH_STUB_EVENT = "dispatch-stub";
-function buildDispatchStubFact(input) {
-  return {
-    event: DISPATCH_STUB_EVENT,
-    observedAt: input.observedAt,
-    bookKey: input.bookKey,
-    dispatch: input.dispatch.kind === "process" ? { kind: "process", pid: input.dispatch.pid } : { kind: "opaque", ref: input.dispatch.ref },
-    correlation: { kind: "caller", id: input.correlation.id }
-  };
-}
-function callerCorrelationId(correlation) {
-  return correlation.kind === "caller" ? correlation.id : void 0;
-}
-function dispatchMatchesActivation(dispatch, activation) {
-  const activationId = callerCorrelationId(activation.correlation);
-  return activationId !== void 0 && activationId === dispatch.correlation.id && activation.bookKey === dispatch.bookKey;
-}
-function reconcileInvocation(subject) {
-  const { dispatch, activation, process } = subject;
-  if (activation !== void 0) {
-    if (dispatch !== void 0 && dispatchMatchesActivation(dispatch, activation)) {
-      return {
-        kind: "matched",
-        correlationId: dispatch.correlation.id,
-        bookKey: dispatch.bookKey
-      };
-    }
-    return {
-      kind: "activation-without-dispatch",
-      correlationId: callerCorrelationId(activation.correlation),
-      bookKey: activation.bookKey
-    };
-  }
-  if (dispatch !== void 0) {
-    if (process === void 0) {
-      throw new TypeError(
-        "reconcileInvocation requires process liveness when activation is absent"
-      );
-    }
-    if (process.state === "alive") {
-      return {
-        kind: "pending",
-        correlationId: dispatch.correlation.id,
-        bookKey: dispatch.bookKey
-      };
-    }
-    return {
-      kind: "ghost",
-      correlationId: dispatch.correlation.id,
-      bookKey: dispatch.bookKey
-    };
-  }
-  throw new TypeError(
-    "reconcileInvocation requires a dispatch stub and/or an accepted-activation fact"
-  );
-}
-export {
-  DISPATCH_STUB_EVENT,
-  buildDispatchStubFact,
-  reconcileInvocation
-};

package/dist/public-cli/command-renderer.js

@@ -1,5 +0,0 @@
-/**
- * Public CLI re-export of the shared registry-owned command renderer.
- * Single implementation lives in src/public-command-renderer.ts.
- */
-export { isPublicCallableRole, renderPublicAkRoleCommand, } from "../public-command-renderer.js";

package/dist/public-command-renderer.js

@@ -1,29 +0,0 @@
-import {
-  PACKAGED_ROLE_REGISTRY,
-  packagedRoleMetadata
-} from "./packaged-role-registry.js";
-const PUBLIC_CALLABLE_ROLES = new Set(
-  PACKAGED_ROLE_REGISTRY.map((entry) => entry.role)
-);
-function isPublicCallableRole(role) {
-  return PUBLIC_CALLABLE_ROLES.has(role);
-}
-function renderPublicAkRoleCommand(target) {
-  if (!isPublicCallableRole(target.role)) return void 0;
-  const role = target.role;
-  const metadata = packagedRoleMetadata(role);
-  if (metadata !== void 0 && "bareCommand" in metadata && metadata.bareCommand === false) {
-    return void 0;
-  }
-  if (target.phase === null || target.phase === void 0) {
-    return `ak-role ${role}`;
-  }
-  if (role === "coder" || role === "fixer") {
-    return `ak-role ${role} ${target.phase}`;
-  }
-  return `ak-role ${role}`;
-}
-export {
-  isPublicCallableRole,
-  renderPublicAkRoleCommand
-};