@aitne/daemon 0.1.8 → 0.1.10

package/dist/core/scheduler.js

@@ -6,9 +6,11 @@ import { cleanupSessionWorkdir, cleanupStaleWorkdirs, getSessionWorkdirPath } fr
 import { discardStalePendingSchedules } from "./schedule-maintenance.js";
 import { createLogger } from "../logging.js";
 import { reconcileRecurringSchedules } from "../db/recurring-schedules.js";
+import { recordAgentFiringBlocked } from "./agents/firing-blocked.js";
 import { getStalledMorningRoutineWake, readMorningRoutineStallThresholdMinutes, } from "../bootstrap/schedule-helpers.js";
 import { readRuntimeState, writeRuntimeState } from "../db/runtime-state.js";
 import { recordProactiveForwardDeliveries } from "./channel-timeline.js";
+import { isInQuietHoursAt, nextQuietHoursEndMs } from "./quiet-hours.js";
 /**
  * Runtime-state key holding the agent-day date string (`YYYY-MM-DD`) on
  * which the watchdog last sent an owner DM about the morning routine
@@ -125,6 +127,19 @@ export const USER_PROFILE_SWEEP_EVENING_CRON_EXPR = "50 17 * * *";
  * `docs/design/appendices/evening-review-slimdown.md` §2.2.
  */
 export const ROADMAP_MAINTENANCE_CRON_EXPR = "45 17 * * *";
+/**
+ * Cron expression for the BROWSER_HISTORY_INTEGRATION_PLAN §5.F2 P4a
+ * pre-morning digest: 60 min before the day boundary, wrapping
+ * backward across midnight (so `dayBoundaryHour = 4` → "0 3 * * *",
+ * `dayBoundaryHour = 0` → "0 23 * * *"). Extracted as a pure helper
+ * so the wrap arithmetic — identical in shape to
+ * `buildUserProfileSweepMorningCronExpr` but at the top of the hour —
+ * is asserted without standing up node-cron in tests.
+ */
+export function buildBrowserHistoryPreMorningDigestCronExpr(dayBoundaryHour) {
+    const hour = (dayBoundaryHour - 1 + 24) % 24;
+    return `0 ${hour} * * *`;
+}
 /**
  * AgentScheduler — manages recurring cron jobs and the DB-driven ScheduleWatcher.
  *
@@ -183,6 +198,20 @@ export class AgentScheduler {
      * agent/journal.md append.
      */
     onRoadmapMaintenance = null;
+    /**
+     * BROWSER_HISTORY_INTEGRATION_PLAN §5.F2 P4a — pre-morning digest
+     * builder. Fires at `dayBoundaryHour − 1` local each night so the
+     * morning Stage B journal reads a static `context/browser/yesterday-<date>.md`
+     * file (pre-warmed) rather than calling `GET /api/browser-history/
+     * yesterday-summary` at 04:00. The callback is deterministic Node
+     * code (no LLM in the path); the scheduler treats it as
+     * fire-and-forget like the roadmap-maintenance and context-index
+     * callbacks above. A failure here logs but never cascades into the
+     * 04:00 morning routine — the journal task-flow has a documented
+     * fallback to the `/api/browser-history/pre-morning-digest/{date}`
+     * endpoint.
+     */
+    onBrowserHistoryPreMorningDigest = null;
     /**
      * Setup gate — returns a skip reason when autonomous work should be
      * paused (initial setup incomplete, or setup conversation active).
@@ -192,6 +221,13 @@ export class AgentScheduler {
      */
     autonomousGate = () => null;
     lastGateBlockLoggedAt = 0;
