@xopcai/xopc 0.0.410 → 0.0.411

package/dist/src/agent/workflow/progress-broker.d.ts

@@ -1,80 +0,0 @@
-/**
- * WorkflowProgressBroker — the single seam that turns mid-run `workflow`
- * snapshots into IM messages (Telegram today, more channels later).
- *
- * Architecture:
- *
- *    pi-agent  ──tool_execution_update──▶  AgentEventHandler / SessionEventBus
- *                                                       │
- *                          attachTo(handler)            │
- *                                                       ▼
- *                                          WorkflowProgressBroker
- *                                                       │
- *                                  per-(conversationId, toolCallId) state
- *                                                       │
- *                                   ┌───────────────────┼───────────────────┐
- *                                   ▼                   ▼                   ▼
- *                              Telegram cap         Feishu cap          WeChat cap
- *
- * Why broker + capability instead of "each channel subscribes the bus"?
- *   - DRY snapshot aggregation and key-event detection.
- *   - Per-channel throttling is enforced by the broker, so a slow / rate-limited
- *     channel can't block a fast one.
- *   - Adding a new channel = one capability + one register call. Broker code
- *     never grows.
- */
-import type { AgentEvent } from '@earendil-works/pi-agent-core';
-import type { Config } from '../../config/schema.js';
-import type { ChannelProgressCapability } from './channel-capability.js';
-import type { WorkflowSnapshot } from './types.js';
-export interface BrokerListenerHandle {
-    /** Detach broker from the session bus and clear all in-flight state. */
-    dispose(): void;
-}
-/**
- * Tiny façade onto the AgentEventHandler. We don't import the concrete class to
- * keep this module test-friendly — a stub listener pump is fine for unit tests.
- */
-export interface SessionBusLike {
-    registerListener(type: AgentEvent['type'] | 'all', listener: (event: AgentEvent, context: {
-        conversationId: string;
-    }) => void): () => void;
-}
-export declare class WorkflowProgressBroker {
-    private readonly opts;
-    private subscribers;
-    private states;
-    /** Now() factory — overridable in tests for deterministic time. */
-    private readonly now;
-    /** Cached resolved settings per (channelId), invalidated on registration. */
-    private resolved;
-    constructor(opts?: {
-        getConfig?: () => Config | undefined;
-        now?: () => number;
-    });
-    registerChannel(cap: ChannelProgressCapability): () => void;
-    attachTo(bus: SessionBusLike): BrokerListenerHandle;
-    /** Visible for tests — direct entry path bypassing the SessionBus glue. */
-    onUpdate(conversationId: string, toolCallId: string, snapshot: WorkflowSnapshot): void;
-    /** Visible for tests — direct entry path bypassing the SessionBus glue. */
-    onEnd(conversationId: string, toolCallId: string, snapshot: WorkflowSnapshot | null): void;
-    private dispatchToChannel;
-    private sendNow;
-    private cancelPending;
-    private disposeAllPending;
-    private getOrCreateState;
-    private getOrCreateChannelState;
-    /** Resolved (enabled / throttleMs / mode) for a channel, with config overrides. */
-    private resolveChannelSettings;
-    /** Drop any cached config so the next dispatch re-reads. Call after config reload. */
-    invalidateConfigCache(): void;
-    /** @internal — for tests only. */
-    _stateCount(): number;
-}
-/**
- * Process-wide broker singleton. Channels register against this one; the
- * service wires it to the session bus during startup.
- */
-export declare function getWorkflowProgressBroker(): WorkflowProgressBroker;
-/** Test-only — reset the singleton between cases. */
-export declare function _resetWorkflowProgressBrokerForTests(): void;

package/dist/src/agent/workflow/progress-broker.js

