umbrella-context 0.1.2 → 0.1.32

package/dist/commands/space.js

@@ -1,52 +1,57 @@
 import chalk from "chalk";
 import prompts from "prompts";
 import { configManager } from "../config.js";
-import { ensureRepoContext } from "../repo-state.js";
-import { getCliSetup, getCompanyContextSummary, toContextSpaces } from "../umbrella.js";
-export function spaceCommand(cli) {
-    cli
-        .command("space <action> [space]", "List or switch context spaces for the current company")
-        .action(async (action, spaceArg) => {
-        const config = configManager.config;
-        if (!config) {
-            console.log(chalk.red("Not configured. Run: umbrella-context setup"));
-            return;
-        }
-        if (!config.umbrellaUrl) {
-            console.log(chalk.red("No Umbrella URL saved for this device. Run umbrella-context setup to enable space commands."));
-            return;
-        }
-        const normalizedAction = action.toLowerCase();
-        const summary = await getCompanyContextSummary(config.umbrellaUrl, config.companyId);
-        const spaces = toContextSpaces(summary);
-        if (normalizedAction === "list") {
-            console.log(chalk.bold(`\n Spaces for ${config.companyName}\n`));
-            spaces.forEach((entry, index) => {
-                const active = entry.id === config.projectId ? " (active)" : "";
-                const primary = entry.isPrimary ? " [core]" : "";
-                console.log(` ${index + 1}. ${entry.name}${primary}${active}`);
-            });
-            return;
-        }
-        if (normalizedAction !== "switch") {
-            console.log(chalk.red("Use either 'umbrella-context space list' or 'umbrella-context space switch'."));
-            return;
-        }
-        let chosen = spaces.find((entry) => entry.id === spaceArg || entry.name.toLowerCase() === (spaceArg ?? "").toLowerCase()) ?? null;
-        if (!chosen) {
+import { ensureRepoContext, 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) {
+    const config = configManager.config;
+    if (!config) {
+        console.log(chalk.red("Not configured. Run: umbrella-context setup"));
+        return;
+    }
+    if (!config.umbrellaUrl) {
+        console.log(chalk.red("No Umbrella URL saved for this device. Run umbrella-context setup to enable space commands."));
+        return;
+    }
+    const normalizedAction = action.toLowerCase();
+    const summary = await getCompanyContextSummary(config.umbrellaUrl, config.companyId);
+    const spaces = toContextSpaces(summary);
+    if (normalizedAction === "list") {
+        await setSessionPanel("space", "list");
+        console.log(chalk.bold(`\n Spaces for ${config.companyName}\n`));
+        spaces.forEach((entry, index) => {
+            const active = entry.id === config.projectId ? " (active)" : "";
+            const primary = entry.isPrimary ? " [core]" : "";
+            console.log(` ${index + 1}. ${entry.name}${primary}${active}`);
+        });
+        return {
+            action: "list",
+            changed: false,
+            companyName: config.companyName,
+            currentSpaceName: config.projectName,
+            spaces,
+        };
+    }
+    if (normalizedAction === "create") {
+        let nextName = spaceArg?.trim() ?? "";
+        if (!nextName) {
             const answer = await prompts({
-                type: "select",
+                type: "text",
                 name: "value",
-                message: "Choose a context space",
-                choices: spaces.map((entry) => ({
-                    title: entry.isPrimary ? `${entry.name} (core)` : entry.name,
-                    value: entry.id,
-                })),
+                message: `Name the new space for ${config.companyName}`,
             });
-            chosen = spaces.find((entry) => entry.id === answer.value) ?? null;
+            nextName = answer.value?.trim() ?? "";
         }
+        if (!nextName) {
+            console.log(chalk.yellow("\n No space name provided."));
+            return;
+        }
+        const created = await createContextSpace(config.umbrellaUrl, config.companyId, nextName);
+        const createdSpaces = toContextSpaces(created);
+        const chosen = createdSpaces.find((entry) => entry.id === created.activeProjectId) ?? null;
         if (!chosen) {
-            console.log(chalk.yellow("\n No space selected."));
+            console.log(chalk.red("\n The new space was created, but the CLI could not find it in the returned summary."));
             return;
         }
         const setup = await getCliSetup(config.umbrellaUrl, config.companyId, chosen.id);
@@ -70,6 +75,97 @@ export function spaceCommand(cli) {
             updatedAt: new Date().toISOString(),
         });
         await ensureRepoContext(configManager.config);
-        console.log(chalk.green(`\n Switched to ${setup.companyName} / ${setup.activeSpaceName}`));
+        await setSessionPanel("space", setup.activeSpaceName);
+        await recordSessionEvent({
+            kind: "space",
+            title: `Created and switched to ${setup.activeSpaceName}`,
+            detail: `The repo is now linked to the new ${setup.companyName} space ${setup.activeSpaceName}.`,
+            panel: "space",
+            focus: setup.activeSpaceName,
+            status: "success",
+        });
+        console.log(chalk.green(`\n Created and switched to ${setup.companyName} / ${setup.activeSpaceName}`));
+        console.log(chalk.gray(" Pulling the latest shared Context snapshot for this space..."));
+        await pullCommandAction();
+        return {
+            action: "create",
+            changed: true,
+            companyName: setup.companyName,
+            currentSpaceName: setup.activeSpaceName,
+            spaces: createdSpaces,
+        };
+    }
+    if (normalizedAction !== "switch") {
+        console.log(chalk.red("Use: umbrella-context space list | switch | create"));
+        return;
+    }
+    let chosen = spaces.find((entry) => entry.id === spaceArg || entry.name.toLowerCase() === (spaceArg ?? "").toLowerCase()) ?? null;
+    if (!chosen) {
+        const answer = await prompts({
+            type: "select",
+            name: "value",
+            message: "Choose a context space",
+            choices: spaces.map((entry) => ({
+                title: entry.isPrimary ? `${entry.name} (core)` : entry.name,
+                value: entry.id,
+            })),
+        });
+        chosen = spaces.find((entry) => entry.id === answer.value) ?? null;
+    }
+    if (!chosen) {
+        console.log(chalk.yellow("\n No space selected."));
+        return;
+    }
+    const setup = await getCliSetup(config.umbrellaUrl, config.companyId, chosen.id);
+    configManager.set({
+        umbrellaUrl: config.umbrellaUrl,
+        serverUrl: setup.baseUrl,
+        apiKey: setup.apiKey,
+        companyId: setup.companyId,
+        companyName: setup.companyName,
+        workspaceId: setup.workspaceId,
+        workspaceName: setup.workspaceName,
+        projectId: setup.activeSpaceId,
+        projectName: setup.activeSpaceName,
+    });
+    configManager.upsertLocation({
+        repoRoot: process.cwd(),
+        companyId: setup.companyId,
+        companyName: setup.companyName,
+        projectId: setup.activeSpaceId,
+        projectName: setup.activeSpaceName,
+        updatedAt: new Date().toISOString(),
+    });
+    await ensureRepoContext(configManager.config);
+    await setSessionPanel("space", setup.activeSpaceName);
+    await recordSessionEvent({
+        kind: "space",
+        title: `Switched repo to ${setup.activeSpaceName}`,
+        detail: `The active Context space for ${setup.companyName} is now ${setup.activeSpaceName}.`,
+        panel: "space",
+        focus: setup.activeSpaceName,
+        status: "success",
+    });
+    console.log(chalk.green(`\n Switched to ${setup.companyName} / ${setup.activeSpaceName}`));
+    console.log(chalk.gray(" Pulling the latest shared Context snapshot for this space..."));
+    await pullCommandAction();
+    return {
+        action: "switch",
+        changed: true,
+        companyName: setup.companyName,
+        currentSpaceName: setup.activeSpaceName,
+        spaces,
+    };
+}
+export function spaceCommand(cli) {
+    cli
+        .command("space <action> [space]", "List, switch, or create context spaces for the current company")
+        .action(async (action, spaceArg) => {
+        try {
+            await spaceCommandAction(action, spaceArg);
+        }
+        catch (err) {
+            console.log(chalk.red(`Could not load spaces: ${err.message}`));
+        }
     });
 }

package/dist/commands/status.d.ts

@@ -1,2 +1,31 @@
+export type StatusSnapshot = {
+    companyName: string;
+    spaceName: string;
+    umbrellaUrl: string | null;
+    serverUrl: string;
+    currentDirectory: string;
+    repoRoot: string;
+    umDir: string;
+    pendingCount: number;
+    pulledContextCount: number;
+    pulledFixCount: number;
+    lastPushAt: string;
+    lastPullAt: string;
+    hubEntriesCount: number;
+    connectorsCount: number;
+    mcpConfigured: boolean;
+    latestConnectorRun: string;
+    providerLabel: string;
+    modelLabel: string;
+    currentPanel: string;
+    currentFocus: string;
+    latestEvent: string;
+    transportStatus: string;
+    transportQueue: number;
+    transportActiveTask: string;
+    contextTreeSummary: string;
+    nextSteps: string[];
+};
+export declare function getStatusSnapshot(): Promise<StatusSnapshot>;
 export declare function statusCommandAction(): Promise<void>;
 export declare function statusCommand(cli: any): void;

package/dist/commands/status.js

@@ -1,29 +1,130 @@
 import chalk from "chalk";
+import { promises as fs } from "fs";
+import path from "path";
 import { configManager } from "../config.js";
-import { getPendingMemories, getPulledFixes, getPulledMemories, getRepoContext } from "../repo-state.js";
-export async function statusCommandAction() {
+import { getConnectorRuns, getContextTreeState, getInstalledConnectors, getInstalledHubEntries, getPendingMemories, getPulledFixes, getPulledMemories, getRepoContext, ensureSessionState, getTransportState, } from "../repo-state.js";
+export async function getStatusSnapshot() {
     const config = configManager.config;
     if (!config) {
-        console.log(chalk.red("Not configured. Run: umbrella-context setup"));
-        return;
+        throw new Error("Not configured. Run: umbrella-context setup");
     }
     const { repoRoot, state, umDir } = await getRepoContext();
-    const pending = await getPendingMemories();
-    const pulledMemories = await getPulledMemories();
-    const pulledFixes = await getPulledFixes();
+    const session = await ensureSessionState();
+    const latestEvent = session.events?.[0] ?? null;
+    const [pending, pulledMemories, pulledFixes, connectors, hubEntries, connectorRuns, transport, contextTree] = await Promise.all([
+        getPendingMemories(),
+        getPulledMemories(),
+        getPulledFixes(),
+        getInstalledConnectors(),
+        getInstalledHubEntries(),
+        getConnectorRuns(),
+        getTransportState(),
+        getContextTreeState(),
+    ]);
+    const activeProvider = configManager.providers.find((entry) => entry.id === config.activeProvider) ?? null;
+    const latestConnectorRun = connectorRuns[0] ?? null;
+    let mcpConfigured = false;
+    try {
+        const repoMcp = JSON.parse(await fs.readFile(path.join(repoRoot, ".mcp.json"), "utf8"));
+        mcpConfigured = Boolean(repoMcp?.mcpServers?.["umbrella-context"]);
+    }
+    catch {
+        mcpConfigured = false;
+    }
+    const nextSteps = [];
+    if (pending.length > 0)
+        nextSteps.push(`Run "umbrella-context push" to share ${pending.length} local draft${pending.length === 1 ? "" : "s"}.`);
+    if (!activeProvider || !config.activeModel) {
+        nextSteps.push('Finish runtime setup with "umbrella-context providers setup".');
+    }
+    if (!mcpConfigured)
+        nextSteps.push('Install the MCP bridge with "umbrella-context connectors install codex-mcp".');
+    if (connectors.length === 0)
+        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".');
+    return {
+        companyName: config.companyName,
+        spaceName: config.projectName,
+        umbrellaUrl: config.umbrellaUrl ?? null,
+        serverUrl: config.serverUrl,
+        currentDirectory: process.cwd(),
+        repoRoot,
+        umDir,
+        pendingCount: pending.length,
+        pulledContextCount: pulledMemories.length,
+        pulledFixCount: pulledFixes.length,
+        lastPushAt: state?.lastPushAt ?? "Never",
+        lastPullAt: state?.lastPullAt ?? "Never",
+        hubEntriesCount: hubEntries.length,
+        connectorsCount: connectors.length,
+        mcpConfigured,
+        latestConnectorRun: latestConnectorRun
+            ? `${latestConnectorRun.connectorName} (${latestConnectorRun.status}) at ${latestConnectorRun.ranAt}`
+            : "Never",
+        providerLabel: activeProvider ? `${activeProvider.name} (${activeProvider.kind})` : "Not connected",
+        modelLabel: config.activeModel ?? "Not selected",
+        currentPanel: session.currentPanel ?? "Home",
+        currentFocus: session.currentFocus ?? "None",
+        latestEvent: latestEvent ? `${latestEvent.title} (${latestEvent.status})` : "No session events yet",
+        transportStatus: transport?.status ?? "unknown",
+        transportQueue: transport?.queue.length ?? 0,
+        transportActiveTask: transport?.activeTaskId ?? "None",
+        contextTreeSummary: contextTree?.summaryHandle ?? "No context tree summary yet",
+        nextSteps,
+    };
+}
+export async function statusCommandAction() {
+    let snapshot;
+    try {
+        snapshot = await getStatusSnapshot();
+    }
+    catch (err) {
+        console.log(chalk.red(err.message));
+        return;
+    }
     console.log(chalk.bold("\n Umbrella Context Status\n"));
-    console.log(` Company: ${config.companyName}`);
-    console.log(` Space: ${config.projectName}`);
-    console.log(` Umbrella: ${config.umbrellaUrl ?? "Not saved"}`);
-    console.log(` Server: ${config.serverUrl}`);
-    console.log(` Current Directory: ${process.cwd()}`);
-    console.log(` Repo Root: ${repoRoot}`);
-    console.log(` Local Context Folder: ${umDir}`);
-    console.log(` Pending Local Context: ${pending.length}`);
-    console.log(` Pulled Context Snapshot: ${pulledMemories.length}`);
-    console.log(` Pulled Known Fixes: ${pulledFixes.length}`);
-    console.log(` Last Push: ${state?.lastPushAt ?? "Never"}`);
-    console.log(` Last Pull: ${state?.lastPullAt ?? "Never"}`);
+    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("");
+    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("");
+    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("");
+    console.log(chalk.cyan(" Context Tree"));
+    console.log(`  Summary: ${snapshot.contextTreeSummary}`);
+    if (snapshot.nextSteps.length > 0) {
+        console.log("");
+        console.log(chalk.cyan(" Suggested Next Steps"));
+        snapshot.nextSteps.forEach((step) => {
+            console.log(`  - ${step}`);
+        });
+    }
 }
 export function statusCommand(cli) {
     cli.command("status", "Show the current repo, company, space, and local sync state").action(async () => {

package/dist/commands/tasks.d.ts

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

package/dist/commands/tasks.js

@@ -0,0 +1,95 @@
+import chalk from "chalk";
+import { getTaskById, getTasks, getTransportState, setSessionPanel } from "../repo-state.js";
+export async function tasksCommandAction(action, target) {
+    await setSessionPanel("tasks", action === "inspect" ? target ?? "inspect" : "list");
+    const [tasks, transport] = await Promise.all([getTasks(), getTransportState()]);
+    if ((action ?? "list") === "inspect") {
+        const defaultTask = (transport?.activeTaskId ? await getTaskById(transport.activeTaskId) : null) ??
+            tasks[0] ??
+            null;
+        const task = target ? await getTaskById(target) : defaultTask;
+        if (!task) {
+            console.log(chalk.yellow("\n No task found to inspect."));
+            return;
+        }
+        console.log(chalk.bold(`\n Task ${task.id}\n`));
+        console.log(` Kind: ${task.kind}`);
+        console.log(` Title: ${task.title}`);
+        console.log(` Status: ${task.status}`);
+        console.log(` Created: ${new Date(task.createdAt).toLocaleString()}`);
+        console.log(` Started: ${task.startedAt ? new Date(task.startedAt).toLocaleString() : "Not started"}`);
+        console.log(` Finished: ${task.finishedAt ? new Date(task.finishedAt).toLocaleString() : "Not finished"}`);
+        console.log(` Focus: ${task.focus ?? "None"}`);
+        console.log(` Panel: ${task.panel ?? "None"}`);
+        console.log(` Session: ${task.sessionId ?? "None"}`);
+        console.log(` Result: ${task.result ?? "No final result yet"}`);
+        console.log(` Reasoning items: ${task.reasoningContents?.length ?? 0}`);
+        console.log(` Tool calls: ${task.toolCalls?.length ?? 0}`);
+        if (task.detail) {
+            console.log("");
+            console.log(chalk.cyan(" Detail"));
+            console.log(`  ${task.detail}`);
+        }
+        if (task.streamingContent) {
+            console.log("");
+            console.log(chalk.cyan(" Streaming"));
+            console.log(`  ${task.streamingContent}`);
+        }
+        if ((task.reasoningContents?.length ?? 0) > 0) {
+            console.log("");
+            console.log(chalk.cyan(" Reasoning"));
+            task.reasoningContents?.forEach((item, index) => {
+                console.log(`  ${index + 1}. ${item.content}`);
+                console.log(chalk.gray(`     ${new Date(item.timestamp).toLocaleString()}${item.isThinking ? " | thinking" : ""}`));
+            });
+        }
+        if ((task.toolCalls?.length ?? 0) > 0) {
+            console.log("");
+            console.log(chalk.cyan(" Tool Calls"));
+            task.toolCalls?.forEach((call, index) => {
+                console.log(`  ${index + 1}. ${call.toolName} (${call.status})`);
+                console.log(chalk.gray(`     ${new Date(call.timestamp).toLocaleString()}`));
+                console.log(chalk.gray(`     args: ${JSON.stringify(call.args)}`));
+                if (call.result !== undefined) {
+                    console.log(chalk.gray(`     result: ${JSON.stringify(call.result)}`));
+                }
+                if (call.error) {
+                    console.log(chalk.red(`     error: ${call.error}`));
+                }
+            });
+        }
+        return;
+    }
+    console.log(chalk.bold("\n Local Context Tasks\n"));
+    if (transport) {
+        console.log(chalk.cyan(" Transport"));
+        console.log(`  Status: ${transport.status}`);
+        console.log(`  Active task: ${transport.activeTaskId ?? "None"}`);
+        console.log(`  Queue: ${transport.queue.length}`);
+        console.log(`  Stats: queued=${transport.stats.queued} running=${transport.stats.running} completed=${transport.stats.completed} failed=${transport.stats.failed}`);
+        console.log("");
+    }
+    if (tasks.length === 0) {
+        console.log(chalk.yellow(" No local tasks yet."));
+        console.log(chalk.gray(" Ask a question, save a local note, or run push/pull to create task history."));
+        return;
+    }
+    tasks.slice(0, 20).forEach((task, index) => {
+        console.log(` ${index + 1}. [${task.kind}] ${task.title}`);
+        console.log(chalk.gray(`    Status: ${task.status} | Updated: ${new Date(task.updatedAt).toLocaleString()}`));
+        if (task.detail) {
+            console.log(chalk.gray(`    ${task.detail}`));
+        }
+        if (task.result) {
+            console.log(chalk.gray(`    Result: ${task.result}`));
+        }
+        if (task.toolCalls?.length) {
+            console.log(chalk.gray(`    Tool calls: ${task.toolCalls.length}`));
+        }
+    });
+}
+export function tasksCommand(cli) {
+    cli.command("tasks [action] [target]", "Show or inspect the local .um task history for this repo").action(async (action, target) => {
+        await tasksCommandAction(action, target);
+    });
+}

package/dist/commands/transport.d.ts

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

package/dist/commands/transport.js

@@ -0,0 +1,88 @@
+import chalk from "chalk";
+import { getTaskById, getTransportState, setSessionPanel } from "../repo-state.js";
+export async function transportCommandAction(action, target) {
+    const transport = await getTransportState();
+    const mode = (action ?? "status").toLowerCase();
+    await setSessionPanel("transport", mode === "inspect" ? target ?? "inspect" : mode);
+    if (mode === "events" || mode === "timeline") {
+        console.log(chalk.bold("\n Transport Timeline\n"));
+        if (transport.events.length === 0) {
+            console.log(chalk.yellow(" No transport events recorded yet."));
+            return;
+        }
+        transport.events.slice(0, 20).forEach((event, index) => {
+            console.log(` ${index + 1}. [${event.kind}] ${event.title}`);
+            console.log(chalk.gray(`    ${new Date(event.at).toLocaleString()} | ${event.status}`));
+            if (event.detail) {
+                console.log(chalk.gray(`    ${event.detail}`));
+            }
+        });
+        return;
+    }
+    if (mode === "inspect") {
+        const taskId = target ?? transport.activeTaskId ?? transport.queue[0]?.id ?? null;
+        if (!taskId) {
+            console.log(chalk.yellow("\n No transport-linked task is available to inspect."));
+            return;
+        }
+        const task = await getTaskById(taskId);
+        if (!task) {
+            console.log(chalk.yellow(`\n Task ${taskId} is no longer available in local task history.`));
+            return;
+        }
+        const relatedEvents = transport.events.filter((event) => event.taskId === taskId);
+        console.log(chalk.bold(`\n Transport Inspect for ${task.title}\n`));
+        console.log(` Task ID: ${task.id}`);
+        console.log(` Status: ${task.status}`);
+        console.log(` Kind: ${task.kind}`);
+        console.log(` Queue position: ${Math.max(transport.queue.findIndex((item) => item.id === taskId), 0) + 1}`);
+        console.log(` Related events: ${relatedEvents.length}`);
+        if (relatedEvents.length > 0) {
+            console.log("");
+            console.log(chalk.cyan(" Event Timeline"));
+            relatedEvents.forEach((event, index) => {
+                console.log(`  ${index + 1}. [${event.kind}] ${event.title}`);
+                console.log(chalk.gray(`     ${new Date(event.at).toLocaleString()} | ${event.status}`));
+                if (event.detail) {
+                    console.log(chalk.gray(`     ${event.detail}`));
+                }
+            });
+        }
+        return;
+    }
+    console.log(chalk.bold("\n Transport Engine\n"));
+    console.log(` Status: ${transport.status}`);
+    console.log(` Active task: ${transport.activeTaskId ?? "None"}`);
+    console.log(` Queue: ${transport.queue.length}`);
+    console.log(` Stats: queued=${transport.stats.queued} running=${transport.stats.running} completed=${transport.stats.completed} failed=${transport.stats.failed}`);
+    console.log(` Subscriptions: ${transport.subscriptions.join(", ")}`);
+    console.log(` Last push: ${transport.lastPushAt ?? "Never"}`);
+    console.log(` Last pull: ${transport.lastPullAt ?? "Never"}`);
+    console.log(` Last runtime check: ${transport.lastRuntimeCheckAt ?? "Never"}`);
+    if (Object.keys(transport.taskKinds ?? {}).length > 0) {
+        console.log(` Task kinds: ${Object.entries(transport.taskKinds)
+            .map(([kind, count]) => `${kind}=${count}`)
+            .join(", ")}`);
+    }
+    console.log("");
+    if (transport.queue.length > 0) {
+        console.log(chalk.cyan(" Queue"));
+        transport.queue.forEach((task, index) => {
+            console.log(`  ${index + 1}. [${task.kind}] ${task.title} (${task.status})`);
+        });
+        console.log("");
+    }
+    if (transport.events.length > 0) {
+        console.log(chalk.cyan(" Recent events"));
+        transport.events.slice(0, 8).forEach((event, index) => {
+            console.log(`  ${index + 1}. [${event.kind}] ${event.title}`);
+        });
+    }
+}
+export function transportCommand(cli) {
+    cli
+        .command("transport [action] [target]", "Show the live local transport engine and timeline")
+        .action(async (action, target) => {
+        await transportCommandAction(action, target);
+    });
+}

package/dist/commands/tree.d.ts

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