@pellux/goodvibes-sdk 0.37.1 → 0.38.0

package/dist/platform/runtime/fleet/adapters/background-process.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"background-process.d.ts","sourceRoot":"","sources":["../../../../../src/platform/runtime/fleet/adapters/background-process.ts"],"names":[],"mappings":"AAAA,qFAAqF;AAErF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0CAA0C,CAAC;AAClF,OAAO,KAAK,EAAE,WAAW,EAAgB,MAAM,aAAa,CAAC;AAE7D,0FAA0F;AAC1F,wBAAgB,cAAc,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,GAAG,SAAS,CAU5E;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,iBAAiB,EAAE,GAAG,EAAE,MAAM,GAAG,WAAW,CAuB1F"}

package/dist/platform/runtime/fleet/adapters/background-process.js

@@ -0,0 +1,46 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+/** Last non-empty stdout line — already tracked on the record, no new emission needed. */
+export function lastOutputLine(stdout) {
+    // stdout is an array of chunks; join a bounded tail and take the last
+    // non-empty line so the scan stays cheap even for chatty processes.
+    const tail = stdout.slice(-8).join('');
+    const lines = tail.split('\n');
+    for (let i = lines.length - 1; i >= 0; i--) {
+        const line = lines[i]?.trim();
+        if (line)
+            return line;
+    }
+    return undefined;
+}
+/**
+ * BackgroundProcess → ProcessNode. Silent source (no bus emission): liveness
+ * rides the registry tick; currentActivity is the last stdout line the
+ * ProcessManager already buffers.
+ */
+export function adaptBackgroundProcess(record, now) {
+    let state;
+    if (!record.done)
+        state = 'executing-tool';
+    else if (record.exitCode !== null && record.exitCode !== 0)
+        state = 'failed';
+    else
+        state = 'done';
+    const line = lastOutputLine(record.stdout);
+    return {
+        id: record.id,
+        kind: 'background-process',
+        parentId: undefined,
+        label: record.cmd,
+        state,
+        startedAt: record.startTime,
+        completedAt: record.completedAt,
+        elapsedMs: Math.max(0, (record.completedAt ?? now) - record.startTime),
+        costUsd: null,
+        costState: 'unpriced',
+        // Silent source: anchored to a stable timestamp (chunk arrival times are
+        // not tracked), so an unchanged line never looks like fresh activity.
+        currentActivity: line ? { kind: 'output-line', text: line, at: record.completedAt ?? record.startTime } : undefined,
+        capabilities: { interruptible: false, killable: !record.done, pausable: false, resumable: false, steerable: false },
+        raw: record,
+    };
+}

package/dist/platform/runtime/fleet/adapters/code-index.d.ts

@@ -0,0 +1,21 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+import type { CodeIndexBuildProgress, CodeIndexStats } from '../../../state/code-index-store.js';
+import type { ProcessNode } from '../types.js';
+/** Narrow view of CodeIndexStore the fleet needs — Pick<CodeIndexStore, ...>, same pattern as the other adapter deps. */
+export interface CodeIndexProcessSource {
+    isBuilding(): boolean;
+    buildProgress(): CodeIndexBuildProgress | null;
+    buildStartedAt(): number | null;
+    stats(): CodeIndexStats;
+}
+/** Single well-known id: one code index per working directory (no per-workspace fan-out in Stage A). */
+export declare function codeIndexNodeId(): string;
+/**
+ * CodeIndexStore → ProcessNode. Silent source (no bus emission, like
+ * background-process): liveness rides the registry tick. An index build has
+ * no pid, so it is NOT a 'background-process' node (ProcessManager is
+ * shell/OS-process-only) — it gets its own ProcessKind, mirroring the
+ * Wave-4 orchestrationEngine-dep precedent.
+ */
+export declare function adaptCodeIndex(service: CodeIndexProcessSource, now: number): ProcessNode;
+//# sourceMappingURL=code-index.d.ts.map