@@ -1,261 +0,0 @@
-import { createLogger } from "../../utils/logger/index.js";
-import { init_logger } from "../../utils/logger.js";
-import { renderWorkflowText } from "./snapshot.js";
-//#region src/agent/workflow/progress-broker.ts
-init_logger();
-const log = createLogger("Agent:WorkflowProgress");
-const WORKFLOW_TOOL_NAME = "workflow";
-const RENDER_MAX_AGENTS_PER_PHASE = 4;
-const RENDER_MAX_LOGS = 2;
-var WorkflowProgressBroker = class {
-	subscribers = [];
-	states = /* @__PURE__ */ new Map();
-	/** Now() factory — overridable in tests for deterministic time. */
-	now;
-	/** Cached resolved settings per (channelId), invalidated on registration. */
-	resolved = /* @__PURE__ */ new Map();
-	constructor(opts = {}) {
-		this.opts = opts;
-		this.now = opts.now ?? (() => Date.now());
-	}
-	registerChannel(cap) {
-		if (this.subscribers.some((s) => s.channelId === cap.channelId)) {
-			log.warn({ channelId: cap.channelId }, "channel capability already registered; replacing");
-			this.subscribers = this.subscribers.filter((s) => s.channelId !== cap.channelId);
-		}
-		this.subscribers.push(cap);
-		this.resolved.delete(cap.channelId);
-		return () => {
-			this.subscribers = this.subscribers.filter((s) => s !== cap);
-			this.resolved.delete(cap.channelId);
-		};
-	}
-	attachTo(bus) {
-		const offUpdate = bus.registerListener("tool_execution_update", (event, ctx) => {
-			const e = event;
-			if (e.toolName !== WORKFLOW_TOOL_NAME) return;
-			const snap = extractWorkflowSnapshot(e.partialResult);
-			if (!snap) return;
-			this.onUpdate(ctx.conversationId, e.toolCallId, snap);
-		});
-		const offEnd = bus.registerListener("tool_execution_end", (event, ctx) => {
-			const e = event;
-			if (e.toolName !== WORKFLOW_TOOL_NAME) return;
-			const snap = extractWorkflowSnapshot(e.result, { fromResultEnvelope: true });
-			this.onEnd(ctx.conversationId, e.toolCallId, snap);
-		});
-		return { dispose: () => {
-			offUpdate();
-			offEnd();
-			this.disposeAllPending();
-		} };
-	}
-	/** Visible for tests — direct entry path bypassing the SessionBus glue. */
-	onUpdate(conversationId, toolCallId, snapshot) {
-		const key = stateKey(conversationId, toolCallId);
-		const state = this.getOrCreateState(key, snapshot);
-		state.prevSnapshot = state.snapshot;
-		state.snapshot = snapshot;
-		const isKey = isKeyEvent(state.prevSnapshot, snapshot);
-		for (const cap of this.subscribers) this.dispatchToChannel(state, conversationId, cap, {
-			isFinal: false,
-			isKey
-		});
-	}
-	/** Visible for tests — direct entry path bypassing the SessionBus glue. */
-	onEnd(conversationId, toolCallId, snapshot) {
-		const key = stateKey(conversationId, toolCallId);
-		const state = this.states.get(key);
-		if (!state) return;
-		if (snapshot) state.snapshot = snapshot;
-		for (const cap of this.subscribers) {
-			this.cancelPending(state, cap.channelId);
-			this.dispatchToChannel(state, conversationId, cap, {
-				isFinal: true,
-				isKey: true
-			});
-		}
-		setTimeout(() => this.states.delete(key), 2e3);
-	}
-	dispatchToChannel(state, conversationId, cap, flags) {
-		const cfg = this.resolveChannelSettings(cap);
-		if (!cfg.enabled) return;
-		if (cfg.mode === "final-only" && !flags.isFinal) return;
-		const chState = this.getOrCreateChannelState(state, cap.channelId);
-		if (flags.isFinal || flags.isKey) {
-			this.cancelPending(state, cap.channelId);
-			this.sendNow(state, conversationId, cap, cfg, flags.isFinal);
-			return;
-		}
-		const elapsed = this.now() - chState.lastSentAt;
-		const wait = Math.max(0, cfg.throttleMs - elapsed);
-		if (wait === 0) {
-			this.sendNow(state, conversationId, cap, cfg, false);
-			return;
-		}
-		if (chState.pendingTimer) return;
-		chState.pendingTimer = setTimeout(() => {
-			chState.pendingTimer = void 0;
-			this.sendNow(state, conversationId, cap, cfg, false);
-		}, wait);
-	}
-	async sendNow(state, conversationId, cap, cfg, isFinal) {
-		const chState = this.getOrCreateChannelState(state, cap.channelId);
-		if (chState.inflight) await chState.inflight.catch(() => void 0);
-		const text = renderWorkflowText(state.snapshot, isFinal, {
-			maxAgentsPerPhase: RENDER_MAX_AGENTS_PER_PHASE,
-			maxLogs: RENDER_MAX_LOGS,
-			showResultPreviews: isFinal
-		});
-		const previousMessageId = cfg.mode === "edit" ? chState.lastMessageId : void 0;
-		const task = cap.postProgress({
-			conversationId,
-			text,
-			previousMessageId,
-			isFinal,
-			mode: cfg.mode
-		}).then((r) => {
-			chState.lastMessageId = r.messageId;
-			chState.lastSentAt = this.now();
-		}).catch((err) => {
-			const msg = err instanceof Error ? err.message : String(err);
-			log.warn({
-				err,
-				errorMessage: msg,
-				channelId: cap.channelId,
-				conversationId
-			}, `workflow progress postProgress failed: ${msg}`);
-		}).finally(() => {
-			chState.inflight = void 0;
-		});
-		chState.inflight = task;
-		await task;
-	}
-	cancelPending(state, channelId) {
-		const chState = state.perChannel.get(channelId);
-		if (chState?.pendingTimer) {
-			clearTimeout(chState.pendingTimer);
-			chState.pendingTimer = void 0;
-		}
-	}
-	disposeAllPending() {
-		for (const state of this.states.values()) for (const ch of state.perChannel.values()) if (ch.pendingTimer) clearTimeout(ch.pendingTimer);
-		this.states.clear();
-	}
-	getOrCreateState(key, snapshot) {
-		let state = this.states.get(key);
-		if (!state) {
-			state = {
-				snapshot,
-				perChannel: /* @__PURE__ */ new Map()
-			};
-			this.states.set(key, state);
-		}
-		return state;
-	}
-	getOrCreateChannelState(state, channelId) {
-		let ch = state.perChannel.get(channelId);
-		if (!ch) {
-			ch = { lastSentAt: 0 };
-			state.perChannel.set(channelId, ch);
-		}
-		return ch;
-	}
-	/** Resolved (enabled / throttleMs / mode) for a channel, with config overrides. */
-	resolveChannelSettings(cap) {
-		const cached = this.resolved.get(cap.channelId);
-		if (cached) return cached;
-		const override = readChannelConfig(this.opts.getConfig?.(), cap.channelId);
-		const resolved = {
-			enabled: override?.enabled ?? true,
-			throttleMs: override?.throttleMs ?? cap.defaultThrottleMs,
-			mode: override?.mode ?? cap.defaultMode
-		};
-		this.resolved.set(cap.channelId, resolved);
-		return resolved;
-	}
-	/** Drop any cached config so the next dispatch re-reads. Call after config reload. */
-	invalidateConfigCache() {
-		this.resolved.clear();
-	}
-	/** @internal — for tests only. */
-	_stateCount() {
-		return this.states.size;
-	}
-};
-let singleton = null;
-/**
-* Process-wide broker singleton. Channels register against this one; the
-* service wires it to the session bus during startup.
-*/
-function getWorkflowProgressBroker() {
-	if (!singleton) singleton = new WorkflowProgressBroker();
-	return singleton;
-}
-/** Test-only — reset the singleton between cases. */
-function _resetWorkflowProgressBrokerForTests() {
-	singleton = null;
-}
-function stateKey(conversationId, toolCallId) {
-	return `${conversationId}
${toolCallId ?? ""}`;
-}
-/**
-* Compare two snapshots and decide whether the new one is "key" — i.e. worth
-* bypassing the per-channel throttle. Anything visible to the user as a
-* progress milestone qualifies; counts ticking by alone do not.
-*/
-function isKeyEvent(prev, next) {
-	if (!prev) return true;
-	if (prev.currentPhase !== next.currentPhase) return true;
-	if (next.errorCount > prev.errorCount) return true;
-	if (next.skippedCount > prev.skippedCount) return true;
-	if (prev.phases.length !== next.phases.length) return true;
-	if (hasNewFailedAgent(prev.agents, next.agents)) return true;
-	return false;
-}
-function hasNewFailedAgent(prev, next) {
-	const prevBad = new Set(prev.filter((a) => a.status === "error" || a.status === "skipped").map((a) => a.id));
-	for (const a of next) if ((a.status === "error" || a.status === "skipped") && !prevBad.has(a.id)) return true;
-	return false;
-}
-/**
-* Pull a {@link WorkflowSnapshot} out of an AgentToolResult-shaped value.
-* Returns null when the payload is not snapshot-shaped (text-only updates,
-* non-workflow tools, etc.).
-*
-* `fromResultEnvelope = true` (used for `tool_end.result`) tolerates the
-* `{ content, details }` wrapper.
-*/
-function extractWorkflowSnapshot(payload, opts = {}) {
-	if (!payload || typeof payload !== "object") return null;
-	const rec = payload;
-	if (opts.fromResultEnvelope) {
-		const details = rec.details;
-		if (details && typeof details === "object") return coerce(details);
-		return null;
-	}
-	if ("details" in rec) {
-		const details = rec.details;
-		if (details && typeof details === "object") return coerce(details);
-		return null;
-	}
-	return coerce(rec);
-}
-function coerce(value) {
-	if (!value || typeof value !== "object") return null;
-	const rec = value;
-	if (typeof rec.name !== "string") return null;
-	if (!Array.isArray(rec.agents)) return null;
-	return value;
-}
-function readChannelConfig(config, channelId) {
-	const channels = config?.channels;
-	if (!channels) return void 0;
-	const cfg = channels[channelId];
-	if (!cfg || typeof cfg !== "object") return void 0;
-	const wf = cfg.workflowProgress;
-	if (!wf || typeof wf !== "object") return void 0;
-	return wf;
-}
-//#endregion
-export { WorkflowProgressBroker, _resetWorkflowProgressBrokerForTests, getWorkflowProgressBroker };

