umbrella-context 0.1.2 → 0.1.32

package/dist/adapters/byterover-transport-task-store.js

@@ -0,0 +1,50 @@
+import { create } from "zustand";
+import { buildVendorRuntimeBridgeSnapshot, } from "./byterover-runtime-bridge.js";
+const emptyTasksState = {
+    recentTaskIds: [],
+    stats: {
+        cancelled: 0,
+        completed: 0,
+        created: 0,
+        error: 0,
+        started: 0,
+    },
+    tasks: {},
+};
+const initialTransportTaskState = {
+    generatedAt: null,
+    isHydrated: false,
+    taskStore: emptyTasksState,
+    transportStore: null,
+};
+export const useUmbrellaTransportTaskBridgeStore = create()((set) => ({
+    ...initialTransportTaskState,
+    hydrateFromSnapshot: (snapshot) => set({
+        generatedAt: snapshot.generatedAt,
+        isHydrated: true,
+        taskStore: snapshot.stores.tasks,
+        transportStore: snapshot.stores.transport,
+    }),
+    reset: () => set(initialTransportTaskState),
+}));
+export function hydrateUmbrellaTransportTaskBridgeFromSnapshot(snapshot) {
+    useUmbrellaTransportTaskBridgeStore.getState().hydrateFromSnapshot(snapshot);
+}
+export async function hydrateUmbrellaTransportTaskBridge(cwd = process.cwd()) {
+    const snapshot = await buildVendorRuntimeBridgeSnapshot(cwd);
+    hydrateUmbrellaTransportTaskBridgeFromSnapshot(snapshot);
+    return snapshot;
+}
+export function getUmbrellaTransportTaskBridgeSummary() {
+    const state = useUmbrellaTransportTaskBridgeStore.getState();
+    const transport = state.transportStore;
+    return {
+        activeTaskId: transport?.queue[0]?.id ?? transport?.queue.find((item) => item.status === "running")?.id ?? null,
+        generatedAt: state.generatedAt,
+        isHydrated: state.isHydrated,
+        queueDepth: transport?.queue.length ?? 0,
+        recentTaskCount: state.taskStore.recentTaskIds.length,
+        startedTasks: state.taskStore.stats.started,
+        transportStatus: transport?.status ?? "idle",
+    };
+}

package/dist/adapters/umbrella-onboarding.d.ts

@@ -0,0 +1,27 @@
+import { type UmbrellaCliSetup, type UmbrellaCompany, type UmbrellaContextSpace } from "../umbrella.js";
+export type UmbrellaOnboardingServerCheck = {
+    companies: UmbrellaCompany[];
+    deploymentMode: "authenticated" | "local_trusted";
+    serverUrl: string;
+};
+export type UmbrellaOnboardingSignInResult = {
+    companies: UmbrellaCompany[];
+    cookie: string | null;
+    serverUrl: string;
+};
+export type UmbrellaOnboardingCompanyResult = {
+    company: UmbrellaCompany;
+    spaces: UmbrellaContextSpace[];
+};
+export type UmbrellaOnboardingSpaceResult = {
+    activeSpaceId: string | null;
+    spaces: UmbrellaContextSpace[];
+};
+export declare function normalizeUmbrellaServerUrl(value: string): string;
+export declare function checkUmbrellaOnboardingServer(serverUrl: string): Promise<UmbrellaOnboardingServerCheck>;
+export declare function signInUmbrellaOnboarding(serverUrl: string, email: string, password: string): Promise<UmbrellaOnboardingSignInResult>;
+export declare function loadUmbrellaOnboardingSpaces(serverUrl: string, companyId: string, cookie?: string | null): Promise<UmbrellaContextSpace[]>;
+export declare function createUmbrellaOnboardingCompany(serverUrl: string, name: string, cookie?: string | null): Promise<UmbrellaOnboardingCompanyResult>;
+export declare function createUmbrellaOnboardingSpace(serverUrl: string, companyId: string, name: string, cookie?: string | null): Promise<UmbrellaOnboardingSpaceResult>;
+export declare function saveUmbrellaDeviceLink(setup: UmbrellaCliSetup, umbrellaUrl: string, cwd?: string): Promise<void>;
+export declare function connectUmbrellaDevice(serverUrl: string, companyId: string, spaceId?: string | null, cookie?: string | null, cwd?: string): Promise<UmbrellaCliSetup>;

