@pellux/goodvibes-sdk 0.18.13 → 0.18.15

package/dist/_internal/platform/runtime/tasks/adapters/index.js

@@ -0,0 +1,10 @@
+/**
+ * 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 { AgentTaskAdapter } from './agent-adapter.js';
+export { AcpTaskAdapter } from './acp-adapter.js';
+export { SchedulerTaskAdapter } from './scheduler-adapter.js';

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

@@ -0,0 +1,82 @@
+/**
+ * ProcessTaskAdapter — bridges ProcessManager background processes into the
+ * unified RuntimeTask registry.
+ *
+ * Each spawned background process gets a corresponding RuntimeTask of kind
+ * 'exec'. The adapter tracks the pid→taskId mapping and reconciles state
+ * on demand via sync().
+ *
+ * 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.
+ */
+import type { RuntimeStore } from '../../store/index.js';
+import { ProcessManager } from '@pellux/goodvibes-sdk/platform/tools/shared/process-manager';
+/** Owner context supplied when wrapping a process. */
+export interface ProcessOwner {
+    /** Session ID that spawned this process. */
+    sessionId: string;
+    /** Optional agent ID that owns this process. */
+    agentId?: string;
+}
+/**
+ * Bridges ProcessManager background processes into the RuntimeTask registry.
+ *
+ * @example
+ * ```ts
+ * const adapter = new ProcessTaskAdapter(store);
+ * const taskId = adapter.wrapProcess(proc.pid, 'npm run build', { sessionId: 'sess_1' });
+ * // later...
+ * adapter.handleProcessExit(proc.pid, 0);
+ * ```
+ */
+export declare class ProcessTaskAdapter {
+    private readonly _store;
+    /** Maps process internal ID (bg_N_ts) → task ID. */
+    private readonly _idToTask;
+    /** Maps task ID → process internal ID. */
+    private readonly _taskToId;
+    /** Maps pid → process internal ID (for exit handling). */
+    private readonly _pidToId;
+    private readonly _manager;
+    private readonly _dispatch;
+    constructor(_store: RuntimeStore, manager: ProcessManager);
+    /**
+     * Wrap a spawned process as a RuntimeTask.
+     *
+     * @param processId - The ProcessManager internal ID (process_id from spawn result).
+     * @param pid - OS process ID.
+     * @param command - The shell command string for display.
+     * @param owner - Session/agent that owns this process.
+     * @returns The new task ID.
+     */
+    wrapProcess(processId: string, pid: number, command: string, owner: ProcessOwner): string;
+    /**
+     * Update task status when a process exits.
+     *
+     * @param pid - OS process ID that exited.
+     * @param exitCode - Process exit code (0 = success).
+     */
+    handleProcessExit(pid: number, exitCode: number): void;
+    /**
+     * Cancel a process task by task ID.
+     * Stops the underlying process via ProcessManager and marks the task cancelled.
+     *
+     * @param taskId - The RuntimeTask ID to cancel.
+     */
+    cancelProcess(taskId: string): void;
+    /**
+     * Reconcile adapter state with the RuntimeTask registry.
+     *
+     * Scans all ProcessManager processes:
+     * - Wraps any un-tracked processes as new tasks (with a fallback owner).
+     * - Marks completed (done) processes as completed or failed in the task store.
+     * - Removes task mappings for processes that have been cleaned up.
+     *
+     * @param defaultOwner - Owner context used when auto-wrapping unknown processes.
+     */
+    sync(defaultOwner?: ProcessOwner): void;
+    private _upsertTask;
+    private _transitionTask;
+}
+//# sourceMappingURL=process-adapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"process-adapter.d.ts","sourceRoot":"","sources":["../../../../../../src/_internal/platform/runtime/tasks/adapters/process-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAkB,MAAM,sBAAsB,CAAC;AAEzE,OAAO,EAAE,cAAc,EAAE,MAAM,6DAA6D,CAAC;AAE7F,sDAAsD;AACtD,MAAM,WAAW,YAAY;IAC3B,4CAA4C;IAC5C,SAAS,EAAE,MAAM,CAAC;IAClB,gDAAgD;IAChD,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;GAUG;AACH,qBAAa,kBAAkB;IAY3B,OAAO,CAAC,QAAQ,CAAC,MAAM;IAXzB,oDAAoD;IACpD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA6B;IACvD,0CAA0C;IAC1C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA6B;IACvD,0DAA0D;IAC1D,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA6B;IAEtD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAiB;IAC1C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAiB;gBAGxB,MAAM,EAAE,YAAY,EACrC,OAAO,EAAE,cAAc;IAQzB;;;;;;;;OAQG;IACH,WAAW,CACT,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,YAAY,GAClB,MAAM;IA+BT;;;;;OAKG;IACH,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAetD;;;;;OAKG;IACH,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAanC;;;;;;;;;OASG;IACH,IAAI,CAAC,YAAY,GAAE,YAAsC,GAAG,IAAI;IAuChE,OAAO,CAAC,WAAW;IAInB,OAAO,CAAC,eAAe;CAgBxB"}

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

