@corbat-tech/coco 2.35.0 → 2.37.0

package/dist/cli/index.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-import { execFileSync, execSync, spawn, execFile, exec } from 'child_process';
+import { execFileSync, spawn, execSync, execFile, exec } from 'child_process';
 import { setGlobalDispatcher, EnvHttpProxyAgent } from 'undici';
 import * as fs5 from 'fs';
-import fs5__default, { accessSync, readFileSync, constants as constants$1 } from 'fs';
+import fs5__default, { accessSync, mkdirSync, appendFileSync, readFileSync, writeFileSync, constants as constants$1 } from 'fs';
 import * as path39 from 'path';
 import path39__default, { join, dirname, resolve, basename } from 'path';
 import { URL as URL$1, fileURLToPath } from 'url';
@@ -23,7 +23,7 @@ import Anthropic from '@anthropic-ai/sdk';
 import { jsonrepair } from 'jsonrepair';
 import OpenAI from 'openai';
 import { GoogleGenAI, FunctionCallingConfigMode } from '@google/genai';
-import { parse as parse$1 } from 'yaml';
+import { parse } from 'yaml';
 import { minimatch } from 'minimatch';
 import hljs from 'highlight.js/lib/core';
 import bash from 'highlight.js/lib/languages/bash';
@@ -42,7 +42,7 @@ import yaml from 'highlight.js/lib/languages/yaml';
 import { diffLines, diffWords } from 'diff';
 import { glob } from 'glob';
 import { execa } from 'execa';
-import { parse } from '@typescript-eslint/typescript-estree';
+import { parse as parse$1 } from '@typescript-eslint/typescript-estree';
 import { simpleGit } from 'simple-git';
 import { Marked } from 'marked';
 import { markedTerminal } from 'marked-terminal';
@@ -893,8 +893,8 @@ async function configExists(configPath, scope = "any") {
   }
   return false;
 }