package/dist/adapters/umbrella-onboarding.js

@@ -0,0 +1,79 @@
+import { configManager } from "../config.js";
+import { ensureRepoContext } from "../repo-state.js";
+import { createContextSpace, createUmbrellaCompany, getCliSetup, getCompanyContextSummary, getUmbrellaHealth, listUmbrellaCompanies, signInToUmbrella, toContextSpaces, } from "../umbrella.js";
+export function normalizeUmbrellaServerUrl(value) {
+    return value.trim().replace(/\/+$/, "");
+}
+export async function checkUmbrellaOnboardingServer(serverUrl) {
+    const normalizedServerUrl = normalizeUmbrellaServerUrl(serverUrl);
+    const health = await getUmbrellaHealth(normalizedServerUrl);
+    if (health.deploymentMode === "authenticated") {
+        return {
+            companies: [],
+            deploymentMode: "authenticated",
+            serverUrl: normalizedServerUrl,
+        };
+    }
+    const companies = await listUmbrellaCompanies(normalizedServerUrl);
+    return {
+        companies,
+        deploymentMode: "local_trusted",
+        serverUrl: normalizedServerUrl,
+    };
+}
+export async function signInUmbrellaOnboarding(serverUrl, email, password) {
+    const normalizedServerUrl = normalizeUmbrellaServerUrl(serverUrl);
+    const session = await signInToUmbrella(normalizedServerUrl, email, password);
+    const companies = await listUmbrellaCompanies(normalizedServerUrl, session.cookie);
+    return {
+        companies,
+        cookie: session.cookie,
+        serverUrl: normalizedServerUrl,
+    };
+}
+export async function loadUmbrellaOnboardingSpaces(serverUrl, companyId, cookie) {
+    const summary = await getCompanyContextSummary(normalizeUmbrellaServerUrl(serverUrl), companyId, cookie);
+    return toContextSpaces(summary);
+}
+export async function createUmbrellaOnboardingCompany(serverUrl, name, cookie) {
+    const normalizedServerUrl = normalizeUmbrellaServerUrl(serverUrl);
+    const company = await createUmbrellaCompany(normalizedServerUrl, name, cookie);
+    const spaces = await loadUmbrellaOnboardingSpaces(normalizedServerUrl, company.id, cookie);
+    return { company, spaces };
+}
+export async function createUmbrellaOnboardingSpace(serverUrl, companyId, name, cookie) {
+    const normalizedServerUrl = normalizeUmbrellaServerUrl(serverUrl);
+    const summary = await createContextSpace(normalizedServerUrl, companyId, name, cookie);
+    return {
+        activeSpaceId: summary.activeProjectId,
+        spaces: toContextSpaces(summary),
+    };
+}
+export async function saveUmbrellaDeviceLink(setup, umbrellaUrl, cwd = process.cwd()) {
+    configManager.set({
+        umbrellaUrl,
+        serverUrl: setup.baseUrl,
+        companyId: setup.companyId,
+        companyName: setup.companyName,
+        workspaceId: setup.workspaceId,
+        workspaceName: setup.workspaceName,
+        projectId: setup.activeSpaceId,
+        projectName: setup.activeSpaceName,
+        apiKey: setup.apiKey,
+    });
+    configManager.upsertLocation({
+        repoRoot: cwd,
+        companyId: setup.companyId,
+        companyName: setup.companyName,
+        projectId: setup.activeSpaceId,
+        projectName: setup.activeSpaceName,
+        updatedAt: new Date().toISOString(),
+    });
+    await ensureRepoContext(configManager.config);
+}
+export async function connectUmbrellaDevice(serverUrl, companyId, spaceId, cookie, cwd = process.cwd()) {
+    const normalizedServerUrl = normalizeUmbrellaServerUrl(serverUrl);
+    const setup = await getCliSetup(normalizedServerUrl, companyId, spaceId, cookie);
+    await saveUmbrellaDeviceLink(setup, normalizedServerUrl, cwd);
+    return setup;
+}

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

