autopilot-ai 1.19.0 → 1.19.2

package/dist/index.js

@@ -4899,8 +4899,8 @@ var init_subagent_policy = __esm({
   "src/intent/subagent-policy.ts"() {
     "use strict";
     init_jev();
-    EXPLICIT_NO = /\b(?:do\s+not|don't|dont|never|avoid|without|no)\s+(?:(?:(?:want\s+to\s+)?(?:use|using|spawn|call|ask|start|launch|skip))\s+)?(?:(?:any|the|a)\s+)?(?:sub[- ]?agents?|agents?|workers?)\b|\b(?:do\s+not|don't|dont|never|avoid|without|no)\s+delegat(?:e|ion|ing)\b|\bwork\s+sequentially\b/i;
-    EXPLICIT_YES = /\b(?:use|spawn|call|start|launch|ask|send|delegate\s+to)\s+(?:(?:some|several|multiple|parallel)\s+)?(?:sub[- ]?agents?|agents?|workers?)\b|\b(?:parallelize|split)\b.{0,50}\b(?:agents?|workers?|subtasks?)\b/i;
+    EXPLICIT_NO = /\b(?:do\s+not|don't|dont|never|avoid|without|no)\s+(?:(?:(?:want\s+to\s+)?(?:use|using|spawn|call|ask|start|launch|skip|run|spin(?:\s+up)?))\s+)?(?:(?:any|the|a|some|several|multiple|parallel|\d+|one|two|three|four|five|six|seven|eight|nine|ten)\s+)?(?:sub[- ]?agents?|agents?|workers?)\b|\b(?:do\s+not|don't|dont|never|avoid|without|no)\s+delegat(?:e|ion|ing)\b|\bwork\s+sequentially\b/i;
+    EXPLICIT_YES = /\b(?:use|spawn|call|start|launch|ask|send|run|spin(?:\s+up)?|delegate\s+to)\s+(?:(?:some|several|multiple|parallel|\d+|one|two|three|four|five|six|seven|eight|nine|ten)\s+)?(?:sub[- ]?agents?|agents?|workers?)\b|\b(?:parallelize|split)\b.{0,50}\b(?:agents?|workers?|subtasks?)\b/i;
     SEQUENTIAL_DEPENDENCY = /\b(?:one\s+at\s+a\s+time|sequentially|in\s+sequence|in\s+dependency\s+order|tightly\s+coupled|same\s+(?:file|function|module)|first\b.{0,80}\bbefore\b|before\b.{0,80}\bthen\b|step[- ]by[- ]step)\b/i;
     CLEAR_PARALLEL = /\b(?:independent\s+(?:research|tasks?|questions?|work)|in\s+parallel|parallel\s+agents?|separately\s+investigate)\b/i;
     AMBIGUOUS_CANDIDATE = /\b(?:research|investigat\w*|audit|compare|contrast|review|comprehensive|across\s+(?:the\s+)?(?:codebase|repo|repository)|entire\s+(?:codebase|repo|repository)|multiple\s+(?:systems|modules|approaches|sources))\b/i;
@@ -13410,10 +13410,11 @@ async function loadAsterServerConfig(configPath3 = process.env.AUTOPILOT_ASTER_C
   }
   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) {
+  const modelCatalog = record.models === "openrouter" ? "openrouter" : "fixed";
+  if (modelCatalog === "fixed" && (!Array.isArray(record.models) || record.models.length === 0 || record.models.length > 100)) {
     throw new AsterConfigError();
   }
-  const models = [...new Set(record.models)];
+  const models = modelCatalog === "fixed" ? [...new Set(record.models)] : [];
   if (models.some((model) => typeof model !== "string" || !model.trim() || model.length > 200)) {
     throw new AsterConfigError();
   }
@@ -13451,7 +13452,7 @@ async function loadAsterServerConfig(configPath3 = process.env.AUTOPILOT_ASTER_C
     roots.push(rootPath);
     workspaces.push({ id: workspace.id, displayName: workspace.displayName.trim(), rootPath });
   }
-  return { models, workspaces, approvalTtlMs };
+  return { models, modelCatalog, workspaces, approvalTtlMs };
 }
 function findAsterWorkspace(config2, workspaceId) {
   return config2.workspaces.find((workspace) => workspace.id === workspaceId);
@@ -13476,7 +13477,8 @@ var init_aster_workspaces = __esm({
 // src/server/aster-store.ts
 var aster_store_exports = {};
 __export(aster_store_exports, {
-  AsterStore: () => AsterStore
+  AsterStore: () => AsterStore,
+  defaultAsterDbPath: () => defaultAsterDbPath
 });
 import Database3 from "better-sqlite3";
 import { createHash as createHash3, randomBytes as randomBytes2, randomUUID as randomUUID5 } from "crypto";
@@ -13641,6 +13643,20 @@ var init_aster_store = __esm({
         UNIQUE(credential_id, create_key_hash)
       );
       CREATE INDEX IF NOT EXISTS idx_aster_cells_lifecycle ON aster_cell_mappings(status, updated_at);
+      CREATE TABLE IF NOT EXISTS aster_github_grants (
+        conversation_id TEXT PRIMARY KEY,
+        token TEXT NOT NULL UNIQUE,
+        repository TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        revoked_at INTEGER
+      );
+      CREATE TABLE IF NOT EXISTS aster_conversation_projects (
+        conversation_id TEXT PRIMARY KEY,
+        kind TEXT NOT NULL,
+        repository TEXT,
+        branch TEXT,
+        created_at INTEGER NOT NULL
+      );
     `);
         try {
           chmodSync2(dbPath, 384);
@@ -13818,6 +13834,47 @@ var init_aster_store = __esm({
         });
         return update.immediate();
       }
+      /** Records a conversation's project once; the first value wins so retries can't change it. */
+      setConversationProject(conversationId, project) {
+        this.db.prepare(`INSERT OR IGNORE INTO aster_conversation_projects (conversation_id, kind, repository, branch, created_at)
+      VALUES (?, ?, ?, ?, ?)`).run(conversationId, project.kind, project.repository, project.branch, Date.now());
+      }
+      getConversationProject(conversationId) {
+        const row = this.db.prepare("SELECT kind, repository, branch FROM aster_conversation_projects WHERE conversation_id = ?").get(conversationId);
+        if (!row) return void 0;
+        return { kind: row.kind === "code" ? "code" : "chat", repository: row.repository, branch: row.branch };
+      }
+      /**
+       * The repository-scoped GitHub token for a code conversation, created once. It is stored
+       * as-is (like the server's own GitHub token, it never leaves the server except into that
+       * conversation's cell) so provisioning retries hand the cell the same value.
+       */
+      getOrCreateGitHubGrant(conversationId, repository) {
+        const existing = this.db.prepare("SELECT token FROM aster_github_grants WHERE conversation_id = ? AND revoked_at IS NULL").get(conversationId);
+        if (existing) return existing.token;
+        const token = "aghp_" + randomBytes2(32).toString("base64url");
+        this.db.prepare(`INSERT INTO aster_github_grants (conversation_id, token, repository, created_at) VALUES (?, ?, ?, ?)
+      ON CONFLICT(conversation_id) DO UPDATE SET token = excluded.token, repository = excluded.repository, created_at = excluded.created_at, revoked_at = NULL`).run(conversationId, token, repository, Date.now());
+        return token;
+      }
+      resolveGitHubGrant(token) {
+        const row = this.db.prepare("SELECT conversation_id, repository FROM aster_github_grants WHERE token = ? AND revoked_at IS NULL").get(token);
+        return row ? { conversationId: row.conversation_id, repository: row.repository } : void 0;
+      }
+      revokeGitHubGrant(conversationId) {
+        this.db.prepare("UPDATE aster_github_grants SET revoked_at = ? WHERE conversation_id = ? AND revoked_at IS NULL").run(Date.now(), conversationId);
+      }
+      /** Switch an idle conversation's model; refused while a turn is active. */
+      setConversationModel(conversationId, model) {
+        const update = this.db.transaction(() => {
+          const now2 = Date.now();
+          const result2 = this.db.prepare("UPDATE aster_conversations SET model = ?, updated_at = ? WHERE id = ? AND active_run_id IS NULL").run(model, now2, conversationId);
+          if (result2.changes !== 1) return false;
+          this.insertEvent(conversationId, null, "model.changed", { model }, 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();
@@ -14720,6 +14777,217 @@ var init_wake_scheduler = __esm({
   }
 });
 
+// src/models/openrouter-catalog.ts
+var openrouter_catalog_exports = {};
+__export(openrouter_catalog_exports, {
+  DEFAULT_CACHE_TTL_MS: () => DEFAULT_CACHE_TTL_MS,
+  ensureOpenRouterCatalog: () => ensureOpenRouterCatalog,
+  fetchOpenRouterCatalog: () => fetchOpenRouterCatalog,
+  loadOpenRouterCatalog: () => loadOpenRouterCatalog,
+  mapOpenRouterModel: () => mapOpenRouterModel
+});
+import { readFile as readFile20, writeFile as writeFile12, mkdir as mkdir13 } from "fs/promises";
+import { homedir as homedir22 } from "os";
+import { join as join30, dirname as dirname15 } from "path";
+function catalogCachePath() {
+  const xdg = process.env.XDG_CONFIG_HOME || join30(homedir22(), ".config");
+  return join30(xdg, "kimiflare", "openrouter-models.json");
+}
+function perMtok(perToken) {
+  const n = Number(perToken);
+  return Number.isFinite(n) ? n * 1e6 : 0;
+}
+function mapOpenRouterModel(raw) {
+  const supported = new Set(raw.supported_parameters ?? []);
+  const aa = raw.benchmarks?.artificial_analysis;
+  const quality = {
+    ...typeof aa?.coding_index === "number" ? { coding: aa.coding_index } : {},
+    ...typeof aa?.agentic_index === "number" ? { agentic: aa.agentic_index } : {},
+    ...typeof aa?.intelligence_index === "number" ? { intelligence: aa.intelligence_index } : {}
+  };
+  return {
+    id: raw.id,
+    ...raw.name ? { name: raw.name } : {},
+    ...typeof raw.created === "number" ? { created: raw.created } : {},
+    ...Object.keys(quality).length > 0 ? { quality } : {},
+    ...raw.supported_parameters ? { parameters: [...raw.supported_parameters] } : {},
+    contextWindow: raw.context_length ?? 128e3,
+    maxOutputTokens: raw.top_provider?.max_completion_tokens ?? 4096,
+    pricing: {
+      inputPerMtok: perMtok(raw.pricing?.prompt),
+      ...raw.pricing?.input_cache_read ? { cachedInputPerMtok: perMtok(raw.pricing.input_cache_read) } : {},
+      outputPerMtok: perMtok(raw.pricing?.completion)
+    },
+    supports: {
+      // OpenRouter's own catalog is the authority on whether a model accepts tool
+      // calls; absence of "tools" here means the upstream provider doesn't support
+      // function calling for this model, and we must not claim otherwise.
+      tools: supported.has("tools"),
+      reasoning: supported.has("reasoning") || supported.has("include_reasoning"),
+      streaming: true,
+      vision: (raw.architecture?.input_modalities ?? []).includes("image"),
+      temperature: supported.has("temperature") ? true : void 0
+    }
+  };
+}
+async function fetchOpenRouterCatalog(fetchImpl2 = fetch) {
+  const res = await fetchWithNetworkRetry(fetchImpl2, openRouterUrl("models"), {
+    headers: { Accept: "application/json" }
+  });
+  if (!res.ok) {
+    throw new Error(`OpenRouter /models returned HTTP ${res.status}`);
+  }
+  const body = await res.json();
+  return (body.data ?? []).map(mapOpenRouterModel);
+}
+async function readCache3() {
+  try {
+    const raw = await readFile20(catalogCachePath(), "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed.version === CACHE_VERSION ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+async function writeCache3(models) {
+  const path = catalogCachePath();
+  try {
+    await mkdir13(dirname15(path), { recursive: true });
+    const cache = { version: CACHE_VERSION, fetchedAt: (/* @__PURE__ */ new Date()).toISOString(), models };
+    await writeFile12(path, JSON.stringify(cache, null, 2), "utf8");
+  } catch {
+  }
+}
+async function loadOpenRouterCatalog(opts2 = {}) {
+  const ttlMs = opts2.ttlMs ?? DEFAULT_CACHE_TTL_MS;
+  const cached = await readCache3();
+  const isFresh = cached && Date.now() - Date.parse(cached.fetchedAt) < ttlMs;
+  if (isFresh) return cached.models;
+  try {
+    const models = await fetchOpenRouterCatalog(opts2.fetchImpl ?? fetch);
+    await writeCache3(models);
+    return models;
+  } catch {
+    return cached?.models ?? [];
+  }
+}
+async function ensureOpenRouterCatalog(opts2 = {}) {
+  try {
+    const models = await loadOpenRouterCatalog(opts2);
+    if (models.length > 0) registerOpenRouterModels(models);
+    return models.length;
+  } catch {
+    return 0;
+  }
+}
+var CACHE_VERSION, DEFAULT_CACHE_TTL_MS;
+var init_openrouter_catalog = __esm({
+  "src/models/openrouter-catalog.ts"() {
+    "use strict";
+    init_registry();
+    init_openrouter();
+    CACHE_VERSION = 4;
+    DEFAULT_CACHE_TTL_MS = 6 * 60 * 60 * 1e3;
+  }
+});
+
+// src/server/aster-github.ts
+function mapRepository(raw) {
+  return {
+    fullName: raw.full_name,
+    name: raw.name,
+    owner: raw.owner?.login ?? raw.full_name.split("/")[0] ?? "",
+    private: raw.private,
+    description: raw.description,
+    defaultBranch: raw.default_branch ?? "main",
+    updatedAt: raw.pushed_at ?? raw.updated_at ?? null
+  };
+}
+var AsterGitHubError, REPOSITORY_FULL_NAME_RE, REPOSITORY_NAME_RE, API, AsterGitHub;
+var init_aster_github = __esm({
+  "src/server/aster-github.ts"() {
+    "use strict";
+    AsterGitHubError = class extends Error {
+      constructor(message2, status, code) {
+        super(message2);
+        this.status = status;
+        this.code = code;
+        this.name = "AsterGitHubError";
+      }
+      status;
+      code;
+    };
+    REPOSITORY_FULL_NAME_RE = /^[A-Za-z0-9](?:[A-Za-z0-9-]{0,38})\/[A-Za-z0-9._-]{1,100}$/;
+    REPOSITORY_NAME_RE = /^[A-Za-z0-9._-]{1,100}$/;
+    API = "https://api.github.com";
+    AsterGitHub = class {
+      constructor(token = process.env.GITHUB_TOKEN, fetchImpl2 = fetch) {
+        this.token = token;
+        this.fetchImpl = fetchImpl2;
+      }
+      token;
+      fetchImpl;
+      get configured() {
+        return Boolean(this.token?.trim());
+      }
+      /** Repositories the token can push to, most recently pushed first. */
+      async listRepositories(query = "") {
+        const raw = await this.request(
+          "GET",
+          "/user/repos?per_page=100&sort=pushed&affiliation=owner,collaborator,organization_member"
+        );
+        const needle = query.trim().toLowerCase();
+        return raw.map(mapRepository).filter((repo) => !needle || repo.fullName.toLowerCase().includes(needle) || (repo.description ?? "").toLowerCase().includes(needle));
+      }
+      async getRepository(fullName) {
+        if (!REPOSITORY_FULL_NAME_RE.test(fullName)) throw new AsterGitHubError("Invalid repository name", 400, "invalid_repository");
+        return mapRepository(await this.request("GET", `/repos/${fullName}`));
+      }
+      /** Creates a repository under the token's user, initialized so it has a default branch to clone. */
+      async createRepository(input) {
+        if (!REPOSITORY_NAME_RE.test(input.name) || input.name === "." || input.name === "..") {
+          throw new AsterGitHubError("Repository names may use letters, digits, '.', '_' and '-'", 400, "invalid_repository_name");
+        }
+        const description = input.description?.trim().slice(0, 350);
+        return mapRepository(await this.request("POST", "/user/repos", {
+          name: input.name,
+          private: input.private,
+          auto_init: true,
+          ...description ? { description } : {}
+        }));
+      }
+      async request(method, path, body) {
+        if (!this.configured) throw new AsterGitHubError("GitHub is not connected on the server", 503, "github_not_configured");
+        let response;
+        try {
+          response = await this.fetchImpl(API + path, {
+            method,
+            headers: {
+              Accept: "application/vnd.github+json",
+              Authorization: `Bearer ${this.token}`,
+              "X-GitHub-Api-Version": "2022-11-28",
+              "User-Agent": "autopilot-aster",
+              ...body === void 0 ? {} : { "Content-Type": "application/json" }
+            },
+            body: body === void 0 ? void 0 : JSON.stringify(body),
+            signal: AbortSignal.timeout(2e4)
+          });
+        } catch {
+          throw new AsterGitHubError("GitHub could not be reached", 502, "github_unreachable");
+        }
+        if (response.ok) return await response.json();
+        const detail = await response.json().catch(() => ({}));
+        const message2 = detail.errors?.[0]?.message ?? detail.message ?? `GitHub returned HTTP ${response.status}`;
+        if (response.status === 404) throw new AsterGitHubError("Repository not found or not accessible with the server's GitHub token", 404, "repository_not_found");
+        if (response.status === 401) throw new AsterGitHubError("The server's GitHub token was rejected", 502, "github_token_rejected");
+        if (response.status === 403) throw new AsterGitHubError(`GitHub refused the request: ${message2}`, 403, "github_forbidden");
+        if (response.status === 422) throw new AsterGitHubError(message2, 422, "github_validation_failed");
+        throw new AsterGitHubError(message2, 502, "github_error");
+      }
+    };
+  }
+});
+
 // src/server/aster-tools.ts
 import { realpath as realpath5 } from "fs/promises";
 import { isAbsolute as isAbsolute5, relative as relative7, sep as sep5 } from "path";
@@ -14785,11 +15053,18 @@ function posixNormalize(value) {
   }
   return "/" + out.join("/");
 }
+function isLikelySkKey(candidate) {
+  if (/^sk-or-v1-[A-Za-z0-9]{16,}/.test(candidate)) return true;
+  return candidate.slice(3).split(/[-_]/).some((chunk) => chunk.length >= 20 && /\d/.test(chunk));
+}
 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);
+  for (const match of value.matchAll(SK_CANDIDATE_RE)) {
+    if (isLikelySkKey(match[0])) return true;
+  }
+  return /(?:\bgh[pousr]_[A-Za-z0-9]{20,}|\bgithub_pat_[A-Za-z0-9_]{20,}|(?:CLOUDFLARE|OPENROUTER|REQUESTY)_API_(?:KEY|TOKEN)\s*=)/.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]");
+  return value.replace(SK_CANDIDATE_RE, (match) => isLikelySkKey(match) ? "[REDACTED_PROVIDER_SECRET]" : match).replace(/\bgh[pousr]_[A-Za-z0-9]{20,}/g, "[REDACTED_PROVIDER_SECRET]").replace(/\bgithub_pat_[A-Za-z0-9_]{20,}/g, "[REDACTED_PROVIDER_SECRET]");
 }
 function assertInside(root, candidate) {
   const rel = relative7(root, candidate);
@@ -14801,7 +15076,7 @@ function assertNotSensitive(root, candidate) {
     throw new Error("workspace_sensitive_path_forbidden");
   }
 }
-var ASTR_TOOLS, SENSITIVE_NAMES;
+var ASTR_TOOLS, SENSITIVE_NAMES, SK_CANDIDATE_RE;
 var init_aster_tools = __esm({
   "src/server/aster-tools.ts"() {
     "use strict";
@@ -14824,11 +15099,519 @@ var init_aster_tools = __esm({
       "credentials",
       "secrets"
     ]);
+    SK_CANDIDATE_RE = /(?<![A-Za-z0-9])sk-[A-Za-z0-9_-]{16,}/g;
   }
 });
 
-// src/server/aster-api.ts
+// src/server/aster-memory.ts
+import Database4 from "better-sqlite3";
 import { randomUUID as randomUUID6 } from "crypto";
+import { chmodSync as chmodSync3, mkdirSync as mkdirSync7 } from "fs";
+import { dirname as dirname16 } from "path";
+function rowToItem(row) {
+  return {
+    id: row.id,
+    kind: row.kind,
+    key: row.key,
+    title: row.title,
+    content: row.content,
+    pinned: row.pinned === 1,
+    sourceConversationId: row.source_conversation_id,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function normalizeKey(kind, value) {
+  const raw = value.toLowerCase().startsWith(`${kind}:`) ? value.slice(kind.length + 1) : value;
+  const slug = raw.toLowerCase().normalize("NFKD").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
+  const key = `${kind}:${slug}`;
+  return KEY_RE.test(key) ? key : null;
+}
+function formatCard(card) {
+  return `- ${card.title} (${card.kind}): ${card.content}`;
+}
+function mentions(text, card) {
+  const haystack = ` ${text.toLowerCase()} `;
+  const words = /* @__PURE__ */ new Set();
+  for (const part of [card.title, card.key?.split(":")[1]?.replace(/-/g, " ") ?? ""]) {
+    for (const word of part.toLowerCase().split(/[^\p{L}\p{N}]+/u)) {
+      if (word.length >= 3 && !STOP_WORDS.has(word)) words.add(word);
+    }
+  }
+  return [...words].some((word) => new RegExp(`[^\\p{L}\\p{N}]${escapeRegExp(word)}[^\\p{L}\\p{N}]`, "u").test(haystack));
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var MAX_CARD_CHARS, MAX_FACT_CHARS, MAX_MEMORY_PROMPT_ITEMS, BRIEF_FACTS, BRIEF_RECENT_SESSIONS, BRIEF_RECENT_CARDS, KEY_RE, AsterMemory, EXTRACTION_PROMPT, STOP_WORDS;
+var init_aster_memory = __esm({
+  "src/server/aster-memory.ts"() {
+    "use strict";
+    init_openrouter();
+    init_aster_store();
+    init_aster_tools();
+    MAX_CARD_CHARS = 900;
+    MAX_FACT_CHARS = 300;
+    MAX_MEMORY_PROMPT_ITEMS = 150;
+    BRIEF_FACTS = 15;
+    BRIEF_RECENT_SESSIONS = 6;
+    BRIEF_RECENT_CARDS = 3;
+    KEY_RE = /^(person|project):[a-z0-9][a-z0-9-]{0,80}$/;
+    AsterMemory = class {
+      constructor(dbPath = defaultAsterDbPath(), options = {}) {
+        this.options = options;
+        mkdirSync7(dirname16(dbPath), { recursive: true, mode: 448 });
+        this.db = new Database4(dbPath);
+        this.db.pragma("journal_mode = WAL");
+        this.db.pragma("busy_timeout = 5000");
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS aster_memories (
+        id TEXT PRIMARY KEY,
+        kind TEXT NOT NULL,
+        key TEXT,
+        title TEXT NOT NULL,
+        content TEXT NOT NULL,
+        pinned INTEGER NOT NULL DEFAULT 0,
+        source_conversation_id TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        deleted INTEGER NOT NULL DEFAULT 0
+      );
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_aster_memories_key ON aster_memories(key) WHERE key IS NOT NULL AND deleted = 0;
+      CREATE INDEX IF NOT EXISTS idx_aster_memories_kind ON aster_memories(kind, deleted, updated_at);
+    `);
+        try {
+          chmodSync3(dbPath, 384);
+        } catch {
+        }
+      }
+      options;
+      db;
+      /** Card keys already shown to the agent per conversation, so later turns only add new ones. */
+      shown = /* @__PURE__ */ new Map();
+      get enabled() {
+        return this.options.enabled !== false && Boolean(this.apiKey);
+      }
+      get apiKey() {
+        return this.options.apiKey ?? process.env.OPENROUTER_API_KEY;
+      }
+      get model() {
+        return this.options.model ?? process.env.AUTOPILOT_ASTER_MEMORY_MODEL ?? "google/gemini-3.8-flash";
+      }
+      close() {
+        this.db.close();
+      }
+      list(kind) {
+        const rows = kind ? this.db.prepare("SELECT * FROM aster_memories WHERE deleted = 0 AND kind = ? ORDER BY updated_at DESC").all(kind) : this.db.prepare("SELECT * FROM aster_memories WHERE deleted = 0 ORDER BY updated_at DESC").all();
+        return rows.map(rowToItem);
+      }
+      get(id) {
+        const row = this.db.prepare("SELECT * FROM aster_memories WHERE id = ? AND deleted = 0").get(id);
+        return row ? rowToItem(row) : void 0;
+      }
+      /** Soft delete; the user removed it, so extraction must not silently recreate it from this item. */
+      delete(id) {
+        return this.db.prepare("UPDATE aster_memories SET deleted = 1, updated_at = ? WHERE id = ? AND deleted = 0").run(Date.now(), id).changes === 1;
+      }
+      /** Write or merge one item. person/project/session are keyed; facts are by id. */
+      upsert(input) {
+        const now2 = Date.now();
+        const limit = input.kind === "fact" ? MAX_FACT_CHARS : MAX_CARD_CHARS;
+        const title = input.title.trim().slice(0, 120);
+        const content = input.content.trim().slice(0, limit);
+        const existing = input.key ? this.db.prepare("SELECT * FROM aster_memories WHERE key = ? AND deleted = 0").get(input.key) : input.id ? this.db.prepare("SELECT * FROM aster_memories WHERE id = ? AND deleted = 0").get(input.id) : void 0;
+        if (existing) {
+          this.db.prepare("UPDATE aster_memories SET title = ?, content = ?, pinned = ?, updated_at = ? WHERE id = ?").run(title, content, existing.pinned || input.pinned ? 1 : 0, now2, existing.id);
+          return { item: this.get(existing.id), change: "updated" };
+        }
+        const id = randomUUID6();
+        this.db.prepare(`INSERT INTO aster_memories (id, kind, key, title, content, pinned, source_conversation_id, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, input.kind, input.key ?? null, title, content, input.pinned ? 1 : 0, input.sourceConversationId ?? null, now2, now2);
+        return { item: this.get(id), change: "added" };
+      }
+      /**
+       * The memory note for a turn: a full brief on a conversation's first turn, afterwards only
+       * person/project cards the user's message newly brings up. Empty when there is nothing new.
+       */
+      brief(conversationId, userText) {
+        const items = this.list();
+        if (items.length === 0) return "";
+        const shown = this.shown.get(conversationId);
+        const cards = items.filter((item) => item.kind === "person" || item.kind === "project");
+        const mentioned = cards.filter((card) => mentions(userText, card));
+        if (shown) {
+          const fresh = mentioned.filter((card) => !shown.has(card.id));
+          if (fresh.length === 0) return "";
+          fresh.forEach((card) => shown.add(card.id));
+          return `[Aster memory \u2014 relevant to this message]
+${fresh.map(formatCard).join("\n")}`;
+        }
+        const shownNow = /* @__PURE__ */ new Set();
+        const facts = items.filter((item) => item.kind === "fact").sort((a, b) => Number(b.pinned) - Number(a.pinned) || b.updatedAt - a.updatedAt).slice(0, BRIEF_FACTS);
+        const featured = [...mentioned, ...cards.filter((card) => !mentioned.includes(card)).slice(0, BRIEF_RECENT_CARDS)];
+        featured.forEach((card) => shownNow.add(card.id));
+        const others = cards.filter((card) => !shownNow.has(card.id));
+        const sessions = items.filter((item) => item.kind === "session" && item.key !== conversationId).slice(0, BRIEF_RECENT_SESSIONS);
+        this.shown.set(conversationId, shownNow);
+        const sections = [
+          "[Aster memory \u2014 what you know about the user from earlier chats. Use it naturally and don't recite it. The full memory is in /workspace/.aster/memory.md; grep it when the user mentions someone or something you don't recognize.]"
+        ];
+        if (facts.length) sections.push("About the user:\n" + facts.map((fact) => `- ${fact.content}`).join("\n"));
+        if (featured.length) sections.push("People and projects:\n" + featured.map(formatCard).join("\n"));
+        if (others.length) sections.push("Also known (details in memory.md): " + others.map((card) => card.title).join(", "));
+        if (sessions.length) sections.push("Recent chats:\n" + sessions.map((session) => `- ${session.title}: ${session.content}`).join("\n"));
+        return sections.join("\n\n");
+      }
+      /** All memory as Markdown, written into the cell so the agent can search it on demand. */
+      snapshot() {
+        const items = this.list();
+        const group = (kind, heading, render2) => {
+          const entries = items.filter((item) => item.kind === kind);
+          return entries.length ? `## ${heading}
+
+${entries.map(render2).join("\n")}
+` : "";
+        };
+        return [
+          "# Aster memory\n\nWhat the user's assistant remembers across chats. Read-only here; it is updated automatically after each turn.\n",
+          group("fact", "About the user", (item) => `- ${item.content}`),
+          group("person", "People", (item) => `### ${item.title}
+${item.content}
+`),
+          group("project", "Projects", (item) => `### ${item.title}
+${item.content}
+`),
+          group("session", "Chats", (item) => `- **${item.title}** (${new Date(item.updatedAt).toISOString().slice(0, 10)}): ${item.content}`)
+        ].filter(Boolean).join("\n");
+      }
+      /** Read one exchange and update memory. Returns what changed (for the app's "memory updated" chip). */
+      async remember(exchange) {
+        if (!this.enabled) return [];
+        const result2 = await this.extract(exchange);
+        if (!result2) return [];
+        const changes = [];
+        const known = new Map(this.list().filter((item) => item.kind !== "session").map((item) => [item.id, item]));
+        for (const id of result2.deletes ?? []) {
+          const item = known.get(id);
+          if (item && !item.pinned && this.delete(id)) changes.push({ id, kind: item.kind, title: item.title, change: "removed" });
+        }
+        for (const upsert of result2.upserts ?? []) {
+          const kind = upsert.kind === "person" || upsert.kind === "project" || upsert.kind === "fact" ? upsert.kind : void 0;
+          const title = upsert.title?.trim();
+          const content = upsert.content?.trim();
+          if (!kind || !title || !content || containsLikelyProviderSecret(content)) continue;
+          const key = kind === "fact" ? null : normalizeKey(kind, upsert.key ?? title);
+          if (kind !== "fact" && !key) continue;
+          const id = kind === "fact" && upsert.id && known.has(upsert.id) ? upsert.id : null;
+          const { item, change } = this.upsert({ kind, key, id, title, content, pinned: upsert.pinned === true, sourceConversationId: exchange.conversationId });
+          changes.push({ id: item.id, kind, title: item.title, change });
+        }
+        const session = result2.session;
+        if (session?.title?.trim() && session.summary?.trim()) {
+          const repo = exchange.project?.kind === "code" && exchange.project.repository ? ` [${exchange.project.repository}]` : "";
+          this.upsert({
+            kind: "session",
+            key: exchange.conversationId,
+            title: session.title.trim().slice(0, 80) + repo,
+            content: session.summary.trim(),
+            sourceConversationId: exchange.conversationId
+          });
+        }
+        return changes;
+      }
+      async extract(exchange) {
+        const items = this.list().filter((item) => item.kind !== "session").sort((a, b) => Number(b.pinned) - Number(a.pinned) || b.updatedAt - a.updatedAt).slice(0, MAX_MEMORY_PROMPT_ITEMS);
+        const currentSession = this.list("session").find((item) => item.key === exchange.conversationId);
+        const memory = items.length ? items.map((item) => JSON.stringify({ id: item.id, kind: item.kind, key: item.key, title: item.title, content: item.content, pinned: item.pinned })).join("\n") : "(empty)";
+        const context = exchange.project?.kind === "code" && exchange.project.repository ? `Code chat in GitHub repository ${exchange.project.repository}.` : "General chat.";
+        const user = [
+          `CURRENT MEMORY (one JSON object per line):
+${memory}`,
+          `THIS CHAT: ${context}${currentSession ? ` Summary so far: ${currentSession.content}` : ""}`,
+          `LATEST USER MESSAGE:
+${exchange.userText.slice(0, 6e3)}`,
+          `ASSISTANT REPLY:
+${exchange.assistantText.slice(0, 4e3)}`
+        ].join("\n\n");
+        let response;
+        try {
+          response = await (this.options.fetchImpl ?? fetch)(openRouterUrl("chat/completions"), {
+            method: "POST",
+            headers: { ...openRouterHeaders(this.apiKey), "Content-Type": "application/json" },
+            body: JSON.stringify({
+              model: this.model,
+              temperature: 0,
+              response_format: { type: "json_object" },
+              messages: [{ role: "system", content: EXTRACTION_PROMPT }, { role: "user", content: user }]
+            }),
+            signal: AbortSignal.timeout(3e4)
+          });
+        } catch {
+          return void 0;
+        }
+        if (!response.ok) return void 0;
+        const body = await response.json().catch(() => void 0);
+        const text = body?.choices?.[0]?.message?.content;
+        if (!text) return void 0;
+        try {
+          return JSON.parse(text.replace(/^```(?:json)?\s*|\s*```$/g, ""));
+        } catch {
+          return void 0;
+        }
+      }
+    };
+    EXTRACTION_PROMPT = `You maintain the long-term memory of one person (the user) for their AI assistant, Aster. The user has many separate chats; memory is how a new chat already knows their world. Read the latest exchange against the current memory and return JSON operations.
+
+Remember what will matter in future, unrelated chats:
+- PEOPLE the user deals with: name, role, organization, relationship to the user, which projects they are part of, anything the user said about working with them.
+- PROJECTS: name, what it is, client or owner, goals, scope, stack, repository, status, key decisions, and ideas the user brainstormed or chose.
+- FACTS about the user: durable preferences, circumstances (job, freelance work, location if stated), ways of working, tools they use.
+
+Do not store: one-off task details, things only relevant inside this chat, general knowledge, the assistant's own suggestions the user did not adopt, credentials or secrets, and sensitive personal details (health, finances, etc.) unless the user explicitly asks you to remember them.
+
+Rules:
+- If the user explicitly asks to remember something, you MUST store it, with "pinned": true.
+- Prefer updating an existing card over creating a new one. To update a person or project, reuse its exact "key" and write the complete new content, merging old and new information (max ~120 words).
+- Keys: "person:<first-last>" or "project:<short-name>", lowercase with hyphens.
+- Facts are one sentence. To change a fact, return it with its "id" and new content; to remove an outdated or contradicted fact, put its id in "deletes".
+- Most exchanges contain nothing worth remembering: return empty "upserts" then. Never invent details.
+- Always write "session": a short title (max 8 words) and a 1-2 sentence summary of what this chat is about and where it stands, updated with the latest exchange.
+
+Return only JSON:
+{"upserts":[{"kind":"person|project|fact","key":"person:...|project:...|null","id":"existing fact id|null","title":"Display name","content":"...","pinned":false}],"deletes":["id"],"session":{"title":"...","summary":"..."}}`;
+    STOP_WORDS = /* @__PURE__ */ new Set(["the", "and", "for", "app", "project", "new", "with", "website", "site"]);
+  }
+});
+
+// src/server/aster-github-proxy.ts
+import { createServer } from "http";
+import { request as httpsRequest } from "https";
+import { request as httpRequest } from "http";
+function extractToken(req) {
+  const header = req.headers.authorization;
+  if (!header) return void 0;
+  const [scheme, value = ""] = header.split(" ", 2);
+  if (/^(bearer|token)$/i.test(scheme ?? "")) return value.trim() || void 0;
+  if (/^basic$/i.test(scheme ?? "")) {
+    const decoded = Buffer.from(value, "base64").toString("utf8");
+    const password = decoded.slice(decoded.indexOf(":") + 1);
+    return password || void 0;
+  }
+  return void 0;
+}
+function deny(res, status, message2) {
+  res.writeHead(status, { "content-type": "application/json" });
+  res.end(JSON.stringify({ message: message2 }));
+}
+var GIT_PATH_RE, API_PATH_RE, FORWARDED_REQUEST_HEADERS, HOP_BY_HOP, AsterGitHubProxy;
+var init_aster_github_proxy = __esm({
+  "src/server/aster-github-proxy.ts"() {
+    "use strict";
+    GIT_PATH_RE = /^\/git\/([A-Za-z0-9-]{1,39})\/([A-Za-z0-9._-]{1,100})\.git\/(info\/refs|git-upload-pack|git-receive-pack)$/;
+    API_PATH_RE = /^\/api\/repos\/([A-Za-z0-9-]{1,39})\/([A-Za-z0-9._-]{1,100})(\/.*)?$/;
+    FORWARDED_REQUEST_HEADERS = ["accept", "content-type", "content-encoding", "content-length", "git-protocol", "user-agent", "x-github-api-version"];
+    HOP_BY_HOP = /* @__PURE__ */ new Set(["connection", "keep-alive", "transfer-encoding", "upgrade", "proxy-authenticate", "proxy-authorization", "te", "trailer"]);
+    AsterGitHubProxy = class {
+      constructor(options) {
+        this.options = options;
+        this.gitUpstream = new URL(options.gitUpstream ?? "https://github.com");
+        this.apiUpstream = new URL(options.apiUpstream ?? "https://api.github.com");
+      }
+      options;
+      server;
+      gitUpstream;
+      apiUpstream;
+      async listen(port, host) {
+        this.server = createServer((req, res) => this.handle(req, res));
+        await new Promise((resolve15, reject) => {
+          this.server.once("error", reject);
+          this.server.listen(port, host, () => resolve15());
+        });
+        const address = this.server.address();
+        return typeof address === "object" && address ? address.port : port;
+      }
+      close() {
+        this.server?.close();
+        this.server = void 0;
+      }
+      handle(req, res) {
+        const url = new URL(req.url ?? "/", "http://proxy.local");
+        const git2 = url.pathname.match(GIT_PATH_RE);
+        const api = git2 ? null : url.pathname.match(API_PATH_RE);
+        if (!git2 && !api) return deny(res, 404, "Only this conversation's repository is reachable");
+        const grantToken = extractToken(req);
+        if (!grantToken) {
+          res.writeHead(401, { "www-authenticate": 'Basic realm="aster-github"', "content-type": "text/plain" });
+          res.end("credentials required");
+          return;
+        }
+        const grant = this.options.resolveGrant(grantToken);
+        if (!grant) return deny(res, 403, "This repository grant is invalid or was revoked");
+        const [, owner, name] = git2 ?? api;
+        if (`${owner}/${name}`.toLowerCase() !== grant.repository.toLowerCase()) {
+          return deny(res, 403, `This conversation can only access ${grant.repository}`);
+        }
+        const upstream = git2 ? new URL(`/${owner}/${name}.git/${git2[3]}${url.search}`, this.gitUpstream) : new URL(`/repos/${owner}/${name}${api[3] ?? ""}${url.search}`, this.apiUpstream);
+        const headers = {};
+        for (const name2 of FORWARDED_REQUEST_HEADERS) {
+          const value = req.headers[name2];
+          if (typeof value === "string") headers[name2] = value;
+        }
+        headers["user-agent"] ??= "autopilot-aster";
+        headers.authorization = git2 ? "Basic " + Buffer.from(`x-access-token:${this.options.token}`).toString("base64") : `Bearer ${this.options.token}`;
+        const send = upstream.protocol === "https:" ? httpsRequest : httpRequest;
+        const forward = send(upstream, { method: req.method, headers }, (upstreamRes) => {
+          const responseHeaders = {};
+          for (const [key, value] of Object.entries(upstreamRes.headers)) {
+            if (value !== void 0 && !HOP_BY_HOP.has(key)) responseHeaders[key] = value;
+          }
+          res.writeHead(upstreamRes.statusCode ?? 502, responseHeaders);
+          upstreamRes.pipe(res);
+        });
+        forward.on("error", () => {
+          if (!res.headersSent) deny(res, 502, "GitHub could not be reached");
+          else res.destroy();
+        });
+        req.pipe(forward);
+      }
+    };
+  }
+});
+
+// src/server/aster-push.ts
+import Database5 from "better-sqlite3";
+import { createSign } from "crypto";
+import { readFileSync as readFileSync5 } from "fs";
+import { connect } from "http2";
+function truncate2(value, limit) {
+  const clean = value.replace(/\s+/g, " ").trim();
+  return clean.length > limit ? clean.slice(0, limit - 1) + "\u2026" : clean;
+}
+var DEVICE_TOKEN_RE, AsterPush;
+var init_aster_push = __esm({
+  "src/server/aster-push.ts"() {
+    "use strict";
+    init_aster_store();
+    DEVICE_TOKEN_RE = /^[0-9a-f]{64,200}$/i;
+    AsterPush = class {
+      db;
+      options;
+      privateKey;
+      jwt;
+      sessions = /* @__PURE__ */ new Map();
+      constructor(dbPath = defaultAsterDbPath(), options = {}, env2 = process.env) {
+        this.options = {
+          ...options,
+          keyPath: options.keyPath ?? env2.AUTOPILOT_ASTER_APNS_KEY_PATH,
+          keyId: options.keyId ?? env2.AUTOPILOT_ASTER_APNS_KEY_ID ?? "",
+          teamId: options.teamId ?? env2.AUTOPILOT_ASTER_APNS_TEAM_ID ?? "",
+          topic: options.topic ?? env2.AUTOPILOT_ASTER_APNS_TOPIC ?? "com.aster.ai"
+        };
+        this.db = new Database5(dbPath);
+        this.db.pragma("journal_mode = WAL");
+        this.db.pragma("busy_timeout = 5000");
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS aster_devices (
+        token TEXT PRIMARY KEY,
+        environment TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+    `);
+      }
+      /** Whether an APNs key is configured; devices are still recorded without one. */
+      get configured() {
+        return Boolean((this.options.keyPath || this.options.deliver) && this.options.keyId && this.options.teamId);
+      }
+      register(token, environment) {
+        if (!DEVICE_TOKEN_RE.test(token)) return false;
+        const now2 = Date.now();
+        this.db.prepare(`INSERT INTO aster_devices (token, environment, created_at, updated_at) VALUES (?, ?, ?, ?)
+      ON CONFLICT(token) DO UPDATE SET environment = excluded.environment, updated_at = excluded.updated_at`).run(token.toLowerCase(), environment, now2, now2);
+        return true;
+      }
+      unregister(token) {
+        this.db.prepare("DELETE FROM aster_devices WHERE token = ?").run(token.toLowerCase());
+      }
+      deviceCount() {
+        return this.db.prepare("SELECT COUNT(*) AS n FROM aster_devices").get().n;
+      }
+      /** Sends to every registered device; tokens Apple reports as gone are removed. Never throws. */
+      async notify(message2) {
+        if (!this.configured) return;
+        const devices = this.db.prepare("SELECT token, environment FROM aster_devices").all();
+        if (devices.length === 0) return;
+        const payload = JSON.stringify({
+          aps: {
+            alert: { title: truncate2(message2.title, 80), body: truncate2(message2.body, 180) },
+            sound: "default",
+            "thread-id": message2.conversationId
+          },
+          conversationId: message2.conversationId
+        });
+        await Promise.all(devices.map(async (device) => {
+          const host = device.environment === "development" ? "api.sandbox.push.apple.com" : "api.push.apple.com";
+          try {
+            const status = await this.send(host, device.token, payload);
+            if (status === 410 || status === 400) this.unregister(device.token);
+          } catch {
+          }
+        }));
+      }
+      close() {
+        for (const session of this.sessions.values()) session.close();
+        this.sessions.clear();
+        this.db.close();
+      }
+      async send(host, token, payload) {
+        const headers = {
+          authorization: `bearer ${this.token()}`,
+          "apns-topic": this.options.topic,
+          "apns-push-type": "alert",
+          "apns-priority": "10"
+        };
+        if (this.options.deliver) return this.options.deliver({ host, token, headers, payload });
+        const session = this.session(host);
+        return await new Promise((resolve15, reject) => {
+          const stream = session.request({ ":method": "POST", ":path": `/3/device/${token}`, ...headers, "content-type": "application/json" });
+          let status = 0;
+          stream.setTimeout(15e3, () => stream.close());
+          stream.on("response", (responseHeaders) => {
+            status = Number(responseHeaders[":status"]) || 0;
+          });
+          stream.on("error", reject);
+          stream.on("close", () => resolve15(status));
+          stream.resume();
+          stream.end(payload);
+        });
+      }
+      session(host) {
+        const existing = this.sessions.get(host);
+        if (existing && !existing.closed && !existing.destroyed) return existing;
+        const session = connect(`https://${host}`);
+        session.on("error", () => this.sessions.delete(host));
+        session.on("close", () => this.sessions.delete(host));
+        session.unref();
+        this.sessions.set(host, session);
+        return session;
+      }
+      /** Provider token (ES256 JWT); Apple accepts one for up to an hour, so it is reused for 50 minutes. */
+      token() {
+        const now2 = Math.floor(Date.now() / 1e3);
+        if (this.jwt && now2 - this.jwt.issuedAt < 50 * 60) return this.jwt.value;
+        this.privateKey ??= readFileSync5(this.options.keyPath, "utf8");
+        const encode = (value) => Buffer.from(JSON.stringify(value)).toString("base64url");
+        const unsigned = `${encode({ alg: "ES256", kid: this.options.keyId })}.${encode({ iss: this.options.teamId, iat: now2 })}`;
+        const signature = createSign("SHA256").update(unsigned).sign({ key: this.privateKey, dsaEncoding: "ieee-p1363" }).toString("base64url");
+        this.jwt = { value: `${unsigned}.${signature}`, issuedAt: now2 };
+        return this.jwt.value;
+      }
+    };
+  }
+});
+
+// src/server/aster-api.ts
+import { randomUUID as randomUUID7 } from "crypto";
 import { unlink as unlink2 } from "fs/promises";
 import { resolve as resolve8 } from "path";
 function parseCursor(header, query) {
@@ -14837,8 +15620,23 @@ function parseCursor(header, query) {
   const cursor = Number(value);
   return Number.isSafeInteger(cursor) ? cursor : void 0;
 }
-function publicConversation(conversation) {
+function collectAssistantText(store, conversationId, runId, after) {
+  let text = "";
+  let cursor = after;
+  for (; ; ) {
+    const events = store.eventsAfter(conversationId, cursor, 500);
+    if (events.length === 0) break;
+    for (const event of events) {
+      if (event.runId === runId && event.type === "assistant.delta" && typeof event.data.text === "string") text += event.data.text;
+    }
+    cursor = events.at(-1).sequence;
+    if (text.length > 2e4) break;
+  }
+  return text;
+}
+function publicConversation(conversation, project) {
   return {
+    ...project ? { kind: project.kind, repository: project.repository, branch: project.branch } : {},
     conversationId: conversation.id,
     workspaceId: conversation.workspaceId,
     model: conversation.model,
@@ -14862,6 +15660,25 @@ function publicApproval(approval) {
     decision: approval.decision
   };
 }
+async function selectableModels(config2) {
+  if (config2.modelCatalog === "fixed") return config2.models.map((id) => ({ id }));
+  const catalog = await loadOpenRouterCatalog();
+  return catalog.filter((model) => model.supports.tools).map((model) => ({
+    id: model.id,
+    ...model.name ? { name: model.name } : {},
+    contextWindow: model.contextWindow,
+    inputPerMtok: model.pricing.inputPerMtok,
+    outputPerMtok: model.pricing.outputPerMtok,
+    ...model.created !== void 0 ? { created: model.created } : {},
+    reasoning: model.supports.reasoning,
+    vision: model.supports.vision === true
+  }));
+}
+async function isSelectableModel(config2, model) {
+  if (!model.trim() || model.length > 200) return false;
+  if (config2.modelCatalog === "fixed") return config2.models.includes(model);
+  return (await selectableModels(config2)).some((entry) => entry.id === model);
+}
 async function readJsonBody(req) {
   const chunks = [];
   let bytes = 0;
@@ -14903,10 +15720,15 @@ var init_aster_api = __esm({
     init_version();
     init_aster_store();
     init_aster_workspaces();
+    init_openrouter_catalog();
+    init_aster_github();
+    init_aster_memory();
+    init_aster_github_proxy();
+    init_aster_push();
     init_aster_tools();
     API_PREFIX = "/api/v1";
-    MAX_BODY_BYTES = 64 * 1024;
-    MAX_USER_TURN_CHARS = 2e4;
+    MAX_BODY_BYTES = 4 * 1024 * 1024;
+    MAX_USER_TURN_CHARS = 5e5;
     CLIENT_TURN_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
     CREATE_IDEMPOTENCY_KEY_RE = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
     MAX_APPROVAL_ARG_BYTES = 24 * 1024;
@@ -14918,9 +15740,57 @@ var init_aster_api = __esm({
       waiters = /* @__PURE__ */ new Map();
       runtime;
       config;
-      constructor(config2, runtime) {
+      github;
+      memory;
+      constructor(config2, runtime, github = new AsterGitHub(), memory) {
         this.config = config2;
         this.runtime = runtime;
+        this.github = github;
+        this.memory = memory;
+      }
+      githubProxy;
+      /** Where cells reach the repository-scoped GitHub proxy, when it is running. */
+      githubProxyUrl;
+      /**
+       * Starts the repository-scoped GitHub proxy when configured
+       * (AUTOPILOT_ASTER_GITHUB_PROXY_LISTEN=host:port, AUTOPILOT_ASTER_GITHUB_PROXY_URL as cells see it).
+       */
+      async startGitHubProxy(env2 = process.env) {
+        const listen = env2.AUTOPILOT_ASTER_GITHUB_PROXY_LISTEN;
+        const publicUrl = env2.AUTOPILOT_ASTER_GITHUB_PROXY_URL;
+        const token = env2.GITHUB_TOKEN;
+        if (!listen || !publicUrl || !token || this.githubProxy) return;
+        const separator = listen.lastIndexOf(":");
+        const proxy = new AsterGitHubProxy({ token, resolveGrant: (grant) => this.getStore().resolveGitHubGrant(grant) });
+        await proxy.listen(Number(listen.slice(separator + 1)), listen.slice(0, separator));
+        this.githubProxy = proxy;
+        this.githubProxyUrl = publicUrl.replace(/\/+$/, "");
+      }
+      push;
+      getPush() {
+        try {
+          return this.push ??= new AsterPush();
+        } catch {
+          return void 0;
+        }
+      }
+      /** "Your task finished" (or failed) on the user's devices; cancelled turns stay silent. */
+      notifyTurnEnd(store, conversationId, runId, status, reason, userText, after) {
+        if (status !== "completed" && status !== "failed") return;
+        const push = this.getPush();
+        if (!push?.configured) return;
+        const reply = status === "completed" ? collectAssistantText(store, conversationId, runId, after).trim() : "";
+        const title = userText.trim().split("\n")[0] || "Aster";
+        const body = status === "completed" ? reply ? `\u2705 ${reply}` : "\u2705 Done" : `\u26A0\uFE0F Couldn\u2019t finish${reason && reason !== "error" ? `: ${reason}` : ""}`;
+        void push.notify({ title, body, conversationId });
+      }
+      getMemory() {
+        if (process.env.AUTOPILOT_ASTER_MEMORY === "off") return void 0;
+        try {
+          return this.memory ??= new AsterMemory();
+        } catch {
+          return void 0;
+        }
       }
       async handle(req, res) {
         const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
@@ -14942,7 +15812,7 @@ var init_aster_api = __esm({
               service: "autopilot",
               apiVersion: "v1",
               serviceVersion: getAppVersion(),
-              capabilities: ["workspaces", "conversations", "turns", "event-replay", "cancellation", "human-approvals", "hotcell-per-conversation", "pause-resume", "destroy"]
+              capabilities: ["workspaces", "conversations", "turns", "event-replay", "cancellation", "human-approvals", "hotcell-per-conversation", "pause-resume", "destroy", "autonomous-cells", "tool-output", "checkpoints", "model-switch", "artifacts", "memory", "push", ...this.github.configured ? ["github"] : [], ...config2.modelCatalog === "openrouter" ? ["model-catalog"] : []]
             });
           }
           if (path === `${API_PREFIX}/workspaces` && method === "GET") {
@@ -14953,27 +15823,86 @@ var init_aster_api = __esm({
           }
           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 });
+            const models = await selectableModels(config2);
+            if (models.length === 0) return sendError(res, 503, "model_catalog_unavailable", "The model catalog is unavailable; try again shortly");
+            return json(res, 200, { models: models.map((model) => model.id), catalog: 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 (Object.keys(body).some((key) => !["workspaceId", "model", "kind", "repository"].includes(key))) {
+              return sendError(res, 400, "unsupported_field", "Conversation creation accepts workspaceId, model, kind, and repository; paths are server-configured");
+            }
+            if (body.kind !== void 0 && body.kind !== "chat" && body.kind !== "code") {
+              return sendError(res, 400, "invalid_kind", 'kind must be "chat" or "code"');
+            }
+            if (body.kind === "code" && (typeof body.repository !== "string" || !REPOSITORY_FULL_NAME_RE.test(body.repository))) {
+              return sendError(res, 400, "repository_required", "Code conversations need a repository as owner/name");
+            }
+            if (body.kind !== "code" && body.repository !== void 0) {
+              return sendError(res, 400, "unsupported_field", "repository is only accepted for code conversations");
             }
             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)) {
+            if (typeof body.model !== "string" || !await isSelectableModel(config2, body.model)) {
               return sendError(res, 400, "model_not_allowed", "Select a model from the configured model list");
             }
             const idempotencyKey = req.headers["idempotency-key"];
             if (typeof idempotencyKey !== "string" || !CREATE_IDEMPOTENCY_KEY_RE.test(idempotencyKey)) {
               return sendError(res, 400, "idempotency_key_required", "Conversation creation requires an Idempotency-Key header of 1-128 safe characters");
             }
-            return await this.createConversation(res, store, principal, workspace, body.model, idempotencyKey);
+            const kind = body.kind;
+            return await this.createConversation(res, store, principal, workspace, body.model, idempotencyKey, kind, body.repository);
+          }
+          if (path === `${API_PREFIX}/devices` && method === "POST") {
+            if (!this.hasScope(principal, "conversations:write")) return sendError(res, 403, "insufficient_scope", "Credential lacks conversation/write scope");
+            const body = await readJsonBody(req);
+            const environment = body.environment === "development" ? "development" : "production";
+            const push = this.getPush();
+            if (!push || typeof body.token !== "string" || !push.register(body.token, environment)) {
+              return sendError(res, 400, "invalid_device_token", "A hex APNs device token is required");
+            }
+            return json(res, 200, { registered: true, notifications: push.configured });
+          }
+          const deviceMatch = path.match(/^\/api\/v1\/devices\/([0-9a-fA-F]{64,200})$/);
+          if (deviceMatch && method === "DELETE") {
+            if (!this.hasScope(principal, "conversations:write")) return sendError(res, 403, "insufficient_scope", "Credential lacks conversation/write scope");
+            this.getPush()?.unregister(deviceMatch[1]);
+            return json(res, 200, { unregistered: true });
+          }
+          if (path === `${API_PREFIX}/memory` && method === "GET") {
+            if (!this.hasScope(principal, "conversations:read")) return sendError(res, 403, "insufficient_scope", "Credential lacks conversation/read scope");
+            const memory = this.getMemory();
+            return json(res, 200, { enabled: Boolean(memory?.enabled), items: memory ? memory.list() : [] });
+          }
+          const memoryMatch = path.match(/^\/api\/v1\/memory\/([^/]+)$/);
+          if (memoryMatch && method === "DELETE") {
+            if (!this.hasScope(principal, "conversations:write")) return sendError(res, 403, "insufficient_scope", "Credential lacks conversation/write scope");
+            const memory = this.getMemory();
+            if (!memory || !memory.delete(memoryMatch[1])) return sendError(res, 404, "memory_not_found", "Memory item not found");
+            return json(res, 200, { deleted: memoryMatch[1] });
+          }
+          if (path === `${API_PREFIX}/github/repositories` && (method === "GET" || method === "POST")) {
+            if (!this.hasScope(principal, "conversations:write")) return sendError(res, 403, "insufficient_scope", "Credential lacks conversation/write scope");
+            try {
+              if (method === "GET") {
+                return json(res, 200, { repositories: await this.github.listRepositories(url.searchParams.get("q") ?? "") });
+              }
+              const body = await readJsonBody(req);
+              if (typeof body.name !== "string") return sendError(res, 400, "invalid_repository_name", "name is required");
+              const repository = await this.github.createRepository({
+                name: body.name.trim(),
+                private: body.private !== false,
+                ...typeof body.description === "string" ? { description: body.description } : {}
+              });
+              return json(res, 201, { repository });
+            } catch (error) {
+              if (error instanceof AsterGitHubError) return sendError(res, error.status, error.code, error.message);
+              throw error;
+            }
           }
           const eventsMatch = path.match(/^\/api\/v1\/conversations\/([^/]+)\/events$/);
           if (eventsMatch && method === "GET") {
@@ -14990,7 +15919,7 @@ var init_aster_api = __esm({
             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");
+            if (Object.keys(body).some((key) => key !== "text" && key !== "clientTurnId" && key !== "model")) return sendError(res, 400, "unsupported_field", "Turns accept text, an optional clientTurnId, and an optional model; the workspace is 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");
@@ -14998,7 +15927,18 @@ var init_aster_api = __esm({
             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);
+            let target = conversation;
+            if (Object.hasOwn(body, "model")) {
+              if (typeof body.model !== "string" || !await isSelectableModel(config2, body.model)) {
+                return sendError(res, 400, "model_not_allowed", "Select a model from the model catalog");
+              }
+              if (body.model !== conversation.model) {
+                const switched = await this.switchModel(res, store, conversation, body.model);
+                if (!switched) return;
+                target = switched;
+              }
+            }
+            return await this.appendTurn(res, store, target, clientTurnId, requestText, text);
           }
           const cancelMatch = path.match(/^\/api\/v1\/conversations\/([^/]+)\/cancel$/);
           if (cancelMatch && method === "POST") {
@@ -15014,6 +15954,61 @@ var init_aster_api = __esm({
             if (!conversation) return sendError(res, 404, "conversation_not_found", "Conversation not found");
             return lifecycleMatch[2] === "pause" ? this.pauseConversation(res, store, conversation) : this.resumeConversation(res, store, conversation);
           }
+          const artifactsMatch = path.match(/^\/api\/v1\/conversations\/([^/]+)\/artifacts(\/file)?$/);
+          if (artifactsMatch && 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, artifactsMatch[1]);
+            if (!conversation) return sendError(res, 404, "conversation_not_found", "Conversation not found");
+            const cell = this.readyCell(res, store, conversation.id);
+            if (!cell) return;
+            if (!this.runtime.listArtifacts || !this.runtime.readArtifact) return sendError(res, 503, "artifacts_unavailable", "Artifacts are not configured");
+            if (!artifactsMatch[2]) return json(res, 200, { artifacts: await this.runtime.listArtifacts(cell) });
+            try {
+              const artifact = await this.runtime.readArtifact(cell, url.searchParams.get("path") ?? "");
+              res.writeHead(200, {
+                "content-type": artifact.mimeType,
+                "content-length": artifact.data.length,
+                "content-disposition": `attachment; filename*=UTF-8''${encodeURIComponent(artifact.name)}`,
+                "cache-control": "no-store",
+                "x-content-type-options": "nosniff"
+              });
+              res.end(artifact.data);
+              return;
+            } catch (error) {
+              const code = error instanceof Error ? error.message : "";
+              if (code === "invalid_artifact_path") return sendError(res, 400, code, "Artifact path is invalid");
+              if (code === "artifact_too_large") return sendError(res, 413, code, "Artifact is larger than 50 MB");
+              return sendError(res, 404, "artifact_not_found", "Artifact not found");
+            }
+          }
+          const checkpointsMatch = path.match(/^\/api\/v1\/conversations\/([^/]+)\/checkpoints$/);
+          if (checkpointsMatch && 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, checkpointsMatch[1]);
+            if (!conversation) return sendError(res, 404, "conversation_not_found", "Conversation not found");
+            const cell = this.readyCell(res, store, conversation.id);
+            if (!cell) return;
+            if (!this.runtime.listCheckpoints) return sendError(res, 503, "checkpoints_unavailable", "Checkpoints are not configured");
+            return json(res, 200, { checkpoints: await this.runtime.listCheckpoints(cell) });
+          }
+          const restoreMatch = path.match(/^\/api\/v1\/conversations\/([^/]+)\/checkpoints\/([0-9a-f]{7,40})\/restore$/);
+          if (restoreMatch && 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, restoreMatch[1]);
+            if (!conversation) return sendError(res, 404, "conversation_not_found", "Conversation not found");
+            if (conversation.activeRunId) return sendError(res, 409, "turn_active", "Wait for the current turn to finish or cancel it before restoring");
+            const cell = this.readyCell(res, store, conversation.id);
+            if (!cell) return;
+            if (!this.runtime.restoreCheckpoint) return sendError(res, 503, "checkpoints_unavailable", "Checkpoints are not configured");
+            try {
+              const checkpoint = await this.runtime.restoreCheckpoint(cell, conversation.id, restoreMatch[2]);
+              store.appendEvent(conversation.id, null, "checkpoint.restored", { restoredFrom: restoreMatch[2], ...checkpoint });
+              return json(res, 200, { checkpoint });
+            } catch (error) {
+              if (error instanceof Error && error.message === "checkpoint_not_found") return sendError(res, 404, "checkpoint_not_found", "Checkpoint not found");
+              return sendError(res, 500, "checkpoint_restore_failed", "The workspace could not be restored");
+            }
+          }
           const conversationMatch = path.match(/^\/api\/v1\/conversations\/([^/]+)$/);
           if (conversationMatch && method === "DELETE") {
             if (!this.hasScope(principal, "conversations:write")) return sendError(res, 403, "insufficient_scope", "Credential lacks conversation/write scope");
@@ -15025,7 +16020,7 @@ var init_aster_api = __esm({
             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));
+            return json(res, 200, publicConversation(conversation, store.getConversationProject(conversation.id)));
           }
           const approvalMatch = path.match(/^\/api\/v1\/approvals\/([^/]+)$/);
           if (approvalMatch && method === "GET") {
@@ -15064,6 +16059,12 @@ var init_aster_api = __esm({
         }
         this.store?.close();
         this.store = void 0;
+        this.memory?.close();
+        this.memory = void 0;
+        this.githubProxy?.close();
+        this.githubProxy = void 0;
+        this.push?.close();
+        this.push = void 0;
       }
       getStore() {
         return this.store ??= new AsterStore();
@@ -15115,6 +16116,14 @@ var init_aster_api = __esm({
               } 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" });
+              } else {
+                const mapping = store.getCellMapping(conversation.id);
+                if (mapping?.cellId && this.runtime.resumeTurn) {
+                  this.runtime.resumeTurn(this.cellTurn(store, conversation, run.id, mapping.cellId, mapping.eventCursor, run.task ?? ""));
+                } else {
+                  runs.transition(run.id, "failed", "server_restarted");
+                  store.updateConversationStatus(conversation.id, run.id, "interrupted", { reason: "server_restart_recovery" });
+                }
               }
             }
           } finally {
@@ -15123,9 +16132,44 @@ var init_aster_api = __esm({
         })();
         return this.recovery;
       }
-      async createConversation(res, store, principal, workspace, model, idempotencyKey) {
-        const candidateId = randomUUID6();
-        const candidateSessionId = randomUUID6();
+      /** A turn handle for re-attaching to a cell turn after a restart (no prompt is sent). */
+      cellTurn(store, conversation, runId, cellId, cursor, userText) {
+        const publishEvent = (type, data) => {
+          store.appendEvent(conversation.id, runId, type, data);
+        };
+        return {
+          runId,
+          conversation,
+          cellId,
+          cellEventCursor: cursor,
+          userText,
+          sessionFile: {},
+          messages: [],
+          executor: new ToolExecutor([]),
+          allowedTools: /* @__PURE__ */ new Set(),
+          maxToolIterations: null,
+          maxRuntimeMs: null,
+          askPermission: async () => "deny",
+          publishEvent,
+          onCellCursor: (next) => store.advanceCellEventCursor(conversation.id, next),
+          finish: (status, reason) => {
+            const runs = new RunStore();
+            try {
+              const run = runs.getRun(runId);
+              if (run && ["queued", "running", "waiting", "needs_input"].includes(run.status)) runs.transition(runId, status, reason ?? status);
+            } catch {
+            } finally {
+              runs.close();
+            }
+            const updated = store.updateConversationStatus(conversation.id, runId, status, reason ? { reason } : {});
+            if (updated) store.appendEvent(conversation.id, runId, status, reason ? { reason } : {});
+            if (updated) this.notifyTurnEnd(store, conversation.id, runId, status, reason, userText, 0);
+          }
+        };
+      }
+      async createConversation(res, store, principal, workspace, model, idempotencyKey, kind, repository) {
+        const candidateId = randomUUID7();
+        const candidateSessionId = randomUUID7();
         const reservation = store.reserveCellConversation({
           conversationId: candidateId,
           credentialId: principal.credentialId,
@@ -15140,12 +16184,47 @@ var init_aster_api = __esm({
         if (mapping.status === "destroyed") return sendError(res, 410, "conversation_destroyed", "Conversation was already destroyed");
         if (mapping.status === "ready") {
           const existing = store.getConversation(mapping.conversationId);
-          if (existing) return json(res, 200, publicConversation(existing));
+          if (existing) return json(res, 200, publicConversation(existing, store.getConversationProject(existing.id)));
         }
         if (!this.runtime.provisionConversation) {
           store.setCellStatus(mapping.conversationId, "failed");
           return sendError(res, 503, "hotcell_unavailable", "Hotcell conversation runtime is not configured");
         }
+        let project;
+        if (kind) {
+          let stored = store.getConversationProject(mapping.conversationId);
+          if (!stored) {
+            if (kind === "code") {
+              let repo;
+              try {
+                repo = await this.github.getRepository(repository);
+              } catch (error) {
+                if (error instanceof AsterGitHubError) return sendError(res, error.status, error.code, error.message);
+                throw error;
+              }
+              store.setConversationProject(mapping.conversationId, {
+                kind,
+                repository: repo.fullName,
+                branch: `aster/${mapping.conversationId.slice(0, 8)}`
+              });
+              stored = { kind, repository: repo.fullName, branch: `aster/${mapping.conversationId.slice(0, 8)}` };
+              project = { kind, repository: repo.fullName, baseBranch: repo.defaultBranch, branch: stored.branch };
+            } else {
+              store.setConversationProject(mapping.conversationId, { kind, repository: null, branch: null });
+              stored = { kind, repository: null, branch: null };
+            }
+          }
+          if (!project) {
+            project = stored.kind === "code" ? { kind: "code", repository: stored.repository, baseBranch: (await this.github.getRepository(stored.repository).catch(() => void 0))?.defaultBranch ?? "main", branch: stored.branch } : { kind: "chat" };
+          }
+          if (project.kind === "code" && project.repository && this.githubProxyUrl) {
+            project.github = {
+              token: store.getOrCreateGitHubGrant(mapping.conversationId, project.repository),
+              gitUrl: `${this.githubProxyUrl}/git`,
+              apiUrl: `${this.githubProxyUrl}/api`
+            };
+          }
+        }
         try {
           const allowCreate = !mapping.createAttempted;
           if (allowCreate) store.markCellCreateAttempted(mapping.conversationId);
@@ -15157,7 +16236,8 @@ var init_aster_api = __esm({
             workspaceRoot: workspace.rootPath,
             model,
             allowCreate,
-            onCellCreated: (cellId) => store.setCellId(mapping.conversationId, cellId)
+            onCellCreated: (cellId) => store.setCellId(mapping.conversationId, cellId),
+            ...project ? { project } : {}
           });
           store.setCellId(mapping.conversationId, provisioned.cellId);
           const conversation = store.getConversation(mapping.conversationId) ?? store.createConversation({
@@ -15181,7 +16261,7 @@ var init_aster_api = __esm({
           await saveSession(sessionFile);
           store.setCellStatus(mapping.conversationId, "ready");
           store.appendEvent(mapping.conversationId, null, "conversation.created", { conversationId: mapping.conversationId, workspaceId: workspace.id, model });
-          json(res, reservation.kind === "created" ? 201 : 200, publicConversation(conversation));
+          json(res, reservation.kind === "created" ? 201 : 200, publicConversation(conversation, store.getConversationProject(conversation.id)));
         } catch {
           const current = store.getCellMapping(mapping.conversationId);
           if (current?.cellId && this.runtime.destroyCell) {
@@ -15219,7 +16299,7 @@ var init_aster_api = __esm({
           sendError(res, 409, "conversation_cell_unavailable", "Conversation cell is not available");
           return;
         }
-        const runId = randomUUID6();
+        const runId = randomUUID7();
         if (!idempotent && !store.beginTurn(conversation.id, runId)) {
           sendError(res, 409, "conversation_busy", "A turn is already active for this conversation");
           return;
@@ -15296,6 +16376,7 @@ var init_aster_api = __esm({
           const publishEvent = (type, data) => {
             store.appendEvent(conversation.id, runId, type, data);
           };
+          const turnStartSequence = store.getConversation(conversation.id)?.lastEventSequence ?? 0;
           const active = {
             runId,
             conversation,
@@ -15314,8 +16395,20 @@ var init_aster_api = __esm({
             finish: (status, reason) => {
               const updated = store.updateConversationStatus(conversation.id, runId, status, reason ? { reason } : {});
               if (updated) store.appendEvent(conversation.id, runId, status, reason ? { reason } : {});
+              if (updated) this.notifyTurnEnd(store, conversation.id, runId, status, reason, text, turnStartSequence);
             }
           };
+          const memory = this.getMemory();
+          if (memory) {
+            active.memory = { note: memory.brief(conversation.id, text), snapshot: memory.snapshot() };
+            const firstSequence = store.getConversation(conversation.id)?.lastEventSequence ?? 0;
+            active.beforeFinish = async () => {
+              const reply = collectAssistantText(store, conversation.id, runId, firstSequence);
+              const project = store.getConversationProject(conversation.id);
+              const changes = await memory.remember({ conversationId: conversation.id, project, userText: text, assistantText: reply });
+              if (changes.length) publishEvent("memory.updated", { items: changes });
+            };
+          }
           this.runtime.startTurn(active);
           json(res, 202, acceptedResponse);
         } catch {
@@ -15466,6 +16559,7 @@ var init_aster_api = __esm({
         if (mapping.status === "destroyed") return json(res, 200, { conversationId: conversation.id, status: "destroyed" });
         if (!this.runtime.destroyCell) return sendError(res, 503, "hotcell_destroy_unavailable", "Hotcell cleanup is not configured");
         store.setCellStatus(conversation.id, "destroying");
+        store.revokeGitHubGrant(conversation.id);
         if (conversation.activeRunId) {
           for (const approval of store.cancelPendingApprovals(conversation.id)) {
             const waiter = this.waiters.get(approval.id);
@@ -15491,6 +16585,50 @@ var init_aster_api = __esm({
           sendError(res, 503, "cleanup_pending", "Cell cleanup is pending; retry DELETE to revoke credentials and remove the cell");
         }
       }
+      /** The conversation's cell id when it can take control requests; otherwise sends the error. */
+      readyCell(res, store, conversationId) {
+        const mapping = store.getCellMapping(conversationId);
+        if (mapping?.status === "paused") {
+          sendError(res, 409, "conversation_paused", "Conversation is paused; resume it first");
+          return void 0;
+        }
+        if (!mapping?.cellId || mapping.status !== "ready") {
+          sendError(res, 409, "conversation_cell_unavailable", "Conversation cell is not available");
+          return void 0;
+        }
+        return mapping.cellId;
+      }
+      /** Switch the cell session first, then the record, so a failed switch leaves both on the old model. */
+      async switchModel(res, store, conversation, model) {
+        if (conversation.activeRunId) {
+          sendError(res, 409, "conversation_busy", "A turn is already active for this conversation");
+          return void 0;
+        }
+        const cell = this.readyCell(res, store, conversation.id);
+        if (!cell) return void 0;
+        if (!this.runtime.setModel) {
+          sendError(res, 503, "model_switch_unavailable", "Model switching is not configured");
+          return void 0;
+        }
+        try {
+          await this.runtime.setModel(cell, model);
+        } catch {
+          sendError(res, 503, "model_switch_failed", "The conversation's model could not be switched");
+          return void 0;
+        }
+        if (!store.setConversationModel(conversation.id, model)) {
+          sendError(res, 409, "conversation_busy", "A turn is already active for this conversation");
+          return void 0;
+        }
+        try {
+          const sessionPath = resolve8(sessionsDir(), conversation.sessionId + ".json");
+          const sessionFile = await loadSession(sessionPath);
+          sessionFile.model = model;
+          await saveSession(sessionFile);
+        } catch {
+        }
+        return store.getConversation(conversation.id);
+      }
       async cancelConversation(res, store, conversation) {
         const runId = conversation.activeRunId;
         if (!runId) {
@@ -15611,7 +16749,31 @@ data: ${JSON.stringify(event.data)}
 // src/server/aster-cell-runtime.ts
 import { execFile as execFile5 } from "child_process";
 import { promisify as promisify4 } from "util";
-import { randomUUID as randomUUID7 } from "crypto";
+import { randomUUID as randomUUID8 } from "crypto";
+async function writeCellFileChunked(cell, path, content) {
+  if (Buffer.byteLength(content, "utf8") <= CELL_FILE_WRITE_CHUNK_CHARS) {
+    await cell.writeFile(path, content, { mode: "0600" });
+    return;
+  }
+  const partsDir = `${path}.parts`;
+  const encoded = Buffer.from(content, "utf8").toString("base64");
+  const partPaths = [];
+  await cell.mkdir(partsDir, { parents: true });
+  try {
+    for (let offset = 0, index = 0; offset < encoded.length; offset += CELL_FILE_WRITE_CHUNK_CHARS, index++) {
+      const partPath = `${partsDir}/${String(index).padStart(6, "0")}.b64`;
+      await cell.writeFile(partPath, encoded.slice(offset, offset + CELL_FILE_WRITE_CHUNK_CHARS), { mode: "0600" });
+      partPaths.push(partPath);
+    }
+    const result2 = await cell.exec(
+      `cat ${partPaths.map(shellQuote2).join(" ")} | base64 -d > ${shellQuote2(path)} && chmod 600 ${shellQuote2(path)}`
+    );
+    if (result2.exitCode !== 0) throw new Error("cell_control_failed");
+  } finally {
+    await cell.exec(`rm -rf ${shellQuote2(partsDir)}`).catch(() => {
+    });
+  }
+}
 async function defaultArchiveWorkspace(workspaceRoot) {
   const { stdout } = await execFileAsync3("git", ["-C", workspaceRoot, "archive", "--format=tar", "HEAD"], {
     encoding: "buffer",
@@ -15619,17 +16781,73 @@ async function defaultArchiveWorkspace(workspaceRoot) {
   });
   return Buffer.from(stdout).toString("base64");
 }
+function projectNote(project) {
+  const artifacts = "Save anything meant for the user to look at (documents, slides, PDFs, spreadsheets, web pages, images, reports) in /workspace/artifacts/. Files there appear in the user's Aster app (an iPhone), where they can preview, download, and share them. Unless the user asks for an editable format, deliver visual documents (slides, reports, one-pagers) as PDF: write HTML/CSS (one page per slide, e.g. @page { size: 1280px 720px; margin: 0 }) and print it with `chromium --headless --no-sandbox --disable-gpu --no-pdf-header-footer --print-to-pdf=/workspace/artifacts/NAME.pdf FILE.html`. For editable files use python-pptx, python-docx, or openpyxl; matplotlib is available for charts. Keep drafts and source files outside artifacts/ so only finished deliverables appear there.";
+  if (project.kind === "chat") {
+    return `[Aster chat. /workspace is this conversation's private Linux sandbox with internet access. ${artifacts}]`;
+  }
+  const { repository, branch, baseBranch } = project;
+  return `[Aster code chat. GitHub repository ${repository} is cloned at /workspace on branch ${branch} (from ${baseBranch}). Commit your work and push with \`git push -u origin HEAD\`; credentials are preconfigured, so never print or write tokens. Only this repository is reachable from here. To open a pull request: curl -s -X POST "\${ASTER_GITHUB_API_URL:-$GITHUB_BASE_URL}/repos/${repository}/pulls" -H "Authorization: Bearer \${ASTER_GITHUB_TOKEN:-$GITHUB_API_KEY}" -H "Accept: application/vnd.github+json" -d '{"title":"\u2026","head":"${branch}","base":"${baseBranch}","body":"\u2026"}'. ${artifacts} The artifacts folder is not committed to the repository.]`;
+}
+function isSafeArtifactPath(path) {
+  if (!path || path.length > 500 || path.startsWith("/") || /[\x00-\x1f\x7f]/.test(path)) return false;
+  return path.split("/").every((part) => part !== "" && part !== "." && part !== ".." && !part.startsWith("."));
+}
+function shellQuote2(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function artifactMimeType(path) {
+  const extension = path.split(".").pop()?.toLowerCase() ?? "";
+  return ARTIFACT_MIME_TYPES[extension] ?? "application/octet-stream";
+}
+function checkpointMessage(userText) {
+  const firstLine2 = redactLikelySecrets(userText).split("\n").find((line) => line.trim())?.trim() ?? "Turn";
+  const subject = firstLine2.length > 72 ? firstLine2.slice(0, 71) + "\u2026" : firstLine2;
+  return `${subject}
+`;
+}
+function summarizeToolInput(toolName, args) {
+  const record = args && typeof args === "object" ? args : {};
+  const preferred = toolName === "bash" ? record.command : record.path ?? record.pattern ?? record.url ?? record.query;
+  const text = typeof preferred === "string" ? preferred : JSON.stringify(args ?? {});
+  return boundedToolText(text, MAX_TOOL_INPUT_CHARS);
+}
+function boundedToolText(text, limit) {
+  const redacted = redactLikelySecrets(text);
+  if (redacted.length <= limit) return redacted;
+  const half = Math.floor((limit - 40) / 2);
+  return `${redacted.slice(0, half)}
+\u2026 [${redacted.length - 2 * half} characters omitted] \u2026
+${redacted.slice(-half)}`;
+}
 function sleep4(ms) {
   return new Promise((resolve15) => setTimeout(resolve15, ms));
 }
-var execFileAsync3, CELL_WORKSPACE, CELL_STATE_DIR, CELL_CONTROL_DIR, BRIDGE_MARKER, CONTROL_RUNNER, BRIDGE_RUNNER, HEALTH_TIMEOUT_MS, EVENT_POLL_MS, AsterHotcellRuntime;
+var execFileAsync3, CELL_WORKSPACE, CELL_STATE_DIR, CHECKPOINT_MESSAGE_FILE, INSTALLED_RUNTIME_PACKAGE, NOTES_FILE, MEMORY_FILE, MEMORY_EXTRACTION_TIMEOUT_MS, LIVENESS_CHECK_MS, ARTIFACTS_DIR, MAX_ARTIFACTS, MAX_ARTIFACT_BYTES, BRANCH_RE, REPOSITORY_RE, GIT, COMMIT_SHA_RE, MAX_TOOL_OUTPUT_CHARS, MAX_TOOL_INPUT_CHARS, MAX_CHECKPOINTS, CELL_CONTROL_DIR, BRIDGE_MARKER, CONTROL_RUNNER, BRIDGE_RUNNER, HEALTH_TIMEOUT_MS, EVENT_POLL_MS, AsterHotcellRuntime, CELL_FILE_WRITE_CHUNK_CHARS, ARTIFACT_MIME_TYPES;
 var init_aster_cell_runtime = __esm({
   "src/server/aster-cell-runtime.ts"() {
     "use strict";
     init_version();
+    init_aster_tools();
     execFileAsync3 = promisify4(execFile5);
     CELL_WORKSPACE = "/workspace";
     CELL_STATE_DIR = "/workspace/.aster";
+    CHECKPOINT_MESSAGE_FILE = `${CELL_STATE_DIR}/checkpoint-message`;
+    INSTALLED_RUNTIME_PACKAGE = "/opt/autopilot/node_modules/autopilot-ai/package.json";
+    NOTES_FILE = `${CELL_STATE_DIR}/pending-notes`;
+    MEMORY_FILE = `${CELL_STATE_DIR}/memory.md`;
+    MEMORY_EXTRACTION_TIMEOUT_MS = 15e3;
+    LIVENESS_CHECK_MS = 2e4;
+    ARTIFACTS_DIR = `${CELL_WORKSPACE}/artifacts`;
+    MAX_ARTIFACTS = 500;
+    MAX_ARTIFACT_BYTES = 50 * 1024 * 1024;
+    BRANCH_RE = /^[A-Za-z0-9._/-]{1,200}$/;
+    REPOSITORY_RE = /^[A-Za-z0-9-]{1,39}\/[A-Za-z0-9._-]{1,100}$/;
+    GIT = `git -C ${CELL_WORKSPACE} -c user.name=Autopilot -c user.email=autopilot@aster.invalid -c commit.gpgsign=false`;
+    COMMIT_SHA_RE = /^[0-9a-f]{7,40}$/;
+    MAX_TOOL_OUTPUT_CHARS = 16e3;
+    MAX_TOOL_INPUT_CHARS = 2e3;
+    MAX_CHECKPOINTS = 100;
     CELL_CONTROL_DIR = `${CELL_STATE_DIR}/control`;
     BRIDGE_MARKER = "startAsterCellBridge";
     CONTROL_RUNNER = `node --input-type=module -e 'import { executeAsterCellControl } from "/opt/autopilot/node_modules/autopilot-ai/dist/sdk/index.js";const r = await executeAsterCellControl(process.argv[1]);process.stdout.write(JSON.stringify(r) + "\\n");'`;
@@ -15643,6 +16861,14 @@ var init_aster_cell_runtime = __esm({
         this.archiveWorkspace = options.archiveWorkspace ?? defaultArchiveWorkspace;
         this.pollIntervalMs = options.pollIntervalMs ?? EVENT_POLL_MS;
         this.healthTimeoutMs = options.healthTimeoutMs ?? HEALTH_TIMEOUT_MS;
+        this.idlePauseMs = options.idlePauseMs ?? 0;
+        if (this.idlePauseMs > 0) {
+          const timer3 = setInterval(() => {
+            void this.pauseIdleCells(this.idlePauseMs).catch(() => {
+            });
+          }, options.idleSweepIntervalMs ?? 6e4);
+          timer3.unref();
+        }
       }
       provider;
       packageSpec;
@@ -15650,22 +16876,63 @@ var init_aster_cell_runtime = __esm({
       pollIntervalMs;
       healthTimeoutMs;
       activeRuns = /* @__PURE__ */ new Map();
+      idlePauseMs;
+      /**
+       * Pause running cells that have no active turn and no API activity within `idleMs`,
+       * least recently used first, stopping after `limit` pauses. Returns the paused ids.
+       */
+      async pauseIdleCells(idleMs, limit = Infinity) {
+        const busy = new Set([...this.activeRuns.values()].map((run) => run.cellId));
+        const now2 = Date.now();
+        const candidates = (await this.provider.listConversationCells()).filter((cell) => cell.status === "running" && !busy.has(cell.id) && now2 - Date.parse(cell.lastActivityAt) >= idleMs).sort((a, b) => Date.parse(a.lastActivityAt) - Date.parse(b.lastActivityAt));
+        const paused = [];
+        for (const cell of candidates) {
+          if (paused.length >= limit) break;
+          try {
+            await this.provider.pauseConversationCell(cell.id);
+            paused.push(cell.id);
+          } catch {
+          }
+        }
+        return paused;
+      }
       async provisionConversation(input) {
         let cell = await this.provider.findConversationCell(input.conversationId);
         if (!cell) {
           if (!input.allowCreate) throw new Error("hotcell_create_uncertain");
-          cell = await this.provider.createConversationCell({
+          const create = () => this.provider.createConversationCell({
             conversationId: input.conversationId,
             workspaceId: input.workspaceId,
-            model: input.model
+            model: input.model,
+            ...input.project ? { kind: input.project.kind } : {},
+            ...input.project?.github ? {
+              githubViaProxy: true,
+              env: {
+                ASTER_GITHUB_TOKEN: input.project.github.token,
+                ASTER_GITHUB_GIT_URL: input.project.github.gitUrl,
+                ASTER_GITHUB_API_URL: input.project.github.apiUrl
+              }
+            } : {}
           });
+          try {
+            cell = await create();
+          } catch (error) {
+            if ((await this.pauseIdleCells(6e4, 1).catch(() => [])).length === 0) throw error;
+            cell = await create();
+          }
         }
         input.onCellCreated(cell.getInfo().id);
-        await this.seedWorkspace(cell, input.workspaceRoot);
+        if (input.project?.kind === "code") {
+          await this.cloneRepository(cell, input.project);
+        } else if (input.project?.kind !== "chat") {
+          await this.seedWorkspace(cell, input.workspaceRoot);
+        }
+        await this.ensureRepository(cell, input.project?.kind === "code");
+        if (input.project) await this.addNote(cell, projectNote(input.project));
         await this.installRuntime(cell);
         await this.ensureBridge(cell);
         await this.control(cell, "POST", "/rpc", {
-          id: randomUUID7(),
+          id: randomUUID8(),
           type: "new_session",
           sessionId: input.sessionId,
           config: { model: input.model, cwd: CELL_WORKSPACE }
@@ -15681,19 +16948,76 @@ var init_aster_cell_runtime = __esm({
       async resumeCell(cellId) {
         await this.provider.resumeConversationCell(cellId);
       }
+      /** Switch the cell session's model between turns. The bridge persists it for session restore. */
+      async setModel(cellId, model) {
+        await this.ensureReady(cellId);
+        await this.controlById(cellId, "POST", "/rpc", { id: randomUUID8(), type: "set_model", modelId: model });
+      }
+      /** Reinstall the runtime if the cell's image lost it and restart the bridge if it isn't running. */
+      async ensureReady(cellId) {
+        const cell = await this.provider.getCell(cellId);
+        await this.installRuntime(cell);
+        await this.ensureBridge(cell);
+      }
+      /** Newest-first git history of the cell workspace; one commit per completed turn. */
+      async listCheckpoints(cellId) {
+        const cell = await this.provider.getCell(cellId);
+        if (!await this.ensureRepository(cell)) return [];
+        const result2 = await cell.exec(`${GIT} log -n ${MAX_CHECKPOINTS} --format=%H%x1f%cI%x1f%s`);
+        if (result2.exitCode !== 0) return [];
+        return result2.stdout.split("\n").filter(Boolean).map((line) => {
+          const [id = "", createdAt = "", message2 = ""] = line.split("");
+          return { id, createdAt, message: message2 };
+        });
+      }
+      /**
+       * Make the workspace match a checkpoint, recorded as a new commit so the restore
+       * itself can be undone. Ignored files (node_modules, .aster state) are untouched.
+       */
+      async restoreCheckpoint(cellId, conversationId, checkpointId) {
+        if (!COMMIT_SHA_RE.test(checkpointId)) throw new Error("invalid_checkpoint");
+        const cell = await this.provider.getCell(cellId);
+        if (!await this.ensureRepository(cell)) throw new Error("checkpoints_unavailable");
+        const exists = await cell.exec(`${GIT} cat-file -e ${checkpointId}^{commit}`);
+        if (exists.exitCode !== 0) throw new Error("checkpoint_not_found");
+        const short = checkpointId.slice(0, 7);
+        await cell.writeFile(CHECKPOINT_MESSAGE_FILE, `Restore checkpoint ${short}
+`);
+        const restore = await cell.exec(
+          `${GIT} restore --source=${checkpointId} --staged --worktree -- :/ && ${GIT} clean -fdq && ${GIT} commit -q --allow-empty -F ${CHECKPOINT_MESSAGE_FILE}`
+        );
+        if (restore.exitCode !== 0) throw new Error("checkpoint_restore_failed");
+        void conversationId;
+        await this.addNote(
+          cell,
+          `[The user restored the workspace to checkpoint ${short}. Files changed after that point were reverted; re-read files before relying on earlier observations.]`
+        );
+        const [head] = await this.listCheckpoints(cellId);
+        if (!head) throw new Error("checkpoint_restore_failed");
+        return head;
+      }
       startTurn(turn) {
         void this.runTurn(turn).catch(() => {
           turn.finish("failed", "cell_runtime_error");
         });
       }
+      /**
+       * Re-attach to a turn that was running when the server restarted. The cell kept working
+       * and journaled its events, so this only resumes reading them from the saved cursor.
+       */
+      resumeTurn(turn) {
+        void this.runTurn(turn, { resume: true }).catch(() => {
+          turn.finish("failed", "cell_runtime_error");
+        });
+      }
       cancelRun(runId) {
         const active = this.activeRuns.get(runId);
         if (!active) return;
         active.stop();
-        void this.controlById(active.cellId, "POST", "/rpc", { id: randomUUID7(), type: "abort" }).catch(() => {
+        void this.controlById(active.cellId, "POST", "/rpc", { id: randomUUID8(), type: "abort" }).catch(() => {
         });
       }
-      async runTurn(turn) {
+      async runTurn(turn, options = {}) {
         const { cellId, runId } = turn;
         let cursor = turn.cellEventCursor;
         let stopped = false;
@@ -15708,12 +17032,32 @@ var init_aster_cell_runtime = __esm({
           this.activeRuns.delete(runId);
           turn.finish(status, reason);
         };
+        let outcome;
+        let artifactsBefore = [];
         try {
-          await this.controlById(cellId, "POST", "/rpc", { id: runId, type: "prompt", message: turn.userText });
-        } catch {
-          finish("failed", "cell_prompt_rejected");
-          return;
+          if (options.resume) throw new Error("resume");
+          await this.ensureReady(cellId);
+          const cell = await this.provider.getCell(cellId);
+          if (turn.memory) {
+            await cell.mkdir(CELL_STATE_DIR, { parents: true });
+            await writeCellFileChunked(cell, MEMORY_FILE, turn.memory.snapshot);
+          }
+          const note = [await this.readNotes(cell), turn.memory?.note ?? ""].filter(Boolean).join("\n\n");
+          const message2 = note ? `${note}
+
+${turn.userText}` : turn.userText;
+          artifactsBefore = await this.listArtifacts(cellId).catch(() => []);
+          await this.controlById(cellId, "POST", "/rpc", { id: runId, type: "prompt", message: message2 });
+          if (note) await this.clearNotes(cell);
+        } catch (error) {
+          if (!(error instanceof Error && error.message === "resume")) {
+            finish("failed", "cell_prompt_rejected");
+            return;
+          }
+          artifactsBefore = await this.listArtifacts(cellId).catch(() => []);
         }
+        let quietPolls = 0;
+        const quietLimit = Math.max(5, Math.ceil(LIVENESS_CHECK_MS / this.pollIntervalMs));
         while (!stopped) {
           await sleep4(this.pollIntervalMs);
           if (stopped) break;
@@ -15724,6 +17068,18 @@ var init_aster_cell_runtime = __esm({
           } catch {
             continue;
           }
+          if (events.length === 0) {
+            if (++quietPolls >= quietLimit) {
+              quietPolls = 0;
+              const status = await this.controlById(cellId, "GET", "/status").catch(() => void 0);
+              if (status && !status.activeRunId) {
+                outcome = { status: "failed", reason: "cell_turn_lost" };
+                break;
+              }
+            }
+            continue;
+          }
+          quietPolls = 0;
           for (const entry of events) {
             cursor = Math.max(cursor, entry.cursor);
             turn.onCellCursor?.(cursor);
@@ -15736,35 +17092,72 @@ var init_aster_cell_runtime = __esm({
                 if (typeof event.text === "string") turn.publishEvent("assistant.reasoning", { text: event.text });
                 break;
               case "tool.start":
-                turn.publishEvent("tool.activity", { tool: event.tool, activity: "started" });
+                turn.publishEvent("tool.activity", {
+                  tool: event.toolName,
+                  toolCallId: event.toolCallId,
+                  activity: "started",
+                  input: summarizeToolInput(event.toolName, event.args)
+                });
+                break;
+              case "tool.result":
+                turn.publishEvent("tool.activity", {
+                  tool: event.toolName,
+                  toolCallId: event.toolCallId,
+                  activity: event.isError === true ? "failed" : "completed",
+                  output: boundedToolText(typeof event.result === "string" ? event.result : "", MAX_TOOL_OUTPUT_CHARS)
+                });
                 break;
               case "permission.request": {
-                const approved = await turn.askPermission({
-                  tool: { name: event.tool },
+                const decision = await turn.askPermission({
+                  tool: { name: event.toolName },
                   args: event.args ?? {}
                 });
                 await this.controlById(cellId, "POST", "/rpc", {
-                  id: randomUUID7(),
+                  id: randomUUID8(),
                   type: "resolve_permission",
-                  permissionId: event.id,
-                  approved
+                  requestId: event.requestId,
+                  decision
                 }).catch(() => {
                 });
-                turn.publishEvent("tool.activity", { tool: event.tool, activity: approved ? "approved" : "rejected" });
+                turn.publishEvent("tool.activity", { tool: event.toolName, activity: decision === "allow" ? "approved" : "rejected" });
                 break;
               }
               case "usage":
                 turn.publishEvent("usage", { usage: event.usage });
                 break;
               case "session.end":
-                finish(event.reason === "aborted" ? "cancelled" : event.reason === "complete" ? "completed" : "failed", String(event.reason ?? "cell_session_ended"));
+                outcome = {
+                  status: event.reason === "aborted" ? "cancelled" : event.reason === "complete" ? "completed" : "failed",
+                  // Surface the agent's actual error (redacted, bounded) instead of a bare "error".
+                  reason: event.reason === "error" && typeof event.error === "string" && event.error.trim() ? boundedToolText(event.error.trim(), 500) : String(event.reason ?? "cell_session_ended")
+                };
+                stopped = true;
                 break;
               default:
                 break;
             }
+            if (outcome) break;
           }
         }
-        if (!finished) finish("cancelled", "cell_turn_stopped");
+        try {
+          const before = new Map(artifactsBefore.map((artifact) => [artifact.path, artifact]));
+          for (const artifact of await this.listArtifacts(cellId)) {
+            const previous = before.get(artifact.path);
+            if (!previous || previous.size !== artifact.size || previous.modifiedAt !== artifact.modifiedAt) {
+              turn.publishEvent("artifact.updated", { ...artifact });
+            }
+          }
+        } catch {
+        }
+        await this.checkpoint(cellId, turn.userText).then((checkpoint) => {
+          if (checkpoint) turn.publishEvent("checkpoint.created", { ...checkpoint });
+        }).catch(() => {
+        });
+        if (outcome?.status === "completed" && turn.beforeFinish) {
+          await Promise.race([turn.beforeFinish().catch(() => {
+          }), sleep4(MEMORY_EXTRACTION_TIMEOUT_MS)]);
+        }
+        finish(outcome?.status ?? "cancelled", outcome?.reason ?? "cell_turn_stopped");
       }
       async seedWorkspace(cell, workspaceRoot) {
         const seeded = await cell.exec(`test -f ${CELL_STATE_DIR}/.seeded`);
@@ -15776,15 +17169,112 @@ var init_aster_cell_runtime = __esm({
         if (extract.exitCode !== 0) throw new Error("workspace_seed_failed");
         await cell.exec(`rm -f ${CELL_STATE_DIR}/workspace.tar.b64 && touch ${CELL_STATE_DIR}/.seeded`);
       }
+      /**
+       * Make /workspace a git repository with an initial commit (idempotent), excluding the
+       * bridge's private .aster state. Returns false when the cell image has no git, in
+       * which case checkpoints are skipped rather than failing the conversation.
+       */
+      async ensureRepository(cell, excludeArtifacts = false) {
+        const result2 = await cell.exec(
+          `command -v git >/dev/null || exit 3; if [ ! -d ${CELL_WORKSPACE}/.git ]; then git init -q ${CELL_WORKSPACE} || exit 1; fi; grep -qx '.aster/' ${CELL_WORKSPACE}/.git/info/exclude 2>/dev/null || printf '.aster/\\n' >> ${CELL_WORKSPACE}/.git/info/exclude; ` + // A code cell's artifacts are for the user, not the repository.
+          (excludeArtifacts ? `grep -qx 'artifacts/' ${CELL_WORKSPACE}/.git/info/exclude || printf 'artifacts/\\n' >> ${CELL_WORKSPACE}/.git/info/exclude; ` : "") + `${GIT} rev-parse -q --verify HEAD >/dev/null || { ${GIT} add -A && ${GIT} commit -q --allow-empty -m 'Workspace created'; }`
+        );
+        return result2.exitCode === 0;
+      }
+      /** Commit all workspace changes; returns the new checkpoint, or undefined when nothing changed. */
+      async checkpoint(cellId, userText) {
+        const cell = await this.provider.getCell(cellId);
+        if (!await this.ensureRepository(cell)) return void 0;
+        await cell.writeFile(CHECKPOINT_MESSAGE_FILE, checkpointMessage(userText), { mode: "0600" });
+        const commit = await cell.exec(
+          `${GIT} add -A && if ${GIT} diff --cached --quiet; then exit 4; fi && ${GIT} commit -q -F ${CHECKPOINT_MESSAGE_FILE}`
+        );
+        if (commit.exitCode !== 0) return void 0;
+        const [head] = await this.listCheckpoints(cellId);
+        return head;
+      }
+      /**
+       * Install the Autopilot runtime unless the cell already has the expected version. This
+       * checks the installed package itself rather than a marker on the persistent volume:
+       * /opt lives in the cell's root filesystem, which a container-driver pause discards,
+       * while an image with the runtime baked in skips the install entirely.
+       */
+      /**
+       * Clone a GitHub repository into /workspace on a new working branch, through Hotcell's
+       * credential gateway: the remote points at the gateway and git authenticates with the
+       * cell's own egress token, so the real GitHub token never enters the cell. Idempotent.
+       */
+      async cloneRepository(cell, project) {
+        const seeded = await cell.exec(`test -f ${CELL_STATE_DIR}/.seeded`);
+        if (seeded.exitCode === 0) return;
+        const { repository, baseBranch, branch } = project;
+        if (!repository || !REPOSITORY_RE.test(repository) || !baseBranch || !BRANCH_RE.test(baseBranch) || !branch || !BRANCH_RE.test(branch)) {
+          throw new Error("invalid_project");
+        }
+        await cell.mkdir(CELL_STATE_DIR, { parents: true });
+        const clone = await cell.exec(
+          `set -e; cd ${CELL_WORKSPACE}; if [ -n "$ASTER_GITHUB_GIT_URL" ]; then remote="$ASTER_GITHUB_GIT_URL/${repository}.git"; else remote="\${GITHUB_BASE_URL%/github}/github-git/${repository}.git"; fi; git init -q; git remote add origin "$remote" 2>/dev/null || git remote set-url origin "$remote"; git config credential.helper '!f() { echo username=x-access-token; echo "password=\${ASTER_GITHUB_TOKEN:-$GITHUB_API_KEY}"; }; f'; git config user.name "Aster Autopilot"; git config user.email "autopilot@aster.invalid"; if git ls-remote --exit-code --heads origin '${baseBranch}' >/dev/null 2>&1; then git fetch -q origin '${baseBranch}'; git checkout -q -b '${branch}' FETCH_HEAD; else git checkout -q -b '${branch}'; fi; touch ${CELL_STATE_DIR}/.seeded`
+        );
+        if (clone.exitCode !== 0) throw new Error("repository_clone_failed");
+      }
+      /** Files under /workspace/artifacts, the folder the agent saves user-facing deliverables in. */
+      async listArtifacts(cellId) {
+        const cell = await this.provider.getCell(cellId);
+        const result2 = await cell.exec(
+          `[ -d ${ARTIFACTS_DIR} ] || exit 0; cd ${ARTIFACTS_DIR} && find . -type f ! -path '*/.*' -printf '%P\\t%s\\t%T@\\n' | head -n ${MAX_ARTIFACTS}`
+        );
+        if (result2.exitCode !== 0) return [];
+        return result2.stdout.split("\n").filter(Boolean).flatMap((line) => {
+          const [path = "", size = "", modified = ""] = line.split("	");
+          if (!isSafeArtifactPath(path)) return [];
+          return [{
+            path,
+            name: path.split("/").pop() ?? path,
+            size: Number(size) || 0,
+            modifiedAt: new Date(Math.round(Number(modified) * 1e3) || Date.now()).toISOString(),
+            mimeType: artifactMimeType(path)
+          }];
+        }).sort((a, b) => b.modifiedAt.localeCompare(a.modifiedAt));
+      }
+      /** The bytes of one artifact, at most 50 MB. */
+      async readArtifact(cellId, path) {
+        if (!isSafeArtifactPath(path)) throw new Error("invalid_artifact_path");
+        const cell = await this.provider.getCell(cellId);
+        const file = shellQuote2(`${ARTIFACTS_DIR}/${path}`);
+        const stat10 = await cell.exec(`[ -f ${file} ] && [ ! -L ${file} ] && stat -c %s -- ${file}`);
+        if (stat10.exitCode !== 0) throw new Error("artifact_not_found");
+        if (Number(stat10.stdout.trim()) > MAX_ARTIFACT_BYTES) throw new Error("artifact_too_large");
+        const encoded = await cell.exec(`base64 -w0 -- ${file}`);
+        if (encoded.exitCode !== 0) throw new Error("artifact_not_found");
+        return { data: Buffer.from(encoded.stdout.trim(), "base64"), mimeType: artifactMimeType(path), name: path.split("/").pop() ?? path };
+      }
+      /** Notes are prepended to the agent's next prompt once; kept in the cell so they survive restarts. */
+      async addNote(cell, text) {
+        const existing = await this.readNotes(cell);
+        await cell.mkdir(CELL_STATE_DIR, { parents: true });
+        await cell.writeFile(NOTES_FILE, existing ? `${existing}
+
+${text}` : text, { mode: "0600" });
+      }
+      async readNotes(cell) {
+        try {
+          return (await cell.readFile(NOTES_FILE)).trim();
+        } catch {
+          return "";
+        }
+      }
+      async clearNotes(cell) {
+        await cell.exec(`rm -f ${NOTES_FILE}`);
+      }
       async installRuntime(cell) {
-        const marker = `${CELL_STATE_DIR}/.runtime-version`;
+        const expectedVersion = /@(\d[^@/]*)$/.exec(this.packageSpec)?.[1];
         try {
-          if (await cell.readFile(marker) === this.packageSpec) return;
+          const installed = JSON.parse(await cell.readFile(INSTALLED_RUNTIME_PACKAGE));
+          if (!expectedVersion || installed.version === expectedVersion) return;
         } catch {
         }
         const install = await cell.exec(`mkdir -p /opt/autopilot && npm install --prefix /opt/autopilot --no-audit --no-fund ${this.packageSpec}`);
         if (install.exitCode !== 0) throw new Error("cell_runtime_install_failed");
-        await cell.writeFile(marker, this.packageSpec);
       }
       async ensureBridge(cell) {
         const processes = await cell.listProcesses().catch(() => []);
@@ -15797,7 +17287,7 @@ var init_aster_cell_runtime = __esm({
         for (; ; ) {
           try {
             const health = await this.control(cell, "GET", "/health");
-            if (health.ok === true) return;
+            if (health.ok === true && (!health.sessionId || health.initialized === true)) return;
           } catch {
           }
           if (Date.now() > deadline) throw new Error("cell_bridge_unhealthy");
@@ -15805,9 +17295,9 @@ var init_aster_cell_runtime = __esm({
         }
       }
       async control(cell, method, path, body) {
-        const requestId = randomUUID7();
+        const requestId = randomUUID8();
         await cell.mkdir(CELL_CONTROL_DIR, { parents: true });
-        await cell.writeFile(`${CELL_CONTROL_DIR}/${requestId}.json`, JSON.stringify({ method, path, body }), { mode: "0600" });
+        await writeCellFileChunked(cell, `${CELL_CONTROL_DIR}/${requestId}.json`, JSON.stringify({ method, path, body }));
         const result2 = await cell.exec(`${CONTROL_RUNNER} ${requestId}`);
         if (result2.exitCode !== 0) throw new Error("cell_control_failed");
         const parsed = JSON.parse(result2.stdout.trim().split("\n").pop() ?? "{}");
@@ -15819,6 +17309,32 @@ var init_aster_cell_runtime = __esm({
         return this.control(cell, method, path, body);
       }
     };
+    CELL_FILE_WRITE_CHUNK_CHARS = 32 * 1024;
+    ARTIFACT_MIME_TYPES = {
+      pdf: "application/pdf",
+      html: "text/html",
+      htm: "text/html",
+      md: "text/markdown",
+      txt: "text/plain",
+      csv: "text/csv",
+      json: "application/json",
+      png: "image/png",
+      jpg: "image/jpeg",
+      jpeg: "image/jpeg",
+      gif: "image/gif",
+      webp: "image/webp",
+      svg: "image/svg+xml",
+      pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+      docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+      xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+      key: "application/vnd.apple.keynote",
+      pages: "application/vnd.apple.pages",
+      numbers: "application/vnd.apple.numbers",
+      zip: "application/zip",
+      mp4: "video/mp4",
+      mov: "video/quicktime",
+      mp3: "audio/mpeg"
+    };
   }
 });
 
@@ -15831,8 +17347,8 @@ function validateConfig(config2) {
     throw new HotcellProviderError("Hotcell must use HTTPS unless the control endpoint is loopback", "insecure_hotcell_endpoint");
   }
   if (!config2.apiKey.trim()) throw new HotcellProviderError("Hotcell API key is required", "hotcell_auth_required");
-  if (config2.driver !== "applevz" && config2.driver !== "firecracker") {
-    throw new HotcellProviderError("Aster requires an explicit Hotcell microVM driver", "unsafe_hotcell_driver");
+  if (!HOTCELL_DRIVERS.includes(config2.driver)) {
+    throw new HotcellProviderError("Aster requires an explicit Hotcell driver", "unsafe_hotcell_driver");
   }
   if (!Number.isInteger(config2.memoryMb) || config2.memoryMb < 512 || !Number.isFinite(config2.cpus) || config2.cpus < 0.5 || !Number.isInteger(config2.pidsLimit) || config2.pidsLimit < 32) {
     throw new HotcellProviderError("Hotcell resource limits are invalid", "invalid_hotcell_limits");
@@ -15856,11 +17372,12 @@ function numberEnv(value, fallback, min, max) {
   if (!Number.isFinite(parsed) || parsed < min || parsed > max) throw new HotcellProviderError("Invalid Hotcell resource configuration", "invalid_hotcell_config");
   return parsed;
 }
-var HOTCELL_CONVERSATION_LABEL, HotcellProviderError, HotcellProvider;
+var HOTCELL_CONVERSATION_LABEL, HOTCELL_DRIVERS, HotcellProviderError, HotcellProvider;
 var init_hotcell_provider = __esm({
   "src/server/hotcell-provider.ts"() {
     "use strict";
     HOTCELL_CONVERSATION_LABEL = "autopilot.conversation_id";
+    HOTCELL_DRIVERS = ["applevz", "firecracker", "container"];
     HotcellProviderError = class extends Error {
       constructor(message2, code) {
         super(message2);
@@ -15881,9 +17398,9 @@ var init_hotcell_provider = __esm({
         const endpoint = env2.AUTOPILOT_HOTCELL_ENDPOINT;
         const apiKey = env2.AUTOPILOT_HOTCELL_API_KEY;
         const driver = env2.AUTOPILOT_HOTCELL_DRIVER;
-        if (!endpoint || !apiKey || driver !== "applevz" && driver !== "firecracker") {
+        if (!endpoint || !apiKey || !HOTCELL_DRIVERS.includes(driver)) {
           throw new HotcellProviderError(
-            "Aster Hotcell requires AUTOPILOT_HOTCELL_ENDPOINT, AUTOPILOT_HOTCELL_API_KEY, and an explicit AUTOPILOT_HOTCELL_DRIVER (applevz or firecracker)",
+            "Aster Hotcell requires AUTOPILOT_HOTCELL_ENDPOINT, AUTOPILOT_HOTCELL_API_KEY, and an explicit AUTOPILOT_HOTCELL_DRIVER (applevz, firecracker, or container)",
             "hotcell_not_configured"
           );
         }
@@ -15891,6 +17408,11 @@ var init_hotcell_provider = __esm({
           endpoint,
           apiKey,
           driver,
+          networked: env2.AUTOPILOT_HOTCELL_NETWORKED === "true",
+          anyModel: env2.AUTOPILOT_HOTCELL_ANY_MODEL === "true",
+          sleepAfterMs: integerEnv(env2.AUTOPILOT_HOTCELL_SLEEP_AFTER_MS, 0, 0, 7 * 24 * 60 * 60 * 1e3),
+          ...env2.AUTOPILOT_HOTCELL_IMAGE ? { image: env2.AUTOPILOT_HOTCELL_IMAGE } : {},
+          ...env2.AUTOPILOT_HOTCELL_CHAT_MEMORY_MB ? { chatMemoryMb: integerEnv(env2.AUTOPILOT_HOTCELL_CHAT_MEMORY_MB, 1024, 512, 65536) } : {},
           memoryMb: integerEnv(env2.AUTOPILOT_HOTCELL_MEMORY_MB, 4096, 512, 65536),
           cpus: numberEnv(env2.AUTOPILOT_HOTCELL_CPUS, 2, 0.5, 64),
           pidsLimit: integerEnv(env2.AUTOPILOT_HOTCELL_PIDS, 256, 32, 8192),
@@ -15915,23 +17437,28 @@ var init_hotcell_provider = __esm({
         const info = await this.client.info();
         if (!info.auth) throw new HotcellProviderError("Hotcell API authentication is disabled; refusing to provision an Aster cell", "hotcell_auth_required");
         if (!info.drivers.includes(this.config.driver)) {
-          throw new HotcellProviderError("Configured Hotcell microVM driver is unavailable", "hotcell_driver_unavailable");
+          throw new HotcellProviderError("Configured Hotcell driver is unavailable", "hotcell_driver_unavailable");
         }
         if (!info.egressProviders.includes("openrouter")) {
           throw new HotcellProviderError("Hotcell OpenRouter credential gateway is unavailable", "hotcell_egress_unavailable");
         }
+        if (input.kind === "code" && !input.githubViaProxy && !info.egressProviders.includes("github")) {
+          throw new HotcellProviderError("Hotcell GitHub credential gateway is unavailable", "hotcell_github_unavailable");
+        }
         const options = {
           driver: this.config.driver,
-          networked: false,
+          ...this.config.image ? { image: this.config.image } : {},
+          ...input.env ? { env: input.env } : {},
+          networked: this.config.networked === true,
           persist: true,
-          sleepAfter: 0,
-          memoryMb: this.config.memoryMb,
+          sleepAfter: this.config.sleepAfterMs ?? 0,
+          memoryMb: input.kind === "chat" ? this.config.chatMemoryMb ?? this.config.memoryMb : this.config.memoryMb,
           cpus: this.config.cpus,
           pidsLimit: this.config.pidsLimit,
           egressSpendCapUsd: this.config.spendCapUsd,
           egress: {
-            providers: ["openrouter"],
-            models: [input.model],
+            providers: input.kind === "code" && !input.githubViaProxy ? ["openrouter", "github", "github-git"] : ["openrouter"],
+            ...this.config.anyModel ? {} : { models: [input.model] },
             spendCapUsd: this.config.spendCapUsd,
             ttlMs: this.config.tokenTtlMs
           },
@@ -15961,6 +17488,15 @@ var init_hotcell_provider = __esm({
         for (const token of tokens) await cell.revokeEgressToken(token.token);
         await cell.destroy();
       }
+      /** Aster conversation cells with their lifecycle status and last API activity. */
+      async listConversationCells() {
+        return (await this.client.list()).filter((item) => item.labels?.[HOTCELL_CONVERSATION_LABEL]).map((item) => ({
+          id: item.id,
+          conversationId: item.labels[HOTCELL_CONVERSATION_LABEL],
+          status: item.status,
+          lastActivityAt: item.lastActivityAt
+        }));
+      }
       /** True suspend: on microVM drivers the daemon snapshots memory, so the Autopilot session resumes alive. */
       async pauseConversationCell(cellId) {
         if (!cellId.trim()) throw new HotcellProviderError("Missing Hotcell id", "hotcell_id_missing");
@@ -15975,13 +17511,16 @@ var init_hotcell_provider = __esm({
 });
 
 // src/server/routes.ts
-import { randomUUID as randomUUID8 } from "crypto";
+import { randomUUID as randomUUID9 } from "crypto";
 import { URL as URL2 } from "url";
-import { readFile as readFile20, unlink as unlink3 } from "fs/promises";
+import { readFile as readFile21, unlink as unlink3 } from "fs/promises";
 import { resolve as resolve9, basename as basename5 } from "path";
 function createHotcellAsterRuntime() {
   try {
-    return new AsterHotcellRuntime(HotcellProvider.fromEnvironment());
+    const idlePauseMs = Number(process.env.AUTOPILOT_ASTER_IDLE_PAUSE_MS ?? 15 * 60 * 1e3);
+    return new AsterHotcellRuntime(HotcellProvider.fromEnvironment(), {
+      idlePauseMs: Number.isFinite(idlePauseMs) && idlePauseMs >= 0 ? idlePauseMs : 15 * 60 * 1e3
+    });
   } catch (error) {
     if (error instanceof HotcellProviderError && error.code === "hotcell_not_configured") return void 0;
     throw error;
@@ -16067,7 +17606,7 @@ async function buildUserMessage2(prompt, files, cwd) {
       }
     } else {
       try {
-        const content = await readFile20(filePath, "utf8");
+        const content = await readFile21(filePath, "utf8");
         const relPath = filePath.startsWith(cwd) ? filePath.slice(cwd.length + 1) : filePath;
         fileContents.push(`
 --- ${relPath} ---
@@ -16146,6 +17685,12 @@ function setupRoutes(config2, options = {}) {
     cancelRun: () => {
     }
   });
+  if (!options.asterRuntime) {
+    void asterApi.startGitHubProxy().catch((error) => {
+      process.stderr.write(`aster: GitHub proxy failed to start: ${error instanceof Error ? error.message : String(error)}
+`);
+    });
+  }
   const wakeScheduler = new RunWakeScheduler({
     onWake: async (event) => {
       const store = new RunStore();
@@ -16288,7 +17833,7 @@ function setupRoutes(config2, options = {}) {
         const executor = new ToolExecutor(tools);
         const { makeSessionId: makeSessionId2 } = await Promise.resolve().then(() => (init_sessions(), sessions_exports));
         const sessionId = makeSessionId2(task);
-        const runId = randomUUID8();
+        const runId = randomUUID9();
         const worktreeManager = new RunWorktreeManager();
         let worktree;
         if (useWorktree) {
@@ -16870,10 +18415,10 @@ var server_exports = {};
 __export(server_exports, {
   startServer: () => startServer
 });
-import { createServer } from "http";
+import { createServer as createServer2 } from "http";
 async function startServer(opts2) {
   const { handleRequest, cleanup } = setupRoutes(opts2.config, { asterRuntime: opts2.asterRuntime });
-  const server = createServer((req, res) => {
+  const server = createServer2((req, res) => {
     const isAsterApi = req.url?.startsWith("/api/v1/") === true;
     if (!isAsterApi) {
       res.setHeader("Access-Control-Allow-Origin", "*");
@@ -16972,9 +18517,9 @@ __export(db_exports, {
   updateAccessedAt: () => updateAccessedAt,
   updateMemoryEmbedding: () => updateMemoryEmbedding
 });
-import Database4 from "better-sqlite3";
-import { dirname as dirname15 } from "path";
-import { mkdirSync as mkdirSync7, statSync as statSync4 } from "fs";
+import Database6 from "better-sqlite3";
+import { dirname as dirname17 } from "path";
+import { mkdirSync as mkdirSync8, statSync as statSync4 } from "fs";
 function initSchema(db) {
   db.exec(`
     CREATE TABLE IF NOT EXISTS memories (
@@ -17058,8 +18603,8 @@ function openMemoryDb(dbPath) {
   if (dbInstance) {
     dbInstance.close();
   }
-  mkdirSync7(dirname15(dbPath), { recursive: true });
-  dbInstance = new Database4(dbPath);
+  mkdirSync8(dirname17(dbPath), { recursive: true });
+  dbInstance = new Database6(dbPath);
   dbInstance.pragma("journal_mode = WAL");
   dbInstance.pragma("foreign_keys = ON");
   initSchema(dbInstance);
@@ -19013,120 +20558,6 @@ var init_lsp = __esm({
   }
 });
 
-// src/models/openrouter-catalog.ts
-var openrouter_catalog_exports = {};
-__export(openrouter_catalog_exports, {
-  DEFAULT_CACHE_TTL_MS: () => DEFAULT_CACHE_TTL_MS,
-  ensureOpenRouterCatalog: () => ensureOpenRouterCatalog,
-  fetchOpenRouterCatalog: () => fetchOpenRouterCatalog,
-  loadOpenRouterCatalog: () => loadOpenRouterCatalog,
-  mapOpenRouterModel: () => mapOpenRouterModel
-});
-import { readFile as readFile21, writeFile as writeFile12, mkdir as mkdir13 } from "fs/promises";
-import { homedir as homedir22 } from "os";
-import { join as join31, dirname as dirname16 } from "path";
-function catalogCachePath() {
-  const xdg = process.env.XDG_CONFIG_HOME || join31(homedir22(), ".config");
-  return join31(xdg, "kimiflare", "openrouter-models.json");
-}
-function perMtok(perToken) {
-  const n = Number(perToken);
-  return Number.isFinite(n) ? n * 1e6 : 0;
-}
-function mapOpenRouterModel(raw) {
-  const supported = new Set(raw.supported_parameters ?? []);
-  const aa = raw.benchmarks?.artificial_analysis;
-  const quality = {
-    ...typeof aa?.coding_index === "number" ? { coding: aa.coding_index } : {},
-    ...typeof aa?.agentic_index === "number" ? { agentic: aa.agentic_index } : {},
-    ...typeof aa?.intelligence_index === "number" ? { intelligence: aa.intelligence_index } : {}
-  };
-  return {
-    id: raw.id,
-    ...raw.name ? { name: raw.name } : {},
-    ...typeof raw.created === "number" ? { created: raw.created } : {},
-    ...Object.keys(quality).length > 0 ? { quality } : {},
-    ...raw.supported_parameters ? { parameters: [...raw.supported_parameters] } : {},
-    contextWindow: raw.context_length ?? 128e3,
-    maxOutputTokens: raw.top_provider?.max_completion_tokens ?? 4096,
-    pricing: {
-      inputPerMtok: perMtok(raw.pricing?.prompt),
-      ...raw.pricing?.input_cache_read ? { cachedInputPerMtok: perMtok(raw.pricing.input_cache_read) } : {},
-      outputPerMtok: perMtok(raw.pricing?.completion)
-    },
-    supports: {
-      // OpenRouter's own catalog is the authority on whether a model accepts tool
-      // calls; absence of "tools" here means the upstream provider doesn't support
-      // function calling for this model, and we must not claim otherwise.
-      tools: supported.has("tools"),
-      reasoning: supported.has("reasoning") || supported.has("include_reasoning"),
-      streaming: true,
-      vision: (raw.architecture?.input_modalities ?? []).includes("image"),
-      temperature: supported.has("temperature") ? true : void 0
-    }
-  };
-}
-async function fetchOpenRouterCatalog(fetchImpl2 = fetch) {
-  const res = await fetchWithNetworkRetry(fetchImpl2, openRouterUrl("models"), {
-    headers: { Accept: "application/json" }
-  });
-  if (!res.ok) {
-    throw new Error(`OpenRouter /models returned HTTP ${res.status}`);
-  }
-  const body = await res.json();
-  return (body.data ?? []).map(mapOpenRouterModel);
-}
-async function readCache3() {
-  try {
-    const raw = await readFile21(catalogCachePath(), "utf8");
-    const parsed = JSON.parse(raw);
-    return parsed.version === CACHE_VERSION ? parsed : null;
-  } catch {
-    return null;
-  }
-}
-async function writeCache3(models) {
-  const path = catalogCachePath();
-  try {
-    await mkdir13(dirname16(path), { recursive: true });
-    const cache = { version: CACHE_VERSION, fetchedAt: (/* @__PURE__ */ new Date()).toISOString(), models };
-    await writeFile12(path, JSON.stringify(cache, null, 2), "utf8");
-  } catch {
-  }
-}
-async function loadOpenRouterCatalog(opts2 = {}) {
-  const ttlMs = opts2.ttlMs ?? DEFAULT_CACHE_TTL_MS;
-  const cached = await readCache3();
-  const isFresh = cached && Date.now() - Date.parse(cached.fetchedAt) < ttlMs;
-  if (isFresh) return cached.models;
-  try {
-    const models = await fetchOpenRouterCatalog(opts2.fetchImpl ?? fetch);
-    await writeCache3(models);
-    return models;
-  } catch {
-    return cached?.models ?? [];
-  }
-}
-async function ensureOpenRouterCatalog(opts2 = {}) {
-  try {
-    const models = await loadOpenRouterCatalog(opts2);
-    if (models.length > 0) registerOpenRouterModels(models);
-    return models.length;
-  } catch {
-    return 0;
-  }
-}
-var CACHE_VERSION, DEFAULT_CACHE_TTL_MS;
-var init_openrouter_catalog = __esm({
-  "src/models/openrouter-catalog.ts"() {
-    "use strict";
-    init_registry();
-    init_openrouter();
-    CACHE_VERSION = 4;
-    DEFAULT_CACHE_TTL_MS = 6 * 60 * 60 * 1e3;
-  }
-});
-
 // src/models/requesty-catalog.ts
 var requesty_catalog_exports = {};
 __export(requesty_catalog_exports, {
@@ -19139,7 +20570,7 @@ __export(requesty_catalog_exports, {
 });
 import { readFile as readFile22, writeFile as writeFile13, mkdir as mkdir14 } from "fs/promises";
 import { homedir as homedir23 } from "os";
-import { join as join32, dirname as dirname17 } from "path";
+import { join as join32, dirname as dirname18 } from "path";
 function catalogCachePath2() {
   const xdg = process.env.XDG_CONFIG_HOME || join32(homedir23(), ".config");
   return join32(xdg, "kimiflare", "requesty-models.json");
@@ -19213,7 +20644,7 @@ async function readCache4() {
 async function writeCache4(catalog) {
   const path = catalogCachePath2();
   try {
-    await mkdir14(dirname17(path), { recursive: true });
+    await mkdir14(dirname18(path), { recursive: true });
     const cache = { version: CACHE_VERSION2, fetchedAt: (/* @__PURE__ */ new Date()).toISOString(), ...catalog };
     await writeFile13(path, JSON.stringify(cache, null, 2), "utf8");
   } catch {
@@ -21261,7 +22692,7 @@ __export(app_helpers_exports, {
   trackRecentFile: () => trackRecentFile
 });
 import { execSync as execSync3, spawn as spawn6 } from "child_process";
-import { existsSync as existsSync5, readFileSync as readFileSync5, statSync as statSync5 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync6, statSync as statSync5 } from "fs";
 import { join as join34 } from "path";
 import { platform as platform3 } from "os";
 function replaceQueuedPrompt(queue2, key, full, display) {
@@ -21375,7 +22806,7 @@ function buildFilePickerIgnoreList(cwd) {
     if (stats.size > MAX_GITIGNORE_SIZE) {
       return hardcoded;
     }
-    const content = readFileSync5(gitignorePath, "utf-8");
+    const content = readFileSync6(gitignorePath, "utf-8");
     for (const line of content.split(/\r?\n/)) {
       const trimmed = line.trim();
       if (!trimmed || trimmed.startsWith("#")) continue;
@@ -25833,6 +27264,8 @@ function humanizeToolTitle(toolName, originalTitle, tier) {
     return humanizeMcpTitle(toolName, originalTitle, tier);
   }
   switch (toolName) {
+    case "execute_code":
+      return "Running code batch";
     case "read":
       return pick(tier, {
         light: `Taking a quick look at ${extractPath(originalTitle)}`,
@@ -26523,6 +27956,7 @@ function isSettled(e) {
   if (e.kind === "assistant") return !e.streaming;
   if (e.kind === "tool") return e.status !== "running" && e.status !== "queued";
   if (e.kind === "user") return !e.queued;
+  if (e.kind === "info") return !e.pending;
   return true;
 }
 function firstUnsettledIndex(events) {
@@ -29447,12 +30881,12 @@ auto (default) lets the coordinator assess substantial tasks and delegate indepe
       setEvents((events) => [
         ...events,
         { kind: "user", key: mkKey2(), text: `/jev ${rest.join(" ")}` },
-        { kind: "info", key: eventKey, text: "Jev is evaluating\u2026" }
+        { kind: "info", key: eventKey, text: "Jev is evaluating\u2026", pending: true }
       ]);
       try {
         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}` });
+        setResult(eventKey, { kind: "info", key: eventKey, text: `Jev is evaluating \xB7 ${receipt}`, pending: true });
         await new Promise((resolve15) => setTimeout(resolve15, 0));
         const answer = await askJev(apiKey, question, { context });
         const presentation = presentJevAnswer(question, answer);
@@ -30905,7 +32339,7 @@ __export(openrouter_oauth_exports, {
   startLoopbackListener: () => startLoopbackListener
 });
 import { createHash as createHash4, randomBytes as randomBytes3 } from "crypto";
-import { createServer as createServer2 } from "http";
+import { createServer as createServer3 } from "http";
 import { hostname } from "os";
 function createPkce() {
   const verifier = randomBytes3(32).toString("base64url");
@@ -30961,7 +32395,7 @@ async function startLoopbackListener(opts2 = {}) {
   });
   code.catch(() => void 0);
   let settled = false;
-  const server = createServer2((req, res) => {
+  const server = createServer3((req, res) => {
     const url = new URL(req.url ?? "/", "http://127.0.0.1");
     if (url.pathname !== "/callback") {
       res.writeHead(404).end();
@@ -36285,7 +37719,7 @@ var init_run_compact = __esm({
 
 // src/commands/save.ts
 import { mkdir as mkdir16, writeFile as writeFile15, unlink as unlink5 } from "fs/promises";
-import { dirname as dirname19 } from "path";
+import { dirname as dirname20 } from "path";
 async function saveCustomCommand(opts2) {
   const dir = opts2.source === "project" ? projectCommandsDir(opts2.cwd) : globalCommandsDir();
   const filepath = `${dir}/${opts2.name}.md`;
@@ -36296,7 +37730,7 @@ async function saveCustomCommand(opts2) {
   if (opts2.effort) data.effort = opts2.effort;
   const frontmatter = serializeFrontmatter(data);
   const content = frontmatter + opts2.template;
-  await mkdir16(dirname19(filepath), { recursive: true });
+  await mkdir16(dirname20(filepath), { recursive: true });
   await writeFile15(filepath, content, "utf8");
   return { filepath };
 }