ivorleaf 1.1.0

package/LICENSE.md

@@ -0,0 +1,9 @@
+# Proprietary License
+
+Copyright (c) 2026 Ivorleaf. All rights reserved.
+
+This software and associated documentation files (the "Software") are proprietary and confidential. No license, right, title, or interest in the Software is granted except by prior written permission from Ivorleaf.
+
+You may not copy, modify, distribute, sublicense, sell, lease, publish, disclose, reverse engineer, decompile, or otherwise use the Software except as expressly authorized in writing by Ivorleaf.
+
+All rights not expressly granted are reserved.

package/README.md

@@ -0,0 +1,134 @@
+# Ivorleaf
+
+A cross-platform terminal client for the Ivorleaf API. Ivorleaf renders lessons and workflows as terminal-friendly Markdown, keeps an active learning session, and supports raw JSON output for debugging.
+
+## Installation
+
+```sh
+npm install -g ivorleaf
+```
+
+Requires Node.js 20 or newer.
+
+## Quick Start
+
+```sh
+ivorleaf init
+ivorleaf explore "using sql for lead management"
+ivorleaf quiz
+ivorleaf sources
+ivorleaf citations
+ivorleaf status
+ivorleaf exit
+```
+
+`explore` creates a lesson and stores the returned session as active. Follow-up commands such as `quiz`, `flashcards`, `citations`, `compare`, and `continue` use that active session automatically.
+
+## Authentication
+
+### `ivorleaf init`
+
+```sh
+ivorleaf init
+```
+
+`init` prompts for an Ivorleaf API key, validates it, and stores it at `~/.ivorleaf/config.json` with user-only permissions. The CLI never persists the API URL.
+
+Environment variables can override saved configuration for development or CI:
+
+```sh
+export IVORLEAF_API_URL="https://ivorleaf-api-745737209421.us-east1.run.app"
+export IVORLEAF_API_KEY="your-key"
+```
+
+The environment API key takes precedence over the saved key.
+
+## Commands
+
+```text
+ivorleaf init
+ivorleaf doctor
+ivorleaf limits
+ivorleaf explore <prompt...>
+ivorleaf quiz
+ivorleaf flashcards
+ivorleaf sources
+ivorleaf citations
+ivorleaf compare
+ivorleaf continue
+ivorleaf status
+ivorleaf exit
+ivorleaf clear-session
+ivorleaf history
+ivorleaf open <session_id>
+ivorleaf action <action_name> [session_id]
+ivorleaf recommend [session_id]
+ivorleaf help
+```
+
+Useful output flags:
+
+```text
+--json              Print the raw JSON API response
+--plain             Print unstyled Markdown
+--sources           Include full source details when available
+--debug-response    Print non-secret response-shape diagnostics
+--pager             Force paged output
+--no-pager          Disable paged output
+```
+
+Long terminal output opens in a paged reading view with session context and bottom hints. Use `--no-pager` for continuous output.
+
+## Examples
+
+```sh
+ivorleaf explore "Explain Newton's second law"
+ivorleaf explore using sql for lead management --show-sources
+ivorleaf quiz --sources
+ivorleaf flashcards
+ivorleaf citations
+ivorleaf compare
+ivorleaf continue --pager
+ivorleaf status
+ivorleaf clear-session
+ivorleaf history --json
+ivorleaf open SESSION_ID --plain
+```
+
+Paged output keeps the command, active session, topic/title, source and warning counts, and available workflows visible while the lesson or workflow body scrolls. Hints shown at the bottom include `q quit`, `↑/↓ scroll`, `Enter continue`, `s sources`, `c citations`, and `w workflows`.
+
+Every request sends:
+
+```text
+Authorization: Bearer <api_key>
+X-Ivorleaf-Client: cli
+```
+
+## Development
+
+```sh
+npm install
+npm run typecheck
+npm test
+npm run build
+node dist/index.js help
+node dist/index.js doctor
+node dist/index.js explore "Explain CRISPR simply"
+```
+
+Before publishing, run:
+
+```sh
+npm run prepublishOnly
+npm pack
+```
+
+Do not publish from local verification unless you intend to release:
+
+```sh
+npm publish
+```
+
+## License
+
+Proprietary / All Rights Reserved. See [LICENSE.md](LICENSE.md).

package/dist/api.js

