@pellux/goodvibes-sdk 0.37.1 → 0.38.0

package/dist/platform/runtime/fleet/adapters/wrfc.js

@@ -0,0 +1,228 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+import { chainNodeId, subtaskNodeId } from './agent.js';
+// 'interrupted' is included: it is only ever produced on an AGENT node
+// (deriveAgentState), never on a chain/subtask's own `state`, but a chain
+// member agent that was individually interrupted (not via chain cascade,
+// which always hard-kills — see registry.ts cancelAgents) must still count
+// as terminal here, or it would be misread as "live" below.
+const TERMINAL_STATES = new Set(['done', 'failed', 'killed', 'interrupted']);
+function chainState(chain, memberNodes) {
+    switch (chain.state) {
+        case 'passed':
+            return { state: 'done' };
+        case 'failed':
+            return { state: 'failed' };
+        case 'pending':
+            return { state: 'queued' };
+        case 'awaiting_gates':
+            return { state: 'idle', phase: chain.state };
+        default:
+            break;
+    }
+    // Active phase (engineering/integrating/reviewing/fixing/gating/committing).
+    // Retrying is DERIVED: a transport retry has been recorded and no member
+    // agent is currently live — i.e. the respawn window. Once the replacement
+    // agent runs, the chain shows its active phase again.
+    const retryCount = chain.transportRetryCount ?? 0;
+    const anyMemberLive = memberNodes.some((node) => !TERMINAL_STATES.has(node.state));
+    if (retryCount > 0 && !anyMemberLive) {
+        return { state: 'retrying', phase: chain.state };
+    }
+    // CONTROLLER-DRIVEN PHASES: 'gating' (running gate checks) and 'committing'
+    // (git commit/merge) are performed by WrfcController itself, never by a
+    // member agent — every phase-worker member has already finished its own
+    // work by the time the chain advances to either state. "Zero live members"
+    // is therefore the NORMAL condition here, not a symptom of a cascade kill,
+    // so these two states are excluded from the CHAIN TERMINAL TRUTH check
+    // below (enumerated from the WrfcState union in wrfc-types.ts — do not
+    // widen this to other active states, where a live member IS expected and
+    // its absence legitimately signals a kill).
+    const controllerDrivenWithNoLiveMembersByDesign = chain.state === 'gating' || chain.state === 'committing';
+    // CHAIN TERMINAL TRUTH: WrfcController has no cancel/abort of its own, so a
+    // cascade kill (registry.ts kill('chain:<id>')) only cancels the member
+    // agents — chain.state never leaves whatever active phase it was in when
+    // killed. Once every known member has reached a terminal state and it's
+    // NOT the transport-retry respawn window handled above, NOR one of the
+    // controller-driven phases handled above, the chain was terminated out
+    // from under its owner: report it terminal instead of a perpetually-running
+    // phase (the replay-found "climbing elapsed" leak). `phase` is preserved
+    // for display ("killed while engineering").
+    if (memberNodes.length > 0 && !anyMemberLive && !controllerDrivenWithNoLiveMembersByDesign) {
+        return { state: 'killed', phase: chain.state };
+    }
+    return { state: 'executing-tool', phase: chain.state };
+}
+/**
+ * Synthetic completedAt for a chain whose terminal state was DERIVED (see
+ * chainState above) rather than reported by WrfcController — cascade kill
+ * never sets `chain.completedAt`. Freezing to the latest member completedAt
+ * (rather than `now`) is what stops elapsedMs from climbing after a kill;
+ * every member here is terminal (chainState's caller only reaches this when
+ * `state === 'killed'`), and every terminal agent node has a completedAt
+ * (set atomically with its terminal status — see agent.ts / manager.ts
+ * cancel()), so the max is always defined when memberNodes is non-empty.
+ */
+function syntheticChainCompletedAt(memberNodes) {
+    let latest;
+    for (const node of memberNodes) {
+        if (node.completedAt === undefined)
+            continue;
+        if (latest === undefined || node.completedAt > latest)
+            latest = node.completedAt;
+    }
+    return latest;
+}
+function subtaskState(subtask) {
+    switch (subtask.state) {
+        case 'pending':
+            return { state: 'queued' };
+        case 'passed':
+            return { state: 'done' };
+        case 'failed':
+            return { state: 'failed' };
+        default:
+            return { state: 'executing-tool', phase: subtask.state };
+    }
+}
+function sumUsage(nodes) {
+    const contributors = nodes.filter((node) => node.usage !== undefined);
+    if (contributors.length === 0)
+        return undefined;
+    const total = {
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0,
+        reasoningTokens: 0,
+        llmCallCount: 0,
+        turnCount: 0,
+        toolCallCount: 0,
+    };
+    let sawReasoning = false;
+    for (const node of contributors) {
+        const usage = node.usage;
+        total.inputTokens += usage.inputTokens;
+        total.outputTokens += usage.outputTokens;
+        total.cacheReadTokens += usage.cacheReadTokens;
+        total.cacheWriteTokens += usage.cacheWriteTokens;
+        if (usage.reasoningTokens !== undefined) {
+            sawReasoning = true;
+            total.reasoningTokens += usage.reasoningTokens;
+        }
+        total.llmCallCount += usage.llmCallCount;
+        total.turnCount += usage.turnCount;
+        total.toolCallCount += usage.toolCallCount;
+    }
+    return {
+        inputTokens: total.inputTokens,
+        outputTokens: total.outputTokens,
+        cacheReadTokens: total.cacheReadTokens,
+        cacheWriteTokens: total.cacheWriteTokens,
+        reasoningTokens: sawReasoning ? total.reasoningTokens : undefined,
+        llmCallCount: total.llmCallCount,
+        turnCount: total.turnCount,
+        toolCallCount: total.toolCallCount,
+    };
+}
+/**
+ * Aggregate member-agent cost onto the chain, honestly:
+ * all contributors priced → 'priced'; none priced → null/'unpriced';
+ * mixed → sum of the priced subset, flagged 'estimated'.
+ *
+ * The owner agent is EXCLUDED from aggregation: it runs no LLM turns itself —
+ * its AgentRecord.usage is populated FROM the phase children at completion
+ * time (Wave-0/1), so including it would double-count.
+ */
+function aggregateCost(members) {
+    const withUsage = members.filter((node) => node.usage !== undefined);
+    if (withUsage.length === 0)
+        return { costUsd: null, costState: 'unpriced' };
+    const priced = withUsage.filter((node) => node.costState === 'priced' && typeof node.costUsd === 'number');
+    if (priced.length === 0)
+        return { costUsd: null, costState: 'unpriced' };
+    const total = priced.reduce((sum, node) => sum + node.costUsd, 0);
+    return { costUsd: total, costState: priced.length === withUsage.length ? 'priced' : 'estimated' };
+}
+/**
+ * The subtask's currently-active member agent, i.e. whichever role is
+ * driving its current phase. Undefined when the subtask has no phase
+ * currently in flight (pending/passed/failed) — matches subtaskState()'s
+ * own phase mapping above.
+ */
+export function activeSubtaskMemberAgentId(subtask) {
+    switch (subtask.state) {
+        case 'engineering':
+            return subtask.engineerAgentId;
+        case 'reviewing':
+            return subtask.reviewerAgentId;
+        case 'fixing':
+            return subtask.fixerAgentId;
+        default:
+            return undefined;
+    }
+}
+/** WrfcSubtask → ProcessNode (child of its chain node). */
+export function adaptSubtask(subtask, chain, opts) {
+    const { state, phase } = subtaskState(subtask);
+    const killable = state !== 'done' && state !== 'failed' && state !== 'killed';
+    return {
+        id: subtaskNodeId(subtask.id),
+        kind: 'wrfc-subtask',
+        parentId: chainNodeId(chain.id),
+        label: subtask.title,
+        task: subtask.task,
+        state,
+        startedAt: undefined,
+        completedAt: undefined,
+        elapsedMs: 0,
+        usage: undefined,
+        costUsd: null,
+        costState: 'unpriced',
+        // Silent source: no phase-transition timestamp exists, so anchor to the
+        // chain's creation time to keep the activity stable across queries.
+        currentActivity: phase ? { kind: 'phase', text: phase, at: chain.createdAt } : undefined,
+        // Steer targets the live member agent driving this subtask's current
+        // phase, NOT the subtask node itself (which has no conversation loop).
+        capabilities: { interruptible: false, killable, pausable: false, resumable: false, steerable: opts.steerable },
+        raw: subtask,
+    };
+}
+/**
+ * WrfcChain → ProcessNode. `memberNodes` are the already-adapted agent nodes
+ * whose ids appear in chain.allAgentIds, EXCLUDING the owner agent (see
+ * aggregateCost). Chain nodes are roots (the owner agent hangs under the
+ * chain via its wrfcId edge, not the other way around).
+ */
+export function adaptChain(chain, memberNodes, now) {
+    const { state, phase } = chainState(chain, memberNodes);
+    const { costUsd, costState } = aggregateCost(memberNodes);
+    const killable = state !== 'done' && state !== 'failed' && state !== 'killed';
+    // chain.completedAt is authoritative when WrfcController set it (the
+    // 'passed'/'failed' clean-terminal cases). `state === 'killed'` is only
+    // ever reached via chainState's DERIVED branch (WrfcController never
+    // literally sets chain.state to 'killed'), so falling back to the
+    // synthetic max(member.completedAt) there — instead of `now` — is what
+    // freezes elapsedMs once the chain is recognized as killed.
+    const completedAt = chain.completedAt ?? (state === 'killed' ? syntheticChainCompletedAt(memberNodes) : undefined);
+    return {
+        id: chainNodeId(chain.id),
+        kind: 'wrfc-chain',
+        parentId: undefined,
+        label: `wrfc ${chain.id}`,
+        task: chain.task,
+        state,
+        startedAt: chain.createdAt,
+        completedAt,
+        elapsedMs: Math.max(0, (completedAt ?? now) - chain.createdAt),
+        usage: sumUsage(memberNodes),
+        costUsd,
+        costState,
+        // Silent source: anchored to createdAt (no phase-transition timestamp).
+        currentActivity: phase ? { kind: 'phase', text: phase, at: chain.createdAt } : undefined,
+        // A wrfc-chain is an FSM coordinating member agents; it has no
+        // conversation loop of its own, so it is NEVER steerable — steer the
+        // member subtask instead (adaptSubtask, above).
+        capabilities: { interruptible: false, killable, pausable: false, resumable: false, steerable: false },
+        raw: chain,
+    };
+}

