neko-harness 0.4.7 → 0.4.8

package/dist/gateway.js

@@ -16598,7 +16598,7 @@ function parseGatewayArgs(argv) {
 }
 
 // packages/gateway/src/gateway.ts
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 import { mkdir as mkdir6, readFile as readFile7, writeFile as writeFile5 } from "fs/promises";
 import { basename as basename4, dirname as dirname9, join as join13 } from "path";
 import { createHost as createHost2 } from "@earendil-works/chord";
@@ -17173,7 +17173,7 @@ function queuedUserInput(raw) {
   if (item.entry?.kind !== NekoInput.kind)
     return;
   const data = item.entry.data;
-  if (!data || data.jobReport || data.subagentRoundId)
+  if (!data || data.jobReport || data.planDecision || data.subagentRoundId)
     return;
   const defaultPrompt = Array.isArray(item.content) ? savedDefaultImagePrompt(item.content, data.defaultImagePrompt) : undefined;
   const content = defaultPrompt && Array.isArray(item.content) ? item.content.slice(1) : item.content;
@@ -17259,6 +17259,11 @@ function toolInteraction(name, details) {
     const { action, revision, completed, total } = details;
     return (action === "list" || action === "replace") && typeof revision === "number" && typeof completed === "number" && typeof total === "number" ? { kind: "todo", action, revision, completed, total } : undefined;
   }
+  if (name === "submit_plan") {
+    const { version, title, note } = details;
+    const steps = strings(details.steps);
+    return typeof version === "string" && typeof title === "string" && typeof note === "string" && steps ? { kind: "submit_plan", version, title, steps, note } : undefined;
+  }
   if (name !== "ask_user")
     return;
   const { id, question, multiple, options, status } = details;
@@ -17304,6 +17309,14 @@ function summarizeToolCall(name, args) {
       return {
         args: truncateMiddle(question.replace(/\s+/g, " "), 100),
         detail: [question, ...lines.length ? ["", ...lines] : []].join(`
+`)
+      };
+    }
+    case "submit_plan": {
+      const steps = strings(record.steps) ?? [];
+      return {
+        args: truncateMiddle(String(record.title ?? "").replace(/\s+/g, " "), 100),
+        detail: steps.map((step, index) => `${index + 1}. ${step}`).join(`
 `)
       };
     }
@@ -17484,6 +17497,17 @@ function projectChatView(view, modelLabel, options = {}) {
   for (const entry of view.entries) {
     const message = entry.model?.[0];
     const jobReport = entry.kind === NekoInput.kind ? entry.data?.jobReport : undefined;
+    const planDecision = entry.kind === NekoInput.kind ? entry.data?.planDecision : undefined;
+    if (message?.role === "user" && planDecision) {
+      items.push({
+        type: "system",
+        key: `e${entry.id}`,
+        id: entry.id,
+        text: planDecision.kind === "approve" ? `Plan approved: ${planDecision.title}` : `Changes requested for plan "${planDecision.title}": ${planDecision.feedback ?? ""}`,
+        planDecision: { version: planDecision.version, kind: planDecision.kind }
+      });
+      continue;
+    }
     if (message?.role === "user" && jobReport) {
       items.push({
         type: "system",
@@ -17687,7 +17711,7 @@ function contextTokens(entries) {
 import {
   AssistantEntry,
   configure,
-  defineDoc,
+  defineDoc as defineDoc2,
   defineExtension,
   defineTask,
   defineTool,
@@ -17697,6 +17721,19 @@ import {
 import { Type } from "typebox";
 import { Value } from "typebox/value";
 
+// packages/core/src/plan-doc.ts
+import { defineDoc } from "@earendil-works/pi-durable";
+var PLAN_HISTORY = 5;
+var PlanDoc = defineDoc({
+  kind: "app.neko.plan",
+  version: 1,
+  scope: "conversation",
+  history: "rewindable",
+  fork: "asOf",
+  initial: () => ({ mode: "normal", revision: 0, items: [] })
+});
+var PLAN_CODER_BLOCKED = "Plan mode is read-only: the coder subagent is unavailable. Use explore or plan subagents, or finish the plan first.";
+
 // packages/core/src/subagent-usage.ts
 var emptySubagentUsage = () => ({ models: {}, tools: {} });
 function subtractSubagentUsage(end, start) {
@@ -17741,7 +17778,7 @@ function subagentUsageTotals(state) {
 
 // packages/core/src/subagents.ts
 var agentIdFor = (childId) => `agent-${childId}`;
-var DelegationsDoc = defineDoc({
+var DelegationsDoc = defineDoc2({
   kind: "app.neko.delegations",
   version: 1,
   scope: "conversation",
@@ -17749,7 +17786,7 @@ var DelegationsDoc = defineDoc({
   fork: "initial",
   initial: () => ({ items: [] })
 });
-var SubagentsDoc = defineDoc({
+var SubagentsDoc = defineDoc2({
   kind: "app.neko.subagents",
   version: 1,
   scope: "conversation",
@@ -17757,7 +17794,7 @@ var SubagentsDoc = defineDoc({
   fork: "initial",
   initial: () => ({ items: [] })
 });
-var SubagentDoc = defineDoc({
+var SubagentDoc = defineDoc2({
   kind: "app.neko.subagent",
   version: 1,
   scope: "conversation",
@@ -17765,7 +17802,7 @@ var SubagentDoc = defineDoc({
   fork: "initial",
   initial: () => ({ role: null, parentId: null })
 });
-var SlotsDoc = defineDoc({
+var SlotsDoc = defineDoc2({
   kind: "app.neko.subagent-slots",
   version: 1,
   scope: "session",
@@ -17777,8 +17814,8 @@ var ROLE_PROMPTS = {
   coder: "You are neko's coding subagent. Implement only the assigned scope and verify it. Coordinate through the main agent; do not overwrite unrelated changes. Report changed files and verification results."
 };
 var SUBAGENT_DELIVERY = " Work from the assigned task, your own prior conversation context and project resources; you cannot see the main conversation. Do not delegate or ask the user directly. Your final message must be a self-contained delivery to the main agent, including evidence, results and limitations. Skills never expand your allowed tools.";
-var MAIN_ONLY_TOOLS = new Set(["todo", "ask_user"]);
-var MAIN_ONLY_EXTENSIONS = new Set(["neko-todos", "neko-questions"]);
+var MAIN_ONLY_TOOLS = new Set(["todo", "ask_user", "submit_plan"]);
+var MAIN_ONLY_EXTENSIONS = new Set(["neko-todos", "neko-questions", "neko-plan"]);
 var READ_TOOLS = new Set(["read", "find_files", "search_text", "web_search", "web_extract"]);
 async function refreshDelegations(tx, id) {
   const doc = await tx.doc(DelegationsDoc, id);
@@ -18078,6 +18115,9 @@ function createSubagentExtension(prepare, discard, guard) {
               return receipt;
             const identities = await tx.doc(SubagentsDoc, api.conversationId);
             let identity;
+            const planning = !receipt && (await tx.doc(PlanDoc, api.conversationId)).mode === "plan";
+            if (planning && args.action !== "continue" && args.type === "coder")
+              throw new Error(PLAN_CODER_BLOCKED);
             if (args.action === "continue") {
               identity = identities.items.find((a) => a.agentId === args.agentId);
               if (!identity)
@@ -18085,6 +18125,8 @@ function createSubagentExtension(prepare, discard, guard) {
               const info = await tx.doc(SubagentDoc, identity.childId);
               if (info.parentId !== api.conversationId || info.role !== identity.role)
                 throw new Error("Subagent ownership mismatch.");
+              if (planning && identity.role === "coder")
+                throw new Error(PLAN_CODER_BLOCKED);
               if (identity.activeRoundId !== null)
                 throw new Error("Subagent is busy; continue only when idle.");
             } else if (receipt) {
@@ -18646,6 +18688,13 @@ var QUESTION_LIMITS = {
   previewChars: 256,
   recordBytes: 65536
 };
+var PLAN_LIMITS = {
+  titleChars: 120,
+  maxSteps: 30,
+  stepChars: 500,
+  noteChars: 4000,
+  feedbackChars: 2000
+};
 var TODO_STATUSES = ["pending", "in_progress", "completed"];
 
 class InteractionInputError extends Error {
@@ -18830,8 +18879,44 @@ var todoProgress = (items) => ({
   completed: items.filter((i) => i.status === "completed").length,
   total: items.length
 });
+function validatePlanArgs(input) {
+  if (!isRecord2(input))
+    return fail("Plan arguments must be an object.");
+  exactKeys(input, ["title", "steps", "note"], "Plan");
+  const title = text(input.title, "title", PLAN_LIMITS.titleChars);
+  if (!Array.isArray(input.steps))
+    return fail("steps must be an array.");
+  if (input.steps.length < 1)
+    fail("A plan needs at least one step.");
+  if (input.steps.length > PLAN_LIMITS.maxSteps)
+    fail(`Too many steps (limit ${PLAN_LIMITS.maxSteps}).`);
+  const steps = input.steps.map((step, index) => text(step, `steps[${index}]`, PLAN_LIMITS.stepChars));
+  let note = "";
+  if (input.note !== undefined) {
+    if (typeof input.note !== "string")
+      fail("note must be a string.");
+    const value = input.note;
+    if (value.length > PLAN_LIMITS.noteChars)
+      fail(`note is too long (limit ${PLAN_LIMITS.noteChars} characters).`);
+    if (!blank(value))
+      note = value;
+  }
+  return { title, steps, note };
+}
+function validatePlanDecision(input) {
+  if (!isRecord2(input))
+    return fail("Decision must be an object.");
+  if (input.kind === "approve") {
+    exactKeys(input, ["kind"], "Decision");
+    return { kind: "approve" };
+  }
+  if (input.kind !== "revise")
+    return fail('Decision kind must be "approve" or "revise".');
+  exactKeys(input, ["kind", "feedback"], "Decision");
+  return { kind: "revise", feedback: text(input.feedback, "feedback", PLAN_LIMITS.feedbackChars) };
+}
 // packages/core/src/jobs.ts
-import { defineDoc as defineDoc2 } from "@earendil-works/pi-durable";
+import { defineDoc as defineDoc3 } from "@earendil-works/pi-durable";
 var JOB_LIMITS = {
   maxRunning: 4,
   keepTerminal: 20,
@@ -18845,7 +18930,7 @@ var JOB_LIMITS = {
   commandBytes: 32 * 1024,
   maxTimeoutSeconds: 7 * 24 * 3600
 };
-var JobsDoc = defineDoc2({
+var JobsDoc = defineDoc3({
   kind: "app.neko.jobs",
   version: 1,
   scope: "conversation",
@@ -18984,9 +19069,9 @@ import { builtinProviders } from "@earendil-works/pi-ai/providers/all";
 import {
   AssistantEntry as AssistantEntry2,
   createRegistry,
-  defineDoc as defineDoc7,
+  defineDoc as defineDoc8,
   Harness,
-  InboxDoc as InboxDoc2,
+  InboxDoc as InboxDoc3,
   LiveDoc as importLiveDoc,
   MemoryStorage,
   UsageDoc as UsageDoc2,
@@ -19785,499 +19870,238 @@ ${text}` : `No new output (next offset ${offset}).`);
   }
 }
 
-// packages/core/src/prompt/invoke.ts
-import { dirname as dirname4 } from "path";
-
-// packages/core/src/prompt/diagnostics.ts
-var ignorePromptDiagnostic = () => {};
-var warnPromptDiagnostic = ({ path, message }) => {
-  console.warn(`[neko-prompt] ${JSON.stringify(path)}: ${message}`);
-};
-var isMissing = (error) => typeof error === "object" && error !== null && ("code" in error) && (error.code === "ENOENT" || error.code === "ENOTDIR");
+// packages/core/src/plan.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import {
+  defineExtension as defineExtension6,
+  defineTool as defineTool5,
+  hook as hook2,
+  InboxDoc,
+  ToolTask as ToolTask2,
+  wrapTool
+} from "@earendil-works/pi-durable";
+import { createBashTool } from "@earendil-works/pi-durable/tools";
+import { Type as Type5 } from "typebox";
 
-// packages/core/src/prompt/skills.ts
-import { readdir, readFile as readFile2 } from "fs/promises";
-import { basename, dirname as dirname3, join as join3 } from "path";
-var MAX_NAME_LENGTH = 64;
-var MAX_DESCRIPTION_LENGTH = 1024;
-var parseSkillFile = (content, filePath, report = ignorePromptDiagnostic) => {
-  const skip = (message) => {
-    report({ path: filePath, message });
-    return null;
-  };
-  try {
-    const { frontmatter } = parseFrontmatter(content);
-    const description = frontmatter.description;
-    if (typeof description !== "string" || description.trim() === "")
-      return skip("Skill description is missing or empty; skipped.");
-    if (description.length > MAX_DESCRIPTION_LENGTH)
-      return skip("Skill description is too long; skipped.");
-    const name = typeof frontmatter.name === "string" && frontmatter.name.trim() !== "" ? frontmatter.name : basename(dirname3(filePath));
-    if (name.length > MAX_NAME_LENGTH || /[\s\p{Cc}]/u.test(name))
-      return skip("Skill name is too long or contains whitespace/control characters; skipped.");
-    return {
-      name,
-      description,
-      filePath,
-      disableModelInvocation: frontmatter["disable-model-invocation"] === true
-    };
-  } catch {
-    return skip("Invalid skill frontmatter; skipped.");
-  }
-};
-var scanSkillsDir = async (dir, report = ignorePromptDiagnostic, capture) => {
-  let entries;
-  try {
-    entries = await readdir(dir, { withFileTypes: true });
-  } catch (error) {
-    if (!isMissing(error))
-      report({ path: dir, message: "Cannot scan skills directory; skipped." });
-    return [];
-  }
-  const skills = [];
-  for (const entry of entries.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0)) {
-    if (!entry.isDirectory())
+// packages/core/src/plan-bash.ts
+var SAFE_PATTERNS = [
+  /^\s*(cat|head|tail|nl|tac|rev|cut|tr|paste|column|fold|comm|wc|sort|uniq|diff|file|stat|du|df|tree)\b/,
+  /^\s*(grep|egrep|fgrep|rg|fd|find|jq|bat|eza|ls|pwd|echo|printf|true|cd)\b/,
+  /^\s*(basename|dirname|realpath|readlink|which|whereis|type|sha256sum|shasum|md5sum)\b/,
+  /^\s*(uname|whoami|id|date|cal|uptime|ps|free)\b/,
+  /^\s*env\s*$/,
+  /^\s*printenv\b/,
+  /^\s*sed\s+-n\b/,
+  /^\s*awk\b/,
+  /^\s*curl\b/,
+  /^\s*wget\s+-O\s*-/,
+  /^\s*git\s+(status|log|diff|show|blame|rev-parse|describe|shortlog|grep|cat-file|merge-base|name-rev|reflog|show-ref|for-each-ref|ls-[\w-]+)\b/,
+  /^\s*git\s+config\s+--get\b/,
+  /^\s*git\s+stash\s+list\b/,
+  /^\s*git\s+branch(\s+(-a|-r|-v|-vv|-l|--all|--remotes|--list|--show-current))*\s*$/,
+  /^\s*git\s+remote(\s+(-v|show\b.*|get-url\b.*))?\s*$/,
+  /^\s*npm\s+(list|ls|view|info|search|outdated|audit)\b/,
+  /^\s*(bun|pnpm)\s+(pm\s+ls|list|ls|why|outdated|info|view)\b/,
+  /^\s*yarn\s+(list|info|why|audit)\b/,
+  /^\s*(node|python3?|bun|deno)\s+(-v|--version)\s*$/
+];
+var DANGEROUS_FLAGS = [
+  /--output\b/,
+  /\bfind\b[^|;&]*\s-(delete|exec|execdir|ok|okdir|fprint0?|fprintf|fls)\b/,
+  /\bsed\b[^|;&]*(\s-[A-Za-z]*i|--in-place)/,
+  /\bsort\b[^|;&]*\s-[A-Za-z]*o/,
+  /\btree\b[^|;&]*\s-o\b/,
+  /\brg\b[^|;&]*--pre\b/,
+  /\bfd\b[^|;&]*(\s-[xX]\b|--exec)/,
+  /\bcurl\b[^|;&]*\s(-[A-Za-z]*[oOdXTF]\b|--(output|remote-name|data[\w-]*|request|upload-file|form|json)\b)/,
+  /\bnpm\s+audit\s+fix\b/
+];
+var DANGEROUS_CONTENT = [
+  /\bawk\b.*(system\s*\(|\bgetline\b|\|\s*"|\bprintf?\b[^}]*>)/,
+  /\bsed\b.*['"\s;{0-9$/,][wWe]\s+\S/
+];
+function segments(command) {
+  const result = [];
+  let raw = "";
+  let bare = "";
+  let quote = null;
+  const flush = () => {
+    if (raw.trim() !== "")
+      result.push({ raw, bare });
+    raw = "";
+    bare = "";
+  };
+  for (let i = 0;i < command.length; i++) {
+    const char = command[i];
+    if (quote) {
+      raw += char;
+      if (char === "\\" && quote === '"' && i + 1 < command.length)
+        raw += command[++i];
+      else if (char === quote) {
+        quote = null;
+        bare += char;
+      }
       continue;
-    const filePath = join3(dir, entry.name, "SKILL.md");
-    let content;
-    try {
-      content = await readFile2(filePath, "utf8");
-    } catch (error) {
-      if (!isMissing(error))
-        report({ path: filePath, message: "Cannot read skill; skipped." });
+    }
+    if (char === "\\" && i + 1 < command.length) {
+      raw += char + command[++i];
+      bare += " ";
       continue;
     }
-    const skill = parseSkillFile(content, filePath, report);
-    if (skill) {
-      skills.push(skill);
-      capture?.(skill, content);
+    if (char === "'" || char === '"') {
+      quote = char;
+      raw += char;
+      bare += char;
+      continue;
     }
+    const two = command.slice(i, i + 2);
+    if (two === "&&" || two === "||") {
+      flush();
+      i++;
+      continue;
+    }
+    if (char === ";" || char === "|" || char === `
+`) {
+      flush();
+      continue;
+    }
+    raw += char;
+    bare += char;
   }
-  return skills;
-};
-var mergeSkills = (groups) => {
-  const byName = new Map;
-  for (const group of groups)
-    for (const skill of group)
-      byName.set(skill.name, skill);
-  return [...byName.values()];
-};
-var escapeXml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
-var formatSkillsForPrompt = (skills) => {
-  const visible = skills.filter((skill) => !skill.disableModelInvocation);
-  if (visible.length === 0)
-    return "";
-  const lines = [
-    "The following skills provide specialized instructions for specific tasks.",
-    "Use the read tool to load a skill's file when the task matches its description.",
-    "When a skill file references a relative path, resolve it against the skill directory (parent of SKILL.md) and use that absolute path in tool commands.",
-    "",
-    "<available_skills>"
-  ];
-  for (const skill of visible) {
-    lines.push("  <skill>");
-    lines.push(`    <name>${escapeXml(skill.name)}</name>`);
-    lines.push(`    <description>${escapeXml(skill.description)}</description>`);
-    lines.push(`    <location>${escapeXml(skill.filePath)}</location>`);
-    lines.push("  </skill>");
-  }
-  lines.push("</available_skills>");
-  return lines.join(`
-`);
-};
-
-// packages/core/src/prompt/invoke.ts
-var expandSkillCommand = async (text, skills, readFile, report = warnPromptDiagnostic, metadata) => {
-  if (!text.startsWith("/skill:"))
-    return text;
-  const spaceIndex = text.indexOf(" ");
-  const skillName = spaceIndex === -1 ? text.slice(7) : text.slice(7, spaceIndex);
-  const args = spaceIndex === -1 ? "" : text.slice(spaceIndex + 1).trim();
-  const skill = skills.find((s) => s.name === skillName);
-  if (!skill)
-    return text;
-  let body;
-  try {
-    body = stripFrontmatter(await readFile(skill.filePath)).trim();
-  } catch {
-    report({ path: skill.filePath, message: "Cannot expand known skill; original input preserved." });
-    return text;
-  }
-  metadata?.({
-    name: skill.name,
-    location: skill.filePath,
-    body: `References are relative to ${dirname4(skill.filePath)}.
-
-${body}`,
-    args
+  if (quote)
+    return null;
+  flush();
+  return result;
+}
+var stripHarmlessRedirects = (text) => text.replace(/[0-9]?>&[0-9-]/g, " ").replace(/(?:[0-9]|&)?>>?\s*\/dev\/null\b/g, " ");
+function isSafeCommand(command) {
+  const parts = segments(command);
+  if (!parts?.length)
+    return false;
+  if (/\$\(|`|<\(|>\(/.test(command.replace(/'[^']*'/g, "''")))
+    return false;
+  return parts.every(({ raw, bare }) => {
+    const text = stripHarmlessRedirects(bare);
+    if (/[>&]|<</.test(text))
+      return false;
+    return SAFE_PATTERNS.some((pattern) => pattern.test(text)) && !DANGEROUS_FLAGS.some((pattern) => pattern.test(text)) && !DANGEROUS_CONTENT.some((pattern) => pattern.test(raw));
   });
-  const block = `<skill name="${escapeXml(skill.name)}" location="${escapeXml(skill.filePath)}">
-References are relative to ${dirname4(skill.filePath)}.
-
-${body}
-</skill>`;
-  return args ? `${block}
+}
 
-${args}` : block;
+// packages/core/src/user-questions.ts
+import { randomUUID } from "crypto";
+import {
+  defineDoc as defineDoc4,
+  defineDocFamily,
+  defineExtension as defineExtension5,
+  defineTool as defineTool4
+} from "@earendil-works/pi-durable";
+import { Type as Type4 } from "typebox";
+var QuestionDoc = defineDocFamily({
+  kind: "app.neko.question",
+  version: 1,
+  scope: "conversation",
+  history: "latest",
+  fork: "initial",
+  family: true,
+  initial: (seed) => seed
+});
+var QuestionsDoc = defineDoc4({
+  kind: "app.neko.questions",
+  version: 1,
+  scope: "conversation",
+  history: "latest",
+  fork: "initial",
+  initial: () => ({ revision: 0, pending: [] })
+});
+var clone = (value) => JSON.parse(JSON.stringify(value));
+var MISSING = {
+  id: 0,
+  callId: "",
+  version: "",
+  question: "",
+  multiple: false,
+  options: [],
+  status: "pending",
+  answer: null,
+  createdAt: 0,
+  settledAt: null
 };
+var argsOf = (record) => ({
+  question: record.question,
+  multiple: record.multiple,
+  options: clone(record.options)
+});
+async function live(tx, id) {
+  let cursor = id;
+  for (let depth = 0;cursor !== undefined && depth < 16; depth++) {
+    const task = await tx.task(cursor);
+    if (!task || task.abortRequested || task.state.status === "terminal" || task.state.status === "completing")
+      return false;
+    cursor = task.owner;
+  }
+  return true;
+}
+function settle(record, index, status) {
+  record.status = status;
+  record.settledAt = Date.now();
+  index.pending = index.pending.filter((id) => id !== record.id);
+  index.revision += 1;
+}
 
-// packages/core/src/prompt/prompt.ts
-import { defineExtension as defineExtension5, section } from "@earendil-works/pi-durable";
-var KEYS = ["preamble", "rules", "project_context", "skills", "cwd"];
-var PREAMBLE = "You are an expert coding assistant operating inside neko, a coding agent harness. You help users by reading files, executing commands, editing code, and writing new files.";
-var TOOL_GUIDELINES = {
-  subagent: [
-    "Delegate only independent, sufficiently scoped work when isolation or parallelism helps. Handle simple tasks directly. Pass necessary context and user constraints; research-only requests must not become coding tasks. For related follow-up work, list and continue a suitable idle subagent using its stable agentId; busy means no task was accepted. Do not change its role. Verify and integrate reports. Do not modify files concurrently with a coder assigned those files."
-  ],
-  find_files: [
-    "Use find_files to discover files; query is a literal substring. Narrow the directory when results are partial."
-  ],
-  search_text: [
-    "Use search_text for literal text search and read for surrounding evidence. Partial results do not prove absence."
-  ],
-  read: ["Use read to examine files instead of cat or sed."],
-  write: ["Use write only for new files or complete rewrites."],
-  edit: [
-    "Use edit for precise changes (edits[].oldText must match exactly)",
-    "When changing multiple separate locations in one file, use one edit call with multiple entries in edits[] instead of multiple edit calls",
-    "Each edits[].oldText is matched against the original file, not after earlier edits are applied. Do not emit overlapping or nested edits. Merge nearby changes into one edit.",
-    "Keep edits[].oldText as small as possible while still being unique in the file. Do not pad with large unchanged regions."
-  ],
-  bash: ["Use bash for file operations like ls, rg, find"],
-  job: [
-    'Use job {action:"start", command, title?, timeout?} for long-running commands (dev servers, watchers, long builds or tests) instead of bash, which would block. Jobs have no stdin. start returns within 2 seconds, with the early result if the command already ended; a job that ends later reports back to you automatically, so do not poll. Read new output with {action:"output", jobId, since?} using the offset from the previous call, list jobs with {action:"list"}, end one with {action:"stop", jobId}. Run short commands with bash.'
-  ],
-  web_search: ["Use web_search for current information from the internet instead of guessing."],
-  web_extract: ["Use web_extract to read the full content of a web page when you have its URL."],
-  todo: [
-    `Use todo for multi-step work: {action:"list"} reads the saved list, {action:"replace", items:[{id, text, status}]} overwrites the whole ordered list (status pending, in_progress or completed; [] clears it). Keep a short list and update it as you go, keep an item's id when you update the same task, and mark it completed only after the work is actually done. If you are unsure what the list holds (for example after the context was compacted), read it with list first instead of guessing or creating a second list. Do not create a list for simple questions or one-step tasks.`
-  ],
-  ask_user: [
-    "Use ask_user {question, options?: [{id, label, description?, recommended?}], multiple?} only when you need a decision or information you cannot determine yourself from the code, the environment or a reasonable assumption; do not ask about things you can find out. Keep the question short and self-contained. Make options short, distinct and understandable on their own, mark a clear preference with recommended, and set multiple: true only when several options may apply (it needs at least 2 options). The user can always type text instead of or in addition to choosing, or skip. The call returns when the user answers or skips; do not poll. A skip is not consent or a preference: continue on your best judgment, state the assumptions you make, and do not ask the same question again unless circumstances change. Independent questions may be asked in one turn and are shown one at a time; ask dependent ones in separate turns. Never ask for passwords, API keys or other secrets. An answer is not approval to run a command and never widens tool permissions."
-  ]
-};
-var GENERIC_RULES = ["Be concise in your responses", "Show file paths clearly when working with files"];
-var WINDOWS_SHELL_RULE = "On Windows, commands run in Git Bash (not PowerShell, cmd or WSL); write paths with forward slashes, e.g. D:/code or /d/code.";
-var toolRules = (name, platform) => {
-  const rules = TOOL_GUIDELINES[name] ?? [];
-  return platform === "win32" && (name === "bash" || name === "job") ? [...rules, WINDOWS_SHELL_RULE] : rules;
-};
-var buildRules = (toolNames, platform) => {
-  const rules = [];
-  const seen = new Set;
-  for (const rule of [...toolNames.flatMap((name) => toolRules(name, platform)), ...GENERIC_RULES]) {
-    if (seen.has(rule))
-      continue;
-    seen.add(rule);
-    rules.push(`- ${rule}`);
-  }
-  return rules.join(`
-`);
-};
-var renderProjectContext = (files) => files.length === 0 ? undefined : [
-  "Project-specific instructions and guidelines:",
-  ...files.map(({ path, content }) => `<project_instructions path="${escapeXml(path)}">
-${content}
-</project_instructions>`)
-].join(`
-
-`);
-var createNekoPrompt = (loadResources, platform = process.platform) => {
-  const built = new WeakMap;
-  const build = async (input, context) => {
-    const cwd = input.agent.cwd;
-    const role = (await input.read.snapshot(SubagentDoc, input.conversationId, context))?.role;
-    const resources = cwd ? await loadResources(input.conversationId, cwd) : { contextFiles: [], skills: [] };
-    const sections = {
-      preamble: role ? ROLE_PROMPTS[role] + SUBAGENT_DELIVERY : PREAMBLE,
-      rules: buildRules(input.agent.tools.map((tool) => tool.name), platform),
-      project_context: renderProjectContext(resources.contextFiles),
-      skills: formatSkillsForPrompt(resources.skills) || undefined,
-      cwd: cwd?.replace(/\\/g, "/")
-    };
-    return sections;
-  };
-  return defineExtension5({
-    name: "neko-prompt",
-    sections: KEYS.map((key) => section(key, async (input, context) => {
-      let pending = built.get(input);
-      if (!pending) {
-        pending = build(input, context);
-        built.set(input, pending);
-      }
-      const text = (await pending)[key];
-      if (text === undefined)
+class UserQuestions {
+  harness;
+  #tracked = new Set;
+  #context;
+  #running = false;
+  #dirty = false;
+  constructor(harness, context) {
+    this.harness = harness;
+    this.#context = context;
+    const stop = harness.subscribeCommits(({ changes }) => {
+      if (!changes.some((c) => c.type === "task" && (c.value.abortRequested || c.value.state.status === "terminal")))
         return;
-      return key === "preamble" ? text : `<${key}>
-${text}
-</${key}>`;
-    }, { tag: false }))
-  });
-};
-
-// packages/core/src/prompt/resources.ts
-import { existsSync as existsSync2 } from "fs";
-import { readFile as readFile3 } from "fs/promises";
-import { homedir as homedir3 } from "os";
-import { join as join4 } from "path";
-import { fileURLToPath } from "url";
-var userAgentsFile = (home) => join4(home, ".agents", "AGENTS.md");
-var userSkillsDir = (home) => join4(home, ".agents", "skills");
-var workspaceAgentsFile = (workspace) => join4(workspace, "AGENTS.md");
-var workspaceSkillsDir = (workspace) => join4(workspace, ".agents", "skills");
-var resolveBuiltinSkillsDir = () => {
-  for (const url of [new URL("./skills/", import.meta.url), new URL("../../skills/", import.meta.url)]) {
-    const path = fileURLToPath(url);
-    if (existsSync2(join4(path, "skill-creator", "SKILL.md")))
-      return path;
+      this.reconcileAll();
+    });
+    harness.closed.finally(stop).catch(() => {});
   }
-  return null;
-};
-var BUILTIN_SKILLS_DIR = resolveBuiltinSkillsDir();
-var readResources = async (workspace, home, builtinDir, report, invocationName) => {
-  const contextFiles = [];
-  for (const path of [userAgentsFile(home), workspaceAgentsFile(workspace)]) {
+  track(...ids) {
+    for (const id of ids)
+      this.#tracked.add(id);
+  }
+  async reconcileAll() {
+    if (this.#running) {
+      this.#dirty = true;
+      return;
+    }
+    this.#running = true;
     try {
-      const content = (await readFile3(path, "utf8")).replace(/^\uFEFF/, "");
-      if (Buffer.byteLength(content, "utf8") > 64 * 1024)
-        report({
-          path,
-          message: "Project instructions exceed 64 KiB; included in full. History compaction does not reduce this input."
-        });
-      contextFiles.push({ path, content });
-    } catch (error) {
-      if (!isMissing(error))
-        report({ path, message: "Cannot read project instructions; skipped." });
+      do {
+        this.#dirty = false;
+        for (const id of [...this.#tracked])
+          await this.reconcile(id, this.#context).catch(() => {});
+      } while (this.#dirty);
+    } finally {
+      this.#running = false;
     }
   }
-  const candidates = invocationName === undefined ? undefined : new Map;
-  const capture = candidates ? (skill, content) => {
-    if (skill.name === invocationName)
-      candidates.set(skill.filePath, content);
-  } : undefined;
-  const scan = async (dir, level) => (await scanSkillsDir(dir, report, capture)).map((skill) => ({ ...skill, level }));
-  const [builtin, user, project] = await Promise.all([
-    builtinDir === null ? Promise.resolve([]) : scan(builtinDir, "builtin"),
-    scan(userSkillsDir(home), "user"),
-    scan(workspaceSkillsDir(workspace), "project")
-  ]);
-  const skills = mergeSkills([builtin, user, project]);
-  const winner = invocationName === undefined ? undefined : skills.find((skill) => skill.name === invocationName);
-  if (winner && candidates) {
-    const content = candidates.get(winner.filePath);
-    if (content !== undefined)
-      return { contextFiles, skills, invocation: { filePath: winner.filePath, content } };
+  async reconcile(conversationId, context) {
+    const index = await this.harness.snapshot(QuestionsDoc, conversationId, context);
+    if (!index?.pending.length)
+      return;
+    await this.harness.commit((tx) => this.#reconcile(tx, conversationId), context);
   }
-  return { contextFiles, skills };
-};
-var createResourceLoader = (home = homedir3(), report = warnPromptDiagnostic, options) => {
-  const builtinDir = options?.builtinDir === undefined ? BUILTIN_SKILLS_DIR : options.builtinDir;
-  const previous = new Map;
-  return async (workspace, invocationName) => {
-    const diagnostics = [];
-    const resources = await readResources(workspace, home, builtinDir, (d) => diagnostics.push(d), invocationName);
-    const known = previous.get(workspace);
-    const current = new Set;
-    for (const diagnostic of diagnostics) {
-      const key = JSON.stringify(diagnostic);
-      if (!known?.has(key) && !current.has(key))
-        report(diagnostic);
-      current.add(key);
-    }
-    if (current.size)
-      previous.set(workspace, current);
-    else
-      previous.delete(workspace);
-    return resources;
-  };
-};
-var scanSkillsByLevel = async (workspace, home = homedir3(), builtinDir = BUILTIN_SKILLS_DIR, report = warnPromptDiagnostic) => {
-  const scan = async (dir, level) => (await scanSkillsDir(dir, report)).map((skill) => ({ ...skill, level }));
-  const [builtin, user, project] = await Promise.all([
-    builtinDir === null ? [] : scan(builtinDir, "builtin"),
-    scan(userSkillsDir(home), "user"),
-    scan(workspaceSkillsDir(workspace), "project")
-  ]);
-  return [...project, ...user, ...builtin];
-};
-
-// packages/core/src/prompt/snapshots.ts
-var createResourceSnapshots = (load, submission) => {
-  const conversations = new Map;
-  const stateFor = (id, workspace) => {
-    let state = conversations.get(id);
-    if (!state || state.workspace !== workspace) {
-      state = { workspace, pending: new Map };
-      conversations.set(id, state);
-    }
-    return state;
-  };
-  return {
-    stage(id, requestId, workspace, resources) {
-      stateFor(id, workspace).pending.set(requestId, {
-        contextFiles: resources.contextFiles,
-        skills: resources.skills
-      });
-    },
-    async current(id, workspace) {
-      const state = stateFor(id, workspace);
-      for (const [requestId, snapshot] of state.pending) {
-        const record = await submission(id, requestId);
-        if (!record || record.status === "queued")
-          continue;
-        state.pending.delete(requestId);
-        if (record.type !== "input" || record.entry === undefined)
-          continue;
-        if (state.entry === undefined || record.entry > state.entry) {
-          state.active = snapshot;
-          state.entry = record.entry;
-        }
-      }
-      state.active ??= load(workspace);
-      return state.active;
-    },
-    discard(id, requestId) {
-      conversations.get(id)?.pending.delete(requestId);
-    },
-    move(id, from, to) {
-      const pending = conversations.get(id)?.pending;
-      const snapshot = pending?.get(from);
-      if (!pending || !snapshot)
-        return;
-      pending.delete(from);
-      pending.set(to, snapshot);
-    },
-    forget(id) {
-      conversations.delete(id);
-    }
-  };
-};
-
-// packages/core/src/session-metadata.ts
-import { stripVTControlCharacters } from "util";
-import { getSupportedThinkingLevels } from "@earendil-works/pi-ai";
-import {
-  defineDoc as defineDoc4,
-  defineExtension as defineExtension7,
-  defineTask as defineTask3,
-  InboxDoc,
-  LiveDoc as LiveDoc2
-} from "@earendil-works/pi-durable";
-
-// packages/core/src/user-questions.ts
-import { randomUUID } from "crypto";
-import {
-  defineDoc as defineDoc3,
-  defineDocFamily,
-  defineExtension as defineExtension6,
-  defineTool as defineTool4
-} from "@earendil-works/pi-durable";
-import { Type as Type4 } from "typebox";
-var QuestionDoc = defineDocFamily({
-  kind: "app.neko.question",
-  version: 1,
-  scope: "conversation",
-  history: "latest",
-  fork: "initial",
-  family: true,
-  initial: (seed) => seed
-});
-var QuestionsDoc = defineDoc3({
-  kind: "app.neko.questions",
-  version: 1,
-  scope: "conversation",
-  history: "latest",
-  fork: "initial",
-  initial: () => ({ revision: 0, pending: [] })
-});
-var clone = (value) => JSON.parse(JSON.stringify(value));
-var MISSING = {
-  id: 0,
-  callId: "",
-  version: "",
-  question: "",
-  multiple: false,
-  options: [],
-  status: "pending",
-  answer: null,
-  createdAt: 0,
-  settledAt: null
-};
-var argsOf = (record) => ({
-  question: record.question,
-  multiple: record.multiple,
-  options: clone(record.options)
-});
-async function live(tx, id) {
-  let cursor = id;
-  for (let depth = 0;cursor !== undefined && depth < 16; depth++) {
-    const task = await tx.task(cursor);
-    if (!task || task.abortRequested || task.state.status === "terminal" || task.state.status === "completing")
-      return false;
-    cursor = task.owner;
-  }
-  return true;
-}
-function settle(record, index, status) {
-  record.status = status;
-  record.settledAt = Date.now();
-  index.pending = index.pending.filter((id) => id !== record.id);
-  index.revision += 1;
-}
-
-class UserQuestions {
-  harness;
-  #tracked = new Set;
-  #context;
-  #running = false;
-  #dirty = false;
-  constructor(harness, context) {
-    this.harness = harness;
-    this.#context = context;
-    const stop = harness.subscribeCommits(({ changes }) => {
-      if (!changes.some((c) => c.type === "task" && (c.value.abortRequested || c.value.state.status === "terminal")))
-        return;
-      this.reconcileAll();
-    });
-    harness.closed.finally(stop).catch(() => {});
-  }
-  track(...ids) {
-    for (const id of ids)
-      this.#tracked.add(id);
-  }
-  async reconcileAll() {
-    if (this.#running) {
-      this.#dirty = true;
-      return;
-    }
-    this.#running = true;
-    try {
-      do {
-        this.#dirty = false;
-        for (const id of [...this.#tracked])
-          await this.reconcile(id, this.#context).catch(() => {});
-      } while (this.#dirty);
-    } finally {
-      this.#running = false;
-    }
-  }
-  async reconcile(conversationId, context) {
-    const index = await this.harness.snapshot(QuestionsDoc, conversationId, context);
-    if (!index?.pending.length)
-      return;
-    await this.harness.commit((tx) => this.#reconcile(tx, conversationId), context);
-  }
-  async#reconcile(tx, conversationId) {
-    const index = await tx.doc(QuestionsDoc, conversationId);
-    const stale = [];
-    for (const id of index.pending) {
-      const record = await tx.doc(QuestionDoc, conversationId, String(id), MISSING);
-      if (record.version === "" || record.status !== "pending")
-        stale.push(id);
-      else if (!await live(tx, id)) {
-        record.status = "cancelled";
-        record.settledAt = Date.now();
-        stale.push(id);
+  async#reconcile(tx, conversationId) {
+    const index = await tx.doc(QuestionsDoc, conversationId);
+    const stale = [];
+    for (const id of index.pending) {
+      const record = await tx.doc(QuestionDoc, conversationId, String(id), MISSING);
+      if (record.version === "" || record.status !== "pending")
+        stale.push(id);
+      else if (!await live(tx, id)) {
+        record.status = "cancelled";
+        record.settledAt = Date.now();
+        stale.push(id);
       }
     }
     if (!stale.length)
@@ -20439,71 +20263,717 @@ function questionOutput(record) {
     return lines.join(`
 `);
   }
-  if (record.status === "skipped")
-    return "The user skipped this question without answering. This is not approval, rejection or a preference. Continue with your best judgment and state the assumptions you make, or continue without this information. Do not ask the same question again unless circumstances change.";
-  return "The question was cancelled because the run was stopped. No answer was given.";
-}
-function outcomeOf(record) {
-  if (record.status === "answered" && record.answer)
-    return {
-      status: "answered",
-      optionIds: record.answer.optionIds,
-      labels: answerLabels(record, record.answer),
-      text: record.answer.text
-    };
-  return { status: record.status === "skipped" ? "skipped" : "cancelled" };
-}
-function questionDetails(record) {
-  const base = {
-    id: record.id,
-    question: record.question,
-    multiple: record.multiple,
-    options: record.options.map((o) => ({
-      id: o.id,
-      label: o.label,
-      ...o.recommended ? { recommended: true } : {}
-    }))
+  if (record.status === "skipped")
+    return "The user skipped this question without answering. This is not approval, rejection or a preference. Continue with your best judgment and state the assumptions you make, or continue without this information. Do not ask the same question again unless circumstances change.";
+  return "The question was cancelled because the run was stopped. No answer was given.";
+}
+function outcomeOf(record) {
+  if (record.status === "answered" && record.answer)
+    return {
+      status: "answered",
+      optionIds: record.answer.optionIds,
+      labels: answerLabels(record, record.answer),
+      text: record.answer.text
+    };
+  return { status: record.status === "skipped" ? "skipped" : "cancelled" };
+}
+function questionDetails(record) {
+  const base = {
+    id: record.id,
+    question: record.question,
+    multiple: record.multiple,
+    options: record.options.map((o) => ({
+      id: o.id,
+      label: o.label,
+      ...o.recommended ? { recommended: true } : {}
+    }))
+  };
+  return record.status === "pending" ? { ...base, status: "pending" } : { ...base, ...outcomeOf(record) };
+}
+function createAskUserTool(service) {
+  return defineTool4({
+    name: "ask_user",
+    description: "Ask the user one question and wait for the answer. question: the text. options: optional [{id, label, description?, recommended?}]; multiple: true lets the user pick several (needs 2+ options). The user can always type text instead of or in addition to choosing, or skip. Use only when you need a decision or information you cannot determine yourself. The call returns when the user answers or skips; do not poll.",
+    parameters: parameters3,
+    structuredOutputSchema: structuredOutputSchema2,
+    replay: "safe",
+    executionMode: "sequential",
+    callers: ["model"],
+    execute: async (input, api, context) => {
+      context.abortSignal?.throwIfAborted();
+      if ((await api.snapshot(SubagentDoc, api.conversationId, context))?.role)
+        throw new Error("Subagents cannot ask the user; report the missing information to the main agent.");
+      let args;
+      try {
+        args = validateQuestionArgs(input);
+      } catch (error) {
+        if (error instanceof InteractionInputError)
+          throw new Error(`Invalid ask_user arguments: ${error.message}`);
+        throw error;
+      }
+      const questions = service();
+      const created = await questions.ensure(api.conversationId, api.taskId, api.callId, args, context);
+      await api.details(questionDetails(created), context);
+      const record = created.status === "pending" ? await questions.wait(api.conversationId, api.taskId, context) : created;
+      return {
+        output: [{ type: "text", text: questionOutput(record) }],
+        structuredOutput: outcomeOf(record),
+        details: questionDetails(record),
+        isError: record.status === "cancelled"
+      };
+    }
+  });
+}
+var createQuestionExtension = (service) => defineExtension5({ name: "neko-questions", tools: [createAskUserTool(service)] });
+
+// packages/core/src/plan.ts
+var PLAN_REMOVED_TOOLS = ["edit", "write", "job"];
+var PLAN_INSTRUCTIONS = [
+  "You are in plan mode: research and plan only, and change nothing.",
+  "- Allowed: read, find_files, search_text, web_search, web_extract, todo, ask_user, read-only subagents (explore, plan) and bash limited to read-only commands (listing, searching, git log/diff/status, version checks). Other commands are rejected.",
+  "- Not available: edit, write, job and any command that modifies files, installs packages or starts processes. Do not try to work around this.",
+  "- When you understand the task, call submit_plan once, alone in its turn, with a short title, ordered concrete steps and an optional note (risks, assumptions, verification). The user then approves it or asks for changes.",
+  "- After submit_plan do nothing else. If the user asks for changes, research what is needed and submit a revised plan.",
+  "- Use ask_user only for decisions you cannot settle by reading the code."
+].join(`
+`);
+var PLAN_BUSY = "PLAN_BUSY: Wait for the current run to finish or stop it first.";
+function planAgentChange(mode) {
+  if (mode === "normal")
+    return { tools: null, modelTools: null, instructions: null };
+  const named = (name) => ({ name });
+  return {
+    tools: { remove: PLAN_REMOVED_TOOLS.map(named) },
+    modelTools: { add: [named("submit_plan")] },
+    instructions: PLAN_INSTRUCTIONS
+  };
+}
+var agentInPlanMode = (agent) => agent.instructions === PLAN_INSTRUCTIONS;
+var clone2 = (value) => JSON.parse(JSON.stringify(value));
+var toRecord = ({ taskId: _taskId, dispatched: _dispatched, ...record }) => clone2(record);
+function settle2(state, item, status) {
+  item.status = status;
+  item.settledAt = Date.now();
+  state.revision += 1;
+}
+
+class PlanService {
+  harness;
+  #context;
+  constructor(harness, context) {
+    this.harness = harness;
+    this.#context = context;
+  }
+  async#state(id) {
+    return this.harness.snapshot(PlanDoc, id, this.#context);
+  }
+  async mode(id) {
+    return (await this.#state(id))?.mode ?? "normal";
+  }
+  async view(id) {
+    const state = await this.#state(id);
+    const current = state?.items.at(-1);
+    return {
+      mode: state?.mode ?? "normal",
+      revision: state?.revision ?? 0,
+      current: current ? toRecord(current) : null
+    };
+  }
+  async get(id, version) {
+    const item = (await this.#state(id))?.items.find((i) => i.version === version);
+    return item ? toRecord(item) : undefined;
+  }
+  async awaiting(id) {
+    const item = (await this.#state(id))?.items.find((i) => i.status === "awaiting_approval");
+    return item ? toRecord(item) : undefined;
+  }
+  async setMode(id, mode) {
+    return this.harness.commit(async (tx) => {
+      const state = await tx.doc(PlanDoc, id);
+      let changed = false;
+      if (state.mode !== mode) {
+        state.mode = mode;
+        state.revision += 1;
+        changed = true;
+      }
+      if (mode === "normal") {
+        for (const item of state.items)
+          if (item.status === "awaiting_approval") {
+            settle2(state, item, "cancelled");
+            changed = true;
+          }
+      }
+      return changed;
+    }, this.#context);
+  }
+  async submit(id, taskId, args, context) {
+    return this.harness.commit(async (tx) => {
+      if (!await live(tx, taskId))
+        throw new Error("Task stopped");
+      const state = await tx.doc(PlanDoc, id);
+      const existing = state.items.find((item) => item.taskId === taskId);
+      if (existing) {
+        if (existing.title !== args.title || existing.note !== args.note || JSON.stringify(existing.steps) !== JSON.stringify(args.steps))
+          throw new Error("Plan operation changed; a new call is required.");
+        return toRecord(existing);
+      }
+      if (state.mode !== "plan")
+        throw new Error("submit_plan is only available in plan mode.");
+      for (const item of state.items)
+        if (item.status === "awaiting_approval")
+          settle2(state, item, "superseded");
+      const item = {
+        version: randomUUID2(),
+        title: args.title,
+        steps: [...args.steps],
+        note: args.note,
+        status: "awaiting_approval",
+        feedback: null,
+        createdAt: Date.now(),
+        settledAt: null,
+        taskId,
+        dispatched: false
+      };
+      state.items.push(item);
+      if (state.items.length > PLAN_HISTORY)
+        state.items.splice(0, state.items.length - PLAN_HISTORY);
+      state.revision += 1;
+      return toRecord(item);
+    }, context);
+  }
+  async decide(id, version, decision) {
+    return this.harness.commit(async (tx) => {
+      const state = await tx.doc(PlanDoc, id);
+      const item = state.items.find((i) => i.version === version);
+      if (!item)
+        throw new Error("Plan not found.");
+      if (item.status === "awaiting_approval") {
+        if (decision.kind === "approve") {
+          settle2(state, item, "approved");
+          state.mode = "normal";
+        } else {
+          settle2(state, item, "revision_requested");
+          item.feedback = decision.feedback;
+        }
+      }
+      return { record: toRecord(item), item: clone2(item) };
+    }, this.#context);
+  }
+  async supersedePending(id) {
+    if (await this.awaiting(id))
+      await this.#cancel(id, "superseded");
+  }
+  async cancelPending(id) {
+    if (await this.awaiting(id))
+      await this.#cancel(id, "cancelled");
+  }
+  async#cancel(id, status) {
+    await this.harness.commit(async (tx) => {
+      const state = await tx.doc(PlanDoc, id);
+      for (const item of state.items)
+        if (item.status === "awaiting_approval")
+          settle2(state, item, status);
+    }, this.#context);
+  }
+  async undispatched(id) {
+    const item = (await this.#state(id))?.items.findLast((i) => (i.status === "approved" || i.status === "revision_requested") && !i.dispatched);
+    return item ? clone2(item) : undefined;
+  }
+  async markDispatched(id, version) {
+    await this.harness.commit(async (tx) => {
+      const item = (await tx.doc(PlanDoc, id)).items.find((i) => i.version === version);
+      if (item)
+        item.dispatched = true;
+    }, this.#context);
+  }
+}
+function approvedPlanPrompt(plan) {
+  return [
+    `The user approved your plan "${plan.title}". Plan mode is off: edit, write and all commands are available again. Execute the plan now, step by step:`,
+    ...plan.steps.map((step, index) => `${index + 1}. ${step}`),
+    ...plan.note ? ["", `Notes: ${plan.note}`] : [],
+    "",
+    "Use the todo tool to track progress, and verify the result when you are done."
+  ].join(`
+`);
+}
+function planRevisionPrompt(plan, feedback) {
+  return [
+    `The user asked for changes to your plan "${plan.title}". Do not start implementing; you are still in plan mode.`,
+    "",
+    feedback,
+    "",
+    "Research what you need, then call submit_plan with the revised plan."
+  ].join(`
+`);
+}
+var parameters4 = Type5.Object({
+  title: Type5.String({ minLength: 1, maxLength: PLAN_LIMITS.titleChars, description: "Short name of the plan." }),
+  steps: Type5.Array(Type5.String({ minLength: 1, maxLength: PLAN_LIMITS.stepChars }), {
+    minItems: 1,
+    maxItems: PLAN_LIMITS.maxSteps,
+    description: "Ordered, concrete implementation steps."
+  }),
+  note: Type5.Optional(Type5.String({ maxLength: PLAN_LIMITS.noteChars, description: "Risks, assumptions and how to verify." }))
+}, { additionalProperties: false });
+function submitPlanTool(service) {
+  return defineTool5({
+    name: "submit_plan",
+    description: "Submit your implementation plan for the user's approval. title: short name. steps: ordered, concrete steps. note: optional risks, assumptions and verification. Call it once, as the only tool call of its turn, when your research is done; the turn ends and the user approves it or asks for changes.",
+    parameters: parameters4,
+    deferred: true,
+    replay: "safe",
+    executionMode: "sequential",
+    callers: ["model"],
+    execute: async (input, api, context) => {
+      context.abortSignal?.throwIfAborted();
+      if ((await api.snapshot(SubagentDoc, api.conversationId, context))?.role)
+        throw new Error("Subagents cannot submit plans; report your findings to the main agent.");
+      let args;
+      try {
+        args = validatePlanArgs(input);
+      } catch (error) {
+        if (error instanceof InteractionInputError)
+          throw new Error(`Invalid submit_plan arguments: ${error.message}`);
+        throw error;
+      }
+      let record = await service().submit(api.conversationId, api.taskId, args, context);
+      const inbox = await api.snapshot(InboxDoc, api.conversationId, context);
+      if (record.status === "awaiting_approval" && inbox?.items.some((item) => queuedUserInput(item))) {
+        await service().supersedePending(api.conversationId);
+        record = await service().get(api.conversationId, record.version) ?? record;
+      }
+      const details = {
+        version: record.version,
+        title: record.title,
+        steps: record.steps,
+        note: record.note
+      };
+      return {
+        output: [
+          {
+            type: "text",
+            text: "Plan submitted. It now waits for the user's decision. Stop here: do not call other tools or continue the work."
+          }
+        ],
+        details,
+        control: { terminate: true }
+      };
+    }
+  });
+}
+var unsafeBash = (command) => `Plan mode is read-only, so this command was not run (it is not on the read-only allowlist): ${command}
+Use read, find_files or search_text, run a read-only command, or ask the user. If the command is needed, put it in the plan.`;
+var blockedTool = (name) => `Plan mode is read-only: ${name} is unavailable. Research with read-only tools, then call submit_plan.`;
+var createPlanExtension = (service) => defineExtension6({
+  name: "neko-plan",
+  tools: [submitPlanTool(service)],
+  hooks: [
+    hook2(ToolTask2, {
+      beforeTool: async (call, api, context) => {
+        if ((await api.snapshot(PlanDoc, api.conversationId, context))?.mode !== "plan")
+          return;
+        if (PLAN_REMOVED_TOOLS.includes(call.name))
+          return { block: blockedTool(call.name) };
+        if (call.name === "bash") {
+          const command = String(call.arguments.command ?? "");
+          if (!isSafeCommand(command))
+            return { block: unsafeBash(command) };
+        }
+      }
+    })
+  ],
+  wraps: [
+    wrapTool(createBashTool(), (bash) => ({
+      ...bash,
+      execute: async (args, api, context) => {
+        if ((await api.snapshot(PlanDoc, api.conversationId, context))?.mode === "plan" && !isSafeCommand(args.command))
+          throw new Error(unsafeBash(args.command));
+        return bash.execute(args, api, context);
+      }
+    }))
+  ]
+});
+
+// packages/core/src/prompt/invoke.ts
+import { dirname as dirname4 } from "path";
+
+// packages/core/src/prompt/diagnostics.ts
+var ignorePromptDiagnostic = () => {};
+var warnPromptDiagnostic = ({ path, message }) => {
+  console.warn(`[neko-prompt] ${JSON.stringify(path)}: ${message}`);
+};
+var isMissing = (error) => typeof error === "object" && error !== null && ("code" in error) && (error.code === "ENOENT" || error.code === "ENOTDIR");
+
+// packages/core/src/prompt/skills.ts
+import { readdir, readFile as readFile2 } from "fs/promises";
+import { basename, dirname as dirname3, join as join3 } from "path";
+var MAX_NAME_LENGTH = 64;
+var MAX_DESCRIPTION_LENGTH = 1024;
+var parseSkillFile = (content, filePath, report = ignorePromptDiagnostic) => {
+  const skip = (message) => {
+    report({ path: filePath, message });
+    return null;
+  };
+  try {
+    const { frontmatter } = parseFrontmatter(content);
+    const description = frontmatter.description;
+    if (typeof description !== "string" || description.trim() === "")
+      return skip("Skill description is missing or empty; skipped.");
+    if (description.length > MAX_DESCRIPTION_LENGTH)
+      return skip("Skill description is too long; skipped.");
+    const name = typeof frontmatter.name === "string" && frontmatter.name.trim() !== "" ? frontmatter.name : basename(dirname3(filePath));
+    if (name.length > MAX_NAME_LENGTH || /[\s\p{Cc}]/u.test(name))
+      return skip("Skill name is too long or contains whitespace/control characters; skipped.");
+    return {
+      name,
+      description,
+      filePath,
+      disableModelInvocation: frontmatter["disable-model-invocation"] === true
+    };
+  } catch {
+    return skip("Invalid skill frontmatter; skipped.");
+  }
+};
+var scanSkillsDir = async (dir, report = ignorePromptDiagnostic, capture) => {
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch (error) {
+    if (!isMissing(error))
+      report({ path: dir, message: "Cannot scan skills directory; skipped." });
+    return [];
+  }
+  const skills = [];
+  for (const entry of entries.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0)) {
+    if (!entry.isDirectory())
+      continue;
+    const filePath = join3(dir, entry.name, "SKILL.md");
+    let content;
+    try {
+      content = await readFile2(filePath, "utf8");
+    } catch (error) {
+      if (!isMissing(error))
+        report({ path: filePath, message: "Cannot read skill; skipped." });
+      continue;
+    }
+    const skill = parseSkillFile(content, filePath, report);
+    if (skill) {
+      skills.push(skill);
+      capture?.(skill, content);
+    }
+  }
+  return skills;
+};
+var mergeSkills = (groups) => {
+  const byName = new Map;
+  for (const group of groups)
+    for (const skill of group)
+      byName.set(skill.name, skill);
+  return [...byName.values()];
+};
+var escapeXml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+var formatSkillsForPrompt = (skills) => {
+  const visible = skills.filter((skill) => !skill.disableModelInvocation);
+  if (visible.length === 0)
+    return "";
+  const lines = [
+    "The following skills provide specialized instructions for specific tasks.",
+    "Use the read tool to load a skill's file when the task matches its description.",
+    "When a skill file references a relative path, resolve it against the skill directory (parent of SKILL.md) and use that absolute path in tool commands.",
+    "",
+    "<available_skills>"
+  ];
+  for (const skill of visible) {
+    lines.push("  <skill>");
+    lines.push(`    <name>${escapeXml(skill.name)}</name>`);
+    lines.push(`    <description>${escapeXml(skill.description)}</description>`);
+    lines.push(`    <location>${escapeXml(skill.filePath)}</location>`);
+    lines.push("  </skill>");
+  }
+  lines.push("</available_skills>");
+  return lines.join(`
+`);
+};
+
+// packages/core/src/prompt/invoke.ts
+var expandSkillCommand = async (text, skills, readFile, report = warnPromptDiagnostic, metadata) => {
+  if (!text.startsWith("/skill:"))
+    return text;
+  const spaceIndex = text.indexOf(" ");
+  const skillName = spaceIndex === -1 ? text.slice(7) : text.slice(7, spaceIndex);
+  const args = spaceIndex === -1 ? "" : text.slice(spaceIndex + 1).trim();
+  const skill = skills.find((s) => s.name === skillName);
+  if (!skill)
+    return text;
+  let body;
+  try {
+    body = stripFrontmatter(await readFile(skill.filePath)).trim();
+  } catch {
+    report({ path: skill.filePath, message: "Cannot expand known skill; original input preserved." });
+    return text;
+  }
+  metadata?.({
+    name: skill.name,
+    location: skill.filePath,
+    body: `References are relative to ${dirname4(skill.filePath)}.
+
+${body}`,
+    args
+  });
+  const block = `<skill name="${escapeXml(skill.name)}" location="${escapeXml(skill.filePath)}">
+References are relative to ${dirname4(skill.filePath)}.
+
+${body}
+</skill>`;
+  return args ? `${block}
+
+${args}` : block;
+};
+
+// packages/core/src/prompt/prompt.ts
+import { defineExtension as defineExtension7, section } from "@earendil-works/pi-durable";
+var KEYS = ["preamble", "rules", "project_context", "skills", "cwd"];
+var PREAMBLE = "You are an expert coding assistant operating inside neko, a coding agent harness. You help users by reading files, executing commands, editing code, and writing new files.";
+var TOOL_GUIDELINES = {
+  subagent: [
+    "Delegate only independent, sufficiently scoped work when isolation or parallelism helps. Handle simple tasks directly. Pass necessary context and user constraints; research-only requests must not become coding tasks. For related follow-up work, list and continue a suitable idle subagent using its stable agentId; busy means no task was accepted. Do not change its role. Verify and integrate reports. Do not modify files concurrently with a coder assigned those files."
+  ],
+  find_files: [
+    "Use find_files to discover files; query is a literal substring. Narrow the directory when results are partial."
+  ],
+  search_text: [
+    "Use search_text for literal text search and read for surrounding evidence. Partial results do not prove absence."
+  ],
+  read: ["Use read to examine files instead of cat or sed."],
+  write: ["Use write only for new files or complete rewrites."],
+  edit: [
+    "Use edit for precise changes (edits[].oldText must match exactly)",
+    "When changing multiple separate locations in one file, use one edit call with multiple entries in edits[] instead of multiple edit calls",
+    "Each edits[].oldText is matched against the original file, not after earlier edits are applied. Do not emit overlapping or nested edits. Merge nearby changes into one edit.",
+    "Keep edits[].oldText as small as possible while still being unique in the file. Do not pad with large unchanged regions."
+  ],
+  bash: ["Use bash for file operations like ls, rg, find"],
+  job: [
+    'Use job {action:"start", command, title?, timeout?} for long-running commands (dev servers, watchers, long builds or tests) instead of bash, which would block. Jobs have no stdin. start returns within 2 seconds, with the early result if the command already ended; a job that ends later reports back to you automatically, so do not poll. Read new output with {action:"output", jobId, since?} using the offset from the previous call, list jobs with {action:"list"}, end one with {action:"stop", jobId}. Run short commands with bash.'
+  ],
+  web_search: ["Use web_search for current information from the internet instead of guessing."],
+  web_extract: ["Use web_extract to read the full content of a web page when you have its URL."],
+  todo: [
+    `Use todo for multi-step work: {action:"list"} reads the saved list, {action:"replace", items:[{id, text, status}]} overwrites the whole ordered list (status pending, in_progress or completed; [] clears it). Keep a short list and update it as you go, keep an item's id when you update the same task, and mark it completed only after the work is actually done. If you are unsure what the list holds (for example after the context was compacted), read it with list first instead of guessing or creating a second list. Do not create a list for simple questions or one-step tasks.`
+  ],
+  ask_user: [
+    "Use ask_user {question, options?: [{id, label, description?, recommended?}], multiple?} only when you need a decision or information you cannot determine yourself from the code, the environment or a reasonable assumption; do not ask about things you can find out. Keep the question short and self-contained. Make options short, distinct and understandable on their own, mark a clear preference with recommended, and set multiple: true only when several options may apply (it needs at least 2 options). The user can always type text instead of or in addition to choosing, or skip. The call returns when the user answers or skips; do not poll. A skip is not consent or a preference: continue on your best judgment, state the assumptions you make, and do not ask the same question again unless circumstances change. Independent questions may be asked in one turn and are shown one at a time; ask dependent ones in separate turns. Never ask for passwords, API keys or other secrets. An answer is not approval to run a command and never widens tool permissions."
+  ]
+};
+var GENERIC_RULES = ["Be concise in your responses", "Show file paths clearly when working with files"];
+var WINDOWS_SHELL_RULE = "On Windows, commands run in Git Bash (not PowerShell, cmd or WSL); write paths with forward slashes, e.g. D:/code or /d/code.";
+var toolRules = (name, platform) => {
+  const rules = TOOL_GUIDELINES[name] ?? [];
+  return platform === "win32" && (name === "bash" || name === "job") ? [...rules, WINDOWS_SHELL_RULE] : rules;
+};
+var buildRules = (toolNames, platform) => {
+  const rules = [];
+  const seen = new Set;
+  for (const rule of [...toolNames.flatMap((name) => toolRules(name, platform)), ...GENERIC_RULES]) {
+    if (seen.has(rule))
+      continue;
+    seen.add(rule);
+    rules.push(`- ${rule}`);
+  }
+  return rules.join(`
+`);
+};
+var renderProjectContext = (files) => files.length === 0 ? undefined : [
+  "Project-specific instructions and guidelines:",
+  ...files.map(({ path, content }) => `<project_instructions path="${escapeXml(path)}">
+${content}
+</project_instructions>`)
+].join(`
+
+`);
+var createNekoPrompt = (loadResources, platform = process.platform) => {
+  const built = new WeakMap;
+  const build = async (input, context) => {
+    const cwd = input.agent.cwd;
+    const role = (await input.read.snapshot(SubagentDoc, input.conversationId, context))?.role;
+    const resources = cwd ? await loadResources(input.conversationId, cwd) : { contextFiles: [], skills: [] };
+    const sections = {
+      preamble: role ? ROLE_PROMPTS[role] + SUBAGENT_DELIVERY : PREAMBLE,
+      rules: buildRules(input.agent.tools.map((tool) => tool.name), platform),
+      project_context: renderProjectContext(resources.contextFiles),
+      skills: formatSkillsForPrompt(resources.skills) || undefined,
+      cwd: cwd?.replace(/\\/g, "/")
+    };
+    return sections;
+  };
+  return defineExtension7({
+    name: "neko-prompt",
+    sections: KEYS.map((key) => section(key, async (input, context) => {
+      let pending = built.get(input);
+      if (!pending) {
+        pending = build(input, context);
+        built.set(input, pending);
+      }
+      const text = (await pending)[key];
+      if (text === undefined)
+        return;
+      return key === "preamble" ? text : `<${key}>
+${text}
+</${key}>`;
+    }, { tag: false }))
+  });
+};
+
+// packages/core/src/prompt/resources.ts
+import { existsSync as existsSync2 } from "fs";
+import { readFile as readFile3 } from "fs/promises";
+import { homedir as homedir3 } from "os";
+import { join as join4 } from "path";
+import { fileURLToPath } from "url";
+var userAgentsFile = (home) => join4(home, ".agents", "AGENTS.md");
+var userSkillsDir = (home) => join4(home, ".agents", "skills");
+var workspaceAgentsFile = (workspace) => join4(workspace, "AGENTS.md");
+var workspaceSkillsDir = (workspace) => join4(workspace, ".agents", "skills");
+var resolveBuiltinSkillsDir = () => {
+  for (const url of [new URL("./skills/", import.meta.url), new URL("../../skills/", import.meta.url)]) {
+    const path = fileURLToPath(url);
+    if (existsSync2(join4(path, "skill-creator", "SKILL.md")))
+      return path;
+  }
+  return null;
+};
+var BUILTIN_SKILLS_DIR = resolveBuiltinSkillsDir();
+var readResources = async (workspace, home, builtinDir, report, invocationName) => {
+  const contextFiles = [];
+  for (const path of [userAgentsFile(home), workspaceAgentsFile(workspace)]) {
+    try {
+      const content = (await readFile3(path, "utf8")).replace(/^\uFEFF/, "");
+      if (Buffer.byteLength(content, "utf8") > 64 * 1024)
+        report({
+          path,
+          message: "Project instructions exceed 64 KiB; included in full. History compaction does not reduce this input."
+        });
+      contextFiles.push({ path, content });
+    } catch (error) {
+      if (!isMissing(error))
+        report({ path, message: "Cannot read project instructions; skipped." });
+    }
+  }
+  const candidates = invocationName === undefined ? undefined : new Map;
+  const capture = candidates ? (skill, content) => {
+    if (skill.name === invocationName)
+      candidates.set(skill.filePath, content);
+  } : undefined;
+  const scan = async (dir, level) => (await scanSkillsDir(dir, report, capture)).map((skill) => ({ ...skill, level }));
+  const [builtin, user, project] = await Promise.all([
+    builtinDir === null ? Promise.resolve([]) : scan(builtinDir, "builtin"),
+    scan(userSkillsDir(home), "user"),
+    scan(workspaceSkillsDir(workspace), "project")
+  ]);
+  const skills = mergeSkills([builtin, user, project]);
+  const winner = invocationName === undefined ? undefined : skills.find((skill) => skill.name === invocationName);
+  if (winner && candidates) {
+    const content = candidates.get(winner.filePath);
+    if (content !== undefined)
+      return { contextFiles, skills, invocation: { filePath: winner.filePath, content } };
+  }
+  return { contextFiles, skills };
+};
+var createResourceLoader = (home = homedir3(), report = warnPromptDiagnostic, options) => {
+  const builtinDir = options?.builtinDir === undefined ? BUILTIN_SKILLS_DIR : options.builtinDir;
+  const previous = new Map;
+  return async (workspace, invocationName) => {
+    const diagnostics = [];
+    const resources = await readResources(workspace, home, builtinDir, (d) => diagnostics.push(d), invocationName);
+    const known = previous.get(workspace);
+    const current = new Set;
+    for (const diagnostic of diagnostics) {
+      const key = JSON.stringify(diagnostic);
+      if (!known?.has(key) && !current.has(key))
+        report(diagnostic);
+      current.add(key);
+    }
+    if (current.size)
+      previous.set(workspace, current);
+    else
+      previous.delete(workspace);
+    return resources;
   };
-  return record.status === "pending" ? { ...base, status: "pending" } : { ...base, ...outcomeOf(record) };
-}
-function createAskUserTool(service) {
-  return defineTool4({
-    name: "ask_user",
-    description: "Ask the user one question and wait for the answer. question: the text. options: optional [{id, label, description?, recommended?}]; multiple: true lets the user pick several (needs 2+ options). The user can always type text instead of or in addition to choosing, or skip. Use only when you need a decision or information you cannot determine yourself. The call returns when the user answers or skips; do not poll.",
-    parameters: parameters3,
-    structuredOutputSchema: structuredOutputSchema2,
-    replay: "safe",
-    executionMode: "sequential",
-    callers: ["model"],
-    execute: async (input, api, context) => {
-      context.abortSignal?.throwIfAborted();
-      if ((await api.snapshot(SubagentDoc, api.conversationId, context))?.role)
-        throw new Error("Subagents cannot ask the user; report the missing information to the main agent.");
-      let args;
-      try {
-        args = validateQuestionArgs(input);
-      } catch (error) {
-        if (error instanceof InteractionInputError)
-          throw new Error(`Invalid ask_user arguments: ${error.message}`);
-        throw error;
+};
+var scanSkillsByLevel = async (workspace, home = homedir3(), builtinDir = BUILTIN_SKILLS_DIR, report = warnPromptDiagnostic) => {
+  const scan = async (dir, level) => (await scanSkillsDir(dir, report)).map((skill) => ({ ...skill, level }));
+  const [builtin, user, project] = await Promise.all([
+    builtinDir === null ? [] : scan(builtinDir, "builtin"),
+    scan(userSkillsDir(home), "user"),
+    scan(workspaceSkillsDir(workspace), "project")
+  ]);
+  return [...project, ...user, ...builtin];
+};
+
+// packages/core/src/prompt/snapshots.ts
+var createResourceSnapshots = (load, submission) => {
+  const conversations = new Map;
+  const stateFor = (id, workspace) => {
+    let state = conversations.get(id);
+    if (!state || state.workspace !== workspace) {
+      state = { workspace, pending: new Map };
+      conversations.set(id, state);
+    }
+    return state;
+  };
+  return {
+    stage(id, requestId, workspace, resources) {
+      stateFor(id, workspace).pending.set(requestId, {
+        contextFiles: resources.contextFiles,
+        skills: resources.skills
+      });
+    },
+    async current(id, workspace) {
+      const state = stateFor(id, workspace);
+      for (const [requestId, snapshot] of state.pending) {
+        const record = await submission(id, requestId);
+        if (!record || record.status === "queued")
+          continue;
+        state.pending.delete(requestId);
+        if (record.type !== "input" || record.entry === undefined)
+          continue;
+        if (state.entry === undefined || record.entry > state.entry) {
+          state.active = snapshot;
+          state.entry = record.entry;
+        }
       }
-      const questions = service();
-      const created = await questions.ensure(api.conversationId, api.taskId, api.callId, args, context);
-      await api.details(questionDetails(created), context);
-      const record = created.status === "pending" ? await questions.wait(api.conversationId, api.taskId, context) : created;
-      return {
-        output: [{ type: "text", text: questionOutput(record) }],
-        structuredOutput: outcomeOf(record),
-        details: questionDetails(record),
-        isError: record.status === "cancelled"
-      };
+      state.active ??= load(workspace);
+      return state.active;
+    },
+    discard(id, requestId) {
+      conversations.get(id)?.pending.delete(requestId);
+    },
+    move(id, from, to) {
+      const pending = conversations.get(id)?.pending;
+      const snapshot = pending?.get(from);
+      if (!pending || !snapshot)
+        return;
+      pending.delete(from);
+      pending.set(to, snapshot);
+    },
+    forget(id) {
+      conversations.delete(id);
     }
-  });
-}
-var createQuestionExtension = (service) => defineExtension6({ name: "neko-questions", tools: [createAskUserTool(service)] });
+  };
+};
 
 // packages/core/src/session-metadata.ts
-var SessionMetadataDoc = defineDoc4({
+import { stripVTControlCharacters } from "util";
+import { getSupportedThinkingLevels } from "@earendil-works/pi-ai";
+import {
+  defineDoc as defineDoc5,
+  defineExtension as defineExtension8,
+  defineTask as defineTask3,
+  InboxDoc as InboxDoc2,
+  LiveDoc as LiveDoc2
+} from "@earendil-works/pi-durable";
+var SessionMetadataDoc = defineDoc5({
   kind: "app.neko.session-metadata",
   version: 1,
   scope: "conversation",
@@ -20691,7 +21161,7 @@ class SessionMetadataManager {
     this.storage = storage;
     this.context = context;
     this.report = report;
-    registry.install(defineExtension7({ name: "neko-naming", tasks: [this.task] }));
+    registry.install(defineExtension8({ name: "neko-naming", tasks: [this.task] }));
     this.#unsubscribe = harness.subscribeCommits(({ changes }) => {
       const ids = new Set;
       const submissions = new Map;
@@ -20704,7 +21174,7 @@ class SessionMetadataManager {
           submissions.set(c.value.conversationId, records);
         }
         if (c.type === "document" && c.conversationId) {
-          if (c.record.kind === "pi.agent" || c.record.kind === QuestionsDoc.definition.kind)
+          if (c.record.kind === "pi.agent" || c.record.kind === QuestionsDoc.definition.kind || c.record.kind === PlanDoc.definition.kind)
             ids.add(c.conversationId);
           if (c.record.kind === "pi.live") {
             const running = c.value?.run !== undefined;
@@ -20773,7 +21243,7 @@ class SessionMetadataManager {
         cursor = page.next;
       } while (cursor);
     records.sort((a, b) => a.id - b.id);
-    const inbox = await this.harness.snapshot(InboxDoc, id, this.context);
+    const inbox = await this.harness.snapshot(InboxDoc2, id, this.context);
     const updates = await Promise.all(records.filter((r) => r.type === "input").map(async (record) => {
       const entry = record.entry === undefined ? undefined : (await this.storage.entry(record.entry, this.context))?.entry;
       const queued = inbox?.items.find((i) => i.id === record.id && i.mode !== "write");
@@ -20783,10 +21253,13 @@ class SessionMetadataManager {
     }));
     const live = await this.harness.snapshot(LiveDoc2, id, this.context);
     const awaiting = live?.run !== undefined && ((await this.harness.snapshot(QuestionsDoc, id, this.context))?.pending.length ?? 0) > 0;
+    const awaitingPlan = (await this.harness.snapshot(PlanDoc, id, this.context))?.items.some((item) => item.status === "awaiting_approval");
     await this.harness.commit(async (tx) => {
       const d = await tx.doc(SessionMetadataDoc, id);
       if ((d.awaiting ?? false) !== awaiting)
         d.awaiting = awaiting;
+      if ((d.awaitingPlan ?? false) !== (awaitingPlan ?? false))
+        d.awaitingPlan = awaitingPlan ?? false;
       for (const { record, data, answer } of updates) {
         if (!data)
           continue;
@@ -20834,9 +21307,9 @@ class SessionMetadataManager {
 }
 
 // packages/core/src/todos.ts
-import { defineDoc as defineDoc5, defineExtension as defineExtension8, defineTool as defineTool5 } from "@earendil-works/pi-durable";
-import { Type as Type5 } from "typebox";
-var TodosDoc = defineDoc5({
+import { defineDoc as defineDoc6, defineExtension as defineExtension9, defineTool as defineTool6 } from "@earendil-works/pi-durable";
+import { Type as Type6 } from "typebox";
+var TodosDoc = defineDoc6({
   kind: "app.neko.todos",
   version: 1,
   scope: "conversation",
@@ -20844,30 +21317,30 @@ var TodosDoc = defineDoc5({
   fork: "asOf",
   initial: () => ({ revision: 0, items: [] })
 });
-var TodoReceiptDoc = defineDoc5({
+var TodoReceiptDoc = defineDoc6({
   kind: "app.neko.todo-receipt",
   version: 1,
   scope: "task",
   initial: () => ({ applied: false, revision: 0, items: [] })
 });
-var itemSchema = Type5.Object({
-  id: Type5.String({
+var itemSchema = Type6.Object({
+  id: Type6.String({
     minLength: 1,
     maxLength: TODO_LIMITS.idChars,
     description: "Stable id; keep it when you update the same task."
   }),
-  text: Type5.String({ minLength: 1, maxLength: TODO_LIMITS.textChars }),
-  status: Type5.String({ enum: [...TODO_STATUSES] })
+  text: Type6.String({ minLength: 1, maxLength: TODO_LIMITS.textChars }),
+  status: Type6.String({ enum: [...TODO_STATUSES] })
 }, { additionalProperties: false });
-var parameters4 = Type5.Object({
-  action: Type5.String({ enum: ["list", "replace"], description: "list reads the list; replace overwrites it." }),
-  items: Type5.Optional(Type5.Array(itemSchema, {
+var parameters5 = Type6.Object({
+  action: Type6.String({ enum: ["list", "replace"], description: "list reads the list; replace overwrites it." }),
+  items: Type6.Optional(Type6.Array(itemSchema, {
     maxItems: TODO_LIMITS.maxItems,
     description: "Required for replace only: the complete ordered list; [] clears it."
   }))
 }, { additionalProperties: false });
-var structuredOutputSchema3 = Type5.Object({ revision: Type5.Integer({ minimum: 0 }), items: Type5.Array(itemSchema) }, { additionalProperties: false });
-var clone2 = (value) => JSON.parse(JSON.stringify(value));
+var structuredOutputSchema3 = Type6.Object({ revision: Type6.Integer({ minimum: 0 }), items: Type6.Array(itemSchema) }, { additionalProperties: false });
+var clone3 = (value) => JSON.parse(JSON.stringify(value));
 function renderTodos(list) {
   const { completed, total } = todoProgress(list.items);
   if (!total)
@@ -20880,10 +21353,10 @@ function renderTodos(list) {
 `);
 }
 function createTodoTool() {
-  return defineTool5({
+  return defineTool6({
     name: "todo",
     description: "Keep a structured todo list for the current multi-step task. list: read the saved list. replace: items [{id, text, status}] overwrites the whole ordered list (status pending, in_progress or completed; [] clears it). Keep ids stable when updating a task and mark completed only after the work is actually done. Users see the list but cannot edit it.",
-    parameters: parameters4,
+    parameters: parameters5,
     structuredOutputSchema: structuredOutputSchema3,
     replay: "safe",
     executionMode: "sequential",
@@ -20898,7 +21371,7 @@ function createTodoTool() {
         if (args.items !== undefined)
           throw new Error("list does not accept items.");
         const saved = await api.snapshot(TodosDoc, api.conversationId, context);
-        list = saved ? clone2(saved) : { revision: 0, items: [] };
+        list = saved ? clone3(saved) : { revision: 0, items: [] };
       } else {
         if (args.items === undefined)
           throw new Error("replace requires items.");
@@ -20906,9 +21379,9 @@ function createTodoTool() {
         list = await api.commit(async (tx) => {
           const receipt = await tx.doc(TodoReceiptDoc, api.taskId);
           if (receipt.applied) {
-            if (JSON.stringify(clone2(receipt.items)) !== JSON.stringify(items))
+            if (JSON.stringify(clone3(receipt.items)) !== JSON.stringify(items))
               throw new Error("This todo call was already applied with different items.");
-            return { revision: receipt.revision, items: clone2(receipt.items) };
+            return { revision: receipt.revision, items: clone3(receipt.items) };
           }
           const doc = await tx.doc(TodosDoc, api.conversationId);
           doc.revision += 1;
@@ -20916,7 +21389,7 @@ function createTodoTool() {
           receipt.applied = true;
           receipt.revision = doc.revision;
           receipt.items = items;
-          return { revision: doc.revision, items: clone2(items) };
+          return { revision: doc.revision, items: clone3(items) };
         }, context);
       }
       const { completed, total } = todoProgress(list.items);
@@ -20928,21 +21401,21 @@ function createTodoTool() {
     }
   });
 }
-var createTodoExtension = () => defineExtension8({ name: "neko-todos", tools: [createTodoTool()] });
+var createTodoExtension = () => defineExtension9({ name: "neko-todos", tools: [createTodoTool()] });
 
 // packages/core/src/tool-approvals.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 import { realpath } from "fs/promises";
 import {
   configure as configure2,
-  defineDoc as defineDoc6,
-  defineExtension as defineExtension9,
-  hook as hook2,
-  ToolTask as ToolTask2,
-  wrapTool
+  defineDoc as defineDoc7,
+  defineExtension as defineExtension10,
+  hook as hook3,
+  ToolTask as ToolTask3,
+  wrapTool as wrapTool2
 } from "@earendil-works/pi-durable";
-import { createBashTool } from "@earendil-works/pi-durable/tools";
-var ApprovalsDoc = defineDoc6({
+import { createBashTool as createBashTool2 } from "@earendil-works/pi-durable/tools";
+var ApprovalsDoc = defineDoc7({
   kind: "app.neko.approvals",
   version: 1,
   scope: "conversation",
@@ -21041,7 +21514,7 @@ class ToolApprovals {
       }
       doc.items.push({
         ...candidate,
-        version: randomUUID2(),
+        version: randomUUID3(),
         status: "pending",
         createdAt: Date.now(),
         decidedAt: null
@@ -21050,10 +21523,10 @@ class ToolApprovals {
   }
 }
 function createApprovalExtension(service) {
-  return defineExtension9({
+  return defineExtension10({
     name: "neko-tool-approvals",
     hooks: [
-      hook2(ToolTask2, {
+      hook3(ToolTask3, {
         beforeTool: async (call, api, context) => {
           const role = await api.snapshot(SubagentDoc, api.conversationId, context);
           if (role?.role !== "explore" || call.name !== "bash")
@@ -21083,7 +21556,7 @@ function createApprovalExtension(service) {
       })
     ],
     wraps: [
-      wrapTool(createBashTool(), (bash) => ({
+      wrapTool2(createBashTool2(), (bash) => ({
         ...bash,
         execute: async (args, api, context) => {
           const role = await api.snapshot(SubagentDoc, api.conversationId, context);
@@ -21107,7 +21580,7 @@ async function prepareApprovalConversations(harness, ids, extension, context) {
     const child = await harness.conversation(id, context);
     const agent = await child.agent(context);
     await harness.commit((tx) => configure2(tx, id, {
-      tools: [...agent.tools.filter((t) => t.name !== "bash"), createBashTool()],
+      tools: [...agent.tools.filter((t) => t.name !== "bash"), createBashTool2()],
       extensions: { add: [extension] }
     }), context);
   }
@@ -21334,8 +21807,8 @@ function createDeepseekProvider(resolveKey, fetchImpl = fetch, options = {}) {
 }
 
 // packages/core/src/web-search/index.ts
-import { Type as Type6 } from "@earendil-works/pi-ai";
-import { defineExtension as defineExtension10, defineTool as defineTool6 } from "@earendil-works/pi-durable";
+import { Type as Type7 } from "@earendil-works/pi-ai";
+import { defineExtension as defineExtension11, defineTool as defineTool7 } from "@earendil-works/pi-durable";
 var MAX_URLS = 20;
 var MAX_RESULTS = 10;
 var DEFAULT_RESULTS = 5;
@@ -21353,15 +21826,15 @@ function content(text) {
   return { output: [{ type: "text", text }] };
 }
 function createWebSearchTools(resolveProvider) {
-  return defineExtension10({
+  return defineExtension11({
     name: "neko-web-search",
     tools: [
-      defineTool6({
+      defineTool7({
         name: "web_search",
         description: "Search the live web for current or unknown information. Returns ranked sources (title, URL, bounded excerpts). Keep the query short and focused (ideally under 128 characters). Use only when up-to-date or external information is needed; use web_extract to read a known URL.",
-        parameters: Type6.Object({
-          query: Type6.String({ minLength: 1, maxLength: 4096, description: "The search query" }),
-          maxResults: Type6.Optional(Type6.Number({ description: `Maximum number of results (1-${MAX_RESULTS}, default ${DEFAULT_RESULTS})` }))
+        parameters: Type7.Object({
+          query: Type7.String({ minLength: 1, maxLength: 4096, description: "The search query" }),
+          maxResults: Type7.Optional(Type7.Number({ description: `Maximum number of results (1-${MAX_RESULTS}, default ${DEFAULT_RESULTS})` }))
         }),
         async execute({ query, maxResults }, _api, context) {
           try {
@@ -21387,11 +21860,11 @@ ${item.date ? `Published: ${item.date}
           }
         }
       }),
-      defineTool6({
+      defineTool7({
         name: "web_extract",
         description: "Extract bounded markdown excerpts from web pages by URL. Every requested URL has a result or failure entry; long content is truncated.",
-        parameters: Type6.Object({
-          urls: Type6.Array(Type6.String({ maxLength: 2048, description: "http(s) URL" }), {
+        parameters: Type7.Object({
+          urls: Type7.Array(Type7.String({ maxLength: 2048, description: "http(s) URL" }), {
             minItems: 1,
             maxItems: MAX_URLS,
             description: `URLs to extract (1-${MAX_URLS})`
@@ -22116,7 +22589,7 @@ function cancellable(work, signal) {
 var DEFAULT_MODEL = { provider: "deepseek", modelId: "deepseek-flash" };
 var DEFAULT_STORAGE_PATH = join5(homedir4(), ".neko", "neko.sqlite");
 var neverAborted = () => new AbortController().signal;
-var ArchivedDoc = defineDoc7({
+var ArchivedDoc = defineDoc8({
   kind: "app.neko.conversation",
   version: 1,
   scope: "conversation",
@@ -22124,7 +22597,7 @@ var ArchivedDoc = defineDoc7({
   fork: "initial",
   initial: () => ({ archived: false })
 });
-var WorkspacesDoc = defineDoc7({
+var WorkspacesDoc = defineDoc8({
   kind: "app.neko.workspaces",
   version: 1,
   scope: "conversation",
@@ -22132,7 +22605,7 @@ var WorkspacesDoc = defineDoc7({
   fork: "initial",
   initial: () => ({ items: [] })
 });
-var SearchSettingsDoc = defineDoc7({
+var SearchSettingsDoc = defineDoc8({
   kind: "app.neko.search-settings",
   version: 1,
   scope: "conversation",
@@ -22140,7 +22613,7 @@ var SearchSettingsDoc = defineDoc7({
   fork: "initial",
   initial: () => ({ provider: null })
 });
-var ProviderSettingsDoc = defineDoc7({
+var ProviderSettingsDoc = defineDoc8({
   kind: "app.neko.provider-settings",
   version: 1,
   scope: "conversation",
@@ -22148,7 +22621,7 @@ var ProviderSettingsDoc = defineDoc7({
   fork: "initial",
   initial: () => ({ enabled: null })
 });
-var DefaultModelDoc = defineDoc7({
+var DefaultModelDoc = defineDoc8({
   kind: "app.neko.default-model",
   version: 1,
   scope: "conversation",
@@ -22156,7 +22629,7 @@ var DefaultModelDoc = defineDoc7({
   fork: "initial",
   initial: () => ({ model: null })
 });
-var ContextSettingsDoc = defineDoc7({
+var ContextSettingsDoc = defineDoc8({
   kind: "app.neko.context-settings",
   version: 1,
   scope: "conversation",
@@ -22164,7 +22637,7 @@ var ContextSettingsDoc = defineDoc7({
   fork: "initial",
   initial: emptySavedContextSettings
 });
-var ActivityDoc = defineDoc7({
+var ActivityDoc = defineDoc8({
   kind: "app.neko.activity",
   version: 1,
   scope: "conversation",
@@ -22268,6 +22741,8 @@ async function createNekoRuntime(options = {}) {
   registry.install(createTodoExtension());
   let questions;
   registry.install(createQuestionExtension(() => questions));
+  let plans;
+  registry.install(createPlanExtension(() => plans));
   for (const extension of options.extensions ?? [])
     registry.install(extension);
   let approvals;
@@ -22301,6 +22776,7 @@ async function createNekoRuntime(options = {}) {
   }, context);
   approvals = new ToolApprovals(harness, context);
   questions = new UserQuestions(harness, context);
+  plans = new PlanService(harness, context);
   const changes = new ChangeTracker(harness, context);
   const existing = await scanConversations();
   questions.track(...existing.map((r) => r.id));
@@ -22417,11 +22893,17 @@ async function createNekoRuntime(options = {}) {
         admissions.delete(id);
     }
   };
-  const submitTo = async (target, content, submitOptions) => admit(target.id, async () => {
+  const syncPlanAgent = async (target) => {
+    const mode = await plans.mode(target.id);
+    if (mode === "plan" !== agentInPlanMode(await target.agent(context)))
+      await target.configure(planAgentChange(mode), context);
+  };
+  const submitTo = async (target, content, submitOptions, extra) => admit(target.id, async () => {
+    await syncPlanAgent(target);
     const agent = await target.agent(context);
     const workspace = executionWorkspace(agent.cwd);
     const duplicate = submitOptions?.requestId !== undefined && await storage.submissionByRequest(target.id, submitOptions.requestId, context);
-    const data = { at: Date.now(), prompt: "", images: [] };
+    const data = { at: Date.now(), prompt: "", images: [], ...extra };
     let invocationName;
     if (!duplicate && typeof content === "string" && content.startsWith("/skill:")) {
       const end = content.indexOf(" ");
@@ -22485,10 +22967,25 @@ async function createNekoRuntime(options = {}) {
       resourceSnapshots.discard(target.id, requestId);
       throw error;
     }
+    if (!extra?.planDecision)
+      await plans.supersedePending(target.id);
     await touchConversation(target.id);
     await metadata.reconcile(target.id);
     return result;
   });
+  const dispatchPlan = async (target, item) => {
+    const approve = item.status === "approved";
+    await submitTo(target, approve ? approvedPlanPrompt(item) : planRevisionPrompt(item, item.feedback ?? ""), { requestId: `${approve ? "plan-exec" : "plan-revise"}:${item.version}`, whenBusy: "followUp" }, {
+      planDecision: {
+        version: item.version,
+        kind: approve ? "approve" : "revise",
+        title: item.title,
+        ...!approve && item.feedback ? { feedback: item.feedback } : {}
+      }
+    });
+    await plans.markDispatched(target.id, item.version);
+  };
+  const isRunning = async (id) => (await harness.snapshot(importLiveDoc, id, context))?.run !== undefined;
   const waitAnswerOf = async (target, submission) => {
     const settled = await submission.wait(context);
     await metadata.flush();
@@ -22553,6 +23050,38 @@ async function createNekoRuntime(options = {}) {
     respondQuestion(id, version, response) {
       return questions.respond(target.id, id, version, response, context);
     },
+    plan() {
+      return plans.view(target.id);
+    },
+    planRecord(version) {
+      return plans.get(target.id, version);
+    },
+    async setPlanMode(mode) {
+      if (mode !== "normal" && mode !== "plan")
+        throw new Error("Unknown plan mode.");
+      return admit(target.id, async () => {
+        if (await isRunning(target.id))
+          throw new Error(PLAN_BUSY);
+        await plans.setMode(target.id, mode);
+        await syncPlanAgent(target);
+        return plans.view(target.id);
+      });
+    },
+    async respondPlan(version, decision) {
+      const parsed = validatePlanDecision(decision);
+      const known = await plans.get(target.id, version);
+      if (!known)
+        throw new Error("Plan not found.");
+      if (known.status === "awaiting_approval") {
+        if (await isRunning(target.id))
+          throw new Error(PLAN_BUSY);
+        await guardProvider((await target.agent(context)).model);
+      }
+      const { record, item } = await plans.decide(target.id, version, parsed);
+      if ((item.status === "approved" || item.status === "revision_requested") && !item.dispatched)
+        await dispatchPlan(target, item);
+      return record;
+    },
     async workspaceDir(path, signal) {
       return workspaceFiles.children(savedWorkspace((await target.agent(context)).cwd), path, signal ?? neverAborted());
     },
@@ -22578,12 +23107,13 @@ async function createNekoRuntime(options = {}) {
         await target.compact(instructions?.trim() || undefined, context);
       });
     },
-    abort() {
-      return target.abort(context);
+    async abort() {
+      await target.abort(context);
+      await plans.cancelPending(target.id);
     },
     async withdraw(submissionId) {
       const id = submissionId;
-      const inbox = await harness.snapshot(InboxDoc2, target.id, context);
+      const inbox = await harness.snapshot(InboxDoc3, target.id, context);
       const item = inbox?.items.find((i) => i.id === id);
       const input = item ? queuedUserInput(item) : undefined;
       if (item && !input)
@@ -22600,7 +23130,7 @@ async function createNekoRuntime(options = {}) {
     },
     async steer(submissionId) {
       const id = submissionId;
-      const inbox = await harness.snapshot(InboxDoc2, target.id, context);
+      const inbox = await harness.snapshot(InboxDoc3, target.id, context);
       const item = inbox?.items.find((i) => i.id === id);
       const input = item ? queuedUserInput(item) : undefined;
       if (item && (!input || item.mode === "write"))
@@ -22650,6 +23180,19 @@ async function createNekoRuntime(options = {}) {
     const record = await harness.commit((tx) => tx.conversation(id), context);
     return archived || record?.owner ? undefined : makeSession(target);
   };
+  for (const id of new Set([conversation.id, ...existing.map((r) => r.id)])) {
+    try {
+      const session = await getConversation(id);
+      if (!session)
+        continue;
+      await admit(id, () => syncPlanAgent(session.conversation));
+      const pending = await plans.undispatched(id);
+      if (pending)
+        await dispatchPlan(session.conversation, pending);
+    } catch (error) {
+      options.onReport?.(error);
+    }
+  }
   return {
     context,
     async compact(instructions, id) {
@@ -22788,6 +23331,7 @@ async function createNekoRuntime(options = {}) {
             lastMessageAt: info.lastMessageAt,
             status: info.status,
             awaitingAnswer: info.awaiting === true,
+            awaitingPlan: info.awaitingPlan === true,
             model: (await target.agent(context)).model ?? null,
             id: record.id,
             archived: false,
@@ -22990,7 +23534,7 @@ async function createNekoRuntime(options = {}) {
 }
 // packages/gateway/src/contract.ts
 import { hostNamed, method, remote } from "@earendil-works/chord";
-import { Type as Type7 } from "typebox";
+import { Type as Type8 } from "typebox";
 var GATEWAY_HOST = "neko";
 var rpc = (args, result) => [args, result];
 function contract(name, def) {
@@ -23003,19 +23547,19 @@ function contract(name, def) {
   ]));
   return remote(name, { ...def, host: hostNamed(GATEWAY_HOST), variants });
 }
-var str = Type7.String();
-var num = Type7.Number();
-var bool = Type7.Boolean();
-var nil = Type7.Null();
-var integer = Type7.Integer({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER });
-var nullableString = Type7.Union([str, nil]);
-var phase = Type7.Enum(["pending", "running", "done"]);
-var level = Type7.Enum(["project", "user", "builtin"]);
-var thinking = Type7.Enum(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
-var model2 = Type7.Object({ provider: str, modelId: str });
-var change = Type7.Object({ model: Type7.Optional(model2), thinkingLevel: Type7.Optional(thinking) }, { additionalProperties: false });
-var usage = Type7.Object({ input: num, output: num, cacheRead: num, cacheWrite: num, cost: num });
-var image = Type7.Object({
+var str = Type8.String();
+var num = Type8.Number();
+var bool = Type8.Boolean();
+var nil = Type8.Null();
+var integer = Type8.Integer({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER });
+var nullableString = Type8.Union([str, nil]);
+var phase = Type8.Enum(["pending", "running", "done"]);
+var level = Type8.Enum(["project", "user", "builtin"]);
+var thinking = Type8.Enum(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
+var model2 = Type8.Object({ provider: str, modelId: str });
+var change = Type8.Object({ model: Type8.Optional(model2), thinkingLevel: Type8.Optional(thinking) }, { additionalProperties: false });
+var usage = Type8.Object({ input: num, output: num, cacheRead: num, cacheWrite: num, cost: num });
+var image = Type8.Object({
   name: str,
   mimeType: str,
   width: integer,
@@ -23024,8 +23568,8 @@ var image = Type7.Object({
   entryId: integer,
   contentIndex: integer
 });
-var skill = Type7.Object({ name: str, location: str, body: str, args: str });
-var call = Type7.Object({
+var skill = Type8.Object({ name: str, location: str, body: str, args: str });
+var call = Type8.Object({
   callId: str,
   name: str,
   summary: str,
@@ -23033,262 +23577,289 @@ var call = Type7.Object({
   phase,
   output: nullableString,
   diff: nullableString,
-  diffAdded: Type7.Union([num, nil]),
-  diffRemoved: Type7.Union([num, nil]),
-  diffTruncated: Type7.Optional(bool)
+  diffAdded: Type8.Union([num, nil]),
+  diffRemoved: Type8.Union([num, nil]),
+  diffTruncated: Type8.Optional(bool)
 });
-var DelegationSchema = Type7.Object({
+var DelegationSchema = Type8.Object({
   parentId: integer,
-  agentId: Type7.Optional(str),
-  round: Type7.Optional(integer),
-  runnerId: Type7.Optional(integer),
-  inputEntryId: Type7.Optional(integer),
-  answerEntryId: Type7.Optional(integer),
-  roundUsage: Type7.Optional(Type7.Union([usage, nil])),
+  agentId: Type8.Optional(str),
+  round: Type8.Optional(integer),
+  runnerId: Type8.Optional(integer),
+  inputEntryId: Type8.Optional(integer),
+  answerEntryId: Type8.Optional(integer),
+  roundUsage: Type8.Optional(Type8.Union([usage, nil])),
   taskId: integer,
   callId: str,
   childId: integer,
-  role: Type7.Enum(["explore", "plan", "coder"]),
+  role: Type8.Enum(["explore", "plan", "coder"]),
   title: str,
   createdAt: num,
-  startedAt: Type7.Union([num, nil]),
-  endedAt: Type7.Union([num, nil]),
-  status: Type7.Enum(["queued", "running", "completed", "failed", "cancelled"]),
+  startedAt: Type8.Union([num, nil]),
+  endedAt: Type8.Union([num, nil]),
+  status: Type8.Enum(["queued", "running", "completed", "failed", "cancelled"]),
   report: nullableString,
-  approvalCount: Type7.Optional(integer),
-  historyThrough: Type7.Optional(integer),
-  historyUsage: Type7.Optional(usage)
+  approvalCount: Type8.Optional(integer),
+  historyThrough: Type8.Optional(integer),
+  historyUsage: Type8.Optional(usage)
 });
-var SubagentSummarySchema = Type7.Object({
+var SubagentSummarySchema = Type8.Object({
   agentId: str,
   parentId: integer,
   childId: integer,
-  role: Type7.Enum(["explore", "plan", "coder"]),
+  role: Type8.Enum(["explore", "plan", "coder"]),
   title: str,
-  status: Type7.Enum(["idle", "queued", "running"]),
-  activeRoundId: Type7.Union([integer, nil]),
+  status: Type8.Enum(["idle", "queued", "running"]),
+  activeRoundId: Type8.Union([integer, nil]),
   lastRoundId: integer,
-  lastReport: Type7.Optional(nullableString),
+  lastReport: Type8.Optional(nullableString),
   roundCount: integer,
   taskTitle: str,
   approvalCount: integer,
   createdAt: num,
-  historyThrough: Type7.Optional(integer),
-  historyUsage: Type7.Optional(usage)
+  historyThrough: Type8.Optional(integer),
+  historyUsage: Type8.Optional(usage)
 });
-var jobStatus = Type7.Enum(["running", "exited", "failed", "stopped", "lost"]);
-var JobSummarySchema = Type7.Object({
+var jobStatus = Type8.Enum(["running", "exited", "failed", "stopped", "lost"]);
+var JobSummarySchema = Type8.Object({
   jobId: str,
   title: str,
   command: str,
   cwd: str,
   status: jobStatus,
   startedAt: num,
-  endedAt: Type7.Union([num, nil]),
-  exitCode: Type7.Union([num, nil]),
-  reason: Type7.Optional(Type7.Enum(["timeout", "spawn-error", "restart", "aborted"])),
-  timeoutSeconds: Type7.Optional(num),
+  endedAt: Type8.Union([num, nil]),
+  exitCode: Type8.Union([num, nil]),
+  reason: Type8.Optional(Type8.Enum(["timeout", "spawn-error", "restart", "aborted"])),
+  timeoutSeconds: Type8.Optional(num),
   outputBytes: integer
 });
-var JobOutputSchema = Type7.Object({
+var JobOutputSchema = Type8.Object({
   job: JobSummarySchema,
   text: str,
   offset: integer,
   truncated: bool,
   dropped: integer
 });
-var QueuedInputSchema = Type7.Object({
+var QueuedInputSchema = Type8.Object({
   id: integer,
-  mode: Type7.Enum(["steer", "followUp"]),
+  mode: Type8.Enum(["steer", "followUp"]),
   preview: str,
   images: integer,
-  skill: Type7.Optional(Type7.Object({ name: str, args: str }))
+  skill: Type8.Optional(Type8.Object({ name: str, args: str }))
 });
-var WithdrawResultSchema = Type7.Object({
-  result: Type7.Enum(["withdrawn", "placed", "settled", "unknown"]),
-  text: Type7.Optional(str),
-  images: Type7.Optional(integer)
+var WithdrawResultSchema = Type8.Object({
+  result: Type8.Enum(["withdrawn", "placed", "settled", "unknown"]),
+  text: Type8.Optional(str),
+  images: Type8.Optional(integer)
 });
-var SteerResultSchema = Type7.Object({
-  result: Type7.Enum(["steered", "withdrawn", "placed", "settled", "unknown"]),
-  id: Type7.Optional(integer),
-  text: Type7.Optional(str),
-  images: Type7.Optional(integer)
+var SteerResultSchema = Type8.Object({
+  result: Type8.Enum(["steered", "withdrawn", "placed", "settled", "unknown"]),
+  id: Type8.Optional(integer),
+  text: Type8.Optional(str),
+  images: Type8.Optional(integer)
 });
-var TodoItemSchema = Type7.Object({
-  id: Type7.String({ minLength: 1, maxLength: TODO_LIMITS.idChars }),
-  text: Type7.String({ minLength: 1, maxLength: TODO_LIMITS.textChars }),
-  status: Type7.Enum(["pending", "in_progress", "completed"])
+var TodoItemSchema = Type8.Object({
+  id: Type8.String({ minLength: 1, maxLength: TODO_LIMITS.idChars }),
+  text: Type8.String({ minLength: 1, maxLength: TODO_LIMITS.textChars }),
+  status: Type8.Enum(["pending", "in_progress", "completed"])
 }, { additionalProperties: false });
-var TodoListSchema = Type7.Object({
+var TodoListSchema = Type8.Object({
   revision: integer,
-  items: Type7.Array(TodoItemSchema, { maxItems: TODO_LIMITS.maxItems })
+  items: Type8.Array(TodoItemSchema, { maxItems: TODO_LIMITS.maxItems })
 });
-var QuestionOptionSchema = Type7.Object({
-  id: Type7.String({ minLength: 1, maxLength: QUESTION_LIMITS.optionIdChars }),
-  label: Type7.String({ minLength: 1, maxLength: QUESTION_LIMITS.labelChars }),
-  description: Type7.Optional(Type7.String({ maxLength: QUESTION_LIMITS.descriptionChars })),
-  recommended: Type7.Optional(bool)
+var QuestionOptionSchema = Type8.Object({
+  id: Type8.String({ minLength: 1, maxLength: QUESTION_LIMITS.optionIdChars }),
+  label: Type8.String({ minLength: 1, maxLength: QUESTION_LIMITS.labelChars }),
+  description: Type8.Optional(Type8.String({ maxLength: QUESTION_LIMITS.descriptionChars })),
+  recommended: Type8.Optional(bool)
 }, { additionalProperties: false });
-var questionStatus = Type7.Enum(["pending", "answered", "skipped", "cancelled"]);
-var QuestionSummarySchema = Type7.Object({
+var questionStatus = Type8.Enum(["pending", "answered", "skipped", "cancelled"]);
+var QuestionSummarySchema = Type8.Object({
   id: integer,
   version: str,
-  preview: Type7.String({ maxLength: QUESTION_LIMITS.previewChars }),
+  preview: Type8.String({ maxLength: QUESTION_LIMITS.previewChars }),
   multiple: bool,
   optionCount: integer,
   createdAt: num
 });
-var WorkspaceEntrySchema = Type7.Object({
+var WorkspaceEntrySchema = Type8.Object({
   name: str,
   path: str,
-  kind: Type7.Enum(["file", "directory", "symlink"]),
-  protected: Type7.Optional(Type7.Literal(true))
+  kind: Type8.Enum(["file", "directory", "symlink"]),
+  protected: Type8.Optional(Type8.Literal(true))
 }, { additionalProperties: false });
-var WorkspaceDirSchema = Type7.Object({
+var WorkspaceDirSchema = Type8.Object({
   path: str,
-  entries: Type7.Array(WorkspaceEntrySchema, { maxItems: 1000 }),
+  entries: Type8.Array(WorkspaceEntrySchema, { maxItems: 1000 }),
   limited: bool,
   incomplete: bool
 });
-var WorkspaceFileSchema = Type7.Object({
+var WorkspaceFileSchema = Type8.Object({
   path: str,
   size: num,
   mtimeMs: num,
-  kind: Type7.Enum(["text", "binary", "protected"]),
-  content: Type7.Optional(str),
+  kind: Type8.Enum(["text", "binary", "protected"]),
+  content: Type8.Optional(str),
   truncated: bool
 });
-var ChangeSummarySchema = Type7.Object({ revision: integer, files: integer, added: integer, removed: integer });
-var ChangedFileSchema = Type7.Object({
+var ChangeSummarySchema = Type8.Object({ revision: integer, files: integer, added: integer, removed: integer });
+var ChangedFileSchema = Type8.Object({
   path: str,
-  outside: Type7.Optional(Type7.Literal(true)),
+  outside: Type8.Optional(Type8.Literal(true)),
   ops: integer,
   added: integer,
   removed: integer,
-  agents: Type7.Array(str, { maxItems: 64 }),
+  agents: Type8.Array(str, { maxItems: 64 }),
   lastSeq: integer
 }, { additionalProperties: false });
-var ChangeListSchema = Type7.Object({
+var ChangeListSchema = Type8.Object({
   revision: integer,
-  files: Type7.Array(ChangedFileSchema, { maxItems: 500 }),
+  files: Type8.Array(ChangedFileSchema, { maxItems: 500 }),
   truncated: bool
 });
-var ChangeOpSchema = Type7.Object({
+var ChangeOpSchema = Type8.Object({
   seq: integer,
   agent: str,
-  tool: Type7.Enum(["edit", "write"]),
+  tool: Type8.Enum(["edit", "write"]),
   diff: str,
   added: integer,
   removed: integer,
   truncated: bool
 }, { additionalProperties: false });
-var ChangeDetailSchema = Type7.Object({
+var ChangeDetailSchema = Type8.Object({
   path: str,
-  outside: Type7.Optional(Type7.Literal(true)),
-  ops: Type7.Array(ChangeOpSchema, { maxItems: 50 }),
+  outside: Type8.Optional(Type8.Literal(true)),
+  ops: Type8.Array(ChangeOpSchema, { maxItems: 50 }),
   truncated: bool
 });
-var QuestionListSchema = Type7.Object({
+var QuestionListSchema = Type8.Object({
   revision: integer,
-  pending: Type7.Array(QuestionSummarySchema, { maxItems: QUESTION_LIMITS.maxPending })
+  pending: Type8.Array(QuestionSummarySchema, { maxItems: QUESTION_LIMITS.maxPending })
 });
-var QuestionRecordSchema = Type7.Object({
+var QuestionRecordSchema = Type8.Object({
   id: integer,
   callId: str,
   version: str,
-  question: Type7.String({ maxLength: QUESTION_LIMITS.questionChars }),
+  question: Type8.String({ maxLength: QUESTION_LIMITS.questionChars }),
   multiple: bool,
-  options: Type7.Array(QuestionOptionSchema, { maxItems: QUESTION_LIMITS.maxOptions }),
+  options: Type8.Array(QuestionOptionSchema, { maxItems: QUESTION_LIMITS.maxOptions }),
   status: questionStatus,
-  answer: Type7.Union([
-    Type7.Object({
-      optionIds: Type7.Array(Type7.String(), { maxItems: QUESTION_LIMITS.maxOptions }),
-      text: Type7.Union([Type7.String({ maxLength: QUESTION_LIMITS.textChars }), nil])
+  answer: Type8.Union([
+    Type8.Object({
+      optionIds: Type8.Array(Type8.String(), { maxItems: QUESTION_LIMITS.maxOptions }),
+      text: Type8.Union([Type8.String({ maxLength: QUESTION_LIMITS.textChars }), nil])
     }),
     nil
   ]),
   createdAt: num,
-  settledAt: Type7.Union([num, nil])
+  settledAt: Type8.Union([num, nil])
 });
-var QuestionResponseSchema = Type7.Union([
-  Type7.Object({
-    kind: Type7.Literal("answer"),
-    optionIds: Type7.Optional(Type7.Array(Type7.String(), { maxItems: QUESTION_LIMITS.maxOptions })),
-    text: Type7.Optional(Type7.String({ maxLength: QUESTION_LIMITS.textChars }))
+var QuestionResponseSchema = Type8.Union([
+  Type8.Object({
+    kind: Type8.Literal("answer"),
+    optionIds: Type8.Optional(Type8.Array(Type8.String(), { maxItems: QUESTION_LIMITS.maxOptions })),
+    text: Type8.Optional(Type8.String({ maxLength: QUESTION_LIMITS.textChars }))
   }, { additionalProperties: false }),
-  Type7.Object({ kind: Type7.Literal("skip") }, { additionalProperties: false })
+  Type8.Object({ kind: Type8.Literal("skip") }, { additionalProperties: false })
+]);
+var PlanRecordSchema = Type8.Object({
+  version: str,
+  title: Type8.String({ maxLength: PLAN_LIMITS.titleChars }),
+  steps: Type8.Array(Type8.String({ maxLength: PLAN_LIMITS.stepChars }), { maxItems: PLAN_LIMITS.maxSteps }),
+  note: Type8.String({ maxLength: PLAN_LIMITS.noteChars }),
+  status: Type8.Enum(["awaiting_approval", "approved", "revision_requested", "superseded", "cancelled"]),
+  feedback: Type8.Union([Type8.String({ maxLength: PLAN_LIMITS.feedbackChars }), nil]),
+  createdAt: num,
+  settledAt: Type8.Union([num, nil])
+});
+var PlanViewSchema = Type8.Object({
+  mode: Type8.Enum(["normal", "plan"]),
+  revision: integer,
+  current: Type8.Union([PlanRecordSchema, nil])
+});
+var PlanDecisionSchema = Type8.Union([
+  Type8.Object({ kind: Type8.Literal("approve") }, { additionalProperties: false }),
+  Type8.Object({ kind: Type8.Literal("revise"), feedback: Type8.String({ minLength: 1, maxLength: PLAN_LIMITS.feedbackChars }) }, { additionalProperties: false })
 ]);
-var ToolInteractionSchema = Type7.Union([
-  Type7.Object({
-    kind: Type7.Literal("ask_user"),
+var ToolInteractionSchema = Type8.Union([
+  Type8.Object({
+    kind: Type8.Literal("ask_user"),
     id: integer,
     question: str,
     multiple: bool,
-    options: Type7.Array(Type7.Object({ id: str, label: str, recommended: Type7.Optional(bool) })),
+    options: Type8.Array(Type8.Object({ id: str, label: str, recommended: Type8.Optional(bool) })),
     status: questionStatus,
-    optionIds: Type7.Optional(Type7.Array(str)),
-    labels: Type7.Optional(Type7.Array(str)),
-    text: Type7.Optional(Type7.Union([str, nil]))
+    optionIds: Type8.Optional(Type8.Array(str)),
+    labels: Type8.Optional(Type8.Array(str)),
+    text: Type8.Optional(Type8.Union([str, nil]))
   }),
-  Type7.Object({
-    kind: Type7.Literal("todo"),
-    action: Type7.Enum(["list", "replace"]),
+  Type8.Object({
+    kind: Type8.Literal("todo"),
+    action: Type8.Enum(["list", "replace"]),
     revision: integer,
     completed: integer,
     total: integer
+  }),
+  Type8.Object({
+    kind: Type8.Literal("submit_plan"),
+    version: str,
+    title: str,
+    steps: Type8.Array(str),
+    note: str
   })
 ]);
-var ChatViewSchema = Type7.Object({
-  historyBefore: Type7.Optional(Type7.Union([integer, nil])),
-  agents: Type7.Optional(Type7.Array(SubagentSummarySchema)),
-  jobs: Type7.Optional(Type7.Array(JobSummarySchema)),
-  queued: Type7.Optional(Type7.Array(QueuedInputSchema)),
-  todos: Type7.Optional(TodoListSchema),
-  questions: Type7.Optional(QuestionListSchema),
-  changes: Type7.Optional(ChangeSummarySchema),
-  rounds: Type7.Optional(Type7.Array(DelegationSchema)),
-  subagents: Type7.Optional(Type7.Array(DelegationSchema)),
-  taskUsage: Type7.Optional(usage),
+var ChatViewSchema = Type8.Object({
+  historyBefore: Type8.Optional(Type8.Union([integer, nil])),
+  agents: Type8.Optional(Type8.Array(SubagentSummarySchema)),
+  jobs: Type8.Optional(Type8.Array(JobSummarySchema)),
+  queued: Type8.Optional(Type8.Array(QueuedInputSchema)),
+  todos: Type8.Optional(TodoListSchema),
+  questions: Type8.Optional(QuestionListSchema),
+  plan: Type8.Optional(PlanViewSchema),
+  changes: Type8.Optional(ChangeSummarySchema),
+  rounds: Type8.Optional(Type8.Array(DelegationSchema)),
+  subagents: Type8.Optional(Type8.Array(DelegationSchema)),
+  taskUsage: Type8.Optional(usage),
   model: str,
-  agent: Type7.Object({ model: Type7.Union([model2, nil]), thinkingLevel: Type7.Union([thinking, nil]) }),
+  agent: Type8.Object({ model: Type8.Union([model2, nil]), thinkingLevel: Type8.Union([thinking, nil]) }),
   cwd: str,
   busy: bool,
   status: nullableString,
   usage,
-  contextUsage: Type7.Optional(Type7.Object({ tokens: Type7.Union([num, nil]), window: num, percent: Type7.Union([num, nil]) })),
-  compaction: Type7.Optional(Type7.Object({
-    failure: Type7.Optional(Type7.Object({ taskId: integer, reason: Type7.Enum(["manual", "threshold", "overflow"]), error: str })),
-    active: Type7.Array(Type7.Object({
+  contextUsage: Type8.Optional(Type8.Object({ tokens: Type8.Union([num, nil]), window: num, percent: Type8.Union([num, nil]) })),
+  compaction: Type8.Optional(Type8.Object({
+    failure: Type8.Optional(Type8.Object({ taskId: integer, reason: Type8.Enum(["manual", "threshold", "overflow"]), error: str })),
+    active: Type8.Array(Type8.Object({
       taskId: integer,
-      reason: Type7.Enum(["manual", "threshold", "overflow"]),
+      reason: Type8.Enum(["manual", "threshold", "overflow"]),
       blocking: bool,
       attempt: integer,
-      retry: Type7.Optional(Type7.Object({ at: num, error: str }))
+      retry: Type8.Optional(Type8.Object({ at: num, error: str }))
     })),
-    latest: Type7.Union([
+    latest: Type8.Union([
       nil,
-      Type7.Object({
+      Type8.Object({
         taskId: integer,
-        phase: Type7.Enum(["summarizing", "waiting-to-apply", "applied", "nothing", "skipped", "cancelled", "failed"]),
+        phase: Type8.Enum(["summarizing", "waiting-to-apply", "applied", "nothing", "skipped", "cancelled", "failed"]),
         at: num
       })
     ])
   })),
-  items: Type7.Array(Type7.Union([
-    Type7.Object({
-      type: Type7.Literal("user"),
-      order: Type7.Optional(num),
+  items: Type8.Array(Type8.Union([
+    Type8.Object({
+      type: Type8.Literal("user"),
+      order: Type8.Optional(num),
       key: str,
       id: integer,
       text: str,
-      images: Type7.Optional(Type7.Array(image)),
-      skill: Type7.Optional(skill),
-      defaultImagePrompt: Type7.Optional(Type7.Object({ version: Type7.Integer({ minimum: 1 }), text: str }))
+      images: Type8.Optional(Type8.Array(image)),
+      skill: Type8.Optional(skill),
+      defaultImagePrompt: Type8.Optional(Type8.Object({ version: Type8.Integer({ minimum: 1 }), text: str }))
     }),
-    Type7.Object({
-      type: Type7.Literal("assistant"),
-      order: Type7.Optional(num),
+    Type8.Object({
+      type: Type8.Literal("assistant"),
+      order: Type8.Optional(num),
       key: str,
       id: integer,
       thinking: str,
@@ -23297,11 +23868,11 @@ var ChatViewSchema = Type7.Object({
       errorMessage: nullableString,
       note: nullableString
     }),
-    Type7.Object({
-      type: Type7.Literal("tool"),
-      order: Type7.Optional(num),
+    Type8.Object({
+      type: Type8.Literal("tool"),
+      order: Type8.Optional(num),
       key: str,
-      images: Type7.Optional(Type7.Array(image)),
+      images: Type8.Optional(Type8.Array(image)),
       callId: str,
       name: str,
       summary: str,
@@ -23310,64 +23881,66 @@ var ChatViewSchema = Type7.Object({
       isError: bool,
       output: nullableString,
       result: nullableString,
-      durationMs: Type7.Union([num, nil]),
+      durationMs: Type8.Union([num, nil]),
       note: nullableString,
       diff: nullableString,
-      diffAdded: Type7.Union([num, nil]),
-      diffRemoved: Type7.Union([num, nil]),
-      diffTruncated: Type7.Optional(bool),
-      interaction: Type7.Optional(ToolInteractionSchema)
+      diffAdded: Type8.Union([num, nil]),
+      diffRemoved: Type8.Union([num, nil]),
+      diffTruncated: Type8.Optional(bool),
+      interaction: Type8.Optional(ToolInteractionSchema)
     }),
-    Type7.Object({
-      type: Type7.Literal("system"),
-      order: Type7.Optional(num),
+    Type8.Object({
+      type: Type8.Literal("system"),
+      order: Type8.Optional(num),
       key: str,
       id: integer,
       text: str,
-      jobId: Type7.Optional(str)
+      jobId: Type8.Optional(str),
+      planDecision: Type8.Optional(Type8.Object({ version: str, kind: Type8.Enum(["approve", "revise"]) }, { additionalProperties: false }))
     })
   ])),
-  streaming: Type7.Union([nil, Type7.Object({ thinking: str, text: str, toolCalls: Type7.Array(call) })])
+  streaming: Type8.Union([nil, Type8.Object({ thinking: str, text: str, toolCalls: Type8.Array(call) })])
 });
-var SessionSummarySchema = Type7.Object({
+var SessionSummarySchema = Type8.Object({
   workspaceRoot: str,
   lastUsedAt: num,
   title: str,
   firstPromptPreview: str,
   createdAt: num,
-  lastMessageAt: Type7.Union([num, nil]),
-  model: Type7.Union([model2, nil]),
-  status: Type7.Enum(["idle", "running", "error"]),
-  awaitingAnswer: Type7.Optional(bool),
+  lastMessageAt: Type8.Union([num, nil]),
+  model: Type8.Union([model2, nil]),
+  status: Type8.Enum(["idle", "running", "error"]),
+  awaitingAnswer: Type8.Optional(bool),
+  awaitingPlan: Type8.Optional(bool),
   id: str
 });
-var DirectoryStateSchema = Type7.Object({ revision: integer, sessions: Type7.Array(SessionSummarySchema) });
-var WorkspaceSummarySchema = Type7.Object({ path: str, createdAt: num });
-var WorkspaceStateSchema = Type7.Object({ revision: integer, workspaces: Type7.Array(WorkspaceSummarySchema) });
-var credentialStatus = Type7.Object({
+var DirectoryStateSchema = Type8.Object({ revision: integer, sessions: Type8.Array(SessionSummarySchema) });
+var WorkspaceSummarySchema = Type8.Object({ path: str, createdAt: num });
+var WorkspaceStateSchema = Type8.Object({ revision: integer, workspaces: Type8.Array(WorkspaceSummarySchema) });
+var credentialStatus = Type8.Object({
   savedConfigured: bool,
   environmentConfigured: bool,
-  source: Type7.Enum(["saved", "environment", "runtime", "keyless", "none"]),
-  enabled: Type7.Optional(bool)
+  source: Type8.Enum(["saved", "environment", "runtime", "keyless", "none"]),
+  enabled: Type8.Optional(bool)
 });
-var CredentialStateSchema = Type7.Object({
+var CredentialStateSchema = Type8.Object({
   revision: integer,
-  statuses: Type7.Record(str, credentialStatus)
+  statuses: Type8.Record(str, credentialStatus)
 });
-var AttachmentSchema = Type7.Object({ sessionId: str, attachmentId: str });
-var chatInput = Type7.Object({ sessionId: str, attachmentId: str }, { additionalProperties: false });
+var AttachmentSchema = Type8.Object({ sessionId: str, attachmentId: str });
+var chatInput = Type8.Object({ sessionId: str, attachmentId: str }, { additionalProperties: false });
 var NekoSessionDirectory = contract("neko.session-directory", {
   version: 1,
-  input: Type7.Object({}, { additionalProperties: false }),
+  input: Type8.Object({}, { additionalProperties: false }),
   variants: { ready: { state: { state: DirectoryStateSchema } } }
 });
 var NekoSessionManagement = contract("neko.session-management", {
   version: 1,
-  input: Type7.Object({}, { additionalProperties: false }),
+  input: Type8.Object({}, { additionalProperties: false }),
   variants: {
     ready: {
       methods: {
-        create: rpc(Type7.Object({ ...change.properties, cwd: Type7.Optional(str) }, { additionalProperties: false }), SessionSummarySchema),
+        create: rpc(Type8.Object({ ...change.properties, cwd: Type8.Optional(str) }, { additionalProperties: false }), SessionSummarySchema),
         archive: rpc(str, nil),
         attach: rpc(str, AttachmentSchema),
         detach: rpc(nil, nil),
@@ -23376,31 +23949,31 @@ var NekoSessionManagement = contract("neko.session-management", {
     }
   }
 });
-var resize = Type7.Object({
-  maxWidth: Type7.Optional(integer),
-  maxHeight: Type7.Optional(integer),
-  maxBytes: Type7.Optional(integer),
-  jpegQuality: Type7.Optional(integer)
+var resize = Type8.Object({
+  maxWidth: Type8.Optional(integer),
+  maxHeight: Type8.Optional(integer),
+  maxBytes: Type8.Optional(integer),
+  jpegQuality: Type8.Optional(integer)
 });
-var inputLimits = Type7.Object({
-  maxRequestBytes: Type7.Optional(integer),
-  images: Type7.Optional(Type7.Object({
-    resize: Type7.Optional(resize),
-    maxPerMessage: Type7.Optional(integer),
-    maxPerRequest: Type7.Optional(integer)
+var inputLimits = Type8.Object({
+  maxRequestBytes: Type8.Optional(integer),
+  images: Type8.Optional(Type8.Object({
+    resize: Type8.Optional(resize),
+    maxPerMessage: Type8.Optional(integer),
+    maxPerRequest: Type8.Optional(integer)
   }))
 });
-var modelInfo = Type7.Object({
+var modelInfo = Type8.Object({
   provider: str,
   modelId: str,
   name: str,
   available: bool,
   contextWindow: num,
-  input: Type7.Array(str),
-  inputLimits: Type7.Optional(inputLimits),
+  input: Type8.Array(str),
+  inputLimits: Type8.Optional(inputLimits),
   reasoning: bool,
-  supportedThinkingLevels: Type7.Array(thinking),
-  thinkingLevelAdjustments: Type7.Object({
+  supportedThinkingLevels: Type8.Array(thinking),
+  thinkingLevelAdjustments: Type8.Object({
     off: thinking,
     minimal: thinking,
     low: thinking,
@@ -23412,31 +23985,31 @@ var modelInfo = Type7.Object({
 });
 var NekoModels = contract("neko.models", {
   version: 1,
-  input: Type7.Object({}, { additionalProperties: false }),
-  variants: { ready: { methods: { list: rpc(nil, Type7.Array(modelInfo)) } } }
+  input: Type8.Object({}, { additionalProperties: false }),
+  variants: { ready: { methods: { list: rpc(nil, Type8.Array(modelInfo)) } } }
 });
-var imageChunk = Type7.Object({ data: str, total: integer, mimeType: str });
+var imageChunk = Type8.Object({ data: str, total: integer, mimeType: str });
 var NekoSubagent = contract("neko.subagent", {
   version: 1,
-  input: Type7.Object({
+  input: Type8.Object({
     sessionId: str,
     attachmentId: str,
-    taskId: Type7.Optional(integer),
-    agentId: Type7.Optional(str)
+    taskId: Type8.Optional(integer),
+    agentId: Type8.Optional(str)
   }),
   variants: {
     ready: {
       state: { revision: integer },
       methods: {
-        chunk: rpc(Type7.Object({
-          kind: Type7.Enum(["view", "history"]),
-          before: Type7.Optional(integer),
-          token: Type7.Optional(integer),
+        chunk: rpc(Type8.Object({
+          kind: Type8.Enum(["view", "history"]),
+          before: Type8.Optional(integer),
+          token: Type8.Optional(integer),
           offset: integer
-        }), Type7.Object({ token: integer, data: str, next: Type7.Union([integer, nil]) })),
-        getImage: rpc(Type7.Object({ entryId: integer, contentIndex: integer, offset: integer }), imageChunk),
-        decideApproval: rpc(Type7.Object({ id: integer, version: str, decision: Type7.Enum(["allowed", "denied"]) }), Type7.Enum(["pending", "allowed", "denied", "cancelled"])),
-        stop: rpc(Type7.Union([nil, Type7.Object({ taskId: integer })]), nil)
+        }), Type8.Object({ token: integer, data: str, next: Type8.Union([integer, nil]) })),
+        getImage: rpc(Type8.Object({ entryId: integer, contentIndex: integer, offset: integer }), imageChunk),
+        decideApproval: rpc(Type8.Object({ id: integer, version: str, decision: Type8.Enum(["allowed", "denied"]) }), Type8.Enum(["pending", "allowed", "denied", "cancelled"])),
+        stop: rpc(Type8.Union([nil, Type8.Object({ taskId: integer })]), nil)
       }
     }
   }
@@ -23448,99 +24021,102 @@ var NekoChat = contract("neko.chat", {
     ready: {
       state: { view: ChatViewSchema },
       methods: {
-        submit: rpc(Type7.Object({
+        submit: rpc(Type8.Object({
           content: str,
-          images: Type7.Optional(Type7.Array(str, { maxItems: 4 })),
-          requestId: Type7.Optional(str),
-          whenBusy: Type7.Optional(Type7.Enum(["steer", "followUp"]))
+          images: Type8.Optional(Type8.Array(str, { maxItems: 4 })),
+          requestId: Type8.Optional(str),
+          whenBusy: Type8.Optional(Type8.Enum(["steer", "followUp"]))
         }, { additionalProperties: false }), nil),
         abort: rpc(nil, nil),
-        withdraw: rpc(Type7.Object({ id: integer }, { additionalProperties: false }), WithdrawResultSchema),
-        steer: rpc(Type7.Object({ id: integer }, { additionalProperties: false }), SteerResultSchema),
-        questionGet: rpc(Type7.Object({ id: integer }, { additionalProperties: false }), Type7.Union([QuestionRecordSchema, nil])),
-        questionRespond: rpc(Type7.Object({ id: integer, version: str, response: QuestionResponseSchema }, { additionalProperties: false }), QuestionRecordSchema),
+        withdraw: rpc(Type8.Object({ id: integer }, { additionalProperties: false }), WithdrawResultSchema),
+        steer: rpc(Type8.Object({ id: integer }, { additionalProperties: false }), SteerResultSchema),
+        questionGet: rpc(Type8.Object({ id: integer }, { additionalProperties: false }), Type8.Union([QuestionRecordSchema, nil])),
+        questionRespond: rpc(Type8.Object({ id: integer, version: str, response: QuestionResponseSchema }, { additionalProperties: false }), QuestionRecordSchema),
+        planGet: rpc(Type8.Object({ version: str }, { additionalProperties: false }), Type8.Union([PlanRecordSchema, nil])),
+        planRespond: rpc(Type8.Object({ version: str, decision: PlanDecisionSchema }, { additionalProperties: false }), PlanRecordSchema),
+        planMode: rpc(Type8.Object({ mode: Type8.Enum(["normal", "plan"]) }, { additionalProperties: false }), PlanViewSchema),
         usage: rpc(nil, usage),
-        workspaceDir: rpc(Type7.Object({ path: str }, { additionalProperties: false }), WorkspaceDirSchema),
-        workspaceFile: rpc(Type7.Object({ path: str }, { additionalProperties: false }), WorkspaceFileSchema),
+        workspaceDir: rpc(Type8.Object({ path: str }, { additionalProperties: false }), WorkspaceDirSchema),
+        workspaceFile: rpc(Type8.Object({ path: str }, { additionalProperties: false }), WorkspaceFileSchema),
         changesList: rpc(nil, ChangeListSchema),
-        changeGet: rpc(Type7.Object({ path: str }, { additionalProperties: false }), Type7.Union([ChangeDetailSchema, nil])),
-        skills: rpc(nil, Type7.Array(Type7.Object({ name: str, description: str, location: str, level }))),
-        jobOutput: rpc(Type7.Object({ jobId: str, since: Type7.Optional(integer) }, { additionalProperties: false }), JobOutputSchema),
-        jobStop: rpc(Type7.Object({ jobId: str }, { additionalProperties: false }), JobSummarySchema),
+        changeGet: rpc(Type8.Object({ path: str }, { additionalProperties: false }), Type8.Union([ChangeDetailSchema, nil])),
+        skills: rpc(nil, Type8.Array(Type8.Object({ name: str, description: str, location: str, level }))),
+        jobOutput: rpc(Type8.Object({ jobId: str, since: Type8.Optional(integer) }, { additionalProperties: false }), JobOutputSchema),
+        jobStop: rpc(Type8.Object({ jobId: str }, { additionalProperties: false }), JobSummarySchema),
         configure: rpc(change, nil),
-        compact: rpc(Type7.Object({ instructions: Type7.Optional(str) }, { additionalProperties: false }), nil),
-        importImage: rpc(str, Type7.Object({ id: str, name: str })),
-        draftImage: rpc(Type7.Object({ id: str, offset: integer }, { additionalProperties: false }), imageChunk),
-        beginImage: rpc(Type7.Object({ name: str, mimeType: str, size: Type7.Integer({ minimum: 1, maximum: 20971520 }) }, { additionalProperties: false }), str),
-        appendImage: rpc(Type7.Object({ id: str, offset: integer, data: Type7.String({ maxLength: 350000 }) }, { additionalProperties: false }), nil),
+        compact: rpc(Type8.Object({ instructions: Type8.Optional(str) }, { additionalProperties: false }), nil),
+        importImage: rpc(str, Type8.Object({ id: str, name: str })),
+        draftImage: rpc(Type8.Object({ id: str, offset: integer }, { additionalProperties: false }), imageChunk),
+        beginImage: rpc(Type8.Object({ name: str, mimeType: str, size: Type8.Integer({ minimum: 1, maximum: 20971520 }) }, { additionalProperties: false }), str),
+        appendImage: rpc(Type8.Object({ id: str, offset: integer, data: Type8.String({ maxLength: 350000 }) }, { additionalProperties: false }), nil),
         finishImage: rpc(str, nil),
         releaseImage: rpc(str, nil),
-        getImage: rpc(Type7.Object({ entryId: integer, contentIndex: integer, offset: integer }, { additionalProperties: false }), imageChunk)
+        getImage: rpc(Type8.Object({ entryId: integer, contentIndex: integer, offset: integer }, { additionalProperties: false }), imageChunk)
       }
     }
   }
 });
-var browse = Type7.Object({ path: str, query: Type7.Optional(str), showHidden: Type7.Optional(bool), cursor: Type7.Optional(str) }, { additionalProperties: false });
-var page = Type7.Object({
+var browse = Type8.Object({ path: str, query: Type8.Optional(str), showHidden: Type8.Optional(bool), cursor: Type8.Optional(str) }, { additionalProperties: false });
+var page = Type8.Object({
   path: str,
   parent: nullableString,
-  entries: Type7.Array(Type7.Object({ name: str, path: str, error: Type7.Optional(str) })),
+  entries: Type8.Array(Type8.Object({ name: str, path: str, error: Type8.Optional(str) })),
   next: nullableString
 });
 var NekoWorkspaces = contract("neko.workspaces", {
   version: 1,
-  input: Type7.Object({}, { additionalProperties: false }),
+  input: Type8.Object({}, { additionalProperties: false }),
   variants: {
     ready: {
       state: { state: WorkspaceStateSchema },
       methods: {
-        add: rpc(Type7.Object({ path: str }, { additionalProperties: false }), WorkspaceSummarySchema),
+        add: rpc(Type8.Object({ path: str }, { additionalProperties: false }), WorkspaceSummarySchema),
         browse: rpc(browse, page)
       }
     }
   }
 });
-var provider = Type7.String({ minLength: 1, maxLength: 64 });
+var provider = Type8.String({ minLength: 1, maxLength: 64 });
 var NekoCredentials = contract("neko.credentials", {
   version: 2,
-  input: Type7.Object({}, { additionalProperties: false }),
+  input: Type8.Object({}, { additionalProperties: false }),
   variants: {
     ready: {
       state: { state: CredentialStateSchema },
       methods: {
-        save: rpc(Type7.Object({ provider, key: Type7.String({ minLength: 1, maxLength: 8192 }) }, { additionalProperties: false }), nil),
-        remove: rpc(Type7.Object({ provider }, { additionalProperties: false }), nil),
-        setEnabled: rpc(Type7.Object({ provider, enabled: bool }, { additionalProperties: false }), nil)
+        save: rpc(Type8.Object({ provider, key: Type8.String({ minLength: 1, maxLength: 8192 }) }, { additionalProperties: false }), nil),
+        remove: rpc(Type8.Object({ provider }, { additionalProperties: false }), nil),
+        setEnabled: rpc(Type8.Object({ provider, enabled: bool }, { additionalProperties: false }), nil)
       }
     }
   }
 });
-var SearchSettingsStateSchema = Type7.Object({
+var SearchSettingsStateSchema = Type8.Object({
   revision: integer,
-  selected: Type7.Enum(["tavily", "deepseek"])
+  selected: Type8.Enum(["tavily", "deepseek"])
 });
 var NekoSearchSettings = contract("neko.search-settings", {
   version: 1,
-  input: Type7.Object({}, { additionalProperties: false }),
+  input: Type8.Object({}, { additionalProperties: false }),
   variants: {
     ready: {
       state: { state: SearchSettingsStateSchema },
       methods: {
-        set: rpc(Type7.Object({ provider: Type7.Enum(["tavily", "deepseek"]) }, { additionalProperties: false }), nil)
+        set: rpc(Type8.Object({ provider: Type8.Enum(["tavily", "deepseek"]) }, { additionalProperties: false }), nil)
       }
     }
   }
 });
-var contextSource = Type7.Enum(["default", "config", "saved"]);
-var ContextSettingsStateSchema = Type7.Object({
+var contextSource = Type8.Enum(["default", "config", "saved"]);
+var ContextSettingsStateSchema = Type8.Object({
   revision: integer,
-  effective: Type7.Object({
-    compaction: Type7.Object({
+  effective: Type8.Object({
+    compaction: Type8.Object({
       enabled: bool,
-      triggerPercent: Type7.Union([integer, nil]),
+      triggerPercent: Type8.Union([integer, nil]),
       keepRecentTokens: integer
     }),
-    pruning: Type7.Object({
+    pruning: Type8.Object({
       enabled: bool,
       triggerPercent: integer,
       keepRecent: integer,
@@ -23548,9 +24124,9 @@ var ContextSettingsStateSchema = Type7.Object({
       minSavePercent: integer
     })
   }),
-  sources: Type7.Object({
-    compaction: Type7.Object({ enabled: contextSource, triggerPercent: contextSource, keepRecentTokens: contextSource }),
-    pruning: Type7.Object({
+  sources: Type8.Object({
+    compaction: Type8.Object({ enabled: contextSource, triggerPercent: contextSource, keepRecentTokens: contextSource }),
+    pruning: Type8.Object({
       enabled: contextSource,
       triggerPercent: contextSource,
       keepRecent: contextSource,
@@ -23559,42 +24135,42 @@ var ContextSettingsStateSchema = Type7.Object({
     })
   })
 });
-var nullable = (schema) => Type7.Union([schema, nil]);
-var ContextSettingsPatchSchema = Type7.Object({
-  compaction: Type7.Optional(Type7.Object({
-    enabled: Type7.Optional(nullable(bool)),
-    triggerPercent: Type7.Optional(nullable(integer)),
-    keepRecentTokens: Type7.Optional(nullable(integer))
+var nullable = (schema) => Type8.Union([schema, nil]);
+var ContextSettingsPatchSchema = Type8.Object({
+  compaction: Type8.Optional(Type8.Object({
+    enabled: Type8.Optional(nullable(bool)),
+    triggerPercent: Type8.Optional(nullable(integer)),
+    keepRecentTokens: Type8.Optional(nullable(integer))
   }, { additionalProperties: false })),
-  pruning: Type7.Optional(Type7.Object({
-    enabled: Type7.Optional(nullable(bool)),
-    triggerPercent: Type7.Optional(nullable(integer)),
-    keepRecent: Type7.Optional(nullable(integer)),
-    minChars: Type7.Optional(nullable(integer)),
-    minSavePercent: Type7.Optional(nullable(integer))
+  pruning: Type8.Optional(Type8.Object({
+    enabled: Type8.Optional(nullable(bool)),
+    triggerPercent: Type8.Optional(nullable(integer)),
+    keepRecent: Type8.Optional(nullable(integer)),
+    minChars: Type8.Optional(nullable(integer)),
+    minSavePercent: Type8.Optional(nullable(integer))
   }, { additionalProperties: false }))
 }, { additionalProperties: false });
 var NekoContextSettings = contract("neko.context-settings", {
   version: 1,
-  input: Type7.Object({}, { additionalProperties: false }),
+  input: Type8.Object({}, { additionalProperties: false }),
   variants: {
     ready: {
       state: { state: ContextSettingsStateSchema },
       methods: {
         set: rpc(ContextSettingsPatchSchema, nil),
-        reset: rpc(Type7.Object({}, { additionalProperties: false }), nil)
+        reset: rpc(Type8.Object({}, { additionalProperties: false }), nil)
       }
     }
   }
 });
-var defaultModelSource = Type7.Enum(["cli", "saved", "config", "default"]);
-var DefaultModelStateSchema = Type7.Object({
+var defaultModelSource = Type8.Enum(["cli", "saved", "config", "default"]);
+var DefaultModelStateSchema = Type8.Object({
   effective: model2,
   source: defaultModelSource
 });
 var NekoDefaultModel = contract("neko.default-model", {
   version: 1,
-  input: Type7.Object({}, { additionalProperties: false }),
+  input: Type8.Object({}, { additionalProperties: false }),
   variants: {
     ready: {
       state: { state: DefaultModelStateSchema },
@@ -23605,23 +24181,23 @@ var NekoDefaultModel = contract("neko.default-model", {
     }
   }
 });
-var FileCandidatesSchema = Type7.Object({
-  entries: Type7.Array(Type7.Object({ name: str, path: str, kind: Type7.Enum(["file", "directory"]) }), { maxItems: 100 }),
+var FileCandidatesSchema = Type8.Object({
+  entries: Type8.Array(Type8.Object({ name: str, path: str, kind: Type8.Enum(["file", "directory"]) }), { maxItems: 100 }),
   limited: bool,
   incomplete: bool
 });
 var NekoWorkspaceFiles = contract("neko.workspace-files", {
   version: 1,
-  input: Type7.Object({}, { additionalProperties: false }),
+  input: Type8.Object({}, { additionalProperties: false }),
   variants: {
     ready: {
       methods: {
-        search: rpc(Type7.Object({ workspaceRoot: str, query: str }, { additionalProperties: false }), FileCandidatesSchema)
+        search: rpc(Type8.Object({ workspaceRoot: str, query: str }, { additionalProperties: false }), FileCandidatesSchema)
       }
     }
   }
 });
-var marketSkill = Type7.Object({
+var marketSkill = Type8.Object({
   name: str,
   description: str,
   category: str,
@@ -23631,48 +24207,48 @@ var marketSkill = Type7.Object({
   sha256: str,
   sizeBytes: integer,
   uploadedAt: str,
-  installed: Type7.Object({ project: bool, user: bool, builtin: bool }),
-  activeLevel: Type7.Union([level, nil])
+  installed: Type8.Object({ project: bool, user: bool, builtin: bool }),
+  activeLevel: Type8.Union([level, nil])
 });
-var preview = Type7.Object({ body: str, files: Type7.Array(str) });
-var scope = Type7.Enum(["user", "project"]);
-var installResult = Type7.Object({ name: str, scope, path: str, shadowedBy: Type7.Optional(scope) });
+var preview = Type8.Object({ body: str, files: Type8.Array(str) });
+var scope = Type8.Enum(["user", "project"]);
+var installResult = Type8.Object({ name: str, scope, path: str, shadowedBy: Type8.Optional(scope) });
 var NekoSkillMarket = contract("neko.skill-market", {
   version: 1,
-  input: Type7.Object({}, { additionalProperties: false }),
+  input: Type8.Object({}, { additionalProperties: false }),
   variants: {
     ready: {
       methods: {
-        list: rpc(Type7.Object({ query: Type7.Optional(str), workspaceRoot: Type7.Optional(str) }, { additionalProperties: false }), Type7.Array(marketSkill)),
-        detail: rpc(Type7.Object({ name: str, workspaceRoot: Type7.Optional(str) }, { additionalProperties: false }), marketSkill),
-        preview: rpc(Type7.Object({ name: str }, { additionalProperties: false }), preview),
-        install: rpc(Type7.Object({ name: str, scope, workspaceRoot: Type7.Optional(str), overwrite: Type7.Optional(bool) }, { additionalProperties: false }), installResult),
-        uninstall: rpc(Type7.Object({ name: str, scope, workspaceRoot: Type7.Optional(str) }, { additionalProperties: false }), nil)
+        list: rpc(Type8.Object({ query: Type8.Optional(str), workspaceRoot: Type8.Optional(str) }, { additionalProperties: false }), Type8.Array(marketSkill)),
+        detail: rpc(Type8.Object({ name: str, workspaceRoot: Type8.Optional(str) }, { additionalProperties: false }), marketSkill),
+        preview: rpc(Type8.Object({ name: str }, { additionalProperties: false }), preview),
+        install: rpc(Type8.Object({ name: str, scope, workspaceRoot: Type8.Optional(str), overwrite: Type8.Optional(bool) }, { additionalProperties: false }), installResult),
+        uninstall: rpc(Type8.Object({ name: str, scope, workspaceRoot: Type8.Optional(str) }, { additionalProperties: false }), nil)
       }
     }
   }
 });
-var ShellStatusSchema = Type7.Union([
-  Type7.Object({ status: Type7.Literal("ready"), path: str, source: Type7.Enum(["config", "auto"]) }),
-  Type7.Object({
-    status: Type7.Literal("missing"),
-    reason: Type7.Enum(["not_found", "invalid_config"]),
-    detail: Type7.Optional(str)
+var ShellStatusSchema = Type8.Union([
+  Type8.Object({ status: Type8.Literal("ready"), path: str, source: Type8.Enum(["config", "auto"]) }),
+  Type8.Object({
+    status: Type8.Literal("missing"),
+    reason: Type8.Enum(["not_found", "invalid_config"]),
+    detail: Type8.Optional(str)
   })
 ]);
-var ApplicationInfoSchema = Type7.Object({
+var ApplicationInfoSchema = Type8.Object({
   runningVersion: str,
   installedVersion: nullableString,
-  protocolVersion: Type7.Integer({ minimum: 1 }),
+  protocolVersion: Type8.Integer({ minimum: 1 }),
   latestVersion: nullableString,
-  checkedAt: Type7.Union([integer, nil]),
-  checkState: Type7.Enum(["unknown", "checking", "ok", "failed", "development"]),
+  checkedAt: Type8.Union([integer, nil]),
+  checkState: Type8.Enum(["unknown", "checking", "ok", "failed", "development"]),
   serverId: str,
-  shell: Type7.Optional(ShellStatusSchema)
+  shell: Type8.Optional(ShellStatusSchema)
 });
 var NekoApplicationInfo = contract("neko.application-info", {
   version: 1,
-  input: Type7.Object({}),
+  input: Type8.Object({}),
   variants: {
     ready: { state: { info: ApplicationInfoSchema }, methods: { check: rpc(nil, ApplicationInfoSchema) } }
   }
@@ -23686,7 +24262,7 @@ function isServerId(value) {
 // packages/gateway/src/mobile/admin.ts
 import { createHash, timingSafeEqual } from "crypto";
 import { ChordError } from "@earendil-works/chord";
-import { Type as Type8 } from "typebox";
+import { Type as Type9 } from "typebox";
 
 // packages/gateway/src/principal.ts
 var HOST_PRINCIPAL = { kind: "host" };
@@ -24015,62 +24591,62 @@ class MobileStore {
 }
 
 // packages/gateway/src/mobile/admin.ts
-var listenerStateSchema = Type8.Union([
-  Type8.Object({ status: Type8.Literal("disabled") }),
-  Type8.Object({ status: Type8.Literal("starting") }),
-  Type8.Object({
-    status: Type8.Literal("listening"),
-    address: Type8.String(),
-    port: Type8.Integer({ minimum: 1, maximum: 65535 }),
-    bindAddress: Type8.Optional(Type8.String()),
-    mode: Type8.Optional(Type8.Union([Type8.Literal("direct"), Type8.Literal("wsl-relay")]))
+var listenerStateSchema = Type9.Union([
+  Type9.Object({ status: Type9.Literal("disabled") }),
+  Type9.Object({ status: Type9.Literal("starting") }),
+  Type9.Object({
+    status: Type9.Literal("listening"),
+    address: Type9.String(),
+    port: Type9.Integer({ minimum: 1, maximum: 65535 }),
+    bindAddress: Type9.Optional(Type9.String()),
+    mode: Type9.Optional(Type9.Union([Type9.Literal("direct"), Type9.Literal("wsl-relay")]))
   }),
-  Type8.Object({ status: Type8.Literal("error"), error: Type8.String() }),
-  Type8.Object({ status: Type8.Literal("stopping") })
+  Type9.Object({ status: Type9.Literal("error"), error: Type9.String() }),
+  Type9.Object({ status: Type9.Literal("stopping") })
 ]);
-var adminDeviceSchema = Type8.Object({
-  deviceId: Type8.String(),
-  name: Type8.String(),
-  pairedAt: Type8.Integer(),
-  lastSeenAt: Type8.Integer(),
-  online: Type8.Boolean()
+var adminDeviceSchema = Type9.Object({
+  deviceId: Type9.String(),
+  name: Type9.String(),
+  pairedAt: Type9.Integer(),
+  lastSeenAt: Type9.Integer(),
+  online: Type9.Boolean()
 });
 var NekoMobileAdmin = contract("neko.mobile-admin", {
   version: 1,
-  input: Type8.Object({ token: Type8.String() }),
+  input: Type9.Object({ token: Type9.String() }),
   variants: {
     admin: {
       methods: {
-        state: rpc(Type8.Null(), Type8.Object({
+        state: rpc(Type9.Null(), Type9.Object({
           state: listenerStateSchema,
-          candidates: Type8.Array(Type8.String()),
-          port: Type8.Integer({ minimum: 1, maximum: 65535 }),
-          certificate: Type8.Union([
-            Type8.Object({ fingerprint: Type8.String(), expiresAt: Type8.Integer() }),
-            Type8.Null()
+          candidates: Type9.Array(Type9.String()),
+          port: Type9.Integer({ minimum: 1, maximum: 65535 }),
+          certificate: Type9.Union([
+            Type9.Object({ fingerprint: Type9.String(), expiresAt: Type9.Integer() }),
+            Type9.Null()
           ]),
-          devices: Type8.Array(adminDeviceSchema),
-          lastConnectedAddress: Type8.Union([Type8.String(), Type8.Null()]),
-          wsl: Type8.Optional(Type8.Union([
-            Type8.Object({ interop: Type8.Boolean(), error: Type8.Union([Type8.String(), Type8.Null()]) }),
-            Type8.Null()
+          devices: Type9.Array(adminDeviceSchema),
+          lastConnectedAddress: Type9.Union([Type9.String(), Type9.Null()]),
+          wsl: Type9.Optional(Type9.Union([
+            Type9.Object({ interop: Type9.Boolean(), error: Type9.Union([Type9.String(), Type9.Null()]) }),
+            Type9.Null()
           ]))
         })),
-        enable: rpc(Type8.Object({
-          address: Type8.String(),
-          port: Type8.Optional(Type8.Integer({ minimum: 1, maximum: 65535 }))
-        }), Type8.Object({
-          status: Type8.Literal("listening"),
-          address: Type8.String(),
-          port: Type8.Integer({ minimum: 1, maximum: 65535 }),
-          bindAddress: Type8.Optional(Type8.String()),
-          mode: Type8.Optional(Type8.Union([Type8.Literal("direct"), Type8.Literal("wsl-relay")]))
+        enable: rpc(Type9.Object({
+          address: Type9.String(),
+          port: Type9.Optional(Type9.Integer({ minimum: 1, maximum: 65535 }))
+        }), Type9.Object({
+          status: Type9.Literal("listening"),
+          address: Type9.String(),
+          port: Type9.Integer({ minimum: 1, maximum: 65535 }),
+          bindAddress: Type9.Optional(Type9.String()),
+          mode: Type9.Optional(Type9.Union([Type9.Literal("direct"), Type9.Literal("wsl-relay")]))
         })),
-        disable: rpc(Type8.Null(), listenerStateSchema),
-        createPairing: rpc(Type8.Null(), Type8.Object({ pairingText: Type8.String(), expiresAt: Type8.Integer() })),
-        cancelPairing: rpc(Type8.Null(), Type8.Null()),
-        revoke: rpc(Type8.Object({ deviceId: Type8.String({ minLength: 1 }) }), Type8.Object({ revoked: Type8.Boolean() })),
-        regenerateCertificate: rpc(Type8.Null(), Type8.Object({ fingerprint: Type8.String(), expiresAt: Type8.Integer() }))
+        disable: rpc(Type9.Null(), listenerStateSchema),
+        createPairing: rpc(Type9.Null(), Type9.Object({ pairingText: Type9.String(), expiresAt: Type9.Integer() })),
+        cancelPairing: rpc(Type9.Null(), Type9.Null()),
+        revoke: rpc(Type9.Object({ deviceId: Type9.String({ minLength: 1 }) }), Type9.Object({ revoked: Type9.Boolean() })),
+        regenerateCertificate: rpc(Type9.Null(), Type9.Object({ fingerprint: Type9.String(), expiresAt: Type9.Integer() }))
       }
     }
   }
@@ -24138,7 +24714,7 @@ function createMobileAdminFactory(deps) {
 }
 
 // packages/gateway/src/mobile/listener.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 import { createServer } from "https";
 import { hostname } from "os";
 import { memoryLinkPair } from "@earendil-works/chord";
@@ -24393,14 +24969,14 @@ function subagentClient(connect) {
 import { createHash as createHash2 } from "crypto";
 
 // packages/core/src/application-version.ts
-var RUNNING_VERSION = "0.4.7";
+var RUNNING_VERSION = "0.4.8";
 var APPLICATION_PROTOCOL = 8;
 function stableVersion(value) {
   return typeof value === "string" && /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.test(value) && value.split(".").every((n) => Number.isSafeInteger(Number(n)));
 }
 
 // packages/gateway/src/mobile/protocol.ts
-import { Type as Type9 } from "typebox";
+import { Type as Type10 } from "typebox";
 import { Check } from "typebox/value";
 var MOBILE_LIMITS = {
   maxFrameBytes: 262144,
@@ -24419,17 +24995,18 @@ var MOBILE_CAPABILITIES = [
   "approvals",
   "media",
   "todos",
-  "questions"
+  "questions",
+  "plan"
 ];
 var MOBILE_CLOSE_REVOKED = 4401;
 var MOBILE_CLOSE_INCOMPATIBLE = 4402;
 var MOBILE_CLOSE_SLOW_CONSUMER = 4408;
-var MobileHelloParams = Type9.Object({
-  apiVersions: Type9.Array(Type9.Integer(), { minItems: 1 }),
-  app: Type9.Object({
-    version: Type9.String({ minLength: 1, maxLength: 64 }),
-    platform: Type9.String({ minLength: 1, maxLength: 64 }),
-    build: Type9.String({ maxLength: 128 })
+var MobileHelloParams = Type10.Object({
+  apiVersions: Type10.Array(Type10.Integer(), { minItems: 1 }),
+  app: Type10.Object({
+    version: Type10.String({ minLength: 1, maxLength: 64 }),
+    platform: Type10.String({ minLength: 1, maxLength: 64 }),
+    build: Type10.String({ maxLength: 128 })
   })
 });
 function asJsonRpcRequest(value) {
@@ -24469,11 +25046,11 @@ function buildHelloResult(serverId, serverName, apiVersion) {
     limits: MOBILE_LIMITS
   };
 }
-var opt = Type9.Optional;
-var str2 = Type9.String();
-var int = Type9.Integer({ minimum: 0 });
-var nullable2 = (schema) => Type9.Union([schema, Type9.Null()]);
-var MobileContentRefSchema = Type9.Object({
+var opt = Type10.Optional;
+var str2 = Type10.String();
+var int = Type10.Integer({ minimum: 0 });
+var nullable2 = (schema) => Type10.Union([schema, Type10.Null()]);
+var MobileContentRefSchema = Type10.Object({
   sessionId: str2,
   agentId: opt(str2),
   key: str2,
@@ -24481,7 +25058,7 @@ var MobileContentRefSchema = Type9.Object({
   digest: str2,
   bytes: int
 });
-var MobileImageRefSchema = Type9.Object({
+var MobileImageRefSchema = Type10.Object({
   name: str2,
   mimeType: str2,
   width: int,
@@ -24490,56 +25067,70 @@ var MobileImageRefSchema = Type9.Object({
   entryId: int,
   contentIndex: int
 });
-var questionStatus2 = Type9.Union([
-  Type9.Literal("pending"),
-  Type9.Literal("answered"),
-  Type9.Literal("skipped"),
-  Type9.Literal("cancelled")
+var planStatus = Type10.Union([
+  Type10.Literal("awaiting_approval"),
+  Type10.Literal("approved"),
+  Type10.Literal("revision_requested"),
+  Type10.Literal("superseded"),
+  Type10.Literal("cancelled")
 ]);
-var MobileToolInteractionSchema = Type9.Union([
-  Type9.Object({
-    kind: Type9.Literal("ask_user"),
+var questionStatus2 = Type10.Union([
+  Type10.Literal("pending"),
+  Type10.Literal("answered"),
+  Type10.Literal("skipped"),
+  Type10.Literal("cancelled")
+]);
+var MobileToolInteractionSchema = Type10.Union([
+  Type10.Object({
+    kind: Type10.Literal("ask_user"),
     id: int,
     question: str2,
-    multiple: Type9.Boolean(),
-    options: Type9.Array(Type9.Object({ id: str2, label: str2, recommended: opt(Type9.Boolean()) })),
+    multiple: Type10.Boolean(),
+    options: Type10.Array(Type10.Object({ id: str2, label: str2, recommended: opt(Type10.Boolean()) })),
     status: questionStatus2,
-    optionIds: opt(Type9.Array(str2)),
-    labels: opt(Type9.Array(str2)),
+    optionIds: opt(Type10.Array(str2)),
+    labels: opt(Type10.Array(str2)),
     text: opt(nullable2(str2))
   }),
-  Type9.Object({
-    kind: Type9.Literal("todo"),
-    action: Type9.Union([Type9.Literal("list"), Type9.Literal("replace")]),
+  Type10.Object({
+    kind: Type10.Literal("todo"),
+    action: Type10.Union([Type10.Literal("list"), Type10.Literal("replace")]),
     revision: int,
     completed: int,
     total: int
+  }),
+  Type10.Object({
+    kind: Type10.Literal("submit_plan"),
+    version: str2,
+    title: str2,
+    steps: Type10.Array(str2),
+    note: str2
   })
 ]);
-var MobileToolItemSchema = Type9.Object({
+var MobileToolItemSchema = Type10.Object({
   callId: str2,
   name: str2,
   summary: str2,
-  status: Type9.Union([Type9.Literal("running"), Type9.Literal("done"), Type9.Literal("error")]),
+  status: Type10.Union([Type10.Literal("running"), Type10.Literal("done"), Type10.Literal("error")]),
   detail: opt(str2),
   output: opt(str2),
   result: opt(str2),
   diff: opt(str2),
-  diffAdded: opt(Type9.Number()),
-  diffRemoved: opt(Type9.Number()),
-  diffTruncated: opt(Type9.Boolean()),
-  durationMs: opt(Type9.Number()),
+  diffAdded: opt(Type10.Number()),
+  diffRemoved: opt(Type10.Number()),
+  diffTruncated: opt(Type10.Boolean()),
+  durationMs: opt(Type10.Number()),
   note: opt(str2),
   interaction: opt(MobileToolInteractionSchema)
 });
-var MobileChatItemSchema = Type9.Object({
+var MobileChatItemSchema = Type10.Object({
   key: str2,
-  type: Type9.Union([
-    Type9.Literal("user"),
-    Type9.Literal("assistant"),
-    Type9.Literal("tool"),
-    Type9.Literal("error"),
-    Type9.Literal("system")
+  type: Type10.Union([
+    Type10.Literal("user"),
+    Type10.Literal("assistant"),
+    Type10.Literal("tool"),
+    Type10.Literal("error"),
+    Type10.Literal("system")
   ]),
   text: opt(str2),
   thinking: opt(str2),
@@ -24548,99 +25139,101 @@ var MobileChatItemSchema = Type9.Object({
   skill: opt(str2),
   jobId: opt(str2),
   tool: opt(MobileToolItemSchema),
-  images: opt(Type9.Array(MobileImageRefSchema)),
-  refs: opt(Type9.Array(MobileContentRefSchema))
+  images: opt(Type10.Array(MobileImageRefSchema)),
+  refs: opt(Type10.Array(MobileContentRefSchema))
 });
-var MobileStreamingSchema = Type9.Object({
+var MobileStreamingSchema = Type10.Object({
   text: str2,
   thinking: str2,
   textOmitted: int,
   thinkingOmitted: int,
-  toolCalls: Type9.Array(Type9.Object({
+  toolCalls: Type10.Array(Type10.Object({
     callId: str2,
     name: str2,
     summary: str2,
-    status: Type9.Union([Type9.Literal("running"), Type9.Literal("done")])
+    status: Type10.Union([Type10.Literal("running"), Type10.Literal("done")])
   }))
 });
-var MobileUsageSchema = Type9.Object({
+var MobileUsageSchema = Type10.Object({
   input: int,
   output: int,
   cacheRead: int,
   cacheWrite: int,
   totalTokens: int,
-  cost: Type9.Number({ minimum: 0 })
+  cost: Type10.Number({ minimum: 0 })
 });
-var MobileSubagentRoundSchema = Type9.Object({
+var MobileSubagentRoundSchema = Type10.Object({
   taskId: int,
   callId: str2,
   agentId: str2,
   round: opt(int),
   role: str2,
   title: str2,
-  status: Type9.Union([
-    Type9.Literal("queued"),
-    Type9.Literal("running"),
-    Type9.Literal("completed"),
-    Type9.Literal("failed"),
-    Type9.Literal("cancelled")
+  status: Type10.Union([
+    Type10.Literal("queued"),
+    Type10.Literal("running"),
+    Type10.Literal("completed"),
+    Type10.Literal("failed"),
+    Type10.Literal("cancelled")
   ]),
   approvalCount: int,
-  readonly: Type9.Boolean(),
-  createdAt: Type9.Number(),
-  endedAt: nullable2(Type9.Number()),
+  readonly: Type10.Boolean(),
+  createdAt: Type10.Number(),
+  endedAt: nullable2(Type10.Number()),
   usage: opt(MobileUsageSchema)
 });
-var MobileAgentSchema = Type9.Object({
+var MobileAgentSchema = Type10.Object({
   agentId: str2,
   role: str2,
   title: str2,
-  status: Type9.Union([Type9.Literal("idle"), Type9.Literal("queued"), Type9.Literal("running")]),
+  status: Type10.Union([Type10.Literal("idle"), Type10.Literal("queued"), Type10.Literal("running")]),
   activeRoundId: nullable2(int),
   lastRoundId: int,
   roundCount: int,
   approvalCount: int
 });
-var MobileQueuedSchema = Type9.Object({
+var MobileQueuedSchema = Type10.Object({
   id: int,
-  mode: Type9.Union([Type9.Literal("steer"), Type9.Literal("followUp")]),
-  preview: Type9.String(),
+  mode: Type10.Union([Type10.Literal("steer"), Type10.Literal("followUp")]),
+  preview: Type10.String(),
   images: int
 });
-var MobileChatStatusSchema = Type9.Object({
-  busy: Type9.Boolean(),
-  queued: opt(Type9.Array(MobileQueuedSchema)),
-  todos: opt(Type9.Object({ revision: int, count: int, completed: int })),
-  questions: opt(Type9.Object({ revision: int, pendingCount: int })),
+var MobileChatStatusSchema = Type10.Object({
+  busy: Type10.Boolean(),
+  queued: opt(Type10.Array(MobileQueuedSchema)),
+  todos: opt(Type10.Object({ revision: int, count: int, completed: int })),
+  questions: opt(Type10.Object({ revision: int, pendingCount: int })),
+  plan: opt(Type10.Object({ revision: int, pending: Type10.Boolean(), version: opt(Type10.String({ minLength: 1 })) })),
   status: nullable2(str2),
   usage: MobileUsageSchema,
   taskUsage: opt(MobileUsageSchema),
-  contextUsage: opt(Type9.Object({ tokens: nullable2(Type9.Number()), window: Type9.Number(), percent: nullable2(Type9.Number()) })),
-  agent: Type9.Object({ model: nullable2(str2), thinkingLevel: nullable2(str2) }),
-  subagents: Type9.Array(MobileSubagentRoundSchema),
-  agents: Type9.Array(MobileAgentSchema),
+  contextUsage: opt(Type10.Object({ tokens: nullable2(Type10.Number()), window: Type10.Number(), percent: nullable2(Type10.Number()) })),
+  agent: Type10.Object({ model: nullable2(str2), thinkingLevel: nullable2(str2) }),
+  subagents: Type10.Array(MobileSubagentRoundSchema),
+  agents: Type10.Array(MobileAgentSchema),
   approvalCount: int,
-  compaction: opt(Type9.Object({ phase: str2, at: Type9.Number() })),
-  readonly: opt(Type9.Boolean())
+  compaction: opt(Type10.Object({ phase: str2, at: Type10.Number() })),
+  readonly: opt(Type10.Boolean())
 });
-var MobileChatSnapshotSchema = Type9.Object({
+var MobileChatSnapshotSchema = Type10.Object({
   ...MobileChatStatusSchema.properties,
-  items: Type9.Array(MobileChatItemSchema),
+  items: Type10.Array(MobileChatItemSchema),
   historyBefore: nullable2(str2),
   streaming: nullable2(MobileStreamingSchema)
 });
-var MobileWorkspaceSchema = Type9.Object({ root: str2, name: str2 });
-var MobileSessionSummarySchema = Type9.Object({
+var MobileWorkspaceSchema = Type10.Object({ root: str2, name: str2 });
+var MobileSessionSummarySchema = Type10.Object({
   id: str2,
   workspace: str2,
   title: str2,
   preview: str2,
-  lastUsedAt: Type9.Integer(),
-  lastMessageAt: Type9.Integer(),
-  archived: Type9.Boolean(),
-  awaitingAnswer: opt(Type9.Boolean())
+  lastUsedAt: Type10.Integer(),
+  lastMessageAt: Type10.Integer(),
+  archived: Type10.Boolean(),
+  awaitingAnswer: opt(Type10.Boolean()),
+  awaitingPlan: opt(Type10.Boolean())
 });
-var MobileApprovalSchema = Type9.Object({
+var MobileApprovalSchema = Type10.Object({
   id: int,
   version: str2,
   taskId: int,
@@ -24648,236 +25241,267 @@ var MobileApprovalSchema = Type9.Object({
   title: opt(str2),
   command: str2,
   cwd: str2,
-  timeoutSeconds: opt(Type9.Number({ minimum: 0 })),
-  requestedAt: Type9.Number()
+  timeoutSeconds: opt(Type10.Number({ minimum: 0 })),
+  requestedAt: Type10.Number()
 });
-var MobileTodoItemSchema = Type9.Object({
-  id: Type9.String({ minLength: 1, maxLength: TODO_LIMITS.idChars }),
-  text: Type9.String({ minLength: 1, maxLength: TODO_LIMITS.textChars }),
-  status: Type9.Union([Type9.Literal("pending"), Type9.Literal("in_progress"), Type9.Literal("completed")])
+var MobileTodoItemSchema = Type10.Object({
+  id: Type10.String({ minLength: 1, maxLength: TODO_LIMITS.idChars }),
+  text: Type10.String({ minLength: 1, maxLength: TODO_LIMITS.textChars }),
+  status: Type10.Union([Type10.Literal("pending"), Type10.Literal("in_progress"), Type10.Literal("completed")])
 });
-var MobileTodoListSchema = Type9.Object({
+var MobileTodoListSchema = Type10.Object({
   revision: int,
-  items: Type9.Array(MobileTodoItemSchema, { maxItems: TODO_LIMITS.maxItems })
+  items: Type10.Array(MobileTodoItemSchema, { maxItems: TODO_LIMITS.maxItems })
 });
-var MobileQuestionOptionSchema = Type9.Object({
-  id: Type9.String({ minLength: 1, maxLength: QUESTION_LIMITS.optionIdChars }),
-  label: Type9.String({ minLength: 1, maxLength: QUESTION_LIMITS.labelChars }),
-  description: opt(Type9.String({ maxLength: QUESTION_LIMITS.descriptionChars })),
-  recommended: opt(Type9.Boolean())
+var MobileQuestionOptionSchema = Type10.Object({
+  id: Type10.String({ minLength: 1, maxLength: QUESTION_LIMITS.optionIdChars }),
+  label: Type10.String({ minLength: 1, maxLength: QUESTION_LIMITS.labelChars }),
+  description: opt(Type10.String({ maxLength: QUESTION_LIMITS.descriptionChars })),
+  recommended: opt(Type10.Boolean())
 });
-var MobileQuestionSummarySchema = Type9.Object({
+var MobileQuestionSummarySchema = Type10.Object({
   id: int,
   version: str2,
-  preview: Type9.String({ maxLength: QUESTION_LIMITS.previewChars }),
-  multiple: Type9.Boolean(),
+  preview: Type10.String({ maxLength: QUESTION_LIMITS.previewChars }),
+  multiple: Type10.Boolean(),
   optionCount: int,
-  createdAt: Type9.Number()
+  createdAt: Type10.Number()
 });
-var MobileQuestionListSchema = Type9.Object({
+var MobileQuestionListSchema = Type10.Object({
   revision: int,
-  pending: Type9.Array(MobileQuestionSummarySchema, { maxItems: QUESTION_LIMITS.maxPending })
+  pending: Type10.Array(MobileQuestionSummarySchema, { maxItems: QUESTION_LIMITS.maxPending })
 });
-var MobileQuestionSchema = Type9.Object({
+var MobileQuestionSchema = Type10.Object({
   id: int,
   callId: str2,
   version: str2,
-  question: Type9.String({ maxLength: QUESTION_LIMITS.questionChars }),
-  multiple: Type9.Boolean(),
-  options: Type9.Array(MobileQuestionOptionSchema, { maxItems: QUESTION_LIMITS.maxOptions }),
+  question: Type10.String({ maxLength: QUESTION_LIMITS.questionChars }),
+  multiple: Type10.Boolean(),
+  options: Type10.Array(MobileQuestionOptionSchema, { maxItems: QUESTION_LIMITS.maxOptions }),
   status: questionStatus2,
-  answer: nullable2(Type9.Object({
-    optionIds: Type9.Array(Type9.String(), { maxItems: QUESTION_LIMITS.maxOptions }),
-    text: nullable2(Type9.String({ maxLength: QUESTION_LIMITS.textChars }))
+  answer: nullable2(Type10.Object({
+    optionIds: Type10.Array(Type10.String(), { maxItems: QUESTION_LIMITS.maxOptions }),
+    text: nullable2(Type10.String({ maxLength: QUESTION_LIMITS.textChars }))
   })),
-  createdAt: Type9.Number(),
-  settledAt: nullable2(Type9.Number())
+  createdAt: Type10.Number(),
+  settledAt: nullable2(Type10.Number())
 });
-var MobileQuestionResponseSchema = Type9.Union([
-  Type9.Object({
-    kind: Type9.Literal("answer"),
-    optionIds: opt(Type9.Array(Type9.String(), { maxItems: QUESTION_LIMITS.maxOptions })),
-    text: opt(Type9.String({ maxLength: QUESTION_LIMITS.textChars }))
+var MobileQuestionResponseSchema = Type10.Union([
+  Type10.Object({
+    kind: Type10.Literal("answer"),
+    optionIds: opt(Type10.Array(Type10.String(), { maxItems: QUESTION_LIMITS.maxOptions })),
+    text: opt(Type10.String({ maxLength: QUESTION_LIMITS.textChars }))
   }, { additionalProperties: false }),
-  Type9.Object({ kind: Type9.Literal("skip") }, { additionalProperties: false })
+  Type10.Object({ kind: Type10.Literal("skip") }, { additionalProperties: false })
+]);
+var MobilePlanSchema = Type10.Object({
+  version: Type10.String({ minLength: 1 }),
+  title: Type10.String({ maxLength: PLAN_LIMITS.titleChars }),
+  steps: Type10.Array(Type10.String({ maxLength: PLAN_LIMITS.stepChars }), { maxItems: PLAN_LIMITS.maxSteps }),
+  note: Type10.String({ maxLength: PLAN_LIMITS.noteChars }),
+  status: planStatus,
+  feedback: nullable2(Type10.String({ maxLength: PLAN_LIMITS.feedbackChars })),
+  createdAt: Type10.Number(),
+  settledAt: nullable2(Type10.Number())
+});
+var MobilePlanDecisionSchema = Type10.Union([
+  Type10.Object({ kind: Type10.Literal("approve") }, { additionalProperties: false }),
+  Type10.Object({ kind: Type10.Literal("revise"), feedback: Type10.String({ minLength: 1, maxLength: PLAN_LIMITS.feedbackChars }) }, { additionalProperties: false })
 ]);
-var sessionListParams = Type9.Object({
+var sessionListParams = Type10.Object({
   workspace: str2,
   query: opt(str2),
   cursor: opt(str2)
 });
-var sessionListResult = Type9.Object({
-  sessions: Type9.Array(MobileSessionSummarySchema),
+var sessionListResult = Type10.Object({
+  sessions: Type10.Array(MobileSessionSummarySchema),
   nextCursor: opt(str2)
 });
-var subscription = { subscriptionId: Type9.String({ minLength: 1 }) };
-var pageResult = Type9.Object({ items: Type9.Array(MobileChatItemSchema), historyBefore: nullable2(str2) });
-var pageParams = Type9.Object({
+var subscription = { subscriptionId: Type10.String({ minLength: 1 }) };
+var pageResult = Type10.Object({ items: Type10.Array(MobileChatItemSchema), historyBefore: nullable2(str2) });
+var pageParams = Type10.Object({
   ...subscription,
-  before: Type9.String({ minLength: 1 }),
-  limit: opt(Type9.Integer({ minimum: 1, maximum: 50 }))
+  before: Type10.String({ minLength: 1 }),
+  limit: opt(Type10.Integer({ minimum: 1, maximum: 50 }))
 });
-var chunkResult = Type9.Object({ data: str2, nextOffset: int, total: int, done: Type9.Boolean() });
+var chunkResult = Type10.Object({ data: str2, nextOffset: int, total: int, done: Type10.Boolean() });
 var MOBILE_API_V1_METHODS = {
   "server.hello": { params: MobileHelloParams, result: buildHelloResultSchema() },
-  "workspaces.list": { params: Type9.Null(), result: Type9.Object({ workspaces: Type9.Array(MobileWorkspaceSchema) }) },
+  "workspaces.list": { params: Type10.Null(), result: Type10.Object({ workspaces: Type10.Array(MobileWorkspaceSchema) }) },
   "sessions.list": { params: sessionListParams, result: sessionListResult },
-  "sessions.create": { params: Type9.Object({ workspace: str2 }), result: MobileSessionSummarySchema },
+  "sessions.create": { params: Type10.Object({ workspace: str2 }), result: MobileSessionSummarySchema },
   "chat.attach": {
-    params: Type9.Object({ sessionId: Type9.String({ minLength: 1 }) }),
-    result: Type9.Object({ subscriptionId: str2, sessionId: str2, snapshot: MobileChatSnapshotSchema })
+    params: Type10.Object({ sessionId: Type10.String({ minLength: 1 }) }),
+    result: Type10.Object({ subscriptionId: str2, sessionId: str2, snapshot: MobileChatSnapshotSchema })
   },
-  "chat.detach": { params: Type9.Object(subscription), result: Type9.Null() },
+  "chat.detach": { params: Type10.Object(subscription), result: Type10.Null() },
   "chat.history": { params: pageParams, result: pageResult },
   "chat.content": {
-    params: Type9.Object({ ref: MobileContentRefSchema, offset: int }),
+    params: Type10.Object({ ref: MobileContentRefSchema, offset: int }),
     result: chunkResult
   },
   "chat.submit": {
-    params: Type9.Object({
+    params: Type10.Object({
       ...subscription,
-      requestId: Type9.String({ minLength: 1, maxLength: 128 }),
-      text: Type9.String({ minLength: 1, maxLength: 65536 }),
-      mode: opt(Type9.Literal("steer"))
+      requestId: Type10.String({ minLength: 1, maxLength: 128 }),
+      text: Type10.String({ minLength: 1, maxLength: 65536 }),
+      mode: opt(Type10.Literal("steer"))
     }),
-    result: Type9.Object({ accepted: Type9.Literal(true), queued: Type9.Boolean() })
+    result: Type10.Object({ accepted: Type10.Literal(true), queued: Type10.Boolean() })
   },
   "chat.submissionStatus": {
-    params: Type9.Object({ ...subscription, requestId: Type9.String({ minLength: 1, maxLength: 128 }) }),
-    result: Type9.Object({ status: Type9.Union([Type9.Literal("accepted"), Type9.Literal("unknown")]) })
+    params: Type10.Object({ ...subscription, requestId: Type10.String({ minLength: 1, maxLength: 128 }) }),
+    result: Type10.Object({ status: Type10.Union([Type10.Literal("accepted"), Type10.Literal("unknown")]) })
   },
   "chat.steer": {
-    params: Type9.Object({ ...subscription, id: int }),
-    result: Type9.Object({
-      result: Type9.Union([
-        Type9.Literal("steered"),
-        Type9.Literal("withdrawn"),
-        Type9.Literal("placed"),
-        Type9.Literal("settled"),
-        Type9.Literal("unknown")
+    params: Type10.Object({ ...subscription, id: int }),
+    result: Type10.Object({
+      result: Type10.Union([
+        Type10.Literal("steered"),
+        Type10.Literal("withdrawn"),
+        Type10.Literal("placed"),
+        Type10.Literal("settled"),
+        Type10.Literal("unknown")
       ]),
       id: opt(int),
-      text: opt(Type9.String()),
+      text: opt(Type10.String()),
       images: opt(int)
     })
   },
   "chat.withdraw": {
-    params: Type9.Object({ ...subscription, id: int }),
-    result: Type9.Object({
-      result: Type9.Union([
-        Type9.Literal("withdrawn"),
-        Type9.Literal("placed"),
-        Type9.Literal("settled"),
-        Type9.Literal("unknown")
+    params: Type10.Object({ ...subscription, id: int }),
+    result: Type10.Object({
+      result: Type10.Union([
+        Type10.Literal("withdrawn"),
+        Type10.Literal("placed"),
+        Type10.Literal("settled"),
+        Type10.Literal("unknown")
       ]),
-      text: opt(Type9.String()),
+      text: opt(Type10.String()),
       images: opt(int)
     })
   },
-  "chat.abort": { params: Type9.Object(subscription), result: Type9.Object({ accepted: Type9.Boolean() }) },
+  "chat.abort": { params: Type10.Object(subscription), result: Type10.Object({ accepted: Type10.Boolean() }) },
   "subagents.open": {
-    params: Type9.Object({ ...subscription, agentId: opt(Type9.String({ minLength: 1 })), taskId: opt(int) }),
-    result: Type9.Object({
+    params: Type10.Object({ ...subscription, agentId: opt(Type10.String({ minLength: 1 })), taskId: opt(int) }),
+    result: Type10.Object({
       subagentSubscriptionId: str2,
       agentId: str2,
       snapshot: MobileChatSnapshotSchema
     })
   },
   "subagents.history": {
-    params: Type9.Object({
-      subagentSubscriptionId: Type9.String({ minLength: 1 }),
-      before: Type9.String({ minLength: 1 }),
-      limit: opt(Type9.Integer({ minimum: 1, maximum: 50 }))
+    params: Type10.Object({
+      subagentSubscriptionId: Type10.String({ minLength: 1 }),
+      before: Type10.String({ minLength: 1 }),
+      limit: opt(Type10.Integer({ minimum: 1, maximum: 50 }))
     }),
     result: pageResult
   },
   "subagents.close": {
-    params: Type9.Object({ subagentSubscriptionId: Type9.String({ minLength: 1 }) }),
-    result: Type9.Null()
+    params: Type10.Object({ subagentSubscriptionId: Type10.String({ minLength: 1 }) }),
+    result: Type10.Null()
   },
   "subagents.stop": {
-    params: Type9.Object({ ...subscription, taskId: int }),
-    result: Type9.Object({ stopped: Type9.Boolean() })
+    params: Type10.Object({ ...subscription, taskId: int }),
+    result: Type10.Object({ stopped: Type10.Boolean() })
   },
   "approvals.list": {
-    params: Type9.Object(subscription),
-    result: Type9.Object({ approvals: Type9.Array(MobileApprovalSchema) })
+    params: Type10.Object(subscription),
+    result: Type10.Object({ approvals: Type10.Array(MobileApprovalSchema) })
   },
-  "approvals.get": { params: Type9.Object({ ...subscription, id: int }), result: MobileApprovalSchema },
+  "approvals.get": { params: Type10.Object({ ...subscription, id: int }), result: MobileApprovalSchema },
   "approvals.decide": {
-    params: Type9.Object({
+    params: Type10.Object({
       ...subscription,
       taskId: int,
       id: int,
-      version: Type9.String({ minLength: 1 }),
-      decision: Type9.Union([Type9.Literal("allow"), Type9.Literal("deny")])
+      version: Type10.String({ minLength: 1 }),
+      decision: Type10.Union([Type10.Literal("allow"), Type10.Literal("deny")])
     }),
-    result: Type9.Object({
-      status: Type9.Union([
-        Type9.Literal("pending"),
-        Type9.Literal("allowed"),
-        Type9.Literal("denied"),
-        Type9.Literal("cancelled")
+    result: Type10.Object({
+      status: Type10.Union([
+        Type10.Literal("pending"),
+        Type10.Literal("allowed"),
+        Type10.Literal("denied"),
+        Type10.Literal("cancelled")
       ])
     })
   },
-  "todos.get": { params: Type9.Object(subscription), result: MobileTodoListSchema },
-  "questions.list": { params: Type9.Object(subscription), result: MobileQuestionListSchema },
-  "questions.get": { params: Type9.Object({ ...subscription, id: int }), result: MobileQuestionSchema },
+  "todos.get": { params: Type10.Object(subscription), result: MobileTodoListSchema },
+  "questions.list": { params: Type10.Object(subscription), result: MobileQuestionListSchema },
+  "questions.get": { params: Type10.Object({ ...subscription, id: int }), result: MobileQuestionSchema },
   "questions.respond": {
-    params: Type9.Object({
+    params: Type10.Object({
       ...subscription,
       id: int,
-      version: Type9.String({ minLength: 1 }),
+      version: Type10.String({ minLength: 1 }),
       response: MobileQuestionResponseSchema
     }),
     result: MobileQuestionSchema
   },
+  "plan.get": {
+    params: Type10.Object({ ...subscription, version: Type10.String({ minLength: 1 }) }),
+    result: MobilePlanSchema
+  },
+  "plan.respond": {
+    params: Type10.Object({
+      ...subscription,
+      version: Type10.String({ minLength: 1 }),
+      decision: MobilePlanDecisionSchema
+    }),
+    result: MobilePlanSchema
+  },
+  "plan.exit": {
+    params: Type10.Object(subscription),
+    result: Type10.Object({ mode: Type10.Literal("normal"), revision: int })
+  },
   "media.read": {
-    params: Type9.Object({
+    params: Type10.Object({
       ...subscription,
-      agentId: opt(Type9.String({ minLength: 1 })),
+      agentId: opt(Type10.String({ minLength: 1 })),
       entryId: int,
       contentIndex: int,
       offset: int
     }),
-    result: Type9.Object({ ...chunkResult.properties, mimeType: str2 })
+    result: Type10.Object({ ...chunkResult.properties, mimeType: str2 })
   }
 };
 function buildHelloResultSchema() {
-  return Type9.Object({
-    apiVersion: Type9.Integer({ minimum: 1 }),
+  return Type10.Object({
+    apiVersion: Type10.Integer({ minimum: 1 }),
     serverId: str2,
     serverName: str2,
     gatewayVersion: str2,
-    capabilities: Type9.Array(str2),
-    limits: Type9.Object({
-      maxFrameBytes: Type9.Integer(),
-      maxPayloadBytes: Type9.Integer(),
-      pageItems: Type9.Integer(),
-      chunkBytes: Type9.Integer(),
-      maxConcurrentRequests: Type9.Integer(),
-      maxSendBufferBytes: Type9.Integer()
+    capabilities: Type10.Array(str2),
+    limits: Type10.Object({
+      maxFrameBytes: Type10.Integer(),
+      maxPayloadBytes: Type10.Integer(),
+      pageItems: Type10.Integer(),
+      chunkBytes: Type10.Integer(),
+      maxConcurrentRequests: Type10.Integer(),
+      maxSendBufferBytes: Type10.Integer()
     })
   });
 }
 var patchBody = {
-  seq: Type9.Integer({ minimum: 1 }),
-  upserts: Type9.Array(MobileChatItemSchema),
+  seq: Type10.Integer({ minimum: 1 }),
+  upserts: Type10.Array(MobileChatItemSchema),
   status: opt(MobileChatStatusSchema),
   streaming: opt(nullable2(MobileStreamingSchema)),
-  streamingAppend: opt(Type9.Object({ text: opt(str2), thinking: opt(str2) }))
+  streamingAppend: opt(Type10.Object({ text: opt(str2), thinking: opt(str2) }))
 };
 var MOBILE_API_V1_NOTIFICATIONS = {
-  "workspaces.changed": Type9.Object({ revision: Type9.Integer({ minimum: 1 }) }),
-  "sessions.changed": Type9.Object({ revision: Type9.Integer({ minimum: 1 }) }),
-  "chat.patch": Type9.Object({ subscriptionId: str2, ...patchBody }),
-  "chat.reset": Type9.Object({ subscriptionId: str2, seq: Type9.Integer({ minimum: 1 }) }),
-  "subagents.patch": Type9.Object({ subagentSubscriptionId: str2, ...patchBody }),
-  "subagents.reset": Type9.Object({ subagentSubscriptionId: str2, seq: Type9.Integer({ minimum: 1 }) }),
-  "approvals.changed": Type9.Object({ subscriptionId: str2, revision: Type9.Integer({ minimum: 1 }) }),
-  "todos.changed": Type9.Object({ subscriptionId: str2, revision: Type9.Integer({ minimum: 1 }) }),
-  "questions.changed": Type9.Object({ subscriptionId: str2, revision: Type9.Integer({ minimum: 1 }) })
+  "workspaces.changed": Type10.Object({ revision: Type10.Integer({ minimum: 1 }) }),
+  "sessions.changed": Type10.Object({ revision: Type10.Integer({ minimum: 1 }) }),
+  "chat.patch": Type10.Object({ subscriptionId: str2, ...patchBody }),
+  "chat.reset": Type10.Object({ subscriptionId: str2, seq: Type10.Integer({ minimum: 1 }) }),
+  "subagents.patch": Type10.Object({ subagentSubscriptionId: str2, ...patchBody }),
+  "subagents.reset": Type10.Object({ subagentSubscriptionId: str2, seq: Type10.Integer({ minimum: 1 }) }),
+  "approvals.changed": Type10.Object({ subscriptionId: str2, revision: Type10.Integer({ minimum: 1 }) }),
+  "todos.changed": Type10.Object({ subscriptionId: str2, revision: Type10.Integer({ minimum: 1 }) }),
+  "questions.changed": Type10.Object({ subscriptionId: str2, revision: Type10.Integer({ minimum: 1 }) }),
+  "plan.changed": Type10.Object({ subscriptionId: str2, revision: Type10.Integer({ minimum: 1 }) })
 };
 
 // packages/gateway/src/mobile/projection.ts
@@ -25088,6 +25712,13 @@ function mapStatus(view, options = {}) {
       }
     },
     ...view.questions === undefined ? {} : { questions: { revision: view.questions.revision, pendingCount: view.questions.pending.length } },
+    ...view.plan === undefined ? {} : {
+      plan: {
+        revision: view.plan.revision,
+        pending: view.plan.current?.status === "awaiting_approval",
+        ...view.plan.current === null ? {} : { version: view.plan.current.version }
+      }
+    },
     status: view.status,
     usage: mapUsage(view.usage),
     ...view.taskUsage === undefined ? {} : { taskUsage: mapUsage(view.taskUsage) },
@@ -25602,6 +26233,12 @@ class MobileAdapter {
         return this.questionsGet(params);
       case "questions.respond":
         return this.questionsRespond(params);
+      case "plan.get":
+        return this.planGet(params);
+      case "plan.respond":
+        return this.planRespond(params);
+      case "plan.exit":
+        return this.planExit(params);
       case "media.read":
         return this.mediaRead(params);
       default:
@@ -25656,7 +26293,8 @@ class MobileAdapter {
         lastUsedAt: Math.round(session.lastUsedAt),
         lastMessageAt: Math.round(messageTime(session)),
         archived: false,
-        ...session.awaitingAnswer === undefined ? {} : { awaitingAnswer: session.awaitingAnswer }
+        ...session.awaitingAnswer === undefined ? {} : { awaitingAnswer: session.awaitingAnswer },
+        ...session.awaitingPlan === undefined ? {} : { awaitingPlan: session.awaitingPlan }
       })),
       ...offset + page.length < sessions.length ? { nextCursor: String(offset + page.length) } : {}
     };
@@ -25675,7 +26313,8 @@ class MobileAdapter {
       lastUsedAt: Math.round(created.lastUsedAt),
       lastMessageAt: Math.round(messageTime(created)),
       archived: false,
-      ...created.awaitingAnswer === undefined ? {} : { awaitingAnswer: created.awaitingAnswer }
+      ...created.awaitingAnswer === undefined ? {} : { awaitingAnswer: created.awaitingAnswer },
+      ...created.awaitingPlan === undefined ? {} : { awaitingPlan: created.awaitingPlan }
     };
   }
   nextId(prefix) {
@@ -25752,7 +26391,8 @@ class MobileAdapter {
       approvalsRunning: false,
       approvalsDirty: false,
       todosRevision: chat.view.value?.todos?.revision ?? 0,
-      questionsRevision: chat.view.value?.questions?.revision ?? 0
+      questionsRevision: chat.view.value?.questions?.revision ?? 0,
+      planRevision: chat.view.value?.plan?.revision ?? 0
     };
     this.chatState = state;
     const snapshot = projection.snapshot();
@@ -25937,6 +26577,11 @@ class MobileAdapter {
       state.questionsRevision = questions;
       this.sendNotification("questions.changed", { subscriptionId: state.subscriptionId, revision: questions });
     }
+    const plan = view?.plan?.revision;
+    if (plan !== undefined && plan > state.planRevision) {
+      state.planRevision = plan;
+      this.sendNotification("plan.changed", { subscriptionId: state.subscriptionId, revision: plan });
+    }
   }
   async todosGet(params) {
     const state = this.requireChat(params);
@@ -25975,6 +26620,31 @@ class MobileAdapter {
       response: params.response
     }), "rejected");
   }
+  async planGet(params) {
+    const state = this.requireChat(params);
+    this.assertAuthorized();
+    if (state.chat.view.value?.plan === undefined)
+      throw new MobileMethodError("not_found", "plan mode is not available");
+    const record = await remote2(() => state.chat.planGet({ version: params.version }));
+    if (record === null)
+      throw new MobileMethodError("not_found", "plan not found in this session");
+    return record;
+  }
+  async planExit(params) {
+    const state = this.requireChat(params);
+    this.assertAuthorized();
+    if (state.chat.view.value?.plan === undefined)
+      throw new MobileMethodError("not_found", "plan mode is not available");
+    const view = await remote2(() => state.chat.planMode({ mode: "normal" }), "rejected");
+    return { mode: "normal", revision: view.revision };
+  }
+  async planRespond(params) {
+    const state = this.requireChat(params);
+    this.assertAuthorized();
+    if (state.chat.view.value?.plan === undefined)
+      throw new MobileMethodError("not_found", "plan mode is not available");
+    return remote2(() => state.chat.planRespond({ version: params.version, decision: params.decision }), "rejected");
+  }
   requireSubagent(params) {
     const state = this.subagentState;
     if (state === undefined || state.subscriptionId !== params.subagentSubscriptionId)
@@ -27278,7 +27948,7 @@ class MobileGateway {
     }
   }
   attachConnection(socket, auth, localAddress) {
-    const connectionId = randomUUID3();
+    const connectionId = randomUUID4();
     const [serverEnd, clientEnd] = memoryLinkPair();
     this.chord.accept(serverEnd, {
       principal: { connectionId, kind: "mobile", deviceId: auth.deviceId, grantRevision: auth.grantRevision },
@@ -27637,7 +28307,7 @@ async function removeGatewayPortFile(nekoDir, serverId) {
 }
 
 // packages/gateway/src/server-services.ts
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 import { ChordError as ChordError5, local as local3, method as method2 } from "@earendil-works/chord";
 
 // packages/core/src/application-updates.ts
@@ -27788,7 +28458,7 @@ class UpdateChecker {
 }
 
 // packages/gateway/src/server-services.ts
-import { Type as Type12 } from "typebox";
+import { Type as Type13 } from "typebox";
 
 // packages/gateway/src/session-host.ts
 import { open as open3 } from "fs/promises";
@@ -27800,7 +28470,7 @@ import {
 } from "@earendil-works/chord";
 import { withAbortSignal as withAbortSignal4 } from "@earendil-works/chord/context";
 import { UsageDoc as UsageDoc4 } from "@earendil-works/pi-durable";
-import { Type as Type11 } from "typebox";
+import { Type as Type12 } from "typebox";
 
 // packages/gateway/src/image-uploads.ts
 var IMAGE_CHUNK_BYTES = 256 * 1024;
@@ -27899,7 +28569,7 @@ class ImageUploads {
 // packages/gateway/src/subagent-host.ts
 import { ChordError as ChordError3, local, opaque } from "@earendil-works/chord";
 import { UsageDoc as UsageDoc3 } from "@earendil-works/pi-durable";
-import { Type as Type10 } from "typebox";
+import { Type as Type11 } from "typebox";
 async function openReader(runtime, childId, parentId, context, through, historyUsage) {
   const child = await runtime.harness.conversation(childId, context);
   if (!child)
@@ -28024,15 +28694,15 @@ async function openReader(runtime, childId, parentId, context, through, historyU
 }
 var ChildProjection = local("neko.subagent-projection", {
   version: 1,
-  input: Type10.Object({ parentId: Type10.Integer(), agentId: Type10.String() }),
+  input: Type11.Object({ parentId: Type11.Integer(), agentId: Type11.String() }),
   members: {
-    revision: Type10.Integer(),
+    revision: Type11.Integer(),
     reader: opaque("neko.subagent-reader@1")
   }
 });
 function installSubagentHost(host, runtime, context) {
   host.serve(ChildProjection, (input, _principal, self2) => {
-    const revision = self2.state("revision", Type10.Integer(), 0);
+    const revision = self2.state("revision", Type11.Integer(), 0);
     const reader = self2.resource("reader", {
       version: 1,
       async open() {
@@ -28073,7 +28743,7 @@ function installSubagentHost(host, runtime, context) {
       parentId: Number(input.sessionId),
       agentId: input.agentId ?? `round-${input.taskId}`
     });
-    const authorizedRevision = self2.state("authorizedRevision", Type10.Integer(), 0);
+    const authorizedRevision = self2.state("authorizedRevision", Type11.Integer(), 0);
     self2.on("authorizedView", shared.revision, async (value, ctx) => {
       try {
         target.value;
@@ -28126,7 +28796,7 @@ function installSubagentHost(host, runtime, context) {
 }
 
 // packages/gateway/src/session-host.ts
-var OwnerInput = Type11.Object({});
+var OwnerInput = Type12.Object({});
 var Owner = local2("neko.attachment-owner", {
   version: 1,
   input: OwnerInput,
@@ -28134,7 +28804,7 @@ var Owner = local2("neko.attachment-owner", {
 });
 var Projection = local2("neko.projection", {
   version: 1,
-  input: Type11.Object({ id: Type11.String() }),
+  input: Type12.Object({ id: Type12.String() }),
   members: {
     view: ChatViewSchema,
     reader: opaque2("neko.projection-reader@1")
@@ -28174,7 +28844,8 @@ async function openProjection(runtime, session, context) {
       "app.neko.subagents",
       "app.neko.jobs",
       "app.neko.todos",
-      "app.neko.questions"
+      "app.neko.questions",
+      "app.neko.plan"
     ].includes(change.record.kind) && change.conversationId === session.id || change.record.kind === "pi.usage" && change.conversationId !== undefined && childIds.has(change.conversationId))))
       changed?.(null);
   });
@@ -28202,7 +28873,7 @@ async function openProjection(runtime, session, context) {
         }
       }, "", { models: runtime.listModels(), contextEntries: view.value.entries, compaction });
       const jobs = (await session.jobs()).map(clipJob);
-      const [todos, questions] = await Promise.all([session.todos(), session.questions()]);
+      const [todos, questions, plan] = await Promise.all([session.todos(), session.questions(), session.plan()]);
       const changes = await session.changeSummary().catch(() => {
         return;
       });
@@ -28223,6 +28894,7 @@ async function openProjection(runtime, session, context) {
         jobs,
         todos,
         questions,
+        plan,
         ...changes ? { changes } : {},
         agents: summarizeSubagents(subagents, (await runtime.harness.snapshot(SubagentsDoc, session.id, context))?.items),
         subagents: subagents.map(({ usageStart: _start, usageEnd: _end, ...entry }) => ({
@@ -28435,6 +29107,21 @@ function serveSessions(host, runtime, context) {
           throw new ChordError4("invalid", error instanceof Error ? error.message : "Cannot answer the question");
         }
       },
+      planGet: async ({ version }) => await projection.value.session.planRecord(version) ?? null,
+      planRespond: async ({ version, decision }) => {
+        try {
+          return await projection.value.session.respondPlan(version, decision);
+        } catch (error) {
+          throw new ChordError4("invalid", error instanceof Error ? error.message : "Cannot decide the plan");
+        }
+      },
+      planMode: async ({ mode }) => {
+        try {
+          return await projection.value.session.setPlanMode(mode);
+        } catch (error) {
+          throw new ChordError4("invalid", error instanceof Error ? error.message : "Cannot change plan mode");
+        }
+      },
       skills: () => runtime.listSkills(projection.value.session.id),
       workspaceDir: async ({ path }, ctx) => {
         try {
@@ -28504,7 +29191,7 @@ function serveSessions(host, runtime, context) {
 }
 
 // packages/gateway/src/skill-market.ts
-import { createHash as createHash6, randomUUID as randomUUID4 } from "crypto";
+import { createHash as createHash6, randomUUID as randomUUID5 } from "crypto";
 import { mkdir as mkdir4, readdir as readdir2, rm as rm4, stat as stat3, writeFile as writeFile4 } from "fs/promises";
 import { homedir as homedir6 } from "os";
 import { dirname as dirname6, join as join11 } from "path";
@@ -29096,7 +29783,7 @@ function createSkillMarketClient(options) {
     const skill = await detail(name);
     const files = unpack(skill, await download(skill));
     await sweepTempDirs(skillsDir);
-    const temp = join11(dirname6(skillsDir), `.tmp-${randomUUID4()}`);
+    const temp = join11(dirname6(skillsDir), `.tmp-${randomUUID5()}`);
     try {
       for (const [relative, bytes] of files) {
         const dest = join11(temp, ...relative.split("/"));
@@ -29105,7 +29792,7 @@ function createSkillMarketClient(options) {
       }
       await mkdir4(skillsDir, { recursive: true });
       if (exists) {
-        const backup = join11(dirname6(skillsDir), `${BACKUP_PREFIX}${randomUUID4()}-${name}`);
+        const backup = join11(dirname6(skillsDir), `${BACKUP_PREFIX}${randomUUID5()}-${name}`);
         await renameWithRetry(target, backup);
         try {
           await renameWithRetry(temp, target, placeRename ? { rename: placeRename } : {});
@@ -29229,7 +29916,7 @@ async function listDrives() {
 // packages/gateway/src/server-services.ts
 var ServerState = local3("neko.server-state", {
   version: 1,
-  input: Type12.Object({}),
+  input: Type13.Object({}),
   members: {
     directory: DirectoryStateSchema,
     workspaces: WorkspaceStateSchema,
@@ -29237,10 +29924,10 @@ var ServerState = local3("neko.server-state", {
     searchSettings: SearchSettingsStateSchema,
     contextSettings: ContextSettingsStateSchema,
     defaultModel: DefaultModelStateSchema,
-    refreshCredentials: method2(Type12.Null(), Type12.Null()),
-    refreshSearchSettings: method2(Type12.Null(), Type12.Null()),
-    refreshContextSettings: method2(Type12.Null(), Type12.Null()),
-    refreshDefaultModel: method2(Type12.Null(), Type12.Null())
+    refreshCredentials: method2(Type13.Null(), Type13.Null()),
+    refreshSearchSettings: method2(Type13.Null(), Type13.Null()),
+    refreshContextSettings: method2(Type13.Null(), Type13.Null()),
+    refreshDefaultModel: method2(Type13.Null(), Type13.Null())
   }
 });
 async function createNekoServerServices(options) {
@@ -29320,7 +30007,8 @@ async function createNekoServerServices(options) {
     lastMessageAt: info.lastMessageAt,
     model: info.model,
     status: info.status,
-    awaitingAnswer: info.awaitingAnswer
+    awaitingAnswer: info.awaitingAnswer,
+    awaitingPlan: info.awaitingPlan
   }));
   const readStatuses = async () => {
     const enabled = new Set(runtime.enabledProviders());
@@ -29519,7 +30207,7 @@ async function createNekoServerServices(options) {
         if (!await runtime.getConversation(toConversationId(id)))
           throw new ChordError5("gone", `Unknown session: ${id}`);
         if (owner.owner.active?.sessionId !== id) {
-          owner.owner.active = { sessionId: id, attachmentId: randomUUID5() };
+          owner.owner.active = { sessionId: id, attachmentId: randomUUID6() };
           await runtime.touchConversation(toConversationId(id));
         }
         return owner.owner.active;
@@ -29853,7 +30541,7 @@ async function bindGateway(runtime, options) {
     listeners.push(wsListener);
   }
   const acceptLocal = (link) => chord.accept(link, {
-    principal: { kind: "local", connectionId: randomUUID6() },
+    principal: { kind: "local", connectionId: randomUUID7() },
     onProtocolMismatch: ({ peer }) => options.onError?.(new Error(`Rejected a client on Chord protocol ${peer ?? "unknown"}; restart or update it.`))
   });
   try {
@@ -29955,7 +30643,7 @@ async function loadOrCreateServerId(nekoDir) {
     if (existing !== "")
       return existing;
   } catch {}
-  const created = randomUUID6();
+  const created = randomUUID7();
   await mkdir6(nekoDir, { recursive: true, mode: 448 });
   await writeFile5(file, `${created}
 `, { mode: 384 });