comisai 1.0.45 → 1.0.46

package/node_modules/@comis/daemon/dist/wiring/setup-schedulers.js

@@ -10,25 +10,25 @@
  * loops from the main daemon wiring sequence.
  * @module
  */
-import { safePath, SkillsConfigSchema, formatSessionKey, systemNowMs, systemSetTimeout, resolveAutonomy } from "@comis/core";
+import { safePath, SkillsConfigSchema, formatSessionKey, systemNowMs, systemSetTimeout, resolveAutonomy, resolveCronWakeGateEnabled, wrapExternalContent } from "@comis/core";
 import { createSessionResetScheduler } from "@comis/agent";
-import { computeNextRunAtMs, createCronScheduler, createCronStore, createExecutionTracker, resolveEffectiveHeartbeatConfig, resolveHeartbeatSessionKey, } from "@comis/scheduler";
+import { computeNextRunAtMs, createCronScheduler, createCronStore, createExecutionTracker, isInQuietHours, resolveEffectiveHeartbeatConfig, resolveHeartbeatSessionKey, } from "@comis/scheduler";
 /**
- * OBS-2/6b (hindsight-reflection-20260626): record a completed `__REFLECT__` run to the firing
+ * Record a completed `__REFLECT__` run to the firing
  * agent's execution tracker, so `cron.runs jobName "Reflection"` surfaces the reflection funnel
  * VERDICT (the admissionOutcome + counts) AND the run is POLLABLE — instead of a daemon.log grep.
  *
  * WHY here (not the cron executeJob path): the reflect sentinel is a fire-and-forget `system_event`,
  * so executeJob cannot await the ~22s reflection to record its result. Instead we fold the per-run
- * record off the content-free `reflect:funnel` event (OBS-1 put the full funnel on it). `jobId` mirrors
+ * record off the content-free `reflect:funnel` event (which carries the full funnel). `jobId` mirrors
  * the reflect cron's id (`reflect-<agentId>`) so `resolveJobByName(scheduler,"Reflection")` resolves to
- * this history. Content-free: the summary is the closed admissionOutcome enum + counts ONLY (INV-6 —
- * never a doc body). `durationMs` is 0 (the event carries no duration; the verdict + ts are the value).
+ * this history. Content-free: the summary is the closed admissionOutcome enum + counts ONLY —
+ * never a doc body. `durationMs` is 0 (the event carries no duration; the verdict + ts are the value).
  */
 export async function recordReflectFunnelRun(tracker, funnel, nowMs) {
     if (tracker === undefined)
         return; // unknown/unregistered agent → no-op (never throws)
-    // OBS-7: `topics=N` (distinctTopicKeys) + maxCard makes under-merge readable on `cron.runs`:
+    // `topics=N` (distinctTopicKeys) + maxCard makes under-merge readable on `cron.runs`:
     // admitted=0 with topics>1 & maxCard=1 = successes that didn't merge (vs topics=1 maxCard>=2 = corroborated).
     const summary = `reflect: outcome=${funnel.admissionOutcome} admitted=${funnel.admitted}` +
         ` maxCard=${funnel.maxClusterCardinality} topics=${funnel.distinctTopicKeys} untrustedDrops=${funnel.untrustedDrops}` +
@@ -36,12 +36,12 @@ export async function recordReflectFunnelRun(tracker, funnel, nowMs) {
     await tracker.record({ ts: nowMs, jobId: `reflect-${funnel.agentId}`, status: "ok", durationMs: 0, summary });
 }
 /**
- * OBS-2b (reflect-obs-20260627): record a completed `__MEMORY_LIFECYCLE__` sweep to the firing agent's
+ * Record a completed `__MEMORY_LIFECYCLE__` sweep to the firing agent's
  * execution tracker, so `cron.runs jobName "Memory lifecycle"` surfaces the sweep result (scanned/
  * evicted/demoted/promoted) — instead of a `db.mjs` `evicted_at` poll. The parity recorder for the
  * forget half of learning (reflection has recordReflectFunnelRun). `jobId` mirrors the lifecycle cron's
  * id (`memory-lifecycle-<agentId>`) so `resolveJobByName(scheduler,"Memory lifecycle")` resolves to this
- * history. Content-free: counts ONLY (INV-6). Recorded off the content-free `learning:lifecycle_swept`
+ * history. Content-free: counts ONLY. Recorded off the content-free `learning:lifecycle_swept`
  * event (the sentinel is fire-and-forget, so executeJob can't await the sweep). `durationMs` is 0 (the
  * event carries no duration; the counts + ts are the value).
  */
@@ -56,6 +56,21 @@ import { createBrowserService } from "@comis/skills";
 import * as fs from "node:fs/promises";
 import { emitMemoryCostFeatureNotice } from "./setup-memory-cost-notice.js";
 // ---------------------------------------------------------------------------
+// Wake-gate context injection
+// ---------------------------------------------------------------------------
+/**
+ * Return a copy of `job` with `wrapped` (an already-`wrapExternalContent`-wrapped
+ * gate finding) prepended to the text the model reads: the `agent_turn` message or
+ * the `system_event` text. A job whose gate does not inject is never passed here,
+ * so a no-gate / no-context fire stays byte-identical.
+ */
+function withInjectedContext(job, wrapped) {
+    if (job.payload.kind === "agent_turn") {
+        return { ...job, payload: { ...job.payload, message: `${wrapped}\n\n${job.payload.message}` } };
+    }
+    return { ...job, payload: { ...job.payload, text: `${wrapped}\n\n${job.payload.text}` } };
+}
+// ---------------------------------------------------------------------------
 // Setup function
 // ---------------------------------------------------------------------------
 /**
@@ -71,15 +86,14 @@ import { emitMemoryCostFeatureNotice } from "./setup-memory-cost-notice.js";
  * @param deps.skillsLogger     - Module-bound logger for skills subsystem
  */
 export async function setupSchedulers(deps) {
-    const { container, workspaceDirs, sessionStore, sessionManager, schedulerLogger, agentLogger, skillsLogger, subprocessEnv, systemEventQueue, onCronWake, clock, timers, leaseManager, boundedAutonomyHolder } = deps;
+    const { container, workspaceDirs, sessionStore, sessionManager, schedulerLogger, agentLogger, skillsLogger, subprocessEnv, systemEventQueue, onCronWake, clock, timers, leaseManager, boundedAutonomyHolder, wakeGateRunnerRef, trajectoryRegistry } = deps;
     const agents = container.config.agents; // Always populated after schema transform
     const schedulerConfig = container.config.scheduler;
-    // Master cost-feature kill switch (opt-out posture; renamed from memory.costFeatures.enabled to
-    // memory.enabled in Phase 226). When the operator sets memory.enabled:false, EVERY LLM
+    // Master cost-feature kill switch (opt-out posture; the config key is memory.enabled).
+    // When the operator sets memory.enabled:false, EVERY LLM
     // cost-bearing memory cron is force-disabled at its registration site below — regardless of the
     // agent's own per-feature opt-in. The gated set: memoryReview, memoryUsefulnessJudge, the
-    // __REFLECT__ reflection cron. NOT gated: the $0 keyless memoryLifecycle sweep. (The
-    // socialModeling cron was DELETED in Phase 226 SIMPLIFY-03 with the rest of that subsystem.)
+    // __REFLECT__ reflection cron. NOT gated: the $0 keyless memoryLifecycle sweep.
     // Default true (schema default) ⇒ byte-identical registration. Read defensively (`!== false`) so an
     // unexpectedly-absent block fails OPEN to the prior behavior rather than silently disabling features.
     const costFeaturesEnabled = container.config.memory?.enabled !== false;
@@ -108,10 +122,201 @@ export async function setupSchedulers(deps) {
         executionTrackers.set(agentId, agentExecTracker);
         const scheduler = createCronScheduler({
             store: agentCronStore,
-            executeJob: async (job) => {
+            executeJob: async (jobInput) => {
+                // `let job` is the seam: the wake-gate may reassign it with injected
+                // context, and every downstream `job.` read then resolves against the
+                // (possibly enriched) local. No gate ⇒ job === jobInput ⇒ byte-identical.
+                let job = jobInput;
                 const startTs = systemNowMs();
                 const jobLogger = schedulerLogger.child({ agentId, jobId: job.id, jobName: job.name });
                 try {
+                    // Pre-payload wake-gate. When the job carries a `wakeGate` AND a runner
+                    // ref is populated (read at FIRE time — the runner is built after this
+                    // scheduler, in the cap layer), run the gate BEFORE the payload branch:
+                    //   - runAsToday (host cannot jail / autonomy off) → fall through unchanged.
+                    //   - wake:false → skip the payload entirely (the model never runs), record
+                    //     a visible skipped row, and return status:ok so the job re-arms cleanly
+                    //     (a status:error would wrongly trigger backoff).
+                    //   - wake:true + context → prepend the wrapExternalContent-wrapped finding
+                    //     so the model starts informed, then fall through to the normal dispatch.
+                    // runWakeGate never throws (it fails open to wake), so a broken gate can
+                    // never silently drop a monitored job. A job without `wakeGate` (or with no
+                    // runner ref) is byte-identical to today.
+                    // Consult the operator toggle BEFORE running the gate. A
+                    // scheduler-initiated gate is a distinct trust context — no human or
+                    // model in the loop at fire time — so an operator can allow
+                    // model-initiated orchestrate while disabling these gates. When the
+                    // toggle resolves OFF (explicit false, or unset with the agent's
+                    // script surface off), runWakeGate is never called and the job falls
+                    // straight through to the existing dispatch, byte-identical to a
+                    // no-wakeGate job. The gate rides the agent's existing caps at the cap
+                    // socket; the toggle grants none.
+                    const gateRunner = wakeGateRunnerRef?.ref;
+                    if (job.wakeGate &&
+                        gateRunner &&
+                        resolveCronWakeGateEnabled(effectiveCron.wakeGate, agentConfig.autonomy?.script)) {
+                        const outcome = await gateRunner.runWakeGate(job.wakeGate, {
+                            agentId: job.agentId,
+                            jobId: job.id,
+                            sessionKey: resolveMainSessionKey(job.agentId),
+                        });
+                        if (!("runAsToday" in outcome)) {
+                            // The verdict drives the existing skip/deliver/context branches; the
+                            // per-fire counts (durationMs + toolCalls from the runner) plus the
+                            // derived estTurnsSaved (1 avoided model turn per skip, 0 on wake)
+                            // feed the content-free scheduler:wake_gate emitted ONCE below for
+                            // BOTH branches. A runAsToday degrade never reaches here (the job ran
+                            // as today — no gate to measure), so it emits nothing.
+                            const { verdict, durationMs, toolCalls, failedOpen, rootRunId } = outcome;
+                            const estTurnsSaved = verdict.wake ? 0 : 1;
+                            // Content-free savings/health signal (I5): ids / verdict enum /
+                            // counts ONLY — NEVER the gathered finding, the script source, or a
+                            // secret. This is the fleet fork's feed (a cross-session skip-rate /
+                            // turns-saved / net-cost rollup); it is wired independently of the
+                            // woke case's direct trajectory record below.
+                            container.eventBus.emit("scheduler:wake_gate", {
+                                jobId: job.id,
+                                agentId: job.agentId,
+                                wake: verdict.wake,
+                                durationMs,
+                                toolCalls,
+                                estTurnsSaved,
+                                failedOpen,
+                                timestamp: systemNowMs(),
+                            });
+                            if (!verdict.wake) {
+                                // Deliver-on-skip: a routine ✓ status delivered directly with NO
+                                // model turn. verdict.deliver is already OutputGuard-scrubbed by the
+                                // runner (safe to ship verbatim). Reuse the existing cron delivery
+                                // path (scheduler:job_result) with payloadKind:"system_event" (→ the
+                                // listener's raw verbatim branch) and NO onComplete (the deferred
+                                // resolver is the sole model trigger — omitting it means the model
+                                // never runs). Honor quiet-hours: a routine ✓ must not ping off-hours;
+                                // when quiet, suppress the delivery but STILL record the skip.
+                                const nowMs = systemNowMs();
+                                if (verdict.deliver && job.deliveryTarget) {
+                                    // isInQuietHours throws on a malformed quietHours.start/end (the
+                                    // schema does not validate HH:MM). Contain the throw here: it must
+                                    // NOT reach executeJob's catch, where this DECIDED skip would degrade
+                                    // to status:"error" → consecutiveErrors → auto-suspend, silently
+                                    // killing the monitor. Fail toward not-pinging (treat as quiet) so a
+                                    // routine status never fires at the wrong time; the skip is still recorded.
+                                    let quiet;
+                                    try {
+                                        quiet = isInQuietHours(schedulerConfig.quietHours, nowMs);
+                                    }
+                                    catch (qhErr) {
+                                        jobLogger.warn({
+                                            err: qhErr,
+                                            step: "wake-gate",
+                                            errorKind: "config",
+                                            hint: "scheduler.quietHours.start/end must be HH:MM — suppressing this routine deliver and recording the skip",
+                                        }, "Wake-gate quiet-hours check failed — suppressing deliver");
+                                        quiet = true;
+                                    }
+                                    if (quiet) {
+                                        jobLogger.debug({ step: "wake-gate", wake: false, quietHours: true }, "Wake-gate deliver suppressed (quiet hours) — recording skip only");
+                                    }
+                                    else {
+                                        container.eventBus.emit("scheduler:job_result", {
+                                            jobId: job.id,
+                                            jobName: job.name,
+                                            agentId: job.agentId,
+                                            result: verdict.deliver, // pre-scrubbed by the runner
+                                            success: true,
+                                            deliveryTarget: job.deliveryTarget,
+                                            timestamp: nowMs,
+                                            payloadKind: "system_event", // force the raw verbatim branch — NO model turn
+                                            // onComplete OMITTED → nothing runs the model
+                                        });
+                                        jobLogger.info({ step: "wake-gate", wake: false, delivered: true, durationMs, toolCalls, estTurnsSaved, ...(rootRunId ? { rootRunId } : {}) }, "Wake-gate delivered a routine status (no model turn)");
+                                    }
+                                }
+                                else if (verdict.deliver) {
+                                    // A deliver on a deliveryTarget-less job is dropped — there is no
+                                    // channel to send to. Log it distinctly so a gate author sees the
+                                    // status was discarded (vs a plain no-deliver skip).
+                                    jobLogger.debug({
+                                        step: "wake-gate",
+                                        wake: false,
+                                        hint: "gate returned a deliver but the job has no deliveryTarget — nothing to deliver to; recording skip only",
+                                    }, "Wake-gate deliver dropped (no delivery target)");
+                                }
+                                else {
+                                    jobLogger.info({ step: "wake-gate", wake: false, durationMs, toolCalls, estTurnsSaved, ...(rootRunId ? { rootRunId } : {}) }, "Wake-gate skipped the job (no model turn)");
+                                }
+                                await agentExecTracker.record({
+                                    ts: systemNowMs(), jobId: job.id, status: "skipped",
+                                    durationMs: systemNowMs() - startTs, summary: "wake-gate: skipped",
+                                    // The skip lens: the counts (never any finding text) let
+                                    // `cron.runs "<jobName>"` reconstruct each suppressed fire. The
+                                    // rootRunId lets an operator pivot to `comis explain <rootRunId>`
+                                    // for a gate that made cap-calls before skipping (a skip-after-fetch).
+                                    toolCalls, estTurnsSaved, ...(rootRunId ? { rootRunId } : {}),
+                                });
+                                return { status: "ok", summary: "wake-gate: skipped" };
+                            }
+                            // §2.7 completion line for a WOKE fire. A skip already logs its own
+                            // INFO above; a wake previously logged only DEBUG, so a raw-log reader
+                            // saw skips but never wakes — the log was not self-sufficient. One INFO
+                            // per gated fire (wake OR skip) makes every decision reconstructable
+                            // from the log alone. `failedOpen` distinguishes a broken fail-open wake
+                            // (crash/timeout/over-cap) from a clean decision; `rootRunId` lets an
+                            // operator reconstruct the gate's cap-calls via `security audit-log`.
+                            jobLogger.info({ step: "wake-gate", wake: true, failedOpen, durationMs, toolCalls, estTurnsSaved, ...(rootRunId ? { rootRunId } : {}) }, failedOpen ? "Wake-gate woke the model (fail-open)" : "Wake-gate woke the model");
+                            if (verdict.context) {
+                                // The wrapExternalContent markers exist to inform the MODEL, so
+                                // only inject where the payload actually reaches one: an agent_turn
+                                // (always model) or a main-routed system_event (heartbeat → model).
+                                // A non-main system_event with a deliveryTarget is delivered as RAW
+                                // text with no model — injecting there would leak the untrusted-
+                                // content boundary markers verbatim to the channel. Mirror the
+                                // main+system_event → heartbeat branch condition below exactly.
+                                const reachesModel = job.payload.kind === "agent_turn" ||
+                                    (job.sessionTarget === "main" && job.payload.kind === "system_event" && !!systemEventQueue);
+                                if (reachesModel) {
+                                    job = withInjectedContext(job, wrapExternalContent(verdict.context, { source: "unknown" }));
+                                }
+                                else {
+                                    jobLogger.debug({ step: "wake-gate", wake: true }, "Wake-gate context dropped — this fire delivers verbatim (no model to inform)");
+                                }
+                            }
+                            // A woke fire runs the model in the job's main session — record a
+                            // content-free wake-gate event DIRECTLY onto that session's trajectory
+                            // so `comis explain <sessionKey|rootRunId>` folds the fire and its
+                            // cap-calls. Off-turn: the cron/daemon context has no live bus bridge,
+                            // so this mirrors the image / capability-audit direct emits (a
+                            // per-session recorder call, not a bus subscription) — the incident
+                            // fork's feed, wired independently of the fleet emit above.
+                            //
+                            // BEST-EFFORT enrichment: this trajectory record is the ONLY source of
+                            // the woke cronWakeGate fact, so it reaches `comis explain` ONLY when
+                            // the main-session recorder is already open. When it is not — a daemon
+                            // restart (the registry is empty until the first turn opens the main
+                            // session), a monitor-only agent whose main session no turn ever
+                            // opens, or an idle-evicted session — getRecorder resolves undefined
+                            // and the fact is DROPPED. The fire stays reconstructable from the
+                            // DURABLE fleet fork (the cron_wake_gate DiagnosticRow /
+                            // cron_wake_gate_efficiency block) and the cap-audit stream
+                            // (`explain <rootRunId>`), so the drop degrades one lens, never the
+                            // fire's record. Emit a DEBUG on the drop so it is observable rather
+                            // than a silent no-op; never throw (a throw here would degrade the
+                            // job). A SKIP records NOTHING here — it opens no session; its lens is
+                            // the enriched cron.runs row.
+                            // Content-free (I5): ids / enum / counts ONLY — never the finding.
+                            const wakeRecorder = trajectoryRegistry?.getRecorder?.(resolveMainSessionKey(job.agentId));
+                            if (wakeRecorder) {
+                                wakeRecorder.recordEvent("scheduler.wake_gate", { jobId: job.id, agentId: job.agentId, wake: true, durationMs, toolCalls, estTurnsSaved: 0 });
+                            }
+                            else {
+                                jobLogger.debug({
+                                    step: "wake-gate",
+                                    wake: true,
+                                    hint: "no open main-session recorder — the woke trajectory fact was dropped; the fire is still captured by the fleet cron_wake_gate lens and the cap-audit stream (explain <rootRunId>)",
+                                }, "Wake-gate woke trajectory record dropped (no open session recorder)");
+                            }
+                        }
+                    }
                     // Route main-session systemEvent jobs through heartbeat pipeline
                     if (job.sessionTarget === "main" && job.payload.kind === "system_event" && systemEventQueue) {
                         const mainSessionKey = resolveMainSessionKey(agentId);
@@ -136,12 +341,12 @@ export async function setupSchedulers(deps) {
                     // --- Existing isolated/direct path below (unchanged) ---
                     const resultText = job.payload.kind === "system_event" ? job.payload.text : job.payload.message;
                     if (!job.deliveryTarget) {
-                        // system_event jobs STILL emit scheduler:job_result (live finding
-                        // 2026-06-11): the memory crons (review / consolidation /
+                        // system_event jobs STILL emit scheduler:job_result: the memory
+                        // crons (review / consolidation /
                         // reasoning / user-representation / usefulness-judge) are
                         // deliveryTarget-less __SENTINEL__ jobs whose
                         // actual WORK rides the scheduler:job_result listener
-                        // (setup-channels-credentials). The old return-before-emit made
+                        // (setup-channels-credentials). A return-before-emit would make
                         // every memory cron complete "ok" nightly while doing NOTHING.
                         // The sentinel listeners return before delivery; a non-sentinel
                         // deliveryTarget-less system_event hits the listener's own
@@ -176,13 +381,13 @@ export async function setupSchedulers(deps) {
                     const deferredPromise = isAgentTurn
                         ? new Promise((resolve) => { deferredResolve = resolve; })
                         : undefined;
-                    // Phase 213-08 (RATE-02): a cron-FIRED agent_turn run mints a FRESH lease
+                    // A cron-FIRED agent_turn run mints a FRESH lease
                     // scoped to the JOB's agentId + the agent's RESOLVED caps (NOT operator/
                     // system) + a fresh root-cron-* id (a new root, no parentLeaseId), then
                     // registerRoot anchors it. STRICTLY gated on agent_turn (system_event memory
                     // crons do NOT mint). Best-effort: absent leaseManager/holder → skip (byte-
-                    // identical to pre-213 unbounded cron); a mint throw is WARN-logged + job STILL runs.
-                    // WR-04 (213-REVIEW): the cron-fired run dispatches via `scheduler:job_result` (not `runner.spawn`), so it deliberately does NOT consult CEIL-01. Cron fan-out is already triple-bounded — `cron.maxConcurrentRuns` (caps simultaneous fires, `cron-scheduler.ts:99`), the per-root budget this mint anchors (token+wall-clock), and `cronSelfMax` (caps self-owned job count). A cron-spawned sub-agent is still CEIL-01-bound via session.spawn→resolveRootRunId (a distinct per-session root; correlating it to this `root-cron-*` is a future enhancement, not an M1 gap).
+                    // identical to an unbounded cron); a mint throw is WARN-logged + job STILL runs.
+                    // The cron-fired run dispatches via `scheduler:job_result` (not `runner.spawn`), so it deliberately does NOT consult the session-spawn concurrency ceiling. Cron fan-out is already triple-bounded — `cron.maxConcurrentRuns` (caps simultaneous fires, `cron-scheduler.ts:99`), the per-root budget this mint anchors (token+wall-clock), and `cronSelfMax` (caps self-owned job count). A cron-spawned sub-agent is still ceiling-bound via session.spawn→resolveRootRunId (a distinct per-session root; correlating it to this `root-cron-*` is a future enhancement).
                     const capLayer = boundedAutonomyHolder?.current;
                     if (isAgentTurn && leaseManager && capLayer) {
                         try {
@@ -311,40 +516,35 @@ export async function setupSchedulers(deps) {
                 schedulerLogger.info({ agentId, schedule: memoryReviewConfig.schedule ?? "0 2 * * *" }, "Registered memory review cron job");
             }
         }
-        // -- (Phase 225 FOLD §3.2) The standalone __MEMORY_CONSOLIDATION__ / __MEMORY_REASONING__ /
-        //    __USER_REPRESENTATION__ cron registrations were REMOVED here: their work folds into the
-        //    ONE __REFLECT__ cron (which now reflects skill + profile + topic in one pass, Plan 04). The
-        //    I1 model — the old crons are GONE, not run in parallel. (Their now-dead job BODIES are
-        //    deleted in Plan 05; this plan removes the registrations + the sentinel intercepts so they
-        //    never fire.) __SOCIAL_MODELING__ was DELETED in Phase 226-04 (the block below).
-        // (The social-modeling cron — __SOCIAL_MODELING__, gated by socialModeling.enabled +
-        // a recorded privacyReviewSignedOffBy — was DELETED in Phase 226 SIMPLIFY-03 with the
-        // ENTIRE social-modeling subsystem (the runRelationshipBuild offline directional-edge
-        // builder, the createRelationshipSeam cheap-model seam, the RelationshipStore port +
-        // sqlite adapter, the `relationship` table, the relationship-block prompt injection).
-        // The per-agent socialModeling config key is gone — a config carrying it is now rejected
-        // at parse (the D-01a operator-update path). Deleting it removes a prompt-injected
-        // relationship-model attack surface; no dormant seam left behind (full delete, I1).
-        // After this, the learning crons are exactly 3: __REFLECT__ + __MEMORY_LIFECYCLE__ +
+        // The standalone __MEMORY_CONSOLIDATION__ / __MEMORY_REASONING__ /
+        //    __USER_REPRESENTATION__ cron registrations do NOT exist here: their work folds into the
+        //    ONE __REFLECT__ cron (which reflects skill + profile + topic in one pass). The
+        //    old crons are GONE, not run in parallel. __SOCIAL_MODELING__ is likewise not registered
+        //    (the block below).
+        // (There is no social-modeling cron — __SOCIAL_MODELING__ — and no social-modeling
+        // subsystem: no offline directional-edge builder, no cheap-model relationship seam, no
+        // RelationshipStore port + sqlite adapter, no `relationship` table, no relationship-block
+        // prompt injection. There is no per-agent socialModeling config key — a config carrying it
+        // is rejected at parse. This keeps a prompt-injected relationship-model attack surface off
+        // the system entirely; no dormant seam is left behind.
+        // The learning crons are exactly 3: __REFLECT__ + __MEMORY_LIFECYCLE__ +
         // the event-driven OutcomeSignalPort.resolve path (__MEMORY_REVIEW__ stays accumulate-tier).)
-        // (The usefulness-judge cron — __USEFULNESS_JUDGE__, gated by memoryUsefulnessJudge.enabled
-        // — was DELETED in Phase 226 SIMPLIFY-03 (D-03). It was a dormant cost-gated cheap-model
-        // seam that fed recordUsage; the FORGET-02 reward write lives in setup-learning.ts and is
-        // unaffected. The per-agent memoryUsefulnessJudge config key is gone — a config carrying it
-        // is now rejected at parse, the D-01a operator-update path.)
-        // (The online-tuning bandit cron — __ONLINE_TUNING__, gated by memoryOnlineTuning.enabled
-        // — was DELETED in Phase 224. The UCB recall bandit is gone; recall scoring is the fixed
-        // config.rag.scoring alphas, with no offline tuned-alpha write job.)
+        // (There is no usefulness-judge cron — __USEFULNESS_JUDGE__. It was a dormant cost-gated
+        // cheap-model seam that fed recordUsage; the reward write lives in setup-learning.ts and is
+        // unaffected. There is no per-agent memoryUsefulnessJudge config key — a config carrying it
+        // is rejected at parse.)
+        // (There is no online-tuning bandit cron — __ONLINE_TUNING__. There is no UCB recall bandit;
+        // recall scoring is the fixed config.rag.scoring alphas, with no offline tuned-alpha write job.)
         // -- Memory lifecycle cron job --
         // OPT-IN, OFF by default. A DETERMINISTIC + KEYLESS (no LLM call, no API key — the sentinel
         // dispatch makes NO model resolution) sweep, so enabling it is a behavior opt-in, not a cost opt-in.
         // Registered ONLY when the operator sets memoryLifecycle.enabled; a default agent
         // registers NO job → byte-identical with the config absent. Default schedule 0 9 * * *
-        // runs AFTER online-tuning's 0 8 so the FEED + tuned alphas it reads have settled. Job
-        // options mirror the online-tuning job 1:1 (isolated / next-heartbeat / no forward-to-main
-        // / fresh). The __MEMORY_LIFECYCLE__ sentinel (setup-channels-memory-crons → the DORMANT
+        // runs at 09:00, after any early-morning feed has settled. Job
+        // options: isolated / next-heartbeat / no forward-to-main / fresh. The __MEMORY_LIFECYCLE__
+        // sentinel (setup-channels-memory-crons → the DORMANT
         // runLifecycleSweep) re-checks the knob; even when on, the SCAFFOLD evicts/demotes NOTHING
-        // (the live policy is the deferred operator step — OD4).
+        // (the live policy is the deferred operator step).
         const memoryLifecycleConfig = agentConfig.memoryLifecycle;
         if (memoryLifecycleConfig?.enabled) {
             const memLifecycleJobId = `memory-lifecycle-${agentId}`;
@@ -368,23 +568,21 @@ export async function setupSchedulers(deps) {
                 schedulerLogger.info({ agentId, schedule: memoryLifecycleConfig.schedule ?? "0 9 * * *" }, "Registered memory lifecycle cron job");
             }
         }
-        // (The memory triple-extraction cron — __MEMORY_TRIPLE_EXTRACTION__, gated by
-        // memoryTripleExtraction.enabled — was DELETED in Phase 226 SIMPLIFY-03 (D-03). It scheduled
-        // a no-op scaffold whose `extract` returned [] (no triples were ever written). The per-agent
-        // memoryTripleExtraction config key is gone — a config carrying it is now rejected at parse,
-        // the D-01a operator-update path. The TripleStorePort + its sqlite adapter + the graphSpread
-        // recall lane SURVIVE — only the dormant extraction JOB went, not the read lane.)
-        // -- Reflection cron job (v2.31 Reflection, Phase 223, REFLECT-01) --
-        // The reflect-engine replacement for the dead procedural-synthesis clustering cron.
+        // (There is no memory triple-extraction cron — __MEMORY_TRIPLE_EXTRACTION__. It scheduled
+        // a no-op scaffold whose `extract` returned [] (no triples were ever written). There is no
+        // per-agent memoryTripleExtraction config key — a config carrying it is rejected at parse.
+        // The TripleStorePort + its sqlite adapter + the graphSpread
+        // recall lane SURVIVE — only the dormant extraction JOB is gone, not the read lane.)
+        // -- Reflection cron job --
         // OPT-IN, DEFAULT OFF (the byte-identity guarantee depends on it). Registered ONLY when the
         // operator sets learning.enabled AND the master cost kill switch is on; a default agent
         // registers NO job → byte-identical with the config absent. The schedule comes from
-        // learning.reflect.schedule (Phase 226 — was a hardcoded 30 9; default every 3h `0 */3 * * *`). Job
+        // learning.reflect.schedule (default every 3h `0 */3 * * *`). Job
         // options mirror the other memory crons 1:1 (isolated / next-heartbeat / no forward-to-main /
         // fresh). The __REFLECT__ sentinel (setup-channels-memory-crons-wire.ts) re-checks the knob +
         // injects the @comis/memory mental-model store + the trusted-origin source into runReflection,
-        // then emits the reflect:* counts (reflect:admitted + reflect:funnel — renamed from the old
-        // learning:skill_* funnel in Phase 226). A reflected candidate is admitted at state:candidate.
+        // then emits the reflect:* counts (reflect:admitted + reflect:funnel). A reflected candidate
+        // is admitted at state:candidate.
         const learningCfg = agentConfig.learning;
         if (costFeaturesEnabled && learningCfg?.enabled) {
             const reflectJobId = `reflect-${agentId}`;
@@ -415,7 +613,7 @@ export async function setupSchedulers(deps) {
     // here (not daemon.ts, which is at its 3000-line cap) — the natural cron-wiring seam, with the
     // agents map + config + logger already in scope.
     emitMemoryCostFeatureNotice({ agents, costFeaturesEnabled, logger: schedulerLogger });
-    // OBS-2/6b (hindsight-reflection-20260626): fold each completed __REFLECT__ run onto the firing
+    // Fold each completed __REFLECT__ run onto the firing
     // agent's cron run history, so `cron.runs jobName "Reflection"` answers "why did the last reflection
     // admit / not-admit" in one call (the funnel verdict + counts) AND the run is pollable — instead of
     // a daemon.log grep for "Reflection complete". The reflect sentinel is fire-and-forget (system_event),
@@ -424,16 +622,16 @@ export async function setupSchedulers(deps) {
     container.eventBus.on("reflect:funnel", (funnel) => {
         void recordReflectFunnelRun(executionTrackers.get(funnel.agentId), funnel, systemNowMs());
     });
-    // OBS-2b (reflect-obs-20260627): the parity recorder for the forget sweep — fold each completed
+    // The parity recorder for the forget sweep — fold each completed
     // __MEMORY_LIFECYCLE__ run onto the firing agent's cron run history, so `cron.runs jobName "Memory
     // lifecycle"` answers "what did the sweep evict/demote" in one call (was a db.mjs evicted_at poll).
     // Recorded off the content-free `learning:lifecycle_swept` event (the sentinel is fire-and-forget).
     container.eventBus.on("learning:lifecycle_swept", (swept) => {
         void recordLifecycleRun(executionTrackers.get(swept.agentId), swept, systemNowMs());
     });
-    // OUTCOME-09 boot posture: `learningOutcome` (Verified Learning WS1) is NOT a cron — it is the
+    // Boot posture: `learningOutcome` is NOT a cron — it is the
     // bus-wired observe/resolve subscriber stood up in setup-memory.ts (wireLearningOutcome). It is
-    // force-disabled by the SAME master cost switch as the six cost crons above: the effective enable
+    // force-disabled by the SAME master cost switch as the cost crons above: the effective enable
     // is `costFeaturesEnabled && agents[id].learningOutcome.enabled` (default OFF → byte-identical).
     // Surface the effective gate state once at boot so an operator can confirm the shadow signal's
     // posture without a live repro (the gate itself is applied at the wiring site, not here).

package/node_modules/@comis/daemon/dist/wiring/setup-shutdown.d.ts

@@ -115,7 +115,7 @@ export interface ShutdownDeps {
     injectionRateLimiter?: {
         destroy: () => void;
     };
-    /** WR-01 (Phase 199): tear down the reaction/session trajectory maps + dedicated reaction rate limiter (optional). */ destroyReactionWiring?: () => void;
+    /** Tear down the reaction/session trajectory maps + dedicated reaction rate limiter (optional). */ destroyReactionWiring?: () => void;
     /** Periodic lock cleanup timer (from setupAgents). */
     lockCleanupTimer?: import("@comis/core").TimerHandle;
     /** Data directory for restart continuation file (optional). */
@@ -164,7 +164,7 @@ export interface ShutdownDeps {
     proxyTypingCleanup?: () => void;
     /** Stop the delivery queue (from setupDeliveryQueue). */
     shutdownDeliveryQueue?: () => void;
-    /** Stop the background video poller — sweeper interval + in-flight loops (189). */
+    /** Stop the background video poller — sweeper interval + in-flight loops. */
     shutdownVideoPoller?: () => void;
     durableResumeShutdown?: () => void;
     /** Stop the delivery mirror (from setupDeliveryMirror). */
@@ -172,6 +172,8 @@ export interface ShutdownDeps {
     /** Stop the output retention housekeeper (from setupOutputRetention). */ outputRetentionShutdown?: () => void;
     /** Stop the channel health monitor (from setupChannelHealthMonitor). */
     stopChannelHealthMonitor?: () => void;
+    /** Stop the missed-inbound liveness monitor (from setupChannelLivenessMonitor). */
+    stopChannelLivenessMonitor?: () => void;
     /** Unsubscribe health budget aggregator. */ unsubscribeHealthAggregator?: () => void;
     /** Stop the credential broker (TCP + unix socket teardown). Only present when executor.broker is configured. */
     brokerStop?: () => Promise<void>;

package/node_modules/@comis/daemon/dist/wiring/setup-shutdown.js

@@ -26,7 +26,7 @@ import { writeRegularFile } from "@comis/observability";
 export function setupShutdown(deps) {
     const { logger, daemonLogger, processMonitor, container, exitFn, tokenTracker, startupTimestamp, activeExecutions, graphCoordinator, subAgentRunner, cronSchedulers, resetSchedulers, browserServices, channelManager, heartbeatRunner, perAgentRunner, wakeCoalescer, gatewayHandle, diagnosticCollector, channelActivityTracker, deliveryTracer, mediaTempManager, backgroundIndexingPromise, db, disposeEmbedding, disposeReranker, skillWatcherHandles, approvalGate, secretStore, auditAggregator, injectionRateLimiter, destroyReactionWiring, lockCleanupTimer, dataDir, lockDataDir, continuationTracker, lifecycleReactors, obsPersistence, disposeActivityStream, otelShutdown, geminiCacheManager, trajectoryRegistry, 
     // 9 new teardown handles lifted from system:shutdown subscribers.
-    shutdownBackgroundProcesses, mcpClientManagerDisconnectAll, bgCompletionRunnerShutdown, terminalWakeShutdown, proxyTypingCleanup, shutdownDeliveryQueue, shutdownVideoPoller, durableResumeShutdown, shutdownDeliveryMirror, outputRetentionShutdown, stopChannelHealthMonitor, unsubscribeHealthAggregator, brokerStop, capEndpointStop, } = deps;
+    shutdownBackgroundProcesses, mcpClientManagerDisconnectAll, bgCompletionRunnerShutdown, terminalWakeShutdown, proxyTypingCleanup, shutdownDeliveryQueue, shutdownVideoPoller, durableResumeShutdown, shutdownDeliveryMirror, outputRetentionShutdown, stopChannelHealthMonitor, stopChannelLivenessMonitor, unsubscribeHealthAggregator, brokerStop, capEndpointStop, } = deps;
     // Inlined graceful-shutdown body: SIGTERM/
     // SIGINT/SIGUSR2 handler registration, shuttingDown re-entrancy guard,
     // 30s hard timeout, logger.flush, and exit-code dispatch.
@@ -276,6 +276,14 @@ export function setupShutdown(deps) {
                 daemonLogger.info({ component: "channel-health-monitor", durationMs: systemNowMs() - stopMs, shutdownOrder: ++shutdownOrder }, "Component stopped");
             }, "channel-health-monitor", daemonLogger);
         }
+        // Cancel the missed-inbound liveness timer (no leaked interval on shutdown).
+        if (stopChannelLivenessMonitor) {
+            const stopMs = systemNowMs();
+            await withStepTimeout(() => {
+                stopChannelLivenessMonitor();
+                daemonLogger.info({ component: "channel-liveness-monitor", durationMs: systemNowMs() - stopMs, shutdownOrder: ++shutdownOrder }, "Component stopped");
+            }, "channel-liveness-monitor", daemonLogger);
+        }
         if (unsubscribeHealthAggregator)
             unsubscribeHealthAggregator(); // health budget aggregator
         if (heartbeatRunner) {
@@ -335,7 +343,7 @@ export function setupShutdown(deps) {
                 daemonLogger.info({ component: "broker", durationMs: systemNowMs() - stopMs, shutdownOrder: ++shutdownOrder }, "Component stopped");
             }, "broker", daemonLogger);
         }
-        if (capEndpointStop) { // Phase 211 — AFTER background processes (no jailed exec dialing cap.sock).
+        if (capEndpointStop) { // AFTER background processes (no jailed exec dialing cap.sock).
             const stopMs = systemNowMs();
             await withStepTimeout(async () => {
                 await capEndpointStop();
@@ -368,7 +376,7 @@ export function setupShutdown(deps) {
                 channelActivityTracker.dispose();
                 deliveryTracer.dispose();
                 await otelShutdown?.();
-                daemonLogger.info({ component: "observability", durationMs: systemNowMs() - stopMs, shutdownOrder: ++shutdownOrder }, "Component stopped"); // otelShutdown: Phase 178 flush+close OTLP/Prometheus exporter (timeout-bounded; no-op when disabled)
+                daemonLogger.info({ component: "observability", durationMs: systemNowMs() - stopMs, shutdownOrder: ++shutdownOrder }, "Component stopped"); // otelShutdown: flush+close OTLP/Prometheus exporter (timeout-bounded; no-op when disabled)
             }, "observability", daemonLogger);
         }
         // Wait for background embedding indexing to finish (with timeout -- has its own 5s race)
@@ -407,7 +415,7 @@ export function setupShutdown(deps) {
                 daemonLogger.info({ component: "injection-rate-limiter", shutdownOrder: ++shutdownOrder }, "Component stopped");
             }, "injection-rate-limiter", daemonLogger);
         }
-        if (destroyReactionWiring) { // WR-01: cancel reaction/session map + reaction limiter TTL timers (else they accumulate across SIGUSR2 hot-reload)
+        if (destroyReactionWiring) { // cancel reaction/session map + reaction limiter TTL timers (else they accumulate across SIGUSR2 hot-reload)
             await withStepTimeout(() => {
                 destroyReactionWiring();
                 daemonLogger.info({ component: "reaction-wiring", shutdownOrder: ++shutdownOrder }, "Component stopped");
@@ -440,7 +448,7 @@ export function setupShutdown(deps) {
         }
     };
     // shutdown(signal): re-entry guard, hard-timeout, ordered cleanup, flush, exit dispatch.
-    // exitCode set EARLY so a graceful SIGUSR2 restart still exits 42 even if the loop drains during the awaited flush before exitFnLocal() runs (drain bug 2026-06-14; full incident in setup-shutdown.test.ts). SIGUSR2 ⇒ 42; else 0; error/timeout still exitFnLocal(1), which overrides exitCode.
+    // exitCode set EARLY so a graceful SIGUSR2 restart still exits 42 even if the loop drains during the awaited flush before exitFnLocal() runs (the drain-exit failure mode; full explanation in setup-shutdown.test.ts). SIGUSR2 ⇒ 42; else 0; error/timeout still exitFnLocal(1), which overrides exitCode.
     async function shutdown(signal) {
         if (shuttingDown)
             return;

package/node_modules/@comis/daemon/dist/wiring/setup-spend-rehydration.d.ts

@@ -1,6 +1,6 @@
 /**
- * Boot-root rehydration of the daemon-wide spend accumulator (Phase 177 — the
- * dollars kill-switch). This is a SEPARATE module from `setup-observability.ts`
+ * Boot-root rehydration of the daemon-wide spend accumulator (the dollars
+ * kill-switch). This is a SEPARATE module from `setup-observability.ts`
  * because `getRollingSpendUsd` lives on `obsStore`, which the daemon builds
  * ~60-90 lines AFTER the `setupObservability(...)` call (and only when
  * `observability.persistence.enabled`). So the accumulator is CONSTRUCTED in
@@ -21,7 +21,7 @@ import type { ObservabilityStore } from "@comis/memory";
  * live from the `recordSpend` subscriber — a documented honest degradation, NOT
  * a bug.
  *
- * L1: `obs_token_usage` has no `tenant_id` column, so the boot read groups by
+ * Known limitation: `obs_token_usage` has no `tenant_id` column, so the boot read groups by
  * `agent_id` only. Global + per-agent are seeded from the persisted dollars;
  * per-tenant accrues live-from-boot (the boot rows carry a placeholder
  * `tenantId: "default"`). Exact historical per-tenant would need a forward-only

package/node_modules/@comis/daemon/dist/wiring/setup-spend-rehydration.js

@@ -7,7 +7,7 @@
  * live from the `recordSpend` subscriber — a documented honest degradation, NOT
  * a bug.
  *
- * L1: `obs_token_usage` has no `tenant_id` column, so the boot read groups by
+ * Known limitation: `obs_token_usage` has no `tenant_id` column, so the boot read groups by
  * `agent_id` only. Global + per-agent are seeded from the persisted dollars;
  * per-tenant accrues live-from-boot (the boot rows carry a placeholder
  * `tenantId: "default"`). Exact historical per-tenant would need a forward-only

package/node_modules/@comis/daemon/dist/wiring/setup-storage-mismatch-warn.d.ts

@@ -20,7 +20,7 @@ export interface StrandedFinding {
 }
 /**
  * The structured result of the probe. Additive to the existing WARN side-effect
- * (one probe, two sinks): the I3 boot snapshot records these COUNTS into the
+ * (one probe, two sinks): the boot snapshot records these COUNTS into the
  * `config_posture` row — never a secret value.
  */
 export interface StorageMismatchResult {