neko-harness 0.4.2 → 0.4.3

package/dist/neko.js

@@ -80,7 +80,7 @@ function updateAction(input) {
     return "install";
   return "none";
 }
-var RUNNING_VERSION = "0.4.2", APPLICATION_PROTOCOL = 4, ApplicationProtocolError;
+var RUNNING_VERSION = "0.4.3", APPLICATION_PROTOCOL = 6, ApplicationProtocolError;
 var init_application_version = __esm(() => {
   ApplicationProtocolError = class ApplicationProtocolError extends Error {
     constructor() {
@@ -375,6 +375,182 @@ var init_update = __esm(() => {
   init_application_version();
 });
 
+// packages/core/src/context-limits.ts
+var PERCENT, CONTEXT_FIELD_LIMITS, PRUNING_DEFAULTS;
+var init_context_limits = __esm(() => {
+  PERCENT = { kind: "int", min: 1, max: 99 };
+  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
+    }
+  };
+  PRUNING_DEFAULTS = {
+    enabled: false,
+    triggerPercent: 35,
+    keepRecent: 10,
+    minChars: 4000,
+    minSavePercent: 5
+  };
+});
+
+// packages/core/src/context-settings.ts
+import { DEFAULT_COMPACTION_POLICY } from "@earendil-works/pi-durable";
+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;
+}
+var emptySavedContextSettings = () => ({
+  compaction: { enabled: null, triggerPercent: null, keepRecentTokens: null },
+  pruning: { enabled: null, triggerPercent: null, keepRecent: null, minChars: null, minSavePercent: null }
+}), SCHEMA, isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var init_context_settings = __esm(() => {
+  init_context_limits();
+  SCHEMA = CONTEXT_FIELD_LIMITS;
+});
+
+// packages/core/src/search-providers.ts
+function isSearchProvider(value) {
+  return typeof value === "string" && SEARCH_PROVIDERS.includes(value);
+}
+var SEARCH_PROVIDERS, DEFAULT_SEARCH_PROVIDER = "tavily";
+var init_search_providers = __esm(() => {
+  SEARCH_PROVIDERS = ["tavily", "deepseek"];
+});
+
 // packages/core/src/config.ts
 import { existsSync, readFileSync } from "fs";
 import { homedir as homedir2 } from "os";
@@ -489,9 +665,28 @@ 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)}`);
+    }
+  }
 }
 var DEFAULT_SKILL_MARKET_URL = "https://skill.kirineko.tech", NEKO_CONFIG_BASENAME = "neko.config.json", ENV_REFERENCE;
 var init_config = __esm(() => {
+  init_context_settings();
+  init_search_providers();
   ENV_REFERENCE = /\$\{([A-Za-z_][A-Za-z0-9_]*)\}|\$([A-Za-z_][A-Za-z0-9_]*)/g;
 });
 
@@ -1517,6 +1712,132 @@ async function readCompaction(harness, storage, id, context) {
 }
 var init_compaction = () => {};
 
+// packages/core/src/context-pruning.ts
+function estimateTokens(text) {
+  const cjk = text.match(CJK)?.length ?? 0;
+  return cjk * TOKENS_PER_CJK_CHAR + (text.length - cjk) * TOKENS_PER_LATIN_CHAR;
+}
+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);
+  }
+}
+var PRUNE_ENTRY_KIND = "app.neko.context-prune", TOKENS_PER_LATIN_CHAR = 0.3, TOKENS_PER_CJK_CHAR = 0.6, CJK, isToolResult = (entry) => {
+  const message = entry.model?.[0];
+  return entry.kind === "pi.tool-result" && message?.role === "toolResult";
+}, resultTexts = (message) => message.content.flatMap((block) => block.type === "text" ? [block.text] : []);
+var init_context_pruning = __esm(() => {
+  CJK = /[\u3000-\u9fff\uac00-\ud7af\uf900-\ufaff\uff00-\uffef]/g;
+});
+
 // packages/core/src/image-metadata.ts
 import { defineExtension as defineExtension2, hook, ToolTask } from "@earendil-works/pi-durable";
 import sharp from "sharp";
@@ -2176,7 +2497,7 @@ class JobRegistry {
 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."
@@ -2355,7 +2676,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.");
@@ -2383,7 +2704,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) {
@@ -2435,7 +2756,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}):
@@ -2500,7 +2821,7 @@ ${text}` : `No new output (next offset ${offset}).`);
     this.registry.abortAll();
   }
 }
-var plain = (value) => JSON.parse(JSON.stringify(value)), statusWord, describe = (job) => {
+var plain = (value) => JSON.parse(JSON.stringify(value)), statusWord, describe2 = (job) => {
   const parts = [statusWord[job.status]];
   if (job.exitCode !== null)
     parts.push(`exit code ${job.exitCode}`);
@@ -3419,21 +3740,22 @@ var init_tool_approvals = __esm(() => {
   });
 });
 
-// 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";
+// packages/core/src/web-search/http.ts
 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 "";
@@ -3454,7 +3776,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 {
@@ -3463,7 +3785,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),
@@ -3471,68 +3794,190 @@ 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.`);
   }
 }
+var REQUEST_TIMEOUT_MS = 30000, MAX_RESPONSE_BYTES, WebToolError;
+var init_http = __esm(() => {
+  MAX_RESPONSE_BYTES = 2 * 1024 * 1024;
+  WebToolError = class WebToolError extends Error {
+    status;
+    constructor(message, status) {
+      super(message);
+      this.status = status;
+    }
+  };
+});
+
+// packages/core/src/web-search/deepseek.ts
+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);
+}
+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;
+    }
+  };
+}
+var SEARCH_URL = "https://api.deepseek.com/v1/tools/search", FETCH_URL = "https://api.deepseek.com/v1/tools/fetch", DEEPSEEK_QUERY_MAX_CHARS = 128, FETCH_CONCURRENCY = 3, MAX_RETRIES = 2, BACKOFF_MS, 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.", retryable = (status) => status !== undefined && (status === 429 || status === 408 || status >= 500), wholeCall = (status) => status === 401 || status === 402;
+var init_deepseek = __esm(() => {
+  init_http();
+  BACKOFF_MS = [250, 750];
+});
+
+// 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";
 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})` }))
