@lmthing/repl 0.0.1

package/dist/index.js

@@ -0,0 +1,3809 @@
+// src/session/session.ts
+import { EventEmitter } from "events";
+
+// src/session/config.ts
+import { z } from "zod";
+var DEFAULT_CONFIG = {
+  functionTimeout: 3e4,
+  askTimeout: 3e5,
+  sessionTimeout: 6e5,
+  maxStopCalls: 50,
+  maxAsyncTasks: 10,
+  maxTasklistReminders: 3,
+  maxTaskRetries: 3,
+  maxTasksPerTasklist: 20,
+  taskAsyncTimeout: 6e4,
+  sleepMaxSeconds: 30,
+  maxContextTokens: 1e5,
+  serializationLimits: {
+    maxStringLength: 2e3,
+    maxArrayElements: 50,
+    maxObjectKeys: 20,
+    maxDepth: 5
+  },
+  workspace: {
+    maxScopeVariables: 50,
+    maxScopeValueWidth: 50,
+    maxScopeTokens: 3e3
+  },
+  contextWindow: {
+    codeWindowLines: 200,
+    stopDecayTiers: {
+      full: 2,
+      keysOnly: 5,
+      summary: 10
+    },
+    neverTruncateInterventions: true
+  }
+};
+function createDefaultConfig() {
+  return structuredClone(DEFAULT_CONFIG);
+}
+var sessionConfigSchema = z.object({
+  functionTimeout: z.number().positive().optional(),
+  askTimeout: z.number().positive().optional(),
+  sessionTimeout: z.number().positive().optional(),
+  maxStopCalls: z.number().int().positive().optional(),
+  maxAsyncTasks: z.number().int().positive().optional(),
+  maxTasklistReminders: z.number().int().positive().optional(),
+  maxTaskRetries: z.number().int().positive().optional(),
+  maxTasksPerTasklist: z.number().int().positive().optional(),
+  taskAsyncTimeout: z.number().int().positive().optional(),
+  sleepMaxSeconds: z.number().int().positive().optional(),
+  maxContextTokens: z.number().int().positive().optional(),
+  serializationLimits: z.object({
+    maxStringLength: z.number().int().positive().optional(),
+    maxArrayElements: z.number().int().positive().optional(),
+    maxObjectKeys: z.number().int().positive().optional(),
+    maxDepth: z.number().int().positive().optional()
+  }).optional(),
+  workspace: z.object({
+    maxScopeVariables: z.number().int().positive().optional(),
+    maxScopeValueWidth: z.number().int().positive().optional(),
+    maxScopeTokens: z.number().int().positive().optional()
+  }).optional(),
+  contextWindow: z.object({
+    codeWindowLines: z.number().int().positive().optional(),
+    stopDecayTiers: z.object({
+      full: z.number().int().nonnegative().optional(),
+      keysOnly: z.number().int().nonnegative().optional(),
+      summary: z.number().int().nonnegative().optional()
+    }).optional(),
+    neverTruncateInterventions: z.boolean().optional()
+  }).optional()
+});
+function validateConfig(input) {
+  const result = sessionConfigSchema.safeParse(input);
+  if (result.success) {
+    return { valid: true, config: result.data };
+  }
+  return {
+    valid: false,
+    errors: result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`)
+  };
+}
+function mergeConfig(overrides) {
+  const base = createDefaultConfig();
+  return {
+    functionTimeout: overrides.functionTimeout ?? base.functionTimeout,
+    askTimeout: overrides.askTimeout ?? base.askTimeout,
+    sessionTimeout: overrides.sessionTimeout ?? base.sessionTimeout,
+    maxStopCalls: overrides.maxStopCalls ?? base.maxStopCalls,
+    maxAsyncTasks: overrides.maxAsyncTasks ?? base.maxAsyncTasks,
+    maxTasklistReminders: overrides.maxTasklistReminders ?? base.maxTasklistReminders,
+    maxTaskRetries: overrides.maxTaskRetries ?? base.maxTaskRetries,
+    maxTasksPerTasklist: overrides.maxTasksPerTasklist ?? base.maxTasksPerTasklist,
+    taskAsyncTimeout: overrides.taskAsyncTimeout ?? base.taskAsyncTimeout,
+    sleepMaxSeconds: overrides.sleepMaxSeconds ?? base.sleepMaxSeconds,
+    maxContextTokens: overrides.maxContextTokens ?? base.maxContextTokens,
+    serializationLimits: {
+      maxStringLength: overrides.serializationLimits?.maxStringLength ?? base.serializationLimits.maxStringLength,
+      maxArrayElements: overrides.serializationLimits?.maxArrayElements ?? base.serializationLimits.maxArrayElements,
+      maxObjectKeys: overrides.serializationLimits?.maxObjectKeys ?? base.serializationLimits.maxObjectKeys,
+      maxDepth: overrides.serializationLimits?.maxDepth ?? base.serializationLimits.maxDepth
+    },
+    workspace: {
+      maxScopeVariables: overrides.workspace?.maxScopeVariables ?? base.workspace.maxScopeVariables,
+      maxScopeValueWidth: overrides.workspace?.maxScopeValueWidth ?? base.workspace.maxScopeValueWidth,
+      maxScopeTokens: overrides.workspace?.maxScopeTokens ?? base.workspace.maxScopeTokens
+    },
+    contextWindow: {
+      codeWindowLines: overrides.contextWindow?.codeWindowLines ?? base.contextWindow.codeWindowLines,
+      stopDecayTiers: {
+        full: overrides.contextWindow?.stopDecayTiers?.full ?? base.contextWindow.stopDecayTiers.full,
+        keysOnly: overrides.contextWindow?.stopDecayTiers?.keysOnly ?? base.contextWindow.stopDecayTiers.keysOnly,
+        summary: overrides.contextWindow?.stopDecayTiers?.summary ?? base.contextWindow.stopDecayTiers.summary
+      },
+      neverTruncateInterventions: overrides.contextWindow?.neverTruncateInterventions ?? base.contextWindow.neverTruncateInterventions
+    }
+  };
+}
+
+// src/sandbox/sandbox.ts
+import vm2 from "vm";
+import React from "react";
+
+// src/sandbox/executor.ts
+import vm from "vm";
+
+// src/sandbox/transpiler.ts
+import ts from "typescript";
+var compilerOptions = {
+  target: ts.ScriptTarget.ESNext,
+  module: ts.ModuleKind.ESNext,
+  jsx: ts.JsxEmit.React,
+  jsxFactory: "React.createElement",
+  jsxFragmentFactory: "React.Fragment",
+  strict: false,
+  esModuleInterop: true
+};
+function transpile(code) {
+  const result = ts.transpileModule(code, { compilerOptions });
+  return result.outputText;
+}
+
+// src/parser/ast-utils.ts
+import ts2 from "typescript";
+function parseStatement(source) {
+  const sourceFile = ts2.createSourceFile(
+    "line.ts",
+    source,
+    ts2.ScriptTarget.ESNext,
+    true,
+    ts2.ScriptKind.TSX
+  );
+  const statements = sourceFile.statements;
+  if (statements.length === 0) return null;
+  return statements[0];
+}
+function extractDeclarations(source) {
+  const node = parseStatement(source);
+  if (!node) return [];
+  const names = [];
+  if (ts2.isVariableStatement(node)) {
+    for (const decl of node.declarationList.declarations) {
+      extractBindingNames(decl.name, names);
+    }
+  } else if (ts2.isFunctionDeclaration(node) && node.name) {
+    names.push(node.name.text);
+  } else if (ts2.isClassDeclaration(node) && node.name) {
+    names.push(node.name.text);
+  }
+  return names;
+}
+function extractBindingNames(node, names) {
+  if (ts2.isIdentifier(node)) {
+    names.push(node.text);
+  } else if (ts2.isObjectBindingPattern(node)) {
+    for (const element of node.elements) {
+      extractBindingNames(element.name, names);
+    }
+  } else if (ts2.isArrayBindingPattern(node)) {
+    for (const element of node.elements) {
+      if (ts2.isBindingElement(element)) {
+        extractBindingNames(element.name, names);
+      }
+    }
+  }
+}
+function recoverArgumentNames(source) {
+  const sourceFile = ts2.createSourceFile(
+    "line.ts",
+    source,
+    ts2.ScriptTarget.ESNext,
+    true,
+    ts2.ScriptKind.TSX
+  );
+  let callExpr = null;
+  function visit(node) {
+    if (callExpr) return;
+    if (ts2.isCallExpression(node)) {
+      const callee = node.expression;
+      if (ts2.isIdentifier(callee)) {
+        const name = callee.text;
+        if (name === "stop" || name === "display" || name === "ask" || name === "async") {
+          callExpr = node;
+          return;
+        }
+      }
+    }
+    ts2.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  if (!callExpr) return [];
+  return callExpr.arguments.map((arg, i) => {
+    if (ts2.isIdentifier(arg)) {
+      return arg.text;
+    }
+    if (ts2.isPropertyAccessExpression(arg)) {
+      return arg.getText(sourceFile);
+    }
+    if (ts2.isElementAccessExpression(arg)) {
+      return arg.getText(sourceFile);
+    }
+    return `arg_${i}`;
+  });
+}
+function extractVariableNames(source) {
+  const sourceFile = ts2.createSourceFile(
+    "line.ts",
+    source,
+    ts2.ScriptTarget.ESNext,
+    true,
+    ts2.ScriptKind.TSX
+  );
+  const names = /* @__PURE__ */ new Set();
+  function visit(node) {
+    if (ts2.isIdentifier(node)) {
+      const parent = node.parent;
+      if (parent && ts2.isPropertyAccessExpression(parent) && parent.name === node) {
+      } else {
+        names.add(node.text);
+      }
+    }
+    ts2.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return [...names];
+}
+
+// src/sandbox/executor.ts
+async function executeLine(code, lineNumber, context, timeout = 3e4) {
+  try {
+    const js = transpile(code);
+    const trimmedJs = js.trim();
+    if (trimmedJs === "") {
+      return { ok: true, result: void 0 };
+    }
+    const hasAwait = trimmedJs.includes("await ");
+    if (hasAwait) {
+      const declaredNames = extractDeclarations(code);
+      const assignments = declaredNames.map((name) => `globalThis[${JSON.stringify(name)}] = typeof ${name} !== 'undefined' ? ${name} : undefined;`).join("\n");
+      const wrapped = `(async () => {
+${trimmedJs}
+${assignments}
+})()`;
+      const script = new vm.Script(wrapped, { filename: `line-${lineNumber}.js` });
+      const result = await script.runInContext(context, { timeout });
+      return { ok: true, result };
+    } else {
+      const script = new vm.Script(trimmedJs, { filename: `line-${lineNumber}.js` });
+      const result = await script.runInContext(context, { timeout });
+      return { ok: true, result };
+    }
+  } catch (err) {
+    const error = err;
+    const payload = {
+      type: error.constructor?.name ?? "Error",
+      message: error.message,
+      line: lineNumber,
+      source: code.trim()
+    };
+    return { ok: false, error: payload };
+  }
+}
+
+// src/sandbox/sandbox.ts
+var BLOCKED_GLOBALS = [
+  "process",
+  "require",
+  "module",
+  "exports",
+  "__filename",
+  "__dirname",
+  "eval",
+  "Function"
+];
+var Sandbox = class {
+  context;
+  declaredNames = /* @__PURE__ */ new Set();
+  lineCount = 0;
+  timeout;
+  constructor(options = {}) {
+    this.timeout = options.timeout ?? 3e4;
+    const contextGlobals = {
+      React,
+      console,
+      setTimeout,
+      clearTimeout,
+      setInterval,
+      clearInterval,
+      Promise,
+      Array,
+      Object,
+      String,
+      Number,
+      Boolean,
+      Date,
+      Math,
+      JSON,
+      Map,
+      Set,
+      WeakMap,
+      WeakSet,
+      RegExp,
+      Error,
+      TypeError,
+      RangeError,
+      SyntaxError,
+      ReferenceError,
+      Symbol,
+      Uint8Array,
+      Int32Array,
+      Float64Array,
+      ArrayBuffer,
+      DataView,
+      URL,
+      URLSearchParams,
+      TextEncoder,
+      TextDecoder,
+      structuredClone,
+      atob: globalThis.atob,
+      btoa: globalThis.btoa,
+      ...options.globals
+    };
+    this.context = vm2.createContext(contextGlobals);
+    for (const name of BLOCKED_GLOBALS) {
+      Object.defineProperty(this.context, name, {
+        get() {
+          throw new Error(`${name} is not available in the sandbox`);
+        },
+        configurable: false
+      });
+    }
+  }
+  /**
+   * Execute a line of TypeScript in the sandbox.
+   */
+  async execute(code) {
+    this.lineCount++;
+    const declarations = extractDeclarations(code);
+    for (const name of declarations) {
+      this.declaredNames.add(name);
+    }
+    return executeLine(code, this.lineCount, this.context, this.timeout);
+  }
+  /**
+   * Inject a value into the sandbox's global scope.
+   */
+  inject(name, value) {
+    this.context[name] = value;
+  }
+  /**
+   * Get a value from the sandbox scope.
+   */
+  getValue(name) {
+    return this.context[name];
+  }
+  /**
+   * Get all user-declared variable names.
+   */
+  getDeclaredNames() {
+    return [...this.declaredNames];
+  }
+  /**
+   * Get the current scope as ScopeEntry[].
+   */
+  getScope() {
+    const entries = [];
+    for (const name of this.declaredNames) {
+      try {
+        const value = this.context[name];
+        entries.push({
+          name,
+          type: describeType(value),
+          value: truncateValue(value)
+        });
+      } catch {
+        entries.push({ name, type: "unknown", value: "<error reading>" });
+      }
+    }
+    return entries;
+  }
+  /**
+   * Get the line count.
+   */
+  getLineCount() {
+    return this.lineCount;
+  }
+  /**
+   * Get the raw vm.Context (for advanced use).
+   */
+  getContext() {
+    return this.context;
+  }
+  /**
+   * Destroy the sandbox.
+   */
+  destroy() {
+    this.declaredNames.clear();
+  }
+};
+function describeType(val) {
+  if (val === null) return "null";
+  if (val === void 0) return "undefined";
+  if (Array.isArray(val)) {
+    if (val.length === 0) return "Array";
+    const firstType = describeType(val[0]);
+    return `Array<${firstType}>`;
+  }
+  const t = typeof val;
+  if (t === "object") {
+    const name = val.constructor?.name;
+    return name && name !== "Object" ? name : "Object";
+  }
+  return t;
+}
+function truncateValue(val, maxLen = 50) {
+  if (val === null) return "null";
+  if (val === void 0) return "undefined";
+  if (typeof val === "function") return `[Function: ${val.name || "anonymous"}]`;
+  if (typeof val === "symbol") return val.toString();
+  try {
+    let str;
+    if (typeof val === "string") {
+      str = JSON.stringify(val);
+    } else if (Array.isArray(val)) {
+      const preview = val.slice(0, 3).map((v) => truncateValue(v, 20)).join(", ");
+      str = val.length > 3 ? `[${preview}, ... +${val.length - 3}]` : `[${preview}]`;
+    } else if (typeof val === "object") {
+      const keys = Object.keys(val);
+      const preview = keys.slice(0, 5).join(", ");
+      str = keys.length > 5 ? `{${preview}, ... +${keys.length - 5}}` : `{${preview}}`;
+    } else {
+      str = String(val);
+    }
+    if (str.length > maxLen) {
+      return str.slice(0, maxLen - 3) + "...";
+    }
+    return str;
+  } catch {
+    return "[value]";
+  }
+}
+
+// src/stream/serializer.ts
+var DEFAULT_LIMITS = {
+  maxStringLength: 2e3,
+  maxArrayElements: 50,
+  maxObjectKeys: 20,
+  maxDepth: 5
+};
+function serialize(value, limits = {}) {
+  const opts = { ...DEFAULT_LIMITS, ...limits };
+  const seen = /* @__PURE__ */ new WeakSet();
+  return serializeValue(value, opts, seen, 0);
+}
+function serializeValue(value, limits, seen, depth) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  const type = typeof value;
+  if (type === "string") {
+    const str = value;
+    if (str.length > limits.maxStringLength) {
+      const half = Math.floor(limits.maxStringLength / 2);
+      return JSON.stringify(str.slice(0, half) + `... (truncated, ${str.length} chars total)`);
+    }
+    return JSON.stringify(str);
+  }
+  if (type === "number" || type === "boolean") {
+    return JSON.stringify(value);
+  }
+  if (type === "function") {
+    const fn = value;
+    return `[Function: ${fn.name || "anonymous"}]`;
+  }
+  if (type === "symbol") {
+    return `[Symbol: ${value.description ?? ""}]`;
+  }
+  if (type === "bigint") {
+    return `${value}n`;
+  }
+  if (value instanceof Error) {
+    return `[Error: ${value.message}]`;
+  }
+  if (value instanceof Promise) {
+    return "[Promise]";
+  }
+  if (value instanceof Date) {
+    return `"${value.toISOString()}"`;
+  }
+  if (value instanceof RegExp) {
+    return value.toString();
+  }
+  if (type === "object") {
+    const obj = value;
+    if (seen.has(obj)) return "[Circular]";
+    seen.add(obj);
+    if (depth >= limits.maxDepth) {
+      if (Array.isArray(obj)) return `[Array(${obj.length})]`;
+      return `[Object]`;
+    }
+    if (Array.isArray(obj)) {
+      return serializeArray(obj, limits, seen, depth);
+    }
+    if (obj instanceof Map) {
+      const entries = [];
+      let count = 0;
+      for (const [k, v] of obj) {
+        if (count >= limits.maxObjectKeys) {
+          entries.push(`... +${obj.size - count} more`);
+          break;
+        }
+        entries.push(`${serializeValue(k, limits, seen, depth + 1)}: ${serializeValue(v, limits, seen, depth + 1)}`);
+        count++;
+      }
+      return `Map { ${entries.join(", ")} }`;
+    }
+    if (obj instanceof Set) {
+      const items = [];
+      let count = 0;
+      for (const v of obj) {
+        if (count >= limits.maxArrayElements) {
+          items.push(`... +${obj.size - count} more`);
+          break;
+        }
+        items.push(serializeValue(v, limits, seen, depth + 1));
+        count++;
+      }
+      return `Set { ${items.join(", ")} }`;
+    }
+    return serializeObject(obj, limits, seen, depth);
+  }
+  return String(value);
+}
+function serializeArray(arr, limits, seen, depth) {
+  if (arr.length === 0) return "[]";
+  const items = [];
+  const max = Math.min(arr.length, limits.maxArrayElements);
+  for (let i = 0; i < max; i++) {
+    items.push(serializeValue(arr[i], limits, seen, depth + 1));
+  }
+  if (arr.length > limits.maxArrayElements) {
+    items.push(`... +${arr.length - limits.maxArrayElements} more`);
+  }
+  return `[${items.join(", ")}]`;
+}
+function serializeObject(obj, limits, seen, depth) {
+  const keys = Object.keys(obj);
+  if (keys.length === 0) return "{}";
+  const entries = [];
+  const max = Math.min(keys.length, limits.maxObjectKeys);
+  for (let i = 0; i < max; i++) {
+    const key = keys[i];
+    const val = obj[key];
+    entries.push(`${JSON.stringify(key)}: ${serializeValue(val, limits, seen, depth + 1)}`);
+  }
+  if (keys.length > limits.maxObjectKeys) {
+    entries.push(`... +${keys.length - limits.maxObjectKeys} more`);
+  }
+  return `{ ${entries.join(", ")} }`;
+}
+
+// src/context/knowledge-decay.ts
+var KNOWLEDGE_TAG = /* @__PURE__ */ Symbol.for("lmthing:knowledge");
+var DEFAULT_TIERS = {
+  full: 0,
+  truncated: 2,
+  headers: 4
+};
+function getKnowledgeDecayLevel(distance, tiers = DEFAULT_TIERS) {
+  if (distance <= tiers.full) return "full";
+  if (distance <= tiers.truncated) return "truncated";
+  if (distance <= tiers.headers) return "headers";
+  return "names";
+}
+function isKnowledgeContent(value) {
+  return value !== null && typeof value === "object" && value[KNOWLEDGE_TAG] === true;
+}
+function tagAsKnowledge(obj) {
+  Object.defineProperty(obj, KNOWLEDGE_TAG, {
+    value: true,
+    enumerable: false,
+    configurable: false
+  });
+  return obj;
+}
+function decayKnowledgeValue(content, distance, tiers = DEFAULT_TIERS) {
+  const level = getKnowledgeDecayLevel(distance, tiers);
+  switch (level) {
+    case "full":
+      return formatFull(content);
+    case "truncated":
+      return formatTruncated(content);
+    case "headers":
+      return formatHeaders(content);
+    case "names":
+      return formatNames(content);
+  }
+}
+function formatFull(content) {
+  return serializeNested(content, (md) => JSON.stringify(md));
+}
+function formatTruncated(content) {
+  return serializeNested(content, (md) => {
+    if (md.length <= 300) return JSON.stringify(md);
+    return JSON.stringify(md.slice(0, 300) + `...(truncated, ${md.length} chars)`);
+  });
+}
+function formatHeaders(content) {
+  return serializeNested(content, (md) => {
+    const headers = md.split("\n").filter((line) => /^#{1,4}\s/.test(line)).join(" | ");
+    return JSON.stringify(headers || "(no headings)");
+  });
+}
+function formatNames(content) {
+  const paths = [];
+  collectPaths(content, [], paths);
+  return `[knowledge: ${paths.join(", ")}]`;
+}
+function collectPaths(obj, prefix, out) {
+  for (const [key, value] of Object.entries(obj)) {
+    if (typeof value === "string") {
+      out.push([...prefix, key].join("/"));
+    } else if (typeof value === "object" && value !== null) {
+      collectPaths(value, [...prefix, key], out);
+    }
+  }
+}
+function serializeNested(content, formatLeaf) {
+  return serializeLevel(content, formatLeaf);
+}
+function serializeLevel(obj, formatLeaf) {
+  const entries = [];
+  for (const [key, value] of Object.entries(obj)) {
+    if (typeof value === "string") {
+      entries.push(`${JSON.stringify(key)}: ${formatLeaf(value)}`);
+    } else if (typeof value === "object" && value !== null) {
+      entries.push(`${JSON.stringify(key)}: ${serializeLevel(value, formatLeaf)}`);
+    }
+  }
+  return `{ ${entries.join(", ")} }`;
+}
+
+// src/sandbox/globals.ts
+function createGlobals(config) {
+  const {
+    pauseController,
+    renderSurface,
+    asyncManager,
+    askTimeout = 3e5
+  } = config;
+  const tasklistsState = {
+    tasklists: /* @__PURE__ */ new Map()
+  };
+  let currentSource = "";
+  function setCurrentSource(source) {
+    currentSource = source;
+  }
+  let stopResolve = null;
+  async function stopFn(...values) {
+    const argNames = recoverArgumentNames(currentSource);
+    const resolved = await Promise.allSettled(
+      values.map((v) => v instanceof Promise ? v : Promise.resolve(v))
+    );
+    const payload = {};
+    for (let i = 0; i < resolved.length; i++) {
+      const key = argNames[i] ?? `arg_${i}`;
+      const settlement = resolved[i];
+      const value = settlement.status === "fulfilled" ? settlement.value : {
+        _error: settlement.reason instanceof Error ? settlement.reason.message : String(settlement.reason)
+      };
+      payload[key] = {
+        value,
+        display: serialize(value, config.serializationLimits)
+      };
+    }
+    const asyncPayload = asyncManager.buildStopPayload();
+    for (const [key, val] of Object.entries(asyncPayload)) {
+      payload[key] = {
+        value: val,
+        display: serialize(val, config.serializationLimits)
+      };
+    }
+    const promise = new Promise((resolve) => {
+      stopResolve = resolve;
+    });
+    pauseController.pause();
+    config.onStop?.(payload, currentSource);
+    return promise;
+  }
+  function resolveStop() {
+    if (stopResolve) {
+      const resolve = stopResolve;
+      stopResolve = null;
+      resolve();
+    }
+  }
+  function displayFn(element) {
+    const id = `display_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    renderSurface.append(id, element);
+    config.onDisplay?.(id);
+  }
+  async function askFn(element) {
+    const formId = `form_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    pauseController.pause();
+    try {
+      const result = await Promise.race([
+        renderSurface.renderForm(formId, element),
+        new Promise(
+          (resolve) => setTimeout(() => resolve({ _timeout: true }), askTimeout)
+        )
+      ]);
+      return result;
+    } finally {
+      pauseController.resume();
+    }
+  }
+  function asyncFn(fn, label) {
+    const derivedLabel = label ?? deriveLabel(currentSource);
+    const taskId = asyncManager.register(
+      (signal) => fn(),
+      derivedLabel
+    );
+    config.onAsyncStart?.(taskId, derivedLabel);
+  }
+  function tasklistFn(tasklistId, description, tasks) {
+    if (tasklistsState.tasklists.has(tasklistId)) {
+      throw new Error(`tasklist() tasklist "${tasklistId}" already declared`);
+    }
+    if (!tasklistId) {
+      throw new Error("tasklist() requires a tasklistId");
+    }
+    if (!description || !Array.isArray(tasks) || tasks.length === 0) {
+      throw new Error("tasklist() requires a description and at least one task");
+    }
+    const maxTasks = config.maxTasksPerTasklist ?? 20;
+    if (tasks.length > maxTasks) {
+      throw new Error(`tasklist() exceeds maximum of ${maxTasks} tasks per tasklist`);
+    }
+    const ids = /* @__PURE__ */ new Set();
+    for (const task of tasks) {
+      if (!task.id || !task.instructions || !task.outputSchema) {
+        throw new Error("Each task must have id, instructions, and outputSchema");
+      }
+      if (ids.has(task.id)) {
+        throw new Error(`Duplicate task id: ${task.id}`);
+      }
+      ids.add(task.id);
+    }
+    for (const task of tasks) {
+      if (task.dependsOn) {
+        for (const dep of task.dependsOn) {
+          if (!ids.has(dep)) {
+            throw new Error(`Task "${task.id}" depends on unknown task "${dep}" in tasklist "${tasklistId}"`);
+          }
+          if (dep === task.id) {
+            throw new Error(`Task "${task.id}" cannot depend on itself`);
+          }
+        }
+      }
+    }
+    const hasDependsOn = tasks.some((t) => t.dependsOn && t.dependsOn.length > 0);
+    if (!hasDependsOn) {
+      for (let i = 1; i < tasks.length; i++) {
+        tasks[i] = { ...tasks[i], dependsOn: [tasks[i - 1].id] };
+      }
+    }
+    const visited = /* @__PURE__ */ new Set();
+    const visiting = /* @__PURE__ */ new Set();
+    const taskMap = new Map(tasks.map((t) => [t.id, t]));
+    function visit(id) {
+      if (visited.has(id)) return;
+      if (visiting.has(id)) {
+        throw new Error(`Cycle detected in tasklist "${tasklistId}" involving task "${id}"`);
+      }
+      visiting.add(id);
+      const task = taskMap.get(id);
+      if (task.dependsOn) {
+        for (const dep of task.dependsOn) {
+          visit(dep);
+        }
+      }
+      visiting.delete(id);
+      visited.add(id);
+    }
+    for (const task of tasks) {
+      visit(task.id);
+    }
+    const readyTasks = /* @__PURE__ */ new Set();
+    for (const task of tasks) {
+      if (!task.dependsOn || task.dependsOn.length === 0) {
+        readyTasks.add(task.id);
+      }
+    }
+    const plan = { tasklistId, description, tasks };
+    const tasklistState = {
+      plan,
+      completed: /* @__PURE__ */ new Map(),
+      readyTasks,
+      runningTasks: /* @__PURE__ */ new Set(),
+      outputs: /* @__PURE__ */ new Map(),
+      progressMessages: /* @__PURE__ */ new Map(),
+      retryCount: /* @__PURE__ */ new Map()
+    };
+    tasklistsState.tasklists.set(tasklistId, tasklistState);
+    renderSurface.appendTasklistProgress?.(tasklistId, tasklistState);
+    config.onTasklistDeclared?.(tasklistId, plan);
+  }
+  function completeTaskFn(tasklistId, id, output) {
+    const tasklist = tasklistsState.tasklists.get(tasklistId);
+    if (!tasklist) {
+      throw new Error(`completeTask() called with unknown tasklist "${tasklistId}" \u2014 declare it with tasklist() first`);
+    }
+    const task = tasklist.plan.tasks.find((t) => t.id === id);
+    if (!task) {
+      throw new Error(`Unknown task id: ${id} in tasklist "${tasklistId}"`);
+    }
+    if (tasklist.completed.has(id)) {
+      throw new Error(`Task "${id}" in tasklist "${tasklistId}" already completed`);
+    }
+    if (!tasklist.readyTasks.has(id)) {
+      const isRunning = tasklist.runningTasks.has(id);
+      if (isRunning) {
+        throw new Error(`Task "${id}" in tasklist "${tasklistId}" is already running via completeTaskAsync()`);
+      }
+      const pendingDeps = (task.dependsOn ?? []).filter((dep) => {
+        const c = tasklist.completed.get(dep);
+        return !c || c.status !== "completed";
+      });
+      const readyTaskDetails = [...tasklist.readyTasks].map((readyId) => {
+        const readyTask = tasklist.plan.tasks.find((t) => t.id === readyId);
+        return { id: readyId, instructions: readyTask.instructions, outputSchema: readyTask.outputSchema };
+      });
+      config.onTaskOrderViolation?.(tasklistId, id, readyTaskDetails);
+      throw new Error(
+        `Task "${id}" in tasklist "${tasklistId}" is not ready. Waiting on: ${pendingDeps.join(", ")}`
+      );
+    }
+    for (const [key, schema] of Object.entries(task.outputSchema)) {
+      if (!(key in output)) {
+        throw new Error(`Task "${id}" output missing required key: ${key}`);
+      }
+      const expectedType = schema.type;
+      const value = output[key];
+      const actual = Array.isArray(value) ? "array" : typeof value;
+      if (actual !== expectedType) {
+        throw new Error(
+          `Task "${id}" output key "${key}": expected ${expectedType}, got ${actual}`
+        );
+      }
+    }
+    tasklist.completed.set(id, {
+      output,
+      timestamp: Date.now(),
+      status: "completed"
+    });
+    tasklist.readyTasks.delete(id);
+    tasklist.outputs.set(id, output);
+    recomputeReadyTasks(tasklist);
+    renderSurface.updateTasklistProgress?.(tasklistId, tasklist);
+    config.onTaskComplete?.(tasklistId, id, output);
+    const hasRemainingTasks = tasklist.plan.tasks.some((t) => {
+      const c = tasklist.completed.get(t.id);
+      return (!c || c.status !== "completed" && c.status !== "skipped") && !t.optional;
+    });
+    if (hasRemainingTasks && tasklist.readyTasks.size > 0) {
+      const readyTaskDetails = [...tasklist.readyTasks].map((readyId) => {
+        const readyTask = tasklist.plan.tasks.find((t) => t.id === readyId);
+        return { id: readyId, instructions: readyTask.instructions, outputSchema: readyTask.outputSchema };
+      });
+      config.onTaskCompleteContinue?.(tasklistId, id, readyTaskDetails);
+    }
+  }
+  function recomputeReadyTasks(tasklist) {
+    for (const task of tasklist.plan.tasks) {
+      if (tasklist.completed.has(task.id) || tasklist.readyTasks.has(task.id) || tasklist.runningTasks.has(task.id)) {
+        continue;
+      }
+      const deps = task.dependsOn ?? [];
+      const allDepsSatisfied = deps.every((dep) => {
+        const c = tasklist.completed.get(dep);
+        return c && (c.status === "completed" || c.status === "skipped" || c.status === "failed" && tasklist.plan.tasks.find((t) => t.id === dep)?.optional);
+      });
+      if (allDepsSatisfied) {
+        if (task.condition) {
+          const conditionMet = evaluateCondition(task.condition, tasklist.outputs);
+          if (!conditionMet) {
+            tasklist.completed.set(task.id, {
+              output: {},
+              timestamp: Date.now(),
+              status: "skipped"
+            });
+            config.onTaskSkipped?.(tasklist.plan.tasklistId, task.id, "condition was falsy");
+            recomputeReadyTasks(tasklist);
+            return;
+          }
+        }
+        tasklist.readyTasks.add(task.id);
+      }
+    }
+  }
+  function evaluateCondition(condition, outputs) {
+    try {
+      const ctx = Object.fromEntries(outputs);
+      const paramNames = Object.keys(ctx);
+      const paramValues = Object.values(ctx);
+      const fn = new Function(...paramNames, `return !!(${condition})`);
+      return fn(...paramValues);
+    } catch {
+      return false;
+    }
+  }
+  function completeTaskAsyncFn(tasklistId, taskId, fn) {
+    const tasklist = tasklistsState.tasklists.get(tasklistId);
+    if (!tasklist) {
+      throw new Error(`completeTaskAsync() called with unknown tasklist "${tasklistId}"`);
+    }
+    const task = tasklist.plan.tasks.find((t) => t.id === taskId);
+    if (!task) {
+      throw new Error(`Unknown task id: ${taskId} in tasklist "${tasklistId}"`);
+    }
+    if (tasklist.completed.has(taskId)) {
+      throw new Error(`Task "${taskId}" in tasklist "${tasklistId}" already completed`);
+    }
+    if (!tasklist.readyTasks.has(taskId)) {
+      const readyTaskDetails = [...tasklist.readyTasks].map((readyId) => {
+        const readyTask = tasklist.plan.tasks.find((t) => t.id === readyId);
+        return { id: readyId, instructions: readyTask.instructions, outputSchema: readyTask.outputSchema };
+      });
+      config.onTaskOrderViolation?.(tasklistId, taskId, readyTaskDetails);
+      throw new Error(`Task "${taskId}" in tasklist "${tasklistId}" is not ready`);
+    }
+    tasklist.readyTasks.delete(taskId);
+    tasklist.runningTasks.add(taskId);
+    config.onTaskAsyncStart?.(tasklistId, taskId);
+    const startTime = Date.now();
+    const promise = fn().then((output) => {
+      for (const [key, schema] of Object.entries(task.outputSchema)) {
+        if (!(key in output)) {
+          throw new Error(`Task "${taskId}" output missing required key: ${key}`);
+        }
+        const expectedType = schema.type;
+        const value = output[key];
+        const actual = Array.isArray(value) ? "array" : typeof value;
+        if (actual !== expectedType) {
+          throw new Error(
+            `Task "${taskId}" output key "${key}": expected ${expectedType}, got ${actual}`
+          );
+        }
+      }
+      tasklist.runningTasks.delete(taskId);
+      tasklist.completed.set(taskId, {
+        output,
+        timestamp: Date.now(),
+        status: "completed",
+        duration: Date.now() - startTime
+      });
+      tasklist.outputs.set(taskId, output);
+      asyncManager.setResult(`task:${taskId}`, output);
+      recomputeReadyTasks(tasklist);
+      renderSurface.updateTasklistProgress?.(tasklistId, tasklist);
+      config.onTaskAsyncComplete?.(tasklistId, taskId, output);
+    }).catch((err) => {
+      const error = err instanceof Error ? err.message : String(err);
+      tasklist.runningTasks.delete(taskId);
+      tasklist.completed.set(taskId, {
+        output: {},
+        timestamp: Date.now(),
+        status: "failed",
+        error,
+        duration: Date.now() - startTime
+      });
+      asyncManager.setResult(`task:${taskId}`, { error });
+      if (task.optional) {
+        recomputeReadyTasks(tasklist);
+      }
+      renderSurface.updateTasklistProgress?.(tasklistId, tasklist);
+      config.onTaskAsyncFailed?.(tasklistId, taskId, error);
+    });
+  }
+  function taskProgressFn(tasklistId, taskId, message, percent) {
+    const tasklist = tasklistsState.tasklists.get(tasklistId);
+    if (!tasklist) {
+      throw new Error(`taskProgress() called with unknown tasklist "${tasklistId}"`);
+    }
+    const task = tasklist.plan.tasks.find((t) => t.id === taskId);
+    if (!task) {
+      throw new Error(`Unknown task id: ${taskId} in tasklist "${tasklistId}"`);
+    }
+    if (!tasklist.readyTasks.has(taskId) && !tasklist.runningTasks.has(taskId)) {
+      throw new Error(`Task "${taskId}" in tasklist "${tasklistId}" is not in ready or running state`);
+    }
+    tasklist.progressMessages.set(taskId, { message, percent });
+    renderSurface.updateTaskProgress?.(tasklistId, taskId, message, percent);
+    config.onTaskProgress?.(tasklistId, taskId, message, percent);
+  }
+  function failTaskFn(tasklistId, taskId, error) {
+    const tasklist = tasklistsState.tasklists.get(tasklistId);
+    if (!tasklist) {
+      throw new Error(`failTask() called with unknown tasklist "${tasklistId}"`);
+    }
+    const task = tasklist.plan.tasks.find((t) => t.id === taskId);
+    if (!task) {
+      throw new Error(`Unknown task id: ${taskId} in tasklist "${tasklistId}"`);
+    }
+    if (!tasklist.readyTasks.has(taskId) && !tasklist.runningTasks.has(taskId)) {
+      throw new Error(`Task "${taskId}" in tasklist "${tasklistId}" is not in ready or running state`);
+    }
+    tasklist.readyTasks.delete(taskId);
+    tasklist.runningTasks.delete(taskId);
+    tasklist.completed.set(taskId, {
+      output: {},
+      timestamp: Date.now(),
+      status: "failed",
+      error
+    });
+    if (task.optional) {
+      recomputeReadyTasks(tasklist);
+    }
+    renderSurface.updateTasklistProgress?.(tasklistId, tasklist);
+    config.onTaskFailed?.(tasklistId, taskId, error);
+  }
+  function retryTaskFn(tasklistId, taskId) {
+    const tasklist = tasklistsState.tasklists.get(tasklistId);
+    if (!tasklist) {
+      throw new Error(`retryTask() called with unknown tasklist "${tasklistId}"`);
+    }
+    const task = tasklist.plan.tasks.find((t) => t.id === taskId);
+    if (!task) {
+      throw new Error(`Unknown task id: ${taskId} in tasklist "${tasklistId}"`);
+    }
+    const completion = tasklist.completed.get(taskId);
+    if (!completion || completion.status !== "failed") {
+      throw new Error(`retryTask() can only retry failed tasks. Task "${taskId}" status: ${completion?.status ?? "not completed"}`);
+    }
+    const maxRetries = config.maxTaskRetries ?? 3;
+    const currentRetries = tasklist.retryCount.get(taskId) ?? 0;
+    if (currentRetries >= maxRetries) {
+      throw new Error(`Task "${taskId}" has exceeded maximum retries (${maxRetries})`);
+    }
+    tasklist.retryCount.set(taskId, currentRetries + 1);
+    tasklist.completed.delete(taskId);
+    tasklist.outputs.delete(taskId);
+    tasklist.readyTasks.add(taskId);
+    tasklist.progressMessages.delete(taskId);
+    renderSurface.updateTasklistProgress?.(tasklistId, tasklist);
+    config.onTaskRetried?.(tasklistId, taskId);
+  }
+  async function sleepFn(seconds) {
+    const maxSeconds = config.sleepMaxSeconds ?? 30;
+    const capped = Math.min(Math.max(0, seconds), maxSeconds);
+    await new Promise((resolve) => setTimeout(resolve, capped * 1e3));
+  }
+  function loadKnowledgeFn(selector) {
+    if (!selector || typeof selector !== "object") {
+      throw new Error("loadKnowledge() requires a selector object: { spaceName: { domain: { field: { option: true } } } }");
+    }
+    if (!config.onLoadKnowledge) {
+      throw new Error("loadKnowledge() is not available \u2014 no space loaded");
+    }
+    return tagAsKnowledge(config.onLoadKnowledge(selector));
+  }
+  const loadedClasses = /* @__PURE__ */ new Set();
+  function loadClassFn(className) {
+    if (typeof className !== "string" || !className) {
+      throw new Error("loadClass() requires a class name string");
+    }
+    if (loadedClasses.has(className)) return;
+    if (!config.getClassInfo) {
+      throw new Error("loadClass() is not available \u2014 no classes exported");
+    }
+    const result = config.getClassInfo(className);
+    if (!result) {
+      throw new Error(`Unknown class: "${className}"`);
+    }
+    loadedClasses.add(className);
+    config.onLoadClass?.(className);
+  }
+  async function askParentFn(message, schema = {}) {
+    if (typeof message !== "string" || !message) {
+      throw new Error("askParent() requires a message string as first argument");
+    }
+    if (config.isFireAndForget || !config.onAskParent) {
+      return { _noParent: true };
+    }
+    pauseController.pause();
+    try {
+      const result = await Promise.race([
+        config.onAskParent({ message, schema }),
+        new Promise(
+          (resolve) => setTimeout(() => resolve({ _timeout: true }), askTimeout)
+        )
+      ]);
+      return result;
+    } finally {
+      pauseController.resume();
+    }
+  }
+  function respondFn(promise, data) {
+    if (!config.onRespond) throw new Error("respond() is not available");
+    if (!data || typeof data !== "object") {
+      throw new Error("respond() requires a data object as second argument");
+    }
+    config.onRespond(promise, data);
+  }
+  return {
+    stop: stopFn,
+    display: displayFn,
+    ask: askFn,
+    async: asyncFn,
+    tasklist: tasklistFn,
+    completeTask: completeTaskFn,
+    completeTaskAsync: completeTaskAsyncFn,
+    taskProgress: taskProgressFn,
+    failTask: failTaskFn,
+    retryTask: retryTaskFn,
+    sleep: sleepFn,
+    loadKnowledge: loadKnowledgeFn,
+    loadClass: loadClassFn,
+    askParent: askParentFn,
+    respond: respondFn,
+    setCurrentSource,
+    resolveStop,
+    getTasklistsState: () => tasklistsState
+  };
+}
+function deriveLabel(source) {
+  const commentMatch = source.match(/\/\/\s*(.+)$/);
+  if (commentMatch) return commentMatch[1].trim();
+  const callMatch = source.match(/=>\s*(?:\{[^}]*)?(\w+)\s*\(/);
+  if (callMatch) return callMatch[1];
+  return "background task";
+}
+
+// src/sandbox/async-manager.ts
+var AsyncManager = class {
+  tasks = /* @__PURE__ */ new Map();
+  results = /* @__PURE__ */ new Map();
+  counter = 0;
+  maxTasks;
+  constructor(maxTasks = 10) {
+    this.maxTasks = maxTasks;
+  }
+  /**
+   * Register a new background task.
+   */
+  register(fn, label) {
+    if (this.getRunningCount() >= this.maxTasks) {
+      throw new Error(`Maximum async tasks reached (${this.maxTasks})`);
+    }
+    const id = `async_${this.counter++}`;
+    const abortController = new AbortController();
+    const startTime = Date.now();
+    const promise = fn(abortController.signal).then(() => {
+      const task = this.tasks.get(id);
+      if (task && task.status === "running") {
+        task.status = "completed";
+      }
+    }).catch((err) => {
+      const task = this.tasks.get(id);
+      if (task) {
+        if (task.status === "running") {
+          task.status = "failed";
+          task.error = err instanceof Error ? err.message : String(err);
+        }
+      }
+    });
+    this.tasks.set(id, {
+      id,
+      label: label ?? id,
+      abortController,
+      promise,
+      status: "running",
+      startTime
+    });
+    return id;
+  }
+  /**
+   * Cancel a task by ID.
+   */
+  cancel(taskId, message = "cancelled by user") {
+    const task = this.tasks.get(taskId);
+    if (!task || task.status !== "running") return false;
+    task.abortController.abort(message);
+    task.status = "cancelled";
+    this.results.set(taskId, { cancelled: true, message });
+    return true;
+  }
+  /**
+   * Store a result from a task's scoped stop() call.
+   */
+  setResult(taskId, value) {
+    this.results.set(taskId, value);
+  }
+  /**
+   * Drain all accumulated results and clear the results map.
+   */
+  drainResults() {
+    const drained = new Map(this.results);
+    this.results.clear();
+    return drained;
+  }
+  /**
+   * Get a task by ID.
+   */
+  getTask(taskId) {
+    return this.tasks.get(taskId);
+  }
+  /**
+   * Get all tasks.
+   */
+  getAllTasks() {
+    return [...this.tasks.values()];
+  }
+  /**
+   * Get count of currently running tasks.
+   */
+  getRunningCount() {
+    return [...this.tasks.values()].filter((t) => t.status === "running").length;
+  }
+  /**
+   * Build the async portion of a stop payload.
+   * Running tasks show "pending", completed ones show their results.
+   */
+  buildStopPayload() {
+    const payload = {};
+    const drained = this.drainResults();
+    for (const [taskId, task] of this.tasks) {
+      if (drained.has(taskId)) {
+        payload[task.label] = drained.get(taskId);
+      } else if (task.status === "running") {
+        payload[task.label] = "pending";
+      }
+    }
+    return payload;
+  }
+  /**
+   * Wait for all running tasks to complete, with timeout.
+   */
+  async drain(timeoutMs = 5e3) {
+    const running = [...this.tasks.values()].filter((t) => t.status === "running");
+    if (running.length === 0) return;
+    await Promise.race([
+      Promise.allSettled(running.map((t) => t.promise)),
+      new Promise((resolve) => setTimeout(resolve, timeoutMs))
+    ]);
+  }
+  /**
+   * Cancel all running tasks.
+   */
+  cancelAll() {
+    for (const task of this.tasks.values()) {
+      if (task.status === "running") {
+        task.abortController.abort("session cleanup");
+        task.status = "cancelled";
+      }
+    }
+  }
+};
+
+// src/stream/bracket-tracker.ts
+function createBracketState() {
+  return {
+    round: 0,
+    curly: 0,
+    square: 0,
+    inString: false,
+    inLineComment: false,
+    inBlockComment: false,
+    templateDepth: 0,
+    jsxDepth: 0,
+    jsxTagState: "none"
+  };
+}
+function feedChunk(state, chunk) {
+  for (let i = 0; i < chunk.length; i++) {
+    const ch = chunk[i];
+    const next = chunk[i + 1];
+    if (state.inLineComment) {
+      if (ch === "\n") state.inLineComment = false;
+      continue;
+    }
+    if (state.inBlockComment) {
+      if (ch === "*" && next === "/") {
+        state.inBlockComment = false;
+        i++;
+      }
+      continue;
+    }
+    if (state.inString) {
+      if (ch === "\\") {
+        i++;
+        continue;
+      }
+      if (state.inString === "`") {
+        if (ch === "`") {
+          state.inString = false;
+        }
+      } else if (ch === state.inString) {
+        state.inString = false;
+      }
+      continue;
+    }
+    if (ch === "/" && next === "/") {
+      state.inLineComment = true;
+      i++;
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      state.inBlockComment = true;
+      i++;
+      continue;
+    }
+    if (ch === "'" || ch === '"' || ch === "`") {
+      state.inString = ch;
+      continue;
+    }
+    if (state.jsxTagState === "pending_open") {
+      if (/[a-zA-Z]/.test(ch)) {
+        state.jsxDepth++;
+        state.jsxTagState = "open";
+        continue;
+      } else if (ch === "/") {
+        state.jsxTagState = "close";
+        continue;
+      } else if (ch === ">") {
+        state.jsxDepth++;
+        state.jsxTagState = "none";
+        continue;
+      } else {
+        state.jsxTagState = "none";
+      }
+    }
+    if (state.jsxTagState === "selfclose_pending") {
+      if (ch === ">") {
+        state.jsxDepth = Math.max(0, state.jsxDepth - 1);
+        state.jsxTagState = "none";
+        continue;
+      }
+      state.jsxTagState = "open";
+    }
+    if (state.jsxTagState === "open") {
+      if (ch === "/") {
+        state.jsxTagState = "selfclose_pending";
+        continue;
+      }
+      if (ch === ">" && state.curly === 0 && state.round === 0 && state.square === 0) {
+        state.jsxTagState = "none";
+        continue;
+      }
+    }
+    if (state.jsxTagState === "close") {
+      if (ch === ">") {
+        state.jsxDepth = Math.max(0, state.jsxDepth - 1);
+        state.jsxTagState = "none";
+      }
+      continue;
+    }
+    if (ch === "<" && state.jsxTagState === "none") {
+      state.jsxTagState = "pending_open";
+      continue;
+    }
+    if (ch === "(") state.round++;
+    else if (ch === ")") state.round = Math.max(0, state.round - 1);
+    else if (ch === "{") state.curly++;
+    else if (ch === "}") state.curly = Math.max(0, state.curly - 1);
+    else if (ch === "[") state.square++;
+    else if (ch === "]") state.square = Math.max(0, state.square - 1);
+  }
+  return state;
+}
+function isBalanced(state) {
+  return state.round === 0 && state.curly === 0 && state.square === 0 && state.jsxDepth === 0 && state.jsxTagState === "none" && state.inString === false && !state.inBlockComment;
+}
+function resetBracketState(state) {
+  state.round = 0;
+  state.curly = 0;
+  state.square = 0;
+  state.inString = false;
+  state.inLineComment = false;
+  state.inBlockComment = false;
+  state.templateDepth = 0;
+  state.jsxDepth = 0;
+  state.jsxTagState = "none";
+}
+
+// src/parser/statement-detector.ts
+function isCompleteStatement(buffer) {
+  const trimmed = buffer.trim();
+  if (trimmed.length === 0) return false;
+  let roundDepth = 0;
+  let curlyDepth = 0;
+  let squareDepth = 0;
+  let jsxDepth = 0;
+  let jsxTagState = "none";
+  let inString = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  let i = 0;
+  while (i < trimmed.length) {
+    const ch = trimmed[i];
+    const next = trimmed[i + 1];
+    if (inLineComment) {
+      if (ch === "\n") inLineComment = false;
+      i++;
+      continue;
+    }
+    if (inBlockComment) {
+      if (ch === "*" && next === "/") {
+        inBlockComment = false;
+        i += 2;
+        continue;
+      }
+      i++;
+      continue;
+    }
+    if (inString) {
+      if (ch === "\\") {
+        i += 2;
+        continue;
+      }
+      if (inString === "`") {
+        if (ch === "$" && next === "{") {
+        }
+        if (ch === "`") {
+          inString = false;
+        }
+      } else if (ch === inString) {
+        inString = false;
+      }
+      i++;
+      continue;
+    }
+    if (ch === "/" && next === "/") {
+      inLineComment = true;
+      i += 2;
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      inBlockComment = true;
+      i += 2;
+      continue;
+    }
+    if (ch === "'" || ch === '"' || ch === "`") {
+      inString = ch;
+      i++;
+      continue;
+    }
+    if (jsxTagState === "open" && ch === "/" && next === ">") {
+      jsxDepth = Math.max(0, jsxDepth - 1);
+      jsxTagState = "none";
+      i += 2;
+      continue;
+    }
+    if (jsxTagState === "open" && ch === ">" && curlyDepth === 0 && roundDepth === 0 && squareDepth === 0) {
+      jsxTagState = "none";
+      i++;
+      continue;
+    }
+    if (jsxTagState === "close" && ch === ">") {
+      jsxDepth = Math.max(0, jsxDepth - 1);
+      jsxTagState = "none";
+      i++;
+      continue;
+    }
+    if (ch === "<" && jsxTagState === "none" && next && /[a-zA-Z]/.test(next)) {
+      jsxDepth++;
+      jsxTagState = "open";
+      i += 2;
+      continue;
+    }
+    if (ch === "<" && jsxTagState === "none" && next === "/") {
+      jsxTagState = "close";
+      i += 2;
+      continue;
+    }
+    if (ch === "<" && jsxTagState === "none" && next === ">") {
+      jsxDepth++;
+      i += 2;
+      continue;
+    }
+    if (ch === "(") roundDepth++;
+    else if (ch === ")") roundDepth = Math.max(0, roundDepth - 1);
+    else if (ch === "{") curlyDepth++;
+    else if (ch === "}") curlyDepth = Math.max(0, curlyDepth - 1);
+    else if (ch === "[") squareDepth++;
+    else if (ch === "]") squareDepth = Math.max(0, squareDepth - 1);
+    i++;
+  }
+  if (inString !== false || inBlockComment) return false;
+  if (roundDepth !== 0 || curlyDepth !== 0 || squareDepth !== 0) return false;
+  if (jsxDepth !== 0 || jsxTagState !== "none") return false;
+  return true;
+}
+
+// src/stream/line-accumulator.ts
+function createLineAccumulator() {
+  return {
+    buffer: "",
+    bracketState: createBracketState()
+  };
+}
+function feed(acc, token) {
+  const statements = [];
+  for (const char of token) {
+    acc.buffer += char;
+    feedChunk(acc.bracketState, char);
+    if (char === "\n" && isBalanced(acc.bracketState)) {
+      const trimmed = acc.buffer.trim();
+      if (trimmed.length > 0 && isCompleteStatement(trimmed)) {
+        statements.push(trimmed);
+        acc.buffer = "";
+        resetBracketState(acc.bracketState);
+      }
+    }
+  }
+  return {
+    statements,
+    hasRemaining: acc.buffer.trim().length > 0
+  };
+}
+function flush(acc) {
+  const trimmed = acc.buffer.trim();
+  if (trimmed.length === 0) return null;
+  acc.buffer = "";
+  resetBracketState(acc.bracketState);
+  return trimmed;
+}
+function clear(acc) {
+  acc.buffer = "";
+  resetBracketState(acc.bracketState);
+}
+
+// src/hooks/hook-executor.ts
+import ts4 from "typescript";
+
+// src/hooks/pattern-matcher.ts
+import ts3 from "typescript";
+function matchPattern(node, pattern, sourceFile) {
+  const captures = {};
+  if ("oneOf" in pattern) {
+    const p = pattern;
+    for (const sub of p.oneOf) {
+      const match = matchPattern(node, sub, sourceFile);
+      if (match) return match;
+    }
+    return null;
+  }
+  if ("not" in pattern && "type" in pattern) {
+    const p = pattern;
+    if (!matchNodeType(node, p.type)) return null;
+    const negMatch = matchPatternProperties(node, p.not, sourceFile, captures);
+    if (negMatch) return null;
+    return { node, source: node.getText(sourceFile), captures };
+  }
+  if ("type" in pattern) {
+    const p = pattern;
+    if (!matchNodeType(node, p.type)) return null;
+    if (!matchPatternProperties(node, p, sourceFile, captures)) return null;
+    return { node, source: node.getText(sourceFile), captures };
+  }
+  return null;
+}
+function matchNodeType(node, type) {
+  if (type === "*") return true;
+  const syntaxKind = ts3.SyntaxKind[node.kind];
+  return String(syntaxKind) === type;
+}
+function matchPatternProperties(node, pattern, sourceFile, captures) {
+  for (const [key, expectedValue] of Object.entries(pattern)) {
+    if (key === "type" || key === "oneOf" || key === "not") continue;
+    const actualValue = node[key];
+    if (actualValue === void 0) return false;
+    if (typeof expectedValue === "object" && expectedValue !== null) {
+      if (actualValue && typeof actualValue === "object" && "kind" in actualValue) {
+        if (!matchPatternProperties(actualValue, expectedValue, sourceFile, captures)) {
+          return false;
+        }
+      } else {
+        return false;
+      }
+    } else if (typeof expectedValue === "string") {
+      if (expectedValue.startsWith("$")) {
+        const captureName = expectedValue.slice(1);
+        if (actualValue && typeof actualValue === "object" && "kind" in actualValue) {
+          captures[captureName] = actualValue.getText(sourceFile);
+        } else {
+          captures[captureName] = actualValue;
+        }
+      } else {
+        if (actualValue && typeof actualValue === "object" && "kind" in actualValue) {
+          if (actualValue.getText(sourceFile) !== expectedValue) return false;
+        } else if (String(actualValue) !== expectedValue) {
+          return false;
+        }
+      }
+    } else {
+      if (actualValue !== expectedValue) return false;
+    }
+  }
+  return true;
+}
+function findMatches(sourceFile, pattern) {
+  const matches = [];
+  function visit(node) {
+    const match = matchPattern(node, pattern, sourceFile);
+    if (match) matches.push(match);
+    ts3.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return matches;
+}
+
+// src/hooks/hook-executor.ts
+async function executeHooks(source, phase, registry, context) {
+  const hooks = registry.listByPhase(phase);
+  const result = {
+    action: "execute",
+    source,
+    sideEffects: [],
+    matchedHooks: []
+  };
+  if (hooks.length === 0) return result;
+  const sourceFile = ts4.createSourceFile(
+    "hook.ts",
+    source,
+    ts4.ScriptTarget.ESNext,
+    true,
+    ts4.ScriptKind.TSX
+  );
+  for (const hook of hooks) {
+    const matches = findMatches(sourceFile, hook.pattern);
+    if (matches.length === 0) continue;
+    for (const match of matches) {
+      let action;
+      try {
+        action = await hook.handler(match, context);
+        registry.recordSuccess(hook.id);
+      } catch (err) {
+        registry.recordFailure(hook.id);
+        continue;
+      }
+      result.matchedHooks.push({ hookId: hook.id, action: action.type });
+      switch (action.type) {
+        case "continue":
+          break;
+        case "side_effect":
+          result.sideEffects.push(action.fn);
+          break;
+        case "transform":
+          if (phase === "before") {
+            result.source = action.newSource;
+          }
+          break;
+        case "interrupt":
+          if (phase === "before") {
+            result.action = "interrupt";
+            result.interruptMessage = action.message;
+            return result;
+          }
+          break;
+        case "skip":
+          if (phase === "before") {
+            result.action = "skip";
+            return result;
+          }
+          break;
+      }
+    }
+  }
+  return result;
+}
+
+// src/stream/stream-controller.ts
+var StreamController = class {
+  accumulator = createLineAccumulator();
+  paused = false;
+  pauseResolve = null;
+  options;
+  lineCount = 0;
+  currentBlockId = "";
+  constructor(options) {
+    this.options = options;
+  }
+  /**
+   * Feed tokens from the LLM stream.
+   */
+  async feedToken(token) {
+    if (this.paused) {
+      await this.waitForResume();
+    }
+    const { statements } = feed(this.accumulator, token);
+    if (token.length > 0) {
+      this.options.onEvent({
+        type: "code",
+        lines: token,
+        blockId: this.currentBlockId || this.newBlockId()
+      });
+    }
+    for (const statement of statements) {
+      await this.processStatement(statement);
+      if (this.paused) {
+        await this.waitForResume();
+      }
+    }
+  }
+  /**
+   * Called when the LLM stream ends. Flush remaining buffer.
+   */
+  async finalize() {
+    const remaining = flush(this.accumulator);
+    if (remaining) {
+      await this.processStatement(remaining);
+    }
+  }
+  async processStatement(source) {
+    this.lineCount++;
+    const ctx = this.options.hookContext();
+    const hookResult = await executeHooks(
+      source,
+      "before",
+      this.options.hookRegistry,
+      ctx
+    );
+    for (const fn of hookResult.sideEffects) {
+      try {
+        await fn();
+      } catch {
+      }
+    }
+    for (const match of hookResult.matchedHooks) {
+      this.options.onEvent({
+        type: "hook",
+        hookId: match.hookId,
+        action: match.action,
+        detail: source,
+        blockId: this.currentBlockId
+      });
+    }
+    if (hookResult.action === "skip") {
+      return;
+    }
+    if (hookResult.action === "interrupt") {
+      this.options.onEvent({
+        type: "hook",
+        hookId: hookResult.matchedHooks[hookResult.matchedHooks.length - 1]?.hookId ?? "unknown",
+        action: "interrupt",
+        detail: hookResult.interruptMessage ?? "",
+        blockId: this.currentBlockId
+      });
+      return;
+    }
+    const finalSource = hookResult.source;
+    this.options.onCodeLine(finalSource);
+    const result = await this.options.onStatement(finalSource);
+    await executeHooks(finalSource, "after", this.options.hookRegistry, ctx);
+    if (!result.ok && result.error) {
+      this.options.onError(result.error);
+      this.options.onEvent({
+        type: "error",
+        error: result.error,
+        blockId: this.currentBlockId
+      });
+    }
+  }
+  // ── StreamPauseController interface ──
+  pause() {
+    this.paused = true;
+  }
+  resume() {
+    this.paused = false;
+    if (this.pauseResolve) {
+      const resolve = this.pauseResolve;
+      this.pauseResolve = null;
+      resolve();
+    }
+  }
+  isPaused() {
+    return this.paused;
+  }
+  waitForResume() {
+    if (!this.paused) return Promise.resolve();
+    return new Promise((resolve) => {
+      this.pauseResolve = resolve;
+    });
+  }
+  /**
+   * Clear the line accumulator (e.g., on intervention).
+   */
+  clearBuffer() {
+    clear(this.accumulator);
+  }
+  /**
+   * Set the current block ID for events.
+   */
+  setBlockId(id) {
+    this.currentBlockId = id;
+  }
+  newBlockId() {
+    this.currentBlockId = `block_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+    return this.currentBlockId;
+  }
+};
+
+// src/hooks/hook-registry.ts
+var HookRegistry = class {
+  hooks = /* @__PURE__ */ new Map();
+  failureCounts = /* @__PURE__ */ new Map();
+  disabledHooks = /* @__PURE__ */ new Set();
+  maxConsecutiveFailures;
+  constructor(maxConsecutiveFailures = 3) {
+    this.maxConsecutiveFailures = maxConsecutiveFailures;
+  }
+  register(hook) {
+    this.hooks.set(hook.id, hook);
+    this.failureCounts.set(hook.id, 0);
+  }
+  unregister(id) {
+    this.failureCounts.delete(id);
+    this.disabledHooks.delete(id);
+    return this.hooks.delete(id);
+  }
+  get(id) {
+    return this.hooks.get(id);
+  }
+  /**
+   * List hooks by phase, excluding disabled hooks.
+   */
+  listByPhase(phase) {
+    return [...this.hooks.values()].filter(
+      (h) => h.phase === phase && !this.disabledHooks.has(h.id)
+    );
+  }
+  /**
+   * Record a failure for a hook. After maxConsecutiveFailures, disable it.
+   */
+  recordFailure(id) {
+    const count = (this.failureCounts.get(id) ?? 0) + 1;
+    this.failureCounts.set(id, count);
+    if (count >= this.maxConsecutiveFailures) {
+      this.disabledHooks.add(id);
+    }
+  }
+  /**
+   * Record a success for a hook (resets failure count).
+   */
+  recordSuccess(id) {
+    this.failureCounts.set(id, 0);
+  }
+  isDisabled(id) {
+    return this.disabledHooks.has(id);
+  }
+  getAll() {
+    return [...this.hooks.values()];
+  }
+  clear() {
+    this.hooks.clear();
+    this.failureCounts.clear();
+    this.disabledHooks.clear();
+  }
+};
+
+// src/context/scope-generator.ts
+function generateScopeTable(entries, options = {}) {
+  const { maxVariables = 50, maxValueWidth = 50 } = options;
+  const visible = entries.slice(0, maxVariables);
+  if (visible.length === 0) {
+    return "(no variables declared)";
+  }
+  const nameCol = Math.max(4, ...visible.map((e) => e.name.length));
+  const typeCol = Math.max(4, ...visible.map((e) => e.type.length));
+  const header = `${"Name".padEnd(nameCol)}  ${"Type".padEnd(typeCol)}  Value`;
+  const separator = `${"-".repeat(nameCol)}  ${"-".repeat(typeCol)}  ${"-".repeat(maxValueWidth)}`;
+  const rows = visible.map((e) => {
+    const truncatedValue = e.value.length > maxValueWidth ? e.value.slice(0, maxValueWidth - 3) + "..." : e.value;
+    return `${e.name.padEnd(nameCol)}  ${e.type.padEnd(typeCol)}  ${truncatedValue}`;
+  });
+  const lines = [header, separator, ...rows];
+  if (entries.length > maxVariables) {
+    lines.push(`... +${entries.length - maxVariables} more variables`);
+  }
+  return lines.join("\n");
+}
+function describeType2(val) {
+  if (val === null) return "null";
+  if (val === void 0) return "undefined";
+  if (Array.isArray(val)) {
+    if (val.length === 0) return "Array";
+    return `Array<${describeType2(val[0])}>`;
+  }
+  const t = typeof val;
+  if (t === "object") {
+    const name = val.constructor?.name;
+    return name && name !== "Object" ? name : "Object";
+  }
+  return t;
+}
+function truncateValue2(val, maxLen = 50) {
+  if (val === null) return "null";
+  if (val === void 0) return "undefined";
+  if (typeof val === "function") return `[Function: ${val.name || "anonymous"}]`;
+  if (typeof val === "symbol") return val.toString();
+  try {
+    let str;
+    if (typeof val === "string") {
+      str = JSON.stringify(val);
+    } else if (Array.isArray(val)) {
+      const preview = val.slice(0, 3).map((v) => truncateValue2(v, 20)).join(", ");
+      str = val.length > 3 ? `[${preview}, ... +${val.length - 3}]` : `[${preview}]`;
+    } else if (typeof val === "object") {
+      const keys = Object.keys(val);
+      const preview = keys.slice(0, 5).join(", ");
+      str = keys.length > 5 ? `{${preview}, ... +${keys.length - 5}}` : `{${preview}}`;
+    } else {
+      str = String(val);
+    }
+    if (str.length > maxLen) {
+      return str.slice(0, maxLen - 3) + "...";
+    }
+    return str;
+  } catch {
+    return "[value]";
+  }
+}
+
+// src/context/message-builder.ts
+function buildStopMessage(payload) {
+  const entries = Object.entries(payload).map(([key, sv]) => `${key}: ${sv.display}`).join(", ");
+  return `\u2190 stop { ${entries} }`;
+}
+function buildErrorMessage(error) {
+  return `\u2190 error [${error.type}] ${error.message} (line ${error.line})`;
+}
+function buildInterventionMessage(text) {
+  return text;
+}
+function buildHookInterruptMessage(hookId, message) {
+  return `\u26A0 [hook:${hookId}] ${message}`;
+}
+function buildTasklistReminderMessage(tasklistId, ready, blocked, failed) {
+  let msg = `\u26A0 [system] Tasklist "${tasklistId}" incomplete.`;
+  if (ready.length > 0) msg += ` Ready: ${ready.join(", ")}.`;
+  if (blocked.length > 0) msg += ` Blocked: ${blocked.join(", ")}.`;
+  if (failed.length > 0) msg += ` Failed: ${failed.join(", ")}.`;
+  msg += " Continue with a ready task.";
+  return msg;
+}
+function renderTaskLine(task, state) {
+  const completion = state.completed.get(task.id);
+  if (completion?.status === "completed") {
+    const outputStr = JSON.stringify(completion.output);
+    const truncated = outputStr.length > 40 ? outputStr.slice(0, 37) + "..." : outputStr;
+    return { symbol: "\u2713", detail: `\u2192 ${truncated}` };
+  }
+  if (completion?.status === "failed") {
+    return { symbol: "\u2717", detail: `\u2014 ${completion.error ?? "unknown error"}` };
+  }
+  if (completion?.status === "skipped") {
+    return { symbol: "\u2298", detail: "(skipped \u2014 condition was falsy)" };
+  }
+  if (state.runningTasks.has(task.id)) {
+    const progress = state.progressMessages?.get(task.id);
+    const detail = progress ? `(running \u2014 ${progress.percent != null ? progress.percent + "% " : ""}${progress.message})` : "(running)";
+    return { symbol: "\u25C9", detail };
+  }
+  if (state.readyTasks.has(task.id)) {
+    return { symbol: "\u25CE", detail: "(ready \u2014 deps satisfied)" };
+  }
+  const deps = task.dependsOn?.join(", ") ?? "";
+  return { symbol: "\u25CB", detail: deps ? `(blocked \u2014 waiting on: ${deps})` : "(pending)" };
+}
+function buildTaskContinueMessage(tasklistId, completedTaskId, readyTasks, tasklistsState) {
+  let msg = `\u2190 completeTask \u2713 ${tasklistId}/${completedTaskId}`;
+  if (readyTasks.length > 0) {
+    msg += `
+
+Next task:`;
+    const next = readyTasks[0];
+    msg += `
+  Task: ${next.id}`;
+    msg += `
+  Instructions: ${next.instructions}`;
+    const schemaStr = Object.entries(next.outputSchema).map(([k, v]) => `${k}: ${v.type}`).join(", ");
+    msg += `
+  Expected output: { ${schemaStr} }`;
+    if (readyTasks.length > 1) {
+      msg += `
+
+Also ready: ${readyTasks.slice(1).map((t) => t.id).join(", ")}`;
+    }
+  }
+  const tasksBlock = generateTasksBlock(tasklistsState);
+  if (tasksBlock) msg += `
+
+${tasksBlock}`;
+  return msg;
+}
+function buildTaskOrderViolationMessage(tasklistId, attemptedTaskId, readyTasks, tasklistsState) {
+  let msg = `\u26A0 [system] Task order violation in tasklist "${tasklistId}": tried to complete "${attemptedTaskId}" but it is not ready.`;
+  if (readyTasks.length > 0) {
+    msg += `
+
+Next task to complete:`;
+    const next = readyTasks[0];
+    msg += `
+  Task: ${next.id}`;
+    msg += `
+  Instructions: ${next.instructions}`;
+    const schemaStr = Object.entries(next.outputSchema).map(([k, v]) => `${k}: ${v.type}`).join(", ");
+    msg += `
+  Expected output: { ${schemaStr} }`;
+    if (readyTasks.length > 1) {
+      msg += `
+
+Also ready: ${readyTasks.slice(1).map((t) => t.id).join(", ")}`;
+    }
+  }
+  msg += "\n\nWork on the ready task above, then call completeTask() when done.";
+  const tasksBlock = generateTasksBlock(tasklistsState);
+  if (tasksBlock) msg += `
+
+${tasksBlock}`;
+  return msg;
+}
+function generateCurrentTaskBlock(tasklistsState) {
+  if (tasklistsState.tasklists.size === 0) return null;
+  const lines = [];
+  for (const [tasklistId, state] of tasklistsState.tasklists) {
+    const readyIds = [...state.readyTasks];
+    if (readyIds.length === 0) continue;
+    const next = state.plan.tasks.find((t) => t.id === readyIds[0]);
+    if (!next) continue;
+    lines.push(`{{CURRENT_TASK}}`);
+    lines.push(`Tasklist: ${tasklistId}`);
+    lines.push(`Task: ${next.id}`);
+    lines.push(`Instructions: ${next.instructions}`);
+    const schemaStr = Object.entries(next.outputSchema).map(([k, v]) => `${k}: ${v.type}`).join(", ");
+    lines.push(`Expected output: { ${schemaStr} }`);
+  }
+  return lines.length > 0 ? lines.join("\n") : null;
+}
+function generateTasksBlock(tasklistsState) {
+  if (tasklistsState.tasklists.size === 0) return null;
+  const lines = ["{{TASKS}}"];
+  for (const [tasklistId, state] of tasklistsState.tasklists) {
+    const width = Math.max(1, 60 - tasklistId.length - 3);
+    lines.push(`\u250C ${tasklistId} ${"\u2500".repeat(width)}\u2510`);
+    for (const task of state.plan.tasks) {
+      const { symbol, detail } = renderTaskLine(task, state);
+      lines.push(`\u2502 ${symbol} ${task.id.padEnd(18)} ${detail.padEnd(40)}\u2502`);
+    }
+    lines.push(`\u2514${"\u2500".repeat(63)}\u2518`);
+  }
+  return lines.join("\n");
+}
+
+// src/sandbox/agent-registry.ts
+var AgentRegistry = class {
+  entries = /* @__PURE__ */ new Map();
+  questionResolvers = /* @__PURE__ */ new Map();
+  currentTurn = 0;
+  config;
+  constructor(config = {}) {
+    this.config = config;
+  }
+  register(varName, promise, label, childSession) {
+    const entry = {
+      varName,
+      label,
+      status: "running",
+      promise,
+      childSession,
+      registeredAt: Date.now(),
+      registeredTurn: this.currentTurn,
+      pendingQuestion: null
+    };
+    this.entries.set(varName, entry);
+    promise.then(
+      (value) => this.resolve(varName, value),
+      (err) => {
+        const error = err instanceof Error ? err.message : String(err);
+        this.fail(varName, error);
+      }
+    );
+    this.config.onRegistered?.(varName, label);
+  }
+  resolve(varName, value) {
+    const entry = this.entries.get(varName);
+    if (!entry) return;
+    entry.status = "resolved";
+    entry.resolvedValue = value;
+    entry.completedAt = Date.now();
+    this.config.onResolved?.(varName);
+  }
+  fail(varName, error) {
+    const entry = this.entries.get(varName);
+    if (!entry) return;
+    entry.status = "failed";
+    entry.error = error;
+    entry.completedAt = Date.now();
+    this.config.onFailed?.(varName, error);
+  }
+  getAll() {
+    return [...this.entries.values()];
+  }
+  getPending() {
+    return [...this.entries.values()].filter(
+      (e) => e.status === "running" || e.status === "waiting"
+    );
+  }
+  getSnapshot(varName) {
+    const entry = this.entries.get(varName);
+    if (!entry) return null;
+    let tasklistsState = null;
+    if (entry.childSession) {
+      try {
+        tasklistsState = entry.childSession.snapshot().tasklistsState;
+      } catch {
+      }
+    }
+    return {
+      varName: entry.varName,
+      label: entry.label,
+      status: entry.status,
+      tasklistsState,
+      pendingQuestion: entry.pendingQuestion ?? null,
+      error: entry.error
+    };
+  }
+  getAllSnapshots() {
+    return [...this.entries.keys()].map((varName) => this.getSnapshot(varName)).filter(Boolean);
+  }
+  findByPromise(promise) {
+    for (const entry of this.entries.values()) {
+      if (entry.promise === promise) return entry;
+    }
+    return null;
+  }
+  advanceTurn() {
+    this.currentTurn++;
+  }
+  getCurrentTurn() {
+    return this.currentTurn;
+  }
+  hasEntries() {
+    return this.entries.size > 0;
+  }
+  hasVisibleEntries() {
+    for (const entry of this.entries.values()) {
+      if (entry.status === "running" || entry.status === "waiting") return true;
+      if (entry.completedAt != null) {
+        const turnsSinceCompletion = this.currentTurn - entry.registeredTurn;
+        if (turnsSinceCompletion <= 5) return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Low-level setter — updates entry status and question fields.
+   * Prefer askQuestion() for the full flow (sets question + returns Promise).
+   */
+  setPendingQuestion(varName, question) {
+    const entry = this.entries.get(varName);
+    if (!entry) throw new Error(`setPendingQuestion: unknown agent "${varName}"`);
+    entry.pendingQuestion = question;
+    entry.status = "waiting";
+  }
+  /**
+   * Ask a question on behalf of a child agent. Sets status to 'waiting',
+   * stores the question, and returns a Promise that resolves when the
+   * parent calls respond().
+   */
+  askQuestion(varName, question) {
+    const entry = this.entries.get(varName);
+    if (!entry) throw new Error(`askQuestion: unknown agent "${varName}"`);
+    entry.pendingQuestion = question;
+    entry.status = "waiting";
+    this.config.onQuestionAsked?.(varName, question);
+    return new Promise((resolve) => {
+      this.questionResolvers.set(varName, resolve);
+    });
+  }
+  /**
+   * Deliver structured input to a child agent's pending askParent() call.
+   * Resolves the Promise returned by askQuestion(), clears the pending
+   * question, and sets the agent back to 'running'.
+   */
+  respond(varName, data) {
+    const entry = this.entries.get(varName);
+    if (!entry) throw new Error(`respond: unknown agent "${varName}"`);
+    if (entry.status !== "waiting") {
+      throw new Error(`respond: agent "${varName}" is not waiting for input (status: ${entry.status})`);
+    }
+    const resolver = this.questionResolvers.get(varName);
+    if (!resolver) throw new Error(`respond: no pending question for agent "${varName}"`);
+    entry.pendingQuestion = null;
+    entry.status = "running";
+    this.questionResolvers.delete(varName);
+    resolver(data);
+    this.config.onQuestionAnswered?.(varName);
+  }
+  destroy() {
+    this.entries.clear();
+    this.questionResolvers.clear();
+  }
+};
+
+// src/context/agents-block.ts
+function generateAgentsBlock(registry, resolvedInThisStop) {
+  if (!registry.hasVisibleEntries()) return null;
+  const currentTurn = registry.getCurrentTurn();
+  const lines = ["{{AGENTS}}"];
+  for (const entry of registry.getAll()) {
+    const turnsSinceRegistered = currentTurn - entry.registeredTurn;
+    const completedTurnDistance = entry.completedAt != null ? currentTurn - entry.registeredTurn : 0;
+    if ((entry.status === "resolved" || entry.status === "failed") && completedTurnDistance >= 6) {
+      continue;
+    }
+    const width = Math.max(1, 60 - entry.varName.length - entry.label.length - 5);
+    lines.push(`\u250C ${entry.varName} \u2014 ${entry.label} ${"\u2500".repeat(width)}\u2510`);
+    const isCompact = (entry.status === "resolved" || entry.status === "failed") && completedTurnDistance >= 3;
+    if (entry.status === "running") {
+      lines.push(`\u2502 \u25C9 running${" ".repeat(52)}\u2502`);
+      const snapshot = registry.getSnapshot(entry.varName);
+      if (snapshot?.tasklistsState && snapshot.tasklistsState.tasklists.size > 0) {
+        for (const [tlId, tlState] of snapshot.tasklistsState.tasklists) {
+          const tlWidth = Math.max(1, 56 - tlId.length - 3);
+          lines.push(`\u2502 \u250C tasks ${"\u2500".repeat(tlWidth)}\u2510  \u2502`);
+          for (const task of tlState.plan.tasks) {
+            const { symbol, detail } = renderTaskLine(task, tlState);
+            lines.push(`\u2502 \u2502 ${symbol} ${task.id.padEnd(16)} ${detail.padEnd(36)}\u2502  \u2502`);
+          }
+          lines.push(`\u2502 \u2514${"\u2500".repeat(Math.max(1, 57))}\u2518  \u2502`);
+        }
+      } else {
+        lines.push(`\u2502 (no tasklist)${" ".repeat(48)}\u2502`);
+      }
+    } else if (entry.status === "waiting") {
+      lines.push(`\u2502 ? waiting \u2014 needs input from parent${" ".repeat(26)}\u2502`);
+      if (entry.pendingQuestion && !isCompact) {
+        lines.push(`\u2502 \u250C question \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510   \u2502`);
+        const msg = entry.pendingQuestion.message.slice(0, 50);
+        lines.push(`\u2502 \u2502 "${msg}"${" ".repeat(Math.max(1, 51 - msg.length))}\u2502   \u2502`);
+        const schemaEntries = Object.entries(entry.pendingQuestion.schema);
+        if (schemaEntries.length > 0) {
+          lines.push(`\u2502 \u2502 schema: {${" ".repeat(43)}\u2502   \u2502`);
+          for (const [key, val] of schemaEntries.slice(0, 5)) {
+            const typeStr = formatSchemaValue(val);
+            lines.push(`\u2502 \u2502   ${key}: ${typeStr}`.padEnd(56) + "\u2502   \u2502");
+          }
+          if (schemaEntries.length > 5) {
+            lines.push(`\u2502 \u2502   ... +${schemaEntries.length - 5} more`.padEnd(56) + "\u2502   \u2502");
+          }
+          lines.push(`\u2502 \u2502 }`.padEnd(56) + "\u2502   \u2502");
+        }
+        lines.push(`\u2502 \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518   \u2502`);
+      }
+    } else if (entry.status === "resolved") {
+      if (isCompact) {
+        lines.push(`\u2502 \u2713 resolved${" ".repeat(51)}\u2502`);
+      } else if (resolvedInThisStop.has(entry.varName)) {
+        lines.push(`\u2502 \u2713 (value included in this stop payload)${" ".repeat(22)}\u2502`);
+      } else {
+        lines.push(`\u2502 \u2713 resolved${" ".repeat(51)}\u2502`);
+      }
+    } else if (entry.status === "failed") {
+      if (isCompact) {
+        lines.push(`\u2502 \u2717 failed${" ".repeat(53)}\u2502`);
+      } else {
+        const errMsg = (entry.error ?? "unknown error").slice(0, 50);
+        lines.push(`\u2502 \u2717 ${errMsg.padEnd(59)}\u2502`);
+      }
+    }
+    lines.push(`\u2514${"\u2500".repeat(63)}\u2518`);
+  }
+  if (lines.length === 1) return null;
+  return lines.join("\n");
+}
+function formatSchemaValue(val) {
+  if (!val || typeof val !== "object") return String(val);
+  const obj = val;
+  if (Array.isArray(obj.enum)) {
+    return obj.enum.slice(0, 4).map((e) => `"${e}"`).join(" | ") + (obj.enum.length > 4 ? ` | ...` : "");
+  }
+  if (typeof obj.type === "string") return obj.type;
+  return JSON.stringify(val).slice(0, 30);
+}
+
+// src/session/conversation-state.ts
+function computeScopeDelta(previous, current) {
+  const prevMap = /* @__PURE__ */ new Map();
+  for (const entry of previous) prevMap.set(entry.name, entry);
+  const currMap = /* @__PURE__ */ new Map();
+  for (const entry of current) currMap.set(entry.name, entry);
+  const added = [];
+  const changed = [];
+  for (const entry of current) {
+    const prev = prevMap.get(entry.name);
+    if (!prev) {
+      added.push(entry);
+    } else if (prev.type !== entry.type || prev.value !== entry.value) {
+      changed.push({
+        ...entry,
+        previousValue: prev.value,
+        previousType: prev.type
+      });
+    }
+  }
+  const removed = [];
+  for (const entry of previous) {
+    if (!currMap.has(entry.name)) {
+      removed.push(entry.name);
+    }
+  }
+  return { added, changed, removed };
+}
+function serializeTasklistsState(state) {
+  const tasklists = {};
+  for (const [id, tl] of state.tasklists) {
+    tasklists[id] = {
+      plan: {
+        tasklistId: tl.plan.tasklistId,
+        description: tl.plan.description,
+        tasks: tl.plan.tasks
+      },
+      completed: Object.fromEntries(tl.completed),
+      readyTasks: [...tl.readyTasks],
+      runningTasks: [...tl.runningTasks],
+      outputs: Object.fromEntries(tl.outputs),
+      progressMessages: Object.fromEntries(tl.progressMessages),
+      retryCount: Object.fromEntries(tl.retryCount)
+    };
+  }
+  return { tasklists };
+}
+var ConversationRecorder = class {
+  state;
+  previousScope = [];
+  pendingEvents = [];
+  currentTurnStartedAt;
+  constructor() {
+    const now = Date.now();
+    this.state = {
+      startedAt: now,
+      turns: [],
+      tasklists: { tasklists: {} },
+      stopCount: 0,
+      status: "idle"
+    };
+    this.currentTurnStartedAt = now;
+  }
+  /** Record an assistant turn ending at a stop boundary. */
+  recordStop(code, payload, scope, tasklists) {
+    const stopPayload = {};
+    for (const [key, sv] of Object.entries(payload)) {
+      stopPayload[key] = { display: sv.display, type: typeof sv.value };
+    }
+    this.state.stopCount++;
+    this.pushTurn({
+      role: "assistant",
+      code,
+      message: null,
+      boundary: { type: "stop", payload: stopPayload },
+      scope
+    });
+    this.state.tasklists = serializeTasklistsState(tasklists);
+  }
+  /** Record an assistant turn ending at an error boundary. */
+  recordError(code, error, scope) {
+    this.pushTurn({
+      role: "assistant",
+      code,
+      message: null,
+      boundary: {
+        type: "error",
+        error: {
+          type: error.type,
+          message: error.message,
+          line: error.line,
+          source: error.source
+        }
+      },
+      scope
+    });
+  }
+  /** Record an assistant turn ending at an intervention boundary. */
+  recordIntervention(code, text, scope) {
+    this.pushTurn({
+      role: "assistant",
+      code,
+      message: null,
+      boundary: { type: "intervention", text },
+      scope
+    });
+  }
+  /** Record an assistant turn ending at a tasklist reminder boundary. */
+  recordTasklistReminder(code, tasklistId, ready, blocked, failed, scope, tasklists) {
+    this.pushTurn({
+      role: "assistant",
+      code,
+      message: null,
+      boundary: { type: "tasklist_reminder", tasklistId, ready, blocked, failed },
+      scope
+    });
+    this.state.tasklists = serializeTasklistsState(tasklists);
+  }
+  /** Record session completion. */
+  recordCompletion(code, scope, tasklists, status) {
+    this.pushTurn({
+      role: "assistant",
+      code,
+      message: null,
+      boundary: { type: "completion" },
+      scope
+    });
+    this.state.tasklists = serializeTasklistsState(tasklists);
+    this.state.status = status;
+  }
+  /** Record a user message turn. */
+  recordUserMessage(text, scope) {
+    this.pushTurn({
+      role: "user",
+      code: null,
+      message: text,
+      boundary: null,
+      scope
+    });
+  }
+  /** Accumulate a session event (filtered to TurnEvent subset). */
+  recordEvent(event) {
+    const turnEvent = toTurnEvent(event);
+    if (turnEvent) this.pendingEvents.push(turnEvent);
+    if (event.type === "status") {
+      this.state.status = event.status;
+    }
+  }
+  /** Update session status. */
+  updateStatus(status) {
+    this.state.status = status;
+  }
+  /** Get the current full conversation state (returns a shallow copy). */
+  getState() {
+    return {
+      ...this.state,
+      turns: [...this.state.turns]
+    };
+  }
+  pushTurn(opts) {
+    const now = Date.now();
+    const scopeSnapshot = [...opts.scope];
+    const scopeDelta = this.state.turns.length > 0 ? computeScopeDelta(this.previousScope, opts.scope) : opts.scope.length > 0 ? { added: [...opts.scope], changed: [], removed: [] } : null;
+    this.state.turns.push({
+      index: this.state.turns.length,
+      startedAt: this.currentTurnStartedAt,
+      endedAt: now,
+      role: opts.role,
+      code: opts.code ? [...opts.code] : null,
+      message: opts.message,
+      boundary: opts.boundary,
+      scopeSnapshot,
+      scopeDelta,
+      events: this.pendingEvents.splice(0)
+    });
+    this.previousScope = scopeSnapshot;
+    this.currentTurnStartedAt = now;
+  }
+};
+function toTurnEvent(event) {
+  switch (event.type) {
+    case "display":
+      return { type: "display", componentId: event.componentId };
+    case "ask_start":
+      return { type: "ask_start", formId: event.formId };
+    case "ask_end":
+      return { type: "ask_end", formId: event.formId };
+    case "async_start":
+      return { type: "async_start", taskId: event.taskId, label: event.label };
+    case "async_complete":
+      return { type: "async_complete", taskId: event.taskId };
+    case "async_failed":
+      return { type: "async_failed", taskId: event.taskId, error: event.error };
+    case "async_cancelled":
+      return { type: "async_cancelled", taskId: event.taskId };
+    case "tasklist_declared":
+      return {
+        type: "tasklist_declared",
+        tasklistId: event.tasklistId,
+        description: event.plan.description,
+        taskCount: event.plan.tasks.length
+      };
+    case "task_complete":
+      return { type: "task_complete", tasklistId: event.tasklistId, taskId: event.id };
+    case "task_failed":
+      return { type: "task_failed", tasklistId: event.tasklistId, taskId: event.id, error: event.error };
+    case "task_retried":
+      return { type: "task_retried", tasklistId: event.tasklistId, taskId: event.id };
+    case "task_skipped":
+      return { type: "task_skipped", tasklistId: event.tasklistId, taskId: event.id, reason: event.reason };
+    case "task_progress":
+      return { type: "task_progress", tasklistId: event.tasklistId, taskId: event.id, message: event.message, percent: event.percent };
+    case "knowledge_loaded":
+      return { type: "knowledge_loaded", domains: event.domains };
+    case "class_loaded":
+      return { type: "class_loaded", className: event.className, methods: event.methods };
+    case "hook":
+      return { type: "hook", hookId: event.hookId, action: event.action };
+    case "agent_registered":
+      return { type: "agent_registered", varName: event.varName, label: event.label };
+    case "agent_resolved":
+      return { type: "agent_resolved", varName: event.varName };
+    case "agent_failed":
+      return { type: "agent_failed", varName: event.varName, error: event.error };
+    default:
+      return null;
+  }
+}
+
+// src/session/session.ts
+var Session = class extends EventEmitter {
+  status = "idle";
+  config;
+  sandbox;
+  asyncManager;
+  hookRegistry;
+  streamController;
+  globalsApi;
+  blocks = [];
+  codeLines = [];
+  messages = [];
+  activeFormId = null;
+  stopCount = 0;
+  tasklistReminderCount = 0;
+  agentRegistry;
+  recorder;
+  turnCodeStart = 0;
+  onSpawn;
+  constructor(options = {}) {
+    super();
+    this.config = options.config ? mergeConfig(options.config) : createDefaultConfig();
+    this.asyncManager = new AsyncManager(this.config.maxAsyncTasks);
+    this.hookRegistry = new HookRegistry();
+    this.agentRegistry = new AgentRegistry({
+      onRegistered: (varName, label) => {
+        this.emitEvent({ type: "agent_registered", varName, label });
+      },
+      onResolved: (varName) => {
+        this.emitEvent({ type: "agent_resolved", varName });
+      },
+      onFailed: (varName, error) => {
+        this.emitEvent({ type: "agent_failed", varName, error });
+      },
+      onQuestionAsked: (varName, question) => {
+        this.emitEvent({ type: "agent_question_asked", varName, question });
+      },
+      onQuestionAnswered: (varName) => {
+        this.emitEvent({ type: "agent_question_answered", varName });
+      }
+    });
+    if (options.hooks) {
+      for (const hook of options.hooks) {
+        this.hookRegistry.register(hook);
+      }
+    }
+    this.sandbox = new Sandbox({
+      timeout: this.config.functionTimeout,
+      globals: options.globals
+    });
+    this.streamController = new StreamController({
+      onStatement: (source) => this.executeStatement(source),
+      onStop: (payload, source) => this.handleStop(payload, source),
+      onError: (error) => this.handleError(error),
+      onEvent: (event) => this.emitEvent(event),
+      onCodeLine: (line) => this.codeLines.push(line),
+      hookRegistry: this.hookRegistry,
+      hookContext: () => ({
+        lineNumber: this.sandbox.getLineCount(),
+        sessionId: `session_${Date.now()}`,
+        scope: this.sandbox.getScope()
+      })
+    });
+    this.globalsApi = createGlobals({
+      pauseController: this.streamController,
+      renderSurface: {
+        append: (id, element) => {
+          this.emitEvent({ type: "display", componentId: id, jsx: serializeReactElement(element) });
+        },
+        renderForm: async (formId, element) => {
+          this.activeFormId = formId;
+          this.emitEvent({ type: "ask_start", formId, jsx: serializeReactElement(element) });
+          return new Promise((resolve) => {
+            this.once(`form:${formId}`, (data) => {
+              this.activeFormId = null;
+              this.emitEvent({ type: "ask_end", formId });
+              resolve(data);
+            });
+          });
+        },
+        cancelForm: (formId) => {
+          this.activeFormId = null;
+          this.emit(`form:${formId}`, { _cancelled: true });
+        }
+      },
+      asyncManager: this.asyncManager,
+      serializationLimits: this.config.serializationLimits,
+      askTimeout: this.config.askTimeout,
+      onStop: (payload, source) => this.handleStop(payload, source),
+      onDisplay: (id) => {
+      },
+      onAsyncStart: (taskId, label) => {
+        this.emitEvent({ type: "async_start", taskId, label });
+      },
+      onTasklistDeclared: (tasklistId, plan) => {
+        this.emitEvent({ type: "tasklist_declared", tasklistId, plan });
+      },
+      onTaskComplete: (tasklistId, id, output) => {
+        this.emitEvent({ type: "task_complete", tasklistId, id, output });
+      },
+      onTaskFailed: (tasklistId, id, error) => {
+        this.emitEvent({ type: "task_failed", tasklistId, id, error });
+      },
+      onTaskRetried: (tasklistId, id) => {
+        this.emitEvent({ type: "task_retried", tasklistId, id });
+      },
+      onTaskSkipped: (tasklistId, id, reason) => {
+        this.emitEvent({ type: "task_skipped", tasklistId, id, reason });
+      },
+      onTaskProgress: (tasklistId, id, message, percent) => {
+        this.emitEvent({ type: "task_progress", tasklistId, id, message, percent });
+      },
+      onTaskAsyncStart: (tasklistId, id) => {
+        this.emitEvent({ type: "task_async_start", tasklistId, id });
+      },
+      onTaskAsyncComplete: (tasklistId, id, output) => {
+        this.emitEvent({ type: "task_async_complete", tasklistId, id, output });
+      },
+      onTaskAsyncFailed: (tasklistId, id, error) => {
+        this.emitEvent({ type: "task_async_failed", tasklistId, id, error });
+      },
+      onTaskOrderViolation: (tasklistId, attemptedTaskId, readyTasks) => {
+        this.emitEvent({ type: "task_order_violation", tasklistId, attemptedTaskId, readyTasks });
+      },
+      onTaskCompleteContinue: (tasklistId, completedTaskId, readyTasks) => {
+        this.emitEvent({ type: "task_complete_continue", tasklistId, completedTaskId, readyTasks });
+      },
+      maxTaskRetries: this.config.maxTaskRetries,
+      maxTasksPerTasklist: this.config.maxTasksPerTasklist,
+      sleepMaxSeconds: this.config.sleepMaxSeconds,
+      onLoadKnowledge: options.knowledgeLoader ? (selector) => {
+        const content = options.knowledgeLoader(selector);
+        const domains = Object.keys(content);
+        this.emitEvent({ type: "knowledge_loaded", domains });
+        return content;
+      } : void 0,
+      getClassInfo: options.getClassInfo ?? void 0,
+      onLoadClass: options.loadClass ? (className) => {
+        const info = options.getClassInfo?.(className);
+        const methodNames = info?.methods.map((m) => m.name) ?? [];
+        options.loadClass(className, this);
+        this.emitEvent({ type: "class_loaded", className, methods: methodNames });
+      } : void 0,
+      onAskParent: options.onAskParent,
+      isFireAndForget: options.isFireAndForget,
+      onRespond: (promise, data) => {
+        const entry = this.agentRegistry.findByPromise(promise);
+        if (!entry) throw new Error("respond: unknown agent \u2014 pass the agent variable as the first argument");
+        this.agentRegistry.respond(entry.varName, data);
+      }
+    });
+    this.sandbox.inject("stop", this.globalsApi.stop);
+    this.sandbox.inject("display", this.globalsApi.display);
+    this.sandbox.inject("ask", this.globalsApi.ask);
+    this.sandbox.inject("async", this.globalsApi.async);
+    this.sandbox.inject("tasklist", this.globalsApi.tasklist);
+    this.sandbox.inject("completeTask", this.globalsApi.completeTask);
+    this.sandbox.inject("completeTaskAsync", this.globalsApi.completeTaskAsync);
+    this.sandbox.inject("taskProgress", this.globalsApi.taskProgress);
+    this.sandbox.inject("failTask", this.globalsApi.failTask);
+    this.sandbox.inject("retryTask", this.globalsApi.retryTask);
+    this.sandbox.inject("sleep", this.globalsApi.sleep);
+    this.sandbox.inject("loadKnowledge", this.globalsApi.loadKnowledge);
+    this.sandbox.inject("loadClass", this.globalsApi.loadClass);
+    this.sandbox.inject("askParent", this.globalsApi.askParent);
+    this.sandbox.inject("respond", this.globalsApi.respond);
+    if (options.agentNamespaces) {
+      for (const [name, ns] of Object.entries(options.agentNamespaces)) {
+        this.sandbox.inject(name, ns);
+      }
+    }
+    if (options.knowledgeNamespace) {
+      this.sandbox.inject("knowledge", options.knowledgeNamespace);
+    }
+    this.recorder = new ConversationRecorder();
+    this.on("event", (event) => this.recorder.recordEvent(event));
+    this.onSpawn = options.onSpawn ? async (config) => {
+      this.emitEvent({
+        type: "agent_spawn_start",
+        spaceName: config.spaceName,
+        agentSlug: config.agentSlug,
+        actionId: config.actionId
+      });
+      try {
+        const result = await options.onSpawn(config);
+        this.emitEvent({
+          type: "agent_spawn_complete",
+          spaceName: config.spaceName,
+          agentSlug: config.agentSlug,
+          actionId: config.actionId,
+          result
+        });
+        return result;
+      } catch (err) {
+        this.emitEvent({
+          type: "agent_spawn_failed",
+          spaceName: config.spaceName,
+          agentSlug: config.agentSlug,
+          actionId: config.actionId,
+          error: err?.message ?? String(err)
+        });
+        throw err;
+      }
+    } : void 0;
+  }
+  async executeStatement(source) {
+    this.globalsApi.setCurrentSource(source);
+    return this.sandbox.execute(source);
+  }
+  handleStop(payload, source) {
+    this.stopCount++;
+    this.agentRegistry.advanceTurn();
+    const cpState = this.globalsApi.getTasklistsState();
+    const tasksBlock = generateTasksBlock(cpState);
+    const resolvedInThisStop = /* @__PURE__ */ new Set();
+    for (const [, sv] of Object.entries(payload)) {
+      const entry = this.agentRegistry.findByPromise(sv.value);
+      if (entry?.status === "resolved") resolvedInThisStop.add(entry.varName);
+    }
+    const agentsBlock = generateAgentsBlock(this.agentRegistry, resolvedInThisStop);
+    const baseMsg = buildStopMessage(payload);
+    let msg = baseMsg;
+    if (tasksBlock) msg += `
+
+${tasksBlock}`;
+    if (agentsBlock) msg += `
+
+${agentsBlock}`;
+    this.messages.push({ role: "assistant", content: this.codeLines.join("\n") });
+    this.messages.push({ role: "user", content: msg });
+    this.emitEvent({
+      type: "read",
+      payload: Object.fromEntries(
+        Object.entries(payload).map(([k, v]) => [k, v.value])
+      ),
+      blockId: `stop_${this.stopCount}`
+    });
+    this.emitEvent({ type: "scope", entries: this.sandbox.getScope() });
+    const turnCode = this.codeLines.slice(this.turnCodeStart);
+    this.recorder.recordStop(turnCode, payload, this.sandbox.getScope(), cpState);
+    this.turnCodeStart = this.codeLines.length;
+  }
+  handleError(error) {
+    const msg = buildErrorMessage(error);
+    this.messages.push({ role: "assistant", content: this.codeLines.join("\n") });
+    this.messages.push({ role: "user", content: msg });
+    this.emitEvent({ type: "scope", entries: this.sandbox.getScope() });
+    const turnCode = this.codeLines.slice(this.turnCodeStart);
+    this.recorder.recordError(turnCode, error, this.sandbox.getScope());
+    this.turnCodeStart = this.codeLines.length;
+  }
+  /**
+   * Handle a user message.
+   */
+  async handleUserMessage(text) {
+    this.setStatus("executing");
+    this.messages.push({ role: "user", content: text });
+    this.recorder.recordUserMessage(text, this.sandbox.getScope());
+  }
+  /**
+   * Feed tokens from the LLM stream.
+   */
+  async feedToken(token) {
+    await this.streamController.feedToken(token);
+  }
+  /**
+   * Finalize the LLM stream.
+   * Returns 'complete' if done, or 'tasklist_incomplete' if tasks remain.
+   */
+  async finalize() {
+    await this.streamController.finalize();
+    const cpState = this.globalsApi.getTasklistsState();
+    for (const [tasklistId, tasklist] of cpState.tasklists) {
+      const hasRequiredIncomplete = tasklist.plan.tasks.some((t) => {
+        const completion = tasklist.completed.get(t.id);
+        const isIncomplete = !completion || completion.status !== "completed" && completion.status !== "skipped";
+        return isIncomplete && !t.optional;
+      });
+      if (!hasRequiredIncomplete) continue;
+      if (tasklist.runningTasks.size > 0) {
+        await Promise.race([
+          Promise.allSettled(
+            [...tasklist.runningTasks].map(
+              (id) => new Promise((resolve) => {
+                const check = () => {
+                  if (!tasklist.runningTasks.has(id)) {
+                    resolve();
+                    return;
+                  }
+                  setTimeout(check, 100);
+                };
+                check();
+              })
+            )
+          ),
+          new Promise((resolve) => setTimeout(resolve, this.config.taskAsyncTimeout))
+        ]);
+      }
+      if (this.tasklistReminderCount < this.config.maxTasklistReminders) {
+        this.tasklistReminderCount++;
+        const ready = [...tasklist.readyTasks];
+        const blocked = tasklist.plan.tasks.filter((t) => !tasklist.readyTasks.has(t.id) && !tasklist.completed.has(t.id) && !tasklist.runningTasks.has(t.id)).map((t) => `${t.id} (waiting on ${(t.dependsOn ?? []).join(", ")})`);
+        const failed = [...tasklist.completed.entries()].filter(([_, c]) => c.status === "failed").map(([id]) => id);
+        const msg = buildTasklistReminderMessage(tasklistId, ready, blocked, failed);
+        const tasksBlock = generateTasksBlock(cpState);
+        const fullMsg = tasksBlock ? `${msg}
+
+${tasksBlock}` : msg;
+        this.messages.push({ role: "assistant", content: this.codeLines.join("\n") });
+        this.messages.push({ role: "user", content: fullMsg });
+        const blockedIds = blocked.map((b) => b.split(" ")[0]);
+        this.recorder.recordTasklistReminder(
+          [...this.codeLines],
+          tasklistId,
+          ready,
+          blockedIds,
+          failed,
+          this.sandbox.getScope(),
+          cpState
+        );
+        this.codeLines = [];
+        this.turnCodeStart = 0;
+        this.emitEvent({ type: "tasklist_reminder", tasklistId, ready, blocked: blockedIds, failed });
+        this.emitEvent({ type: "scope", entries: this.sandbox.getScope() });
+        return "tasklist_incomplete";
+      }
+    }
+    await this.asyncManager.drain(5e3);
+    const turnCode = this.codeLines.slice(this.turnCodeStart);
+    this.recorder.recordCompletion(turnCode, this.sandbox.getScope(), this.globalsApi.getTasklistsState(), "complete");
+    this.turnCodeStart = this.codeLines.length;
+    this.setStatus("complete");
+    return "complete";
+  }
+  /**
+   * Resolve a pending stop() call, allowing sandbox to continue.
+   * Called by the runner after injecting the stop payload as a user message.
+   */
+  resolveStop() {
+    this.globalsApi.resolveStop();
+    this.streamController.resume();
+  }
+  /**
+   * Inject a value into the sandbox as a global.
+   * Used to inject class namespace objects after loadClass().
+   */
+  injectGlobal(name, value) {
+    this.sandbox.inject(name, value);
+  }
+  /**
+   * Resolve a pending ask() form.
+   */
+  resolveAsk(formId, data) {
+    const hasListener = this.listenerCount(`form:${formId}`) > 0;
+    console.log(`\x1B[90m  [session] resolveAsk ${formId} hasListener=${hasListener} activeFormId=${this.activeFormId}\x1B[0m`);
+    this.emit(`form:${formId}`, data);
+  }
+  /**
+   * Cancel a pending ask() form.
+   */
+  cancelAsk(formId) {
+    this.emit(`form:${formId}`, { _cancelled: true });
+  }
+  /**
+   * Cancel an async task.
+   */
+  cancelAsyncTask(taskId, message = "") {
+    this.asyncManager.cancel(taskId, message);
+    this.emitEvent({ type: "async_cancelled", taskId });
+  }
+  /**
+   * Pause the session.
+   */
+  pause() {
+    this.streamController.pause();
+    this.setStatus("paused");
+  }
+  /**
+   * Resume the session.
+   */
+  resume() {
+    this.streamController.resume();
+    this.setStatus("executing");
+  }
+  /**
+   * Handle user intervention (message while agent is running).
+   */
+  handleIntervention(text) {
+    if (this.activeFormId) {
+      this.cancelAsk(this.activeFormId);
+    }
+    this.streamController.pause();
+    const msg = buildInterventionMessage(text);
+    this.messages.push({ role: "assistant", content: this.codeLines.join("\n") });
+    this.messages.push({ role: "user", content: msg });
+    this.recorder.recordIntervention([...this.codeLines], text, this.sandbox.getScope());
+    this.codeLines = [];
+    this.turnCodeStart = 0;
+    this.emitEvent({ type: "scope", entries: this.sandbox.getScope() });
+    this.streamController.resume();
+  }
+  /**
+   * Get a snapshot of the current session state.
+   */
+  snapshot() {
+    return {
+      status: this.status,
+      blocks: [...this.blocks],
+      scope: this.sandbox.getScope(),
+      asyncTasks: this.asyncManager.getAllTasks().map((t) => ({
+        id: t.id,
+        label: t.label,
+        status: t.status,
+        elapsed: Date.now() - t.startTime
+      })),
+      activeFormId: this.activeFormId,
+      tasklistsState: this.globalsApi.getTasklistsState(),
+      agentEntries: this.agentRegistry.getAll().map((e) => ({
+        varName: e.varName,
+        label: e.label,
+        status: e.status,
+        error: e.error
+      }))
+    };
+  }
+  /**
+   * Get the full serializable conversation state.
+   */
+  getConversationState() {
+    return this.recorder.getState();
+  }
+  /**
+   * Get the current status.
+   */
+  getStatus() {
+    return this.status;
+  }
+  /**
+   * Get messages for context.
+   */
+  getMessages() {
+    return this.messages;
+  }
+  /**
+   * Get the public globals object (for passing to setup functions).
+   */
+  getGlobals() {
+    return {
+      stop: this.globalsApi.stop,
+      display: this.globalsApi.display,
+      ask: this.globalsApi.ask,
+      async: this.globalsApi.async,
+      tasklist: this.globalsApi.tasklist,
+      completeTask: this.globalsApi.completeTask,
+      completeTaskAsync: this.globalsApi.completeTaskAsync,
+      taskProgress: this.globalsApi.taskProgress,
+      failTask: this.globalsApi.failTask,
+      retryTask: this.globalsApi.retryTask,
+      sleep: this.globalsApi.sleep,
+      loadKnowledge: this.globalsApi.loadKnowledge,
+      loadClass: this.globalsApi.loadClass,
+      askParent: this.globalsApi.askParent,
+      respond: this.globalsApi.respond
+    };
+  }
+  /**
+   * Get the agent registry.
+   */
+  getAgentRegistry() {
+    return this.agentRegistry;
+  }
+  /**
+   * Get scope table as string.
+   */
+  getScopeTable() {
+    return generateScopeTable(this.sandbox.getScope(), {
+      maxVariables: this.config.workspace.maxScopeVariables,
+      maxValueWidth: this.config.workspace.maxScopeValueWidth
+    });
+  }
+  setStatus(status) {
+    this.status = status;
+    this.emitEvent({ type: "status", status });
+  }
+  emitEvent(event) {
+    this.emit("event", event);
+  }
+  /**
+   * Destroy the session and clean up resources.
+   */
+  destroy() {
+    this.agentRegistry.destroy();
+    this.asyncManager.cancelAll();
+    this.sandbox.destroy();
+    this.hookRegistry.clear();
+    this.removeAllListeners();
+  }
+};
+var CLIENT_COMPONENTS = /* @__PURE__ */ new Set([
+  "TextInput",
+  "TextArea",
+  "NumberInput",
+  "Slider",
+  "Checkbox",
+  "Select",
+  "MultiSelect",
+  "DatePicker",
+  "FileUpload"
+]);
+function serializeReactElement(element, depth = 0) {
+  if (depth > 20) return { component: "div", props: {}, children: ["[max depth]"] };
+  if (!element || typeof element !== "object" || !("type" in element)) {
+    return { component: "span", props: {}, children: [String(element ?? "")] };
+  }
+  const el = element;
+  const { children, ...restProps } = el.props ?? {};
+  let component;
+  if (typeof el.type === "string") {
+    component = el.type;
+  } else if (typeof el.type === "function") {
+    const name = el.type.name || "";
+    if (CLIENT_COMPONENTS.has(name)) {
+      component = name;
+    } else {
+      const _consoleError = console.error;
+      try {
+        console.error = () => {
+        };
+        const rendered = el.type(el.props);
+        return serializeReactElement(rendered, depth + 1);
+      } catch {
+        component = name || "div";
+      } finally {
+        console.error = _consoleError;
+      }
+    }
+  } else {
+    component = "div";
+  }
+  const safeProps = {};
+  for (const [key, value] of Object.entries(restProps)) {
+    if (typeof value === "function") continue;
+    if (typeof value === "symbol") continue;
+    safeProps[key] = value;
+  }
+  const serializedChildren = serializeChildren(children, depth);
+  return { component, props: safeProps, children: serializedChildren.length > 0 ? serializedChildren : void 0 };
+}
+function serializeChildren(children, depth) {
+  if (children == null) return [];
+  if (typeof children === "string") return [children];
+  if (typeof children === "number" || typeof children === "boolean") return [String(children)];
+  if (Array.isArray(children)) {
+    return children.flatMap((child) => serializeChildren(child, depth));
+  }
+  if (typeof children === "object" && "type" in children) {
+    return [serializeReactElement(children, depth + 1)];
+  }
+  return [String(children)];
+}
+
+// src/parser/global-detector.ts
+var GLOBALS = ["stop", "display", "ask", "async", "tasklist", "completeTask", "loadKnowledge"];
+function detectGlobalCall(source) {
+  const trimmed = source.trim();
+  const withoutAwait = trimmed.startsWith("await ") ? trimmed.slice(6).trim() : trimmed;
+  for (const name of GLOBALS) {
+    if (withoutAwait.startsWith(name + "(") || withoutAwait.startsWith(name + " (")) {
+      return name;
+    }
+  }
+  const assignMatch = trimmed.match(/^(?:const|let|var)\s+\w+\s*=\s*(?:await\s+)?(\w+)\s*\(/);
+  if (assignMatch) {
+    const callee = assignMatch[1];
+    if (GLOBALS.includes(callee)) {
+      return callee;
+    }
+  }
+  return null;
+}
+
+// src/context/code-window.ts
+function compressCodeWindow(turns, maxLines) {
+  if (turns.length === 0) return [];
+  let totalLines = turns.reduce((sum, t) => sum + t.lines.length, 0);
+  if (totalLines <= maxLines) {
+    return turns.flatMap((t) => t.lines);
+  }
+  const result = [];
+  const summaries = [];
+  let linesRemaining = maxLines;
+  for (let i = turns.length - 1; i >= 0; i--) {
+    const turn = turns[i];
+    if (linesRemaining >= turn.lines.length) {
+      result.unshift(...turn.lines);
+      linesRemaining -= turn.lines.length;
+    } else {
+      const startLine = turn.turnIndex;
+      const endLine = startLine + turn.lines.length - 1;
+      const declList = turn.declarations.length > 0 ? ` declared: ${turn.declarations.join(", ")}` : "";
+      summaries.unshift(`// [lines ${startLine}-${endLine} executed]${declList}`);
+    }
+  }
+  return [...summaries, ...result];
+}
+function buildSummaryComment(startLine, endLine, declarations) {
+  const declList = declarations.length > 0 ? ` declared: ${declarations.join(", ")}` : "";
+  return `// [lines ${startLine}-${endLine} executed]${declList}`;
+}
+
+// src/context/stop-decay.ts
+var DEFAULT_TIERS2 = { full: 2, keysOnly: 5, summary: 10 };
+function getDecayLevel(distance, tiers = DEFAULT_TIERS2) {
+  if (distance <= tiers.full) return "full";
+  if (distance <= tiers.keysOnly) return "keys";
+  if (distance <= tiers.summary) return "count";
+  return "removed";
+}
+function decayStopPayload(payload, distance, tiers = DEFAULT_TIERS2) {
+  const level = getDecayLevel(distance, tiers);
+  switch (level) {
+    case "full":
+      return formatFullPayload(payload);
+    case "keys":
+      return formatKeysPayload(payload);
+    case "count":
+      return formatCountPayload(payload);
+    case "removed":
+      return null;
+  }
+}
+function formatFullPayload(payload) {
+  const entries = Object.entries(payload).map(([key, sv]) => `${key}: ${sv.display}`);
+  return `\u2190 stop { ${entries.join(", ")} }`;
+}
+function formatKeysPayload(payload) {
+  const entries = Object.entries(payload).map(([key, sv]) => {
+    const type = describeValueType(sv);
+    return `${key}: ${type}`;
+  });
+  return `\u2190 stop { ${entries.join(", ")} }`;
+}
+function formatCountPayload(payload) {
+  const count = Object.keys(payload).length;
+  return `\u2190 stop (${count} value${count === 1 ? "" : "s"} read)`;
+}
+function describeValueType(sv) {
+  const val = sv.value;
+  if (val === null) return "null";
+  if (val === void 0) return "undefined";
+  if (Array.isArray(val)) return `Array(${val.length})`;
+  if (typeof val === "object") {
+    const keys = Object.keys(val);
+    return `Object{${keys.join(",")}}`;
+  }
+  return typeof val;
+}
+function decayErrorMessage(errorMsg, distance, tiers = DEFAULT_TIERS2) {
+  const level = getDecayLevel(distance, tiers);
+  if (level === "removed") return null;
+  if (level === "count") return "\u2190 error (1 error occurred)";
+  return errorMsg;
+}
+
+// src/context/system-prompt.ts
+function buildSystemPrompt(template, slots) {
+  let result = template;
+  for (const [key, value] of Object.entries(slots)) {
+    const marker = `{{${key}}}`;
+    result = result.replaceAll(marker, value);
+  }
+  return result;
+}
+function updateScopeInPrompt(systemPrompt, scopeTable) {
+  const scopeStart = systemPrompt.indexOf("{{SCOPE}}");
+  if (scopeStart === -1) {
+    return systemPrompt;
+  }
+  return systemPrompt.replace(
+    /\{\{SCOPE\}\}[\s\S]*?(?=\{\{|$)/,
+    scopeTable + "\n\n"
+  );
+}
+
+// src/security/function-registry.ts
+function wrapFunction(name, fn, options = {}) {
+  const timeout = options.timeout ?? 3e4;
+  const rateState = options.rateLimit ? { calls: [] } : null;
+  const wrapped = async function(...args) {
+    if (rateState && options.rateLimit) {
+      const now = Date.now();
+      const { maxCalls, windowMs } = options.rateLimit;
+      rateState.calls = rateState.calls.filter((t) => now - t < windowMs);
+      if (rateState.calls.length >= maxCalls) {
+        throw new Error(`Rate limit exceeded for ${name}: max ${maxCalls} calls per ${windowMs}ms`);
+      }
+      rateState.calls.push(now);
+    }
+    const start = Date.now();
+    const result = await Promise.race([
+      Promise.resolve(fn(...args)),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error(`Timeout: ${name} exceeded ${timeout}ms`)), timeout)
+      )
+    ]);
+    const duration = Date.now() - start;
+    options.onCall?.(name, args, duration);
+    return result;
+  };
+  Object.defineProperty(wrapped, "name", { value: name });
+  return wrapped;
+}
+var FunctionRegistry = class {
+  functions = /* @__PURE__ */ new Map();
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  register(name, fn) {
+    this.functions.set(name, wrapFunction(name, fn, this.options));
+  }
+  get(name) {
+    return this.functions.get(name);
+  }
+  getAll() {
+    const result = {};
+    for (const [name, fn] of this.functions) {
+      result[name] = fn;
+    }
+    return result;
+  }
+  has(name) {
+    return this.functions.has(name);
+  }
+  names() {
+    return [...this.functions.keys()];
+  }
+};
+
+// src/security/jsx-sanitizer.ts
+var BLOCKED_TAGS = /* @__PURE__ */ new Set(["script", "iframe", "object", "embed"]);
+var DANGEROUS_PROPS = /* @__PURE__ */ new Set(["dangerouslySetInnerHTML"]);
+var JAVASCRIPT_URL_PATTERN = /^\s*javascript:/i;
+function sanitizeJSX(jsx, path = "root") {
+  const errors = [];
+  if (BLOCKED_TAGS.has(jsx.component.toLowerCase())) {
+    errors.push({
+      path,
+      message: `Blocked element: <${jsx.component}> is not allowed`
+    });
+  }
+  for (const [key, value] of Object.entries(jsx.props)) {
+    if (DANGEROUS_PROPS.has(key)) {
+      errors.push({
+        path: `${path}.props.${key}`,
+        message: `Dangerous prop: ${key} is not allowed`
+      });
+    }
+    if ((key === "href" || key === "src" || key === "action") && typeof value === "string" && JAVASCRIPT_URL_PATTERN.test(value)) {
+      errors.push({
+        path: `${path}.props.${key}`,
+        message: `javascript: URLs are not allowed in ${key}`
+      });
+    }
+    if (key.startsWith("on") && key.length > 2 && key[2] === key[2].toUpperCase()) {
+      if (typeof value === "string") {
+        errors.push({
+          path: `${path}.props.${key}`,
+          message: `String event handler: ${key} must be a function, not a string`
+        });
+      }
+    }
+  }
+  if (jsx.children) {
+    for (let i = 0; i < jsx.children.length; i++) {
+      const child = jsx.children[i];
+      if (typeof child === "string") continue;
+      const childErrors = sanitizeJSX(child, `${path}.children[${i}]`);
+      errors.push(...childErrors);
+    }
+  }
+  return errors;
+}
+function isJSXSafe(jsx) {
+  return sanitizeJSX(jsx).length === 0;
+}
+function validateFormComponents(jsx, allowedComponents, path = "root") {
+  const errors = [];
+  if (path === "root" && jsx.component !== "Form" && jsx.component !== "form") {
+    errors.push({
+      path,
+      message: "ask() root must be a <Form> component"
+    });
+  }
+  if (jsx.children) {
+    for (let i = 0; i < jsx.children.length; i++) {
+      const child = jsx.children[i];
+      if (typeof child === "string") continue;
+      if (!allowedComponents.has(child.component) && child.component !== "Form" && child.component !== "form") {
+        errors.push({
+          path: `${path}.children[${i}]`,
+          message: `Unknown form component: <${child.component}>. Only registered input components are allowed.`
+        });
+      }
+      const childErrors = validateFormComponents(child, allowedComponents, `${path}.children[${i}]`);
+      errors.push(...childErrors);
+    }
+  }
+  return errors;
+}
+
+// src/catalog/index.ts
+var BUILTIN_MODULE_IDS = [
+  "path",
+  "date",
+  "crypto",
+  "json",
+  "csv",
+  "env",
+  "fs",
+  "fetch",
+  "shell",
+  "image",
+  "db"
+];
+async function loadCatalog(moduleIds) {
+  const ids = moduleIds === "all" ? [...BUILTIN_MODULE_IDS] : moduleIds;
+  const modules = [];
+  for (const id of ids) {
+    if (!isBuiltinModule(id)) {
+      throw new Error(`Unknown catalog module: ${id}`);
+    }
+    const mod = await importModule(id);
+    modules.push(mod);
+  }
+  return modules;
+}
+function isBuiltinModule(id) {
+  return BUILTIN_MODULE_IDS.includes(id);
+}
+async function importModule(id) {
+  switch (id) {
+    case "path":
+      return (await import("./path-K3VLZVTH.js")).default;
+    case "date":
+      return (await import("./date-DL6PIRCI.js")).default;
+    case "crypto":
+      return (await import("./crypto-BTVPQPPV.js")).default;
+    case "json":
+      return (await import("./json-VPTMTXR6.js")).default;
+    case "csv":
+      return (await import("./csv-3IL3IKAY.js")).default;
+    case "env":
+      return (await import("./env-PPLEQ47H.js")).default;
+    case "fs":
+      return (await import("./fs-QRXDDXB5.js")).default;
+    case "fetch":
+      return (await import("./fetch-TN4ZJVQW.js")).default;
+    case "shell":
+      return (await import("./shell-NAGRIUA4.js")).default;
+    case "image":
+      return (await import("./image-FGNY3CMJ.js")).default;
+    case "db":
+      return (await import("./db-IVNVHDFE.js")).default;
+  }
+}
+function mergeCatalogs(modules) {
+  return modules.flatMap((m) => m.functions);
+}
+function getCatalogModule(modules, id) {
+  return modules.find((m) => m.id === id);
+}
+function formatCatalogForPrompt(modules) {
+  const lines = [];
+  for (const mod of modules) {
+    lines.push(`  # Built-in: ${mod.id}`);
+    for (const fn of mod.functions) {
+      lines.push(`  ${fn.name}${fn.signature}`);
+      lines.push(`    \u2014 ${fn.description}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/knowledge/index.ts
+import { readFileSync, readdirSync, existsSync } from "fs";
+import { join } from "path";
+function mergeKnowledgeTrees(trees) {
+  const domainMap = /* @__PURE__ */ new Map();
+  for (const tree of trees) {
+    for (const domain of tree.domains) {
+      const existing = domainMap.get(domain.slug);
+      if (!existing) {
+        domainMap.set(domain.slug, { ...domain, fields: [...domain.fields] });
+      } else {
+        const fieldSlugs = new Set(existing.fields.map((f) => f.slug));
+        for (const field of domain.fields) {
+          if (!fieldSlugs.has(field.slug)) {
+            existing.fields.push(field);
+          }
+        }
+      }
+    }
+  }
+  return { domains: [...domainMap.values()] };
+}
+function buildKnowledgeTree(knowledgeDir) {
+  if (!existsSync(knowledgeDir)) {
+    return { domains: [] };
+  }
+  const domains = [];
+  const entries = readdirSync(knowledgeDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const domainPath = join(knowledgeDir, entry.name);
+    const domain = readDomain(domainPath, entry.name);
+    if (domain) domains.push(domain);
+  }
+  return { domains };
+}
+function readDomain(domainPath, slug) {
+  const configPath = join(domainPath, "config.json");
+  if (!existsSync(configPath)) return null;
+  try {
+    const config = JSON.parse(readFileSync(configPath, "utf-8"));
+    const fields = [];
+    const entries = readdirSync(domainPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const field = readField(join(domainPath, entry.name), entry.name);
+      if (field) fields.push(field);
+    }
+    return {
+      slug,
+      label: config.label ?? slug,
+      description: config.description ?? "",
+      icon: config.icon ?? "",
+      color: config.color ?? "#888888",
+      fields
+    };
+  } catch {
+    return null;
+  }
+}
+function readField(fieldPath, slug) {
+  const configPath = join(fieldPath, "config.json");
+  if (!existsSync(configPath)) return null;
+  try {
+    const config = JSON.parse(readFileSync(configPath, "utf-8"));
+    const options = [];
+    const entries = readdirSync(fieldPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+      const optionSlug = entry.name.replace(/\.md$/, "");
+      const option = readOptionMeta(join(fieldPath, entry.name), optionSlug);
+      if (option) options.push(option);
+    }
+    options.sort((a, b) => a.order - b.order);
+    return {
+      slug,
+      label: config.label ?? slug,
+      description: config.description ?? "",
+      fieldType: config.fieldType ?? "select",
+      required: config.required ?? false,
+      default: config.default,
+      variableName: config.variableName ?? slug,
+      options
+    };
+  } catch {
+    return null;
+  }
+}
+function readOptionMeta(filePath, slug) {
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    const fm = parseFrontmatter(content);
+    return {
+      slug,
+      title: fm.title ?? slug,
+      description: fm.description ?? "",
+      order: fm.order ?? 99
+    };
+  } catch {
+    return null;
+  }
+}
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return {};
+  const result = {};
+  for (const line of match[1].split("\n")) {
+    const m = line.match(/^(\w[\w-]*)\s*:\s*(.+)$/);
+    if (!m) continue;
+    const [, key, raw] = m;
+    let value = raw.trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    if (/^\d+$/.test(value)) value = parseInt(value, 10);
+    result[key] = value;
+  }
+  return result;
+}
+function loadKnowledgeFiles(knowledgeDir, selector) {
+  const result = {};
+  for (const [domainSlug, fields] of Object.entries(selector)) {
+    if (typeof fields !== "object" || fields === null) continue;
+    result[domainSlug] = {};
+    for (const [fieldSlug, options] of Object.entries(fields)) {
+      if (typeof options !== "object" || options === null) continue;
+      result[domainSlug][fieldSlug] = {};
+      for (const [optionSlug, selected] of Object.entries(options)) {
+        if (selected !== true) continue;
+        const filePath = join(knowledgeDir, domainSlug, fieldSlug, `${optionSlug}.md`);
+        if (!existsSync(filePath)) continue;
+        try {
+          const content = readFileSync(filePath, "utf-8");
+          const body = content.replace(/^---\n[\s\S]*?\n---\n*/, "").trim();
+          result[domainSlug][fieldSlug][optionSlug] = body;
+        } catch {
+        }
+      }
+    }
+  }
+  return result;
+}
+function formatKnowledgeTreeForPrompt(treeOrTrees) {
+  const trees = Array.isArray(treeOrTrees) ? treeOrTrees : [treeOrTrees];
+  const allDomains = trees.flatMap((t) => t.domains);
+  if (allDomains.length === 0) return "(no knowledge loaded)";
+  const lines = ["<knowledge>"];
+  const hasNames = trees.some((t) => t.name);
+  if (hasNames) {
+    const nonEmpty = trees.filter((t) => t.domains.length > 0);
+    for (const tree of nonEmpty) {
+      lines.push(`  <space name="${xmlEsc(tree.name ?? "unknown")}">`);
+      for (const domain of tree.domains) {
+        formatDomainXml(lines, domain, "    ");
+      }
+      lines.push("  </space>");
+    }
+  } else {
+    for (const domain of allDomains) {
+      formatDomainXml(lines, domain, "  ");
+    }
+  }
+  lines.push("</knowledge>");
+  return lines.join("\n");
+}
+function formatDomainXml(lines, domain, indent) {
+  lines.push(`${indent}<domain name="${xmlEsc(domain.slug)}" icon="${xmlEsc(domain.icon)}" label="${xmlEsc(domain.label)}">`);
+  for (const field of domain.fields) {
+    lines.push(`${indent}  <field name="${xmlEsc(field.slug)}" type="${xmlEsc(field.fieldType)}" var="${xmlEsc(field.variableName)}">`);
+    for (const option of field.options) {
+      const desc = option.description ? ` \u2014 ${xmlEsc(option.description)}` : "";
+      lines.push(`${indent}    <option name="${xmlEsc(option.slug)}">${xmlEsc(option.title)}${desc}</option>`);
+    }
+    lines.push(`${indent}  </field>`);
+  }
+  lines.push(`${indent}</domain>`);
+}
+function xmlEsc(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+
+// src/knowledge/writer.ts
+import { mkdirSync, writeFileSync, unlinkSync, existsSync as existsSync2, readdirSync as readdirSync2 } from "fs";
+import { join as join2 } from "path";
+var MEMORY_DOMAIN_CONFIG = {
+  label: "Memory",
+  description: "Persistent agent memory",
+  icon: "\u{1F9E0}",
+  color: "#9b59b6",
+  renderAs: "section"
+};
+var MEMORY_FIELDS = {
+  user: {
+    label: "User",
+    description: "User preferences and context",
+    fieldType: "text",
+    variableName: "userMemory"
+  },
+  project: {
+    label: "Project",
+    description: "Project-specific knowledge",
+    fieldType: "text",
+    variableName: "projectMemory"
+  },
+  feedback: {
+    label: "Feedback",
+    description: "Behavioral guidance",
+    fieldType: "text",
+    variableName: "feedbackMemory"
+  },
+  reference: {
+    label: "Reference",
+    description: "External resource pointers",
+    fieldType: "text",
+    variableName: "referenceMemory"
+  }
+};
+function saveKnowledgeFile(knowledgeDir, domain, field, option, content) {
+  const domainDir = join2(knowledgeDir, domain);
+  const fieldDir = join2(domainDir, field);
+  const filePath = join2(fieldDir, `${option}.md`);
+  mkdirSync(fieldDir, { recursive: true });
+  const domainConfigPath = join2(domainDir, "config.json");
+  if (!existsSync2(domainConfigPath)) {
+    if (domain === "memory") {
+      writeFileSync(domainConfigPath, JSON.stringify(MEMORY_DOMAIN_CONFIG, null, 2), "utf-8");
+    } else {
+      writeFileSync(domainConfigPath, JSON.stringify({
+        label: domain.charAt(0).toUpperCase() + domain.slice(1),
+        description: "",
+        icon: "\u{1F4C1}",
+        color: "#888888",
+        renderAs: "section"
+      }, null, 2), "utf-8");
+    }
+  }
+  const fieldConfigPath = join2(fieldDir, "config.json");
+  if (!existsSync2(fieldConfigPath)) {
+    const memoryFieldConfig = MEMORY_FIELDS[field];
+    if (domain === "memory" && memoryFieldConfig) {
+      writeFileSync(fieldConfigPath, JSON.stringify({
+        ...memoryFieldConfig,
+        required: false,
+        renderAs: "field"
+      }, null, 2), "utf-8");
+    } else {
+      writeFileSync(fieldConfigPath, JSON.stringify({
+        label: field.charAt(0).toUpperCase() + field.slice(1),
+        description: "",
+        fieldType: "text",
+        required: false,
+        variableName: field,
+        renderAs: "field"
+      }, null, 2), "utf-8");
+    }
+  }
+  const title = option.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+  const hasFrontmatter = content.trimStart().startsWith("---");
+  let fileContent;
+  if (hasFrontmatter) {
+    fileContent = content;
+  } else {
+    fileContent = `---
+title: ${title}
+description: ${content.slice(0, 80).replace(/\n/g, " ")}
+order: 99
+---
+
+${content}
+`;
+  }
+  writeFileSync(filePath, fileContent, "utf-8");
+}
+function deleteKnowledgeFile(knowledgeDir, domain, field, option) {
+  const filePath = join2(knowledgeDir, domain, field, `${option}.md`);
+  if (!existsSync2(filePath)) return false;
+  unlinkSync(filePath);
+  return true;
+}
+function ensureMemoryDomain(knowledgeDir) {
+  if (!existsSync2(knowledgeDir)) {
+    mkdirSync(knowledgeDir, { recursive: true });
+  }
+  const memoryDir = join2(knowledgeDir, "memory");
+  mkdirSync(memoryDir, { recursive: true });
+  const domainConfigPath = join2(memoryDir, "config.json");
+  if (!existsSync2(domainConfigPath)) {
+    writeFileSync(domainConfigPath, JSON.stringify(MEMORY_DOMAIN_CONFIG, null, 2), "utf-8");
+  }
+  for (const [fieldSlug, fieldConfig] of Object.entries(MEMORY_FIELDS)) {
+    const fieldDir = join2(memoryDir, fieldSlug);
+    mkdirSync(fieldDir, { recursive: true });
+    const fieldConfigPath = join2(fieldDir, "config.json");
+    if (!existsSync2(fieldConfigPath)) {
+      writeFileSync(fieldConfigPath, JSON.stringify({
+        ...fieldConfig,
+        required: false,
+        renderAs: "field"
+      }, null, 2), "utf-8");
+    }
+  }
+}
+function parseFieldPath(fieldParam) {
+  const parts = fieldParam.split("/");
+  if (parts.length >= 2) {
+    return { domain: parts[0], field: parts.slice(1).join("/") };
+  }
+  return { domain: "memory", field: parts[0] };
+}
+export {
+  AgentRegistry,
+  AsyncManager,
+  ConversationRecorder,
+  FunctionRegistry,
+  HookRegistry,
+  KNOWLEDGE_TAG,
+  Sandbox,
+  Session,
+  StreamController,
+  buildErrorMessage,
+  buildHookInterruptMessage,
+  buildInterventionMessage,
+  buildKnowledgeTree,
+  buildStopMessage,
+  buildSummaryComment,
+  buildSystemPrompt,
+  buildTaskContinueMessage,
+  buildTaskOrderViolationMessage,
+  buildTasklistReminderMessage,
+  clear,
+  compressCodeWindow,
+  computeScopeDelta,
+  createBracketState,
+  createDefaultConfig,
+  createGlobals,
+  createLineAccumulator,
+  decayErrorMessage,
+  decayKnowledgeValue,
+  decayStopPayload,
+  deleteKnowledgeFile,
+  describeType2 as describeType,
+  detectGlobalCall,
+  ensureMemoryDomain,
+  executeHooks,
+  executeLine,
+  extractDeclarations,
+  extractVariableNames,
+  feed,
+  feedChunk,
+  findMatches,
+  flush,
+  formatCatalogForPrompt,
+  formatKnowledgeTreeForPrompt,
+  generateAgentsBlock,
+  generateCurrentTaskBlock,
+  generateScopeTable,
+  generateTasksBlock,
+  getCatalogModule,
+  getDecayLevel,
+  getKnowledgeDecayLevel,
+  isBalanced,
+  isCompleteStatement,
+  isJSXSafe,
+  isKnowledgeContent,
+  loadCatalog,
+  loadKnowledgeFiles,
+  matchPattern,
+  mergeCatalogs,
+  mergeConfig,
+  mergeKnowledgeTrees,
+  parseFieldPath,
+  parseStatement,
+  recoverArgumentNames,
+  renderTaskLine,
+  resetBracketState,
+  sanitizeJSX,
+  saveKnowledgeFile,
+  serialize,
+  serializeTasklistsState,
+  tagAsKnowledge,
+  transpile,
+  truncateValue2 as truncateValue,
+  updateScopeInPrompt,
+  validateConfig,
+  validateFormComponents,
+  wrapFunction
+};