@pellux/goodvibes-sdk 0.18.14 → 0.18.15

package/dist/_internal/platform/runtime/store/state.d.ts

@@ -0,0 +1,77 @@
+/**
+ * RuntimeState — the canonical top-level state shape for the GoodVibes
+ * runtime store. All domain slices are defined here.
+ *
+ * Each domain includes revision, lastUpdatedAt, and source metadata fields.
+ * These are defined per-domain in the domain files.
+ */
+import type { SessionDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/session';
+import type { ModelDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/model';
+import type { ConversationDomainState } from './domains/conversation.js';
+import type { OverlayDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/overlays';
+import type { PanelDomainState } from './domains/panels.js';
+import type { PermissionDomainState } from './domains/permissions.js';
+import type { TaskDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/tasks';
+import type { AgentDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/agents';
+import type { OrchestrationDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/orchestration';
+import type { CommunicationDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/communication';
+import type { ProviderHealthDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/provider-health';
+import type { McpDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/mcp';
+import type { PluginDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/plugins';
+import type { DaemonDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/daemon';
+import type { AutomationDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/automation';
+import type { AcpDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/acp';
+import type { RoutesDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/routes';
+import type { ControlPlaneDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/control-plane';
+import type { DeliveryDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/deliveries';
+import type { WatcherDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/watchers';
+import type { SurfaceDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/surfaces';
+import type { IntegrationDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/integrations';
+import type { TelemetryDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/telemetry';
+import type { GitDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/git';
+import type { DiscoveryDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/discovery';
+import type { IntelligenceDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/intelligence';
+import type { UiPerfDomainState } from './domains/ui-perf.js';
+/**
+ * RuntimeState — the complete state shape managed by the runtime store.
+ *
+ * Domain slices, each with revision/lastUpdatedAt/source metadata.
+ * All mutations must go through typed domain dispatch APIs.
+ */
+export interface RuntimeState {
+    session: SessionDomainState;
+    model: ModelDomainState;
+    conversation: ConversationDomainState;
+    overlays: OverlayDomainState;
+    panels: PanelDomainState;
+    permissions: PermissionDomainState;
+    tasks: TaskDomainState;
+    agents: AgentDomainState;
+    orchestration: OrchestrationDomainState;
+    communication: CommunicationDomainState;
+    providerHealth: ProviderHealthDomainState;
+    mcp: McpDomainState;
+    plugins: PluginDomainState;
+    daemon: DaemonDomainState;
+    automation: AutomationDomainState;
+    routes: RoutesDomainState;
+    controlPlane: ControlPlaneDomainState;
+    deliveries: DeliveryDomainState;
+    watchers: WatcherDomainState;
+    surfaces: SurfaceDomainState;
+    acp: AcpDomainState;
+    integrations: IntegrationDomainState;
+    telemetry: TelemetryDomainState;
+    git: GitDomainState;
+    discovery: DiscoveryDomainState;
+    intelligence: IntelligenceDomainState;
+    uiPerf: UiPerfDomainState;
+}
+/**
+ * Creates and returns a fully initialized RuntimeState with all domains
+ * set to their default initial values.
+ *
+ * This is the factory used by `createRuntimeStore()` and test harnesses.
+ */
+export declare function createInitialRuntimeState(): RuntimeState;
+//# sourceMappingURL=state.d.ts.map

package/dist/_internal/platform/runtime/store/state.d.ts.map

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

package/dist/_internal/platform/runtime/store/state.js

@@ -0,0 +1,71 @@
+/**
+ * RuntimeState — the canonical top-level state shape for the GoodVibes
+ * runtime store. All domain slices are defined here.
+ *
+ * Each domain includes revision, lastUpdatedAt, and source metadata fields.
+ * These are defined per-domain in the domain files.
+ */
+import { createInitialSessionState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/session';
+import { createInitialModelState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/model';
+import { createInitialConversationState } from './domains/conversation.js';
+import { createInitialOverlaysState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/overlays';
+import { createInitialPanelsState } from './domains/panels.js';
+import { createInitialPermissionsState } from './domains/permissions.js';
+import { createInitialTasksState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/tasks';
+import { createInitialAgentsState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/agents';
+import { createInitialOrchestrationState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/orchestration';
+import { createInitialCommunicationState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/communication';
+import { createInitialProviderHealthState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/provider-health';
+import { createInitialMcpState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/mcp';
+import { createInitialPluginsState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/plugins';
+import { createInitialDaemonState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/daemon';
+import { createInitialAutomationState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/automation';
+import { createInitialAcpState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/acp';
+import { createInitialRoutesState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/routes';
+import { createInitialControlPlaneState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/control-plane';
+import { createInitialDeliveryState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/deliveries';
+import { createInitialWatcherState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/watchers';
+import { createInitialSurfaceState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/surfaces';
+import { createInitialIntegrationsState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/integrations';
+import { createInitialTelemetryState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/telemetry';
+import { createInitialGitState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/git';
+import { createInitialDiscoveryState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/discovery';
+import { createInitialIntelligenceState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/intelligence';
+import { createInitialUiPerfState } from './domains/ui-perf.js';
+/**
+ * Creates and returns a fully initialized RuntimeState with all domains
+ * set to their default initial values.
+ *
+ * This is the factory used by `createRuntimeStore()` and test harnesses.
+ */
+export function createInitialRuntimeState() {
+    return {
+        session: createInitialSessionState(),
+        model: createInitialModelState(),
+        conversation: createInitialConversationState(),
+        overlays: createInitialOverlaysState(),
+        panels: createInitialPanelsState(),
+        permissions: createInitialPermissionsState(),
+        tasks: createInitialTasksState(),
+        agents: createInitialAgentsState(),
+        orchestration: createInitialOrchestrationState(),
+        communication: createInitialCommunicationState(),
+        providerHealth: createInitialProviderHealthState(),
+        mcp: createInitialMcpState(),
+        plugins: createInitialPluginsState(),
+        daemon: createInitialDaemonState(),
+        automation: createInitialAutomationState(),
+        routes: createInitialRoutesState(),
+        controlPlane: createInitialControlPlaneState(),
+        deliveries: createInitialDeliveryState(),
+        watchers: createInitialWatcherState(),
+        surfaces: createInitialSurfaceState(),
+        acp: createInitialAcpState(),
+        integrations: createInitialIntegrationsState(),
+        telemetry: createInitialTelemetryState(),
+        git: createInitialGitState(),
+        discovery: createInitialDiscoveryState(),
+        intelligence: createInitialIntelligenceState(),
+        uiPerf: createInitialUiPerfState(),
+    };
+}

package/dist/_internal/platform/runtime/tasks/adapters/acp-adapter.d.ts

@@ -0,0 +1,65 @@
+/**
+ * AcpTaskAdapter — bridges ACP remote subagent tasks (managed by AcpManager)
+ * into the unified RuntimeTask registry.
+ *
+ * Each spawned ACP subagent gets a corresponding RuntimeTask of kind 'acp'.
+ * The adapter maps SubagentStatus strings to task lifecycle transitions.
+ */
+import type { RuntimeStore } from '../../store/index.js';
+import type { SubagentStatus } from '@pellux/goodvibes-sdk/platform/acp/protocol';
+import type { AcpManager } from '../../../acp/manager.js';
+/**
+ * Bridges ACP remote subagent tasks into the RuntimeTask registry.
+ *
+ * NOTE: This adapter writes directly to the Zustand store for performance,
+ * bypassing TaskManager. Lifecycle validation is the caller's responsibility.
+ * This is intentional — adapters are authoritative sources for their subsystem.
+ *
+ * @example
+ * ```ts
+ * const adapter = new AcpTaskAdapter(store);
+ * const taskId = adapter.wrapRemoteTask(acpId, 'Refactor auth module');
+ * adapter.handleRemoteUpdate(acpId, 'complete');
+ * ```
+ */
+export declare class AcpTaskAdapter {
+    private readonly _store;
+    /** Maps ACP remote ID → task ID. */
+    private readonly _remoteToTask;
+    /** Maps task ID → ACP remote ID. */
+    private readonly _taskToRemote;
+    private readonly _dispatch;
+    constructor(_store: RuntimeStore);
+    /**
+     * Wrap an ACP remote subagent task as a RuntimeTask.
+     *
+     * @param remoteId - The ACP subagent ID from AcpManager.spawn().
+     * @param title - Human-readable title for display in the task monitor.
+     * @returns The new task ID.
+     */
+    wrapRemoteTask(remoteId: string, title: string): string;
+    /**
+     * Handle an ACP status update and transition the task accordingly.
+     *
+     * @param remoteId - The ACP subagent ID.
+     * @param status - New status string (SubagentStatus).
+     */
+    handleRemoteUpdate(remoteId: string, status: SubagentStatus): void;
+    /**
+     * Cancel an ACP remote task by task ID.
+     * Cancels the underlying ACP connection via AcpManager and marks the task cancelled.
+     *
+     * @param taskId - The RuntimeTask ID to cancel.
+     * @param manager - The AcpManager instance to use for cancellation.
+     */
+    cancelRemote(taskId: string, manager?: AcpManager): void;
+    /**
+     * Reconcile adapter state with the current AcpManager snapshot.
+     *
+     * @param manager - The AcpManager whose active subagents to sync from.
+     */
+    sync(manager: AcpManager): void;
+    private _upsertTask;
+    private _transitionTask;
+}
+//# sourceMappingURL=acp-adapter.d.ts.map

package/dist/_internal/platform/runtime/tasks/adapters/acp-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"acp-adapter.d.ts","sourceRoot":"","sources":["../../../../../../src/_internal/platform/runtime/tasks/adapters/acp-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAkB,MAAM,sBAAsB,CAAC;AAEzE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6CAA6C,CAAC;AAClF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AA8B1D;;;;;;;;;;;;;GAaG;AACH,qBAAa,cAAc;IAQb,OAAO,CAAC,QAAQ,CAAC,MAAM;IAPnC,oCAAoC;IACpC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA6B;IAC3D,oCAAoC;IACpC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA6B;IAE3D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAiB;gBAEd,MAAM,EAAE,YAAY;IAMjD;;;;;;OAMG;IACH,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM;IA6BvD;;;;;OAKG;IACH,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,cAAc,GAAG,IAAI;IAmBlE;;;;;;OAMG;IACH,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG,IAAI;IAgBxD;;;;OAIG;IACH,IAAI,CAAC,OAAO,EAAE,UAAU,GAAG,IAAI;IA+B/B,OAAO,CAAC,WAAW;IAInB,OAAO,CAAC,eAAe;CAexB"}

package/dist/_internal/platform/runtime/tasks/adapters/acp-adapter.js

@@ -0,0 +1,176 @@
+/**
+ * AcpTaskAdapter — bridges ACP remote subagent tasks (managed by AcpManager)
+ * into the unified RuntimeTask registry.
+ *
+ * Each spawned ACP subagent gets a corresponding RuntimeTask of kind 'acp'.
+ * The adapter maps SubagentStatus strings to task lifecycle transitions.
+ */
+import { randomUUID } from 'node:crypto';
+import { createDomainDispatch } from '../../store/index.js';
+/**
+ * Maps an ACP SubagentStatus to a RuntimeTask lifecycle state.
+ *
+ * @param status - SubagentStatus from the ACP protocol.
+ * @returns Corresponding task lifecycle state.
+ */
+function mapAcpStatusToTask(status) {
+    switch (status) {
+        case 'running':
+            return 'running';
+        case 'complete':
+            return 'completed';
+        case 'error':
+            return 'failed';
+        case 'cancelled':
+            return 'cancelled';
+    }
+}
+/** Terminal ACP statuses. */
+const TERMINAL_ACP_STATUSES = new Set([
+    'complete',
+    'error',
+    'cancelled',
+]);
+/**
+ * Bridges ACP remote subagent tasks into the RuntimeTask registry.
+ *
+ * NOTE: This adapter writes directly to the Zustand store for performance,
+ * bypassing TaskManager. Lifecycle validation is the caller's responsibility.
+ * This is intentional — adapters are authoritative sources for their subsystem.
+ *
+ * @example
+ * ```ts
+ * const adapter = new AcpTaskAdapter(store);
+ * const taskId = adapter.wrapRemoteTask(acpId, 'Refactor auth module');
+ * adapter.handleRemoteUpdate(acpId, 'complete');
+ * ```
+ */
+export class AcpTaskAdapter {
+    _store;
+    /** Maps ACP remote ID → task ID. */
+    _remoteToTask = new Map();
+    /** Maps task ID → ACP remote ID. */
+    _taskToRemote = new Map();
+    _dispatch;
+    constructor(_store) {
+        this._store = _store;
+        this._dispatch = createDomainDispatch(_store);
+    }
+    // ── Core API ────────────────────────────────────────────────────────────────
+    /**
+     * Wrap an ACP remote subagent task as a RuntimeTask.
+     *
+     * @param remoteId - The ACP subagent ID from AcpManager.spawn().
+     * @param title - Human-readable title for display in the task monitor.
+     * @returns The new task ID.
+     */
+    wrapRemoteTask(remoteId, title) {
+        // Idempotent: return existing task ID if already wrapped
+        const existing = this._remoteToTask.get(remoteId);
+        if (existing !== undefined)
+            return existing;
+        const taskId = randomUUID();
+        const now = Date.now();
+        const task = {
+            id: taskId,
+            kind: 'acp',
+            title: title.length > 80 ? `${title.slice(0, 77)}...` : title,
+            description: title,
+            status: 'running',
+            owner: remoteId,
+            cancellable: true,
+            childTaskIds: [],
+            queuedAt: now,
+            startedAt: now,
+            correlationId: remoteId,
+        };
+        this._remoteToTask.set(remoteId, taskId);
+        this._taskToRemote.set(taskId, remoteId);
+        this._upsertTask(task);
+        return taskId;
+    }
+    /**
+     * Handle an ACP status update and transition the task accordingly.
+     *
+     * @param remoteId - The ACP subagent ID.
+     * @param status - New status string (SubagentStatus).
+     */
+    handleRemoteUpdate(remoteId, status) {
+        const taskId = this._remoteToTask.get(remoteId);
+        if (taskId === undefined)
+            return;
+        const acpStatus = status;
+        const taskStatus = mapAcpStatusToTask(acpStatus);
+        const isTerminal = TERMINAL_ACP_STATUSES.has(acpStatus);
+        this._transitionTask(taskId, taskStatus, {
+            isTerminal,
+            error: acpStatus === 'error' ? `ACP subagent ${remoteId} reported an error` : undefined,
+        });
+        if (isTerminal) {
+            this._remoteToTask.delete(remoteId);
+            this._taskToRemote.delete(taskId);
+        }
+    }
+    /**
+     * Cancel an ACP remote task by task ID.
+     * Cancels the underlying ACP connection via AcpManager and marks the task cancelled.
+     *
+     * @param taskId - The RuntimeTask ID to cancel.
+     * @param manager - The AcpManager instance to use for cancellation.
+     */
+    cancelRemote(taskId, manager) {
+        const remoteId = this._taskToRemote.get(taskId);
+        if (remoteId === undefined)
+            return;
+        if (manager) {
+            // Fire-and-forget cancellation; errors are non-fatal
+            void manager.cancel(remoteId).catch(() => {
+                // Non-fatal: process may have already exited
+            });
+        }
+        this._transitionTask(taskId, 'cancelled', { isTerminal: true });
+        this._remoteToTask.delete(remoteId);
+        this._taskToRemote.delete(taskId);
+    }
+    /**
+     * Reconcile adapter state with the current AcpManager snapshot.
+     *
+     * @param manager - The AcpManager whose active subagents to sync from.
+     */
+    sync(manager) {
+        const active = manager.getActive();
+        const liveIds = new Set(active.map((a) => a.id));
+        // Wrap newly discovered subagents
+        for (const subagent of active) {
+            if (!this._remoteToTask.has(subagent.id)) {
+                this.wrapRemoteTask(subagent.id, subagent.task);
+            }
+            // Sync status if non-running
+            if (subagent.status !== 'running') {
+                this.handleRemoteUpdate(subagent.id, subagent.status);
+            }
+        }
+        // Mark stale tracked subagents as cancelled
+        const staleRemoteIds = [];
+        for (const [remoteId] of this._remoteToTask.entries()) {
+            if (!liveIds.has(remoteId))
+                staleRemoteIds.push(remoteId);
+        }
+        for (const remoteId of staleRemoteIds) {
+            const taskId = this._remoteToTask.get(remoteId);
+            this._transitionTask(taskId, 'cancelled', { isTerminal: true });
+            this._remoteToTask.delete(remoteId);
+            this._taskToRemote.delete(taskId);
+        }
+    }
+    // ── Private helpers ─────────────────────────────────────────────────────────
+    _upsertTask(task) {
+        this._dispatch.syncRuntimeTask(task, 'acp-adapter');
+    }
+    _transitionTask(taskId, status, opts) {
+        this._dispatch.transitionRuntimeTask(taskId, status, {
+            endedAt: opts.isTerminal ? Date.now() : undefined,
+            error: opts.error,
+        }, 'acp-adapter');
+    }
+}

package/dist/_internal/platform/runtime/tasks/adapters/agent-adapter.d.ts

@@ -0,0 +1,68 @@
+/**
+ * AgentTaskAdapter — bridges agent sessions (AgentOrchestrator / WRFC agents)
+ * into the unified RuntimeTask registry.
+ *
+ * Each running agent gets a corresponding RuntimeTask of kind 'agent'. The
+ * adapter maps agent lifecycle state strings to task lifecycle transitions.
+ */
+import type { RuntimeStore } from '../../store/index.js';
+import type { AgentLifecycleState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/agents';
+/** Owner context for an agent task. */
+export interface AgentOwner {
+    /** Session ID that spawned this agent. */
+    sessionId: string;
+}
+/**
+ * Bridges agent sessions into the RuntimeTask registry.
+ *
+ * @example
+ * ```ts
+ * const adapter = new AgentTaskAdapter(store);
+ * const taskId = adapter.wrapAgent('agent_1', 'Fix the linting errors', { sessionId: 'sess_1' });
+ * adapter.handleAgentStateChange('agent_1', 'running');
+ * adapter.handleAgentStateChange('agent_1', 'completed');
+ * ```
+ */
+export declare class AgentTaskAdapter {
+    private readonly _store;
+    /** Maps agent ID → task ID. */
+    private readonly _agentToTask;
+    /** Maps task ID → agent ID. */
+    private readonly _taskToAgent;
+    private readonly _dispatch;
+    constructor(_store: RuntimeStore);
+    /**
+     * Wrap an agent session as a RuntimeTask.
+     *
+     * @param agentId - Unique agent ID from the agent system.
+     * @param task - Human-readable description of what the agent is doing.
+     * @param owner - Session that spawned this agent.
+     * @returns The new task ID.
+     */
+    wrapAgent(agentId: string, task: string, owner: AgentOwner): string;
+    /**
+     * Handle an agent lifecycle state change and transition the task accordingly.
+     *
+     * @param agentId - The agent whose state changed.
+     * @param state - New agent lifecycle state (AgentLifecycleState string).
+     */
+    handleAgentStateChange(agentId: string, state: AgentLifecycleState): void;
+    /**
+     * Cancel an agent task by task ID.
+     * Marks the task as cancelled in the store. The caller is responsible for
+     * actually stopping the agent session.
+     *
+     * @param taskId - The RuntimeTask ID to cancel.
+     */
+    cancelAgent(taskId: string): void;
+    /**
+     * Reconcile adapter state with an external agent registry snapshot.
+     *
+     * @param activeAgents - Current snapshot of active agents: agentId → task description.
+     * @param owner - Default owner context for auto-wrapped agents.
+     */
+    sync(activeAgents: ReadonlyMap<string, string>, owner?: AgentOwner): void;
+    private _upsertTask;
+    private _transitionTask;
+}
+//# sourceMappingURL=agent-adapter.d.ts.map

package/dist/_internal/platform/runtime/tasks/adapters/agent-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-adapter.d.ts","sourceRoot":"","sources":["../../../../../../src/_internal/platform/runtime/tasks/adapters/agent-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAkB,MAAM,sBAAsB,CAAC;AAEzE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6DAA6D,CAAC;AAEvG,uCAAuC;AACvC,MAAM,WAAW,UAAU;IACzB,0CAA0C;IAC1C,SAAS,EAAE,MAAM,CAAC;CACnB;AAkCD;;;;;;;;;;GAUG;AACH,qBAAa,gBAAgB;IAQf,OAAO,CAAC,QAAQ,CAAC,MAAM;IAPnC,+BAA+B;IAC/B,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA6B;IAC1D,+BAA+B;IAC/B,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA6B;IAE1D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAiB;gBAEd,MAAM,EAAE,YAAY;IAMjD;;;;;;;OAOG;IACH,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,MAAM;IA4BnE;;;;;OAKG;IACH,sBAAsB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,mBAAmB,GAAG,IAAI;IAmBzE;;;;;;OAMG;IACH,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IASjC;;;;;OAKG;IACH,IAAI,CAAC,YAAY,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,KAAK,GAAE,UAAoC,GAAG,IAAI;IAyBlG,OAAO,CAAC,WAAW;IAInB,OAAO,CAAC,eAAe;CAkBxB"}

package/dist/_internal/platform/runtime/tasks/adapters/agent-adapter.js

@@ -0,0 +1,174 @@
+/**
+ * AgentTaskAdapter — bridges agent sessions (AgentOrchestrator / WRFC agents)
+ * into the unified RuntimeTask registry.
+ *
+ * Each running agent gets a corresponding RuntimeTask of kind 'agent'. The
+ * adapter maps agent lifecycle state strings to task lifecycle transitions.
+ */
+import { randomUUID } from 'node:crypto';
+import { createDomainDispatch } from '../../store/index.js';
+/** Terminal agent lifecycle states that map to terminal task states. */
+const TERMINAL_STATES = new Set([
+    'completed',
+    'failed',
+    'cancelled',
+]);
+/** Active (non-terminal, non-queued) agent states that map to 'running'. */
+const RUNNING_STATES = new Set([
+    'running',
+    'awaiting_message',
+    'awaiting_tool',
+    'finalizing',
+]);
+/**
+ * Maps an agent lifecycle state string to a RuntimeTask lifecycle state.
+ *
+ * @param state - Agent lifecycle state from AgentLifecycleState.
+ * @returns Corresponding task lifecycle state.
+ */
+function mapAgentStateToTask(state) {
+    if (state === 'spawning')
+        return 'queued';
+    if (RUNNING_STATES.has(state))
+        return 'running';
+    if (state === 'completed')
+        return 'completed';
+    if (state === 'failed')
+        return 'failed';
+    if (state === 'cancelled')
+        return 'cancelled';
+    return 'running'; // fallback for unknown states
+}
+/**
+ * Bridges agent sessions into the RuntimeTask registry.
+ *
+ * @example
+ * ```ts
+ * const adapter = new AgentTaskAdapter(store);
+ * const taskId = adapter.wrapAgent('agent_1', 'Fix the linting errors', { sessionId: 'sess_1' });
+ * adapter.handleAgentStateChange('agent_1', 'running');
+ * adapter.handleAgentStateChange('agent_1', 'completed');
+ * ```
+ */
+export class AgentTaskAdapter {
+    _store;
+    /** Maps agent ID → task ID. */
+    _agentToTask = new Map();
+    /** Maps task ID → agent ID. */
+    _taskToAgent = new Map();
+    _dispatch;
+    constructor(_store) {
+        this._store = _store;
+        this._dispatch = createDomainDispatch(_store);
+    }
+    // ── Core API ────────────────────────────────────────────────────────────────
+    /**
+     * Wrap an agent session as a RuntimeTask.
+     *
+     * @param agentId - Unique agent ID from the agent system.
+     * @param task - Human-readable description of what the agent is doing.
+     * @param owner - Session that spawned this agent.
+     * @returns The new task ID.
+     */
+    wrapAgent(agentId, task, owner) {
+        // Idempotent: return existing task ID if already wrapped
+        const existing = this._agentToTask.get(agentId);
+        if (existing !== undefined)
+            return existing;
+        const taskId = randomUUID();
+        const now = Date.now();
+        const runtimeTask = {
+            id: taskId,
+            kind: 'agent',
+            title: task.length > 80 ? `${task.slice(0, 77)}...` : task,
+            description: task,
+            status: 'queued',
+            owner: agentId,
+            cancellable: true,
+            childTaskIds: [],
+            queuedAt: now,
+            correlationId: owner.sessionId,
+        };
+        this._agentToTask.set(agentId, taskId);
+        this._taskToAgent.set(taskId, agentId);
+        this._upsertTask(runtimeTask);
+        return taskId;
+    }
+    /**
+     * Handle an agent lifecycle state change and transition the task accordingly.
+     *
+     * @param agentId - The agent whose state changed.
+     * @param state - New agent lifecycle state (AgentLifecycleState string).
+     */
+    handleAgentStateChange(agentId, state) {
+        const taskId = this._agentToTask.get(agentId);
+        if (taskId === undefined)
+            return;
+        const agentState = state;
+        const taskStatus = mapAgentStateToTask(agentState);
+        this._transitionTask(taskId, taskStatus, {
+            isTerminal: TERMINAL_STATES.has(agentState),
+            error: agentState === 'failed' ? `Agent ${agentId} failed` : undefined,
+        });
+        // Clean up mappings once terminal
+        if (TERMINAL_STATES.has(agentState)) {
+            this._agentToTask.delete(agentId);
+            this._taskToAgent.delete(taskId);
+        }
+    }
+    /**
+     * Cancel an agent task by task ID.
+     * Marks the task as cancelled in the store. The caller is responsible for
+     * actually stopping the agent session.
+     *
+     * @param taskId - The RuntimeTask ID to cancel.
+     */
+    cancelAgent(taskId) {
+        const agentId = this._taskToAgent.get(taskId);
+        if (agentId === undefined)
+            return;
+        this._transitionTask(taskId, 'cancelled', { isTerminal: true });
+        this._agentToTask.delete(agentId);
+        this._taskToAgent.delete(taskId);
+    }
+    /**
+     * Reconcile adapter state with an external agent registry snapshot.
+     *
+     * @param activeAgents - Current snapshot of active agents: agentId → task description.
+     * @param owner - Default owner context for auto-wrapped agents.
+     */
+    sync(activeAgents, owner = { sessionId: 'system' }) {
+        const liveIds = new Set(activeAgents.keys());
+        // Wrap newly discovered agents
+        for (const [agentId, task] of activeAgents.entries()) {
+            if (!this._agentToTask.has(agentId)) {
+                this.wrapAgent(agentId, task, owner);
+            }
+        }
+        // Mark stale tracked agents as cancelled
+        const staleAgentIds = [];
+        for (const [agentId] of this._agentToTask.entries()) {
+            if (!liveIds.has(agentId))
+                staleAgentIds.push(agentId);
+        }
+        for (const agentId of staleAgentIds) {
+            const taskId = this._agentToTask.get(agentId);
+            this._transitionTask(taskId, 'cancelled', { isTerminal: true });
+            this._agentToTask.delete(agentId);
+            this._taskToAgent.delete(taskId);
+        }
+    }
+    // ── Private helpers ─────────────────────────────────────────────────────────
+    _upsertTask(task) {
+        this._dispatch.syncRuntimeTask(task, 'agent-adapter');
+    }
+    _transitionTask(taskId, status, opts) {
+        const current = this._store.getState().tasks.tasks.get(taskId);
+        const timestamp = Date.now();
+        this._dispatch.transitionRuntimeTask(taskId, status, {
+            startedAt: status === 'running' && current?.startedAt === undefined ? timestamp : current?.startedAt,
+            endedAt: opts.isTerminal ? timestamp : current?.endedAt,
+            error: opts.error,
+        }, 'agent-adapter');
+    }
+}

package/dist/_internal/platform/runtime/tasks/adapters/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Task adapter barrel — re-exports all subsystem-to-RuntimeTask bridge adapters.
+ *
+ * Each adapter converts a subsystem-specific task representation into the
+ * unified RuntimeTask model and handles lifecycle transitions.
+ */
+export { ProcessTaskAdapter } from './process-adapter.js';
+export type { ProcessOwner } from './process-adapter.js';
+export { AgentTaskAdapter } from './agent-adapter.js';
+export type { AgentOwner } from './agent-adapter.js';
+export { AcpTaskAdapter } from './acp-adapter.js';
+export { SchedulerTaskAdapter } from './scheduler-adapter.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/_internal/platform/runtime/tasks/adapters/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/_internal/platform/runtime/tasks/adapters/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,YAAY,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,YAAY,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC"}