@akagilnc/pi-workflow-roles 0.1.5216 → 0.1.5235

package/src/headless-host/role-turn-host.ts

@@ -22,7 +22,10 @@ import {
   type SessionIdentityAuthority,
 } from "../prepared-role-turn.ts";
 
-import { reportHostSessionEvent } from "../host-session-record.ts";
+import {
+  copyAndRecordHostDossier,
+  recordNativeSessionPointer,
+} from "../host-session-record.ts";
 import {
   closeJsonSchemaForCodex,
   codexTurnArgs,
@@ -261,6 +264,7 @@ function spawnHeadlessTurn(options: {
   readonly stdin?: string;
   /** Called for each complete stdout line as it arrives (live stream-json). */
   readonly onStdoutLine?: (line: string) => void;
+  readonly onClose?: () => void;
 }): Promise<{ code: number | null; stdout: string; stderr: string; timedOut: boolean }> {
   return new Promise((resolve, reject) => {
     if (options.signal?.aborted) {
@@ -325,8 +329,15 @@ function spawnHeadlessTurn(options: {
         lineBuffer = "";
       }
     };
+    let aborted = false;
     const settle = (code: number | null): void => {
       if (settled) return;
+      if (aborted) {
+        settled = true;
+        if (timer !== undefined) clearTimeout(timer);
+        reject(hostAbortedError("headless host aborted"));
+        return;
+      }
       // Final flush first: onStdoutLine may failLine (reject + settled=true).
       flushStdoutLines("", true);
       if (settled) return;
@@ -340,11 +351,9 @@ function spawnHeadlessTurn(options: {
       resolve({ code, stdout: resultStdout, stderr, timedOut });
     };
     const onAbort = (): void => {
-      child.kill("SIGTERM");
       if (settled) return;
-      settled = true;
-      if (timer !== undefined) clearTimeout(timer);
-      reject(hostAbortedError("headless host aborted"));
+      aborted = true;
+      child.kill("SIGTERM");
     };
     child.stdout.setEncoding("utf8").on("data", (chunk: string) => { flushStdoutLines(chunk, false); });
     child.stderr.setEncoding("utf8").on("data", (chunk: string) => {
@@ -357,7 +366,10 @@ function spawnHeadlessTurn(options: {
       options.signal?.removeEventListener("abort", onAbort);
       reject(error);
     });
-    child.on("close", (code) => settle(code));
+    child.on("close", (code) => {
+      options.onClose?.();
+      settle(code);
+    });
     options.signal?.addEventListener("abort", onAbort, { once: true });
     if (options.timeoutMs !== undefined && options.timeoutMs > 0) {
       timer = setTimeout(() => {
@@ -498,6 +510,8 @@ export function createHeadlessRoleTurnHost(config: HeadlessRoleTurnHostConfig):
       }
 
       const sessionParent = config.sessionIdentity.resolveSessionFile(request.principal);
+      let exitedSessionId: string | undefined;
+      try {
       outcome = await driveExternalRoleTurnRounds(prepared, request, {
         roundLimitName: "HeadlessRoundLimit",
         currentSessionId: () => sessionId,
@@ -532,9 +546,23 @@ export function createHeadlessRoleTurnHost(config: HeadlessRoleTurnHostConfig):
           }
 
           const codexObserver = codex ? createCodexExecTurnObserver() : undefined;
+          let pointerRecorded = false;
+          let codexIdObserved = false;
+          if (sessionId !== undefined && sessionId !== "") {
+            pointerRecorded = recordNativeSessionPointer({
+              host: config.hostName,
+              sessionId,
+              cwd: request.cwd,
+              sessionParent,
+              home: request.home,
+            }) !== undefined;
+          }
+
           let spawned: { code: number | null; stdout: string; stderr: string; timedOut: boolean };
+          let childExited = false;
           try {
             spawned = await spawnHeadlessTurn({
+              onClose() { childExited = true; },
               binary: config.binary,
               args,
               cwd: request.cwd,
@@ -554,16 +582,33 @@ export function createHeadlessRoleTurnHost(config: HeadlessRoleTurnHostConfig):
                 }
                 // One bounded live seam owns both recording and host-specific reduction.
                 codexObserver?.observe(event);
-                reportHostSessionEvent({
-                  host: config.hostName,
-                  cwd: request.cwd,
-                  sessionParent,
-                  source: "headless-host",
-                  event,
-                });
+                if (!codex && typeof event === "object" && event !== null && "session_id" in event
+                  && typeof event.session_id === "string" && event.session_id !== "" && event.session_id !== sessionId) {
+                  sessionId = event.session_id;
+                  recordNativeSessionPointer({ host: config.hostName, sessionId, cwd: request.cwd, sessionParent, home: request.home });
+                }
+                if (codex && !codexIdObserved) {
+                  const tid = codexObserver?.result().threadId;
+                  if (tid !== undefined && tid !== "") {
+                    codexIdObserved = true;
+                    pointerRecorded = recordNativeSessionPointer({
+                      host: config.hostName,
+                      sessionId: tid,
+                      cwd: request.cwd,
+                      sessionParent,
+                      home: request.home,
+                    }) !== undefined;
+                  }
+                }
               },
             });
+            const roundSessionId = (codex ? codexObserver?.result().threadId : undefined) ?? sessionId;
+            exitedSessionId = roundSessionId;
+            if (codex && roundSessionId !== undefined && roundSessionId !== "" && !pointerRecorded) {
+              recordNativeSessionPointer({ host: config.hostName, sessionId: roundSessionId, cwd: request.cwd, sessionParent, home: request.home });
+            }
           } catch (error) {
+            if (childExited) exitedSessionId = (codex ? codexObserver?.result().threadId : undefined) ?? sessionId;
             if (isHostAbortedError(error)) throw error;
             const message = error instanceof Error ? error.message : String(error);
             const observedHostFailure = codexObserver?.result().failureDiagnostic;
@@ -577,24 +622,6 @@ export function createHeadlessRoleTurnHost(config: HeadlessRoleTurnHostConfig):
                 }, observedHostFailure),
               };
             }
-            // SitianInfrastructureError.knownCause is session; spawn errno stays activation.
-            const isRecordFailure =
-              typeof error === "object"
-              && error !== null
-              && ((error as { knownCause?: unknown }).knownCause === "session"
-                || (error as { name?: unknown }).name === "SitianInfrastructureError");
-            if (isRecordFailure) {
-              return {
-                status: "terminal",
-                result: failure(
-                  "session",
-                  "HostSessionRecordFailure",
-                  "host-session-record-failed",
-                  { diagnostic: message, sessionId },
-                  message,
-                ),
-              };
-            }
             return {
               status: "terminal",
               result: failure("activation", "HeadlessSpawnFailure", "spawn-failed", {
@@ -773,6 +800,15 @@ export function createHeadlessRoleTurnHost(config: HeadlessRoleTurnHostConfig):
           return { status: "delivered", stderr: spawned.stderr };
         },
       });
+      } finally {
+        if (exitedSessionId !== undefined && exitedSessionId !== "") copyAndRecordHostDossier({
+          host: config.hostName, sessionId: exitedSessionId, cwd: request.cwd,
+          sessionDirectory: join(request.runDirectory, "session"), sessionParent,
+          continuation: request.continuation,
+          ...(request.model !== undefined ? { model: request.model } : {}),
+          ...(request.home !== undefined ? { home: request.home } : {}),
+        });
+      }
     } finally {
       try {
         await prepared.dispose?.();

package/src/host-contracts.ts

@@ -158,19 +158,6 @@ export type RoleTurnModelConfig = {
   readonly thinking?: string;
 };
 
-/**
- * Typed cross-host resume handoff (#617 DK-4).
- * Present only when post-admission projects a real host switch.
- * priorNativeKind names the record family the paths belong to — Pi's own
- * session file, or sitian run records (ADR 0077) — so a consuming adapter
- * reads the handoff without knowing which host wrote it.
- * Target host reads those files itself; projector never copies bytes.
- */
-export type RoleTurnHostTransition = {
-  readonly priorNativeKind: "pi-native" | "sitian";
-  readonly priorNativePaths: readonly string[];
-};
-
 /** One main-session turn request over the host-neutral execution seam. */
 export type RoleTurnRequest = {
   readonly principal: DurablePrincipal;
@@ -193,8 +180,6 @@ export type RoleTurnRequest = {
    * has no parent to observe and leaves it absent.
    */
   readonly signal?: AbortSignal;
-  /** Set by post-admission only on a real host switch; never on same-host resume. */
-  readonly hostTransition?: RoleTurnHostTransition;
   /**
    * Court-turn attempt (#637 / #833): sole-final per attempt. Open court, summons,
    * and resume-with-message set this; bare resume without an open court omits it.

package/src/host-session-record.ts

@@ -1,41 +1,341 @@
 /**
- * Non-pi host turn events → sitian sole entry (ADR 0065 / 0077 / #811).
- * Adapters capture host-native structured events; this helper only packages
- * the common sitianReport call. session.jsonl stays header-only (#617 DK-4).
- * Write failures propagate (SitianInfrastructureError) — not best-effort.
+ * Host conversation dossiers are native file copies; sitian append-only (ADR 0086).
+ * Replaces live event streaming (ADR 0077) with post-exit CLI original copy.
+ * Writes native-session-pointer when session ID is obtained.
+ * Writes native-session-copy (or native-session-warning on retry failure) after CLI exit.
+ * Log line write failures declare to stderr and never abort the leg.
  */
+import { spawnSync } from "node:child_process";
+import {
+  appendFileSync,
+  copyFileSync,
+  closeSync,
+  existsSync,
+  openSync,
+  readFileSync,
+  mkdirSync,
+  readdirSync,
+  rmSync,
+  statSync,
+  type Dirent,
+} from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+import type { RoleTurnContinuation } from "./host-contracts.ts";
 import { sitianReport } from "./sitian-facade.ts";
+import type { SitianRecordInput } from "./sitian-contracts.ts";
 
 /** Volume category under `<run>/session/<kind>/records.jsonl`. */
 export const HOST_SESSION_RECORD_KIND = "host-session" as const;
 
-function eventField(event: unknown, key: string): string | undefined {
-  if (typeof event !== "object" || event === null || Array.isArray(event)) return undefined;
-  const value = (event as Record<string, unknown>)[key];
-  return typeof value === "string" && value.length > 0 ? value : undefined;
+function declareHostSessionFailure(error: unknown): void {
+  const message = error instanceof Error ? (error.stack || error.message) : String(error);
+  process.stderr.write(`[host-session] Dossier record failure: ${message}\n`);
+}
+
+/** Declare sitian record failure once to stderr without aborting the leg (ADR 0086). */
+export function sitianReportSafe(input: SitianRecordInput): void {
+  try {
+    sitianReport(input);
+  } catch (error) {
+    declareHostSessionFailure(error);
+  }
+}
+
+/** Recursively scan for Codex rollout file matching sessionId under sessionsDir. */
+function findCodexRollout(sessionsDir: string, sessionId: string): string | undefined {
+  if (!existsSync(sessionsDir)) return undefined;
+  const matches: Array<{ path: string; mtime: number }> = [];
+  function scan(dir: string, depth = 0): void {
+    if (depth > 6) return;
+    let entries: Dirent[];
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        scan(fullPath, depth + 1);
+      } else if (entry.isFile() && entry.name.endsWith(".jsonl") && entry.name.includes(sessionId)) {
+        try {
+          const stat = statSync(fullPath);
+          matches.push({ path: fullPath, mtime: stat.mtimeMs });
+        } catch {
+          matches.push({ path: fullPath, mtime: 0 });
+        }
+      }
+    }
+  }
+  scan(sessionsDir);
+  if (matches.length === 0 || matches[0] === undefined) return undefined;
+  matches.sort((a, b) => b.mtime - a.mtime);
+  return matches[0]?.path;
+}
+
+/**
+ * Sanitize working directory to match Claude Code's project directory name layout.
+ * Claude Code replaces all non-alphanumeric characters (slashes, dots, underscores, spaces, etc.) with '-'.
+ */
+export function sanitizeClaudeCwd(cwd: string): string {
+  return cwd.replace(/[^a-zA-Z0-9]/g, "-");
 }
 
-/** Live write of one host-emitted structured event. Throws on sitian persistence failure. */
-export function reportHostSessionEvent(input: {
+/**
+ * Resolve the CLI native session original path.
+ * Codex: single file rollout from ~/.codex/sessions/** /rollout-*-${sessionId}.jsonl
+ * Claude: single file transcript from ~/.claude/projects/<sanitized-cwd>/${sessionId}.jsonl
+ * Grok: directory ~/.grok/sessions/<encoded-cwd>/${sessionId}
+ * Pi / Hermes: undefined (Pi directly lands in session.jsonl; Hermes is state.db excluded from ADR 0086)
+ */
+export function resolveNativeSessionPath(options: {
   readonly host: string;
+  readonly sessionId: string;
+  readonly cwd: string;
+  readonly home?: string | undefined;
+}): string | undefined {
+  const home = options.home || homedir();
+  if (options.host === "claude") {
+    const configDir = process.env.CLAUDE_CONFIG_DIR || join(home, ".claude");
+    const sanitizedCwd = sanitizeClaudeCwd(options.cwd);
+    return join(configDir, "projects", sanitizedCwd, `${options.sessionId}.jsonl`);
+  }
+  if (options.host === "codex") {
+    return findCodexRollout(codexSessionsDirectory(home), options.sessionId);
+  }
+  if (options.host === "grok-build") {
+    const grokHome = process.env.GROK_HOME || join(home, ".grok");
+    return join(grokHome, "sessions", encodeURIComponent(options.cwd), options.sessionId);
+  }
+  return undefined;
+}
+
+function codexSessionsDirectory(home?: string): string {
+  return join(process.env.CODEX_HOME || join(home || homedir(), ".codex"), "sessions");
+}
+
+/** Count each host activation, including Pi turns without an external copy. */
+export function recordRunStart(runDirectory: string): void {
+  try { appendFileSync(join(runDirectory, ".run-starts"), "\n"); }
+  catch (error) { declareHostSessionFailure(error); }
+}
+
+/**
+ * Resolve the host dossier landing destination under `<run>/session/`.
+ * Format: `<run>/session/<host>-<model>-<n>` (single file adds .jsonl; model slashes replaced with -).
+ * Ordinal n is the start/resume count in the run (initial 1, each resume +1).
+ */
+export function resolveHostDossierLandingPath(options: {
+  readonly host: string;
+  readonly model?: { readonly model?: string; readonly thinking?: string } | undefined;
+  readonly sessionDirectory: string;
+  readonly continuation: RoleTurnContinuation;
+}): { readonly landingPath: string; readonly ordinal: number; readonly sanitizedModel: string } {
+  const sanitizedModel = (options.model?.model ?? "default").replace(/[\/\\]+/g, "-");
+  let maxOrdinal = 0;
+
+  if (existsSync(options.sessionDirectory)) {
+    try {
+      const entries = readdirSync(options.sessionDirectory);
+      for (const entry of entries) {
+        const match = entry.match(/-(\d+)(?:\.jsonl|\.failed)?$/);
+        const first = match?.[1];
+        if (first !== undefined) {
+          const val = parseInt(first, 10);
+          if (!isNaN(val) && val > maxOrdinal) {
+            maxOrdinal = val;
+          }
+        }
+      }
+    } catch {
+      // Ignore directory read errors
+    }
+  }
+
+  const startsPath = join(dirname(options.sessionDirectory), ".run-starts");
+  let starts = 0;
+  if (existsSync(startsPath)) starts = readFileSync(startsPath, "utf8").length;
+  const ordinal = Math.max(maxOrdinal + 1, starts, options.continuation.kind === "resume" ? 2 : 1);
+
+  const baseName = `${options.host}-${sanitizedModel}-${ordinal}`;
+  const landingPath = options.host === "grok-build"
+    ? join(options.sessionDirectory, baseName)
+    : join(options.sessionDirectory, `${baseName}.jsonl`);
+
+  return { landingPath, ordinal, sanitizedModel };
+}
+
+/** Record native session pointer line to Sitian as soon as session ID is known. */
+export function recordNativeSessionPointer(options: {
+  readonly host: string;
+  readonly sessionId: string;
   readonly cwd: string;
   readonly sessionParent: string;
-  readonly source: string;
-  readonly event: unknown;
-  readonly identity?: string;
-  readonly timestamp?: string;
-}): void {
-  const identity = input.identity ?? eventField(input.event, "uuid");
-  const timestamp = input.timestamp ?? eventField(input.event, "timestamp");
-  sitianReport({
+  readonly home?: string | undefined;
+}): string | undefined {
+  if (options.host === "pi" || options.host === "hermes") {
+    return undefined;
+  }
+  const nativePath = options.host === "codex"
+    ? codexSessionsDirectory(options.home)
+    : resolveNativeSessionPath(options);
+  if (nativePath === undefined) return undefined;
+
+  sitianReportSafe({
     level: "event",
     kind: HOST_SESSION_RECORD_KIND,
-    host: input.host,
-    cwd: input.cwd,
-    sessionParent: input.sessionParent,
-    source: input.source,
-    payload: input.event,
-    ...(identity === undefined ? {} : { identity }),
-    ...(timestamp === undefined ? {} : { timestamp }),
+    host: options.host,
+    cwd: options.cwd,
+    sessionParent: options.sessionParent,
+    source: `${options.host}-dossier`,
+    payload: {
+      type: "native-session-pointer",
+      nativePath,
+      sessionId: options.sessionId,
+    },
   });
+  return nativePath;
+}
+
+/** File clone via APFS `cp -c` with fallback to `copyFileSync`. */
+function copyFileCloneOrFallback(src: string, dest: string): void {
+  try {
+    const res = spawnSync("cp", ["-c", src, dest]);
+    if (res.status === 0) return;
+  } catch {
+    // cp execution failed, fall back
+  }
+  copyFileSync(src, dest);
+}
+
+/** Copy both grok-build originals: chat_history.jsonl and usage.json into destDir. */
+function copyGrokDossier(srcDir: string, destDir: string): void {
+  const chatHistorySrc = join(srcDir, "chat_history.jsonl");
+  if (!existsSync(chatHistorySrc)) {
+    throw new Error(`Grok native chat_history.jsonl missing at ${chatHistorySrc}`);
+  }
+  mkdirSync(destDir, { recursive: true });
+  const chatHistoryDest = join(destDir, "chat_history.jsonl");
+  copyFileCloneOrFallback(chatHistorySrc, chatHistoryDest);
+
+  const usageSrc = join(srcDir, "usage.json");
+  if (!existsSync(usageSrc)) {
+    throw new Error(`Grok native usage.json missing at ${usageSrc}`);
+  }
+  copyFileCloneOrFallback(usageSrc, join(destDir, "usage.json"));
+}
+
+/**
+ * Copy native host session original to run session dossier after child process exits.
+ * If copy fails, retries once.
+ * On success, appends native-session-copy line to Sitian.
+ * On repeated failure, appends native-session-warning line to Sitian.
+ * Does not throw; turn outcome is never altered by copy success or failure.
+ */
+export function copyAndRecordHostDossier(options: {
+  readonly host: string;
+  readonly sessionId: string;
+  readonly cwd: string;
+  readonly sessionDirectory: string;
+  readonly sessionParent: string;
+  readonly continuation: RoleTurnContinuation;
+  readonly model?: { readonly model?: string; readonly thinking?: string } | undefined;
+  readonly home?: string | undefined;
+}): void {
+  if (options.host === "pi" || options.host === "hermes") {
+    return;
+  }
+  const nativePath = resolveNativeSessionPath({
+    host: options.host,
+    sessionId: options.sessionId,
+    cwd: options.cwd,
+    ...(options.home !== undefined ? { home: options.home } : {}),
+  });
+  if (nativePath === undefined && options.host !== "codex") return;
+
+  let destination: ReturnType<typeof resolveHostDossierLandingPath>;
+  try {
+    destination = resolveHostDossierLandingPath(options);
+  } catch (error) {
+    sitianReportSafe({
+      level: "event",
+      kind: HOST_SESSION_RECORD_KIND,
+      host: options.host,
+      cwd: options.cwd,
+      sessionParent: options.sessionParent,
+      source: `${options.host}-dossier`,
+      payload: {
+        type: "native-session-warning",
+        sessionId: options.sessionId,
+        error: error instanceof Error ? error.message : String(error),
+      },
+    });
+    return;
+  }
+  const { landingPath, ordinal, sanitizedModel } = destination;
+
+  let lastError: unknown;
+  let copySuccess = false;
+  for (let attempt = 1; attempt <= 2; attempt++) {
+    try {
+      if (options.host === "grok-build") {
+        copyGrokDossier(nativePath!, landingPath);
+      } else {
+        if (nativePath === undefined || !existsSync(nativePath)) {
+          throw new Error(`Native session file missing for ${options.host} session ${options.sessionId}`);
+        }
+        mkdirSync(dirname(landingPath), { recursive: true });
+        copyFileCloneOrFallback(nativePath, landingPath);
+      }
+      copySuccess = true;
+      break;
+    } catch (error) {
+      lastError = error;
+    }
+  }
+
+  if (copySuccess) {
+    sitianReportSafe({
+      level: "event",
+      kind: HOST_SESSION_RECORD_KIND,
+      host: options.host,
+      cwd: options.cwd,
+      sessionParent: options.sessionParent,
+      source: `${options.host}-dossier`,
+      payload: {
+        type: "native-session-copy",
+        nativePath,
+        landingPath,
+        ordinal,
+        sessionId: options.sessionId,
+      },
+    });
+  } else {
+    // A partial first attempt must not masquerade as a complete native original.
+    try { rmSync(landingPath, { recursive: options.host === "grok-build", force: true }); }
+    catch { /* warning below reports the original copy failure */ }
+    // Reserve the failed ordinal outside the native dossier landing namespace.
+    try {
+      mkdirSync(options.sessionDirectory, { recursive: true });
+      closeSync(openSync(join(options.sessionDirectory, `${options.host}-${sanitizedModel}-${ordinal}.failed`), "a"));
+    } catch { /* the warning below retains the original copy failure */ }
+    sitianReportSafe({
+      level: "event",
+      kind: HOST_SESSION_RECORD_KIND,
+      host: options.host,
+      cwd: options.cwd,
+      sessionParent: options.sessionParent,
+      source: `${options.host}-dossier`,
+      payload: {
+        type: "native-session-warning",
+        nativePath,
+        landingPath,
+        ordinal,
+        sessionId: options.sessionId,
+        error: lastError instanceof Error ? lastError.message : String(lastError),
+      },
+    });
+  }
 }

package/src/pi/role-turn-host.ts

@@ -22,7 +22,6 @@ import type {
   RoleTurnResult,
 } from "../host-contracts.ts";
 import { ExplicitInternalActivationError } from "../host-contracts.ts";
-import { isOfficerReviewSeat } from "../packaged-role-registry.ts";
 import { applyEngineChildEnv, ENGINE_MODEL_FLAG_NAME, normalizeEngineName } from "../engine-detour.ts";
 import { projectActivationFlags } from "../role-activation-flags.ts";
 import { encodeUserDialogueStdin } from "../user-dialogue-stdin.ts";
@@ -377,30 +376,7 @@ export function createPiRoleTurnHost(config: PiRoleTurnHostConfig): RoleTurnHost
 
   return {
     async executeTurn(request: RoleTurnRequest): Promise<RoleTurnResult> {
-      // #617 DK-7: Pi argv gets projected native paths once; never record bytes.
-      // Pi already owns its own session file, so only sitian prior volume rides in.
-      // #879: station-child officer dialogue keeps peer words — do not splice
-      // host-transition priorNativePaths into the review prompt body.
-      let turnRequest = request;
-      const officerStationChild =
-        request.stationChild === true && isOfficerReviewSeat(request.activation.role);
-      const paths =
-        !officerStationChild && request.hostTransition?.priorNativeKind === "sitian"
-          ? request.hostTransition.priorNativePaths
-          : undefined;
-      if (
-        request.continuation.kind === "resume"
-        && paths !== undefined
-        && paths.length > 0
-      ) {
-        turnRequest = {
-          ...request,
-          continuation: {
-            ...request.continuation,
-            prompt: `${request.continuation.prompt}\n${paths.join("\n")}`,
-          },
-        };
-      }
+      const turnRequest = request;
       const roleEntry = await realpath(resolveInternalRoleEntrypoint(config.packageRoot));
       const extraArgs = buildPiTurnExtraArgs(
         turnRequest,