package/dist/platform/runtime/fleet/adapters/code-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-index.d.ts","sourceRoot":"","sources":["../../../../../src/platform/runtime/fleet/adapters/code-index.ts"],"names":[],"mappings":"AAAA,qFAAqF;AAErF,OAAO,KAAK,EAAE,sBAAsB,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AACjG,OAAO,KAAK,EAAE,WAAW,EAAgB,MAAM,aAAa,CAAC;AAE7D,yHAAyH;AACzH,MAAM,WAAW,sBAAsB;IACrC,UAAU,IAAI,OAAO,CAAC;IACtB,aAAa,IAAI,sBAAsB,GAAG,IAAI,CAAC;IAC/C,cAAc,IAAI,MAAM,GAAG,IAAI,CAAC;IAChC,KAAK,IAAI,cAAc,CAAC;CACzB;AAED,wGAAwG;AACxG,wBAAgB,eAAe,IAAI,MAAM,CAExC;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,sBAAsB,EAAE,GAAG,EAAE,MAAM,GAAG,WAAW,CAkCxF"}

package/dist/platform/runtime/fleet/adapters/code-index.js

@@ -0,0 +1,44 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+/** Single well-known id: one code index per working directory (no per-workspace fan-out in Stage A). */
+export function codeIndexNodeId() {
+    return 'code-index:main';
+}
+/**
+ * CodeIndexStore → ProcessNode. Silent source (no bus emission, like
+ * background-process): liveness rides the registry tick. An index build has
+ * no pid, so it is NOT a 'background-process' node (ProcessManager is
+ * shell/OS-process-only) — it gets its own ProcessKind, mirroring the
+ * Wave-4 orchestrationEngine-dep precedent.
+ */
+export function adaptCodeIndex(service, now) {
+    const building = service.isBuilding();
+    const progress = service.buildProgress();
+    const startedAt = service.buildStartedAt();
+    const stats = service.stats();
+    const lastBuild = stats.lastBuild;
+    const state = building ? 'executing-tool' : lastBuild ? 'done' : 'idle';
+    const label = building
+        ? progress
+            ? `Code index: building ${progress.scanned}/${progress.total} files`
+            : 'Code index: building'
+        : lastBuild
+            ? `Code index: ${stats.indexedFiles} files, ${stats.indexedChunks} chunks`
+            : 'Code index: idle';
+    return {
+        id: codeIndexNodeId(),
+        kind: 'code-index',
+        parentId: undefined,
+        label,
+        state,
+        startedAt: building ? (startedAt ?? undefined) : (lastBuild?.startedAt ?? undefined),
+        completedAt: building ? undefined : (lastBuild?.completedAt ?? undefined),
+        elapsedMs: building ? Math.max(0, now - (startedAt ?? now)) : Math.max(0, lastBuild?.durationMs ?? 0),
+        costUsd: null,
+        costState: 'unpriced',
+        currentActivity: building
+            ? { kind: 'phase', text: progress ? `Indexing ${progress.scanned}/${progress.total}` : 'Indexing', at: now }
+            : undefined,
+        capabilities: { interruptible: false, killable: false, pausable: false, resumable: false, steerable: false },
+        raw: stats,
+    };
+}

package/dist/platform/runtime/fleet/adapters/orchestration.d.ts

