@corbat-tech/coco 2.37.0 → 2.39.0

package/dist/index.js

@@ -1,6 +1,6 @@
 import { Logger } from 'tslog';
 import * as fs4 from 'fs';
-import fs4__default, { readFileSync, mkdirSync, appendFileSync, writeFileSync, renameSync, constants } from 'fs';
+import fs4__default, { readFileSync, mkdirSync, writeFileSync, appendFileSync, renameSync, constants } from 'fs';
 import * as path17 from 'path';
 import path17__default, { dirname, join, basename, resolve } from 'path';
 import * as fs16 from 'fs/promises';
@@ -7350,25 +7350,25 @@ var DuplicationAnalyzer = class {
         const lines = content.split("\n");
         totalLines += lines.length;
         for (let i = 0; i <= lines.length - this.minLines; i++) {
-          const chunk = lines.slice(i, i + this.minLines).join("\n").trim();
-          if (chunk.length < 20) continue;
-          if (!chunks.has(chunk)) {
-            chunks.set(chunk, []);
+          const chunk2 = lines.slice(i, i + this.minLines).join("\n").trim();
+          if (chunk2.length < 20) continue;
+          if (!chunks.has(chunk2)) {
+            chunks.set(chunk2, []);
           }
-          chunks.get(chunk).push({ file, line: i + 1 });
+          chunks.get(chunk2).push({ file, line: i + 1 });
         }
       } catch {
       }
     }
     const duplicates = [];
     let duplicateLines = 0;
-    for (const [chunk, locations] of chunks.entries()) {
+    for (const [chunk2, locations] of chunks.entries()) {
       if (locations.length > 1) {
         duplicates.push({
-          lines: chunk.split("\n"),
+          lines: chunk2.split("\n"),
           files: locations
         });
-        duplicateLines += chunk.split("\n").length * (locations.length - 1);
+        duplicateLines += chunk2.split("\n").length * (locations.length - 1);
       }
     }
     const percentage = totalLines > 0 ? duplicateLines / totalLines * 100 : 0;
@@ -15845,12 +15845,12 @@ var OpenAIProvider = class {
         ...reasoningEffort && { reasoning_effort: reasoningEffort }
       });
       let streamStopReason;
