@jungjaehoon/mama-os 0.74.0 → 0.76.0

package/dist/runtime/owner-runtime.js

@@ -4,8 +4,14 @@ exports.readOwnerMemoryRecords = readOwnerMemoryRecords;
 exports.runtimeModelRun = runtimeModelRun;
 exports.guidanceInSearchOrder = guidanceInSearchOrder;
 exports.createOwnerRuntime = createOwnerRuntime;
+const personal_jobs_js_1 = require("./personal-jobs.js");
+const skills_js_1 = require("./skills.js");
+const node_os_1 = require("node:os");
 const mama_core_1 = require("@jungjaehoon/mama-core");
+const personal_notices_js_1 = require("./personal-notices.js");
+const runtime_1 = require("@jungjaehoon/mama-core/runtime/runtime");
 const principal_sessions_js_1 = require("./principal-sessions.js");
+const telegram_message_ledger_js_1 = require("../gateways/telegram-message-ledger.js");
 const member_session_js_1 = require("./member-session.js");
 const backend_security_js_1 = require("./backend-security.js");
 const member_paths_js_1 = require("./member-paths.js");
@@ -13,7 +19,9 @@ const principal_access_js_1 = require("./principal-access.js");
 const mama_core_2 = require("@jungjaehoon/mama-core");
 const node_crypto_1 = require("node:crypto");
 const node_path_1 = require("node:path");
+const node_fs_1 = require("node:fs");
 const stored_source_reader_js_1 = require("../api/stored-source-reader.js");
+const backend_security_js_2 = require("./backend-security.js");
 const report_persistence_js_1 = require("../api/report-persistence.js");
 const obsidian_writer_js_1 = require("../wiki/obsidian-writer.js");
 const source_archive_js_1 = require("../storage/source-archive.js");
@@ -84,7 +92,7 @@ function isOwnerGuidanceRecord(record) {
     return owner_authority_js_1.RULE_KINDS.includes(record.kind);
 }
 /** Active guidance among the search hits, in the search's own order. */