@@ -0,0 +1,268 @@
+import { getApiKey, getApiUrl, redactSecrets } from "./config.js";
+export const ACTION_ROUTES = {
+    quiz: "/v1/history/{session_id}/quiz/generate",
+    flashcards: "/v1/history/{session_id}/flashcards/generate",
+    table: "/v1/history/{session_id}/workflows/table",
+    citation_builder: "/v1/history/{session_id}/workflows/citations",
+    educator_mode: "/v1/history/{session_id}/actions/educator_mode",
+    sop_mode: "/v1/history/{session_id}/actions/sop_mode",
+    review_sheet: "/v1/history/{session_id}/actions/review_sheet",
+    literature_expansion: "/v1/history/{session_id}/actions/literature_expansion",
+    source_comparison: "/v1/history/{session_id}/actions/source_comparison",
+};
+export function resolveActionRoute(sessionId, actionName) {
+    const route = ACTION_ROUTES[actionName];
+    if (!route) {
+        throw new ApiError(`Unknown workflow action "${actionName}". Supported actions: ${Object.keys(ACTION_ROUTES).join(", ")}`);
+    }
+    return route.replace("{session_id}", encodeURIComponent(sessionId));
+}
+export class ApiError extends Error {
+    status;
+    response;
+    constructor(message, status, response) {
+        super(message);
+        this.status = status;
+        this.response = response;
+        this.name = "ApiError";
+    }
+}
+export class IvorleafApi {
+    apiKey;
+    baseUrl;
+    constructor(apiKey, baseUrl = getApiUrl()) {
+        this.apiKey = apiKey;
+        this.baseUrl = baseUrl;
+    }
+    static async fromConfig() {
+        const key = await getApiKey();
+        if (!key)
+            throw new ApiError("No API key is configured.\n\nRun:\nivorleaf init");
+        return new IvorleafApi(key);
+    }
+    async request(path, init = {}) {
+        let response;
+        try {
+            response = await fetch(`${this.baseUrl}${path}`, {
+                ...init,
+                headers: {
+                    Authorization: `Bearer ${this.apiKey}`,
+                    "X-Ivorleaf-Client": "cli",
+                    Accept: "application/json",
+                    ...(init.body ? { "Content-Type": "application/json" } : {}),
+                    ...init.headers,
+                },
+            });
+        }
+        catch (error) {
+            throw new ApiError(`API unreachable. Verify internet connectivity and API availability.\n${redactSecrets(String(error))}`);
+        }
+        const text = await response.text();
+        let data = null;
+        if (text) {
+            try {
+                data = JSON.parse(text);
+            }
+            catch {
+                data = text;
+            }
+        }
+        if (!response.ok) {
+            const guidance = response.status === 401 || response.status === 403
+                ? "Verify the API key is active and has not been revoked. Run: ivorleaf init"
+                : `The API returned HTTP ${response.status}.`;
+            throw new ApiError(guidance, response.status, data);
+        }
+        if (text && typeof data === "string") {
+            throw new ApiError("The API returned a non-JSON response. Verify IVORLEAF_API_URL points to the Ivorleaf API.", response.status);
+        }
+        return data;
+    }
+    usageStatus() {
+        return this.request("/v1/api/usage/status");
+    }
+    createLesson(prompt) {
+        // TODO: Align this deliberately isolated payload if the FastAPI schema differs.
+        return this.request("/v1/lesson", { method: "POST", body: JSON.stringify({ prompt }) });
+    }
+    history() {
+        return this.request("/v1/history");
+    }
+    getSession(sessionId) {
+        return this.request(`/v1/history/${encodeURIComponent(sessionId)}`);
+    }
+    action(sessionId, actionName) {
+        return this.request(resolveActionRoute(sessionId, actionName), {
+            method: "POST",
+        });
+    }
+    orchestrate(sessionId, intent) {
+        // TODO: Align the intent field if the FastAPI request model uses a different name.
+        return this.request(`/v1/history/${encodeURIComponent(sessionId)}/orchestrate`, {
+            method: "POST",
+            body: JSON.stringify({ intent }),
+        });
+    }
+}
+export function asObject(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+export function findString(value, keys) {
+    const object = asObject(value);
+    for (const key of keys)
+        if (typeof object[key] === "string")
+            return object[key];
+    for (const nested of ["data", "result", "lesson", "session", "output"]) {
+        if (object[nested]) {
+            const found = findString(object[nested], keys);
+            if (found)
+                return found;
+        }
+    }
+    return null;
+}
+export function findPlan(value) {
+    return findNamedMetadataString(value, ["plan", "plan_name", "tier", "subscription_plan", "account_plan"]);
+}
+export function findRevisionId(value) {
+    return findNamedMetadataString(value, ["revision_id", "revisionId"]);
+}
+export function findSessionId(value, seen = new Set()) {
+    if (!value || typeof value !== "object" || seen.has(value))
+        return null;
+    seen.add(value);
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            const found = findSessionId(item, seen);
+            if (found)
+                return found;
+        }
+        return null;
+    }
+    const object = value;
+    for (const key of ["session_id", "sessionId"]) {
+        const candidate = object[key];
+        if (typeof candidate === "string" && candidate.trim())
+            return candidate.trim();
+        if (typeof candidate === "number" && Number.isFinite(candidate))
+            return String(candidate);
+    }
+    // An `id` is a session identifier only inside an explicitly named session object.
+    for (const key of ["session", "history_session"]) {
+        const session = asObject(object[key]);
+        const candidate = session.id;
+        if (typeof candidate === "string" && candidate.trim())
+            return candidate.trim();
+        if (typeof candidate === "number" && Number.isFinite(candidate))
+            return String(candidate);
+    }
+    for (const child of Object.values(object)) {
+        const found = findSessionId(child, seen);
+        if (found)
+            return found;
+    }
+    return null;
+}
+function findNamedMetadataString(value, keys, seen = new Set()) {
+    if (!value || typeof value !== "object" || seen.has(value))
+        return null;
+    seen.add(value);
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            const found = findNamedMetadataString(item, keys, seen);
+            if (found)
+                return found;
+        }
+        return null;
+    }
+    const object = value;
+    for (const key of keys) {
+        const candidate = object[key];
+        if (typeof candidate === "string" && candidate.trim())
+            return candidate.trim();
+        if (typeof candidate === "number" && Number.isFinite(candidate))
+            return String(candidate);
+    }
+    for (const [key, child] of Object.entries(object)) {
+        if (["sources", "source_details", "references", "citations", "citation_sources"].includes(key))
+            continue;
+        const found = findNamedMetadataString(child, keys, seen);
+        if (found)
+            return found;
+    }
+    return null;
+}
+export function findLatestHistorySessionId(value) {
+    const list = findHistoryList(value);
+    if (!list.length)
+        return null;
+    return findHistoryItemSessionId(list[0]);
+}
+export function findFreshHistorySessionId(lessonResponse, historyResponse) {
+    const requestId = findRequestId(lessonResponse);
+    if (!requestId)
+        return null;
+    const list = findHistoryList(historyResponse);
+    for (const item of list) {
+        if (findRequestId(item) === requestId)
+            return findHistoryItemSessionId(item);
+    }
+    return null;
+}
+export function findRequestId(value, seen = new Set()) {
+    if (!value || typeof value !== "object" || seen.has(value))
+        return null;
+    seen.add(value);
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            const found = findRequestId(item, seen);
+            if (found)
+                return found;
+        }
+        return null;
+    }
+    const object = value;
+    for (const key of ["request_id", "requestId"]) {
+        const candidate = object[key];
+        if (typeof candidate === "string" && candidate.trim())
+            return candidate.trim();
+        if (typeof candidate === "number" && Number.isFinite(candidate))
+            return String(candidate);
+    }
+    for (const child of Object.values(object)) {
+        const found = findRequestId(child, seen);
+        if (found)
+            return found;
+    }
+    return null;
+}
+function findHistoryList(value, seen = new Set()) {
+    if (!value || typeof value !== "object" || seen.has(value))
+        return [];
+    seen.add(value);
+    if (Array.isArray(value))
+        return value;
+    const object = value;
+    for (const key of ["sessions", "history", "items", "results"]) {
+        if (Array.isArray(object[key]))
+            return object[key];
+    }
+    for (const child of Object.values(object)) {
+        const found = findHistoryList(child, seen);
+        if (found.length)
+            return found;
+    }
+    return [];
+}
+function findHistoryItemSessionId(value) {
+    const object = asObject(value);
+    for (const key of ["session_id", "sessionId", "id"]) {
+        const candidate = object[key];
+        if (typeof candidate === "string" && candidate.trim())
+            return candidate.trim();
+        if (typeof candidate === "number" && Number.isFinite(candidate))
+            return String(candidate);
+    }
+    return findSessionId(value);
+}
+//# sourceMappingURL=api.js.map