package/dist/src/agent/workflow/snapshot-empty.d.ts

@@ -1,2 +0,0 @@
-import type { WorkflowSnapshot } from './types.js';
-export declare function emptySnapshotFor(name: string, description?: string, phaseTitles?: string[]): WorkflowSnapshot;

package/dist/src/agent/workflow/snapshot-empty.js

@@ -1,17 +0,0 @@
-//#region src/agent/workflow/snapshot-empty.ts
-function emptySnapshotFor(name, description, phaseTitles) {
-	return {
-		name,
-		description,
-		phases: phaseTitles ? [...phaseTitles] : [],
-		logs: [],
-		agents: [],
-		agentCount: 0,
-		runningCount: 0,
-		doneCount: 0,
-		errorCount: 0,
-		skippedCount: 0
-	};
-}
-//#endregion
-export { emptySnapshotFor };

package/dist/src/agent/workflow/snapshot.d.ts

@@ -1,28 +0,0 @@
-/**
- * Workflow progress snapshot model + text renderers.
- *
- * The runtime emits per-event callbacks (`onPhase`, `onAgentStart`, `onAgentEnd`,
- * `onLog`). The workflow tool wraps those callbacks to mutate a snapshot and push
- * a text rendering through `onUpdate` — keeping TUI / Gateway / IM consumers in
- * lock-step from a single source of truth.
- */
-import type { WorkflowSnapshotDefinition, WorkflowSnapshot } from './types.js';
-export declare function createWorkflowSnapshot(definition: WorkflowSnapshotDefinition): WorkflowSnapshot;
-export declare function recomputeCounts(snapshot: WorkflowSnapshot): void;
-export interface RenderOptions {
-    maxAgentsPerPhase?: number;
-    maxLogs?: number;
-    showResultPreviews?: boolean;
-}
-export type WorkflowPanelStatus = 'queued' | 'running' | 'succeeded' | 'failed' | 'cancelled' | 'timeout' | string;
-export interface WorkflowPanelOptions {
-    status?: WorkflowPanelStatus;
-    maxActiveAgents?: number;
-    maxRecentAgents?: number;
-    maxErrors?: number;
-    nowMs?: number;
-}
-export declare function renderWorkflowText(snapshot: WorkflowSnapshot, completed?: boolean, options?: RenderOptions): string;
-export declare function previewValue(value: unknown, max?: number): string;
-export declare function renderWorkflowPanel(snapshot: WorkflowSnapshot, options?: WorkflowPanelOptions): string;
-export declare function renderWorkflowFinalSummary(snapshot: WorkflowSnapshot, options?: WorkflowPanelOptions): string;