@@ -0,0 +1,38 @@
+import { type SavedProvider } from "../config.js";
+export declare const UMBRELLA_PROVIDER_CHOICES: Array<{
+    kind: string;
+    name: string;
+}>;
+export type ProviderConnectDraft = {
+    apiKey: string;
+    baseUrl: string;
+    kind: string | null;
+    label: string;
+};
+export declare function createEmptyProviderConnectDraft(): ProviderConnectDraft;
+export declare function resolveSavedProvider(target?: string | null): SavedProvider | null;
+export declare function getActiveSavedProvider(): SavedProvider | null;
+export declare function getProviderRuntimeReadiness(): {
+    activeModel: string | null;
+    activeProvider: SavedProvider | null;
+    modelReady: boolean;
+    providerReady: boolean;
+};
+export declare function buildProviderDraftValue(draft: ProviderConnectDraft, mode: "connect-base-url" | "connect-key" | "connect-label"): string;
+export declare function updateProviderDraftValue(draft: ProviderConnectDraft, mode: "connect-base-url" | "connect-key" | "connect-label", value: string): ProviderConnectDraft;
+export declare function connectSavedProviderFromDraft(draft: ProviderConnectDraft): Promise<SavedProvider>;
+export declare function switchActiveSavedProvider(target: string): Promise<SavedProvider | null>;
+export declare function disconnectSavedProvider(target: string): Promise<{
+    activeProvider: SavedProvider | null;
+    removedProvider: SavedProvider;
+} | null>;
+export declare function inspectSavedProvider(target: string): Promise<SavedProvider | null>;
+export declare function inspectRecentSavedProvider(target?: string | null): Promise<{
+    isActive: boolean;
+    provider: SavedProvider;
+} | null>;
+export declare function testActiveSavedProviderRuntime(): Promise<{
+    activeModel: string | null;
+    provider: SavedProvider;
+    runtimeReady: boolean;
+} | null>;

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

