neko-harness 0.5.2 → 0.5.4

package/dist/gateway.js

@@ -16604,6 +16604,47 @@ import { basename as basename4, dirname as dirname9, join as join13 } from "path
 import { createHost as createHost2 } from "@earendil-works/chord";
 import { BACKGROUND_CONTEXT as BACKGROUND_CONTEXT4 } from "@earendil-works/chord/context";
 
+// packages/core/src/codemode-mode.ts
+var CODEMODE_NAME = "codemode";
+var CODEMODE_MODES = ["off", "on", "only"];
+var DEFAULT_CODEMODE_MODE = "off";
+var isCodemodeMode = (value) => typeof value === "string" && CODEMODE_MODES.includes(value);
+var CODEMODE_LIMITS = {
+  memoryLimitBytes: 256 * 1024 * 1024,
+  maxWorkers: 2,
+  waitMs: 60000
+};
+var CODEMODE_VIEW_LIMITS = {
+  maxCalls: 100,
+  argsChars: 200,
+  errorChars: 200
+};
+function parseCodemodeMode(value, field = "codemode.mode") {
+  if (!isCodemodeMode(value))
+    throw new Error(`"${field}" must be one of ${CODEMODE_MODES.join(", ")}.`);
+  return value;
+}
+function parseCodemodeSettings(value, prefix = "codemode") {
+  if (value === null || typeof value !== "object" || Array.isArray(value))
+    throw new Error(`"${prefix}" must be an object.`);
+  const { mode, ...rest } = value;
+  const unknown = Object.keys(rest)[0];
+  if (unknown !== undefined)
+    throw new Error(`"${prefix}.${unknown}" is not a known setting.`);
+  return mode === undefined ? {} : { mode: parseCodemodeMode(mode, `${prefix}.mode`) };
+}
+function resolveCodemodeSettings(config, saved) {
+  if (isCodemodeMode(saved))
+    return { effective: { mode: saved }, source: "saved" };
+  if (config?.mode !== undefined)
+    return { effective: { mode: config.mode }, source: "config" };
+  return { effective: { mode: DEFAULT_CODEMODE_MODE }, source: "default" };
+}
+// packages/core/src/commits.ts
+function onCommits(session, listener) {
+  const observation = session.observeCommits({ advance: (publication) => listener(publication), end: () => {} });
+  return () => observation.detach();
+}
 // packages/core/src/config.ts
 import { existsSync, readFileSync } from "fs";
 import { homedir } from "os";