-      for await (const chunk of stream) {
-        const delta = chunk.choices[0]?.delta;
+      for await (const chunk2 of stream) {
+        const delta = chunk2.choices[0]?.delta;
         if (delta?.content) {
           yield { type: "text", text: delta.content };
         }
-        const finishReason = chunk.choices[0]?.finish_reason;
+        const finishReason = chunk2.choices[0]?.finish_reason;
         if (finishReason) {
           streamStopReason = this.mapFinishReason(finishReason);
         }
@@ -15919,8 +15919,8 @@ var OpenAIProvider = class {
       });
       try {
         let streamStopReason;
-        for await (const chunk of stream) {
-          const delta = chunk.choices[0]?.delta;
+        for await (const chunk2 of stream) {
+          const delta = chunk2.choices[0]?.delta;
           if (delta?.content || delta?.tool_calls) {
             lastActivityTime = Date.now();
           }
@@ -15958,7 +15958,7 @@ var OpenAIProvider = class {
               }
             }
           }
-          const finishReason = chunk.choices[0]?.finish_reason;
+          const finishReason = chunk2.choices[0]?.finish_reason;
           if (finishReason) {
             streamStopReason = this.mapFinishReason(finishReason);
           }
@@ -17674,12 +17674,12 @@ var GeminiProvider = class {
         config: this.buildConfig(messages, options)
       });
       let streamStopReason = "end_turn";
-      for await (const chunk of stream) {
-        const text2 = chunk.text;
+      for await (const chunk2 of stream) {
+        const text2 = chunk2.text;
         if (text2) {
           yield { type: "text", text: text2 };
         }
-        const finishReason = chunk.candidates?.[0]?.finishReason;
+        const finishReason = chunk2.candidates?.[0]?.finishReason;
         if (finishReason) {
           streamStopReason = this.mapFinishReason(finishReason);
         }
@@ -17700,12 +17700,12 @@ var GeminiProvider = class {
       let streamStopReason = "end_turn";
       let fallbackToolCounter = 0;
       const emittedToolIds = /* @__PURE__ */ new Set();
-      for await (const chunk of stream) {
-        const text2 = chunk.text;
+      for await (const chunk2 of stream) {
+        const text2 = chunk2.text;
         if (text2) {
           yield { type: "text", text: text2 };
         }
-        const toolCalls = this.extractToolCalls(chunk, { includeLegacyFunctionCalls: true });
+        const toolCalls = this.extractToolCalls(chunk2, { includeLegacyFunctionCalls: true });
         for (const toolCall of toolCalls) {
           const toolCallId = toolCall.id ?? `gemini_call_${++fallbackToolCounter}`;
           if (emittedToolIds.has(toolCallId)) continue;
@@ -17726,7 +17726,7 @@ var GeminiProvider = class {
             toolCall: normalizedToolCall
           };
         }
-        const finishReason = chunk.candidates?.[0]?.finishReason;
+        const finishReason = chunk2.candidates?.[0]?.finishReason;
         if (toolCalls.length > 0) {
           streamStopReason = "tool_use";
         } else if (finishReason) {
@@ -18069,8 +18069,8 @@ var VertexProvider = class {
     this.ensureInitialized();
     const stream = await this.streamGenerateContent(messages, options);
     let stopReason = "end_turn";
-    for await (const chunk of stream) {
-      const candidate = chunk.candidates?.[0];
+    for await (const chunk2 of stream) {
+      const candidate = chunk2.candidates?.[0];
       const parts = candidate?.content?.parts ?? [];
       for (const part of parts) {
         if (part.text) {
@@ -18092,8 +18092,8 @@ var VertexProvider = class {
     let stopReason = "end_turn";
     let streamToolCallCounter = 0;
     const emittedToolFingerprints = /* @__PURE__ */ new Set();
-    for await (const chunk of stream) {
-      const candidate = chunk.candidates?.[0];
+    for await (const chunk2 of stream) {
+      const candidate = chunk2.candidates?.[0];
       const parts = candidate?.content?.parts ?? [];
       for (const part of parts) {
         if (part.text) {
@@ -18693,9 +18693,9 @@ var ResilientProvider = class {
       }
       let emittedChunk = false;
       try {
-        for await (const chunk of createStream()) {
+        for await (const chunk2 of createStream()) {
           emittedChunk = true;
-          yield chunk;
+          yield chunk2;
         }
         this.breaker.recordSuccess();
         return;
@@ -19437,6 +19437,774 @@ z.string().regex(
 
 // src/cli/repl/agents/manager.ts
 init_logger();
+var LEGACY_ROLE_MAPPINGS = [
+  { legacy: "explore", role: "researcher", reason: "read-only codebase exploration" },
+  { legacy: "researcher", role: "researcher", reason: "legacy executor role" },
+  { legacy: "plan", role: "planner", reason: "task planning" },
+  { legacy: "planner", role: "planner", reason: "legacy executor role" },
+  { legacy: "architect", role: "architect", reason: "architecture design" },
+  { legacy: "editor", role: "editor", reason: "implementation edits" },
+  { legacy: "debug", role: "coder", reason: "debugging maps to coding capability" },
+  { legacy: "coder", role: "coder", reason: "legacy executor role" },
+  { legacy: "test", role: "tester", reason: "test authoring/execution" },
+  { legacy: "tester", role: "tester", reason: "legacy executor role" },
+  { legacy: "tdd", role: "tester", reason: "test-first implementation" },
+  { legacy: "e2e", role: "tester", reason: "end-to-end testing" },
+  { legacy: "review", role: "reviewer", reason: "code review" },
+  { legacy: "reviewer", role: "reviewer", reason: "legacy executor role" },
+  { legacy: "refactor", role: "optimizer", reason: "structure optimization" },
+  { legacy: "optimizer", role: "optimizer", reason: "legacy executor role" },
+  { legacy: "security", role: "security", reason: "security analysis" },
+  { legacy: "qa", role: "qa", reason: "quality assurance" },
+  { legacy: "integrator", role: "integrator", reason: "integration coordination" },
+  { legacy: "pm", role: "pm", reason: "product/project coordination" },
+  { legacy: "docs", role: "docs", reason: "documentation" },
+  { legacy: "database", role: "database", reason: "database work" }
+];
+var LEGACY_ROLE_MAP = new Map(LEGACY_ROLE_MAPPINGS.map((mapping) => [mapping.legacy, mapping]));
+function mapLegacyAgentRole(legacyRole, fallback = "coder") {
+  return LEGACY_ROLE_MAP.get(legacyRole)?.role ?? fallback;
+}
+function listLegacyAgentRoleMappings() {
+  return LEGACY_ROLE_MAPPINGS.map((mapping) => ({ ...mapping }));
+}
+function assertProvenance(provenance) {
+  if (!provenance.workflowRunId) {
+    throw new Error("Shared workspace writes require workflowRunId provenance.");
+  }
+}
+function snapshotFromRecords(records, role) {
+  const includeSensitive = role === void 0 || role === "security" || role === "integrator" || role === "pm";
+  const facts = /* @__PURE__ */ new Map();
+  const decisions = /* @__PURE__ */ new Map();
+  const risks = /* @__PURE__ */ new Map();
+  const files = /* @__PURE__ */ new Map();
+  const testResults = /* @__PURE__ */ new Map();
+  const artifacts = [];
+  for (const record of records) {
+    if (!includeSensitive && (record.kind === "risk" || record.provenance.risk === "secrets-sensitive")) {
+      continue;
+    }
+    switch (record.kind) {
+      case "fact":
+        facts.set(record.key, record.value);
+        break;
+      case "decision":
+        decisions.set(record.key, record.value);
+        break;
+      case "risk":
+        risks.set(record.key, record.value);
+        break;
+      case "file":
+        files.set(record.key, record.value);
+        break;
+      case "testResult":
+        testResults.set(record.key, record.value);
+        break;
+      case "artifact":
+        if (isAgentArtifact(record.value)) {
+          if (includeSensitive || record.value.kind !== "riskReport") {
+            artifacts.push(cloneArtifact(record.value));
+          }
+        }
+        break;
+    }
+  }
+  return {
+    facts: Object.fromEntries(facts),
+    decisions: Object.fromEntries(decisions),
+    risks: Object.fromEntries(risks),
+    files: Object.fromEntries(files),
+    testResults: Object.fromEntries(testResults),
+    artifacts
+  };
+}
+var InMemorySharedWorkspaceStore = class {
+  records = [];
+  write(input) {
+    assertProvenance(input.provenance);
+    const record = {
+      id: `state-${randomUUID()}`,
+      kind: input.kind,
+      key: input.key,
+      value: cloneUnknown(input.value),
+      provenance: { ...input.provenance },
+      createdAt: input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.records.push(record);
+    return cloneRecord(record);
+  }
+  list() {
+    return this.records.map(cloneRecord);
+  }
+  snapshot() {
+    return snapshotFromRecords(this.records);
+  }
+  readForRole(role) {
+    return snapshotFromRecords(this.records, role);
+  }
+  clear() {
+    this.records = [];
+  }
+};
+var FileSharedWorkspaceStore = class {
+  constructor(filePath) {
+    this.filePath = filePath;
+    try {
+      mkdirSync(dirname(filePath), { recursive: true });
+      for (const record of this.readRecordsFromDisk()) {
+        this.memory.write(record);
+      }
+    } catch {
+      this.writable = false;
+    }
+  }
+  filePath;
+  memory = new InMemorySharedWorkspaceStore();
+  writable = true;
+  write(input) {
+    const record = this.memory.write(input);
+    if (this.writable) {
+      try {
+        writeFileSync(this.filePath, JSON.stringify(this.memory.list(), null, 2), "utf-8");
+      } catch {
+        this.writable = false;
+      }
+    }
+    return record;
+  }
+  list() {
+    return this.memory.list();
+  }
+  snapshot() {
+    return this.memory.snapshot();
+  }
+  readForRole(role) {
+    return this.memory.readForRole(role);
+  }
+  clear() {
+    this.memory.clear();
+    if (this.writable) {
+      try {
+        writeFileSync(this.filePath, "[]", "utf-8");
+      } catch {
+        this.writable = false;
+      }
+    }
+  }
+  readRecordsFromDisk() {
+    try {
+      const parsed = JSON.parse(readFileSync(this.filePath, "utf-8"));
+      return Array.isArray(parsed) ? parsed.map((record) => ({
+        kind: record.kind,
+        key: record.key,
+        value: record.value,
+        provenance: record.provenance,
+        createdAt: record.createdAt
+      })) : [];
+    } catch {
+      return [];
+    }
+  }
+};
+var SharedWorkspaceState = class {
+  workflowRunId = `legacy-state-${Date.now().toString(36)}`;
+  store = new InMemorySharedWorkspaceStore();
+  facts = /* @__PURE__ */ new Map();
+  decisions = /* @__PURE__ */ new Map();
+  risks = /* @__PURE__ */ new Map();
+  files = /* @__PURE__ */ new Map();
+  testResults = /* @__PURE__ */ new Map();
+  artifacts = [];
+  writeFact(key, value) {
+    this.facts.set(key, value);
+    this.store.write({
+      kind: "fact",
+      key,
+      value,
+      provenance: { workflowRunId: this.workflowRunId }
+    });
+  }
+  recordDecision(key, value) {
+    this.decisions.set(key, value);
+    this.store.write({
+      kind: "decision",
+      key,
+      value,
+      provenance: { workflowRunId: this.workflowRunId }
+    });
+  }
+  recordRisk(key, value) {
+    this.risks.set(key, value);
+    this.store.write({
+      kind: "risk",
+      key,
+      value,
+      provenance: { workflowRunId: this.workflowRunId, risk: "secrets-sensitive" }
+    });
+  }
+  recordFile(path44, value) {
+    this.files.set(path44, value);
+    this.store.write({
+      kind: "file",
+      key: path44,
+      value,
+      provenance: { workflowRunId: this.workflowRunId }
+    });
+  }
+  recordTestResult(key, value) {
+    this.testResults.set(key, value);
+    this.store.write({
+      kind: "testResult",
+      key,
+      value,
+      provenance: { workflowRunId: this.workflowRunId }
+    });
+  }
+  addArtifact(artifact) {
+    this.artifacts.push(cloneArtifact(artifact));
+    this.store.write({
+      kind: "artifact",
+      key: artifact.id,
+      value: artifact,
+      provenance: {
+        workflowRunId: this.workflowRunId,
+        agentRunId: artifact.agentRunId,
+        taskId: artifact.taskId
+      }
+    });
+  }
+  readForRole(role) {
+    const includeSensitive = role === "security" || role === "integrator" || role === "pm";
+    return {
+      facts: Object.fromEntries(this.facts),
+      decisions: Object.fromEntries(this.decisions),
+      risks: includeSensitive ? Object.fromEntries(this.risks) : {},
+      files: Object.fromEntries(this.files),
+      testResults: Object.fromEntries(this.testResults),
+      artifacts: this.artifacts.filter((artifact) => includeSensitive || artifact.kind !== "riskReport").map(cloneArtifact)
+    };
+  }
+  snapshot() {
+    return {
+      facts: Object.fromEntries(this.facts),
+      decisions: Object.fromEntries(this.decisions),
+      risks: Object.fromEntries(this.risks),
+      files: Object.fromEntries(this.files),
+      testResults: Object.fromEntries(this.testResults),
+      artifacts: this.artifacts.map(cloneArtifact)
+    };
+  }
+  records() {
+    return this.store.list();
+  }
+};
+function evaluateAgentToolPolicy(input) {
+  const manifestEntry = input.manifest?.[input.toolName];
+  const risk = manifestEntry?.risk ?? input.capability.risk;
+  if (!input.capability.allowedTools.includes(input.toolName)) {
+    return {
+      allowed: false,
+      risk,
+      reason: `Tool '${input.toolName}' is not allowed for agent role '${input.capability.role}'.`
+    };
+  }
+  if (manifestEntry?.requiredCapability) {
+    const allowedRoles = Array.isArray(manifestEntry.requiredCapability) ? manifestEntry.requiredCapability : [manifestEntry.requiredCapability];
+    if (!allowedRoles.includes(input.capability.role)) {
+      return {
+        allowed: false,
+        risk,
+        reason: `Tool '${input.toolName}' requires role ${allowedRoles.join(", ")}.`
+      };
+    }
+  }
+  if (riskRank(risk) > riskRank(input.capability.risk)) {
+    return {
+      allowed: false,
+      risk,
+      reason: `Tool '${input.toolName}' risk '${risk}' exceeds agent capability risk '${input.capability.risk}'.`
+    };
+  }
+  return {
+    allowed: true,
+    risk,
+    requiresConsent: manifestEntry?.requiresConsent ?? (risk === "destructive" || risk === "secrets-sensitive")
+  };
+}
+function createAgentTraceContext(input = {}) {
+  return {
+    traceId: input.traceId ?? `trace-${randomUUID()}`,
+    spanId: input.spanId ?? `span-${randomUUID()}`,
+    parentSpanId: input.parentSpanId,
+    workflowRunId: input.workflowRunId,
+    agentRunId: input.agentRunId,
+    taskId: input.taskId,
+    toolCallId: input.toolCallId
+  };
+}
+var AgentGraphEngine = class {
+  eventLog;
+  sharedState;
+  nodeExecutor;
+  gateEvaluator;
+  trace;
+  constructor(options = {}) {
+    this.eventLog = options.eventLog;
+    this.sharedState = options.sharedState ?? new InMemorySharedWorkspaceStore();
+    this.nodeExecutor = options.nodeExecutor ?? defaultAgentGraphNodeExecutor;
+    this.gateEvaluator = options.gateEvaluator ?? defaultAgentGateEvaluator;
+    this.trace = options.trace ?? createAgentTraceContext();
+  }
+  async run(input) {
+    const validation = validateAgentGraph(input.graph);
+    if (!validation.valid) {
+      throw new Error(
+        `Invalid agent graph: ${validation.issues.map((issue) => issue.message).join("; ")}`
+      );
+    }
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const nodeResults = /* @__PURE__ */ new Map();
+    const artifacts = [];
+    const graphTrace = createAgentTraceContext({
+      ...this.trace,
+      workflowRunId: input.workflowRunId
+    });
+    this.eventLog?.record("agent.graph.started", {
+      workflowRunId: input.workflowRunId,
+      trace: graphTrace,
+      levels: validation.levels
+    });
+    try {
+      for (const level of validation.levels) {
+        const batches = chunk(level, input.graph.parallelism ?? level.length);
+        for (const batch of batches) {
+          const levelResults = await Promise.all(
+            batch.map(
+              (nodeId) => this.executeNode({
+                node: input.graph.nodes.find((candidate) => candidate.id === nodeId),
+                graph: input.graph,
+                workflowRunId: input.workflowRunId,
+                input: input.input,
+                graphTrace,
+                nodeResults
+              })
+            )
+          );
+          for (const result2 of levelResults) {
+            nodeResults.set(result2.taskId, result2);
+            artifacts.push(...result2.artifacts.map(cloneArtifact));
+          }
+        }
+      }
+      const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const result = {
+        id: input.workflowRunId,
+        status: "completed",
+        nodeResults: Object.fromEntries(nodeResults),
+        artifacts,
+        stateSnapshot: this.sharedState.snapshot(),
+        trace: graphTrace,
+        startedAt,
+        completedAt
+      };
+      this.eventLog?.record("agent.graph.completed", {
+        workflowRunId: input.workflowRunId,
+        trace: graphTrace,
+        nodeCount: nodeResults.size
+      });
+      return result;
+    } catch (error) {
+      const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const message = error instanceof Error ? error.message : String(error);
+      this.eventLog?.record("agent.graph.failed", {
+        workflowRunId: input.workflowRunId,
+        trace: graphTrace,
+        error: message
+      });
+      return {
+        id: input.workflowRunId,
+        status: "failed",
+        nodeResults: Object.fromEntries(nodeResults),
+        artifacts,
+        stateSnapshot: this.sharedState.snapshot(),
+        trace: graphTrace,
+        startedAt,
+        completedAt,
+        error: message
+      };
+    }
+  }
+  async executeNode(input) {
+    const attempts = input.node.retryPolicy?.maxAttempts ?? 1;
+    let lastResult;
+    for (let attempt = 1; attempt <= attempts; attempt++) {
+      const task = graphNodeToTask(input.node, input.input);
+      const trace = createAgentTraceContext({
+        traceId: input.graphTrace.traceId,
+        parentSpanId: input.graphTrace.spanId,
+        workflowRunId: input.workflowRunId,
+        taskId: task.id
+      });
+      this.eventLog?.record("agent.started", {
+        workflowRunId: input.workflowRunId,
+        nodeId: input.node.id,
+        taskId: task.id,
+        role: task.role,
+        attempt,
+        trace
+      });
+      const result = await this.nodeExecutor({
+        node: input.node,
+        task,
+        attempt,
+        workflowRunId: input.workflowRunId,
+        trace,
+        dependencyResults: input.nodeResults,
+        sharedState: this.sharedState,
+        eventLog: this.eventLog ?? NULL_EVENT_LOG
+      });
+      lastResult = result;
+      for (const artifact of result.artifacts) {
+        this.sharedState.write({
+          kind: "artifact",
+          key: artifact.id,
+          value: artifact,
+          provenance: {
+            workflowRunId: input.workflowRunId,
+            agentRunId: result.id,
+            nodeId: input.node.id,
+            taskId: task.id,
+            risk: input.node.risk
+          }
+        });
+        this.eventLog?.record("agent.artifact.created", {
+          workflowRunId: input.workflowRunId,
+          nodeId: input.node.id,
+          agentRunId: result.id,
+          artifactId: artifact.id,
+          kind: artifact.kind,
+          trace
+        });
+      }
+      if (result.success) {
+        await this.evaluateNodeGates(input.graph, input.node, result, input.workflowRunId, trace);
+        this.eventLog?.record("agent.completed", {
+          workflowRunId: input.workflowRunId,
+          nodeId: input.node.id,
+          agentRunId: result.id,
+          taskId: task.id,
+          role: result.role,
+          attempt,
+          trace
+        });
+        return result;
+      }
+      this.eventLog?.record("agent.failed", {
+        workflowRunId: input.workflowRunId,
+        nodeId: input.node.id,
+        agentRunId: result.id,
+        taskId: task.id,
+        role: result.role,
+        attempt,
+        error: result.error,
+        trace
+      });
+      if (attempt < attempts && input.node.retryPolicy?.backoffMs) {
+        await new Promise((resolve3) => setTimeout(resolve3, input.node.retryPolicy.backoffMs));
+      }
+    }
+    throw new Error(
+      `Node '${input.node.id}' failed after ${attempts} attempt(s): ${lastResult?.error ?? "unknown error"}`
+    );
+  }
+  async evaluateNodeGates(graph, node, result, workflowRunId, trace) {
+    for (const gateId of node.gates ?? []) {
+      const gate = graph.gates?.find((candidate) => candidate.id === gateId);
+      if (!gate) continue;
+      const evaluation = await this.gateEvaluator({
+        gate,
+        node,
+        result,
+        workflowRunId,
+        trace,
+        sharedState: this.sharedState,
+        eventLog: this.eventLog ?? NULL_EVENT_LOG
+      });
+      const eventType = evaluation.passed ? "workflow.gate.passed" : "workflow.gate.failed";
+      this.eventLog?.record(eventType, {
+        workflowRunId,
+        nodeId: node.id,
+        gateId: gate.id,
+        kind: gate.kind,
+        required: gate.required,
+        reason: evaluation.reason,
+        trace
+      });
+      if (!evaluation.passed && gate.required) {
+        throw new Error(
+          `Required gate '${gate.id}' failed for node '${node.id}': ${evaluation.reason ?? "no reason"}`
+        );
+      }
+    }
+  }
+};
+function createAgentGraphEngine(options) {
+  return new AgentGraphEngine(options);
+}
+function createAgentArtifact(input) {
+  return {
+    ...input,
+    id: input.id ?? `artifact-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`,
+    createdAt: input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function createSummaryArtifact(output, metadata = {}) {
+  return createAgentArtifact({
+    kind: "summary",
+    content: output,
+    title: metadata.title ?? "Agent summary",
+    agentRunId: metadata.agentRunId,
+    taskId: metadata.taskId
+  });
+}
+function normalizeAgentRunResult(input) {
+  const completedAt = input.completedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  const startedAt = input.startedAt ?? completedAt;
+  const status = input.status ?? (input.success ? "completed" : "failed");
+  const artifacts = input.artifacts && input.artifacts.length > 0 ? input.artifacts.map(cloneArtifact) : [createSummaryArtifact(input.output, { agentRunId: input.id, taskId: input.taskId })];
+  return {
+    id: input.id,
+    taskId: input.taskId,
+    role: input.role,
+    status,
+    success: input.success,
+    output: input.output,
+    artifacts,
+    toolsUsed: [...input.toolsUsed ?? []],
+    turns: input.turns ?? 0,
+    durationMs: input.durationMs ?? 0,
+    usage: input.usage,
+    error: input.error,
+    startedAt,
+    completedAt,
+    metadata: input.metadata
+  };
+}
+function validateAgentCapabilities(capability, requiredTools = []) {
+  const allowed = new Set(capability.allowedTools);
+  return requiredTools.filter((tool) => !allowed.has(tool)).map((tool) => ({
+    code: "missing-dependency",
+    message: `Tool '${tool}' is not allowed for agent role '${capability.role}'.`
+  }));
+}
+function validateAgentGraph(graph) {
+  const issues = [];
+  const nodeIds = /* @__PURE__ */ new Set();
+  const gateIds = new Set((graph.gates ?? []).map((gate) => gate.id));
+  if (graph.parallelism !== void 0 && graph.parallelism < 1) {
+    issues.push({
+      code: "invalid-parallelism",
+      message: "Graph parallelism must be greater than zero."
+    });
+  }
+  for (const node of graph.nodes) {
+    if (nodeIds.has(node.id)) {
+      issues.push({
+        code: "duplicate-node",
+        message: `Duplicate graph node '${node.id}'.`,
+        nodeId: node.id
+      });
+    }
+    nodeIds.add(node.id);
+    if (node.retryPolicy && node.retryPolicy.maxAttempts < 1) {
+      issues.push({
+        code: "invalid-retry-policy",
+        message: `Node '${node.id}' retry policy must allow at least one attempt.`,
+        nodeId: node.id
+      });
+    }
+    for (const dep of node.dependsOn ?? []) {
+      if (!nodeIds.has(dep) && !graph.nodes.some((candidate) => candidate.id === dep)) {
+        issues.push({
+          code: "missing-dependency",
+          message: `Node '${node.id}' depends on missing node '${dep}'.`,
+          nodeId: node.id
+        });
+      }
+    }
+    for (const gate of node.gates ?? []) {
+      if (!gateIds.has(gate)) {
+        issues.push({
+          code: "missing-gate",
+          message: `Node '${node.id}' references missing gate '${gate}'.`,
+          nodeId: node.id,
+          gateId: gate
+        });
+      }
+    }
+  }
+  for (const edge of graph.edges ?? []) {
+    if (!nodeIds.has(edge.from)) {
+      issues.push({
+        code: "missing-edge-node",
+        message: `Graph edge references missing source node '${edge.from}'.`,
+        nodeId: edge.from
+      });
+    }
+    if (!nodeIds.has(edge.to)) {
+      issues.push({
+        code: "missing-edge-node",
+        message: `Graph edge references missing target node '${edge.to}'.`,
+        nodeId: edge.to
+      });
+    }
+  }
+  const levels = buildExecutionLevels(graph, issues);
+  return { valid: issues.length === 0, issues, levels };
+}
+function buildExecutionLevels(graph, issues) {
+  const dependencies = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) {
+    dependencies.set(node.id, new Set(node.dependsOn ?? []));
+  }
+  for (const edge of graph.edges ?? []) {
+    if (dependencies.has(edge.to)) {
+      dependencies.get(edge.to).add(edge.from);
+    }
+  }
+  const completed = /* @__PURE__ */ new Set();
+  const levels = [];
+  while (completed.size < dependencies.size) {
+    const level = [...dependencies.entries()].filter(([id, deps]) => !completed.has(id) && [...deps].every((dep) => completed.has(dep))).map(([id]) => id);
+    if (level.length === 0) {
+      const remaining = [...dependencies.keys()].filter((id) => !completed.has(id));
+      issues.push({
+        code: "cycle",
+        message: `Graph contains a cycle involving: ${remaining.join(", ")}.`
+      });
+      return levels;
+    }
+    for (const id of level) completed.add(id);
+    levels.push(level);
+  }
+  return levels;
+}
+var NULL_EVENT_LOG = {
+  record(type, data = {}) {
+    return {
+      id: `event-${randomUUID()}`,
+      type,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      data
+    };
+  },
+  list() {
+    return [];
+  },
+  count() {
+    return 0;
+  },
+  clear() {
+  }
+};
+function graphNodeToTask(node, workflowInput) {
+  return {
+    id: node.id,
+    role: node.agentRole ?? "coder",
+    objective: node.description,
+    context: {
+      workflowInput,
+      condition: node.condition
+    },
+    dependencies: node.dependsOn,
+    constraints: node.requiredTools?.map((tool) => `Requires tool: ${tool}`)
+  };
+}
+async function defaultAgentGraphNodeExecutor(execution) {
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const dependencyOutputs = Object.fromEntries(
+    [...execution.dependencyResults.entries()].map(([id, result]) => [
+      id,
+      { success: result.success, output: result.output }
+    ])
+  );
+  const output = [
+    `Node '${execution.node.id}' executed by ${execution.task.role}.`,
+    `Objective: ${execution.task.objective}`,
+    Object.keys(dependencyOutputs).length > 0 ? `Dependencies: ${JSON.stringify(dependencyOutputs)}` : "Dependencies: none"
+  ].join("\n");
+  return normalizeAgentRunResult({
+    id: `${execution.workflowRunId}-${execution.node.id}-attempt-${execution.attempt}`,
+    taskId: execution.task.id,
+    role: execution.task.role,
+    success: true,
+    output,
+    startedAt,
+    completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    turns: 0,
+    toolsUsed: [],
+    durationMs: 0,
+    metadata: {
+      workflowRunId: execution.workflowRunId,
+      nodeId: execution.node.id,
+      trace: execution.trace,
+      simulated: true
+    }
+  });
+}
+async function defaultAgentGateEvaluator(input) {
+  if (!input.result.success) {
+    return { passed: false, reason: "Agent result was not successful." };
+  }
+  return { passed: true };
+}
+function chunk(items, size) {
+  const safeSize = Math.max(1, size);
+  const result = [];
+  for (let index = 0; index < items.length; index += safeSize) {
+    result.push(items.slice(index, index + safeSize));
+  }
+  return result;
+}
+function riskRank(risk) {
+  switch (risk) {
+    case "read-only":
+      return 0;
+    case "network":
+      return 1;
+    case "write":
+      return 2;
+    case "destructive":
+      return 3;
+    case "secrets-sensitive":
+      return 4;
+  }
+}
+function cloneUnknown(value) {
+  if (value === void 0 || value === null) return value;
+  try {
+    return JSON.parse(JSON.stringify(value));
+  } catch {
+    return value;
+  }
+}
+function cloneRecord(record) {
+  return {
+    ...record,
+    value: cloneUnknown(record.value),
+    provenance: { ...record.provenance }
+  };
+}
+function isAgentArtifact(value) {
+  return typeof value === "object" && value !== null && "id" in value && "kind" in value && "content" in value && "createdAt" in value;
+}
+function cloneArtifact(artifact) {
+  return {
+    ...artifact,
+    metadata: artifact.metadata ? { ...artifact.metadata } : void 0
+  };
+}
 
 // src/cli/repl/agents/prompts.ts
 var EXPLORE_PROMPT = `You are an exploration agent for Corbat-Coco.
@@ -20018,11 +20786,15 @@ var AgentManager = class extends EventEmitter {
       failedAgent.status = "failed";
       failedAgent.error = error;
       failedAgent.completedAt = /* @__PURE__ */ new Date();
-      return {
+      return this.buildResult({
         agent: failedAgent,
         success: false,
-        output: error
-      };
+        output: error,
+        turns: 0,
+        toolsUsed: [],
+        startedAt: failedAgent.createdAt.toISOString(),
+        usage: { inputTokens: 0, outputTokens: 0 }
+      });
     }
     const agent = this.createAgent(type, task);
     this.activeAgents.set(agent.id, agent);
@@ -20074,11 +20846,15 @@ var AgentManager = class extends EventEmitter {
       options.onStatusChange?.(agent);
       this.logger.error(`Agent ${agent.id} failed unexpectedly`, { error: errorMessage });
       this.emitEvent("fail", agent);
-      return {
+      return this.buildResult({
         agent,
         success: false,
-        output: errorMessage
-      };
+        output: errorMessage,
+        turns: 0,
+        toolsUsed: [],
+        startedAt: agent.createdAt.toISOString(),
+        usage: { inputTokens: 0, outputTokens: 0 }
+      });
     }
   }
   /**
@@ -20199,6 +20975,8 @@ var AgentManager = class extends EventEmitter {
     let finalOutput = "";
     let iteration = 0;
     const maxTurns = config.maxTurns ?? 10;
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const toolsUsed = /* @__PURE__ */ new Set();
     while (iteration < maxTurns) {
       iteration++;
       if (options.signal?.aborted) {
@@ -20207,12 +20985,15 @@ var AgentManager = class extends EventEmitter {
         agent.completedAt = /* @__PURE__ */ new Date();
         this.moveToCompleted(agent.id);
         options.onStatusChange?.(agent);
-        return {
+        return this.buildResult({
           agent,
           success: false,
           output: "Agent execution was aborted",
+          turns: iteration,
+          toolsUsed: Array.from(toolsUsed),
+          startedAt,
           usage: { inputTokens: totalInputTokens, outputTokens: totalOutputTokens }
-        };
+        });
       }
       const response = await this.provider.chatWithTools(messages, {
         system: config.systemPrompt,
@@ -20229,7 +21010,7 @@ var AgentManager = class extends EventEmitter {
         messages.push({ role: "assistant", content: response.content });
         break;
       }
-      const toolResults = await this.executeToolCalls(response.toolCalls, config);
+      const toolResults = await this.executeToolCalls(response.toolCalls, config, toolsUsed);
       const toolUses = response.toolCalls.map((tc) => ({
         type: "tool_use",
         id: tc.id,
@@ -20253,12 +21034,15 @@ var AgentManager = class extends EventEmitter {
       iterations: iteration,
       outputLength: finalOutput.length
     });
-    return {
+    return this.buildResult({
       agent,
       success: true,
       output: finalOutput,
+      turns: iteration,
+      toolsUsed: Array.from(toolsUsed),
+      startedAt,
       usage: { inputTokens: totalInputTokens, outputTokens: totalOutputTokens }
-    };
+    });
   }
   /**
    * Get tool definitions filtered for the agent's allowed tools
@@ -20271,10 +21055,11 @@ var AgentManager = class extends EventEmitter {
   /**
    * Execute tool calls and return results
    */
-  async executeToolCalls(toolCalls, config) {
+  async executeToolCalls(toolCalls, config, toolsUsed) {
     const results = [];
     const allowedTools = new Set(config.tools);
     for (const toolCall of toolCalls) {
+      toolsUsed.add(toolCall.name);
       if (!allowedTools.has(toolCall.name)) {
         results.push({
           type: "tool_result",
@@ -20315,6 +21100,33 @@ var AgentManager = class extends EventEmitter {
       this.abortControllers.delete(agentId);
     }
   }
+  buildResult(input) {
+    const structuredResult = normalizeAgentRunResult({
+      id: `${input.agent.id}-run`,
+      taskId: input.agent.id,
+      role: agentTypeToRuntimeRole(input.agent.type),
+      success: input.success,
+      output: input.output,
+      turns: input.turns,
+      toolsUsed: input.toolsUsed,
+      usage: input.usage,
+      startedAt: input.startedAt,
+      durationMs: input.agent.completedAt ? input.agent.completedAt.getTime() - input.agent.createdAt.getTime() : 0,
+      status: input.success ? "completed" : "failed",
+      error: input.success ? void 0 : input.agent.error,
+      metadata: { agentType: input.agent.type }
+    });
+    return {
+      agent: input.agent,
+      success: input.success,
+      output: input.output,
+      artifacts: structuredResult.artifacts,
+      structuredResult,
+      toolsUsed: input.toolsUsed,
+      turns: input.turns,
+      usage: input.usage
+    };
+  }
   /**
    * Emit an agent event
    */
@@ -20324,6 +21136,9 @@ var AgentManager = class extends EventEmitter {
     this.emit("agent", event);
   }
 };
+function agentTypeToRuntimeRole(type) {
+  return mapLegacyAgentRole(type);
+}
 
 // src/agents/provider-bridge.ts
 var agentProvider = null;
@@ -20355,6 +21170,140 @@ function getAgentManager() {
 
 // src/runtime/agent-runtime.ts
 init_env();
+var PUBLIC_WEB_TOOLS = /* @__PURE__ */ new Set(["search_public_docs", "list_public_services"]);
+var CUSTOMER_SUPPORT_TOOLS = /* @__PURE__ */ new Set([
+  "search_public_docs",
+  "knowledge_search",
+  "create_support_draft",
+  "request_human_escalation"
+]);
+function createNoToolRegistry() {
+  return new ToolRegistry();
+}
+function createCodingToolRegistry() {
+  return createFullToolRegistry();
+}
+function createPublicWebToolRegistry(source) {
+  return copyAllowedTools(PUBLIC_WEB_TOOLS, source);
+}
+function createCustomerSupportToolRegistry(source) {
+  return copyAllowedTools(CUSTOMER_SUPPORT_TOOLS, source);
+}
+function createSupportRagToolRegistry(options = {}) {
+  const registry = createRagToolRegistry(options.retriever);
+  if (options.supportDraft) {
+    registry.register(
+      defineTool({
+        name: "create_support_draft",
+        description: "Create a support response draft from the customer message and approved retrieved sources.",
+        category: "document",
+        parameters: z.object({
+          conversationId: z.string(),
+          customerMessage: z.string(),
+          retrievedSources: z.array(
+            z.object({
+              id: z.string(),
+              title: z.string(),
+              content: z.string(),
+              url: z.string().optional(),
+              score: z.number(),
+              metadata: z.record(z.string(), z.unknown()).optional()
+            })
+          ).optional()
+        }),
+        execute: options.supportDraft
+      })
+    );
+  }
+  if (options.humanEscalation) {
+    registry.register(
+      defineTool({
+        name: "request_human_escalation",
+        description: "Prepare a human escalation request. Runtime consumers must confirmation-gate this external action.",
+        category: "config",
+        parameters: z.object({
+          conversationId: z.string(),
+          summary: z.string(),
+          priority: z.enum(["low", "normal", "high", "urgent"]),
+          reason: z.string()
+        }),
+        execute: options.humanEscalation
+      })
+    );
+  }
+  return registry;
+}
+function createSalesIntakeToolRegistry(options = {}) {
+  const registry = new ToolRegistry();
+  if (options.leadSummary) {
+    registry.register(
+      defineTool({
+        name: "create_sales_lead_summary",
+        description: "Create a structured lead intake summary and recommended commercial next step.",
+        category: "document",
+        parameters: z.object({
+          conversationId: z.string(),
+          company: z.string().optional(),
+          contact: z.string().optional(),
+          problem: z.string(),
+          desiredOutcome: z.string().optional(),
+          urgency: z.enum(["low", "normal", "high"]).optional(),
+          budgetRange: z.string().optional(),
+          currentStack: z.string().optional()
+        }),
+        execute: options.leadSummary
+      })
+    );
+  }
+  return registry;
+}
+function createInternalOpsToolRegistry(options = {}) {
+  const registry = new ToolRegistry();
+  if (options.opsDraft) {
+    registry.register(
+      defineTool({
+        name: "create_internal_ops_draft",
+        description: "Prepare an internal operations action draft. This does not execute the operation.",
+        category: "document",
+        parameters: z.object({
+          requestId: z.string(),
+          requester: z.string().optional(),
+          workflow: z.string(),
+          requestedAction: z.string(),
+          context: z.string().optional()
+        }),
+        execute: options.opsDraft
+      })
+    );
+  }
+  return registry;
+}
+function createRagToolRegistry(retriever) {
+  const registry = new ToolRegistry();
+  if (!retriever) return registry;
+  registry.register(
+    defineTool({
+      name: "knowledge_search",
+      description: "Search the configured knowledge base and return ranked sources.",
+      category: "search",
+      parameters: z.object({
+        query: z.string(),
+        limit: z.number().optional()
+      }),
+      execute: async ({ query, limit }) => retriever.search(query, { limit })
+    })
+  );
+  return registry;
+}
+function copyAllowedTools(allowed, source) {
+  const registry = new ToolRegistry();
+  if (!source) return registry;
+  for (const name of allowed) {
+    const tool = source.get(name);
+    if (tool) registry.register(tool);
+  }
+  return registry;
+}
 init_errors();
 init_allowed_paths();
 function levenshtein(a, b) {
@@ -21450,14 +22399,14 @@ ${message}
       const subprocess = execa(command, options);
       let stdoutBuffer = "";
       let stderrBuffer = "";
-      subprocess.stdout?.on("data", (chunk) => {
-        const text2 = chunk.toString();
+      subprocess.stdout?.on("data", (chunk2) => {
+        const text2 = chunk2.toString();
         stdoutBuffer += text2;
         process.stdout.write(text2);
         heartbeat.activity();
       });
-      subprocess.stderr?.on("data", (chunk) => {
-        const text2 = chunk.toString();
+      subprocess.stderr?.on("data", (chunk2) => {
+        const text2 = chunk2.toString();
         stderrBuffer += text2;
         process.stderr.write(text2);
         heartbeat.activity();
@@ -22133,7 +23082,7 @@ var AGENT_TYPES = [
   "docs",
   "database"
 ];
-var LEGACY_ROLE_MAP = {
+var LEGACY_ROLE_MAP2 = {
   researcher: "explore",
   coder: "debug",
   // "debug" has write + bash + read — closest to general coding
@@ -22153,7 +23102,7 @@ var SpawnSimpleAgentSchema = z.object({
 });
 function resolveAgentType(input) {
   if (input.type) return input.type;
-  if (input.role && input.role in LEGACY_ROLE_MAP) return LEGACY_ROLE_MAP[input.role];
+  if (input.role && input.role in LEGACY_ROLE_MAP2) return LEGACY_ROLE_MAP2[input.role];
   return "explore";
 }
 var spawnSimpleAgentTool = defineTool({
@@ -23431,14 +24380,14 @@ ${message}
       const subprocess = execa(pm, cmdArgs, options);
       let stdoutBuffer = "";
       let stderrBuffer = "";
-      subprocess.stdout?.on("data", (chunk) => {
-        const text2 = chunk.toString();
+      subprocess.stdout?.on("data", (chunk2) => {
+        const text2 = chunk2.toString();
         stdoutBuffer += text2;
         process.stdout.write(text2);
         heartbeat.activity();
       });
-      subprocess.stderr?.on("data", (chunk) => {
-        const text2 = chunk.toString();
+      subprocess.stderr?.on("data", (chunk2) => {
+        const text2 = chunk2.toString();
         stderrBuffer += text2;
         process.stderr.write(text2);
         heartbeat.activity();
@@ -23556,14 +24505,14 @@ ${message}
       const subprocess = execa(pm, cmdArgs, options);
       let stdoutBuffer = "";
       let stderrBuffer = "";
-      subprocess.stdout?.on("data", (chunk) => {
-        const text2 = chunk.toString();
+      subprocess.stdout?.on("data", (chunk2) => {
+        const text2 = chunk2.toString();
         stdoutBuffer += text2;
         process.stdout.write(text2);
         heartbeat.activity();
       });
-      subprocess.stderr?.on("data", (chunk) => {
-        const text2 = chunk.toString();
+      subprocess.stderr?.on("data", (chunk2) => {
+        const text2 = chunk2.toString();
         stderrBuffer += text2;
         process.stderr.write(text2);
         heartbeat.activity();
@@ -23658,14 +24607,14 @@ ${message}
       const subprocess = execa("make", cmdArgs, options);
       let stdoutBuffer = "";
       let stderrBuffer = "";
-      subprocess.stdout?.on("data", (chunk) => {
-        const text2 = chunk.toString();
+      subprocess.stdout?.on("data", (chunk2) => {
+        const text2 = chunk2.toString();
         stdoutBuffer += text2;
         process.stdout.write(text2);
         heartbeat.activity();
       });
-      subprocess.stderr?.on("data", (chunk) => {
-        const text2 = chunk.toString();
+      subprocess.stderr?.on("data", (chunk2) => {
+        const text2 = chunk2.toString();
         stderrBuffer += text2;
         process.stderr.write(text2);
         heartbeat.activity();
@@ -23761,14 +24710,14 @@ ${message}
       const subprocess = execa("npx", ["tsc", ...cmdArgs], options);
       let stdoutBuffer = "";
       let stderrBuffer = "";
-      subprocess.stdout?.on("data", (chunk) => {
-        const text2 = chunk.toString();
+      subprocess.stdout?.on("data", (chunk2) => {
+        const text2 = chunk2.toString();
         stdoutBuffer += text2;
         process.stdout.write(text2);
         heartbeat.activity();
       });
-      subprocess.stderr?.on("data", (chunk) => {
-        const text2 = chunk.toString();
+      subprocess.stderr?.on("data", (chunk2) => {
+        const text2 = chunk2.toString();
         stderrBuffer += text2;
         process.stderr.write(text2);
         heartbeat.activity();
@@ -23865,14 +24814,14 @@ ${message}
       });
       let stdoutBuffer = "";
       let stderrBuffer = "";
-      subprocess.stdout?.on("data", (chunk) => {
-        const text2 = chunk.toString();
+      subprocess.stdout?.on("data", (chunk2) => {
+        const text2 = chunk2.toString();
         stdoutBuffer += text2;
         process.stdout.write(text2);
         heartbeat.activity();
       });
-      subprocess.stderr?.on("data", (chunk) => {
-        const text2 = chunk.toString();
+      subprocess.stderr?.on("data", (chunk2) => {
+        const text2 = chunk2.toString();
         stderrBuffer += text2;
         process.stderr.write(text2);
         heartbeat.activity();
@@ -23952,14 +24901,14 @@ ${message}
       });
       let stdoutBuffer = "";
       let stderrBuffer = "";
-      subprocess.stdout?.on("data", (chunk) => {
-        const text2 = chunk.toString();
+      subprocess.stdout?.on("data", (chunk2) => {
+        const text2 = chunk2.toString();
         stdoutBuffer += text2;
         process.stdout.write(text2);
         heartbeat.activity();
       });
-      subprocess.stderr?.on("data", (chunk) => {
-        const text2 = chunk.toString();
+      subprocess.stderr?.on("data", (chunk2) => {
+        const text2 = chunk2.toString();
         stderrBuffer += text2;
         process.stderr.write(text2);
         heartbeat.activity();
@@ -27167,13 +28116,13 @@ Examples:
           const content = await fs28.readFile(fullPath, "utf-8");
           if (content.length > 1e5) continue;
           const fileChunks = chunkContent(content, DEFAULT_CHUNK_SIZE);
-          for (const chunk of fileChunks) {
-            const vector = await getEmbedding(chunk.text);
+          for (const chunk2 of fileChunks) {
+            const vector = await getEmbedding(chunk2.text);
             chunks.push({
               file,
-              startLine: chunk.startLine,
-              endLine: chunk.endLine,
-              text: chunk.text,
+              startLine: chunk2.startLine,
+              endLine: chunk2.endLine,
+              text: chunk2.text,
               vector,
               mtime: stat2.mtimeMs
             });
@@ -27207,9 +28156,9 @@ Examples:
       }
     }
     const queryVector = await getEmbedding(query);
-    const scored = index.chunks.map((chunk) => ({
-      chunk,
-      score: cosineSimilarity(queryVector, chunk.vector)
+    const scored = index.chunks.map((chunk2) => ({
+      chunk: chunk2,
+      score: cosineSimilarity(queryVector, chunk2.vector)
     }));
     const filtered = scored.filter((s) => s.score >= effectiveThreshold).sort((a, b) => b.score - a.score).slice(0, effectiveMaxResults);
     const results = filtered.map((s) => {
@@ -32305,7 +33254,6 @@ var READ_ONLY_TOOL_NAMES = /* @__PURE__ */ new Set([
   "recall_memory",
   "list_memories",
   "list_checkpoints",
-  "spawnSimpleAgent",
   "checkAgentCapability"
 ]);
 var WRITE_CAPABLE_TOOL_NAMES = /* @__PURE__ */ new Set(["run_linter"]);
@@ -32316,7 +33264,8 @@ var DESTRUCTIVE_TOOL_NAMES = /* @__PURE__ */ new Set([
   "delete_file",
   "restore_checkpoint",
   "git_commit",
-  "git_push"
+  "git_push",
+  "request_human_escalation"
 ]);
 function riskForTool(tool) {
   if (READ_ONLY_TOOL_NAMES.has(tool.name)) return "read-only";
@@ -32350,6 +33299,22 @@ var DefaultPermissionPolicy = class {
     return { allowed: true, risk };
   }
   canExecuteToolInput(mode, tool, input) {
+    if (tool.name === "spawnSimpleAgent") {
+      const risk = riskForSpawnedAgent(input);
+      const definition2 = getAgentMode(mode);
+      if (definition2.readOnly && risk !== "read-only" && risk !== "network") {
+        return {
+          allowed: false,
+          reason: `${definition2.label} mode is read-only; spawnSimpleAgent with this role can perform ${risk} work.`,
+          risk
+        };
+      }
+      return {
+        allowed: true,
+        requiresConfirmation: risk === "destructive" || risk === "secrets-sensitive",
+        risk
+      };
+    }
     if (tool.name !== "run_linter") {
       return this.canExecuteTool(mode, tool);
     }
@@ -32369,6 +33334,37 @@ var DefaultPermissionPolicy = class {
 function createPermissionPolicy() {
   return new DefaultPermissionPolicy();
 }
+function riskForSpawnedAgent(input) {
+  const type = typeof input["type"] === "string" ? input["type"] : void 0;
+  const role = typeof input["role"] === "string" ? input["role"] : void 0;
+  const resolved = type ?? role;
+  switch (resolved) {
+    case "explore":
+    case "plan":
+    case "review":
+    case "architect":
+    case "security":
+    case "docs":
+    case "researcher":
+    case "reviewer":
+    case "planner":
+      return "read-only";
+    case "database":
+      return "secrets-sensitive";
+    case "test":
+    case "tdd":
+    case "e2e":
+    case "tester":
+      return "destructive";
+    case "debug":
+    case "refactor":
+    case "coder":
+    case "optimizer":
+      return "write";
+    default:
+      return "read-only";
+  }
+}
 
 // src/runtime/provider-registry.ts
 init_catalog();
@@ -32543,7 +33539,32 @@ function cloneWorkflow(workflow) {
     steps: workflow.steps.map((step) => ({
       ...step,
       requiredTools: [...step.requiredTools]
-    }))
+    })),
+    nodes: workflow.nodes?.map((node) => ({
+      ...node,
+      dependsOn: node.dependsOn ? [...node.dependsOn] : void 0,
+      requiredTools: node.requiredTools ? [...node.requiredTools] : void 0,
+      gates: node.gates ? [...node.gates] : void 0,
+      retryPolicy: node.retryPolicy ? { ...node.retryPolicy } : void 0
+    })),
+    edges: workflow.edges?.map((edge) => ({ ...edge })),
+    gates: workflow.gates?.map((gate) => ({ ...gate })),
+    retryPolicy: workflow.retryPolicy ? { ...workflow.retryPolicy } : void 0
+  };
+}
+function workflowToAgentGraph(workflow) {
+  const nodes = workflow.nodes ?? workflow.steps.map((step, index) => ({
+    id: step.id,
+    description: step.description,
+    requiredTools: [...step.requiredTools],
+    risk: step.risk,
+    dependsOn: index > 0 ? [workflow.steps[index - 1].id] : []
+  }));
+  return {
+    nodes,
+    edges: workflow.edges,
+    gates: workflow.gates,
+    parallelism: workflow.parallelism
   };
 }
 var WorkflowCatalog = class {
@@ -32554,6 +33575,12 @@ var WorkflowCatalog = class {
     }
   }
   register(workflow) {
+    const validation = validateAgentGraph(workflowToAgentGraph(workflow));
+    if (!validation.valid) {
+      throw new Error(
+        `Invalid workflow graph for '${workflow.id}': ${validation.issues.map((issue) => issue.message).join("; ")}`
+      );
+    }
     this.workflows.set(workflow.id, cloneWorkflow(workflow));
   }
   get(id) {
@@ -32579,7 +33606,8 @@ var WorkflowCatalog = class {
       workflowId,
       planId: plan.id,
       replayable: workflow.replayable,
-      checks: workflow.checks
+      checks: workflow.checks,
+      graphLevels: validateAgentGraph(workflowToAgentGraph(workflow)).levels
     });
     return plan;
   }
@@ -32729,19 +33757,26 @@ function createWorkflowRegistry(workflows) {
 
 // src/runtime/workflow-engine.ts
 var WorkflowEngine = class {
-  constructor(catalog = createWorkflowCatalog(), eventLog = createEventLog()) {
+  constructor(catalog = createWorkflowCatalog(), eventLog = createEventLog(), options = {}) {
     this.catalog = catalog;
     this.eventLog = eventLog;
+    this.sharedState = options.sharedState ?? new InMemorySharedWorkspaceStore();
+    this.nodeExecutor = options.nodeExecutor;
   }
   catalog;
   eventLog;
   handlers = /* @__PURE__ */ new Map();
+  sharedState;
+  nodeExecutor;
   registerHandler(workflowId, handler) {
     if (!this.catalog.get(workflowId)) {
       throw new Error(`Unknown workflow: ${workflowId}`);
     }
     this.handlers.set(workflowId, handler);
   }
+  registerNodeExecutor(executor) {
+    this.nodeExecutor = executor;
+  }
   createPlan(workflowId, input) {
     return this.catalog.createPlan(workflowId, input, this.eventLog);
   }
@@ -32751,23 +33786,35 @@ var WorkflowEngine = class {
       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)}`;
+    const trace = createAgentTraceContext({ workflowRunId: runId });
     this.eventLog.record("workflow.started", {
       workflowId: request.workflowId,
       planId: plan.id,
-      runId
+      runId,
+      trace
     });
     try {
-      const output = await handler(request.input, {
+      const graphResult = handler ? void 0 : await new AgentGraphEngine({
+        eventLog: this.eventLog,
+        sharedState: this.sharedState,
+        nodeExecutor: this.nodeExecutor,
+        trace
+      }).run({
+        workflowRunId: runId,
+        graph: workflowToAgentGraph(workflow),
+        input: request.input
+      });
+      const output = graphResult ?? await handler(request.input, {
         workflow,
         plan,
         eventLog: this.eventLog
       });
+      if (graphResult?.status === "failed") {
+        throw new Error(graphResult.error ?? "Workflow graph failed");
+      }
       const completedAt = (/* @__PURE__ */ new Date()).toISOString();
       const result = {
         id: runId,
@@ -32775,12 +33822,15 @@ var WorkflowEngine = class {
         status: "completed",
         output,
         startedAt,
-        completedAt
+        completedAt,
+        graphResult,
+        trace
       };
       this.eventLog.record("workflow.completed", {
         workflowId: request.workflowId,
         planId: plan.id,
-        runId
+        runId,
+        trace
       });
       return result;
     } catch (error) {
@@ -32790,7 +33840,8 @@ var WorkflowEngine = class {
         workflowId: request.workflowId,
         planId: plan.id,
         runId,
-        error: message
+        error: message,
+        trace
       });
       return {
         id: runId,
@@ -32799,13 +33850,14 @@ var WorkflowEngine = class {
         output: null,
         startedAt,
         completedAt,
-        error: message
+        error: message,
+        trace
       };
     }
   }
 };
-function createWorkflowEngine(catalog, eventLog) {
-  return new WorkflowEngine(catalog, eventLog);
+function createWorkflowEngine(catalog, eventLog, options) {
+  return new WorkflowEngine(catalog, eventLog, options);
 }
 
 // src/runtime/agent-runtime.ts
@@ -32983,7 +34035,7 @@ var AgentRuntime = class {
     let completed = false;
     let failed = false;
     try {
-      for await (const chunk of provider.stream(messages, {
+      for await (const chunk2 of provider.stream(messages, {
         model: input.options?.model,
         maxTokens: input.options?.maxTokens,
         temperature: input.options?.temperature,
@@ -32993,12 +34045,12 @@ var AgentRuntime = class {
         signal: input.options?.signal,
         thinking: input.options?.thinking
       })) {
-        if (chunk.type === "text" && chunk.text) {
-          content += chunk.text;
+        if (chunk2.type === "text" && chunk2.text) {
+          content += chunk2.text;
           yield {
             type: "text",
             sessionId: effectiveSession.id,
-            text: chunk.text
+            text: chunk2.text
           };
         }
       }
@@ -33177,6 +34229,213 @@ async function createAgentRuntime(options) {
   await runtime.initialize();
   return runtime;
 }
+
+// src/runtime/agent-runner.ts
+var AgentRunner = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  options;
+  async run(input) {
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const trace = input.trace ?? createAgentTraceContext({ taskId: input.task.id });
+    this.options.eventLog?.record("agent.started", {
+      taskId: input.task.id,
+      role: input.task.role,
+      trace
+    });
+    try {
+      const raw = await (this.options.executor ?? defaultExecutor)({
+        task: input.task,
+        capability: input.capability,
+        trace,
+        assertToolAllowed: (toolName) => {
+          const decision = evaluateAgentToolPolicy({
+            capability: input.capability,
+            toolName,
+            manifest: input.toolRiskManifest
+          });
+          this.options.eventLog?.record("agent.tool.called", {
+            taskId: input.task.id,
+            role: input.task.role,
+            toolName,
+            decision,
+            trace
+          });
+          if (!decision.allowed) {
+            throw new Error(decision.reason ?? `Tool '${toolName}' is not allowed.`);
+          }
+        }
+      });
+      const result = normalizeAgentRunResult({
+        id: `${input.task.id}-run-${Date.now().toString(36)}`,
+        taskId: input.task.id,
+        role: input.task.role,
+        success: raw.success ?? true,
+        output: raw.output,
+        turns: raw.turns,
+        toolsUsed: raw.toolsUsed,
+        usage: {
+          inputTokens: raw.inputTokens ?? 0,
+          outputTokens: raw.outputTokens ?? 0,
+          estimated: raw.inputTokens === void 0 || raw.outputTokens === void 0
+        },
+        startedAt,
+        completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        durationMs: Date.now() - Date.parse(startedAt),
+        error: raw.error,
+        metadata: { ...raw.metadata, trace }
+      });
+      this.options.eventLog?.record(result.success ? "agent.completed" : "agent.failed", {
+        taskId: input.task.id,
+        role: input.task.role,
+        agentRunId: result.id,
+        trace,
+        error: result.error
+      });
+      return result;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const result = normalizeAgentRunResult({
+        id: `${input.task.id}-run-${Date.now().toString(36)}`,
+        taskId: input.task.id,
+        role: input.task.role,
+        success: false,
+        output: message,
+        startedAt,
+        completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        durationMs: Date.now() - Date.parse(startedAt),
+        error: message,
+        metadata: { trace }
+      });
+      this.options.eventLog?.record("agent.failed", {
+        taskId: input.task.id,
+        role: input.task.role,
+        agentRunId: result.id,
+        trace,
+        error: message
+      });
+      return result;
+    }
+  }
+};
+function createAgentRunner(options) {
+  return new AgentRunner(options);
+}
+async function defaultExecutor(context) {
+  return {
+    output: `Agent ${context.capability.role} accepted task '${context.task.objective}'.`
+  };
+}
+
+// src/runtime/tool-calling-turn-runner.ts
+function runtimeWithTools(runtime) {
+  if (runtime && typeof runtime === "object" && "executeTool" in runtime && typeof runtime.executeTool === "function") {
+    return runtime;
+  }
+  throw new Error("ToolCallingRuntimeTurnRunner requires a runtime with executeTool().");
+}
+function toolResultToContent(result) {
+  if (!result.success) {
+    return `Error: ${result.error ?? "Tool failed."}`;
+  }
+  if (typeof result.output === "string") return result.output;
+  return JSON.stringify(result.output ?? null);
+}
+var ToolCallingRuntimeTurnRunner = class {
+  maxToolIterations;
+  constructor(options = {}) {
+    this.maxToolIterations = options.maxToolIterations ?? 10;
+  }
+  async run(input, context) {
+    const runtime = runtimeWithTools(context.runtime);
+    const messages = [
+      ...context.session.messages,
+      {
+        role: "user",
+        content: input.content
+      }
+    ];
+    const tools = context.toolRegistry.getToolDefinitionsForLLM();
+    const confirmedTools = new Set(input.confirmedTools ?? []);
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let lastModel = input.options?.model ?? context.provider.id;
+    for (let iteration = 0; iteration < this.maxToolIterations; iteration++) {
+      const response = await context.provider.chatWithTools(messages, {
+        tools,
+        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
+      });
+      inputTokens += response.usage.inputTokens;
+      outputTokens += response.usage.outputTokens;
+      lastModel = response.model;
+      if (response.stopReason !== "tool_use" || response.toolCalls.length === 0) {
+        return {
+          sessionId: context.session.id,
+          content: response.content,
+          usage: { inputTokens, outputTokens },
+          model: response.model,
+          mode: context.session.mode
+        };
+      }
+      const assistantContent = [];
+      if (response.content.trim().length > 0) {
+        assistantContent.push({ type: "text", text: response.content });
+      }
+      for (const toolCall of response.toolCalls) {
+        assistantContent.push({
+          type: "tool_use",
+          id: toolCall.id,
+          name: toolCall.name,
+          input: toolCall.input,
+          geminiThoughtSignature: toolCall.geminiThoughtSignature
+        });
+      }
+      messages.push({
+        role: "assistant",
+        content: assistantContent
+      });
+      const toolResults = [];
+      for (const toolCall of response.toolCalls) {
+        const result = await runtime.executeTool({
+          sessionId: context.session.id,
+          mode: context.session.mode,
+          toolName: toolCall.name,
+          input: toolCall.input,
+          confirmed: confirmedTools.has(toolCall.name),
+          metadata: input.metadata
+        });
+        toolResults.push({
+          type: "tool_result",
+          tool_use_id: toolCall.id,
+          content: toolResultToContent(result),
+          is_error: !result.success
+        });
+      }
+      messages.push({
+        role: "user",
+        content: toolResults
+      });
+    }
+    return {
+      sessionId: context.session.id,
+      content: "The tool-calling runtime reached its maximum tool iteration budget.",
+      usage: { inputTokens, outputTokens },
+      model: lastModel,
+      mode: context.session.mode
+    };
+  }
+};
+function createToolCallingRuntimeTurnRunner(options) {
+  return new ToolCallingRuntimeTurnRunner(options);
+}
 var HttpRequestError = class extends Error {
   constructor(message, status) {
     super(message);
@@ -33187,8 +34446,8 @@ var HttpRequestError = class extends Error {
 async function readJsonBody(request, maxBodyBytes) {
   const chunks = [];
   let size = 0;
-  for await (const chunk of request) {
-    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+  for await (const chunk2 of request) {
+    const buffer = Buffer.isBuffer(chunk2) ? chunk2 : Buffer.from(chunk2);
     size += buffer.length;
     if (size > maxBodyBytes) {
       throw new HttpRequestError(`Request body exceeds ${maxBodyBytes} bytes.`, 413);
@@ -33288,11 +34547,551 @@ function createMcpToolPolicy(server, tool, risk, allowedModes = ["ask", "plan",
   };
 }
 
+// src/runtime/guardrails.ts
+var DEFAULT_REDACTION = "[REDACTED]";
+var SECRET_PATTERNS = [
+  { id: "openai-api-key", pattern: /\bsk-[A-Za-z0-9_-]{20,}\b/g },
+  { id: "anthropic-api-key", pattern: /\bsk-ant-[A-Za-z0-9_-]{20,}\b/g },
+  { id: "github-token", pattern: /\bgh[pousr]_[A-Za-z0-9_]{20,}\b/g },
+  { id: "generic-bearer-token", pattern: /\bBearer\s+[A-Za-z0-9._~+/=-]{20,}\b/gi },
+  {
+    id: "private-key",
+    pattern: /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g
+  }
+];
+var PROMPT_INJECTION_PATTERNS = [
+  {
+    id: "ignore-instructions",
+    pattern: /\b(ignore|forget|override|bypass)\b.{0,60}\b(instructions|system|developer|policy|guardrail)\b/i
+  },
+  {
+    id: "reveal-prompt",
+    pattern: /\b(reveal|print|show|dump)\b.{0,40}\b(system prompt|instructions|developer message)\b/i
+  },
+  {
+    id: "tool-exfiltration",
+    pattern: /\b(use|call|run)\b.{0,40}\b(tool|shell|filesystem|git)\b.{0,40}\b(secret|token|key)\b/i
+  },
+  {
+    id: "agent-privilege-escalation",
+    pattern: /\b(spawn|delegate|handoff)\b.{0,50}\b(agent|sub.?agent)\b.{0,50}\b(admin|root|full access|unrestricted|destructive)\b/i
+  },
+  {
+    id: "credential-exfiltration",
+    pattern: /\b(exfiltrate|copy|send|upload)\b.{0,50}\b(secret|token|api key|credential|private key)\b/i
+  }
+];
+var defaultPublicGuardrails = {
+  maxInputChars: 4e3,
+  maxOutputChars: 6e3,
+  secretRedaction: { enabled: true },
+  promptInjectionDetection: true
+};
+function redactSecrets(content, config = { enabled: true }) {
+  if (!config.enabled) return { content, findings: [] };
+  let redacted = content;
+  const findings = [];
+  const replacement = config.replacement ?? DEFAULT_REDACTION;
+  for (const { id, pattern } of SECRET_PATTERNS) {
+    const before = redacted;
+    redacted = redacted.replace(pattern, replacement);
+    if (before !== redacted) {
+      findings.push({
+        id,
+        stage: "input",
+        severity: "warning",
+        message: `Potential secret redacted: ${id}`,
+        redacted: true
+      });
+    }
+  }
+  return { content: redacted, findings };
+}
+function runGuardrails(stage, content, config = {}) {
+  const findings = [];
+  const maxChars = stage === "input" ? config.maxInputChars : config.maxOutputChars;
+  let checked = content;
+  if (typeof maxChars === "number" && checked.length > maxChars) {
+    findings.push({
+      id: `${stage}-too-long`,
+      stage,
+      severity: "blocked",
+      message: `${stage} exceeds ${maxChars} characters.`
+    });
+  }
+  const redaction = redactSecrets(checked, config.secretRedaction);
+  checked = redaction.content;
+  findings.push(...redaction.findings.map((finding) => ({ ...finding, stage })));
+  if (config.promptInjectionDetection) {
+    for (const { id, pattern } of PROMPT_INJECTION_PATTERNS) {
+      if (pattern.test(checked)) {
+        findings.push({
+          id,
+          stage,
+          severity: "warning",
+          message: `Potential prompt-injection pattern detected: ${id}`
+        });
+      }
+    }
+  }
+  const blockedTopics = config.topicBoundary?.blockedTopics ?? [];
+  for (const topic of blockedTopics) {
+    if (topic && checked.toLowerCase().includes(topic.toLowerCase())) {
+      findings.push({
+        id: "blocked-topic",
+        stage,
+        severity: "blocked",
+        message: `Content mentions blocked topic: ${topic}`
+      });
+    }
+  }
+  return {
+    allowed: !findings.some((finding) => finding.severity === "blocked"),
+    content: checked,
+    findings
+  };
+}
+function validateStructuredOutput(output, schema) {
+  if (!schema) return [];
+  const result = schema.safeParse(output);
+  if (result.success) return [];
+  return [
+    {
+      id: "invalid-structured-output",
+      stage: "output",
+      severity: "blocked",
+      message: result.error.issues.map((issue) => issue.message).join("; ")
+    }
+  ];
+}
+
+// src/runtime/blueprints.ts
+function mapActionModeToRuntimeMode(mode) {
+  if (mode === "act") return "build";
+  if (mode === "review") return "review";
+  return "ask";
+}
+function createSafeToolRegistry(allowedTools, source) {
+  const safe = new ToolRegistry();
+  if (!source) return safe;
+  for (const toolName of allowedTools) {
+    const tool = source.get(toolName);
+    if (tool) safe.register(tool);
+  }
+  return safe;
+}
+async function createAgentFromBlueprint(blueprint, options) {
+  const runtime = await createAgentRuntime({
+    providerType: options.providerType,
+    model: options.model,
+    providerConfig: options.providerConfig,
+    provider: options.provider,
+    eventLog: options.eventLog,
+    turnRunner: options.turnRunner,
+    toolRegistry: options.toolRegistry ?? createSafeToolRegistry(blueprint.allowedTools.length > 0 ? blueprint.allowedTools : []),
+    publishToGlobalBridge: false
+  });
+  return {
+    blueprint,
+    runtime,
+    createSession(metadata = {}) {
+      return runtime.createSession({
+        mode: mapActionModeToRuntimeMode(blueprint.defaultMode),
+        instructions: blueprint.instructions,
+        metadata: {
+          blueprintId: blueprint.id,
+          surface: blueprint.surface,
+          ...metadata
+        }
+      });
+    },
+    async runTurn(input) {
+      const guardrails = { ...defaultPublicGuardrails, ...blueprint.guardrails };
+      const checkedInput = runGuardrails("input", input.content, guardrails);
+      runtime.eventLog.record("guardrail.input", {
+        blueprintId: blueprint.id,
+        allowed: checkedInput.allowed,
+        findings: checkedInput.findings
+      });
+      if (!checkedInput.allowed) {
+        throw new Error(formatGuardrailBlock(checkedInput.findings));
+      }
+      const result = await runtime.runTurn({
+        ...input,
+        content: checkedInput.content,
+        mode: input.mode ?? mapActionModeToRuntimeMode(blueprint.defaultMode)
+      });
+      const checkedOutput = runGuardrails("output", result.content, guardrails);
+      runtime.eventLog.record("guardrail.output", {
+        blueprintId: blueprint.id,
+        allowed: checkedOutput.allowed,
+        findings: checkedOutput.findings
+      });
+      if (!checkedOutput.allowed) {
+        throw new Error(formatGuardrailBlock(checkedOutput.findings));
+      }
+      return { ...result, content: checkedOutput.content };
+    }
+  };
+}
+function formatGuardrailBlock(findings) {
+  const messages = findings.filter((finding) => finding.severity === "blocked").map((finding) => finding.message);
+  return messages.length > 0 ? messages.join("; ") : "Guardrail blocked the request.";
+}
+function createBaseBlueprint(input) {
+  return {
+    ...input,
+    guardrails: input.guardrails ?? defaultPublicGuardrails,
+    memory: input.memory ?? { enabled: true, retention: "session" },
+    approval: input.approval ?? { requireHumanForExternalActions: true },
+    observability: input.observability ?? { logEvents: true, redactSensitiveData: true }
+  };
+}
+
+// src/runtime/rag.ts
+var InMemoryKnowledgeRetriever = class {
+  constructor(documents) {
+    this.documents = documents;
+  }
+  documents;
+  async search(query, options = {}) {
+    const terms = tokenize(query);
+    const limit = options.limit ?? 5;
+    const minScore = options.minScore ?? 0;
+    return this.documents.map((document) => ({
+      ...document,
+      score: scoreDocument(document, terms)
+    })).filter((source) => source.score >= minScore && source.score > 0).sort((a, b) => b.score - a.score).slice(0, limit);
+  }
+};
+function createInMemoryKnowledgeRetriever(documents) {
+  return new InMemoryKnowledgeRetriever(documents);
+}
+function formatRetrievedSourcesForPrompt(sources) {
+  if (sources.length === 0) return "No retrieved sources.";
+  return sources.map((source, index) => {
+    const url = source.url ? `
+URL: ${source.url}` : "";
+    return `[${index + 1}] ${source.title}${url}
+${source.content}`;
+  }).join("\n\n");
+}
+function tokenize(text2) {
+  return text2.toLowerCase().split(/[^a-z0-9áéíóúüñ]+/i).map((term) => term.trim()).filter((term) => term.length > 2);
+}
+function scoreDocument(document, terms) {
+  const haystack = `${document.title}
+${document.content}`.toLowerCase();
+  if (terms.length === 0) return 0;
+  const matches = terms.filter((term) => haystack.includes(term)).length;
+  return matches / terms.length;
+}
+
+// src/presets/index.ts
+var publicWebsiteAssistantPreset = {
+  id: "public-website-assistant",
+  name: "Public Website Assistant",
+  createBlueprint(config) {
+    return createBaseBlueprint({
+      id: "public-website-assistant",
+      name: "Public Website Assistant",
+      description: "Safe public assistant for landing pages, FAQs, service explanation, and lead intake.",
+      surface: "web",
+      defaultMode: "ask",
+      maturity: "experimental",
+      instructions: [
+        `You are the public website assistant for ${config.brand}.`,
+        "Help visitors understand services, ask concise qualification questions, and suggest a safe next step.",
+        "Do not claim that you sent messages, changed systems, booked meetings, or created records unless a registered tool result proves it.",
+        "If you are unsure, say so and offer to route the visitor to a human.",
+        config.audience ? `Primary audience: ${config.audience}.` : "",
+        config.extraInstructions ?? ""
+      ].filter(Boolean).join("\n"),
+      allowedTools: []
+    });
+  },
+  async createRuntime(config) {
+    return createPresetRuntime(config, publicWebsiteAssistantPreset.createBlueprint(config));
+  }
+};
+var ragKnowledgeAssistantPreset = {
+  id: "rag-knowledge-assistant",
+  name: "RAG Knowledge Assistant",
+  createBlueprint(config) {
+    return createBaseBlueprint({
+      id: "rag-knowledge-assistant",
+      name: "RAG Knowledge Assistant",
+      description: "Assistant that answers from a configured knowledge base and cites retrieved sources.",
+      surface: "web",
+      defaultMode: "ask",
+      maturity: "experimental",
+      instructions: [
+        `You are a knowledge assistant for ${config.brand}.`,
+        "Answer only from retrieved or approved knowledge.",
+        "Cite source titles when using retrieved content.",
+        "If the answer is not in the available knowledge, say you do not know and suggest escalation.",
+        config.extraInstructions ?? ""
+      ].filter(Boolean).join("\n"),
+      allowedTools: config.retriever ? ["knowledge_search"] : []
+    });
+  },
+  async createRuntime(config) {
+    const blueprint = ragKnowledgeAssistantPreset.createBlueprint(config);
+    return createPresetRuntime(config, blueprint, createRagToolRegistry(config.retriever));
+  }
+};
+var supportRagAssistantPreset = {
+  id: "support-rag-assistant",
+  name: "Support RAG Assistant",
+  createBlueprint(config) {
+    const allowedTools = [];
+    if (config.retriever) allowedTools.push("knowledge_search");
+    if (config.supportDraft) allowedTools.push("create_support_draft");
+    if (config.humanEscalation) allowedTools.push("request_human_escalation");
+    return createBaseBlueprint({
+      id: "support-rag-assistant",
+      name: "Support RAG Assistant",
+      description: "Support assistant that answers from approved knowledge, drafts responses, and escalates uncertain cases.",
+      surface: "web",
+      defaultMode: "draft",
+      maturity: "experimental",
+      instructions: [
+        `You are a support assistant for ${config.brand}.`,
+        "Answer only from approved retrieved knowledge.",
+        "Cite source titles when using retrieved content.",
+        "If retrieval is weak or the case is sensitive, say you are unsure and prepare an escalation.",
+        "Never claim a ticket was created, closed, or escalated unless a registered tool result proves it.",
+        config.extraInstructions ?? ""
+      ].filter(Boolean).join("\n"),
+      allowedTools,
+      approval: { requireHumanForExternalActions: true, requireHumanForSensitiveData: true }
+    });
+  },
+  async createRuntime(config) {
+    const blueprint = supportRagAssistantPreset.createBlueprint(config);
+    return createPresetRuntime(
+      config,
+      blueprint,
+      createSupportRagToolRegistry({
+        retriever: config.retriever,
+        supportDraft: config.supportDraft,
+        humanEscalation: config.humanEscalation
+      }),
+      createToolCallingRuntimeTurnRunner()
+    );
+  }
+};
+var salesIntakeAssistantPreset = {
+  id: "sales-intake-assistant",
+  name: "Sales Intake Assistant",
+  createBlueprint(config) {
+    return createBaseBlueprint({
+      id: "sales-intake-assistant",
+      name: "Sales Intake Assistant",
+      description: "Assistant for lead qualification, project context, urgency, budget, and next step capture.",
+      surface: "web",
+      defaultMode: "ask",
+      maturity: "experimental",
+      instructions: [
+        `You are the sales intake assistant for ${config.brand}.`,
+        "Collect problem, desired outcome, urgency, approximate budget, current stack, decision process, and contact preference.",
+        "Keep the conversation concise and useful. Produce a clear summary and recommended next step when enough context is available.",
+        "Do not promise pricing, timelines, or delivery commitments.",
+        "Use create_sales_lead_summary only to prepare an internal summary; do not claim a CRM record was created.",
+        config.extraInstructions ?? ""
+      ].filter(Boolean).join("\n"),
+      allowedTools: config.leadSummary ? ["create_sales_lead_summary"] : []
+    });
+  },
+  async createRuntime(config) {
+    return createPresetRuntime(
+      config,
+      salesIntakeAssistantPreset.createBlueprint(config),
+      createSalesIntakeToolRegistry({ leadSummary: config.leadSummary }),
+      createToolCallingRuntimeTurnRunner()
+    );
+  }
+};
+var customerSupportAssistantPreset = {
+  id: "customer-support-assistant",
+  name: "Customer Support Assistant",
+  createBlueprint(config) {
+    return createBaseBlueprint({
+      id: "customer-support-assistant",
+      name: "Customer Support Assistant",
+      description: "Assistant for support triage, answer drafts, and escalation recommendations.",
+      surface: "web",
+      defaultMode: "draft",
+      maturity: "experimental",
+      instructions: [
+        `You are the customer support assistant for ${config.brand}.`,
+        "Classify the issue, suggest a helpful answer, and escalate sensitive or uncertain cases to a human.",
+        "Do not close tickets or make account changes without explicit approval and a registered tool result.",
+        config.extraInstructions ?? ""
+      ].filter(Boolean).join("\n"),
+      allowedTools: []
+    });
+  },
+  async createRuntime(config) {
+    return createPresetRuntime(
+      config,
+      customerSupportAssistantPreset.createBlueprint(config),
+      createCustomerSupportToolRegistry(config.toolRegistry)
+    );
+  }
+};
+var appointmentBookingAssistantPreset = {
+  id: "appointment-booking-assistant",
+  name: "Appointment Booking Assistant",
+  createBlueprint(config) {
+    return createBaseBlueprint({
+      id: "appointment-booking-assistant",
+      name: "Appointment Booking Assistant",
+      description: "Assistant for appointment intake, availability discussion, and confirmation-gated booking.",
+      surface: "web",
+      defaultMode: "draft",
+      maturity: "experimental",
+      instructions: [
+        `You are the appointment assistant for ${config.brand}.`,
+        config.businessHours ? `Business hours: ${config.businessHours}.` : "",
+        "Collect preferred time, timezone, purpose, and contact details.",
+        "Never book, cancel, or move an appointment without explicit user confirmation and an approved tool call.",
+        config.extraInstructions ?? ""
+      ].filter(Boolean).join("\n"),
+      allowedTools: []
+    });
+  },
+  async createRuntime(config) {
+    return createPresetRuntime(config, appointmentBookingAssistantPreset.createBlueprint(config));
+  }
+};
+var internalOpsAssistantPreset = {
+  id: "internal-ops-assistant",
+  name: "Internal Ops Assistant",
+  createBlueprint(config) {
+    return createBaseBlueprint({
+      id: "internal-ops-assistant",
+      name: "Internal Ops Assistant",
+      description: "Internal automation assistant for controlled operations workflows.",
+      surface: "internal",
+      defaultMode: "draft",
+      maturity: "experimental",
+      instructions: [
+        `You are an internal operations assistant for ${config.brand}.`,
+        "Prefer drafts and summaries before actions. Ask for confirmation before external side effects.",
+        "Use create_internal_ops_draft for controlled planning only. Do not execute ERP, CRM, billing, or account changes unless a separate allowlisted tool exists.",
+        "Follow the configured tool policy and record decisions for audit.",
+        config.extraInstructions ?? ""
+      ].filter(Boolean).join("\n"),
+      allowedTools: config.opsDraft ? ["create_internal_ops_draft"] : [],
+      approval: { requireHumanForExternalActions: true, requireHumanForSensitiveData: true }
+    });
+  },
+  async createRuntime(config) {
+    return createPresetRuntime(
+      config,
+      internalOpsAssistantPreset.createBlueprint(config),
+      createInternalOpsToolRegistry({ opsDraft: config.opsDraft }),
+      createToolCallingRuntimeTurnRunner()
+    );
+  }
+};
+var codingAgentPreset = {
+  id: "coding-agent",
+  name: "Coco Coding Agent",
+  createBlueprint(config) {
+    return createBaseBlueprint({
+      id: "coding-agent",
+      name: "Coco Coding Agent",
+      description: "Coco's full coding-agent surface for trusted developer environments.",
+      surface: "cli",
+      defaultMode: "act",
+      maturity: "beta",
+      instructions: config.extraInstructions ?? "You are Coco, a coding agent for trusted repositories.",
+      allowedTools: [],
+      guardrails: { secretRedaction: { enabled: true }, promptInjectionDetection: true },
+      approval: { requireHumanForExternalActions: true, requireHumanForSensitiveData: true }
+    });
+  },
+  async createRuntime(config) {
+    return createPresetRuntime(
+      config,
+      codingAgentPreset.createBlueprint(config),
+      createCodingToolRegistry()
+    );
+  }
+};
+async function createPresetRuntime(config, blueprint, fallbackToolRegistry = createNoToolRegistry(), fallbackTurnRunner = config.turnRunner) {
+  return createAgentRuntime({
+    providerType: config.providerType,
+    model: config.model,
+    providerConfig: config.providerConfig,
+    provider: config.provider,
+    eventLog: config.eventLog,
+    turnRunner: config.turnRunner ?? fallbackTurnRunner,
+    toolRegistry: blueprint.id === "coding-agent" ? config.toolRegistry ?? fallbackToolRegistry : config.toolRegistry ? createSafeToolRegistry(blueprint.allowedTools, config.toolRegistry) : fallbackToolRegistry,
+    publishToGlobalBridge: false
+  });
+}
+var AGENT_PRESETS = [
+  publicWebsiteAssistantPreset,
+  ragKnowledgeAssistantPreset,
+  supportRagAssistantPreset,
+  salesIntakeAssistantPreset,
+  customerSupportAssistantPreset,
+  appointmentBookingAssistantPreset,
+  internalOpsAssistantPreset,
+  codingAgentPreset
+];
+
+// src/adapters/index.ts
+function createHttpAssistantAdapter(runtime) {
+  return {
+    createSession(metadata = {}) {
+      const session = runtime.createSession({ mode: "ask", metadata });
+      return { sessionId: session.id };
+    },
+    async handleMessage(input) {
+      const sessionId = input.sessionId ?? runtime.createSession({ mode: "ask", metadata: input.metadata }).id;
+      const result = await runtime.runTurn({
+        sessionId,
+        content: input.content,
+        metadata: input.metadata
+      });
+      return { sessionId, content: result.content, metadata: { model: result.model } };
+    }
+  };
+}
+function createStreamingHttpAssistantAdapter(runtime) {
+  const base = createHttpAssistantAdapter(runtime);
+  return {
+    ...base,
+    async *streamMessage(input) {
+      const sessionId = input.sessionId ?? runtime.createSession({ mode: "ask", metadata: input.metadata }).id;
+      yield* runtime.streamTurn({
+        sessionId,
+        content: input.content,
+        metadata: input.metadata
+      });
+    }
+  };
+}
+function createWebhookAssistantAdapter(runtime, options = {}) {
+  return {
+    id: options.id ?? "webhook-assistant",
+    surface: options.surface ?? "api",
+    async handle(input) {
+      const adapter = createHttpAssistantAdapter(runtime);
+      return adapter.handleMessage(input);
+    }
+  };
+}
+
 // src/index.ts
 init_errors();
 init_logger();
 init_proxy();
 
-export { ADRGenerator, AGENT_MODES, AgentRuntime, AnthropicProvider, ArchitectureGenerator, BacklogGenerator, CICDGenerator, CocoError, CodeGenerator, CodeReviewer, CompleteExecutor, ConfigError, ConvergeExecutor, DEFAULT_WORKFLOWS, DefaultPermissionPolicy, DefaultRuntimeTurnRunner, DiscoveryEngine, DockerGenerator, DocsGenerator, FileEventLog, FileRuntimeSessionStore, InMemoryEventLog, InMemoryRuntimeSessionStore, OrchestrateExecutor, OutputExecutor, PhaseError, ProviderRegistry, SessionManager, SpecificationGenerator, TaskError, TaskIterator, ToolRegistry, VERSION, WorkflowCatalog, WorkflowEngine, WorkflowRegistry, configExists, createADRGenerator, createAgentRuntime, createAnthropicProvider, createArchitectureGenerator, createBacklogGenerator, createCICDGenerator, createCodeGenerator, createCodeReviewer, createCompleteExecutor, createConvergeExecutor, createDefaultConfig, createDefaultRuntimeTurnRunner, createDiscoveryEngine, createDockerGenerator, createDocsGenerator, createEventLog, createFileEventLog, createFileRuntimeSessionStore, createFullToolRegistry, createLogger, createMcpToolPolicy, createOrchestrateExecutor, createOrchestrator, createOutputExecutor, createPermissionPolicy, createProvider, createProviderRegistry, createRuntimeHttpServer, createRuntimeSessionStore, createSessionManager, createSpecificationGenerator, createTaskIterator, createToolRegistry, createWorkflowCatalog, createWorkflowEngine, createWorkflowRegistry, getAgentMode, installProxyDispatcher, isAgentMode, listAgentModes, loadConfig, registerAllTools, saveConfig };
+export { ADRGenerator, AGENT_MODES, AGENT_PRESETS, AgentGraphEngine, AgentRunner, AgentRuntime, AnthropicProvider, ArchitectureGenerator, BacklogGenerator, CICDGenerator, CocoError, CodeGenerator, CodeReviewer, CompleteExecutor, ConfigError, ConvergeExecutor, DEFAULT_WORKFLOWS, DefaultPermissionPolicy, DefaultRuntimeTurnRunner, DiscoveryEngine, DockerGenerator, DocsGenerator, FileEventLog, FileRuntimeSessionStore, FileSharedWorkspaceStore, InMemoryEventLog, InMemoryKnowledgeRetriever, InMemoryRuntimeSessionStore, InMemorySharedWorkspaceStore, OrchestrateExecutor, OutputExecutor, PhaseError, ProviderRegistry, SessionManager, SharedWorkspaceState, SpecificationGenerator, TaskError, TaskIterator, ToolCallingRuntimeTurnRunner, ToolRegistry, VERSION, WorkflowCatalog, WorkflowEngine, WorkflowRegistry, appointmentBookingAssistantPreset, codingAgentPreset, configExists, createADRGenerator, createAgentArtifact, createAgentFromBlueprint, createAgentGraphEngine, createAgentRunner, createAgentRuntime, createAgentTraceContext, createAnthropicProvider, createArchitectureGenerator, createBacklogGenerator, createBaseBlueprint, createCICDGenerator, createCodeGenerator, createCodeReviewer, createCodingToolRegistry, createCompleteExecutor, createConvergeExecutor, createCustomerSupportToolRegistry, createDefaultConfig, createDefaultRuntimeTurnRunner, createDiscoveryEngine, createDockerGenerator, createDocsGenerator, createEventLog, createFileEventLog, createFileRuntimeSessionStore, createFullToolRegistry, createHttpAssistantAdapter, createInMemoryKnowledgeRetriever, createLogger, createMcpToolPolicy, createNoToolRegistry, createOrchestrateExecutor, createOrchestrator, createOutputExecutor, createPermissionPolicy, createProvider, createProviderRegistry, createPublicWebToolRegistry, createRagToolRegistry, createRuntimeHttpServer, createRuntimeSessionStore, createSafeToolRegistry, createSessionManager, createSpecificationGenerator, createStreamingHttpAssistantAdapter, createSummaryArtifact, createSupportRagToolRegistry, createTaskIterator, createToolCallingRuntimeTurnRunner, createToolRegistry, createWebhookAssistantAdapter, createWorkflowCatalog, createWorkflowEngine, createWorkflowRegistry, customerSupportAssistantPreset, defaultPublicGuardrails, evaluateAgentToolPolicy, formatRetrievedSourcesForPrompt, getAgentMode, installProxyDispatcher, internalOpsAssistantPreset, isAgentMode, listAgentModes, listLegacyAgentRoleMappings, loadConfig, mapActionModeToRuntimeMode, mapLegacyAgentRole, normalizeAgentRunResult, publicWebsiteAssistantPreset, ragKnowledgeAssistantPreset, redactSecrets, registerAllTools, runGuardrails, salesIntakeAssistantPreset, saveConfig, supportRagAssistantPreset, validateAgentCapabilities, validateAgentGraph, validateStructuredOutput, workflowToAgentGraph };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map