@@ -0,0 +1,171 @@
+/**
+ * ProcessTaskAdapter — bridges ProcessManager background processes into the
+ * unified RuntimeTask registry.
+ *
+ * Each spawned background process gets a corresponding RuntimeTask of kind
+ * 'exec'. The adapter tracks the pid→taskId mapping and reconciles state
+ * on demand via sync().
+ *
+ * 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.
+ */
+import { randomUUID } from 'node:crypto';
+import { createDomainDispatch } from '../../store/index.js';
+import { ProcessManager } from '@pellux/goodvibes-sdk/platform/tools/shared/process-manager';
+/**
+ * Bridges ProcessManager background processes into the RuntimeTask registry.
+ *
+ * @example
+ * ```ts
+ * const adapter = new ProcessTaskAdapter(store);
+ * const taskId = adapter.wrapProcess(proc.pid, 'npm run build', { sessionId: 'sess_1' });
+ * // later...
+ * adapter.handleProcessExit(proc.pid, 0);
+ * ```
+ */
+export class ProcessTaskAdapter {
+    _store;
+    /** Maps process internal ID (bg_N_ts) → task ID. */
+    _idToTask = new Map();
+    /** Maps task ID → process internal ID. */
+    _taskToId = new Map();
+    /** Maps pid → process internal ID (for exit handling). */
+    _pidToId = new Map();
+    _manager;
+    _dispatch;
+    constructor(_store, manager) {
+        this._store = _store;
+        this._manager = manager;
+        this._dispatch = createDomainDispatch(_store);
+    }
+    // ── Core API ────────────────────────────────────────────────────────────────
+    /**
+     * Wrap a spawned process as a RuntimeTask.
+     *
+     * @param processId - The ProcessManager internal ID (process_id from spawn result).
+     * @param pid - OS process ID.
+     * @param command - The shell command string for display.
+     * @param owner - Session/agent that owns this process.
+     * @returns The new task ID.
+     */
+    wrapProcess(processId, pid, command, owner) {
+        // Idempotent: if already wrapped, return existing task ID
+        const existing = this._idToTask.get(processId);
+        if (existing !== undefined)
+            return existing;
+        const taskId = randomUUID();
+        const now = Date.now();
+        const task = {
+            id: taskId,
+            kind: 'exec',
+            title: command.length > 80 ? `${command.slice(0, 77)}...` : command,
+            description: command,
+            status: 'running',
+            owner: owner.agentId ?? owner.sessionId,
+            cancellable: true,
+            childTaskIds: [],
+            queuedAt: now,
+            startedAt: now,
+            correlationId: owner.sessionId,
+            turnId: owner.agentId,
+        };
+        this._idToTask.set(processId, taskId);
+        this._taskToId.set(taskId, processId);
+        this._pidToId.set(pid, processId);
+        this._upsertTask(task);
+        return taskId;
+    }
+    /**
+     * Update task status when a process exits.
+     *
+     * @param pid - OS process ID that exited.
+     * @param exitCode - Process exit code (0 = success).
+     */
+    handleProcessExit(pid, exitCode) {
+        const processId = this._pidToId.get(pid);
+        if (processId === undefined)
+            return;
+        const taskId = this._idToTask.get(processId);
+        if (taskId === undefined)
+            return;
+        this._pidToId.delete(pid);
+        this._transitionTask(taskId, exitCode === 0 ? 'completed' : 'failed', {
+            exitCode,
+            error: exitCode !== 0 ? `Process exited with code ${exitCode}` : undefined,
+        });
+    }
+    /**
+     * Cancel a process task by task ID.
+     * Stops the underlying process via ProcessManager and marks the task cancelled.
+     *
+     * @param taskId - The RuntimeTask ID to cancel.
+     */
+    cancelProcess(taskId) {
+        const processId = this._taskToId.get(taskId);
+        if (processId === undefined)
+            return;
+        // Look up the pid before stopping so we can clean up _pidToId
+        const entry = this._manager.getStatus(processId);
+        this._manager.stop(processId);
+        if (entry !== undefined) {
+            this._pidToId.delete(entry.pid);
+        }
+        this._transitionTask(taskId, 'cancelled', {});
+    }
+    /**
+     * Reconcile adapter state with the RuntimeTask registry.
+     *
+     * Scans all ProcessManager processes:
+     * - Wraps any un-tracked processes as new tasks (with a fallback owner).
+     * - Marks completed (done) processes as completed or failed in the task store.
+     * - Removes task mappings for processes that have been cleaned up.
+     *
+     * @param defaultOwner - Owner context used when auto-wrapping unknown processes.
+     */
+    sync(defaultOwner = { sessionId: 'system' }) {
+        const liveProcesses = this._manager.list();
+        const liveIds = new Set(liveProcesses.map((p) => p.id));
+        // Handle processes not yet tracked
+        for (const proc of liveProcesses) {
+            if (!this._idToTask.has(proc.id)) {
+                // Use the real pid from list() for accurate _pidToId tracking
+                this.wrapProcess(proc.id, proc.pid, proc.cmd, defaultOwner);
+            }
+            // Check if the process has finished
+            const entry = this._manager.getStatus(proc.id);
+            if (entry?.done) {
+                const taskId = this._idToTask.get(proc.id);
+                if (taskId !== undefined) {
+                    const exitCode = entry.exitCode ?? 1;
+                    this._transitionTask(taskId, exitCode === 0 ? 'completed' : 'failed', {
+                        exitCode,
+                        error: exitCode !== 0 ? `Process exited with code ${exitCode}` : undefined,
+                    });
+                }
+            }
+        }
+        // Clean up stale mappings for processes no longer tracked by the manager
+        const staleProcessIds = [];
+        for (const [processId] of this._idToTask.entries()) {
+            if (!liveIds.has(processId))
+                staleProcessIds.push(processId);
+        }
+        for (const processId of staleProcessIds) {
+            const taskId = this._idToTask.get(processId);
+            this._idToTask.delete(processId);
+            this._taskToId.delete(taskId);
+        }
+    }
+    // ── Private helpers ─────────────────────────────────────────────────────────
+    _upsertTask(task) {
+        this._dispatch.syncRuntimeTask(task, 'process-adapter');
+    }
+    _transitionTask(taskId, status, extras) {
+        this._dispatch.transitionRuntimeTask(taskId, status, {
+            endedAt: Date.now(),
+            exitCode: extras.exitCode,
+            error: extras.error,
+        }, 'process-adapter');
+    }
+}

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

