aiwcli 0.14.0 → 0.15.2

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

@@ -1,42 +1,35 @@
 ---
 name: codex
-description: Launch Codex CLI in a tmux pane. USE WHEN codex OR send to codex OR codex implement OR hand off to codex OR launch codex OR codex plan OR run 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 codex plan OR run codex.
 user-invocable: true
 ---
 
-# Codex CLI
+Read `.aiwcli/_shared/skills/codex/SKILL.md` for delegation patterns and examples.
 
-Launch Codex in a tmux split pane and optionally inject a prompt.
+## Role
 
-## Command
+You are the orchestrator. Codex instances are your implementation sub-agents. Decide what to delegate, how to split work, and review results when summaries arrive.
 
-`bun .aiwcli/_shared/skills/prompt-codex/scripts/launch-codex.ts [flags] <mode>`
+## Command
 
-**Modes:** `plan` (inject active plan) | `--file <path>` (inject file) | `<text...>` (inject inline text)
+```
+bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_shared/skills/codex/scripts/launch-codex.ts [flags] <mode>
+```
 
-**Flags:**
-- `--model <name>` — Model aliases: `spark`, `codex`, `gpt`. Tiers: `fast`, `standard`, `smart`. Or any full model ID.
-- `--sandbox <mode>` — `read-only`, `workspace-write`, `danger-full-access`. Default: Codex default.
-- `--context <id>` — Pass the active context ID so Codex receives project orientation (context folder, notes path). **Always pass this when an active context exists** (check the `Active Context:` system reminder for the ID).
+The script blocks until Codex exits and prints a summary — run with Bash `run_in_background: true` so you stay unblocked.
 
-## Model Reference
+**Modes:** `plan` | `--file <path>` | `<inline text...>`
 
-| Name | Resolves To |
-|------|-------------|
-| `spark` | `gpt-5.3-codex-spark` (fastest) |
-| `codex` | `gpt-5.3-codex` (default) |
-| `gpt` | `gpt-5.2` (non-Codex GPT) |
-| `fast` | `gpt-5.3-codex-spark` (tier) |
-| `standard` | `gpt-5.3-codex` (tier) |
-| `smart` | `gpt-5.3-codex` (tier) |
+**Key flags:**
+- `--context <id>` — Project orientation. Pass when implementing a plan.
+- `--prompt <text>` — Scope the agent's work to a specific plan section or task.
+- `--model <name>` — `spark`, `codex`, `gpt`, or tier: `fast`, `standard`, `smart`.
+- `--no-watch` — Fire-and-forget (skip waiting for summary).
 
-## Examples
+## Delegation Decision
 
-- `/codex --model spark --context <context-id> plan` — hand off active plan to Spark with context
-- `/codex --model codex --context <context-id> Refactor auth to use JWT` — inline prompt with context
-- `/codex --file ./spec.md` — inject file contents (no context)
+**One-shot:** Plan is small or tightly coupled → launch one Codex with `plan` mode. Wait for the summary, then review.
 
-## Requirements
+**Parallel:** Plan has independent sections → launch multiple Codex instances, each scoped with `--prompt` to its section. All share the same `--context`. Review when summaries arrive, check for conflicts.
 
-- Must be running inside tmux
-- `codex` CLI must be on PATH
+**Ad-hoc:** No plan, just a task → pass inline text (e.g., `"Fix the failing test in auth.ts"`).

package/dist/templates/_shared/.codex/workflows/codex.md

@@ -0,0 +1,11 @@
+# Codex Workflow
+
+Use Codex CLI handoff instructions from `.aiwcli/_shared/skills/codex/SKILL.md`.
+
+## Command
+
+`bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_shared/skills/codex/scripts/launch-codex.ts [flags] <mode>`
+
+**Modes:** `plan` | `--file <path>` | `<inline text...>`
+
+**Common flags:** `--model <name>`, `--sandbox <mode>`, `--context <id>`, `--prompt <text>`, `--no-yolo`, `--capture`

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/base/tmux-driver.ts

@@ -12,9 +12,11 @@
 import * as fs from "node:fs";
 
 import { execFileAsync, findExecutable } from "./subprocess-utils.js";
+import { findBestSplit, listPanes } from "./tmux-pane-placement.js";
 
 export type DriverMode = "exec" | "repl";
 export type TmuxSplitFlag = "-h" | "-v";