-function getConfigValue(config, path63) {
-  const keys = path63.split(".");
+function getConfigValue(config, path65) {
+  const keys = path65.split(".");
   let current = config;
   for (const key of keys) {
     if (current === null || current === void 0 || typeof current !== "object") {
@@ -956,6 +956,10 @@ function getCatalogDefaultModel(provider) {
 function getCatalogModel(provider, modelId) {
   return getProviderCatalogEntry(provider).models.find((modelEntry) => modelEntry.id === modelId);
 }
+function getCatalogRecommendedModel(provider) {
+  const entry = getProviderCatalogEntry(provider);
+  return entry.models.find((modelEntry) => modelEntry.recommended) ?? entry.models[0];
+}
 function getCatalogContextWindow(provider, modelId, fallback) {
   if (!modelId) return fallback;
   const exact = getCatalogModel(provider, modelId);
@@ -9496,9 +9500,9 @@ async function migrateGlobalConfig(oldDir, newConfigPath) {
     );
   }
 }
-async function fileExists(path63) {
+async function fileExists(path65) {
   try {
-    await access(path63);
+    await access(path65);
     return true;
   } catch {
     return false;
@@ -9881,8 +9885,8 @@ var init_registry = __esm({
       /**
        * Ensure directory exists
        */
-      async ensureDir(path63) {
-        await mkdir(dirname(path63), { recursive: true });
+      async ensureDir(path65) {
+        await mkdir(dirname(path65), { recursive: true });
       }
     };
   }
@@ -10057,7 +10061,7 @@ function parseSkillMarkdown(raw) {
   const frontmatter = normalized.slice(3, closeIndex).trim();
   const afterMarkerStart = closeIndex + closeMarker.length;
   const contentStart = normalized[afterMarkerStart] === "\n" ? afterMarkerStart + 1 : afterMarkerStart;
-  const parsed = frontmatter.length > 0 ? parse$1(frontmatter) : {};
+  const parsed = frontmatter.length > 0 ? parse(frontmatter) : {};
   return {
     data: parsed && typeof parsed === "object" ? parsed : {},
     content: normalized.slice(contentStart)
@@ -11563,9 +11567,9 @@ function createEmptyMemoryContext() {
     errors: []
   };
 }
-function createMissingMemoryFile(path63, level) {
+function createMissingMemoryFile(path65, level) {
   return {
-    path: path63,
+    path: path65,
     level,
     content: "",
     sections: [],
@@ -13126,8 +13130,8 @@ __export(trust_store_exports, {
   saveTrustStore: () => saveTrustStore,
   updateLastAccessed: () => updateLastAccessed
 });
-async function ensureDir(path63) {
-  await mkdir(dirname(path63), { recursive: true });
+async function ensureDir(path65) {
+  await mkdir(dirname(path65), { recursive: true });
 }
 async function loadTrustStore(storePath = TRUST_STORE_PATH) {
   try {
@@ -13212,8 +13216,8 @@ function canPerformOperation(store, projectPath, operation) {
   };
   return permissions[level]?.includes(operation) ?? false;
 }
-function normalizePath(path63) {
-  return join(path63);
+function normalizePath(path65) {
+  return join(path65);
 }
 function createTrustStore(storePath = TRUST_STORE_PATH) {
   let store = null;
@@ -13569,12 +13573,12 @@ function humanizeError(message, toolName) {
     return msg;
   }
   if (/ENOENT/i.test(msg)) {
-    const path63 = extractQuotedPath(msg);
-    return path63 ? `File or directory not found: ${path63}` : "File or directory not found";
+    const path65 = extractQuotedPath(msg);
+    return path65 ? `File or directory not found: ${path65}` : "File or directory not found";
   }
   if (/EACCES/i.test(msg)) {
-    const path63 = extractQuotedPath(msg);
-    return path63 ? `Permission denied: ${path63}` : "Permission denied \u2014 check file permissions";
+    const path65 = extractQuotedPath(msg);
+    return path65 ? `Permission denied: ${path65}` : "Permission denied \u2014 check file permissions";
   }
   if (/EISDIR/i.test(msg)) {
     return "Expected a file but found a directory at the specified path";
@@ -14516,9 +14520,9 @@ var init_diff_renderer = __esm({
     getTerminalWidth = () => process.stdout.columns || 80;
   }
 });
-async function fileExists4(path63) {
+async function fileExists4(path65) {
   try {
-    await access(path63);
+    await access(path65);
     return true;
   } catch {
     return false;
@@ -15461,7 +15465,7 @@ var init_complexity = __esm({
        * Analyze single file
        */
       async analyzeFile(file, content) {
-        const ast = parse(content, {
+        const ast = parse$1(content, {
           loc: true,
           range: true,
           comment: false,
@@ -16058,7 +16062,7 @@ var init_completeness = __esm({
         for (const file of files) {
           try {
             const content = await readFile(file, "utf-8");
-            const ast = parse(content, {
+            const ast = parse$1(content, {
               loc: true,
               range: true,
               jsx: file.endsWith(".tsx") || file.endsWith(".jsx")
@@ -16271,7 +16275,7 @@ var init_robustness = __esm({
         for (const file of targetFiles) {
           try {
             const content = await readFile(file, "utf-8");
-            const ast = parse(content, {
+            const ast = parse$1(content, {
               loc: true,
               range: true,
               jsx: file.endsWith(".tsx") || file.endsWith(".jsx")
@@ -16564,7 +16568,7 @@ var init_documentation = __esm({
         for (const file of targetFiles) {
           try {
             const content = await readFile(file, "utf-8");
-            const ast = parse(content, {
+            const ast = parse$1(content, {
               loc: true,
               range: true,
               comment: true,
@@ -16942,7 +16946,7 @@ var init_readability = __esm({
         for (const file of targetFiles) {
           try {
             const content = await readFile(file, "utf-8");
-            const ast = parse(content, {
+            const ast = parse$1(content, {
               loc: true,
               range: true,
               jsx: file.endsWith(".tsx") || file.endsWith(".jsx")
@@ -17100,7 +17104,7 @@ var init_maintainability = __esm({
           try {
             const content = await readFile(file, "utf-8");
             const lineCount = countLines(content);
-            const ast = parse(content, {
+            const ast = parse$1(content, {
               loc: true,
               range: true,
               jsx: file.endsWith(".tsx") || file.endsWith(".jsx")
@@ -26985,8 +26989,8 @@ Generated by Corbat-Coco v0.1.0
 
 // src/cli/commands/init.ts
 function registerInitCommand(program2) {
-  program2.command("init").description("Initialize a new Corbat-Coco project").argument("[path]", "Project directory path", ".").option("-t, --template <template>", "Project template to use").option("-y, --yes", "Skip prompts and use defaults").option("--skip-discovery", "Skip the discovery phase (use existing spec)").action(async (path63, options) => {
-    await runInit(path63, options);
+  program2.command("init").description("Initialize a new Corbat-Coco project").argument("[path]", "Project directory path", ".").option("-t, --template <template>", "Project template to use").option("-y, --yes", "Skip prompts and use defaults").option("--skip-discovery", "Skip the discovery phase (use existing spec)").action(async (path65, options) => {
+    await runInit(path65, options);
   });
 }
 async function runInit(projectPath, options) {
@@ -27065,18 +27069,18 @@ async function gatherProjectInfo() {
     language
   };
 }
-function getDefaultProjectInfo(path63) {
-  const name = path63 === "." ? "my-project" : path63.split("/").pop() || "my-project";
+function getDefaultProjectInfo(path65) {
+  const name = path65 === "." ? "my-project" : path65.split("/").pop() || "my-project";
   return {
     name,
     description: "",
     language: "typescript"
   };
 }
-async function checkExistingProject(path63) {
+async function checkExistingProject(path65) {
   try {
     const fs57 = await import('fs/promises');
-    await fs57.access(`${path63}/.coco`);
+    await fs57.access(`${path65}/.coco`);
     return true;
   } catch {
     return false;
@@ -30577,20 +30581,20 @@ async function createCliPhaseContext(projectPath, _onUserInput) {
     },
     tools: {
       file: {
-        async read(path63) {
+        async read(path65) {
           const fs57 = await import('fs/promises');
-          return fs57.readFile(path63, "utf-8");
+          return fs57.readFile(path65, "utf-8");
         },
-        async write(path63, content) {
+        async write(path65, content) {
           const fs57 = await import('fs/promises');
           const nodePath = await import('path');
-          await fs57.mkdir(nodePath.dirname(path63), { recursive: true });
-          await fs57.writeFile(path63, content, "utf-8");
+          await fs57.mkdir(nodePath.dirname(path65), { recursive: true });
+          await fs57.writeFile(path65, content, "utf-8");
         },
-        async exists(path63) {
+        async exists(path65) {
           const fs57 = await import('fs/promises');
           try {
-            await fs57.access(path63);
+            await fs57.access(path65);
             return true;
           } catch {
             return false;
@@ -30946,10 +30950,10 @@ function getPhaseStatusForPhase(phase) {
 }
 async function loadProjectState(cwd, config) {
   const fs57 = await import('fs/promises');
-  const path63 = await import('path');
-  const statePath = path63.join(cwd, ".coco", "state.json");
-  const backlogPath = path63.join(cwd, ".coco", "planning", "backlog.json");
-  const checkpointDir = path63.join(cwd, ".coco", "checkpoints");
+  const path65 = await import('path');
+  const statePath = path65.join(cwd, ".coco", "state.json");
+  const backlogPath = path65.join(cwd, ".coco", "planning", "backlog.json");
+  const checkpointDir = path65.join(cwd, ".coco", "checkpoints");
   let currentPhase = "idle";
   let metrics;
   let sprint;
@@ -32521,8 +32525,8 @@ async function saveConfig2(config) {
   await fs57.mkdir(dir, { recursive: true });
   await fs57.writeFile(CONFIG_PATH, JSON.stringify(config, null, 2));
 }
-function getNestedValue(obj, path63) {
-  const keys = path63.split(".");
+function getNestedValue(obj, path65) {
+  const keys = path65.split(".");
   let current = obj;
   for (const key of keys) {
     if (current === null || current === void 0 || typeof current !== "object") {
@@ -32532,8 +32536,8 @@ function getNestedValue(obj, path63) {
   }
   return current;
 }
-function setNestedValue(obj, path63, value) {
-  const keys = path63.split(".");
+function setNestedValue(obj, path65, value) {
+  const keys = path65.split(".");
   let current = obj;
   for (let i = 0; i < keys.length - 1; i++) {
     const key = keys[i];
@@ -33565,9 +33569,9 @@ function registerCheckCommand(program2) {
 // src/swarm/spec-parser.ts
 async function parseSwarmSpec(filePath) {
   const fs57 = await import('fs/promises');
-  const path63 = await import('path');
+  const path65 = await import('path');
   const rawContent = await fs57.readFile(filePath, "utf-8");
-  const ext = path63.extname(filePath).toLowerCase();
+  const ext = path65.extname(filePath).toLowerCase();
   if (ext === ".yaml" || ext === ".yml") {
     return parseYamlSpec(rawContent);
   }
@@ -33897,8 +33901,8 @@ var DEFAULT_AGENT_CONFIG = {
 };
 async function loadAgentConfig(projectPath) {
   const fs57 = await import('fs/promises');
-  const path63 = await import('path');
-  const configPath = path63.join(projectPath, ".coco", "swarm", "agents.json");
+  const path65 = await import('path');
+  const configPath = path65.join(projectPath, ".coco", "swarm", "agents.json");
   try {
     const raw = await fs57.readFile(configPath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -34089,16 +34093,16 @@ async function createBoard(projectPath, spec) {
 }
 async function loadBoard(projectPath) {
   const fs57 = await import('fs/promises');
-  const path63 = await import('path');
-  const boardPath = path63.join(projectPath, ".coco", "swarm", "task-board.json");
+  const path65 = await import('path');
+  const boardPath = path65.join(projectPath, ".coco", "swarm", "task-board.json");
   const raw = await fs57.readFile(boardPath, "utf-8");
   return JSON.parse(raw);
 }
 async function saveBoard(projectPath, board) {
   const fs57 = await import('fs/promises');
-  const path63 = await import('path');
-  const boardDir = path63.join(projectPath, ".coco", "swarm");
-  const boardPath = path63.join(boardDir, "task-board.json");
+  const path65 = await import('path');
+  const boardDir = path65.join(projectPath, ".coco", "swarm");
+  const boardPath = path65.join(boardDir, "task-board.json");
   await fs57.mkdir(boardDir, { recursive: true });
   await fs57.writeFile(boardPath, JSON.stringify(board, null, 2), "utf-8");
 }
@@ -34266,9 +34270,9 @@ async function defaultPromptHandler(q) {
 }
 async function writeAssumptionsFile(projectPath, projectName, questions, assumptions) {
   const fs57 = await import('fs/promises');
-  const path63 = await import('path');
-  const swarmDir = path63.join(projectPath, ".coco", "swarm");
-  const assumptionsPath = path63.join(swarmDir, "assumptions.md");
+  const path65 = await import('path');
+  const swarmDir = path65.join(projectPath, ".coco", "swarm");
+  const assumptionsPath = path65.join(swarmDir, "assumptions.md");
   await fs57.mkdir(swarmDir, { recursive: true });
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const content = [
@@ -34292,9 +34296,9 @@ async function writeAssumptionsFile(projectPath, projectName, questions, assumpt
 // src/swarm/events.ts
 async function appendSwarmEvent(projectPath, event) {
   const fs57 = await import('fs/promises');
-  const path63 = await import('path');
-  const eventsDir = path63.join(projectPath, ".coco", "swarm");
-  const eventsFile = path63.join(eventsDir, "events.jsonl");
+  const path65 = await import('path');
+  const eventsDir = path65.join(projectPath, ".coco", "swarm");
+  const eventsFile = path65.join(eventsDir, "events.jsonl");
   await fs57.mkdir(eventsDir, { recursive: true });
   await fs57.appendFile(eventsFile, JSON.stringify(event) + "\n", "utf-8");
 }
@@ -34305,9 +34309,9 @@ function createEventId() {
 // src/swarm/knowledge.ts
 async function appendKnowledge(projectPath, entry) {
   const fs57 = await import('fs/promises');
-  const path63 = await import('path');
-  const knowledgeDir = path63.join(projectPath, ".coco", "swarm");
-  const knowledgeFile = path63.join(knowledgeDir, "knowledge.jsonl");
+  const path65 = await import('path');
+  const knowledgeDir = path65.join(projectPath, ".coco", "swarm");
+  const knowledgeFile = path65.join(knowledgeDir, "knowledge.jsonl");
   await fs57.mkdir(knowledgeDir, { recursive: true });
   await fs57.appendFile(knowledgeFile, JSON.stringify(entry) + "\n", "utf-8");
 }
@@ -34614,10 +34618,10 @@ async function runSwarmLifecycle(options) {
 async function stageInit(ctx) {
   const { projectPath, spec } = ctx.options;
   const fs57 = await import('fs/promises');
-  const path63 = await import('path');
-  await fs57.mkdir(path63.join(projectPath, ".coco", "swarm"), { recursive: true });
+  const path65 = await import('path');
+  await fs57.mkdir(path65.join(projectPath, ".coco", "swarm"), { recursive: true });
   await fs57.mkdir(ctx.options.outputPath, { recursive: true });
-  const specSummaryPath = path63.join(projectPath, ".coco", "swarm", "spec-summary.json");
+  const specSummaryPath = path65.join(projectPath, ".coco", "swarm", "spec-summary.json");
   const specSummary = {
     projectName: spec.projectName,
     description: spec.description,
@@ -34689,8 +34693,8 @@ async function stagePlan(ctx) {
   ]);
   await createBoard(projectPath, spec);
   const fs57 = await import('fs/promises');
-  const path63 = await import('path');
-  const planPath = path63.join(projectPath, ".coco", "swarm", "plan.json");
+  const path65 = await import('path');
+  const planPath = path65.join(projectPath, ".coco", "swarm", "plan.json");
   await fs57.writeFile(
     planPath,
     JSON.stringify({ pm: pmResult, architect: archResult, bestPractices: bpResult }, null, 2),
@@ -34907,7 +34911,7 @@ async function stageIntegrate(ctx) {
 async function stageOutput(ctx) {
   const { projectPath, outputPath } = ctx.options;
   const fs57 = await import('fs/promises');
-  const path63 = await import('path');
+  const path65 = await import('path');
   const board = await loadBoard(projectPath);
   const featureResults = Array.from(ctx.featureResults.values());
   const summary = {
@@ -34922,7 +34926,7 @@ async function stageOutput(ctx) {
     globalScore: computeGlobalScore(featureResults)
   };
   await fs57.mkdir(outputPath, { recursive: true });
-  const summaryPath = path63.join(outputPath, "swarm-summary.json");
+  const summaryPath = path65.join(outputPath, "swarm-summary.json");
   await fs57.writeFile(summaryPath, JSON.stringify(summary, null, 2), "utf-8");
   const passed = summary.globalScore >= ctx.options.minScore;
   await emitGate(projectPath, "global-score", passed, `Global score: ${summary.globalScore}`);
@@ -35269,8 +35273,8 @@ var SwarmOrchestrator = class {
       noQuestions = false,
       onProgress
     } = options;
-    const path63 = await import('path');
-    const projectPath = path63.dirname(path63.resolve(specFile));
+    const path65 = await import('path');
+    const projectPath = path65.dirname(path65.resolve(specFile));
     onProgress?.("init", `Parsing spec file: ${specFile}`);
     const spec = await parseSwarmSpec(specFile);
     onProgress?.("init", `Initializing provider: ${providerType}`);
@@ -35281,7 +35285,7 @@ var SwarmOrchestrator = class {
     await runSwarmLifecycle({
       spec,
       projectPath,
-      outputPath: path63.resolve(outputPath),
+      outputPath: path65.resolve(outputPath),
       provider,
       agentConfig,
       minScore,
@@ -39219,8 +39223,8 @@ async function listTrustedProjects2(trustStore) {
   p26.log.message("");
   for (const project of projects) {
     const level = project.approvalLevel.toUpperCase().padEnd(5);
-    const path63 = project.path.length > 50 ? "..." + project.path.slice(-47) : project.path;
-    p26.log.message(`  [${level}] ${path63}`);
+    const path65 = project.path.length > 50 ? "..." + project.path.slice(-47) : project.path;
+    p26.log.message(`  [${level}] ${path65}`);
     p26.log.message(`      Last accessed: ${new Date(project.lastAccessed).toLocaleString()}`);
   }
   p26.log.message("");
@@ -40451,8 +40455,8 @@ function displayRewindResult(result) {
     const fileName = filePath.split("/").pop() ?? filePath;
     console.log(`${chalk.green(String.fromCodePoint(10003))} Restored: ${fileName}`);
   }
-  for (const { path: path63, error } of result.filesFailed) {
-    const fileName = path63.split("/").pop() ?? path63;
+  for (const { path: path65, error } of result.filesFailed) {
+    const fileName = path65.split("/").pop() ?? path65;
     console.log(`${chalk.red(String.fromCodePoint(10007))} Failed: ${fileName} (${error})`);
   }
   if (result.conversationRestored) {
@@ -49993,7 +49997,7 @@ async function validateCode(code, filePath, _language) {
   const errors = [];
   const warnings = [];
   try {
-    const ast = parse(code, {
+    const ast = parse$1(code, {
       loc: true,
       range: true,
       comment: true,
@@ -50120,7 +50124,7 @@ async function analyzeFile(filePath, includeAst = false) {
   const exports$1 = [];
   let ast;
   try {
-    ast = parse(content, {
+    ast = parse$1(content, {
       loc: true,
       range: true,
       comment: true,
@@ -52599,7 +52603,7 @@ var repoMapCommand = {
   }
 };
 
-// src/cli/repl/modes.ts
+// src/runtime/agent-modes.ts
 var AGENT_MODES = {
   ask: {
     id: "ask",
@@ -54880,8 +54884,8 @@ function formatToolSummary(toolName, input) {
     case "grep":
     case "search_files": {
       const pattern = String(input.pattern || "");
-      const path63 = input.path ? ` in ${input.path}` : "";
-      return `"${pattern}"${path63}`;
+      const path65 = input.path ? ` in ${input.path}` : "";
+      return `"${pattern}"${path65}`;
     }
     case "bash_exec": {
       const cmd = String(input.command || "");
@@ -54902,8 +54906,8 @@ function formatToolSummary(toolName, input) {
 function formatUrl(url) {
   try {
     const u = new URL(url);
-    const path63 = u.pathname.replace(/\/$/, "");
-    const display = path63 ? `${u.hostname} \u203A ${path63.slice(1)}` : u.hostname;
+    const path65 = u.pathname.replace(/\/$/, "");
+    const display = path65 ? `${u.hostname} \u203A ${path65.slice(1)}` : u.hostname;
     const max = Math.max(getTerminalWidth2() - 20, 50);
     return display.length > max ? display.slice(0, max - 1) + "\u2026" : display;
   } catch {
@@ -55083,6 +55087,12 @@ var RepeatedOutputSuppressor = class {
 // src/cli/repl/agent-loop.ts
 async function executeAgentTurn(session, userMessage, provider, toolRegistry, options = {}) {
   resetLineBuffer();
+  session.runtime?.eventLog.record("turn.started", {
+    sessionId: session.id,
+    provider: session.config.provider.type,
+    model: session.config.provider.model,
+    mode: session.agentMode ?? (session.planMode ? "plan" : "build")
+  });
   const messageSnapshot = session.messages.length;
   addMessage(session, { role: "user", content: userMessage });
   const executedTools = [];
@@ -55099,6 +55109,15 @@ async function executeAgentTurn(session, userMessage, provider, toolRegistry, op
   const readOnlyModeEnabled = session.planMode === true || activeMode?.readOnly === true;
   const strictPlanModeEnabled = readOnlyModeEnabled && session.config.agent.planModeStrict === true;
   const outputOffloadObservationEnabled = session.config.agent.outputOffload === true;
+  const recordToolSkipped = (toolCall, reason) => {
+    session.runtime?.eventLog.record("tool.skipped", {
+      sessionId: session.id,
+      tool: toolCall.name,
+      toolCallId: toolCall.id,
+      reason
+    });
+    options.onToolSkipped?.(toolCall, reason);
+  };
   const buildQualityMetrics = () => computeTurnQualityMetrics({
     iterationsUsed: iteration,
     maxIterations,
@@ -55110,7 +55129,7 @@ async function executeAgentTurn(session, userMessage, provider, toolRegistry, op
   });
   const abortReturn = () => {
     session.messages.length = messageSnapshot;
-    return {
+    const result2 = {
       content: finalContent,
       toolCalls: executedTools,
       usage: { inputTokens: totalInputTokens, outputTokens: totalOutputTokens },
@@ -55119,6 +55138,14 @@ async function executeAgentTurn(session, userMessage, provider, toolRegistry, op
       partialContent: finalContent || void 0,
       abortReason: "user_cancel"
     };
+    session.runtime?.eventLog.record("turn.completed", {
+      sessionId: session.id,
+      aborted: true,
+      toolsExecuted: executedTools.length,
+      inputTokens: totalInputTokens,
+      outputTokens: totalOutputTokens
+    });
+    return result2;
   };
   const allTools = toolRegistry.getToolDefinitionsForLLM();
   const tools = readOnlyModeEnabled ? strictPlanModeEnabled ? filterStrictPlanModeTools(allTools) : filterReadOnlyTools(allTools) : allTools;
@@ -55441,10 +55468,20 @@ ${tail}`;
         return abortReturn();
       }
       if (classification.kind === "provider_non_retryable") {
+        session.runtime?.eventLog.record("turn.failed", {
+          sessionId: session.id,
+          error: classification.original instanceof Error ? classification.original.message : String(classification.original),
+          toolsExecuted: executedTools.length
+        });
         throw classification.original;
       }
       hadTurnError = true;
       const errorMsg = classification.message;
+      session.runtime?.eventLog.record("turn.failed", {
+        sessionId: session.id,
+        error: errorMsg,
+        toolsExecuted: executedTools.length
+      });
       addMessage(session, {
         role: "assistant",
         content: `[Error during streaming: ${errorMsg}]`
@@ -55550,7 +55587,7 @@ ${tail}`;
           toolCall.id,
           `User explicitly requested MCP, but the model selected '${toolCall.name}' instead. Use an MCP tool (${availableMcpToolNames.join(", ")}) for this service access.`
         );
-        options.onToolSkipped?.(toolCall, "Use MCP tool instead of generic fetch");
+        recordToolSkipped(toolCall, "Use MCP tool instead of generic fetch");
         continue;
       }
       if (shouldBlockShellMcpInspection(toolCall)) {
@@ -55558,7 +55595,7 @@ ${tail}`;
           toolCall.id,
           "Use the native mcp_list_servers tool to inspect configured and connected MCP services in this session. Do not shell out to `coco mcp ...` for runtime MCP diagnosis unless the user explicitly asked for the CLI command."
         );
-        options.onToolSkipped?.(toolCall, "Use mcp_list_servers instead of coco mcp CLI");
+        recordToolSkipped(toolCall, "Use mcp_list_servers instead of coco mcp CLI");
         continue;
       }
       if (strictPlanModeEnabled && !STRICT_PLAN_MODE_ALLOWED_TOOLS.has(toolCall.name)) {
@@ -55566,7 +55603,7 @@ ${tail}`;
           toolCall.id,
           `Blocked by strict plan mode: tool '${toolCall.name}' is not read-only`
         );
-        options.onToolSkipped?.(toolCall, "Blocked by strict plan mode");
+        recordToolSkipped(toolCall, "Blocked by strict plan mode");
         continue;
       }
       const trustPattern = getTrustPattern(toolCall.name, toolCall.input);
@@ -55579,7 +55616,7 @@ ${tail}`;
         } catch (confirmError) {
           options.onAfterConfirmation?.();
           declinedTools.set(toolCall.id, "Confirmation failed");
-          options.onToolSkipped?.(
+          recordToolSkipped(
             toolCall,
             `Confirmation failed: ${confirmError instanceof Error ? confirmError.message : String(confirmError)}`
           );
@@ -55598,7 +55635,7 @@ ${tail}`;
         switch (confirmResult) {
           case "no":
             declinedTools.set(toolCall.id, "User declined");
-            options.onToolSkipped?.(toolCall, "User declined");
+            recordToolSkipped(toolCall, "User declined");
             continue;
           case "abort":
             turnAborted = true;
@@ -55628,15 +55665,33 @@ ${tail}`;
         onToolStart: (toolCall, _index, _total) => {
           const originalIndex = response.toolCalls.findIndex((tc) => tc.id === toolCall.id) + 1;
           options.onToolStart?.(toolCall, originalIndex, totalTools);
+          session.runtime?.eventLog.record("tool.started", {
+            sessionId: session.id,
+            tool: toolCall.name,
+            toolCallId: toolCall.id,
+            index: originalIndex,
+            total: totalTools
+          });
+        },
+        onToolEnd: (result2) => {
+          session.runtime?.eventLog.record("tool.completed", {
+            sessionId: session.id,
+            tool: result2.name,
+            toolCallId: result2.id,
+            success: result2.result.success,
+            duration: result2.duration
+          });
+          options.onToolEnd?.(result2);
+        },
+        onToolSkipped: (toolCall, reason) => {
+          recordToolSkipped(toolCall, reason);
         },
-        onToolEnd: options.onToolEnd,
-        onToolSkipped: options.onToolSkipped,
         signal: options.signal,
         onPathAccessDenied: async (dirPath) => {
           options.onBeforeConfirmation?.();
-          const result = await promptAllowPath(dirPath);
+          const result2 = await promptAllowPath(dirPath);
           options.onAfterConfirmation?.();
-          return result;
+          return result2;
         },
         // Pass hooks through so PreToolUse/PostToolUse hooks fire during execution
         hookRegistry: options.hookRegistry,
@@ -55910,13 +55965,21 @@ I have reached the maximum iteration limit (${maxIterations}). The task may be i
     }
   }
   options.onStream?.({ type: "done" });
-  return {
+  const result = {
     content: finalContent,
     toolCalls: executedTools,
     usage: { inputTokens: totalInputTokens, outputTokens: totalOutputTokens },
     quality: buildQualityMetrics(),
     aborted: false
   };
+  session.runtime?.eventLog.record("turn.completed", {
+    sessionId: session.id,
+    aborted: false,
+    toolsExecuted: executedTools.length,
+    inputTokens: totalInputTokens,
+    outputTokens: totalOutputTokens
+  });
+  return result;
 }
 function formatAbortSummary(executedTools) {
   if (executedTools.length === 0) return null;
@@ -56307,6 +56370,9 @@ var statsCommand = {
     console.log(`  Model: ${chalk.cyan(session.config.provider.model)}`);
     console.log(`  Endpoint: ${chalk.yellow(runtime.endpoint)}`);
     console.log(`  Mode: ${session.agentMode ?? (session.planMode ? "plan" : "build")}`);
+    if (session.runtime) {
+      console.log(`  Runtime events: ${chalk.yellow(String(session.runtime.eventLog.count()))}`);
+    }
     console.log();
     console.log(chalk.dim("  Messages:"));
     console.log(chalk.dim(`    user:          ${userMessages}`));
@@ -57302,6 +57368,937 @@ function createSpinner(message) {
 // src/cli/repl/index.ts
 init_error_resilience();
 init_providers();
+
+// src/runtime/agent-runtime.ts
+init_env();
+
+// src/runtime/default-turn-runner.ts
+var DefaultRuntimeTurnRunner = class {
+  async run(input, context) {
+    const messages = [
+      ...context.session.messages,
+      {
+        role: "user",
+        content: input.content
+      }
+    ];
+    const response = await context.provider.chat(messages, {
+      model: input.options?.model,
+      maxTokens: input.options?.maxTokens,
+      temperature: input.options?.temperature,
+      stopSequences: input.options?.stopSequences,
+      system: context.session.instructions ?? input.options?.system,
+      timeout: input.options?.timeout,
+      signal: input.options?.signal,
+      thinking: input.options?.thinking
+    });
+    return {
+      sessionId: context.session.id,
+      content: response.content,
+      usage: response.usage,
+      model: response.model,
+      mode: context.session.mode
+    };
+  }
+};
+function createDefaultRuntimeTurnRunner() {
+  return new DefaultRuntimeTurnRunner();
+}
+var InMemoryEventLog = class {
+  events = [];
+  record(type, data = {}) {
+    const event = {
+      id: randomUUID(),
+      type,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      data
+    };
+    this.events.push(event);
+    return event;
+  }
+  list() {
+    return [...this.events];
+  }
+  count() {
+    return this.events.length;
+  }
+  clear() {
+    this.events = [];
+  }
+};
+var FileEventLog = class {
+  constructor(filePath) {
+    this.filePath = filePath;
+    try {
+      mkdirSync(dirname(filePath), { recursive: true });
+    } catch {
+      this.writable = false;
+    }
+  }
+  filePath;
+  memory = new InMemoryEventLog();
+  writable = true;
+  record(type, data = {}) {
+    const event = this.memory.record(type, data);
+    if (this.writable) {
+      try {
+        appendFileSync(this.filePath, JSON.stringify(event) + "\n", "utf-8");
+      } catch {
+        this.writable = false;
+      }
+    }
+    return event;
+  }
+  list() {
+    if (!this.writable) return this.memory.list();
+    try {
+      const raw = readFileSync(this.filePath, "utf-8");
+      return raw.split("\n").filter(Boolean).flatMap((line) => {
+        try {
+          return [JSON.parse(line)];
+        } catch {
+          return [];
+        }
+      });
+    } catch {
+      return this.memory.list();
+    }
+  }
+  count() {
+    return this.list().length;
+  }
+  clear() {
+    this.memory.clear();
+    if (this.writable) {
+      try {
+        writeFileSync(this.filePath, "", "utf-8");
+      } catch {
+        this.writable = false;
+      }
+    }
+  }
+};
+function createEventLog() {
+  return new InMemoryEventLog();
+}
+function createFileEventLog(filePath) {
+  return new FileEventLog(filePath);
+}
+
+// src/runtime/permission-policy.ts
+var READ_ONLY_CATEGORIES = /* @__PURE__ */ new Set(["search", "web", "document"]);
+var WRITE_CATEGORIES = /* @__PURE__ */ new Set(["file", "git", "test", "build", "memory"]);
+var READ_ONLY_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "glob",
+  "read_file",
+  "list_dir",
+  "tree",
+  "grep",
+  "find_in_file",
+  "semantic_search",
+  "codebase_map",
+  "repo_context",
+  "lsp_status",
+  "lsp_document_symbols",
+  "lsp_workspace_symbols",
+  "lsp_definition",
+  "lsp_references",
+  "git_status",
+  "git_log",
+  "git_diff",
+  "git_show",
+  "git_branch",
+  "recall_memory",
+  "list_memories",
+  "list_checkpoints",
+  "spawnSimpleAgent",
+  "checkAgentCapability"
+]);
+var WRITE_CAPABLE_TOOL_NAMES = /* @__PURE__ */ new Set(["run_linter"]);
+var DESTRUCTIVE_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "bash_exec",
+  "write_file",
+  "edit_file",
+  "delete_file",
+  "restore_checkpoint",
+  "git_commit",
+  "git_push"
+]);
+function riskForTool(tool) {
+  if (READ_ONLY_TOOL_NAMES.has(tool.name)) return "read-only";
+  if (DESTRUCTIVE_TOOL_NAMES.has(tool.name)) return "destructive";
+  if (WRITE_CAPABLE_TOOL_NAMES.has(tool.name)) return "write";
+  if (tool.category === "web") return "network";
+  if (WRITE_CATEGORIES.has(tool.category)) return "write";
+  if (tool.category === "quality") return "write";
+  return "read-only";
+}
+var DefaultPermissionPolicy = class {
+  canExecuteTool(mode, tool) {
+    const definition = getAgentMode(mode);
+    const risk = riskForTool(tool);
+    const readOnlyTool = READ_ONLY_TOOL_NAMES.has(tool.name) || READ_ONLY_CATEGORIES.has(tool.category);
+    if (definition.readOnly && !readOnlyTool) {
+      return {
+        allowed: false,
+        reason: `${definition.label} mode is read-only; ${tool.name} is a ${tool.category} tool.`,
+        risk
+      };
+    }
+    if (risk === "destructive") {
+      return {
+        allowed: true,
+        requiresConfirmation: true,
+        reason: `${tool.name} can change repository state and should be confirmed.`,
+        risk
+      };
+    }
+    return { allowed: true, risk };
+  }
+  canExecuteToolInput(mode, tool, input) {
+    if (tool.name !== "run_linter") {
+      return this.canExecuteTool(mode, tool);
+    }
+    const definition = getAgentMode(mode);
+    const fixEnabled = input["fix"] === true;
+    const decision = fixEnabled ? { allowed: true, risk: "write" } : { allowed: true, risk: "read-only" };
+    if (definition.readOnly && fixEnabled) {
+      return {
+        allowed: false,
+        reason: `${definition.label} mode is read-only; run_linter with fix=true can modify files.`,
+        risk: "write"
+      };
+    }
+    return decision;
+  }
+};
+function createPermissionPolicy() {
+  return new DefaultPermissionPolicy();
+}
+
+// src/runtime/provider-registry.ts
+init_providers();
+init_catalog();
+init_runtime_capabilities();
+var ProviderRegistry = class {
+  listProviders() {
+    return Object.values(PROVIDER_CATALOG);
+  }
+  getProvider(provider) {
+    return getProviderCatalogEntry(provider);
+  }
+  listModels(provider) {
+    return this.getProvider(provider).models;
+  }
+  getModel(provider, model2) {
+    return getCatalogModel(provider, model2);
+  }
+  getDefaultModel(provider) {
+    return getCatalogDefaultModel(provider);
+  }
+  getRecommendedModel(provider) {
+    return getCatalogRecommendedModel(provider);
+  }
+  getCapability(provider, model2) {
+    return getProviderRuntimeCapability(provider, model2);
+  }
+  async createProvider(provider, config = {}) {
+    return createProvider(provider, config);
+  }
+  async probe(provider, model2, checkAvailability) {
+    return probeProviderRuntimeCapability(provider, model2, checkAvailability);
+  }
+};
+function createProviderRegistry() {
+  return new ProviderRegistry();
+}
+function createSessionId() {
+  return `rt_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
+}
+function cloneSession(session) {
+  return structuredClone(session);
+}
+var InMemoryRuntimeSessionStore = class {
+  sessions = /* @__PURE__ */ new Map();
+  create(options = {}) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const session = {
+      id: options.id ?? createSessionId(),
+      createdAt: now,
+      updatedAt: now,
+      mode: options.mode ?? "ask",
+      messages: options.messages ? options.messages.map((message) => ({ ...message })) : [],
+      instructions: options.instructions,
+      metadata: { ...options.metadata }
+    };
+    this.sessions.set(session.id, cloneSession(session));
+    return cloneSession(session);
+  }
+  get(id) {
+    const session = this.sessions.get(id);
+    return session ? cloneSession(session) : void 0;
+  }
+  update(session) {
+    const updated = {
+      ...session,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      messages: session.messages.map((message) => ({ ...message })),
+      metadata: { ...session.metadata }
+    };
+    this.sessions.set(updated.id, cloneSession(updated));
+    return cloneSession(updated);
+  }
+  list() {
+    return [...this.sessions.values()].map(cloneSession);
+  }
+  delete(id) {
+    return this.sessions.delete(id);
+  }
+};
+function createRuntimeSessionStore() {
+  return new InMemoryRuntimeSessionStore();
+}
+
+// src/runtime/workflow-registry.ts
+function cloneWorkflow(workflow) {
+  return {
+    ...workflow,
+    checks: [...workflow.checks],
+    steps: workflow.steps.map((step) => ({
+      ...step,
+      requiredTools: [...step.requiredTools]
+    }))
+  };
+}
+var WorkflowCatalog = class {
+  workflows = /* @__PURE__ */ new Map();
+  constructor(workflows = DEFAULT_WORKFLOWS) {
+    for (const workflow of workflows) {
+      this.register(workflow);
+    }
+  }
+  register(workflow) {
+    this.workflows.set(workflow.id, cloneWorkflow(workflow));
+  }
+  get(id) {
+    const workflow = this.workflows.get(id);
+    return workflow ? cloneWorkflow(workflow) : void 0;
+  }
+  list() {
+    return [...this.workflows.values()].map(cloneWorkflow).sort((a, b) => a.id.localeCompare(b.id));
+  }
+  createPlan(workflowId, input, eventLog) {
+    const workflow = this.get(workflowId);
+    if (!workflow) {
+      throw new Error(`Unknown workflow: ${workflowId}`);
+    }
+    const plan = {
+      id: `${workflowId}-${Date.now().toString(36)}`,
+      workflowId,
+      input,
+      status: "planned",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    eventLog?.record("workflow.planned", {
+      workflowId,
+      planId: plan.id,
+      replayable: workflow.replayable,
+      checks: workflow.checks
+    });
+    return plan;
+  }
+};
+var DEFAULT_WORKFLOWS = [
+  {
+    id: "architect-editor-verifier",
+    name: "Architect / Editor / Verifier",
+    description: "Plan read-only, apply approved changes, then verify and summarize risks.",
+    inputSchema: "task: string; approvedPlan?: string",
+    outputKind: "patch",
+    replayable: true,
+    checks: ["pnpm check", "diff summary", "review risks"],
+    steps: [
+      {
+        id: "architect",
+        description: "Inspect context and produce a read-only implementation plan.",
+        requiredTools: ["repo_context", "read_file", "git_diff"],
+        risk: "read-only"
+      },
+      {
+        id: "editor",
+        description: "Apply the approved plan without reinterpreting the objective.",
+        requiredTools: ["read_file", "edit_file", "write_file"],
+        risk: "write"
+      },
+      {
+        id: "verifier",
+        description: "Run checks, review diff, and report residual risk.",
+        requiredTools: ["bash_exec", "git_diff", "review_code"],
+        risk: "destructive"
+      }
+    ]
+  },
+  {
+    id: "provider-diagnosis",
+    name: "Provider Diagnosis",
+    description: "Probe provider/model capabilities, endpoint strategy, credentials, and fallbacks.",
+    inputSchema: "provider?: string; model?: string; live?: boolean",
+    outputKind: "json",
+    replayable: true,
+    checks: ["provider capability matrix", "optional live probe"],
+    steps: [
+      {
+        id: "capability",
+        description: "Resolve catalog metadata and runtime endpoint strategy.",
+        requiredTools: [],
+        risk: "read-only"
+      },
+      {
+        id: "fallbacks",
+        description: "Suggest fallback provider/model choices when unsupported.",
+        requiredTools: [],
+        risk: "read-only"
+      }
+    ]
+  },
+  {
+    id: "review-pr",
+    name: "Review PR",
+    description: "Review a branch or PR read-only and emit severity-ranked findings.",
+    inputSchema: "target: string",
+    outputKind: "markdown",
+    replayable: true,
+    checks: ["git diff", "tests gap review", "security review"],
+    steps: [
+      {
+        id: "collect-diff",
+        description: "Collect PR diff and related context.",
+        requiredTools: ["git_diff", "repo_context"],
+        risk: "read-only"
+      },
+      {
+        id: "findings",
+        description: "Produce prioritized findings with file and line references.",
+        requiredTools: ["read_file", "review_code"],
+        risk: "read-only"
+      }
+    ]
+  },
+  {
+    id: "best-of-n",
+    name: "Best Of N",
+    description: "Run multiple isolated attempts, score them, and select a winning patch.",
+    inputSchema: "task: string; attempts: number",
+    outputKind: "patch",
+    replayable: true,
+    checks: ["worktree isolation", "checks pass", "diff risk score"],
+    steps: [
+      {
+        id: "fanout",
+        description: "Create isolated attempts in temporary worktrees.",
+        requiredTools: ["git_status", "bash_exec"],
+        risk: "destructive"
+      },
+      {
+        id: "score",
+        description: "Run checks and compare quality, cost, latency, and diff risk.",
+        requiredTools: ["bash_exec", "git_diff"],
+        risk: "destructive"
+      },
+      {
+        id: "apply-winner",
+        description: "Apply the winning patch only if conservative checks pass.",
+        requiredTools: ["git_diff", "edit_file"],
+        risk: "write"
+      }
+    ]
+  },
+  {
+    id: "release",
+    name: "Release",
+    description: "Follow the project release skill: changelog, version bump, PR, merge, tag, publish verify.",
+    inputSchema: "bump?: patch|minor|major",
+    outputKind: "release",
+    replayable: true,
+    checks: ["pnpm check", "PR checks", "release.yml", "npm view"],
+    steps: [
+      {
+        id: "preflight",
+        description: "Verify branch, clean tree, GitHub auth, and remote state.",
+        requiredTools: ["git_status", "bash_exec"],
+        risk: "destructive"
+      },
+      {
+        id: "version",
+        description: "Update changelog and package versions using the release skill.",
+        requiredTools: ["read_file", "edit_file", "bash_exec"],
+        risk: "destructive"
+      },
+      {
+        id: "publish",
+        description: "Merge release PR, tag main, and verify release workflow outputs.",
+        requiredTools: ["bash_exec"],
+        risk: "destructive"
+      }
+    ]
+  }
+];
+function createWorkflowCatalog(workflows) {
+  return new WorkflowCatalog(workflows);
+}
+
+// src/runtime/workflow-engine.ts
+var WorkflowEngine = class {
+  constructor(catalog = createWorkflowCatalog(), eventLog = createEventLog()) {
+    this.catalog = catalog;
+    this.eventLog = eventLog;
+  }
+  catalog;
+  eventLog;
+  handlers = /* @__PURE__ */ new Map();
+  registerHandler(workflowId, handler) {
+    if (!this.catalog.get(workflowId)) {
+      throw new Error(`Unknown workflow: ${workflowId}`);
+    }
+    this.handlers.set(workflowId, handler);
+  }
+  createPlan(workflowId, input) {
+    return this.catalog.createPlan(workflowId, input, this.eventLog);
+  }
+  async run(request) {
+    const workflow = this.catalog.get(request.workflowId);
+    if (!workflow) {
+      throw new Error(`Unknown workflow: ${request.workflowId}`);
+    }
+    const handler = this.handlers.get(request.workflowId);
+    if (!handler) {
+      throw new Error(`No handler registered for workflow: ${request.workflowId}`);
+    }
+    const plan = request.plan ?? this.createPlan(request.workflowId, request.input);
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const runId = `${request.workflowId}-run-${Date.now().toString(36)}`;
+    this.eventLog.record("workflow.started", {
+      workflowId: request.workflowId,
+      planId: plan.id,
+      runId
+    });
+    try {
+      const output = await handler(request.input, {
+        workflow,
+        plan,
+        eventLog: this.eventLog
+      });
+      const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const result = {
+        id: runId,
+        workflowId: request.workflowId,
+        status: "completed",
+        output,
+        startedAt,
+        completedAt
+      };
+      this.eventLog.record("workflow.completed", {
+        workflowId: request.workflowId,
+        planId: plan.id,
+        runId
+      });
+      return result;
+    } catch (error) {
+      const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const message = error instanceof Error ? error.message : String(error);
+      this.eventLog.record("workflow.failed", {
+        workflowId: request.workflowId,
+        planId: plan.id,
+        runId,
+        error: message
+      });
+      return {
+        id: runId,
+        workflowId: request.workflowId,
+        status: "failed",
+        output: null,
+        startedAt,
+        completedAt,
+        error: message
+      };
+    }
+  }
+};
+function createWorkflowEngine(catalog, eventLog) {
+  return new WorkflowEngine(catalog, eventLog);
+}
+
+// src/runtime/agent-runtime.ts
+var AgentRuntime = class {
+  constructor(options) {
+    this.options = options;
+    this.providerRegistry = createProviderRegistry();
+    this.toolRegistry = options.toolRegistry ?? createFullToolRegistry();
+    this.sessionStore = options.sessionStore;
+    this.runtimeSessionStore = options.runtimeSessionStore ?? createRuntimeSessionStore();
+    this.eventLog = options.eventLog ?? (options.eventLogPath ? createFileEventLog(options.eventLogPath) : createEventLog());
+    this.workflowEngine = options.workflowEngine ?? createWorkflowEngine(void 0, this.eventLog);
+    this.permissionPolicy = options.permissionPolicy ?? createPermissionPolicy();
+    this.turnRunner = options.turnRunner ?? createDefaultRuntimeTurnRunner();
+    this.providerType = options.providerType;
+    this.model = options.model ?? options.providerConfig?.model ?? getDefaultModel(options.providerType);
+  }
+  options;
+  providerRegistry;
+  toolRegistry;
+  sessionStore;
+  runtimeSessionStore;
+  workflowEngine;
+  permissionPolicy;
+  eventLog;
+  turnRunner;
+  providerType;
+  model;
+  provider;
+  async initialize() {
+    const providerInjected = Boolean(this.options.provider);
+    const provider = this.options.provider ?? await this.providerRegistry.createProvider(this.providerType, {
+      ...this.options.providerConfig,
+      model: this.getModel()
+    });
+    this.provider = provider;
+    this.publishToGlobalBridge(provider);
+    this.eventLog.record(providerInjected ? "provider.attached" : "provider.created", {
+      provider: this.providerType,
+      model: this.getModel(),
+      createdByRuntime: !providerInjected
+    });
+    this.eventLog.record("runtime.initialized", { snapshot: this.snapshot() });
+  }
+  getModel() {
+    return this.model;
+  }
+  updateProvider(providerType, model2, provider) {
+    this.providerType = providerType;
+    this.model = model2 ?? getDefaultModel(providerType);
+    this.provider = provider;
+    this.publishToGlobalBridge(provider);
+    this.eventLog.record("provider.updated", {
+      provider: this.providerType,
+      model: this.model
+    });
+  }
+  publishToGlobalBridge(provider) {
+    if (this.options.publishToGlobalBridge !== true) return;
+    setAgentProvider(provider);
+    setAgentToolRegistry(this.toolRegistry);
+  }
+  snapshot() {
+    const capability = this.providerRegistry.getCapability(this.providerType, this.getModel());
+    const toolNames = this.toolRegistry.getAll().map((tool) => tool.name).sort();
+    return {
+      provider: {
+        type: this.providerType,
+        model: this.getModel(),
+        capability
+      },
+      tools: {
+        count: toolNames.length,
+        names: toolNames
+      },
+      modes: listAgentModes()
+    };
+  }
+  createSession(options = {}) {
+    const session = this.runtimeSessionStore.create(options);
+    this.eventLog.record("session.created", {
+      sessionId: session.id,
+      mode: session.mode,
+      metadataKeys: Object.keys(session.metadata).sort()
+    });
+    return session;
+  }
+  getSession(sessionId) {
+    return this.runtimeSessionStore.get(sessionId);
+  }
+  listSessions() {
+    return this.runtimeSessionStore.list();
+  }
+  async runTurn(input) {
+    const provider = this.provider;
+    if (!provider) {
+      throw new Error("Runtime provider is not initialized.");
+    }
+    const session = input.sessionId ? this.runtimeSessionStore.get(input.sessionId) : this.createSession({ mode: input.mode, metadata: input.metadata });
+    if (!session) {
+      throw new Error(`Runtime session not found: ${input.sessionId}`);
+    }
+    const effectiveSession = input.mode && input.mode !== session.mode ? { ...session, mode: input.mode } : session;
+    this.eventLog.record("turn.started", {
+      sessionId: effectiveSession.id,
+      provider: this.providerType,
+      model: this.getModel(),
+      mode: effectiveSession.mode,
+      runtimeApi: true
+    });
+    try {
+      const result = await this.turnRunner.run(input, {
+        runtime: this,
+        session: effectiveSession,
+        provider,
+        toolRegistry: this.toolRegistry,
+        permissionPolicy: this.permissionPolicy,
+        eventLog: this.eventLog
+      });
+      const updatedSession = this.runtimeSessionStore.update({
+        ...effectiveSession,
+        messages: [
+          ...effectiveSession.messages,
+          { role: "user", content: input.content },
+          { role: "assistant", content: result.content }
+        ]
+      });
+      this.eventLog.record("session.updated", {
+        sessionId: updatedSession.id,
+        messages: updatedSession.messages.length
+      });
+      this.eventLog.record("turn.completed", {
+        sessionId: updatedSession.id,
+        inputTokens: result.usage.inputTokens,
+        outputTokens: result.usage.outputTokens,
+        model: result.model,
+        runtimeApi: true
+      });
+      return { ...result, sessionId: updatedSession.id, mode: updatedSession.mode };
+    } catch (error) {
+      this.eventLog.record("turn.failed", {
+        sessionId: effectiveSession.id,
+        error: error instanceof Error ? error.message : String(error),
+        runtimeApi: true
+      });
+      throw error;
+    }
+  }
+  async *streamTurn(input) {
+    const provider = this.provider;
+    if (!provider) {
+      throw new Error("Runtime provider is not initialized.");
+    }
+    const session = input.sessionId ? this.runtimeSessionStore.get(input.sessionId) : this.createSession({ mode: input.mode, metadata: input.metadata });
+    if (!session) {
+      throw new Error(`Runtime session not found: ${input.sessionId}`);
+    }
+    const effectiveSession = input.mode && input.mode !== session.mode ? { ...session, mode: input.mode } : session;
+    const messages = [
+      ...effectiveSession.messages,
+      {
+        role: "user",
+        content: input.content
+      }
+    ];
+    this.eventLog.record("turn.started", {
+      sessionId: effectiveSession.id,
+      provider: this.providerType,
+      model: this.getModel(),
+      mode: effectiveSession.mode,
+      streaming: true,
+      runtimeApi: true
+    });
+    let content = "";
+    let completed = false;
+    let failed = false;
+    try {
+      for await (const chunk of provider.stream(messages, {
+        model: input.options?.model,
+        maxTokens: input.options?.maxTokens,
+        temperature: input.options?.temperature,
+        stopSequences: input.options?.stopSequences,
+        system: effectiveSession.instructions ?? input.options?.system,
+        timeout: input.options?.timeout,
+        signal: input.options?.signal,
+        thinking: input.options?.thinking
+      })) {
+        if (chunk.type === "text" && chunk.text) {
+          content += chunk.text;
+          yield {
+            type: "text",
+            sessionId: effectiveSession.id,
+            text: chunk.text
+          };
+        }
+      }
+      const updatedSession = this.runtimeSessionStore.update({
+        ...effectiveSession,
+        messages: [
+          ...effectiveSession.messages,
+          { role: "user", content: input.content },
+          { role: "assistant", content }
+        ]
+      });
+      const result = {
+        sessionId: updatedSession.id,
+        content,
+        usage: {
+          inputTokens: provider.countTokens(input.content),
+          outputTokens: provider.countTokens(content),
+          estimated: true
+        },
+        model: input.options?.model ?? this.getModel(),
+        mode: updatedSession.mode
+      };
+      this.eventLog.record("session.updated", {
+        sessionId: updatedSession.id,
+        messages: updatedSession.messages.length
+      });
+      this.eventLog.record("turn.completed", {
+        sessionId: updatedSession.id,
+        inputTokens: result.usage.inputTokens,
+        outputTokens: result.usage.outputTokens,
+        model: result.model,
+        streaming: true,
+        runtimeApi: true
+      });
+      completed = true;
+      yield { type: "done", sessionId: updatedSession.id, result };
+    } catch (error) {
+      failed = true;
+      const message = error instanceof Error ? error.message : String(error);
+      this.eventLog.record("turn.failed", {
+        sessionId: effectiveSession.id,
+        error: message,
+        streaming: true,
+        runtimeApi: true
+      });
+      yield {
+        type: "error",
+        sessionId: effectiveSession.id,
+        error: message
+      };
+    } finally {
+      if (!completed && !failed) {
+        this.eventLog.record("turn.cancelled", {
+          sessionId: effectiveSession.id,
+          outputTokens: provider.countTokens(content),
+          streaming: true,
+          runtimeApi: true
+        });
+      }
+    }
+  }
+  async executeTool(input) {
+    const startedAt = performance.now();
+    const session = input.sessionId ? this.getSession(input.sessionId) : void 0;
+    if (input.sessionId && !session) {
+      const decision2 = {
+        allowed: false,
+        reason: `Runtime session not found: ${input.sessionId}`,
+        risk: "read-only"
+      };
+      this.eventLog.record("tool.blocked", {
+        sessionId: input.sessionId,
+        mode: input.mode ?? "ask",
+        tool: input.toolName,
+        reason: decision2.reason,
+        runtimeApi: true
+      });
+      return {
+        toolName: input.toolName,
+        success: false,
+        error: decision2.reason,
+        duration: performance.now() - startedAt,
+        decision: decision2
+      };
+    }
+    const mode = input.mode ?? session?.mode ?? "ask";
+    const tool = this.toolRegistry.get(input.toolName);
+    if (!tool) {
+      const decision2 = {
+        allowed: false,
+        reason: "Tool not registered.",
+        risk: "read-only"
+      };
+      this.eventLog.record("tool.blocked", {
+        sessionId: input.sessionId,
+        mode,
+        tool: input.toolName,
+        reason: decision2.reason,
+        runtimeApi: true
+      });
+      return {
+        toolName: input.toolName,
+        success: false,
+        error: decision2.reason,
+        duration: performance.now() - startedAt,
+        decision: decision2
+      };
+    }
+    const decision = this.permissionPolicy.canExecuteToolInput ? this.permissionPolicy.canExecuteToolInput(mode, tool, input.input) : this.permissionPolicy.canExecuteTool(mode, tool);
+    if (!decision.allowed || decision.requiresConfirmation && input.confirmed !== true) {
+      const reason = decision.reason ?? (decision.requiresConfirmation ? "Tool requires explicit runtime confirmation." : "Tool is not allowed.");
+      this.eventLog.record("tool.blocked", {
+        sessionId: input.sessionId,
+        mode,
+        tool: input.toolName,
+        reason,
+        risk: decision.risk,
+        requiresConfirmation: decision.requiresConfirmation,
+        runtimeApi: true
+      });
+      return {
+        toolName: input.toolName,
+        success: false,
+        error: reason,
+        duration: performance.now() - startedAt,
+        decision
+      };
+    }
+    this.eventLog.record("tool.started", {
+      sessionId: input.sessionId,
+      mode,
+      tool: input.toolName,
+      risk: decision.risk,
+      runtimeApi: true,
+      metadataKeys: Object.keys(input.metadata ?? {}).sort()
+    });
+    const result = await this.toolRegistry.execute(input.toolName, input.input);
+    this.eventLog.record("tool.completed", {
+      sessionId: input.sessionId,
+      mode,
+      tool: input.toolName,
+      success: result.success,
+      duration: result.duration,
+      runtimeApi: true
+    });
+    return {
+      toolName: input.toolName,
+      success: result.success,
+      output: result.data,
+      error: result.error,
+      duration: result.duration,
+      decision
+    };
+  }
+  assertToolAllowed(mode, toolName, input) {
+    const tool = this.toolRegistry.get(toolName);
+    if (!tool) {
+      this.eventLog.record("tool.blocked", {
+        mode,
+        tool: toolName,
+        reason: "Tool not registered."
+      });
+      return false;
+    }
+    const decision = input && this.permissionPolicy.canExecuteToolInput ? this.permissionPolicy.canExecuteToolInput(mode, tool, input) : this.permissionPolicy.canExecuteTool(mode, tool);
+    this.eventLog.record(decision.allowed ? "tool.allowed" : "tool.blocked", {
+      mode,
+      tool: toolName,
+      ...decision
+    });
+    return decision.allowed;
+  }
+};
+async function createAgentRuntime(options) {
+  const runtime = new AgentRuntime(options);
+  await runtime.initialize();
+  return runtime;
+}
+
+// src/cli/repl/index.ts
 init_version();
 init_trust_store();
 
@@ -57854,9 +58851,15 @@ async function startRepl(options = {}) {
     loadFullAccessPreference2(),
     loadFullPowerRiskPreference2()
   ]);
-  const toolRegistry = createFullToolRegistry();
-  setAgentProvider(provider);
-  setAgentToolRegistry(toolRegistry);
+  const runtime = await createAgentRuntime({
+    providerType: internalProviderId,
+    model: session.config.provider.model || void 0,
+    provider,
+    eventLogPath: path39__default.join(projectPath, ".coco", "events", `${session.id}.jsonl`),
+    publishToGlobalBridge: true
+  });
+  session.runtime = runtime;
+  const toolRegistry = runtime.toolRegistry;
   try {
     const { createUnifiedSkillRegistry: createUnifiedSkillRegistry2 } = await Promise.resolve().then(() => (init_skills(), skills_exports));
     const { getBuiltinSkillsForDiscovery: getBuiltinSkillsForDiscovery2 } = await Promise.resolve().then(() => (init_skills2(), skills_exports2));
@@ -58040,7 +59043,7 @@ async function startRepl(options = {}) {
   let consecutiveErrors = 0;
   const AUTO_SWITCH_THRESHOLD = 2;
   const autoSwitchHistory = /* @__PURE__ */ new Set();
-  const enableAutoSwitchProvider = session.config.agent.enableAutoSwitchProvider === true;
+  const enableAutoSwitchProvider = session.config.agent?.enableAutoSwitchProvider === true;
   const buildReplayMessage = (message) => {
     if (typeof message === "string") {
       const trimmed = message.trim();
@@ -58143,7 +59146,8 @@ async function startRepl(options = {}) {
         provider = nextProvider;
         session.config.provider.type = candidate;
         session.config.provider.model = getDefaultModel(candidate);
-        setAgentProvider(provider);
+        runtime.updateProvider(nextInternalId, session.config.provider.model, provider);
+        session.runtime = runtime;
         initializeContextManager(session, provider);
         llmClassifier = createLLMClassifier2(provider);
         autoSwitchHistory.add(edge);
@@ -58205,7 +59209,12 @@ async function startRepl(options = {}) {
             project: session.config.provider.project ?? process.env["VERTEX_PROJECT"] ?? process.env["GOOGLE_CLOUD_PROJECT"] ?? process.env["GCLOUD_PROJECT"],
             location: session.config.provider.location ?? process.env["VERTEX_LOCATION"] ?? process.env["GOOGLE_CLOUD_LOCATION"]
           });
-          setAgentProvider(provider);
+          runtime.updateProvider(
+            newInternalId,
+            session.config.provider.model || void 0,
+            provider
+          );
+          session.runtime = runtime;
           initializeContextManager(session, provider);
         } catch (err) {
           session.config.provider.type = prevProviderType;
@@ -59118,9 +60127,15 @@ ${stdinContent}
     const provider = await createProvider(providerType, {
       model: session.config.provider.model || void 0
     });
-    const toolRegistry = createFullToolRegistry();
-    setAgentProvider(provider);
-    setAgentToolRegistry(toolRegistry);
+    const runtime = await createAgentRuntime({
+      providerType,
+      model: session.config.provider.model || void 0,
+      provider,
+      eventLogPath: path39__default.join(options.projectPath, ".coco", "events", `${session.id}.jsonl`),
+      publishToGlobalBridge: true
+    });
+    session.runtime = runtime;
+    const toolRegistry = runtime.toolRegistry;
     await loadAllowedPaths(options.projectPath);
     await initializeContextManager(session, provider);
     const result = await executeAgentTurn(session, task, provider, toolRegistry, {