aiwcli 0.15.5 → 0.17.0

package/dist/templates/{_shared → core}/scripts/status_line.ts

@@ -12,7 +12,8 @@
 import { execFileSync } from "node:child_process";
 import * as fs from "node:fs";
 import { homedir } from "node:os";
-import * as path from "node:path";
+import path from "node:path";
+
 import type { ContextState } from "../lib-ts/types.js";
 
 // PAI infrastructure imports — graceful fallback when libs aren't available
@@ -25,7 +26,7 @@ let saveState: (id: string, state: ContextState) => void = () => {};
 let findLatestPlan: (contextId: string) => string | null = () => null;
 
 try {
-	const hookUtils = await import("../lib-ts/base/hook-utils.js");
+	const hookUtils = await import("../lib-ts/hooks/hook-utils.js");
 	CONTEXT_BASELINE_TOKENS = hookUtils.CONTEXT_BASELINE_TOKENS;
 } catch {
 	/* PAI hook-utils not available */
@@ -52,7 +53,7 @@ try {
 // Path setup
 // ---------------------------------------------------------------------------
 const SCRIPT_DIR = path.dirname(new URL(import.meta.url).pathname);
-// Resolve project root from script location (.aiwcli/_shared/scripts/) so paths
+// Resolve project root from script location (.aiwcli/_core/scripts/) so paths
 // work even when cwd has drifted via `cd` in a Bash tool call.
 const PROJECT_ROOT = path.resolve(SCRIPT_DIR, "..", "..", "..");
 const OUTPUT_DIR = path.join(PROJECT_ROOT, "_output");
@@ -213,19 +214,18 @@ function renderContextBar(width: number, pct: number): [string, string] {
 // Display width helper — accounts for wide Unicode and ANSI escapes
 // ---------------------------------------------------------------------------
 
-// biome-ignore lint/suspicious/noControlCharactersInRegex: ANSI escape stripping requires \x1b
-const ANSI_RE = /\x1b\[[0-9;]*m/g;
+const ANSI_RE = new RegExp(`${String.raw`\u001B`}\\[[0-9;]*m`, "g");
 
 function isWideChar(cp: number): boolean {
 	return (
-		cp === 0x26c1 || // ⛁ draughts man
-		cp === 0x23f1 || // ⏱ stopwatch
-		(cp >= 0x2600 && cp <= 0x26ff) || // misc symbols
-		(cp >= 0x2700 && cp <= 0x27bf) || // dingbats
-		(cp >= 0x1f300 && cp <= 0x1faff) || // emoji
-		(cp >= 0xfe00 && cp <= 0xfe0f) || // variation selectors
-		(cp >= 0x4e00 && cp <= 0x9fff) || // CJK
-		(cp >= 0x3000 && cp <= 0x303f) // CJK symbols
+		cp === 0x26_c1 || // ⛁ draughts man
+		cp === 0x23_f1 || // ⏱ stopwatch
+		(cp >= 0x26_00 && cp <= 0x26_ff) || // misc symbols
+		(cp >= 0x27_00 && cp <= 0x27_bf) || // dingbats
+		(cp >= 0x1_f3_00 && cp <= 0x1_fa_ff) || // emoji
+		(cp >= 0xfe_00 && cp <= 0xfe_0f) || // variation selectors
+		(cp >= 0x4e_00 && cp <= 0x9f_ff) || // CJK
+		(cp >= 0x30_00 && cp <= 0x30_3f) // CJK symbols
 	);
 }
 
@@ -401,10 +401,10 @@ interface GitStatus {
 
 function runGit(args: string[], cwd: string, timeout = 2000): string | null {
 	try {
-		const result = execFileSync("git", args, {
+		const result = execFileSync("git", ["--no-optional-locks", ...args], {
 			cwd,
 			timeout,
-			encoding: "utf-8",
+			encoding: "utf8",
 			stdio: ["pipe", "pipe", "pipe"],
 			windowsHide: true,
 		});
@@ -687,12 +687,15 @@ function renderContextManager(
 	// Note: termWidth not available here — caller truncates via main()
 	switch (mode) {
 		case "micro":
-		case "nano":
+		case "nano": {
 			return `${CTX_ACCENT}\u25C6${RESET} ${SLATE_400}${truncatedId}${RESET}${modeBadge}`;
-		case "mini":
+		}
+		case "mini": {
 			return `${CTX_ACCENT}\u25C6${RESET} ${SLATE_400}${truncatedId}${RESET}${modeBadge}${planPart}`;
-		default:
+		}
+		default: {
 			return `${CTX_ACCENT}\u25C6${RESET} ${CTX_SECONDARY}Context:${RESET} ${SLATE_300}${truncatedId}${RESET}${modeBadge}${planPart}`;
+		}
 	}
 }
 
@@ -715,7 +718,7 @@ interface StatuslineCache {
 function loadCache(): StatuslineCache {
 	try {
 		if (fs.existsSync(STATUSLINE_CACHE)) {
-			return JSON.parse(fs.readFileSync(STATUSLINE_CACHE, "utf-8"));
+			return JSON.parse(fs.readFileSync(STATUSLINE_CACHE, "utf8"));
 		}
 	} catch {
 		/* ignore */
@@ -726,7 +729,7 @@ function loadCache(): StatuslineCache {
 function saveCache(cache: StatuslineCache): void {
 	try {
 		fs.mkdirSync(path.dirname(STATUSLINE_CACHE), { recursive: true });
-		fs.writeFileSync(STATUSLINE_CACHE, JSON.stringify(cache, null, 2), "utf-8");
+		fs.writeFileSync(STATUSLINE_CACHE, JSON.stringify(cache, null, 2), "utf8");
 	} catch {
 		/* ignore */
 	}
@@ -810,7 +813,7 @@ function main(): void {
 	// Read JSON from stdin
 	let inputData: StatusLineInput;
 	try {
-		inputData = JSON.parse(fs.readFileSync(0, "utf-8")) as StatusLineInput;
+		inputData = JSON.parse(fs.readFileSync(0, "utf8")) as StatusLineInput;
 	} catch {
 		inputData = {};
 	}
@@ -898,3 +901,5 @@ function main(): void {
 }
 
 main();
+
+

package/dist/templates/core/skills/codex/CLAUDE.md

@@ -0,0 +1,83 @@
+# Codex Skill
+
+Launch Codex CLI in a visible pane (tmux on Unix, Windows Terminal/window fallback on native Windows) and pass the prompt at process start.
+
+## Directory Structure
+
+```
+codex/
+├── CLAUDE.md       ← This file
+├── SKILL.md        ← Skill metadata (user-invocable)
+├── lib/
+│   └── codex-watcher.ts  ← Reusable watch/summarize library
+└── scripts/
+    ├── launch-codex.ts   ← Single entry point (launch + optional watch)
+    └── watch-codex.ts    ← Standalone watch mode
+```
+
+## Script: launch-codex.ts
+
+> Note: This file documents template source paths (`.aiwcli/_core/...`). During installation, settings command paths are normalized to runtime `.aiwcli/_core/...`.
+
+**Usage:**
+```bash
+bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_core/skills/codex/scripts/launch-codex.ts [--model <tier|id>] [--sandbox <sandbox-mode>] [--prompt <text>] [--no-yolo] [--no-watch] [--context <id>] plan
+bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_core/skills/codex/scripts/launch-codex.ts [--model <tier|id>] [--sandbox <sandbox-mode>] [--prompt <text>] [--no-yolo] [--no-watch] [--context <id>] --file <path>
+bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_core/skills/codex/scripts/launch-codex.ts [--model <tier|id>] [--sandbox <sandbox-mode>] [--prompt <text>] [--no-yolo] [--no-watch] [--context <id>] <inline text...>
+```
+
+**Args:**
+- `plan` — discover active plan via context system, build a bootstrap startup prompt that includes the plan filepath (Codex reads that file directly)
+- `--file <path>` — build a bootstrap startup prompt that includes the file path (Codex reads that file directly)
+- `<text...>` — join remaining args as inline prompt
+- `--model <alias|tier|id>` — Aliases: `spark` → `gpt-5.3-codex-spark`, `codex` → `gpt-5.4`, `gpt` → `gpt-5.4`. Tiers: `fast`/`standard`/`smart` (resolved via `resolveModelForProvider()`). Or a full model ID.
+- `--sandbox <mode>` — `read-only`, `workspace-write`, or `danger-full-access`. Default is `danger-full-access`.
+- `--prompt <text>` — append extra instructions. In `plan` and `--file` modes, these are embedded into a bootstrap temp file alongside the target path.
+- `--task-id <id>` — Caller-provided task ID for direct summary file lookup. If omitted, auto-generated as `<timestamp>-<pid>`. Enables the caller to know the exact summary file path without reading background task stdout.
+- `--no-yolo` — Disable YOLO mode (`--dangerously-bypass-approvals-and-sandbox`).
+- `--no-watch` — Disable watch/summarize mode.
+
+**Plan discovery order:**
+1. `CLAUDE_SESSION_ID` env → `getContextBySessionId()` → `findLatestPlan(contextId)`
+2. Fallback: scan `_output/contexts/*/plans/*.md` by mtime
+
+**Dependencies:**
+- `runtime/aiw-cli.ts` — shells out to `aiw launch` for pane management (no direct tmux imports)
+- `runtime/cli-args.ts` — model/sandbox/yolo CLI arg generation
+- `context/*` — context lookup, formatting, plan discovery
+
+**Watch behavior (single entry point):**
+- Watch is enabled by default.
+- `launch-codex.ts` launches Codex, waits for completion (pane close or sentinel), and prints a summary.
+- Summary cascade:
+  1. Session-file summary (`summarizeViaSessionFile`): Codex CLI Spark primary, `fast` tier (Haiku) fallback
+  2. `codex exec resume <session_id>` summary (output file, then stdout/stderr parse fallback)
+  3. Transcript-line fallback
+  4. Static `Summary unavailable` message
+- Summary persistence:
+  - `persistSummary()` in `agent-launcher.ts` writes to `os.tmpdir()/codex-summary-<ts>-<id>.md` (unique per run)
+  - Also writes to well-known path: `$TMPDIR/aiw-agent-output/<session-key>/codex-<taskId>.md`
+  - Task ID is caller-provided via `--task-id` or auto-generated as `<timestamp>-<pid>`
+  - Caller can compute the exact path via `getWellKnownSummaryPath("codex", taskId)` — no discovery needed
+  - Multiple concurrent agents use different task IDs, so they don't clobber each other
+  - Session key resolution: tmux (`$TMUX`), psmux (`psmux display-message`), exec fallback (project-root hash)
+  - Task ID + summary path printed early (before agent runs) so even partial stdout capture is useful
+  - Best-effort: logs warning on failure, stdout output still proceeds
+
+**Design decisions:**
+- Prompt is delivered at launch time (no tmux buffer paste/capture workflow)
+- Pane backend detection delegated to `aiw launch` (tmux in-session only → inline exec fallback)
+- `core` source only — runtime execution resolves to `.aiwcli/_core`
+- Watch path is best-effort and does not change launch success semantics
+
+## Library: lib/codex-watcher.ts
+
+Reusable side-effect-free watch/summarize functions used by launch flow:
+- `waitForPaneClose(target, timeoutMs?)` where `target` can be tmux pane id or `{ backend, paneId, sentinelPath }`
+- `summarizeViaSessionFile(sessionFile)`
+- `summarizeViaResume(sessionId)`
+- `summarizeFromSessionFileFallback(sessionFile)`
+- `collectTranscriptLines(sessionFile)`
+
+Constants and helper utilities are exported for reuse and testing (`POLL_INTERVAL_MS`, `SUMMARY_UNAVAILABLE_MESSAGE`, `normalizeText`, `looksLikeBadSummary`, etc.).
+

package/dist/templates/{_shared → core}/skills/codex/SKILL.md

@@ -1,3 +1,9 @@
+---
+name: codex
+description: Delegate implementation to Codex sub-agents. USE WHEN codex OR send to codex OR codex implement OR hand off to codex OR launch codex OR run codex.
+user-invocable: true
+---
+
 # /codex
 
 ## Role
@@ -9,19 +15,31 @@ The script blocks until Codex exits and prints a session summary. Run with Bash
 ## Command
 
 ```
-bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_shared/skills/codex/scripts/launch-codex.ts [flags] <mode>
+bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_core/skills/codex/scripts/launch-codex.ts [flags] <mode>
 ```
 
 **Modes:** `plan` | `--file <path>` | `<inline text...>`
 
+`plan` and `--file` modes pass a filepath-first bootstrap prompt so Codex reads the file from disk instead of relying on a pasted full document.
+
 **Flags:**
 - `--context <id>` — Project orientation for the sub-agent. Pass when implementing a plan so Codex understands the project structure.
-- `--prompt <text>` — Scope the agent's work. Direct each instance to a specific plan section or task.
-- `--model <name>` — Aliases: `spark`, `codex`, `gpt`. Tiers: `fast`, `standard`, `smart`. Or any full model ID.
+- `--prompt <text>` — Add extra instructions. In `plan`/`--file` mode, this is embedded into the bootstrap temp file with the target path.
+- `--model <name>` — Aliases: `spark`, `codex`, `gpt`. Tiers: `fast`, `standard`, `smart`. Or unknown full model ID.
 - `--sandbox <mode>` — `read-only`, `workspace-write`, `danger-full-access`.
 - `--no-yolo` — Disable YOLO mode (on by default).
 - `--no-watch` — Fire-and-forget: exit immediately after launch, skip waiting for summary.
 
+## Retrieving Results
+
+The script prints a summary to stdout and writes it to a temp file.
+
+**Primary:** Check TaskOutput for the background task — the summary and file path are inline.
+
+**Fallback (if TaskOutput is empty):** Look for the `[summary_file:<path>]` line in the output. If found, read that file path directly. The temp file persists independently of Claude Code's background task capture.
+
+If neither is available, check `_output/hook-log.jsonl` for `codex-capture` or `codex-skill` entries for diagnostics.
+
 ## Delegation Patterns
 
 ### One-shot
@@ -29,24 +47,14 @@ bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_shared/skills/codex/scripts/launch-cod
 For small or tightly coupled plans. One sub-agent implements the whole plan.
 
 ```bash
-bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_shared/skills/codex/scripts/launch-codex.ts --context <ctx-id> plan
+bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_core/skills/codex/scripts/launch-codex.ts --context <ctx-id> plan
 ```
 
 Run with `run_in_background: true`. Wait for the summary. Review the changes.
 
 ### Parallel
 
-For plans with independent sections. Each sub-agent owns one section, scoped by `--prompt`.
-
-```bash
-# Sub-agent A — section 1
-bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_shared/skills/codex/scripts/launch-codex.ts \
-  --context <ctx-id> --prompt "Implement section 1: Extract watch logic into lib/codex-watcher.ts" plan
-
-# Sub-agent B — section 3
-bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_shared/skills/codex/scripts/launch-codex.ts \
-  --context <ctx-id> --prompt "Implement section 3: Update launch-codex.ts arg parsing" plan
-```
+For plans with independent sections, create small section-brief files and launch one sub-agent per brief with `--file`.
 
 Run each with `run_in_background: true`. Summaries arrive as separate background task notifications. When all complete, review for conflicts between agents, then verify with tests or import checks.
 
@@ -55,10 +63,10 @@ Run each with `run_in_background: true`. Summaries arrive as separate background
 For tasks outside a plan. Pass inline text or a file path.
 
 ```bash
-bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_shared/skills/codex/scripts/launch-codex.ts \
+bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_core/skills/codex/scripts/launch-codex.ts \
   "Fix the failing test in auth.ts"
 
-bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_shared/skills/codex/scripts/launch-codex.ts \
+bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_core/skills/codex/scripts/launch-codex.ts \
   --file path/to/task-description.md
 ```
 
@@ -67,5 +75,6 @@ bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_shared/skills/codex/scripts/launch-cod
 - **Delegate implementation.** If the work involves writing code and Codex can handle it, send it to Codex.
 - **Split independent sections** into parallel sub-agents for faster execution.
 - **Pass `--context`** when implementing a plan — Codex needs project orientation to make good decisions.
-- **Scope with `--prompt`** when running parallel agents — each sub-agent performs better when it knows exactly which section it owns.
+- **Scope parallel agents with separate `--file` briefs** so each sub-agent has an explicit task boundary.
 - **Review results** when summaries arrive. Check for merge conflicts between parallel agents, then verify with `tsc --noEmit`, tests, or manual inspection.
+

package/dist/templates/{_shared → core}/skills/codex/lib/codex-watcher.ts

@@ -1,29 +1,29 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
-import * as path from "node:path";
+import path from "node:path";
 
-import { inference } from "../../../lib-ts/base/inference.js";
-import { logDebug, logWarn } from "../../../lib-ts/base/logger.js";
-import { CODEX_MODELS } from "../../../lib-ts/base/models.js";
-import type { PaneBackend } from "../../../lib-ts/base/pane-launcher.js";
-import { execFileAsync } from "../../../lib-ts/base/subprocess-utils.js";
-import { getTmuxAvailability } from "../../../lib-ts/base/tmux-driver.js";
+import { inference } from "../../../lib-ts/runtime/inference.js";
+import { logWarn } from "../../../lib-ts/runtime/logger.js";
+import { CODEX_MODELS } from "../../../lib-ts/runtime/models.js";
+import { execFileAsync } from "../../../lib-ts/runtime/subprocess-utils.js";
+
+// Re-export shared symbols that consumers import from this module
+export {
+  type PaneWatchTarget,
+  looksLikeBadSummary,
+  persistSummary,
+  sleep,
+  waitForPaneClose,
+} from "../../../lib-ts/runtime/agent-launcher.js";
+
+import { looksLikeBadSummary } from "../../../lib-ts/runtime/agent-launcher.js";
 
-export const POLL_INTERVAL_MS = 2000;
-export const POLL_TIMEOUT_MS = 3000;
 export const SUMMARY_TIMEOUT_SEC = 8;
-export const RESUME_TIMEOUT_MS = 45000;
+export const RESUME_TIMEOUT_MS = 45_000;
 export const MAX_TRANSCRIPT_LINES = 220;
 export const MAX_LINE_LENGTH = 500;
-export const WAIT_TIMEOUT_MS_DEFAULT = 14_400_000;
 export const SUMMARY_UNAVAILABLE_MESSAGE = "Codex session completed. Summary unavailable.";
 
-export interface PaneWatchTarget {
-  backend?: PaneBackend;
-  paneId?: string;
-  sentinelPath?: string;
-}
-
 export const TRANSCRIPT_SUMMARY_PROMPT = `Summarize this Codex session transcript excerpt.
 Return 3-5 concise bullet points.
 Focus on:
@@ -43,10 +43,6 @@ Do not ask follow-up questions.
 Do not request additional input.
 If the prior session was brief, still provide a best-effort summary.`;
 
-export function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
 export function safeCleanup(filePath: string): void {
   try {
     if (fs.existsSync(filePath)) fs.unlinkSync(filePath);
@@ -58,7 +54,7 @@ export function safeCleanup(filePath: string): void {
 export function readTextIfExists(filePath: string): string {
   try {
     if (!filePath || !fs.existsSync(filePath)) return "";
-    return fs.readFileSync(filePath, "utf-8").trim();
+    return fs.readFileSync(filePath, "utf8").trim();
   } catch {
     return "";
   }
@@ -66,16 +62,16 @@ export function readTextIfExists(filePath: string): string {
 
 export function normalizeText(text: string): string {
   return text
-    .replace(/\r/g, "")
-    .replace(/[\x00-\x08\x0B-\x1F\x7F]/g, "")
-    .replace(/\s+/g, " ")
+    .replaceAll('\r', "")
+    .replaceAll(/\p{Cc}/gu, "")
+    .replaceAll(/\s+/g, " ")
     .trim();
 }
 
 export function getMessageContentText(content: unknown): string {
   if (!Array.isArray(content)) return "";
   return content
-    .map((entry: any) => {
+    .map((entry: unknown) => {
       if (!entry || typeof entry !== "object") return "";
       if (typeof entry.text !== "string") return "";
       return entry.text;
@@ -90,11 +86,11 @@ export function collectTranscriptLines(sessionFile: string): string[] {
   const seen = new Set<string>();
 
   try {
-    const raw = fs.readFileSync(sessionFile, "utf-8");
+    const raw = fs.readFileSync(sessionFile, "utf8");
     const lines = raw.split(/\r?\n/).filter((line) => line.trim().length > 0);
 
     for (const line of lines) {
-      let parsed: any;
+      let parsed: unknown;
       try {
         parsed = JSON.parse(line);
       } catch {
@@ -132,99 +128,32 @@ export function collectTranscriptLines(sessionFile: string): string[] {
   return out.slice(-MAX_TRANSCRIPT_LINES);
 }
 
-export function looksLikeBadSummary(output: string): boolean {
-  const normalized = output.toLowerCase();
-  return (
-    normalized.includes("don't see") ||
-    normalized.includes("no output") ||
-    normalized.includes("could you provide") ||
-    normalized.includes("paste")
-  );
-}
-
-async function waitForSentinelClose(sentinelPath: string, timeoutMs: number): Promise<void> {
-  const deadline = Date.now() + timeoutMs;
-  while (true) {
-    if (fs.existsSync(sentinelPath)) return;
-    if (Date.now() >= deadline) {
-      logDebug("codex-capture", `watch timeout reached waiting for sentinel ${sentinelPath}`);
-      return;
-    }
-
-    const remainingMs = deadline - Date.now();
-    await sleep(Math.max(0, Math.min(POLL_INTERVAL_MS, remainingMs)));
-  }
-}
-
-function normalizeWatchTarget(target: string | PaneWatchTarget): PaneWatchTarget {
-  if (typeof target === "string") {
-    return { backend: "tmux", paneId: target };
-  }
-  return target;
-}
-
-export async function waitForPaneClose(
-  target: string | PaneWatchTarget,
-  timeoutMs = WAIT_TIMEOUT_MS_DEFAULT,
-): Promise<void> {
-  const watch = normalizeWatchTarget(target);
-
-  if (watch.sentinelPath) {
-    await waitForSentinelClose(watch.sentinelPath, timeoutMs);
-    return;
-  }
-
-  const backend = watch.backend ?? "tmux";
-  const paneId = watch.paneId ?? "";
-
-  if (backend !== "tmux") {
-    logDebug("codex-capture", `No pane watcher for backend=${backend}; continuing without wait`);
-    return;
-  }
-
-  if (!paneId) return;
-
-  const tmux = getTmuxAvailability({ requireSessionEnv: false });
-  if (!tmux.available || !tmux.tmuxPath) {
-    logWarn("codex-capture", `tmux unavailable while watching pane ${paneId}: ${tmux.reason ?? "unknown reason"}`);
-    return;
-  }
-
-  const deadline = Date.now() + timeoutMs;
-  while (true) {
-    if (Date.now() >= deadline) {
-      logDebug("codex-capture", `watch timeout reached for pane ${paneId} after ${timeoutMs}ms`);
-      return;
-    }
-
-    const result = await execFileAsync(tmux.tmuxPath, ["list-panes", "-a", "-F", "#{pane_id}"], {
-      timeout: POLL_TIMEOUT_MS,
-    });
-
-    if (result.exitCode !== 0) {
-      logDebug("codex-capture", `list-panes failed; assuming pane closed (${result.stderr.trim() || "no stderr"})`);
-      return;
-    }
-
-    const activePaneIds = result.stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
-    if (!activePaneIds.includes(paneId)) return;
-
-    const remainingMs = deadline - Date.now();
-    await sleep(Math.max(0, Math.min(POLL_INTERVAL_MS, remainingMs)));
-  }
-}
-
-export function summarizeViaSessionFileSpark(sessionFile: string): string | null {
+export async function summarizeViaSessionFile(sessionFile: string): Promise<string | null> {
   const transcriptLines = collectTranscriptLines(sessionFile);
   if (transcriptLines.length === 0) return null;
 
   const transcript = transcriptLines.join("\n");
+  const fullPrompt = `${TRANSCRIPT_SUMMARY_PROMPT}\n\nSession transcript excerpt:\n\n${transcript}`;
+
+  const codexResult = await execFileAsync(
+    "codex",
+    ["exec", fullPrompt, "--model", CODEX_MODELS.spark, "--json"],
+    { timeout: SUMMARY_TIMEOUT_SEC * 1000 },
+  );
+  if (codexResult.exitCode === 0 && codexResult.stdout.trim()) {
+    const output = codexResult.stdout.trim();
+    if (!looksLikeBadSummary(output)) return output;
+  }
+  logWarn(
+    "codex-capture",
+    `Codex Spark transcript summary failed (exit=${codexResult.exitCode}), falling back to Haiku`,
+  );
+
   const result = inference(
     TRANSCRIPT_SUMMARY_PROMPT,
     `Session transcript excerpt:\n\n${transcript}`,
     "fast",
     SUMMARY_TIMEOUT_SEC,
-    { model: CODEX_MODELS.spark },
   );
 
   if (result.success && result.output && result.output.trim() && !looksLikeBadSummary(result.output)) {
@@ -238,6 +167,31 @@ export function summarizeViaSessionFileSpark(sessionFile: string): string | null
   return null;
 }
 
+export function extractResumeSummary(text: string): string {
+  if (!text) return "";
+
+  const normalized = text.replaceAll("\r", "");
+  const marker = /(?:^|\n)codex\n/.exec(normalized);
+  if (!marker) return "";
+
+  const lines = normalized.slice(marker.index + marker[0].length).split("\n");
+  const bullets: string[] = [];
+  let collecting = false;
+
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!collecting && line.length === 0) continue;
+    if (line.startsWith("- ")) {
+      bullets.push(line);
+      collecting = true;
+      continue;
+    }
+    if (collecting) break;
+  }
+
+  return bullets.length >= 2 ? bullets.join("\n") : "";
+}
+
 export async function summarizeViaResume(sessionId: string): Promise<string | null> {
   const outputFile = path.join(os.tmpdir(), `codex-resume-summary-${Date.now()}-${process.pid}.txt`);
 
@@ -261,7 +215,16 @@ export async function summarizeViaResume(sessionId: string): Promise<string | nu
   safeCleanup(outputFile);
 
   if (summary && !looksLikeBadSummary(summary)) return summary;
-  logWarn("codex-capture", `codex exec resume failed for ${sessionId}: exit=${result.exitCode}, stderr=${result.stderr.trim() || "none"}`);
+
+  const stdoutSummary = extractResumeSummary(result.stdout);
+  if (stdoutSummary && !looksLikeBadSummary(stdoutSummary)) return stdoutSummary;
+
+  const stderrSummary = extractResumeSummary(result.stderr);
+  if (stderrSummary && !looksLikeBadSummary(stderrSummary)) return stderrSummary;
+
+  const stderrTrimmed = result.stderr.trim();
+  const stderrPreview = stderrTrimmed.length > 200 ? `${stderrTrimmed.slice(0, 200)}...` : (stderrTrimmed || "none");
+  logWarn("codex-capture", `codex exec resume failed for ${sessionId}: exit=${result.exitCode}, stderr=${stderrPreview}`);
   return null;
 }
 
@@ -270,3 +233,6 @@ export function summarizeFromSessionFileFallback(sessionFile: string): string |
   if (lines.length === 0) return null;
   return `Codex session completed. Transcript fallback:\n- ${lines.join("\n- ")}`;
 }
+
+
+