t3code-cli 0.14.1 → 0.14.2

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

@@ -1,2 +1,2 @@
-import { $n as createEnvironmentShellAtoms, Mr as ShellSnapshotLoader, Nr as fetchEnvironmentShellSnapshot, Pr as shellSnapshotLoaderLayer, Qn as createEnvironmentServerConfigsAtom, ar as scopeProject, cr as selectEnvironmentThreadShell, er as createEnvironmentShellSummaryAtom, ir as createShellEnvironmentAtoms, jr as applyShellStreamEvent, nr as shellStateChanges, or as scopeThread, rr as createEnvironmentSnapshotAtom, sr as scopeThreadShell, tr as makeEnvironmentShellState } from "../../shared.js";
+import { Ir as applyShellStreamEvent, Lr as ShellSnapshotLoader, Rr as fetchEnvironmentShellSnapshot, ar as makeEnvironmentShellState, cr as createShellEnvironmentAtoms, dr as scopeThreadShell, fr as selectEnvironmentThreadShell, ir as createEnvironmentShellSummaryAtom, lr as scopeProject, nr as createEnvironmentServerConfigsAtom, or as shellStateChanges, rr as createEnvironmentShellAtoms, sr as createEnvironmentSnapshotAtom, ur as scopeThread, zr as shellSnapshotLoaderLayer } from "../../shared.js";
 export { ShellSnapshotLoader, applyShellStreamEvent, createEnvironmentServerConfigsAtom, createEnvironmentShellAtoms, createEnvironmentShellSummaryAtom, createEnvironmentSnapshotAtom, createShellEnvironmentAtoms, fetchEnvironmentShellSnapshot, makeEnvironmentShellState, scopeProject, scopeThread, scopeThreadShell, selectEnvironmentThreadShell, shellSnapshotLoaderLayer, shellStateChanges };

package/dist/client-runtime/state/source-control.d.ts