@@ -0,0 +1,76 @@
+/**
+ * SchedulerTaskAdapter — bridges TaskScheduler scheduled job executions into
+ * the unified RuntimeTask registry.
+ *
+ * Each time a scheduled task fires (i.e. TaskRunRecord is created), a
+ * corresponding RuntimeTask of kind 'scheduler' is registered. The adapter
+ * tracks runRecord agentId → task ID and handles completion via state sync.
+ *
+ * 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.
+ */
+import type { RuntimeStore } from '../../store/index.js';
+import type { TaskScheduler, ScheduledTask, TaskRunRecord } from '@pellux/goodvibes-sdk/platform/scheduler/scheduler';
+/**
+ * Bridges TaskScheduler job executions into the RuntimeTask registry.
+ *
+ * The scheduler runs jobs that spawn agent sessions. Each run is tracked as a
+ * RuntimeTask of kind 'scheduler'. The run's agentId is used as the correlation
+ * key between the scheduler's TaskRunRecord and the RuntimeTask.
+ *
+ * @example
+ * ```ts
+ * const adapter = new SchedulerTaskAdapter(store);
+ * // When a scheduled task fires:
+ * const taskId = adapter.wrapScheduledRun(record, scheduledTask);
+ * // When the run completes:
+ * adapter.handleRunComplete(record.agentId, 'completed');
+ * ```
+ */
+export declare class SchedulerTaskAdapter {
+    private readonly _store;
+    /** Maps run agentId → task ID. */
+    private readonly _runToTask;
+    /** Maps task ID → run agentId. */
+    private readonly _taskToRun;
+    private readonly _dispatch;
+    constructor(_store: RuntimeStore);
+    /**
+     * Wrap a scheduled task run as a RuntimeTask.
+     *
+     * @param record - The TaskRunRecord from the scheduler.
+     * @param scheduledTask - The parent ScheduledTask definition.
+     * @returns The new task ID.
+     */
+    wrapScheduledRun(record: TaskRunRecord, scheduledTask: ScheduledTask): string;
+    /**
+     * Handle a scheduled run completion or failure.
+     *
+     * @param runAgentId - The agentId from the TaskRunRecord.
+     * @param status - Terminal status: 'completed' or 'failed'.
+     * @param error - Optional error message if status is 'failed'.
+     */
+    handleRunComplete(runAgentId: string, status: 'completed' | 'failed', error?: string): void;
+    /**
+     * Cancel a scheduled run task by task ID.
+     * Marks the task as cancelled. The caller is responsible for disabling the
+     * scheduled task via TaskScheduler.setEnabled().
+     *
+     * @param taskId - The RuntimeTask ID to cancel.
+     */
+    cancelScheduled(taskId: string): void;
+    /**
+     * Reconcile adapter state with the current TaskScheduler snapshot.
+     *
+     * Scans all run history records from the scheduler:
+     * - Wraps any un-tracked running jobs as new tasks.
+     * - Marks completed/failed jobs that are still showing as running.
+     *
+     * @param scheduler - The TaskScheduler instance to sync from.
+     */
+    sync(scheduler: TaskScheduler): void;
+    private _upsertTask;
+    private _transitionTask;
+}
+//# sourceMappingURL=scheduler-adapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler-adapter.d.ts","sourceRoot":"","sources":["../../../../../../src/_internal/platform/runtime/tasks/adapters/scheduler-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAkB,MAAM,sBAAsB,CAAC;AAEzE,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,oDAAoD,CAAC;AAEtH;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,oBAAoB;IAQnB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAPnC,kCAAkC;IAClC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA6B;IACxD,kCAAkC;IAClC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA6B;IAExD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAiB;gBAEd,MAAM,EAAE,YAAY;IAMjD;;;;;;OAMG;IACH,gBAAgB,CAAC,MAAM,EAAE,aAAa,EAAE,aAAa,EAAE,aAAa,GAAG,MAAM;IAkC7E;;;;;;OAMG;IACH,iBAAiB,CACf,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,WAAW,GAAG,QAAQ,EAC9B,KAAK,CAAC,EAAE,MAAM,GACb,IAAI;IASP;;;;;;OAMG;IACH,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IASrC;;;;;;;;OAQG;IACH,IAAI,CAAC,SAAS,EAAE,aAAa,GAAG,IAAI;IAsCpC,OAAO,CAAC,WAAW;IAInB,OAAO,CAAC,eAAe;CAexB"}

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

