@cognipeer/agent-sdk 0.3.1 → 0.4.0

package/dist/index.cjs

@@ -6,6 +6,7 @@ var fs = require('fs');
 var path = require('path');
 var buffer = require('buffer');
 var nanoid = require('nanoid');
+var crypto = require('crypto');
 var AjvModule = require('ajv');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
@@ -13,6 +14,7 @@ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var fs__default = /*#__PURE__*/_interopDefault(fs);
 var path__default = /*#__PURE__*/_interopDefault(path);
+var crypto__default = /*#__PURE__*/_interopDefault(crypto);
 var AjvModule__default = /*#__PURE__*/_interopDefault(AjvModule);
 
 // src/adapters/langchain.ts
@@ -224,7 +226,8 @@ function createTool({
   func,
   needsApproval,
   approvalPrompt,
-  approvalDefaults
+  approvalDefaults,
+  maxExecutionsPerRun
 }) {
   const execute = async (input) => func(input);
   const toolRecord = {
@@ -246,25 +249,45 @@ function createTool({
   if (approvalDefaults !== void 0) {
     toolRecord.approvalDefaults = approvalDefaults;
   }
+  if (maxExecutionsPerRun !== void 0) {
+    toolRecord.maxExecutionsPerRun = maxExecutionsPerRun;
+  }
   toolRecord.__source = toolRecord.__source || "smart";
   toolRecord.__impl = func;
   return toolRecord;
 }
 
 // src/prompts.ts
-function buildSystemPrompt(extra, planning, name = "Agent") {
-  const extraTrimmed = extra?.trim();
-  const agentHeader = `Agent Name: ${name}`;
-  const planningBlock = planning ? `<planning>
-PLANNING IS MANDATORY.
+var DEFAULT_TODO_LIST_PROMPT = `Planning tools are available when they materially improve execution.
 
 Rules:
-1) Your FIRST action in every task is a single call to the tool "manage_todo_list" with operation="write" and a full, ordered plan (1+ items). Even for trivial tasks, write a one-item plan.
-2) After every non-planning tool call, you MUST immediately call "manage_todo_list" with operation="write" (or re-write) to update statuses and append one-line evidence on the affected item only.
-3) Keep exactly ONE item "in-progress" at any time; all others are "not-started" or "completed".
-4) Never reveal the plan text. Never summarize the plan in the assistant messages.
-5) If you ever produce an assistant message without having written a plan in this session, STOP and first write the plan via "manage_todo_list".
-</planning>` : "";
+1) Use "manage_todo_list" for multi-step work, delegation, recovery after a failed attempt, or when the user explicitly asks for a plan.
+2) Do NOT create a plan for direct Q&A, simple recall from existing context, or a single straightforward tool lookup unless the user asks for one.
+3) If a task is multi-step and no valid plan exists yet, create one before substantial execution.
+4) Use operation="write" only to create or fully replace the entire plan. After a plan exists, default to operation="update" for progress, evidence, status, owner changes, blockers, or reprioritization.
+5) When using operation="update", send only the changed items. Do not resend unchanged plan items unless the whole plan structure is being rewritten.
+6) Include expectedVersion from the latest successful plan state whenever you update an existing plan. If you do not know the latest version, read the plan first.
+7) Keep exactly ONE item "in-progress" at a time.
+8) Update the plan whenever a step starts, completes, becomes blocked, fails, or the approach changes. Do not finish a multi-step task with stale plan state.
+9) If tool results materially change the task state, sync the plan before the final answer.
+10) Reuse prior tool results already present in the conversation before calling tools again.
+11) If an update fails because of a version mismatch, read the latest plan and retry instead of blindly rewriting it.
+12) Repeating full operation="write" calls for the same plan is a mistake unless the plan structure itself changed.
+13) Keep the plan internal unless the user explicitly asks to see it.`;
+function buildPlanningBlock(todoListPrompt) {
+  const promptBody = todoListPrompt?.trim() || DEFAULT_TODO_LIST_PROMPT;
+  if (promptBody.startsWith("<planning>")) {
+    return promptBody;
+  }
+  return `<planning>
+${promptBody}
+</planning>`;
+}
+function buildSystemPrompt(extra, planning, name = "Agent", todoListPrompt) {
+  const extraTrimmed = extra?.trim();
+  const agentHeader = `Agent Name: ${name}`;
+  const planningMode = typeof planning === "string" ? planning : planning ? "todo" : "off";
+  const planningBlock = planningMode !== "off" ? buildPlanningBlock(todoListPrompt) : "";
   return [
     agentHeader,
     "You are an advanced AI agent that is concise, accurate, and helpful.",
@@ -376,6 +399,9 @@ function cognipeerSink(first, second) {
 function httpSink(url, headers) {
   return { type: "http", url, headers };
 }
+function otlpSink(endpoint, headers) {
+  return { type: "otlp", endpoint, headers };
+}
 function resolveLogsBaseDir(customPath, ensureDirectory = true) {
   const root = process.cwd();
   const base = customPath && customPath.trim().length > 0 ? customPath : path__default.default.join(root, "logs");
@@ -575,6 +601,14 @@ function resolveSink(sink) {
       const headers = candidate.headers ? { ...candidate.headers } : void 0;
       return headers ? { type: "http", url, headers } : { type: "http", url };
     }
+    case "otlp": {
+      const endpoint = typeof candidate.endpoint === "string" ? candidate.endpoint.trim() : "";
+      if (!endpoint) {
+        throw new Error("otlp sink requires a non-empty endpoint");
+      }
+      const headers = candidate.headers ? { ...candidate.headers } : void 0;
+      return headers ? { type: "otlp", endpoint, headers } : { type: "otlp", endpoint };
+    }
     default: {
       if (typeof console !== "undefined" && typeof console.warn === "function") {
         console.warn("Unknown tracing sink type. Falling back to file sink.", candidate);
@@ -594,6 +628,8 @@ function snapshotSink(runtime) {
       return { type: "cognipeer", url: sink.url };
     case "http":
       return { type: "http", url: sink.url };
+    case "otlp":
+      return { type: "otlp", endpoint: sink.endpoint };
     default:
       return { type: "custom" };
   }
@@ -744,6 +780,202 @@ async function postStreamingSessionEnd(baseUrl, headers, payload) {
     throw err;
   }
 }
+function isoToUnixNano(iso) {
+  const ms = new Date(iso).getTime();
+  return `${ms}000000`;
+}
+function toOtlpStatusCode(status) {
+  if (status === "error") return 2;
+  if (status === "success" || status === "completed") return 1;
+  return 0;
+}
+function toOtlpSpanKind(type) {
+  switch (type) {
+    case "ai_call":
+      return 3;
+    // CLIENT — outgoing LLM request
+    case "tool_call":
+      return 1;
+    // INTERNAL
+    case "agent_iteration":
+      return 1;
+    // INTERNAL
+    default:
+      return 1;
+  }
+}
+function stringAttr(key, val) {
+  return val != null ? { key, value: { stringValue: val } } : null;
+}
+function intAttr(key, val) {
+  return val != null && !Number.isNaN(val) ? { key, value: { intValue: String(val) } } : null;
+}
+function doubleAttr(key, val) {
+  return val != null && !Number.isNaN(val) ? { key, value: { doubleValue: val } } : null;
+}
+function eventToOtlpSpan(event) {
+  const startNano = isoToUnixNano(event.timestamp);
+  const endNano = event.durationMs != null ? `${new Date(new Date(event.timestamp).getTime() + event.durationMs).getTime()}000000` : startNano;
+  const attrs = [
+    stringAttr("cognipeer.event.type", event.type),
+    stringAttr("cognipeer.event.label", event.label),
+    intAttr("cognipeer.event.sequence", event.sequence),
+    stringAttr("cognipeer.actor.scope", event.actor?.scope),
+    stringAttr("cognipeer.actor.name", event.actor?.name),
+    stringAttr("cognipeer.actor.role", event.actor?.role),
+    stringAttr("cognipeer.model", event.model),
+    stringAttr("cognipeer.provider", event.provider),
+    intAttr("cognipeer.tokens.input", event.inputTokens),
+    intAttr("cognipeer.tokens.output", event.outputTokens),
+    intAttr("cognipeer.tokens.total", event.totalTokens),
+    intAttr("cognipeer.tokens.cached_input", event.cachedInputTokens),
+    intAttr("cognipeer.bytes.request", event.requestBytes),
+    intAttr("cognipeer.bytes.response", event.responseBytes),
+    stringAttr("cognipeer.tool.execution_id", event.toolExecutionId),
+    stringAttr("cognipeer.retry_of", event.retryOf),
+    stringAttr("cognipeer.event.id", event.id)
+  ].filter(Boolean);
+  if (event.data?.sections && event.data.sections.length > 0) {
+    try {
+      attrs.push({ key: "cognipeer.sections", value: { stringValue: JSON.stringify(event.data.sections) } });
+    } catch {
+    }
+  }
+  const span = {
+    traceId: event.traceId,
+    spanId: event.spanId,
+    parentSpanId: event.parentSpanId || "",
+    name: event.label || event.type,
+    kind: toOtlpSpanKind(event.type),
+    startTimeUnixNano: startNano,
+    endTimeUnixNano: endNano,
+    attributes: attrs,
+    status: {
+      code: toOtlpStatusCode(event.status),
+      ...event.status === "error" && event.error?.message ? { message: event.error.message } : {}
+    }
+  };
+  if (event.error) {
+    span.events = [{
+      timeUnixNano: startNano,
+      name: "exception",
+      attributes: [
+        { key: "exception.message", value: { stringValue: event.error.message } },
+        ...event.error.stack ? [{ key: "exception.stacktrace", value: { stringValue: event.error.stack } }] : []
+      ]
+    }];
+  }
+  return span;
+}
+function traceSessionToOtlp(session) {
+  const traceId = session.traceId || generateTraceId();
+  const rootSpanId = session.rootSpanId || generateSpanId();
+  const startNano = isoToUnixNano(session.startedAt);
+  const endNano = session.endedAt ? isoToUnixNano(session.endedAt) : startNano;
+  const resourceAttrs = [
+    { key: "service.name", value: { stringValue: session.agent?.name || "cognipeer-agent" } },
+    stringAttr("service.version", session.agent?.version),
+    stringAttr("cognipeer.session.id", session.sessionId),
+    stringAttr("cognipeer.thread.id", session.threadId),
+    stringAttr("cognipeer.agent.model", session.agent?.model),
+    stringAttr("cognipeer.agent.provider", session.agent?.provider)
+  ].filter(Boolean);
+  const rootAttrs = [
+    stringAttr("cognipeer.session.status", session.status),
+    doubleAttr("cognipeer.session.duration_ms", session.durationMs),
+    intAttr("cognipeer.session.total_input_tokens", session.summary.totalInputTokens),
+    intAttr("cognipeer.session.total_output_tokens", session.summary.totalOutputTokens),
+    intAttr("cognipeer.session.total_cached_input_tokens", session.summary.totalCachedInputTokens),
+    intAttr("cognipeer.session.total_bytes_in", session.summary.totalBytesIn),
+    intAttr("cognipeer.session.total_bytes_out", session.summary.totalBytesOut),
+    intAttr("cognipeer.session.event_count", session.events.length)
+  ].filter(Boolean);
+  if (session.summary.eventCounts) {
+    for (const [key, count] of Object.entries(session.summary.eventCounts)) {
+      rootAttrs.push({ key: `cognipeer.session.event_count.${key}`, value: { intValue: String(count) } });
+    }
+  }
+  const rootSpan = {
+    traceId,
+    spanId: rootSpanId,
+    parentSpanId: "",
+    name: `agent_session: ${session.agent?.name || "agent"}`,
+    kind: 1,
+    // INTERNAL
+    startTimeUnixNano: startNano,
+    endTimeUnixNano: endNano,
+    attributes: rootAttrs,
+    status: {
+      code: toOtlpStatusCode(session.status),
+      ...session.status === "error" && session.errors.length > 0 ? { message: session.errors.map((e) => e.message).join("; ") } : {}
+    }
+  };
+  if (session.errors.length > 0) {
+    rootSpan.events = session.errors.map((err) => ({
+      timeUnixNano: err.timestamp ? isoToUnixNano(err.timestamp) : startNano,
+      name: "exception",
+      attributes: [
+        { key: "exception.message", value: { stringValue: err.message } },
+        ...err.stack ? [{ key: "exception.stacktrace", value: { stringValue: err.stack } }] : [],
+        ...err.type ? [{ key: "exception.type", value: { stringValue: err.type } }] : []
+      ]
+    }));
+  }
+  const childSpans = session.events.map((event) => {
+    const span = eventToOtlpSpan({
+      ...event,
+      traceId: event.traceId || traceId,
+      spanId: event.spanId || generateSpanId(),
+      parentSpanId: event.parentSpanId || rootSpanId
+    });
+    return span;
+  });
+  return {
+    resourceSpans: [{
+      resource: { attributes: resourceAttrs },
+      scopeSpans: [{
+        scope: {
+          name: "cognipeer-agent-sdk",
+          version: "1.0.0"
+        },
+        spans: [rootSpan, ...childSpans]
+      }]
+    }]
+  };
+}
+async function postOtlpTraces(endpoint, headers, payload) {
+  const fetchFn = typeof globalThis.fetch === "function" ? globalThis.fetch.bind(globalThis) : void 0;
+  if (!fetchFn) {
+    throw new Error("OTLP sink requires fetch to be available in this runtime.");
+  }
+  const finalHeaders = {
+    "content-type": "application/json",
+    ...headers || {}
+  };
+  try {
+    const response = await fetchFn(endpoint, {
+      method: "POST",
+      headers: finalHeaders,
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      let responseText = "";
+      try {
+        responseText = await response.text();
+      } catch {
+      }
+      const statusLine = `HTTP ${response.status}${response.statusText ? ` ${response.statusText}` : ""}`;
+      const bodyPreview = responseText ? ` - ${responseText.slice(0, 200)}` : "";
+      throw new Error(`${statusLine}${bodyPreview}`);
+    }
+  } catch (err) {
+    const errMsg = err instanceof Error ? err.message : String(err);
+    if (typeof console !== "undefined" && typeof console.error === "function") {
+      console.error("[Tracing] OTLP export failed:", errMsg);
+    }
+    throw err;
+  }
+}
 function createEmptySummary() {
   return {
     totalDurationMs: 0,
@@ -761,6 +993,12 @@ function generateSessionId() {
 function generateEventId(sequence) {
   return `evt_${String(sequence).padStart(4, "0")}_${nanoid.nanoid(4)}`;
 }
+function generateTraceId() {
+  return crypto__default.default.randomBytes(16).toString("hex");
+}
+function generateSpanId() {
+  return crypto__default.default.randomBytes(8).toString("hex");
+}
 function defaultEventLabel(type) {
   switch (type) {
     case "ai_call":
@@ -913,8 +1151,12 @@ function createTraceSession(opts) {
   const cfg = withDefaults(opts.tracing);
   if (!cfg.enabled) return void 0;
   const sessionId = generateSessionId();
+  const traceId = generateTraceId();
+  const rootSpanId = generateSpanId();
   const runtime = {
     sessionId,
+    traceId,
+    rootSpanId,
     threadId: opts.tracing?.threadId,
     startedAt: Date.now(),
     resolvedConfig: cfg,
@@ -1024,8 +1266,13 @@ function recordTraceEvent(session, event) {
   const resolvedModel = event.model ?? inferModelFromMessages(event.messageList);
   const resolvedProvider = event.provider ?? inferProviderFromMessages(event.messageList);
   const isAiCall = event.type === "ai_call";
+  const spanId = generateSpanId();
+  const parentSpanId = event.parentSpanId || session.currentIterationSpanId || session.rootSpanId;
   const record = {
     sessionId: session.sessionId,
+    traceId: session.traceId,
+    spanId,
+    parentSpanId,
     id,
     type: event.type,
     label: eventLabel,
@@ -1132,6 +1379,8 @@ async function finalizeTraceSession(session, params = {}) {
   const initialStatus = params.status ? params.status : session.errors.length > 0 ? "error" : "success";
   const buildPayload = (status2) => ({
     sessionId: session.sessionId,
+    traceId: session.traceId,
+    rootSpanId: session.rootSpanId,
     threadId: session.threadId,
     startedAt: startedAtIso,
     endedAt: endedAtIso,
@@ -1147,7 +1396,21 @@ async function finalizeTraceSession(session, params = {}) {
   let sinkFailed = false;
   const sink = session.resolvedConfig.sink;
   const isStreamingMode = session.resolvedConfig.mode === "streaming";
-  if (sink.type === "cognipeer" || sink.type === "http") {
+  if (sink.type === "otlp") {
+    try {
+      const otlpPayload = traceSessionToOtlp(payloadForSink);
+      await postOtlpTraces(sink.endpoint, sink.headers, otlpPayload);
+    } catch (err) {
+      sinkFailed = true;
+      const message = err instanceof Error ? err.message : String(err);
+      session.errors.push({
+        eventId: "sink",
+        message,
+        type: "sink",
+        timestamp: endedAtIso
+      });
+    }
+  } else if (sink.type === "cognipeer" || sink.type === "http") {
     try {
       const headers = sink.type === "cognipeer" ? { Authorization: `Bearer ${sink.apiKey}` } : sink.headers;
       if (isStreamingMode && session.sessionStarted) {
@@ -1174,8 +1437,9 @@ async function finalizeTraceSession(session, params = {}) {
     }
   }
   const hadNonSinkErrors = session.errors.some((error) => error.type && error.type !== "sink");
+  const hadSinkErrors = session.errors.some((error) => error.type === "sink");
   let status = params.status ?? (hadNonSinkErrors ? "error" : "success");
-  if (status === "success" && sinkFailed) {
+  if (status === "success" && (sinkFailed || hadSinkErrors)) {
     status = "partial";
   }
   let finalPayload = buildPayload(status);
@@ -1279,6 +1543,7 @@ function createAgentCoreNode(opts) {
       model: opts.model,
       tools: opts.tools || [],
       guardrails: opts.guardrails,
+      todoListPrompt: opts.todoListPrompt,
       limits: opts.limits,
       outputSchema: opts.outputSchema,
       tracing: opts.tracing
@@ -1353,7 +1618,7 @@ function createAgentCoreNode(opts) {
             }
           }
         }
-      } catch (e) {
+      } catch {
       }
     };
     const onEvent = state.ctx?.__onEvent;
@@ -1469,9 +1734,523 @@ function createAgentCoreNode(opts) {
     return { messages: messagesWithResponse, usage: state.usage };
   };
 }
+
+// src/smart/runtimeConfig.ts
+var DEFAULT_CRITICAL_TOOLS = ["response", "manage_todo_list", "get_tool_response"];
+var DEFAULT_PROFILE_CONFIGS = {
+  fast: {
+    limits: { maxToolCalls: 4, maxParallelTools: 1, maxContextTokens: 12e3 },
+    summarization: {
+      enable: true,
+      maxTokens: 12e3,
+      summaryTriggerTokens: 9e3,
+      summaryPromptMaxTokens: 5e3,
+      summaryCompressionRatioTarget: 0.4,
+      summaryMode: "incremental",
+      promptTemplate: "",
+      toolFreeCall: true,
+      integrityCheck: true
+    },
+    context: {
+      policy: "hybrid",
+      lastTurnsToKeep: 6,
+      toolResponsePolicy: "keep_structured",
+      archiveLargeToolResponses: true,
+      retrieveArchivedToolResponseOnDemand: true,
+      budget: {
+        systemReserveTokens: 1e3,
+        goalsReserveTokens: 900,
+        recentTurnsReserveTokens: 3200,
+        toolResponseReserveTokens: 1800
+      }
+    },
+    planning: {
+      mode: "off",
+      replanPolicy: "on_failure",
+      everyNSteps: 0
+    },
+    memory: {
+      provider: "inMemory",
+      scope: "session",
+      writePolicy: "auto_important",
+      readPolicy: "recent_only"
+    },
+    delegation: {
+      mode: "off",
+      maxDelegationDepth: 1,
+      maxChildCalls: 2,
+      maxParallelChild: 1,
+      childContextPolicy: "minimal",
+      requireJsonOutputContract: true
+    },
+    toolResponses: {
+      maxToolResponseChars: 2400,
+      maxToolResponseTokens: 800,
+      defaultPolicy: "keep_structured",
+      largeResponsePolicy: "summarize_archive",
+      toolResponseRetentionByTool: {},
+      criticalTools: [...DEFAULT_CRITICAL_TOOLS],
+      schemaValidation: "strict",
+      retryOnSchemaError: true,
+      fallbackPolicy: "keep_structured"
+    },
+    watchdog: {
+      enabled: true,
+      tokenDriftThreshold: 1200,
+      overToolingSpikeThreshold: 0.7,
+      contextRotThreshold: 0.65,
+      autoCompaction: true,
+      autoReplanOnFailure: true
+    }
+  },
+  balanced: {
+    limits: { maxToolCalls: 8, maxParallelTools: 2, maxContextTokens: 24e3 },
+    summarization: {
+      enable: true,
+      maxTokens: 24e3,
+      summaryTriggerTokens: 17e3,
+      summaryPromptMaxTokens: 7e3,
+      summaryCompressionRatioTarget: 0.35,
+      summaryMode: "incremental",
+      promptTemplate: "",
+      toolFreeCall: true,
+      integrityCheck: true
+    },
+    context: {
+      policy: "hybrid",
+      lastTurnsToKeep: 8,
+      toolResponsePolicy: "summarize_archive",
+      archiveLargeToolResponses: true,
+      retrieveArchivedToolResponseOnDemand: true,
+      budget: {
+        systemReserveTokens: 1200,
+        goalsReserveTokens: 1200,
+        recentTurnsReserveTokens: 5200,
+        toolResponseReserveTokens: 2800
+      }
+    },
+    planning: {
+      mode: "off",
+      replanPolicy: "on_failure",
+      everyNSteps: 0
+    },
+    memory: {
+      provider: "inMemory",
+      scope: "session",
+      writePolicy: "auto_important",
+      readPolicy: "hybrid"
+    },
+    delegation: {
+      mode: "role_based",
+      maxDelegationDepth: 2,
+      maxChildCalls: 4,
+      maxParallelChild: 2,
+      childContextPolicy: "scoped",
+      requireJsonOutputContract: true
+    },
+    toolResponses: {
+      maxToolResponseChars: 3600,
+      maxToolResponseTokens: 1200,
+      defaultPolicy: "keep_structured",
+      largeResponsePolicy: "summarize_archive",
+      toolResponseRetentionByTool: {},
+      criticalTools: [...DEFAULT_CRITICAL_TOOLS],
+      schemaValidation: "strict",
+      retryOnSchemaError: true,
+      fallbackPolicy: "keep_structured"
+    },
+    watchdog: {
+      enabled: true,
+      tokenDriftThreshold: 1800,
+      overToolingSpikeThreshold: 0.6,
+      contextRotThreshold: 0.55,
+      autoCompaction: true,
+      autoReplanOnFailure: true
+    }
+  },
+  deep: {
+    limits: { maxToolCalls: 14, maxParallelTools: 3, maxContextTokens: 42e3 },
+    summarization: {
+      enable: true,
+      maxTokens: 42e3,
+      summaryTriggerTokens: 3e4,
+      summaryPromptMaxTokens: 9e3,
+      summaryCompressionRatioTarget: 0.3,
+      summaryMode: "incremental",
+      promptTemplate: "",
+      toolFreeCall: true,
+      integrityCheck: true
+    },
+    context: {
+      policy: "hybrid",
+      lastTurnsToKeep: 12,
+      toolResponsePolicy: "summarize_archive",
+      archiveLargeToolResponses: true,
+      retrieveArchivedToolResponseOnDemand: true,
+      budget: {
+        systemReserveTokens: 1400,
+        goalsReserveTokens: 1600,
+        recentTurnsReserveTokens: 7e3,
+        toolResponseReserveTokens: 3600
+      }
+    },
+    planning: {
+      mode: "off",
+      replanPolicy: "on_failure",
+      everyNSteps: 0
+    },
+    memory: {
+      provider: "inMemory",
+      scope: "workspace",
+      writePolicy: "auto_important",
+      readPolicy: "hybrid"
+    },
+    delegation: {
+      mode: "role_based",
+      maxDelegationDepth: 3,
+      maxChildCalls: 6,
+      maxParallelChild: 2,
+      childContextPolicy: "scoped",
+      requireJsonOutputContract: true
+    },
+    toolResponses: {
+      maxToolResponseChars: 5400,
+      maxToolResponseTokens: 1800,
+      defaultPolicy: "keep_structured",
+      largeResponsePolicy: "summarize_archive",
+      toolResponseRetentionByTool: {},
+      criticalTools: [...DEFAULT_CRITICAL_TOOLS],
+      schemaValidation: "strict",
+      retryOnSchemaError: true,
+      fallbackPolicy: "keep_structured"
+    },
+    watchdog: {
+      enabled: true,
+      tokenDriftThreshold: 2200,
+      overToolingSpikeThreshold: 0.55,
+      contextRotThreshold: 0.5,
+      autoCompaction: true,
+      autoReplanOnFailure: true
+    }
+  },
+  research: {
+    limits: { maxToolCalls: 20, maxParallelTools: 4, maxContextTokens: 56e3 },
+    summarization: {
+      enable: true,
+      maxTokens: 56e3,
+      summaryTriggerTokens: 42e3,
+      summaryPromptMaxTokens: 1e4,
+      summaryCompressionRatioTarget: 0.28,
+      summaryMode: "incremental",
+      promptTemplate: "",
+      toolFreeCall: true,
+      integrityCheck: true
+    },
+    context: {
+      policy: "hybrid",
+      lastTurnsToKeep: 20,
+      toolResponsePolicy: "summarize_archive",
+      archiveLargeToolResponses: true,
+      retrieveArchivedToolResponseOnDemand: true,
+      budget: {
+        systemReserveTokens: 1600,
+        goalsReserveTokens: 1800,
+        recentTurnsReserveTokens: 9e3,
+        toolResponseReserveTokens: 4800
+      }
+    },
+    planning: {
+      mode: "off",
+      replanPolicy: "on_failure",
+      everyNSteps: 0
+    },
+    memory: {
+      provider: "inMemory",
+      scope: "workspace",
+      writePolicy: "auto_important",
+      readPolicy: "hybrid"
+    },
+    delegation: {
+      mode: "automatic",
+      maxDelegationDepth: 4,
+      maxChildCalls: 8,
+      maxParallelChild: 3,
+      childContextPolicy: "full",
+      requireJsonOutputContract: true
+    },
+    toolResponses: {
+      maxToolResponseChars: 7200,
+      maxToolResponseTokens: 2200,
+      defaultPolicy: "keep_structured",
+      largeResponsePolicy: "summarize_archive",
+      toolResponseRetentionByTool: {},
+      criticalTools: [...DEFAULT_CRITICAL_TOOLS],
+      schemaValidation: "strict",
+      retryOnSchemaError: true,
+      fallbackPolicy: "keep_structured"
+    },
+    watchdog: {
+      enabled: true,
+      tokenDriftThreshold: 2600,
+      overToolingSpikeThreshold: 0.5,
+      contextRotThreshold: 0.45,
+      autoCompaction: true,
+      autoReplanOnFailure: true
+    }
+  }
+};
+function mergeLimits(base, override) {
+  return {
+    maxToolCalls: override?.maxToolCalls ?? base.maxToolCalls,
+    maxParallelTools: override?.maxParallelTools ?? base.maxParallelTools,
+    maxContextTokens: override?.maxContextTokens ?? base.maxContextTokens
+  };
+}
+function resolveBaseProfile(opts, runtimeProfile) {
+  if (opts.customProfile?.extends) return opts.customProfile.extends;
+  if (runtimeProfile !== "custom") return runtimeProfile;
+  return "balanced";
+}
+function normalizeSmartAgentOptions(opts) {
+  const runtimeProfile = opts.runtimeProfile ?? (opts.customProfile ? "custom" : "balanced");
+  const baseProfile = resolveBaseProfile(opts, runtimeProfile);
+  const preset = DEFAULT_PROFILE_CONFIGS[baseProfile];
+  const customProfile = opts.customProfile || {};
+  const useTodoList = opts.useTodoList === true;
+  const summarizationDisabled = opts.summarization === false;
+  const summarizationOverride = typeof opts.summarization === "object" ? opts.summarization : {};
+  const planningMode = opts.planning?.mode ?? customProfile.planning?.mode ?? (useTodoList ? "todo" : preset.planning.mode);
+  const memoryStore = opts.memory?.store ?? customProfile.memory?.store;
+  return {
+    runtimeProfile,
+    baseProfile,
+    limits: mergeLimits(mergeLimits(preset.limits, customProfile.limits), opts.limits),
+    summarization: {
+      ...preset.summarization,
+      ...customProfile.summarization || {},
+      ...summarizationOverride,
+      enable: summarizationDisabled ? false : summarizationOverride.enable ?? customProfile.summarization?.enable ?? preset.summarization.enable,
+      maxTokens: summarizationOverride.maxTokens ?? opts.limits?.maxContextTokens ?? customProfile.summarization?.maxTokens ?? preset.summarization.maxTokens,
+      summaryTriggerTokens: summarizationOverride.summaryTriggerTokens ?? summarizationOverride.maxTokens ?? opts.limits?.maxContextTokens ?? customProfile.summarization?.summaryTriggerTokens ?? customProfile.summarization?.maxTokens ?? preset.summarization.summaryTriggerTokens,
+      promptTemplate: summarizationOverride.promptTemplate ?? customProfile.summarization?.promptTemplate ?? preset.summarization.promptTemplate
+    },
+    context: {
+      ...preset.context,
+      ...customProfile.context || {},
+      ...opts.context || {},
+      budget: {
+        ...preset.context.budget,
+        ...customProfile.context?.budget || {},
+        ...opts.context?.budget || {}
+      },
+      toolResponsePolicy: opts.context?.toolResponsePolicy ?? customProfile.context?.toolResponsePolicy ?? preset.context.toolResponsePolicy
+    },
+    planning: {
+      ...preset.planning,
+      ...customProfile.planning || {},
+      ...opts.planning || {},
+      mode: planningMode
+    },
+    memory: {
+      ...preset.memory,
+      ...customProfile.memory || {},
+      ...opts.memory || {},
+      store: memoryStore
+    },
+    delegation: {
+      ...preset.delegation,
+      ...customProfile.delegation || {},
+      ...opts.delegation || {}
+    },
+    toolResponses: {
+      ...preset.toolResponses,
+      ...customProfile.toolResponses || {},
+      ...opts.toolResponses || {},
+      toolResponseRetentionByTool: {
+        ...preset.toolResponses.toolResponseRetentionByTool,
+        ...customProfile.toolResponses?.toolResponseRetentionByTool || {},
+        ...opts.toolResponses?.toolResponseRetentionByTool || {}
+      },
+      criticalTools: opts.toolResponses?.criticalTools ?? customProfile.toolResponses?.criticalTools ?? preset.toolResponses.criticalTools
+    },
+    watchdog: {
+      ...preset.watchdog,
+      ...customProfile.watchdog || {},
+      ...opts.watchdog || {}
+    }
+  };
+}
+function getResolvedSmartConfig(opts, runtime) {
+  return runtime?.smart || normalizeSmartAgentOptions(opts);
+}
+
+// src/utils/utilTokens.ts
+function countApproxTokens(text) {
+  if (!text) return 0;
+  const nonAsciiCount = (text.match(/[^\x00-\x7F]/g) || []).length;
+  const asciiCount = text.length - nonAsciiCount;
+  return Math.ceil(asciiCount / 4 + nonAsciiCount / 1.5);
+}
+function extractMessageText(m) {
+  if (!m) return "";
+  const parts = [];
+  parts.push(m.role || "");
+  if (m.name) parts.push(m.name);
+  if (typeof m.content === "string") {
+    parts.push(m.content);
+  } else if (Array.isArray(m.content)) {
+    for (const c of m.content) {
+      if (typeof c === "string") parts.push(c);
+      else if (c?.text) parts.push(c.text);
+      else if (c?.content) parts.push(c.content);
+      else if (c?.type === "tool_use" && c?.input) {
+        parts.push(c.name || "");
+        parts.push(typeof c.input === "string" ? c.input : JSON.stringify(c.input));
+      } else if (c != null && typeof c === "object") {
+        parts.push(JSON.stringify(c));
+      }
+    }
+  } else if (m.content != null && typeof m.content === "object") {
+    parts.push(JSON.stringify(m.content));
+  }
+  if (Array.isArray(m.tool_calls)) {
+    for (const tc of m.tool_calls) {
+      if (tc?.function?.name) parts.push(tc.function.name);
+      if (tc?.function?.arguments) {
+        parts.push(
+          typeof tc.function.arguments === "string" ? tc.function.arguments : JSON.stringify(tc.function.arguments)
+        );
+      }
+      if (tc?.name && !tc?.function?.name) parts.push(tc.name);
+      if (tc?.args && !tc?.function?.arguments) {
+        parts.push(typeof tc.args === "string" ? tc.args : JSON.stringify(tc.args));
+      }
+    }
+  }
+  if (Array.isArray(m.additional_kwargs?.tool_calls)) {
+    for (const tc of m.additional_kwargs.tool_calls) {
+      if (tc?.function?.name) parts.push(tc.function.name);
+      if (tc?.function?.arguments) {
+        parts.push(
+          typeof tc.function.arguments === "string" ? tc.function.arguments : JSON.stringify(tc.function.arguments)
+        );
+      }
+    }
+  }
+  return parts.join("\n");
+}
+function countMessagesTokens(messages) {
+  if (!Array.isArray(messages) || messages.length === 0) return 0;
+  const allText = messages.map(extractMessageText).join("\n");
+  return countApproxTokens(allText) + messages.length * 4;
+}
+
+// src/smart/toolResponses.ts
+function safeStringify(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function summarizeObject(value) {
+  if (value == null) return "null";
+  if (typeof value === "string") {
+    return value.length > 240 ? `${value.slice(0, 240)}...` : value;
+  }
+  if (Array.isArray(value)) {
+    const preview = value.slice(0, 3).map((entry) => safeStringify(entry).slice(0, 120)).join(" | ");
+    return `array(length=${value.length}) ${preview}`.trim();
+  }
+  if (typeof value === "object") {
+    const keys = Object.keys(value);
+    const preview = keys.slice(0, 6).map((key) => `${key}=${safeStringify(value[key]).slice(0, 80)}`).join("; ");
+    return `object(keys=${keys.length}) ${preview}`.trim();
+  }
+  return safeStringify(value);
+}
+function classifyToolResponse(toolName, output, config) {
+  const serialized = safeStringify(output);
+  const tokenCount = countApproxTokens(serialized);
+  const criticalTools = new Set(config.toolResponses.criticalTools);
+  if (criticalTools.has(toolName)) return "critical";
+  if (tokenCount >= config.toolResponses.maxToolResponseTokens || serialized.length >= config.toolResponses.maxToolResponseChars) {
+    return "verbose";
+  }
+  if (serialized === "ok" || serialized === "true" || serialized === "null") {
+    return "redundant";
+  }
+  return "informative";
+}
+function resolveToolResponsePolicy(toolName, output, config) {
+  const serialized = safeStringify(output);
+  const tokenCount = countApproxTokens(serialized);
+  const classification = classifyToolResponse(toolName, output, config);
+  const byTool = config.toolResponses.toolResponseRetentionByTool[toolName];
+  let retentionPolicy = byTool || config.toolResponses.defaultPolicy;
+  if (classification === "critical") {
+    retentionPolicy = byTool || "keep_structured";
+  } else if (classification === "verbose") {
+    retentionPolicy = byTool || config.toolResponses.largeResponsePolicy;
+  } else if (classification === "redundant") {
+    retentionPolicy = byTool || "drop";
+  }
+  const summary = summarizeObject(output);
+  if (retentionPolicy === "keep_full") {
+    return { classification, retentionPolicy, content: serialized, rawOutput: output, summary, tokenCount };
+  }
+  if (retentionPolicy === "keep_structured") {
+    return { classification, retentionPolicy, content: summary, rawOutput: output, summary, tokenCount };
+  }
+  if (retentionPolicy === "summarize_archive") {
+    return {
+      classification,
+      retentionPolicy,
+      content: `ARCHIVED_TOOL_RESPONSE: ${summary}`,
+      rawOutput: output,
+      summary,
+      tokenCount
+    };
+  }
+  return {
+    classification,
+    retentionPolicy,
+    content: `DROPPED_TOOL_RESPONSE: ${summary}`,
+    rawOutput: output,
+    summary,
+    tokenCount
+  };
+}
+function validateToolArgs(tool, args) {
+  const schema = tool.schema;
+  if (!schema || typeof schema.parse !== "function") {
+    return { ok: true, value: args };
+  }
+  try {
+    return { ok: true, value: schema.parse(args) };
+  } catch (error) {
+    if (error instanceof zod.ZodError) {
+      const message = error.issues.map((issue) => `${issue.path.join(".") || "root"}: ${issue.message}`).join("; ");
+      return { ok: false, message };
+    }
+    return { ok: false, message: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+// src/nodes/tools.ts
+function normalizeMaxExecutionsPerRun(value) {
+  if (value === null || value === void 0 || value === "") return null;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) return null;
+  const normalized = Math.trunc(parsed);
+  return normalized >= 0 ? normalized : null;
+}
+function countSuccessfulToolExecutions(toolHistory, toolName) {
+  if (!Array.isArray(toolHistory)) return 0;
+  return toolHistory.filter((entry) => entry?.toolName === toolName && (entry?.status === "success" || entry?.status === "handoff")).length;
+}
 function createToolsNode(initialTools, opts) {
-  const baseToolByName = /* @__PURE__ */ new Map();
-  for (const t of initialTools) baseToolByName.set(t.name, t);
   return async (state) => {
     const runtime = state.agent || {
       name: opts?.name,
@@ -1479,15 +2258,17 @@ function createToolsNode(initialTools, opts) {
       tools: initialTools,
       limits: opts?.limits,
       systemPrompt: opts?.systemPrompt,
+      todoListPrompt: opts?.todoListPrompt,
       useTodoList: opts?.useTodoList,
       outputSchema: opts?.outputSchema
     };
+    const resolved = getResolvedSmartConfig(opts || {}, runtime);
     const activeTools = runtime.tools;
     const toolByName = /* @__PURE__ */ new Map();
-    for (const t of activeTools) toolByName.set(t.name, t);
+    for (const tool of activeTools) toolByName.set(tool.name, tool);
     const limits = {
-      maxToolCalls: runtime.limits?.maxToolCalls ?? 10,
-      maxParallelTools: Math.max(1, runtime.limits?.maxParallelTools ?? 1)
+      maxToolCalls: runtime.limits?.maxToolCalls ?? resolved.limits.maxToolCalls ?? 10,
+      maxParallelTools: Math.max(1, runtime.limits?.maxParallelTools ?? resolved.limits.maxParallelTools ?? 1)
     };
     const appended = [];
     const onEvent = state.ctx?.__onEvent;
@@ -1498,20 +2279,19 @@ function createToolsNode(initialTools, opts) {
     const pendingApprovals = Array.isArray(state.pendingApprovals) ? state.pendingApprovals.map((entry) => ({ ...entry })) : [];
     const pendingByCallId = new Map(pendingApprovals.map((entry) => [entry.toolCallId, entry]));
     let awaitingApproval = false;
-    for (const t of toolByName.values()) {
-      const anyT = t;
-      if (anyT._stateRef && typeof anyT._stateRef === "object") {
-        anyT._stateRef.toolHistory = state.toolHistory;
-        anyT._stateRef.toolHistoryArchived = state.toolHistoryArchived;
-        anyT._stateRef.__onEvent = onEvent;
+    for (const tool of toolByName.values()) {
+      const anyTool = tool;
+      if (anyTool._stateRef && typeof anyTool._stateRef === "object") {
+        anyTool._stateRef.toolHistory = state.toolHistory;
+        anyTool._stateRef.toolHistoryArchived = state.toolHistoryArchived;
+        anyTool._stateRef.__onEvent = onEvent;
       }
     }
     const last = state.messages[state.messages.length - 1];
     let toolCount = state.toolCallCount || 0;
-    const toolCalls = Array.isArray(
-      last?.tool_calls
-    ) ? last.tool_calls : [];
+    const toolCalls = Array.isArray(last?.tool_calls) ? last.tool_calls : [];
     const toolHistory = state.toolHistory || [];
+    const toolHistoryArchived = state.toolHistoryArchived || [];
     const remaining = Math.max(0, limits.maxToolCalls - toolCount);
     const planned = toolCalls.slice(0, remaining);
     const skipped = toolCalls.slice(remaining);
@@ -1520,6 +2300,17 @@ function createToolsNode(initialTools, opts) {
       if (cancellationToken && cancellationToken.isCancellationRequested) return { cancelled: true, reason: "cancelled" };
       return { cancelled: false, reason: void 0 };
     };
+    const markToolFailure = (message, toolName, toolCallId) => {
+      const ctx = { ...state.ctx || {} };
+      ctx.__lastToolError = message;
+      if (toolCallId) {
+        ctx.__toolSchemaError = { toolName, toolCallId, message };
+      }
+      if (resolved.watchdog.autoReplanOnFailure) {
+        ctx.__planNeedsReplan = true;
+      }
+      state.ctx = ctx;
+    };
     const runOne = async (tc) => {
       const cancelState = isCancelled();
       if (cancelState.cancelled) {
@@ -1529,15 +2320,10 @@ function createToolsNode(initialTools, opts) {
         onProgress?.({ stage: "tools", message: "Cancelled", detail: { reason: cancelState.reason } });
         return { status: "error" };
       }
-      const t = toolByName.get(tc.name);
-      if (!t) {
+      const tool = toolByName.get(tc.name);
+      if (!tool) {
+        appended.push({ role: "tool", content: `Tool not found: ${tc.name}`, tool_call_id: tc.id || `${tc.name}_${appended.length}`, name: tc.name });
         onEvent?.({ type: "tool_call", phase: "error", name: tc.name, id: tc.id, args: tc.args, error: { message: "Tool not found" } });
-        appended.push({
-          role: "tool",
-          content: `Tool not found: ${tc.name}`,
-          tool_call_id: tc.id || `${tc.name}_${appended.length}`,
-          name: tc.name
-        });
         toolCount += 1;
         return { status: "error" };
       }
@@ -1545,22 +2331,67 @@ function createToolsNode(initialTools, opts) {
       if (typeof args === "string") {
         try {
           args = JSON.parse(args);
-        } catch (_) {
+        } catch {
         }
       }
       const toolCallId = tc.id || `${tc.name}_${toolCount + 1}`;
+      const validatedArgs = validateToolArgs(tool, args);
+      if (!validatedArgs.ok && resolved.toolResponses.schemaValidation === "strict") {
+        const errorMessage = `Tool argument validation failed for ${tc.name}: ${validatedArgs.message}`;
+        appended.push({ role: "tool", content: errorMessage, tool_call_id: toolCallId, name: tc.name });
+        markToolFailure(errorMessage, tc.name, toolCallId);
+        onEvent?.({ type: "tool_call", phase: "error", name: tc.name, id: tc.id, args, error: { message: errorMessage } });
+        toolCount += 1;
+        return { status: "error" };
+      }
+      if (validatedArgs.ok) {
+        args = validatedArgs.value;
+      }
+      const toolName = tool.name || tc.name;
+      const maxExecutionsPerRun = normalizeMaxExecutionsPerRun(tool.maxExecutionsPerRun);
+      if (maxExecutionsPerRun !== null) {
+        const currentExecutions = countSuccessfulToolExecutions(toolHistory, toolName);
+        if (currentExecutions >= maxExecutionsPerRun) {
+          const limitMessage = `Skipped tool due to per-tool execution limit: ${toolName} (${maxExecutionsPerRun}/run)`;
+          appended.push({ role: "tool", content: limitMessage, tool_call_id: toolCallId, name: tc.name });
+          onEvent?.({ type: "tool_call", phase: "skipped", name: toolName, id: tc.id, args });
+          recordTraceEvent(traceSession, {
+            type: "tool_call",
+            label: `Tool Skipped - ${toolName}`,
+            actor: { scope: "tool", name: toolName, role: "tool" },
+            status: "skipped",
+            toolExecutionId: tc.id,
+            messageList: [
+              {
+                role: "assistant",
+                name: toolName,
+                content: limitMessage,
+                tool_calls: [
+                  {
+                    id: tc.id,
+                    type: "function",
+                    function: { name: toolName, arguments: sanitizeTracePayload(args) }
+                  }
+                ]
+              }
+            ]
+          });
+          toolCount += 1;
+          return { status: "error" };
+        }
+      }
       let approvalEntry = pendingByCallId.get(toolCallId);
-      const needsApproval = Boolean(t.needsApproval);
+      const needsApproval = Boolean(tool.needsApproval);
       if (needsApproval) {
         if (!approvalEntry) {
           approvalEntry = {
             id: nanoid.nanoid(),
             toolCallId,
-            toolName: t.name || tc.name,
+            toolName: tool.name || tc.name,
             args,
             status: "pending",
             requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
-            metadata: t.approvalPrompt || t.approvalDefaults ? { prompt: t.approvalPrompt, defaults: t.approvalDefaults } : void 0
+            metadata: tool.approvalPrompt || tool.approvalDefaults ? { prompt: tool.approvalPrompt, defaults: tool.approvalDefaults } : void 0
           };
           pendingApprovals.push(approvalEntry);
           pendingByCallId.set(toolCallId, approvalEntry);
@@ -1582,71 +2413,97 @@ function createToolsNode(initialTools, opts) {
         }
         if (approvalEntry.status === "rejected") {
           const rejectionMessage = approvalEntry.comment || "Tool call rejected by reviewer.";
-          appended.push({
-            role: "tool",
-            content: `Tool call rejected: ${rejectionMessage}`,
-            tool_call_id: toolCallId,
-            name: tc.name
-          });
-          onEvent?.({ type: "tool_approval", status: "rejected", id: approvalEntry.id, toolName: approvalEntry.toolName, toolCallId: approvalEntry.toolCallId, comment: approvalEntry.comment, decidedBy: approvalEntry.decidedBy });
+          appended.push({ role: "tool", content: `Tool call rejected: ${rejectionMessage}`, tool_call_id: toolCallId, name: tc.name });
           approvalEntry.metadata = { ...approvalEntry.metadata || {}, resolution: "rejected" };
           approvalEntry.status = "executed";
           approvalEntry.resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
-          toolHistory.push({ executionId: nanoid.nanoid(), toolName: t.name, args, output: `Rejected: ${rejectionMessage}`, rawOutput: null, timestamp: (/* @__PURE__ */ new Date()).toISOString(), tool_call_id: tc.id });
           pendingByCallId.set(toolCallId, approvalEntry);
+          toolHistory.push({ executionId: nanoid.nanoid(), toolName: tool.name, args, output: `Rejected: ${rejectionMessage}`, rawOutput: null, timestamp: (/* @__PURE__ */ new Date()).toISOString(), tool_call_id: tc.id, status: "rejected" });
+          onEvent?.({ type: "tool_approval", status: "rejected", id: approvalEntry.id, toolName: approvalEntry.toolName, toolCallId: approvalEntry.toolCallId, comment: approvalEntry.comment, decidedBy: approvalEntry.decidedBy });
           toolCount += 1;
           return { status: "rejected", approval: approvalEntry };
         }
-        if (approvalEntry.status === "approved") {
-          if (approvalEntry.approvedArgs !== void 0) {
-            args = approvalEntry.approvedArgs;
-          }
+        if (approvalEntry.status === "approved" && approvalEntry.approvedArgs !== void 0) {
+          args = approvalEntry.approvedArgs;
           onEvent?.({ type: "tool_approval", status: "approved", id: approvalEntry.id, toolName: approvalEntry.toolName, toolCallId: approvalEntry.toolCallId, decidedBy: approvalEntry.decidedBy, comment: approvalEntry.comment });
         }
       }
       const start = Date.now();
+      const sanitizedArgs = sanitizeTracePayload(args);
+      const inputBytes = traceSession?.resolvedConfig.logData ? estimatePayloadBytes(sanitizedArgs) : void 0;
       try {
-        onEvent?.({ type: "tool_call", phase: "start", name: t.name, id: tc.id, args });
+        onEvent?.({ type: "tool_call", phase: "start", name: toolName, id: tc.id, args });
         onProgress?.({ stage: "tools", message: `Running tool ${tc.name}` });
-        const sanitizedArgs = sanitizeTracePayload(args);
-        const inputBytes = traceSession?.resolvedConfig.logData ? estimatePayloadBytes(sanitizedArgs) : void 0;
-        let output;
-        const anyTool = t;
+        const anyTool = tool;
         const callOptions = { cancellationToken, signal: abortSignal };
+        let output;
         if (typeof anyTool.func === "function") output = await anyTool.func(args, callOptions);
         else if (typeof anyTool.invoke === "function") output = await anyTool.invoke(args, callOptions);
         else if (typeof anyTool.call === "function") output = await anyTool.call(args, callOptions);
         else if (typeof anyTool._call === "function") output = await anyTool._call(args, callOptions);
         else if (typeof anyTool.run === "function") output = await anyTool.run(args, callOptions);
         else throw new Error("Tool is not invokable");
-        if (output && typeof output === "object" && output.__handoff && output.__handoff.runtime) {
-          const newRuntime = output.__handoff.runtime;
-          const executionId2 = nanoid.nanoid();
-          toolHistory.push({ executionId: executionId2, toolName: t.name, args, output: "handoff:ok", rawOutput: output, timestamp: (/* @__PURE__ */ new Date()).toISOString(), tool_call_id: tc.id });
+        const durationMs = Date.now() - start;
+        const executionId = nanoid.nanoid();
+        if (output && typeof output === "object" && output.__handoff && output.__handoff.runtime) {
+          toolHistory.push({ executionId, toolName, args, output: "handoff:ok", rawOutput: output, timestamp: (/* @__PURE__ */ new Date()).toISOString(), tool_call_id: tc.id, status: "handoff" });
           appended.push({ role: "tool", content: "ok", tool_call_id: tc.id || `${tc.name}_${appended.length}`, name: tc.name });
-          onEvent?.({ type: "handoff", from: runtime.name, to: newRuntime.name, toolName: t.name });
-          state.agent = newRuntime;
-          onEvent?.({ type: "tool_call", phase: "success", name: t.name, id: tc.id, args, result: "handoff", durationMs: Date.now() - start });
-          toolCount += 1;
+          state.agent = output.__handoff.runtime;
+          onEvent?.({ type: "handoff", from: runtime.name, to: state.agent?.name, toolName });
+          onEvent?.({ type: "tool_call", phase: "success", name: toolName, id: tc.id, args, result: "handoff", durationMs });
           if (needsApproval && approvalEntry) {
             approvalEntry.status = "executed";
             approvalEntry.resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
-            approvalEntry.executionId = executionId2;
+            approvalEntry.executionId = executionId;
             pendingByCallId.set(toolCallId, approvalEntry);
           }
+          toolCount += 1;
           return { status: "success", approval: approvalEntry };
         }
-        const content = typeof output === "string" ? output : JSON.stringify(output);
         if (output && typeof output === "object" && output.__finalStructuredOutput) {
           if (!state.ctx) state.ctx = {};
           state.ctx.__structuredOutputParsed = output.data;
           state.ctx.__finalizedDueToStructuredOutput = true;
         }
-        const durationMs = Date.now() - start;
-        const executionId = nanoid.nanoid();
-        toolHistory.push({ executionId, toolName: t.name, args, output, rawOutput: output, timestamp: (/* @__PURE__ */ new Date()).toISOString(), tool_call_id: tc.id });
-        appended.push({ role: "tool", content, tool_call_id: tc.id || `${tc.name}_${appended.length}`, name: tc.name });
-        onEvent?.({ type: "tool_call", phase: "success", name: t.name, id: tc.id, args, result: output, durationMs });
+        const responsePolicy = resolveToolResponsePolicy(toolName, output, resolved);
+        const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+        const storedOutput = responsePolicy.retentionPolicy === "keep_full" ? output : responsePolicy.summary;
+        toolHistory.push({
+          executionId,
+          toolName,
+          args,
+          output: storedOutput,
+          rawOutput: output,
+          timestamp,
+          tool_call_id: tc.id,
+          summarized: responsePolicy.retentionPolicy !== "keep_full",
+          originalTokenCount: responsePolicy.tokenCount,
+          classification: responsePolicy.classification,
+          retentionPolicy: responsePolicy.retentionPolicy,
+          summary: responsePolicy.summary,
+          archiveId: responsePolicy.retentionPolicy === "summarize_archive" || responsePolicy.retentionPolicy === "drop" ? executionId : void 0,
+          status: "success"
+        });
+        if (resolved.context.archiveLargeToolResponses && (responsePolicy.retentionPolicy === "summarize_archive" || responsePolicy.retentionPolicy === "drop")) {
+          toolHistoryArchived.push({
+            executionId,
+            toolName,
+            args,
+            output,
+            rawOutput: output,
+            timestamp,
+            tool_call_id: tc.id,
+            summarized: true,
+            originalTokenCount: responsePolicy.tokenCount,
+            classification: responsePolicy.classification,
+            retentionPolicy: responsePolicy.retentionPolicy,
+            summary: responsePolicy.summary,
+            archiveId: executionId,
+            status: "success"
+          });
+        }
+        appended.push({ role: "tool", content: responsePolicy.content, tool_call_id: tc.id || `${tc.name}_${appended.length}`, name: tc.name });
+        onEvent?.({ type: "tool_call", phase: "success", name: toolName, id: tc.id, args, result: output, durationMs });
         onProgress?.({ stage: "tools", message: `Tool ${tc.name} completed`, detail: { durationMs } });
         if (needsApproval && approvalEntry) {
           approvalEntry.status = "executed";
@@ -1656,7 +2513,6 @@ function createToolsNode(initialTools, opts) {
         }
         const sanitizedOutput = sanitizeTracePayload(output);
         const outputBytes = traceSession?.resolvedConfig.logData ? estimatePayloadBytes(sanitizedOutput) : void 0;
-        const toolName = t.name || tc.name;
         const messageList = [
           {
             role: "assistant",
@@ -1676,7 +2532,7 @@ function createToolsNode(initialTools, opts) {
           {
             role: "tool",
             name: toolName,
-            content: sanitizedOutput ?? output ?? ""
+            content: responsePolicy.content
           }
         ];
         recordTraceEvent(traceSession, {
@@ -1687,43 +2543,24 @@ function createToolsNode(initialTools, opts) {
           requestBytes: inputBytes,
           responseBytes: outputBytes,
           toolExecutionId: executionId,
-          messageList
+          messageList,
+          debug: {
+            classification: responsePolicy.classification,
+            retentionPolicy: responsePolicy.retentionPolicy,
+            originalTokenCount: responsePolicy.tokenCount
+          }
         });
         toolCount += 1;
         return { status: "success", approval: approvalEntry };
-      } catch (e) {
+      } catch (error) {
         const durationMs = Date.now() - start;
         const executionId = nanoid.nanoid();
-        toolHistory.push({ executionId, toolName: t.name, args, output: `Error executing tool: ${e?.message || String(e)}`, rawOutput: null, timestamp: (/* @__PURE__ */ new Date()).toISOString(), tool_call_id: tc.id });
-        appended.push({ role: "tool", content: `Error executing tool: ${e?.message || String(e)}`, tool_call_id: tc.id || `${tc.name}_${appended.length}`, name: tc.name });
-        onEvent?.({ type: "tool_call", phase: "error", name: t.name, id: tc.id, args, error: { message: e?.message || String(e) } });
-        onProgress?.({ stage: "tools", message: `Tool ${tc.name} failed`, detail: { error: e?.message || String(e) } });
-        const sanitizedArgs = sanitizeTracePayload(args);
-        const inputBytes = traceSession?.resolvedConfig.logData ? estimatePayloadBytes(sanitizedArgs) : void 0;
-        const toolName = t.name || tc.name;
-        const errorMessage = e?.message || String(e);
-        const messageList = [
-          {
-            role: "assistant",
-            name: toolName,
-            content: "",
-            tool_calls: [
-              {
-                id: tc.id || executionId,
-                type: "function",
-                function: {
-                  name: toolName,
-                  arguments: sanitizedArgs
-                }
-              }
-            ]
-          },
-          {
-            role: "tool",
-            name: toolName,
-            content: `Error executing tool: ${errorMessage}`
-          }
-        ];
+        const message = error?.message || String(error);
+        toolHistory.push({ executionId, toolName, args, output: `Error executing tool: ${message}`, rawOutput: null, timestamp: (/* @__PURE__ */ new Date()).toISOString(), tool_call_id: tc.id, status: "error" });
+        appended.push({ role: "tool", content: `Error executing tool: ${message}`, tool_call_id: tc.id || `${tc.name}_${appended.length}`, name: tc.name });
+        markToolFailure(message, toolName, toolCallId);
+        onEvent?.({ type: "tool_call", phase: "error", name: toolName, id: tc.id, args, error: { message } });
+        onProgress?.({ stage: "tools", message: `Tool ${tc.name} failed`, detail: { error: message } });
         recordTraceEvent(traceSession, {
           type: "tool_call",
           label: `Tool Error - ${toolName}`,
@@ -1732,8 +2569,26 @@ function createToolsNode(initialTools, opts) {
           durationMs,
           requestBytes: inputBytes,
           toolExecutionId: executionId,
-          error: { message: e?.message || String(e), stack: e?.stack },
-          messageList
+          error: { message, stack: error?.stack },
+          messageList: [
+            {
+              role: "assistant",
+              name: toolName,
+              content: "",
+              tool_calls: [
+                {
+                  id: tc.id || executionId,
+                  type: "function",
+                  function: { name: toolName, arguments: sanitizedArgs }
+                }
+              ]
+            },
+            {
+              role: "tool",
+              name: toolName,
+              content: `Error executing tool: ${message}`
+            }
+          ]
         });
         toolCount += 1;
         return { status: "error", approval: approvalEntry };
@@ -1750,7 +2605,7 @@ function createToolsNode(initialTools, opts) {
         break;
       }
       const result = await runOne(tc);
-      if (result?.status === "awaiting_approval") {
+      if (result.status === "awaiting_approval") {
         awaitingApproval = true;
         break;
       }
@@ -1758,37 +2613,28 @@ function createToolsNode(initialTools, opts) {
     for (const tc of skipped) {
       onEvent?.({ type: "tool_call", phase: "skipped", name: tc.name, id: tc.id, args: tc.args });
       const sanitizedArgs = sanitizeTracePayload(tc.args);
-      const messageList = [
-        {
-          role: "assistant",
-          name: tc.name,
-          content: `Skipped tool due to tool-call limit: ${tc.name}`,
-          tool_calls: [
-            {
-              id: tc.id,
-              type: "function",
-              function: {
-                name: tc.name,
-                arguments: sanitizedArgs
-              }
-            }
-          ]
-        }
-      ];
       recordTraceEvent(traceSession, {
         type: "tool_call",
         label: `Tool Skipped - ${tc.name}`,
         actor: { scope: "tool", name: tc.name, role: "tool" },
         status: "skipped",
         toolExecutionId: tc.id,
-        messageList
-      });
-      appended.push({
-        role: "tool",
-        content: `Skipped tool due to tool-call limit: ${tc.name}`,
-        tool_call_id: tc.id || `${tc.name}_${appended.length}`,
-        name: tc.name
+        messageList: [
+          {
+            role: "assistant",
+            name: tc.name,
+            content: `Skipped tool due to tool-call limit: ${tc.name}`,
+            tool_calls: [
+              {
+                id: tc.id,
+                type: "function",
+                function: { name: tc.name, arguments: sanitizedArgs }
+              }
+            ]
+          }
+        ]
       });
+      appended.push({ role: "tool", content: `Skipped tool due to tool-call limit: ${tc.name}`, tool_call_id: tc.id || `${tc.name}_${appended.length}`, name: tc.name });
       toolCount += 1;
     }
     if (!awaitingApproval && state.ctx?.__awaitingApproval) {
@@ -1803,6 +2649,7 @@ function createToolsNode(initialTools, opts) {
       messages: [...state.messages, ...appended],
       toolCallCount: toolCount,
       toolHistory,
+      toolHistoryArchived,
       agent: state.agent,
       pendingApprovals
     };
@@ -2027,68 +2874,20 @@ function resolveToolApprovalState(state, resolution) {
   };
 }
 
-// src/utils/utilTokens.ts
-function countApproxTokens(text) {
-  if (!text) return 0;
-  const nonAsciiCount = (text.match(/[^\x00-\x7F]/g) || []).length;
-  const asciiCount = text.length - nonAsciiCount;
-  return Math.ceil(asciiCount / 4 + nonAsciiCount / 1.5);
-}
-function extractMessageText(m) {
-  if (!m) return "";
-  const parts = [];
-  parts.push(m.role || "");
-  if (m.name) parts.push(m.name);
-  if (typeof m.content === "string") {
-    parts.push(m.content);
-  } else if (Array.isArray(m.content)) {
-    for (const c of m.content) {
-      if (typeof c === "string") parts.push(c);
-      else if (c?.text) parts.push(c.text);
-      else if (c?.content) parts.push(c.content);
-      else if (c?.type === "tool_use" && c?.input) {
-        parts.push(c.name || "");
-        parts.push(typeof c.input === "string" ? c.input : JSON.stringify(c.input));
-      } else if (c != null && typeof c === "object") {
-        parts.push(JSON.stringify(c));
-      }
-    }
-  } else if (m.content != null && typeof m.content === "object") {
-    parts.push(JSON.stringify(m.content));
-  }
-  if (Array.isArray(m.tool_calls)) {
-    for (const tc of m.tool_calls) {
-      if (tc?.function?.name) parts.push(tc.function.name);
-      if (tc?.function?.arguments) {
-        parts.push(
-          typeof tc.function.arguments === "string" ? tc.function.arguments : JSON.stringify(tc.function.arguments)
-        );
-      }
-      if (tc?.name && !tc?.function?.name) parts.push(tc.name);
-      if (tc?.args && !tc?.function?.arguments) {
-        parts.push(typeof tc.args === "string" ? tc.args : JSON.stringify(tc.args));
-      }
-    }
+// src/agent.ts
+function isSyntheticSummaryMessage(message) {
+  if (!message) return false;
+  if (message.role === "tool" && message.name === "summarize_context") {
+    return true;
   }
-  if (Array.isArray(m.additional_kwargs?.tool_calls)) {
-    for (const tc of m.additional_kwargs.tool_calls) {
-      if (tc?.function?.name) parts.push(tc.function.name);
-      if (tc?.function?.arguments) {
-        parts.push(
-          typeof tc.function.arguments === "string" ? tc.function.arguments : JSON.stringify(tc.function.arguments)
-        );
-      }
-    }
+  if (message.role === "assistant" && Array.isArray(message.tool_calls)) {
+    return message.tool_calls.some((toolCall) => {
+      const toolName = toolCall?.function?.name || toolCall?.name;
+      return toolName === "summarize_context";
+    });
   }
-  return parts.join("\n");
-}
-function countMessagesTokens(messages) {
-  if (!Array.isArray(messages) || messages.length === 0) return 0;
-  const allText = messages.map(extractMessageText).join("\n");
-  return countApproxTokens(allText) + messages.length * 4;
+  return false;
 }
-
-// src/agent.ts
 function createAgent(opts) {
   const resolver = createResolverNode();
   const agentCore = createAgentCoreNode(opts);
@@ -2131,6 +2930,7 @@ function createAgent(opts) {
     tools: toolsBase,
     guardrails: opts.guardrails,
     systemPrompt: void 0,
+    todoListPrompt: opts.todoListPrompt,
     limits: opts.limits,
     useTodoList: void 0,
     outputSchema: opts.outputSchema,
@@ -2206,6 +3006,18 @@ function createAgent(opts) {
     };
     while (iterations < iterationLimit) {
       iterations++;
+      const traceSession = state.ctx?.__traceSession;
+      if (traceSession) {
+        const iterEvent = recordTraceEvent(traceSession, {
+          type: "agent_iteration",
+          label: `Iteration ${iterations}`,
+          actor: { scope: "agent", name: opts.name || "agent", role: "orchestrator" },
+          parentSpanId: traceSession.rootSpanId
+        });
+        if (iterEvent) {
+          traceSession.currentIterationSpanId = iterEvent.spanId;
+        }
+      }
       if (cancelIfRequested("loop")) break;
       const skippingAgent = resumeStage === "tools";
       if (!skippingAgent) {
@@ -2256,11 +3068,21 @@ function createAgent(opts) {
           maxTok = 5e4;
         }
         if (maxTok) {
-          const tokenCount = countMessagesTokens(state.messages || []);
+          const tokCountMessages = (state.messages || []).filter((message) => {
+            if (isSyntheticSummaryMessage(message)) return false;
+            if (message.role === "system" && (message.name === "context_summary" || message.name === "memory_context")) return false;
+            return true;
+          });
+          const tokenCount = countMessagesTokens(tokCountMessages);
           if (tokenCount > maxTok) {
-            const ctx = { ...state.ctx || {}, __needsSummarization: true };
-            state = { ...state, ctx };
-            break;
+            const hasFreshSummary = (state.messages || []).some(
+              (m) => m.role === "tool" && m.content === "SUMMARIZED"
+            );
+            if (hasFreshSummary && tokenCount <= maxTok * 1.15) ; else {
+              const ctx = { ...state.ctx || {}, __needsSummarization: true };
+              state = { ...state, ctx };
+              break;
+            }
           }
         }
         onProgress?.({ stage: "agent", message: "Invoking model" });
@@ -2498,7 +3320,11 @@ function createAgent(opts) {
         schema,
         func: async ({ input }) => {
           const res = await instance.invoke({ messages: [{ role: "user", content: input }] });
-          return { content: res.content };
+          return {
+            content: res.content,
+            output: res.output,
+            summary: res.state?.summaries?.[res.state.summaries.length - 1]
+          };
         }
       });
     },
@@ -2539,6 +3365,7 @@ function createAgentNode(opts) {
       model: opts.model,
       tools: opts.tools || [],
       systemPrompt: opts.systemPrompt,
+      todoListPrompt: opts.todoListPrompt,
       limits: opts.limits,
       useTodoList: opts.useTodoList,
       outputSchema: opts.outputSchema
@@ -2556,7 +3383,8 @@ function createAgentNode(opts) {
       content: buildSystemPrompt(
         [runtime.systemPrompt, structuredOutputHint].filter(Boolean).join("\n"),
         runtime.useTodoList === true,
-        runtime.name || "Agent"
+        runtime.name || "Agent",
+        runtime.todoListPrompt
       )
     };
     const messages = [systemMsg, ...state.messages];
@@ -2638,9 +3466,119 @@ function createAgentNode(opts) {
   };
 }
 
+// src/smart/contextPolicy.ts
+function messageText(message) {
+  if (typeof message.content === "string") return message.content;
+  if (Array.isArray(message.content)) {
+    return message.content.map((part) => typeof part === "string" ? part : part?.text ?? part?.content ?? JSON.stringify(part)).join(" ");
+  }
+  return "";
+}
+function collectRecentTurns(messages, lastTurnsToKeep) {
+  if (lastTurnsToKeep <= 0) return [];
+  const systemPrefix = messages.filter((message, index) => index === 0 && message.role === "system");
+  const body = systemPrefix.length > 0 ? messages.slice(1) : [...messages];
+  let userTurnCount = 0;
+  const collected = [];
+  for (let index = body.length - 1; index >= 0; index -= 1) {
+    const message = body[index];
+    collected.unshift(message);
+    if (message.role === "user") {
+      userTurnCount += 1;
+      if (userTurnCount >= lastTurnsToKeep) break;
+    }
+  }
+  return [...systemPrefix, ...collected];
+}
+function renderStructuredSummary(summary) {
+  if (!summary) return "";
+  const lines = ["Context summary:"];
+  if (summary.stable_facts.length > 0) {
+    lines.push("Stable facts:");
+    lines.push(...summary.stable_facts.map((fact) => `- ${fact.key}: ${fact.value}`));
+  }
+  if (summary.active_goals.length > 0) {
+    lines.push("Active goals:");
+    lines.push(...summary.active_goals.map((goal) => `- ${goal}`));
+  }
+  if (summary.open_questions.length > 0) {
+    lines.push("Open questions:");
+    lines.push(...summary.open_questions.map((question) => `- ${question}`));
+  }
+  if (summary.discarded_obsolete.length > 0) {
+    lines.push("Discarded obsolete:");
+    lines.push(...summary.discarded_obsolete.map((item) => `- ${item}`));
+  }
+  return lines.join("\n");
+}
+function renderMemoryBlock(facts) {
+  if (!facts || facts.length === 0) return "";
+  return [
+    "Retrieved memory:",
+    ...facts.map((fact) => `- ${fact.key}: ${fact.value}`)
+  ].join("\n");
+}
+function clampToBudget(messages, maxContextTokens) {
+  let working = [...messages];
+  while (working.length > 2) {
+    const tokenCount = countApproxTokens(working.map(messageText).join("\n"));
+    if (tokenCount <= maxContextTokens) return working;
+    const firstNonSystem = working.findIndex((message, index) => !(index === 0 && message.role === "system"));
+    if (firstNonSystem < 0) break;
+    working.splice(firstNonSystem, 1);
+  }
+  return working;
+}
+function buildModelMessages(state, config) {
+  const rawMessages = state.messages || [];
+  if (config.context.policy === "raw") {
+    return clampToBudget(rawMessages, config.limits.maxContextTokens);
+  }
+  const recentMessages = collectRecentTurns(rawMessages, config.context.lastTurnsToKeep);
+  const latestSummary = state.summaryRecords?.[state.summaryRecords.length - 1];
+  const summaryText = renderStructuredSummary(latestSummary);
+  const memoryText = renderMemoryBlock(state.memoryFacts);
+  const systemMessage2 = recentMessages[0]?.role === "system" ? recentMessages[0] : void 0;
+  const body = systemMessage2 ? recentMessages.slice(1) : recentMessages;
+  const syntheticContextMessages = [];
+  if (summaryText) {
+    syntheticContextMessages.push({ role: "system", name: "context_summary", content: summaryText });
+  }
+  if (memoryText) {
+    syntheticContextMessages.push({ role: "system", name: "memory_context", content: memoryText });
+  }
+  const assembled = [
+    ...systemMessage2 ? [systemMessage2] : [],
+    ...syntheticContextMessages,
+    ...config.context.policy === "summary_only" ? body.filter((message) => message.role === "user" || message.role === "assistant").slice(-2) : body
+  ];
+  return clampToBudget(assembled, config.limits.maxContextTokens);
+}
+function estimateContextRotScore(state) {
+  const summaryCount = state.summaryRecords?.length || 0;
+  const archivedCount = state.toolHistoryArchived?.length || 0;
+  const messageCount = state.messages?.length || 0;
+  const summarizedMessages = state.messages?.filter((message) => message.role === "tool" && message.content === "SUMMARIZED").length || 0;
+  const numerator = summaryCount * 2 + archivedCount + summarizedMessages;
+  const denominator = Math.max(messageCount, 1);
+  return Number((numerator / denominator).toFixed(3));
+}
+
 // src/nodes/contextSummarize.ts
 var systemMessage = (content) => ({ role: "system", content });
 var humanMessage = (content) => ({ role: "user", content });
+function isSyntheticSummaryToolMessage(message) {
+  return message.role === "tool" && message.name === "summarize_context";
+}
+function isSyntheticSummaryAssistantMessage(message) {
+  if (message.role !== "assistant" || !Array.isArray(message.tool_calls)) {
+    return false;
+  }
+  return message.tool_calls.some((toolCall) => {
+    const toolName = toolCall?.function?.name || toolCall?.name;
+    return toolName === "summarize_context";
+  });
+}
 function validateMessageSequence(messages) {
   const validated = [];
   const pendingToolCallIds = /* @__PURE__ */ new Set();
@@ -2666,33 +3604,137 @@ function validateMessageSequence(messages) {
   }
   return validated;
 }
-function getSummarizationConfig(opts) {
-  if (typeof opts.summarization === "object") {
-    return {
-      enabled: opts.summarization.enable !== false,
-      maxTokens: opts.summarization.maxTokens ?? 5e4,
-      // Max tokens we can send to the model for summarization prompt itself
-      // This should be well under the model's context limit
-      summaryPromptMaxTokens: opts.summarization.summaryPromptMaxTokens ?? 8e3,
-      promptTemplate: opts.summarization.promptTemplate
-    };
+function extractJsonObject(text) {
+  const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  if (fenced?.[1]) return fenced[1].trim();
+  const start = text.indexOf("{");
+  const end = text.lastIndexOf("}");
+  if (start >= 0 && end > start) {
+    return text.slice(start, end + 1);
+  }
+  return null;
+}
+function normalizeStructuredSummary(input, fallbackText) {
+  const summary = {
+    stable_facts: Array.isArray(input?.stable_facts) ? input.stable_facts.filter((fact) => fact && typeof fact === "object").map((fact) => ({
+      key: String(fact.key || "unknown"),
+      value: String(fact.value || ""),
+      confidence: typeof fact.confidence === "number" ? fact.confidence : 0.7,
+      source: fact.source ? String(fact.source) : void 0
+    })) : [],
+    active_goals: Array.isArray(input?.active_goals) ? input.active_goals.map((goal) => String(goal)) : [],
+    open_questions: Array.isArray(input?.open_questions) ? input.open_questions.map((question) => String(question)) : [],
+    discarded_obsolete: Array.isArray(input?.discarded_obsolete || input?.obsolete_discarded) ? (input.discarded_obsolete || input.obsolete_discarded).map((item) => String(item)) : [],
+    rawSummary: typeof input?.rawSummary === "string" ? input.rawSummary : fallbackText
+  };
+  if (summary.stable_facts.length === 0 && fallbackText) {
+    const importantLines = fallbackText.split("\n").map((line) => line.trim()).filter(Boolean).slice(0, 8);
+    summary.stable_facts = importantLines.map((line, index) => ({
+      key: `fact_${index + 1}`,
+      value: line,
+      confidence: 0.5
+    }));
+  }
+  return summary;
+}
+function normalizeFactKeySegment(value) {
+  return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "") || "item";
+}
+function extractCanonicalFacts(messages) {
+  const facts = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    const content = typeof message.content === "string" ? message.content : Array.isArray(message.content) ? message.content.map((part) => part?.text ?? part?.content ?? String(part ?? "")).join("\n") : "";
+    if (!content) continue;
+    const lines = content.split("\n").map((line) => line.trim()).filter(Boolean);
+    for (const line of lines) {
+      if (!/^[A-Z0-9_]+\|/.test(line) || !line.includes("=")) continue;
+      const segments = line.split("|").map((segment) => segment.trim()).filter(Boolean);
+      const label = segments[0];
+      const entries = segments.slice(1).map((segment) => {
+        const eqIndex = segment.indexOf("=");
+        if (eqIndex <= 0) return null;
+        return {
+          key: segment.slice(0, eqIndex).trim(),
+          value: segment.slice(eqIndex + 1).trim()
+        };
+      }).filter((entry) => Boolean(entry?.key));
+      if (entries.length === 0) continue;
+      const identifier = entries.find((entry) => ["code", "id", "project", "name", "key"].includes(entry.key.toLowerCase()))?.value;
+      const keyPrefix = [normalizeFactKeySegment(label), identifier ? normalizeFactKeySegment(identifier) : void 0].filter(Boolean).join(".");
+      for (const entry of entries) {
+        const normalizedEntryKey = normalizeFactKeySegment(entry.key);
+        const factKey = keyPrefix ? `${keyPrefix}.${normalizedEntryKey}` : `${normalizeFactKeySegment(label)}.${normalizedEntryKey}`;
+        facts.set(factKey, {
+          key: factKey,
+          value: entry.value,
+          confidence: 0.98,
+          source: "canonical_tool_output"
+        });
+      }
+    }
+  }
+  return [...facts.values()];
+}
+function mergeStableFacts(summary, additionalFacts) {
+  if (additionalFacts.length === 0) return summary;
+  const merged = new Map(summary.stable_facts.map((fact) => [fact.key, fact]));
+  for (const fact of additionalFacts) {
+    const existing = merged.get(fact.key);
+    if (!existing || (fact.confidence || 0) >= (existing.confidence || 0)) {
+      merged.set(fact.key, fact);
+    }
   }
   return {
-    enabled: opts.summarization !== false,
-    maxTokens: 5e4,
-    summaryPromptMaxTokens: 8e3,
-    promptTemplate: void 0
+    ...summary,
+    stable_facts: [...merged.values()]
   };
 }
+function runIntegrityCheck(previous, current) {
+  const notes = [];
+  const previousKeys = new Set((previous?.stable_facts || []).map((fact) => fact.key));
+  const currentKeys = new Set(current.stable_facts.map((fact) => fact.key));
+  const obsoleteKeys = new Set(current.discarded_obsolete);
+  const criticalFactLoss = [...previousKeys].some((key) => !obsoleteKeys.has(key) && !currentKeys.has(key));
+  const obsoleteFactRevived = current.stable_facts.some((fact) => obsoleteKeys.has(fact.key));
+  if (criticalFactLoss) {
+    notes.push("Missing previously retained facts; merged forward during integrity repair.");
+  }
+  if (obsoleteFactRevived) {
+    notes.push("Obsolete facts reappeared; removed during integrity repair.");
+  }
+  return {
+    passed: !criticalFactLoss && !obsoleteFactRevived,
+    criticalFactLoss,
+    obsoleteFactRevived,
+    notes
+  };
+}
+function repairStructuredSummary(previous, current, integrity) {
+  if (!previous) return current;
+  const nextFacts = [...current.stable_facts];
+  if (integrity.criticalFactLoss) {
+    const existingKeys = new Set(nextFacts.map((fact) => fact.key));
+    for (const fact of previous.stable_facts) {
+      if (!existingKeys.has(fact.key) && !current.discarded_obsolete.includes(fact.key)) {
+        nextFacts.push(fact);
+      }
+    }
+  }
+  const filteredFacts = integrity.obsoleteFactRevived ? nextFacts.filter((fact) => !current.discarded_obsolete.includes(fact.key)) : nextFacts;
+  return { ...current, stable_facts: filteredFacts };
+}
 function createContextSummarizeNode(opts) {
   return async (state) => {
-    const config = getSummarizationConfig(opts);
-    if (!config.enabled) return {};
+    const resolved = getResolvedSmartConfig(opts, state.agent);
+    const config = resolved.summarization;
+    if (!config.enable) return {};
     const model = opts.model;
     const messages = state.messages || [];
     const onEvent = state.ctx?.__onEvent;
     const traceSession = state.ctx?.__traceSession;
-    const compressableMessages = messages.filter((m) => m.role === "tool" && m.content !== "SUMMARIZED");
+    const compressableMessages = messages.filter(
+      (m) => m.role === "tool" && m.content !== "SUMMARIZED" && !isSyntheticSummaryToolMessage(m)
+    );
     if (compressableMessages.length === 0) {
       return {};
     }
@@ -2704,6 +3746,9 @@ function createContextSummarizeNode(opts) {
     let accumulatedTokens = 0;
     for (let i = messages.length - 1; i >= 0; i--) {
       const m = messages[i];
+      if (isSyntheticSummaryToolMessage(m) || isSyntheticSummaryAssistantMessage(m)) {
+        continue;
+      }
       let content = "";
       if (typeof m.content === "string") content = m.content;
       else if (Array.isArray(m.content)) {
@@ -2715,39 +3760,60 @@ function createContextSummarizeNode(opts) {
       }
       let prefix = `${m.role.toUpperCase()}`;
       if (m.name) prefix += ` (${m.name})`;
-      const messageText = `${prefix}: ${content}`;
-      const messageTokens = countApproxTokens(messageText);
+      const messageText2 = `${prefix}: ${content}`;
+      const messageTokens = countApproxTokens(messageText2);
       if (accumulatedTokens + messageTokens > availableTokensForConversation) {
         messageTexts.unshift("[Earlier conversation history omitted for brevity]");
         break;
       }
-      messageTexts.unshift(messageText);
+      messageTexts.unshift(messageText2);
       accumulatedTokens += messageTokens;
     }
     const conversationText = messageTexts.join("\n\n");
+    const canonicalFacts = extractCanonicalFacts(compressableMessages);
     const previousSummary = Array.isArray(state.summaries) && state.summaries.length > 0 ? state.summaries[state.summaries.length - 1] : "";
-    const defaultPrompt = `Please summarize the following conversation history and update any previous summary.
-Focus on:
-- User goals and intent.
-- Key decisions made and actions taken.
-- Important tool outputs and data retrieved.
-- Current state of the task.
+    const previousStructuredSummary = Array.isArray(state.summaryRecords) && state.summaryRecords.length > 0 ? state.summaryRecords[state.summaryRecords.length - 1] : void 0;
+    const defaultPrompt = `Summarize the conversation into strict JSON.
+
+Return exactly one JSON object with this schema:
+{
+  "stable_facts": [{ "key": string, "value": string, "confidence": number }],
+  "active_goals": [string],
+  "open_questions": [string],
+  "discarded_obsolete": [string],
+  "rawSummary": string
+}
+
+Rules:
+- Keep stable_facts only for facts that future turns must remember.
+- Put invalidated or superseded fact keys in discarded_obsolete.
+- Preserve active_goals still relevant to the user.
+- Preserve unresolved questions.
+- Do not include prose outside JSON.
+- Target compression ratio: ${config.summaryCompressionRatioTarget}.
+- Summary mode: ${config.summaryMode}.
 
-Previous summary (if any):
+Previous summary text:
 ${previousSummary || "(none)"}
 
+Previous structured summary:
+${previousStructuredSummary ? JSON.stringify(previousStructuredSummary) : "(none)"}
+
 Conversation:
 ${conversationText}
 
-Summary:`;
+Canonical facts extracted from tool outputs:
+${canonicalFacts.length > 0 ? canonicalFacts.map((fact) => `- ${fact.key}: ${fact.value}`).join("\n") : "(none)"}`;
     const template = config.promptTemplate || defaultPrompt;
     const promptBody = template.replace(/\{\{\s*conversation\s*\}\}/g, conversationText).replace(/\{\{\s*previousSummary\s*\}\}/g, previousSummary || "");
     const summaryPrompt = [
-      systemMessage("You are a helpful assistant that summarizes conversation history efficiently."),
+      systemMessage("You are a helpful assistant that summarizes conversation history efficiently. Return strict JSON only."),
       humanMessage(promptBody)
     ];
     const inputTokensEstimate = countApproxTokens(summaryPrompt.map((m) => m.content).join("\n"));
     let summaryText = "Summary unavailable.";
+    let structuredSummary;
+    let integrity;
     let outputTokensEstimate = 0;
     let durationMs = 0;
     let inputTokensActual;
@@ -2756,10 +3822,23 @@ Summary:`;
     let totalTokensActual;
     const startTime = Date.now();
     try {
+      if (!model || typeof model.invoke !== "function") {
+        throw new Error("Summarization model is unavailable.");
+      }
       const response = await model.invoke(summaryPrompt);
       durationMs = Date.now() - startTime;
       summaryText = typeof response.content === "string" ? response.content : Array.isArray(response.content) ? response.content.map((c) => c.text || "").join("") : JSON.stringify(response.content);
       outputTokensEstimate = countApproxTokens(summaryText);
+      const jsonText = extractJsonObject(summaryText);
+      const parsed = jsonText ? JSON.parse(jsonText) : void 0;
+      structuredSummary = normalizeStructuredSummary(parsed, summaryText);
+      structuredSummary = mergeStableFacts(structuredSummary, canonicalFacts);
+      integrity = config.integrityCheck ? runIntegrityCheck(previousStructuredSummary, structuredSummary) : { passed: true, criticalFactLoss: false, obsoleteFactRevived: false, notes: [] };
+      if (integrity && !integrity.passed) {
+        structuredSummary = repairStructuredSummary(previousStructuredSummary, structuredSummary, integrity);
+        integrity = { ...integrity, passed: true };
+      }
+      summaryText = renderStructuredSummary(structuredSummary);
       const rawUsage = response?.usage || response?.response_metadata?.token_usage || response?.response_metadata?.tokenUsage || response?.response_metadata?.usage;
       const normalized = normalizeUsage(rawUsage);
       if (normalized) {
@@ -2770,17 +3849,22 @@ Summary:`;
       }
     } catch (err) {
       durationMs = Date.now() - startTime;
-      console.error("[ContextSummarize] Failed to generate summary:", err);
+      structuredSummary = normalizeStructuredSummary(void 0, previousSummary || conversationText.slice(0, 800));
+      structuredSummary = mergeStableFacts(structuredSummary, canonicalFacts);
+      integrity = { passed: true, criticalFactLoss: false, obsoleteFactRevived: false, notes: ["Fallback summary generated locally."] };
+      summaryText = renderStructuredSummary(structuredSummary);
       const errorEvent = {
         type: "summarization",
-        summary: "",
-        messagesCompressed: 0,
+        summary: summaryText,
+        messagesCompressed: compressableMessages.length,
         inputTokens: inputTokensEstimate,
-        outputTokens: 0,
+        outputTokens: countApproxTokens(summaryText),
         durationMs,
         previousSummary: previousSummary || void 0,
         tokenCountBefore,
-        tokenCountAfter: tokenCountBefore
+        tokenCountAfter: tokenCountBefore,
+        structuredSummary,
+        integrity
       };
       onEvent?.(errorEvent);
       recordTraceEvent(traceSession, {
@@ -2790,11 +3874,10 @@ Summary:`;
         status: "error",
         durationMs,
         inputTokens: inputTokensEstimate,
-        outputTokens: 0,
+        outputTokens: countApproxTokens(summaryText),
         error: { message: err?.message || String(err), stack: err?.stack },
         messageList: sanitizeTracePayload(summaryPrompt)
       });
-      return {};
     }
     const toolCallIdToAssistantIdx = /* @__PURE__ */ new Map();
     messages.forEach((m, idx) => {
@@ -2808,6 +3891,9 @@ Summary:`;
     });
     const newMessages = messages.map((m) => {
       if (m.role === "tool") {
+        if (isSyntheticSummaryToolMessage(m)) {
+          return m;
+        }
         const toolCallId = m.tool_call_id;
         if (!toolCallId || !toolCallIdToAssistantIdx.has(toolCallId)) {
           return null;
@@ -2845,6 +3931,7 @@ Summary:`;
       content: summaryText
     };
     const summaries = Array.isArray(state.summaries) ? [...state.summaries, summaryText] : [summaryText];
+    const summaryRecords = Array.isArray(state.summaryRecords) ? [...state.summaryRecords, { ...structuredSummary || normalizeStructuredSummary(void 0, summaryText), integrity, createdAt: (/* @__PURE__ */ new Date()).toISOString() }] : [{ ...structuredSummary || normalizeStructuredSummary(void 0, summaryText), integrity, createdAt: (/* @__PURE__ */ new Date()).toISOString() }];
     const finalMessages = [...validatedMessages, assistantSummaryCall, toolSummaryResponse];
     const allTextAfter = finalMessages.map((m) => typeof m.content === "string" ? m.content : Array.isArray(m.content) ? m.content.map((c) => typeof c === "string" ? c : c?.text ?? c?.content ?? "").join("") : "").join("\n");
     const tokenCountAfter = countApproxTokens(allTextAfter);
@@ -2860,8 +3947,10 @@ Summary:`;
       previousSummary: previousSummary || void 0,
       tokenCountBefore,
       tokenCountAfter,
-      archivedCount: compressableMessages.length
+      archivedCount: compressableMessages.length,
       // deprecated field for backward compatibility
+      structuredSummary,
+      integrity
     };
     onEvent?.(summarizationEvent);
     recordTraceEvent(traceSession, {
@@ -2885,12 +3974,19 @@ Summary:`;
         tokensSaved: tokenCountBefore - tokenCountAfter,
         previousSummaryLength: previousSummary?.length || 0,
         usageFromModel: inputTokensActual !== void 0,
-        cachedInputTokens
+        cachedInputTokens,
+        integrity
       }
     });
     return {
       messages: finalMessages,
-      summaries
+      summaries,
+      summaryRecords,
+      watchdog: {
+        ...state.watchdog || {},
+        compactions: (state.watchdog?.compactions || 0) + 1,
+        lastAction: "summarized"
+      }
     };
   };
 }
@@ -2913,38 +4009,200 @@ async function applyTokenLimits({
   }
   return { ...state, messages: newMessages };
 }
+var todoStatusSchema = zod.z.enum(["not-started", "in-progress", "completed", "blocked"]);
+var todoWriteItemSchema = zod.z.object({
+  id: zod.z.number().int().min(1).describe("Sequential id starting from 1"),
+  step: zod.z.string().min(1).optional(),
+  title: zod.z.string().min(1).optional(),
+  description: zod.z.string().min(1).optional(),
+  owner: zod.z.string().min(1).optional(),
+  exitCriteria: zod.z.string().min(1).optional(),
+  status: todoStatusSchema,
+  evidence: zod.z.string().max(300).optional()
+});
+var todoUpdateItemSchema = zod.z.object({
+  id: zod.z.number().int().min(1).describe("Existing todo id to update"),
+  step: zod.z.string().min(1).optional(),
+  title: zod.z.string().min(1).optional(),
+  description: zod.z.string().min(1).optional(),
+  owner: zod.z.string().min(1).optional(),
+  exitCriteria: zod.z.string().min(1).optional(),
+  status: todoStatusSchema.optional(),
+  evidence: zod.z.string().max(300).optional()
+});
+function normalizeTodoItem(item, existing) {
+  const id = item.id ?? existing?.id;
+  const step = item.step || item.title || item.description || existing?.step || existing?.title || existing?.description || `Step ${id}`;
+  const title = item.title || item.step || existing?.title || existing?.step || `Step ${id}`;
+  const description = item.description || item.step || item.title || existing?.description || existing?.step || existing?.title || `Step ${id}`;
+  return {
+    ...existing,
+    ...item,
+    id,
+    step,
+    title,
+    description,
+    owner: item.owner || existing?.owner || "agent",
+    exitCriteria: item.exitCriteria || existing?.exitCriteria || description || `Complete step ${id}`,
+    status: item.status || existing?.status,
+    evidence: item.evidence ?? existing?.evidence
+  };
+}
+function validatePlanInvariants(todoList, requireSequentialIds) {
+  const ids = todoList.map((item) => item.id);
+  const uniqueIds = new Set(ids);
+  if (uniqueIds.size !== ids.length) {
+    return { ok: false, error: "Todo ids must be unique." };
+  }
+  if (requireSequentialIds) {
+    const expectedIds = Array.from({ length: todoList.length }, (_, index) => index + 1);
+    const isSequential = ids.every((id, index) => id === expectedIds[index]);
+    if (!isSequential) {
+      return { ok: false, error: "Todo ids must be sequential starting from 1 for write operations." };
+    }
+  }
+  const inProgressCount = todoList.filter((item) => item.status === "in-progress").length;
+  if (inProgressCount > 1) {
+    return { ok: false, error: "Only one todo item may be in-progress at a time." };
+  }
+  return { ok: true };
+}
+function calculateAdherenceScore(todoList) {
+  const completedCount = todoList.filter((item) => item.status === "completed").length;
+  return todoList.length === 0 ? 1 : Number((completedCount / todoList.length).toFixed(2));
+}
 function createContextTools(stateRef, opts) {
   const tools = [];
   if (opts?.planningEnabled) {
     const manageTodo = createTool({
       name: "manage_todo_list",
-      description: "Manage a structured todo list to track progress and plan tasks throughout your coding session. Use this tool VERY frequently to ensure task visibility and proper planning.\n\nWhen to use this tool:\n- Complex multi-step work requiring planning and tracking\n- When user provides multiple tasks or requests (numbered/comma-separated)\n- After receiving new instructions that require multiple steps\n- BEFORE starting work on any todo (mark as in-progress)\n- IMMEDIATELY after completing each todo (mark completed individually)\n- When breaking down larger tasks into smaller actionable steps\n- To give users visibility into your progress and planning\n\nWhen NOT to use:\n- Single, trivial tasks that can be completed in one step\n- Purely conversational/informational requests\n- When just reading files or performing simple searches\n\nCRITICAL workflow:\n1. Plan tasks by writing todo list with specific, actionable items\n2. Complete the work for that specific todo\n3. Mark that todo as completed IMMEDIATELY\n4. Move to next todo and repeat\n\nTodo states:\n- not-started: Todo not yet begun\n- in-progress: Currently working (limit ONE at a time)\n- completed: Finished successfully\n\nIMPORTANT: Mark todos completed as soon as they are done. Do not batch completions.",
+      description: "Manage a structured todo list to track progress and plan tasks throughout your coding session.\n\nOperations:\n- read: return the current plan\n- write: replace the full plan with a complete ordered todoList\n- update: patch existing todo items by id without resending the whole plan\n\nRules:\n- Use write only when creating or fully rewriting the plan\n- After a plan exists, prefer update for status, evidence, or owner changes\n- Update payloads should contain only the changed items\n- When using update, pass expectedVersion to avoid overwriting a newer plan\n- Keep ids unique; write operations must keep ids sequential starting from 1\n- Keep at most ONE item in-progress at a time\n- If update fails due to version mismatch, read the latest plan and retry",
       schema: zod.z.object({
-        operation: zod.z.enum(["write", "read"]),
-        todoList: zod.z.array(zod.z.object({
-          id: zod.z.number().int().min(1).describe("Sequential id starting from 1"),
-          title: zod.z.string().min(1),
-          description: zod.z.string().min(1),
-          status: zod.z.enum(["not-started", "in-progress", "completed"]),
-          evidence: zod.z.string().max(200).optional()
-        })).optional()
+        operation: zod.z.enum(["write", "read", "update"]),
+        expectedVersion: zod.z.number().int().min(0).optional(),
+        todoList: zod.z.array(zod.z.union([todoWriteItemSchema, todoUpdateItemSchema])).optional()
       }),
-      func: async ({ operation, todoList }) => {
+      func: async ({ operation, expectedVersion, todoList }) => {
         const onEvent = manageTodo._stateRef?.__onEvent;
+        const currentVersion = stateRef.planVersion || 0;
         if (operation === "read") {
           const list = stateRef.todoList || [];
-          onEvent?.({ type: "plan", source: "manage_todo_list", operation: "read", todoList: list });
+          onEvent?.({ type: "plan", source: "manage_todo_list", operation: "read", todoList: list, version: stateRef.planVersion || 1, adherenceScore: stateRef.adherenceScore || 0 });
           return list;
         }
-        if (Array.isArray(todoList)) {
-          stateRef.todoList = todoList;
+        if (typeof expectedVersion === "number" && expectedVersion !== currentVersion) {
+          return {
+            status: "error",
+            operation,
+            error: "Plan version mismatch. Read the latest plan and retry.",
+            version: currentVersion,
+            adherenceScore: stateRef.adherenceScore || 0
+          };
+        }
+        if (!Array.isArray(todoList)) {
+          return {
+            status: "error",
+            operation,
+            error: "todoList is required for write and update operations.",
+            version: currentVersion,
+            adherenceScore: stateRef.adherenceScore || 0
+          };
         }
+        if (operation === "write") {
+          const parsed = zod.z.array(todoWriteItemSchema).safeParse(todoList);
+          if (!parsed.success) {
+            return {
+              status: "error",
+              operation,
+              error: parsed.error.issues[0]?.message || "Invalid todoList for write.",
+              version: currentVersion,
+              adherenceScore: stateRef.adherenceScore || 0
+            };
+          }
+          const normalizedList = parsed.data.map((item) => normalizeTodoItem(item));
+          const validation = validatePlanInvariants(normalizedList, true);
+          if (!validation.ok) {
+            return {
+              status: "error",
+              operation,
+              error: validation.error,
+              version: currentVersion,
+              adherenceScore: stateRef.adherenceScore || 0
+            };
+          }
+          stateRef.todoList = normalizedList;
+        } else if (operation === "update") {
+          const parsed = zod.z.array(todoUpdateItemSchema).safeParse(todoList);
+          if (!parsed.success) {
+            return {
+              status: "error",
+              operation,
+              error: parsed.error.issues[0]?.message || "Invalid todoList for update.",
+              version: currentVersion,
+              adherenceScore: stateRef.adherenceScore || 0
+            };
+          }
+          const currentList = Array.isArray(stateRef.todoList) ? stateRef.todoList : [];
+          if (currentList.length === 0) {
+            return {
+              status: "error",
+              operation,
+              error: "No existing plan to update. Use write first.",
+              version: currentVersion,
+              adherenceScore: stateRef.adherenceScore || 0
+            };
+          }
+          const patchIds = /* @__PURE__ */ new Set();
+          for (const item of parsed.data) {
+            if (patchIds.has(item.id)) {
+              return {
+                status: "error",
+                operation,
+                error: "Update payload contains duplicate todo ids.",
+                version: currentVersion,
+                adherenceScore: stateRef.adherenceScore || 0
+              };
+            }
+            patchIds.add(item.id);
+          }
+          const currentMap = new Map(currentList.map((item) => [item.id, item]));
+          for (const item of parsed.data) {
+            if (!currentMap.has(item.id)) {
+              return {
+                status: "error",
+                operation,
+                error: `Cannot update missing todo id ${item.id}. Use write to replace the plan.`,
+                version: currentVersion,
+                adherenceScore: stateRef.adherenceScore || 0
+              };
+            }
+          }
+          const mergedList = currentList.map((item) => {
+            const patch = parsed.data.find((candidate) => candidate.id === item.id);
+            return patch ? normalizeTodoItem(patch, item) : item;
+          });
+          const validation = validatePlanInvariants(mergedList, false);
+          if (!validation.ok) {
+            return {
+              status: "error",
+              operation,
+              error: validation.error,
+              version: currentVersion,
+              adherenceScore: stateRef.adherenceScore || 0
+            };
+          }
+          stateRef.todoList = mergedList;
+        }
+        stateRef.planVersion = currentVersion + 1;
+        stateRef.adherenceScore = calculateAdherenceScore(stateRef.todoList || []);
         const payload = {
           status: "ok",
           operation,
-          count: Array.isArray(todoList) ? todoList.length : void 0
+          count: Array.isArray(todoList) ? todoList.length : void 0,
+          version: stateRef.planVersion || 1,
+          adherenceScore: stateRef.adherenceScore || 0
         };
-        onEvent?.({ type: "plan", source: "manage_todo_list", operation: "write", todoList });
+        onEvent?.({ type: "plan", source: "manage_todo_list", operation, todoList: stateRef.todoList, version: stateRef.planVersion || 1, adherenceScore: stateRef.adherenceScore || 0 });
         return payload;
       }
     });
@@ -2953,12 +4211,13 @@ function createContextTools(stateRef, opts) {
   }
   const getTool = createTool({
     name: "get_tool_response",
-    description: "RETRIEVE tool execution response: Use this to access the full output of a tool execution that shows as 'SUMMARIZED' in the tool history.",
+    description: "RETRIEVE tool execution response: Use this to access the full output of a tool execution that shows as 'SUMMARIZED' in the tool history. Accepts either the internal executionId or the provider tool call id shown in prior tool traces.",
     schema: zod.z.object({ executionId: zod.z.string().describe("Tool execution id") }),
     func: async ({ executionId }) => {
-      let execution = stateRef.toolHistory?.find((t) => t.executionId === executionId);
+      const matchesExecution = (t) => t?.executionId === executionId || t?.tool_call_id === executionId;
+      let execution = stateRef.toolHistory?.find((t) => matchesExecution(t));
       if (!execution) {
-        execution = stateRef.toolHistoryArchived?.find((t) => t.executionId === executionId);
+        execution = stateRef.toolHistoryArchived?.find((t) => matchesExecution(t));
       }
       if (execution) {
         return execution.rawOutput || execution.output;
@@ -2989,19 +4248,33 @@ function createContextTools(stateRef, opts) {
 }
 
 // src/graph/decisions.ts
+function isSyntheticSummaryMessage2(message) {
+  if (!message) return false;
+  if (message.role === "tool" && message.name === "summarize_context") {
+    return true;
+  }
+  if (message.role === "assistant" && Array.isArray(message.tool_calls)) {
+    return message.tool_calls.some((toolCall) => {
+      const toolName = toolCall?.function?.name || toolCall?.name;
+      return toolName === "summarize_context";
+    });
+  }
+  return false;
+}
 function needsSummarization(state, opts, summarizationEnabled) {
   if (!summarizationEnabled) {
     return false;
   }
-  let maxTok;
-  if (typeof opts.summarization === "object" && typeof opts.summarization.maxTokens === "number") {
-    maxTok = opts.summarization.maxTokens;
+  if (state.ctx?.__needsSummarization) {
+    return true;
   }
-  if (maxTok === void 0) {
-    maxTok = 5e4;
+  const resolved = getResolvedSmartConfig(opts, state.agent);
+  if (!resolved.summarization.enable) {
+    return false;
   }
+  const maxTok = resolved.summarization.summaryTriggerTokens;
   try {
-    const allText = (state.messages || []).map((m) => {
+    const allText = (state.messages || []).filter((message) => !isSyntheticSummaryMessage2(message)).map((m) => {
       if (typeof m.content === "string") return m.content;
       if (Array.isArray(m.content)) {
         return m.content.map((c) => typeof c === "string" ? c : c?.text ?? c?.content ?? JSON.stringify(c)).join("");
@@ -3012,7 +4285,8 @@ function needsSummarization(state, opts, summarizationEnabled) {
       return "";
     }).join("\n");
     const tokenCount = countApproxTokens(allText);
-    const needsSum = tokenCount > maxTok;
+    const contextRotScore = state.watchdog?.contextRotScore || 0;
+    const needsSum = tokenCount > maxTok || resolved.watchdog.enabled && resolved.watchdog.autoCompaction && contextRotScore >= resolved.watchdog.contextRotThreshold;
     if (process.env.DEBUG_SUMMARIZATION) {
       const msgCount = (state.messages || []).length;
       const toolMsgs = (state.messages || []).filter((m) => m.role === "tool");
@@ -3022,10 +4296,10 @@ function needsSummarization(state, opts, summarizationEnabled) {
       });
       console.log(`[Summarization] Messages: ${msgCount}, Tool messages: ${toolMsgs.length}`);
       toolDetails.forEach((d) => console.log(`  ${d}`));
-      console.log(`[Summarization] Token count: ${tokenCount}, Max: ${maxTok}, Needs summarization: ${needsSum}`);
+      console.log(`[Summarization] Token count: ${tokenCount}, Max: ${maxTok}, Context rot: ${contextRotScore}, Needs summarization: ${needsSum}`);
     }
     return needsSum;
-  } catch (e) {
+  } catch {
     return false;
   }
 }
@@ -3043,33 +4317,205 @@ function toolsDecisionFactory(opts, summarizationEnabled) {
   };
 }
 
+// src/smart/memory.ts
+function normalizeFact(scope, fact) {
+  return {
+    ...fact,
+    scope,
+    obsolete: fact.obsolete ?? false,
+    lastUpdatedAt: fact.lastUpdatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    confidence: Number.isFinite(fact.confidence) ? fact.confidence : 0.5
+  };
+}
+var InMemoryMemoryStore = class {
+  constructor() {
+    this.buckets = /* @__PURE__ */ new Map();
+  }
+  async get(scope, options) {
+    const includeObsolete = options?.includeObsolete === true;
+    const all = [...this.buckets.get(scope) || []].filter((fact) => includeObsolete || !fact.obsolete).sort((left, right) => new Date(right.lastUpdatedAt || 0).getTime() - new Date(left.lastUpdatedAt || 0).getTime());
+    return typeof options?.limit === "number" ? all.slice(0, options.limit) : all;
+  }
+  async upsert(scope, facts) {
+    const existing = [...this.buckets.get(scope) || []];
+    for (const fact of facts) {
+      const normalized = normalizeFact(scope, fact);
+      const sameKey = existing.filter((entry) => entry.key === normalized.key && !entry.obsolete);
+      for (const entry of sameKey) {
+        if (entry.value !== normalized.value) {
+          entry.obsolete = true;
+          entry.lastUpdatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        }
+      }
+      const match = existing.find((entry) => entry.key === normalized.key && entry.value === normalized.value && !entry.obsolete);
+      if (match) {
+        match.confidence = Math.max(match.confidence, normalized.confidence);
+        match.sourceTurn = normalized.sourceTurn;
+        match.ttl = normalized.ttl;
+        match.tags = normalized.tags;
+        match.lastUpdatedAt = normalized.lastUpdatedAt;
+      } else {
+        existing.push(normalized);
+      }
+    }
+    this.buckets.set(scope, existing);
+  }
+  async markObsolete(scope, keys) {
+    const bucket = this.buckets.get(scope) || [];
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    for (const fact of bucket) {
+      if (keys.includes(fact.key)) {
+        fact.obsolete = true;
+        fact.lastUpdatedAt = now;
+      }
+    }
+    this.buckets.set(scope, bucket);
+  }
+  async semanticSearch(scope, query, options) {
+    const normalizedQuery = query.toLowerCase();
+    const bucket = (this.buckets.get(scope) || []).filter((fact) => !fact.obsolete);
+    const scored = bucket.map((fact) => {
+      const haystack = `${fact.key} ${fact.value} ${(fact.tags || []).join(" ")}`.toLowerCase();
+      const score = haystack.includes(normalizedQuery) ? 2 : normalizedQuery.split(/\s+/).filter(Boolean).reduce((acc, token) => acc + (haystack.includes(token) ? 1 : 0), 0);
+      return { fact, score };
+    }).filter((entry) => entry.score > 0).sort((left, right) => right.score - left.score || right.fact.confidence - left.fact.confidence).map((entry) => entry.fact);
+    return typeof options?.limit === "number" ? scored.slice(0, options.limit) : scored;
+  }
+};
+function resolveMemoryStore(config) {
+  if (config.memory.store) return config.memory.store;
+  if (config.memory.provider === "inMemory") return new InMemoryMemoryStore();
+  return void 0;
+}
+async function readMemoryFacts(store, config, query) {
+  if (!store) return [];
+  const scope = config.memory.scope;
+  const limit = config.context.lastTurnsToKeep;
+  const policy = config.memory.readPolicy;
+  if (policy === "recent_only") {
+    return store.get(scope, { limit });
+  }
+  if (policy === "semantic" && typeof store.semanticSearch === "function") {
+    return store.semanticSearch(scope, query, { limit });
+  }
+  if (policy === "hybrid") {
+    const recent = await store.get(scope, { limit: Math.max(3, Math.ceil(limit / 2)) });
+    const semantic = typeof store.semanticSearch === "function" ? await store.semanticSearch(scope, query, { limit: Math.max(3, Math.ceil(limit / 2)) }) : [];
+    const deduped = /* @__PURE__ */ new Map();
+    for (const fact of [...semantic, ...recent]) {
+      deduped.set(`${fact.key}:${fact.value}`, fact);
+    }
+    return [...deduped.values()].slice(0, limit);
+  }
+  return store.get(scope, { limit });
+}
+async function writeSummaryFactsToMemory(store, config, summary, sourceTurn) {
+  if (!store || !summary) return [];
+  const facts = summary.stable_facts.map((fact) => ({
+    key: fact.key,
+    value: fact.value,
+    sourceTurn,
+    confidence: fact.confidence ?? 0.8,
+    obsolete: false,
+    tags: ["summary_fact"]
+  }));
+  if (summary.discarded_obsolete.length > 0) {
+    await store.markObsolete(config.memory.scope, summary.discarded_obsolete);
+  }
+  if (facts.length > 0) {
+    await store.upsert(config.memory.scope, facts);
+  }
+  return store.get(config.memory.scope, { limit: config.context.lastTurnsToKeep + summary.stable_facts.length });
+}
+function renderMemoryFacts(facts) {
+  if (facts.length === 0) return "";
+  return [
+    "Memory facts:",
+    ...facts.map((fact) => `- ${fact.key}: ${fact.value} (confidence ${fact.confidence.toFixed(2)})`)
+  ].join("\n");
+}
+
 // src/smart/index.ts
 function createSmartAgent(opts) {
-  const stateRef = { toolHistory: void 0, toolHistoryArchived: void 0, todoList: void 0 };
-  const planningEnabled = opts.useTodoList === true;
+  const resolved = normalizeSmartAgentOptions(opts);
+  const planningEnabled = resolved.planning.mode !== "off";
+  const memoryStore = resolveMemoryStore(resolved);
+  const runtimeOpts = {
+    ...opts,
+    runtimeProfile: resolved.runtimeProfile,
+    limits: resolved.limits,
+    summarization: resolved.summarization,
+    context: resolved.context,
+    planning: resolved.planning,
+    delegation: resolved.delegation,
+    memory: { ...resolved.memory, store: memoryStore },
+    toolResponses: resolved.toolResponses,
+    watchdog: resolved.watchdog,
+    useTodoList: planningEnabled
+  };
+  const stateRef = { toolHistory: void 0, toolHistoryArchived: void 0, todoList: void 0, planVersion: 0, adherenceScore: 0 };
   const contextTools = createContextTools(stateRef, { planningEnabled, outputSchema: void 0 });
   const mergedTools = [...opts.tools ?? [], ...contextTools];
-  const base = createAgent({ ...opts, tools: mergedTools });
-  let summarizationEnabled = false;
-  if (typeof opts.summarization === "object") {
-    summarizationEnabled = opts.summarization.enable !== false;
-  } else {
-    summarizationEnabled = opts.summarization !== false;
-  }
-  const summarizer = summarizationEnabled ? createContextSummarizeNode(opts) : void 0;
-  const decideBefore = resolverDecisionFactory(opts, summarizationEnabled);
-  const decideAfter = toolsDecisionFactory(opts, summarizationEnabled);
+  const base = createAgent({ ...runtimeOpts, tools: mergedTools });
+  base.__runtime.runtimeProfile = resolved.runtimeProfile;
+  base.__runtime.smart = resolved;
+  const summarizationEnabled = resolved.summarization.enable !== false;
+  const summarizer = summarizationEnabled ? createContextSummarizeNode(runtimeOpts) : void 0;
+  const decideBefore = resolverDecisionFactory(runtimeOpts, summarizationEnabled);
+  const decideAfter = toolsDecisionFactory(runtimeOpts, summarizationEnabled);
   const structuredOutputHint = opts.outputSchema ? [
     "A structured output schema is active.",
     "Do NOT output the final JSON directly as an assistant message.",
     "When completely finished, call tool `response` passing the final JSON matching the schema as its arguments (direct object).",
     "Call it exactly once then STOP producing further assistant messages."
   ].join("\n") : "";
+  const runtimeHint = [
+    resolved.runtimeProfile === resolved.baseProfile ? `Runtime profile: ${resolved.runtimeProfile}.` : `Runtime profile: ${resolved.runtimeProfile} (base: ${resolved.baseProfile}).`,
+    `Context policy: ${resolved.context.policy}.`,
+    `Planning mode: ${resolved.planning.mode}. Replan policy: ${resolved.planning.replanPolicy}.`,
+    `Delegation mode: ${resolved.delegation.mode}. Child context policy: ${resolved.delegation.childContextPolicy}.`,
+    `Tool response policy: ${resolved.context.toolResponsePolicy}.`
+  ].join("\n");
+  function latestUserPrompt(messages) {
+    const latest = [...messages].reverse().find((message) => message.role === "user");
+    if (!latest) return "";
+    return typeof latest.content === "string" ? latest.content : Array.isArray(latest.content) ? latest.content.map((part) => typeof part === "string" ? part : part?.text ?? part?.content ?? "").join(" ") : "";
+  }
+  async function syncMemory(state) {
+    const query = latestUserPrompt(state.messages || []);
+    const memoryFacts = await readMemoryFacts(memoryStore, resolved, query);
+    return { ...state, memoryFacts };
+  }
+  async function persistLatestSummary(state) {
+    if (!memoryStore) return state;
+    if (resolved.memory.writePolicy === "manual") return state;
+    const latestSummary = state.summaryRecords?.[state.summaryRecords.length - 1];
+    if (!latestSummary) return state;
+    if (resolved.memory.writePolicy === "auto_important" && latestSummary.stable_facts.length === 0) {
+      return state;
+    }
+    const memoryFacts = await writeSummaryFactsToMemory(memoryStore, resolved, latestSummary, Math.max(1, (state.messages || []).filter((message) => message.role === "user").length));
+    return { ...state, memoryFacts };
+  }
+  function syncPlanState(state) {
+    if (!Array.isArray(stateRef.todoList)) return state;
+    return {
+      ...state,
+      plan: {
+        version: stateRef.planVersion || state.planVersion || 1,
+        steps: stateRef.todoList,
+        lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+        adherenceScore: stateRef.adherenceScore || 0
+      },
+      planVersion: stateRef.planVersion || state.planVersion || 1
+    };
+  }
   function systemMessage2() {
     const sys = buildSystemPrompt(
-      [opts.systemPrompt, structuredOutputHint].filter(Boolean).join("\n"),
-      opts.useTodoList === true,
-      opts.name || "Agent"
+      [opts.systemPrompt, runtimeHint, structuredOutputHint].filter(Boolean).join("\n"),
+      planningEnabled,
+      opts.name || "Agent",
+      opts.todoListPrompt
     );
     return { role: "system", content: sys };
   }
@@ -3077,38 +4523,81 @@ function createSmartAgent(opts) {
     invoke: async (input, config) => {
       stateRef.toolHistory = input.toolHistory;
       stateRef.toolHistoryArchived = input.toolHistoryArchived;
+      stateRef.todoList = input.plan?.steps;
+      stateRef.planVersion = input.planVersion || input.plan?.version || 0;
+      stateRef.adherenceScore = input.plan?.adherenceScore || 0;
       const alreadyHasSystem = Array.isArray(input.messages) && input.messages[0]?.role === "system";
       const seedMessages = alreadyHasSystem ? [...input.messages || []] : [systemMessage2(), ...input.messages || []];
-      let state = { ...input, messages: seedMessages };
+      let state = await syncMemory({ ...input, messages: seedMessages });
       let lastResult = null;
-      const effectiveMaxToolCalls = config?.limits?.maxToolCalls ?? opts.limits?.maxToolCalls ?? 10;
+      let rawMessages = [...seedMessages];
+      const effectiveMaxToolCalls = config?.limits?.maxToolCalls ?? resolved.limits.maxToolCalls ?? 10;
       const iterationLimit = Math.max(effectiveMaxToolCalls * 3 + 5, 30);
+      let previousTokenCount = countApproxTokens(rawMessages.map((message) => typeof message.content === "string" ? message.content : JSON.stringify(message.content)).join("\n"));
       for (let i = 0; i < iterationLimit; i++) {
+        state = { ...state, messages: rawMessages };
         const next = summarizationEnabled ? decideBefore(state) : "agent";
         if (next === "contextSummarize" && summarizer) {
           const delta = await summarizer(state);
           if (!delta || Object.keys(delta).length === 0) ; else {
-            state = { ...state, ...delta };
+            state = await persistLatestSummary(syncPlanState({ ...state, ...delta }));
+            rawMessages = [...state.messages || rawMessages];
             continue;
           }
         }
-        const res = await base.invoke(state, config);
+        const modelMessages = buildModelMessages(state, resolved);
+        const res = await base.invoke({ ...state, messages: modelMessages }, config);
         lastResult = res;
         const currentSummaries = state.summaries;
+        const currentSummaryRecords = state.summaryRecords;
+        const currentPlan = state.plan;
+        const appendedMessages = res.messages.slice(modelMessages.length);
+        rawMessages = [...rawMessages, ...appendedMessages];
         state = res.state || { ...state, messages: res.messages };
+        state = { ...state, messages: rawMessages };
         if (currentSummaries && currentSummaries.length > 0 && (!state.summaries || state.summaries.length === 0)) {
           state = { ...state, summaries: currentSummaries };
         }
-        if (state.ctx?.__awaitingApproval || state.ctx?.__waitingForInput) break;
+        if (currentSummaryRecords && currentSummaryRecords.length > 0 && (!state.summaryRecords || state.summaryRecords.length === 0)) {
+          state = { ...state, summaryRecords: currentSummaryRecords };
+        }
+        if (currentPlan && !state.plan) {
+          state = { ...state, plan: currentPlan };
+        }
+        state = syncPlanState(await syncMemory(state));
+        stateRef.toolHistory = state.toolHistory;
+        stateRef.toolHistoryArchived = state.toolHistoryArchived;
+        const currentTokenCount = countApproxTokens(rawMessages.map((message) => typeof message.content === "string" ? message.content : JSON.stringify(message.content)).join("\n"));
+        const tokenDrift = Math.max(0, currentTokenCount - previousTokenCount);
+        const toolMessagesThisTurn = appendedMessages.filter((message) => message.role === "tool").length;
+        const overToolingRate = appendedMessages.length === 0 ? 0 : Number((toolMessagesThisTurn / appendedMessages.length).toFixed(2));
+        state = {
+          ...state,
+          watchdog: {
+            tokenDrift,
+            contextRotScore: estimateContextRotScore(state),
+            overToolingRate,
+            compactions: state.watchdog?.compactions || 0,
+            lastAction: appendedMessages.length > 0 ? "agent_turn" : state.watchdog?.lastAction
+          }
+        };
+        previousTokenCount = currentTokenCount;
+        if (resolved.watchdog.enabled && resolved.watchdog.autoCompaction) {
+          const shouldCompact = tokenDrift >= resolved.watchdog.tokenDriftThreshold || (state.watchdog?.overToolingRate || 0) >= resolved.watchdog.overToolingSpikeThreshold || (state.watchdog?.contextRotScore || 0) >= resolved.watchdog.contextRotThreshold;
+          if (shouldCompact) {
+            state = { ...state, ctx: { ...state.ctx || {}, __needsSummarization: true } };
+          }
+        }
         if (state.ctx?.__needsSummarization && summarizer) {
           const ctx = { ...state.ctx || {} };
           delete ctx.__needsSummarization;
           state = { ...state, ctx };
           const delta = await summarizer(state);
           if (delta && Object.keys(delta).length > 0) {
-            state = { ...state, ...delta };
+            state = await persistLatestSummary(syncPlanState({ ...state, ...delta }));
+            rawMessages = [...state.messages || rawMessages];
+            continue;
           }
-          continue;
         }
         if (state.ctx?.__finalizedDueToStructuredOutput) break;
         if (summarizationEnabled) {
@@ -3116,7 +4605,8 @@ function createSmartAgent(opts) {
           if (after === "contextSummarize" && summarizer) {
             const delta = await summarizer(state);
             if (delta && Object.keys(delta).length > 0) {
-              state = { ...state, ...delta };
+              state = await persistLatestSummary(syncPlanState({ ...state, ...delta }));
+              rawMessages = [...state.messages || rawMessages];
               continue;
             }
           }
@@ -3129,10 +4619,12 @@ function createSmartAgent(opts) {
       }
       if (state.summaries && state.summaries.length > 0) {
         if (lastResult.state) {
-          lastResult = { ...lastResult, state: { ...lastResult.state, summaries: state.summaries } };
+          lastResult = { ...lastResult, state: { ...lastResult.state, summaries: state.summaries, summaryRecords: state.summaryRecords, memoryFacts: state.memoryFacts, plan: state.plan, planVersion: state.planVersion, watchdog: state.watchdog, messages: rawMessages } };
         } else {
-          lastResult = { ...lastResult, state: { ...state, summaries: state.summaries } };
+          lastResult = { ...lastResult, state: { ...state, summaries: state.summaries, summaryRecords: state.summaryRecords, memoryFacts: state.memoryFacts, plan: state.plan, planVersion: state.planVersion, watchdog: state.watchdog, messages: rawMessages } };
         }
+      } else if (lastResult.state) {
+        lastResult = { ...lastResult, state: { ...lastResult.state, memoryFacts: state.memoryFacts, plan: state.plan, planVersion: state.planVersion, watchdog: state.watchdog, messages: rawMessages } };
       }
       return lastResult;
     },
@@ -3146,6 +4638,141 @@ function createSmartAgent(opts) {
   return instance;
 }
 
+// src/smart/eval.ts
+function normalizeProfileTarget(target) {
+  if (typeof target === "string") {
+    return {
+      label: target,
+      runtimeProfile: target,
+      baseProfile: target === "custom" ? "balanced" : target
+    };
+  }
+  return {
+    label: target.label,
+    runtimeProfile: target.runtimeProfile,
+    baseProfile: target.baseProfile ?? (target.runtimeProfile === "custom" ? target.customProfile?.extends ?? "balanced" : target.runtimeProfile),
+    customProfile: target.customProfile
+  };
+}
+function normalizeText(value) {
+  return (value || "").toLowerCase();
+}
+function ratio(numerator, denominator) {
+  if (denominator <= 0) return 1;
+  return Number((numerator / denominator).toFixed(3));
+}
+function sum(values) {
+  return values.reduce((acc, value) => acc + value, 0);
+}
+function mean(values) {
+  if (values.length === 0) return 0;
+  return Number((sum(values) / values.length).toFixed(3));
+}
+function extractTotalTokens(usage) {
+  if (!usage?.totals || typeof usage.totals !== "object") return 0;
+  return Object.values(usage.totals).reduce((acc, entry) => acc + (Number(entry?.total) || 0), 0);
+}
+function caseResultFromRun(descriptor, testCase, content, events, state, latencyMs, totalTokens) {
+  const normalizedContent = normalizeText(content);
+  const matchedPhrases = (testCase.expectedPhrases || []).filter((phrase) => normalizedContent.includes(normalizeText(phrase)));
+  const matchedFacts = (testCase.expectedFacts || []).filter((fact) => {
+    const memoryMatch = state?.memoryFacts?.some((entry) => entry.key === fact.key && normalizeText(entry.value).includes(normalizeText(fact.value)));
+    const summaryMatch = state?.summaryRecords?.some((record) => record.stable_facts.some((entry) => entry.key === fact.key && normalizeText(entry.value).includes(normalizeText(fact.value))));
+    return Boolean(memoryMatch || summaryMatch || normalizedContent.includes(normalizeText(fact.value)));
+  });
+  const forbiddenMisses = (testCase.forbiddenPhrases || []).filter((phrase) => !normalizedContent.includes(normalizeText(phrase)));
+  const toolCalls = events.filter((event) => event.type === "tool_call" && event.phase === "success");
+  const expectedToolHits = (testCase.expectedToolNames || []).filter((toolName) => toolCalls.some((event) => event.name === toolName));
+  const toolPrecision = ratio(expectedToolHits.length, Math.max(toolCalls.length, 1));
+  const recallAccuracy = ratio(matchedPhrases.length + matchedFacts.length, (testCase.expectedPhrases?.length || 0) + (testCase.expectedFacts?.length || 0));
+  const obsoleteDropAccuracy = ratio(forbiddenMisses.length, testCase.forbiddenPhrases?.length || 0);
+  const trajectoryScore = ratio(expectedToolHits.length, testCase.expectedToolNames?.length || 0);
+  const hadRecoverableError = events.some((event) => event.type === "tool_call" && event.phase === "error");
+  const recoveryRate = hadRecoverableError ? Number((normalizedContent.length > 0 ? 1 : 0).toFixed(3)) : 1;
+  const overToolingRate = toolCalls.length === 0 ? 0 : Number((Math.max(0, toolCalls.length - Math.max(testCase.expectedToolNames?.length || 0, 1)) / toolCalls.length).toFixed(3));
+  const success = recallAccuracy >= 0.8 && obsoleteDropAccuracy >= 0.8;
+  return {
+    id: testCase.id,
+    family: testCase.family,
+    success,
+    recallAccuracy,
+    obsoleteDropAccuracy,
+    trajectoryScore: Number(((trajectoryScore + toolPrecision) / 2).toFixed(3)),
+    recoveryRate,
+    overToolingRate,
+    latencyMs,
+    totalTokens,
+    profile: descriptor.runtimeProfile,
+    profileLabel: descriptor.label,
+    baseProfile: descriptor.baseProfile,
+    notes: success ? [] : [
+      recallAccuracy < 0.8 ? "Recall below threshold." : "",
+      obsoleteDropAccuracy < 0.8 ? "Obsolete filtering below threshold." : "",
+      trajectoryScore < 0.5 ? "Tool trajectory diverged from expectation." : ""
+    ].filter(Boolean)
+  };
+}
+function aggregateMetrics(caseResults) {
+  const taskSuccess = ratio(caseResults.filter((result) => result.success).length, caseResults.length);
+  const recallAccuracy = mean(caseResults.map((result) => result.recallAccuracy));
+  const obsoleteDropAccuracy = mean(caseResults.map((result) => result.obsoleteDropAccuracy));
+  const trajectoryScore = mean(caseResults.map((result) => result.trajectoryScore));
+  const recoveryRate = mean(caseResults.map((result) => result.recoveryRate));
+  const overToolingRate = mean(caseResults.map((result) => result.overToolingRate));
+  const latencyMs = mean(caseResults.map((result) => result.latencyMs));
+  const totalTokens = sum(caseResults.map((result) => result.totalTokens || 0));
+  const toolPrecision = trajectoryScore;
+  const costScore = totalTokens <= 0 ? 1 : Number((1 / (1 + totalTokens / 1e4)).toFixed(3));
+  const score = Number((0.45 * taskSuccess + 0.2 * trajectoryScore + 0.15 * toolPrecision + 0.1 * recoveryRate + 0.1 * costScore).toFixed(3));
+  return {
+    taskSuccess,
+    recallAccuracy,
+    obsoleteDropAccuracy,
+    trajectoryScore,
+    recoveryRate,
+    overToolingRate,
+    latencyMs,
+    totalTokens,
+    score
+  };
+}
+async function runSmartAgentEvalHarness(params) {
+  const results = [];
+  for (const profileTarget of params.profiles) {
+    const descriptor = normalizeProfileTarget(profileTarget);
+    const caseResults = [];
+    for (const testCase of params.cases) {
+      const agent = params.createAgent(descriptor.runtimeProfile, descriptor);
+      const events = [];
+      const startedAt = Date.now();
+      const result = await agent.invoke({
+        messages: [{ role: "user", content: testCase.prompt }]
+      }, {
+        onEvent: (event) => {
+          events.push(event);
+        }
+      });
+      caseResults.push(caseResultFromRun(
+        descriptor,
+        testCase,
+        result.content,
+        events,
+        result.state,
+        Date.now() - startedAt,
+        extractTotalTokens(result.metadata?.usage)
+      ));
+    }
+    results.push({
+      profile: descriptor.runtimeProfile,
+      profileLabel: descriptor.label,
+      baseProfile: descriptor.baseProfile,
+      metrics: aggregateMetrics(caseResults),
+      cases: caseResults
+    });
+  }
+  return results;
+}
+
 // src/utils/content.ts
 function contentToString(content) {
   try {
@@ -3423,7 +5050,9 @@ function createCodeGuardrail(options) {
   });
 }
 
+exports.DEFAULT_PROFILE_CONFIGS = DEFAULT_PROFILE_CONFIGS;
 exports.GuardrailPhase = GuardrailPhase;
+exports.InMemoryMemoryStore = InMemoryMemoryStore;
 exports.agentVerdictRule = agentVerdictRule;
 exports.applyTokenLimits = applyTokenLimits;
 exports.buildSystemPrompt = buildSystemPrompt;
@@ -3451,13 +5080,24 @@ exports.evaluateGuardrails = evaluateGuardrails;
 exports.fileSink = fileSink;
 exports.fromLangchainModel = fromLangchainModel;
 exports.fromLangchainTools = fromLangchainTools;
+exports.generateSpanId = generateSpanId;
+exports.generateTraceId = generateTraceId;
+exports.getResolvedSmartConfig = getResolvedSmartConfig;
 exports.httpSink = httpSink;
 exports.isSmartModel = isSmartModel;
 exports.jsonSchemaRule = jsonSchemaRule;
+exports.normalizeSmartAgentOptions = normalizeSmartAgentOptions;
+exports.otlpSink = otlpSink;
+exports.readMemoryFacts = readMemoryFacts;
 exports.regexRule = regexRule;
+exports.renderMemoryFacts = renderMemoryFacts;
+exports.resolveMemoryStore = resolveMemoryStore;
 exports.resolveToolApprovalState = resolveToolApprovalState;
 exports.restoreSnapshot = restoreSnapshot;
+exports.runSmartAgentEvalHarness = runSmartAgentEvalHarness;
 exports.startStreamingSession = startStreamingSession;
+exports.traceSessionToOtlp = traceSessionToOtlp;
 exports.withTools = withTools;
+exports.writeSummaryFactsToMemory = writeSummaryFactsToMemory;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map