@aitne/daemon 0.1.10 → 0.1.11

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

@@ -113,18 +113,13 @@ export declare class DispatcherErrorRouter {
      */
     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.
+     * The distinct per-backend failures hiding behind a thrown error.
+     * `BackendRouterHandledError` carries up to two (main + fallback —
+     * both may have billed before failing); any other error is its own
+     * single entry. Identity-deduped because `cause` usually aliases one
+     * of `mainFailure` / `fallbackFailure`.
      */
-    private recordPostHocBudgetSpend;
+    private collectSpendFailures;
     extractQuotaError(error: unknown): BackendQuotaError | null;
     formatQuotaMessage(quotaError: BackendQuotaError): string;
     formatBackendLabel(backendId: BackendQuotaError["backendId"]): string;

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

@@ -41,6 +41,7 @@
 import { isMessageEvent, isScheduledEvent } from "@aitne/shared";
 import { BackendDecisiveFailure, BackendQuotaError, } from "./agent-core.js";
 import { BackendRouterHandledError } from "./backends/backend-router.js";
+import { extractFailureSpendInfo, recordFailureSpendRow, } from "./backends/failure-spend.js";
 import { consultDelegatedConnectorHealth, markSignoutWarned, renderSignoutDm, } from "./delegated-connector-health.js";
 import { compareLocalDateParts, getLocalDateParts, localDateTimeToUtcMs, } from "./dispatcher-date-utils.js";
 import { createLogger } from "../logging.js";
@@ -137,16 +138,27 @@ 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);
+        // Cost visibility for failed turns that already billed the provider —
+        // post-hoc budget rejections (Codex / Gemini run the turn to
+        // completion before the cap can reject; Claude's SDK aborts mid-
+        // stream with a partial-usage snapshot stamped by the core) and
+        // non-quota terminal errors that carried usage (auth-mid-run,
+        // timeout, transport failure). Write a `result='failed'`
+        // agent_actions row per distinct backend failure so the dashboard's
+        // cost dials reflect reality. Without this the success-only audit
+        // path (`logAction` in ResultProcessor) silently drops the spend.
+        // PREPASS_COST_REDUCTION_PLAN.md N1.
+        //
+        // `BackendRouterHandledError` is unwrapped into its per-backend
+        // failures (main + fallback can BOTH have billed); a raw failover
+        // signal is recorded as-is. Pre-N1 this looked only at the top-level
+        // error, so a no-fallback quota kill — which the router wraps —
+        // recorded nothing.
+        for (const failure of this.collectSpendFailures(error)) {
+            const spendInfo = extractFailureSpendInfo(failure);
+            if (spendInfo) {
+                recordFailureSpendRow(this.db, event, spendInfo, error.message);
+            }
         }
         // Defense-in-depth cleanup of the notify-dedup marker — processResult
         // is the primary collection point, but if execution threw before
