@moorline/core 0.0.1 → 0.0.2

package/dist/core/runtime/execution/runtimePluginContextService.js

@@ -1,5 +1,8 @@
+import { randomUUID } from 'node:crypto';
+import { join } from 'node:path';
 import { usesProviderDefaultModel } from '../../../types/config.js';
 import { saveMoorlineConfig } from '../../system/config/configStore.js';
+import { writeSkill } from '../../extension/skills/skillWriter.js';
 import { parseRuntimeModeName } from '../../../types/runtime.js';
 import { refreshMemoryIndex, retrieveFromMemoryWithSQLite } from '../../domain/memory/retrieval.js';
 import { recordHistoryCheckpoint } from '../../system/vcs/gitCheckpointService.js';
@@ -7,6 +10,7 @@ import { createPluginContextCapabilities } from './pluginContext/pluginContextFa
 import { describeTransportAuthor } from './pluginContext/transportAuthor.js';
 import { toPluginPackageId } from '../../extension/plugins/pluginId.js';
 import { normalizeAndValidateDefaultModel } from './defaultModelSelection.js';
+import { computePackageJobRunAtOrAfterWithMeta, packageScheduleMetaToJson, parsePackageSchedule, parsePackageScheduleStartTime } from '../../shared/scheduling/packageSchedule.js';
 export { defaultSessionOwner } from './pluginContext/defaultSessionOwner.js';
 export class RuntimePluginContextService {
     deps;
@@ -43,6 +47,103 @@ export class RuntimePluginContextService {
         const providerId = this.deps.config.provider.packageId ?? this.deps.config.provider.kind;
         return `provider:${providerId}:${threadId}:${suffix}`;
     }
+    contextPackageId(actorId) {
+        return actorId.startsWith('plugin:') ? actorId.slice('plugin:'.length) : actorId;
+    }
+    packageState(valueJson) {
+        try {
+            return JSON.parse(valueJson);
+        }
+        catch {
+            return null;
+        }
+    }
+    validateStructuredOutput(value, schema) {
+        if (!schema || typeof schema !== 'object' || Array.isArray(schema)) {
+            return;
+        }
+        const record = schema;
+        if (record.type === 'object' && (!value || typeof value !== 'object' || Array.isArray(value))) {
+            throw new Error('Headless run output must be a JSON object.');
+        }
+        const objectValue = value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+        if (Array.isArray(record.required)) {
+            for (const key of record.required) {
+                if (typeof key === 'string' && objectValue[key] === undefined) {
+                    throw new Error(`Headless run output is missing required field: ${key}.`);
+                }
+            }
+        }
+        const properties = record.properties && typeof record.properties === 'object' && !Array.isArray(record.properties)
+            ? record.properties
+            : {};
+        for (const [key, property] of Object.entries(properties)) {
+            const expected = property.type;
+            const actual = objectValue[key];
+            if (actual === undefined || typeof expected !== 'string') {
+                continue;
+            }
+            const ok = expected === 'array'
+                ? Array.isArray(actual)
+                : expected === 'object'
+                    ? actual !== null && typeof actual === 'object' && !Array.isArray(actual)
+                    : typeof actual === expected;
+            if (!ok) {
+                throw new Error(`Headless run output field ${key} must be ${expected}.`);
+            }
+        }
+    }
+    transitionWorkItem(actorId, workItemId, update) {
+        const current = this.requireOwnedWorkItem(actorId, workItemId);
+        const nowIso = this.deps.now();
+        const updated = this.deps.store.updateWorkItem(update(current, nowIso));
+        this.deps.appendAuditEvent('work_item.updated', {
+            actorId,
+            packageId: updated.packageId,
+            workItemId: updated.workItemId,
+            queue: updated.queue,
+            status: updated.status
+        });
+        this.deps.recordRuntimeActivity({
+            ...this.activityTargetForSession(updated.sessionId, 'runtime:work'),
+            sourceEventId: randomUUID(),
+            kind: `work_item.${updated.status}`,
+            severity: updated.status === 'failed' || updated.status === 'dead_lettered' ? 'error' : 'info',
+            title: `Work item ${updated.status}`,
+            detail: `${updated.packageId}/${updated.queue}/${updated.workItemId}`,
+            createdAt: nowIso
+        });
+        return updated;
+    }
+    requireOwnedWorkItem(actorId, workItemId) {
+        const record = this.deps.store.getWorkItem(workItemId);
+        if (!record) {
+            throw new Error(`Unknown work item: ${workItemId}`);
+        }
+        const packageId = this.contextPackageId(actorId);
+        if (record.packageId !== packageId) {
+            throw new Error(`Work item ${workItemId} is owned by ${record.packageId}, not ${packageId}.`);
+        }
+        return record;
+    }
+    requireSession(sessionId) {
+        const session = this.deps.store.getSession(sessionId);
+        if (!session) {
+            throw new Error(`Unknown session: ${sessionId}`);
+        }
+        return session;
+    }
+    activityTargetForSession(sessionId, fallbackThreadId) {
+        if (!sessionId) {
+            return { threadId: fallbackThreadId, sessionId: null, transportResourceId: null };
+        }
+        const session = this.deps.store.getSession(sessionId);
+        return {
+            threadId: session?.threadId ?? fallbackThreadId,
+            sessionId,
+            transportResourceId: session?.transportResourceId ?? null
+        };
+    }
     createContext(actorId) {
         const capabilities = createPluginContextCapabilities({
             actorId,
@@ -63,66 +164,329 @@ export class RuntimePluginContextService {
             config: this.deps.config,
             getAdminConfig: () => capabilities.admin.getAdminConfig(),
             isAdminActor: (input) => this.deps.isAdminActor(input),
-            getNamespaceState: () => this.deps.requireNamespaceState(),
-            getCurrentSpaceId: () => this.deps.getNamespaceState()?.chatChannelId ?? this.deps.config.transport.scopeId,
-            getCurrentThreadId: () => `chat:${this.deps.getNamespaceState()?.chatChannelId ?? this.deps.config.transport.scopeId}`,
-            getCurrentWorkspacePath: () => this.deps.chatWorkspacePath,
-            getChatWorkspacePath: () => this.deps.chatWorkspacePath,
+            getSurfaceState: () => this.deps.requireSurfaceState(),
+            getCurrentTransportResourceId: () => this.deps.getSurfaceState()?.coordinationResourceId ?? this.deps.config.transport.scopeId,
+            getCurrentThreadId: () => `coordination:${this.deps.getSurfaceState()?.coordinationResourceId ?? this.deps.config.transport.scopeId}`,
+            getCurrentWorkspacePath: () => this.deps.coordinationWorkspacePath,
+            getCoordinationWorkspacePath: () => this.deps.coordinationWorkspacePath,
+            getRuntimeRootPath: () => this.deps.runtimeRoot,
             listSkills: () => capabilities.memory.listSkills(),
             loadSkill: async (name) => await capabilities.memory.loadSkill(name),
             writeSkill: async (input) => await capabilities.memory.writeSkill(input),
             listSessions: () => this.deps.snapshots.listSessions().map((entry) => entry.session),
-            getSessionBySpaceId: (spaceId) => this.deps.snapshots.getSessionBySpaceId(spaceId)?.session ?? null,
+            getSessionByTransportResourceId: (transportResourceId) => this.deps.snapshots.getSessionByTransportResourceId(transportResourceId)?.session ?? null,
             getSessionById: (sessionId) => this.deps.snapshots.getSessionById(sessionId)?.session ?? null,
-            listMissions: () => this.deps.missionRegistry.list(),
-            getMissionBySpaceId: (spaceId) => this.deps.missionRegistry.getBySpaceId(spaceId),
-            getMissionById: (missionId) => this.deps.missionRegistry.getById(missionId),
-            listMissionRuns: (missionId, limit) => this.deps.missionRegistry.listRuns(missionId, limit),
-            listMissionHookBindings: (filter) => this.deps.missionHooks.listBindings({
-                ...(filter?.missionId ? { missionId: filter.missionId } : {}),
-                ...(filter?.hookKey ? { hookKey: filter.hookKey } : {})
+            getPackageState: (key) => {
+                const row = this.deps.store.getPackageState(this.contextPackageId(actorId), key);
+                return row ? this.packageState(row.valueJson) : null;
+            },
+            putPackageState: async (key, value) => await this.deps.runGuardedAction({
+                action: 'package.state.write',
+                actor: actorId,
+                target: `${this.contextPackageId(actorId)}:${key}`,
+                title: 'Package state write blocked',
+                execute: async () => {
+                    this.deps.store.putPackageState({
+                        packageId: this.contextPackageId(actorId),
+                        key,
+                        valueJson: JSON.stringify(value),
+                        updatedAt: this.deps.now()
+                    });
+                }
             }),
-            bindMissionHook: ({ missionId, hookKey, condition }) => this.deps.runGuardedAction({
-                action: 'mission.control',
+            deletePackageState: async (key) => await this.deps.runGuardedAction({
+                action: 'package.state.write',
                 actor: actorId,
-                target: missionId,
-                payload: { hookKey, hasCondition: Boolean(condition) },
-                title: 'Mission hook binding blocked',
-                execute: async () => this.deps.missionHooks.bind({
-                    actorId,
-                    missionId,
-                    hookKey,
-                    ...(condition ? { condition } : {})
-                })
+                target: `${this.contextPackageId(actorId)}:${key}`,
+                title: 'Package state delete blocked',
+                execute: async () => {
+                    this.deps.store.deletePackageState(this.contextPackageId(actorId), key);
+                }
             }),
-            unbindMissionHook: ({ bindingId }) => this.deps.runGuardedAction({
-                action: 'mission.control',
+            listPackageState: (prefix) => this.deps.store.listPackageState(this.contextPackageId(actorId), prefix).map((row) => ({
+                packageId: row.packageId,
+                key: row.key,
+                value: this.packageState(row.valueJson),
+                updatedAt: row.updatedAt
+            })),
+            schedulePackageJob: async ({ jobId, actionId, schedule, startTime, payload }) => await this.deps.runGuardedAction({
+                action: 'package.job.manage',
                 actor: actorId,
-                target: bindingId,
-                title: 'Mission hook binding removal blocked',
-                execute: async () => this.deps.missionHooks.unbind({
-                    actorId,
-                    bindingId
-                })
+                target: `${this.contextPackageId(actorId)}:${jobId}`,
+                payload: { actionId, schedule },
+                title: 'Package job schedule blocked',
+                execute: async () => {
+                    const nowIso = this.deps.now();
+                    const parsed = parsePackageSchedule(schedule);
+                    const anchor = parsePackageScheduleStartTime(startTime, nowIso);
+                    const nextRunAt = computePackageJobRunAtOrAfterWithMeta(anchor, parsed.cadenceMinutes, nowIso, parsed.meta);
+                    const row = {
+                        packageId: this.contextPackageId(actorId),
+                        jobId,
+                        actionId,
+                        schedule: parsed.normalized,
+                        scheduleAnchorAt: anchor,
+                        cadenceMinutes: parsed.cadenceMinutes,
+                        scheduleMetaJson: packageScheduleMetaToJson(parsed.meta),
+                        payloadJson: JSON.stringify(payload ?? {}),
+                        nextRunAt,
+                        createdAt: this.deps.store.getPackageJob(this.contextPackageId(actorId), jobId)?.createdAt ?? nowIso,
+                        updatedAt: nowIso
+                    };
+                    this.deps.store.upsertPackageJob(row);
+                    return {
+                        packageId: row.packageId,
+                        jobId: row.jobId,
+                        actionId: row.actionId,
+                        schedule: row.schedule,
+                        scheduleAnchorAt: row.scheduleAnchorAt,
+                        nextRunAt: row.nextRunAt,
+                        payload: payload ?? {},
+                        createdAt: row.createdAt,
+                        updatedAt: row.updatedAt
+                    };
+                }
             }),
-            emitMissionHook: ({ hookKey, payload, source }) => this.deps.runGuardedAction({
-                action: 'mission.control',
+            cancelPackageJob: async (jobId) => await this.deps.runGuardedAction({
+                action: 'package.job.manage',
                 actor: actorId,
-                target: hookKey,
-                payload: { source: source ?? actorId, payloadKeys: Object.keys(payload ?? {}) },
-                title: 'Mission hook trigger blocked',
-                execute: async () => await this.deps.missionHooks.emit({
-                    actorId,
-                    hookKey,
-                    ...(payload ? { payload } : {}),
-                    ...(source ? { source } : {})
+                target: `${this.contextPackageId(actorId)}:${jobId}`,
+                title: 'Package job cancel blocked',
+                execute: async () => {
+                    const row = this.deps.store.deletePackageJob(this.contextPackageId(actorId), jobId);
+                    return row
+                        ? {
+                            packageId: row.packageId,
+                            jobId: row.jobId,
+                            actionId: row.actionId,
+                            schedule: row.schedule,
+                            scheduleAnchorAt: row.scheduleAnchorAt,
+                            nextRunAt: row.nextRunAt,
+                            payload: this.packageState(row.payloadJson) ?? {},
+                            createdAt: row.createdAt,
+                            updatedAt: row.updatedAt
+                        }
+                        : null;
+                }
+            }),
+            listPackageJobs: () => this.deps.store.listPackageJobs(this.contextPackageId(actorId)).map((row) => ({
+                packageId: row.packageId,
+                jobId: row.jobId,
+                actionId: row.actionId,
+                schedule: row.schedule,
+                scheduleAnchorAt: row.scheduleAnchorAt,
+                nextRunAt: row.nextRunAt,
+                payload: this.packageState(row.payloadJson) ?? {},
+                createdAt: row.createdAt,
+                updatedAt: row.updatedAt
+            })),
+            enqueueWorkItem: async ({ queue, workItemId, idempotencyKey, externalResource, payload, priority, runAfter, maxAttempts }) => await this.deps.runGuardedAction({
+                action: 'package.work.manage',
+                actor: actorId,
+                target: `${this.contextPackageId(actorId)}:${queue}`,
+                payload: { idempotencyKey, externalResource },
+                title: 'Package work enqueue blocked',
+                execute: async () => {
+                    const packageId = this.contextPackageId(actorId);
+                    const normalizedQueue = queue.trim();
+                    if (!normalizedQueue) {
+                        throw new Error('Work item queue is required.');
+                    }
+                    const nowIso = this.deps.now();
+                    if (externalResource) {
+                        this.deps.store.upsertExternalResource({ ...externalResource, nowIso });
+                    }
+                    const record = this.deps.store.enqueueWorkItem({
+                        workItemId: workItemId?.trim() || randomUUID(),
+                        packageId,
+                        queue: normalizedQueue,
+                        status: 'queued',
+                        priority: Number.isFinite(priority) ? Math.trunc(priority ?? 0) : 0,
+                        ...(idempotencyKey ? { idempotencyKey } : {}),
+                        ...(externalResource ? { externalResource } : {}),
+                        payload: payload ?? {},
+                        attempts: 0,
+                        maxAttempts: Math.max(1, Math.trunc(maxAttempts ?? 3)),
+                        runAfter: runAfter ?? null,
+                        leaseOwner: null,
+                        leaseExpiresAt: null,
+                        lastError: null,
+                        createdAt: nowIso,
+                        updatedAt: nowIso,
+                        completedAt: null
+                    });
+                    this.deps.appendAuditEvent('work_item.enqueued', {
+                        actorId,
+                        packageId,
+                        workItemId: record.workItemId,
+                        queue: record.queue,
+                        idempotencyKey: record.idempotencyKey
+                    });
+                    this.deps.recordRuntimeActivity({
+                        threadId: 'runtime:work',
+                        sessionId: null,
+                        transportResourceId: null,
+                        sourceEventId: randomUUID(),
+                        kind: 'work_item.queued',
+                        severity: 'info',
+                        title: 'Work item queued',
+                        detail: `${record.packageId}/${record.queue}/${record.workItemId}`,
+                        createdAt: nowIso
+                    });
+                    return record;
+                }
+            }),
+            claimWorkItem: async ({ queue, leaseSeconds, leaseOwner }) => await this.deps.runGuardedAction({
+                action: 'package.work.manage',
+                actor: actorId,
+                target: `${this.contextPackageId(actorId)}:${queue}`,
+                title: 'Package work claim blocked',
+                execute: async () => {
+                    const now = new Date(this.deps.now());
+                    const leaseMs = Math.max(1, leaseSeconds ?? 300) * 1000;
+                    const claimed = this.deps.store.claimWorkItem({
+                        packageId: this.contextPackageId(actorId),
+                        queue,
+                        leaseOwner: leaseOwner?.trim() || actorId,
+                        leaseExpiresAt: new Date(now.getTime() + leaseMs).toISOString(),
+                        nowIso: now.toISOString()
+                    });
+                    if (claimed) {
+                        this.deps.appendAuditEvent('work_item.claimed', {
+                            actorId,
+                            packageId: claimed.packageId,
+                            workItemId: claimed.workItemId,
+                            queue: claimed.queue,
+                            attempts: claimed.attempts
+                        });
+                        this.deps.recordRuntimeActivity({
+                            ...this.activityTargetForSession(claimed.sessionId, 'runtime:work'),
+                            sourceEventId: randomUUID(),
+                            kind: 'work_item.claimed',
+                            severity: 'info',
+                            title: 'Work item claimed',
+                            detail: `${claimed.packageId}/${claimed.queue}/${claimed.workItemId}`,
+                            createdAt: now.toISOString()
+                        });
+                    }
+                    return claimed;
+                }
+            }),
+            completeWorkItem: async ({ workItemId, phase }) => await this.deps.runGuardedAction({
+                action: 'package.work.manage',
+                actor: actorId,
+                target: workItemId,
+                title: 'Package work complete blocked',
+                execute: async () => this.transitionWorkItem(actorId, workItemId, (current, nowIso) => ({
+                    ...current,
+                    status: 'completed',
+                    ...(phase ? { phase } : {}),
+                    leaseOwner: null,
+                    leaseExpiresAt: null,
+                    lastError: null,
+                    updatedAt: nowIso,
+                    completedAt: nowIso
+                }))
+            }),
+            failWorkItem: async ({ workItemId, error, retryAfter, phase }) => await this.deps.runGuardedAction({
+                action: 'package.work.manage',
+                actor: actorId,
+                target: workItemId,
+                title: 'Package work fail blocked',
+                execute: async () => this.transitionWorkItem(actorId, workItemId, (current, nowIso) => {
+                    const shouldRetry = retryAfter !== undefined && current.attempts < current.maxAttempts;
+                    return {
+                        ...current,
+                        status: shouldRetry ? 'queued' : 'failed',
+                        ...(phase ? { phase } : {}),
+                        runAfter: shouldRetry ? retryAfter : current.runAfter,
+                        leaseOwner: null,
+                        leaseExpiresAt: null,
+                        lastError: error,
+                        updatedAt: nowIso,
+                        completedAt: shouldRetry ? null : nowIso
+                    };
                 })
             }),
-            listPendingRequests: (spaceId) => this.deps.store.listPendingRequestsBySpace(spaceId).filter((request) => request.status === 'open'),
+            deadLetterWorkItem: async ({ workItemId, reason, phase }) => await this.deps.runGuardedAction({
+                action: 'package.work.manage',
+                actor: actorId,
+                target: workItemId,
+                title: 'Package work dead-letter blocked',
+                execute: async () => this.transitionWorkItem(actorId, workItemId, (current, nowIso) => ({
+                    ...current,
+                    status: 'dead_lettered',
+                    ...(phase ? { phase } : {}),
+                    leaseOwner: null,
+                    leaseExpiresAt: null,
+                    lastError: reason,
+                    updatedAt: nowIso,
+                    completedAt: nowIso
+                }))
+            }),
+            updateWorkItem: async ({ workItemId, payload, phase, externalResource, sessionId }) => await this.deps.runGuardedAction({
+                action: 'package.work.manage',
+                actor: actorId,
+                target: workItemId,
+                title: 'Package work update blocked',
+                execute: async () => {
+                    if (sessionId) {
+                        this.requireSession(sessionId);
+                    }
+                    return this.transitionWorkItem(actorId, workItemId, (current, nowIso) => ({
+                        ...current,
+                        ...(payload ? { payload } : {}),
+                        ...(phase ? { phase } : {}),
+                        ...(externalResource ? { externalResource } : {}),
+                        ...(sessionId ? { sessionId } : {}),
+                        updatedAt: nowIso
+                    }));
+                }
+            }),
+            getWorkItem: (workItemId) => {
+                const record = this.deps.store.getWorkItem(workItemId);
+                return record?.packageId === this.contextPackageId(actorId) ? record : null;
+            },
+            listWorkItems: (filter) => this.deps.store.listWorkItems({
+                packageId: this.contextPackageId(actorId),
+                queue: filter?.queue,
+                status: filter?.status,
+                externalResource: filter?.externalResource,
+                limit: filter?.limit
+            }),
+            upsertExternalResource: async (input) => await this.deps.runGuardedAction({
+                action: 'package.work.manage',
+                actor: actorId,
+                target: `${input.provider}:${input.kind}:${input.id}`,
+                title: 'External resource update blocked',
+                execute: async () => this.deps.store.upsertExternalResource({ ...input, nowIso: this.deps.now() })
+            }),
+            listExternalResources: (filter) => this.deps.store.listExternalResources(filter),
+            bindSessionToExternalResource: async ({ sessionId, externalResource, relationship }) => await this.deps.runGuardedAction({
+                action: 'package.work.manage',
+                actor: actorId,
+                target: `${sessionId}:${externalResource.provider}:${externalResource.kind}:${externalResource.id}`,
+                title: 'Session resource binding blocked',
+                execute: async () => {
+                    this.requireSession(sessionId);
+                    this.deps.store.upsertExternalResource({ ...externalResource, nowIso: this.deps.now() });
+                    this.deps.store.bindSessionToExternalResource({
+                        sessionId,
+                        resource: externalResource,
+                        relationship: relationship?.trim() || 'source',
+                        nowIso: this.deps.now()
+                    });
+                }
+            }),
+            listSessionsForExternalResource: (resource) => {
+                const ids = new Set(this.deps.store.listSessionIdsForExternalResource(resource));
+                return this.deps.snapshots.listSessions().filter((snapshot) => ids.has(snapshot.session.sessionId));
+            },
+            listPendingRequests: (transportResourceId) => this.deps.store.listPendingRequestsByTransportResource(transportResourceId).filter((request) => request.status === 'open'),
             listRuntimeReceipts: () => this.deps.snapshots.overview().receipts,
             listProviderConnections: () => this.deps.snapshots.overview().providers,
             listRuntimeActivities: (threadId) => threadId ? this.deps.snapshots.getSessionByThreadId(threadId)?.recentActivities ?? [] : this.deps.activities.listRecent(25),
-            getSessionSnapshotBySpaceId: (spaceId) => this.deps.snapshots.getSessionBySpaceId(spaceId),
+            getSessionSnapshotByTransportResourceId: (transportResourceId) => this.deps.snapshots.getSessionByTransportResourceId(transportResourceId),
             getSessionSnapshotById: (sessionId) => this.deps.snapshots.getSessionById(sessionId),
             getRuntimeOverview: () => this.deps.snapshots.overview(),
             querySessions: (filter) => this.deps.snapshots.querySessions(filter),
@@ -167,40 +531,40 @@ export class RuntimePluginContextService {
             listDomainEvents: (threadId) => this.deps.store.listDomainEvents(threadId).map((row) => ({
                 eventId: row.eventId,
                 threadId: row.threadId,
-                spaceId: row.spaceId,
+                transportResourceId: row.transportResourceId,
                 sessionId: row.sessionId,
                 sourceProviderEventId: row.sourceProviderEventId,
                 createdAt: row.createdAt,
                 type: row.type,
                 payload: JSON.parse(row.payloadJson)
             })),
-            updateSessionSummary: async (spaceId, summary, nowIso) => {
-                this.deps.sessionRegistry.updateSummary(spaceId, summary, nowIso);
+            updateSessionSummary: async (transportResourceId, summary, nowIso) => {
+                this.deps.sessionRegistry.updateSummary(transportResourceId, summary, nowIso);
             },
-            retrieveMemory: async ({ query, scopeId, spaceId, threadId, maxResults, enableRerank }) => this.deps.runGuardedAction({
+            retrieveMemory: async ({ query, scopeId, transportResourceId, threadId, maxResults, enableRerank }) => this.deps.runGuardedAction({
                 action: 'memory.read',
                 actor: actorId,
-                target: spaceId ? `${scopeId}:${spaceId}:${threadId ?? 'root'}` : scopeId,
+                target: transportResourceId ? `${scopeId}:${transportResourceId}:${threadId ?? 'root'}` : scopeId,
                 payload: { query, maxResults, enableRerank },
                 title: 'Memory read blocked',
-                execute: async () => await retrieveFromMemoryWithSQLite(query, this.deps.runtimeRoot, { scopeId: scopeId, spaceId: spaceId, threadId: threadId ?? null, projectKey: 'default' }, this.deps.sqlitePath, { maxResults, enableRerank })
+                execute: async () => await retrieveFromMemoryWithSQLite(query, this.deps.runtimeRoot, { scopeId: scopeId, transportResourceId: transportResourceId, threadId: threadId ?? null, projectKey: 'default' }, this.deps.sqlitePath, { maxResults, enableRerank })
             }),
-            writeSessionMemory: async ({ scopeId, spaceId, threadId, kind, content, sourceRefs }) => {
+            writeSessionMemory: async ({ scopeId, transportResourceId, threadId, kind, content, sourceRefs }) => {
                 await this.deps.runGuardedAction({
                     action: kind === 'summary' ? 'memory.write' : 'fs.write',
                     actor: actorId,
-                    target: `${scopeId}:${spaceId}:${threadId ?? 'root'}:${kind}`,
+                    target: `${scopeId}:${transportResourceId}:${threadId ?? 'root'}:${kind}`,
                     payload: { sourceRefs },
                     title: 'Session memory write blocked',
                     execute: async () => this.deps.memoryStore.writeSessionRecord({
                         scopeId: scopeId,
-                        spaceId: spaceId,
+                        transportResourceId: transportResourceId,
                         threadId: threadId ?? null,
                         kind,
                         content,
                         sourceRefs
                     }).then(() => {
-                        void refreshMemoryIndex(this.deps.runtimeRoot, { scopeId: scopeId, spaceId: spaceId, threadId: threadId ?? null, projectKey: 'default' }, this.deps.sqlitePath);
+                        void refreshMemoryIndex(this.deps.runtimeRoot, { scopeId: scopeId, transportResourceId: transportResourceId, threadId: threadId ?? null, projectKey: 'default' }, this.deps.sqlitePath);
                     })
                 });
             },
@@ -228,7 +592,7 @@ export class RuntimePluginContextService {
                     })
                 });
             },
-            createSession: async ({ requestedName, runtimeMode, initialInstruction, objective, owner, tags }) => {
+            createSession: async ({ requestedName, runtimeMode, initialInstruction, objective, owner, tags, externalResource, workItemId }) => {
                 const safeRuntimeMode = parseRuntimeModeName(runtimeMode, 'runtime_mode');
                 const created = await this.deps.workManagement.createManagedSession({
                     actorId,
@@ -239,84 +603,189 @@ export class RuntimePluginContextService {
                     owner,
                     tags
                 });
-                return { session: created.session, spaceId: created.spaceId };
+                if (externalResource) {
+                    this.deps.store.upsertExternalResource({ ...externalResource, nowIso: this.deps.now() });
+                    this.deps.store.bindSessionToExternalResource({
+                        sessionId: created.session.sessionId,
+                        resource: externalResource,
+                        relationship: 'source',
+                        nowIso: this.deps.now()
+                    });
+                }
+                if (workItemId) {
+                    this.transitionWorkItem(actorId, workItemId, (current, nowIso) => ({
+                        ...current,
+                        sessionId: created.session.sessionId,
+                        ...(externalResource ? { externalResource } : {}),
+                        updatedAt: nowIso
+                    }));
+                }
+                return { session: created.session, transportResourceId: created.transportResourceId };
             },
-            directSession: async ({ sessionId, spaceId, instruction, reason }) => await this.deps.workManagement.directManagedSession({
+            runGate: async ({ gateId, command, args, cwd, required, workItemId, sessionId }) => await this.deps.runGuardedAction({
+                action: 'command.exec',
+                actor: actorId,
+                target: `${gateId}:${command}`,
+                payload: { args, cwd, required, workItemId, sessionId },
+                threadId: sessionId ? this.deps.store.getSession(sessionId)?.threadId : undefined,
+                title: 'Runtime gate blocked',
+                execute: async () => {
+                    if (!this.deps.commandRunner) {
+                        throw new Error('Runtime gates require a command runner.');
+                    }
+                    if (sessionId) {
+                        this.requireSession(sessionId);
+                    }
+                    if (workItemId) {
+                        this.requireOwnedWorkItem(actorId, workItemId);
+                    }
+                    const packageId = this.contextPackageId(actorId);
+                    const startedAt = this.deps.now();
+                    let gate = this.deps.store.upsertGateRun({
+                        gateRunId: randomUUID(),
+                        gateId,
+                        packageId,
+                        ...(workItemId ? { workItemId } : {}),
+                        ...(sessionId ? { sessionId } : {}),
+                        command,
+                        args: args ?? [],
+                        ...(cwd ? { cwd } : {}),
+                        required: required === true,
+                        status: 'running',
+                        exitCode: null,
+                        stdout: '',
+                        stderr: '',
+                        startedAt,
+                        completedAt: null
+                    });
+                    try {
+                        const result = await this.deps.commandRunner.run(command, args ?? [], cwd);
+                        gate = this.deps.store.upsertGateRun({
+                            ...gate,
+                            status: result.exitCode === 0 ? 'passed' : 'failed',
+                            exitCode: result.exitCode,
+                            stdout: result.stdout,
+                            stderr: result.stderr,
+                            completedAt: this.deps.now()
+                        });
+                        this.deps.appendAuditEvent(result.exitCode === 0 ? 'runtime.gate.passed' : 'runtime.gate.failed', {
+                            actorId,
+                            packageId,
+                            gateRunId: gate.gateRunId,
+                            gateId,
+                            workItemId,
+                            sessionId,
+                            exitCode: result.exitCode
+                        });
+                        this.deps.recordRuntimeActivity({
+                            ...this.activityTargetForSession(sessionId, 'runtime:gates'),
+                            sourceEventId: gate.gateRunId,
+                            kind: result.exitCode === 0 ? 'runtime.gate.passed' : 'runtime.gate.failed',
+                            severity: result.exitCode === 0 ? 'info' : 'error',
+                            title: result.exitCode === 0 ? 'Runtime gate passed' : 'Runtime gate failed',
+                            detail: `${gate.gateId}: ${gate.command} ${(gate.args ?? []).join(' ')}`.trim(),
+                            createdAt: gate.completedAt ?? this.deps.now()
+                        });
+                        return gate;
+                    }
+                    catch (error) {
+                        this.deps.store.upsertGateRun({
+                            ...gate,
+                            status: 'error',
+                            exitCode: null,
+                            stderr: error instanceof Error ? error.message : String(error),
+                            completedAt: this.deps.now()
+                        });
+                        this.deps.recordRuntimeActivity({
+                            ...this.activityTargetForSession(sessionId, 'runtime:gates'),
+                            sourceEventId: gate.gateRunId,
+                            kind: 'runtime.gate.error',
+                            severity: 'error',
+                            title: 'Runtime gate errored',
+                            detail: error instanceof Error ? error.message : String(error),
+                            createdAt: this.deps.now()
+                        });
+                        throw error;
+                    }
+                }
+            }),
+            runHeadless: async ({ requestedName, runtimeMode, prompt, objective, owner, tags, externalResource, workItemId, outputSchema, requireStructuredOutput }) => await this.deps.runGuardedAction({
+                action: 'provider.headless.run',
+                actor: actorId,
+                target: `${this.contextPackageId(actorId)}:${requestedName}`,
+                payload: { requestedName, runtimeMode, objective, owner, tags, externalResource, workItemId },
+                title: 'Headless provider run blocked',
+                execute: async () => {
+                    const context = this.createContext(actorId);
+                    // First-pass headless runs are session-backed, so provider execution uses the managed session workspace.
+                    const created = await context.createSession({
+                        requestedName,
+                        runtimeMode,
+                        objective,
+                        owner,
+                        tags,
+                        externalResource,
+                        workItemId
+                    });
+                    const reply = await context.runAgent({
+                        surface: 'session',
+                        transportResourceId: created.transportResourceId,
+                        actorId,
+                        actorLabel: this.contextPackageId(actorId),
+                        message: prompt,
+                        session: created.session,
+                        cwd: created.session.workspacePath,
+                        runtimeMode,
+                        context: {
+                            systemPromptSections: await this.loadSessionPromptSections(this.toInternalSessionRow(created.session))
+                        },
+                        promptSource: 'headless'
+                    });
+                    const text = reply.text ?? '';
+                    let parsedOutput;
+                    if (outputSchema || requireStructuredOutput) {
+                        try {
+                            parsedOutput = JSON.parse(text);
+                            this.validateStructuredOutput(parsedOutput, outputSchema);
+                        }
+                        catch (error) {
+                            if (requireStructuredOutput) {
+                                throw error;
+                            }
+                        }
+                    }
+                    return {
+                        session: created.session,
+                        reply,
+                        ...(parsedOutput !== undefined ? { parsedOutput } : {})
+                    };
+                }
+            }),
+            directSession: async ({ sessionId, transportResourceId, instruction, reason }) => await this.deps.workManagement.directManagedSession({
                 actorId,
                 sessionId,
-                spaceId: spaceId,
+                transportResourceId: transportResourceId,
                 instruction,
                 reason
             }),
-            archiveSession: async ({ spaceId, sessionId }) => await this.deps.workManagement.archiveManagedSession({
+            archiveSession: async ({ transportResourceId, sessionId }) => await this.deps.workManagement.archiveManagedSession({
                 actorId,
-                spaceId: spaceId,
+                transportResourceId: transportResourceId,
                 sessionId
             }),
-            deleteArchivedSession: async ({ spaceId, sessionId }) => await this.deps.workManagement.deleteManagedSession({
+            deleteArchivedSession: async ({ transportResourceId, sessionId }) => await this.deps.workManagement.deleteManagedSession({
                 actorId,
-                spaceId: spaceId,
+                transportResourceId: transportResourceId,
                 sessionId
             }),
-            archiveMission: async ({ spaceId, missionId }) => await this.deps.workManagement.archiveMission({
-                actorId,
-                spaceId: spaceId,
-                missionId
-            }),
-            deleteArchivedMission: async ({ spaceId, missionId }) => await this.deps.workManagement.deleteArchivedMission({
-                actorId,
-                spaceId: spaceId,
-                missionId
-            }),
-            archiveSpaceTarget: async ({ spaceId }) => await this.deps.workManagement.archiveChannelTarget({
+            archiveTransportResourceTarget: async ({ transportResourceId }) => await this.deps.workManagement.archiveResourceTarget({
                 actorId,
-                spaceId: spaceId
+                transportResourceId: transportResourceId
             }),
-            deleteArchivedSpaceTarget: async ({ spaceId }) => await this.deps.workManagement.deleteArchivedChannelTarget({
+            deleteArchivedTransportResourceTarget: async ({ transportResourceId }) => await this.deps.workManagement.deleteArchivedResourceTarget({
                 actorId,
-                spaceId: spaceId
+                transportResourceId: transportResourceId
             }),
-            createMission: async ({ title, goal, schedule, startTime, runtimeMode }) => {
-                const safeRuntimeMode = parseRuntimeModeName(runtimeMode, 'runtime_mode');
-                const created = await this.deps.workManagement.createMission({
-                    actorId,
-                    title,
-                    goal,
-                    schedule,
-                    startTime,
-                    runtimeMode: safeRuntimeMode
-                });
-                return { mission: created.mission, spaceId: created.spaceId };
-            },
-            pauseMission: async ({ spaceId, missionId }) => this.deps.workManagement.updateMissionLifecycle(actorId, { spaceId: spaceId, missionId }, 'pause'),
-            resumeMission: async ({ spaceId, missionId }) => this.deps.workManagement.updateMissionLifecycle(actorId, { spaceId: spaceId, missionId }, 'resume'),
-            stopMission: async ({ spaceId, missionId }) => this.deps.workManagement.updateMissionLifecycle(actorId, { spaceId: spaceId, missionId }, 'stop'),
-            runMissionNow: async ({ spaceId, missionId, requesterActorId }) => {
-                const mission = this.deps.workManagement.resolveMission({ spaceId, missionId });
-                if (!mission) {
-                    return null;
-                }
-                await this.deps.runGuardedAction({
-                    action: 'mission.control',
-                    actor: actorId,
-                    target: mission.missionId,
-                    title: 'Mission control blocked',
-                    execute: async () => undefined
-                });
-                if (mission.lifecycleStatus === 'draft' || mission.lifecycleStatus === 'stopped' || mission.completedAt || mission.archivedAt) {
-                    throw new Error(`Mission ${mission.missionId} cannot be run because it is not fully configured or is stopped.`);
-                }
-                void this.deps.lifecycleService
-                    .runMissionTurn(mission.missionId, 'manual', 'runtime:mission/manual', requesterActorId ?? null)
-                    .catch((error) => {
-                    this.deps.appendAuditEvent('mission.trigger.failed', {
-                        missionId: mission.missionId,
-                        actorId,
-                        error: error instanceof Error ? error.message : String(error)
-                    });
-                });
-                return this.deps.missionRegistry.getById(mission.missionId) ?? mission;
-            },
             respondToRuntimeRequest: async ({ threadId, requestId, decision, requesterActor }) => {
                 await this.deps.resolvePendingRequest({
                     actorId,
@@ -444,69 +913,99 @@ export class RuntimePluginContextService {
                 }
                 return true;
             }),
-            sendMessage: async (spaceId, payload) => {
-                await this.deps.postTransportMessage(actorId, spaceId, payload);
+            sendMessage: async (transportResourceId, payload) => {
+                await this.deps.postTransportMessage(actorId, transportResourceId, payload);
             },
             sendStatusUpdate: async (payload) => {
-                const namespaceState = this.deps.getNamespaceState();
-                if (namespaceState) {
-                    await this.deps.postTransportMessage(actorId, namespaceState.statusChannelId, payload);
+                const surfaceState = this.deps.getSurfaceState();
+                if (surfaceState) {
+                    await this.deps.postTransportMessage(actorId, surfaceState.statusResourceId, payload);
                 }
             },
             appendAuditEvent: (event, payload) => {
                 this.deps.appendAuditEvent(event, payload);
             },
             nowIso: () => this.deps.now(),
-            runAgent: async ({ surface, spaceId, actorId: promptActorId, actorLabel, text, attachments, session, cwd, runtimeMode, basePromptSections, promptSource }) => {
-                const promptSections = [
-                    ...basePromptSections,
-                    ...(await this.deps.getPluginHost().beforeAgentPrompt({
-                        surface,
-                        spaceId,
-                        actorId: promptActorId,
-                        actorLabel,
-                        text,
-                        attachments,
-                        session
-                    }, (pluginId) => this.createContext(`plugin:${pluginId}`)))
+            runAgent: async ({ surface, transportResourceId, actorId: promptActorId, actorLabel, message, attachments, session, cwd, runtimeMode, toolGrantIds, context: agentContext, agentKind, promptSource }) => {
+                const activeSession = session
+                    ? this.toInternalSessionRow(session)
+                    : await this.deps.ensureCoordinationSession(transportResourceId, cwd ?? this.deps.coordinationWorkspacePath);
+                const effectiveAgentKind = agentKind ?? activeSession.agentKind ?? (session ? 'workspace' : 'ephemeral');
+                const contributions = await this.deps.getPluginHost().contributeAgentContext({
+                    surface,
+                    transportResourceId,
+                    actorId: promptActorId,
+                    actorLabel,
+                    text: message,
+                    attachments,
+                    session
+                }, (pluginId) => this.createContext(`plugin:${pluginId}`));
+                const contributionSystemSections = contributions.flatMap((entry) => entry.systemPromptSections ?? []);
+                const contributionContext = contributions.flatMap((entry) => entry.perTurnContext ?? []);
+                const contributionGrantIds = contributions.flatMap((entry) => entry.toolGrantIds ?? []);
+                const policyGrants = this.deps.providerToolPolicy[effectiveAgentKind].grants ?? [];
+                const resources = this.buildProviderResourceBundle([
+                    ...(agentContext?.systemPromptSections ?? []),
+                    ...contributionSystemSections
+                ]);
+                const providerContext = [
+                    {
+                        title: promptSource === 'orchestration' ? 'Orchestration instruction source' : 'Transport message source',
+                        content: promptSource === 'orchestration'
+                            ? `${actorLabel} (${promptActorId})`
+                            : describeTransportAuthor({
+                                authorId: promptActorId,
+                                authorUsername: actorLabel,
+                                authorGlobalName: null,
+                                authorDisplayName: actorLabel,
+                                authorLabel: actorLabel
+                            }),
+                        source: 'moorline/runtime'
+                    },
+                    ...((attachments ?? []).length > 0
+                        ? [{
+                                title: 'Attachment summary',
+                                content: `Attached image count: ${(attachments ?? []).length}`,
+                                source: 'moorline/runtime'
+                            }]
+                        : []),
+                    ...(agentContext?.perTurnContext ?? []),
+                    ...contributionContext
+                ];
+                const resolvedGrantIds = [
+                    ...(activeSession.toolGrantIds ?? []),
+                    ...policyGrants,
+                    ...(toolGrantIds ?? []),
+                    ...contributionGrantIds,
+                    ...(effectiveAgentKind === 'ephemeral' ? ['core.moorline_session'] : [])
                 ];
-                const activeSession = session ?? (await this.deps.ensureChatSession(spaceId, cwd));
-                const prompt = [
-                    ...promptSections,
-                    '',
-                    promptSource === 'orchestration'
-                        ? `Orchestration instruction from ${actorLabel} (${promptActorId}): ${text || '(no text content)'}`
-                        : `Transport message from ${describeTransportAuthor({
-                            authorId: promptActorId,
-                            authorUsername: actorLabel,
-                            authorGlobalName: null,
-                            authorDisplayName: actorLabel,
-                            authorLabel: actorLabel
-                        })}: ${text || '(no text content)'}`,
-                    ...((attachments ?? []).length > 0 ? [`Attached image count: ${(attachments ?? []).length}`] : [])
-                ].join('\n');
+                const providerTools = this.resolveProviderTools(effectiveAgentKind, resolvedGrantIds);
                 const providerImages = await this.deps.prepareProviderImages(activeSession.threadId, attachments);
                 const result = await this.deps.providerOrchestrator.runTurn({
                     actorId,
                     session: activeSession,
-                    spaceId: spaceId,
+                    transportResourceId: transportResourceId,
                     surface,
-                    promptContent: text,
+                    promptContent: message,
                     promptSource,
                     authorId: promptActorId,
                     authorLabel: actorLabel,
                     providerInput: {
-                        text: prompt,
-                        ...(providerImages && providerImages.length > 0 ? { images: providerImages } : {})
-                    }
+                        text: message,
+                        ...(providerImages && providerImages.length > 0 ? { images: providerImages } : {}),
+                        ...(providerContext.length > 0 ? { context: providerContext } : {})
+                    },
+                    providerResources: resources,
+                    providerTools,
+                    providerToolExecutor: this.createProviderToolExecutor(providerTools)
                 });
                 const formattedResult = this.deps.normalizeReply(result.text || (result.attachments?.length ? '' : 'I could not finish that cleanly.'));
                 await this.deps.getPluginHost().afterAgentResponse({
                     surface,
-                    spaceId,
+                    transportResourceId,
                     actorId: promptActorId,
                     actorLabel,
-                    text,
+                    text: message,
                     attachments,
                     session,
                     replyMessage: formattedResult
@@ -539,18 +1038,342 @@ export class RuntimePluginContextService {
         }
         return dynamicSections;
     }
-    async loadMissionPromptSections(mission) {
+    toInternalSessionRow(session) {
+        return session;
+    }
+    buildProviderResourceBundle(systemPromptSections) {
+        const skills = this.deps.skillRegistry.list().map((skill) => ({
+            name: skill.name,
+            description: skill.description,
+            filePath: skill.path,
+            baseDir: skill.path.replace(/[\\/]SKILL\.md$/, ''),
+            metadata: skill.metadata
+        }));
+        return {
+            systemPromptSections: systemPromptSections.map((section) => section.trim()).filter(Boolean),
+            contextFiles: [],
+            skills,
+            promptTemplates: []
+        };
+    }
+    coreSessionTool() {
+        return {
+            name: 'moorline_session',
+            description: 'Inspect, query, create, direct, archive, or delete Moorline managed sessions.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    action: {
+                        type: 'string',
+                        enum: ['query', 'inspect', 'create', 'direct', 'archive', 'delete_archived']
+                    },
+                    session_id: { type: 'string' },
+                    transport_resource_id: { type: 'string' },
+                    requested_name: { type: 'string' },
+                    runtime_mode: { type: 'string' },
+                    instruction: { type: 'string' },
+                    objective: { type: 'string' },
+                    reason: { type: 'string' },
+                    include_archived: { type: 'boolean' },
+                    limit: { type: 'number' }
+                },
+                required: ['action'],
+                additionalProperties: false
+            },
+            execute: async (input, context) => {
+                const action = typeof input.action === 'string' ? input.action : '';
+                const sessionId = typeof input.session_id === 'string' ? input.session_id.trim() : '';
+                const transportResourceId = typeof input.transport_resource_id === 'string' ? input.transport_resource_id.trim() : '';
+                switch (action) {
+                    case 'query': {
+                        return await this.deps.runGuardedAction({
+                            action: 'session.inspect',
+                            actor: context.actorId,
+                            target: 'sessions',
+                            title: 'Session query blocked',
+                            execute: async () => {
+                                const sessions = this.deps.snapshots.querySessions({
+                                    includeArchived: input.include_archived === true,
+                                    limit: typeof input.limit === 'number' ? input.limit : undefined
+                                });
+                                return {
+                                    content: sessions.length === 0
+                                        ? 'No sessions matched.'
+                                        : [
+                                            'Sessions:',
+                                            ...sessions.map(({ session }) => [
+                                                `- ${session.sessionId}`,
+                                                `kind=${session.agentKind ?? 'workspace'}`,
+                                                `lifecycle=${session.lifecycleStatus}`,
+                                                `mode=${session.runtimeMode}`,
+                                                `provider=${session.providerStatus}`,
+                                                session.objective ? `objective=${session.objective}` : null
+                                            ].filter(Boolean).join(' | '))
+                                        ].join('\n')
+                                };
+                            }
+                        });
+                    }
+                    case 'inspect': {
+                        return await this.deps.runGuardedAction({
+                            action: 'session.inspect',
+                            actor: context.actorId,
+                            target: sessionId || transportResourceId || 'session',
+                            title: 'Session inspect blocked',
+                            execute: async () => {
+                                const snapshot = sessionId
+                                    ? this.deps.snapshots.getSessionById(sessionId)
+                                    : transportResourceId
+                                        ? this.deps.snapshots.getSessionByTransportResourceId(transportResourceId)
+                                        : null;
+                                return { content: snapshot ? JSON.stringify(snapshot, null, 2) : 'No matching session found.' };
+                            }
+                        });
+                    }
+                    case 'create': {
+                        const requestedName = typeof input.requested_name === 'string' ? input.requested_name.trim() : '';
+                        if (!requestedName)
+                            return { content: 'create error: requested_name is required.' };
+                        const runtimeMode = parseRuntimeModeName(input.runtime_mode, 'runtime_mode');
+                        return await this.deps.runGuardedAction({
+                            action: 'session.create',
+                            actor: context.actorId,
+                            target: requestedName,
+                            title: 'Session create blocked',
+                            execute: async () => {
+                                const created = await this.deps.workManagement.createManagedSession({
+                                    actorId: 'runtime:provider/tool',
+                                    requestedName,
+                                    runtimeMode,
+                                    objective: typeof input.objective === 'string' ? input.objective : undefined
+                                });
+                                return { content: `Created session ${created.session.sessionId} (${created.transportResourceId}).` };
+                            }
+                        });
+                    }
+                    case 'direct': {
+                        const instruction = typeof input.instruction === 'string' ? input.instruction.trim() : '';
+                        if (!instruction)
+                            return { content: 'direct error: instruction is required.' };
+                        return await this.deps.runGuardedAction({
+                            action: 'session.direct',
+                            actor: context.actorId,
+                            target: sessionId || transportResourceId || 'session',
+                            title: 'Session direct blocked',
+                            execute: async () => {
+                                const result = await this.deps.workManagement.directManagedSession({
+                                    actorId: 'runtime:provider/tool',
+                                    sessionId: sessionId || undefined,
+                                    transportResourceId: transportResourceId || undefined,
+                                    instruction,
+                                    reason: typeof input.reason === 'string' ? input.reason : undefined
+                                });
+                                return { content: `Directed session ${result.session.sessionId}.\n${result.reply.text ?? ''}`.trim() };
+                            }
+                        });
+                    }
+                    case 'archive': {
+                        return await this.deps.runGuardedAction({
+                            action: 'session.archive',
+                            actor: context.actorId,
+                            target: sessionId || transportResourceId || 'session',
+                            title: 'Session archive blocked',
+                            execute: async () => {
+                                const archived = await this.deps.workManagement.archiveManagedSession({
+                                    actorId: 'runtime:provider/tool',
+                                    sessionId: sessionId || undefined,
+                                    transportResourceId: transportResourceId || undefined
+                                });
+                                return { content: archived ? `Archived session ${archived.sessionId}.` : 'No matching session found.' };
+                            }
+                        });
+                    }
+                    case 'delete_archived': {
+                        return await this.deps.runGuardedAction({
+                            action: 'session.delete',
+                            actor: context.actorId,
+                            target: sessionId || transportResourceId || 'session',
+                            title: 'Session delete blocked',
+                            execute: async () => {
+                                const deleted = await this.deps.workManagement.deleteManagedSession({
+                                    actorId: 'runtime:provider/tool',
+                                    sessionId: sessionId || undefined,
+                                    transportResourceId: transportResourceId || undefined
+                                });
+                                return { content: deleted ? `Deleted archived session ${deleted.sessionId}.` : 'No matching archived session found.' };
+                            }
+                        });
+                    }
+                    default:
+                        return { content: 'moorline_session error: unknown action.' };
+                }
+            }
+        };
+    }
+    coreSkillLoadTool() {
+        return {
+            name: 'moorline_skill.load',
+            description: 'Load a Moorline-managed skill by name.',
+            requiredCapability: 'fs.read',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    name: { type: 'string' }
+                },
+                required: ['name'],
+                additionalProperties: false
+            },
+            execute: async (input) => {
+                const name = typeof input.name === 'string' ? input.name.trim() : '';
+                if (!name) {
+                    return { content: 'moorline_skill.load error: name is required.' };
+                }
+                const skill = await this.deps.skillRegistry.load(name);
+                return {
+                    content: skill ? JSON.stringify(skill, null, 2) : `No matching skill found: ${name}`
+                };
+            }
+        };
+    }
+    coreSkillSaveTool() {
+        return {
+            name: 'moorline_skill.save',
+            description: 'Create or update a Moorline-managed runtime skill.',
+            requiredCapability: 'fs.write',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    name: { type: 'string' },
+                    description: { type: 'string' },
+                    tags: { type: 'array', items: { type: 'string' } },
+                    body: { type: 'string' },
+                    directory_name: { type: 'string' },
+                    resource_files: {
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                path: { type: 'string' },
+                                content: { type: 'string' }
+                            },
+                            required: ['path', 'content'],
+                            additionalProperties: false
+                        }
+                    }
+                },
+                required: ['name', 'body'],
+                additionalProperties: false
+            },
+            execute: async (input, context) => {
+                const name = typeof input.name === 'string' ? input.name.trim() : '';
+                const body = typeof input.body === 'string' ? input.body : '';
+                if (!name) {
+                    return { content: 'moorline_skill.save error: name is required.' };
+                }
+                if (!body.trim()) {
+                    return { content: 'moorline_skill.save error: body is required.' };
+                }
+                const resourceFiles = Array.isArray(input.resource_files)
+                    ? input.resource_files
+                        .filter((entry) => !!entry && typeof entry === 'object' && !Array.isArray(entry))
+                        .map((entry) => ({
+                        path: typeof entry.path === 'string' ? entry.path : '',
+                        content: typeof entry.content === 'string' ? entry.content : ''
+                    }))
+                    : [];
+                const written = writeSkill({
+                    rootDir: join(this.deps.runtimeRoot, 'packages', 'skills'),
+                    name,
+                    description: typeof input.description === 'string' ? input.description : undefined,
+                    tags: Array.isArray(input.tags) ? input.tags.filter((tag) => typeof tag === 'string') : undefined,
+                    body,
+                    directoryName: typeof input.directory_name === 'string' ? input.directory_name : undefined,
+                    resourceFiles
+                });
+                this.deps.skillRegistry.invalidateCache();
+                recordHistoryCheckpoint({
+                    homeRoot: this.deps.homeRoot,
+                    actor: context.actorId,
+                    reason: `Updated skill ${name}.`,
+                    operation: `provider tool write skill ${typeof input.directory_name === 'string' ? input.directory_name : name}`,
+                    absoluteTargets: [written.skillDir]
+                });
+                return { content: JSON.stringify(written, null, 2) };
+            }
+        };
+    }
+    allProviderRuntimeTools() {
         return [
-            `Mission ID: ${mission.missionId}`,
-            `Mission title: ${mission.title}`,
-            `Mission goal: ${mission.goal}`,
-            `Mission schedule: ${mission.scheduleText}`,
-            `Mission workspace: ${mission.workspacePath}`,
-            `Runtime mode: ${mission.runtimeMode}`,
-            'Mission interactions are independent operator messages. Respond directly to the current message while using the persistent mission thread context when helpful.',
-            'Manual mission messages must not change or cancel the recurring mission schedule.'
+            { ...this.coreSessionTool(), pluginId: 'core' },
+            { ...this.coreSkillLoadTool(), pluginId: 'core' },
+            { ...this.coreSkillSaveTool(), pluginId: 'core' },
+            ...this.deps.getPluginHost().listTools((pluginId) => this.createContext(`plugin:${pluginId}`))
         ];
     }
+    toolId(tool) {
+        return tool.pluginId === 'core' ? `core.${tool.name}` : `plugin:${tool.pluginId ?? 'unknown'}.${tool.name}`;
+    }
+    resolveProviderTools(agentKind, grantIds) {
+        const grants = new Set(grantIds);
+        if (agentKind === 'ephemeral') {
+            grants.add('core.moorline_session');
+        }
+        return this.allProviderRuntimeTools()
+            .filter((tool) => grants.has(this.toolId(tool)))
+            .map((tool) => ({
+            id: this.toolId(tool),
+            name: tool.name,
+            description: tool.description ?? tool.name,
+            inputSchema: tool.inputSchema ?? { type: 'object', additionalProperties: true },
+            ...(tool.requiredCapability ? { requiredCapability: tool.requiredCapability } : {}),
+            source: tool.pluginId === 'core' ? 'core' : 'plugin',
+            ...(tool.pluginId && tool.pluginId !== 'core' ? { ownerPackageId: tool.pluginId } : {})
+        }));
+    }
+    createProviderToolExecutor(tools) {
+        const allowed = new Set(tools.map((tool) => tool.id));
+        return {
+            executeProviderTool: async ({ toolId, arguments: args, actor }) => {
+                if (!allowed.has(toolId)) {
+                    throw new Error(`Provider tool is not granted for this session: ${toolId}`);
+                }
+                const runtimeTool = this.allProviderRuntimeTools().find((tool) => this.toolId(tool) === toolId);
+                if (!runtimeTool) {
+                    throw new Error(`Unknown provider tool: ${toolId}`);
+                }
+                const context = this.createContext(runtimeTool.pluginId && runtimeTool.pluginId !== 'core' ? `plugin:${runtimeTool.pluginId}` : actor);
+                const run = async () => await runtimeTool.execute(args, context);
+                try {
+                    const result = runtimeTool.requiredCapability
+                        ? await this.deps.runGuardedAction({
+                            action: runtimeTool.requiredCapability,
+                            actor,
+                            target: toolId,
+                            title: 'Provider tool blocked',
+                            execute: run
+                        })
+                        : await run();
+                    this.deps.appendAuditEvent('provider.tool.executed', {
+                        actor,
+                        toolId,
+                        ownerPackageId: runtimeTool.pluginId ?? 'core',
+                        ok: true
+                    });
+                    return { content: result.content };
+                }
+                catch (error) {
+                    this.deps.appendAuditEvent('provider.tool.executed', {
+                        actor,
+                        toolId,
+                        ownerPackageId: runtimeTool.pluginId ?? 'core',
+                        ok: false,
+                        error: error instanceof Error ? error.message : String(error)
+                    });
+                    throw error;
+                }
+            }
+        };
+    }
     normalizePluginSidecarScope(scope) {
         if (scope.kind === 'session') {
             return {
@@ -564,7 +1387,7 @@ export class RuntimePluginContextService {
         const normalized = candidate.trim();
         const sessions = this.deps.sessionRegistry.list();
         const session = sessions.find((entry) => entry.sessionId === normalized) ??
-            sessions.find((entry) => entry.spaceId === normalized) ??
+            sessions.find((entry) => entry.transportResourceId === normalized) ??
             sessions.find((entry) => entry.threadId === normalized) ??
             null;
         if (!session) {