aiwcli 0.15.7 → 0.17.0

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

@@ -23,6 +23,7 @@ import {
 import { logInfo, logWarn, logError, setContextPath } from "../runtime/logger.js";
 import { readStateJson, writeStateJson } from "../runtime/state-io.js";
 import { nowIso, generateContextId } from "../runtime/utils.js";
+import { IndexFileSchema } from "../schemas.js";
 import type { ContextState, IndexFile, IndexEntry, Mode } from "../types.js";
 
 const INDEX_VERSION = "3.0";
@@ -81,8 +82,14 @@ function loadIndex(projectRoot?: string): IndexFile {
   if (fs.existsSync(indexPath)) {
     try {
       const raw = fs.readFileSync(indexPath, "utf8");
-      _indexCache = JSON.parse(raw) as IndexFile;
-      return _indexCache;
+      const data = JSON.parse(raw);
+      const validated = IndexFileSchema.safeParse(data);
+      if (!validated.success) {
+        logWarn("context_store", `Index schema validation failed, recreating: ${validated.error.message}`);
+      } else {
+        _indexCache = data as IndexFile;
+        return _indexCache;
+      }
     } catch (error: unknown) {
       logWarn("context_store", `Failed to read index, recreating: ${error}`);
     }
@@ -313,11 +320,31 @@ export function getAllContexts(
   const ctxMap = index.contexts;
 
   if (ctxMap && typeof ctxMap === "object" && Object.keys(ctxMap).length > 0) {
+    const orphanIds: string[] = [];
     for (const cid of Object.keys(ctxMap)) {
       const state = loadState(cid, projectRoot);
       if (state && (!status || state.status === status)) {
         results.push(state);
+      } else if (!state) {
+        orphanIds.push(cid);
+      }
+    }
+
+    if (orphanIds.length > 0) {
+      logWarn(
+        "context_store",
+        `Index references ${orphanIds.length} missing context(s): ${orphanIds.join(", ")}. Auto-repairing index.`
+      );
+      const idx = loadIndex(projectRoot);
+      for (const cid of orphanIds) {
+        delete idx.contexts[cid];
+        if (idx.sessions) {
+          for (const [sid, target] of Object.entries(idx.sessions)) {
+            if (target === cid) delete idx.sessions[sid];
+          }
+        }
       }
+      saveIndex(idx, projectRoot);
     }
   } else {
     // Fallback: scan folders

package/dist/templates/core/lib-ts/hooks/hook-utils.ts

@@ -9,6 +9,7 @@ import * as fs from "node:fs";
 import { getContextBySessionId, maybeActivate } from "../context/context-store.js";
 import { getProjectRoot } from "../runtime/constants.js";
 import { logDebug,  logWarn,     hookLog, setSessionId,  getContextPath as _getContextPath } from "../runtime/logger.js";
+import { HookInputSchema } from "../schemas.js";
 import type { ContextState, HookInput, HookOutput, PermissionRequestOutput } from "../types.js";
 
 // Re-export logger functions for convenience (matches Python hook_utils re-exports)
@@ -161,6 +162,11 @@ export function loadHookInput(): HookInput | null {
     if (!inputData) return null;
 
     const result = JSON.parse(inputData) as Record<string, unknown>;
+    const validated = HookInputSchema.safeParse(result);
+    if (!validated.success) {
+      logWarn("hook_utils", `Hook input schema validation failed: ${validated.error.message}`);
+      return null;
+    }
     if (result && typeof result === "object") {
       _lastHookEvent = readStringField(result, "hook_event_name");
       _lastToolName = readStringField(result, "tool_name");
@@ -533,6 +539,11 @@ function _earlyReadInput(prefetchedInput?: Record<string, unknown>): void {
     const inputData = fs.readFileSync(0, "utf8").trim();
     if (inputData) {
       const parsed = JSON.parse(inputData) as Record<string, unknown>;
+      const validated = HookInputSchema.safeParse(parsed);
+      if (!validated.success) {
+        logWarn("hook_utils", `Early input schema validation failed: ${validated.error.message}`);
+        return;
+      }
       if (parsed && typeof parsed === "object") {
         _prefetchedInput = parsed;
         _lastHookEvent = readStringField(parsed, "hook_event_name");

package/dist/templates/core/lib-ts/hooks/session-end-logic.ts

@@ -1,5 +1,6 @@
 import * as crypto from "node:crypto";
 
+import { determineArtifactType } from "../context/context-store.js";
 import {
   extractPlanAnchors,
   generatePlanId,
@@ -18,18 +19,6 @@ function formatArchiveTimestamp(date: Date): string {
   );
 }
 
-function resolveArtifactType(state: ContextState): "plan" | "handoff" | null {
-  if (state.next_artifact_type) return state.next_artifact_type;
-
-  const hasPlan = Boolean(state.plan_path && state.plan_hash);
-  const hasHandoff = Boolean(state.handoff_path);
-
-  if (hasPlan && hasHandoff) return "plan";
-  if (hasPlan) return "plan";
-  if (hasHandoff) return "handoff";
-  return null;
-}
-
 export function computePlanFallback(
   state: ContextState,
   planContent: string,
@@ -54,7 +43,7 @@ export function shouldStage(
   state: ContextState,
   permissionMode: string,
 ): boolean {
-  const artifactType = resolveArtifactType(state);
+  const artifactType = determineArtifactType(state);
   const canStage = state.mode === "active" || permissionMode === "plan";
   return Boolean(artifactType && canStage && !state.work_consumed);
 }

package/dist/templates/core/lib-ts/runtime/agent-launcher.ts

@@ -43,10 +43,72 @@ export function sleep(ms: number): Promise<void> {
   });
 }
 
+/**
+ * Print to stderr (shared by agent launch scripts).
+ */
+export function eprint(...args: unknown[]): void {
+  process.stderr.write(args.map(String).join(" ") + "\n");
+}
+
+/**
+ * Best-effort cleanup of a sentinel directory.
+ */
+export 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 */ }
+}
+
+/**
+ * Case-sensitive (or case-insensitive on Windows) path comparison.
+ */
+export function samePath(a: string, b: string): boolean {
+  const left = path.resolve(a);
+  const right = path.resolve(b);
+  if (process.platform === "win32") {
+    return left.toLowerCase() === right.toLowerCase();
+  }
+  return left === right;
+}
+
+/**
+ * Heuristic check for LLM output that isn't a real summary.
+ */
+export function looksLikeBadSummary(output: string): boolean {
+  const normalized = output.toLowerCase();
+  return (
+    normalized.includes("don't see") ||
+    normalized.includes("no output") ||
+    normalized.includes("could you provide") ||
+    normalized.includes("paste")
+  );
+}
+
+/**
+ * Return a deterministic summary file path for a given agent prefix + task ID.
+ * Callers can advertise this path before the session finishes so consumers
+ * know where to look for the summary once it's written.
+ */
+export function getWellKnownSummaryPath(
+  prefix: string,
+  taskId: string,
+  projectRoot?: string,
+): string {
+  const sessionKey = projectRoot
+    ? path.basename(projectRoot)
+    : "unknown";
+  const dir = path.join(os.tmpdir(), "aiw-agent-output", sessionKey);
+  return path.join(dir, `${prefix}-${taskId}.md`).replaceAll("\\", "/");
+}
+
 export function persistSummary(
   summary: string,
   prefix: string,
   sessionId?: string,
+  taskId?: string,
+  projectRoot?: string,
 ): string | null {
   try {
     const suffix = sessionId
@@ -57,6 +119,18 @@ export function persistSummary(
       `${prefix}-summary-${Date.now()}-${suffix}.md`,
     );
     fs.writeFileSync(filePath, summary, "utf8");
+
+    // Also write to the well-known path for deterministic discovery.
+    if (taskId) {
+      try {
+        const wkPath = getWellKnownSummaryPath(prefix, taskId, projectRoot);
+        fs.mkdirSync(path.dirname(wkPath), { recursive: true });
+        fs.writeFileSync(wkPath, summary, "utf8");
+      } catch {
+        logWarn("agent-launcher", "Failed to write well-known summary path");
+      }
+    }
+
     return filePath.replaceAll("\\", "/");
   } catch (error) {
     logWarn("agent-launcher", `Failed to persist summary: ${String(error)}`);

package/dist/templates/core/lib-ts/runtime/aiw-cli.ts

@@ -27,6 +27,8 @@ function resolveAiwBin(cwd?: string): string {
 export interface AiwLaunchOptions {
   /** Launch codex instead of claude. */
   codex?: boolean;
+  /** Launch devin instead of claude. */
+  devin?: boolean;
   /** Working directory. */
   cwd?: string;
   /** Extra env vars to inject. */
@@ -61,6 +63,7 @@ export async function aiwLaunch(options: AiwLaunchOptions): Promise<AiwLaunchRes
   const args = ["launch"];
 
   if (options.codex) args.push("--codex");
+  if (options.devin) args.push("--devin");
   if (options.wait) args.push("--wait");
   args.push("--json");
   if (options.split) args.push("--split", options.split);
@@ -87,7 +90,7 @@ function parseJsonResult(result: ExecResult): AiwLaunchResult {
     return {
       launched: Boolean(parsed.launched),
       backend: String(parsed.backend ?? "exec"),
-      paneId: parsed.paneId ?? null,
+      paneId: parsed.handle ?? parsed.paneId ?? null,
       sentinelPath: parsed.sentinelPath ?? null,
       exitCode: typeof parsed.exitCode === "number" ? parsed.exitCode : null,
       reason: parsed.reason ?? null,
@@ -103,4 +106,3 @@ function parseJsonResult(result: ExecResult): AiwLaunchResult {
     };
   }
 }
-

package/dist/templates/core/lib-ts/runtime/cli-args.ts

@@ -4,7 +4,7 @@
  * platform quoting, model tier resolution, and env setup.
  */
 
-import { CLAUDE_MODELS, CODEX_MODELS } from "./models.js";
+import { CLAUDE_MODELS, CODEX_MODELS, DEVIN_MODELS } from "./models.js";
 import type { PreflightCommandConfig } from "./preflight.js";
 import { getInternalSubprocessEnv, shellQuoteWin } from "./subprocess-utils.js";
 
@@ -15,7 +15,7 @@ import { getInternalSubprocessEnv, shellQuoteWin } from "./subprocess-utils.js";
 // ---------------------------------------------------------------------------
 
 export type InvocationMode = "structured" | "print" | "preflight";
-export type CliProvider = "claude" | "codex";
+export type CliProvider = "claude" | "codex" | "devin";
 export type ModelTier = "fast" | "standard" | "smart";
 
 const VALID_SANDBOXES = ["read-only", "workspace-write", "danger-full-access"] as const;
@@ -71,6 +71,12 @@ export const CODEX_MODEL_TIERS: Record<ModelTier, string> = {
   smart: CODEX_MODELS.codex,
 };
 
+export const DEVIN_MODEL_TIERS: Record<ModelTier, string> = {
+  fast: DEVIN_MODELS.sonnet,
+  standard: DEVIN_MODELS.swe,
+  smart: DEVIN_MODELS.opus,
+};
+
 export const TIER_TIMEOUTS: Record<ModelTier, number> = {
   fast: 15,
   standard: 30,
@@ -91,7 +97,9 @@ export function resolveModelForProvider(
   provider: CliProvider,
 ): string {
   if (!isModelTier(model)) return model;
-  return provider === "codex" ? CODEX_MODEL_TIERS[model] : MODEL_TIERS[model];
+  if (provider === "codex") return CODEX_MODEL_TIERS[model];
+  if (provider === "devin") return DEVIN_MODEL_TIERS[model];
+  return MODEL_TIERS[model];
 }
 
 export function getTierTimeout(tier: ModelTier): number {
@@ -104,6 +112,12 @@ export function resolveCodexModel(input: string): string {
   return input;
 }
 
+/** Resolve a Devin model: tier resolution + pass-through. No aliases (those are skill-specific). */
+export function resolveDevinModel(input: string): string {
+  if (isModelTier(input)) return DEVIN_MODEL_TIERS[input as ModelTier];
+  return input;
+}
+
 // ---------------------------------------------------------------------------
 // Core Builder
 // ---------------------------------------------------------------------------
@@ -286,4 +300,4 @@ export function preflightCommandConfig(provider: CliProvider): PreflightCommandC
   };
 }
 
-export {CLAUDE_MODELS, CODEX_MODELS} from "./models.js";
+export {CLAUDE_MODELS, CODEX_MODELS, DEVIN_MODELS} from "./models.js";

package/dist/templates/core/lib-ts/runtime/inference.ts

@@ -7,7 +7,7 @@
 import { execFileSync } from "node:child_process";
 
 import { logDebug, logWarn } from "./logger.js";
-import { STOP_WORDS } from "./stop-words.js";
+import { filterStopWords } from "./stop-words.js";
 import type { InferenceResult } from "../types.js";
 import {
   buildCliInvocation,
@@ -143,7 +143,7 @@ export function generateSemanticSummary(
   summary = summary.replace(/[.!?]+$/, "");
 
   // Filter stop words
-  summary = filterStopWords(summary);
+  summary = filterStopWords(summary).toLowerCase();
 
   const words = summary.split(/\s+/);
   if (words.length < 6 || words.length > 12) return null;
@@ -193,7 +193,7 @@ Respond with ONLY a JSON object: {"slug": "your 8-12 word phrase here"}`;
  */
 export function generateContextIdSlug(
   prompt: string,
-  timeout = 3,
+  timeout = 8,
 ): string | null {
   const truncated = prompt.slice(0, 500);
 
@@ -341,16 +341,4 @@ export async function codexInferAsync(
   };
 }
 
-/**
- * Filter stop words from text.
- * See SPEC.md §6.4
- */
-function filterStopWords(text: string): string {
-  return text
-    .toLowerCase()
-    .split(/\s+/)
-    .filter((w) => !STOP_WORDS.has(w) && w.length > 1)
-    .join(" ");
-}
-
 

package/dist/templates/core/lib-ts/runtime/models.ts

@@ -14,3 +14,10 @@ export const CODEX_MODELS = {
   codex: "gpt-5.4",
   gpt: "gpt-5.4",
 } as const;
+
+export const DEVIN_MODELS = {
+  swe: "swe",
+  gpt: "gpt",
+  opus: "opus",
+  sonnet: "sonnet",
+} as const;

package/dist/templates/core/lib-ts/runtime/state-io.ts

@@ -10,6 +10,7 @@ import path from "node:path";
 import { atomicWrite } from "./atomic-write.js";
 import { getContextDir } from "./constants.js";
 import { logWarn } from "./logger.js";
+import { ContextStateSchema } from "../schemas.js";
 import type { ContextState, Mode } from "../types.js";
 
 /** Mode migration from legacy context_manager values. */
@@ -34,12 +35,13 @@ interface LegacyStateData {
 
 /**
  * Serialize a ContextState for JSON output.
- * Omits null/undefined keys but keeps false, 0, empty string, and empty arrays.
+ * Omits undefined keys but preserves null (semantically meaningful in the schema).
+ * Keeps false, 0, empty string, and empty arrays.
  */
 export function toDict(state: ContextState): Record<string, unknown> {
   const result: Record<string, unknown> = {};
   for (const [key, value] of Object.entries(state)) {
-    if (value !== null && value !== undefined) {
+    if (value !== undefined) {
       result[key] = value;
     }
   }
@@ -121,6 +123,11 @@ export function readStateJson(
     const raw = fs.readFileSync(sp, "utf8");
     const data = JSON.parse(raw) as Record<string, unknown>;
     migrateConsumedFlags(data); // Migrate before dictToState
+    const parsed = ContextStateSchema.safeParse(data);
+    if (!parsed.success) {
+      logWarn("state_io", `Schema validation failed for '${contextId}': ${parsed.error.message}`);
+      // Fail-open: still attempt to reconstruct state from raw data
+    }
     return dictToState(data);
   } catch (error: unknown) {
     logWarn("state_io", `Failed to read state.json for '${contextId}': ${error}`);
@@ -138,8 +145,6 @@ export function writeStateJson(
   projectRoot?: string,
 ): [boolean, string | null] {
   const sp = statePath(contextId, projectRoot);
-  const dir = path.dirname(sp);
-  fs.mkdirSync(dir, { recursive: true });
 
   const content = JSON.stringify(toDict(state), null, 2);
   // fsync: false — state.json is reconstructable from context folder contents

package/dist/templates/core/lib-ts/runtime/utils.ts

@@ -3,6 +3,9 @@
  * See SPEC.md §14.2, §14.3
  */
 
+import * as fs from "node:fs";
+import path from "node:path";
+
 import { sanitizeTitle } from "./constants.js";
 import { logDebug, logError, logWarn } from "./logger.js";
 import { STOP_WORDS } from "./stop-words.js";
@@ -110,7 +113,7 @@ export function generateSlug(
   // Tier 1: AI inference via generateContextIdSlug (sync — uses execFileSync)
   try {
     // eslint-disable-next-line @typescript-eslint/no-require-imports, no-undef
-    const { generateContextIdSlug } = require("./inference.js");
+    const { generateContextIdSlug } = require("./inference");
     const aiSlug = generateContextIdSlug(text);
     if (aiSlug) {
       const filteredWords = aiSlug
@@ -191,3 +194,29 @@ export function generateContextId(
   return `${baseId}-${counter}`;
 }
 
+/**
+ * Get .md files in a directory sorted by mtime (newest first).
+ */
+export function getMdFilesByMtime(dir: string): string[] {
+  try {
+    if (!fs.existsSync(dir)) return [];
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    return entries
+      .filter(e => e.isFile() && e.name.endsWith(".md"))
+      .map(e => {
+        const fullPath = path.join(dir, e.name);
+        const stat = fs.statSync(fullPath);
+        return { path: fullPath, mtime: stat.mtimeMs };
+      })
+      .sort((a, b) => b.mtime - a.mtime)
+      .map(f => f.path);
+  } catch { return []; }
+}
+
+/**
+ * Get the most recently modified .md file in a directory.
+ */
+export function mostRecentMd(dir: string): string | null {
+  return getMdFilesByMtime(dir)[0] ?? null;
+}
+

package/dist/templates/core/lib-ts/schemas.ts

@@ -0,0 +1,233 @@
+/**
+ * Zod schemas mirroring types.ts for runtime validation at JSON.parse boundaries.
+ * All object schemas use .passthrough() to preserve method-specific extension fields.
+ * See types.ts for corresponding TypeScript interfaces.
+ */
+
+import { z } from "zod";
+
+// §1.1
+export const ModeSchema = z.enum(["active", "has_staged_work", "idle"]);
+
+// §1.2
+export const GitStateSchema = z
+  .object({
+    branch: z.string().optional(),
+    last_commit_short: z.string().optional(),
+    uncommitted_files: z.array(z.string()).optional(),
+  })
+  .passthrough();
+
+export const LastSessionSchema = z
+  .object({
+    context_remaining_pct: z.number().optional(),
+    context_warnings_fired: z.array(z.number()).optional(),
+    git_state: GitStateSchema.optional(),
+    save_reason: z.string().optional(),
+    saved_at: z.string().optional(),
+    session_id: z.string().optional(),
+    transcript_path: z.string().optional(),
+  })
+  .passthrough();
+
+// §1.3
+export const TaskSchema = z
+  .object({
+    active_form: z.string(),
+    completed_at: z.string().nullable(),
+    created_at: z.string(),
+    description: z.string(),
+    evidence: z.string(),
+    files_changed: z.array(z.string()),
+    id: z.string(),
+    session_id: z.string().optional(),
+    status: z.enum(["blocked", "completed", "in_progress", "pending"]),
+    subject: z.string(),
+    work_summary: z.string(),
+  })
+  .passthrough();
+
+// §1.1 (continued)
+export const ContextStateSchema = z
+  .object({
+    created_at: z.string(),
+    handoff_consumed: z.boolean().optional(), // deprecated
+    handoff_path: z.string().nullable().optional(),
+    id: z.string(),
+    last_active: z.string(),
+    last_session: LastSessionSchema.nullable().optional(),
+    method: z.string(),
+    mode: ModeSchema,
+    next_artifact_type: z.enum(["handoff", "plan"]).nullable().optional(),
+    plan_anchors: z.array(z.string()).optional(),
+    plan_consumed: z.boolean().optional(), // deprecated
+    plan_hash: z.string().nullable().optional(),
+    plan_hash_consumed: z.string().nullable().optional(),
+    plan_id: z.string().nullable().optional(),
+    plan_path: z.string().nullable().optional(),
+    plan_signature: z.string().nullable().optional(),
+    session_ids: z.array(z.string()).optional(),
+    status: z.enum(["active", "completed"]),
+    summary: z.string(),
+    tags: z.array(z.string()).optional(),
+    tasks: z.array(TaskSchema).optional(),
+    work_consumed: z.boolean().optional(),
+  })
+  .passthrough();
+
+// §1.4
+export const IndexEntrySchema = z
+  .object({
+    last_active: z.string(),
+    mode: z.string(),
+    summary: z.string(),
+  })
+  .passthrough();
+
+export const IndexFileSchema = z
+  .object({
+    contexts: z.record(z.string(), IndexEntrySchema),
+    sessions: z.record(z.string(), z.string()),
+    updated_at: z.string(),
+    version: z.literal("3.0"),
+  })
+  .passthrough();
+
+// §1.5
+export const LogEntrySchema = z
+  .object({
+    component: z.string().optional(),
+    data: z.unknown().optional(),
+    hook: z.string(),
+    level: z.enum(["debug", "error", "info", "warn"]),
+    msg: z.string(),
+    tb: z.string().optional(),
+    ts: z.string(),
+  })
+  .passthrough();
+
+// §1.6
+export const HookInputSchema = z
+  .object({
+    context_window: z
+      .object({
+        context_window_size: z.number().optional(),
+        current_usage: z
+          .object({
+            cache_creation_input_tokens: z.number().optional(),
+            cache_read_input_tokens: z.number().optional(),
+            input_tokens: z.number().optional(),
+            output_tokens: z.number().optional(),
+          })
+          .passthrough()
+          .optional(),
+      })
+      .passthrough()
+      .optional(),
+    cwd: z.string().optional(),
+    hook_event_name: z.string(),
+    permission_mode: z.string().optional(),
+    session_id: z.string().optional(),
+    source: z.string().optional(),
+    tool_input: z.record(z.string(), z.unknown()).optional(),
+    tool_name: z.string().optional(),
+    tool_result: z.string().optional(),
+    transcript_path: z.string().optional(),
+  })
+  .passthrough();
+
+// §1.7
+export const HookOutputSchema = z
+  .object({
+    decision: z.literal("block").optional(),
+    hookSpecificOutput: z
+      .object({
+        additionalContext: z.string().optional(),
+        hookEventName: z.string().optional(),
+        permissionDecision: z.enum(["allow", "ask", "deny"]).optional(),
+        permissionDecisionReason: z.string().optional(),
+        updatedInput: z.record(z.string(), z.unknown()).optional(),
+      })
+      .passthrough()
+      .optional(),
+    reason: z.string().optional(),
+  })
+  .passthrough();
+
+// §1.7b
+export const PermissionRequestOutputSchema = z
+  .object({
+    decision: z.object({
+      behavior: z.enum(["allow", "deny"]),
+      message: z.string().optional(),
+      updatedInput: z.record(z.string(), z.unknown()).optional(),
+      updatedPermissions: z.record(z.string(), z.unknown()).optional(),
+    }),
+  })
+  .passthrough();
+
+// §1.8
+export const InferenceResultSchema = z
+  .object({
+    error: z.string().optional(),
+    latency_ms: z.number(),
+    output: z.string(),
+    success: z.boolean(),
+  })
+  .passthrough();
+
+// §1.9
+export const HandoffDocumentSchema = z
+  .object({
+    active_tasks: z.array(TaskSchema),
+    completed_tasks_this_session: z.array(z.object({ subject: z.string() }).passthrough()),
+    context_folder: z.string(),
+    context_id: z.string(),
+    context_summary: z.string(),
+    created_at: z.string(),
+    events_log_path: z.string(),
+    file_path: z.string().nullable(),
+    important_notes: z.array(z.string()),
+    next_steps: z.array(z.string()),
+    plan_path: z.string().nullable(),
+    reason: z.string(),
+    session_id: z.string(),
+    work_summary: z.string(),
+  })
+  .passthrough();
+
+// §1.10
+export const HandoffSectionsSchema = z
+  .object({
+    completedWork: z.string().nullable(),
+    context: z.string().nullable(),
+    deadEnds: z.string().nullable(),
+    decisions: z.string().nullable(),
+    index: z.string().nullable(),
+    pending: z.string().nullable(),
+    plan: z.string().nullable(),
+  })
+  .passthrough();
+
+// §1.11
+export const CaretCommandSchema = z
+  .object({
+    ends: z.array(z.string()),
+    new_context_desc: z.string().nullable(),
+    remaining_prompt: z.string(),
+    select: z.string().nullable(),
+  })
+  .passthrough();
+
+// §1.13
+export const AgentConfigSchema = z
+  .object({
+    categories: z.array(z.string()),
+    description: z.string(),
+    focus: z.string(),
+    model: z.string(),
+    name: z.string(),
+    provider: z.string(),
+    system_prompt: z.string(),
+  })
+  .passthrough();