autopilot-ai 1.21.0 → 1.22.0

package/dist/index.js

@@ -18192,8 +18192,7 @@ var init_aster_workspaces = __esm({
 // src/server/aster-store.ts
 var aster_store_exports = {};
 __export(aster_store_exports, {
-  AsterStore: () => AsterStore,
-  defaultAsterDbPath: () => defaultAsterDbPath
+  AsterStore: () => AsterStore
 });
 import Database4 from "better-sqlite3";
 import { createHash as createHash5, randomBytes as randomBytes2, randomUUID as randomUUID6 } from "crypto";
@@ -18207,22 +18206,6 @@ function defaultAsterDbPath() {
 function hashToken(token) {
   return createHash5("sha256").update(token).digest("hex");
 }
-function cellMappingFromRow(row) {
-  return {
-    conversationId: row.conversation_id,
-    credentialId: row.credential_id,
-    workspaceId: row.workspace_id,
-    model: row.model,
-    sessionId: row.session_id,
-    cellName: row.cell_name,
-    cellId: row.cell_id ?? null,
-    status: row.status,
-    createAttempted: row.create_attempted === 1,
-    eventCursor: row.event_cursor,
-    createdAt: row.created_at,
-    updatedAt: row.updated_at
-  };
-}
 function rowToConversation(row) {
   return {
     id: row.id,
@@ -18340,38 +18323,6 @@ var init_aster_store = __esm({
         created_at INTEGER NOT NULL,
         PRIMARY KEY (conversation_id, client_turn_id)
       );
-      CREATE TABLE IF NOT EXISTS aster_cell_mappings (
-        conversation_id TEXT PRIMARY KEY,
-        credential_id TEXT NOT NULL,
-        workspace_id TEXT NOT NULL,
-        model TEXT NOT NULL,
-        session_id TEXT NOT NULL UNIQUE,
-        cell_name TEXT NOT NULL UNIQUE,
-        cell_id TEXT,
-        create_key_hash TEXT NOT NULL,
-        create_fingerprint TEXT NOT NULL,
-        status TEXT NOT NULL,
-        create_attempted INTEGER NOT NULL DEFAULT 0,
-        event_cursor INTEGER NOT NULL DEFAULT 0,
-        created_at INTEGER NOT NULL,
-        updated_at INTEGER NOT NULL,
-        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);
@@ -18381,49 +18332,6 @@ var init_aster_store = __esm({
       close() {
         this.db.close();
       }
-      reserveCellConversation(input) {
-        const keyHash = createHash5("sha256").update(input.idempotencyKey).digest("hex");
-        const fingerprint = createHash5("sha256").update(JSON.stringify([input.workspaceId, input.model])).digest("hex");
-        const reserve = this.db.transaction(() => {
-          const existing = this.db.prepare("SELECT * FROM aster_cell_mappings WHERE credential_id = ? AND create_key_hash = ?").get(input.credentialId, keyHash);
-          if (existing) {
-            const mapping = cellMappingFromRow(existing);
-            return mapping.workspaceId === input.workspaceId && mapping.model === input.model ? { kind: "replay", mapping } : { kind: "conflict" };
-          }
-          const now2 = Date.now();
-          this.db.prepare(`INSERT INTO aster_cell_mappings
-        (conversation_id, credential_id, workspace_id, model, session_id, cell_name, create_key_hash, create_fingerprint, status, created_at, updated_at)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'provisioning', ?, ?)`).run(input.conversationId, input.credentialId, input.workspaceId, input.model, input.sessionId, input.cellName, keyHash, fingerprint, now2, now2);
-          return { kind: "created", mapping: this.getCellMapping(input.conversationId) };
-        });
-        return reserve.immediate();
-      }
-      getCellMapping(conversationId) {
-        const row = this.db.prepare("SELECT * FROM aster_cell_mappings WHERE conversation_id = ?").get(conversationId);
-        return row ? cellMappingFromRow(row) : void 0;
-      }
-      listCellMappings() {
-        const rows = this.db.prepare("SELECT * FROM aster_cell_mappings ORDER BY created_at").all();
-        return rows.map(cellMappingFromRow);
-      }
-      getCredentialCellMapping(conversationId, credentialId) {
-        const row = this.db.prepare("SELECT * FROM aster_cell_mappings WHERE conversation_id = ? AND credential_id = ?").get(conversationId, credentialId);
-        return row ? cellMappingFromRow(row) : void 0;
-      }
-      markCellCreateAttempted(conversationId) {
-        this.db.prepare("UPDATE aster_cell_mappings SET create_attempted = 1, updated_at = ? WHERE conversation_id = ?").run(Date.now(), conversationId);
-      }
-      setCellId(conversationId, cellId) {
-        this.db.prepare("UPDATE aster_cell_mappings SET cell_id = ?, updated_at = ? WHERE conversation_id = ?").run(cellId, Date.now(), conversationId);
-      }
-      setCellStatus(conversationId, status) {
-        this.db.prepare("UPDATE aster_cell_mappings SET status = ?, updated_at = ? WHERE conversation_id = ?").run(status, Date.now(), conversationId);
-      }
-      advanceCellEventCursor(conversationId, cursor) {
-        if (!Number.isSafeInteger(cursor) || cursor < 0) throw new Error("invalid Hotcell event cursor");
-        const result2 = this.db.prepare("UPDATE aster_cell_mappings SET event_cursor = ?, updated_at = ? WHERE conversation_id = ? AND event_cursor < ?").run(cursor, Date.now(), conversationId, cursor);
-        return result2.changes === 1;
-      }
       createCredential(input) {
         const name = input.name.trim();
         if (!name || name.length > 100) throw new Error("credential name must be 1 to 100 characters");
@@ -18539,57 +18447,6 @@ var init_aster_store = __esm({
         });
         return update.immediate();
       }
-      setConversationStatus(conversationId, status, data = {}) {
-        const update = this.db.transaction(() => {
-          const now2 = Date.now();
-          const result2 = this.db.prepare("UPDATE aster_conversations SET status = ?, updated_at = ? WHERE id = ? AND active_run_id IS NULL").run(status, now2, conversationId);
-          if (result2.changes !== 1) return false;
-          this.insertEvent(conversationId, null, "status", { status, ...data }, now2);
-          return true;
-        });
-        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();
@@ -19492,103 +19349,6 @@ var init_wake_scheduler = __esm({
   }
 });
 
-// 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 isAbsolute6, relative as relative9, sep as sep5 } from "path";
@@ -19629,31 +19389,6 @@ async function assertAsterWorkspacePath(workspaceRoot, value, allowMissing = fal
   assertNotSensitive(root, actual);
   return candidate;
 }
-function assertAsterCellPath(value) {
-  if (typeof value !== "string" || !value.trim()) throw new Error("workspace_path_invalid");
-  const root = "/workspace";
-  const candidate = value.startsWith("/") ? posixNormalize(value) : posixNormalize(`${root}/${value}`);
-  if (candidate !== root && !candidate.startsWith(root + "/")) throw new Error("workspace_path_forbidden");
-  const parts = candidate.slice(root.length).split("/").filter(Boolean).map((part) => part.toLowerCase());
-  if (parts.some((part) => part === ".env" || part.startsWith(".env.") || SENSITIVE_NAMES.has(part))) {
-    throw new Error("workspace_sensitive_path_forbidden");
-  }
-  return candidate;
-}
-function posixNormalize(value) {
-  const parts = value.split("/");
-  const out = [];
-  for (const part of parts) {
-    if (!part || part === ".") continue;
-    if (part === "..") {
-      if (out.length === 0) return "/__escape__";
-      out.pop();
-      continue;
-    }
-    out.push(part);
-  }
-  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));
@@ -19704,517 +19439,8 @@ var init_aster_tools = __esm({
   }
 });
 
-// src/server/aster-memory.ts
-import Database5 from "better-sqlite3";
-import { randomUUID as randomUUID7 } from "crypto";
-import { chmodSync as chmodSync3, mkdirSync as mkdirSync10 } from "fs";
-import { dirname as dirname20 } 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;
-        mkdirSync10(dirname20(dbPath), { recursive: true, mode: 448 });
-        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_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 = randomUUID7();
-        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((resolve19, reject) => {
-          this.server.once("error", reject);
-          this.server.listen(port, host, () => resolve19());
-        });
-        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 git4 = url.pathname.match(GIT_PATH_RE);
-        const api = git4 ? null : url.pathname.match(API_PATH_RE);
-        if (!git4 && !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] = git4 ?? api;
-        if (`${owner}/${name}`.toLowerCase() !== grant.repository.toLowerCase()) {
-          return deny(res, 403, `This conversation can only access ${grant.repository}`);
-        }
-        const upstream = git4 ? new URL(`/${owner}/${name}.git/${git4[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 = git4 ? "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 Database6 from "better-sqlite3";
-import { createSign } from "crypto";
-import { readFileSync as readFileSync6 } 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 Database6(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,
-            ...message2.category ? { category: message2.category } : {}
-          },
-          conversationId: message2.conversationId,
-          ...message2.approvalId ? { approvalId: message2.approvalId } : {}
-        });
-        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((resolve19, 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", () => resolve19(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 ??= readFileSync6(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 randomUUID8 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 import { unlink as unlink2 } from "fs/promises";
 import { resolve as resolve13 } from "path";
 function parseCursor(header, query) {
@@ -20223,23 +19449,8 @@ function parseCursor(header, query) {
   const cursor = Number(value);
   return Number.isSafeInteger(cursor) ? cursor : void 0;
 }
-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) {
+function publicConversation(conversation) {
   return {
-    ...project ? { kind: project.kind, repository: project.repository, branch: project.branch } : {},
     conversationId: conversation.id,
     workspaceId: conversation.workspaceId,
     model: conversation.model,
@@ -20263,25 +19474,6 @@ 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;
@@ -20313,27 +19505,23 @@ function json(res, status, data) {
   res.writeHead(status, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-store" });
   res.end(JSON.stringify(data));
 }
-var API_PREFIX, MAX_BODY_BYTES, MAX_USER_TURN_CHARS, CLIENT_TURN_ID_RE, CREATE_IDEMPOTENCY_KEY_RE, MAX_APPROVAL_ARG_BYTES, CONVERSATION_ID_RE, ALLOWED_ASTER_TOOLS, AsterApi;
+var API_PREFIX, MAX_BODY_BYTES, MAX_USER_TURN_CHARS, CLIENT_TURN_ID_RE, MAX_APPROVAL_ARG_BYTES, CONVERSATION_ID_RE, ALLOWED_ASTER_TOOLS, AsterApi;
 var init_aster_api = __esm({
   "src/server/aster-api.ts"() {
     "use strict";
+    init_system_prompt();
     init_executor();
     init_store();
+    init_worktrees();
     init_sessions();
     init_version();
     init_aster_store();
     init_aster_workspaces();
-    init_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 = 4 * 1024 * 1024;
-    MAX_USER_TURN_CHARS = 5e5;
+    MAX_BODY_BYTES = 64 * 1024;
+    MAX_USER_TURN_CHARS = 2e4;
     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;
     CONVERSATION_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
     ALLOWED_ASTER_TOOLS = ["read", "write", "edit"];
@@ -20341,62 +19529,11 @@ var init_aster_api = __esm({
       store;
       recovery;
       waiters = /* @__PURE__ */ new Map();
-      connectedEventStreams = /* @__PURE__ */ new Map();
       runtime;
       config;
-      github;
-      memory;
-      constructor(config2, runtime, github = new AsterGitHub(), memory, push) {
+      constructor(config2, runtime) {
         this.config = config2;
         this.runtime = runtime;
-        this.github = github;
-        this.memory = memory;
-        this.push = push;
-      }
-      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;
-        if ((this.connectedEventStreams.get(conversationId) ?? 0) > 0) 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"}`);
@@ -20418,7 +19555,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", "autonomous-cells", "tool-output", "checkpoints", "model-switch", "artifacts", "memory", "push", ...this.github.configured ? ["github"] : [], ...config2.modelCatalog === "openrouter" ? ["model-catalog"] : []]
+              capabilities: ["workspaces", "conversations", "turns", "event-replay", "cancellation", "human-approvals"]
             });
           }
           if (path === `${API_PREFIX}/workspaces` && method === "GET") {
@@ -20429,86 +19566,23 @@ 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");
-            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 });
+            return json(res, 200, { models: config2.models });
           }
           if (path === `${API_PREFIX}/conversations` && method === "POST") {
             if (!this.hasScope(principal, "conversations:write")) return sendError(res, 403, "insufficient_scope", "Credential lacks conversation/write scope");
             const body = await readJsonBody(req);
-            if (Object.keys(body).some((key) => !["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 (Object.keys(body).some((key) => key !== "workspaceId" && key !== "model")) {
+              return sendError(res, 400, "unsupported_field", "Conversation creation accepts only workspaceId and model; paths are server-configured");
             }
             if (typeof body.workspaceId !== "string" || !principal.workspaceIds.includes(body.workspaceId)) {
               return sendError(res, 403, "workspace_forbidden", "Workspace ID is not in this credential's scope");
             }
             const workspace = findAsterWorkspace(config2, body.workspaceId);
             if (!workspace) return sendError(res, 404, "workspace_not_found", "Workspace is not configured");
-            if (typeof body.model !== "string" || !await isSelectableModel(config2, body.model)) {
+            if (typeof body.model !== "string" || !config2.models.includes(body.model)) {
               return sendError(res, 400, "model_not_allowed", "Select a model from the configured model list");
             }
-            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");
-            }
-            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;
-            }
+            return await this.createConversation(res, store, workspace, body.model);
           }
           const eventsMatch = path.match(/^\/api\/v1\/conversations\/([^/]+)\/events$/);
           if (eventsMatch && method === "GET") {
@@ -20525,7 +19599,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" && 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");
+            if (Object.keys(body).some((key) => key !== "text" && key !== "clientTurnId")) return sendError(res, 400, "unsupported_field", "Turns accept text and an optional clientTurnId; workspace and model are fixed by the conversation");
             const hasClientTurnId = Object.hasOwn(body, "clientTurnId");
             const clientTurnId = hasClientTurnId && typeof body.clientTurnId === "string" ? body.clientTurnId : void 0;
             if (hasClientTurnId && (!clientTurnId || !CLIENT_TURN_ID_RE.test(clientTurnId))) return sendError(res, 400, "invalid_client_turn_id", "clientTurnId must be 1-128 ASCII letters, digits, '.', '_', ':', or '-' and start with a letter or digit");
@@ -20533,18 +19607,7 @@ 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");
-            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);
+            return await this.appendTurn(res, store, conversation, clientTurnId, requestText, text);
           }
           const cancelMatch = path.match(/^\/api\/v1\/conversations\/([^/]+)\/cancel$/);
           if (cancelMatch && method === "POST") {
@@ -20553,80 +19616,12 @@ var init_aster_api = __esm({
             if (!conversation) return sendError(res, 404, "conversation_not_found", "Conversation not found");
             return this.cancelConversation(res, store, conversation);
           }
-          const lifecycleMatch = path.match(/^\/api\/v1\/conversations\/([^/]+)\/(pause|resume)$/);
-          if (lifecycleMatch && 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, lifecycleMatch[1]);
-            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");
-            const conversation = await this.authorizedConversation(store, principal, conversationMatch[1]);
-            if (!conversation) return sendError(res, 404, "conversation_not_found", "Conversation not found");
-            return this.destroyConversation(res, store, conversation);
-          }
           if (conversationMatch && method === "GET") {
             if (!this.hasScope(principal, "conversations:read")) return sendError(res, 403, "insufficient_scope", "Credential lacks conversation/read scope");
             const conversation = await this.authorizedConversation(store, principal, conversationMatch[1]);
             if (!conversation) return sendError(res, 404, "conversation_not_found", "Conversation not found");
-            return json(res, 200, publicConversation(conversation, store.getConversationProject(conversation.id)));
+            return json(res, 200, publicConversation(conversation));
           }
           const approvalMatch = path.match(/^\/api\/v1\/approvals\/([^/]+)$/);
           if (approvalMatch && method === "GET") {
@@ -20634,8 +19629,7 @@ var init_aster_api = __esm({
             const approval = store.getApproval(approvalMatch[1]);
             if (!approval) return sendError(res, 404, "approval_not_found", "Approval not found");
             const conversation = store.getConversation(approval.conversationId);
-            const mapping = store.getCellMapping(approval.conversationId);
-            if (!conversation || mapping?.credentialId !== principal.credentialId || !principal.workspaceIds.includes(conversation.workspaceId)) return sendError(res, 404, "approval_not_found", "Approval not found");
+            if (!conversation || !principal.workspaceIds.includes(conversation.workspaceId)) return sendError(res, 404, "approval_not_found", "Approval not found");
             return json(res, 200, publicApproval(approval));
           }
           if (approvalMatch && method === "POST") {
@@ -20643,8 +19637,7 @@ var init_aster_api = __esm({
             const approval = store.getApproval(approvalMatch[1]);
             if (!approval) return sendError(res, 404, "approval_not_found", "Approval not found");
             const conversation = store.getConversation(approval.conversationId);
-            const mapping = store.getCellMapping(approval.conversationId);
-            if (!conversation || mapping?.credentialId !== principal.credentialId || !principal.workspaceIds.includes(conversation.workspaceId)) return sendError(res, 404, "approval_not_found", "Approval not found");
+            if (!conversation || !principal.workspaceIds.includes(conversation.workspaceId)) return sendError(res, 404, "approval_not_found", "Approval not found");
             const body = await readJsonBody(req);
             if (Object.keys(body).some((key) => key !== "decision")) return sendError(res, 400, "unsupported_field", "Approval resolution accepts decision only");
             if (body.decision !== "allow" && body.decision !== "deny") return sendError(res, 400, "invalid_approval_decision", "decision must be allow or deny");
@@ -20665,12 +19658,6 @@ 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();
@@ -20681,8 +19668,7 @@ var init_aster_api = __esm({
       async authorizedConversation(store, principal, id) {
         if (!CONVERSATION_ID_RE.test(id)) return void 0;
         const conversation = store.getConversation(id);
-        const mapping = store.getCellMapping(id);
-        if (!conversation || mapping?.credentialId !== principal.credentialId || !principal.workspaceIds.includes(conversation.workspaceId)) return void 0;
+        if (!conversation || !principal.workspaceIds.includes(conversation.workspaceId)) return void 0;
         const activeRunId = conversation.activeRunId;
         if (activeRunId) {
           const runs = new RunStore();
@@ -20722,14 +19708,6 @@ 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 {
@@ -20738,149 +19716,50 @@ var init_aster_api = __esm({
         })();
         return this.recovery;
       }
-      /** 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 = randomUUID8();
-        const candidateSessionId = randomUUID8();
-        const reservation = store.reserveCellConversation({
-          conversationId: candidateId,
-          credentialId: principal.credentialId,
-          workspaceId: workspace.id,
-          model,
-          sessionId: candidateSessionId,
-          cellName: `aster-${candidateId}`,
-          idempotencyKey
-        });
-        if (reservation.kind === "conflict") return sendError(res, 409, "idempotency_conflict", "Idempotency-Key was already used for different conversation parameters");
-        const mapping = reservation.mapping;
-        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, 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`
-            };
-          }
+      async createConversation(res, store, workspace, model) {
+        const id = randomUUID7();
+        const sessionId = randomUUID7();
+        const worktreeManager = new RunWorktreeManager();
+        let worktree;
+        try {
+          worktree = await worktreeManager.create(id, workspace.rootPath);
+        } catch {
+          sendError(res, 409, "workspace_repository_unavailable", "Configured workspace must be an accessible Git repository");
+          return;
         }
+        const tools = createAsterTools(worktree.cwd);
+        const messages = [
+          { role: "system", content: buildSystemPrompt({ cwd: worktree.cwd, tools, model, preferPullRequests: true }) },
+          { role: "system", content: "You are operating through Aster. Only read, write, and edit tools are available. All file access is confined to the selected workspace. Never request, reveal, store, or repeat provider credentials or secrets." }
+        ];
+        const sessionFile = {
+          id: sessionId,
+          cwd: worktree.cwd,
+          model,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          messages,
+          title: "Aster conversation"
+        };
         try {
-          const allowCreate = !mapping.createAttempted;
-          if (allowCreate) store.markCellCreateAttempted(mapping.conversationId);
-          const provisioned = await this.runtime.provisionConversation({
-            conversationId: mapping.conversationId,
-            sessionId: mapping.sessionId,
-            cellName: mapping.cellName,
-            workspaceId: workspace.id,
-            workspaceRoot: workspace.rootPath,
-            model,
-            allowCreate,
-            onCellCreated: (cellId) => store.setCellId(mapping.conversationId, cellId),
-            ...project ? { project } : {}
-          });
-          store.setCellId(mapping.conversationId, provisioned.cellId);
-          const conversation = store.getConversation(mapping.conversationId) ?? store.createConversation({
-            id: mapping.conversationId,
+          await saveSession(sessionFile);
+          const conversation = store.createConversation({
+            id,
             workspaceId: workspace.id,
             model,
-            sessionId: mapping.sessionId,
-            worktreePath: "/workspace",
-            cwd: "/workspace",
-            branch: "cell"
+            sessionId,
+            worktreePath: worktree.worktreePath,
+            cwd: worktree.cwd,
+            branch: worktree.branch
           });
-          const sessionFile = {
-            id: mapping.sessionId,
-            cwd: "/workspace",
-            model,
-            createdAt: new Date(mapping.createdAt).toISOString(),
-            updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-            messages: [],
-            title: "Aster conversation"
-          };
-          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, store.getConversationProject(conversation.id)));
+          store.appendEvent(id, null, "conversation.created", { conversationId: id, workspaceId: workspace.id, model });
+          json(res, 201, publicConversation(conversation));
         } catch {
-          const current = store.getCellMapping(mapping.conversationId);
-          if (current?.cellId && this.runtime.destroyCell) {
-            try {
-              await this.runtime.destroyCell(current.cellId);
-              store.setCellStatus(mapping.conversationId, "failed");
-            } catch {
-              store.setCellStatus(mapping.conversationId, "cleanup_pending");
-            }
-          } else {
-            store.setCellStatus(mapping.conversationId, "failed");
-          }
-          sendError(res, 503, "conversation_provisioning_failed", "Conversation provisioning failed; retry with the same Idempotency-Key to reconcile its state");
+          await unlink2(resolve13(sessionsDir(), `${sessionId}.json`)).catch(() => {
+          });
+          await worktreeManager.discard(worktree).catch(() => {
+          });
+          sendError(res, 500, "conversation_create_failed", "Conversation could not be created");
         }
       }
       async appendTurn(res, store, conversation, clientTurnId, requestText, text) {
@@ -20896,16 +19775,7 @@ var init_aster_api = __esm({
             return;
           }
         }
-        const cellMapping = store.getCellMapping(conversation.id);
-        if (cellMapping?.status === "paused") {
-          sendError(res, 409, "conversation_paused", "Conversation is paused; resume it before submitting a turn");
-          return;
-        }
-        if (!cellMapping?.cellId || ["provisioning", "destroying", "cleanup_pending", "destroyed", "failed"].includes(cellMapping.status)) {
-          sendError(res, 409, "conversation_cell_unavailable", "Conversation cell is not available");
-          return;
-        }
-        const runId = randomUUID8();
+        const runId = randomUUID7();
         if (!idempotent && !store.beginTurn(conversation.id, runId)) {
           sendError(res, 409, "conversation_busy", "A turn is already active for this conversation");
           return;
@@ -20982,13 +19852,9 @@ 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,
-            cellId: cellMapping.cellId,
-            cellEventCursor: cellMapping.eventCursor,
-            userText: text,
             sessionFile,
             messages: sessionFile.messages,
             executor,
@@ -20997,24 +19863,11 @@ var init_aster_api = __esm({
             maxRuntimeMs: run.maxRuntimeMs,
             askPermission: (request) => this.askForApproval(store, conversation, runId, request, publishEvent),
             publishEvent,
-            onCellCursor: (cursor) => store.advanceCellEventCursor(conversation.id, cursor),
             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 {
@@ -21044,8 +19897,9 @@ var init_aster_api = __esm({
           publish("tool.activity", { tool: request.tool.name, activity: "rejected", reason: "unsafe_payload" });
           return "deny";
         }
+        const workspaceRoot = conversation.cwd;
         try {
-          assertAsterCellPath(request.args.path);
+          await assertAsterWorkspacePath(workspaceRoot, request.args.path, request.tool.name === "write");
         } catch {
           publish("tool.activity", { tool: request.tool.name, activity: "rejected", reason: "workspace_path_forbidden" });
           return "deny";
@@ -21070,16 +19924,6 @@ var init_aster_api = __esm({
         }
         store.updateConversationStatus(conversation.id, runId, "waiting_approval", { approvalId: approval.id });
         publish("approval.required", { approvalId: approval.id, tool: approval.toolName, explanation: approval.explanation, expiresAt: approval.expiresAt });
-        const push = this.getPush();
-        if (push?.configured) {
-          void push.notify({
-            title: "Approval required",
-            body: approval.toolName + ": " + approval.explanation,
-            conversationId: conversation.id,
-            category: "APPROVAL",
-            approvalId: approval.id
-          });
-        }
         return new Promise((resolveDecision) => {
           const timer3 = setTimeout(() => {
             void this.expireApproval(store, approval.id);
@@ -21136,115 +19980,6 @@ var init_aster_api = __esm({
           waiter.resolve(status === "expired" ? "deny" : decision);
         }
       }
-      async pauseConversation(res, store, conversation) {
-        const mapping = store.getCellMapping(conversation.id);
-        if (!mapping || !mapping.cellId) return sendError(res, 409, "cell_not_ready", "Conversation cell is not ready");
-        if (mapping.status === "paused") return json(res, 200, { ...publicConversation(conversation), cellStatus: "paused" });
-        if (conversation.activeRunId) return sendError(res, 409, "turn_active", "Pause is only available at a safe boundary; cancel or wait for the active turn first");
-        if (!this.runtime.pauseCell) return sendError(res, 503, "hotcell_pause_unavailable", "Hotcell pause is not configured");
-        try {
-          await this.runtime.pauseCell(mapping.cellId);
-          store.setCellStatus(conversation.id, "paused");
-          store.setConversationStatus(conversation.id, "paused", { reason: "safe_boundary" });
-          store.appendEvent(conversation.id, null, "conversation.paused", { strategy: "safe_boundary" });
-          const updated = store.getConversation(conversation.id);
-          json(res, 200, { ...publicConversation(updated), cellStatus: "paused" });
-        } catch {
-          sendError(res, 503, "pause_failed", "Conversation could not be paused; its lifecycle state was not changed");
-        }
-      }
-      async resumeConversation(res, store, conversation) {
-        const mapping = store.getCellMapping(conversation.id);
-        if (!mapping || !mapping.cellId) return sendError(res, 409, "cell_not_ready", "Conversation cell is not ready");
-        if (mapping.status !== "paused") return json(res, 200, { ...publicConversation(conversation), cellStatus: mapping.status });
-        if (!this.runtime.resumeCell) return sendError(res, 503, "hotcell_resume_unavailable", "Hotcell resume is not configured");
-        try {
-          await this.runtime.resumeCell(mapping.cellId);
-          store.setCellStatus(conversation.id, "ready");
-          store.setConversationStatus(conversation.id, "ready", { reason: "resumed" });
-          store.appendEvent(conversation.id, null, "conversation.resumed", { sessionId: mapping.sessionId });
-          const updated = store.getConversation(conversation.id);
-          json(res, 200, { ...publicConversation(updated), cellStatus: "ready" });
-        } catch {
-          sendError(res, 503, "resume_failed", "Conversation could not be resumed; the persisted cell state is unchanged");
-        }
-      }
-      async destroyConversation(res, store, conversation) {
-        const mapping = store.getCellMapping(conversation.id);
-        if (!mapping) return sendError(res, 404, "conversation_not_found", "Conversation not found");
-        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);
-            if (waiter) {
-              clearTimeout(waiter.timer);
-              this.waiters.delete(approval.id);
-              waiter.resolve("deny");
-            }
-          }
-          this.runtime.cancelRun(conversation.activeRunId);
-          store.updateConversationStatus(conversation.id, conversation.activeRunId, "cancelled", { reason: "conversation_destroyed" });
-        }
-        try {
-          if (mapping.cellId) await this.runtime.destroyCell(mapping.cellId);
-          await unlink2(resolve13(sessionsDir(), mapping.sessionId + ".json")).catch(() => {
-          });
-          store.setCellStatus(conversation.id, "destroyed");
-          store.setConversationStatus(conversation.id, "destroyed");
-          store.appendEvent(conversation.id, null, "conversation.destroyed", { conversationId: conversation.id });
-          json(res, 200, { conversationId: conversation.id, status: "destroyed" });
-        } catch {
-          store.setCellStatus(conversation.id, "cleanup_pending");
-          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 = resolve13(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) {
@@ -21287,16 +20022,6 @@ var init_aster_api = __esm({
         let last = cursor;
         let closed = false;
         let polling = false;
-        let released = false;
-        const connected = this.connectedEventStreams.get(conversationId) ?? 0;
-        this.connectedEventStreams.set(conversationId, connected + 1);
-        const release2 = () => {
-          if (released) return;
-          released = true;
-          const remaining = (this.connectedEventStreams.get(conversationId) ?? 1) - 1;
-          if (remaining > 0) this.connectedEventStreams.set(conversationId, remaining);
-          else this.connectedEventStreams.delete(conversationId);
-        };
         let lastHeartbeat = Date.now();
         const pump = async () => {
           if (closed || polling) return;
@@ -21318,7 +20043,6 @@ data: ${JSON.stringify(event.data)}
             }
           } catch {
             closed = true;
-            release2();
             res.end();
           } finally {
             polling = false;
@@ -21329,9 +20053,7 @@ data: ${JSON.stringify(event.data)}
         };
         res.on("close", () => {
           closed = true;
-          release2();
         });
-        res.on("finish", release2);
         void pump();
       }
       async recover(store) {
@@ -21368,8 +20090,7 @@ data: ${JSON.stringify(event.data)}
       async requireConversation(store, principal, id) {
         if (!CONVERSATION_ID_RE.test(id)) return void 0;
         const conversation = store.getConversation(id);
-        const mapping = store.getCellMapping(id);
-        return conversation && mapping?.credentialId === principal.credentialId && principal.workspaceIds.includes(conversation.workspaceId) ? conversation : void 0;
+        return conversation && principal.workspaceIds.includes(conversation.workspaceId) ? conversation : void 0;
       }
     };
   }
@@ -21379,7 +20100,7 @@ data: ${JSON.stringify(event.data)}
 import { execFile as execFile8 } from "child_process";
 import { readFile as readFile26 } from "fs/promises";
 import { promisify as promisify7 } from "util";
-import { randomUUID as randomUUID9 } 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" });
@@ -21575,7 +20296,7 @@ var init_aster_cell_runtime = __esm({
         await this.installRuntime(cell);
         await this.ensureBridge(cell);
         await this.control(cell, "POST", "/rpc", {
-          id: randomUUID9(),
+          id: randomUUID8(),
           type: "new_session",
           sessionId: input.sessionId,
           config: { model: input.model, cwd: CELL_WORKSPACE }
@@ -21594,7 +20315,7 @@ var init_aster_cell_runtime = __esm({
       /** 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: randomUUID9(), type: "set_model", modelId: model });
+        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) {
@@ -21657,7 +20378,7 @@ var init_aster_cell_runtime = __esm({
         const active = this.activeRuns.get(runId);
         if (!active) return;
         active.stop();
-        void this.controlById(active.cellId, "POST", "/rpc", { id: randomUUID9(), type: "abort" }).catch(() => {
+        void this.controlById(active.cellId, "POST", "/rpc", { id: randomUUID8(), type: "abort" }).catch(() => {
         });
       }
       async runTurn(turn, options = {}) {
@@ -21757,7 +20478,7 @@ ${turn.userText}` : turn.userText;
                   args: event.args ?? {}
                 });
                 await this.controlById(cellId, "POST", "/rpc", {
-                  id: randomUUID9(),
+                  id: randomUUID8(),
                   type: "resolve_permission",
                   requestId: event.requestId,
                   decision
@@ -21984,7 +20705,7 @@ ${text}` : text, { mode: "0600" });
         }
       }
       async control(cell, method, path, body) {
-        const requestId = randomUUID9();
+        const requestId = randomUUID8();
         await cell.mkdir(CELL_CONTROL_DIR, { parents: true });
         await writeCellFileChunked(cell, `${CELL_CONTROL_DIR}/${requestId}.json`, JSON.stringify({ method, path, body }));
         const result2 = await cell.exec(`${CONTROL_RUNNER} ${requestId}`);
@@ -22200,7 +20921,7 @@ var init_hotcell_provider = __esm({
 });
 
 // src/server/routes.ts
-import { randomUUID as randomUUID10 } from "crypto";
+import { randomUUID as randomUUID9 } from "crypto";
 import { URL as URL2 } from "url";
 import { readFile as readFile27, unlink as unlink3 } from "fs/promises";
 import { resolve as resolve14, basename as basename7 } from "path";
@@ -22544,7 +21265,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 = randomUUID10();
+        const runId = randomUUID9();
         const worktreeManager = new RunWorktreeManager();
         let worktree;
         if (useWorktree) {
@@ -23153,10 +21874,10 @@ var server_exports = {};
 __export(server_exports, {
   startServer: () => startServer
 });
-import { createServer as createServer2 } from "http";
+import { createServer } from "http";
 async function startServer(opts2) {
   const { handleRequest, cleanup } = setupRoutes(opts2.config, { asterRuntime: opts2.asterRuntime });
-  const server = createServer2((req, res) => {
+  const server = createServer((req, res) => {
     const isAsterApi = req.url?.startsWith("/api/v1/") === true;
     if (!isAsterApi) {
       res.setHeader("Access-Control-Allow-Origin", "*");
@@ -24642,7 +23363,7 @@ __export(app_helpers_exports, {
   trackRecentFile: () => trackRecentFile
 });
 import { execSync as execSync3, spawn as spawn7 } from "child_process";
-import { existsSync as existsSync8, readFileSync as readFileSync7, statSync as statSync5 } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync6, statSync as statSync5 } from "fs";
 import { join as join41 } from "path";
 import { platform as platform3 } from "os";
 function replaceQueuedPrompt(queue2, key, full, display) {
@@ -24756,7 +23477,7 @@ function buildFilePickerIgnoreList(cwd) {
     if (stats.size > MAX_GITIGNORE_SIZE) {
       return hardcoded;
     }
-    const content = readFileSync7(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;
@@ -34315,7 +33036,7 @@ __export(openrouter_oauth_exports, {
   startLoopbackListener: () => startLoopbackListener
 });
 import { createHash as createHash6, randomBytes as randomBytes3 } from "crypto";
-import { createServer as createServer3 } from "http";
+import { createServer as createServer2 } from "http";
 import { hostname } from "os";
 function createPkce() {
   const verifier = randomBytes3(32).toString("base64url");
@@ -34371,7 +33092,7 @@ async function startLoopbackListener(opts2 = {}) {
   });
   code.catch(() => void 0);
   let settled = false;
-  const server = createServer3((req, res) => {
+  const server = createServer2((req, res) => {
     const url = new URL(req.url ?? "/", "http://127.0.0.1");
     if (url.pathname !== "/callback") {
       res.writeHead(404).end();
@@ -39775,7 +38496,7 @@ var init_run_compact = __esm({
 
 // src/commands/save.ts
 import { mkdir as mkdir18, writeFile as writeFile16, unlink as unlink5 } from "fs/promises";
-import { dirname as dirname22 } from "path";
+import { dirname as dirname21 } from "path";
 async function saveCustomCommand(opts2) {
   const dir = opts2.source === "project" ? projectCommandsDir(opts2.cwd) : globalCommandsDir();
   const filepath = `${dir}/${opts2.name}.md`;
@@ -39786,7 +38507,7 @@ async function saveCustomCommand(opts2) {
   if (opts2.effort) data.effort = opts2.effort;
   const frontmatter = serializeFrontmatter(data);
   const content = frontmatter + opts2.template;
-  await mkdir18(dirname22(filepath), { recursive: true });
+  await mkdir18(dirname21(filepath), { recursive: true });
   await writeFile16(filepath, content, "utf8");
   return { filepath };
 }
@@ -41999,21 +40720,6 @@ ${result2.output ?? "(output not captured)"}`,
     [processMessage, handleSlash, queue2, history, historyIndex, events]
   );
   submitRef.current = submit;
-  useEffect11(() => {
-    if (!bridge) return;
-    const seen = announcedSubagentsRef.current;
-    const fresh = runningSubagents.filter((w) => !seen.has(w.id));
-    if (fresh.length === 0) return;
-    for (const w of fresh) seen.add(w.id);
-    setEvents((evts) => [
-      ...evts,
-      ...fresh.map((w) => ({
-        kind: "info",
-        key: mkKey(),
-        text: `subagent #${w.index} started: ${w.task.replace(/\s+/g, " ").slice(0, 100)} \xB7 /agents to view or stop`
-      }))
-    ]);
-  }, [bridge, runningSubagents]);
   const textOf = (m) => !m ? "" : typeof m.content === "string" ? m.content : Array.isArray(m.content) ? m.content.filter((p) => p.type === "text").map((p) => p.text).join(" ") : "";
   const describeActivity = () => {
     const msgs = messagesRef.current;