@circuitwall/jarela 2.2.0 → 2.3.0

package/lib/providers/github-copilot.test.ts

@@ -1,5 +1,9 @@
 import { afterEach, describe, it, expect, vi } from "vitest";
 import type AnthropicNS from "@anthropic-ai/sdk";
+
+// Keep routing tests off the developer's real data directory: no stored OAuth token.
+vi.mock("./github-copilot-auth", () => ({ getStoredOAuthToken: () => null }));
+
 import { githubCopilotProvider, isCopilotClaudeModel } from "./github-copilot";
 
 afterEach(() => vi.unstubAllGlobals());
@@ -113,4 +117,27 @@ describe("Claude-via-Copilot routing", () => {
     }, [])).rejects.toMatchObject({ status: 429 });
     expect(fetch).toHaveBeenCalledTimes(1);
   });
+  it.each(["ghp_synthetic", "github_pat_synthetic"])("rejects PAT %s without network access", async (apiKey) => {
+    const fetch = vi.fn(async () => new Response("{}", { status: 503 }));
+    vi.stubGlobal("fetch", fetch);
+
+    await expect(githubCopilotProvider.invoke!("gpt-4o", [{ role: "user", content: "synthetic" }], {
+      api_key: apiKey,
+    }, [])).rejects.toThrow(/PAT route used GitHub Models.*retired/i);
+    expect(fetch).not.toHaveBeenCalled();
+  });
+
+  it("routes explicit session tokens through the Copilot Chat endpoint", async () => {
+    const urls: string[] = [];
+    const fetch = vi.fn(async (input: RequestInfo | URL) => {
+      urls.push(input instanceof Request ? input.url : input.toString());
+      return new Response("{}", { status: 503 });
+    });
+    vi.stubGlobal("fetch", fetch);
+
+    await expect(githubCopilotProvider.invoke!("gpt-4o", [{ role: "user", content: "synthetic" }], {
+      copilot_session_token: "synthetic-session-token",
+    }, [])).rejects.toThrow();
+    expect(urls).toEqual(["https://api.githubcopilot.com/chat/completions"]);
+  });
 });

package/lib/providers/github-copilot.ts

