@akagilnc/pi-workflow-roles 0.1.5504 → 0.1.5575

package/dist/host-descriptions.js

@@ -26,7 +26,6 @@ export const HOST_DESCRIPTIONS = Object.freeze({
         }),
         modelPassing: "set_model",
         setModelId: "bare",
-        sessionBindingFile: "grok-acp-session.json",
     }),
     /**
      * Operator home `~/.hermes`, native session/load resume, `acp` subcommand.
@@ -44,7 +43,6 @@ export const HOST_DESCRIPTIONS = Object.freeze({
         }),
         modelPassing: "set_model",
         setModelId: "provider:model",
-        sessionBindingFile: "hermes-acp-session.json",
         seatProfileSoul: Object.freeze({
             flag: "-p",
             namePrefix: "ak-",
@@ -64,7 +62,6 @@ export const HEADLESS_HOST_DESCRIPTIONS = Object.freeze({
     "claude": Object.freeze({
         protocol: "claude-print",
         binaryFromHome: Object.freeze([".local", "bin", "claude"]),
-        sessionBindingFile: "claude-headless-session.json",
         fixedArgs: Object.freeze([
             // Live NDJSON events → sitian host-session records (#811); last line is the result receipt.
             "--output-format", "stream-json",
@@ -89,7 +86,6 @@ export const HEADLESS_HOST_DESCRIPTIONS = Object.freeze({
     "codex": Object.freeze({
         protocol: "codex-exec",
         binaryFromHome: Object.freeze([".local", "bin", "codex"]),
-        sessionBindingFile: "codex-headless-session.json",
     }),
 });
 export function lookupHostDescription(host) {

package/dist/host-session-record.js

@@ -1,304 +1,303 @@
-/**
- * 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 { randomBytes } from "node:crypto";
 import { spawnSync } from "node:child_process";
-import { appendFileSync, copyFileSync, closeSync, existsSync, openSync, readFileSync, mkdirSync, readdirSync, rmSync, statSync, } from "node:fs";
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  renameSync,
+  rmSync,
+  statSync
+} from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { sitianReport } from "./sitian-facade.js";
-import { errorText } from "./unknown-value.js";
-/** Volume category under `<run>/session/<kind>/records.jsonl`. */
-export const HOST_SESSION_RECORD_KIND = "host-session";
+import { errorText, isEnoent } from "./unknown-value.js";
+const HOST_SESSION_RECORD_KIND = "host-session";
 function declareHostSessionFailure(error) {
-    const message = error instanceof Error ? (error.stack || error.message) : String(error);
-    process.stderr.write(`[host-session] Dossier record failure: ${message}\n`);
+  const message = error instanceof Error ? error.stack || error.message : String(error);
+  process.stderr.write(`[host-session] Dossier record failure: ${message}
+`);
 }
-/** Declare sitian record failure once to stderr without aborting the leg (ADR 0086). */
-export function sitianReportSafe(input) {
-    try {
-        sitianReport(input);
-    }
-    catch (error) {
-        declareHostSessionFailure(error);
-    }
+function sitianReportSafe(input) {
+  try {
+    sitianReport(input);
+  } catch (error) {
+    declareHostSessionFailure(error);
+  }
 }
-/** Recursively scan for Codex rollout file matching sessionId under sessionsDir. */
 function findCodexRollout(sessionsDir, sessionId) {
-    if (!existsSync(sessionsDir))
-        return undefined;
-    const matches = [];
-    function scan(dir, depth = 0) {
-        if (depth > 6)
-            return;
-        let entries;
+  const matches = [];
+  function scan(dir, depth = 0) {
+    if (depth > 6) return;
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch (error) {
+      if (isEnoent(error)) return;
+      throw error;
+    }
+    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 {
-            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 });
-                }
-            }
+          const stat = statSync(fullPath);
+          matches.push({ path: fullPath, mtime: stat.mtimeMs });
+        } catch (error) {
+          if (isEnoent(error)) continue;
+          throw error;
         }
+      }
     }