@@ -0,0 +1,199 @@
+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" },
+];
+export function createEmptyProviderConnectDraft() {
+    return {
+        apiKey: "",
+        baseUrl: "",
+        kind: null,
+        label: "",
+    };
+}
+export function resolveSavedProvider(target) {
+    if (!target)
+        return null;
+    const normalized = target.toLowerCase();
+    return (configManager.providers.find((entry) => entry.id === target ||
+        entry.name.toLowerCase() === normalized ||
+        entry.kind.toLowerCase() === normalized) ?? null);
+}
+export function getActiveSavedProvider() {
+    const config = configManager.config;
+    const providers = configManager.providers;
+    return providers.find((entry) => entry.id === config?.activeProvider) ?? null;
+}
+export function getProviderRuntimeReadiness() {
+    const activeProvider = getActiveSavedProvider();
+    const activeModel = configManager.config?.activeModel ?? null;
+    return {
+        activeModel,
+        activeProvider,
+        modelReady: Boolean(activeProvider && activeModel),
+        providerReady: Boolean(activeProvider),
+    };
+}
+export function buildProviderDraftValue(draft, mode) {
+    if (mode === "connect-label")
+        return draft.label;
+    if (mode === "connect-key")
+        return draft.apiKey;
+    return draft.baseUrl;
+}
+export function updateProviderDraftValue(draft, mode, value) {
+    if (mode === "connect-label") {
+        return { ...draft, label: value };
+    }
+    if (mode === "connect-key") {
+        return { ...draft, apiKey: value };
+    }
+    return { ...draft, baseUrl: value };
+}
+export async function connectSavedProviderFromDraft(draft) {
+    const nextLabel = draft.label.trim();
+    const nextKey = draft.apiKey.trim();
+    const nextKind = draft.kind ?? "openai";
+    const nextBaseUrl = draft.baseUrl.trim();
+    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) {
+        throw new Error("Type the compatible base URL first.");
+    }
+    const provider = {
+        apiKey: nextKey,
+        baseUrl: nextKind === "openai-compatible" ? nextBaseUrl : undefined,
+        id: randomUUID(),
+        kind: nextKind,
+        name: nextLabel,
+        updatedAt: new Date().toISOString(),
+    };
+    configManager.upsertProvider(provider);
+    configManager.set({
+        activeModel: undefined,
+        activeProvider: provider.id,
+    });
+    await setSessionPanel("providers", provider.id);
+    await recordSessionProvider(provider.id);
+    await recordSessionEvent({
+        detail: `${provider.name} is now the active provider for this device and needs a model next.`,
+        focus: provider.id,
+        kind: "provider",
+        panel: "providers",
+        status: "success",
+        title: `Connected provider ${provider.name}`,
+    });
+    return provider;
+}
+export async function switchActiveSavedProvider(target) {
+    const provider = resolveSavedProvider(target);
+    if (!provider)
+        return null;
+    configManager.set({ activeModel: undefined, activeProvider: provider.id });
+    await setSessionPanel("providers", provider.id);
+    await recordSessionProvider(provider.id);
+    await recordSessionEvent({
+        detail: "The active model was cleared so you can choose one for this provider.",
+        focus: provider.id,
+        kind: "provider",
+        panel: "providers",
+        status: "success",
+        title: `Switched active provider to ${provider.name}`,
+    });
+    return provider;
+}
+export async function disconnectSavedProvider(target) {
+    const provider = resolveSavedProvider(target);
+    if (!provider)
+        return null;
+    configManager.removeProvider(provider.id);
+    const activeProvider = getActiveSavedProvider();
+    await setSessionPanel("providers", provider.id);
+    await recordSessionEvent({
+        detail: activeProvider
+            ? `${activeProvider.name} is still available as the active provider.`
+            : "No active provider is left on this device.",
+        focus: provider.id,
+        kind: "provider",
+        panel: "providers",
+        status: "warning",
+        title: `Disconnected ${provider.name}`,
+    });
+    return { activeProvider, removedProvider: provider };
+}
+export async function inspectSavedProvider(target) {
+    const provider = resolveSavedProvider(target);
+    if (!provider)
+        return null;
+    const activeProviderId = configManager.config?.activeProvider;
+    await setSessionPanel("providers", provider.id);
+    await recordSessionProvider(provider.id);
+    await recordSessionEvent({
+        detail: `${provider.name} is ${provider.id === activeProviderId ? "the active provider" : "saved on this device but not active"}.`,
+        focus: provider.id,
+        kind: "provider",
+        panel: "providers",
+        status: "info",
+        title: `Inspected provider ${provider.name}`,
+    });
+    return provider;
+}
+export async function inspectRecentSavedProvider(target) {
+    const session = await getSessionState();
+    const recentId = target ?? session?.recentProviderIds?.[0] ?? null;
+    if (!recentId)
+        return null;
+    const provider = resolveSavedProvider(recentId);
+    if (!provider)
+        return null;
+    const activeProviderId = configManager.config?.activeProvider;
+    await setSessionPanel("providers", provider.id);
+    await recordSessionProvider(provider.id);
+    await recordSessionEvent({
+        detail: "Returned to the provider you touched most recently in this session.",
+        focus: provider.id,
+        kind: "provider",
+        panel: "providers",
+        status: "info",
+        title: `Re-opened recent provider ${provider.name}`,
+    });
+    return {
+        isActive: provider.id === activeProviderId,
+        provider,
+    };
+}
+export async function testActiveSavedProviderRuntime() {
+    const current = getActiveSavedProvider();
+    if (!current)
+        return null;
+    const activeModel = configManager.config?.activeModel ?? null;
+    const runtimeReady = Boolean(current.apiKey && activeModel);
+    await setSessionPanel("providers", current.id);
+    await recordSessionProvider(current.id);
+    await recordSessionEvent({
+        detail: runtimeReady
+            ? `${current.name} has both an API key and an active model.`
+            : !activeModel
+                ? `${current.name} is connected, but you still need to choose a model.`
+                : `${current.name} is missing the configuration needed to run.`,
+        focus: current.id,
+        kind: "provider",
+        panel: "providers",
+        status: runtimeReady ? "success" : "warning",
+        title: runtimeReady ? `Runtime ready for ${current.name}` : `Runtime incomplete for ${current.name}`,
+    });
+    return {
+        activeModel,
+        provider: current,
+        runtimeReady,
+    };
+}

package/dist/adapters/vendor-byterover.d.ts

@@ -0,0 +1,4 @@
+export declare const vendorByteRoverAdapterPlan: {
+    readonly importedSubsystems: readonly ["tui/features/provider", "tui/features/model", "tui/features/space", "tui/features/tasks", "tui/stores/transport-store", "agent/infra/map/context-tree-store", "agent/infra/map/map-shared", "agent/infra/map/llm-map-memory", "agent/infra/map/agentic-map-service"];
+    readonly umbrellaAdapterTargets: readonly ["Umbrella auth and company selection", "Umbrella server URLs and API calls", "repo-local .um state and transport persistence", "company/space naming and mapping"];
+};

