@aitne/daemon 0.1.10 → 0.1.11

package/dist/core/dispatcher-types.js

@@ -5,12 +5,12 @@
  * the daemon — adapter / service interfaces (`IDashboardStream`,
  * `INotificationManager`, `ISessionManager`, `IMessageRecorder`,
  * `IContextBuilder`, `IAuditLogger`), the `GetTaskFlow` callback, and the
- * value types used at API boundaries (`TriggerHourlyCheckOptions`,
- * `TriggerHourlyCheckResult`, `InFlightExecutionInfo`, `SetupMode`,
+ * value types used at API boundaries (`TriggerActivityScanOptions`,
+ * `TriggerActivityScanResult`, `InFlightExecutionInfo`, `SetupMode`,
  * `BangCommandDetail`, `ReplyActivityHandle`). It also hosts two pure
  * helpers that have no dependence on dispatcher instance state:
  * `buildLogErrorContext` (recovers backend/quota failure metadata from a
- * thrown error) and `parseStage2Verdict` (extracts the Stage 2 hourly-check
+ * thrown error) and `parseStage2Verdict` (extracts the Stage 2 activity-scan
  * triage JSON verdict from an LLM response).
  *
  * The dispatcher re-exports the public-surface members of this file so that

package/dist/core/dispatcher.d.ts

@@ -1,23 +1,26 @@
 import type Database from "better-sqlite3";
 import type { Event } from "@aitne/shared";
+import { type TaskDeliveryAsset } from "@aitne/shared";
 import type { AgentConfig } from "../config.js";
 import type { DocsCitationLookup } from "./docs/citation-validator.js";
 import type { SignalDetector } from "./signal-detector.js";
 import type { ServiceRegistry } from "../services/service-registry.js";
 import { EventBus } from "./event-bus.js";
+import { SessionGateRegistry } from "./session-gate.js";
 import type { IAgentRouter } from "./backends/backend-router.js";
 import type { TodayWriteLockManager } from "./today-write-lock.js";
 import type { RoadmapWriteLockManager } from "./roadmap-write-lock.js";
 import type { AgentWriteTracker } from "../safety/agent-write-tracker.js";
 import type { AttachmentStore } from "../services/attachments/store.js";
+import type { OutboundAttachmentRef } from "../adapters/types.js";
 import type { VoiceTranscriber } from "../services/voice/transcriber.js";
 import type { AgentExecutionTracker } from "./agents/agent-execution-tracker.js";
 export type { IAgentCore, StreamCallbacks } from "./agent-core.js";
 export type { IAgentRouter } from "./backends/backend-router.js";
-import { parseStage2Verdict, type ReplyActivityHandle, type IDashboardStream, type IContextBuilder, type GetTaskFlow, type INotificationManager, type ISessionManager, type IMessageRecorder, type IAuditLogger, type BangCommandDetail, type DailyWriteAuditDetail, type TriggerHourlyCheckSkipReason, type SetupMode, type TriggerHourlyCheckOptions, type TriggerHourlyCheckResult, type InFlightExecutionInfo } from "./dispatcher-types.js";
+import { parseStage2Verdict, type ReplyActivityHandle, type IDashboardStream, type IContextBuilder, type GetTaskFlow, type INotificationManager, type ISessionManager, type IMessageRecorder, type IAuditLogger, type BangCommandDetail, type DailyWriteAuditDetail, type TriggerActivityScanSkipReason, type SetupMode, type TriggerActivityScanOptions, type TriggerActivityScanResult, type InFlightExecutionInfo } from "./dispatcher-types.js";
 export { parseStage2Verdict, };
-export type { ReplyActivityHandle, IDashboardStream, IContextBuilder, GetTaskFlow, INotificationManager, ISessionManager, IMessageRecorder, IAuditLogger, BangCommandDetail, DailyWriteAuditDetail, TriggerHourlyCheckSkipReason, SetupMode, TriggerHourlyCheckOptions, TriggerHourlyCheckResult, InFlightExecutionInfo, };
-import type { QueueMorningRoutineWake } from "./dispatcher-hourly-check.js";
+export type { ReplyActivityHandle, IDashboardStream, IContextBuilder, GetTaskFlow, INotificationManager, ISessionManager, IMessageRecorder, IAuditLogger, BangCommandDetail, DailyWriteAuditDetail, TriggerActivityScanSkipReason, SetupMode, TriggerActivityScanOptions, TriggerActivityScanResult, InFlightExecutionInfo, };
+import type { QueueMorningRoutineWake } from "./dispatcher-activity-scan.js";
 import { SKILL_CURATION_OPTIMIZER_ALLOWED_TOOLS } from "./dispatcher-scheduled-tasks.js";
 export { SKILL_CURATION_OPTIMIZER_ALLOWED_TOOLS };
 export declare class EventDispatcher {
@@ -101,6 +104,14 @@ export declare class EventDispatcher {
      * instead of leaving the row silently flipped to `failed` in the DB.
      */
     private browserTaskTerminalNotifier;
+    /**
+     * BACKGROUND_TASK_RUNNER_DESIGN.md §4.2 — the dispatcher routes
+     * `scheduled.background_task` events to this runner. Wired at startup
+     * from `bootstrap/event-pipeline.ts` via `setBackgroundTaskRunner`.
+     * Null when the runner factory has not landed — the dispatch branch
+     * flips the row to `failed (runner_unavailable)` so it doesn't park.
+     */
+    private backgroundTaskRunner;
     /**
      * Current setup mode — scope-agnostic flag that survives internal
      * direct-message session refresh (day boundary, stale flag, etc). Previously this
@@ -130,38 +141,38 @@ export declare class EventDispatcher {
     /** Dedup guard: timestamp of the last roadmap_refresh emission */
     private lastRoadmapRefreshEmitMs;
     private morningRoutineInProgress;
-    private hourlyCheckInProgress;
+    private activityScanInProgress;
     /**
      * Wall-clock timestamp (ms since epoch) of the most recent flip of
-     * `hourlyCheckInProgress` to `true`, or `null` when the flag is false.
+     * `activityScanInProgress` to `true`, or `null` when the flag is false.
      *
-     * Paired with `HOURLY_CHECK_FLAG_MAX_AGE_MS` to break the silent-stall
+     * Paired with `ACTIVITY_SCAN_FLAG_MAX_AGE_MS` to break the silent-stall
      * pattern where the flag is set true at enqueue time but the matching
      * `dispatchSafe` finally never runs — currently possible when the
      * EventBus evicts/drops the queued routine event under `put()` pressure
      * (heap-js drops the lowest-priority entry silently when `heap.size() >=
      * maxSize=1000`). Without the timestamp the flag stays `true` until
      * process restart and every subsequent hourly tick short-circuits with
-     * `hourly_check_in_progress`.
+     * `activity_scan_in_progress`.
      *
-     * Read side (`isHourlyCheckInProgress` callback below) checks the age
+     * Read side (`isActivityScanInProgress` callback below) checks the age
      * and auto-clears when it exceeds the bound, surfacing the recovery via
      * a warn log so the operator sees the EventBus pressure event.
      */
-    private hourlyCheckInProgressAt;
+    private activityScanInProgressAt;
     /**
-     * Upper bound for how long `hourlyCheckInProgress=true` can plausibly
+     * Upper bound for how long `activityScanInProgress=true` can plausibly
      * be valid before we treat it as stuck and force-clear.
      *
-     * Sized generously above the realistic Stage-3 hourly_check ceiling
-     * (fetch_window pre-pass ~30–60 s + Sonnet hourly_check session
+     * Sized generously above the realistic Stage-3 activity_scan ceiling
+     * (fetch_window pre-pass ~30–60 s + Sonnet activity_scan session
      * ~1–3 min) so a slow but normal run is never falsely cleared. Sized
      * well below an entire agent-day so a stuck flag recovers within a
      * single hourly cron cycle's worst case (default cadence 60 min).
      * The 30-minute window is comfortably outside any plausible "still
      * running" interpretation and inside one full hourly slot.
      */
-    private static readonly HOURLY_CHECK_FLAG_MAX_AGE_MS;
+    private static readonly ACTIVITY_SCAN_FLAG_MAX_AGE_MS;
     /**
      * P22 §3.4 — wired by `index.ts` after the daemon's data dir + skills root
      * are known. Returns a `{runId, runToken, workdirPath, targetSkills}` tuple
@@ -194,12 +205,19 @@ export declare class EventDispatcher {
      *  and older code paths that don't wire the store. When null, the
      *  dispatcher skips attachment staging + outbound collection. */
     private attachmentStore;
+    /** Injected lazily via `setTaskDeliveryAssetResolver` — optional.
+     *  Resolves a task's deliverable assets (browser-task screenshots +
+     *  worker-written files) to outbound attachments for the `task.delivery`
+     *  idle + active branches (the ingest hook is constructed after this
+     *  dispatcher, so it is wired post-construction like the attachment
+     *  store). When null, task-delivery DMs are text-only. */
+    private taskDeliveryAssetResolver;
     /** Injected lazily via `setDelegatedSyncRefresh` — optional. When null,
-     *  hourly check fires without first refreshing delegated-mode snapshots,
+     *  activity scan fires without first refreshing delegated-mode snapshots,
      *  matching the pre-Phase-9 behaviour. Wired in production when at
      *  least one integration is in delegated mode. See
      *  `docs/design/appendices/delegated-sync-opt-in.md` and the worker's
-     *  `runDisabledCadencesForHourlyCheck` method. */
+     *  `runDisabledCadencesForActivityScan` method. */
     private delegatedSyncRefresh;
     /**
      * Injected lazily via `setQueueMorningRoutineWake` (wired in `index.ts`
@@ -218,7 +236,7 @@ export declare class EventDispatcher {
      * Injected lazily via `setEventBroadcaster` — optional. When wired, the
      * dispatcher emits `routine_started` / `routine_completed` SSE events at
      * the `dispatchSafe` chokepoint so the dashboard can render real-time
-     * progress for autonomous routines (morning_routine, hourly_check,
+     * progress for autonomous routines (morning_routine, activity_scan,
      * roadmap_refresh, evening/weekly/monthly reviews, etc.).
      *
      * Failure to broadcast is non-fatal: the throw is swallowed and logged
@@ -295,21 +313,38 @@ export declare class EventDispatcher {
      */
     private readonly resultProcessor;
     /**
-     * Phase D-2 coordinator: owns `triggerHourlyCheck` and the
+     * Phase D-2 coordinator: owns `triggerActivityScan` and the
      * cost-reduction-structural §B three-stage gate. Borrows live
-     * accessors for the dispatcher's `hourlyCheckInProgress` flag so the
+     * accessors for the dispatcher's `activityScanInProgress` flag so the
      * pre-existing C1 atomic check-and-set semantics survive the split.
      */
     /**
      * docs/design/appendices/routine-data-acquisition.md Phase 4 / D1 — shared pre-pass
-     * runner for `routine.fetch_window`. Injected into HourlyCheckCoordinator
+     * runner for `routine.fetch_window`. Injected into ActivityScanCoordinator
      * (D3), MorningRoutineRunner (D2), and ScheduledTaskRunner (D4) so
      * every routine that has rows in `ROUTINE_WINDOWS` gets the same
      * fetcher session ahead of its parent dispatch. Pure helper, no
      * mutable state of its own.
      */
     private readonly fetchWindowRunner;
-    private readonly hourlyCheck;
+    /**
+     * PREPASS_COST_REDUCTION_PLAN.md N2 — offline (backend-API-host DNS) +
+     * cached-auth spawn gate for autonomous sessions. Shared with the
+     * pre-pass fan-out runner so both layers reuse one DNS verdict cache.
+     */
+    private readonly spawnGate;
+    /**
+     * Last spawn-gate skip *audit write* per (schedule-or-type, reason) —
+     * ms epoch. A released schedule row is re-claimed by the
+     * ScheduleWatcher every poll tick (default 5s), so an hours-long
+     * offline window would otherwise INSERT thousands of identical
+     * `result='skipped'` rows. The DB row release/claim churn is bounded
+     * (UPDATEs to one row); the audit INSERT is what must be throttled.
+     * In-memory on purpose: worst case after a restart is one extra row.
+     */
+    private readonly spawnGateSkipAuditAt;
+    private static readonly SPAWN_GATE_SKIP_AUDIT_THROTTLE_MS;
+    private readonly activityScan;
     /**
      * Phase D-2 coordinator: owns morning-routine execution end-to-end
      * (lock acquisition, prompt-variant selection, retry chain, today.md
@@ -341,7 +376,7 @@ export declare class EventDispatcher {
      * thin shims that forward into this handler.
      */
     private readonly messageHandler;
-    constructor(eventBus: EventBus, agentRouter: IAgentRouter, contextBuilder: IContextBuilder, getTaskFlow: GetTaskFlow, notificationMgr: INotificationManager, sessionMgr: ISessionManager, messageRecorder: IMessageRecorder, audit: IAuditLogger, db: Database.Database, config: AgentConfig, todayWriteLock?: TodayWriteLockManager | undefined, services?: ServiceRegistry | undefined, roadmapWriteLock?: RoadmapWriteLockManager | undefined, writeTracker?: AgentWriteTracker | undefined);
+    constructor(eventBus: EventBus, agentRouter: IAgentRouter, contextBuilder: IContextBuilder, getTaskFlow: GetTaskFlow, notificationMgr: INotificationManager, sessionMgr: ISessionManager, messageRecorder: IMessageRecorder, audit: IAuditLogger, db: Database.Database, config: AgentConfig, todayWriteLock?: TodayWriteLockManager | undefined, services?: ServiceRegistry | undefined, roadmapWriteLock?: RoadmapWriteLockManager | undefined, writeTracker?: AgentWriteTracker | undefined, sessionGates?: SessionGateRegistry);
     private loadPersistedSetupMode;
     /** Set the SignalDetector for implicit feedback collection from user messages. */
     setSignalDetector(detector: SignalDetector): void;
@@ -373,6 +408,13 @@ export declare class EventDispatcher {
      */
     setBrowserTaskRunner(runner: import("../services/browser-task/browser-task-runner.js").BrowserTaskRunner | null): void;
     getBrowserTaskRunner(): import("../services/browser-task/browser-task-runner.js").BrowserTaskRunner | null;
+    /**
+     * BACKGROUND_TASK_RUNNER_DESIGN.md §4.2 — wire the generic
+     * background-task runner so the `scheduled.background_task` dispatch
+     * branch can hand fire-time events to it. Pairs with the
+     * `event-pipeline.ts` `createBackgroundTaskRunner` factory call.
+     */
+    setBackgroundTaskRunner(runner: import("../services/background-task/background-task-runner.js").BackgroundTaskRunner | null): void;
     /**
      * BROWSER_TASK_REDESIGN_PLAN.md §7 — wire the terminal-state DM
      * emitter used by the `scheduled.browser_task` failure paths (see
@@ -394,13 +436,19 @@ export declare class EventDispatcher {
     setDocsCitationLookup(lookup: DocsCitationLookup): void;
     /** Chat-attachments Phase 1 — inject the shared AttachmentStore. */
     setAttachmentStore(store: AttachmentStore): void;
+    /** BACKGROUND_TASK_RUNNER_DESIGN.md Phase 1 (delivery assets) — inject the
+     *  asset resolver used by the `task.delivery` idle + active branches to
+     *  attach a task's deliverable files (screenshots, PDF/PPTX/PNG/docs)
+     *  inline. Wired post-construction because the underlying
+     *  dashboard-ingest hook is built after this dispatcher. */
+    setTaskDeliveryAssetResolver(resolver: (platform: string, assets: readonly TaskDeliveryAsset[]) => Promise<readonly OutboundAttachmentRef[]>): void;
     /** Inject the local-Whisper voice transcriber. Optional — when unset,
      *  inbound audio attachments are passed to the backend with a path-only
      *  reference (the pre-feature behaviour). */
     setVoiceTranscriber(transcriber: VoiceTranscriber): void;
     /**
      * Inject the delegated-sync refresh callback. Called from
-     * `triggerHourlyCheck` before the gate decision so any cadence the
+     * `triggerActivityScan` before the gate decision so any cadence the
      * operator left opted-OUT (post-Phase-9 default) populates fresh
      * Gmail / Notion observations the agent can then consume.
      *
@@ -410,13 +458,13 @@ export declare class EventDispatcher {
      * dispatcher holding a stale reference.
      *
      * Pass `null` to detach (e.g. when no delegated integration exists).
-     * The hourly check then proceeds without a refresh — equivalent to the
+     * The activity scan then proceeds without a refresh — equivalent to the
      * pre-injection behaviour.
      */
     setDelegatedSyncRefresh(fn: (() => Promise<void>) | null): void;
     /**
      * Wire the scheduler's `queueMorningRoutineWake` so the pre-routine
-     * gate (hourly_check + evening/weekly/monthly review) can self-recover
+     * gate (activity_scan + evening/weekly/monthly review) can self-recover
      * after a missed 04:00 cron fire. Wired once in `index.ts` after both
      * the dispatcher and scheduler are constructed; passing `null` detaches.
      * When unset, the gate logs a warning and still skips the dependent
@@ -439,6 +487,14 @@ export declare class EventDispatcher {
      * behaves exactly as before. Set once at boot from the event-pipeline factory.
      */
     setAgentExecutionTracker(tracker: AgentExecutionTracker): void;
+    /**
+     * Resolve the user-Agent slug owning an in-flight firing, for stamping
+     * `agent_id` into quiet-hours-deferred DM rows (QUIET_HOURS_HARDENING_PLAN
+     * Phase 1 — the `/api/notify` gate coalesces per Agent so an hourly Agent
+     * firing five times overnight yields one combined DM). `null` when no
+     * tracker is wired or no execution is active for the correlation id.
+     */
+    agentIdForCorrelation(correlationId: string): string | null;
     /**
      * Open an execution row for an agent-resolvable firing (§8.1), called from
      * `dispatchSafe` after the setup / cost gates pass so a skipped firing never
@@ -507,7 +563,7 @@ export declare class EventDispatcher {
     /**
      * Enter setup mode. Called from `POST /setup/start` so the warm gate
      * engages the moment the user opens the dashboard setup flow — before any
-     * agent turn runs — so concurrent hourly_check / morning routine / scheduled
+     * agent turn runs — so concurrent activity_scan / morning routine / scheduled
      * wake work cannot race with the setup conversation. Persisted to
      * `runtime_state` so the flag survives daemon restart.
      */
@@ -526,7 +582,7 @@ export declare class EventDispatcher {
      */
     getInFlightExecutions(): InFlightExecutionInfo[];
     /**
-     * Gate for autonomous background work (cron routines, hourly_check,
+     * Gate for autonomous background work (cron routines, activity_scan,
      * scheduled wake tasks, startup catchup, calendar-poller reactive events).
      *
      * Two layers:
@@ -558,21 +614,29 @@ export declare class EventDispatcher {
     /**
      * Check whether this autonomous event should be skipped because the daily
      * autonomous cost cap has been exceeded. Uses priority-based degradation:
-     * hourly_check (lowest priority, skipped first) → roadmap_refresh →
+     * activity_scan (lowest priority, skipped first) → roadmap_refresh →
      * evening_review → morning_routine (highest, last to be cut).
      *
      * Lower-priority events are skipped at 100% of cap; higher-priority events
      * only at 150%+, giving headroom for the morning briefing.
      */
     private shouldSkipForCostCap;
+    /**
+     * Resolve the candidate backends for an autonomous event and run the
+     * N2 spawn gates against them. Fail-open on every internal error
+     * (binding resolution included) — the gate exists to save sessions
+     * that would deterministically fail, never to block live ones.
+     * Returns `null` when the gate could not be evaluated.
+     */
+    private evaluateAutonomousSpawnGate;
     private handleEvent;
     private handleEventInner;
     /**
-     * Public entry point. Delegates to the HourlyCheckCoordinator.
+     * Public entry point. Delegates to the ActivityScanCoordinator.
      * The dispatcher keeps the wrapper because tests + the cron entry
-     * call `dispatcher.triggerHourlyCheck(source, opts)` directly.
+     * call `dispatcher.triggerActivityScan(source, opts)` directly.
      */
-    triggerHourlyCheck(source: string, options?: TriggerHourlyCheckOptions): Promise<TriggerHourlyCheckResult>;
+    triggerActivityScan(source: string, options?: TriggerActivityScanOptions): Promise<TriggerActivityScanResult>;
     /**
      * Advisory check: is a morning routine execution or retry currently in
      * progress? Synchronous (no async) so callers can atomically gate other
@@ -586,7 +650,7 @@ export declare class EventDispatcher {
      *
      * Public (not private) because Phase 4's `AuthHealthMonitor.checkAll()`
      * shares the same skip-while-morning-routine-active invariant as the
-     * hourly check, and injects this method as an option so a probe tick
+     * activity scan, and injects this method as an option so a probe tick
      * running concurrently with morning routine can no-op cleanly. See
      * `docs/design/09-safety-cost.md` §9.5.4.
      */
@@ -608,8 +672,25 @@ export declare class EventDispatcher {
      * non-scheduled events or already-terminal rows.
      */
     private releaseClaimedSchedule;
+    /**
+     * Throttle for spawn-gate skip audit rows. A released schedule row is
+     * due immediately, so the watcher re-claims it every poll tick (5s
+     * default) for the whole outage — without this, one offline day per
+     * pending row writes ~17k identical agent_actions rows. Keyed by
+     * (schedule id | event type) × reason so distinct routines and
+     * distinct reasons each still get their own first row, and a reason
+     * flip (offline → auth_unhealthy) is recorded promptly.
+     */
+    private shouldWriteSpawnGateSkipAudit;
     private dispatchSafe;
     private dispatch;
+    /**
+     * BACKGROUND_TASK_RUNNER_DESIGN.md §4.2 — dispatch branch for
+     * `scheduled.background_task`. Defers to `handleScheduledBackgroundTask`
+     * (validation + row creation + runner handoff) and translates the
+     * outcome into the `agent_schedule.status` write.
+     */
+    private handleScheduledBackgroundTaskDispatch;
     /**
      * BROWSER_TASK_REDESIGN_PLAN.md §6.2 + §7 — dispatch branch for
      * `scheduled.browser_task`. Defers the heavy lifting to