@moorline/core 0.0.1 → 0.0.3

package/dist/core/domain/sessions/runtimeWorkManagementService.js

@@ -1,28 +1,23 @@
-import { parseMissionSchedule, parseMissionStartTime } from '../missions/missionSchedule.js';
 import { isManagedWorkerSession } from './managedWorkerSessions.js';
-import { slugifySpaceName, truncatePreview } from './workManagement/spaceNames.js';
+import { slugifyResourceName, truncatePreview } from './workManagement/transportResourceNames.js';
 import { enforceManagedSessionLimit } from './workManagement/managedSessionLimit.js';
-import { buildManagedSpaceMetadata } from '../../runtime/hosting/managedSpaceMetadata.js';
+import { buildManagedTransportResourceMetadata } from '../../runtime/hosting/managedTransportResourceMetadata.js';
+import { MoorlineStatusError } from '../../shared/errors/statusError.js';
 const INITIAL_KICKOFF_PREVIEW_LIMIT = 700;
 export class RuntimeWorkManagementService {
     deps;
     constructor(deps) {
         this.deps = deps;
     }
-    resolveMission(input) {
-        return (input.missionId ? this.deps.missionRegistry.getById(input.missionId) : null) ?? this.deps.missionRegistry.getBySpaceId(input.spaceId);
-    }
     async createManagedSession(input) {
-        const namespace = this.deps.requireNamespaceState();
         const owner = input.owner ?? this.deps.defaultSessionOwner(input.actorId);
-        const ownerMission = owner.kind === 'mission' ? this.deps.missionRegistry.getByThreadId(owner.id) : null;
-        const objective = input.objective ?? ownerMission?.goal ?? null;
+        const objective = input.objective ?? null;
         enforceManagedSessionLimit(this.deps.snapshots, owner);
-        const spaceName = slugifySpaceName('session', input.requestedName);
+        const transportResourceName = slugifyResourceName('session', input.requestedName);
         await this.deps.getGuard().run({
             action: 'session.create',
             actor: input.actorId,
-            target: `${this.deps.config.transport.scopeId}:${spaceName}`,
+            target: `${this.deps.config.transport.scopeId}:${transportResourceName}`,
             payload: {
                 runtimeMode: input.runtimeMode,
                 owner,
@@ -31,43 +26,28 @@ export class RuntimeWorkManagementService {
             },
             execute: async () => undefined
         });
-        const space = await this.deps.getGuard().run({
-            action: 'transport.space.create',
+        const resource = await this.deps.getGuard().run({
+            action: 'transport.resource.create',
             actor: input.actorId,
-            target: `${this.deps.config.transport.scopeId}:${spaceName}`,
-            execute: async () => await this.createRuntimeSpace(spaceName, namespace.sessionsCategoryId)
+            target: `${this.deps.config.transport.scopeId}:${transportResourceName}`,
+            execute: async () => await this.createRuntimeTransportResource(input.actorId, transportResourceName, null)
+        });
+        const session = this.deps.reactor.createSession({
+            scopeId: this.deps.config.transport.scopeId,
+            transportResourceId: resource.id,
+            transportResourceName: resource.name,
+            requestedName: input.requestedName,
+            runtimeMode: input.runtimeMode,
+            nowIso: this.deps.now(),
+            providerAutoStartEnabled: this.deps.getProviderAutoStartDefault(),
+            owner,
+            objective: objective ?? undefined,
+            tags: input.tags,
+            createdBy: input.actorId
         });
-        let session;
-        try {
-            session = this.deps.reactor.createSession({
-                scopeId: this.deps.config.transport.scopeId,
-                spaceId: space.id,
-                spaceName: space.name,
-                requestedName: input.requestedName,
-                runtimeMode: input.runtimeMode,
-                nowIso: this.deps.now(),
-                providerAutoStartEnabled: this.deps.getProviderAutoStartDefault(),
-                owner,
-                objective: objective ?? undefined,
-                tags: input.tags,
-                createdBy: input.actorId
-            });
-        }
-        catch (error) {
-            // Resource lifecycle adoption can race with explicit managed session creation.
-            // If adoption already persisted the session for this new space, reuse it.
-            const adopted = this.deps.sessionRegistry.getBySpaceId(space.id);
-            if (adopted) {
-                session = adopted;
-            }
-            else {
-                await this.deleteRuntimeSpace(space.id, 'best-effort');
-                throw error;
-            }
-        }
         this.deps.appendAuditEvent('session.created', {
             sessionId: session.sessionId,
-            spaceId: session.spaceId,
+            transportResourceId: session.transportResourceId,
             runtimeMode: session.runtimeMode,
             ownerKind: session.ownerKind,
             ownerId: session.ownerId,
@@ -75,16 +55,9 @@ export class RuntimeWorkManagementService {
             tags: session.tags ?? [],
             actorId: input.actorId
         });
-        if (session.createdBy === 'runtime:transport/space-lifecycle') {
-            this.deps.appendAuditEvent('session.created.race_recovered', {
-                sessionId: session.sessionId,
-                spaceId: session.spaceId,
-                actorId: input.actorId
-            });
-        }
         if (input.initialInstruction?.trim()) {
             try {
-                await this.deps.postTransportMessage(input.actorId, session.spaceId, {
+                await this.deps.postTransportMessage(input.actorId, session.transportResourceId, {
                     text: `Queued initial kickoff for ${session.sessionId}.`,
                     blocks: [
                         {
@@ -110,24 +83,82 @@ export class RuntimeWorkManagementService {
             catch (error) {
                 this.deps.appendAuditEvent('session.created.notification_failed', {
                     sessionId: session.sessionId,
-                    spaceId: session.spaceId,
+                    transportResourceId: session.transportResourceId,
                     actorId: input.actorId,
                     error: error instanceof Error ? error.message : String(error)
                 });
             }
             this.enqueueInitialManagedSessionKickoff({
                 actorId: input.actorId,
-                spaceId: session.spaceId,
+                transportResourceId: session.transportResourceId,
                 sessionId: session.sessionId,
                 instruction: input.initialInstruction
             });
         }
-        return { session, spaceId: space.id };
+        return { session, transportResourceId: resource.id };
+    }
+    async bindManagedSessionToTransportResource(input) {
+        const existing = this.deps.sessionRegistry.getByTransportResourceId(input.transportResourceId);
+        if (existing) {
+            const updated = this.deps.sessionRegistry.updateSession({
+                ...existing,
+                transportResourceName: input.transportResourceName,
+                runtimeMode: input.runtimeMode,
+                ownerKind: input.owner?.kind ?? existing.ownerKind,
+                ownerId: input.owner?.id ?? existing.ownerId,
+                ownerLabel: input.owner?.label ?? existing.ownerLabel,
+                objective: input.objective ?? existing.objective,
+                tags: input.tags ?? existing.tags ?? [],
+                updatedAt: this.deps.now()
+            });
+            this.deps.appendAuditEvent('session.transport_binding.updated', {
+                sessionId: updated.sessionId,
+                transportResourceId: updated.transportResourceId,
+                actorId: input.actorId
+            });
+            return updated;
+        }
+        const owner = input.owner ?? this.deps.defaultSessionOwner(input.actorId);
+        const objective = input.objective ?? null;
+        enforceManagedSessionLimit(this.deps.snapshots, owner);
+        await this.deps.getGuard().run({
+            action: 'session.create',
+            actor: input.actorId,
+            target: `${this.deps.config.transport.scopeId}:${input.transportResourceId}`,
+            payload: {
+                runtimeMode: input.runtimeMode,
+                owner,
+                objective,
+                tags: input.tags ?? [],
+                source: 'transport-intent'
+            },
+            execute: async () => undefined
+        });
+        const session = this.deps.reactor.createSession({
+            scopeId: this.deps.config.transport.scopeId,
+            transportResourceId: input.transportResourceId,
+            transportResourceName: input.transportResourceName,
+            requestedName: input.requestedName ?? input.transportResourceName,
+            runtimeMode: input.runtimeMode,
+            nowIso: this.deps.now(),
+            providerAutoStartEnabled: this.deps.getProviderAutoStartDefault(),
+            owner,
+            objective: objective ?? undefined,
+            tags: input.tags,
+            createdBy: input.actorId
+        });
+        this.deps.appendAuditEvent('session.created.from_transport_intent', {
+            sessionId: session.sessionId,
+            transportResourceId: session.transportResourceId,
+            runtimeMode: session.runtimeMode,
+            actorId: input.actorId
+        });
+        return session;
     }
     async directManagedSession(input) {
         const session = this.resolveManagedWorkerSession(input);
         if (!session) {
-            throw new Error('No matching managed worker session found.');
+            throw new MoorlineStatusError(404, 'No matching managed worker session found.');
         }
         if (session.lifecycleStatus === 'archived') {
             throw new Error(`Session ${session.sessionId} is archived.`);
@@ -148,17 +179,17 @@ export class RuntimeWorkManagementService {
             : instruction;
         const reply = await this.deps.runOrchestrationTurn(session, input.actorId, prompt);
         const updatedSession = this.deps.sessionRegistry.markDirected({
-            spaceId: session.spaceId,
+            transportResourceId: session.transportResourceId,
             directedAt: this.deps.now(),
             directedBy: input.actorId
         }) ?? session;
         this.deps.appendAuditEvent('session.directed', {
             sessionId: session.sessionId,
-            spaceId: session.spaceId,
+            transportResourceId: session.transportResourceId,
             actorId: input.actorId,
             reason: input.reason ?? null
         });
-        await this.deps.postTransportMessage(input.actorId, session.spaceId, reply);
+        await this.deps.postTransportMessage(input.actorId, session.transportResourceId, reply);
         return {
             session: updatedSession,
             reply
@@ -169,23 +200,12 @@ export class RuntimeWorkManagementService {
         if (!session) {
             return null;
         }
-        const namespace = this.deps.requireNamespaceState();
         await this.deps.getGuard().run({
             action: 'session.archive',
             actor: input.actorId,
             target: session.sessionId,
             execute: async () => undefined
         });
-        await this.deps.getGuard().run({
-            action: 'transport.space.update',
-            actor: input.actorId,
-            target: session.spaceId,
-            execute: async () => this.deps.getTransport().updateSpace?.({
-                scopeId: this.deps.config.transport.scopeId,
-                spaceId: session.spaceId,
-                parentId: namespace.archiveCategoryId
-            })
-        });
         this.deps.providerService.stopSession(session.threadId);
         this.deps.providerDirectory.delete(session.threadId);
         this.deps.rejectTurnWaitersForThread(session.threadId, `Session ${session.sessionId} was archived.`);
@@ -196,14 +216,14 @@ export class RuntimeWorkManagementService {
             lifecycleStatus: 'archived',
             archivedAt: nowIso,
             providerThreadId: null,
-            resumeThreadId: null,
+            resumeCursor: null,
             providerStatus: 'closed',
             activeTurnId: null,
             updatedAt: nowIso
         });
         this.deps.appendAuditEvent('session.archived', {
             sessionId: archived.sessionId,
-            spaceId: archived.spaceId,
+            transportResourceId: archived.transportResourceId,
             actorId: input.actorId
         });
         return archived;
@@ -220,340 +240,136 @@ export class RuntimeWorkManagementService {
             execute: async () => undefined
         });
         await this.deps.getGuard().run({
-            action: 'transport.space.delete',
+            action: 'transport.resource.delete',
             actor: input.actorId,
-            target: session.spaceId,
-            execute: async () => await this.deleteRuntimeSpace(session.spaceId, 'strict')
+            target: session.transportResourceId,
+            execute: async () => await this.deleteRuntimeTransportResource(session.transportResourceId, 'best-effort')
         });
         this.deps.providerService.stopSession(session.threadId);
         this.deps.providerDirectory.delete(session.threadId);
         this.deps.rejectTurnWaitersForThread(session.threadId, `Session ${session.sessionId} was deleted.`);
         await this.deps.cleanupScopedSidecars('session', session.sessionId, `session ${session.sessionId} deleted`);
-        const deleted = this.deps.sessionRegistry.deleteArchived(session.spaceId);
+        const deleted = this.deps.sessionRegistry.deleteArchived(session.transportResourceId);
         if (deleted) {
             this.deps.appendAuditEvent('session.deleted', {
                 sessionId: deleted.sessionId,
-                spaceId: deleted.spaceId,
+                transportResourceId: deleted.transportResourceId,
                 workspacePath: deleted.workspacePath,
                 actorId: input.actorId
             });
         }
         return deleted;
     }
-    async createMission(input) {
-        const namespace = this.deps.requireNamespaceState();
-        const spaceName = slugifySpaceName('mission', input.title);
-        parseMissionSchedule(input.schedule);
-        parseMissionStartTime(input.startTime, this.deps.now());
-        await this.deps.getGuard().run({
-            action: 'mission.create',
-            actor: input.actorId,
-            target: `${this.deps.config.transport.scopeId}:${spaceName}`,
-            payload: { runtimeMode: input.runtimeMode, schedule: input.schedule, startTime: input.startTime ?? null },
-            execute: async () => undefined
-        });
-        const space = await this.deps.getGuard().run({
-            action: 'transport.space.create',
-            actor: input.actorId,
-            target: `${this.deps.config.transport.scopeId}:${spaceName}`,
-            execute: async () => await this.createRuntimeSpace(spaceName, namespace.missionsCategoryId)
-        });
-        let mission;
-        try {
-            mission = this.deps.missionRegistry.create({
-                scopeId: this.deps.config.transport.scopeId,
-                spaceId: space.id,
-                spaceName: space.name,
-                title: input.title,
-                goal: input.goal,
-                schedule: input.schedule,
-                ...(input.startTime ? { startTime: input.startTime } : {}),
-                runtimeMode: input.runtimeMode,
-                nowIso: this.deps.now()
-            });
-        }
-        catch (error) {
-            await this.deleteRuntimeSpace(space.id, 'best-effort');
-            throw error;
-        }
-        this.deps.appendAuditEvent('mission.created', {
-            missionId: mission.missionId,
-            spaceId: mission.spaceId,
-            runtimeMode: mission.runtimeMode,
-            actorId: input.actorId
-        });
-        return { mission, spaceId: space.id };
-    }
-    async adoptMissionChannel(input) {
-        await this.deps.getGuard().run({
-            action: 'mission.create',
-            actor: input.actorId,
-            target: `${this.deps.config.transport.scopeId}:${input.spaceName}`,
-            execute: async () => undefined
-        });
-        const mission = this.deps.missionRegistry.createDraft({
-            scopeId: this.deps.config.transport.scopeId,
-            spaceId: input.spaceId,
-            spaceName: input.spaceName,
-            title: input.spaceName,
-            runtimeMode: this.deps.config.defaults.runtimeMode,
-            nowIso: this.deps.now()
-        });
-        this.deps.appendAuditEvent('mission.adopted_from_transport', {
-            missionId: mission.missionId,
-            spaceId: mission.spaceId,
-            actorId: input.actorId
-        });
-        return mission;
-    }
-    async configureDraftMission(input) {
-        const mission = this.resolveMission({ spaceId: input.spaceId, missionId: input.missionId });
-        if (!mission) {
-            throw new Error('No matching mission found.');
-        }
-        if (mission.lifecycleStatus !== 'draft') {
-            throw new Error(`Mission ${mission.missionId} is not waiting for initial setup.`);
-        }
-        const goal = input.goal.trim();
-        const schedule = input.schedule.trim();
-        if (!goal) {
-            throw new Error('goal is required');
-        }
-        if (!schedule) {
-            throw new Error('schedule is required');
+    async deleteManagedSessionNow(input) {
+        const session = this.resolveManagedWorkerSession(input);
+        if (!session) {
+            return null;
         }
         await this.deps.getGuard().run({
-            action: 'mission.create',
+            action: 'session.delete',
             actor: input.actorId,
-            target: mission.missionId,
+            target: session.sessionId,
             payload: {
-                schedule,
-                startTime: input.startTime ?? null,
-                runtimeMode: input.runtimeMode ?? mission.runtimeMode
+                deleteWorkspace: input.deleteWorkspace,
+                reason: input.reason ?? null
             },
             execute: async () => undefined
         });
-        const configured = this.deps.missionRegistry.configureDraftMission({
-            missionId: mission.missionId,
-            goal,
-            schedule,
-            ...(input.startTime ? { startTime: input.startTime } : {}),
-            ...(input.runtimeMode ? { runtimeMode: input.runtimeMode } : {}),
-            nowIso: this.deps.now()
-        });
-        this.deps.appendAuditEvent('mission.configured', {
-            missionId: configured.missionId,
-            spaceId: configured.spaceId,
-            actorId: input.actorId,
-            schedule: configured.scheduleText,
-            runtimeMode: configured.runtimeMode
-        });
-        return configured;
-    }
-    async archiveMission(input) {
-        const mission = this.resolveMission({ spaceId: input.spaceId, missionId: input.missionId });
-        if (!mission) {
-            return null;
+        this.deps.providerService.stopSession(session.threadId);
+        this.deps.providerDirectory.delete(session.threadId);
+        this.deps.rejectTurnWaitersForThread(session.threadId, input.reason ?? `Session ${session.sessionId} was deleted.`);
+        await this.deps.cleanupScopedSidecars('session', session.sessionId, `session ${session.sessionId} deleted`);
+        const deleted = input.deleteWorkspace
+            ? this.deps.sessionRegistry.delete(session.transportResourceId)
+            : this.deleteSessionStateOnly(session);
+        if (deleted) {
+            this.deps.appendAuditEvent('session.deleted', {
+                sessionId: deleted.sessionId,
+                transportResourceId: deleted.transportResourceId,
+                workspacePath: deleted.workspacePath,
+                actorId: input.actorId,
+                deleteWorkspace: input.deleteWorkspace,
+                reason: input.reason ?? null
+            });
         }
-        const currentMission = this.deps.missionRegistry.getById(mission.missionId);
-        if (!currentMission) {
+        return deleted;
+    }
+    async resumeManagedSession(input) {
+        const session = this.resolveManagedWorkerSession(input);
+        if (!session) {
             return null;
         }
-        if (currentMission.archivedAt) {
-            return currentMission;
+        if (session.lifecycleStatus !== 'archived' && session.lifecycleStatus !== 'cool') {
+            return session;
         }
-        const namespace = this.deps.requireNamespaceState();
         await this.deps.getGuard().run({
-            action: 'mission.archive',
+            action: 'session.resume',
             actor: input.actorId,
-            target: currentMission.missionId,
+            target: session.sessionId,
+            payload: { reason: input.reason ?? null },
             execute: async () => undefined
         });
-        await this.deps.getGuard().run({
-            action: 'transport.space.update',
-            actor: input.actorId,
-            target: currentMission.spaceId,
-            execute: async () => this.deps.getTransport().updateSpace?.({
-                scopeId: this.deps.config.transport.scopeId,
-                spaceId: currentMission.spaceId,
-                parentId: namespace.archiveCategoryId
-            })
-        });
-        this.deps.providerService.stopSession(currentMission.threadId);
-        this.deps.providerDirectory.delete(currentMission.threadId);
-        this.deps.rejectTurnWaitersForThread(currentMission.threadId, `Mission ${currentMission.missionId} was archived.`);
-        const archivedAt = this.deps.now();
-        const archived = this.deps.missionRegistry.update({
-            ...currentMission,
-            lifecycleStatus: 'stopped',
-            pausedAt: null,
-            nextRunAt: null,
-            stoppedAt: currentMission.stoppedAt ?? archivedAt,
-            archivedAt,
-            updatedAt: archivedAt
-        });
-        this.deps.appendAuditEvent('mission.archived', {
-            missionId: archived.missionId,
-            spaceId: archived.spaceId,
-            actorId: input.actorId
-        });
-        return archived;
-    }
-    async deleteArchivedMission(input) {
-        const mission = this.resolveMission({ spaceId: input.spaceId, missionId: input.missionId });
-        if (!mission || !mission.archivedAt) {
-            return null;
-        }
-        return await this.deps.queue(`mission:${mission.missionId}`, async () => {
-            const currentMission = this.deps.missionRegistry.getById(mission.missionId);
-            if (!currentMission || !currentMission.archivedAt) {
-                return null;
-            }
-            await this.deps.getGuard().run({
-                action: 'mission.delete',
-                actor: input.actorId,
-                target: currentMission.missionId,
-                execute: async () => undefined
-            });
-            await this.deps.getGuard().run({
-                action: 'transport.space.delete',
-                actor: input.actorId,
-                target: currentMission.spaceId,
-                execute: async () => await this.deleteRuntimeSpace(currentMission.spaceId, 'strict')
+        const resumed = this.deps.sessionRegistry.resume(session.transportResourceId, this.deps.now());
+        if (resumed) {
+            this.deps.appendAuditEvent('session.resumed', {
+                sessionId: resumed.sessionId,
+                transportResourceId: resumed.transportResourceId,
+                actorId: input.actorId,
+                reason: input.reason ?? null
             });
-            this.deps.providerService.stopSession(currentMission.threadId);
-            this.deps.providerDirectory.delete(currentMission.threadId);
-            this.deps.rejectTurnWaitersForThread(currentMission.threadId, `Mission ${currentMission.missionId} was deleted.`);
-            const deleted = this.deps.missionRegistry.deleteArchived(currentMission.spaceId);
-            if (deleted) {
-                this.deps.appendAuditEvent('mission.deleted', {
-                    missionId: deleted.missionId,
-                    spaceId: deleted.spaceId,
-                    workspacePath: deleted.workspacePath,
-                    actorId: input.actorId
-                });
-            }
-            return deleted;
-        });
+        }
+        return resumed;
     }
-    async archiveChannelTarget(input) {
-        const target = this.resolveArchivableChannelTarget(input.spaceId);
+    async archiveResourceTarget(input) {
+        const target = this.resolveArchivableResourceTarget(input.transportResourceId);
         if (!target) {
             return null;
         }
         if (target.kind === 'session') {
             const session = await this.archiveManagedSession({
                 actorId: input.actorId,
-                spaceId: target.session.spaceId,
+                transportResourceId: target.session.transportResourceId,
                 sessionId: target.session.sessionId
             });
             return session ? { kind: 'session', session } : null;
         }
-        const mission = await this.archiveMission({
-            actorId: input.actorId,
-            spaceId: target.mission.spaceId,
-            missionId: target.mission.missionId
-        });
-        return mission ? { kind: 'mission', mission } : null;
+        return null;
     }
-    async deleteArchivedChannelTarget(input) {
-        const target = this.resolveArchivableChannelTarget(input.spaceId);
+    async deleteArchivedResourceTarget(input) {
+        const target = this.resolveArchivableResourceTarget(input.transportResourceId);
         if (!target) {
             return null;
         }
         if (target.kind === 'session') {
             const session = await this.deleteManagedSession({
                 actorId: input.actorId,
-                spaceId: target.session.spaceId,
+                transportResourceId: target.session.transportResourceId,
                 sessionId: target.session.sessionId
             });
             return session ? { kind: 'session', session } : null;
         }
-        const mission = await this.deleteArchivedMission({
-            actorId: input.actorId,
-            spaceId: target.mission.spaceId,
-            missionId: target.mission.missionId
-        });
-        return mission ? { kind: 'mission', mission } : null;
-    }
-    async updateMissionLifecycle(actorId, input, action) {
-        const mission = this.resolveMission(input);
-        if (!mission) {
-            return null;
-        }
-        await this.deps.getGuard().run({
-            action: 'mission.control',
-            actor: actorId,
-            target: mission.missionId,
-            execute: async () => undefined
-        });
-        const nowIso = this.deps.now();
-        if (mission.lifecycleStatus === 'draft') {
-            throw new Error(`Mission ${mission.missionId} still needs goal and schedule setup before lifecycle controls are available.`);
-        }
-        if (action === 'pause') {
-            if (mission.archivedAt) {
-                throw new Error(`Mission ${mission.missionId} is archived and cannot be paused.`);
-            }
-            if (mission.lifecycleStatus === 'active' || mission.lifecycleStatus === 'waiting_on_user') {
-                throw new Error(`Mission ${mission.missionId} is busy. Stop it before pausing.`);
-            }
-            return this.deps.missionRegistry.update({
-                ...mission,
-                pausedAt: nowIso,
-                lifecycleStatus: 'sleeping',
-                updatedAt: nowIso
-            });
-        }
-        if (mission.archivedAt) {
-            throw new Error(`Mission ${mission.missionId} is archived and cannot be resumed.`);
-        }
-        if (action === 'resume') {
-            if (mission.lifecycleStatus === 'stopped' && mission.stoppedAt) {
-                throw new Error(`Mission ${mission.missionId} is stopped and cannot be resumed.`);
-            }
-            const resumedNextRunAt = this.deps.missionRegistry.runAtOrAfter(mission, nowIso);
-            const resumedOneShotComplete = this.deps.missionRegistry.isOneShotSchedule(mission) && !resumedNextRunAt;
-            return this.deps.missionRegistry.update({
-                ...mission,
-                pausedAt: null,
-                lifecycleStatus: resumedOneShotComplete ? 'completed' : 'sleeping',
-                nextRunAt: resumedNextRunAt,
-                completedAt: resumedOneShotComplete ? nowIso : mission.completedAt,
-                updatedAt: nowIso
-            });
-        }
-        this.deps.providerService.stopSession(mission.threadId);
-        return this.deps.missionRegistry.update({
-            ...mission,
-            pausedAt: null,
-            lifecycleStatus: 'stopped',
-            stoppedAt: nowIso,
-            nextRunAt: null,
-            updatedAt: nowIso
-        });
+        return null;
     }
     resolveSession(input) {
         return ((input.sessionId ? this.deps.sessionRegistry.list().find((entry) => entry.sessionId === input.sessionId) : null) ??
-            (input.spaceId ? this.deps.sessionRegistry.getBySpaceId(input.spaceId) : null));
+            (input.transportResourceId ? this.deps.sessionRegistry.getByTransportResourceId(input.transportResourceId) : null));
     }
     resolveManagedWorkerSession(input) {
         const session = this.resolveSession(input);
         return session && isManagedWorkerSession(session) ? session : null;
     }
-    resolveArchivableChannelTarget(spaceId) {
-        const session = this.resolveManagedWorkerSession({ spaceId });
+    resolveArchivableResourceTarget(transportResourceId) {
+        const session = this.resolveManagedWorkerSession({ transportResourceId });
         if (session) {
             return { kind: 'session', session };
         }
-        const mission = this.deps.missionRegistry.getBySpaceId(spaceId);
-        if (mission) {
-            return { kind: 'mission', mission };
-        }
         return null;
     }
+    deleteSessionStateOnly(session) {
+        return this.deps.sessionRegistry.deleteRecordOnly(session.transportResourceId) ?? session;
+    }
     enqueueInitialManagedSessionKickoff(input) {
-        void this.deps.queue(input.spaceId, async () => {
+        void this.deps.queue(input.transportResourceId, async () => {
             try {
                 await this.directManagedSession({
                     actorId: input.actorId,
@@ -573,7 +389,7 @@ export class RuntimeWorkManagementService {
                 if (session) {
                     try {
                         await this.deps.sendStatusUpdate({
-                            text: `Initial kickoff failed for ${session.sessionId} in space ${session.spaceId}: ${message}`
+                            text: `Initial kickoff failed for ${session.sessionId} in transport resource ${session.transportResourceId}: ${message}`
                         });
                     }
                     catch (statusError) {
@@ -588,31 +404,33 @@ export class RuntimeWorkManagementService {
             }
         });
     }
-    async createRuntimeSpace(name, parentId) {
+    async createRuntimeTransportResource(actor, name, parentId) {
         const transport = this.deps.getTransport();
-        if (!transport.capabilities().spaces.create || !transport.createSpace) {
-            throw new Error('Managed space creation requires transport support for spaces.create. Configure a transport with managed space creation or disable managed sessions/missions.');
+        if (!transport.capabilities().resources.create) {
+            throw new Error('Managed resource creation requires transport support for resources.create. Configure a transport with managed resource creation or disable managed sessions.');
         }
-        return await transport.createSpace({
+        return await this.deps.effects().createResource(actor, {
             scopeId: this.deps.config.transport.scopeId,
             name,
-            kind: 'room',
-            metadata: buildManagedSpaceMetadata({
+            kind: 'conversation',
+            metadata: buildManagedTransportResourceMetadata({
                 scopeId: this.deps.config.transport.scopeId,
-                applicationId: this.deps.config.transport.applicationId
+                ...(typeof this.deps.config.transport.config.applicationId === 'string'
+                    ? { ownerApplicationId: this.deps.config.transport.config.applicationId }
+                    : {})
             }),
             parentId
         });
     }
-    async deleteRuntimeSpace(spaceId, mode) {
+    async deleteRuntimeTransportResource(transportResourceId, mode) {
         const transport = this.deps.getTransport();
-        if (!transport.capabilities().spaces.delete || !transport.deleteSpace) {
+        if (!transport.capabilities().resources.delete) {
             return;
         }
         try {
-            await transport.deleteSpace({
+            await this.deps.effects().deleteResource('runtime:work-management', {
                 scopeId: this.deps.config.transport.scopeId,
-                spaceId: spaceId
+                transportResourceId: transportResourceId
             });
         }
         catch (error) {