package/dist/adapters/vendor-byterover.js

@@ -0,0 +1,19 @@
+export const vendorByteRoverAdapterPlan = {
+    importedSubsystems: [
+        "tui/features/provider",
+        "tui/features/model",
+        "tui/features/space",
+        "tui/features/tasks",
+        "tui/stores/transport-store",
+        "agent/infra/map/context-tree-store",
+        "agent/infra/map/map-shared",
+        "agent/infra/map/llm-map-memory",
+        "agent/infra/map/agentic-map-service",
+    ],
+    umbrellaAdapterTargets: [
+        "Umbrella auth and company selection",
+        "Umbrella server URLs and API calls",
+        "repo-local .um state and transport persistence",
+        "company/space naming and mapping",
+    ],
+};

package/dist/commands/activity.d.ts

@@ -0,0 +1,2 @@
+export declare function activityCommandAction(): Promise<void>;
+export declare function activityCommand(cli: any): void;

package/dist/commands/activity.js

@@ -0,0 +1,82 @@
+import chalk from "chalk";
+import { ensureSessionState, getConnectorRuns, getPendingMemories, getPulledFixes, getPulledMemories, getTransportState, recordSessionEvent, setSessionPanel, } from "../repo-state.js";
+function statusBadge(status) {
+    if (status === "success")
+        return chalk.green("success");
+    if (status === "warning")
+        return chalk.yellow("warning");
+    if (status === "failure")
+        return chalk.red("failure");
+    return chalk.cyan("info");
+}
+function toActivityRow(event) {
+    return {
+        at: event.at,
+        detail: event.detail ?? "No extra detail recorded.",
+        kind: event.kind,
+        status: event.status,
+        title: event.title,
+    };
+}
+function transportRow(event) {
+    return {
+        at: event.at,
+        detail: event.detail ?? "No extra detail recorded.",
+        kind: "transport",
+        status: event.status,
+        title: `${event.kind}: ${event.title}`,
+    };
+}
+export async function activityCommandAction() {
+    await setSessionPanel("activity", "feed");
+    const session = await ensureSessionState();
+    const pending = await getPendingMemories();
+    const pulled = await getPulledMemories();
+    const fixes = await getPulledFixes();
+    const connectorRuns = await getConnectorRuns();
+    const transport = await getTransportState();
+    const rows = [
+        ...(session.events ?? []).map(toActivityRow),
+        ...(transport.events ?? []).map(transportRow),
+        ...connectorRuns.slice(0, 8).map((run) => ({
+            at: run.ranAt,
+            detail: run.summary,
+            kind: "connector",
+            status: run.status,
+            title: `Connector run: ${run.connectorName}`,
+        })),
+    ]
+        .sort((a, b) => new Date(b.at).getTime() - new Date(a.at).getTime())
+        .slice(0, 12);
+    await recordSessionEvent({
+        kind: "session",
+        title: "Opened the activity feed",
+        detail: `Viewed ${rows.length} recent timeline item${rows.length === 1 ? "" : "s"} for this repo.`,
+        panel: "activity",
+        focus: "feed",
+        status: "info",
+    });
+    console.log(chalk.bold("\n Activity Feed\n"));
+    console.log(`  Pending local drafts: ${pending.length}`);
+    console.log(`  Pulled context notes: ${pulled.length}`);
+    console.log(`  Pulled known fixes: ${fixes.length}`);
+    console.log(`  Connector runs saved: ${connectorRuns.length}`);
+    console.log(`  Transport events saved: ${transport.events.length}`);
+    console.log("");
+    if (rows.length === 0) {
+        console.log(chalk.gray("  No activity has been recorded for this repo yet."));
+        console.log("");
+        return;
+    }
+    rows.forEach((row, index) => {
+        console.log(`  ${index + 1}. [${row.kind}] ${row.title}`);
+        console.log(chalk.gray(`     ${new Date(row.at).toLocaleString()} | ${statusBadge(row.status)}`));
+        console.log(chalk.gray(`     ${row.detail}`));
+    });
+    console.log("");
+}
+export function activityCommand(cli) {
+    cli.command("activity", "Show the latest repo activity feed for Context work").action(async () => {
+        await activityCommandAction();
+    });
+}

package/dist/commands/bridge.d.ts

