@aitne/daemon 0.1.7 → 0.1.9

package/dist/core/dispatcher-scheduled-tasks.js

@@ -50,11 +50,20 @@ import { randomUUID } from "node:crypto";
 import { CONTEXT_RELATIVE_PATHS } from "./context-paths.js";
 import { getContextDir } from "../config.js";
 import { cleanupSessionWorkdir, ensureBackendMaterialized, } from "./workdir.js";
-import { readIntegrations } from "../db/integrations-store.js";
+import { readIntegrations, readIntegrationState } from "../db/integrations-store.js";
+import { refreshInterestsReflection } from "../services/browser-history/refresh-interests-reflection.js";
+import { InterestsReflectionLockBusyError } from "../services/browser-history/interests-reflection-lock.js";
+import { findSectionLineBounds } from "./roadmap-validate.js";
+import { writeFileAtomically } from "./atomic-write.js";
+import { serializeContextFileWrite } from "./context-file-serializer.js";
 import { getRepository, getRepositoryByLocalPath, recordManagementInitDone, recordManagementScan, } from "../db/repositories-store.js";
 import { runRepositoryManagementInit, runRepositoryManagementScan, } from "./repository-management-docs.js";
 import { routineWindowKeyFromEvent } from "./routine-fetch-window-runner.js";
 import { routineHasWindows } from "./routine-windows.js";
+import { morningRoutineRanToday } from "../bootstrap/schedule-helpers.js";
+import { resolveAgentId } from "./agents/agent-id-resolver.js";
+import { loadEffectiveDefinition } from "./agents/effective-definition.js";
+import { getAgent } from "../db/agents-store.js";
 import { releaseWikiCompileLock } from "./wiki/compile-lock.js";
 import { parseGithubRepoSlug, normalizeRepositoryClassification, normalizeRepositoryCategory, parseRepositoryRunTaskContext, repositoryRunInstructionFilename, safeRepositoryRunDirName, } from "./dispatcher-repository-helpers.js";
 import { createLogger } from "../logging.js";
