@zhin.js/agent 0.3.1 → 1.0.2

package/lib/orchestrator/orchestration-service.js

@@ -1,66 +1,367 @@
 import { getAgentDispatcher } from './agent-dispatcher.js';
 import { taskRecordToAgentTaskShape, } from './orchestration-repository.js';
-import { MISSIONS_TEMPLATE, createDefaultMissionState, } from './mission-state.js';
-import { validateMissionStatePatch } from './mission-patch-acl.js';
-export { MISSIONS_TEMPLATE };
-export class OrchestrationService {
+import { mapEventRecord, mapRunRecord, mapTaskRecord, normalizeExecutorKind } from './orchestration-mappers.js';
+const ACTIVE_RUN_STATUSES = new Set(['open', 'running', 'waiting']);
+const ACTIVE_TASK_STATUSES = new Set([
+    'pending',
+    'assigned',
+    'running',
+    'waiting_result',
+]);
+const TERMINAL_TASK_STATUSES = new Set([
+    'completed',
+    'failed',
+    'cancelled',
+]);
+function normalizeExecutor(input) {
+    const value = String(input ?? 'local');
+    if (value === 'local')
+        return { executorKind: 'local' };
+    if (value === 'remote')
+        return { executorKind: 'remote_mesh' };
+    if (value.startsWith('remote:')) {
+        return { executorKind: 'remote_mesh', remoteAgentId: value.slice('remote:'.length) };
+    }
+    if (value === 'group_mention' || value === 'scene_mention')
+        return { executorKind: 'im_projection' };
+    if (value === 'internal_room' || value === 'im_projection' || value === 'remote_mesh') {
+        return { executorKind: value };
+    }
+    return { executorKind: 'local' };
+}
+async function* resultIterable(result) {
+    const value = await result;
+    yield { type: 'result', result: value };
+}
+export class OrchestrationKernel {
     repository;
+    executors = new Map();
+    strategies = new Map();
+    waiters = new Map();
     constructor(repository) {
         this.repository = repository;
     }
     get repositoryHandle() {
         return this.repository;
     }
+    /**
+     * Swap the backing repository in-place (preserves registered executors/strategies).
+     * Used by the DB activation path to upgrade from the Memory placeholder without
+     * discarding executor/strategy registrations made during bootstrap.
+     */
+    replaceRepository(repository) {
+        this.repository = repository;
+    }
+    registerExecutor(executor) {
+        this.executors.set(executor.kind, executor);
+        return () => {
+            if (this.executors.get(executor.kind) === executor)
+                this.executors.delete(executor.kind);
+        };
+    }
+    registerWorkflowStrategy(strategy) {
+        this.strategies.set(strategy.name, strategy);
+        return () => {
+            if (this.strategies.get(strategy.name) === strategy)
+                this.strategies.delete(strategy.name);
+        };
+    }
     async startRun(input) {
-        const remoteValidator = input.remoteValidator?.trim();
         const run = await this.repository.createRun({
             session_key: input.sessionKey,
-            title: input.title ?? 'Orchestration run',
-            template: MISSIONS_TEMPLATE,
+            title: input.title ?? 'Agent run',
+            source: input.source,
+            state: input.state,
+        });
+        await this.appendEvent(run.id, 'run.started', undefined, {
+            title: run.title,
+            source: input.source ?? null,
         });
-        await this.installMissionsTemplate(run.id, { remoteValidatorId: remoteValidator });
-        return { run, tasks: await this.repository.listTasksByRun(run.id) };
+        return { run, tasks: [], events: await this.repository.listEventsByRun(run.id) };
+    }
+    async findOrCreateRun(input) {
+        const existing = (await this.repository.listRunsBySessionKey(input.sessionKey))
+            .find((run) => ACTIVE_RUN_STATUSES.has(run.status));
+        if (existing)
+            return existing;
+        return (await this.startRun(input)).run;
     }
     async addTask(input) {
-        let executor_kind = 'local';
-        let remote_agent_id = '';
-        if (input.executor?.startsWith('remote:')) {
-            executor_kind = 'remote';
-            remote_agent_id = input.executor.slice('remote:'.length);
-        }
-        const task = await this.repository.createTask({
+        const executor = normalizeExecutor(input.executor);
+        return this.createTaskRecord({
             run_id: input.runId,
             name: input.name,
             description: input.description,
             role: input.role,
             goal: input.goal,
             depends_on: input.dependsOn,
-            executor_kind,
-            remote_agent_id,
+            executor_kind: executor.executorKind,
+            assigned_to: input.assignedTo,
+            remote_agent_id: executor.remoteAgentId,
             priority: input.priority,
             context: input.context,
-            is_writer: input.is_writer,
-            phase: input.phase,
         });
-        const dispatcher = getAgentDispatcher();
-        dispatcher.syncTaskFromRecord(task);
-        return task;
+    }
+    async dispatchTask(input) {
+        const record = await this.createTaskRecord({
+            run_id: input.runId,
+            name: input.name,
+            description: input.description,
+            role: input.role,
+            goal: input.goal,
+            depends_on: input.dependsOn,
+            executor_kind: input.executorKind ?? 'local',
+            assigned_to: input.assignedTo,
+            remote_agent_id: input.remoteAgentId,
+            priority: input.priority,
+            context: input.context,
+        });
+        const snapshot = await this.getSnapshot(input.runId);
+        const task = mapTaskRecord(record);
+        if (input.autoStart !== false) {
+            void this.runTask(record.id, input.message).catch((err) => {
+                void this.safeFailTask(record.id, err instanceof Error ? err.message : String(err));
+            });
+        }
+        return { run: snapshot.run, task };
+    }
+    async handleUserMessage(input) {
+        const run = await this.findOrCreateRun({
+            sessionKey: input.sessionKey,
+            title: input.title ?? (input.content.slice(0, 80) || 'IM agent run'),
+            source: input.source,
+        });
+        return this.dispatchTask({
+            runId: run.id,
+            name: input.task?.name ?? 'Handle user message',
+            description: input.task?.description ?? input.content,
+            role: input.task?.role ?? 'planner',
+            goal: input.task?.goal ?? input.content,
+            executorKind: input.task?.executorKind ?? 'local',
+            assignedTo: input.task?.assignedTo,
+            context: input.task?.context,
+            message: input.message,
+            autoStart: input.autoStart,
+        });
+    }
+    async runWorkflowStrategy(name, input) {
+        const strategy = this.strategies.get(name);
+        if (!strategy)
+            throw new Error(`Workflow strategy ${name} is not registered`);
+        const runRecord = await this.findOrCreateRun({
+            sessionKey: input.sessionKey,
+            title: input.title ?? (input.content.slice(0, 80) || `${name} run`),
+            source: input.source,
+        });
+        const run = mapRunRecord(runRecord);
+        const specs = await strategy.plan({ run, goal: input.content, message: input.message });
+        const taskIdsByKey = new Map();
+        for (const spec of specs) {
+            const task = await this.dispatchWorkflowTask(run.id, spec, input.message, taskIdsByKey);
+            if (spec.key)
+                taskIdsByKey.set(spec.key, task.id);
+        }
+        return this.getSnapshot(run.id);
+    }
+    async runTaskWithResult(taskId, result) {
+        return this.runTask(taskId, undefined, {
+            kind: 'local',
+            execute: () => resultIterable(result),
+        });
+    }
+    async runTask(taskId, message, overrideExecutor) {
+        const taskRecord = await this.repository.getTask(taskId);
+        if (!taskRecord)
+            throw new Error(`task ${taskId} not found`);
+        const runRecord = await this.repository.getRun(taskRecord.run_id);
+        if (!runRecord)
+            throw new Error(`run ${taskRecord.run_id} not found`);
+        if (!ACTIVE_TASK_STATUSES.has(taskRecord.status))
+            return mapTaskRecord(taskRecord);
+        const executorKind = normalizeExecutorKind(taskRecord.executor_kind);
+        const executor = overrideExecutor ?? this.executors.get(executorKind);
+        if (!executor) {
+            await this.repository.updateTaskStatus(taskId, 'waiting_result');
+            await this.appendEvent(taskRecord.run_id, 'task.progress', taskId, {
+                status: 'waiting_result',
+                reason: `executor ${executorKind} not registered`,
+            });
+            return mapTaskRecord((await this.repository.getTask(taskId)));
+        }
+        await this.repository.updateRunStatus(taskRecord.run_id, 'running');
+        await this.repository.updateTaskStatus(taskId, 'running', { started_at: Date.now() });
+        await this.appendEvent(taskRecord.run_id, 'run.status_changed', undefined, { status: 'running' });
+        await this.appendEvent(taskRecord.run_id, 'task.started', taskId, { executorKind: taskRecord.executor_kind });
+        let completed = false;
+        try {
+            const run = mapRunRecord(runRecord);
+            const task = mapTaskRecord((await this.repository.getTask(taskId)));
+            for await (const event of executor.execute({ run, task, message })) {
+                await this.consumeExecutionEvent(taskId, event);
+                if (event.type === 'result')
+                    completed = true;
+            }
+            if (!completed) {
+                const afterLoop = await this.repository.getTask(taskId);
+                if (afterLoop && !TERMINAL_TASK_STATUSES.has(afterLoop.status)) {
+                    await this.repository.updateTaskStatus(taskId, 'waiting_result');
+                    await this.appendEvent(taskRecord.run_id, 'task.progress', taskId, { status: 'waiting_result' });
+                }
+            }
+        }
+        catch (err) {
+            return this.safeFailTask(taskId, err instanceof Error ? err.message : String(err));
+        }
+        return mapTaskRecord((await this.repository.getTask(taskId)));
+    }
+    async completeTask(taskId, result) {
+        const task = await this.requireTask(taskId);
+        if (task.status === 'completed') {
+            return mapTaskRecord(task);
+        }
+        if (TERMINAL_TASK_STATUSES.has(task.status)) {
+            throw new Error(`task ${taskId} is ${task.status}, cannot complete`);
+        }
+        await this.repository.updateTaskStatus(taskId, 'completed', {
+            result_summary: result,
+            error: '',
+            finished_at: Date.now(),
+        });
+        const completedRecord = await this.repository.getTask(taskId);
+        if (completedRecord)
+            getAgentDispatcher().syncTaskFromRecord(completedRecord);
+        await this.appendEvent(task.run_id, 'task.completed', taskId, { result });
+        await this.appendEvent(task.run_id, 'result.returned', taskId, { result });
+        await this.recomputeRunStatus(task.run_id);
+        const updated = mapTaskRecord((await this.repository.getTask(taskId)));
+        this.notifyWaiters(updated);
+        return updated;
+    }
+    async failTask(taskId, error) {
+        const task = await this.requireTask(taskId);
+        if (TERMINAL_TASK_STATUSES.has(task.status)) {
+            return mapTaskRecord(task);
+        }
+        await this.repository.updateTaskStatus(taskId, 'failed', {
+            error,
+            result_summary: '',
+            finished_at: Date.now(),
+        });
+        const failedRecord = await this.repository.getTask(taskId);
+        if (failedRecord)
+            getAgentDispatcher().syncTaskFromRecord(failedRecord);
+        await this.appendEvent(task.run_id, 'task.failed', taskId, { error });
+        await this.recomputeRunStatus(task.run_id);
+        const updated = mapTaskRecord((await this.repository.getTask(taskId)));
+        this.notifyWaiters(updated);
+        return updated;
+    }
+    async taskThinking(taskId, text) {
+        const task = await this.requireTask(taskId);
+        await this.appendEvent(task.run_id, 'task.thinking', taskId, { text });
+    }
+    async taskProgress(taskId, text) {
+        const task = await this.requireTask(taskId);
+        await this.appendEvent(task.run_id, 'task.progress', taskId, { text });
+    }
+    /** Mark task waiting on external handback (e.g. remote mesh); kernel-owned status transition. */
+    async markTaskWaitingResult(taskId, patch = {}) {
+        const task = await this.requireTask(taskId);
+        if (TERMINAL_TASK_STATUSES.has(task.status)) {
+            return mapTaskRecord(task);
+        }
+        await this.repository.updateTaskStatus(taskId, 'waiting_result', {
+            remote_task_id: patch.remoteTaskId,
+            started_at: task.started_at ?? Date.now(),
+        });
+        if (patch.progress) {
+            await this.appendEvent(task.run_id, 'task.progress', taskId, { text: patch.progress });
+        }
+        const updated = await this.repository.getTask(taskId);
+        if (updated)
+            getAgentDispatcher().syncTaskFromRecord(updated);
+        await this.recomputeRunStatus(task.run_id);
+        return mapTaskRecord((await this.repository.getTask(taskId)));
+    }
+    /** Cancel an active task (mesh / director); idempotent when already cancelled. */
+    async cancelTask(taskId, reason) {
+        const task = await this.requireTask(taskId);
+        if (task.status === 'cancelled') {
+            return mapTaskRecord(task);
+        }
+        if (TERMINAL_TASK_STATUSES.has(task.status)) {
+            throw new Error(`task ${taskId} is ${task.status}, cannot cancel`);
+        }
+        await this.repository.updateTaskStatus(taskId, 'cancelled', {
+            error: reason,
+            result_summary: '',
+            finished_at: Date.now(),
+        });
+        const updated = await this.repository.getTask(taskId);
+        if (updated)
+            getAgentDispatcher().syncTaskFromRecord(updated);
+        await this.appendEvent(task.run_id, 'task.failed', taskId, { cancelled: true, reason });
+        await this.recomputeRunStatus(task.run_id);
+        const mapped = mapTaskRecord((await this.repository.getTask(taskId)));
+        this.notifyWaiters(mapped);
+        return mapped;
+    }
+    /** failTask wrapper that never throws on terminal races (executor catch paths). */
+    async safeFailTask(taskId, error) {
+        try {
+            return await this.failTask(taskId, error);
+        }
+        catch (err) {
+            const task = await this.repository.getTask(taskId);
+            if (task && TERMINAL_TASK_STATUSES.has(task.status)) {
+                return mapTaskRecord(task);
+            }
+            throw err;
+        }
+    }
+    async waitForTask(taskId, timeoutMs = 120_000) {
+        const current = await this.repository.getTask(taskId);
+        if (!current)
+            throw new Error(`task ${taskId} not found`);
+        if (!ACTIVE_TASK_STATUSES.has(current.status))
+            return mapTaskRecord(current);
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                const list = this.waiters.get(taskId) ?? [];
+                this.waiters.set(taskId, list.filter(fn => fn !== done));
+                reject(new Error(`task ${taskId} timed out`));
+            }, timeoutMs);
+            const done = (task) => {
+                clearTimeout(timer);
+                resolve(task);
+            };
+            this.waiters.set(taskId, [...(this.waiters.get(taskId) ?? []), done]);
+        });
     }
     async getStatus(runId) {
         const snapshot = await this.repository.getRunWithTasks(runId);
         if (!snapshot)
             return null;
         const dispatcher = getAgentDispatcher();
-        for (const task of snapshot.tasks) {
+        for (const task of snapshot.tasks)
             dispatcher.syncTaskFromRecord(task);
-        }
         return snapshot;
     }
