aiwcli 0.14.0 → 0.15.1

package/dist/templates/_shared/.claude/skills/codex/prompt.md

@@ -2,9 +2,29 @@
 
 | Command | Description |
 |---|---|
-| `bun launch-codex.ts [--model fast|standard|smart|<model-id>] [--sandbox read-only|disabled] plan` | Launch Codex REPL with active plan. |
-| `bun launch-codex.ts [--model fast|standard|smart|<model-id>] [--sandbox read-only|disabled] --file <path>` | Launch Codex REPL with file contents. |
-| `bun launch-codex.ts [--model fast|standard|smart|<model-id>] [--sandbox read-only|disabled] <inline text...>` | Launch Codex REPL with inline prompt. |
+| `bun launch-codex.ts [--model fast|standard|smart|<model-id>] [--sandbox read-only|workspace-write|danger-full-access] [--no-yolo] [--capture] plan` | Launch Codex REPL with active plan. |
+| `bun launch-codex.ts [--model fast|standard|smart|<model-id>] [--sandbox read-only|workspace-write|danger-full-access] [--no-yolo] [--capture] --file <path>` | Launch Codex REPL with file contents. |
+| `bun launch-codex.ts [--model fast|standard|smart|<model-id>] [--sandbox read-only|workspace-write|danger-full-access] [--no-yolo] [--capture] <inline text...>` | Launch Codex REPL with inline prompt. |
 
-- `--model`: model tier (`fast`/`standard`/`smart`) resolves to `gpt-5.3-codex-spark` / `gpt-5.3-codex-think`, or any explicit Codex model id.
-- `--sandbox`: `read-only` or `disabled` (default). `read-only` restricts file writes; `disabled` allows writes.
+- `--model`: model tier (`fast`/`standard`/`smart`) resolves to `gpt-5.3-codex-spark` / `gpt-5.3-codex`, or any explicit Codex model id. Aliases: `spark`, `codex`, `gpt`.
+- `--sandbox`: `read-only`, `workspace-write`, or `danger-full-access`. Default is `danger-full-access` for implementation handoffs.
+- YOLO mode is **on by default** — bypasses all approvals and sandbox (`--dangerously-bypass-approvals-and-sandbox`). Use `--no-yolo` to disable.
+- `--capture`: best-effort session capture. If setup succeeds, launch output includes:
+  - `CODEX_CAPTURE_PANE=<pane_id>`
+  - `CODEX_CAPTURE_SESSION_ID=<session_id>`
+  - `CODEX_CAPTURE_SESSION_FILE=<path>`
+
+If launch output includes `CODEX_CAPTURE_PANE` and `CODEX_CAPTURE_SESSION_ID`:
+
+1. Parse pane/session metadata from stdout.
+2. Start a background watcher:
+```bash
+bun .aiwcli/_shared/skills/prompt-codex/scripts/watch-codex.ts <pane_id> <session_id> <session_file>
+```
+Use `Bash` with `run_in_background: true`.
+3. Tell the user: `Codex is running in the tmux pane. I'll receive a summary when you exit.`
+4. Continue with other work; the background task output will arrive as a notification.
+
+Watcher behavior:
+- Primary: summarize from `CODEX_CAPTURE_SESSION_FILE` with Spark.
+- Fallback: use `codex exec resume <session_id>` if transcript summarization fails.

package/dist/templates/_shared/lib-ts/agent-exec/index.ts

@@ -2,3 +2,5 @@ export { BaseCliAgent, type AgentExecutionConfig } from "./base-agent.js";
 export type { ExecutionBackend, ExecutionRequest, ExecutionResult, AgentDebugLogger } from "./execution-backend.js";
 export { HeadlessBackend } from "./backends/headless.js";
 export { TmuxBackend } from "./backends/tmux.js";
+export { parseJsonObjectMaybe, parseStructuredOutput } from "./structured-output.js";
+export type { StructuredOutputParseOptions } from "./structured-output.js";