@@ -16873,6 +16914,10 @@ function validate(config, source) {
   if (level !== undefined && typeof level !== "string") {
     throw new Error(`neko config: ${source}: "thinkingLevel" must be a string.`);
   }
+  const maxTurns = config.maxTurns;
+  if (maxTurns !== undefined && !(Number.isSafeInteger(maxTurns) && maxTurns >= 1)) {
+    throw new Error(`neko config: ${source}: "maxTurns" must be an integer of 1 or more.`);
+  }
   const storagePath = config.storagePath;
   if (storagePath !== undefined && typeof storagePath !== "string") {
     throw new Error(`neko config: ${source}: "storagePath" must be a string.`);
@@ -16934,6 +16979,73 @@ function validate(config, source) {
       throw new Error(`neko config: ${source}: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
+  if (config.codemode !== undefined) {
+    try {
+      parseCodemodeSettings(config.codemode);
+    } catch (error) {
+      throw new Error(`neko config: ${source}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+}
+// packages/core/src/conversation-follow.ts
+import {
+  ConversationTranscript
+} from "@earendil-works/pi-durable";
+var PAGE_SIZE = 200;
+async function followConversation(conversation, context) {
+  const transcript = new ConversationTranscript((query, limit, ctx) => conversation.entries(query, limit, undefined, ctx), { pageSize: PAGE_SIZE });
+  const watch = await conversation.watch(context);
+  const listeners = new Set;
+  let byId;
+  let value;
+  const complete = async (view) => {
+    while (view.items[0]?.kind === "earlier") {
+      const before = view.items;
+      view = await transcript.loadEarlier(context);
+      if (view.items === before)
+        break;
+    }
+    for (let gap = view.items.find((item) => item.kind === "gap");gap; ) {
+      const before = view.items;
+      view = await transcript.fillGap(gap, context);
+      if (view.items === before)
+        break;
+      gap = view.items.find((item) => item.kind === "gap");
+    }
+    const { items, ...rest } = view;
+    byId = undefined;
+    return { ...rest, entries: items.flatMap((item) => item.kind === "entry" ? [item.entry] : []) };
+  };
+  try {
+    value = await complete(transcript.merge(watch.value));
+  } catch (error) {
+    await watch.stop();
+    throw error;
+  }
+  watch.start(async (call) => {
+    if (call.kind !== "value")
+      return;
+    value = await complete(transcript.merge(call.value));
+    for (const listener of listeners)
+      listener(value);
+  });
+  return {
+    get value() {
+      return value;
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    entry(id) {
+      byId ??= new Map(value.entries.map((entry) => [entry.id, entry]));
+      return byId.get(id);
+    },
+    dispose() {
+      listeners.clear();
+      watch.stop();
+    }
+  };
 }
 // packages/core/src/credentials.ts
 import { chmod, mkdir, open, readFile, stat, unlink } from "fs/promises";
@@ -17146,6 +17258,36 @@ class FileCredentialStore {
 // packages/core/src/file-changes.ts
 import { isAbsolute as isAbsolute2, relative, resolve as resolve3, sep } from "path";
 
+// packages/core/src/change-limits.ts
+var CHANGE_LIMITS = {
+  files: 500,
+  opsPerFile: 50,
+  diffBytes: 2 * 1024 * 1024,
+  opDiffBytes: 64 * 1024,
+  conversations: 64,
+  nestedRecords: 1000
+};
+function clipDiff(diff) {
+  if (Buffer.byteLength(diff, "utf8") <= CHANGE_LIMITS.opDiffBytes)
+    return { diff, truncated: false };
+  const lines = diff.split(`
+`);
+  const kept = [];
+  let bytes = 0;
+  for (const line of lines) {
+    bytes += Buffer.byteLength(line, "utf8") + 1;
+    if (bytes > CHANGE_LIMITS.opDiffBytes)
+      break;
+    kept.push(line);
+  }
+  return { diff: kept.join(`
+`), truncated: true };
+}
+
+// packages/core/src/nested-changes.ts
+import { defineDoc, wrapTool } from "@earendil-works/pi-durable";
+import { createEditTool, createWriteTool } from "@earendil-works/pi-durable/tools";
+
 // packages/core/src/image-prompt.ts
 var DEFAULT_IMAGE_PROMPT = {
   version: 2,
@@ -17310,6 +17452,47 @@ var interactionField = (name, details) => {
   const interaction = toolInteraction(name, details);
   return interaction ? { interaction } : {};
 };
+var clip2 = (text, max) => text.length <= max ? text : `${text.slice(0, max - 1)}\u2026`;
+function codemodeView(calls, fullOutputPath) {
+  const limit = CODEMODE_VIEW_LIMITS.maxCalls;
+  return { calls: calls.slice(0, limit), omitted: Math.max(0, calls.length - limit), fullOutputPath };
+}
+function liveCodemodeView(live, callId) {
+  const slots = (live.nestedTools ?? []).filter((slot) => slot.parentCallId === callId);
+  return codemodeView(slots.map((slot, index) => {
+    const key = /\/c(\d+)$/.exec(slot.callId)?.[1];
+    const summary = slot.summary;
+    return {
+      id: key === undefined ? index + 1 : Number(key),
+      name: slot.name,
+      args: clip2(JSON.stringify(slot.arguments) ?? "", CODEMODE_VIEW_LIMITS.argsChars),
+      status: slot.status !== "done" ? "running" : summary === undefined ? "cancelled" : summary.isError ? "error" : "ok",
+      durationMs: summary?.durationMs ?? null,
+      error: summary?.error === undefined ? null : clip2(summary.error, CODEMODE_VIEW_LIMITS.errorChars)
+    };
+  }), null);
+}
+function codemodeResultView(details) {
+  if (!isRecord(details) || !Array.isArray(details.calls))
+    return;
+  const calls = details.calls.flatMap((call) => {
+    if (!isRecord(call) || typeof call.name !== "string")
+      return [];
+    const { id, args, status, durationMs, error } = call;
+    return [
+      {
+        id: typeof id === "number" ? id : 0,
+        name: call.name,
+        args: typeof args === "string" ? clip2(args, CODEMODE_VIEW_LIMITS.argsChars) : "",
+        status: status === "ok" || status === "error" || status === "cancelled" ? status : "running",
+        durationMs: typeof durationMs === "number" ? durationMs : null,
+        error: typeof error === "string" ? clip2(error, CODEMODE_VIEW_LIMITS.errorChars) : null
+      }
+    ];
+  });
+  return codemodeView(calls, typeof details.fullOutputPath === "string" ? details.fullOutputPath : null);
+}
+var codemodeField = (name, view) => name === CODEMODE_NAME && view ? { codemode: view } : {};
 function summarizeToolCall(name, args) {
   const record = args ?? {};
   switch (name) {
@@ -17342,6 +17525,12 @@ function summarizeToolCall(name, args) {
 `)
       };
     }
+    case "codemode": {
+      const code = typeof record.code === "string" ? record.code : "";
+      const first = code.split(`
+`).find((line) => line.trim() !== "" && !line.trim().startsWith("// @options")) ?? "";
+      return { args: truncateMiddle(first.trim(), 100), detail: code };
+    }
     case "subagent":
       return {
         args: record.action === "list" ? "List agents" : `${record.agentId ?? record.type}: ${record.title}`,
@@ -17452,13 +17641,14 @@ function totalUsage(state) {
   }
   return total;
 }
+var RUN_FAILURE_DETAIL_CHARS = 500;
 function projectChatView(view, modelLabel, options = {}) {
   const live = view.docs["pi.live"] ?? {};
   const usage = totalUsage(view.docs["pi.usage"] ?? { models: {}, tools: {} });
   const agent = view.docs["pi.agent"];
   const agentModel = agent?.model ?? null;
   const contextWindow = options.models?.find((m) => `${m.provider}/${m.modelId}` === (agentModel ? `${agentModel.provider}/${agentModel.modelId}` : modelLabel))?.contextWindow ?? 0;
-  const tokens = contextTokens(options.contextEntries ?? view.entries);
+  const tokens = contextTokens(view.entries);
   const results = new Map;
   for (const entry of view.entries) {
     for (const message of entry.model ?? []) {
@@ -17487,7 +17677,8 @@ function projectChatView(view, modelLabel, options = {}) {
         diff,
         diffAdded: counts?.added ?? null,
         diffRemoved: counts?.removed ?? null,
-        ...interactionField(message.toolName, message.details)
+        ...interactionField(message.toolName, message.details),
+        ...codemodeField(message.toolName, codemodeResultView(message.details))
       });
     }
   }
@@ -17585,7 +17776,8 @@ function projectChatView(view, modelLabel, options = {}) {
             diffAdded: synthesized?.added ?? null,
             diffRemoved: synthesized?.removed ?? null,
             diffTruncated: synthesized?.truncated ?? false,
-            ...interactionField(block.name, slot?.details)
+            ...interactionField(block.name, slot?.details),
+            ...codemodeField(block.name, slot?.status === "running" ? liveCodemodeView(live, block.id) : undefined)
           });
         }
       }
@@ -17608,10 +17800,18 @@ function projectChatView(view, modelLabel, options = {}) {
       percent: tokens !== null && contextWindow > 0 ? tokens / contextWindow * 100 : null
     },
     compaction: {
-      active: [...live.compactions ?? []],
+      active: (live.compactions ?? []).map(({ trigger, ...status }) => ({ ...status, reason: trigger })),
       latest: options.compaction ?? null,
-      ...live.compactionFailure ? { failure: live.compactionFailure } : {}
+      ...live.compactionFailure ? {
+        failure: {
+          taskId: live.compactionFailure.taskId,
+          reason: live.compactionFailure.trigger,
+          error: live.compactionFailure.error
+        }
+      } : {}
     },
+    ...live.run === undefined && live.runFailure ? { runFailure: runFailureView(live.runFailure) } : {},
+    continuable: true,
     model: agentModel !== null ? `${agentModel.provider}/${agentModel.modelId}` : modelLabel,
     agent: {
       model: agentModel,
@@ -17632,6 +17832,13 @@ function projectChatView(view, modelLabel, options = {}) {
     streaming: projectStreaming(live)
   };
 }
+function runFailureView(failure) {
+  const detail = failure.detail?.replace(/\p{Cc}/gu, " ").trim();
+  return {
+    reason: failure.reason,
+    ...detail ? { detail: detail.length > RUN_FAILURE_DETAIL_CHARS ? `${detail.slice(0, RUN_FAILURE_DETAIL_CHARS)}\u2026` : detail } : {}
+  };
+}
 function withArgs(item, name, args) {
   const summary = summarizeToolCall(name, args);
   const synthesized = name === "write" ? synthesizedWriteDiff(args) : null;
@@ -17708,14 +17915,15 @@ ${block.text}`;
         diff: synthesized?.diff ?? null,
         diffAdded: synthesized?.added ?? null,
         diffRemoved: synthesized?.removed ?? null,
-        diffTruncated: synthesized?.truncated ?? false
+        diffTruncated: synthesized?.truncated ?? false,
+        ...codemodeField(block.name, slot?.status === "running" ? liveCodemodeView(live, block.id) : undefined)
       });
     }
   }
   return { thinking, text, toolCalls };
 }
 function contextTokens(entries) {
-  const compacted = entries.reduce((id, entry) => entry.kind === "pi.compaction" ? Math.max(id, entry.id) : id, 0);
+  const compacted = entries.reduce((id, entry) => entry.kind === "pi.compaction" || entry.kind === "pi.reset" ? Math.max(id, entry.id) : id, 0);
   for (let i = entries.length - 1;i >= 0; i--) {
     const entry = entries[i];
     const message = entry.model?.[0];
@@ -17729,24 +17937,87 @@ function contextTokens(entries) {
   return null;
 }
 
+// packages/core/src/nested-changes.ts
+var NestedChangesDoc = defineDoc({
+  kind: "app.neko.nested-changes",
+  checkpointWhen: () => false,
+  version: 1,
+  scope: "conversation",
+  history: "rewindable",
+  fork: "asOf",
+  initial: () => ({ total: 0, dropped: false, items: [] })
+});
+var bytesOf = (items) => items.reduce((sum, item) => sum + Buffer.byteLength(item.diff, "utf8"), 0);
+function addNestedChange(state, change) {
+  const existing = state.items.findIndex((item) => item.id === change.id);
+  if (existing !== -1)
+    state.items.splice(existing, 1);
+  else
+    state.total += 1;
+  state.items.push(change);
+  let bytes = bytesOf(state.items);
+  while (state.items.length > 1 && (state.items.length > CHANGE_LIMITS.nestedRecords || bytes > CHANGE_LIMITS.diffBytes)) {
+    const evicted = state.items.shift();
+    bytes -= Buffer.byteLength(evicted.diff, "utf8");
+    state.dropped = true;
+  }
+}
+function describe2(tool, args, details) {
+  if (tool === "edit") {
+    const raw = editResultDiff(details);
+    if (raw === null)
+      return { diff: "", added: 0, removed: 0, truncated: false };
+    return { ...clipDiff(raw), ...countDiffLines(raw) };
+  }
+  return synthesizedWriteDiff(args) ?? { diff: "", added: 0, removed: 0, truncated: false };
+}
+function nestedChangeWraps() {
+  const wrap = (reference, tool) => wrapTool(reference, (inner) => ({
+    ...inner,
+    execute: async (args, api, context) => {
+      const result = await inner.execute(args, api, context);
+      const path = args?.path;
+      if (result.isError || typeof path !== "string" || path === "")
+        return result;
+      const task = await api.getTask(api.taskId, context);
+      const input = task?.input;
+      if (input?.kind !== "nested" || typeof input.parentCallId !== "string")
+        return result;
+      const parentCallId = input.parentCallId;
+      const change = {
+        id: api.callId,
+        parentCallId,
+        tool,
+        path,
+        ...describe2(tool, args, result.details)
+      };
+      await api.commit(async (tx) => {
+        addNestedChange(await tx.doc(NestedChangesDoc, api.conversationId), change);
+      }, context);
+      return result;
+    }
+  }));
+  return [wrap(createEditTool(), "edit"), wrap(createWriteTool(), "write")];
+}
+
 // packages/core/src/subagents.ts
+import { StringEnum } from "@earendil-works/pi-ai";
 import {
   AssistantEntry,
   configure,
-  defineDoc as defineDoc2,
+  defineDoc as defineDoc4,
   defineExtension,
   defineTask,
   defineTool,
   LiveDoc,
   UsageDoc
 } from "@earendil-works/pi-durable";
-import { Type } from "typebox";
-import { Value } from "typebox/value";
+import { arr, compile, int, lit, nul, num, obj, oneOf, opt, str, union } from "@earendil-works/pi-schema";
 
 // packages/core/src/plan-doc.ts
-import { defineDoc } from "@earendil-works/pi-durable";
+import { defineDoc as defineDoc2 } from "@earendil-works/pi-durable";
 var PLAN_HISTORY = 5;
-var PlanDoc = defineDoc({
+var PlanDoc = defineDoc2({
   kind: "app.neko.plan",
   checkpointWhen: () => false,
   version: 1,
@@ -17756,6 +18027,198 @@ var PlanDoc = defineDoc({
   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.";
+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(`
+`);
+
+// packages/core/src/agent-change.ts
+var ONLY_MODE_MAIN_TOOLS = ["todo", "ask_user", "subagent"];
+var named = (name) => ({ name });
+function onlyModeTools(plan, role) {
+  return [
+    CODEMODE_NAME,
+    ...role === "main" ? [...ONLY_MODE_MAIN_TOOLS, ...plan === "plan" ? ["submit_plan"] : []] : []
+  ];
+}
+function agentChangeFor({ plan, codemode, role }) {
+  const planning = plan === "plan";
+  return {
+    tools: planning ? { remove: PLAN_REMOVED_TOOLS.map(named) } : null,
+    modelTools: codemode === "only" ? onlyModeTools(plan, role).map(named) : planning ? { add: [named("submit_plan")] } : null,
+    extensions: codemode === "off" ? { remove: [{ name: CODEMODE_NAME }] } : { add: [{ name: CODEMODE_NAME }] },
+    instructions: planning ? PLAN_INSTRUCTIONS : null
+  };
+}
+function enabledTools(agent) {
+  const offered = new Set(agent.tools.map((tool) => tool.name));
+  return [...agent.tools, ...agent.callable.filter((tool) => !offered.has(tool.name))];
+}
+var agentInPlanMode = (agent) => agent.instructions === PLAN_INSTRUCTIONS;
+function agentSyncChange(agent, state) {
+  const desired = agentChangeFor(state);
+  const planMismatch = agentInPlanMode(agent) !== (state.plan === "plan");
+  const hasExtension = agent.extensions.some((extension) => extension.name === CODEMODE_NAME);
+  const callable = new Set(agent.callable.map((tool) => tool.name));
+  const offered = agent.tools.map((tool) => tool.name);
+  let codemodeMismatch;
+  if (state.codemode === "off")
+    codemodeMismatch = hasExtension || callable.has(CODEMODE_NAME);
+  else {
+    codemodeMismatch = !hasExtension || !offered.includes(CODEMODE_NAME);
+    if (state.codemode === "only") {
+      const allowed = new Set(onlyModeTools(state.plan, state.role));
+      codemodeMismatch ||= offered.some((name) => !allowed.has(name));
+    }
+  }
+  if (!planMismatch && !codemodeMismatch)
+    return;
+  return {
+    ...planMismatch ? { tools: desired.tools, instructions: desired.instructions } : {},
+    modelTools: desired.modelTools,
+    ...codemodeMismatch ? { extensions: desired.extensions } : {}
+  };
+}
+
+// packages/core/src/codemode.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { CodemodeSandbox } from "@earendil-works/pi-codemode";
+import { defineDoc as defineDoc3, wrapTool as wrapTool2 } from "@earendil-works/pi-durable";
+import { createCodemodeExtension, createCodemodeTool } from "@earendil-works/pi-durable/codemode";
+var CodemodeSettingsDoc = defineDoc3({
+  kind: "app.neko.codemode-settings",
+  checkpointWhen: () => false,
+  version: 1,
+  scope: "conversation",
+  history: "latest",
+  fork: "initial",
+  initial: () => ({ mode: null })
+});
+var CodemodeDoc = defineDoc3({
+  kind: "app.neko.codemode",
+  checkpointWhen: () => false,
+  version: 1,
+  scope: "conversation",
+  history: "rewindable",
+  fork: "asOf",
+  initial: () => ({ mode: "off" })
+});
+var SANDBOX_BUSY = "Codemode sandbox is busy: too many scripts are running. Try again shortly.";
+
+class WorkerLimiter {
+  #max;
+  #waitMs;
+  #tickets = new AsyncLocalStorage;
+  #waiters = [];
+  #running = 0;
+  #reserved = 0;
+  constructor(limits = CODEMODE_LIMITS) {
+    this.#max = limits.maxWorkers;
+    this.#waitMs = limits.waitMs;
+  }
+  get running() {
+    return this.#running;
+  }
+  get waiting() {
+    return this.#waiters.length;
+  }
+  #free() {
+    return this.#running + this.#reserved < this.#max;
+  }
+  #wake() {
+    while (this.#waiters.length > 0 && this.#free()) {
+      this.#reserved += 1;
+      this.#waiters.shift()?.();
+    }
+  }
+  acquireWorker = () => {
+    const ticket = this.#tickets.getStore();
+    if (ticket && !ticket.claimed) {
+      ticket.claimed = true;
+      this.#reserved -= 1;
+    } else if (!this.#free())
+      throw new Error(SANDBOX_BUSY);
+    this.#running += 1;
+    let released = false;
+    return () => {
+      if (released)
+        return;
+      released = true;
+      this.#running -= 1;
+      this.#wake();
+    };
+  };
+  async#admit(signal) {
+    signal?.throwIfAborted();
+    if (this.#waiters.length === 0 && this.#free()) {
+      this.#reserved += 1;
+      return;
+    }
+    await new Promise((resolve, reject) => {
+      let timer;
+      const leave = () => {
+        clearTimeout(timer);
+        signal?.removeEventListener("abort", onAbort);
+      };
+      const grant = () => {
+        leave();
+        resolve();
+      };
+      const drop = (error) => {
+        const index = this.#waiters.indexOf(grant);
+        if (index === -1)
+          return;
+        this.#waiters.splice(index, 1);
+        leave();
+        reject(error);
+      };
+      const onAbort = () => drop(signal?.reason instanceof Error ? signal.reason : new Error("Aborted"));
+      this.#waiters.push(grant);
+      timer = setTimeout(() => drop(new Error(SANDBOX_BUSY)), this.#waitMs);
+      signal?.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+  async run(signal, work) {
+    await this.#admit(signal);
+    const ticket = { claimed: false };
+    try {
+      return await this.#tickets.run(ticket, work);
+    } finally {
+      if (!ticket.claimed) {
+        this.#reserved -= 1;
+        this.#wake();
+      }
+    }
+  }
+}
+function createCodemodeRuntime(limits = CODEMODE_LIMITS) {
+  const limiter = new WorkerLimiter(limits);
+  const sandbox = new CodemodeSandbox({
+    memoryLimitBytes: CODEMODE_LIMITS.memoryLimitBytes,
+    acquireWorker: limiter.acquireWorker
+  });
+  const options = { sandbox, models: false };
+  const base = createCodemodeExtension(options);
+  const reference = createCodemodeTool(options);
+  const extension = {
+    ...base,
+    wraps: [
+      ...base.wraps ?? [],
+      ...nestedChangeWraps(),
+      wrapTool2(reference, (tool) => ({
+        ...tool,
+        execute: (args, api, context) => limiter.run(context.abortSignal, () => tool.execute(args, api, context))
+      }))
+    ]
+  };
+  return { extension, limiter, close: () => sandbox.close() };
+}
 
 // packages/core/src/subagent-usage.ts
 var emptySubagentUsage = () => ({ models: {}, tools: {} });
@@ -17801,7 +18264,7 @@ function subagentUsageTotals(state) {
 
 // packages/core/src/subagents.ts
 var agentIdFor = (childId) => `agent-${childId}`;
-var DelegationsDoc = defineDoc2({
+var DelegationsDoc = defineDoc4({
   kind: "app.neko.delegations",
   checkpointWhen: () => false,
   version: 1,
@@ -17810,7 +18273,7 @@ var DelegationsDoc = defineDoc2({
   fork: "initial",
   initial: () => ({ items: [] })
 });
-var SubagentsDoc = defineDoc2({
+var SubagentsDoc = defineDoc4({
   kind: "app.neko.subagents",
   checkpointWhen: () => false,
   version: 1,
@@ -17819,7 +18282,7 @@ var SubagentsDoc = defineDoc2({
   fork: "initial",
   initial: () => ({ items: [] })
 });
-var SubagentDoc = defineDoc2({
+var SubagentDoc = defineDoc4({
   kind: "app.neko.subagent",
   checkpointWhen: () => false,
   version: 1,
@@ -17828,7 +18291,7 @@ var SubagentDoc = defineDoc2({
   fork: "initial",
   initial: () => ({ role: null, parentId: null })
 });
-var SlotsDoc = defineDoc2({
+var SlotsDoc = defineDoc4({
   kind: "app.neko.subagent-slots",
   checkpointWhen: () => false,
   version: 1,
@@ -17843,7 +18306,7 @@ var ROLE_PROMPTS = {
 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", "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"]);
+var READ_TOOLS = new Set(["read", "find_files", "search_text", "web_search", "web_extract", CODEMODE_NAME]);
 async function refreshDelegations(tx, id) {
   const doc = await tx.doc(DelegationsDoc, id);
   const identities = await tx.doc(SubagentsDoc, id);
@@ -17935,59 +18398,60 @@ async function acquireSlot(tx, round, cwd) {
   slots.items.push({ taskId: round.taskId, parentId: round.parentId, cwd, coder: round.role === "coder" });
   return true;
 }
-var actionParameters = Type.Union([
-  Type.Object({
-    action: Type.Optional(Type.Literal("create")),
-    type: Type.Enum(["explore", "plan", "coder"]),
-    title: Type.String({ minLength: 1, maxLength: 80 }),
-    task: Type.String({ minLength: 1, maxLength: 32768 })
-  }, { additionalProperties: false }),
-  Type.Object({
-    action: Type.Literal("continue"),
-    agentId: Type.String(),
-    title: Type.String({ minLength: 1, maxLength: 80 }),
-    task: Type.String({ minLength: 1, maxLength: 32768 })
-  }, { additionalProperties: false }),
-  Type.Object({
-    action: Type.Literal("list"),
-    cursor: Type.Optional(Type.Integer({ minimum: 0 })),
-    limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 100 }))
-  }, { additionalProperties: false })
+var actionParameters = union([
+  obj({
+    action: opt(lit("create")),
+    type: oneOf(["explore", "plan", "coder"]),
+    title: str({ minLength: 1, maxLength: 80 }),
+    task: str({ minLength: 1, maxLength: 32768 })
+  }),
+  obj({
+    action: lit("continue"),
+    agentId: str(),
+    title: str({ minLength: 1, maxLength: 80 }),
+    task: str({ minLength: 1, maxLength: 32768 })
+  }),
+  obj({
+    action: lit("list"),
+    cursor: opt(int({ minimum: 0 })),
+    limit: opt(int({ minimum: 1, maximum: 100 }))
+  })
 ]);
-var parameters = Type.Object({
-  action: Type.Optional(Type.String({ enum: ["create", "continue", "list"], description: "Defaults to create." })),
-  type: Type.Optional(Type.String({ enum: ["explore", "plan", "coder"], description: "Required for create only." })),
-  agentId: Type.Optional(Type.String({ description: "Required for continue only; use an ID returned by create/list." })),
-  title: Type.Optional(Type.String({ minLength: 1, maxLength: 80, description: "Required for create/continue." })),
-  task: Type.Optional(Type.String({ minLength: 1, maxLength: 32768, description: "Required for create/continue." })),
-  cursor: Type.Optional(Type.Integer({ minimum: 0, description: "List pagination cursor only." })),
-  limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 100, description: "List page size only." }))
-}, { additionalProperties: false });
-var structuredOutputSchema = Type.Union([
-  Type.Object({
-    agentId: Type.String(),
-    roundId: Type.Integer(),
-    status: Type.Enum(["completed", "failed", "cancelled"]),
-    report: Type.String()
-  }, { additionalProperties: false }),
-  Type.Object({
-    items: Type.Array(Type.Object({
-      agentId: Type.String(),
-      parentId: Type.Integer(),
-      childId: Type.Integer(),
-      role: Type.Enum(["explore", "plan", "coder"]),
-      title: Type.String(),
-      status: Type.Enum(["idle", "queued", "running"]),
-      activeRoundId: Type.Union([Type.Integer(), Type.Null()]),
-      lastRoundId: Type.Integer(),
-      lastReport: Type.Optional(Type.Union([Type.String(), Type.Null()])),
-      roundCount: Type.Integer(),
-      taskTitle: Type.String(),
-      approvalCount: Type.Integer(),
-      createdAt: Type.Number()
-    }, { additionalProperties: false })),
-    next: Type.Union([Type.Integer(), Type.Null()])
-  }, { additionalProperties: false })
+var isActionParameters = compile(actionParameters).check;
+var parameters = obj({
+  action: opt(StringEnum(["create", "continue", "list"], { description: "Defaults to create." })),
+  type: opt(StringEnum(["explore", "plan", "coder"], { description: "Required for create only." })),
+  agentId: opt(str({ description: "Required for continue only; use an ID returned by create/list." })),
+  title: opt(str({ minLength: 1, maxLength: 80, description: "Required for create/continue." })),
+  task: opt(str({ minLength: 1, maxLength: 32768, description: "Required for create/continue." })),
+  cursor: opt(int({ minimum: 0, description: "List pagination cursor only." })),
+  limit: opt(int({ minimum: 1, maximum: 100, description: "List page size only." }))
+});
+var structuredOutputSchema = union([
+  obj({
+    agentId: str(),
+    roundId: int(),
+    status: oneOf(["completed", "failed", "cancelled"]),
+    report: str()
+  }),
+  obj({
+    items: arr(obj({
+      agentId: str(),
+      parentId: int(),
+      childId: int(),
+      role: oneOf(["explore", "plan", "coder"]),
+      title: str(),
+      status: oneOf(["idle", "queued", "running"]),
+      activeRoundId: union([int(), nul()]),
+      lastRoundId: int(),
+      lastReport: opt(union([str(), nul()])),
+      roundCount: int(),
+      taskTitle: str(),
+      approvalCount: int(),
+      createdAt: num()
+    })),
+    next: union([int(), nul()])
+  })
 ]);
 var ADMISSION_POLL_MS = 100;
 function pause(runtime, ms) {
@@ -18131,8 +18595,9 @@ function createSubagentExtension(prepare, discard, guard) {
         parameters,
         structuredOutputSchema,
         replay: "safe",
+        callers: ["model"],
         execute: async (input, api, context) => {
-          if (!Value.Check(actionParameters, input))
+          if (!isActionParameters(input))
             throw new Error("Invalid subagent arguments. create requires type/title/task; continue requires agentId/title/task; list accepts only cursor/limit. Do not mix fields from different actions.");
           const args = input;
           if ((await api.snapshot(SubagentDoc, api.conversationId, context))?.role)
@@ -18181,12 +18646,17 @@ function createSubagentExtension(prepare, discard, guard) {
             if (!identity) {
               const created = child ?? await tx.createConversation({ ownership: { kind: "task", taskId: api.taskId } });
               const role = args.action === "continue" ? "explore" : args.type;
+              const codemode = (await tx.doc(CodemodeDoc, api.conversationId)).mode;
+              (await tx.doc(CodemodeDoc, created.id)).mode = codemode;
+              const enabled = enabledTools(agent);
               await configure(tx, created.id, {
                 model: agent.model,
                 thinkingLevel: agent.thinkingLevel,
                 cwd: agent.cwd,
+                maxTurns: agent.maxTurns ?? null,
                 extensions: agent.extensions.filter((e) => e.name !== extension.name && !MAIN_ONLY_EXTENSIONS.has(e.name)),
-                tools: agent.tools.filter((t) => t.name !== "subagent" && t.name !== "job" && !MAIN_ONLY_TOOLS.has(t.name) && (role === "coder" || READ_TOOLS.has(t.name) || role === "explore" && t.name === "bash"))
+                modelTools: agentChangeFor({ plan: "normal", codemode, role: "subagent" }).modelTools,
+                tools: enabled.filter((t) => t.name !== "subagent" && t.name !== "job" && !MAIN_ONLY_TOOLS.has(t.name) && (role === "coder" || READ_TOOLS.has(t.name) || role === "explore" && t.name === "bash"))
               });
               Object.assign(await tx.doc(SubagentDoc, created.id), { role, parentId: api.conversationId });
               identity = {
@@ -18289,9 +18759,10 @@ async function removeMainOnlyTools(harness, ids, context) {
     if (!(await harness.snapshot(SubagentDoc, id, context))?.role)
       continue;
     const agent = await (await harness.conversation(id, context)).agent(context);
-    if (!agent.tools.some((t) => MAIN_ONLY_TOOLS.has(t.name)))
+    const enabled = enabledTools(agent);
+    if (!enabled.some((t) => MAIN_ONLY_TOOLS.has(t.name)))
       continue;
-    await harness.commit((tx) => configure(tx, id, { tools: agent.tools.filter((t) => !MAIN_ONLY_TOOLS.has(t.name)) }), context);
+    await harness.commit((tx) => configure(tx, id, { tools: enabled.filter((t) => !MAIN_ONLY_TOOLS.has(t.name)) }), context);
   }
 }
 async function installSubagentCoordinator(harness, parents, context) {
@@ -18327,7 +18798,7 @@ async function installSubagentCoordinator(harness, parents, context) {
         }, context);
     }
   }
-  const stop = harness.subscribeCommits(({ changes }) => {
+  const stop = onCommits(harness, ({ changes }) => {
     for (const c of changes)
       if (c.type === "document" && c.record.kind === "app.neko.delegations" && c.conversationId !== undefined)
         known.add(c.conversationId);
@@ -18338,13 +18809,6 @@ async function installSubagentCoordinator(harness, parents, context) {
 }
 
 // packages/core/src/file-changes.ts
-var CHANGE_LIMITS = {
-  files: 500,
-  opsPerFile: 50,
-  diffBytes: 2 * 1024 * 1024,
-  opDiffBytes: 64 * 1024,
-  conversations: 64
-};
 var MAIN_AGENT = "main";
 function normalizeChangePath(raw, cwd, workspace) {
   const resolved = raw.startsWith("~") ? raw : resolve3(cwd, raw);
@@ -18355,22 +18819,6 @@ function normalizeChangePath(raw, cwd, workspace) {
   }
   return { path: resolved.split(sep).join("/"), outside: true };
 }
-function clipDiff(diff) {
-  if (Buffer.byteLength(diff, "utf8") <= CHANGE_LIMITS.opDiffBytes)
-    return { diff, truncated: false };
-  const lines = diff.split(`
-`);
-  const kept = [];
-  let bytes = 0;
-  for (const line of lines) {
-    bytes += Buffer.byteLength(line, "utf8") + 1;
-    if (bytes > CHANGE_LIMITS.opDiffBytes)
-      break;
-    kept.push(line);
-  }
-  return { diff: kept.join(`
-`), truncated: true };
-}
 
 class ConversationChanges {
   last = 0;
@@ -18378,6 +18826,7 @@ class ConversationChanges {
   truncated = false;
   bytes = 0;
   files = new Map;
+  #scripts = new Map;
   #pending = new Map;
   #agent;
   #cwd;
@@ -18391,6 +18840,8 @@ class ConversationChanges {
     for (const message of entry.model ?? []) {
       if (message.role === "assistant") {
         for (const block of message.content) {
+          if (block.type === "toolCall" && block.name === CODEMODE_NAME)
+            this.#scripts.set(block.id, entry.id);
           if (block.type !== "toolCall" || block.name !== "edit" && block.name !== "write")
             continue;
           const path = block.arguments?.path;
@@ -18398,6 +18849,8 @@ class ConversationChanges {
             this.#pending.set(block.id, { tool: block.name, path, args: block.arguments });
         }
       } else if (message.role === "toolResult") {
+        if (this.#scripts.has(message.toolCallId))
+          this.#scripts.set(message.toolCallId, entry.id);
         const call = this.#pending.get(message.toolCallId);
         if (!call)
           continue;
@@ -18409,8 +18862,20 @@ class ConversationChanges {
     }
     this.last = entry.id;
   }
+  withNested(nested) {
+    const visible = nested.items.filter((item) => this.#scripts.has(item.parentCallId));
+    const copy = new ConversationChanges(this.#agent, this.#cwd, this.#workspace);
+    copy.last = this.last;
+    copy.total = this.total;
+    copy.truncated = this.truncated || nested.dropped && visible.length > 0;
+    copy.bytes = this.bytes;
+    for (const [path, file] of this.files)
+      copy.files.set(path, { ...file, agents: new Set(file.agents), items: file.items.map((item) => ({ ...item })) });
+    for (const item of visible)
+      copy.#record({ tool: item.tool, path: item.path }, { diff: item.diff, added: item.added, removed: item.removed, truncated: item.truncated }, this.#scripts.get(item.parentCallId));
+    return copy;
+  }
   #add(call, details, seq) {
-    const { path, outside } = normalizeChangePath(call.path, this.#cwd, this.#workspace);
     let diff = "";
     let added = 0;
     let removed = 0;
@@ -18430,6 +18895,11 @@ class ConversationChanges {
         ({ diff, added, removed, truncated } = synthesized);
       }
     }
+    this.#record(call, { diff, added, removed, truncated }, seq);
+  }
+  #record(call, shown, seq) {
+    const { path, outside } = normalizeChangePath(call.path, this.#cwd, this.#workspace);
+    const { diff, added, removed, truncated } = shown;
     this.total++;
     let file = this.files.get(path);
     if (!file) {
@@ -18450,7 +18920,7 @@ class ConversationChanges {
     file.added += added;
     file.removed += removed;
     file.agents.add(this.#agent);
-    file.lastSeq = seq;
+    file.lastSeq = Math.max(file.lastSeq, seq);
     file.items.push({ seq, agent: this.#agent, tool: call.tool, diff, added, removed, truncated });
     this.bytes += Buffer.byteLength(diff, "utf8");
     if (file.items.length > CHANGE_LIMITS.opsPerFile) {
@@ -18552,10 +19022,12 @@ class ChangeTracker {
     let revision = 0;
     let truncated = false;
     for (const member of await this.#members(rootId)) {
-      const state = await this.#sync(member, workspace);
-      if (!state)
+      const synced = await this.#sync(member, workspace);
+      if (!synced)
         continue;
-      revision += state.total;
+      const nested = await this.#harness.snapshot(NestedChangesDoc, member.id, this.#context);
+      const state = nested && nested.items.length > 0 ? synced.withNested(nested) : synced;
+      revision += synced.total + (nested?.total ?? 0);
       truncated ||= state.truncated;
       for (const file of state.files.values()) {
         const existing = merged.get(file.path);
@@ -18960,7 +19432,7 @@ function validatePlanDecision(input) {
   return { kind: "revise", feedback: text(input.feedback, "feedback", PLAN_LIMITS.feedbackChars) };
 }
 // packages/core/src/jobs.ts
-import { defineDoc as defineDoc3 } from "@earendil-works/pi-durable";
+import { defineDoc as defineDoc5 } from "@earendil-works/pi-durable";
 var JOB_LIMITS = {
   maxRunning: 4,
   keepTerminal: 20,
@@ -18974,7 +19446,7 @@ var JOB_LIMITS = {
   commandBytes: 32 * 1024,
   maxTimeoutSeconds: 7 * 24 * 3600
 };
-var JobsDoc = defineDoc3({
+var JobsDoc = defineDoc5({
   kind: "app.neko.jobs",
   checkpointWhen: () => false,
   version: 1,
@@ -19105,6 +19577,9 @@ var parseFrontmatter = (content) => {
   return { frontmatter: parsed ?? {}, body };
 };
 var stripFrontmatter = (content) => extractFrontmatter(content).body;
+// packages/core/src/run-failure.ts
+var CONTINUE_BUSY = "CONTINUE_BUSY: The session is running; wait for it to finish.";
+var CONTINUE_UNAVAILABLE = "CONTINUE_UNAVAILABLE: The last run was answered; there is nothing to continue.";
 // packages/core/src/runtime.ts
 import { homedir as homedir4 } from "os";
 import { join as join5 } from "path";
@@ -19114,14 +19589,15 @@ import { builtinProviders } from "@earendil-works/pi-ai/providers/all";
 import { PI_ATTRIBUTION } from "@earendil-works/pi-ai/utils/identity";
 import {
   AssistantEntry as AssistantEntry2,
+  ConversationBusy,
+  configure as configure3,
   createRegistry,
-  defineDoc as defineDoc8,
+  defineDoc as defineDoc10,
   Harness,
   InboxDoc as InboxDoc3,
   LiveDoc as importLiveDoc,
   MemoryStorage,
-  UsageDoc as UsageDoc2,
-  watchEvents
+  UsageDoc as UsageDoc2
 } from "@earendil-works/pi-durable";
 import { createNodePhotonImages } from "@earendil-works/pi-durable/images/node";
 import { openNodeSqliteStorage } from "@earendil-works/pi-durable/storage/sqlite/node";
@@ -19131,7 +19607,7 @@ import { createCodingTools } from "@earendil-works/pi-durable/tools";
 import { BACKGROUND_CONTEXT, withAbortSignal } from "@earendil-works/chord/context";
 import { defineExtension as defineExtension2, defineTool as defineTool2 } from "@earendil-works/pi-durable";
 import { getOrThrow } from "@earendil-works/pi-durable/env";
-import { Type as Type2 } from "typebox";
+import { bool, int as int2, obj as obj2, opt as opt2, str as str2 } from "@earendil-works/pi-schema";
 var SEARCH_LIMITS = {
   entries: 1e4,
   fileBytes: 2 * 1024 * 1024,
@@ -19139,8 +19615,8 @@ var SEARCH_LIMITS = {
   outputBytes: 32 * 1024,
   timeoutMs: 1e4
 };
-var path = Type2.Optional(Type2.String({ description: "Directory relative to this conversation's cwd, or absolute path." }));
-var limit = Type2.Optional(Type2.Integer({ minimum: 1, maximum: 500, description: "Maximum results (default 100)." }));
+var path = opt2(str2({ description: "Directory relative to this conversation's cwd, or absolute path." }));
+var limit = opt2(int2({ minimum: 1, maximum: 500, description: "Maximum results (default 100)." }));
 var text2 = (value) => ({ type: "text", text: value });
 async function search(api, context, run) {
   if (!api.env)
@@ -19180,7 +19656,7 @@ ${status}${skipped ? ` Skipped/unreadable files: ${skipped}.` : ""}`)],
 var FindFiles = defineTool2({
   name: "find_files",
   description: "Discover files and directories without a shell. query is a literal path/name substring (not a glob). Respects gitignore; returns absolute paths usable by read. A partial result is not a complete absence of matches.",
-  parameters: Type2.Object({ path, query: Type2.Optional(Type2.String()), limit }),
+  parameters: obj2({ path, query: opt2(str2()), limit }, { open: true }),
   replay: "safe",
   execute: (args, api, context) => search(api, context, async (env, ctx) => {
     const files = await listing(env, args.path ?? ".", ctx);
@@ -19206,14 +19682,14 @@ var FindFiles = defineTool2({
 var SearchText = defineTool2({
   name: "search_text",
   description: "Search UTF-8 file contents without a shell. pattern and filePattern are literal substrings, not regex/globs. Returns absolute paths, 1-based line numbers and context for read. Binary/large/unreadable files and exhausted budgets are explicitly reported as partial results.",
-  parameters: Type2.Object({
-    pattern: Type2.String({ minLength: 1, maxLength: 4096 }),
+  parameters: obj2({
+    pattern: str2({ minLength: 1, maxLength: 4096 }),
     path,
-    filePattern: Type2.Optional(Type2.String()),
-    caseSensitive: Type2.Optional(Type2.Boolean()),
-    contextLines: Type2.Optional(Type2.Integer({ minimum: 0, maximum: 5 })),
+    filePattern: opt2(str2()),
+    caseSensitive: opt2(bool()),
+    contextLines: opt2(int2({ minimum: 0, maximum: 5 })),
     limit
-  }),
+  }, { open: true }),
   replay: "safe",
   execute: (args, api, context) => search(api, context, async (env, ctx) => {
     const files = await listing(env, args.path ?? ".", ctx);
@@ -19382,7 +19858,7 @@ class ContextPruner {
   #closed = false;
   constructor(options) {
     this.#options = options;
-    this.#unsubscribe = options.harness.subscribeCommits(({ changes }) => {
+    this.#unsubscribe = onCommits(options.harness, ({ changes }) => {
       if (!options.settings().enabled)
         return;
       for (const change of changes) {
@@ -19490,7 +19966,7 @@ import {
   defineTask as defineTask2,
   defineTool as defineTool3
 } from "@earendil-works/pi-durable";
-import { Type as Type3 } from "typebox";
+import { int as int3, lit as lit2, num as num2, obj as obj3, opt as opt3, str as str3, union as union2 } from "@earendil-works/pi-schema";
 var plain = (value) => JSON.parse(JSON.stringify(value));
 
 class JobEntry {
@@ -19547,7 +20023,7 @@ var statusWord = {
   stopped: "stopped",
   lost: "lost"
 };
-var describe2 = (job) => {
+var describe3 = (job) => {
   const parts = [statusWord[job.status]];
   if (job.exitCode !== null)
     parts.push(`exit code ${job.exitCode}`);
@@ -19562,7 +20038,7 @@ var describe2 = (job) => {
 function reportText(job, tail) {
   const body = reportTail(tail);
   return [
-    `[Background job ${job.jobId} "${job.title}" ${describe2(job)}]`,
+    `[Background job ${job.jobId} "${job.title}" ${describe3(job)}]`,
     `Command: ${job.command}`,
     body ? `Last output (use the job tool's output action with jobId "${job.jobId}" for more):
 ${body}` : "It produced no output."
@@ -19631,15 +20107,15 @@ var delay = (ms, signal) => new Promise((resolve) => {
   else
     signal?.addEventListener("abort", done, { once: true });
 });
-var action = Type3.Union([Type3.Literal("start"), Type3.Literal("output"), Type3.Literal("stop"), Type3.Literal("list")]);
-var parameters2 = Type3.Object({
+var action = union2([lit2("start"), lit2("output"), lit2("stop"), lit2("list")]);
+var parameters2 = obj3({
   action,
-  command: Type3.Optional(Type3.String({ description: "start: shell command to run in the session's working directory." })),
-  title: Type3.Optional(Type3.String({ description: "start: short label shown in the job list." })),
-  timeout: Type3.Optional(Type3.Number({ description: "start: optional timeout in seconds; no default timeout." })),
-  jobId: Type3.Optional(Type3.String({ description: "output/stop: the job id returned by start or list." })),
-  since: Type3.Optional(Type3.Integer({ description: "output: resume after this offset, as returned by the previous output call." }))
-});
+  command: opt3(str3({ description: "start: shell command to run in the session's working directory." })),
+  title: opt3(str3({ description: "start: short label shown in the job list." })),
+  timeout: opt3(num2({ description: "start: optional timeout in seconds; no default timeout." })),
+  jobId: opt3(str3({ description: "output/stop: the job id returned by start or list." })),
+  since: opt3(int3({ description: "output: resume after this offset, as returned by the previous output call." }))
+}, { open: true });
 var stringField = (value, name) => {
   if (typeof value !== "string" || !value.trim())
     throw new Error(`Invalid job arguments: ${name} must be a nonempty string.`);
@@ -19772,7 +20248,7 @@ class JobManager {
             if (kind === "stop") {
               const jobId = stringField(args.jobId, "jobId");
               const job = await this.stop(io, api.conversationId, jobId, "model", context);
-              return this.#text(`Job ${job.jobId} ${describe2(job)}.`);
+              return this.#text(`Job ${job.jobId} ${describe3(job)}.`);
             }
             if (kind !== "start")
               throw new Error("Invalid job arguments: action must be start, output, stop or list.");
@@ -19800,7 +20276,7 @@ class JobManager {
   #listText(items) {
     if (!items.length)
       return "No jobs.";
-    return items.map((job) => `${job.jobId} [${describe2(job)}] "${job.title}" \u2014 ${job.command}`).join(`
+    return items.map((job) => `${job.jobId} [${describe3(job)}] "${job.title}" \u2014 ${job.command}`).join(`
 `);
   }
   async start(io, conversationId, cwd, args, context) {
@@ -19852,7 +20328,7 @@ class JobManager {
     return this.#render(job, read.text, read.offset, read.dropped);
   }
   #render(job, text, offset, dropped) {
-    const lines = [`Job ${job.jobId} ${describe2(job)}.`, `Title: ${job.title}`, `Command: ${job.command}`];
+    const lines = [`Job ${job.jobId} ${describe3(job)}.`, `Title: ${job.title}`, `Command: ${job.command}`];
     if (dropped > 0)
       lines.push(`(${dropped} bytes of earlier output were dropped)`);
     lines.push(text ? `Output (next offset ${offset}):
@@ -19926,10 +20402,10 @@ import {
   hook as hook2,
   InboxDoc,
   ToolTask as ToolTask2,
-  wrapTool
+  wrapTool as wrapTool3
 } from "@earendil-works/pi-durable";
 import { createBashTool } from "@earendil-works/pi-durable/tools";
-import { Type as Type5 } from "typebox";
+import { arr as arr3, obj as obj5, opt as opt5, str as str5 } from "@earendil-works/pi-schema";
 
 // packages/core/src/plan-bash.ts
 var SAFE_PATTERNS = [
@@ -20038,13 +20514,14 @@ function isSafeCommand(command) {
 
 // packages/core/src/user-questions.ts
 import { randomUUID } from "crypto";
+import { StringEnum as StringEnum2 } from "@earendil-works/pi-ai";
 import {
-  defineDoc as defineDoc4,
+  defineDoc as defineDoc6,
   defineDocFamily,
   defineExtension as defineExtension5,
   defineTool as defineTool4
 } from "@earendil-works/pi-durable";
-import { Type as Type4 } from "typebox";
+import { arr as arr2, bool as bool2, nul as nul2, obj as obj4, opt as opt4, str as str4, union as union3 } from "@earendil-works/pi-schema";
 var QuestionDoc = defineDocFamily({
   kind: "app.neko.question",
   checkpointWhen: () => false,
@@ -20055,7 +20532,7 @@ var QuestionDoc = defineDocFamily({
   family: true,
   initial: (seed) => seed
 });
-var QuestionsDoc = defineDoc4({
+var QuestionsDoc = defineDoc6({
   kind: "app.neko.questions",
   checkpointWhen: () => false,
   version: 1,
@@ -20108,7 +20585,7 @@ class UserQuestions {
   constructor(harness, context) {
     this.harness = harness;
     this.#context = context;
-    const stop = harness.subscribeCommits(({ changes }) => {
+    const stop = onCommits(harness, ({ changes }) => {
       if (!changes.some((c) => c.type === "task" && (c.value.abortRequested || c.value.state.status === "terminal")))
         return;
       this.reconcileAll();
@@ -20214,13 +20691,16 @@ class UserQuestions {
         if (signal?.aborted)
           return onAbort();
         watch.closed.then((end) => {
-          if (end.reason === "stopped")
+          if (end.kind === "stopped")
             return;
-          finish(() => reject(signal?.aborted ? signal.reason : end.reason === "listener_error" || end.reason === "session_failed" ? end.error : new Error(`Question watch ended: ${end.reason}`)));
+          finish(() => reject(signal?.aborted ? signal.reason : end.kind === "listener_error" || end.kind === "failed" ? end.error : new Error(`Question watch ended: ${end.kind}`)));
         });
         check(watch.value);
         if (!done)
-          watch.start(async (value) => check(value));
+          watch.start(async (call) => {
+            if (call.kind === "value")
+              check(call.value);
+          });
       });
     } finally {
       signal?.removeEventListener("abort", onAbort);
@@ -20274,31 +20754,31 @@ class UserQuestions {
     }, context);
   }
 }
-var optionSchema = Type4.Object({
-  id: Type4.String({
+var optionSchema = obj4({
+  id: str4({
     minLength: 1,
     maxLength: QUESTION_LIMITS.optionIdChars,
     description: "Unique within the question."
   }),
-  label: Type4.String({
+  label: str4({
     minLength: 1,
     maxLength: QUESTION_LIMITS.labelChars,
     description: "Short, unique, readable alone."
   }),
-  description: Type4.Optional(Type4.String({ maxLength: QUESTION_LIMITS.descriptionChars })),
-  recommended: Type4.Optional(Type4.Boolean({ description: "Your suggested choice; shown as a hint, never preselected." }))
-}, { additionalProperties: false });
-var parameters3 = Type4.Object({
-  question: Type4.String({ minLength: 1, maxLength: QUESTION_LIMITS.questionChars }),
-  multiple: Type4.Optional(Type4.Boolean({ description: "Let the user pick several options; needs at least 2 options. Default false." })),
-  options: Type4.Optional(Type4.Array(optionSchema, { maxItems: QUESTION_LIMITS.maxOptions }))
-}, { additionalProperties: false });
-var structuredOutputSchema2 = Type4.Object({
-  status: Type4.String({ enum: ["answered", "skipped", "cancelled"] }),
-  optionIds: Type4.Optional(Type4.Array(Type4.String())),
-  labels: Type4.Optional(Type4.Array(Type4.String())),
-  text: Type4.Optional(Type4.Union([Type4.String(), Type4.Null()]))
-}, { additionalProperties: false });
+  description: opt4(str4({ maxLength: QUESTION_LIMITS.descriptionChars })),
+  recommended: opt4(bool2({ description: "Your suggested choice; shown as a hint, never preselected." }))
+});
+var parameters3 = obj4({
+  question: str4({ minLength: 1, maxLength: QUESTION_LIMITS.questionChars }),
+  multiple: opt4(bool2({ description: "Let the user pick several options; needs at least 2 options. Default false." })),
+  options: opt4(arr2(optionSchema, { maxItems: QUESTION_LIMITS.maxOptions }))
+});
+var structuredOutputSchema2 = obj4({
+  status: StringEnum2(["answered", "skipped", "cancelled"]),
+  optionIds: opt4(arr2(str4())),
+  labels: opt4(arr2(str4())),
+  text: opt4(union3([str4(), nul2()]))
+});
 function questionOutput(record) {
   if (record.status === "answered" && record.answer) {
     const labels = answerLabels(record, record.answer);
@@ -20377,28 +20857,7 @@ function createAskUserTool(service) {
 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) {
@@ -20491,22 +20950,24 @@ class PlanService {
       return toRecord(item);
     }, context);
   }
-  async decide(id, version, decision) {
+  async decideWith(id, version, decision, act) {
     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;
-        }
+      if (item.status !== "awaiting_approval")
+        return toRecord(item);
+      await act(tx);
+      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) };
+      item.dispatched = true;
+      return toRecord(item);
     }, this.#context);
   }
   async supersedePending(id) {
@@ -20557,15 +21018,15 @@ function planRevisionPrompt(plan, feedback) {
   ].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 }), {
+var parameters4 = obj5({
+  title: str5({ minLength: 1, maxLength: PLAN_LIMITS.titleChars, description: "Short name of the plan." }),
+  steps: arr3(str5({ 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 });
+  note: opt5(str5({ maxLength: PLAN_LIMITS.noteChars, description: "Risks, assumptions and how to verify." }))
+});
 function submitPlanTool(service) {
   return defineTool5({
     name: "submit_plan",
@@ -20634,7 +21095,7 @@ var createPlanExtension = (service) => defineExtension6({
     })
   ],
   wraps: [
-    wrapTool(createBashTool(), (bash) => ({
+    wrapTool3(createBashTool(), (bash) => ({
       ...bash,
       execute: async (args, api, context) => {
         if ((await api.snapshot(PlanDoc, api.conversationId, context))?.mode === "plan" && !isSafeCommand(args.command))
@@ -20786,6 +21247,9 @@ import { defineExtension as defineExtension7, section } from "@earendil-works/pi
 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 = {
+  codemode: [
+    "Use codemode to batch independent tool calls (Promise.allSettled), chain them, or filter large output, instead of many separate calls."
+  ],
   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."
   ],
@@ -20850,7 +21314,7 @@ var createNekoPrompt = (loadResources, platform = process.platform) => {
     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),
+      rules: buildRules(enabledTools(input.agent).map((tool) => tool.name), platform),
       project_context: renderProjectContext(resources.contextFiles),
       skills: formatSkillsForPrompt(resources.skills) || undefined,
       cwd: cwd?.replace(/\\/g, "/")
@@ -21017,13 +21481,13 @@ var createResourceSnapshots = (load, submission) => {
 import { stripVTControlCharacters } from "util";
 import { getSupportedThinkingLevels } from "@earendil-works/pi-ai";
 import {
-  defineDoc as defineDoc5,
+  defineDoc as defineDoc7,
   defineExtension as defineExtension8,
   defineTask as defineTask3,
   InboxDoc as InboxDoc2,
   LiveDoc as LiveDoc2
 } from "@earendil-works/pi-durable";
-var SessionMetadataDoc = defineDoc5({
+var SessionMetadataDoc = defineDoc7({
   kind: "app.neko.session-metadata",
   checkpointWhen: () => false,
   version: 1,
@@ -21215,7 +21679,7 @@ class SessionMetadataManager {
     this.context = context;
     this.report = report;
     registry.install(defineExtension8({ name: "neko-naming", tasks: [this.task] }));
-    this.#unsubscribe = harness.subscribeCommits(({ changes }) => {
+    this.#unsubscribe = onCommits(harness, ({ changes }) => {
       const ids = new Set;
       const submissions = new Map;
       let notice = false;
@@ -21230,7 +21694,7 @@ class SessionMetadataManager {
           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;
+            const running = c.kind === "change" && c.value.run !== undefined;
             if (this.#live.get(c.conversationId) !== running) {
               this.#live.set(c.conversationId, running);
               ids.add(c.conversationId);
@@ -21360,9 +21824,10 @@ class SessionMetadataManager {
 }
 
 // packages/core/src/todos.ts
-import { defineDoc as defineDoc6, defineExtension as defineExtension9, defineTool as defineTool6 } from "@earendil-works/pi-durable";
-import { Type as Type6 } from "typebox";
-var TodosDoc = defineDoc6({
+import { StringEnum as StringEnum3 } from "@earendil-works/pi-ai";
+import { defineDoc as defineDoc8, defineExtension as defineExtension9, defineTool as defineTool6 } from "@earendil-works/pi-durable";
+import { arr as arr4, int as int4, obj as obj6, opt as opt6, str as str6 } from "@earendil-works/pi-schema";
+var TodosDoc = defineDoc8({
   kind: "app.neko.todos",
   checkpointWhen: () => false,
   version: 1,
@@ -21371,30 +21836,30 @@ var TodosDoc = defineDoc6({
   fork: "asOf",
   initial: () => ({ revision: 0, items: [] })
 });
-var TodoReceiptDoc = defineDoc6({
+var TodoReceiptDoc = defineDoc8({
   kind: "app.neko.todo-receipt",
   checkpointWhen: () => false,
   version: 1,
   scope: "task",
   initial: () => ({ applied: false, revision: 0, items: [] })
 });
-var itemSchema = Type6.Object({
-  id: Type6.String({
+var itemSchema = obj6({
+  id: str6({
     minLength: 1,
     maxLength: TODO_LIMITS.idChars,
     description: "Stable id; keep it when you update the same task."
   }),
-  text: Type6.String({ minLength: 1, maxLength: TODO_LIMITS.textChars }),
-  status: Type6.String({ enum: [...TODO_STATUSES] })
-}, { additionalProperties: false });
-var parameters5 = Type6.Object({
-  action: Type6.String({ enum: ["list", "replace"], description: "list reads the list; replace overwrites it." }),
-  items: Type6.Optional(Type6.Array(itemSchema, {
+  text: str6({ minLength: 1, maxLength: TODO_LIMITS.textChars }),
+  status: StringEnum3([...TODO_STATUSES])
+});
+var parameters5 = obj6({
+  action: StringEnum3(["list", "replace"], { description: "list reads the list; replace overwrites it." }),
+  items: opt6(arr4(itemSchema, {
     maxItems: TODO_LIMITS.maxItems,
     description: "Required for replace only: the complete ordered list; [] clears it."
   }))
-}, { additionalProperties: false });
-var structuredOutputSchema3 = Type6.Object({ revision: Type6.Integer({ minimum: 0 }), items: Type6.Array(itemSchema) }, { additionalProperties: false });
+});
+var structuredOutputSchema3 = obj6({ revision: int4({ minimum: 0 }), items: arr4(itemSchema) });
 var clone3 = (value) => JSON.parse(JSON.stringify(value));
 function renderTodos(list) {
   const { completed, total } = todoProgress(list.items);
@@ -21463,14 +21928,14 @@ import { randomUUID as randomUUID3 } from "crypto";
 import { realpath } from "fs/promises";
 import {
   configure as configure2,
-  defineDoc as defineDoc7,
+  defineDoc as defineDoc9,
   defineExtension as defineExtension10,
   hook as hook3,
   ToolTask as ToolTask3,
-  wrapTool as wrapTool2
+  wrapTool as wrapTool4
 } from "@earendil-works/pi-durable";
 import { createBashTool as createBashTool2 } from "@earendil-works/pi-durable/tools";
-var ApprovalsDoc = defineDoc7({
+var ApprovalsDoc = defineDoc9({
   kind: "app.neko.approvals",
   checkpointWhen: () => false,
   version: 1,
@@ -21489,7 +21954,7 @@ class ToolApprovals {
   #parents = new Set;
   constructor(harness, context) {
     this.harness = harness;
-    const stop = harness.subscribeCommits(({ changes }) => {
+    const stop = onCommits(harness, ({ changes }) => {
       if (!changes.some((c) => c.type === "task" && (c.value.abortRequested || c.value.state.status === "terminal")))
         return;
       for (const parent of this.#parents)
@@ -21524,14 +21989,12 @@ class ToolApprovals {
     }, context);
   }
   async wait(parent, id, context) {
-    const state = await this.harness.documentState(ApprovalsDoc, parent, context);
-    if (!state)
+    const watch = await this.harness.watchDoc(ApprovalsDoc, parent, context);
+    if (!watch)
       throw new Error("Approval unavailable");
     try {
       return await new Promise((resolve, reject) => {
-        let stop = () => {};
         const cleanup = () => {
-          stop();
           context.abortSignal?.removeEventListener("abort", abort);
         };
         const abort = () => {
@@ -21539,13 +22002,16 @@ class ToolApprovals {
           reject(context.abortSignal?.reason ?? new Error("Cancelled"));
         };
         const check = () => {
-          const item = state.value?.items.find((a) => a.id === id);
+          const item = watch.value.items.find((a) => a.id === id);
           if (item && item.status !== "pending") {
             cleanup();
             resolve(structuredClone(item));
           }
         };
-        stop = state.subscribe(check);
+        watch.start(async (call) => {
+          if (call.kind === "value")
+            check();
+        });
         context.abortSignal?.addEventListener("abort", abort, { once: true });
         if (context.abortSignal?.aborted)
           abort();
@@ -21553,7 +22019,7 @@ class ToolApprovals {
           check();
       });
     } finally {
-      state.dispose();
+      await watch.stop();
     }
   }
   async ensure(parent, candidate, context) {
@@ -21612,7 +22078,7 @@ function createApprovalExtension(service) {
       })
     ],
     wraps: [
-      wrapTool2(createBashTool2(), (bash) => ({
+      wrapTool4(createBashTool2(), (bash) => ({
         ...bash,
         execute: async (args, api, context) => {
           const role = await api.snapshot(SubagentDoc, api.conversationId, context);
@@ -21636,7 +22102,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"), createBashTool2()],
+      tools: [...enabledTools(agent).filter((t) => t.name !== "bash"), createBashTool2()],
       extensions: { add: [extension] }
     }), context);
   }
@@ -21863,8 +22329,8 @@ function createDeepseekProvider(resolveKey, fetchImpl = fetch, options = {}) {
 }
 
 // packages/core/src/web-search/index.ts
-import { Type as Type7 } from "@earendil-works/pi-ai";
 import { defineExtension as defineExtension11, defineTool as defineTool7 } from "@earendil-works/pi-durable";
+import { arr as arr5, num as num3, obj as obj7, opt as opt7, str as str7 } from "@earendil-works/pi-schema";
 var MAX_URLS = 20;
 var MAX_RESULTS = 10;
 var DEFAULT_RESULTS = 5;
@@ -21888,10 +22354,10 @@ function createWebSearchTools(resolveProvider) {
       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: 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})` }))
-        }),
+        parameters: obj7({
+          query: str7({ minLength: 1, maxLength: 4096, description: "The search query" }),
+          maxResults: opt7(num3({ description: `Maximum number of results (1-${MAX_RESULTS}, default ${DEFAULT_RESULTS})` }))
+        }, { open: true }),
         async execute({ query, maxResults }, _api, context) {
           try {
             if (!query.trim() || query.length > 4096)
@@ -21919,13 +22385,13 @@ ${item.date ? `Published: ${item.date}
       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: Type7.Object({
-          urls: Type7.Array(Type7.String({ maxLength: 2048, description: "http(s) URL" }), {
+        parameters: obj7({
+          urls: arr5(str7({ maxLength: 2048, description: "http(s) URL" }), {
             minItems: 1,
             maxItems: MAX_URLS,
             description: `URLs to extract (1-${MAX_URLS})`
           })
-        }),
+        }, { open: true }),
         async execute({ urls }, _api, context) {
           try {
             if (!urls.length || urls.length > MAX_URLS)
@@ -22323,7 +22789,7 @@ class WorkspaceFiles {
   }
   #disposeWatch(watch) {
     watch.controller.abort();
-    const closing = watch.work.catch(() => {}).then(() => watch.watcher?.close(BACKGROUND_CONTEXT2)).then(() => {}).catch(() => {}).finally(() => this.#disposing.delete(closing));
+    const closing = watch.work.catch(() => {}).then(() => watch.watcher?.stop(BACKGROUND_CONTEXT2)).then(() => {}).catch(() => {}).finally(() => this.#disposing.delete(closing));
     this.#disposing.add(closing);
   }
   #closeWatcher(item) {
@@ -22364,7 +22830,7 @@ class WorkspaceFiles {
             user.generation++;
             user.loaded = 0;
           }
-          if ("error" in change) {
+          if (change.kind === "failed") {
             if (this.#watches.get(item.root) === current)
               this.#watches.delete(item.root);
             for (const user of [...current.users])
@@ -22374,7 +22840,7 @@ class WorkspaceFiles {
         if (result.ok) {
           current.watcher = result.value;
           if (current.controller.signal.aborted)
-            await result.value.close(BACKGROUND_CONTEXT2);
+            await result.value.stop(BACKGROUND_CONTEXT2);
         } else {
           forget();
         }
@@ -22645,7 +23111,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 = defineDoc8({
+var ArchivedDoc = defineDoc10({
   kind: "app.neko.conversation",
   checkpointWhen: () => false,
   version: 1,
@@ -22654,7 +23120,7 @@ var ArchivedDoc = defineDoc8({
   fork: "initial",
   initial: () => ({ archived: false })
 });
-var WorkspacesDoc = defineDoc8({
+var WorkspacesDoc = defineDoc10({
   kind: "app.neko.workspaces",
   checkpointWhen: () => false,
   version: 1,
@@ -22663,7 +23129,7 @@ var WorkspacesDoc = defineDoc8({
   fork: "initial",
   initial: () => ({ items: [] })
 });
-var RemovedWorkspacesDoc = defineDoc8({
+var RemovedWorkspacesDoc = defineDoc10({
   kind: "app.neko.workspaces-removed",
   checkpointWhen: () => false,
   version: 1,
@@ -22672,7 +23138,7 @@ var RemovedWorkspacesDoc = defineDoc8({
   fork: "initial",
   initial: () => ({ paths: [] })
 });
-var SearchSettingsDoc = defineDoc8({
+var SearchSettingsDoc = defineDoc10({
   kind: "app.neko.search-settings",
   checkpointWhen: () => false,
   version: 1,
@@ -22681,7 +23147,7 @@ var SearchSettingsDoc = defineDoc8({
   fork: "initial",
   initial: () => ({ provider: null })
 });
-var ProviderSettingsDoc = defineDoc8({
+var ProviderSettingsDoc = defineDoc10({
   kind: "app.neko.provider-settings",
   checkpointWhen: () => false,
   version: 1,
@@ -22690,7 +23156,7 @@ var ProviderSettingsDoc = defineDoc8({
   fork: "initial",
   initial: () => ({ enabled: null })
 });
-var DefaultModelDoc = defineDoc8({
+var DefaultModelDoc = defineDoc10({
   kind: "app.neko.default-model",
   checkpointWhen: () => false,
   version: 1,
@@ -22699,7 +23165,7 @@ var DefaultModelDoc = defineDoc8({
   fork: "initial",
   initial: () => ({ model: null })
 });
-var ContextSettingsDoc = defineDoc8({
+var ContextSettingsDoc = defineDoc10({
   kind: "app.neko.context-settings",
   checkpointWhen: () => false,
   version: 1,
@@ -22708,7 +23174,7 @@ var ContextSettingsDoc = defineDoc8({
   fork: "initial",
   initial: emptySavedContextSettings
 });
-var ActivityDoc = defineDoc8({
+var ActivityDoc = defineDoc10({
   kind: "app.neko.activity",
   checkpointWhen: () => false,
   version: 1,
@@ -22719,6 +23185,9 @@ var ActivityDoc = defineDoc8({
 });
 async function createNekoRuntime(options = {}) {
   const context = options.context ?? BACKGROUND_CONTEXT3;
+  if (options.maxTurns !== undefined && !(Number.isSafeInteger(options.maxTurns) && options.maxTurns >= 1))
+    throw new RangeError(`maxTurns must be an integer of 1 or more, got ${options.maxTurns}`);
+  const turnLimit = options.maxTurns === undefined ? {} : { maxTurns: options.maxTurns };
   const defaultCwd = normalizeWorkspace(options.cwd);
   const model = options.model ?? DEFAULT_MODEL;
   const modelOverride = options.modelOverride;
@@ -22815,6 +23284,11 @@ async function createNekoRuntime(options = {}) {
   registry.install(createQuestionExtension(() => questions));
   let plans;
   registry.install(createPlanExtension(() => plans));
+  const codemode = createCodemodeRuntime({
+    maxWorkers: options.codemodeLimits?.maxWorkers ?? CODEMODE_LIMITS.maxWorkers,
+    waitMs: options.codemodeLimits?.waitMs ?? CODEMODE_LIMITS.waitMs
+  });
+  registry.install(codemode.extension);
   for (const extension of options.extensions ?? [])
     registry.install(extension);
   let approvals;
@@ -22833,7 +23307,7 @@ async function createNekoRuntime(options = {}) {
         return compactionFor(contextState);
       }
     },
-    onReport: options.onReport,
+    onReport: (report) => options.onReport?.(report.error, report),
     conversationCreated: async (tx, record) => {
       (await tx.doc(SessionMetadataDoc, record.id)).createdAt = Date.now();
     },
@@ -22868,6 +23342,7 @@ async function createNekoRuntime(options = {}) {
       }
     }
   } catch (error) {
+    await codemode.close();
     await workspaceFiles.close();
     await harness.close(context);
     throw error;
@@ -22878,10 +23353,18 @@ async function createNekoRuntime(options = {}) {
     agent: {
       model: rootModel,
       thinkingLevel: resolveLevel(rootModel, options.thinkingLevel ?? "high"),
-      cwd: defaultCwd
+      cwd: defaultCwd,
+      ...turnLimit
     }
   });
   enabled = new Set(normalizeEnabledProviders((await harness.snapshot(ProviderSettingsDoc, conversation.id, context))?.enabled));
+  const codemodeState = async () => resolveCodemodeSettings(options.codemodeSettings, (await harness.snapshot(CodemodeSettingsDoc, conversation.id, context))?.mode);
+  if (existing.length === 0) {
+    const initial = (await codemodeState()).effective.mode;
+    await harness.commit(async (tx) => {
+      (await tx.doc(CodemodeDoc, conversation.id)).mode = initial;
+    }, context);
+  }
   const savedSearch = (await harness.snapshot(SearchSettingsDoc, conversation.id, context))?.provider;
   if (isSearchProvider(savedSearch))
     searchProvider = savedSearch;
@@ -23008,14 +23491,16 @@ async function createNekoRuntime(options = {}) {
         admissions.delete(id);
     }
   };
-  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 syncAgent = async (target) => {
+    const change = agentSyncChange(await target.agent(context), {
+      plan: await plans.mode(target.id),
+      codemode: (await harness.snapshot(CodemodeDoc, target.id, context))?.mode ?? "off",
+      role: "main"
+    });
+    if (change)
+      await target.configure(change, context);
   };
-  const submitTo = async (target, content, submitOptions, extra) => admit(target.id, async () => {
-    await syncPlanAgent(target);
-    const agent = await target.agent(context);
+  const prepareSubmission = async (target, agent, content, submitOptions, extra) => {
     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: [], ...extra };
@@ -23069,15 +23554,23 @@ async function createNekoRuntime(options = {}) {
     }
     if (prepared)
       resourceSnapshots.stage(target.id, requestId, workspace, prepared);
-    let result;
-    try {
-      result = await target.submit({
+    return {
+      draft: {
         type: "input",
         content,
         entry: { kind: NekoInput.kind, data },
         requestId,
         ...submitOptions?.whenBusy !== undefined ? { whenBusy: submitOptions.whenBusy } : {}
-      }, context);
+      },
+      requestId
+    };
+  };
+  const submitNow = async (target, content, submitOptions, extra) => {
+    await syncAgent(target);
+    const { draft, requestId } = await prepareSubmission(target, await target.agent(context), content, submitOptions, extra);
+    let result;
+    try {
+      result = await target.submit(draft, context);
     } catch (error) {
       resourceSnapshots.discard(target.id, requestId);
       throw error;
@@ -23087,10 +23580,11 @@ async function createNekoRuntime(options = {}) {
     await touchConversation(target.id);
     await metadata.reconcile(target.id);
     return result;
-  });
-  const dispatchPlan = async (target, item) => {
+  };
+  const submitTo = (target, ...args) => admit(target.id, () => submitNow(target, ...args));
+  const dispatchPlan = async (target, item, submit = submitTo) => {
     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" }, {
+    await submit(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",
@@ -23127,15 +23621,12 @@ async function createNekoRuntime(options = {}) {
     waitAnswer(submission) {
       return waitAnswerOf(target, submission);
     },
-    viewState() {
-      return target.viewState(context);
+    follow() {
+      return followConversation(target, context);
     },
     watch() {
       return target.watch(context);
     },
-    events() {
-      return watchEvents(harness, target.id, context);
-    },
     async usage() {
       return mergeUsage(await harness.snapshot(UsageDoc2, target.id, context) ?? { models: {}, tools: {} }, (await harness.snapshot(SessionMetadataDoc, target.id, context))?.namingUsage ?? { models: {}, tools: {} });
     },
@@ -23178,24 +23669,55 @@ async function createNekoRuntime(options = {}) {
         if (await isRunning(target.id))
           throw new Error(PLAN_BUSY);
         await plans.setMode(target.id, mode);
-        await syncPlanAgent(target);
+        await syncAgent(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") {
+      return admit(target.id, async () => {
+        const known = await plans.get(target.id, version);
+        if (!known)
+          throw new Error("Plan not found.");
+        if (known.status !== "awaiting_approval") {
+          const legacy = await plans.undispatched(target.id);
+          if (legacy?.version === version)
+            await dispatchPlan(target, legacy, submitNow);
+          return known;
+        }
         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;
+        await syncAgent(target);
+        const agent = await target.agent(context);
+        const approve = parsed.kind === "approve";
+        const feedback = parsed.kind === "revise" ? parsed.feedback : "";
+        const { draft, requestId } = await prepareSubmission(target, agent, approve ? approvedPlanPrompt(known) : planRevisionPrompt(known, feedback), { requestId: `${approve ? "plan-exec" : "plan-revise"}:${version}`, whenBusy: "followUp" }, {
+          planDecision: {
+            version,
+            kind: approve ? "approve" : "revise",
+            title: known.title,
+            ...!approve && feedback ? { feedback } : {}
+          }
+        });
+        const codemode = (await harness.snapshot(CodemodeDoc, target.id, context))?.mode ?? "off";
+        const leave = approve ? agentSyncChange(agent, { plan: "normal", codemode, role: "main" }) : undefined;
+        let record;
+        try {
+          record = await plans.decideWith(target.id, version, parsed, async (tx) => {
+            await target.submit(tx, draft);
+            if (leave)
+              await configure3(tx, target.id, leave);
+          });
+        } catch (error) {
+          resourceSnapshots.discard(target.id, requestId);
+          throw error;
+        }
+        if (record.status !== "approved" && record.status !== "revision_requested")
+          resourceSnapshots.discard(target.id, requestId);
+        await touchConversation(target.id);
+        await metadata.reconcile(target.id);
+        return record;
+      });
     },
     async workspaceDir(path, signal) {
       return workspaceFiles.children(savedWorkspace((await target.agent(context)).cwd), path, signal ?? neverAborted());
@@ -23226,6 +23748,26 @@ async function createNekoRuntime(options = {}) {
       await target.abort(context);
       await plans.cancelPending(target.id);
     },
+    continueRun() {
+      return admit(target.id, async () => {
+        await syncAgent(target);
+        await guardProvider((await target.agent(context)).model);
+        const live = await harness.snapshot(importLiveDoc, target.id, context);
+        if (live?.run !== undefined)
+          throw new Error(CONTINUE_BUSY);
+        if (live?.runFailure === undefined)
+          throw new Error(CONTINUE_UNAVAILABLE);
+        try {
+          await target.submit({ type: "continue" }, context);
+        } catch (error) {
+          if (error instanceof ConversationBusy)
+            throw new Error(CONTINUE_BUSY);
+          throw error;
+        }
+        await touchConversation(target.id);
+        await metadata.reconcile(target.id);
+      });
+    },
     async withdraw(submissionId) {
       const id = submissionId;
       const inbox = await harness.snapshot(InboxDoc3, target.id, context);
@@ -23300,7 +23842,7 @@ async function createNekoRuntime(options = {}) {
       const session = await getConversation(id);
       if (!session)
         continue;
-      await admit(id, () => syncPlanAgent(session.conversation));
+      await admit(id, () => syncAgent(session.conversation));
       const pending = await plans.undispatched(id);
       if (pending)
         await dispatchPlan(session.conversation, pending);
@@ -23386,6 +23928,8 @@ async function createNekoRuntime(options = {}) {
         }
         const child = at === undefined ? await tx.createConversation({ ownership: { kind: "ownerless" } }) : await tx.forkConversation(id, at, { ownership: { kind: "ownerless" } });
         (await tx.doc(DelegationsDoc, child.id)).items = inherited;
+        if (at === undefined)
+          (await tx.doc(CodemodeDoc, child.id)).mode = (await tx.doc(CodemodeDoc, id)).mode;
         if (sourceMetadata) {
           const doc = await tx.doc(SessionMetadataDoc, child.id);
           doc.title = sourceMetadata.title || sourceMetadata.firstPromptPreview;
@@ -23413,15 +23957,12 @@ async function createNekoRuntime(options = {}) {
     root: rootSession,
     submit: rootSession.submit,
     waitAnswer: rootSession.waitAnswer,
-    async viewState(id) {
-      return (await sessionFor(id)).viewState();
+    async follow(id) {
+      return (await sessionFor(id)).follow();
     },
     async watch(id) {
       return (await sessionFor(id)).watch();
     },
-    async events(id) {
-      return (await sessionFor(id)).events();
-    },
     async usage(id) {
       return (await sessionFor(id)).usage();
     },
@@ -23466,12 +24007,18 @@ async function createNekoRuntime(options = {}) {
       const workspace = await addWorkspace(createOptions?.cwd ?? defaultCwd);
       const savedDefault = (await harness.snapshot(DefaultModelDoc, conversation.id, context))?.model ?? null;
       const effective = createOptions?.model ?? modelOverride ?? savedDefault ?? model;
+      const mode = (await codemodeState()).effective.mode;
       const created = await harness.createConversation({
         ownership: { kind: "ownerless" },
         agent: {
           model: effective,
           thinkingLevel: resolveLevel(effective, createOptions?.thinkingLevel ?? options.thinkingLevel ?? "high"),
-          cwd: workspace.path
+          cwd: workspace.path,
+          ...turnLimit,
+          ...agentChangeFor({ plan: "normal", codemode: mode, role: "main" })
+        },
+        init: async (tx, id) => {
+          (await tx.doc(CodemodeDoc, id)).mode = mode;
         }
       }, context);
       await metadata.initialize(created.id);
@@ -23526,6 +24073,20 @@ async function createNekoRuntime(options = {}) {
     async resetContextSettings() {
       return persistContext(emptySavedContextSettings());
     },
+    codemodeSettings: codemodeState,
+    async setCodemodeMode(mode) {
+      const parsed = parseCodemodeMode(mode);
+      await harness.commit(async (tx) => {
+        (await tx.doc(CodemodeSettingsDoc, conversation.id)).mode = parsed;
+      }, context);
+      return codemodeState();
+    },
+    async resetCodemodeMode() {
+      await harness.commit(async (tx) => {
+        (await tx.doc(CodemodeSettingsDoc, conversation.id)).mode = null;
+      }, context);
+      return codemodeState();
+    },
     async searchSettings() {
       return { selected: searchProvider };
     },
@@ -23647,6 +24208,7 @@ async function createNekoRuntime(options = {}) {
       registry.install(extension);
     },
     async close() {
+      await codemode.close();
       await cleanup();
       return harness.close(context);
     }
@@ -23654,7 +24216,20 @@ async function createNekoRuntime(options = {}) {
 }
 // packages/gateway/src/contract.ts
 import { hostNamed, method, remote } from "@earendil-works/chord";
-import { Type as Type8 } from "typebox";
+import {
+  arr as arr6,
+  bool as bool3,
+  int as int5,
+  lit as lit3,
+  map,
+  nul as nul3,
+  num as num4,
+  obj as obj8,
+  oneOf as oneOf2,
+  opt as opt8,
+  str as str8,
+  union as union4
+} from "@earendil-works/pi-schema";
 var GATEWAY_HOST = "neko";
 var rpc = (args, result) => [args, result];
 function contract(name, def) {
@@ -23667,433 +24242,458 @@ function contract(name, def) {
   ]));
   return remote(name, { ...def, host: hostNamed(GATEWAY_HOST), variants });
 }
-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,
+var text3 = str8();
+var number = num4();
+var boolean = bool3();
+var nil = nul3();
+var integer = int5({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER });
+var nullableString = union4([text3, nil]);
+var phase = oneOf2(["pending", "running", "done"]);
+var level = oneOf2(["project", "user", "builtin"]);
+var thinking = oneOf2(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
+var model2 = obj8({ provider: text3, modelId: text3 }, { open: true });
+var changeProperties = { model: opt8(model2), thinkingLevel: opt8(thinking) };
+var change = obj8(changeProperties);
+var usage = obj8({ input: number, output: number, cacheRead: number, cacheWrite: number, cost: number }, { open: true });
+var image = obj8({
+  name: text3,
+  mimeType: text3,
   width: integer,
   height: integer,
   bytes: integer,
   entryId: integer,
   contentIndex: integer
-});
-var skill = Type8.Object({ name: str, location: str, body: str, args: str });
-var call = Type8.Object({
-  callId: str,
-  name: str,
-  summary: str,
+}, { open: true });
+var skill = obj8({ name: text3, location: text3, body: text3, args: text3 }, { open: true });
+var CodemodeViewSchema = obj8({
+  calls: arr6(obj8({
+    id: integer,
+    name: text3,
+    args: text3,
+    status: oneOf2(["running", "ok", "error", "cancelled"]),
+    durationMs: union4([number, nil]),
+    error: nullableString
+  }, { open: true })),
+  omitted: integer,
+  fullOutputPath: nullableString
+}, { open: true });
+var call = obj8({
+  callId: text3,
+  name: text3,
+  summary: text3,
   detail: nullableString,
   phase,
   output: nullableString,
   diff: nullableString,
-  diffAdded: Type8.Union([num, nil]),
-  diffRemoved: Type8.Union([num, nil]),
-  diffTruncated: Type8.Optional(bool)
-});
-var DelegationSchema = Type8.Object({
+  diffAdded: union4([number, nil]),
+  diffRemoved: union4([number, nil]),
+  diffTruncated: opt8(boolean),
+  codemode: opt8(CodemodeViewSchema)
+}, { open: true });
+var DelegationSchema = obj8({
   parentId: integer,
-  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])),
+  agentId: opt8(text3),
+  round: opt8(integer),
+  runnerId: opt8(integer),
+  inputEntryId: opt8(integer),
+  answerEntryId: opt8(integer),
+  roundUsage: opt8(union4([usage, nil])),
   taskId: integer,
-  callId: str,
+  callId: text3,
   childId: integer,
-  role: Type8.Enum(["explore", "plan", "coder"]),
-  title: str,
-  createdAt: num,
-  startedAt: Type8.Union([num, nil]),
-  endedAt: Type8.Union([num, nil]),
-  status: Type8.Enum(["queued", "running", "completed", "failed", "cancelled"]),
+  role: oneOf2(["explore", "plan", "coder"]),
+  title: text3,
+  createdAt: number,
+  startedAt: union4([number, nil]),
+  endedAt: union4([number, nil]),
+  status: oneOf2(["queued", "running", "completed", "failed", "cancelled"]),
   report: nullableString,
-  approvalCount: Type8.Optional(integer),
-  historyThrough: Type8.Optional(integer),
-  historyUsage: Type8.Optional(usage)
-});
-var SubagentSummarySchema = Type8.Object({
-  agentId: str,
+  approvalCount: opt8(integer),
+  historyThrough: opt8(integer),
+  historyUsage: opt8(usage)
+}, { open: true });
+var SubagentSummarySchema = obj8({
+  agentId: text3,
   parentId: integer,
   childId: integer,
-  role: Type8.Enum(["explore", "plan", "coder"]),
-  title: str,
-  status: Type8.Enum(["idle", "queued", "running"]),
-  activeRoundId: Type8.Union([integer, nil]),
+  role: oneOf2(["explore", "plan", "coder"]),
+  title: text3,
+  status: oneOf2(["idle", "queued", "running"]),
+  activeRoundId: union4([integer, nil]),
   lastRoundId: integer,
-  lastReport: Type8.Optional(nullableString),
+  lastReport: opt8(nullableString),
   roundCount: integer,
-  taskTitle: str,
+  taskTitle: text3,
   approvalCount: integer,
-  createdAt: num,
-  historyThrough: Type8.Optional(integer),
-  historyUsage: Type8.Optional(usage)
-});
-var jobStatus = Type8.Enum(["running", "exited", "failed", "stopped", "lost"]);
-var JobSummarySchema = Type8.Object({
-  jobId: str,
-  title: str,
-  command: str,
-  cwd: str,
+  createdAt: number,
+  historyThrough: opt8(integer),
+  historyUsage: opt8(usage)
+}, { open: true });
+var jobStatus = oneOf2(["running", "exited", "failed", "stopped", "lost"]);
+var JobSummarySchema = obj8({
+  jobId: text3,
+  title: text3,
+  command: text3,
+  cwd: text3,
   status: jobStatus,
-  startedAt: 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),
+  startedAt: number,
+  endedAt: union4([number, nil]),
+  exitCode: union4([number, nil]),
+  reason: opt8(oneOf2(["timeout", "spawn-error", "restart", "aborted"])),
+  timeoutSeconds: opt8(number),
   outputBytes: integer
-});
-var JobOutputSchema = Type8.Object({
+}, { open: true });
+var JobOutputSchema = obj8({
   job: JobSummarySchema,
-  text: str,
+  text: text3,
   offset: integer,
-  truncated: bool,
+  truncated: boolean,
   dropped: integer
-});
-var QueuedInputSchema = Type8.Object({
+}, { open: true });
+var QueuedInputSchema = obj8({
   id: integer,
-  mode: Type8.Enum(["steer", "followUp"]),
-  preview: str,
+  mode: oneOf2(["steer", "followUp"]),
+  preview: text3,
   images: integer,
-  skill: Type8.Optional(Type8.Object({ name: str, args: str }))
-});
-var WithdrawResultSchema = Type8.Object({
-  result: Type8.Enum(["withdrawn", "placed", "settled", "unknown"]),
-  text: Type8.Optional(str),
-  images: Type8.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)
+  skill: opt8(obj8({ name: text3, args: text3 }, { open: true }))
+}, { open: true });
+var WithdrawResultSchema = obj8({
+  result: oneOf2(["withdrawn", "placed", "settled", "unknown"]),
+  text: opt8(text3),
+  images: opt8(integer)
+}, { open: true });
+var SteerResultSchema = obj8({
+  result: oneOf2(["steered", "withdrawn", "placed", "settled", "unknown"]),
+  id: opt8(integer),
+  text: opt8(text3),
+  images: opt8(integer)
+}, { open: true });
+var TodoItemSchema = obj8({
+  id: str8({ minLength: 1, maxLength: TODO_LIMITS.idChars }),
+  text: str8({ minLength: 1, maxLength: TODO_LIMITS.textChars }),
+  status: oneOf2(["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 = Type8.Object({
+var TodoListSchema = obj8({
   revision: integer,
-  items: Type8.Array(TodoItemSchema, { maxItems: TODO_LIMITS.maxItems })
+  items: arr6(TodoItemSchema, { maxItems: TODO_LIMITS.maxItems })
+}, { open: true });
+var QuestionOptionSchema = obj8({
+  id: str8({ minLength: 1, maxLength: QUESTION_LIMITS.optionIdChars }),
+  label: str8({ minLength: 1, maxLength: QUESTION_LIMITS.labelChars }),
+  description: opt8(str8({ maxLength: QUESTION_LIMITS.descriptionChars })),
+  recommended: opt8(boolean)
 });
-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 = Type8.Enum(["pending", "answered", "skipped", "cancelled"]);
-var QuestionSummarySchema = Type8.Object({
+var questionStatus = oneOf2(["pending", "answered", "skipped", "cancelled"]);
+var QuestionSummarySchema = obj8({
   id: integer,
-  version: str,
-  preview: Type8.String({ maxLength: QUESTION_LIMITS.previewChars }),
-  multiple: bool,
+  version: text3,
+  preview: str8({ maxLength: QUESTION_LIMITS.previewChars }),
+  multiple: boolean,
   optionCount: integer,
-  createdAt: num
+  createdAt: number
+}, { open: true });
+var WorkspaceEntrySchema = obj8({
+  name: text3,
+  path: text3,
+  kind: oneOf2(["file", "directory", "symlink"]),
+  protected: opt8(lit3(true))
 });
-var WorkspaceEntrySchema = Type8.Object({
-  name: str,
-  path: str,
-  kind: Type8.Enum(["file", "directory", "symlink"]),
-  protected: Type8.Optional(Type8.Literal(true))
-}, { additionalProperties: false });
-var WorkspaceDirSchema = Type8.Object({
-  path: str,
-  entries: Type8.Array(WorkspaceEntrySchema, { maxItems: 1000 }),
-  limited: bool,
-  incomplete: bool
-});
-var WorkspaceFileSchema = Type8.Object({
-  path: str,
-  size: num,
-  mtimeMs: num,
-  kind: Type8.Enum(["text", "binary", "protected"]),
-  content: Type8.Optional(str),
-  truncated: bool
-});
-var ChangeSummarySchema = Type8.Object({ revision: integer, files: integer, added: integer, removed: integer });
-var ChangedFileSchema = Type8.Object({
-  path: str,
-  outside: Type8.Optional(Type8.Literal(true)),
+var WorkspaceDirSchema = obj8({
+  path: text3,
+  entries: arr6(WorkspaceEntrySchema, { maxItems: 1000 }),
+  limited: boolean,
+  incomplete: boolean
+}, { open: true });
+var WorkspaceFileSchema = obj8({
+  path: text3,
+  size: number,
+  mtimeMs: number,
+  kind: oneOf2(["text", "binary", "protected"]),
+  content: opt8(text3),
+  truncated: boolean
+}, { open: true });
+var ChangeSummarySchema = obj8({ revision: integer, files: integer, added: integer, removed: integer }, { open: true });
+var ChangedFileSchema = obj8({
+  path: text3,
+  outside: opt8(lit3(true)),
   ops: integer,
   added: integer,
   removed: integer,
-  agents: Type8.Array(str, { maxItems: 64 }),
+  agents: arr6(text3, { maxItems: 64 }),
   lastSeq: integer
-}, { additionalProperties: false });
-var ChangeListSchema = Type8.Object({
-  revision: integer,
-  files: Type8.Array(ChangedFileSchema, { maxItems: 500 }),
-  truncated: bool
 });
-var ChangeOpSchema = Type8.Object({
+var ChangeListSchema = obj8({
+  revision: integer,
+  files: arr6(ChangedFileSchema, { maxItems: 500 }),
+  truncated: boolean
+}, { open: true });
+var ChangeOpSchema = obj8({
   seq: integer,
-  agent: str,
-  tool: Type8.Enum(["edit", "write"]),
-  diff: str,
+  agent: text3,
+  tool: oneOf2(["edit", "write"]),
+  diff: text3,
   added: integer,
   removed: integer,
-  truncated: bool
-}, { additionalProperties: false });
-var ChangeDetailSchema = Type8.Object({
-  path: str,
-  outside: Type8.Optional(Type8.Literal(true)),
-  ops: Type8.Array(ChangeOpSchema, { maxItems: 50 }),
-  truncated: bool
+  truncated: boolean
 });
-var QuestionListSchema = Type8.Object({
+var ChangeDetailSchema = obj8({
+  path: text3,
+  outside: opt8(lit3(true)),
+  ops: arr6(ChangeOpSchema, { maxItems: 50 }),
+  truncated: boolean
+}, { open: true });
+var QuestionListSchema = obj8({
   revision: integer,
-  pending: Type8.Array(QuestionSummarySchema, { maxItems: QUESTION_LIMITS.maxPending })
-});
-var QuestionRecordSchema = Type8.Object({
+  pending: arr6(QuestionSummarySchema, { maxItems: QUESTION_LIMITS.maxPending })
+}, { open: true });
+var QuestionRecordSchema = obj8({
   id: integer,
-  callId: str,
-  version: str,
-  question: Type8.String({ maxLength: QUESTION_LIMITS.questionChars }),
-  multiple: bool,
-  options: Type8.Array(QuestionOptionSchema, { maxItems: QUESTION_LIMITS.maxOptions }),
+  callId: text3,
+  version: text3,
+  question: str8({ maxLength: QUESTION_LIMITS.questionChars }),
+  multiple: boolean,
+  options: arr6(QuestionOptionSchema, { maxItems: QUESTION_LIMITS.maxOptions }),
   status: questionStatus,
-  answer: Type8.Union([
-    Type8.Object({
-      optionIds: Type8.Array(Type8.String(), { maxItems: QUESTION_LIMITS.maxOptions }),
-      text: Type8.Union([Type8.String({ maxLength: QUESTION_LIMITS.textChars }), nil])
-    }),
+  answer: union4([
+    obj8({
+      optionIds: arr6(str8(), { maxItems: QUESTION_LIMITS.maxOptions }),
+      text: union4([str8({ maxLength: QUESTION_LIMITS.textChars }), nil])
+    }, { open: true }),
     nil
   ]),
-  createdAt: num,
-  settledAt: Type8.Union([num, nil])
-});
-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 }),
-  Type8.Object({ kind: Type8.Literal("skip") }, { additionalProperties: false })
+  createdAt: number,
+  settledAt: union4([number, nil])
+}, { open: true });
+var QuestionResponseSchema = union4([
+  obj8({
+    kind: lit3("answer"),
+    optionIds: opt8(arr6(str8(), { maxItems: QUESTION_LIMITS.maxOptions })),
+    text: opt8(str8({ maxLength: QUESTION_LIMITS.textChars }))
+  }),
+  obj8({ kind: lit3("skip") })
 ]);
-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"]),
+var PlanRecordSchema = obj8({
+  version: text3,
+  title: str8({ maxLength: PLAN_LIMITS.titleChars }),
+  steps: arr6(str8({ maxLength: PLAN_LIMITS.stepChars }), { maxItems: PLAN_LIMITS.maxSteps }),
+  note: str8({ maxLength: PLAN_LIMITS.noteChars }),
+  status: oneOf2(["awaiting_approval", "approved", "revision_requested", "superseded", "cancelled"]),
+  feedback: union4([str8({ maxLength: PLAN_LIMITS.feedbackChars }), nil]),
+  createdAt: number,
+  settledAt: union4([number, nil])
+}, { open: true });
+var PlanViewSchema = obj8({
+  mode: oneOf2(["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 })
+  current: union4([PlanRecordSchema, nil])
+}, { open: true });
+var PlanDecisionSchema = union4([
+  obj8({ kind: lit3("approve") }),
+  obj8({ kind: lit3("revise"), feedback: str8({ minLength: 1, maxLength: PLAN_LIMITS.feedbackChars }) })
 ]);
-var ToolInteractionSchema = Type8.Union([
-  Type8.Object({
-    kind: Type8.Literal("ask_user"),
+var ToolInteractionSchema = union4([
+  obj8({
+    kind: lit3("ask_user"),
     id: integer,
-    question: str,
-    multiple: bool,
-    options: Type8.Array(Type8.Object({ id: str, label: str, recommended: Type8.Optional(bool) })),
+    question: text3,
+    multiple: boolean,
+    options: arr6(obj8({ id: text3, label: text3, recommended: opt8(boolean) }, { open: true })),
     status: questionStatus,
-    optionIds: Type8.Optional(Type8.Array(str)),
-    labels: Type8.Optional(Type8.Array(str)),
-    text: Type8.Optional(Type8.Union([str, nil]))
-  }),
-  Type8.Object({
-    kind: Type8.Literal("todo"),
-    action: Type8.Enum(["list", "replace"]),
+    optionIds: opt8(arr6(text3)),
+    labels: opt8(arr6(text3)),
+    text: opt8(union4([text3, nil]))
+  }, { open: true }),
+  obj8({
+    kind: lit3("todo"),
+    action: oneOf2(["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
-  })
+  }, { open: true }),
+  obj8({
+    kind: lit3("submit_plan"),
+    version: text3,
+    title: text3,
+    steps: arr6(text3),
+    note: text3
+  }, { open: true })
 ]);
-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: Type8.Object({ model: Type8.Union([model2, nil]), thinkingLevel: Type8.Union([thinking, nil]) }),
-  cwd: str,
-  busy: bool,
+var ChatViewSchema = obj8({
+  historyBefore: opt8(union4([integer, nil])),
+  agents: opt8(arr6(SubagentSummarySchema)),
+  jobs: opt8(arr6(JobSummarySchema)),
+  queued: opt8(arr6(QueuedInputSchema)),
+  todos: opt8(TodoListSchema),
+  questions: opt8(QuestionListSchema),
+  plan: opt8(PlanViewSchema),
+  changes: opt8(ChangeSummarySchema),
+  rounds: opt8(arr6(DelegationSchema)),
+  subagents: opt8(arr6(DelegationSchema)),
+  taskUsage: opt8(usage),
+  model: text3,
+  agent: obj8({ model: union4([model2, nil]), thinkingLevel: union4([thinking, nil]) }, { open: true }),
+  cwd: text3,
+  busy: boolean,
   status: nullableString,
   usage,
-  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({
+  contextUsage: opt8(obj8({ tokens: union4([number, nil]), window: number, percent: union4([number, nil]) }, { open: true })),
+  compaction: opt8(obj8({
+    failure: opt8(obj8({ taskId: integer, reason: oneOf2(["manual", "threshold", "overflow"]), error: text3 }, { open: true })),
+    active: arr6(obj8({
       taskId: integer,
-      reason: Type8.Enum(["manual", "threshold", "overflow"]),
-      blocking: bool,
+      reason: oneOf2(["manual", "threshold", "overflow"]),
+      blocking: boolean,
       attempt: integer,
-      retry: Type8.Optional(Type8.Object({ at: num, error: str }))
-    })),
-    latest: Type8.Union([
+      retry: opt8(obj8({ at: number, error: text3 }, { open: true }))
+    }, { open: true })),
+    latest: union4([
       nil,
-      Type8.Object({
+      obj8({
         taskId: integer,
-        phase: Type8.Enum(["summarizing", "waiting-to-apply", "applied", "nothing", "skipped", "cancelled", "failed"]),
-        at: num
-      })
+        phase: oneOf2([
+          "summarizing",
+          "waiting-to-apply",
+          "applied",
+          "nothing",
+          "skipped",
+          "cancelled",
+          "failed"
+        ]),
+        at: number
+      }, { open: true })
     ])
-  })),
-  items: Type8.Array(Type8.Union([
-    Type8.Object({
-      type: Type8.Literal("user"),
-      order: Type8.Optional(num),
-      key: str,
+  }, { open: true })),
+  runFailure: opt8(obj8({ reason: text3, detail: opt8(text3) }, { open: true })),
+  continuable: opt8(lit3(true)),
+  items: arr6(union4([
+    obj8({
+      type: lit3("user"),
+      order: opt8(number),
+      key: text3,
       id: integer,
-      text: str,
-      images: Type8.Optional(Type8.Array(image)),
-      skill: Type8.Optional(skill),
-      defaultImagePrompt: Type8.Optional(Type8.Object({ version: Type8.Integer({ minimum: 1 }), text: str }))
-    }),
-    Type8.Object({
-      type: Type8.Literal("assistant"),
-      order: Type8.Optional(num),
-      key: str,
+      text: text3,
+      images: opt8(arr6(image)),
+      skill: opt8(skill),
+      defaultImagePrompt: opt8(obj8({ version: int5({ minimum: 1 }), text: text3 }, { open: true }))
+    }, { open: true }),
+    obj8({
+      type: lit3("assistant"),
+      order: opt8(number),
+      key: text3,
       id: integer,
-      thinking: str,
-      text: str,
+      thinking: text3,
+      text: text3,
       stopReason: nullableString,
       errorMessage: nullableString,
       note: nullableString
-    }),
-    Type8.Object({
-      type: Type8.Literal("tool"),
-      order: Type8.Optional(num),
-      key: str,
-      images: Type8.Optional(Type8.Array(image)),
-      callId: str,
-      name: str,
-      summary: str,
+    }, { open: true }),
+    obj8({
+      type: lit3("tool"),
+      order: opt8(number),
+      key: text3,
+      images: opt8(arr6(image)),
+      callId: text3,
+      name: text3,
+      summary: text3,
       detail: nullableString,
       phase,
-      isError: bool,
+      isError: boolean,
       output: nullableString,
       result: nullableString,
-      durationMs: Type8.Union([num, nil]),
+      durationMs: union4([number, nil]),
       note: nullableString,
       diff: nullableString,
-      diffAdded: Type8.Union([num, nil]),
-      diffRemoved: Type8.Union([num, nil]),
-      diffTruncated: Type8.Optional(bool),
-      interaction: Type8.Optional(ToolInteractionSchema)
-    }),
-    Type8.Object({
-      type: Type8.Literal("system"),
-      order: Type8.Optional(num),
-      key: str,
+      diffAdded: union4([number, nil]),
+      diffRemoved: union4([number, nil]),
+      diffTruncated: opt8(boolean),
+      interaction: opt8(ToolInteractionSchema),
+      codemode: opt8(CodemodeViewSchema)
+    }, { open: true }),
+    obj8({
+      type: lit3("system"),
+      order: opt8(number),
+      key: text3,
       id: integer,
-      text: str,
-      jobId: Type8.Optional(str),
-      planDecision: Type8.Optional(Type8.Object({ version: str, kind: Type8.Enum(["approve", "revise"]) }, { additionalProperties: false }))
-    })
+      text: text3,
+      jobId: opt8(text3),
+      planDecision: opt8(obj8({ version: text3, kind: oneOf2(["approve", "revise"]) }))
+    }, { open: true })
   ])),
-  streaming: Type8.Union([nil, Type8.Object({ thinking: str, text: str, toolCalls: Type8.Array(call) })])
-});
-var SessionSummarySchema = Type8.Object({
-  workspaceRoot: str,
-  lastUsedAt: num,
-  title: str,
-  firstPromptPreview: str,
-  createdAt: num,
-  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 = 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: Type8.Enum(["saved", "environment", "runtime", "keyless", "none"]),
-  enabled: Type8.Optional(bool)
-});
-var CredentialStateSchema = Type8.Object({
+  streaming: union4([nil, obj8({ thinking: text3, text: text3, toolCalls: arr6(call) }, { open: true })])
+}, { open: true });
+var SessionSummarySchema = obj8({
+  workspaceRoot: text3,
+  lastUsedAt: number,
+  title: text3,
+  firstPromptPreview: text3,
+  createdAt: number,
+  lastMessageAt: union4([number, nil]),
+  model: union4([model2, nil]),
+  status: oneOf2(["idle", "running", "error"]),
+  awaitingAnswer: opt8(boolean),
+  awaitingPlan: opt8(boolean),
+  id: text3
+}, { open: true });
+var DirectoryStateSchema = obj8({ revision: integer, sessions: arr6(SessionSummarySchema) }, { open: true });
+var WorkspaceSummarySchema = obj8({ path: text3, createdAt: number }, { open: true });
+var WorkspaceStateSchema = obj8({ revision: integer, workspaces: arr6(WorkspaceSummarySchema) }, { open: true });
+var credentialStatus = obj8({
+  savedConfigured: boolean,
+  environmentConfigured: boolean,
+  source: oneOf2(["saved", "environment", "runtime", "keyless", "none"]),
+  enabled: opt8(boolean)
+}, { open: true });
+var CredentialStateSchema = obj8({
   revision: integer,
-  statuses: Type8.Record(str, credentialStatus)
-});
-var AttachmentSchema = Type8.Object({ sessionId: str, attachmentId: str });
-var chatInput = Type8.Object({ sessionId: str, attachmentId: str }, { additionalProperties: false });
+  statuses: map(credentialStatus)
+}, { open: true });
+var AttachmentSchema = obj8({ sessionId: text3, attachmentId: text3 }, { open: true });
+var chatInput = obj8({ sessionId: text3, attachmentId: text3 });
 var NekoSessionDirectory = contract("neko.session-directory", {
   version: 1,
-  input: Type8.Object({}, { additionalProperties: false }),
+  input: obj8({}),
   variants: { ready: { state: { state: DirectoryStateSchema } } }
 });
 var NekoSessionManagement = contract("neko.session-management", {
   version: 1,
-  input: Type8.Object({}, { additionalProperties: false }),
+  input: obj8({}),
   variants: {
     ready: {
       methods: {
-        create: rpc(Type8.Object({ ...change.properties, cwd: Type8.Optional(str) }, { additionalProperties: false }), SessionSummarySchema),
-        archive: rpc(str, nil),
-        attach: rpc(str, AttachmentSchema),
+        create: rpc(obj8({ ...changeProperties, cwd: opt8(text3) }), SessionSummarySchema),
+        archive: rpc(text3, nil),
+        attach: rpc(text3, AttachmentSchema),
         detach: rpc(nil, nil),
-        fork: rpc(str, SessionSummarySchema)
+        fork: rpc(text3, SessionSummarySchema)
       }
     }
   }
 });
-var resize = Type8.Object({
-  maxWidth: Type8.Optional(integer),
-  maxHeight: Type8.Optional(integer),
-  maxBytes: Type8.Optional(integer),
-  jpegQuality: Type8.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 = Type8.Object({
-  provider: str,
-  modelId: str,
-  name: str,
-  available: bool,
-  contextWindow: num,
-  input: Type8.Array(str),
-  inputLimits: Type8.Optional(inputLimits),
-  reasoning: bool,
-  supportedThinkingLevels: Type8.Array(thinking),
-  thinkingLevelAdjustments: Type8.Object({
+var resize = obj8({
+  maxWidth: opt8(integer),
+  maxHeight: opt8(integer),
+  maxBytes: opt8(integer),
+  jpegQuality: opt8(integer)
+}, { open: true });
+var inputLimits = obj8({
+  maxRequestBytes: opt8(integer),
+  images: opt8(obj8({
+    resize: opt8(resize),
+    maxPerMessage: opt8(integer),
+    maxPerRequest: opt8(integer)
+  }, { open: true }))
+}, { open: true });
+var modelInfo = obj8({
+  provider: text3,
+  modelId: text3,
+  name: text3,
+  available: boolean,
+  contextWindow: number,
+  input: arr6(text3),
+  inputLimits: opt8(inputLimits),
+  reasoning: boolean,
+  supportedThinkingLevels: arr6(thinking),
+  thinkingLevelAdjustments: obj8({
     off: thinking,
     minimal: thinking,
     low: thinking,
@@ -24101,35 +24701,35 @@ var modelInfo = Type8.Object({
     high: thinking,
     xhigh: thinking,
     max: thinking
-  })
-});
+  }, { open: true })
+}, { open: true });
 var NekoModels = contract("neko.models", {
   version: 1,
-  input: Type8.Object({}, { additionalProperties: false }),
-  variants: { ready: { methods: { list: rpc(nil, Type8.Array(modelInfo)) } } }
+  input: obj8({}),
+  variants: { ready: { methods: { list: rpc(nil, arr6(modelInfo)) } } }
 });
-var imageChunk = Type8.Object({ data: str, total: integer, mimeType: str });
+var imageChunk = obj8({ data: text3, total: integer, mimeType: text3 }, { open: true });
 var NekoSubagent = contract("neko.subagent", {
   version: 1,
-  input: Type8.Object({
-    sessionId: str,
-    attachmentId: str,
-    taskId: Type8.Optional(integer),
-    agentId: Type8.Optional(str)
-  }),
+  input: obj8({
+    sessionId: text3,
+    attachmentId: text3,
+    taskId: opt8(integer),
+    agentId: opt8(text3)
+  }, { open: true }),
   variants: {
     ready: {
       state: { revision: integer },
       methods: {
-        chunk: rpc(Type8.Object({
-          kind: Type8.Enum(["view", "history"]),
-          before: Type8.Optional(integer),
-          token: Type8.Optional(integer),
+        chunk: rpc(obj8({
+          kind: oneOf2(["view", "history"]),
+          before: opt8(integer),
+          token: opt8(integer),
           offset: integer
-        }), 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)
+        }, { open: true }), obj8({ token: integer, data: text3, next: union4([integer, nil]) }, { open: true })),
+        getImage: rpc(obj8({ entryId: integer, contentIndex: integer, offset: integer }, { open: true }), imageChunk),
+        decideApproval: rpc(obj8({ id: integer, version: text3, decision: oneOf2(["allowed", "denied"]) }, { open: true }), oneOf2(["pending", "allowed", "denied", "cancelled"])),
+        stop: rpc(union4([nil, obj8({ taskId: integer }, { open: true })]), nil)
       }
     }
   }
@@ -24141,157 +24741,176 @@ var NekoChat = contract("neko.chat", {
     ready: {
       state: { view: ChatViewSchema },
       methods: {
-        submit: rpc(Type8.Object({
-          content: str,
-          images: Type8.Optional(Type8.Array(str, { maxItems: 4 })),
-          requestId: Type8.Optional(str),
-          whenBusy: Type8.Optional(Type8.Enum(["steer", "followUp"]))
-        }, { additionalProperties: false }), nil),
+        submit: rpc(obj8({
+          content: text3,
+          images: opt8(arr6(text3, { maxItems: 4 })),
+          requestId: opt8(text3),
+          whenBusy: opt8(oneOf2(["steer", "followUp"]))
+        }), nil),
         abort: rpc(nil, nil),
-        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),
+        continueRun: rpc(nil, nil),
+        withdraw: rpc(obj8({ id: integer }), WithdrawResultSchema),
+        steer: rpc(obj8({ id: integer }), SteerResultSchema),
+        questionGet: rpc(obj8({ id: integer }), union4([QuestionRecordSchema, nil])),
+        questionRespond: rpc(obj8({ id: integer, version: text3, response: QuestionResponseSchema }), QuestionRecordSchema),
+        planGet: rpc(obj8({ version: text3 }), union4([PlanRecordSchema, nil])),
+        planRespond: rpc(obj8({ version: text3, decision: PlanDecisionSchema }), PlanRecordSchema),
+        planMode: rpc(obj8({ mode: oneOf2(["normal", "plan"]) }), PlanViewSchema),
         usage: rpc(nil, usage),
-        workspaceDir: rpc(Type8.Object({ path: str }, { additionalProperties: false }), WorkspaceDirSchema),
-        workspaceFile: rpc(Type8.Object({ path: str }, { additionalProperties: false }), WorkspaceFileSchema),
+        workspaceDir: rpc(obj8({ path: text3 }), WorkspaceDirSchema),
+        workspaceFile: rpc(obj8({ path: text3 }), WorkspaceFileSchema),
         changesList: rpc(nil, ChangeListSchema),
-        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),
+        changeGet: rpc(obj8({ path: text3 }), union4([ChangeDetailSchema, nil])),
+        skills: rpc(nil, arr6(obj8({ name: text3, description: text3, location: text3, level }, { open: true }))),
+        jobOutput: rpc(obj8({ jobId: text3, since: opt8(integer) }), JobOutputSchema),
+        jobStop: rpc(obj8({ jobId: text3 }), JobSummarySchema),
         configure: rpc(change, 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(Type8.Object({ entryId: integer, contentIndex: integer, offset: integer }, { additionalProperties: false }), imageChunk)
+        compact: rpc(obj8({ instructions: opt8(text3) }), nil),
+        importImage: rpc(text3, obj8({ id: text3, name: text3 }, { open: true })),
+        draftImage: rpc(obj8({ id: text3, offset: integer }), imageChunk),
+        beginImage: rpc(obj8({ name: text3, mimeType: text3, size: int5({ minimum: 1, maximum: 20971520 }) }), text3),
+        appendImage: rpc(obj8({ id: text3, offset: integer, data: str8({ maxLength: 350000 }) }), nil),
+        finishImage: rpc(text3, nil),
+        releaseImage: rpc(text3, nil),
+        getImage: rpc(obj8({ entryId: integer, contentIndex: integer, offset: integer }), imageChunk)
       }
     }
   }
 });
-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,
+var browse = obj8({ path: text3, query: opt8(text3), showHidden: opt8(boolean), cursor: opt8(text3) });
+var page = obj8({
+  path: text3,
   parent: nullableString,
-  entries: Type8.Array(Type8.Object({ name: str, path: str, error: Type8.Optional(str) })),
+  entries: arr6(obj8({ name: text3, path: text3, error: opt8(text3) }, { open: true })),
   next: nullableString
-});
+}, { open: true });
 var NekoWorkspaces = contract("neko.workspaces", {
   version: 2,
-  input: Type8.Object({}, { additionalProperties: false }),
+  input: obj8({}),
   variants: {
     ready: {
       state: { state: WorkspaceStateSchema },
       methods: {
-        add: rpc(Type8.Object({ path: str }, { additionalProperties: false }), WorkspaceSummarySchema),
-        remove: rpc(Type8.Object({ path: str }, { additionalProperties: false }), Type8.Null()),
+        add: rpc(obj8({ path: text3 }), WorkspaceSummarySchema),
+        remove: rpc(obj8({ path: text3 }), nul3()),
         browse: rpc(browse, page)
       }
     }
   }
 });
-var provider = Type8.String({ minLength: 1, maxLength: 64 });
+var provider = str8({ minLength: 1, maxLength: 64 });
 var NekoCredentials = contract("neko.credentials", {
   version: 2,
-  input: Type8.Object({}, { additionalProperties: false }),
+  input: obj8({}),
   variants: {
     ready: {
       state: { state: CredentialStateSchema },
       methods: {
-        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)
+        save: rpc(obj8({ provider, key: str8({ minLength: 1, maxLength: 8192 }) }), nil),
+        remove: rpc(obj8({ provider }), nil),
+        setEnabled: rpc(obj8({ provider, enabled: boolean }), nil)
       }
     }
   }
 });
-var SearchSettingsStateSchema = Type8.Object({
+var SearchSettingsStateSchema = obj8({
   revision: integer,
-  selected: Type8.Enum(["tavily", "deepseek"])
-});
+  selected: oneOf2(["tavily", "deepseek"])
+}, { open: true });
 var NekoSearchSettings = contract("neko.search-settings", {
   version: 1,
-  input: Type8.Object({}, { additionalProperties: false }),
+  input: obj8({}),
   variants: {
     ready: {
       state: { state: SearchSettingsStateSchema },
       methods: {
-        set: rpc(Type8.Object({ provider: Type8.Enum(["tavily", "deepseek"]) }, { additionalProperties: false }), nil)
+        set: rpc(obj8({ provider: oneOf2(["tavily", "deepseek"]) }), nil)
       }
     }
   }
 });
-var contextSource = Type8.Enum(["default", "config", "saved"]);
-var ContextSettingsStateSchema = Type8.Object({
+var contextSource = oneOf2(["default", "config", "saved"]);
+var ContextSettingsStateSchema = obj8({
   revision: integer,
-  effective: Type8.Object({
-    compaction: Type8.Object({
-      enabled: bool,
-      triggerPercent: Type8.Union([integer, nil]),
+  effective: obj8({
+    compaction: obj8({
+      enabled: boolean,
+      triggerPercent: union4([integer, nil]),
       keepRecentTokens: integer
-    }),
-    pruning: Type8.Object({
-      enabled: bool,
+    }, { open: true }),
+    pruning: obj8({
+      enabled: boolean,
       triggerPercent: integer,
       keepRecent: integer,
       minChars: integer,
       minSavePercent: integer
-    })
-  }),
-  sources: Type8.Object({
-    compaction: Type8.Object({ enabled: contextSource, triggerPercent: contextSource, keepRecentTokens: contextSource }),
-    pruning: Type8.Object({
+    }, { open: true })
+  }, { open: true }),
+  sources: obj8({
+    compaction: obj8({ enabled: contextSource, triggerPercent: contextSource, keepRecentTokens: contextSource }, { open: true }),
+    pruning: obj8({
       enabled: contextSource,
       triggerPercent: contextSource,
       keepRecent: contextSource,
       minChars: contextSource,
       minSavePercent: contextSource
-    })
-  })
+    }, { open: true })
+  }, { open: true })
+}, { open: true });
+var nullable = (schema) => union4([schema, nil]);
+var ContextSettingsPatchSchema = obj8({
+  compaction: opt8(obj8({
+    enabled: opt8(nullable(boolean)),
+    triggerPercent: opt8(nullable(integer)),
+    keepRecentTokens: opt8(nullable(integer))
+  })),
+  pruning: opt8(obj8({
+    enabled: opt8(nullable(boolean)),
+    triggerPercent: opt8(nullable(integer)),
+    keepRecent: opt8(nullable(integer)),
+    minChars: opt8(nullable(integer)),
+    minSavePercent: opt8(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: 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: Type8.Object({}, { additionalProperties: false }),
+  input: obj8({}),
   variants: {
     ready: {
       state: { state: ContextSettingsStateSchema },
       methods: {
         set: rpc(ContextSettingsPatchSchema, nil),
-        reset: rpc(Type8.Object({}, { additionalProperties: false }), nil)
+        reset: rpc(obj8({}), nil)
+      }
+    }
+  }
+});
+var CodemodeSettingsStateSchema = obj8({
+  revision: integer,
+  effective: obj8({ mode: oneOf2([...CODEMODE_MODES]) }, { open: true }),
+  source: oneOf2(["default", "config", "saved"])
+}, { open: true });
+var NekoCodemodeSettings = contract("neko.codemode-settings", {
+  version: 1,
+  input: obj8({}),
+  variants: {
+    ready: {
+      state: { state: CodemodeSettingsStateSchema },
+      methods: {
+        set: rpc(obj8({ mode: oneOf2([...CODEMODE_MODES]) }), nil),
+        reset: rpc(obj8({}), nil)
       }
     }
   }
 });
-var defaultModelSource = Type8.Enum(["cli", "saved", "config", "default"]);
-var DefaultModelStateSchema = Type8.Object({
+var defaultModelSource = oneOf2(["cli", "saved", "config", "default"]);
+var DefaultModelStateSchema = obj8({
   effective: model2,
   source: defaultModelSource
-});
+}, { open: true });
 var NekoDefaultModel = contract("neko.default-model", {
   version: 1,
-  input: Type8.Object({}, { additionalProperties: false }),
+  input: obj8({}),
   variants: {
     ready: {
       state: { state: DefaultModelStateSchema },
@@ -24302,74 +24921,76 @@ var NekoDefaultModel = contract("neko.default-model", {
     }
   }
 });
-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 FileCandidatesSchema = obj8({
+  entries: arr6(obj8({ name: text3, path: text3, kind: oneOf2(["file", "directory"]) }, { open: true }), {
+    maxItems: 100
+  }),
+  limited: boolean,
+  incomplete: boolean
+}, { open: true });
 var NekoWorkspaceFiles = contract("neko.workspace-files", {
   version: 1,
-  input: Type8.Object({}, { additionalProperties: false }),
+  input: obj8({}),
   variants: {
     ready: {
       methods: {
-        search: rpc(Type8.Object({ workspaceRoot: str, query: str }, { additionalProperties: false }), FileCandidatesSchema)
+        search: rpc(obj8({ workspaceRoot: text3, query: text3 }), FileCandidatesSchema)
       }
     }
   }
 });
-var marketSkill = Type8.Object({
-  name: str,
-  description: str,
-  category: str,
-  source: str,
-  license: str,
-  version: str,
-  sha256: str,
+var marketSkill = obj8({
+  name: text3,
+  description: text3,
+  category: text3,
+  source: text3,
+  license: text3,
+  version: text3,
+  sha256: text3,
   sizeBytes: integer,
-  uploadedAt: str,
-  installed: Type8.Object({ project: bool, user: bool, builtin: bool }),
-  activeLevel: Type8.Union([level, nil])
-});
-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) });
+  uploadedAt: text3,
+  installed: obj8({ project: boolean, user: boolean, builtin: boolean }, { open: true }),
+  activeLevel: union4([level, nil])
+}, { open: true });
+var preview = obj8({ body: text3, files: arr6(text3) }, { open: true });
+var scope = oneOf2(["user", "project"]);
+var installResult = obj8({ name: text3, scope, path: text3, shadowedBy: opt8(scope) }, { open: true });
 var NekoSkillMarket = contract("neko.skill-market", {
   version: 1,
-  input: Type8.Object({}, { additionalProperties: false }),
+  input: obj8({}),
   variants: {
     ready: {
       methods: {
-        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)
+        list: rpc(obj8({ query: opt8(text3), workspaceRoot: opt8(text3) }), arr6(marketSkill)),
+        detail: rpc(obj8({ name: text3, workspaceRoot: opt8(text3) }), marketSkill),
+        preview: rpc(obj8({ name: text3 }), preview),
+        install: rpc(obj8({ name: text3, scope, workspaceRoot: opt8(text3), overwrite: opt8(boolean) }), installResult),
+        uninstall: rpc(obj8({ name: text3, scope, workspaceRoot: opt8(text3) }), nil)
       }
     }
   }
 });
-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 ShellStatusSchema = union4([
+  obj8({ status: lit3("ready"), path: text3, source: oneOf2(["config", "auto"]) }, { open: true }),
+  obj8({
+    status: lit3("missing"),
+    reason: oneOf2(["not_found", "invalid_config"]),
+    detail: opt8(text3)
+  }, { open: true })
 ]);
-var ApplicationInfoSchema = Type8.Object({
-  runningVersion: str,
+var ApplicationInfoSchema = obj8({
+  runningVersion: text3,
   installedVersion: nullableString,
-  protocolVersion: Type8.Integer({ minimum: 1 }),
+  protocolVersion: int5({ minimum: 1 }),
   latestVersion: nullableString,
-  checkedAt: Type8.Union([integer, nil]),
-  checkState: Type8.Enum(["unknown", "checking", "ok", "failed", "development"]),
-  serverId: str,
-  shell: Type8.Optional(ShellStatusSchema)
-});
+  checkedAt: union4([integer, nil]),
+  checkState: oneOf2(["unknown", "checking", "ok", "failed", "development"]),
+  serverId: text3,
+  shell: opt8(ShellStatusSchema)
+}, { open: true });
 var NekoApplicationInfo = contract("neko.application-info", {
   version: 1,
-  input: Type8.Object({}),
+  input: obj8({}, { open: true }),
   variants: {
     ready: { state: { info: ApplicationInfoSchema }, methods: { check: rpc(nil, ApplicationInfoSchema) } }
   }
@@ -24383,7 +25004,7 @@ function isServerId(value) {
 // packages/gateway/src/mobile/admin.ts
 import { createHash, timingSafeEqual } from "crypto";
 import { ChordError } from "@earendil-works/chord";
-import { Type as Type9 } from "typebox";
+import { arr as arr7, bool as bool4, int as int6, lit as lit4, nul as nul4, obj as obj9, opt as opt9, str as str9, union as union5 } from "@earendil-works/pi-schema";
 
 // packages/gateway/src/principal.ts
 var HOST_PRINCIPAL = { kind: "host" };
@@ -24712,62 +25333,56 @@ class MobileStore {
 }
 
 // packages/gateway/src/mobile/admin.ts
-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")]))
-  }),
-  Type9.Object({ status: Type9.Literal("error"), error: Type9.String() }),
-  Type9.Object({ status: Type9.Literal("stopping") })
+var listenerStateSchema = union5([
+  obj9({ status: lit4("disabled") }, { open: true }),
+  obj9({ status: lit4("starting") }, { open: true }),
+  obj9({
+    status: lit4("listening"),
+    address: str9(),
+    port: int6({ minimum: 1, maximum: 65535 }),
+    bindAddress: opt9(str9()),
+    mode: opt9(union5([lit4("direct"), lit4("wsl-relay")]))
+  }, { open: true }),
+  obj9({ status: lit4("error"), error: str9() }, { open: true }),
+  obj9({ status: lit4("stopping") }, { open: true })
 ]);
-var adminDeviceSchema = Type9.Object({
-  deviceId: Type9.String(),
-  name: Type9.String(),
-  pairedAt: Type9.Integer(),
-  lastSeenAt: Type9.Integer(),
-  online: Type9.Boolean()
-});
+var adminDeviceSchema = obj9({
+  deviceId: str9(),
+  name: str9(),
+  pairedAt: int6(),
+  lastSeenAt: int6(),
+  online: bool4()
+}, { open: true });
 var NekoMobileAdmin = contract("neko.mobile-admin", {
   version: 1,
-  input: Type9.Object({ token: Type9.String() }),
+  input: obj9({ token: str9() }, { open: true }),
   variants: {
     admin: {
       methods: {
-        state: rpc(Type9.Null(), Type9.Object({
+        state: rpc(nul4(), obj9({
           state: listenerStateSchema,
-          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: 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(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(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() }))
+          candidates: arr7(str9()),
+          port: int6({ minimum: 1, maximum: 65535 }),
+          certificate: union5([obj9({ fingerprint: str9(), expiresAt: int6() }, { open: true }), nul4()]),
+          devices: arr7(adminDeviceSchema),
+          lastConnectedAddress: union5([str9(), nul4()]),
+          wsl: opt9(union5([obj9({ interop: bool4(), error: union5([str9(), nul4()]) }, { open: true }), nul4()]))
+        }, { open: true })),
+        enable: rpc(obj9({
+          address: str9(),
+          port: opt9(int6({ minimum: 1, maximum: 65535 }))
+        }, { open: true }), obj9({
+          status: lit4("listening"),
+          address: str9(),
+          port: int6({ minimum: 1, maximum: 65535 }),
+          bindAddress: opt9(str9()),
+          mode: opt9(union5([lit4("direct"), lit4("wsl-relay")]))
+        }, { open: true })),
+        disable: rpc(nul4(), listenerStateSchema),
+        createPairing: rpc(nul4(), obj9({ pairingText: str9(), expiresAt: int6() }, { open: true })),
+        cancelPairing: rpc(nul4(), nul4()),
+        revoke: rpc(obj9({ deviceId: str9({ minLength: 1 }) }, { open: true }), obj9({ revoked: bool4() }, { open: true })),
+        regenerateCertificate: rpc(nul4(), obj9({ fingerprint: str9(), expiresAt: int6() }, { open: true }))
       }
     }
   }
@@ -24943,9 +25558,6 @@ import { ChordError as ChordError2 } from "@earendil-works/chord";
 var messageTime = (session) => session.lastMessageAt ?? session.createdAt;
 var byMessage = (a, b) => messageTime(b) - messageTime(a) || Number(b.id) - Number(a.id);
 
-// packages/gateway/src/mobile/adapter.ts
-import { Check as Check2 } from "typebox/value";
-
 // packages/gateway/src/subagent-client.ts
 function subagentClient(connect) {
   let value;
@@ -25089,16 +25701,29 @@ function subagentClient(connect) {
 // packages/gateway/src/mobile/projection.ts
 import { createHash as createHash2 } from "crypto";
 
+// packages/gateway/src/mobile/protocol.ts
+import {
+  arr as arr8,
+  bool as bool5,
+  compile as compile2,
+  int as int7,
+  lit as lit5,
+  nul as nul5,
+  num as num5,
+  obj as obj10,
+  opt as opt10,
+  str as str10,
+  union as union6
+} from "@earendil-works/pi-schema";
+
 // packages/core/src/application-version.ts
-var RUNNING_VERSION = "0.5.2";
-var APPLICATION_PROTOCOL = 9;
+var RUNNING_VERSION = "0.5.4";
+var APPLICATION_PROTOCOL = 10;
 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 Type10 } from "typebox";
-import { Check } from "typebox/value";
 var MOBILE_LIMITS = {
   maxFrameBytes: 262144,
   maxPayloadBytes: 131072,
@@ -25122,14 +25747,14 @@ var MOBILE_CAPABILITIES = [
 var MOBILE_CLOSE_REVOKED = 4401;
 var MOBILE_CLOSE_INCOMPATIBLE = 4402;
 var MOBILE_CLOSE_SLOW_CONSUMER = 4408;
-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 })
-  })
-});
+var MobileHelloParams = obj10({
+  apiVersions: arr8(int7(), { minItems: 1 }),
+  app: obj10({
+    version: str10({ minLength: 1, maxLength: 64 }),
+    platform: str10({ minLength: 1, maxLength: 64 }),
+    build: str10({ maxLength: 128 })
+  }, { open: true })
+}, { open: true });
 function asJsonRpcRequest(value) {
   if (typeof value !== "object" || value === null)
     return;
@@ -25142,8 +25767,18 @@ function asJsonRpcRequest(value) {
     return;
   return { jsonrpc: "2.0", id: record.id, method: record.method, params: record.params };
 }
+var validators = new WeakMap;
+function checkSchema(schema, value) {
+  let validator = validators.get(schema);
+  if (!validator) {
+    validator = compile2(schema);
+    validators.set(schema, validator);
+  }
+  return validator.check(value);
+}
+var helloParams = compile2(MobileHelloParams);
 function isMobileHelloParams(value) {
-  return Check(MobileHelloParams, value);
+  return helloParams.check(value);
 }
 function negotiateApiVersion(clientVersions) {
   let best;
@@ -25167,462 +25802,444 @@ function buildHelloResult(serverId, serverName, apiVersion) {
     limits: MOBILE_LIMITS
   };
 }
-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,
-  field: str2,
-  digest: str2,
-  bytes: int
-});
-var MobileImageRefSchema = Type10.Object({
-  name: str2,
-  mimeType: str2,
-  width: int,
-  height: int,
-  bytes: int,
-  entryId: int,
-  contentIndex: int
-});
-var planStatus = Type10.Union([
-  Type10.Literal("awaiting_approval"),
-  Type10.Literal("approved"),
-  Type10.Literal("revision_requested"),
-  Type10.Literal("superseded"),
-  Type10.Literal("cancelled")
+var text4 = str10();
+var count = int7({ minimum: 0 });
+var nullable2 = (schema) => union6([schema, nul5()]);
+var MobileContentRefSchema = obj10({
+  sessionId: text4,
+  agentId: opt10(text4),
+  key: text4,
+  field: text4,
+  digest: text4,
+  bytes: count
+}, { open: true });
+var MobileImageRefSchema = obj10({
+  name: text4,
+  mimeType: text4,
+  width: count,
+  height: count,
+  bytes: count,
+  entryId: count,
+  contentIndex: count
+}, { open: true });
+var planStatus = union6([
+  lit5("awaiting_approval"),
+  lit5("approved"),
+  lit5("revision_requested"),
+  lit5("superseded"),
+  lit5("cancelled")
 ]);
-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: Type10.Boolean(),
-    options: Type10.Array(Type10.Object({ id: str2, label: str2, recommended: opt(Type10.Boolean()) })),
+var questionStatus2 = union6([lit5("pending"), lit5("answered"), lit5("skipped"), lit5("cancelled")]);
+var MobileToolInteractionSchema = union6([
+  obj10({
+    kind: lit5("ask_user"),
+    id: count,
+    question: text4,
+    multiple: bool5(),
+    options: arr8(obj10({ id: text4, label: text4, recommended: opt10(bool5()) }, { open: true })),
     status: questionStatus2,
-    optionIds: opt(Type10.Array(str2)),
-    labels: opt(Type10.Array(str2)),
-    text: opt(nullable2(str2))
-  }),
-  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
-  })
+    optionIds: opt10(arr8(text4)),
+    labels: opt10(arr8(text4)),
+    text: opt10(nullable2(text4))
+  }, { open: true }),
+  obj10({
+    kind: lit5("todo"),
+    action: union6([lit5("list"), lit5("replace")]),
+    revision: count,
+    completed: count,
+    total: count
+  }, { open: true }),
+  obj10({
+    kind: lit5("submit_plan"),
+    version: text4,
+    title: text4,
+    steps: arr8(text4),
+    note: text4
+  }, { open: true })
 ]);
-var MobileToolItemSchema = Type10.Object({
-  callId: str2,
-  name: str2,
-  summary: str2,
-  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(Type10.Number()),
-  diffRemoved: opt(Type10.Number()),
-  diffTruncated: opt(Type10.Boolean()),
-  durationMs: opt(Type10.Number()),
-  note: opt(str2),
-  interaction: opt(MobileToolInteractionSchema)
-});
-var MobileChatItemSchema = Type10.Object({
-  key: str2,
-  type: Type10.Union([
-    Type10.Literal("user"),
-    Type10.Literal("assistant"),
-    Type10.Literal("tool"),
-    Type10.Literal("error"),
-    Type10.Literal("system")
-  ]),
-  text: opt(str2),
-  thinking: opt(str2),
-  note: opt(str2),
-  error: opt(str2),
-  skill: opt(str2),
-  jobId: opt(str2),
-  tool: opt(MobileToolItemSchema),
-  images: opt(Type10.Array(MobileImageRefSchema)),
-  refs: opt(Type10.Array(MobileContentRefSchema))
-});
-var MobileStreamingSchema = Type10.Object({
-  text: str2,
-  thinking: str2,
-  textOmitted: int,
-  thinkingOmitted: int,
-  toolCalls: Type10.Array(Type10.Object({
-    callId: str2,
-    name: str2,
-    summary: str2,
-    status: Type10.Union([Type10.Literal("running"), Type10.Literal("done")])
-  }))
-});
-var MobileUsageSchema = Type10.Object({
-  input: int,
-  output: int,
-  cacheRead: int,
-  cacheWrite: int,
-  totalTokens: int,
-  cost: Type10.Number({ minimum: 0 })
-});
-var MobileSubagentRoundSchema = Type10.Object({
-  taskId: int,
-  callId: str2,
-  agentId: str2,
-  round: opt(int),
-  role: str2,
-  title: str2,
-  status: Type10.Union([
-    Type10.Literal("queued"),
-    Type10.Literal("running"),
-    Type10.Literal("completed"),
-    Type10.Literal("failed"),
-    Type10.Literal("cancelled")
-  ]),
-  approvalCount: int,
-  readonly: Type10.Boolean(),
-  createdAt: Type10.Number(),
-  endedAt: nullable2(Type10.Number()),
-  usage: opt(MobileUsageSchema)
-});
-var MobileAgentSchema = Type10.Object({
-  agentId: str2,
-  role: str2,
-  title: str2,
-  status: Type10.Union([Type10.Literal("idle"), Type10.Literal("queued"), Type10.Literal("running")]),
-  activeRoundId: nullable2(int),
-  lastRoundId: int,
-  roundCount: int,
-  approvalCount: int
-});
-var MobileQueuedSchema = Type10.Object({
-  id: int,
-  mode: Type10.Union([Type10.Literal("steer"), Type10.Literal("followUp")]),
-  preview: Type10.String(),
-  images: 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),
+var MobileCodemodeSchema = obj10({
+  calls: arr8(obj10({
+    id: count,
+    name: text4,
+    args: str10({ maxLength: CODEMODE_VIEW_LIMITS.argsChars }),
+    status: union6([lit5("running"), lit5("ok"), lit5("error"), lit5("cancelled")]),
+    durationMs: opt10(num5()),
+    error: opt10(str10({ maxLength: CODEMODE_VIEW_LIMITS.errorChars }))
+  }, { open: true }), { maxItems: CODEMODE_VIEW_LIMITS.maxCalls }),
+  omitted: count,
+  fullOutputPath: opt10(text4)
+}, { open: true });
+var MobileToolItemSchema = obj10({
+  callId: text4,
+  name: text4,
+  summary: text4,
+  status: union6([lit5("running"), lit5("done"), lit5("error")]),
+  detail: opt10(text4),
+  output: opt10(text4),
+  result: opt10(text4),
+  diff: opt10(text4),
+  diffAdded: opt10(num5()),
+  diffRemoved: opt10(num5()),
+  diffTruncated: opt10(bool5()),
+  durationMs: opt10(num5()),
+  note: opt10(text4),
+  interaction: opt10(MobileToolInteractionSchema),
+  codemode: opt10(MobileCodemodeSchema)
+}, { open: true });
+var MobileChatItemSchema = obj10({
+  key: text4,
+  type: union6([lit5("user"), lit5("assistant"), lit5("tool"), lit5("error"), lit5("system")]),
+  text: opt10(text4),
+  thinking: opt10(text4),
+  note: opt10(text4),
+  error: opt10(text4),
+  skill: opt10(text4),
+  jobId: opt10(text4),
+  tool: opt10(MobileToolItemSchema),
+  images: opt10(arr8(MobileImageRefSchema)),
+  refs: opt10(arr8(MobileContentRefSchema))
+}, { open: true });
+var MobileStreamingSchema = obj10({
+  text: text4,
+  thinking: text4,
+  textOmitted: count,
+  thinkingOmitted: count,
+  toolCalls: arr8(obj10({
+    callId: text4,
+    name: text4,
+    summary: text4,
+    status: union6([lit5("running"), lit5("done")])
+  }, { open: true }))
+}, { open: true });
+var MobileUsageSchema = obj10({
+  input: count,
+  output: count,
+  cacheRead: count,
+  cacheWrite: count,
+  totalTokens: count,
+  cost: num5({ minimum: 0 })
+}, { open: true });
+var MobileSubagentRoundSchema = obj10({
+  taskId: count,
+  callId: text4,
+  agentId: text4,
+  round: opt10(count),
+  role: text4,
+  title: text4,
+  status: union6([lit5("queued"), lit5("running"), lit5("completed"), lit5("failed"), lit5("cancelled")]),
+  approvalCount: count,
+  readonly: bool5(),
+  createdAt: num5(),
+  endedAt: nullable2(num5()),
+  usage: opt10(MobileUsageSchema)
+}, { open: true });
+var MobileAgentSchema = obj10({
+  agentId: text4,
+  role: text4,
+  title: text4,
+  status: union6([lit5("idle"), lit5("queued"), lit5("running")]),
+  activeRoundId: nullable2(count),
+  lastRoundId: count,
+  roundCount: count,
+  approvalCount: count
+}, { open: true });
+var MobileQueuedSchema = obj10({
+  id: count,
+  mode: union6([lit5("steer"), lit5("followUp")]),
+  preview: str10(),
+  images: count
+}, { open: true });
+var mobileChatStatusProperties = {
+  busy: bool5(),
+  queued: opt10(arr8(MobileQueuedSchema)),
+  todos: opt10(obj10({ revision: count, count, completed: count }, { open: true })),
+  questions: opt10(obj10({ revision: count, pendingCount: count }, { open: true })),
+  plan: opt10(obj10({ revision: count, pending: bool5(), version: opt10(str10({ minLength: 1 })) }, { open: true })),
+  status: nullable2(text4),
   usage: MobileUsageSchema,
-  taskUsage: opt(MobileUsageSchema),
-  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(Type10.Object({ phase: str2, at: Type10.Number() })),
-  readonly: opt(Type10.Boolean())
-});
-var MobileChatSnapshotSchema = Type10.Object({
-  ...MobileChatStatusSchema.properties,
-  items: Type10.Array(MobileChatItemSchema),
-  historyBefore: nullable2(str2),
+  taskUsage: opt10(MobileUsageSchema),
+  contextUsage: opt10(obj10({ tokens: nullable2(num5()), window: num5(), percent: nullable2(num5()) }, { open: true })),
+  agent: obj10({ model: nullable2(text4), thinkingLevel: nullable2(text4) }, { open: true }),
+  subagents: arr8(MobileSubagentRoundSchema),
+  agents: arr8(MobileAgentSchema),
+  approvalCount: count,
+  compaction: opt10(obj10({ phase: text4, at: num5() }, { open: true })),
+  runFailure: opt10(obj10({ reason: text4, detail: opt10(text4) }, { open: true })),
+  readonly: opt10(bool5())
+};
+var MobileChatStatusSchema = obj10(mobileChatStatusProperties, { open: true });
+var MobileChatSnapshotSchema = obj10({
+  ...mobileChatStatusProperties,
+  items: arr8(MobileChatItemSchema),
+  historyBefore: nullable2(text4),
   streaming: nullable2(MobileStreamingSchema)
-});
-var MobileWorkspaceSchema = Type10.Object({ root: str2, name: str2 });
-var MobileSessionSummarySchema = Type10.Object({
-  id: str2,
-  workspace: str2,
-  title: str2,
-  preview: str2,
-  lastUsedAt: Type10.Integer(),
-  lastMessageAt: Type10.Integer(),
-  archived: Type10.Boolean(),
-  awaitingAnswer: opt(Type10.Boolean()),
-  awaitingPlan: opt(Type10.Boolean())
-});
-var MobileApprovalSchema = Type10.Object({
-  id: int,
-  version: str2,
-  taskId: int,
-  agentId: opt(str2),
-  title: opt(str2),
-  command: str2,
-  cwd: str2,
-  timeoutSeconds: opt(Type10.Number({ minimum: 0 })),
-  requestedAt: Type10.Number()
-});
-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 = Type10.Object({
-  revision: int,
-  items: Type10.Array(MobileTodoItemSchema, { maxItems: TODO_LIMITS.maxItems })
-});
-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 = Type10.Object({
-  id: int,
-  version: str2,
-  preview: Type10.String({ maxLength: QUESTION_LIMITS.previewChars }),
-  multiple: Type10.Boolean(),
-  optionCount: int,
-  createdAt: Type10.Number()
-});
-var MobileQuestionListSchema = Type10.Object({
-  revision: int,
-  pending: Type10.Array(MobileQuestionSummarySchema, { maxItems: QUESTION_LIMITS.maxPending })
-});
-var MobileQuestionSchema = Type10.Object({
-  id: int,
-  callId: str2,
-  version: str2,
-  question: Type10.String({ maxLength: QUESTION_LIMITS.questionChars }),
-  multiple: Type10.Boolean(),
-  options: Type10.Array(MobileQuestionOptionSchema, { maxItems: QUESTION_LIMITS.maxOptions }),
+}, { open: true });
+var MobileWorkspaceSchema = obj10({ root: text4, name: text4 }, { open: true });
+var MobileSessionSummarySchema = obj10({
+  id: text4,
+  workspace: text4,
+  title: text4,
+  preview: text4,
+  lastUsedAt: int7(),
+  lastMessageAt: int7(),
+  archived: bool5(),
+  awaitingAnswer: opt10(bool5()),
+  awaitingPlan: opt10(bool5())
+}, { open: true });
+var MobileApprovalSchema = obj10({
+  id: count,
+  version: text4,
+  taskId: count,
+  agentId: opt10(text4),
+  title: opt10(text4),
+  command: text4,
+  cwd: text4,
+  timeoutSeconds: opt10(num5({ minimum: 0 })),
+  requestedAt: num5()
+}, { open: true });
+var MobileTodoItemSchema = obj10({
+  id: str10({ minLength: 1, maxLength: TODO_LIMITS.idChars }),
+  text: str10({ minLength: 1, maxLength: TODO_LIMITS.textChars }),
+  status: union6([lit5("pending"), lit5("in_progress"), lit5("completed")])
+}, { open: true });
+var MobileTodoListSchema = obj10({
+  revision: count,
+  items: arr8(MobileTodoItemSchema, { maxItems: TODO_LIMITS.maxItems })
+}, { open: true });
+var MobileQuestionOptionSchema = obj10({
+  id: str10({ minLength: 1, maxLength: QUESTION_LIMITS.optionIdChars }),
+  label: str10({ minLength: 1, maxLength: QUESTION_LIMITS.labelChars }),
+  description: opt10(str10({ maxLength: QUESTION_LIMITS.descriptionChars })),
+  recommended: opt10(bool5())
+}, { open: true });
+var MobileQuestionSummarySchema = obj10({
+  id: count,
+  version: text4,
+  preview: str10({ maxLength: QUESTION_LIMITS.previewChars }),
+  multiple: bool5(),
+  optionCount: count,
+  createdAt: num5()
+}, { open: true });
+var MobileQuestionListSchema = obj10({
+  revision: count,
+  pending: arr8(MobileQuestionSummarySchema, { maxItems: QUESTION_LIMITS.maxPending })
+}, { open: true });
+var MobileQuestionSchema = obj10({
+  id: count,
+  callId: text4,
+  version: text4,
+  question: str10({ maxLength: QUESTION_LIMITS.questionChars }),
+  multiple: bool5(),
+  options: arr8(MobileQuestionOptionSchema, { maxItems: QUESTION_LIMITS.maxOptions }),
   status: questionStatus2,
-  answer: nullable2(Type10.Object({
-    optionIds: Type10.Array(Type10.String(), { maxItems: QUESTION_LIMITS.maxOptions }),
-    text: nullable2(Type10.String({ maxLength: QUESTION_LIMITS.textChars }))
-  })),
-  createdAt: Type10.Number(),
-  settledAt: nullable2(Type10.Number())
-});
-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 }),
-  Type10.Object({ kind: Type10.Literal("skip") }, { additionalProperties: false })
+  answer: nullable2(obj10({
+    optionIds: arr8(str10(), { maxItems: QUESTION_LIMITS.maxOptions }),
+    text: nullable2(str10({ maxLength: QUESTION_LIMITS.textChars }))
+  }, { open: true })),
+  createdAt: num5(),
+  settledAt: nullable2(num5())
+}, { open: true });
+var MobileQuestionResponseSchema = union6([
+  obj10({
+    kind: lit5("answer"),
+    optionIds: opt10(arr8(str10(), { maxItems: QUESTION_LIMITS.maxOptions })),
+    text: opt10(str10({ maxLength: QUESTION_LIMITS.textChars }))
+  }),
+  obj10({ kind: lit5("skip") })
 ]);
-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 }),
+var MobilePlanSchema = obj10({
+  version: str10({ minLength: 1 }),
+  title: str10({ maxLength: PLAN_LIMITS.titleChars }),
+  steps: arr8(str10({ maxLength: PLAN_LIMITS.stepChars }), { maxItems: PLAN_LIMITS.maxSteps }),
+  note: str10({ 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 })
+  feedback: nullable2(str10({ maxLength: PLAN_LIMITS.feedbackChars })),
+  createdAt: num5(),
+  settledAt: nullable2(num5())
+}, { open: true });
+var MobilePlanDecisionSchema = union6([
+  obj10({ kind: lit5("approve") }),
+  obj10({ kind: lit5("revise"), feedback: str10({ minLength: 1, maxLength: PLAN_LIMITS.feedbackChars }) })
 ]);
-var sessionListParams = Type10.Object({
-  workspace: str2,
-  query: opt(str2),
-  cursor: opt(str2)
-});
-var sessionListResult = Type10.Object({
-  sessions: Type10.Array(MobileSessionSummarySchema),
-  nextCursor: opt(str2)
-});
-var subscription = { subscriptionId: Type10.String({ minLength: 1 }) };
-var pageResult = Type10.Object({ items: Type10.Array(MobileChatItemSchema), historyBefore: nullable2(str2) });
-var pageParams = Type10.Object({
+var sessionListParams = obj10({
+  workspace: text4,
+  query: opt10(text4),
+  cursor: opt10(text4)
+}, { open: true });
+var sessionListResult = obj10({
+  sessions: arr8(MobileSessionSummarySchema),
+  nextCursor: opt10(text4)
+}, { open: true });
+var subscription = { subscriptionId: str10({ minLength: 1 }) };
+var pageResult = obj10({ items: arr8(MobileChatItemSchema), historyBefore: nullable2(text4) }, { open: true });
+var pageParams = obj10({
   ...subscription,
-  before: Type10.String({ minLength: 1 }),
-  limit: opt(Type10.Integer({ minimum: 1, maximum: 50 }))
-});
-var chunkResult = Type10.Object({ data: str2, nextOffset: int, total: int, done: Type10.Boolean() });
+  before: str10({ minLength: 1 }),
+  limit: opt10(int7({ minimum: 1, maximum: 50 }))
+}, { open: true });
+var chunkResultProperties = { data: text4, nextOffset: count, total: count, done: bool5() };
+var chunkResult = obj10(chunkResultProperties, { open: true });
 var MOBILE_API_V1_METHODS = {
   "server.hello": { params: MobileHelloParams, result: buildHelloResultSchema() },
-  "workspaces.list": { params: Type10.Null(), result: Type10.Object({ workspaces: Type10.Array(MobileWorkspaceSchema) }) },
+  "workspaces.list": { params: nul5(), result: obj10({ workspaces: arr8(MobileWorkspaceSchema) }, { open: true }) },
   "sessions.list": { params: sessionListParams, result: sessionListResult },
-  "sessions.create": { params: Type10.Object({ workspace: str2 }), result: MobileSessionSummarySchema },
+  "sessions.create": { params: obj10({ workspace: text4 }, { open: true }), result: MobileSessionSummarySchema },
   "chat.attach": {
-    params: Type10.Object({ sessionId: Type10.String({ minLength: 1 }) }),
-    result: Type10.Object({ subscriptionId: str2, sessionId: str2, snapshot: MobileChatSnapshotSchema })
+    params: obj10({ sessionId: str10({ minLength: 1 }) }, { open: true }),
+    result: obj10({ subscriptionId: text4, sessionId: text4, snapshot: MobileChatSnapshotSchema }, { open: true })
   },
-  "chat.detach": { params: Type10.Object(subscription), result: Type10.Null() },
+  "chat.detach": { params: obj10(subscription, { open: true }), result: nul5() },
   "chat.history": { params: pageParams, result: pageResult },
   "chat.content": {
-    params: Type10.Object({ ref: MobileContentRefSchema, offset: int }),
+    params: obj10({ ref: MobileContentRefSchema, offset: count }, { open: true }),
     result: chunkResult
   },
   "chat.submit": {
-    params: Type10.Object({
+    params: obj10({
       ...subscription,
-      requestId: Type10.String({ minLength: 1, maxLength: 128 }),
-      text: Type10.String({ minLength: 1, maxLength: 65536 }),
-      mode: opt(Type10.Literal("steer"))
-    }),
-    result: Type10.Object({ accepted: Type10.Literal(true), queued: Type10.Boolean() })
+      requestId: str10({ minLength: 1, maxLength: 128 }),
+      text: str10({ minLength: 1, maxLength: 65536 }),
+      mode: opt10(lit5("steer"))
+    }, { open: true }),
+    result: obj10({ accepted: lit5(true), queued: bool5() }, { open: true })
   },
   "chat.submissionStatus": {
-    params: Type10.Object({ ...subscription, requestId: Type10.String({ minLength: 1, maxLength: 128 }) }),
-    result: Type10.Object({ status: Type10.Union([Type10.Literal("accepted"), Type10.Literal("unknown")]) })
+    params: obj10({ ...subscription, requestId: str10({ minLength: 1, maxLength: 128 }) }, { open: true }),
+    result: obj10({ status: union6([lit5("accepted"), lit5("unknown")]) }, { open: true })
   },
   "chat.steer": {
-    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(Type10.String()),
-      images: opt(int)
-    })
+    params: obj10({ ...subscription, id: count }, { open: true }),
+    result: obj10({
+      result: union6([lit5("steered"), lit5("withdrawn"), lit5("placed"), lit5("settled"), lit5("unknown")]),
+      id: opt10(count),
+      text: opt10(str10()),
+      images: opt10(count)
+    }, { open: true })
   },
   "chat.withdraw": {
-    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(Type10.String()),
-      images: opt(int)
-    })
+    params: obj10({ ...subscription, id: count }, { open: true }),
+    result: obj10({
+      result: union6([lit5("withdrawn"), lit5("placed"), lit5("settled"), lit5("unknown")]),
+      text: opt10(str10()),
+      images: opt10(count)
+    }, { open: true })
   },
-  "chat.abort": { params: Type10.Object(subscription), result: Type10.Object({ accepted: Type10.Boolean() }) },
+  "chat.abort": { params: obj10(subscription, { open: true }), result: obj10({ accepted: bool5() }, { open: true }) },
   "subagents.open": {
-    params: Type10.Object({ ...subscription, agentId: opt(Type10.String({ minLength: 1 })), taskId: opt(int) }),
-    result: Type10.Object({
-      subagentSubscriptionId: str2,
-      agentId: str2,
+    params: obj10({ ...subscription, agentId: opt10(str10({ minLength: 1 })), taskId: opt10(count) }, { open: true }),
+    result: obj10({
+      subagentSubscriptionId: text4,
+      agentId: text4,
       snapshot: MobileChatSnapshotSchema
-    })
+    }, { open: true })
   },
   "subagents.history": {
-    params: Type10.Object({
-      subagentSubscriptionId: Type10.String({ minLength: 1 }),
-      before: Type10.String({ minLength: 1 }),
-      limit: opt(Type10.Integer({ minimum: 1, maximum: 50 }))
-    }),
+    params: obj10({
+      subagentSubscriptionId: str10({ minLength: 1 }),
+      before: str10({ minLength: 1 }),
+      limit: opt10(int7({ minimum: 1, maximum: 50 }))
+    }, { open: true }),
     result: pageResult
   },
   "subagents.close": {
-    params: Type10.Object({ subagentSubscriptionId: Type10.String({ minLength: 1 }) }),
-    result: Type10.Null()
+    params: obj10({ subagentSubscriptionId: str10({ minLength: 1 }) }, { open: true }),
+    result: nul5()
   },
   "subagents.stop": {
-    params: Type10.Object({ ...subscription, taskId: int }),
-    result: Type10.Object({ stopped: Type10.Boolean() })
+    params: obj10({ ...subscription, taskId: count }, { open: true }),
+    result: obj10({ stopped: bool5() }, { open: true })
   },
   "approvals.list": {
-    params: Type10.Object(subscription),
-    result: Type10.Object({ approvals: Type10.Array(MobileApprovalSchema) })
+    params: obj10(subscription, { open: true }),
+    result: obj10({ approvals: arr8(MobileApprovalSchema) }, { open: true })
   },
-  "approvals.get": { params: Type10.Object({ ...subscription, id: int }), result: MobileApprovalSchema },
+  "approvals.get": { params: obj10({ ...subscription, id: count }, { open: true }), result: MobileApprovalSchema },
   "approvals.decide": {
-    params: Type10.Object({
+    params: obj10({
       ...subscription,
-      taskId: int,
-      id: int,
-      version: Type10.String({ minLength: 1 }),
-      decision: Type10.Union([Type10.Literal("allow"), Type10.Literal("deny")])
-    }),
-    result: Type10.Object({
-      status: Type10.Union([
-        Type10.Literal("pending"),
-        Type10.Literal("allowed"),
-        Type10.Literal("denied"),
-        Type10.Literal("cancelled")
-      ])
-    })
+      taskId: count,
+      id: count,
+      version: str10({ minLength: 1 }),
+      decision: union6([lit5("allow"), lit5("deny")])
+    }, { open: true }),
+    result: obj10({
+      status: union6([lit5("pending"), lit5("allowed"), lit5("denied"), lit5("cancelled")])
+    }, { open: true })
   },
-  "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 },
+  "todos.get": { params: obj10(subscription, { open: true }), result: MobileTodoListSchema },
+  "questions.list": { params: obj10(subscription, { open: true }), result: MobileQuestionListSchema },
+  "questions.get": { params: obj10({ ...subscription, id: count }, { open: true }), result: MobileQuestionSchema },
   "questions.respond": {
-    params: Type10.Object({
+    params: obj10({
       ...subscription,
-      id: int,
-      version: Type10.String({ minLength: 1 }),
+      id: count,
+      version: str10({ minLength: 1 }),
       response: MobileQuestionResponseSchema
-    }),
+    }, { open: true }),
     result: MobileQuestionSchema
   },
   "plan.get": {
-    params: Type10.Object({ ...subscription, version: Type10.String({ minLength: 1 }) }),
+    params: obj10({ ...subscription, version: str10({ minLength: 1 }) }, { open: true }),
     result: MobilePlanSchema
   },
   "plan.respond": {
-    params: Type10.Object({
+    params: obj10({
       ...subscription,
-      version: Type10.String({ minLength: 1 }),
+      version: str10({ minLength: 1 }),
       decision: MobilePlanDecisionSchema
-    }),
+    }, { open: true }),
     result: MobilePlanSchema
   },
   "plan.exit": {
-    params: Type10.Object(subscription),
-    result: Type10.Object({ mode: Type10.Literal("normal"), revision: int })
+    params: obj10(subscription, { open: true }),
+    result: obj10({ mode: lit5("normal"), revision: count }, { open: true })
   },
   "media.read": {
-    params: Type10.Object({
+    params: obj10({
       ...subscription,
-      agentId: opt(Type10.String({ minLength: 1 })),
-      entryId: int,
-      contentIndex: int,
-      offset: int
-    }),
-    result: Type10.Object({ ...chunkResult.properties, mimeType: str2 })
+      agentId: opt10(str10({ minLength: 1 })),
+      entryId: count,
+      contentIndex: count,
+      offset: count
+    }, { open: true }),
+    result: obj10({ ...chunkResultProperties, mimeType: text4 }, { open: true })
   }
 };
 function buildHelloResultSchema() {
-  return Type10.Object({
-    apiVersion: Type10.Integer({ minimum: 1 }),
-    serverId: str2,
-    serverName: str2,
-    gatewayVersion: str2,
-    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()
-    })
-  });
+  return obj10({
+    apiVersion: int7({ minimum: 1 }),
+    serverId: text4,
+    serverName: text4,
+    gatewayVersion: text4,
+    capabilities: arr8(text4),
+    limits: obj10({
+      maxFrameBytes: int7(),
+      maxPayloadBytes: int7(),
+      pageItems: int7(),
+      chunkBytes: int7(),
+      maxConcurrentRequests: int7(),
+      maxSendBufferBytes: int7()
+    }, { open: true })
+  }, { open: true });
 }
 var patchBody = {
-  seq: Type10.Integer({ minimum: 1 }),
-  upserts: Type10.Array(MobileChatItemSchema),
-  status: opt(MobileChatStatusSchema),
-  streaming: opt(nullable2(MobileStreamingSchema)),
-  streamingAppend: opt(Type10.Object({ text: opt(str2), thinking: opt(str2) }))
+  seq: int7({ minimum: 1 }),
+  upserts: arr8(MobileChatItemSchema),
+  status: opt10(MobileChatStatusSchema),
+  streaming: opt10(nullable2(MobileStreamingSchema)),
+  streamingAppend: opt10(obj10({ text: opt10(text4), thinking: opt10(text4) }, { open: true }))
 };
 var MOBILE_API_V1_NOTIFICATIONS = {
-  "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 }) })
+  "workspaces.changed": obj10({ revision: int7({ minimum: 1 }) }, { open: true }),
+  "sessions.changed": obj10({ revision: int7({ minimum: 1 }) }, { open: true }),
+  "chat.patch": obj10({ subscriptionId: text4, ...patchBody }, { open: true }),
+  "chat.reset": obj10({ subscriptionId: text4, seq: int7({ minimum: 1 }) }, { open: true }),
+  "subagents.patch": obj10({ subagentSubscriptionId: text4, ...patchBody }, { open: true }),
+  "subagents.reset": obj10({ subagentSubscriptionId: text4, seq: int7({ minimum: 1 }) }, { open: true }),
+  "approvals.changed": obj10({ subscriptionId: text4, revision: int7({ minimum: 1 }) }, { open: true }),
+  "todos.changed": obj10({ subscriptionId: text4, revision: int7({ minimum: 1 }) }, { open: true }),
+  "questions.changed": obj10({ subscriptionId: text4, revision: int7({ minimum: 1 }) }, { open: true }),
+  "plan.changed": obj10({ subscriptionId: text4, revision: int7({ minimum: 1 }) }, { open: true })
 };
 
 // packages/gateway/src/mobile/projection.ts
@@ -25664,12 +26281,12 @@ function utf8Prefix(value, maxBytes) {
 function jsonBytes2(value) {
   return Buffer.byteLength(JSON.stringify(value), "utf8");
 }
-var count = (value) => Math.max(0, Math.round(value ?? 0));
+var count2 = (value) => Math.max(0, Math.round(value ?? 0));
 function mapUsage(usage) {
-  const input = count(usage.input);
-  const output = count(usage.output);
-  const cacheRead = count(usage.cacheRead);
-  const cacheWrite = count(usage.cacheWrite);
+  const input = count2(usage.input);
+  const output = count2(usage.output);
+  const cacheRead = count2(usage.cacheRead);
+  const cacheWrite = count2(usage.cacheWrite);
   return {
     input,
     output,
@@ -25721,9 +26338,9 @@ function mapChatItem(raw, owner) {
     images: list.map((image) => ({
       name: image.name,
       mimeType: image.mimeType,
-      width: count(image.width),
-      height: count(image.height),
-      bytes: count(image.bytes),
+      width: count2(image.width),
+      height: count2(image.height),
+      bytes: count2(image.bytes),
       entryId: image.entryId,
       contentIndex: image.contentIndex
     }))
@@ -25773,6 +26390,17 @@ function mapChatItem(raw, owner) {
         tool.note = raw.note;
       if (raw.interaction !== undefined)
         tool.interaction = raw.interaction;
+      if (raw.codemode !== undefined) {
+        tool.codemode = {
+          calls: raw.codemode.calls.map(({ durationMs, error, ...call }) => ({
+            ...call,
+            ...durationMs === null ? {} : { durationMs },
+            ...error === null ? {} : { error }
+          })),
+          omitted: raw.codemode.omitted,
+          ...raw.codemode.fullOutputPath === null ? {} : { fullOutputPath: raw.codemode.fullOutputPath }
+        };
+      }
       item = { key: raw.key, type: "tool", tool, ...images(raw.images) };
       break;
     }
@@ -25799,7 +26427,7 @@ function mapRound(round, readonlyRound) {
     role: round.role,
     title: round.title,
     status: round.status,
-    approvalCount: count(round.approvalCount),
+    approvalCount: count2(round.approvalCount),
     readonly: readonlyRound || round.historyThrough !== undefined,
     createdAt: round.createdAt,
     endedAt: round.endedAt,
@@ -25816,7 +26444,7 @@ function mapStatus(view, options = {}) {
     activeRoundId: agent.activeRoundId,
     lastRoundId: agent.lastRoundId,
     roundCount: agent.roundCount,
-    approvalCount: count(agent.approvalCount)
+    approvalCount: count2(agent.approvalCount)
   }));
   const approvalCount = view.approvals !== undefined ? view.approvals.filter((approval) => approval.status === "pending").length : rounds.reduce((sum, round) => sum + round.approvalCount, 0);
   const latest = view.compaction?.latest;
@@ -25852,6 +26480,12 @@ function mapStatus(view, options = {}) {
     agents,
     approvalCount,
     ...latest ? { compaction: { phase: latest.phase, at: latest.at } } : {},
+    ...view.runFailure === undefined ? {} : {
+      runFailure: {
+        reason: view.runFailure.reason,
+        ...view.runFailure.detail === undefined ? {} : { detail: view.runFailure.detail }
+      }
+    },
     ...options.readonly === undefined ? {} : { readonly: options.readonly }
   };
 }
@@ -26294,12 +26928,12 @@ class MobileAdapter {
       this.sendError(id, -32601, "method not found", { code: "not_found" });
       return;
     }
-    if (!Check2(spec.params, params)) {
+    if (!checkSchema(spec.params, params)) {
       this.sendError(id, -32602, "invalid params", { code: "invalid_params" });
       return;
     }
     const result = await this.invoke(method, params);
-    if (!Check2(spec.result, result)) {
+    if (!checkSchema(spec.result, result)) {
       this.onError?.(new Error(`mobile result for ${method} does not match its schema`));
       this.sendError(id, -32603, "internal result mismatch", { code: "internal" });
       return;
@@ -28430,6 +29064,7 @@ async function removeGatewayPortFile(nekoDir, serverId) {
 // packages/gateway/src/server-services.ts
 import { randomUUID as randomUUID6 } from "crypto";
 import { ChordError as ChordError5, local as local3, method as method2 } from "@earendil-works/chord";
+import { nul as nul6, obj as obj13 } from "@earendil-works/pi-schema";
 
 // packages/core/src/application-updates.ts
 import { mkdir as mkdir3, readFile as readFile6, rm as rm3, writeFile as writeFile3 } from "fs/promises";
@@ -28578,9 +29213,6 @@ class UpdateChecker {
   }
 }
 
-// packages/gateway/src/server-services.ts
-import { Type as Type13 } from "typebox";
-
 // packages/gateway/src/session-host.ts
 import { open as open3 } from "fs/promises";
 import { basename as basename3, extname } from "path";
@@ -28591,7 +29223,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 Type12 } from "typebox";
+import { obj as obj12, str as str12 } from "@earendil-works/pi-schema";
 
 // packages/gateway/src/image-uploads.ts
 var IMAGE_CHUNK_BYTES = 256 * 1024;
@@ -28690,18 +29322,23 @@ 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 Type11 } from "typebox";
+import { int as int8, obj as obj11, str as str11 } from "@earendil-works/pi-schema";
 async function openReader(runtime, childId, parentId, context, through, historyUsage) {
   const child = await runtime.harness.conversation(childId, context);
   if (!child)
     throw new ChordError3("gone", "Subagent unavailable");
-  const native = await child.viewState(context);
+  const native = await child.watch(context);
+  const listeners = new Set;
   if (through !== undefined)
-    native.dispose();
+    await native.stop();
+  else
+    native.start(async () => {
+      for (const listener of listeners)
+        listener();
+    });
   const project = (entries, streaming = true) => {
     const result = projectChatView({ ...native.value, entries: [...entries].sort((a, b) => a.id - b.id) }, "", {
-      models: runtime.listModels(),
-      contextEntries: native.value.entries
+      models: runtime.listModels()
     });
     if (!streaming || through !== undefined) {
       result.streaming = null;
@@ -28750,8 +29387,10 @@ async function openReader(runtime, childId, parentId, context, through, historyU
     subscribe: (fn) => {
       if (through !== undefined)
         return () => {};
-      const stop = native.subscribe(() => fn(null));
-      const stopApprovals = runtime.harness.subscribeCommits(({ changes }) => {
+      const listener = () => fn(null);
+      listeners.add(listener);
+      const stop = () => listeners.delete(listener);
+      const stopApprovals = onCommits(runtime.harness, ({ changes }) => {
         if (changes.some((c) => c.type === "document" && ["app.neko.approvals", "app.neko.delegations", "app.neko.subagents"].includes(c.record.kind) && c.conversationId === parentId))
           fn(null);
       });
@@ -28810,20 +29449,23 @@ async function openReader(runtime, childId, parentId, context, through, historyU
         mimeType: image.mimeType
       };
     },
-    close: () => native.dispose()
+    close: () => {
+      listeners.clear();
+      native.stop();
+    }
   };
 }
 var ChildProjection = local("neko.subagent-projection", {
   version: 1,
-  input: Type11.Object({ parentId: Type11.Integer(), agentId: Type11.String() }),
+  input: obj11({ parentId: int8(), agentId: str11() }, { open: true }),
   members: {
-    revision: Type11.Integer(),
+    revision: int8(),
     reader: opaque("neko.subagent-reader@1")
   }
 });
 function installSubagentHost(host, runtime, context) {
   host.serve(ChildProjection, (input, _principal, self2) => {
-    const revision = self2.state("revision", Type11.Integer(), 0);
+    const revision = self2.state("revision", int8(), 0);
     const reader = self2.resource("reader", {
       version: 1,
       async open() {
@@ -28864,7 +29506,7 @@ function installSubagentHost(host, runtime, context) {
       parentId: Number(input.sessionId),
       agentId: input.agentId ?? `round-${input.taskId}`
     });
-    const authorizedRevision = self2.state("authorizedRevision", Type11.Integer(), 0);
+    const authorizedRevision = self2.state("authorizedRevision", int8(), 0);
     self2.on("authorizedView", shared.revision, async (value, ctx) => {
       try {
         target.value;
@@ -28917,7 +29559,7 @@ function installSubagentHost(host, runtime, context) {
 }
 
 // packages/gateway/src/session-host.ts
-var OwnerInput = Type12.Object({});
+var OwnerInput = obj12({}, { open: true });
 var Owner = local2("neko.attachment-owner", {
   version: 1,
   input: OwnerInput,
@@ -28925,7 +29567,7 @@ var Owner = local2("neko.attachment-owner", {
 });
 var Projection = local2("neko.projection", {
   version: 1,
-  input: Type12.Object({ id: Type12.String() }),
+  input: obj12({ id: str12() }, { open: true }),
   members: {
     view: ChatViewSchema,
     reader: opaque2("neko.projection-reader@1")
@@ -28945,20 +29587,12 @@ var emptyView = {
 var JOB_COMMAND_PREVIEW_CHARS = 1000;
 var clipJob = (job) => job.command.length > JOB_COMMAND_PREVIEW_CHARS ? { ...job, command: `${job.command.slice(0, JOB_COMMAND_PREVIEW_CHARS)}\u2026` } : job;
 async function openProjection(runtime, session, context) {
-  const view = await session.viewState();
-  const history = new Map;
-  let cursor;
-  do {
-    const page = await session.conversation.entries({ order: "ascending" }, 100, cursor, context);
-    for (const entry of page.items)
-      history.set(entry.id, entry);
-    cursor = page.next;
-  } while (cursor);
+  const view = await session.follow();
   let changed;
   const stop = view.subscribe(() => changed?.(null));
   const stopMetadata = runtime.onDirectoryChange(() => changed?.(null));
   let childIds = new Set;
-  const stopChildren = runtime.harness.subscribeCommits(({ changes }) => {
+  const stopChildren = onCommits(runtime.harness, ({ changes }) => {
     if (changes.some((change) => change.type === "entry" && change.value.kind === "pi.tool-result" && childIds.has(change.value.conversationId) || change.type === "document" && ([
       "app.neko.delegations",
       "app.neko.approvals",
@@ -28979,12 +29613,9 @@ async function openProjection(runtime, session, context) {
       };
     },
     async project() {
-      for (const entry of view.value.entries)
-        history.set(entry.id, entry);
       const [naming, compaction] = await Promise.all([runtime.namingUsage(session.id), session.compactionRecord()]);
       const projected = projectChatView({
         ...view.value,
-        entries: [...history.values()].sort((a, b) => a.id - b.id),
         docs: {
           ...view.value.docs,
           "pi.usage": mergeUsage(view.value.docs["pi.usage"] ?? {
@@ -28992,7 +29623,7 @@ async function openProjection(runtime, session, context) {
             tools: {}
           }, naming)
         }
-      }, "", { models: runtime.listModels(), contextEntries: view.value.entries, compaction });
+      }, "", { models: runtime.listModels(), compaction });
       const jobs = (await session.jobs()).map(clipJob);
       const [todos, questions, plan] = await Promise.all([session.todos(), session.questions(), session.plan()]);
       const changes = await session.changeSummary().catch(() => {
@@ -29033,16 +29664,13 @@ async function openProjection(runtime, session, context) {
     },
     async entry(id, ctx) {
       ctx.abortSignal?.throwIfAborted();
-      for (const entry of view.value.entries)
-        history.set(entry.id, entry);
-      return history.get(id);
+      return view.entry(id);
     },
     close() {
       stop();
       stopMetadata();
       stopChildren();
       view.dispose();
-      history.clear();
     }
   };
 }
@@ -29218,6 +29846,14 @@ function serveSessions(host, runtime, context) {
         await projection.value.session.abort();
         return null;
       },
+      continueRun: async () => {
+        try {
+          await projection.value.session.continueRun();
+          return null;
+        } catch (error) {
+          throw new ChordError4("invalid", error instanceof Error ? error.message : "Cannot continue");
+        }
+      },
       withdraw: ({ id }) => projection.value.session.withdraw(id),
       steer: ({ id }) => projection.value.session.steer(id),
       questionGet: async ({ id }) => await projection.value.session.question(id) ?? null,
@@ -30037,18 +30673,20 @@ async function listDrives() {
 // packages/gateway/src/server-services.ts
 var ServerState = local3("neko.server-state", {
   version: 1,
-  input: Type13.Object({}),
+  input: obj13({}, { open: true }),
   members: {
     directory: DirectoryStateSchema,
     workspaces: WorkspaceStateSchema,
     credentials: CredentialStateSchema,
     searchSettings: SearchSettingsStateSchema,
     contextSettings: ContextSettingsStateSchema,
+    codemodeSettings: CodemodeSettingsStateSchema,
     defaultModel: DefaultModelStateSchema,
-    refreshCredentials: method2(Type13.Null(), Type13.Null()),
-    refreshSearchSettings: method2(Type13.Null(), Type13.Null()),
-    refreshContextSettings: method2(Type13.Null(), Type13.Null()),
-    refreshDefaultModel: method2(Type13.Null(), Type13.Null())
+    refreshCredentials: method2(nul6(), nul6()),
+    refreshSearchSettings: method2(nul6(), nul6()),
+    refreshContextSettings: method2(nul6(), nul6()),
+    refreshCodemodeSettings: method2(nul6(), nul6()),
+    refreshDefaultModel: method2(nul6(), nul6())
   }
 });
 async function createNekoServerServices(options) {
@@ -30138,12 +30776,13 @@ async function createNekoServerServices(options) {
       return [spec.id, spec.kind === "model" ? { ...status, enabled: enabled.has(spec.id) } : status];
     })));
   };
-  const [sessions, workspaces, statuses, search, contextSettings0, defaultModel0] = await Promise.all([
+  const [sessions, workspaces, statuses, search, contextSettings0, codemodeSettings0, defaultModel0] = await Promise.all([
     list(),
     runtime.listWorkspaces(),
     readStatuses(),
     runtime.searchSettings(),
     runtime.contextSettings(),
+    runtime.codemodeSettings(),
     runtime.defaultModel()
   ]);
   let mutationTail = Promise.resolve();
@@ -30161,6 +30800,10 @@ async function createNekoServerServices(options) {
       revision: 1,
       ...contextSettings0
     });
+    const codemodeSettings = self2.state("codemodeSettings", CodemodeSettingsStateSchema, {
+      revision: 1,
+      ...codemodeSettings0
+    });
     const defaultModel = self2.state("defaultModel", DefaultModelStateSchema, defaultModel0);
     const refreshContextSettings = async (_input, ctx) => {
       const next = await runtime.contextSettings();
@@ -30169,6 +30812,13 @@ async function createNekoServerServices(options) {
         contextSettings.replace(ctx, { revision: revision + 1, ...next });
       return null;
     };
+    const refreshCodemodeSettings = async (_input, ctx) => {
+      const next = await runtime.codemodeSettings();
+      const { revision, ...current } = codemodeSettings.value;
+      if (JSON.stringify(next) !== JSON.stringify(current))
+        codemodeSettings.replace(ctx, { revision: revision + 1, ...next });
+      return null;
+    };
     const refreshDefaultModel = async (_input, ctx) => {
       const next = await runtime.defaultModel();
       if (JSON.stringify(next) !== JSON.stringify(defaultModel.value))
@@ -30182,7 +30832,7 @@ async function createNekoServerServices(options) {
         searchSettings.replace(ctx, { revision: current.revision + 1, ...next });
       return null;
     };
-    self2.on("directory", { subscribe: runtime.harness.subscribeCommits.bind(runtime.harness) }, async (event, ctx) => {
+    self2.on("directory", { subscribe: (listener) => onCommits(runtime.harness, listener) }, async (event, ctx) => {
       if (!event.changes.some((change) => change.type === "conversation" || change.type === "document" && [
         "app.neko.session-metadata",
         "app.neko.activity",
@@ -30204,6 +30854,7 @@ async function createNekoServerServices(options) {
       credentials,
       searchSettings,
       contextSettings,
+      codemodeSettings,
       defaultModel,
       async refreshCredentials(_input, ctx) {
         credentials.replace(ctx, {
@@ -30214,6 +30865,7 @@ async function createNekoServerServices(options) {
       },
       refreshSearchSettings,
       refreshContextSettings,
+      refreshCodemodeSettings,
       refreshDefaultModel
     };
   }, { lifetime: "host" });
@@ -30280,6 +30932,21 @@ async function createNekoServerServices(options) {
       })
     };
   });
+  host.serve(NekoCodemodeSettings, (_input, _principal, self2) => {
+    const hub = shared(self2);
+    return {
+      variant: "ready",
+      state: hub.codemodeSettings,
+      set: (input, ctx) => serialize(async () => {
+        await runtime.setCodemodeMode(input.mode);
+        return hub.refreshCodemodeSettings(null, ctx);
+      }),
+      reset: (_input, ctx) => serialize(async () => {
+        await runtime.resetCodemodeMode();
+        return hub.refreshCodemodeSettings(null, ctx);
+      })
+    };
+  });
   host.serve(NekoDefaultModel, (_input, _principal, self2) => {
     const hub = shared(self2);
     return {
@@ -30608,6 +31275,8 @@ async function startGateway(options = {}) {
     ...options.apiKey !== undefined ? { apiKey: options.apiKey } : {},
     ...searchProvider !== undefined ? { searchProvider } : {},
     ...fileConfig.context !== undefined ? { contextSettings: fileConfig.context } : {},
+    ...fileConfig.codemode !== undefined ? { codemodeSettings: fileConfig.codemode } : {},
+    ...fileConfig.maxTurns !== undefined ? { maxTurns: fileConfig.maxTurns } : {},
     ...fileConfig.defaultModel !== undefined ? { model: fileConfig.defaultModel } : {},
     ...options.model !== undefined ? { modelOverride: options.model } : {},
     thinkingLevel: options.thinkingLevel ?? fileConfig.thinkingLevel ?? "high",
@@ -30733,7 +31402,7 @@ async function bindGateway(runtime, options) {
     }
   };
   runtime.closed.then(async (result) => {
-    if (result.reason === "failed") {
+    if (result.kind === "failed") {
       options.onError?.(new Error("Gateway storage failed"));
       await gateway.close();
     }