@@ -0,0 +1,47 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+/**
+ * Orchestration-engine fleet adapters (Wave 4, wo701) — Workstream/Phase/
+ * WorkItem -> ProcessNode, mirroring adapters/wrfc.ts's chain/subtask
+ * pattern: a workstream is a root node (no native cancel of its own, so kill
+ * is DERIVED — cascades AgentManager.cancel over every agent any item ever
+ * spawned, same shape as adaptChain/cancelAgents), a phase is a pure grouping
+ * node (no lifecycle, no usage — same "report nothing" choice adaptSubtask
+ * makes, since attributing a work-item's CUMULATIVE usage to whichever phase
+ * it currently sits in would double-count across phases), and a work-item is
+ * the WRFC-subtask analogue: it delegates interrupt/kill/steer to its
+ * current live agent when it has one.
+ */
+import type { Phase, WorkItem, Workstream } from '../../../orchestration/types.js';
+import type { ProcessNode } from '../types.js';
+import { workItemNodeId } from './agent.js';
+/** Workstream node ids are namespaced to avoid colliding with agent/process ids. */
+export declare function workstreamNodeId(workstreamId: string): string;
+/**
+ * Phase node ids are namespaced by their owning workstream — phase ids are
+ * only unique WITHIN a workstream, so two workstreams' phases must not
+ * collide in the flat node list.
+ */
+export declare function phaseNodeId(workstreamId: string, phaseId: string): string;
+export { workItemNodeId };
+/** The work-item's currently-active agent, i.e. the one driving its live phase run. Undefined once terminal or between phases. */
+export declare function activeWorkItemAgentId(item: WorkItem): string | undefined;
+/** WorkItem -> ProcessNode. Delegates interruptible/killable/steerable to its currently-active agent, mirroring adaptSubtask. */
+export declare function adaptWorkItem(item: WorkItem, workstreamId: string, parentId: string, opts: {
+    steerable: boolean;
+}): ProcessNode;
+/**
+ * Phase -> ProcessNode. Deliberately reports NO usage/cost (mirrors
+ * adaptSubtask's "report nothing" choice): a work-item's usage is cumulative
+ * across every phase it has visited, so attributing it to whichever phase it
+ * currently occupies would double-count against both the phase and the
+ * workstream total. Real numbers live on the workstream (sums every item
+ * exactly once) and the work-item (its own direct total) — never on phase.
+ */
+export declare function adaptPhase(phase: Phase, workstream: Workstream): ProcessNode;
+/**
+ * Workstream -> ProcessNode. Root node (no parentId). Sums every item's
+ * usage/cost exactly once (never through an intermediate phase bucket — see
+ * adaptPhase) so this total can never double-count.
+ */
+export declare function adaptWorkstream(workstream: Workstream, now: number): ProcessNode;
+//# sourceMappingURL=orchestration.d.ts.map

package/dist/platform/runtime/fleet/adapters/orchestration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestration.d.ts","sourceRoot":"","sources":["../../../../../src/platform/runtime/fleet/adapters/orchestration.ts"],"names":[],"mappings":"AAAA,qFAAqF;AAErF;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AACnF,OAAO,KAAK,EAAE,WAAW,EAA8B,MAAM,aAAa,CAAC;AAC3E,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAE5C,oFAAoF;AACpF,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAE7D;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAEzE;AAED,OAAO,EAAE,cAAc,EAAE,CAAC;AAI1B,kIAAkI;AAClI,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,SAAS,CAExE;AA6FD,iIAAiI;AACjI,wBAAgB,aAAa,CAAC,IAAI,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE;IAAE,SAAS,EAAE,OAAO,CAAA;CAAE,GAAG,WAAW,CA6C/H;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,UAAU,GAAG,WAAW,CAuB5E;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,GAAG,WAAW,CA+BhF"}

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