package/dist/templates/_shared/lib-ts/agent-exec/structured-output.ts

@@ -0,0 +1,166 @@
+/**
+ * Shared structured output parsing utilities for CLI-based agents.
+ * Supports Claude/Codex-style envelopes and heuristic JSON extraction.
+ */
+
+import { logDebug, logError, logWarn } from "../base/logger.js";
+
+export interface StructuredOutputParseOptions {
+  requireFields?: string[];
+  loggerTag?: string;
+}
+
+const DEFAULT_LOG_TAG = "structured_output";
+
+function getTag(options?: StructuredOutputParseOptions): string {
+  return options?.loggerTag ?? DEFAULT_LOG_TAG;
+}
+
+function validateRequiredFields(
+  obj: Record<string, unknown>,
+  parseMethod: "strict" | "heuristic",
+  options?: StructuredOutputParseOptions,
+): Record<string, unknown> | null {
+  const required = options?.requireFields;
+  if (!required || required.length === 0) return obj;
+
+  const missing = required.filter((field) => !(field in obj) || obj[field] === undefined || obj[field] === null);
+  if (missing.length === 0) return obj;
+
+  const tag = getTag(options);
+  logWarn(tag, `Parsed JSON (${parseMethod}) missing required fields: ${JSON.stringify(missing)}`);
+  logDebug(tag, `Parsed keys: ${JSON.stringify(Object.keys(obj))}`);
+
+  // Heuristic extraction often grabs the wrong JSON blob. Reject in that case.
+  if (parseMethod === "heuristic") {
+    return null;
+  }
+  return obj;
+}
+
+/**
+ * Parse a JSON object from text using strict parse first, then heuristic
+ * extraction of the first object-like block.
+ */
+export function parseJsonObjectMaybe(
+  text: string,
+  options?: StructuredOutputParseOptions,
+): Record<string, unknown> | null {
+  const tag = getTag(options);
+  const trimmed = text.trim();
+  if (!trimmed) return null;
+
+  // Strict parse first.
+  try {
+    const parsed: unknown = JSON.parse(trimmed);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return validateRequiredFields(parsed as Record<string, unknown>, "strict", options);
+    }
+  } catch {
+    // Fall through to heuristic extraction.
+  }
+
+  // Heuristic parse: extract the first object-like block.
+  const start = trimmed.indexOf("{");
+  const end = trimmed.lastIndexOf("}");
+  if (start === -1 || end === -1 || end <= start) return null;
+
+  const candidate = trimmed.slice(start, end + 1);
+  try {
+    const parsed: unknown = JSON.parse(candidate);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      logDebug(tag, `Used heuristic JSON extraction (chars ${start}-${end})`);
+      return validateRequiredFields(parsed as Record<string, unknown>, "heuristic", options);
+    }
+  } catch {
+    logDebug(tag, `Heuristic JSON extraction failed (chars ${start}-${end})`);
+  }
+
+  return null;
+}
+
+function parseAssistantEnvelope(
+  envelope: Record<string, unknown>,
+  options?: StructuredOutputParseOptions,
+): Record<string, unknown> | null {
+  const tag = getTag(options);
+  const message = envelope.message;
+  if (!message || typeof message !== "object") return null;
+
+  const content = (message as Record<string, unknown>).content;
+  if (!Array.isArray(content)) return null;
+
+  for (const item of content) {
+    if (!item || typeof item !== "object") continue;
+    const toolUse = item as Record<string, unknown>;
+    if (toolUse.name !== "StructuredOutput") continue;
+    if (toolUse.input && typeof toolUse.input === "object" && !Array.isArray(toolUse.input)) {
+      logDebug(tag, "Found StructuredOutput in assistant envelope");
+      return toolUse.input as Record<string, unknown>;
+    }
+  }
+  return null;
+}
+
+/**
+ * Parse structured output across known CLI envelope formats.
+ * Falls back to generic JSON extraction when no recognized envelope exists.
+ */
+export function parseStructuredOutput(
+  raw: string,
+  options?: StructuredOutputParseOptions,
+): Record<string, unknown> | null {
+  const tag = getTag(options);
+
+  try {
+    const parsed: unknown = JSON.parse(raw);
+
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      const obj = parsed as Record<string, unknown>;
+
+      if (obj.structured_output && typeof obj.structured_output === "object" && !Array.isArray(obj.structured_output)) {
+        logDebug(tag, "Found structured_output in root object");
+        return validateRequiredFields(obj.structured_output as Record<string, unknown>, "strict", options);
+      }
+
+      const assistantResult = parseAssistantEnvelope(obj, options);
+      if (assistantResult) return assistantResult;
+
+      // Session result envelope (no structured output tool call).
+      if (obj.type === "result" || ("duration_ms" in obj && "session_id" in obj)) {
+        if (obj.is_error === true || (Array.isArray(obj.errors) && obj.errors.length > 0)) {
+          logWarn(tag, `CLI returned error envelope: ${JSON.stringify(obj.errors ?? "is_error=true")}`);
+          return null;
+        }
+
+        if (typeof obj.result === "string" && obj.result.trim().length > 0) {
+          logDebug(tag, "Found text result in session envelope, attempting JSON extraction");
+          const extracted = parseJsonObjectMaybe(obj.result, options);
+          if (extracted) return extracted;
+          logWarn(tag, "Session envelope result contained no extractable JSON object");
+        }
+        return null;
+      }
+    } else if (Array.isArray(parsed)) {
+      for (let i = 0; i < parsed.length; i++) {
+        const event = parsed[i];
+        if (!event || typeof event !== "object") continue;
+        const eventObj = event as Record<string, unknown>;
+        const assistantResult = parseAssistantEnvelope(eventObj, options);
+        if (assistantResult) {
+          logDebug(tag, `Found StructuredOutput in event[${i}]`);
+          return assistantResult;
+        }
+      }
+    }
+  } catch (error: unknown) {
+    if (error instanceof SyntaxError) {
+      logWarn(tag, `JSON decode error: ${error.message}`);
+    } else {
+      logError(tag, `Unexpected parse error: ${error}`);
+    }
+  }
+
+  logDebug(tag, "No structured envelope found, falling back to generic JSON extraction");
+  return parseJsonObjectMaybe(raw, options);
+}

