@aitne/daemon 0.1.0

package/dist/core/context-builder.js

@@ -0,0 +1,1148 @@
+import { readFile } from "node:fs/promises";
+import { existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { AGENT_ROLE_DESCRIPTOR, APP_NAME, formatAgentOutboundLabel, formatSqliteDatetime, isRoutineEvent, isMessageEvent, isScheduledDmEvent, isScheduledEvent, localDateStr, normalizeAgentDisplayName, nowInTimezone, getAgentDayBoundsUtc, getAgentDayDateStr, parseSqliteUtcMs, } from "@aitne/shared";
+import { getContextDir } from "../config.js";
+import { getDegradedMode } from "../db/runtime-state.js";
+import { readIntegrations } from "../db/integrations-store.js";
+import { CONTEXT_RELATIVE_PATHS } from "./context-paths.js";
+import { OWNER_DM_SCOPE, OWNER_SCOPE_KEY, DASHBOARD_CHAT_SCOPE, DASHBOARD_SCOPE_KEY, getConversationScope, } from "../messaging/constants.js";
+import { getProactiveForwardType, isProactiveForwardMetadata, metadataDispatchIds, parseMessageMetadata, } from "./channel-timeline.js";
+import { createLogger } from "../logging.js";
+import { truncateRoadmap } from "./roadmap-truncate.js";
+import { isIntegrationDelegated } from "./integration-lifecycle.js";
+const logger = createLogger("context-builder");
+const YESTERDAY_AGENT_ACTION_LIMIT = 40;
+const YESTERDAY_MESSAGE_LIMIT = 60;
+const YESTERDAY_DM_LOG_LIMIT = 20;
+export class ContextBuilder {
+    config;
+    db;
+    services;
+    constructor(config, db, services) {
+        this.config = config;
+        this.db = db;
+        this.services = services;
+    }
+    /**
+     * Resolve the readable primary-vault location for prompt construction.
+     *
+     * During degraded mode we intentionally return `null` instead of the
+     * fallback `<dataDir>/context`: reactive sessions may still run so the
+     * user can fix the vault, but they must not see stale context data from
+     * a legacy location.
+     */
+    get readableContextDir() {
+        if (getDegradedMode(this.db)) {
+            return null;
+        }
+        return getContextDir(this.config);
+    }
+    async build(event) {
+        const sections = [];
+        const degradedState = getDegradedMode(this.db);
+        if (degradedState) {
+            sections.push([
+                "<management_mode_degraded>",
+                `- reason: ${degradedState.reason}`,
+                `- path: ${degradedState.path ?? "(unset)"}`,
+                `- since: ${degradedState.since}`,
+                "Primary vault reads are disabled while Management Mode is degraded.",
+                "Context files were intentionally not loaded to avoid serving stale fallback data.",
+                "</management_mode_degraded>",
+            ].join("\n"));
+        }
+        // Always injected (all sessions) — B-007 §5.1 canonical paths.
+        const [userMd, rulesMd, todayMd] = await Promise.all([
+            this.readFile(CONTEXT_RELATIVE_PATHS.user.profile),
+            this.readFile(CONTEXT_RELATIVE_PATHS.rules.management),
+            this.readFile(CONTEXT_RELATIVE_PATHS.today),
+        ]);
+        // Capture the read time as the authoritative "as of when did this
+        // conversation see today.md" anchor. Read-time (not mtime) is what the
+        // freshness contract needs: mtime advances every quiet append from
+        // background routines, but the value that matters here is when THIS
+        // session's snapshot was taken. See STAGE-C-DM-FRESHNESS-PLAN §Task 1.
+        const todayReadAt = todayMd ? new Date().toISOString() : null;
+        if (userMd)
+            sections.push(`<user>\n${userMd}\n</user>`);
+        if (rulesMd)
+            sections.push(`<management_rules>\n${rulesMd}\n</management_rules>`);
+        if (todayMd) {
+            // Truncate ## Agent Log to last N entries for non-evening sessions.
+            // Evening review needs the full log to assess the day.
+            const skipTruncation = isRoutineEvent(event) && event.routine === "evening_review";
+            const injected = skipTruncation
+                ? todayMd
+                : truncateAgentLog(todayMd, 10);
+            sections.push(`<today snapshot_at="${todayReadAt}">\n${injected}\n</today>`);
+        }
+        const agentDisplayName = normalizeAgentDisplayName(typeof event.data.agentDisplayName === "string"
+            ? event.data.agentDisplayName
+            : this.config.agentDisplayName);
+        // Three-axis identity (see packages/shared/src/branding.ts):
+        //   product = the software running this session (rebrand target)
+        //   role    = LLM role anchor (kept stable across rebrands)
+        //   display_name = how the agent signs messages to the operator
+        // Naming each axis explicitly prevents the LLM from conflating brand
+        // with role when the operator renames their instance.
+        sections.push([
+            "<agent_identity>",
+            `- product: ${APP_NAME}`,
+            `- role: ${AGENT_ROLE_DESCRIPTOR} (acting on behalf of the operator)`,
+            `- display_name: ${agentDisplayName}`,
+            `- whatsapp_label: ${formatAgentOutboundLabel(agentDisplayName)}`,
+            "</agent_identity>",
+        ].join("\n"));
+        const now = new Date();
+        const tz = this.config.timezone || undefined;
+        const local = nowInTimezone(tz, now);
+        const localTimeStr = `${local.year}-${String(local.month).padStart(2, "0")}-${String(local.day).padStart(2, "0")} ${String(local.hours).padStart(2, "0")}:${String(local.minutes).padStart(2, "0")}`;
+        const tzLabel = this.config.timezone || "system";
+        sections.push(`<current_time utc="${now.toISOString()}" local="${localTimeStr}" timezone="${tzLabel}" />`);
+        // Agent-day date — explicit, unambiguous date for today.md line 1 and
+        // every "today" reference in skills. The agent-day starts at
+        // `dayBoundaryHour` (default 04:00) in `tzLabel`, so before that boundary
+        // the agent-day date is the previous calendar date. Example: at 02:00
+        // local on 2026-04-28 with boundary_hour=4, agent_day_date is "2026-04-27".
+        // Skills MUST use this attribute (not <current_time>) for any date stamp
+        // written to today.md or roadmap.md so the daemon's
+        // hasCurrentAgentDayTodayMd / rotateDayFiles checks line up with what
+        // the agent writes.
+        const dayBoundaryHour = this.config.dayBoundaryHour ?? 4;
+        const agentDayDateStr = getAgentDayDateStr(tz, dayBoundaryHour, now);
+        const agentDayWeekday = new Date(`${agentDayDateStr}T12:00:00Z`).toLocaleDateString("en-US", {
+            weekday: "long",
+            timeZone: "UTC",
+        });
+        sections.push(`<current_agent_day date="${agentDayDateStr}" weekday="${agentDayWeekday}" boundary_hour="${dayBoundaryHour}" />`);
+        sections.push(`<event_correlation_id>${event.correlationId}</event_correlation_id>`);
+        if (typeof event.data?.todayWriteLockId === "string") {
+            sections.push(`<today_write_lock_id>${event.data.todayWriteLockId}</today_write_lock_id>`);
+        }
+        if (typeof event.data?.roadmapWriteLockId === "string") {
+            sections.push(`<roadmap_write_lock_id>${event.data.roadmapWriteLockId}</roadmap_write_lock_id>`);
+        }
+        // cost-reduction-structural §B — Stage 3 / Stage 2-triage events
+        // arrive with a pre-rendered `<gate_decision>` block from the
+        // dispatcher. Inject verbatim so the routine can branch on the
+        // gate's reason without re-deriving signals.
+        if (event.data?.gateDecision &&
+            typeof event.data.gateDecision === "object" &&
+            typeof event.data.gateDecision.block === "string") {
+            sections.push(event.data.gateDecision.block);
+        }
+        // The <obsidian_vault_path> prompt fragment always points at the EXTERNAL
+        // Obsidian vault (CLI skill target), never the agent's primary vault.
+        // Kept verbatim for skill compatibility even after the field rename.
+        if (this.config.externalObsidianVaultPath) {
+            sections.push(`<obsidian_vault_path>${this.config.externalObsidianVaultPath}</obsidian_vault_path>`);
+        }
+        // B-007 §3 P6 / §5.9 — expose the two setup-wizard answers to every
+        // task-flow so prompts can branch on them without re-reading the DB.
+        // `primary_language` governs user-editable prose language; `vault_mode`
+        // toggles `[[wikilink]]` emission in synthesized content like daily/*.md.
+        const primaryLanguage = this.config.primaryLanguage ?? "en";
+        const vaultMode = this.config.vaultMode ?? "plain";
+        sections.push(`<settings primary_language="${primaryLanguage}" vault_mode="${vaultMode}" />`);
+        // Integration modes — expose the current `direct | delegated | disabled`
+        // state of every registered integration so task-flows can branch without
+        // re-reading the DB or relying on "is this MCP tool in my allowed-tools
+        // list" self-introspection, which is unreliable across backends. For
+        // delegated keys, also emit `<key>_delegated_to="<backend>"` so the
+        // hourly_check delegated variants can pick the cross-backend proxy path
+        // vs the same-backend native MCP path per integration without reading
+        // `~/.personal-agent/integrations.md` themselves
+        // (DELEGATED-MODE-V2-DESIGN.md §5.4).
+        const integrationsSnapshot = readIntegrations(this.db);
+        const integrationAttrs = Object.entries(integrationsSnapshot)
+            .flatMap(([key, state]) => {
+            const attrs = [`${key}="${state.mode}"`];
+            if (state.mode === "delegated" && state.delegatedBackend) {
+                attrs.push(`${key}_delegated_to="${state.delegatedBackend}"`);
+            }
+            return attrs;
+        })
+            .join(" ");
+        sections.push(`<integration_modes ${integrationAttrs} />`);
+        // Routine events: additional context
+        if (isRoutineEvent(event)) {
+            // Silent-by-default protocol: applies uniformly to every routine
+            // event (morning / evening / hourly / weekly / monthly / roadmap /
+            // any future routine). The daemon does NOT forward the agent's
+            // final text as a user notification for routines; POST /api/notify
+            // is the only user-visible channel. Each routine prompt owns its
+            // own go/no-go decision for whether to make that call. Injected
+            // here instead of duplicated per-prompt so new routines inherit
+            // the rule automatically.
+            sections.push([
+                "<routine_protocol>",
+                "This is an autonomous background run. Your final text response",
+                "is an internal agent log — the daemon does not forward it to",
+                "the user. POST /api/notify is the only user-visible channel for",
+                "routine events, so if you don't call it, the user sees nothing.",
+                "Each routine prompt owns the go/no-go decision for whether to",
+                "call /api/notify.",
+                "</routine_protocol>",
+            ].join("\n"));
+            if (event.routine === "morning_routine") {
+                // yesterday.md is created by Dispatcher.rotateDayFiles() before this runs.
+                // It contains the previous day's today.md (with ## Handoff section).
+                const [yesterdayMd, roadmapMd, activeProjects, yesterdaySqlite] = await Promise.all([
+                    this.readFile("yesterday.md"),
+                    this.readFile("roadmap.md"),
+                    this.buildActiveProjectsSection(),
+                    this.buildYesterdaySqliteContext(),
+                ]);
+                if (yesterdayMd)
+                    sections.push(`<yesterday>\n${yesterdayMd}\n</yesterday>`);
+                sections.push(`<yesterday_agent_actions>\n${yesterdaySqlite.agentActions}\n</yesterday_agent_actions>`);
+                sections.push(`<yesterday_messages>\n${yesterdaySqlite.messages}\n</yesterday_messages>`);
+                sections.push(`<yesterday_dm_conversation_log>\n${yesterdaySqlite.dmConversationLog}\n</yesterday_dm_conversation_log>`);
+                if (roadmapMd)
+                    sections.push(`<roadmap>\n${truncateRoadmap(roadmapMd, { timezone: this.config.timezone || undefined })}\n</roadmap>`);
+                if (activeProjects)
+                    sections.push(`<active_projects>\n${activeProjects}\n</active_projects>`);
+                // Fetch 7-day calendar events for today.md / roadmap.md updates.
+                // Delegated mode emits an MCP-fetch directive inside the same block.
+                sections.push(await this.buildCalendarBlock(7, "calendar_events_7d"));
+            }
+            else if (event.routine === "roadmap_refresh") {
+                const [roadmapMd, activeProjects] = await Promise.all([
+                    this.readFile("roadmap.md"),
+                    this.buildActiveProjectsSection(),
+                ]);
+                // Roadmap refresh must see the full file — the session
+                // regenerates `## Agent Action Plan` wholesale, so any entry the
+                // truncator dropped would be erased on PUT. Do NOT truncate here.
+                if (roadmapMd)
+                    sections.push(`<roadmap>\n${roadmapMd}\n</roadmap>`);
+                if (activeProjects)
+                    sections.push(`<active_projects>\n${activeProjects}\n</active_projects>`);
+                // 7-day DM rolling-summary window. RFC-B Phase 1 wants the
+                // refresh to incorporate long-horizon intent captured in recent
+                // DMs; the rolling summaries in dm_conversation_log are the
+                // cheapest source (already AI-condensed by the dispatcher).
+                const dmLog7d = this.buildRecentDmConversationLog(7);
+                sections.push(`<recent_dm_conversation_log days="7">\n${dmLog7d}\n</recent_dm_conversation_log>`);
+                // Signal calendar availability — agent fetches 90-day events itself.
+                // The delegated variant of this task flow bypasses `<calendar_status>`
+                // and goes straight to the backend connector's list_events / search
+                // tool; the delegated branch below keeps the hint informational so
+                // the prompt stays legible when the variant isn't loaded for some
+                // reason (e.g. hot-switch in progress).
+                if (isIntegrationDelegated(this.db, "google_calendar")) {
+                    sections.push(`<calendar_status>Google Calendar is delegated. Use the backend connector's list_events / search tool for the 90-day window — direct /api/calendar/* returns 410.</calendar_status>`);
+                }
+                else if (this.services.calendar?.available) {
+                    sections.push(`<calendar_status>Calendar service available. Use GET /api/calendar/events?date=today&days=90 to fetch events.</calendar_status>`);
+                }
+                else {
+                    sections.push(`<calendar_status>Calendar service not available. Skip calendar-based sections — preserve existing roadmap content.</calendar_status>`);
+                }
+            }
+            else if (event.routine === "evening_review") {
+                const [roadmapMd, activeProjects] = await Promise.all([
+                    this.readFile("roadmap.md"),
+                    this.buildActiveProjectsSection(),
+                ]);
+                if (roadmapMd)
+                    sections.push(`<roadmap>\n${truncateRoadmap(roadmapMd, { timezone: this.config.timezone || undefined })}\n</roadmap>`);
+                if (activeProjects)
+                    sections.push(`<active_projects>\n${activeProjects}\n</active_projects>`);
+                // 3-day calendar look-ahead for evening review. Delegated mode emits
+                // an MCP-fetch directive inside the same block so the flow works
+                // without a routine-specific delegated variant.
+                sections.push(await this.buildCalendarBlock(3, "calendar_events_3d"));
+            }
+            else if (event.routine === "user_profile_sweep") {
+                // Both phases read the same current-agent-day bounds at session
+                // start — the phase flag is preserved for journaling only and
+                // does not branch the window. The guard below exists purely as
+                // a misconfig fuse: if the event arrives without a valid phase
+                // (e.g. a manual trigger that didn't thread `data.phase`), skip
+                // the injection so the task-flow's Step 1 abort path (USER-PROFILE-
+                // CAPTURE-PLAN.md §2.3 Step 1 / §2.4) fires as documented rather
+                // than silently running the sweep with an unlabeled log line.
+                const phase = event.data?.phase;
+                if (phase === "morning" || phase === "evening") {
+                    const agentDayDm = this.buildAgentDayDmContext();
+                    sections.push(`<agent_day_messages>\n${agentDayDm.messages}\n</agent_day_messages>`);
+                    sections.push(`<agent_day_dm_conversation_log>\n${agentDayDm.dmConversationLog}\n</agent_day_dm_conversation_log>`);
+                }
+                else {
+                    logger.warn({ phase, correlationId: event.correlationId }, "user_profile_sweep event missing valid phase — skipping window injection");
+                }
+            }
+            else if (event.routine === "today_refresh") {
+                // Dashboard-triggered manual refresh of today.md's User Schedule
+                // section. The task flow fetches calendar events itself (so the
+                // flow body works uniformly across direct and delegated modes);
+                // this status hint is informational and mainly helps the direct
+                // path distinguish configured-but-unavailable from delegated.
+                if (isIntegrationDelegated(this.db, "google_calendar")) {
+                    sections.push(`<calendar_status>Google Calendar is delegated. Fetch today's events via the backend connector's list_events / search tool — direct /api/calendar/* returns 410.</calendar_status>`);
+                }
+                else if (this.services.calendar?.available) {
+                    sections.push(`<calendar_status>Calendar service available. Use GET /api/calendar/events?date=today&days=1 to fetch today's events.</calendar_status>`);
+                }
+                else {
+                    sections.push(`<calendar_status>Calendar service not available. If direct /api/calendar returns 503 or 410, log and skip the User Schedule rewrite.</calendar_status>`);
+                }
+            }
+            else if (event.routine === "weekly_review" ||
+                event.routine === "monthly_review") {
+                const [roadmapMd, activeProjects] = await Promise.all([
+                    this.readFile("roadmap.md"),
+                    this.buildActiveProjectsSection(),
+                ]);
+                if (roadmapMd)
+                    sections.push(`<roadmap>\n${truncateRoadmap(roadmapMd, { timezone: this.config.timezone || undefined })}\n</roadmap>`);
+                if (activeProjects) {
+                    sections.push(`<active_projects>\n${activeProjects}\n</active_projects>`);
+                }
+                const lookaheadDays = event.routine === "monthly_review" ? 30 : 7;
+                sections.push(await this.buildCalendarBlock(lookaheadDays, `calendar_events_${lookaheadDays}d`));
+            }
+        }
+        // Agent task / DM-tone events: inject live calendar + origin
+        // metadata for informed execution. Both scheduled.task and
+        // scheduled.dm need this — without it, scheduled sessions would
+        // execute "blind" knowing only today.md (which may be stale) and
+        // the task description (which may be terse).
+        if (isScheduledEvent(event)) {
+            // 1-day live calendar — critical for temporal awareness (meetings,
+            // conflicts). Delegated mode emits an MCP-fetch directive inside the
+            // same block.
+            sections.push(await this.buildCalendarBlock(1, "calendar_today"));
+            // Task origin metadata — tells the agent WHO scheduled this
+            sections.push(`<task_origin source="${event.source}" schedule_id="${event.scheduleId ?? "none"}" />`);
+            sections.push(`<task_context>\n${JSON.stringify(event.taskContext ?? {}, null, 2)}\n</task_context>`);
+            // Dashboard regeneration tasks additionally get roadmap + projects
+            // (Calendar data is already embedded in the task description by the API endpoint)
+            if (event.source === "dashboard_regenerate") {
+                const [roadmapMd, activeProjects] = await Promise.all([
+                    this.readFile("roadmap.md"),
+                    this.buildActiveProjectsSection(),
+                ]);
+                if (roadmapMd)
+                    sections.push(`<roadmap>\n${roadmapMd}\n</roadmap>`);
+                if (activeProjects)
+                    sections.push(`<active_projects>\n${activeProjects}\n</active_projects>`);
+            }
+            // SCHEDULED-DM-IMPLEMENTATION-PLAN §3.3 / §5.7 — DM-tone
+            // sessions additionally see the user's recent DM activity and
+            // the rolling owner-DM history so the LLM can detect the
+            // conversation state (asleep vs. active vs. very-recent) and
+            // pick Variant A (greeting) vs. Variant B (mid-conversation
+            // weave) per the scheduled.dm.md task-flow.
+            if (isScheduledDmEvent(event)) {
+                const recentDms = this.buildRecentDmActivityBlock(60);
+                if (recentDms) {
+                    sections.push(`<recent_dm_messages window="60min">\n${recentDms}\n</recent_dm_messages>`);
+                }
+                const dmHistory = this.buildOwnerDmConversationHistory(20);
+                if (dmHistory) {
+                    sections.push(`<recent_dm_conversation>\n${dmHistory}\n</recent_dm_conversation>`);
+                }
+            }
+        }
+        // Message events: include conversation history from the active session.
+        // Cross-session continuity (expired/closed sessions) is handled separately
+        // by the dispatcher's buildCrossSessionConversationHistory(), which injects
+        // history via the backend's conversationHistory parameter. Doing it here
+        // as well would duplicate the data under two different XML tags.
+        if (isMessageEvent(event)) {
+            const history = this.getConversationHistory(event);
+            if (history) {
+                sections.push(`<conversation_history>\n${history}\n</conversation_history>`);
+            }
+            const otherSurface = this.buildRecentOtherSurfaceBlock(event);
+            if (otherSurface) {
+                sections.push(`<recent_other_surface>\n${otherSurface}\n</recent_other_surface>`);
+            }
+        }
+        return sections.join("\n\n");
+    }
+    /**
+     * Compute the calendar lookahead window anchored at the user-timezone
+     * midnight boundary. Shared by direct-mode fetches and the delegated-mode
+     * MCP-fetch directive so both paths describe exactly the same range.
+     */
+    computeCalendarWindow(days) {
+        const tz = this.config.timezone || undefined;
+        const dayBounds = getAgentDayBoundsUtc(tz, 0);
+        const startMs = parseSqliteUtcMs(dayBounds.start);
+        return {
+            timeMin: new Date(startMs).toISOString(),
+            timeMax: new Date(startMs + days * 24 * 60 * 60 * 1000).toISOString(),
+        };
+    }
+    /**
+     * Build a `<calendar_events_…>` context block, honouring Google Calendar
+     * integration mode:
+     *
+     * - **direct + service available** → embed the formatted event list (prior
+     *   behaviour).
+     * - **delegated** → the daemon has no local CalendarService to call. Emit
+     *   a structured directive telling the task-flow agent to fetch the same
+     *   window itself via its backend's Google Calendar MCP tool and treat the
+     *   response as the contents of this block.
+     * - **direct but service broken / disabled** → emit the legacy
+     *   `<calendar_status>` unavailable line so the flow degrades gracefully.
+     *
+     * All callers funnel through this method so the three surfaces
+     * (morning / evening / weekly+monthly and the agent-task path) stay in
+     * lock-step when delegated-mode handling changes.
+     */
+    async buildCalendarBlock(days, blockName) {
+        const integrations = readIntegrations(this.db);
+        const calendarMode = integrations.google_calendar?.mode ?? "disabled";
+        // Delegated mode wins over a live `services.calendar` — if the user
+        // set the integration to delegated, respect that even if Google
+        // credentials are still resident. Using the direct path here would
+        // silently violate the mode invariant and leave the MCP tool surface
+        // (exposed to the session) out of sync with the data surface.
+        if (calendarMode === "delegated") {
+            const { timeMin, timeMax } = this.computeCalendarWindow(days);
+            return [
+                `<${blockName} mode="delegated" timeMin="${timeMin}" timeMax="${timeMax}" days="${days}">`,
+                "Calendar is delegated — see `<integration_modes>`. Fetch this",
+                "window yourself, then treat the returned events as the contents",
+                "of this block for the rest of the task flow. Pick the path by",
+                "your session backend vs `<integration_modes>.google_calendar_delegated_to`:",
+                "",
+                "  Same-backend (delegated_to == your session backend) — use your",
+                "  native Google Calendar MCP tool:",
+                `    Claude: mcp__claude_ai_Google_Calendar__list_events(calendarId="primary", timeMin="${timeMin}", timeMax="${timeMax}", maxResults=50)`,
+                `    Codex:  mcp__codex_apps__google_calendar._search(timeMin="${timeMin}", timeMax="${timeMax}")`,
+                `    Gemini: mcp_google-workspace_calendar.listEvents(timeMin="${timeMin}", timeMax="${timeMax}", maxResults=50)`,
+                "",
+                "  Cross-backend (delegated_to != your session backend) — call the",
+                "  daemon's task-mode endpoint with a natural-language `task` and",
+                "  `outputSchema`, so the configured account is used (your own",
+                "  backend's Google MCP would query the wrong account):",
+                "    curl -s -X POST http://localhost:8321/api/integrations/google_calendar/exec \\",
+                "      -H 'Content-Type: application/json' \\",
+                `      -d '{"task":"List every event on my primary calendar between ${timeMin} and ${timeMax}. Return id, title, start, end, attendees.","outputSchema":{"type":"object","required":["events"],"properties":{"events":{"type":"array","items":{"type":"object","required":["id","title","start","end"]}}}},"maxToolCalls":3,"cacheable":true}'`,
+                "    Do NOT call `/api/calendar/events` (returns 410 in delegated mode).",
+                "",
+                "If the call errors out, log one line to ## Agent Log and proceed",
+                "as if the window were empty. Do NOT emit `(calendar unavailable)`",
+                "as a user-visible marker — that string is reserved for the case",
+                "where the tool itself is missing (mode misconfigured).",
+                `</${blockName}>`,
+            ].join("\n");
+        }
+        if (this.services.calendar) {
+            const section = await this.fetchCalendarEvents(days);
+            if (section !== null)
+                return `<${blockName}>\n${section}\n</${blockName}>`;
+        }
+        // Direct mode with no service (not configured / init failed) or disabled.
+        return `<calendar_status>Calendar service not available. Google Calendar is not configured or failed to initialize.</calendar_status>`;
+    }
+    /**
+     * Fetch calendar events for the next N days and format as markdown.
+     * Groups events by date with day-of-week and Today/Tomorrow labels.
+     * Returns null if CalendarService is not available.
+     */
+    async fetchCalendarEvents(days) {
+        if (!this.services.calendar)
+            return null;
+        try {
+            const { timeMin, timeMax } = this.computeCalendarWindow(days);
+            const events = await this.services.calendar.listEvents(timeMin, timeMax);
+            if (events.length === 0) {
+                return `Calendar connected (Google Calendar). No events found in the next ${days} days.`;
+            }
+            return this.formatCalendarEvents(events, days);
+        }
+        catch (err) {
+            logger.warn({ err }, "Failed to fetch calendar events for context");
+            return null;
+        }
+    }
+    /** Format calendar events grouped by date */
+    formatCalendarEvents(events, days) {
+        const now = new Date();
+        const tz = this.config.timezone || undefined;
+        const todayStr = localDateStr(now, tz);
+        const tomorrow = new Date(now);
+        tomorrow.setDate(tomorrow.getDate() + 1);
+        const tomorrowStr = localDateStr(tomorrow, tz);
+        const dayNames = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+        // Group events by local date in the configured timezone.
+        const byDate = new Map();
+        for (const event of events) {
+            if (!event.start)
+                continue;
+            const dateStr = event.start.length === 10
+                ? event.start
+                : localDateStr(new Date(event.start), tz);
+            const group = byDate.get(dateStr) ?? [];
+            group.push(event);
+            byDate.set(dateStr, group);
+        }
+        const lines = [];
+        // Generate all dates in range
+        for (let i = 0; i < days; i++) {
+            const date = new Date(now);
+            date.setDate(date.getDate() + i);
+            const dateStr = localDateStr(date, tz);
+            const localInfo = nowInTimezone(tz, date);
+            const dayName = dayNames[localInfo.dayOfWeek];
+            let label = "";
+            if (dateStr === todayStr)
+                label = " — Today";
+            else if (dateStr === tomorrowStr)
+                label = " — Tomorrow";
+            lines.push(`## ${dateStr} (${dayName})${label}`);
+            const dayEvents = byDate.get(dateStr);
+            if (!dayEvents || dayEvents.length === 0) {
+                lines.push("- (no events)");
+            }
+            else {
+                for (const event of dayEvents) {
+                    const timeRange = this.formatTimeRange(event);
+                    const summary = event.summary ?? "Untitled";
+                    const locationPart = event.location ? ` @ ${event.location}` : "";
+                    lines.push(`- ${timeRange} ${summary}${locationPart}`);
+                }
+            }
+            lines.push("");
+        }
+        return lines.join("\n").trimEnd();
+    }
+    /** Format event time range as "HH:MM–HH:MM" or "All day" */
+    formatTimeRange(event) {
+        if (!event.start || !event.end)
+            return "All day";
+        // All-day events have date format (YYYY-MM-DD) without time component
+        if (event.start.length === 10)
+            return "All day";
+        const startDate = new Date(event.start);
+        const endDate = new Date(event.end);
+        const startTime = this.formatLocalTime(startDate);
+        const endTime = this.formatLocalTime(endDate);
+        return `${startTime}\u2013${endTime}`;
+    }
+    formatLocalTime(date) {
+        const local = nowInTimezone(this.config.timezone || undefined, date);
+        return `${String(local.hours).padStart(2, "0")}:${String(local.minutes).padStart(2, "0")}`;
+    }
+    /**
+     * SCHEDULED-DM-IMPLEMENTATION-PLAN §5.7 — return inbound owner-DM
+     * messages received in the last `windowMinutes` across BOTH
+     * owner-facing scopes (`owner_dm` for messaging-app DMs and
+     * `dashboard_chat` for the dashboard chat panel), formatted one per
+     * line oldest first. Returns null when there are no messages so the
+     * caller can omit the block entirely.
+     *
+     * The two-scope query mirrors §3.6's gate set: the briefing
+     * serializes behind both surfaces, so the LLM must see both
+     * surfaces when classifying conversation state. A single-scope read
+     * here would mis-classify state as `asleep` whenever the user is
+     * mid-conversation on the OTHER surface — exactly the
+     * voice-mismatch failure the design exists to fix.
+     *
+     * `docs_qa` is intentionally excluded — that surface is research
+     * lookups, not conversation; gating against it would freeze
+     * briefings during long doc-searches.
+     */
+    buildRecentDmActivityBlock(windowMinutes) {
+        const sinceUtc = formatSqliteDatetime(new Date(Date.now() - windowMinutes * 60_000));
+        const rows = this.db
+            .prepare(`SELECT m.role, m.content, m.timestamp
+         FROM messages m
+         JOIN conversation_sessions s ON m.session_id = s.id
+         WHERE s.scope IN (?, ?) AND m.role = 'user' AND m.timestamp >= ?
+         ORDER BY m.timestamp ASC
+         LIMIT 30`)
+            .all(OWNER_DM_SCOPE, DASHBOARD_CHAT_SCOPE, sinceUtc);
+        if (rows.length === 0)
+            return null;
+        return rows
+            .map((r) => `[${r.timestamp}] ${truncateForBlock(r.content, 200)}`)
+            .join("\n");
+    }
+    /**
+     * SCHEDULED-DM-IMPLEMENTATION-PLAN §5.7 — return the last `limit`
+     * owner-facing messages across BOTH `owner_dm` and `dashboard_chat`
+     * scopes (interleaved by timestamp), formatted with role tags. Used
+     * by `<recent_dm_conversation>` for topic awareness in the bridge
+     * phrasing of Variant B briefings.
+     *
+     * Two-scope read — same reasoning as `buildRecentDmActivityBlock`:
+     * the briefing must reconstruct topic context from whichever surface
+     * the user has been using, not just the messaging-app one.
+     */
+    buildOwnerDmConversationHistory(limit) {
+        const rows = this.db
+            .prepare(`SELECT m.role, m.content, m.timestamp, m.metadata
+         FROM messages m
+         JOIN conversation_sessions s ON m.session_id = s.id
+         WHERE (s.scope = ? AND s.scope_key = ?)
+            OR (s.scope = ? AND s.scope_key = ?)
+         ORDER BY m.timestamp DESC, m.id DESC
+         LIMIT ?`)
+            .all(OWNER_DM_SCOPE, OWNER_SCOPE_KEY, DASHBOARD_CHAT_SCOPE, DASHBOARD_SCOPE_KEY, limit);
+        if (rows.length === 0)
+            return null;
+        return rows
+            .reverse()
+            .map((r) => {
+            const forwardSuffix = r.role === "assistant"
+                && isProactiveForwardMetadata(parseMessageMetadata(r.metadata))
+                ? " (forwarded from autonomous run)"
+                : "";
+            return `[${r.timestamp}] [${r.role}]${forwardSuffix}: ${truncateForBlock(r.content, 400)}`;
+        })
+            .join("\n");
+    }
+    getConversationHistory(event) {
+        const maxMessages = this.config.historyInjectionMaxMessages ?? 50;
+        let rows;
+        if (event.isDm) {
+            const { scope, scopeKey } = getConversationScope({
+                platform: event.platform,
+                channel: event.channel,
+                threadId: event.threadId,
+                isDm: true,
+                // Without `intent`, a docs_qa event would query under
+                // `dashboard_chat` and inject chat history into the QA prompt
+                // (or miss its own QA history). Thread it through so each
+                // dashboard scope retrieves only its own conversation.
+                intent: event.intent,
+            });
+            // DM: load the active conversation for the matching DM surface.
+            rows = this.db
+                .prepare(`SELECT
+             m.session_id,
+             m.role,
+             m.content,
+             m.platform,
+             m.timestamp,
+             m.metadata,
+             m.backend,
+             m.model_id,
+             s.backend_session_id
+           FROM messages m
+           JOIN conversation_sessions s ON m.session_id = s.id
+           WHERE s.scope = ? AND s.scope_key = ? AND s.status = 'active'
+           ORDER BY m.timestamp DESC, m.id DESC LIMIT ?`)
+                .all(scope, scopeKey, maxMessages);
+        }
+        else {
+            // Non-DM: query by (platform, channel, thread).
+            // Hard-cap at 20 — threads are short-lived and higher limits risk
+            // injecting stale context from unrelated earlier threads.
+            const threadLimit = Math.min(maxMessages, 20);
+            rows = this.db
+                .prepare(`SELECT
+             m.session_id,
+             m.role,
+             m.content,
+             m.platform,
+             m.timestamp,
+             m.metadata,
+             m.backend,
+             m.model_id,
+             s.backend_session_id
+           FROM messages m
+           JOIN conversation_sessions s ON m.session_id = s.id
+           WHERE s.platform = ? AND s.channel_id = ? AND s.thread_id IS ?
+           ORDER BY m.timestamp DESC, m.id DESC LIMIT ?`)
+                .all(event.platform, event.channel, event.threadId ?? null, threadLimit);
+        }
+        if (rows.length === 0)
+            return null;
+        // Truncate by approximate token budget (1 token ≈ 4 chars).
+        const maxTokens = this.config.historyInjectionMaxTokens ?? 8000;
+        const reversed = rows.reverse();
+        const proactiveRows = [];
+        let tokenBudget = maxTokens * 4; // chars remaining
+        const lines = [];
+        for (const r of reversed) {
+            const metadata = parseMessageMetadata(r.metadata);
+            const isForward = isProactiveForwardMetadata(metadata);
+            const tag = r.backend
+                ? `[${r.timestamp}] [${r.role}/${r.backend}:${r.model_id ?? "?"}]`
+                : `[${r.timestamp}] [${r.role}]`;
+            const forwardSuffix = r.role === "assistant" && isForward
+                ? " (forwarded from autonomous run)"
+                : "";
+            const line = `${tag}${forwardSuffix}: ${r.content}`;
+            tokenBudget -= line.length;
+            if (tokenBudget < 0 && lines.length > 0) {
+                lines.unshift(`[...${reversed.length - lines.length} older messages omitted]`);
+                break;
+            }
+            if (isForward) {
+                proactiveRows.push({
+                    sessionId: r.session_id,
+                    dispatchIds: metadataDispatchIds(metadata),
+                    sessionResumed: r.backend_session_id !== null,
+                });
+            }
+            lines.push(line);
+        }
+        if (proactiveRows.length > 0) {
+            this.logProactiveForwardInjected(proactiveRows);
+        }
+        return lines.join("\n");
+    }
+    buildRecentOtherSurfaceBlock(event) {
+        if (!event.isDm || event.intent === "docs_qa")
+            return null;
+        const windowMinutes = this.config.historyOtherSurfaceWindowMinutes ?? 1440;
+        if (!Number.isFinite(windowMinutes) || windowMinutes <= 0)
+            return null;
+        const { scope } = getConversationScope({
+            platform: event.platform,
+            channel: event.channel,
+            threadId: event.threadId,
+            isDm: true,
+            intent: event.intent,
+        });
+        const other = scope === OWNER_DM_SCOPE
+            ? { scope: DASHBOARD_CHAT_SCOPE, scopeKey: DASHBOARD_SCOPE_KEY }
+            : scope === DASHBOARD_CHAT_SCOPE
+                ? { scope: OWNER_DM_SCOPE, scopeKey: OWNER_SCOPE_KEY }
+                : null;
+        if (!other)
+            return null;
+        const sinceUtc = formatSqliteDatetime(new Date(Date.now() - windowMinutes * 60_000));
+        const rows = this.db
+            .prepare(`SELECT
+           m.role,
+           m.content,
+           m.platform,
+           m.timestamp,
+           m.metadata,
+           s.scope,
+           s.scope_key
+         FROM messages m
+         JOIN conversation_sessions s ON m.session_id = s.id
+         WHERE s.scope = ?
+           AND s.scope_key = ?
+           AND s.status = 'active'
+           AND m.timestamp >= ?
+         ORDER BY m.timestamp ASC, m.id ASC
+         LIMIT 60`)
+            .all(other.scope, other.scopeKey, sinceUtc);
+        if (rows.length === 0)
+            return null;
+        const lines = [];
+        const ordinaryGroups = new Map();
+        for (const row of rows) {
+            const metadata = parseMessageMetadata(row.metadata);
+            const forwardType = getProactiveForwardType(metadata);
+            if (forwardType) {
+                lines.push(`[${row.timestamp}] [${forwardType} → ${row.platform}]: ${row.content}`);
+                continue;
+            }
+            const key = `${row.scope}:${row.scope_key}`;
+            const timestampMs = parseSqliteUtcMs(row.timestamp);
+            const existing = ordinaryGroups.get(key);
+            if (existing) {
+                existing.count += 1;
+                existing.firstMs = Math.min(existing.firstMs, timestampMs);
+                existing.lastMs = Math.max(existing.lastMs, timestampMs);
+            }
+            else {
+                ordinaryGroups.set(key, {
+                    scope: row.scope,
+                    count: 1,
+                    firstMs: timestampMs,
+                    lastMs: timestampMs,
+                });
+            }
+        }
+        for (const group of ordinaryGroups.values()) {
+            const spanMinutes = Math.max(1, Math.ceil((group.lastMs - group.firstMs) / 60_000));
+            lines.push(`(${group.scope}: ${group.count} turns in last ${spanMinutes} minutes)`);
+        }
+        return lines.length > 0 ? lines.join("\n") : null;
+    }
+    logProactiveForwardInjected(rows) {
+        const sessionId = rows[rows.length - 1]?.sessionId;
+        if (sessionId === undefined)
+            return;
+        const dispatchIds = [
+            ...new Set(rows.flatMap((row) => row.dispatchIds)),
+        ];
+        try {
+            this.db
+                .prepare(`INSERT INTO agent_actions (
+             action_type, trigger, result, detail, started_at
+           )
+           VALUES (
+             'proactive_forward_injected',
+             'reactive',
+             'success',
+             ?,
+             CURRENT_TIMESTAMP
+           )`)
+                .run(JSON.stringify({
+                sessionId,
+                dispatchIds,
+                forwardCount: rows.length,
+                sessionResumed: rows.some((row) => row.sessionResumed),
+            }));
+        }
+        catch (err) {
+            logger.warn({ err, sessionId }, "Failed to log proactive forward injection");
+        }
+    }
+    async readFile(relativePath) {
+        const contextDir = this.readableContextDir;
+        if (!contextDir)
+            return null;
+        const fullPath = join(contextDir, relativePath);
+        if (!existsSync(fullPath))
+            return null;
+        try {
+            return await readFile(fullPath, "utf-8");
+        }
+        catch {
+            return null;
+        }
+    }
+    async buildActiveProjectsSection() {
+        const contextDir = this.readableContextDir;
+        if (!contextDir)
+            return null;
+        const projectsDir = join(contextDir, CONTEXT_RELATIVE_PATHS.projects.dir);
+        if (!existsSync(projectsDir))
+            return null;
+        const projectFiles = readdirSync(projectsDir)
+            .filter((name) => name.endsWith(".md"))
+            .filter((name) => !name.startsWith("_"));
+        if (projectFiles.length === 0)
+            return null;
+        const summaries = (await Promise.all(projectFiles.map(async (name) => {
+            const content = await this.readFile(`${CONTEXT_RELATIVE_PATHS.projects.dir}/${name}`);
+            if (!content)
+                return null;
+            return summarizeProjectFile(name, content);
+        })))
+            .filter((summary) => summary !== null)
+            .filter((summary) => summary.state !== "archived");
+        if (summaries.length === 0)
+            return null;
+        summaries.sort((a, b) => {
+            const aUpdated = a.updated ?? "";
+            const bUpdated = b.updated ?? "";
+            if (aUpdated !== bUpdated)
+                return bUpdated.localeCompare(aUpdated);
+            return a.title.localeCompare(b.title);
+        });
+        const lines = ["# Active projects", ""];
+        for (const project of summaries) {
+            const parts = [`state: ${project.state}`];
+            if (project.nextMilestone) {
+                parts.push(`next: ${project.nextMilestone}`);
+            }
+            if (project.due) {
+                parts.push(`due: ${project.due}`);
+            }
+            lines.push(`- ${project.title} (\`${project.slug}\`) — ${parts.join("; ")}`);
+        }
+        return lines.join("\n");
+    }
+    /**
+     * Render a rolling 7-day (or N-day) window of DM conversation-log
+     * summaries for roadmap_refresh. Unlike `buildYesterdaySqliteContext`,
+     * which is anchored to the previous agent-day for journal synthesis,
+     * this window is calendar-rolling — refreshes can trigger at any
+     * time, and the prompt needs whatever recent DM context exists.
+     *
+     * Returns a formatted markdown block; falls back to a "(none)" stub
+     * so the prompt can always cite the tag unconditionally.
+     */
+    buildRecentDmConversationLog(days) {
+        const timezoneLabel = this.config.timezone || "system";
+        const nowMs = Date.now();
+        const startMs = nowMs - days * 24 * 60 * 60 * 1000;
+        const startSqlite = formatSqliteDatetime(new Date(startMs));
+        const endSqlite = formatSqliteDatetime(new Date(nowMs));
+        const total = this.db
+            .prepare(`SELECT COUNT(*) as cnt FROM dm_conversation_log
+           WHERE created_at >= ? AND created_at < ?`)
+            .get(startSqlite, endSqlite).cnt;
+        const rows = this.db
+            .prepare(`SELECT platform, scope, scope_key, summary, message_count, created_at
+           FROM dm_conversation_log
+           WHERE created_at >= ? AND created_at < ?
+           ORDER BY created_at DESC
+           LIMIT ?`)
+            .all(startSqlite, endSqlite, YESTERDAY_DM_LOG_LIMIT).reverse();
+        const lines = [
+            `- Window: last ${days} days`,
+            `- Timezone: ${timezoneLabel}`,
+            `- Rows: ${total}`,
+        ];
+        if (total > rows.length) {
+            lines.push(`- Showing latest ${rows.length} rows only`);
+        }
+        if (rows.length === 0) {
+            lines.push("- (none)");
+            return lines.join("\n");
+        }
+        for (const row of rows) {
+            const scopeKey = row.scope_key && row.scope_key.length > 0 ? `/${row.scope_key}` : "";
+            lines.push(`- ${formatSqliteTimestampForContext(row.created_at, timezoneLabel)} [${row.platform}:${row.scope}${scopeKey}] (${row.message_count} msgs) ${truncateContextText(row.summary, 220)}`);
+        }
+        return lines.join("\n");
+    }
+    async buildYesterdaySqliteContext() {
+        const tz = this.config.timezone || undefined;
+        const dayBoundaryHour = this.config.dayBoundaryHour ?? 4;
+        const previousAgentDayRef = new Date(Date.now() - 24 * 60 * 60 * 1000);
+        const bounds = getAgentDayBoundsUtc(tz, dayBoundaryHour, previousAgentDayRef);
+        const dayLabel = localDateStr(new Date(parseSqliteUtcMs(bounds.start)), tz);
+        const timezoneLabel = this.config.timezone || "system";
+        const agentActionTotal = this.db
+            .prepare(`SELECT COUNT(*) as cnt FROM agent_actions
+           WHERE started_at >= ? AND started_at < ?`)
+            .get(bounds.start, bounds.end).cnt;
+        const agentActionRows = this.db
+            .prepare(`SELECT action_type, trigger, result, started_at, completed_at, error
+           FROM agent_actions
+           WHERE started_at >= ? AND started_at < ?
+           ORDER BY started_at DESC
+           LIMIT ?`)
+            .all(bounds.start, bounds.end, YESTERDAY_AGENT_ACTION_LIMIT).reverse();
+        const messageTotal = this.db
+            .prepare(`SELECT COUNT(*) as cnt FROM messages
+           WHERE timestamp >= ? AND timestamp < ?
+             AND role != 'system'`)
+            .get(bounds.start, bounds.end).cnt;
+        const messageRows = this.db
+            .prepare(`SELECT role, content, platform, timestamp
+           FROM messages
+           WHERE timestamp >= ? AND timestamp < ?
+             AND role != 'system'
+           ORDER BY timestamp DESC
+           LIMIT ?`)
+            .all(bounds.start, bounds.end, YESTERDAY_MESSAGE_LIMIT).reverse();
+        const dmLogTotal = this.db
+            .prepare(`SELECT COUNT(*) as cnt FROM dm_conversation_log
+           WHERE created_at >= ? AND created_at < ?`)
+            .get(bounds.start, bounds.end).cnt;
+        const dmLogRows = this.db
+            .prepare(`SELECT platform, scope, scope_key, summary, message_count, created_at
+           FROM dm_conversation_log
+           WHERE created_at >= ? AND created_at < ?
+           ORDER BY created_at DESC
+           LIMIT ?`)
+            .all(bounds.start, bounds.end, YESTERDAY_DM_LOG_LIMIT).reverse();
+        return {
+            agentActions: formatYesterdayAgentActions(dayLabel, timezoneLabel, agentActionRows, agentActionTotal),
+            messages: formatYesterdayMessages(dayLabel, timezoneLabel, messageRows, messageTotal),
+            dmConversationLog: formatYesterdayDmConversationLog(dayLabel, timezoneLabel, dmLogRows, dmLogTotal),
+        };
+    }
+    /**
+     * Current-agent-day variant of `buildYesterdaySqliteContext` for the
+     * user-profile sweep (§Phase 2). Resolves the day bounds to the
+     * CURRENT agent-day — at 03:50 that window is ~04:00 yesterday →
+     * 03:50 today (the agent-day about to close), and at 17:50 it is
+     * ~04:00 today → 17:50 today. The sweep reads DM traffic + rolling
+     * summaries but not agent_actions (not needed for fact extraction).
+     */
+    buildAgentDayDmContext() {
+        const tz = this.config.timezone || undefined;
+        const dayBoundaryHour = this.config.dayBoundaryHour ?? 4;
+        const bounds = getAgentDayBoundsUtc(tz, dayBoundaryHour);
+        const dayLabel = localDateStr(new Date(parseSqliteUtcMs(bounds.start)), tz);
+        const timezoneLabel = this.config.timezone || "system";
+        const messageTotal = this.db
+            .prepare(`SELECT COUNT(*) as cnt FROM messages
+           WHERE timestamp >= ? AND timestamp < ?
+             AND role != 'system'`)
+            .get(bounds.start, bounds.end).cnt;
+        const messageRows = this.db
+            .prepare(`SELECT role, content, platform, timestamp
+           FROM messages
+           WHERE timestamp >= ? AND timestamp < ?
+             AND role != 'system'
+           ORDER BY timestamp DESC
+           LIMIT ?`)
+            .all(bounds.start, bounds.end, YESTERDAY_MESSAGE_LIMIT).reverse();
+        const dmLogTotal = this.db
+            .prepare(`SELECT COUNT(*) as cnt FROM dm_conversation_log
+           WHERE created_at >= ? AND created_at < ?`)
+            .get(bounds.start, bounds.end).cnt;
+        const dmLogRows = this.db
+            .prepare(`SELECT platform, scope, scope_key, summary, message_count, created_at
+           FROM dm_conversation_log
+           WHERE created_at >= ? AND created_at < ?
+           ORDER BY created_at DESC
+           LIMIT ?`)
+            .all(bounds.start, bounds.end, YESTERDAY_DM_LOG_LIMIT).reverse();
+        return {
+            messages: formatYesterdayMessages(dayLabel, timezoneLabel, messageRows, messageTotal),
+            dmConversationLog: formatYesterdayDmConversationLog(dayLabel, timezoneLabel, dmLogRows, dmLogTotal),
+        };
+    }
+}
+/**
+ * Truncate `value` to at most `max` chars, collapsing newlines so the
+ * result fits on one line. Suffix `…` when truncation occurs. Used by
+ * the scheduled.dm DM-activity / DM-history blocks.
+ */
+function truncateForBlock(value, max) {
+    const oneLine = value.replace(/\s+/g, " ").trim();
+    if (oneLine.length <= max)
+        return oneLine;
+    return `${oneLine.slice(0, max - 1)}…`;
+}
+function summarizeProjectFile(filename, content) {
+    const slug = filename.replace(/\.md$/, "");
+    const { frontmatter, body } = splitFrontmatter(content);
+    const state = readFrontmatterScalar(frontmatter, "state") ?? "active";
+    const title = body.match(/^#\s+(.+)$/m)?.[1]?.trim() || slug;
+    return {
+        slug,
+        title,
+        state,
+        due: readFrontmatterScalar(frontmatter, "due"),
+        nextMilestone: readFrontmatterScalar(frontmatter, "next_milestone"),
+        updated: readFrontmatterScalar(frontmatter, "updated"),
+    };
+}
+function splitFrontmatter(content) {
+    if (!content.startsWith("---\n")) {
+        return { frontmatter: "", body: content };
+    }
+    const endIdx = content.indexOf("\n---", 4);
+    if (endIdx < 0) {
+        return { frontmatter: "", body: content };
+    }
+    return {
+        frontmatter: content.slice(4, endIdx),
+        body: content.slice(endIdx + 4).replace(/^\n+/, ""),
+    };
+}
+function readFrontmatterScalar(frontmatter, key) {
+    if (!frontmatter)
+        return null;
+    const escapedKey = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const match = frontmatter.match(new RegExp(`^${escapedKey}:\\s*(.+)$`, "m"));
+    if (!match)
+        return null;
+    return match[1].trim().replace(/^['"]|['"]$/g, "");
+}
+/**
+ * Truncate the ## Agent Log section of today.md to the last `maxEntries`
+ * bullet lines. Operates on the string content only (does not touch disk).
+ * Inserts an omission marker pointing to GET /api/context/today.
+ */
+function truncateAgentLog(content, maxEntries) {
+    // Match "\n## Agent Log\n" to avoid false positives inside code blocks or
+    // quoted text. The leading \n ensures we match a heading at line start, not
+    // a substring of prose. today.md's structure is daemon-controlled, but this
+    // is defence-in-depth against accidental matches in Handoff/Notes.
+    const needle = "\n## Agent Log\n";
+    const needleIdx = content.indexOf(needle);
+    if (needleIdx < 0)
+        return content;
+    const headerIdx = needleIdx + 1; // skip the leading \n to point at "##"
+    const sectionHeader = "## Agent Log";
+    // Find the end of the Agent Log section (next ## heading or EOF)
+    const afterHeader = headerIdx + sectionHeader.length;
+    const nextSectionIdx = content.indexOf("\n## ", afterHeader);
+    const sectionEnd = nextSectionIdx >= 0 ? nextSectionIdx : content.length;
+    const sectionBody = content.slice(afterHeader, sectionEnd);
+    const lines = sectionBody.split("\n");
+    // Extract bullet lines (start with "- ")
+    const bulletLines = lines.filter((l) => l.trimStart().startsWith("- "));
+    if (bulletLines.length <= maxEntries)
+        return content;
+    // Keep only the last maxEntries bullets
+    const omitted = bulletLines.length - maxEntries;
+    const kept = bulletLines.slice(-maxEntries);
+    const truncatedBody = [
+        "",
+        `[...${omitted} earlier entries omitted — use GET /api/context/today for full content]`,
+        ...kept,
+        "",
+    ].join("\n");
+    return (content.slice(0, headerIdx) +
+        sectionHeader +
+        truncatedBody +
+        content.slice(sectionEnd));
+}
+function formatYesterdayAgentActions(dayLabel, timezoneLabel, rows, total) {
+    const lines = [
+        `- Agent day: ${dayLabel}`,
+        `- Timezone: ${timezoneLabel}`,
+        `- Rows: ${total}`,
+    ];
+    if (total > rows.length) {
+        lines.push(`- Showing latest ${rows.length} rows only`);
+    }
+    if (rows.length === 0) {
+        lines.push("- (none)");
+        return lines.join("\n");
+    }
+    for (const row of rows) {
+        const trigger = row.trigger ? ` (${row.trigger})` : "";
+        const result = row.result ?? "unknown";
+        const error = row.error
+            ? ` — error: ${truncateContextText(row.error, 140)}`
+            : "";
+        lines.push(`- ${formatSqliteTimestampForContext(row.started_at, timezoneLabel)} [${result}] ${row.action_type}${trigger}${error}`);
+    }
+    return lines.join("\n");
+}
+function formatYesterdayMessages(dayLabel, timezoneLabel, rows, total) {
+    const lines = [
+        `- Agent day: ${dayLabel}`,
+        `- Timezone: ${timezoneLabel}`,
+        `- Rows: ${total}`,
+    ];
+    if (total > rows.length) {
+        lines.push(`- Showing latest ${rows.length} rows only`);
+    }
+    if (rows.length === 0) {
+        lines.push("- (none)");
+        return lines.join("\n");
+    }
+    for (const row of rows) {
+        lines.push(`- ${formatSqliteTimestampForContext(row.timestamp, timezoneLabel)} [${row.platform}/${row.role}] ${truncateContextText(row.content, 180)}`);
+    }
+    return lines.join("\n");
+}
+function formatYesterdayDmConversationLog(dayLabel, timezoneLabel, rows, total) {
+    const lines = [
+        `- Agent day: ${dayLabel}`,
+        `- Timezone: ${timezoneLabel}`,
+        `- Rows: ${total}`,
+    ];
+    if (total > rows.length) {
+        lines.push(`- Showing latest ${rows.length} rows only`);
+    }
+    if (rows.length === 0) {
+        lines.push("- (none)");
+        return lines.join("\n");
+    }
+    for (const row of rows) {
+        const scopeKey = row.scope_key && row.scope_key.length > 0 ? `/${row.scope_key}` : "";
+        lines.push(`- ${formatSqliteTimestampForContext(row.created_at, timezoneLabel)} [${row.platform}:${row.scope}${scopeKey}] (${row.message_count} msgs) ${truncateContextText(row.summary, 220)}`);
+    }
+    return lines.join("\n");
+}
+function formatSqliteTimestampForContext(timestamp, timezone) {
+    const local = nowInTimezone(timezone === "system" ? undefined : timezone, new Date(parseSqliteUtcMs(timestamp)));
+    return `${local.year}-${String(local.month).padStart(2, "0")}-${String(local.day).padStart(2, "0")} ${String(local.hours).padStart(2, "0")}:${String(local.minutes).padStart(2, "0")}`;
+}
+function truncateContextText(text, maxChars) {
+    const compact = text.replace(/\s+/g, " ").trim();
+    if (compact.length <= maxChars)
+        return compact;
+    return `${compact.slice(0, maxChars - 3)}...`;
+}
+//# sourceMappingURL=context-builder.js.map