@@ -0,0 +1,225 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+import { workItemNodeId } from './agent.js';
+/** Workstream node ids are namespaced to avoid colliding with agent/process ids. */
+export function workstreamNodeId(workstreamId) {
+    return `workstream:${workstreamId}`;
+}
+/**
+ * Phase node ids are namespaced by their owning workstream — phase ids are
+ * only unique WITHIN a workstream, so two workstreams' phases must not
+ * collide in the flat node list.
+ */
+export function phaseNodeId(workstreamId, phaseId) {
+    return `phase:${workstreamId}:${phaseId}`;
+}
+export { workItemNodeId };
+const TERMINAL_ITEM_STATES = new Set(['passed', 'failed']);
+/** The work-item's currently-active agent, i.e. the one driving its live phase run. Undefined once terminal or between phases. */
+export function activeWorkItemAgentId(item) {
+    return item.state === 'in-phase' ? item.agentId : undefined;
+}
+function workItemState(item) {
+    switch (item.state) {
+        case 'passed':
+            return 'done';
+        case 'failed':
+            return 'failed';
+        case 'pending':
+        case 'awaiting-capacity':
+            return 'queued';
+        case 'blocked-budget':
+            // Honest "stuck, not progressing" signal reusing an existing state
+            // rather than adding a new one (charter: prefer existing-contract
+            // reuse). Distinct from 'queued': a queued item WILL be claimed by
+            // free capacity; a blocked-budget item will not until its workstream's
+            // ceiling rises (or is cleared) via OrchestrationEngine.updateBudget —
+            // computeClaims (scheduler.ts) keeps it in the waiting set so that
+            // reconsideration is automatic the instant the ceiling changes, but a
+            // fixed ceiling on its own never lifts the block (usage only grows).
+            return 'stalled';
+        case 'in-phase':
+            return 'executing-tool';
+    }
+}
+function workstreamState(workstream) {
+    if (workstream.items.length === 0)
+        return 'idle';
+    if (workstream.items.some((item) => item.state === 'in-phase'))
+        return 'executing-tool';
+    if (workstream.items.some((item) => item.state === 'pending' || item.state === 'awaiting-capacity'))
+        return 'queued';
+    if (workstream.items.some((item) => item.state === 'blocked-budget'))
+        return 'stalled';
+    return workstream.items.some((item) => item.state === 'failed') ? 'failed' : 'done';
+}
+function phaseState(workstream, phase) {
+    const occupants = workstream.items.filter((item) => item.currentPhaseId === phase.id && item.state === 'in-phase');
+    if (occupants.length > 0)
+        return 'executing-tool';
+    const everVisited = workstream.items.some((item) => (item.visits.get(phase.id) ?? 0) > 0);
+    if (!everVisited)
+        return 'idle';
+    const allTerminal = workstream.items.every((item) => TERMINAL_ITEM_STATES.has(item.state));
+    return allTerminal ? 'done' : 'idle';
+}
+/** token-count-only rollup over a workstream's items (cost handled separately — see aggregateWorkItemCost). */
+function sumWorkItemUsage(items) {
+    if (items.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 item of items) {
+        const usage = item.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,
+    };
+}
+/** Honest cost rollup: all-priced -> 'priced'; none -> null/'unpriced'; mixed -> summed subset, 'estimated'. Mirrors adapters/wrfc.ts aggregateCost. */
+function aggregateWorkItemCost(items) {
+    const withUsage = items.filter((item) => item.usage.costState !== 'unpriced' || item.usage.inputTokens > 0 || item.usage.outputTokens > 0);
+    if (withUsage.length === 0)
+        return { costUsd: null, costState: 'unpriced' };
+    const priced = withUsage.filter((item) => item.usage.costState === 'priced' && item.usage.costUsd !== null);
+    if (priced.length === 0)
+        return { costUsd: null, costState: 'unpriced' };
+    const total = priced.reduce((sum, item) => sum + item.usage.costUsd, 0);
+    return { costUsd: total, costState: priced.length === withUsage.length ? 'priced' : 'estimated' };
+}
+/** WorkItem -> ProcessNode. Delegates interruptible/killable/steerable to its currently-active agent, mirroring adaptSubtask. */
+export function adaptWorkItem(item, workstreamId, parentId, opts) {
+    const state = workItemState(item);
+    const killable = !TERMINAL_ITEM_STATES.has(item.state);
+    const activeAgentId = activeWorkItemAgentId(item);
+    return {
+        id: workItemNodeId(item.id),
+        kind: 'work-item',
+        parentId,
+        label: item.title,
+        task: item.task,
+        state,
+        startedAt: item.createdAt,
+        completedAt: item.completedAt,
+        elapsedMs: Math.max(0, (item.completedAt ?? Date.now()) - item.createdAt),
+        usage: item.usage.inputTokens > 0 || item.usage.outputTokens > 0
+            ? {
+                inputTokens: item.usage.inputTokens,
+                outputTokens: item.usage.outputTokens,
+                cacheReadTokens: item.usage.cacheReadTokens,
+                cacheWriteTokens: item.usage.cacheWriteTokens,
+                reasoningTokens: item.usage.reasoningTokens,
+                llmCallCount: item.usage.llmCallCount,
+                turnCount: item.usage.turnCount,
+                toolCallCount: item.usage.toolCallCount,
+            }
+            : undefined,
+        costUsd: item.usage.costUsd,
+        costState: item.usage.costState,
+        // Blocked-budget items surface their reason (set/cleared by the engine
+        // alongside the state transition, types.ts WorkItem.blockedReason) in
+        // place of the bare phase id — the phase id alone doesn't tell an
+        // operator WHY the item stopped moving.
+        currentActivity: item.currentPhaseId
+            ? { kind: 'phase', text: item.state === 'blocked-budget' && item.blockedReason ? item.blockedReason : item.currentPhaseId, at: item.createdAt }
+            : undefined,
+        capabilities: {
+            interruptible: activeAgentId !== undefined,
+            killable,
+            pausable: false,
+            resumable: false,
+            steerable: activeAgentId !== undefined && opts.steerable,
+        },
+        sessionRef: activeAgentId ? { agentId: activeAgentId } : undefined,
+        raw: { item, workstreamId },
+    };
+}
+/**
+ * Phase -> ProcessNode. Deliberately reports NO usage/cost (mirrors
+ * adaptSubtask's "report nothing" choice): a work-item's usage is cumulative
+ * across every phase it has visited, so attributing it to whichever phase it
+ * currently occupies would double-count against both the phase and the
+ * workstream total. Real numbers live on the workstream (sums every item
+ * exactly once) and the work-item (its own direct total) — never on phase.
+ */
+export function adaptPhase(phase, workstream) {
+    const state = phaseState(workstream, phase);
+    return {
+        id: phaseNodeId(workstream.id, phase.id),
+        kind: 'phase',
+        parentId: workstreamNodeId(workstream.id),
+        label: `${phase.kind} (${phase.role})`,
+        state,
+        startedAt: workstream.createdAt,
+        completedAt: state === 'done' ? workstream.items.reduce((latest, item) => (item.completedAt !== undefined && (latest === undefined || item.completedAt > latest) ? item.completedAt : latest), undefined) : undefined,
+        elapsedMs: 0,
+        usage: undefined,
+        costUsd: null,
+        costState: 'unpriced',
+        currentActivity: undefined,
+        // Pure grouping node: no conversation loop, no native single-phase
+        // cancel (killing work belongs to the work-items running IN the phase).
+        capabilities: { interruptible: false, killable: false, pausable: false, resumable: false, steerable: false },
+        raw: phase,
+    };
+}
+/**
+ * Workstream -> ProcessNode. Root node (no parentId). Sums every item's
+ * usage/cost exactly once (never through an intermediate phase bucket — see
+ * adaptPhase) so this total can never double-count.
+ */
+export function adaptWorkstream(workstream, now) {
+    const state = workstreamState(workstream);
+    const killable = state !== 'done' && state !== 'failed';
+    const completedAt = (state === 'done' || state === 'failed')
+        ? workstream.items.reduce((latest, item) => (item.completedAt !== undefined && (latest === undefined || item.completedAt > latest) ? item.completedAt : latest), undefined)
+        : undefined;
+    const { costUsd, costState } = aggregateWorkItemCost(workstream.items);
+    return {
+        id: workstreamNodeId(workstream.id),
+        kind: 'workstream',
+        parentId: undefined,
+        label: workstream.title,
+        state,
+        startedAt: workstream.createdAt,
+        completedAt,
+        elapsedMs: Math.max(0, (completedAt ?? now) - workstream.createdAt),
+        usage: sumWorkItemUsage(workstream.items),
+        costUsd,
+        costState,
+        currentActivity: undefined,
+        // A workstream is an FSM coordinating work-items, not itself a
+        // conversation loop — steer a work-item instead (mirrors wrfc-chain).
+        // Kill is DERIVED (no native single-call cancel): cascades
+        // AgentManager.cancel over every agent any item ever spawned — see
+        // registry.ts killNode's 'workstream' case.
+        capabilities: { interruptible: false, killable, pausable: false, resumable: false, steerable: false },
+        raw: workstream,
+    };
+}

