umbrella-context 0.1.2 → 0.1.32

package/dist/commands/providers.js

@@ -0,0 +1,379 @@
+import chalk from "chalk";
+import prompts from "prompts";
+import { configManager } from "../config.js";
+import { connectSavedProviderFromDraft, createEmptyProviderConnectDraft, getActiveSavedProvider, getProviderRuntimeReadiness, inspectRecentSavedProvider, inspectSavedProvider, resolveSavedProvider, switchActiveSavedProvider, testActiveSavedProviderRuntime, disconnectSavedProvider, UMBRELLA_PROVIDER_CHOICES, } from "../adapters/umbrella-provider-runtime.js";
+import { recordSessionEvent, setSessionPanel } from "../repo-state.js";
+import { modelCommandAction } from "./model.js";
+function printProviders(providers, activeProvider) {
+    console.log(chalk.bold("\n Connected Providers\n"));
+    if (providers.length === 0) {
+        console.log(chalk.yellow(" No providers connected yet. Run: umbrella-context providers connect"));
+        return;
+    }
+    providers.forEach((provider, index) => {
+        const active = provider.id === activeProvider ? " (active)" : "";
+        const base = provider.baseUrl ? ` -> ${provider.baseUrl}` : "";
+        console.log(` ${index + 1}. ${provider.name} [${provider.kind}]${active}${base}`);
+    });
+}
+async function runProviderSetupFlow() {
+    const providers = configManager.providers;
+    let provider = getActiveSavedProvider();
+    let changed = false;
+    await setSessionPanel("providers", provider?.id ?? "setup");
+    if (providers.length === 0) {
+        console.log(chalk.cyan("\n No provider is connected yet, so setup will start by connecting one."));
+        const connectResult = await providersCommandAction("connect");
+        if (!connectResult?.activeProvider)
+            return;
+        provider = connectResult.activeProvider;
+        changed = changed || connectResult.changed;
+    }
+    else {
+        const answer = await prompts({
+            type: "select",
+            name: "value",
+            message: provider
+                ? `Runtime setup (active provider: ${provider.name})`
+                : "Runtime setup",
+            choices: [
+                ...(provider
+                    ? [
+                        {
+                            title: `Keep ${provider.name} as the active provider`,
+                            description: "Use the current provider and continue into model setup",
+                            value: "__keep__",
+                        },
+                    ]
+                    : []),
+                ...providers.map((entry) => ({
+                    title: `${entry.name} (${entry.kind})${entry.id === provider?.id ? " [active]" : ""}`,
+                    description: "Switch to this provider and continue the setup flow",
+                    value: entry.id,
+                })),
+                {
+                    title: "Connect a new provider",
+                    description: "Add another provider to this device first",
+                    value: "__connect__",
+                },
+            ],
+        });
+        if (!answer.value) {
+            console.log(chalk.yellow("\n Provider setup cancelled."));
+            return;
+        }
+        if (answer.value === "__connect__") {
+            const connectResult = await providersCommandAction("connect");
+            if (!connectResult?.activeProvider)
+                return;
+            provider = connectResult.activeProvider;
+            changed = changed || connectResult.changed;
+        }
+        else if (answer.value !== "__keep__") {
+            const switchResult = await providersCommandAction("switch", answer.value);
+            if (!switchResult?.activeProvider)
+                return;
+            provider = switchResult.activeProvider;
+            changed = true;
+        }
+    }
+    if (!provider) {
+        console.log(chalk.yellow("\n Provider setup could not find an active provider."));
+        return;
+    }
+    if (!configManager.config?.activeModel) {
+        const modelResult = await modelCommandAction("switch");
+        if (!modelResult?.activeModel) {
+            console.log(chalk.yellow("\n Model setup cancelled before the runtime was fully ready."));
+            return {
+                action: "setup",
+                changed,
+                activeProvider: provider,
+                needsModelSelection: true,
+            };
+        }
+        changed = changed || modelResult.changed;
+    }
+    const runtimeResult = await providersCommandAction("test");
+    const activeModel = configManager.config?.activeModel ?? null;
+    const runtimeReady = Boolean(provider.apiKey && activeModel);
+    await recordSessionEvent({
+        kind: "provider",
+        title: runtimeReady ? `Completed runtime setup for ${provider.name}` : `Runtime setup stopped early for ${provider.name}`,
+        detail: runtimeReady
+            ? `${provider.name} and ${activeModel} are ready for terminal Context work.`
+            : `${provider.name} is selected, but the runtime still needs attention.`,
+        panel: "providers",
+        focus: provider.id,
+        status: runtimeReady ? "success" : "warning",
+    });
+    console.log("");
+    console.log(chalk.bold(" Runtime Setup Summary"));
+    console.log(`  Provider: ${provider.name}`);
+    console.log(`  Model: ${activeModel ?? "Not selected"}`);
+    console.log(`  Ready: ${runtimeReady ? "Yes" : "No"}`);
+    console.log("");
+    console.log(chalk.cyan(" Recommended Next Step"));
+    console.log(runtimeReady
+        ? '  - Ask a plain question in the shell or run "umbrella-context query".'
+        : '  - Run "umbrella-context model switch" or "umbrella-context providers test" to finish setup.');
+    return {
+        action: "setup",
+        changed: changed || Boolean(runtimeResult?.changed),
+        activeProvider: provider,
+        needsModelSelection: !runtimeReady,
+    };
+}
+export function getActiveProvider() {
+    return getActiveSavedProvider();
+}
+export function getProviderReadinessSummary() {
+    return getProviderRuntimeReadiness();
+}
+export async function providersCommandAction(action, target) {
+    const normalized = action.toLowerCase();
+    const providers = configManager.providers;
+    const activeProvider = configManager.config?.activeProvider;
+    await setSessionPanel("providers", null);
+    if (normalized === "list") {
+        await setSessionPanel("providers", "list");
+        printProviders(providers, activeProvider);
+        const current = getActiveSavedProvider();
+        return {
+            action: "list",
+            changed: false,
+            activeProvider: current,
+            needsModelSelection: Boolean(current && !configManager.config?.activeModel),
+        };
+    }
+    if (normalized === "setup") {
+        return runProviderSetupFlow();
+    }
+    if (normalized === "test") {
+        const runtime = await testActiveSavedProviderRuntime();
+        if (!runtime) {
+            console.log(chalk.yellow("\n No active provider. Run: umbrella-context providers connect"));
+            return;
+        }
+        const { provider: current, runtimeReady } = runtime;
+        console.log(chalk.bold(`\n Runtime check for ${current.name}\n`));
+        console.log(` Kind: ${current.kind}`);
+        console.log(` API key saved: ${current.apiKey ? "Yes" : "No"}`);
+        console.log(` Active model: ${configManager.config?.activeModel ?? "Not selected"}`);
+        console.log(` Runtime ready: ${runtimeReady ? "Yes" : "No"}`);
+        console.log("");
+        console.log(chalk.cyan(" Recommended Next Step"));
+        console.log(runtimeReady
+            ? "  - Runtime is ready. Ask a plain question or run umbrella-context query."
+            : '  - Run umbrella-context model switch to finish the runtime setup.');
+        return {
+            action: "test",
+            changed: false,
+            activeProvider: current,
+            needsModelSelection: !configManager.config?.activeModel,
+        };
+    }
+    if (normalized === "inspect") {
+        if (providers.length === 0) {
+            console.log(chalk.yellow(" No connected providers yet. Run: umbrella-context providers connect"));
+            return;
+        }
+        let selectedId = target;
+        if (!selectedId) {
+            const answer = await prompts({
+                type: "select",
+                name: "value",
+                message: "Choose a provider to inspect",
+                choices: providers.map((provider) => ({
+                    title: `${provider.name} (${provider.kind})`,
+                    value: provider.id,
+                })),
+            });
+            if (!answer.value) {
+                console.log(chalk.yellow("\n No provider selected."));
+                return;
+            }
+            selectedId = answer.value;
+        }
+        if (!selectedId) {
+            console.log(chalk.yellow("\n No provider selected."));
+            return;
+        }
+        const provider = await inspectSavedProvider(selectedId);
+        if (!provider)
+            return;
+        console.log(chalk.bold(`\n ${provider.name}\n`));
+        console.log(` Kind: ${provider.kind}`);
+        console.log(` Active: ${provider.id === activeProvider ? "Yes" : "No"}`);
+        console.log(` Base URL: ${provider.baseUrl ?? "Default"}`);
+        console.log(` Updated: ${new Date(provider.updatedAt).toLocaleString()}`);
+        console.log("");
+        console.log(chalk.cyan(" Recommended Next Step"));
+        if (provider.id !== activeProvider) {
+            console.log("  - Run umbrella-context providers switch to make this the active runtime.");
+        }
+        else if (!configManager.config?.activeModel) {
+            console.log("  - Run umbrella-context model switch to choose a model for this provider.");
+        }
+        else {
+            console.log("  - Runtime is ready. Ask a question or run umbrella-context query.");
+        }
+        return {
+            action: "inspect",
+            changed: false,
+            activeProvider: getActiveSavedProvider(),
+            needsModelSelection: Boolean(provider.id === activeProvider && !configManager.config?.activeModel),
+            inspectedProvider: provider,
+        };
+    }
+    if (normalized === "recent") {
+        const recent = await inspectRecentSavedProvider(target);
+        if (!recent) {
+            console.log(chalk.yellow("\n No recent provider in this session yet."));
+            return;
+        }
+        const { provider } = recent;
+        console.log(chalk.bold(`\n ${provider.name}\n`));
+        console.log(` Kind: ${provider.kind}`);
+        console.log(` Active: ${provider.id === activeProvider ? "Yes" : "No"}`);
+        console.log(` Base URL: ${provider.baseUrl ?? "Default"}`);
+        console.log(` Updated: ${new Date(provider.updatedAt).toLocaleString()}`);
+        console.log("");
+        console.log(chalk.cyan(" Recommended Next Step"));
+        if (provider.id !== activeProvider) {
+            console.log("  - Run umbrella-context providers switch to make this the active runtime.");
+        }
+        else if (!configManager.config?.activeModel) {
+            console.log("  - Run umbrella-context model switch to choose a model for this provider.");
+        }
+        else {
+            console.log("  - Runtime is ready. Ask a question or run umbrella-context query.");
+        }
+        return {
+            action: "inspect",
+            changed: false,
+            activeProvider: getActiveSavedProvider(),
+            needsModelSelection: Boolean(provider.id === activeProvider && !configManager.config?.activeModel),
+            inspectedProvider: provider,
+        };
+    }
+    if (normalized === "connect") {
+        const draft = createEmptyProviderConnectDraft();
+        const answer = await prompts([
+            {
+                type: "select",
+                name: "kind",
+                message: "Choose a provider",
+                choices: UMBRELLA_PROVIDER_CHOICES.map((entry) => ({ title: entry.name, value: entry.kind })),
+            },
+            {
+                type: "text",
+                name: "label",
+                message: "What label should this provider use on this device?",
+            },
+            {
+                type: "password",
+                name: "apiKey",
+                message: "Paste the provider API key (stored only on this device)",
+            },
+            {
+                type: (prev) => (prev === "openai-compatible" ? "text" : null),
+                name: "baseUrl",
+                message: "Base URL for the compatible API",
+            },
+        ]);
+        if (!answer.kind || !answer.label || !answer.apiKey) {
+            console.log(chalk.yellow("\n Provider connection cancelled."));
+            return;
+        }
+        draft.kind = answer.kind;
+        draft.label = answer.label;
+        draft.apiKey = answer.apiKey;
+        draft.baseUrl = answer.baseUrl || "";
+        const provider = await connectSavedProviderFromDraft(draft);
+        console.log(chalk.green(`\n Connected ${provider.name}.`));
+        console.log(chalk.gray(" Use 'umbrella-context model switch' to choose a model next."));
+        return {
+            action: "connect",
+            changed: true,
+            activeProvider: provider,
+            needsModelSelection: true,
+        };
+    }
+    if (normalized === "switch") {
+        if (providers.length === 0) {
+            console.log(chalk.yellow(" No connected providers yet. Run: umbrella-context providers connect"));
+            return;
+        }
+        let provider = resolveSavedProvider(target);
+        if (!provider) {
+            const answer = await prompts({
+                type: "select",
+                name: "value",
+                message: "Choose the active provider",
+                choices: providers.map((provider) => ({
+                    title: `${provider.name} (${provider.kind})`,
+                    value: provider.id,
+                })),
+            });
+            if (!answer.value) {
+                console.log(chalk.yellow("\n No provider selected."));
+                return;
+            }
+            provider = resolveSavedProvider(answer.value);
+        }
+        if (!provider) {
+            console.log(chalk.yellow("\n No provider selected."));
+            return;
+        }
+        provider = await switchActiveSavedProvider(provider.id);
+        console.log(chalk.green(`\n Active provider: ${provider?.name ?? "Updated"}`));
+        return {
+            action: "switch",
+            changed: true,
+            activeProvider: provider ?? null,
+            needsModelSelection: true,
+        };
+    }
+    if (normalized === "disconnect") {
+        if (providers.length === 0) {
+            console.log(chalk.yellow(" No connected providers yet."));
+            return;
+        }
+        let provider = resolveSavedProvider(target);
+        if (!provider) {
+            const answer = await prompts({
+                type: "select",
+                name: "value",
+                message: "Choose a provider to disconnect",
+                choices: providers.map((provider) => ({
+                    title: `${provider.name} (${provider.kind})`,
+                    value: provider.id,
+                })),
+            });
+            if (!answer.value) {
+                console.log(chalk.yellow("\n No provider selected."));
+                return;
+            }
+            provider = resolveSavedProvider(answer.value);
+        }
+        if (!provider) {
+            console.log(chalk.yellow("\n No provider selected."));
+            return;
+        }
+        const disconnectResult = await disconnectSavedProvider(provider.id);
+        console.log(chalk.green(`\n Disconnected ${disconnectResult?.removedProvider.name ?? "provider"}.`));
+        return {
+            action: "disconnect",
+            changed: true,
+            activeProvider: disconnectResult?.activeProvider ?? getActiveSavedProvider(),
+            needsModelSelection: false,
+        };
+    }
+    console.log(chalk.red("Use one of: providers list, providers setup, providers inspect, providers recent, providers test, providers connect, providers switch, providers disconnect"));
+}
+export function providersCommand(cli) {
+    cli.command("providers <action> [target]", "Manage local LLM providers for the interactive Context terminal").action(async (action, target) => {
+        await providersCommandAction(action, target);
+    });
+}

