theokit 0.8.0 → 0.8.1

package/dist/{dist-6GPD6WCU.js → dist-IW7G5Y23.js}

@@ -2,11 +2,11 @@
 import "tsx/esm";
 import "./chunk-KT3MWNZG.js";
 
-// ../../node_modules/.pnpm/@theokit+sdk@2.0.1_@lancedb+lancedb@0.30.0_apache-arrow@18.1.0__@types+ws@8.18.1_better-sqlit_hxks36aepiyjbgw5nq4izwbfgy/node_modules/@theokit/sdk/dist/index.js
+// ../../node_modules/.pnpm/@theokit+sdk@2.5.0_@lancedb+lancedb@0.30.0_apache-arrow@18.1.0__@types+ws@8.18.1_better-sqlit_zipxufn4zgvf3bcwwyuqnkcqfi/node_modules/@theokit/sdk/dist/index.js
+import { createHash, randomUUID, randomBytes } from "crypto";
 import { existsSync, rmSync, mkdirSync, renameSync, readFileSync, realpathSync, lstatSync, readlinkSync, readdirSync } from "fs";
 import { join, dirname, relative, resolve, sep, isAbsolute } from "path";
-import { createHash, randomUUID, randomBytes } from "crypto";
-import { readFile, stat, rm, readdir, mkdir, appendFile, rename, open, unlink, statfs, access } from "fs/promises";
+import { readFile, stat, rm, readdir, mkdir, appendFile, open, rename, unlink, statfs, access } from "fs/promises";
 import { z, toJSONSchema } from "zod";
 import { AsyncLocalStorage } from "async_hooks";
 import { createRequire } from "module";
@@ -384,7 +384,7 @@ var R = class {
   }
 };
 
