neko-harness 0.4.2 → 0.4.4

package/dist/gateway.js

@@ -16503,7 +16503,8 @@ var GATEWAY_USAGE = `\u7528\u6CD5: neko serve [\u9009\u9879]
   --config <dir>       neko.config.json \u67E5\u627E\u8D77\u59CB\u76EE\u5F55\uFF08\u9ED8\u8BA4\u5F53\u524D\u76EE\u5F55\uFF09
   -h, --help           \u663E\u793A\u6B64\u5E2E\u52A9
 
-\u53EF\u901A\u8FC7\u524D\u7AEF\u8BBE\u7F6E\u6216 DEEPSEEK_API_KEY \u914D\u7F6E\u51ED\u636E\u3002`;
+\u53EF\u901A\u8FC7\u524D\u7AEF\u8BBE\u7F6E\u6216 DEEPSEEK_API_KEY / TAVILY_API_KEY \u914D\u7F6E\u51ED\u636E\uFF1B
+\u8054\u7F51\u641C\u7D22\u670D\u52A1\u53EF\u5728\u524D\u7AEF\u8BBE\u7F6E\uFF0C\u6216\u7528\u914D\u7F6E\u6587\u4EF6 webSearch.provider\uFF08tavily / deepseek\uFF0C\u9ED8\u8BA4 tavily\uFF09\u3002`;
 function parseGatewayArgs(argv) {
   let port;
   const options = {};
@@ -16594,13 +16595,186 @@ function parseGatewayArgs(argv) {
 import { randomUUID as randomUUID5 } from "crypto";
 import { mkdir as mkdir6, readFile as readFile7, writeFile as writeFile5 } from "fs/promises";
 import { basename as basename4, dirname as dirname9, join as join13 } from "path";
-import { createHost as createHost3 } from "@earendil-works/chord";
+import { createHost as createHost2 } from "@earendil-works/chord";
 import { BACKGROUND_CONTEXT as BACKGROUND_CONTEXT4 } from "@earendil-works/chord/context";
 
 // packages/core/src/config.ts
 import { existsSync, readFileSync } from "fs";
 import { homedir } from "os";
 import { dirname, join, resolve } from "path";
+
+// packages/core/src/context-settings.ts
+import { DEFAULT_COMPACTION_POLICY } from "@earendil-works/pi-durable";
+
+// packages/core/src/context-limits.ts
+var PERCENT = { kind: "int", min: 1, max: 99 };
+var CONTEXT_FIELD_LIMITS = {
+  compaction: {
+    enabled: { kind: "boolean" },
+    triggerPercent: PERCENT,
+    keepRecentTokens: { kind: "int", min: 1, max: 1e8 }
+  },
+  pruning: {
+    enabled: { kind: "boolean" },
+    triggerPercent: PERCENT,
+    keepRecent: { kind: "int", min: 0, max: 1e5 },
+    minChars: { kind: "int", min: 1, max: 1e8 },
+    minSavePercent: PERCENT
+  }
+};
+var PRUNING_DEFAULTS = {
+  enabled: false,
+  triggerPercent: 35,
+  keepRecent: 10,
+  minChars: 4000,
+  minSavePercent: 5
+};
+
+// packages/core/src/context-settings.ts
+var emptySavedContextSettings = () => ({
+  compaction: { enabled: null, triggerPercent: null, keepRecentTokens: null },
+  pruning: { enabled: null, triggerPercent: null, keepRecent: null, minChars: null, minSavePercent: null }
+});
+var SCHEMA = CONTEXT_FIELD_LIMITS;
+var isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function describe(field) {
+  return field.kind === "boolean" ? "a boolean" : `an integer between ${field.min} and ${field.max}`;
+}
+function validateGroups(value, prefix, allowNull) {
+  if (!isObject(value))
+    throw new Error(`"${prefix}" must be an object.`);
+  const out = {};
+  for (const key of Object.keys(value)) {
+    if (!(key in SCHEMA))
+      throw new Error(`"${prefix}.${key}" is not a known setting.`);
+  }
+  for (const [group, fields] of Object.entries(SCHEMA)) {
+    const given = value[group];
+    if (given === undefined)
+      continue;
+    if (!isObject(given))
+      throw new Error(`"${prefix}.${group}" must be an object.`);
+    const target = {};
+    for (const key of Object.keys(given)) {
+      if (!(key in fields))
+        throw new Error(`"${prefix}.${group}.${key}" is not a known setting.`);
+    }
+    for (const [name, field] of Object.entries(fields)) {
+      const item = given[name];
+      if (item === undefined)
+        continue;
+      if (item === null && allowNull) {
+        target[name] = null;
+        continue;
+      }
+      const ok = field.kind === "boolean" ? typeof item === "boolean" : typeof item === "number" && Number.isInteger(item) && item >= field.min && item <= field.max;
+      if (!ok)
+        throw new Error(`"${prefix}.${group}.${name}" must be ${describe(field)}.`);
+      target[name] = item;
+    }
+    out[group] = target;
+  }
+  return out;
+}
+function parseContextSettings(value, prefix = "context") {
+  return validateGroups(value, prefix, false);
+}
+function parseContextSettingsPatch(value) {
+  return validateGroups(value, "context", true);
+}
+function applyContextPatch(saved, patch) {
+  const next = {
+    compaction: { ...saved.compaction },
+    pruning: { ...saved.pruning }
+  };
+  for (const [key, value] of Object.entries(patch.compaction ?? {})) {
+    if (value !== undefined)
+      next.compaction[key] = value;
+  }
+  for (const [key, value] of Object.entries(patch.pruning ?? {})) {
+    if (value !== undefined)
+      next.pruning[key] = value;
+  }
+  return next;
+}
+function sanitizeSavedContextSettings(raw) {
+  const saved = emptySavedContextSettings();
+  if (!isObject(raw))
+    return saved;
+  for (const [group, fields] of Object.entries(SCHEMA)) {
+    const stored = raw[group];
+    if (!isObject(stored))
+      continue;
+    for (const [name, field] of Object.entries(fields)) {
+      const item = stored[name];
+      const ok = field.kind === "boolean" ? typeof item === "boolean" : typeof item === "number" && Number.isInteger(item) && item >= field.min && item <= field.max;
+      if (ok)
+        saved[group][name] = item;
+    }
+  }
+  return saved;
+}
+function pick(saved, config, fallback) {
+  if (saved !== null && saved !== undefined)
+    return { value: saved, source: "saved" };
+  if (config !== undefined)
+    return { value: config, source: "config" };
+  return { value: fallback, source: "default" };
+}
+function resolveContextSettings(config, saved) {
+  const cEnabled = pick(saved.compaction.enabled, config?.compaction?.enabled, DEFAULT_COMPACTION_POLICY.enabled);
+  const cTrigger = pick(saved.compaction.triggerPercent, config?.compaction?.triggerPercent, null);
+  const cKeep = pick(saved.compaction.keepRecentTokens, config?.compaction?.keepRecentTokens, DEFAULT_COMPACTION_POLICY.keepRecentTokens);
+  const pEnabled = pick(saved.pruning.enabled, config?.pruning?.enabled, PRUNING_DEFAULTS.enabled);
+  const pTrigger = pick(saved.pruning.triggerPercent, config?.pruning?.triggerPercent, PRUNING_DEFAULTS.triggerPercent);
+  const pKeep = pick(saved.pruning.keepRecent, config?.pruning?.keepRecent, PRUNING_DEFAULTS.keepRecent);
+  const pMin = pick(saved.pruning.minChars, config?.pruning?.minChars, PRUNING_DEFAULTS.minChars);
+  const pSave = pick(saved.pruning.minSavePercent, config?.pruning?.minSavePercent, PRUNING_DEFAULTS.minSavePercent);
+  return {
+    effective: {
+      compaction: { enabled: cEnabled.value, triggerPercent: cTrigger.value, keepRecentTokens: cKeep.value },
+      pruning: {
+        enabled: pEnabled.value,
+        triggerPercent: pTrigger.value,
+        keepRecent: pKeep.value,
+        minChars: pMin.value,
+        minSavePercent: pSave.value
+      }
+    },
+    sources: {
+      compaction: { enabled: cEnabled.source, triggerPercent: cTrigger.source, keepRecentTokens: cKeep.source },
+      pruning: {
+        enabled: pEnabled.source,
+        triggerPercent: pTrigger.source,
+        keepRecent: pKeep.source,
+        minChars: pMin.source,
+        minSavePercent: pSave.source
+      }
+    }
+  };
+}
+function compactionPolicy(state, windows) {
+  const { effective, sources } = state;
+  const policy = {};
+  if (sources.compaction.enabled !== "default")
+    policy.enabled = effective.compaction.enabled;
+  if (sources.compaction.keepRecentTokens !== "default")
+    policy.keepRecentTokens = effective.compaction.keepRecentTokens;
+  const percent = effective.compaction.triggerPercent;
+  const window2 = windows.length > 0 ? Math.min(...windows) : 0;
+  if (percent !== null && window2 > 0)
+    policy.reserveTokens = window2 - Math.floor(window2 * percent / 100);
+  return policy;
+}
+
+// packages/core/src/search-providers.ts
+var SEARCH_PROVIDERS = ["tavily", "deepseek"];
+var DEFAULT_SEARCH_PROVIDER = "tavily";
+function isSearchProvider(value) {
+  return typeof value === "string" && SEARCH_PROVIDERS.includes(value);
+}
+
+// packages/core/src/config.ts
 var DEFAULT_SKILL_MARKET_URL = "https://skill.kirineko.tech";
 var NEKO_CONFIG_BASENAME = "neko.config.json";
 function findNekoConfigFile(startDir = process.cwd()) {
@@ -16714,6 +16888,23 @@ function validate(config, source) {
       throw new Error(`neko config: ${source}: "skills.marketUrl" must be a string.`);
     }
   }
+  const webSearch = config.webSearch;
+  if (webSearch !== undefined) {
+    if (typeof webSearch !== "object" || webSearch === null || Array.isArray(webSearch)) {
+      throw new Error(`neko config: ${source}: "webSearch" must be an object.`);
+    }
+    const { provider } = webSearch;
+    if (provider !== undefined && !isSearchProvider(provider)) {
+      throw new Error(`neko config: ${source}: "webSearch.provider" must be one of ${SEARCH_PROVIDERS.map((item) => `"${item}"`).join(", ")}.`);
+    }
+  }
+  if (config.context !== undefined) {
+    try {
+      parseContextSettings(config.context);
+    } catch (error) {
+      throw new Error(`neko config: ${source}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
 }
 // packages/core/src/credentials.ts
 import { chmod, mkdir, open, readFile, rename, unlink } from "fs/promises";
@@ -17065,6 +17256,50 @@ function savedDefaultImagePrompt(content, value) {
 import { defineEntry } from "@earendil-works/pi-durable";
 var NekoInput = defineEntry("app.neko.input");
 
+// packages/core/src/queued.ts
+var QUEUED_PREVIEW_CHARS = 300;
+var textOf = (content) => {
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return "";
+  return content.flatMap((b) => b && b.type === "text" && typeof b.text === "string" ? [b.text] : []).join("");
+};
+var clip = (text) => {
+  const chars = [...text.replace(/\s+/g, " ").trim()];
+  return chars.length > QUEUED_PREVIEW_CHARS ? `${chars.slice(0, QUEUED_PREVIEW_CHARS - 1).join("")}\u2026` : chars.join("");
+};
+function queuedUserInput(raw) {
+  const item = raw;
+  if (item.mode !== "steer" && item.mode !== "followUp")
+    return;
+  if (item.entry?.kind !== NekoInput.kind)
+    return;
+  const data = item.entry.data;
+  if (!data || data.jobReport || data.subagentRoundId)
+    return;
+  const defaultPrompt = Array.isArray(item.content) ? savedDefaultImagePrompt(item.content, data.defaultImagePrompt) : undefined;
+  const content = defaultPrompt && Array.isArray(item.content) ? item.content.slice(1) : item.content;
+  const skill = data.skill ? { name: data.skill.name, args: data.skill.args } : undefined;
+  return {
+    id: item.id,
+    mode: item.mode,
+    text: skill ? `/skill:${skill.name}${skill.args ? ` ${skill.args}` : ""}` : textOf(content),
+    images: data.images?.length ?? 0,
+    ...skill ? { skill } : {}
+  };
+}
+function projectQueued(view) {
+  const items = view.docs["pi.inbox"]?.items ?? [];
+  return items.flatMap((raw) => {
+    const input = queuedUserInput(raw);
+    if (!input)
+      return [];
+    const { text, ...rest } = input;
+    return [{ ...rest, preview: clip(text) }];
+  });
+}
+
 // packages/core/src/workspace.ts
 import { accessSync, constants, realpathSync, statSync } from "fs";
 import { isAbsolute, resolve as resolve2 } from "path";
@@ -17385,6 +17620,7 @@ function projectChatView(view, modelLabel, options = {}) {
     },
     cwd: savedWorkspace(agent?.cwd),
     busy: live.run !== undefined,
+    queued: projectQueued(view),
     status,
     usage: {
       input: usage.input,
@@ -17530,6 +17766,7 @@ import {
   createRegistry,
   defineDoc as defineDoc5,
   Harness,
+  InboxDoc as InboxDoc2,
   LiveDoc as importLiveDoc,
   MemoryStorage,
   UsageDoc as UsageDoc2,
@@ -17728,6 +17965,134 @@ async function readCompaction(harness, storage, id, context) {
   return { taskId: task.id, phase, at: task.endedAt ?? task.startedAt ?? 0 };
 }
 
+// packages/core/src/context-pruning.ts
+var PRUNE_ENTRY_KIND = "app.neko.context-prune";
+var TOKENS_PER_LATIN_CHAR = 0.3;
+var TOKENS_PER_CJK_CHAR = 0.6;
+var CJK = /[\u3000-\u9fff\uac00-\ud7af\uf900-\ufaff\uff00-\uffef]/g;
+function estimateTokens(text) {
+  const cjk = text.match(CJK)?.length ?? 0;
+  return cjk * TOKENS_PER_CJK_CHAR + (text.length - cjk) * TOKENS_PER_LATIN_CHAR;
+}
+var isToolResult = (entry) => {
+  const message = entry.model?.[0];
+  return entry.kind === "pi.tool-result" && message?.role === "toolResult";
+};
+var resultTexts = (message) => message.content.flatMap((block) => block.type === "text" ? [block.text] : []);
+function toolResultChars(message) {
+  return resultTexts(message).reduce((total, text) => total + text.length, 0);
+}
+function toolResultTokens(message) {
+  return resultTexts(message).reduce((total, text) => total + estimateTokens(text), 0);
+}
+function prunedPlaceholder(message, chars) {
+  const { details: _details, ...rest } = message;
+  return {
+    ...rest,
+    content: [
+      {
+        type: "text",
+        text: `[Output of ${message.toolName} omitted from context to save space (${chars} characters). Run the tool again if the content is needed.]`
+      }
+    ]
+  };
+}
+function planPrune(entries, settings) {
+  const replaced = new Set;
+  for (const entry of entries)
+    for (const edit of entry.edits ?? [])
+      replaced.add(edit.target);
+  const results = entries.filter(isToolResult);
+  const candidates = results.slice(0, Math.max(0, results.length - settings.keepRecent));
+  const edits = [];
+  const targets = [];
+  let savedChars = 0;
+  let savedTokens = 0;
+  for (const entry of candidates) {
+    if (replaced.has(entry.id))
+      continue;
+    const message = entry.model[0];
+    const chars = toolResultChars(message);
+    if (chars < settings.minChars)
+      continue;
+    const replacement = prunedPlaceholder(message, chars);
+    edits.push({ target: entry.id, action: "replace", messages: [replacement] });
+    targets.push(entry.id);
+    savedChars += chars;
+    savedTokens += toolResultTokens(message);
+  }
+  return edits.length === 0 ? undefined : { edits, targets, savedChars, savedTokens };
+}
+
+class ContextPruner {
+  #options;
+  #unsubscribe;
+  #tail = Promise.resolve();
+  #closed = false;
+  constructor(options) {
+    this.#options = options;
+    this.#unsubscribe = options.harness.subscribeCommits(({ changes }) => {
+      if (!options.settings().enabled)
+        return;
+      for (const change of changes) {
+        if (change.type !== "entry" || change.value.kind !== "pi.assistant")
+          continue;
+        const message = change.value.model?.[0];
+        if (message?.role !== "assistant" || message.stopReason === "aborted" || message.stopReason === "error")
+          continue;
+        const usage = message.usage;
+        const tokens = usage.totalTokens || usage.input + usage.output + usage.cacheRead + usage.cacheWrite;
+        if (tokens <= 0)
+          continue;
+        const { conversationId, id } = change.value;
+        this.#enqueue(() => this.#evaluate(conversationId, id, tokens));
+      }
+    });
+  }
+  async flush() {
+    await this.#tail;
+  }
+  close() {
+    this.#closed = true;
+    this.#unsubscribe();
+  }
+  #enqueue(work) {
+    if (this.#closed)
+      return;
+    this.#tail = this.#tail.then(work).catch((error) => {
+      if (!this.#closed)
+        this.#options.report(error);
+    });
+  }
+  async#evaluate(conversationId, entryId, tokens) {
+    const { harness, context } = this.#options;
+    const settings = this.#options.settings();
+    if (!settings.enabled)
+      return;
+    const window2 = await this.#options.windowOf(conversationId);
+    if (window2 <= 0 || tokens / window2 * 100 < settings.triggerPercent)
+      return;
+    const conversation = await harness.conversation(conversationId, context);
+    if (!conversation)
+      return;
+    const view = await conversation.context(context);
+    const plan = planPrune(view.entries, settings);
+    if (!plan)
+      return;
+    if (plan.savedTokens / window2 * 100 < settings.minSavePercent)
+      return;
+    await conversation.submit({
+      type: "write",
+      requestId: `prune:${entryId}`,
+      entry: {
+        kind: PRUNE_ENTRY_KIND,
+        data: { targets: [...plan.targets], savedChars: plan.savedChars },
+        edits: plan.edits
+      }
+    }, context);
+  }
+}
+
 // packages/core/src/image-metadata.ts
 import { defineExtension as defineExtension2, hook, ToolTask } from "@earendil-works/pi-durable";
 import sharp from "sharp";
@@ -18387,7 +18752,7 @@ var statusWord = {
   stopped: "stopped",
   lost: "lost"
 };
