@ashrlabs/ashr 0.0.0-stage → 0.1.0

package/dist/ashr.js

@@ -0,0 +1,4604 @@
+#!/usr/bin/env node
+
+// src/main.ts
+import { existsSync as existsSync7 } from "node:fs";
+import { dirname as dirname5, join as join9, resolve as resolve9 } from "node:path";
+import { ProcessTerminal as ProcessTerminal2 } from "@earendil-works/pi-tui";
+
+// package.json
+var package_default = {
+  name: "@ashrlabs/ashr",
+  version: "0.1.0",
+  description: "Ashr terminal agent for post-training models",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/ashrlabs/manifold.git",
+    directory: "cli"
+  },
+  type: "module",
+  engines: {
+    node: ">=22.19.0"
+  },
+  bin: {
+    ashr: "dist/ashr.js"
+  },
+  files: [
+    "dist"
+  ],
+  scripts: {
+    build: "node scripts/build.mjs",
+    typecheck: "tsc -p tsconfig.json --noEmit",
+    test: "vitest --run",
+    "test:parity": "vitest --run --config vitest.parity.config.ts",
+    "test:parity:browser": "node scripts/test-parity-browser.mjs"
+  },
+  dependencies: {
+    "@earendil-works/pi-agent-core": "0.87.1",
+    "@earendil-works/pi-ai": "0.87.1",
+    "@earendil-works/pi-coding-agent": "0.87.1",
+    "@earendil-works/pi-tui": "0.87.1",
+    "js-tiktoken": "1.0.21",
+    picomatch: "4.0.7",
+    "shell-quote": "1.12.0"
+  },
+  devDependencies: {
+    "@types/node": "22.19.19",
+    "@types/picomatch": "4.0.3",
+    "@types/shell-quote": "1.7.5",
+    "@xterm/headless": "6.0.0",
+    esbuild: "0.28.2",
+    typescript: "7.0.2",
+    vitest: "4.1.9"
+  }
+};
+
+// src/agent/models.ts
+import { findEnvKeys, getProviders } from "@earendil-works/pi-ai/compat";
+var PROVIDER_KEYS = {
+  anthropic: ["ANTHROPIC_API_KEY", "ANTHROPIC_OAUTH_TOKEN"],
+  openai: ["OPENAI_API_KEY"],
+  google: ["GEMINI_API_KEY", "GOOGLE_API_KEY"],
+  openrouter: ["OPENROUTER_API_KEY"],
+  xai: ["XAI_API_KEY"],
+  groq: ["GROQ_API_KEY"],
+  mistral: ["MISTRAL_API_KEY"],
+  cerebras: ["CEREBRAS_API_KEY"]
+};
+function piProviderKeys() {
+  const everything = new Proxy({}, { get: () => "set", has: () => true });
+  return getProviders().flatMap((provider) => findEnvKeys(provider, everything) ?? []);
+}
+var SHELL_CREDENTIALS = /* @__PURE__ */ new Set(["HF_TOKEN"]);
+var SECRET_NAMES = [.../* @__PURE__ */ new Set([...Object.values(PROVIDER_KEYS).flat(), ...piProviderKeys(), "ASHR_API_KEY"])].filter((name) => !SHELL_CREDENTIALS.has(name));
+var PREFERRED = [
+  "anthropic/claude-opus-5-5",
+  "anthropic/claude-fable-5-1",
+  "anthropic/claude-sonnet-5-5",
+  "anthropic/claude-opus-5",
+  "openai/gpt-5",
+  "google/gemini-3.1-pro-preview"
+];
+var ModelError = class extends Error {
+};
+function hasKey(provider, env) {
+  return (PROVIDER_KEYS[provider] ?? []).some((name) => Boolean(env[name]));
+}
+function parse(model) {
+  const slash = model.indexOf("/");
+  if (slash <= 0 || slash === model.length - 1) throw new ModelError(`"${model}" is not a model name. Use provider/model, for example anthropic/claude-opus-5-5.`);
+  return { provider: model.slice(0, slash), id: model.slice(slash + 1) };
+}
+function pickModel(runtime, opts) {
+  const env = opts.env ?? process.env;
+  if (opts.requested) {
+    const { provider, id } = parse(opts.requested);
+    const model = runtime.getModel(provider, id);
+    if (model) return { model, label: opts.requested };
+    const known = runtime.getModels(provider).slice(0, 8).map((m) => `${m.provider}/${m.id}`);
+    const choices = known.length ? ` Some ${provider} models: ${known.join(", ")}.` : "";
+    throw new ModelError(`Unknown model "${opts.requested}". Pick one with /model or --model.${choices}`);
+  }
+  for (const label of PREFERRED) {
+    const { provider, id } = parse(label);
+    if (!hasKey(provider, env)) continue;
+    const model = runtime.getModel(provider, id);
+    if (model) return { model, label };
+  }
+  throw new ModelError("No model provider key found. Set ANTHROPIC_API_KEY (or OPENAI_API_KEY, GEMINI_API_KEY), or run: ashr login --provider anthropic");
+}
+
+// src/args.ts
+var USAGE = `Usage:
+  ashr                      open your hosted Manifold workspace
+  ashr --local              start a local agent in this repo
+  ashr --task <name>        select a hosted task
+  ashr --chat <id>          open an existing hosted chat
+  ashr --service            require a Manifold service key (never opens a browser)
+      --api-url <url>      select the API deployment
+      --dashboard-url <url> select the dashboard used for browser sign-in
+  ashr -c, --continue       continue the latest session here
+  ashr -r, --resume         pick a session to resume
+  ashr -p "<prompt>"        run one turn and print the answer
+      --mode ask|edit|auto  local permission mode (default from settings, else auto)
+      --allow "<rule>"      allow one more rule for this run (repeatable)
+      --output text|json    how to print the result
+  ashr --local --model provider/id  use this local model (hosted: /model)
+  ashr login [--key ask_\u2026] [--api-url <url>]   sign in (browser, or a service key)
+  ashr login --provider anthropic [--key sk-\u2026] store a model provider key
+  ashr logout [--provider <name>]
+  ashr --version | --help`;
+var UsageError = class extends Error {
+  constructor(message) {
+    super(`${message}
+
+${USAGE}`);
+  }
+};
+function parseArgs(argv) {
+  const a = { command: "run", runtime: "hosted", service: false, continue: false, resume: false, allow: [], output: "text" };
+  let runtime;
+  const rest = [...argv];
+  if (rest[0] === "login" || rest[0] === "logout") a.command = rest.shift();
+  const value = (flag) => {
+    const v = rest.shift();
+    if (v === void 0 || v.startsWith("-") && v.length > 1) throw new UsageError(`${flag} needs a value.`);
+    return v;
+  };
+  while (rest.length) {
+    const flag = rest.shift();
+    switch (flag) {
+      case "--local":
+      case "--hosted": {
+        const selected = flag === "--local" ? "local" : "hosted";
+        if (runtime && runtime !== selected) throw new UsageError("Choose either --local or --hosted.");
+        runtime = selected;
+        break;
+      }
+      case "--service":
+        a.service = true;
+        break;
+      case "--task":
+        a.task = value(flag);
+        break;
+      case "--chat":
+        a.chat = value(flag);
+        break;
+      case "--dashboard-url":
+        a.dashboardUrl = value(flag);
+        break;
+      case "-h":
+      case "--help":
+        a.command = "help";
+        break;
+      case "-v":
+      case "--version":
+        a.command = "version";
+        break;
+      case "-c":
+      case "--continue":
+        a.continue = true;
+        break;
+      case "-r":
+      case "--resume":
+        a.resume = true;
+        break;
+      case "-p":
+      case "--print":
+        a.print = value(flag);
+        break;
+      case "--model":
+        a.model = value(flag);
+        break;
+      case "--allow":
+        a.allow.push(value(flag));
+        break;
+      case "--key":
+        a.key = value(flag);
+        break;
+      case "--api-url":
+        a.apiUrl = value(flag);
+        break;
+      case "--provider":
+        a.provider = value(flag);
+        break;
+      case "--mode": {
+        const m = value(flag);
+        if (m !== "ask" && m !== "edit" && m !== "auto") throw new UsageError(`--mode must be ask, edit or auto, not "${m}".`);
+        a.mode = m;
+        break;
+      }
+      case "--output": {
+        const o = value(flag);
+        if (o !== "text" && o !== "json") throw new UsageError(`--output must be text or json, not "${o}".`);
+        a.output = o;
+        break;
+      }
+      default:
+        throw new UsageError(`Unknown option ${flag}.`);
+    }
+  }
+  const localOptions = a.print !== void 0 || a.continue || a.resume || a.model !== void 0 || a.mode !== void 0 || a.allow.length > 0;
+  a.runtime = runtime ?? (localOptions ? "local" : "hosted");
+  if (a.command === "run") {
+    if (a.runtime === "hosted" && localOptions) throw new UsageError("Print, resume, model and permission flags apply to --local sessions only. Use /model within hosted chats.");
+    if (a.runtime === "local" && (a.task || a.chat || a.service)) throw new UsageError("Task, chat and service selection apply to hosted sessions only.");
+  }
+  return a;
+}
+
+// src/platform/credentials.ts
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname } from "node:path";
+
+// src/paths.ts
+import { createHash } from "node:crypto";
+import { homedir } from "node:os";
+import { basename, join, resolve } from "node:path";
+function ashrHome(env = process.env) {
+  return env.ASHR_HOME ? resolve(env.ASHR_HOME) : join(homedir(), ".ashr");
+}
+function repoSlug(repo) {
+  const abs = resolve(repo);
+  const name = basename(abs).replace(/[^A-Za-z0-9._-]/g, "_") || "root";
+  return `${name}-${createHash("sha256").update(abs).digest("hex").slice(0, 8)}`;
+}
+function ashrPaths(env = process.env) {
+  const home = ashrHome(env);
+  return {
+    home,
+    credentials: join(home, "credentials.json"),
+    settings: join(home, "settings.json"),
+    trust: join(home, "trust.json"),
+    agentDir: join(home, "agent"),
+    memory: join(home, "memory.md"),
+    sessions: (org, repo) => join(home, "sessions", org, repoSlug(repo))
+  };
+}
+
+// src/permissions/settings.ts
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join as join2 } from "node:path";
+function readJson(path) {
+  if (!existsSync(path)) return void 0;
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch (err) {
+    throw new Error(`${path} is not valid JSON (${err.message}). Fix or delete it.`);
+  }
+}
+var MODES = /* @__PURE__ */ new Set(["ask", "edit", "auto"]);
+var asMode = (m) => typeof m === "string" && MODES.has(m) ? m : void 0;
+function localIsShared(repoRoot) {
+  try {
+    execFileSync("git", ["ls-files", "--error-unmatch", "--", ".ashr/settings.local.json"], { cwd: repoRoot, stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function loadSettings(repoRoot, opts) {
+  const user = readJson(ashrPaths(opts.env).settings) ?? {};
+  const team = readJson(join2(repoRoot, ".ashr", "settings.json")) ?? {};
+  const local = readJson(join2(repoRoot, ".ashr", "settings.local.json")) ?? {};
+  const allow = [];
+  const deny = [];
+  const add = (file, source, withAllow) => {
+    for (const text of file.permissions?.deny ?? []) deny.push({ text, source });
+    if (withAllow) for (const text of file.permissions?.allow ?? []) allow.push({ text, source });
+  };
+  add(user, "~/.ashr/settings.json", true);
+  add(team, ".ashr/settings.json", opts.trusted);
+  const shared = localIsShared(repoRoot);
+  add(local, ".ashr/settings.local.json", opts.trusted || !shared);
+  const teamMode = (m) => opts.trusted && asMode(m) !== "auto" ? asMode(m) : void 0;
+  const localMode = shared ? teamMode(local.defaultMode) : asMode(local.defaultMode);
+  const untrusted = [...team.permissions?.allow ?? [], ...shared ? local.permissions?.allow ?? [] : []];
+  return {
+    rules: { allow, deny },
+    defaultMode: localMode ?? teamMode(team.defaultMode) ?? asMode(user.defaultMode) ?? "auto",
+    model: local.model ?? user.model,
+    ignored: { allow: opts.trusted ? [] : untrusted }
+  };
+}
+function addLocalRule(repoRoot, rule) {
+  const dir = join2(repoRoot, ".ashr");
+  mkdirSync(dir, { recursive: true });
+  const path = join2(dir, "settings.local.json");
+  const current = readJson(path) ?? {};
+  const allow = new Set(current.permissions?.allow ?? []);
+  allow.add(rule);
+  const next = { ...current, permissions: { ...current.permissions, allow: [...allow] } };
+  writeFileSync(path, `${JSON.stringify(next, null, 2)}
+`);
+  ignoreLocalFiles(repoRoot);
+}
+function ignoreLocalFiles(repoRoot) {
+  const dir = join2(repoRoot, ".ashr");
+  mkdirSync(dir, { recursive: true });
+  const ignore = join2(dir, ".gitignore");
+  const lines = existsSync(ignore) ? readFileSync(ignore, "utf8").split("\n").filter(Boolean) : [];
+  for (const want of ["settings.local.json", "data/"]) if (!lines.includes(want)) lines.push(want);
+  writeFileSync(ignore, `${lines.join("\n")}
+`);
+}
+function removeLocalRule(repoRoot, rule) {
+  const path = join2(repoRoot, ".ashr", "settings.local.json");
+  const current = readJson(path);
+  const allow = current?.permissions?.allow ?? [];
+  if (!current || !allow.includes(rule)) return false;
+  const next = { ...current, permissions: { ...current.permissions, allow: allow.filter((r) => r !== rule) } };
+  writeFileSync(path, `${JSON.stringify(next, null, 2)}
+`);
+  return true;
+}
+
+// src/platform/credentials.ts
+function readCredentials(env = process.env) {
+  const c = readJson(ashrPaths(env).credentials) ?? {};
+  return { ...c.manifold ? { manifold: c.manifold } : {}, providers: c.providers ?? {} };
+}
+function writeCredentials(c, env = process.env) {
+  const path = ashrPaths(env).credentials;
+  mkdirSync2(dirname(path), { recursive: true });
+  writeFileSync2(path, `${JSON.stringify(c, null, 2)}
+`, { mode: 384 });
+}
+function applyProviderKeys(c, env) {
+  for (const [provider, key2] of Object.entries(c.providers)) {
+    const names = PROVIDER_KEYS[provider];
+    if (!names?.length || names.some((n) => env[n])) continue;
+    env[names[0]] = key2;
+  }
+}
+
+// src/platform/manifold.ts
+var DEFAULT_API_URL = "https://api.manifold.ashr.io";
+var KeyRejectedError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "KeyRejectedError";
+  }
+  status;
+};
+async function validateKey(apiUrl, key2, fetchImpl = fetch) {
+  let res;
+  try {
+    res = await fetchImpl(`${apiUrl.replace(/\/$/, "")}/v1/tasks`, { headers: { Authorization: `Bearer ${key2}` } });
+  } catch (err) {
+    throw new Error(`Couldn't reach ${apiUrl}: ${err.message}. Check the address and your connection.`);
+  }
+  if (res.status === 401 || res.status === 403) throw new KeyRejectedError(`That key was rejected by ${apiUrl}. Create one in the Manifold dashboard under API keys.`, res.status);
+  if (!res.ok) throw new KeyRejectedError(`Manifold answered ${res.status} at ${apiUrl}. Try again, or check the address.`, res.status);
+}
+
+// src/print.ts
+import { relative as relative4, resolve as resolve5 } from "node:path";
+
+// src/agent/session.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync5, readFileSync as readFileSync3 } from "node:fs";
+import { join as join5 } from "node:path";
+import {
+  createAgentSessionFromServices,
+  createAgentSessionServices,
+  ModelRuntime,
+  SessionManager,
+  SettingsManager
+} from "@earendil-works/pi-coding-agent";
+
+// ../operator/src/context-budget.mjs
+import { closeSync, mkdirSync as mkdirSync3, openSync, readSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { Tiktoken } from "js-tiktoken/lite";
+import o200k from "js-tiktoken/ranks/o200k_base";
+var encoder;
+var maxTokenBytes;
+var openAIProviders = /* @__PURE__ */ new Set(["openai", "openai-codex", "azure"]);
+var TOKENIZER_CHUNK_SIZE = 1024;
+function tokenizer(model) {
+  if (!openAIProviders.has(model?.provider) || !/^(?:gpt-(?:4o|4\.[15]|[56](?:[.-]|$))|o[134](?:[.-]|$)|chatgpt-4o)/.test(model.id)) return null;
+  if (!encoder) {
+    encoder = new Tiktoken(o200k);
+    maxTokenBytes = 1;
+    for (const bytes of encoder.textMap.values()) maxTokenBytes = Math.max(maxTokenBytes, bytes.length);
+  }
+  return encoder;
+}
+function encodeText(text, model = void 0) {
+  const encoding = tokenizer(model);
+  const chunks = [];
+  const append = (text2, bpe) => chunks.push({ tokens: bpe ? encoding.encode(text2, [], []) : Buffer.from(text2, "utf8"), bpe });
+  if (encoding) {
+    let pending = "";
+    for (const [run] of text.matchAll(/\s+|\S+/gu)) {
+      if (pending.length + run.length > TOKENIZER_CHUNK_SIZE) {
+        if (pending) append(pending, true);
+        pending = "";
+      }
+      if (run.length > TOKENIZER_CHUNK_SIZE) append(run, false);
+      else pending += run;
+    }
+    if (pending) append(pending, true);
+  } else append(text, false);
+  const length = chunks.reduce((sum, chunk) => sum + chunk.tokens.length, 0);
+  return {
+    length,
+    slice: (start = 0, end = length) => {
+      start = start < 0 ? Math.max(0, length + start) : Math.min(start, length);
+      end = end < 0 ? Math.max(0, length + end) : Math.min(end, length);
+      const pieces = [];
+      let offset2 = 0;
+      for (const { tokens, bpe } of chunks) {
+        if (offset2 >= end) break;
+        if (offset2 + tokens.length > start) {
+          const slice = tokens.slice(Math.max(0, start - offset2), Math.max(0, end - offset2));
+          pieces.push(bpe ? Buffer.concat(slice.map((token) => encoding.textMap.get(token))) : slice);
+        }
+        offset2 += tokens.length;
+      }
+      return trimEnd(trimStart(Buffer.concat(pieces))).toString("utf8");
+    }
+  };
+}
+var estimateTokens = (text, model = void 0) => encodeText(text, model).length;
+var tokenByteCapacity = (tokens, model = void 0) => Math.floor(tokens) * (tokenizer(model) ? maxTokenBytes : 1);
+var REPLY_FLOOR_TOKENS = 4096;
+function replyReserve(messages = []) {
+  let largest = 0;
+  for (const message of messages) if (message?.role === "assistant") largest = Math.max(largest, message.usage?.output ?? 0);
+  return Math.max(REPLY_FLOOR_TOKENS, largest);
+}
+var ContextBudget = class {
+  constructor({ hardFraction }) {
+    if (!(hardFraction > 0 && hardFraction <= 1)) throw new Error("ContextBudget needs the session's hard context fraction");
+    this.hardFraction = hardFraction;
+    this.grants = /* @__PURE__ */ new Map();
+  }
+  /** `null` when the session cannot say how full it is (no session context, or no context window). */
+  measure(ctx, toolCallId) {
+    const usage = ctx?.getContextUsage?.();
+    if (!usage || usage.tokens == null || !usage.contextWindow) return null;
+    const messages = (ctx.sessionManager?.getBranch?.() || []).filter((e) => e.type === "message").map((e) => e.message);
+    const appended = new Set(messages.filter((m) => m?.role === "toolResult").map((m) => m.toolCallId));
+    for (const id of this.grants.keys()) if (appended.has(id)) this.grants.delete(id);
+    const pending = [...this.grants].reduce((sum, [id, tokens]) => sum + (id === toolCallId ? 0 : tokens), 0);
+    const reserve = replyReserve(messages);
+    const limit = Math.floor(this.hardFraction * usage.contextWindow) - reserve;
+    return { window: usage.contextWindow, used: usage.tokens, pending, reserve, limit, available: Math.max(0, limit - usage.tokens - pending) };
+  }
+  register(toolCallId, path) {
+    if (!this.grants.has(toolCallId)) this.grant(toolCallId, Buffer.byteLength(compactNotice(path, Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER)));
+  }
+  reserve(toolCallId, ctx, bytes) {
+    const measured = this.measure(ctx, toolCallId);
+    if (measured) {
+      measured.available = Math.min(measured.available, bytes);
+      this.grant(toolCallId, measured.available);
+    }
+    return measured;
+  }
+  release(toolCallId) {
+    this.grants.delete(toolCallId);
+  }
+  grant(toolCallId, tokens) {
+    this.grants.set(toolCallId, tokens);
+  }
+};
+function countLines(buffer) {
+  let lines = 0;
+  for (let i = buffer.indexOf(10); i !== -1; i = buffer.indexOf(10, i + 1)) lines++;
+  return lines + (buffer.length && buffer[buffer.length - 1] !== 10 ? 1 : 0);
+}
+var outputFileName = (toolCallId, ext = "txt") => `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}-${String(toolCallId).replace(/[^A-Za-z0-9_-]/g, "_")}.${ext}`;
+var readRange = (path, start, length) => {
+  const buffer = Buffer.alloc(length);
+  const fd = openSync(path, "r");
+  try {
+    return buffer.subarray(0, readSync(fd, buffer, 0, length, start));
+  } finally {
+    closeSync(fd);
+  }
+};
+var trimStart = (b) => {
+  let i = 0;
+  while (i < b.length && i < 4 && (b[i] & 192) === 128) i++;
+  return b.subarray(i);
+};
+var trimEnd = (b) => {
+  for (let back = 1; back <= Math.min(4, b.length); back++) {
+    const byte = b[b.length - back];
+    if ((byte & 192) === 128) continue;
+    const need = byte >= 240 ? 4 : byte >= 224 ? 3 : byte >= 192 ? 2 : 1;
+    return need > back ? b.subarray(0, b.length - back) : b;
+  }
+  return b;
+};
+function headAndTail(path, size, budgetBytes) {
+  const headBudget = Math.floor(budgetBytes / 4), tailBudget = budgetBytes - headBudget;
+  let head = trimEnd(readRange(path, 0, Math.min(headBudget, size)));
+  const headNewline = head.lastIndexOf(10);
+  if (headNewline !== -1) head = head.subarray(0, headNewline + 1);
+  const tailStart = Math.max(head.length, size - tailBudget);
+  let tail = trimStart(readRange(path, tailStart, size - tailStart));
+  let tailOffset = size - tail.length;
+  const tailNewline = tailOffset > 0 ? tail.indexOf(10) : -1;
+  if (tailNewline !== -1 && tailNewline < tail.length - 1) {
+    tail = tail.subarray(tailNewline + 1);
+    tailOffset = size - tail.length;
+  }
+  return { head, tail, tailOffset };
+}
+var compactNotice = (path, bytes, lines) => `[NOT SHOWN IN FULL. Full size: ${bytes} bytes, ${lines} lines. Full text: ${path}
+Use read with offset/limit for the rest.]`;
+function renderPartial(path, bytes, lines, measured, subject, model, encoded) {
+  const header = (headBytes, headLines, tailBytes, tailLines) => `[${subject.toUpperCase()} DOES NOT FIT THE CONTEXT YOU HAVE LEFT AND IS NOT SHOWN IN FULL. Full size: ${bytes} bytes, ${lines} lines. Full text: ${path}
+Shown below: ${headBytes ? `the first ${headBytes} bytes (lines 1-${headLines})` : "nothing from the start"} and ${tailBytes ? `the last ${tailBytes} bytes (lines ${lines - tailLines + 1}-${lines})` : "nothing from the end"}; ${bytes - headBytes - tailBytes} bytes in between are only in the file. Context: ${measured.used} tokens used of a ${measured.window}-token window; ${measured.available} tokens were available below the session's stop line after reserving ${measured.reserve} for your reply. Use read with offset/limit, grep, or sed on the file for the rest.]`;
+  const middle = (omitted2) => `
+[... ${omitted2} bytes omitted; see ${path} ...]
+`;
+  const overhead = Buffer.byteLength(header(bytes, lines, bytes, 1) + "\n" + middle(bytes));
+  if (overhead >= measured.available) return compactNotice(path, bytes, lines);
+  const available = measured.available - overhead;
+  const headTokens = Math.floor(available / 4), tailTokens = available - headTokens;
+  let headText, tailText;
+  if (encoded) {
+    headText = encoded.slice(0, headTokens);
+    tailText = tailTokens ? encoded.slice(-tailTokens) : "";
+  } else {
+    const candidates = headAndTail(path, bytes, tokenByteCapacity(available, model));
+    headText = encodeText(candidates.head.toString("utf8"), model).slice(0, headTokens);
+    tailText = tailTokens ? encodeText(candidates.tail.toString("utf8"), model).slice(-tailTokens) : "";
+  }
+  const headNewline = headText.lastIndexOf("\n"), tailNewline = tailText.indexOf("\n");
+  if (headNewline !== -1) headText = headText.slice(0, headNewline + 1);
+  if (tailNewline !== -1 && tailNewline < tailText.length - 1) tailText = tailText.slice(tailNewline + 1);
+  const head = Buffer.from(headText), tail = Buffer.from(tailText);
+  const omitted = bytes - head.length - tail.length;
+  return `${header(head.length, countLines(head), tail.length, countLines(tail))}
+${headText}${omitted > 0 ? middle(omitted) : ""}${tailText}`;
+}
+
+// ../operator/src/tools/bash.mjs
+import { openSync as openSync2, writeSync, closeSync as closeSync2, mkdirSync as mkdirSync4, readFileSync as readFileSync2 } from "node:fs";
+import { join as join3 } from "node:path";
+import { createBashToolDefinition, createLocalBashOperations, defineTool } from "@earendil-works/pi-coding-agent";
+var SECRET_ENVIRONMENT = ["ASHR_API_KEY", "MANIFOLD_PLATFORM_CONFIG"];
+function scrubbedEnvironment(env = process.env, extra = []) {
+  const clean2 = { ...env };
+  for (const name of [...SECRET_ENVIRONMENT, ...extra]) delete clean2[name];
+  return clean2;
+}
+function createBashTool({ cwd, outputDir, budget, secretNames = [] }) {
+  const pi = createBashToolDefinition(cwd);
+  return defineTool({
+    name: "bash",
+    label: "bash",
+    description: `Execute a bash command in the current working directory. Returns stdout and stderr. The complete output of every command is saved to a file under ${outputDir}. The whole output is returned inline whenever it fits the context you have left; when it does not, the result starts with the exact byte and line counts and the file path, followed by the start and end of the output that fit. Optionally provide a timeout in seconds (no default timeout).`,
+    promptSnippet: pi.promptSnippet,
+    promptGuidelines: pi.promptGuidelines,
+    parameters: pi.parameters,
+    async execute(toolCallId, params, signal, _onUpdate, ctx) {
+      mkdirSync4(outputDir, { recursive: true });
+      const path = join3(outputDir, outputFileName(toolCallId, "log"));
+      budget.register(toolCallId, path);
+      const controller = new AbortController();
+      const executionSignal = signal ? AbortSignal.any([signal, controller.signal]) : controller.signal;
+      let fd;
+      let persistenceFailure = null;
+      let bytes = 0, lines = 0, last = 10;
+      const local = createLocalBashOperations();
+      const operations = { exec: (command, dir, options) => local.exec(command, dir, { ...options, env: scrubbedEnvironment(options.env, secretNames), onData: (chunk) => {
+        if (persistenceFailure) return;
+        try {
+          for (let offset2 = 0; offset2 < chunk.length; ) {
+            const written = writeSync(fd, chunk, offset2, chunk.length - offset2);
+            if (written === 0) throw new Error("Output write made no progress");
+            offset2 += written;
+          }
+          bytes += chunk.length;
+          last = chunk[chunk.length - 1] ?? last;
+          for (let i = chunk.indexOf(10); i !== -1; i = chunk.indexOf(10, i + 1)) lines++;
+        } catch (error) {
+          persistenceFailure = error;
+          controller.abort();
+        }
+      } }) };
+      let failure = null;
+      let outcome;
+      try {
+        try {
+          fd = openSync2(path, "w", 384);
+        } catch (error) {
+          persistenceFailure = error;
+          throw error;
+        }
+        outcome = await createBashToolDefinition(cwd, { operations }).execute(toolCallId, params, executionSignal, void 0, ctx);
+      } catch (error) {
+        failure = error;
+      } finally {
+        if (fd !== void 0) {
+          try {
+            closeSync2(fd);
+          } catch (error) {
+            persistenceFailure ??= error;
+          }
+        }
+      }
+      if (persistenceFailure) {
+        const message = `Could not persist complete command output to ${path}: ${persistenceFailure.message}. The command was stopped; the output file may be incomplete or missing.`;
+        budget.grant(toolCallId, estimateTokens(message, ctx?.model));
+        throw new Error(message);
+      }
+      if (bytes && last !== 10) lines++;
+      const piText = failure ? String(failure.message ?? failure) : outcome?.isError ? outcome.content.map((part) => part.text ?? "").join("") : "";
+      const status = piText.replace(/^\(no output\)\n\n/, "").trim();
+      const measured = budget.reserve(toolCallId, ctx, bytes + Buffer.byteLength(status ? `
+
+${status}` : "(no output)"));
+      let text;
+      if (bytes === 0) text = status ? "" : "(no output)";
+      else {
+        const statusTokens = status ? estimateTokens(`
+
+${status}`, ctx?.model) : 0;
+        const available = measured ? Math.max(0, measured.available - statusTokens) : Infinity;
+        if (!measured || bytes <= tokenByteCapacity(available, ctx?.model)) text = readFileSync2(path, "utf8");
+        const encoded = text === void 0 ? void 0 : encodeText(text, ctx?.model);
+        if (measured && (!encoded || encoded.length > available)) text = renderPartial(path, bytes, lines, { ...measured, available }, "This command's output", ctx?.model, encoded);
+      }
+      const result = status ? `${text ? `${text}
+
+` : ""}${status}` : text;
+      budget.grant(toolCallId, estimateTokens(result, ctx?.model));
+      if (failure) throw new Error(result);
+      return { content: [{ type: "text", text: result }], details: { fullOutputPath: path, bytes, lines }, ...outcome?.isError ? { isError: true } : {} };
+    }
+  });
+}
+
+// src/permissions/gate.ts
+import { randomUUID } from "node:crypto";
+import { isAbsolute as isAbsolute2, relative as relative3 } from "node:path";
+
+// src/permissions/paths.ts
+import { lstatSync, readlinkSync, realpathSync } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { basename as basename2, dirname as dirname2, isAbsolute, join as join4, relative, resolve as resolve2 } from "node:path";
+import { fileURLToPath } from "node:url";
+function expandToolPath(path, base) {
+  let p = path.trim();
+  if (p.startsWith("@")) p = p.slice(1);
+  if (p.startsWith("file://")) p = fileURLToPath(p);
+  if (p === "~") p = homedir2();
+  else if (p.startsWith("~/")) p = join4(homedir2(), p.slice(2));
+  return isAbsolute(p) ? resolve2(p) : resolve2(base, p);
+}
+var exists = (p) => {
+  try {
+    lstatSync(p);
+    return true;
+  } catch {
+    return false;
+  }
+};
+function canonical(path) {
+  let cur = resolve2(path);
+  const rest = [];
+  while (!exists(cur)) {
+    const up = dirname2(cur);
+    if (up === cur) break;
+    rest.unshift(basename2(cur));
+    cur = up;
+  }
+  try {
+    cur = realpathSync(cur);
+  } catch {
+    try {
+      cur = resolve2(dirname2(cur), readlinkSync(cur));
+    } catch {
+    }
+  }
+  return join4(cur, ...rest);
+}
+function isInside(path, dir) {
+  const rel = relative(canonical(dir), canonical(path));
+  return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+}
+
+// src/permissions/rules.ts
+import { relative as relative2, sep } from "node:path";
+import picomatch from "picomatch";
+import { parse as parse2 } from "shell-quote";
+var SEPARATORS = /* @__PURE__ */ new Set(["&&", "||", ";", "|", "&", "|&", ";;"]);
+var REDIRECTS = /* @__PURE__ */ new Set([">", ">>", ">|", "&>", "&>>", ">&"]);
+function splitShell(command) {
+  const complex = /\$\(|`|<\(|>\(/.test(command);
+  const parts = [];
+  const redirects = [];
+  for (const line2 of command.split(/\r?\n/)) {
+    let words = [];
+    let redirectNext = false;
+    const flush = () => {
+      if (words.length) parts.push(words.join(" "));
+      words = [];
+    };
+    for (const tok of parse2(line2, (name) => `$${name}`)) {
+      if (typeof tok === "string" || "op" in tok && tok.op === "glob") {
+        const word = typeof tok === "string" ? tok : tok.pattern;
+        if (redirectNext) redirects.push(word);
+        else words.push(word);
+        redirectNext = false;
+      } else if ("op" in tok && SEPARATORS.has(tok.op)) flush();
+      else if ("op" in tok && REDIRECTS.has(tok.op)) redirectNext = true;
+      else if ("op" in tok) words.push(tok.op);
+    }
+    flush();
+  }
+  return { parts, complex, redirects };
+}
+function program(part) {
+  const words = part.split(" ");
+  while (words.length && /^[A-Za-z_][A-Za-z0-9_]*=/.test(words[0])) words.shift();
+  if (words[0]?.includes("/")) words[0] = words[0].slice(words[0].lastIndexOf("/") + 1);
+  return words;
+}
+function shellFlags(command) {
+  const dangerous = /* @__PURE__ */ new Set();
+  const notes = /* @__PURE__ */ new Set();
+  const { parts, complex } = splitShell(command);
+  const downloads = parts.some((p) => /\b(curl|wget)\b/.test(p));
+  const runsShell = parts.some((p) => /^(sh|bash|zsh|source|\.)$/.test(program(p)[0] ?? ""));
+  if (/\b(curl|wget)\b[^|]*\|\s*(sudo\s+)?(sh|bash|zsh|python3?)\b/.test(command) || downloads && (runsShell || complex)) dangerous.add("download into shell");
+  for (const part of parts) {
+    const [cmd = "", ...args] = program(part);
+    if (cmd === "sudo" || cmd === "doas") dangerous.add("sudo");
+    if (cmd === "git" && args.includes("push")) dangerous.add("git push");
+    if (cmd === "git" && args.some((a) => /^(--force|-f|--force-with-lease|--hard)$/.test(a))) dangerous.add("force");
+    if (/\b(curl|wget|ssh|scp|rsync|nc)\b|\bgit\s+clone\b/.test(part)) notes.add("network");
+    if (/^(rm|rmdir|shred)$/.test(cmd)) notes.add("deletes");
+    if (/\b(pip3?|npm|pnpm|yarn|brew|apt-get|apt)\s+(install|add|i)\b|\buv\s+pip\s+install\b/.test(part)) notes.add("package install");
+  }
+  return { dangerous: [...dangerous], notes: [...notes] };
+}
+function pathsIn(word) {
+  const value = /^--?[A-Za-z0-9-]+=(.+)$/.exec(word)?.[1] ?? word;
+  return /^(\/|~|\.\.(\/|$))|\/\.\.(\/|$)/.test(value) ? [value] : [];
+}
+function outsidePaths(command, repoRoot, extraDirs) {
+  const { parts, redirects } = splitShell(command);
+  const named = [...parts.flatMap((p) => p.split(" ").slice(1).flatMap(pathsIn)), ...redirects.flatMap(pathsIn)];
+  return named.filter((p) => {
+    const path = expandToolPath(p, repoRoot);
+    if (canonical(path).startsWith(`${sep}dev${sep}`)) return false;
+    return ![repoRoot, ...extraDirs].some((d) => isInside(path, d));
+  });
+}
+var READ_ONLY = /* @__PURE__ */ new Set([
+  "ls",
+  "cat",
+  "head",
+  "tail",
+  "wc",
+  "pwd",
+  "echo",
+  "printf",
+  "which",
+  "file",
+  "stat",
+  "tree",
+  "du",
+  "df",
+  "uname",
+  "whoami",
+  "date",
+  "grep",
+  "egrep",
+  "fgrep",
+  "rg",
+  "cut",
+  "tr",
+  "nl",
+  "diff",
+  "cmp",
+  "basename",
+  "dirname",
+  "realpath",
+  "readlink",
+  "jq",
+  "true",
+  "false",
+  "test"
+]);
+var GIT_READ_ONLY = /* @__PURE__ */ new Set(["status", "log", "diff", "show", "rev-parse", "ls-files", "blame", "describe", "shortlog"]);
+function readOnlyPart(part) {
+  const [cmd = "", ...args] = part.split(" ");
+  if (READ_ONLY.has(cmd)) return !(cmd === "rg" && args.some((a) => a.startsWith("--pre")));
+  if (cmd === "find") return !args.some((a) => /^-(exec|execdir|ok|okdir|delete|fprint\w*|fls)$/.test(a));
+  if (cmd === "git") return GIT_READ_ONLY.has(args[0] ?? "") && !args.some((a) => a.startsWith("--output"));
+  return /^(python3?|node|pip3?|uv|npm)$/.test(cmd) && args.length === 1 && /^(--version|-V)$/.test(args[0]);
+}
+function readOnlyShell(command) {
+  const { parts, complex, redirects } = splitShell(command);
+  return !complex && parts.length > 0 && redirects.every((t) => t.startsWith("/dev/") || /^&?\d$/.test(t)) && parts.every(readOnlyPart);
+}
+function ruleParts(text) {
+  const i = text.indexOf(":");
+  return i < 0 ? { kind: "", body: text } : { kind: text.slice(0, i), body: text.slice(i + 1) };
+}
+function shellRuleMatches(body, part) {
+  if (body === "*") return true;
+  if (body.endsWith(" *")) {
+    const prefix = body.slice(0, -2);
+    return part === prefix || part.startsWith(`${prefix} `);
+  }
+  return part === body;
+}
+function matches(rule, action, repoRoot) {
+  const { kind, body } = ruleParts(rule.text);
+  switch (action.kind) {
+    case "shell":
+      return kind === "shell" && shellRuleMatches(body, action.command);
+    case "edit":
+      return kind === "edit" && picomatch(body, { dot: true })(relative2(canonical(repoRoot), canonical(action.path)));
+    case "read":
+      return (kind === "read" || kind === "edit") && picomatch(body, { dot: true })(relative2(canonical(repoRoot), canonical(action.path)));
+    case "mcp": {
+      const [server, tool = "*"] = body.split(":");
+      return kind === "mcp" && server === action.server && picomatch(tool)(action.tool);
+    }
+    case "spend":
+      return false;
+  }
+}
+var SUBCOMMANDS = /* @__PURE__ */ new Set(["git", "npm", "pnpm", "yarn", "uv", "pip", "pip3", "docker", "kubectl", "cargo", "go", "model-ops", "make"]);
+function offerForPart(part) {
+  const words = part.split(" ");
+  const [cmd = ""] = words;
+  if (!cmd || /^[A-Za-z_][A-Za-z0-9_]*=/.test(cmd) || /^(env|time|xargs|nohup|nice|timeout|sudo|sh|bash|zsh|eval|exec)$/.test(cmd)) return null;
+  const sub = words[1];
+  return SUBCOMMANDS.has(cmd) && sub && !sub.startsWith("-") ? `shell:${cmd} ${sub} *` : `shell:${cmd} *`;
+}
+function offerFor(action, repoRoot) {
+  switch (action.kind) {
+    case "edit":
+      return `edit:${relative2(canonical(repoRoot), canonical(action.path))}`;
+    case "shell": {
+      const { parts, complex } = splitShell(action.command);
+      return !complex && parts.length === 1 ? offerForPart(parts[0]) : null;
+    }
+    case "mcp":
+      return `mcp:${action.server}:${action.tool}`;
+    default:
+      return null;
+  }
+}
+var isUnderGit = (path, repoRoot) => relative2(canonical(repoRoot), canonical(path)).split(sep)[0]?.toLowerCase() === ".git";
+function decide(action, ctx) {
+  const { mode, rules, repoRoot, extraDirs } = ctx;
+  const ask = (reason, flags2 = []) => ({ verdict: "ask", reason, offer: null, flags: flags2, needsPerson: true });
+  const parts = action.kind === "shell" ? splitShell(action.command).parts : [];
+  const deny = rules.deny.find((r) => action.kind === "shell" ? parts.some((p) => matches(r, { kind: "shell", command: p }, repoRoot)) : matches(r, action, repoRoot));
+  if (deny) return { verdict: "deny", reason: `blocked by rule ${deny.text} (${deny.source})`, offer: null, flags: [] };
+  if (action.kind === "spend") return ask("spends money on Manifold");
+  if ((action.kind === "read" || action.kind === "edit") && ![repoRoot, ...extraDirs].some((d) => isInside(action.path, d))) {
+    return ask("outside the repo", ["outside repo"]);
+  }
+  let flags = [];
+  if (action.kind === "shell") {
+    const f = shellFlags(action.command);
+    flags = [...f.dangerous, ...f.notes];
+    if (f.dangerous.length) return ask(`dangerous: ${f.dangerous.join(", ")}`, flags);
+    const outside = outsidePaths(action.command, repoRoot, extraDirs);
+    if (outside.length) return ask(`outside the repo: ${outside.join(", ")}`, [...flags, "outside repo"]);
+  }
+  if (action.kind === "edit" && mode !== "auto" && isUnderGit(action.path, repoRoot)) return ask("changes git's own files", ["git config"]);
+  if (action.kind === "read") return { verdict: "allow", reason: "read inside the repo", offer: null, flags };
+  if (action.kind === "shell" && readOnlyShell(action.command)) return { verdict: "allow", reason: "reads only, inside the repo", offer: null, flags };
+  if (mode === "auto") return { verdict: "allow", reason: "auto mode", offer: null, flags };
+  if (mode === "edit" && action.kind === "edit") return { verdict: "allow", reason: "edit mode", offer: null, flags };
+  if (action.kind === "shell") {
+    const complex = splitShell(action.command).complex;
+    const used = complex ? [] : parts.map((p) => rules.allow.find((r) => matches(r, { kind: "shell", command: p }, repoRoot)));
+    if (used.length && used.every(Boolean)) return { verdict: "allow", reason: `allowed by ${[...new Set(used.map((r) => r.text))].join(", ")}`, offer: null, flags };
+    const offer = offerFor(action, repoRoot);
+    if (offer) return { verdict: "ask", reason: `${mode} mode`, offer, flags };
+    const partRules = complex ? [] : parts.map(offerForPart).filter((r) => r !== null);
+    return { verdict: "ask", reason: `${mode} mode`, offer: null, flags, ...partRules.length === parts.length ? { partRules } : {} };
+  }
+  const allow = rules.allow.find((r) => matches(r, action, repoRoot));
+  if (allow) return { verdict: "allow", reason: `allowed by ${allow.text} (${allow.source})`, offer: null, flags };
+  return { verdict: "ask", reason: `${mode} mode`, offer: offerFor(action, repoRoot), flags };
+}
+
+// src/permissions/gate.ts
+var absolute = (p, root2) => canonical(expandToolPath(String(p ?? ""), root2));
+function classify(toolName, input, repoRoot) {
+  if (toolName === "bash") return { kind: "shell", command: String(input.command ?? "") };
+  if (toolName === "edit" || toolName === "write") return { kind: "edit", path: absolute(input.path, repoRoot) };
+  if (["read", "grep", "find", "ls"].includes(toolName)) return { kind: "read", path: absolute(input.path ?? ".", repoRoot) };
+  const mcp = /^mcp__(.+?)__(.+)$/.exec(toolName);
+  if (mcp) return { kind: "mcp", server: mcp[1], tool: mcp[2] };
+  return { kind: "mcp", server: "ashr", tool: toolName };
+}
+function editPreview(input) {
+  if (Array.isArray(input.edits)) {
+    const out = [];
+    for (const e of input.edits) {
+      for (const l of String(e.oldText ?? "").split("\n")) out.push(`- ${l}`);
+      for (const l of String(e.newText ?? "").split("\n")) out.push(`+ ${l}`);
+    }
+    return out;
+  }
+  return String(input.content ?? "").split("\n").map((l) => `+ ${l}`);
+}
+function describeAction(action, input, d, repoRoot) {
+  return { ...card(action, input, d, repoRoot), partRules: d.partRules ?? [], needsPerson: d.needsPerson ?? false };
+}
+function card(action, input, d, repoRoot) {
+  const shown = (p) => {
+    const r = relative3(canonical(repoRoot), p);
+    return r.startsWith("..") || isAbsolute2(r) ? p : r;
+  };
+  switch (action.kind) {
+    case "edit": {
+      const outside = d.flags.includes("outside repo");
+      return { kind: outside ? "outside" : "edit", title: outside ? "Write outside the repo" : "Edit", subject: shown(action.path), detail: editPreview(input), flags: d.flags, offer: d.offer };
+    }
+    case "read":
+      return { kind: "outside", title: "Read outside the repo", subject: action.path, detail: [], flags: d.flags, offer: null };
+    case "shell": {
+      const lines = action.command.split(/\r?\n/);
+      const long = lines.length > 1 || action.command.length > 60;
+      return { kind: "shell", title: "Shell", subject: long ? "" : action.command, detail: long ? lines : [], flags: d.flags, offer: d.offer };
+    }
+    case "mcp":
+      return { kind: "mcp", title: `${action.server} \xB7 ${action.tool}`, subject: JSON.stringify(input), detail: [], flags: d.flags, offer: d.offer };
+    case "spend":
+      return { kind: "spend", title: action.what, subject: "", detail: [], flags: [], offer: null };
+  }
+}
+function createGate(opts) {
+  return {
+    name: "ashr-gate",
+    hidden: true,
+    factory: (pi) => {
+      pi.on("tool_call", async (event, ctx) => {
+        const input = event.input;
+        const action = classify(event.toolName, input, opts.repoRoot);
+        const d = decide(action, { mode: opts.getMode(), rules: opts.getRules(), repoRoot: opts.repoRoot, extraDirs: opts.extraDirs() });
+        if (d.verdict === "deny") return { block: true, reason: `Not allowed: ${d.reason}.` };
+        if (d.verdict === "ask") {
+          const answer = await opts.approver.ask({ id: event.toolCallId || randomUUID(), ...describeAction(action, input, d, opts.repoRoot) }, ctx.signal);
+          if (!answer.approve) {
+            return { block: true, reason: answer.reason ? `The user rejected this: ${answer.reason}` : "The user rejected this action." };
+          }
+          if (answer.always && d.offer) {
+            addLocalRule(opts.repoRoot, d.offer);
+            opts.onRuleSaved?.(d.offer);
+          }
+        }
+        if (action.kind === "edit") opts.onBeforeWrite?.(action.path);
+        return void 0;
+      });
+    }
+  };
+}
+
+// src/agent/events.ts
+function resultText(result) {
+  const content = result?.content;
+  if (!Array.isArray(content)) return "";
+  return content.map((c) => c.type === "text" ? c.text ?? "" : "").join("");
+}
+function mapEvent(e) {
+  switch (e.type) {
+    case "message_update": {
+      const ev = e.assistantMessageEvent;
+      if (ev.type === "text_delta") return [{ type: "text", delta: ev.delta }];
+      if (ev.type === "thinking_delta") return [{ type: "thinking" }];
+      return [];
+    }
+    case "tool_execution_start":
+      return [{ type: "tool_start", id: e.toolCallId, name: e.toolName, args: e.args ?? {} }];
+    case "tool_execution_end": {
+      const text = resultText(e.result).trim();
+      return [{ type: "tool_end", id: e.toolCallId, name: e.toolName, isError: e.isError, summary: text.split("\n")[0] ?? "", output: text }];
+    }
+    case "turn_end":
+      return [{ type: "turn_end" }];
+    case "agent_settled":
+      return [{ type: "settled" }];
+    case "queue_update":
+      return [{ type: "queue", steering: [...e.steering], followUp: [...e.followUp] }];
+    case "compaction_start":
+      return [{ type: "compaction", phase: "start" }];
+    case "compaction_end":
+      return [{ type: "compaction", phase: "end", ...e.errorMessage ? { error: e.errorMessage } : {} }];
+    case "auto_retry_start":
+      return [{ type: "retry", attempt: e.attempt, max: e.maxAttempts, error: e.errorMessage }];
+    case "agent_end": {
+      const last = [...e.messages].reverse().find((m) => m.role === "assistant");
+      if (last?.stopReason === "error" && !e.willRetry) return [{ type: "error", message: last.errorMessage ?? "The model request failed." }];
+      return [];
+    }
+    default:
+      return [];
+  }
+}
+
+// src/agent/session.ts
+var ASHR_SYSTEM_PROMPT = [
+  "You are Ashr, a terminal agent for engineers who post-train models.",
+  "You work in the user's repository on their machine. You can read, edit and write files and run shell commands; the user approves actions according to their permission mode.",
+  "Be direct. Before a long or costly action, say what you will do. When the user rejects a tool call, adapt to their reason instead of retrying the same action."
+].join("\n");
+function contextFiles(repoRoot, env) {
+  return [join5(repoRoot, "ASHR.md"), ashrPaths(env).memory].filter((path) => existsSync2(path)).map((path) => ({ path, content: readFileSync3(path, "utf8") }));
+}
+function recordedModel(file, sessionDir, repoRoot) {
+  const entries = SessionManager.open(file, sessionDir, repoRoot).getEntries();
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const e = entries[i];
+    if (e.type === "model_change" && e.provider && e.modelId) return `${e.provider}/${e.modelId}`;
+    if (e.type === "message" && e.message?.role === "assistant" && e.message.provider && e.message.model) return `${e.message.provider}/${e.message.model}`;
+  }
+  return void 0;
+}
+function modelKnown(runtime, label) {
+  const slash = label.indexOf("/");
+  return slash > 0 && runtime.getModel(label.slice(0, slash), label.slice(slash + 1)) !== void 0;
+}
+async function createAshrSession(o) {
+  const env = o.env ?? process.env;
+  const paths = ashrPaths(env);
+  const outputDir = join5(o.sessionDir, "outputs");
+  for (const dir of [paths.agentDir, o.sessionDir]) mkdirSync5(dir, { recursive: true });
+  const modelRuntime = o.modelRuntime ?? await ModelRuntime.create({ authPath: join5(paths.agentDir, "auth.json"), modelsPath: null, refreshOnCreate: false });
+  const recorded = !o.model && o.sessionFile ? recordedModel(o.sessionFile, o.sessionDir, o.repoRoot) : void 0;
+  let notice;
+  let picked;
+  if (recorded && modelKnown(modelRuntime, recorded)) picked = pickModel(modelRuntime, { requested: recorded, env: process.env });
+  else {
+    picked = pickModel(modelRuntime, { requested: o.model, env: process.env });
+    if (recorded) notice = `Model ${recorded} is not available; using ${picked.label}. Change it with /model.`;
+  }
+  const { model, label } = picked;
+  const settingsManager = SettingsManager.inMemory({
+    compaction: { enabled: true },
+    retry: { enabled: true, maxRetries: 3, baseDelayMs: Number(env.ASHR_RETRY_BASE_MS ?? 2e3), maxAgentDelayMs: 6e4 }
+  });
+  const services = await createAgentSessionServices({
+    cwd: o.repoRoot,
+    agentDir: paths.agentDir,
+    settingsManager,
+    modelRuntime,
+    resourceLoaderOptions: {
+      noExtensions: true,
+      noThemes: true,
+      noContextFiles: true,
+      noSkills: true,
+      noPromptTemplates: true,
+      appendSystemPrompt: [],
+      extensionFactories: [
+        createGate({
+          repoRoot: o.repoRoot,
+          getMode: o.mode,
+          getRules: o.rules,
+          extraDirs: o.extraDirs,
+          approver: o.approver,
+          onRuleSaved: o.onRuleSaved,
+          onBeforeWrite: o.onBeforeWrite
+        })
+      ],
+      systemPrompt: ASHR_SYSTEM_PROMPT,
+      agentsFilesOverride: () => ({ agentsFiles: contextFiles(o.repoRoot, env) })
+    }
+  });
+  const sessionManager = o.sessionFile ? SessionManager.open(o.sessionFile, o.sessionDir, o.repoRoot) : SessionManager.create(o.repoRoot, o.sessionDir);
+  const bash = createBashTool({ cwd: o.repoRoot, outputDir, budget: new ContextBudget({ hardFraction: 0.9 }), secretNames: SECRET_NAMES });
+  const { session } = await createAgentSessionFromServices({
+    services,
+    sessionManager,
+    model,
+    tools: ["bash", "read", "edit", "write"],
+    customTools: [bash]
+  });
+  return {
+    session,
+    modelRuntime,
+    modelLabel: label,
+    outputDir,
+    ...notice ? { notice } : {},
+    subscribe: (fn) => session.subscribe((e) => {
+      for (const mapped of mapEvent(e)) fn(mapped);
+    }),
+    dispose: async () => session.dispose()
+  };
+}
+
+// src/permissions/trust.ts
+import { createHash as createHash2 } from "node:crypto";
+import { existsSync as existsSync3, mkdirSync as mkdirSync6, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "node:fs";
+import { dirname as dirname3, join as join6, resolve as resolve4 } from "node:path";
+var read = (path) => existsSync3(path) ? readFileSync4(path, "utf8") : "";
+function repoTrustState(repoRoot, env = process.env) {
+  const settingsPath = join6(repoRoot, ".ashr", "settings.json");
+  const mcpPath = join6(repoRoot, ".ashr", "mcp.json");
+  const localPath = join6(repoRoot, ".ashr", "settings.local.json");
+  const shared = localIsShared(repoRoot);
+  const content = [read(settingsPath), read(mcpPath), ...shared ? [read(localPath)] : []];
+  const hash = createHash2("sha256").update(content.join("\0")).digest("hex");
+  const files = [settingsPath, ...shared ? [localPath] : []].map((p) => readJson(p) ?? {});
+  const mcp = readJson(mcpPath) ?? {};
+  const allow = files.flatMap((f) => f.permissions?.allow ?? []);
+  const servers = Object.entries(mcp.mcpServers ?? {}).map(([name, s]) => ({
+    name,
+    command: s.url ?? [s.command, ...s.args ?? []].filter(Boolean).join(" ")
+  }));
+  const needed = allow.length > 0 || servers.length > 0 || files.some((f) => f.defaultMode !== void 0);
+  const store = readJson(ashrPaths(env).trust) ?? {};
+  return { needed, trusted: !needed || store[resolve4(repoRoot)] === hash, hash, allow, servers };
+}
+function trustRepo(repoRoot, hash, env = process.env) {
+  const path = ashrPaths(env).trust;
+  const store = readJson(path) ?? {};
+  store[resolve4(repoRoot)] = hash;
+  mkdirSync6(dirname3(path), { recursive: true });
+  writeFileSync4(path, `${JSON.stringify(store, null, 2)}
+`, { mode: 384 });
+  ignoreLocalFiles(repoRoot);
+}
+
+// src/print.ts
+async function runPrint(o) {
+  const out = o.stdout ?? ((s2) => process.stdout.write(s2));
+  const err = o.stderr ?? ((s2) => process.stderr.write(s2));
+  const trust = repoTrustState(o.repoRoot, o.env);
+  const settings = loadSettings(o.repoRoot, { trusted: trust.trusted, env: o.env });
+  const rules = { allow: [...settings.rules.allow, ...o.allow.map((text) => ({ text, source: "--allow" }))], deny: settings.rules.deny };
+  const mode = o.mode ?? settings.defaultMode;
+  const needed = [];
+  let s;
+  try {
+    s = await createAshrSession({
+      repoRoot: o.repoRoot,
+      sessionDir: ashrPaths(o.env).sessions(o.org ?? "default", o.repoRoot),
+      modelRuntime: o.modelRuntime,
+      model: o.model,
+      env: o.env,
+      mode: () => mode,
+      rules: () => rules,
+      extraDirs: () => [],
+      approver: {
+        ask: async (req) => {
+          needed.push(req);
+          return { approve: false, reason: "This needs approval and print mode cannot ask. Stop and explain what you would do." };
+        }
+      }
+    });
+  } catch (e) {
+    err(`${e.message}
+`);
+    return 1;
+  }
+  const tools = [];
+  const starts = /* @__PURE__ */ new Map();
+  let failure;
+  s.subscribe((e) => {
+    if (e.type === "tool_start") {
+      const subject = e.name === "bash" ? String(e.args.command ?? "") : typeof e.args.path === "string" ? relative4(o.repoRoot, resolve5(o.repoRoot, e.args.path)) : "";
+      starts.set(e.id, { name: e.name, subject });
+    }
+    if (e.type === "tool_end") tools.push({ ...starts.get(e.id) ?? { name: e.name, subject: "" }, isError: e.isError });
+    if (e.type === "error") failure = e.message;
+  });
+  try {
+    await s.session.prompt(o.prompt);
+  } catch (e) {
+    failure = e.message;
+  }
+  const last = [...s.session.messages].reverse().find((m) => m.role === "assistant");
+  const result = (last?.content ?? []).filter((c) => c.type === "text").map((c) => c.text ?? "").join("").trim();
+  const stats = s.session.getSessionStats();
+  await s.dispose();
+  if (failure) {
+    err(`${failure}
+`);
+    return 1;
+  }
+  if (needed.length) {
+    for (const req of needed) {
+      const rules2 = req.offer ? [req.offer] : req.partRules ?? [];
+      const allow = rules2.map((r) => `--allow "${r}"`).join(" ");
+      const hint = req.needsPerson ? "this always needs a person; run ashr interactively" : `rerun with ${allow ? `${allow} or ` : ""}--mode ${req.kind === "edit" ? "edit|auto" : "auto"}`;
+      err(`Needs approval in print mode: ${req.title} ${req.subject || req.detail[0] || ""}. To allow it, ${hint}.
+`);
+    }
+    return 3;
+  }
+  out(o.output === "json" ? `${JSON.stringify({ result, tools, usage: { tokens: stats.tokens.total, cost: stats.cost } })}
+` : `${result}
+`);
+  return 0;
+}
+
+// src/ui/app.ts
+import { existsSync as existsSync6, statSync as statSync2 } from "node:fs";
+import { isAbsolute as isAbsolute3, relative as relative5, resolve as resolve6 } from "node:path";
+import { Container, matchesKey, SelectList, Spacer, TuiMainScreen } from "@earendil-works/pi-tui";
+
+// src/agent/snapshots.ts
+import { createHash as createHash3 } from "node:crypto";
+import { existsSync as existsSync4, mkdirSync as mkdirSync7, readdirSync, readFileSync as readFileSync5, rmSync, writeFileSync as writeFileSync5 } from "node:fs";
+import { dirname as dirname4, join as join7 } from "node:path";
+var root = (dir, sessionId) => join7(dir, sessionId, "snapshots");
+var key = (path) => createHash3("sha256").update(path).digest("hex").slice(0, 16);
+function snapshotBefore(dir, sessionId, entryId, path) {
+  const file = join7(root(dir, sessionId), entryId, `${key(path)}.json`);
+  if (existsSync4(file)) return;
+  mkdirSync7(dirname4(file), { recursive: true });
+  const snap = existsSync4(path) ? { path, existed: true, content: readFileSync5(path).toString("base64") } : { path, existed: false };
+  writeFileSync5(file, JSON.stringify(snap));
+}
+function snapshotsAfter(dir, sessionId, entryIds) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const entryId of entryIds) {
+    const d = join7(root(dir, sessionId), entryId);
+    if (!existsSync4(d)) continue;
+    for (const name of readdirSync(d)) {
+      const snap = JSON.parse(readFileSync5(join7(d, name), "utf8"));
+      if (seen.has(snap.path)) continue;
+      seen.set(snap.path, { path: snap.path, existed: snap.existed, entryId, ...snap.content !== void 0 ? { content: Buffer.from(snap.content, "base64") } : {} });
+    }
+  }
+  return [...seen.values()];
+}
+function restore(snaps) {
+  for (const s of snaps) {
+    if (s.existed) {
+      mkdirSync7(dirname4(s.path), { recursive: true });
+      writeFileSync5(s.path, s.content ?? Buffer.alloc(0));
+    } else rmSync(s.path, { force: true });
+  }
+  return { restored: snaps.map((s) => s.path) };
+}
+
+// src/sessions/store.ts
+import { existsSync as existsSync5, linkSync, readFileSync as readFileSync6, renameSync, statSync, unlinkSync, writeFileSync as writeFileSync6 } from "node:fs";
+import { SessionManager as SessionManager2 } from "@earendil-works/pi-coding-agent";
+var MODE_ENTRY = "ashr-mode";
+async function listSessions(repoRoot, dir) {
+  if (!existsSync5(dir)) return [];
+  const infos = await SessionManager2.list(repoRoot, dir);
+  return infos.map((s) => ({ file: s.path, id: s.id, name: s.name ?? s.firstMessage.split("\n")[0] ?? "", updatedAt: s.modified.getTime(), messages: s.messageCount })).sort((a, b) => b.updatedAt - a.updatedAt);
+}
+async function latestSession(repoRoot, dir) {
+  return (await listSessions(repoRoot, dir))[0];
+}
+function alive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function lockHolder(file) {
+  const lock = `${file}.lock`;
+  if (!existsSync5(lock)) return void 0;
+  const pid = Number(readFileSync6(lock, "utf8").trim());
+  return Number.isInteger(pid) && pid > 0 && pid !== process.pid && alive(pid) ? pid : void 0;
+}
+function acquireLock(file) {
+  const lock = `${file}.lock`;
+  for (let attempt = 0; attempt < 3; attempt++) {
+    if (createLock(lock)) return { release: () => releaseLock(lock) };
+    const holder = livePid(lock);
+    if (holder !== void 0) return { heldBy: holder };
+    if (justCreated(lock)) continue;
+    const stale = `${lock}.${process.pid}.stale`;
+    try {
+      renameSync(lock, stale);
+    } catch {
+      continue;
+    }
+    const taken = livePid(stale);
+    if (taken !== void 0) {
+      try {
+        linkSync(stale, lock);
+      } catch {
+      }
+      unlinkSync(stale);
+      return { heldBy: taken };
+    }
+    unlinkSync(stale);
+  }
+  throw new Error(`Could not lock ${file}: another process keeps taking it.`);
+}
+function createLock(lock) {
+  const tmp = `${lock}.${process.pid}.tmp`;
+  writeFileSync6(tmp, String(process.pid));
+  try {
+    linkSync(tmp, lock);
+    return true;
+  } catch (err) {
+    if (err.code !== "EEXIST") throw err;
+    return false;
+  } finally {
+    unlinkSync(tmp);
+  }
+}
+function justCreated(lock) {
+  try {
+    return readFileSync6(lock, "utf8").trim() === "" && Date.now() - statSync(lock).mtimeMs < 5e3;
+  } catch {
+    return false;
+  }
+}
+function livePid(path) {
+  let pid;
+  try {
+    pid = Number(readFileSync6(path, "utf8").trim());
+  } catch {
+    return void 0;
+  }
+  return Number.isInteger(pid) && pid > 0 && alive(pid) ? pid : void 0;
+}
+function releaseLock(lock) {
+  try {
+    if (readFileSync6(lock, "utf8").trim() === String(process.pid)) unlinkSync(lock);
+  } catch {
+  }
+}
+function restoredMode(saved, fallback) {
+  return saved === "ask" || saved === "edit" || saved === "auto" ? saved : fallback;
+}
+function recordMode(sm, mode) {
+  sm.appendCustomEntry(MODE_ENTRY, { mode });
+}
+function lastRecordedMode(sm) {
+  const entries = sm.getEntries();
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const e = entries[i];
+    if (e.type === "custom" && e.customType === MODE_ENTRY) return e.data?.mode;
+  }
+  return void 0;
+}
+
+// src/ui/commands.ts
+var COMMANDS = [
+  { name: "/usage", group: "VIEWS", kind: "view", description: "tokens, context and cost for this session", run: (app) => app.showUsage() },
+  { name: "/permissions", group: "VIEWS", kind: "view", description: "permission rules; /permissions remove <rule> deletes one of yours", run: (app, args) => app.showPermissions(args) },
+  { name: "/resume", group: "SESSION", kind: "local", description: "open an earlier session in this repo", run: (app) => app.pickResume() },
+  { name: "/fork", group: "SESSION", kind: "local", description: "branch a new session from an earlier message", run: (app) => app.pickFork() },
+  { name: "/rewind", group: "SESSION", kind: "local", description: "go back to an earlier message, optionally restoring files", run: (app) => app.pickRewind() },
+  { name: "/compact", group: "SESSION", kind: "local", description: "summarise the conversation to free context", run: (app) => app.compact() },
+  { name: "/model", group: "SETTINGS", kind: "local", description: "switch the model", run: (app, args) => app.setModel(args) },
+  { name: "/mode", group: "SETTINGS", kind: "local", description: "ask, edit or auto", run: (app, args) => app.setMode(args) },
+  { name: "/add-dir", group: "SETTINGS", kind: "local", description: "let the agent use another directory this session", run: (app, args) => app.addDir(args) },
+  { name: "/help", group: "SETTINGS", kind: "view", description: "commands and keys", run: (app) => app.showHelp() },
+  { name: "/quit", group: "SETTINGS", kind: "local", description: "leave ashr", run: (app) => app.quit() }
+];
+var ORDER = ["TRAINING", "VIEWS", "SESSION", "SETTINGS"];
+function menuGroups(commands, values) {
+  return ORDER.map((label) => ({
+    label,
+    commands: commands.filter((c) => c.group === label).map((c) => ({ name: c.name, description: c.description, ...values[c.name] ? { value: values[c.name] } : {} }))
+  })).filter((g) => g.commands.length > 0);
+}
+
+// src/ui/components/approval.ts
+import { wrapTextWithAnsi } from "@earendil-works/pi-tui";
+
+// src/ui/components/layout.ts
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+var Block = class {
+  cachedWidth = -1;
+  cachedLines = [];
+  render(width) {
+    if (width !== this.cachedWidth) {
+      this.cachedLines = this.draw(width).map((l) => fit(l, width));
+      this.cachedWidth = width;
+    }
+    return this.cachedLines;
+  }
+  invalidate() {
+    this.cachedWidth = -1;
+  }
+  changed() {
+    this.cachedWidth = -1;
+  }
+};
+function fit(s, width) {
+  return visibleWidth(s) > width ? truncateToWidth(s, Math.max(0, width - 1), "\u2026") : s;
+}
+function line(left, right, width) {
+  const r = visibleWidth(right) > width - 2 ? fit(right, Math.max(0, width - 2)) : right;
+  const room = width - visibleWidth(r) - 1;
+  const l = visibleWidth(left) > room ? fit(left, Math.max(0, room)) : left;
+  return l + " ".repeat(Math.max(1, width - visibleWidth(l) - visibleWidth(r))) + r;
+}
+function formatTokens(n) {
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1e3) return `${Math.round(n / 1e3)}k`;
+  return String(n);
+}
+function formatDuration(ms) {
+  const s = Math.floor(ms / 1e3);
+  const h = Math.floor(s / 3600);
+  const m = Math.floor(s % 3600 / 60);
+  if (h > 0) return `${h}h${String(m).padStart(2, "0")}m`;
+  if (m > 0) return `${m}m${String(s % 60).padStart(2, "0")}s`;
+  return `${s}s`;
+}
+function clock(ms) {
+  const s = Math.floor(ms / 1e3);
+  return `${Math.floor(s / 60)}:${String(s % 60).padStart(2, "0")}`;
+}
+
+// src/ui/components/approval.ts
+var COLLAPSED_DETAIL = 12;
+var ApprovalCard = class extends Block {
+  constructor(t, req) {
+    super();
+    this.t = t;
+    this.req = req;
+  }
+  t;
+  req;
+  expanded = false;
+  /** While focused, a/r/A/e answer the card; Tab hands the keyboard to the input box. */
+  focused = true;
+  /** Drawn under its tool row: the row already names the tool and what it touches, so the title is left out. */
+  attached = false;
+  toggle() {
+    this.expanded = !this.expanded;
+    this.changed();
+  }
+  setFocused(focused) {
+    this.focused = focused;
+    this.changed();
+  }
+  draw(width) {
+    const { t, req } = this;
+    const rail = `${this.attached ? "   " : ""}${t.fg("accent", "\u2503")}`;
+    const indent = this.attached ? 6 : 4;
+    const label = req.kind === "spend" ? t.fg("warn", "SPEND") : t.fg("soft", "APPROVAL");
+    const lines = [];
+    if (!this.attached) lines.push(line(`${rail} ${t.bold(t.fg("text", req.title))}  ${t.fg("text", req.subject)}`, label, width));
+    const detail = this.expanded ? req.detail : req.detail.slice(0, COLLAPSED_DETAIL);
+    for (const d of detail) {
+      const colour = d.startsWith("- ") ? "bad" : d.startsWith("+ ") ? "ok" : "text";
+      for (const part of wrapTextWithAnsi(d, Math.max(1, width - indent))) lines.push(`${rail}   ${t.fg(colour, part)}`);
+    }
+    if (detail.length < req.detail.length) lines.push(`${rail}   ${t.fg("soft", `${req.detail.length - detail.length} more lines`)}`);
+    if (req.flags.length) lines.push(`${rail} ${t.fg("soft", req.flags.join(" \xB7 "))}`);
+    const keys = [`${t.bold(t.fg("accent", "a"))} ${t.bold(t.fg("text", "approve"))}`, `${t.fg("accent", "r")} ${t.fg("soft", "reject")}`];
+    if (req.offer) keys.push(`${t.fg("accent", "A")} ${t.fg("soft", `always allow ${req.offer}`)}`);
+    if (req.detail.length > COLLAPSED_DETAIL) keys.push(`${t.fg("accent", "e")} ${t.fg("soft", this.expanded ? "collapse" : "expand")}`);
+    keys.push(t.fg("soft", this.focused ? "tab to type" : "tab to answer"));
+    lines.push(this.attached ? line(`${rail} ${keys.join("   ")}`, label, width) : `${rail} ${keys.join("    ")}`);
+    return lines;
+  }
+};
+
+// src/ui/components/header.ts
+var Header = class extends Block {
+  constructor(t, info) {
+    super();
+    this.t = t;
+    this.info = info;
+  }
+  t;
+  info;
+  set(info) {
+    this.info = info;
+    this.changed();
+  }
+  draw(width) {
+    const { t, info } = this;
+    const where = [info.org, info.task, info.model].filter(Boolean).join(" \xB7 ");
+    return [line(` ${t.bold(t.fg("text", "ashr"))} ${t.fg("accent", "labs")}`, t.fg("soft", where), width), ` ${t.fg("hair", "\u2500".repeat(Math.max(0, width - 1)))}`];
+  }
+};
+
+// src/ui/components/input-box.ts
+import { Editor, truncateToWidth as truncateToWidth2, visibleWidth as visibleWidth2 } from "@earendil-works/pi-tui";
+
+// src/ui/theme.ts
+var PALETTES = {
+  dark: { text: "#f3f0e8", soft: "#a8a49a", hair: "#4a473f", accent: "#867afe", ok: "#34c38f", bad: "#e07a5f", warn: "#d4a24c" },
+  light: { text: "#141310", soft: "#57544c", hair: "#a29c90", accent: "#4d41d0", ok: "#0f8f62", bad: "#b3452b", warn: "#8f5f10" }
+};
+var rgb = (hex) => [1, 3, 5].map((i) => parseInt(hex.slice(i, i + 2), 16));
+function to256([r, g, b]) {
+  const step = (v) => v < 48 ? 0 : v < 115 ? 1 : Math.min(5, Math.round((v - 35) / 40));
+  const level = (i) => i === 0 ? 0 : 55 + i * 40;
+  const [qr, qg, qb] = [step(r), step(g), step(b)];
+  const cube = 16 + 36 * qr + 6 * qg + qb;
+  const avg = Math.round((r + g + b) / 3);
+  const greyIndex = avg > 238 ? 255 : avg < 8 ? 232 : 232 + Math.round((avg - 8) / 10);
+  const greyLevel = 8 + (greyIndex - 232) * 10;
+  const dist = (c) => (c[0] - r) ** 2 + (c[1] - g) ** 2 + (c[2] - b) ** 2;
+  return dist([level(qr), level(qg), level(qb)]) <= dist([greyLevel, greyLevel, greyLevel]) ? cube : greyIndex;
+}
+function colorMode(env = process.env) {
+  if (env.NO_COLOR !== void 0 && env.NO_COLOR !== "") return "none";
+  if (/truecolor|24bit/i.test(env.COLORTERM ?? "")) return "truecolor";
+  return "256";
+}
+function detectBackground(env = process.env, color2) {
+  if (env.ASHR_THEME === "light" || env.ASHR_THEME === "dark") return env.ASHR_THEME;
+  if (color2) return (0.2126 * color2.r + 0.7152 * color2.g + 0.0722 * color2.b) / 255 > 0.5 ? "light" : "dark";
+  return "dark";
+}
+function createTheme({ background, mode }) {
+  const palette = PALETTES[background];
+  const wrap = (open4, close) => (s) => mode === "none" ? s : `${open4}${s}${close}`;
+  return {
+    background,
+    mode,
+    fg(role, s) {
+      if (mode === "none") return s;
+      const c = rgb(palette[role]);
+      const open4 = mode === "truecolor" ? `\x1B[38;2;${c[0]};${c[1]};${c[2]}m` : `\x1B[38;5;${to256(c)}m`;
+      return `${open4}${s}\x1B[39m`;
+    },
+    bold: wrap("\x1B[1m", "\x1B[22m"),
+    dim: wrap("\x1B[2m", "\x1B[22m"),
+    italic: wrap("\x1B[3m", "\x1B[23m")
+  };
+}
+function markdownTheme(t) {
+  const f = (role) => (s) => t.fg(role, s);
+  return {
+    heading: (s) => t.bold(t.fg("text", s)),
+    link: f("accent"),
+    linkUrl: f("soft"),
+    code: f("accent"),
+    codeBlock: f("text"),
+    codeBlockBorder: f("hair"),
+    quote: f("soft"),
+    quoteBorder: f("hair"),
+    hr: f("hair"),
+    listBullet: f("soft"),
+    bold: t.bold,
+    italic: t.italic,
+    strikethrough: (s) => s,
+    underline: (s) => s
+  };
+}
+function editorTheme(t) {
+  return {
+    borderColor: (s) => t.fg("hair", s),
+    selectList: {
+      selectedPrefix: (s) => t.fg("accent", s),
+      selectedText: (s) => t.bold(t.fg("accent", s)),
+      description: (s) => t.fg("soft", s),
+      scrollInfo: (s) => t.fg("soft", s),
+      noMatch: (s) => t.fg("soft", s)
+    }
+  };
+}
+
+// src/ui/components/input-box.ts
+var PLACEHOLDER = "Ask, build, or steer the agent\u2026";
+var InputBox = class {
+  constructor(tui, t) {
+    this.t = t;
+    this.editor = new Editor(tui, editorTheme(t), { paddingX: 1 });
+  }
+  t;
+  editor;
+  get focused() {
+    return this.editor.focused;
+  }
+  set focused(v) {
+    this.editor.focused = v;
+  }
+  set onSubmit(fn) {
+    this.editor.onSubmit = fn;
+  }
+  getText() {
+    return this.editor.getText();
+  }
+  setText(text) {
+    this.editor.setText(text);
+  }
+  handleInput(data) {
+    this.editor.handleInput(data);
+  }
+  invalidate() {
+    this.editor.invalidate();
+  }
+  render(width) {
+    const { t } = this;
+    const inner = Math.max(4, width - 3);
+    const rendered = this.editor.render(inner);
+    const bottom = rendered.findIndex((l, i) => i > 0 && /^[─\s]*$/.test(l.replace(/\x1b\[[0-9;]*m/g, "")) && l.includes("\u2500"));
+    const content = rendered.slice(1, bottom > 0 ? bottom : rendered.length);
+    const below = bottom > 0 ? rendered.slice(bottom + 1) : [];
+    const bar = t.fg("hair", "\u2502");
+    const empty = this.getText() === "";
+    const body = content.map((l, i) => {
+      let text = l;
+      if (empty && i === 0) {
+        const cursor = l.match(/^\s*\x1b\[7m.\x1b\[0m/)?.[0] ?? " ";
+        text = truncateToWidth2(`${cursor}${t.fg("soft", PLACEHOLDER)}`, inner, "\u2026");
+      }
+      const padded = text + " ".repeat(Math.max(0, inner - visibleWidth2(text)));
+      return `${bar}${i === 0 ? t.fg("accent", "\u203A") : " "}${truncateToWidth2(padded, inner, "")}${bar}`;
+    });
+    return [
+      t.fg("hair", `\u250C${"\u2500".repeat(width - 2)}\u2510`),
+      ...body,
+      t.fg("hair", `\u2514${"\u2500".repeat(width - 2)}\u2518`),
+      ...below.map((l) => truncateToWidth2(l, width, ""))
+    ];
+  }
+};
+
+// src/ui/components/panels.ts
+function heading(t, title, sub, width) {
+  return [line(` ${t.bold(t.fg("text", title))}  ${t.fg("soft", sub)}`, t.fg("soft", "esc close"), width), ` ${t.fg("hair", "\u2500".repeat(Math.max(0, width - 1)))}`];
+}
+var UsagePanel = class extends Block {
+  constructor(t, s) {
+    super();
+    this.t = t;
+    this.s = s;
+  }
+  t;
+  s;
+  draw(width) {
+    const { t, s } = this;
+    const row = (label, value) => ` ${t.fg("soft", label.padEnd(12))}${value}`;
+    const pct = s.contextPercent;
+    const filled = pct === null ? 0 : Math.max(0, Math.min(20, Math.round(pct / 5)));
+    const cached = s.tokens.input ? Math.round(100 * s.tokens.cacheRead / (s.tokens.input + s.tokens.cacheRead)) : 0;
+    return [
+      ...heading(t, "Usage", "this session", width),
+      row("MODEL", t.fg("text", s.model)),
+      row("TOKENS", `${t.fg("text", s.tokens.total.toLocaleString("en-US"))}  ${t.fg("soft", `in ${s.tokens.input.toLocaleString("en-US")} \xB7 out ${s.tokens.output.toLocaleString("en-US")} \xB7 ${cached}% cached`)}`),
+      row("CONTEXT", `${t.fg("accent", "\u25AE".repeat(filled))}${t.fg("hair", "\u25AE".repeat(20 - filled))}  ${t.fg("text", pct === null ? "\u2014" : `${Math.round(pct)}%`)} ${t.fg("soft", `of ${formatTokens(s.contextWindow)} \xB7 compacts automatically near the limit`)}`),
+      row("MODEL COST", t.fg("text", `$${s.cost.toFixed(2)}`)),
+      row("SESSION", `${t.fg("text", formatDuration(s.elapsedMs))} ${t.fg("soft", `\xB7 ${s.turns} turns \xB7 ${s.toolCalls} tool calls`)}`)
+    ];
+  }
+};
+var PermissionsPanel = class extends Block {
+  constructor(t, v) {
+    super();
+    this.t = t;
+    this.v = v;
+  }
+  t;
+  v;
+  draw(width) {
+    const { t, v } = this;
+    const longest = Math.max(10, ...[...v.allow, ...v.deny].map((r) => r.text.length), ...v.ignored.map((r) => r.length));
+    const rows = [
+      ...v.deny.map((r) => ` ${t.fg("bad", "DENY ")}  ${t.fg("text", r.text.padEnd(longest))}  ${t.fg("soft", r.source)}`),
+      ...v.allow.map((r) => ` ${t.fg("ok", "ALLOW")}  ${t.fg("text", r.text.padEnd(longest))}  ${t.fg("soft", r.source)}`),
+      ...v.ignored.map((r) => ` ${t.fg("hair", "ALLOW")}  ${t.fg("soft", r.padEnd(longest))}  ${t.fg("warn", "not trusted \xB7 .ashr/settings.json")}`)
+    ];
+    return [
+      ...heading(t, "Permissions", `mode ${v.mode}`, width),
+      ...rows.length ? rows : [` ${t.fg("soft", "No rules yet. Answer A on an approval to save one.")}`],
+      "",
+      ` ${t.fg("soft", "Rules live in ~/.ashr/settings.json, .ashr/settings.json (team) and .ashr/settings.local.json (you).")}`
+    ];
+  }
+};
+
+// src/ui/components/slash-menu.ts
+var SlashMenu = class extends Block {
+  constructor(t, groups) {
+    super();
+    this.t = t;
+    this.groups = groups;
+  }
+  t;
+  groups;
+  prefix = "/";
+  index = 0;
+  visible() {
+    return this.groups.map((g) => ({ label: g.label, commands: g.commands.filter((c) => c.name.startsWith(this.prefix)) })).filter((g) => g.commands.length > 0);
+  }
+  flat() {
+    return this.visible().flatMap((g) => g.commands);
+  }
+  setGroups(groups) {
+    this.groups = groups;
+    this.changed();
+  }
+  filter(prefix) {
+    this.prefix = prefix || "/";
+    this.index = 0;
+    this.changed();
+  }
+  isEmpty() {
+    return this.flat().length === 0;
+  }
+  selected() {
+    return this.flat()[this.index];
+  }
+  /** dx moves along the list; dy jumps to the first command of the next or previous group. */
+  move(dx, dy) {
+    const flat = this.flat();
+    if (!flat.length) return;
+    if (dx) this.index = (this.index + dx + flat.length) % flat.length;
+    if (dy) {
+      const groups = this.visible();
+      const current = groups.findIndex((g) => g.commands.includes(flat[this.index]));
+      const target = groups[(current + dy + groups.length) % groups.length];
+      this.index = flat.indexOf(target.commands[0]);
+    }
+    this.changed();
+  }
+  draw() {
+    const { t } = this;
+    const sel = this.selected();
+    const rows = this.visible().map((g) => {
+      const items = g.commands.map((c) => {
+        const name = c === sel ? t.bold(t.fg("accent", c.name)) : t.fg("text", c.name);
+        return c.value ? `${name} ${t.fg("soft", c.value)}` : name;
+      });
+      return `  ${t.fg("soft", g.label.padEnd(10))}${items.join("  ")}`;
+    });
+    if (!sel) return [`  ${t.fg("soft", "No command starts with that. Enter sends it to the agent.")}`];
+    return [...rows, "", `  ${t.fg("accent", sel.name)}  ${t.fg("soft", sel.description)}`];
+  }
+};
+
+// src/ui/components/status-line.ts
+var MODE_COLOUR = { ask: "text", edit: "text", auto: "accent" };
+var StatusLine = class extends Block {
+  constructor(t) {
+    super();
+    this.t = t;
+  }
+  t;
+  info = { mode: "ask", tokens: 0, cost: 0, contextPercent: null, runs: [], streaming: false };
+  set(info) {
+    this.info = { ...this.info, ...info };
+    this.changed();
+  }
+  get current() {
+    return this.info;
+  }
+  draw(width) {
+    const { t, info } = this;
+    const dot = t.fg("soft", " \xB7 ");
+    const pct = info.contextPercent;
+    const filled = pct === null ? 0 : Math.max(0, Math.min(10, Math.round(pct / 10)));
+    const bar = `${t.fg("accent", "\u25AE".repeat(filled))}${t.fg("hair", "\u25AE".repeat(10 - filled))} ${t.fg("soft", pct === null ? "\u2014" : `${Math.round(pct)}%`)}`;
+    const parts = [t.fg(MODE_COLOUR[info.mode], info.mode), ...info.runs.map((r) => `${t.fg("warn", "\u25D0")} ${t.fg("text", r)}`), bar, t.fg("soft", formatTokens(info.tokens)), t.fg("soft", `$${info.cost.toFixed(2)}`)];
+    const right = info.streaming ? t.fg("soft", "esc stop") : t.fg("soft", info.hint ?? "");
+    return [line(`  ${parts.join(dot)}`, right, width)];
+  }
+};
+
+// src/ui/components/tool-row.ts
+var ToolRow = class extends Block {
+  constructor(t, info) {
+    super();
+    this.t = t;
+    this.info = info;
+  }
+  t;
+  info;
+  state = { kind: "running", elapsedMs: 0 };
+  expanded = false;
+  waiting = false;
+  /** While its approval card waits, the row says so instead of counting up. */
+  setWaiting(waiting) {
+    this.waiting = waiting;
+    this.changed();
+  }
+  setRunning(elapsedMs) {
+    this.state = { kind: "running", elapsedMs };
+    this.changed();
+  }
+  finish(r) {
+    const output = r.output ?? r.summary;
+    this.state = r.isError ? { kind: "failed", summary: r.summary, output } : { kind: "done", summary: r.summary, output };
+    this.changed();
+  }
+  toggle() {
+    this.expanded = !this.expanded;
+    this.changed();
+  }
+  get finished() {
+    return this.state.kind !== "running";
+  }
+  draw(width) {
+    const { t, info, state } = this;
+    const left = `   ${t.fg("soft", info.name.padEnd(5))} ${t.fg("text", info.subject.replace(/\s*\n\s*/g, " "))}`;
+    const status = state.kind === "running" ? t.fg("warn", this.waiting ? "needs approval" : `running ${clock(state.elapsedMs)}`) : state.kind === "done" ? t.fg("ok", "done") : t.fg("bad", "failed");
+    const lines = [line(left, status, width)];
+    if (state.kind === "running") return lines;
+    if (this.expanded) {
+      for (const l of state.output.split("\n")) lines.push(`        ${t.fg(state.kind === "failed" ? "bad" : "soft", l)}`);
+    } else if (state.kind === "failed" && state.summary) {
+      lines.push(`        ${t.fg("bad", state.summary)}`);
+    }
+    return lines;
+  }
+};
+
+// src/ui/components/turns.ts
+import { Markdown } from "@earendil-works/pi-tui";
+var INDENT = 7;
+var UserTurn = class extends Block {
+  constructor(t, text) {
+    super();
+    this.t = t;
+    this.text = text;
+  }
+  t;
+  text;
+  draw() {
+    const [first = "", ...rest] = this.text.split("\n");
+    return ["", ` ${this.t.fg("accent", "\u203A")} ${this.t.fg("text", first)}`, ...rest.map((l) => `   ${this.t.fg("text", l)}`)];
+  }
+};
+var AssistantTurn = class extends Block {
+  constructor(t) {
+    super();
+    this.t = t;
+    this.md = new Markdown("", 0, 0, markdownTheme(t));
+  }
+  t;
+  text = "";
+  note;
+  md;
+  append(delta) {
+    this.text += delta;
+    this.md.setText(this.text);
+    this.changed();
+  }
+  hasText() {
+    return this.text.trim().length > 0;
+  }
+  /** A soft trailing line, e.g. "stopped by you". */
+  setNote(note) {
+    this.note = note;
+    this.changed();
+  }
+  draw(width) {
+    const { t } = this;
+    const body = this.text ? this.md.render(Math.max(10, width - INDENT)) : [""];
+    const label = ` ${t.bold(t.fg("accent", "Ashr"))}  `;
+    const lines = ["", ...body.map((l, i) => (i === 0 ? label : " ".repeat(INDENT)) + l)];
+    if (this.note) lines.push(`${" ".repeat(INDENT)}${t.fg("soft", this.note)}`);
+    return lines;
+  }
+};
+
+// src/ui/route.ts
+function distance(a, b) {
+  const row = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    let prev = row[0];
+    row[0] = i;
+    for (let j = 1; j <= b.length; j++) {
+      const cur = row[j];
+      row[j] = Math.min(row[j] + 1, row[j - 1] + 1, prev + (a[i - 1] === b[j - 1] ? 0 : 1));
+      prev = cur;
+    }
+  }
+  return row[b.length];
+}
+function route(input, commands) {
+  const text = input.trim();
+  const first = text.split(/\s/, 1)[0] ?? "";
+  const spec = commands.find((c) => c.name === first);
+  if (spec) return { kind: "command", spec, args: text.slice(first.length).trim() };
+  if (/^\/[a-z-]+$/.test(first)) {
+    const suggestions = commands.map((c) => c.name).filter((n) => distance(n, first) <= 2);
+    if (suggestions.length) return { kind: "unknown", name: first, suggestions };
+  }
+  return { kind: "prompt", text };
+}
+
+// src/ui/app.ts
+var Note = class extends Block {
+  constructor(t, text, role = "soft") {
+    super();
+    this.t = t;
+    this.text = text;
+    this.role = role;
+  }
+  t;
+  text;
+  role;
+  draw() {
+    return this.text.split("\n").map((l) => ` ${this.t.fg(this.role, l)}`);
+  }
+};
+var Lines = class extends Block {
+  constructor(lines) {
+    super();
+    this.lines = lines;
+  }
+  lines;
+  draw() {
+    return this.lines;
+  }
+};
+var QueueStrip = class extends Block {
+  constructor(t) {
+    super();
+    this.t = t;
+  }
+  t;
+  items = [];
+  set(items) {
+    this.items = items;
+    this.changed();
+  }
+  draw() {
+    const { t } = this;
+    return this.items.map((q, i) => `  ${t.fg("soft", i === 0 ? "QUEUED" : "      ")}  ${q.kind === "steer" ? t.fg("accent", "steer") : t.fg("soft", "next ")}  ${t.fg("text", q.text.replace(/\n/g, " "))}`);
+  }
+};
+var TrustPrompt = class extends Block {
+  constructor(t, state) {
+    super();
+    this.t = t;
+    this.state = state;
+  }
+  t;
+  state;
+  draw() {
+    const { t, state } = this;
+    return [
+      ` ${t.fg("text", "This repo has team settings you haven't trusted yet.")}`,
+      "",
+      ...state.allow.map((r) => `   ${t.fg("ok", "ALLOW ")} ${t.fg("text", r)}`),
+      ...state.servers.map((s) => `   ${t.fg("accent", "MCP   ")} ${t.fg("text", s.name)}  ${t.fg("soft", s.command)}`),
+      "",
+      ` ${t.bold(t.fg("accent", "\u23CE"))} ${t.bold(t.fg("text", "trust and use"))}    ${t.fg("accent", "n")} ${t.fg("soft", "continue without")}    ${t.fg("accent", "e")} ${t.fg("soft", "show the file")}`
+    ];
+  }
+};
+function messageText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.map((c) => c.type === "text" ? c.text ?? "" : "").join("");
+}
+var App = class {
+  constructor(o) {
+    this.o = o;
+    this.t = o.theme ?? createTheme({ background: detectBackground(o.env), mode: colorMode(o.env) });
+    this.tui = new TuiMainScreen(o.terminal);
+    this.queue = new QueueStrip(this.t);
+    this.input = new InputBox(this.tui, this.t);
+    this.status = new StatusLine(this.t);
+    this.menu = new SlashMenu(this.t, menuGroups(COMMANDS, {}));
+    this.org = o.org ?? "default";
+    this.sessionDir = ashrPaths(o.env).sessions(this.org, o.repoRoot);
+    this.trust = repoTrustState(o.repoRoot, o.env);
+    this.settings = loadSettings(o.repoRoot, { trusted: this.trust.trusted, env: o.env });
+    this.mode = this.settings.defaultMode;
+    this.header = new Header(this.t, { org: this.org, model: "" });
+    this.done = new Promise((r) => {
+      this.finish = r;
+    });
+    for (const c of [this.approvalHost, new Spacer(1), this.queue, this.panelHost, this.input, this.menuHost, this.status]) this.live.addChild(c);
+    this.tui.addChild(this.transcript);
+    this.tui.addChild(this.live);
+  }
+  o;
+  t;
+  tui;
+  transcript = new Container();
+  live = new Container();
+  approvalHost = new Container();
+  panelHost = new Container();
+  menuHost = new Container();
+  queue;
+  input;
+  status;
+  menu;
+  header;
+  ashr;
+  unsubscribe = () => {
+  };
+  releaseLock = () => {
+  };
+  settings;
+  trust;
+  mode;
+  extraDirs = [];
+  streaming = false;
+  seq = 0;
+  currentTurn;
+  rows = /* @__PURE__ */ new Map();
+  lastFinished;
+  queued = [];
+  pending;
+  picker;
+  trustPrompt;
+  autoExplained = false;
+  lastCtrlC = 0;
+  lastView;
+  ticker;
+  finish;
+  done;
+  org;
+  sessionDir;
+  // ── lifecycle ────────────────────────────────────────────────────────────
+  async start() {
+    let file = this.o.sessionFile;
+    if (!file && this.o.continueLatest) file = (await latestSession(this.o.repoRoot, this.sessionDir))?.file;
+    await this.open(file, this.o.model);
+    this.input.onSubmit = (text) => void this.submit(text);
+    this.input.editor.onChange = () => this.updateMenu();
+    this.tui.addInputListener((data) => this.onKey(data));
+    if (this.trust.needed && !this.trust.trusted) {
+      this.trustPrompt = new TrustPrompt(this.t, this.trust);
+      this.panelHost.addChild(this.trustPrompt);
+    }
+    this.tui.setFocus(this.input);
+    this.tui.start();
+    await this.matchTerminalBackground();
+    this.ticker = setInterval(() => this.tick(), 1e3);
+    this.refreshStatus();
+    if (this.o.resumePicker) await this.pickResume();
+    this.o.onReady?.({ session: () => this.ashr, app: this });
+  }
+  /** Ask the terminal for its background colour and switch to the light palette on a light terminal. */
+  async matchTerminalBackground() {
+    if (this.o.theme || this.o.env.ASHR_THEME || this.t.mode === "none") return;
+    const rgb2 = await this.tui.queryTerminalBackgroundColor({ timeoutMs: 150 }).catch(() => void 0);
+    if (!rgb2 || detectBackground(this.o.env, rgb2) === this.t.background) return;
+    Object.assign(this.t, createTheme({ background: detectBackground(this.o.env, rgb2), mode: this.t.mode }));
+    this.tui.invalidate();
+    this.tui.requestRender(true);
+  }
+  async open(file, model) {
+    if (file) {
+      const lock = acquireLock(file);
+      if ("heldBy" in lock) throw new Error(`That session is open in another terminal (pid ${lock.heldBy}). Close it there, or start a new session.`);
+      this.releaseLock = lock.release;
+    }
+    this.ashr = await createAshrSession({
+      repoRoot: this.o.repoRoot,
+      sessionDir: this.sessionDir,
+      sessionFile: file,
+      modelRuntime: this.o.modelRuntime,
+      model,
+      env: this.o.env,
+      mode: () => this.mode,
+      rules: () => this.settings.rules,
+      extraDirs: () => this.extraDirs,
+      approver: this,
+      onRuleSaved: (rule) => {
+        this.reloadSettings();
+        const shared = localIsShared(this.o.repoRoot) ? ". Git tracks that file, so the rule is shared with your team and this repo will need trusting again" : "";
+        this.note(`Saved ${rule} to .ashr/settings.local.json${shared}`);
+      },
+      onBeforeWrite: (path) => {
+        const leaf = this.ashr.session.sessionManager.getLeafId();
+        if (leaf) snapshotBefore(this.sessionDir, this.ashr.session.sessionId, leaf, path);
+      }
+    });
+    if (!file) this.releaseLock = (() => {
+      const f = this.ashr.session.sessionFile;
+      if (!f) return () => {
+      };
+      const lock = acquireLock(f);
+      return "release" in lock ? lock.release : () => {
+      };
+    })();
+    this.unsubscribe = this.ashr.subscribe((e) => this.onEvent(e));
+    this.header.set({ org: this.org, model: this.ashr.modelLabel });
+    this.transcript.addChild(this.header);
+    if (file) {
+      this.replay();
+      this.note(`Resumed. ${this.ashr.session.messages.length} messages.`);
+      this.mode = restoredMode(lastRecordedMode(this.ashr.session.sessionManager), this.settings.defaultMode);
+    }
+    if (this.ashr.notice) this.note(this.ashr.notice, "warn");
+    this.updateMenuValues();
+  }
+  async close() {
+    this.unsubscribe();
+    if (this.streaming) await this.ashr.session.abort().catch(() => {
+    });
+    await this.ashr.dispose();
+    this.releaseLock();
+  }
+  async quit() {
+    if (this.ticker) clearInterval(this.ticker);
+    await this.close();
+    this.tui.stop();
+    this.finish(0);
+  }
+  // ── transcript ───────────────────────────────────────────────────────────
+  add(c) {
+    this.transcript.addChild(c);
+    this.tui.requestRender();
+  }
+  note(text, role = "soft") {
+    this.add(new Note(this.t, text, role));
+  }
+  replay() {
+    const results = /* @__PURE__ */ new Map();
+    for (const m of this.ashr.session.messages) {
+      if (m.role === "toolResult" && m.toolCallId) results.set(m.toolCallId, Boolean(m.isError));
+    }
+    for (const m of this.ashr.session.messages) {
+      if (m.role === "user") this.transcript.addChild(new UserTurn(this.t, messageText(m.content)));
+      if (m.role !== "assistant" || !Array.isArray(m.content)) continue;
+      for (const part of m.content) {
+        if (part.type === "text" && part.text?.trim()) {
+          const turn = new AssistantTurn(this.t);
+          turn.append(part.text);
+          this.transcript.addChild(turn);
+        }
+        if (part.type === "toolCall") {
+          const row = new ToolRow(this.t, { seq: ++this.seq, name: part.name ?? "tool", subject: this.subject(part.name ?? "", part.arguments ?? {}) });
+          row.finish({ isError: results.get(part.id ?? "") ?? false, summary: "" });
+          this.transcript.addChild(row);
+        }
+      }
+    }
+  }
+  subject(name, args) {
+    if (name === "bash") return String(args.command ?? "");
+    if (typeof args.path === "string") {
+      const rel = relative5(canonical(this.o.repoRoot), canonical(expandToolPath(args.path, this.o.repoRoot)));
+      return rel.startsWith("..") || isAbsolute3(rel) ? args.path : rel;
+    }
+    return JSON.stringify(args);
+  }
+  // ── agent events ─────────────────────────────────────────────────────────
+  onEvent(e) {
+    switch (e.type) {
+      case "text":
+        if (!this.currentTurn) {
+          this.currentTurn = new AssistantTurn(this.t);
+          this.transcript.addChild(this.currentTurn);
+        }
+        this.currentTurn.append(e.delta);
+        break;
+      case "tool_start": {
+        this.currentTurn = void 0;
+        const row = new ToolRow(this.t, { seq: ++this.seq, name: e.name, subject: this.subject(e.name, e.args) });
+        this.rows.set(e.id, { row, started: Date.now() });
+        this.transcript.addChild(row);
+        break;
+      }
+      case "tool_end": {
+        const r = this.rows.get(e.id);
+        r?.row.finish({ isError: e.isError, summary: e.summary, output: e.output });
+        if (r) this.lastFinished = r.row;
+        this.rows.delete(e.id);
+        this.refreshStatus();
+        break;
+      }
+      case "queue": {
+        const still = /* @__PURE__ */ new Set([...e.steering, ...e.followUp]);
+        for (const q of this.queued) if (!still.has(q.text)) this.transcript.addChild(new UserTurn(this.t, q.text));
+        this.queued = this.queued.filter((q) => still.has(q.text));
+        this.queue.set(this.queued);
+        if (still.size) this.currentTurn = void 0;
+        break;
+      }
+      case "settled":
+        this.streaming = false;
+        this.currentTurn = void 0;
+        this.refreshStatus();
+        break;
+      case "error":
+        this.note(`\u2717 ${e.message}`, "bad");
+        break;
+      case "compaction":
+        this.note(e.phase === "start" ? "Compacting the conversation to free context\u2026" : e.error ? `\u2717 Compaction failed: ${e.error}` : "Compacted. Earlier turns are summarised; the full history stays in the session file.", e.error ? "bad" : "soft");
+        break;
+      case "retry":
+        this.note(`Retrying (${e.attempt}/${e.max}): ${e.error}`, "warn");
+        break;
+      default:
+        break;
+    }
+    this.tui.requestRender();
+  }
+  tick() {
+    const now = Date.now();
+    for (const { row, started } of this.rows.values()) row.setRunning(now - started);
+    if (this.rows.size) this.tui.requestRender();
+  }
+  refreshStatus() {
+    if (!this.ashr) return;
+    const stats = this.ashr.session.getSessionStats();
+    const usage = this.ashr.session.getContextUsage();
+    this.status.set({ mode: this.mode, tokens: stats.tokens.total, cost: stats.cost, contextPercent: usage?.percent ?? null, streaming: this.streaming });
+    this.tui.requestRender();
+  }
+  // ── input ────────────────────────────────────────────────────────────────
+  async submit(raw) {
+    this.input.setText("");
+    this.hideMenu();
+    const routed = route(raw, COMMANDS);
+    if (routed.kind === "unknown") {
+      this.note(`${routed.name} is not a command. Did you mean ${routed.suggestions.join(" or ")}?`, "warn");
+      return;
+    }
+    if (routed.kind === "command") {
+      try {
+        await routed.spec.run(this, routed.args);
+      } catch (err) {
+        this.note(`\u2717 ${err.message}`, "bad");
+      }
+      return;
+    }
+    if (!routed.text) return;
+    this.closePanel();
+    if (this.streaming) {
+      this.queued.push({ kind: "steer", text: routed.text });
+      this.queue.set(this.queued);
+      await this.ashr.session.steer(routed.text);
+      this.tui.requestRender();
+      return;
+    }
+    this.startTurn(routed.text);
+  }
+  startTurn(text) {
+    this.add(new UserTurn(this.t, text));
+    this.currentTurn = void 0;
+    this.streaming = true;
+    this.refreshStatus();
+    const withView = this.lastView ? `${text}
+
+[What the user was just looking at in the terminal]
+${this.lastView}` : text;
+    this.lastView = void 0;
+    this.ashr.session.prompt(withView).catch((err) => {
+      this.streaming = false;
+      this.note(`\u2717 ${err instanceof Error ? err.message : String(err)}`, "bad");
+      this.refreshStatus();
+    });
+  }
+  async abortTurn() {
+    const unsent = this.queued.map((q) => q.text);
+    this.queued = [];
+    this.queue.set([]);
+    this.ashr.session.clearQueue();
+    if (this.pending) this.answer({ approve: false, reason: "The user stopped the turn." });
+    await this.ashr.session.abort().catch(() => {
+    });
+    if (this.currentTurn) this.currentTurn.setNote("stopped by you");
+    else this.note("stopped by you");
+    this.currentTurn = void 0;
+    for (const { row } of this.rows.values()) row.finish({ isError: true, summary: "stopped" });
+    this.rows.clear();
+    this.streaming = false;
+    if (unsent.length) this.input.setText(unsent.join("\n"));
+    this.refreshStatus();
+  }
+  onKey(data) {
+    const consume = { consume: true };
+    if (matchesKey(data, "ctrl+c")) {
+      if (this.streaming) void this.abortTurn();
+      else if (Date.now() - this.lastCtrlC < 2e3) void this.quit();
+      else {
+        this.lastCtrlC = Date.now();
+        this.note("Press Ctrl-C again to quit.");
+      }
+      return consume;
+    }
+    if (this.trustPrompt) {
+      if (matchesKey(data, "enter")) {
+        trustRepo(this.o.repoRoot, this.trust.hash, this.o.env);
+        this.trust = repoTrustState(this.o.repoRoot, this.o.env);
+        this.reloadSettings();
+        this.endTrustPrompt("Trusted. The team's rules and connectors now apply in this repo.");
+      } else if (data === "n") this.endTrustPrompt("Continuing without the team's rules and connectors. They stay ignored until you trust them.");
+      else if (data === "e") this.note(`Team settings: ${resolve6(this.o.repoRoot, ".ashr/settings.json")}`);
+      return consume;
+    }
+    if (this.picker) {
+      this.picker.handleInput(data);
+      this.tui.requestRender();
+      return consume;
+    }
+    if (this.pending) {
+      const { card: card2 } = this.pending;
+      if (matchesKey(data, "tab")) {
+        card2.setFocused(!card2.focused);
+        this.tui.requestRender();
+        return consume;
+      }
+      if (card2.focused) {
+        if (data === "a") this.answer({ approve: true });
+        else if (data === "r") this.answer({ approve: false });
+        else if (data === "A" && card2.req.offer) this.answer({ approve: true, always: true });
+        else if (data === "e") card2.toggle();
+        else if (!matchesKey(data, "escape") && !matchesKey(data, "shift+tab")) return consume;
+        if (!matchesKey(data, "escape") && !matchesKey(data, "shift+tab")) {
+          this.tui.requestRender();
+          return consume;
+        }
+      }
+    }
+    if (matchesKey(data, "ctrl+o")) {
+      this.lastFinished?.toggle();
+      this.tui.requestRender();
+      return consume;
+    }
+    if (this.menuHost.children.length) {
+      if (matchesKey(data, "up")) {
+        this.menu.move(-1, 0);
+        this.tui.requestRender();
+        return consume;
+      }
+      if (matchesKey(data, "down")) {
+        this.menu.move(1, 0);
+        this.tui.requestRender();
+        return consume;
+      }
+      if (matchesKey(data, "tab")) {
+        const sel = this.menu.selected();
+        if (sel) this.input.setText(`${sel.name} `);
+        this.updateMenu();
+        return consume;
+      }
+      if (matchesKey(data, "enter")) {
+        const sel = this.menu.selected();
+        const typed = this.input.getText().trim();
+        if (sel && !COMMANDS.some((c) => c.name === typed)) {
+          void this.submit(sel.name);
+          return consume;
+        }
+      }
+    }
+    if (matchesKey(data, "escape")) {
+      if (this.streaming) {
+        void this.abortTurn();
+        return consume;
+      }
+      if (this.panelHost.children.length) {
+        this.closePanel();
+        return consume;
+      }
+      if (this.menuHost.children.length) {
+        this.input.setText("");
+        this.hideMenu();
+        return consume;
+      }
+    }
+    if (matchesKey(data, "shift+tab")) {
+      this.cycleMode();
+      return consume;
+    }
+    if (matchesKey(data, "alt+enter") && this.streaming) {
+      const text = this.input.getText().trim();
+      if (text) {
+        this.input.setText("");
+        this.queued.push({ kind: "next", text });
+        this.queue.set(this.queued);
+        void this.ashr.session.followUp(text);
+        this.tui.requestRender();
+      }
+      return consume;
+    }
+    return void 0;
+  }
+  // ── slash menu ───────────────────────────────────────────────────────────
+  updateMenuValues() {
+    const short = this.ashr ? (this.ashr.modelLabel.split("/")[1] ?? this.ashr.modelLabel).replace(/^claude-/, "") : "";
+    this.menu.setGroups(menuGroups(COMMANDS, { "/model": short, "/mode": this.mode }));
+  }
+  updateMenu() {
+    const text = this.input.getText();
+    if (/^\/\S*$/.test(text)) {
+      this.menu.filter(text);
+      if (!this.menuHost.children.length) this.menuHost.addChild(this.menu);
+    } else this.hideMenu();
+    this.tui.requestRender();
+  }
+  hideMenu() {
+    this.menuHost.clear();
+  }
+  // ── approvals ────────────────────────────────────────────────────────────
+  ask(req, signal) {
+    return new Promise((resolveAnswer) => {
+      const card2 = new ApprovalCard(this.t, req);
+      this.pending = { card: card2, resolve: resolveAnswer };
+      const row = this.rows.get(req.id);
+      if (row) {
+        row.row.setWaiting(true);
+        card2.attached = true;
+      }
+      this.approvalHost.clear();
+      this.approvalHost.addChild(card2);
+      if (req.kind === "spend") this.o.terminal.write("\x07");
+      signal?.addEventListener("abort", () => {
+        if (this.pending?.card === card2) this.answer({ approve: false });
+      }, { once: true });
+      this.tui.requestRender();
+    });
+  }
+  answer(a) {
+    const p = this.pending;
+    if (!p) return;
+    this.pending = void 0;
+    this.approvalHost.clear();
+    const waiting = this.rows.get(p.card.req.id);
+    if (waiting) {
+      waiting.row.setWaiting(false);
+      waiting.started = Date.now();
+    }
+    const what = `${p.card.req.title} ${p.card.req.subject}`.trim();
+    if (!p.card.attached) this.note(a.approve ? `approved ${what}${a.always ? " \xB7 always" : ""}` : `rejected ${what}`, a.approve ? "soft" : "warn");
+    p.resolve(a);
+    this.tui.requestRender();
+  }
+  // ── panels and pickers ───────────────────────────────────────────────────
+  openPanel(c, summary) {
+    this.panelHost.clear();
+    this.panelHost.addChild(c);
+    this.lastView = summary;
+    this.tui.requestRender();
+  }
+  closePanel() {
+    if (this.picker) this.picker = void 0;
+    this.panelHost.clear();
+    this.tui.requestRender();
+  }
+  endTrustPrompt(message) {
+    this.trustPrompt = void 0;
+    this.panelHost.clear();
+    this.note(message);
+  }
+  openPicker(items, onSelect, footnote) {
+    if (!items.length) {
+      this.note("Nothing to pick from yet.");
+      return;
+    }
+    const list = new SelectList(items, 10, editorTheme(this.t).selectList);
+    list.onSelect = (item) => {
+      this.closePanel();
+      onSelect(item.value);
+    };
+    list.onCancel = () => this.closePanel();
+    this.picker = list;
+    this.panelHost.clear();
+    this.panelHost.addChild(list);
+    if (footnote) this.panelHost.addChild(new Note(this.t, footnote));
+    this.tui.requestRender();
+  }
+  showUsage() {
+    const stats = this.ashr.session.getSessionStats();
+    const usage = this.ashr.session.getContextUsage();
+    const created = this.ashr.session.sessionManager.getHeader()?.timestamp;
+    const elapsedMs = created ? Date.now() - new Date(created).getTime() : 0;
+    const panel = new UsagePanel(this.t, {
+      model: this.ashr.modelLabel,
+      tokens: { input: stats.tokens.input, output: stats.tokens.output, cacheRead: stats.tokens.cacheRead, total: stats.tokens.total },
+      contextPercent: usage?.percent ?? null,
+      contextWindow: usage?.contextWindow ?? 0,
+      cost: stats.cost,
+      turns: stats.userMessages,
+      toolCalls: stats.toolCalls,
+      elapsedMs
+    });
+    this.openPanel(panel, `Usage: ${formatTokens(stats.tokens.total)} tokens, $${stats.cost.toFixed(2)}, context ${usage?.percent ?? "unknown"}%.`);
+  }
+  showPermissions(args) {
+    const remove = /^remove\s+(.+)$/.exec(args.trim());
+    if (remove) {
+      const rule = remove[1].trim();
+      if (removeLocalRule(this.o.repoRoot, rule)) {
+        this.reloadSettings();
+        this.note(`Removed ${rule} from .ashr/settings.local.json`);
+      } else this.note(`${rule} is not in .ashr/settings.local.json. Team and user rules are edited in their own files.`, "warn");
+      return;
+    }
+    const v = { mode: this.mode, allow: this.settings.rules.allow, deny: this.settings.rules.deny, ignored: this.settings.ignored.allow };
+    this.openPanel(new PermissionsPanel(this.t, v), `Permission mode ${this.mode}. Allow: ${v.allow.map((r) => r.text).join(", ") || "none"}. Deny: ${v.deny.map((r) => r.text).join(", ") || "none"}.`);
+  }
+  showHelp() {
+    const { t } = this;
+    const lines = [
+      ` ${t.bold(t.fg("text", "Commands"))}`,
+      ...COMMANDS.map((c) => `   ${t.fg("accent", c.name.padEnd(13))}${t.fg("soft", c.description)}`),
+      "",
+      ` ${t.bold(t.fg("text", "Keys"))}`,
+      `   ${t.fg("accent", "\u23CE".padEnd(13))}${t.fg("soft", "send; while the agent works, steer it")}`,
+      `   ${t.fg("accent", "\u2325\u23CE".padEnd(13))}${t.fg("soft", "queue a message for when the agent finishes")}`,
+      `   ${t.fg("accent", "esc".padEnd(13))}${t.fg("soft", "stop the agent")}`,
+      `   ${t.fg("accent", "\u21E7\u21E5".padEnd(13))}${t.fg("soft", "permission mode: ask \u2192 edit \u2192 auto")}`,
+      `   ${t.fg("accent", "tab".padEnd(13))}${t.fg("soft", "while an approval waits: switch between answering it and typing")}`,
+      `   ${t.fg("accent", "ctrl-o".padEnd(13))}${t.fg("soft", "show or hide the full output of the last tool")}`,
+      `   ${t.fg("accent", "ctrl-c \xD72".padEnd(13))}${t.fg("soft", "quit")}`
+    ];
+    this.openPanel(new Lines(lines));
+  }
+  async pickResume() {
+    const sessions = await listSessions(this.o.repoRoot, this.sessionDir);
+    const current = this.ashr.session.sessionFile;
+    this.openPicker(
+      sessions.filter((s) => s.file !== current).map((s) => ({ value: s.file, label: s.name || "(empty)", description: `${new Date(s.updatedAt).toLocaleString()} \xB7 ${s.messages} messages` })),
+      (file) => void this.switchSession(file)
+    );
+  }
+  userMessages() {
+    return this.ashr.session.getUserMessagesForForking().slice().reverse().map((m) => ({ value: m.entryId, label: m.text.split("\n")[0] ?? "" }));
+  }
+  /** The agent's file changes made at or after `entryId` on the current branch. */
+  changesSince(entryId) {
+    const branch = this.ashr.session.sessionManager.getBranch();
+    const at = branch.findIndex((e) => e.id === entryId);
+    return at < 0 ? [] : snapshotsAfter(this.sessionDir, this.ashr.session.sessionId, branch.slice(at).map((e) => e.id));
+  }
+  offerRestore(snaps) {
+    if (!snaps.length) return;
+    const shown = snaps.map((s) => this.subject("read", { path: s.path }));
+    this.openPicker(
+      [
+        { value: "yes", label: `Restore ${snaps.length} file${snaps.length === 1 ? "" : "s"}`, description: shown.join(", ") },
+        { value: "no", label: "Keep files as they are" }
+      ],
+      (v) => {
+        if (v !== "yes") return;
+        restore(snaps);
+        this.note(`Restored ${shown.join(", ")}`);
+      },
+      "Restores the agent's file edits only. Shell side effects and your own edits are not restored."
+    );
+  }
+  async pickRewind() {
+    this.openPicker(this.userMessages(), (entryId) => void this.rewindTo(entryId), "Go back to before this message in this session.");
+  }
+  async rewindTo(entryId) {
+    const snaps = this.changesSince(entryId);
+    const result = await this.ashr.session.navigateTree(entryId);
+    this.transcript.clear();
+    this.seq = 0;
+    this.transcript.addChild(this.header);
+    this.replay();
+    this.note("Rewound. Edit the message and send it, or ask something else.");
+    this.input.setText(result.editorText ?? "");
+    this.offerRestore(snaps);
+    this.refreshStatus();
+  }
+  async pickFork() {
+    this.openPicker(this.userMessages(), (entryId) => void this.forkAt(entryId), "Start a new session from before this message. This session stays as it is.");
+  }
+  async forkAt(entryId) {
+    const sm = this.ashr.session.sessionManager;
+    const entry = sm.getEntries().find((e) => e.id === entryId);
+    const text = messageText(entry?.message?.content);
+    const snaps = this.changesSince(entryId);
+    const file = entry?.parentId ? sm.createBranchedSession(entry.parentId) : void 0;
+    await this.switchSession(file);
+    this.note("Forked into a new session. The original is unchanged.");
+    this.input.setText(text);
+    this.offerRestore(snaps);
+  }
+  async switchSession(file) {
+    const holder = file ? lockHolder(file) : void 0;
+    if (holder) {
+      this.note(`That session is open in another terminal (pid ${holder}). Close it there, or /fork it to continue here.`, "warn");
+      return;
+    }
+    await this.close();
+    this.transcript.clear();
+    this.seq = 0;
+    try {
+      await this.open(file, void 0);
+    } catch (err) {
+      this.note(`\u2717 ${err.message}`, "bad");
+      await this.open(void 0, void 0);
+    }
+    this.refreshStatus();
+  }
+  async compact() {
+    await this.ashr.session.compact();
+    this.refreshStatus();
+  }
+  async setModel(arg) {
+    const runtime = this.ashr.modelRuntime;
+    if (!arg) {
+      const models = runtime.getModels().filter((m) => hasKey(m.provider, process.env) || m.provider === this.ashr.session.model?.provider);
+      this.openPicker(models.map((m) => ({ value: `${m.provider}/${m.id}`, label: `${m.provider}/${m.id}` })), (v) => void this.setModel(v));
+      return;
+    }
+    try {
+      const { model, label } = pickModel(runtime, { requested: arg, env: process.env });
+      await this.ashr.session.setModel(model);
+      this.ashr.modelLabel = label;
+      this.header.set({ org: this.org, model: label });
+      this.updateMenuValues();
+      this.note(`Model ${label}`);
+    } catch (err) {
+      this.note(`\u2717 ${err.message}`, "bad");
+    }
+  }
+  setMode(arg) {
+    const m = arg.trim();
+    if (!["ask", "edit", "auto"].includes(m)) {
+      this.note(`Mode is ${this.mode}. Use /mode ask, /mode edit or /mode auto.`);
+      return;
+    }
+    this.mode = m;
+    recordMode(this.ashr.session.sessionManager, m);
+    if (m === "auto" && !this.autoExplained) {
+      this.autoExplained = true;
+      this.note("Auto mode: everything inside the repo runs without asking. Spend, outside-repo and dangerous commands still ask.", "warn");
+    }
+    this.updateMenuValues();
+    this.refreshStatus();
+  }
+  cycleMode() {
+    this.setMode(this.mode === "ask" ? "edit" : this.mode === "edit" ? "auto" : "ask");
+  }
+  addDir(path) {
+    if (!path) {
+      this.note("Usage: /add-dir <path>");
+      return;
+    }
+    const abs = resolve6(this.o.repoRoot, path);
+    if (!existsSync6(abs) || !statSync2(abs).isDirectory()) {
+      this.note(`\u2717 ${abs} is not a directory.`, "bad");
+      return;
+    }
+    this.extraDirs.push(abs);
+    this.note(`The agent may use ${abs} for this session.`);
+  }
+  reloadSettings() {
+    this.settings = loadSettings(this.o.repoRoot, { trusted: this.trust.trusted, env: this.o.env });
+  }
+};
+async function runApp(o) {
+  const app = new App(o);
+  try {
+    await app.start();
+  } catch (err) {
+    app.tui.stop();
+    throw err;
+  }
+  return app.done;
+}
+
+// src/hosted/entry.ts
+import { spawn } from "node:child_process";
+import { hostname } from "node:os";
+import { ProcessTerminal } from "@earendil-works/pi-tui";
+
+// src/platform/terminal-login.ts
+import { createServer } from "node:http";
+import { randomBytes, timingSafeEqual } from "node:crypto";
+var same = (a, b) => Buffer.byteLength(a) === Buffer.byteLength(b) && timingSafeEqual(Buffer.from(a), Buffer.from(b));
+async function readForm(request) {
+  let length = 0;
+  const chunks = [];
+  for await (const chunk of request) {
+    length += chunk.length;
+    if (length > 16384) throw Error("Too large");
+    chunks.push(chunk);
+  }
+  return new URLSearchParams(Buffer.concat(chunks).toString());
+}
+async function startTerminalLogin(options) {
+  const dashboard = new URL(options.dashboardUrl);
+  if (dashboard.protocol !== "https:" && !(dashboard.protocol === "http:" && ["127.0.0.1", "localhost"].includes(dashboard.hostname)))
+    throw Error("Dashboard must use HTTPS (or explicitly configured local development).");
+  if (dashboard.username || dashboard.password) throw Error("Dashboard URL cannot contain credentials.");
+  if (options.signal?.aborted) throw Error("Sign-in cancelled.");
+  const state = randomBytes(32).toString("hex");
+  let host = "";
+  let settle;
+  const result = new Promise((resolve10, reject) => {
+    settle = { resolve: resolve10, reject };
+  });
+  const page = (response, status, title, detail) => {
+    response.writeHead(status, {
+      "Content-Type": "text/html; charset=utf-8",
+      "Content-Security-Policy": "default-src 'none'; style-src 'unsafe-inline'; frame-ancestors 'none'"
+    });
+    response.end(resultPage(title, detail));
+  };
+  const server = createServer(async (request, response) => {
+    response.setHeader("Cache-Control", "no-store");
+    response.setHeader("Referrer-Policy", "no-referrer");
+    response.setHeader("X-Content-Type-Options", "nosniff");
+    if (request.headers.host !== host || request.method !== "POST" || request.url !== "/callback" || request.headers.origin !== void 0 && request.headers.origin !== "null" && request.headers.origin !== dashboard.origin) {
+      page(response, 403, "This link doesn't belong to this terminal.", "Run ashr again to start a new sign-in.");
+      return;
+    }
+    let form;
+    try {
+      form = await readForm(request);
+    } catch {
+      page(response, 400, "Sign-in failed.", "Run ashr again to start a new sign-in.");
+      return;
+    }
+    if (!same(form.get("state") ?? "", state)) {
+      page(response, 403, "This link doesn't belong to this terminal.", "Run ashr again to start a new sign-in.");
+      return;
+    }
+    if (form.get("error")) {
+      page(response, 200, "Sign-in cancelled.", "Nothing was shared. You can close this tab.");
+      finish(Error("Sign-in was cancelled in the browser."));
+      return;
+    }
+    const key2 = form.get("key") ?? "";
+    if (!/^ask_[A-Za-z0-9]{8,200}$/.test(key2)) {
+      page(response, 400, "Sign-in failed.", "Manifold didn't return a usable key. Run ashr again.");
+      finish(Error("The dashboard returned no usable key."));
+      return;
+    }
+    page(response, 200, "You're signed in.", "Return to your terminal. You can close this tab.");
+    finish(void 0, { key: key2, email: form.get("email") || void 0, organization: form.get("organization") || void 0 });
+  });
+  server.requestTimeout = 1e4;
+  server.headersTimeout = 1e4;
+  const timer = setTimeout(() => finish(Error("Sign-in timed out. Run ashr again.")), 6e5);
+  const abort = () => finish(Error("Sign-in cancelled."));
+  function finish(error, login2) {
+    if (!settle) return;
+    const { resolve: resolve10, reject } = settle;
+    settle = void 0;
+    clearTimeout(timer);
+    options.signal?.removeEventListener("abort", abort);
+    setTimeout(() => {
+      server.close();
+      server.closeAllConnections();
+    }, 250).unref();
+    if (error) reject(error);
+    else resolve10(login2);
+  }
+  await new Promise((resolve10, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", resolve10);
+  });
+  const address = server.address();
+  if (!address || typeof address === "string") {
+    finish(Error("Loopback listener failed."));
+    return result;
+  }
+  host = `127.0.0.1:${address.port}`;
+  options.signal?.addEventListener("abort", abort, { once: true });
+  const url = new URL("/terminal", dashboard);
+  url.search = new URLSearchParams({ port: String(address.port), state, device: options.device }).toString();
+  options.onUrl(url.toString());
+  return result;
+}
+function resultPage(title, detail) {
+  const escape = (text) => text.replace(/[&<>"]/g, (c) => `&#${c.charCodeAt(0)};`);
+  return `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>${escape(title)} \xB7 Ashr</title><style>
+:root{--paper:#faf8f4;--raised:#fffdf9;--ink:#141310;--soft:#57544c;--line:#dcd8ce;--accent:#4d41d0}
+@media (prefers-color-scheme:dark){:root{--paper:#141310;--raised:#1c1b17;--ink:#f4f1e9;--soft:#a9a49a;--line:#34322c;--accent:#a49bff}}
+*{box-sizing:border-box}body{margin:0;min-height:100vh;display:grid;place-items:center;padding:3rem 1.25rem;background:linear-gradient(var(--line) 1px,transparent 1px),linear-gradient(90deg,var(--line) 1px,transparent 1px),var(--paper);background-size:2.5rem 2.5rem;color:var(--ink);font:15px/1.55 "Helvetica Neue",system-ui,sans-serif}
+main{width:min(28rem,100%);padding:2.5rem;background:var(--raised);border:1px solid var(--line);box-shadow:0 18px 40px -18px rgba(20,19,16,.25)}
+p.e{margin:0 0 .8rem;color:var(--accent);font:500 .68rem ui-monospace,monospace;letter-spacing:.18em}
+h1{margin:0 0 .6rem;font-size:2rem;font-weight:650;letter-spacing:-.035em;line-height:1.05}p{margin:0;color:var(--soft)}
+</style></head><body><main><p class="e">ASHR TERMINAL</p><h1>${escape(title)}</h1><p>${escape(detail)}</p></main></body></html>`;
+}
+
+// src/hosted/client.ts
+var ManifoldHttpError = class extends Error {
+  constructor(status, message) {
+    super(`HTTP ${status}: ${message}`);
+    this.status = status;
+  }
+  status;
+};
+var ManifoldClient = class {
+  constructor(options) {
+    this.options = options;
+    this.base = new URL(options.apiUrl);
+    if (!["http:", "https:"].includes(this.base.protocol) || this.base.username || this.base.password || this.base.search || this.base.hash || this.base.protocol === "http:" && !["localhost", "127.0.0.1", "[::1]"].includes(this.base.hostname))
+      throw new Error(
+        "Use HTTPS or a loopback HTTP API URL without credentials"
+      );
+  }
+  options;
+  base;
+  get apiOrigin() {
+    return this.base.origin;
+  }
+  async request(path, init = {}) {
+    const response = await this.requestResponse(path, init, "application/json");
+    if (response.status === 204) return void 0;
+    return await response.json();
+  }
+  async requestStream(path, init = {}) {
+    return this.requestResponse(path, init, "text/event-stream");
+  }
+  async requestResponse(path, init, accept) {
+    const decoded = decodeURIComponent(path.split("?")[0]);
+    if (!decoded.startsWith("/v1/") || decoded.includes("\\") || decoded.split("/").some((p) => p === ".." || p === ".") || /[\x00-\x1f#]/.test(decoded) || /[\x00-\x20#]/.test(path.split("?")[0]) || /%2f|%5c/i.test(path.split("?")[0]))
+      throw new Error("Invalid API path");
+    const url = new URL(path, this.base);
+    if (url.origin !== this.base.origin || !url.pathname.startsWith("/v1/"))
+      throw new Error("Invalid API path");
+    init.signal?.throwIfAborted();
+    const signal = init.signal;
+    const token = signal ? await new Promise((resolve10, reject) => {
+      const cancel = () => {
+        signal.removeEventListener("abort", cancel);
+        reject(
+          signal.reason ?? new DOMException("Local request paused", "AbortError")
+        );
+      };
+      signal.addEventListener("abort", cancel, { once: true });
+      void Promise.resolve().then(() => this.options.getToken()).then(
+        (value) => {
+          signal.removeEventListener("abort", cancel);
+          resolve10(value);
+        },
+        (error) => {
+          signal.removeEventListener("abort", cancel);
+          reject(error);
+        }
+      );
+    }) : await this.options.getToken();
+    init.signal?.throwIfAborted();
+    if (!token) throw new ManifoldHttpError(401, "Authentication required");
+    const headers = new Headers(init.headers);
+    if (!headers.has("authorization"))
+      headers.set("authorization", `Bearer ${token}`);
+    headers.set("accept", accept);
+    if (init.body && !headers.has("content-type"))
+      headers.set("content-type", "application/json");
+    let response;
+    try {
+      response = await (this.options.fetch ?? fetch)(url, {
+        ...init,
+        headers,
+        redirect: "manual"
+      });
+    } catch {
+      if (init.signal?.aborted)
+        throw init.signal.reason ?? new DOMException("Local request paused", "AbortError");
+      throw new Error(
+        "Connection failed. The request may have been accepted; retry with the same request ID."
+      );
+    }
+    if (response.status >= 300 && response.status < 400)
+      throw new Error("API redirect refused");
+    if (!response.ok) {
+      let detail = "Request failed";
+      try {
+        const body = await response.json();
+        detail = typeof body.detail === "string" ? body.detail : JSON.stringify(body.detail ?? detail);
+      } catch {
+      }
+      throw new ManifoldHttpError(
+        response.status,
+        [token, headers.get("authorization")?.replace(/^Bearer /, "") ?? ""].filter(Boolean).reduce(
+          (value, secret) => value.split(secret).join("[credential]"),
+          detail
+        )
+      );
+    }
+    return response;
+  }
+};
+
+// src/hosted/app.ts
+import {
+  TuiMainScreen as TuiMainScreen2,
+  matchesKey as matchesKey2,
+  wrapTextWithAnsi as wrapTextWithAnsi2
+} from "@earendil-works/pi-tui";
+import { parse as parse3 } from "shell-quote";
+
+// src/hosted/workspace.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { lstat, readFile, readdir, open } from "node:fs/promises";
+import { basename as basename3, join as join8, resolve as resolve7 } from "node:path";
+function terminalText(value) {
+  const text = typeof value === "string" ? value : JSON.stringify(value, null, 2) ?? String(value);
+  return text.replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)/g, "").replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "").replace(/[\x00-\x08\x0b-\x1f\x7f-\x9f]/g, "");
+}
+function safeWorkspacePath(path) {
+  if (!path || path.length > 300 || path.includes("\\") || path.startsWith("/") || path.split("/").some((p) => !p || p === "." || p === ".." || p.startsWith(".")) || /[\x00-\x1f]/.test(path))
+    throw Error("Use a safe relative skill path");
+  return path;
+}
+async function writeExclusive(destination, content) {
+  const file = await open(resolve7(destination), "wx", 384);
+  try {
+    await file.writeFile(content);
+  } finally {
+    await file.close();
+  }
+}
+async function importSkill(path) {
+  const root2 = resolve7(path);
+  const stat2 = await lstat(root2);
+  if (stat2.isSymbolicLink())
+    throw Error("Skill paths cannot be symbolic links");
+  const files = {};
+  let bytes = 0;
+  async function read2(file, name2) {
+    safeWorkspacePath(name2);
+    const info = await lstat(file);
+    if (info.isSymbolicLink() || !info.isFile())
+      throw Error("Skill paths must be regular files");
+    if (info.size > 1e6) throw Error("Skill exceeds 1 MB");
+    const value = await readFile(file, "utf8");
+    bytes += Buffer.byteLength(value);
+    if (bytes > 1e6 || Object.keys(files).length >= 100)
+      throw Error("Import at most 100 files totaling 1 MB");
+    files[name2] = value;
+  }
+  async function walk(dir, prefix = "") {
+    for (const entry of await readdir(dir, { withFileTypes: true })) {
+      const name2 = prefix + entry.name;
+      safeWorkspacePath(name2);
+      if (entry.isSymbolicLink())
+        throw Error("Skill paths cannot be symbolic links");
+      if (entry.isDirectory()) await walk(join8(dir, entry.name), name2 + "/");
+      else await read2(join8(dir, entry.name), name2);
+    }
+  }
+  if (stat2.isDirectory()) await walk(root2);
+  else {
+    if (basename3(root2) !== "SKILL.md")
+      throw Error("Import a SKILL.md file or skill folder");
+    await read2(root2, "SKILL.md");
+  }
+  const source = files["SKILL.md"] ?? "";
+  const name = /^name:\s*([a-z0-9]+(?:-[a-z0-9]+)*)\s*$/m.exec(source)?.[1];
+  if (!source.startsWith("---\n") && !source.startsWith("---\r\n") || !name || name.length > 64 || !/^description:\s*\S/m.test(source))
+    throw Error("SKILL.md needs name and description frontmatter");
+  return { name, files, enabled: true };
+}
+function normalizeHostedTask(value) {
+  const canonical2 = value.trim().toLowerCase().replace(/[\s-]+/g, "_");
+  if (!/^[a-z0-9_]+$/.test(canonical2) || canonical2.length > 200)
+    throw Error("Enter a valid task name");
+  return canonical2;
+}
+var HostedWorkspace = class {
+  constructor(client, task2) {
+    this.client = client;
+    this.scope = task2 === void 0 ? void 0 : normalizeHostedTask(task2);
+  }
+  client;
+  detail;
+  events = [];
+  cursor = 0;
+  connection = "Disconnected";
+  generation = 0;
+  pending = /* @__PURE__ */ new Map();
+  scope;
+  pollInFlight;
+  get task() {
+    return this.scope;
+  }
+  get chat() {
+    return this.detail?.id;
+  }
+  get busy() {
+    return ["working", "queued", "stopping"].includes(
+      this.detail?.status ?? ""
+    );
+  }
+  path(id = this.chat) {
+    if (!id) throw Error("Open or create a hosted chat first");
+    return `/v1/agent/chats/${encodeURIComponent(id)}`;
+  }
+  async list(search = "") {
+    const result = await this.client.request(
+      `/v1/agent/chats${this.scope ? "?task=" + encodeURIComponent(this.scope) : ""}`
+    );
+    return result.chats.filter(
+      (c) => c.name.toLowerCase().includes(search.toLowerCase()) || c.id.includes(search)
+    );
+  }
+  setTask(task2) {
+    this.scope = task2 === void 0 ? void 0 : normalizeHostedTask(task2);
+    this.generation++;
+    this.detail = void 0;
+    this.events = [];
+    this.cursor = 0;
+    this.connection = "Disconnected";
+  }
+  async open(id) {
+    const gen = ++this.generation;
+    this.detail = void 0;
+    this.events = [];
+    this.cursor = 0;
+    this.connection = "Connecting";
+    try {
+      const detail = await this.client.request(this.path(id));
+      if (gen !== this.generation) return;
+      if (this.scope && detail.task !== this.scope)
+        throw Error("Chat belongs to a different task");
+      this.detail = detail;
+    } catch (error) {
+      if (gen === this.generation) this.connection = "Open failed";
+      throw error;
+    }
+  }
+  async create(name = "New chat") {
+    const gen = this.generation;
+    const chat = await this.client.request("/v1/agent/chats", {
+      method: "POST",
+      body: JSON.stringify({ name, task: this.scope ?? null })
+    });
+    if (gen === this.generation) await this.open(chat.id);
+    return chat;
+  }
+  async refresh() {
+    const gen = this.generation, id = this.chat;
+    if (!id) return;
+    const detail = await this.client.request(this.path(id));
+    if (gen === this.generation) this.detail = detail;
+  }
+  async rename(name) {
+    if (!name.trim() || name.length > 120)
+      throw Error("Name must be 1\u2013120 characters");
+    const gen = this.generation;
+    const updated = await this.client.request(this.path(), {
+      method: "PATCH",
+      body: JSON.stringify({ name })
+    });
+    if (gen === this.generation && this.detail)
+      this.detail = { ...this.detail, ...updated };
+  }
+  async fork(name, through) {
+    const gen = this.generation;
+    const chat = await this.client.request(this.path() + "/fork", {
+      method: "POST",
+      body: JSON.stringify({
+        name,
+        ...through === void 0 ? {} : { through }
+      })
+    });
+    if (gen === this.generation) await this.open(chat.id);
+    return chat;
+  }
+  poll() {
+    if (this.pollInFlight) return this.pollInFlight;
+    const pending = this.pollPage();
+    this.pollInFlight = pending;
+    void pending.finally(() => {
+      if (this.pollInFlight === pending) this.pollInFlight = void 0;
+    }).catch(() => {
+    });
+    return pending;
+  }
+  async pollPage() {
+    if (!this.chat) return;
+    const gen = this.generation, id = this.chat;
+    try {
+      const page = await this.client.request(
+        this.path(id) + `/events?after=${this.cursor}&limit=500`
+      );
+      if (gen !== this.generation) return;
+      const seen = new Set(this.events.map((e) => e.seq));
+      for (const e of page.events) {
+        if (!Number.isSafeInteger(e.seq) || e.seq <= 0)
+          throw Error("Invalid event cursor");
+        if (!seen.has(e.seq)) {
+          this.events.push(e);
+          seen.add(e.seq);
+          if (e.kind === "status" && this.detail)
+            this.detail.status = String(e.data.status);
+        }
+      }
+      this.events.sort((a, b) => a.seq - b.seq);
+      if (!Number.isSafeInteger(page.cursor) || page.cursor < this.cursor)
+        throw Error("Invalid event cursor");
+      this.cursor = page.cursor;
+      this.connection = "Connected";
+    } catch (error) {
+      if (gen === this.generation)
+        this.connection = error instanceof ManifoldHttpError && [401, 403].includes(error.status) ? "Authentication required" : "Disconnected";
+      throw error;
+    }
+  }
+  async send(kind, text = "", options = {}) {
+    if (["prompt", "steer", "follow_up", "shell"].includes(kind) && !text.trim())
+      throw Error("Enter a message or command");
+    if (text.length > 1e5) throw Error("Command exceeds 100000 characters");
+    const chat = this.chat;
+    this.path(chat);
+    const old = [...this.pending.values()].find(
+      (p) => p.chat === chat && p.body.kind === kind && p.body.text === text && JSON.stringify(p.body.options) === JSON.stringify(options)
+    );
+    const attempt = old ?? {
+      chat,
+      body: { request_id: randomUUID2(), kind, text, options }
+    };
+    this.pending.set(attempt.body.request_id, attempt);
+    return this.deliver(attempt);
+  }
+  async deliver(attempt) {
+    const result = await this.client.request(
+      this.path(attempt.chat) + "/commands",
+      { method: "POST", body: JSON.stringify(attempt.body) }
+    );
+    this.pending.delete(attempt.body.request_id);
+    if (this.detail?.id === attempt.chat) {
+      if (attempt.body.kind === "stop") this.detail.status = "stopping";
+      else if (!["cancel", "approve", "reject"].includes(attempt.body.kind) && ["idle", "failed", "stopped"].includes(this.detail.status))
+        this.detail.status = "queued";
+    }
+    return result;
+  }
+  async retry(id) {
+    const attempts = [...this.pending.values()].filter(
+      (p) => p.chat === this.chat
+    );
+    const attempt = id ? this.pending.get(id) : attempts.at(-1);
+    if (!attempt || attempt.chat !== this.chat)
+      throw Error("No uncertain command in this chat");
+    return this.deliver(attempt);
+  }
+  async editQueue(id, text) {
+    const gen = this.generation;
+    await this.refresh();
+    if (gen !== this.generation) throw Error("Chat changed during queue edit");
+    const item = this.detail?.commands.find((c) => c.id === id);
+    if (!item || !["accepted", "held"].includes(item.status))
+      throw Error("That command has already been delivered");
+    if (!text.trim()) throw Error("Enter replacement text");
+    await this.send("cancel", id);
+    if (gen !== this.generation)
+      throw Error(
+        "Chat changed after cancellation; original cancelled, replacement not sent"
+      );
+    await this.send(item.kind, text, item.options);
+    await this.refresh();
+  }
+  async skill(skill) {
+    const gen = this.generation, id = this.chat;
+    await this.client.request(this.path(id) + "/skills", {
+      method: "POST",
+      body: JSON.stringify({
+        name: skill.name,
+        files: skill.files,
+        enabled: skill.enabled
+      })
+    });
+    if (gen === this.generation) {
+      await this.refresh();
+      await this.send("reload");
+    }
+  }
+  async export() {
+    const gen = this.generation;
+    await this.pollInFlight;
+    if (gen !== this.generation) throw Error("Chat changed during export");
+    await this.refresh();
+    do {
+      const before = this.events.length;
+      await this.poll();
+      if (gen !== this.generation) throw Error("Chat changed during export");
+      if (this.events.length - before < 500) break;
+    } while (true);
+    if (gen !== this.generation) throw Error("Chat changed during export");
+    return {
+      format: "ashr-chat-v1",
+      name: this.detail?.name,
+      files: this.detail?.files,
+      skills: this.detail?.skills,
+      events: this.events.filter((e) => e.kind !== "delta")
+    };
+  }
+};
+
+// src/hosted/render.ts
+var str = (v) => typeof v === "string" && v ? v : void 0;
+function subagentEvent(data, subagents) {
+  const id = str(data.subagent_id);
+  const name = str(data.name);
+  const status = str(data.status);
+  if (!id || !name || !status) return void 0;
+  const prev = subagents.get(id);
+  const cap = typeof data.cap_usd === "number" && Number.isFinite(data.cap_usd) ? data.cap_usd : prev?.cap_usd;
+  const model = str(data.model) ?? prev?.model;
+  subagents.set(id, { name, status, ...cap === void 0 ? {} : { cap_usd: cap }, ...model ? { model } : {} });
+  if (status === "running" && !prev) return `subagent ${name} started${model ? ` on ${model}` : ""}${cap === void 0 ? "" : `, cap $${cap.toFixed(2)}`}`;
+  return prev?.status === status ? void 0 : `subagent ${name} ${status}`;
+}
+function renderHostedEvent(lines, event, streams, subagents = /* @__PURE__ */ new Map()) {
+  const data = event.data;
+  if (event.kind === "subagent") {
+    const line2 = subagentEvent(data, subagents);
+    if (line2) lines.push(`[${event.seq}] ${terminalText(line2)}`, "");
+    return;
+  }
+  if (event.kind === "tool_update") return;
+  if (event.kind === "delta" || event.kind === "assistant") {
+    if (!data.text) return;
+    const id = String(data.message_id ?? "current");
+    let index = streams.get(id);
+    if (index === void 0) {
+      index = lines.length;
+      lines.push("", "");
+      streams.set(id, index);
+    }
+    lines[index] = `[${event.seq}] assistant${event.kind === "delta" ? " \xB7 streaming" : ""}`;
+    lines[index + 1] = event.kind === "delta" ? (lines[index + 1] ?? "") + terminalText(data.text ?? "") : terminalText(data.text ?? "");
+    if (event.kind === "assistant") streams.delete(id);
+    return;
+  }
+  const sid = str(data.subagent_id);
+  const who = sid ? subagents.get(sid)?.name ?? sid : void 0;
+  lines.push(
+    `[${event.seq}] ${who ? terminalText(who) + " \u25B8 " : ""}${terminalText(event.kind)}${data.tool ? " " + terminalText(data.tool) : ""}`,
+    terminalText(data.text ?? data)
+  );
+}
+
+// src/hosted/app.ts
+var hostedHelpLines = [
+  "HOSTED execution \u2014 same chats, files, queues and approvals as the browser.",
+  "/tasks | /task NAME | /task create NAME | /task all",
+  "/chats [SEARCH] | /open ID | /new NAME | /rename NAME | /fork NAME [SEQ]",
+  "/model PROVIDER/MODEL | /thinking LEVEL | /compact | /reload",
+  "/steer TEXT | /next TEXT | /stop | /approve ID | /reject ID",
+  "/queue | /queue edit ID TEXT | /queue remove ID | /retry [REQUEST_ID] | /pending",
+  "/files | /view PATH | /diff PATH | /download PATH LOCAL_DESTINATION",
+  "/skills | /skill import LOCAL_PATH | /skill view NAME [PATH] | /skill toggle NAME | /skill invoke NAME [TEXT] | /skill reload",
+  "/memory [QUERY] | /memory page OFFSET [QUERY] | /memory delete ID",
+  "/history [FIRST_SEQUENCE] | PageUp/PageDown scroll output | /export LOCAL_DESTINATION",
+  "!COMMAND runs in hosted workspace; !!COMMAND excludes shell output from model context.",
+  "Escape pauses local dashboard transfers or stops active hosted work. Ctrl-C stops active work, otherwise disconnects. /quit disconnects without stopping jobs.",
+  "/help | /quit"
+];
+var HostedScreen = class {
+  constructor(terminal, header) {
+    this.terminal = terminal;
+    this.header = header;
+  }
+  terminal;
+  header;
+  offset = 0;
+  lines = [];
+  invalidate() {
+  }
+  render(width) {
+    const lines = this.lines.flatMap(
+      (l) => wrapTextWithAnsi2(terminalText(l), Math.max(width, 1))
+    );
+    const count = Math.max(3, this.terminal.rows - 9);
+    const end = Math.max(0, lines.length - this.offset);
+    return [
+      terminalText(this.header()),
+      "",
+      ...lines.slice(Math.max(0, end - count), end),
+      this.offset ? "[Viewing history \u2014 PageDown returns to live output]" : ""
+    ];
+  }
+};
+async function runHostedApp(options) {
+  const workspace = new HostedWorkspace(options.client, options.task);
+  const env = options.env ?? process.env;
+  const tui = new TuiMainScreen2(options.terminal);
+  const input = new InputBox(
+    tui,
+    createTheme({ background: detectBackground(env), mode: colorMode(env) })
+  );
+  const screen = new HostedScreen(
+    options.terminal,
+    () => `HOSTED \xB7 ${workspace.task ?? "All tasks"} \xB7 ${workspace.detail?.name ?? "No hosted chat"} ${workspace.chat ?? ""} \xB7 ${workspace.detail?.status ?? "idle"} \xB7 ${workspace.connection}`
+  );
+  let done = false, finish = () => {
+  }, timer, failures = 0, seenGeneration = -1, seenCount = 0;
+  const result = new Promise((resolve10) => finish = resolve10);
+  const streams = /* @__PURE__ */ new Map();
+  const subagents = /* @__PURE__ */ new Map();
+  let dashboardAbort;
+  let uncertainComposer;
+  function show(title, value) {
+    screen.lines.push(`${title}:`, terminalText(value));
+    tui.requestRender();
+  }
+  function redraw() {
+    if (seenGeneration !== workspace.generation) {
+      seenGeneration = workspace.generation;
+      seenCount = 0;
+      screen.lines = [];
+      screen.offset = 0;
+      streams.clear();
+      subagents.clear();
+    }
+    for (const event of workspace.events.slice(seenCount))
+      renderHostedEvent(screen.lines, event, streams, subagents);
+    seenCount = workspace.events.length;
+    tui.requestRender();
+  }
+  function quit() {
+    dashboardAbort?.abort();
+    if (done) return;
+    done = true;
+    if (timer) clearTimeout(timer);
+    workspace.setTask(workspace.task);
+    tui.stop();
+    finish(0);
+  }
+  async function poll() {
+    if (done) return;
+    try {
+      await workspace.poll();
+      if (workspace.chat) await workspace.refresh();
+      failures = 0;
+      redraw();
+    } catch (e) {
+      failures++;
+      if (failures === 1 || failures === 5)
+        show("Connection", e instanceof Error ? e.message : String(e));
+      if (e instanceof ManifoldHttpError && [401, 403].includes(e.status)) {
+        failures = 5;
+      }
+    }
+    if (!done && failures < 5)
+      timer = setTimeout(
+        () => void poll(),
+        Math.min(1e4, 500 * 2 ** failures)
+      );
+    else if (!done)
+      show(
+        "Connection",
+        "Polling paused after 5 failures. /reconnect resumes; uncertain commands remain under /pending."
+      );
+  }
+  function reconnect() {
+    failures = 0;
+    if (timer) clearTimeout(timer);
+    void poll();
+  }
+  function requireArg(value, message) {
+    if (!value?.trim()) throw Error(message);
+    return value;
+  }
+  async function execute(raw) {
+    const text = raw.trim();
+    if (!text) return;
+    if (text === "/quit" || text === "/exit") {
+      quit();
+      return;
+    }
+    if (!text.startsWith("/")) {
+      const shell = text.startsWith("!");
+      const kind = shell ? "shell" : workspace.busy ? "steer" : "prompt";
+      const content = shell ? text.replace(/^!!?/, "").trim() : text;
+      const commandOptions = shell ? { excludeFromContext: text.startsWith("!!") } : {};
+      const prior = uncertainComposer;
+      if (prior && prior.raw === text && prior.chat === workspace.chat && workspace.pending.has(prior.request_id)) {
+        await workspace.retry(prior.request_id);
+      } else {
+        try {
+          await workspace.send(kind, content, commandOptions);
+        } catch (error) {
+          const pending = [...workspace.pending.values()].find(
+            (p) => p.chat === workspace.chat && p.body.kind === kind && p.body.text === content && JSON.stringify(p.body.options) === JSON.stringify(commandOptions)
+          );
+          if (pending)
+            uncertainComposer = {
+              raw: text,
+              chat: pending.chat,
+              request_id: pending.body.request_id
+            };
+          throw error;
+        }
+      }
+      uncertainComposer = void 0;
+      show("Accepted", shell ? "Hosted shell command" : text);
+      return;
+    }
+    const match = /^\/(\S+)(?:\s+([\s\S]*))?$/.exec(text);
+    const cmd = match[1], rest = match[2] ?? "";
+    const tokens = parse3(rest);
+    if (tokens.some((t) => typeof t !== "string"))
+      throw Error(
+        "Use plain arguments; shell operators are supported only with !"
+      );
+    const args = tokens;
+    if (options.runDashboardCommand) {
+      dashboardAbort = new AbortController();
+      try {
+        const handled = await options.runDashboardCommand(text, {
+          client: options.client,
+          task: workspace.task,
+          show,
+          signal: dashboardAbort.signal
+        });
+        dashboardAbort.signal.throwIfAborted();
+        if (handled) return;
+      } finally {
+        dashboardAbort = void 0;
+      }
+    }
+    switch (cmd) {
+      case "help":
+        show("Commands", hostedHelpLines.join("\n"));
+        break;
+      case "reconnect":
+        reconnect();
+        break;
+      case "tasks":
+        show("Tasks", await options.client.request("/v1/tasks"));
+        break;
+      case "task":
+        if (args[0] === "create") {
+          const task2 = await options.client.request(
+            "/v1/tasks",
+            {
+              method: "POST",
+              body: JSON.stringify({
+                name: requireArg(args.slice(1).join(" "), "Enter task name")
+              })
+            }
+          );
+          workspace.setTask(task2.name);
+        } else {
+          const value = requireArg(rest, "Use /task NAME or /task all");
+          const name = value === "all" ? value : normalizeHostedTask(value);
+          if (name !== "all") {
+            const tasks = await options.client.request(
+              "/v1/tasks"
+            );
+            if (!tasks.some((t) => t.name === name))
+              throw Error("Task not found; use /tasks or /task create NAME");
+          }
+          workspace.setTask(name === "all" ? void 0 : name);
+        }
+        redraw();
+        show("Chats", await workspace.list());
+        break;
+      case "chats":
+        show("Chats", await workspace.list(rest));
+        break;
+      case "open":
+        await workspace.open(requireArg(args[0], "Enter chat ID"));
+        await workspace.poll();
+        redraw();
+        break;
+      case "new":
+        await workspace.create(rest || "New chat");
+        await workspace.poll();
+        redraw();
+        break;
+      case "rename":
+        await workspace.rename(requireArg(rest, "Enter chat name"));
+        break;
+      case "fork": {
+        const seq = args.at(-1);
+        const through = seq && /^\d+$/.test(seq) ? Number(seq) : void 0;
+        await workspace.fork(
+          requireArg(
+            through === void 0 ? rest : args.slice(0, -1).join(" "),
+            "Enter fork name"
+          ),
+          through
+        );
+        await workspace.poll();
+        redraw();
+        break;
+      }
+      case "model":
+      case "thinking":
+        if (cmd === "thinking" && !["off", "minimal", "low", "medium", "high", "xhigh"].includes(rest))
+          throw Error("Thinking level: off, minimal, low, medium, high, xhigh");
+        await workspace.send(cmd, requireArg(rest, `Enter ${cmd}`));
+        break;
+      case "compact":
+      case "reload":
+      case "stop":
+        await workspace.send(cmd);
+        break;
+      case "approve":
+      case "reject":
+        await workspace.send(cmd, requireArg(rest, "Enter approval ID"));
+        break;
+      case "steer":
+      case "next":
+        await workspace.send(
+          cmd === "next" ? "follow_up" : "steer",
+          requireArg(rest, "Enter a message")
+        );
+        break;
+      case "retry":
+        await workspace.retry(args[0]);
+        break;
+      case "pending":
+        show(
+          "Uncertain commands",
+          [...workspace.pending.values()].filter(
+            (p) => p.chat === workspace.chat
+          )
+        );
+        break;
+      case "queue":
+        if (args[0] === "edit")
+          await workspace.editQueue(
+            requireArg(args[1], "Enter command ID"),
+            requireArg(args.slice(2).join(" "), "Enter replacement text")
+          );
+        else if (args[0] === "remove") {
+          await workspace.send(
+            "cancel",
+            requireArg(args[1], "Enter command ID")
+          );
+          await workspace.refresh();
+        } else if (args.length)
+          throw Error("Use /queue, /queue edit ID TEXT, or /queue remove ID");
+        else {
+          await workspace.refresh();
+          show("Queue", workspace.detail?.commands ?? []);
+        }
+        break;
+      case "files":
+        await workspace.refresh();
+        show("Files", Object.keys(workspace.detail?.files ?? {}));
+        break;
+      case "view":
+      case "diff":
+      case "download": {
+        await workspace.refresh();
+        const path = requireArg(args[0], "Enter hosted file path");
+        const file = workspace.detail?.files[path];
+        if (!file) throw Error("File not found");
+        if (cmd === "download") {
+          const destination = requireArg(
+            args[1],
+            "Enter an explicit local destination"
+          );
+          await writeExclusive(destination, file.content);
+          show("Saved", destination);
+        } else
+          show(
+            path,
+            cmd === "diff" ? `BEFORE
+${file.before ?? "(no previous content)"}
+AFTER
+${file.content}` : file.content
+          );
+        break;
+      }
+      case "skills":
+        await workspace.refresh();
+        show("Skills", workspace.detail?.skills ?? []);
+        break;
+      case "skill": {
+        const action = args[0];
+        if (action === "import") {
+          const skill = await importSkill(
+            requireArg(args[1], "Enter local skill file or folder")
+          );
+          await workspace.skill(skill);
+          show("Imported", skill.name);
+        } else if (action === "reload") await workspace.send("reload");
+        else {
+          await workspace.refresh();
+          const skill = workspace.detail?.skills.find(
+            (s) => s.name === args[1]
+          );
+          if (!skill) throw Error("Skill not found");
+          if (action === "view")
+            show(
+              skill.name,
+              skill.files[args[2] ?? "SKILL.md"] ?? (() => {
+                throw Error("Skill file not found");
+              })()
+            );
+          else if (action === "toggle")
+            await workspace.skill({ ...skill, enabled: !skill.enabled });
+          else if (action === "invoke") {
+            if (!skill.enabled)
+              throw Error("Enable the skill before invoking it");
+            await workspace.send(
+              workspace.busy ? "steer" : "prompt",
+              `/skill:${skill.name} ${args.slice(2).join(" ")}`.trim()
+            );
+          } else
+            throw Error("Use /skill import, view, toggle, invoke, or reload");
+        }
+        break;
+      }
+      case "memory":
+        if (args[0] === "delete")
+          show(
+            "Deleted note",
+            await options.client.request(
+              `/v1/agent/notes/${encodeURIComponent(requireArg(args[1], "Enter note ID"))}`,
+              { method: "DELETE" }
+            )
+          );
+        else {
+          const offset2 = args[0] === "page" ? Number(args[1]) : 0;
+          if (!Number.isSafeInteger(offset2) || offset2 < 0)
+            throw Error("Page offset must be a nonnegative integer");
+          const query2 = args[0] === "page" ? args.slice(2).join(" ") : rest;
+          show(
+            "Memory",
+            await options.client.request(
+              `/v1/agent/notes?limit=100&offset=${offset2}&query=${encodeURIComponent(query2)}`
+            )
+          );
+        }
+        break;
+      case "history": {
+        const from = rest ? Number(rest) : 0;
+        if (!Number.isSafeInteger(from) || from < 0)
+          throw Error("Enter a nonnegative sequence");
+        show(
+          "History",
+          workspace.events.filter((e) => e.seq >= from)
+        );
+        break;
+      }
+      case "export":
+        await writeExclusive(
+          requireArg(args[0], "Enter an explicit local export destination"),
+          JSON.stringify(await workspace.export(), null, 2) + "\n"
+        );
+        show("Exported", args[0]);
+        break;
+      default:
+        throw Error(`Unknown command /${cmd}. Use /help.`);
+    }
+    tui.requestRender();
+  }
+  let submitting = false;
+  let ready = false;
+  async function submit(text) {
+    const generation = workspace.generation;
+    if (!ready || submitting) {
+      input.setText(text);
+      show(
+        !ready ? "Hosted workspace loading" : "Busy",
+        !ready ? "Wait for the selected chat to load. Your draft is preserved." : "Wait for the current request to finish. Your draft is preserved."
+      );
+      return;
+    }
+    submitting = true;
+    show(
+      "Loading",
+      text.startsWith("/") ? text.split(" ")[0] : "Submitting hosted command"
+    );
+    try {
+      await execute(text);
+      if (input.getText() === text) input.setText("");
+    } catch (e) {
+      if (!done) {
+        redraw();
+        if (generation === workspace.generation && !input.getText())
+          input.setText(text);
+        show(
+          e instanceof Error && e.name === "AbortError" ? "Transfer paused" : "Error",
+          e instanceof Error && e.name === "AbortError" ? "Local request interrupted. Upload receipts are preserved; use /uploads retry to resume. Hosted jobs continue." : e instanceof Error ? e.message : String(e)
+        );
+      }
+    } finally {
+      submitting = false;
+      if (generation !== workspace.generation && !/^\/(task|open|new|fork|quit|exit)(?:\s|$)/.test(text)) {
+        screen.lines = [];
+        seenGeneration = workspace.generation;
+        seenCount = 0;
+        screen.offset = 0;
+        streams.clear();
+      }
+      tui.requestRender();
+    }
+  }
+  tui.addChild(screen);
+  tui.addChild(input);
+  input.onSubmit = (text) => void submit(text);
+  tui.addInputListener((data) => {
+    if (matchesKey2(data, "escape") && dashboardAbort) {
+      dashboardAbort.abort();
+      show(
+        "Transfer paused",
+        "Interrupting the local dashboard request; upload receipts are preserved."
+      );
+      return { consume: true };
+    }
+    if (ready && !dashboardAbort && workspace.busy && (matchesKey2(data, "escape") || matchesKey2(data, "ctrl+c"))) {
+      void workspace.send("stop").then(
+        () => show(
+          "Stop requested",
+          "Stopping hosted work; the chat remains open."
+        ),
+        (error) => show(
+          "Stop failed",
+          error instanceof Error ? error.message : String(error)
+        )
+      );
+      return { consume: true };
+    }
+    if (matchesKey2(data, "ctrl+c")) {
+      quit();
+      return { consume: true };
+    }
+    if (matchesKey2(data, "pageUp") || matchesKey2(data, "pageDown")) {
+      screen.offset = Math.max(
+        0,
+        Math.min(
+          screen.lines.length,
+          screen.offset + (matchesKey2(data, "pageUp") ? 10 : -10)
+        )
+      );
+      tui.requestRender();
+      return { consume: true };
+    }
+    return void 0;
+  });
+  tui.setFocus(input);
+  tui.start();
+  show(
+    "Ready",
+    "Use /help for hosted commands. No hosted chat selected; /chats, /open ID or /new NAME."
+  );
+  if (options.chat)
+    try {
+      await workspace.open(options.chat);
+      await workspace.poll();
+      redraw();
+    } catch (e) {
+      show("Error", e instanceof Error ? e.message : String(e));
+    }
+  ready = true;
+  options.onReady?.({ workspace, submit, quit });
+  void poll();
+  return await result;
+}
+
+// sdk-markdown:/Users/kapavarapu/Desktop/ashr-manifold/.worktrees/cli-scoped-name/docs/sdk.md
+var sdk_default = '# Manifold Python SDK\n\n## Quickstart\n\nCapture calls, train candidates, and serve promoted models. Reviewed against repository code on September 15, 2026; deployed API/worker and installed SDK versions may differ.\n\n### Install\n\n```bash\npip install ashr-manifold  # Python 3.10+; from a checkout: pip install ./sdk\nexport ASHR_BASE_URL="https://api.manifold.ashr.io"\nexport ASHR_API_KEY="ask_..."\n```\n\nCreate a service key in the platform\u2019s API keys page. The platform renders this guide under SDK docs.\n\n```python\nfrom ashr_sdk import AshrClient\nashr = AshrClient()  # reads both environment variables\n```\n\nExamples use placeholder IDs. Replace them with objects in your tenant; keep one client open and close it when finished.\n\n### Serve a promoted model\n\nCall a promoted model with the Anthropic- or OpenAI-style client, pointed at\nManifold\'s base URL with the task name as `model`. The capture ID comes back in\nthe `X-Manifold-Interaction-Id` response header:\n\n```python\nimport os\nfrom anthropic import Anthropic\n\nmodel_client = Anthropic(\n    api_key=os.environ["ASHR_API_KEY"],\n    base_url=os.environ["ASHR_BASE_URL"].rstrip("/"),\n)\nserved = model_client.messages.with_raw_response.create(\n    model="game_generation",   # a promoted task; add "@alias" to pin one\n    max_tokens=1024,\n    messages=[{"role": "user", "content": "Build an ice cavern."}],\n)\nmessage = served.parse()\ninteraction_id = served.headers.get("x-manifold-interaction-id")\nprint(message.content[0].text, interaction_id)\n```\n\nRequires a promoted, loadable artifact. Manifold captures served completions\nautomatically when telemetry succeeds. See Host a trained model for the OpenAI\nclient, tools, streaming, and limits.\n\n### Wrap an existing client\n\nFor models served elsewhere, install the provider package and wrap its client:\n\n```python\nimport anthropic\nimport ashr_sdk as capture\n\ncapture.init(task="game_generation")\nclient = capture.wrap(anthropic.Anthropic())  # your provider credentials\nresponse = client.messages.create(\n    model="claude-sonnet-4-5", max_tokens=512,\n    messages=[{"role": "user", "content": "Design a level."}],\n)\ncapture.flush()\n```\n\nSupports OpenAI and Anthropic sync, async, and streaming calls. Capture failures warn without failing the provider call. Flush before short-lived processes exit.\n\n## Capture production behavior\n\nProduction shows captured calls, model lineage, review coverage, latency, and cost. Use the SDK to capture calls and record feedback.\n\n### Group calls with a trace\n\n```python\nwith ashr.trace("support_routing", client_ref="ticket-4821"):\n    interaction_id = ashr.log(\n        task="support_routing", model_id="m_router",\n        input={"subject": "Cannot reset password"},\n        output={"queue": "identity"}, latency_ms=210,\n        input_tokens=86, output_tokens=18,\n        decisions=[{\n            "field_path": "queue", "value": "identity", "confidence": 0.91,\n            "alternatives": [{"value": "billing", "probability": 0.07}],\n            "source_citation": "ticket subject",\n        }],\n    )\n```\n\n`log()` requires a registered `model_id`. The wrapper and `log_batch()` also support model-name auto-registration. `client_ref` is your request ID; use dotted `field_path` values for nested decisions.\n\n### Attach artifacts\n\n```python\nartifact = ashr.artifacts.register(\n    name="ticket attachment", kind="document",\n    bucket="my-evidence", object_key="tickets/4821.pdf",\n)\ninteraction_id = ashr.log(\n    "support_routing", "m_router", {"ticket": "4821"}, {"queue": "identity"},\n    artifacts=[artifact["id"]],\n)\nurl = ashr.artifacts.access_url(artifact["id"], expires_in=900)\n```\n\n`artifacts.list()` and `get(id)` read registered evidence. These are object-store artifacts; discovered training weights use the download API under Run model experiments.\n\n## Build feedback and evidence\n\n### Record human feedback\n\n```python\nashr.feedback(\n    interaction_id, "corrected", corrected_output={"queue": "account_recovery"},\n    diff={"queue": ["identity", "account_recovery"]},\n    by="reviewer-142", reason="routing_error",\n)\n```\n\nUse `confirmed` for correct output, `corrected` with the complete desired output, or `rejected`. Rejected output is never a positive target; it can supply a DPO negative.\n\n### Report validator checks\n\n```python\nashr.checks([{\n    "interaction_id": interaction_id,\n    "checks": {"schema_valid": True, "correct_queue": False},\n    "details": {"correct_queue": "expected account_recovery"},\n}], reviewer="routing-validator")\n```\n\nAll checks passing confirms the observation; any failure rejects it. Report measured results only.\n\n### Import labeled data\n\n```python\nresult = ashr.datasets.import_examples(\n    task="support_routing", model_id="m_router",\n    examples=[{"subject": "Reset password", "queue": "identity"}],\n    input_fn=lambda row: {"subject": row["subject"]},\n    output_fn=lambda row: {"queue": row["queue"]},\n    metadata_fn=lambda row: {"source": "reviewed_tickets"},\n    batch_size=25, freeze=False,\n)\n```\n\nAccepts any iterable, including a Hugging Face Dataset. Batches allow 1\u2013500 rows; use 25\u201350 for large payloads. `log_batch()` accepts `interaction` plus optional `feedback`; `interaction.model` can register by name.\n\n`input.source` is reserved for `manifold.source/v1`; put ordinary provenance in `input.metadata`. The batch API accepts historical `created_at` values from 2020 through now and normalizes aware timestamps to UTC.\n\n### Freeze and resume safely\n\n```python\ndataset = ashr.datasets.freeze("support_routing", holdout_fraction=0.1)\ndataset_id = dataset["id"]\nversions = ashr.datasets.list()\n```\n\nFreeze records immutable membership and holdout splits. Alternatively, set `freeze=True` on import and use `result["dataset"]["id"]`; do not freeze again without new labeled data (400). After an import failure, inspect `failed_index`/`completed` in the API error. The SDK exposes that detail as `AshrError` text, not a cross-batch resume cursor. Track your batches. After an ambiguous import or freeze timeout, reconcile accepted rows or dataset versions before retrying; a concurrent freeze returns 409.\n\n## Run model experiments\n\nExperiments trains candidates on the same frozen dataset and compares their evaluation evidence. Use the SDK for training configuration, cancellation, retries, and deployment rollback.\n\n### Create an experiment\n\n```python\nexperiment = ashr.experiments.create(\n    name="support-router-v5", task="support_routing", dataset="ds_support_v5",\n    models=["org/router-small", {\n        "model_ref": "org/router-large", "revision": "PINNED_REVISION",\n        "recipe": "dpo_lora", "config": {"gpu": "L40S", "dpo_beta": 0.1},\n    }],\n    training_config={"epochs": 1, "eval_batch_size": 8, "eval_max_tokens": 256},\n    primary_metric="field_f1", gates={"field_f1": 0.8, "schema_validity": 0.95},\n    evaluator_config={"required_fields": ["queue"]},\n)\nprint(experiment.id, experiment.estimate())\nexperiment.start(idempotency_key="support-router-v5-start")\nexperiment.wait(timeout=21600, poll_interval=10)\nresults = experiment.comparison()\nprint(experiment.failures())\n```\n\nPin each model revision. Candidate settings override experiment defaults. SFT uses positive targets; DPO needs chosen/rejected pairs. Gates require measured metrics and cannot lower platform floors. An estimate is directional, not a bill.\n\n### Track runs and recover failures\n\n```python\nexperiment.refresh()\nfor candidate in experiment.candidates:\n    for run in candidate["runs"]:\n        current = ashr.training_runs.get(run["id"])\n        print(current["status"], current.get("error"))\nstale_runs = ashr.training_runs.stale(minutes=15)\n# After inspecting a specific run:\n# ashr.training_runs.cancel(run_id)\n# retried = ashr.training_runs.retry(run_id)\n```\n\n`wait()` includes failed/cancelled terminal states; inspect errors and gates. Save the experiment ID before starting. Retry `start()` on `experiments.get(id)` with the same key. Repeating `experiments.run()` creates a new experiment. `experiments.list()` lists existing experiments.\n\nThe worker enables gradient checkpointing by default. For OOM, reduce `max_length` or choose a supported larger GPU. `retain_failed_artifacts=True` retains a written final artifact after a gate miss; it cannot recover unwritten weights.\n\n### Own the weights\n\n```python\nresume = ashr.training_runs.weights_url(run_id)\nadapter = ashr.training_runs.weights_url(run_id, format="adapter")\nexact = ashr.training_runs.weights_url(run_id, checkpoint=600)\nfinal = ashr.training_runs.weights_url(run_id, checkpoint=None, format="adapter")\nprint(resume["url"])\n```\n\nSigned downloads expire after one hour by default. `latest` resolves at download time; numbered steps pin selection. Resume archives include weights, optimizer, scheduler, RNG, and trainer state; adapter archives are for inference. A URL can be issued before files exist; the download may return 409 before the first save. Defaults: `save_steps=100`, `save_total_limit=2`. Download needed steps before pruning.\n\n```python\nimport os\nashr.training_runs.export_to_huggingface(\n    run_id, repo_id="acme/support-router-v5", hf_token=os.environ["HF_TOKEN"],\n)\n```\n\nThe token is forwarded for upload, not stored. The response means queued, not uploaded. Load adapter files with PEFT and the matching base model.\n\n### Discovered artifacts\n\nArtifacts lists checkpoints/adapters from Modal volumes, including failed runs. Filter for weights; inspect written time, adoption status, and download size, which includes nested files. Discovery does not mean evaluated, registered, or promoted.\n\nFor a row\u2019s exact `volume` and `path`, use its download button/API command or `POST /v1/modal-artifacts/download-url` with `format="resume"` or `"adapter"`. Your session or service key authorizes the grant; no Modal token is needed. The SDK has no dedicated helper for this endpoint.\n\n## Run the full learning cycle\n\n### Run a cycle\n\n```python\nreport = ashr.learning_loops.run(\n    task="support_routing",\n    candidates=[{"model_source_id": "src_router", "recipe": "sft_lora"}],\n    eval_config={"primary_metric": "field_f1"},\n    halving={"metric": "proxy_score", "at_progress": 0.5, "kill_fraction": 0.5},\n    alias="production", timeout_seconds=300,\n)\nprint(report["killed"], report["winner"], report["promoted"], report["reason"])\n```\n\nUses registered model-source IDs. Freezes/reuses evidence, builds an environment, trains, halves, evaluates, and promotes only a passing winner that beats the incumbent. Halving is recorded before launch. This synchronous request needs sufficient client/gateway time; inspect runs after a timeout before starting another cycle.\n\n### Test without GPUs\n\nUse `MANIFOLD_TRAINING_BACKEND=mock` on a local test API. It exercises callbacks, gates, lineage, and cancellation with simulated training. `backend/scripts/learning_loop_demo.py` runs the local example. Mock scores do not establish model quality.\n\n## Continuous learning configuration\n\n### Build an environment\n\n```python\nenvironment = ashr.environments.build(\n    task="support_routing", dataset_id="ds_support_v5",\n    reward_spec={"resolved": 1, "policy_violation": -5},\n)\nashr.learning_loops.configure(\n    task="support_routing", environment_id=environment["id"],\n    config={"trigger_after_reviewed": 500, "trigger_every_days": 7,\n            "benchmark_incumbent": True, "auto_train": True},\n)\n```\n\nThese calls store environment and retraining configuration. Trigger scheduling remains in progress. Read configurations with `environments.list()` and `learning_loops.list()`.\n\n### Application-side routing\n\n```python\nashr.router.configure(\n    task="support_routing", incumbent_model_id="m_current",\n    challenger_model_id="m_candidate", traffic_percent=5,\n)\nassignment = ashr.router.decide(task="support_routing", request_key="ticket-4821")\n# Your application serves assignment["model_id"], then records the actual result:\nashr.router.outcome(assignment["id"], {"resolved": True, "reward": 1})\nashr.router.set_traffic("support_routing", 0)\n```\n\nAssignment is deterministic per policy/key. For managed serving, also promote the challenger to `canary` as described below.\n\n## Host a trained model\n\nRequires a promoted task alias backed by a loadable trained artifact. Installing the SDK or finding weights does not create a deployment.\n\n### Choose a client\n\nOpenAI uses the API root plus `/v1`; Anthropic and `AshrClient` use the API root. Install provider packages separately.\n\n```python\nimport os\nfrom openai import OpenAI\n\nclient = OpenAI(api_key=os.environ["ASHR_API_KEY"],\n                base_url=os.environ["ASHR_BASE_URL"].rstrip("/") + "/v1")\nresponse = client.chat.completions.create(\n    model="game_generation", max_completion_tokens=1024,\n    messages=[{"role": "user", "content": "Build an ice cavern."}],\n)\nprint(response.choices[0].message.content)\n```\n\n```python\nfrom anthropic import Anthropic\n\nclient = Anthropic(api_key=os.environ["ASHR_API_KEY"],\n                   base_url=os.environ["ASHR_BASE_URL"].rstrip("/"))\nmessage = client.messages.create(\n    model="game_generation", max_tokens=1024,\n    system="Return a concise level design.",\n    messages=[{"role": "user", "content": "Build an ice cavern."}],\n)\nprint(message.content[0].text)\n```\n\nTools and streaming work on either client. From OpenAI, declare `tools` and stream with `stream=True`:\n\n```python\nopenai_client = OpenAI(api_key=os.environ["ASHR_API_KEY"],\n                       base_url=os.environ["ASHR_BASE_URL"].rstrip("/") + "/v1")\nstream = openai_client.chat.completions.create(\n    model="game_generation", stream=True,\n    messages=[{"role": "user", "content": "Design a level, then call the tool."}],\n    tools=[{"type": "function", "function": {\n        "name": "save_level",\n        "parameters": {"type": "object", "properties": {"name": {"type": "string"}}}}}],\n)\nstream_text = "".join(\n    chunk.choices[0].delta.content or "" for chunk in stream)\n```\n\nA non-streaming tools call returns `tool_calls` on the message with `finish_reason="tool_calls"`; send each result back as a `{"role": "tool", "tool_call_id": ..., "content": ...}` message. The Anthropic client uses `tools` with `input_schema` and receives `tool_use` content blocks.\n\nNative SDK: `ashr.infer(task, input, alias="production", max_new_tokens=1024)` returns the parsed `output`, per-field `decisions`, `usage`, `deployment`, and `interaction_id`. Read `deployment.alias` for the actual selection; the top-level alias is the requested one.\n\n`ashr.infer` (and `POST /v1/inference/{task}`) is **deprecated for chat and agentic models** \u2014 use the Anthropic or OpenAI client shown above, which serve the hosted model directly with tools and streaming. It remains supported, and is the right choice, for structured-output tasks (e.g. classification) that need the per-field `decisions` capture the transparent surfaces don\'t produce. It is not being removed.\n\n### Supported requests and generation limits\n\n- Model: `task` or `task@alias`; default alias is `production`.\n- Both surfaces are served by the same hosted model \u2014 OpenAI (`/v1/chat/completions`) is translated to Anthropic Messages at the edge \u2014 so the same model key works from either SDK. `system`/`user`/`assistant`/`tool` roles, `temperature`, `top_p`, and `stop` are supported; `max_completion_tokens` takes precedence over `max_tokens`.\n- **Tools and streaming are supported on both surfaces.** OpenAI `tools` come back as `tool_calls` (with `finish_reason: "tool_calls"`), `tool` messages carry results back, and `stream: true` yields `chat.completion.chunk` events including tool-call deltas and final usage. The Anthropic surface forwards request and response bodies unchanged \u2014 tools, thinking, and streams \u2014 subject to the hosted model\u2019s capabilities.\n- OpenAI multimodal (image) content is not supported; a message whose content is not text is rejected. Older API deployments support only text and reject streaming; verify your deployed revision.\n- Token limits must be positive. Omitted limits use remaining model context; the Anthropic Python client requires `max_tokens`. Configure client timeouts for your budget.\n- Platform keys (`ask_`) support platform operations. Model keys (`msk_`) grant inference for one task; use a platform key for feedback and training.\n\n### Completion evidence and feedback\n\nNo capture wrapper is needed for hosted calls. OpenAI responses add `manifold` metadata:\n\n```python\nmetadata = response.model_dump()["manifold"]\ninteraction_id = metadata["interaction_id"]\n# After actual review, and only if interaction_id is not None:\n# ashr.feedback(interaction_id, "confirmed", by="reviewer-142")\n```\n\nIncludes task, actual alias, and deployment ID. Both surfaces return the capture ID in the `X-Manifold-Interaction-Id` header on non-streaming responses (read it via each client\u2019s raw-response interface); the OpenAI non-streaming body also carries it in the `manifold` block above. Streams return no capture ID; their capture retains text deltas, not tool/thinking deltas, even though those events reach the caller. Capture failure returns a null interaction ID without failing a completed answer. Do not attach feedback to a missing ID.\n\nOpenAI finish reasons: `stop`/`length`/`tool_calls`; null means missing/unrecognized worker evidence. Anthropic stop reasons are passed through from the hosted model. Inspect truncated output. Literal text is retained in `sampling_params.raw_text` when available; retained context is not automatically supervised training data.\n\n### Canary rollout and rollback\n\n```python\nincumbent = ashr.deployments.resolve("support_routing", alias="production")\ncanary = experiment.promote(candidate_id, alias="canary")\nashr.router.configure(\n    task="support_routing", incumbent_model_id=incumbent["model_id"],\n    challenger_model_id=canary["model_id"], traffic_percent=5,\n)\nashr.router.set_traffic("support_routing", 0)  # stop automatic canary selection\n```\n\nUse a passing candidate ID. Production requests participate in the split; explicit `@canary` bypasses it, even at zero traffic. OpenAI `user` or Anthropic `metadata.user_id` makes assignment sticky; without a key it is per request. Native `infer()` has no request-key parameter.\n\nAutomatic routing falls back to production if canary is absent, unavailable, or mismatched. Check returned deployment metadata. Alias-history rollback is separate: `deployments.rollback(deployment_id)`.\n\n### Hosting failures and separate endpoints\n\n- 401: invalid key/environment. 409: alias lacks a loadable artifact.\n- 400/422: local request validation failed. Anthropic upstream failures become 502, or an error event after a stream opens. 502 also indicates inference gateway failure.\n- Timeout: completion may be unknown; a retry can duplicate work.\n\nVerify an authenticated request through the intended alias; health and alias existence do not prove GPU readiness. The standalone `ashr-model-api` uses its own fixed model and endpoint key, without Manifold tenant lookup or billing. Obtain its details from the operator; do not assume those calls appear in Production.\n\n## Deploy and monitor\n\n### Promote and resolve\n\nAfter reviewing metrics and gates, select a passing candidate:\n\n```python\ndeployment = experiment.promote(candidate_id, alias="production")\nproduction = ashr.deployments.resolve("support_routing")\n# To restore the previous revision:\n# ashr.deployments.rollback(deployment["id"])\n```\n\n`deployments.list(task=...)` lists aliases; `get(id)` reads deployment details. Training completion is not serving readiness or evidence of quality.\n\n### Read production metrics\n\n```python\nhealth = ashr.monitoring.model("m_router", days=30)\ndaily = ashr.monitoring.timeseries("m_router", days=30)\ncomparison = ashr.monitoring.compare("m_previous", "m_router", days=30)\ndrift = ashr.monitoring.drift("m_router", days=30, minimum_reviewed=20)\n```\n\nInspect volume, review coverage, correction rate, and latency. Reviewer rates use reviewed observations; pending output is not counted as correct.\n\n### Create an alert\n\n```python\npolicy = ashr.monitoring.create_alert(\n    name="Routing correction rate", model_id="m_router",\n    metric="correction_rate", operator="gte", threshold=0.08,\n    window_days=7, minimum_observations=50,\n)\npolicies = ashr.monitoring.alert_policies()\nalerts = ashr.monitoring.alerts(limit=100)\n```\n\n`evaluate_alerts()` evaluates policies now. Scheduled checks depend on the deployed monitoring worker.\n\n## Pipelines and progress\n\nPipeline shows stage evidence; Data sources shows owned/shared source access. Use an ID from `pipelines.list()`; `manifold_loop` exists only after it has been seeded.\n\n### Reading progress\n\n```python\npipelines = ashr.pipelines.list()\nstatus = ashr.pipelines.status("manifold_loop", task="document_parsing")\nprint(status.progress, status.stage("capture"))\nfresh = status.refresh(task="document_parsing")\n```\n\n- `progress.unbroken`: completed prefix; `complete`: all completed stages, including those past a gap.\n- `next` and `startable`: next gap and stages whose dependencies permit running.\n- `status.complete`, `blocked`, `failed`, `unknown`, `stale`, `startable`, and `gates`: filtered stage lists. `state(id)` reads one state.\n- `unknown`: probe could not run, not pending. Freshness uses `observedAt`, `ageSeconds`, `stale`, and each probe\u2019s TTL. `refresh=True` re-probes.\n\n### Writing a definition\n\n```python\nashr.pipelines.put({\n    "schemaVersion": 1, "id": "my_pipeline", "label": "My pipeline",\n    "phases": [{"id": "acquire", "label": "Acquire", "stages": [{\n        "id": "reachable", "title": "Data is reachable",\n        "probe": {\n            "kind": "object_store", "storeRef": "corpus", "prefix": "sessions/",\n            "maxObjects": 10000,\n            "extract": {"objects": {"path": "$.Contents[*]", "agg": "count"}},\n            "complete": {"gte": ["objects", 1]},\n            "detail": "{objects} objects reachable", "ttlSeconds": 3600,\n        },\n    }]}],\n})\n```\n\n`put()` validates tenant-safe probes and invalidates cached readings. `get(id)`, `delete(id)`, and `registries()` manage definitions and allowed probe/query names. Full schema: `docs/pipelines.md`.\n\n### Data sources\n\n```python\nashr.pipelines.data_sources.put(\n    "corpus", provider="s3_compatible", bucket="my-corpus",\n    endpoint="https://nyc3.digitaloceanspaces.com", allowed_prefixes=["sessions/"],\n    credential_ref="awssm://YOUR_SECRET_REFERENCE",\n)\nsources = ashr.pipelines.data_sources.list()\naccess = ashr.pipelines.data_sources.check("corpus")\nprint(access)\n```\n\nSupply either a secret reference or `credentials={"access_key_id": ..., "secret_access_key": ...}`. Credentials are accepted once and never returned. Empty `allowed_prefixes` grants no access; probes name the source alias.\n\nFor shared data, set `shared_from` and optionally `shared_from_tenant_id`; resolved `sharing.from_tenant` takes precedence over the label. `credential.name` is a pointer, not secret material. `delete(alias)` removes a source.\n\nA configured credential does not prove access. Inspect `reachable`, `error`, and `truncated`; a capped listing is a lower bound. S3-compatible checks list metadata only. GCS, Azure Blob, and HTTPS can be registered but report unsupported listing, so their probes read `unknown`.\n\n## Reliability and lifecycle\n\n### Handle errors\n\n```python\nfrom ashr_sdk import AshrClient, AshrError\n\ntry:\n    with AshrClient(timeout=180) as ashr:\n        health = ashr.monitoring.model("m_router")\nexcept AshrError as error:\n    print(error.status_code, error.request_id, str(error))\n```\n\nInclude request IDs when reporting failures. API errors and transport failures raise `AshrError`; transport failures may have no status or request ID. Reconcile timed-out writes before retrying.\n\n### Manage the client\n\nUse a context manager for scripts, or reuse one `AshrClient` and call `close()` at shutdown. Module-level capture uses `flush()` before exit. Never place service keys in browser code; the platform uses Clerk through its same-origin API.\n';
+
+// src/hosted/sdk-reference.ts
+var documentTitle = /^# (.+)$/m.exec(sdk_default)?.[1] ?? "Manifold Python SDK";
+var sections = [];
+var offset = 0;
+var fenced = false;
+for (const line2 of sdk_default.split(/(?<=\n)/)) {
+  if (line2.startsWith("```")) fenced = !fenced;
+  const heading2 = !fenced ? /^## ([^\r\n]+)\r?\n?$/.exec(line2) : null;
+  if (heading2) {
+    const previous = sections.at(-1);
+    if (previous) previous.end = offset;
+    const title = heading2[1];
+    const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
+    sections.push({ title, slug, start: offset, end: sdk_default.length });
+  }
+  offset += line2.length;
+}
+function sdkReference(topic) {
+  const selected = topic || "quickstart";
+  if (selected === "all") return { title: documentTitle, content: sdk_default };
+  if (selected === "index")
+    return {
+      title: documentTitle,
+      content: sections.map((section2) => `- ${section2.title}: /sdk ${section2.slug}`).join("\n") + "\n\n/sdk all reads the complete guide. /sdk defaults to Quickstart."
+    };
+  const section = sections.find((candidate) => candidate.slug === selected);
+  if (!section) throw Error(`Unknown SDK topic '${selected}'. Use /sdk index.`);
+  return {
+    title: section.title,
+    content: sdk_default.slice(section.start, section.end)
+  };
+}
+
+// src/hosted/dashboard-sample.ts
+import { open as open2, readFile as readFile2, rename, unlink } from "node:fs/promises";
+import { randomUUID as randomUUID3 } from "node:crypto";
+async function sampleModel(context, model, prompt, maxTokens, temperature, file, show) {
+  const stream = context.client.requestStream;
+  if (!stream) throw Error("This client does not support streaming samples");
+  let conversation = { version: 1, task: model, api_origin: context.client.apiOrigin, messages: [], turns: [] };
+  let resumed = false;
+  if (file) {
+    if (!context.client.apiOrigin) throw Error("Conversation requires a client with a verified API origin");
+    try {
+      conversation = JSON.parse(await readFile2(file, "utf8"));
+      resumed = true;
+    } catch (error) {
+      if (error.code !== "ENOENT") throw Error("Conversation must be a readable terminal sample JSON file");
+      const handle = await open2(file, "wx", 384);
+      await handle.close();
+    }
+    if (conversation.version !== 1 || conversation.task !== model || !Array.isArray(conversation.messages) || !Array.isArray(conversation.turns) || conversation.messages.some((m) => !m || !["user", "assistant"].includes(m.role) || typeof m.content !== "string")) throw Error("Conversation task or format does not match this sample");
+    if (resumed) {
+      if (conversation.api_origin !== context.client.apiOrigin) throw Error("Conversation API origin does not match; no history was sent");
+    }
+  }
+  const persist = async () => {
+    if (!file) return;
+    const temp = `${file}.${randomUUID3()}.tmp`;
+    const handle = await open2(temp, "wx", 384);
+    try {
+      await handle.writeFile(JSON.stringify(conversation, null, 2) + "\n");
+      await handle.sync();
+      await handle.close();
+      await rename(temp, file);
+    } catch (error) {
+      await handle.close().catch(() => {
+      });
+      await unlink(temp).catch(() => {
+      });
+      throw error;
+    }
+  };
+  context.signal?.throwIfAborted();
+  conversation.messages.push({ role: "user", content: prompt });
+  const messages = [...conversation.messages];
+  const assistant = { role: "assistant", content: "" };
+  conversation.messages.push(assistant);
+  const turn = { events: [], status: "streaming" };
+  conversation.turns.push(turn);
+  await persist();
+  try {
+    const response = await stream.call(context.client, "/v1/messages", { method: "POST", signal: context.signal, body: JSON.stringify({ model, max_tokens: maxTokens, temperature, stream: true, messages }) });
+    if (!response.body) throw Error("Sample response has no stream");
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let complete = false;
+    const cancel = () => {
+      void reader.cancel(context.signal?.reason);
+    };
+    context.signal?.addEventListener("abort", cancel, { once: true });
+    const event = async (block) => {
+      const data = block.split("\n").filter((line2) => line2.startsWith("data:")).map((line2) => line2.slice(5).trimStart()).join("\n");
+      if (!data) return;
+      if (data === "[DONE]") {
+        complete = true;
+        return;
+      }
+      const value = JSON.parse(data);
+      turn.events.push(value);
+      if (value.type === "error" || value.error) throw Error("Model stream error: " + JSON.stringify(value.error ?? value));
+      const text = value.type === "content_block_delta" && value.delta?.type === "text_delta" ? value.delta.text : value.type === "content_block_start" ? value.content_block?.text : value.choices?.[0]?.delta?.content;
+      if (typeof text === "string" && text) {
+        assistant.content += text;
+        show("Sample text", text);
+      }
+      if (value.type === "message_stop") complete = true;
+      await persist();
+    };
+    try {
+      while (true) {
+        context.signal?.throwIfAborted();
+        const part = await reader.read();
+        buffer += decoder.decode(part.value, { stream: !part.done });
+        buffer = buffer.replace(/\r\n/g, "\n");
+        let split;
+        while ((split = buffer.indexOf("\n\n")) >= 0) {
+          await event(buffer.slice(0, split));
+          buffer = buffer.slice(split + 2);
+        }
+        if (part.done) break;
+      }
+      context.signal?.throwIfAborted();
+      if (buffer.trim()) await event(buffer);
+      if (!complete) throw Error("Model stream incomplete; partial conversation retained. A new sample is a new paid request.");
+    } finally {
+      context.signal?.removeEventListener("abort", cancel);
+      await reader.cancel().catch(() => {
+      });
+    }
+    turn.status = "complete";
+    await persist();
+    show("Model sample", { task: model, message: assistant, events: turn.events, conversation: file ?? null });
+  } catch (error) {
+    turn.status = "interrupted";
+    if (!assistant.content) conversation.messages.pop();
+    await persist();
+    const message = error instanceof Error ? error.message : String(error);
+    throw Error(message);
+  }
+}
+
+// src/hosted/dashboard.ts
+import { parse as parse4 } from "shell-quote";
+import { readFile as readFile4 } from "node:fs/promises";
+
+// src/hosted/dashboard-files.ts
+import { createHash as createHash4 } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { open as open3, readFile as readFile3, rename as rename2, stat, unlink as unlink2, writeFile } from "node:fs/promises";
+import { basename as basename4, resolve as resolve8 } from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+function transferUrl(value) {
+  const url = new URL(value);
+  if (url.username || url.password || !(url.protocol === "https:" || url.protocol === "http:" && ["127.0.0.1", "localhost", "[::1]"].includes(url.hostname))) throw Error("Transfer URL must use HTTPS (or loopback for local fixtures)");
+  return url.href;
+}
+async function downloadArtifact(client, path, body, output, show, signal) {
+  signal?.throwIfAborted();
+  const destination = resolve8(output);
+  const handle = await open3(destination, "wx", 384);
+  try {
+    const grant = await client.request(path, { method: "POST", body: JSON.stringify(body), ...signal ? { signal } : {} });
+    const response = await fetch(transferUrl(grant.url), { redirect: "error", signal });
+    if (!response.ok || !response.body) throw Error(`Artifact download failed (${response.status})`);
+    await pipeline(Readable.fromWeb(response.body), handle.createWriteStream(), { signal });
+    show("Artifact downloaded", { output: destination, bytes: (await stat(destination)).size });
+  } catch (error) {
+    await handle.close().catch(() => {
+    });
+    await unlink2(destination).catch(() => {
+    });
+    throw error;
+  } finally {
+    await handle.close().catch(() => {
+    });
+  }
+}
+async function fingerprint(file, signal) {
+  const info = await stat(file);
+  if (!info.isFile() || info.size < 1) throw Error("Upload requires a nonempty regular file");
+  const hash = createHash4("sha256");
+  for await (const chunk of createReadStream(file, { signal })) {
+    signal?.throwIfAborted();
+    hash.update(chunk);
+  }
+  return { size: info.size, sha256: hash.digest("hex") };
+}
+async function save(path, receipt) {
+  const temporary = path + ".tmp";
+  await writeFile(temporary, JSON.stringify(receipt, null, 2) + "\n", { flag: "wx", mode: 384 });
+  try {
+    await rename2(temporary, path);
+  } catch (error) {
+    await unlink2(temporary).catch(() => {
+    });
+    throw error;
+  }
+}
+async function uploadFile(action, input, receiptPath, client, show, signal) {
+  signal?.throwIfAborted();
+  const path = resolve8(action === "retry" ? input : receiptPath);
+  let receipt;
+  if (action === "retry") {
+    receipt = JSON.parse(await readFile3(path, "utf8"));
+    if (receipt.version !== 1 || !receipt.file || !Number.isInteger(receipt.size) || !/^[a-f0-9]{64}$/.test(receipt.sha256)) throw Error("Invalid upload receipt");
+    if (receipt.state === "complete") {
+      show("Upload already complete", { receipt: path, key: receipt.key });
+      return;
+    }
+    if (receipt.state !== "uploading") throw Error(`Upload is ${receipt.state}; last response is uncertain. Inspect upload status before retrying; creation/completion will not be repeated.`);
+    const identity = await fingerprint(receipt.file, signal);
+    if (identity.size !== receipt.size || identity.sha256 !== receipt.sha256) throw Error("Source file changed; refusing to resume");
+  } else {
+    const file = resolve8(input), identity = await fingerprint(file, signal);
+    receipt = { version: 1, file, ...identity, state: "creating" };
+    await writeFile(path, JSON.stringify(receipt, null, 2) + "\n", { flag: "wx", mode: 384 });
+    show("Upload opening", { receipt: path, file, bytes: identity.size });
+    signal?.throwIfAborted();
+    const plan = await client.request("/v1/uploads/create", { method: "POST", body: JSON.stringify({ filename: basename4(file), size: identity.size, content_type: "application/octet-stream" }), ...signal ? { signal } : {} });
+    receipt = { ...receipt, upload_id: plan.upload_id, key: plan.key, part_size: plan.part_size, part_count: plan.part_count, state: "uploading" };
+    try {
+      await save(path, receipt);
+    } catch (error) {
+      show("Upload receipt write failed", { receipt: path, upload_id: receipt.upload_id, key: receipt.key, action: "Keep these identifiers; creation must not be repeated." });
+      throw error;
+    }
+  }
+  if (!receipt.upload_id || !receipt.key || !Number.isInteger(receipt.part_size) || receipt.part_size < 1 || !Number.isInteger(receipt.part_count) || receipt.part_count < 1 || receipt.part_count > 1e4 || Math.ceil(receipt.size / receipt.part_size) !== receipt.part_count) throw Error("Invalid multipart upload plan; receipt preserved");
+  const base = `/v1/uploads/${encodeURIComponent(receipt.upload_id)}`;
+  const state = await client.request(`${base}/status?${new URLSearchParams({ key: receipt.key })}`, signal ? { signal } : void 0);
+  const parts = [...state.uploaded_parts];
+  const stored = new Set(parts.map((p) => p.part_number));
+  const handle = await open3(receipt.file, "r");
+  try {
+    for (let n = 1; n <= receipt.part_count; n++) {
+      signal?.throwIfAborted();
+      if (stored.has(n)) continue;
+      const signed = await client.request(base + "/sign", { method: "POST", body: JSON.stringify({ key: receipt.key, part_numbers: [n] }), ...signal ? { signal } : {} });
+      signal?.throwIfAborted();
+      const offset2 = (n - 1) * receipt.part_size, length = Math.min(receipt.part_size, receipt.size - offset2), bytes = Buffer.alloc(length);
+      const read2 = await handle.read(bytes, 0, length, offset2);
+      if (read2.bytesRead !== length) throw Error("Source file changed while uploading");
+      const response = await fetch(transferUrl(signed.urls[String(n)]), { method: "PUT", body: bytes, redirect: "error", signal });
+      if (!response.ok) throw Error(`Upload part ${n} failed (${response.status}); resume with /uploads retry '${path}' --confirm`);
+      const etag = response.headers.get("etag");
+      if (!etag) throw Error(`Upload part ${n} returned no ETag; resume from server status`);
+      parts.push({ part_number: n, etag });
+      show("Upload progress", { receipt: path, uploaded_parts: parts.length, total_parts: receipt.part_count });
+    }
+  } finally {
+    await handle.close();
+  }
+  const finalIdentity = await fingerprint(receipt.file, signal);
+  if (finalIdentity.size !== receipt.size || finalIdentity.sha256 !== receipt.sha256) throw Error("Source file changed while uploading; refusing completion; receipt preserved");
+  signal?.throwIfAborted();
+  receipt.state = "completing";
+  await save(path, receipt);
+  const result = await client.request(base + "/complete", { method: "POST", body: JSON.stringify({ key: receipt.key, parts: parts.map(({ part_number, etag }) => ({ part_number, etag })).sort((a, b) => a.part_number - b.part_number) }), ...signal ? { signal } : {} });
+  receipt.state = "complete";
+  await save(path, receipt);
+  show("Upload complete", { receipt: path, result });
+}
+
+// src/hosted/dashboard.ts
+var enc = encodeURIComponent;
+var dashboardHelpLines = [
+  "/dashboard help \u2014 commands use shell-quoted arguments; writes require repeating with --confirm",
+  "/pipelines list | show ID | status ID | task [TASK]",
+  "/runs list [--app-name NAME --limit N] | show ID [--logs true|false] | claims",
+  "/runs sync --confirm | explain ID [--regenerate true|false] --confirm (paid log explanation)",
+  "/sources list | check ALIAS --confirm",
+  "/sources objects ALIAS --limit N [--prefix PREFIX]",
+  "/sources connect ALIAS --config FILE --confirm | disconnect ALIAS --confirm",
+  "/datasets list [--task TASK]; /evals list [--limit N --after CURSOR --pipeline-id ID] | show ID | report ID",
+  "/evals results ID --model-run-id ID [--limit N --after CURSOR]",
+  "/benchmarks list [--task TASK --benchmark NAME --status STATUS --limit N --offset N] | show EXPERIMENT",
+  "/benchmarks events TRAINING_RUN [--limit N --after CURSOR --kind KIND,KIND --query TEXT --problems-only true|false]",
+  "/experiments list [--task TASK] | show ID | comparison ID | estimate ID",
+  "/models list; /monitoring summary MODEL | series MODEL | drift MODEL [--days N]",
+  "/monitoring compare BASELINE CANDIDATE [--days N]",
+  "/interactions list [--task TASK --model-id ID --feedback-status STATUS --limit N --offset N] | show ID",
+  "/uploads list | status ID --key KEY | cancel ID --key KEY --confirm",
+  "/uploads send FILE --receipt FILE --confirm | retry RECEIPT --confirm (server parts are resume authority)",
+  "/artifacts list [--kind KIND --limit N --has-weights true|false] | records [--kind KIND] | show ID",
+  "/artifacts download VOLUME PATH --output FILE [--format resume|adapter] --confirm",
+  "/artifacts download-record ID --output FILE --confirm (never overwrites)",
+  "/serving list | pools | show ID",
+  "/serving promote EXPERIMENT CANDIDATE [--alias production] --confirm",
+  '/serving sample "PROMPT" [--task TASK --max-tokens N --temperature N --conversation FILE] --confirm',
+  "/sdk [TOPIC|index|all] \u2014 read the shared SDK guide; index lists browser section names"
+];
+function argumentsFor(tokens) {
+  const values = [];
+  const options = {};
+  let confirm = false;
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (token === "--confirm") {
+      if (confirm) throw Error("Duplicate --confirm");
+      confirm = true;
+    } else if (token.startsWith("--")) {
+      const key2 = token.slice(2);
+      const value = tokens[++i];
+      if (!key2 || value === void 0 || value.startsWith("--") || Object.hasOwn(options, key2)) throw Error(`Expected one value for ${token}`);
+      options[key2] = value;
+    } else values.push(token);
+  }
+  return { values, options, confirm };
+}
+function validate(a, min, max, allowed = []) {
+  if (a.values.length < min || a.values.length > max) throw Error(`Expected ${min === max ? min : `${min}\u2013${max}`} positional arguments; see /dashboard help`);
+  for (const key2 of Object.keys(a.options)) if (!allowed.includes(key2)) throw Error(`Unknown option --${key2}`);
+}
+function required(a, key2) {
+  const value = a.options[key2];
+  if (!value) throw Error(`Required --${key2}`);
+  return value;
+}
+function task(a, context) {
+  const value = a.options.task ?? context.task;
+  if (!value) throw Error("Select a task or pass --task TASK");
+  return value;
+}
+function query(path, a, keys, defaults = {}) {
+  const params = new URLSearchParams();
+  for (const key2 of keys) if (a.options[key2] !== void 0) params.set(key2.replaceAll("-", "_"), a.options[key2]);
+  for (const [key2, value] of Object.entries(defaults)) if (!params.has(key2)) params.set(key2, value);
+  return path + (params.size ? `?${params}` : "");
+}
+function clean(value) {
+  if (typeof value === "string") return value.replace(/[\x00-\x1f\x7f-\x9f]/g, (c) => `\\u${c.charCodeAt(0).toString(16).padStart(4, "0")}`);
+  if (Array.isArray(value)) return value.map(clean);
+  if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([k, v]) => [String(clean(k)), clean(v)]));
+  return value;
+}
+function confirmation(context, a, title, target) {
+  if (a.confirm) return true;
+  context.show("Confirmation required", clean({ action: title, target, instruction: "Repeat the exact command with --confirm. No write was sent." }));
+  return false;
+}
+function currentBenchmarkStatus(row) {
+  const candidates = Array.isArray(row.candidates) ? row.candidates : [];
+  const base = candidates.find((candidate) => candidate.recipe === "external_ptb" && candidate.config?.ptb_role === "base");
+  const runs = Array.isArray(base?.runs) ? base.runs : [];
+  const stamp = (run) => {
+    const value = Date.parse(String(run.started_at ?? run.created_at ?? ""));
+    return Number.isNaN(value) ? -Infinity : value;
+  };
+  const latest = [...runs].sort((a, b) => stamp(a) - stamp(b)).at(-1);
+  return latest?.status ?? null;
+}
+async function runDashboardCommand(input, context) {
+  const family = input.trim().split(/\s/)[0]?.slice(1);
+  if (!input.trim().startsWith("/") || !["dashboard", "pipelines", "runs", "sources", "datasets", "evals", "benchmarks", "experiments", "models", "monitoring", "interactions", "uploads", "artifacts", "serving", "sdk"].includes(family ?? "")) return false;
+  const sensitiveValues = [];
+  const redact = (value) => {
+    if (typeof value === "string") return sensitiveValues.reduce((text, secret) => text.split(secret).join("[credential]"), value);
+    if (Array.isArray(value)) return value.map(redact);
+    if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([key2, item]) => [key2, redact(item)]));
+    return value;
+  };
+  const show = (title, value) => context.show(title, clean(redact(value)));
+  const client = { request: (path, init) => context.client.request(path, context.signal ? { ...init, signal: context.signal } : init) };
+  try {
+    const parsed = parse4(input, () => {
+      throw Error("Environment expansion is unavailable; use literal quoted values");
+    });
+    if (parsed.some((token) => typeof token !== "string")) throw Error("Shell operators and comments are unavailable");
+    const tokens = parsed;
+    tokens.shift();
+    const action = tokens.shift() ?? (family === "sdk" ? "" : "list");
+    const a = argumentsFor(tokens);
+    const v = a.values;
+    if (family === "dashboard" || action === "help") {
+      show("Hosted dashboard commands", dashboardHelpLines);
+      return true;
+    }
+    if (family === "sdk") {
+      validate(a, 0, 0);
+      const topic = action;
+      const reference = sdkReference(topic);
+      context.show(reference.title, reference.content);
+      return true;
+    }
+    if (family === "benchmarks") {
+      if (action === "show") {
+        validate(a, 1, 1);
+        show("Benchmark experiment", await client.request(`/v1/experiments/${enc(v[0])}`));
+        return true;
+      }
+      if (action === "events") {
+        validate(a, 1, 1, ["limit", "after", "kind", "query", "problems-only"]);
+        const limit2 = Number(a.options.limit ?? 200);
+        if (!Number.isInteger(limit2) || limit2 < 1 || limit2 > 500) throw Error("Event limit must be 1\u2013500");
+        if (a.options["problems-only"] && !["true", "false"].includes(a.options["problems-only"])) throw Error("problems-only must be true or false");
+        const path = query(`/v1/training-runs/${enc(v[0])}`, a, ["after", "limit"], { limit: String(limit2) });
+        const page = await client.request(path);
+        const events = page.events ?? [], kinds = a.options.kind ? new Set(a.options.kind.split(",")) : void 0, needle = (a.options.query ?? "").trim().toLowerCase();
+        const filtered2 = events.filter((event) => (!kinds || kinds.has(String(event.event))) && (a.options["problems-only"] !== "true" || ["warning", "warn", "error", "critical"].includes(String(event.level ?? "").toLowerCase()) || ["integrity_flag", "stopped"].includes(String(event.event))) && (!needle || `${event.event} ${event.message ?? ""} ${JSON.stringify(Object.fromEntries(Object.entries(event.metadata ?? {}).filter(([key2]) => key2 !== "event_key")))}`.toLowerCase().includes(needle))).reverse();
+        show("Benchmark event page", { ...page, events: filtered2, page_event_count: events.length, filtered_event_count: filtered2.length, filters_apply_to: "this event page; use next_after to read the next page" });
+        return true;
+      }
+      if (action !== "list") throw Error("Use /benchmarks list, show or events");
+      validate(a, 0, 0, ["task", "benchmark", "status", "limit", "offset"]);
+      const rows = await client.request("/v1/experiments");
+      const selectedTask2 = a.options.task ?? context.task;
+      const normalize = (t) => String(t ?? "").trim().toLowerCase().replace(/[\s-]+/g, "_");
+      const filtered = rows.filter((row) => {
+        const cfg = row.eval_config;
+        return cfg?.kind === "ptb_benchmark_run" && (!selectedTask2 || normalize(row.task) === normalize(selectedTask2)) && (!a.options.benchmark || cfg.benchmark === a.options.benchmark) && (!a.options.status || currentBenchmarkStatus(row) === a.options.status);
+      });
+      const limit = Number(a.options.limit ?? 25), offset2 = Number(a.options.offset ?? 0);
+      if (!Number.isInteger(limit) || limit < 1 || limit > 200 || !Number.isInteger(offset2) || offset2 < 0) throw Error("limit must be 1\u2013200; offset must be nonnegative");
+      show("Benchmark runs", { items: filtered.slice(offset2, offset2 + limit), total: filtered.length, limit, offset: offset2, next_offset: offset2 + limit < filtered.length ? offset2 + limit : null, pagination: "client-side; backend experiment list is not paginated" });
+      return true;
+    }
+    if (family === "uploads" && ["send", "retry"].includes(action)) {
+      validate(a, 1, 1, action === "send" ? ["receipt"] : []);
+      if (action === "send") required(a, "receipt");
+      if (confirmation(context, a, `Upload ${action}`, { file: v[0], receipt: a.options.receipt })) await uploadFile(action, v[0], a.options.receipt, client, show, context.signal);
+      return true;
+    }
+    if (family === "artifacts" && ["download", "download-record"].includes(action)) {
+      validate(a, action === "download" ? 2 : 1, action === "download" ? 2 : 1, action === "download" ? ["output", "format"] : ["output"]);
+      required(a, "output");
+      const format = a.options.format ?? "resume";
+      if (!["resume", "adapter"].includes(format)) throw Error("format must be resume or adapter");
+      if (confirmation(context, a, "Download artifact", { source: v, output: a.options.output, format })) {
+        const path = action === "download" ? "/v1/modal-artifacts/download-url" : `/v1/artifacts/${enc(v[0])}/access-url`;
+        const body = action === "download" ? { volume: v[0], path: v[1], format } : { expires_in: 300 };
+        await downloadArtifact(client, path, body, a.options.output, show, context.signal);
+      }
+      return true;
+    }
+    if (family === "serving" && action === "sample") {
+      validate(a, 1, 1, ["task", "max-tokens", "temperature", "conversation"]);
+      const model = task(a, context);
+      const maxTokens = Number(a.options["max-tokens"] ?? 256), temperature = Number(a.options.temperature ?? 0.7);
+      if (!Number.isInteger(maxTokens) || maxTokens < 1 || maxTokens > 8192 || !Number.isFinite(temperature) || temperature < 0 || temperature > 2) throw Error("max-tokens must be 1\u20138192; temperature must be 0\u20132");
+      if (!confirmation(context, a, "Sample model (inference spend)", { task: model, prompt: v[0], max_tokens: maxTokens, temperature, conversation: a.options.conversation })) return true;
+      await sampleModel(context, model, v[0], maxTokens, temperature, a.options.conversation, show);
+      return true;
+    }
+    let op;
+    const read2 = (path, min = 0, max = min, opts = []) => {
+      validate(a, min, max, opts);
+      op = { path };
+    };
+    const write = (path, method, body, min, max = min, opts = []) => {
+      validate(a, min, max, opts);
+      op = { path, method, body };
+    };
+    if (family === "pipelines") {
+      if (action === "list") read2("/v1/pipelines");
+      if (action === "show" || action === "status") read2(`/v1/pipelines/${enc(v[0] ?? "")}${action === "status" ? "/status" : ""}`, 1);
+      if (action === "task") {
+        validate(a, 0, 1);
+        const selected = v[0] ?? context.task;
+        if (!selected) throw Error("Select a task or provide TASK");
+        op = { path: `/v1/tasks/${enc(selected)}/pipeline` };
+      }
+    } else if (family === "runs") {
+      if (action === "list") read2(query("/v1/modal-runs", a, ["app-name", "limit"]), 0, 0, ["app-name", "limit"]);
+      if (action === "show") read2(query(`/v1/modal-runs/${enc(v[0] ?? "")}`, a, ["logs"]), 1, 1, ["logs"]);
+      if (action === "claims") read2("/v1/modal-run-claims");
+      if (action === "sync") write("/v1/modal-runs/sync", "POST", void 0, 0);
+      if (action === "explain") write(query(`/v1/modal-runs/${enc(v[0] ?? "")}/explain`, a, ["regenerate"]), "POST", void 0, 1, 1, ["regenerate"]);
+    } else if (family === "sources") {
+      if (action === "list") read2("/v1/pipeline-data-sources");
+      if (action === "objects") {
+        required(a, "limit");
+        read2(query(`/v1/pipeline-data-sources/${enc(v[0] ?? "")}/objects`, a, ["limit", "prefix"]), 1, 1, ["limit", "prefix"]);
+      }
+      if (action === "check") write(`/v1/pipeline-data-sources/${enc(v[0] ?? "")}/check`, "POST", void 0, 1);
+      if (action === "disconnect") write(`/v1/pipeline-data-sources/${enc(v[0] ?? "")}`, "DELETE", void 0, 1);
+      if (action === "connect") {
+        validate(a, 1, 1, ["config"]);
+        const config = required(a, "config");
+        if (!confirmation(context, a, "Connect data source", { alias: v[0], config })) return true;
+        let body;
+        try {
+          body = JSON.parse(await readFile4(config, "utf8"));
+        } catch {
+          throw Error("Source config must be a readable JSON object");
+        }
+        if (!body || typeof body !== "object" || Array.isArray(body)) throw Error("Source config must be a JSON object");
+        if (body.credentials && typeof body.credentials === "object") {
+          for (const value of Object.values(body.credentials)) if (typeof value === "string" && value) sensitiveValues.push(value);
+        }
+        if (typeof body.credential_ref === "string" && body.credential_ref) sensitiveValues.push(body.credential_ref);
+        op = { path: `/v1/pipeline-data-sources/${enc(v[0])}`, method: "PUT", body };
+      }
+    } else if (family === "datasets" || family === "models") {
+      if (action === "list") read2(`/v1/${family}`, 0, 0, family === "datasets" ? ["task"] : []);
+    } else if (family === "evals") {
+      const path = `/v1/evaluation-runs/${enc(v[0] ?? "")}`;
+      if (action === "list") read2(query("/v1/evaluation-runs", a, ["limit", "after"]), 0, 0, ["limit", "after", "pipeline-id"]);
+      if (action === "show" || action === "report") read2(path + (action === "report" ? "/report" : ""), 1);
+      if (action === "results") {
+        required(a, "model-run-id");
+        read2(query(`${path}/task-results`, a, ["model-run-id", "after", "limit"]), 1, 1, ["model-run-id", "after", "limit"]);
+      }
+    } else if (family === "experiments") {
+      if (action === "list") read2("/v1/experiments", 0, 0, ["task"]);
+      if (["show", "comparison", "estimate"].includes(action)) read2(`/v1/experiments/${enc(v[0] ?? "")}${action === "show" ? "" : "/" + action}`, 1);
+    } else if (family === "monitoring") {
+      if (["summary", "series", "drift"].includes(action)) read2(query(`/v1/models/${enc(v[0] ?? "")}/monitoring${action === "summary" ? "" : action === "series" ? "/timeseries" : "/drift"}`, a, ["days", "minimum-reviewed"]), 1, 1, action === "drift" ? ["days", "minimum-reviewed"] : ["days"]);
+      if (action === "compare") read2(query("/v1/monitoring/compare", a, ["days"], { baseline_model_id: v[0] ?? "", candidate_model_id: v[1] ?? "" }), 2, 2, ["days"]);
+    } else if (family === "interactions") {
+      if (action === "list") read2(query("/v1/interactions", a, ["limit", "offset", "feedback-status", "model-id", "task"], context.task ? { task: context.task } : {}), 0, 0, ["task", "model-id", "feedback-status", "limit", "offset"]);
+      if (action === "show") read2(`/v1/interactions/${enc(v[0] ?? "")}`, 1);
+    } else if (family === "uploads") {
+      if (action === "list") read2("/v1/uploads");
+      if (action === "status" || action === "cancel") {
+        required(a, "key");
+        validate(a, 1, 1, ["key"]);
+        op = { path: query(`/v1/uploads/${enc(v[0])}/${action === "status" ? "status" : "abort"}`, a, ["key"]), method: action === "cancel" ? "POST" : void 0 };
+      }
+    } else if (family === "artifacts") {
+      if (action === "list") read2(query("/v1/modal-artifacts", a, ["kind", "limit"]), 0, 0, ["kind", "limit", "has-weights"]);
+      if (action === "records") read2(query("/v1/artifacts", a, ["kind"]), 0, 0, ["kind"]);
+      if (action === "show") read2(`/v1/artifacts/${enc(v[0] ?? "")}`, 1);
+    } else if (family === "serving") {
+      if (action === "list") read2("/v1/deployments");
+      if (action === "pools") read2("/v1/serving/pools");
+      if (action === "show") read2(`/v1/deployments/${enc(v[0] ?? "")}`, 1);
+      if (action === "promote") write(`/v1/experiments/${enc(v[0] ?? "")}/promote`, "POST", { candidate_id: v[1], alias: a.options.alias ?? "production" }, 2, 2, ["alias"]);
+    }
+    if (!op) throw Error(`Unknown ${family} action '${action}'; see /dashboard help`);
+    if (op.method && !confirmation(context, a, `${family} ${action}`, { method: op.method, path: op.path, ...family === "sources" && action === "connect" ? { config: a.options.config } : { body: op.body, ...a.options.output ? { output: a.options.output } : {} } })) return true;
+    const init = op.method ? { method: op.method, ...op.body === void 0 ? {} : { body: JSON.stringify(op.body) } } : void 0;
+    let result = await client.request(op.path, init);
+    if (family === "evals" && action === "list" && a.options["pipeline-id"]) {
+      const page = result;
+      if (Array.isArray(page.items)) result = { ...page, items: page.items.filter((row) => row.pipeline_id === a.options["pipeline-id"]), filters_apply_to: "this page; use next_cursor for the next page" };
+    }
+    if (family === "artifacts" && action === "list" && a.options["has-weights"]) {
+      if (!["true", "false"].includes(a.options["has-weights"])) throw Error("has-weights must be true or false");
+      const page = result;
+      if (Array.isArray(page.artifacts)) result = { ...page, artifacts: page.artifacts.filter((row) => row.has_weights === (a.options["has-weights"] === "true")) };
+    }
+    const selectedTask = a.options.task ?? context.task;
+    if (selectedTask && action === "list" && ["datasets", "experiments"].includes(family) && Array.isArray(result)) result = result.filter((row) => row?.task === selectedTask);
+    show(`${family} ${action}`, result);
+  } catch (error) {
+    show("Dashboard command failed", error instanceof Error ? error.message : String(error));
+  }
+  return true;
+}
+
+// src/hosted/entry.ts
+var DEFAULT_DASHBOARD_URL = "https://manifold.ashr.io";
+var accountHelp = [
+  "/account            who this terminal is signed in as",
+  "/org                open organization settings in the dashboard",
+  "/login              sign in again, e.g. to switch organization",
+  "/logout             sign this terminal out"
+];
+function openBrowser(url) {
+  const program2 = process.platform === "darwin" ? "open" : process.platform === "win32" ? "explorer.exe" : "xdg-open";
+  const child = spawn(program2, [url], { stdio: "ignore", detached: true });
+  child.unref();
+  return new Promise((resolve10, reject) => {
+    child.once("error", reject);
+    child.once("exit", (code) => code === 0 ? resolve10() : reject(Error("Browser could not open")));
+  });
+}
+var color = (on) => {
+  const wrap = (code) => (text) => on ? `\x1B[${code}m${text}\x1B[0m` : text;
+  return { bold: wrap("1"), dim: wrap("2"), accent: wrap("38;2;134;122;254"), green: wrap("32"), red: wrap("31") };
+};
+async function signIn(apiUrl, dashboardUrl, credentials, options, reason) {
+  const write = options.write ?? ((text) => process.stdout.write(text));
+  const tty = options.interactive ?? !!process.stdout.isTTY;
+  const c = color(tty);
+  const abort = new AbortController();
+  const onInterrupt = () => abort.abort();
+  process.once("SIGINT", onInterrupt);
+  const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+  let spinner;
+  try {
+    write(`
+  ${c.bold("ashr")} ${c.dim("\xB7 Manifold")}
+
+`);
+    if (reason) write(`  ${reason}
+
+`);
+    const login2 = await (options.startLogin ?? startTerminalLogin)({
+      dashboardUrl,
+      device: hostname().replace(/\.local$/, ""),
+      signal: abort.signal,
+      onUrl: (url) => {
+        write(`  Sign in to continue. Opening your browser\u2026
+  ${c.dim("If it doesn't open, visit:")}
+  ${c.accent(url)}
+
+`);
+        void (options.openBrowser ?? openBrowser)(url).catch(() => {
+        });
+        if (tty) {
+          let frame = 0;
+          const line2 = () => `\r  ${c.accent(frames[frame++ % frames.length])} Waiting for you to approve in the browser ${c.dim("\xB7 Ctrl+C to cancel")}`;
+          write(line2());
+          spinner = setInterval(() => write(line2()), 80);
+        } else write("  Waiting for you to approve in the browser\u2026\n");
+      }
+    });
+    if (spinner) {
+      clearInterval(spinner);
+      spinner = void 0;
+      write("\r\x1B[2K");
+    }
+    await (options.validate ?? validateKey)(apiUrl, login2.key, options.fetch);
+    const saved = { apiUrl, key: login2.key, profile: credentials.manifold?.profile ?? "default", email: login2.email, organization: login2.organization };
+    (options.saveCredentials ?? writeCredentials)({ ...credentials, manifold: saved });
+    const who = [login2.email, login2.organization].filter(Boolean).map((v) => terminalText(v)).join(c.dim(" \xB7 "));
+    write(`  ${c.green("\u2713")} Signed in${who ? ` as ${c.bold(who)}` : ""}
+
+`);
+    return saved;
+  } catch (error) {
+    if (spinner) {
+      clearInterval(spinner);
+      write("\r\x1B[2K");
+    }
+    if (abort.signal.aborted) {
+      write(`  Sign-in cancelled.
+`);
+      return void 0;
+    }
+    write(`  ${c.red("\u2717")} ${terminalText(error.message)}
+`);
+    throw error;
+  } finally {
+    process.removeListener("SIGINT", onInterrupt);
+  }
+}
+async function runLogin(args, credentials, options = {}) {
+  const env = options.env ?? process.env;
+  const apiUrl = args.apiUrl ?? env.MANIFOLD_API_URL ?? DEFAULT_API_URL;
+  const dashboardUrl = args.dashboardUrl ?? env.MANIFOLD_DASHBOARD_URL ?? DEFAULT_DASHBOARD_URL;
+  return await signIn(apiUrl, dashboardUrl, credentials, options) ? 0 : 130;
+}
+async function runHostedEntry(args, credentials, options = {}) {
+  const env = options.env ?? process.env;
+  const write = options.write ?? ((text) => process.stdout.write(text));
+  const apiUrl = args.apiUrl ?? env.MANIFOLD_API_URL ?? credentials.manifold?.apiUrl ?? DEFAULT_API_URL;
+  const dashboardUrl = args.dashboardUrl ?? env.MANIFOLD_DASHBOARD_URL ?? DEFAULT_DASHBOARD_URL;
+  const explicit = args.key ?? env.MANIFOLD_API_KEY;
+  const save2 = options.saveCredentials ?? writeCredentials;
+  let saved = !explicit && credentials.manifold && credentials.manifold.apiUrl === apiUrl ? credentials.manifold : void 0;
+  let token = explicit;
+  if (!token && args.service) throw Error("No Manifold service key. Set MANIFOLD_API_KEY or run ashr login --key <key>.");
+  if (!token && saved) {
+    try {
+      await (options.validate ?? validateKey)(apiUrl, saved.key, options.fetch);
+      token = saved.key;
+    } catch (error) {
+      if (!(error instanceof KeyRejectedError && error.status === 401)) throw error;
+      const { manifold: _revoked, ...rest } = credentials;
+      credentials = rest;
+      save2(credentials);
+      saved = await signIn(apiUrl, dashboardUrl, credentials, options, "This terminal's sign-in was revoked. Sign in again.");
+      if (!saved) return 130;
+      credentials = { ...credentials, manifold: saved };
+      token = saved.key;
+    }
+  }
+  if (!token) {
+    saved = await signIn(apiUrl, dashboardUrl, credentials, options);
+    if (!saved) return 130;
+    credentials = { ...credentials, manifold: saved };
+    token = saved.key;
+  }
+  const current = { token };
+  const client = new ManifoldClient({ apiUrl, getToken: () => Promise.resolve(current.token), fetch: options.fetch });
+  let task2 = args.task, chat = args.chat;
+  for (; ; ) {
+    let handle;
+    let next;
+    const result = await (options.run ?? runHostedApp)({
+      client,
+      terminal: options.terminal ?? new ProcessTerminal(),
+      task: task2,
+      chat,
+      env,
+      onReady: (value) => {
+        handle = value;
+      },
+      runDashboardCommand: async (input, context) => {
+        if (input === "/help") {
+          context.show("Dashboard commands", dashboardHelpLines.join("\n"));
+          context.show("Account", accountHelp.join("\n"));
+          return false;
+        }
+        if (input === "/login" || input === "/logout") {
+          if (explicit) throw Error("This session uses MANIFOLD_API_KEY or --key; unset it to sign in through the browser.");
+          next = input === "/login" ? "login" : "logout";
+          handle?.quit();
+          return true;
+        }
+        if (input === "/account") {
+          context.show("Account", saved ? [`Signed in as ${saved.email ?? "unknown account"}`, `Organization: ${saved.organization ?? "\u2014"}`, `API: ${apiUrl}`, `Key: ${saved.key.slice(0, 12)}\u2026`].join("\n") : `Using a service key (${current.token.slice(0, 12)}\u2026) against ${apiUrl}.`);
+          return true;
+        }
+        if (input === "/account settings" || /^\/org(?:\s|$)/.test(input)) {
+          const url = new URL("/?view=organization", dashboardUrl).toString();
+          void (options.openBrowser ?? openBrowser)(url).catch(() => {
+          });
+          context.show("Opened in your browser", url);
+          return true;
+        }
+        return runDashboardCommand(input, context);
+      }
+    });
+    if (!next) return result;
+    const { manifold: _signedOut, ...rest } = credentials;
+    credentials = rest;
+    save2(credentials);
+    if (next === "logout") {
+      write("Signed out. The terminal key stays listed under API keys in Manifold until an admin revokes it.\n");
+      return 0;
+    }
+    saved = await signIn(apiUrl, dashboardUrl, credentials, options);
+    if (!saved) return 130;
+    credentials = { ...credentials, manifold: saved };
+    current.token = saved.key;
+    task2 = void 0;
+    chat = void 0;
+  }
+}
+
+// src/main.ts
+function findRepoRoot(cwd) {
+  let dir = resolve9(cwd);
+  for (; ; ) {
+    if (existsSync7(join9(dir, ".git"))) return dir;
+    const up = dirname5(dir);
+    if (up === dir) return resolve9(cwd);
+    dir = up;
+  }
+}
+function hiddenPrompt(question) {
+  return new Promise((done, fail) => {
+    const stdin = process.stdin;
+    if (!stdin.isTTY) {
+      fail(new Error("No terminal to read the key from. Pass it with --key."));
+      return;
+    }
+    process.stdout.write(question);
+    let value = "";
+    stdin.setRawMode(true);
+    stdin.resume();
+    const onData = (buf) => {
+      for (const ch of buf.toString("utf8")) {
+        if (ch === "\r" || ch === "\n") {
+          stdin.setRawMode(false);
+          stdin.pause();
+          stdin.off("data", onData);
+          process.stdout.write("\n");
+          done(value.trim());
+          return;
+        }
+        if (ch === "") {
+          stdin.setRawMode(false);
+          process.stdout.write("\n");
+          process.exit(130);
+        }
+        if (ch === "\x7F") value = value.slice(0, -1);
+        else value += ch;
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+async function login(args) {
+  const creds = readCredentials();
+  if (args.provider) {
+    const names = PROVIDER_KEYS[args.provider];
+    if (!names) throw new UsageError(`Unknown provider "${args.provider}". Known: ${Object.keys(PROVIDER_KEYS).join(", ")}.`);
+    const key3 = args.key ?? await hiddenPrompt(`${args.provider} API key: `);
+    if (!key3) throw new Error("No key entered.");
+    creds.providers[args.provider] = key3;
+    writeCredentials(creds);
+    process.stdout.write(`Saved your ${args.provider} key. ashr uses it when ${names[0]} is not set in your shell.
+`);
+    return 0;
+  }
+  if (!args.key && !args.service) return runLogin(args, creds);
+  const apiUrl = args.apiUrl ?? DEFAULT_API_URL;
+  const key2 = args.key ?? await hiddenPrompt("Manifold API key (ask_\u2026): ");
+  if (!key2) throw new Error("No key entered.");
+  await validateKey(apiUrl, key2);
+  writeCredentials({ ...creds, manifold: { apiUrl, key: key2, profile: creds.manifold?.profile ?? "default" } });
+  process.stdout.write(`Signed in to ${apiUrl}.
+`);
+  return 0;
+}
+function logout(args) {
+  const creds = readCredentials();
+  if (args.provider) {
+    delete creds.providers[args.provider];
+    process.stdout.write(`Removed the stored ${args.provider} key.
+`);
+  } else {
+    delete creds.manifold;
+    process.stdout.write("Signed out of Manifold.\n");
+  }
+  writeCredentials(creds);
+  return 0;
+}
+async function main(argv) {
+  const args = parseArgs(argv);
+  if (args.command === "help") {
+    process.stdout.write(`ashr ${package_default.version} \u2014 the Ashr terminal agent
+
+${USAGE}
+`);
+    return 0;
+  }
+  if (args.command === "version") {
+    process.stdout.write(`${package_default.version}
+`);
+    return 0;
+  }
+  if (args.command === "login") return login(args);
+  if (args.command === "logout") return logout(args);
+  const creds = readCredentials();
+  if (args.runtime === "hosted") return runHostedEntry(args, creds);
+  applyProviderKeys(creds, process.env);
+  const repoRoot = findRepoRoot(process.cwd());
+  const org = creds.manifold?.profile ?? "default";
+  if (args.print !== void 0) {
+    return runPrint({ repoRoot, prompt: args.print, mode: args.mode, allow: args.allow, output: args.output, env: process.env, model: args.model, org });
+  }
+  return runApp({ repoRoot, terminal: new ProcessTerminal2(), env: process.env, org, model: args.model, continueLatest: args.continue, resumePicker: args.resume });
+}
+main(process.argv.slice(2)).then(
+  (code) => process.exit(code),
+  (err) => {
+    process.stderr.write(`${err instanceof Error ? err.message : String(err)}
+`);
+    process.exit(err instanceof UsageError ? 2 : 1);
+  }
+);
+//# sourceMappingURL=ashr.js.map