aiwcli 0.13.8 → 0.14.0

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

@@ -0,0 +1,46 @@
+# Prompt Codex Skill
+
+Launch Codex CLI in a tmux pane and inject a prompt into its REPL.
+
+## Directory Structure
+
+```
+prompt-codex/
+├── CLAUDE.md       ← This file
+└── scripts/
+    └── launch-codex.ts  ← CLI entry point
+```
+
+## 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...>
+```
+
+**Args:**
+- `plan` — discover active plan via context system, inject into Codex REPL
+- `--file <path>` — inject file contents into Codex REPL
+- `<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.
+
+**Plan discovery order:**
+1. `CLAUDE_SESSION_ID` env → `getContextBySessionId()` → `findLatestPlan(contextId)`
+2. Fallback: scan `_output/contexts/*/plans/*.md` by mtime (inline, no `_cc-native` import)
+
+**Dependencies (all from `_shared/lib-ts/`):**
+- `base/tmux-driver.ts` — `launchDriverInTmuxOrFallback()`, `getTmuxAvailability()`
+- `base/cli-args.ts` — `resolveCodexModel()`, `codexReplSpec()`, `buildCliInvocation()`, `isCodexSandbox()`
+- `base/logger.ts` — `logDebug()`, `logWarn()` (injection diagnostics)
+- `context/context-store.ts` — `getContextBySessionId()`
+- `context/context-formatter.ts` — `buildExternalAgentContext()` (orientation header for Codex)
+- `context/plan-manager.ts` — `findLatestPlan()`
+
+**Design decisions:**
+- Always creates a new tmux pane (no pane reuse/tracking)
+- No exec fallback — REPL mode requires tmux
+- `_shared` only — never imports from `_cc-native`
+- Temp file cleanup after injection confirmed

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