package/dist/commands/action.js

@@ -0,0 +1,19 @@
+import { findRevisionId, findSessionId, IvorleafApi } from "../api.js";
+import { renderHeader, renderResponse } from "../render.js";
+import { getActiveSession, updateActiveSessionMetadata } from "../utils/activeSession.js";
+export async function actionCommand(actionName, sessionArg, options) {
+    const sessionId = sessionArg || await getActiveSession();
+    if (!sessionId)
+        throw new Error("No active session.\nRun:\nivorleaf open <session_id>\nor\nivorleaf explore <prompt>");
+    const data = await (await IvorleafApi.fromConfig()).action(sessionId, actionName);
+    const responseSessionId = findSessionId(data) || sessionId;
+    await updateActiveSessionMetadata({
+        sessionId: responseSessionId,
+        revisionId: findRevisionId(data),
+        command: `action ${actionName}`,
+    });
+    if (!options.json)
+        await renderHeader(`action ${actionName}`, { sessionId: responseSessionId });
+    await renderResponse(data, options, { kind: "workflow", actionName, sessionId: responseSessionId, command: actionName });
+}
+//# sourceMappingURL=action.js.map

package/dist/commands/clear.js

@@ -0,0 +1,7 @@
+import { success } from "../render.js";
+import { clearActiveSession } from "../utils/activeSession.js";
+export async function clearCommand() {
+    await clearActiveSession();
+    console.log(success("Active session cleared"));
+}
+//# sourceMappingURL=clear.js.map