+    /**
+     * AGENT_DEFINITIONS_DESIGN.md §7.1 — per-built-in enabled gate. Wired from
+     * the Phase-7 boot path via {@link setAgentEnabledCache}; until then (and in
+     * tests that construct a bare scheduler) it is `null` and the gate is a
+     * no-op, so disabling is opt-in and never accidentally stops a routine.
+     */
+    agentEnabledCache = null;
     /**
      * Single source of truth for the ScheduleWatcher's between-poll wake
      * signaling, unifying what was previously a (pollAbort: AbortController
@@ -268,6 +304,18 @@ export class AgentScheduler {
     setRoadmapMaintenanceCallback(fn) {
         this.onRoadmapMaintenance = fn;
     }
+    /**
+     * Register the BROWSER_HISTORY_INTEGRATION_PLAN §5.F2 P4a
+     * pre-morning digest cron callback. Fires at `dayBoundaryHour − 1`
+     * local; the callback is fire-and-forget — it builds the digest
+     * from `browser_visits` / `browser_research_clusters` /
+     * `browser_pending_offers` and writes the markdown + JSON sidecar
+     * into the daemon-owned `context/browser/` directory. Failures
+     * inside the callback log but do not throw outward.
+     */
+    setBrowserHistoryPreMorningDigestCallback(fn) {
+        this.onBrowserHistoryPreMorningDigest = fn;
+    }
     /**
      * Register the autonomous-work gate. Returning null allows autonomous work;
      * any non-null string is treated as a skip reason and surfaced in logs.
@@ -275,6 +323,39 @@ export class AgentScheduler {
     setAutonomousGate(fn) {
         this.autonomousGate = fn;
     }
+    /**
+     * Wire the live built-in enabled cache (AGENT_DEFINITIONS_DESIGN.md §7.1).
+     * The loader watcher + the `PATCH /api/agents/:slug` handler call
+     * `cache.invalidate()` so the next firing re-queries the DB.
+     */
+    setAgentEnabledCache(cache) {
+        this.agentEnabledCache = cache;
+    }
+    /**
+     * Per-built-in enabled gate (§7.1), checked BEFORE `autonomousGate()` in
+     * every built-in routine's cron callback. Returns `true` to proceed; on a
+     * disabled Agent returns `false` and records a throttled `agent.firing_blocked`
+     * audit row (one per agent-day, then `detail.suppressed_count++` — §12.3). It
+     * is placed AFTER each callback's runtime gates (monthly last-day, hourly
+     * interval, skill-curation cadence) so a per-minute hourly tick that is not a
+     * real firing never inflates the suppressed count. A `null` cache (unwired /
+     * tests) always proceeds.
+     */
+    isAgentEnabledForFiring(slug, cronLabel) {
+        if (this.agentEnabledCache === null)
+            return true;
+        if (this.agentEnabledCache.isEnabled(slug))
+            return true;
+        try {
+            const agentDay = getAgentDayDateStr(this.config.timezone || undefined, this.config.dayBoundaryHour, new Date());
+            recordAgentFiringBlocked(this.db, { slug, agentDay, reason: "disabled" });
+        }
+        catch (err) {
+            logger.warn({ err, slug, cron: cronLabel }, "Failed to record agent.firing_blocked");
+        }
+        logger.debug({ slug, cron: cronLabel }, "Agent disabled — routine firing blocked");
+        return false;
+    }
     /** Log gate blocks at most once every 5 minutes to avoid spam. */
     logGateBlock(reason, context) {
         const now = Date.now();
@@ -459,6 +540,8 @@ export class AgentScheduler {
         // Morning Routine: daily at dayBoundaryHour (default 04:00)
         // Order: day boundary callback (DM summarize) → morning routine → cleanup
         const morningJob = cron.schedule(`0 ${this.config.dayBoundaryHour} * * *`, () => {
+            if (!this.isAgentEnabledForFiring("morning-routine", "morning_routine"))
+                return;
             const gateReason = this.autonomousGate();
             if (gateReason !== null) {
                 this.logGateBlock(gateReason, { cron: "morning_routine" });
@@ -480,6 +563,8 @@ export class AgentScheduler {
         this.cronJobs.push(morningJob);
         // Evening Review: daily at 18:00
         const eveningJob = cron.schedule("0 18 * * *", () => {
+            if (!this.isAgentEnabledForFiring("evening-review", "evening_review"))
+                return;
             const gateReason = this.autonomousGate();
             if (gateReason !== null) {
                 this.logGateBlock(gateReason, { cron: "evening_review" });
@@ -494,6 +579,8 @@ export class AgentScheduler {
         // user/profile.md when it loads <user>. See USER-PROFILE-CAPTURE-PLAN.md
         // §Phase 2.
         const sweepMorningJob = cron.schedule(buildUserProfileSweepMorningCronExpr(this.config.dayBoundaryHour), () => {
+            if (!this.isAgentEnabledForFiring("user-profile-sweep-morning", "user_profile_sweep_morning"))
+                return;
             const gateReason = this.autonomousGate();
             if (gateReason !== null) {
                 this.logGateBlock(gateReason, { cron: "user_profile_sweep_morning" });
@@ -507,6 +594,8 @@ export class AgentScheduler {
         // * * *". If Evening Review ever becomes time-configurable, this
         // cron must track the same config knob in lockstep.
         const sweepEveningJob = cron.schedule(USER_PROFILE_SWEEP_EVENING_CRON_EXPR, () => {
+            if (!this.isAgentEnabledForFiring("user-profile-sweep-evening", "user_profile_sweep_evening"))
+                return;
             const gateReason = this.autonomousGate();
             if (gateReason !== null) {
                 this.logGateBlock(gateReason, { cron: "user_profile_sweep_evening" });
@@ -526,6 +615,8 @@ export class AgentScheduler {
         // maintenance on the very days the operator needs roadmap.md to
         // stay clean.
         const roadmapMaintenanceJob = cron.schedule(ROADMAP_MAINTENANCE_CRON_EXPR, () => {
+            if (!this.isAgentEnabledForFiring("roadmap-maintenance", "roadmap_maintenance"))
+                return;
             const gateReason = this.autonomousGate();
             if (gateReason !== null) {
                 this.logGateBlock(gateReason, { cron: "roadmap_maintenance" });
@@ -542,6 +633,8 @@ export class AgentScheduler {
         // Weekly Review: Friday at 19:00 (one hour after evening_review)
         // Emits a separate routine event so the prompt can generate weekly/YYYY-Www.md
         const weeklyJob = cron.schedule("0 19 * * 5", () => {
+            if (!this.isAgentEnabledForFiring("weekly-review", "weekly_review"))
+                return;
             const gateReason = this.autonomousGate();
             if (gateReason !== null) {
                 this.logGateBlock(gateReason, { cron: "weekly_review" });
@@ -570,6 +663,8 @@ export class AgentScheduler {
             tomorrow.setDate(tomorrow.getDate() + 1);
             const tomorrowLocal = nowInTimezone(tz, tomorrow);
             if (tomorrowLocal.day === 1) {
+                if (!this.isAgentEnabledForFiring("monthly-review", "monthly_review"))
+                    return;
                 const gateReason = this.autonomousGate();
                 if (gateReason !== null) {
                     this.logGateBlock(gateReason, { cron: "monthly_review" });
@@ -587,6 +682,8 @@ export class AgentScheduler {
         const reconcilerHour = (this.config.dayBoundaryHour + 23) % 24;
         const reconcilerCron = `45 ${reconcilerHour} * * *`;
         const reconcilerJob = cron.schedule(reconcilerCron, () => {
+            if (!this.isAgentEnabledForFiring("context-index-reconcile", "context_index_reconcile"))
+                return;
             const gateReason = this.autonomousGate();
             if (gateReason !== null) {
                 this.logGateBlock(gateReason, { cron: "context_index_reconcile" });
@@ -600,6 +697,34 @@ export class AgentScheduler {
             }
         }, { timezone: tz });
         this.cronJobs.push(reconcilerJob);
+        // BROWSER_HISTORY_INTEGRATION_PLAN §5.F2 Stage 1 — pre-morning
+        // digest at `dayBoundaryHour − 1` (default 03:00 when
+        // `dayBoundaryHour=4`). Same hour as the context-index reconciler
+        // above (03:45) but at :00 instead of :45 so the digest's snapshot
+        // is taken BEFORE the reconciler nudges the prompt context — the
+        // morning routine's task-flow then sees both the reconciled index
+        // AND the freshly-written digest in its first turn.
+        //
+        // Gated by `autonomousGate` like every other autonomous cron;
+        // setup-incomplete + setup-active states pause the build.
+        // Fire-and-forget: the callback handles its own failure logging
+        // (see `safeRunPreMorningDigestJob`), and any uncaught throw lands
+        // in the local catch block here rather than escaping the cron.
+        const browserDigestCron = buildBrowserHistoryPreMorningDigestCronExpr(this.config.dayBoundaryHour);
+        const browserDigestJob = cron.schedule(browserDigestCron, () => {
+            const gateReason = this.autonomousGate();
+            if (gateReason !== null) {
+                this.logGateBlock(gateReason, { cron: "browser_history_pre_morning_digest" });
+                return;
+            }
+            try {
+                this.onBrowserHistoryPreMorningDigest?.();
+            }
+            catch (err) {
+                logger.warn({ err }, "browser-history pre-morning digest callback threw");
+            }
+        }, { timezone: tz });
+        this.cronJobs.push(browserDigestJob);
         if (this.config.hourlyCheckEnabled) {
             const hourlyExpr = buildHourlyCronExpr(this.config.hourlyCheckIntervalMinutes, this.config.hourlyCheckActiveStartHour, this.config.hourlyCheckActiveEndHour);
             const hourlyJob = cron.schedule(hourlyExpr, () => {
@@ -622,6 +747,10 @@ export class AgentScheduler {
                 if (!shouldFireHourlyTickAt(local.hours, local.minutes, this.config.hourlyCheckIntervalMinutes, this.config.hourlyCheckActiveStartHour)) {
                     return;
                 }
+                // Per-built-in enabled gate, AFTER the interval gate so a
+                // per-minute non-firing tick never inflates the suppressed count.
+                if (!this.isAgentEnabledForFiring("hourly-check", "hourly_check"))
+                    return;
                 // triggerHourlyCheck has its own setup gate, but short-circuit
                 // here to avoid the in-progress flag toggling for no reason.
                 const gateReason = this.autonomousGate();
@@ -674,6 +803,8 @@ export class AgentScheduler {
                     logger.debug({ cadence }, "skill_curation cadence interval not elapsed yet");
                     return;
                 }
+                if (!this.isAgentEnabledForFiring("skill-curation", "skill_curation"))
+                    return;
                 const gateReason = this.autonomousGate();
                 if (gateReason !== null) {
                     this.logGateBlock(gateReason, { cron: "skill_curation" });
@@ -783,11 +914,15 @@ export class AgentScheduler {
                     .run(JSON.stringify(mergedContext), scheduledFor, existing.id);
                 return { inserted: false, existingId: existing.id };
             }
+            const morningInstruction = "Morning routine. Generate today.md and register the day schedule.";
             this.db
                 .prepare(`INSERT INTO agent_schedule
-             (scheduled_for, task_type, task_description, task_context, correlation_id, model, status)
-           VALUES (?, 'wake', ?, ?, ?, NULL, 'pending')`)
-                .run(scheduledFor, "Morning routine. Generate today.md and register the day schedule.", taskContext, wakeEvent.correlationId);
+             (scheduled_for, task_type, task_description, task_prompt, task_context, correlation_id, model, status)
+           VALUES (?, 'wake', ?, ?, ?, ?, NULL, 'pending')`)
+                .run(scheduledFor, 
+            // task_description (list label) doubles as task_prompt (agent
+            // instruction) for this system-generated row.
+            morningInstruction, morningInstruction, taskContext, wakeEvent.correlationId);
             return { inserted: true };
         });
         const result = insertTxn();
@@ -876,9 +1011,11 @@ export class AgentScheduler {
                                 });
                                 const event = {
                                     ...base,
-                                    // task_prompt overrides task_description as the agent body
-                                    // when set; falls back to the description otherwise.
-                                    task: row.task_prompt ?? row.task_description,
+                                    // task_prompt is the agent body. Every insert site sets it
+                                    // (and a backfill migration filled legacy rows), so the old
+                                    // `?? task_description` fallback is gone; `?? ""` is only a
+                                    // null-type guard that never fires in practice.
+                                    task: row.task_prompt ?? "",
                                     taskContext: JSON.parse(row.task_context ?? "{}"),
                                     correlationId: row.correlation_id ?? base.correlationId,
                                     scheduleId: row.id,
@@ -890,28 +1027,130 @@ export class AgentScheduler {
                                     ...(isProcessTier(row.tier_override)
                                         ? { requestedTier: row.tier_override }
                                         : {}),
-                                    // `agent_schedule.model` is operator-supplied. Three
-                                    // resolution branches (SCHEDULE_API_REDESIGN_PLAN §4.3a):
+                                    // `agent_schedule.model` is operator-supplied. Four
+                                    // resolution branches (SCHEDULE_API_REDESIGN_PLAN §4.3a;
+                                    // branch 3 added 2026-06-01 —
+                                    // AGENT_DEFINITIONS_KNOWN_LIMITATIONS §1):
                                     //   1. legacy alias 'sonnet' / 'opus' → `requestedModel`
                                     //   2. registered model id paired with backend_id →
                                     //      emit BOTH `requestedBackendId` and
                                     //      `requestedModelId` so the dispatcher's override
-                                    //      block (which guards on both fields together)
-                                    //      actually fires. Without the backend companion the
-                                    //      pin is silently dropped.
-                                    //   3. model present but backend_id NULL (legacy rows or
+                                    //      block fires with an exact model pin.
+                                    //   3. backend_id WITHOUT a model → emit
+                                    //      `requestedBackendId` alone. resolveBinding's
+                                    //      backend-only branch resolves the model from the
+                                    //      row's tier / the backend default, so an engine-only
+                                    //      pin ("run this on codex") routes to that engine
+                                    //      instead of being silently dropped.
+                                    //   4. model present but backend_id NULL (legacy rows or
                                     //      pure-tier rows) → fall through to no-override so
                                     //      the row resolves via process-key defaults.
                                     ...(row.model === "sonnet" || row.model === "opus"
                                         ? { requestedModel: row.model }
                                         : row.model && row.backend_id && isBackendId(row.backend_id)
                                             ? { requestedBackendId: row.backend_id, requestedModelId: row.model }
-                                            : {}),
+                                            : row.backend_id && isBackendId(row.backend_id)
+                                                ? { requestedBackendId: row.backend_id }
+                                                : {}),
                                 };
                                 await this.eventBus.put(event);
                                 logger.info({ taskId: row.id, taskType: row.task_type }, "Scheduled DM session dispatched");
                                 continue;
                             }
+                            // BROWSER_TASK_REDESIGN_PLAN.md §6.2 + §12 Q#5 — open-ended
+                            // browser sub-agent firing at its scheduled time. The body
+                            // of the original POST lives in `task_context` (frozen at
+                            // schedule time); the dispatcher's `scheduled.browser_task`
+                            // handler is responsible for creating the `browser_task`
+                            // row at fire time and handing off to the runner.
+                            //
+                            // Quiet-hours deferral: when `browserTaskRespectQuietHours`
+                            // is true (default) and the current wall-clock instant is
+                            // inside the configured quiet-hours window, the row is
+                            // pushed forward to the next quiet-hours-end boundary
+                            // instead of being dispatched. One `agent_actions` audit
+                            // row is written per deferral so the user can see the
+                            // delay; the row's status is reverted to `pending` so
+                            // the next ScheduleWatcher tick re-evaluates.
+                            if (row.task_type === "browser_task") {
+                                const fireAt = new Date();
+                                const respectQuietHours = this.config.browserTaskRespectQuietHours !== false;
+                                if (respectQuietHours) {
+                                    const quietHoursWindow = {
+                                        start: this.config.quietHoursStart,
+                                        end: this.config.quietHoursEnd,
+                                        timezone: this.config.timezone || undefined,
+                                    };
+                                    if (isInQuietHoursAt(fireAt, quietHoursWindow)) {
+                                        const deferUntilMs = nextQuietHoursEndMs(fireAt, quietHoursWindow);
+                                        if (deferUntilMs !== null) {
+                                            const deferredFor = formatSqliteDatetime(new Date(deferUntilMs));
+                                            this.db
+                                                .prepare(`UPDATE agent_schedule
+                              SET scheduled_for = ?, status = 'pending'
+                            WHERE id = ?`)
+                                                .run(deferredFor, row.id);
+                                            try {
+                                                this.db
+                                                    .prepare(`INSERT INTO agent_actions
+                               (action_type, detail, result, started_at, completed_at)
+                             VALUES (?, ?, 'success', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)`)
+                                                    .run("browser_task.deferred_for_quiet_hours", JSON.stringify({
+                                                    scheduleId: row.id,
+                                                    originalScheduledFor: row.scheduled_for,
+                                                    deferredUntil: deferredFor,
+                                                    quietHoursStart: this.config.quietHoursStart,
+                                                    quietHoursEnd: this.config.quietHoursEnd,
+                                                }));
+                                            }
+                                            catch (auditErr) {
+                                                /* c8 ignore start -- defensive against schema partials */
+                                                logger.warn({ err: auditErr, scheduleId: row.id }, "Failed to record browser_task.deferred_for_quiet_hours audit");
+                                                /* c8 ignore stop */
+                                            }
+                                            logger.info({
+                                                scheduleId: row.id,
+                                                deferredUntil: deferredFor,
+                                                quietHoursStart: this.config.quietHoursStart,
+                                                quietHoursEnd: this.config.quietHoursEnd,
+                                            }, "scheduled.browser_task deferred for quiet hours");
+                                            continue;
+                                        }
+                                        // `nextQuietHoursEndMs` returning null inside a quiet-
+                                        // hours predicate that just returned true would mean
+                                        // a 24-hour window — the runtime-settings schema
+                                        // disallows this (equal start/end short-circuits the
+                                        // predicate), so it cannot occur in normal operation.
+                                        // Fall through to dispatch rather than re-deferring
+                                        // forever.
+                                    }
+                                }
+                                const base = createEvent({
+                                    type: "scheduled.browser_task",
+                                    source: row.task_type,
+                                    priority: EventPriority.NORMAL,
+                                });
+                                let parsedContext;
+                                try {
+                                    parsedContext = JSON.parse(row.task_context ?? "{}");
+                                }
+                                catch (parseErr) {
+                                    logger.error({ err: parseErr, scheduleId: row.id }, "scheduled.browser_task: task_context JSON parse failed — marking row failed");
+                                    this.db
+                                        .prepare("UPDATE agent_schedule SET status = 'failed' WHERE id = ? AND status = 'running'")
+                                        .run(row.id);
+                                    continue;
+                                }
+                                const event = {
+                                    ...base,
+                                    taskContext: parsedContext,
+                                    correlationId: row.correlation_id ?? base.correlationId,
+                                    scheduleId: row.id,
+                                };
+                                await this.eventBus.put(event);
+                                logger.info({ scheduleId: row.id, taskType: row.task_type }, "Scheduled browser-task dispatched");
+                                continue;
+                            }
                             const base = createEvent({
                                 type: "scheduled.task",
                                 source: row.task_type,
@@ -932,9 +1171,11 @@ export class AgentScheduler {
                                 : undefined;
                             const event = {
                                 ...base,
-                                // task_prompt overrides task_description as the agent body
-                                // when set; falls back to the description otherwise.
-                                task: row.task_prompt ?? row.task_description,
+                                // task_prompt is the agent body. Every insert site sets it
+                                // (and a backfill migration filled legacy rows), so the old
+                                // `?? task_description` fallback is gone; `?? ""` is only a
+                                // null-type guard that never fires in practice.
+                                task: row.task_prompt ?? "",
                                 taskContext: parsedTaskContext,
                                 correlationId: row.correlation_id ?? base.correlationId,
                                 scheduleId: row.id,
@@ -950,14 +1191,18 @@ export class AgentScheduler {
                                     : {}),
                                 // `agent_schedule.model` is operator-supplied. See the
                                 // scheduled.dm branch above (SCHEDULE_API_REDESIGN_PLAN
-                                // §4.3a) for the three resolution branches. Same shape —
-                                // a registered full model id requires the `backend_id`
-                                // companion or it falls through to process-key defaults.
+                                // §4.3a) for the four resolution branches. Same shape — a
+                                // registered full model id pairs with `backend_id`; a
+                                // standalone `backend_id` (no model) emits `requestedBackendId`
+                                // alone (resolveBinding fills the model from tier / default);
+                                // a model with no backend_id falls through to defaults.
                                 ...(row.model === "sonnet" || row.model === "opus"
                                     ? { requestedModel: row.model }
                                     : row.model && row.backend_id && isBackendId(row.backend_id)
                                         ? { requestedBackendId: row.backend_id, requestedModelId: row.model }
-                                        : {}),
+                                        : row.backend_id && isBackendId(row.backend_id)
+                                            ? { requestedBackendId: row.backend_id }
+                                            : {}),
                             };
                             await this.eventBus.put(event);
                             logger.info({ taskId: row.id, taskType: row.task_type }, "Scheduled task dispatched");
@@ -1253,4 +1498,3 @@ function isCadenceIntervalElapsed(db, cadence) {
         return true;
     }
 }
-//# sourceMappingURL=scheduler.js.map

package/dist/core/semaphore.d.ts

@@ -10,4 +10,3 @@ export declare class Semaphore {
     release(): void;
     get available(): number;
 }
-//# sourceMappingURL=semaphore.d.ts.map

package/dist/core/semaphore.js

@@ -28,4 +28,3 @@ export class Semaphore {
         return this.permits;
     }
 }
-//# sourceMappingURL=semaphore.js.map

package/dist/core/session-gate.d.ts

@@ -34,4 +34,3 @@ export declare class SessionGateRegistry {
      *  serialized work to the migration-context endpoint. */
     activeKeys(): IterableIterator<string>;
 }
-//# sourceMappingURL=session-gate.d.ts.map

package/dist/core/session-gate.js

@@ -66,4 +66,3 @@ export class SessionGateRegistry {
         return this.chains.keys();
     }
 }
-//# sourceMappingURL=session-gate.js.map

package/dist/core/session-manager.d.ts

@@ -268,4 +268,3 @@ export declare class SessionManager implements ISessionManager {
     saveDmSummary(platform: string, summary: string, messageCount: number): void;
 }
 export {};
-//# sourceMappingURL=session-manager.d.ts.map

package/dist/core/session-manager.js

@@ -730,4 +730,3 @@ export class SessionManager {
             .run(platform, platform, summary, messageCount);
     }
 }
-//# sourceMappingURL=session-manager.js.map

package/dist/core/signal-detector.d.ts

@@ -1,3 +1,4 @@
+import type Database from "better-sqlite3";
 import type { AgentConfig } from "../config.js";
 /**
  * Raw signal entry that gets appended to user/profile.md ## Raw Signals section.
@@ -12,7 +13,7 @@ interface RawSignal {
  *
  * Detects behavioral patterns from messaging platforms and appends
  * structured entries to user/profile.md's "Raw Signals" section via the
- * Context File API (PATCH /api/context/user/profile).
+ * Context File API (PATCH /api/context/identity/profile).
  *
  * All writes go through the Daemon's own HTTP API to:
  * - Respect the Context File API mutex (no race conditions)
@@ -31,6 +32,7 @@ interface RawSignal {
  */
 export declare class SignalDetector {
     private readonly config;
+    private readonly deps;
     /** Track pending notifications for ignore detection */
     private readonly pendingNotifications;
     /** Rolling dedup cache: signal key → expiry timestamp */
@@ -41,7 +43,9 @@ export declare class SignalDetector {
     private ignoreCheckInterval;
     /** API base URL for Context File API (self-referencing) */
     private readonly apiBaseUrl;
-    constructor(config: AgentConfig);
+    constructor(config: AgentConfig, deps?: {
+        db?: Database.Database;
+    });
     /** Start the signal detector (periodic ignore check) */
     start(): void;
     /** Stop the signal detector */
@@ -67,14 +71,38 @@ export declare class SignalDetector {
      */
     onUserMessage(params: {
         platform: string;
+        channel?: string;
         content: string;
         responseToNotificationId?: string;
     }): void;
+    /**
+     * Record a positive action correlated with a notification. This is the
+     * narrow "acted" path: callers must have an actual task/action observation,
+     * never silence, before invoking it.
+     *
+     * NOTE — intentional Phase-1.5 seam, no production caller yet (by design).
+     * Firing `acted` deterministically needs the notification's subject
+     * `(source, ref)` in `pendingNotifications` to match a later observation,
+     * but that subject never reaches `trackNotification`: entity-related
+     * proactive DMs are re-authored by an agent turn and delivered via
+     * `POST /api/agent/notify`, which carries only message/platform/priority
+     * (no subject), and the direct `NotificationManager.send()` paths carry
+     * `data:{}`. So this stays correct + silence-safe but dormant — do NOT
+     * wire it from a silence- or substring-heuristic source (that re-opens the
+     * sign-inversion the promotion gate exists to kill). The loop is complete
+     * without it (`explicit` + `replied` drive promotion). See
+     * FEEDBACK_LEARNING_LOOP_DESIGN.md §11 v1.9#2 + v1.11.
+     */
+    onNotificationActed(params: {
+        notificationId: string;
+        actionRef?: string;
+        detail?: string;
+    }): void;
     /** Check for messages that have been ignored (no response within threshold) */
     private checkIgnoredMessages;
     /**
      * Append a raw signal to user/profile.md's "## Raw Signals" section
-     * via the Context File API (PATCH /api/context/user/profile).
+     * via the Context File API (PATCH /api/context/identity/profile).
      *
      * Uses the Daemon's own HTTP API to ensure:
      * - Write serialization via context mutex
@@ -92,6 +120,15 @@ export declare class SignalDetector {
     static normalizeDedupKey(signal: RawSignal): string;
     /** Remove expired entries from the dedup cache */
     private pruneExpiredDedup;
+    private static isCorrectionContent;
+    private findPendingNotificationForReply;
+    private resolvePendingNotificationId;
+    private lookupNotificationMetadata;
+    private resolveAgentIdForNotification;
+    private recordNotificationOutcome;
+    private updateNotificationReaction;
+    private buildOutcomeSummary;
+    private sanitizeEvidence;
+    private static parseTrackedNotificationId;
 }
 export {};
-//# sourceMappingURL=signal-detector.d.ts.map