@aitne/daemon 0.1.8 → 0.1.10

package/dist/core/dispatcher-types.d.ts

@@ -223,6 +223,38 @@ export interface IMessageRecorder {
         notificationDispatchId?: string | null;
     }): boolean;
 }
+/**
+ * `agent_actions.detail.dailyWrite` shape — see
+ * `docs/design/appendices/daily-journal-daemon-write.md` §4.3.
+ *
+ * Persisted on the Stage B (`routine.morning_routine_journal`) row both
+ * on the success path (`audit.logAction(.., dailyWrite)`) and on the
+ * failure path (`audit.logError(.., { dailyWrite })`) so downstream
+ * readers — `agent-journal-appender.formatJournalLine`, the §4.7b
+ * partial-extract streak detector — can branch on `detail.dailyWrite.ok`
+ * for a single source of truth.
+ *
+ * Discriminated union on `ok`:
+ *   - `"complete"` — both XML blocks extracted, frontmatter parsed,
+ *     daily file written.
+ *   - `"partial"` — body extracted but frontmatter parsing failed; the
+ *     daily file IS on disk with empty projects/people/tags arrays.
+ *     `partialReason` identifies which sub-shape failed.
+ *   - `false` — no daily file written. `reason` identifies why.
+ */
+export type DailyWriteAuditDetail = {
+    ok: "complete";
+    bytesWritten: number;
+    wroteMode: "put" | "append_revision";
+} | {
+    ok: "partial";
+    bytesWritten: number;
+    wroteMode: "put" | "append_revision";
+    partialReason: "frontmatter_tag_missing" | "frontmatter_invalid_json" | "frontmatter_schema_invalid";
+} | {
+    ok: false;
+    reason: "stage_b_null" | "empty_output" | "body_tag_missing" | "write_failed";
+};
 /** Interface for AuditLogger — implemented in Phase 1D */
 export interface IAuditLogger {
     logAction(params: {
@@ -318,6 +350,22 @@ export interface IAuditLogger {
              */
             requestedBackend?: BackendId;
         };
+        /**
+         * docs/design/appendices/daily-journal-daemon-write.md §4.11 — daily
+         * journal compose outcome for `routine.morning_routine_journal`
+         * (Stage B) rows. The orchestrator threads it through
+         * `persistStageAuditRows` so `detail.dailyWrite` lands on the same
+         * INSERT/UPSERT as the row's terminal `result` — no post-UPDATE
+         * needed. `agent-journal-appender.formatJournalLine` reads
+         * `detail.dailyWrite.ok` to render the "complete" / "partial" /
+         * "failed" verbs without grepping the fs.
+         *
+         * Shape mirrors `DailyJournalComposeResult` — we copy it inline
+         * rather than importing the morning module to keep audit decoupled
+         * from the morning pipeline's import graph (audit is at the bottom
+         * of the dep stack).
+         */
+        dailyWrite?: DailyWriteAuditDetail | null;
     }): void;
     logSkip(event: Event, reason: string, trigger: "reactive" | "autonomous"): void;
     logError(event: Event, error: Error, trigger: "reactive" | "autonomous", context?: {
@@ -352,6 +400,14 @@ export interface IAuditLogger {
             fallbackTriggered?: boolean;
             requestedBackend?: BackendId;
         };
+        /**
+         * See `logAction.dailyWrite` JSDoc. Mirrored on the failure path
+         * so a Stage B `recordStageFailure` row also carries the
+         * dailyWrite outcome — useful for the §4.7b streak detector when
+         * Stage B's session threw but a prior attempt's daily file is on
+         * disk.
+         */
+        dailyWrite?: DailyWriteAuditDetail | null;
     }): void;
     /**
      * Chat-attachments Phase 1 — log an inbound (user→agent) or outbound
@@ -480,4 +536,3 @@ export interface InFlightExecutionInfo {
     taskType?: string;
     detail?: string;
 }
-//# sourceMappingURL=dispatcher-types.d.ts.map

package/dist/core/dispatcher-types.js

@@ -103,4 +103,3 @@ export function parseStage2Verdict(output) {
         return action;
     return "failed";
 }
-//# sourceMappingURL=dispatcher-types.js.map

package/dist/core/dispatcher.d.ts

@@ -11,11 +11,12 @@ 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 { 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 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 TriggerHourlyCheckSkipReason, type SetupMode, type TriggerHourlyCheckOptions, type TriggerHourlyCheckResult, type InFlightExecutionInfo } from "./dispatcher-types.js";
 export { parseStage2Verdict, };
-export type { ReplyActivityHandle, IDashboardStream, IContextBuilder, GetTaskFlow, INotificationManager, ISessionManager, IMessageRecorder, IAuditLogger, BangCommandDetail, TriggerHourlyCheckSkipReason, SetupMode, TriggerHourlyCheckOptions, TriggerHourlyCheckResult, InFlightExecutionInfo, };
+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";
 import { SKILL_CURATION_OPTIMIZER_ALLOWED_TOOLS } from "./dispatcher-scheduled-tasks.js";
 export { SKILL_CURATION_OPTIMIZER_ALLOWED_TOOLS };
@@ -61,6 +62,45 @@ export declare class EventDispatcher {
      * Spec: docs/design/backlog/messaging-bang-commands.md
      */
     private bangCommandRegistry;
+    /**
+     * Phase B-4 — DM-issued purchase confirmation handler. Wired at
+     * daemon startup from `index.ts` via `setPurchaseHandler`. Null
+     * when B-4 is not enabled at startup; the dispatcher's inbound
+     * classifier no-ops in that case and the workflow runner refuses
+     * `variant: "purchase"` calls with `purchase_b4_disabled`.
+     *
+     * Spec: MANAGED_CHROMIUM_IMPLEMENTATION_PLAN.md §17 / §13 step 50.
+     */
+    private purchaseHandler;
+    /**
+     * BROWSER_TASK_REDESIGN_PLAN.md §5 / §14.11 — lite-final-confirm
+     * handler. Wired at daemon startup from `bootstrap/event-pipeline.ts`
+     * via `setFinalConfirmHandler`. The inbound classifier (§14.11 Q#6)
+     * routes `!~xxxxxxxx` replies between this handler and
+     * `purchaseHandler` by querying both stores via `lookupByRaw` and
+     * dispatching to whichever returned a row.
+     */
+    private finalConfirmHandler;
+    /**
+     * BROWSER_TASK_REDESIGN_PLAN.md §6.2 + §7 — Phase 3 wiring. The
+     * dispatcher routes `scheduled.browser_task` events to the runner.
+     * Wired at daemon startup from `bootstrap/event-pipeline.ts` via
+     * `setBrowserTaskRunner`. Null when the runner factory has not yet
+     * landed (test harness or stripped-down boot path) — the dispatch
+     * branch flips the `agent_schedule` row to `failed
+     * (runner_unavailable)` in that case so the row doesn't park.
+     */
+    private browserTaskRunner;
+    /**
+     * BROWSER_TASK_REDESIGN_PLAN.md §7 — "the user is DMed" on fire-time
+     * dispatch failure (`site_unregistered`, `allowlist_rejected`,
+     * `runner_unavailable`). The runner's own `notifier.notifyTerminal`
+     * only fires when the runner is reached, which is exactly NOT the
+     * case for these pre-runner failure paths. Wired from `event-pipeline.ts`
+     * alongside the runner factory so a fire-time failure DMs the owner
+     * instead of leaving the row silently flipped to `failed` in the DB.
+     */
+    private browserTaskTerminalNotifier;
     /**
      * Current setup mode — scope-agnostic flag that survives internal
      * direct-message session refresh (day boundary, stale flag, etc). Previously this
@@ -189,6 +229,16 @@ export declare class EventDispatcher {
      * carried on the default `event` SSE channel.
      */
     private eventBroadcaster;
+    /**
+     * AGENT_DEFINITIONS_DESIGN.md §8 — per-firing execution recorder. Wired
+     * post-construction via {@link setAgentExecutionTracker} (the recorder +
+     * contextDir + SSE deps only exist after the event-pipeline factory runs).
+     * `null` in tests / pre-wire → no execution rows are written, preserving the
+     * legacy dispatch shape. The ResultProcessor reaches it through a call-time
+     * closure (see the constructor's `recordExecutionOutcome` dep) so it stays
+     * live even though the tracker is set after the processor is built.
+     */
+    private agentExecutionTracker;
     /**
      * Notify-dedup tracking — set of correlationIds for in-flight events
      * that have already invoked `POST /api/notify` from inside the agent
@@ -295,6 +345,43 @@ export declare class EventDispatcher {
     private loadPersistedSetupMode;
     /** Set the SignalDetector for implicit feedback collection from user messages. */
     setSignalDetector(detector: SignalDetector): void;
+    /**
+     * Wire the B-4 purchase-confirmation handler. Called once at startup
+     * from `index.ts` after the messaging hub is up — the handler's
+     * `sender` dependency requires a live MessageHub for outbound DMs.
+     * Calling more than once replaces the prior reference (used by the
+     * dashboard's "Disable B-4" flow which can later re-enable).
+     */
+    setPurchaseHandler(handler: import("../services/browser-history/automation/purchase-handler.js").PurchaseHandler | null): void;
+    /** Read accessor — used by the route layer's wiring to thread the
+     *  same instance into `ApiDependencies.purchaseHandler` without a
+     *  parallel construction path. */
+    getPurchaseHandler(): import("../services/browser-history/automation/purchase-handler.js").PurchaseHandler | null;
+    /**
+     * BROWSER_TASK_REDESIGN_PLAN.md §5 / §14.11 — wire the lite-final-
+     * confirm handler. Mirrors `setPurchaseHandler` so the inbound `!~`
+     * classifier and the route layer share one instance via the
+     * dispatcher.
+     */
+    setFinalConfirmHandler(handler: import("../services/browser-history/automation/final-confirm-handler.js").FinalConfirmHandler | null): void;
+    getFinalConfirmHandler(): import("../services/browser-history/automation/final-confirm-handler.js").FinalConfirmHandler | null;
+    /**
+     * BROWSER_TASK_REDESIGN_PLAN.md §6.2 + §7 — wire the browser-task
+     * runner so the `scheduled.browser_task` dispatch branch can hand
+     * fire-time events to it. Pairs with the `event-pipeline.ts`
+     * `createBrowserTaskRunner` factory call (Phase 3).
+     */
+    setBrowserTaskRunner(runner: import("../services/browser-task/browser-task-runner.js").BrowserTaskRunner | null): void;
+    getBrowserTaskRunner(): import("../services/browser-task/browser-task-runner.js").BrowserTaskRunner | null;
+    /**
+     * BROWSER_TASK_REDESIGN_PLAN.md §7 — wire the terminal-state DM
+     * emitter used by the `scheduled.browser_task` failure paths (see
+     * `browserTaskTerminalNotifier` field doc). `event-pipeline.ts` passes
+     * the same `BrowserTaskNotifier` instance that's threaded into the
+     * runner so a single DM-emission contract covers both pre-runner
+     * fire-time failures and the runner's own non-completed terminals.
+     */
+    setBrowserTaskTerminalNotifier(notifier: import("../services/browser-task/browser-task-runner.js").BrowserTaskNotifier | null): void;
     /** Set the dashboard stream adapter for real-time response streaming. */
     setDashboardStream(adapter: IDashboardStream): void;
     /**
@@ -346,6 +433,21 @@ export declare class EventDispatcher {
     setEventBroadcaster(broadcaster: {
         broadcastEvent: (data: unknown) => void;
     } | null): void;
+    /**
+     * Wire the per-firing execution tracker (AGENT_DEFINITIONS_DESIGN.md §8).
+     * Optional — when unset, no `agent_executions` rows are written and dispatch
+     * behaves exactly as before. Set once at boot from the event-pipeline factory.
+     */
+    setAgentExecutionTracker(tracker: AgentExecutionTracker): void;
+    /**
+     * 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
+     * records an execution. Reactive DMs resolve to no Agent (no routine / no
+     * schedule row / no `task_context.agent_id`) and are a near-free no-op.
+     */
+    private beginAgentExecution;
+    /** Classify an execution's trigger for the rollup row (§5.2). */
+    private resolveExecutionTrigger;
     /**
      * Internal helper: broadcast `routine_started` or `routine_completed` for
      * the given routine event. Centralised so the JSON shape and failure
@@ -428,7 +530,7 @@ export declare class EventDispatcher {
      * scheduled wake tasks, startup catchup, calendar-poller reactive events).
      *
      * Two layers:
-     *  - **Cold gate**: `rules/management.md` must exist. Before initial setup
+     *  - **Cold gate**: `policies/management.md` must exist. Before initial setup
      *    there is no policy document, no user/profile.md, no today.md — running
      *    routines would produce garbage AND, crucially, any loud prompt-context
      *    write from such a routine can trigger
@@ -489,8 +591,47 @@ export declare class EventDispatcher {
      * `docs/design/09-safety-cost.md` §9.5.4.
      */
     isMorningRoutineActive(): boolean;
+    /**
+     * Release a claimed `agent_schedule` row back to `pending` when an
+     * autonomous scheduled event is short-circuited before its dispatch
+     * branch can run (setup gate or autonomous cost cap). The ScheduleWatcher
+     * claims the row as `running` and hands the event to the EventBus before
+     * these gates are evaluated, so a silent skip would otherwise leave the
+     * row stuck in `running` forever — blocking both boot recovery (there is
+     * none for stuck `running` schedule rows) and the recurring
+     * `NOT EXISTS(status IN pending/running)` reconcile guard. Reverting to
+     * `pending` (rather than `failed`/`skipped`) is correct because the skip
+     * is transient: once the cost-cap window rolls over or setup completes,
+     * the next ScheduleWatcher tick should re-evaluate and fire the row. This
+     * matches the quiet-hours deferral precedent in the scheduler. The
+     * `WHERE ... status = 'running'` clause keeps it idempotent — a no-op for
+     * non-scheduled events or already-terminal rows.
+     */
+    private releaseClaimedSchedule;
     private dispatchSafe;
     private dispatch;
+    /**
+     * BROWSER_TASK_REDESIGN_PLAN.md §6.2 + §7 — dispatch branch for
+     * `scheduled.browser_task`. Defers the heavy lifting to
+     * `handleScheduledBrowserTask` (validation + row creation + runner
+     * handoff) and translates the discriminated outcome into the
+     * `agent_schedule.status` write so the row lifecycle stays in sync.
+     *
+     * Outcomes map to:
+     *   - `dispatched` / `row_already_exists` → `agent_schedule` row
+     *     `completed` (the dispatch itself succeeded; the `browser_task`
+     *     row's own state machine tracks the long-running outcome).
+     *   - `site_unregistered` / `allowlist_rejected` / `task_context_invalid`
+     *     / `runner_unavailable` → `agent_schedule` row `failed` (the
+     *     dispatch could not proceed).
+     *
+     * A throw escapes upward into the `dispatch()` try/catch, where
+     * `errorRouter.handleError` flips the schedule row to `failed` via
+     * the existing `isScheduledEvent(event) && event.scheduleId` branch
+     * (defence-in-depth — the explicit `failed` writes here cover every
+     * normal-path failure so the error route never has to).
+     */
+    private handleScheduledBrowserTaskDispatch;
     private getMessageExecutionKey;
     private runWithSessionGate;
     /**
@@ -557,4 +698,3 @@ export declare class EventDispatcher {
         bypassDedup?: boolean;
     }): void;
 }
-//# sourceMappingURL=dispatcher.d.ts.map