package/dist/commands/pull.js

@@ -1,6 +1,6 @@
 import chalk from "chalk";
 import { configManager } from "../config.js";
-import { ensureRepoContext, setPulledFixes, setPulledMemories } from "../repo-state.js";
+import { addTaskReasoningContent, addTaskToolCall, completeTask, createTask, ensureRepoContext, recordSessionEvent, setPulledFixes, setPulledMemories, setSessionPanel, } from "../repo-state.js";
 export async function pullCommandAction() {
     const config = configManager.config;
     if (!config) {
@@ -9,6 +9,26 @@ export async function pullCommandAction() {
     }
     try {
         await ensureRepoContext(config);
+        await setSessionPanel("pull", config.projectName);
+        const task = await createTask({
+            kind: "pull",
+            title: `Pull shared Context for ${config.companyName} / ${config.projectName}`,
+            detail: "Refreshing the repo-local snapshot from the server.",
+            status: "running",
+            panel: "pull",
+            focus: config.projectName,
+        });
+        await addTaskReasoningContent(task.id, "Requesting shared memories and known fixes from the server.");
+        await addTaskToolCall(task.id, {
+            toolName: "server.memory.list",
+            status: "running",
+            args: { limit: 50 },
+        });
+        await addTaskToolCall(task.id, {
+            toolName: "server.evolutions.list",
+            status: "running",
+            args: { limit: 50 },
+        });
         const [memoriesRes, fixesRes] = await Promise.all([
             fetch(`${config.serverUrl}/api/memories?limit=50`, {
                 headers: { Authorization: `Bearer ${config.apiKey}` },
@@ -19,11 +39,32 @@ export async function pullCommandAction() {
         ]);
         if (!memoriesRes.ok) {
             const err = await memoriesRes.text();
+            await addTaskToolCall(task.id, {
+                toolName: "server.memory.list",
+                status: "error",
+                args: { limit: 50 },
+                error: err || memoriesRes.statusText,
+            });
+            await completeTask(task.id, "failed", err || memoriesRes.statusText);
             console.log(chalk.red(`\n Pull failed: ${err || memoriesRes.statusText}`));
             return;
         }
         const memoriesJson = await memoriesRes.json();
         const fixesJson = fixesRes.ok ? await fixesRes.json() : { results: [] };
+        await addTaskToolCall(task.id, {
+            toolName: "server.memory.list",
+            status: "completed",
+            args: { limit: 50 },
+            result: { total: memoriesJson.results?.length ?? 0 },
+        });
+        await addTaskToolCall(task.id, {
+            toolName: "server.evolutions.list",
+            status: fixesRes.ok ? "completed" : "error",
+            args: { limit: 50 },
+            result: fixesRes.ok ? { total: fixesJson.results?.length ?? 0 } : undefined,
+            error: fixesRes.ok ? undefined : fixesRes.statusText,
+        });
+        await addTaskReasoningContent(task.id, `Pulled ${memoriesJson.results?.length ?? 0} context entr${(memoriesJson.results?.length ?? 0) === 1 ? "y" : "ies"} and ${fixesJson.results?.length ?? 0} known fix${(fixesJson.results?.length ?? 0) === 1 ? "" : "es"}.`);
         await setPulledMemories((memoriesJson.results ?? []).map((entry) => ({
             id: entry.id,
             content: entry.content,
@@ -42,12 +83,30 @@ export async function pullCommandAction() {
             createdAt: entry.createdAt ?? new Date().toISOString(),
             lastApplied: entry.lastApplied ?? null,
         })));
+        await recordSessionEvent({
+            kind: "pull",
+            title: `Pulled ${memoriesJson.results?.length ?? 0} Context entr${(memoriesJson.results?.length ?? 0) === 1 ? "y" : "ies"}`,
+            detail: `Cached ${fixesJson.results?.length ?? 0} known fix${(fixesJson.results?.length ?? 0) === 1 ? "" : "es"} for ${config.companyName} / ${config.projectName}.`,
+            panel: "pull",
+            focus: config.projectName,
+            status: "success",
+        });
+        await completeTask(task.id, "completed", `Pulled ${memoriesJson.results?.length ?? 0} context entr${(memoriesJson.results?.length ?? 0) === 1 ? "y" : "ies"} and ${fixesJson.results?.length ?? 0} known fix${(fixesJson.results?.length ?? 0) === 1 ? "" : "es"}.`);
         console.log(chalk.green(`\n Pulled ${memoriesJson.results?.length ?? 0} context entries from the server.`));
         console.log(chalk.gray(`   Company: ${config.companyName}`));
         console.log(chalk.gray(`   Space: ${config.projectName}`));
         console.log(chalk.gray(`   Known fixes cached: ${fixesJson.results?.length ?? 0}`));
     }
     catch (err) {
+        const failedTask = await createTask({
+            kind: "pull",
+            title: `Pull failed for ${config.companyName} / ${config.projectName}`,
+            detail: err.message,
+            status: "failed",
+            panel: "pull",
+            focus: config.projectName,
+        });
+        await completeTask(failedTask.id, "failed", err.message);
         console.log(chalk.red(`\n Error: ${err.message}`));
     }
 }

package/dist/commands/push.js

@@ -1,6 +1,6 @@
 import chalk from "chalk";
 import { configManager } from "../config.js";
-import { clearPendingMemories, ensureRepoContext, getPendingMemories, getPulledMemories, markPushCompleted, setPulledMemories, } from "../repo-state.js";
+import { addTaskReasoningContent, addTaskToolCall, clearPendingMemories, completeTask, createTask, ensureRepoContext, getPendingMemories, getPulledMemories, markPushCompleted, recordSessionEvent, setSessionPanel, setPulledMemories, } from "../repo-state.js";
 export async function pushCommandAction() {
     const config = configManager.config;
     if (!config) {
@@ -9,13 +9,41 @@ export async function pushCommandAction() {
     }
     try {
         await ensureRepoContext(config);
+        await setSessionPanel("push", config.projectName);
+        const task = await createTask({
+            kind: "push",
+            title: `Push Context to ${config.companyName} / ${config.projectName}`,
+            detail: "Syncing repo-local drafts to the shared server.",
+            status: "running",
+            panel: "push",
+            focus: config.projectName,
+        });
         const pending = await getPendingMemories();
+        await addTaskReasoningContent(task.id, `Found ${pending.length} pending local draft${pending.length === 1 ? "" : "s"} ready for upload.`);
         if (pending.length === 0) {
+            await completeTask(task.id, "completed", "Nothing was pending, so no push was needed.");
+            await recordSessionEvent({
+                kind: "push",
+                title: "Push skipped because nothing was pending",
+                detail: `This repo had no local drafts waiting to sync for ${config.companyName} / ${config.projectName}.`,
+                panel: "push",
+                focus: config.projectName,
+                status: "info",
+            });
             console.log(chalk.yellow("\n Nothing to push. Your local .um folder is already in sync."));
             return;
         }
         const synced = [];
         for (const entry of pending) {
+            await addTaskToolCall(task.id, {
+                toolName: "server.memory.create",
+                status: "running",
+                args: {
+                    source: entry.source,
+                    systemType: entry.systemType,
+                    tags: entry.tags,
+                },
+            });
             const res = await fetch(`${config.serverUrl}/api/memories`, {
                 method: "POST",
                 headers: {
@@ -31,10 +59,24 @@ export async function pushCommandAction() {
             });
             if (!res.ok) {
                 const err = await res.text();
+                await addTaskToolCall(task.id, {
+                    toolName: "server.memory.create",
+                    status: "error",
+                    args: { source: entry.source, systemType: entry.systemType },
+                    error: err || res.statusText,
+                });
+                await completeTask(task.id, "failed", err || res.statusText);
                 console.log(chalk.red(`\n Push failed: ${err || res.statusText}`));
                 return;
             }
-            synced.push(await res.json());
+            const created = await res.json();
+            await addTaskToolCall(task.id, {
+                toolName: "server.memory.create",
+                status: "completed",
+                args: { source: entry.source, systemType: entry.systemType },
+                result: { id: created.id },
+            });
+            synced.push(created);
         }
         const existingPulled = await getPulledMemories();
         await setPulledMemories([
@@ -50,11 +92,29 @@ export async function pushCommandAction() {
         ]);
         await clearPendingMemories();
         await markPushCompleted();
+        await recordSessionEvent({
+            kind: "push",
+            title: `Pushed ${synced.length} Context entr${synced.length === 1 ? "y" : "ies"}`,
+            detail: `Shared local drafts from ${config.companyName} / ${config.projectName} with the server.`,
+            panel: "push",
+            focus: config.projectName,
+            status: "success",
+        });
+        await completeTask(task.id, "completed", `Pushed ${synced.length} entr${synced.length === 1 ? "y" : "ies"} to the server.`);
         console.log(chalk.green(`\n Pushed ${synced.length} local context entr${synced.length === 1 ? "y" : "ies"}.`));
         console.log(chalk.gray(`   Company: ${config.companyName}`));
         console.log(chalk.gray(`   Space: ${config.projectName}`));
     }
     catch (err) {
+        const failedTask = await createTask({
+            kind: "push",
+            title: `Push failed for ${config.companyName} / ${config.projectName}`,
+            detail: err.message,
+            status: "failed",
+            panel: "push",
+            focus: config.projectName,
+        });
+        await completeTask(failedTask.id, "failed", err.message);
         console.log(chalk.red(`\n Error: ${err.message}`));
     }
 }

package/dist/commands/reset.d.ts

@@ -0,0 +1,2 @@
+export declare function resetCommandAction(skipConfirm?: boolean): Promise<void>;
+export declare function resetCommand(cli: any): void;

package/dist/commands/reset.js

@@ -0,0 +1,35 @@
+import chalk from "chalk";
+import prompts from "prompts";
+import { recordSessionEvent, resetRepoState } from "../repo-state.js";
+export async function resetCommandAction(skipConfirm = false) {
+    if (!skipConfirm) {
+        const answer = await prompts({
+            type: "confirm",
+            name: "value",
+            message: "Reset this repo's local Context state? This clears .um drafts, pulled snapshots, hub installs, connectors, and saved session history for this repo.",
+            initial: false,
+        });
+        if (!answer.value) {
+            console.log(chalk.yellow("\n Reset cancelled. Your local Context state was left alone."));
+            return;
+        }
+    }
+    const result = await resetRepoState();
+    await recordSessionEvent({
+        kind: "session",
+        title: "Completed a local Context reset",
+        detail: `Local Context files were reset inside ${result.umDir}.`,
+        panel: "reset",
+        focus: null,
+        status: "warning",
+    });
+    console.log(chalk.green("\n Local Context state reset."));
+    console.log(chalk.gray(` Repo root: ${result.repoRoot}`));
+    console.log(chalk.gray(` Local folder: ${result.umDir}`));
+    console.log(chalk.gray(" Your repo link to the company stayed in place, but the local Context cache and session state were cleared."));
+}
+export function resetCommand(cli) {
+    cli.command("reset", "Reset this repo's local Context state and clear the .um working set").action(async () => {
+        await resetCommandAction();
+    });
+}

package/dist/commands/restart.d.ts

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

package/dist/commands/restart.js

@@ -0,0 +1,21 @@
+import chalk from "chalk";
+import { configManager } from "../config.js";
+import { ensureRepoContext, ensureSessionState, resetSessionState } from "../repo-state.js";
+export async function restartCommandAction() {
+    const config = configManager.config;
+    if (!config) {
+        console.log(chalk.red("Not configured. Run: umbrella-context setup"));
+        return;
+    }
+    await ensureRepoContext(config);
+    const session = await resetSessionState();
+    await ensureSessionState();
+    console.log(chalk.green("\n Context terminal restarted for this repo."));
+    console.log(chalk.gray(` New session: ${session.id}`));
+    console.log(chalk.gray(" Local .um context files were kept. Only the live shell session was refreshed."));
+}
+export function restartCommand(cli) {
+    cli.command("restart", "Refresh the local repo session without deleting .um data").action(async () => {
+        await restartCommandAction();
+    });
+}