@aitne/daemon 0.1.7 → 0.1.9

package/dist/core/daemon-api-cli.js

@@ -8,18 +8,19 @@ export const DAEMON_API_READ_TOKEN_ENV = "PA_DAEMON_READ_TOKEN";
 // DELEGATED-MODE-V2-DESIGN.md §4.2.3 — env-var pathway for the
 // `x-session-backend` / `x-event-id` / `x-process-key` headers used by the
 // delegated-mode endpoints. The CLI shims auto-inject these on requests
-// to `/api/integrations/*/exec`, `/api/integrations/*/invoke` (RESERVED;
-// see route comment), and `/api/delegated/run` so skill prose can call
-// plain curl without the agent having to compose env-var expansions
-// inline (which Claude Code's classifier denies). Scoping to the
-// delegated routes keeps the session identity from leaking onto
-// unrelated endpoints.
+// to `/api/integrations/*/exec` and `/api/delegated/run` so skill prose
+// can call plain curl without the agent having to compose env-var
+// expansions inline (which Claude Code's classifier denies). Scoping to
+// the delegated routes keeps the session identity from leaking onto
+// unrelated endpoints. (The historical `/api/integrations/*/invoke` RPC
+// route was retired 2026-05-01; the regex below intentionally no longer
+// matches it so a future reactivation must explicitly reopen the path.)
 export const DAEMON_API_SESSION_BACKEND_ENV = "PA_SESSION_BACKEND";
 export const DAEMON_API_EVENT_ID_ENV = "PA_EVENT_ID";
 export const DAEMON_API_PROCESS_KEY_ENV = "PA_PROCESS_KEY";
 export const DAEMON_API_SESSION_ID_ENV = "PA_SESSION_ID";
 // Event correlationId — distinct from PA_EVENT_ID (which carries the
-// integration-invoke parent attribution). PA_EVENT_CORRELATION_ID is the
+// delegated-call parent attribution for /exec). PA_EVENT_CORRELATION_ID is the
 // full Event.correlationId so the dispatcher can attribute /api/notify
 // calls back to the in-flight scheduled.task / morning_routine / message.*
 // run. Used to suppress the implicit "final assistant text → DM" forward