@@ -0,0 +1,160 @@
+/**
+ * SchedulerTaskAdapter — bridges TaskScheduler scheduled job executions into
+ * the unified RuntimeTask registry.
+ *
+ * Each time a scheduled task fires (i.e. TaskRunRecord is created), a
+ * corresponding RuntimeTask of kind 'scheduler' is registered. The adapter
+ * tracks runRecord agentId → task ID and handles completion via state sync.
+ *
+ * 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.
+ */
+import { randomUUID } from 'node:crypto';
+import { createDomainDispatch } from '../../store/index.js';
+/**
+ * Bridges TaskScheduler job executions into the RuntimeTask registry.
+ *
+ * The scheduler runs jobs that spawn agent sessions. Each run is tracked as a
+ * RuntimeTask of kind 'scheduler'. The run's agentId is used as the correlation
+ * key between the scheduler's TaskRunRecord and the RuntimeTask.
+ *
+ * @example
+ * ```ts
+ * const adapter = new SchedulerTaskAdapter(store);
+ * // When a scheduled task fires:
+ * const taskId = adapter.wrapScheduledRun(record, scheduledTask);
+ * // When the run completes:
+ * adapter.handleRunComplete(record.agentId, 'completed');
+ * ```
+ */
+export class SchedulerTaskAdapter {
+    _store;
+    /** Maps run agentId → task ID. */
+    _runToTask = new Map();
+    /** Maps task ID → run agentId. */
+    _taskToRun = new Map();
+    _dispatch;
+    constructor(_store) {
+        this._store = _store;
+        this._dispatch = createDomainDispatch(_store);
+    }
+    // ── Core API ────────────────────────────────────────────────────────────────
+    /**
+     * Wrap a scheduled task run as a RuntimeTask.
+     *
+     * @param record - The TaskRunRecord from the scheduler.
+     * @param scheduledTask - The parent ScheduledTask definition.
+     * @returns The new task ID.
+     */
+    wrapScheduledRun(record, scheduledTask) {
+        // Idempotent: return existing if already wrapped
+        const existing = this._runToTask.get(record.agentId);
+        if (existing !== undefined)
+            return existing;
+        const taskId = randomUUID();
+        const now = record.startedAt;
+        const task = {
+            id: taskId,
+            kind: 'scheduler',
+            title: `Scheduled: ${scheduledTask.name}`,
+            description: scheduledTask.prompt.length > 200
+                ? `${scheduledTask.prompt.slice(0, 197)}...`
+                : scheduledTask.prompt,
+            status: record.status === 'running' ? 'running' : 'completed',
+            owner: `scheduler:${scheduledTask.id}`,
+            cancellable: record.status === 'running',
+            childTaskIds: [],
+            queuedAt: now,
+            startedAt: now,
+            endedAt: record.status !== 'running' ? Date.now() : undefined,
+            correlationId: record.agentId,
+            turnId: record.taskId,
+            error: record.error,
+        };
+        this._runToTask.set(record.agentId, taskId);
+        this._taskToRun.set(taskId, record.agentId);
+        this._upsertTask(task);
+        return taskId;
+    }
+    /**
+     * Handle a scheduled run completion or failure.
+     *
+     * @param runAgentId - The agentId from the TaskRunRecord.
+     * @param status - Terminal status: 'completed' or 'failed'.
+     * @param error - Optional error message if status is 'failed'.
+     */
+    handleRunComplete(runAgentId, status, error) {
+        const taskId = this._runToTask.get(runAgentId);
+        if (taskId === undefined)
+            return;
+        this._transitionTask(taskId, status, { error });
+        this._runToTask.delete(runAgentId);
+        this._taskToRun.delete(taskId);
+    }
+    /**
+     * Cancel a scheduled run task by task ID.
+     * Marks the task as cancelled. The caller is responsible for disabling the
+     * scheduled task via TaskScheduler.setEnabled().
+     *
+     * @param taskId - The RuntimeTask ID to cancel.
+     */
+    cancelScheduled(taskId) {
+        const runAgentId = this._taskToRun.get(taskId);
+        if (runAgentId === undefined)
+            return;
+        this._transitionTask(taskId, 'cancelled', {});
+        this._runToTask.delete(runAgentId);
+        this._taskToRun.delete(taskId);
+    }
+    /**
+     * Reconcile adapter state with the current TaskScheduler snapshot.
+     *
+     * Scans all run history records from the scheduler:
+     * - Wraps any un-tracked running jobs as new tasks.
+     * - Marks completed/failed jobs that are still showing as running.
+     *
+     * @param scheduler - The TaskScheduler instance to sync from.
+     */
+    sync(scheduler) {
+        const scheduledTasks = scheduler.list();
+        const scheduledTaskMap = new Map(scheduledTasks.map((t) => [t.id, t]));
+        const allHistory = scheduler.getAllHistory();
+        const runningRuns = allHistory.filter((r) => r.status === 'running');
+        for (const record of runningRuns) {
+            const scheduledTask = scheduledTaskMap.get(record.taskId);
+            if (!scheduledTask)
+                continue;
+            if (!this._runToTask.has(record.agentId)) {
+                this.wrapScheduledRun(record, scheduledTask);
+            }
+        }
+        // Reconcile tracked runs that are no longer running.
+        // Build a Map for O(1) history lookups — acceptable O(n) build at current scheduler scale.
+        const historyByAgentId = new Map(allHistory.map((r) => [r.agentId, r]));
+        const runningAgentIds = new Set(runningRuns.map((r) => r.agentId));
+        const staleRunIds = [];
+        for (const [runAgentId] of this._runToTask.entries()) {
+            if (!runningAgentIds.has(runAgentId))
+                staleRunIds.push(runAgentId);
+        }
+        for (const runAgentId of staleRunIds) {
+            const taskId = this._runToTask.get(runAgentId);
+            const record = historyByAgentId.get(runAgentId);
+            const terminalStatus = record?.status === 'failed' ? 'failed' : 'completed';
+            this._transitionTask(taskId, terminalStatus, { error: record?.error });
+            this._runToTask.delete(runAgentId);
+            this._taskToRun.delete(taskId);
+        }
+    }
+    // ── Private helpers ─────────────────────────────────────────────────────────
+    _upsertTask(task) {
+        this._dispatch.syncRuntimeTask(task, 'scheduler-adapter');
+    }
+    _transitionTask(taskId, status, opts) {
+        this._dispatch.transitionRuntimeTask(taskId, status, {
+            endedAt: Date.now(),
+            error: opts.error,
+        }, 'scheduler-adapter');
+    }
+}

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

