t3code-cli 0.14.1 → 0.14.2

package/dist/client-runtime/state/subagentRuntime.js

@@ -0,0 +1,521 @@
+//#region upstream-t3code/packages/client-runtime/src/state/subagentRuntime.ts
+const TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+	"completed",
+	"failed",
+	"cancelled",
+	"interrupted"
+]);
+function isTerminalSubagentStatus(status) {
+	return TERMINAL_STATUSES.has(status);
+}
+/** Active = the user may still need to care while it runs. Idle is settled-ish
+* but resumable; waiting counts as active because it needs the user. */
+function isActiveSubagentStatus(status) {
+	return status === "pending" || status === "running" || status === "waiting";
+}
+const RECENT_ACTIVITY_LIMIT = 6;
+const SUMMARY_CHAR_LIMIT = 180;
+const ROSTER_LIMIT = 100;
+/**
+* True when this activity's payload does NOT belong on the Agents surface.
+* Classification happens exactly once, server-side at ingestion
+* (classifyTaskAgentKind → the persisted agentKind stamp); the client only
+* reads it. Rows without a stamp — legacy threads, pre-stamp servers — are
+* background by definition: they render in the ordinary work log, exactly
+* as they did before this feature existed.
+*/
+function isBackgroundTaskActivity(payload) {
+	return payload.agentKind !== "agent";
+}
+function bounded(value) {
+	return value.length <= SUMMARY_CHAR_LIMIT ? value : `${value.slice(0, SUMMARY_CHAR_LIMIT - 1)}…`;
+}
+/** Appends to the ring buffer, deduping consecutive identical summaries. */
+function appendActivity(entries, at, summary) {
+	const boundedSummary = bounded(summary);
+	if (entries.length > 0 && entries[entries.length - 1]?.summary === boundedSummary) return entries;
+	const next = [...entries, {
+		at,
+		summary: boundedSummary
+	}];
+	return next.length > RECENT_ACTIVITY_LIMIT ? next.slice(-6) : next;
+}
+function asString(value) {
+	return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function asCount(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+function asUsage(value) {
+	if (typeof value !== "object" || value === null) return;
+	const record = value;
+	const totalTokens = asCount(record.totalTokens);
+	if (totalTokens === void 0) return;
+	const usage = { totalTokens };
+	const inputTokens = asCount(record.inputTokens);
+	if (inputTokens !== void 0) usage.inputTokens = inputTokens;
+	const cachedInputTokens = asCount(record.cachedInputTokens);
+	if (cachedInputTokens !== void 0) usage.cachedInputTokens = cachedInputTokens;
+	const outputTokens = asCount(record.outputTokens);
+	if (outputTokens !== void 0) usage.outputTokens = outputTokens;
+	const reasoningOutputTokens = asCount(record.reasoningOutputTokens);
+	if (reasoningOutputTokens !== void 0) usage.reasoningOutputTokens = reasoningOutputTokens;
+	const toolUses = asCount(record.toolUses);
+	if (toolUses !== void 0) usage.toolUses = toolUses;
+	const durationMs = asCount(record.durationMs);
+	if (durationMs !== void 0) usage.durationMs = durationMs;
+	return usage;
+}
+/**
+* Provider-specific usage merge (#4779 semantics, verbatim):
+* - max-merge (Codex-style cumulative frames): field-wise maximum, idempotent
+*   under duplicate or late frames. Cumulative totals never shrink.
+* - accumulate (Claude-style activation deltas): not needed at this layer —
+*   Claude's task_progress usage is itself cumulative per task, so the fold
+*   also max-merges. The distinction matters when v2 sums activations.
+* Field-wise: a terminal payload carrying only totalTokens must not wipe a
+* known breakdown.
+*/
+function mergeUsageMax(current, incoming) {
+	if (!incoming) return current;
+	if (!current) return incoming;
+	const pick = (a, b) => a === void 0 ? b : b === void 0 ? a : Math.max(a, b);
+	const merged = { totalTokens: Math.max(current.totalTokens, incoming.totalTokens) };
+	const inputTokens = pick(current.inputTokens, incoming.inputTokens);
+	if (inputTokens !== void 0) merged.inputTokens = inputTokens;
+	const cachedInputTokens = pick(current.cachedInputTokens, incoming.cachedInputTokens);
+	if (cachedInputTokens !== void 0) merged.cachedInputTokens = cachedInputTokens;
+	const outputTokens = pick(current.outputTokens, incoming.outputTokens);
+	if (outputTokens !== void 0) merged.outputTokens = outputTokens;
+	const reasoningOutputTokens = pick(current.reasoningOutputTokens, incoming.reasoningOutputTokens);
+	if (reasoningOutputTokens !== void 0) merged.reasoningOutputTokens = reasoningOutputTokens;
+	const toolUses = pick(current.toolUses, incoming.toolUses);
+	if (toolUses !== void 0) merged.toolUses = toolUses;
+	const durationMs = pick(current.durationMs, incoming.durationMs);
+	if (durationMs !== void 0) merged.durationMs = durationMs;
+	return merged;
+}
+function kindFromPayload(payload, agentId) {
+	if (asString(payload.taskType) === "local_workflow") return "workflow";
+	if (payload.parentAgentId !== void 0 || agentId.includes(":wf:")) return "workflow_agent";
+	return "subagent";
+}
+/** Completion can create an agent (its start may have aged out of retention). */
+function getOrCreate(agents, id, payload, at) {
+	const existing = agents.get(id);
+	if (existing) return existing;
+	const created = {
+		id,
+		kind: kindFromPayload(payload, id),
+		title: asString(payload.title) ?? asString(payload.detail) ?? id,
+		role: asString(payload.role) ?? null,
+		model: asString(payload.model) ?? null,
+		effort: asString(payload.effort) ?? null,
+		status: "pending",
+		activationCount: 0,
+		usage: null,
+		progress: null,
+		lastToolName: null,
+		result: null,
+		error: null,
+		outputFile: null,
+		parentAgentId: asString(payload.parentAgentId) ?? null,
+		agentIndex: asCount(payload.agentIndex) ?? null,
+		phaseIndex: asCount(payload.phaseIndex) ?? null,
+		phaseTitle: asString(payload.phaseTitle) ?? null,
+		attempt: asCount(payload.attempt) ?? null,
+		workflowName: asString(payload.workflowName) ?? null,
+		phases: [],
+		runHandles: null,
+		recentActivity: [],
+		firstSeenAt: at,
+		startedAt: null,
+		completedAt: null,
+		updatedAt: at
+	};
+	agents.set(id, created);
+	return created;
+}
+/** Metadata fill from any payload: never downgrades known values to null. */
+function fillMetadata(agent, payload) {
+	const title = asString(payload.title);
+	if (title) agent.title = title;
+	const role = asString(payload.role);
+	if (role) agent.role = role;
+	const model = asString(payload.model);
+	if (model) agent.model = model;
+	const effort = asString(payload.effort);
+	if (effort) agent.effort = effort;
+	const parentAgentId = asString(payload.parentAgentId);
+	if (parentAgentId) {
+		agent.parentAgentId = parentAgentId;
+		if (agent.kind === "subagent") agent.kind = "workflow_agent";
+	}
+	const workflowName = asString(payload.workflowName);
+	if (workflowName) agent.workflowName = workflowName;
+	if (asString(payload.taskType) === "local_workflow") agent.kind = "workflow";
+	const agentIndex = asCount(payload.agentIndex);
+	if (agentIndex !== void 0) agent.agentIndex = agentIndex;
+	const phaseIndex = asCount(payload.phaseIndex);
+	if (phaseIndex !== void 0) agent.phaseIndex = phaseIndex;
+	const phaseTitle = asString(payload.phaseTitle);
+	if (phaseTitle) agent.phaseTitle = phaseTitle;
+	const attempt = asCount(payload.attempt);
+	if (attempt !== void 0) {
+		if (agent.attempt !== null && attempt > agent.attempt) {
+			agent.result = null;
+			agent.error = null;
+			agent.completedAt = null;
+		}
+		agent.attempt = attempt;
+	}
+	const outputFile = asString(payload.outputFile);
+	if (outputFile) agent.outputFile = outputFile;
+	if (Array.isArray(payload.phases)) {
+		const phases = [];
+		for (const entry of payload.phases) {
+			if (typeof entry !== "object" || entry === null) continue;
+			const record = entry;
+			const index = asCount(record.index);
+			const phaseName = asString(record.title);
+			if (index !== void 0 && phaseName) phases.push({
+				index,
+				title: phaseName
+			});
+		}
+		if (phases.length > 0) agent.phases = phases.slice().sort((a, b) => a.index - b.index);
+	}
+	if (typeof payload.runHandles === "object" && payload.runHandles !== null) {
+		const record = payload.runHandles;
+		const runHandles = {};
+		const runId = asString(record.runId);
+		if (runId) runHandles.runId = runId;
+		const scriptPath = asString(record.scriptPath);
+		if (scriptPath) runHandles.scriptPath = scriptPath;
+		const transcriptDir = asString(record.transcriptDir);
+		if (transcriptDir) runHandles.transcriptDir = transcriptDir;
+		const sessionUrl = asString(record.sessionUrl);
+		if (sessionUrl && /^https?:\/\//i.test(sessionUrl)) runHandles.sessionUrl = sessionUrl;
+		if (Object.keys(runHandles).length > 0) agent.runHandles = {
+			...agent.runHandles,
+			...runHandles
+		};
+	}
+}
+function applyStatus(agent, status, at) {
+	const wasTerminal = isTerminalSubagentStatus(agent.status);
+	const isTerminal = isTerminalSubagentStatus(status);
+	if (wasTerminal && isTerminal) return;
+	if ((wasTerminal || agent.status === "idle") && (status === "running" || status === "pending")) {
+		agent.activationCount += 1;
+		agent.result = null;
+		agent.error = null;
+		agent.completedAt = null;
+		if (status === "running") agent.startedAt = at;
+	}
+	if (status === "running" && agent.startedAt === null) agent.startedAt = at;
+	if (isTerminal && agent.completedAt === null) agent.completedAt = at;
+	agent.status = status;
+}
+const TASK_COMPLETED_STATUS = /* @__PURE__ */ new Map([
+	["completed", "completed"],
+	["failed", "failed"],
+	["stopped", "interrupted"]
+]);
+const KNOWN_STATUSES = /* @__PURE__ */ new Set([
+	"pending",
+	"running",
+	"waiting",
+	"idle",
+	"completed",
+	"failed",
+	"cancelled",
+	"interrupted"
+]);
+function asRuntimeStatus(value) {
+	return typeof value === "string" && KNOWN_STATUSES.has(value) ? value : void 0;
+}
+/**
+* Folds a thread's persisted activities into subagent state. Tolerant by
+* construction: malformed rows are skipped individually; unknown kinds are
+* ignored. Pure — memoize by activity-list identity at the atom layer.
+*
+* sessionLive=false derives interruption: background tasks die with their
+* provider session, so agents whose terminal rows were lost (server
+* restart, crash) must not read as running forever (review finding: a dead
+* session left a panel full of "Working" agents while the sidebar showed
+* nothing). Idle is preserved — a resumable Codex child stays resumable.
+*/
+function foldSubagentActivities(activities, options) {
+	const agents = /* @__PURE__ */ new Map();
+	for (const activity of activities) {
+		if (typeof activity.payload !== "object" || activity.payload === null) continue;
+		const payload = activity.payload;
+		const at = activity.createdAt;
+		switch (activity.kind) {
+			case "task.started": {
+				const taskId = asString(payload.taskId);
+				if (!taskId) break;
+				if (isBackgroundTaskActivity(payload)) break;
+				const agent = getOrCreate(agents, taskId, payload, at);
+				fillMetadata(agent, payload);
+				if (agent.activationCount === 0 && !isTerminalSubagentStatus(agent.status)) {
+					agent.activationCount = 1;
+					agent.startedAt = agent.startedAt ?? at;
+					agent.status = "running";
+				} else if (agent.status === "idle") applyStatus(agent, "running", at);
+				const detail = asString(payload.detail);
+				if (detail && agent.title === agent.id) agent.title = detail;
+				agent.updatedAt = at;
+				break;
+			}
+			case "task.progress": {
+				const taskId = asString(payload.taskId);
+				if (!taskId) break;
+				const existed = agents.has(taskId);
+				if (!existed && isBackgroundTaskActivity(payload)) break;
+				const agent = getOrCreate(agents, taskId, payload, at);
+				fillMetadata(agent, payload);
+				if (agent.activationCount === 0) agent.activationCount = 1;
+				const explicitStatus = asRuntimeStatus(payload.status);
+				if (explicitStatus) applyStatus(agent, explicitStatus, at);
+				else if ((payload.usageSnapshot !== true || !existed) && !isTerminalSubagentStatus(agent.status) && agent.status !== "idle") applyStatus(agent, "running", at);
+				const summary = asString(payload.summary);
+				if (summary) {
+					agent.progress = bounded(summary);
+					agent.recentActivity = appendActivity(agent.recentActivity, at, summary);
+				}
+				const lastToolName = asString(payload.lastToolName);
+				if (lastToolName) {
+					agent.lastToolName = lastToolName;
+					if (!summary) agent.recentActivity = appendActivity(agent.recentActivity, at, `▸ ${lastToolName}`);
+				}
+				const error = asString(payload.error);
+				if (error) agent.error = bounded(error);
+				agent.usage = mergeUsageMax(agent.usage, asUsage(payload.typedUsage));
+				agent.updatedAt = at;
+				break;
+			}
+			case "task.updated": {
+				const taskId = asString(payload.taskId);
+				if (!taskId) break;
+				if (!agents.has(taskId) && isBackgroundTaskActivity(payload)) break;
+				const agent = getOrCreate(agents, taskId, payload, at);
+				fillMetadata(agent, payload);
+				if (agent.activationCount === 0) agent.activationCount = 1;
+				const wasTerminal = isTerminalSubagentStatus(agent.status);
+				const status = asRuntimeStatus(payload.status);
+				if (status) applyStatus(agent, status, at);
+				const error = asString(payload.error);
+				if (error) agent.error = bounded(error);
+				const endedAt = asString(payload.endedAt);
+				if (endedAt && !wasTerminal && isTerminalSubagentStatus(agent.status)) agent.completedAt = endedAt;
+				agent.updatedAt = at;
+				break;
+			}
+			case "task.completed": {
+				const taskId = asString(payload.taskId);
+				if (!taskId) break;
+				if (!agents.has(taskId) && isBackgroundTaskActivity(payload)) break;
+				const agent = getOrCreate(agents, taskId, payload, at);
+				fillMetadata(agent, payload);
+				if (agent.activationCount === 0) agent.activationCount = 1;
+				const summary = asString(payload.summary) ?? asString(payload.detail);
+				if (isTerminalSubagentStatus(agent.status)) {
+					if (summary) if (agent.status === "failed") agent.error = agent.error ?? bounded(summary);
+					else agent.result = agent.result ?? bounded(summary);
+					agent.usage = mergeUsageMax(agent.usage, asUsage(payload.typedUsage));
+					break;
+				}
+				const status = TASK_COMPLETED_STATUS.get(asString(payload.status) ?? "") ?? "completed";
+				applyStatus(agent, status, at);
+				if (summary) if (status === "failed") agent.error = agent.error ?? bounded(summary);
+				else agent.result = bounded(summary);
+				agent.usage = mergeUsageMax(agent.usage, asUsage(payload.typedUsage));
+				agent.updatedAt = at;
+				break;
+			}
+			case "tool.progress": {
+				const taskId = asString(payload.taskId);
+				if (!taskId) break;
+				const agent = agents.get(taskId);
+				if (!agent) break;
+				const toolName = asString(payload.toolName);
+				if (toolName) {
+					agent.lastToolName = toolName;
+					agent.recentActivity = appendActivity(agent.recentActivity, at, `▸ ${toolName}`);
+				}
+				agent.updatedAt = at;
+				break;
+			}
+			default: break;
+		}
+	}
+	for (const agent of agents.values()) {
+		if (agent.kind !== "workflow" || !isTerminalSubagentStatus(agent.status)) continue;
+		for (const member of agents.values()) {
+			if (member.parentAgentId !== agent.id) continue;
+			if (isTerminalSubagentStatus(member.status) || member.status === "idle") continue;
+			member.status = agent.status === "completed" ? "completed" : "interrupted";
+			member.completedAt = member.completedAt ?? agent.completedAt ?? agent.updatedAt;
+			member.updatedAt = agent.updatedAt;
+		}
+	}
+	if (options?.sessionLive === false) {
+		for (const agent of agents.values()) if (isActiveSubagentStatus(agent.status)) {
+			agent.status = "interrupted";
+			agent.completedAt = agent.completedAt ?? agent.updatedAt;
+		}
+	}
+	let roster = Array.from(agents.values());
+	if (roster.length > ROSTER_LIMIT) {
+		const rank = (agent) => isActiveSubagentStatus(agent.status) ? 0 : agent.status === "idle" ? 1 : 2;
+		roster = roster.slice().sort((a, b) => rank(a) - rank(b) || b.updatedAt.localeCompare(a.updatedAt)).slice(0, ROSTER_LIMIT);
+	}
+	return roster.map((agent) => ({ ...agent }));
+}
+const EMPTY_PANEL_MODEL = {
+	workflows: [],
+	directAgents: [],
+	runningCount: 0,
+	waitingCount: 0,
+	idleCount: 0,
+	settledCount: 0,
+	totalTokens: 0,
+	hasAgents: false,
+	liveCount: 0
+};
+function emptyAgentPanelModel() {
+	return EMPTY_PANEL_MODEL;
+}
+/**
+* Source-neutral view model. When the orchestration-v2 subagent projection
+* exists for the thread, pass it as v2Projection and it wins outright — the
+* two sources are never merged (duplicate-agents failure mode). Until v2
+* lands, callers pass null and the native fold output is used.
+*/
+function deriveAgentPanelModel({ agents, v2Projection }) {
+	const source = v2Projection ?? agents;
+	if (source.length === 0) return EMPTY_PANEL_MODEL;
+	const workflows = source.filter((agent) => agent.kind === "workflow").slice().sort((a, b) => a.firstSeenAt.localeCompare(b.firstSeenAt) || a.id.localeCompare(b.id));
+	const workflowIds = new Set(workflows.map((workflow) => workflow.id));
+	const members = /* @__PURE__ */ new Map();
+	const direct = [];
+	for (const agent of source) {
+		if (agent.kind === "workflow") continue;
+		if (agent.parentAgentId !== null && workflowIds.has(agent.parentAgentId)) {
+			const list = members.get(agent.parentAgentId) ?? [];
+			list.push(agent);
+			members.set(agent.parentAgentId, list);
+		} else direct.push(agent);
+	}
+	const workflowGroups = workflows.map((workflow) => {
+		const workflowMembers = members.get(workflow.id) ?? [];
+		const knownPhases = workflow.phases.length > 0 ? workflow.phases : (() => {
+			const derived = /* @__PURE__ */ new Map();
+			for (const member of workflowMembers) if (member.phaseIndex !== null && !derived.has(member.phaseIndex)) derived.set(member.phaseIndex, member.phaseTitle ?? `Phase ${member.phaseIndex + 1}`);
+			return Array.from(derived.entries()).map(([index, title]) => ({
+				index,
+				title
+			})).slice().sort((a, b) => a.index - b.index);
+		})();
+		const knownPhaseIndices = new Set(knownPhases.map((phase) => phase.index));
+		return {
+			workflow,
+			phases: knownPhases.map((phase) => {
+				const phaseMembers = workflowMembers.filter((member) => member.phaseIndex === phase.index).slice().sort((a, b) => (a.agentIndex ?? 0) - (b.agentIndex ?? 0));
+				const activeCount = phaseMembers.filter((member) => isActiveSubagentStatus(member.status) || member.status === "idle").length;
+				const settledCount = phaseMembers.filter((member) => isTerminalSubagentStatus(member.status)).length;
+				const state = phaseMembers.length === 0 ? "pending" : activeCount > 0 ? "running" : settledCount === phaseMembers.length ? "done" : "pending";
+				return {
+					index: phase.index,
+					title: phase.title,
+					members: phaseMembers,
+					state,
+					activeCount,
+					settledCount
+				};
+			}),
+			unphasedMembers: workflowMembers.filter((member) => member.phaseIndex === null || !knownPhaseIndices.has(member.phaseIndex)).slice().sort((a, b) => (a.agentIndex ?? 0) - (b.agentIndex ?? 0))
+		};
+	});
+	let runningCount = 0;
+	let waitingCount = 0;
+	let idleCount = 0;
+	let settledCount = 0;
+	let totalTokens = 0;
+	for (const agent of source) {
+		if (agent.status === "running" || agent.status === "pending") runningCount += 1;
+		else if (agent.status === "waiting") waitingCount += 1;
+		else if (agent.status === "idle") idleCount += 1;
+		else settledCount += 1;
+		if (agent.kind !== "workflow" || (members.get(agent.id) ?? []).length === 0) totalTokens += agent.usage?.totalTokens ?? 0;
+	}
+	return {
+		workflows: workflowGroups,
+		directAgents: direct.slice().sort((a, b) => a.firstSeenAt.localeCompare(b.firstSeenAt) || a.id.localeCompare(b.id)),
+		runningCount,
+		waitingCount,
+		idleCount,
+		settledCount,
+		totalTokens,
+		hasAgents: true,
+		liveCount: runningCount + waitingCount
+	};
+}
+/**
+* Members ordered by urgency for the capped inline workflow card: running and
+* failed first, then waiting, then most recently updated.
+*/
+function workflowCardMembers(group, limit) {
+	const all = [...group.phases.flatMap((phase) => phase.members), ...group.unphasedMembers];
+	const urgency = (agent) => {
+		if (agent.status === "failed") return 0;
+		if (agent.status === "running") return 1;
+		if (agent.status === "waiting") return 2;
+		return 3;
+	};
+	const ordered = all.slice().sort((a, b) => urgency(a) - urgency(b) || b.updatedAt.localeCompare(a.updatedAt));
+	return {
+		visible: ordered.slice(0, limit),
+		overflow: Math.max(0, ordered.length - limit)
+	};
+}
+/** Kinds the timeline should not render as generic rows (fold input only). */
+function isSubagentActivityKind(kind) {
+	return kind === "task.started" || kind === "task.progress" || kind === "task.updated" || kind === "task.completed" || kind === "tool.progress";
+}
+/**
+* Quiet-timeline guarantee: tool rows attributed to an owning agent belong in
+* the Agents surface, not the parent chat. Unattributed rows must stay.
+*/
+function isAgentAttributedToolActivity(activity) {
+	if (typeof activity.payload !== "object" || activity.payload === null) return false;
+	const payload = activity.payload;
+	return typeof payload.agentId === "string" && payload.agentId.trim().length > 0;
+}
+/** Timeline-bypassing synthesized rows (Codex children, workflow members). */
+function isTimelineBypassActivity(activity) {
+	if (typeof activity.payload !== "object" || activity.payload === null) return false;
+	return activity.payload.timelineBypass === true;
+}
+/**
+* Compact model chip text: strips vendor prefixes/date-or-context suffixes
+* ("claude-sonnet-5[1m]" → "sonnet-5[1m]", "claude-opus-4-20250514" →
+* "opus-4"). Unknown ids pass through untouched; effort appends as "· high".
+*/
+function formatSubagentModelLabel(model, effort) {
+	if (!model) return null;
+	const compact = model.replace(/^claude-/, "").replace(/-\d{8}$/, "").replace(/-latest$/, "");
+	return effort ? `${compact} · ${effort}` : compact;
+}
+function formatSubagentTokenCount(totalTokens) {
+	if (totalTokens < 1e3) return `${totalTokens}`;
+	if (totalTokens < 1e6) {
+		const value = totalTokens / 1e3;
+		return `${value >= 100 ? Math.round(value) : value.toFixed(1)}k`;
+	}
+	return `${(totalTokens / 1e6).toFixed(1)}M`;
+}
+//#endregion
+export { deriveAgentPanelModel, emptyAgentPanelModel, foldSubagentActivities, formatSubagentModelLabel, formatSubagentTokenCount, isActiveSubagentStatus, isAgentAttributedToolActivity, isBackgroundTaskActivity, isSubagentActivityKind, isTerminalSubagentStatus, isTimelineBypassActivity, workflowCardMembers };

package/dist/client-runtime/state/terminal.d.ts

@@ -1,4 +1,4 @@
-import { $T as ThreadId, Hb as TerminalCwdNotDirectoryError, Jb as TerminalMetadataStreamEvent, Rb as TerminalAttachStreamEvent, Ub as TerminalCwdNotFoundError, Wb as TerminalCwdStatError, Yb as TerminalNotRunningError, Zb as TerminalResizeError, bT as EnvironmentAuthorizationError, f as AtomCommand, ha as EnvironmentRegistry, ix as TerminalSummary, ma as EnvironmentNotRegisteredError, nx as TerminalSessionSnapshot, on as EnvironmentRpcUnavailableError, ox as TerminalWriteError, qb as TerminalHistoryError, tx as TerminalSessionLookupError, zT as EnvironmentId } from "../../shared.js";
+import { AS as TerminalSessionLookupError, CD as EnvironmentId, CS as TerminalMetadataStreamEvent, ES as TerminalResizeError, FS as TerminalWriteError, NS as TerminalSummary, RD as ThreadId, SS as TerminalHistoryError, Ta as EnvironmentRegistry, _S as TerminalCwdNotDirectoryError, f as AtomCommand, iD as EnvironmentAuthorizationError, jS as TerminalSessionSnapshot, mn as EnvironmentRpcUnavailableError, pS as TerminalAttachStreamEvent, vS as TerminalCwdNotFoundError, wS as TerminalNotRunningError, wa as EnvironmentNotRegisteredError, yS as TerminalCwdStatError } from "../../shared.js";
 import { Atom } from "effect/unstable/reactivity";
 //#region upstream-t3code/packages/client-runtime/src/state/terminalSession.d.ts
 interface TerminalSessionState {
@@ -54,7 +54,7 @@ declare function createTerminalEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<
   }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<TerminalBufferState, E | EnvironmentAuthorizationError | import("effect/Cause").NoSuchElementError | import("effect/unstable/rpc/RpcClientError").RpcClientError | TerminalCwdNotDirectoryError | TerminalCwdNotFoundError | TerminalCwdStatError | TerminalHistoryError | TerminalNotRunningError | TerminalResizeError | TerminalSessionLookupError | TerminalWriteError>>;
   events: (target: {
     readonly environmentId: EnvironmentId;
-    readonly input: import("effect/Schema").Struct.ReadonlyMakeIn<{}>;
+    readonly input: {};
   }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
     readonly threadId: string;
     readonly terminalId: string;
@@ -175,27 +175,27 @@ declare function createTerminalEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<
   }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | import("effect/unstable/rpc/RpcClientError").RpcClientError | TerminalCwdNotDirectoryError | TerminalCwdNotFoundError | TerminalCwdStatError | TerminalHistoryError | TerminalNotRunningError | TerminalResizeError | TerminalSessionLookupError | TerminalWriteError>;
   write: AtomCommand<{
     readonly environmentId: EnvironmentId;
-    readonly input: import("effect/Schema").Struct.ReadonlyMakeIn<{
-      readonly threadId: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
-      readonly terminalId: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
-      readonly data: import("effect/Schema").String;
-    }>;
+    readonly input: {
+      readonly threadId: string;
+      readonly terminalId: string;
+      readonly data: string;
+    };
   }, void, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | import("effect/unstable/rpc/RpcClientError").RpcClientError | TerminalCwdNotDirectoryError | TerminalCwdNotFoundError | TerminalCwdStatError | TerminalHistoryError | TerminalNotRunningError | TerminalResizeError | TerminalSessionLookupError | TerminalWriteError>;
   resize: AtomCommand<{
     readonly environmentId: EnvironmentId;
-    readonly input: import("effect/Schema").Struct.ReadonlyMakeIn<{
-      readonly threadId: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
-      readonly terminalId: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
-      readonly cols: import("effect/Schema").Int;
-      readonly rows: import("effect/Schema").Int;
-    }>;
+    readonly input: {
+      readonly threadId: string;
+      readonly terminalId: string;
+      readonly cols: number;
+      readonly rows: number;
+    };
   }, void, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | import("effect/unstable/rpc/RpcClientError").RpcClientError | TerminalCwdNotDirectoryError | TerminalCwdNotFoundError | TerminalCwdStatError | TerminalHistoryError | TerminalNotRunningError | TerminalResizeError | TerminalSessionLookupError | TerminalWriteError>;
   clear: AtomCommand<{
     readonly environmentId: EnvironmentId;
-    readonly input: import("effect/Schema").Struct.ReadonlyMakeIn<{
-      readonly threadId: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
-      readonly terminalId: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
-    }>;
+    readonly input: {
+      readonly threadId: string;
+      readonly terminalId: string;
+    };
   }, void, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | import("effect/unstable/rpc/RpcClientError").RpcClientError | TerminalCwdNotDirectoryError | TerminalCwdNotFoundError | TerminalCwdStatError | TerminalHistoryError | TerminalNotRunningError | TerminalResizeError | TerminalSessionLookupError | TerminalWriteError>;
   restart: AtomCommand<{
     readonly environmentId: EnvironmentId;

package/dist/client-runtime/state/terminal.js

@@ -1,4 +1,4 @@
-import { Fs as WS_METHODS, Ur as subscribe, dr as createEnvironmentRpcCommand, hr as createEnvironmentSubscriptionAtomFamily, iD as scan, lr as createAtomCommandScheduler, mr as createEnvironmentRpcSubscriptionAtomFamily } from "../../shared.js";
+import { Us as WS_METHODS, WO as scan, Yr as subscribe, hr as createEnvironmentRpcCommand, pr as createAtomCommandScheduler, vr as createEnvironmentRpcSubscriptionAtomFamily, yr as createEnvironmentSubscriptionAtomFamily } from "../../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/state/terminalSession.ts
 function selectRunningSubprocessTerminalIds(sessions) {
 	return sessions.filter((session) => session.state.hasRunningSubprocess).map((session) => session.target.terminalId);

package/dist/client-runtime/state/thread-search.d.ts

@@ -0,0 +1,23 @@
+import { CD as EnvironmentId, Ty as OrchestrationSearchThreadsResult, zy as OrchestrationThreadSearchMatch } from "../../shared.js";
+import { AsyncResult, Atom } from "effect/unstable/reactivity";
+//#region upstream-t3code/packages/client-runtime/src/state/threadSearch.d.ts
+interface EnvironmentThreadSearchMatch extends OrchestrationThreadSearchMatch {
+  readonly environmentId: EnvironmentId;
+}
+interface ThreadSearchResultsState {
+  readonly matches: ReadonlyArray<EnvironmentThreadSearchMatch>;
+  readonly isLoading: boolean;
+}
+declare function makeThreadSearchKey(environmentIds: ReadonlyArray<EnvironmentId>, query: string): string;
+declare function threadSearchMatchKey(match: Pick<EnvironmentThreadSearchMatch, "environmentId" | "threadId">): string;
+/**
+ * Combines one search query atom per environment. Failed and disconnected
+ * environments contribute no content matches, preserving local title search
+ * as the compatibility fallback.
+ */
+declare function createThreadSearchResultsAtomFamily<E>(options: {
+  readonly getSearchAtom: (environmentId: EnvironmentId, query: string) => Atom.Atom<AsyncResult.AsyncResult<OrchestrationSearchThreadsResult, E>>;
+  readonly labelPrefix: string;
+}): (arg: string) => Atom.Atom<ThreadSearchResultsState>;
+//#endregion
+export { EnvironmentThreadSearchMatch, ThreadSearchResultsState, createThreadSearchResultsAtomFamily, makeThreadSearchKey, threadSearchMatchKey };

package/dist/client-runtime/state/thread-search.js

@@ -0,0 +1,38 @@
+import { $r as make, Cj as getOrNull, Cw as EnvironmentId, LD as decodeUnknownSync, Zr as family, bD as ArraySchema, jD as Tuple, ni as withLabel, si as value, yx as OrchestrationSearchThreadsInput } from "../../shared.js";
+const decodeThreadSearchKey = decodeUnknownSync(Tuple([ArraySchema(EnvironmentId), OrchestrationSearchThreadsInput.fields.query]));
+function makeThreadSearchKey(environmentIds, query) {
+	return JSON.stringify([[...environmentIds].sort((left, right) => left.localeCompare(right)), query]);
+}
+function parseThreadSearchKey(key) {
+	return decodeThreadSearchKey(JSON.parse(key));
+}
+function threadSearchMatchKey(match) {
+	return JSON.stringify([match.environmentId, match.threadId]);
+}
+/**
+* Combines one search query atom per environment. Failed and disconnected
+* environments contribute no content matches, preserving local title search
+* as the compatibility fallback.
+*/
+function createThreadSearchResultsAtomFamily(options) {
+	return family((key) => make((get) => {
+		const [environmentIds, query] = parseThreadSearchKey(key);
+		const matches = [];
+		let isLoading = false;
+		for (const environmentId of environmentIds) {
+			const result = get(options.getSearchAtom(environmentId, query));
+			isLoading ||= result.waiting;
+			const value$1 = getOrNull(value(result));
+			if (value$1 !== null) matches.push(...value$1.matches.map((match) => ({
+				...match,
+				environmentId
+			})));
+		}
+		return {
+			matches,
+			isLoading
+		};
+	}).pipe(withLabel(`${options.labelPrefix}:${key}`)));
+}
+//#endregion
+export { createThreadSearchResultsAtomFamily, makeThreadSearchKey, threadSearchMatchKey };