neko-harness 0.5.3 → 0.5.4

package/dist/gateway.js

@@ -16640,6 +16640,11 @@ function resolveCodemodeSettings(config, saved) {
     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";
@@ -16909,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.`);
@@ -16978,6 +16987,66 @@ function validate(config, source) {
     }
   }
 }
+// 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";
 import { homedir as homedir2 } from "os";
@@ -17572,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 ?? []) {
@@ -17730,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,
@@ -17754,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;
@@ -17838,7 +17923,7 @@ ${block.text}`;
   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];
@@ -17916,6 +18001,7 @@ function nestedChangeWraps() {
 }
 
 // packages/core/src/subagents.ts
+import { StringEnum } from "@earendil-works/pi-ai";
 import {
   AssistantEntry,
   configure,
@@ -17926,8 +18012,7 @@ import {
   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 as defineDoc2 } from "@earendil-works/pi-durable";
@@ -18313,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) {
@@ -18511,7 +18597,7 @@ function createSubagentExtension(prepare, discard, guard) {
         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)
@@ -18567,6 +18653,7 @@ function createSubagentExtension(prepare, discard, guard) {
                 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)),
                 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"))
@@ -18711,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);
@@ -19490,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";
@@ -19499,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 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";
@@ -19516,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,
@@ -19524,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)
@@ -19565,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);
@@ -19591,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);
@@ -19767,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) {
@@ -19875,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 {
@@ -20016,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.`);
@@ -20314,7 +20405,7 @@ import {
   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 = [
@@ -20423,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 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,
@@ -20493,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();
@@ -20599,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);
@@ -20659,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);
@@ -20855,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) {
@@ -20921,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",
@@ -21582,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;
@@ -21597,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);
@@ -21727,8 +21824,9 @@ class SessionMetadataManager {
 }
 
 // packages/core/src/todos.ts
+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 { Type as Type6 } from "typebox";
+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,
@@ -21745,23 +21843,23 @@ var TodoReceiptDoc = defineDoc8({
   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);
@@ -21856,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)
@@ -21891,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 = () => {
@@ -21906,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();
@@ -21920,7 +22019,7 @@ class ToolApprovals {
           check();
       });
     } finally {
-      state.dispose();
+      await watch.stop();
     }
   }
   async ensure(parent, candidate, context) {
@@ -22230,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;
@@ -22255,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)
@@ -22286,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)
@@ -22690,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) {
@@ -22731,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])
@@ -22741,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();
         }
@@ -23086,6 +23185,9 @@ var ActivityDoc = defineDoc10({
 });
 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;
@@ -23205,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();
     },
@@ -23251,7 +23353,8 @@ 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));
@@ -23397,9 +23500,7 @@ async function createNekoRuntime(options = {}) {
     if (change)
       await target.configure(change, context);
   };
-  const submitTo = async (target, content, submitOptions, extra) => admit(target.id, async () => {
-    await syncAgent(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 };
@@ -23453,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;
@@ -23471,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",
@@ -23511,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: {} });
     },
@@ -23568,18 +23675,49 @@ async function createNekoRuntime(options = {}) {
     },
     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());
@@ -23610,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);
@@ -23799,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();
     },
@@ -23859,6 +24014,7 @@ async function createNekoRuntime(options = {}) {
           model: effective,
           thinkingLevel: resolveLevel(effective, createOptions?.thinkingLevel ?? options.thinkingLevel ?? "high"),
           cwd: workspace.path,
+          ...turnLimit,
           ...agentChangeFor({ plan: "normal", codemode: mode, role: "main" })
         },
         init: async (tx, id) => {
@@ -24060,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) {
@@ -24073,447 +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 CodemodeViewSchema = Type8.Object({
-  calls: Type8.Array(Type8.Object({
+}, { open: true });
+var skill = obj8({ name: text3, location: text3, body: text3, args: text3 }, { open: true });
+var CodemodeViewSchema = obj8({
+  calls: arr6(obj8({
     id: integer,
-    name: str,
-    args: str,
-    status: Type8.Enum(["running", "ok", "error", "cancelled"]),
-    durationMs: Type8.Union([num, nil]),
+    name: text3,
+    args: text3,
+    status: oneOf2(["running", "ok", "error", "cancelled"]),
+    durationMs: union4([number, nil]),
     error: nullableString
-  })),
+  }, { open: true })),
   omitted: integer,
   fullOutputPath: nullableString
-});
-var call = Type8.Object({
-  callId: str,
-  name: str,
-  summary: str,
+}, { 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),
-  codemode: Type8.Optional(CodemodeViewSchema)
-});
-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)
+  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 SteerResultSchema = Type8.Object({
-  result: Type8.Enum(["steered", "withdrawn", "placed", "settled", "unknown"]),
-  id: Type8.Optional(integer),
-  text: Type8.Optional(str),
-  images: Type8.Optional(integer)
-});
-var TodoItemSchema = 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
-});
-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
+  createdAt: number
+}, { open: true });
+var WorkspaceEntrySchema = obj8({
+  name: text3,
+  path: text3,
+  kind: oneOf2(["file", "directory", "symlink"]),
+  protected: opt8(lit3(true))
 });
-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),
-      codemode: Type8.Optional(CodemodeViewSchema)
-    }),
-    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,
@@ -24521,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)
       }
     }
   }
@@ -24561,175 +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 = Type8.Object({
+var CodemodeSettingsStateSchema = obj8({
   revision: integer,
-  effective: Type8.Object({ mode: Type8.Enum([...CODEMODE_MODES]) }),
-  source: Type8.Enum(["default", "config", "saved"])
-});
+  effective: obj8({ mode: oneOf2([...CODEMODE_MODES]) }, { open: true }),
+  source: oneOf2(["default", "config", "saved"])
+}, { open: true });
 var NekoCodemodeSettings = contract("neko.codemode-settings", {
   version: 1,
-  input: Type8.Object({}, { additionalProperties: false }),
+  input: obj8({}),
   variants: {
     ready: {
       state: { state: CodemodeSettingsStateSchema },
       methods: {
-        set: rpc(Type8.Object({ mode: Type8.Enum([...CODEMODE_MODES]) }, { additionalProperties: false }), nil),
-        reset: rpc(Type8.Object({}, { additionalProperties: false }), nil)
+        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 },
@@ -24740,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) } }
   }
@@ -24821,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" };
@@ -25150,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 }))
       }
     }
   }
@@ -25381,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;
@@ -25527,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.3";
+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,
@@ -25560,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;
@@ -25580,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;
@@ -25605,480 +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 questionStatus2 = Type10.Union([
-  Type10.Literal("pending"),
-  Type10.Literal("answered"),
-  Type10.Literal("skipped"),
-  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 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 MobileCodemodeSchema = Type10.Object({
-  calls: Type10.Array(Type10.Object({
-    id: int,
-    name: str2,
-    args: Type10.String({ maxLength: CODEMODE_VIEW_LIMITS.argsChars }),
-    status: Type10.Union([
-      Type10.Literal("running"),
-      Type10.Literal("ok"),
-      Type10.Literal("error"),
-      Type10.Literal("cancelled")
-    ]),
-    durationMs: opt(Type10.Number()),
-    error: opt(Type10.String({ maxLength: CODEMODE_VIEW_LIMITS.errorChars }))
-  }), { maxItems: CODEMODE_VIEW_LIMITS.maxCalls }),
-  omitted: int,
-  fullOutputPath: opt(str2)
-});
-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),
-  codemode: opt(MobileCodemodeSchema)
-});
-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
@@ -26120,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,
@@ -26177,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
     }))
@@ -26266,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,
@@ -26283,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;
@@ -26319,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 }
   };
 }
@@ -26761,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;
@@ -28897,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";
@@ -29045,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";
@@ -29058,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;
@@ -29157,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;
@@ -29217,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);
       });
@@ -29277,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() {
@@ -29331,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;
@@ -29384,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,
@@ -29392,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")
@@ -29412,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",
@@ -29446,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"] ?? {
@@ -29459,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(() => {
@@ -29500,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();
     }
   };
 }
@@ -29685,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,
@@ -30504,7 +30673,7 @@ 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,
@@ -30513,11 +30682,11 @@ var ServerState = local3("neko.server-state", {
     contextSettings: ContextSettingsStateSchema,
     codemodeSettings: CodemodeSettingsStateSchema,
     defaultModel: DefaultModelStateSchema,
-    refreshCredentials: method2(Type13.Null(), Type13.Null()),
-    refreshSearchSettings: method2(Type13.Null(), Type13.Null()),
-    refreshContextSettings: method2(Type13.Null(), Type13.Null()),
-    refreshCodemodeSettings: 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) {
@@ -30663,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",
@@ -31107,6 +31276,7 @@ async function startGateway(options = {}) {
     ...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",
@@ -31232,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();
     }