package/dist/platform/runtime/fleet/index.d.ts

@@ -0,0 +1,10 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+export type { ProcessKind, ProcessState, ProcessUsage, ProcessActivity, ProcessCapabilities, ProcessSessionRef, ProcessCostState, ProcessNode, FleetSnapshot, FleetQueryFilter, ProcessKillOptions, ProcessRegistry, SteerResult, } from './types.js';
+export type { ProcessRegistryDeps, RegistryTimers } from './registry.js';
+export { createProcessRegistry, DEFAULT_STALLED_THRESHOLD_MS, DEFAULT_TICK_INTERVAL_MS, STEER_TTL_MS, } from './registry.js';
+export { chainNodeId, subtaskNodeId, workItemNodeId } from './adapters/agent.js';
+export { scheduleNodeId } from './adapters/schedule.js';
+export { workstreamNodeId, phaseNodeId } from './adapters/orchestration.js';
+export { codeIndexNodeId } from './adapters/code-index.js';
+export type { CodeIndexProcessSource } from './adapters/code-index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/platform/runtime/fleet/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/platform/runtime/fleet/index.ts"],"names":[],"mappings":"AAAA,qFAAqF;AAKrF,YAAY,EACV,WAAW,EACX,YAAY,EACZ,YAAY,EACZ,eAAe,EACf,mBAAmB,EACnB,iBAAiB,EACjB,gBAAgB,EAChB,WAAW,EACX,aAAa,EACb,gBAAgB,EAChB,kBAAkB,EAClB,eAAe,EACf,WAAW,GACZ,MAAM,YAAY,CAAC;AACpB,YAAY,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AACzE,OAAO,EACL,qBAAqB,EACrB,4BAA4B,EAC5B,wBAAwB,EACxB,YAAY,GACb,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACjF,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAC5E,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,YAAY,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC"}