-// ../../node_modules/.pnpm/@theokit+sdk@2.0.1_@lancedb+lancedb@0.30.0_apache-arrow@18.1.0__@types+ws@8.18.1_better-sqlit_hxks36aepiyjbgw5nq4izwbfgy/node_modules/@theokit/sdk/dist/index.js
+// ../../node_modules/.pnpm/@theokit+sdk@2.5.0_@lancedb+lancedb@0.30.0_apache-arrow@18.1.0__@types+ws@8.18.1_better-sqlit_zipxufn4zgvf3bcwwyuqnkcqfi/node_modules/@theokit/sdk/dist/index.js
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __esm = (fn, res) => function __init() {
@@ -394,6 +394,22 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+function defaultRetriableForCode(code) {
+  switch (code) {
+    case "rate_limit":
+    case "timeout":
+    case "server_error":
+    case "network":
+    case "provider_unreachable":
+      return true;
+    default:
+      return false;
+  }
+}
+var init_default_retriable = __esm({
+  "src/internal/default-retriable.ts"() {
+  }
+});
 function readEnvOnce() {
   const raw = process.env.THEOKIT_REDACT_SECRETS;
   if (raw === void 0) return true;
@@ -552,7 +568,8 @@ __export(errors_exports, {
   UnsupportedBudgetOperationError: () => UnsupportedBudgetOperationError,
   UnsupportedRunOperationError: () => UnsupportedRunOperationError,
   UnsupportedTaskOperationError: () => UnsupportedTaskOperationError,
-  coerceToKnownAgentRunErrorCode: () => coerceToKnownAgentRunErrorCode
+  coerceToKnownAgentRunErrorCode: () => coerceToKnownAgentRunErrorCode,
+  isTransientError: () => isTransientError
 });
 function coerceToKnownAgentRunErrorCode(code) {
   if (code !== void 0 && KNOWN_AGENT_RUN_ERROR_CODES.has(code)) {
@@ -584,17 +601,8 @@ function safeStringify(value) {
     return String(value);
   }
 }
-function defaultRetriableForCode(code) {
-  switch (code) {
-    case "rate_limit":
-    case "timeout":
-    case "server_error":
-    case "network":
-    case "provider_unreachable":
-      return true;
-    default:
-      return false;
-  }
+function isTransientError(err) {
+  return err instanceof TheokitAgentError && err.isRetryable === true;
 }
 var KNOWN_AGENT_RUN_ERROR_CODES;
 var TheokitAgentError;
@@ -616,6 +624,7 @@ var AgentDisposedError;
 var UnsupportedBudgetOperationError;
 var init_errors = __esm({
   "src/errors.ts"() {
+    init_default_retriable();
     init_redact();
     KNOWN_AGENT_RUN_ERROR_CODES = /* @__PURE__ */ new Set([
       "rate_limit",
@@ -1037,6 +1046,19 @@ function sanitizeIdentifier(input, options) {
   }
   return input.toLowerCase();
 }
+function safeFilenameForId(id, options) {
+  if (id.length === 0) {
+    throw new ConfigurationError("Filename id must be a non-empty string", {
+      code: "invalid_filename_id"
+    });
+  }
+  const maxLen = options?.maxLen;
+  const lower = id.toLowerCase();
+  if (lower.length <= maxLen && IDENTIFIER_PATTERN.test(lower)) {
+    return lower;
+  }
+  return `h-${createHash("sha256").update(id).digest("hex").slice(0, 16)}`;
+}
 var PathTraversalError;
 var IDENTIFIER_PATTERN;
 var init_path_guard = __esm({
@@ -1439,10 +1461,7 @@ function sessionsDir(cwd) {
   return join(memoryDir(cwd), "sessions");
 }
 function sessionSummaryPath(cwd, runId) {
-  return join(sessionsDir(cwd), `${sanitizeRunId(runId)}.md`);
-}
-function sanitizeRunId(runId) {
-  return runId.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 128);
+  return join(sessionsDir(cwd), `${safeFilenameForId(runId, { maxLen: 128 })}.md`);
 }
 function truncate(text) {
   if (text.length <= MAX_TURN_CHARS) return text;
@@ -1478,6 +1497,7 @@ var MAX_TURN_CHARS;
 var init_session_summary_writer = __esm({
   "src/internal/memory/storage/session-summary-writer.ts"() {
     init_atomic_write();
+    init_path_guard();
     init_types();
     init_markdown_store();
     MAX_TURN_CHARS = 2e3;
@@ -1506,6 +1526,47 @@ var init_async_local_storage = __esm({
     toolWhitelistStore = new AsyncLocalStorage();
   }
 });
+function createSemaphore(permits) {
+  if (!Number.isInteger(permits) || permits < 1) {
+    throw new ConfigurationError(
+      `async-semaphore: permits must be a positive integer, got ${permits}`,
+      { code: "invalid_concurrency" }
+    );
+  }
+  let active = 0;
+  const queue = [];
+  function tryGrant() {
+    if (active < permits && queue.length > 0) {
+      const resolve3 = queue.shift();
+      if (resolve3 !== void 0) {
+        active += 1;
+        resolve3();
+      }
+    }
+  }
+  return {
+    inFlight: () => active,
+    pending: () => queue.length + active,
+    async acquire() {
+      await new Promise((resolve3) => {
+        queue.push(resolve3);
+        tryGrant();
+      });
+      let released = false;
+      return () => {
+        if (released) return;
+        released = true;
+        active -= 1;
+        tryGrant();
+      };
+    }
+  };
+}
+var init_async_semaphore = __esm({
+  "src/internal/runtime/concurrency/async-semaphore.ts"() {
+    init_errors();
+  }
+});
 var COOLDOWN_MS;
 var DEFAULT_COOLDOWN_MS;
 var init_credential_pool_types = __esm({
@@ -1879,6 +1940,61 @@ var init_sqlite_wal = __esm({
     warnedLabels = /* @__PURE__ */ new Set();
   }
 });
+async function openSqliteResilient(options) {
+  await mkdir(dirname(options.filePath), { recursive: true });
+  try {
+    return await openConcrete(options);
+  } catch (cause) {
+    if (options.recoverCorrupt !== false && isCorruptionError(cause)) {
+      await renameAside(options.filePath, options.label ?? "sqlite");
+      return await openConcrete(options);
+    }
+    throw cause;
+  }
+}
+async function openConcrete(options) {
+  const db = await loadDriver(options.filePath);
+  applyWalWithFallback(db, options.label ?? "sqlite");
+  await options.onOpen?.(db);
+  return db;
+}
+async function loadDriver(filePath) {
+  try {
+    const mod = await import("./lib-JBI3XXH3.js");
+    const Ctor = mod.default ?? mod;
+    if (typeof Ctor !== "function") {
+      throw new Error(`better-sqlite3 export is not a constructor (got ${typeof Ctor})`);
+    }
+    return new Ctor(filePath);
+  } catch (cause) {
+    const message = cause instanceof Error ? cause.message : String(cause);
+    throw new ConfigurationError(
+      `Failed to load SQLite driver. Install \`better-sqlite3\` or run on Node 22.5+ for built-in \`node:sqlite\`. Cause: ${message}`,
+      { code: "sqlite_driver_unavailable", cause }
+    );
+  }
+}
+function isCorruptionError(cause) {
+  if (!(cause instanceof Error)) return false;
+  const msg = cause.message.toLowerCase();
+  return msg.includes("malformed") || msg.includes("not a database") || msg.includes("encrypted") || msg.includes("disk image is malformed");
+}
+async function renameAside(filePath, label) {
+  const asidePath = `${filePath}.corrupt-${Date.now()}`;
+  await rename(filePath, asidePath).catch(() => void 0);
+  await rename(`${filePath}-wal`, `${asidePath}-wal`).catch(() => void 0);
+  await rename(`${filePath}-shm`, `${asidePath}-shm`).catch(() => void 0);
+  process.stderr.write(
+    `[theokit-sdk] ${label} database corrupt; renamed aside to ${asidePath} and rebuilt schema
+`
+  );
+}
+var init_sqlite_open = __esm({
+  "src/internal/persistence/sqlite-open.ts"() {
+    init_errors();
+    init_sqlite_wal();
+  }
+});
 var SCHEMA_STATEMENTS;
 var PRAGMA_STATEMENTS;
 var init_index_schema = __esm({
@@ -1925,60 +2041,22 @@ var init_index_schema = __esm({
   }
 });
 async function openMemoryDb(opts) {
-  await mkdir(dirname(opts.filePath), { recursive: true });
-  try {
-    return await openConcrete(opts.filePath);
-  } catch (cause) {
-    if (opts.recoverCorrupt !== false && isCorruptionError(cause)) {
-      await renameAside(opts.filePath);
-      return await openConcrete(opts.filePath);
+  return openSqliteResilient({
+    filePath: opts.filePath,
+    label: "memory-index",
+    recoverCorrupt: opts.recoverCorrupt,
+    onOpen: (db) => {
+      for (const pragma of PRAGMA_STATEMENTS) db.exec(pragma);
+      for (const stmt of SCHEMA_STATEMENTS) db.exec(stmt);
     }
-    throw cause;
-  }
-}
-async function openConcrete(filePath) {
-  const db = await loadDriver(filePath);
-  applyWalWithFallback(db, "memory-index");
-  for (const pragma of PRAGMA_STATEMENTS) db.exec(pragma);
-  for (const stmt of SCHEMA_STATEMENTS) db.exec(stmt);
-  return db;
-}
-async function loadDriver(filePath) {
-  try {
-    const mod = await import("./lib-JBI3XXH3.js");
-    const Ctor = mod.default ?? mod;
-    const db = new Ctor(filePath);
-    return db;
-  } catch (cause) {
-    const message = cause instanceof Error ? cause.message : String(cause);
-    throw new ConfigurationError(
-      `Failed to load SQLite driver. Install \`better-sqlite3\` or run on Node 22.5+ for built-in \`node:sqlite\`. Cause: ${message}`,
-      { code: "sqlite_driver_unavailable", cause }
-    );
-  }
-}
-function isCorruptionError(cause) {
-  if (!(cause instanceof Error)) return false;
-  const msg = cause.message.toLowerCase();
-  return msg.includes("malformed") || msg.includes("not a database") || msg.includes("encrypted") || msg.includes("disk image is malformed");
-}
-async function renameAside(filePath) {
-  const asidePath = `${filePath}.corrupt-${Date.now()}`;
-  await rename(filePath, asidePath).catch(() => void 0);
-  await rename(`${filePath}-wal`, `${asidePath}-wal`).catch(() => void 0);
-  await rename(`${filePath}-shm`, `${asidePath}-shm`).catch(() => void 0);
-  process.stderr.write(
-    `[theokit-sdk] memory index corrupt; renamed aside to ${asidePath} and rebuilt schema
-`
-  );
+  });
 }
 function defaultIndexPath(cwd) {
   return join(cwd, ".theokit", "memory", ".index", "memory.sqlite");
 }
 var init_index_db = __esm({
   "src/internal/memory/index-db.ts"() {
-    init_errors();
-    init_sqlite_wal();
+    init_sqlite_open();
     init_index_schema();
   }
 });
@@ -3077,6 +3155,70 @@ var init_agent_factory_registry = __esm({
   "src/internal/runtime/registry/agent-factory-registry.ts"() {
   }
 });
+var run_to_completion_exports = {};
+__export(run_to_completion_exports, {
+  classifyRound: () => classifyRound,
+  runToCompletionImpl: () => runToCompletionImpl
+});
+function isEmptyRound(result) {
+  return (result.result ?? "").trim() === "";
+}
+function classifyRound(result, round, maxRounds, emptyStreak) {
+  if (result.stoppedAtIterationLimit !== true) return "done";
+  if (isEmptyRound(result) && emptyStreak >= 1) return "no_progress";
+  if (round >= maxRounds) return "step_limit";
+  return "continue";
+}
+function addUsage(acc, u) {
+  if (u === void 0) return acc;
+  const inputTokens = (acc?.inputTokens ?? 0) + u.inputTokens;
+  const outputTokens = (acc?.outputTokens ?? 0) + u.outputTokens;
+  const sumOpt = (a, b2) => a === void 0 && b2 === void 0 ? void 0 : (a ?? 0) + (b2 ?? 0);
+  return {
+    inputTokens,
+    outputTokens,
+    totalTokens: inputTokens + outputTokens,
+    cacheReadTokens: sumOpt(acc?.cacheReadTokens, u.cacheReadTokens),
+    cacheWriteTokens: sumOpt(acc?.cacheWriteTokens, u.cacheWriteTokens),
+    reasoningTokens: sumOpt(acc?.reasoningTokens, u.reasoningTokens)
+  };
+}
+function buildResult(terminal, rounds, lastResult, usage) {
+  return { terminal, rounds, lastResult, ...usage !== void 0 ? { usage } : {} };
+}
+async function stepRound(agent, prompt, sendOptions, round, maxRounds, state4) {
+  const run = await agent.send(prompt, sendOptions);
+  const result = await run.wait();
+  const usage = addUsage(state4.usage, result.usage);
+  const decision = classifyRound(result, round, maxRounds, state4.emptyStreak);
+  if (decision !== "continue") return { terminal: buildResult(decision, round, result, usage) };
+  const emptyStreak = isEmptyRound(result) ? state4.emptyStreak + 1 : 0;
+  return { next: { usage, emptyStreak }, lastResult: result };
+}
+async function runToCompletionImpl(agent, message, options) {
+  const maxRounds = options?.maxRounds ?? DEFAULT_MAX_ROUNDS;
+  const continuationPrompt = options?.continuationPrompt ?? DEFAULT_CONTINUATION_PROMPT;
+  const { onTruncated, signal, sendOptions } = options ?? {};
+  let state4 = { usage: void 0, emptyStreak: 0 };
+  for (let round = 0; ; round += 1) {
+    const prompt = round === 0 ? message : continuationPrompt;
+    const outcome = await stepRound(agent, prompt, sendOptions, round, maxRounds, state4);
+    if ("terminal" in outcome) return outcome.terminal;
+    state4 = outcome.next;
+    await onTruncated?.({ round });
+    if (signal?.aborted === true) {
+      return buildResult("step_limit", round, outcome.lastResult, state4.usage);
+    }
+  }
+}
+var DEFAULT_MAX_ROUNDS;
+var DEFAULT_CONTINUATION_PROMPT;
+var init_run_to_completion = __esm({
+  "src/internal/runtime/lifecycle/run-to-completion.ts"() {
+    DEFAULT_MAX_ROUNDS = 5;
+    DEFAULT_CONTINUATION_PROMPT = "Continue from where you left off and finish the task. If it is already complete, give the final answer.";
+  }
+});
 var fork_agent_exports = {};
 __export(fork_agent_exports, {
   filterMemoryPlugins: () => filterMemoryPlugins,
@@ -3157,55 +3299,14 @@ var init_task = __esm({
     RESERVED_PREFIXES = ["wf-", "b-", "cron-"];
   }
 });
-function createSemaphore(permits) {
-  if (!Number.isInteger(permits) || permits < 1) {
-    throw new ConfigurationError(
-      `async-semaphore: permits must be a positive integer, got ${permits}`,
-      { code: "invalid_concurrency" }
-    );
-  }
-  let active = 0;
-  const queue = [];
-  function tryGrant() {
-    if (active < permits && queue.length > 0) {
-      const resolve3 = queue.shift();
-      if (resolve3 !== void 0) {
-        active += 1;
-        resolve3();
-      }
-    }
-  }
-  return {
-    inFlight: () => active,
-    pending: () => queue.length + active,
-    async acquire() {
-      await new Promise((resolve3) => {
-        queue.push(resolve3);
-        tryGrant();
-      });
-      let released = false;
-      return () => {
-        if (released) return;
-        released = true;
-        active -= 1;
-        tryGrant();
-      };
-    }
-  };
-}
-var init_async_semaphore = __esm({
-  "src/internal/runtime/concurrency/async-semaphore.ts"() {
-    init_errors();
-  }
-});
 var RingBuffer;
 var init_ring_buffer = __esm({
   "src/internal/task/ring-buffer.ts"() {
     RingBuffer = class {
-      constructor(cap) {
-        this.cap = cap;
-        if (!Number.isInteger(cap) || cap < 1) {
-          throw new Error(`RingBuffer capacity must be a positive integer, got ${cap}`);
+      constructor(cap2) {
+        this.cap = cap2;
+        if (!Number.isInteger(cap2) || cap2 < 1) {
+          throw new Error(`RingBuffer capacity must be a positive integer, got ${cap2}`);
         }
       }
       cap;
@@ -7060,8 +7161,7 @@ var FixtureRunBase = class {
     if (status === "error" && this.script.errorDetail !== void 0) {
       base.error = this.script.errorDetail;
     }
-    if (this.script.usage !== void 0) base.usage = this.script.usage;
-    if (this.script.cost !== void 0) base.cost = this.script.cost;
+    applyScriptMetrics(base, this.script);
     return this.extendRunResult(applyExtraRunFields(base, this.script));
   }
   /** Subclasses override to attach runtime-specific fields (e.g. cloud git info). */
@@ -7095,6 +7195,11 @@ function makeNotifier() {
   });
   return { promise, resolve: resolve3 };
 }
+function applyScriptMetrics(base, script) {
+  if (script.usage !== void 0) base.usage = script.usage;
+  if (script.cost !== void 0) base.cost = script.cost;
+  if (script.stoppedAtIterationLimit === true) base.stoppedAtIterationLimit = true;
+}
 function createCloudRun(options) {
   const { userText, id, startTime } = prepareRunContext(options.message);
   const supported = /* @__PURE__ */ new Set([
@@ -7593,6 +7698,18 @@ var CloudAgent = class {
       "fork"
     );
   }
+  /**
+   * The continuation driver re-sends against a stateful local session; the
+   * cloud runtime manages its own continuation policy server-side (M1 Phase 3).
+   *
+   * @public
+   */
+  runToCompletion() {
+    throw new UnsupportedRunOperationError(
+      "Agent.runToCompletion() is not supported on cloud agents. Cloud runtime manages continuation server-side. Use a local agent.",
+      "runToCompletion"
+    );
+  }
   /**
    * Personality presets require consistent server-side enforcement that
    * the cloud runtime (pre-release) does not yet provide. Reject explicitly
@@ -9064,6 +9181,8 @@ function parseSubagentMarkdown(raw, filename) {
   if (fields.model !== void 0) {
     definition.model = fields.model === "inherit" ? "inherit" : { id: fields.model };
   }
+  const tools = fields.tools?.split(/[\s,]+/).map((t) => t.trim()).filter((t) => t.length > 0);
+  if (tools !== void 0 && tools.length > 0) definition.tools = tools;
   return { name, definition };
 }
 function splitFrontmatter2(raw, filename) {
@@ -9210,20 +9329,21 @@ ${lines.join("\n")}
 </memory>`);
   }
 };
+function buildSkillsBlock(skills) {
+  if (skills.length === 0) return void 0;
+  const lines = skills.map(
+    (skill) => `  - ${escapeBlockBody(skill.name)}: ${escapeBlockBody(skill.description)}`
+  );
+  return `<skills>
+${lines.join("\n")}
+</skills>`;
+}
 var SkillsPromptProvider = class {
   id = "skills";
   priority = 20;
   contribute(ctx) {
     if (ctx.skillsAutoInject === false) return Promise.resolve(void 0);
-    if (ctx.skills.length === 0) return Promise.resolve(void 0);
-    const lines = ctx.skills.map((skill) => {
-      const name = escapeBlockBody(skill.name);
-      const description = escapeBlockBody(skill.description);
-      return `  - ${name}: ${description}`;
-    });
-    return Promise.resolve(`<skills>
-${lines.join("\n")}
-</skills>`);
+    return Promise.resolve(buildSkillsBlock(ctx.skills));
   }
 };
 var SystemPromptPipeline = class _SystemPromptPipeline {
@@ -10272,7 +10392,7 @@ async function loadPluginManifestFromJson(manifestPath, folderName) {
   const record = parsed;
   const name = typeof record.name === "string" ? record.name : folderName;
   const version = typeof record.version === "string" ? record.version : "0.0.0";
-  const capabilities = Array.isArray(record.capabilities) ? record.capabilities.filter((cap) => typeof cap === "string") : [];
+  const capabilities = Array.isArray(record.capabilities) ? record.capabilities.filter((cap2) => typeof cap2 === "string") : [];
   const source = manifestPath.slice(manifestPath.indexOf(".theokit/"));
   const metadata = { name, version, capabilities, source };
   if (typeof record.entry === "string") metadata.entry = record.entry;
@@ -10383,6 +10503,59 @@ function parseDependencies(raw) {
 function hasContent(value) {
   return value !== void 0 && value.trim().length > 0;
 }
+async function discoverSkills(dir, options) {
+  let entries;
+  try {
+    entries = await readWorkspaceDir(dir, "skills_read_error", "skills directory");
+  } catch {
+    return [];
+  }
+  const skills = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    let skillDir;
+    try {
+      skillDir = safePathJoin(dir, entry.name);
+      assertNoSymlinkEscape(skillDir, dir);
+    } catch {
+      continue;
+    }
+    const skillPath = join(skillDir, "SKILL.md");
+    let raw;
+    try {
+      raw = await readFile(skillPath, "utf8");
+    } catch {
+      continue;
+    }
+    const skill = tryParseSkill(raw, entry.name, skillPath, options);
+    if (skill !== void 0) skills.push(skill);
+  }
+  return skills;
+}
+function tryParseSkill(raw, fallbackName, source, options) {
+  try {
+    const frontmatter = parseSkillFrontmatter(raw, fallbackName);
+    const skill = {
+      name: frontmatter.name,
+      description: frontmatter.description,
+      source
+    };
+    if (frontmatter.category !== void 0) skill.category = frontmatter.category;
+    if (frontmatter.dependencies !== void 0) skill.dependencies = frontmatter.dependencies;
+    return skill;
+  } catch (cause) {
+    if (cause instanceof ConfigurationError) {
+      options?.onInvalidSkill?.({
+        name: fallbackName,
+        source,
+        code: cause.code ?? "unknown",
+        message: cause.message
+      });
+      return void 0;
+    }
+    throw cause;
+  }
+}
 var SkillsManager = class {
   constructor(cwd, _enabled, settingSourcesIncludeProject) {
     this.cwd = cwd;
@@ -10399,56 +10572,20 @@ var SkillsManager = class {
     await this.refresh();
   }
   async refresh() {
-    this.skills = [];
     const skillsRoot = join(this.cwd, ".theokit", "skills");
-    const entries = await readWorkspaceDir(skillsRoot, "skills_read_error", "skills directory");
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      let skillDir;
-      try {
-        skillDir = safePathJoin(skillsRoot, entry.name);
-        assertNoSymlinkEscape(skillDir, skillsRoot);
-      } catch {
-        continue;
-      }
-      const skillPath = join(skillDir, "SKILL.md");
-      let raw;
-      try {
-        raw = await readFile(skillPath, "utf8");
-      } catch {
-        continue;
+    this.skills = await discoverSkills(skillsRoot, {
+      onInvalidSkill: (info) => {
+        process.stderr.write(
+          `[theokit-sdk] skill ${info.name} skipped (${info.code}): ${info.message}
+`
+        );
       }
-      const metadata = tryParseSkill(raw, entry.name, skillPath);
-      if (metadata !== void 0) this.skills.push(metadata);
-    }
+    });
   }
   list() {
     return Promise.resolve(this.skills);
   }
 };
-function tryParseSkill(raw, fallbackName, source) {
-  try {
-    const frontmatter = parseSkillFrontmatter(raw, fallbackName);
-    const metadata = {
-      name: frontmatter.name,
-      description: frontmatter.description,
-      source
-    };
-    if (frontmatter.category !== void 0) metadata.category = frontmatter.category;
-    if (frontmatter.dependencies !== void 0) metadata.dependencies = frontmatter.dependencies;
-    return metadata;
-  } catch (cause) {
-    if (cause instanceof ConfigurationError) {
-      const code = cause.code ?? "unknown";
-      process.stderr.write(
-        `[theokit-sdk] skill ${fallbackName} skipped (${code}): ${cause.message}
-`
-      );
-      return void 0;
-    }
-    throw cause;
-  }
-}
 function registerLocalAgent(args) {
   registerAgent({
     agentId: args.agentId,
@@ -10582,6 +10719,7 @@ var LocalRun = class extends FixtureRunBase {
     }
   }
 };
+init_errors();
 var IterationBudget = class {
   #remaining;
   #total;
@@ -10840,6 +10978,7 @@ async function initLoopContext(inputs) {
     finalStatus: "finished",
     usage: new UsageAccumulator(),
     nudgeAttempts: 0,
+    stopFeedbackAttempts: 0,
     ...memoryProviderHandle !== void 0 ? { memoryProviderHandle } : {},
     ...memorySystemPromptAdditions !== void 0 ? { memorySystemPromptAdditions } : {}
   };
@@ -10980,8 +11119,9 @@ function registerLoopError(ctx, cause) {
   if (ctx.error !== void 0) return;
   const rawMessage = cause?.message;
   const message = typeof rawMessage === "string" ? rawMessage : cause instanceof Error ? cause.message : String(cause);
+  const metaCode = cause?.metadata?.code;
   const rawCode = cause?.code;
-  const code = typeof rawCode === "string" ? rawCode : void 0;
+  const code = typeof metaCode === "string" ? metaCode : typeof rawCode === "string" ? rawCode : void 0;
   ctx.error = code !== void 0 ? { message, code, cause } : { message, cause };
 }
 async function runCollectorLoop(generator, inputs, ctx) {
@@ -11017,6 +11157,25 @@ async function emitTextDeltaCallback(inputs, text) {
   );
 }
 init_async_local_storage();
+init_async_semaphore();
+var NEVER_ABORT = new AbortController().signal;
+async function mapWithConcurrency(items, concurrency, fn, options) {
+  const semaphore = createSemaphore(concurrency);
+  const signal = NEVER_ABORT;
+  return Promise.all(
+    items.map(async (item, index) => {
+      const release = await semaphore.acquire();
+      try {
+        if (signal.aborted) {
+          throw signal.reason instanceof Error ? signal.reason : new Error("mapWithConcurrency: aborted");
+        }
+        return await fn(item, index, signal);
+      } finally {
+        release();
+      }
+    })
+  );
+}
 var DECIMAL_RE = /^-?\d+(\.\d+)?$/;
 function repairToolCall(raw, registry3) {
   const repairs = [];
@@ -11184,38 +11343,12 @@ ${result.stderr}`.trim();
 }
 async function dispatchTools(inputs, tools, toolCalls, events) {
   const maxConcurrent = inputs.maxConcurrentTools ?? 4;
-  return boundedParallel(
-    maxConcurrent,
+  return mapWithConcurrency(
     toolCalls,
+    maxConcurrent,
     (call) => dispatchSingleCall(inputs, tools, call, events)
   );
 }
-async function boundedParallel(max, items, fn) {
-  let running = 0;
-  const queue = [];
-  async function acquire() {
-    if (running < max) {
-      running++;
-      return;
-    }
-    await new Promise((resolve3) => queue.push(resolve3));
-    running++;
-  }
-  function release() {
-    running--;
-    if (queue.length > 0) queue.shift()();
-  }
-  return Promise.all(
-    items.map(async (item) => {
-      await acquire();
-      try {
-        return await fn(item);
-      } finally {
-        release();
-      }
-    })
-  );
-}
 async function dispatchSingleCall(inputs, tools, call, events) {
   const { call: workingCall, repairs } = applyRepairAndExtractCall(tools, call);
   const callId = generateCallId();
@@ -11761,6 +11894,7 @@ function computeUsageCost(inputs, usage) {
   return computeCost({ provider, model, usage });
 }
 var MAX_NUDGE_ATTEMPTS = 2;
+var MAX_STOP_FEEDBACK_ATTEMPTS = 2;
 async function runAgentLoop(inputs) {
   const sendSpan = inputs.telemetry?.startSpan("agent.send", {
     agentId: inputs.agentId,
@@ -11775,6 +11909,7 @@ async function runAgentLoop(inputs) {
     const ctx = await initLoopContext(inputs);
     ctxRef = ctx;
     const budget = inputs.budget ?? new IterationBudget({ maxIterations: inputs.maxIterations ?? 8 });
+    let lastTurnDecision;
     while (budget.shouldContinue()) {
       if (inputs.budgetTracker !== void 0) {
         const decision2 = evaluateBudgetGate(inputs.budgetTracker);
@@ -11783,18 +11918,26 @@ async function runAgentLoop(inputs) {
           if (decision2.detail !== void 0) {
             ctx.error = { message: decision2.detail, code: decision2.reason ?? "budget" };
           }
+          if (decision2.reason === "iteration_limit") {
+            ctx.stoppedAtIterationLimit = true;
+          }
           break;
         }
       }
       const usingGrace = budget.remaining <= 0 && !budget.graceCallUsed;
       if (usingGrace) budget.useGraceCall();
       const decision = await runIteration(inputs, ctx);
+      lastTurnDecision = decision;
       if (decision === "done") break;
       if (decision === "error") {
         ctx.finalStatus = "error";
         break;
       }
       budget.consume();
+      inputs.budgetTracker?.nextIteration?.();
+    }
+    if (lastTurnDecision === "continue" && budget.shouldContinue() === false) {
+      ctx.stoppedAtIterationLimit = true;
     }
     if (budget.shouldContinue() === false && ctx.finalStatus === "finished" && ctx.finalText === "") {
       ctx.finalStatus = "error";
@@ -11825,7 +11968,8 @@ async function runAgentLoop(inputs) {
       conversation: ctx.conversation,
       ...usage !== void 0 ? { usage } : {},
       ...cost !== void 0 ? { cost } : {},
-      ...ctx.error !== void 0 ? { error: ctx.error } : {}
+      ...ctx.error !== void 0 ? { error: ctx.error } : {},
+      ...ctx.stoppedAtIterationLimit === true ? { stoppedAtIterationLimit: true } : {}
     };
   } finally {
     if (ctxRef !== void 0 && ctxRef.memoryProviderHandle !== void 0 && inputs.memoryProvider !== void 0) {
@@ -11882,8 +12026,8 @@ function handleToolErrorContinuation(inputs, ctx, toolResults) {
   const hasError = toolResults.some((part) => part.type === "tool_result" && part.isError === true);
   if (hasError) {
     ctx._consecutiveToolErrors = (ctx._consecutiveToolErrors ?? 0) + 1;
-    const cap = inputs.maxConsecutiveToolErrors ?? 3;
-    if (ctx._consecutiveToolErrors >= cap) return "error";
+    const cap2 = inputs.maxConsecutiveToolErrors ?? 3;
+    if (ctx._consecutiveToolErrors >= cap2) return "error";
     return "continue";
   }
   ctx._consecutiveToolErrors = 0;
@@ -11908,6 +12052,28 @@ function shouldNudgeAndContinue(ctx, llmOutput) {
   });
   return true;
 }
+async function reflectAfterStop(inputs, ctx) {
+  const result = await inputs.hooks.run({
+    event: "stop",
+    agentId: inputs.agentId,
+    runId: inputs.runId
+  });
+  if (result.blocked) return false;
+  if (ctx.stopFeedbackAttempts >= MAX_STOP_FEEDBACK_ATTEMPTS) return false;
+  const feedback = result.decisions.find(
+    (d2) => d2.decision === "feedback" && (d2.feedback ?? "").length > 0
+  )?.feedback;
+  if (feedback === void 0) return false;
+  ctx.stopFeedbackAttempts += 1;
+  ctx.messages.push({ role: "user", content: [{ type: "text", text: feedback }] });
+  return true;
+}
+async function finishOrReflect(inputs, ctx, llmOutput) {
+  if (shouldNudgeAndContinue(ctx, llmOutput)) return "continue";
+  if (await reflectAfterStop(inputs, ctx)) return "continue";
+  ctx.finalStatus = "finished";
+  return "done";
+}
 async function runIteration(inputs, ctx) {
   const llmOutput = await streamLlmTurn(inputs, ctx);
   accumulateUsage(ctx.usage, llmOutput);
@@ -11941,9 +12107,7 @@ async function continueOrTerminate(inputs, ctx, llmOutput) {
     await emitAssistantTextStep(inputs, ctx, llmOutput.text);
   }
   if (llmOutput.stopReason !== "tool_use" || llmOutput.toolCalls.length === 0) {
-    if (shouldNudgeAndContinue(ctx, llmOutput)) return "continue";
-    ctx.finalStatus = "finished";
-    return "done";
+    return finishOrReflect(inputs, ctx, llmOutput);
   }
   ctx.messages.push(buildAssistantTurn(llmOutput.text, llmOutput.toolCalls));
   const toolResults = await dispatchTools(inputs, ctx.tools, llmOutput.toolCalls, ctx.events);
@@ -14073,6 +14237,14 @@ function resolveMcpCwd(configCwd) {
   if (isAbsolute(configCwd)) return configCwd;
   return safePathJoin(process.cwd(), configCwd);
 }
+function registerPluginProviderProfiles(entries) {
+  let registered4 = 0;
+  for (const entry of entries) {
+    registerProvider(entry.profile);
+    registered4 += 1;
+  }
+  return registered4;
+}
 init_hooks_source();
 function applyPersonalityFilter(exposedTools, whitelist, opts) {
   if (whitelist === void 0) return exposedTools;
@@ -14146,12 +14318,34 @@ function createRealLocalRun(options) {
   registerRun(handle);
   return handle;
 }
-function buildLoopInputs(options, runId, userText) {
+var pluginProvidersAnnounced = false;
+function resolveRunProvider(options) {
   registerBuiltins();
+  const profiles = options.pluginManager?.aggregated.providerProfiles ?? [];
+  const registered4 = registerPluginProviderProfiles(profiles);
+  if (registered4 > 0 && !pluginProvidersAnnounced) {
+    pluginProvidersAnnounced = true;
+    const names = profiles.map((e) => e.profile.name).join(", ");
+    process.stderr.write(
+      `[theokit-sdk] registered ${registered4} plugin provider profile(s): ${names}
+`
+    );
+  }
   const parsedModel = parseModelId(options.model?.id);
   const inferredProvider = parsedModel.provider !== void 0 && getProviderProfile(parsedModel.provider) !== void 0 ? parsedModel.provider : void 0;
   const primary = options.agentOptions.providers?.routes?.[0]?.provider ?? inferredProvider ?? detectPrimaryProvider();
   const effectiveModelId = inferredProvider !== void 0 ? parsedModel.name : options.model?.id ?? "claude-sonnet-4-6";
+  return { primary, effectiveModelId };
+}
+function buildLoopInputs(options, runId, userText) {
+  const maxIterations = options.sendOptions.maxIterations;
+  if (maxIterations !== void 0 && (!Number.isInteger(maxIterations) || maxIterations < 1)) {
+    throw new ConfigurationError(
+      `SendOptions.maxIterations must be a positive integer, got ${maxIterations}`,
+      { code: "invalid_max_iterations" }
+    );
+  }
+  const { primary, effectiveModelId } = resolveRunProvider(options);
   const fallback = options.agentOptions.providers?.fallback;
   const apiKeys = options.agentOptions.providers?.apiKeys;
   const credentialPoolStrategy = options.agentOptions.providers?.credentialPoolStrategy;
@@ -14189,6 +14383,9 @@ function buildLoopInputs(options, runId, userText) {
     // D318 — forward SendOptions.signal to the agent loop so streamLlmTurn
     // can attach it to the LLM `fetch({ signal })` call.
     ...options.sendOptions.signal !== void 0 ? { signal: options.sendOptions.signal } : {},
+    // M1-2: per-send iteration ceiling (validated above). The loop reads
+    // inputs.maxIterations (default 8 when unset).
+    ...maxIterations !== void 0 ? { maxIterations } : {},
     // D315-D317 — tool lifecycle hooks (cost tracking + audit + retry/alert)
     ...options.agentOptions.onToolStart !== void 0 ? { onToolStart: options.agentOptions.onToolStart } : {},
     ...options.agentOptions.onToolEnd !== void 0 ? { onToolEnd: options.agentOptions.onToolEnd } : {},
@@ -14320,6 +14517,7 @@ var RealLocalRun = class extends FixtureRunBase {
     if (output.result.length > 0) this.script.result = output.result;
     if (output.usage !== void 0) this.script.usage = output.usage;
     if (output.cost !== void 0) this.script.cost = output.cost;
+    if (output.stoppedAtIterationLimit === true) this.script.stoppedAtIterationLimit = true;
     if (output.error !== void 0 && this.script.errorDetail === void 0) {
       this.script.errorDetail = {
         message: output.error.message,
@@ -14731,7 +14929,7 @@ async function embedTexts(input) {
       pending
     });
   }
-  await runBatches(input, pending, results);
+  await embedInBoundedBatches(input, pending, results);
   return results.map((v2) => v2 ?? new Array(dimension).fill(0));
 }
 function classifyEntry(args) {
@@ -14750,45 +14948,34 @@ function classifyEntry(args) {
   args.pending.push({ index: args.index, text: args.text, key: key2 });
 }
 var MAX_CONCURRENT_BATCHES = 3;
-async function runBatches(input, pending, results) {
+async function embedInBoundedBatches(input, pending, results) {
   const batches = [];
   for (let offset = 0; offset < pending.length; offset += MAX_BATCH) {
     batches.push(pending.slice(offset, offset + MAX_BATCH));
   }
-  let running = 0;
-  const queue = [];
-  await Promise.all(batches.map((batch) => processBatch(input, batch, results, acquire, release)));
-  async function acquire() {
-    if (running >= MAX_CONCURRENT_BATCHES) await new Promise((r) => queue.push(r));
-    running++;
-  }
-  function release() {
-    running--;
-    if (queue.length > 0) queue.shift()();
-  }
+  await mapWithConcurrency(
+    batches,
+    MAX_CONCURRENT_BATCHES,
+    (batch) => processBatch(input, batch, results)
+  );
 }
-async function processBatch(input, batch, results, acquire, release) {
-  await acquire();
-  try {
-    const vectors = await embedBatch({
-      apiKey: input.apiKey,
-      baseUrl: input.baseUrl,
-      embeddingsPath: input.embeddingsPath,
-      model: input.model,
-      inputs: batch.map((b2) => b2.text),
-      fetchImpl: input.fetchImpl,
-      stats: input.stats,
-      providerId: input.providerId
-    });
-    for (let j = 0; j < batch.length; j++) {
-      const slot = batch[j];
-      const vector = vectors[j];
-      if (slot === void 0 || vector === void 0) continue;
-      results[slot.index] = vector;
-      input.cache.set(slot.key, vector);
-    }
-  } finally {
-    release();
+async function processBatch(input, batch, results) {
+  const vectors = await embedBatch({
+    apiKey: input.apiKey,
+    baseUrl: input.baseUrl,
+    embeddingsPath: input.embeddingsPath,
+    model: input.model,
+    inputs: batch.map((b2) => b2.text),
+    fetchImpl: input.fetchImpl,
+    stats: input.stats,
+    providerId: input.providerId
+  });
+  for (let j = 0; j < batch.length; j++) {
+    const slot = batch[j];
+    const vector = vectors[j];
+    if (slot === void 0 || vector === void 0) continue;
+    results[slot.index] = vector;
+    input.cache.set(slot.key, vector);
   }
 }
 async function embedBatch(opts) {
@@ -15228,7 +15415,7 @@ var MEMORY_GET_SCHEMA = {
 };
 var DEFAULT_MAX_TOTAL_CHARS = 16384;
 function createMemorySearchTool(opts) {
-  const cap = opts.maxTotalChars ?? DEFAULT_MAX_TOTAL_CHARS;
+  const cap2 = opts.maxTotalChars ?? DEFAULT_MAX_TOTAL_CHARS;
   return {
     name: "memory_search",
     description: SEARCH_DESCRIPTION,
@@ -15245,7 +15432,7 @@ function createMemorySearchTool(opts) {
         ...sources !== void 0 ? { sources } : {}
       };
       const hits = await opts.index.search(query, searchOptions);
-      return JSON.stringify(capByTotalChars(hits, cap));
+      return JSON.stringify(capByTotalChars(hits, cap2));
     }
   };
 }
@@ -15793,6 +15980,13 @@ function localAgentRunUntil(agent, goal, options) {
   }
   return wrap();
 }
+function localAgentRunToCompletion(agent, message, options) {
+  async function run() {
+    const { runToCompletionImpl: runToCompletionImpl2 } = await Promise.resolve().then(() => (init_run_to_completion(), run_to_completion_exports));
+    return runToCompletionImpl2({ send: (m2, o) => agent.send(m2, o) }, message, options);
+  }
+  return run();
+}
 async function localAgentFork(parent, options) {
   const { forkAgentImpl: forkAgentImpl2 } = await Promise.resolve().then(() => (init_fork_agent(), fork_agent_exports));
   const { getAgentFacade: getAgentFacade2 } = await Promise.resolve().then(() => (init_agent_factory_registry(), agent_factory_registry_exports));
@@ -15850,8 +16044,8 @@ async function applyPreUserSendHook(args) {
     ...args.options.memoryContext !== void 0 ? { memoryContext: args.options.memoryContext } : {},
     ...args.sendOptions.signal !== void 0 ? { signal: args.sendOptions.signal } : {}
   };
-  const cap = args.options.maxRecallContextBytes ?? DEFAULT_MAX_RECALL_BYTES;
-  const recalled = await args.pluginManager.runPreUserSendHooks(ctx, cap);
+  const cap2 = args.options.maxRecallContextBytes ?? DEFAULT_MAX_RECALL_BYTES;
+  const recalled = await args.pluginManager.runPreUserSendHooks(ctx, cap2);
   if (recalled === void 0 || recalled.length === 0) return args.original;
   const wrapped = `<memory-context>
 ${recalled}
@@ -16321,6 +16515,10 @@ var LocalAgent = class {
   fork(options) {
     return localAgentFork({ agentId: this.agentId, options: this.options, personalitySlugSnapshot: this.personalityStore.active(this.agentId) }, options);
   }
+  // biome-ignore format: G8 budget — see runUntil comment above.
+  runToCompletion(message, options) {
+    return localAgentRunToCompletion(this, message, options);
+  }
 };
 function resolveCwd(cwd) {
   return (Array.isArray(cwd) ? cwd[0] : cwd) ?? process.cwd();
@@ -17652,6 +17850,14 @@ async function updateJobStatus(jobId, enabled) {
   }
   return updated;
 }
+function defineProvider(profile, opts) {
+  return {
+    name: profile.name,
+    version: opts?.version ?? "1.0.0",
+    kind: "model-provider",
+    profile
+  };
+}
 init_to_json_schema();
 function defineTool(spec) {
   const inputSchema = toJsonSchema(spec.inputSchema, {
@@ -17775,6 +17981,75 @@ function createCounterBudgetTracker(options = {}) {
     }
   };
 }
+var CHARS_PER_TOKEN = 4;
+var DEFAULT_RESERVE_TOKENS = 8e3;
+function finiteOr(value, fallback) {
+  return Number.isFinite(value) ? value : fallback;
+}
+function charBudget(options) {
+  const window = finiteOr(options.contextWindowTokens, 0);
+  const reserve = finiteOr(options.reserveTokens ?? DEFAULT_RESERVE_TOKENS, DEFAULT_RESERVE_TOKENS);
+  return Math.max(0, window - reserve) * CHARS_PER_TOKEN;
+}
+function assistantText2(event) {
+  return event.message.content.filter((block) => block.type === "text").map((block) => block.text).join("");
+}
+function stringifyPayload(value) {
+  if (value === void 0) return "";
+  return typeof value === "string" ? value : JSON.stringify(value) ?? "";
+}
+function cap(content, perItemCap) {
+  return truncateWithMarker(content, Math.max(0, perItemCap)).finalContent;
+}
+function mapEvent(event, perItemCap) {
+  if (event.type === "assistant") {
+    const text = assistantText2(event);
+    return text.length > 0 ? { message: { role: "assistant", content: cap(text, perItemCap) } } : null;
+  }
+  if (event.type === "tool_call") {
+    if (event.status === "running") {
+      const content2 = cap(`[tool_call ${event.name}] ${stringifyPayload(event.args)}`, perItemCap);
+      return { message: { role: "tool_call", content: content2 }, pairId: event.call_id };
+    }
+    const content = cap(
+      `[tool_result ${event.name}] ${stringifyPayload(event.result)}`,
+      perItemCap
+    );
+    return { message: { role: "tool_result", content }, pairId: event.call_id };
+  }
+  return null;
+}
+function evictionIndices(turns) {
+  const head = turns[0];
+  if (head?.pairId === void 0) return [0];
+  const indices = [];
+  for (let i = 0; i < turns.length; i += 1) {
+    if (turns[i]?.pairId === head.pairId) indices.push(i);
+  }
+  return indices;
+}
+function totalChars(turns) {
+  return turns.reduce((n2, t) => n2 + t.message.content.length, 0);
+}
+function trimToBudget(turns, budgetChars) {
+  const kept = [...turns];
+  while (kept.length > 1 && totalChars(kept) > budgetChars) {
+    const evict = evictionIndices(kept);
+    if (kept.length - evict.length < 1) break;
+    for (const idx of evict.sort((a, b2) => b2 - a)) kept.splice(idx, 1);
+  }
+  return kept;
+}
+function buildReplayHistory(base, events, options) {
+  const budgetChars = charBudget(options);
+  const perItemCap = Math.max(0, options.perItemCap ?? Math.floor(budgetChars / 2));
+  const turns = base.map((message) => ({ message }));
+  for (const event of events) {
+    const turn = mapEvent(event, perItemCap);
+    if (turn !== null) turns.push(turn);
+  }
+  return trimToBudget(turns, budgetChars).map((t) => t.message);
+}
 var NOOP_ADAPTER_ID = "noop";
 var NOOP_CAPABILITIES = {
   history: false,
@@ -18336,24 +18611,44 @@ async function migrateSqliteToLance2(options) {
   return migrateSqliteToLance(options);
 }
 var PermissionEngine = class {
-  constructor(rules) {
+  constructor(rules, options = {}) {
     this.rules = rules;
+    this.defaultAction = options.defaultAction ?? "allow";
   }
   rules;
+  defaultAction;
   /**
-   * Evaluate a tool name against the rules. First match wins; default "allow".
+   * Evaluate a tool name against the rules. First match wins; falls back to the
+   * configured `defaultAction` (default `"allow"`) when no rule matches.
    */
   evaluate(toolName) {
     for (const rule of this.rules) {
-      if (typeof rule.tool === "string") {
-        if (rule.tool === toolName) return rule.action;
-      } else {
-        if (rule.tool.test(toolName)) return rule.action;
-      }
+      const matches = typeof rule.tool === "string" ? rule.tool === toolName : rule.tool.test(toolName);
+      if (matches) return rule.action;
     }
-    return "allow";
+    return this.defaultAction;
   }
 };
+function createPermissionPlugin(engine, opts = {}) {
+  return definePlugin({
+    name: opts.name ?? "permission-engine",
+    version: "1.0.0",
+    kind: "general",
+    register(ctx) {
+      ctx.on("pre_tool_call", (rawCtx) => {
+        const { name } = rawCtx;
+        const action = engine.evaluate(name);
+        if (action === "deny") {
+          return { block: true, message: `denied by permission engine: ${name}` };
+        }
+        if (action === "ask") {
+          return opts.onAsk ? opts.onAsk(name) : { block: true, message: `requires approval: ${name}` };
+        }
+        return void 0;
+      });
+    }
+  });
+}
 init_security();
 var Security = class {
   constructor() {
@@ -19134,17 +19429,21 @@ export {
   UnsupportedRunOperationError,
   UnsupportedTaskOperationError,
   UsageAccumulator,
+  buildReplayHistory,
   chargeAndCheckThresholds,
   computeCost,
   createAgentFactory,
   createCounterBudgetTracker,
   createNoopMemoryProvider,
+  createPermissionPlugin,
   createSquad,
   definePlugin,
+  defineProvider,
   defineTool,
   extractRawId,
   getPricingEntry,
   inferApiMode,
+  isTransientError,
   migrateSqliteToLance2 as migrateSqliteToLance,
   mkMemoryId,
   normalizeUsage,
@@ -19152,4 +19451,4 @@ export {
   toShareGptTrajectory,
   withCwdMutex
 };
-//# sourceMappingURL=dist-6GPD6WCU.js.map
+//# sourceMappingURL=dist-IW7G5Y23.js.map