package/dist/platform/runtime/fleet/adapters/schedule.d.ts

@@ -0,0 +1,14 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+import type { ScheduleEntry } from '../../../tools/workflow/index.js';
+import type { ProcessNode } from '../types.js';
+/** Schedule node ids are namespaced: entries are keyed by user-chosen names. */
+export declare function scheduleNodeId(name: string): string;
+/**
+ * ScheduleEntry → ProcessNode. A schedule between runs is honestly 'idle'
+ * (not force-fit into an active state); disabled maps to 'paused' (Wave 6,
+ * wo-F item d2 — NOT 'killed': the entry still exists and ScheduleManager.
+ * enable() can re-arm it, so collapsing it into a terminal state was
+ * dishonest). resumable mirrors the inverse of pausable.
+ */
+export declare function adaptSchedule(entry: ScheduleEntry): ProcessNode;
+//# sourceMappingURL=schedule.d.ts.map

package/dist/platform/runtime/fleet/adapters/schedule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schedule.d.ts","sourceRoot":"","sources":["../../../../../src/platform/runtime/fleet/adapters/schedule.ts"],"names":[],"mappings":"AAAA,qFAAqF;AAErF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAC;AACtE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C,gFAAgF;AAChF,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEnD;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,aAAa,GAAG,WAAW,CAe/D"}

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