@@ -0,0 +1,254 @@
+#!/usr/bin/env bun
+/**
+ * Launch Codex in a tmux pane and inject a prompt into its REPL.
+ *
+ * Usage:
+ *   bun launch-codex.ts [--model fast|standard|smart|<model-id>] [--sandbox read-only|workspace-write|danger-full-access] [--context <id>] plan
+ *   bun launch-codex.ts [--model fast|standard|smart|<model-id>] [--sandbox read-only|workspace-write|danger-full-access] [--context <id>] --file <path>
+ *   bun launch-codex.ts [--model fast|standard|smart|<model-id>] [--sandbox read-only|workspace-write|danger-full-access] [--context <id>] <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 { getProjectRoot } from "../../../lib-ts/base/constants.js";
+import { resolveCodexModel, codexReplSpec, buildCliInvocation, isCodexSandbox, type CodexSandbox } 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 { findLatestPlan } from "../../../lib-ts/context/plan-manager.js";
+import type { ContextState } from "../../../lib-ts/types.js";
+
+/** Codex-specific model abbreviations. Checked before tier resolution. */
+const CODEX_ALIASES: Record<string, string> = {
+  spark: CODEX_MODELS.spark,
+  codex: CODEX_MODELS.codex,
+  gpt: CODEX_MODELS.gpt,
+};
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function eprint(...args: unknown[]): void {
+  process.stderr.write(args.map(String).join(" ") + "\n");
+}
+
+/** 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;
+}
+
+// ---------------------------------------------------------------------------
+// Arg parsing
+// ---------------------------------------------------------------------------
+
+const rawArgs = process.argv.slice(2);
+
+if (rawArgs.length === 0) {
+  eprint("Usage: launch-codex.ts [--model <model>] [--sandbox <mode>] [--context <id>] plan | --file <path> | <text...>");
+  process.exit(1);
+}
+
+// Extract --model, --sandbox, and --context flags before mode dispatch
+let modelFlag: string | undefined;
+let sandboxFlag: CodexSandbox | undefined;
+let contextFlag: string | undefined;
+const args: string[] = [];
+
+for (let i = 0; i < rawArgs.length; i++) {
+  if (rawArgs[i] === "--model" && i + 1 < rawArgs.length) {
+    modelFlag = rawArgs[++i];
+  } else if (rawArgs[i] === "--sandbox" && i + 1 < rawArgs.length) {
+    const val = rawArgs[++i];
+    if (!isCodexSandbox(val)) {
+      eprint(`Error: Invalid sandbox mode "${val}". Valid: read-only, workspace-write, danger-full-access`);
+      process.exit(1);
+    }
+    sandboxFlag = val;
+  } else if (rawArgs[i] === "--context" && i + 1 < rawArgs.length) {
+    contextFlag = rawArgs[++i];
+  } else {
+    args.push(rawArgs[i]);
+  }
+}
+
+if (args.length === 0) {
+  eprint("Usage: launch-codex.ts [--model <model>] [--sandbox <mode>] [--context <id>] plan | --file <path> | <text...>");
+  process.exit(1);
+}
+
+// Resolve model: alias first, then tier/pass-through via shared resolver
+let resolvedModel: string | undefined;
+if (modelFlag) {
+  const lower = modelFlag.toLowerCase();
+  resolvedModel = lower in CODEX_ALIASES
+    ? CODEX_ALIASES[lower]
+    : resolveCodexModel(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;
+  }
+}
+
+if (args[0] === "plan") {
+  // Plan discovery: context system first, mtime fallback second
+  let planPath: string | null = null;
+
+  if (ctx) {
+    planPath = findLatestPlan(ctx.id, projectRoot);
+  }
+
+  if (!planPath) {
+    planPath = findLatestPlanByMtime(projectRoot);
+  }
+
+  if (!planPath) {
+    eprint("Error: No plan found. Create a plan first (use plan mode), then run this command.");
+    process.exit(1);
+  }
+
+  promptPath = planPath;
+  console.log(`Found plan: ${displayPath(planPath)}`);
+
+} else if (args[0] === "--file") {
+  if (!args[1]) {
+    eprint("Error: --file requires a path argument.");
+    process.exit(1);
+  }
+  const filePath = path.resolve(args[1]);
+  if (!fs.existsSync(filePath)) {
+    eprint(`Error: File not found: ${filePath}`);
+    process.exit(1);
+  }
+  promptPath = filePath;
+
+} 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`);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// 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);
+}
+
+// ---------------------------------------------------------------------------
+// Launch Codex REPL in tmux pane
+// ---------------------------------------------------------------------------
+
+// Build args via centralized CLI builder
+const codexArgs = buildCliInvocation(codexReplSpec(resolvedModel, sandboxFlag)).args;
+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"}, source=${args[0]}, bytes=${promptPath ? fs.statSync(promptPath).size : 0}`);
+
+const result = await launchDriverInTmuxOrFallback({
+  toolName: "codex",
+  mode: "repl",
+  args: codexArgs,
+  promptPath,
+  sendPromptInRepl: true,
+  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);
+}
+
+// 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"}`);
+  }
+}
+
+if (result.paneId) {
+  console.log(`Codex launched in tmux pane: ${result.paneId}`);
+} else {
+  console.log("Codex launched in tmux pane.");
+}
+
+if (result.reason) {
+  // Partial success (e.g., launched but prompt injection failed)
+  eprint(`Warning: ${result.reason}`);
+}

package/dist/templates/cc-native/.claude/settings.json

@@ -1,6 +1,23 @@
 {
+  "statusLine": {
+    "type": "command",
+    "command": "NO_COLOR= FORCE_COLOR=2 bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_shared/scripts/status_line.ts"
+  },
+  "fileSuggestion": {
+    "type": "command",
+    "command": "bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_shared/hooks-ts/file-suggestion.ts"
+  },
   "hooks": {
     "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_shared/hooks-ts/user_prompt_submit.ts",
+            "timeout": 10000
+          }
+        ]
+      },
       {
         "hooks": [
           {
@@ -12,6 +29,56 @@
       }
     ],
     "PostToolUse": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_shared/hooks-ts/context_monitor.ts",
+            "timeout": 5000
+          }
+        ]
+      },
+      {
+        "matcher": "TaskCreate",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_shared/hooks-ts/task_create_capture.ts",
+            "timeout": 3000
+          }
+        ]
+      },
+      {
+        "matcher": "TaskUpdate",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_shared/hooks-ts/task_update_capture.ts",
+            "timeout": 3000
+          }
+        ]
+      },
+      {
+        "matcher": "ExitPlanMode",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_shared/hooks-ts/archive_plan.ts",
+            "timeout": 5000
+          }
+        ]
+      },
+      {
+        "matcher": "Write|Edit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_shared/hooks-ts/lint_after_edit.ts",
+            "timeout": 10000
+          }
+        ]
+      },
       {
         "matcher": "AskUserQuestion",
         "hooks": [
@@ -44,6 +111,51 @@
         ]
       }
     ],
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_shared/hooks-ts/session_start.ts",
+            "timeout": 5000
+          }
+        ]
+      }
+    ],
+    "SessionEnd": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_shared/hooks-ts/session_end.ts",
+            "timeout": 5000
+          }
+        ]
+      }
+    ],
+    "PreCompact": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_shared/hooks-ts/pre_compact.ts",
+            "timeout": 5000
+          }
+        ]
+      }
+    ],
+    "PermissionRequest": [
+      {
+        "matcher": "ExitPlanMode",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_shared/hooks-ts/archive_plan.ts",
+            "timeout": 5000
+          }
+        ]
+      }
+    ],
     "PreToolUse": [
       {
         "matcher": "^TaskCreate$",
@@ -83,5 +195,13 @@
   "env": {
     "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
   },
-  "enabledPlugins": {}
+  "enabledPlugins": {},
+  "methods": {
+    "cc-native": {
+      "ides": [
+        "claude"
+      ],
+      "installedAt": "2026-02-21T16:59:33.520Z"
+    }
+  }
 }

package/dist/templates/cc-native/_cc-native/CLAUDE.md

@@ -0,0 +1,73 @@
+# CC-Native Method
+
+**Location:** `.aiwcli/_cc-native/` — Claude Code-specific plan review, artifacts, and agent orchestration.
+
+---
+
+## Subsystems
+
+| Directory | Purpose | CLAUDE.md |
+|-----------|---------|-----------|
+| `agents/` | Plan review agent roster and specs | `agents/CLAUDE.md` |
+| `artifacts/` | Review artifact generation and tracking | `artifacts/CLAUDE.md` |
+| `hooks/` | CC-native hook entry points (plan review triggers) | `hooks/CLAUDE.md` |
+| `lib-ts/` | Shared TypeScript library for cc-native subsystems | `lib-ts/CLAUDE.md` |
+| `lib-ts/rlm/` | Retrieval-augmented learning memory | `lib-ts/rlm/CLAUDE.md` |
+| `plan-review/` | Multi-agent plan review pipeline | `plan-review/CLAUDE.md` |
+
+---
+
+## Shared Infrastructure (`_shared/lib-ts/`)
+
+CC-native code depends heavily on shared infrastructure. Full API details: `_shared/lib-ts/CLAUDE.md`.
+
+| Module | Capability | Use When |
+|--------|-----------|----------|
+| `base/hook-utils` | Hook lifecycle (load input, run, emit context) | Writing hooks |
+| `base/logger` | Structured logging (debug/info/warn/error) | Any hook or lib module |
+| `base/constants` | Project paths, context dirs, sanitization | Resolving file locations |
+| `base/subprocess-utils` | Find executables, exec with env, shell quoting | Spawning agent CLIs |
+| `base/cli-args` | CLI invocation builder, review spec construction | Launching review agents |
+| `base/atomic-write` | Crash-safe file writes | Writing state or artifacts |
+| `base/state-io` | State read/write helpers | Context state persistence |
+| `base/inference` | Claude CLI subprocess calls | AI inference from hooks |
+| `context/context-store` | Context CRUD (get by session, list all) | Session/context binding |
+| `context/plan-manager` | Plan lifecycle (archive, hash, sign) | Plan discovery and hashing |
+| `types` | Shared type definitions (`ContextState`, etc.) | Type imports |
+
+---
+
+## Import Patterns
+
+**Import direction:** `hooks/` → `lib-ts/` → `_shared/lib-ts/`. Never the reverse.
+
+```typescript
+// From hooks/ (2 levels up to _shared):
+import { runHook, logInfo } from "../../_shared/lib-ts/base/hook-utils.js";
+import { loadConfig } from "../lib-ts/config.js";
+
+// From lib-ts/ (2 levels up to _shared):
+import { logDebug } from "../../_shared/lib-ts/base/logger.js";
+import { atomicWrite } from "../../_shared/lib-ts/base/atomic-write.js";
+
+// From plan-review/lib/ (3 levels up to _shared):
+import { logInfo } from "../../../_shared/lib-ts/base/logger.js";
+```
+
+---
+
+## Context Maintenance
+
+**After modifying files in this directory:** scan the entries above — if any claim is now
+false or incomplete, update this file before ending the task. Do not defer.
+
+**Add** an entry only if an agent would fail without knowing it, it is not obvious from
+the code, and it belongs at this scope.
+
+**Remove** any entry that fails the falsifiability test: if removing it would not change
+how an agent acts here, remove it.
+
+**Staleness anchor:** This file assumes `lib-ts/index.ts` exists. If it doesn't, this file
+is stale — update or regenerate before relying on it.
+
+<!-- context-layer: generated=2026-03-01 | last-audited=2026-03-01 | version=1 | dir-commits-at-audit=15 -->

package/dist/templates/cc-native/_cc-native/lib-ts/CLAUDE.md

@@ -0,0 +1,70 @@
+# CC-Native Library
+
+**Location:** `_cc-native/lib-ts/` — TypeScript modules for plan review, state, and agent orchestration.
+
+**Import direction:** `hooks/` → `lib-ts/` → `_shared/lib-ts/`. Never the reverse.
+
+---
+
+## Module Reference
+
+The barrel `index.ts` re-exports most modules. Three files are **not** re-exported and must be imported directly: `plan-discovery.ts`, `plan-enhancement.ts`, `settings.ts`.
+
+| File | Purpose | Key Exports |
+|------|---------|-------------|
+| `aggregate-agents.ts` | Agent frontmatter parser — loads agent configs from markdown | `aggregateAgents`, `extractBody`, `extractFrontmatter` |
+| `cc-native-state.ts` | CC-native state accessor for context `state.json` | `getCcNativeState`, `saveCcNativeState`, `isPlanAlreadyReviewed`, `markPlanReviewed`, `markQuestionsAsked` |
+| `cli-output-parser.ts` | Unified Claude CLI JSON output parser | `parseCliOutput` |
+| `config.ts` | Configuration loading from `cc-native.config.json` | `loadConfig`, `getDisplaySettings` |
+| `constants.ts` | Feature flags, security limits, path validation | `ENABLE_ROBUST_PLAN_WRITES`, `PLANS_DIR`, `validatePlanPath`, `MAX_RETRY_ATTEMPTS` |
+| `debug.ts` | Per-context debug logging (thin layer over shared logger) | `debugLog`, `debugRaw`, `getDebugDir`, `cleanupDebugFolder` |
+| `index.ts` | Barrel — re-exports public API from all modules | (see individual modules) |
+| `json-parser.ts` | JSON parsing with recovery for LLM responses | `parseJsonMaybe`, `coerceToReview` |
+| `plan-discovery.ts` | Plan file discovery, reading, and hashing | *(not re-exported)* — import directly |
+| `plan-enhancement.ts` | Plan quality guidance prompt for context emission | *(not re-exported)* — import directly |
+| `settings.ts` | Settings loading, defaults, agent library management | *(not re-exported)* — import directly |
+| `state.ts` | Iteration state management for plan review cycles | `loadState`, `saveStateToPlan`, `getIterationState`, `shouldContinueIterating` |
+| `types.ts` | All cc-native type definitions and prompt constants | `Verdict`, `ReviewData`, `AgentConfig`, `PlanReviewConfig`, `REVIEW_SCHEMA` |
+
+**Subfolder:** `rlm/` — retrieval-augmented learning memory. Has its own `rlm/CLAUDE.md`.
+
+---
+
+## Shared Dependencies
+
+These `_shared/lib-ts` modules are used across cc-native lib-ts:
+
+| Shared Module | Used By |
+|--------------|---------|
+| `base/logger` | All modules (logging) |
+| `base/atomic-write` | `state.ts` (crash-safe writes) |
+| `base/utils` | `cc-native-state.ts` (`nowIso`) |
+| `context/context-store` | `cc-native-state.ts` (state access) |
+| `context/plan-manager` | `plan-discovery.ts` (plan path lookup) |
+| `types` | `types.ts` (re-exports `ContextState`, `HookInput`, `HookOutput`) |
+
+---
+
+## Import Direction
+
+```
+hooks/                    (entry points — import from lib-ts/ and _shared/)
+  ↓
+lib-ts/                   (this directory — import from _shared/ only)
+  ↓
+_shared/lib-ts/           (cross-method infrastructure — no reverse imports)
+```
+
+Never import from `hooks/` or `plan-review/` into `lib-ts/`. The one exception noted in `aggregate-agents.ts`: it stays in `lib-ts/` because both `settings.ts` and `plan-review/` depend on it.
+
+---
+
+## Context Maintenance
+
+**After modifying files in this directory:** scan the entries above — if any claim is now
+false or incomplete, update this file before ending the task. Do not defer.
+
+**Staleness anchor:** This file assumes `index.ts` exists with 13 sibling `.ts` files. If the
+count changes, update the Module Reference table.
+
+<!-- context-layer: generated=2026-03-01 | last-audited=2026-03-01 | version=1 | dir-commits-at-audit=15 -->

package/dist/templates/cc-native/_cc-native/lib-ts/settings.ts

@@ -16,6 +16,7 @@ import type {
 } from "./types.js";
 import { DEFAULT_DISPLAY, DEFAULT_SANITIZATION } from "./types.js";
 import { logInfo } from "../../_shared/lib-ts/base/logger.js";
+import { CODEX_MODELS } from "../../_shared/lib-ts/base/models.js";
 
 const HOOK = "settings";
 
@@ -71,7 +72,7 @@ export const DEFAULT_COMPLEXITY_CATEGORIES = ["code", "infrastructure", "documen
 export const DEFAULT_MODELS_CONFIG: ModelsConfig = {
   providers: {
     claude: { enabled: false, models: ["sonnet"] },
-    codex: { enabled: true, models: ["gpt-5.2"] },
+    codex: { enabled: true, models: [CODEX_MODELS.codex] },
   },
 };
 

package/dist/templates/cc-native/_cc-native/lib-ts/types.ts

@@ -7,6 +7,10 @@
 // Re-export shared types used by cc-native consumers
 export type { ContextState, HookInput, HookOutput } from "../../_shared/lib-ts/types.js";
 
+// Import AgentConfig for local use and re-export
+import type { AgentConfig as _AgentConfig } from "../../_shared/lib-ts/types.js";
+export type AgentConfig = _AgentConfig;
+
 // ---------------------------------------------------------------------------
 // Verdict & Decision Types
 // ---------------------------------------------------------------------------
@@ -118,17 +122,7 @@ export interface ReviewDecisionResult {
 // Agent & Orchestrator Configuration
 // ---------------------------------------------------------------------------
 
-/** Configuration for a Claude Code review agent */
-export interface AgentConfig {
-  name: string;
-  model: string;
-  provider: string; // e.g. "claude" | "codex" — assigned at runtime by assignModelsToAgents()
-  focus: string;
-  categories: string[];
-  description: string;
-  system_prompt: string; // Markdown body content for --system-prompt
-  reasoningEffort?: string; // e.g. "low", "medium", "high" — passed to codex -c model_reasoning_effort
-}
+// AgentConfig re-exported from _shared/lib-ts/types.ts above
 
 /** Configuration for the plan orchestrator */
 export interface OrchestratorConfig {
@@ -141,7 +135,6 @@ export interface OrchestratorConfig {
 export interface ProviderConfig {
   enabled: boolean;
   models: string[];
-  reasoningEffort?: string; // e.g. "low", "medium", "high" — codex model_reasoning_effort
 }
 
 /** Model provider pool configuration */