package/dist/commands/doctor.js

@@ -0,0 +1,41 @@
+import { ApiError, IvorleafApi, asObject, findString } from "../api.js";
+import { CONFIG_PATH, loadConfig } from "../config.js";
+import { failure, renderHeader, success } from "../render.js";
+export async function doctorCommand() {
+    await renderHeader("doctor");
+    console.log("Ivorleaf CLI Doctor\n" + "─".repeat(24));
+    const config = await loadConfig();
+    console.log(`\nConfiguration\n${config ? success("Config Found") : failure("Config Missing")}`);
+    if (!config)
+        return suggestion(`Configuration was not found at ${CONFIG_PATH}.`);
+    console.log(`\nAuthentication\n${config.apiKey ? success("API Key Found") : failure("API Key Missing")}`);
+    if (!config.apiKey)
+        return suggestion("The configuration does not contain an API key.");
+    const start = performance.now();
+    try {
+        const status = await new IvorleafApi(config.apiKey).usageStatus();
+        const latency = Math.round(performance.now() - start);
+        const object = asObject(status);
+        const plan = findString(object, ["plan", "plan_name", "tier"]) || "Unknown";
+        const organization = findString(object, ["organization", "organization_id", "org_id", "org"]) || "Unknown";
+        console.log(success("API Key Valid"));
+        console.log(`\nConnection\n${success("API Reachable")}\nLatency: ${latency}ms`);
+        console.log(`\nAccount\nPlan: ${plan}\nOrganization: ${organization}`);
+        console.log(`\nStatus\n${success("System Healthy")}`);
+    }
+    catch (error) {
+        const unauthorized = error instanceof ApiError && [401, 403].includes(error.status || 0);
+        console.log(unauthorized ? failure("API Key Invalid") : failure("API Unreachable"));
+        console.log(`\nStatus\n${failure("Attention Required")}`);
+        if (unauthorized)
+            suggestion("Verify the API key is active and has not been revoked.");
+        else
+            console.log("\nSuggested Action:\nVerify internet connectivity and API availability.");
+        process.exitCode = 1;
+    }
+}
+function suggestion(reason) {
+    console.log(`\n${reason}\n\nSuggested Action:\nRun:\nivorleaf init`);
+    process.exitCode = 1;
+}
+//# sourceMappingURL=doctor.js.map

package/dist/commands/explore.js