+    async getSnapshot(runId) {
+        const snapshot = await this.repository.getRunWithTasks(runId);
+        if (!snapshot)
+            throw new Error(`run ${runId} not found`);
+        return {
+            run: mapRunRecord(snapshot.run),
+            tasks: snapshot.tasks.map(mapTaskRecord),
+            events: (snapshot.events ?? []).map(mapEventRecord),
+        };
+    }
     async completeRun(runId, force = false) {
         const snapshot = await this.getStatus(runId);
         if (!snapshot)
             return { ok: false, message: `Run ${runId} not found` };
-        const blocking = snapshot.tasks.filter((t) => t.status === 'pending' || t.status === 'running');
+        const blocking = snapshot.tasks.filter(t => ACTIVE_TASK_STATUSES.has(t.status));
         if (blocking.length > 0 && !force) {
             return {
                 ok: false,
@@ -68,8 +369,10 @@ export class OrchestrationService {
             };
         }
         const hasFailed = snapshot.tasks.some((t) => t.status === 'failed');
-        await this.repository.updateRunStatus(runId, hasFailed && !force ? 'failed' : 'completed');
-        return { ok: true, message: `Run ${runId} marked ${hasFailed && !force ? 'failed' : 'completed'}` };
+        const status = hasFailed && !force ? 'failed' : 'completed';
+        await this.repository.updateRunStatus(runId, status);
+        await this.appendEvent(runId, 'run.status_changed', undefined, { status });
+        return { ok: true, message: `Run ${runId} marked ${status}` };
     }
     async retryTask(taskId) {
         const task = await this.repository.getTask(taskId);
@@ -87,6 +390,7 @@ export class OrchestrationService {
         const updated = await this.repository.getTask(taskId);
         if (updated)
             getAgentDispatcher().syncTaskFromRecord(updated);
+        await this.appendEvent(task.run_id, 'task.progress', taskId, { status: 'pending', action: 'retry' });
         return { ok: true, message: `Task ${taskId} reset to pending` };
     }
     async skipTask(taskId, reason) {
@@ -94,26 +398,28 @@ export class OrchestrationService {
         if (!task)
             return { ok: false, message: `Task ${taskId} not found` };
         if (task.status !== 'failed' && task.status !== 'pending') {
-            return { ok: false, message: `Task ${taskId} is ${task.status}, cannot skip` };
+            return { ok: false, message: `Task ${taskId} is ${task.status}, cannot cancel` };
         }
-        await this.repository.updateTaskStatus(taskId, 'skipped', {
-            error: reason || 'skipped by director',
+        await this.repository.updateTaskStatus(taskId, 'cancelled', {
+            error: reason || 'cancelled by director',
             finished_at: Date.now(),
         });
         const updated = await this.repository.getTask(taskId);
         if (updated)
             getAgentDispatcher().syncTaskFromRecord(updated);
-        return { ok: true, message: `Task ${taskId} skipped` };
+        await this.appendEvent(task.run_id, 'task.failed', taskId, { cancelled: true, reason });
+        await this.recomputeRunStatus(task.run_id);
+        return { ok: true, message: `Task ${taskId} cancelled` };
     }
     async listRuns(sessionKey) {
-        if (!sessionKey) {
+        if (!sessionKey)
             return [];
-        }
         const runs = await this.repository.listRunsBySessionKey(sessionKey);
         const out = [];
         for (const run of runs) {
             const tasks = await this.repository.listTasksByRun(run.id);
-            out.push({ run, tasks });
+            const events = await this.repository.listEventsByRun(run.id);
+            out.push({ run, tasks, events });
         }
         return out;
     }
@@ -133,89 +439,125 @@ export class OrchestrationService {
             executorKind: shape.executorKind,
             remoteAgentId: shape.remoteAgentId,
             remoteTaskId: shape.remoteTaskId,
-            isWriter: shape.isWriter,
-            phase: shape.phase,
         };
     }
-    async installMissionsTemplate(runId, options) {
-        const initial = createDefaultMissionState('plan');
-        if (options.remoteValidatorId?.trim()) {
-            initial.remote_validator_id = options.remoteValidatorId.trim();
-        }
-        await this.patchMissionState(runId, initial, { skipAcl: true });
-        const plan = await this.addTask({
-            runId,
-            name: 'Plan',
-            role: 'planner',
-            phase: 'plan',
-            goal: 'Produce implementation plan (plan.md)',
-            description: 'Missions planning phase',
+    async createTaskRecord(input) {
+        const record = await this.repository.createTask(input);
+        getAgentDispatcher().syncTaskFromRecord(record);
+        await this.appendEvent(record.run_id, 'task.created', record.id, {
+            name: record.name,
+            role: record.role,
+            executorKind: record.executor_kind,
         });
-        const writeSpec = await this.addTask({
-            runId,
-            name: 'WriteSpec',
-            role: 'planner',
-            phase: 'spec',
-            goal: 'Write Validation Spec under .zhin/missions/<runId>/ (spec.test.ts + manifest.json)',
-            description: 'Validation Spec phase',
-            dependsOn: [plan.id],
-        });
-        const develop = await this.addTask({
-            runId,
-            name: 'Develop',
-            role: 'subtask',
-            phase: 'develop',
-            is_writer: true,
-            goal: 'Implement to satisfy Validation Spec only',
-            description: 'Single writer development phase',
-            dependsOn: [writeSpec.id],
-        });
-        const validateExecutor = options.remoteValidatorId?.trim()
-            ? `remote:${options.remoteValidatorId.trim()}`
-            : undefined;
-        const validate = await this.addTask({
-            runId,
-            name: 'Validate',
-            role: 'validator',
-            phase: 'validate',
-            goal: 'Run run_validation_spec until all assertions pass',
-            description: options.remoteValidatorId ? 'Remote behavior validation' : 'Behavior validation phase',
-            dependsOn: [develop.id],
-            executor: validateExecutor,
-        });
-        await this.addTask({
+        await this.repository.updateTaskStatus(record.id, 'assigned', {
+            assigned_to: record.assigned_to,
+        });
+        const assigned = (await this.repository.getTask(record.id)) ?? record;
+        getAgentDispatcher().syncTaskFromRecord(assigned);
+        await this.appendEvent(record.run_id, 'task.assigned', record.id, {
+            executorKind: record.executor_kind,
+            assignedTo: record.assigned_to || null,
+        });
+        await this.recomputeRunStatus(record.run_id);
+        return assigned;
+    }
+    async dispatchWorkflowTask(runId, spec, message, taskIdsByKey) {
+        const dependsOn = spec.dependsOn?.map((dep) => taskIdsByKey.get(dep) ?? dep);
+        const dispatched = await this.dispatchTask({
             runId,
-            name: 'Negotiate',
-            role: 'planner',
-            phase: 'negotiate',
-            goal: 'Re-evaluate mission direction on validation failure',
-            description: 'Negotiation phase',
-            dependsOn: [validate.id],
-        });
-    }
-    async patchMissionState(runId, patch, options) {
-        if (!options?.skipAcl) {
-            const current = await this.repository.getMissionState(runId);
-            if (current) {
-                const check = validateMissionStatePatch(current.phase, patch);
-                if (!check.ok) {
-                    throw new Error(check.reason ?? 'Mission State patch 被拒绝');
-                }
-            }
+            name: spec.name,
+            description: spec.description,
+            role: spec.role,
+            goal: spec.goal,
+            dependsOn,
+            executorKind: spec.executorKind ?? 'local',
+            assignedTo: spec.assignedTo,
+            context: spec.context,
+            message,
+            autoStart: false,
+        });
+        return dispatched.task;
+    }
+    async consumeExecutionEvent(taskId, event) {
+        if (event.type === 'thinking') {
+            await this.taskThinking(taskId, event.text ?? '');
+            return;
+        }
+        if (event.type === 'progress') {
+            await this.taskProgress(taskId, event.text ?? '');
+            return;
+        }
+        if (event.type === 'result') {
+            await this.completeTask(taskId, event.result ?? event.text ?? '');
+            return;
         }
-        return this.repository.patchMissionState(runId, patch);
+        if (event.type === 'error') {
+            await this.failTask(taskId, event.error ?? event.text ?? 'task failed');
+        }
+    }
+    async recomputeRunStatus(runId) {
+        const snapshot = await this.repository.getRunWithTasks(runId);
+        if (!snapshot)
+            return;
+        let status = 'completed';
+        if (snapshot.tasks.some(t => t.status === 'failed'))
+            status = 'failed';
+        else if (snapshot.tasks.some(t => t.status === 'running'))
+            status = 'running';
+        else if (snapshot.tasks.some(t => t.status === 'waiting_result' || t.status === 'assigned' || t.status === 'pending'))
+            status = 'waiting';
+        await this.repository.updateRunStatus(runId, status);
+        await this.appendEvent(runId, 'run.status_changed', undefined, { status });
+    }
+    async requireTask(taskId) {
+        const task = await this.repository.getTask(taskId);
+        if (!task)
+            throw new Error(`task ${taskId} not found`);
+        return task;
+    }
+    async appendEvent(runId, type, taskId, payload) {
+        return mapEventRecord(await this.repository.appendEvent({
+            run_id: runId,
+            task_id: taskId,
+            type,
+            payload,
+        }));
     }
-    async getMissionState(runId) {
-        return this.repository.getMissionState(runId);
+    notifyWaiters(task) {
+        const waiters = this.waiters.get(task.id) ?? [];
+        this.waiters.delete(task.id);
+        for (const waiter of waiters)
+            waiter(task);
     }
 }
+export class OrchestrationService extends OrchestrationKernel {
+}
 let globalService = null;
 export function initOrchestrationService(repository) {
     globalService = new OrchestrationService(repository);
     getAgentDispatcher().setRepository(repository);
     return globalService;
 }
+/**
+ * Upgrade the global kernel's repository in-place. If no kernel exists yet, this
+ * is equivalent to {@link initOrchestrationService}. Otherwise it swaps the
+ * repository while preserving registered executors and workflow strategies —
+ * used by the DB activation path to move from the Memory placeholder to a
+ * Database repository without losing bootstrap-time registrations.
+ */
+export function upgradeOrchestrationRepository(repository) {
+    const existing = globalService;
+    if (existing) {
+        existing.replaceRepository(repository);
+        getAgentDispatcher().setRepository(repository);
+        return existing;
+    }
+    return initOrchestrationService(repository);
+}
 export function getOrchestrationService() {
     return globalService;
 }
+export function getOrchestrationKernel() {
+    return globalService;
+}
 //# sourceMappingURL=orchestration-service.js.map