@@ -208,60 +220,24 @@ export class DispatcherErrorRouter {
         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.
+     * The distinct per-backend failures hiding behind a thrown error.
+     * `BackendRouterHandledError` carries up to two (main + fallback —
+     * both may have billed before failing); any other error is its own
+     * single entry. Identity-deduped because `cause` usually aliases one
+     * of `mainFailure` / `fallbackFailure`.
      */
-    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");
+    collectSpendFailures(error) {
+        if (error instanceof BackendRouterHandledError) {
+            const failures = [error.mainFailure];
+            if (error.fallbackFailure && error.fallbackFailure !== error.mainFailure) {
+                failures.push(error.fallbackFailure);
+            }
+            if (error.cause && !failures.includes(error.cause)) {
+                failures.push(error.cause);
+            }
+            return failures;
         }
+        return [error];
     }
     extractQuotaError(error) {
         if (error instanceof BackendQuotaError) {

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

@@ -62,6 +62,8 @@ 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 { getRuntimeWindow } from "../db/agents-store.js";
+import { resolveHourlyCadence } from "./agents/hourly-cadence.js";
 import { createLogger } from "../logging.js";
 const logger = createLogger("dispatcher-hourly-check");
 export class HourlyCheckCoordinator {
@@ -99,7 +101,10 @@ export class HourlyCheckCoordinator {
     }
     async trigger(source, options = {}) {
         const forced = options.force === true;
-        const minObservations = this.config.hourlyCheckMinObservations;
+        // Observation threshold comes from the hourly-check agent row's
+        // runtime_window, with the legacy `hourlyCheckMinObservations` config key
+        // as fallback (AGENTS_HUB_REDESIGN_PLAN.md §2).
+        const minObservations = resolveHourlyCadence(getRuntimeWindow(this.db, "hourly-check"), this.config).minObservations;
         // C1 fix: atomic check-and-set on hourlyCheckInProgress BEFORE any await
         // boundary. Previously `await this.isMorningRoutineActive()` yielded to
         // the microtask queue, allowing cron + /api/agent/run-now arriving in

package/dist/core/dispatcher-message-handler.d.ts

@@ -110,6 +110,14 @@ export interface MessageHandlerDeps {
      * either kind on the affected channel.
      */
     getFinalConfirmHandler?: () => import("../services/browser-history/automation/final-confirm-handler.js").FinalConfirmHandler | null;
+    /**
+     * BACKGROUND_TASK_RUNNER_DESIGN.md Phase 4 — lazily-injected runner
+     * accessors for the per-task `!stop <id>` bang command. Null in tests
+     * and before the runners are wired at startup; the `!stop` handler tells
+     * the owner the runner is unavailable rather than dropping the request.
+     */
+    getBackgroundTaskRunner?: () => import("../services/background-task/background-task-runner.js").BackgroundTaskRunner | null;
+    getBrowserTaskRunner?: () => import("../services/browser-task/browser-task-runner.js").BrowserTaskRunner | null;
     /** Live getter for the dispatcher's `currentSetupMode` flag. */
     getCurrentSetupMode: () => SetupMode | null;
     /** Forward into the dispatcher's `beginSetupMode` so persistence stays
@@ -147,6 +155,8 @@ export declare class MessageHandler {
     private readonly getBangCommandRegistry;
     private readonly getPurchaseHandler;
     private readonly getFinalConfirmHandler;
+    private readonly getBackgroundTaskRunner;
+    private readonly getBrowserTaskRunner;
     private readonly getCurrentSetupMode;
     private readonly beginSetupMode;
     private readonly lookupCustomBangCommandForEvent;

package/dist/core/dispatcher-message-handler.js

@@ -81,6 +81,8 @@ export class MessageHandler {
     getBangCommandRegistry;
     getPurchaseHandler;
     getFinalConfirmHandler;
+    getBackgroundTaskRunner;
+    getBrowserTaskRunner;
     getCurrentSetupMode;
     beginSetupMode;
     lookupCustomBangCommandForEvent;
@@ -116,6 +118,10 @@ export class MessageHandler {
         this.getPurchaseHandler = deps.getPurchaseHandler ?? (() => null);
         this.getFinalConfirmHandler =
             deps.getFinalConfirmHandler ?? (() => null);
+        this.getBackgroundTaskRunner =
+            deps.getBackgroundTaskRunner ?? (() => null);
+        this.getBrowserTaskRunner =
+            deps.getBrowserTaskRunner ?? (() => null);
         this.getCurrentSetupMode = deps.getCurrentSetupMode;
         this.beginSetupMode = deps.beginSetupMode;
         this.lookupCustomBangCommandForEvent = deps.lookupCustomBangCommandForEvent;
@@ -492,6 +498,17 @@ export class MessageHandler {
                 enqueueBrowserResearchEvent: async (researchEvent) => {
                     await this.eventBus.put(researchEvent);
                 },
+                // Per-task `!stop <id>` — abort one detached worker. Resolved
+                // lazily from the live runner instances (which hold the in-memory
+                // handles the abort must reach); null until the runners are wired.
+                cancelBackgroundTask: async (taskId, reason) => {
+                    const runner = this.getBackgroundTaskRunner();
+                    return runner ? runner.cancel(taskId, reason) : false;
+                },
+                cancelBrowserTask: async (taskId, reason) => {
+                    const runner = this.getBrowserTaskRunner();
+                    return runner ? runner.cancel(taskId, reason) : false;
+                },
                 enqueueWikiApproval: async (approvalInput) => {
                     // WIKI_BUILDER_DESIGN.md §5.5 / §P2.E — escalate to Approve tier
                     // via the existing agent_schedule approval queue. The dashboard

package/dist/core/dispatcher-morning-routine.d.ts

@@ -26,7 +26,7 @@
  * and bridges into a handful of dispatcher / coordinator methods that
  * are still owned elsewhere (`rotateDayFiles`,
  * `diagnoseTodayMdState`, `isRoadmapStale`, `emitRoadmapRefresh`,
- * `triggerHourlyCheck`).
+ * `triggerActivityScan`).
  *
  * Dispatcher entry points served:
  *   - `EventDispatcher.dispatch` routes `routine === "morning_routine"`
@@ -38,7 +38,7 @@
  * Shared-state references held:
  *   - `setMorningRoutineInProgress` — setter callback. The flag is
  *     flipped to true at the start of the execute → executeWithRetry
- *     wrapper and reset in `finally` so the hourly check can resume.
+ *     wrapper and reset in `finally` so the activity scan can resume.
  */
 import type Database from "better-sqlite3";
 import type { Event } from "@aitne/shared";
@@ -104,10 +104,10 @@ export interface MorningRoutineRunnerDeps {
     /** Bridges into the dispatcher's roadmap-refresh emit. */
     emitRoadmapRefresh: (source: string) => void;
     /**
-     * Bridges into `EventDispatcher.triggerHourlyCheck` so the deferred
-     * post-morning hourly_check can fire from `emitPostMorningCatchups`.
+     * Bridges into `EventDispatcher.triggerActivityScan` so the deferred
+     * post-morning activity_scan can fire from `emitPostMorningCatchups`.
      */
-    triggerHourlyCheck: (source: string) => Promise<unknown>;
+    triggerActivityScan: (source: string) => Promise<unknown>;
     /**
      * morning-routine-optimization.md Phase 5/6/7 — the split-stage
      * pipeline orchestrator owns Stage A (today.md) + Stage B (daily
@@ -131,7 +131,7 @@ export declare class MorningRoutineRunner {
     private readonly diagnoseTodayMdState;
     private readonly isRoadmapStale;
     private readonly emitRoadmapRefresh;
-    private readonly triggerHourlyCheck;
+    private readonly triggerActivityScan;
     private readonly pipelineOrchestrator;
     constructor(deps: MorningRoutineRunnerDeps);
     /**

package/dist/core/dispatcher-morning-routine.js

@@ -26,7 +26,7 @@
  * and bridges into a handful of dispatcher / coordinator methods that
  * are still owned elsewhere (`rotateDayFiles`,
  * `diagnoseTodayMdState`, `isRoadmapStale`, `emitRoadmapRefresh`,
- * `triggerHourlyCheck`).
+ * `triggerActivityScan`).
  *
  * Dispatcher entry points served:
  *   - `EventDispatcher.dispatch` routes `routine === "morning_routine"`
@@ -38,7 +38,7 @@
  * Shared-state references held:
  *   - `setMorningRoutineInProgress` — setter callback. The flag is
  *     flipped to true at the start of the execute → executeWithRetry
- *     wrapper and reset in `finally` so the hourly check can resume.
+ *     wrapper and reset in `finally` so the activity scan can resume.
  */
 import { EventPriority, createEvent, formatSqliteDatetime, } from "@aitne/shared";
 import { flushPendingTodayRefresh } from "./drift-effects.js";
@@ -68,7 +68,7 @@ export class MorningRoutineRunner {
     diagnoseTodayMdState;
     isRoadmapStale;
     emitRoadmapRefresh;
-    triggerHourlyCheck;
+    triggerActivityScan;
     pipelineOrchestrator;
     constructor(deps) {
         this.db = deps.db;
@@ -82,7 +82,7 @@ export class MorningRoutineRunner {
         this.diagnoseTodayMdState = deps.diagnoseTodayMdState;
         this.isRoadmapStale = deps.isRoadmapStale;
         this.emitRoadmapRefresh = deps.emitRoadmapRefresh;
-        this.triggerHourlyCheck = deps.triggerHourlyCheck;
+        this.triggerActivityScan = deps.triggerActivityScan;
         this.pipelineOrchestrator = deps.pipelineOrchestrator;
     }
     /**
@@ -141,15 +141,15 @@ export class MorningRoutineRunner {
         logger.info({ promptKey, roadmapStale: roadmapStaleBeforeMorning, isRetry, retryCount, requestedTier: requestedTier ?? "default" }, "Morning routine dispatch");
         // B2 fix + docs/design/appendices/routine-data-acquisition.md Phase 4 / D2 race fix:
         // flip `morningRoutineInProgress=true` BEFORE the pre-pass fires so
-        // hourly_check can't squeeze through the cold-start window
-        // (`hourlyCheck.trigger` skips when `isMorningRoutineActive()`
+        // activity_scan can't squeeze through the cold-start window
+        // (`activityScan.trigger` skips when `isMorningRoutineActive()`
         // returns true). The original B2 fix already widened the flag to
         // span the whole retry chain; the pre-pass shifts the boundary
         // earlier so the same guard covers context build + binding resolve
         // + Haiku fetcher cold-start, all of which precede the executor.
         // The flag is reset in `finally` regardless of whether the pre-pass,
         // context build, or main session throws — so a partial-failure path
-        // cannot leave the flag stuck `true` and starve hourly_check forever.
+        // cannot leave the flag stuck `true` and starve activity_scan forever.
         this.setMorningRoutineInProgress(true);
         // `pipelineRun` is non-null when the orchestrator completed and
         // Stage A produced an `AgentResult`. A null value means Stage A
@@ -214,7 +214,7 @@ export class MorningRoutineRunner {
             // `routine.morning_routine` success audit row is durable opens a
             // window where, for a cron-triggered (non-wake) run, both
             // `isMorningRoutineActive()` and `morningRoutineRanToday()` read
-            // false — an hourly_check tick would then take the
+            // false — an activity_scan tick would then take the
             // `morning_routine_pending_for_today` branch and enqueue a
             // spurious morning_routine wake. The flag is instead cleared in
             // the post-finally try/finally below, AFTER the journal append +
@@ -368,7 +368,7 @@ export class MorningRoutineRunner {
             // audit row is durable (journal append + emitParentAuditRow above).
             // Reached on every post-finally exit path — success/catchup,
             // retry-scheduled, and the `pipelineRun === null` branch — so a
-            // Stage-A failure cannot leak the flag and wedge hourly_check.
+            // Stage-A failure cannot leak the flag and wedge activity_scan.
             this.setMorningRoutineInProgress(false);
         }
     }
@@ -387,9 +387,9 @@ export class MorningRoutineRunner {
                 routine,
             });
         }
-        if (event.data?.postCatchupHourlyCheck === true) {
-            logger.info("Triggering deferred hourly_check after morning catchup");
-            await this.triggerHourlyCheck("post_morning_catchup");
+        if (event.data?.postCatchupActivityScan === true) {
+            logger.info("Triggering deferred activity_scan after morning catchup");
+            await this.triggerActivityScan("post_morning_catchup");
         }
     }
     /**
@@ -456,7 +456,7 @@ export class MorningRoutineRunner {
             postCatchupRoutines: Array.isArray(event.data?.postCatchupRoutines)
                 ? event.data.postCatchupRoutines
                 : [],
-            postCatchupHourlyCheck: event.data?.postCatchupHourlyCheck === true,
+            postCatchupActivityScan: event.data?.postCatchupActivityScan === true,
             importance: "low",
         });
         // M1: dedup + INSERT in a single transaction so two concurrent

package/dist/core/dispatcher-result-processor.d.ts

@@ -41,6 +41,7 @@
 import type Database from "better-sqlite3";
 import type { Event, MessageEvent, AgentResult } from "@aitne/shared";
 import type { AgentConfig } from "../config.js";
+import { type ProactiveForwardType } from "./channel-timeline.js";
 import type { IAuditLogger, INotificationManager, ISessionManager } from "./dispatcher-types.js";
 import type { AgentExecutionOutcome } from "./agents/agent-execution-tracker.js";
 /**
@@ -161,6 +162,34 @@ export declare class ResultProcessor {
      * contextUpdated observability log in processResult.
      */
     isObserverEvent(event: Event): boolean;
+    /**
+     * RESEARCH_CLUSTER_COST_FIX_PLAN F5 — was the cluster journal actually
+     * written during this `routine.research_cluster_update` run?
+     *
+     * Detection is the on-disk journal file itself — the authoritative,
+     * path-specific, backend-agnostic signal. The daemon writes the journal
+     * via the context-API chokepoint (`writeFileAtomically`), so the file's
+     * mtime reflects the real write time; a write that landed inside the run
+     * window (`[min(event enqueue, now − durationMs) − buffer, now]`) proves
+     * the agent executed the append rather than narrating success.
+     *
+     * Why not the `context_write` audit row (the plan's first idea): that
+     * row is emitted only inside `notifyPromptContextChanged`, which fires
+     * solely for prompt-refreshing paths (`shouldRefreshPromptContext`).
+     * `research/*` is intentionally a *quiet* namespace — it never triggers
+     * a refresh — so a research write records **no** `context_write` row.
+     * (The plan's §1 "zero context_write rows ⇒ zero writes" inference was
+     * therefore unsound for this namespace; the on-disk check has none of
+     * that coupling.) F1 guarantees ≤ 1 cluster_update run/cluster/day, so
+     * the run window cannot collide with another run writing the same file;
+     * the sibling research flows write *different* files
+     * (`<slug>-assistance-<date>.md`, `<slug>-wiki.md`), never `<slug>.md`.
+     *
+     * Returns `true` (treat as written — do NOT downgrade) when the slug is
+     * absent/invalid or the stat fails for any reason other than ENOENT: a
+     * verification fault must never relabel a genuinely-successful run.
+     */
+    private researchClusterJournalWritten;
     /**
      * Confirm that a `wiki.ingest_url` session actually wrote a raw note via
      * the Wiki API before letting the agent's claimed success DM reach the
@@ -185,3 +214,7 @@ export declare class ResultProcessor {
      */
     private verifyWikiIngestWriteOrRewrite;
 }
+export declare function readTaskDeliveryRecord(event: Event): {
+    notificationType: ProactiveForwardType;
+    metadata: Record<string, unknown>;
+} | null;