autopilot-ai 1.9.0 → 1.10.1

package/dist/index.js

@@ -93,8 +93,8 @@ async function flushAndCloseForTesting() {
   const s = currentStream;
   currentStream = null;
   currentDate = null;
-  await new Promise((resolve14) => {
-    s.end(() => resolve14());
+  await new Promise((resolve15) => {
+    s.end(() => resolve15());
   });
 }
 function isLogSinkEnabled() {
@@ -1333,10 +1333,10 @@ async function* readSSE(stream, signal, idleTimeoutMs, postFirstByteIdleTimeoutM
       gotFirstByte = true;
       buffer += decoder.decode(value, { stream: true });
       buffer = buffer.replace(/\r\n/g, "\n");
-      let sep5;
-      while ((sep5 = buffer.indexOf("\n\n")) !== -1) {
-        const event = buffer.slice(0, sep5);
-        buffer = buffer.slice(sep5 + 2);
+      let sep7;
+      while ((sep7 = buffer.indexOf("\n\n")) !== -1) {
+        const event = buffer.slice(0, sep7);
+        buffer = buffer.slice(sep7 + 2);
         const data = extractData(event);
         if (data !== null) yield data;
       }
@@ -2668,11 +2668,11 @@ function extractApiError(parsed, rawText) {
   return null;
 }
 function sleep(ms, signal) {
-  return new Promise((resolve14, reject) => {
+  return new Promise((resolve15, reject) => {
     if (signal?.aborted) return reject(new DOMException("aborted", "AbortError"));
     const t = setTimeout(() => {
       signal?.removeEventListener("abort", onAbort);
-      resolve14();
+      resolve15();
     }, ms);
     const onAbort = () => {
       clearTimeout(t);
@@ -3419,9 +3419,9 @@ var require_node_gyp_build = __commonJS({
         var debug = getFirst(path.join(dir, "build/Debug"), matchBuild);
         if (debug) return debug;
       }
-      var prebuild = resolve14(dir);
+      var prebuild = resolve15(dir);
       if (prebuild) return prebuild;
-      var nearby = resolve14(path.dirname(process.execPath));
+      var nearby = resolve15(path.dirname(process.execPath));
       if (nearby) return nearby;
       var target = [
         "platform=" + platform8,
@@ -3437,7 +3437,7 @@ var require_node_gyp_build = __commonJS({
         // eslint-disable-line
       ].filter(Boolean).join(" ");
       throw new Error("No native build was found for " + target + "\n    loaded from: " + dir + "\n");
-      function resolve14(dir2) {
+      function resolve15(dir2) {
         var tuples = readdirSync2(path.join(dir2, "prebuilds")).map(parseTuple);
         var tuple = tuples.filter(matchTuple(platform8, arch)).sort(compareTuples)[0];
         if (!tuple) return;
@@ -3858,7 +3858,7 @@ function truncateForEmbedding(text) {
   return text.slice(0, MAX_EMBED_CHARS);
 }
 async function sleep2(ms) {
-  return new Promise((resolve14) => setTimeout(resolve14, ms));
+  return new Promise((resolve15) => setTimeout(resolve15, ms));
 }
 async function fetchWithRetry(url, init, retries = 3) {
   let lastError;
@@ -3882,11 +3882,11 @@ async function fetchWithRetry(url, init, retries = 3) {
   }
   throw lastError ?? new Error("embeddings request failed after retries");
 }
-function parseOpenAiEmbeddingResponse(json2) {
-  if (!json2 || typeof json2 !== "object") {
+function parseOpenAiEmbeddingResponse(json3) {
+  if (!json3 || typeof json3 !== "object") {
     throw new Error("embeddings response was not an object");
   }
-  const data = json2.data;
+  const data = json3.data;
   if (!Array.isArray(data)) {
     throw new Error("embeddings response contained no data array");
   }
@@ -3939,8 +3939,8 @@ async function fetchEmbeddings(opts2) {
     headers,
     body: JSON.stringify({ model, input: texts })
   });
-  const json2 = await res.json();
-  return parseOpenAiEmbeddingResponse(json2);
+  const json3 = await res.json();
+  return parseOpenAiEmbeddingResponse(json3);
 }
 function cosineSimilarity(a, b) {
   if (a.length !== b.length) {
@@ -6576,15 +6576,15 @@ function makeErrorOutput(message2) {
   return { content: message2, rawBytes: bytes, reducedBytes: bytes };
 }
 async function execOnce(command, cwd) {
-  return new Promise((resolve14) => {
+  return new Promise((resolve15) => {
     const child = spawn("bash", ["-lc", command], { cwd });
     let out = "";
     child.stdout.on("data", (d) => {
       out += d.toString("utf8");
     });
     child.on("close", (code) => {
-      if (code !== 0) return resolve14(void 0);
-      resolve14(out.trim() || void 0);
+      if (code !== 0) return resolve15(void 0);
+      resolve15(out.trim() || void 0);
     });
   });
 }
@@ -6722,7 +6722,7 @@ async function runBash(args, ctx) {
   if (pushGuard) return pushGuard;
   const { shell, args: shellArgs, isPosix } = getShellCommand(ctx.shell);
   const command = isPosix ? injectCoauthor(args.command, ctx.coauthor) : args.command;
-  return new Promise((resolve14, reject) => {
+  return new Promise((resolve15, reject) => {
     logger.debug("bash:spawn", { command: args.command.slice(0, 200), cwd: ctx.cwd, shell });
     const child = spawn(shell, [...shellArgs, command], {
       cwd: ctx.cwd,
@@ -6786,7 +6786,7 @@ ${stderr}`
         if (hint) parts.push(hint);
       }
       const raw = parts.join("\n");
-      resolve14({
+      resolve15({
         content: raw,
         rawBytes: Buffer.byteLength(raw, "utf8"),
         reducedBytes: Buffer.byteLength(raw, "utf8")
@@ -8115,7 +8115,7 @@ import { tmpdir as tmpdir2 } from "os";
 import { join as join17, dirname as dirname8 } from "path";
 async function autoScroll(page) {
   await page.evaluate(async () => {
-    await new Promise((resolve14) => {
+    await new Promise((resolve15) => {
       let totalHeight = 0;
       const distance = 300;
       const timer3 = setInterval(() => {
@@ -8124,12 +8124,12 @@ async function autoScroll(page) {
         totalHeight += distance;
         if (totalHeight >= scrollHeight) {
           clearInterval(timer3);
-          resolve14();
+          resolve15();
         }
       }, 100);
       setTimeout(() => {
         clearInterval(timer3);
-        resolve14();
+        resolve15();
       }, 1e4);
     });
   });
@@ -8538,9 +8538,9 @@ ${options.context}` : ""
     });
     const stats = await execute(command, ["stats", cellId], { cwd, timeoutMs: 3e4 }).catch(() => void 0);
     const metrics = stats?.code === 0 ? parseHotcellStats(stats.stdout) : {};
-    const json2 = parsePrintOutput(execution.stdout);
-    const summary = typeof json2?.text === "string" ? json2.text.trim() : execution.stdout.trim();
-    const tokensUsed = typeof json2?.usage?.totalTokens === "number" ? json2.usage.totalTokens : 0;
+    const json3 = parsePrintOutput(execution.stdout);
+    const summary = typeof json3?.text === "string" ? json3.text.trim() : execution.stdout.trim();
+    const tokensUsed = typeof json3?.usage?.totalTokens === "number" ? json3.usage.totalTokens : 0;
     const budgetExhausted = execution.code === 42;
     const diagnostic = `${execution.stdout}
 ${execution.stderr}`.toLowerCase();
@@ -9684,8 +9684,8 @@ function waitForProcessStartTime(pid, jobId, exitPath) {
 function readProcessStartTime(pid) {
   if (process.platform === "linux") {
     try {
-      const stat9 = readFileSync3(`/proc/${pid}/stat`, "utf8");
-      const fieldsAfterCommand = stat9.slice(stat9.lastIndexOf(")") + 1).trim().split(/\s+/);
+      const stat10 = readFileSync3(`/proc/${pid}/stat`, "utf8");
+      const fieldsAfterCommand = stat10.slice(stat10.lastIndexOf(")") + 1).trim().split(/\s+/);
       return fieldsAfterCommand[19] ? `linux:${fieldsAfterCommand[19]}` : null;
     } catch {
       return null;
@@ -11775,11 +11775,11 @@ async function runHook(hook, payload, signal) {
   const start = Date.now();
   const timeoutMs = hook.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const env2 = { ...process.env, ...buildHookEnv(payload) };
-  const json2 = JSON.stringify(payload);
+  const json3 = JSON.stringify(payload);
   const id = hook.id ?? "anonymous";
   let result2;
   try {
-    result2 = await spawnImpl(hook.command, json2, env2, payload.cwd, timeoutMs, signal);
+    result2 = await spawnImpl(hook.command, json3, env2, payload.cwd, timeoutMs, signal);
   } catch (e) {
     return {
       id,
@@ -11850,7 +11850,7 @@ var init_runner = __esm({
     init_logger();
     DEFAULT_TIMEOUT_MS = 3e4;
     STREAM_CAP_BYTES = 4 * 1024;
-    defaultSpawn = (command, payloadJson, env2, cwd, timeoutMs, signal) => new Promise((resolve14) => {
+    defaultSpawn = (command, payloadJson, env2, cwd, timeoutMs, signal) => new Promise((resolve15) => {
       const child = spawn4(command, {
         shell: true,
         cwd,
@@ -11865,7 +11865,7 @@ var init_runner = __esm({
         settled = true;
         clearTimeout(timer3);
         signal?.removeEventListener("abort", onAbort);
-        resolve14({ exitCode, stdout, stderr, timedOut });
+        resolve15({ exitCode, stdout, stderr, timedOut });
       };
       const onAbort = () => {
         child.kill("SIGTERM");
@@ -12640,13 +12640,454 @@ var init_cli = __esm({
   }
 });
 
+// src/server/aster-workspaces.ts
+var aster_workspaces_exports = {};
+__export(aster_workspaces_exports, {
+  AsterConfigError: () => AsterConfigError,
+  findAsterWorkspace: () => findAsterWorkspace,
+  loadAsterServerConfig: () => loadAsterServerConfig
+});
+import { readFile as readFile17, realpath as realpath3, stat as stat6 } from "fs/promises";
+import { isAbsolute as isAbsolute3, relative as relative5, sep as sep3 } from "path";
+async function loadAsterServerConfig(configPath3 = process.env.AUTOPILOT_ASTER_CONFIG || "/etc/autopilot/aster.json") {
+  let raw;
+  try {
+    raw = JSON.parse(await readFile17(configPath3, "utf8"));
+  } catch {
+    throw new AsterConfigError();
+  }
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new AsterConfigError();
+  const record = raw;
+  if (!Array.isArray(record.models) || record.models.length === 0 || record.models.length > 100) {
+    throw new AsterConfigError();
+  }
+  const models = [...new Set(record.models)];
+  if (models.some((model) => typeof model !== "string" || !model.trim() || model.length > 200)) {
+    throw new AsterConfigError();
+  }
+  if (!Array.isArray(record.workspaces) || record.workspaces.length === 0 || record.workspaces.length > 100) {
+    throw new AsterConfigError();
+  }
+  const approvalTtlMs = record.approvalTtlMs ?? 5 * 60 * 1e3;
+  if (!Number.isInteger(approvalTtlMs) || approvalTtlMs < 1e3 || approvalTtlMs > 60 * 60 * 1e3) {
+    throw new AsterConfigError();
+  }
+  const ids = /* @__PURE__ */ new Set();
+  const roots = [];
+  const workspaces = [];
+  for (const entry of record.workspaces) {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) throw new AsterConfigError();
+    const workspace = entry;
+    if (typeof workspace.id !== "string" || !/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/.test(workspace.id) || ids.has(workspace.id)) {
+      throw new AsterConfigError();
+    }
+    if (typeof workspace.displayName !== "string" || !workspace.displayName.trim() || workspace.displayName.length > 100) {
+      throw new AsterConfigError();
+    }
+    if (typeof workspace.rootPath !== "string" || !isAbsolute3(workspace.rootPath)) throw new AsterConfigError();
+    let rootPath;
+    try {
+      rootPath = await realpath3(workspace.rootPath);
+      if (!(await stat6(rootPath)).isDirectory()) throw new Error("not a directory");
+    } catch {
+      throw new AsterConfigError();
+    }
+    if (roots.some((root) => isWithin(root, rootPath) || isWithin(rootPath, root))) {
+      throw new AsterConfigError();
+    }
+    ids.add(workspace.id);
+    roots.push(rootPath);
+    workspaces.push({ id: workspace.id, displayName: workspace.displayName.trim(), rootPath });
+  }
+  return { models, workspaces, approvalTtlMs };
+}
+function findAsterWorkspace(config2, workspaceId) {
+  return config2.workspaces.find((workspace) => workspace.id === workspaceId);
+}
+function isWithin(parent, candidate) {
+  const rel = relative5(parent, candidate);
+  return rel === "" || rel !== ".." && !rel.startsWith(`..${sep3}`) && !isAbsolute3(rel);
+}
+var AsterConfigError;
+var init_aster_workspaces = __esm({
+  "src/server/aster-workspaces.ts"() {
+    "use strict";
+    AsterConfigError = class extends Error {
+      constructor(message2 = "Aster server configuration is unavailable or invalid") {
+        super(message2);
+        this.name = "AsterConfigError";
+      }
+    };
+  }
+});
+
+// src/server/aster-store.ts
+var aster_store_exports = {};
+__export(aster_store_exports, {
+  AsterStore: () => AsterStore
+});
+import Database3 from "better-sqlite3";
+import { createHash as createHash3, randomBytes as randomBytes2, randomUUID as randomUUID5 } from "crypto";
+import { chmodSync as chmodSync2, mkdirSync as mkdirSync6 } from "fs";
+import { homedir as homedir18 } from "os";
+import { dirname as dirname12, join as join25 } from "path";
+function defaultAsterDbPath() {
+  const root = process.env.XDG_STATE_HOME || join25(homedir18(), ".local", "state");
+  return process.env.AUTOPILOT_ASTER_DB || join25(root, "autopilot", "aster.db");
+}
+function hashToken(token) {
+  return createHash3("sha256").update(token).digest("hex");
+}
+function rowToConversation(row) {
+  return {
+    id: row.id,
+    workspaceId: row.workspace_id,
+    model: row.model,
+    sessionId: row.session_id,
+    worktreePath: row.worktree_path,
+    cwd: row.cwd,
+    branch: row.branch,
+    status: row.status,
+    activeRunId: row.active_run_id,
+    lastEventSequence: row.last_event_sequence,
+    oldestEventSequence: row.oldest_event_sequence,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function rowToApproval(row) {
+  return {
+    id: row.id,
+    conversationId: row.conversation_id,
+    runId: row.run_id,
+    toolName: row.tool_name,
+    explanation: row.explanation,
+    arguments: JSON.parse(row.arguments_json),
+    status: row.status,
+    expiresAt: row.expires_at,
+    decision: row.decision,
+    createdAt: row.created_at,
+    resolvedAt: row.resolved_at
+  };
+}
+var VALID_SCOPES, AsterStore;
+var init_aster_store = __esm({
+  "src/server/aster-store.ts"() {
+    "use strict";
+    VALID_SCOPES = /* @__PURE__ */ new Set([
+      "workspaces:read",
+      "models:read",
+      "conversations:read",
+      "conversations:write",
+      "approvals:resolve"
+    ]);
+    AsterStore = class {
+      db;
+      constructor(dbPath = defaultAsterDbPath()) {
+        mkdirSync6(dirname12(dbPath), { recursive: true, mode: 448 });
+        try {
+          chmodSync2(dirname12(dbPath), 448);
+        } catch {
+        }
+        this.db = new Database3(dbPath);
+        this.db.pragma("journal_mode = WAL");
+        this.db.pragma("foreign_keys = ON");
+        this.db.pragma("busy_timeout = 5000");
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS aster_credentials (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        token_hash TEXT NOT NULL UNIQUE,
+        workspace_ids_json TEXT NOT NULL,
+        scopes_json TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        expires_at INTEGER NOT NULL,
+        revoked_at INTEGER,
+        last_used_at INTEGER
+      );
+      CREATE TABLE IF NOT EXISTS aster_conversations (
+        id TEXT PRIMARY KEY,
+        workspace_id TEXT NOT NULL,
+        model TEXT NOT NULL,
+        session_id TEXT NOT NULL UNIQUE,
+        worktree_path TEXT NOT NULL,
+        cwd TEXT NOT NULL,
+        branch TEXT NOT NULL,
+        status TEXT NOT NULL,
+        active_run_id TEXT,
+        last_event_sequence INTEGER NOT NULL DEFAULT 0,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_aster_conversations_workspace ON aster_conversations(workspace_id, updated_at);
+      CREATE TABLE IF NOT EXISTS aster_events (
+        conversation_id TEXT NOT NULL REFERENCES aster_conversations(id) ON DELETE CASCADE,
+        sequence INTEGER NOT NULL,
+        run_id TEXT,
+        event_type TEXT NOT NULL,
+        data_json TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        PRIMARY KEY(conversation_id, sequence)
+      );
+      CREATE INDEX IF NOT EXISTS idx_aster_events_run ON aster_events(run_id, sequence);
+      CREATE TABLE IF NOT EXISTS aster_approvals (
+        id TEXT PRIMARY KEY,
+        conversation_id TEXT NOT NULL REFERENCES aster_conversations(id) ON DELETE CASCADE,
+        run_id TEXT NOT NULL,
+        tool_name TEXT NOT NULL,
+        explanation TEXT NOT NULL,
+        arguments_json TEXT NOT NULL,
+        status TEXT NOT NULL,
+        expires_at INTEGER NOT NULL,
+        decision TEXT,
+        created_at INTEGER NOT NULL,
+        resolved_at INTEGER
+      );
+      CREATE INDEX IF NOT EXISTS idx_aster_approvals_pending ON aster_approvals(conversation_id, status, expires_at);
+      CREATE TABLE IF NOT EXISTS aster_turn_idempotency (
+        conversation_id TEXT NOT NULL REFERENCES aster_conversations(id) ON DELETE CASCADE,
+        client_turn_id TEXT NOT NULL,
+        request_text TEXT NOT NULL,
+        accepted_text TEXT NOT NULL,
+        run_id TEXT NOT NULL UNIQUE,
+        response_status INTEGER NOT NULL,
+        response_json TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        PRIMARY KEY (conversation_id, client_turn_id)
+      );
+    `);
+        try {
+          chmodSync2(dbPath, 384);
+        } catch {
+        }
+      }
+      close() {
+        this.db.close();
+      }
+      createCredential(input) {
+        const name = input.name.trim();
+        if (!name || name.length > 100) throw new Error("credential name must be 1 to 100 characters");
+        const workspaceIds = [...new Set(input.workspaceIds)];
+        if (workspaceIds.length === 0 || workspaceIds.length > 100 || workspaceIds.some((id2) => !/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/.test(id2))) {
+          throw new Error("credential must be scoped to valid workspace IDs");
+        }
+        const scopes = [...new Set(input.scopes)];
+        if (scopes.length === 0 || scopes.some((scope) => !VALID_SCOPES.has(scope))) throw new Error("credential scopes are invalid");
+        if (!Number.isSafeInteger(input.expiresAt) || input.expiresAt <= Date.now()) throw new Error("credential expiry must be in the future");
+        const id = randomUUID5();
+        const token = `aster_${randomBytes2(32).toString("base64url")}`;
+        const now2 = Date.now();
+        this.db.prepare(`INSERT INTO aster_credentials
+      (id, name, token_hash, workspace_ids_json, scopes_json, created_at, expires_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?)`).run(id, name, hashToken(token), JSON.stringify(workspaceIds), JSON.stringify(scopes), now2, input.expiresAt);
+        return { id, name, workspaceIds, scopes, createdAt: now2, expiresAt: input.expiresAt, token };
+      }
+      authenticate(authorization, now2 = Date.now()) {
+        const match = authorization?.match(/^Bearer (aster_[A-Za-z0-9_-]{40,})$/);
+        if (!match) return void 0;
+        const row = this.db.prepare("SELECT * FROM aster_credentials WHERE token_hash = ?").get(hashToken(match[1]));
+        if (!row || row.revoked_at !== null || row.expires_at <= now2) return void 0;
+        this.db.prepare("UPDATE aster_credentials SET last_used_at = ? WHERE id = ?").run(now2, row.id);
+        return {
+          credentialId: row.id,
+          name: row.name,
+          workspaceIds: JSON.parse(row.workspace_ids_json),
+          scopes: JSON.parse(row.scopes_json),
+          expiresAt: row.expires_at
+        };
+      }
+      revokeCredential(id, now2 = Date.now()) {
+        const result2 = this.db.prepare("UPDATE aster_credentials SET revoked_at = COALESCE(revoked_at, ?) WHERE id = ?").run(now2, id);
+        return result2.changes > 0;
+      }
+      createConversation(input) {
+        const now2 = Date.now();
+        const create = this.db.transaction(() => {
+          this.db.prepare(`INSERT INTO aster_conversations
+        (id, workspace_id, model, session_id, worktree_path, cwd, branch, status, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, 'ready', ?, ?)`).run(input.id, input.workspaceId, input.model, input.sessionId, input.worktreePath, input.cwd, input.branch, now2, now2);
+          this.insertEvent(input.id, null, "status", { status: "ready" }, now2);
+        });
+        create.immediate();
+        return this.getConversation(input.id);
+      }
+      getConversation(id) {
+        const row = this.db.prepare("SELECT * FROM aster_conversations WHERE id = ?").get(id);
+        return row ? rowToConversation(row) : void 0;
+      }
+      listActiveConversations() {
+        const rows = this.db.prepare("SELECT * FROM aster_conversations WHERE active_run_id IS NOT NULL").all();
+        return rows.map(rowToConversation);
+      }
+      lookupTurn(conversationId, clientTurnId, requestText) {
+        const row = this.db.prepare("SELECT run_id, request_text, response_status, response_json FROM aster_turn_idempotency WHERE conversation_id = ? AND client_turn_id = ?").get(conversationId, clientTurnId);
+        if (!row) return { kind: "absent" };
+        if (row.request_text !== requestText) return { kind: "conflict" };
+        return {
+          kind: "replay",
+          runId: row.run_id,
+          responseStatus: row.response_status,
+          response: JSON.parse(row.response_json)
+        };
+      }
+      reserveTurn(input) {
+        const reserve = this.db.transaction(() => {
+          const existing = this.db.prepare("SELECT run_id, request_text, response_status, response_json FROM aster_turn_idempotency WHERE conversation_id = ? AND client_turn_id = ?").get(input.conversationId, input.clientTurnId);
+          if (existing) {
+            if (existing.request_text !== input.requestText) return { kind: "conflict" };
+            return {
+              kind: "replay",
+              runId: existing.run_id,
+              responseStatus: existing.response_status,
+              response: JSON.parse(existing.response_json)
+            };
+          }
+          const conversation = this.getConversation(input.conversationId);
+          if (!conversation) return { kind: "not_found" };
+          if (conversation.activeRunId) return { kind: "busy" };
+          const now2 = Date.now();
+          const updated = this.db.prepare("UPDATE aster_conversations SET status = 'running', active_run_id = ?, updated_at = ? WHERE id = ? AND active_run_id IS NULL").run(input.runId, now2, input.conversationId);
+          if (updated.changes !== 1) return { kind: "busy" };
+          this.insertEvent(input.conversationId, input.runId, "status", { status: "running" }, now2);
+          this.db.prepare("INSERT INTO aster_turn_idempotency (conversation_id, client_turn_id, request_text, accepted_text, run_id, response_status, response_json, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)").run(input.conversationId, input.clientTurnId, input.requestText, input.acceptedText, input.runId, 202, JSON.stringify(input.response), now2);
+          return { kind: "reserved" };
+        });
+        return reserve.immediate();
+      }
+      beginTurn(conversationId, runId) {
+        const update = this.db.transaction(() => {
+          const conversation = this.getConversation(conversationId);
+          if (!conversation || conversation.activeRunId) return false;
+          const now2 = Date.now();
+          const result2 = this.db.prepare(`UPDATE aster_conversations SET status = 'running', active_run_id = ?, updated_at = ?
+        WHERE id = ? AND active_run_id IS NULL`).run(runId, now2, conversationId);
+          if (result2.changes !== 1) return false;
+          this.insertEvent(conversationId, runId, "status", { status: "running" }, now2);
+          return true;
+        });
+        return update.immediate();
+      }
+      updateConversationStatus(conversationId, runId, status, data = {}) {
+        const terminal = status === "completed" || status === "failed" || status === "cancelled" || status === "interrupted";
+        const update = this.db.transaction(() => {
+          const now2 = Date.now();
+          const result2 = this.db.prepare(`UPDATE aster_conversations SET status = ?, active_run_id = ?, updated_at = ?
+        WHERE id = ? AND active_run_id = ?`).run(status, terminal ? null : runId, now2, conversationId, runId);
+          if (result2.changes !== 1) return false;
+          this.insertEvent(conversationId, runId, "status", { status, ...data }, now2);
+          return true;
+        });
+        return update.immediate();
+      }
+      appendEvent(conversationId, runId, type, data) {
+        const append = this.db.transaction(() => this.insertEvent(conversationId, runId, type, data, Date.now()));
+        return append.immediate();
+      }
+      eventsAfter(conversationId, after, limit = 200) {
+        const rows = this.db.prepare(`SELECT * FROM aster_events WHERE conversation_id = ? AND sequence > ?
+      ORDER BY sequence LIMIT ?`).all(conversationId, after, Math.max(1, Math.min(500, Math.trunc(limit))));
+        return rows.map((row) => ({
+          sequence: row.sequence,
+          conversationId: row.conversation_id,
+          runId: row.run_id ?? null,
+          type: row.event_type,
+          data: JSON.parse(row.data_json),
+          createdAt: row.created_at
+        }));
+      }
+      createApproval(input) {
+        const id = randomUUID5();
+        const now2 = Date.now();
+        this.db.prepare(`INSERT INTO aster_approvals
+      (id, conversation_id, run_id, tool_name, explanation, arguments_json, status, expires_at, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, 'pending', ?, ?)`).run(id, input.conversationId, input.runId, input.toolName, input.explanation, JSON.stringify(input.arguments), input.expiresAt, now2);
+        return this.getApproval(id);
+      }
+      getApproval(id) {
+        const row = this.db.prepare("SELECT * FROM aster_approvals WHERE id = ?").get(id);
+        return row ? rowToApproval(row) : void 0;
+      }
+      pendingApprovalsForConversation(conversationId) {
+        const rows = this.db.prepare("SELECT * FROM aster_approvals WHERE conversation_id = ? AND status = 'pending' ORDER BY created_at").all(conversationId);
+        return rows.map(rowToApproval);
+      }
+      getConversationForApproval(approvalId) {
+        const row = this.db.prepare(`SELECT c.* FROM aster_conversations c
+      JOIN aster_approvals a ON a.conversation_id = c.id WHERE a.id = ?`).get(approvalId);
+        return row ? rowToConversation(row) : void 0;
+      }
+      expireApproval(id, now2 = Date.now()) {
+        const update = this.db.transaction(() => {
+          const approval = this.getApproval(id);
+          if (!approval) return void 0;
+          if (approval.status === "pending" && approval.expiresAt <= now2) {
+            this.db.prepare("UPDATE aster_approvals SET status = 'expired', resolved_at = ? WHERE id = ? AND status = 'pending'").run(now2, id);
+            return this.getApproval(id);
+          }
+          return approval;
+        });
+        return update.immediate();
+      }
+      cancelPendingApprovals(conversationId, now2 = Date.now()) {
+        const update = this.db.transaction(() => {
+          const rows = this.db.prepare("SELECT * FROM aster_approvals WHERE conversation_id = ? AND status = 'pending'").all(conversationId);
+          for (const row of rows) this.db.prepare("UPDATE aster_approvals SET status = 'cancelled', resolved_at = ? WHERE id = ? AND status = 'pending'").run(now2, row.id);
+          return rows.map((row) => ({ ...rowToApproval(row), status: "cancelled", resolvedAt: now2 }));
+        });
+        return update.immediate();
+      }
+      expirePendingApprovals(now2 = Date.now()) {
+        const update = this.db.transaction(() => {
+          const rows = this.db.prepare("SELECT * FROM aster_approvals WHERE status = 'pending' AND expires_at <= ?").all(now2);
+          for (const row of rows) this.db.prepare("UPDATE aster_approvals SET status = 'expired', resolved_at = ? WHERE id = ? AND status = 'pending'").run(now2, row.id);
+          return rows.map((row) => ({ ...rowToApproval(row), status: "expired", resolvedAt: now2 }));
+        });
+        return update.immediate();
+      }
+      expireAllPendingApprovals(now2 = Date.now()) {
+        const update = this.db.transaction(() => {
+          const rows = this.db.prepare("SELECT * FROM aster_approvals WHERE status = 'pending'").all();
+          for (const row of rows) this.db.prepare("UPDATE aster_approvals SET status = 'expired', resolved_at = ? WHERE id = ? AND status = 'pending'").run(now2, row.id);
+          return rows.map((row) => ({ ...rowToApproval(row), status: "expired", resolvedAt: now2 }));
+        });
+        return update.immediate();
+      }
+      resolveApproval(id, decision, now2 = Date.now()) {
+        const update = this.db.transaction(() => {
+          const current = this.getApproval(id);
+          if (!current) return { conflict: false, changed: false };
+          if (current.status === "pending" && current.expiresAt <= now2) {
+            this.db.prepare("UPDATE aster_approvals SET status = 'expired', resolved_at = ? WHERE id = ? AND status = 'pending'").run(now2, id);
+            return { approval: this.getApproval(id), conflict: true, changed: true };
+          }
+          if (current.status !== "pending") {
+            return { approval: current, conflict: current.decision !== decision, changed: false };
+          }
+          this.db.prepare("UPDATE aster_approvals SET status = ?, decision = ?, resolved_at = ? WHERE id = ? AND status = 'pending'").run(decision === "allow" ? "approved" : "denied", decision, now2, id);
+          return { approval: this.getApproval(id), conflict: false, changed: true };
+        });
+        return update.immediate();
+      }
+      insertEvent(conversationId, runId, type, data, now2) {
+        const row = this.db.prepare("SELECT last_event_sequence FROM aster_conversations WHERE id = ?").get(conversationId);
+        if (!row) throw new Error("Conversation not found");
+        const sequence = row.last_event_sequence + 1;
+        this.db.prepare("UPDATE aster_conversations SET last_event_sequence = ?, updated_at = ? WHERE id = ?").run(sequence, now2, conversationId);
+        this.db.prepare(`INSERT INTO aster_events (conversation_id, sequence, run_id, event_type, data_json, created_at)
+      VALUES (?, ?, ?, ?, ?, ?)`).run(conversationId, sequence, runId, type, JSON.stringify(data), now2);
+        return { sequence, conversationId, runId, type, data, createdAt: now2 };
+      }
+    };
+  }
+});
+
 // src/remote/tui-auth.ts
 var tui_auth_exports = {};
 __export(tui_auth_exports, {
   authGitHubForTui: () => authGitHubForTui
 });
 function sleep3(ms) {
-  return new Promise((resolve14) => setTimeout(resolve14, ms));
+  return new Promise((resolve15) => setTimeout(resolve15, ms));
 }
 async function* authGitHubForTui() {
   yield { message: "Starting GitHub OAuth device flow..." };
@@ -13045,11 +13486,101 @@ function getOpenApiSpec() {
             }
           }
         }
+      },
+      "/api/v1/health": {
+        get: {
+          summary: "Authenticated Aster capabilities and health",
+          security: [{ asterBearer: [] }],
+          responses: { "200": { description: "API version and supported capabilities; contains no host paths or secrets" }, "401": { description: "Invalid or expired credential" } }
+        }
+      },
+      "/api/v1/workspaces": {
+        get: {
+          summary: "List credential-scoped workspaces",
+          security: [{ asterBearer: [] }],
+          responses: { "200": { description: "Configured workspace IDs and display names only" } }
+        }
+      },
+      "/api/v1/models": {
+        get: {
+          summary: "List server-configured models",
+          security: [{ asterBearer: [] }],
+          responses: { "200": { description: "Configured model IDs" } }
+        }
+      },
+      "/api/v1/conversations": {
+        post: {
+          summary: "Create a persistent conversation in an isolated workspace worktree",
+          security: [{ asterBearer: [] }],
+          requestBody: {
+            required: true,
+            content: { "application/json": { schema: {
+              type: "object",
+              required: ["workspaceId", "model"],
+              properties: { workspaceId: { type: "string" }, model: { type: "string" } },
+              additionalProperties: false
+            }, example: { workspaceId: "default", model: "moonshotai/kimi-k2.6" } } }
+          },
+          responses: { "201": { description: "Created conversation with opaque ID" }, "400": { description: "Invalid workspace or model" } }
+        }
+      },
+      "/api/v1/conversations/{conversationId}": {
+        get: {
+          summary: "Get conversation status without returning model/tool history or filesystem paths",
+          security: [{ asterBearer: [] }],
+          parameters: [{ name: "conversationId", in: "path", required: true, schema: { type: "string", format: "uuid" } }],
+          responses: { "200": { description: "Conversation metadata and last event cursor" }, "404": { description: "Conversation not found or outside credential scope" } }
+        }
+      },
+      "/api/v1/conversations/{conversationId}/turns": {
+        post: {
+          summary: "Append a user turn to the persistent conversation",
+          security: [{ asterBearer: [] }],
+          parameters: [{ name: "conversationId", in: "path", required: true, schema: { type: "string", format: "uuid" } }],
+          requestBody: { required: true, content: { "application/json": { schema: { type: "object", required: ["text"], properties: { clientTurnId: { type: "string", minLength: 1, maxLength: 128, pattern: "^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$", description: "Optional stable idempotency key, scoped to this conversation. Omit only for non-idempotent legacy submission." }, text: { type: "string", maxLength: 2e4 } }, additionalProperties: false }, examples: { legacy: { summary: "Legacy text-only submission (do not automatically retry ambiguous requests)", value: { text: "Summarize the failing test and propose a fix." } }, idempotent: { summary: "Retry-safe submission", value: { clientTurnId: "turn-550e8400-e29b-41d4-a716-446655440000", text: "Summarize the failing test and propose a fix." } } } } } },
+          responses: { "202": { description: "Turn accepted; keyed submissions replay the persisted response for the same ID and text" }, "400": { description: "clientTurnId, when present, or text is invalid" }, "409": { description: "conversation_busy or idempotency_conflict for a reused key with different text" } }
+        }
+      },
+      "/api/v1/conversations/{conversationId}/events": {
+        get: {
+          summary: "Reconnectable per-conversation SSE stream",
+          security: [{ asterBearer: [] }],
+          parameters: [
+            { name: "conversationId", in: "path", required: true, schema: { type: "string", format: "uuid" } },
+            { name: "Last-Event-ID", in: "header", schema: { type: "integer" }, description: "Replay events with larger sequence IDs." },
+            { name: "after", in: "query", schema: { type: "integer", minimum: 0 }, description: "Alternative replay cursor." }
+          ],
+          responses: { "200": { description: "Typed SSE events with monotonic IDs: status, assistant.delta, tool.activity, approval.required, approval.resolved, approval.expired, usage, completed, cancelled, failed." } }
+        }
+      },
+      "/api/v1/conversations/{conversationId}/cancel": {
+        post: {
+          summary: "Idempotently cancel the active run and abort its agent signal",
+          security: [{ asterBearer: [] }],
+          parameters: [{ name: "conversationId", in: "path", required: true, schema: { type: "string", format: "uuid" } }],
+          responses: { "200": { description: "Current conversation state" }, "404": { description: "Conversation not found" } }
+        }
+      },
+      "/api/v1/approvals/{approvalId}": {
+        get: {
+          summary: "Review a pending approval action and exact arguments",
+          security: [{ asterBearer: [] }],
+          parameters: [{ name: "approvalId", in: "path", required: true, schema: { type: "string", format: "uuid" } }],
+          responses: { "200": { description: "Pending action and exact arguments; secret-like actions are rejected before approval" }, "404": { description: "Approval not found" } }
+        },
+        post: {
+          summary: "Allow or deny one pending action; resolution is single-use and idempotent",
+          security: [{ asterBearer: [] }],
+          parameters: [{ name: "approvalId", in: "path", required: true, schema: { type: "string", format: "uuid" } }],
+          requestBody: { required: true, content: { "application/json": { schema: { type: "object", required: ["decision"], properties: { decision: { type: "string", enum: ["allow", "deny"] } }, additionalProperties: false }, example: { decision: "allow" } } } },
+          responses: { "200": { description: "Resolved approval" }, "409": { description: "Conflicting prior resolution" }, "410": { description: "Approval expired; action was not executed" } }
+        }
       }
     },
     components: {
       securitySchemes: {
-        basicAuth: { type: "http", scheme: "basic" }
+        basicAuth: { type: "http", scheme: "basic" },
+        asterBearer: { type: "http", scheme: "bearer", bearerFormat: "revocable, workspace-scoped Autopilot credential" }
       }
     }
   };
@@ -13082,18 +13613,18 @@ var init_openapi = __esm({
 
 // src/runs/worktrees.ts
 import { execFile as execFile3 } from "child_process";
-import { access as access2, chmod as chmod2, mkdir as mkdir10, realpath as realpath3 } from "fs/promises";
-import { homedir as homedir18 } from "os";
-import { isAbsolute as isAbsolute3, join as join25, parse, relative as relative5, resolve as resolve7, sep as sep3 } from "path";
+import { access as access2, chmod as chmod2, mkdir as mkdir10, realpath as realpath4 } from "fs/promises";
+import { homedir as homedir19 } from "os";
+import { isAbsolute as isAbsolute4, join as join26, parse, relative as relative6, resolve as resolve7, sep as sep4 } from "path";
 function defaultWorktreesDir() {
-  const dataHome = process.env.XDG_DATA_HOME || join25(homedir18(), ".local", "share");
-  return join25(dataHome, "autopilot", "worktrees");
+  const dataHome = process.env.XDG_DATA_HOME || join26(homedir19(), ".local", "share");
+  return join26(dataHome, "autopilot", "worktrees");
 }
 function isOutside(path) {
-  return path === ".." || path.startsWith(`..${sep3}`) || isAbsolute3(path);
+  return path === ".." || path.startsWith(`..${sep4}`) || isAbsolute4(path);
 }
-function isWithin(parent, candidate) {
-  const path = relative5(parent, candidate);
+function isWithin2(parent, candidate) {
+  const path = relative6(parent, candidate);
   return path === "" || !isOutside(path);
 }
 function runGit(args, cwd) {
@@ -13121,24 +13652,24 @@ var init_worktrees = __esm({
         if (runId === "." || runId === ".." || !/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/.test(runId)) {
           throw new Error("runId must contain only letters, numbers, dots, underscores, or hyphens");
         }
-        const source = await realpath3(sourceCwd);
+        const source = await realpath4(sourceCwd);
         const repositoryRoot = (await runGit(["rev-parse", "--show-toplevel"], source)).trim();
-        const repository = await realpath3(repositoryRoot);
-        const sourceRelativePath = relative5(repository, source);
+        const repository = await realpath4(repositoryRoot);
+        const sourceRelativePath = relative6(repository, source);
         if (isOutside(sourceRelativePath)) {
           throw new Error("sourceCwd must be inside the Git repository");
         }
         const configuredRoot = resolve7(this.rootDir);
-        if (configuredRoot === parse(configuredRoot).root || isWithin(repository, configuredRoot)) {
+        if (configuredRoot === parse(configuredRoot).root || isWithin2(repository, configuredRoot)) {
           throw new Error("worktree root must be outside the source repository and not the filesystem root");
         }
         await mkdir10(configuredRoot, { recursive: true, mode: 448 });
-        const worktreesRoot = await realpath3(configuredRoot);
-        if (isWithin(repository, worktreesRoot)) {
+        const worktreesRoot = await realpath4(configuredRoot);
+        if (isWithin2(repository, worktreesRoot)) {
           throw new Error("worktree root must be outside the source repository");
         }
         await chmod2(worktreesRoot, 448);
-        const worktreePath = join25(worktreesRoot, runId);
+        const worktreePath = join26(worktreesRoot, runId);
         try {
           await access2(worktreePath);
           throw new Error(`worktree path already exists for run ${runId}`);
@@ -13158,10 +13689,10 @@ var init_worktrees = __esm({
       }
       /** Remove a newly-created, still-clean worktree when run initialization fails. */
       async discard(worktree) {
-        const root = await realpath3(this.rootDir);
-        const target = await realpath3(worktree.worktreePath);
-        const repository = await realpath3(worktree.repositoryRoot);
-        if (target === root || !isWithin(root, target)) {
+        const root = await realpath4(this.rootDir);
+        const target = await realpath4(worktree.worktreePath);
+        const repository = await realpath4(worktree.repositoryRoot);
+        if (target === root || !isWithin2(root, target)) {
           throw new Error("worktree path is outside the configured worktree root");
         }
         if (worktree.branch !== `autopilot/run/${worktree.runId}`) {
@@ -13305,20 +13836,759 @@ var init_wake_scheduler = __esm({
   }
 });
 
+// src/server/aster-tools.ts
+import { realpath as realpath5 } from "fs/promises";
+import { isAbsolute as isAbsolute5, relative as relative7, sep as sep5 } from "path";
+function createAsterTools(workspaceRoot) {
+  return ASTR_TOOLS.map((tool) => ({
+    ...tool,
+    run: async (args, context) => {
+      await assertAsterWorkspacePath(workspaceRoot, args.path, tool.name !== "read");
+      return tool.run(args, { ...context, cwd: workspaceRoot });
+    }
+  }));
+}
+async function assertAsterWorkspacePath(workspaceRoot, value, allowMissing = false) {
+  if (typeof value !== "string" || !value.trim()) throw new Error("workspace_path_invalid");
+  const root = await realpath5(workspaceRoot);
+  const candidate = resolvePath(root, value);
+  assertInside(root, candidate);
+  assertNotSensitive(root, candidate);
+  let actual;
+  try {
+    actual = await realpath5(candidate);
+  } catch (error) {
+    if (!allowMissing || error.code !== "ENOENT") throw new Error("workspace_path_unavailable");
+    let ancestor = candidate;
+    while (true) {
+      try {
+        actual = await realpath5(ancestor);
+        break;
+      } catch (ancestorError) {
+        if (ancestorError.code !== "ENOENT") throw new Error("workspace_path_unavailable");
+        const parent = relative7(root, ancestor);
+        if (!parent || parent === ".") throw new Error("workspace_path_unavailable");
+        ancestor = ancestor.slice(0, ancestor.lastIndexOf(sep5));
+      }
+    }
+  }
+  assertInside(root, actual);
+  assertNotSensitive(root, actual);
+  return candidate;
+}
+function containsLikelyProviderSecret(value) {
+  return /(?:sk-or-(?:v1-)?[A-Za-z0-9_-]{16,}|sk-[A-Za-z0-9_-]{24,}|gh[pousr]_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]{20,}|(?:CLOUDFLARE|OPENROUTER|REQUESTY)_API_(?:KEY|TOKEN)\s*=)/i.test(value);
+}
+function redactLikelySecrets(value) {
+  return value.replace(/sk-or-(?:v1-)?[A-Za-z0-9_-]{16,}/g, "[REDACTED_PROVIDER_SECRET]").replace(/sk-[A-Za-z0-9_-]{24,}/g, "[REDACTED_PROVIDER_SECRET]").replace(/gh[pousr]_[A-Za-z0-9]{20,}/g, "[REDACTED_PROVIDER_SECRET]").replace(/github_pat_[A-Za-z0-9_]{20,}/g, "[REDACTED_PROVIDER_SECRET]");
+}
+function assertInside(root, candidate) {
+  const rel = relative7(root, candidate);
+  if (rel === ".." || rel.startsWith(`..${sep5}`) || isAbsolute5(rel)) throw new Error("workspace_path_forbidden");
+}
+function assertNotSensitive(root, candidate) {
+  const parts = relative7(root, candidate).split(sep5).filter(Boolean).map((part) => part.toLowerCase());
+  if (parts.some((part) => part === ".env" || part.startsWith(".env.") || SENSITIVE_NAMES.has(part))) {
+    throw new Error("workspace_sensitive_path_forbidden");
+  }
+}
+var ASTR_TOOLS, SENSITIVE_NAMES;
+var init_aster_tools = __esm({
+  "src/server/aster-tools.ts"() {
+    "use strict";
+    init_edit();
+    init_read();
+    init_write();
+    init_paths();
+    ASTR_TOOLS = [readTool, writeTool, editTool];
+    SENSITIVE_NAMES = /* @__PURE__ */ new Set([
+      ".git",
+      ".ssh",
+      ".aws",
+      ".azure",
+      ".config",
+      ".netrc",
+      ".npmrc",
+      ".git-credentials",
+      "id_rsa",
+      "id_ed25519",
+      "credentials",
+      "secrets"
+    ]);
+  }
+});
+
+// src/server/aster-api.ts
+import { randomUUID as randomUUID6 } from "crypto";
+import { unlink as unlink2 } from "fs/promises";
+import { resolve as resolve8 } from "path";
+function parseCursor(header, query) {
+  const value = (Array.isArray(header) ? header[0] : header) ?? query ?? "0";
+  if (!/^\d{1,16}$/.test(value)) return void 0;
+  const cursor = Number(value);
+  return Number.isSafeInteger(cursor) ? cursor : void 0;
+}
+function publicConversation(conversation) {
+  return {
+    conversationId: conversation.id,
+    workspaceId: conversation.workspaceId,
+    model: conversation.model,
+    status: conversation.status,
+    activeRunId: conversation.activeRunId,
+    lastEventId: conversation.lastEventSequence,
+    createdAt: new Date(conversation.createdAt).toISOString(),
+    updatedAt: new Date(conversation.updatedAt).toISOString()
+  };
+}
+function publicApproval(approval) {
+  return {
+    approvalId: approval.id,
+    conversationId: approval.conversationId,
+    runId: approval.runId,
+    status: approval.status,
+    tool: approval.toolName,
+    explanation: approval.explanation,
+    arguments: approval.arguments,
+    expiresAt: new Date(approval.expiresAt).toISOString(),
+    decision: approval.decision
+  };
+}
+async function readJsonBody(req) {
+  const chunks = [];
+  let bytes = 0;
+  for await (const chunk of req) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    bytes += buffer.length;
+    if (bytes > MAX_BODY_BYTES) throw httpFailure(413, "request_too_large", "Request body exceeds 64 KiB");
+    chunks.push(buffer);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+  } catch {
+    throw httpFailure(400, "invalid_json", "Request body must be valid JSON");
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw httpFailure(400, "invalid_json", "Request body must be a JSON object");
+  return parsed;
+}
+function httpFailure(status, code, message2) {
+  return { status, code, message: message2 };
+}
+function isHttpFailure(error) {
+  return !!error && typeof error === "object" && "status" in error && "code" in error && "message" in error;
+}
+function sendError(res, status, code, message2) {
+  json(res, status, { error: { code, message: message2 } });
+}
+function json(res, status, data) {
+  res.writeHead(status, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-store" });
+  res.end(JSON.stringify(data));
+}
+var API_PREFIX, MAX_BODY_BYTES, MAX_USER_TURN_CHARS, CLIENT_TURN_ID_RE, MAX_APPROVAL_ARG_BYTES, CONVERSATION_ID_RE, ALLOWED_ASTER_TOOLS, AsterApi;
+var init_aster_api = __esm({
+  "src/server/aster-api.ts"() {
+    "use strict";
+    init_system_prompt();
+    init_executor();
+    init_store();
+    init_worktrees();
+    init_sessions();
+    init_version();
+    init_aster_store();
+    init_aster_workspaces();
+    init_aster_tools();
+    API_PREFIX = "/api/v1";
+    MAX_BODY_BYTES = 64 * 1024;
+    MAX_USER_TURN_CHARS = 2e4;
+    CLIENT_TURN_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
+    MAX_APPROVAL_ARG_BYTES = 24 * 1024;
+    CONVERSATION_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+    ALLOWED_ASTER_TOOLS = ["read", "write", "edit"];
+    AsterApi = class {
+      store;
+      recovery;
+      waiters = /* @__PURE__ */ new Map();
+      runtime;
+      config;
+      constructor(config2, runtime) {
+        this.config = config2;
+        this.runtime = runtime;
+      }
+      async handle(req, res) {
+        const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+        try {
+          const store = this.getStore();
+          const principal = store.authenticate(req.headers.authorization);
+          if (!principal) {
+            sendError(res, 401, "invalid_credential", "A valid Aster bearer credential is required");
+            return;
+          }
+          await this.ensureRecovered(store);
+          const config2 = await loadAsterServerConfig();
+          const method = req.method ?? "GET";
+          const path = url.pathname;
+          if (path === `${API_PREFIX}/health` && method === "GET") {
+            if (!this.hasScope(principal, "workspaces:read")) return sendError(res, 403, "insufficient_scope", "Credential lacks health/read scope");
+            return json(res, 200, {
+              status: "ok",
+              service: "autopilot",
+              apiVersion: "v1",
+              serviceVersion: getAppVersion(),
+              capabilities: ["workspaces", "conversations", "turns", "event-replay", "cancellation", "human-approvals"]
+            });
+          }
+          if (path === `${API_PREFIX}/workspaces` && method === "GET") {
+            if (!this.hasScope(principal, "workspaces:read")) return sendError(res, 403, "insufficient_scope", "Credential lacks workspace/read scope");
+            return json(res, 200, {
+              workspaces: config2.workspaces.filter((workspace) => principal.workspaceIds.includes(workspace.id)).map(({ id, displayName }) => ({ id, displayName }))
+            });
+          }
+          if (path === `${API_PREFIX}/models` && method === "GET") {
+            if (!this.hasScope(principal, "models:read")) return sendError(res, 403, "insufficient_scope", "Credential lacks model/read scope");
+            return json(res, 200, { models: config2.models });
+          }
+          if (path === `${API_PREFIX}/conversations` && method === "POST") {
+            if (!this.hasScope(principal, "conversations:write")) return sendError(res, 403, "insufficient_scope", "Credential lacks conversation/write scope");
+            const body = await readJsonBody(req);
+            if (Object.keys(body).some((key) => key !== "workspaceId" && key !== "model")) {
+              return sendError(res, 400, "unsupported_field", "Conversation creation accepts only workspaceId and model; paths are server-configured");
+            }
+            if (typeof body.workspaceId !== "string" || !principal.workspaceIds.includes(body.workspaceId)) {
+              return sendError(res, 403, "workspace_forbidden", "Workspace ID is not in this credential's scope");
+            }
+            const workspace = findAsterWorkspace(config2, body.workspaceId);
+            if (!workspace) return sendError(res, 404, "workspace_not_found", "Workspace is not configured");
+            if (typeof body.model !== "string" || !config2.models.includes(body.model)) {
+              return sendError(res, 400, "model_not_allowed", "Select a model from the configured model list");
+            }
+            return await this.createConversation(res, store, workspace, body.model);
+          }
+          const eventsMatch = path.match(/^\/api\/v1\/conversations\/([^/]+)\/events$/);
+          if (eventsMatch && method === "GET") {
+            if (!this.hasScope(principal, "conversations:read")) return sendError(res, 403, "insufficient_scope", "Credential lacks conversation/read scope");
+            const conversation = await this.authorizedConversation(store, principal, eventsMatch[1]);
+            if (!conversation) return sendError(res, 404, "conversation_not_found", "Conversation not found");
+            const cursor = parseCursor(req.headers["last-event-id"], url.searchParams.get("after"));
+            if (cursor === void 0) return sendError(res, 400, "invalid_event_cursor", "Event cursor must be a non-negative integer");
+            return this.streamEvents(req, res, store, conversation.id, cursor);
+          }
+          const turnMatch = path.match(/^\/api\/v1\/conversations\/([^/]+)\/turns$/);
+          if (turnMatch && method === "POST") {
+            if (!this.hasScope(principal, "conversations:write")) return sendError(res, 403, "insufficient_scope", "Credential lacks conversation/write scope");
+            const conversation = await this.authorizedConversation(store, principal, turnMatch[1]);
+            if (!conversation) return sendError(res, 404, "conversation_not_found", "Conversation not found");
+            const body = await readJsonBody(req);
+            if (Object.keys(body).some((key) => key !== "text" && key !== "clientTurnId")) return sendError(res, 400, "unsupported_field", "Turns accept text and an optional clientTurnId; workspace and model are fixed by the conversation");
+            const hasClientTurnId = Object.hasOwn(body, "clientTurnId");
+            const clientTurnId = hasClientTurnId && typeof body.clientTurnId === "string" ? body.clientTurnId : void 0;
+            if (hasClientTurnId && (!clientTurnId || !CLIENT_TURN_ID_RE.test(clientTurnId))) return sendError(res, 400, "invalid_client_turn_id", "clientTurnId must be 1-128 ASCII letters, digits, '.', '_', ':', or '-' and start with a letter or digit");
+            const requestText = typeof body.text === "string" ? body.text : "";
+            const text = requestText.trim();
+            if (!text || text.length > MAX_USER_TURN_CHARS) return sendError(res, 400, "invalid_turn", `Turn text must be 1-${MAX_USER_TURN_CHARS} characters`);
+            if (containsLikelyProviderSecret(text)) return sendError(res, 400, "secret_input_rejected", "Provider credentials must not be sent in conversation text");
+            return await this.appendTurn(res, store, conversation, clientTurnId, requestText, text);
+          }
+          const cancelMatch = path.match(/^\/api\/v1\/conversations\/([^/]+)\/cancel$/);
+          if (cancelMatch && method === "POST") {
+            if (!this.hasScope(principal, "conversations:write")) return sendError(res, 403, "insufficient_scope", "Credential lacks conversation/write scope");
+            const conversation = await this.authorizedConversation(store, principal, cancelMatch[1]);
+            if (!conversation) return sendError(res, 404, "conversation_not_found", "Conversation not found");
+            return this.cancelConversation(res, store, conversation);
+          }
+          const conversationMatch = path.match(/^\/api\/v1\/conversations\/([^/]+)$/);
+          if (conversationMatch && method === "GET") {
+            if (!this.hasScope(principal, "conversations:read")) return sendError(res, 403, "insufficient_scope", "Credential lacks conversation/read scope");
+            const conversation = await this.authorizedConversation(store, principal, conversationMatch[1]);
+            if (!conversation) return sendError(res, 404, "conversation_not_found", "Conversation not found");
+            return json(res, 200, publicConversation(conversation));
+          }
+          const approvalMatch = path.match(/^\/api\/v1\/approvals\/([^/]+)$/);
+          if (approvalMatch && method === "GET") {
+            if (!this.hasScope(principal, "conversations:read")) return sendError(res, 403, "insufficient_scope", "Credential lacks conversation/read scope");
+            const approval = store.getApproval(approvalMatch[1]);
+            if (!approval) return sendError(res, 404, "approval_not_found", "Approval not found");
+            const conversation = store.getConversation(approval.conversationId);
+            if (!conversation || !principal.workspaceIds.includes(conversation.workspaceId)) return sendError(res, 404, "approval_not_found", "Approval not found");
+            return json(res, 200, publicApproval(approval));
+          }
+          if (approvalMatch && method === "POST") {
+            if (!this.hasScope(principal, "approvals:resolve")) return sendError(res, 403, "insufficient_scope", "Credential lacks approval/resolve scope");
+            const approval = store.getApproval(approvalMatch[1]);
+            if (!approval) return sendError(res, 404, "approval_not_found", "Approval not found");
+            const conversation = store.getConversation(approval.conversationId);
+            if (!conversation || !principal.workspaceIds.includes(conversation.workspaceId)) return sendError(res, 404, "approval_not_found", "Approval not found");
+            const body = await readJsonBody(req);
+            if (Object.keys(body).some((key) => key !== "decision")) return sendError(res, 400, "unsupported_field", "Approval resolution accepts decision only");
+            if (body.decision !== "allow" && body.decision !== "deny") return sendError(res, 400, "invalid_approval_decision", "decision must be allow or deny");
+            return this.resolveApproval(res, store, approval.id, body.decision);
+          }
+          return sendError(res, 404, "not_found", "Aster endpoint not found");
+        } catch (error) {
+          if (isHttpFailure(error)) return sendError(res, error.status, error.code, error.message);
+          if (error instanceof AsterConfigError) return sendError(res, 503, "aster_not_configured", "Aster workspaces/models are not configured");
+          return sendError(res, 500, "internal_error", "Aster request could not be completed");
+        }
+      }
+      close() {
+        for (const [id, waiter] of this.waiters) {
+          clearTimeout(waiter.timer);
+          waiter.resolve("deny");
+          this.waiters.delete(id);
+        }
+        this.store?.close();
+        this.store = void 0;
+      }
+      getStore() {
+        return this.store ??= new AsterStore();
+      }
+      hasScope(principal, scope) {
+        return principal.scopes.includes(scope);
+      }
+      async authorizedConversation(store, principal, id) {
+        if (!CONVERSATION_ID_RE.test(id)) return void 0;
+        const conversation = store.getConversation(id);
+        if (!conversation || !principal.workspaceIds.includes(conversation.workspaceId)) return void 0;
+        const activeRunId = conversation.activeRunId;
+        if (activeRunId) {
+          const runs = new RunStore();
+          try {
+            const run = runs.getRun(activeRunId);
+            if (run && ["interrupted_unknown", "cancelled", "failed", "completed"].includes(run.status)) {
+              const status = run.status === "completed" ? "completed" : run.status === "cancelled" ? "cancelled" : "interrupted";
+              store.updateConversationStatus(conversation.id, activeRunId, status, { reason: "run_recovered" });
+              return store.getConversation(id);
+            }
+          } finally {
+            runs.close();
+          }
+        }
+        return conversation;
+      }
+      async ensureRecovered(store) {
+        if (this.recovery) return this.recovery;
+        this.recovery = (async () => {
+          const runs = new RunStore();
+          try {
+            runs.reconcileInterruptedRuns();
+            for (const approval of store.expireAllPendingApprovals()) {
+              const run = runs.getRun(approval.runId);
+              if (run && ["running", "waiting", "needs_input", "queued"].includes(run.status)) {
+                runs.transition(run.id, "cancelled", "server_restarted_during_approval");
+                runs.cancelTimersForRun(run.id);
+              }
+              store.updateConversationStatus(approval.conversationId, approval.runId, "interrupted", { reason: "approval_expired_on_restart" });
+              store.appendEvent(approval.conversationId, approval.runId, "approval.expired", { approvalId: approval.id });
+            }
+            for (const conversation of store.listActiveConversations()) {
+              const run = conversation.activeRunId ? runs.getRun(conversation.activeRunId) : void 0;
+              if (!run || ["interrupted_unknown", "cancelled", "failed", "completed"].includes(run.status)) {
+                const status = run?.status === "completed" ? "completed" : run?.status === "cancelled" ? "cancelled" : "interrupted";
+                store.updateConversationStatus(conversation.id, conversation.activeRunId, status, { reason: "server_restart_recovery" });
+              } else if (run.status === "needs_input") {
+                runs.transition(run.id, "cancelled", "approval_expired_on_restart");
+                store.updateConversationStatus(conversation.id, run.id, "interrupted", { reason: "approval_expired_on_restart" });
+              }
+            }
+          } finally {
+            runs.close();
+          }
+        })();
+        return this.recovery;
+      }
+      async createConversation(res, store, workspace, model) {
+        const id = randomUUID6();
+        const sessionId = randomUUID6();
+        const worktreeManager = new RunWorktreeManager();
+        let worktree;
+        try {
+          worktree = await worktreeManager.create(id, workspace.rootPath);
+        } catch {
+          sendError(res, 409, "workspace_repository_unavailable", "Configured workspace must be an accessible Git repository");
+          return;
+        }
+        const tools = createAsterTools(worktree.cwd);
+        const messages = [
+          { role: "system", content: buildSystemPrompt({ cwd: worktree.cwd, tools, model, preferPullRequests: true }) },
+          { role: "system", content: "You are operating through Aster. Only read, write, and edit tools are available. All file access is confined to the selected workspace. Never request, reveal, store, or repeat provider credentials or secrets." }
+        ];
+        const sessionFile = {
+          id: sessionId,
+          cwd: worktree.cwd,
+          model,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          messages,
+          title: "Aster conversation"
+        };
+        try {
+          await saveSession(sessionFile);
+          const conversation = store.createConversation({
+            id,
+            workspaceId: workspace.id,
+            model,
+            sessionId,
+            worktreePath: worktree.worktreePath,
+            cwd: worktree.cwd,
+            branch: worktree.branch
+          });
+          store.appendEvent(id, null, "conversation.created", { conversationId: id, workspaceId: workspace.id, model });
+          json(res, 201, publicConversation(conversation));
+        } catch {
+          await unlink2(resolve8(sessionsDir(), `${sessionId}.json`)).catch(() => {
+          });
+          await worktreeManager.discard(worktree).catch(() => {
+          });
+          sendError(res, 500, "conversation_create_failed", "Conversation could not be created");
+        }
+      }
+      async appendTurn(res, store, conversation, clientTurnId, requestText, text) {
+        const idempotent = clientTurnId !== void 0;
+        if (clientTurnId !== void 0) {
+          const previous = store.lookupTurn(conversation.id, clientTurnId, requestText);
+          if (previous.kind === "replay") {
+            json(res, previous.responseStatus, previous.response);
+            return;
+          }
+          if (previous.kind === "conflict") {
+            sendError(res, 409, "idempotency_conflict", "clientTurnId was already used with different text");
+            return;
+          }
+        }
+        const runId = randomUUID6();
+        if (!idempotent && !store.beginTurn(conversation.id, runId)) {
+          sendError(res, 409, "conversation_busy", "A turn is already active for this conversation");
+          return;
+        }
+        const sessionPath = resolve8(sessionsDir(), conversation.sessionId + ".json");
+        let sessionFile;
+        try {
+          sessionFile = await loadSession(sessionPath);
+        } catch {
+          if (!idempotent) store.updateConversationStatus(conversation.id, runId, "interrupted", { reason: "session_missing" });
+          sendError(res, 409, "conversation_state_unavailable", "Conversation state is unavailable; no new turn was started");
+          return;
+        }
+        if (sessionFile.cwd !== conversation.cwd) {
+          if (!idempotent) store.updateConversationStatus(conversation.id, runId, "failed", { reason: "workspace_mismatch" });
+          sendError(res, 500, "conversation_state_invalid", "Conversation workspace binding is invalid");
+          return;
+        }
+        const acceptedResponse = {
+          conversationId: conversation.id,
+          runId,
+          status: "running"
+        };
+        if (clientTurnId !== void 0) acceptedResponse.clientTurnId = clientTurnId;
+        if (clientTurnId !== void 0) {
+          const reservation = store.reserveTurn({
+            conversationId: conversation.id,
+            clientTurnId,
+            requestText,
+            acceptedText: text,
+            runId,
+            response: acceptedResponse
+          });
+          if (reservation.kind === "replay") {
+            json(res, reservation.responseStatus, reservation.response);
+            return;
+          }
+          if (reservation.kind === "conflict") {
+            sendError(res, 409, "idempotency_conflict", "clientTurnId was already used with different text");
+            return;
+          }
+          if (reservation.kind === "busy") {
+            sendError(res, 409, "conversation_busy", "A turn is already active for this conversation");
+            return;
+          }
+          if (reservation.kind === "not_found") {
+            sendError(res, 404, "conversation_not_found", "Conversation not found");
+            return;
+          }
+        }
+        const previousLength = sessionFile.messages.length;
+        sessionFile.messages.push({ role: "user", content: text });
+        sessionFile.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        try {
+          await saveSession(sessionFile);
+          const runStore = new RunStore();
+          let run;
+          try {
+            run = runStore.createRun({
+              id: runId,
+              task: text,
+              cwd: conversation.cwd,
+              sessionId: conversation.sessionId,
+              allowedTools: [...ALLOWED_ASTER_TOOLS]
+            });
+            runStore.transition(runId, "running");
+          } finally {
+            runStore.close();
+          }
+          const tools = createAsterTools(conversation.cwd);
+          const executor = new ToolExecutor(tools);
+          executor.unregister("expand_artifact");
+          const allowedTools = new Set(tools.map((tool) => tool.name));
+          const publishEvent = (type, data) => {
+            store.appendEvent(conversation.id, runId, type, data);
+          };
+          const active = {
+            runId,
+            conversation,
+            sessionFile,
+            messages: sessionFile.messages,
+            executor,
+            allowedTools,
+            maxToolIterations: run.maxToolIterations,
+            maxRuntimeMs: run.maxRuntimeMs,
+            askPermission: (request) => this.askForApproval(store, conversation, runId, request, publishEvent),
+            publishEvent,
+            finish: (status, reason) => {
+              const updated = store.updateConversationStatus(conversation.id, runId, status, reason ? { reason } : {});
+              if (updated) store.appendEvent(conversation.id, runId, status, reason ? { reason } : {});
+            }
+          };
+          this.runtime.startTurn(active);
+          json(res, 202, acceptedResponse);
+        } catch {
+          sessionFile.messages.length = previousLength;
+          await saveSession(sessionFile).catch(() => {
+          });
+          const runs = new RunStore();
+          try {
+            const run = runs.getRun(runId);
+            if (run && ["queued", "running", "waiting", "needs_input"].includes(run.status)) {
+              runs.transition(runId, "failed", "aster_turn_start_failed");
+              runs.cancelTimersForRun(runId);
+            }
+          } finally {
+            runs.close();
+          }
+          store.updateConversationStatus(conversation.id, runId, "failed", { reason: "turn_start_failed" });
+          store.appendEvent(conversation.id, runId, "failed", { code: "turn_start_failed" });
+          if (idempotent) json(res, 202, acceptedResponse);
+          else sendError(res, 500, "turn_start_failed", "Turn could not be started");
+        }
+      }
+      async askForApproval(store, conversation, runId, request, publish) {
+        if (request.tool.name !== "write" && request.tool.name !== "edit") return "deny";
+        const argsJson = JSON.stringify(request.args);
+        if (Buffer.byteLength(argsJson, "utf8") > MAX_APPROVAL_ARG_BYTES || containsLikelyProviderSecret(argsJson)) {
+          publish("tool.activity", { tool: request.tool.name, activity: "rejected", reason: "unsafe_payload" });
+          return "deny";
+        }
+        const workspaceRoot = conversation.cwd;
+        try {
+          await assertAsterWorkspacePath(workspaceRoot, request.args.path, request.tool.name === "write");
+        } catch {
+          publish("tool.activity", { tool: request.tool.name, activity: "rejected", reason: "workspace_path_forbidden" });
+          return "deny";
+        }
+        const file = typeof request.args.path === "string" ? request.args.path.split(/[\\/]/).filter(Boolean).slice(-2).join("/") : "workspace file";
+        const explanation = request.tool.name === "write" ? `Create or replace ${file} in this workspace` : `Edit ${file} in this workspace`;
+        const config2 = await loadAsterServerConfig();
+        const approval = store.createApproval({
+          conversationId: conversation.id,
+          runId,
+          toolName: request.tool.name,
+          explanation,
+          arguments: request.args,
+          expiresAt: Date.now() + config2.approvalTtlMs
+        });
+        const runs = new RunStore();
+        try {
+          const run = runs.getRun(runId);
+          if (run?.status === "running") runs.transition(runId, "needs_input", `approval:${approval.id}`);
+        } finally {
+          runs.close();
+        }
+        store.updateConversationStatus(conversation.id, runId, "waiting_approval", { approvalId: approval.id });
+        publish("approval.required", { approvalId: approval.id, tool: approval.toolName, explanation: approval.explanation, expiresAt: approval.expiresAt });
+        return new Promise((resolveDecision) => {
+          const timer3 = setTimeout(() => {
+            void this.expireApproval(store, approval.id);
+          }, config2.approvalTtlMs);
+          timer3.unref();
+          this.waiters.set(approval.id, { resolve: resolveDecision, timer: timer3 });
+        });
+      }
+      async expireApproval(store, id) {
+        const approval = store.expireApproval(id);
+        if (!approval || approval.status !== "expired") return;
+        await this.resumeAfterApproval(store, approval, "deny", "expired");
+      }
+      async resolveApproval(res, store, id, decision) {
+        const result2 = store.resolveApproval(id, decision);
+        if (!result2.approval) {
+          sendError(res, 404, "approval_not_found", "Approval not found");
+          return;
+        }
+        const approval = result2.approval;
+        if (approval.status === "expired") {
+          if (result2.changed) await this.resumeAfterApproval(store, approval, "deny", "expired");
+          sendError(res, 410, "approval_expired", "Approval has expired; the action was not executed");
+          return;
+        }
+        if (result2.conflict) {
+          sendError(res, 409, "approval_already_resolved", "Approval was already resolved with a different decision");
+          return;
+        }
+        if (approval.status === "approved" || approval.status === "denied") {
+          if (result2.changed) await this.resumeAfterApproval(store, approval, decision, approval.status);
+          json(res, 200, { approvalId: id, status: approval.status, decision: approval.decision });
+          return;
+        }
+        sendError(res, 409, "approval_not_pending", "Approval is not pending");
+      }
+      async resumeAfterApproval(store, approval, decision, status) {
+        const runs = new RunStore();
+        try {
+          const run = runs.getRun(approval.runId);
+          if (run?.status === "needs_input") runs.transition(approval.runId, "running", `approval_${status}:${approval.id}`);
+        } finally {
+          runs.close();
+        }
+        store.updateConversationStatus(approval.conversationId, approval.runId, "running", { approvalId: approval.id, decision: status });
+        store.appendEvent(approval.conversationId, approval.runId, status === "expired" ? "approval.expired" : "approval.resolved", {
+          approvalId: approval.id,
+          decision: status === "expired" ? "deny" : decision
+        });
+        const waiter = this.waiters.get(approval.id);
+        if (waiter) {
+          clearTimeout(waiter.timer);
+          this.waiters.delete(approval.id);
+          waiter.resolve(status === "expired" ? "deny" : decision);
+        }
+      }
+      async cancelConversation(res, store, conversation) {
+        const runId = conversation.activeRunId;
+        if (!runId) {
+          json(res, 200, publicConversation(conversation));
+          return;
+        }
+        const approvals = store.cancelPendingApprovals(conversation.id);
+        for (const approval of approvals) {
+          const waiter = this.waiters.get(approval.id);
+          if (waiter) {
+            clearTimeout(waiter.timer);
+            this.waiters.delete(approval.id);
+            waiter.resolve("deny");
+          }
+          store.appendEvent(conversation.id, runId, "approval.resolved", { approvalId: approval.id, decision: "cancelled" });
+        }
+        const runs = new RunStore();
+        try {
+          const run = runs.getRun(runId);
+          if (run && ["queued", "running", "waiting", "needs_input"].includes(run.status)) {
+            runs.transition(runId, "cancelled", "cancelled_by_aster_client");
+            runs.cancelTimersForRun(runId);
+          }
+        } finally {
+          runs.close();
+        }
+        this.runtime.cancelRun(runId);
+        store.updateConversationStatus(conversation.id, runId, "cancelled", { reason: "client_cancelled" });
+        store.appendEvent(conversation.id, runId, "cancelled", { code: "cancelled_by_client" });
+        const updated = store.getConversation(conversation.id);
+        json(res, 200, updated ? publicConversation(updated) : { conversationId: conversation.id, status: "cancelled" });
+      }
+      streamEvents(req, res, store, conversationId, cursor) {
+        res.writeHead(200, {
+          "Content-Type": "text/event-stream; charset=utf-8",
+          "Cache-Control": "no-cache, no-store",
+          Connection: "keep-alive",
+          "X-Accel-Buffering": "no"
+        });
+        let last = cursor;
+        let closed = false;
+        let polling = false;
+        let lastHeartbeat = Date.now();
+        const pump = async () => {
+          if (closed || polling) return;
+          polling = true;
+          try {
+            const events = store.eventsAfter(conversationId, last, 200);
+            for (const event of events) {
+              if (closed) break;
+              res.write(`id: ${event.sequence}
+event: ${event.type}
+data: ${JSON.stringify(event.data)}
+
+`);
+              last = event.sequence;
+            }
+            if (!events.length && Date.now() - lastHeartbeat >= 15e3) {
+              res.write(": heartbeat\n\n");
+              lastHeartbeat = Date.now();
+            }
+          } catch {
+            closed = true;
+            res.end();
+          } finally {
+            polling = false;
+            if (!closed) setTimeout(() => {
+              void pump();
+            }, 500).unref();
+          }
+        };
+        res.on("close", () => {
+          closed = true;
+        });
+        void pump();
+      }
+      async recover(store) {
+        if (this.recovery) return this.recovery;
+        this.recovery = (async () => {
+          const runs = new RunStore();
+          try {
+            runs.reconcileInterruptedRuns();
+            for (const approval of store.expireAllPendingApprovals()) {
+              const run = runs.getRun(approval.runId);
+              if (run && ["queued", "running", "waiting", "needs_input"].includes(run.status)) {
+                runs.transition(run.id, "cancelled", "server_restarted_during_approval");
+                runs.cancelTimersForRun(run.id);
+              }
+              store.updateConversationStatus(approval.conversationId, approval.runId, "interrupted", { reason: "server_restart_during_approval" });
+              store.appendEvent(approval.conversationId, approval.runId, "approval.expired", { approvalId: approval.id });
+            }
+            for (const conversation of store.listActiveConversations()) {
+              const run = conversation.activeRunId ? runs.getRun(conversation.activeRunId) : void 0;
+              if (!run || ["interrupted_unknown", "cancelled", "failed", "completed"].includes(run.status)) {
+                const status = run?.status === "completed" ? "completed" : run?.status === "cancelled" ? "cancelled" : "interrupted";
+                store.updateConversationStatus(conversation.id, conversation.activeRunId, status, { reason: "server_restart_recovery" });
+              } else if (run.status === "needs_input") {
+                runs.transition(run.id, "cancelled", "approval_expired_on_restart");
+                store.updateConversationStatus(conversation.id, run.id, "interrupted", { reason: "approval_expired_on_restart" });
+              }
+            }
+          } finally {
+            runs.close();
+          }
+        })();
+        return this.recovery;
+      }
+      async requireConversation(store, principal, id) {
+        if (!CONVERSATION_ID_RE.test(id)) return void 0;
+        const conversation = store.getConversation(id);
+        return conversation && principal.workspaceIds.includes(conversation.workspaceId) ? conversation : void 0;
+      }
+    };
+  }
+});
+
 // src/server/routes.ts
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 import { URL as URL2 } from "url";
-import { readFile as readFile17, unlink as unlink2 } from "fs/promises";
-import { resolve as resolve8, basename as basename5 } from "path";
-function json(res, status, data) {
+import { readFile as readFile18, unlink as unlink3 } from "fs/promises";
+import { resolve as resolve9, basename as basename5 } from "path";
+function json2(res, status, data) {
   res.writeHead(status, { "Content-Type": "application/json" });
   res.end(JSON.stringify(data));
 }
 function badRequest(res, message2) {
-  json(res, 400, { error: message2 });
+  json2(res, 400, { error: message2 });
 }
 function notFound(res, message2) {
-  json(res, 404, { error: message2 });
+  json2(res, 404, { error: message2 });
 }
 async function readBody(req) {
   const chunks = [];
@@ -13336,9 +14606,9 @@ async function resolveFiles2(filePatterns, cwd) {
   const resolved = /* @__PURE__ */ new Set();
   for (const pattern of filePatterns) {
     try {
-      const stat9 = await import("fs/promises").then((m) => m.stat(resolve8(cwd, pattern)));
-      if (stat9.isFile()) {
-        resolved.add(resolve8(cwd, pattern));
+      const stat10 = await import("fs/promises").then((m) => m.stat(resolve9(cwd, pattern)));
+      if (stat10.isFile()) {
+        resolved.add(resolve9(cwd, pattern));
         continue;
       }
     } catch {
@@ -13366,7 +14636,7 @@ async function buildUserMessage2(prompt, files, cwd) {
       }
     } else {
       try {
-        const content = await readFile17(filePath, "utf8");
+        const content = await readFile18(filePath, "utf8");
         const relPath = filePath.startsWith(cwd) ? filePath.slice(cwd.length + 1) : filePath;
         fileContents.push(`
 --- ${relPath} ---
@@ -13391,6 +14661,29 @@ ${content}
   return text;
 }
 function setupRoutes(config2) {
+  const asterApi = new AsterApi(config2, {
+    startTurn: (turn) => {
+      const active = {
+        sessionFile: turn.sessionFile,
+        messages: turn.messages,
+        executor: turn.executor,
+        sseClients: /* @__PURE__ */ new Set(),
+        runId: turn.runId,
+        allowedTools: turn.allowedTools,
+        maxToolIterations: turn.maxToolIterations,
+        maxRuntimeMs: turn.maxRuntimeMs,
+        conversationId: turn.conversation.id,
+        workspaceRoot: turn.conversation.worktreePath,
+        askAsterPermission: turn.askPermission,
+        publishAsterEvent: turn.publishEvent,
+        finishAsterTurn: turn.finish
+      };
+      activeSessions.set(turn.sessionFile.id, active);
+      activeRuns.set(turn.runId, active);
+      launchAgentTurnForSession(active, config2, false);
+    },
+    cancelRun: (runId) => activeRuns.get(runId)?.controller?.abort(new Error("cancelled_by_aster_client"))
+  });
   const wakeScheduler = new RunWakeScheduler({
     onWake: async (event) => {
       const store = new RunStore();
@@ -13405,7 +14698,7 @@ function setupRoutes(config2) {
       }
       let active = activeRuns.get(run.id) ?? activeSessions.get(run.sessionId);
       if (!active) {
-        const sessionFile = await loadSession(resolve8(sessionsDir(), `${run.sessionId}.json`));
+        const sessionFile = await loadSession(resolve9(sessionsDir(), `${run.sessionId}.json`));
         const allowedTools = new Set(run.allowedTools);
         allowedTools.add("wait_for");
         const tools = ALL_TOOLS.filter((tool) => allowedTools.has(tool.name));
@@ -13435,9 +14728,13 @@ function setupRoutes(config2) {
     const url = new URL2(req.url ?? "/", `http://${req.headers.host}`);
     const method = req.method ?? "GET";
     const pathname = url.pathname;
+    if (pathname.startsWith("/api/v1/")) {
+      await asterApi.handle(req, res);
+      return;
+    }
     try {
       if (pathname === "/" && method === "GET") {
-        json(res, 200, { status: "ok", version: process.env.npm_package_version ?? "dev" });
+        json2(res, 200, { status: "ok", version: process.env.npm_package_version ?? "dev" });
         return;
       }
       if (pathname === "/doc" && method === "GET") {
@@ -13448,13 +14745,13 @@ function setupRoutes(config2) {
       const runPathMatch = pathname.match(/^\/runs\/([^/]+)(?:\/(events|cancel))?$/);
       if (pathname === "/runs" && method === "GET") {
         if (!process.env.KIMIFLARE_SERVER_PASSWORD) {
-          json(res, 503, { error: "Set KIMIFLARE_SERVER_PASSWORD before accessing unattended runs" });
+          json2(res, 503, { error: "Set KIMIFLARE_SERVER_PASSWORD before accessing unattended runs" });
           return;
         }
         const store = new RunStore();
         try {
           const limit = Number(url.searchParams.get("limit") ?? 50);
-          json(res, 200, { runs: store.listRuns({ limit }) });
+          json2(res, 200, { runs: store.listRuns({ limit }) });
         } finally {
           store.close();
         }
@@ -13462,7 +14759,7 @@ function setupRoutes(config2) {
       }
       if (pathname === "/runs" && method === "POST") {
         if (!process.env.KIMIFLARE_SERVER_PASSWORD) {
-          json(res, 503, { error: "Set KIMIFLARE_SERVER_PASSWORD before creating unattended runs" });
+          json2(res, 503, { error: "Set KIMIFLARE_SERVER_PASSWORD before creating unattended runs" });
           return;
         }
         const parsedBody = await readBody(req);
@@ -13474,7 +14771,7 @@ function setupRoutes(config2) {
         const task = typeof body.task === "string" ? body.task.trim() : "";
         let cwd;
         try {
-          cwd = typeof body.cwd === "string" ? resolve8(body.cwd) : process.cwd();
+          cwd = typeof body.cwd === "string" ? resolve9(body.cwd) : process.cwd();
         } catch {
           badRequest(res, "cwd must be a valid path");
           return;
@@ -13547,7 +14844,7 @@ function setupRoutes(config2) {
         const executor = new ToolExecutor(tools);
         const { makeSessionId: makeSessionId2 } = await Promise.resolve().then(() => (init_sessions(), sessions_exports));
         const sessionId = makeSessionId2(task);
-        const runId = randomUUID5();
+        const runId = randomUUID7();
         const worktreeManager = new RunWorktreeManager();
         let worktree;
         if (useWorktree) {
@@ -13596,7 +14893,7 @@ function setupRoutes(config2) {
             store.close();
           }
         } catch (error) {
-          await unlink2(resolve8(sessionsDir(), `${sessionId}.json`)).catch(() => {
+          await unlink3(resolve9(sessionsDir(), `${sessionId}.json`)).catch(() => {
           });
           if (worktree) {
             await worktreeManager.discard(worktree).catch((cleanupError) => {
@@ -13618,7 +14915,7 @@ function setupRoutes(config2) {
         activeSessions.set(sessionId, active);
         activeRuns.set(run.id, active);
         launchAgentTurnForSession(active, config2, false);
-        json(res, 202, {
+        json2(res, 202, {
           runId: run.id,
           sessionId,
           status: "running",
@@ -13628,7 +14925,7 @@ function setupRoutes(config2) {
       }
       if (runPathMatch) {
         if (!process.env.KIMIFLARE_SERVER_PASSWORD) {
-          json(res, 503, { error: "Set KIMIFLARE_SERVER_PASSWORD before accessing unattended runs" });
+          json2(res, 503, { error: "Set KIMIFLARE_SERVER_PASSWORD before accessing unattended runs" });
           return;
         }
         const runId = runPathMatch[1];
@@ -13641,7 +14938,7 @@ function setupRoutes(config2) {
             return;
           }
           if (suffix === "events" && method === "GET") {
-            json(res, 200, { events: store.listEvents(runId) });
+            json2(res, 200, { events: store.listEvents(runId) });
             return;
           }
           if (suffix === "cancel" && method === "POST") {
@@ -13650,11 +14947,11 @@ function setupRoutes(config2) {
               store.transition(runId, "cancelled", "cancelled_by_client");
               store.cancelTimersForRun(runId);
             }
-            json(res, 200, { run: store.getRun(runId) });
+            json2(res, 200, { run: store.getRun(runId) });
             return;
           }
           if (!suffix && method === "GET") {
-            json(res, 200, { run });
+            json2(res, 200, { run });
             return;
           }
         } finally {
@@ -13669,7 +14966,7 @@ function setupRoutes(config2) {
       if (pathname === "/session" && method === "GET") {
         const cwd = url.searchParams.get("cwd") ?? void 0;
         const sessions = await listSessions(30, cwd);
-        json(res, 200, { sessions });
+        json2(res, 200, { sessions });
         return;
       }
       const sessionMatch = pathname.match(/^\/session\/([^/]+)$/);
@@ -13677,7 +14974,7 @@ function setupRoutes(config2) {
         const sessionId = sessionMatch[1];
         const active = activeSessions.get(sessionId);
         if (active) {
-          json(res, 200, {
+          json2(res, 200, {
             id: active.sessionFile.id,
             cwd: active.sessionFile.cwd,
             model: active.sessionFile.model,
@@ -13688,8 +14985,8 @@ function setupRoutes(config2) {
           return;
         }
         try {
-          const file = await loadSession(resolve8(sessionsDir(), `${sessionId}.json`));
-          json(res, 200, {
+          const file = await loadSession(resolve9(sessionsDir(), `${sessionId}.json`));
+          json2(res, 200, {
             id: file.id,
             cwd: file.cwd,
             model: file.model,
@@ -13707,11 +15004,11 @@ function setupRoutes(config2) {
         const sessionId = sessionMatch[1];
         activeSessions.delete(sessionId);
         try {
-          const { unlink: unlink5 } = await import("fs/promises");
-          await unlink5(resolve8(sessionsDir(), `${sessionId}.json`));
+          const { unlink: unlink6 } = await import("fs/promises");
+          await unlink6(resolve9(sessionsDir(), `${sessionId}.json`));
         } catch {
         }
-        json(res, 200, { deleted: sessionId });
+        json2(res, 200, { deleted: sessionId });
         return;
       }
       if (pathname === "/prompt" && method === "POST") {
@@ -13755,7 +15052,7 @@ function setupRoutes(config2) {
         };
         activeSessions.set(sessionId, active);
         launchAgentTurnForSession(active, config2, allowAll);
-        json(res, 202, { sessionId, status: "started" });
+        json2(res, 202, { sessionId, status: "started" });
         return;
       }
       if (pathname === "/session/:id/prompt" && method === "POST") {
@@ -13780,13 +15077,13 @@ function setupRoutes(config2) {
         const userContent = await buildUserMessage2(prompt, resolvedFiles, active.sessionFile.cwd);
         active.messages.push({ role: "user", content: userContent });
         launchAgentTurnForSession(active, config2, allowAll);
-        json(res, 202, { sessionId, status: "started" });
+        json2(res, 202, { sessionId, status: "started" });
         return;
       }
       notFound(res, `unknown endpoint: ${method} ${pathname}`);
     } catch (err) {
       logger.error("server: request error", { error: err.message, path: pathname });
-      json(res, 500, { error: err.message });
+      json2(res, 500, { error: err.message });
     }
   }
   function cleanup() {
@@ -13799,13 +15096,17 @@ function setupRoutes(config2) {
     }
     activeRuns.clear();
     activeSessions.clear();
+    asterApi.close();
   }
   return { handleRequest, cleanup };
 }
 function launchAgentTurnForSession(active, config2, allowAll) {
   void runAgentTurnForSession(active, config2, allowAll).catch((error) => {
     const message2 = error instanceof Error ? error.message : String(error);
-    logger.error("server: agent turn startup failed", { sessionId: active.sessionFile.id, error: message2 });
+    logger.error("server: agent turn startup failed", {
+      sessionId: active.sessionFile.id,
+      error: active.conversationId ? "aster_agent_start_failed" : redactLikelySecrets(message2)
+    });
     active.running = false;
     active.controller = void 0;
     if (!active.runId) return;
@@ -13814,7 +15115,7 @@ function launchAgentTurnForSession(active, config2, allowAll) {
       try {
         const run = store.getRun(active.runId);
         if (run && ["queued", "running", "waiting"].includes(run.status)) {
-          store.transition(run.id, "failed", `server_turn_start_failed:${message2}`.slice(0, 500));
+          store.transition(run.id, "failed", active.conversationId ? "aster_agent_start_failed" : `server_turn_start_failed:${redactLikelySecrets(message2)}`.slice(0, 500));
           store.cancelTimersForRun(run.id);
         }
       } finally {
@@ -13823,7 +15124,7 @@ function launchAgentTurnForSession(active, config2, allowAll) {
     } catch (storeError) {
       logger.error("server: failed to record agent startup failure", {
         runId: active.runId,
-        error: storeError instanceof Error ? storeError.message : String(storeError)
+        error: active.conversationId ? "aster_run_state_update_failed" : storeError instanceof Error ? redactLikelySecrets(storeError.message) : "unknown"
       });
     }
   });
@@ -13844,6 +15145,7 @@ async function runAgentTurnForSession(active, config2, allowAll) {
     if (!run || run.status !== "running") {
       runStore.close();
       active.running = false;
+      active.finishAsterTurn?.("failed", "run_not_active");
       return;
     }
     const elapsed = run.startedAt ? Date.now() - run.startedAt : 0;
@@ -13853,11 +15155,15 @@ async function runAgentTurnForSession(active, config2, allowAll) {
   }
   const callbacks = {
     onTextDelta: (delta) => {
+      if (active.publishAsterEvent) active.publishAsterEvent("assistant.delta", { delta: redactLikelySecrets(delta) });
       for (const client of active.sseClients) {
         client.send("assistant.delta", { delta });
       }
     },
     onToolCallFinalized: (call) => {
+      if (active.publishAsterEvent) {
+        active.publishAsterEvent("tool.activity", { tool: call.function.name, activity: "proposed" });
+      }
       for (const client of active.sseClients) {
         client.send("tool.call", {
           id: call.id,
@@ -13867,6 +15173,9 @@ async function runAgentTurnForSession(active, config2, allowAll) {
       }
     },
     onToolResult: (result2) => {
+      if (active.publishAsterEvent) {
+        active.publishAsterEvent("tool.activity", { tool: result2.name, activity: result2.ok ? "completed" : "failed", ok: result2.ok });
+      }
       for (const client of active.sseClients) {
         client.send("tool.result", {
           toolCallId: result2.tool_call_id,
@@ -13877,6 +15186,14 @@ async function runAgentTurnForSession(active, config2, allowAll) {
       }
     },
     onUsage: (usage) => {
+      if (active.publishAsterEvent) {
+        active.publishAsterEvent("usage", {
+          promptTokens: usage.prompt_tokens,
+          completionTokens: usage.completion_tokens,
+          totalTokens: usage.total_tokens,
+          ...usage.cost !== void 0 ? { costUsd: usage.cost } : {}
+        });
+      }
       for (const client of active.sseClients) {
         client.send("usage.update", {
           promptTokens: usage.prompt_tokens,
@@ -13895,6 +15212,7 @@ async function runAgentTurnForSession(active, config2, allowAll) {
       if (result2.budgetExceededReason) throw new Error(result2.budgetExceededReason);
     },
     onWarning: (msg) => {
+      if (active.publishAsterEvent) active.publishAsterEvent("status", { detail: redactLikelySecrets(msg) });
       for (const client of active.sseClients) {
         client.send("warning", { message: msg });
       }
@@ -13902,9 +15220,11 @@ async function runAgentTurnForSession(active, config2, allowAll) {
     onRunYield: (request) => {
       if (!runStore || !active.runId || request.runId !== active.runId) return;
       runStore.transition(active.runId, "waiting", `timer:${request.timerId}`);
+      active.publishAsterEvent?.("status", { status: "waiting", condition: request.condition, wakeAt: request.wakeAt });
       yielded = true;
     },
-    askPermission: async ({ tool, args }) => {
+    askPermission: async ({ tool, args, sessionKey }) => {
+      if (active.askAsterPermission) return active.askAsterPermission({ tool, args, sessionKey });
       if (active.runId) {
         if (active.allowedTools?.has(tool.name)) return "allow";
         return "deny";
@@ -13984,11 +15304,13 @@ async function runAgentTurnForSession(active, config2, allowAll) {
       const current = runStore.getRun(active.runId);
       if (current?.status === "running" && !yielded) runStore.transition(active.runId, "completed");
     }
+    active.finishAsterTurn?.("completed");
     for (const client of active.sseClients) {
       client.send("session.completed", { sessionId: sessionFile.id });
     }
   } catch (err) {
-    const message2 = err.message;
+    const rawMessage = err.message;
+    const message2 = active.conversationId ? "aster_agent_turn_failed" : redactLikelySecrets(rawMessage);
     logger.error("server: agent turn failed", { sessionId: sessionFile.id, error: message2 });
     if (runStore && active.runId) {
       const current = runStore.getRun(active.runId);
@@ -13997,6 +15319,11 @@ async function runAgentTurnForSession(active, config2, allowAll) {
         runStore.transition(active.runId, "failed", reason);
       }
     }
+    if (active.finishAsterTurn) {
+      const runStatus = active.runId ? runStore?.getRun(active.runId)?.status : void 0;
+      const finalStatus = runStatus === "cancelled" ? "cancelled" : runStatus === "completed" ? "completed" : "failed";
+      active.finishAsterTurn(finalStatus, finalStatus === "failed" ? "agent_turn_failed" : void 0);
+    }
     for (const client of active.sseClients) {
       client.send("error", { message: message2, sessionId: sessionFile.id });
     }
@@ -14026,6 +15353,8 @@ var init_routes = __esm({
     init_store();
     init_worktrees();
     init_wake_scheduler();
+    init_aster_api();
+    init_aster_tools();
     activeSessions = /* @__PURE__ */ new Map();
     activeRuns = /* @__PURE__ */ new Map();
   }
@@ -14040,16 +15369,19 @@ import { createServer } from "http";
 async function startServer(opts2) {
   const { handleRequest, cleanup } = setupRoutes(opts2.config);
   const server = createServer((req, res) => {
-    res.setHeader("Access-Control-Allow-Origin", "*");
-    res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
-    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization, Last-Event-ID");
-    if (req.method === "OPTIONS") {
+    const isAsterApi = req.url?.startsWith("/api/v1/") === true;
+    if (!isAsterApi) {
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+      res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization, Last-Event-ID");
+    }
+    if (req.method === "OPTIONS" && !isAsterApi) {
       res.writeHead(204);
       res.end();
       return;
     }
     const password = process.env.KIMIFLARE_SERVER_PASSWORD;
-    if (password) {
+    if (!isAsterApi && password) {
       const auth = req.headers.authorization ?? "";
       const expected = "Basic " + Buffer.from(`kimiflare:${password}`).toString("base64");
       if (auth !== expected) {
@@ -14060,6 +15392,9 @@ async function startServer(opts2) {
     }
     void handleRequest(req, res);
   });
+  server.headersTimeout = 1e4;
+  server.requestTimeout = 3e4;
+  server.keepAliveTimeout = 5e3;
   server.on("close", () => {
     cleanup();
   });
@@ -14076,13 +15411,13 @@ async function startServer(opts2) {
   };
   process.on("SIGINT", shutdown);
   process.on("SIGTERM", shutdown);
-  return new Promise((resolve14, reject) => {
+  return new Promise((resolve15, reject) => {
     server.listen(opts2.port, opts2.hostname, () => {
       logger.info("server: listening", { hostname: opts2.hostname, port: opts2.port });
       console.log(`kimiflare serve: http://${opts2.hostname}:${opts2.port}`);
       console.log(`  API docs: http://${opts2.hostname}:${opts2.port}/doc`);
       console.log(`  SSE stream: http://${opts2.hostname}:${opts2.port}/event`);
-      resolve14(server);
+      resolve15(server);
     });
     server.on("error", reject);
   });
@@ -14132,9 +15467,9 @@ __export(db_exports, {
   updateAccessedAt: () => updateAccessedAt,
   updateMemoryEmbedding: () => updateMemoryEmbedding
 });
-import Database3 from "better-sqlite3";
-import { dirname as dirname12 } from "path";
-import { mkdirSync as mkdirSync6, statSync as statSync4 } from "fs";
+import Database4 from "better-sqlite3";
+import { dirname as dirname13 } from "path";
+import { mkdirSync as mkdirSync7, statSync as statSync4 } from "fs";
 function initSchema(db) {
   db.exec(`
     CREATE TABLE IF NOT EXISTS memories (
@@ -14218,8 +15553,8 @@ function openMemoryDb(dbPath) {
   if (dbInstance) {
     dbInstance.close();
   }
-  mkdirSync6(dirname12(dbPath), { recursive: true });
-  dbInstance = new Database3(dbPath);
+  mkdirSync7(dirname13(dbPath), { recursive: true });
+  dbInstance = new Database4(dbPath);
   dbInstance.pragma("journal_mode = WAL");
   dbInstance.pragma("foreign_keys = ON");
   initSchema(dbInstance);
@@ -15214,7 +16549,7 @@ var init_connection = __esm({
         if (this.child) {
           throw new Error("LSP connection already started");
         }
-        return new Promise((resolve14, reject) => {
+        return new Promise((resolve15, reject) => {
           const abortController = new AbortController();
           const spawnTimer = setTimeout(() => {
             abortController.abort();
@@ -15253,7 +16588,7 @@ var init_connection = __esm({
               if (child.pid) {
                 clearTimeout(spawnTimer);
                 this.child = child;
-                resolve14();
+                resolve15();
               }
             });
           } catch (err) {
@@ -15268,12 +16603,12 @@ var init_connection = __esm({
         }
         const id = this.nextId++;
         const msg = { jsonrpc: "2.0", id, method, params };
-        return new Promise((resolve14, reject) => {
+        return new Promise((resolve15, reject) => {
           const timer3 = setTimeout(() => {
             this.pending.delete(id);
             reject(toolTimeoutError(`LSP request '${method}'`, this.requestTimeoutMs));
           }, this.requestTimeoutMs);
-          const pending = { resolve: resolve14, reject, signal, timer: timer3 };
+          const pending = { resolve: resolve15, reject, signal, timer: timer3 };
           this.pending.set(id, pending);
           if (signal) {
             const onAbort = () => {
@@ -15837,10 +17172,10 @@ var init_manager4 = __esm({
 });
 
 // src/lsp/adapter.ts
-import { relative as relative6 } from "path";
+import { relative as relative8 } from "path";
 function formatLocation(loc, cwd) {
   const path = fromUri(loc.uri);
-  const rel = relative6(cwd, path) || path;
+  const rel = relative8(cwd, path) || path;
   return `${rel}:${loc.range.start.line + 1}:${loc.range.start.character + 1}`;
 }
 function formatLocations(locs, cwd) {
@@ -15877,7 +17212,7 @@ function formatWorkspaceSymbols(symbols, cwd) {
   if (!symbols || symbols.length === 0) return "No symbols found.";
   return symbols.map((s) => {
     const path = fromUri(s.location.uri);
-    const rel = relative6(cwd, path) || path;
+    const rel = relative8(cwd, path) || path;
     const container = s.containerName ? ` in ${s.containerName}` : "";
     return `${s.name} (${symbolKindName(s.kind)})${container} \u2014 ${rel}:${s.location.range.start.line + 1}:${s.location.range.start.character + 1}`;
   }).join("\n");
@@ -15897,7 +17232,7 @@ function formatWorkspaceEdit(edit, cwd) {
   if (edit.changes) {
     for (const [uri, edits] of Object.entries(edit.changes)) {
       const path = fromUri(uri);
-      const rel = relative6(cwd, path) || path;
+      const rel = relative8(cwd, path) || path;
       lines.push(`File: ${rel}`);
       for (const e of edits) {
         lines.push(`  ${e.range.start.line + 1}:${e.range.start.character + 1}-${e.range.end.line + 1}:${e.range.end.character + 1}: ${e.newText}`);
@@ -15922,7 +17257,7 @@ var init_adapter = __esm({
 });
 
 // src/tools/lsp.ts
-import { relative as relative7 } from "path";
+import { relative as relative9 } from "path";
 function makeOutput2(content) {
   const bytes = Buffer.byteLength(content, "utf8");
   return { content, rawBytes: bytes, reducedBytes: bytes };
@@ -15930,7 +17265,7 @@ function makeOutput2(content) {
 function resolveLspPath(args, ctx) {
   const raw = typeof args.path === "string" ? args.path : "";
   const resolved = resolvePath(ctx.cwd, raw);
-  const rel = relative7(ctx.cwd, resolved);
+  const rel = relative9(ctx.cwd, resolved);
   if (isPathOutside(rel)) {
     throw new Error(`Path outside workspace: ${raw}`);
   }
@@ -16196,12 +17531,12 @@ __export(openrouter_catalog_exports, {
   loadOpenRouterCatalog: () => loadOpenRouterCatalog,
   mapOpenRouterModel: () => mapOpenRouterModel
 });
-import { readFile as readFile18, writeFile as writeFile11, mkdir as mkdir11 } from "fs/promises";
-import { homedir as homedir19 } from "os";
-import { join as join27, dirname as dirname13 } from "path";
+import { readFile as readFile19, writeFile as writeFile11, mkdir as mkdir11 } from "fs/promises";
+import { homedir as homedir20 } from "os";
+import { join as join28, dirname as dirname14 } from "path";
 function catalogCachePath() {
-  const xdg = process.env.XDG_CONFIG_HOME || join27(homedir19(), ".config");
-  return join27(xdg, "kimiflare", "openrouter-models.json");
+  const xdg = process.env.XDG_CONFIG_HOME || join28(homedir20(), ".config");
+  return join28(xdg, "kimiflare", "openrouter-models.json");
 }
 function perMtok(perToken) {
   const n = Number(perToken);
@@ -16252,7 +17587,7 @@ async function fetchOpenRouterCatalog(fetchImpl2 = fetch) {
 }
 async function readCache2() {
   try {
-    const raw = await readFile18(catalogCachePath(), "utf8");
+    const raw = await readFile19(catalogCachePath(), "utf8");
     const parsed = JSON.parse(raw);
     return parsed.version === CACHE_VERSION ? parsed : null;
   } catch {
@@ -16262,7 +17597,7 @@ async function readCache2() {
 async function writeCache2(models) {
   const path = catalogCachePath();
   try {
-    await mkdir11(dirname13(path), { recursive: true });
+    await mkdir11(dirname14(path), { recursive: true });
     const cache = { version: CACHE_VERSION, fetchedAt: (/* @__PURE__ */ new Date()).toISOString(), models };
     await writeFile11(path, JSON.stringify(cache, null, 2), "utf8");
   } catch {
@@ -16311,12 +17646,12 @@ __export(requesty_catalog_exports, {
   loadRequestyCatalog: () => loadRequestyCatalog,
   mapRequestyModel: () => mapRequestyModel
 });
-import { readFile as readFile19, writeFile as writeFile12, mkdir as mkdir12 } from "fs/promises";
-import { homedir as homedir20 } from "os";
-import { join as join28, dirname as dirname14 } from "path";
+import { readFile as readFile20, writeFile as writeFile12, mkdir as mkdir12 } from "fs/promises";
+import { homedir as homedir21 } from "os";
+import { join as join29, dirname as dirname15 } from "path";
 function catalogCachePath2() {
-  const xdg = process.env.XDG_CONFIG_HOME || join28(homedir20(), ".config");
-  return join28(xdg, "kimiflare", "requesty-models.json");
+  const xdg = process.env.XDG_CONFIG_HOME || join29(homedir21(), ".config");
+  return join29(xdg, "kimiflare", "requesty-models.json");
 }
 function isSafeModelId(id) {
   return typeof id === "string" && id.length > 0 && !CONTROL_CHARS.test(id);
@@ -16372,7 +17707,7 @@ async function fetchRequestyCatalog(fetchImpl2 = fetch) {
 }
 async function readCache3() {
   try {
-    const raw = await readFile19(catalogCachePath2(), "utf8");
+    const raw = await readFile20(catalogCachePath2(), "utf8");
     const parsed = JSON.parse(raw);
     if (parsed.version !== CACHE_VERSION2) return null;
     return {
@@ -16387,7 +17722,7 @@ async function readCache3() {
 async function writeCache3(catalog) {
   const path = catalogCachePath2();
   try {
-    await mkdir12(dirname14(path), { recursive: true });
+    await mkdir12(dirname15(path), { recursive: true });
     const cache = { version: CACHE_VERSION2, fetchedAt: (/* @__PURE__ */ new Date()).toISOString(), ...catalog };
     await writeFile12(path, JSON.stringify(cache, null, 2), "utf8");
   } catch {
@@ -16478,15 +17813,15 @@ var init_permissions = __esm({
 });
 
 // src/sdk/session.ts
-import { resolve as resolve9 } from "path";
-import { homedir as homedir21 } from "os";
-import { join as join29 } from "path";
+import { resolve as resolve10 } from "path";
+import { homedir as homedir22 } from "os";
+import { join as join30 } from "path";
 import { existsSync as existsSync4 } from "fs";
 async function createAgentSession(opts2) {
   const config2 = await resolveSdkConfig(opts2);
   if (usesRequesty(llmAuthFromConfig(config2))) await ensureRequestyCatalog();
   else if (!resolveCustomEndpoint(config2)) await ensureOpenRouterCatalog();
-  const cwd = resolve9(opts2.cwd ?? process.cwd());
+  const cwd = resolve10(opts2.cwd ?? process.cwd());
   const tools = opts2.tools ?? ALL_TOOLS;
   let hooks;
   if (opts2.enableHooks) {
@@ -16497,7 +17832,7 @@ async function createAgentSession(opts2) {
   let memoryManager = null;
   const memoryEnabled = opts2.memoryEnabled ?? config2.memoryEnabled ?? false;
   if (memoryEnabled) {
-    const dbPath = config2.memoryDbPath ?? join29(homedir21(), ".local", "share", "kimiflare", "memory.db");
+    const dbPath = config2.memoryDbPath ?? join30(homedir22(), ".local", "share", "kimiflare", "memory.db");
     memoryManager = new MemoryManager({
       dbPath,
       ...llmAuthFromConfig(config2),
@@ -16527,7 +17862,7 @@ async function createAgentSession(opts2) {
   }
   let sessionFile;
   if (opts2.sessionId) {
-    const filePath = join29(sessionsDir(), `${opts2.sessionId}.json`);
+    const filePath = join30(sessionsDir(), `${opts2.sessionId}.json`);
     try {
       sessionFile = await loadSession(filePath);
     } catch {
@@ -16690,8 +18025,8 @@ var init_session = __esm({
           const parts = [{ type: "text", text }];
           for (const img of options.images) {
             if ("path" in img) {
-              const { readFile: readFile29 } = await import("fs/promises");
-              const data = await readFile29(img.path, "base64");
+              const { readFile: readFile30 } = await import("fs/promises");
+              const data = await readFile30(img.path, "base64");
               const mimeType = img.path.endsWith(".png") ? "image/png" : img.path.endsWith(".jpg") || img.path.endsWith(".jpeg") ? "image/jpeg" : "image/webp";
               parts.push({ type: "image_url", image_url: { url: `data:${mimeType};base64,${data}` } });
             } else {
@@ -16894,12 +18229,12 @@ var init_session = __esm({
               toolName: req.tool.name,
               args: req.args
             });
-            const decision = await new Promise((resolve14) => {
-              this.permissionResolvers.set(requestId, resolve14);
+            const decision = await new Promise((resolve15) => {
+              this.permissionResolvers.set(requestId, resolve15);
               setTimeout(() => {
                 if (this.permissionResolvers.has(requestId)) {
                   this.permissionResolvers.delete(requestId);
-                  resolve14("deny");
+                  resolve15("deny");
                 }
               }, 3e5);
             });
@@ -16948,14 +18283,14 @@ var init_session = __esm({
               this.lspManager?.notifyChange(path, content);
             } else {
               void import("fs/promises").then(
-                ({ readFile: readFile29 }) => readFile29(path, "utf8").then((c) => this.lspManager?.notifyChange(path, c)).catch(() => {
+                ({ readFile: readFile30 }) => readFile30(path, "utf8").then((c) => this.lspManager?.notifyChange(path, c)).catch(() => {
                 })
               ).catch(() => {
               });
             }
           }
         });
-        if (["AGENTS.md", "KIMI.md", "KIMIFLARE.md", "AGENT.md"].some((name) => existsSync4(join29(this.cwd, name)))) {
+        if (["AGENTS.md", "KIMI.md", "KIMIFLARE.md", "AGENT.md"].some((name) => existsSync4(join30(this.cwd, name)))) {
           this.messages[0] = {
             role: "system",
             content: buildSystemPrompt({
@@ -17202,20 +18537,20 @@ var init_repo_info = __esm({
 });
 
 // src/agent/supervisor.ts
-import { readdir as readdir5, readFile as readFile20, stat as stat6 } from "fs/promises";
-import { createHash as createHash3 } from "crypto";
-import { resolve as resolve10, join as join30 } from "path";
+import { readdir as readdir5, readFile as readFile21, stat as stat7 } from "fs/promises";
+import { createHash as createHash4 } from "crypto";
+import { resolve as resolve11, join as join31 } from "path";
 async function preReadFilesForWorkers(files, repoRoot, maxChars = DEFAULT_PRE_READ_MAX_CHARS) {
   const results = [];
   const filesRead = [];
   let chars = 0;
   for (const file of files) {
     if (chars >= maxChars) break;
-    const path = resolve10(repoRoot, file);
+    const path = resolve11(repoRoot, file);
     try {
-      const s = await stat6(path);
+      const s = await stat7(path);
       if (!s.isFile()) continue;
-      const raw = await readFile20(path, "utf8");
+      const raw = await readFile21(path, "utf8");
       const remaining = maxChars - chars;
       const content = raw.length > remaining ? raw.slice(0, remaining) + "\n\u2026 (truncated)" : raw;
       results.push(`--- ${file} ---
@@ -17239,7 +18574,7 @@ ${results.join("\n\n")}`,
 }
 function getPreReadFilesFromMemory(cfg, repoRoot, limit = 10) {
   if (!cfg.memoryEnabled) return [];
-  const dbPath = cfg.memoryDbPath ?? join30(repoRoot, ".kimiflare", "memory.db");
+  const dbPath = cfg.memoryDbPath ?? join31(repoRoot, ".kimiflare", "memory.db");
   try {
     const db = openMemoryDb(dbPath);
     const files = getTopRelatedFiles(db, repoRoot, limit);
@@ -17249,7 +18584,7 @@ function getPreReadFilesFromMemory(cfg, repoRoot, limit = 10) {
   }
 }
 function cacheKey(prompt, context, strategy) {
-  return createHash3("sha256").update(`${prompt}\0${context}\0${strategy}`).digest("hex");
+  return createHash4("sha256").update(`${prompt}\0${context}\0${strategy}`).digest("hex");
 }
 function getCached(key) {
   return decompositionCache.get(key);
@@ -18190,8 +19525,8 @@ async function runEmitMode(opts2) {
   async function nextFollowUp() {
     if (followUpQueue.length > 0) return followUpQueue.shift();
     if (stdinClosed) return null;
-    return new Promise((resolve14) => {
-      followUpResolver = resolve14;
+    return new Promise((resolve15) => {
+      followUpResolver = resolve15;
     });
   }
   const cwd = process.cwd();
@@ -18381,8 +19716,8 @@ ${conflicts.join("\n")}`,
               return "allow";
             }
             if (opts2.multiTurn) {
-              const choice = await new Promise((resolve14) => {
-                pendingPermissions.set(reqId, resolve14);
+              const choice = await new Promise((resolve15) => {
+                pendingPermissions.set(reqId, resolve15);
               });
               if (choice === "allow" || choice === "allow_session") {
                 emit("PermissionGranted", { request_id: reqId });
@@ -18520,7 +19855,7 @@ async function runAttachMode(opts2) {
 async function streamSse(url, sessionId, format) {
   const eventSource = new EventSource(`${url}/event`);
   let done = false;
-  return new Promise((resolve14, reject) => {
+  return new Promise((resolve15, reject) => {
     eventSource.onmessage = (event) => {
       try {
         const data = JSON.parse(event.data);
@@ -18567,7 +19902,7 @@ async function streamSse(url, sessionId, format) {
             done = true;
             eventSource.close();
             if (format === "text") process.stdout.write("\n");
-            resolve14(void 0);
+            resolve15(void 0);
             break;
           case "error":
             done = true;
@@ -18580,7 +19915,7 @@ async function streamSse(url, sessionId, format) {
               process.stdout.write(JSON.stringify({ event: "error", message: data.message }) + "\n");
             }
             process.exitCode = 1;
-            resolve14(void 0);
+            resolve15(void 0);
             break;
         }
       } catch {
@@ -18606,7 +19941,7 @@ async function streamSseJson(url, sessionId) {
   const toolResults = [];
   let usage;
   const eventSource = new EventSource(`${url}/event`);
-  return new Promise((resolve14, reject) => {
+  return new Promise((resolve15, reject) => {
     eventSource.onmessage = (event) => {
       try {
         const data = JSON.parse(event.data);
@@ -18643,7 +19978,7 @@ async function streamSseJson(url, sessionId) {
                 2
               ) + "\n"
             );
-            resolve14(void 0);
+            resolve15(void 0);
             break;
           case "error":
             eventSource.close();
@@ -18651,7 +19986,7 @@ async function streamSseJson(url, sessionId) {
               JSON.stringify({ error: data.message, sessionId }, null, 2) + "\n"
             );
             process.exitCode = 1;
-            resolve14(void 0);
+            resolve15(void 0);
             break;
         }
       } catch {
@@ -19338,7 +20673,7 @@ __export(app_helpers_exports, {
 });
 import { execSync as execSync3, spawn as spawn6 } from "child_process";
 import { existsSync as existsSync5, readFileSync as readFileSync5, statSync as statSync5 } from "fs";
-import { join as join31 } from "path";
+import { join as join32 } from "path";
 import { platform as platform3 } from "os";
 function buildFilePickerIgnoreList(cwd) {
   const hardcoded = [
@@ -19410,7 +20745,7 @@ function buildFilePickerIgnoreList(cwd) {
   ];
   const gitignorePatterns = [];
   try {
-    const gitignorePath = join31(cwd, ".gitignore");
+    const gitignorePath = join32(cwd, ".gitignore");
     const stats = statSync5(gitignorePath);
     if (stats.size > MAX_GITIGNORE_SIZE) {
       return hardcoded;
@@ -19585,12 +20920,180 @@ var init_app_helpers = __esm({
   }
 });
 
-// src/remote/deploy-commute.ts
+// src/ui/bang-command.ts
 import { spawn as spawn7 } from "child_process";
-import { mkdtemp, readFile as readFile21, writeFile as writeFile13, rm as rm2 } from "fs/promises";
-import { tmpdir as tmpdir3 } from "os";
-import { join as join32 } from "path";
-import { randomBytes as randomBytes2 } from "crypto";
+import { mkdtemp, readFile as readFile22, rm as rm2 } from "fs/promises";
+import { tmpdir as tmpdir3, platform as platform4 } from "os";
+import { join as join33 } from "path";
+function registerInkInstance(instance) {
+  inkInstance = instance;
+}
+function registerTerminalHandoff(h) {
+  terminalHandoff = h;
+}
+function runCaptured(inv, cwd) {
+  return new Promise((resolve15) => {
+    const child = spawn7(inv.file, inv.args, { cwd, stdio: ["ignore", "pipe", "pipe"], env: inv.env ?? process.env });
+    let output = "";
+    child.stdout?.on("data", (c) => output += c.toString("utf8"));
+    child.stderr?.on("data", (c) => output += c.toString("utf8"));
+    child.once("error", (e) => resolve15({ code: 127, signal: null, output: `failed to start: ${e.message}` }));
+    child.once("exit", (code, signal) => resolve15({ code, signal, output }));
+  });
+}
+function isTerminalHandedOff() {
+  return handedOff;
+}
+function parseBangCommand(input) {
+  const t = input.trimStart();
+  if (!t.startsWith("!")) return null;
+  return t.slice(1).trim();
+}
+function scriptInvocation(command, shell, logPath, plat = platform4()) {
+  if (plat === "darwin" || plat === "freebsd" || plat === "openbsd" || plat === "netbsd") {
+    return { file: "script", args: ["-q", logPath, shell, "-c", command] };
+  }
+  if (plat === "linux") {
+    return { file: "script", args: ["-q", "-e", "-c", command, logPath], env: { ...process.env, SHELL: shell } };
+  }
+  return null;
+}
+function cleanTerminalOutput(raw) {
+  const text = raw.replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, "").replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "").replace(/\x1b[@-Z\\-_]/g, "").replace(/^Script (?:started|done) on .*$/gm, "");
+  const lines = text.split(/\r?\n/).map((line) => {
+    const segs = line.split("\r");
+    let out = segs[segs.length - 1] ?? "";
+    if (!out && segs.length > 1) out = segs.filter(Boolean).pop() ?? "";
+    while (/[^\x08]\x08/.test(out)) out = out.replace(/[^\x08]\x08/, "");
+    return out.replace(/[\x00-\x08\x0b-\x1f\x7f]/g, "");
+  });
+  return lines.join("\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+function truncateMiddle2(text, max = MAX_CONTEXT_CHARS) {
+  if (text.length <= max) return text;
+  const half = Math.floor(max / 2);
+  return `${text.slice(0, half)}
+
+[\u2026 ${text.length - max} chars omitted \u2026]
+
+${text.slice(-half)}`;
+}
+function formatBangContext(r) {
+  const status = r.signal ? `killed by ${r.signal}` : `exit code ${r.exitCode ?? "?"}`;
+  const body = r.output === null ? "(output was shown in the user's terminal but could not be captured)" : r.output ? truncateMiddle2(r.output) : "(no output)";
+  return `[The user ran this shell command themselves with \`!\` in the autopilot prompt. This is context for you, not a new request.]
+$ ${r.command}
+(${status})
+${body}`;
+}
+function stopReading(stdin) {
+  stdin.pause();
+  const stream = stdin;
+  try {
+    if (stream._handle?.reading && stream._handle.readStop) {
+      stream._handle.readStop();
+      stream._handle.reading = false;
+      if (stream._readableState) stream._readableState.reading = false;
+    }
+  } catch {
+  }
+}
+function swallow() {
+  return ((_chunk, encOrCb, cb) => {
+    const done = typeof encOrCb === "function" ? encOrCb : cb;
+    if (typeof done === "function") done();
+    return true;
+  });
+}
+function spawnInherit(inv, cwd) {
+  return new Promise((resolve15, reject) => {
+    const child = spawn7(inv.file, inv.args, { cwd, stdio: "inherit", env: inv.env ?? process.env });
+    child.once("error", reject);
+    child.once("exit", (code, signal) => resolve15({ code, signal }));
+  });
+}
+async function runBangCommand(command, cwd) {
+  const isWindows = platform4() === "win32";
+  const shell = isWindows ? process.env.COMSPEC || "cmd.exe" : process.env.SHELL || "/bin/sh";
+  const direct = isWindows ? { file: shell, args: ["/c", command] } : { file: shell, args: ["-c", command] };
+  if (terminalHandoff && !await terminalHandoff.suspend()) {
+    const r = await runCaptured(direct, cwd);
+    return { command, exitCode: r.code, signal: r.signal, output: cleanTerminalOutput(r.output) };
+  }
+  const stdin = process.stdin;
+  const stdout = process.stdout;
+  const stderr = process.stderr;
+  const origOut = stdout.write;
+  const origErr = stderr.write;
+  const readable = stdin.listeners("readable");
+  const wasRaw = stdin.isTTY ? stdin.isRaw : false;
+  const logDir2 = isWindows ? null : await mkdtemp(join33(tmpdir3(), "autopilot-bang-"));
+  const logPath = logDir2 ? join33(logDir2, "out.log") : null;
+  const viaScript = logPath ? scriptInvocation(command, shell, logPath) : null;
+  inkInstance?.clear();
+  origOut.call(stdout, `
+$ ${command}
+`);
+  stdout.write = swallow();
+  stderr.write = swallow();
+  for (const l of readable) stdin.removeListener("readable", l);
+  if (stdin.isTTY) stdin.setRawMode(false);
+  stopReading(stdin);
+  handedOff = true;
+  let result2;
+  let captured = false;
+  let spawnError = null;
+  try {
+    if (viaScript) {
+      try {
+        result2 = await spawnInherit(viaScript, cwd);
+        captured = true;
+      } catch (e) {
+        logger.warn("bang:script_unavailable", { error: e.message });
+        result2 = await spawnInherit(direct, cwd);
+      }
+    } else {
+      result2 = await spawnInherit(direct, cwd);
+    }
+  } catch (e) {
+    result2 = { code: 127, signal: null };
+    spawnError = e.message;
+    logger.warn("bang:spawn_failed", { error: spawnError });
+  } finally {
+    handedOff = false;
+    stdout.write = origOut;
+    stderr.write = origErr;
+    if (stdin.isTTY) stdin.setRawMode(wasRaw);
+    for (const l of readable) stdin.addListener("readable", l);
+    origOut.call(stdout, "\n");
+    terminalHandoff?.resume();
+  }
+  let output = spawnError ? `failed to start: ${spawnError}` : null;
+  if (captured && logPath) {
+    output = cleanTerminalOutput(await readFile22(logPath, "utf8").catch(() => ""));
+  }
+  if (logDir2) await rm2(logDir2, { recursive: true, force: true }).catch(() => {
+  });
+  return { command, exitCode: result2.code, signal: result2.signal, output };
+}
+var inkInstance, handedOff, terminalHandoff, MAX_CONTEXT_CHARS;
+var init_bang_command = __esm({
+  "src/ui/bang-command.ts"() {
+    "use strict";
+    init_logger();
+    inkInstance = null;
+    handedOff = false;
+    terminalHandoff = null;
+    MAX_CONTEXT_CHARS = 16e3;
+  }
+});
+
+// src/remote/deploy-commute.ts
+import { spawn as spawn8 } from "child_process";
+import { mkdtemp as mkdtemp2, readFile as readFile23, writeFile as writeFile13, rm as rm3 } from "fs/promises";
+import { tmpdir as tmpdir4 } from "os";
+import { join as join34 } from "path";
+import { randomBytes as randomBytes3 } from "crypto";
 async function cfApiFetch(accountId, apiToken, path, init) {
   const url = `${CF_API}/accounts/${encodeURIComponent(accountId)}${path}`;
   const res = await fetch(url, {
@@ -19602,65 +21105,65 @@ async function cfApiFetch(accountId, apiToken, path, init) {
       ...init?.headers
     }
   });
-  const json2 = await res.json();
-  return json2;
+  const json3 = await res.json();
+  return json3;
 }
 async function listDurableObjectNamespaces(accountId, apiToken) {
-  const json2 = await cfApiFetch(
+  const json3 = await cfApiFetch(
     accountId,
     apiToken,
     "/workers/durable_objects/namespaces"
   );
-  if (!json2.success || !json2.result) {
+  if (!json3.success || !json3.result) {
     throw new Error(
-      json2.errors?.map((e) => e.message).join(", ") ?? "Failed to list DO namespaces"
+      json3.errors?.map((e) => e.message).join(", ") ?? "Failed to list DO namespaces"
     );
   }
-  return json2.result;
+  return json3.result;
 }
 async function deleteDurableObjectNamespace(accountId, apiToken, namespaceId) {
-  const json2 = await cfApiFetch(
+  const json3 = await cfApiFetch(
     accountId,
     apiToken,
     `/workers/durable_objects/namespaces/${encodeURIComponent(namespaceId)}`,
     { method: "DELETE" }
   );
-  if (!json2.success) {
+  if (!json3.success) {
     throw new Error(
-      json2.errors?.map((e) => e.message).join(", ") ?? "Failed to delete DO namespace"
+      json3.errors?.map((e) => e.message).join(", ") ?? "Failed to delete DO namespace"
     );
   }
 }
 async function listContainerApplications(accountId, apiToken) {
-  const json2 = await cfApiFetch(
+  const json3 = await cfApiFetch(
     accountId,
     apiToken,
     "/containers/applications"
   );
-  if (!json2.success || !json2.result) {
+  if (!json3.success || !json3.result) {
     return [];
   }
-  return json2.result;
+  return json3.result;
 }
 async function deleteContainerApplication(accountId, apiToken, appId) {
-  const json2 = await cfApiFetch(
+  const json3 = await cfApiFetch(
     accountId,
     apiToken,
     `/containers/applications/${encodeURIComponent(appId)}`,
     { method: "DELETE" }
   );
-  if (!json2.success) {
+  if (!json3.success) {
     throw new Error(
-      json2.errors?.map((e) => e.message).join(", ") ?? "Failed to delete container application"
+      json3.errors?.map((e) => e.message).join(", ") ?? "Failed to delete container application"
     );
   }
 }
 function generateSecret2() {
-  return randomBytes2(32).toString("hex");
+  return randomBytes3(32).toString("hex");
 }
 function runCmd(cmd, args, opts2 = {}) {
-  return new Promise((resolve14) => {
-    const child = spawn7(cmd, args, {
+  return new Promise((resolve15) => {
+    const child = spawn8(cmd, args, {
       cwd: opts2.cwd,
       env: { ...process.env, ...opts2.env ?? {} },
       stdio: [opts2.input ? "pipe" : "ignore", "pipe", "pipe"]
@@ -19680,11 +21183,11 @@ function runCmd(cmd, args, opts2 = {}) {
     const timer3 = opts2.timeoutMs ? setTimeout(() => child.kill("SIGKILL"), opts2.timeoutMs) : null;
     child.on("close", (code) => {
       if (timer3) clearTimeout(timer3);
-      resolve14({ stdout, stderr, code: code ?? -1 });
+      resolve15({ stdout, stderr, code: code ?? -1 });
     });
     child.on("error", (err) => {
       if (timer3) clearTimeout(timer3);
-      resolve14({ stdout, stderr: stderr + String(err), code: -1 });
+      resolve15({ stdout, stderr: stderr + String(err), code: -1 });
     });
   });
 }
@@ -19820,8 +21323,8 @@ ${wranglerInstall.stderr.slice(-600)}`,
     ok: true
   };
   yield { message: "Prerequisites ready", ok: true };
-  const tmpRoot = await mkdtemp(join32(tmpdir3(), "kimiflare-commute-"));
-  const repoDir = join32(tmpRoot, "kimiflare-commute");
+  const tmpRoot = await mkdtemp2(join34(tmpdir4(), "kimiflare-commute-"));
+  const repoDir = join34(tmpRoot, "kimiflare-commute");
   yield { message: `Fetching worker source from GitHub (${COMMUTE_REPO})\u2026` };
   const clone = await runCmd("git", ["clone", "--depth", "1", "--branch", COMMUTE_BRANCH, COMMUTE_REPO, repoDir], { timeoutMs: 6e4 });
   if (clone.code !== 0) {
@@ -19830,8 +21333,8 @@ ${(clone.stderr || clone.stdout).slice(0, 400)}`, error: true };
     throw new Error("clone failed");
   }
   yield { message: "Source fetched from GitHub", ok: true };
-  const workerDir = join32(repoDir, "remote", "worker");
-  const wranglerToml = join32(workerDir, "wrangler.toml");
+  const workerDir = join34(repoDir, "remote", "worker");
+  const wranglerToml = join34(workerDir, "wrangler.toml");
   yield { message: "Installing Worker dependencies (npm install)\u2026" };
   const install = await runCmd("npm", ["install", "--no-audit", "--no-fund", "--loglevel=error"], {
     cwd: workerDir,
@@ -19920,7 +21423,7 @@ ${(install.stderr || install.stdout).slice(-1200).trim()}`,
     ok: true
   };
   yield { message: "Patching wrangler.toml\u2026" };
-  let toml = await readFile21(wranglerToml, "utf8");
+  let toml = await readFile23(wranglerToml, "utf8");
   toml = toml.replace(/^name\s*=\s*"[^"]+"/m, `name = "${workerName}"`);
   toml = toml.replace(
     /(\[\[kv_namespaces\]\][\s\S]*?binding\s*=\s*"OAUTH_KV"[\s\S]*?id\s*=\s*")[^"]+(")/,
@@ -20004,7 +21507,7 @@ invocation_logs = true
   };
   await saveConfig(next);
   yield { message: "Saved to ~/.config/kimiflare/config.json", ok: true };
-  await rm2(tmpRoot, { recursive: true, force: true }).catch(() => {
+  await rm3(tmpRoot, { recursive: true, force: true }).catch(() => {
   });
   yield { message: "Setup complete \u2014 multi-agent is ready to use.", done: true };
   return { workerEndpoint: workerUrl, workerApiKey };
@@ -21258,7 +22761,7 @@ var init_text_input = __esm({
 import { useState as useState5 } from "react";
 import { Box as Box5, Text as Text5 } from "ink";
 import SelectInput3 from "ink-select-input";
-import { spawn as spawn8 } from "child_process";
+import { spawn as spawn9 } from "child_process";
 import { jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
 function LspWizard({ servers, currentScope, hasProjectDir, onDone, onSave }) {
   const theme = useTheme();
@@ -21272,7 +22775,7 @@ function LspWizard({ servers, currentScope, hasProjectDir, onDone, onSave }) {
   const runInstall = (command) => {
     setInstallState({ status: "running", output: "Installing..." });
     const { shell, args } = getShellCommand();
-    const child = spawn8(shell, [...args, command], {
+    const child = spawn9(shell, [...args, command], {
       env: process.env
     });
     let stdout = "";
@@ -21780,7 +23283,7 @@ var init_lsp_wizard = __esm({
 });
 
 // src/hooks/recommended.ts
-import { platform as platform4 } from "os";
+import { platform as platform5 } from "os";
 function getRecommendedHook(id) {
   return RECOMMENDED_HOOKS.find((r) => r.id === id);
 }
@@ -21788,7 +23291,7 @@ var isMac, RECOMMENDED_HOOKS;
 var init_recommended = __esm({
   "src/hooks/recommended.ts"() {
     "use strict";
-    isMac = platform4() === "darwin";
+    isMac = platform5() === "darwin";
     RECOMMENDED_HOOKS = [
       // ── Stop notifications ───────────────────────────────────────────────
       {
@@ -22264,10 +23767,10 @@ __export(camouflage_view_exports, {
   toolSummary: () => toolSummary,
   validateCommandName: () => validateCommandName
 });
-import { execFileSync as execFileSync3, spawn as spawn9 } from "child_process";
+import { execFileSync as execFileSync3, spawn as spawn10 } from "child_process";
 import { readdir as readdir6 } from "fs/promises";
-import { homedir as homedir22 } from "os";
-import { join as join33, resolve as resolve11 } from "path";
+import { homedir as homedir23 } from "os";
+import { join as join35, resolve as resolve12 } from "path";
 async function loadSdk() {
   const sdk = await import("camouflage-tui").catch((err) => {
     throw new CamouflageUnavailable(`camouflage-tui is not installed (${err.message})`);
@@ -22308,6 +23811,10 @@ async function runCamouflageView(opts2) {
     cam.send("MentionCandidatesRegistered", { candidates: files.map((token) => ({ token, kind: "file" })) });
   }
   const view = new View(cam, sdk);
+  registerTerminalHandoff({
+    suspend: async () => sdk.suspendTerminal ? (await sdk.suspendTerminal(cam)).supported : false,
+    resume: () => sdk.resumeTerminal?.(cam)
+  });
   cam.on("userInput", (text) => {
     view.echoed.push(text.trim());
     view.actions?.submit(text);
@@ -22328,6 +23835,7 @@ async function runCamouflageView(opts2) {
   const finish = async () => {
     if (closing) return;
     closing = true;
+    registerTerminalHandoff(null);
     await cam.close().catch(() => void 0);
     restoreConsole();
   };
@@ -22345,14 +23853,14 @@ async function runCamouflageView(opts2) {
   }
 }
 function runShell(command) {
-  return new Promise((resolve14) => {
+  return new Promise((resolve15) => {
     const { shell, args } = getShellCommand();
-    const child = spawn9(shell, [...args, command], { env: process.env });
+    const child = spawn10(shell, [...args, command], { env: process.env });
     let out = "";
     child.stdout?.on("data", (c) => out += c.toString("utf8"));
     child.stderr?.on("data", (c) => out += c.toString("utf8"));
-    child.on("close", (code) => resolve14({ ok: code === 0, output: out || (code === 0 ? "" : `Exit code: ${code}`) }));
-    child.on("error", (err) => resolve14({ ok: false, output: err.message }));
+    child.on("close", (code) => resolve15({ ok: code === 0, output: out || (code === 0 ? "" : `Exit code: ${code}`) }));
+    child.on("error", (err) => resolve15({ ok: false, output: err.message }));
   });
 }
 function validateCommandName(name, existing) {
@@ -22403,8 +23911,8 @@ function truncateText(s, max) {
 async function listMentionDir(cwd, query) {
   const exact = query === "~" || query === "." || query === ".." || query.endsWith("/..");
   const dir = exact ? `${query}/` : query.slice(0, query.lastIndexOf("/") + 1);
-  const expanded = dir.startsWith("~") ? join33(homedir22(), dir.slice(1)) : dir;
-  const target = resolve11(cwd, expanded || ".");
+  const expanded = dir.startsWith("~") ? join35(homedir23(), dir.slice(1)) : dir;
+  const target = resolve12(cwd, expanded || ".");
   try {
     const items = await readdir6(target, { withFileTypes: true });
     const entries = items.filter((d) => !d.name.startsWith(".")).map((d) => ({ name: d.name, isDir: d.isDirectory() })).sort((a, b) => a.isDir !== b.isDir ? a.isDir ? -1 : 1 : a.name.localeCompare(b.name)).slice(0, 300).map((d) => `${dir}${d.name}${d.isDir ? "/" : ""}`);
@@ -22485,7 +23993,7 @@ function shortModel(id) {
   return id.includes("/") ? id.slice(id.indexOf("/") + 1) : id;
 }
 function shortPath(p) {
-  const home = homedir22();
+  const home = homedir23();
   return p === home ? "~" : p.startsWith(home + "/") ? `~${p.slice(home.length)}` : p;
 }
 function gitBranch(cwd) {
@@ -22535,6 +24043,7 @@ var init_camouflage_view = __esm({
     init_model_picker();
     init_help_menu();
     init_app_helpers();
+    init_bang_command();
     init_deploy_commute();
     init_remote_dashboard();
     init_worker_client();
@@ -25114,7 +26623,7 @@ var init_status = __esm({
 // src/ui/permission.tsx
 import { useState as useState9, useCallback } from "react";
 import { Box as Box13, Text as Text14, useInput as useInput6 } from "ink";
-import { platform as platform5 } from "os";
+import { platform as platform6 } from "os";
 import { jsx as jsx15, jsxs as jsxs12 } from "react/jsx-runtime";
 function formatSelection(label, shortcut) {
   return `${label}  [${MOD_KEY}+${shortcut}]`;
@@ -25278,7 +26787,7 @@ var init_permission = __esm({
       { value: { decision: "deny", scope: "once" }, label: "Something else", key: 3 }
     ];
     DENY = { decision: "deny", scope: "once" };
-    MOD_KEY = platform5() === "darwin" ? "\u2325" : "Alt";
+    MOD_KEY = platform6() === "darwin" ? "\u2325" : "Alt";
   }
 });
 
@@ -25305,19 +26814,19 @@ function usePermissionController(getMode, onPlanModeBlocked) {
   const onPlanModeBlockedRef = useRef3(onPlanModeBlocked);
   onPlanModeBlockedRef.current = onPlanModeBlocked;
   const askPermission = useCallback2(
-    (req, askOpts) => new Promise((resolve14) => {
+    (req, askOpts) => new Promise((resolve15) => {
       const outcome = decidePermission(req, getModeRef.current(), askOpts);
       if (outcome.kind === "resolve") {
-        resolve14(outcome.decision);
+        resolve15(outcome.decision);
         return;
       }
       if (outcome.kind === "plan_blocked") {
         onPlanModeBlockedRef.current(outcome.toolName);
-        resolve14(AUTO_DENY);
+        resolve15(AUTO_DENY);
         return;
       }
-      resolveRef.current = resolve14;
-      setPending({ tool: req.tool, args: req.args, resolve: resolve14 });
+      resolveRef.current = resolve15;
+      setPending({ tool: req.tool, args: req.args, resolve: resolve15 });
     }),
     []
   );
@@ -25956,15 +27465,15 @@ __export(openrouter_oauth_exports, {
   pkceChallenge: () => pkceChallenge,
   startLoopbackListener: () => startLoopbackListener
 });
-import { createHash as createHash4, randomBytes as randomBytes3 } from "crypto";
+import { createHash as createHash5, randomBytes as randomBytes4 } from "crypto";
 import { createServer as createServer2 } from "http";
 import { hostname } from "os";
 function createPkce() {
-  const verifier = randomBytes3(32).toString("base64url");
+  const verifier = randomBytes4(32).toString("base64url");
   return { verifier, challenge: pkceChallenge(verifier) };
 }
 function pkceChallenge(verifier) {
-  return createHash4("sha256").update(verifier).digest("base64url");
+  return createHash5("sha256").update(verifier).digest("base64url");
 }
 function openRouterAuthPageUrl() {
   return (process.env.OPENROUTER_AUTH_URL?.trim() || "https://openrouter.ai/auth").replace(/\/+$/, "");
@@ -26047,9 +27556,9 @@ async function startLoopbackListener(opts2 = {}) {
     rejectCode(e);
     finish();
   }
-  await new Promise((resolve14, reject) => {
+  await new Promise((resolve15, reject) => {
     server.once("error", reject);
-    server.listen(0, "127.0.0.1", () => resolve14());
+    server.listen(0, "127.0.0.1", () => resolve15());
   });
   const address = server.address();
   const port = typeof address === "object" && address ? address.port : 0;
@@ -26475,15 +27984,15 @@ var init_frontmatter = __esm({
 });
 
 // src/commands/loader.ts
-import { open, realpath as realpath4 } from "fs/promises";
-import { homedir as homedir23 } from "os";
-import { join as join34, relative as relative8, sep as sep4 } from "path";
+import { open, realpath as realpath6 } from "fs/promises";
+import { homedir as homedir24 } from "os";
+import { join as join36, relative as relative10, sep as sep6 } from "path";
 function projectCommandsDir(cwd = process.cwd()) {
-  return join34(cwd, ".kimiflare", "commands");
+  return join36(cwd, ".kimiflare", "commands");
 }
 function globalCommandsDir() {
-  const xdg = process.env.XDG_CONFIG_HOME || join34(homedir23(), ".config");
-  return join34(xdg, "kimiflare", "commands");
+  const xdg = process.env.XDG_CONFIG_HOME || join36(homedir24(), ".config");
+  return join36(xdg, "kimiflare", "commands");
 }
 async function loadCustomCommands(cwd = process.cwd()) {
   const warnings = [];
@@ -26522,7 +28031,7 @@ async function loadCustomCommands(cwd = process.cwd()) {
 async function resolveSafeDir(dir, source, cwd, warnings) {
   let realDir;
   try {
-    realDir = await realpath4(dir);
+    realDir = await realpath6(dir);
   } catch (err) {
     const code = err.code;
     if (code !== "ENOENT" && code !== "ENOTDIR") {
@@ -26533,11 +28042,11 @@ async function resolveSafeDir(dir, source, cwd, warnings) {
   if (source === "project") {
     let realCwd;
     try {
-      realCwd = await realpath4(cwd);
+      realCwd = await realpath6(cwd);
     } catch {
       return null;
     }
-    const rel = relative8(realCwd, realDir);
+    const rel = relative10(realCwd, realDir);
     if (rel !== "" && isPathOutside(rel)) {
       warnings.push(`commands dir ${dir} escapes workspace via symlink \u2014 skipped`);
       return null;
@@ -26612,10 +28121,10 @@ async function loadOne(file, rootDir, source, warnings) {
   return cmd;
 }
 function filenameToCommandName(file, rootDir) {
-  const rel = relative8(rootDir, file);
+  const rel = relative10(rootDir, file);
   if (!rel || isPathOutside(rel)) return null;
   const noExt = rel.replace(/\.md$/i, "");
-  const parts = noExt.split(sep4).filter((p) => p.length > 0);
+  const parts = noExt.split(sep6).filter((p) => p.length > 0);
   if (parts.length === 0) return null;
   if (parts.some((p) => !/^[\w.-]+$/.test(p))) return null;
   return parts.join("/");
@@ -26635,8 +28144,8 @@ var init_loader = __esm({
 
 // src/commands/renderer.ts
 import { exec } from "child_process";
-import { open as open2, realpath as realpath5 } from "fs/promises";
-import { isAbsolute as isAbsolute4, relative as relative9, resolve as resolvePathJoin, basename as pathBasename } from "path";
+import { open as open2, realpath as realpath7 } from "fs/promises";
+import { isAbsolute as isAbsolute6, relative as relative11, resolve as resolvePathJoin, basename as pathBasename } from "path";
 import { promisify as promisify3 } from "util";
 function tokenizeArgs(s) {
   return [...s.matchAll(ARG_TOKEN_RE)].map((match) => {
@@ -26727,7 +28236,7 @@ async function replaceFiles(prompt, warnings, cmd, cwd, maxFileBytes) {
       return "" + trailing;
     });
   }
-  const realCwd = await realpath5(cwd).catch(() => cwd);
+  const realCwd = await realpath7(cwd).catch(() => cwd);
   const replacements = await Promise.all(
     matches.map(async (match) => {
       const rawPath = match[1] ?? "";
@@ -26736,23 +28245,23 @@ async function replaceFiles(prompt, warnings, cmd, cwd, maxFileBytes) {
         warnings.push(`file inclusion blocked: @${rawPath} \u2014 secret file pattern`);
         return "";
       }
-      if (isAbsolute4(rawPath) || rawPath.startsWith("~")) {
+      if (isAbsolute6(rawPath) || rawPath.startsWith("~")) {
         warnings.push(`file inclusion skipped: @${rawPath} \u2014 outside workspace`);
         return "";
       }
       const resolved = resolvePathJoin(cwd, rawPath);
-      if (isPathOutside(relative9(cwd, resolved))) {
+      if (isPathOutside(relative11(cwd, resolved))) {
         warnings.push(`file inclusion skipped: @${rawPath} \u2014 outside workspace`);
         return "";
       }
       let real;
       try {
-        real = await realpath5(resolved);
+        real = await realpath7(resolved);
       } catch (error) {
         warnings.push(`file inclusion failed: @${rawPath} \u2014 ${message(error)}`);
         return "";
       }
-      if (isPathOutside(relative9(realCwd, real))) {
+      if (isPathOutside(relative11(realCwd, real))) {
         warnings.push(`file inclusion skipped: @${rawPath} \u2014 symlink escapes workspace`);
         return "";
       }
@@ -27547,8 +29056,8 @@ var init_one_dark = __esm({
 });
 
 // src/ui/theme.ts
-function normalizeTheme(json2) {
-  const obj = json2;
+function normalizeTheme(json3) {
+  const obj = json3;
   const palette = obj.palette;
   const normalizeDim = (v) => {
     if (v === void 0) return void 0;
@@ -27691,11 +29200,11 @@ var init_wcag = __esm({
 });
 
 // src/ui/theme-loader.ts
-import { readFile as readFile22, readdir as readdir7 } from "fs/promises";
-import { join as join35 } from "path";
-import { homedir as homedir24 } from "os";
+import { readFile as readFile24, readdir as readdir7 } from "fs/promises";
+import { join as join37 } from "path";
+import { homedir as homedir25 } from "os";
 function projectThemesDir(cwd = process.cwd()) {
-  return join35(cwd, ".kimiflare", "themes");
+  return join37(cwd, ".kimiflare", "themes");
 }
 function isHexColor(c) {
   return /^#[0-9a-fA-F]{6}$/.test(c);
@@ -27784,26 +29293,26 @@ async function loadThemesFromDir(dir, source) {
     return { themes, errors };
   }
   for (const file of files.filter((f) => f.endsWith(".json"))) {
-    const path = join35(dir, file);
+    const path = join37(dir, file);
     let raw;
     try {
-      raw = await readFile22(path, "utf-8");
+      raw = await readFile24(path, "utf-8");
     } catch (e) {
       errors.push(`${path}: ${e instanceof Error ? e.message : String(e)}`);
       continue;
     }
-    let json2;
+    let json3;
     try {
-      json2 = JSON.parse(raw);
+      json3 = JSON.parse(raw);
     } catch (e) {
       errors.push(`${path}: invalid JSON \u2014 ${e instanceof Error ? e.message : String(e)}`);
       continue;
     }
-    if (!json2 || typeof json2 !== "object") {
+    if (!json3 || typeof json3 !== "object") {
       errors.push(`${path}: root must be an object`);
       continue;
     }
-    const obj = json2;
+    const obj = json3;
     const fileErrors = [];
     if (typeof obj.name !== "string" || obj.name.length === 0) {
       fileErrors.push("name is required");
@@ -27933,8 +29442,8 @@ var init_theme_loader = __esm({
     "use strict";
     init_wcag();
     init_theme();
-    USER_THEMES_DIR = join35(
-      process.env.XDG_CONFIG_HOME || join35(homedir24(), ".config"),
+    USER_THEMES_DIR = join37(
+      process.env.XDG_CONFIG_HOME || join37(homedir25(), ".config"),
       "kimiflare",
       "themes"
     );
@@ -31053,8 +32562,8 @@ var init_input_handlers = __esm({
 
 // src/agent/jev-context.ts
 import { execFileSync as execFileSync4 } from "child_process";
-import { readFile as readFile23 } from "fs/promises";
-import { basename as basename6, join as join36, resolve as resolve12 } from "path";
+import { readFile as readFile25 } from "fs/promises";
+import { basename as basename6, join as join38, resolve as resolve13 } from "path";
 function messageText(message2) {
   if (typeof message2.content === "string") return message2.content.trim();
   if (!Array.isArray(message2.content)) return "";
@@ -31071,12 +32580,12 @@ function projectRoot(cwd) {
       timeout: 1e3
     }).trim();
   } catch {
-    return resolve12(cwd);
+    return resolve13(cwd);
   }
 }
 async function readPackageMetadata(root) {
   try {
-    const parsed = JSON.parse(await readFile23(join36(root, "package.json"), "utf8"));
+    const parsed = JSON.parse(await readFile25(join38(root, "package.json"), "utf8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
     const pkg = parsed;
     const metadata = {};
@@ -31093,7 +32602,7 @@ async function readPackageMetadata(root) {
 async function readLicenseEvidence(root) {
   for (const name of ["LICENSE", "LICENSE.md", "LICENSE.txt", "LICENCE", "COPYING"]) {
     try {
-      const content = (await readFile23(join36(root, name), "utf8")).trim();
+      const content = (await readFile25(join38(root, name), "utf8")).trim();
       if (content) return { source: `project license (${name})`, content: content.slice(0, 700) };
     } catch {
     }
@@ -31102,7 +32611,7 @@ async function readLicenseEvidence(root) {
 }
 async function buildJevContext(question, messages, cwd = process.cwd()) {
   const entries = [];
-  let remaining = MAX_CONTEXT_CHARS;
+  let remaining = MAX_CONTEXT_CHARS2;
   const add = (source, content, limit = remaining) => {
     if (remaining <= 0 || !content.trim()) return;
     const sourceText = source.slice(0, 160);
@@ -31126,7 +32635,7 @@ async function buildJevContext(question, messages, cwd = process.cwd()) {
       conversationRemaining -= source.length + content.length + 2;
     }
   }
-  const currentDirectory = basename6(resolve12(cwd));
+  const currentDirectory = basename6(resolve13(cwd));
   const escapedDirectory = currentDirectory.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   const namesCurrentDirectory = currentDirectory.length >= 5 && !/^(?:agent|app|code|lib|project|repo|src|test|tests|workspace)$/i.test(currentDirectory) && new RegExp(`\\b${escapedDirectory}\\b`, "i").test(question);
   if (CURRENT_PROJECT_REFERENCE.test(question) || namesCurrentDirectory) {
@@ -31169,11 +32678,11 @@ function formatJevContextReceipt(entries, includeContent = false) {
     "Chat/project context is reference data, not verified fact."
   ].join("\n");
 }
-var MAX_CONTEXT_CHARS, MAX_CONVERSATION_CHARS, CURRENT_PROJECT_REFERENCE, LICENSE_QUESTION, CONVERSATION_REFERENCE, SECRET_PATTERNS3;
+var MAX_CONTEXT_CHARS2, MAX_CONVERSATION_CHARS, CURRENT_PROJECT_REFERENCE, LICENSE_QUESTION, CONVERSATION_REFERENCE, SECRET_PATTERNS3;
 var init_jev_context = __esm({
   "src/agent/jev-context.ts"() {
     "use strict";
-    MAX_CONTEXT_CHARS = 6e3;
+    MAX_CONTEXT_CHARS2 = 6e3;
     MAX_CONVERSATION_CHARS = 4e3;
     CURRENT_PROJECT_REFERENCE = /\b(?:this|that|our|current|local|working)\s+(?:repo(?:sitory)?|project|workspace|codebase|harness)\b/i;
     LICENSE_QUESTION = /\bopen[\s-]?source\b|\blicen[cs](?:e|ed|ing)?\b|\bspdx\b|\bcopyleft\b/i;
@@ -31349,8 +32858,8 @@ var init_frontmatter2 = __esm({
 });
 
 // src/skills/loader.ts
-import { readFile as readFile24, readdir as readdir8, stat as stat7 } from "fs/promises";
-import { join as join37, extname } from "path";
+import { readFile as readFile26, readdir as readdir8, stat as stat8 } from "fs/promises";
+import { join as join39, extname } from "path";
 function normalizeManifest(raw, filePath) {
   const name = typeof raw.name === "string" ? raw.name : "";
   const description = typeof raw.description === "string" ? raw.description : "";
@@ -31364,7 +32873,7 @@ function normalizeManifest(raw, filePath) {
   return { name, description, match, scope, priority, enabled: enabled2 };
 }
 async function loadSkillFile(filePath) {
-  const raw = await readFile24(filePath, "utf-8");
+  const raw = await readFile26(filePath, "utf-8");
   const parsed = parseFrontmatter2(raw);
   const manifest = normalizeManifest(parsed.data, filePath);
   const body = parsed.content.trim();
@@ -31386,8 +32895,8 @@ async function loadSkillsFromDir(dirPath) {
     const entries = await readdir8(dirPath);
     const files = [];
     for (const entry of entries) {
-      const full = join37(dirPath, entry);
-      const s = await stat7(full);
+      const full = join39(dirPath, entry);
+      const s = await stat8(full);
       if (s.isFile() && extname(entry) === ".md") {
         files.push(full);
       }
@@ -31414,12 +32923,12 @@ var init_loader2 = __esm({
 });
 
 // src/skills/manager.ts
-import { mkdir as mkdir13, writeFile as writeFile14, unlink as unlink3, readFile as readFile25 } from "fs/promises";
-import { join as join38 } from "path";
+import { mkdir as mkdir13, writeFile as writeFile14, unlink as unlink4, readFile as readFile27 } from "fs/promises";
+import { join as join40 } from "path";
 function getSkillDirs(cwd) {
   return {
-    projectDir: join38(cwd, ".kimiflare", "skills"),
-    globalDir: join38(process.env.HOME ?? "", ".config", "kimiflare", "skills")
+    projectDir: join40(cwd, ".kimiflare", "skills"),
+    globalDir: join40(process.env.HOME ?? "", ".config", "kimiflare", "skills")
   };
 }
 async function listAllSkills(cwd) {
@@ -31433,7 +32942,7 @@ async function listAllSkills(cwd) {
 async function createSkill(opts2) {
   const dirs = getSkillDirs(opts2.cwd);
   const dir = opts2.scope === "project" ? dirs.projectDir : dirs.globalDir;
-  const filepath = join38(dir, `${opts2.name}.md`);
+  const filepath = join40(dir, `${opts2.name}.md`);
   const frontmatter = {
     name: opts2.name,
     enabled: true,
@@ -31462,14 +32971,14 @@ async function deleteSkill(name, cwd) {
   const all = await listAllSkills(cwd);
   const skill = all.project.find((s) => s.name === name) ?? all.global.find((s) => s.name === name);
   if (!skill) throw new Error(`skill "${name}" not found`);
-  await unlink3(skill.filePath);
+  await unlink4(skill.filePath);
   return { filepath: skill.filePath };
 }
 async function setSkillEnabled(name, enabled2, cwd) {
   const all = await listAllSkills(cwd);
   const skill = all.project.find((s) => s.name === name) ?? all.global.find((s) => s.name === name);
   if (!skill) throw new Error(`skill "${name}" not found`);
-  const raw = await readFile25(skill.filePath, "utf-8");
+  const raw = await readFile27(skill.filePath, "utf-8");
   const parsed = parseFrontmatter2(raw);
   parsed.data.enabled = enabled2;
   const yaml = Object.entries(parsed.data).map(([k, v]) => {
@@ -31525,9 +33034,9 @@ var init_plan_resolver = __esm({
 
 // src/util/clipboard.ts
 import { execSync as execSync5 } from "child_process";
-import { platform as platform6 } from "os";
+import { platform as platform7 } from "os";
 function writeToClipboard(text) {
-  const os2 = platform6();
+  const os2 = platform7();
   try {
     if (os2 === "darwin") {
       execSync5("pbcopy", { input: text, timeout: 5e3 });
@@ -31562,15 +33071,15 @@ var tui_report_exports = {};
 __export(tui_report_exports, {
   getCategoryReportText: () => getCategoryReportText
 });
-import { readFile as readFile26 } from "fs/promises";
-import { join as join39 } from "path";
-import { homedir as homedir25 } from "os";
+import { readFile as readFile28 } from "fs/promises";
+import { join as join41 } from "path";
+import { homedir as homedir26 } from "os";
 function usageDir3() {
-  const xdg = process.env.XDG_DATA_HOME || join39(homedir25(), ".local", "share");
-  return join39(xdg, "kimiflare");
+  const xdg = process.env.XDG_DATA_HOME || join41(homedir26(), ".local", "share");
+  return join41(xdg, "kimiflare");
 }
 function usagePath4() {
-  return join39(usageDir3(), "usage.json");
+  return join41(usageDir3(), "usage.json");
 }
 function today3() {
   return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
@@ -31582,7 +33091,7 @@ function daysAgo2(n) {
 }
 async function loadLog3() {
   try {
-    const raw = await readFile26(usagePath4(), "utf8");
+    const raw = await readFile28(usagePath4(), "utf8");
     return JSON.parse(raw);
   } catch {
     return { version: 1, days: [], sessions: [] };
@@ -31639,7 +33148,7 @@ var init_tui_report = __esm({
 });
 
 // src/ui/slash-commands.ts
-import { join as join40 } from "path";
+import { join as join42 } from "path";
 import QRCode from "qrcode";
 function executeFreshStart(ctx, planText, overrideMode, opts2 = {}) {
   const oldSessionId = ctx.sessionIdRef.current;
@@ -32040,7 +33549,7 @@ auto (default) lets the coordinator assess substantial tasks and delegate indepe
         const context = noContext ? [] : await buildJevContext(question.prompt, ctx.messagesRef.current, process.cwd());
         const receipt = formatJevContextReceipt(context, showContext);
         setResult(eventKey, { kind: "info", key: eventKey, text: `Jev is evaluating \xB7 ${receipt}` });
-        await new Promise((resolve14) => setTimeout(resolve14, 0));
+        await new Promise((resolve15) => setTimeout(resolve15, 0));
         const answer = await askJev(apiKey, question, { context });
         const presentation = presentJevAnswer(question, answer);
         setResult(eventKey, {
@@ -32563,7 +34072,7 @@ ${lines.join("\n")}` }]);
         void (async () => {
           try {
             const { sessionsDir: sessionsDir3 } = await Promise.resolve().then(() => (init_sessions(), sessions_exports));
-            const file = await loadSession(join40(sessionsDir3(), `${currentId}.json`));
+            const file = await loadSession(join42(sessionsDir3(), `${currentId}.json`));
             const cps = file.checkpoints ?? [];
             if (cps.length === 0) {
               setEvents((e) => [...e, { kind: "info", key: mkKey2(), text: "no checkpoints in this session" }]);
@@ -32608,7 +34117,7 @@ ${lines.join("\n")}` }]);
         try {
           ctx.ensureSessionId();
           const { sessionsDir: sessionsDir3 } = await Promise.resolve().then(() => (init_sessions(), sessions_exports));
-          const filePath = join40(sessionsDir3(), `${ctx.sessionIdRef.current}.json`);
+          const filePath = join42(sessionsDir3(), `${ctx.sessionIdRef.current}.json`);
           await addCheckpoint(filePath, cp);
           setEvents((e) => [...e, { kind: "info", key: mkKey2(), text: `checkpoint saved: "${label}"` }]);
         } catch (e) {
@@ -33240,12 +34749,12 @@ project: ${projectSettingsPath(cwd)}`
 
 // src/init/context-generator.ts
 import { existsSync as existsSync6, statSync as statSync6 } from "fs";
-import { join as join41 } from "path";
+import { join as join43 } from "path";
 function detectFlavor(cwd) {
   for (const [flavor, signatures] of Object.entries(FLAVOR_SIGNATURES)) {
     if (flavor === "generic") continue;
     for (const sig of signatures) {
-      const path = join41(cwd, sig);
+      const path = join43(cwd, sig);
       if (sig.includes("*")) {
         try {
           const parts = sig.split("*");
@@ -33266,14 +34775,14 @@ function detectFlavor(cwd) {
 }
 function findFile(cwd, candidates) {
   for (const c of candidates) {
-    if (existsSync6(join41(cwd, c))) return c;
+    if (existsSync6(join43(cwd, c))) return c;
   }
   return null;
 }
 function findSourceRoots(cwd) {
   const roots = [];
   for (const r of SOURCE_ROOT_CANDIDATES) {
-    const p = join41(cwd, r);
+    const p = join43(cwd, r);
     try {
       const s = statSync6(p);
       if (s.isDirectory()) roots.push(r);
@@ -33284,9 +34793,9 @@ function findSourceRoots(cwd) {
 }
 function findCiConfig(cwd) {
   for (const c of CI_PATHS) {
-    if (existsSync6(join41(cwd, c))) {
+    if (existsSync6(join43(cwd, c))) {
       try {
-        const s = statSync6(join41(cwd, c));
+        const s = statSync6(join43(cwd, c));
         return s.isDirectory() ? c : c;
       } catch {
       }
@@ -33423,7 +34932,7 @@ function analyzeProject(cwd) {
     ciConfig: findCiConfig(cwd),
     readme: findFile(cwd, ["README.md", "README.rst", "README.txt", "Readme.md"]),
     sourceRoots: findSourceRoots(cwd),
-    hasGit: existsSync6(join41(cwd, ".git"))
+    hasGit: existsSync6(join43(cwd, ".git"))
   };
 }
 function bashDiscoveryCommands(profile) {
@@ -33588,7 +35097,7 @@ Aim for 100\u2013200 lines total. Use markdown tables where they save space.
 }
 function buildInitPrompt(cwd) {
   const existingName = ["AGENTS.md", "KIMI.md", "KIMIFLARE.md", "AGENT.md"].find(
-    (n) => existsSync6(join41(cwd, n))
+    (n) => existsSync6(join43(cwd, n))
   );
   const isRefresh = existingName !== void 0;
   const targetFilename = existingName ?? "AGENTS.md";
@@ -33672,7 +35181,7 @@ var init_context_generator = __esm({
 
 // src/init/run-init.ts
 import { existsSync as existsSync7 } from "fs";
-import { join as join42 } from "path";
+import { join as join44 } from "path";
 async function runInit(deps) {
   const {
     cfg,
@@ -33765,7 +35274,7 @@ async function runInit(deps) {
           lspManagerRef.current.notifyChange(path, content);
         } else {
           void import("fs/promises").then(
-            ({ readFile: readFile29 }) => readFile29(path, "utf8").then((c) => lspManagerRef.current.notifyChange(path, c)).catch(() => {
+            ({ readFile: readFile30 }) => readFile30(path, "utf8").then((c) => lspManagerRef.current.notifyChange(path, c)).catch(() => {
             })
           );
         }
@@ -33870,7 +35379,7 @@ async function runInit(deps) {
         }
       }
     });
-    if (existsSync7(join42(cwd, targetFilename))) {
+    if (existsSync7(join44(cwd, targetFilename))) {
       if (cacheStableRef.current) {
         messagesRef.current[1] = {
           role: "system",
@@ -33962,11 +35471,11 @@ var init_run_init = __esm({
 });
 
 // src/skills/discovery.ts
-import { readdir as readdir9, stat as stat8, readFile as readFile27 } from "fs/promises";
-import { join as join43, extname as extname2 } from "path";
+import { readdir as readdir9, stat as stat9, readFile as readFile29 } from "fs/promises";
+import { join as join45, extname as extname2 } from "path";
 async function dirExists(path) {
   try {
-    const s = await stat8(path);
+    const s = await stat9(path);
     return s.isDirectory();
   } catch {
     return false;
@@ -33974,7 +35483,7 @@ async function dirExists(path) {
 }
 async function fileExists(path) {
   try {
-    const s = await stat8(path);
+    const s = await stat9(path);
     return s.isFile();
   } catch {
     return false;
@@ -33987,20 +35496,20 @@ async function scanSkillDir(dirPath, source) {
   for (const entry of entries) {
     if (!entry.isFile()) continue;
     if (!SKILL_EXTENSIONS.has(extname2(entry.name))) continue;
-    files.push({ filePath: join43(dirPath, entry.name), source });
+    files.push({ filePath: join45(dirPath, entry.name), source });
   }
   return files;
 }
 async function discoverSkills(cwd) {
-  const agentsSkills = await scanSkillDir(join43(cwd, ".agents", "skills"), "agents");
-  const agentsMd = await fileExists(join43(cwd, "AGENTS.md")) ? [{ filePath: join43(cwd, "AGENTS.md"), source: "agents-md" }] : [];
-  const githubSkills = await scanSkillDir(join43(cwd, ".github", "skills"), "github");
-  const kimiflareSkills = await scanSkillDir(join43(cwd, ".kimiflare", "skills"), "kimiflare");
+  const agentsSkills = await scanSkillDir(join45(cwd, ".agents", "skills"), "agents");
+  const agentsMd = await fileExists(join45(cwd, "AGENTS.md")) ? [{ filePath: join45(cwd, "AGENTS.md"), source: "agents-md" }] : [];
+  const githubSkills = await scanSkillDir(join45(cwd, ".github", "skills"), "github");
+  const kimiflareSkills = await scanSkillDir(join45(cwd, ".kimiflare", "skills"), "kimiflare");
   const ordered = [...agentsSkills, ...agentsMd, ...githubSkills, ...kimiflareSkills];
   return ordered;
 }
 async function readSkillFile(filePath) {
-  const bytes = await readFile27(filePath);
+  const bytes = await readFile29(filePath);
   return { bytes, text: bytes.toString("utf-8") };
 }
 var SKILL_EXTENSIONS;
@@ -34012,9 +35521,9 @@ var init_discovery = __esm({
 });
 
 // src/skills/parser.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 function sha2562(input) {
-  return createHash5("sha256").update(input).digest("hex");
+  return createHash6("sha256").update(input).digest("hex");
 }
 function computeContentHash(rawText, parserVersion) {
   return sha2562(`${rawText}
@@ -34206,7 +35715,7 @@ var init_skills = __esm({
 
 // src/ui/run-startup-tasks.ts
 import { existsSync as existsSync8 } from "fs";
-import { join as join44 } from "path";
+import { join as join46 } from "path";
 function runStartupTasks(deps) {
   const {
     cfg,
@@ -34228,7 +35737,7 @@ function runStartupTasks(deps) {
     }
   });
   if (cfg.memoryEnabled) {
-    const dbPath = cfg.memoryDbPath ?? join44(process.cwd(), ".kimiflare", "memory.db");
+    const dbPath = cfg.memoryDbPath ?? join46(process.cwd(), ".kimiflare", "memory.db");
     const manager = new MemoryManager({
       dbPath,
       ...auth,
@@ -34260,7 +35769,7 @@ function runStartupTasks(deps) {
     });
     const cwd = process.cwd();
     sessionStartRecallRef.current = manager.recall({ text: cwd, repoPath: cwd, limit: 5 });
-    if (["AGENTS.md", "KIMI.md", "KIMIFLARE.md", "AGENT.md"].some((name) => existsSync8(join44(cwd, name)))) {
+    if (["AGENTS.md", "KIMI.md", "KIMIFLARE.md", "AGENT.md"].some((name) => existsSync8(join46(cwd, name)))) {
       const lastRefresh = manager.getLastKimiMdRefreshTime(cwd);
       const driftCount = manager.countHighSignalMemoriesSince(cwd, lastRefresh);
       if (driftCount >= 5) {
@@ -34271,7 +35780,7 @@ function runStartupTasks(deps) {
     memoryManagerRef.current?.close();
     memoryManagerRef.current = null;
   }
-  const skillDbPath = cfg.memoryDbPath ?? join44(process.cwd(), ".kimiflare", "memory.db");
+  const skillDbPath = cfg.memoryDbPath ?? join46(process.cwd(), ".kimiflare", "memory.db");
   const skillDb = getMemoryDb() ?? openMemoryDb(skillDbPath);
   initSkillsSchema(skillDb);
   void indexSkills({
@@ -34622,158 +36131,9 @@ var init_run_compact = __esm({
   }
 });
 
-// src/ui/bang-command.ts
-import { spawn as spawn10 } from "child_process";
-import { mkdtemp as mkdtemp2, readFile as readFile28, rm as rm3 } from "fs/promises";
-import { tmpdir as tmpdir4, platform as platform7 } from "os";
-import { join as join45 } from "path";
-function registerInkInstance(instance) {
-  inkInstance = instance;
-}
-function isTerminalHandedOff() {
-  return handedOff;
-}
-function parseBangCommand(input) {
-  const t = input.trimStart();
-  if (!t.startsWith("!")) return null;
-  return t.slice(1).trim();
-}
-function scriptInvocation(command, shell, logPath, plat = platform7()) {
-  if (plat === "darwin" || plat === "freebsd" || plat === "openbsd" || plat === "netbsd") {
-    return { file: "script", args: ["-q", logPath, shell, "-c", command] };
-  }
-  if (plat === "linux") {
-    return { file: "script", args: ["-q", "-e", "-c", command, logPath], env: { ...process.env, SHELL: shell } };
-  }
-  return null;
-}
-function cleanTerminalOutput(raw) {
-  const text = raw.replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, "").replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "").replace(/\x1b[@-Z\\-_]/g, "").replace(/^Script (?:started|done) on .*$/gm, "");
-  const lines = text.split(/\r?\n/).map((line) => {
-    const segs = line.split("\r");
-    let out = segs[segs.length - 1] ?? "";
-    if (!out && segs.length > 1) out = segs.filter(Boolean).pop() ?? "";
-    while (/[^\x08]\x08/.test(out)) out = out.replace(/[^\x08]\x08/, "");
-    return out.replace(/[\x00-\x08\x0b-\x1f\x7f]/g, "");
-  });
-  return lines.join("\n").replace(/\n{3,}/g, "\n\n").trim();
-}
-function truncateMiddle2(text, max = MAX_CONTEXT_CHARS2) {
-  if (text.length <= max) return text;
-  const half = Math.floor(max / 2);
-  return `${text.slice(0, half)}
-
-[\u2026 ${text.length - max} chars omitted \u2026]
-
-${text.slice(-half)}`;
-}
-function formatBangContext(r) {
-  const status = r.signal ? `killed by ${r.signal}` : `exit code ${r.exitCode ?? "?"}`;
-  const body = r.output === null ? "(output was shown in the user's terminal but could not be captured)" : r.output ? truncateMiddle2(r.output) : "(no output)";
-  return `[The user ran this shell command themselves with \`!\` in the autopilot prompt. This is context for you, not a new request.]
-$ ${r.command}
-(${status})
-${body}`;
-}
-function stopReading(stdin) {
-  stdin.pause();
-  const stream = stdin;
-  try {
-    if (stream._handle?.reading && stream._handle.readStop) {
-      stream._handle.readStop();
-      stream._handle.reading = false;
-      if (stream._readableState) stream._readableState.reading = false;
-    }
-  } catch {
-  }
-}
-function swallow() {
-  return ((_chunk, encOrCb, cb) => {
-    const done = typeof encOrCb === "function" ? encOrCb : cb;
-    if (typeof done === "function") done();
-    return true;
-  });
-}
-function spawnInherit(inv, cwd) {
-  return new Promise((resolve14, reject) => {
-    const child = spawn10(inv.file, inv.args, { cwd, stdio: "inherit", env: inv.env ?? process.env });
-    child.once("error", reject);
-    child.once("exit", (code, signal) => resolve14({ code, signal }));
-  });
-}
-async function runBangCommand(command, cwd) {
-  const isWindows = platform7() === "win32";
-  const shell = isWindows ? process.env.COMSPEC || "cmd.exe" : process.env.SHELL || "/bin/sh";
-  const direct = isWindows ? { file: shell, args: ["/c", command] } : { file: shell, args: ["-c", command] };
-  const stdin = process.stdin;
-  const stdout = process.stdout;
-  const stderr = process.stderr;
-  const origOut = stdout.write;
-  const origErr = stderr.write;
-  const readable = stdin.listeners("readable");
-  const wasRaw = stdin.isTTY ? stdin.isRaw : false;
-  const logDir2 = isWindows ? null : await mkdtemp2(join45(tmpdir4(), "autopilot-bang-"));
-  const logPath = logDir2 ? join45(logDir2, "out.log") : null;
-  const viaScript = logPath ? scriptInvocation(command, shell, logPath) : null;
-  inkInstance?.clear();
-  origOut.call(stdout, `
-$ ${command}
-`);
-  stdout.write = swallow();
-  stderr.write = swallow();
-  for (const l of readable) stdin.removeListener("readable", l);
-  if (stdin.isTTY) stdin.setRawMode(false);
-  stopReading(stdin);
-  handedOff = true;
-  let result2;
-  let captured = false;
-  let spawnError = null;
-  try {
-    if (viaScript) {
-      try {
-        result2 = await spawnInherit(viaScript, cwd);
-        captured = true;
-      } catch (e) {
-        logger.warn("bang:script_unavailable", { error: e.message });
-        result2 = await spawnInherit(direct, cwd);
-      }
-    } else {
-      result2 = await spawnInherit(direct, cwd);
-    }
-  } catch (e) {
-    result2 = { code: 127, signal: null };
-    spawnError = e.message;
-    logger.warn("bang:spawn_failed", { error: spawnError });
-  } finally {
-    handedOff = false;
-    stdout.write = origOut;
-    stderr.write = origErr;
-    if (stdin.isTTY) stdin.setRawMode(wasRaw);
-    for (const l of readable) stdin.addListener("readable", l);
-    origOut.call(stdout, "\n");
-  }
-  let output = spawnError ? `failed to start: ${spawnError}` : null;
-  if (captured && logPath) {
-    output = cleanTerminalOutput(await readFile28(logPath, "utf8").catch(() => ""));
-  }
-  if (logDir2) await rm3(logDir2, { recursive: true, force: true }).catch(() => {
-  });
-  return { command, exitCode: result2.code, signal: result2.signal, output };
-}
-var inkInstance, handedOff, MAX_CONTEXT_CHARS2;
-var init_bang_command = __esm({
-  "src/ui/bang-command.ts"() {
-    "use strict";
-    init_logger();
-    inkInstance = null;
-    handedOff = false;
-    MAX_CONTEXT_CHARS2 = 16e3;
-  }
-});
-
 // src/commands/save.ts
-import { mkdir as mkdir14, writeFile as writeFile15, unlink as unlink4 } from "fs/promises";
-import { dirname as dirname16 } from "path";
+import { mkdir as mkdir14, writeFile as writeFile15, unlink as unlink5 } from "fs/promises";
+import { dirname as dirname17 } from "path";
 async function saveCustomCommand(opts2) {
   const dir = opts2.source === "project" ? projectCommandsDir(opts2.cwd) : globalCommandsDir();
   const filepath = `${dir}/${opts2.name}.md`;
@@ -34784,12 +36144,12 @@ async function saveCustomCommand(opts2) {
   if (opts2.effort) data.effort = opts2.effort;
   const frontmatter = serializeFrontmatter(data);
   const content = frontmatter + opts2.template;
-  await mkdir14(dirname16(filepath), { recursive: true });
+  await mkdir14(dirname17(filepath), { recursive: true });
   await writeFile15(filepath, content, "utf8");
   return { filepath };
 }
 async function deleteCustomCommand(cmd) {
-  await unlink4(cmd.filepath);
+  await unlink5(cmd.filepath);
 }
 var init_save = __esm({
   "src/commands/save.ts"() {
@@ -34908,8 +36268,8 @@ __export(app_exports, {
 import React27, { useState as useState28, useRef as useRef9, useEffect as useEffect11, useCallback as useCallback9, useMemo as useMemo6 } from "react";
 import { Box as Box41, Text as Text42, useApp, useInput as useInput20, useWindowSize as useWindowSize2, render } from "ink";
 import { existsSync as existsSync9 } from "fs";
-import { join as join46, resolve as resolve13 } from "path";
-import { homedir as homedir26 } from "os";
+import { join as join47, resolve as resolve14 } from "path";
+import { homedir as homedir27 } from "os";
 import { jsx as jsx43, jsxs as jsxs40 } from "react/jsx-runtime";
 function App({
   initialCfg,
@@ -35231,8 +36591,8 @@ ${wcagWarnings.join("\n")}` }
       const exactDirectory = query === "~" || query === "." || query === ".." || query.endsWith("/..");
       const prefix = exactDirectory ? `${query.replace(/\/$/, "")}/` : slash >= 0 ? query.slice(0, slash + 1) : "";
       const directory = exactDirectory ? query : slash >= 0 ? query.slice(0, slash + 1) : query;
-      const expanded = directory.startsWith("~") ? join46(homedir26(), directory.slice(1)) : directory;
-      const target = resolve13(cwd, expanded || ".");
+      const expanded = directory.startsWith("~") ? join47(homedir27(), directory.slice(1)) : directory;
+      const target = resolve14(cwd, expanded || ".");
       const entries2 = await glob("*", {
         cwd: target,
         dot: false,
@@ -36208,7 +37568,7 @@ ${result2.output ?? "(output not captured)"}`,
         }
       }
       turnCounterRef.current += 1;
-      if (turnCounterRef.current % 15 === 0 && ["AGENTS.md", "KIMI.md", "KIMIFLARE.md", "AGENT.md"].some((name) => existsSync9(join46(process.cwd(), name))) && !kimiMdStale) {
+      if (turnCounterRef.current % 15 === 0 && ["AGENTS.md", "KIMI.md", "KIMIFLARE.md", "AGENT.md"].some((name) => existsSync9(join47(process.cwd(), name))) && !kimiMdStale) {
         setEvents((e) => [
           ...e,
           { kind: "info", key: mkKey(), text: "Tip: Rerunning /init occasionally helps autopilot (formerly kimiflare) stay accurate as your project evolves." }
@@ -36232,7 +37592,7 @@ ${result2.output ?? "(output not captured)"}`,
                 };
                 ensureSessionId();
                 const { sessionsDir: sessionsDir3 } = await Promise.resolve().then(() => (init_sessions(), sessions_exports));
-                const filePath = join46(sessionsDir3(), `${sessionIdRef.current}.json`);
+                const filePath = join47(sessionsDir3(), `${sessionIdRef.current}.json`);
                 await addCheckpoint(filePath, cp);
               }
               const summary = await generateContinuationSummary({
@@ -36600,7 +37960,7 @@ ${conflicts.join("\n")}` }
               lspManagerRef.current.notifyChange(path, content2);
             } else {
               void import("fs/promises").then(
-                ({ readFile: readFile29 }) => readFile29(path, "utf8").then((c) => lspManagerRef.current.notifyChange(path, c)).catch(() => {
+                ({ readFile: readFile30 }) => readFile30(path, "utf8").then((c) => lspManagerRef.current.notifyChange(path, c)).catch(() => {
                 })
               );
             }
@@ -36786,7 +38146,7 @@ ${conflicts.join("\n")}` }
                       };
                       ensureSessionId();
                       const { sessionsDir: sessionsDir3 } = await Promise.resolve().then(() => (init_sessions(), sessions_exports));
-                      const filePath = join46(sessionsDir3(), `${sessionIdRef.current}.json`);
+                      const filePath = join47(sessionsDir3(), `${sessionIdRef.current}.json`);
                       await addCheckpoint(filePath, cp);
                     }
                     const summary = await generateContinuationSummary({
@@ -37202,7 +38562,7 @@ ${conflicts.join("\n")}` }
       lsp: {
         servers: cfg?.lspServers ?? {},
         scope: lspScope,
-        hasProjectDir: existsSync9(join46(process.cwd(), ".kimiflare"))
+        hasProjectDir: existsSync9(join47(process.cwd(), ".kimiflare"))
       }
     });
   });
@@ -37259,7 +38619,7 @@ ${conflicts.join("\n")}` }
         onCommandDelete: handleCommandDelete2,
         lspServers: cfg?.lspServers ?? {},
         lspScope,
-        hasProjectDir: existsSync9(join46(process.cwd(), ".kimiflare")),
+        hasProjectDir: existsSync9(join47(process.cwd(), ".kimiflare")),
         onLspSave: handleLspSave2,
         themes: themeList(),
         onPickTheme: handleThemePick,
@@ -37770,8 +39130,8 @@ async function resolveFiles(filePatterns, cwd) {
   const resolved = /* @__PURE__ */ new Set();
   for (const pattern of filePatterns) {
     try {
-      const stat9 = await import("fs/promises").then((m) => m.stat(resolve6(cwd, pattern)));
-      if (stat9.isFile()) {
+      const stat10 = await import("fs/promises").then((m) => m.stat(resolve6(cwd, pattern)));
+      if (stat10.isFile()) {
         resolved.add(resolve6(cwd, pattern));
         continue;
       }
@@ -38110,6 +39470,55 @@ program.command("cost").description("Show cost attribution by task type (require
   await runCostCommand2({ ...cmdOpts, config: cfg });
 });
 program.addCommand(createRemoteCommand());
+var asterCommand = program.command("aster").description("Manage the Aster mobile API");
+var asterTokenCommand = asterCommand.command("token").description("Manage scoped Aster API credentials");
+asterTokenCommand.command("create").description("Create a 30-day credential scoped to selected workspace IDs").requiredOption("-n, --name <name>", "Credential label").requiredOption("-w, --workspace <id>", "Allowed workspace ID (repeatable)", (value, previous = []) => [...previous, value]).option("--expires-in-days <days>", "Expiry in days (1-365)", (value) => Number.parseInt(value, 10), 30).action(async (options) => {
+  const { loadAsterServerConfig: loadAsterServerConfig2 } = await Promise.resolve().then(() => (init_aster_workspaces(), aster_workspaces_exports));
+  const { AsterStore: AsterStore2 } = await Promise.resolve().then(() => (init_aster_store(), aster_store_exports));
+  try {
+    const config2 = await loadAsterServerConfig2();
+    const workspaceIds = [...new Set(options.workspace)];
+    if (!Number.isInteger(options.expiresInDays) || options.expiresInDays < 1 || options.expiresInDays > 365) {
+      throw new Error("--expires-in-days must be an integer from 1 through 365");
+    }
+    if (workspaceIds.some((id) => !config2.workspaces.some((workspace) => workspace.id === id))) {
+      throw new Error("credential includes an unknown workspace ID");
+    }
+    const store = new AsterStore2();
+    try {
+      const created = store.createCredential({
+        name: options.name,
+        workspaceIds,
+        scopes: ["workspaces:read", "models:read", "conversations:read", "conversations:write", "approvals:resolve"],
+        expiresAt: Date.now() + options.expiresInDays * 24 * 60 * 60 * 1e3
+      });
+      console.log(`Credential ID: ${created.id}`);
+      console.log(`Workspace scope: ${created.workspaceIds.join(", ")}`);
+      console.log(`Expires: ${new Date(created.expiresAt).toISOString()}`);
+      console.log("Copy this token into the Aster app's Keychain now; it will not be shown again:");
+      console.log(created.token);
+    } finally {
+      store.close();
+    }
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 2;
+  }
+});
+asterTokenCommand.command("revoke").description("Revoke an Aster credential immediately").argument("<credential-id>").action(async (credentialId) => {
+  const { AsterStore: AsterStore2 } = await Promise.resolve().then(() => (init_aster_store(), aster_store_exports));
+  const store = new AsterStore2();
+  try {
+    if (!store.revokeCredential(credentialId)) {
+      console.error("Aster credential not found");
+      process.exitCode = 1;
+      return;
+    }
+    console.log(`Revoked credential ${credentialId}`);
+  } finally {
+    store.close();
+  }
+});
 var logsCmd = program.command("logs").description("Inspect KimiFlare's structured logs (jsonl, one file per day, 7-day retention)");
 logsCmd.command("path").description("Print today's log file path. Useful for tailing: tail -f $(autopilot logs path) | jq").action(async () => {
   const { logPathFor: logPathFor2 } = await Promise.resolve().then(() => (init_log_sink(), log_sink_exports));
@@ -38386,11 +39795,11 @@ async function promptHidden(question) {
     }
   });
   const rl = createInterface4({ input: process.stdin, output, terminal: true });
-  return new Promise((resolve14) => {
+  return new Promise((resolve15) => {
     rl.question(question, (answer) => {
       rl.close();
       process.stdout.write("\n");
-      resolve14(answer);
+      resolve15(answer);
     });
     muted = true;
   });