@marcoscale98/piewf-cli 5.14.1-fork.1

package/dist/src/session-inspector.d.ts

@@ -0,0 +1,82 @@
+import { type SessionEntry, type SessionInfo } from "@earendil-works/pi-coding-agent";
+import { type AgentSetupSummary, type ModelSpec, type StaticWorkflowCall } from "@marcoscale98/pi-extensible-workflows";
+import { type PersistedRun, type RunSummary } from "@marcoscale98/pi-extensible-workflows/persistence";
+export interface ModelUsage {
+    model: string;
+    cost: number;
+}
+export interface AttemptReport {
+    attempt: number;
+    prompt: string;
+    model: string;
+    thinking?: ModelSpec["thinking"];
+    cost: number;
+    models: readonly ModelUsage[];
+    error?: string;
+    setup?: AgentSetupSummary;
+}
+export interface AgentReport {
+    name: string;
+    label?: string;
+    state: string;
+    role?: string;
+    requestedModel?: string;
+    model: string;
+    thinking?: ModelSpec["thinking"];
+    cost: number;
+    attempts: readonly AttemptReport[];
+    setup?: AgentSetupSummary;
+}
+export interface WorkflowReport {
+    name: string;
+    description?: string;
+    status: string;
+    runId?: string;
+    script?: string;
+    calls: readonly StaticWorkflowCall[];
+    parseError?: string;
+    cost: number;
+    models: readonly ModelUsage[];
+    agents: readonly AgentReport[];
+    budget?: PersistedRun["budget"];
+    budgetVersion?: number;
+    usage?: PersistedRun["usage"];
+    budgetEvents?: PersistedRun["budgetEvents"];
+    events?: readonly {
+        type: string;
+        message: string;
+    }[];
+}
+export interface SessionReport {
+    id: string;
+    cwd: string;
+    path: string;
+    cost: number;
+    models: readonly ModelUsage[];
+    workflows: readonly WorkflowReport[];
+    totalCost: number;
+    totalModels: readonly ModelUsage[];
+}
+export interface InspectorViewState {
+    view: "list" | "detail" | "script";
+    selected: number;
+    scroll: number;
+}
+export type InspectMode = "tui" | "json" | "summary";
+export interface PersistedSessionSummary {
+    schemaVersion: 1;
+    cwd: string;
+    sessionId: string;
+    runs: readonly RunSummary[];
+}
+export declare function transcriptLines(entries: readonly SessionEntry[]): string[];
+export declare function transcriptFileLines(path: string): string[];
+export declare function matchSession(query: string, sessions: readonly SessionInfo[]): SessionInfo;
+export declare function loadSessionReport(path: string, home?: string): Promise<SessionReport>;
+export declare function renderInspector(report: SessionReport, state: InspectorViewState, width?: number, height?: number, highlighter?: (script: string) => string[]): string[];
+export declare function loadPersistedSessionSummary(cwd: string, sessionId: string, home?: string, failedOnly?: boolean): Promise<PersistedSessionSummary>;
+export declare function loadPersistedSummaries(cwd: string, sessionId: string | undefined, home?: string, failedOnly?: boolean): Promise<readonly PersistedSessionSummary[]>;
+export declare function formatPersistedRunSummary(summary: RunSummary, sessionId?: string): string;
+export declare function showSessionInspector(report: SessionReport): Promise<void>;
+export declare function resolveSession(query: string, sessionDir?: string | undefined): Promise<SessionInfo>;
+export declare function runSessionInspector(sessionId?: string, mode?: InspectMode, cwd?: string, home?: string, write?: (text: string) => void, failedOnly?: boolean): Promise<void>;

package/dist/src/session-inspector.js

