umbrella-context 0.1.40 → 0.1.41

package/README.md

@@ -52,6 +52,16 @@ The setup flow will:
 ```bash
 umbrella-context query "What do we already know?"
 umbrella-context curate "We learned that..."
+umbrella-context swarm onboard
+umbrella-context swarm status
+umbrella-context swarm query "How are auth cookies refreshed?"
+umbrella-context swarm curate "JWT refresh notes"
+umbrella-context worktree add ../other-checkout
+umbrella-context worktree list
+umbrella-context source add ../shared-lib --alias shared-lib
+umbrella-context source list
+umbrella-context adaptive refresh
+umbrella-context adaptive status
 umbrella-context push
 umbrella-context pull
 umbrella-context fix "ETIMEDOUT"
@@ -61,3 +71,73 @@ umbrella-context
 
 The old `agent-memory` command still works as a compatibility alias.
 The short `um` command works too.
+
+## Swarm
+
+Swarm lets one repo search more than just its own saved Context.
+
+Think of it like this:
+- `umbrella-context query` searches Umbrella Context
+- `umbrella-context swarm query` searches Umbrella Context plus any extra note folders you connected
+
+Typical flow:
+
+```bash
+umbrella-context swarm onboard
+umbrella-context swarm status
+umbrella-context swarm query "How do auth cookies refresh?"
+umbrella-context swarm curate "New JWT refresh notes"
+```
+
+Right now this version supports:
+- Umbrella Context
+- read-only Umbrella repo sources linked with `source add`
+- Obsidian vaults
+- local markdown folders
+- GBrain-style markdown folders
+- Memory Wiki folders
+
+## Worktrees and Sources
+
+Use `worktree` when one Umbrella repo has more than one checkout or sub-worktree:
+
+```bash
+umbrella-context worktree add ../other-checkout
+umbrella-context worktree list
+umbrella-context worktree remove ../other-checkout
+```
+
+Use `source` when you want this repo to read another Umbrella repo as a read-only knowledge source:
+
+```bash
+umbrella-context source add ../shared-lib --alias shared-lib
+umbrella-context source list
+umbrella-context source remove shared-lib
+```
+
+Those sources automatically show up inside swarm queries.
+
+## Adaptive Knowledge
+
+Adaptive knowledge keeps lightweight `.abstract.md` and `.overview.md` files inside `.um/adaptive/`.
+It also tracks which saved notes get reused the most, so frequently helpful notes can rise over time.
+
+```bash
+umbrella-context adaptive refresh
+umbrella-context adaptive status
+umbrella-context query "How is authentication implemented?" --timeout 900
+```
+
+`--timeout` lets longer provider-backed queries wait longer before failing.
+
+## Claude Desktop Connector
+
+Claude Desktop is now available as a first-class connector:
+
+```bash
+umbrella-context connectors install claude-desktop-mcp
+umbrella-context connectors run claude-desktop-mcp
+```
+
+On Windows and macOS, this writes Claude Desktop's MCP config so Claude can talk to `umbrella-context mcp`.
+After install, fully quit Claude Desktop from the tray or menu bar, then reopen it.

package/dist/adapters/byterover-runtime-bridge.js

@@ -157,38 +157,50 @@ async function buildSpaceSnapshot(cwd = process.cwd()) {
     const repoContext = await getRepoContext(cwd);
     const config = configManager.config;
     if (!config?.umbrellaUrl) {
+        return buildFallbackSpaceSnapshot(null, repoContext.state ?? null);
+    }
+    try {
+        const summary = await getCompanyContextSummary(config.umbrellaUrl, config.companyId);
+        const spaces = toContextSpaces(summary);
         return {
-            activeSpaceId: repoContext.state?.projectId ?? null,
-            activeSpaceName: repoContext.state?.projectName ?? null,
-            companyId: repoContext.state?.companyId ?? null,
-            companyName: repoContext.state?.companyName ?? null,
+            activeSpaceId: config.projectId,
+            activeSpaceName: config.projectName,
+            companyId: config.companyId,
+            companyName: config.companyName,
             isLoading: false,
-            spaces: repoContext.state
-                ? [
-                    {
-                        id: repoContext.state.projectId,
-                        isPrimary: true,
-                        isSelected: true,
-                        name: repoContext.state.projectName,
-                    },
-                ]
-                : [],
+            spaces: spaces.map((space) => ({
+                id: space.id,
+                isPrimary: space.isPrimary,
+                isSelected: space.id === config.projectId,
+                name: space.name,
+            })),
         };
     }
-    const summary = await getCompanyContextSummary(config.umbrellaUrl, config.companyId);
-    const spaces = toContextSpaces(summary);
+    catch {
+        return buildFallbackSpaceSnapshot(config, repoContext.state ?? null);
+    }
+}
+function buildFallbackSpaceSnapshot(config, repoState) {
+    const companyId = config?.companyId ?? repoState?.companyId ?? null;
+    const companyName = config?.companyName ?? repoState?.companyName ?? null;
+    const projectId = config?.projectId ?? repoState?.projectId ?? null;
+    const projectName = config?.projectName ?? repoState?.projectName ?? null;
     return {
-        activeSpaceId: config.projectId,
-        activeSpaceName: config.projectName,
-        companyId: config.companyId,
-        companyName: config.companyName,
+        activeSpaceId: projectId,
+        activeSpaceName: projectName,
+        companyId,
+        companyName,
         isLoading: false,
-        spaces: spaces.map((space) => ({
-            id: space.id,
-            isPrimary: space.isPrimary,
-            isSelected: space.id === config.projectId,
-            name: space.name,
-        })),
+        spaces: projectId && projectName
+            ? [
+                {
+                    id: projectId,
+                    isPrimary: true,
+                    isSelected: true,
+                    name: projectName,
+                },
+            ]
+            : [],
     };
 }
 async function buildHubSnapshot(cwd = process.cwd()) {
@@ -217,8 +229,8 @@ async function buildConnectorsSnapshot(cwd = process.cwd()) {
     };
 }
 export async function buildVendorRuntimeBridgeSnapshot(cwd = process.cwd()) {
-    const [repoContext, pending, pulled, fixes, hubEntries, connectors, connectorRuns, localTasks, transport, contextTree, providerStore, modelStore, spaceStore, hubStore, connectorsStore,] = await Promise.all([
-        getRepoContext(cwd),
+    const baseRepoContext = await getRepoContext(cwd);
+    const [pending, pulled, fixes, hubEntries, connectors, connectorRuns, localTasks, transport, contextTree, providerStore, modelStore, spaceStore, hubStore, connectorsStore,] = await Promise.all([
         getPendingMemories(cwd),
         getPulledMemories(cwd),
         getPulledFixes(cwd),
@@ -230,7 +242,7 @@ export async function buildVendorRuntimeBridgeSnapshot(cwd = process.cwd()) {
         getContextTreeState(cwd),
         buildProviderSnapshot(),
         buildModelSnapshot(),
-        buildSpaceSnapshot(cwd),
+        buildSpaceSnapshot(cwd).catch(() => buildFallbackSpaceSnapshot(configManager.config, baseRepoContext.state ?? null)),
         buildHubSnapshot(cwd),
         buildConnectorsSnapshot(cwd),
     ]);
@@ -243,16 +255,16 @@ export async function buildVendorRuntimeBridgeSnapshot(cwd = process.cwd()) {
     };
     return {
         company: {
-            id: repoContext.state?.companyId ?? null,
-            name: repoContext.state?.companyName ?? null,
+            id: baseRepoContext.state?.companyId ?? null,
+            name: baseRepoContext.state?.companyName ?? null,
         },
         generatedAt: new Date().toISOString(),
         repo: {
             pendingDrafts: pending.length,
             pulledContext: pulled.length,
             pulledFixes: fixes.length,
-            repoRoot: repoContext.repoRoot,
-            umDir: repoContext.umDir,
+            repoRoot: baseRepoContext.repoRoot,
+            umDir: baseRepoContext.umDir,
         },
         services: {
             activeModel: configManager.config?.activeModel ?? null,
@@ -262,8 +274,8 @@ export async function buildVendorRuntimeBridgeSnapshot(cwd = process.cwd()) {
             hubEntriesInstalled: hubEntries.length,
         },
         space: {
-            id: repoContext.state?.projectId ?? null,
-            name: repoContext.state?.projectName ?? null,
+            id: baseRepoContext.state?.projectId ?? null,
+            name: baseRepoContext.state?.projectName ?? null,
         },
         stores: {
             connectors: connectorsStore,

package/dist/adapters/umbrella-provider-runtime.d.ts

@@ -1,14 +1,21 @@
 import { type SavedProvider } from "../config.js";
-export declare const UMBRELLA_PROVIDER_CHOICES: Array<{
+export type ProviderChoice = {
     kind: string;
     name: string;
-}>;
+    description: string;
+    suggestedLabel: string;
+    baseUrl?: string;
+    requiresBaseUrlInput?: boolean;
+    exampleModels: string[];
+};
+export declare const UMBRELLA_PROVIDER_CHOICES: ProviderChoice[];
 export type ProviderConnectDraft = {
     apiKey: string;
     baseUrl: string;
     kind: string | null;
     label: string;
 };
+export declare function getProviderChoice(kind?: string | null): ProviderChoice | null;
 export declare function createEmptyProviderConnectDraft(): ProviderConnectDraft;
 export declare function resolveSavedProvider(target?: string | null): SavedProvider | null;
 export declare function getActiveSavedProvider(): SavedProvider | null;

package/dist/adapters/umbrella-provider-runtime.js

@@ -2,12 +2,90 @@ import { randomUUID } from "crypto";
 import { configManager } from "../config.js";
 import { getSessionState, recordSessionEvent, recordSessionProvider, setSessionPanel } from "../repo-state.js";
 export const UMBRELLA_PROVIDER_CHOICES = [
-    { kind: "anthropic", name: "Anthropic" },
-    { kind: "openai", name: "OpenAI" },
-    { kind: "google", name: "Google" },
-    { kind: "openrouter", name: "OpenRouter" },
-    { kind: "openai-compatible", name: "OpenAI-Compatible" },
+    {
+        kind: "openai",
+        name: "OpenAI / Codex",
+        description: "Best when you want OpenAI models like GPT-5 and Codex-style coding workflows.",
+        suggestedLabel: "OpenAI",
+        exampleModels: ["gpt-5.4", "gpt-5.4-mini", "gpt-5"],
+    },
+    {
+        kind: "anthropic",
+        name: "Anthropic",
+        description: "Claude models for strong reasoning and coding.",
+        suggestedLabel: "Anthropic",
+        exampleModels: ["claude-sonnet-4-6", "claude-opus-4-6", "claude-haiku-4-5"],
+    },
+    {
+        kind: "google",
+        name: "Google Gemini",
+        description: "Gemini models through Google's API.",
+        suggestedLabel: "Google Gemini",
+        baseUrl: "https://generativelanguage.googleapis.com/v1beta/openai/",
+        exampleModels: ["gemini-2.5-pro", "gemini-2.5-flash"],
+    },
+    {
+        kind: "openrouter",
+        name: "OpenRouter",
+        description: "One provider that can route to many model families.",
+        suggestedLabel: "OpenRouter",
+        baseUrl: "https://openrouter.ai/api/v1",
+        exampleModels: ["openai/gpt-5", "anthropic/claude-sonnet-4-6", "google/gemini-2.5-pro"],
+    },
+    {
+        kind: "minimax",
+        name: "MiniMax",
+        description: "MiniMax coding and chat models through its OpenAI-compatible endpoint.",
+        suggestedLabel: "MiniMax",
+        baseUrl: "https://api.minimax.io/v1",
+        exampleModels: ["MiniMax-M2.7", "MiniMax-M2.5", "custom-model"],
+    },
+    {
+        kind: "groq",
+        name: "Groq",
+        description: "Fast OpenAI-compatible inference for supported models.",
+        suggestedLabel: "Groq",
+        baseUrl: "https://api.groq.com/openai/v1",
+        exampleModels: ["custom-model"],
+    },
+    {
+        kind: "together",
+        name: "Together AI",
+        description: "OpenAI-compatible access to many open coding models.",
+        suggestedLabel: "Together AI",
+        baseUrl: "https://api.together.xyz/v1",
+        exampleModels: ["custom-model"],
+    },
+    {
+        kind: "deepseek",
+        name: "DeepSeek",
+        description: "DeepSeek reasoning and chat models through its compatible endpoint.",
+        suggestedLabel: "DeepSeek",
+        baseUrl: "https://api.deepseek.com",
+        exampleModels: ["deepseek-chat", "deepseek-reasoner", "custom-model"],
+    },
+    {
+        kind: "fireworks",
+        name: "Fireworks AI",
+        description: "OpenAI-compatible hosted inference for many model families.",
+        suggestedLabel: "Fireworks AI",
+        baseUrl: "https://api.fireworks.ai/inference/v1",
+        exampleModels: ["custom-model"],
+    },
+    {
+        kind: "openai-compatible",
+        name: "Custom OpenAI-Compatible",
+        description: "Use this when your provider gives you an OpenAI-compatible base URL that is not listed here.",
+        suggestedLabel: "Custom Compatible",
+        requiresBaseUrlInput: true,
+        exampleModels: ["custom-model"],
+    },
 ];
+export function getProviderChoice(kind) {
+    if (!kind)
+        return null;
+    return UMBRELLA_PROVIDER_CHOICES.find((entry) => entry.kind === kind) ?? null;
+}
 export function createEmptyProviderConnectDraft() {
     return {
         apiKey: "",
@@ -60,18 +138,19 @@ export async function connectSavedProviderFromDraft(draft) {
     const nextKey = draft.apiKey.trim();
     const nextKind = draft.kind ?? "openai";
     const nextBaseUrl = draft.baseUrl.trim();
+    const choice = getProviderChoice(nextKind);
     if (!nextLabel) {
         throw new Error("Type a provider label first.");
     }
     if (!nextKey) {
         throw new Error("Paste an API key first.");
     }
-    if (nextKind === "openai-compatible" && !nextBaseUrl) {
+    if ((choice?.requiresBaseUrlInput || nextKind === "openai-compatible") && !nextBaseUrl) {
         throw new Error("Type the compatible base URL first.");
     }
     const provider = {
         apiKey: nextKey,
-        baseUrl: nextKind === "openai-compatible" ? nextBaseUrl : undefined,
+        baseUrl: nextBaseUrl || choice?.baseUrl || undefined,
         id: randomUUID(),
         kind: nextKind,
         name: nextLabel,

package/dist/adaptive/runtime.d.ts

@@ -0,0 +1,27 @@
+export type AdaptiveKnowledgeEntry = {
+    abstractPath: string;
+    consultationCount: number;
+    hotness: number;
+    id: string;
+    lastConsultedAt: string | null;
+    overviewPath: string;
+    sourceLabel: string;
+    title: string;
+    updatedAt: string;
+};
+export type AdaptiveKnowledgeState = {
+    entries: Record<string, AdaptiveKnowledgeEntry>;
+    generatedAt: string;
+    sessionPatternsPath?: string | null;
+    version: 1;
+};
+export declare function loadAdaptiveKnowledgeState(cwd?: string): Promise<AdaptiveKnowledgeState>;
+export declare function refreshAdaptiveKnowledge(cwd?: string): Promise<AdaptiveKnowledgeState>;
+export declare function recordAdaptiveConsultations(memoryIds: string[], cwd?: string): Promise<AdaptiveKnowledgeState>;
+export declare function getAdaptiveKnowledgeBoost(memoryId: string, cwd?: string): Promise<number>;
+export declare function getAdaptiveKnowledgeSummary(cwd?: string): Promise<{
+    generatedAt: string;
+    entryCount: number;
+    hottestEntries: AdaptiveKnowledgeEntry[];
+    sessionPatternsPath: string | null;
+}>;

package/dist/adaptive/runtime.js

@@ -0,0 +1,154 @@
+import { promises as fs } from "fs";
+import path from "path";
+import { getPendingMemories, getPulledMemories, getRepoContext, getSessionState, } from "../repo-state.js";
+const ADAPTIVE_DIR = "adaptive";
+const ADAPTIVE_STATE_FILE = "knowledge.json";
+function sanitizeFileName(value) {
+    return (value
+        .toLowerCase()
+        .replace(/[^\w-]+/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 48) || "note");
+}
+function pickTitle(entry) {
+    const firstLine = entry.content.split(/\r?\n/).find((line) => line.trim().length > 0)?.trim() ?? "Untitled note";
+    return firstLine.length > 80 ? `${firstLine.slice(0, 77).trim()}...` : firstLine;
+}
+function buildAbstract(entry) {
+    const compact = entry.content.replace(/\s+/g, " ").trim();
+    return compact.length > 220 ? `${compact.slice(0, 217).trim()}...` : compact;
+}
+function buildOverview(entry) {
+    const lines = [
+        `# ${pickTitle(entry)}`,
+        "",
+        `- Source: ${entry.source}`,
+        `- System type: ${entry.systemType}`,
+        `- Access: ${entry.accessLevel}`,
+        `- Category: ${entry.category ?? "uncategorized"}`,
+        `- Tags: ${entry.tags.length > 0 ? entry.tags.join(", ") : "none"}`,
+        `- Keywords: ${entry.keywords.length > 0 ? entry.keywords.join(", ") : "none"}`,
+        `- Created: ${entry.createdAt}`,
+        "",
+        "## Abstract",
+        "",
+        buildAbstract(entry),
+        "",
+    ];
+    return lines.join("\n");
+}
+async function ensureAdaptiveDir(cwd = process.cwd()) {
+    const { repoRoot } = await getRepoContext(cwd);
+    const dir = path.join(repoRoot, ".um", ADAPTIVE_DIR);
+    await fs.mkdir(dir, { recursive: true });
+    return dir;
+}
+async function getAdaptiveStatePath(cwd = process.cwd()) {
+    return path.join(await ensureAdaptiveDir(cwd), ADAPTIVE_STATE_FILE);
+}
+async function readJsonFile(filePath, fallback) {
+    try {
+        return JSON.parse(await fs.readFile(filePath, "utf8"));
+    }
+    catch {
+        return fallback;
+    }
+}
+async function writeJsonFile(filePath, value) {
+    await fs.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+export async function loadAdaptiveKnowledgeState(cwd = process.cwd()) {
+    const raw = await readJsonFile(await getAdaptiveStatePath(cwd), null);
+    return raw ?? {
+        version: 1,
+        generatedAt: new Date(0).toISOString(),
+        entries: {},
+        sessionPatternsPath: null,
+    };
+}
+export async function refreshAdaptiveKnowledge(cwd = process.cwd()) {
+    const adaptiveDir = await ensureAdaptiveDir(cwd);
+    const state = await loadAdaptiveKnowledgeState(cwd);
+    const session = await getSessionState(cwd);
+    const entries = [...(await getPendingMemories(cwd)), ...(await getPulledMemories(cwd))];
+    const nextEntries = {};
+    for (const entry of entries) {
+        const title = pickTitle(entry);
+        const safeBase = `${sanitizeFileName(title)}-${entry.id.slice(0, 8)}`;
+        const abstractPath = path.join(adaptiveDir, `${safeBase}.abstract.md`);
+        const overviewPath = path.join(adaptiveDir, `${safeBase}.overview.md`);
+        await fs.writeFile(abstractPath, `${buildAbstract(entry)}\n`, "utf8");
+        await fs.writeFile(overviewPath, buildOverview(entry), "utf8");
+        const previous = state.entries[entry.id];
+        nextEntries[entry.id] = {
+            id: entry.id,
+            title,
+            sourceLabel: entry.source,
+            abstractPath,
+            overviewPath,
+            consultationCount: previous?.consultationCount ?? 0,
+            hotness: previous?.hotness ?? 0,
+            lastConsultedAt: previous?.lastConsultedAt ?? null,
+            updatedAt: new Date().toISOString(),
+        };
+    }
+    const sessionPatternsPath = path.join(adaptiveDir, "session-patterns.md");
+    const recentQueries = session?.recentQueries.slice(0, 5) ?? [];
+    const recentCurations = session?.recentCurations.slice(0, 5) ?? [];
+    const patternLines = [
+        "# Session Patterns",
+        "",
+        "## Recent questions",
+        "",
+        ...(recentQueries.length > 0 ? recentQueries.map((query, index) => `${index + 1}. ${query}`) : ["No recent questions yet."]),
+        "",
+        "## Recent curations",
+        "",
+        ...(recentCurations.length > 0
+            ? recentCurations.map((entry, index) => `${index + 1}. ${entry.replace(/\s+/g, " ").trim()}`)
+            : ["No recent curations yet."]),
+        "",
+    ];
+    await fs.writeFile(sessionPatternsPath, `${patternLines.join("\n")}\n`, "utf8");
+    const nextState = {
+        version: 1,
+        generatedAt: new Date().toISOString(),
+        entries: nextEntries,
+        sessionPatternsPath,
+    };
+    await writeJsonFile(await getAdaptiveStatePath(cwd), nextState);
+    return nextState;
+}
+export async function recordAdaptiveConsultations(memoryIds, cwd = process.cwd()) {
+    if (memoryIds.length === 0)
+        return loadAdaptiveKnowledgeState(cwd);
+    const uniqueIds = [...new Set(memoryIds)];
+    const state = await refreshAdaptiveKnowledge(cwd);
+    const now = new Date().toISOString();
+    for (const id of uniqueIds) {
+        const entry = state.entries[id];
+        if (!entry)
+            continue;
+        entry.consultationCount += 1;
+        entry.hotness = Number((entry.hotness * 0.82 + 1).toFixed(4));
+        entry.lastConsultedAt = now;
+        entry.updatedAt = now;
+    }
+    await writeJsonFile(await getAdaptiveStatePath(cwd), state);
+    return state;
+}
+export async function getAdaptiveKnowledgeBoost(memoryId, cwd = process.cwd()) {
+    const state = await loadAdaptiveKnowledgeState(cwd);
+    return state.entries[memoryId]?.hotness ?? 0;
+}
+export async function getAdaptiveKnowledgeSummary(cwd = process.cwd()) {
+    const state = await loadAdaptiveKnowledgeState(cwd);
+    const entries = Object.values(state.entries).sort((left, right) => right.hotness - left.hotness);
+    return {
+        generatedAt: state.generatedAt,
+        entryCount: entries.length,
+        hottestEntries: entries.slice(0, 3),
+        sessionPatternsPath: state.sessionPatternsPath ?? null,
+    };
+}

package/dist/commands/adaptive.d.ts

@@ -0,0 +1,7 @@
+export declare function adaptiveStatusCommandAction(opts?: {
+    format?: string;
+}): Promise<void>;
+export declare function adaptiveRefreshCommandAction(opts?: {
+    format?: string;
+}): Promise<void>;
+export declare function adaptiveCommand(cli: any): void;

package/dist/commands/adaptive.js

@@ -0,0 +1,92 @@
+import chalk from "chalk";
+import { getAdaptiveKnowledgeSummary, refreshAdaptiveKnowledge } from "../adaptive/runtime.js";
+import { recordSessionEvent, setSessionPanel } from "../repo-state.js";
+function asOutputFormat(value) {
+    return value === "json" ? "json" : "text";
+}
+export async function adaptiveStatusCommandAction(opts = {}) {
+    const format = asOutputFormat(opts.format);
+    try {
+        await setSessionPanel("session", "adaptive-status");
+        const summary = await getAdaptiveKnowledgeSummary();
+        if (format === "json") {
+            console.log(JSON.stringify({ ok: true, action: "adaptive.status", ...summary }, null, 2));
+            return;
+        }
+        console.log(chalk.bold("\n Adaptive Knowledge\n"));
+        console.log(` Entries with abstracts: ${summary.entryCount}`);
+        console.log(` Last refresh: ${summary.generatedAt}`);
+        console.log(` Session patterns file: ${summary.sessionPatternsPath ?? "Not generated yet"}`);
+        console.log("");
+        if (summary.hottestEntries.length === 0) {
+            console.log(chalk.yellow("No adaptive entries have been generated yet. Run 'umbrella-context adaptive refresh' first."));
+            return;
+        }
+        console.log(chalk.bold(" Hottest notes"));
+        summary.hottestEntries.forEach((entry, index) => {
+            console.log(` - ${index + 1}. ${entry.title} (hotness ${entry.hotness.toFixed(2)}, consultations ${entry.consultationCount})`);
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (format === "json") {
+            console.log(JSON.stringify({ ok: false, action: "adaptive.status", error: message }, null, 2));
+            return;
+        }
+        console.log(chalk.red(`\n ${message}`));
+    }
+}
+export async function adaptiveRefreshCommandAction(opts = {}) {
+    const format = asOutputFormat(opts.format);
+    try {
+        await setSessionPanel("session", "adaptive-refresh");
+        const state = await refreshAdaptiveKnowledge();
+        await recordSessionEvent({
+            kind: "session",
+            title: "Refreshed adaptive knowledge",
+            detail: `Generated adaptive artifacts for ${Object.keys(state.entries).length} note${Object.keys(state.entries).length === 1 ? "" : "s"}.`,
+            panel: "session",
+            focus: "adaptive-refresh",
+            status: "success",
+        });
+        if (format === "json") {
+            console.log(JSON.stringify({
+                ok: true,
+                action: "adaptive.refresh",
+                entryCount: Object.keys(state.entries).length,
+                generatedAt: state.generatedAt,
+                sessionPatternsPath: state.sessionPatternsPath ?? null,
+            }, null, 2));
+            return;
+        }
+        console.log(chalk.green(`\n Refreshed adaptive knowledge for ${Object.keys(state.entries).length} note${Object.keys(state.entries).length === 1 ? "" : "s"}.`));
+        console.log(chalk.gray(` Session patterns: ${state.sessionPatternsPath ?? "none"}`));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (format === "json") {
+            console.log(JSON.stringify({ ok: false, action: "adaptive.refresh", error: message }, null, 2));
+            return;
+        }
+        console.log(chalk.red(`\n ${message}`));
+    }
+}
+export function adaptiveCommand(cli) {
+    cli
+        .command("adaptive <action>", "Inspect and refresh adaptive knowledge artifacts for this repo")
+        .example("adaptive status")
+        .example("adaptive refresh")
+        .option("--format <format>", "Output format (text or json)")
+        .action(async (action, opts) => {
+        const normalized = action.trim().toLowerCase();
+        if (normalized === "status") {
+            await adaptiveStatusCommandAction(opts);
+            return;
+        }
+        if (normalized === "refresh") {
+            await adaptiveRefreshCommandAction(opts);
+            return;
+        }
+        console.log(chalk.red("Use one of: adaptive status, adaptive refresh"));
+    });
+}