-function guidanceInSearchOrder(hitIds, records, limit, ownerRuleRecordIds) {
+function guidanceInSearchOrder(hitIds, records, limit, ownerRuleRecordIds, skillScopes = []) {
     const active = new Map(records
         .filter((record) => isOwnerGuidanceRecord(record) && record.status === 'active')
         .map((record) => [record.id, record]));
@@ -98,6 +106,10 @@ function guidanceInSearchOrder(hitIds, records, limit, ownerRuleRecordIds) {
                     topic: record.topic,
                     summary: record.summary,
                     ...(record.applies_when ? { appliesWhen: record.applies_when } : {}),
+                    ...(record.kind === 'workflow' &&
+                        record.scopes.some((scope) => skillScopes.some((admitted) => admitted.kind === scope.kind && admitted.id === scope.id))
+                        ? { skillId: record.id }
+                        : {}),
                     ownerRule: ownerRuleRecordIds.has(record.id),
                 },
             ]
@@ -119,7 +131,15 @@ async function createOwnerRuntime(options) {
     let stopping = false;
     const sessions = (0, principal_sessions_js_1.createPrincipalSessions)(options.ownerPrincipalId, {
         onUncertain: options.onStimulusUncertain,
-        onDead: options.onStimulusDead,
+        onDead: async (row, reason) => {
+            if ((0, personal_notices_js_1.personalNoticePayload)(row)) {
+                await actionSurface?.personalNotices.close(row);
+                const ledger = options.messageLedger?.();
+                if (ledger)
+                    (0, telegram_message_ledger_js_1.retirePersonalTurnReceipt)(ledger, row.stimulusId);
+            }
+            await options.onStimulusDead?.(row, reason);
+        },
     }, (id) => {
         if (stopping)
             throw new Error('Runtime is stopping');
@@ -133,13 +153,12 @@ async function createOwnerRuntime(options) {
     const reportSseClients = new Set();
     let wikiRoot = null;
     try {
+        const principals = (0, mama_core_1.createPrincipalRepository)(database.adapter);
         const knowledge = (0, mama_core_2.createKnowledge)({
             adapter: database.adapter,
             embedder: runtimeEmbedder(options),
         });
-        const activeMembers = (0, mama_core_1.createPrincipalRepository)(database.adapter)
-            .listMembers()
-            .filter((member) => member.status === 'active');
+        const activeMembers = principals.listMembers().filter((member) => member.status === 'active');
         if (activeMembers.length && options.memberRoot === undefined)
             throw new Error('Active members require member_root');
         const ownerDeniedPaths = options.memberRoot === undefined ? [] : (0, backend_security_js_1.ownerDataReadPaths)(options);
@@ -150,6 +169,15 @@ async function createOwnerRuntime(options) {
         rawStore = new source_archive_js_1.RawStore(options.rawPath);
         const chat = new chat_sources_js_1.ChatSources(rawStore, database.adapter, options.ownerPrincipalId, options.agentId);
         const sourceStore = rawStore;
+        // A member's personal copy of a host exchange; the common management copy is separate.
+        const writeMemberHostExchange = (id, { message, reply }) => {
+            const archive = new chat_sources_js_1.ChatSources(sourceStore, database.adapter, id, `member-agent:${id}`);
+            archive.saveOwnerMessage({ ...message, senderPrincipalId: id });
+            archive.saveReply({ ...reply, messageRef: message.id, author: 'host' });
+        };
+        // A member's chat archive: its personal records for a DM, the common records for a room
+        // (as its room session keeps them).
+        const memberChat = (id, room) => new chat_sources_js_1.ChatSources(sourceStore, database.adapter, room === undefined ? id : options.ownerPrincipalId, `member-agent:${id}`);
         const storedSourceReader = (0, stored_source_reader_js_1.createStoredSourceReader)({
             adapter: database.adapter,
             rawStore: () => sourceStore,
@@ -182,7 +210,41 @@ async function createOwnerRuntime(options) {
             })()
             : {};
         const surface = (0, action_surface_js_1.createActionSurface)({
+            commonChannelId: options.commonChannelId,
             runtimeRoot: options.runtimeRoot,
+            skillPaths: {
+                toolsRoot: options.toolsRoot,
+                workspace: (id) => {
+                    if (id === options.ownerPrincipalId)
+                        return options.workspaceDir;
+                    if (memberRoot === undefined)
+                        throw new Error('Member skills require member_root');
+                    return (0, member_paths_js_1.memberPaths)(memberRoot, id).workspaceDir;
+                },
+            },
+            documentPorts: {
+                toolsRoot: options.toolsRoot,
+                workspaceDir: options.workspaceDir,
+                deniedReadPaths: [
+                    (0, node_os_1.homedir)(),
+                    ...(0, backend_security_js_2.credentialReadPaths)(options.runtimeRoot, options.codexHome, options.replayKeyFile),
+                    ...(0, backend_security_js_1.ownerNativeDataReadPaths)(options),
+                ],
+                ...(memberRoot === undefined
+                    ? {}
+                    : {
+                        principalPaths: (id) => {
+                            sessions.get(id);
+                            return members.get(id).activePaths();
+                        },
+                        // Linked document resources have the same private-data boundary as native tools.
+                        principalDeniedReadPaths: (id) => {
+                            sessions.get(id);
+                            return members.get(id).activeDeniedReadPaths();
+                        },
+                    }),
+            },
+            memberDirectoryChange: sessions.exclusive,
             adapter: database.adapter,
             ...(options.outboundAttempts === undefined
                 ? {}
@@ -195,14 +257,43 @@ async function createOwnerRuntime(options) {
             storedSourceReader,
             timeZone: options.timeZone,
             configPath: (0, node_path_1.join)(options.runtimeRoot, 'config.yaml'),
-            isOwnerMessageTurn: (sourceMessageRef, principalId = options.ownerPrincipalId) => ownerMailbox?.readInput(sourceMessageRef, principalId)?.kind === 'owner_message',
+            isOwnerMessageTurn: (sourceMessageRef, principalId) => ownerMailbox?.readInput(sourceMessageRef, principalId)?.kind === 'owner_message',
+            recordManagementReceipt: ({ callerPrincipalId, operationId, action, input, result }) => {
+                const at = Date.now();
+                const ref = `host:management:${operationId}`;
+                chat.saveOwnerMessage({
+                    id: ref,
+                    channelKey: 'management',
+                    ...(callerPrincipalId === undefined ? {} : { senderPrincipalId: callerPrincipalId }),
+                    occurredAt: at,
+                    text: action,
+                    payload: { managementAction: action },
+                });
+                chat.saveReply({
+                    messageRef: ref,
+                    text: JSON.stringify({ action, input, result }),
+                    occurredAt: at,
+                    deliveryVerified: true,
+                    author: 'host',
+                });
+            },
             // Without member_root no member can be served or set aside, so no change may be committed.
             ...(memberRoot === undefined
                 ? {}
                 : {
+                    memberNotices: {
+                        mailbox: () => ownerMailbox,
+                        wake: () => {
+                            // The recipient delivery prepares service outside the common turn.
+                            void intakeRuntime
+                                .drainOnce()
+                                .catch((error) => options.onPersonalJobError?.(error));
+                        },
+                    },
                     memberRecords: {
                         root: memberRoot,
                         isStopping: () => stopping,
+                        isReady: () => options.deliveryReady?.() ?? true,
                         resumeQueued: () => {
                             void intakeRuntime
                                 .drainOnce()
@@ -218,7 +309,12 @@ async function createOwnerRuntime(options) {
                         serve: (id) => {
                             serveMember(id);
                         },
+                        writeHostExchange: (id, exchange) => writeMemberHostExchange(id, exchange),
                         recordExchange: (id, kind, ref, text, deliveryVerified) => {
+                            if (database.adapter
+                                .prepare("SELECT 1 FROM connector_event_index WHERE source_connector='chat' AND source_entity_id=? AND memory_scope_id=?")
+                                .get(`${ref}:reply`, id))
+                                return;
                             const memberChat = new chat_sources_js_1.ChatSources(sourceStore, database.adapter, id, `member-agent:${id}`);
                             const at = Date.now();
                             memberChat.saveOwnerMessage({
@@ -237,25 +333,39 @@ async function createOwnerRuntime(options) {
                         },
                     },
                     memberLifecycle: {
+                        mailbox: () => ownerMailbox,
+                        isStopping: () => stopping,
+                        isServed: (id) => members.has(id),
+                        resumeQueued: () => {
+                            void intakeRuntime
+                                .drainOnce()
+                                .catch((error) => console.error('[Member management] delivery failed', error));
+                        },
+                        turnChain: sessions.turnChain,
                         resetSession: async (id) => {
                             const member = members.get(id);
                             if (!member)
                                 throw new Error(`Member session is not served: ${id}`);
                             await member.native.resetSession(member.native.sessionKey);
                         },
-                        cancelQueued: (id, reason) => ownerMailbox.cancelQueued(id, reason),
+                        cancelQueued: (id, reason) => {
+                            if (reason === 'member_suspend')
+                                options.memberEnrollment?.cancelSelection?.(id);
+                            return ownerMailbox.cancelQueued(id, reason);
+                        },
                         retire: (id) => retireMember(id),
                         resume: async (id) => {
                             // A suspended member may retain a session after an earlier stop/move failure.
                             await retireMember(id);
-                            const repo = (0, mama_core_1.createPrincipalRepository)(database.adapter);
-                            repo.resume(id, Date.now());
+                            const resumedAt = Date.now();
+                            await surface.personalJobs.resume(id, resumedAt);
+                            principals.resume(id, resumedAt);
                             try {
                                 serveMember(id);
                             }
                             catch (error) {
                                 // A failed preparation never leaves an active registry entry with a partial runtime.
-                                repo.suspend(id, Date.now());
+                                principals.suspend(id, Date.now());
                                 throw error;
                             }
                         },
@@ -268,7 +378,14 @@ async function createOwnerRuntime(options) {
                         ...options.memberEnrollment,
                         memberRoot,
                         serveMember: (id) => {
+                            if (stopping)
+                                return 'next_start';
+                            // Serving recreates the member's paths; an erasure checks them against the
+                            // delivered export and serves the member itself when it ends.
+                            if (surface.memberRecords.excludePrincipals().includes(id))
+                                return 'after_erasure';
                             serveMember(id);
+                            return undefined;
                         },
                     },
                 }),
@@ -286,7 +403,7 @@ async function createOwnerRuntime(options) {
                             downloadsDir: options.attachmentPorts?.downloadsDir ?? '',
                         };
                     sessions.get(principalId);
-                    return members.get(principalId).paths;
+                    return members.get(principalId).activePaths();
                 },
             },
             ...(options.driveDelivery === undefined
@@ -313,6 +430,7 @@ async function createOwnerRuntime(options) {
                 model: options.model,
                 workspaceDir: options.workspaceDir,
                 runtimeRoot: options.runtimeRoot,
+                toolsRoot: options.toolsRoot,
                 deniedReadPaths: (0, backend_security_js_1.ownerNativeDataReadPaths)(options),
                 replayKeyFile: options.replayKeyFile,
                 ...(options.sandboxNetworkProxy === undefined
@@ -345,9 +463,61 @@ async function createOwnerRuntime(options) {
             ...(options.onRecordOrderEvent === undefined ? {} : { onEvent: options.onRecordOrderEvent }),
         });
         delivery = (0, stimulus_delivery_js_1.createStimulusDelivery)({
-            turnChain: sessions.turnChain,
+            skills: (0, skills_js_1.createSkillTurnContext)(() => surface.skills.list(options.ownerPrincipalId)),
+            turnChain: sessions.turnChain(options.ownerPrincipalId),
             backend: options.backend,
             timeZone: options.timeZone,
+            principalRoles: (principalId) => principals.listRoles(principalId).map(({ role }) => role),
+            principalDisplayName: (principalId) => principals.findById(principalId)?.displayName,
+            commonPrincipalId: options.ownerPrincipalId,
+            ownerMessageSenderActive: (id) => {
+                const person = principals.findById(id);
+                return (person?.kind === 'member' && person.status === 'active' && (0, owner_authority_js_1.holdsOwnerRole)(principals, id));
+            },
+            rerouteOwnerMessage: async (row, sender) => {
+                const person = principals.findById(sender);
+                if (person?.kind !== 'member' ||
+                    person.status !== 'active' ||
+                    !row.stimulusId.startsWith(`telegram:${row.channelKey}:`) ||
+                    !options.roomChannels?.includes(row.channelKey))
+                    return false;
+                await serveMemberOnLane(sender);
+                // The room session cannot read the common downloads; its files go to the room's own.
+                const payload = row.payload;
+                let input = payload.input;
+                if (input?.attachments?.length) {
+                    const target = (0, node_path_1.join)(members.get(sender).roomSession(row.channelKey).paths.downloadsDir, 'telegram');
+                    (0, node_fs_1.mkdirSync)(target, { recursive: true });
+                    input = {
+                        ...input,
+                        attachments: input.attachments.map((attachment) => {
+                            if (!('path' in attachment))
+                                return attachment;
+                            const path = (0, node_path_1.join)(target, (0, node_path_1.basename)(attachment.path));
+                            (0, node_fs_1.copyFileSync)(attachment.path, path);
+                            return { ...attachment, path };
+                        }),
+                    };
+                }
+                // A deterministic handoff ref survives a crash between this append and the common
+                // acknowledgement. Mailbox ref identities are global; keep the evidence handles.
+                intakeRuntime.accept({
+                    id: row.stimulusId,
+                    kind: 'owner_message',
+                    principalId: sender,
+                    channelKey: row.channelKey,
+                    occurredAt: row.occurredAt,
+                    refs: row.refs.map((ref) => ({ ...ref, refId: `room-handoff:${sender}:${ref.refId}` })),
+                    replyTo: row.replyTo,
+                    payload: {
+                        ...row.payload,
+                        ...(input === undefined ? {} : { input }),
+                        senderPrincipalId: sender,
+                        roomChannel: row.channelKey,
+                    },
+                });
+                return true;
+            },
             wikiEnabled: options.wiki?.enabled ?? false,
             formattingRoutes: options.formattingRoutes ?? {
                 reports: 'telegram',
@@ -360,7 +530,13 @@ async function createOwnerRuntime(options) {
                 ? {}
                 : { onUncertain: options.onStimulusUncertain }),
             ...(options.onStimulusDead === undefined ? {} : { onDead: options.onStimulusDead }),
-            ...(options.onStimulusSkipped === undefined ? {} : { onSkipped: options.onStimulusSkipped }),
+            onSkipped: async (row, reason) => {
+                if (row.kind === 'owner_message')
+                    database.adapter
+                        .prepare('UPDATE mailbox_inputs SET last_error = ? WHERE id = ?')
+                        .run(reason, row.id);
+                await options.onStimulusSkipped?.(row, reason);
+            },
             ...(options.closeUncertain === undefined ? {} : { closeUncertain: options.closeUncertain }),
             sessionStart: (row) => (0, session_start_context_js_1.readSessionStartInput)({
                 exchanges: chat.recentExchanges(row.stimulusId),
@@ -405,7 +581,7 @@ async function createOwnerRuntime(options) {
                     });
                     // Ten in search order: the session filter drops lessons already shown and keeps three.
                     const hitIds = hits.map((hit) => hit.id);
-                    return guidanceInSearchOrder(hitIds, active, 10, (0, owner_authority_js_1.ownerRuleIds)(database.adapter, hitIds, options.ownerPrincipalId));
+                    return guidanceInSearchOrder(hitIds, active, 10, (0, owner_authority_js_1.ownerRuleIds)(database.adapter, hitIds, options.ownerPrincipalId), surface.skills.workflowScopes(options.ownerPrincipalId));
                 }),
             recordOrders,
             ...(options.onOwnerResult === undefined ? {} : { onOwnerResult: options.onOwnerResult }),
@@ -422,19 +598,19 @@ async function createOwnerRuntime(options) {
         const prepareMember = (principalId) => {
             if (memberRoot === undefined)
                 throw new Error('Active members require member_root');
-            const principal = (0, mama_core_1.createPrincipalRepository)(database.adapter).findById(principalId);
+            const principal = principals.findById(principalId);
             if (principal?.kind !== 'member' || principal.status !== 'active')
                 throw new Error(`serveMember requires an active member: ${principalId}`);
             const member = (0, member_session_js_1.createMemberSession)(principalId, memberRoot, {
                 options,
+                personalJobs: surface.personalJobs,
+                ownerPolicyProvider,
                 ownerDeniedPaths,
-                registeredMemberIds: () => (0, mama_core_1.createPrincipalRepository)(database.adapter)
-                    .listMembers()
-                    .map((row) => row.principalId),
+                registeredMemberIds: () => principals.listMembers().map((row) => row.principalId),
                 database,
                 rawStore: sourceStore,
                 surface,
-                turnChain: sessions.turnChain,
+                turnChain: sessions.turnChain(principalId),
                 readResult: (row) => row.nativeDelivery?.receipt
                     ? intakeRuntime.mailbox.nativeInputs.resultForReceipt(row.nativeDelivery.receipt, row.principalId)
                     : null,
@@ -444,16 +620,22 @@ async function createOwnerRuntime(options) {
             return member;
         };
         for (const member of activeMembers)
-            prepareMember(member.principalId);
-        const executionAccess = (principalId) => principalId === options.ownerPrincipalId
+            if (!surface.memberRecords.isBlocked(member.principalId))
+                prepareMember(member.principalId);
+        const executionAccess = (principalId, sessionKey) => principalId === options.ownerPrincipalId
             ? access
             : (0, principal_access_js_1.resolvePrincipalAccess)(principalId, {
                 adapter: database.adapter,
                 ownerAccess: access,
                 agentId: `member-agent:${principalId}`,
+                sessionKey,
+                commonChannelId: options.commonChannelId,
             });
         const socketDispatch = Object.assign(async (...[call, context]) => {
-            context = { ...context, access: executionAccess(context.access.principalId) };
+            context = {
+                ...context,
+                access: executionAccess(context.access.principalId, members.get(context.access.principalId)?.activeSessionKey()),
+            };
             const caller = context.session?.nativeCaller;
             if (caller !== undefined) {
                 const principalSession = sessions.get(context.access.principalId).native;
@@ -480,6 +662,7 @@ async function createOwnerRuntime(options) {
                 executionAccess(callerAccess.principalId);
                 const ceiling = sessions.replaySourceEndMs(callerAccess.principalId);
                 return {
+                    ...members.get(callerAccess.principalId)?.activeSessionFacts(),
                     ...(ceiling === undefined ? {} : { replaySourceEndMs: ceiling }),
                     ...(request.session?.nativeCaller === undefined
                         ? {}
@@ -490,8 +673,80 @@ async function createOwnerRuntime(options) {
             nativeSession: sessions.native,
             delivery: {
                 ...sessions.delivery,
+                deliverHost: surface.deliverManagement,
+                prepareNative: async (row) => {
+                    const payload = row.payload;
+                    if (row.kind === 'owner_message' && payload?.deferredMemberMessage) {
+                        if (!intakeRuntime.servesPrincipal(row.principalId))
+                            await serveMemberOnLane(row.principalId);
+                        // A room message belongs to its room session's common archive, never to the
+                        // member's personal records.
+                        const room = payload.roomChannel;
+                        const archive = memberChat(row.principalId, room);
+                        const existing = database.adapter
+                            .prepare("SELECT current_observation_id, metadata_json FROM connector_event_index WHERE source_connector='chat' AND source_id=? AND memory_scope_id=?")
+                            .get(row.stimulusId, room === undefined ? row.principalId : options.ownerPrincipalId);
+                        let observation;
+                        let input = payload.input;
+                        if (existing) {
+                            observation = existing.current_observation_id;
+                            input = JSON.parse(existing.metadata_json).input ?? undefined;
+                        }
+                        else {
+                            let message = {
+                                id: row.stimulusId,
+                                channelKey: row.channelKey,
+                                occurredAt: row.occurredAt,
+                                text: payload.text ?? '',
+                                replyTo: row.replyTo,
+                                ...(payload.input === undefined ? {} : { payload: payload.input }),
+                                ...(payload.senderPrincipalId === undefined
+                                    ? {}
+                                    : { senderPrincipalId: payload.senderPrincipalId }),
+                            };
+                            if (message.payload &&
+                                typeof message.payload === 'object' &&
+                                !Array.isArray(message.payload) &&
+                                'pendingTelegramMessage' in message.payload) {
+                                if (!options.prepareDeferredMemberInput)
+                                    throw new Error('Deferred Telegram input requires its gateway preparer');
+                                message = await options.prepareDeferredMemberInput(row.principalId, message);
+                            }
+                            observation = archive.saveOwnerMessage(message);
+                            input = message.payload;
+                        }
+                        intakeRuntime.mailbox.bindInputObservation(row.id, row.stimulusId, observation);
+                        for (const ref of row.refs)
+                            if (ref.refId === row.stimulusId)
+                                ref.observationRef = observation;
+                        // The immutable accepted payload remains the dedupe identity. Native delivery sees
+                        // the stored projection's prepared attachments rather than downloading them again.
+                        row.payload = { ...payload, ...(input === undefined ? {} : { input }) };
+                    }
+                    if ((0, personal_notices_js_1.personalNoticePayload)(row)) {
+                        if (principals.findById(row.principalId)?.status !== 'active')
+                            throw new runtime_1.StimulusQuarantine('Personal notice person is no longer active');
+                        // Core calls this port before native admission, including scheduled inputs.
+                        // Serve-on-demand may wait here, in this recipient's delivery, never in the common
+                        // action. The one durable notice remains claimed without a native dispatch meanwhile.
+                        try {
+                            if (!intakeRuntime.servesPrincipal(row.principalId))
+                                await serveMemberOnLane(row.principalId);
+                        }
+                        catch (error) {
+                            // Suspend/offboard can finish while service waits for the directory lane.
+                            // That lifecycle cancellation is final; an active person's preparation error retries.
+                            if (principals.findById(row.principalId)?.status !== 'active')
+                                throw new runtime_1.StimulusQuarantine('Personal notice person is no longer active');
+                            throw error;
+                        }
+                    }
+                },
+                hostReady: () => !stopping,
+                excludePrincipals: surface.memberRecords.excludePrincipals,
                 onSettled: surface.memberRecords.onSettled,
                 onDead: (row, reason) => {
+                    surface.onManagementDead(row, reason);
                     surface.memberRecords.onDead(row, reason);
                     return sessions.delivery.onDead?.(row, reason);
                 },
@@ -499,27 +754,75 @@ async function createOwnerRuntime(options) {
                     surface.memberRecords.onUncertain(row, reason);
                     return sessions.delivery.onUncertain?.(row, reason);
                 },
-                ready: () => !stopping && !surface.memberRecords.isBusy() && (options.deliveryReady?.() ?? true),
+                ready: () => !stopping && (options.deliveryReady?.() ?? true),
             },
             reclaimStaleSocket: true,
         });
         ownerMailbox = intakeRuntime.mailbox;
         recordOrders.recover();
+        // Recovered host inputs need no new Telegram update to run.
+        void intakeRuntime
+            .drainOnce()
+            .catch((error) => console.error('[Member management] recovery failed', error));
         const intake = (0, stimulus_delivery_js_1.createStimulusIntake)(intakeRuntime, options.ownerPrincipalId, chat);
-        const createMemberIntake = (id, member) => (0, stimulus_delivery_js_1.createStimulusIntake)(intakeRuntime, id, {
-            saveOwnerMessage: (input) => {
-                executionAccess(id);
-                if (!intakeRuntime.servesPrincipal(id))
-                    throw new Error(`Member session is not served: ${id}`);
-                return member.chat.saveOwnerMessage(input);
-            },
-            saveReply: (input) => member.chat.saveReply(input),
-        });
+        const createMemberIntake = (id, member, room) => {
+            const archive = member?.chat ?? memberChat(id, room);
+            // A room intake made while the member was retired stays a room intake after the erasure
+            // ends: its message runs in the room session and is kept in the room's common archive.
+            const direct = (0, stimulus_delivery_js_1.createStimulusIntake)(intakeRuntime, id, {
+                saveOwnerMessage: (input) => {
+                    executionAccess(id);
+                    if (!intakeRuntime.servesPrincipal(id))
+                        throw new Error(`Member session is not served: ${id}`);
+                    return archive.saveOwnerMessage(input);
+                },
+                saveReply: (input) => archive.saveReply(input),
+                hasOwnerMessage: (ref) => archive.hasOwnerMessage(ref),
+            }, room);
+            const deferred = () => surface.memberRecords.isBlocked(id) && !intakeRuntime.servesPrincipal(id);
+            return {
+                ...direct,
+                deferIncoming: deferred,
+                acceptOwnerMessage: (input) => {
+                    if (stopping)
+                        throw new Error('Runtime is stopping');
+                    if (!deferred())
+                        return direct.acceptOwnerMessage(input);
+                    executionAccess(id);
+                    // New work received after retirement is durable, but creates no personal projection
+                    // while an idempotent erasure is finishing its already exported snapshot.
+                    const rowId = intakeRuntime.mailbox.enqueue({
+                        id: input.id,
+                        kind: 'owner_message',
+                        principalId: id,
+                        channelKey: input.channelKey,
+                        occurredAt: input.occurredAt,
+                        refs: [{ refId: input.id, observationRef: null }],
+                        replyTo: input.replyTo,
+                        payload: {
+                            text: input.text,
+                            deferredMemberMessage: true,
+                            // A room message waits with its room, so it runs in that room session.
+                            ...(room === undefined ? {} : { roomChannel: room }),
+                            ...(input.payload === undefined ? {} : { input: input.payload }),
+                            ...(input.senderPrincipalId === undefined
+                                ? {}
+                                : { senderPrincipalId: input.senderPrincipalId }),
+                        },
+                    });
+                    return {
+                        inputId: rowId === null ? null : String(rowId),
+                        state: rowId === null ? 'duplicate' : 'accepted',
+                    };
+                },
+            };
+        };
         for (const [id, member] of members)
             memberIntakes.set(id, createMemberIntake(id, member));
         const retireMember = async (id, setAside = true) => {
             if (memberRoot === undefined)
                 throw new Error('Member lifecycle requires member_root');
+            surface.releasePrincipal(id);
             intakeRuntime.unservePrincipal(id);
             const member = members.get(id);
             if (member) {
@@ -569,7 +872,53 @@ async function createOwnerRuntime(options) {
             memberIntakes.set(principalId, memberIntake);
             return memberIntake;
         };
+        // Gateway DMs and personal jobs serve active unserved members through the directory lane. A
+        // served intake needs no directory work; P9 restores its own known paths on the member chain.
+        const serveMemberOnLane = (id) => {
+            executionAccess(id);
+            if (stopping)
+                return Promise.reject(new Error('Cannot serve a member after runtime stop'));
+            if (surface.memberRecords.isBlocked(id) && !intakeRuntime.servesPrincipal(id))
+                return Promise.resolve(createMemberIntake(id));
+            if (intakeRuntime.servesPrincipal(id))
+                return Promise.resolve(memberIntakes.get(id));
+            return sessions.exclusive(async () => {
+                if (stopping)
+                    throw new Error('Cannot serve a member after runtime stop');
+                if (surface.memberRecords.isBlocked(id) && !intakeRuntime.servesPrincipal(id))
+                    return createMemberIntake(id);
+                return serveMember(id);
+            });
+        };
+        const personalJobs = (0, personal_jobs_js_1.createPersonalJobScheduler)({
+            adapter: database.adapter,
+            store: surface.personalJobs,
+            mailbox: intakeRuntime.mailbox,
+            intake: serveMemberOnLane,
+            blocked: surface.memberRecords.isBlocked,
+            onError: (error) => options.onPersonalJobError?.(error),
+        });
+        let schedulerStop;
+        const beginStop = () => {
+            if (stopping)
+                return;
+            stopping = true;
+            schedulerStop = personalJobs.stop();
+            recordOrders.stop();
+            surface.memberRecords.stopRecovery();
+            intakeRuntime.beginStop();
+        };
+        let drainPromise;
+        const drain = () => (drainPromise ??= (async () => {
+            beginStop();
+            await intakeRuntime.stop();
+            await schedulerStop;
+            await surface.memberRecords.idle();
+            await sessions.idle();
+        })());
+        surface.memberRecords.startRecovery();
         return {
+            personalJobs,
             runtime: intakeRuntime,
             database,
             knowledge,
@@ -579,36 +928,89 @@ async function createOwnerRuntime(options) {
             wikiRoot,
             intake,
             acceptSourceDelta: intake.acceptSourceDelta,
-            serveMember: (id) => {
+            serveMember: serveMemberOnLane,
+            memberIntake: (id, room) => {
                 // Erasure owns restoration once it unserves the member. Intake callers must not
                 // recreate a writer while the host takes and delivers that member's snapshot.
                 if (surface.memberRecords.isBlocked(id) && !intakeRuntime.servesPrincipal(id))
+                    return createMemberIntake(id, undefined, room);
+                if (stopped)
+                    throw new Error('Cannot obtain member intake after runtime stop');
+                executionAccess(id);
+                const intake = memberIntakes.get(id);
+                if (!intake || !intakeRuntime.servesPrincipal(id))
                     throw new Error(`Member session is not served: ${id}`);
-                return serveMember(id);
+                if (room === undefined)
+                    return intake;
+                const session = members.get(id).roomSession(room);
+                return (0, stimulus_delivery_js_1.createStimulusIntake)(intakeRuntime, id, {
+                    saveOwnerMessage: (input) => {
+                        executionAccess(id, session.native.sessionKey);
+                        return session.chat.saveOwnerMessage(input);
+                    },
+                    saveReply: (input) => session.chat.saveReply(input),
+                    hasOwnerMessage: (ref) => session.chat.hasOwnerMessage(ref),
+                }, room);
             },
-            completeMemberEnrollment: (selection) => sessions.turnChain(async () => {
-                if (stopped)
-                    throw new Error('Cannot enroll a member after runtime stop');
+            principalPaths: (principalId, room) => {
+                if (principalId === options.ownerPrincipalId) {
+                    const downloadsDir = options.attachmentPorts?.downloadsDir;
+                    if (!downloadsDir?.trim())
+                        throw new Error('Owner downloads directory is required');
+                    return {
+                        workspaceDir: options.workspaceDir,
+                        downloadsDir,
+                    };
+                }
+                executionAccess(principalId);
+                sessions.get(principalId);
+                const member = members.get(principalId);
+                return room === undefined ? member.paths : member.roomSession(room).paths;
+            },
+            completeMemberEnrollment: (selection) => {
+                if (stopping)
+                    return Promise.reject(new Error('Cannot enroll a member after runtime stop'));
                 return surface.completeMemberEnrollment(selection);
-            }),
+            },
             recordHostExchange: ({ message, reply }) => {
-                chat.saveOwnerMessage(message);
-                chat.saveReply({ ...reply, messageRef: message.id, author: 'host' });
+                const person = message.id.startsWith('telegram:')
+                    ? principals.resolveByExternal('telegram', 'private', message.channelKey)
+                    : null;
+                if (person?.kind !== 'member') {
+                    chat.saveOwnerMessage({
+                        ...message,
+                        ...(person ? { senderPrincipalId: person.principalId } : {}),
+                    });
+                    chat.saveReply({ ...reply, messageRef: message.id, author: 'host' });
+                }
+                else {
+                    // A member being erased gets its personal copy after the erasure, never inside it.
+                    if (!surface.memberRecords.deferWhileErasing(person.principalId, { message, reply }))
+                        writeMemberHostExchange(person.principalId, { message, reply });
+                    const ref = `host:management:${message.id}`;
+                    chat.saveOwnerMessage({
+                        ...message,
+                        id: ref,
+                        channelKey: 'management',
+                        senderPrincipalId: person.principalId,
+                    });
+                    chat.saveReply({ ...reply, messageRef: ref, author: 'host' });
+                }
             },
             stop: () => {
                 if (stopPromise)
                     return stopPromise;
-                stopping = true;
+                beginStop();
                 stopPromise = (async () => {
-                    await surface.memberRecords.idle();
+                    await drain();
                     stopped = true;
-                    recordOrders.stop();
-                    await intakeRuntime.stop();
                     rawStore?.close();
                     await database.close();
                 })();
                 return stopPromise;
             },
+            beginStop,
+            drain,
         };
     }
     catch (error) {