@aitne/daemon 0.1.6 → 0.1.8

package/dist/core/dispatcher-hourly-check.js

@@ -48,7 +48,7 @@
  *     integration is wired, in which case the gate proceeds without
  *     a refresh, matching pre-injection behaviour.
  */
-import { EventPriority, createEvent, nativeIntegrationsContributingObservationsForProcessKey, } from "@aitne/shared";
+import { EventPriority, INTEGRATION_KEYS, createEvent, } from "@aitne/shared";
 import { readIntegrations } from "../db/integrations-store.js";
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
@@ -59,6 +59,9 @@ import { computeHourlyCheckSignals } from "../db/hourly-check-signals.js";
 import { buildGateAuditDetail, decideStage, renderGateDecisionBlock, } from "../scheduler/hourly-check-gate.js";
 import { appendAgentLogLine } from "./today-direct-writer.js";
 import { parseStage2Verdict } from "./dispatcher-types.js";
+import { morningRoutineRanToday } from "../bootstrap/schedule-helpers.js";
+import { prePassLastRunRuntimeStateKey } from "./pre-pass-freshness.js";
+import { readRuntimeState } from "../db/runtime-state.js";
 import { createLogger } from "../logging.js";
 const logger = createLogger("dispatcher-hourly-check");
 export class HourlyCheckCoordinator {
@@ -76,6 +79,7 @@ export class HourlyCheckCoordinator {
     isHourlyCheckInProgress;
     isMorningRoutineActive;
     isAutonomousAllowed;
+    getQueueMorningRoutineWake;
     constructor(deps) {
         this.db = deps.db;
         this.config = deps.config;
@@ -91,6 +95,7 @@ export class HourlyCheckCoordinator {
         this.isHourlyCheckInProgress = deps.isHourlyCheckInProgress;
         this.isMorningRoutineActive = deps.isMorningRoutineActive;
         this.isAutonomousAllowed = deps.isAutonomousAllowed;
+        this.getQueueMorningRoutineWake = deps.getQueueMorningRoutineWake;
     }
     async trigger(source, options = {}) {
         const forced = options.force === true;
@@ -136,6 +141,32 @@ export class HourlyCheckCoordinator {
                     forced,
                 };
             }
+            // Pre-routine morning_routine gate. The signal is the
+            // `agent_actions` row (not today.md) because today.md can be
+            // user-edited and lie about completion — see the 2026-05-14
+            // sleep-skip incident captured in `morningRoutineRanToday`'s
+            // doc. When the gate trips, we enqueue a wake row so the
+            // morning_routine catches up on the next watcher tick, then
+            // skip the current hourly tick. The next hourly cron tick will
+            // see the action row and proceed normally; `queueMorningRoutineWake`
+            // dedups across back-to-back trips so a sleep gap covering many
+            // hours produces exactly one wake row.
+            if (!morningRoutineRanToday(this.db, this.config)) {
+                const queueWake = this.getQueueMorningRoutineWake();
+                if (queueWake) {
+                    const queueResult = queueWake(`hourly_check_dependency:${source}`);
+                    logger.info({ source, queueResult }, "Hourly check skipped — morning_routine not yet complete for current agent-day; enqueued morning_routine wake");
+                }
+                else {
+                    logger.warn({ source }, "Hourly check skipped — morning_routine not yet complete and queueMorningRoutineWake not wired");
+                }
+                return {
+                    status: "skipped",
+                    reason: "morning_routine_pending_for_today",
+                    minObservations,
+                    forced,
+                };
+            }
             // Refresh delegated-sync snapshots for any cadence the operator
             // left opted-OUT (the post-Phase-9 default). Without this, Gmail /
             // Notion observations would dry up entirely in delegated mode and
@@ -157,116 +188,62 @@ export class HourlyCheckCoordinator {
                     logger.warn({ err, source }, "Pre-hourly-check delegated sync refresh failed; proceeding with stale snapshot");
                 }
             }
-            const pendingCount = getPendingCount(this.db, { actorFilter: "user" });
-            // INTEGRATION_NATIVE_MODE_DESIGN.md §6.5.1 — threshold bypass when
-            // at least one native integration contributes observations during
-            // hourly_check execution. "Contributes observations" is the union
-            // of `taskFlowsTouched` (in-turn variant POSTs) and
-            // `taskFlowsReferenced` (partial-include POSTs from the
-            // `routine.fetch_window` pre-pass — RDAD §10 R3). Without the
-            // referenced arm, an Outlook-only-native deployment
-            // (taskFlowsTouched is `[]` for user-managed connectors) would
-            // never trip the bypass: pre-pass would never run, no observations
-            // would land, and the gate would lock the routine into permanent
-            // skip. When the bypass fires the legacy `below_threshold` floor
-            // is suppressed; the in-turn POSTs populate the table by end of
-            // turn.
-            const nativeHourlyCheckIntegrations = nativeIntegrationsContributingObservationsForProcessKey("routine.hourly_check", readIntegrations(this.db));
-            const hasNativeForHourlyCheck = nativeHourlyCheckIntegrations.length > 0;
-            if (hasNativeForHourlyCheck) {
-                logger.debug({
-                    source,
-                    pendingCount,
-                    minObservations,
-                    nativeIntegrations: nativeHourlyCheckIntegrations,
-                }, "Hourly check: native integrations active — pre-run threshold bypass per §6.5.1");
-            }
-            // cost-reduction-structural §B — three-stage gate.
-            // Mode `off` falls through to the legacy min-observations gate +
-            // straight enqueue (rollback path for the gate); `shadow`/`live`
-            // compute the gate verdict before any other branch fires.
-            const gateMode = (this.config.hourlyCheckGateMode
-                ?? "shadow");
-            if (gateMode === "off") {
-                if (!forced && !hasNativeForHourlyCheck && pendingCount < minObservations) {
-                    logger.debug({ source, pendingCount, minObservations }, "Hourly check skipped — not enough pending observations");
-                    return {
-                        status: "skipped",
-                        reason: "below_threshold",
-                        pendingCount,
-                        minObservations,
-                        forced,
-                    };
+            // HOURLY_CHECK_GATE_REDESIGN_PLAN.md Layer 1 — pre-pass harvest
+            // for delegated/native integrations BEFORE the gate signal
+            // computation. Direct-mode integrations rely on their in-process
+            // pollers and are not touched here. The freshness window
+            // (`hourlyCheckPrePassFreshnessMinutes`, default 30 min) bounds
+            // Haiku spend; forced runs (`/api/agent/run-now`) bypass the
+            // window so the operator always sees fresh data.
+            //
+            // Failures surface as `harvest.failed === true`; combined with
+            // §3.5 cautious-escalate the gate force-runs Stage 3 so a
+            // transient fetch outage doesn't manifest as silent stage0.
+            const harvest = await this.harvestForGate(source, forced);
+            // Layer 2 — gate signals are now mode-blind. The actor='user'
+            // filter has been dropped (HOURLY_CHECK_GATE_REDESIGN_PLAN.md
+            // Phase 1+2): delegated-sync-worker and pre-pass both POST
+            // actor='agent' rows that represent real activity. The
+            // signal-compute filters by source-prefix sets derived from
+            // `INTEGRATION_DESCRIPTORS` instead.
+            const pendingCount = getPendingCount(this.db);
+            // Layer 2+3 — compute gate verdict.
+            const baseDecision = this.computeHourlyCheckGateDecision();
+            // §3.5 cautious-escalate: when pre-pass failed for any non-direct
+            // integration, force `stage3` regardless of the signal verdict.
+            // The Stage 3 prompt carries the `<fetch_report status="failed">`
+            // block so the routine knows the fetch was lossy. We preserve the
+            // pre-overwrite gate verdict so the audit row carries both views
+            // (`gate_stage`/`gate_reason` show the cautious-escalate label
+            // the prompt sees; `pre_escalate_gate_stage`/`_reason` show what
+            // the gate would have said without the pre-pass failure).
+            const cautiousEscalate = harvest.failed;
+            const decision = cautiousEscalate
+                ? {
+                    ...baseDecision,
+                    stage: "stage3",
+                    reason: "cautious_escalate_prepass_failure",
                 }
-                await this.eventBus.put({
-                    ...createEvent({
-                        type: "routine.hourly_check",
-                        source,
-                        priority: EventPriority.NORMAL,
-                    }),
-                    routine: "hourly_check",
-                    data: { pendingCount, forced },
-                    ...(options.requestedModel ? { requestedModel: options.requestedModel } : {}),
-                });
-                enqueued = true;
-                return {
-                    status: "queued",
-                    pendingCount,
-                    minObservations,
-                    forced,
-                    gateMode: "off",
-                };
-            }
-            const decision = this.computeHourlyCheckGateDecision();
-            if (gateMode === "shadow") {
-                // Shadow mode: log the gate verdict, then proceed to Stage 3
-                // exactly as before so the existing pipeline is uncovered.
-                this.logGateAuditRow(decision, {
-                    mode: "shadow",
-                    appliedDecision: "stage3_shadow",
-                    forced,
-                });
-                if (!forced && !hasNativeForHourlyCheck && pendingCount < minObservations) {
-                    logger.debug({ source, pendingCount, minObservations, gateStage: decision.stage }, "Hourly check skipped (shadow) — not enough pending observations");
-                    return {
-                        status: "skipped",
-                        reason: "below_threshold",
-                        pendingCount,
-                        minObservations,
-                        forced,
-                        gateMode: "shadow",
-                        gateStage: decision.stage,
-                        gateReason: decision.reason,
-                        appliedStage: "stage3_shadow",
-                    };
-                }
-                await this.enqueueStage3HourlyCheck(source, { ...decision }, { mode: "shadow", forced, pendingCount, requestedModel: options.requestedModel });
-                enqueued = true;
-                return {
-                    status: "queued",
-                    pendingCount,
-                    minObservations,
-                    forced,
-                    gateMode: "shadow",
-                    gateStage: decision.stage,
-                    gateReason: decision.reason,
-                    appliedStage: "stage3_shadow",
-                };
-            }
-            // gateMode === 'live'
+                : baseDecision;
+            const preEscalate = cautiousEscalate
+                ? { stage: baseDecision.stage, reason: baseDecision.reason }
+                : null;
             // Honour the legacy min-observations floor only when the gate
             // would have proceeded to Stage 3 anyway. The silent gate path
             // already short-circuits the noisy "1 obs, no signal" case below
             // it, so keeping the floor active there would just suppress the
-            // gate's telemetry.
+            // gate's telemetry. The native-integration §6.5.1 bypass is no
+            // longer needed — the gate's signal compute now sees pre-pass +
+            // delegated-sync rows directly.
             if (!forced
-                && !hasNativeForHourlyCheck
+                && !cautiousEscalate
                 && decision.stage === "stage3"
                 && pendingCount < minObservations) {
                 this.logGateAuditRow(decision, {
-                    mode: "live",
                     appliedDecision: "stage3",
                     forced,
+                    harvest,
+                    preEscalate,
                     // Mark the row as a skip even though the gate wanted Stage 3 —
                     // the legacy min-observations floor short-circuited it. Without
                     // this, every `below_threshold` skip would persist as a phantom
@@ -280,7 +257,6 @@ export class HourlyCheckCoordinator {
                     pendingCount,
                     minObservations,
                     forced,
-                    gateMode: "live",
                     gateStage: decision.stage,
                     gateReason: decision.reason,
                 };
@@ -289,12 +265,13 @@ export class HourlyCheckCoordinator {
                 const silentResult = this.runSilentHourlyCheckPath(decision, "stage0_silent", {
                     source,
                     forced,
+                    harvest,
+                    preEscalate,
                 });
                 silentPathOwnsReset = true;
                 return {
                     ...silentResult,
                     minObservations,
-                    gateMode: "live",
                     gateStage: decision.stage,
                     gateReason: decision.reason,
                     appliedStage: "stage0_silent",
@@ -303,12 +280,11 @@ export class HourlyCheckCoordinator {
             if (decision.stage === "stage2") {
                 const verdict = await this.runStage2Triage(decision, source);
                 if (verdict === "log_only") {
-                    const silentResult = this.runSilentHourlyCheckPath(decision, "stage2_log_only", { source, forced });
+                    const silentResult = this.runSilentHourlyCheckPath(decision, "stage2_log_only", { source, forced, harvest, preEscalate });
                     silentPathOwnsReset = true;
                     return {
                         ...silentResult,
                         minObservations,
-                        gateMode: "live",
                         gateStage: decision.stage,
                         gateReason: decision.reason,
                         appliedStage: "stage2_log_only",
@@ -318,11 +294,13 @@ export class HourlyCheckCoordinator {
                 // since a malformed JSON should not silently skip a hour's worth
                 // of signals; matches the prompt contract's stated default).
                 await this.enqueueStage3HourlyCheck(source, decision, {
-                    mode: "live",
                     forced,
                     pendingCount,
                     requestedModel: options.requestedModel,
                     stage2Verdict: verdict,
+                    harvest,
+                    cautiousEscalate,
+                    preEscalate,
                 });
                 enqueued = true;
                 return {
@@ -330,24 +308,31 @@ export class HourlyCheckCoordinator {
                     pendingCount,
                     minObservations,
                     forced,
-                    gateMode: "live",
                     gateStage: decision.stage,
                     gateReason: decision.reason,
                     appliedStage: "stage3",
+                    ...(cautiousEscalate ? { cautiousEscalate: true } : {}),
                 };
             }
             // decision.stage === 'stage3'
-            await this.enqueueStage3HourlyCheck(source, decision, { mode: "live", forced, pendingCount, requestedModel: options.requestedModel });
+            await this.enqueueStage3HourlyCheck(source, decision, {
+                forced,
+                pendingCount,
+                requestedModel: options.requestedModel,
+                harvest,
+                cautiousEscalate,
+                preEscalate,
+            });
             enqueued = true;
             return {
                 status: "queued",
                 pendingCount,
                 minObservations,
                 forced,
-                gateMode: "live",
                 gateStage: decision.stage,
                 gateReason: decision.reason,
                 appliedStage: "stage3",
+                ...(cautiousEscalate ? { cautiousEscalate: true } : {}),
             };
         }
         finally {
@@ -361,6 +346,116 @@ export class HourlyCheckCoordinator {
             }
         }
     }
+    /**
+     * HOURLY_CHECK_GATE_REDESIGN_PLAN.md §3.3 Layer 1 — pre-pass harvest
+     * for active non-direct integrations. Reads the per-integration
+     * `pre_pass_last_run:<key>` freshness key; integrations whose last
+     * successful run is within `hourlyCheckPrePassFreshnessMinutes` are
+     * skipped this tick. Forced runs (`/api/agent/run-now`) bypass the
+     * freshness gate.
+     *
+     * Returns a `HarvestResult` so the caller can:
+     *   - emit telemetry (which integrations fetched, which skipped on
+     *     freshness, which failed),
+     *   - cautious-escalate when any non-direct integration failed
+     *     (§3.5 — prevents silent stage0 from masking a fetch outage),
+     *   - plumb the rendered `<fetch_report>` block onto the Stage 3
+     *     event so ContextBuilder folds it into the prompt.
+     */
+    async harvestForGate(source, forced) {
+        const startedAt = Date.now();
+        const integrations = readIntegrations(this.db);
+        const freshnessMinutes = this.config.hourlyCheckPrePassFreshnessMinutes ?? 30;
+        const freshnessMs = Math.max(0, freshnessMinutes) * 60 * 1000;
+        const now = Date.now();
+        const eligibleIntegrations = [];
+        const skipped = [];
+        for (const key of INTEGRATION_KEYS) {
+            const state = integrations[key];
+            if (!state)
+                continue;
+            // Only non-direct integrations participate in pre-pass harvest.
+            // Direct-mode integrations rely on their in-process pollers; their
+            // observations land in `observations` independently of the gate.
+            if (state.mode !== "delegated" && state.mode !== "native")
+                continue;
+            if (forced || freshnessMs === 0) {
+                eligibleIntegrations.push(key);
+                continue;
+            }
+            const last = readRuntimeState(this.db, prePassLastRunRuntimeStateKey(key));
+            const lastMs = last ? Date.parse(last) : NaN;
+            if (Number.isFinite(lastMs) && now - lastMs < freshnessMs) {
+                skipped.push(key);
+                continue;
+            }
+            eligibleIntegrations.push(key);
+        }
+        if (eligibleIntegrations.length === 0) {
+            return {
+                ran: false,
+                integrations: [],
+                skippedIntegrations: skipped,
+                failedIntegrations: [],
+                durationMs: Date.now() - startedAt,
+                failed: false,
+                fetchReportBlock: null,
+            };
+        }
+        // Manufacture a placeholder hourly_check event so the runner can
+        // derive `RoutineWindowKey` and the agent-day. The runner's own
+        // `prepass_started` / `prepass_completed` SSE pair carries the
+        // correlation id back to the dashboard.
+        const parentEvent = {
+            ...createEvent({
+                type: "routine.hourly_check",
+                source,
+                priority: EventPriority.NORMAL,
+            }),
+            routine: "hourly_check",
+            data: { forced },
+        };
+        let result;
+        try {
+            result = await this.fetchWindowRunner.run(parentEvent, "routine.hourly_check", { integrationKeyFilter: new Set(eligibleIntegrations) });
+        }
+        catch (err) {
+            // Runner errors never propagate per design — but as a defensive
+            // floor we treat any throw as a hard failure across all eligible
+            // integrations so cautious-escalate kicks in.
+            logger.error({ err, source, eligibleIntegrations }, "harvestForGate: fetchWindowRunner.run threw — forcing cautious escalate");
+            return {
+                ran: true,
+                integrations: [],
+                skippedIntegrations: skipped,
+                failedIntegrations: eligibleIntegrations,
+                durationMs: Date.now() - startedAt,
+                failed: true,
+                fetchReportBlock: null,
+            };
+        }
+        const perIntegration = result.report.perIntegration ?? [];
+        const fetched = [];
+        const failed = [];
+        for (const sub of perIntegration) {
+            if (sub.status === "success")
+                fetched.push(sub.integrationKey);
+            else if (sub.status === "failed")
+                failed.push(sub.integrationKey);
+            else if (sub.status === "partial")
+                fetched.push(sub.integrationKey);
+            // skipped → no per-integration list entry; suppressed silently.
+        }
+        return {
+            ran: true,
+            integrations: fetched,
+            skippedIntegrations: skipped,
+            failedIntegrations: failed,
+            durationMs: Date.now() - startedAt,
+            failed: failed.length > 0,
+            fetchReportBlock: result.block,
+        };
+    }
     /**
      * cost-reduction-structural §B — pull a fresh signal snapshot and run
      * the deterministic gate. Helper so the dispatcher's call site stays
@@ -426,12 +521,12 @@ export class HourlyCheckCoordinator {
             }
             // Consume the observations under the gate's correlation id so
             // dashboards can attribute "consumed by gate" rows separately
-            // from agent-driven consumption.
+            // from agent-driven consumption. The actor filter is dropped
+            // (HOURLY_CHECK_GATE_REDESIGN_PLAN.md Phase 1+2) so pre-pass and
+            // delegated-sync agent rows are cleared too — otherwise they
+            // would accumulate on every silent tick.
             try {
-                const pending = getPendingObservations(this.db, {
-                    actorFilter: "user",
-                    limit: 100,
-                });
+                const pending = getPendingObservations(this.db, { limit: 100 });
                 if (pending.length > 0) {
                     consumeObservations(this.db, pending.map((row) => row.id), `hourly_check_gate:${appliedDecision}`);
                 }
@@ -440,9 +535,10 @@ export class HourlyCheckCoordinator {
                 logger.warn({ err }, "Failed to consume observations on silent gate path");
             }
             this.logGateAuditRow(decision, {
-                mode: "live",
                 appliedDecision,
                 forced: ctx.forced,
+                harvest: ctx.harvest,
+                preEscalate: ctx.preEscalate,
             });
             logger.info({
                 source: ctx.source,
@@ -464,17 +560,17 @@ export class HourlyCheckCoordinator {
     }
     async enqueueStage3HourlyCheck(source, decision, extra) {
         const gateBlock = renderGateDecisionBlock(decision, {
-            mode: extra.mode,
             forced: extra.forced,
+            cautiousEscalate: extra.cautiousEscalate,
+        });
+        this.logGateAuditRow(decision, {
+            appliedDecision: "stage3",
+            forced: extra.forced,
+            harvest: extra.harvest,
+            preEscalate: extra.preEscalate,
+            ...(extra.cautiousEscalate ? { cautiousEscalate: true } : {}),
+            ...(extra.stage2Verdict ? { stage2Verdict: extra.stage2Verdict } : {}),
         });
-        if (extra.mode === "live") {
-            this.logGateAuditRow(decision, {
-                mode: extra.mode,
-                appliedDecision: "stage3",
-                forced: extra.forced,
-                ...(extra.stage2Verdict ? { stage2Verdict: extra.stage2Verdict } : {}),
-            });
-        }
         const stage3Event = {
             ...createEvent({
                 type: "routine.hourly_check",
@@ -486,63 +582,66 @@ export class HourlyCheckCoordinator {
                 pendingCount: extra.pendingCount,
                 forced: extra.forced,
                 gateDecision: {
-                    mode: extra.mode,
                     stage: decision.stage,
                     reason: decision.reason,
                     forced: extra.forced,
+                    ...(extra.cautiousEscalate ? { cautiousEscalate: true } : {}),
                     ...(extra.stage2Verdict ? { stage2Verdict: extra.stage2Verdict } : {}),
                     block: gateBlock,
                 },
+                // HOURLY_CHECK_GATE_REDESIGN_PLAN.md §3.3 — Layer-1 harvest ran
+                // BEFORE this enqueue so the gate could see fresh signals. The
+                // rendered `<fetch_report>` block is plumbed onto the event so
+                // ContextBuilder folds it into the Stage 3 prompt (the routine
+                // body still relies on the block for "what arrived this tick").
+                ...(extra.harvest.fetchReportBlock
+                    ? { fetchReportBlock: extra.harvest.fetchReportBlock }
+                    : {}),
             },
             ...(extra.requestedModel ? { requestedModel: extra.requestedModel } : {}),
         };
-        // ROUTINE_DATA_ACQUISITION_DESIGN.md Phase 4 / D3 — synchronous
-        // pre-pass between the gate's escalate verdict and the Stage 3
-        // enqueue. The block lives on `event.data.fetchReportBlock` so
-        // ContextBuilder folds it into the Stage 3 prompt when the EventBus
-        // consumer dispatches the routine. Pre-pass is skipped when the
-        // gate's escalate reason is `forced` (operator-pushed runs already
-        // know they want a fresh look) or `shadow` (shadow mode is
-        // explicitly running the existing pipeline unchanged, so the
-        // pre-pass would change the comparison fixture). Failures inside
-        // the runner surface as `<fetch_report status="failed">` and never
-        // throw — design §11 R5.
-        if (extra.mode === "live" && !extra.forced) {
-            const prepass = await this.fetchWindowRunner.run(stage3Event, "routine.hourly_check");
-            stage3Event.data = {
-                ...stage3Event.data,
-                fetchReportBlock: prepass.block,
-            };
-        }
         await this.eventBus.put(stage3Event);
     }
     logGateAuditRow(decision, params) {
         try {
             // The gate-audit helper only knows about the canonical stages
-            // (gate output) plus the shadow-mode marker. Map the silent-path
-            // alias `stage2_log_only` onto its canonical sibling so the
-            // helper's typing stays narrow; the verdict is preserved verbatim
-            // alongside `stage_reached` in the merged detail.
+            // (gate output). Map the silent-path alias `stage2_log_only` onto
+            // its canonical sibling so the helper's typing stays narrow; the
+            // verdict is preserved verbatim alongside `stage_reached` in the
+            // merged detail.
             const auditAppliedDecision = params.appliedDecision === "stage2_log_only"
                 ? "stage0_silent"
                 : params.appliedDecision;
             const detail = {
                 ...buildGateAuditDetail(decision, {
-                    mode: params.mode,
                     appliedDecision: auditAppliedDecision,
                     forced: params.forced,
                     ...(params.stage2Verdict ? { stage2Verdict: params.stage2Verdict } : {}),
+                    ...(params.cautiousEscalate ? { cautiousEscalate: true } : {}),
+                    ...(params.preEscalate
+                        ? {
+                            preEscalateGateStage: params.preEscalate.stage,
+                            preEscalateGateReason: params.preEscalate.reason,
+                        }
+                        : {}),
                 }),
                 // Always reflect the *real* applied stage in the row regardless
                 // of the alias mapping above.
                 stage_reached: params.appliedDecision,
+                // §7.2 harvest telemetry — surfaces on every gate audit row,
+                // including silent-gate skips, so per-tick cadence is observable
+                // without re-querying `routine.fetch_window` rows.
+                harvest_ran: params.harvest.ran,
+                harvest_integrations: params.harvest.integrations,
+                harvest_skipped_integrations: params.harvest.skippedIntegrations,
+                harvest_failed_integrations: params.harvest.failedIntegrations,
+                harvest_duration_ms: params.harvest.durationMs,
                 ...(params.extra ?? {}),
             };
-            const isShadow = params.appliedDecision === "stage3_shadow";
             const isSilentPath = params.appliedDecision === "stage0_silent"
                 || params.appliedDecision === "stage2_log_only";
             const result = params.resultOverride
-                ?? (isShadow ? "success" : isSilentPath ? "skipped" : "success");
+                ?? (isSilentPath ? "skipped" : "success");
             this.db
                 .prepare(`INSERT INTO agent_actions
              (action_type, trigger, result, detail, started_at, completed_at)
@@ -586,11 +685,10 @@ export class HourlyCheckCoordinator {
             data: {
                 forced: false,
                 gateDecision: {
-                    mode: "live",
                     stage: decision.stage,
                     reason: decision.reason,
                     forced: false,
-                    block: renderGateDecisionBlock(decision, { mode: "live", forced: false }),
+                    block: renderGateDecisionBlock(decision, { forced: false }),
                 },
             },
         };