dsh-plugin-sessiongraph-tool 0.0.0-stage → 0.1.1

package/lib/refresh.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Lazy incremental refresh: a query should not answer from an index that is hours old when the
+ * machine has been writing session logs all along.
+ *
+ * The indexer refreshes in the background when a *new session* is created, which leaves one gap: the
+ * session currently being written has no successor yet, so the model asking "what did we just say"
+ * would search an index that predates the current conversation. This module closes that gap on the
+ * query path — but only when the sidecar says the index is older than `freshnessThresholdMs`, and
+ * never at the price of the query itself: a refresh that fails or is handed to a background job is
+ * logged/skipped and the answer is served from the index as it stands.
+ *
+ * Two rules shape the implementation:
+ *
+ * - The decision reads `<indexRoot>/status.json`, the same synchronous sidecar prompt assembly reads.
+ *   Opening SQLite to ask "how old are you" would put a database on every query's critical path.
+ * - One incremental run per index root at a time. A model that fires two queries in parallel joins
+ *   the in-flight run instead of starting a second one; a burst must not turn into a rebuild storm.
+ * @module dsh-plugin-sessiongraph-tool/refresh
+ */
+import type { SessiongraphIndexOptions } from 'dsh-plugin-sessiongraph-service';
+/**
+ * The options a lazy refresh sends, and the one it deliberately does not.
+ *
+ * A job-capable indexer reads the owning session id from a runtime extension of the seam's options
+ * (`owner`); it hands the run to the host's background-job registry only when that extension is
+ * present. Omitting it is therefore how this call asks for a synchronous report — the whole point,
+ * because the query must answer with the refreshed index, not with a promise about one. A run that
+ * some indexer still delegates is detected by its `jobId` (see {@link isCompletedReport}) and skipped:
+ * the query answers from the previous index, and the job makes the next call fresh.
+ */
+export type SynchronousIndexOptions = SessiongraphIndexOptions;
+/** What one `ensureFresh` call decided and did, for the renderer's staleness note. */
+export interface RefreshOutcome {
+    /** True when this call actually ran an incremental index (and got a report back). */
+    readonly refreshed: boolean;
+    /** True when the answer is served from an index that may predate the conversation. */
+    readonly stale: boolean;
+}
+/** Dependencies a {@link LazyIndexRefresher} needs; all injected so the decision stays testable. */
+export interface LazyRefreshDeps {
+    /** Absolute directory holding the index and its sidecar. */
+    readonly indexRoot: string;
+    /**
+     * Age at which the index counts as stale, milliseconds. `0` disables lazy refresh entirely — the
+     * query then trusts the indexer's own schedule and never spends a query budget on indexing.
+     */
+    readonly freshnessThresholdMs: number;
+    /**
+     * Run one incremental index. Resolves with the seam's report, or with whatever a job-capable
+     * indexer returned instead; rejecting is expected and handled.
+     * @param options - an incremental scope with no owning-session extension, so the run stays
+     *   synchronous.
+     * @param signal - aborts the run.
+     */
+    readonly index: (options: SynchronousIndexOptions, signal?: AbortSignal) => Promise<unknown>;
+    /** Clock, injected so a test can place the sidecar on either side of the threshold. */
+    readonly now?: () => number;
+    /** Sink for the single explanatory line a failed refresh logs (default `console.error`). */
+    readonly logError?: (message: string) => void;
+}
+/**
+ * Refresh one index root lazily, at most once at a time.
+ *
+ * The instance is process-local state (one per plugin registration), which is exactly the scope the
+ * requirement names: a second query in the same process joins the run already in flight, while a
+ * second DSH process is a separate writer the indexer's own atomic rename already handles.
+ */
+export declare class LazyIndexRefresher {
+    private readonly deps;
+    private inFlight;
+    private lastOutcome;
+    /**
+     * @param deps - the root, threshold, index runner, and optional clock/logger.
+     */
+    constructor(deps: LazyRefreshDeps);
+    /**
+     * Make sure the index is fresh enough for one query, running an incremental index when needed.
+     *
+     * Never rejects: a refresh is an optimisation, and a failed one must leave the query free to
+     * answer from the existing index. The returned outcome says whether this call refreshed and
+     * whether the answer may be stale, which the renderer turns into one line of text.
+     * @param signal - the query's cancellation signal, forwarded to the index run.
+     * @returns what this call did.
+     */
+    ensureFresh(signal?: AbortSignal): Promise<RefreshOutcome>;
+    /**
+     * Whether the sidecar places the index past the threshold.
+     *
+     * A missing sidecar beside an existing index means a run that predates the summary (or one whose
+     * summary was lost), and the only way to learn its age is to refresh it — an incremental run is
+     * cheap and self-heals the sidecar. A missing index file is different: building from nothing can
+     * take minutes, which the dedicated `sessiongraph_index` tool owns on its own budget, so a query
+     * leaves it alone and fails with the "no index" guidance instead.
+     * @returns true when an incremental run should happen before the query.
+     */
+    private shouldRefresh;
+    /**
+     * Run one incremental index, swallowing every failure into the outcome.
+     * @param signal - the query's cancellation signal.
+     */
+    private refreshOnce;
+}
+//# sourceMappingURL=refresh.d.ts.map

