@pellux/goodvibes-sdk 0.37.2 → 1.0.0

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

@@ -46,6 +46,19 @@ function extractErrorMessage(err) {
  * sessionId, timestamps, and source context.
  *
  * This is the authoritative event transport for runtime domain signaling.
+ *
+ * DISPATCH ORDERING GUARANTEE (contract — pinned by
+ * test/runtime-event-bus-dispatch-contract.test.ts): {@link emit} NEVER invokes
+ * a subscriber synchronously. Each matching handler is deferred to its own
+ * `queueMicrotask`, so emit() always returns to its caller — and the caller's
+ * remaining synchronous statements run — BEFORE any listener fires. A component
+ * may therefore emit an event from the MIDDLE of a state mutation without risk
+ * that a subscriber observes the half-applied state: by the time a listener
+ * runs, the mutating call has already completed and the state has settled. This
+ * asynchronous-dispatch ordering is load-bearing for event-ordering safety
+ * across the runtime (e.g. the orchestration zombie-reap path relies on
+ * listeners never seeing a mutation mid-flight) — do NOT replace queueMicrotask
+ * with synchronous invocation.
  */
 export class RuntimeEventBus {
     /** Per-event-type listener sets. Keyed by the exact event type string. */

package/dist/platform/runtime/feature-flags/flags.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"flags.d.ts","sourceRoot":"","sources":["../../../../src/platform/runtime/feature-flags/flags.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C;;;;GAIG;AACH,eAAO,MAAM,aAAa,EAAE,WAAW,EAyctC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,gBAAgB,EAAE,WAAW,CAAC,MAAM,EAAE,WAAW,CAE7D,CAAC"}
+{"version":3,"file":"flags.d.ts","sourceRoot":"","sources":["../../../../src/platform/runtime/feature-flags/flags.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C;;;;GAIG;AACH,eAAO,MAAM,aAAa,EAAE,WAAW,EAogBtC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,gBAAgB,EAAE,WAAW,CAAC,MAAM,EAAE,WAAW,CAE7D,CAAC"}

package/dist/platform/runtime/feature-flags/flags.js

@@ -190,6 +190,43 @@ export const FEATURE_FLAGS = [
         tier: 9,
         runtimeToggleable: true,
     },
+    {
+        id: 'agent-passive-knowledge-injection',
+        name: 'Agent Passive Knowledge Injection',
+        description: 'Enables per-turn re-retrieval of project-memory knowledge against the EVOLVING main-'
+            + 'session conversation (steers, new sub-topics), not just the frozen spawn-time task. '
+            + 'Re-runs retrieval only when a new user/steer message arrived this turn, applies a '
+            + 'relevance floor to filter filler, and holds the injected block to a hard token '
+            + 'budget (min ~800 tokens or 3% of the model context window) with a visible per-turn '
+            + 'record (candidates considered, ids injected, ids dropped for budget, token cost, '
+            + 'embeddings backend) stored on AgentRecord.turnInjections and the session transcript. '
+            + 'Default-on is safe specifically because the block is hard-budgeted and every turn '
+            + 'is honestly recorded, never silently eating context. Disable or set the budget to 0 '
+            + 'to revert to spawn-time-only injection (base system prompt byte-identical).',
+        defaultState: 'enabled',
+        tier: 9,
+        runtimeToggleable: true,
+    },
+    {
+        id: 'agent-passive-code-injection',
+        name: 'Agent Passive Code Injection',
+        description: 'Enables per-turn passive retrieval from the repo SOURCE-TREE CODE INDEX (CodeIndexStore) '
+            + 'alongside project-memory knowledge, sharing the SAME token budget and relevance floor. '
+            + 'When the query would benefit and the index is built, similarity-ranked code chunks are '
+            + 'injected as untrusted reference pointers, each recorded on the turn injection record with '
+            + 'source=code-index and its honest match label (semantic/lexical). Never injects from an '
+            + 'empty or provider-mismatched index, or from a hashed-only (no real semantic) provider — '
+            + 'the store exposes each of those and the turn record states which. '
+            + 'DEFAULT OFF (unlike agent-passive-knowledge-injection, which defaults on): code injection '
+            + 'is a newer, higher-variance signal than reviewed project memory — code chunks carry no '
+            + 'review/trust provenance and a weak similarity match can pull in a plausibly-worded but '
+            + 'wrong chunk — so this first landing is opt-in, earned on by the same hard-budget + '
+            + 'honest-record discipline before it becomes a default. Also respects the embedder’s '
+            + 'storage.codeIndexEnabled setting; disable either to revert to memory-only injection.',
+        defaultState: 'disabled',
+        tier: 9,
+        runtimeToggleable: true,
+    },
     {
         id: 'output-schema-fingerprint',
         name: 'Output Schema Fingerprints',
@@ -306,11 +343,29 @@ export const FEATURE_FLAGS = [
         runtimeToggleable: true,
     },
     {
+        // NOTE: control-plane-gateway is the ONE tier-10 flag that defaults ON (One-Platform
+        // Wave 1). A stock daemon (no config) must be able to stream companion chat over SSE;
+        // leaving this OFF made a fresh daemon return 503 on the live-stream path (the W1
+        // "stock daemon is dead" bug).
+        //
+        // HONEST SURFACE STATEMENT: flipping this default ON DOES expose surface — just not
+        // an UNAUTHENTICATED one. Concretely it turns on: (1) the auth-gated streaming surface
+        // — SSE `/api/control-plane/events`, the companion-chat `.../events` stream, and the WS
+        // control channel — every one of which returns 401 before any principal is resolved
+        // (daemon-sdk/control-routes.ts), and per-channel scopes are enforced on the fan-out
+        // (e.g. read:sessions on session-update); and (2) the inert pre-auth login shell — the
+        // handful of unauthenticated bootstrap endpoints that carry NO session/runtime data and
+        // exist only to establish auth. The default bind stays loopback and the 60/min + 5/min
+        // rate limiters are unchanged. It remains runtimeToggleable, so an operator who wants a
+        // request/response-only daemon can turn it back off via config
+        // (`flags: { 'control-plane-gateway': 'disabled' }`), which the manager honours over
+        // this default. Do NOT generalise this to the other tier-10 siblings (slack/discord/web
+        // surfaces, delivery-engine, etc.) — they stay OFF until individually validated.
         id: 'control-plane-gateway',
         name: 'Control-Plane Gateway',
         description: 'Enables the shared gateway/control-plane host that serves state snapshots, live streams, '
             + 'and authenticated automation control APIs to terminal hosts and remote clients.',
-        defaultState: 'disabled',
+        defaultState: 'enabled',
         tier: 10,
         runtimeToggleable: true,
     },

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

@@ -0,0 +1,56 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+import type { AgentRecord } from '../../../tools/agent/manager.js';
+import type { ProcessActivity, ProcessNode, ProcessState, ProcessUsage } from '../types.js';
+/** Chain node ids are namespaced to avoid colliding with agent/process ids. */
+export declare function chainNodeId(chainId: string): string;
+/** Subtask node ids are namespaced to avoid colliding with agent/process ids. */
+export declare function subtaskNodeId(subtaskId: string): string;
+/** Work-item node ids are namespaced to avoid colliding with agent/process ids (Wave 4, wo701). */
+export declare function workItemNodeId(workItemId: string): string;
+/**
+ * One activity side-table entry. Registry-owned; populated from the EXISTING
+ * runtime-bus 'agents' channel emitters (no new event contract).
+ */
+export interface AgentActivityEntry {
+    readonly state: Extract<ProcessState, 'thinking' | 'executing-tool' | 'streaming' | 'retrying' | 'queued' | 'done' | 'failed'>;
+    readonly activity?: ProcessActivity | undefined;
+    /** Epoch ms of the last observed bus event for this agent. */
+    readonly at: number;
+}
+/** Assembly context the agent adapter needs to derive state and edges. */
+export interface AgentAdapterContext {
+    readonly now: number;
+    readonly stalledThresholdMs: number;
+    /** Side-table entries keyed by agentId. Empty map when no runtimeBus was provided. */
+    readonly activity: ReadonlyMap<string, AgentActivityEntry>;
+    /** True when a runtimeBus feeds the side-table — gates the stalled derivation. */
+    readonly liveness: boolean;
+    /** Agent ids that have a pending shared approval (metadata.agentId match). */
+    readonly pendingApprovalAgentIds: ReadonlySet<string>;
+    /** Session ids that have a pending shared approval (sessionRef cross-match). */
+    readonly pendingApprovalSessionIds: ReadonlySet<string>;
+    /** agentId → bound sessionId (from the session broker, when available). */
+    readonly sessionIdByAgentId: ReadonlyMap<string, string>;
+    /** Raw WrfcChain ids present in this snapshot. */
+    readonly chainIds: ReadonlySet<string>;
+    /** Raw WrfcSubtask ids present in this snapshot. */
+    readonly subtaskIds: ReadonlySet<string>;
+    /** Raw orchestration-engine WorkItem ids present in this snapshot (Wave 4, wo701). */
+    readonly workItemIds: ReadonlySet<string>;
+    /** orchestrationNodeId → owning agentId, for parentNodeId edge resolution. */
+    readonly agentIdByOrchestrationNodeId: ReadonlyMap<string, string>;
+    /** All agent ids present in this snapshot. */
+    readonly agentIds: ReadonlySet<string>;
+    readonly priceUsage?: ((model: string | undefined, usage: ProcessUsage) => number | null) | undefined;
+    /**
+     * True when the registry was constructed with a `messageBus` dep — gates
+     * `steerable`. Without it, steering has no delivery mechanism, so every
+     * agent (even a live one) honestly reports steerable=false.
+     */
+    readonly messageBusPresent: boolean;
+}
+/** AgentRecord.usage + toolCallCount → ProcessUsage. */
+export declare function usageFromAgentRecord(record: AgentRecord): ProcessUsage | undefined;
+/** AgentRecord → ProcessNode. */
+export declare function adaptAgent(record: AgentRecord, ctx: AgentAdapterContext): ProcessNode;
+//# sourceMappingURL=agent.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../../../../src/platform/runtime/fleet/adapters/agent.ts"],"names":[],"mappings":"AAAA,qFAAqF;AAErF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,KAAK,EACV,eAAe,EACf,WAAW,EACX,YAAY,EACZ,YAAY,EACb,MAAM,aAAa,CAAC;AAErB,+EAA+E;AAC/E,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEnD;AAED,iFAAiF;AACjF,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED,mGAAmG;AACnG,wBAAgB,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,YAAY,EAAE,UAAU,GAAG,gBAAgB,GAAG,WAAW,GAAG,UAAU,GAAG,QAAQ,GAAG,MAAM,GAAG,QAAQ,CAAC,CAAC;IAC/H,QAAQ,CAAC,QAAQ,CAAC,EAAE,eAAe,GAAG,SAAS,CAAC;IAChD,8DAA8D;IAC9D,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACrB;AAED,0EAA0E;AAC1E,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,sFAAsF;IACtF,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;IAC3D,kFAAkF;IAClF,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,8EAA8E;IAC9E,QAAQ,CAAC,uBAAuB,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACtD,gFAAgF;IAChF,QAAQ,CAAC,yBAAyB,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACxD,2EAA2E;IAC3E,QAAQ,CAAC,kBAAkB,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzD,kDAAkD;IAClD,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACvC,oDAAoD;IACpD,QAAQ,CAAC,UAAU,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACzC,sFAAsF;IACtF,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC1C,8EAA8E;IAC9E,QAAQ,CAAC,4BAA4B,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnE,8CAA8C;IAC9C,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACvC,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,KAAK,EAAE,YAAY,KAAK,MAAM,GAAG,IAAI,CAAC,GAAG,SAAS,CAAC;IACtG;;;;OAIG;IACH,QAAQ,CAAC,iBAAiB,EAAE,OAAO,CAAC;CACrC;AAED,wDAAwD;AACxD,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,WAAW,GAAG,YAAY,GAAG,SAAS,CAYlF;AA8ED,iCAAiC;AACjC,wBAAgB,UAAU,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,EAAE,mBAAmB,GAAG,WAAW,CA6CrF"}

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

@@ -0,0 +1,143 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+/** Chain node ids are namespaced to avoid colliding with agent/process ids. */
+export function chainNodeId(chainId) {
+    return `chain:${chainId}`;
+}
+/** Subtask node ids are namespaced to avoid colliding with agent/process ids. */
+export function subtaskNodeId(subtaskId) {
+    return `subtask:${subtaskId}`;
+}
+/** Work-item node ids are namespaced to avoid colliding with agent/process ids (Wave 4, wo701). */
+export function workItemNodeId(workItemId) {
+    return `work-item:${workItemId}`;
+}
+/** AgentRecord.usage + toolCallCount → ProcessUsage. */
+export function usageFromAgentRecord(record) {
+    if (!record.usage)
+        return undefined;
+    return {
+        inputTokens: record.usage.inputTokens,
+        outputTokens: record.usage.outputTokens,
+        cacheReadTokens: record.usage.cacheReadTokens,
+        cacheWriteTokens: record.usage.cacheWriteTokens,
+        reasoningTokens: record.usage.reasoningTokens,
+        llmCallCount: record.usage.llmCallCount,
+        turnCount: record.usage.turnCount,
+        toolCallCount: record.toolCallCount,
+    };
+}
+/**
+ * parentId precedence (brief-mandated, Wave-4 stable):
+ * wrfcSubtaskId → `subtask:<id>` else wrfcId → `chain:<id>` else
+ * workItemId → `work-item:<id>` (Wave 4, wo701 — orchestration-engine phase
+ * agents, a separate track from WRFC so the two systems' agents are never
+ * conflated) else orchestrationNodeId/parentNodeId (resolved to the owning
+ * agent) else parentAgentId. Every step falls through when the referenced
+ * node is not present in this snapshot, so edges always resolve or the node
+ * is a root.
+ */
+function resolveParentId(record, ctx) {
+    if (record.wrfcSubtaskId && ctx.subtaskIds.has(record.wrfcSubtaskId)) {
+        return subtaskNodeId(record.wrfcSubtaskId);
+    }
+    if (record.wrfcId && ctx.chainIds.has(record.wrfcId)) {
+        return chainNodeId(record.wrfcId);
+    }
+    if (record.workItemId && ctx.workItemIds.has(record.workItemId)) {
+        return workItemNodeId(record.workItemId);
+    }
+    if (record.parentNodeId) {
+        const owner = ctx.agentIdByOrchestrationNodeId.get(record.parentNodeId);
+        if (owner && owner !== record.id && ctx.agentIds.has(owner))
+            return owner;
+    }
+    if (record.parentAgentId && ctx.agentIds.has(record.parentAgentId)) {
+        return record.parentAgentId;
+    }
+    return undefined;
+}
+function deriveAgentState(record, entry, sessionId, ctx) {
+    switch (record.status) {
+        case 'completed':
+            return 'done';
+        case 'failed':
+            return 'failed';
+        case 'cancelled':
+            // terminationKind distinguishes a graceful interrupt request from a hard
+            // kill for display purposes (Wave-3 verb formalization). Records
+            // persisted before this field existed have no terminationKind and
+            // default to 'killed' — the historical behavior.
+            return record.terminationKind === 'interrupt' ? 'interrupted' : 'killed';
+        case 'pending':
+            return 'queued';
+        case 'running':
+            break;
+    }
+    // running — fine-grained derivation.
+    if (ctx.pendingApprovalAgentIds.has(record.id) ||
+        (sessionId !== undefined && ctx.pendingApprovalSessionIds.has(sessionId))) {
+        return 'awaiting-approval';
+    }
+    // Stalled: only derivable when a bus feeds the side-table (headless runtimes
+    // degrade to the coarse state, never crash). Baseline is the last observed
+    // event, or startedAt when the agent predates the registry.
+    //
+    // executing-tool is exempt: AGENT_AWAITING_TOOL stamps activity.at once at
+    // tool start and no further 'agents' event fires until the tool returns, so
+    // a long-running tool call (build, test suite, bash) would otherwise be
+    // misread as silence and falsely flip a working agent to 'stalled'. Only
+    // thinking/streaming (and other non-tool) silence may stall.
+    if (ctx.liveness && entry?.state !== 'executing-tool') {
+        const lastActivityAt = entry?.at ?? record.startedAt;
+        if (ctx.now - lastActivityAt > ctx.stalledThresholdMs)
+            return 'stalled';
+    }
+    if (entry && entry.state !== 'done' && entry.state !== 'failed')
+        return entry.state;
+    return 'executing-tool';
+}
+/** AgentRecord → ProcessNode. */
+export function adaptAgent(record, ctx) {
+    const entry = ctx.activity.get(record.id);
+    const sessionId = ctx.sessionIdByAgentId.get(record.id);
+    const state = deriveAgentState(record, entry, sessionId, ctx);
+    const usage = usageFromAgentRecord(record);
+    const active = record.status === 'pending' || record.status === 'running';
+    let costUsd = null;
+    let costState = 'unpriced';
+    if (usage && ctx.priceUsage) {
+        let priced = null;
+        try {
+            priced = ctx.priceUsage(record.model, usage);
+        }
+        catch {
+            priced = null;
+        }
+        if (priced !== null) {
+            costUsd = priced;
+            costState = 'priced';
+        }
+    }
+    const label = record.wrfcRole ? `${record.template} (${record.wrfcRole})` : record.template;
+    const elapsedMs = Math.max(0, (record.completedAt ?? ctx.now) - record.startedAt);
+    return {
+        id: record.id,
+        kind: 'agent',
+        parentId: resolveParentId(record, ctx),
+        label,
+        task: record.task,
+        state,
+        startedAt: record.startedAt,
+        completedAt: record.completedAt,
+        elapsedMs,
+        usage,
+        model: record.model,
+        provider: record.provider,
+        costUsd,
+        costState,
+        currentActivity: entry?.activity,
+        capabilities: { interruptible: active, killable: active, pausable: false, resumable: false, steerable: active && ctx.messageBusPresent },
+        sessionRef: { sessionId, agentId: record.id },
+        raw: record,
+    };
+}

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

@@ -0,0 +1,30 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+import type { AutomationJob } from '../../../automation/jobs.js';
+import type { ProcessNode } from '../types.js';
+/**
+ * Automation-job node ids are namespaced separately from workflow-tool
+ * ScheduleEntry ids (adapters/schedule.ts's scheduleNodeId) — same kind
+ * ('schedule'), completely different id space (AutomationJob.id vs
+ * ScheduleEntry.name), so the two can never collide even though a user
+ * could name a workflow-tool schedule and an automation job identically.
+ */
+export declare function automationJobNodeId(jobId: string): string;
+/** The `raw` shape for an automation-job-sourced 'schedule' node — the source marker registry.ts's control dispatch switches on to route kill/interrupt/resume to AutomationManager instead of ScheduleManager. */
+export interface AutomationJobRaw {
+    readonly source: 'automation-manager';
+    readonly job: AutomationJob;
+}
+/** Type guard for AutomationJobRaw, used by registry.ts to distinguish an automation-job 'schedule' node's `raw` from a workflow-tool ScheduleEntry's `raw` — both share the 'schedule' kind. */
+export declare function isAutomationJobRaw(raw: unknown): raw is AutomationJobRaw;
+/**
+ * AutomationJob → ProcessNode (Wave 6, wo-F item d4). Reuses the 'schedule'
+ * kind rather than inventing a new one — a job created via `/schedule` IS a
+ * schedule from the user's viewpoint, even though it lives in a completely
+ * separate subsystem (platform/automation) from the workflow-tool's
+ * ScheduleManager (platform/tools/workflow) that adapters/schedule.ts
+ * already covers. `raw.source: 'automation-manager'` (AutomationJobRaw)
+ * distinguishes the origin so registry.ts's kill/interrupt/resume dispatch
+ * can route to the right manager.
+ */
+export declare function adaptAutomationJob(job: AutomationJob): ProcessNode;
+//# sourceMappingURL=automation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"automation.d.ts","sourceRoot":"","sources":["../../../../../src/platform/runtime/fleet/adapters/automation.ts"],"names":[],"mappings":"AAAA,qFAAqF;AAErF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED,mNAAmN;AACnN,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,MAAM,EAAE,oBAAoB,CAAC;IACtC,QAAQ,CAAC,GAAG,EAAE,aAAa,CAAC;CAC7B;AAED,iMAAiM;AACjM,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,gBAAgB,CAExE;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,aAAa,GAAG,WAAW,CAelE"}

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

@@ -0,0 +1,41 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+/**
+ * Automation-job node ids are namespaced separately from workflow-tool
+ * ScheduleEntry ids (adapters/schedule.ts's scheduleNodeId) — same kind
+ * ('schedule'), completely different id space (AutomationJob.id vs
+ * ScheduleEntry.name), so the two can never collide even though a user
+ * could name a workflow-tool schedule and an automation job identically.
+ */
+export function automationJobNodeId(jobId) {
+    return `automation-job:${jobId}`;
+}
+/** Type guard for AutomationJobRaw, used by registry.ts to distinguish an automation-job 'schedule' node's `raw` from a workflow-tool ScheduleEntry's `raw` — both share the 'schedule' kind. */
+export function isAutomationJobRaw(raw) {
+    return raw !== null && typeof raw === 'object' && raw.source === 'automation-manager';
+}
+/**
+ * AutomationJob → ProcessNode (Wave 6, wo-F item d4). Reuses the 'schedule'
+ * kind rather than inventing a new one — a job created via `/schedule` IS a
+ * schedule from the user's viewpoint, even though it lives in a completely
+ * separate subsystem (platform/automation) from the workflow-tool's
+ * ScheduleManager (platform/tools/workflow) that adapters/schedule.ts
+ * already covers. `raw.source: 'automation-manager'` (AutomationJobRaw)
+ * distinguishes the origin so registry.ts's kill/interrupt/resume dispatch
+ * can route to the right manager.
+ */
+export function adaptAutomationJob(job) {
+    return {
+        id: automationJobNodeId(job.id),
+        kind: 'schedule',
+        parentId: undefined,
+        label: job.name,
+        task: job.execution.prompt,
+        state: job.enabled ? 'idle' : 'paused',
+        startedAt: job.lastRunAt,
+        elapsedMs: 0,
+        costUsd: null,
+        costState: 'unpriced',
+        capabilities: { interruptible: false, killable: true, pausable: job.enabled, resumable: !job.enabled, steerable: false },
+        raw: { source: 'automation-manager', job },
+    };
+}

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

@@ -0,0 +1,12 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+import type { BackgroundProcess } from '../../../tools/shared/process-manager.js';
+import type { ProcessNode } from '../types.js';
+/** Last non-empty stdout line — already tracked on the record, no new emission needed. */
+export declare function lastOutputLine(stdout: readonly string[]): string | undefined;
+/**
+ * BackgroundProcess → ProcessNode. Silent source (no bus emission): liveness
+ * rides the registry tick; currentActivity is the last stdout line the
+ * ProcessManager already buffers.
+ */
+export declare function adaptBackgroundProcess(record: BackgroundProcess, now: number): ProcessNode;
+//# sourceMappingURL=background-process.d.ts.map

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,69 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+import type { Phase, WorkItem, WorkItemUsage, Workstream } from '../../../orchestration/types.js';
+import type { ProcessCostState, ProcessNode, ProcessUsage } from '../types.js';
+import { workItemNodeId } from './agent.js';
+/**
+ * Live in-flight usage of a work-item's currently-active agent, read from that
+ * agent's fleet node at snapshot time (DEBT-4 item 2). Overlaid onto the
+ * item's phase-boundary-committed `item.usage` so a RUNNING phase shows real,
+ * growing numbers instead of n/a until it completes.
+ */
+export interface LiveItemUsage {
+    readonly usage?: ProcessUsage | undefined;
+    readonly costUsd?: number | null | undefined;
+    readonly costState?: ProcessCostState | undefined;
+}
+/**
+ * The usage the fleet DISPLAYS for a work-item: its committed phase-boundary
+ * total, plus — only while it is actively 'in-phase' — the live in-flight
+ * usage of its current agent. The overlay is applied ONLY for an 'in-phase'
+ * item, which is exactly the window in which `item.usage` does NOT yet include
+ * the running phase (the engine folds that in at completion — see
+ * runItemPhase), so committed + live never double-counts and the two hand off
+ * atomically at the phase boundary. Because both operands only ever grow and
+ * merge through {@link mergeWorkItemUsage}, presence is MONOTONE: once usage
+ * has appeared for an item it never blinks back to n/a (DEBT-4 item 2).
+ */
+export declare function displayWorkItemUsage(item: WorkItem, live: LiveItemUsage | undefined): WorkItemUsage;
+/** 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. `opts.live` supplies the
+ * currently-active agent's in-flight usage so a running phase shows real,
+ * growing numbers instead of n/a until it completes (DEBT-4 item 2); omit it
+ * (or pass undefined) for the committed-only view.
+ */
+export declare function adaptWorkItem(item: WorkItem, workstreamId: string, parentId: string, opts: {
+    steerable: boolean;
+    live?: LiveItemUsage | undefined;
+}): 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 DISPLAY
+ * usage/cost (committed total + any live in-flight overlay, resolved once per
+ * item) exactly once — never through an intermediate phase bucket (see
+ * adaptPhase) — so this total can never double-count and never shows n/a while
+ * an item is actively producing usage (DEBT-4 item 2). `liveByItemId` supplies
+ * the active agents' in-flight usage keyed by item id; omit it for the
+ * committed-only view.
+ */
+export declare function adaptWorkstream(workstream: Workstream, now: number, liveByItemId?: ReadonlyMap<string, LiveItemUsage>): 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,OAAO,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAClG,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAgB,YAAY,EAAE,MAAM,aAAa,CAAC;AAC7F,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAE5C;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,KAAK,CAAC,EAAE,YAAY,GAAG,SAAS,CAAC;IAC1C,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAC7C,QAAQ,CAAC,SAAS,CAAC,EAAE,gBAAgB,GAAG,SAAS,CAAC;CACnD;AA2CD;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,aAAa,GAAG,SAAS,GAAG,aAAa,CAOnG;AAED,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;AA0GD;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE;IAAE,SAAS,EAAE,OAAO,CAAC;IAAC,IAAI,CAAC,EAAE,aAAa,GAAG,SAAS,CAAA;CAAE,GAAG,WAAW,CAqDjK;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,UAAU,GAAG,WAAW,CAuB5E;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,GAAG,WAAW,CAgCnI"}