aiwcli 0.15.5 → 0.15.7

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

@@ -1,29 +1,26 @@
 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,
+  persistSummary,
+  sleep,
+  waitForPaneClose,
+} 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 +40,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 +51,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 +59,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 +83,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 {
@@ -142,89 +135,32 @@ export function looksLikeBadSummary(output: string): boolean {
   );
 }
 
-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 +174,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 +222,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 +240,6 @@ export function summarizeFromSessionFileFallback(sessionFile: string): string |
   if (lines.length === 0) return null;
   return `Codex session completed. Transcript fallback:\n- ${lines.join("\n- ")}`;
 }
+
+
+

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

@@ -9,19 +9,22 @@
  */
 import * as fs from "node:fs";
 import * as os from "node:os";
-import * as path from "node:path";
-
-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, 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";
-import { getContextBySessionId, getContext } from "../../../lib-ts/context/context-store.js";
-import { buildExternalAgentContext } from "../../../lib-ts/context/context-formatter.js";
+import path from "node:path";
+
 import { findLatestPlan } from "../../../lib-ts/context/plan-manager.js";
-import type { ContextState } from "../../../lib-ts/types.js";
+import {
+  findLatestPlanByMtime,
+  resolveContextForLaunch,
+  sleep,
+  writeFileRefPromptFile,
+  writeInlinePromptFile,
+} from "../../../lib-ts/runtime/agent-launcher.js";
+import { aiwLaunch } from "../../../lib-ts/runtime/aiw-cli.js";
+import { resolveCodexModel, buildCliInvocation, isCodexSandbox, type CodexSandbox, type CliArgSpec } from "../../../lib-ts/runtime/cli-args.js";
+import { getProjectRoot } from "../../../lib-ts/runtime/constants.js";
+import { logDebug, logWarn } from "../../../lib-ts/runtime/logger.js";
+import { CODEX_MODELS } from "../../../lib-ts/runtime/models.js";
+import { displayPath } from "../../../lib-ts/runtime/utils.js";
 
 /** Codex-specific model abbreviations. Checked before tier resolution. */
 const CODEX_ALIASES: Record<string, string> = {
@@ -30,9 +33,9 @@ const CODEX_ALIASES: Record<string, string> = {
   gpt: CODEX_MODELS.gpt,
 };
 
-const SESSION_DISCOVERY_TIMEOUT_MS = 12000;
+const SESSION_DISCOVERY_TIMEOUT_MS = 12_000;
 const SESSION_DISCOVERY_POLL_MS = 250;
-const SESSION_MTIME_WINDOW_MS = 120000;
+const SESSION_MTIME_WINDOW_MS = 120_000;
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -42,8 +45,12 @@ function eprint(...args: unknown[]): void {
   process.stderr.write(args.map(String).join(" ") + "\n");
 }
 
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+function cleanupSentinel(sentinelPath: string | null | undefined): void {
+  if (!sentinelPath) return;
+  try {
+    const dir = path.dirname(sentinelPath);
+    fs.rmSync(dir, { recursive: true, force: true });
+  } catch { /* best-effort */ }
 }
 
 function collectSessionJsonlFiles(rootDir: string): string[] {
@@ -83,17 +90,21 @@ function samePath(a: string, b: string): boolean {
   return left === right;
 }
 
-function readSessionMeta(sessionFile: string): { sessionId: string; cwd: string } | null {
+function readSessionMeta(sessionFile: string): { sessionId: string; cwd: string; startedAtMs: number } | null {
   try {
-    const raw = fs.readFileSync(sessionFile, "utf-8");
+    const raw = fs.readFileSync(sessionFile, "utf8");
     const firstLine = raw.split(/\r?\n/).find((line) => line.trim().length > 0);
     if (!firstLine) return null;
     const parsed = JSON.parse(firstLine);
     if (parsed?.type !== "session_meta") return null;
     const sessionId = parsed?.payload?.id;
     const cwd = parsed?.payload?.cwd;
+    const startedAt = parsed?.payload?.timestamp;
     if (typeof sessionId !== "string" || typeof cwd !== "string") return null;
-    return { sessionId, cwd };
+    const startedAtMs = typeof startedAt === "string"
+      ? (Date.parse(startedAt) || 0)
+      : 0;
+    return { sessionId, cwd, startedAtMs };
   } catch {
     return null;
   }
@@ -102,12 +113,14 @@ function readSessionMeta(sessionFile: string): { sessionId: string; cwd: string
 function findLatestSessionCandidate(
   projectRoot: string,
   launchStartedAtMs: number,
+  requireProjectCwd = true,
 ): { sessionId: string; sessionFile: string } | null {
   const sessionsRoot = path.join(os.homedir(), ".codex", "sessions");
   const files = collectSessionJsonlFiles(sessionsRoot);
   if (files.length === 0) return null;
 
   const candidates: Array<{ sessionId: string; sessionFile: string; mtimeMs: number }> = [];
+  const currentThreadId = process.env.CODEX_THREAD_ID ?? "";
   for (const sessionFile of files) {
     let mtimeMs = 0;
     try {
@@ -119,7 +132,9 @@ function findLatestSessionCandidate(
 
     const meta = readSessionMeta(sessionFile);
     if (!meta) continue;
-    if (!samePath(meta.cwd, projectRoot)) continue;
+    if (currentThreadId && meta.sessionId === currentThreadId) continue;
+    if (meta.startedAtMs > 0 && meta.startedAtMs < launchStartedAtMs - 1000) continue;
+    if (requireProjectCwd && !samePath(meta.cwd, projectRoot)) continue;
 
     candidates.push({ sessionId: meta.sessionId, sessionFile, mtimeMs });
   }
@@ -136,38 +151,12 @@ async function waitForCaptureSession(
 ): Promise<{ sessionId: string; sessionFile: string } | null> {
   const deadline = Date.now() + SESSION_DISCOVERY_TIMEOUT_MS;
   while (Date.now() < deadline) {
-    const candidate = findLatestSessionCandidate(projectRoot, launchStartedAtMs);
+    const candidate = findLatestSessionCandidate(projectRoot, launchStartedAtMs, true);
     if (candidate) return candidate;
     await sleep(SESSION_DISCOVERY_POLL_MS);
   }
-  return findLatestSessionCandidate(projectRoot, launchStartedAtMs);
-}
-
-/** Fallback plan discovery: scan all context plan dirs by mtime. */
-function findLatestPlanByMtime(projectRoot: string): string | null {
-  const contextsDir = path.join(projectRoot, "_output", "contexts");
-  if (!fs.existsSync(contextsDir)) return null;
-
-  let best: { path: string; mtime: number } | null = null;
-
-  for (const ctxEntry of fs.readdirSync(contextsDir)) {
-    if (ctxEntry.startsWith("_")) continue;
-    const plansDir = path.join(contextsDir, ctxEntry, "plans");
-    if (!fs.existsSync(plansDir)) continue;
-
-    for (const file of fs.readdirSync(plansDir)) {
-      if (!file.endsWith(".md")) continue;
-      const fullPath = path.join(plansDir, file);
-      try {
-        const mtime = fs.statSync(fullPath).mtimeMs;
-        if (!best || mtime > best.mtime) {
-          best = { path: fullPath, mtime };
-        }
-      } catch { /* skip unreadable */ }
-    }
-  }
-
-  return best?.path ?? null;
+  // Fallback: tolerate launcher cwd drift (common on Windows pane backends).
+  return findLatestSessionCandidate(projectRoot, launchStartedAtMs, false);
 }
 
 // ---------------------------------------------------------------------------
@@ -204,18 +193,32 @@ for (let i = 0; i < rawArgs.length; i++) {
     contextFlag = rawArgs[++i];
   } else if (rawArgs[i] === "--prompt" && i + 1 < rawArgs.length) {
     extraPrompt = rawArgs[++i];
-  } else if (rawArgs[i] === "--prompt") {
+  } else switch (rawArgs[i]) {
+ case "--no-watch": {
+    watch = false;
+  
+ break;
+ }
+ case "--no-yolo": {
+    yolo = false;
+  
+ break;
+ }
+ case "--prompt": {
     eprint("Error: --prompt requires a text argument.");
     process.exit(1);
-  } else if (rawArgs[i] === "--yolo") {
+  
+ break;
+ }
+ case "--yolo": {
     yolo = true;
-  } else if (rawArgs[i] === "--no-yolo") {
-    yolo = false;
-  } else if (rawArgs[i] === "--no-watch") {
-    watch = false;
-  } else {
+  
+ break;
+ }
+ default: {
     args.push(rawArgs[i]);
   }
+ }
 }
 
 if (args.length === 0) {
@@ -233,21 +236,9 @@ if (modelFlag) {
 }
 
 let promptPath: string | null = null;
-let tempFile: string | null = null;
 
 const projectRoot = getProjectRoot(process.cwd());
-
-// Context lookup — available for all modes (orientation header + plan discovery)
-// --context flag preferred (passed by skill caller); CLAUDE_SESSION_ID as fallback (hooks only)
-let ctx: ContextState | null = null;
-if (contextFlag) {
-  ctx = getContext(contextFlag, projectRoot) ?? null;
-} else {
-  const sessionId = process.env.CLAUDE_SESSION_ID;
-  if (sessionId) {
-    ctx = getContextBySessionId(sessionId, projectRoot) ?? null;
-  }
-}
+const ctx = resolveContextForLaunch(contextFlag, projectRoot);
 
 if (args[0] === "plan") {
   // Plan discovery: context system first, mtime fallback second
@@ -266,8 +257,15 @@ if (args[0] === "plan") {
     process.exit(1);
   }
 
-  promptPath = planPath;
   console.log(`Found plan: ${displayPath(planPath)}`);
+  promptPath = writeFileRefPromptFile({
+    fileReferencePath: path.resolve(planPath),
+    label: "plan",
+    extraPrompt,
+    ctx,
+    projectRoot,
+    tempFilePrefix: "codex",
+  });
 
 } else if (args[0] === "--file") {
   if (!args[1]) {
@@ -279,69 +277,48 @@ if (args[0] === "plan") {
     eprint(`Error: File not found: ${filePath}`);
     process.exit(1);
   }
-  promptPath = filePath;
+  promptPath = writeFileRefPromptFile({
+    fileReferencePath: filePath,
+    label: "file",
+    extraPrompt,
+    ctx,
+    projectRoot,
+    tempFilePrefix: "codex",
+  });
 
 } else {
-  // Inline text: join args, write to temp file
-  const text = args.join(" ");
-  tempFile = path.join(os.tmpdir(), `codex-prompt-${Date.now()}.md`);
-  fs.writeFileSync(tempFile, text, "utf-8");
-  promptPath = tempFile;
-}
-
-// Prepend context orientation if available — graceful degradation on failure
-if (ctx && promptPath) {
-  try {
-    const orientation = buildExternalAgentContext(ctx, projectRoot);
-    const original = fs.readFileSync(promptPath, "utf-8");
-    const combined = `${orientation}\n\n---\n\n${original}`;
-    const contextPromptPath = path.join(os.tmpdir(), `codex-ctx-prompt-${Date.now()}.md`);
-    fs.writeFileSync(contextPromptPath, combined, "utf-8");
-    if (tempFile) {
-      try { fs.unlinkSync(tempFile); } catch { /* ignore */ }
-    }
-    promptPath = contextPromptPath;
-    tempFile = contextPromptPath;
-  } catch {
-    logWarn("codex-skill", `Context orientation prepend failed for ${ctx.id}, continuing without header`);
-  }
-}
-
-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");
-  }
+  // Inline text: join args, write to temp file with context + extra prompt
+  promptPath = writeInlinePromptFile({
+    text: args.join(" "),
+    extraPrompt,
+    ctx,
+    projectRoot,
+    tempFilePrefix: "codex",
+  });
 }
 
 // ---------------------------------------------------------------------------
 // Launch Codex
 // ---------------------------------------------------------------------------
 
-const codexArgs = buildCliInvocation(codexReplSpec(resolvedModel, sandboxFlag, yolo)).args;
+const launchCwd = process.env.AIW_CALLER_CWD?.trim() || process.cwd();
 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}, extraPrompt=${!!extraPrompt}, source=${args[0]}, bytes=${promptPath ? fs.statSync(promptPath).size : 0}`);
+logDebug("codex-skill", `Launching: model=${resolvedModel ?? "default"}, sandbox=${sandboxFlag ?? "default"}, yolo=${yolo}, extraPrompt=${Boolean(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,
-  splitFlag: "auto",
+
+// Shell out to `aiw launch` instead of importing tmux modules directly.
+// This consolidates all pane-launching logic in the CLI binary.
+const result = await aiwLaunch({
+  codex: true,
+  wait: false,
+  json: true,
+  split: "auto",
   promptPath: promptPath ?? undefined,
-  allowExecFallback: false,
+  cwd: launchCwd,
 });
 
 if (!result.launched) {
@@ -355,13 +332,13 @@ if (!result.launched) {
     sandbox: sandboxFlag ?? "danger-full-access",
   };
   const execInv = buildCliInvocation(execSpec);
-  const promptContent = promptPath ? fs.readFileSync(promptPath, "utf-8") : "";
+  const promptContent = promptPath ? fs.readFileSync(promptPath, "utf8") : "";
 
-  if (tempFile) {
-    try { fs.unlinkSync(tempFile); } catch { /* ignore */ }
+  if (promptPath) {
+    try { fs.unlinkSync(promptPath); } catch { /* ignore */ }
   }
 
-  const { execFileAsync } = await import("../../../lib-ts/base/subprocess-utils.js");
+  const { execFileAsync } = await import("../../../lib-ts/runtime/subprocess-utils.js");
   const execResult = await execFileAsync(execInv.cliName, execInv.args, {
     input: promptContent,
     env: { ...process.env, ...execInv.env },
@@ -379,11 +356,7 @@ if (!result.launched) {
   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");
+const backendLabel = result.backend === "tmux" ? "tmux pane" : result.backend === "psmux" ? "psmux pane" : "window";
 if (result.paneId) {
   console.log(`Codex launched in ${backendLabel}: ${result.paneId}`);
 } else {
@@ -393,10 +366,11 @@ if (result.paneId) {
 if (watch && (result.paneId || result.sentinelPath)) {
   try {
     const {
+      persistSummary,
       SUMMARY_UNAVAILABLE_MESSAGE,
       summarizeFromSessionFileFallback,
       summarizeViaResume,
-      summarizeViaSessionFileSpark,
+      summarizeViaSessionFile,
       waitForPaneClose,
     } = await import("../lib/codex-watcher.js");
 
@@ -409,24 +383,36 @@ if (watch && (result.paneId || result.sentinelPath)) {
 
     const sessionFile = sessionInfo?.sessionFile ?? "";
     const sessionId = sessionInfo?.sessionId ?? "";
-    const summary = summarizeViaSessionFileSpark(sessionFile)
+    const summary = (await summarizeViaSessionFile(sessionFile))
       ?? (sessionId ? await summarizeViaResume(sessionId) : null)
       ?? summarizeFromSessionFileFallback(sessionFile)
       ?? SUMMARY_UNAVAILABLE_MESSAGE;
+    const summaryPath = persistSummary(summary, "codex", sessionId || undefined);
 
     console.log("\n--- Codex Session Summary ---");
     console.log(summary);
+    if (summaryPath) {
+      console.log(`\n[summary_file:${summaryPath}]`);
+    }
   } catch (error) {
-    logWarn("codex-skill", `Watch flow failed for ${result.paneId ?? result.backend}: ${String(error)}`);
+    logWarn("codex-skill", `Watch flow failed: ${String(error)}`);
+    const fallbackMsg = "Codex session completed. Summary unavailable (watch error).";
+    const { persistSummary: persistFallback } = await import("../lib/codex-watcher.js");
+    const fallbackPath = persistFallback(fallbackMsg, "codex");
     console.log("\n--- Codex Session Summary ---");
-    console.log("Codex session completed. Summary unavailable.");
+    console.log(fallbackMsg);
+    if (fallbackPath) {
+      console.log(`\n[summary_file:${fallbackPath}]`);
+    }
   } finally {
-    cleanupSentinelPath(result.sentinelPath);
+    cleanupSentinel(result.sentinelPath);
   }
 } else {
-  cleanupSentinelPath(result.sentinelPath);
+  cleanupSentinel(result.sentinelPath);
 }
 
 if (result.reason) {
   eprint(`Warning: ${result.reason}`);
 }
+
+