@@ -3540,18 +3985,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.");
@@ -3573,28 +4019,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(`
 
@@ -3607,11 +4050,75 @@ ${truncate(String(item.url ?? ""), 300)}
     ]
   });
 }
-var SEARCH_URL = "https://api.tavily.com/search", EXTRACT_URL = "https://api.tavily.com/extract", REQUEST_TIMEOUT_MS = 30000, MAX_RESPONSE_BYTES, MAX_URLS = 20, MAX_RESULTS = 10, DEFAULT_RESULTS = 5, MAX_SOURCE_CHARS = 2000, MAX_TOTAL_CHARS = 12000, TavilyError;
+var MAX_URLS = 20, MAX_RESULTS = 10, DEFAULT_RESULTS = 5, MAX_SOURCE_CHARS = 2000, MAX_TOTAL_CHARS = 12000;
 var init_web_search = __esm(() => {
-  MAX_RESPONSE_BYTES = 2 * 1024 * 1024;
-  TavilyError = class TavilyError extends Error {
+  init_http();
+  init_http();
+});
+
+// packages/core/src/web-search/tavily.ts
+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") };
+      });
+    }
   };
+}
+var SEARCH_URL2 = "https://api.tavily.com/search", EXTRACT_URL = "https://api.tavily.com/extract";
+var init_tavily = __esm(() => {
+  init_http();
 });
 
 // packages/core/src/workspace-files.ts
@@ -4034,12 +4541,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));
@@ -4053,9 +4569,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();
@@ -4097,6 +4620,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);
@@ -4133,10 +4671,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();
@@ -4503,6 +5053,26 @@ async function createNekoRuntime(options = {}) {
         source: runtimeKeys.has(spec.id) ? "runtime" : savedConfigured ? "saved" : environmentConfigured ? "environment" : spec.keyless ? "keyless" : "none"
       };
     },
+    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))
@@ -4576,10 +5146,12 @@ async function createNekoRuntime(options = {}) {
     }
   };
 }
-var DEFAULT_MODEL, DEFAULT_STORAGE_PATH, ArchivedDoc, WorkspacesDoc, ActivityDoc;
+var DEFAULT_MODEL, DEFAULT_STORAGE_PATH, ArchivedDoc, WorkspacesDoc, SearchSettingsDoc, ContextSettingsDoc, ActivityDoc;
 var init_runtime = __esm(() => {
   init_agent_file_search();
   init_compaction();
+  init_context_pruning();
+  init_context_settings();
   init_credentials();
   init_image_metadata();
   init_image_prompt();
@@ -4591,11 +5163,14 @@ var init_runtime = __esm(() => {
   init_invoke();
   init_prompt();
   init_resources();
+  init_search_providers();
   init_session_metadata();
   init_subagent_usage();
   init_subagents();
   init_tool_approvals();
+  init_deepseek();
   init_web_search();
+  init_tavily();
   init_workspace();
   init_workspace_files();
   DEFAULT_MODEL = { provider: "deepseek", modelId: "deepseek-flash" };
@@ -4616,6 +5191,22 @@ var init_runtime = __esm(() => {
     fork: "initial",
     initial: () => ({ items: [] })
   });
+  SearchSettingsDoc = defineDoc5({
+    kind: "app.neko.search-settings",
+    version: 1,
+    scope: "conversation",
+    history: "latest",
+    fork: "initial",
+    initial: () => ({ provider: null })
+  });
+  ContextSettingsDoc = defineDoc5({
+    kind: "app.neko.context-settings",
+    version: 1,
+    scope: "conversation",
+    history: "latest",
+    fork: "initial",
+    initial: emptySavedContextSettings
+  });
   ActivityDoc = defineDoc5({
     kind: "app.neko.activity",
     version: 1,
@@ -4641,12 +5232,14 @@ function mergeTranscriptItems(previous, incoming) {
 // packages/core/src/index.ts
 var init_src = __esm(() => {
   init_config();
+  init_context_settings();
   init_credentials();
   init_images();
   init_jobs();
   init_projection();
   init_frontmatter();
   init_runtime();
+  init_search_providers();
   init_session_metadata();
   init_subagent_usage();
   init_subagents();
@@ -4763,7 +5356,7 @@ function relativeTime(at, now, language = "en") {
 var sessionName = (session, empty = "New session") => session.title || session.firstPromptPreview || empty, messageTime = (session) => session.lastMessageAt ?? session.createdAt, byMessage = (a, b) => messageTime(b) - messageTime(a) || Number(b.id) - Number(a.id), byVisited = (a, b) => b.lastUsedAt - a.lastUsedAt || Number(b.id) - Number(a.id);
 
 // packages/gateway/src/contract.ts
-import { method, remote } from "@earendil-works/chord";
+import { hostNamed, method, remote } from "@earendil-works/chord";
 import { Type as Type5 } from "typebox";
 function contract(name, def) {
   const variants = Object.fromEntries(Object.entries(def.variants).map(([key, value]) => [
@@ -4773,9 +5366,9 @@ function contract(name, def) {
       methods: Object.fromEntries(Object.entries(value.methods ?? {}).map(([member, [args, result]]) => [member, method(args, result)]))
     }
   ]));
-  return remote(name, { ...def, variants });
+  return remote(name, { ...def, host: hostNamed(GATEWAY_HOST), variants });
 }
-var rpc = (args, result) => [args, result], str, num, bool, nil, integer, nullableString, phase, level, thinking, model, change, usage, image, skill, call, DelegationSchema, SubagentSummarySchema, jobStatus, JobSummarySchema, JobOutputSchema, ChatViewSchema, SessionSummarySchema, DirectoryStateSchema, WorkspaceSummarySchema, WorkspaceStateSchema, credentialStatus, CredentialStateSchema, AttachmentSchema, chatInput, NekoSessionDirectory, NekoSessionManagement, resize, inputLimits, modelInfo, NekoModels, imageChunk, NekoSubagent, NekoChat, browse, page, NekoWorkspaces, provider, NekoCredentials, FileCandidatesSchema, NekoWorkspaceFiles, marketSkill, preview, scope, installResult, NekoSkillMarket, ApplicationInfoSchema, NekoApplicationInfo;
+var GATEWAY_HOST = "neko", rpc = (args, result) => [args, result], str, num, bool, nil, integer, nullableString, phase, level, thinking, model, change, usage, image, skill, call, DelegationSchema, SubagentSummarySchema, jobStatus, JobSummarySchema, JobOutputSchema, ChatViewSchema, SessionSummarySchema, DirectoryStateSchema, WorkspaceSummarySchema, WorkspaceStateSchema, credentialStatus, CredentialStateSchema, AttachmentSchema, chatInput, NekoSessionDirectory, NekoSessionManagement, resize, inputLimits, modelInfo, NekoModels, imageChunk, NekoSubagent, NekoChat, browse, page, NekoWorkspaces, provider, NekoCredentials, SearchSettingsStateSchema, NekoSearchSettings, contextSource, ContextSettingsStateSchema, nullable = (schema) => Type5.Union([schema, nil]), ContextSettingsPatchSchema, NekoContextSettings, FileCandidatesSchema, NekoWorkspaceFiles, marketSkill, preview, scope, installResult, NekoSkillMarket, ApplicationInfoSchema, NekoApplicationInfo;
 var init_contract = __esm(() => {
   str = Type5.String();
   num = Type5.Number();
@@ -5130,6 +5723,77 @@ var init_contract = __esm(() => {
       }
     }
   });
+  SearchSettingsStateSchema = Type5.Object({
+    revision: integer,
+    selected: Type5.Enum(["tavily", "deepseek"])
+  });
+  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)
+        }
+      }
+    }
+  });
+  contextSource = Type5.Enum(["default", "config", "saved"]);
+  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
+      })
+    })
+  });
+  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 });
+  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)
+        }
+      }
+    }
+  });
   FileCandidatesSchema = Type5.Object({
     entries: Type5.Array(Type5.Object({ name: str, path: str, kind: Type5.Enum(["file", "directory"]) }), { maxItems: 100 }),
     limited: bool,
@@ -5183,18 +5847,24 @@ var init_contract = __esm(() => {
     protocolVersion: Type5.Integer({ minimum: 1 }),
     latestVersion: nullableString,
     checkedAt: Type5.Union([integer, nil]),
-    checkState: Type5.Enum(["unknown", "checking", "ok", "failed", "development"])
+    checkState: Type5.Enum(["unknown", "checking", "ok", "failed", "development"]),
+    serverId: str
   });
   NekoApplicationInfo = contract("neko.application-info", {
     version: 1,
     input: Type5.Object({}),
-    variants: { ready: { state: { info: ApplicationInfoSchema }, methods: { check: rpc(nil, ApplicationInfoSchema) } } }
+    variants: {
+      ready: { state: { info: ApplicationInfoSchema }, methods: { check: rpc(nil, ApplicationInfoSchema) } }
+    }
   });
 });
 
 // packages/gateway/src/link.ts
-import { webSocketLink } from "@earendil-works/chord";
-function boundedWebSocketLink(socket, max = MAX_LINK_BYTES) {
+import {
+  createHost,
+  webSocketLink
+} from "@earendil-works/chord";
+function boundedWebSocketLink(socket, max = MAX_LINK_BYTES, options) {
   let queued = 0, incoming = 0, receiving = false;
   let native;
   const bridge = {
@@ -5210,18 +5880,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;
@@ -5233,7 +5907,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() {
@@ -5253,7 +5927,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;
@@ -5264,49 +5938,19 @@ 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: () => {}
+  });
 }
-var MAX_LINK_BYTES, size = (text) => new TextEncoder().encode(text).byteLength;
+var MAX_LINK_BYTES, asBytes = (data) => data instanceof Uint8Array ? data : new Uint8Array(data), size = (data) => typeof data === "string" ? new TextEncoder().encode(data).byteLength : data.byteLength;
 var init_link = __esm(() => {
   MAX_LINK_BYTES = 16 * 1024 * 1024;
 });
@@ -5494,35 +6138,14 @@ class ApprovalQueue {
 }
 
 // packages/gateway/src/client-session.ts
-import { createHost } from "@earendil-works/chord";
-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();
-  });
+async function assertGatewayIdentity(host, serverId, signal) {
+  const application = await host.get(NekoApplicationInfo, {}, signal ? { signal } : {});
+  try {
+    if (application.info.value.serverId !== serverId)
+      throw new GatewayIdentityError;
+  } finally {
+    application.release();
+  }
 }
 function jobsClient(chat) {
   const supported = () => chat.view.value?.jobs !== undefined;
@@ -5546,16 +6169,37 @@ function jobsClient(chat) {
   };
 }
 function createGatewayConnection(link, serverId) {
-  const host = createHost({ kind: "client", upstream: identifiedLink(link, serverId), onError: () => {} });
-  const get = (type) => host.get(type, {}, { at: serverId });
+  let protocolMismatch = false;
+  const linkClosed = new AbortController;
+  let closeReason = "";
+  link.onClose((reason) => {
+    closeReason = reason;
+    linkClosed.abort(new Error(`Gateway connection closed: ${reason}`));
+  });
+  const host = createClientHost(link, {
+    onProtocolMismatch: () => {
+      protocolMismatch = true;
+    }
+  });
+  const get = (type) => host.hold(type, {});
   const application = get(NekoApplicationInfo);
   const keep = [application.info.subscribe(() => {})];
   let business;
   let protocolChecked = false;
   function bindBusiness() {
-    const directory = get(NekoSessionDirectory), management = get(NekoSessionManagement), models = get(NekoModels), workspaces = get(NekoWorkspaces), workspaceFiles = get(NekoWorkspaceFiles), credentials = get(NekoCredentials), skillMarket = get(NekoSkillMarket);
-    keep.push(directory.state.subscribe(() => {}), workspaces.state.subscribe(() => {}), credentials.state.subscribe(() => {}));
-    return { directory, management, models, workspaces, workspaceFiles, credentials, skillMarket };
+    const directory = get(NekoSessionDirectory), management = get(NekoSessionManagement), models = get(NekoModels), workspaces = get(NekoWorkspaces), workspaceFiles = get(NekoWorkspaceFiles), credentials = get(NekoCredentials), searchSettings = get(NekoSearchSettings), contextSettings = get(NekoContextSettings), skillMarket = get(NekoSkillMarket);
+    keep.push(directory.state.subscribe(() => {}), workspaces.state.subscribe(() => {}), credentials.state.subscribe(() => {}), searchSettings.state.subscribe(() => {}), contextSettings.state.subscribe(() => {}));
+    return {
+      directory,
+      management,
+      models,
+      workspaces,
+      workspaceFiles,
+      credentials,
+      searchSettings,
+      contextSettings,
+      skillMarket
+    };
   }
   const services = () => {
     if (!protocolChecked)
@@ -5564,6 +6208,37 @@ function createGatewayConnection(link, serverId) {
       business = bindBusiness();
     return business;
   };
+  const checkReady = async (signal) => {
+    await deadline(application.ready, signal);
+    const info = application.info.value;
+    if (info.serverId !== serverId)
+      throw new GatewayIdentityError;
+    if (info.protocolVersion !== APPLICATION_PROTOCOL)
+      throw new ApplicationProtocolError;
+    protocolChecked = true;
+    const {
+      directory,
+      management,
+      models,
+      workspaces,
+      credentials,
+      searchSettings,
+      contextSettings,
+      workspaceFiles,
+      skillMarket
+    } = services();
+    await deadline(Promise.all([
+      directory.ready,
+      management.ready,
+      models.ready,
+      workspaces.ready,
+      credentials.ready,
+      searchSettings.ready,
+      contextSettings.ready,
+      workspaceFiles.ready,
+      skillMarket.ready
+    ]), signal);
+  };
   let chat;
   let attachment;
   let stopView;
@@ -5575,7 +6250,7 @@ function createGatewayConnection(link, serverId) {
       if (!attachment)
         throw new Error("No active session");
       const input = { ...attachment, ...typeof target === "string" ? { agentId: target } : { taskId: target } };
-      return subagentClient(() => host.get(NekoSubagent, input, { at: serverId }));
+      return subagentClient(() => host.hold(NekoSubagent, input));
     },
     host,
     link,
@@ -5597,6 +6272,12 @@ function createGatewayConnection(link, serverId) {
     get credentials() {
       return services().credentials;
     },
+    get searchSettings() {
+      return services().searchSettings;
+    },
+    get contextSettings() {
+      return services().contextSettings;
+    },
     get skillMarket() {
       return services().skillMarket;
     },
@@ -5604,26 +6285,13 @@ function createGatewayConnection(link, serverId) {
       return attachment;
     },
     async ready(signal) {
-      await deadline(application.ready, signal);
-      const info = await waitForValue(application.info, signal);
-      if (info.protocolVersion !== APPLICATION_PROTOCOL)
-        throw new ApplicationProtocolError;
-      protocolChecked = true;
-      const { directory, management, models, workspaces, credentials, workspaceFiles, skillMarket } = services();
-      await deadline(Promise.all([
-        directory.ready,
-        management.ready,
-        models.ready,
-        workspaces.ready,
-        credentials.ready,
-        workspaceFiles.ready,
-        skillMarket.ready
-      ]), signal);
-      await Promise.all([
-        waitForValue(directory.state, signal),
-        waitForValue(workspaces.state, signal),
-        waitForValue(credentials.state, signal)
-      ]);
+      try {
+        await checkReady(signal ? AbortSignal.any([signal, linkClosed.signal]) : linkClosed.signal);
+      } catch (error) {
+        if (protocolMismatch || closeReason.startsWith("protocol"))
+          throw new ApplicationProtocolError;
+        throw error;
+      }
     },
     async attach(sessionId, ctx) {
       const next = await connection.management.attach(sessionId, ctx);
@@ -5632,12 +6300,11 @@ function createGatewayConnection(link, serverId) {
       stopView?.();
       chat?.release();
       attachment = next;
-      const current = host.get(NekoChat, next, { at: serverId });
+      const current = host.hold(NekoChat, next);
       chat = current;
       stopView = current.view.subscribe(() => {});
       try {
         await deadline(current.ready, ctx?.signal);
-        await waitForValue(current.view, ctx?.signal);
         if (current !== chat)
           throw new Error("Attachment changed");
         return current;
@@ -5697,11 +6364,17 @@ function deadline(work, signal) {
     signal?.removeEventListener("abort", abort);
   });
 }
-var JOBS_UNSUPPORTED = "This gateway does not support background jobs. Restart the gateway to enable them.";
+var GatewayIdentityError, JOBS_UNSUPPORTED = "This gateway does not support background jobs. Restart the gateway to enable them.";
 var init_client_session = __esm(() => {
   init_application_version();
   init_contract();
   init_link();
+  GatewayIdentityError = class GatewayIdentityError extends Error {
+    constructor() {
+      super("Gateway identity mismatch");
+      this.name = "GatewayIdentityError";
+    }
+  };
 });
 
 // packages/tui/src/theme/palette.ts
@@ -17881,6 +18554,8 @@ var init_labels = __esm(() => {
     { name: "model", description: "Choose a model" },
     { name: "agents", description: "View agent tasks and activity" },
     { name: "jobs", description: "View background jobs" },
+    { name: "search", description: "Choose the web search provider (Tavily/DeepSeek)" },
+    { name: "context", description: "Tune context compaction and tool result pruning" },
     { name: "theme", description: "Choose color theme (auto/light/dark)" },
     { name: "think", description: "Set thinking level (/think high)" },
     { name: "fork", description: "Fork this session" },
@@ -19390,6 +20065,227 @@ var init_welcome = __esm(() => {
   CAT = ["|\\___/|", ")     (", "=\\^_^ /=", ")---("];
 });
 
+// packages/tui/src/context-ui.ts
+import { matchesKey as matchesKey7 } from "@earendil-works/pi-tui";
+function format(kind, value) {
+  if (value === null)
+    return "Default";
+  if (typeof value === "boolean")
+    return value ? "On" : "Off";
+  switch (kind) {
+    case "percent":
+      return `${value}%`;
+    case "tokens":
+      return value >= 1000 ? `${Math.round(value / 1000)}k tokens` : `${value} tokens`;
+    case "chars":
+      return value >= 1000 ? `${Math.round(value / 1000)}k chars` : `${value} chars`;
+    default:
+      return String(value);
+  }
+}
+function read(state, row) {
+  const effective = state.effective[row.group];
+  const sources = state.sources[row.group];
+  return { value: effective[row.field] ?? null, source: sources[row.field] ?? "default" };
+}
+function contextItems(state) {
+  if (!state)
+    return [];
+  const items = [];
+  let group = "";
+  for (const row of CONTEXT_ROWS) {
+    if (row.group !== group) {
+      group = row.group;
+      items.push({
+        value: `header:${group}`,
+        label: group === "compaction" ? "Compaction" : "Tool result pruning",
+        header: true
+      });
+    }
+    const { value, source } = read(state, row);
+    const custom = source !== "default" && value !== null && !row.presets.includes(value);
+    items.push({
+      value: row.key,
+      label: row.label,
+      rightLabel: `${format(row.kind, value)}  ${SOURCES[source]}${custom ? " \xB7 Custom" : ""}`,
+      description: row.description
+    });
+  }
+  items.push({
+    value: RESET_VALUE,
+    label: "Reset to defaults",
+    description: "Clear every saved value. Config file values still apply."
+  });
+  return items;
+}
+
+class PresetDetail {
+  help = shortcutHints(["\u2191\u2193", "Select"], ["Enter", "Save"], ["Esc", "Back"]);
+  #index = 0;
+  #error = "";
+  #saving = false;
+  #options;
+  #row;
+  #client;
+  #panel;
+  #notify;
+  #changed;
+  constructor(row, client, panel, notify, changed) {
+    this.#row = row;
+    this.#client = client;
+    this.#panel = panel;
+    this.#notify = notify;
+    this.#changed = changed;
+    const state = client.contextSettings.state.value;
+    const current = state ? read(state, row) : { value: null, source: "default" };
+    const options = [null, ...row.presets];
+    const custom = current.source !== "default" && current.value !== null && !row.presets.includes(current.value);
+    if (custom)
+      options.push(current.value);
+    this.#options = options;
+    this.#index = current.source === "saved" || custom ? Math.max(0, options.indexOf(current.value)) : 0;
+  }
+  lines(_width, height) {
+    const state = this.#client.contextSettings.state.value;
+    const current = state ? read(state, this.#row) : undefined;
+    const head = [theme.accent(this.#row.label), theme.dim(this.#row.description)];
+    if (this.#saving)
+      head.push("Saving...");
+    if (this.#error)
+      head.push(theme.error(`Error: ${this.#error}`));
+    const options = this.#options.map((option, i) => {
+      const custom = option !== null && !this.#row.presets.includes(option);
+      const text = `${format(this.#row.kind, option)}${custom ? " (Custom)" : ""}${option === null && current ? ` - now ${SOURCES[current.source]}` : ""}`;
+      return i === this.#index ? theme.selection(`\u276F ${text}`) : `  ${text}`;
+    });
+    const count = Math.max(1, height - head.length);
+    const start = Math.max(0, Math.min(this.#index - Math.floor(count / 2), options.length - count));
+    return [...head, ...options.slice(start, start + count)];
+  }
+  handleKey(data) {
+    if (this.#saving)
+      return true;
+    if (matchesKey7(data, "up"))
+      this.#index = Math.max(0, this.#index - 1);
+    else if (matchesKey7(data, "down"))
+      this.#index = Math.min(this.#options.length - 1, this.#index + 1);
+    else if (matchesKey7(data, "enter")) {
+      const value = this.#options[this.#index] ?? null;
+      this.#saving = true;
+      this.#error = "";
+      const patch = { [this.#row.group]: { [this.#row.field]: value } };
+      this.#client.contextSettings.set(patch).then(() => {
+        this.#saving = false;
+        this.#notify(`${this.#row.label} set to ${format(this.#row.kind, value)}.`);
+        this.#panel.popDetail();
+      }, (error) => {
+        this.#saving = false;
+        this.#error = message(error);
+        this.#changed();
+      });
+    } else
+      return false;
+    return true;
+  }
+}
+function openContextPanel(panel, client, notify) {
+  const items = () => contextItems(client.contextSettings.state.value);
+  const stop = client.contextSettings.state.subscribe(() => panel.update(items()));
+  panel.emptyText = CONTEXT_EMPTY;
+  panel.show("Context settings", async () => items(), async (value) => {
+    if (value === RESET_VALUE) {
+      await client.contextSettings.reset({});
+      notify("Context settings reset to defaults.");
+      return;
+    }
+    const row = CONTEXT_ROWS.find((item) => item.key === value);
+    if (!row)
+      return;
+    return new PresetDetail(row, client, panel, notify, () => panel.changed());
+  });
+  return stop;
+}
+var CONTEXT_EMPTY = "Context settings are unavailable.", CONTEXT_ROWS, SOURCES, RESET_VALUE = "reset", message = (error) => error instanceof Error ? error.message : String(error);
+var init_context_ui = __esm(() => {
+  init_shortcut_hints();
+  init_theme();
+  CONTEXT_ROWS = [
+    {
+      key: "compaction.enabled",
+      group: "compaction",
+      field: "enabled",
+      label: "Auto compaction",
+      kind: "bool",
+      description: "Compact automatically near the limit. /compact always works.",
+      presets: [true, false]
+    },
+    {
+      key: "compaction.triggerPercent",
+      group: "compaction",
+      field: "triggerPercent",
+      label: "Compact at",
+      kind: "percent",
+      description: "Compact when context reaches this share of the smallest model window. Default is near the limit.",
+      presets: [30, 40, 50, 60, 70, 80]
+    },
+    {
+      key: "compaction.keepRecentTokens",
+      group: "compaction",
+      field: "keepRecentTokens",
+      label: "Keep recent",
+      kind: "tokens",
+      description: "Recent context a compaction keeps verbatim.",
+      presets: [1e4, 20000, 40000, 80000]
+    },
+    {
+      key: "pruning.enabled",
+      group: "pruning",
+      field: "enabled",
+      label: "Prune tool results",
+      kind: "bool",
+      description: "Replace old, large tool results with a short note in what the model sees. History is kept.",
+      presets: [true, false]
+    },
+    {
+      key: "pruning.triggerPercent",
+      group: "pruning",
+      field: "triggerPercent",
+      label: "Prune at",
+      kind: "percent",
+      description: "Prune when context reaches this share of the model window. Each prune invalidates the prompt cache.",
+      presets: [20, 30, 35, 45, 55]
+    },
+    {
+      key: "pruning.keepRecent",
+      group: "pruning",
+      field: "keepRecent",
+      label: "Keep recent results",
+      kind: "count",
+      description: "Newest tool results that are never pruned.",
+      presets: [5, 10, 20, 40]
+    },
+    {
+      key: "pruning.minChars",
+      group: "pruning",
+      field: "minChars",
+      label: "Min result size",
+      kind: "chars",
+      description: "Results shorter than this are never pruned.",
+      presets: [2000, 4000, 8000, 16000]
+    },
+    {
+      key: "pruning.minSavePercent",
+      group: "pruning",
+      field: "minSavePercent",
+      label: "Min release",
+      kind: "percent",
+      description: "A prune runs only if it frees at least this share of the model window. Each prune invalidates the prompt cache, so a larger share means fewer prunes.",
+      presets: [2, 5, 10, 15]
+    }
+  ];
+  SOURCES = { default: "Default", config: "Config", saved: "Saved" };
+});
+
 // packages/tui/src/detect-theme.ts
 function detectColorFgBgMode(env = process.env) {
   const bg = env.COLORFGBG?.split(";").at(-1)?.trim();
@@ -19695,7 +20591,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;
@@ -19829,7 +20725,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() {
@@ -19879,6 +20775,25 @@ 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/principal.ts
+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";
+}
+var HOST_PRINCIPAL;
+var init_principal = __esm(() => {
+  HOST_PRINCIPAL = { kind: "host" };
+});
+
 // packages/gateway/src/mobile/store.ts
 import { randomBytes } from "crypto";
 import { chmod as chmod2, mkdir as mkdir5, readFile as readFile6, rename as rename3, rm as rm3, writeFile as writeFile3 } from "fs/promises";
@@ -20189,20 +21104,8 @@ var init_store = __esm(() => {
 
 // packages/gateway/src/mobile/admin.ts
 import { createHash, timingSafeEqual } from "crypto";
-import { ChordError, method as method2, remote as remote2 } from "@earendil-works/chord";
+import { ChordError } from "@earendil-works/chord";
 import { Type as Type6 } from "typebox";
-function contract2(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, method2(args, result)]))
-    }
-  ]));
-  return remote2(name, { ...def, variants });
-}
-function isMobilePrincipal(principal) {
-  return typeof principal === "object" && principal !== null && principal.kind === "mobile";
-}
 function digest(value) {
   return createHash("sha256").update(value, "utf8").digest();
 }