+export type TmuxSplitOption = TmuxSplitFlag | "auto";
 
 export interface DriverPreflightResult {
   available: boolean;
@@ -53,7 +55,7 @@ export interface LaunchDriverOptions {
   env?: Record<string, string>;
   promptPath?: string;
   sendPromptInRepl?: boolean;
-  splitFlag?: string;
+  splitFlag?: TmuxSplitOption;
   splitTarget?: string;
   autoClose?: boolean;
   holdPane?: boolean;
@@ -165,6 +167,54 @@ export function normalizeSplitFlag(value: string | undefined): TmuxSplitFlag {
   return value?.trim() === "-v" ? "-v" : "-h";
 }
 
+function splitFlagFromDimensions(width: number, height: number): TmuxSplitFlag {
+  return width >= height ? "-h" : "-v";
+}
+
+async function resolveSplitFlagForTargetPane(
+  tmuxPath: string,
+  splitTarget: string,
+): Promise<TmuxSplitFlag | null> {
+  const size = await execFileAsync(
+    tmuxPath,
+    ["display-message", "-p", "-t", splitTarget, "#{pane_width} #{pane_height}"],
+    { timeout: 3000 },
+  );
+  if (size.exitCode !== 0) return null;
+
+  const parts = size.stdout.trim().split(/\s+/);
+  if (parts.length < 2) return null;
+
+  const width = Number.parseInt(parts[0] ?? "", 10);
+  const height = Number.parseInt(parts[1] ?? "", 10);
+  if (!Number.isFinite(width) || !Number.isFinite(height)) return null;
+
+  return splitFlagFromDimensions(width, height);
+}
+
+async function resolveAutoSplit(
+  tmuxPath: string,
+  splitTarget?: string,
+): Promise<{ splitFlag: TmuxSplitFlag; splitTarget?: string }> {
+  const explicitTarget = splitTarget?.trim();
+  if (explicitTarget) {
+    const splitFlag = await resolveSplitFlagForTargetPane(tmuxPath, explicitTarget);
+    return {
+      splitFlag: splitFlag ?? "-h",
+      splitTarget: explicitTarget,
+    };
+  }
+
+  const panes = await listPanes(tmuxPath);
+  const placement = findBestSplit(panes);
+  if (!placement) return { splitFlag: "-h" };
+
+  return {
+    splitFlag: placement.splitFlag,
+    splitTarget: placement.targetPane,
+  };
+}
+
 export function isTruthy(value: string | undefined): boolean {
   if (!value) return false;
   const normalized = value.trim().toLowerCase();
@@ -287,8 +337,25 @@ export async function launchDriverInTmuxOrFallback(
 
   const tmux = getTmuxAvailability();
   if (tmux.available && tmux.tmuxPath) {
-    const splitFlag = normalizeSplitFlag(options.splitFlag);
-    const splitTarget = options.splitTarget?.trim();
+    const requestedSplitFlag = options.splitFlag;
+    const explicitSplitTarget = options.splitTarget?.trim();
+    let splitFlag: TmuxSplitFlag;
+    let splitTarget: string | undefined;
+
+    if (requestedSplitFlag === "auto") {
+      try {
+        const resolved = await resolveAutoSplit(tmux.tmuxPath, explicitSplitTarget);
+        splitFlag = resolved.splitFlag;
+        splitTarget = resolved.splitTarget;
+      } catch {
+        splitFlag = "-h";
+        splitTarget = explicitSplitTarget;
+      }
+    } else {
+      splitFlag = normalizeSplitFlag(requestedSplitFlag);
+      splitTarget = explicitSplitTarget;
+    }
+
     const baseCmd = buildToolCommand(toolPath, args, envVars, mode, options.promptPath);
     const holdMessage = options.holdMessage ?? "[aiwcli] Driver exited. Pane held open.";
     const paneBody = wrapPaneCommand(

package/dist/templates/_shared/lib-ts/base/tmux-pane-placement.ts

@@ -0,0 +1,70 @@
+import { execFileAsync } from "./subprocess-utils.js";
+
+export type TmuxSplitFlag = "-h" | "-v";
+
+export interface TmuxPaneInfo {
+  paneId: string;
+  width: number;
+  height: number;
+  active: boolean;
+}
+
+export interface PlacementResult {
+  targetPane: string;
+  splitFlag: TmuxSplitFlag;
+}
+
+const LIST_PANES_FORMAT = "#{pane_id} #{pane_width} #{pane_height} #{pane_active}";
+
+export async function listPanes(tmuxPath: string): Promise<TmuxPaneInfo[]> {
+  const result = await execFileAsync(tmuxPath, ["list-panes", "-F", LIST_PANES_FORMAT], {
+    timeout: 3000,
+  });
+  if (result.exitCode !== 0) return [];
+
+  const panes: TmuxPaneInfo[] = [];
+  for (const rawLine of result.stdout.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line) continue;
+
+    const parts = line.split(/\s+/);
+    if (parts.length < 4) continue;
+
+    const paneId = parts[0] ?? "";
+    const width = Number.parseInt(parts[1] ?? "", 10);
+    const height = Number.parseInt(parts[2] ?? "", 10);
+    const activeRaw = parts[3] ?? "";
+
+    if (!paneId || !Number.isFinite(width) || !Number.isFinite(height)) continue;
+    panes.push({
+      paneId,
+      width,
+      height,
+      active: activeRaw === "1",
+    });
+  }
+
+  return panes;
+}
+
+export function findBestSplit(panes: TmuxPaneInfo[]): PlacementResult | null {
+  if (panes.length === 0) return null;
+
+  let best = panes[0];
+  let bestArea = best.width * best.height;
+
+  for (let i = 1; i < panes.length; i++) {
+    const pane = panes[i];
+    if (!pane) continue;
+    const area = pane.width * pane.height;
+    if (area > bestArea) {
+      best = pane;
+      bestArea = area;
+    }
+  }
+
+  return {
+    targetPane: best.paneId,
+    splitFlag: best.width >= best.height ? "-h" : "-v",
+  };
+}

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/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/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;