package/dist/templates/_shared/lib-ts/base/cli-args.ts

@@ -44,6 +44,7 @@ export interface CodexReplSpec {
   mode: "repl";
   model?: string | ModelTier;
   sandbox?: CodexSandbox;
+  yolo?: boolean;
   extraArgs?: string[];
 }
 
@@ -203,6 +204,7 @@ function buildCodexReplInvocation(
   env: Record<string, string | undefined>,
 ): CliInvocation {
   const args: string[] = [];
+  if (spec.yolo) args.push("--dangerously-bypass-approvals-and-sandbox");
   if (spec.sandbox) args.push("--sandbox", spec.sandbox);
   if (model) args.push("--model", model);
   if (spec.extraArgs) args.push(...spec.extraArgs);
@@ -263,12 +265,14 @@ export function reviewSpec(
 export function codexReplSpec(
   model?: string,
   sandbox?: CodexSandbox,
+  yolo?: boolean,
 ): CodexReplSpec {
   return {
     provider: "codex",
     mode: "repl",
     model,
     sandbox,
+    yolo,
   };
 }
 

package/dist/templates/_shared/lib-ts/base/state-io.ts

@@ -16,7 +16,7 @@ import type { ContextState, Mode } from "../types.js";
 const MODE_MIGRATION: Record<string, Mode> = {
   none: "idle",
   planning: "idle",
-  pending_implementation: "has_plan",
+  pending_implementation: "has_staged_work",
   implementing: "active",
 };
 

package/dist/templates/_shared/lib-ts/base/subprocess-utils.ts

@@ -4,7 +4,7 @@
  */
 
 import { execSync, execFile } from "node:child_process";
-import type { ChildProcess } from "node:child_process";
+import type { ChildProcess, ExecSyncOptionsWithStringEncoding } from "node:child_process";
 
 // ─── Child Process Cleanup ─────────────────────────────────────────────────
 //
@@ -68,7 +68,7 @@ export function isInternalCall(): boolean {
  * claude instances can run without being blocked.
  */
 export function getInternalSubprocessEnv(): Record<string, string | undefined> {
-  const env = {
+  const env: Record<string, string | undefined> = {
     ...process.env,
     AIWCLI_INTERNAL_CALL: "true",
   };
@@ -87,7 +87,8 @@ export function getInternalSubprocessEnv(): Record<string, string | undefined> {
 export function findExecutable(name: string): string | null {
   try {
     const cmd = process.platform === "win32" ? `where ${name}` : `which ${name}`;
-    const lines = execSync(cmd, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], shell: true })
+    // shell: true is valid at runtime but Node's TS types restrict it to string for this overload
+    const lines = execSync(cmd, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], shell: true } as unknown as ExecSyncOptionsWithStringEncoding)
       .trim()
       .split(/\r?\n/)
       .map((l) => l.trim())

package/dist/templates/_shared/lib-ts/context/context-store.ts

@@ -139,9 +139,12 @@ function migrateContextJson(contextId: string, projectRoot?: string): ContextSta
       plan_signature: null,
       plan_id: null,
       plan_anchors: [],
+      plan_hash_consumed: null,
       plan_consumed: false,
       handoff_path: inFlight.handoff_path ?? null,
       handoff_consumed: false,
+      work_consumed: false,
+      next_artifact_type: null,
       session_ids: sessionIds,
       last_session: null,
       tasks: [],

package/dist/templates/_shared/scripts/status_line.ts

@@ -13,14 +13,15 @@ import { execFileSync } from "node:child_process";
 import * as fs from "node:fs";
 import { homedir } from "node:os";
 import * as path from "node:path";
+import type { ContextState } from "../lib-ts/types.js";
 
 // PAI infrastructure imports — graceful fallback when libs aren't available
 let CONTEXT_BASELINE_TOKENS = 22_600;
-let getContextBySessionId: (id: string) => Record<string, unknown> | null =
+let getContextBySessionId: (id: string, root?: string) => ContextState | null =
 	() => null;
-let getContext: (id: string) => Record<string, unknown> | null = () => null;
-let loadState: (id: string) => Record<string, unknown> | null = () => null;
-let saveState: (id: string, state: unknown) => void = () => {};
+let getContext: (id: string, root?: string) => ContextState | null = () => null;
+let loadState: (id: string, root?: string) => ContextState | null = () => null;
+let saveState: (id: string, state: ContextState) => void = () => {};
 let findLatestPlan: (contextId: string) => string | null = () => null;
 
 try {
@@ -619,7 +620,7 @@ function findActivePlanFile(): string | null {
 function renderContextManager(
 	mode: string,
 	contextId: string,
-	contextState: Record<string, unknown> | null,
+	contextState: ContextState | null,
 ): string {
 	// Strip YYMMDD-HHMM- timestamp prefix from context ID for display
 	let displayId = contextId.replace(/^\d{6}-\d{4}-/, "");
@@ -649,7 +650,7 @@ function renderContextManager(
 	if (isPlanning) {
 		const label = mode === "nano" ? "Plan" : "Planning";
 		modeBadge = ` ${SLATE_600}\u2502${RESET} ${CTX_SECONDARY}Mode:${RESET} ${AMBER}${label}${RESET}`;
-	} else if (stateMode === "has_plan") {
+	} else if (stateMode === "has_staged_work") {
 		const label = mode === "nano" ? "Ready" : "Plan Ready";
 		modeBadge = ` ${SLATE_600}\u2502${RESET} ${CTX_SECONDARY}Mode:${RESET} ${EMERALD}${label}${RESET}`;
 	} else if (stateMode === "active") {
@@ -663,7 +664,7 @@ function renderContextManager(
 		planFilePath = activePlanFile;
 	} else if (statePlanPath) {
 		planFilePath = statePlanPath;
-	} else if (stateMode === "has_plan" || stateMode === "active") {
+	} else if (stateMode === "has_staged_work" || stateMode === "active") {
 		try {
 			planFilePath = findLatestPlan(contextId) ?? null;
 		} catch {
@@ -746,7 +747,7 @@ function resolveContextId(sessionId: string): string | null {
 		const context = getContextBySessionId(sessionId);
 		if (context) {
 			if (!cache.sessions) cache.sessions = {};
-			const ctxId = (context as Record<string, unknown>).id as string;
+			const ctxId = context.id;
 			cache.sessions[sessionId] = { context_id: ctxId };
 			saveCache(cache);
 			return ctxId;
@@ -759,9 +760,9 @@ function resolveContextId(sessionId: string): string | null {
 	return null;
 }
 
-function loadContextState(contextId: string): Record<string, unknown> | null {
+function loadContextState(contextId: string): ContextState | null {
 	try {
-		return loadState(contextId) as Record<string, unknown> | null;
+		return loadState(contextId);
 	} catch {
 		return null;
 	}
@@ -772,12 +773,12 @@ function writeContextWindow(
 	contextWindowData: Record<string, unknown>,
 ): void {
 	try {
-		const state = getContext(contextId) as Record<string, unknown> | null;
+		const state = getContext(contextId);
 		if (state) {
-			if (!state.last_session) state.last_session = {};
-			state.last_session.context_remaining_pct =
+			if (!state.last_session) state.last_session = { session_id: undefined, saved_at: undefined, save_reason: undefined, transcript_path: undefined };
+			(state.last_session as Record<string, unknown>).context_remaining_pct =
 				contextWindowData.remaining_percentage;
-			saveState(contextId, state as unknown);
+			saveState(contextId, state);
 		}
 	} catch {
 		/* ignore */
@@ -788,11 +789,28 @@ function writeContextWindow(
 // Main
 // ---------------------------------------------------------------------------
 
+/** Shape of the JSON payload piped to status_line.ts via stdin */
+interface StatusLineInput {
+	session_id?: string;
+	model?: { display_name?: string };
+	workspace?: { project_dir?: string };
+	context_window?: {
+		current_usage?: {
+			cache_read_input_tokens?: number;
+			input_tokens?: number;
+			cache_creation_input_tokens?: number;
+			output_tokens?: number;
+		};
+		context_window_size?: number;
+		used_percentage?: number;
+	};
+}
+
 function main(): void {
 	// Read JSON from stdin
-	let inputData: Record<string, unknown>;
+	let inputData: StatusLineInput;
 	try {
-		inputData = JSON.parse(fs.readFileSync(0, "utf-8"));
+		inputData = JSON.parse(fs.readFileSync(0, "utf-8")) as StatusLineInput;
 	} catch {
 		inputData = {};
 	}
@@ -804,8 +822,7 @@ function main(): void {
 	// Extract input fields
 	const sessionId = inputData.session_id ?? "";
 	const modelName = inputData.model?.display_name ?? "unknown";
-	const workspace = inputData.workspace ?? {};
-	const currentDir: string = workspace.project_dir ?? process.cwd();
+	const currentDir: string = inputData.workspace?.project_dir ?? process.cwd();
 	const dirName = path.basename(currentDir);
 
 	// Context window data
@@ -824,7 +841,7 @@ function main(): void {
 	const contextUsed = totalInput + outputTokens + CONTEXT_BASELINE_TOKENS;
 
 	if (usedPct !== undefined && usedPct !== null) {
-		contextPct = Math.floor(usedPct);
+		contextPct = Math.floor(usedPct as number);
 	} else {
 		contextPct =
 			contextMax > 0 ? Math.floor((contextUsed * 100) / contextMax) : 0;

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

@@ -8,16 +8,18 @@ Launch Codex CLI in a tmux pane and inject a prompt into its REPL.
 prompt-codex/
 ├── CLAUDE.md       ← This file
 └── scripts/
-    └── launch-codex.ts  ← CLI entry point
+    ├── launch-codex.ts  ← CLI entry point
+    └── watch-codex.ts   ← Capture watcher and summarizer
 ```
 
 ## Script: launch-codex.ts
 
 **Usage:**
 ```bash
-bun .aiwcli/_shared/skills/prompt-codex/scripts/launch-codex.ts [--model <tier|id>] [--sandbox <sandbox-mode>] plan
-bun .aiwcli/_shared/skills/prompt-codex/scripts/launch-codex.ts [--model <tier|id>] [--sandbox <sandbox-mode>] --file <path>
-bun .aiwcli/_shared/skills/prompt-codex/scripts/launch-codex.ts [--model <tier|id>] [--sandbox <sandbox-mode>] <inline text...>
+bun .aiwcli/_shared/skills/prompt-codex/scripts/launch-codex.ts [--model <tier|id>] [--sandbox <sandbox-mode>] [--full-auto] plan
+bun .aiwcli/_shared/skills/prompt-codex/scripts/launch-codex.ts [--model <tier|id>] [--sandbox <sandbox-mode>] [--full-auto] --file <path>
+bun .aiwcli/_shared/skills/prompt-codex/scripts/launch-codex.ts [--model <tier|id>] [--sandbox <sandbox-mode>] [--full-auto] <inline text...>
+bun .aiwcli/_shared/skills/prompt-codex/scripts/launch-codex.ts [--model <tier|id>] [--sandbox <sandbox-mode>] [--full-auto] [--capture] <mode>
 ```
 
 **Args:**
@@ -26,6 +28,12 @@ bun .aiwcli/_shared/skills/prompt-codex/scripts/launch-codex.ts [--model <tier|i
 - `<text...>` — join remaining args as inline prompt, write to temp file, inject
 - `--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. Aliases are checked first (local `CODEX_ALIASES` constant in `launch-codex.ts`), then tiers, then pass-through. Omitted = Codex default.
 - `--sandbox <mode>` — `read-only`, `workspace-write`, or `danger-full-access`. Default is `danger-full-access` for implementation handoffs.
+- `--no-yolo` — Disable YOLO mode (on by default). YOLO maps to Codex CLI's `--dangerously-bypass-approvals-and-sandbox`. Use `--no-yolo` to restore normal approval prompts.
+- `--capture` — Best-effort session capture. On success, prints:
+  - `CODEX_CAPTURE_PANE=<pane_id>`
+  - `CODEX_CAPTURE_SESSION_ID=<session_id>`
+  - `CODEX_CAPTURE_SESSION_FILE=<session_file>`
+  These are consumed by the skill prompt to run `watch-codex.ts` as a background task.
 
 **Plan discovery order:**
 1. `CLAUDE_SESSION_ID` env → `getContextBySessionId()` → `findLatestPlan(contextId)`
@@ -44,3 +52,20 @@ bun .aiwcli/_shared/skills/prompt-codex/scripts/launch-codex.ts [--model <tier|i
 - No exec fallback — REPL mode requires tmux
 - `_shared` only — never imports from `_cc-native`
 - Temp file cleanup after injection confirmed
+
+## Script: watch-codex.ts
+
+**Usage:**
+```bash
+bun .aiwcli/_shared/skills/prompt-codex/scripts/watch-codex.ts <pane_id> <session_id> <session_file>
+```
+
+**Behavior:**
+- Polls tmux until `<pane_id>` closes
+- Primary: parses `<session_file>` transcript and summarizes via Spark (`inference()` + `CODEX_MODELS.spark`)
+- Fallback: runs `codex exec resume <session_id>` if transcript summarization fails
+- Final fallback: emits concise transcript lines directly from `<session_file>`
+
+**Resilience policy:**
+- Capture path is best-effort and never blocks Codex launch
+- Watcher exits cleanly on poll/summary/parse failures with fallback text