@openrig/cli 0.6.14 → 0.7.0

package/daemon/dist/startup.js

@@ -1,8 +1,10 @@
-import { makeWatchdogDeliver, occurrenceAttempted, priorDigestAttempt } from "./domain/watchdog-delivery.js";
+import { physicalSessionName } from "./domain/session-registry.js";
+import { makeWatchdogDeliver } from "./domain/watchdog-delivery.js";
 import { fileURLToPath } from "node:url";
 import { discoverTailscaleSelfNames } from "./middleware/browser-boundary.js";
 import { configureShadowCapture } from "./domain/shadow-capture.js";
 import { SeatDeliveryGuard, resolveGuardTarget } from "./domain/seat-delivery-guard.js";
+import { seatCodexCorePluginDir, vendoredCorePluginDir } from "./domain/claude-core-plugin-env.js";
 import { queueRecoveryOwnsWake } from "./domain/queue-wake-ladder.js";
 import { HealthPolicyStore } from "./domain/health-policy.js";
 import { HealthCheckpointSource } from "./domain/health-checkpoints.js";
@@ -17,7 +19,7 @@ import { ALL_MIGRATIONS } from "./db/all-migrations.js";
 import { RigRepository } from "./domain/rig-repository.js";
 import { SessionRegistry } from "./domain/session-registry.js";
 import { deriveCanonicalSessionName, isHumanSeatSessionRef, parseSessionName } from "./domain/session-name.js";
-import { resolveExternal } from "./domain/gateway/external-admission.js";
+import { makeTopologyDestinationCheck } from "./domain/queue-destination-check.js";
 import { loadHumanRegistry } from "./domain/gateway/human-registry.js";
 import { EventBus } from "./domain/event-bus.js";
 import { NodeLauncher } from "./domain/node-launcher.js";
@@ -79,6 +81,7 @@ import { LegacyBundleSourceResolver as BundleSourceResolver } from "./domain/bun
 import { PodBundleSourceResolver } from "./domain/bundle-source-resolver.js";
 import { PsProjectionService } from "./domain/ps-projection.js";
 import { SeatActivityService } from "./domain/seat-activity-service.js";
+import { restoredRunnerHookEvidence } from "./routes/activity.js";
 import { readClaudeSelfReportEvidence } from "./adapters/claude-code-adapter.js";
 import { replaceFile } from "./adapters/replace-file.js";
 import { SeatStructuralActivityService } from "./domain/seat-structural-activity-service.js";
@@ -164,6 +167,7 @@ import { homeIsolationAdvisory } from "./domain/home-isolation.js";
 import { materializeBuiltinPolicyReference } from "./domain/builtin-policy-reference.js";
 import { withCommunityHarnessResolver, withCommunityHarnesses } from "./adapters/community-harness-runtime-adapter.js";
 import { ensureActivityHookToken, writeActivityEndpointFile, deriveActivityUrl, readActivityEndpointFile } from "./domain/activity-endpoint.js";