@@ -0,0 +1,28 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+/** Schedule node ids are namespaced: entries are keyed by user-chosen names. */
+export function scheduleNodeId(name) {
+    return `schedule:${name}`;
+}
+/**
+ * ScheduleEntry → ProcessNode. A schedule between runs is honestly 'idle'
+ * (not force-fit into an active state); disabled maps to 'paused' (Wave 6,
+ * wo-F item d2 — NOT 'killed': the entry still exists and ScheduleManager.
+ * enable() can re-arm it, so collapsing it into a terminal state was
+ * dishonest). resumable mirrors the inverse of pausable.
+ */
+export function adaptSchedule(entry) {
+    return {
+        id: scheduleNodeId(entry.name),
+        kind: 'schedule',
+        parentId: undefined,
+        label: `${entry.name} (${entry.interval})`,
+        task: entry.command,
+        state: entry.enabled ? 'idle' : 'paused',
+        startedAt: entry.lastRun,
+        elapsedMs: 0,
+        costUsd: null,
+        costState: 'unpriced',
+        capabilities: { interruptible: false, killable: true, pausable: entry.enabled, resumable: !entry.enabled, steerable: false },
+        raw: entry,
+    };
+}

package/dist/platform/runtime/fleet/adapters/trigger.d.ts

@@ -0,0 +1,12 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+import type { TriggerDefinition } from '../../../tools/workflow/index.js';
+import type { ProcessNode } from '../types.js';
+/**
+ * TriggerDefinition → ProcessNode. Triggers have no timestamps and no run
+ * state — enabled means armed ('idle'), disabled maps to 'paused' (Wave 6,
+ * wo-F item d2 — NOT 'killed': the definition still exists and
+ * TriggerManager.enable() can re-arm it). resumable mirrors the inverse of
+ * pausable.
+ */
+export declare function adaptTrigger(def: TriggerDefinition): ProcessNode;
+//# sourceMappingURL=trigger.d.ts.map

package/dist/platform/runtime/fleet/adapters/trigger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigger.d.ts","sourceRoot":"","sources":["../../../../../src/platform/runtime/fleet/adapters/trigger.ts"],"names":[],"mappings":"AAAA,qFAAqF;AAErF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AAC1E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,iBAAiB,GAAG,WAAW,CAahE"}

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