@@ -0,0 +1,40 @@
+import { IvorleafApi, findFreshHistorySessionId, findPlan, findRevisionId, findSessionId } from "../api.js";
+import { extractSources, renderHeader, renderResponse } from "../render.js";
+import { clearActiveSession, updateActiveSessionMetadata } from "../utils/activeSession.js";
+import { clearRecentSources, setRecentSources } from "../utils/recentSources.js";
+import { workflowMenu } from "./workflowMenu.js";
+export async function exploreCommand(prompt, options) {
+    const api = await IvorleafApi.fromConfig();
+    const data = await api.createLesson(prompt);
+    let sessionId = findSessionId(data);
+    if (!sessionId && !options.json && !options.plain) {
+        try {
+            sessionId = findFreshHistorySessionId(data, await api.history());
+        }
+        catch {
+            sessionId = null;
+        }
+    }
+    if (sessionId)
+        await updateActiveSessionMetadata({
+            sessionId,
+            revisionId: findRevisionId(data),
+            command: "explore",
+        });
+    else
+        await clearActiveSession();
+    const sources = extractSources(data);
+    if (sources.length)
+        await setRecentSources(sources);
+    else
+        await clearRecentSources();
+    const plan = findPlan(data);
+    if (!options.json)
+        await renderHeader("explore", { plan, sessionId });
+    await renderResponse(data, options, { kind: "lesson", sessionId, plan, command: "explore" });
+    if (sessionId)
+        await workflowMenu(sessionId, options);
+    else if (!options.json && !options.plain)
+        console.log("\nNo session_id returned, so workflow actions are unavailable.");
+}
+//# sourceMappingURL=explore.js.map

package/dist/commands/history.js

@@ -0,0 +1,20 @@
+import { IvorleafApi, asObject, findString } from "../api.js";
+import { printJson, renderHeader } from "../render.js";
+export async function historyCommand(options) {
+    const data = await (await IvorleafApi.fromConfig()).history();
+    if (options.json)
+        return printJson(data);
+    await renderHeader("history");
+    const o = asObject(data);
+    const list = Array.isArray(data) ? data : [o.sessions, o.history, o.items, asObject(o.data).sessions].find(Array.isArray) || [];
+    if (!list.length)
+        return console.log("No history found.");
+    list.forEach((item, index) => {
+        const session = asObject(item);
+        const title = findString(session, ["title", "summary", "prompt"]) || "Untitled session";
+        const id = findString(session, ["session_id", "sessionId", "id"]) || "Unknown ID";
+        const date = findString(session, ["created_at", "updated_at", "date", "timestamp"]);
+        console.log(`${index + 1}. ${title}\n   ${id}${date ? ` · ${date}` : ""}`);
+    });
+}
+//# sourceMappingURL=history.js.map

package/dist/commands/init.js

@@ -0,0 +1,16 @@
+import { password } from "@inquirer/prompts";
+import { IvorleafApi } from "../api.js";
+import { CONFIG_PATH, saveConfig } from "../config.js";
+import { renderHeader, success } from "../render.js";
+export async function initCommand() {
+    await renderHeader("init");
+    const apiKey = (await password({ message: "Ivorleaf API key:", mask: "*" })).trim();
+    if (!apiKey)
+        throw new Error("An API key is required. No configuration was saved.");
+    process.stdout.write("Validating API key… ");
+    await new IvorleafApi(apiKey).usageStatus();
+    console.log(success("valid"));
+    await saveConfig({ apiKey });
+    console.log(`${success("Configuration saved")}\n${CONFIG_PATH}`);
+}
+//# sourceMappingURL=init.js.map

package/dist/commands/limits.js

@@ -0,0 +1,21 @@
+import { IvorleafApi, asObject, findString } from "../api.js";
+import { printJson, renderHeader } from "../render.js";
+export async function limitsCommand(options) {
+    const data = await (await IvorleafApi.fromConfig()).usageStatus();
+    if (options.json)
+        return printJson(data);
+    await renderHeader("limits", findString(data, ["plan", "plan_name", "tier"]));
+    const o = asObject(data);
+    const usage = asObject(o.usage ?? o.data ?? o);
+    console.log(`Plan: ${findString(data, ["plan", "plan_name", "tier"]) || "Unknown"}`);
+    console.log(formatLimit("Sessions", usage, ["sessions_used", "session_count"], ["sessions_limit", "session_limit"]));
+    const workflowLine = formatLimit("Workflows", usage, ["workflows_used", "workflow_count"], ["workflows_limit", "workflow_limit"]);
+    if (!workflowLine.endsWith("Unavailable"))
+        console.log(workflowLine);
+}
+function formatLimit(label, o, usedKeys, limitKeys) {
+    const get = (keys) => keys.map(k => o[k]).find(v => v !== undefined);
+    const used = get(usedKeys), limit = get(limitKeys);
+    return `${label}: ${used ?? "Unavailable"}${used !== undefined ? ` / ${limit ?? "Unlimited"}` : ""}`;
+}
+//# sourceMappingURL=limits.js.map