@@ -0,0 +1,2 @@
+export declare function bridgeCommandAction(action?: string): Promise<void>;
+export declare function bridgeCommand(cli: any): void;

package/dist/commands/bridge.js

@@ -0,0 +1,40 @@
+import chalk from "chalk";
+import { buildVendorRuntimeBridgeSnapshot, buildVendorRuntimeBridgeSummary, } from "../adapters/byterover-runtime-bridge.js";
+import { setSessionPanel } from "../repo-state.js";
+export async function bridgeCommandAction(action) {
+    const mode = (action ?? "summary").toLowerCase();
+    await setSessionPanel("bridge", mode);
+    if (mode === "json" || mode === "snapshot") {
+        const snapshot = await buildVendorRuntimeBridgeSnapshot();
+        console.log(JSON.stringify(snapshot, null, 2));
+        return;
+    }
+    const summary = await buildVendorRuntimeBridgeSummary();
+    console.log(chalk.bold("\n ByteRover Runtime Bridge\n"));
+    console.log(` Company: ${summary.company}`);
+    console.log(` Space: ${summary.space}`);
+    console.log(` Repo: ${summary.repoRoot}`);
+    console.log("");
+    console.log(chalk.cyan(" Task Store"));
+    console.log(`  total=${summary.tasks.total} created=${summary.tasks.created} started=${summary.tasks.started} completed=${summary.tasks.completed} error=${summary.tasks.error}`);
+    console.log(chalk.cyan(" Transport Store"));
+    console.log(`  status=${summary.transport.status} connection=${summary.transport.connectionState} queue=${summary.transport.queueDepth} events=${summary.transport.events}`);
+    console.log(chalk.cyan(" Provider Store"));
+    console.log(`  active=${summary.provider.active ?? "none"} providers=${summary.provider.count}`);
+    console.log(chalk.cyan(" Model Store"));
+    console.log(`  active=${summary.model.active ?? "none"} models=${summary.model.count}`);
+    console.log(chalk.cyan(" Space Store"));
+    console.log(`  active=${summary.spaces.active ?? "none"} spaces=${summary.spaces.count}`);
+    console.log(chalk.cyan(" Context Tree Store"));
+    console.log(`  nodes=${summary.tree.nodes} transport=${summary.tree.runtimeStatus}`);
+    console.log(`  provider=${summary.tree.runtimeProvider ?? "none"}`);
+    console.log("");
+    console.log(chalk.gray(" Use `umbrella-context bridge json` to inspect the full projected upstream-shaped snapshot."));
+}
+export function bridgeCommand(cli) {
+    cli
+        .command("bridge [action]", "Project the local .um runtime into ByteRover-shaped store snapshots")
+        .action(async (action) => {
+        await bridgeCommandAction(action);
+    });
+}

package/dist/commands/catalog.d.ts

@@ -0,0 +1,34 @@
+import type { AgentMemoryConfig } from "../config.js";
+export type InteractiveContext = {
+    config: AgentMemoryConfig;
+    handleFix: (error: string, config: AgentMemoryConfig) => Promise<void>;
+    handleRecord: (parts: string[], config: AgentMemoryConfig) => Promise<void>;
+    handleSpaces: (config: AgentMemoryConfig) => Promise<void>;
+    handleHome: (config: AgentMemoryConfig) => Promise<void>;
+    handleRecent: (config: AgentMemoryConfig) => Promise<void>;
+    handleTimeline: () => Promise<void>;
+    handleActivity: () => Promise<void>;
+    handleHistory: () => Promise<void>;
+    handleSession: () => Promise<void>;
+    handleNewSession: () => Promise<void>;
+    handleRestart: () => Promise<void>;
+    handleDebug: () => Promise<void>;
+    handleLogout: () => Promise<void>;
+    handlePanel: () => Promise<void>;
+    handleContinue: () => Promise<void>;
+};
+export type CommandSpec = {
+    key: string;
+    usage: string;
+    description: string;
+    aliases?: string[];
+    action: (args: string[], context: InteractiveContext) => Promise<void>;
+};
+export declare const COMMAND_SPECS: CommandSpec[];
+export declare function parseInteractiveInput(input: string): {
+    command: string;
+    args: string[];
+    raw: string;
+};
+export declare function resolveCommand(name: string): CommandSpec | null;
+export declare function renderCommandList(): string;