+import { restoreExistingRigUnattended } from "./domain/existing-rig-restore.js";
 import { getCompatibleOpenRigPath, getDefaultOpenRigPath, readOpenRigEnv, } from "./openrig-compat.js";
 const KNOWN_PROVIDER_AUTH_ENV = new Set([
     "ANTHROPIC_API_KEY",
@@ -300,33 +304,11 @@ export async function createDaemon(opts) {
     catch (error) {
         console.error("[slow-operation] setDegradedHandler registration failed", error);
     }
-    // PL-004 Phase A revision (R1): topology-backed validateRig.
-    // Reject `<member>@<unknown-rig>` shapes against the rig registry.
-    // Bare ids without `@` are also rejected
-    // (no canonical rig binding).
-    // OPR.0.4.6.MH1 FR-8: this gate is the ARCHETYPE consumer of the shared
-    // parse contract — human-seat classification BEFORE parse, then the
-    // greedy first-@ rig (so "member@rig@x" looks up rig "rig@x", misses,
-    // and rejects with the same unknown_destination_rig as ever — BR-1).
-    const topologyValidateRig = (sessionRef) => {
-        const parsed = parseSessionName(sessionRef);
-        // M1 A4b — @external entity-admission (checked BEFORE the human-CLASS bare-admit,
-        // which A2 also makes true for <local>@external): a queue row destinationed to
-        // <local>@external is admitted ONLY if the human is REGISTERED (or it is a literal
-        // scheme address); an unregistered entity is REFUSED (the 4b site carries the
-        // entity-level teaching via externalAdmissionTeaching). Admission is the gateway's
-        // job, never the classifier's (arch 8cd30094).
-        if (parsed.kind === "external") {
-            const reg = loadHumanRegistry();
-            const entities = reg.ok ? reg.entities.map((e) => ({ entityId: e.entityId, address: e.address })) : [];
-            return resolveExternal(parsed.local, entities).kind !== "unregistered";
-        }
-        if (isHumanSeatSessionRef(sessionRef))
-            return true;
-        if (parsed.kind !== "canonical")
-            return false;
-        return rigRepo.findRigsByName(parsed.rig).length > 0;
-    };
+    // PL-004 Phase A revision (R1): topology-backed validateRig (queue-destination-check.ts has the rule).
+    const topologyValidateRig = makeTopologyDestinationCheck({
+        findRigsByName: (name) => rigRepo.findRigsByName(name),
+        loadHumanRegistry: () => loadHumanRegistry(),
+    });
     // Seat absence in positively known local topology is advice, never admission
     // authority. Keep every typed destination intact, including adopted aliases.
     const topologyDestinationAdvisory = (sessionRef) => {
@@ -386,6 +368,7 @@ export async function createDaemon(opts) {
         // GHOST-STAGE (h): resolve the source seat's atom-B generation for the handoff-nudge Sent: line
         // (same injected-predicate layering — the queue never imports the session domain).
         resolveOccupantGeneration: (sessionName) => sessionRegistry.currentOccupantGenerationForSession(sessionName),
+        resolveSessionAddresses: (sessionName) => sessionRegistry.sessionAddresses(sessionName),
     });
     // W1 (transactional closure): ONE OutboxHandler shared between the deps slot
     // (sender-side audit surface) and the queue repo's durable wake-intent
@@ -393,6 +376,14 @@ export async function createDaemon(opts) {
     // db.transaction commits atomically with the close + successor create.
     const outboxHandlerInstance = new OutboxHandler(db);
     queueRepoInstance.attachOutbox(outboxHandlerInstance);
+    // Reconcile only the prior process's claims, before transport/producers/timers can start new sends.
+    let reconciledWakeIntents = 0;
+    try {
+        reconciledWakeIntents = queueRepoInstance.reconcileAbandonedWakeIntents();
+    }
+    catch (err) {
+        console.warn(`wake-intent claim recovery: failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+    }
     // PL-004 Phase B — classifier lease manager. Constructed early so both
     // the leaseManager dep slot and project-classifier can share one instance.
     // isAlive is post-attached after whoami-service is constructed.
@@ -446,15 +437,25 @@ export async function createDaemon(opts) {
     const seatActivityService = new SeatActivityService({
         tmux: tmuxAdapter,
         defaultWindowSeconds: 3,
-        permissionPromptReader: async (sessionName) => {
-            const activity = await probeSessionActivity({ sessionName, runtime: "codex", attachmentType: "tmux", tmuxAdapter });
+        permissionPromptReader: async (sessionName, runtime) => {
+            if (runtime === "claude-code") {
+                const context = sessionRegistry.findResumeContextByName(sessionName);
+                if (!context || context.runtime !== runtime
+                    || sessionRegistry.getBindingForNode(context.nodeId)?.attachmentType !== "tmux")
+                    return null;
+            }
+            const activity = await probeSessionActivity({ sessionName, runtime, attachmentType: "tmux", tmuxAdapter,
+                visibleScreenOnly: runtime === "claude-code" });
             if (activity.state === "unknown")
                 return null;
+            if (runtime === "claude-code" && activity.state === "needs_input"
+                && !["permission_prompt", "selection_prompt"].includes(activity.reason))
+                return null;
             return activity.state === "needs_input" && ["permission_prompt", "selection_prompt"].includes(activity.reason);
         },
-        permissionPromptChanged: (sessionName, confirmed) => {
+        permissionPromptChanged: (sessionName, confirmed, runtime) => {
             const latest = agentActivityStore.getLatestForNode({ sessionName });
-            agentActivityStore.recordHookEvent({ sessionName, runtime: "codex", generation: latest?.generation,
+            agentActivityStore.recordHookEvent({ sessionName, runtime, generation: latest?.generation,
                 hookEvent: confirmed ? "PermissionPromptConfirmed" : "PermissionPromptCleared" });
         },
         eventBus,
@@ -464,6 +465,8 @@ export async function createDaemon(opts) {
             const sessionsDir = nodePath.join(process.env.CLAUDE_CONFIG_DIR ?? nodePath.join(os.homedir(), ".claude"), "sessions");
             return readClaudeSelfReportEvidence({ sessionsDir, sessionName, seatNodeId });
         },
+        // pi and omp: after a restart, a runner seat takes its last recorded hook (current session and generation only).
+        restoreHookEvidence: (seat, runtime) => restoredRunnerHookEvidence(agentActivityStore, seat, runtime),
     });
     // 5b82324b — the STRUCTURAL activity cache (sibling of SeatActivityService). Captures pane TEXT once
     // per running seat per tick + classifies motion STRUCTURALLY, so the `rig ps` ACTIVITY column reflects
@@ -539,6 +542,13 @@ export async function createDaemon(opts) {
     // applies to the NEXT launch without a daemon restart; a resolution failure
     // falls back to off (bar hidden).
     const tmuxOptionSettings = new ContextPackSettingsStore();
+    tmuxAdapter.launchEnvironment = () => ({
+        inheritTmuxEnvironment: tmuxOptionSettings.resolveOne("terminal.inherit_tmux_environment").value === true,
+        // Reuse the selected auth/endpoint channel, not every daemon credential.
+        // Ordinary shell/config roots remain daemon-selected; seat overrides are merged by the adapter.
+        env: { ...Object.fromEntries(["LANG", "LC_ALL", "LC_CTYPE", "TZ", "TMPDIR", "XDG_CONFIG_HOME", "XDG_DATA_HOME", "XDG_CACHE_HOME", "CLAUDE_CONFIG_DIR"]
+                .map(key => [key, process.env[key]])), ...launchSessionEnv },
+    });
     const tmuxOptionDefaults = new TmuxOptionDefaultsApplier({
         tmuxAdapter,
         platform: opts?.tmuxOptionPlatform,
@@ -574,7 +584,7 @@ export async function createDaemon(opts) {
     // #275: one reader for both Codex launch adapters, with the PATH, HOME and CODEX_HOME a seat session gets.
     const readCodexNetworkDefault = codexNetworkDefaultReader({ launchPath: process.env.PATH, home: daemonHome, codexHome });
     const prepareTeamWorkspace = (sessionName) => prepareCodexTeamWorkspace(sessionName, new ContextPackSettingsStore().resolveConfig().workspaceRoot, process.env.OPENRIG_SHARED_DOCS_ROOT?.trim() || nodePath.join(daemonHome, ".openrig", "shared-docs"), daemonHome);
-    const codexResume = new CodexResumeAdapter(tmuxAdapter, { ensureManagedConfig: () => codexAdapter.ensureManagedConfig(), prepareTeamWorkspace, seatLaunchEnvironment, codexHome: configuredCodexHome, launchPath: process.env.PATH, detectDaemonSupport: codexDaemonSupportProbe(process.env.PATH, undefined, configuredCodexHome), readNetworkDefault: readCodexNetworkDefault });
+    const codexResume = new CodexResumeAdapter(tmuxAdapter, { ensureManagedConfig: async () => { await codexAdapter.ensureManagedConfig(); }, prepareTeamWorkspace, seatLaunchEnvironment, codexHome: configuredCodexHome, launchPath: process.env.PATH, detectDaemonSupport: codexDaemonSupportProbe(process.env.PATH, undefined, configuredCodexHome), readNetworkDefault: readCodexNetworkDefault });
     // OPR.0.4.6.PI1 — the Pi seat-state root + the compiled runner entry (daemon
     // dist). Shared by the Pi runtime adapter, the resume adapter, and the
     // resume-token capture sidecar reader.
@@ -753,7 +763,7 @@ export async function createDaemon(opts) {
                     w(nodePath.join(d, e.name), nodePath.join(pre, e.name));
                 else
                     r.push(pre ? nodePath.join(pre, e.name) : e.name);
-            } } w(dir, ""); return r; }, statMode: (p) => fs.statSync(p).mode, chmod: (p, m) => fs.chmodSync(p, m), homedir: daemonHome }, codexHome: configuredCodexHome, launchPath: process.env.PATH, detectDaemonSupport: codexDaemonSupportProbe(process.env.PATH, undefined, configuredCodexHome), readNetworkDefault: readCodexNetworkDefault, activityRelayPath: nodePath.resolve(import.meta.dirname, "../assets/plugins/openrig-core/hooks/scripts/activity-relay.cjs"), resolveHooksEnabled: async () => {
+            } } w(dir, ""); return r; }, statMode: (p) => fs.statSync(p).mode, chmod: (p, m) => fs.chmodSync(p, m), homedir: daemonHome }, codexHome: configuredCodexHome, launchPath: process.env.PATH, detectDaemonSupport: codexDaemonSupportProbe(process.env.PATH, undefined, configuredCodexHome), readNetworkDefault: readCodexNetworkDefault, activityRelayPath: nodePath.resolve(import.meta.dirname, "../assets/plugins/openrig-core/hooks/scripts/activity-relay.cjs"), resolveCorePluginDir: () => vendoredCorePluginDir(), resolveCorePluginSelected: (nodeId) => Boolean(seatCodexCorePluginDir({ id: nodeId, runtime: "codex" }, db)), resolveHooksEnabled: async () => {
             const { SettingsStore } = await import("./domain/user-settings/settings-store.js");
             return new SettingsStore().resolveOne("runtime.codex.hooks_enabled").value;
         }, resolveManagedConfigSettings: async () => {
@@ -827,6 +837,7 @@ export async function createDaemon(opts) {
         const realFs = {
             readFile: (p) => fs.readFileSync(p, "utf-8"),
             writeFile: (p, c) => fs.writeFileSync(p, c, "utf-8"),
+            copyFileExclusive: (src, dest) => fs.copyFileSync(src, dest, fs.constants.COPYFILE_EXCL),
             exists: (p) => fs.existsSync(p),
             mkdirp: (p) => fs.mkdirSync(p, { recursive: true }),
             listFiles: (dir) => {
@@ -894,6 +905,15 @@ export async function createDaemon(opts) {
     catch (err) {
         console.error(`[openrig] plugin vendor setup warning: ${err.message}`);
     }
+    // After vendoring, so Codex installs the openrig-core version this daemon ships: only when some Codex seat's resolved
+    // selection includes it (a daemon whose Codex seats didn't select it never installs it).
+    try {
+        const codexNodes = db.prepare("SELECT id FROM nodes WHERE runtime = 'codex'").all();
+        await codexAdapter.ensureCodexCorePluginAtBoot(codexNodes.some(({ id }) => Boolean(seatCodexCorePluginDir({ id, runtime: "codex" }, db))));
+    }
+    catch (err) {
+        console.error(`[openrig] runtime setup warning: ${err.message}`);
+    }
     // PL-014: one daemon-scoped ContextPackLibraryService backs the
     // delivery-free /api/context-packs list/sync/compose/read/delete/preview/pieces
     // routes. Startup context-pack expansion is intentionally unsupported;
@@ -1030,6 +1050,14 @@ export async function createDaemon(opts) {
     // observability. The kernel rig is still the only rig the daemon
     // auto-boots; other rigs require explicit operator-initiated
     // `rig up` / `rig restore` per amended IMPL-PRD §16.2.
+    const runtimeAdaptersMap = withCommunityHarnessResolver({
+        "claude-code": claudeAdapter,
+        "codex": codexAdapter,
+        "pi": piAdapter,
+        "omp": ompAdapter,
+        "stub": stubAdapter,
+        "terminal": new (await import("./adapters/terminal-adapter.js")).TerminalAdapter(),
+    }, { tmux: tmuxAdapter, seatLaunchEnvironment });
     let kernelBootTracker;
     try {
         const { bootKernelIfNeeded } = await import("./domain/kernel-boot.js");
@@ -1050,6 +1078,9 @@ export async function createDaemon(opts) {
             // workspace.root setting as the per-operator default.
             cwdOverride: runtimeSettings.workspaceRoot,
             degradedTimeoutMs,
+            // A kernel a reboot left down comes back the way `rig up kernel --existing` brings it back.
+            // Synchronous, so the restore is registered before any request can ask for the same one.
+            restoreLostKernel: (rigId) => restoreExistingRigUnattended({ rigRepo, snapshotRepo, snapshotCapture, restoreOrchestrator, runtimeAdapters: runtimeAdaptersMap, tmuxAdapter }, rigId, (p) => fs.existsSync(p)),
         });
         try {
             // eslint-disable-next-line no-console
@@ -1210,14 +1241,6 @@ export async function createDaemon(opts) {
     // Capture compatibility before the spec-library initializer creates the primary directory.
     const userSpecLibraryRoot = getDefaultOpenRigPath("specs");
     const compatibleSpecLibraryRoot = getCompatibleOpenRigPath("specs");
-    const runtimeAdaptersMap = withCommunityHarnessResolver({
-        "claude-code": claudeAdapter,
-        "codex": codexAdapter,
-        "pi": piAdapter,
-        "omp": ompAdapter,
-        "stub": stubAdapter,
-        "terminal": new (await import("./adapters/terminal-adapter.js")).TerminalAdapter(),
-    }, { tmux: tmuxAdapter, seatLaunchEnvironment });
     const deps = {
         rigRepo,
         sessionRegistry,
@@ -1328,6 +1351,7 @@ export async function createDaemon(opts) {
             // status == 'running'.
             classifierLeaseManagerInstance.attachIsAlive((classifierSession) => {
                 try {
+                    classifierSession = physicalSessionName(db, classifierSession);
                     const row = db
                         .prepare(`SELECT 1 FROM sessions WHERE session_name = ? AND status = 'running' LIMIT 1`)
                         .get(classifierSession);
@@ -1978,6 +2002,7 @@ export async function createDaemon(opts) {
     const sessionTransport = deps.sessionTransport;
     if (sessionTransport) {
         queueRepoInstance.attachActivityReader((session) => {
+            session = physicalSessionName(db, session);
             const node = db.prepare("SELECT node_id FROM sessions WHERE session_name = ? ORDER BY id DESC LIMIT 1").get(session);
             return node ? seatActivityService.getSeatState(node.node_id) : null;
         });
@@ -1987,8 +2012,7 @@ export async function createDaemon(opts) {
             eventBus,
             deliver: makeWatchdogDeliver({
                 sessionTransport,
-                outbox: outboxHandlerInstance,
-                db,
+                hasPendingPostCompactStage: (sessionName) => deps.compactionEnforcer?.hasPendingPostCompactStage(sessionName) ?? false,
                 createContinuityAction: (action) => createContinuityCutoverBaton(action, queueRepoInstance).then(() => { }),
             }),
             // (i-c) fire-time target-generation gate: resolve the target's LIVE occupant-generation (P12
@@ -2003,8 +2027,6 @@ export async function createDaemon(opts) {
             },
             // Due parked-row reminders for one seat in one scheduler pass go as one message.
             resolveDigestEntry: ({ jobId, message }) => queueRepoInstance.parkReminderDigestEntry(jobId, message),
-            priorDigestAttempt: (occurrenceId) => priorDigestAttempt(outboxHandlerInstance, occurrenceId),
-            occurrenceAttempted: (occurrenceId) => occurrenceAttempted(outboxHandlerInstance, occurrenceId),
             // PL-004 Phase D: register workflow-keepalive policy alongside
             // Phase C's three built-in policies. workflow-keepalive reads
             // SQLite workflow_instances directly via the new Phase D tables
@@ -2027,9 +2049,7 @@ export async function createDaemon(opts) {
                 // parked diagnosis (diagnoseRigParked over the arbitrated oracle +
                 // destination-scoped obligations + wake status; the same derivation
                 // `rig parked` serves) consumed by one rig-level supervisor job.
-                // Episode receipts are TRANSITIONS on the obligation row, written
-                // reserve-before-deliver (the retention active-frontier invariant is
-                // the durability proof); watchdog history is telemetry only.
+                // Attempt notes preserve prompt-refusal recovery; neither notes nor history suppress current reminders.
                 makeParkedOwnerConsumerPolicy({
                     diagnoseRig: (rigName) => {
                         const seats = db
@@ -2055,9 +2075,7 @@ export async function createDaemon(opts) {
                         listForJob: (jobId, limit) => watchdogHistoryLogInstance.listForJob(jobId, limit),
                         countForJob: (jobId) => watchdogHistoryLogInstance.countForJob(jobId),
                     },
-                    // R2 repair: the durable row-side surfaces. Receipts are transitions on
-                    // the obligation row (reserve-before-deliver); failures land in the
-                    // ladder's native last_nudge_result vocabulary.
+                    // Best-effort attempt reporting; actual prompt and failure recovery still use the existing ladder.
                     rows: {
                         recoveryOwnsWake: (qitemId) => queueRecoveryOwnsWake(db, queueRepoInstance.getById(qitemId)),
                         listTransitions: (qitemId) => queueRepoInstance
@@ -2078,6 +2096,8 @@ export async function createDaemon(opts) {
                         listOpenIds: (destinationSession) => queueRepoInstance.listOpenObligations(destinationSession, 500).map((r) => r.qitemId),
                     },
                     occupantGeneration: (sessionName) => sessionRegistry.currentOccupantGenerationForSession(sessionName),
+                    // The enforcer is constructed below; read its shared instance at evaluation time.
+                    hasPendingPostCompactStage: (sessionName) => deps.compactionEnforcer?.hasPendingPostCompactStage(sessionName) ?? false,
                 }),
                 // OPR.0.5.6.1 AM-F1 — the delivery engine's two timing legs on THIS
                 // substrate. The gateway dispatch binds late (the subsystem is built
@@ -2113,6 +2133,26 @@ export async function createDaemon(opts) {
                         return fn(op, ref, payload, opts);
                     },
                 }),
+                // Quiet hours: one release job per quiet window posts what was held, once quiet is off, through the same gateway.
+                (await import("./domain/policies/quiet-release.js")).makeQuietReleasePolicy({
+                    queueRepo: queueRepoInstance,
+                    jobsRepo: watchdogJobsRepoInstance,
+                    registry: { loadHumanRegistry: (home) => loadHumanRegistryForDelivery(home) },
+                    home: OPENRIG_HOME,
+                    dispatch: (op, ref, payload, opts) => {
+                        const fn = lateGatewayDispatch.fn;
+                        if (!fn)
+                            return { ok: false, error: "gateway not yet active" };
+                        return fn(op, ref, payload, opts);
+                    },
+                }),
+                // A person's mode ends at the scheduled end they chose, on the same clock.
+                (await import("./domain/policies/mode-scheduled-end.js")).makeModeScheduledEndPolicy({
+                    db,
+                    queueRepo: queueRepoInstance,
+                    jobsRepo: watchdogJobsRepoInstance,
+                    home: OPENRIG_HOME,
+                }),
             ],
         });
         queueRepoInstance.startWaitReminders();
@@ -2127,8 +2167,9 @@ export async function createDaemon(opts) {
         // ensured idempotently on the (policy, target_session) tuple; the anchor is
         // `parked-owner-consumer@<rigName>` (member@rig shape, policy name as the
         // member slug). activeWakeIntervalSeconds stays NULL so the engine never
-        // throttles one seat's wake because another fired — per-seat dedup lives in
-        // the durable episode receipts. Rigs created after startup are BORN ARMED:
+        // throttles one seat's wake because another fired. Only recorded success to
+        // the same known occupant with unchanged rows suppresses a repeat; failed,
+        // unknown or unrecorded attempts remain eligible. Prompt recovery stays with the ladder. Rigs created after startup are BORN ARMED:
         // rigRepo.onRigCreated (wired below) runs the same ensure in the creation
         // act itself (the birth-property ruling) — no restart wait, no watcher.
         {
@@ -2268,10 +2309,8 @@ export async function createDaemon(opts) {
         // No periodic timer (ruled out of scope): a transient failure lands the row
         // in a VISIBLE state and is retried on the next start.
         try {
-            // BLOCKING 1: reconcile abandoned `sending` claims (a prior crash) FIRST,
-            // then drain committed `pending` intents. Reconcile is a one-time boundary
-            // step, separate from the drain.
-            const reconciled = queueRepoInstance.reconcileAbandonedWakeIntents();
+            // Prior-process claims were reconciled before current-process producers started.
+            const reconciled = reconciledWakeIntents;
             const drained = await queueRepoInstance.drainPendingWakeIntents();
             if (drained.delivered || drained.indeterminate || drained.failed || reconciled) {
                 console.log(`wake-intent recovery sweep: delivered=${drained.delivered} indeterminate=${drained.indeterminate} failed=${drained.failed} reconciled=${reconciled}`);
@@ -2300,6 +2339,9 @@ export async function createDaemon(opts) {
             },
         })
         : undefined;
+    // A send to a seat this enforcer is compacting or restoring is delivered as always, with a notice of what it recorded.
+    if (compactionEnforcer)
+        deps.sessionTransport?.setCompactionObserver((sessionName) => compactionEnforcer.observedCompaction(sessionName));
     // 51-08 A1 — the over-time series rides the SAME 30s tick (PM decision 1):
     // context lane appends beside the existing persist; the provider-window lane
     // drains the same statusline cache directory the read model scans.
@@ -2377,7 +2419,7 @@ export async function createDaemon(opts) {
         wire: () => buildSlackGatewayWire({
             home: OPENRIG_HOME,
             queueRepo: queueRepoInstance,
-            resolveHumanReply: makeHumanReplyResolver(queueRepoInstance, deps.missionControlWriteContract),
+            resolveHumanReply: makeHumanReplyResolver(queueRepoInstance, deps.missionControlWriteContract, OPENRIG_HOME),
             log: (m) => console.log(`[gateway] ${m}`),
         }),
         log: (m) => console.log(`[gateway] ${m}`),