umbrella-context 0.1.37 → 0.1.39

package/dist/commands/session.js

@@ -226,9 +226,6 @@ export function sessionCommand(cli) {
     cli.command("recent", "Show saved recent repo activity").action(async () => {
         await sessionCommandAction("recent");
     });
-    cli.command("activity", "Show the saved richer repo activity feed").action(async () => {
-        await sessionCommandAction("activity");
-    });
     cli.command("timeline", "Show the saved session event timeline").action(async () => {
         await sessionCommandAction("timeline");
     });

package/dist/commands/setup.js

@@ -6,6 +6,7 @@ import { UmbrellaRequestError } from "../umbrella.js";
 import { setUmbrellaAuthAuthorized, setUmbrellaAuthChecking, setUmbrellaAuthFailure, } from "../adapters/umbrella-auth-runtime.js";
 import { checkUmbrellaOnboardingServer, connectUmbrellaDevice, createUmbrellaOnboardingCompany, createUmbrellaOnboardingSpace, loadUmbrellaOnboardingSpaces, normalizeUmbrellaServerUrl, signInUmbrellaOnboarding, } from "../adapters/umbrella-onboarding.js";
 const DEFAULT_UMBRELLA_SERVER_URL = "http://5.161.55.138:3100";
+const LOCAL_UMBRELLA_SERVER_URL = "http://127.0.0.1:3100";
 function isLocalOnlyServerUrl(value) {
     try {
         const parsed = new URL(value);
@@ -16,6 +17,29 @@ function isLocalOnlyServerUrl(value) {
         return false;
     }
 }
+function detectMixedSavedConnection(umbrellaUrl, serverUrl) {
+    if (!umbrellaUrl || !serverUrl)
+        return null;
+    try {
+        const umbrella = new URL(umbrellaUrl);
+        const backend = new URL(serverUrl);
+        const umbrellaIsLoopback = isLocalOnlyServerUrl(umbrellaUrl);
+        const backendIsLoopback = isLocalOnlyServerUrl(serverUrl);
+        const differentHosts = umbrella.hostname !== backend.hostname || umbrella.port !== backend.port;
+        if (!differentHosts && umbrellaIsLoopback === backendIsLoopback) {
+            return null;
+        }
+        return {
+            backendUrl: serverUrl,
+            umbrellaUrl,
+            umbrellaIsLoopback,
+            backendIsLoopback,
+        };
+    }
+    catch {
+        return null;
+    }
+}
 function printConnected(setup) {
     console.log(chalk.green(`\n Connected to ${setup.companyName} / ${setup.activeSpaceName}`));
     console.log(chalk.gray(` Context space: ${setup.activeSpaceName}`));
@@ -63,6 +87,69 @@ function describeSetupFailure(error) {
     }
     return error.message;
 }
+async function promptForCredentials(options) {
+    const emailPrompt = await prompts({
+        message: "Umbrella email",
+        name: "value",
+        type: options.email ? null : "text",
+    });
+    const passwordPrompt = await prompts({
+        message: "Umbrella password",
+        name: "value",
+        type: options.password ? null : "password",
+    });
+    const email = options.email?.trim() || emailPrompt.value;
+    const password = options.password?.trim() || passwordPrompt.value;
+    if (!email || !password) {
+        return null;
+    }
+    return { email, password };
+}
+async function attemptAuthenticatedSignIn(serverUrl, options) {
+    const canRetryInteractively = !options.email && !options.password;
+    const maxAttempts = canRetryInteractively ? 3 : 1;
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        const credentials = await promptForCredentials(options);
+        if (!credentials) {
+            return { kind: "cancelled", error: new Error("Sign-in cancelled.") };
+        }
+        const { email, password } = credentials;
+        try {
+            console.log(chalk.gray(` Signing into Umbrella as ${email} ...`));
+            const signIn = await signInUmbrellaOnboarding(serverUrl, email, password);
+            return {
+                companies: signIn.companies,
+                cookie: signIn.cookie,
+                email,
+                kind: "success",
+            };
+        }
+        catch (error) {
+            const message = describeSetupFailure(error);
+            console.log(chalk.red(` Sign-in failed: ${message}`));
+            if (attempt >= maxAttempts) {
+                return { kind: "failure", error };
+            }
+            const retryPrompt = await prompts({
+                choices: [
+                    { title: "Try email and password again", value: "retry" },
+                    { title: "Cancel setup", value: "cancel" },
+                ],
+                initial: 0,
+                message: "The live Umbrella sign-in did not work. What do you want to do?",
+                name: "value",
+                type: "select",
+            });
+            if (retryPrompt.value !== "retry") {
+                return { kind: "cancelled", error: new Error("Sign-in cancelled.") };
+            }
+        }
+    }
+    return {
+        kind: "failure",
+        error: new Error("Sign-in failed."),
+    };
+}
 async function chooseCompany(serverUrl, companies, cookie, initialCompanyId) {
     if (initialCompanyId) {
         const matched = companies.find((company) => company.id === initialCompanyId);
@@ -132,30 +219,108 @@ async function chooseSpace(serverUrl, companyId, spaces, cookie, initialSpaceId)
 }
 export function setupCommand(cli) {
     cli
-        .command("setup", "Sign into Umbrella, choose a company, and connect this device to a context space")
+        .command("setup", `Sign into Umbrella, choose a company, and connect this device to a context space
+
+Use this the first time you connect a machine, when the saved company or space looks wrong, or when status says your live Umbrella connection has not been verified yet.`)
         .option("--server-url <url>", "Umbrella server URL")
         .option("--email <email>", "Umbrella email for authenticated mode")
         .option("--password <password>", "Umbrella password for authenticated mode")
         .option("--company-id <id>", "Existing Umbrella company ID")
         .option("--space-id <id>", "Existing context space ID")
+        .example("setup")
+        .example("setup --server-url http://5.161.55.138:3100")
+        .example("setup --server-url http://127.0.0.1:3100")
         .action(async (options) => {
         console.log(chalk.bold("\n Umbrella Context Setup\n"));
         const existing = configManager.config;
         const envServerUrl = process.env.UMBRELLA_SERVER_URL?.trim();
+        const mixedSavedConnection = detectMixedSavedConnection(existing?.umbrellaUrl, existing?.serverUrl);
         const suggestedServerUrl = options.serverUrl?.trim() ||
             envServerUrl ||
+            mixedSavedConnection?.backendUrl ||
             existing?.umbrellaUrl ||
             existing?.serverUrl ||
             DEFAULT_UMBRELLA_SERVER_URL;
         console.log(chalk.gray(` Defaulting to the live Umbrella server at ${DEFAULT_UMBRELLA_SERVER_URL}. Only use 127.0.0.1 if you are intentionally running Umbrella on this same computer instead.`));
-        const serverUrlPrompt = await prompts({
-            initial: suggestedServerUrl,
-            message: "Umbrella server URL",
-            name: "value",
-            type: options.serverUrl ? null : "text",
-        });
-        const serverUrl = normalizeUmbrellaServerUrl(options.serverUrl?.trim() ||
-            serverUrlPrompt.value ||
+        if (mixedSavedConnection) {
+            console.log(chalk.yellow(` Saved setup is mixed right now: Umbrella app URL is ${mixedSavedConnection.umbrellaUrl}, but the Context backend URL is ${mixedSavedConnection.backendUrl}.`));
+            console.log(chalk.yellow(" That usually means the device was partly pointed at local Umbrella and partly at the live server. Setup can repair that now."));
+        }
+        let serverUrlInput = options.serverUrl?.trim() || "";
+        if (!serverUrlInput) {
+            const normalizedSuggestedServer = normalizeUmbrellaServerUrl(suggestedServerUrl);
+            const defaultServerChoice = mixedSavedConnection
+                ? mixedSavedConnection.backendIsLoopback
+                    ? "local"
+                    : normalizedSuggestedServer === DEFAULT_UMBRELLA_SERVER_URL
+                        ? "live"
+                        : "custom"
+                : normalizedSuggestedServer === DEFAULT_UMBRELLA_SERVER_URL
+                    ? "live"
+                    : isLocalOnlyServerUrl(normalizedSuggestedServer)
+                        ? "local"
+                        : "custom";
+            const serverChoicePrompt = await prompts({
+                choices: [
+                    {
+                        description: "Recommended for most people. Uses the shared live Umbrella server.",
+                        title: `Live Umbrella server (${DEFAULT_UMBRELLA_SERVER_URL})`,
+                        value: "live",
+                    },
+                    {
+                        description: "Only use this if Umbrella is running on the same computer right now.",
+                        title: `Local development server (${LOCAL_UMBRELLA_SERVER_URL})`,
+                        value: "local",
+                    },
+                    {
+                        description: mixedSavedConnection
+                            ? "Use this if the saved app/backend URLs were mixed and you want to repair them to some other server."
+                            : "Type a different server URL yourself.",
+                        title: "Custom URL",
+                        value: "custom",
+                    },
+                ],
+                initial: ["live", "local", "custom"].indexOf(defaultServerChoice),
+                message: "Which Umbrella server should this device use?",
+                name: "value",
+                type: "select",
+            });
+            if (!serverChoicePrompt.value) {
+                console.log(chalk.red("\n Setup cancelled."));
+                return;
+            }
+            if (serverChoicePrompt.value === "live") {
+                serverUrlInput = DEFAULT_UMBRELLA_SERVER_URL;
+            }
+            else if (serverChoicePrompt.value === "local") {
+                serverUrlInput = LOCAL_UMBRELLA_SERVER_URL;
+            }
+            else {
+                const customServerPrompt = await prompts({
+                    initial: defaultServerChoice === "custom"
+                        ? normalizedSuggestedServer
+                        : DEFAULT_UMBRELLA_SERVER_URL,
+                    message: "Custom Umbrella server URL",
+                    name: "value",
+                    type: "text",
+                    validate: (value) => {
+                        try {
+                            normalizeUmbrellaServerUrl(value);
+                            return true;
+                        }
+                        catch {
+                            return "Enter a valid URL like http://5.161.55.138:3100";
+                        }
+                    },
+                });
+                if (!customServerPrompt.value) {
+                    console.log(chalk.red("\n Setup cancelled."));
+                    return;
+                }
+                serverUrlInput = customServerPrompt.value;
+            }
+        }
+        const serverUrl = normalizeUmbrellaServerUrl(serverUrlInput ||
             envServerUrl ||
             existing?.umbrellaUrl ||
             existing?.serverUrl ||
@@ -163,29 +328,24 @@ export function setupCommand(cli) {
         try {
             let cookie = null;
             let companies = [];
+            let signedInEmail = options.email?.trim() || null;
+            console.log(chalk.gray(` Checking ${serverUrl} ...`));
             setUmbrellaAuthChecking(serverUrl);
             const serverCheck = await checkUmbrellaOnboardingServer(serverUrl);
             if (serverCheck.deploymentMode === "authenticated") {
-                const emailPrompt = await prompts({
-                    message: "Umbrella email",
-                    name: "value",
-                    type: options.email ? null : "text",
-                });
-                const passwordPrompt = await prompts({
-                    message: "Umbrella password",
-                    name: "value",
-                    type: options.password ? null : "password",
-                });
-                const email = options.email?.trim() || emailPrompt.value;
-                const password = options.password?.trim() || passwordPrompt.value;
-                if (!email || !password) {
+                const signInResult = await attemptAuthenticatedSignIn(serverUrl, options);
+                if (signInResult.kind === "cancelled") {
                     console.log(chalk.red("\n Sign-in cancelled."));
                     return;
                 }
-                const signIn = await signInUmbrellaOnboarding(serverUrl, email, password);
-                cookie = signIn.cookie;
-                companies = signIn.companies;
-                const authSnapshot = setUmbrellaAuthAuthorized(serverUrl, email, companies.length);
+                if (signInResult.kind === "failure") {
+                    throw signInResult.error;
+                }
+                const successfulSignIn = signInResult;
+                cookie = successfulSignIn.cookie;
+                companies = successfulSignIn.companies;
+                signedInEmail = successfulSignIn.email;
+                const authSnapshot = setUmbrellaAuthAuthorized(serverUrl, signedInEmail, companies.length);
                 console.log(chalk.gray(` Auth state: ${formatUmbrellaAuthStatus(authSnapshot.status)}`));
                 if (companies.length === 0) {
                     console.log(chalk.yellow("\n Signed in, but this account does not currently see any companies. That usually means the account exists but has not been given board access or company membership yet."));

package/dist/commands/space.js

@@ -1,7 +1,7 @@
 import chalk from "chalk";
 import prompts from "prompts";
 import { configManager } from "../config.js";
-import { ensureRepoContext, recordSessionEvent, setSessionPanel } from "../repo-state.js";
+import { ensureRepoContext, findRepoRoot, recordSessionEvent, setSessionPanel } from "../repo-state.js";
 import { pullCommandAction } from "./pull.js";
 import { createContextSpace, getCliSetup, getCompanyContextSummary, toContextSpaces } from "../umbrella.js";
 export async function spaceCommandAction(action, spaceArg) {
@@ -15,6 +15,7 @@ export async function spaceCommandAction(action, spaceArg) {
         return;
     }
     const normalizedAction = action.toLowerCase();
+    const repoRoot = await findRepoRoot(process.cwd());
     const summary = await getCompanyContextSummary(config.umbrellaUrl, config.companyId);
     const spaces = toContextSpaces(summary);
     if (normalizedAction === "list") {
@@ -67,7 +68,7 @@ export async function spaceCommandAction(action, spaceArg) {
             projectName: setup.activeSpaceName,
         });
         configManager.upsertLocation({
-            repoRoot: process.cwd(),
+            repoRoot,
             companyId: setup.companyId,
             companyName: setup.companyName,
             projectId: setup.activeSpaceId,
@@ -129,7 +130,7 @@ export async function spaceCommandAction(action, spaceArg) {
         projectName: setup.activeSpaceName,
     });
     configManager.upsertLocation({
-        repoRoot: process.cwd(),
+        repoRoot,
         companyId: setup.companyId,
         companyName: setup.companyName,
         projectId: setup.activeSpaceId,

package/dist/commands/status.d.ts

@@ -1,10 +1,13 @@
 import { type UmbrellaAuthSnapshot } from "../auth-state.js";
+import { type AgentMemoryConfig } from "../config.js";
 export type StatusSnapshot = {
     authSnapshot: UmbrellaAuthSnapshot;
     companyName: string;
     spaceName: string;
     umbrellaUrl: string | null;
     serverUrl: string;
+    connectionMode: "saved_local_config" | "verified_live_connection";
+    connectionSummary: string;
     currentDirectory: string;
     repoRoot: string;
     umDir: string;
@@ -26,8 +29,20 @@ export type StatusSnapshot = {
     transportQueue: number;
     transportActiveTask: string;
     contextTreeSummary: string;
+    warnings: string[];
     nextSteps: string[];
 };
+type OutputFormat = "text" | "json";
+export type ConnectionPresentation = {
+    authSnapshot: UmbrellaAuthSnapshot;
+    connectionMode: "saved_local_config" | "verified_live_connection";
+    connectionSummary: string;
+    warnings: string[];
+};
+export declare function buildConnectionPresentation(config: Pick<AgentMemoryConfig, "serverUrl" | "umbrellaUrl">, authSnapshot?: UmbrellaAuthSnapshot): ConnectionPresentation;
 export declare function getStatusSnapshot(): Promise<StatusSnapshot>;
-export declare function statusCommandAction(): Promise<void>;
+export declare function statusCommandAction(opts?: {
+    format?: OutputFormat;
+}): Promise<void>;
 export declare function statusCommand(cli: any): void;
+export {};

package/dist/commands/status.js

@@ -5,6 +5,46 @@ import { formatUmbrellaAuthStatus } from "../auth-state.js";
 import { getStoredUmbrellaAuthSnapshot } from "../adapters/umbrella-auth-runtime.js";
 import { configManager } from "../config.js";
 import { getConnectorRuns, getContextTreeState, getInstalledConnectors, getInstalledHubEntries, getPendingMemories, getPulledFixes, getPulledMemories, getRepoContext, ensureSessionState, getTransportState, } from "../repo-state.js";
+export function buildConnectionPresentation(config, authSnapshot = getStoredUmbrellaAuthSnapshot()) {
+    const warnings = [];
+    const connectionMode = authSnapshot.status === "authorized"
+        ? "verified_live_connection"
+        : "saved_local_config";
+    const normalizedAuthSnapshot = connectionMode === "saved_local_config" && authSnapshot.status === "checking"
+        ? {
+            ...authSnapshot,
+            hint: "The last live sign-in check did not finish, so this device is still falling back to saved local setup.",
+            message: "Saved local setup is present, but the live Umbrella connection has not been verified yet.",
+            status: "not_initialized",
+        }
+        : authSnapshot;
+    const connectionSummary = connectionMode === "verified_live_connection"
+        ? "This device last completed a real Umbrella sign-in check, so the saved company and space should match a live server session."
+        : "This device still has saved local setup details, but the current Umbrella sign-in has not been verified yet. Treat the company and space below as saved local selections until setup succeeds again.";
+    if (config.umbrellaUrl && config.serverUrl) {
+        try {
+            const umbrella = new URL(config.umbrellaUrl);
+            const backend = new URL(config.serverUrl);
+            const umbrellaIsLoopback = ["127.0.0.1", "localhost"].includes(umbrella.hostname.toLowerCase());
+            const backendIsLoopback = ["127.0.0.1", "localhost"].includes(backend.hostname.toLowerCase());
+            if (umbrella.hostname !== backend.hostname || umbrella.port !== backend.port) {
+                warnings.push(`The saved Umbrella app URL (${config.umbrellaUrl}) and Context backend URL (${config.serverUrl}) point to different places.`);
+            }
+            if (umbrellaIsLoopback !== backendIsLoopback) {
+                warnings.push("One saved URL points to a local-only address while the other points somewhere else. This usually means setup mixed a local app URL with a remote backend URL.");
+            }
+        }
+        catch {
+            warnings.push("One of the saved server URLs could not be parsed cleanly. Re-run setup to refresh the connection details.");
+        }
+    }
+    return {
+        authSnapshot: normalizedAuthSnapshot,
+        connectionMode,
+        connectionSummary,
+        warnings,
+    };
+}
 export async function getStatusSnapshot() {
     const config = configManager.config;
     if (!config) {
@@ -34,6 +74,7 @@ export async function getStatusSnapshot() {
         mcpConfigured = false;
     }
     const nextSteps = [];
+    const warnings = [];
     if (pending.length > 0)
         nextSteps.push(`Run "umbrella-context push" to share ${pending.length} local draft${pending.length === 1 ? "" : "s"}.`);
     if (!activeProvider || !config.activeModel) {
@@ -45,12 +86,18 @@ export async function getStatusSnapshot() {
         nextSteps.push('Add a first repo connector with "umbrella-context connectors install".');
     if (hubEntries.length === 0)
         nextSteps.push('Browse reusable bundles with "umbrella-context hub list".');
+    const connection = buildConnectionPresentation(config);
+    if (connection.connectionMode === "saved_local_config") {
+        nextSteps.unshift('Re-run "umbrella-context setup" to verify the live Umbrella connection before trusting the saved company and space.');
+    }
     return {
-        authSnapshot: getStoredUmbrellaAuthSnapshot(),
+        authSnapshot: connection.authSnapshot,
         companyName: config.companyName,
         spaceName: config.projectName,
         umbrellaUrl: config.umbrellaUrl ?? null,
         serverUrl: config.serverUrl,
+        connectionMode: connection.connectionMode,
+        connectionSummary: connection.connectionSummary,
         currentDirectory: process.cwd(),
         repoRoot,
         umDir,
@@ -74,72 +121,89 @@ export async function getStatusSnapshot() {
         transportQueue: transport?.queue.length ?? 0,
         transportActiveTask: transport?.activeTaskId ?? "None",
         contextTreeSummary: contextTree?.summaryHandle ?? "No context tree summary yet",
+        warnings: connection.warnings,
         nextSteps,
     };
 }
-export async function statusCommandAction() {
+function printStatusJson(snapshot) {
+    console.log(JSON.stringify({ ok: true, action: "status", ...snapshot }, null, 2));
+}
+function formatTextConnectionMode(mode) {
+    return mode === "verified_live_connection" ? "Verified live connection" : "Saved local config only";
+}
+function printBullets(items) {
+    for (const item of items) {
+        console.log(`- ${item}`);
+    }
+}
+export async function statusCommandAction(opts = {}) {
     let snapshot;
     try {
         snapshot = await getStatusSnapshot();
     }
     catch (err) {
+        if (opts.format === "json") {
+            console.log(JSON.stringify({ ok: false, action: "status", error: err.message }, null, 2));
+            return;
+        }
         console.log(chalk.red(err.message));
         return;
     }
+    if (opts.format === "json") {
+        printStatusJson(snapshot);
+        return;
+    }
     console.log(chalk.bold("\n Umbrella Context Status\n"));
-    console.log(chalk.cyan(" Auth"));
-    console.log(`  State: ${formatUmbrellaAuthStatus(snapshot.authSnapshot.status)}`);
-    console.log(`  Checked At: ${snapshot.authSnapshot.checkedAt === new Date(0).toISOString() ? "Never" : snapshot.authSnapshot.checkedAt}`);
-    console.log(`  Auth Server: ${snapshot.authSnapshot.serverUrl ?? "Not checked yet"}`);
-    console.log(`  Email: ${snapshot.authSnapshot.email ?? "Not saved"}`);
-    console.log(`  Companies Visible: ${snapshot.authSnapshot.companiesVisible === null ? "Unknown" : String(snapshot.authSnapshot.companiesVisible)}`);
-    console.log(`  Auth Message: ${snapshot.authSnapshot.message ?? "No auth check has been saved yet"}`);
-    console.log(`  Auth Hint: ${snapshot.authSnapshot.hint ?? "No auth hint recorded yet"}`);
-    console.log("");
-    console.log(chalk.cyan(" Connection"));
-    console.log(`  Company: ${snapshot.companyName}`);
-    console.log(`  Space: ${snapshot.spaceName}`);
-    console.log(`  Umbrella: ${snapshot.umbrellaUrl ?? "Not saved"}`);
-    console.log(`  Context Backend: ${snapshot.serverUrl}`);
+    console.log(`Connection: ${formatTextConnectionMode(snapshot.connectionMode)}`);
+    console.log(`Auth: ${formatUmbrellaAuthStatus(snapshot.authSnapshot.status)}`);
+    console.log(`Workspace: ${snapshot.companyName} / ${snapshot.spaceName}`);
+    console.log(`Current Directory: ${snapshot.currentDirectory}`);
+    console.log(`Provider: ${snapshot.providerLabel}`);
+    console.log(`Model: ${snapshot.modelLabel}`);
+    console.log(`Context Tree: ${snapshot.contextTreeSummary}`);
     console.log("");
-    console.log(chalk.cyan(" Local Repo"));
-    console.log(`  Current Directory: ${snapshot.currentDirectory}`);
-    console.log(`  Repo Root: ${snapshot.repoRoot}`);
-    console.log(`  Local Context Folder: ${snapshot.umDir}`);
-    console.log(`  Pending Local Context: ${snapshot.pendingCount}`);
-    console.log(`  Pulled Context Snapshot: ${snapshot.pulledContextCount}`);
-    console.log(`  Pulled Known Fixes: ${snapshot.pulledFixCount}`);
-    console.log(`  Last Push: ${snapshot.lastPushAt}`);
-    console.log(`  Last Pull: ${snapshot.lastPullAt}`);
-    console.log("");
-    console.log(chalk.cyan(" Repo Ecosystem"));
-    console.log(`  Hub Entries Installed: ${snapshot.hubEntriesCount}`);
-    console.log(`  Connectors Installed: ${snapshot.connectorsCount}`);
-    console.log(`  Repo MCP Wired: ${snapshot.mcpConfigured ? "Yes" : "No"}`);
-    console.log(`  Last Connector Run: ${snapshot.latestConnectorRun}`);
+    console.log(chalk.cyan("Summary"));
+    console.log(snapshot.connectionSummary);
+    if (snapshot.authSnapshot.message) {
+        console.log(snapshot.authSnapshot.message);
+    }
     console.log("");
-    console.log(chalk.cyan(" Model Runtime"));
-    console.log(`  Provider: ${snapshot.providerLabel}`);
-    console.log(`  Model: ${snapshot.modelLabel}`);
-    console.log(`  Session Panel: ${snapshot.currentPanel}`);
-    console.log(`  Session Focus: ${snapshot.currentFocus}`);
-    console.log(`  Latest Session Event: ${snapshot.latestEvent}`);
-    console.log(`  Transport Status: ${snapshot.transportStatus}`);
-    console.log(`  Transport Queue: ${snapshot.transportQueue}`);
-    console.log(`  Active Task: ${snapshot.transportActiveTask}`);
+    console.log(chalk.cyan("Local Context"));
+    printBullets([
+        `${snapshot.pendingCount} pending draft${snapshot.pendingCount === 1 ? "" : "s"}`,
+        `${snapshot.pulledContextCount} pulled note${snapshot.pulledContextCount === 1 ? "" : "s"}`,
+        `${snapshot.pulledFixCount} pulled known fix${snapshot.pulledFixCount === 1 ? "" : "es"}`,
+        `Last push: ${snapshot.lastPushAt}`,
+        `Last pull: ${snapshot.lastPullAt}`,
+    ]);
     console.log("");
-    console.log(chalk.cyan(" Context Tree"));
-    console.log(`  Summary: ${snapshot.contextTreeSummary}`);
+    console.log(chalk.cyan("Runtime"));
+    printBullets([
+        `Panel: ${snapshot.currentPanel}`,
+        `Focus: ${snapshot.currentFocus}`,
+        `Latest event: ${snapshot.latestEvent}`,
+        `Transport: ${snapshot.transportStatus}`,
+        `Queue: ${snapshot.transportQueue}`,
+        `Active task: ${snapshot.transportActiveTask}`,
+    ]);
+    if (snapshot.warnings.length > 0) {
+        console.log("");
+        console.log(chalk.yellow(" Warnings"));
+        printBullets(snapshot.warnings);
+    }
     if (snapshot.nextSteps.length > 0) {
         console.log("");
         console.log(chalk.cyan(" Suggested Next Steps"));
-        snapshot.nextSteps.forEach((step) => {
-            console.log(`  - ${step}`);
-        });
+        printBullets(snapshot.nextSteps);
     }
 }
 export function statusCommand(cli) {
-    cli.command("status", "Show the current repo, company, space, and local sync state").action(async () => {
-        await statusCommandAction();
+    cli
+        .command("status", "Show the current repo, company, space, and local sync state")
+        .option("--format <format>", "Output format (text or json)")
+        .example("status")
+        .example("status --format json")
+        .action(async (opts) => {
+        await statusCommandAction(opts);
     });
 }