@@ -0,0 +1,36 @@
+/**
+ * Runtime Tasks — barrel exports and factory.
+ *
+ * Usage:
+ * ```ts
+ * import { createTaskManager } from './tasks/index.js';
+ *
+ * const taskManager = createTaskManager(store, bus, sessionId);
+ * const task = taskManager.createTask({ kind: 'exec', title: 'Run lint', owner: 'exec-tool' });
+ * taskManager.startTask(task.id);
+ * taskManager.completeTask(task.id);
+ * ```
+ */
+export type { TaskManager, TaskCreateParams, TaskUpdateParams, TaskCancelParams, TaskFailParams, } from '@pellux/goodvibes-sdk/platform/runtime/tasks/types';
+export { canTransition, getValidTransitions, isTerminalStatus, } from '@pellux/goodvibes-sdk/platform/runtime/tasks/lifecycle';
+export { TaskRegistry } from '@pellux/goodvibes-sdk/platform/runtime/tasks/registry';
+export { UnifiedTaskManager, TaskTransitionError, TaskNotFoundError, TaskNotCancellableError, } from './manager.js';
+import type { RuntimeStore } from '../store/index.js';
+import type { RuntimeEventBus } from '../events/index.js';
+import type { TaskManager } from '@pellux/goodvibes-sdk/platform/runtime/tasks/types';
+/**
+ * Creates a fully initialized UnifiedTaskManager bound to the given
+ * Zustand store, RuntimeEventBus, and session identifier.
+ *
+ * @param store - The runtime Zustand store.
+ * @param bus - The RuntimeEventBus for event emission.
+ * @param sessionId - Current session identifier (used in emitter context).
+ * @returns A TaskManager instance ready for use.
+ *
+ * @example
+ * ```ts
+ * const taskManager = createTaskManager(store, bus, sessionId);
+ * ```
+ */
+export declare function createTaskManager(store: RuntimeStore, bus: RuntimeEventBus, sessionId: string): TaskManager;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/runtime/tasks/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,YAAY,EACV,WAAW,EACX,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,EAChB,cAAc,GACf,MAAM,oDAAoD,CAAC;AAG5D,OAAO,EACL,aAAa,EACb,mBAAmB,EACnB,gBAAgB,GACjB,MAAM,wDAAwD,CAAC;AAGhE,OAAO,EAAE,YAAY,EAAE,MAAM,uDAAuD,CAAC;AAGrF,OAAO,EACL,kBAAkB,EAClB,mBAAmB,EACnB,iBAAiB,EACjB,uBAAuB,GACxB,MAAM,cAAc,CAAC;AAGtB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oDAAoD,CAAC;AAGtF;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,YAAY,EACnB,GAAG,EAAE,eAAe,EACpB,SAAS,EAAE,MAAM,GAChB,WAAW,CAEb"}