@@ -55,19 +55,19 @@ interface SessionToken {
 
 const tokenCache = new Map<string, SessionToken>();
 
-function isLikelyGitHubPat(token: string): boolean {
-  return token.startsWith("ghp_") || token.startsWith("github_pat_") || token.startsWith("gho_");
+function isGitHubPat(token: string): boolean {
+  return token.startsWith("ghp_") || token.startsWith("github_pat_");
 }
 
-async function getCopilotToken(pat: string): Promise<string> {
-  if (!pat) throw new Error("GitHub Copilot: no API key configured for token exchange.");
-  const cached = tokenCache.get(pat);
+async function exchangeCopilotSessionToken(githubToken: string): Promise<string> {
+  if (!githubToken) throw new Error("GitHub Copilot: no API key configured for token exchange.");
+  const cached = tokenCache.get(githubToken);
   if (cached && cached.expiresAt - Date.now() > 60_000) return cached.token;
-  tokenCache.delete(pat);
+  tokenCache.delete(githubToken);
 
   const res = await fetch("https://api.github.com/copilot_internal/v2/token", {
     headers: {
-      Authorization: `token ${pat}`,
+      Authorization: `token ${githubToken}`,
       "User-Agent": "Jarela/1.0",
     },
     signal: AbortSignal.timeout(30_000),
@@ -78,15 +78,14 @@ async function getCopilotToken(pat: string): Promise<string> {
     if (res.status === 401) {
       throw new Error(
         `GitHub Copilot: token exchange failed (401). ` +
-        `Ensure your PAT has the "copilot" scope and that you have an active Copilot subscription. ` +
+        `Check that this GitHub account has an active Copilot subscription and the credential is valid. ` +
         `Details: ${body}`,
       );
     }
     if (res.status === 404) {
       throw new Error(
-        "GitHub Copilot token exchange endpoint was not found for this credential. " +
-        "Personal Access Tokens are not accepted directly by Copilot chat. " +
-        "Use a Copilot session token in params.copilot_session_token, or a credential that supports token exchange.",
+        "GitHub Copilot could not exchange this credential for a session token. " +
+        "Use the in-app device-flow sign-in or set params.copilot_session_token.",
       );
     }
     throw new Error(`GitHub Copilot: token exchange failed (${res.status}): ${body}`);
@@ -96,7 +95,7 @@ async function getCopilotToken(pat: string): Promise<string> {
   if (!json.token) throw new Error("GitHub Copilot: token exchange returned no token");
 
   const expiresAt = json.expires_at ? new Date(json.expires_at).getTime() : Date.now() + 28 * 60_000;
-  tokenCache.set(pat, { token: json.token, expiresAt });
+  tokenCache.set(githubToken, { token: json.token, expiresAt });
   return json.token;
 }
 
@@ -119,14 +118,8 @@ async function resolvedClient(params: ProviderParams): Promise<OpenAI> {
   });
 }
 
-// Returns the auth + transport details needed to talk to GitHub Copilot. The
-// session-token + native-Messages-API path is preferred because it preserves
-// Anthropic `cache_control` markers; the legacy PAT path falls back to
-// GitHub Models REST (OpenAI-shaped, no Claude Messages support, capped at
-// ~8K input tokens) and is incompatible with Anthropic routing.
-type CopilotAuth =
-  | { kind: "copilot-api"; baseURL: string; apiKey: string; headers: Record<string, string> }
-  | { kind: "models-rest"; baseURL: string; apiKey: string; headers: Record<string, string> };
+// Resolves credentials for Copilot's OpenAI-compatible and native Messages APIs.
+type CopilotAuth = { baseURL: string; apiKey: string; headers: Record<string, string> };
 
 async function resolveCopilotAuth(params: ProviderParams): Promise<CopilotAuth> {
   const apiKey = (params.api_key as string | undefined) ?? "";
@@ -134,7 +127,6 @@ async function resolveCopilotAuth(params: ProviderParams): Promise<CopilotAuth>
 
   if (explicitSessionToken && explicitSessionToken.length > 0) {
     return {
-      kind: "copilot-api",
       baseURL: params.base_url ?? "https://api.githubcopilot.com",
       apiKey: explicitSessionToken,
       headers: { ...FIXED_HEADERS },
@@ -143,25 +135,19 @@ async function resolveCopilotAuth(params: ProviderParams): Promise<CopilotAuth>
 
   const oauthToken = getStoredOAuthToken();
   if (oauthToken) {
-    const token = await getCopilotToken(oauthToken);
+    const token = await exchangeCopilotSessionToken(oauthToken);
     return {
-      kind: "copilot-api",
       baseURL: params.base_url ?? "https://api.githubcopilot.com",
       apiKey: token,
       headers: { ...FIXED_HEADERS },
     };
   }
 
-  if (apiKey && isLikelyGitHubPat(apiKey)) {
-    return {
-      kind: "models-rest",
-      baseURL: params.base_url ?? "https://models.github.ai/inference",
-      apiKey,
-      headers: {
-        Accept: "application/vnd.github+json",
-        "X-GitHub-Api-Version": "2026-03-10",
-      },
-    };
+  if (apiKey && isGitHubPat(apiKey)) {
+    throw new Error(
+      "GitHub Copilot: this provider's GitHub PAT route used GitHub Models, which has been retired. " +
+      "Use the in-app device-flow sign-in or set copilot_session_token.",
+    );
   }
 
   if (!apiKey) {
@@ -169,9 +155,8 @@ async function resolveCopilotAuth(params: ProviderParams): Promise<CopilotAuth>
       "GitHub Copilot: not signed in. Use the in-app device-flow login, or set api_key / copilot_session_token.",
     );
   }
-  const token = await getCopilotToken(apiKey);
+  const token = await exchangeCopilotSessionToken(apiKey);
   return {
-    kind: "copilot-api",
     baseURL: params.base_url ?? "https://api.githubcopilot.com",
     apiKey: token,
     headers: { ...FIXED_HEADERS },
@@ -181,17 +166,9 @@ async function resolveCopilotAuth(params: ProviderParams): Promise<CopilotAuth>
 // Anthropic SDK client pointed at Copilot's native `/v1/messages` endpoint.
 // Copilot accepts the Anthropic request shape (including `cache_control`
 // ephemeral breakpoints) for Claude-family models when called with a
-// session token. The PAT-only `models.github.ai` fallback does NOT expose
-// this endpoint, so we surface a clear error there instead of silently
-// downgrading to a path that strips the cache markers.
+// Copilot session token.
 async function resolvedAnthropicClient(params: ProviderParams): Promise<Anthropic> {
   const auth = await resolveCopilotAuth(params);
-  if (auth.kind !== "copilot-api") {
-    throw new Error(
-      "GitHub Copilot: Claude models require a Copilot session token (OAuth or copilot_session_token). " +
-      "Personal Access Tokens route to GitHub Models REST, which does not expose the native Messages API.",
-    );
-  }
   return new Anthropic({
     // The SDK requires an apiKey field; we authenticate via authToken
     // (Authorization: Bearer ...) per Copilot's contract. The empty

package/lib/skills/builtins/memory-organization/SKILL.md

@@ -37,6 +37,22 @@ Every update to an existing key keeps a dated snapshot of the prior record in
 its `history`, and older free-form or v1 entries are upgraded to the current
 schema automatically the first time they're read — no manual migration step.
 
+## Proactive Saving
+
+Memory is shared by every Jarela agent, so save durable information in the
+turn it appears instead of relying on background compaction, which runs later
+and can miss details.
+
+1. **Trigger:** the user states a preference, fact, decision, constraint, or
+   correction; or a tool result verifies a durable fact.
+2. **Check:** search for an existing record on the same subject and reuse its
+   key.
+3. **Write:** call `memory_upsert` before the final reply.
+4. **Validate:** the result must contain `ok: true` and the key you sent;
+   retry once on failure, then tell the user it was not saved.
+5. **Cite:** end the reply with `Saved to memory: facts/<key>` for each saved
+   key.
+
 ## Retrieval And Consolidation
 
 1. Let proactive recall supply matching facts on normal user turns. Use

package/lib/stores/integrations.test.ts

@@ -175,6 +175,13 @@ describe("integrations store (credentials-backed)", () => {
     // And no credential was created as a side effect of the failed write.
     expect(listCredentials({ type: "integration", provider: "anthropic" }).length).toBe(0);
   });
+
+  it("does not create a configured row from an empty optional credential field", () => {
+    const result = saveIntegration("github-copilot", { api_key: "" });
+    expect("error" in result).toBe(true);
+    expect(getIntegrationStatus("github-copilot")?.configured).toBe(false);
+    expect(listCredentials({ type: "integration", provider: "github-copilot" })).toHaveLength(0);
+  });
 });
 
 describe("integrations store: multi-instance + ALS routing", () => {

package/lib/stores/integrations.ts

@@ -176,11 +176,10 @@ export const INTEGRATIONS = {
     label: "GitHub Copilot",
     category: "llm" as IntegrationCategory,
     description:
-      "Routes chat-completion requests through your Copilot subscription. Paste a GitHub PAT " +
-      "with `copilot` scope from github.com/settings/tokens, or run the device-flow sign-in in " +
-      "the Models panel.",
+      "Routes chat-completion requests through your Copilot subscription. Use the device-flow " +
+      "sign-in in the Models panel; legacy GitHub PAT authentication is no longer supported.",
     fields: [
-      { key: "api_key", label: "GitHub PAT", placeholder: "ghp_… or github_pat_…", secret: true, required: true },
+      { key: "api_key", label: "Legacy GitHub PAT (unsupported)", placeholder: "Use Models panel sign-in", secret: true, required: false },
     ],
   },
   gmail: {
@@ -437,6 +436,7 @@ export function saveIntegration(name: string, incoming: Record<string, string>):
       else if (f.required) return { error: `missing required secret "${f.key}"` };
     } else {
       if (f.required && !v.trim()) return { error: `"${f.key}" cannot be empty` };
+      if (!v.trim()) continue;
       merged[f.key] = v;
       if (existing[f.key] !== v) touched.push(f.key);
     }

package/lib/stores/model-config.test.ts

@@ -118,3 +118,91 @@ describe("deleteModelConfig auto-promotes default", () => {
     deleteModelConfig("keep-default");
   });
 });
+
+describe("model config enable/disable and atomic default", () => {
+  async function load() {
+    return import("./model-config");
+  }
+
+  function reset(names: string[]) {
+    for (const n of names) deleteModelConfig(n);
+  }
+
+  it("new rows are enabled and upsert without is_default preserves the default flag", async () => {
+    const { isModelConfigEnabled } = await load();
+    upsertModelConfig("ena-a", "anthropic", "claude-x", {}, true);
+    const saved = upsertModelConfig("ena-a", "anthropic", "claude-x", { temperature: 0.2 }, undefined);
+    expect(saved.is_default).toBe(1);
+    expect(isModelConfigEnabled(saved)).toBe(true);
+    reset(["ena-a"]);
+  });
+
+  it("setDefaultModelConfig leaves exactly one default", async () => {
+    const { setDefaultModelConfig, listModelConfigs } = await load();
+    upsertModelConfig("def-a", "anthropic", "claude-x", {}, true);
+    upsertModelConfig("def-b", "anthropic", "claude-y", {}, false);
+    const row = setDefaultModelConfig("def-b");
+    expect(row.is_default).toBe(1);
+    expect(listModelConfigs().filter((r) => r.is_default === 1).map((r) => r.name)).toEqual(["def-b"]);
+    // Params are untouched by a default switch.
+    expect(getModelConfig("def-a")?.params).toBe(JSON.stringify({}));
+    reset(["def-a", "def-b"]);
+  });
+
+  it("setDefaultModelConfig rejects unknown and disabled configs without changing the default", async () => {
+    const { setDefaultModelConfig, setModelConfigEnabled, ModelConfigStateError } = await load();
+    upsertModelConfig("rej-a", "anthropic", "claude-x", {}, true);
+    upsertModelConfig("rej-b", "anthropic", "claude-y", {}, false);
+    setModelConfigEnabled("rej-b", false);
+    expect(() => setDefaultModelConfig("missing-model")).toThrow(ModelConfigStateError);
+    expect(() => setDefaultModelConfig("rej-b")).toThrow(/disabled/);
+    expect(getDefaultModelConfig()?.name).toBe("rej-a");
+    reset(["rej-a", "rej-b"]);
+  });
+
+  it("disabling the default promotes another enabled config in the same step", async () => {
+    const { setModelConfigEnabled, listModelConfigs } = await load();
+    upsertModelConfig("dis-a", "anthropic", "claude-x", {}, true);
+    upsertModelConfig("dis-b", "anthropic", "claude-y", {}, false);
+    const disabled = setModelConfigEnabled("dis-a", false);
+    expect(disabled.enabled).toBe(0);
+    expect(disabled.is_default).toBe(0);
+    const defaults = listModelConfigs().filter((r) => r.is_default === 1);
+    expect(defaults).toHaveLength(1);
+    expect(defaults[0].enabled).toBe(1);
+    expect(getDefaultModelConfig()?.name).not.toBe("dis-a");
+    reset(["dis-a", "dis-b"]);
+  });
+
+  it("refuses to disable the last enabled config", async () => {
+    const { setModelConfigEnabled, listModelConfigs } = await load();
+    for (const r of listModelConfigs()) deleteModelConfig(r.name);
+    upsertModelConfig("only-one", "anthropic", "claude-x", {}, true);
+    expect(() => setModelConfigEnabled("only-one", false)).toThrow(/at least one/i);
+    expect(getModelConfig("only-one")?.enabled).toBe(1);
+    reset(["only-one"]);
+  });
+
+  it("disabled configs are skipped by default fallback and runnable resolution", async () => {
+    const { setModelConfigEnabled, resolveRunnableModelConfig, listEnabledModelConfigs } = await load();
+    upsertModelConfig("run-a", "anthropic", "claude-x", {}, true);
+    upsertModelConfig("run-b", "anthropic", "claude-y", {}, false);
+    setModelConfigEnabled("run-b", false);
+    expect(listEnabledModelConfigs().map((r) => r.name)).not.toContain("run-b");
+    expect(resolveRunnableModelConfig("run-b")?.name).toBe("run-a");
+    setModelConfigEnabled("run-b", true);
+    expect(resolveRunnableModelConfig("run-b")?.name).toBe("run-b");
+    reset(["run-a", "run-b"]);
+  });
+
+  it("making a disabled config the default via upsert re-enables it", async () => {
+    const { setModelConfigEnabled } = await load();
+    upsertModelConfig("up-a", "anthropic", "claude-x", {}, true);
+    upsertModelConfig("up-b", "anthropic", "claude-y", {}, false);
+    setModelConfigEnabled("up-b", false);
+    const row = upsertModelConfig("up-b", "anthropic", "claude-y", {}, true);
+    expect(row.enabled).toBe(1);
+    expect(getDefaultModelConfig()?.name).toBe("up-b");
+    reset(["up-a", "up-b"]);
+  });
+});

package/lib/stores/model-config.ts

@@ -17,6 +17,9 @@ export function withModelConfigMutation<T>(
 export interface ModelConfigRow {
   name: string; provider: string; model_id: string;
   params: string; is_default: number;
+  // ADR-0102: 0 hides the config from model selection, routing, and the
+  // default fallback without deleting it. Optional for rows built in tests.
+  enabled?: number;
   // ADR forthcoming ??? first-class credentials. NULL until the row is
   // explicitly bound (or until the auto-migration in lib/db/migrations.ts
   // lifts an inline api_key into a credential row).
@@ -24,6 +27,16 @@ export interface ModelConfigRow {
   created_at: string; updated_at: string;
 }
 
+export class ModelConfigStateError extends Error {
+  constructor(message: string, readonly status: 404 | 409) {
+    super(message);
+  }
+}
+
+export function isModelConfigEnabled(cfg: Pick<ModelConfigRow, "enabled"> | null | undefined): boolean {
+  return !!cfg && cfg.enabled !== 0;
+}
+
 // `params` holds the provider API key alongside hyperparameters and is
 // stored encrypted at rest (ADR-0005). Decrypt before returning rows.
 function decryptRow<T extends { params: string }>(row: T): T {
@@ -37,6 +50,11 @@ export function listModelConfigs(): ModelConfigRow[] {
   return rows.map(decryptRow);
 }
 
+/** Model configs that may be offered for selection or routing. */
+export function listEnabledModelConfigs(): ModelConfigRow[] {
+  return listModelConfigs().filter(isModelConfigEnabled);
+}
+
 export function getModelConfig(name: string): ModelConfigRow | null {
   const row = (getDb().prepare("SELECT * FROM model_configs WHERE name=?").get(name) as unknown as ModelConfigRow) ?? null;
   return row ? decryptRow(row) : null;
@@ -44,15 +62,77 @@ export function getModelConfig(name: string): ModelConfigRow | null {
 
 export function getDefaultModelConfig(): ModelConfigRow | null {
   const db = getDb();
-  const row = (db.prepare("SELECT * FROM model_configs WHERE is_default=1 LIMIT 1").get() as unknown as ModelConfigRow) ?? null;
+  const row = (db.prepare("SELECT * FROM model_configs WHERE is_default=1 AND enabled=1 LIMIT 1").get() as unknown as ModelConfigRow) ?? null;
   if (row) return decryptRow(row);
-  const fallback = (db.prepare("SELECT * FROM model_configs ORDER BY name ASC LIMIT 1").get() as unknown as ModelConfigRow) ?? null;
+  const fallback = (db.prepare("SELECT * FROM model_configs WHERE enabled=1 ORDER BY name ASC LIMIT 1").get() as unknown as ModelConfigRow) ?? null;
   return fallback ? decryptRow(fallback) : null;
 }
 
+/**
+ * Resolve the config a run should use: the named config when it exists and is
+ * enabled, otherwise the workspace default. A disabled assignment therefore
+ * falls back without being cleared, so re-enabling restores it.
+ */
+export function resolveRunnableModelConfig(name: string | null | undefined): ModelConfigRow | null {
+  const named = name ? getModelConfig(name) : null;
+  if (named && isModelConfigEnabled(named)) return named;
+  return getDefaultModelConfig();
+}
+
+/** Atomically make `name` the only default model config. */
+export function setDefaultModelConfig(name: string): ModelConfigRow {
+  return withDbTransaction(() => {
+    const db = getDb();
+    const target = getModelConfig(name);
+    if (!target) throw new ModelConfigStateError(`Model config "${name}" not found`, 404);
+    if (!isModelConfigEnabled(target)) {
+      throw new ModelConfigStateError(`Model config "${name}" is disabled; enable it before making it the default`, 409);
+    }
+    const t = now();
+    db.prepare("UPDATE model_configs SET is_default=0, updated_at=? WHERE is_default=1 AND name<>?").run(t, name);
+    db.prepare("UPDATE model_configs SET is_default=1, updated_at=? WHERE name=?").run(t, name);
+    return getModelConfig(name)!;
+  });
+}
+
+/**
+ * Enable or disable a model config. Disabling the default promotes the
+ * alphabetically-first other enabled config in the same transaction, and the
+ * last enabled config cannot be disabled so runs always have a model.
+ */
+export function setModelConfigEnabled(name: string, enabled: boolean): ModelConfigRow {
+  return withDbTransaction(() => {
+    const db = getDb();
+    const target = getModelConfig(name);
+    if (!target) throw new ModelConfigStateError(`Model config "${name}" not found`, 404);
+    if (isModelConfigEnabled(target) === enabled) return target;
+    const t = now();
+    if (enabled) {
+      db.prepare("UPDATE model_configs SET enabled=1, updated_at=? WHERE name=?").run(t, name);
+      return getModelConfig(name)!;
+    }
+    const next = db.prepare(
+      "SELECT name FROM model_configs WHERE enabled=1 AND name<>? ORDER BY name ASC LIMIT 1",
+    ).get(name) as { name?: string } | undefined;
+    if (!next?.name) {
+      throw new ModelConfigStateError("At least one model config must stay enabled", 409);
+    }
+    db.prepare("UPDATE model_configs SET enabled=0, is_default=0, updated_at=? WHERE name=?").run(t, name);
+    if (target.is_default === 1) {
+      db.prepare("UPDATE model_configs SET is_default=1, updated_at=? WHERE name=?").run(t, next.name);
+    }
+    return getModelConfig(name)!;
+  });
+}
+
+/**
+ * Insert or update a model config. `is_default` undefined keeps the current
+ * flag (false for new rows); true atomically clears every other default and
+ * re-enables the row, because the default must always be selectable.
+ */
 export function upsertModelConfig(
   name: string, provider: string, model_id: string,
-  params: Record<string, unknown>, is_default: boolean,
+  params: Record<string, unknown>, is_default: boolean | undefined,
   credential_id: string | null = null,
 ): ModelConfigRow {
   return withDbTransaction(() => {
@@ -67,11 +147,13 @@ export function upsertModelConfig(
     // other field a custom provider relies on (e.g. custom-provider.js's
     // username/password auth) on every save.
     const mergedParams = { ...decodeInlineParams(existing), ...params };
+    const finalDefault = is_default ?? existing?.is_default === 1;
+    const finalEnabled = finalDefault || !existing || isModelConfigEnabled(existing);
     const db = getDb();
-    if (is_default) db.prepare("UPDATE model_configs SET is_default=0").run();
+    if (finalDefault) db.prepare("UPDATE model_configs SET is_default=0 WHERE name<>?").run(name);
     db.prepare(
-      "INSERT OR REPLACE INTO model_configs (name,provider,model_id,params,is_default,credential_id,created_at,updated_at) VALUES (?,?,?,?,?,?,?,?)"
-    ).run(name, provider, model_id, encrypt(JSON.stringify(mergedParams)), is_default ? 1 : 0, finalCredId, created_at, t);
+      "INSERT OR REPLACE INTO model_configs (name,provider,model_id,params,is_default,enabled,credential_id,created_at,updated_at) VALUES (?,?,?,?,?,?,?,?,?)"
+    ).run(name, provider, model_id, encrypt(JSON.stringify(mergedParams)), finalDefault ? 1 : 0, finalEnabled ? 1 : 0, finalCredId, created_at, t);
     return getModelConfig(name)!;
   });
 }
@@ -85,10 +167,10 @@ export function deleteModelConfig(name: string): boolean {
     // Automatically reset any agent pointing to this deleted model config to NULL (automatic / default model)
     db.prepare("UPDATE agent_configs SET model_config_name = NULL WHERE model_config_name = ?").run(name);
     // Avoid the "no default" state: if the deleted row was the default and any
-    // other rows remain, promote the alphabetically-first remaining row so
+    // other enabled rows remain, promote the alphabetically-first one so
     // agents that fall back to the default keep working.
     if (wasDefault) {
-      const next = db.prepare("SELECT name FROM model_configs ORDER BY name ASC LIMIT 1").get() as { name?: string } | undefined;
+      const next = db.prepare("SELECT name FROM model_configs WHERE enabled=1 ORDER BY name ASC LIMIT 1").get() as { name?: string } | undefined;
       if (next?.name) db.prepare("UPDATE model_configs SET is_default=1 WHERE name=?").run(next.name);
     }
     return true;

package/lib/stores/threads.test.ts

@@ -692,6 +692,15 @@ describe("thread channel summaries (ADR-0044)", () => {
     expect(getThreadChannelSummary(t.thread_id, "watcher")?.summary).toBe("watcher recap");
     expect(getThreadChannelSummary(t.thread_id, "bridge")?.summary).toBe("bridge recap");
   });
+
+  it("round-trips stored channel topics and clears them when a later commit omits them", () => {
+    const t = createThread("agent-chsum-4");
+    const topics = JSON.stringify([{ title: "Nightly backup", start_seq: 1, end_seq: 2, recap: "r", facts: [], message_count: 2 }]);
+    commitThreadChannelSummary(t.thread_id, "scheduled_task", { summary: "recap", summaryBefore: null, summaryBeforeSeq: 3, topics });
+    expect(getThreadChannelSummary(t.thread_id, "scheduled_task")?.topics).toBe(topics);
+    commitThreadChannelSummary(t.thread_id, "scheduled_task", { summary: "fallback", summaryBefore: null, summaryBeforeSeq: 4 });
+    expect(getThreadChannelSummary(t.thread_id, "scheduled_task")?.topics).toBeNull();
+  });
 });
 
 describe("getRecentlyUsedToolNames", () => {

package/lib/stores/threads.ts

@@ -671,6 +671,8 @@ export interface ThreadChannelSummaryRow {
   summary_before: string | null;
   summary_before_seq: number | null;
   computed_at: string;
+  /** JSON array of SummaryTopicSegment, or null for summaries without topics. */
+  topics: string | null;
 }
 
 // ADR-0044 — one cached warm summary per (thread, automation channel),
@@ -682,27 +684,34 @@ export interface ThreadChannelSummaryRow {
 // hot/warm boundary move, there's no cross-field invariant to protect here.
 export function getThreadChannelSummary(threadId: string, channel: string): ThreadChannelSummaryRow | null {
   return (getDb()
-    .prepare("SELECT thread_id, channel, summary, summary_before, summary_before_seq, computed_at FROM thread_channel_summaries WHERE thread_id=? AND channel=?")
+    .prepare("SELECT thread_id, channel, summary, summary_before, summary_before_seq, computed_at, topics FROM thread_channel_summaries WHERE thread_id=? AND channel=?")
     .get(threadId, channel) as ThreadChannelSummaryRow | undefined) ?? null;
 }
 
+export function listThreadChannelSummaries(threadId: string): ThreadChannelSummaryRow[] {
+  return getDb()
+    .prepare("SELECT thread_id, channel, summary, summary_before, summary_before_seq, computed_at, topics FROM thread_channel_summaries WHERE thread_id=?")
+    .all(threadId) as unknown as ThreadChannelSummaryRow[];
+}
+
 export function commitThreadChannelSummary(
   threadId: string,
   channel: string,
-  input: { summary: string; summaryBefore: string | null; summaryBeforeSeq?: number | null },
+  input: { summary: string; summaryBefore: string | null; summaryBeforeSeq?: number | null; topics?: string | null },
 ): void {
   if (input.summaryBefore !== null && input.summaryBeforeSeq == null) {
     throw new Error("summaryBeforeSeq is required for a boundary summary");
   }
   getDb()
     .prepare(
-      `INSERT INTO thread_channel_summaries (thread_id, channel, summary, summary_before, summary_before_seq, computed_at)
-       VALUES (?, ?, ?, ?, ?, ?)
+      `INSERT INTO thread_channel_summaries (thread_id, channel, summary, summary_before, summary_before_seq, computed_at, topics)
+       VALUES (?, ?, ?, ?, ?, ?, ?)
        ON CONFLICT(thread_id, channel) DO UPDATE SET
          summary=excluded.summary, summary_before=excluded.summary_before,
-         summary_before_seq=excluded.summary_before_seq, computed_at=excluded.computed_at`,
+         summary_before_seq=excluded.summary_before_seq, computed_at=excluded.computed_at,
+         topics=excluded.topics`,
     )
-    .run(threadId, channel, input.summary, input.summaryBefore, input.summaryBeforeSeq ?? null, now());
+    .run(threadId, channel, input.summary, input.summaryBefore, input.summaryBeforeSeq ?? null, now(), input.topics ?? null);
 }
 
 export function touchThread(thread_id: string, firstMsg?: string): void {
@@ -746,7 +755,7 @@ export interface ThreadWarmContextCommit {
   /** Reject the commit if another compactor refreshed the same boundary. */
   expectedWarmSummary?: string | null;
   autoBoundaryLockedUntilMessageCount?: number;
-  channelSummaries?: Array<{ channel: string; summary: string }>;
+  channelSummaries?: Array<{ channel: string; summary: string; topics?: string | null }>;
 }
 
 // A warm recap is only valid for the exact boundary it replaced. Commit both
@@ -790,14 +799,15 @@ export function commitThreadWarmContext(
       thread_id,
     );
     const upsertChannel = db.prepare(
-      `INSERT INTO thread_channel_summaries (thread_id, channel, summary, summary_before, summary_before_seq, computed_at)
-       VALUES (?, ?, ?, ?, ?, ?)
+      `INSERT INTO thread_channel_summaries (thread_id, channel, summary, summary_before, summary_before_seq, computed_at, topics)
+       VALUES (?, ?, ?, ?, ?, ?, ?)
        ON CONFLICT(thread_id, channel) DO UPDATE SET
          summary=excluded.summary, summary_before=excluded.summary_before,
-         summary_before_seq=excluded.summary_before_seq, computed_at=excluded.computed_at`,
+         summary_before_seq=excluded.summary_before_seq, computed_at=excluded.computed_at,
+         topics=excluded.topics`,
     );
     for (const channelSummary of input.channelSummaries ?? []) {
-      upsertChannel.run(thread_id, channelSummary.channel, channelSummary.summary, input.hotSince, hotSinceSeq, now());
+      upsertChannel.run(thread_id, channelSummary.channel, channelSummary.summary, input.hotSince, hotSinceSeq, now(), channelSummary.topics ?? null);
     }
     db.exec("COMMIT");
     return getThread(thread_id);