@popcraft/kit 0.26.0 → 0.27.0

package/dist/chunks/runner-CLMKK5RT.js

@@ -0,0 +1,1229 @@
+import { createRequire as __popcraftRequire } from 'node:module';
+import { fileURLToPath as __popcraftPath } from 'node:url';
+import { dirname as __popcraftDirname } from 'node:path';
+const require = __popcraftRequire(import.meta.url);
+const __filename = __popcraftPath(import.meta.url);
+const __dirname = __popcraftDirname(__filename);
+import {
+  activeMessages,
+  agentModel,
+  allSkills,
+  appendMessage,
+  findSkill,
+  mentionContext,
+  newId,
+  rememberCheckpoint,
+  setParts,
+  setTodos,
+  skillIndexLine,
+  updateActiveThread,
+  updateMessage,
+  useAgentStore
+} from "./chunk-TM4LPOUZ.js";
+import {
+  ALL_TOOLS,
+  SUBAGENT_FRAMING,
+  allProfiles,
+  findProfile,
+  profileIndexLine
+} from "./chunk-4FL63S7V.js";
+import {
+  registerBuiltinTools
+} from "./chunk-22GTRC7O.js";
+import {
+  registerDangerousCommands
+} from "./chunk-JFZ6TYLB.js";
+import "./chunk-LQO3XEPZ.js";
+import "./chunk-474GISCF.js";
+import "./chunk-QX7BYX2M.js";
+import "./chunk-3OKZ57OD.js";
+import "./chunk-FENVY7S5.js";
+import "./chunk-U57RZGPM.js";
+import {
+  editBlockReason,
+  editorToolContext
+} from "./chunk-IEVDSTOY.js";
+import "./chunk-5JFDKTA6.js";
+import "./chunk-4UQLA7H3.js";
+import "./chunk-2GKJJQ73.js";
+import {
+  buildDesignContext,
+  joinWithin
+} from "./chunk-KVQ7R7FV.js";
+import "./chunk-3CLJHQC5.js";
+import "./chunk-HXDZI7ZZ.js";
+import {
+  allTools,
+  getTool,
+  runTool,
+  toolSpecs
+} from "./chunk-JD3YSMGH.js";
+import {
+  external_exports
+} from "./chunk-EZVFNLBJ.js";
+import "./chunk-RFPT4JQQ.js";
+import "./chunk-DNLHYUDE.js";
+import "./chunk-WPV57UKC.js";
+import "./chunk-ASQLSWJW.js";
+import "./chunk-BD2I4GBL.js";
+import "./chunk-YZ2OHMU7.js";
+import "./chunk-R2HH6LHS.js";
+import "./chunk-H6WKO5QW.js";
+import "./chunk-Q3LHD6Z5.js";
+import "./chunk-DLQRSLRX.js";
+import "./chunk-54IJHQTM.js";
+import "./chunk-PELUYQR3.js";
+import "./chunk-I3H35HAN.js";
+import {
+  HYPERY_TEAM_HEADER
+} from "./chunk-B725OBTW.js";
+import {
+  aiAvailability,
+  effectiveChatModel,
+  useAiStore
+} from "./chunk-3ZOB33EA.js";
+import {
+  provideAgentCapability
+} from "./chunk-C3OI7EOK.js";
+import {
+  defineCommand
+} from "./chunk-XPLI2SES.js";
+import "./chunk-VLB4KIHU.js";
+import "./chunk-SPBIZ4KY.js";
+import "./chunk-UBCYP6QI.js";
+import "./chunk-J2SFBGA7.js";
+import "./chunk-F6NIUSR5.js";
+import "./chunk-L4VNBPA2.js";
+import "./chunk-F6KBJTPS.js";
+import "./chunk-LDUVMQY7.js";
+import "./chunk-F672DUYT.js";
+import "./chunk-ODM43UFC.js";
+import "./chunk-FU7HUS2Q.js";
+import "./chunk-KCVX77FZ.js";
+import "./chunk-N4MSAAPR.js";
+import "./chunk-YVUYNEKE.js";
+import {
+  useEditorStore
+} from "./chunk-VB2QT3P7.js";
+import "./chunk-LU6OMVWV.js";
+import "./chunk-DPP3C3RR.js";
+import "./chunk-VEHJYALZ.js";
+import "./chunk-OIQSOCOU.js";
+import "./chunk-BZAKET67.js";
+import "./chunk-XVR2UHX3.js";
+import "./chunk-Y34IK6FH.js";
+import "./chunk-N45J7SVZ.js";
+import "./chunk-BN5QADN2.js";
+import "./chunk-YJB7BGFC.js";
+import "./chunk-CDTD3QPR.js";
+import "./chunk-VSCIKRIG.js";
+import "./chunk-HDAR7DUN.js";
+import "./chunk-52RHMMNG.js";
+import "./chunk-EGMCBOHC.js";
+import {
+  activeHyperyTeamId
+} from "./chunk-6TU5EOB2.js";
+import "./chunk-R3RPQEL2.js";
+import "./chunk-RVU4WKRT.js";
+import "./chunk-FK2VTANM.js";
+import "./chunk-4VEVFATD.js";
+import "./chunk-BJQMKXZJ.js";
+import "./chunk-F4FBI2LN.js";
+import {
+  registerCommand
+} from "./chunk-L3BAPZSJ.js";
+import {
+  ToolError
+} from "./chunk-4YDNCKSQ.js";
+import "./chunk-N7ZA4FJL.js";
+import "./chunk-KRHFQFZQ.js";
+import "./chunk-ILG7UWXL.js";
+import "./chunk-UQ7JTCPB.js";
+import {
+  HYPERY_GATEWAY_URL,
+  accessToken
+} from "./chunk-ZTNA7M3C.js";
+import "./chunk-FEJYW55H.js";
+import "./chunk-SUMRUI7X.js";
+import "./chunk-UE6EMDAD.js";
+import "./chunk-PV5XGV4R.js";
+import "./chunk-H3ITRMRL.js";
+import "./chunk-WGWAUMXY.js";
+import "./chunk-6732B54W.js";
+import "./chunk-KMTP6JI7.js";
+import "./chunk-VKMQPITY.js";
+import "./chunk-ZEZB3YTY.js";
+import "./chunk-6WJFEMOH.js";
+import "./chunk-XAGVE2C6.js";
+import "./chunk-B4V4FPRS.js";
+import "./chunk-KCECJPVX.js";
+import "./chunk-HMPI4D5J.js";
+import "./chunk-C6TIZNKI.js";
+import "./chunk-WH4YKN3O.js";
+import "./chunk-J2DAGUJZ.js";
+import "./chunk-7WFWNN3B.js";
+import "./chunk-TH56ELBN.js";
+import "./chunk-S6WJ2KY5.js";
+import "./chunk-JF5USU5E.js";
+import "./chunk-P2LIBAGF.js";
+import "./chunk-Q7LANE4G.js";
+import "./chunk-7YOOT7S2.js";
+import "./chunk-MELC4CJB.js";
+import "./chunk-CUV2OTUF.js";
+import "./chunk-ZC635HJD.js";
+import "./chunk-MDU2XGW5.js";
+import "./chunk-DEZFUOPJ.js";
+import "./chunk-VG6DGRSQ.js";
+import "./chunk-D27VWWNN.js";
+import "./chunk-X4J663TQ.js";
+import "./chunk-X2PCP2GO.js";
+import "./chunk-KWGZ2B3G.js";
+import "./chunk-55XINATM.js";
+import "./chunk-AVWA3JAF.js";
+import "./chunk-UMHPXVRM.js";
+import "./chunk-KD3DG7OQ.js";
+import "./chunk-LUMECRFW.js";
+import "./chunk-ZPIQLTT7.js";
+import "./chunk-K2L3GX3R.js";
+import "./chunk-NGD2672T.js";
+import "./chunk-73G63N4F.js";
+import "./chunk-USNPFHKI.js";
+import "./chunk-U4LTVSLE.js";
+import "./chunk-ZXT7BHFK.js";
+import "./chunk-QFFXZQH5.js";
+import "./chunk-VFSYVEQF.js";
+import "./chunk-WBFFALRV.js";
+import "./chunk-GDUMY3VG.js";
+import "./chunk-W5NE37NW.js";
+import "./chunk-B44DSGZP.js";
+import "./chunk-VIDOT3BT.js";
+import "./chunk-XV5ONKNC.js";
+import "./chunk-Q5FICCEE.js";
+import "./chunk-3KX7WU34.js";
+import "./chunk-5C7BZONG.js";
+import "./chunk-BDU2OUVJ.js";
+import "./chunk-OGA5VCNY.js";
+import "./chunk-HHQYOV6U.js";
+import "./chunk-DECP3A2X.js";
+import "./chunk-SZSJX54N.js";
+import "./chunk-4PE7EX3N.js";
+import "./chunk-NIHPNDDJ.js";
+import "./chunk-OYXVKB4X.js";
+import "./chunk-GD45G3CY.js";
+import {
+  AI_LIMITS,
+  init_limits,
+  str
+} from "./chunk-TZHWIVE5.js";
+import "./chunk-MFNTHBR5.js";
+import "./chunk-AYZ32MGJ.js";
+import "./chunk-CAGDE6PT.js";
+import "./chunk-POXV7LS3.js";
+import "./chunk-6YICR6OK.js";
+import "./chunk-MF4NUZBE.js";
+import "./chunk-D3K35HSL.js";
+import "./chunk-7ECF2YL5.js";
+import "./chunk-PSVLITJE.js";
+import "./chunk-CQPFKV2N.js";
+import "./chunk-CVWCFBOJ.js";
+import "./chunk-E6EMPOWS.js";
+import "./chunk-73FVHI5B.js";
+import {
+  init_define_POPCRAFT_COMPONENT_IDS
+} from "./chunk-6VMOKHMF.js";
+import "./chunk-LJSVREWM.js";
+
+// lib/agent/runner.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+
+// lib/agent/gateway.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+
+// lib/agent/stream-parse.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var StreamError = class extends Error {
+  constructor(message, code = "ai_upstream", status = 502) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.name = "StreamError";
+  }
+};
+function streamErrorMessage(payload, fallback = "The AI request failed.") {
+  const err = payload?.error;
+  if (typeof err === "string" && err.trim()) return err;
+  const message = err?.message ?? payload?.message;
+  return typeof message === "string" && message.trim() ? message : fallback;
+}
+function errorCode(payload) {
+  const code = payload?.error?.code ?? payload?.code;
+  return typeof code === "string" ? code : void 0;
+}
+function createStreamAccumulator() {
+  let buffer = "";
+  let text = "";
+  let reasoning = "";
+  let sawDone = false;
+  const calls = [];
+  const handleChunk = (chunk, out) => {
+    if (chunk.error) throw new StreamError(streamErrorMessage(chunk), errorCode(chunk));
+    const delta = chunk.choices?.[0]?.delta;
+    if (!delta) return;
+    if (typeof delta.content === "string" && delta.content) {
+      text += delta.content;
+      out.push({ textDelta: delta.content });
+    }
+    const reason = typeof delta.reasoning === "string" ? delta.reasoning : typeof delta.reasoning_content === "string" ? delta.reasoning_content : "";
+    if (reason) {
+      reasoning += reason;
+      out.push({ reasoningDelta: reason });
+    }
+    for (const tc of delta.tool_calls ?? []) {
+      const i = typeof tc.index === "number" ? tc.index : Math.max(0, calls.length - 1);
+      const call = calls[i] ??= { name: "", arguments: "" };
+      if (tc.id) call.id = tc.id;
+      if (tc.function?.name) call.name += tc.function.name;
+      if (tc.function?.arguments) {
+        call.arguments += tc.function.arguments;
+        out.push({ toolProgress: { index: i, name: call.name, bytes: call.arguments.length, arguments: call.arguments } });
+      }
+    }
+  };
+  return {
+    /** Feed stream text; returns the events in it. Throws StreamError on an `{ error }` frame. */
+    push(part) {
+      buffer += part;
+      const out = [];
+      let nl;
+      while ((nl = buffer.indexOf("\n")) >= 0) {
+        const line = buffer.slice(0, nl).trim();
+        buffer = buffer.slice(nl + 1);
+        if (!line.startsWith("data:")) continue;
+        const data = line.slice(5).trim();
+        if (!data) continue;
+        if (data === "[DONE]") {
+          sawDone = true;
+          out.push({ done: true });
+          continue;
+        }
+        let chunk;
+        try {
+          chunk = JSON.parse(data);
+        } catch {
+          continue;
+        }
+        handleChunk(chunk, out);
+      }
+      return out;
+    },
+    /** The assistant message so far: text, reasoning and every complete tool call. */
+    result() {
+      return {
+        text,
+        reasoning,
+        // Nameless entries are fragments the provider never finished; ids are synthesized like dune does.
+        toolCalls: calls.filter((c) => c && c.name).map((c, i) => ({ id: c.id ?? `call_${i}`, name: c.name, arguments: c.arguments })),
+        sawDone
+      };
+    }
+  };
+}
+
+// lib/agent/gateway.ts
+var IDLE_TIMEOUT_MS = 18e4;
+async function authHeaders() {
+  const token = await accessToken();
+  if (!token) throw new StreamError("Sign in to Hypery to use the agent.", "unauthenticated", 401);
+  const team = activeHyperyTeamId();
+  return {
+    Authorization: `Bearer ${token}`,
+    "Content-Type": "application/json",
+    Accept: "text/event-stream",
+    ...team ? { [HYPERY_TEAM_HEADER]: team } : {}
+  };
+}
+async function streamChat(opts, handlers = {}, signal) {
+  const res = await fetch(`${HYPERY_GATEWAY_URL}/api/v1/chat/completions`, {
+    method: "POST",
+    headers: await authHeaders(),
+    signal,
+    body: JSON.stringify({
+      model: opts.model,
+      messages: opts.messages,
+      stream: true,
+      max_tokens: opts.maxTokens ?? (opts.tools?.length ? 16384 : 4096),
+      ...opts.temperature !== void 0 ? { temperature: opts.temperature } : {},
+      ...opts.tools?.length ? { tools: opts.tools, tool_choice: opts.toolChoice ?? "auto" } : {}
+    })
+  }).catch((err) => {
+    if (err.name === "AbortError") throw err;
+    throw new StreamError("Could not reach Hypery. Check your connection.", "network", 0);
+  });
+  if (!res.ok || !res.body) {
+    const body = await res.text().catch(() => "");
+    let payload = body;
+    try {
+      payload = JSON.parse(body);
+    } catch {
+    }
+    throw new StreamError(streamErrorMessage(payload, `The AI request failed (${res.status}).`), errorCodeFor(res.status, payload), res.status);
+  }
+  const acc = createStreamAccumulator();
+  const reader = res.body.pipeThrough(new TextDecoderStream()).getReader();
+  let idle;
+  const armWatchdog = (reject) => {
+    clearTimeout(idle);
+    idle = setTimeout(() => reject(new StreamError("The model stopped responding.", "ai_timeout", 504)), IDLE_TIMEOUT_MS);
+  };
+  try {
+    await new Promise((resolve, reject) => {
+      armWatchdog(reject);
+      const pump = async () => {
+        const { value, done } = await reader.read();
+        if (done) return resolve();
+        armWatchdog(reject);
+        for (const event of acc.push(value)) emit(event, handlers);
+        return pump();
+      };
+      pump().catch(reject);
+    });
+  } finally {
+    clearTimeout(idle);
+    reader.cancel().catch(() => {
+    });
+  }
+  const result = acc.result();
+  if (!result.sawDone && !result.text && !result.toolCalls.length) {
+    throw new StreamError("The response was cut off before it started. Try again.", "ai_upstream", 502);
+  }
+  return { text: result.text, reasoning: result.reasoning, toolCalls: result.toolCalls };
+}
+function emit(event, handlers) {
+  if (event.textDelta) handlers.onTextDelta?.(event.textDelta);
+  if (event.reasoningDelta) handlers.onReasoningDelta?.(event.reasoningDelta);
+  if (event.toolProgress) handlers.onToolProgress?.(event.toolProgress);
+}
+function errorCodeFor(status, payload) {
+  const code = payload?.error?.code;
+  if (typeof code === "string") return code;
+  if (status === 401) return "ai_reauth";
+  if (status === 402) return "ai_credits";
+  if (status === 403) return "ai_scope";
+  if (status === 429) return "ai_rate_limited";
+  return "ai_upstream";
+}
+
+// lib/agent/loop.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var DEFAULT_MAX_ROUNDS = 12;
+var DEFAULT_MAX_PARALLEL = 4;
+function batchCalls(calls, isParallel, max) {
+  const batches = [];
+  for (const call of calls) {
+    const last = batches[batches.length - 1];
+    const parallel = isParallel(call.name);
+    if (parallel && last && last.length < max && isParallel(last[0].name)) last.push(call);
+    else batches.push([call]);
+  }
+  return batches;
+}
+function truncateResult(text, max) {
+  return text.length <= max ? text : `${text.slice(0, max)}
+\u2026[truncated ${text.length - max} characters]`;
+}
+var KEEP_IMAGE_TURNS = 2;
+var RENDER_TURN_PREFIX = "Result of ";
+function pruneOldImages(messages, keep = KEEP_IMAGE_TURNS) {
+  let seen = 0;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const m = messages[i];
+    if (m.role !== "user" || !Array.isArray(m.content) || !m.content.some((p) => p.type === "image_url")) continue;
+    const lead = m.content[0];
+    if (lead?.type !== "text" || !lead.text?.startsWith(RENDER_TURN_PREFIX)) continue;
+    if (++seen <= keep) continue;
+    const images = m.content.filter((p) => p.type === "image_url").length;
+    const text = m.content.flatMap((p) => p.type === "text" ? [p.text] : []).join(" ");
+    messages[i] = { ...m, content: `${text} [${images === 1 ? "image" : `${images} images`} omitted: superseded by a later render \u2014 render again if you need to look.]`.trim() };
+  }
+}
+async function runAgentLoop(opts) {
+  const maxRounds = opts.maxRounds ?? DEFAULT_MAX_ROUNDS;
+  const maxResultChars = opts.maxResultChars ?? 8e3;
+  const specs = opts.tools.map((t) => t.spec);
+  const messages = [...opts.messages];
+  let text = "";
+  let rounds = 0;
+  for (; rounds < maxRounds; rounds++) {
+    if (opts.stopped?.()) return { messages, text, rounds, exhausted: false, stopped: true };
+    for (const note of opts.drainNotifications?.() ?? []) messages.push({ role: "user", content: note });
+    pruneOldImages(messages);
+    opts.hooks?.onAssistantStart?.(rounds);
+    const turn = await opts.callModel(messages, specs, {
+      onTextDelta: opts.hooks?.onTextDelta,
+      onReasoningDelta: opts.hooks?.onReasoningDelta,
+      onToolProgress: opts.hooks?.onToolProgress
+    });
+    text = turn.text;
+    const assistant = {
+      role: "assistant",
+      content: turn.text,
+      ...turn.toolCalls.length ? { tool_calls: turn.toolCalls.map((c) => ({ id: c.id, type: "function", function: { name: c.name, arguments: c.arguments } })) } : {}
+    };
+    messages.push(assistant);
+    if (!turn.toolCalls.length) {
+      opts.hooks?.onRoundEnd?.(rounds);
+      const late = opts.drainNotifications?.() ?? [];
+      if (!late.length) return { messages, text, rounds: rounds + 1, exhausted: false, stopped: false };
+      for (const note of late) messages.push({ role: "user", content: note });
+      continue;
+    }
+    const parallelNames = new Set(opts.tools.filter((t) => t.readOnly).map((t) => t.spec.function.name));
+    const calls = turn.toolCalls.map((c) => ({ id: c.id, name: c.name, argsText: c.arguments }));
+    const imageTurns = [];
+    for (const batch of batchCalls(calls, (n) => parallelNames.has(n), opts.maxParallel ?? DEFAULT_MAX_PARALLEL)) {
+      if (opts.stopped?.()) return { messages, text, rounds, exhausted: false, stopped: true };
+      for (const info of batch) opts.hooks?.onToolStart?.(info);
+      const runs = await Promise.all(
+        batch.map(async (info) => {
+          try {
+            return await opts.execTool(info);
+          } catch (err) {
+            const message = err.message;
+            return { ...info, ok: false, summary: message, content: JSON.stringify({ error: message }) };
+          }
+        })
+      );
+      for (const run of runs) {
+        opts.hooks?.onToolEnd?.(run);
+        messages.push({ role: "tool", tool_call_id: run.id, name: run.name, content: truncateResult(run.content, maxResultChars) });
+        if (run.images?.length) {
+          imageTurns.push({
+            role: "user",
+            content: [
+              { type: "text", text: `${RENDER_TURN_PREFIX}${run.name}: ${run.images.length === 1 ? "the rendered view" : `${run.images.length} rendered views`}.` },
+              ...run.images.map((url) => ({ type: "image_url", image_url: { url } }))
+            ]
+          });
+        }
+      }
+    }
+    for (const turnMessage of imageTurns) messages.push(turnMessage);
+    opts.hooks?.onRoundEnd?.(rounds);
+  }
+  messages.push({ role: "user", content: "You have reached the tool limit for this turn. Summarise what you changed and what is left, without calling more tools." });
+  const final = await opts.callModel(messages, [], { onTextDelta: opts.hooks?.onTextDelta });
+  messages.push({ role: "assistant", content: final.text });
+  return { messages, text: final.text, rounds, exhausted: true, stopped: false };
+}
+
+// lib/agent/tools/subagent-tools.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+
+// lib/agent/subagent.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+
+// lib/agent/prompt.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+init_limits();
+var PROMPT_LIMITS = {
+  maxPromptChars: 14e3,
+  maxSkillIndexChars: 4800,
+  maxProfileIndexChars: 1600,
+  maxContextChars: AI_LIMITS.maxContextChars,
+  maxSelectionItems: 12
+};
+var IDENTITY = `You are the PopCraft design agent. PopCraft is a browser design tool (frames, vectors, text, components, styles, variables, auto layout), and you work inside the user's open document through tools that edit it live.`;
+var HOW_TO_WORK = `How you work:
+- Inspect before you edit. Read the selection and the layers you are about to change; never guess at node ids, colors or sizes.
+- Make designs as code. Anything bigger than a small tweak \u2014 a poster, a post, a reel, a page, an ad set \u2014 is ONE script built with write_design (read the design-code skill and read_design_reference first), not dozens of create_node and update_nodes calls: it builds in one step, shows on the canvas as you write it, returns a render to look at, and is changed by editing the script and building again. Before calling a design done, review it with the design-review skill: every size, moments in time, a light and a dark brand kit.
+- Prefer batched tools. One call that renames thirty layers or sets ten strings beats thirty calls: every write is one undo step for the user, and a wall of undo steps is a bad edit.
+- Stay inside the scope the user pointed at. The selection is the default scope; do not touch the rest of the page unless asked.
+- Explain briefly. A line or two about what you did and why, with counts rather than lists. No preamble, no restating the request.
+- Use skills. Before a multi-step job, read the matching skill with read_skill and follow it; skills carry the rules that make the result look designed rather than generated.
+- Plan visibly for anything longer than a couple of steps: manage_todos puts the plan in front of the user and keeps you honest.
+- When a tool fails, read the error and fix the call \u2014 do not retry the same arguments, and do not pretend a failed edit happened.
+- Ask only when you genuinely cannot proceed (a structural ambiguity), and ask once. ask_user puts the question in front of them with options to click \u2014 use it when a choice is both ambiguous AND consequential, and never when you can reasonably infer the answer from the document or the request, or when you could just try it and let them undo. If they skip the question, pick sensibly and say which way you went.
+- Delegate the heavy parts. Surveying a big page, writing all the copy, restyling dozens of layers \u2014 hand those to a subagent with task(); it burns its own context and hands you back a short summary, which is what keeps you able to finish the turn. Several task() calls in one message run at the same time.`;
+var describeNodes = (doc, ids) => {
+  const shown = ids.slice(0, PROMPT_LIMITS.maxSelectionItems);
+  const parts = shown.map((id) => {
+    const n = doc.nodes[id];
+    return n ? `${id} (${n.type}${n.name ? ` "${str(n.name, 40)}"` : ""})` : `${id} (missing)`;
+  });
+  const rest = ids.length - shown.length;
+  return parts.join(", ") + (rest > 0 ? `, +${rest} more` : "");
+};
+function buildContextBlock(ctx, maxChars = PROMPT_LIMITS.maxContextChars) {
+  const { doc, pageId, selection } = ctx;
+  const page = doc.nodes[pageId];
+  const lines = [
+    `Document: "${str(doc.name, AI_LIMITS.maxNameChars)}" (${doc.pages.length} page${doc.pages.length === 1 ? "" : "s"}, ${Object.keys(doc.nodes).length} nodes)`,
+    `Current page: ${page ? `"${str(page.name, AI_LIMITS.maxNameChars)}"` : "unknown"} (id ${pageId}, ${page?.childIds?.length ?? 0} top-level layers)`,
+    selection.length ? `Selection (${selection.length}): ${describeNodes(doc, selection)}` : "Selection: nothing selected \u2014 ask what to work on, or use find_nodes / get_document_outline to locate it."
+  ];
+  const mentions = mentionContext(ctx.mentions, doc);
+  if (mentions) lines.push(mentions);
+  if (ctx.camera) {
+    const z = Math.round(ctx.camera.zoom * 100);
+    const size = ctx.viewport ? `, ${Math.round(ctx.viewport.width / ctx.camera.zoom)}x${Math.round(ctx.viewport.height / ctx.camera.zoom)} canvas units visible` : "";
+    lines.push(`Viewport: ${z}% zoom at (${Math.round(ctx.camera.x)}, ${Math.round(ctx.camera.y)})${size}`);
+  }
+  const design = buildDesignContext(doc, Math.max(200, Math.floor(maxChars / 2)));
+  if (design) lines.push(design);
+  if (ctx.readOnly) lines.push("This document is currently read-only (a version-history preview, or you are in this file as a viewer or commenter) \u2014 editing tools will refuse; explain that instead of retrying.");
+  return joinWithin(lines, maxChars);
+}
+function buildSkillIndex(skills, maxChars = PROMPT_LIMITS.maxSkillIndexChars) {
+  return joinWithin(skills.map(skillIndexLine), maxChars);
+}
+function buildProfileIndex(profiles, maxChars = PROMPT_LIMITS.maxProfileIndexChars) {
+  return joinWithin(profiles.map(profileIndexLine), maxChars);
+}
+function buildSubagentPrompt(instructions, ctx) {
+  const prompt = [instructions, SUBAGENT_FRAMING, `Current context:
+${buildContextBlock(ctx)}`].join("\n\n");
+  return prompt.length <= PROMPT_LIMITS.maxPromptChars ? prompt : `${prompt.slice(0, PROMPT_LIMITS.maxPromptChars)}
+\u2026`;
+}
+function buildSystemPrompt(ctx) {
+  const skills = ctx.skills ?? allSkills();
+  const profiles = ctx.profiles ?? allProfiles();
+  const active = ctx.activeSkillId ? findSkill(ctx.activeSkillId) : void 0;
+  const sections = [
+    IDENTITY,
+    HOW_TO_WORK,
+    `Skills (read the full instructions with read_skill before you follow one \u2014 only the summaries are here):
+${buildSkillIndex(skills)}`,
+    `Subagent profiles (spawn one with task({ subagent_type, prompt }); it starts fresh, sees this document but not this conversation, and returns only a summary):
+${buildProfileIndex(profiles)}`,
+    active ? `The user selected the "${active.name}" skill (${active.id}) for this turn. Call read_skill("${active.id}") first and follow it.` : "",
+    // Last on purpose: selection, camera and viewport change every turn, and providers cache prompts by
+    // prefix — everything above is identical from turn to turn, so it stays cacheable.
+    `Current context:
+${buildContextBlock(ctx)}`
+  ].filter(Boolean);
+  const prompt = sections.join("\n\n");
+  return prompt.length <= PROMPT_LIMITS.maxPromptChars ? prompt : `${prompt.slice(0, PROMPT_LIMITS.maxPromptChars)}
+\u2026`;
+}
+
+// lib/agent/subagent.ts
+var PARENT_ONLY_TOOLS = ["task", "await_job"];
+var depth = 0;
+var subagentDepth = () => depth;
+var FAST_HINTS = ["flash", "mini", "haiku", "lite", "nano", "small"];
+var isFastModelId = (id) => {
+  const lower = id.toLowerCase();
+  return FAST_HINTS.some((h) => lower.includes(h));
+};
+function canRunTools(model) {
+  if (model.capabilities && !model.capabilities.includes("tools")) return false;
+  const modalities = model.outputModalities;
+  if (modalities?.length && !modalities.includes("text")) return false;
+  return !/(^|[-/_])image([-/_]|$)/.test(model.id.toLowerCase());
+}
+function pickChildModel(profile, parentModel, catalog) {
+  const explicit = profile.model?.trim();
+  if (explicit && explicit !== "inherit") return explicit;
+  if (!profile.readOnly) return parentModel;
+  const fast = catalog.find((m) => isFastModelId(m.id) && canRunTools(m));
+  return fast?.id ?? parentModel;
+}
+function childToolNames(profile, registered, forceReadOnly) {
+  const wanted = profile.tools.includes(ALL_TOOLS) ? null : new Set(profile.tools);
+  const parentOnly = new Set(PARENT_ONLY_TOOLS);
+  return registered.filter((t) => !parentOnly.has(t.name)).filter((t) => t.confirm === void 0).filter((t) => t.interactive !== true).filter((t) => !wanted || wanted.has(t.name)).filter((t) => !forceReadOnly || t.readOnly === true).map((t) => t.name);
+}
+function editorPromptContext() {
+  const st = useEditorStore.getState();
+  return {
+    doc: st.document,
+    pageId: st.currentPageId,
+    selection: st.selection,
+    camera: st.camera,
+    viewport: typeof window === "undefined" ? void 0 : { width: window.innerWidth, height: window.innerHeight },
+    readOnly: !!editBlockReason()
+  };
+}
+var editorChildToolContext = editorToolContext;
+async function runSubagent(opts) {
+  const deps = opts.deps ?? {};
+  const profile = findProfile(opts.profileId);
+  if (!profile) {
+    const { allProfiles: allProfiles2 } = await import("./profiles-W756443W.js");
+    return { summary: `No subagent profile named "${opts.profileId}". Available: ${allProfiles2().map((p) => p.id).join(", ")}.`, rounds: 0, ok: false };
+  }
+  const prompt = opts.prompt?.trim();
+  if (!prompt) return { summary: "A task needs a self-contained `prompt` \u2014 the child cannot see this conversation.", rounds: 0, ok: false };
+  const promptCtx = (deps.promptContext ?? editorPromptContext)();
+  const forceReadOnly = profile.readOnly || opts.readOnly === true || promptCtx.readOnly === true;
+  const registered = (deps.registeredTools ?? (() => allTools().map((t) => ({ name: t.name, readOnly: t.readOnly, confirm: t.confirm, interactive: t.interactive }))))();
+  const names = childToolNames(profile, registered, forceReadOnly);
+  const specs = names.length ? toolSpecs(names) : [];
+  const parentModel = (deps.parentModel ?? (() => effectiveChatModel()))();
+  const catalog = (deps.catalog ?? (() => useAiStore.getState().catalog?.chat ?? []))();
+  const model = pickChildModel(profile, parentModel, catalog);
+  if (!model) return { summary: "No chat model is available for the subagent.", rounds: 0, ok: false };
+  const call = deps.callModel ?? ((args) => streamChat({ model: args.model, messages: args.messages, tools: args.tools }, {}, args.signal));
+  const base = (deps.toolContext ?? editorChildToolContext)(opts.signal);
+  const ctx = { ...base, actor: { ...base.actor ?? {}, kind: "agent", nested: true } };
+  const messages = [
+    { role: "system", content: buildSubagentPrompt(profile.instructions, promptCtx) },
+    { role: "user", content: opts.description ? `${opts.description}
+
+${prompt}` : prompt }
+  ];
+  const tools = specs.map((spec) => ({
+    spec,
+    readOnly: registered.find((t) => t.name === spec.function.name)?.readOnly === true
+  }));
+  depth += 1;
+  try {
+    const outcome = await runAgentLoop({
+      messages,
+      tools,
+      maxRounds: profile.maxRounds,
+      stopped: () => opts.signal?.aborted === true,
+      callModel: (msgs, toolSpecList) => call({ model, messages: msgs, tools: toolSpecList, signal: opts.signal }),
+      execTool: async (info) => {
+        opts.onChildTool?.({ name: info.name, status: "running" });
+        try {
+          const result = await runTool(info.name, info.argsText, ctx);
+          opts.onChildTool?.({ name: info.name, status: "done", summary: result.summary });
+          return {
+            ...info,
+            ok: true,
+            summary: result.summary,
+            content: JSON.stringify(result.data ?? { ok: true, summary: result.summary }),
+            images: result.images
+          };
+        } catch (err) {
+          const message = err.message ?? String(err);
+          opts.onChildTool?.({ name: info.name, status: "error", summary: message });
+          return { ...info, ok: false, summary: message, content: JSON.stringify({ error: message }) };
+        }
+      }
+    });
+    const summary = outcome.text.trim();
+    if (outcome.stopped) return { summary: summary || "(subagent stopped)", rounds: outcome.rounds, ok: false };
+    return { summary: summary || "(the subagent finished without a summary)", rounds: outcome.rounds, ok: true };
+  } catch (err) {
+    return { summary: `(subagent error: ${err.message ?? String(err)})`, rounds: 0, ok: false };
+  } finally {
+    depth = Math.max(0, depth - 1);
+  }
+}
+
+// lib/agent/jobs.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var jobs = /* @__PURE__ */ new Map();
+var notifications = [];
+var listeners = /* @__PURE__ */ new Set();
+var emit2 = () => {
+  for (const l of listeners) l();
+};
+function newJobId() {
+  return `task-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 7)}`;
+}
+function startJob(job) {
+  const row = { ...job, status: "running", startedAt: Date.now() };
+  jobs.set(row.id, row);
+  emit2();
+  return row;
+}
+function finishJob(id, summary, ok = true) {
+  const row = jobs.get(id);
+  if (!row || row.status !== "running") return;
+  Object.assign(row, { status: ok ? "done" : "error", summary, endedAt: Date.now() });
+  notifications.push(`Background task ${id} (${row.profile}) ${ok ? "completed" : "failed"}:
+${summary}`);
+  emit2();
+}
+function getJob(id) {
+  return jobs.get(id);
+}
+function drainNotifications() {
+  if (!notifications.length) return [];
+  const out = notifications.splice(0, notifications.length);
+  return out;
+}
+function cancelJob(id) {
+  const row = jobs.get(id);
+  if (!row || row.status !== "running") return;
+  Object.assign(row, { status: "cancelled", endedAt: Date.now() });
+  emit2();
+}
+function cancelAllJobs() {
+  for (const job of jobs.values()) {
+    if (job.status !== "running") continue;
+    job.cancel?.();
+    Object.assign(job, { status: "cancelled", endedAt: Date.now() });
+  }
+  notifications.length = 0;
+  emit2();
+}
+
+// lib/agent/tools/subagent-tools.ts
+function subagentDelegate(deps = {}) {
+  const run = deps.run ?? runSubagent;
+  return async (raw) => {
+    const request = raw;
+    if (request.op === "await") {
+      const job = getJob(request.jobId);
+      if (!job) return { kind: "unknown-job", jobId: request.jobId };
+      return { kind: "status", jobId: request.jobId, status: job.status, summary: job.summary ?? "" };
+    }
+    if (subagentDepth() > 0) {
+      return { kind: "refused", reason: "Subagents cannot spawn subagents. Do this work yourself and report it in your summary." };
+    }
+    const options = (job, signal) => ({
+      profileId: request.profileId,
+      prompt: request.prompt,
+      description: request.description,
+      readOnly: deps.readOnly === true || request.readOnly === true,
+      signal: signal ?? deps.signal,
+      onChildTool: deps.onChildTool ? (info) => deps.onChildTool?.({ ...info, profile: request.profileId, toolCallId: request.callId, jobId: job, job }) : void 0
+    });
+    if (!request.background) {
+      const result = await run(options());
+      return { kind: "result", ok: result.ok, rounds: result.rounds, summary: result.summary };
+    }
+    const id = newJobId();
+    const controller = new AbortController();
+    const abortChild = () => controller.abort();
+    if (deps.signal) {
+      if (deps.signal.aborted) controller.abort();
+      else deps.signal.addEventListener("abort", abortChild, { once: true });
+    }
+    const release = () => deps.signal?.removeEventListener("abort", abortChild);
+    startJob({
+      id,
+      profile: request.profileId,
+      description: request.description ?? request.prompt.slice(0, 80),
+      // What the strip's cancel button calls: abort the child's loop, then mark the row cancelled so no
+      // late summary is delivered to the parent.
+      cancel: () => {
+        controller.abort();
+        cancelJob(id);
+      }
+    });
+    void run(options(id, controller.signal)).then(
+      (result) => {
+        release();
+        finishJob(id, result.summary, result.ok);
+      },
+      (err) => {
+        release();
+        finishJob(id, `(subagent error: ${err.message ?? String(err)})`, false);
+      }
+    );
+    return { kind: "job", jobId: id };
+  };
+}
+
+// lib/commands/delegate.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var TASK_DESCRIPTION = [
+  "Delegate a self-contained piece of work to a subagent, which runs with its own fresh context and hands back only a summary. Use it to keep your own context small: surveys of large pages, writing all the copy, restyling dozens of layers.",
+  "The child CANNOT see this conversation \u2014 put everything it needs in the prompt: the scope (node ids), the goal, the constraints, and what you want back. It cannot ask you a question, and it cannot spawn subagents of its own.",
+  "Several task calls in one message run at the same time. Set run_in_background when you want to carry on working while it runs: you get a job id immediately and its summary arrives as a notification (check it with await_job)."
+].join("\n\n");
+var delegateTask = defineCommand({
+  id: "delegate.task",
+  title: "Delegate to a subagent",
+  domain: "delegate",
+  // NOT harmless: a background task or a full-tool child obviously edits the document. The loop's
+  // `readOnly` flag means "independent of the other calls in this batch", which a subagent spawn is, so
+  // the agent exposure keeps saying true while the honest effect says document.
+  effect: "document",
+  permission: null,
+  needs: ["delegate"],
+  params: external_exports.object({
+    subagent_type: external_exports.string().describe("Profile id \u2014 one of the profiles listed in your system prompt (list_profiles for the full set)."),
+    prompt: external_exports.string().describe("The self-contained task. The child does not see this conversation."),
+    description: external_exports.string().optional().describe('Short label for the panel row, e.g. "Survey the pricing page".'),
+    readonly: external_exports.boolean().optional().describe("Force read-only tools for this child, whatever the profile allows."),
+    run_in_background: external_exports.boolean().optional().describe("Return a job id immediately and notify you when the child finishes.")
+  }),
+  expose: {
+    agent: { name: "task", description: TASK_DESCRIPTION, readOnly: true }
+  },
+  run: async (args, ctx) => {
+    const reply = await ctx.use("delegate")({
+      op: "spawn",
+      profileId: args.subagent_type,
+      prompt: args.prompt,
+      description: args.description,
+      readOnly: args.readonly === true,
+      background: args.run_in_background === true,
+      callId: ctx.callId
+    });
+    if (reply.kind === "refused") return { summary: "task refused (nested)", data: { error: reply.reason } };
+    if (reply.kind === "job") {
+      return {
+        summary: `${args.subagent_type} started (${reply.jobId})`,
+        data: {
+          job_id: reply.jobId,
+          status: "running",
+          subagent_type: args.subagent_type,
+          note: "Keep working. The summary arrives as a notification when it finishes; await_job never blocks."
+        }
+      };
+    }
+    const result = reply;
+    return {
+      summary: `${args.subagent_type}: ${result.ok ? "done" : "failed"} in ${result.rounds} round${result.rounds === 1 ? "" : "s"}`,
+      data: { subagent_type: args.subagent_type, ok: result.ok, rounds: result.rounds, summary: result.summary }
+    };
+  }
+});
+var delegateAwait = defineCommand({
+  id: "delegate.await",
+  title: "Check a background task",
+  domain: "delegate",
+  effect: "document",
+  permission: null,
+  needs: ["delegate"],
+  params: external_exports.object({
+    job_id: external_exports.string().describe("The id returned by a background task call."),
+    timeout_ms: external_exports.number().optional().describe("Accepted for compatibility and ignored \u2014 this call always returns immediately.")
+  }),
+  expose: {
+    agent: {
+      name: "await_job",
+      description: "Check a background task by job id. It never blocks: you get the current status now, and the summary once the job has finished.",
+      readOnly: true
+    }
+  },
+  run: async (args, ctx) => {
+    const reply = await ctx.use("delegate")({ op: "await", jobId: args.job_id });
+    if (reply.kind === "unknown-job") {
+      return { summary: `No job ${args.job_id}`, data: { error: `No background task with id "${args.job_id}".` } };
+    }
+    const status = reply;
+    if (status.status === "running") {
+      return {
+        summary: `${args.job_id}: running`,
+        data: {
+          job_id: args.job_id,
+          status: "running",
+          note: "Still running. Do not call await_job in a loop \u2014 carry on with other work; its summary will be delivered to you automatically when it lands."
+        }
+      };
+    }
+    return { summary: `${args.job_id}: ${status.status}`, data: { job_id: args.job_id, status: status.status, summary: status.summary ?? "" } };
+  }
+});
+var profileList = defineCommand({
+  id: "delegate.listProfiles",
+  title: "List subagent profiles",
+  domain: "delegate",
+  effect: "none",
+  permission: null,
+  params: external_exports.object({}),
+  expose: {
+    agent: {
+      name: "list_profiles",
+      description: "List the subagent profiles you can delegate to with task (id, what each is for, when to use it)."
+    }
+  },
+  run: () => {
+    const profiles = allProfiles();
+    return {
+      summary: `${profiles.length} profile${profiles.length === 1 ? "" : "s"}`,
+      data: {
+        profiles: profiles.map((p) => ({
+          id: p.id,
+          name: p.name,
+          description: p.description,
+          whenToUse: p.whenToUse,
+          readOnly: p.readOnly,
+          tools: p.tools,
+          maxRounds: p.maxRounds
+        }))
+      }
+    };
+  }
+});
+var profileRead = defineCommand({
+  id: "delegate.readProfile",
+  title: "Read a subagent profile",
+  domain: "delegate",
+  effect: "none",
+  permission: null,
+  params: external_exports.object({ id: external_exports.string().describe('The profile id, e.g. "inspector".') }),
+  expose: {
+    agent: {
+      name: "read_profile",
+      description: "Read a subagent profile in full \u2014 its instructions, tool allowlist and round budget \u2014 before you delegate to it."
+    }
+  },
+  run: ({ id }) => {
+    const profile = findProfile(id);
+    if (!profile) {
+      return { summary: `No profile "${id}"`, data: { error: `No subagent profile with id "${id}".`, available: allProfiles().map(profileIndexLine) } };
+    }
+    return {
+      summary: `Read profile: ${profile.name}`,
+      data: { id: profile.id, name: profile.name, readOnly: profile.readOnly, tools: profile.tools, maxRounds: profile.maxRounds, instructions: profile.instructions }
+    };
+  }
+});
+var delegateCommands = [delegateTask, delegateAwait, profileList, profileRead];
+function registerDelegateCommands() {
+  registerCommand(...delegateCommands);
+}
+
+// lib/commands/skill.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var skillList = defineCommand({
+  id: "skill.list",
+  title: "List skills",
+  domain: "skill",
+  effect: "none",
+  // The skill sheets are the agent's own instructions, not the user's document.
+  permission: null,
+  params: external_exports.object({}),
+  expose: {
+    agent: {
+      name: "list_skills",
+      description: "List the available skills (name, what they are for, and when to use them). The full instructions come from read_skill."
+    }
+  },
+  run: () => {
+    const skills = allSkills();
+    return {
+      summary: `${skills.length} skill${skills.length === 1 ? "" : "s"}`,
+      data: { skills: skills.map((s) => ({ id: s.id, name: s.name, description: s.description, whenToUse: s.whenToUse, tools: s.tools })) }
+    };
+  }
+});
+var skillRead = defineCommand({
+  id: "skill.read",
+  title: "Read a skill",
+  domain: "skill",
+  effect: "none",
+  permission: null,
+  params: external_exports.object({ id: external_exports.string().describe('The skill id, e.g. "fill-content".') }),
+  expose: {
+    agent: {
+      name: "read_skill",
+      description: "Read a skill\u2019s full instructions by id. Do this before following a skill; the system prompt only carries the summaries."
+    }
+  },
+  run: ({ id }) => {
+    const skill = findSkill(id);
+    if (!skill) {
+      return {
+        summary: `No skill "${id}"`,
+        data: { error: `No skill with id "${id}".`, available: allSkills().map(skillIndexLine) }
+      };
+    }
+    return {
+      summary: `Read skill: ${skill.name}`,
+      data: { id: skill.id, name: skill.name, tools: skill.tools, instructions: skill.instructions }
+    };
+  }
+});
+var skillCommands = [skillList, skillRead];
+function registerSkillCommands() {
+  registerCommand(...skillCommands);
+}
+
+// lib/agent/parts.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+function todoItemsFrom(rows) {
+  if (!Array.isArray(rows)) return null;
+  return rows.map((row) => {
+    const t = row ?? {};
+    return {
+      text: String(t.title ?? t.text ?? ""),
+      done: typeof t.done === "boolean" ? t.done : t.status === "done"
+    };
+  });
+}
+var textOf = (m) => m.parts.filter((p) => p.type === "text").map((p) => p.text).join("");
+function pushTextDelta(parts, delta) {
+  const last = parts[parts.length - 1];
+  if (last?.type === "text") {
+    parts[parts.length - 1] = { type: "text", text: last.text + delta };
+    return parts;
+  }
+  return [...parts, { type: "text", text: delta }];
+}
+function pushReasoningDelta(parts, delta) {
+  const last = parts[parts.length - 1];
+  if (last?.type === "reasoning") {
+    parts[parts.length - 1] = { type: "reasoning", text: last.text + delta };
+    return parts;
+  }
+  return [...parts, { type: "reasoning", text: delta }];
+}
+function upsertToolPart(parts, part) {
+  const i = parts.findIndex((p) => p.type === "tool" && p.id === part.id);
+  if (i < 0) return [...parts, part];
+  const next = [...parts];
+  next[i] = { ...next[i], ...part };
+  return next;
+}
+
+// lib/agent/runner.ts
+var ALWAYS_ALLOWED = ["list_skills", "read_skill", "manage_todos", "notify", "get_selection", "task", "await_job", "list_profiles", "read_profile", "ask_user"];
+var childToolListener = null;
+function onChildTool(fn) {
+  childToolListener = fn;
+  return () => {
+    if (childToolListener === fn) childToolListener = null;
+  };
+}
+var MAX_HISTORY_MESSAGES = 24;
+var MAX_PARALLEL_TOOLS = 4;
+var TURN_MAX_ROUNDS = 500;
+function needsEditableSession(name) {
+  const tool = getTool(name);
+  if (tool?.readOnly) return false;
+  if (tool?.interactive) return false;
+  return true;
+}
+function guardEdit(name) {
+  if (!needsEditableSession(name)) return;
+  const reason = editBlockReason();
+  if (reason) throw new ToolError(`${name} cannot run: ${reason}`);
+}
+function historyMessages() {
+  return activeMessages().slice(-MAX_HISTORY_MESSAGES).map((m) => ({ role: m.role, content: textOf(m).trim() })).filter((m) => !!m.content);
+}
+function systemMessage(skillId, mentions = []) {
+  const st = useEditorStore.getState();
+  return {
+    role: "system",
+    content: buildSystemPrompt({
+      doc: st.document,
+      pageId: st.currentPageId,
+      selection: st.selection,
+      camera: st.camera,
+      viewport: typeof window === "undefined" ? void 0 : { width: window.innerWidth, height: window.innerHeight },
+      activeSkillId: skillId,
+      readOnly: !!editBlockReason(),
+      mentions
+    })
+  };
+}
+var registerTurnTools = (deps) => {
+  registerBuiltinTools();
+  registerSkillCommands();
+  registerDelegateCommands();
+  registerDangerousCommands();
+  provideAgentCapability("delegate", subagentDelegate(deps));
+};
+var specsFor = (skillId) => {
+  const skill = skillId ? findSkill(skillId) : void 0;
+  return skill?.tools.length ? toolSpecs([.../* @__PURE__ */ new Set([...skill.tools, ...ALWAYS_ALLOWED])]) : toolSpecs();
+};
+var loopTools = (skillId) => specsFor(skillId).map((spec) => ({ spec, readOnly: getTool(spec.function.name)?.readOnly === true }));
+function syncTodos(run) {
+  if (run.name !== "manage_todos" || !run.ok) return;
+  try {
+    const data = JSON.parse(run.content);
+    const items = todoItemsFrom(data.todos);
+    if (items) setTodos(items);
+  } catch {
+  }
+}
+async function runTurn(text, mentions = []) {
+  const availability = aiAvailability();
+  if (!availability.ok) {
+    useAgentStore.setState({ error: { message: availability.message, code: availability.reason } });
+    return;
+  }
+  const model = agentModel();
+  if (!model) {
+    useAgentStore.setState({ error: { message: "Pick a chat model for the agent first.", code: "no_model" } });
+    return;
+  }
+  const skillId = mentions.find((m) => m.kind === "skill")?.id ?? useAgentStore.getState().skillId;
+  const before = useEditorStore.getState().document;
+  const checkpoint = rememberCheckpoint(before);
+  const user = { id: newId(), role: "user", parts: [{ type: "text", text }], createdAt: Date.now() };
+  appendMessage(user);
+  const assistantId = newId();
+  appendMessage({ id: assistantId, role: "assistant", parts: [], createdAt: Date.now(), checkpoint }, { save: false });
+  let parts = [];
+  const flush = (save = false) => setParts(assistantId, parts, { save });
+  const abort = new AbortController();
+  useAgentStore.setState({ running: true, abort, error: null });
+  const ctx = editorToolContext(abort.signal);
+  const { createDesignPreview, DESIGN_TOOL } = await import("./live-LQ4LJE5T.js");
+  const preview = createDesignPreview();
+  registerTurnTools({
+    readOnly: !!editBlockReason(),
+    signal: abort.signal,
+    onChildTool: (report) => childToolListener?.(report)
+  });
+  try {
+    await runAgentLoop({
+      messages: [systemMessage(skillId, mentions), ...historyMessages()],
+      tools: loopTools(skillId),
+      stopped: () => abort.signal.aborted,
+      // Finished background subagents report back here, between rounds.
+      drainNotifications,
+      maxParallel: MAX_PARALLEL_TOOLS,
+      maxRounds: TURN_MAX_ROUNDS,
+      callModel: (messages, specs, hooks) => streamChat({ model, messages, tools: specs }, hooks, abort.signal),
+      execTool: async (call) => {
+        const row = { type: "tool", id: call.id, name: call.name, argsText: call.argsText, status: "running" };
+        parts = upsertToolPart(parts, row);
+        flush();
+        try {
+          if (call.name === DESIGN_TOOL) preview.end();
+          guardEdit(call.name);
+          const result = await runTool(call.name, call.argsText, { ...ctx, toolCallId: call.id });
+          const content = JSON.stringify(result.data ?? { ok: true, summary: result.summary });
+          parts = upsertToolPart(parts, { ...row, status: "done", summary: result.summary, result: content });
+          for (const url of result.images ?? []) parts = [...parts, { type: "image", url, caption: call.name }];
+          flush();
+          return { id: call.id, name: call.name, argsText: call.argsText, ok: true, summary: result.summary, content, images: result.images };
+        } catch (err) {
+          const message = err.message ?? String(err);
+          parts = upsertToolPart(parts, { ...row, status: "error", summary: message, error: message });
+          flush();
+          return { id: call.id, name: call.name, argsText: call.argsText, ok: false, summary: message, content: JSON.stringify({ error: message }) };
+        }
+      },
+      hooks: {
+        onTextDelta: (d) => {
+          parts = pushTextDelta([...parts], d);
+          flush();
+        },
+        onReasoningDelta: (d) => {
+          parts = pushReasoningDelta([...parts], d);
+          flush();
+        },
+        onToolProgress: (p) => preview.update(p.name, p.arguments),
+        onToolEnd: syncTodos
+      }
+    });
+  } catch (err) {
+    if (!abort.signal.aborted) {
+      const message = err?.message ?? String(err);
+      const code = err?.code;
+      parts = [...parts, { type: "error", message, code }];
+    }
+  } finally {
+    preview.end();
+    if (abort.signal.aborted) {
+      cancelAllJobs();
+      parts = [...parts, { type: "error", message: "Stopped. Any edits already applied are still there." }];
+    }
+    if (useEditorStore.getState().document === before) updateMessage(assistantId, (m) => ({ ...m, checkpoint: void 0 }), { save: false });
+    flush(true);
+    updateActiveThread((t) => ({ ...t, checkpoint: { id: checkpoint, label: "Undo these changes" } }));
+    useAgentStore.setState({ running: false, abort: null });
+  }
+}
+export {
+  editorToolContext,
+  needsEditableSession,
+  onChildTool,
+  runTurn
+};