heyio 4.2.5 → 4.3.0

package/dist/daemon/index.js

@@ -79,10 +79,10 @@ var init_constants = __esm({
   "packages/shared/dist/constants.js"() {
     "use strict";
     APP_NAME = "io";
-    APP_VERSION = "4.2.5";
+    APP_VERSION = "4.3.0";
     API_PORT = 7777;
     API_HOST = "0.0.0.0";
-    DEFAULT_MODEL = "gpt-4o";
+    DEFAULT_MODEL = "gpt-4.1-mini";
     SESSION_RESET_THRESHOLD = 50;
     SCHEDULER_INTERVAL_MS = 6e4;
     QA_MAX_REVISIONS = 3;
@@ -152,6 +152,349 @@ var init_paths = __esm({
   }
 });
 
+// packages/daemon/src/store/db.ts
+import { mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
+import { pathToFileURL } from "node:url";
+import { createClient } from "@libsql/client";
+function asString(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value === null || value === void 0) {
+    throw new Error("Expected string value but received null or undefined");
+  }
+  return String(value);
+}
+function asNullableString(value) {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  return typeof value === "string" ? value : String(value);
+}
+function asNumber(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  if (typeof value === "bigint") {
+    return Number(value);
+  }
+  if (typeof value === "string") {
+    return Number(value);
+  }
+  throw new Error(`Expected numeric value but received ${typeof value}`);
+}
+function asNullableNumber(value) {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  return asNumber(value);
+}
+function asBoolean(value) {
+  return asNumber(value) === 1;
+}
+function toSqliteBoolean(value) {
+  return value ? 1 : 0;
+}
+function parseJson(value) {
+  if (typeof value !== "string") {
+    return value;
+  }
+  return JSON.parse(value);
+}
+function serializeJson(value) {
+  return JSON.stringify(value);
+}
+async function initDatabase() {
+  if (client && !client.closed) {
+    return client;
+  }
+  if (initPromise) {
+    return initPromise;
+  }
+  initPromise = initializeDatabase(defaultConnectionOptions);
+  try {
+    client = await initPromise;
+    return client;
+  } finally {
+    initPromise = null;
+  }
+}
+async function getDatabase() {
+  return initDatabase();
+}
+async function initializeDatabase(options2 = {}) {
+  const url2 = await resolveDatabaseUrl(options2);
+  const databaseClient = createClient({ url: url2 });
+  await databaseClient.execute("PRAGMA foreign_keys = ON");
+  await databaseClient.execute("PRAGMA journal_mode = WAL");
+  await ensureMigrationTable(databaseClient);
+  await applyMigrations(databaseClient);
+  return databaseClient;
+}
+async function resolveDatabaseUrl(options2) {
+  if (options2.url) {
+    return options2.url;
+  }
+  const databasePath = options2.path ?? DB_PATH;
+  await mkdir(dirname(databasePath), { recursive: true });
+  return pathToFileURL(databasePath).href;
+}
+async function ensureMigrationTable(databaseClient) {
+  await databaseClient.executeMultiple(`
+		CREATE TABLE IF NOT EXISTS schema_migrations (
+			version INTEGER PRIMARY KEY,
+			name TEXT NOT NULL,
+			applied_at TEXT NOT NULL
+		);
+	`);
+}
+async function applyMigrations(databaseClient) {
+  const appliedVersions = await getAppliedVersions(databaseClient);
+  for (const migration of MIGRATIONS) {
+    if (appliedVersions.has(migration.version)) {
+      continue;
+    }
+    const transaction = await databaseClient.transaction("write");
+    try {
+      for (const statement of migration.statements) {
+        await transaction.execute(statement);
+      }
+      await transaction.execute({
+        sql: "INSERT INTO schema_migrations (version, name, applied_at) VALUES (?, ?, ?)",
+        args: [migration.version, migration.name, nowIso()]
+      });
+      await transaction.commit();
+    } catch (error51) {
+      if (!transaction.closed) {
+        await transaction.rollback();
+      }
+      throw error51;
+    } finally {
+      if (!transaction.closed) {
+        transaction.close();
+      }
+    }
+  }
+}
+async function getAppliedVersions(databaseClient) {
+  const result = await databaseClient.execute(
+    "SELECT version FROM schema_migrations ORDER BY version ASC"
+  );
+  return new Set(result.rows.map((row) => asNumber(row.version)));
+}
+var MIGRATIONS, client, initPromise, defaultConnectionOptions, generateId, nowIso;
+var init_db = __esm({
+  "packages/daemon/src/store/db.ts"() {
+    "use strict";
+    init_paths();
+    MIGRATIONS = [
+      {
+        version: 1,
+        name: "create-store-schema",
+        statements: [
+          `CREATE TABLE IF NOT EXISTS squads (
+				id TEXT PRIMARY KEY,
+				name TEXT NOT NULL,
+				repo_url TEXT NOT NULL,
+				repo_owner TEXT NOT NULL,
+				repo_name TEXT NOT NULL,
+				status TEXT NOT NULL,
+				config TEXT NOT NULL,
+				created_at TEXT NOT NULL,
+				updated_at TEXT NOT NULL,
+				UNIQUE (repo_owner, repo_name)
+			)`,
+          `CREATE TABLE IF NOT EXISTS squad_members (
+				id TEXT PRIMARY KEY,
+				squad_id TEXT NOT NULL REFERENCES squads(id) ON DELETE CASCADE,
+				role TEXT NOT NULL,
+				name TEXT NOT NULL,
+				system_prompt TEXT NOT NULL,
+				model TEXT,
+				created_at TEXT NOT NULL
+			)`,
+          `CREATE TABLE IF NOT EXISTS objectives (
+				id TEXT PRIMARY KEY,
+				squad_id TEXT NOT NULL REFERENCES squads(id) ON DELETE CASCADE,
+				description TEXT NOT NULL,
+				status TEXT NOT NULL,
+				plan TEXT,
+				revision_count INTEGER NOT NULL DEFAULT 0,
+				branch TEXT,
+				pr_url TEXT,
+				created_at TEXT NOT NULL,
+				updated_at TEXT NOT NULL
+			)`,
+          `CREATE TABLE IF NOT EXISTS tasks (
+				id TEXT PRIMARY KEY,
+				objective_id TEXT NOT NULL REFERENCES objectives(id) ON DELETE CASCADE,
+				assignee_id TEXT REFERENCES squad_members(id) ON DELETE SET NULL,
+				title TEXT NOT NULL,
+				description TEXT NOT NULL,
+				status TEXT NOT NULL,
+				result TEXT,
+				created_at TEXT NOT NULL,
+				updated_at TEXT NOT NULL
+			)`,
+          `CREATE TABLE IF NOT EXISTS conversations (
+				id TEXT PRIMARY KEY,
+				title TEXT,
+				source TEXT NOT NULL,
+				created_at TEXT NOT NULL,
+				updated_at TEXT NOT NULL
+			)`,
+          `CREATE TABLE IF NOT EXISTS messages (
+				id TEXT PRIMARY KEY,
+				conversation_id TEXT NOT NULL REFERENCES conversations(id) ON DELETE CASCADE,
+				role TEXT NOT NULL,
+				content TEXT NOT NULL,
+				model TEXT,
+				input_tokens INTEGER,
+				output_tokens INTEGER,
+				created_at TEXT NOT NULL
+			)`,
+          `CREATE TABLE IF NOT EXISTS inbox (
+				id TEXT PRIMARY KEY,
+				squad_id TEXT REFERENCES squads(id) ON DELETE SET NULL,
+				objective_id TEXT REFERENCES objectives(id) ON DELETE SET NULL,
+				type TEXT NOT NULL,
+				title TEXT NOT NULL,
+				content TEXT NOT NULL,
+				status TEXT NOT NULL,
+				reply TEXT,
+				created_at TEXT NOT NULL,
+				updated_at TEXT NOT NULL
+			)`,
+          `CREATE TABLE IF NOT EXISTS schedules (
+				id TEXT PRIMARY KEY,
+				name TEXT NOT NULL,
+				cron_expression TEXT NOT NULL,
+				prompt TEXT NOT NULL,
+				enabled INTEGER NOT NULL DEFAULT 1,
+				last_run_at TEXT,
+				next_run_at TEXT,
+				created_at TEXT NOT NULL,
+				updated_at TEXT NOT NULL
+			)`,
+          `CREATE TABLE IF NOT EXISTS token_usage (
+				id TEXT PRIMARY KEY,
+				squad_id TEXT REFERENCES squads(id) ON DELETE SET NULL,
+				agent_id TEXT,
+				model TEXT NOT NULL,
+				input_tokens INTEGER NOT NULL,
+				output_tokens INTEGER NOT NULL,
+				cost REAL NOT NULL,
+				created_at TEXT NOT NULL
+			)`,
+          `CREATE TABLE IF NOT EXISTS activity (
+				id TEXT PRIMARY KEY,
+				squad_id TEXT REFERENCES squads(id) ON DELETE SET NULL,
+				objective_id TEXT REFERENCES objectives(id) ON DELETE SET NULL,
+				event TEXT NOT NULL,
+				description TEXT NOT NULL,
+				metadata TEXT,
+				created_at TEXT NOT NULL
+			)`,
+          `CREATE TABLE IF NOT EXISTS agent_history (
+				id TEXT PRIMARY KEY,
+				agent_id TEXT NOT NULL,
+				squad_id TEXT REFERENCES squads(id) ON DELETE SET NULL,
+				content TEXT NOT NULL,
+				created_at TEXT NOT NULL
+			)`,
+          `CREATE TABLE IF NOT EXISTS settings (
+				key TEXT PRIMARY KEY,
+				value TEXT
+			)`,
+          "CREATE INDEX IF NOT EXISTS idx_squad_members_squad_id ON squad_members(squad_id)",
+          "CREATE INDEX IF NOT EXISTS idx_objectives_squad_id ON objectives(squad_id)",
+          "CREATE INDEX IF NOT EXISTS idx_objectives_status ON objectives(status)",
+          "CREATE INDEX IF NOT EXISTS idx_tasks_objective_id ON tasks(objective_id)",
+          "CREATE INDEX IF NOT EXISTS idx_tasks_assignee_id ON tasks(assignee_id)",
+          "CREATE INDEX IF NOT EXISTS idx_messages_conversation_id_created_at ON messages(conversation_id, created_at)",
+          "CREATE INDEX IF NOT EXISTS idx_inbox_status_created_at ON inbox(status, created_at)",
+          "CREATE INDEX IF NOT EXISTS idx_inbox_squad_id ON inbox(squad_id)",
+          "CREATE INDEX IF NOT EXISTS idx_inbox_objective_id ON inbox(objective_id)",
+          "CREATE INDEX IF NOT EXISTS idx_schedules_enabled_next_run_at ON schedules(enabled, next_run_at)",
+          "CREATE INDEX IF NOT EXISTS idx_token_usage_created_at ON token_usage(created_at)",
+          "CREATE INDEX IF NOT EXISTS idx_token_usage_squad_id ON token_usage(squad_id)",
+          "CREATE INDEX IF NOT EXISTS idx_token_usage_agent_id ON token_usage(agent_id)",
+          "CREATE INDEX IF NOT EXISTS idx_token_usage_model ON token_usage(model)",
+          "CREATE INDEX IF NOT EXISTS idx_activity_created_at ON activity(created_at)",
+          "CREATE INDEX IF NOT EXISTS idx_activity_squad_id ON activity(squad_id)",
+          "CREATE INDEX IF NOT EXISTS idx_activity_objective_id ON activity(objective_id)",
+          "CREATE INDEX IF NOT EXISTS idx_agent_history_agent_id_created_at ON agent_history(agent_id, created_at)"
+        ]
+      },
+      {
+        version: 2,
+        name: "add-model-pricing-and-dual-costs",
+        statements: [
+          `CREATE TABLE IF NOT EXISTS model_pricing (
+				id TEXT PRIMARY KEY,
+				display_name TEXT NOT NULL,
+				premium_multiplier REAL,
+				token_input_multiplier REAL,
+				token_output_multiplier REAL,
+				cached_input_multiplier REAL,
+				tier TEXT NOT NULL,
+				available INTEGER NOT NULL DEFAULT 1,
+				updated_at TEXT NOT NULL
+			)`,
+          "CREATE INDEX IF NOT EXISTS idx_model_pricing_tier ON model_pricing(tier)",
+          "CREATE INDEX IF NOT EXISTS idx_model_pricing_available ON model_pricing(available)",
+          "ALTER TABLE token_usage ADD COLUMN premium_request_cost REAL",
+          "ALTER TABLE token_usage ADD COLUMN token_unit_cost REAL"
+        ]
+      },
+      {
+        version: 3,
+        name: "add-squad-instances",
+        statements: [
+          `CREATE TABLE IF NOT EXISTS squad_instances (
+				id TEXT PRIMARY KEY,
+				squad_id TEXT NOT NULL REFERENCES squads(id) ON DELETE CASCADE,
+				objective_id TEXT REFERENCES objectives(id) ON DELETE SET NULL,
+				status TEXT NOT NULL DEFAULT 'queued',
+				branch TEXT,
+				worktree_path TEXT,
+				created_at TEXT NOT NULL,
+				started_at TEXT,
+				completed_at TEXT,
+				error TEXT
+			)`,
+          "CREATE INDEX IF NOT EXISTS idx_squad_instances_squad_status ON squad_instances(squad_id, status)",
+          "CREATE INDEX IF NOT EXISTS idx_squad_instances_status ON squad_instances(status)",
+          "CREATE INDEX IF NOT EXISTS idx_squad_instances_objective_id ON squad_instances(objective_id)"
+        ]
+      },
+      {
+        version: 4,
+        name: "denormalize-usage-names",
+        statements: [
+          "ALTER TABLE token_usage ADD COLUMN squad_name TEXT",
+          "ALTER TABLE token_usage ADD COLUMN agent_name TEXT",
+          `UPDATE token_usage SET
+				squad_name = (SELECT s.name FROM squads s WHERE s.id = token_usage.squad_id),
+				agent_name = (SELECT sm.name FROM squad_members sm WHERE sm.id = token_usage.agent_id)
+			WHERE squad_id IS NOT NULL OR agent_id IS NOT NULL`
+        ]
+      },
+      {
+        version: 5,
+        name: "add-squad-soft-delete",
+        statements: ["ALTER TABLE squads ADD COLUMN deleted_at TEXT"]
+      }
+    ];
+    client = null;
+    initPromise = null;
+    defaultConnectionOptions = {};
+    generateId = () => crypto.randomUUID();
+    nowIso = () => (/* @__PURE__ */ new Date()).toISOString();
+  }
+});
+
 // node_modules/cron-parser/dist/fields/types.js
 var require_types = __commonJS({
   "node_modules/cron-parser/dist/fields/types.js"(exports2) {
@@ -62206,6 +62549,493 @@ var require_websocket_server = __commonJS({
   }
 });
 
+// packages/daemon/src/models/catalog.ts
+import { execFileSync } from "node:child_process";
+function resolveGitHubToken() {
+  const envToken = process.env.GITHUB_TOKEN?.trim();
+  if (envToken && envToken.length > 0) {
+    return envToken;
+  }
+  try {
+    const token = execFileSync("gh", ["auth", "token"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"]
+    }).trim();
+    return token.length > 0 ? token : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function fetchModelCatalog() {
+  const token = resolveGitHubToken();
+  if (!token) {
+    throw new Error("No GitHub token available for model catalog fetch");
+  }
+  const response = await fetch(CATALOG_URL, {
+    headers: {
+      Accept: "application/json",
+      Authorization: `Bearer ${token}`,
+      "X-GitHub-Api-Version": "2024-12-01"
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`Model catalog fetch failed: ${response.status} ${response.statusText}`);
+  }
+  const data = await response.json();
+  if (!Array.isArray(data)) {
+    throw new Error("Model catalog response is not an array");
+  }
+  const models = [];
+  for (const entry of data) {
+    const id = entry.id ?? entry.name;
+    const displayName = entry.friendly_name ?? entry.name ?? id;
+    if (id && typeof id === "string") {
+      models.push({ id, displayName: displayName ?? id });
+    }
+  }
+  return models;
+}
+var CATALOG_URL;
+var init_catalog = __esm({
+  "packages/daemon/src/models/catalog.ts"() {
+    "use strict";
+    CATALOG_URL = "https://models.github.ai/catalog/models";
+  }
+});
+
+// packages/daemon/src/models/pricing-scraper.ts
+async function scrapeTokenUnitPricing() {
+  const html = await fetchPage(TOKEN_UNIT_COSTS_URL);
+  return parseTokenUnitTable(html);
+}
+async function scrapeCopilotPricing() {
+  const markdown = await fetchMarkdown(COPILOT_PRICING_URL);
+  return parseCopilotPricingMarkdown(markdown);
+}
+async function scrapePremiumRequestPricing() {
+  const html = await fetchPage(PREMIUM_MULTIPLIERS_URL);
+  return parsePremiumMultiplierTable(html);
+}
+async function fetchPage(url2) {
+  const response = await fetch(url2, {
+    headers: {
+      Accept: "text/html",
+      "User-Agent": "IO-Daemon/4.0 (pricing-refresh)"
+    },
+    redirect: "follow"
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to fetch ${url2}: ${response.status} ${response.statusText}`);
+  }
+  return response.text();
+}
+async function fetchMarkdown(url2) {
+  const response = await fetch(url2, {
+    headers: {
+      Accept: "text/markdown, text/plain, */*",
+      "User-Agent": "IO-Daemon/4.0 (pricing-refresh)"
+    },
+    redirect: "follow"
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to fetch ${url2}: ${response.status} ${response.statusText}`);
+  }
+  return response.text();
+}
+function parseTokenUnitTable(html) {
+  const results = [];
+  const tableRowPattern = /<tr[^>]*>\s*<td[^>]*>([^<]+)<\/td>\s*<td[^>]*>([^<]+)<\/td>\s*<td[^>]*>([^<]*)<\/td>\s*<td[^>]*>([^<]+)<\/td>/gi;
+  for (const match of html.matchAll(tableRowPattern)) {
+    const modelName = cleanCellText(match[1]);
+    const inputMultiplier = Number.parseFloat(match[2]);
+    const cachedInput = match[3].trim().toLowerCase();
+    const outputMultiplier = Number.parseFloat(match[4]);
+    if (modelName && !Number.isNaN(inputMultiplier) && !Number.isNaN(outputMultiplier)) {
+      results.push({
+        modelName,
+        inputMultiplier,
+        cachedInputMultiplier: cachedInput === "n/a" || cachedInput === "" ? null : Number.parseFloat(cachedInput) || null,
+        outputMultiplier
+      });
+    }
+  }
+  return results;
+}
+function parsePremiumMultiplierTable(html) {
+  const results = [];
+  const tableRowPattern = /<tr[^>]*>\s*<td[^>]*>([^<]+)<\/td>\s*<td[^>]*>([^<]+)<\/td>\s*<\/tr>/gi;
+  for (const match of html.matchAll(tableRowPattern)) {
+    const modelName = cleanCellText(match[1]);
+    const multiplier = Number.parseFloat(match[2]);
+    if (modelName && !Number.isNaN(multiplier) && multiplier > 0) {
+      results.push({ modelName, multiplier });
+    }
+  }
+  return results;
+}
+function cleanCellText(text) {
+  return text.replace(/<[^>]*>/g, "").replace(/&[^;]+;/g, " ").trim();
+}
+function parseCopilotPricingMarkdown(markdown) {
+  const results = [];
+  const seenModels = /* @__PURE__ */ new Set();
+  const lines = markdown.split("\n");
+  let columnIndices = null;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("|")) continue;
+    if (/\|\s*Model\s/i.test(trimmed)) {
+      columnIndices = parseHeaderColumns(trimmed);
+      continue;
+    }
+    if (/^[\s|:-]+$/.test(trimmed) || !columnIndices) continue;
+    const entry = parseDataRow(trimmed, columnIndices);
+    if (entry && !seenModels.has(entry.modelName.toLowerCase())) {
+      seenModels.add(entry.modelName.toLowerCase());
+      results.push(entry);
+    }
+  }
+  return results;
+}
+function parseDataRow(line, columnIndices) {
+  const cells = splitMarkdownRow(line);
+  if (cells.length <= columnIndices.output) return null;
+  const modelName = cells[columnIndices.model].trim();
+  const inputPrice = parseDollarValue(cells[columnIndices.input]);
+  const cachedPrice = columnIndices.cached >= 0 ? parseDollarValue(cells[columnIndices.cached]) : null;
+  const outputPrice = parseDollarValue(cells[columnIndices.output]);
+  if (!modelName || inputPrice === null || outputPrice === null) return null;
+  return {
+    modelName,
+    inputMultiplier: inputPrice * PRICE_TO_MULTIPLIER,
+    cachedInputMultiplier: cachedPrice !== null ? cachedPrice * PRICE_TO_MULTIPLIER : null,
+    outputMultiplier: outputPrice * PRICE_TO_MULTIPLIER
+  };
+}
+function parseHeaderColumns(headerLine) {
+  const cells = splitMarkdownRow(headerLine).map((c) => c.trim().toLowerCase());
+  const model = cells.findIndex((c) => c === "model" || c === "model name");
+  const input = cells.findIndex(
+    (c) => (c === "input" || c === "input multiplier") && !c.includes("cached")
+  );
+  const cached2 = cells.findIndex(
+    (c) => c.includes("cached input") || c === "cached input multiplier"
+  );
+  const output = cells.findIndex(
+    (c) => (c === "output" || c === "output multiplier") && !c.includes("cached")
+  );
+  if (model < 0 || input < 0 || output < 0) {
+    return null;
+  }
+  return { model, input, cached: cached2 >= 0 ? cached2 : -1, output };
+}
+function splitMarkdownRow(line) {
+  const parts = line.split("|");
+  if (parts[0].trim() === "") parts.shift();
+  if (parts[parts.length - 1]?.trim() === "") parts.pop();
+  return parts;
+}
+function parseDollarValue(cell) {
+  if (!cell) return null;
+  const cleaned = cell.trim().replace(/[$,]/g, "");
+  if (cleaned.toLowerCase() === "n/a" || cleaned === "" || cleaned === "-") {
+    return null;
+  }
+  const value = Number.parseFloat(cleaned);
+  return Number.isNaN(value) ? null : value;
+}
+var TOKEN_UNIT_COSTS_URL, PREMIUM_MULTIPLIERS_URL, COPILOT_PRICING_URL, PRICE_TO_MULTIPLIER;
+var init_pricing_scraper = __esm({
+  "packages/daemon/src/models/pricing-scraper.ts"() {
+    "use strict";
+    TOKEN_UNIT_COSTS_URL = "https://docs.github.com/en/billing/reference/costs-for-github-models";
+    PREMIUM_MULTIPLIERS_URL = "https://docs.github.com/en/copilot/reference/copilot-billing/request-based-billing-legacy/model-multipliers-for-annual-plans";
+    COPILOT_PRICING_URL = "https://docs.github.com/api/article/body?pathname=/en/copilot/reference/copilot-billing/models-and-pricing";
+    PRICE_TO_MULTIPLIER = 0.1;
+  }
+});
+
+// packages/daemon/src/models/types.ts
+function computeTierFromMultiplier(premiumMultiplier) {
+  if (premiumMultiplier === null) {
+    return "standard";
+  }
+  for (const [tier, range] of Object.entries(TIER_RANGES)) {
+    if (premiumMultiplier >= range.min && premiumMultiplier <= range.max) {
+      return tier;
+    }
+  }
+  return "ultra";
+}
+var TIER_RANGES, TOKEN_UNIT_PRICE;
+var init_types = __esm({
+  "packages/daemon/src/models/types.ts"() {
+    "use strict";
+    TIER_RANGES = {
+      trivial: { min: 0, max: 0.33 },
+      fast: { min: 0.34, max: 1 },
+      standard: { min: 1.1, max: 5 },
+      premium: { min: 5.1, max: 15 },
+      ultra: { min: 15.1, max: Number.POSITIVE_INFINITY }
+    };
+    TOKEN_UNIT_PRICE = 1e-5;
+  }
+});
+
+// packages/daemon/src/models/registry.ts
+function normalizeModelName(name) {
+  return name.toLowerCase().replace(/^openai\s+/i, "").replace(/\s+/g, "-").replace(/[^a-z0-9.\-]/g, "").trim();
+}
+async function fetchCatalogIntoMap(modelMap, result, logger2) {
+  try {
+    const catalogModels = await fetchModelCatalog();
+    result.catalogFetched = true;
+    for (const m of catalogModels) {
+      const key = normalizeModelName(m.id);
+      modelMap.set(key, { id: m.id, displayName: m.displayName, available: true });
+    }
+  } catch (error51) {
+    const msg = error51 instanceof Error ? error51.message : String(error51);
+    result.errors.push(`Catalog fetch failed: ${msg}`);
+    logger2?.warn(`Model catalog fetch failed: ${msg}`);
+  }
+}
+async function scrapeTokenPricingIntoMap(modelMap, result, logger2) {
+  try {
+    const tokenPricing = await scrapeTokenUnitPricing();
+    result.tokenPricingScraped = true;
+    for (const tp of tokenPricing) {
+      const key = normalizeModelName(tp.modelName);
+      const existing = modelMap.get(key) ?? findClosestKey(modelMap, key);
+      if (existing) {
+        existing.tokenInputMultiplier = tp.inputMultiplier;
+        existing.tokenOutputMultiplier = tp.outputMultiplier;
+        existing.cachedInputMultiplier = tp.cachedInputMultiplier;
+      } else {
+        modelMap.set(key, {
+          id: key,
+          displayName: tp.modelName,
+          tokenInputMultiplier: tp.inputMultiplier,
+          tokenOutputMultiplier: tp.outputMultiplier,
+          cachedInputMultiplier: tp.cachedInputMultiplier,
+          available: true
+        });
+      }
+    }
+  } catch (error51) {
+    const msg = error51 instanceof Error ? error51.message : String(error51);
+    result.errors.push(`Token pricing scrape failed: ${msg}`);
+    logger2?.warn(`Token pricing scrape failed: ${msg}`);
+  }
+}
+async function scrapePremiumPricingIntoMap(modelMap, result, logger2) {
+  try {
+    const premiumPricing = await scrapePremiumRequestPricing();
+    result.premiumPricingScraped = true;
+    for (const pp of premiumPricing) {
+      const key = normalizeModelName(pp.modelName);
+      const existing = modelMap.get(key) ?? findClosestKey(modelMap, key);
+      if (existing) {
+        existing.premiumMultiplier = pp.multiplier;
+      } else {
+        modelMap.set(key, {
+          id: key,
+          displayName: pp.modelName,
+          premiumMultiplier: pp.multiplier,
+          available: true
+        });
+      }
+    }
+  } catch (error51) {
+    const msg = error51 instanceof Error ? error51.message : String(error51);
+    result.errors.push(`Premium pricing scrape failed: ${msg}`);
+    logger2?.warn(`Premium pricing scrape failed: ${msg}`);
+  }
+}
+async function scrapeCopilotPricingIntoMap(modelMap, result, logger2) {
+  try {
+    const copilotPricing = await scrapeCopilotPricing();
+    result.copilotPricingScraped = true;
+    for (const cp of copilotPricing) {
+      const key = normalizeModelName(cp.modelName);
+      const existing = modelMap.get(key) ?? findClosestKey(modelMap, key);
+      if (existing) {
+        existing.tokenInputMultiplier = cp.inputMultiplier;
+        existing.tokenOutputMultiplier = cp.outputMultiplier;
+        if (cp.cachedInputMultiplier !== null) {
+          existing.cachedInputMultiplier = cp.cachedInputMultiplier;
+        }
+      } else {
+        modelMap.set(key, {
+          id: key,
+          displayName: cp.modelName,
+          tokenInputMultiplier: cp.inputMultiplier,
+          tokenOutputMultiplier: cp.outputMultiplier,
+          cachedInputMultiplier: cp.cachedInputMultiplier,
+          available: true
+        });
+      }
+    }
+  } catch (error51) {
+    const msg = error51 instanceof Error ? error51.message : String(error51);
+    result.errors.push(`Copilot pricing scrape failed: ${msg}`);
+    logger2?.warn(`Copilot pricing scrape failed: ${msg}`);
+  }
+}
+async function refreshModelPricing(logger2) {
+  const result = {
+    modelsUpdated: 0,
+    catalogFetched: false,
+    tokenPricingScraped: false,
+    premiumPricingScraped: false,
+    copilotPricingScraped: false,
+    errors: []
+  };
+  const modelMap = /* @__PURE__ */ new Map();
+  await fetchCatalogIntoMap(modelMap, result, logger2);
+  await scrapeTokenPricingIntoMap(modelMap, result, logger2);
+  await scrapeCopilotPricingIntoMap(modelMap, result, logger2);
+  await scrapePremiumPricingIntoMap(modelMap, result, logger2);
+  if (!result.catalogFetched && !result.tokenPricingScraped && !result.premiumPricingScraped && !result.copilotPricingScraped) {
+    logger2?.warn("All pricing sources failed, no models available");
+    return result;
+  }
+  const db = await getDatabase();
+  const now = nowIso();
+  for (const model of modelMap.values()) {
+    if (model.tokenInputMultiplier == null) {
+      continue;
+    }
+    const tier = computeTierFromMultiplier(model.premiumMultiplier ?? null);
+    await upsertModel(db, {
+      id: model.id,
+      displayName: model.displayName,
+      premiumMultiplier: model.premiumMultiplier ?? null,
+      tokenInputMultiplier: model.tokenInputMultiplier,
+      tokenOutputMultiplier: model.tokenOutputMultiplier ?? null,
+      cachedInputMultiplier: model.cachedInputMultiplier ?? null,
+      tier,
+      available: model.available ?? true,
+      updatedAt: now
+    });
+    result.modelsUpdated++;
+  }
+  return result;
+}
+async function getModelsForTier(tier) {
+  const db = await getDatabase();
+  const result = await db.execute({
+    sql: "SELECT * FROM model_pricing WHERE tier = ? AND available = 1 ORDER BY premium_multiplier ASC NULLS LAST",
+    args: [tier]
+  });
+  return result.rows.map(rowToModelPricing);
+}
+async function getCheapestInTier(tier) {
+  const models = await getModelsForTier(tier);
+  return models[0] ?? null;
+}
+async function getModelPricing(modelId) {
+  const db = await getDatabase();
+  const result = await db.execute({
+    sql: "SELECT * FROM model_pricing WHERE id = ?",
+    args: [modelId]
+  });
+  if (result.rows.length > 0) {
+    return rowToModelPricing(result.rows[0]);
+  }
+  const allModels = await db.execute(
+    "SELECT * FROM model_pricing WHERE token_input_multiplier IS NOT NULL ORDER BY length(id) DESC"
+  );
+  for (const row of allModels.rows) {
+    const storedId = asString(row.id);
+    if (modelId.startsWith(storedId) || storedId.startsWith(modelId)) {
+      return rowToModelPricing(row);
+    }
+  }
+  return null;
+}
+async function getCheapestAvailableModel() {
+  const tiers = ["trivial", "fast", "standard", "premium", "ultra"];
+  for (const tier of tiers) {
+    const model = await getCheapestInTier(tier);
+    if (model) {
+      return model;
+    }
+  }
+  return null;
+}
+function calculateTokenUnitCost(inputTokens, outputTokens, inputMultiplier, outputMultiplier) {
+  if (inputMultiplier === null || outputMultiplier === null) {
+    return 0;
+  }
+  const tokenUnits = inputTokens * inputMultiplier + outputTokens * outputMultiplier;
+  return tokenUnits * TOKEN_UNIT_PRICE;
+}
+function getNextTierUp(tier) {
+  const order = ["trivial", "fast", "standard", "premium", "ultra"];
+  const idx = order.indexOf(tier);
+  if (idx < 0 || idx >= order.length - 1) {
+    return null;
+  }
+  return order[idx + 1];
+}
+async function upsertModel(db, model) {
+  await db.execute({
+    sql: `INSERT INTO model_pricing (id, display_name, premium_multiplier, token_input_multiplier, token_output_multiplier, cached_input_multiplier, tier, available, updated_at)
+			VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+			ON CONFLICT(id) DO UPDATE SET
+				display_name = excluded.display_name,
+				premium_multiplier = COALESCE(excluded.premium_multiplier, model_pricing.premium_multiplier),
+				token_input_multiplier = COALESCE(excluded.token_input_multiplier, model_pricing.token_input_multiplier),
+				token_output_multiplier = COALESCE(excluded.token_output_multiplier, model_pricing.token_output_multiplier),
+				cached_input_multiplier = COALESCE(excluded.cached_input_multiplier, model_pricing.cached_input_multiplier),
+				tier = excluded.tier,
+				available = excluded.available,
+				updated_at = excluded.updated_at`,
+    args: [
+      model.id,
+      model.displayName,
+      model.premiumMultiplier,
+      model.tokenInputMultiplier,
+      model.tokenOutputMultiplier,
+      model.cachedInputMultiplier,
+      model.tier,
+      model.available ? 1 : 0,
+      model.updatedAt
+    ]
+  });
+}
+function rowToModelPricing(row) {
+  return {
+    id: asString(row.id),
+    displayName: asString(row.display_name),
+    premiumMultiplier: asNullableNumber(row.premium_multiplier),
+    tokenInputMultiplier: asNullableNumber(row.token_input_multiplier),
+    tokenOutputMultiplier: asNullableNumber(row.token_output_multiplier),
+    cachedInputMultiplier: asNullableNumber(row.cached_input_multiplier),
+    tier: asString(row.tier),
+    available: asNumber(row.available) === 1,
+    updatedAt: asString(row.updated_at)
+  };
+}
+function findClosestKey(map2, targetKey) {
+  for (const [key, value] of map2) {
+    if (key.includes(targetKey) || targetKey.includes(key)) {
+      return value;
+    }
+  }
+  return void 0;
+}
+var init_registry = __esm({
+  "packages/daemon/src/models/registry.ts"() {
+    "use strict";
+    init_db();
+    init_catalog();
+    init_pricing_scraper();
+    init_types();
+  }
+});
+
 // node_modules/grammy/out/filter.js
 var require_filter = __commonJS({
   "node_modules/grammy/out/filter.js"(exports2) {
@@ -76932,339 +77762,11 @@ var TypedEventBus = class extends EventEmitter {
 };
 var eventBus = new TypedEventBus();
 
-// packages/daemon/src/store/db.ts
-init_paths();
-import { mkdir } from "node:fs/promises";
-import { dirname } from "node:path";
-import { pathToFileURL } from "node:url";
-import { createClient } from "@libsql/client";
-var MIGRATIONS = [
-  {
-    version: 1,
-    name: "create-store-schema",
-    statements: [
-      `CREATE TABLE IF NOT EXISTS squads (
-				id TEXT PRIMARY KEY,
-				name TEXT NOT NULL,
-				repo_url TEXT NOT NULL,
-				repo_owner TEXT NOT NULL,
-				repo_name TEXT NOT NULL,
-				status TEXT NOT NULL,
-				config TEXT NOT NULL,
-				created_at TEXT NOT NULL,
-				updated_at TEXT NOT NULL,
-				UNIQUE (repo_owner, repo_name)
-			)`,
-      `CREATE TABLE IF NOT EXISTS squad_members (
-				id TEXT PRIMARY KEY,
-				squad_id TEXT NOT NULL REFERENCES squads(id) ON DELETE CASCADE,
-				role TEXT NOT NULL,
-				name TEXT NOT NULL,
-				system_prompt TEXT NOT NULL,
-				model TEXT,
-				created_at TEXT NOT NULL
-			)`,
-      `CREATE TABLE IF NOT EXISTS objectives (
-				id TEXT PRIMARY KEY,
-				squad_id TEXT NOT NULL REFERENCES squads(id) ON DELETE CASCADE,
-				description TEXT NOT NULL,
-				status TEXT NOT NULL,
-				plan TEXT,
-				revision_count INTEGER NOT NULL DEFAULT 0,
-				branch TEXT,
-				pr_url TEXT,
-				created_at TEXT NOT NULL,
-				updated_at TEXT NOT NULL
-			)`,
-      `CREATE TABLE IF NOT EXISTS tasks (
-				id TEXT PRIMARY KEY,
-				objective_id TEXT NOT NULL REFERENCES objectives(id) ON DELETE CASCADE,
-				assignee_id TEXT REFERENCES squad_members(id) ON DELETE SET NULL,
-				title TEXT NOT NULL,
-				description TEXT NOT NULL,
-				status TEXT NOT NULL,
-				result TEXT,
-				created_at TEXT NOT NULL,
-				updated_at TEXT NOT NULL
-			)`,
-      `CREATE TABLE IF NOT EXISTS conversations (
-				id TEXT PRIMARY KEY,
-				title TEXT,
-				source TEXT NOT NULL,
-				created_at TEXT NOT NULL,
-				updated_at TEXT NOT NULL
-			)`,
-      `CREATE TABLE IF NOT EXISTS messages (
-				id TEXT PRIMARY KEY,
-				conversation_id TEXT NOT NULL REFERENCES conversations(id) ON DELETE CASCADE,
-				role TEXT NOT NULL,
-				content TEXT NOT NULL,
-				model TEXT,
-				input_tokens INTEGER,
-				output_tokens INTEGER,
-				created_at TEXT NOT NULL
-			)`,
-      `CREATE TABLE IF NOT EXISTS inbox (
-				id TEXT PRIMARY KEY,
-				squad_id TEXT REFERENCES squads(id) ON DELETE SET NULL,
-				objective_id TEXT REFERENCES objectives(id) ON DELETE SET NULL,
-				type TEXT NOT NULL,
-				title TEXT NOT NULL,
-				content TEXT NOT NULL,
-				status TEXT NOT NULL,
-				reply TEXT,
-				created_at TEXT NOT NULL,
-				updated_at TEXT NOT NULL
-			)`,
-      `CREATE TABLE IF NOT EXISTS schedules (
-				id TEXT PRIMARY KEY,
-				name TEXT NOT NULL,
-				cron_expression TEXT NOT NULL,
-				prompt TEXT NOT NULL,
-				enabled INTEGER NOT NULL DEFAULT 1,
-				last_run_at TEXT,
-				next_run_at TEXT,
-				created_at TEXT NOT NULL,
-				updated_at TEXT NOT NULL
-			)`,
-      `CREATE TABLE IF NOT EXISTS token_usage (
-				id TEXT PRIMARY KEY,
-				squad_id TEXT REFERENCES squads(id) ON DELETE SET NULL,
-				agent_id TEXT,
-				model TEXT NOT NULL,
-				input_tokens INTEGER NOT NULL,
-				output_tokens INTEGER NOT NULL,
-				cost REAL NOT NULL,
-				created_at TEXT NOT NULL
-			)`,
-      `CREATE TABLE IF NOT EXISTS activity (
-				id TEXT PRIMARY KEY,
-				squad_id TEXT REFERENCES squads(id) ON DELETE SET NULL,
-				objective_id TEXT REFERENCES objectives(id) ON DELETE SET NULL,
-				event TEXT NOT NULL,
-				description TEXT NOT NULL,
-				metadata TEXT,
-				created_at TEXT NOT NULL
-			)`,
-      `CREATE TABLE IF NOT EXISTS agent_history (
-				id TEXT PRIMARY KEY,
-				agent_id TEXT NOT NULL,
-				squad_id TEXT REFERENCES squads(id) ON DELETE SET NULL,
-				content TEXT NOT NULL,
-				created_at TEXT NOT NULL
-			)`,
-      `CREATE TABLE IF NOT EXISTS settings (
-				key TEXT PRIMARY KEY,
-				value TEXT
-			)`,
-      "CREATE INDEX IF NOT EXISTS idx_squad_members_squad_id ON squad_members(squad_id)",
-      "CREATE INDEX IF NOT EXISTS idx_objectives_squad_id ON objectives(squad_id)",
-      "CREATE INDEX IF NOT EXISTS idx_objectives_status ON objectives(status)",
-      "CREATE INDEX IF NOT EXISTS idx_tasks_objective_id ON tasks(objective_id)",
-      "CREATE INDEX IF NOT EXISTS idx_tasks_assignee_id ON tasks(assignee_id)",
-      "CREATE INDEX IF NOT EXISTS idx_messages_conversation_id_created_at ON messages(conversation_id, created_at)",
-      "CREATE INDEX IF NOT EXISTS idx_inbox_status_created_at ON inbox(status, created_at)",
-      "CREATE INDEX IF NOT EXISTS idx_inbox_squad_id ON inbox(squad_id)",
-      "CREATE INDEX IF NOT EXISTS idx_inbox_objective_id ON inbox(objective_id)",
-      "CREATE INDEX IF NOT EXISTS idx_schedules_enabled_next_run_at ON schedules(enabled, next_run_at)",
-      "CREATE INDEX IF NOT EXISTS idx_token_usage_created_at ON token_usage(created_at)",
-      "CREATE INDEX IF NOT EXISTS idx_token_usage_squad_id ON token_usage(squad_id)",
-      "CREATE INDEX IF NOT EXISTS idx_token_usage_agent_id ON token_usage(agent_id)",
-      "CREATE INDEX IF NOT EXISTS idx_token_usage_model ON token_usage(model)",
-      "CREATE INDEX IF NOT EXISTS idx_activity_created_at ON activity(created_at)",
-      "CREATE INDEX IF NOT EXISTS idx_activity_squad_id ON activity(squad_id)",
-      "CREATE INDEX IF NOT EXISTS idx_activity_objective_id ON activity(objective_id)",
-      "CREATE INDEX IF NOT EXISTS idx_agent_history_agent_id_created_at ON agent_history(agent_id, created_at)"
-    ]
-  },
-  {
-    version: 2,
-    name: "add-model-pricing-and-dual-costs",
-    statements: [
-      `CREATE TABLE IF NOT EXISTS model_pricing (
-				id TEXT PRIMARY KEY,
-				display_name TEXT NOT NULL,
-				premium_multiplier REAL,
-				token_input_multiplier REAL,
-				token_output_multiplier REAL,
-				cached_input_multiplier REAL,
-				tier TEXT NOT NULL,
-				available INTEGER NOT NULL DEFAULT 1,
-				updated_at TEXT NOT NULL
-			)`,
-      "CREATE INDEX IF NOT EXISTS idx_model_pricing_tier ON model_pricing(tier)",
-      "CREATE INDEX IF NOT EXISTS idx_model_pricing_available ON model_pricing(available)",
-      "ALTER TABLE token_usage ADD COLUMN premium_request_cost REAL",
-      "ALTER TABLE token_usage ADD COLUMN token_unit_cost REAL"
-    ]
-  },
-  {
-    version: 3,
-    name: "add-squad-instances",
-    statements: [
-      `CREATE TABLE IF NOT EXISTS squad_instances (
-				id TEXT PRIMARY KEY,
-				squad_id TEXT NOT NULL REFERENCES squads(id) ON DELETE CASCADE,
-				objective_id TEXT REFERENCES objectives(id) ON DELETE SET NULL,
-				status TEXT NOT NULL DEFAULT 'queued',
-				branch TEXT,
-				worktree_path TEXT,
-				created_at TEXT NOT NULL,
-				started_at TEXT,
-				completed_at TEXT,
-				error TEXT
-			)`,
-      "CREATE INDEX IF NOT EXISTS idx_squad_instances_squad_status ON squad_instances(squad_id, status)",
-      "CREATE INDEX IF NOT EXISTS idx_squad_instances_status ON squad_instances(status)",
-      "CREATE INDEX IF NOT EXISTS idx_squad_instances_objective_id ON squad_instances(objective_id)"
-    ]
-  },
-  {
-    version: 4,
-    name: "denormalize-usage-names",
-    statements: [
-      "ALTER TABLE token_usage ADD COLUMN squad_name TEXT",
-      "ALTER TABLE token_usage ADD COLUMN agent_name TEXT",
-      `UPDATE token_usage SET
-				squad_name = (SELECT s.name FROM squads s WHERE s.id = token_usage.squad_id),
-				agent_name = (SELECT sm.name FROM squad_members sm WHERE sm.id = token_usage.agent_id)
-			WHERE squad_id IS NOT NULL OR agent_id IS NOT NULL`
-    ]
-  }
-];
-var client = null;
-var initPromise = null;
-var defaultConnectionOptions = {};
-var generateId = () => crypto.randomUUID();
-var nowIso = () => (/* @__PURE__ */ new Date()).toISOString();
-function asString(value) {
-  if (typeof value === "string") {
-    return value;
-  }
-  if (value === null || value === void 0) {
-    throw new Error("Expected string value but received null or undefined");
-  }
-  return String(value);
-}
-function asNullableString(value) {
-  if (value === null || value === void 0) {
-    return null;
-  }
-  return typeof value === "string" ? value : String(value);
-}
-function asNumber(value) {
-  if (typeof value === "number") {
-    return value;
-  }
-  if (typeof value === "bigint") {
-    return Number(value);
-  }
-  if (typeof value === "string") {
-    return Number(value);
-  }
-  throw new Error(`Expected numeric value but received ${typeof value}`);
-}
-function asNullableNumber(value) {
-  if (value === null || value === void 0) {
-    return null;
-  }
-  return asNumber(value);
-}
-function asBoolean(value) {
-  return asNumber(value) === 1;
-}
-function toSqliteBoolean(value) {
-  return value ? 1 : 0;
-}
-function parseJson(value) {
-  if (typeof value !== "string") {
-    return value;
-  }
-  return JSON.parse(value);
-}
-function serializeJson(value) {
-  return JSON.stringify(value);
-}
-async function initDatabase() {
-  if (client && !client.closed) {
-    return client;
-  }
-  if (initPromise) {
-    return initPromise;
-  }
-  initPromise = initializeDatabase(defaultConnectionOptions);
-  try {
-    client = await initPromise;
-    return client;
-  } finally {
-    initPromise = null;
-  }
-}
-async function getDatabase() {
-  return initDatabase();
-}
-async function initializeDatabase(options2 = {}) {
-  const url2 = await resolveDatabaseUrl(options2);
-  const databaseClient = createClient({ url: url2 });
-  await databaseClient.execute("PRAGMA foreign_keys = ON");
-  await databaseClient.execute("PRAGMA journal_mode = WAL");
-  await ensureMigrationTable(databaseClient);
-  await applyMigrations(databaseClient);
-  return databaseClient;
-}
-async function resolveDatabaseUrl(options2) {
-  if (options2.url) {
-    return options2.url;
-  }
-  const databasePath = options2.path ?? DB_PATH;
-  await mkdir(dirname(databasePath), { recursive: true });
-  return pathToFileURL(databasePath).href;
-}
-async function ensureMigrationTable(databaseClient) {
-  await databaseClient.executeMultiple(`
-		CREATE TABLE IF NOT EXISTS schema_migrations (
-			version INTEGER PRIMARY KEY,
-			name TEXT NOT NULL,
-			applied_at TEXT NOT NULL
-		);
-	`);
-}
-async function applyMigrations(databaseClient) {
-  const appliedVersions = await getAppliedVersions(databaseClient);
-  for (const migration of MIGRATIONS) {
-    if (appliedVersions.has(migration.version)) {
-      continue;
-    }
-    const transaction = await databaseClient.transaction("write");
-    try {
-      for (const statement of migration.statements) {
-        await transaction.execute(statement);
-      }
-      await transaction.execute({
-        sql: "INSERT INTO schema_migrations (version, name, applied_at) VALUES (?, ?, ?)",
-        args: [migration.version, migration.name, nowIso()]
-      });
-      await transaction.commit();
-    } catch (error51) {
-      if (!transaction.closed) {
-        await transaction.rollback();
-      }
-      throw error51;
-    } finally {
-      if (!transaction.closed) {
-        transaction.close();
-      }
-    }
-  }
-}
-async function getAppliedVersions(databaseClient) {
-  const result = await databaseClient.execute(
-    "SELECT version FROM schema_migrations ORDER BY version ASC"
-  );
-  return new Set(result.rows.map((row) => asNumber(row.version)));
-}
+// packages/daemon/src/store/index.ts
+init_db();
 
 // packages/daemon/src/store/squads.ts
+init_db();
 async function createSquad(data, db) {
   const database = db ?? await getDatabase();
   const timestamp = nowIso();
@@ -77277,7 +77779,8 @@ async function createSquad(data, db) {
     status: data.status ?? "active",
     config: data.config,
     createdAt: timestamp,
-    updatedAt: timestamp
+    updatedAt: timestamp,
+    deletedAt: null
   };
   await database.execute({
     sql: `INSERT INTO squads (id, name, repo_url, repo_owner, repo_name, status, config, created_at, updated_at)
@@ -77299,7 +77802,7 @@ async function createSquad(data, db) {
 async function getSquad(id, db) {
   const database = db ?? await getDatabase();
   const squadResult = await database.execute({
-    sql: "SELECT * FROM squads WHERE id = ? LIMIT 1",
+    sql: "SELECT * FROM squads WHERE id = ? AND deleted_at IS NULL LIMIT 1",
     args: [id]
   });
   const row = squadResult.rows[0];
@@ -77315,7 +77818,7 @@ async function getSquad(id, db) {
 async function getSquadByName(name, db) {
   const database = db ?? await getDatabase();
   const result = await database.execute({
-    sql: "SELECT * FROM squads WHERE name = ? LIMIT 1",
+    sql: "SELECT * FROM squads WHERE name = ? AND deleted_at IS NULL LIMIT 1",
     args: [name]
   });
   const row = result.rows[0];
@@ -77328,7 +77831,9 @@ async function getSquadByName(name, db) {
 }
 async function listSquads(db) {
   const database = db ?? await getDatabase();
-  const result = await database.execute("SELECT * FROM squads ORDER BY created_at DESC, id DESC");
+  const result = await database.execute(
+    "SELECT * FROM squads WHERE deleted_at IS NULL ORDER BY created_at DESC, id DESC"
+  );
   return result.rows.map((row) => mapSquad(row));
 }
 async function updateSquad(id, data, db) {
@@ -77347,7 +77852,8 @@ async function updateSquad(id, data, db) {
     status: data.status ?? existing.status,
     config: data.config ?? existing.config,
     createdAt: existing.createdAt,
-    updatedAt
+    updatedAt,
+    deletedAt: existing.deletedAt
   };
   await database.execute({
     sql: `UPDATE squads
@@ -77368,16 +77874,34 @@ async function updateSquad(id, data, db) {
 }
 async function deleteSquad(id, db) {
   const database = db ?? await getDatabase();
+  const now = nowIso();
   const result = await database.execute({
-    sql: "DELETE FROM squads WHERE id = ?",
-    args: [id]
+    sql: "UPDATE squads SET status = 'deleted', deleted_at = ?, updated_at = ? WHERE id = ? AND deleted_at IS NULL",
+    args: [now, now, id]
   });
   return result.rowsAffected > 0;
 }
+async function restoreSquad(id, db) {
+  const database = db ?? await getDatabase();
+  const now = nowIso();
+  const result = await database.execute({
+    sql: "UPDATE squads SET status = 'active', deleted_at = NULL, updated_at = ? WHERE id = ? AND deleted_at IS NOT NULL",
+    args: [now, id]
+  });
+  if (result.rowsAffected === 0) return null;
+  return getSquadRow(id, database);
+}
+async function listDeletedSquads(db) {
+  const database = db ?? await getDatabase();
+  const result = await database.execute(
+    "SELECT * FROM squads WHERE deleted_at IS NOT NULL ORDER BY deleted_at DESC, id DESC"
+  );
+  return result.rows.map((row) => mapSquad(row));
+}
 async function getSquadByRepo(repoOwner, repoName, db) {
   const database = db ?? await getDatabase();
   const result = await database.execute({
-    sql: "SELECT * FROM squads WHERE repo_owner = ? AND repo_name = ? LIMIT 1",
+    sql: "SELECT * FROM squads WHERE repo_owner = ? AND repo_name = ? AND deleted_at IS NULL LIMIT 1",
     args: [repoOwner, repoName]
   });
   const row = result.rows[0];
@@ -77481,7 +78005,8 @@ function mapSquad(row) {
     status: asString(row.status),
     config: parseJson(asString(row.config)),
     createdAt: asString(row.created_at),
-    updatedAt: asString(row.updated_at)
+    updatedAt: asString(row.updated_at),
+    deletedAt: asNullableString(row.deleted_at)
   };
 }
 function mapMember(row) {
@@ -77497,6 +78022,7 @@ function mapMember(row) {
 }
 
 // packages/daemon/src/store/conversations.ts
+init_db();
 async function createConversation(source, title, db) {
   const database = db ?? await getDatabase();
   const createdAt = nowIso();
@@ -77615,6 +78141,7 @@ function mapMessage(row) {
 }
 
 // packages/daemon/src/store/inbox.ts
+init_db();
 async function createInboxItem(data, db) {
   const database = db ?? await getDatabase();
   const timestamp = nowIso();
@@ -77710,6 +78237,7 @@ function mapInboxItem(row) {
 
 // packages/daemon/src/store/schedules.ts
 var import_cron_parser = __toESM(require_dist(), 1);
+init_db();
 var parseExpression = import_cron_parser.CronExpressionParser.parse;
 async function createSchedule(data, db) {
   const database = db ?? await getDatabase();
@@ -77848,6 +78376,7 @@ function mapSchedule(row) {
 }
 
 // packages/daemon/src/store/token-usage.ts
+init_db();
 async function recordUsage(data, db) {
   const database = db ?? await getDatabase();
   const usage = {
@@ -77977,6 +78506,7 @@ async function getUsageRecords(params = {}, db) {
 }
 
 // packages/daemon/src/store/activity.ts
+init_db();
 async function logActivity(data, db) {
   const database = db ?? await getDatabase();
   const activity = {
@@ -78032,6 +78562,7 @@ function mapActivity(row) {
 }
 
 // packages/daemon/src/store/agent-history.ts
+init_db();
 async function appendHistory(agentId, squadId, content, db) {
   const database = db ?? await getDatabase();
   const entry = {
@@ -78067,6 +78598,7 @@ function mapAgentHistory(row) {
 }
 
 // packages/daemon/src/store/objectives.ts
+init_db();
 async function createObjective(squadId, description, db) {
   const database = db ?? await getDatabase();
   const timestamp = nowIso();
@@ -78259,6 +78791,7 @@ function mapTask(row) {
 }
 
 // packages/daemon/src/store/instances.ts
+init_db();
 async function createInstance(input, db) {
   const database = db ?? await getDatabase();
   const instance = {
@@ -79552,6 +80085,7 @@ function emitInstanceEvent(event, instance) {
 }
 
 // packages/daemon/src/api/routes/squads.ts
+init_db();
 var router7 = (0, import_express7.Router)();
 var DEFAULT_CONFIG = {
   prMode: "draft-pr",
@@ -79724,6 +80258,39 @@ router7.delete("/api/squads/:id", async (req, res) => {
     });
   }
 });
+router7.get("/api/squads/deleted", async (_req, res) => {
+  try {
+    const squads = await listDeletedSquads();
+    res.status(200).json({ squads });
+  } catch (error51) {
+    res.status(500).json({
+      error: "Failed to list deleted squads",
+      details: error51 instanceof Error ? error51.message : "Unknown error"
+    });
+  }
+});
+router7.post("/api/squads/:id/restore", async (req, res) => {
+  try {
+    const restored = await restoreSquad(req.params.id);
+    if (!restored) {
+      res.status(404).json({ error: "Squad not found or not deleted" });
+      return;
+    }
+    await logActivity({
+      squadId: restored.id,
+      event: EVENT_NAMES.SQUAD_UPDATED,
+      description: `Restored squad ${restored.name}`,
+      metadata: { repoUrl: restored.repoUrl }
+    });
+    eventBus.emit(EVENT_NAMES.SQUAD_UPDATED, { squad: restored });
+    res.status(200).json({ squad: restored });
+  } catch (error51) {
+    res.status(500).json({
+      error: "Failed to restore squad",
+      details: error51 instanceof Error ? error51.message : "Unknown error"
+    });
+  }
+});
 router7.get("/api/squads/:id/members", async (req, res) => {
   try {
     const squad = await resolveSquad(req.params.id);
@@ -80777,655 +81344,10 @@ function ensureDataDirectories() {
   }
 }
 
-// packages/daemon/src/models/catalog.ts
-import { execFileSync } from "node:child_process";
-var CATALOG_URL = "https://models.github.ai/catalog/models";
-function resolveGitHubToken() {
-  const envToken = process.env.GITHUB_TOKEN?.trim();
-  if (envToken && envToken.length > 0) {
-    return envToken;
-  }
-  try {
-    const token = execFileSync("gh", ["auth", "token"], {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "pipe"]
-    }).trim();
-    return token.length > 0 ? token : void 0;
-  } catch {
-    return void 0;
-  }
-}
-async function fetchModelCatalog() {
-  const token = resolveGitHubToken();
-  if (!token) {
-    throw new Error("No GitHub token available for model catalog fetch");
-  }
-  const response = await fetch(CATALOG_URL, {
-    headers: {
-      Accept: "application/json",
-      Authorization: `Bearer ${token}`,
-      "X-GitHub-Api-Version": "2024-12-01"
-    }
-  });
-  if (!response.ok) {
-    throw new Error(`Model catalog fetch failed: ${response.status} ${response.statusText}`);
-  }
-  const data = await response.json();
-  if (!Array.isArray(data)) {
-    throw new Error("Model catalog response is not an array");
-  }
-  const models = [];
-  for (const entry of data) {
-    const id = entry.id ?? entry.name;
-    const displayName = entry.friendly_name ?? entry.name ?? id;
-    if (id && typeof id === "string") {
-      models.push({ id, displayName: displayName ?? id });
-    }
-  }
-  return models;
-}
-
-// packages/daemon/src/models/pricing-scraper.ts
-var TOKEN_UNIT_COSTS_URL = "https://docs.github.com/en/billing/reference/costs-for-github-models";
-var PREMIUM_MULTIPLIERS_URL = "https://docs.github.com/en/copilot/reference/copilot-billing/request-based-billing-legacy/model-multipliers-for-annual-plans";
-var COPILOT_PRICING_URL = "https://docs.github.com/api/article/body?pathname=/en/copilot/reference/copilot-billing/models-and-pricing";
-var PRICE_TO_MULTIPLIER = 0.1;
-async function scrapeTokenUnitPricing() {
-  const html = await fetchPage(TOKEN_UNIT_COSTS_URL);
-  return parseTokenUnitTable(html);
-}
-async function scrapeCopilotPricing() {
-  const markdown = await fetchMarkdown(COPILOT_PRICING_URL);
-  return parseCopilotPricingMarkdown(markdown);
-}
-async function scrapePremiumRequestPricing() {
-  const html = await fetchPage(PREMIUM_MULTIPLIERS_URL);
-  return parsePremiumMultiplierTable(html);
-}
-async function fetchPage(url2) {
-  const response = await fetch(url2, {
-    headers: {
-      Accept: "text/html",
-      "User-Agent": "IO-Daemon/4.0 (pricing-refresh)"
-    },
-    redirect: "follow"
-  });
-  if (!response.ok) {
-    throw new Error(`Failed to fetch ${url2}: ${response.status} ${response.statusText}`);
-  }
-  return response.text();
-}
-async function fetchMarkdown(url2) {
-  const response = await fetch(url2, {
-    headers: {
-      Accept: "text/markdown, text/plain, */*",
-      "User-Agent": "IO-Daemon/4.0 (pricing-refresh)"
-    },
-    redirect: "follow"
-  });
-  if (!response.ok) {
-    throw new Error(`Failed to fetch ${url2}: ${response.status} ${response.statusText}`);
-  }
-  return response.text();
-}
-function parseTokenUnitTable(html) {
-  const results = [];
-  const tableRowPattern = /<tr[^>]*>\s*<td[^>]*>([^<]+)<\/td>\s*<td[^>]*>([^<]+)<\/td>\s*<td[^>]*>([^<]*)<\/td>\s*<td[^>]*>([^<]+)<\/td>/gi;
-  for (const match of html.matchAll(tableRowPattern)) {
-    const modelName = cleanCellText(match[1]);
-    const inputMultiplier = Number.parseFloat(match[2]);
-    const cachedInput = match[3].trim().toLowerCase();
-    const outputMultiplier = Number.parseFloat(match[4]);
-    if (modelName && !Number.isNaN(inputMultiplier) && !Number.isNaN(outputMultiplier)) {
-      results.push({
-        modelName,
-        inputMultiplier,
-        cachedInputMultiplier: cachedInput === "n/a" || cachedInput === "" ? null : Number.parseFloat(cachedInput) || null,
-        outputMultiplier
-      });
-    }
-  }
-  return results;
-}
-function parsePremiumMultiplierTable(html) {
-  const results = [];
-  const tableRowPattern = /<tr[^>]*>\s*<td[^>]*>([^<]+)<\/td>\s*<td[^>]*>([^<]+)<\/td>\s*<\/tr>/gi;
-  for (const match of html.matchAll(tableRowPattern)) {
-    const modelName = cleanCellText(match[1]);
-    const multiplier = Number.parseFloat(match[2]);
-    if (modelName && !Number.isNaN(multiplier) && multiplier > 0) {
-      results.push({ modelName, multiplier });
-    }
-  }
-  return results;
-}
-function cleanCellText(text) {
-  return text.replace(/<[^>]*>/g, "").replace(/&[^;]+;/g, " ").trim();
-}
-function parseCopilotPricingMarkdown(markdown) {
-  const results = [];
-  const seenModels = /* @__PURE__ */ new Set();
-  const lines = markdown.split("\n");
-  let columnIndices = null;
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (!trimmed.startsWith("|")) continue;
-    if (/\|\s*Model\s/i.test(trimmed)) {
-      columnIndices = parseHeaderColumns(trimmed);
-      continue;
-    }
-    if (/^[\s|:-]+$/.test(trimmed) || !columnIndices) continue;
-    const entry = parseDataRow(trimmed, columnIndices);
-    if (entry && !seenModels.has(entry.modelName.toLowerCase())) {
-      seenModels.add(entry.modelName.toLowerCase());
-      results.push(entry);
-    }
-  }
-  return results;
-}
-function parseDataRow(line, columnIndices) {
-  const cells = splitMarkdownRow(line);
-  if (cells.length <= columnIndices.output) return null;
-  const modelName = cells[columnIndices.model].trim();
-  const inputPrice = parseDollarValue(cells[columnIndices.input]);
-  const cachedPrice = columnIndices.cached >= 0 ? parseDollarValue(cells[columnIndices.cached]) : null;
-  const outputPrice = parseDollarValue(cells[columnIndices.output]);
-  if (!modelName || inputPrice === null || outputPrice === null) return null;
-  return {
-    modelName,
-    inputMultiplier: inputPrice * PRICE_TO_MULTIPLIER,
-    cachedInputMultiplier: cachedPrice !== null ? cachedPrice * PRICE_TO_MULTIPLIER : null,
-    outputMultiplier: outputPrice * PRICE_TO_MULTIPLIER
-  };
-}
-function parseHeaderColumns(headerLine) {
-  const cells = splitMarkdownRow(headerLine).map((c) => c.trim().toLowerCase());
-  const model = cells.findIndex((c) => c === "model" || c === "model name");
-  const input = cells.findIndex(
-    (c) => (c === "input" || c === "input multiplier") && !c.includes("cached")
-  );
-  const cached2 = cells.findIndex(
-    (c) => c.includes("cached input") || c === "cached input multiplier"
-  );
-  const output = cells.findIndex(
-    (c) => (c === "output" || c === "output multiplier") && !c.includes("cached")
-  );
-  if (model < 0 || input < 0 || output < 0) {
-    return null;
-  }
-  return { model, input, cached: cached2 >= 0 ? cached2 : -1, output };
-}
-function splitMarkdownRow(line) {
-  const parts = line.split("|");
-  if (parts[0].trim() === "") parts.shift();
-  if (parts[parts.length - 1]?.trim() === "") parts.pop();
-  return parts;
-}
-function parseDollarValue(cell) {
-  if (!cell) return null;
-  const cleaned = cell.trim().replace(/[$,]/g, "");
-  if (cleaned.toLowerCase() === "n/a" || cleaned === "" || cleaned === "-") {
-    return null;
-  }
-  const value = Number.parseFloat(cleaned);
-  return Number.isNaN(value) ? null : value;
-}
-
-// packages/daemon/src/models/seed.ts
-var SEED_MODELS = [
-  {
-    id: "gpt-4o-mini",
-    displayName: "OpenAI GPT-4o mini",
-    premiumMultiplier: 0.33,
-    tokenInputMultiplier: 0.015,
-    tokenOutputMultiplier: 0.06,
-    cachedInputMultiplier: 75e-4,
-    tier: "trivial",
-    available: true
-  },
-  {
-    id: "gpt-4o",
-    displayName: "OpenAI GPT-4o",
-    premiumMultiplier: 0.33,
-    tokenInputMultiplier: 0.25,
-    tokenOutputMultiplier: 1,
-    cachedInputMultiplier: 0.125,
-    tier: "trivial",
-    available: true
-  },
-  {
-    id: "gpt-5-mini",
-    displayName: "GPT-5 mini",
-    premiumMultiplier: 0.33,
-    tokenInputMultiplier: 0.025,
-    tokenOutputMultiplier: 0.2,
-    cachedInputMultiplier: 25e-4,
-    tier: "trivial",
-    available: true
-  },
-  {
-    id: "gpt-5.3-codex",
-    displayName: "GPT-5.3-Codex",
-    premiumMultiplier: 6,
-    tokenInputMultiplier: 0.175,
-    tokenOutputMultiplier: 1.4,
-    cachedInputMultiplier: 0.0175,
-    tier: "premium",
-    available: true
-  },
-  {
-    id: "gpt-5.4",
-    displayName: "GPT-5.4",
-    premiumMultiplier: 6,
-    tokenInputMultiplier: 0.25,
-    tokenOutputMultiplier: 1.5,
-    cachedInputMultiplier: 0.025,
-    tier: "premium",
-    available: true
-  },
-  {
-    id: "gpt-5.4-mini",
-    displayName: "GPT-5.4 mini",
-    premiumMultiplier: 6,
-    tokenInputMultiplier: 0.075,
-    tokenOutputMultiplier: 0.45,
-    cachedInputMultiplier: 75e-4,
-    tier: "premium",
-    available: true
-  },
-  {
-    id: "gpt-5.5",
-    displayName: "GPT-5.5",
-    premiumMultiplier: 57,
-    tokenInputMultiplier: 0.5,
-    tokenOutputMultiplier: 3,
-    cachedInputMultiplier: 0.05,
-    tier: "ultra",
-    available: true
-  },
-  {
-    id: "claude-sonnet-4",
-    displayName: "Claude Sonnet 4",
-    premiumMultiplier: 6,
-    tokenInputMultiplier: 0.3,
-    tokenOutputMultiplier: 1.5,
-    cachedInputMultiplier: 0.03,
-    tier: "premium",
-    available: true
-  },
-  {
-    id: "claude-sonnet-4.5",
-    displayName: "Claude Sonnet 4.5",
-    premiumMultiplier: 6,
-    tokenInputMultiplier: 0.3,
-    tokenOutputMultiplier: 1.5,
-    cachedInputMultiplier: 0.03,
-    tier: "premium",
-    available: true
-  },
-  {
-    id: "claude-sonnet-4.6",
-    displayName: "Claude Sonnet 4.6",
-    premiumMultiplier: 9,
-    tokenInputMultiplier: 0.3,
-    tokenOutputMultiplier: 1.5,
-    cachedInputMultiplier: 0.03,
-    tier: "premium",
-    available: true
-  },
-  {
-    id: "claude-haiku-4.5",
-    displayName: "Claude Haiku 4.5",
-    premiumMultiplier: 0.33,
-    tokenInputMultiplier: 0.1,
-    tokenOutputMultiplier: 0.5,
-    cachedInputMultiplier: 0.01,
-    tier: "trivial",
-    available: true
-  },
-  {
-    id: "claude-opus-4.5",
-    displayName: "Claude Opus 4.5",
-    premiumMultiplier: 15,
-    tokenInputMultiplier: 0.5,
-    tokenOutputMultiplier: 2.5,
-    cachedInputMultiplier: 0.05,
-    tier: "premium",
-    available: true
-  },
-  {
-    id: "claude-opus-4.6",
-    displayName: "Claude Opus 4.6",
-    premiumMultiplier: 27,
-    tokenInputMultiplier: 0.5,
-    tokenOutputMultiplier: 2.5,
-    cachedInputMultiplier: 0.05,
-    tier: "ultra",
-    available: true
-  },
-  {
-    id: "claude-opus-4.7",
-    displayName: "Claude Opus 4.7",
-    premiumMultiplier: 27,
-    tokenInputMultiplier: 0.5,
-    tokenOutputMultiplier: 2.5,
-    cachedInputMultiplier: 0.05,
-    tier: "ultra",
-    available: true
-  },
-  {
-    id: "claude-opus-4.8",
-    displayName: "Claude Opus 4.8",
-    premiumMultiplier: 27,
-    tokenInputMultiplier: 0.5,
-    tokenOutputMultiplier: 2.5,
-    cachedInputMultiplier: 0.05,
-    tier: "ultra",
-    available: true
-  },
-  {
-    id: "gemini-2.5-pro",
-    displayName: "Gemini 2.5 Pro",
-    premiumMultiplier: 1,
-    tokenInputMultiplier: 0.125,
-    tokenOutputMultiplier: 1,
-    cachedInputMultiplier: 0.0125,
-    tier: "fast",
-    available: true
-  },
-  {
-    id: "gemini-3-flash",
-    displayName: "Gemini 3 Flash",
-    premiumMultiplier: 0.33,
-    tokenInputMultiplier: 0.05,
-    tokenOutputMultiplier: 0.3,
-    cachedInputMultiplier: 5e-3,
-    tier: "trivial",
-    available: true
-  },
-  {
-    id: "gemini-3.1-pro",
-    displayName: "Gemini 3.1 Pro",
-    premiumMultiplier: 6,
-    tokenInputMultiplier: 0.2,
-    tokenOutputMultiplier: 1.2,
-    cachedInputMultiplier: 0.02,
-    tier: "premium",
-    available: true
-  },
-  {
-    id: "gemini-3.5-flash",
-    displayName: "Gemini 3.5 Flash",
-    premiumMultiplier: 14,
-    tokenInputMultiplier: 0.15,
-    tokenOutputMultiplier: 0.9,
-    cachedInputMultiplier: 0.015,
-    tier: "premium",
-    available: true
-  },
-  {
-    id: "raptor-mini",
-    displayName: "Raptor mini",
-    premiumMultiplier: 0.33,
-    tokenInputMultiplier: 0.025,
-    tokenOutputMultiplier: 0.2,
-    cachedInputMultiplier: 25e-4,
-    tier: "trivial",
-    available: true
-  },
-  {
-    id: "mai-code-1-flash",
-    displayName: "MAI-Code-1-Flash",
-    premiumMultiplier: 0.33,
-    tokenInputMultiplier: 0.075,
-    tokenOutputMultiplier: 0.45,
-    cachedInputMultiplier: 75e-4,
-    tier: "trivial",
-    available: true
-  }
-];
-
-// packages/daemon/src/models/types.ts
-var TIER_RANGES = {
-  trivial: { min: 0, max: 0.33 },
-  fast: { min: 0.34, max: 1 },
-  standard: { min: 1.1, max: 5 },
-  premium: { min: 5.1, max: 15 },
-  ultra: { min: 15.1, max: Number.POSITIVE_INFINITY }
-};
-function computeTierFromMultiplier(premiumMultiplier) {
-  if (premiumMultiplier === null) {
-    return "standard";
-  }
-  for (const [tier, range] of Object.entries(TIER_RANGES)) {
-    if (premiumMultiplier >= range.min && premiumMultiplier <= range.max) {
-      return tier;
-    }
-  }
-  return "ultra";
-}
-var TOKEN_UNIT_PRICE = 1e-5;
-
-// packages/daemon/src/models/registry.ts
-function normalizeModelName(name) {
-  return name.toLowerCase().replace(/^openai\s+/i, "").replace(/\s+/g, "-").replace(/[^a-z0-9.\-]/g, "").trim();
-}
-async function fetchCatalogIntoMap(modelMap, result, logger2) {
-  try {
-    const catalogModels = await fetchModelCatalog();
-    result.catalogFetched = true;
-    for (const m of catalogModels) {
-      const key = normalizeModelName(m.id);
-      modelMap.set(key, { id: m.id, displayName: m.displayName, available: true });
-    }
-  } catch (error51) {
-    const msg = error51 instanceof Error ? error51.message : String(error51);
-    result.errors.push(`Catalog fetch failed: ${msg}`);
-    logger2?.warn(`Model catalog fetch failed: ${msg}`);
-  }
-}
-async function scrapeTokenPricingIntoMap(modelMap, result, logger2) {
-  try {
-    const tokenPricing = await scrapeTokenUnitPricing();
-    result.tokenPricingScraped = true;
-    for (const tp of tokenPricing) {
-      const key = normalizeModelName(tp.modelName);
-      const existing = modelMap.get(key) ?? findClosestKey(modelMap, key);
-      if (existing) {
-        existing.tokenInputMultiplier = tp.inputMultiplier;
-        existing.tokenOutputMultiplier = tp.outputMultiplier;
-        existing.cachedInputMultiplier = tp.cachedInputMultiplier;
-      } else {
-        modelMap.set(key, {
-          id: key,
-          displayName: tp.modelName,
-          tokenInputMultiplier: tp.inputMultiplier,
-          tokenOutputMultiplier: tp.outputMultiplier,
-          cachedInputMultiplier: tp.cachedInputMultiplier,
-          available: true
-        });
-      }
-    }
-  } catch (error51) {
-    const msg = error51 instanceof Error ? error51.message : String(error51);
-    result.errors.push(`Token pricing scrape failed: ${msg}`);
-    logger2?.warn(`Token pricing scrape failed: ${msg}`);
-  }
-}
-async function scrapePremiumPricingIntoMap(modelMap, result, logger2) {
-  try {
-    const premiumPricing = await scrapePremiumRequestPricing();
-    result.premiumPricingScraped = true;
-    for (const pp of premiumPricing) {
-      const key = normalizeModelName(pp.modelName);
-      const existing = modelMap.get(key) ?? findClosestKey(modelMap, key);
-      if (existing) {
-        existing.premiumMultiplier = pp.multiplier;
-      } else {
-        modelMap.set(key, {
-          id: key,
-          displayName: pp.modelName,
-          premiumMultiplier: pp.multiplier,
-          available: true
-        });
-      }
-    }
-  } catch (error51) {
-    const msg = error51 instanceof Error ? error51.message : String(error51);
-    result.errors.push(`Premium pricing scrape failed: ${msg}`);
-    logger2?.warn(`Premium pricing scrape failed: ${msg}`);
-  }
-}
-async function scrapeCopilotPricingIntoMap(modelMap, result, logger2) {
-  try {
-    const copilotPricing = await scrapeCopilotPricing();
-    result.copilotPricingScraped = true;
-    for (const cp of copilotPricing) {
-      const key = normalizeModelName(cp.modelName);
-      const existing = modelMap.get(key) ?? findClosestKey(modelMap, key);
-      if (existing) {
-        existing.tokenInputMultiplier = cp.inputMultiplier;
-        existing.tokenOutputMultiplier = cp.outputMultiplier;
-        if (cp.cachedInputMultiplier !== null) {
-          existing.cachedInputMultiplier = cp.cachedInputMultiplier;
-        }
-      } else {
-        modelMap.set(key, {
-          id: key,
-          displayName: cp.modelName,
-          tokenInputMultiplier: cp.inputMultiplier,
-          tokenOutputMultiplier: cp.outputMultiplier,
-          cachedInputMultiplier: cp.cachedInputMultiplier,
-          available: true
-        });
-      }
-    }
-  } catch (error51) {
-    const msg = error51 instanceof Error ? error51.message : String(error51);
-    result.errors.push(`Copilot pricing scrape failed: ${msg}`);
-    logger2?.warn(`Copilot pricing scrape failed: ${msg}`);
-  }
-}
-async function refreshModelPricing(logger2) {
-  const result = {
-    modelsUpdated: 0,
-    catalogFetched: false,
-    tokenPricingScraped: false,
-    premiumPricingScraped: false,
-    copilotPricingScraped: false,
-    errors: []
-  };
-  const modelMap = /* @__PURE__ */ new Map();
-  await fetchCatalogIntoMap(modelMap, result, logger2);
-  await scrapeTokenPricingIntoMap(modelMap, result, logger2);
-  await scrapeCopilotPricingIntoMap(modelMap, result, logger2);
-  await scrapePremiumPricingIntoMap(modelMap, result, logger2);
-  if (!result.catalogFetched && !result.tokenPricingScraped && !result.premiumPricingScraped && !result.copilotPricingScraped) {
-    logger2?.warn("All pricing sources failed, using seed data");
-    await seedFromFallback();
-    result.modelsUpdated = SEED_MODELS.length;
-    return result;
-  }
-  const db = await getDatabase();
-  const now = nowIso();
-  for (const model of modelMap.values()) {
-    const tier = computeTierFromMultiplier(model.premiumMultiplier ?? null);
-    await upsertModel(db, {
-      id: model.id,
-      displayName: model.displayName,
-      premiumMultiplier: model.premiumMultiplier ?? null,
-      tokenInputMultiplier: model.tokenInputMultiplier ?? null,
-      tokenOutputMultiplier: model.tokenOutputMultiplier ?? null,
-      cachedInputMultiplier: model.cachedInputMultiplier ?? null,
-      tier,
-      available: model.available ?? true,
-      updatedAt: now
-    });
-    result.modelsUpdated++;
-  }
-  return result;
-}
-async function seedFromFallback() {
-  const db = await getDatabase();
-  const now = nowIso();
-  for (const model of SEED_MODELS) {
-    await upsertModel(db, { ...model, updatedAt: now });
-  }
-}
-async function getModelPricing(modelId) {
-  const db = await getDatabase();
-  const result = await db.execute({
-    sql: "SELECT * FROM model_pricing WHERE id = ?",
-    args: [modelId]
-  });
-  if (result.rows.length > 0) {
-    return rowToModelPricing(result.rows[0]);
-  }
-  const allModels = await db.execute(
-    "SELECT * FROM model_pricing WHERE token_input_multiplier IS NOT NULL ORDER BY length(id) DESC"
-  );
-  for (const row of allModels.rows) {
-    const storedId = asString(row.id);
-    if (modelId.startsWith(storedId) || storedId.startsWith(modelId)) {
-      return rowToModelPricing(row);
-    }
-  }
-  return null;
-}
-function calculateTokenUnitCost(inputTokens, outputTokens, inputMultiplier, outputMultiplier) {
-  if (inputMultiplier === null || outputMultiplier === null) {
-    return 0;
-  }
-  const tokenUnits = inputTokens * inputMultiplier + outputTokens * outputMultiplier;
-  return tokenUnits * TOKEN_UNIT_PRICE;
-}
-async function upsertModel(db, model) {
-  await db.execute({
-    sql: `INSERT INTO model_pricing (id, display_name, premium_multiplier, token_input_multiplier, token_output_multiplier, cached_input_multiplier, tier, available, updated_at)
-			VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-			ON CONFLICT(id) DO UPDATE SET
-				display_name = excluded.display_name,
-				premium_multiplier = COALESCE(excluded.premium_multiplier, model_pricing.premium_multiplier),
-				token_input_multiplier = COALESCE(excluded.token_input_multiplier, model_pricing.token_input_multiplier),
-				token_output_multiplier = COALESCE(excluded.token_output_multiplier, model_pricing.token_output_multiplier),
-				cached_input_multiplier = COALESCE(excluded.cached_input_multiplier, model_pricing.cached_input_multiplier),
-				tier = excluded.tier,
-				available = excluded.available,
-				updated_at = excluded.updated_at`,
-    args: [
-      model.id,
-      model.displayName,
-      model.premiumMultiplier,
-      model.tokenInputMultiplier,
-      model.tokenOutputMultiplier,
-      model.cachedInputMultiplier,
-      model.tier,
-      model.available ? 1 : 0,
-      model.updatedAt
-    ]
-  });
-}
-function rowToModelPricing(row) {
-  return {
-    id: asString(row.id),
-    displayName: asString(row.display_name),
-    premiumMultiplier: asNullableNumber(row.premium_multiplier),
-    tokenInputMultiplier: asNullableNumber(row.token_input_multiplier),
-    tokenOutputMultiplier: asNullableNumber(row.token_output_multiplier),
-    cachedInputMultiplier: asNullableNumber(row.cached_input_multiplier),
-    tier: asString(row.tier),
-    available: asNumber(row.available) === 1,
-    updatedAt: asString(row.updated_at)
-  };
-}
-function findClosestKey(map2, targetKey) {
-  for (const [key, value] of map2) {
-    if (key.includes(targetKey) || targetKey.includes(key)) {
-      return value;
-    }
-  }
-  return void 0;
-}
+// packages/daemon/src/models/index.ts
+init_catalog();
+init_registry();
+init_types();
 
 // packages/daemon/src/orchestrator/system-prompt.ts
 function formatSquadRoster(squads) {
@@ -81759,6 +81681,9 @@ async function sendMessage(session, message2, onChunk) {
   return operation;
 }
 
+// packages/daemon/src/orchestrator/orchestrator.ts
+init_registry();
+
 // packages/daemon/src/skills/loader.ts
 var import_gray_matter2 = __toESM(require_gray_matter(), 1);
 init_paths();
@@ -82110,6 +82035,7 @@ var executeCodingToolCall = async (toolName, rawArgs) => {
 // packages/daemon/src/orchestrator/tools/inbox.ts
 init_dist();
 init_zod();
+init_db();
 var inboxReplySchema = external_exports.object({
   itemId: external_exports.string().trim().min(1),
   reply: external_exports.string().trim().min(1)
@@ -82381,17 +82307,80 @@ async function isSquadAvailable(squadId) {
 }
 
 // packages/daemon/src/execution/agent.ts
-init_dist();
+init_registry();
 import { exec as exec3 } from "node:child_process";
 import { mkdir as mkdir9, readFile as readFile7, readdir as readdir5, stat as stat3, writeFile as writeFile6 } from "node:fs/promises";
 import { dirname as dirname8, extname as extname3, isAbsolute, join as join11, relative as relative3, resolve as resolve4 } from "node:path";
 import { promisify as promisify3 } from "node:util";
 import {
-  CopilotClient as CopilotClient2,
-  approveAll as approveAll2,
+  CopilotClient as CopilotClient3,
+  approveAll as approveAll3,
   defineTool
 } from "@github/copilot-sdk";
 
+// packages/daemon/src/squad/model-selector.ts
+init_registry();
+import { CopilotClient as CopilotClient2, approveAll as approveAll2 } from "@github/copilot-sdk";
+var VALID_TIERS = ["trivial", "fast", "standard", "premium", "ultra"];
+var CLASSIFICATION_PROMPT = `You are a task complexity classifier. Given a task description, classify its complexity into exactly one tier.
+
+Tiers (from simplest to most complex):
+- trivial: Typos, renames, comment changes, config tweaks, formatting
+- fast: Simple bug fixes, small features, documentation updates, single-file changes
+- standard: Feature implementation, multi-file changes, moderate refactoring
+- premium: Architecture changes, complex refactoring, security work, performance optimization
+- ultra: System-wide redesigns, critical infrastructure, cross-cutting concerns
+
+Reply with ONLY the tier name (one word, lowercase). Nothing else.`;
+async function selectModelForTask(taskDescription) {
+  const classifierModel = await getCheapestAvailableModel();
+  if (!classifierModel) {
+    throw new Error("No models available in pricing database");
+  }
+  let tier;
+  try {
+    tier = await classifyTaskComplexity(taskDescription, classifierModel.id);
+  } catch {
+    return classifierModel.id;
+  }
+  const selectedModel = await getCheapestInTier(tier);
+  if (selectedModel) {
+    return selectedModel.id;
+  }
+  const nextTier = getNextTierUp(tier);
+  if (nextTier) {
+    const escalatedModel = await getCheapestInTier(nextTier);
+    if (escalatedModel) {
+      return escalatedModel.id;
+    }
+  }
+  return classifierModel.id;
+}
+async function classifyTaskComplexity(taskDescription, modelId) {
+  let client2 = null;
+  try {
+    client2 = new CopilotClient2();
+    await client2.start();
+    const session = await client2.createSession({
+      model: modelId,
+      onPermissionRequest: approveAll2,
+      systemMessage: { content: CLASSIFICATION_PROMPT }
+    });
+    try {
+      const response = await session.sendAndWait({ prompt: `Task: ${taskDescription}` }, 15e3);
+      const raw = (response.text ?? "").trim().toLowerCase();
+      const tier = VALID_TIERS.find((t) => raw.includes(t));
+      return tier ?? "standard";
+    } finally {
+      await session.disconnect().catch(() => void 0);
+    }
+  } finally {
+    if (client2) {
+      await client2.stop().catch(() => void 0);
+    }
+  }
+}
+
 // packages/daemon/src/execution/history.ts
 var DEFAULT_CONTEXT_LIMIT = 5;
 var MAX_LEARNING_LENGTH = 1e3;
@@ -82677,14 +82666,15 @@ async function executeAgentTask(member, task, worktreePath, options2) {
   const mcpServerNote = options2?.mcpServers?.length ? `Available MCP server labels: ${options2.mcpServers.join(", ")}.` : "No additional MCP servers were configured for this run.";
   let client2 = null;
   try {
-    client2 = new CopilotClient2({ workingDirectory: worktreePath });
+    client2 = new CopilotClient3({ workingDirectory: worktreePath });
     await client2.start();
+    const model = member.model ?? await selectModelForTask(task.description);
     const session = await client2.createSession({
-      model: member.model ?? DEFAULT_MODEL,
+      model,
       workingDirectory: worktreePath,
       tools,
       availableTools: ["custom:*"],
-      onPermissionRequest: approveAll2,
+      onPermissionRequest: approveAll3,
       systemMessage: {
         content: `${member.systemPrompt}
 
@@ -82761,12 +82751,11 @@ async function buildInstanceSystemPromptSuffix(squadId, instanceId) {
 }
 
 // packages/daemon/src/execution/planning.ts
-init_dist();
 import { exec as exec4 } from "node:child_process";
 import { access, readFile as readFile8 } from "node:fs/promises";
 import { join as join12 } from "node:path";
 import { promisify as promisify4 } from "node:util";
-import { CopilotClient as CopilotClient3, approveAll as approveAll3 } from "@github/copilot-sdk";
+import { CopilotClient as CopilotClient4, approveAll as approveAll4 } from "@github/copilot-sdk";
 
 // packages/daemon/src/squad/roles.ts
 var ROLE_GUIDELINES = [
@@ -82909,12 +82898,13 @@ Return strict JSON in this shape:
 }`;
   let client2 = null;
   try {
-    client2 = new CopilotClient3({ workingDirectory: repoPath });
+    client2 = new CopilotClient4({ workingDirectory: repoPath });
     await client2.start();
+    const model = await selectModelForTask(`Create implementation plan: ${objective.description}`);
     const session = await client2.createSession({
-      model: DEFAULT_MODEL,
+      model,
       workingDirectory: repoPath,
-      onPermissionRequest: approveAll3,
+      onPermissionRequest: approveAll4,
       systemMessage: {
         content: `${TEAM_LEAD_PROMPT}
 
@@ -83017,7 +83007,7 @@ async function createPullRequest(options2) {
 init_dist();
 import { exec as exec6 } from "node:child_process";
 import { promisify as promisify6 } from "node:util";
-import { CopilotClient as CopilotClient4, approveAll as approveAll4 } from "@github/copilot-sdk";
+import { CopilotClient as CopilotClient5, approveAll as approveAll5 } from "@github/copilot-sdk";
 var execAsync6 = promisify6(exec6);
 var GIT_DIFF_MAX_BUFFER = 10 * 1024 * 1024;
 function extractJsonObject2(content) {
@@ -83057,12 +83047,13 @@ Return strict JSON:
 }`;
   let client2 = null;
   try {
-    client2 = new CopilotClient4({ workingDirectory: worktreePath });
+    client2 = new CopilotClient5({ workingDirectory: worktreePath });
     await client2.start();
+    const model = qaMember.model ?? await selectModelForTask(`QA review: ${objective.description}`);
     const session = await client2.createSession({
-      model: qaMember.model ?? DEFAULT_MODEL,
+      model,
       workingDirectory: worktreePath,
-      onPermissionRequest: approveAll4,
+      onPermissionRequest: approveAll5,
       systemMessage: {
         content: QA_PROMPT
       }
@@ -83132,8 +83123,7 @@ async function handleQARejection(objectiveId, feedback) {
 }
 
 // packages/daemon/src/execution/review.ts
-init_dist();
-import { CopilotClient as CopilotClient5, approveAll as approveAll5 } from "@github/copilot-sdk";
+import { CopilotClient as CopilotClient6, approveAll as approveAll6 } from "@github/copilot-sdk";
 function extractJsonObject3(content) {
   const fenced = content.match(/```(?:json)?\s*([\s\S]*?)```/i);
   if (fenced?.[1]) {
@@ -83178,11 +83168,12 @@ Return strict JSON:
 }`;
   let client2 = null;
   try {
-    client2 = new CopilotClient5();
+    client2 = new CopilotClient6();
     await client2.start();
+    const model = teamLead.model ?? await selectModelForTask(`Code review: ${objective.description}`);
     const session = await client2.createSession({
-      model: teamLead.model ?? DEFAULT_MODEL,
-      onPermissionRequest: approveAll5,
+      model,
+      onPermissionRequest: approveAll6,
       systemMessage: {
         content: `${TEAM_LEAD_PROMPT}
 
@@ -83647,10 +83638,22 @@ var squadToolDefinitions = [
   },
   {
     name: "fire_squad",
-    description: "Deactivate or delete a squad.",
+    description: "Soft-delete a squad. The squad can be restored later with restore_squad.",
     parameters: squadIdSchema,
     skipPermission: true
   },
+  {
+    name: "restore_squad",
+    description: "Restore a previously deleted squad and all its members.",
+    parameters: squadIdSchema,
+    skipPermission: true
+  },
+  {
+    name: "list_deleted_squads",
+    description: "List all soft-deleted squads that can be restored.",
+    parameters: external_exports.object({}),
+    skipPermission: true
+  },
   {
     name: "list_squads",
     description: "List all squads and their status.",
@@ -83850,7 +83853,7 @@ async function processQueue2(squadId) {
       const next = await getNextQueued(squadId);
       if (next) {
         const freshSquad = await getSquad(squadId);
-        if (freshSquad) {
+        if (freshSquad && next.objectiveId) {
           void startAndExecuteInstance(next.id, freshSquad, next.objectiveId);
         }
       }
@@ -83985,13 +83988,28 @@ async function handleFireSquad(rawArgs) {
   if (activeObjectives.length > 0) {
     const updated = await updateSquad(squadId, { status: "inactive" });
     return {
-      message: `Squad ${squadId} was deactivated because it still has active objectives.`,
+      message: `Squad ${squadId} was deactivated because it still has active objectives. Use fire_squad again after objectives complete to delete it.`,
       squad: updated,
       activeObjectives
     };
   }
   await deleteSquad(squadId);
-  return { message: `Squad ${squadId} was deleted.`, squadId };
+  return {
+    message: `Squad "${squad.name}" has been deleted. It can be restored with restore_squad if needed.`,
+    squadId
+  };
+}
+async function handleRestoreSquad(rawArgs) {
+  const { squadId } = squadIdSchema.parse(rawArgs);
+  const restored = await restoreSquad(squadId);
+  if (!restored) {
+    throw new Error(`Squad ${squadId} was not found or is not deleted.`);
+  }
+  eventBus.emit(EVENT_NAMES.SQUAD_UPDATED, { squad: restored });
+  return {
+    message: `Squad "${restored.name}" has been restored.`,
+    squad: restored
+  };
 }
 async function handleDelegateToSquad(rawArgs) {
   const { squadId, objective } = delegateToSquadSchema.parse(rawArgs);
@@ -84056,11 +84074,26 @@ function createSquadToolExecutor(_config) {
         return handleAnalyzeRepo(rawArgs);
       case "fire_squad":
         return handleFireSquad(rawArgs);
+      case "restore_squad":
+        return handleRestoreSquad(rawArgs);
+      case "list_deleted_squads": {
+        const deletedSquads = await listDeletedSquads();
+        if (deletedSquads.length === 0) {
+          return { message: "No deleted squads.", squads: [] };
+        }
+        const list = deletedSquads.map((s) => `${s.id}: ${s.name} (${s.repoOwner}/${s.repoName}) [deleted ${s.deletedAt}]`).join("\n");
+        return { message: list, squads: deletedSquads };
+      }
       case "list_squads": {
         const squads = await listSquads();
+        const deletedCount = (await listDeletedSquads()).length;
+        const suffix = deletedCount > 0 ? `
+
+${deletedCount} deleted squad(s) available for restore (use list_deleted_squads to view).` : "";
         return {
-          message: formatSquadList(squads),
-          squads
+          message: formatSquadList(squads) + suffix,
+          squads,
+          deletedCount
         };
       }
       case "get_squad_status": {
@@ -84454,13 +84487,13 @@ var Orchestrator = class {
       });
       this.activeModel = model;
     } catch (error51) {
-      if (model !== DEFAULT_MODEL) {
+      if (model !== this.config.defaultModel) {
         this.activeSession = await createSession({
-          model: DEFAULT_MODEL,
+          model: this.config.defaultModel,
           systemPrompt,
           tools: createBoundOrchestratorTools(this.config)
         });
-        this.activeModel = DEFAULT_MODEL;
+        this.activeModel = this.config.defaultModel;
       } else {
         throw error51;
       }
@@ -84509,6 +84542,7 @@ function createOrchestrator(config2, eventBus2) {
 // packages/daemon/src/scheduler/engine.ts
 init_dist();
 var import_cron_parser2 = __toESM(require_dist(), 1);
+init_db();
 var Scheduler = class {
   orchestrator;
   eventBus;
@@ -84596,6 +84630,9 @@ function createScheduler(orchestrator2, eventBus2) {
   return new Scheduler(orchestrator2, eventBus2);
 }
 
+// packages/daemon/src/index.ts
+init_db();
+
 // packages/daemon/src/telegram/bot.ts
 var import_grammy = __toESM(require_mod2(), 1);
 var TelegramBot = class {
@@ -84616,9 +84653,16 @@ var TelegramBot = class {
     if (this.started) {
       return;
     }
+    this.bot.catch((err) => {
+      this.logger.error({ err: err.error }, "Telegram bot error: %s", err.message);
+    });
     this.registerHandlers();
-    this.bot.start().catch((error51) => {
-      this.logger.error({ err: error51 }, "Telegram polling failed");
+    this.bot.start({
+      onStart: () => {
+        this.logger.info("Telegram bot connected and polling");
+      }
+    }).catch((error51) => {
+      this.logger.error({ err: error51 }, "Telegram polling failed to start");
     });
     this.started = true;
   }
@@ -84628,11 +84672,26 @@ var TelegramBot = class {
     }
     this.bot.stop();
     this.started = false;
+    this.logger.info("Telegram bot stopped");
   }
   async sendText(chatId, text) {
     await this.bot.api.sendMessage(chatId, text);
   }
+  isAuthorized(userId) {
+    if (!this.config.telegramUserId) {
+      return false;
+    }
+    return String(userId) === this.config.telegramUserId;
+  }
   registerHandlers() {
+    this.bot.use(async (ctx, next) => {
+      const userId = ctx.from?.id;
+      if (!userId || !this.isAuthorized(userId)) {
+        this.logger.warn({ userId }, "Unauthorized Telegram message, ignoring");
+        return;
+      }
+      await next();
+    });
     this.bot.command("start", async (ctx) => {
       await ctx.reply(
         "Hello from Io. Send me a message and I will route it through the daemon orchestrator."
@@ -84807,8 +84866,7 @@ async function main() {
     logger2.info("Database initialized");
     const pricingResult = await refreshModelPricing(logger2);
     if (pricingResult.modelsUpdated === 0) {
-      logger2.warn("Model pricing refresh returned 0 models, seeding with fallback");
-      await seedFromFallback();
+      logger2.warn("Model pricing refresh returned 0 models");
     }
     logger2.info({ modelsUpdated: pricingResult.modelsUpdated }, "Model pricing initialized");
     await scanSkills();
@@ -84828,8 +84886,13 @@ async function main() {
     setChatOrchestrator(orchestrator2);
     const apiServer = createApiServer(config2);
     const telegramBot = createTelegramBot(config2, orchestrator2);
-    telegramBot?.start();
-    createTelegramNotifier(telegramBot, config2, eventBus);
+    if (telegramBot) {
+      telegramBot.start();
+      createTelegramNotifier(telegramBot, config2, eventBus);
+      logger2.info("Telegram bot initialized");
+    } else {
+      logger2.info("Telegram bot disabled (no token configured)");
+    }
     registerShutdownHandlers(logger2, async () => {
       if (pricingRefreshTimer) {
         clearInterval(pricingRefreshTimer);