package/dist/platform/runtime/fleet/index.js

@@ -0,0 +1,6 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+export { createProcessRegistry, DEFAULT_STALLED_THRESHOLD_MS, DEFAULT_TICK_INTERVAL_MS, STEER_TTL_MS, } from './registry.js';
+export { chainNodeId, subtaskNodeId, workItemNodeId } from './adapters/agent.js';
+export { scheduleNodeId } from './adapters/schedule.js';
+export { workstreamNodeId, phaseNodeId } from './adapters/orchestration.js';
+export { codeIndexNodeId } from './adapters/code-index.js';

package/dist/platform/runtime/fleet/registry.d.ts

@@ -0,0 +1,113 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+/**
+ * Live process registry (W2.1) — one queryable + subscribable aggregation
+ * surface over the already-composed runtime managers. ZERO new store state:
+ * every query is an aggregate-on-read over the managers' in-memory maps, and
+ * the only registry-owned mutable state is the agent activity side-table fed
+ * by EXISTING runtime-bus 'agents' events (no new event contract).
+ *
+ * Pattern precedent: platform/core/orchestrator-context-runtime.ts already
+ * aggregates agentManager.list() + wrfcController.listChains() into a
+ * read-only context; this module generalizes that into a durable registry.
+ */
+import type { AgentManager } from '../../tools/agent/manager.js';
+import type { WrfcController } from '../../agents/wrfc-controller.js';
+import type { ProcessManager } from '../../tools/shared/process-manager.js';
+import type { WatcherRegistry } from '../../watchers/registry.js';
+import type { ScheduleManager, TriggerManager, WorkflowManager } from '../../tools/workflow/index.js';
+import type { AutomationManager } from '../../automation/index.js';
+import type { ApprovalBroker } from '../../control-plane/approval-broker.js';
+import type { SharedSessionBroker } from '../../control-plane/session-broker.js';
+import type { AgentMessageBus } from '../../agents/message-bus.js';
+import type { RuntimeEventBus } from '../events/index.js';
+import type { ProcessRegistry, ProcessUsage } from './types.js';
+import type { CodeIndexProcessSource } from './adapters/code-index.js';
+import type { OrchestrationEngine } from '../../orchestration/engine.js';
+/** Default stalled threshold: running agent with no bus activity for this long → 'stalled'. */
+export declare const DEFAULT_STALLED_THRESHOLD_MS = 20000;
+/** Default coalesced tick interval for subscriber notification. */
+export declare const DEFAULT_TICK_INTERVAL_MS = 750;
+/**
+ * TTL for a steer message, deliberately much larger than
+ * AgentMessageBus's own DEFAULT_TTL_MS (5 min, message-bus-core.ts). A
+ * steer queued against an agent mid long-running tool call (build, test
+ * suite) must survive the wait for that tool to return rather than
+ * silently expiring before the agent reaches its next turn boundary.
+ */
+export declare const STEER_TTL_MS: number;
+/** Injectable timer seam so tests can drive/observe the coalesced tick. */
+export interface RegistryTimers {
+    setInterval(callback: () => void, intervalMs: number): unknown;
+    clearInterval(handle: unknown): void;
+}
+/**
+ * Narrow structural deps — a pick of each manager's read/control surface, NOT
+ * the whole RuntimeServices, so the registry stays testable with stubs and
+ * cannot participate in a construction cycle.
+ */
+export interface ProcessRegistryDeps {
+    readonly agentManager: Pick<AgentManager, 'list' | 'cancel'>;
+    readonly wrfcController: Pick<WrfcController, 'listChains'>;
+    /**
+     * Optional (Wave 4, wo701): folds workstream/phase/work-item nodes into
+     * the fleet, nested workstream -> phase -> work-item, mirroring the
+     * wrfc-chain/subtask nesting. Without this dep the registry degrades to
+     * exactly today's behavior — no orchestration nodes, no new capability.
+     *
+     * `kill` is used (not a raw AgentManager.cancel cascade like the wrfc-chain
+     * path) so a fleet-initiated kill goes through the SAME
+     * engine.kill(itemId) path as an engine-internal caller: it aborts the
+     * item's registered AbortController (reaching an in-flight exec/fetch
+     * tool's child process, not just the agent's next turn-boundary poll) AND
+     * updates the engine's own WorkItem.state bookkeeping. Bypassing it would
+     * silently reopen the orphaned-child-process gap for this one kill path.
+     */
+    readonly orchestrationEngine?: Pick<OrchestrationEngine, 'listWorkstreams' | 'kill'> | undefined;
+    readonly processManager: Pick<ProcessManager, 'list' | 'stop' | 'getStatus'>;
+    readonly watcherRegistry: Pick<WatcherRegistry, 'list' | 'stopWatcher'>;
+    readonly workflow: {
+        readonly workflowManager: Pick<WorkflowManager, 'list' | 'cancel'>;
+        /** `enable` (Wave 6, wo-F item d2) backs ProcessRegistry.resume() — the inverse of `disable`'s interrupt/pause. */
+        readonly triggerManager: Pick<TriggerManager, 'list' | 'remove' | 'disable' | 'enable'>;
+        readonly scheduleManager: Pick<ScheduleManager, 'list' | 'remove' | 'disable' | 'enable'>;
+    };
+    /** Optional: awaiting-approval derivation. Non-control-plane runtimes still build a fleet. */
+    readonly approvalBroker?: Pick<ApprovalBroker, 'listApprovals'> | undefined;
+    /** Optional: populates ProcessNode.sessionRef.sessionId (Wave-3 tab attach point). */
+    readonly sessionBroker?: Pick<SharedSessionBroker, 'listSessions'> | undefined;
+    /**
+     * Optional: the repo source-tree code index (Wave-5 wo802, W5.3 Stage A).
+     * When present, its build/idle state surfaces as a single 'code-index'
+     * ProcessNode. Without this dep the fleet degrades to exactly today's
+     * behavior — zero code-index nodes, no new capability.
+     */
+    readonly codeIndexService?: CodeIndexProcessSource | undefined;
+    /**
+     * Optional (Wave 6, wo-F item d4): folds `/schedule` automation jobs
+     * (platform/automation, a SEPARATE subsystem from the workflow-tool's
+     * ScheduleManager above) into the fleet as 'schedule'-kind nodes — see
+     * adapters/automation.ts. Without this dep the fleet degrades to exactly
+     * today's behavior — zero automation-job nodes, no new capability.
+     */
+    readonly automationManager?: Pick<AutomationManager, 'listJobs' | 'setEnabled' | 'removeJob'> | undefined;
+    /**
+     * Optional: backs `steer()` and the `steerable` capability (Wave-3). The
+     * bus already exists in the composed runtime and already feeds every
+     * in-process agent's per-turn inbox drain (orchestrator-runner.ts) — this
+     * just hands the registry a narrow `send`-only pick of it. Without this
+     * dep, steer() always refuses and steerable is false everywhere
+     * (graceful degrade, matches the approvalBroker/sessionBroker pattern).
+     */
+    readonly messageBus?: Pick<AgentMessageBus, 'send'> | undefined;
+    /** Optional: feeds the fine-grained agent activity side-table. Without it the registry degrades to coarse states. */
+    readonly runtimeBus?: RuntimeEventBus | undefined;
+    /** Optional: honest cost pricing. Return null when the model is unknown — NEVER fabricate. */
+    readonly priceUsage?: ((model: string | undefined, usage: ProcessUsage) => number | null) | undefined;
+    readonly now?: (() => number) | undefined;
+    readonly stalledThresholdMs?: number | undefined;
+    readonly tickIntervalMs?: number | undefined;
+    readonly timers?: RegistryTimers | undefined;
+}
+/** Create the live process registry over the already-composed managers. */
+export declare function createProcessRegistry(deps: ProcessRegistryDeps): ProcessRegistry;
+//# sourceMappingURL=registry.d.ts.map

package/dist/platform/runtime/fleet/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../../src/platform/runtime/fleet/registry.ts"],"names":[],"mappings":"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"}