@@ -39,6 +40,11 @@ const EVENT_CORRELATION_ID_ENV = "${DAEMON_API_EVENT_CORRELATION_ID_ENV}";
 const ALLOWED_METHODS = new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"]);
 const ALLOWED_HEADERS = new Set([
   "content-type",
+  // The shim sets a sensible default Accept itself; honour an explicit one
+  // too so a request-format hint the agent adds out of habit
+  // (\`-H "Accept: application/json"\`) does not fail the whole call and
+  // burn a retry turn.
+  "accept",
   "x-lock-id",
   "x-session-id",
   // DELEGATED-MODE-V2-DESIGN.md §4.2.3 — delegated-mode pathway. The
@@ -55,14 +61,21 @@ const ALLOWED_HEADERS = new Set([
   "x-pa-session-id",
 ]);
 // Delegated-mode routes that the env-var auto-injection scopes to. Covers
-// /api/integrations/:key/exec (task mode, agent-facing), the RESERVED
-// /api/integrations/:key/invoke (RPC mode, currently commented out),
-// and /api/delegated/run (Phase 2 generic task mode). Note: the
-// regex must mirror the matched real-world path shape; pa-api injects
-// header auto-attribution only when the path matches.
-const INVOKE_ROUTE_PATTERN =
-  /^\\/api\\/(?:integrations\\/[^/]+\\/(?:invoke|exec)|delegated\\/run)$/;
+// /api/integrations/:key/exec (task mode, agent-facing) and
+// /api/delegated/run (Phase 2 generic task mode). The retired
+// /api/integrations/:key/invoke RPC route is intentionally NOT matched
+// (retired 2026-05-01); a future reactivation must explicitly reopen the
+// path. Note: the regex must mirror the matched real-world path shape;
+// pa-api injects header auto-attribution only when the path matches.
+const DELEGATED_ROUTE_PATTERN =
+  /^\\/api\\/(?:integrations\\/[^/]+\\/exec|delegated\\/run)$/;
 const NOTIFY_ROUTE_PATTERN = /^\\/api\\/notify$/;
+// docs/design/appendices/morning-routine-optimization.md §"PATCH
+// /api/agent-actions/self" — the endpoint authenticates via the
+// dispatcher-injected x-pa-event-correlation-id + x-process-key
+// headers. Scope the auto-injection to this exact path so the
+// session identity does not leak onto unrelated endpoints.
+const AGENT_ACTIONS_SELF_ROUTE_PATTERN = /^\\/api\\/agent-actions\\/self$/;
 
 function usage(message) {
   if (message) {
@@ -161,12 +174,11 @@ async function main() {
   }
 
   // DELEGATED-MODE-V2-DESIGN.md §4.2.3 — auto-inject session identity on
-  // /api/integrations/*/exec (task mode), the RESERVED /invoke route, and
-  // /api/delegated/run. Mirrors the curl shim's PA_TURN_TOKEN pattern:
-  // skill prose calls plain pa-api / curl, the shim adds the header from
-  // env. Scoped to the delegated routes so the identity does not leak
-  // onto unrelated endpoints.
-  if (INVOKE_ROUTE_PATTERN.test(url.pathname)) {
+  // /api/integrations/*/exec (task mode) and /api/delegated/run. Mirrors
+  // the curl shim's PA_TURN_TOKEN pattern: skill prose calls plain pa-api
+  // / curl, the shim adds the header from env. Scoped to the delegated
+  // routes so the identity does not leak onto unrelated endpoints.
+  if (DELEGATED_ROUTE_PATTERN.test(url.pathname)) {
     const sessionBackend = process.env[SESSION_BACKEND_ENV];
     if (sessionBackend && !headers.has("x-session-backend")) {
       headers.set("x-session-backend", sessionBackend);
@@ -196,6 +208,21 @@ async function main() {
     }
   }
 
+  // Agent-self-write pathway — PATCH /api/agent-actions/self resolves
+  // the row via correlation_id + process_key. Skill prose calls plain
+  // pa-api / curl; the shim attaches both headers from the
+  // dispatcher-injected env vars.
+  if (AGENT_ACTIONS_SELF_ROUTE_PATTERN.test(url.pathname)) {
+    const correlationId = process.env[EVENT_CORRELATION_ID_ENV];
+    if (correlationId && !headers.has("x-pa-event-correlation-id")) {
+      headers.set("x-pa-event-correlation-id", correlationId);
+    }
+    const processKey = process.env[PROCESS_KEY_ENV];
+    if (processKey && !headers.has("x-process-key")) {
+      headers.set("x-process-key", processKey);
+    }
+  }
+
   let body = undefined;
   let outputPath = null;
 
@@ -294,13 +321,16 @@ const SESSION_ID_ENV = "${DAEMON_API_SESSION_ID_ENV}";
 const EVENT_CORRELATION_ID_ENV = "${DAEMON_API_EVENT_CORRELATION_ID_ENV}";
 const ALLOWED_HEADERS = new Set([
   "content-type",
+  // Honour an explicit Accept (the shim also sets a default) so the agent's
+  // habitual \`-H "Accept: application/json"\` does not fail and trigger a retry.
+  "accept",
   "x-lock-id",
   "x-session-id",
   "x-turn-token",
   "x-filename",
   "x-caption",
   // DELEGATED-MODE-V2-DESIGN.md §4.2.3 — delegated-mode pathway
-  // (auto-injected on /exec, RESERVED /invoke, and /api/delegated/run).
+  // (auto-injected on /exec and /api/delegated/run).
   "x-session-backend",
   "x-event-id",
   "x-process-key",
@@ -309,14 +339,21 @@ const ALLOWED_HEADERS = new Set([
   "x-pa-session-id",
 ]);
 // Delegated-mode routes that the env-var auto-injection scopes to. Covers
-// /api/integrations/:key/exec (task mode, agent-facing), the RESERVED
-// /api/integrations/:key/invoke (RPC mode, currently commented out),
-// and /api/delegated/run (Phase 2 generic task mode). Note: the
-// regex must mirror the matched real-world path shape; pa-api injects
-// header auto-attribution only when the path matches.
-const INVOKE_ROUTE_PATTERN =
-  /^\\/api\\/(?:integrations\\/[^/]+\\/(?:invoke|exec)|delegated\\/run)$/;
+// /api/integrations/:key/exec (task mode, agent-facing) and
+// /api/delegated/run (Phase 2 generic task mode). The retired
+// /api/integrations/:key/invoke RPC route is intentionally NOT matched
+// (retired 2026-05-01); a future reactivation must explicitly reopen the
+// path. Note: the regex must mirror the matched real-world path shape;
+// pa-api injects header auto-attribution only when the path matches.
+const DELEGATED_ROUTE_PATTERN =
+  /^\\/api\\/(?:integrations\\/[^/]+\\/exec|delegated\\/run)$/;
 const NOTIFY_ROUTE_PATTERN = /^\\/api\\/notify$/;
+// docs/design/appendices/morning-routine-optimization.md §"PATCH
+// /api/agent-actions/self" — the endpoint authenticates via the
+// dispatcher-injected x-pa-event-correlation-id + x-process-key
+// headers. Scope the auto-injection to this exact path so the
+// session identity does not leak onto unrelated endpoints.
+const AGENT_ACTIONS_SELF_ROUTE_PATTERN = /^\\/api\\/agent-actions\\/self$/;
 const IGNORED_FLAGS = new Set(["-s", "--silent", "--show-error"]);
 
 // MIME inference for plain-text / data formats that have no magic bytes.
@@ -467,6 +504,38 @@ async function main() {
       idx += 1;
       continue;
     }
+    // Real curl 7.82+ \`--json <body>\` is shorthand for setting
+    // Content-Type: application/json + Accept: application/json + sending
+    // the body. The agent learns this shape from skill prose and from
+    // pa-api (which has its own --json). Matching curl's behavior here
+    // avoids the previous "Unsupported curl flag: --json" failure that
+    // burned budget on every routine.morning_routine_today retry.
+    if (arg === "--json") {
+      const rawBody = args[idx + 1];
+      if (rawBody === undefined) {
+        fail("--json requires a value.");
+      }
+      if (rawBody === "@-") {
+        body = await readAllStdin();
+      } else if (rawBody.length > 0 && rawBody[0] === "@") {
+        fail(\`--json \${rawBody}: @<path> file-read syntax is not allowed; use \\\`--json @-\\\` with a heredoc instead.\`);
+      } else {
+        body = rawBody;
+      }
+      if (!headers.has("content-type")) {
+        headers.set("content-type", "application/json");
+      }
+      headers.set("accept", "application/json");
+      idx += 1;
+      continue;
+    }
+    // Real curl \`-I\` / \`--head\` issues a HEAD request. HEAD is in
+    // ALLOWED_METHODS so this is safe; supporting the flag keeps the
+    // agent's muscle memory working when it probes for existence.
+    if (arg === "-I" || arg === "--head") {
+      method = "HEAD";
+      continue;
+    }
     if (arg === "-o" || arg === "--output") {
       const filePath = args[idx + 1];
       if (!filePath) {
@@ -537,10 +606,10 @@ async function main() {
   }
 
   // DELEGATED-MODE-V2-DESIGN.md §4.2.3 — auto-inject session identity on
-  // /api/integrations/*/exec (task mode), the RESERVED /invoke route,
-  // and /api/delegated/run. Same pattern as the turn token above: skill
-  // prose calls plain curl, the shim adds the header from env.
-  if (INVOKE_ROUTE_PATTERN.test(url.pathname)) {
+  // /api/integrations/*/exec (task mode) and /api/delegated/run. Same
+  // pattern as the turn token above: skill prose calls plain curl, the
+  // shim adds the header from env.
+  if (DELEGATED_ROUTE_PATTERN.test(url.pathname)) {
     const sessionBackend = process.env[SESSION_BACKEND_ENV];
     if (sessionBackend && !headers.has("x-session-backend")) {
       headers.set("x-session-backend", sessionBackend);
@@ -566,6 +635,18 @@ async function main() {
       headers.set("x-pa-session-id", sessionId);
     }
   }
+
+  // Agent-self-write — see pa-api shim for rationale.
+  if (AGENT_ACTIONS_SELF_ROUTE_PATTERN.test(url.pathname)) {
+    const correlationId = process.env[EVENT_CORRELATION_ID_ENV];
+    if (correlationId && !headers.has("x-pa-event-correlation-id")) {
+      headers.set("x-pa-event-correlation-id", correlationId);
+    }
+    const processKey = process.env[PROCESS_KEY_ENV];
+    if (processKey && !headers.has("x-process-key")) {
+      headers.set("x-process-key", processKey);
+    }
+  }
   const response = await fetch(url, {
     method: resolvedMethod,
     headers,
@@ -606,6 +687,25 @@ export function ensureDaemonApiCli(sessionDir) {
     chmodSync(cliPath, 0o700);
     writeFileSync(curlShimPath, DAEMON_CURL_SHIM_SOURCE, { encoding: "utf-8", mode: 0o700 });
     chmodSync(curlShimPath, 0o700);
+    // POSIX: the shebang + 0o700 makes the extensionless scripts executable and
+    // PATH-resolvable. On Windows, CreateProcess/cmd only run files whose ext is
+    // in PATHEXT, so an extensionless shebang file is never executed: a bare
+    // `curl` would silently fall through to the real curl.exe (bypassing the
+    // daemon-API auth/header injection and safety hooks) and `pa-api` would be
+    // "command not found". Write sibling .cmd launchers so PATHEXT resolution
+    // finds these and shadows the real curl.exe; cmd propagates node's errorlevel
+    // as the exit code. (The chmod above is a harmless near-no-op on Windows.)
+    /* c8 ignore start -- win32-only PATHEXT shim; the POSIX test runner never enters this branch */
+    if (process.platform === "win32") {
+        const binDir = join(sessionDir, SESSION_DAEMON_API_BIN_DIR);
+        writeFileSync(join(binDir, "pa-api.cmd"), '@echo off\r\nnode "%~dp0pa-api" %*\r\n', {
+            encoding: "utf-8",
+        });
+        writeFileSync(join(binDir, "curl.cmd"), '@echo off\r\nnode "%~dp0curl" %*\r\n', {
+            encoding: "utf-8",
+        });
+    }
+    /* c8 ignore stop */
     return cliPath;
 }
 export function buildDaemonApiCliEnv(sessionDir, apiPort, optionsOrReadToken) {
@@ -659,4 +759,3 @@ export function buildDaemonApiCliEnv(sessionDir, apiPort, optionsOrReadToken) {
     }
     return env;
 }
-//# sourceMappingURL=daemon-api-cli.js.map

package/dist/core/dashboard-session-cleanup.d.ts

@@ -36,4 +36,3 @@ export declare function deleteChatSession(params: {
     dataDir: string;
     sessionId: number;
 }): DeleteSessionResult;
-//# sourceMappingURL=dashboard-session-cleanup.d.ts.map

package/dist/core/dashboard-session-cleanup.js

@@ -105,4 +105,3 @@ export function deleteChatSession(params) {
     logger.info({ sessionId: row.id, scope: row.scope }, "Dashboard deleted chat sidebar session");
     return { ok: true, deleted };
 }
-//# sourceMappingURL=dashboard-session-cleanup.js.map

package/dist/core/dashboard-session-controls.d.ts

@@ -38,4 +38,3 @@ export declare function continueDashboardSession(params: {
     sessionManager: ISessionManager;
     sessionId: number;
 }): DashboardContinueResult;
-//# sourceMappingURL=dashboard-session-controls.d.ts.map

package/dist/core/dashboard-session-controls.js

@@ -151,4 +151,3 @@ export function continueDashboardSession(params) {
     params.sessionManager.flushEffects(effects);
     return { ok: true, sessionId: sessionRow.id };
 }
-//# sourceMappingURL=dashboard-session-controls.js.map

package/dist/core/delegated-connector-health.d.ts

@@ -60,4 +60,3 @@ export declare function markSignoutWarned(db: Database.Database, warning: Delega
  * into `INotificationManager.send`. US-English per Decision Log #11.
  */
 export declare function renderSignoutDm(warning: DelegatedSignoutWarning): string;
-//# sourceMappingURL=delegated-connector-health.d.ts.map

package/dist/core/delegated-connector-health.js

@@ -154,4 +154,3 @@ export function renderSignoutDm(warning) {
         `Re-authorize from your ${warning.backend} connector settings, then re-run the integration probe from the dashboard.`,
     ].join(" ");
 }
-//# sourceMappingURL=delegated-connector-health.js.map

package/dist/core/dispatcher-date-utils.d.ts

@@ -46,4 +46,3 @@ export declare function getLocalDateParts(date: Date, timeZone?: string): LocalD
  * passed today.
  */
 export declare function compareLocalDateParts(a: LocalDateParts, b: LocalDateParts): number;
-//# sourceMappingURL=dispatcher-date-utils.d.ts.map

package/dist/core/dispatcher-date-utils.js

@@ -129,4 +129,3 @@ export function compareLocalDateParts(a, b) {
         return a.hour - b.hour;
     return a.minute - b.minute;
 }
-//# sourceMappingURL=dispatcher-date-utils.js.map

package/dist/core/dispatcher-error-handling.d.ts

@@ -112,6 +112,19 @@ export declare class DispatcherErrorRouter {
      * chat_error semantics.
      */
     notifyDashboardError(event: Event, message: string): void;
+    /**
+     * Write a `result='failed'` agent_actions row carrying the actual spend
+     * for a turn the backend completed before the daemon's per-turn budget
+     * cap rejected it. Codex / Gemini enforce `max_budget_usd` post-hoc, so
+     * the provider has already billed by the time we land here. Without
+     * this row the dashboard's cost telemetry under-reports real spend by
+     * the size of every budget-rejected turn (in this repo it was a $2.26
+     * morning_routine that left the daily total at $0).
+     *
+     * Best-effort: a logging failure must not mask the original quota error
+     * — we catch and warn instead of rethrowing.
+     */
+    private recordPostHocBudgetSpend;
     extractQuotaError(error: unknown): BackendQuotaError | null;
     formatQuotaMessage(quotaError: BackendQuotaError): string;
     formatBackendLabel(backendId: BackendQuotaError["backendId"]): string;
@@ -156,4 +169,3 @@ export declare class DispatcherErrorRouter {
      */
     runDelegatedConnectorWarningDispatch(warnings: readonly DelegatedSignoutWarning[], event: MessageEvent, sessionBackend: BackendId, sessionId: number): void;
 }
-//# sourceMappingURL=dispatcher-error-handling.d.ts.map

package/dist/core/dispatcher-error-handling.js

@@ -137,6 +137,17 @@ export class DispatcherErrorRouter {
     }
     async handleError(event, error) {
         logger.error({ event: event.type, error: error.message }, "Event processing error");
+        // Cost visibility for post-hoc budget rejections — Codex / Gemini CLI
+        // run a turn to completion before the daemon's per-turn cap can
+        // reject. The user has already been billed by the provider, so write
+        // a `result='failed'` agent_actions row carrying the actual usage so
+        // the dashboard's cost dials reflect reality. Without this the
+        // success-only audit path (`logAction` in ResultProcessor) silently
+        // drops budget-rejected spend.
+        const quotaForSpend = this.extractQuotaError(error);
+        if (quotaForSpend?.spend) {
+            this.recordPostHocBudgetSpend(event, quotaForSpend, error.message);
+        }
         // Defense-in-depth cleanup of the notify-dedup marker — processResult
         // is the primary collection point, but if execution threw before
         // reaching it, drop any orphan entry here so the set cannot grow
@@ -196,6 +207,62 @@ export class DispatcherErrorRouter {
             return;
         this.getDashboardStream()?.sendError?.(event.channel, message);
     }
+    /**
+     * Write a `result='failed'` agent_actions row carrying the actual spend
+     * for a turn the backend completed before the daemon's per-turn budget
+     * cap rejected it. Codex / Gemini enforce `max_budget_usd` post-hoc, so
+     * the provider has already billed by the time we land here. Without
+     * this row the dashboard's cost telemetry under-reports real spend by
+     * the size of every budget-rejected turn (in this repo it was a $2.26
+     * morning_routine that left the daily total at $0).
+     *
+     * Best-effort: a logging failure must not mask the original quota error
+     * — we catch and warn instead of rethrowing.
+     */
+    recordPostHocBudgetSpend(event, quotaError, errorMessage) {
+        const spend = quotaError.spend;
+        if (!spend)
+            return;
+        try {
+            const columns = [
+                "event_id",
+                "action_type",
+                "model_used",
+                "cost_usd",
+                "tokens_input",
+                "tokens_output",
+                "duration_ms",
+                "num_turns",
+                "result",
+                "backend",
+                "cost_source",
+                "error",
+                "completed_at",
+            ];
+            const placeholders = columns.map(() => "?").join(", ");
+            const values = [
+                event.correlationId,
+                event.type,
+                spend.modelId,
+                spend.costUsd,
+                spend.usage.inputTokens,
+                spend.usage.outputTokens,
+                spend.durationMs,
+                spend.numTurns,
+                "failed",
+                quotaError.backendId,
+                spend.costSource ?? null,
+                errorMessage.slice(0, 4096),
+                new Date().toISOString(),
+            ];
+            this.db
+                .prepare(`INSERT INTO agent_actions (${columns.join(", ")}) VALUES (${placeholders})`)
+                .run(...values);
+        }
+        catch (err) {
+            logger.warn({ err, eventType: event.type, backendId: quotaError.backendId }, "Failed to record post-hoc budget spend in agent_actions");
+        }
+    }
     extractQuotaError(error) {
         if (error instanceof BackendQuotaError) {
             return error;
@@ -252,6 +319,8 @@ export class DispatcherErrorRouter {
                 return "Codex";
             case "gemini":
                 return "Gemini CLI";
+            case "opencode":
+                return "OpenCode";
             default:
                 return backendId;
         }
@@ -390,4 +459,3 @@ export class DispatcherErrorRouter {
         }
     }
 }
-//# sourceMappingURL=dispatcher-error-handling.js.map

package/dist/core/dispatcher-hourly-check.d.ts

@@ -49,6 +49,7 @@
  *     a refresh, matching pre-injection behaviour.
  */
 import type Database from "better-sqlite3";
+import type { IntegrationKey } from "@aitne/shared";
 import type { AgentConfig } from "../config.js";
 import type { EventBus } from "./event-bus.js";
 import type { TodayWriteLockManager } from "./today-write-lock.js";
@@ -66,7 +67,7 @@ export interface HourlyCheckCoordinatorDeps {
     todayWriteLock: TodayWriteLockManager | undefined;
     prompt: PromptAssembler;
     /**
-     * ROUTINE_DATA_ACQUISITION_DESIGN.md Phase 4 / D3 — pre-pass runner
+     * docs/design/appendices/routine-data-acquisition.md Phase 4 / D3 — pre-pass runner
      * spawned between Stage 2 (lite-tier triage) and Stage 3 (medium-tier
      * main session) on `escalate` / `failed` verdicts. The rendered
      * `<fetch_report>` block rides on the Stage 3 RoutineEvent's
@@ -89,6 +90,59 @@ export interface HourlyCheckCoordinatorDeps {
      * permitted to proceed.
      */
     isAutonomousAllowed: () => TriggerHourlyCheckSkipReason | null;
+    /**
+     * Accessor for the scheduler's `queueMorningRoutineWake`. Returns the
+     * bound function once wiring has completed, or `null` early in startup
+     * before the scheduler is constructed. The pre-routine gate calls this
+     * when it detects the current agent-day's morning_routine has not run
+     * yet (typical cause: Mac slept through the 04:00 cron tick). The
+     * wake row carries the dedup guarantee — multiple back-to-back hourly
+     * ticks all see the same in-flight row instead of stacking up.
+     */
+    getQueueMorningRoutineWake: () => QueueMorningRoutineWake | null;
+}
+/** Signature of `AgentScheduler.queueMorningRoutineWake`, narrowed to the
+ *  surface the dispatcher gate consumes. Kept structural so we don't pull
+ *  the scheduler class into this module just for a type reference. */
+export type QueueMorningRoutineWake = (source: string, options?: {
+    postCatchupRoutines?: string[];
+    postCatchupHourlyCheck?: boolean;
+}) => {
+    inserted: boolean;
+    existingId?: number;
+};
+/**
+ * HOURLY_CHECK_GATE_REDESIGN_PLAN.md §3.3 + §7.2 — outcome of the
+ * Layer-1 pre-pass harvest that runs at the top of `trigger()` for
+ * delegated/native integrations. Surfaced both in the audit row (per-
+ * tick observability) and on the Stage 3 event (the rendered
+ * `<fetch_report>` block).
+ */
+export interface HarvestResult {
+    /** True when at least one integration was eligible and the runner ran. */
+    ran: boolean;
+    /** Integrations whose sub-session completed successfully or partially. */
+    integrations: IntegrationKey[];
+    /** Eligible integrations suppressed by the freshness window. */
+    skippedIntegrations: IntegrationKey[];
+    /** Eligible integrations whose sub-session ended in `failed`. */
+    failedIntegrations: IntegrationKey[];
+    /** Wall-clock time spent on the harvest (ms). */
+    durationMs: number;
+    /**
+     * True when any eligible integration failed. Triggers §3.5 cautious-
+     * escalate: gate decision is forced to `stage3` regardless of the
+     * signal verdict so a fetch outage doesn't manifest as silent
+     * stage0.
+     */
+    failed: boolean;
+    /**
+     * Rendered `<fetch_report>` block from the runner, ready to plumb
+     * onto `stage3Event.data.fetchReportBlock`. `null` when the runner
+     * was not spawned (no eligible integrations) — in that case the
+     * Stage 3 prompt simply omits the block.
+     */
+    fetchReportBlock: string | null;
 }
 export declare class HourlyCheckCoordinator {
     private readonly db;
@@ -105,8 +159,26 @@ export declare class HourlyCheckCoordinator {
     private readonly isHourlyCheckInProgress;
     private readonly isMorningRoutineActive;
     private readonly isAutonomousAllowed;
+    private readonly getQueueMorningRoutineWake;
     constructor(deps: HourlyCheckCoordinatorDeps);
     trigger(source: string, options?: TriggerHourlyCheckOptions): Promise<TriggerHourlyCheckResult>;
+    /**
+     * 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.
+     */
+    private harvestForGate;
     /**
      * cost-reduction-structural §B — pull a fresh signal snapshot and run
      * the deterministic gate. Helper so the dispatcher's call site stays
@@ -147,4 +219,3 @@ export declare class HourlyCheckCoordinator {
      */
     private runStage2Triage;
 }
-//# sourceMappingURL=dispatcher-hourly-check.d.ts.map