@@ -0,0 +1,22 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+/**
+ * TriggerDefinition → ProcessNode. Triggers have no timestamps and no run
+ * state — enabled means armed ('idle'), disabled maps to 'paused' (Wave 6,
+ * wo-F item d2 — NOT 'killed': the definition still exists and
+ * TriggerManager.enable() can re-arm it). resumable mirrors the inverse of
+ * pausable.
+ */
+export function adaptTrigger(def) {
+    return {
+        id: def.id,
+        kind: 'trigger',
+        parentId: undefined,
+        label: `on ${def.event} → ${def.action}`,
+        state: def.enabled ? 'idle' : 'paused',
+        elapsedMs: 0,
+        costUsd: null,
+        costState: 'unpriced',
+        capabilities: { interruptible: false, killable: true, pausable: def.enabled, resumable: !def.enabled, steerable: false },
+        raw: def,
+    };
+}

package/dist/platform/runtime/fleet/adapters/watcher.d.ts

@@ -0,0 +1,13 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+import type { WatcherRecord } from '../../store/domains/watchers.js';
+import type { ProcessNode } from '../types.js';
+/**
+ * WatcherRecord → ProcessNode. WatcherRegistry.list() already normalizes each
+ * record through its sourceStatusFor derivation (healthy/lagging/stale/
+ * failed), so the mapping here reads the post-derivation state:
+ * running → 'idle' (alive, armed between checks), starting → 'queued',
+ * degraded → 'stalled' (heartbeat lagging/stale is the watcher-shaped stall),
+ * failed → 'failed', stopped → 'killed'.
+ */
+export declare function adaptWatcher(record: WatcherRecord, now: number): ProcessNode;
+//# sourceMappingURL=watcher.d.ts.map

package/dist/platform/runtime/fleet/adapters/watcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watcher.d.ts","sourceRoot":"","sources":["../../../../../src/platform/runtime/fleet/adapters/watcher.ts"],"names":[],"mappings":"AAAA,qFAAqF;AAErF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AACrE,OAAO,KAAK,EAAE,WAAW,EAAgB,MAAM,aAAa,CAAC;AAE7D;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,EAAE,MAAM,GAAG,WAAW,CAqC5E"}

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

@@ -0,0 +1,47 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+/**
+ * WatcherRecord → ProcessNode. WatcherRegistry.list() already normalizes each
+ * record through its sourceStatusFor derivation (healthy/lagging/stale/
+ * failed), so the mapping here reads the post-derivation state:
+ * running → 'idle' (alive, armed between checks), starting → 'queued',
+ * degraded → 'stalled' (heartbeat lagging/stale is the watcher-shaped stall),
+ * failed → 'failed', stopped → 'killed'.
+ */
+export function adaptWatcher(record, now) {
+    let state;
+    switch (record.state) {
+        case 'running':
+            state = 'idle';
+            break;
+        case 'starting':
+            state = 'queued';
+            break;
+        case 'degraded':
+            state = 'stalled';
+            break;
+        case 'failed':
+            state = 'failed';
+            break;
+        case 'stopped':
+            state = 'killed';
+            break;
+    }
+    const alive = record.state === 'running' || record.state === 'starting' || record.state === 'degraded';
+    const statusText = record.degradedReason ?? record.sourceStatus;
+    return {
+        id: record.id,
+        kind: 'watcher',
+        parentId: undefined,
+        label: record.label,
+        state,
+        startedAt: record.source.createdAt,
+        elapsedMs: alive ? Math.max(0, now - record.source.createdAt) : 0,
+        costUsd: null,
+        costState: 'unpriced',
+        currentActivity: statusText
+            ? { kind: 'phase', text: statusText, at: record.lastHeartbeatAt ?? record.source.createdAt }
+            : undefined,
+        capabilities: { interruptible: false, killable: alive, pausable: false, resumable: false, steerable: false },
+        raw: record,
+    };
+}

package/dist/platform/runtime/fleet/adapters/workflow.d.ts