-var describe = (job) => {
+var describe2 = (job) => {
   const parts = [statusWord[job.status]];
   if (job.exitCode !== null)
     parts.push(`exit code ${job.exitCode}`);
@@ -18402,7 +18767,7 @@ var describe = (job) => {
 function reportText(job, tail) {
   const body = reportTail(tail);
   return [
-    `[Background job ${job.jobId} "${job.title}" ${describe(job)}]`,
+    `[Background job ${job.jobId} "${job.title}" ${describe2(job)}]`,
     `Command: ${job.command}`,
     body ? `Last output (use the job tool's output action with jobId "${job.jobId}" for more):
 ${body}` : "It produced no output."
@@ -18607,7 +18972,7 @@ class JobManager {
             if (kind === "stop") {
               const jobId = stringField(args.jobId, "jobId");
               const job = await this.stop(io, api.conversationId, jobId, "model", context);
-              return this.#text(`Job ${job.jobId} ${describe(job)}.`);
+              return this.#text(`Job ${job.jobId} ${describe2(job)}.`);
             }
             if (kind !== "start")
               throw new Error("Invalid job arguments: action must be start, output, stop or list.");
@@ -18635,7 +19000,7 @@ class JobManager {
   #listText(items) {
     if (!items.length)
       return "No jobs.";
-    return items.map((job) => `${job.jobId} [${describe(job)}] "${job.title}" \u2014 ${job.command}`).join(`
+    return items.map((job) => `${job.jobId} [${describe2(job)}] "${job.title}" \u2014 ${job.command}`).join(`
 `);
   }
   async start(io, conversationId, cwd, args, context) {
@@ -18687,7 +19052,7 @@ class JobManager {
     return this.#render(job, read.text, read.offset, read.dropped);
   }
   #render(job, text, offset, dropped) {
-    const lines = [`Job ${job.jobId} ${describe(job)}.`, `Title: ${job.title}`, `Command: ${job.command}`];
+    const lines = [`Job ${job.jobId} ${describe2(job)}.`, `Title: ${job.title}`, `Command: ${job.command}`];
     if (dropped > 0)
       lines.push(`(${dropped} bytes of earlier output were dropped)`);
     lines.push(text ? `Output (next offset ${offset}):
@@ -19096,6 +19461,14 @@ var createResourceSnapshots = (load, submission) => {
     discard(id, requestId) {
       conversations.get(id)?.pending.delete(requestId);
     },
+    move(id, from, to) {
+      const pending = conversations.get(id)?.pending;
+      const snapshot = pending?.get(from);
+      if (!pending || !snapshot)
+        return;
+      pending.delete(from);
+      pending.set(to, snapshot);
+    },
     forget(id) {
       conversations.delete(id);
     }
@@ -19621,33 +19994,32 @@ async function prepareApprovalConversations(harness, ids, extension, context) {
   }
 }
 
-// packages/core/src/web-search.ts
-import { Type as Type4 } from "@earendil-works/pi-ai";
-import { defineExtension as defineExtension8, defineTool as defineTool4 } from "@earendil-works/pi-durable";
-var SEARCH_URL = "https://api.tavily.com/search";
-var EXTRACT_URL = "https://api.tavily.com/extract";
+// packages/core/src/web-search/http.ts
 var REQUEST_TIMEOUT_MS = 30000;
 var MAX_RESPONSE_BYTES = 2 * 1024 * 1024;
-var MAX_URLS = 20;
-var MAX_RESULTS = 10;
-var DEFAULT_RESULTS = 5;
-var MAX_SOURCE_CHARS = 2000;
-var MAX_TOTAL_CHARS = 12000;
 
-class TavilyError extends Error {
+class WebToolError extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+  }
 }
 function redact(text, key) {
   for (const secret of key ? [key, encodeURIComponent(key)] : [])
     text = text.replaceAll(secret, "[redacted]");
-  return text.replace(/tvly-[a-zA-Z0-9_-]+/g, "[redacted]");
+  return text.replace(/\b(?:tvly|sk)-[a-zA-Z0-9_-]+/g, "[redacted]");
 }
 function record(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-async function readBounded(response, signal) {
+function truncate(text, max) {
+  return text.length > max ? `${text.slice(0, Math.max(0, max - 1))}\u2026` : text;
+}
+async function readBounded(response, signal, label) {
   if (Number(response.headers.get("content-length")) > MAX_RESPONSE_BYTES) {
     await response.body?.cancel();
-    throw new TavilyError("Tavily response exceeds the 2 MiB limit.");
+    throw new WebToolError(`${label} response exceeds the 2 MiB limit.`);
   }
   if (!response.body)
     return "";
@@ -19668,7 +20040,7 @@ async function readBounded(response, signal) {
         return text + decoder.decode();
       size += chunk.value.byteLength;
       if (size > MAX_RESPONSE_BYTES)
-        throw new TavilyError("Tavily response exceeds the 2 MiB limit.");
+        throw new WebToolError(`${label} response exceeds the 2 MiB limit.`);
       text += decoder.decode(chunk.value, { stream: true });
     }
   } finally {
@@ -19677,7 +20049,8 @@ async function readBounded(response, signal) {
     reader.releaseLock();
   }
 }
-async function tavilyPost(url, body, resolveKey, fetchImpl, context) {
+async function postJson(options) {
+  const { label, context } = options;
   let key;
   const signal = AbortSignal.any([
     AbortSignal.timeout(REQUEST_TIMEOUT_MS),
@@ -19685,68 +20058,188 @@ async function tavilyPost(url, body, resolveKey, fetchImpl, context) {
   ]);
   try {
     signal.throwIfAborted();
-    key = await resolveKey();
+    key = await options.resolveKey();
     signal.throwIfAborted();
-    const headers = { "content-type": "application/json" };
-    if (key)
-      headers.authorization = `Bearer ${key}`;
-    else
-      headers["x-tavily-access-mode"] = "keyless";
-    const response = await fetchImpl(url, { method: "POST", headers, body: JSON.stringify(body), signal });
-    const text = redact(await readBounded(response, signal), key);
+    const response = await options.fetchImpl(options.url, {
+      method: "POST",
+      headers: { "content-type": "application/json", ...options.headers(key) },
+      body: JSON.stringify(options.body),
+      signal
+    });
+    const text = redact(await readBounded(response, signal, label), key);
     if (!response.ok)
-      throw new TavilyError(`Tavily request failed (${response.status}): ${truncate(text, 500)}${key ? "" : " (keyless rate limits apply; save a Tavily API key in settings for higher limits)"}`);
-    const data = JSON.parse(text);
-    if (!record(data))
-      throw new TavilyError("Invalid Tavily response.");
-    if (data.error)
-      throw new TavilyError(`Tavily request failed: ${truncate(JSON.stringify(data.error), 500)}`);
-    return data;
+      throw options.httpError(response.status, text, key);
+    return JSON.parse(text);
   } catch (error) {
     if (context.abortSignal?.aborted)
-      throw new TavilyError("Web request cancelled.");
+      throw new WebToolError("Web request cancelled.");
     if (signal.aborted)
-      throw new TavilyError("Tavily request timed out. Please retry.");
-    if (error instanceof TavilyError)
+      throw new WebToolError(`${label} request timed out. Please retry.`);
+    if (error instanceof WebToolError)
       throw error;
-    throw new TavilyError("Tavily request failed. Check the connection and credentials, then retry.");
+    throw new WebToolError(`${label} request failed. Check the connection and credentials, then retry.`);
   }
 }
+
+// packages/core/src/web-search/deepseek.ts
+var SEARCH_URL = "https://api.deepseek.com/v1/tools/search";
+var FETCH_URL = "https://api.deepseek.com/v1/tools/fetch";
+var DEEPSEEK_QUERY_MAX_CHARS = 128;
+var FETCH_CONCURRENCY = 3;
+var MAX_RETRIES = 2;
+var BACKOFF_MS = [250, 750];
+var DEEPSEEK_MISSING_KEY = "DeepSeek API key is not configured. Save one with /login or in the Web settings, or switch the search provider to Tavily.";
+function defaultSleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted)
+      return reject(signal.reason);
+    const timer = setTimeout(resolve, ms);
+    signal?.addEventListener("abort", () => {
+      clearTimeout(timer);
+      reject(signal.reason);
+    }, { once: true });
+  });
+}
+function apiMessage(text) {
+  try {
+    const data = JSON.parse(text);
+    if (record(data) && record(data.error) && typeof data.error.message === "string")
+      return truncate(data.error.message, 300);
+  } catch {}
+  return truncate(text, 300);
+}
+function httpError(status, text) {
+  const guidance = "Check the key in /login or the Web settings, or switch the search provider.";
+  if (status === 401)
+    return new WebToolError(`DeepSeek API key is missing or invalid. ${guidance}`, status);
+  if (status === 402)
+    return new WebToolError("DeepSeek account balance is insufficient. Recharge, or switch the search provider to Tavily.", status);
+  if (status === 403)
+    return new WebToolError("DeepSeek blocked this request by its security policy.", status);
+  if (status === 404)
+    return new WebToolError("DeepSeek could not fetch a usable page for this URL.", status);
+  if (status === 429)
+    return new WebToolError("DeepSeek rate limit reached. Retry shortly.", status);
+  if (status === 408 || status >= 500)
+    return new WebToolError(`DeepSeek service error (${status}). Retry shortly.`, status);
+  return new WebToolError(`DeepSeek request failed (${status}): ${apiMessage(text)}`, status);
+}
+var retryable = (status) => status !== undefined && (status === 429 || status === 408 || status >= 500);
+var wholeCall = (status) => status === 401 || status === 402;
+function dateOnly(value) {
+  return typeof value === "string" && /^\d{4}-\d{2}-\d{2}/.test(value) ? value.slice(0, 10) : undefined;
+}
+function createDeepseekProvider(resolveKey, fetchImpl = fetch, options = {}) {
+  const sleep = options.sleep ?? defaultSleep;
+  const requireKey = async () => {
+    const key = await resolveKey();
+    if (!key)
+      throw new WebToolError(DEEPSEEK_MISSING_KEY);
+    return key;
+  };
+  const post = (url, body, context) => postJson({
+    label: "DeepSeek",
+    url,
+    body,
+    fetchImpl,
+    context,
+    resolveKey: requireKey,
+    headers: (key) => ({ authorization: `Bearer ${key}` }),
+    httpError
+  });
+  return {
+    id: "deepseek",
+    async search(query, limit, context) {
+      if (!query.trim())
+        throw new WebToolError("Provide a non-empty query.");
+      if ([...query].length > DEEPSEEK_QUERY_MAX_CHARS)
+        throw new WebToolError(`DeepSeek search queries are limited to ${DEEPSEEK_QUERY_MAX_CHARS} characters. Shorten the query and retry.`);
+      await requireKey();
+      const data = await post(SEARCH_URL, { query, count: limit, need_content: false }, context);
+      if (!record(data) || !Array.isArray(data.results) || !data.results.every(record))
+        throw new WebToolError("Invalid DeepSeek response.");
+      return data.results.slice(0, limit).map((item) => {
+        const date = dateOnly(item.date);
+        return {
+          title: String(item.title ?? "(untitled)"),
+          url: String(item.url ?? ""),
+          text: String(item.summary || item.snippet || ""),
+          ...date ? { date } : {}
+        };
+      });
+    },
+    async extract(urls, context) {
+      await requireKey();
+      const outcomes = new Array(urls.length);
+      let next = 0;
+      let fatal;
+      const fetchOne = async (url) => {
+        for (let attempt = 0;; attempt++) {
+          try {
+            const data = await post(FETCH_URL, { url }, context);
+            if (!record(data) || typeof data.content !== "string")
+              throw new WebToolError("Invalid DeepSeek response.");
+            return { url, text: data.content };
+          } catch (error) {
+            const failure = error instanceof WebToolError ? error : new WebToolError("DeepSeek request failed.");
+            if (context.abortSignal?.aborted || wholeCall(failure.status))
+              throw failure;
+            if (!retryable(failure.status) || attempt >= MAX_RETRIES)
+              return { url, error: failure.message };
+            try {
+              await sleep(BACKOFF_MS[attempt] ?? 750, context.abortSignal);
+            } catch {
+              throw new WebToolError("Web request cancelled.");
+            }
+          }
+        }
+      };
+      const worker = async () => {
+        while (!fatal) {
+          const index = next++;
+          if (index >= urls.length)
+            return;
+          try {
+            outcomes[index] = await fetchOne(urls[index]);
+          } catch (error) {
+            fatal ??= error instanceof WebToolError ? error : new WebToolError("DeepSeek request failed.");
+          }
+        }
+      };
+      await Promise.all(Array.from({ length: Math.min(FETCH_CONCURRENCY, urls.length) }, worker));
+      if (fatal)
+        throw fatal;
+      return outcomes;
+    }
+  };
+}
+
+// packages/core/src/web-search/index.ts
+import { Type as Type4 } from "@earendil-works/pi-ai";
+import { defineExtension as defineExtension8, defineTool as defineTool4 } from "@earendil-works/pi-durable";
+var MAX_URLS = 20;
+var MAX_RESULTS = 10;
+var DEFAULT_RESULTS = 5;
+var MAX_SOURCE_CHARS = 2000;
+var MAX_TOTAL_CHARS = 12000;
 function toolError(error) {
   return {
     output: [
-      { type: "text", text: error instanceof TavilyError ? error.message : "Web tool failed. Please retry." }
+      { type: "text", text: error instanceof WebToolError ? error.message : "Web tool failed. Please retry." }
     ],
     isError: true
   };
 }
-function truncate(text, max) {
-  return text.length > max ? `${text.slice(0, Math.max(0, max - 1))}\u2026` : text;
-}
-function rows(data, field) {
-  const value = data[field];
-  if (!Array.isArray(value) || !value.every(record))
-    throw new TavilyError("Invalid Tavily response.");
-  return value;
-}
 function content(text) {
   return { output: [{ type: "text", text }] };
 }
-function urlKey(value) {
-  const text = String(value);
-  try {
-    return new URL(text).href;
-  } catch {
-    return text;
-  }
-}
-function createWebSearchTools(resolveKey, fetchImpl = fetch) {
+function createWebSearchTools(resolveProvider) {
   return defineExtension8({
     name: "neko-web-search",
     tools: [
       defineTool4({
         name: "web_search",
-        description: "Search the live web for current or unknown information. Returns ranked sources (title, URL, bounded excerpts). Use only when up-to-date or external information is needed; use web_extract to read a known URL.",
+        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: Type4.Object({
           query: Type4.String({ minLength: 1, maxLength: 4096, description: "The search query" }),
           maxResults: Type4.Optional(Type4.Number({ description: `Maximum number of results (1-${MAX_RESULTS}, default ${DEFAULT_RESULTS})` }))
@@ -19754,18 +20247,19 @@ function createWebSearchTools(resolveKey, fetchImpl = fetch) {
         async execute({ query, maxResults }, _api, context) {
           try {
             if (!query.trim() || query.length > 4096)
-              throw new TavilyError("Provide a non-empty query of at most 4096 characters.");
+              throw new WebToolError("Provide a non-empty query of at most 4096 characters.");
             if (maxResults !== undefined && !Number.isFinite(maxResults))
-              throw new TavilyError("maxResults must be a finite number.");
+              throw new WebToolError("maxResults must be a finite number.");
             const limit = Math.max(1, Math.min(MAX_RESULTS, Math.trunc(maxResults ?? DEFAULT_RESULTS)));
-            const data = await tavilyPost(SEARCH_URL, { query, max_results: limit, search_depth: "basic" }, resolveKey, fetchImpl, context);
-            const results = rows(data, "results").slice(0, limit);
+            const provider = await resolveProvider(context);
+            const results = (await provider.search(query, limit, context)).slice(0, limit);
             const budget = Math.floor(MAX_TOTAL_CHARS / Math.max(1, results.length)) - 2;
             return content(results.map((item, index) => {
-              const header = `${index + 1}. ${truncate(String(item.title ?? "(untitled)"), 200)}
-${truncate(String(item.url ?? ""), 300)}
-`;
-              return header + truncate(String(item.content ?? ""), Math.min(MAX_SOURCE_CHARS, budget - header.length));
+              const header = `${index + 1}. ${truncate(item.title, 200)}
+${truncate(item.url, 300)}
+${item.date ? `Published: ${item.date}
+` : ""}`;
+              return header + truncate(item.text, Math.min(MAX_SOURCE_CHARS, budget - header.length));
             }).join(`
 
 `) || "No results.");
@@ -19787,28 +20281,25 @@ ${truncate(String(item.url ?? ""), 300)}
         async execute({ urls }, _api, context) {
           try {
             if (!urls.length || urls.length > MAX_URLS)
-              throw new TavilyError(`Provide between 1 and ${MAX_URLS} URLs.`);
+              throw new WebToolError(`Provide between 1 and ${MAX_URLS} URLs.`);
             for (const url of urls) {
               let parsed;
               try {
                 parsed = new URL(url);
               } catch {
-                throw new TavilyError("Provide valid http(s) URLs.");
+                throw new WebToolError("Provide valid http(s) URLs.");
               }
               if (url.length > 2048 || !["http:", "https:"].includes(parsed.protocol) || parsed.username || parsed.password)
-                throw new TavilyError("Provide http(s) URLs of at most 2048 characters without embedded credentials.");
+                throw new WebToolError("Provide http(s) URLs of at most 2048 characters without embedded credentials.");
             }
-            const data = await tavilyPost(EXTRACT_URL, { urls, format: "markdown" }, resolveKey, fetchImpl, context);
-            const results = rows(data, "results");
-            const failed = data.failed_results === undefined ? [] : rows(data, "failed_results");
-            const byUrl = (items) => new Map(items.map((item) => [urlKey(item.url), item]));
-            const successes = byUrl(results), failures = byUrl(failed);
+            const provider = await resolveProvider(context);
+            const outcomes = await provider.extract(urls, context);
             const budget = Math.floor(MAX_TOTAL_CHARS / urls.length) - 2;
             return content(urls.map((url, index) => {
               const header = `## ${index + 1}. ${truncate(url, 300)}
 `;
-              const result = successes.get(urlKey(url)), failure = failures.get(urlKey(url));
-              const text = result ? String(result.raw_content ?? "") : `Extraction failed: ${String(failure?.error ?? "No result returned for this URL")}`;
+              const outcome = outcomes[index];
+              const text = outcome && "text" in outcome ? outcome.text : `Extraction failed: ${outcome?.error ?? "No result returned for this URL"}`;
               return header + truncate(text, Math.min(MAX_SOURCE_CHARS, budget - header.length));
             }).join(`
 
@@ -19822,6 +20313,69 @@ ${truncate(String(item.url ?? ""), 300)}
   });
 }
 
+// packages/core/src/web-search/tavily.ts
+var SEARCH_URL2 = "https://api.tavily.com/search";
+var EXTRACT_URL = "https://api.tavily.com/extract";
+function rows(data, field) {
+  const value = data[field];
+  if (!Array.isArray(value) || !value.every(record))
+    throw new WebToolError("Invalid Tavily response.");
+  return value;
+}
+function urlKey(value) {
+  const text = String(value);
+  try {
+    return new URL(text).href;
+  } catch {
+    return text;
+  }
+}
+function createTavilyProvider(resolveKey, fetchImpl = fetch) {
+  const post = async (url, body, context) => {
+    const data = await postJson({
+      label: "Tavily",
+      url,
+      body,
+      fetchImpl,
+      context,
+      resolveKey,
+      headers: (key) => key ? { authorization: `Bearer ${key}` } : { "x-tavily-access-mode": "keyless" },
+      httpError: (status, text, key) => new WebToolError(`Tavily request failed (${status}): ${truncate(text, 500)}${key ? "" : " (keyless rate limits apply; save a Tavily API key in settings for higher limits)"}`, status)
+    });
+    if (!record(data))
+      throw new WebToolError("Invalid Tavily response.");
+    if (data.error)
+      throw new WebToolError(`Tavily request failed: ${truncate(JSON.stringify(data.error), 500)}`);
+    return data;
+  };
+  return {
+    id: "tavily",
+    async search(query, limit, context) {
+      const data = await post(SEARCH_URL2, { query, max_results: limit, search_depth: "basic" }, context);
+      return rows(data, "results").slice(0, limit).map((item) => ({
+        title: String(item.title ?? "(untitled)"),
+        url: String(item.url ?? ""),
+        text: String(item.content ?? "")
+      }));
+    },
+    async extract(urls, context) {
+      const data = await post(EXTRACT_URL, { urls, format: "markdown" }, context);
+      const results = rows(data, "results");
+      const failed = data.failed_results === undefined ? [] : rows(data, "failed_results");
+      const byUrl = (items) => new Map(items.map((item) => [urlKey(item.url), item]));
+      const successes = byUrl(results);
+      const failures = byUrl(failed);
+      return urls.map((url) => {
+        const result = successes.get(urlKey(url));
+        if (result)
+          return { url, text: String(result.raw_content ?? "") };
+        const failure = failures.get(urlKey(url));
+        return { url, error: String(failure?.error ?? "No result returned for this URL") };
+      });
+    }
+  };
+}
+
 // packages/core/src/workspace-files.ts
 import { realpath as realpath2, stat } from "fs/promises";
 import { basename as basename2, isAbsolute as isAbsolute2, relative, resolve as resolve3, sep } from "path";
@@ -20201,6 +20755,22 @@ var WorkspacesDoc = defineDoc5({
   fork: "initial",
   initial: () => ({ items: [] })
 });
+var SearchSettingsDoc = defineDoc5({
+  kind: "app.neko.search-settings",
+  version: 1,
+  scope: "conversation",
+  history: "latest",
+  fork: "initial",
+  initial: () => ({ provider: null })
+});
+var ContextSettingsDoc = defineDoc5({
+  kind: "app.neko.context-settings",
+  version: 1,
+  scope: "conversation",
+  history: "latest",
+  fork: "initial",
+  initial: emptySavedContextSettings
+});
 var ActivityDoc = defineDoc5({
   kind: "app.neko.activity",
   version: 1,
@@ -20247,12 +20817,21 @@ async function createNekoRuntime(options = {}) {
   registry.install(createCodingTools({ images: await createNodePhotonImages() }));
   registry.install(ImageDetails);
   registry.install(AgentFileSearch);
-  registry.install(createWebSearchTools(async () => {
+  const tavily = createTavilyProvider(async () => {
     const saved = await effectiveCredentials.read("tavily");
     if (saved?.type === "api_key" && saved.key)
       return saved.key;
     return process.env.TAVILY_API_KEY || undefined;
-  }));
+  });
+  const deepseekApiKey = async () => {
+    const saved = await effectiveCredentials.read("deepseek");
+    if (saved?.type === "api_key" && saved.key)
+      return saved.key;
+    return process.env.DEEPSEEK_API_KEY || undefined;
+  };
+  const deepseek = createDeepseekProvider(deepseekApiKey);
+  let searchProvider = options.searchProvider ?? DEFAULT_SEARCH_PROVIDER;
+  registry.install(createWebSearchTools(async () => searchProvider === "deepseek" ? deepseek : tavily));
   const loadResources = createResourceLoader(options.promptHome);
   const resourceSnapshots = createResourceSnapshots(loadResources, (id, requestId) => storage.submissionByRequest(id, requestId, context));
   registry.install(createNekoPrompt(resourceSnapshots.current));
@@ -20266,9 +20845,16 @@ async function createNekoRuntime(options = {}) {
   let approvals;
   const approvalExtension = createApprovalExtension(() => approvals);
   registry.install(approvalExtension);
+  let savedContext = emptySavedContextSettings();
+  let contextState = resolveContextSettings(options.contextSettings, savedContext);
   const harness = await Harness.open(storage, {
     models,
     registry,
+    settings: {
+      get compaction() {
+        return compactionPolicy(contextState, models.getModels().map((model) => model.contextWindow));
+      }
+    },
     onReport: options.onReport,
     conversationCreated: async (tx, record) => {
       (await tx.doc(SessionMetadataDoc, record.id)).createdAt = Date.now();
@@ -20310,6 +20896,21 @@ async function createNekoRuntime(options = {}) {
       cwd: defaultCwd
     }
   });
+  const savedSearch = (await harness.snapshot(SearchSettingsDoc, conversation.id, context))?.provider;
+  if (isSearchProvider(savedSearch))
+    searchProvider = savedSearch;
+  savedContext = sanitizeSavedContextSettings(await harness.snapshot(ContextSettingsDoc, conversation.id, context));
+  contextState = resolveContextSettings(options.contextSettings, savedContext);
+  const persistContext = async (next) => {
+    await harness.commit(async (tx) => {
+      const doc = await tx.doc(ContextSettingsDoc, conversation.id);
+      doc.compaction = next.compaction;
+      doc.pruning = next.pruning;
+    }, context);
+    savedContext = next;
+    contextState = resolveContextSettings(options.contextSettings, savedContext);
+    return contextState;
+  };
   const registerWorkspace = async (path) => {
     await harness.commit(async (tx) => {
       const doc = await tx.doc(WorkspacesDoc, conversation.id);
@@ -20346,10 +20947,22 @@ async function createNekoRuntime(options = {}) {
   for (const record of existing)
     if (!record.owner && !(await harness.snapshot(ArchivedDoc, record.id, context))?.archived)
       await metadata.restore(record.id);
+  const pruner = new ContextPruner({
+    harness,
+    context,
+    settings: () => contextState.effective.pruning,
+    windowOf: async (id) => {
+      const target = await harness.conversation(id, context);
+      const model = (await target?.agent(context))?.model;
+      return model && models.getModel(model.provider, model.modelId)?.contextWindow || 0;
+    },
+    report: (error) => options.onReport?.(error)
+  });
   let closing;
   const cleanup = () => {
     if (!closing)
       closing = (async () => {
+        pruner.close();
         jobs.shutdown();
         await workspaceFiles.close();
         await metadata.close();
@@ -20506,6 +21119,57 @@ async function createNekoRuntime(options = {}) {
     },
     abort() {
       return target.abort(context);
+    },
+    async withdraw(submissionId) {
+      const id = submissionId;
+      const inbox = await harness.snapshot(InboxDoc2, target.id, context);
+      const item = inbox?.items.find((i) => i.id === id);
+      const input = item ? queuedUserInput(item) : undefined;
+      if (item && !input)
+        return { result: "unknown" };
+      const requestId = (await (await harness.submission(id, context))?.status(context))?.requestId;
+      const outcome = await harness.abortSubmission(id, context, target.id);
+      if (outcome !== "aborted") {
+        return { result: outcome === "already_placed" ? "placed" : outcome === "settled" ? "settled" : "unknown" };
+      }
+      if (requestId !== undefined)
+        resourceSnapshots.discard(target.id, requestId);
+      await metadata.reconcile(target.id);
+      return { result: "withdrawn", ...input ? { text: input.text, images: input.images } : {} };
+    },
+    async steer(submissionId) {
+      const id = submissionId;
+      const inbox = await harness.snapshot(InboxDoc2, target.id, context);
+      const item = inbox?.items.find((i) => i.id === id);
+      const input = item ? queuedUserInput(item) : undefined;
+      if (item && (!input || item.mode === "write"))
+        return { result: "unknown" };
+      if (item && input?.mode === "steer")
+        return { result: "steered", id: submissionId };
+      const requestId = (await (await harness.submission(id, context))?.status(context))?.requestId;
+      const outcome = await harness.abortSubmission(id, context, target.id);
+      if (outcome !== "aborted" || !item || !input) {
+        return { result: outcome === "already_placed" ? "placed" : outcome === "settled" ? "settled" : "unknown" };
+      }
+      const steerRequestId = requestId !== undefined ? `steer:${requestId}` : crypto.randomUUID();
+      try {
+        const next = await target.submit({
+          type: "input",
+          content: item.content,
+          ...item.entry ? { entry: item.entry } : {},
+          requestId: steerRequestId,
+          whenBusy: "steer"
+        }, context);
+        if (requestId !== undefined)
+          resourceSnapshots.move(target.id, requestId, steerRequestId);
+        await metadata.reconcile(target.id);
+        return { result: "steered", id: next.id };
+      } catch {
+        if (requestId !== undefined)
+          resourceSnapshots.discard(target.id, requestId);
+        await metadata.reconcile(target.id);
+        return { result: "withdrawn", text: input.text, images: input.images };
+      }
     }
   });
   const rootSession = makeSession(conversation);
@@ -20716,8 +21380,28 @@ async function createNekoRuntime(options = {}) {
         source: runtimeKeys.has(spec.id) ? "runtime" : savedConfigured ? "saved" : environmentConfigured ? "environment" : spec.keyless ? "keyless" : "none"
       };
     },
-    async saveCredential(provider, key) {
-      const spec = credentialProvider(provider);
+    async contextSettings() {
+      return contextState;
+    },
+    async setContextSettings(patch) {
+      return persistContext(applyContextPatch(savedContext, parseContextSettingsPatch(patch)));
+    },
+    async resetContextSettings() {
+      return persistContext(emptySavedContextSettings());
+    },
+    async searchSettings() {
+      return { selected: searchProvider };
+    },
+    async setSearchProvider(provider) {
+      if (!isSearchProvider(provider))
+        throw new Error("Unknown search provider.");
+      await harness.commit(async (tx) => {
+        (await tx.doc(SearchSettingsDoc, conversation.id)).provider = provider;
+      }, context);
+      searchProvider = provider;
+    },
+    async saveCredential(provider, key) {
+      const spec = credentialProvider(provider);
       if (typeof key !== "string" || !key.trim() || key.length > 4096 || Array.from(key).some((char) => char.charCodeAt(0) < 32))
         throw new Error("Enter a valid API key.");
       try {
@@ -20789,506 +21473,34 @@ async function createNekoRuntime(options = {}) {
     }
   };
 }
-// packages/gateway/src/identity.ts
-function isServerId(value) {
-  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
-}
-
-// packages/gateway/src/mobile/admin.ts
-import { createHash, timingSafeEqual } from "crypto";
-import { ChordError, method, remote } from "@earendil-works/chord";
+// packages/gateway/src/contract.ts
+import { hostNamed, method, remote } from "@earendil-works/chord";
 import { Type as Type5 } from "typebox";
-
-// packages/gateway/src/mobile/store.ts
-import { randomBytes } from "crypto";
-import { chmod as chmod2, mkdir as mkdir2, readFile as readFile4, rename as rename2, rm, writeFile } from "fs/promises";
-import { join as join6 } from "path";
-var MOBILE_STATE_FORMAT_VERSION = 1;
-var MOBILE_DEFAULT_PORT = 8323;
-var MOBILE_ADMIN_TOKEN_BYTES = 32;
-var POSIX = process.platform !== "win32";
-var ADMIN_TOKEN_PATTERN = /^[A-Za-z0-9_-]{43}$/;
-var CREDENTIAL_HASH_PATTERN = /^[0-9a-fA-F]{64}$/;
-function defaultState() {
-  return {
-    formatVersion: MOBILE_STATE_FORMAT_VERSION,
-    enabled: false,
-    address: null,
-    port: MOBILE_DEFAULT_PORT,
-    devices: [],
-    receipts: [],
-    lastConnectedAddress: null
-  };
-}
-function freezeState(state) {
-  for (const device of state.devices)
-    Object.freeze(device);
-  Object.freeze(state.devices);
-  for (const receipt of state.receipts)
-    Object.freeze(receipt);
-  Object.freeze(state.receipts);
-  return Object.freeze(state);
-}
-function isNotFound(error) {
-  return error?.code === "ENOENT";
-}
-function invalidState(statePath, detail) {
-  return new Error(`Invalid mobile state file ${statePath}: ${detail}`);
-}
-function readString(value, what, statePath) {
-  if (typeof value !== "string")
-    throw invalidState(statePath, `${what} must be a string`);
-  return value;
-}
-function readNonEmptyString(value, what, statePath) {
-  const text = readString(value, what, statePath);
-  if (text === "")
-    throw invalidState(statePath, `${what} must be a non-empty string`);
-  return text;
-}
-function readCredentialHash(value, what, statePath) {
-  const text = readString(value, what, statePath);
-  if (!CREDENTIAL_HASH_PATTERN.test(text))
-    throw invalidState(statePath, `${what} must be a 64-character hex string`);
-  return text;
-}
-function readRevision(value, what, statePath) {
-  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0)
-    throw invalidState(statePath, `${what} must be a non-negative integer`);
-  return value;
-}
-function readTimestamp(value, what, statePath) {
-  if (typeof value !== "number" || !Number.isFinite(value))
-    throw invalidState(statePath, `${what} must be a finite number`);
-  return value;
-}
-function parseDevice(raw, index, statePath) {
-  const what = `devices[${index}]`;
-  if (typeof raw !== "object" || raw === null)
-    throw invalidState(statePath, `${what} must be an object`);
-  const record = raw;
-  return {
-    deviceId: readNonEmptyString(record.deviceId, `${what}.deviceId`, statePath),
-    name: readString(record.name, `${what}.name`, statePath),
-    credentialHash: readCredentialHash(record.credentialHash, `${what}.credentialHash`, statePath),
-    grantRevision: readRevision(record.grantRevision, `${what}.grantRevision`, statePath),
-    pairedAt: readTimestamp(record.pairedAt, `${what}.pairedAt`, statePath),
-    lastSeenAt: readTimestamp(record.lastSeenAt, `${what}.lastSeenAt`, statePath)
-  };
-}
-function parseReceipt(raw, index, statePath) {
-  const what = `receipts[${index}]`;
-  if (typeof raw !== "object" || raw === null)
-    throw invalidState(statePath, `${what} must be an object`);
-  const record = raw;
-  return {
-    pairRequestId: readNonEmptyString(record.pairRequestId, `${what}.pairRequestId`, statePath),
-    deviceId: readNonEmptyString(record.deviceId, `${what}.deviceId`, statePath),
-    credentialHash: readCredentialHash(record.credentialHash, `${what}.credentialHash`, statePath),
-    grantRevision: readRevision(record.grantRevision, `${what}.grantRevision`, statePath),
-    expiresAt: readTimestamp(record.expiresAt, `${what}.expiresAt`, statePath)
-  };
-}
-function parseState(raw, statePath) {
-  if (typeof raw !== "object" || raw === null)
-    throw invalidState(statePath, "root must be an object");
-  const record = raw;
-  if (record.formatVersion !== MOBILE_STATE_FORMAT_VERSION)
-    throw invalidState(statePath, `unsupported formatVersion (expected ${MOBILE_STATE_FORMAT_VERSION})`);
-  if (typeof record.enabled !== "boolean")
-    throw invalidState(statePath, "enabled must be a boolean");
-  if (record.address !== null && typeof record.address !== "string")
-    throw invalidState(statePath, "address must be a string or null");
-  const port = record.port;
-  if (typeof port !== "number" || !Number.isInteger(port) || port < 1 || port > 65535)
-    throw invalidState(statePath, "port must be an integer between 1 and 65535");
-  if (!Array.isArray(record.devices))
-    throw invalidState(statePath, "devices must be an array");
-  if (!Array.isArray(record.receipts))
-    throw invalidState(statePath, "receipts must be an array");
-  const lastConnectedAddress = record.lastConnectedAddress === undefined || record.lastConnectedAddress === null ? null : readString(record.lastConnectedAddress, "lastConnectedAddress", statePath);
-  return {
-    formatVersion: MOBILE_STATE_FORMAT_VERSION,
-    enabled: record.enabled,
-    address: record.address,
-    port,
-    devices: record.devices.map((device, index) => parseDevice(device, index, statePath)),
-    receipts: record.receipts.map((receipt, index) => parseReceipt(receipt, index, statePath)),
-    lastConnectedAddress
-  };
-}
-function assertPort(port) {
-  if (!Number.isInteger(port) || port < 1 || port > 65535)
-    throw new Error("port must be an integer between 1 and 65535");
-  return port;
-}
-var tempCounter = 0;
-async function writeFileAtomic(filePath, contents, mode) {
-  const tempPath = `${filePath}.tmp-${process.pid}-${++tempCounter}`;
-  try {
-    await writeFile(tempPath, contents, { mode });
-    if (POSIX)
-      await chmod2(tempPath, mode);
-    await rename2(tempPath, filePath);
-  } finally {
-    await rm(tempPath, { force: true });
-  }
-}
-async function writeSecretFile(filePath, contents) {
-  await writeFileAtomic(filePath, contents, 384);
-}
-async function readSecretFile(filePath) {
-  try {
-    return await readFile4(filePath, "utf8");
-  } catch (error) {
-    if (isNotFound(error))
-      return;
-    throw error;
-  }
-}
-async function loadState(statePath) {
-  let raw;
-  try {
-    raw = await readFile4(statePath, "utf8");
-  } catch (error) {
-    if (isNotFound(error))
-      return freezeState(defaultState());
-    throw error;
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    throw invalidState(statePath, "not valid JSON");
-  }
-  return freezeState(parseState(parsed, statePath));
-}
-
-class MobileStore {
-  mobileDir;
-  tlsDir;
-  statePath;
-  adminTokenPath;
-  current;
-  queue = Promise.resolve();
-  constructor(mobileDir, initial) {
-    this.mobileDir = mobileDir;
-    this.tlsDir = join6(mobileDir, "tls");
-    this.statePath = join6(mobileDir, "state.json");
-    this.adminTokenPath = join6(mobileDir, "admin-token");
-    this.current = initial;
-  }
-  static async open(nekoDir) {
-    const mobileDir = join6(nekoDir, "mobile");
-    const tlsDir = join6(mobileDir, "tls");
-    await mkdir2(mobileDir, { recursive: true, mode: 448 });
-    await mkdir2(tlsDir, { recursive: true, mode: 448 });
-    if (POSIX) {
-      await chmod2(mobileDir, 448);
-      await chmod2(tlsDir, 448);
-    }
-    return new MobileStore(mobileDir, await loadState(join6(mobileDir, "state.json")));
-  }
-  getState() {
-    return this.current;
-  }
-  updateConfig(patch) {
-    return this.mutate((state) => ({
-      ...state,
-      ...patch.enabled !== undefined ? { enabled: patch.enabled } : {},
-      ...patch.address !== undefined ? { address: patch.address } : {},
-      ...patch.port !== undefined ? { port: assertPort(patch.port) } : {}
-    }));
-  }
-  upsertDevice(device) {
-    return this.mutate((state) => ({
-      ...state,
-      devices: state.devices.some((d) => d.deviceId === device.deviceId) ? state.devices.map((d) => d.deviceId === device.deviceId ? device : d) : [...state.devices, device]
-    }));
-  }
-  removeDevice(deviceId) {
-    return this.mutate((state) => ({
-      ...state,
-      devices: state.devices.filter((d) => d.deviceId !== deviceId)
-    }));
-  }
-  completePairing(input) {
-    return this.mutate((state) => {
-      const now = Date.now();
-      const existing = state.devices.find((d) => d.deviceId === input.deviceId);
-      const grantRevision = existing === undefined ? 1 : existing.grantRevision + 1;
-      const device = {
-        deviceId: input.deviceId,
-        name: input.name,
-        credentialHash: input.credentialHash,
-        grantRevision,
-        pairedAt: input.pairedAt,
-        lastSeenAt: input.pairedAt
-      };
-      const receipt = {
-        pairRequestId: input.pairRequestId,
-        deviceId: input.deviceId,
-        credentialHash: input.credentialHash,
-        grantRevision,
-        expiresAt: input.receiptExpiresAt
-      };
-      return {
-        ...state,
-        devices: existing === undefined ? [...state.devices, device] : state.devices.map((d) => d.deviceId === input.deviceId ? device : d),
-        receipts: [
-          ...state.receipts.filter((r) => r.expiresAt > now && r.pairRequestId !== input.pairRequestId),
-          receipt
-        ]
-      };
-    });
-  }
-  putReceipt(receipt) {
-    return this.mutate((state) => ({
-      ...state,
-      receipts: state.receipts.some((r) => r.pairRequestId === receipt.pairRequestId) ? state.receipts.map((r) => r.pairRequestId === receipt.pairRequestId ? receipt : r) : [...state.receipts, receipt]
-    }));
-  }
-  removeReceipt(pairRequestId) {
-    return this.mutate((state) => ({
-      ...state,
-      receipts: state.receipts.filter((r) => r.pairRequestId !== pairRequestId)
-    }));
-  }
-  touchDevice(deviceId, lastSeenAt) {
-    return this.mutate((state) => {
-      const existing = state.devices.find((d) => d.deviceId === deviceId);
-      if (existing === undefined)
-        return state;
-      return {
-        ...state,
-        devices: state.devices.map((d) => d.deviceId === deviceId ? { ...d, lastSeenAt } : d)
-      };
-    });
-  }
-  rememberConnectedAddress(address) {
-    if (this.current.lastConnectedAddress === address)
-      return Promise.resolve(this.current);
-    return this.mutate((state) => ({ ...state, lastConnectedAddress: address }));
-  }
-  clearMobileAuthorizations() {
-    return this.mutate((state) => ({ ...state, devices: [], receipts: [] }));
-  }
-  ensureAdminToken() {
-    return this.enqueue(async () => {
-      const existing = await readSecretFile(this.adminTokenPath);
-      if (existing !== undefined) {
-        const token = existing.trim();
-        if (ADMIN_TOKEN_PATTERN.test(token))
-          return token;
-        throw new Error(`Invalid mobile admin token file ${this.adminTokenPath}: expected a base64url token`);
-      }
-      const token = randomBytes(MOBILE_ADMIN_TOKEN_BYTES).toString("base64url");
-      await writeSecretFile(this.adminTokenPath, `${token}
-`);
-      return token;
-    });
-  }
-  mutate(recipe) {
-    return this.enqueue(async () => {
-      const next = freezeState(recipe(this.current));
-      await writeFileAtomic(this.statePath, `${JSON.stringify(next, null, "\t")}
-`, 384);
-      this.current = next;
-      return next;
-    });
-  }
-  enqueue(task) {
-    const run = this.queue.then(task);
-    this.queue = run.then(() => {
-      return;
-    }, () => {
-      return;
-    });
-    return run;
-  }
-}
-
-// packages/gateway/src/mobile/admin.ts
-function contract(name, def) {
-  const variants = Object.fromEntries(Object.entries(def.variants).map(([key, value]) => [
-    key,
-    {
-      methods: Object.fromEntries(Object.entries(value.methods ?? {}).map(([member, [args, result]]) => [member, method(args, result)]))
-    }
-  ]));
-  return remote(name, { ...def, variants });
-}
-var listenerStateSchema = Type5.Union([
-  Type5.Object({ status: Type5.Literal("disabled") }),
-  Type5.Object({ status: Type5.Literal("starting") }),
-  Type5.Object({
-    status: Type5.Literal("listening"),
-    address: Type5.String(),
-    port: Type5.Integer({ minimum: 1, maximum: 65535 }),
-    bindAddress: Type5.Optional(Type5.String()),
-    mode: Type5.Optional(Type5.Union([Type5.Literal("direct"), Type5.Literal("wsl-relay")]))
-  }),
-  Type5.Object({ status: Type5.Literal("error"), error: Type5.String() }),
-  Type5.Object({ status: Type5.Literal("stopping") })
-]);
-var adminDeviceSchema = Type5.Object({
-  deviceId: Type5.String(),
-  name: Type5.String(),
-  pairedAt: Type5.Integer(),
-  lastSeenAt: Type5.Integer(),
-  online: Type5.Boolean()
-});
-var NekoMobileAdmin = contract("neko.mobile-admin", {
-  version: 1,
-  input: Type5.Object({ token: Type5.String() }),
-  variants: {
-    admin: {
-      methods: {
-        state: [
-          Type5.Null(),
-          Type5.Object({
-            state: listenerStateSchema,
-            candidates: Type5.Array(Type5.String()),
-            port: Type5.Integer({ minimum: 1, maximum: 65535 }),
-            certificate: Type5.Union([
-              Type5.Object({ fingerprint: Type5.String(), expiresAt: Type5.Integer() }),
-              Type5.Null()
-            ]),
-            devices: Type5.Array(adminDeviceSchema),
-            lastConnectedAddress: Type5.Union([Type5.String(), Type5.Null()]),
-            wsl: Type5.Optional(Type5.Union([
-              Type5.Object({ interop: Type5.Boolean(), error: Type5.Union([Type5.String(), Type5.Null()]) }),
-              Type5.Null()
-            ]))
-          })
-        ],
-        enable: [
-          Type5.Object({
-            address: Type5.String(),
-            port: Type5.Optional(Type5.Integer({ minimum: 1, maximum: 65535 }))
-          }),
-          Type5.Object({
-            status: Type5.Literal("listening"),
-            address: Type5.String(),
-            port: Type5.Integer({ minimum: 1, maximum: 65535 }),
-            bindAddress: Type5.Optional(Type5.String()),
-            mode: Type5.Optional(Type5.Union([Type5.Literal("direct"), Type5.Literal("wsl-relay")]))
-          })
-        ],
-        disable: [Type5.Null(), listenerStateSchema],
-        createPairing: [Type5.Null(), Type5.Object({ pairingText: Type5.String(), expiresAt: Type5.Integer() })],
-        cancelPairing: [Type5.Null(), Type5.Null()],
-        revoke: [
-          Type5.Object({ deviceId: Type5.String({ minLength: 1 }) }),
-          Type5.Object({ revoked: Type5.Boolean() })
-        ],
-        regenerateCertificate: [
-          Type5.Null(),
-          Type5.Object({ fingerprint: Type5.String(), expiresAt: Type5.Integer() })
-        ]
-      }
-    }
-  }
-});
-function isMobilePrincipal(principal) {
-  return typeof principal === "object" && principal !== null && principal.kind === "mobile";
-}
-function digest(value) {
-  return createHash("sha256").update(value, "utf8").digest();
-}
-async function tokenMatches(token, store) {
-  if (store === undefined)
-    return false;
-  let adminToken;
-  try {
-    adminToken = await store.ensureAdminToken();
-  } catch {
-    return false;
-  }
-  const expected = digest(adminToken);
-  const provided = digest(token);
-  return expected.length === provided.length && timingSafeEqual(expected, provided);
-}
-function createMobileAdminFactory(deps) {
-  return (input, principal) => {
-    if (isMobilePrincipal(principal))
-      throw new ChordError("forbidden", "mobile principals cannot administer pairing");
-    const guard = async () => {
-      if (!await tokenMatches(input.token, deps.store))
-        throw new ChordError("forbidden", "forbidden");
-    };
-    return {
-      kind: "admin",
-      async state() {
-        await guard();
-        return deps.mobile.adminState();
-      },
-      async enable(params) {
-        await guard();
-        const state = await deps.mobile.enable({ address: params.address, port: params.port });
-        if (state.status !== "listening")
-          throw new ChordError("unavailable", `mobile listener failed: ${state.status}`);
-        return state;
-      },
-      async disable() {
-        await guard();
-        return deps.mobile.disable();
-      },
-      async createPairing() {
-        await guard();
-        return deps.mobile.createPairing();
-      },
-      async cancelPairing() {
-        await guard();
-        deps.mobile.cancelPairing();
-        return null;
-      },
-      async revoke(params) {
-        await guard();
-        return { revoked: await deps.mobile.revoke(params.deviceId) };
-      },
-      async regenerateCertificate() {
-        await guard();
-        return deps.mobile.regenerateCertificate();
-      }
-    };
-  };
-}
-
-// packages/gateway/src/mobile/listener.ts
-import { randomUUID as randomUUID2 } from "crypto";
-import { createServer } from "https";
-import { hostname } from "os";
-import { createHost as createHost2, memoryLinkPair } from "@earendil-works/chord";
-import { WebSocketServer } from "ws";
-
-// packages/gateway/src/contract.ts
-import { method as method2, remote as remote2 } from "@earendil-works/chord";
-import { Type as Type6 } from "typebox";
-var rpc = (args, result) => [args, result];
-function contract2(name, def) {
-  const variants = Object.fromEntries(Object.entries(def.variants).map(([key, value]) => [
-    key,
-    {
-      ...value,
-      methods: Object.fromEntries(Object.entries(value.methods ?? {}).map(([member, [args, result]]) => [member, method2(args, result)]))
+var GATEWAY_HOST = "neko";
+var rpc = (args, result) => [args, result];
+function contract(name, def) {
+  const variants = Object.fromEntries(Object.entries(def.variants).map(([key, value]) => [
+    key,
+    {
+      ...value,
+      methods: Object.fromEntries(Object.entries(value.methods ?? {}).map(([member, [args, result]]) => [member, method(args, result)]))
     }
   ]));
-  return remote2(name, { ...def, variants });
+  return remote(name, { ...def, host: hostNamed(GATEWAY_HOST), variants });
 }
-var str = Type6.String();
-var num = Type6.Number();
-var bool = Type6.Boolean();
-var nil = Type6.Null();
-var integer = Type6.Integer({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER });
-var nullableString = Type6.Union([str, nil]);
-var phase = Type6.Enum(["pending", "running", "done"]);
-var level = Type6.Enum(["project", "user", "builtin"]);
-var thinking = Type6.Enum(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
-var model = Type6.Object({ provider: str, modelId: str });
-var change = Type6.Object({ model: Type6.Optional(model), thinkingLevel: Type6.Optional(thinking) }, { additionalProperties: false });
-var usage = Type6.Object({ input: num, output: num, cacheRead: num, cacheWrite: num, cost: num });
-var image = Type6.Object({
+var str = Type5.String();
+var num = Type5.Number();
+var bool = Type5.Boolean();
+var nil = Type5.Null();
+var integer = Type5.Integer({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER });
+var nullableString = Type5.Union([str, nil]);
+var phase = Type5.Enum(["pending", "running", "done"]);
+var level = Type5.Enum(["project", "user", "builtin"]);
+var thinking = Type5.Enum(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
+var model = Type5.Object({ provider: str, modelId: str });
+var change = Type5.Object({ model: Type5.Optional(model), thinkingLevel: Type5.Optional(thinking) }, { additionalProperties: false });
+var usage = Type5.Object({ input: num, output: num, cacheRead: num, cacheWrite: num, cost: num });
+var image = Type5.Object({
   name: str,
   mimeType: str,
   width: integer,
@@ -21297,8 +21509,8 @@ var image = Type6.Object({
   entryId: integer,
   contentIndex: integer
 });
-var skill = Type6.Object({ name: str, location: str, body: str, args: str });
-var call = Type6.Object({
+var skill = Type5.Object({ name: str, location: str, body: str, args: str });
+var call = Type5.Object({
   callId: str,
   name: str,
   summary: str,
@@ -21306,116 +21518,135 @@ var call = Type6.Object({
   phase,
   output: nullableString,
   diff: nullableString,
-  diffAdded: Type6.Union([num, nil]),
-  diffRemoved: Type6.Union([num, nil]),
-  diffTruncated: Type6.Optional(bool)
+  diffAdded: Type5.Union([num, nil]),
+  diffRemoved: Type5.Union([num, nil]),
+  diffTruncated: Type5.Optional(bool)
 });
-var DelegationSchema = Type6.Object({
+var DelegationSchema = Type5.Object({
   parentId: integer,
-  agentId: Type6.Optional(str),
-  round: Type6.Optional(integer),
-  runnerId: Type6.Optional(integer),
-  inputEntryId: Type6.Optional(integer),
-  answerEntryId: Type6.Optional(integer),
-  roundUsage: Type6.Optional(Type6.Union([usage, nil])),
+  agentId: Type5.Optional(str),
+  round: Type5.Optional(integer),
+  runnerId: Type5.Optional(integer),
+  inputEntryId: Type5.Optional(integer),
+  answerEntryId: Type5.Optional(integer),
+  roundUsage: Type5.Optional(Type5.Union([usage, nil])),
   taskId: integer,
   callId: str,
   childId: integer,
-  role: Type6.Enum(["explore", "plan", "coder"]),
+  role: Type5.Enum(["explore", "plan", "coder"]),
   title: str,
   createdAt: num,
-  startedAt: Type6.Union([num, nil]),
-  endedAt: Type6.Union([num, nil]),
-  status: Type6.Enum(["queued", "running", "completed", "failed", "cancelled"]),
+  startedAt: Type5.Union([num, nil]),
+  endedAt: Type5.Union([num, nil]),
+  status: Type5.Enum(["queued", "running", "completed", "failed", "cancelled"]),
   report: nullableString,
-  approvalCount: Type6.Optional(integer),
-  historyThrough: Type6.Optional(integer),
-  historyUsage: Type6.Optional(usage)
+  approvalCount: Type5.Optional(integer),
+  historyThrough: Type5.Optional(integer),
+  historyUsage: Type5.Optional(usage)
 });
-var SubagentSummarySchema = Type6.Object({
+var SubagentSummarySchema = Type5.Object({
   agentId: str,
   parentId: integer,
   childId: integer,
-  role: Type6.Enum(["explore", "plan", "coder"]),
+  role: Type5.Enum(["explore", "plan", "coder"]),
   title: str,
-  status: Type6.Enum(["idle", "queued", "running"]),
-  activeRoundId: Type6.Union([integer, nil]),
+  status: Type5.Enum(["idle", "queued", "running"]),
+  activeRoundId: Type5.Union([integer, nil]),
   lastRoundId: integer,
-  lastReport: Type6.Optional(nullableString),
+  lastReport: Type5.Optional(nullableString),
   roundCount: integer,
   taskTitle: str,
   approvalCount: integer,
   createdAt: num,
-  historyThrough: Type6.Optional(integer),
-  historyUsage: Type6.Optional(usage)
+  historyThrough: Type5.Optional(integer),
+  historyUsage: Type5.Optional(usage)
 });
-var jobStatus = Type6.Enum(["running", "exited", "failed", "stopped", "lost"]);
-var JobSummarySchema = Type6.Object({
+var jobStatus = Type5.Enum(["running", "exited", "failed", "stopped", "lost"]);
+var JobSummarySchema = Type5.Object({
   jobId: str,
   title: str,
   command: str,
   cwd: str,
   status: jobStatus,
   startedAt: num,
-  endedAt: Type6.Union([num, nil]),
-  exitCode: Type6.Union([num, nil]),
-  reason: Type6.Optional(Type6.Enum(["timeout", "spawn-error", "restart", "aborted"])),
-  timeoutSeconds: Type6.Optional(num),
+  endedAt: Type5.Union([num, nil]),
+  exitCode: Type5.Union([num, nil]),
+  reason: Type5.Optional(Type5.Enum(["timeout", "spawn-error", "restart", "aborted"])),
+  timeoutSeconds: Type5.Optional(num),
   outputBytes: integer
 });
-var JobOutputSchema = Type6.Object({
+var JobOutputSchema = Type5.Object({
   job: JobSummarySchema,
   text: str,
   offset: integer,
   truncated: bool,
   dropped: integer
 });
-var ChatViewSchema = Type6.Object({
-  historyBefore: Type6.Optional(Type6.Union([integer, nil])),
-  agents: Type6.Optional(Type6.Array(SubagentSummarySchema)),
-  jobs: Type6.Optional(Type6.Array(JobSummarySchema)),
-  rounds: Type6.Optional(Type6.Array(DelegationSchema)),
-  subagents: Type6.Optional(Type6.Array(DelegationSchema)),
-  taskUsage: Type6.Optional(usage),
+var QueuedInputSchema = Type5.Object({
+  id: integer,
+  mode: Type5.Enum(["steer", "followUp"]),
+  preview: str,
+  images: integer,
+  skill: Type5.Optional(Type5.Object({ name: str, args: str }))
+});
+var WithdrawResultSchema = Type5.Object({
+  result: Type5.Enum(["withdrawn", "placed", "settled", "unknown"]),
+  text: Type5.Optional(str),
+  images: Type5.Optional(integer)
+});
+var SteerResultSchema = Type5.Object({
+  result: Type5.Enum(["steered", "withdrawn", "placed", "settled", "unknown"]),
+  id: Type5.Optional(integer),
+  text: Type5.Optional(str),
+  images: Type5.Optional(integer)
+});
+var ChatViewSchema = Type5.Object({
+  historyBefore: Type5.Optional(Type5.Union([integer, nil])),
+  agents: Type5.Optional(Type5.Array(SubagentSummarySchema)),
+  jobs: Type5.Optional(Type5.Array(JobSummarySchema)),
+  queued: Type5.Optional(Type5.Array(QueuedInputSchema)),
+  rounds: Type5.Optional(Type5.Array(DelegationSchema)),
+  subagents: Type5.Optional(Type5.Array(DelegationSchema)),
+  taskUsage: Type5.Optional(usage),
   model: str,
-  agent: Type6.Object({ model: Type6.Union([model, nil]), thinkingLevel: Type6.Union([thinking, nil]) }),
+  agent: Type5.Object({ model: Type5.Union([model, nil]), thinkingLevel: Type5.Union([thinking, nil]) }),
   cwd: str,
   busy: bool,
   status: nullableString,
   usage,
-  contextUsage: Type6.Optional(Type6.Object({ tokens: Type6.Union([num, nil]), window: num, percent: Type6.Union([num, nil]) })),
-  compaction: Type6.Optional(Type6.Object({
-    failure: Type6.Optional(Type6.Object({ taskId: integer, reason: Type6.Enum(["manual", "threshold", "overflow"]), error: str })),
-    active: Type6.Array(Type6.Object({
+  contextUsage: Type5.Optional(Type5.Object({ tokens: Type5.Union([num, nil]), window: num, percent: Type5.Union([num, nil]) })),
+  compaction: Type5.Optional(Type5.Object({
+    failure: Type5.Optional(Type5.Object({ taskId: integer, reason: Type5.Enum(["manual", "threshold", "overflow"]), error: str })),
+    active: Type5.Array(Type5.Object({
       taskId: integer,
-      reason: Type6.Enum(["manual", "threshold", "overflow"]),
+      reason: Type5.Enum(["manual", "threshold", "overflow"]),
       blocking: bool,
       attempt: integer,
-      retry: Type6.Optional(Type6.Object({ at: num, error: str }))
+      retry: Type5.Optional(Type5.Object({ at: num, error: str }))
     })),
-    latest: Type6.Union([
+    latest: Type5.Union([
       nil,
-      Type6.Object({
+      Type5.Object({
         taskId: integer,
-        phase: Type6.Enum(["summarizing", "waiting-to-apply", "applied", "nothing", "skipped", "cancelled", "failed"]),
+        phase: Type5.Enum(["summarizing", "waiting-to-apply", "applied", "nothing", "skipped", "cancelled", "failed"]),
         at: num
       })
     ])
   })),
-  items: Type6.Array(Type6.Union([
-    Type6.Object({
-      type: Type6.Literal("user"),
-      order: Type6.Optional(num),
+  items: Type5.Array(Type5.Union([
+    Type5.Object({
+      type: Type5.Literal("user"),
+      order: Type5.Optional(num),
       key: str,
       id: integer,
       text: str,
-      images: Type6.Optional(Type6.Array(image)),
-      skill: Type6.Optional(skill),
-      defaultImagePrompt: Type6.Optional(Type6.Object({ version: Type6.Integer({ minimum: 1 }), text: str }))
+      images: Type5.Optional(Type5.Array(image)),
+      skill: Type5.Optional(skill),
+      defaultImagePrompt: Type5.Optional(Type5.Object({ version: Type5.Integer({ minimum: 1 }), text: str }))
     }),
-    Type6.Object({
-      type: Type6.Literal("assistant"),
-      order: Type6.Optional(num),
+    Type5.Object({
+      type: Type5.Literal("assistant"),
+      order: Type5.Optional(num),
       key: str,
       id: integer,
       thinking: str,
@@ -21424,11 +21655,11 @@ var ChatViewSchema = Type6.Object({
       errorMessage: nullableString,
       note: nullableString
     }),
-    Type6.Object({
-      type: Type6.Literal("tool"),
-      order: Type6.Optional(num),
+    Type5.Object({
+      type: Type5.Literal("tool"),
+      order: Type5.Optional(num),
       key: str,
-      images: Type6.Optional(Type6.Array(image)),
+      images: Type5.Optional(Type5.Array(image)),
       callId: str,
       name: str,
       summary: str,
@@ -21437,61 +21668,61 @@ var ChatViewSchema = Type6.Object({
       isError: bool,
       output: nullableString,
       result: nullableString,
-      durationMs: Type6.Union([num, nil]),
+      durationMs: Type5.Union([num, nil]),
       note: nullableString,
       diff: nullableString,
-      diffAdded: Type6.Union([num, nil]),
-      diffRemoved: Type6.Union([num, nil]),
-      diffTruncated: Type6.Optional(bool)
+      diffAdded: Type5.Union([num, nil]),
+      diffRemoved: Type5.Union([num, nil]),
+      diffTruncated: Type5.Optional(bool)
     }),
-    Type6.Object({
-      type: Type6.Literal("system"),
-      order: Type6.Optional(num),
+    Type5.Object({
+      type: Type5.Literal("system"),
+      order: Type5.Optional(num),
       key: str,
       id: integer,
       text: str,
-      jobId: Type6.Optional(str)
+      jobId: Type5.Optional(str)
     })
   ])),
-  streaming: Type6.Union([nil, Type6.Object({ thinking: str, text: str, toolCalls: Type6.Array(call) })])
+  streaming: Type5.Union([nil, Type5.Object({ thinking: str, text: str, toolCalls: Type5.Array(call) })])
 });
-var SessionSummarySchema = Type6.Object({
+var SessionSummarySchema = Type5.Object({
   workspaceRoot: str,
   lastUsedAt: num,
   title: str,
   firstPromptPreview: str,
   createdAt: num,
-  lastMessageAt: Type6.Union([num, nil]),
-  model: Type6.Union([model, nil]),
-  status: Type6.Enum(["idle", "running", "error"]),
+  lastMessageAt: Type5.Union([num, nil]),
+  model: Type5.Union([model, nil]),
+  status: Type5.Enum(["idle", "running", "error"]),
   id: str
 });
-var DirectoryStateSchema = Type6.Object({ revision: integer, sessions: Type6.Array(SessionSummarySchema) });
-var WorkspaceSummarySchema = Type6.Object({ path: str, createdAt: num });
-var WorkspaceStateSchema = Type6.Object({ revision: integer, workspaces: Type6.Array(WorkspaceSummarySchema) });
-var credentialStatus = Type6.Object({
+var DirectoryStateSchema = Type5.Object({ revision: integer, sessions: Type5.Array(SessionSummarySchema) });
+var WorkspaceSummarySchema = Type5.Object({ path: str, createdAt: num });
+var WorkspaceStateSchema = Type5.Object({ revision: integer, workspaces: Type5.Array(WorkspaceSummarySchema) });
+var credentialStatus = Type5.Object({
   savedConfigured: bool,
   environmentConfigured: bool,
-  source: Type6.Enum(["saved", "environment", "runtime", "keyless", "none"])
+  source: Type5.Enum(["saved", "environment", "runtime", "keyless", "none"])
 });
-var CredentialStateSchema = Type6.Object({
+var CredentialStateSchema = Type5.Object({
   revision: integer,
-  statuses: Type6.Object({ deepseek: credentialStatus, tavily: credentialStatus })
+  statuses: Type5.Object({ deepseek: credentialStatus, tavily: credentialStatus })
 });
-var AttachmentSchema = Type6.Object({ sessionId: str, attachmentId: str });
-var chatInput = Type6.Object({ sessionId: str, attachmentId: str }, { additionalProperties: false });
-var NekoSessionDirectory = contract2("neko.session-directory", {
+var AttachmentSchema = Type5.Object({ sessionId: str, attachmentId: str });
+var chatInput = Type5.Object({ sessionId: str, attachmentId: str }, { additionalProperties: false });
+var NekoSessionDirectory = contract("neko.session-directory", {
   version: 1,
-  input: Type6.Object({}, { additionalProperties: false }),
+  input: Type5.Object({}, { additionalProperties: false }),
   variants: { ready: { state: { state: DirectoryStateSchema } } }
 });
-var NekoSessionManagement = contract2("neko.session-management", {
+var NekoSessionManagement = contract("neko.session-management", {
   version: 1,
-  input: Type6.Object({}, { additionalProperties: false }),
+  input: Type5.Object({}, { additionalProperties: false }),
   variants: {
     ready: {
       methods: {
-        create: rpc(Type6.Object({ ...change.properties, cwd: Type6.Optional(str) }, { additionalProperties: false }), SessionSummarySchema),
+        create: rpc(Type5.Object({ ...change.properties, cwd: Type5.Optional(str) }, { additionalProperties: false }), SessionSummarySchema),
         archive: rpc(str, nil),
         attach: rpc(str, AttachmentSchema),
         detach: rpc(nil, nil),
@@ -21500,30 +21731,30 @@ var NekoSessionManagement = contract2("neko.session-management", {
     }
   }
 });
-var resize = Type6.Object({
-  maxWidth: Type6.Optional(integer),
-  maxHeight: Type6.Optional(integer),
-  maxBytes: Type6.Optional(integer),
-  jpegQuality: Type6.Optional(integer)
+var resize = Type5.Object({
+  maxWidth: Type5.Optional(integer),
+  maxHeight: Type5.Optional(integer),
+  maxBytes: Type5.Optional(integer),
+  jpegQuality: Type5.Optional(integer)
 });
-var inputLimits = Type6.Object({
-  maxRequestBytes: Type6.Optional(integer),
-  images: Type6.Optional(Type6.Object({
-    resize: Type6.Optional(resize),
-    maxPerMessage: Type6.Optional(integer),
-    maxPerRequest: Type6.Optional(integer)
+var inputLimits = Type5.Object({
+  maxRequestBytes: Type5.Optional(integer),
+  images: Type5.Optional(Type5.Object({
+    resize: Type5.Optional(resize),
+    maxPerMessage: Type5.Optional(integer),
+    maxPerRequest: Type5.Optional(integer)
   }))
 });
-var modelInfo = Type6.Object({
+var modelInfo = Type5.Object({
   provider: str,
   modelId: str,
   name: str,
   contextWindow: num,
-  input: Type6.Array(str),
-  inputLimits: Type6.Optional(inputLimits),
+  input: Type5.Array(str),
+  inputLimits: Type5.Optional(inputLimits),
   reasoning: bool,
-  supportedThinkingLevels: Type6.Array(thinking),
-  thinkingLevelAdjustments: Type6.Object({
+  supportedThinkingLevels: Type5.Array(thinking),
+  thinkingLevelAdjustments: Type5.Object({
     off: thinking,
     minimal: thinking,
     low: thinking,
@@ -21533,168 +21764,714 @@ var modelInfo = Type6.Object({
     max: thinking
   })
 });
-var NekoModels = contract2("neko.models", {
+var NekoModels = contract("neko.models", {
   version: 1,
-  input: Type6.Object({}, { additionalProperties: false }),
-  variants: { ready: { methods: { list: rpc(nil, Type6.Array(modelInfo)) } } }
+  input: Type5.Object({}, { additionalProperties: false }),
+  variants: { ready: { methods: { list: rpc(nil, Type5.Array(modelInfo)) } } }
 });
-var imageChunk = Type6.Object({ data: str, total: integer, mimeType: str });
-var NekoSubagent = contract2("neko.subagent", {
+var imageChunk = Type5.Object({ data: str, total: integer, mimeType: str });
+var NekoSubagent = contract("neko.subagent", {
   version: 1,
-  input: Type6.Object({
+  input: Type5.Object({
     sessionId: str,
     attachmentId: str,
-    taskId: Type6.Optional(integer),
-    agentId: Type6.Optional(str)
+    taskId: Type5.Optional(integer),
+    agentId: Type5.Optional(str)
   }),
   variants: {
     ready: {
       state: { revision: integer },
       methods: {
-        chunk: rpc(Type6.Object({
-          kind: Type6.Enum(["view", "history"]),
-          before: Type6.Optional(integer),
-          token: Type6.Optional(integer),
+        chunk: rpc(Type5.Object({
+          kind: Type5.Enum(["view", "history"]),
+          before: Type5.Optional(integer),
+          token: Type5.Optional(integer),
           offset: integer
-        }), Type6.Object({ token: integer, data: str, next: Type6.Union([integer, nil]) })),
-        getImage: rpc(Type6.Object({ entryId: integer, contentIndex: integer, offset: integer }), imageChunk),
-        decideApproval: rpc(Type6.Object({ id: integer, version: str, decision: Type6.Enum(["allowed", "denied"]) }), Type6.Enum(["pending", "allowed", "denied", "cancelled"])),
-        stop: rpc(Type6.Union([nil, Type6.Object({ taskId: integer })]), nil)
+        }), Type5.Object({ token: integer, data: str, next: Type5.Union([integer, nil]) })),
+        getImage: rpc(Type5.Object({ entryId: integer, contentIndex: integer, offset: integer }), imageChunk),
+        decideApproval: rpc(Type5.Object({ id: integer, version: str, decision: Type5.Enum(["allowed", "denied"]) }), Type5.Enum(["pending", "allowed", "denied", "cancelled"])),
+        stop: rpc(Type5.Union([nil, Type5.Object({ taskId: integer })]), nil)
       }
     }
   }
 });
-var NekoChat = contract2("neko.chat", {
+var NekoChat = contract("neko.chat", {
   version: 1,
   input: chatInput,
   variants: {
     ready: {
       state: { view: ChatViewSchema },
       methods: {
-        submit: rpc(Type6.Object({
+        submit: rpc(Type5.Object({
           content: str,
-          images: Type6.Optional(Type6.Array(str, { maxItems: 4 })),
-          requestId: Type6.Optional(str),
-          whenBusy: Type6.Optional(Type6.Enum(["steer", "followUp"]))
+          images: Type5.Optional(Type5.Array(str, { maxItems: 4 })),
+          requestId: Type5.Optional(str),
+          whenBusy: Type5.Optional(Type5.Enum(["steer", "followUp"]))
         }, { additionalProperties: false }), nil),
         abort: rpc(nil, nil),
+        withdraw: rpc(Type5.Object({ id: integer }, { additionalProperties: false }), WithdrawResultSchema),
+        steer: rpc(Type5.Object({ id: integer }, { additionalProperties: false }), SteerResultSchema),
         usage: rpc(nil, usage),
-        skills: rpc(nil, Type6.Array(Type6.Object({ name: str, description: str, location: str, level }))),
-        jobOutput: rpc(Type6.Object({ jobId: str, since: Type6.Optional(integer) }, { additionalProperties: false }), JobOutputSchema),
-        jobStop: rpc(Type6.Object({ jobId: str }, { additionalProperties: false }), JobSummarySchema),
+        skills: rpc(nil, Type5.Array(Type5.Object({ name: str, description: str, location: str, level }))),
+        jobOutput: rpc(Type5.Object({ jobId: str, since: Type5.Optional(integer) }, { additionalProperties: false }), JobOutputSchema),
+        jobStop: rpc(Type5.Object({ jobId: str }, { additionalProperties: false }), JobSummarySchema),
         configure: rpc(change, nil),
-        compact: rpc(Type6.Object({ instructions: Type6.Optional(str) }, { additionalProperties: false }), nil),
-        importImage: rpc(str, Type6.Object({ id: str, name: str })),
-        draftImage: rpc(Type6.Object({ id: str, offset: integer }, { additionalProperties: false }), imageChunk),
-        beginImage: rpc(Type6.Object({ name: str, mimeType: str, size: Type6.Integer({ minimum: 1, maximum: 20971520 }) }, { additionalProperties: false }), str),
-        appendImage: rpc(Type6.Object({ id: str, offset: integer, data: Type6.String({ maxLength: 350000 }) }, { additionalProperties: false }), nil),
+        compact: rpc(Type5.Object({ instructions: Type5.Optional(str) }, { additionalProperties: false }), nil),
+        importImage: rpc(str, Type5.Object({ id: str, name: str })),
+        draftImage: rpc(Type5.Object({ id: str, offset: integer }, { additionalProperties: false }), imageChunk),
+        beginImage: rpc(Type5.Object({ name: str, mimeType: str, size: Type5.Integer({ minimum: 1, maximum: 20971520 }) }, { additionalProperties: false }), str),
+        appendImage: rpc(Type5.Object({ id: str, offset: integer, data: Type5.String({ maxLength: 350000 }) }, { additionalProperties: false }), nil),
         finishImage: rpc(str, nil),
         releaseImage: rpc(str, nil),
-        getImage: rpc(Type6.Object({ entryId: integer, contentIndex: integer, offset: integer }, { additionalProperties: false }), imageChunk)
+        getImage: rpc(Type5.Object({ entryId: integer, contentIndex: integer, offset: integer }, { additionalProperties: false }), imageChunk)
       }
     }
   }
 });
-var browse = Type6.Object({ path: str, query: Type6.Optional(str), showHidden: Type6.Optional(bool), cursor: Type6.Optional(str) }, { additionalProperties: false });
-var page = Type6.Object({
+var browse = Type5.Object({ path: str, query: Type5.Optional(str), showHidden: Type5.Optional(bool), cursor: Type5.Optional(str) }, { additionalProperties: false });
+var page = Type5.Object({
   path: str,
   parent: nullableString,
-  entries: Type6.Array(Type6.Object({ name: str, path: str, error: Type6.Optional(str) })),
+  entries: Type5.Array(Type5.Object({ name: str, path: str, error: Type5.Optional(str) })),
   next: nullableString
 });
-var NekoWorkspaces = contract2("neko.workspaces", {
+var NekoWorkspaces = contract("neko.workspaces", {
   version: 1,
-  input: Type6.Object({}, { additionalProperties: false }),
+  input: Type5.Object({}, { additionalProperties: false }),
   variants: {
     ready: {
       state: { state: WorkspaceStateSchema },
       methods: {
-        add: rpc(Type6.Object({ path: str }, { additionalProperties: false }), WorkspaceSummarySchema),
+        add: rpc(Type5.Object({ path: str }, { additionalProperties: false }), WorkspaceSummarySchema),
         browse: rpc(browse, page)
       }
     }
   }
 });
-var provider = Type6.Enum(["deepseek", "tavily"]);
-var NekoCredentials = contract2("neko.credentials", {
+var provider = Type5.Enum(["deepseek", "tavily"]);
+var NekoCredentials = contract("neko.credentials", {
   version: 1,
-  input: Type6.Object({}, { additionalProperties: false }),
+  input: Type5.Object({}, { additionalProperties: false }),
   variants: {
     ready: {
       state: { state: CredentialStateSchema },
       methods: {
-        save: rpc(Type6.Object({ provider, key: Type6.String({ minLength: 1, maxLength: 8192 }) }, { additionalProperties: false }), nil),
-        remove: rpc(Type6.Object({ provider }, { additionalProperties: false }), nil)
+        save: rpc(Type5.Object({ provider, key: Type5.String({ minLength: 1, maxLength: 8192 }) }, { additionalProperties: false }), nil),
+        remove: rpc(Type5.Object({ provider }, { additionalProperties: false }), nil)
+      }
+    }
+  }
+});
+var SearchSettingsStateSchema = Type5.Object({
+  revision: integer,
+  selected: Type5.Enum(["tavily", "deepseek"])
+});
+var NekoSearchSettings = contract("neko.search-settings", {
+  version: 1,
+  input: Type5.Object({}, { additionalProperties: false }),
+  variants: {
+    ready: {
+      state: { state: SearchSettingsStateSchema },
+      methods: {
+        set: rpc(Type5.Object({ provider: Type5.Enum(["tavily", "deepseek"]) }, { additionalProperties: false }), nil)
       }
     }
   }
 });
-var FileCandidatesSchema = Type6.Object({
-  entries: Type6.Array(Type6.Object({ name: str, path: str, kind: Type6.Enum(["file", "directory"]) }), { maxItems: 100 }),
+var contextSource = Type5.Enum(["default", "config", "saved"]);
+var ContextSettingsStateSchema = Type5.Object({
+  revision: integer,
+  effective: Type5.Object({
+    compaction: Type5.Object({
+      enabled: bool,
+      triggerPercent: Type5.Union([integer, nil]),
+      keepRecentTokens: integer
+    }),
+    pruning: Type5.Object({
+      enabled: bool,
+      triggerPercent: integer,
+      keepRecent: integer,
+      minChars: integer,
+      minSavePercent: integer
+    })
+  }),
+  sources: Type5.Object({
+    compaction: Type5.Object({ enabled: contextSource, triggerPercent: contextSource, keepRecentTokens: contextSource }),
+    pruning: Type5.Object({
+      enabled: contextSource,
+      triggerPercent: contextSource,
+      keepRecent: contextSource,
+      minChars: contextSource,
+      minSavePercent: contextSource
+    })
+  })
+});
+var nullable = (schema) => Type5.Union([schema, nil]);
+var ContextSettingsPatchSchema = Type5.Object({
+  compaction: Type5.Optional(Type5.Object({
+    enabled: Type5.Optional(nullable(bool)),
+    triggerPercent: Type5.Optional(nullable(integer)),
+    keepRecentTokens: Type5.Optional(nullable(integer))
+  }, { additionalProperties: false })),
+  pruning: Type5.Optional(Type5.Object({
+    enabled: Type5.Optional(nullable(bool)),
+    triggerPercent: Type5.Optional(nullable(integer)),
+    keepRecent: Type5.Optional(nullable(integer)),
+    minChars: Type5.Optional(nullable(integer)),
+    minSavePercent: Type5.Optional(nullable(integer))
+  }, { additionalProperties: false }))
+}, { additionalProperties: false });
+var NekoContextSettings = contract("neko.context-settings", {
+  version: 1,
+  input: Type5.Object({}, { additionalProperties: false }),
+  variants: {
+    ready: {
+      state: { state: ContextSettingsStateSchema },
+      methods: {
+        set: rpc(ContextSettingsPatchSchema, nil),
+        reset: rpc(Type5.Object({}, { additionalProperties: false }), nil)
+      }
+    }
+  }
+});
+var FileCandidatesSchema = Type5.Object({
+  entries: Type5.Array(Type5.Object({ name: str, path: str, kind: Type5.Enum(["file", "directory"]) }), { maxItems: 100 }),
   limited: bool,
   incomplete: bool
 });
-var NekoWorkspaceFiles = contract2("neko.workspace-files", {
+var NekoWorkspaceFiles = contract("neko.workspace-files", {
+  version: 1,
+  input: Type5.Object({}, { additionalProperties: false }),
+  variants: {
+    ready: {
+      methods: {
+        search: rpc(Type5.Object({ workspaceRoot: str, query: str }, { additionalProperties: false }), FileCandidatesSchema)
+      }
+    }
+  }
+});
+var marketSkill = Type5.Object({
+  name: str,
+  description: str,
+  category: str,
+  source: str,
+  license: str,
+  version: str,
+  sha256: str,
+  sizeBytes: integer,
+  uploadedAt: str,
+  installed: Type5.Object({ project: bool, user: bool, builtin: bool }),
+  activeLevel: Type5.Union([level, nil])
+});
+var preview = Type5.Object({ body: str, files: Type5.Array(str) });
+var scope = Type5.Enum(["user", "project"]);
+var installResult = Type5.Object({ name: str, scope, path: str, shadowedBy: Type5.Optional(scope) });
+var NekoSkillMarket = contract("neko.skill-market", {
   version: 1,
-  input: Type6.Object({}, { additionalProperties: false }),
+  input: Type5.Object({}, { additionalProperties: false }),
   variants: {
     ready: {
       methods: {
-        search: rpc(Type6.Object({ workspaceRoot: str, query: str }, { additionalProperties: false }), FileCandidatesSchema)
+        list: rpc(Type5.Object({ query: Type5.Optional(str), workspaceRoot: Type5.Optional(str) }, { additionalProperties: false }), Type5.Array(marketSkill)),
+        detail: rpc(Type5.Object({ name: str, workspaceRoot: Type5.Optional(str) }, { additionalProperties: false }), marketSkill),
+        preview: rpc(Type5.Object({ name: str }, { additionalProperties: false }), preview),
+        install: rpc(Type5.Object({ name: str, scope, workspaceRoot: Type5.Optional(str), overwrite: Type5.Optional(bool) }, { additionalProperties: false }), installResult),
+        uninstall: rpc(Type5.Object({ name: str, scope, workspaceRoot: Type5.Optional(str) }, { additionalProperties: false }), nil)
       }
     }
   }
 });
-var marketSkill = Type6.Object({
-  name: str,
-  description: str,
-  category: str,
-  source: str,
-  license: str,
-  version: str,
-  sha256: str,
-  sizeBytes: integer,
-  uploadedAt: str,
-  installed: Type6.Object({ project: bool, user: bool, builtin: bool }),
-  activeLevel: Type6.Union([level, nil])
-});
-var preview = Type6.Object({ body: str, files: Type6.Array(str) });
-var scope = Type6.Enum(["user", "project"]);
-var installResult = Type6.Object({ name: str, scope, path: str, shadowedBy: Type6.Optional(scope) });
-var NekoSkillMarket = contract2("neko.skill-market", {
+var ApplicationInfoSchema = Type5.Object({
+  runningVersion: str,
+  installedVersion: nullableString,
+  protocolVersion: Type5.Integer({ minimum: 1 }),
+  latestVersion: nullableString,
+  checkedAt: Type5.Union([integer, nil]),
+  checkState: Type5.Enum(["unknown", "checking", "ok", "failed", "development"]),
+  serverId: str
+});
+var NekoApplicationInfo = contract("neko.application-info", {
+  version: 1,
+  input: Type5.Object({}),
+  variants: {
+    ready: { state: { info: ApplicationInfoSchema }, methods: { check: rpc(nil, ApplicationInfoSchema) } }
+  }
+});
+
+// packages/gateway/src/identity.ts
+function isServerId(value) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
+}
+
+// packages/gateway/src/mobile/admin.ts
+import { createHash, timingSafeEqual } from "crypto";
+import { ChordError } from "@earendil-works/chord";
+import { Type as Type6 } from "typebox";
+
+// packages/gateway/src/principal.ts
+var HOST_PRINCIPAL = { kind: "host" };
+function gatewayPrincipalKey(principal) {
+  switch (principal.kind) {
+    case "mobile":
+      return `mobile:${principal.deviceId}:${principal.grantRevision}:${principal.connectionId}`;
+    case "local":
+      return `local:${principal.connectionId}`;
+    case "host":
+      return "host";
+  }
+}
+function isMobilePrincipal(principal) {
+  return typeof principal === "object" && principal !== null && principal.kind === "mobile";
+}
+
+// packages/gateway/src/mobile/store.ts
+import { randomBytes } from "crypto";
+import { chmod as chmod2, mkdir as mkdir2, readFile as readFile4, rename as rename2, rm, writeFile } from "fs/promises";
+import { join as join6 } from "path";
+var MOBILE_STATE_FORMAT_VERSION = 1;
+var MOBILE_DEFAULT_PORT = 8323;
+var MOBILE_ADMIN_TOKEN_BYTES = 32;
+var POSIX = process.platform !== "win32";
+var ADMIN_TOKEN_PATTERN = /^[A-Za-z0-9_-]{43}$/;
+var CREDENTIAL_HASH_PATTERN = /^[0-9a-fA-F]{64}$/;
+function defaultState() {
+  return {
+    formatVersion: MOBILE_STATE_FORMAT_VERSION,
+    enabled: false,
+    address: null,
+    port: MOBILE_DEFAULT_PORT,
+    devices: [],
+    receipts: [],
+    lastConnectedAddress: null
+  };
+}
+function freezeState(state) {
+  for (const device of state.devices)
+    Object.freeze(device);
+  Object.freeze(state.devices);
+  for (const receipt of state.receipts)
+    Object.freeze(receipt);
+  Object.freeze(state.receipts);
+  return Object.freeze(state);
+}
+function isNotFound(error) {
+  return error?.code === "ENOENT";
+}
+function invalidState(statePath, detail) {
+  return new Error(`Invalid mobile state file ${statePath}: ${detail}`);
+}
+function readString(value, what, statePath) {
+  if (typeof value !== "string")
+    throw invalidState(statePath, `${what} must be a string`);
+  return value;
+}
+function readNonEmptyString(value, what, statePath) {
+  const text = readString(value, what, statePath);
+  if (text === "")
+    throw invalidState(statePath, `${what} must be a non-empty string`);
+  return text;
+}
+function readCredentialHash(value, what, statePath) {
+  const text = readString(value, what, statePath);
+  if (!CREDENTIAL_HASH_PATTERN.test(text))
+    throw invalidState(statePath, `${what} must be a 64-character hex string`);
+  return text;
+}
+function readRevision(value, what, statePath) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0)
+    throw invalidState(statePath, `${what} must be a non-negative integer`);
+  return value;
+}
+function readTimestamp(value, what, statePath) {
+  if (typeof value !== "number" || !Number.isFinite(value))
+    throw invalidState(statePath, `${what} must be a finite number`);
+  return value;
+}
+function parseDevice(raw, index, statePath) {
+  const what = `devices[${index}]`;
+  if (typeof raw !== "object" || raw === null)
+    throw invalidState(statePath, `${what} must be an object`);
+  const record = raw;
+  return {
+    deviceId: readNonEmptyString(record.deviceId, `${what}.deviceId`, statePath),
+    name: readString(record.name, `${what}.name`, statePath),
+    credentialHash: readCredentialHash(record.credentialHash, `${what}.credentialHash`, statePath),
+    grantRevision: readRevision(record.grantRevision, `${what}.grantRevision`, statePath),
+    pairedAt: readTimestamp(record.pairedAt, `${what}.pairedAt`, statePath),
+    lastSeenAt: readTimestamp(record.lastSeenAt, `${what}.lastSeenAt`, statePath)
+  };
+}
+function parseReceipt(raw, index, statePath) {
+  const what = `receipts[${index}]`;
+  if (typeof raw !== "object" || raw === null)
+    throw invalidState(statePath, `${what} must be an object`);
+  const record = raw;
+  return {
+    pairRequestId: readNonEmptyString(record.pairRequestId, `${what}.pairRequestId`, statePath),
+    deviceId: readNonEmptyString(record.deviceId, `${what}.deviceId`, statePath),
+    credentialHash: readCredentialHash(record.credentialHash, `${what}.credentialHash`, statePath),
+    grantRevision: readRevision(record.grantRevision, `${what}.grantRevision`, statePath),
+    expiresAt: readTimestamp(record.expiresAt, `${what}.expiresAt`, statePath)
+  };
+}
+function parseState(raw, statePath) {
+  if (typeof raw !== "object" || raw === null)
+    throw invalidState(statePath, "root must be an object");
+  const record = raw;
+  if (record.formatVersion !== MOBILE_STATE_FORMAT_VERSION)
+    throw invalidState(statePath, `unsupported formatVersion (expected ${MOBILE_STATE_FORMAT_VERSION})`);
+  if (typeof record.enabled !== "boolean")
+    throw invalidState(statePath, "enabled must be a boolean");
+  if (record.address !== null && typeof record.address !== "string")
+    throw invalidState(statePath, "address must be a string or null");
+  const port = record.port;
+  if (typeof port !== "number" || !Number.isInteger(port) || port < 1 || port > 65535)
+    throw invalidState(statePath, "port must be an integer between 1 and 65535");
+  if (!Array.isArray(record.devices))
+    throw invalidState(statePath, "devices must be an array");
+  if (!Array.isArray(record.receipts))
+    throw invalidState(statePath, "receipts must be an array");
+  const lastConnectedAddress = record.lastConnectedAddress === undefined || record.lastConnectedAddress === null ? null : readString(record.lastConnectedAddress, "lastConnectedAddress", statePath);
+  return {
+    formatVersion: MOBILE_STATE_FORMAT_VERSION,
+    enabled: record.enabled,
+    address: record.address,
+    port,
+    devices: record.devices.map((device, index) => parseDevice(device, index, statePath)),
+    receipts: record.receipts.map((receipt, index) => parseReceipt(receipt, index, statePath)),
+    lastConnectedAddress
+  };
+}
+function assertPort(port) {
+  if (!Number.isInteger(port) || port < 1 || port > 65535)
+    throw new Error("port must be an integer between 1 and 65535");
+  return port;
+}
+var tempCounter = 0;
+async function writeFileAtomic(filePath, contents, mode) {
+  const tempPath = `${filePath}.tmp-${process.pid}-${++tempCounter}`;
+  try {
+    await writeFile(tempPath, contents, { mode });
+    if (POSIX)
+      await chmod2(tempPath, mode);
+    await rename2(tempPath, filePath);
+  } finally {
+    await rm(tempPath, { force: true });
+  }
+}
+async function writeSecretFile(filePath, contents) {
+  await writeFileAtomic(filePath, contents, 384);
+}
+async function readSecretFile(filePath) {
+  try {
+    return await readFile4(filePath, "utf8");
+  } catch (error) {
+    if (isNotFound(error))
+      return;
+    throw error;
+  }
+}
+async function loadState(statePath) {
+  let raw;
+  try {
+    raw = await readFile4(statePath, "utf8");
+  } catch (error) {
+    if (isNotFound(error))
+      return freezeState(defaultState());
+    throw error;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw invalidState(statePath, "not valid JSON");
+  }
+  return freezeState(parseState(parsed, statePath));
+}
+
+class MobileStore {
+  mobileDir;
+  tlsDir;
+  statePath;
+  adminTokenPath;
+  current;
+  queue = Promise.resolve();
+  constructor(mobileDir, initial) {
+    this.mobileDir = mobileDir;
+    this.tlsDir = join6(mobileDir, "tls");
+    this.statePath = join6(mobileDir, "state.json");
+    this.adminTokenPath = join6(mobileDir, "admin-token");
+    this.current = initial;
+  }
+  static async open(nekoDir) {
+    const mobileDir = join6(nekoDir, "mobile");
+    const tlsDir = join6(mobileDir, "tls");
+    await mkdir2(mobileDir, { recursive: true, mode: 448 });
+    await mkdir2(tlsDir, { recursive: true, mode: 448 });
+    if (POSIX) {
+      await chmod2(mobileDir, 448);
+      await chmod2(tlsDir, 448);
+    }
+    return new MobileStore(mobileDir, await loadState(join6(mobileDir, "state.json")));
+  }
+  getState() {
+    return this.current;
+  }
+  updateConfig(patch) {
+    return this.mutate((state) => ({
+      ...state,
+      ...patch.enabled !== undefined ? { enabled: patch.enabled } : {},
+      ...patch.address !== undefined ? { address: patch.address } : {},
+      ...patch.port !== undefined ? { port: assertPort(patch.port) } : {}
+    }));
+  }
+  upsertDevice(device) {
+    return this.mutate((state) => ({
+      ...state,
+      devices: state.devices.some((d) => d.deviceId === device.deviceId) ? state.devices.map((d) => d.deviceId === device.deviceId ? device : d) : [...state.devices, device]
+    }));
+  }
+  removeDevice(deviceId) {
+    return this.mutate((state) => ({
+      ...state,
+      devices: state.devices.filter((d) => d.deviceId !== deviceId)
+    }));
+  }
+  completePairing(input) {
+    return this.mutate((state) => {
+      const now = Date.now();
+      const existing = state.devices.find((d) => d.deviceId === input.deviceId);
+      const grantRevision = existing === undefined ? 1 : existing.grantRevision + 1;
+      const device = {
+        deviceId: input.deviceId,
+        name: input.name,
+        credentialHash: input.credentialHash,
+        grantRevision,
+        pairedAt: input.pairedAt,
+        lastSeenAt: input.pairedAt
+      };
+      const receipt = {
+        pairRequestId: input.pairRequestId,
+        deviceId: input.deviceId,
+        credentialHash: input.credentialHash,
+        grantRevision,
+        expiresAt: input.receiptExpiresAt
+      };
+      return {
+        ...state,
+        devices: existing === undefined ? [...state.devices, device] : state.devices.map((d) => d.deviceId === input.deviceId ? device : d),
+        receipts: [
+          ...state.receipts.filter((r) => r.expiresAt > now && r.pairRequestId !== input.pairRequestId),
+          receipt
+        ]
+      };
+    });
+  }
+  putReceipt(receipt) {
+    return this.mutate((state) => ({
+      ...state,
+      receipts: state.receipts.some((r) => r.pairRequestId === receipt.pairRequestId) ? state.receipts.map((r) => r.pairRequestId === receipt.pairRequestId ? receipt : r) : [...state.receipts, receipt]
+    }));
+  }
+  removeReceipt(pairRequestId) {
+    return this.mutate((state) => ({
+      ...state,
+      receipts: state.receipts.filter((r) => r.pairRequestId !== pairRequestId)
+    }));
+  }
+  touchDevice(deviceId, lastSeenAt) {
+    return this.mutate((state) => {
+      const existing = state.devices.find((d) => d.deviceId === deviceId);
+      if (existing === undefined)
+        return state;
+      return {
+        ...state,
+        devices: state.devices.map((d) => d.deviceId === deviceId ? { ...d, lastSeenAt } : d)
+      };
+    });
+  }
+  rememberConnectedAddress(address) {
+    if (this.current.lastConnectedAddress === address)
+      return Promise.resolve(this.current);
+    return this.mutate((state) => ({ ...state, lastConnectedAddress: address }));
+  }
+  clearMobileAuthorizations() {
+    return this.mutate((state) => ({ ...state, devices: [], receipts: [] }));
+  }
+  ensureAdminToken() {
+    return this.enqueue(async () => {
+      const existing = await readSecretFile(this.adminTokenPath);
+      if (existing !== undefined) {
+        const token = existing.trim();
+        if (ADMIN_TOKEN_PATTERN.test(token))
+          return token;
+        throw new Error(`Invalid mobile admin token file ${this.adminTokenPath}: expected a base64url token`);
+      }
+      const token = randomBytes(MOBILE_ADMIN_TOKEN_BYTES).toString("base64url");
+      await writeSecretFile(this.adminTokenPath, `${token}
+`);
+      return token;
+    });
+  }
+  mutate(recipe) {
+    return this.enqueue(async () => {
+      const next = freezeState(recipe(this.current));
+      await writeFileAtomic(this.statePath, `${JSON.stringify(next, null, "\t")}
+`, 384);
+      this.current = next;
+      return next;
+    });
+  }
+  enqueue(task) {
+    const run = this.queue.then(task);
+    this.queue = run.then(() => {
+      return;
+    }, () => {
+      return;
+    });
+    return run;
+  }
+}
+
+// packages/gateway/src/mobile/admin.ts
+var listenerStateSchema = Type6.Union([
+  Type6.Object({ status: Type6.Literal("disabled") }),
+  Type6.Object({ status: Type6.Literal("starting") }),
+  Type6.Object({
+    status: Type6.Literal("listening"),
+    address: Type6.String(),
+    port: Type6.Integer({ minimum: 1, maximum: 65535 }),
+    bindAddress: Type6.Optional(Type6.String()),
+    mode: Type6.Optional(Type6.Union([Type6.Literal("direct"), Type6.Literal("wsl-relay")]))
+  }),
+  Type6.Object({ status: Type6.Literal("error"), error: Type6.String() }),
+  Type6.Object({ status: Type6.Literal("stopping") })
+]);
+var adminDeviceSchema = Type6.Object({
+  deviceId: Type6.String(),
+  name: Type6.String(),
+  pairedAt: Type6.Integer(),
+  lastSeenAt: Type6.Integer(),
+  online: Type6.Boolean()
+});
+var NekoMobileAdmin = contract("neko.mobile-admin", {
   version: 1,
-  input: Type6.Object({}, { additionalProperties: false }),
+  input: Type6.Object({ token: Type6.String() }),
   variants: {
-    ready: {
+    admin: {
       methods: {
-        list: rpc(Type6.Object({ query: Type6.Optional(str), workspaceRoot: Type6.Optional(str) }, { additionalProperties: false }), Type6.Array(marketSkill)),
-        detail: rpc(Type6.Object({ name: str, workspaceRoot: Type6.Optional(str) }, { additionalProperties: false }), marketSkill),
-        preview: rpc(Type6.Object({ name: str }, { additionalProperties: false }), preview),
-        install: rpc(Type6.Object({ name: str, scope, workspaceRoot: Type6.Optional(str), overwrite: Type6.Optional(bool) }, { additionalProperties: false }), installResult),
-        uninstall: rpc(Type6.Object({ name: str, scope, workspaceRoot: Type6.Optional(str) }, { additionalProperties: false }), nil)
+        state: rpc(Type6.Null(), Type6.Object({
+          state: listenerStateSchema,
+          candidates: Type6.Array(Type6.String()),
+          port: Type6.Integer({ minimum: 1, maximum: 65535 }),
+          certificate: Type6.Union([
+            Type6.Object({ fingerprint: Type6.String(), expiresAt: Type6.Integer() }),
+            Type6.Null()
+          ]),
+          devices: Type6.Array(adminDeviceSchema),
+          lastConnectedAddress: Type6.Union([Type6.String(), Type6.Null()]),
+          wsl: Type6.Optional(Type6.Union([
+            Type6.Object({ interop: Type6.Boolean(), error: Type6.Union([Type6.String(), Type6.Null()]) }),
+            Type6.Null()
+          ]))
+        })),
+        enable: rpc(Type6.Object({
+          address: Type6.String(),
+          port: Type6.Optional(Type6.Integer({ minimum: 1, maximum: 65535 }))
+        }), Type6.Object({
+          status: Type6.Literal("listening"),
+          address: Type6.String(),
+          port: Type6.Integer({ minimum: 1, maximum: 65535 }),
+          bindAddress: Type6.Optional(Type6.String()),
+          mode: Type6.Optional(Type6.Union([Type6.Literal("direct"), Type6.Literal("wsl-relay")]))
+        })),
+        disable: rpc(Type6.Null(), listenerStateSchema),
+        createPairing: rpc(Type6.Null(), Type6.Object({ pairingText: Type6.String(), expiresAt: Type6.Integer() })),
+        cancelPairing: rpc(Type6.Null(), Type6.Null()),
+        revoke: rpc(Type6.Object({ deviceId: Type6.String({ minLength: 1 }) }), Type6.Object({ revoked: Type6.Boolean() })),
+        regenerateCertificate: rpc(Type6.Null(), Type6.Object({ fingerprint: Type6.String(), expiresAt: Type6.Integer() }))
       }
     }
   }
 });
-var ApplicationInfoSchema = Type6.Object({
-  runningVersion: str,
-  installedVersion: nullableString,
-  protocolVersion: Type6.Integer({ minimum: 1 }),
-  latestVersion: nullableString,
-  checkedAt: Type6.Union([integer, nil]),
-  checkState: Type6.Enum(["unknown", "checking", "ok", "failed", "development"])
-});
-var NekoApplicationInfo = contract2("neko.application-info", {
-  version: 1,
-  input: Type6.Object({}),
-  variants: { ready: { state: { info: ApplicationInfoSchema }, methods: { check: rpc(nil, ApplicationInfoSchema) } } }
-});
+function digest(value) {
+  return createHash("sha256").update(value, "utf8").digest();
+}
+async function tokenMatches(token, store) {
+  if (store === undefined)
+    return false;
+  let adminToken;
+  try {
+    adminToken = await store.ensureAdminToken();
+  } catch {
+    return false;
+  }
+  const expected = digest(adminToken);
+  const provided = digest(token);
+  return expected.length === provided.length && timingSafeEqual(expected, provided);
+}
+function createMobileAdminFactory(deps) {
+  return (input, principal) => {
+    if (isMobilePrincipal(principal))
+      throw new ChordError("forbidden", "mobile principals cannot administer pairing");
+    const guard = async () => {
+      if (!await tokenMatches(input.token, deps.store))
+        throw new ChordError("forbidden", "forbidden");
+    };
+    return {
+      variant: "admin",
+      async state() {
+        await guard();
+        return deps.mobile.adminState();
+      },
+      async enable(params) {
+        await guard();
+        const state = await deps.mobile.enable({ address: params.address, port: params.port });
+        if (state.status !== "listening")
+          throw new ChordError("unavailable", `mobile listener failed: ${state.status}`);
+        return state;
+      },
+      async disable() {
+        await guard();
+        return deps.mobile.disable();
+      },
+      async createPairing() {
+        await guard();
+        return deps.mobile.createPairing();
+      },
+      async cancelPairing() {
+        await guard();
+        deps.mobile.cancelPairing();
+        return null;
+      },
+      async revoke(params) {
+        await guard();
+        return { revoked: await deps.mobile.revoke(params.deviceId) };
+      },
+      async regenerateCertificate() {
+        await guard();
+        return deps.mobile.regenerateCertificate();
+      }
+    };
+  };
+}
+
+// packages/gateway/src/mobile/listener.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { createServer } from "https";
+import { hostname } from "os";
+import { memoryLinkPair } from "@earendil-works/chord";
+import { WebSocketServer } from "ws";
 
 // packages/gateway/src/link.ts
-import { webSocketLink } from "@earendil-works/chord";
+import {
+  createHost,
+  webSocketLink
+} from "@earendil-works/chord";
 var MAX_LINK_BYTES = 16 * 1024 * 1024;
-var size = (text) => new TextEncoder().encode(text).byteLength;
-function boundedWebSocketLink(socket, max = MAX_LINK_BYTES) {
+var asBytes = (data) => data instanceof Uint8Array ? data : new Uint8Array(data);
+var size = (data) => typeof data === "string" ? new TextEncoder().encode(data).byteLength : data.byteLength;
+function boundedWebSocketLink(socket, max = MAX_LINK_BYTES, options) {
   let queued = 0, incoming = 0, receiving = false;
   let native;
   const bridge = {
@@ -21710,18 +22487,22 @@ function boundedWebSocketLink(socket, max = MAX_LINK_BYTES) {
     },
     close: (code, reason) => socket.close(code, reason),
     addEventListener(type, handler) {
-      if (type === "message")
-        socket.addEventListener("message", (event) => {
-          const bytes = size(String(event.data));
+      if (type === "message") {
+        const deliver = (data) => {
+          const bytes = size(data);
           if (!receiving)
             incoming += bytes;
           if (bytes > max || incoming > max) {
             native.close("frame limit exceeded");
             return;
           }
-          handler(event);
-        });
-      else
+          handler({ data });
+        };
+        if (socket.on)
+          socket.on("message", (data, isBinary) => deliver(isBinary ? asBytes(data) : new TextDecoder().decode(asBytes(data))));
+        else
+          socket.addEventListener("message", (event) => deliver(typeof event.data === "string" || event.data instanceof Uint8Array ? event.data : String(event.data)));
+      } else
         socket.addEventListener(type, () => {
           if (type === "open")
             queued = 0;
@@ -21733,7 +22514,7 @@ function boundedWebSocketLink(socket, max = MAX_LINK_BYTES) {
         });
     }
   };
-  native = webSocketLink(bridge);
+  native = webSocketLink(bridge, options);
   socket.addEventListener("error", () => native.close("socket error"));
   return {
     get closed() {
@@ -21753,7 +22534,7 @@ function boundedWebSocketLink(socket, max = MAX_LINK_BYTES) {
       }
       if (socket.readyState === 0)
         queued += bytes;
-      native.send(frame);
+      return native.send(frame);
     },
     receive(handler) {
       receiving = true;
@@ -21764,47 +22545,17 @@ function boundedWebSocketLink(socket, max = MAX_LINK_BYTES) {
     close: (reason) => native.close(reason)
   };
 }
-function identifiedLink(link, expectedName) {
-  let receiver;
-  let seen = false, pendingBytes = 0;
-  const pending = [];
-  link.receive((frame) => {
-    if (!seen) {
-      if (frame.t !== "hello" || frame.name !== expectedName) {
-        link.close("serverId mismatch");
-        return;
-      }
-      seen = true;
-    }
-    if (receiver)
-      receiver(frame);
-    else {
-      pendingBytes += size(JSON.stringify(frame));
-      if (pendingBytes > MAX_LINK_BYTES) {
-        link.close("receive queue limit exceeded");
-        pending.length = 0;
-        return;
-      }
-      pending.push(frame);
-    }
-  });
-  return {
-    get closed() {
-      return link.closed;
-    },
-    send: (frame) => link.send(frame),
-    receive(handler) {
-      receiver = handler;
-      pendingBytes = 0;
-      for (const frame of pending.splice(0)) {
-        if (link.closed)
-          break;
-        handler(frame);
-      }
+function createClientHost(link, options = {}) {
+  return createHost({
+    kind: "client",
+    self: { kind: "client" },
+    upstream: {
+      link,
+      principal: { kind: "server" },
+      ...options.onProtocolMismatch ? { onProtocolMismatch: options.onProtocolMismatch } : {}
     },
-    onClose: (handler) => link.onClose(handler),
-    close: (reason) => link.close(reason)
-  };
+    onError: () => {}
+  });
 }
 
 // packages/gateway/src/mobile/adapter.ts
@@ -21817,16 +22568,6 @@ var byMessage = (a, b) => messageTime(b) - messageTime(a) || Number(b.id) - Numb
 // packages/gateway/src/mobile/adapter.ts
 import { Check as Check2 } from "typebox/value";
 
-// packages/gateway/src/client-session.ts
-import { createHost } from "@earendil-works/chord";
-
-// packages/core/src/application-version.ts
-var RUNNING_VERSION = "0.4.2";
-var APPLICATION_PROTOCOL = 4;
-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/subagent-client.ts
 function subagentClient(connect) {
   let value;
@@ -21967,40 +22708,16 @@ function subagentClient(connect) {
   };
 }
 
-// packages/gateway/src/client-session.ts
-function waitForValue(state, signal) {
-  return new Promise((resolve, reject) => {
-    let stop = () => {};
-    let settled = false;
-    const finish = (error, value) => {
-      if (settled)
-        return;
-      settled = true;
-      clearTimeout(timer);
-      stop();
-      signal?.removeEventListener("abort", abort);
-      if (error)
-        reject(error);
-      else
-        resolve(value);
-    };
-    const abort = () => finish(signal?.reason ?? new Error("Cancelled"));
-    const timer = setTimeout(() => finish(new Error("Timed out waiting for first snapshot")), 5000);
-    stop = state.subscribe((value) => {
-      if (value !== undefined)
-        finish(undefined, value);
-    });
-    if (settled)
-      stop();
-    signal?.addEventListener("abort", abort, { once: true });
-    if (signal?.aborted)
-      abort();
-  });
-}
-
 // packages/gateway/src/mobile/projection.ts
 import { createHash as createHash2 } from "crypto";
 
+// packages/core/src/application-version.ts
+var RUNNING_VERSION = "0.4.4";
+var APPLICATION_PROTOCOL = 6;
+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 Type7 } from "typebox";
 import { Check } from "typebox/value";
@@ -22072,7 +22789,7 @@ function buildHelloResult(serverId, serverName, apiVersion) {
 var opt = Type7.Optional;
 var str2 = Type7.String();
 var int = Type7.Integer({ minimum: 0 });
-var nullable = (schema) => Type7.Union([schema, Type7.Null()]);
+var nullable2 = (schema) => Type7.Union([schema, Type7.Null()]);
 var MobileContentRefSchema = Type7.Object({
   sessionId: str2,
   agentId: opt(str2),
@@ -22161,7 +22878,7 @@ var MobileSubagentRoundSchema = Type7.Object({
   approvalCount: int,
   readonly: Type7.Boolean(),
   createdAt: Type7.Number(),
-  endedAt: nullable(Type7.Number()),
+  endedAt: nullable2(Type7.Number()),
   usage: opt(MobileUsageSchema)
 });
 var MobileAgentSchema = Type7.Object({
@@ -22169,18 +22886,25 @@ var MobileAgentSchema = Type7.Object({
   role: str2,
   title: str2,
   status: Type7.Union([Type7.Literal("idle"), Type7.Literal("queued"), Type7.Literal("running")]),
-  activeRoundId: nullable(int),
+  activeRoundId: nullable2(int),
   lastRoundId: int,
   roundCount: int,
   approvalCount: int
 });
+var MobileQueuedSchema = Type7.Object({
+  id: int,
+  mode: Type7.Union([Type7.Literal("steer"), Type7.Literal("followUp")]),
+  preview: Type7.String(),
+  images: int
+});
 var MobileChatStatusSchema = Type7.Object({
   busy: Type7.Boolean(),
-  status: nullable(str2),
+  queued: opt(Type7.Array(MobileQueuedSchema)),
+  status: nullable2(str2),
   usage: MobileUsageSchema,
   taskUsage: opt(MobileUsageSchema),
-  contextUsage: opt(Type7.Object({ tokens: nullable(Type7.Number()), window: Type7.Number(), percent: nullable(Type7.Number()) })),
-  agent: Type7.Object({ model: nullable(str2), thinkingLevel: nullable(str2) }),
+  contextUsage: opt(Type7.Object({ tokens: nullable2(Type7.Number()), window: Type7.Number(), percent: nullable2(Type7.Number()) })),
+  agent: Type7.Object({ model: nullable2(str2), thinkingLevel: nullable2(str2) }),
   subagents: Type7.Array(MobileSubagentRoundSchema),
   agents: Type7.Array(MobileAgentSchema),
   approvalCount: int,
@@ -22190,8 +22914,8 @@ var MobileChatStatusSchema = Type7.Object({
 var MobileChatSnapshotSchema = Type7.Object({
   ...MobileChatStatusSchema.properties,
   items: Type7.Array(MobileChatItemSchema),
-  historyBefore: nullable(str2),
-  streaming: nullable(MobileStreamingSchema)
+  historyBefore: nullable2(str2),
+  streaming: nullable2(MobileStreamingSchema)
 });
 var MobileWorkspaceSchema = Type7.Object({ root: str2, name: str2 });
 var MobileSessionSummarySchema = Type7.Object({
@@ -22224,7 +22948,7 @@ var sessionListResult = Type7.Object({
   nextCursor: opt(str2)
 });
 var subscription = { subscriptionId: Type7.String({ minLength: 1 }) };
-var pageResult = Type7.Object({ items: Type7.Array(MobileChatItemSchema), historyBefore: nullable(str2) });
+var pageResult = Type7.Object({ items: Type7.Array(MobileChatItemSchema), historyBefore: nullable2(str2) });
 var pageParams = Type7.Object({
   ...subscription,
   before: Type7.String({ minLength: 1 }),
@@ -22259,6 +22983,34 @@ var MOBILE_API_V1_METHODS = {
     params: Type7.Object({ ...subscription, requestId: Type7.String({ minLength: 1, maxLength: 128 }) }),
     result: Type7.Object({ status: Type7.Union([Type7.Literal("accepted"), Type7.Literal("unknown")]) })
   },
+  "chat.steer": {
+    params: Type7.Object({ ...subscription, id: int }),
+    result: Type7.Object({
+      result: Type7.Union([
+        Type7.Literal("steered"),
+        Type7.Literal("withdrawn"),
+        Type7.Literal("placed"),
+        Type7.Literal("settled"),
+        Type7.Literal("unknown")
+      ]),
+      id: opt(int),
+      text: opt(Type7.String()),
+      images: opt(int)
+    })
+  },
+  "chat.withdraw": {
+    params: Type7.Object({ ...subscription, id: int }),
+    result: Type7.Object({
+      result: Type7.Union([
+        Type7.Literal("withdrawn"),
+        Type7.Literal("placed"),
+        Type7.Literal("settled"),
+        Type7.Literal("unknown")
+      ]),
+      text: opt(Type7.String()),
+      images: opt(int)
+    })
+  },
   "chat.abort": { params: Type7.Object(subscription), result: Type7.Object({ accepted: Type7.Boolean() }) },
   "subagents.open": {
     params: Type7.Object({ ...subscription, agentId: opt(Type7.String({ minLength: 1 })), taskId: opt(int) }),
@@ -22338,7 +23090,7 @@ var patchBody = {
   seq: Type7.Integer({ minimum: 1 }),
   upserts: Type7.Array(MobileChatItemSchema),
   status: opt(MobileChatStatusSchema),
-  streaming: opt(nullable(MobileStreamingSchema)),
+  streaming: opt(nullable2(MobileStreamingSchema)),
   streamingAppend: opt(Type7.Object({ text: opt(str2), thinking: opt(str2) }))
 };
 var MOBILE_API_V1_NOTIFICATIONS = {
@@ -22546,6 +23298,9 @@ function mapStatus(view, options = {}) {
   const latest = view.compaction?.latest;
   return {
     busy: view.busy,
+    ...view.queued === undefined ? {} : {
+      queued: view.queued.map(({ id, mode, preview, images }) => ({ id, mode, preview, images }))
+    },
     status: view.status,
     usage: mapUsage(view.usage),
     ...view.taskUsage === undefined ? {} : { taskUsage: mapUsage(view.taskUsage) },
@@ -22850,7 +23605,7 @@ function chordToMobileCode(error) {
       return "internal";
   }
 }
-async function remote3(work, invalidAs = "invalid_params") {
+async function remote2(work, invalidAs = "invalid_params") {
   try {
     return await work();
   } catch (error) {
@@ -23032,6 +23787,10 @@ class MobileAdapter {
         return this.chatSubmit(params);
       case "chat.submissionStatus":
         return this.chatSubmissionStatus(params);
+      case "chat.steer":
+        return this.chatSteer(params);
+      case "chat.withdraw":
+        return this.chatWithdraw(params);
       case "chat.abort":
         return this.chatAbort(params);
       case "subagents.open":
@@ -23064,14 +23823,17 @@ class MobileAdapter {
     }
   }
   async workspacesList() {
-    const state = await waitForValue(this.services().workspaces.state);
+    const { workspaces } = this.services();
+    await workspaces.ready;
+    const state = workspaces.state.value;
     return {
       workspaces: state.workspaces.map((workspace) => ({ root: workspace.path, name: baseName(workspace.path) }))
     };
   }
   async registeredWorkspaceRoots() {
-    const state = await waitForValue(this.services().workspaces.state);
-    return state.workspaces.map((workspace) => workspace.path);
+    const { workspaces } = this.services();
+    await workspaces.ready;
+    return workspaces.state.value.workspaces.map((workspace) => workspace.path);
   }
   async sessionsList(params) {
     const roots = await this.registeredWorkspaceRoots();
@@ -23080,7 +23842,9 @@ class MobileAdapter {
     const offset = params.cursor === undefined ? 0 : Number.parseInt(params.cursor, 10);
     if (!Number.isInteger(offset) || offset < 0)
       throw new MobileMethodError("invalid_params", "invalid cursor");
-    const directory = await waitForValue(this.services().directory.state);
+    const { directory: directoryRef } = this.services();
+    await directoryRef.ready;
+    const directory = directoryRef.state.value;
     let sessions = directory.sessions.filter((session) => session.workspaceRoot === params.workspace);
     if (params.query !== undefined) {
       const query = params.query.toLowerCase();
@@ -23106,7 +23870,7 @@ class MobileAdapter {
     if (!roots.includes(params.workspace))
       throw new MobileMethodError("invalid_params", `unknown workspace: ${params.workspace}`);
     this.assertAuthorized();
-    const created = await remote3(() => this.services().management.create({ cwd: params.workspace }));
+    const created = await remote2(() => this.services().management.create({ cwd: params.workspace }));
     return {
       id: created.id,
       workspace: created.workspaceRoot,
@@ -23143,16 +23907,13 @@ class MobileAdapter {
     const generation = ++this.attachGeneration;
     this.closeSubagent();
     this.releaseChat();
-    const attachment = await remote3(() => services.management.attach(params.sessionId));
+    const attachment = await remote2(() => services.management.attach(params.sessionId));
     if (generation !== this.attachGeneration || this.disposed)
       throw new MobileMethodError("gone", "superseded by a newer attach");
     const chat = services.openChat(attachment);
     const stopView = chat.view.subscribe(() => {});
     try {
-      await remote3(async () => {
-        await chat.ready;
-        await waitForValue(chat.view);
-      });
+      await remote2(() => chat.ready);
     } catch (error) {
       stopView();
       chat.release();
@@ -23214,7 +23975,7 @@ class MobileAdapter {
     this.attachGeneration += 1;
     this.closeSubagent();
     this.releaseChat();
-    await remote3(() => this.services().management.detach(null)).catch(() => {
+    await remote2(() => this.services().management.detach(null)).catch(() => {
       return;
     });
     return null;
@@ -23245,7 +24006,7 @@ class MobileAdapter {
     const state = this.requireChat(params);
     const busy = state.chat.view.value?.busy ?? false;
     this.assertAuthorized();
-    await remote3(() => state.chat.submit({
+    await remote2(() => state.chat.submit({
       content: params.text,
       requestId: params.requestId,
       ...params.mode === "steer" ? { whenBusy: "steer" } : {}
@@ -23259,10 +24020,20 @@ class MobileAdapter {
     const accepted = await this.runtime.submissionAccepted(state.sessionId, params.requestId);
     return { status: accepted ? "accepted" : "unknown" };
   }
+  async chatSteer(params) {
+    const state = this.requireChat(params);
+    this.assertAuthorized();
+    return remote2(() => state.chat.steer({ id: params.id }), "rejected");
+  }
+  async chatWithdraw(params) {
+    const state = this.requireChat(params);
+    this.assertAuthorized();
+    return remote2(() => state.chat.withdraw({ id: params.id }), "rejected");
+  }
   async chatAbort(params) {
     const state = this.requireChat(params);
     this.assertAuthorized();
-    await remote3(() => state.chat.abort(null));
+    await remote2(() => state.chat.abort(null));
     return { accepted: true };
   }
   async approvalRecords(state) {
@@ -23341,7 +24112,7 @@ class MobileAdapter {
     this.assertAuthorized();
     const handle = openSubagent({ ...state.attachment, taskId: params.taskId });
     try {
-      const status = await remote3(() => handle.decideApproval({
+      const status = await remote2(() => handle.decideApproval({
         id: params.id,
         version: params.version,
         decision: params.decision === "allow" ? "allowed" : "denied"
@@ -23421,7 +24192,7 @@ class MobileAdapter {
         return () => listeners.delete(listener);
       },
       older: async (before) => {
-        const page = await remote3(() => client.history({ before }));
+        const page = await remote2(() => client.history({ before }));
         return { items: page.items, next: page.next };
       }
     };
@@ -23465,7 +24236,7 @@ class MobileAdapter {
     this.assertAuthorized();
     const handle = openSubagent({ ...chat.attachment, taskId: params.taskId });
     try {
-      await remote3(() => handle.stop({ taskId: params.taskId }));
+      await remote2(() => handle.stop({ taskId: params.taskId }));
     } finally {
       handle.release();
     }
@@ -23479,9 +24250,9 @@ class MobileAdapter {
       const state = this.subagentState;
       if (state === undefined || state.agentId !== params.agentId || state.chatSubscriptionId !== chat.subscriptionId)
         throw new MobileMethodError("gone", "subagent view is no longer open");
-      chunk = await remote3(() => state.client.getImage(input));
+      chunk = await remote2(() => state.client.getImage(input));
     } else {
-      chunk = await remote3(() => chat.chat.getImage(input));
+      chunk = await remote2(() => chat.chat.getImage(input));
     }
     const bytes = Buffer.from(chunk.data, "base64").subarray(0, MOBILE_LIMITS.chunkBytes);
     const nextOffset = params.offset + bytes.length;
@@ -24412,9 +25183,6 @@ function describeRelayError(error, address, port, bindAddress) {
       return `Windows \u4E2D\u7EE7\u542F\u52A8\u5931\u8D25\uFF1A${error.message}`;
   }
 }
-function isMobilePrincipal2(principal) {
-  return typeof principal === "object" && principal !== null && principal.kind === "mobile";
-}
 function toMessage(error) {
   if (error instanceof Error) {
     const code = error.code;
@@ -24593,7 +25361,7 @@ class MobileGateway {
     await store.clearMobileAuthorizations();
     this.certificate = certificate;
     this.pairingValue?.invalidate();
-    await this.chord.invalidatePrincipal(isMobilePrincipal2);
+    await this.chord.invalidatePrincipal(isMobilePrincipal);
     for (const connection of [...this.connections.values()])
       connection.close(MOBILE_CLOSE_REVOKED, "revoked");
     const current = this.stateValue;
@@ -24669,11 +25437,7 @@ class MobileGateway {
         store.rememberConnectedAddress(learned).catch((error) => this.onError?.(toError(error)));
       }
     }
-    const clientHost = createHost2({
-      kind: "client",
-      upstream: identifiedLink(clientEnd, this.serverId),
-      onError: () => {}
-    });
+    const clientHost = createClientHost(clientEnd);
     let servicesValue;
     const adapter = new MobileAdapter({
       socket,
@@ -24685,11 +25449,11 @@ class MobileGateway {
       services: () => {
         if (servicesValue === undefined) {
           servicesValue = {
-            directory: clientHost.get(NekoSessionDirectory, {}, { at: this.serverId }),
-            management: clientHost.get(NekoSessionManagement, {}, { at: this.serverId }),
-            workspaces: clientHost.get(NekoWorkspaces, {}, { at: this.serverId }),
-            openChat: (attachment) => clientHost.get(NekoChat, attachment, { at: this.serverId }),
-            openSubagent: (input) => clientHost.get(NekoSubagent, input, { at: this.serverId })
+            directory: clientHost.hold(NekoSessionDirectory, {}),
+            management: clientHost.hold(NekoSessionManagement, {}),
+            workspaces: clientHost.hold(NekoWorkspaces, {}),
+            openChat: (attachment) => clientHost.hold(NekoChat, attachment),
+            openSubagent: (input) => clientHost.hold(NekoSubagent, input)
           };
         }
         return servicesValue;
@@ -24713,10 +25477,13 @@ class MobileGateway {
     if (this.notificationCleanup !== undefined)
       return;
     const [serverEnd, clientEnd] = memoryLinkPair();
-    this.chord.accept(serverEnd, { principal: { connectionId: "mobile-notification-hub" }, kind: "client" });
-    const host = createHost2({ kind: "client", upstream: identifiedLink(clientEnd, this.serverId), onError: () => {} });
-    const directory = host.get(NekoSessionDirectory, {}, { at: this.serverId });
-    const workspaces = host.get(NekoWorkspaces, {}, { at: this.serverId });
+    this.chord.accept(serverEnd, {
+      principal: { kind: "local", connectionId: "mobile-notification-hub" },
+      kind: "client"
+    });
+    const host = createClientHost(clientEnd);
+    const directory = host.hold(NekoSessionDirectory, {});
+    const workspaces = host.hold(NekoWorkspaces, {});
     const last = { directory: -1, workspaces: -1 };
     const unsubscribe = [
       directory.state.subscribe(() => {
@@ -25013,14 +25780,7 @@ async function removeGatewayPortFile(nekoDir, serverId) {
 
 // packages/gateway/src/server-services.ts
 import { randomUUID as randomUUID4 } from "crypto";
-import {
-  ChordError as ChordError5,
-  cell as cell3,
-  hostPrincipal as hostPrincipal3,
-  listener as listener3,
-  local as local3,
-  method as method3
-} from "@earendil-works/chord";
+import { ChordError as ChordError5, local as local3, method as method2 } from "@earendil-works/chord";
 
 // packages/core/src/application-updates.ts
 import { mkdir as mkdir3, readFile as readFile6, rename as rename3, rm as rm3, writeFile as writeFile3 } from "fs/promises";
@@ -25177,12 +25937,8 @@ import { open as open2 } from "fs/promises";
 import { basename as basename3, extname } from "path";
 import {
   ChordError as ChordError4,
-  cell as cell2,
-  hostPrincipal as hostPrincipal2,
-  listener as listener2,
   local as local2,
-  opaque as opaque2,
-  resource as resource2
+  opaque as opaque2
 } from "@earendil-works/chord";
 import { withAbortSignal as withAbortSignal4 } from "@earendil-works/chord/context";
 import { UsageDoc as UsageDoc4 } from "@earendil-works/pi-durable";
@@ -25283,15 +26039,7 @@ class ImageUploads {
 }
 
 // packages/gateway/src/subagent-host.ts
-import {
-  ChordError as ChordError3,
-  cell,
-  hostPrincipal,
-  listener,
-  local,
-  opaque,
-  resource
-} from "@earendil-works/chord";
+import { ChordError as ChordError3, local, opaque } from "@earendil-works/chord";
 import { UsageDoc as UsageDoc3 } from "@earendil-works/pi-durable";
 import { Type as Type8 } from "typebox";
 async function openReader(runtime, childId, parentId, context, through, historyUsage) {
@@ -25426,31 +26174,27 @@ var ChildProjection = local("neko.subagent-projection", {
 });
 function installSubagentHost(host, runtime, context) {
   host.serve(ChildProjection, (input, _principal, self2) => {
-    const { revision } = self2.state({ revision: cell(Type8.Integer(), 0) });
-    const { reader } = self2.resources({
-      reader: resource({
-        rev: 1,
-        async open() {
-          const entry = (await listDelegations(runtime.harness, input.parentId, context)).find((d) => input.agentId.startsWith("round-") ? d.taskId === Number(input.agentId.slice(6)) : (d.agentId ?? agentIdFor(d.childId)) === input.agentId);
-          if (!entry)
-            throw new ChordError3("gone", "Subagent unavailable");
-          const r = await openReader(runtime, entry.childId, input.parentId, context, entry.historyThrough, entry.historyUsage);
-          try {
-            const initial = await r.refresh();
-            await host.root((ctx) => revision.replace(ctx, initial));
-            return r;
-          } catch (error) {
-            r.close();
-            throw error;
-          }
-        },
-        close: (r) => r.close()
-      })
+    const revision = self2.state("revision", Type8.Integer(), 0);
+    const reader = self2.resource("reader", {
+      version: 1,
+      async open() {
+        const entry = (await listDelegations(runtime.harness, input.parentId, context)).find((d) => input.agentId.startsWith("round-") ? d.taskId === Number(input.agentId.slice(6)) : (d.agentId ?? agentIdFor(d.childId)) === input.agentId);
+        if (!entry)
+          throw new ChordError3("gone", "Subagent unavailable");
+        const r = await openReader(runtime, entry.childId, input.parentId, context, entry.historyThrough, entry.historyUsage);
+        try {
+          const initial = await r.refresh();
+          await host.root((ctx) => revision.replace(ctx, initial));
+          return r;
+        } catch (error) {
+          r.close();
+          throw error;
+        }
+      },
+      close: (r) => r.close()
     });
-    self2.listen({
-      view: listener(reader, (r) => r, async (_event, ctx) => {
-        revision.replace(ctx, await reader.value.refresh());
-      })
+    self2.on("view", reader, (r) => r, async (_event, ctx) => {
+      revision.replace(ctx, await reader.value.refresh());
     });
     return { revision, reader: self2.expose(reader) };
   });
@@ -25466,23 +26210,24 @@ function installSubagentHost(host, runtime, context) {
         throw new ChordError3("forbidden", "Subagent does not belong to this session");
       return entry;
     };
-    const { target } = self2.resources({ target: resource({ rev: 1, deps: [owner], open: check }) });
-    const shared = self2.get(ChildProjection, { parentId: Number(input.sessionId), agentId: input.agentId ?? `round-${input.taskId}` }, { principal: hostPrincipal });
-    const { authorizedRevision } = self2.state({ authorizedRevision: cell(Type8.Integer(), 0) });
-    self2.listen({
-      authorizedView: listener(shared.revision, async (value, ctx) => {
-        try {
-          target.value;
-          await check();
-          if (value)
-            authorizedRevision.replace(ctx, value);
-        } catch {
-          authorizedRevision.replace(ctx, 0);
-        }
-      })
+    const target = self2.resource("target", { version: 1, deps: [owner], open: check });
+    const shared = self2.get(ChildProjection, {
+      parentId: Number(input.sessionId),
+      agentId: input.agentId ?? `round-${input.taskId}`
+    });
+    const authorizedRevision = self2.state("authorizedRevision", Type8.Integer(), 0);
+    self2.on("authorizedView", shared.revision, async (value, ctx) => {
+      try {
+        target.value;
+        await check();
+        if (value)
+          authorizedRevision.replace(ctx, value);
+      } catch {
+        authorizedRevision.replace(ctx, 0);
+      }
     });
     return {
-      kind: "ready",
+      variant: "ready",
       revision: authorizedRevision,
       chunk: async (request) => {
         await check();
@@ -25542,6 +26287,7 @@ var emptyView = {
   agent: { model: null, thinkingLevel: null },
   cwd: "",
   busy: false,
+  queued: [],
   status: null,
   usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 },
   items: [],
@@ -25638,65 +26384,61 @@ async function openProjection(runtime, session, context) {
 function serveSessions(host, runtime, context) {
   installSubagentHost(host, runtime, context);
   host.serve(Owner, (_input, _principal, self2) => {
-    const { owner } = self2.resources({
-      owner: resource2({
-        rev: 1,
-        open: () => ({ active: null }),
-        close: (value) => {
-          value.active = null;
-        }
-      })
+    const owner = self2.resource("owner", {
+      version: 1,
+      open: () => ({ active: null }),
+      close: (value) => {
+        value.active = null;
+      }
     });
     return { owner: self2.expose(owner) };
   });
   host.serve(Projection, (input, _principal, self2) => {
-    const { view } = self2.state({ view: cell2(ChatViewSchema, emptyView) });
-    const { projection } = self2.resources({
-      projection: resource2({
-        rev: 1,
-        async open({ signal }) {
-          const session = await runtime.getConversation(Number(input.id));
-          if (!session)
-            throw new ChordError4("gone", "Session unavailable");
-          const opened = await openProjection(runtime, session, context);
-          try {
-            const initial = await opened.project();
-            await host.root((ctx) => view.replace(ctx, initial), { signal });
-            return opened;
-          } catch (error) {
-            opened.close();
-            throw error;
-          }
-        },
-        close: (value) => value.close()
-      })
+    const view = self2.state("view", ChatViewSchema, emptyView);
+    const projection = self2.resource("projection", {
+      version: 1,
+      async open({ signal }) {
+        const session = await runtime.getConversation(Number(input.id));
+        if (!session)
+          throw new ChordError4("gone", "Session unavailable");
+        const opened = await openProjection(runtime, session, context);
+        try {
+          const initial = await opened.project();
+          await host.root((ctx) => view.replace(ctx, initial), { signal });
+          return opened;
+        } catch (error) {
+          opened.close();
+          throw error;
+        }
+      },
+      close: (value) => value.close()
     });
-    self2.listen({
-      view: listener2(projection, (value) => value, async (_event, ctx) => {
-        view.replace(ctx, await projection.value.project());
-      })
+    self2.on("view", projection, (value) => value, async (_event, ctx) => {
+      view.replace(ctx, await projection.value.project());
     });
     return { view, reader: self2.expose(projection) };
   });
   host.serve(NekoChat, (input, principal, self2) => {
     const owner = self2.get(Owner, {}, { principal });
-    const shared = self2.get(Projection, { id: input.sessionId }, { principal: hostPrincipal2 });
-    const { uploads, projection } = self2.resources({
-      uploads: resource2({ rev: 1, open: () => new ImageUploads, close: (value) => value.close() }),
-      projection: resource2({
-        rev: 1,
-        deps: [owner],
-        async open() {
-          if (owner.owner?.active?.attachmentId !== input.attachmentId || owner.owner.active.sessionId !== input.sessionId)
-            throw new ChordError4("forbidden", "Attachment does not belong to this connection");
-          const session = await runtime.getConversation(Number(input.sessionId));
-          if (!session)
-            throw new ChordError4("gone", "Session unavailable");
-          return {
-            session
-          };
-        }
-      })
+    const shared = self2.get(Projection, { id: input.sessionId });
+    const uploads = self2.resource("uploads", {
+      version: 1,
+      open: () => new ImageUploads,
+      close: (value) => value.close()
+    });
+    const projection = self2.resource("projection", {
+      version: 1,
+      deps: [owner],
+      async open() {
+        if (owner.owner?.active?.attachmentId !== input.attachmentId || owner.owner.active.sessionId !== input.sessionId)
+          throw new ChordError4("forbidden", "Attachment does not belong to this connection");
+        const session = await runtime.getConversation(Number(input.sessionId));
+        if (!session)
+          throw new ChordError4("gone", "Session unavailable");
+        return {
+          session
+        };
+      }
     });
     const safeUpload = (action) => {
       try {
@@ -25706,7 +26448,7 @@ function serveSessions(host, runtime, context) {
       }
     };
     const behavior = {
-      kind: "ready",
+      variant: "ready",
       view: shared.view,
       draftImage: async ({ id, offset }) => safeUpload(() => uploads.value.read(id, offset)),
       importImage: async (path, ctx) => {
@@ -25813,6 +26555,8 @@ function serveSessions(host, runtime, context) {
         await projection.value.session.abort();
         return null;
       },
+      withdraw: ({ id }) => projection.value.session.withdraw(id),
+      steer: ({ id }) => projection.value.session.steer(id),
       skills: () => runtime.listSkills(projection.value.session.id),
       jobOutput: async ({ jobId, since }) => {
         try {
@@ -26568,7 +27312,11 @@ var ServerState = local3("neko.server-state", {
     directory: DirectoryStateSchema,
     workspaces: WorkspaceStateSchema,
     credentials: CredentialStateSchema,
-    refreshCredentials: method3(Type10.Null(), Type10.Null())
+    searchSettings: SearchSettingsStateSchema,
+    contextSettings: ContextSettingsStateSchema,
+    refreshCredentials: method2(Type10.Null(), Type10.Null()),
+    refreshSearchSettings: method2(Type10.Null(), Type10.Null()),
+    refreshContextSettings: method2(Type10.Null(), Type10.Null())
   }
 });
 async function createNekoServerServices(options) {
@@ -26576,6 +27324,7 @@ async function createNekoServerServices(options) {
   const updates = new UpdateChecker(options.updates);
   await updates.local();
   const updateListeners = new Set;
+  const info = (value) => ({ ...value, serverId: options.serverId });
   let published = JSON.stringify(updates.state), closed = false;
   const publishUpdates = () => {
     if (closed)
@@ -26588,22 +27337,20 @@ async function createNekoServerServices(options) {
       listener(updates.state);
   };
   host.serve(NekoApplicationInfo, (_input, _principal, self2) => {
-    const state = self2.state({ info: cell3(ApplicationInfoSchema, updates.state) });
-    self2.listen({
-      updates: listener3({
-        subscribe: (fn) => {
-          updateListeners.add(fn);
-          return () => updateListeners.delete(fn);
-        }
-      }, (value, ctx) => state.info.replace(ctx, value))
-    });
+    const current = self2.state("info", ApplicationInfoSchema, info(updates.state));
+    self2.on("updates", {
+      subscribe: (fn) => {
+        updateListeners.add(fn);
+        return () => updateListeners.delete(fn);
+      }
+    }, (value, ctx) => current.replace(ctx, info(value)));
     return {
-      kind: "ready",
-      info: state.info,
+      variant: "ready",
+      info: current,
       check: async () => {
         await updates.check(true);
         publishUpdates();
-        return updates.state;
+        return info(updates.state);
       }
     };
   });
@@ -26647,7 +27394,13 @@ async function createNekoServerServices(options) {
     status: info.status
   }));
   const readStatuses = async () => Object.fromEntries(await Promise.all(CREDENTIAL_PROVIDERS.map(async (spec) => [spec.id, await runtime.credentialStatus(spec.id)])));
-  const [sessions, workspaces, statuses] = await Promise.all([list(), runtime.listWorkspaces(), readStatuses()]);
+  const [sessions, workspaces, statuses, search, contextSettings0] = await Promise.all([
+    list(),
+    runtime.listWorkspaces(),
+    readStatuses(),
+    runtime.searchSettings(),
+    runtime.contextSettings()
+  ]);
   let mutationTail = Promise.resolve();
   const serialize = (fn) => {
     const result = mutationTail.catch(() => {}).then(fn);
@@ -26655,43 +27408,64 @@ async function createNekoServerServices(options) {
     return result;
   };
   host.serve(ServerState, (_input, _principal, self2) => {
-    const state = self2.state({
-      directory: cell3(DirectoryStateSchema, { revision: 1, sessions }),
-      workspaces: cell3(WorkspaceStateSchema, { revision: 1, workspaces }),
-      credentials: cell3(CredentialStateSchema, { revision: 1, statuses })
+    const directory = self2.state("directory", DirectoryStateSchema, { revision: 1, sessions });
+    const workspaceState = self2.state("workspaces", WorkspaceStateSchema, { revision: 1, workspaces });
+    const credentials = self2.state("credentials", CredentialStateSchema, { revision: 1, statuses });
+    const searchSettings = self2.state("searchSettings", SearchSettingsStateSchema, { revision: 1, ...search });
+    const contextSettings = self2.state("contextSettings", ContextSettingsStateSchema, {
+      revision: 1,
+      ...contextSettings0
     });
-    self2.listen({
-      directory: listener3({ subscribe: runtime.harness.subscribeCommits.bind(runtime.harness) }, async (event, ctx) => {
-        if (!event.changes.some((change) => change.type === "conversation" || change.type === "document" && [
-          "app.neko.session-metadata",
-          "app.neko.activity",
-          "app.neko.conversation",
-          "app.neko.workspaces",
-          "pi.agent"
-        ].includes(change.record.kind)))
-          return;
-        await serialize(async () => {
-          const [items, roots] = await Promise.all([list(), runtime.listWorkspaces()]);
-          state.directory.replace(ctx, { revision: state.directory.value.revision + 1, sessions: items });
-          state.workspaces.replace(ctx, { revision: state.workspaces.value.revision + 1, workspaces: roots });
-        });
-      })
+    const refreshContextSettings = async (_input, ctx) => {
+      const next = await runtime.contextSettings();
+      const { revision, ...current } = contextSettings.value;
+      if (JSON.stringify(next) !== JSON.stringify(current))
+        contextSettings.replace(ctx, { revision: revision + 1, ...next });
+      return null;
+    };
+    const refreshSearchSettings = async (_input, ctx) => {
+      const next = await runtime.searchSettings();
+      const current = searchSettings.value;
+      if (next.selected !== current.selected)
+        searchSettings.replace(ctx, { revision: current.revision + 1, ...next });
+      return null;
+    };
+    self2.on("directory", { subscribe: runtime.harness.subscribeCommits.bind(runtime.harness) }, async (event, ctx) => {
+      if (!event.changes.some((change) => change.type === "conversation" || change.type === "document" && [
+        "app.neko.session-metadata",
+        "app.neko.activity",
+        "app.neko.conversation",
+        "app.neko.workspaces",
+        "pi.agent"
+      ].includes(change.record.kind)))
+        return;
+      await serialize(async () => {
+        const [items, roots] = await Promise.all([list(), runtime.listWorkspaces()]);
+        directory.replace(ctx, { revision: directory.value.revision + 1, sessions: items });
+        workspaceState.replace(ctx, { revision: workspaceState.value.revision + 1, workspaces: roots });
+      });
     });
     return {
-      ...state,
+      directory,
+      workspaces: workspaceState,
+      credentials,
+      searchSettings,
+      contextSettings,
       async refreshCredentials(_input, ctx) {
-        state.credentials.replace(ctx, {
-          revision: state.credentials.value.revision + 1,
+        credentials.replace(ctx, {
+          revision: credentials.value.revision + 1,
           statuses: await readStatuses()
         });
         return null;
-      }
+      },
+      refreshSearchSettings,
+      refreshContextSettings
     };
-  }, { eager: { input: {} } });
-  const shared = (self2) => self2.get(ServerState, {}, { principal: hostPrincipal3 });
-  host.serve(NekoSessionDirectory, (_input, _principal, self2) => ({ kind: "ready", state: shared(self2).directory }));
+  }, { lifetime: "host" });
+  const shared = (self2) => self2.get(ServerState, {});
+  host.serve(NekoSessionDirectory, (_input, _principal, self2) => ({ variant: "ready", state: shared(self2).directory }));
   host.serve(NekoWorkspaces, (_input, _principal, self2) => ({
-    kind: "ready",
+    variant: "ready",
     state: shared(self2).workspaces,
     browse: (input) => browseWorkspaces(input),
     add: (input) => serialize(() => runtime.addWorkspace(input.path))
@@ -26699,7 +27473,7 @@ async function createNekoServerServices(options) {
   host.serve(NekoCredentials, (_input, _principal, self2) => {
     const hub = shared(self2);
     return {
-      kind: "ready",
+      variant: "ready",
       state: hub.credentials,
       save: async (input, ctx) => {
         await runtime.saveCredential(input.provider, input.key);
@@ -26711,8 +27485,34 @@ async function createNekoServerServices(options) {
       }
     };
   });
+  host.serve(NekoSearchSettings, (_input, _principal, self2) => {
+    const hub = shared(self2);
+    return {
+      variant: "ready",
+      state: hub.searchSettings,
+      set: (input, ctx) => serialize(async () => {
+        await runtime.setSearchProvider(input.provider);
+        return hub.refreshSearchSettings(null, ctx);
+      })
+    };
+  });
+  host.serve(NekoContextSettings, (_input, _principal, self2) => {
+    const hub = shared(self2);
+    return {
+      variant: "ready",
+      state: hub.contextSettings,
+      set: (input, ctx) => serialize(async () => {
+        await runtime.setContextSettings(input);
+        return hub.refreshContextSettings(null, ctx);
+      }),
+      reset: (_input, ctx) => serialize(async () => {
+        await runtime.resetContextSettings();
+        return hub.refreshContextSettings(null, ctx);
+      })
+    };
+  });
   host.serve(NekoModels, () => ({
-    kind: "ready",
+    variant: "ready",
     list: async () => [...runtime.listModels()].map((value) => ({
       ...value,
       input: [...value.input],
@@ -26720,7 +27520,7 @@ async function createNekoServerServices(options) {
     }))
   }));
   host.serve(NekoWorkspaceFiles, () => ({
-    kind: "ready",
+    variant: "ready",
     search: async (input, ctx) => {
       const roots = await runtime.listWorkspaces();
       if (!roots.some((root) => root.path === input.workspaceRoot))
@@ -26738,7 +27538,7 @@ async function createNekoServerServices(options) {
       return found;
     };
     return {
-      kind: "ready",
+      variant: "ready",
       create: (input) => serialize(async () => summary((await runtime.createConversation(input)).id)),
       fork: (id) => serialize(async () => summary((await runtime.forkConversation(toConversationId(id))).id)),
       archive: async (id) => {
@@ -26761,7 +27561,7 @@ async function createNekoServerServices(options) {
     };
   });
   host.serve(NekoSkillMarket, () => ({
-    kind: "ready",
+    variant: "ready",
     list: (input) => market.list(input.query).then((skills) => Promise.all(skills.map((skill) => withInstallState(skill, input.workspaceRoot)))).catch(toRemote),
     detail: (input) => market.detail(input.name).then((skill) => withInstallState(skill, input.workspaceRoot)).catch(toRemote),
     preview: (input) => market.preview(input.name).then((value) => ({ ...value, files: [...value.files] })).catch(toRemote),
@@ -26876,7 +27676,7 @@ class UnixLink {
   }
   send(frame) {
     try {
-      this.#native.send(frame);
+      return this.#native.send(frame);
     } catch (error) {
       this.#native.close("pending byte limit exceeded");
       throw error;
@@ -26985,7 +27785,7 @@ function createWsListener(options) {
       server.on("error", (error) => options.onError?.(error));
       server.on("connection", (socket) => {
         socket.on("error", (error) => options.onError?.(error));
-        accept(boundedWebSocketLink(socket, options.maxPendingBytes));
+        accept(boundedWebSocketLink(socket, options.maxPendingBytes, { acceptPacked: false }));
       });
     },
     async close() {
@@ -27011,6 +27811,7 @@ async function startGateway(options = {}) {
   const storagePath = options.storagePath ?? fileConfig.storagePath ?? DEFAULT_STORAGE_PATH;
   const host = options.host ?? fileConfig.gateway?.host ?? DEFAULT_HOST;
   const port = options.port !== undefined ? options.port : fileConfig.gateway?.port ?? (process.platform === "win32" ? 0 : DEFAULT_PORT);
+  const searchProvider = options.searchProvider ?? fileConfig.webSearch?.provider;
   const marketUrl = options.marketUrl ?? fileConfig.skills?.marketUrl ?? DEFAULT_SKILL_MARKET_URL;
   const nekoDir = dirname9(storagePath);
   const serverId = options.serverId ?? await loadOrCreateServerId(nekoDir);
@@ -27022,6 +27823,8 @@ async function startGateway(options = {}) {
     ...options.storage !== "memory" ? { storagePath } : {},
     ...options.credentialsPath !== undefined ? { credentialsPath: options.credentialsPath } : {},
     ...options.apiKey !== undefined ? { apiKey: options.apiKey } : {},
+    ...searchProvider !== undefined ? { searchProvider } : {},
+    ...fileConfig.context !== undefined ? { contextSettings: fileConfig.context } : {},
     model,
     thinkingLevel: options.thinkingLevel ?? fileConfig.thinkingLevel ?? "high",
     ...options.cwd !== undefined ? { cwd: options.cwd } : {},
@@ -27052,8 +27855,9 @@ async function startGateway(options = {}) {
 }
 async function bindGateway(runtime, options) {
   const { context, host, port, socketPath, serverId, nekoDir } = options;
-  const chord = createHost3({
-    name: serverId,
+  const chord = createHost2({
+    name: GATEWAY_HOST,
+    self: HOST_PRINCIPAL,
     dev: true,
     onError: (error) => options.onError?.(error instanceof Error ? error : new Error(String(error))),
     principalKey: gatewayPrincipalKey
@@ -27062,6 +27866,7 @@ async function bindGateway(runtime, options) {
     host: chord,
     runtime,
     context,
+    serverId,
     marketUrl: options.marketUrl,
     ...options.updates ? { updates: options.updates } : {},
     ...options.updateIntervalMs ? { updateIntervalMs: options.updateIntervalMs } : {},
@@ -27077,7 +27882,10 @@ async function bindGateway(runtime, options) {
   }
   try {
     for (const listener of listeners)
-      await listener.start((link) => chord.accept(link, { principal: { connectionId: randomUUID5() } }));
+      await listener.start((link) => chord.accept(link, {
+        principal: { kind: "local", connectionId: randomUUID5() },
+        onProtocolMismatch: ({ peer }) => options.onError?.(new Error(`Rejected a client on Chord protocol ${peer ?? "unknown"}; restart or update it.`))
+      }));
   } catch (error) {
     await Promise.allSettled(listeners.map((listener) => listener.close()));
     await chord.close();
@@ -27140,16 +27948,6 @@ async function bindGateway(runtime, options) {
   }).catch((error) => options.onError?.(error instanceof Error ? error : new Error(String(error))));
   return gateway;
 }
-function gatewayPrincipalKey(principal) {
-  if (typeof principal === "object" && principal !== null) {
-    const record = principal;
-    if (record.kind === "mobile" && typeof record.deviceId === "string" && typeof record.grantRevision === "number") {
-      const connectionId = typeof record.connectionId === "string" ? record.connectionId : "";
-      return `mobile:${record.deviceId}:${record.grantRevision}:${connectionId}`;
-    }
-  }
-  return JSON.stringify(principal) ?? "unknown";
-}
 function toStartupError(error, info) {
   const message = error instanceof Error ? error.message : String(error);
   const existingServerId = info.socketPath === null ? undefined : serverIdFromSocketPath(info.socketPath);