package/dist/_internal/platform/runtime/tasks/index.js

@@ -0,0 +1,37 @@
+/**
+ * Runtime Tasks — barrel exports and factory.
+ *
+ * Usage:
+ * ```ts
+ * import { createTaskManager } from './tasks/index.js';
+ *
+ * const taskManager = createTaskManager(store, bus, sessionId);
+ * const task = taskManager.createTask({ kind: 'exec', title: 'Run lint', owner: 'exec-tool' });
+ * taskManager.startTask(task.id);
+ * taskManager.completeTask(task.id);
+ * ```
+ */
+// ── Lifecycle ─────────────────────────────────────────────────────────────────
+export { canTransition, getValidTransitions, isTerminalStatus, } from '@pellux/goodvibes-sdk/platform/runtime/tasks/lifecycle';
+// ── Registry ──────────────────────────────────────────────────────────────────
+export { TaskRegistry } from '@pellux/goodvibes-sdk/platform/runtime/tasks/registry';
+// ── Manager ───────────────────────────────────────────────────────────────────
+export { UnifiedTaskManager, TaskTransitionError, TaskNotFoundError, TaskNotCancellableError, } from './manager.js';
+import { UnifiedTaskManager } from './manager.js';
+/**
+ * Creates a fully initialized UnifiedTaskManager bound to the given
+ * Zustand store, RuntimeEventBus, and session identifier.
+ *
+ * @param store - The runtime Zustand store.
+ * @param bus - The RuntimeEventBus for event emission.
+ * @param sessionId - Current session identifier (used in emitter context).
+ * @returns A TaskManager instance ready for use.
+ *
+ * @example
+ * ```ts
+ * const taskManager = createTaskManager(store, bus, sessionId);
+ * ```
+ */
+export function createTaskManager(store, bus, sessionId) {
+    return new UnifiedTaskManager(store, bus, sessionId);
+}