@@ -263,11 +272,25 @@ export class ScheduledTaskRunner {
         return lines.join("\n");
     }
     prepareRepositoryRunSessionDir(ctx, backendId) {
+        // docs/design/appendices/skills-improvement.md §9-§11 + §14 / `evening-review-slimdown.md`
+        // §3.5 — even though `scheduled.task`'s static manifest carries no
+        // per-event predicate today, thread `contextDir`, `db`, and an
+        // explicit `messageText = null` so this path stays symmetric with
+        // every other materialise site (dispatcher-message-handler,
+        // backend-core fresh sessions, index.ts fallback callback). Future
+        // predicates added for `scheduled.task` will receive the correct
+        // inputs without revisiting this file; threading `null` for
+        // `messageText` documents the contract — repository runs never
+        // surface inbound DM text — so a `*ForDm` predicate added later
+        // will degrade cleanly to its base branch instead of silently
+        // reading from `undefined`.
+        const contextDir = getContextDir(this.config, this.db);
         if (ctx.workdirMode === "local-clone") {
             if (!ctx.localPath) {
                 throw new Error("Repository local-clone run missing localPath");
             }
-            ensureBackendMaterialized(this.config.workspaceDir, ctx.localPath, backendId, "scheduled.task", "agent.task", this.getConfiguredServices(), this.getActiveMailAccounts(), readIntegrations(this.db), this.config.character);
+            ensureBackendMaterialized(this.config.workspaceDir, ctx.localPath, backendId, "scheduled.task", "agent.task", this.getConfiguredServices(), this.getActiveMailAccounts(), readIntegrations(this.db), this.config.character, undefined, // wikiWorkspaceName — repository runs are not wiki tasks
+            contextDir, this.db, null);
             return { sessionDir: ctx.localPath, cleanup: false };
         }
         if (!ctx.instructionMd) {
@@ -276,7 +299,7 @@ export class ScheduledTaskRunner {
         const sessionDir = join(this.config.dataDir, "run", `${safeRepositoryRunDirName(ctx.slug)}-${Date.now()}-${randomUUID().slice(0, 8)}`);
         mkdirSync(sessionDir, { recursive: true, mode: 0o700 });
         try {
-            ensureBackendMaterialized(this.config.workspaceDir, sessionDir, backendId, "scheduled.task", "agent.task", this.getConfiguredServices(), this.getActiveMailAccounts(), readIntegrations(this.db), this.config.character);
+            ensureBackendMaterialized(this.config.workspaceDir, sessionDir, backendId, "scheduled.task", "agent.task", this.getConfiguredServices(), this.getActiveMailAccounts(), readIntegrations(this.db), this.config.character, undefined, contextDir, this.db, null);
             writeFileSync(join(sessionDir, repositoryRunInstructionFilename(backendId)), ctx.instructionMd, "utf-8");
             return { sessionDir, cleanup: true };
         }
@@ -288,15 +311,29 @@ export class ScheduledTaskRunner {
     async executeRepositoryRunTask(event, ctx) {
         const context = await this.contextBuilder.build(event);
         const processKey = "agent.task";
-        const requestedTier = event.requestedModel
-            ? (event.requestedModel === "sonnet" ? "medium" : "high")
-            : undefined;
-        const internalBackendOverride = event.requestedBackendId
-            && isBackendId(event.requestedBackendId)
-            && typeof event.requestedModelId === "string"
+        // Tier override > model-derived tier > undefined (resolve via
+        // process-key default = medium). agent_schedule.tier_override is
+        // the primary cost-pinning surface; the legacy `model` column
+        // stays as an Opus/Sonnet escape hatch for callers that still
+        // want a concrete Claude model.
+        const requestedTier = event.requestedTier
+            ?? (event.requestedModel
+                ? (event.requestedModel === "sonnet" ? "medium" : "high")
+                : undefined);
+        // Forward the backend pin carried by the scheduled-row event. A
+        // `requestedModelId` companion is honored when present (exact model
+        // pin) but is NOT required: a standalone `requestedBackendId`
+        // (engine-only Agent pin) routes to that backend via resolveBinding's
+        // backend-only branch, which fills the model from `requestedTier` / the
+        // backend default. Before 2026-06-01 the `typeof requestedModelId ===
+        // "string"` co-guard silently dropped engine-only pins
+        // (AGENT_DEFINITIONS_KNOWN_LIMITATIONS §1).
+        const internalBackendOverride = event.requestedBackendId && isBackendId(event.requestedBackendId)
             ? {
                 requestedBackendId: event.requestedBackendId,
-                requestedModelId: event.requestedModelId,
+                ...(typeof event.requestedModelId === "string"
+                    ? { requestedModelId: event.requestedModelId }
+                    : {}),
             }
             : {};
         const binding = this.agentRouter.resolveBinding(event, {
@@ -370,15 +407,26 @@ export class ScheduledTaskRunner {
             : null;
         const processKey = (processKeyOverride ?? resolveProcessKey(event));
         const promptKey = processKeyOverride ?? event.type;
-        const requestedTier = event.requestedModel
-            ? (event.requestedModel === "sonnet" ? "medium" : "high")
-            : undefined;
-        const internalBackendOverride = event.requestedBackendId
-            && isBackendId(event.requestedBackendId)
-            && typeof event.requestedModelId === "string"
+        // Tier override > model-derived tier > undefined (see
+        // executeRepositoryRunTask for the precedence rationale).
+        const requestedTier = event.requestedTier
+            ?? (event.requestedModel
+                ? (event.requestedModel === "sonnet" ? "medium" : "high")
+                : undefined);
+        // Forward the backend pin carried by the scheduled-row event. A
+        // `requestedModelId` companion is honored when present (exact model
+        // pin) but is NOT required: a standalone `requestedBackendId`
+        // (engine-only Agent pin) routes to that backend via resolveBinding's
+        // backend-only branch, which fills the model from `requestedTier` / the
+        // backend default. Before 2026-06-01 the `typeof requestedModelId ===
+        // "string"` co-guard silently dropped engine-only pins
+        // (AGENT_DEFINITIONS_KNOWN_LIMITATIONS §1).
+        const internalBackendOverride = event.requestedBackendId && isBackendId(event.requestedBackendId)
             ? {
                 requestedBackendId: event.requestedBackendId,
-                requestedModelId: event.requestedModelId,
+                ...(typeof event.requestedModelId === "string"
+                    ? { requestedModelId: event.requestedModelId }
+                    : {}),
             }
             : {};
         const binding = this.agentRouter.resolveBinding(event, {
@@ -406,6 +454,11 @@ export class ScheduledTaskRunner {
             this.markScheduledTaskCompleted(event);
             return;
         }
+        // AGENT_DEFINITIONS_DESIGN.md §4.2 — fold the firing Agent's
+        // `tools.skills` onto the process-key skill bundle. `undefined` for every
+        // non-Agent firing (managed task, git project doc, automation trigger) and
+        // for Agents declaring no extra skills, so the common path is unchanged.
+        const agentSkillOverride = this.resolveAgentSkillOverride(taskCtx);
         const result = await this.errorRouter.executeWithRetry(() => this.agentRouter.execute({
             prompt,
             context,
@@ -417,9 +470,62 @@ export class ScheduledTaskRunner {
             ...(refreshArchitectureOverride
                 ? { allowedToolsOverride: refreshArchitectureOverride }
                 : {}),
+            ...(agentSkillOverride
+                ? {
+                    extraSkills: agentSkillOverride.extraSkills,
+                    skillsReplace: agentSkillOverride.skillsReplace,
+                }
+                : {}),
         }), event);
         await this.resultProcessor.processResult(result, event);
     }
+    /**
+     * AGENT_DEFINITIONS_DESIGN.md §4.2 — resolve the firing Agent's
+     * `tools.skills` override for a `scheduled.task` firing.
+     *
+     * Returns `undefined` for every firing that is NOT a user Agent run, and for
+     * Agents that declare no extra skills, so the common dispatch path stays a
+     * pure no-op. Only firings carrying a stamped `task_context.agent_id` (§7.2)
+     * or a `recurring_schedule_id` that joins an Agent row resolve a slug —
+     * built-in routines (which manage skills via the process-key manifest, not
+     * `tools.skills`) and legacy/managed/automation tasks fall through to
+     * `null`. The effective definition is re-read from the Agent's `agent.md` on
+     * disk, so a live `tools.skills` edit takes effect on the next firing.
+     */
+    resolveAgentSkillOverride(taskCtx) {
+        const ctx = taskCtx && typeof taskCtx === "object"
+            ? taskCtx
+            : {};
+        const agentId = resolveAgentId(this.db, {
+            taskContextAgentId: typeof ctx.agent_id === "string" ? ctx.agent_id : null,
+            recurringScheduleId: typeof ctx.recurringScheduleId === "number"
+                ? ctx.recurringScheduleId
+                : null,
+        });
+        if (!agentId)
+            return undefined;
+        const dto = getAgent(this.db, agentId);
+        if (!dto)
+            return undefined;
+        const { definition } = loadEffectiveDefinition(dto, {
+            readFile: (path) => {
+                try {
+                    return existsSync(path) ? readFileSync(path, "utf-8") : null;
+                }
+                catch {
+                    return null;
+                }
+            },
+            dayBoundaryHour: this.config.dayBoundaryHour ?? 4,
+        });
+        const skills = definition?.tools.skills ?? [];
+        if (skills.length === 0)
+            return undefined;
+        return {
+            extraSkills: skills,
+            skillsReplace: definition?.tools.skills_replace ?? false,
+        };
+    }
     /**
      * Legacy git project documentation tasks used to run as autonomous Claude
      * task-flows. That made file creation probabilistic: the backend could
@@ -642,6 +748,7 @@ export class ScheduledTaskRunner {
             }),
             routine,
             ...(event.requestedModel ? { requestedModel: event.requestedModel } : {}),
+            ...(event.requestedTier ? { requestedTier: event.requestedTier } : {}),
         };
         try {
             await this.executeDefault(routineEvent);
@@ -681,12 +788,38 @@ export class ScheduledTaskRunner {
      */
     async handleMorningRoutineRetry(event, taskCtx) {
         const retryCount = Number(taskCtx.retryCount ?? 0);
-        // O1: early skip only when the current agent day's today.md already exists
-        if (this.hasCurrentAgentDayTodayMd()) {
+        // O1 + 2026-05-14 stall-loop fix: skip ONLY when both signals agree
+        // that the morning routine has genuinely completed for the current
+        // agent-day:
+        //   (a) today.md exists with the expected H1 date, AND
+        //   (b) `agent_actions.result='success'` for `routine.morning_routine`
+        //       within the current agent-day window.
+        //
+        // The original implementation skipped on (a) alone, which created a
+        // silent stall loop in two real scenarios:
+        //   - the daemon crashes between the today.md write and the audit
+        //     row insert (today.md is fresh, audit row is missing);
+        //   - the user manually edits today.md to the current date (CLAUDE.md
+        //     calls this out as a documented edit path).
+        // In both, the hourly_check pre-routine gate (`morningRoutineRanToday`)
+        // would keep refusing to run because the audit row is absent, the
+        // pre-routine gate kept enqueuing wake rows, and each wake row was
+        // fast-path completed here — never producing the audit row that would
+        // break the loop. The morning-routine stall watchdog could not catch
+        // it either because the wake rows transitioned to `completed` before
+        // the watchdog's pending/running window.
+        //
+        // Requiring both signals means a missing audit row falls through to
+        // the actual retry path, which performs the work that produces the
+        // audit row and unblocks the autonomous routines. The lock-acquire
+        // step still guards against concurrent retries.
+        const todayMdFresh = this.hasCurrentAgentDayTodayMd();
+        const auditRowPresent = morningRoutineRanToday(this.db, this.config);
+        if (todayMdFresh && auditRowPresent) {
             logger.info({
                 retryCount,
                 originalCorrelationId: taskCtx.originalCorrelationId,
-            }, "Morning routine retry skipped — today.md already exists (cron likely raced us)");
+            }, "Morning routine retry skipped — today.md fresh and morning_routine audit row present (cron likely raced us)");
             if (event.scheduleId) {
                 this.db
                     .prepare("UPDATE agent_schedule SET status = 'completed' WHERE id = ? AND status = 'running'")
@@ -694,6 +827,12 @@ export class ScheduledTaskRunner {
             }
             return;
         }
+        if (todayMdFresh && !auditRowPresent) {
+            logger.warn({
+                retryCount,
+                originalCorrelationId: taskCtx.originalCorrelationId,
+            }, "Morning routine retry proceeding even though today.md exists — morning_routine audit row missing for current agent-day (recovers from the 2026-05-14 silent-stall failure mode)");
+        }
         // Synthesize a RoutineEvent for executeMorningRoutine. event.data.retryCount
         // carries the previous attempt so executeMorningRoutine → scheduleMorningRetry
         // can increment properly. correlationId tracks back to the original
@@ -743,7 +882,7 @@ export class ScheduledTaskRunner {
      * failure modes (process crash vs. format-confusion bug).
      */
     diagnoseTodayMdState() {
-        const todayPath = join(getContextDir(this.config, this.db), "today.md");
+        const todayPath = join(getContextDir(this.config, this.db), CONTEXT_RELATIVE_PATHS.today);
         if (!existsSync(todayPath)) {
             return { kind: "missing" };
         }
@@ -768,7 +907,7 @@ export class ScheduledTaskRunner {
      */
     rotateDayFiles() {
         const contextDir = getContextDir(this.config, this.db);
-        const todayPath = join(contextDir, "today.md");
+        const todayPath = join(contextDir, CONTEXT_RELATIVE_PATHS.today);
         if (!existsSync(todayPath))
             return;
         const content = readFileSync(todayPath, "utf-8");
@@ -787,7 +926,7 @@ export class ScheduledTaskRunner {
         try {
             this.db
                 .prepare("INSERT INTO md_file_snapshots (file_path, content, trigger) VALUES (?, ?, ?)")
-                .run("today", content, "day_rotation");
+                .run("state/today", content, "day_rotation");
         }
         catch (err) {
             logger.warn({ err }, "Failed to save rotation snapshot");
@@ -920,7 +1059,7 @@ export class ScheduledTaskRunner {
             ? event.data?.workspace
             : undefined;
         try {
-            // ROUTINE_DATA_ACQUISITION_DESIGN.md Phase 4 / D4 — pre-pass for
+            // docs/design/appendices/routine-data-acquisition.md Phase 4 / D4 — pre-pass for
             // routine events whose ProcessKey appears in `ROUTINE_WINDOWS`
             // (today_refresh, evening_review, weekly_review). The hourly_check
             // and morning_routine dispatch paths attach their own
@@ -946,15 +1085,34 @@ export class ScheduledTaskRunner {
                     };
                 }
             }
+            // WEEKLY_INTERESTS_REFLECTION_PLAN.md §10.4 — deterministic
+            // pre-hook for `routine.weekly_review`. Runs synchronously
+            // BEFORE `contextBuilder.build` so the freshly-refreshed
+            // `## Current research themes (auto)` block lands in the
+            // session's `<user>` injection. Failure-isolated: a throw
+            // here is caught (`appendWeeklyInterestsJournalLine`) and the
+            // user-facing weekly artifact still ships. Skip when the
+            // upstream `browser-history` integration is disabled, mirroring
+            // the F1 / F2 / F4 gate.
+            if (isRoutineEvent(effectiveEvent)
+                && effectiveEvent.routine === "weekly_review") {
+                this.runWeeklyInterestsReflectionPreHook(effectiveEvent);
+            }
             const context = await this.contextBuilder.build(effectiveEvent);
             const processKey = resolveProcessKey(effectiveEvent);
             // Honour run-now's `requestedModel` hint for routine events. Other event
             // types (messages, scheduled.task) have their own dedicated paths that
             // already handle tier selection, so this branch is routine-only.
-            const routineHint = isRoutineEvent(effectiveEvent) && effectiveEvent.requestedModel
-                ? effectiveEvent.requestedModel === "opus"
-                    ? "high"
-                    : "medium"
+            // `requestedTier` (set by the today_refresh fast-path forwarder) wins
+            // when present so the caller's abstract tier choice isn't downgraded
+            // through the binary sonnet/opus → medium/high mapping.
+            const routineHint = isRoutineEvent(effectiveEvent)
+                ? (effectiveEvent.requestedTier
+                    ?? (effectiveEvent.requestedModel
+                        ? effectiveEvent.requestedModel === "opus"
+                            ? "high"
+                            : "medium"
+                        : undefined))
                 : undefined;
             // Knowledge-import events carry the dashboard form's backend/model
             // pick. Honor the (backendId, modelId) pair only when the event was
@@ -1028,5 +1186,270 @@ export class ScheduledTaskRunner {
     static formatScheduledFor(date) {
         return formatSqliteDatetime(date);
     }
+    /**
+     * WEEKLY_INTERESTS_REFLECTION_PLAN.md §10.4 pre-hook.
+     *
+     * Synchronous and failure-isolated. The only side-effect the caller
+     * cares about is the freshly-refreshed `context/identity/profile.md`
+     * block — which `contextBuilder.build` (called immediately after
+     * this method returns) picks up via its normal read path. Every
+     * branch below routes through a try/catch so a throw cannot abort
+     * the user-facing weekly artifact.
+     *
+     * Three terminal states:
+     *
+     *   - `browser_history` mode is `disabled` → no-op (with a journal
+     *     line for traceability so an operator wondering "why didn't the
+     *     reflection run this week?" finds the answer in
+     *     `journal/agent.md` rather than having to greppling
+     *     `agent_actions`).
+     *   - The helper returns `{ skipped }` → journal line + audit row
+     *     already emitted by the helper.
+     *   - The helper throws → log + journal line. Audit row may or may
+     *     not have been written depending on how far the helper got;
+     *     the journal line is the defensive trace.
+     */
+    runWeeklyInterestsReflectionPreHook(event) {
+        try {
+            const browserHistory = readIntegrationState(this.db, "browser_history");
+            const integrationDisabled = browserHistory.mode === "disabled";
+            // Pass `this.db` so degraded-Obsidian-mode falls back to the
+            // internal `~/.personal-agent/context/` — the rest of this file
+            // (lines 424, 698, 725, 1107, 1135) follows the same convention;
+            // without the db argument the pre-hook would write into the
+            // user's Obsidian vault even when the daemon has decided to skip
+            // it, leaving the LLM's contextBuilder reading from a different
+            // location than the writer wrote to.
+            const contextDir = getContextDir(this.config, this.db);
+            const boundary = {
+                timezone: this.config.timezone ? this.config.timezone : undefined,
+                dayBoundaryHour: this.config.dayBoundaryHour ?? 4,
+            };
+            // rev 4 — the disabled gate is now enforced INSIDE the helper
+            // (via `integrationDisabled`) so the audit-row shape is uniform
+            // across both skip reasons. The helper short-circuits without
+            // taking the lock or touching disk; it still emits the audit
+            // row + returns `{ skipped: { reason: "no_browser_history" } }`.
+            const result = refreshInterestsReflection(this.db, contextDir, {
+                trigger: "scheduler",
+                boundary,
+                integrationDisabled,
+                // Thread the agent-write tracker so each write the helper does
+                // to user/profile.md, user/research-themes.md, user/_index.md,
+                // and projects/*.md is attributed to the agent by FS-watch
+                // consumers (the context-index reconciler chain + future
+                // observers). Without this thread the chokidar `change` events
+                // would be classified as user edits and feed into the hourly-
+                // check pending floor as if the user had typed them.
+                writeTracker: this.writeTracker,
+                // `correlationId` is the routine event's identifier in the
+                // bus; thread it as `event_id` on the audit row so the
+                // dashboard's audit log can join the reflection trace to the
+                // triggering weekly_review event.
+                eventId: event.correlationId,
+            });
+            if (result.skipped) {
+                this.appendWeeklyInterestsJournalLine(`interest reflection skipped: ${result.skipped.reason} (weekStart=${result.weekStart})`);
+            }
+            else {
+                logger.info({
+                    correlationId: event.correlationId,
+                    weekStart: result.weekStart,
+                    targetsWritten: result.targetsWritten.length,
+                    themesSelected: result.themesSelected.length,
+                    projectsAnnotated: result.projectsAnnotated,
+                }, "Weekly interests reflection pre-hook completed");
+            }
+        }
+        catch (err) {
+            // Catch-all: never propagate up to `executeDefault` — the user-
+            // facing weekly artifact must still ship. Lock contention is a
+            // distinct, expected failure mode (e.g. the dashboard's
+            // "Refresh now" button is mid-flight when the scheduler tick
+            // fires) so we tag it separately for operator clarity.
+            if (err instanceof InterestsReflectionLockBusyError) {
+                logger.warn({ err, correlationId: event.correlationId }, "Weekly interests reflection pre-hook hit lock contention — yielding to in-flight run");
+                this.appendWeeklyInterestsJournalLine(`interest reflection deferred: lock busy (${err.heldBy})`);
+                return;
+            }
+            logger.error({ err, correlationId: event.correlationId }, "Weekly interests reflection pre-hook threw — continuing to LLM session");
+            const message = err instanceof Error ? err.message : String(err);
+            this.appendWeeklyInterestsJournalLine(`interest reflection failed: ${message}`);
+        }
+    }
+    /**
+     * Append a single bullet under `## Weekly interests reflection`
+     * inside `context/journal/agent.md`, creating the section (and the
+     * file) when absent. Mirrors the `appendToJournalSection` pattern
+     * `roadmap-maintenance.ts` uses for its own one-liner trace; kept
+     * inline here because the section header is feature-specific and
+     * the helper has zero call sites outside this module.
+     *
+     * Best-effort: any FS failure is logged and swallowed.
+     */
+    appendWeeklyInterestsJournalLine(message) {
+        // Same `this.db` thread-through as the pre-hook — keep the
+        // journal write in the same file tree the reflection writes to.
+        const contextDir = getContextDir(this.config, this.db);
+        const journalPath = join(contextDir, CONTEXT_RELATIVE_PATHS.agent.journal);
+        const now = new Date();
+        const tz = this.config.timezone ? this.config.timezone : undefined;
+        const dayStr = getAgentDayDateStr(tz, this.config.dayBoundaryHour ?? 4, now);
+        const hm = formatJournalTime(now, tz);
+        const bullet = `- ${dayStr} ${hm}: ${message}`;
+        // Fire-and-forget through the per-path serializer so the read AND
+        // the write run inside the daemon-wide write fence on
+        // `journal/agent.md`. Mirrors the roadmap-maintenance journal-line
+        // appender — without the fence, two concurrent journal appenders
+        // (this one, the morning routine, or an HTTP PATCH) would read the
+        // same pre-state and the loser's bullet would be silently dropped.
+        //
+        // The journal line is a best-effort trace — never fail the pre-hook
+        // on a journal write hiccup. The structured log is sufficient for
+        // daemon-log triage.
+        void serializeContextFileWrite(journalPath, () => {
+            const original = existsSync(journalPath)
+                ? readFileSync(journalPath, "utf-8")
+                : null;
+            // Thread `now.getTime()` so the 30-day retention window cuts
+            // deterministically against the same instant the bullet's date
+            // prefix was computed from — without it, prune would default to
+            // `Date.now()` and a long-running test (or a slow disk) could
+            // see the two diverge across the read/append boundary.
+            const next = appendToWeeklyInterestsJournalSection(original, bullet, now.getTime());
+            // The agent-write tracker must see the new content BEFORE the
+            // rename so a downstream FS-watch consumer attributes the
+            // resulting event to the agent (and not to the user). The same
+            // mark-then-write-then-unmark-on-failure dance the roadmap-
+            // maintenance journal appender uses.
+            this.writeTracker?.markWriting(journalPath, next);
+            try {
+                writeFileAtomically(journalPath, next);
+            }
+            catch (writeErr) {
+                this.writeTracker?.unmark(journalPath);
+                throw writeErr;
+            }
+        }).catch((err) => {
+            logger.error({ err }, "Failed to append weekly interests journal line");
+        });
+    }
+}
+const WEEKLY_INTERESTS_JOURNAL_SECTION = "## Weekly interests reflection";
+/**
+ * rev 4 — monthly retention window for the `## Weekly interests
+ * reflection` section. Bullets whose date prefix is older than this
+ * window get pruned on the next append. At the weekly cadence the
+ * pre-hook fires, this caps the section at ~4-5 entries.
+ *
+ * Rationale: `context/journal/agent.md` is the operator-facing trace
+ * for "why didn't my reflection fire?" type questions. Six months of
+ * weekly skip/success lines is noise — the load-bearing detail is
+ * "did it work this month and last?", which a 30-day window captures
+ * comfortably. Lines older than that live in git history if needed.
+ */
+const WEEKLY_INTERESTS_JOURNAL_RETENTION_DAYS = 30;
+/**
+ * Match the date prefix our journal bullets carry — `- YYYY-MM-DD HH:MM:`
+ * — and capture the date component. Lines that don't match (e.g. a
+ * user-authored note inside the section) are left untouched by the
+ * rotation pass; only daemon-emitted bullets get pruned.
+ */
+const JOURNAL_BULLET_DATE_RE = /^- (\d{4}-\d{2}-\d{2})\s/;
+/**
+ * Drop bullets whose date prefix is older than `retentionDays` days
+ * before `nowMs`. Pure of FS/DB; exported for tests.
+ *
+ * Lines that aren't recognisable as daemon-emitted bullets (no
+ * `- YYYY-MM-DD` prefix) are preserved as-is — the rotation only
+ * targets entries we created, never user prose someone may have
+ * dropped into the section by hand.
+ */
+export function pruneWeeklyInterestsJournalBullets(lines, bodyStart, bodyEnd, nowMs, retentionDays = WEEKLY_INTERESTS_JOURNAL_RETENTION_DAYS) {
+    const cutoffMs = nowMs - retentionDays * 24 * 60 * 60 * 1000;
+    const kept = [];
+    for (let i = bodyStart; i < bodyEnd; i++) {
+        const line = lines[i];
+        const match = JOURNAL_BULLET_DATE_RE.exec(line);
+        if (!match) {
+            kept.push(line);
+            continue;
+        }
+        // Anchor at noon UTC so a DST flip in the host's local zone
+        // cannot move the parsed date into the day before/after.
+        const dateMs = Date.parse(`${match[1]}T12:00:00Z`);
+        if (Number.isNaN(dateMs) || dateMs >= cutoffMs) {
+            kept.push(line);
+        }
+    }
+    return [...lines.slice(0, bodyStart), ...kept, ...lines.slice(bodyEnd)];
+}
+/**
+ * Append `bullet` to the `## Weekly interests reflection` section of
+ * an agent-journal file, creating section + skeleton when absent.
+ * Also prunes bullets older than the retention window (rev 4 — see
+ * `WEEKLY_INTERESTS_JOURNAL_RETENTION_DAYS`).
+ *
+ * The function is pure of FS / DB — exported only for tests.
+ */
+export function appendToWeeklyInterestsJournalSection(original, bullet, nowMs = Date.now()) {
+    if (original === null) {
+        return `# Agent journal\n\n${WEEKLY_INTERESTS_JOURNAL_SECTION}\n\n${bullet}\n`;
+    }
+    const lines = original.split("\n");
+    const bounds = findSectionLineBounds(lines, "Weekly interests reflection");
+    if (bounds) {
+        // Prune first so the section contains only the last `RETENTION_DAYS`
+        // worth of entries BEFORE we compute the insertion point — without
+        // this, a long-stale bullet at the end would push the new bullet
+        // into a section that's about to lose half its content.
+        const pruned = pruneWeeklyInterestsJournalBullets(lines, bounds.bodyStart, bounds.bodyEnd, nowMs);
+        // Re-resolve bounds after pruning — bodyEnd shifted by the
+        // delta. Section header position is unchanged so re-using
+        // bodyStart is safe; we recompute bodyEnd as the old end minus
+        // the number of lines we dropped.
+        const removedCount = lines.length - pruned.length;
+        const newBodyStart = bounds.bodyStart;
+        const newBodyEnd = bounds.bodyEnd - removedCount;
+        let insertAt = newBodyEnd;
+        while (insertAt > newBodyStart && pruned[insertAt - 1].trim() === "") {
+            insertAt -= 1;
+        }
+        const next = [
+            ...pruned.slice(0, insertAt),
+            bullet,
+            ...pruned.slice(insertAt),
+        ];
+        let out = next.join("\n");
+        if (!out.endsWith("\n"))
+            out += "\n";
+        return out;
+    }
+    const trimmed = original.replace(/\n+$/, "");
+    return `${trimmed}\n\n${WEEKLY_INTERESTS_JOURNAL_SECTION}\n\n${bullet}\n`;
+}
+/**
+ * Local 2-digit "HH:MM". Mirrors `roadmap-maintenance.ts:formatHm`
+ * (which is module-private) without re-exporting from there — the
+ * roadmap helper has the same posture (best-effort wall-clock for a
+ * journal bullet) but lives in a feature-specific module.
+ */
+function formatJournalTime(now, timezone) {
+    if (!timezone) {
+        return (`${String(now.getHours()).padStart(2, "0")}:`
+            + `${String(now.getMinutes()).padStart(2, "0")}`);
+    }
+    const fmt = new Intl.DateTimeFormat("en-US", {
+        timeZone: timezone,
+        hour: "2-digit",
+        minute: "2-digit",
+        hour12: false,
+    });
+    const parts = fmt.formatToParts(now);
+    const hh = parts.find((p) => p.type === "hour")?.value ?? "00";
+    const mm = parts.find((p) => p.type === "minute")?.value ?? "00";
+    // Intl can emit "24" for midnight in some locales — guard so the
+    // journal line is stable regardless of host locale.
+    const normalizedHh = hh === "24" ? "00" : hh;
+    return `${normalizedHh}:${mm}`;
 }
-//# sourceMappingURL=dispatcher-scheduled-tasks.js.map