+  }
+  try {
     scan(sessionsDir);
-    if (matches.length === 0 || matches[0] === undefined)
-        return undefined;
-    matches.sort((a, b) => b.mtime - a.mtime);
-    return matches[0]?.path;
+  } catch (error) {
+    if (isEnoent(error)) return void 0;
+    throw error;
+  }
+  if (matches.length === 0 || matches[0] === void 0) return void 0;
+  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) {
-    return cwd.replace(/[^a-zA-Z0-9]/g, "-");
+function sanitizeClaudeCwd(cwd) {
+  return cwd.replace(/[^a-zA-Z0-9]/g, "-");
 }
-/**
- * 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) {
-    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 resolveNativeSessionPath(options) {
+  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 void 0;
 }
 function codexSessionsDirectory(home) {
-    return join(process.env.CODEX_HOME || join(home || homedir(), ".codex"), "sessions");
+  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) {
-    try {
-        appendFileSync(join(runDirectory, ".run-starts"), "\n");
-    }
-    catch (error) {
-        declareHostSessionFailure(error);
-    }
+function resolveHostDossierLandingPath(options) {
+  return options.host === "grok-build" ? join(options.sessionDirectory, options.host) : join(options.sessionDirectory, `${options.host}.jsonl`);
 }
-/**
- * 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) {
-    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) {
-    if (options.host === "pi" || options.host === "hermes") {
-        return undefined;
+function recordNativeSessionPointer(options) {
+  if (options.host === "pi" || options.host === "hermes") {
+    return void 0;
+  }
+  const nativePath = options.host === "codex" ? codexSessionsDirectory(options.home) : resolveNativeSessionPath(options);
+  if (nativePath === void 0) return void 0;
+  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-pointer",
+      nativePath,
+      sessionId: options.sessionId
     }
-    const nativePath = options.host === "codex"
-        ? codexSessionsDirectory(options.home)
-        : resolveNativeSessionPath(options);
-    if (nativePath === undefined)
-        return undefined;
-    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-pointer",
-            nativePath,
-            sessionId: options.sessionId,
-        },
-    });
-    return nativePath;
+  });
+  return nativePath;
 }
-/** File clone via APFS `cp -c` with fallback to `copyFileSync`. */
 function copyFileCloneOrFallback(src, dest) {
-    try {
-        const res = spawnSync("cp", ["-c", src, dest]);
-        if (res.status === 0)
-            return;
-    }
-    catch {
-        // cp execution failed, fall back
-    }
-    copyFileSync(src, dest);
+  try {
+    const res = spawnSync("cp", ["-c", src, dest]);
+    if (res.status === 0) return;
+  } catch {
+  }
+  copyFileSync(src, dest);
 }
-/** Copy both grok-build originals: chat_history.jsonl and usage.json into destDir. */
 function copyGrokDossier(srcDir, destDir) {
-    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"));
+  mkdirSync(destDir, { recursive: true });
+  copyFileCloneOrFallback(join(srcDir, "chat_history.jsonl"), join(destDir, "chat_history.jsonl"));
+  copyFileCloneOrFallback(join(srcDir, "usage.json"), 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) {
-    if (options.host === "pi" || options.host === "hermes") {
-        return;
-    }
-    const nativePath = resolveNativeSessionPath({
+function copyAndRecordHostDossier(options) {
+  if (options.host === "hermes") {
+    return;
+  }
+  const report = (payload) => sitianReportSafe({
+    level: "event",
+    kind: HOST_SESSION_RECORD_KIND,
+    host: options.host,
+    cwd: options.cwd,
+    sessionParent: options.sessionParent,
+    source: `${options.host}-dossier`,
+    payload
+  });
+  if (options.host === "pi") {
+    report({
+      type: "native-session-copy",
+      nativePath: options.sessionParent,
+      landingPath: options.sessionParent,
+      sessionId: options.sessionId
+    });
+    return;
+  }
+  const landingPath = resolveHostDossierLandingPath(options);
+  let lastError;
+  let copySuccess = false;
+  let stagingForCleanup;
+  let nativePath;
+  for (let attempt = 1; attempt <= 2; attempt++) {
+    const attemptToken = randomBytes(6).toString("hex");
+    const staging = `${landingPath}.copying.${attemptToken}`;
+    stagingForCleanup = staging;
+    try {
+      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;
-    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: errorText(error),
-            },
-        });
+        ...options.home !== void 0 ? { home: options.home } : {}
+      });
+      if (nativePath === void 0 && options.host !== "codex") {
+        stagingForCleanup = void 0;
         return;
-    }
-    const { landingPath, ordinal, sanitizedModel } = destination;
-    let lastError;
-    let copySuccess = false;
-    for (let attempt = 1; attempt <= 2; attempt++) {
+      }
+      if (options.host === "grok-build") {
+        copyGrokDossier(nativePath, staging);
+      } else {
+        if (nativePath === void 0) {
+          throw new Error(`Native session file missing for ${options.host} session ${options.sessionId}`);
+        }
+        mkdirSync(dirname(landingPath), { recursive: true });
+        copyFileCloneOrFallback(nativePath, staging);
+      }
+      if (options.host === "grok-build") {
+        const previous = `${landingPath}.previous.${attemptToken}`;
+        const hadPrevious = existsSync(landingPath);
+        let parked = false;
+        let keepUniquePrevious = false;
+        let cleanupError;
+        let swapFailure;
+        let restoreError;
         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}`);
+          if (hadPrevious) {
+            renameSync(landingPath, previous);
+            parked = true;
+          }
+          try {
+            renameSync(staging, landingPath);
+          } catch (swapError) {
+            if (parked && existsSync(previous) && !existsSync(landingPath)) {
+              try {
+                renameSync(previous, landingPath);
+              } catch (error) {
+                restoreError = error;
+                if (existsSync(previous) && !existsSync(landingPath)) {
+                  keepUniquePrevious = true;
                 }
-                mkdirSync(dirname(landingPath), { recursive: true });
-                copyFileCloneOrFallback(nativePath, landingPath);
+              }
+            }
+            swapFailure = swapError;
+          }
+        } finally {
+          if (parked && existsSync(previous) && !keepUniquePrevious) {
+            try {
+              rmSync(previous, { recursive: true, force: true });
+            } catch (error) {
+              cleanupError = error;
             }
-            copySuccess = true;
+          }
+        }
+        if (swapFailure !== void 0) {
+          lastError = combineCopyFailureCauses(
+            swapFailure,
+            restoreError,
+            cleanupError,
+            cleanupError === void 0 ? void 0 : previous
+          );
+          if (restoreError !== void 0 || cleanupError !== void 0) {
+            break;
+          }
+          try {
+            rmSync(staging, { recursive: true, force: true });
+            stagingForCleanup = void 0;
+          } catch (stagingCleanupError) {
+            lastError = combineCopyFailureCauses(
+              swapFailure,
+              void 0,
+              stagingCleanupError,
+              staging
+            );
+            stagingForCleanup = void 0;
             break;
+          }
+          continue;
         }
-        catch (error) {
-            lastError = error;
+        if (cleanupError !== void 0) {
+          lastError = combineCopyFailureCauses(cleanupError, void 0, cleanupError, previous);
+          stagingForCleanup = void 0;
+          break;
         }
+      } else {
+        renameSync(staging, landingPath);
+      }
+      copySuccess = true;
+      stagingForCleanup = void 0;
+      break;
+    } catch (error) {
+      lastError = error;
+      try {
+        rmSync(staging, { recursive: true, force: true });
+        stagingForCleanup = void 0;
+      } catch (cleanupError) {
+        lastError = combineCopyFailureCauses(error, void 0, cleanupError, staging);
+        stagingForCleanup = void 0;
+        break;
+      }
     }
-    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: errorText(lastError),
-            },
-        });
+  }
+  if (copySuccess) {
+    report({ type: "native-session-copy", nativePath, landingPath, sessionId: options.sessionId });
+  } else {
+    if (stagingForCleanup !== void 0) {
+      try {
+        rmSync(stagingForCleanup, { recursive: true, force: true });
+      } catch (cleanupError) {
+        lastError = combineCopyFailureCauses(lastError, void 0, cleanupError, stagingForCleanup);
+      }
     }
+    report({
+      type: "native-session-warning",
+      nativePath,
+      landingPath,
+      sessionId: options.sessionId,
+      error: errorText(lastError)
+    });
+  }
+}
+function combineCopyFailureCauses(primary, restoreError, cleanupError, residualPath) {
+  const errors = [primary];
+  const parts = [errorText(primary)];
+  if (restoreError !== void 0) {
+    errors.push(restoreError);
+    parts.push(`restore failed: ${errorText(restoreError)}`);
+  }
+  if (cleanupError !== void 0) {
+    if (cleanupError !== primary) errors.push(cleanupError);
+    parts.push(
+      residualPath === void 0 ? `cleanup failed: ${errorText(cleanupError)}` : `cleanup failed: ${errorText(cleanupError)} (residual: ${residualPath})`
+    );
+  }
+  if (errors.length === 1 && parts.length === 1) return primary;
+  return new AggregateError(errors, parts.join("; "), { cause: primary });
 }
+export {
+  HOST_SESSION_RECORD_KIND,
+  copyAndRecordHostDossier,
+  recordNativeSessionPointer,
+  resolveHostDossierLandingPath,
+  resolveNativeSessionPath,
+  sanitizeClaudeCwd,
+  sitianReportSafe
+};