@@ -20231,7 +21134,7 @@ function createMobileAdminFactory(deps) {
         throw new ChordError("forbidden", "forbidden");
     };
     return {
-      kind: "admin",
+      variant: "admin",
       async state() {
         await guard();
         return deps.mobile.adminState();
@@ -20269,6 +21172,8 @@ function createMobileAdminFactory(deps) {
 }
 var listenerStateSchema, adminDeviceSchema, NekoMobileAdmin;
 var init_admin = __esm(() => {
+  init_contract();
+  init_principal();
   init_store();
   listenerStateSchema = Type6.Union([
     Type6.Object({ status: Type6.Literal("disabled") }),
@@ -20290,54 +21195,42 @@ var init_admin = __esm(() => {
     lastSeenAt: Type6.Integer(),
     online: Type6.Boolean()
   });
-  NekoMobileAdmin = contract2("neko.mobile-admin", {
+  NekoMobileAdmin = contract("neko.mobile-admin", {
     version: 1,
     input: Type6.Object({ token: Type6.String() }),
     variants: {
       admin: {
         methods: {
-          state: [
-            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: [
-            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: [Type6.Null(), listenerStateSchema],
-          createPairing: [Type6.Null(), Type6.Object({ pairingText: Type6.String(), expiresAt: Type6.Integer() })],
-          cancelPairing: [Type6.Null(), Type6.Null()],
-          revoke: [
-            Type6.Object({ deviceId: Type6.String({ minLength: 1 }) }),
-            Type6.Object({ revoked: Type6.Boolean() })
-          ],
-          regenerateCertificate: [
-            Type6.Null(),
-            Type6.Object({ fingerprint: Type6.String(), expiresAt: Type6.Integer() })
-          ]
+          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() }))
         }
       }
     }
@@ -20401,7 +21294,7 @@ function buildHelloResultSchema() {
     })
   });
 }
-var MOBILE_LIMITS, MOBILE_API_VERSIONS, MOBILE_CAPABILITIES, MOBILE_CLOSE_REVOKED = 4401, MOBILE_CLOSE_INCOMPATIBLE = 4402, MOBILE_CLOSE_SLOW_CONSUMER = 4408, MobileHelloParams, opt, str2, int, nullable = (schema) => Type7.Union([schema, Type7.Null()]), MobileContentRefSchema, MobileImageRefSchema, MobileToolItemSchema, MobileChatItemSchema, MobileStreamingSchema, MobileUsageSchema, MobileSubagentRoundSchema, MobileAgentSchema, MobileChatStatusSchema, MobileChatSnapshotSchema, MobileWorkspaceSchema, MobileSessionSummarySchema, MobileApprovalSchema, sessionListParams, sessionListResult, subscription, pageResult, pageParams, chunkResult, MOBILE_API_V1_METHODS, patchBody, MOBILE_API_V1_NOTIFICATIONS;
+var MOBILE_LIMITS, MOBILE_API_VERSIONS, MOBILE_CAPABILITIES, MOBILE_CLOSE_REVOKED = 4401, MOBILE_CLOSE_INCOMPATIBLE = 4402, MOBILE_CLOSE_SLOW_CONSUMER = 4408, MobileHelloParams, opt, str2, int, nullable2 = (schema) => Type7.Union([schema, Type7.Null()]), MobileContentRefSchema, MobileImageRefSchema, MobileToolItemSchema, MobileChatItemSchema, MobileStreamingSchema, MobileUsageSchema, MobileSubagentRoundSchema, MobileAgentSchema, MobileChatStatusSchema, MobileChatSnapshotSchema, MobileWorkspaceSchema, MobileSessionSummarySchema, MobileApprovalSchema, sessionListParams, sessionListResult, subscription, pageResult, pageParams, chunkResult, MOBILE_API_V1_METHODS, patchBody, MOBILE_API_V1_NOTIFICATIONS;
 var init_protocol = __esm(() => {
   init_application_version();
   MOBILE_LIMITS = {
@@ -20520,7 +21413,7 @@ var init_protocol = __esm(() => {
     approvalCount: int,
     readonly: Type7.Boolean(),
     createdAt: Type7.Number(),
-    endedAt: nullable(Type7.Number()),
+    endedAt: nullable2(Type7.Number()),
     usage: opt(MobileUsageSchema)
   });
   MobileAgentSchema = Type7.Object({
@@ -20528,18 +21421,18 @@ var init_protocol = __esm(() => {
     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
   });
   MobileChatStatusSchema = Type7.Object({
     busy: Type7.Boolean(),
-    status: nullable(str2),
+    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,
@@ -20549,8 +21442,8 @@ var init_protocol = __esm(() => {
   MobileChatSnapshotSchema = Type7.Object({
     ...MobileChatStatusSchema.properties,
     items: Type7.Array(MobileChatItemSchema),
-    historyBefore: nullable(str2),
-    streaming: nullable(MobileStreamingSchema)
+    historyBefore: nullable2(str2),
+    streaming: nullable2(MobileStreamingSchema)
   });
   MobileWorkspaceSchema = Type7.Object({ root: str2, name: str2 });
   MobileSessionSummarySchema = Type7.Object({
@@ -20583,7 +21476,7 @@ var init_protocol = __esm(() => {
     nextCursor: opt(str2)
   });
   subscription = { subscriptionId: Type7.String({ minLength: 1 }) };
-  pageResult = Type7.Object({ items: Type7.Array(MobileChatItemSchema), historyBefore: nullable(str2) });
+  pageResult = Type7.Object({ items: Type7.Array(MobileChatItemSchema), historyBefore: nullable2(str2) });
   pageParams = Type7.Object({
     ...subscription,
     before: Type7.String({ minLength: 1 }),
@@ -20680,7 +21573,7 @@ var init_protocol = __esm(() => {
     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) }))
   };
   MOBILE_API_V1_NOTIFICATIONS = {
@@ -21183,7 +22076,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) {
@@ -21397,14 +22290,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();
@@ -21413,7 +22309,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();
@@ -21439,7 +22337,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,
@@ -21476,16 +22374,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();
@@ -21547,7 +22442,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;
@@ -21578,7 +22473,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" } : {}
@@ -21595,7 +22490,7 @@ class MobileAdapter {
   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) {
@@ -21674,7 +22569,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"
@@ -21754,7 +22649,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 };
       }
     };
@@ -21798,7 +22693,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();
     }
@@ -21812,9 +22707,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;
@@ -21864,7 +22759,6 @@ class MobileAdapter {
 var CLOSE_INVALID_JSON = 1003, CLOSE_PROTOCOL_ERROR = 1002, ACTIVE_ROUND, MobileMethodError;
 var init_adapter = __esm(() => {
   init_src();
-  init_client_session();
   init_projection2();
   init_protocol();
   ACTIVE_ROUND = new Set(["queued", "running"]);
@@ -39188,7 +40082,7 @@ var init_wsl = __esm(() => {
 import { randomUUID as randomUUID2 } from "crypto";
 import { createServer as createServer2 } from "https";
 import { hostname } from "os";
-import { createHost as createHost2, memoryLinkPair } from "@earendil-works/chord";
+import { memoryLinkPair } from "@earendil-works/chord";
 import { WebSocketServer as WebSocketServer2 } from "ws";
 function defaultServerName() {
   const name = hostname().trim();
@@ -39220,9 +40114,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;
@@ -39401,7 +40292,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;
@@ -39477,11 +40368,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,
@@ -39493,11 +40380,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;
@@ -39521,10 +40408,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(() => {
@@ -39808,6 +40698,7 @@ var RELAY_PORT_RETRY_MS = 1e4, RELAY_PORT_RETRY_INTERVAL_MS = 1000, WSL_INTEROP_
 var init_listener = __esm(() => {
   init_contract();
   init_link();
+  init_principal();
   init_adapter();
   init_auth();
   init_certificate();
@@ -39942,15 +40833,7 @@ var init_image_uploads = __esm(() => {
 });
 
 // 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) {
@@ -40077,31 +40960,27 @@ async function openReader(runtime, childId, parentId, context, through, historyU
 }
 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) };
   });
@@ -40117,23 +40996,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();
@@ -40193,12 +41073,8 @@ import { open as open3 } from "fs/promises";
 import { basename as basename5, 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";
@@ -40292,65 +41168,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 {
@@ -40360,7 +41232,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) => {
@@ -41224,20 +42096,14 @@ var init_workspaces = __esm(() => {
 
 // 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";
 import { Type as Type10 } from "typebox";
 async function createNekoServerServices(options) {
   const { runtime, context, host } = 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)
@@ -41250,22 +42116,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);
       }
     };
   });
@@ -41309,7 +42173,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);
@@ -41317,43 +42187,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))
@@ -41361,7 +42252,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);
@@ -41373,8 +42264,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],
@@ -41382,7 +42299,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))
@@ -41400,7 +42317,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) => {
@@ -41423,7 +42340,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),
@@ -41465,7 +42382,11 @@ var init_server_services = __esm(() => {
       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())
     }
   });
 });
@@ -41474,7 +42395,7 @@ var init_server_services = __esm(() => {
 import { randomUUID as randomUUID5 } from "crypto";
 import { mkdir as mkdir7, readFile as readFile8, writeFile as writeFile6 } from "fs/promises";
 import { basename as basename6, dirname as dirname10, join as join14 } 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";
 async function startGateway(options = {}) {
   const context = options.context ?? BACKGROUND_CONTEXT4;
@@ -41483,6 +42404,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 = dirname10(storagePath);
   const serverId = options.serverId ?? await loadOrCreateServerId(nekoDir);
@@ -41494,6 +42416,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 } : {},
@@ -41524,8 +42448,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
@@ -41534,6 +42459,7 @@ async function bindGateway(runtime, options) {
     host: chord,
     runtime,
     context,
+    serverId,
     marketUrl: options.marketUrl,
     ...options.updates ? { updates: options.updates } : {},
     ...options.updateIntervalMs ? { updateIntervalMs: options.updateIntervalMs } : {},
@@ -41549,7 +42475,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();
@@ -41612,16 +42541,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);
@@ -41661,9 +42580,11 @@ async function loadOrCreateServerId(nekoDir) {
 var DEFAULT_HOST = "127.0.0.1", DEFAULT_PORT = 8321, SERVER_ID_FILENAME = "gateway-server-id";
 var init_gateway = __esm(() => {
   init_src();
+  init_contract();
   init_admin();
   init_listener();
   init_port_file();
+  init_principal();
   init_server_services();
   init_unix_link();
   init_ws_listener();
@@ -41768,6 +42689,7 @@ var DEFAULT_SHUTDOWN_TIMEOUT_MS = 5000;
 // packages/gateway/src/index.ts
 var init_src2 = __esm(() => {
   init_client();
+  init_client_session();
   init_contract();
   init_gateway();
   init_link();
@@ -41838,7 +42760,7 @@ async function connectSpawned(plan, child, outputTail, spawnError) {
   const timeoutMs = plan.spawnTimeoutMs ?? 20000;
   if (plan.platform === "win32") {
     const timeoutAt = Date.now() + timeoutMs;
-    const serverId = plan.fileServerId ?? await waitForValue2(() => readServerId(join15(plan.nekoDir, SERVER_ID_FILENAME2)), "gateway serverId file", timeoutMs, child, outputTail, spawnError);
+    const serverId = plan.fileServerId ?? await waitForValue(() => readServerId(join15(plan.nekoDir, SERVER_ID_FILENAME2)), "gateway serverId file", timeoutMs, child, outputTail, spawnError);
     let lastError = new Error("Gateway port file unavailable");
     while (Date.now() < timeoutAt) {
       if (child.exitCode !== null || child.signalCode !== null || spawnError() !== undefined) {
@@ -41875,10 +42797,10 @@ async function connectSpawned(plan, child, outputTail, spawnError) {
   }
   let socketPath = plan.socketPath;
   if (socketPath === undefined) {
-    const generated = await waitForValue2(() => readServerId(join15(plan.nekoDir, SERVER_ID_FILENAME2)), "gateway serverId file", timeoutMs, child, outputTail, spawnError);
+    const generated = await waitForValue(() => readServerId(join15(plan.nekoDir, SERVER_ID_FILENAME2)), "gateway serverId file", timeoutMs, child, outputTail, spawnError);
     socketPath = join15(plan.nekoDir, `${generated}.sock`);
   }
-  await waitForValue2(() => existsSync3(socketPath) ? true : undefined, `gateway ready (socket: ${socketPath})`, timeoutMs, child, outputTail, spawnError);
+  await waitForValue(() => existsSync3(socketPath) ? true : undefined, `gateway ready (socket: ${socketPath})`, timeoutMs, child, outputTail, spawnError);
   const serverId = plan.fileServerId ?? serverIdFromSocketPath2(socketPath) ?? readServerId(join15(plan.nekoDir, SERVER_ID_FILENAME2));
   if (serverId === undefined) {
     throw new Error(`Cannot determine gateway serverId (socket: ${socketPath})`);
@@ -41975,7 +42897,7 @@ function captureOutput(child) {
   return () => [stdout.trimEnd(), stderr.trimEnd()].filter((part) => part !== "").join(`
 `);
 }
-async function waitForValue2(poll, what, timeoutMs, child, outputTail, spawnError) {
+async function waitForValue(poll, what, timeoutMs, child, outputTail, spawnError) {
   const start = Date.now();
   for (;; ) {
     const error = spawnError();
@@ -42010,7 +42932,7 @@ var init_gateway2 = __esm(() => {
 });
 
 // packages/tui/src/help-ui.ts
-import { getKeybindings, matchesKey as matchesKey7, TUI_KEYBINDINGS, wrapTextWithAnsi as wrapTextWithAnsi4 } from "@earendil-works/pi-tui";
+import { getKeybindings, matchesKey as matchesKey8, TUI_KEYBINDINGS, wrapTextWithAnsi as wrapTextWithAnsi4 } from "@earendil-works/pi-tui";
 function helpLines(platform = process.platform) {
   const rows = [];
   const section = (title, hints) => {
@@ -42055,6 +42977,15 @@ function helpLines(platform = process.platform) {
     ["End", "Jump to the newest output"],
     ["\u2190", "Back"]
   ]);
+  section("Web search", [
+    ["/search", "Choose the web search provider"],
+    ["Enter", "Apply the highlighted provider"]
+  ]);
+  section("Context", [
+    ["/context", "Tune compaction and tool result pruning"],
+    ["Enter", "Choose a setting, then a value to save"],
+    ["Esc", "Back"]
+  ]);
   section("Skills", [
     ["U", "Install for user"],
     ["P", "Install for project"],
@@ -42107,13 +43038,13 @@ class HelpDetail {
     this.#offset = Math.max(0, Math.min(this.#max, this.#offset + delta));
   }
   handleKey(data) {
-    if (matchesKey7(data, "up"))
+    if (matchesKey8(data, "up"))
       this.scroll(-1);
-    else if (matchesKey7(data, "down"))
+    else if (matchesKey8(data, "down"))
       this.scroll(1);
-    else if (matchesKey7(data, "pageUp"))
+    else if (matchesKey8(data, "pageUp"))
       this.scroll(-this.#page);
-    else if (matchesKey7(data, "pageDown"))
+    else if (matchesKey8(data, "pageDown"))
       this.scroll(this.#page);
     else
       return false;
@@ -42140,7 +43071,7 @@ import { readFile as readFile9, stat as stat5 } from "fs/promises";
 import { homedir as homedir8 } from "os";
 import { basename as basename8, resolve as resolve5 } from "path";
 import { promisify as promisify2 } from "util";
-import { isKeyRelease as isKeyRelease4, isKeyRepeat as isKeyRepeat2, matchesKey as matchesKey8 } from "@earendil-works/pi-tui";
+import { isKeyRelease as isKeyRelease4, isKeyRepeat as isKeyRepeat2, matchesKey as matchesKey9 } from "@earendil-works/pi-tui";
 function imagePaths(text, platform = process.platform) {
   const paths = [];
   let word = "", quote = "", escaped = false;
@@ -42234,7 +43165,7 @@ end try`]).catch(() => ""));
   return { text: String(await run(tool, wayland ? ["--no-newline"] : ["-selection", "clipboard", "-o"])) };
 }
 function isClipboardShortcut(data, platform = process.platform) {
-  return !isKeyRelease4(data) && !isKeyRepeat2(data) && matchesKey8(data, platform === "win32" ? "alt+v" : "ctrl+v");
+  return !isKeyRelease4(data) && !isKeyRepeat2(data) && matchesKey9(data, platform === "win32" ? "alt+v" : "ctrl+v");
 }
 var exec;
 var init_image_input = __esm(() => {
@@ -42279,9 +43210,55 @@ function createAppLayout(parts) {
 var usableSize = (width, height) => width >= 40 && height >= 10;
 var init_layout = () => {};
 
+// packages/tui/src/search-ui.ts
+function searchItems(settings, credentials) {
+  if (!settings)
+    return [];
+  const source = (provider) => {
+    const status = credentials?.statuses[provider];
+    return status ? SOURCES2[status.source] : "loading";
+  };
+  const deepseekMissing = credentials?.statuses.deepseek.source === "none";
+  const descriptions = {
+    tavily: `Tavily search (${source("tavily")}). Default`,
+    deepseek: deepseekMissing ? "No DeepSeek key. Run /login to set one before choosing it" : `DeepSeek search and fetch with your DeepSeek API key (${source("deepseek")})`
+  };
+  return SEARCH_PROVIDERS.map((value) => ({
+    value,
+    label: `${NAMES[value]}${settings.selected === value ? " (Current)" : ""}`,
+    description: descriptions[value]
+  }));
+}
+function openSearchPanel(panel, client, notify) {
+  const items = () => searchItems(client.searchSettings.state.value, client.credentials.state.value);
+  const refresh = () => panel.update(items());
+  const stops = [client.searchSettings.state.subscribe(refresh), client.credentials.state.subscribe(refresh)];
+  panel.emptyText = SEARCH_EMPTY;
+  panel.show("Web search", async () => items(), async (value) => {
+    await client.searchSettings.set({ provider: value });
+    notify(`Web search provider set to ${NAMES[value]}.`);
+  });
+  return () => {
+    for (const stop of stops)
+      stop();
+  };
+}
+var SEARCH_EMPTY = "Search settings are unavailable.", NAMES, SOURCES2;
+var init_search_ui = __esm(() => {
+  init_search_providers();
+  NAMES = { tavily: "Tavily", deepseek: "DeepSeek" };
+  SOURCES2 = {
+    saved: "saved key",
+    environment: "environment variable",
+    runtime: "runtime key",
+    keyless: "keyless, rate-limited",
+    none: "no key"
+  };
+});
+
 // packages/tui/src/skill-market-ui.ts
 import { ChordError as ChordError6 } from "@earendil-works/chord";
-import { Markdown as Markdown3, matchesKey as matchesKey9, wrapTextWithAnsi as wrapTextWithAnsi5 } from "@earendil-works/pi-tui";
+import { Markdown as Markdown3, matchesKey as matchesKey10, wrapTextWithAnsi as wrapTextWithAnsi5 } from "@earendil-works/pi-tui";
 
 class SkillDetailView {
   #skill = null;
@@ -42320,11 +43297,11 @@ class SkillDetailView {
   }
   handleKey(data) {
     if (this.#confirm) {
-      if (matchesKey9(data, "y")) {
+      if (matchesKey10(data, "y")) {
         const pending = this.#confirm;
         this.#confirm = null;
         this.run(pending.run);
-      } else if (matchesKey9(data, "n")) {
+      } else if (matchesKey10(data, "n")) {
         this.#confirm = null;
       }
       return true;
@@ -42333,17 +43310,17 @@ class SkillDetailView {
       return true;
     const skill = this.#skill;
     const builtinOnly = skill.installed.builtin && !skill.installed.user && !skill.installed.project;
-    if (matchesKey9(data, "v")) {
+    if (matchesKey10(data, "v")) {
       this.#openPreview(this.#name);
       return true;
     }
     if (builtinOnly)
       return true;
-    if (matchesKey9(data, "u"))
+    if (matchesKey10(data, "u"))
       this.askInstall("user", skill);
-    else if (matchesKey9(data, "p"))
+    else if (matchesKey10(data, "p"))
       this.askInstall("project", skill);
-    else if (matchesKey9(data, "d"))
+    else if (matchesKey10(data, "d"))
       this.askUninstall(skill);
     else
       return false;
@@ -42468,13 +43445,13 @@ class SkillPreviewView {
     this.#offset = Math.max(0, Math.min(this.#maxOffset, this.#offset + delta));
   }
   handleKey(data) {
-    if (matchesKey9(data, "up"))
+    if (matchesKey10(data, "up"))
       this.scroll(-1);
-    else if (matchesKey9(data, "down"))
+    else if (matchesKey10(data, "down"))
       this.scroll(1);
-    else if (matchesKey9(data, "pageUp"))
+    else if (matchesKey10(data, "pageUp"))
       this.scroll(-this.#pageSize);
-    else if (matchesKey9(data, "pageDown"))
+    else if (matchesKey10(data, "pageDown"))
       this.scroll(this.#pageSize);
     else
       return false;
@@ -42526,7 +43503,7 @@ var init_skill_market_ui = __esm(() => {
 });
 
 // packages/tui/src/subagents-ui.ts
-import { matchesKey as matchesKey10 } from "@earendil-works/pi-tui";
+import { matchesKey as matchesKey11 } from "@earendil-works/pi-tui";
 
 class SubagentDetail {
   get help() {
@@ -42646,13 +43623,13 @@ class SubagentDetail {
       this.history();
   }
   handleKey(data) {
-    if (matchesKey10(data, "up")) {
+    if (matchesKey11(data, "up")) {
       this.scroll(-1);
-    } else if (matchesKey10(data, "down")) {
+    } else if (matchesKey11(data, "down")) {
       this.scroll(1);
-    } else if (matchesKey10(data, "pageUp")) {
+    } else if (matchesKey11(data, "pageUp")) {
       this.scroll(-this.#pageSize);
-    } else if (matchesKey10(data, "pageDown")) {
+    } else if (matchesKey11(data, "pageDown")) {
       this.scroll(this.#pageSize);
     } else if (data.toLowerCase() === "e") {
       this.#expanded = !this.#expanded;
@@ -42668,7 +43645,7 @@ class SubagentDetail {
         help: shortcutHints(["Enter", "Stop"], ["Esc", "Back"]),
         lines: () => [theme.warning("Stop this task? Existing changes will be kept.")],
         handleKey: (key) => {
-          if (!matchesKey10(key, "enter"))
+          if (!matchesKey11(key, "enter"))
             return false;
           this.#service.stop(stopTaskId === undefined ? null : { taskId: stopTaskId }).catch((e) => {
             this.#error = String(e);
@@ -42799,7 +43776,7 @@ var init_subagents_ui = __esm(() => {
 });
 
 // packages/tui/src/version-ui.ts
-import { matchesKey as matchesKey11, Text as Text9 } from "@earendil-works/pi-tui";
+import { matchesKey as matchesKey12, Text as Text9 } from "@earendil-works/pi-tui";
 function actionFor(state, installed, runningVersion) {
   const action = updateAction({ gateway: state, frontend: runningVersion, installed });
   return action === "install" && !newer(state?.latestVersion, runningVersion) ? "none" : action;
@@ -42877,9 +43854,9 @@ class VersionDetail {
     return lines.slice(this.#offset, this.#offset + height);
   }
   handleKey(data) {
-    if (matchesKey11(data, "up"))
+    if (matchesKey12(data, "up"))
       this.#offset = Math.max(0, this.#offset - 1);
-    else if (matchesKey11(data, "down"))
+    else if (matchesKey12(data, "down"))
       this.#offset++;
     else
       return false;
@@ -42944,7 +43921,7 @@ import {
   Container as Container6,
   isKeyRelease as isKeyRelease5,
   Loader,
-  matchesKey as matchesKey12,
+  matchesKey as matchesKey13,
   ProcessTerminal,
   ScrollView,
   TuiAltScreen
@@ -42980,6 +43957,8 @@ class NekoTuiApp {
   #chat;
   #agentsPanel = false;
   #jobsPanel = false;
+  #searchStop;
+  #contextStop;
   #agentDetails = new Map;
   #sessionId = "";
   #viewUnsubscribe;
@@ -43021,6 +44000,10 @@ class NekoTuiApp {
       this.#thinkingModel = undefined;
       this.#agentsPanel = false;
       this.#jobsPanel = false;
+      this.#searchStop?.();
+      this.#searchStop = undefined;
+      this.#contextStop?.();
+      this.#contextStop = undefined;
       clearInterval(this.#sessionPanelTimer);
       this.#sessionPanelTimer = undefined;
       this.#ui.setFocus(this.#editor);
@@ -43081,10 +44064,10 @@ class NekoTuiApp {
     this.#ui.addInputListener((data) => {
       if (isKeyRelease5(data))
         return { consume: true };
-      if (!matchesKey12(data, "escape") || this.#panel.open || this.#login.open || this.#busyText !== undefined || this.#lastView?.compaction?.active.length)
+      if (!matchesKey13(data, "escape") || this.#panel.open || this.#login.open || this.#busyText !== undefined || this.#lastView?.compaction?.active.length)
         this.#editor.resetEscapeSequence();
       if (!usableSize(this.#terminal.columns, this.#terminal.rows)) {
-        if (matchesKey12(data, "ctrl+c"))
+        if (matchesKey13(data, "ctrl+c"))
           this.exit();
         return { consume: true };
       }
@@ -43095,11 +44078,11 @@ class NekoTuiApp {
       }
       if (this.#sessionOperation)
         return { consume: true };
-      if (matchesKey12(data, "right") && this.#lastView?.subagents?.length && this.#editor.getText() === "" && !this.#editor.isShowingAutocomplete()) {
+      if (matchesKey13(data, "right") && this.#lastView?.subagents?.length && this.#editor.getText() === "" && !this.#editor.isShowingAutocomplete()) {
         this.#showAgents();
         return { consume: true };
       }
-      if (matchesKey12(data, process.platform === "win32" ? "alt+v" : "ctrl+v")) {
+      if (matchesKey13(data, process.platform === "win32" ? "alt+v" : "ctrl+v")) {
         if (isClipboardShortcut(data))
           this.pasteClipboard();
         return { consume: true };
@@ -43116,26 +44099,26 @@ class NekoTuiApp {
           return { consume: true };
         }
       }
-      if (matchesKey12(data, "escape") && this.#editor.isShowingAutocomplete()) {
+      if (matchesKey13(data, "escape") && this.#editor.isShowingAutocomplete()) {
         this.#editor.resetEscapeSequence();
         return;
       }
-      if (matchesKey12(data, "ctrl+c")) {
+      if (matchesKey13(data, "ctrl+c")) {
         if (this.#busyText !== undefined)
           this.abort();
         else
           this.exit();
         return { consume: true };
       }
-      if (matchesKey12(data, "escape") && (this.#busyText !== undefined || this.#lastView?.compaction?.active.some((c) => c.reason === "manual" || c.blocking))) {
+      if (matchesKey13(data, "escape") && (this.#busyText !== undefined || this.#lastView?.compaction?.active.some((c) => c.reason === "manual" || c.blocking))) {
         this.abort();
         return { consume: true };
       }
-      if (matchesKey12(data, "ctrl+s")) {
+      if (matchesKey13(data, "ctrl+s")) {
         this.openSessionsOverlay();
         return { consume: true };
       }
-      if (this.#busyText !== undefined && matchesKey12(data, "alt+enter")) {
+      if (this.#busyText !== undefined && matchesKey13(data, "alt+enter")) {
         this.submitFollowUp();
         return { consume: true };
       }
@@ -43194,7 +44177,7 @@ class NekoTuiApp {
       const installed = await installedVersion();
       if (this.#exitStarted)
         return;
-      const notice = versionNotice(this.#gateway.client.application.info.value ?? null, installed);
+      const notice = versionNotice(this.#gateway.client.application.info.value, installed);
       this.#versionNotice.clear();
       if (notice)
         this.#versionNotice.addChild(new ThemedTruncatedText(() => formatNotice(notice, "info"), 1, 0));
@@ -43242,6 +44225,14 @@ class NekoTuiApp {
       this.#showJobs();
       return;
     }
+    if (trimmed === "/search") {
+      this.#showSearch();
+      return;
+    }
+    if (trimmed === "/context") {
+      this.#showContext();
+      return;
+    }
     const instructions = compactInstructions(trimmed);
     if (instructions !== null) {
       const chat = this.#chat;
@@ -43293,7 +44284,7 @@ class NekoTuiApp {
     if (trimmed === "/version") {
       if (!this.#exitStarted && !this.#panel.open && !this.#login.open) {
         openVersion(this.#panel, async () => ({
-          state: this.#gateway.client.application.info.value ?? null,
+          state: this.#gateway.client.application.info.value,
           installed: await installedVersion()
         }), () => this.#gateway.client.application.check(null));
         this.#ui.setFocus(this.#panel);
@@ -43327,7 +44318,7 @@ class NekoTuiApp {
     const chat = this.#chat;
     if (chat === undefined)
       return;
-    if (this.#lastView?.agent.model?.provider === "deepseek" && this.#gateway.client.credentials.state.value?.statuses.deepseek.source === "none") {
+    if (this.#lastView?.agent.model?.provider === "deepseek" && this.#gateway.client.credentials.state.value.statuses.deepseek.source === "none") {
       this.#editor.setText(text);
       this.addNotice("Configure DeepSeek with /login before sending.", "warning");
       return;
@@ -43445,7 +44436,7 @@ class NekoTuiApp {
       this.addNotice(messageOf(error), "warning", { wrap: true });
       return;
     }
-    const summary = this.#gateway.client.directory.state.value?.sessions.find((s) => s.id === sessionId);
+    const summary = this.#gateway.client.directory.state.value.sessions.find((s) => s.id === sessionId);
     const title = summary ? sessionName(summary, "") : "";
     this.addNotice("Exporting...");
     try {
@@ -43498,8 +44489,7 @@ class NekoTuiApp {
     this.#historyItems = undefined;
     this.#resetTranscript();
     const view = handle.view;
-    if (view.value !== undefined)
-      this.applyView(view.value);
+    this.applyView(view.value);
     this.#viewUnsubscribe = view.subscribe(() => {
       this.scheduleApply();
     });
@@ -43541,7 +44531,7 @@ class NekoTuiApp {
   async archiveSession() {
     const current = this.#sessionId;
     await this.#gateway.client.management.archive(current);
-    const next = recentlyVisited(this.#gateway.client.directory.state.value?.sessions ?? [], this.#options.cwd).find((s) => s.id !== current);
+    const next = recentlyVisited(this.#gateway.client.directory.state.value.sessions, this.#options.cwd).find((s) => s.id !== current);
     if (next)
       await this.switchSession(next.id);
     else
@@ -43550,7 +44540,7 @@ class NekoTuiApp {
   sessionItems() {
     return [
       { value: NEW_SESSION_VALUE, label: "+ New session", description: this.#options.cwd },
-      ...sessionPickerItems(this.#gateway.client.directory.state.value?.sessions ?? [], this.#options.cwd, this.#sessionId)
+      ...sessionPickerItems(this.#gateway.client.directory.state.value.sessions, this.#options.cwd, this.#sessionId)
     ];
   }
   openSessionsOverlay() {
@@ -43685,7 +44675,7 @@ class NekoTuiApp {
     this.#panel.pointerSelection = true;
     this.#panel.emptyText = JOBS_EMPTY;
     this.#panel.listKey = (data, value) => {
-      if (matchesKey12(data, "left")) {
+      if (matchesKey13(data, "left")) {
         this.#panel.close();
         return true;
       }
@@ -43699,6 +44689,18 @@ class NekoTuiApp {
     this.#panel.show("Jobs", async () => jobItems(jobs.list()), async (value) => new JobDetail(jobs, value, this.#panel, changed).open());
     this.#ui.setFocus(this.#panel);
   }
+  #showSearch() {
+    if (this.#exitStarted || this.#panel.open || this.#login.open)
+      return;
+    this.#searchStop = openSearchPanel(this.#panel, this.#gateway.client, (message) => this.addNotice(message));
+    this.#ui.setFocus(this.#panel);
+  }
+  #showContext() {
+    if (this.#exitStarted || this.#panel.open || this.#login.open)
+      return;
+    this.#contextStop = openContextPanel(this.#panel, this.#gateway.client, (message) => this.addNotice(message));
+    this.#ui.setFocus(this.#panel);
+  }
   #agentDetail(target) {
     const round = typeof target === "number" ? this.#lastView?.subagents?.find((r) => r.taskId === target) : undefined;
     const id = typeof target === "string" ? target : round?.agentId ?? `agent-${round?.childId}`;
@@ -44085,14 +45087,7 @@ async function runTui(options = {}) {
   }
 }
 async function initialSessionId(gateway, cwd) {
-  const state = gateway.client.directory.state;
-  const start = Date.now();
-  while (state.value === undefined) {
-    if (Date.now() - start > 5000)
-      throw new Error("Timed out loading sessions");
-    await new Promise((resolve) => setTimeout(resolve, 25));
-  }
-  const sessions = state.value?.sessions ?? [];
+  const sessions = gateway.client.directory.state.value.sessions;
   const first = recentlyVisited(sessions, cwd)[0];
   if (first !== undefined)
     return first.id;
@@ -44118,6 +45113,7 @@ var init_tui = __esm(() => {
   init_tool_execution();
   init_user_message();
   init_welcome();
+  init_context_ui();
   init_export_command();
   init_file_completion();
   init_gateway2();
@@ -44126,6 +45122,7 @@ var init_tui = __esm(() => {
   init_jobs_ui();
   init_labels();
   init_layout();
+  init_search_ui();
   init_skill_market_ui();
   init_subagents_ui();
   init_theme();
@@ -44216,7 +45213,7 @@ var USAGE = `\u7528\u6CD5: neko tui [\u9009\u9879]
 
 \u6062\u590D\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\u6700\u8FD1\u4F7F\u7528\u7684\u4F1A\u8BDD\uFF0C\u4E0D\u5B58\u5728\u5219\u521B\u5EFA\u3002
 \u6309\u9700\u62C9\u8D77\u7F51\u5173\uFF0C\u5C5E\u4E3B TUI \u9000\u51FA\u65F6\u968F\u4E4B\u505C\u6B62\u3002
-\u53EF\u7528 /login \u6216 DEEPSEEK_API_KEY \u914D\u7F6E\u51ED\u636E\u3002`;
+\u53EF\u7528 /login \u6216 DEEPSEEK_API_KEY \u914D\u7F6E\u51ED\u636E\uFF1B/search \u9009\u62E9\u8054\u7F51\u641C\u7D22\u670D\u52A1\uFF08tavily / deepseek\uFF0C\u9ED8\u8BA4 tavily\uFF09\uFF1B/context \u8C03\u6574\u4E0A\u4E0B\u6587\u538B\u7F29\u4E0E\u5DE5\u5177\u7ED3\u679C\u88C1\u526A\u3002`;
 var init_main = __esm(async () => {
   init_tui();
   try {
@@ -44453,7 +45450,7 @@ var init_gateway_spawn = __esm(() => {
 
 // packages/web/src/mobile-admin.ts
 import { randomBytes as randomBytes4, timingSafeEqual as timingSafeEqual3 } from "crypto";
-import { ChordError as ChordError7, createHost as createHost4 } from "@earendil-works/chord";
+import { ChordError as ChordError7 } from "@earendil-works/chord";
 function createMobileAdminCaller(gateway, nekoDir, timeouts = {}) {
   const serverId = gateway.serverId;
   let tokenPromise;
@@ -44468,7 +45465,7 @@ function createMobileAdminCaller(gateway, nekoDir, timeouts = {}) {
     const token = await readToken();
     signal.throwIfAborted();
     const link = gateway.socketPath !== undefined ? await createUnixLink(gateway.socketPath) : createWsLink(gateway.wsUrl);
-    const host = createHost4({ kind: "client", upstream: identifiedLink(link, serverId), onError: () => {} });
+    const host = createClientHost(link);
     const release = () => {
       host.close().catch(() => {
         return;
@@ -44477,7 +45474,8 @@ function createMobileAdminCaller(gateway, nekoDir, timeouts = {}) {
     };
     signal.addEventListener("abort", release, { once: true });
     try {
-      const admin = host.get(NekoMobileAdmin, { token }, { at: serverId });
+      await assertGatewayIdentity(host, serverId, signal);
+      const admin = await host.get(NekoMobileAdmin, { token }, { signal });
       const call = admin[method];
       if (call === undefined)
         throw new Error(`unknown mobile admin method: ${method}`);
@@ -45167,7 +46165,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`;
 
 // packages/gateway/src/main.ts
 var argv, shutdown2, options, gateway;
@@ -45211,7 +46210,8 @@ var USAGE3 = `\u7528\u6CD5: neko <\u547D\u4EE4> [\u9009\u9879]
   -h, --help     \u663E\u793A\u6B64\u5E2E\u52A9
 
 \u5404\u547D\u4EE4\u7684\u9009\u9879\u8BE6\u89C1 neko <\u547D\u4EE4> --help\u3002
-\u53EF\u901A\u8FC7 TUI /login\u3001Web \u8BBE\u7F6E\u9875\u6216 DEEPSEEK_API_KEY / TAVILY_API_KEY \u914D\u7F6E\u51ED\u636E\u3002`;
+\u53EF\u901A\u8FC7 TUI /login\u3001Web \u8BBE\u7F6E\u9875\u6216 DEEPSEEK_API_KEY / TAVILY_API_KEY \u914D\u7F6E\u51ED\u636E\u3002
+\u8054\u7F51\u641C\u7D22\u670D\u52A1\uFF08\u9ED8\u8BA4 Tavily\uFF0C\u53EF\u6539\u9009 DeepSeek\uFF09\u53EF\u7528 TUI /search\u3001Web \u8BBE\u7F6E\u9875\u6216\u914D\u7F6E\u6587\u4EF6 webSearch.provider \u9009\u62E9\u3002`;
 var [command2, ...rest] = process.argv.slice(2);
 switch (command2) {
   case "update": {