package/lib/refresh.js

@@ -0,0 +1,171 @@
+/**
+ * Lazy incremental refresh: a query should not answer from an index that is hours old when the
+ * machine has been writing session logs all along.
+ *
+ * The indexer refreshes in the background when a *new session* is created, which leaves one gap: the
+ * session currently being written has no successor yet, so the model asking "what did we just say"
+ * would search an index that predates the current conversation. This module closes that gap on the
+ * query path — but only when the sidecar says the index is older than `freshnessThresholdMs`, and
+ * never at the price of the query itself: a refresh that fails or is handed to a background job is
+ * logged/skipped and the answer is served from the index as it stands.
+ *
+ * Two rules shape the implementation:
+ *
+ * - The decision reads `<indexRoot>/status.json`, the same synchronous sidecar prompt assembly reads.
+ *   Opening SQLite to ask "how old are you" would put a database on every query's critical path.
+ * - One incremental run per index root at a time. A model that fires two queries in parallel joins
+ *   the in-flight run instead of starting a second one; a burst must not turn into a rebuild storm.
+ * @module dsh-plugin-sessiongraph-tool/refresh
+ */
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { INDEX_RELATIVE_PATH } from 'dsh-plugin-sessiongraph-service';
+import { readIndexStatus } from "./status-hint.js";
+/** The outcome of a call that decided to leave the index alone. */
+const IDLE = { refreshed: false, stale: false };
+/**
+ * Refresh one index root lazily, at most once at a time.
+ *
+ * The instance is process-local state (one per plugin registration), which is exactly the scope the
+ * requirement names: a second query in the same process joins the run already in flight, while a
+ * second DSH process is a separate writer the indexer's own atomic rename already handles.
+ */
+export class LazyIndexRefresher {
+    deps;
+    inFlight;
+    lastOutcome = IDLE;
+    /**
+     * @param deps - the root, threshold, index runner, and optional clock/logger.
+     */
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /**
+     * Make sure the index is fresh enough for one query, running an incremental index when needed.
+     *
+     * Never rejects: a refresh is an optimisation, and a failed one must leave the query free to
+     * answer from the existing index. The returned outcome says whether this call refreshed and
+     * whether the answer may be stale, which the renderer turns into one line of text.
+     * @param signal - the query's cancellation signal, forwarded to the index run.
+     * @returns what this call did.
+     */
+    async ensureFresh(signal) {
+        if (this.deps.freshnessThresholdMs <= 0) {
+            this.lastOutcome = IDLE;
+            return IDLE;
+        }
+        // A parallel call joins the run already in flight instead of starting a second one. It waits,
+        // because the index it would otherwise read is the one being replaced right now.
+        if (this.inFlight !== undefined) {
+            await this.inFlight;
+            return this.lastOutcome;
+        }
+        if (!this.shouldRefresh()) {
+            this.lastOutcome = IDLE;
+            return IDLE;
+        }
+        const run = this.refreshOnce(signal);
+        this.inFlight = run;
+        try {
+            await run;
+        }
+        finally {
+            this.inFlight = undefined;
+        }
+        return this.lastOutcome;
+    }
+    /**
+     * Whether the sidecar places the index past the threshold.
+     *
+     * A missing sidecar beside an existing index means a run that predates the summary (or one whose
+     * summary was lost), and the only way to learn its age is to refresh it — an incremental run is
+     * cheap and self-heals the sidecar. A missing index file is different: building from nothing can
+     * take minutes, which the dedicated `sessiongraph_index` tool owns on its own budget, so a query
+     * leaves it alone and fails with the "no index" guidance instead.
+     * @returns true when an incremental run should happen before the query.
+     */
+    shouldRefresh() {
+        const { indexRoot, freshnessThresholdMs } = this.deps;
+        // Without an index file there is nothing to refresh in place. Building one from nothing can take
+        // minutes, and that decision belongs to `sessiongraph_index` on its own budget — a query leaves
+        // it alone and fails with the "no index" guidance instead.
+        if (!existsSync(join(indexRoot, INDEX_RELATIVE_PATH)))
+            return false;
+        const status = readIndexStatus(indexRoot);
+        // An index with no sidecar is a run that predates the summary (or lost it). Its age cannot be
+        // read, and the incremental run that answers the question is cheap and writes the sidecar back.
+        if (status === undefined)
+            return true;
+        const now = this.deps.now?.() ?? Date.now();
+        return now - status.indexedAt >= freshnessThresholdMs;
+    }
+    /**
+     * Run one incremental index, swallowing every failure into the outcome.
+     * @param signal - the query's cancellation signal.
+     */
+    async refreshOnce(signal) {
+        const { indexRoot } = this.deps;
+        try {
+            // No `owner` extension on purpose: a job-capable indexer only delegates a run whose caller
+            // named an owner, so this is the explicit request for a synchronous report.
+            const result = await this.deps.index({ force: false }, signal);
+            if (!isCompletedReport(result)) {
+                // The indexer still handed the run to a background job: waiting would outlive this query,
+                // and starting another would only duplicate it. Answer from the index as it stands; the job
+                // will make the next call fresh.
+                this.lastOutcome = { refreshed: false, stale: true };
+                return;
+            }
+            this.lastOutcome = { refreshed: true, stale: false };
+        }
+        catch (error) {
+            this.lastOutcome = { refreshed: false, stale: true };
+            // A cancelled query is not a failed refresh: the caller is gone, so a log line would only
+            // report an abort as a defect.
+            if (signal?.aborted === true)
+                return;
+            // One line, once per failed attempt: the model still gets its answer, and a human reading the
+            // log learns why the result may be behind. The default sink is `console.error`; a test (or a
+            // host that routes tool diagnostics elsewhere) can replace it.
+            const log = this.deps.logError ?? logToConsole;
+            log(`sessiongraph: incremental refresh of ${indexRoot} failed; answering from the existing index: ${describe(error)}`);
+        }
+    }
+}
+/**
+ * Whether a seam answer is a finished index report rather than a report about a delegated run.
+ *
+ * A job-capable indexer answers a delegated run with a full report shape plus a `jobId` (the seam's
+ * return type cannot express the distinction), so the discriminator is the presence of that id — not
+ * the report's other fields, which describe the index as it stood when the job started. Detected
+ * structurally on purpose: this package depends on the seam, never on a particular indexer.
+ * @param value - whatever `ctx.sessiongraph.index` resolved with.
+ * @returns true when this call itself finished the work.
+ */
+function isCompletedReport(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const record = value;
+    if (typeof record['jobId'] === 'string')
+        return false;
+    return typeof record['indexPath'] === 'string'
+        && typeof record['added'] === 'number'
+        && typeof record['sessions'] === 'number';
+}
+/**
+ * One line describing a thrown value, without a stack.
+ * @param error - whatever the indexer threw.
+ * @returns the message when there is one, else the string form.
+ */
+function describe(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/**
+ * The default sink for a failed refresh: one line on stderr, never a stack. A refresh failure is a
+ * degraded state, not a query failure, so it must not look like a crash.
+ * @param message - the already-composed diagnostic line.
+ */
+function logToConsole(message) {
+    console.error(message);
+}
+//# sourceMappingURL=refresh.js.map

package/lib/render.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Model-facing text for each operation's canonical value.
+ *
+ * Every line is meant to be acted on directly: a hit names the full session id, so the next call can
+ * be `session` without a search round-trip, and every timestamp is rendered in the machine's local
+ * zone (`2026-11-03 10:37`) rather than as a bare epoch, which the model would have to convert before
+ * it could reason about "last week". A truncated answer always says so — a capped list that reads as
+ * complete is worse than a short one, because the model concludes it has seen everything.
+ * @module dsh-plugin-sessiongraph-tool/render
+ */
+import type { SessiongraphToolValue } from './schema.ts';
+/**
+ * The arguments rendering may look at: the few model-supplied facts the canonical value does not echo
+ * back (the query text, the workspace filter).
+ *
+ * Deliberately structural rather than `SessiongraphToolArgs`: the index tool shares this renderer and
+ * its arguments carry no `operation` at all. Both tools' argument objects satisfy this shape.
+ */
+export interface RenderArgs {
+    /** The search text, when the call was a search. */
+    readonly query?: string;
+    /** The workspace filter, when the model named one. */
+    readonly workspace?: string;
+}
+/** Caps applied while rendering; the tool owns them so a deployment can retune answer size. */
+export interface RenderOptions {
+    /** Longest snippet (or session entry) shown per item before it is clipped with `…`. */
+    maxSnippetChars: number;
+}
+/**
+ * Render one epoch-millisecond timestamp in the machine's local zone, minute precision.
+ * @param epochMs - epoch milliseconds.
+ * @returns `YYYY-MM-DD HH:mm` in local time.
+ */
+export declare function formatTime(epochMs: number): string;
+/**
+ * Render a byte count in binary units, at most one decimal.
+ * @param bytes - the byte count.
+ * @returns a short human-readable size.
+ */
+export declare function formatBytes(bytes: number): string;
+/**
+ * Render a duration in the unit a reader thinks in: seconds under a minute, minutes above it.
+ * @param ms - duration in milliseconds.
+ * @returns a short human-readable duration.
+ */
+export declare function formatDuration(ms: number): string;
+/**
+ * Report how many of the indexed sessions are still running.
+ *
+ * Always rendered, even at zero: "no live sessions" and "this store cannot tell" are different
+ * states, and a reader who wanted to know whether the conversation they are in right now is
+ * searchable must be able to tell them apart. The caller supplies `0` for a store that omits the
+ * count, which is the honest reading of a store that predates live indexing.
+ * @param live - live sessions the index holds.
+ * @returns the one status line.
+ */
+export declare function formatLiveSessions(live: number): string;
+/**
+ * One line a finished index run adds when it replayed sessions that are still running.
+ *
+ * Omitted at zero on purpose: an empty run is the normal case, and a line that almost always says
+ * "replayed 0 live sessions" trains a reader to skip the block it sits in.
+ * @param live - live sessions replayed by the run.
+ * @returns the sentence, or an empty string when there were none.
+ */
+export declare function formatLiveReplay(live: number): string;
+/**
+ * Clip one blob of text to a character cap, marking the cut.
+ * @param text - the text to bound.
+ * @param maxChars - characters allowed, ellipsis included.
+ * @returns the text, or its clipped prefix with `…`.
+ */
+export declare function clipText(text: string, maxChars: number): string;
+/** The one line an answer carries when the index could not be brought up to date before querying. */
+export declare const STALE_NOTE: string;
+/**
+ * Render one result as the text the model reads.
+ * @param args - the validated arguments, used for the few facts the value does not echo back.
+ * @param value - the canonical value the operation returned.
+ * @param options - rendering caps.
+ * @returns the rendered text.
+ */
+export declare function renderSessiongraph(args: RenderArgs, value: SessiongraphToolValue, options: RenderOptions): string;
+//# sourceMappingURL=render.d.ts.map

package/lib/render.js

@@ -0,0 +1,247 @@
+/**
+ * Model-facing text for each operation's canonical value.
+ *
+ * Every line is meant to be acted on directly: a hit names the full session id, so the next call can
+ * be `session` without a search round-trip, and every timestamp is rendered in the machine's local
+ * zone (`2026-11-03 10:37`) rather than as a bare epoch, which the model would have to convert before
+ * it could reason about "last week". A truncated answer always says so — a capped list that reads as
+ * complete is worse than a short one, because the model concludes it has seen everything.
+ * @module dsh-plugin-sessiongraph-tool/render
+ */
+import { assertNever } from 'dsh-plugin-sessiongraph-service';
+/**
+ * Render one epoch-millisecond timestamp in the machine's local zone, minute precision.
+ * @param epochMs - epoch milliseconds.
+ * @returns `YYYY-MM-DD HH:mm` in local time.
+ */
+export function formatTime(epochMs) {
+    const date = new Date(epochMs);
+    return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} `
+        + `${pad(date.getHours())}:${pad(date.getMinutes())}`;
+}
+/**
+ * Two-digit zero pad.
+ * @param value - the number to pad.
+ * @returns the padded decimal string.
+ */
+function pad(value) {
+    return String(value).padStart(2, '0');
+}
+/**
+ * Render a byte count in binary units, at most one decimal.
+ * @param bytes - the byte count.
+ * @returns a short human-readable size.
+ */
+export function formatBytes(bytes) {
+    if (!Number.isFinite(bytes) || bytes <= 0)
+        return '0 B';
+    const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+    const exponent = Math.min(units.length - 1, Math.floor(Math.log(bytes) / Math.log(1024)));
+    const unit = units[exponent] ?? 'B';
+    const value = bytes / 1024 ** exponent;
+    const rounded = exponent === 0 || value >= 10 ? Math.round(value) : Math.round(value * 10) / 10;
+    return `${rounded} ${unit}`;
+}
+/**
+ * Render a duration in the unit a reader thinks in: seconds under a minute, minutes above it.
+ * @param ms - duration in milliseconds.
+ * @returns a short human-readable duration.
+ */
+export function formatDuration(ms) {
+    if (!Number.isFinite(ms) || ms <= 0)
+        return '0 秒';
+    if (ms < 60_000)
+        return `${Math.round(ms / 100) / 10} 秒`;
+    const minutes = Math.floor(ms / 60_000);
+    const seconds = Math.round((ms % 60_000) / 1000);
+    return `${minutes} 分 ${seconds} 秒`;
+}
+/**
+ * Report how many of the indexed sessions are still running.
+ *
+ * Always rendered, even at zero: "no live sessions" and "this store cannot tell" are different
+ * states, and a reader who wanted to know whether the conversation they are in right now is
+ * searchable must be able to tell them apart. The caller supplies `0` for a store that omits the
+ * count, which is the honest reading of a store that predates live indexing.
+ * @param live - live sessions the index holds.
+ * @returns the one status line.
+ */
+export function formatLiveSessions(live) {
+    return live === 0
+        ? '实时会话：0（当前没有正在跑的会话）'
+        : `实时会话：${live} 个（当前还在跑、未落盘）`;
+}
+/**
+ * One line a finished index run adds when it replayed sessions that are still running.
+ *
+ * Omitted at zero on purpose: an empty run is the normal case, and a line that almost always says
+ * "replayed 0 live sessions" trains a reader to skip the block it sits in.
+ * @param live - live sessions replayed by the run.
+ * @returns the sentence, or an empty string when there were none.
+ */
+export function formatLiveReplay(live) {
+    return live === 0 ? '' : `本次重放 ${live} 个实时会话。`;
+}
+/**
+ * Clip one blob of text to a character cap, marking the cut.
+ * @param text - the text to bound.
+ * @param maxChars - characters allowed, ellipsis included.
+ * @returns the text, or its clipped prefix with `…`.
+ */
+export function clipText(text, maxChars) {
+    if (text.length <= maxChars)
+        return text;
+    return `${text.slice(0, Math.max(0, maxChars - 1))}…`;
+}
+/** The `N shown of M` suffix a truncatable list carries. */
+function counted(shown, total, truncated) {
+    return truncated ? `（共 ${total} 条，显示前 ${shown} 条；用 offset 翻页）` : `（共 ${total} 条）`;
+}
+/** A session title for a line, with an explicit placeholder when the log never recorded one. */
+function titled(title) {
+    return title === undefined || title.trim() === '' ? '（无标题）' : `《${title}》`;
+}
+/** One hit as the three lines a reader needs: when/who, where, and the matched text. */
+function hitLines(hit, maxChars) {
+    const turn = hit.turn === undefined ? '' : ` · 第 ${hit.turn} 轮`;
+    return [
+        `${formatTime(hit.time)} · [${hit.kind}] · ${titled(hit.title)}`,
+        `  ${hit.workspace} · session ${hit.session_id} #${hit.seq}${turn}`,
+        `  ${clipText(hit.snippet, maxChars)}`,
+    ];
+}
+/** The one line an answer carries when the index could not be brought up to date before querying. */
+export const STALE_NOTE = '（注意：本次增量刷新没有完成，答案可能不是最新——索引里可能还没有刚才的对话。'
+    + '确实需要最新结果时可以调用 sessiongraph_index 强制刷新。）';
+/** Whether a value was served from an index the query path could not refresh first. */
+function isStale(value) {
+    return 'stale' in value && value.stale === true;
+}
+/**
+ * Render one result as the text the model reads.
+ * @param args - the validated arguments, used for the few facts the value does not echo back.
+ * @param value - the canonical value the operation returned.
+ * @param options - rendering caps.
+ * @returns the rendered text.
+ */
+export function renderSessiongraph(args, value, options) {
+    const text = renderValue(args, value, options);
+    return isStale(value) ? `${text}\n${STALE_NOTE}` : text;
+}
+/**
+ * The per-operation rendering, without the cross-cutting staleness note.
+ * @param args - the validated arguments.
+ * @param value - the canonical value the operation returned.
+ * @param options - rendering caps.
+ * @returns the rendered text.
+ */
+function renderValue(args, value, options) {
+    const maxChars = options.maxSnippetChars;
+    switch (value.operation) {
+        case 'search': {
+            if (value.hits.length === 0) {
+                const where = args.workspace === undefined ? '' : `（工作区 ${args.workspace}）`;
+                return `会话历史里没有命中「${args.query ?? ''}」${where}。换个词，或省略 workspace 扩大范围。`;
+            }
+            const header = `命中 ${value.hits.length} 条${counted(value.hits.length, value.total, value.truncated)}`
+                + `${args.query === undefined ? '' : `，查询「${args.query}」`}：`;
+            const lines = [header];
+            value.hits.forEach((hit, index) => {
+                lines.push(`${index + 1}. ${hitLines(hit, maxChars).join('\n')}`);
+            });
+            return lines.join('\n');
+        }
+        case 'session': {
+            const session = value.session;
+            const lines = [
+                `会话 ${session.session_id} · ${titled(session.title)}`,
+                `${session.workspace} · ${formatTime(session.created_at)} → ${formatTime(session.last_at)}`
+                    + ` · ${session.turns} 轮 · ${session.entries} 条`,
+            ];
+            const meta = [];
+            if (session.parent_session !== undefined)
+                meta.push(`父会话 ${session.parent_session}`);
+            if (session.origin !== undefined)
+                meta.push(`来源 ${session.origin}`);
+            if (session.agent_preset !== undefined)
+                meta.push(`预设 ${session.agent_preset}`);
+            if (meta.length > 0)
+                lines.push(meta.join(' · '));
+            if (value.children.length > 0) {
+                lines.push(`子会话 ${value.children.length} 个：${value.children.join(', ')}`);
+            }
+            if (value.entries.length === 0) {
+                lines.push('索引里没有这个会话的可读条目。');
+                return lines.join('\n');
+            }
+            const clipped = value.truncated ? '（已截断；用 offset 继续翻页）' : '';
+            lines.push(`条目 ${value.entries.length} 条${clipped}：`);
+            for (const entry of value.entries) {
+                const turn = entry.turn === undefined ? '' : ` 第 ${entry.turn} 轮`;
+                const cut = entry.clipped ? ' [索引里只存了前缀]' : '';
+                lines.push(`${formatTime(entry.time)} #${entry.seq} [${entry.kind}]${turn}${cut}:`);
+                lines.push(`  ${clipText(entry.text, maxChars)}`);
+            }
+            return lines.join('\n');
+        }
+        case 'timeline': {
+            if (value.sessions.length === 0) {
+                return args.workspace === undefined ? '索引里还没有会话。' : `工作区 ${args.workspace} 还没有被索引的会话。`;
+            }
+            const header = `最近 ${value.sessions.length} 个会话${value.truncated ? '（还有更旧的；用 limit 扩大）' : ''}，最新在前：`;
+            const lines = [header];
+            for (const session of value.sessions) {
+                lines.push(`${formatTime(session.last_at)} · session ${session.session_id} · ${titled(session.title)}`
+                    + ` · ${session.workspace} · ${session.turns} 轮 / ${session.entries} 条`);
+            }
+            return lines.join('\n');
+        }
+        case 'workspaces': {
+            if (value.workspaces.length === 0)
+                return '索引里还没有工作区。';
+            const header = `工作区 ${value.workspaces.length} 个${value.total > value.workspaces.length ? `（共 ${value.total} 个）` : ''}，最近活跃在前：`;
+            const lines = [header];
+            for (const workspace of value.workspaces) {
+                lines.push(`${workspace.workspace} · ${workspace.sessions} 会话 · ${workspace.entries} 条`
+                    + ` · ${formatTime(workspace.first_at)} → ${formatTime(workspace.last_at)}`);
+            }
+            return lines.join('\n');
+        }
+        case 'status': {
+            if (!value.indexed) {
+                return `还没有索引（${value.index_path}）。请先调用 sessiongraph_index 建一次索引；建好之前除 status 外的查询都会失败。`;
+            }
+            const indexedAt = value.indexed_at === undefined ? '未知' : formatTime(value.indexed_at);
+            return `索引就绪（${value.index_path}）：${value.sessions} 个会话、${value.entries} 条可检索条目、`
+                + `${value.workspaces} 个工作区、${formatBytes(value.bytes)}。最近一次建索引 ${indexedAt}。`
+                + `\n${formatLiveSessions(value.live_sessions)}`;
+        }
+        case 'index': {
+            // A delegated run has no report yet. Saying so, and naming the job that will carry it, is the
+            // whole answer: the model must not read "started" as "indexed" and query an index that is
+            // still being replaced.
+            if ('status' in value) {
+                return `已在后台建索引，jobId=${value.job_id}。可以稍后查 sessiongraph status 看规模；`
+                    + `job_output ${value.job_id} 能取这次运行的报告。`;
+            }
+            const failed = value.failed.length === 0
+                ? '没有会话解析失败。'
+                : `解析失败 ${value.failed.length} 个：`
+                    + value.failed.map(entry => `\n  ${entry.path} — ${entry.reason}`).join('');
+            const replayed = formatLiveReplay(value.live_sessions);
+            return [
+                `建索引完成，用时 ${formatDuration(value.elapsed_ms)}：`
+                    + `新增 ${value.added}、更新 ${value.updated}、跳过 ${value.skipped}、移除 ${value.removed}`
+                    + `（共发现 ${value.discovered} 个会话）。`,
+                `${value.index_path}：${value.sessions} 个会话、${value.entries} 条可检索条目、`
+                    + `${value.workspaces} 个工作区、${formatBytes(value.bytes)}。`,
+                ...(replayed === '' ? [] : [replayed]),
+                failed,
+            ].join('\n');
+        }
+        /* v8 ignore next -- exhaustive over the output schema's closed union; unreachable. */
+        default:
+            return assertNever(value);
+    }
+}
+//# sourceMappingURL=render.js.map