@@ -0,0 +1,454 @@
+import { existsSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { emitKeypressEvents } from "node:readline";
+import { createInterface } from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+import { highlightCode, initTheme, SessionManager, truncateToVisualLines } from "@earendil-works/pi-coding-agent";
+import { errorText, formatBudgetStatus, inspectWorkflowScript, parseThinking } from "@marcoscale98/pi-extensible-workflows";
+import { listPersistedSessionIds, listRunIds, RunStore } from "@marcoscale98/pi-extensible-workflows/persistence";
+function text(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    const parts = content;
+    return parts.flatMap((part) => typeof part === "object" && part !== null && "type" in part && part.type === "text" && "text" in part && typeof part.text === "string" ? [part.text] : []).join("");
+}
+function isTranscriptPart(value) {
+    if (typeof value !== "object" || value === null || !("type" in value))
+        return false;
+    if (value.type === "text")
+        return "text" in value && typeof value.text === "string";
+    if (value.type === "thinking")
+        return "thinking" in value && typeof value.thinking === "string";
+    if (value.type === "toolCall")
+        return "name" in value && typeof value.name === "string";
+    return value.type === "image";
+}
+function isTranscriptMessage(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    return (!(("role" in value) && value.role !== undefined) || typeof value.role === "string") && (!(("toolName" in value) && value.toolName !== undefined) || typeof value.toolName === "string") && (!(("customType" in value) && value.customType !== undefined) || typeof value.customType === "string");
+}
+function transcriptPartLines(part) {
+    if (!isTranscriptPart(part))
+        return [];
+    if (part.type === "text")
+        return part.text.split("\n");
+    if (part.type === "thinking")
+        return ["Thinking:", ...part.thinking.split("\n")];
+    if (part.type === "toolCall")
+        return [`Tool call: ${part.name}`, JSON.stringify(part.arguments, null, 2)];
+    return ["[image]"];
+}
+function transcriptMessageLines(message) {
+    if (!isTranscriptMessage(message))
+        return ["(invalid message)"];
+    const role = message.role ?? "message";
+    const label = role === "toolResult" && message.toolName !== undefined ? `${role}: ${message.toolName}` : role === "custom" && message.customType !== undefined ? `${role}: ${message.customType}` : role;
+    const content = Array.isArray(message.content) ? message.content.flatMap(transcriptPartLines) : typeof message.content === "string" ? message.content.split("\n") : [];
+    return [`[${label}]`, ...(content.length ? content : ["(empty)"])];
+}
+export function transcriptLines(entries) {
+    if (!entries.length)
+        return ["(no active transcript entries)"];
+    return entries.flatMap((entry, index) => {
+        const lines = entry.type === "message" ? transcriptMessageLines(entry.message) : entry.type === "model_change" ? [`[model] ${entry.provider}/${entry.modelId}`] : entry.type === "thinking_level_change" ? [`[thinking] ${entry.thinkingLevel}`] : entry.type === "compaction" ? ["[compaction]", ...entry.summary.split("\n")] : entry.type === "branch_summary" ? ["[branch summary]", ...entry.summary.split("\n")] : entry.type === "custom_message" ? [`[custom_message: ${entry.customType}]`, ...(typeof entry.content === "string" ? entry.content.split("\n") : entry.content.flatMap(transcriptPartLines))] : entry.type === "custom" ? [`[custom: ${entry.customType}]`] : entry.type === "label" ? [`[label] ${entry.label ?? ""}`] : [`[session info] ${entry.name ?? ""}`];
+        return index ? ["", ...lines] : lines;
+    });
+}
+export function transcriptFileLines(path) {
+    if (!existsSync(path))
+        throw new Error(`Transcript file not found: ${path}`);
+    return transcriptLines(SessionManager.open(path).buildContextEntries());
+}
+function mergedModels(groups) {
+    const totals = new Map();
+    for (const group of groups)
+        for (const item of group)
+            totals.set(item.model, (totals.get(item.model) ?? 0) + item.cost);
+    return [...totals].map(([model, cost]) => ({ model, cost })).sort((a, b) => b.cost - a.cost || a.model.localeCompare(b.model));
+}
+function modelName(provider, model) {
+    return typeof provider === "string" && provider && typeof model === "string" && model ? `${provider}/${model}` : undefined;
+}
+function transcript(manager) {
+    const models = new Map();
+    let cost = 0;
+    let prompt;
+    let model;
+    let thinking;
+    for (const entry of manager.getEntries()) {
+        if (entry.type === "model_change") {
+            model = modelName(entry.provider, entry.modelId);
+            if (!model)
+                throw new Error("Invalid model policy");
+            continue;
+        }
+        if (entry.type === "thinking_level_change") {
+            thinking = parseThinking(entry.thinkingLevel);
+            if (thinking === undefined)
+                throw new Error("Invalid thinking policy");
+            continue;
+        }
+        if (entry.type !== "message")
+            continue;
+        const message = entry.message;
+        if (message.role === "user" && prompt === undefined) {
+            const full = text(message.content);
+            const marker = "\n\nTask:\n";
+            prompt = full.includes(marker) ? full.slice(full.indexOf(marker) + marker.length) : full;
+        }
+        if (message.role === "assistant") {
+            const actualModel = modelName(message.provider, message.model);
+            const messageCost = message.usage.cost.total;
+            if (!actualModel || typeof messageCost !== "number" || !Number.isFinite(messageCost))
+                throw new Error("Invalid assistant policy");
+            model = actualModel;
+            cost += messageCost;
+            models.set(actualModel, (models.get(actualModel) ?? 0) + messageCost);
+        }
+    }
+    return { ...(prompt !== undefined ? { prompt } : {}), cost, models: [...models].map(([model, modelCost]) => ({ model, cost: modelCost })), ...(model !== undefined ? { model } : {}), ...(thinking !== undefined ? { thinking } : {}) };
+}
+function readTranscript(path) {
+    try {
+        if (!existsSync(path) || !statSync(path).isFile() || statSync(path).size === 0)
+            return undefined;
+        const manager = SessionManager.open(path);
+        if (!manager.getHeader())
+            return undefined;
+        const summary = transcript(manager);
+        return summary.model === undefined ? undefined : summary;
+    }
+    catch {
+        return undefined;
+    }
+}
+function attemptTranscriptPath(attempt) {
+    const session = attempt.session;
+    if (!session || session.transport !== "local" || typeof session.locator !== "object" || session.locator === null || Array.isArray(session.locator))
+        return undefined;
+    const path = session.locator.sessionFile;
+    return typeof path === "string" && path ? path : undefined;
+}
+function resultRunId(result) {
+    if (!result)
+        return undefined;
+    if (typeof result.details === "object" && result.details !== null && "runId" in result.details && typeof result.details.runId === "string")
+        return result.details.runId;
+    const raw = text(result.content);
+    try {
+        const parsed = JSON.parse(raw);
+        return typeof parsed === "object" && parsed !== null && "runId" in parsed && typeof parsed.runId === "string" ? parsed.runId : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function workflowEntries(manager) {
+    const calls = [];
+    const results = new Map();
+    for (const entry of manager.getEntries()) {
+        if (entry.type !== "message")
+            continue;
+        const message = entry.message;
+        if (message.role === "assistant")
+            for (const part of message.content) {
+                if (part.type === "toolCall" && part.name === "workflow")
+                    calls.push({ id: part.id, arguments: part.arguments });
+            }
+        if (message.role === "toolResult" && message.toolName === "workflow")
+            results.set(message.toolCallId, { toolCallId: message.toolCallId, isError: message.isError, content: message.content, details: message.details });
+    }
+    return { calls, results };
+}
+async function loadRuns(cwd, sessionId, home) {
+    const runs = new Map();
+    for (const runId of await listRunIds(cwd, sessionId, home)) {
+        try {
+            runs.set(runId, await new RunStore(cwd, sessionId, runId, home).load());
+        }
+        catch { /* Ignore corrupt or concurrently removed runs. */ }
+    }
+    return runs;
+}
+function agentReport(agent) {
+    const fallbackModel = `${agent.model.provider}/${agent.model.model}`;
+    const fallbackThinking = agent.model.thinking;
+    const attempts = [];
+    for (const attempt of agent.attemptDetails ?? []) {
+        const setup = attempt.setup;
+        const path = attemptTranscriptPath(attempt);
+        const log = path ? readTranscript(path) : undefined;
+        const model = log?.model ?? `${setup.model.provider}/${setup.model.model}`;
+        const thinking = log ? log.thinking : setup.model.thinking;
+        const cost = log?.cost ?? attempt.accounting.cost;
+        attempts.push({ attempt: attempt.attempt, prompt: log?.prompt ?? "(transcript unavailable)", model, ...(thinking !== undefined ? { thinking } : {}), cost, models: log?.models.length ? log.models : [{ model, cost }], ...(attempt.error ? { error: `${attempt.error.code}: ${attempt.error.message}` } : {}), setup });
+    }
+    if (!attempts.length) {
+        const cost = agent.accounting?.cost ?? 0;
+        attempts.push({ attempt: 1, prompt: "(transcript unavailable)", model: fallbackModel, ...(fallbackThinking !== undefined ? { thinking: fallbackThinking } : {}), cost, models: [{ model: fallbackModel, cost }] });
+    }
+    const latest = attempts[attempts.length - 1];
+    return { name: agent.name, ...(agent.label ? { label: agent.label } : {}), state: agent.state, ...(agent.role ? { role: agent.role } : {}), ...(agent.requestedModel ? { requestedModel: agent.requestedModel } : {}), model: latest?.model ?? fallbackModel, ...(latest?.thinking !== undefined ? { thinking: latest.thinking } : {}), cost: attempts.reduce((sum, attempt) => sum + attempt.cost, 0), attempts, ...(latest?.setup ? { setup: latest.setup } : {}) };
+}
+export function matchSession(query, sessions) {
+    const exact = sessions.filter(({ id }) => id === query);
+    if (exact[0])
+        return exact[0];
+    const partial = sessions.filter(({ id }) => id.startsWith(query));
+    if (partial.length === 1 && partial[0])
+        return partial[0];
+    if (!partial.length)
+        throw new Error(`Session not found: ${query}`);
+    throw new Error(`Session ID is ambiguous: ${query}`);
+}
+export async function loadSessionReport(path, home = homedir()) {
+    const manager = SessionManager.open(path);
+    const header = manager.getHeader();
+    if (!header)
+        throw new Error(`Invalid session file: ${path}`);
+    const parent = transcript(manager);
+    const { calls, results } = workflowEntries(manager);
+    const runs = await loadRuns(header.cwd, header.id, home);
+    const workflows = [];
+    for (const call of calls) {
+        const result = results.get(call.id);
+        const runId = resultRunId(result);
+        const loaded = runId ? runs.get(runId) : undefined;
+        const args = call.arguments;
+        const agents = loaded ? loaded.run.agents.map(agentReport) : [];
+        const models = mergedModels(agents.flatMap(({ attempts }) => attempts.map(({ models: attemptModels }) => attemptModels)));
+        const name = loaded?.run.workflowName ?? (typeof args.name === "string" ? args.name : "workflow");
+        const description = typeof args.description === "string" ? args.description : loaded?.snapshot.metadata.description;
+        const script = typeof args.script === "string" && args.script.trim() ? args.script : loaded?.snapshot.script;
+        let staticCalls = [];
+        let parseError;
+        if (script) {
+            try {
+                staticCalls = inspectWorkflowScript(script);
+            }
+            catch (error) {
+                parseError = errorText(error);
+            }
+        }
+        workflows.push({
+            name,
+            ...(description ? { description } : {}),
+            status: loaded?.run.state ?? (result ? result.isError ? "failed" : "completed" : "pending"),
+            ...(runId ? { runId } : {}),
+            ...(script ? { script } : {}),
+            calls: staticCalls,
+            ...(parseError ? { parseError } : {}),
+            cost: agents.reduce((sum, agent) => sum + agent.cost, 0),
+            models,
+            agents,
+            ...(loaded?.run.budget ? { budget: loaded.run.budget } : {}),
+            ...(loaded?.run.budgetVersion !== undefined ? { budgetVersion: loaded.run.budgetVersion } : {}),
+            ...(loaded?.run.usage ? { usage: loaded.run.usage } : {}),
+            ...(loaded?.run.budgetEvents ? { budgetEvents: loaded.run.budgetEvents } : {}),
+            ...(loaded?.run.events?.length ? { events: loaded.run.events } : {})
+        });
+    }
+    const workflowCost = workflows.reduce((sum, workflow) => sum + workflow.cost, 0);
+    return {
+        id: header.id, cwd: header.cwd, path, cost: parent.cost, models: parent.models, workflows,
+        totalCost: parent.cost + workflowCost,
+        totalModels: mergedModels([parent.models, ...workflows.map(({ models }) => models)]),
+    };
+}
+const ansi = { reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m", cyan: "\x1b[36m", green: "\x1b[32m", red: "\x1b[31m", yellow: "\x1b[33m", inverse: "\x1b[7m" };
+const style = (code, value) => `${code}${value}${ansi.reset}`;
+const money = (cost) => `$${cost < 0.01 && cost > 0 ? cost.toFixed(4) : cost.toFixed(2)}`;
+const modelSummary = (models) => models.length ? models.map(({ model, cost }) => `${model} ${money(cost)}`).join(" · ") : "(none)";
+function wrapped(lines, width) {
+    return lines.flatMap((line) => line ? truncateToVisualLines(line, Number.MAX_SAFE_INTEGER, Math.max(1, width), 0).visualLines : [""]);
+}
+function detailLines(workflow) {
+    const lines = [
+        style(ansi.bold + ansi.cyan, workflow.name),
+        `${workflow.status} · ${money(workflow.cost)}${workflow.runId ? ` · ${workflow.runId}` : ""}`,
+        workflow.description ?? "",
+        ...(workflow.events?.length ? ["", style(ansi.bold, "Run events"), ...workflow.events.map((event) => `${event.type}: ${event.message}`)] : []),
+        "",
+        ...(workflow.budget ? formatBudgetStatus({ budget: workflow.budget, ...(workflow.budgetVersion !== undefined ? { budgetVersion: workflow.budgetVersion } : {}), ...(workflow.usage ? { usage: workflow.usage } : {}), ...(workflow.budgetEvents ? { budgetEvents: workflow.budgetEvents } : {}) }).map((line) => `Budget ${line}`) : []),
+        style(ansi.bold, "Models"),
+        modelSummary(workflow.models),
+        "",
+        style(ansi.bold, "Static workflow calls"),
+        ...(workflow.parseError ? [style(ansi.red, `Parse error: ${workflow.parseError}`)] : workflow.calls.length ? workflow.calls.map((call, index) => {
+            const fields = [call.name ? `name=${JSON.stringify(call.name)}` : "", call.prompt ? `prompt=${JSON.stringify(call.prompt)}` : call.kind === "agent" || call.kind === "checkpoint" ? "prompt=<dynamic>" : "", call.label ? `label=${call.label}` : "", call.role ? `role=${call.role}` : "", call.model ? `model=${call.model}` : ""].filter(Boolean);
+            return `${String(index + 1)}. ${call.kind}${fields.length ? ` · ${fields.join(" · ")}` : ""}`;
+        }) : ["(none)"]),
+        "",
+        style(ansi.bold, "Agents and runtime prompts"),
+    ];
+    if (!workflow.agents.length)
+        lines.push("(no agent run was persisted)");
+    for (const agent of workflow.agents) {
+        lines.push("", style(agent.state === "completed" ? ansi.green : agent.state === "failed" ? ansi.red : ansi.yellow, `${agent.label ?? agent.name} [${agent.state}]`), `${agent.role ? `role=${agent.role} · ` : ""}${agent.requestedModel ? `requested=${agent.requestedModel} · ` : ""}${agent.model}${agent.thinking !== undefined ? `:${agent.thinking}` : ""} · ${money(agent.cost)}`);
+        for (const attempt of agent.attempts) {
+            lines.push(`Attempt ${String(attempt.attempt)} · ${attempt.model}${attempt.thinking !== undefined ? `:${attempt.thinking}` : ""} · ${money(attempt.cost)}${attempt.error ? ` · ${attempt.error}` : ""}`, `Prompt: ${attempt.prompt}`, ...(attempt.setup ? [
+                `Hooks: ${attempt.setup.hookNames.join(", ") || "(none)"}`,
+                `Effective: model=${attempt.setup.model.provider}/${attempt.setup.model.model}${attempt.setup.model.thinking ? `:${attempt.setup.model.thinking}` : ""} tools=${attempt.setup.tools.join(",") || "(none)"} cwd=${attempt.setup.cwd}`,
+                ...(attempt.setup.resourceSelectors ? [
+                    `Selector sources: global/project/role/call are persisted with the attempt`,
+                    `Configured skill patterns: ${attempt.setup.resourceSelectors.selectors.skills.join(", ") || "(none)"}`,
+                    `Effective skills: ${attempt.setup.resourceSelectors.skills.join(", ") || "(none)"}`,
+                    `Configured extension patterns: ${attempt.setup.resourceSelectors.selectors.extensions.join(", ") || "(none)"}`,
+                    `Effective extensions: ${attempt.setup.resourceSelectors.extensions.join(", ") || "(none)"}`,
+                    `Configured tool patterns: ${(attempt.setup.resourceSelectors.selectors.tools ?? []).join(", ") || "(none)"}`,
+                    `Effective tools: ${attempt.setup.resourceSelectors.tools.join(", ") || "(none)"}`,
+                    `Unmatched skills: ${attempt.setup.resourceSelectors.unmatchedSkills.join(", ") || "(none)"}`,
+                    `Unmatched extensions: ${attempt.setup.resourceSelectors.unmatchedExtensions.join(", ") || "(none)"}`,
+                    `Unmatched tools: ${attempt.setup.resourceSelectors.unmatchedTools.join(", ") || "(none)"}`,
+                ] : []),
+            ] : []));
+        }
+    }
+    return lines.filter((line, index) => line || index !== 2);
+}
+let themeReady = false;
+function highlighted(script) {
+    if (!themeReady) {
+        initTheme(undefined, false);
+        themeReady = true;
+    }
+    return highlightCode(script, "javascript");
+}
+export function renderInspector(report, state, width = 80, height = 24, highlighter = highlighted) {
+    const usableWidth = Math.max(1, width);
+    const selected = report.workflows[state.selected];
+    if (state.view === "list") {
+        const header = wrapped([
+            style(ansi.bold + ansi.cyan, "Pi workflow session inspector"),
+            `${report.id} · ${report.cwd}`,
+            `Total ${money(report.totalCost)} · parent ${money(report.cost)}`,
+            modelSummary(report.totalModels),
+            "",
+            style(ansi.bold, `Workflows (${String(report.workflows.length)})`),
+        ], usableWidth);
+        const rows = report.workflows.length ? report.workflows.map((workflow, index) => `${index === state.selected ? style(ansi.inverse, ">") : " "} ${workflow.name} · ${workflow.status} · ${money(workflow.cost)} · ${String(workflow.agents.length)} agents`) : ["No workflow calls found."];
+        const footer = wrapped(["", style(ansi.dim, "↑↓ select · enter details · q quit")], usableWidth);
+        const room = Math.max(1, height - header.length - footer.length);
+        const start = Math.max(0, Math.min(state.selected - Math.floor(room / 2), rows.length - room));
+        return [...header, ...rows.slice(start, start + room).map((line) => wrapped([line], usableWidth)[0] ?? ""), ...footer].slice(0, height);
+    }
+    if (!selected)
+        return wrapped(["No workflow selected.", style(ansi.dim, "esc back · q quit")], usableWidth).slice(0, height);
+    const title = state.view === "script" ? `${selected.name} · script` : `${selected.name} · details`;
+    const body = state.view === "script" ? selected.script ? highlighter(selected.script) : ["Script unavailable."] : detailLines(selected);
+    const fitted = wrapped(body, usableWidth);
+    const header = wrapped([style(ansi.bold + ansi.cyan, title)], usableWidth);
+    const hint = state.view === "script" ? "↑↓/pgup/pgdn scroll · esc details · q quit" : "↑↓/pgup/pgdn scroll · s script · esc workflows · q quit";
+    const footer = wrapped([style(ansi.dim, hint)], usableWidth);
+    const room = Math.max(1, height - header.length - footer.length);
+    const scroll = Math.max(0, Math.min(state.scroll, Math.max(0, fitted.length - room)));
+    return [...header, ...fitted.slice(scroll, scroll + room), ...footer].slice(0, height);
+}
+export async function loadPersistedSessionSummary(cwd, sessionId, home = homedir(), failedOnly = false) {
+    const runs = [];
+    for (const runId of (await listRunIds(cwd, sessionId, home)).sort()) {
+        try {
+            const summary = await new RunStore(cwd, sessionId, runId, home).loadSummary();
+            if (!failedOnly || summary.state === "failed")
+                runs.push(summary);
+        }
+        catch { /* Ignore corrupt or concurrently removed runs. */ }
+    }
+    return { schemaVersion: 1, cwd, sessionId, runs };
+}
+export async function loadPersistedSummaries(cwd, sessionId, home = homedir(), failedOnly = false) {
+    const sessionIds = sessionId ? [sessionId] : (await listPersistedSessionIds(cwd, home)).sort();
+    const sessions = await Promise.all(sessionIds.map((id) => loadPersistedSessionSummary(cwd, id, home, failedOnly)));
+    return sessionId || !failedOnly ? sessions : sessions.filter((session) => session.runs.length > 0);
+}
+export function formatPersistedRunSummary(summary, sessionId = summary.sessionId) {
+    const counts = summary.agents.reduce((result, agent) => { result[agent.state] = (result[agent.state] ?? 0) + 1; return result; }, {});
+    const status = Object.entries(counts).map(([state, count]) => `${state}=${String(count)}`).join(", ") || "agents=0";
+    return `${sessionId} ${summary.runId} ${summary.workflowName} ${summary.state} ${status} updated=${summary.updatedAt}`;
+}
+function nextState(current, key, workflowCount) {
+    if (current.view === "list") {
+        if (key === "up")
+            return { ...current, selected: Math.max(0, current.selected - 1) };
+        if (key === "down")
+            return { ...current, selected: Math.min(Math.max(0, workflowCount - 1), current.selected + 1) };
+        if (key === "return" && workflowCount)
+            return { ...current, view: "detail", scroll: 0 };
+        return current;
+    }
+    if (key === "escape" || key === "left")
+        return { ...current, view: current.view === "script" ? "detail" : "list", scroll: 0 };
+    if ((key === "s" || key === "tab") && current.view === "detail")
+        return { ...current, view: "script", scroll: 0 };
+    const delta = key === "up" ? -1 : key === "down" ? 1 : key === "pageup" ? -10 : key === "pagedown" ? 10 : 0;
+    return delta ? { ...current, scroll: Math.max(0, current.scroll + delta) } : current;
+}
+export async function showSessionInspector(report) {
+    if (!stdin.isTTY || !stdout.isTTY)
+        throw new Error("The session inspector requires an interactive terminal.");
+    let state = { view: "list", selected: 0, scroll: 0 };
+    const render = () => { stdout.write(`\x1b[H\x1b[2J${renderInspector(report, state, stdout.columns || 80, stdout.rows || 24).join("\n")}`); };
+    await new Promise((resolve) => {
+        const wasRaw = stdin.isRaw;
+        const done = () => {
+            stdin.off("keypress", onKey);
+            stdout.off("resize", render);
+            stdin.setRawMode(wasRaw);
+            if (!wasRaw)
+                stdin.pause();
+            stdout.write("\x1b[?25h\x1b[?1049l");
+            resolve();
+        };
+        const onKey = (value, key) => {
+            if ((key.ctrl && key.name === "c") || value === "q") {
+                done();
+                return;
+            }
+            state = nextState(state, value === "s" ? "s" : key.name ?? value, report.workflows.length);
+            render();
+        };
+        emitKeypressEvents(stdin);
+        stdin.setRawMode(true);
+        stdin.resume();
+        stdin.on("keypress", onKey);
+        stdout.on("resize", render);
+        stdout.write("\x1b[?1049h\x1b[?25l");
+        render();
+    });
+}
+async function askSessionId() {
+    if (!stdin.isTTY || !stdout.isTTY)
+        throw new Error("Pass a session ID when stdin is not interactive.");
+    const prompt = createInterface({ input: stdin, output: stdout });
+    try {
+        return (await prompt.question("Session ID: ")).trim();
+    }
+    finally {
+        prompt.close();
+    }
+}
+export async function resolveSession(query, sessionDir = process.env.PI_CODING_AGENT_SESSION_DIR) {
+    return matchSession(query, await SessionManager.listAll(sessionDir));
+}
+export async function runSessionInspector(sessionId, mode = "tui", cwd = process.cwd(), home = homedir(), write = (text) => { stdout.write(text); }, failedOnly = false) {
+    if (mode !== "tui") {
+        const sessions = await loadPersistedSummaries(cwd, sessionId?.trim() || undefined, home, failedOnly);
+        if (mode === "json") {
+            const value = sessionId?.trim() ? sessions[0] : undefined;
+            write(`${JSON.stringify(value ?? { schemaVersion: 1, cwd, sessions })}\n`);
+            return;
+        }
+        const emptyLabel = failedOnly ? "no failed runs" : "no persisted runs";
+        const lines = sessions.flatMap((session) => session.runs.length ? session.runs.map((run) => formatPersistedRunSummary(run, session.sessionId)) : [`${session.sessionId} (${emptyLabel})`]);
+        write(`${lines.length ? lines.join("\n") : failedOnly ? "No failed workflow runs." : "No persisted workflow runs."}\n`);
+        return;
+    }
+    const query = sessionId?.trim() || await askSessionId();
+    if (!query)
+        throw new Error("Session ID is required.");
+    const session = await resolveSession(query);
+    await showSessionInspector(await loadSessionReport(session.path));
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@marcoscale98/piewf-cli",
+  "version": "5.14.1-fork.1",
+  "description": "CLI for pi-extensible-workflows",
+  "homepage": "https://vekexasia.github.io/pi-extensible-workflows/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/marcoscale98/pi-extensible-workflows.git",
+    "directory": "packages/cli"
+  },
+  "type": "module",
+  "exports": {
+    ".": "./dist/src/cli.js"
+  },
+  "bin": {
+    "piewf": "./dist/src/cli.js"
+  },
+  "files": [
+    "dist/src"
+  ],
+  "scripts": {
+    "build": "npm --prefix ../.. run build --workspace=../core && rm -rf dist && tsc -p tsconfig.json && chmod +x dist/src/cli.js",
+    "inspect": "node dist/src/cli.js inspect",
+    "test": "npm run build && TEST_FILES='dist/test/*.test.js' npm run test:run",
+    "test:run": "files=${TEST_FILES:-dist/test/*.test.js}; printf '%s\\n' $files | xargs -n1 -P20 sh -c 'tmp=$(mktemp -d); TMPDIR=\"$tmp\" node --test --test-concurrency=1 --test-timeout=60000 --test-force-exit --test-reporter=dot \"$1\"; status=$?; rm -rf \"$tmp\"; exit $status' sh",
+    "lint": "eslint .",
+    "prepack": "npm run build"
+  },
+  "devDependencies": {
+    "@eslint/js": "10.0.1",
+    "@types/node": "24.12.4",
+    "esbuild": "^0.28.2",
+    "eslint": "10.0.3",
+    "typescript": "5.9.3",
+    "typescript-eslint": "8.63.0"
+  },
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@earendil-works/pi-ai": "0.85.0",
+    "@earendil-works/pi-coding-agent": "0.85.0",
+    "@earendil-works/pi-server": "0.85.0",
+    "@earendil-works/pi-tui": "0.85.0",
+    "@marcoscale98/pi-extensible-workflows": "5.14.1-fork.1",
+    "typebox": "1.3.7"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}