aiwcli 0.15.1 → 0.15.3

package/dist/templates/_shared/scripts/resolve-run.ts

@@ -52,7 +52,7 @@ if (!fs.existsSync(fullPath)) {
   process.exit(1);
 }
 
-const result = Bun.spawnSync(["bun", fullPath], {
+const result = Bun.spawnSync(["bun", fullPath, ...process.argv.slice(3)], {
   stdin: "inherit",
   stdout: "inherit",
   stderr: "inherit",

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

@@ -0,0 +1,70 @@
+# 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
+├── lib/
+│   └── codex-watcher.ts  ← Reusable watch/summarize library
+└── scripts/
+    └── launch-codex.ts   ← Single entry point (launch + optional watch)
+```
+
+## Script: launch-codex.ts
+
+**Usage:**
+```bash
+bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_shared/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/_shared/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/_shared/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, send it as startup prompt to Codex
+- `--file <path>` — read file contents and send as startup prompt
+- `<text...>` — join remaining args as inline prompt
+- `--model <alias|tier|id>` — Aliases: `spark` → `gpt-5.3-codex-spark`, `codex` → `gpt-5.3-codex`, `gpt` → `gpt-5.2`. Tiers: `fast`/`standard`/`smart` (resolved via `resolveModelForProvider()`). Or any full model ID.
+- `--sandbox <mode>` — `read-only`, `workspace-write`, or `danger-full-access`. Default is `danger-full-access`.
+- `--prompt <text>` — append extra instructions under `## Additional Instructions`.
+- `--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 (all from `_shared/lib-ts/`):**
+- `base/tmux-driver.ts` — pane launcher orchestration with cross-platform fallback
+- `base/pane-launcher.ts` + `base/launchers/*` — tmux / wt / window launchers
+- `base/cli-args.ts` — model/sandbox/yolo CLI arg generation
+- `base/sentinel-ipc.ts` — completion sentinel file lifecycle
+- `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. Spark transcript summary from session file
+  2. `codex exec resume <session_id>` summary
+  3. Transcript-line fallback
+  4. Static `Summary unavailable` message
+
+**Design decisions:**
+- Prompt is delivered at launch time (no tmux buffer paste/capture workflow)
+- Pane backend detection order: tmux (in-session) → Windows Terminal split pane → Windows new window → non-interactive exec fallback
+- `_shared` only — never imports from `_cc-native`
+- 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 }`
+- `summarizeViaSessionFileSpark(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/skills/codex/SKILL.md

@@ -0,0 +1,71 @@
+# /codex
+
+## Role
+
+You are the orchestrator. Each Codex launch spawns an implementation sub-agent. Delegate implementation work to Codex, then review results when summaries arrive.
+
+The script blocks until Codex exits and prints a session summary. Run with Bash `run_in_background: true` so you stay unblocked and receive the summary as a background task notification.
+
+## Command
+
+```
+bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_shared/skills/codex/scripts/launch-codex.ts [flags] <mode>
+```
+
+**Modes:** `plan` | `--file <path>` | `<inline text...>`
+
+**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.
+- `--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.
+
+## Delegation Patterns
+
+### One-shot
+
+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
+```
+
+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
+```
+
+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.
+
+### Ad-hoc
+
+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 \
+  "Fix the failing test in auth.ts"
+
+bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_shared/skills/codex/scripts/launch-codex.ts \
+  --file path/to/task-description.md
+```
+
+## Orchestrator Checklist
+
+- **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.
+- **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/skills/{prompt-codex/scripts/watch-codex.ts → codex/lib/codex-watcher.ts}

@@ -1,5 +1,3 @@
-#!/usr/bin/env bun
-
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
@@ -7,18 +5,26 @@ import * as 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";
 
-const POLL_INTERVAL_MS = 2000;
-const POLL_TIMEOUT_MS = 3000;
-const SUMMARY_TIMEOUT_SEC = 8;
-const RESUME_TIMEOUT_MS = 45000;
-const MAX_TRANSCRIPT_LINES = 220;
-const MAX_LINE_LENGTH = 500;
-const SUMMARY_UNAVAILABLE_MESSAGE = "Codex session completed. Summary unavailable.";
+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 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;
+}
 
-const TRANSCRIPT_SUMMARY_PROMPT = `Summarize this Codex session transcript excerpt.
+export const TRANSCRIPT_SUMMARY_PROMPT = `Summarize this Codex session transcript excerpt.
 Return 3-5 concise bullet points.
 Focus on:
 - what was accomplished
@@ -28,7 +34,7 @@ Do not ask follow-up questions.
 Do not request additional input.
 If information is partial, provide best-effort summary from available text.`;
 
-const RESUME_SUMMARY_PROMPT = `Summarize the previous Codex session in 3-5 concise bullet points.
+export const RESUME_SUMMARY_PROMPT = `Summarize the previous Codex session in 3-5 concise bullet points.
 Focus on:
 - what was accomplished
 - files changed
@@ -37,11 +43,11 @@ Do not ask follow-up questions.
 Do not request additional input.
 If the prior session was brief, still provide a best-effort summary.`;
 
-function sleep(ms: number): Promise<void> {
+export function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-function safeCleanup(filePath: string): void {
+export function safeCleanup(filePath: string): void {
   try {
     if (fs.existsSync(filePath)) fs.unlinkSync(filePath);
   } catch {
@@ -49,7 +55,7 @@ function safeCleanup(filePath: string): void {
   }
 }
 
-function readTextIfExists(filePath: string): string {
+export function readTextIfExists(filePath: string): string {
   try {
     if (!filePath || !fs.existsSync(filePath)) return "";
     return fs.readFileSync(filePath, "utf-8").trim();
@@ -58,7 +64,7 @@ function readTextIfExists(filePath: string): string {
   }
 }
 
-function normalizeText(text: string): string {
+export function normalizeText(text: string): string {
   return text
     .replace(/\r/g, "")
     .replace(/[\x00-\x08\x0B-\x1F\x7F]/g, "")
@@ -66,7 +72,7 @@ function normalizeText(text: string): string {
     .trim();
 }
 
-function getMessageContentText(content: unknown): string {
+export function getMessageContentText(content: unknown): string {
   if (!Array.isArray(content)) return "";
   return content
     .map((entry: any) => {
@@ -77,7 +83,7 @@ function getMessageContentText(content: unknown): string {
     .join("\n");
 }
 
-function collectTranscriptLines(sessionFile: string): string[] {
+export function collectTranscriptLines(sessionFile: string): string[] {
   if (!sessionFile || !fs.existsSync(sessionFile)) return [];
 
   const out: string[] = [];
@@ -126,7 +132,7 @@ function collectTranscriptLines(sessionFile: string): string[] {
   return out.slice(-MAX_TRANSCRIPT_LINES);
 }
 
-function looksLikeBadSummary(output: string): boolean {
+export function looksLikeBadSummary(output: string): boolean {
   const normalized = output.toLowerCase();
   return (
     normalized.includes("don't see") ||
@@ -136,14 +142,61 @@ function looksLikeBadSummary(output: string): boolean {
   );
 }
 
-async function waitForPaneClose(paneId: string): Promise<void> {
-  const tmux = getTmuxAvailability();
+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,
     });
@@ -156,11 +209,12 @@ async function waitForPaneClose(paneId: string): Promise<void> {
     const activePaneIds = result.stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
     if (!activePaneIds.includes(paneId)) return;
 
-    await sleep(POLL_INTERVAL_MS);
+    const remainingMs = deadline - Date.now();
+    await sleep(Math.max(0, Math.min(POLL_INTERVAL_MS, remainingMs)));
   }
 }
 
-function summarizeViaSessionFileSpark(sessionFile: string): string | null {
+export function summarizeViaSessionFileSpark(sessionFile: string): string | null {
   const transcriptLines = collectTranscriptLines(sessionFile);
   if (transcriptLines.length === 0) return null;
 
@@ -184,7 +238,7 @@ function summarizeViaSessionFileSpark(sessionFile: string): string | null {
   return null;
 }
 
-async function summarizeViaResume(sessionId: string): Promise<string | null> {
+export async function summarizeViaResume(sessionId: string): Promise<string | null> {
   const outputFile = path.join(os.tmpdir(), `codex-resume-summary-${Date.now()}-${process.pid}.txt`);
 
   const result = await execFileAsync(
@@ -211,47 +265,8 @@ async function summarizeViaResume(sessionId: string): Promise<string | null> {
   return null;
 }
 
-function summarizeFromSessionFileFallback(sessionFile: string): string | null {
+export function summarizeFromSessionFileFallback(sessionFile: string): string | null {
   const lines = collectTranscriptLines(sessionFile).slice(-12);
   if (lines.length === 0) return null;
   return `Codex session completed. Transcript fallback:\n- ${lines.join("\n- ")}`;
 }
-
-async function main(): Promise<void> {
-  const [paneId, sessionId, sessionFile] = process.argv.slice(2);
-
-  if (!paneId) {
-    console.log(SUMMARY_UNAVAILABLE_MESSAGE);
-    return;
-  }
-
-  await waitForPaneClose(paneId);
-
-  const transcriptSummary = summarizeViaSessionFileSpark(sessionFile ?? "");
-  if (transcriptSummary) {
-    console.log(transcriptSummary);
-    return;
-  }
-
-  if (sessionId) {
-    const resumeSummary = await summarizeViaResume(sessionId);
-    if (resumeSummary) {
-      console.log(resumeSummary);
-      return;
-    }
-  }
-
-  const fallback = summarizeFromSessionFileFallback(sessionFile ?? "");
-  if (fallback) {
-    console.log(fallback);
-    return;
-  }
-
-  console.log(SUMMARY_UNAVAILABLE_MESSAGE);
-}
-
-main().catch((error) => {
-  logWarn("codex-capture", `watch-codex failed: ${String(error)}`);
-  console.log(SUMMARY_UNAVAILABLE_MESSAGE);
-  process.exit(0);
-});

package/dist/templates/_shared/skills/{prompt-codex → codex}/scripts/launch-codex.ts

@@ -1,22 +1,20 @@
 #!/usr/bin/env bun
 /**
- * Launch Codex in a tmux pane and inject a prompt into its REPL.
+ * Launch Codex in a visible pane (tmux/wt/window) and pass the prompt at startup.
  *
  * Usage:
- *   bun launch-codex.ts [--model fast|standard|smart|<model-id>] [--sandbox read-only|workspace-write|danger-full-access] [--no-yolo] [--capture] [--context <id>] plan
- *   bun launch-codex.ts [--model fast|standard|smart|<model-id>] [--sandbox read-only|workspace-write|danger-full-access] [--no-yolo] [--capture] [--context <id>] --file <path>
- *   bun launch-codex.ts [--model fast|standard|smart|<model-id>] [--sandbox read-only|workspace-write|danger-full-access] [--no-yolo] [--capture] [--context <id>] <inline text...>
+ *   bun launch-codex.ts [--model fast|standard|smart|<model-id>] [--sandbox read-only|workspace-write|danger-full-access] [--no-yolo] [--no-watch] [--context <id>] [--prompt <text>] plan
+ *   bun launch-codex.ts [--model fast|standard|smart|<model-id>] [--sandbox read-only|workspace-write|danger-full-access] [--no-yolo] [--no-watch] [--context <id>] [--prompt <text>] --file <path>
+ *   bun launch-codex.ts [--model fast|standard|smart|<model-id>] [--sandbox read-only|workspace-write|danger-full-access] [--no-yolo] [--no-watch] [--context <id>] [--prompt <text>] <inline text...>
  */
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 
-import {
-  getTmuxAvailability,
-  launchDriverInTmuxOrFallback,
-} from "../../../lib-ts/base/tmux-driver.js";
+import { launchDriverInTmuxOrFallback } from "../../../lib-ts/base/tmux-driver.js";
+import { cleanupSentinelPath } from "../../../lib-ts/base/sentinel-ipc.js";
 import { getProjectRoot } from "../../../lib-ts/base/constants.js";
-import { resolveCodexModel, codexReplSpec, buildCliInvocation, isCodexSandbox, type CodexSandbox } from "../../../lib-ts/base/cli-args.js";
+import { resolveCodexModel, codexReplSpec, buildCliInvocation, isCodexSandbox, type CodexSandbox, type CliArgSpec } from "../../../lib-ts/base/cli-args.js";
 import { CODEX_MODELS } from "../../../lib-ts/base/models.js";
 import { logDebug, logWarn } from "../../../lib-ts/base/logger.js";
 import { displayPath } from "../../../lib-ts/base/utils.js";
@@ -179,16 +177,17 @@ function findLatestPlanByMtime(projectRoot: string): string | null {
 const rawArgs = process.argv.slice(2);
 
 if (rawArgs.length === 0) {
-  eprint("Usage: launch-codex.ts [--model <model>] [--sandbox <mode>] [--no-yolo] [--capture] [--context <id>] plan | --file <path> | <text...>");
+  eprint("Usage: launch-codex.ts [--model <model>] [--sandbox <mode>] [--no-yolo] [--no-watch] [--context <id>] [--prompt <text>] plan | --file <path> | <text...>");
   process.exit(1);
 }
 
-// Extract --model, --sandbox, and --context flags before mode dispatch
+// Extract flags before mode dispatch
 let modelFlag: string | undefined;
 let sandboxFlag: CodexSandbox | undefined;
 let contextFlag: string | undefined;
+let extraPrompt: string | undefined;
 let yolo = true;
-let capture = false;
+let watch = true;
 const args: string[] = [];
 
 for (let i = 0; i < rawArgs.length; i++) {
@@ -203,19 +202,24 @@ for (let i = 0; i < rawArgs.length; i++) {
     sandboxFlag = val;
   } else if (rawArgs[i] === "--context" && i + 1 < rawArgs.length) {
     contextFlag = rawArgs[++i];
+  } else if (rawArgs[i] === "--prompt" && i + 1 < rawArgs.length) {
+    extraPrompt = rawArgs[++i];
+  } else if (rawArgs[i] === "--prompt") {
+    eprint("Error: --prompt requires a text argument.");
+    process.exit(1);
   } else if (rawArgs[i] === "--yolo") {
     yolo = true;
   } else if (rawArgs[i] === "--no-yolo") {
     yolo = false;
-  } else if (rawArgs[i] === "--capture") {
-    capture = true;
+  } else if (rawArgs[i] === "--no-watch") {
+    watch = false;
   } else {
     args.push(rawArgs[i]);
   }
 }
 
 if (args.length === 0) {
-  eprint("Usage: launch-codex.ts [--model <model>] [--sandbox <mode>] [--no-yolo] [--capture] [--context <id>] plan | --file <path> | <text...>");
+  eprint("Usage: launch-codex.ts [--model <model>] [--sandbox <mode>] [--no-yolo] [--no-watch] [--context <id>] [--prompt <text>] plan | --file <path> | <text...>");
   process.exit(1);
 }
 
@@ -303,85 +307,126 @@ if (ctx && promptPath) {
   }
 }
 
-// ---------------------------------------------------------------------------
-// Pre-flight: tmux required
-// ---------------------------------------------------------------------------
-
-const tmux = getTmuxAvailability();
-if (!tmux.available) {
-  eprint(`Error: tmux is required for Codex REPL mode. ${tmux.reason ?? ""}`);
-  if (tempFile) try { fs.unlinkSync(tempFile); } catch { /* ignore */ }
-  process.exit(1);
+if (extraPrompt && promptPath) {
+  try {
+    const base = fs.readFileSync(promptPath, "utf-8");
+    const combined = `${base}\n\n---\n\n## Additional Instructions\n\n${extraPrompt}`;
+    const extraPromptPath = path.join(os.tmpdir(), `codex-extra-prompt-${Date.now()}.md`);
+    fs.writeFileSync(extraPromptPath, combined, "utf-8");
+    if (tempFile) {
+      try { fs.unlinkSync(tempFile); } catch { /* ignore */ }
+    }
+    promptPath = extraPromptPath;
+    tempFile = extraPromptPath;
+  } catch {
+    logWarn("codex-skill", "Extra prompt append failed, continuing without it");
+  }
 }
 
 // ---------------------------------------------------------------------------
-// Launch Codex REPL in tmux pane
+// Launch Codex
 // ---------------------------------------------------------------------------
 
-// Build args via centralized CLI builder
 const codexArgs = buildCliInvocation(codexReplSpec(resolvedModel, sandboxFlag, yolo)).args;
 if (yolo) console.log("Mode: YOLO (bypass approvals and sandbox)");
 if (sandboxFlag) console.log(`Sandbox: ${sandboxFlag}`);
 if (resolvedModel) console.log(`Model: ${resolvedModel}${modelFlag !== resolvedModel ? ` (from "${modelFlag}")` : ""}`);
 
-logDebug("codex-skill", `Launching: model=${resolvedModel ?? "default"}, sandbox=${sandboxFlag ?? "default"}, yolo=${yolo}, source=${args[0]}, bytes=${promptPath ? fs.statSync(promptPath).size : 0}`);
-const launchStartedAtMs = Date.now();
+logDebug("codex-skill", `Launching: model=${resolvedModel ?? "default"}, sandbox=${sandboxFlag ?? "default"}, yolo=${yolo}, extraPrompt=${!!extraPrompt}, source=${args[0]}, bytes=${promptPath ? fs.statSync(promptPath).size : 0}`);
 
+const launchStartedAtMs = Date.now();
 const result = await launchDriverInTmuxOrFallback({
   toolName: "codex",
   mode: "repl",
   args: codexArgs,
-  promptPath,
-  sendPromptInRepl: true,
+  splitFlag: "auto",
+  promptPath: promptPath ?? undefined,
   allowExecFallback: false,
 });
 
-// Cleanup temp file after injection
-if (tempFile) {
-  try { fs.unlinkSync(tempFile); } catch { /* ignore */ }
-}
-
 if (!result.launched) {
-  logWarn("codex-skill", `Launch failed: ${result.reason}`);
-  eprint(`Error: Failed to launch Codex. ${result.reason ?? ""}`);
-  process.exit(1);
-}
+  // Final fallback: non-interactive codex exec in current terminal.
+  eprint(`Note: Pane launch unavailable (${result.reason ?? "unknown"}). Using codex exec mode (non-interactive).`);
+
+  const execSpec: CliArgSpec = {
+    provider: "codex",
+    model: resolvedModel ?? CODEX_MODELS.codex,
+    mode: "structured",
+    sandbox: sandboxFlag ?? "danger-full-access",
+  };
+  const execInv = buildCliInvocation(execSpec);
+  const promptContent = promptPath ? fs.readFileSync(promptPath, "utf-8") : "";
+
+  if (tempFile) {
+    try { fs.unlinkSync(tempFile); } catch { /* ignore */ }
+  }
 
-// Log injection diagnostics
-const diag = result.sendDiagnostics;
-if (diag) {
-  if (diag.success) {
-    logDebug("codex-skill", `Injection OK: promptWait=${diag.promptWaitMs}ms, retrySent=${diag.retrySent}`);
-  } else {
-    logWarn("codex-skill", `Injection failed at ${diag.failedAt}: wait=${diag.promptWaitMs}ms, stderr=${diag.tmuxStderr ?? "none"}, paneTail=${diag.paneTailOnTimeout ?? "none"}`);
+  const { execFileAsync } = await import("../../../lib-ts/base/subprocess-utils.js");
+  const execResult = await execFileAsync(execInv.cliName, execInv.args, {
+    input: promptContent,
+    env: { ...process.env, ...execInv.env },
+    shell: process.platform === "win32",
+  });
+
+  if (execResult.stdout) console.log(execResult.stdout);
+  if (execResult.exitCode !== 0) {
+    eprint(`Codex exec exited with code ${execResult.exitCode}`);
+    if (execResult.stderr) eprint(execResult.stderr);
+    process.exit(1);
   }
+
+  console.log("Codex exec completed (non-interactive mode).");
+  process.exit(0);
 }
 
+if (tempFile) {
+  try { fs.unlinkSync(tempFile); } catch { /* ignore */ }
+}
+
+const backendLabel = result.backend === "tmux" ? "tmux pane" : (result.backend === "wt" ? "Windows Terminal pane" : "window");
 if (result.paneId) {
-  console.log(`Codex launched in tmux pane: ${result.paneId}`);
+  console.log(`Codex launched in ${backendLabel}: ${result.paneId}`);
 } else {
-  console.log("Codex launched in tmux pane.");
+  console.log(`Codex launched in ${backendLabel}.`);
 }
 
-if (capture && result.paneId) {
+if (watch && (result.paneId || result.sentinelPath)) {
   try {
+    const {
+      SUMMARY_UNAVAILABLE_MESSAGE,
+      summarizeFromSessionFileFallback,
+      summarizeViaResume,
+      summarizeViaSessionFileSpark,
+      waitForPaneClose,
+    } = await import("../lib/codex-watcher.js");
+
     const sessionInfo = await waitForCaptureSession(projectRoot, launchStartedAtMs);
-    if (sessionInfo) {
-      console.log(`CODEX_CAPTURE_PANE=${result.paneId}`);
-      console.log(`CODEX_CAPTURE_SESSION_ID=${sessionInfo.sessionId}`);
-      console.log(`CODEX_CAPTURE_SESSION_FILE=${sessionInfo.sessionFile}`);
-    } else {
-      logWarn(
-        "codex-skill",
-        `Capture session discovery failed for pane ${result.paneId} in ${SESSION_DISCOVERY_TIMEOUT_MS}ms`,
-      );
-    }
+    await waitForPaneClose({
+      backend: result.backend,
+      paneId: result.paneId,
+      sentinelPath: result.sentinelPath,
+    });
+
+    const sessionFile = sessionInfo?.sessionFile ?? "";
+    const sessionId = sessionInfo?.sessionId ?? "";
+    const summary = summarizeViaSessionFileSpark(sessionFile)
+      ?? (sessionId ? await summarizeViaResume(sessionId) : null)
+      ?? summarizeFromSessionFileFallback(sessionFile)
+      ?? SUMMARY_UNAVAILABLE_MESSAGE;
+
+    console.log("\n--- Codex Session Summary ---");
+    console.log(summary);
   } catch (error) {
-    logWarn("codex-skill", `Capture session discovery threw for ${result.paneId}: ${String(error)}`);
+    logWarn("codex-skill", `Watch flow failed for ${result.paneId ?? result.backend}: ${String(error)}`);
+    console.log("\n--- Codex Session Summary ---");
+    console.log("Codex session completed. Summary unavailable.");
+  } finally {
+    cleanupSentinelPath(result.sentinelPath);
   }
+} else {
+  cleanupSentinelPath(result.sentinelPath);
 }
 
 if (result.reason) {
-  // Partial success (e.g., launched but prompt injection failed)
   eprint(`Warning: ${result.reason}`);
 }