package/dist/commands/open.js

@@ -0,0 +1,25 @@
+import { IvorleafApi, findPlan, findRevisionId, findSessionId } from "../api.js";
+import { extractSources, renderHeader, renderResponse } from "../render.js";
+import { updateActiveSessionMetadata } from "../utils/activeSession.js";
+import { clearRecentSources, setRecentSources } from "../utils/recentSources.js";
+import { workflowMenu } from "./workflowMenu.js";
+export async function openCommand(sessionId, options) {
+    const data = await (await IvorleafApi.fromConfig()).getSession(sessionId);
+    const responseSessionId = findSessionId(data) || sessionId;
+    await updateActiveSessionMetadata({
+        sessionId: responseSessionId,
+        revisionId: findRevisionId(data),
+        command: "open",
+    });
+    const sources = extractSources(data);
+    if (sources.length)
+        await setRecentSources(sources);
+    else
+        await clearRecentSources();
+    const plan = findPlan(data);
+    if (!options.json)
+        await renderHeader("open", { plan, sessionId: responseSessionId });
+    await renderResponse(data, options, { kind: "lesson", sessionId: responseSessionId, plan, command: "open" });
+    await workflowMenu(responseSessionId, options);
+}
+//# sourceMappingURL=open.js.map

package/dist/commands/orchestrate.js

@@ -0,0 +1,19 @@
+import { findRevisionId, findSessionId, IvorleafApi } from "../api.js";
+import { renderHeader, renderResponse } from "../render.js";
+import { getActiveSession, updateActiveSessionMetadata } from "../utils/activeSession.js";
+export async function orchestrateCommand(intent, sessionArg, options) {
+    const sessionId = sessionArg || await getActiveSession();
+    if (!sessionId)
+        throw new Error("No active session.\nRun:\nivorleaf open <session_id>\nor\nivorleaf explore <prompt>");
+    const data = await (await IvorleafApi.fromConfig()).orchestrate(sessionId, intent);
+    const responseSessionId = findSessionId(data) || sessionId;
+    await updateActiveSessionMetadata({
+        sessionId: responseSessionId,
+        revisionId: findRevisionId(data),
+        command: intent,
+    });
+    if (!options.json)
+        await renderHeader(intent, { sessionId: responseSessionId });
+    await renderResponse(data, options, { kind: "workflow", actionName: intent, sessionId: responseSessionId, command: intent });
+}
+//# sourceMappingURL=orchestrate.js.map

package/dist/commands/sources.js

@@ -0,0 +1,16 @@
+import { formatSources, renderHeader } from "../render.js";
+import { getRecentSources } from "../utils/recentSources.js";
+export async function sourcesCommand(options) {
+    const sources = await getRecentSources();
+    if (options.json) {
+        console.log(JSON.stringify({ sources }, null, 2));
+        return;
+    }
+    await renderHeader("sources");
+    if (!sources.length) {
+        console.log("No sources are available yet. Run an explore command first.");
+        return;
+    }
+    console.log(formatSources(sources));
+}
+//# sourceMappingURL=sources.js.map

package/dist/commands/status.js

@@ -0,0 +1,20 @@
+import { renderHeader } from "../render.js";
+import { getActiveSession, getActiveSessionMetadata } from "../utils/activeSession.js";
+export async function statusCommand() {
+    const sessionId = await getActiveSession();
+    const metadata = await getActiveSessionMetadata();
+    await renderHeader("status", { sessionId });
+    if (!sessionId) {
+        console.log("No active session.");
+        console.log("Run: ivorleaf explore <prompt>");
+        return;
+    }
+    console.log(`Active session: ${sessionId}`);
+    if (metadata?.revisionId)
+        console.log(`Latest revision: ${metadata.revisionId}`);
+    if (metadata?.command)
+        console.log(`Last command: ${metadata.command}`);
+    if (metadata?.updatedAt)
+        console.log(`Updated: ${metadata.updatedAt}`);
+}
+//# sourceMappingURL=status.js.map