package/dist/src/agent/workflow/snapshot.js

@@ -1,267 +0,0 @@
-import { emptySnapshotFor } from "./snapshot-empty.js";
-//#region src/agent/workflow/snapshot.ts
-function createWorkflowSnapshot(definition) {
-	return emptySnapshotFor(definition.name, definition.description, definition.phases?.map((phase) => phase.title));
-}
-function recomputeCounts(snapshot) {
-	let running = 0;
-	let done = 0;
-	let error = 0;
-	let skipped = 0;
-	for (const agent of snapshot.agents) switch (agent.status) {
-		case "running":
-			running++;
-			break;
-		case "done":
-			done++;
-			break;
-		case "error":
-			error++;
-			break;
-		case "skipped":
-			skipped++;
-			break;
-	}
-	snapshot.agentCount = snapshot.agents.length;
-	snapshot.runningCount = running;
-	snapshot.doneCount = done;
-	snapshot.errorCount = error;
-	snapshot.skippedCount = skipped;
-}
-function renderWorkflowText(snapshot, completed = false, options = {}) {
-	const maxAgentsPerPhase = options.maxAgentsPerPhase ?? 6;
-	const maxLogs = options.maxLogs ?? 2;
-	const showPreviews = options.showResultPreviews ?? false;
-	const state = stateSuffix(snapshot);
-	const lines = [completed ? `◆ workflow ✓ ${snapshot.name} (${snapshot.doneCount}/${snapshot.agentCount} done${state})` : `◆ workflow: ${snapshot.name} (${snapshot.doneCount}/${snapshot.agentCount} done${state})`];
-	const phaseNames = uniqueOrdered([
-		...snapshot.phases,
-		...snapshot.currentPhase ? [snapshot.currentPhase] : [],
-		...snapshot.agents.map((a) => a.phase).filter((p) => Boolean(p))
-	]);
-	const rendered = /* @__PURE__ */ new Set();
-	for (const phase of phaseNames) {
-		const agents = snapshot.agents.filter((a) => a.phase === phase);
-		if (agents.length === 0 && snapshot.currentPhase !== phase) continue;
-		for (const a of agents) rendered.add(a);
-		const counts = countAgents(agents);
-		const completeHere = agents.length > 0 && counts.done + counts.error + counts.skipped === agents.length;
-		const marker = counts.running > 0 || !completeHere && snapshot.currentPhase === phase ? "▶" : completeHere ? "✓" : " ";
-		const tail = (counts.running ? ` · ${counts.running} running` : "") + (counts.error ? ` · ${counts.error} errors` : "") + (counts.skipped ? ` · ${counts.skipped} skipped` : "");
-		lines.push(`  ${marker} ${phase} ${counts.done}/${agents.length}${tail}`);
-		const visible = agents.slice(-maxAgentsPerPhase);
-		for (const agent of visible) {
-			const previewText = showPreviews && agent.resultPreview ? ` — ${agent.resultPreview}` : "";
-			lines.push(`    #${agent.id} ${statusIcon(agent.status)} ${shorten(agent.label, 56)}${previewText}`);
-		}
-		if (agents.length > visible.length) lines.push(`    … ${agents.length - visible.length} earlier agents`);
-	}
-	const unphased = snapshot.agents.filter((a) => !rendered.has(a));
-	if (unphased.length > 0) {
-		lines.push("  unphased");
-		for (const agent of unphased.slice(-maxAgentsPerPhase)) {
-			const previewText = showPreviews && agent.resultPreview ? ` — ${agent.resultPreview}` : "";
-			lines.push(`    #${agent.id} ${statusIcon(agent.status)} ${shorten(agent.label, 56)}${previewText}`);
-		}
-	}
-	const visibleLogs = snapshot.logs.slice(-maxLogs);
-	if (visibleLogs.length > 0) {
-		lines.push("");
-		for (const log of visibleLogs) lines.push(`  log: ${shorten(log, 80)}`);
-	}
-	return lines.join("\n");
-}
-function previewValue(value, max = 80) {
-	if (value === null || value === void 0) return "";
-	const text = typeof value === "string" ? value : safeStringify(value);
-	if (!text) return "";
-	return text.length > max ? `${text.slice(0, max - 1)}…` : text;
-}
-function renderWorkflowPanel(snapshot, options = {}) {
-	const status = options.status ?? inferPanelStatus(snapshot);
-	const activeAgents = snapshot.agents.filter((agent) => agent.status === "running");
-	const queuedAgents = snapshot.agents.filter((agent) => agent.status === "queued");
-	const activeLimit = options.maxActiveAgents ?? 4;
-	const recentLimit = options.maxRecentAgents ?? 4;
-	const durationText = formatDuration(resolveElapsedMs(snapshot, options.nowMs));
-	const counts = formatRunCounts(snapshot);
-	const lines = [`◆ ${snapshot.name} ${statusText(status)} ${counts}${durationText ? ` ${durationText}` : ""}`];
-	const phaseLines = renderPanelPhaseLines(snapshot);
-	if (phaseLines.length > 0) lines.push("", "Phase", ...phaseLines);
-	const visibleActive = activeAgents.length > 0 ? activeAgents : queuedAgents;
-	if (visibleActive.length > 0) {
-		lines.push("", activeAgents.length > 0 ? "Active" : "Queued");
-		for (const agent of visibleActive.slice(0, activeLimit)) lines.push(...renderActiveAgentLines(agent));
-		if (visibleActive.length > activeLimit) lines.push(`  … ${visibleActive.length - activeLimit} more`);
-	}
-	const recent = recentCompletedAgents(snapshot).slice(0, recentLimit);
-	if (recent.length > 0) {
-		lines.push("", "Recent");
-		for (const agent of recent) lines.push(renderRecentAgentLine(agent));
-	}
-	const errors = snapshot.agents.filter((agent) => agent.status === "error" || agent.error);
-	if (errors.length > 0) {
-		lines.push("", "Errors");
-		for (const agent of errors.slice(0, options.maxErrors ?? 3)) lines.push(`  ✗ #${agent.id} ${shorten(agent.label, 28)}${agent.error ? `: ${shorten(agent.error, 96)}` : ""}`);
-		if (errors.length > (options.maxErrors ?? 3)) lines.push(`  … ${errors.length - (options.maxErrors ?? 3)} more`);
-	}
-	return lines.join("\n");
-}
-function renderWorkflowFinalSummary(snapshot, options = {}) {
-	const status = options.status ?? inferPanelStatus(snapshot);
-	const durationText = formatDuration(resolveElapsedMs(snapshot, options.nowMs));
-	const lines = [`◆ ${snapshot.name} ${statusText(status)} ${formatRunCounts(snapshot)}${durationText ? ` ${durationText}` : ""}`];
-	const result = previewValue(snapshot.result, 280);
-	if (result) lines.push("", "Result", `  ${result}`);
-	else {
-		const fallback = recentCompletedAgents(snapshot).map((agent) => agent.resultPreview).find((value) => Boolean(value));
-		if (fallback) lines.push("", "Result", `  ${shorten(fallback, 280)}`);
-	}
-	const errors = snapshot.agents.filter((agent) => agent.status === "error" || agent.error);
-	if (errors.length > 0) {
-		lines.push("", "Errors");
-		for (const agent of errors.slice(0, options.maxErrors ?? 5)) lines.push(`  ✗ #${agent.id} ${shorten(agent.label, 32)}${agent.error ? `: ${shorten(agent.error, 120)}` : ""}`);
-	}
-	const recent = recentCompletedAgents(snapshot).slice(0, options.maxRecentAgents ?? 5);
-	if (recent.length > 0) {
-		lines.push("", "Completed");
-		for (const agent of recent) lines.push(renderRecentAgentLine(agent));
-	}
-	return lines.join("\n");
-}
-function countAgents(agents) {
-	let done = 0;
-	let running = 0;
-	let error = 0;
-	let skipped = 0;
-	for (const a of agents) if (a.status === "done") done++;
-	else if (a.status === "running") running++;
-	else if (a.status === "error") error++;
-	else if (a.status === "skipped") skipped++;
-	return {
-		done,
-		running,
-		error,
-		skipped
-	};
-}
-function statusIcon(status) {
-	switch (status) {
-		case "queued": return "○";
-		case "running": return "●";
-		case "done": return "✓";
-		case "error": return "✗";
-		case "skipped": return "-";
-	}
-}
-function statusText(status) {
-	switch (status) {
-		case "queued": return "queued";
-		case "running": return "running";
-		case "succeeded": return "✓ completed";
-		case "failed": return "✗ failed";
-		case "cancelled": return "cancelled";
-		case "timeout": return "timeout";
-		default: return String(status || "running");
-	}
-}
-function inferPanelStatus(snapshot) {
-	if (snapshot.errorCount > 0) return "failed";
-	if (snapshot.runningCount > 0) return "running";
-	if (snapshot.doneCount + snapshot.skippedCount >= snapshot.agentCount && snapshot.agentCount > 0) return "succeeded";
-	return "queued";
-}
-function formatRunCounts(snapshot) {
-	const parts = [`${snapshot.doneCount}/${snapshot.agentCount} done`];
-	if (snapshot.runningCount > 0) parts.push(`${snapshot.runningCount} running`);
-	if (snapshot.errorCount > 0) parts.push(`${snapshot.errorCount} errors`);
-	if (snapshot.skippedCount > 0) parts.push(`${snapshot.skippedCount} skipped`);
-	return parts.join(" · ");
-}
-function resolveElapsedMs(snapshot, nowMs = Date.now()) {
-	if (snapshot.durationMs != null) return snapshot.durationMs;
-	const starts = snapshot.agents.map((agent) => agent.startedAtMs).filter((value) => typeof value === "number" && Number.isFinite(value));
-	if (starts.length === 0) return void 0;
-	return Math.max(0, nowMs - Math.min(...starts));
-}
-function formatDuration(ms) {
-	if (ms == null || !Number.isFinite(ms)) return "";
-	const totalSeconds = Math.max(0, Math.floor(ms / 1e3));
-	const minutes = Math.floor(totalSeconds / 60);
-	const seconds = totalSeconds % 60;
-	if (minutes < 60) return `${minutes}:${String(seconds).padStart(2, "0")}`;
-	const hours = Math.floor(minutes / 60);
-	const restMinutes = minutes % 60;
-	return `${hours}:${String(restMinutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}`;
-}
-function renderPanelPhaseLines(snapshot) {
-	const phaseNames = uniqueOrdered([
-		...snapshot.phases,
-		...snapshot.currentPhase ? [snapshot.currentPhase] : [],
-		...snapshot.agents.map((a) => a.phase).filter((p) => Boolean(p))
-	]);
-	const out = [];
-	for (const phase of phaseNames) {
-		const agents = snapshot.agents.filter((agent) => agent.phase === phase);
-		const counts = countAgents(agents);
-		const complete = agents.length > 0 && counts.done + counts.error + counts.skipped === agents.length;
-		const marker = counts.running > 0 || !complete && snapshot.currentPhase === phase ? "▶" : complete ? "✓" : "○";
-		const tail = [
-			counts.running > 0 ? `${counts.running} running` : "",
-			counts.error > 0 ? `${counts.error} errors` : "",
-			counts.skipped > 0 ? `${counts.skipped} skipped` : ""
-		].filter(Boolean).join(" · ");
-		out.push(`  ${marker} ${phase} ${counts.done}/${agents.length}${tail ? ` · ${tail}` : ""}`);
-	}
-	return out;
-}
-function renderActiveAgentLines(agent) {
-	const step = agent.currentStep || latestStepSummary(agent);
-	const iteration = agent.iteration != null && agent.maxIterations != null ? ` [${agent.iteration}/${agent.maxIterations}]` : "";
-	const head = `  ${agent.status === "running" ? "●" : "○"} #${agent.id} ${shorten(agent.label, 32)}${iteration}`;
-	return step ? [head, `     ${shorten(step, 96)}`] : [head];
-}
-function renderRecentAgentLine(agent) {
-	const preview = agent.error || agent.resultPreview || latestStepResult(agent);
-	return `  ${statusIcon(agent.status)} #${agent.id} ${shorten(agent.label, 32)}${preview ? ` — ${shorten(preview, 96)}` : ""}`;
-}
-function recentCompletedAgents(snapshot) {
-	return [...snapshot.agents].filter((agent) => agent.status === "done" || agent.status === "error" || agent.status === "skipped").reverse();
-}
-function latestStepSummary(agent) {
-	const step = [...agent.steps ?? []].reverse().find((entry) => entry.status === "running") ?? agent.steps?.[agent.steps.length - 1];
-	if (!step) return "";
-	return step.detail ? `${step.label}: ${step.detail}` : step.label;
-}
-function latestStepResult(agent) {
-	const step = [...agent.steps ?? []].reverse().find((entry) => entry.resultPreview || entry.error);
-	return step?.error || step?.resultPreview || "";
-}
-function stateSuffix(snapshot) {
-	if (snapshot.errorCount > 0) return `, ${snapshot.errorCount} errors`;
-	if (snapshot.skippedCount > 0) return `, ${snapshot.skippedCount} skipped`;
-	if (snapshot.runningCount > 0) return `, ${snapshot.runningCount} running`;
-	return "";
-}
-function uniqueOrdered(values) {
-	const seen = /* @__PURE__ */ new Set();
-	const out = [];
-	for (const v of values) if (!seen.has(v)) {
-		seen.add(v);
-		out.push(v);
-	}
-	return out;
-}
-function shorten(value, max) {
-	const text = value.replace(/\s+/g, " ").trim();
-	return text.length > max ? `${text.slice(0, max - 1)}…` : text;
-}
-function safeStringify(value) {
-	try {
-		return JSON.stringify(value);
-	} catch {
-		return String(value);
-	}
-}
-//#endregion
-export { createWorkflowSnapshot, previewValue, recomputeCounts, renderWorkflowFinalSummary, renderWorkflowPanel, renderWorkflowText };

package/dist/src/agent/workflow/step-labels.d.ts

@@ -1,8 +0,0 @@
-/**
- * Human-readable labels for workflow subagent tool steps (server-side snapshot).
- * Mirrors the web `tool-friendly-title` rules so IM/TUI and gateway stay aligned.
- */
-export declare function workflowStepLabel(toolName: string, args: Record<string, unknown>): {
-    label: string;
-    detail?: string;
-};