@@ -0,0 +1,11 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+import type { WorkflowInstance } from '../../../tools/workflow/index.js';
+import type { ProcessNode } from '../types.js';
+/**
+ * WorkflowInstance → ProcessNode. Workflow FSMs are a SILENT source (no bus
+ * emission); their liveness rides the registry's coalesced tick, and the
+ * manager self-evicts completed entries (1 h TTL / 50 cap) so terminal nodes
+ * eventually disappear from the snapshot.
+ */
+export declare function adaptWorkflow(instance: WorkflowInstance, now: number): ProcessNode;
+//# sourceMappingURL=workflow.d.ts.map

package/dist/platform/runtime/fleet/adapters/workflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.d.ts","sourceRoot":"","sources":["../../../../../src/platform/runtime/fleet/adapters/workflow.ts"],"names":[],"mappings":"AAAA,qFAAqF;AAErF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,KAAK,EAAE,WAAW,EAAgB,MAAM,aAAa,CAAC;AAE7D;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,gBAAgB,EAAE,GAAG,EAAE,MAAM,GAAG,WAAW,CAuBlF"}

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

@@ -0,0 +1,34 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+/**
+ * WorkflowInstance → ProcessNode. Workflow FSMs are a SILENT source (no bus
+ * emission); their liveness rides the registry's coalesced tick, and the
+ * manager self-evicts completed entries (1 h TTL / 50 cap) so terminal nodes
+ * eventually disappear from the snapshot.
+ */
+export function adaptWorkflow(instance, now) {
+    let state;
+    if (instance.cancelled)
+        state = 'killed';
+    else if (instance.completedAt !== undefined)
+        state = 'done';
+    else
+        state = 'executing-tool';
+    const active = state === 'executing-tool';
+    return {
+        id: instance.id,
+        kind: 'workflow',
+        parentId: undefined,
+        label: instance.definition,
+        task: instance.task,
+        state,
+        startedAt: instance.startedAt,
+        completedAt: instance.completedAt,
+        elapsedMs: Math.max(0, (instance.completedAt ?? now) - instance.startedAt),
+        costUsd: null,
+        costState: 'unpriced',
+        // Silent source: anchored to startedAt (no state-transition timestamp).
+        currentActivity: active ? { kind: 'phase', text: instance.currentState, at: instance.startedAt } : undefined,
+        capabilities: { interruptible: false, killable: active, pausable: false, resumable: false, steerable: false },
+        raw: instance,
+    };
+}

package/dist/platform/runtime/fleet/adapters/wrfc.d.ts

@@ -0,0 +1,22 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+import type { WrfcChain, WrfcSubtask } from '../../../agents/wrfc-types.js';
+import type { ProcessNode } from '../types.js';
+/**
+ * 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 declare function activeSubtaskMemberAgentId(subtask: WrfcSubtask): string | undefined;
+/** WrfcSubtask → ProcessNode (child of its chain node). */
+export declare function adaptSubtask(subtask: WrfcSubtask, chain: WrfcChain, opts: {
+    steerable: boolean;
+}): ProcessNode;
+/**
+ * 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 declare function adaptChain(chain: WrfcChain, memberNodes: readonly ProcessNode[], now: number): ProcessNode;
+//# sourceMappingURL=wrfc.d.ts.map

package/dist/platform/runtime/fleet/adapters/wrfc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrfc.d.ts","sourceRoot":"","sources":["../../../../../src/platform/runtime/fleet/adapters/wrfc.ts"],"names":[],"mappings":"AAAA,qFAAqF;AAErF,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,KAAK,EAAE,WAAW,EAA8B,MAAM,aAAa,CAAC;AAmJ3E;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,GAAG,SAAS,CAWnF;AAED,2DAA2D;AAC3D,wBAAgB,YAAY,CAAC,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE;IAAE,SAAS,EAAE,OAAO,CAAA;CAAE,GAAG,WAAW,CAwB9G;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,SAAS,WAAW,EAAE,EAAE,GAAG,EAAE,MAAM,GAAG,WAAW,CAgC1G"}