@@ -1,10 +1,10 @@
-import { Ca as EnvironmentCacheStore, SC as SourceControlRepositoryError, bT as EnvironmentAuthorizationError, f as AtomCommand, ha as EnvironmentRegistry, ma as EnvironmentNotRegisteredError, on as EnvironmentRpcUnavailableError, zT as EnvironmentId } from "../../shared.js";
+import { CD as EnvironmentId, Na as EnvironmentCacheStore, Ta as EnvironmentRegistry, aT as SourceControlRepositoryError, f as AtomCommand, iD as EnvironmentAuthorizationError, mn as EnvironmentRpcUnavailableError, wa as EnvironmentNotRegisteredError } from "../../shared.js";
 import { Atom } from "effect/unstable/reactivity";
 //#region upstream-t3code/packages/client-runtime/src/state/sourceControl.d.ts
 declare function createSourceControlEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<EnvironmentRegistry | EnvironmentCacheStore | R, E>): {
   discovery: (target: {
     readonly environmentId: EnvironmentId;
-    readonly input: import("effect/Schema").Struct.ReadonlyMakeIn<{}>;
+    readonly input: {};
   }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
     readonly versionControlSystems: readonly {
       readonly label: string;

package/dist/client-runtime/state/source-control.js

@@ -1,4 +1,4 @@
-import { Fs as WS_METHODS, St as vcsCommandScheduler, dr as createEnvironmentRpcCommand, fr as createEnvironmentRpcQueryAtomFamily, lr as createAtomCommandScheduler, vt as invalidateCachedVcsRefs, xt as vcsCommandConcurrency } from "../../shared.js";
+import { St as vcsCommandScheduler, Us as WS_METHODS, gr as createEnvironmentRpcQueryAtomFamily, hr as createEnvironmentRpcCommand, pr as createAtomCommandScheduler, vt as invalidateCachedVcsRefs, xt as vcsCommandConcurrency } from "../../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/state/sourceControl.ts
 function createSourceControlEnvironmentAtoms(runtime) {
 	const commandScheduler = createAtomCommandScheduler();

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

@@ -0,0 +1,145 @@
+import { Py as OrchestrationThreadActivity } from "../../shared.js";
+//#region upstream-t3code/packages/client-runtime/src/state/subagentRuntime.d.ts
+type RuntimeSubagentStatus = "pending" | "running" | "waiting" | "idle" | "completed" | "failed" | "cancelled" | "interrupted";
+interface SubagentUsage {
+  readonly totalTokens: number;
+  readonly inputTokens?: number;
+  readonly cachedInputTokens?: number;
+  readonly outputTokens?: number;
+  readonly reasoningOutputTokens?: number;
+  readonly toolUses?: number;
+  readonly durationMs?: number;
+}
+interface SubagentActivityEntry {
+  readonly at: string;
+  readonly summary: string;
+}
+interface SubagentWorkflowPhase {
+  readonly index: number;
+  readonly title: string;
+}
+interface SubagentRunHandles {
+  readonly runId?: string;
+  readonly scriptPath?: string;
+  readonly transcriptDir?: string;
+  readonly sessionUrl?: string;
+}
+interface RuntimeSubagent {
+  readonly id: string;
+  readonly kind: "subagent" | "workflow" | "workflow_agent";
+  readonly title: string;
+  readonly role: string | null;
+  readonly model: string | null;
+  readonly effort: string | null;
+  readonly status: RuntimeSubagentStatus;
+  readonly activationCount: number;
+  readonly usage: SubagentUsage | null;
+  readonly progress: string | null;
+  readonly lastToolName: string | null;
+  readonly result: string | null;
+  readonly error: string | null;
+  readonly outputFile: string | null;
+  readonly parentAgentId: string | null;
+  readonly agentIndex: number | null;
+  readonly phaseIndex: number | null;
+  readonly phaseTitle: string | null;
+  readonly attempt: number | null;
+  readonly workflowName: string | null;
+  readonly phases: ReadonlyArray<SubagentWorkflowPhase>;
+  readonly runHandles: SubagentRunHandles | null;
+  readonly recentActivity: ReadonlyArray<SubagentActivityEntry>;
+  /** First retained observation, used as the roster's stable display order. */
+  readonly firstSeenAt: string;
+  readonly startedAt: string | null;
+  readonly completedAt: string | null;
+  readonly updatedAt: string;
+}
+declare function isTerminalSubagentStatus(status: RuntimeSubagentStatus): boolean;
+/** 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. */
+declare function isActiveSubagentStatus(status: RuntimeSubagentStatus): boolean;
+/**
+ * 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.
+ */
+declare function isBackgroundTaskActivity(payload: Record<string, unknown>): boolean;
+/**
+ * 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.
+ */
+declare function foldSubagentActivities(activities: ReadonlyArray<OrchestrationThreadActivity>, options?: {
+  readonly sessionLive?: boolean;
+}): ReadonlyArray<RuntimeSubagent>;
+interface AgentPanelWorkflowGroup {
+  readonly workflow: RuntimeSubagent;
+  readonly phases: ReadonlyArray<{
+    readonly index: number;
+    readonly title: string;
+    readonly members: ReadonlyArray<RuntimeSubagent>;
+    /** done = every member settled (success or error); running = any active. */
+    readonly state: "pending" | "running" | "done";
+    readonly activeCount: number;
+    readonly settledCount: number;
+  }>;
+  /** Members with no resolvable phase (orphans render under the workflow). */
+  readonly unphasedMembers: ReadonlyArray<RuntimeSubagent>;
+}
+interface AgentPanelModel {
+  readonly workflows: ReadonlyArray<AgentPanelWorkflowGroup>;
+  readonly directAgents: ReadonlyArray<RuntimeSubagent>;
+  readonly runningCount: number;
+  readonly waitingCount: number;
+  readonly idleCount: number;
+  readonly settledCount: number;
+  readonly totalTokens: number;
+  readonly hasAgents: boolean;
+  readonly liveCount: number;
+}
+declare function emptyAgentPanelModel(): AgentPanelModel;
+/**
+ * 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.
+ */
+declare function deriveAgentPanelModel({ agents, v2Projection }: {
+  readonly agents: ReadonlyArray<RuntimeSubagent>;
+  readonly v2Projection?: ReadonlyArray<RuntimeSubagent> | null;
+}): AgentPanelModel;
+/**
+ * Members ordered by urgency for the capped inline workflow card: running and
+ * failed first, then waiting, then most recently updated.
+ */
+declare function workflowCardMembers(group: AgentPanelWorkflowGroup, limit: number): {
+  readonly visible: ReadonlyArray<RuntimeSubagent>;
+  readonly overflow: number;
+};
+/** Kinds the timeline should not render as generic rows (fold input only). */
+declare function isSubagentActivityKind(kind: string): boolean;
+/**
+ * Quiet-timeline guarantee: tool rows attributed to an owning agent belong in
+ * the Agents surface, not the parent chat. Unattributed rows must stay.
+ */
+declare function isAgentAttributedToolActivity(activity: OrchestrationThreadActivity): boolean;
+/** Timeline-bypassing synthesized rows (Codex children, workflow members). */
+declare function isTimelineBypassActivity(activity: OrchestrationThreadActivity): boolean;
+/**
+ * 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".
+ */
+declare function formatSubagentModelLabel(model: string | null, effort: string | null): string | null;
+declare function formatSubagentTokenCount(totalTokens: number): string;
+//#endregion
+export { AgentPanelModel, AgentPanelWorkflowGroup, RuntimeSubagent, RuntimeSubagentStatus, SubagentActivityEntry, SubagentRunHandles, SubagentUsage, SubagentWorkflowPhase, deriveAgentPanelModel, emptyAgentPanelModel, foldSubagentActivities, formatSubagentModelLabel, formatSubagentTokenCount, isActiveSubagentStatus, isAgentAttributedToolActivity, isBackgroundTaskActivity, isSubagentActivityKind, isTerminalSubagentStatus, isTimelineBypassActivity, workflowCardMembers };