@openrig/cli 0.6.14 → 0.7.1

package/daemon/dist/startup.js

@@ -1,8 +1,12 @@
-import { makeWatchdogDeliver, occurrenceAttempted, priorDigestAttempt } from "./domain/watchdog-delivery.js";
+import { TerminalPolicyStore } from "./domain/terminal-policy.js";
+import { daemonDatabaseWarnings } from "./daemon-db-path.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 +21,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 +83,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 +169,8 @@ 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 { recoverSeatSkillAttempts } from "./domain/seat-skill-apply.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",
@@ -239,6 +246,13 @@ export async function createDaemon(opts) {
     // Only the explicit selection overrides a pane rc or the legacy PID-home
     // reader. The resolved default remains the writer/network-reader/session root.
     const dbPath = opts?.dbPath ?? ":memory:";
+    const seatDbPath = dbPath === ":memory:" ? dbPath : nodePath.resolve(dbPath);
+    const allowDbConflict = process.env.OPENRIG_ALLOW_DB_CONFLICT === "1";
+    delete process.env.OPENRIG_ALLOW_DB_CONFLICT; // this boot only; never pass the go-ahead to seats
+    const databaseWarnings = await daemonDatabaseWarnings(dbPath, OPENRIG_HOME, process.env.OPENRIG_DB === dbPath ? "OPENRIG_DB" : process.env.RIGGED_DB === dbPath ? "RIGGED_DB" : undefined, { conflictPolicy: new ContextPackSettingsStore().resolveOne("daemon.db_conflict").value,
+        allowConflict: allowDbConflict });
+    for (const warning of databaseWarnings)
+        console.warn(`Warning: ${warning}`);
     const db = createDb(dbPath);
     migrate(db, ALL_MIGRATIONS);
     // 51-09 increment 1 — establish the daemon's durable self-host identity at
@@ -300,33 +314,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 +378,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 +386,24 @@ 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)}`);
+    }
+    // OPR.0.7.0.13: a seat skill list attempt a previous process left mid-send becomes indeterminate, never resent. Like the
+    // wake-intent claims above, it is settled before this process can start new attempts.
+    try {
+        const seatSkillAttempts = recoverSeatSkillAttempts(db);
+        if (seatSkillAttempts)
+            console.log(`seat skill list recovery: ${seatSkillAttempts} interrupted attempt(s) marked indeterminate, not resent`);
+    }
+    catch (err) {
+        console.warn(`seat skill list 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 +457,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 +485,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
@@ -520,6 +543,8 @@ export async function createDaemon(opts) {
     const launchSessionEnv = {
         PATH: process.env.PATH,
         OPENRIG_HOME,
+        OPENRIG_DB: seatDbPath,
+        TMUX_TMPDIR: process.env.TMUX_TMPDIR,
         OPENRIG_PORT: openRigPort,
         OPENRIG_HOST: openRigHost,
         OPENRIG_URL: resolvedActivityHookUrl,
@@ -539,6 +564,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 +606,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.
@@ -622,13 +654,25 @@ export async function createDaemon(opts) {
     const rigs = rigRepo.listRigs();
     let reconcileChecked = 0;
     let reconcileDetached = 0;
+    let reconcileUnseen = 0;
     let reconcileErrors = 0;
     for (const rig of rigs) {
         try {
             const result = await reconciler.reconcile(rig.id);
             reconcileChecked += result.checked;
             reconcileDetached += result.detached;
+            reconcileUnseen += result.unseen.length;
             reconcileErrors += result.errors.length;
+            for (const u of result.unseen) {
+                try {
+                    // eslint-disable-next-line no-console
+                    console.warn(`startup reconcile: ${u.sessionName} isn't on this daemon's tmux server, but its last observed process ${u.pid} is still running`
+                        + `${u.parent ? ` (parent process ${u.parent.pid}: ${u.parent.command.slice(0, 160)})` : ""}, so it was left as it was: not marked`
+                        + ` detached and not relaunched. The daemon is probably using a different tmux server from its seats (it didn't inherit their`
+                        + ` TMUX). Restart the daemon from inside the seats' tmux server, or with TMUX set to it.`);
+                }
+                catch { /* logging must never throw */ }
+            }
             for (const e of result.errors) {
                 try {
                     // eslint-disable-next-line no-console
@@ -648,7 +692,7 @@ export async function createDaemon(opts) {
     }
     try {
         // eslint-disable-next-line no-console
-        console.log(`startup reconcile: rigs=${rigs.length} checked=${reconcileChecked} detached=${reconcileDetached} errors=${reconcileErrors}`);
+        console.log(`startup reconcile: rigs=${rigs.length} checked=${reconcileChecked} detached=${reconcileDetached} unseen=${reconcileUnseen} errors=${reconcileErrors}`);
     }
     catch { /* logging must never throw */ }
     // Transcript rotators are process-local. Reattach them after lifecycle
@@ -753,7 +797,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 +871,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 +939,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 +1084,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 +1112,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
@@ -1190,16 +1255,11 @@ export async function createDaemon(opts) {
             });
         });
     }
-    const { SeatAttentionReconciler } = await import("./domain/seat-attention-reconciler.js");
+    const { SeatAttentionReconciler, attentionProbeSend } = await import("./domain/seat-attention-reconciler.js");
     const seatAttentionReconciler = new SeatAttentionReconciler({
         sessionRegistry, eventBus, agentActivityStore, db, tmux: tmuxAdapter,
         reconcileRestoreOutcome: (rigId, nodeId) => restoreOrchestrator.reconcileNodeRuntimeTruth(rigId, nodeId),
-        sendVerify: async (session, text, opts) => {
-            const transport = deps.sessionTransport;
-            if (!transport)
-                return { ok: false, outcome: "failed" };
-            return transport.send(session, text, { verify: opts?.verify });
-        },
+        sendVerify: attentionProbeSend(() => deps.sessionTransport),
         capture: async (session, opts) => {
             const transport = deps.sessionTransport;
             if (!transport)
@@ -1210,15 +1270,8 @@ 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 = {
+        databaseWarnings,
         rigRepo,
         sessionRegistry,
         daemonLifecycleStore,
@@ -1282,7 +1335,7 @@ export async function createDaemon(opts) {
         seatIdentityReconciler,
         // OPR.0.4.4.21 — agentActivity feeds the rig-rollup attention
         // predicate's needs_input signal (synchronous events lookup only).
-        psProjectionService: new PsProjectionService({ db, seatActivity: seatActivityService, agentActivity: agentActivityStore }),
+        psProjectionService: new PsProjectionService({ db, seatActivity: seatActivityService, agentActivity: agentActivityStore, structuralActivity: seatStructuralActivityService }),
         upRouter: new UpCommandRouter({
             fsOps: {
                 exists: (p) => fs.existsSync(p),
@@ -1328,6 +1381,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);
@@ -1363,7 +1417,7 @@ export async function createDaemon(opts) {
         askService: (() => {
             // P19 A5 (finding graduated): inject seatActivity like the attention path
             // (line ~919) — one terminalActive truth, never two divergent projections.
-            const psProjectionService = new PsProjectionService({ db, seatActivity: seatActivityService, agentActivity: agentActivityStore });
+            const psProjectionService = new PsProjectionService({ db, seatActivity: seatActivityService, agentActivity: agentActivityStore, structuralActivity: seatStructuralActivityService });
             const execDep = (cmd, args) => new Promise((resolve) => {
                 execFile(cmd, args, { maxBuffer: 10 * 1024 * 1024 }, (err, stdout) => {
                     if (err && typeof err.code === "string" && err.code === "ENOENT") {
@@ -1806,8 +1860,7 @@ export async function createDaemon(opts) {
     // built, those scopes honestly return not-found rather than throwing.
     {
         const { TerminalService } = await import("./domain/terminal/terminal-service.js");
-        const { HerdrAdapter } = await import("./domain/terminal/herdr-adapter.js");
-        const { createHerdrSocketRpc, createHerdrSocketTransport, resolveHerdrSocketPath } = await import("./domain/terminal/herdr-transport.js");
+        const { createHerdrProviders } = await import("./domain/terminal/herdr-sessions.js");
         const { CmuxProviderAdapter } = await import("./domain/terminal/cmux-provider-adapter.js");
         const { CmuxLayoutService } = await import("./domain/cmux-layout-service.js");
         const { TerminalViewsStore } = await import("./domain/terminal/terminal-views-store.js");
@@ -1823,12 +1876,7 @@ export async function createDaemon(opts) {
             rigName: e.rigName,
             logicalId: e.logicalId,
         });
-        const herdrSocketPath = resolveHerdrSocketPath();
-        const herdrProvider = new HerdrAdapter({
-            // FB4: herdr speaks its unix control socket (there is no `layout` CLI).
-            transportFactory: createHerdrSocketTransport(createHerdrSocketRpc(herdrSocketPath)),
-            launch: { socketPath: herdrSocketPath, ...(process.env["HERDR_SESSION"] ? { session: process.env["HERDR_SESSION"] } : {}) },
-        });
+        const { defaultProvider: herdrProvider, sessionProvider: herdrSessionProvider } = createHerdrProviders();
         const cmuxProvider = new CmuxProviderAdapter({
             cmuxAdapter,
             // One gridded workspace per composed page — the same grid machinery as
@@ -1841,6 +1889,7 @@ export async function createDaemon(opts) {
         };
         deps.terminalService = new TerminalService({
             resolveProvider: (name) => providerMap[name] ?? null,
+            resolveSessionProvider: (name, session) => name === "herdr" ? herdrSessionProvider(session) : null,
             viewsStore: new TerminalViewsStore(),
             listRigSeatsBatch: (names) => {
                 const rigs = rigRepo.listRigs();
@@ -1978,6 +2027,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 +2037,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
@@ -1996,6 +2045,9 @@ export async function createDaemon(opts) {
             // UNKNOWN (null) fails open → deliver. A drop of this line disables the gate silently (gen-bound
             // wakes would fire at the successor) — pinned in watchdog-target-gen-wiring.test.ts.
             resolveTargetGeneration: (s) => sessionRegistry.currentOccupantGenerationForSession(s),
+            // Issue #1180 — sampled context use for token/percent context watchdogs,
+            // generation-guarded against a predecessor's frozen telemetry.
+            resolveContextUsage: (s, occupantGeneration) => watchdogJobsRepoInstance.findContextUsageForSession(s, occupantGeneration),
             resolvePreDeliveryTerminalReason: ({ jobId }) => queueRepoInstance.resolveWatchdogPreDeliveryTerminalReason(jobId),
             resolveQueueWait: (input) => queueRepoInstance.evaluateWaitReminder(input),
             onWakeAttempt: ({ jobId, deliveryStatus }) => {
@@ -2003,8 +2055,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 +2077,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 +2103,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 +2124,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 +2161,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 +2195,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.
         {
@@ -2178,7 +2247,7 @@ export async function createDaemon(opts) {
         // hardcoded); oversight = the fleet judgment seat, locally resolvable or a NAMED deferral
         // (no daemon-side cross-host send seam exists yet — the deferral names that, never silence).
         {
-            const { ModelDivergenceMonitor } = await import("./domain/model-divergence/model-divergence-monitor.js");
+            const { ModelDivergenceMonitor, proclaimedInEventLog } = await import("./domain/model-divergence/model-divergence-monitor.js");
             const OVERSIGHT_SEAT = "watch-lead@oversight";
             const modelDivergenceMonitor = new ModelDivergenceMonitor({
                 processCensus: modelCensus,
@@ -2200,7 +2269,7 @@ export async function createDaemon(opts) {
                     try {
                         const previous = deliveryId ? outboxHandlerInstance.getById(deliveryId) : null;
                         const payload = previous?.guardBinding ? previous.body : message;
-                        const result = await sessionTransport.send(target, payload, { deliveryId, actorSession: "model-monitor@system", auditPointer: deliveryId });
+                        const result = await sessionTransport.send(target, payload, { deliveryId, actorSession: "model-monitor@system", openrigNotice: true, auditPointer: deliveryId });
                         return result.ok ? { ok: true, outcome: result.outcome } : { ok: false, error: result.error };
                     }
                     catch (err) {
@@ -2230,9 +2299,11 @@ export async function createDaemon(opts) {
                         pinnedModel: proclamation.pinnedModel,
                         effectiveModel: proclamation.effectiveModel,
                         diagnosis: proclamation.diagnosis,
+                        occurrenceId: proclamation.occurrenceId,
                         channels: proclamation.channels,
                     });
                 },
+                wasProclaimed: proclaimedInEventLog(db),
             });
             modelDivergenceMonitor.startPolling(60_000);
             deps.modelDivergenceMonitor = modelDivergenceMonitor;
@@ -2268,10 +2339,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}`);
@@ -2294,12 +2363,16 @@ export async function createDaemon(opts) {
         // so a stage minted by a retired generation is refused for the successor. null = UNKNOWN → the
         // gate is inert (never compares a stale generation as if live).
         {
+            terminalPolicies: new TerminalPolicyStore(db),
             resolveOccupantGeneration: (sessionName) => sessionRegistry.currentOccupantGenerationForSession(sessionName),
             onPostRestoreComplete: (receipt) => {
                 recordManagedWidthReceipt(receipt, watchdogJobsRepoInstance, watchdogHistoryLogInstance);
             },
         })
         : 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.
@@ -2324,8 +2397,10 @@ export async function createDaemon(opts) {
     deps.occupantInvalidator = new DefaultOccupantInvalidator({
         enforcer: compactionEnforcer ?? { invalidateOccupant: () => { } },
         contextUsage: contextUsageStore,
-        // (e/Class-B) watchdog store — armed jobs registered by the retiring generation stop at swap.
+        // (e/Class-B) watchdog store — armed jobs the retiring generation registered for its own seat stop at swap.
         watchdog: watchdogJobsRepoInstance,
+        // The names that reach a seat, so a job addressed to its logical or physical spelling counts as its own.
+        addresses: sessionRegistry,
         // (e/Class-B) queue store — in-progress items claimed by the retiring generation release to pending.
         queue: queueRepoInstance,
         log: (msg) => console.warn(msg),
@@ -2377,7 +2452,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}`),