@moorline/core 0.0.1 → 0.0.2

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

@@ -1,28 +1,24 @@
-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 surface = this.deps.requireSurfaceState();
         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,18 +27,19 @@ 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(transportResourceName, surface.sessionsCategoryId)
         });
         let session;
+        let recoveredFromLifecycleRace = false;
         try {
             session = this.deps.reactor.createSession({
                 scopeId: this.deps.config.transport.scopeId,
-                spaceId: space.id,
-                spaceName: space.name,
+                transportResourceId: resource.id,
+                transportResourceName: resource.name,
                 requestedName: input.requestedName,
                 runtimeMode: input.runtimeMode,
                 nowIso: this.deps.now(),
@@ -55,19 +52,31 @@ export class RuntimeWorkManagementService {
         }
         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 adoption already persisted the session for this new resource, reuse it.
+            const adopted = this.deps.sessionRegistry.getByTransportResourceId(resource.id);
             if (adopted) {
-                session = adopted;
+                recoveredFromLifecycleRace = adopted.createdBy === 'runtime:transport/resource-lifecycle';
+                session = this.deps.sessionRegistry.updateSession({
+                    ...adopted,
+                    runtimeMode: input.runtimeMode,
+                    providerAutoStartEnabled: this.deps.getProviderAutoStartDefault(),
+                    ownerKind: owner.kind,
+                    ownerId: owner.id,
+                    ownerLabel: owner.label,
+                    objective: objective ?? adopted.objective,
+                    tags: input.tags ?? adopted.tags ?? [],
+                    createdBy: input.actorId,
+                    updatedAt: this.deps.now()
+                });
             }
             else {
-                await this.deleteRuntimeSpace(space.id, 'best-effort');
+                await this.deleteRuntimeTransportResource(resource.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 +84,16 @@ export class RuntimeWorkManagementService {
             tags: session.tags ?? [],
             actorId: input.actorId
         });
-        if (session.createdBy === 'runtime:transport/space-lifecycle') {
+        if (recoveredFromLifecycleRace) {
             this.deps.appendAuditEvent('session.created.race_recovered', {
                 sessionId: session.sessionId,
-                spaceId: session.spaceId,
+                transportResourceId: session.transportResourceId,
                 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 +119,24 @@ 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 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 +157,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 +178,13 @@ export class RuntimeWorkManagementService {
         if (!session) {
             return null;
         }
-        const namespace = this.deps.requireNamespaceState();
+        const surface = this.deps.requireSurfaceState();
         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 +195,36 @@ export class RuntimeWorkManagementService {
             lifecycleStatus: 'archived',
             archivedAt: nowIso,
             providerThreadId: null,
-            resumeThreadId: null,
+            resumeCursor: null,
             providerStatus: 'closed',
             activeTurnId: null,
             updatedAt: nowIso
         });
+        await this.deps.getGuard().run({
+            action: 'transport.resource.update',
+            actor: input.actorId,
+            target: session.transportResourceId,
+            execute: async () => {
+                try {
+                    await this.deps.getTransport().updateTransportResource?.({
+                        scopeId: this.deps.config.transport.scopeId,
+                        transportResourceId: session.transportResourceId,
+                        parentId: surface.archiveCategoryId
+                    });
+                }
+                catch (error) {
+                    this.deps.appendAuditEvent('session.archive.transport_update_failed', {
+                        sessionId: session.sessionId,
+                        transportResourceId: session.transportResourceId,
+                        actorId: input.actorId,
+                        error: error instanceof Error ? error.message : String(error)
+                    });
+                }
+            }
+        });
         this.deps.appendAuditEvent('session.archived', {
             sessionId: archived.sessionId,
-            spaceId: archived.spaceId,
+            transportResourceId: archived.transportResourceId,
             actorId: input.actorId
         });
         return archived;
@@ -220,340 +241,73 @@ 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');
-        }
-        await this.deps.getGuard().run({
-            action: 'mission.create',
-            actor: input.actorId,
-            target: mission.missionId,
-            payload: {
-                schedule,
-                startTime: input.startTime ?? null,
-                runtimeMode: input.runtimeMode ?? mission.runtimeMode
-            },
-            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;
-        }
-        const currentMission = this.deps.missionRegistry.getById(mission.missionId);
-        if (!currentMission) {
-            return null;
-        }
-        if (currentMission.archivedAt) {
-            return currentMission;
-        }
-        const namespace = this.deps.requireNamespaceState();
-        await this.deps.getGuard().run({
-            action: 'mission.archive',
-            actor: input.actorId,
-            target: currentMission.missionId,
-            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')
-            });
-            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;
-        });
-    }
-    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;
     }
     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 +327,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 +342,33 @@ export class RuntimeWorkManagementService {
             }
         });
     }
-    async createRuntimeSpace(name, parentId) {
+    async createRuntimeTransportResource(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 || !transport.createTransportResource) {
+            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 transport.createTransportResource({
             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 || !transport.deleteTransportResource) {
             return;
         }
         try {
-            await transport.deleteSpace({
+            await transport.deleteTransportResource({
                 scopeId: this.deps.config.transport.scopeId,
-                spaceId: spaceId
+                transportResourceId: transportResourceId
             });
         }
         catch (error) {