@aitne/daemon 0.1.7 → 0.1.9

package/dist/core/context/reconciler-runner.js

@@ -7,7 +7,8 @@ import { validateContextFileFrontmatter } from "../context-frontmatter.js";
 import { POLICY_FILE_MAX_BYTES } from "../policy-files.js";
 import { writeRuntimeState, getDegradedMode, } from "../../db/runtime-state.js";
 import { createLogger } from "../../logging.js";
-import { applyRollingRetention, reconcileContextIndex, renderContextIndex, shouldIndexPath, } from "./index-reconciler.js";
+import { applyRollingRetention, defaultRootIndexScaffold, reconcileContextIndex, renderReconcilerBlockBody, shouldIndexPath, } from "./index-reconciler.js";
+import { mergeReconcilerBlock } from "./reconciler-section.js";
 const logger = createLogger("context-index-reconciler");
 /** Runtime-state key for the minimum-viable run record — §5.6. */
 export const RECONCILER_LAST_RUN_KEY = "reconciler.context_index.last_run";
@@ -83,8 +84,23 @@ async function runOnce(opts) {
             persistRunRecord(opts.db, record);
             return record;
         }
-        const output = renderContextIndex(diff.rows, today);
-        const validationError = validateContextFileFrontmatter(output, CONTEXT_RELATIVE_PATHS.contextIndex);
+        // V15: render only the inner block body, then splice it into the host
+        // `_index.md` so user-curated content around the block is preserved.
+        const blockBody = renderReconcilerBlockBody(diff.rows, today);
+        const existing = readExistingIndexFile(opts.contextDir);
+        let baseTarget = existing ?? defaultRootIndexScaffold(today);
+        let output = mergeReconcilerBlock(baseTarget, blockBody);
+        let validationError = validateContextFileFrontmatter(output, CONTEXT_RELATIVE_PATHS.contextIndex);
+        if (validationError && existing) {
+            // Recovery path (§4.5): the host `_index.md` is corrupt — frontmatter
+            // missing, type/owner invalid, etc. Rebuild from the scaffold rather
+            // than refusing to reconcile. The user's broken content is replaced;
+            // the previous bytes survive in `md_file_snapshots` for restore.
+            logger.warn({ validation: validationError }, "Reconciler rebuilding _index.md from scaffold — host content failed validation");
+            baseTarget = defaultRootIndexScaffold(today);
+            output = mergeReconcilerBlock(baseTarget, blockBody);
+            validationError = validateContextFileFrontmatter(output, CONTEXT_RELATIVE_PATHS.contextIndex);
+        }
         if (validationError) {
             const record = {
                 ...recordBase,
@@ -238,10 +254,27 @@ function readCurrentRows(contextDir) {
         return parseContextIndexRows(content);
     }
     catch (err) {
-        logger.warn({ err }, "Reconciler could not read existing context-index.md — treating as empty");
+        logger.warn({ err }, "Reconciler could not read existing _index.md — treating as empty");
         return [];
     }
 }
+/**
+ * Return the host `_index.md` content verbatim so the reconciler can splice
+ * its block in without clobbering the user-curated prose. Returns `null`
+ * when the file does not exist (first-run case — the caller falls back to
+ * `defaultRootIndexScaffold`).
+ */
+function readExistingIndexFile(contextDir) {
+    const absolute = join(contextDir, CONTEXT_RELATIVE_PATHS.contextIndex);
+    if (!existsSync(absolute))
+        return null;
+    try {
+        return readFileSync(absolute, "utf-8");
+    }
+    catch {
+        return null;
+    }
+}
 function writeIndex(opts, content) {
     const absolute = join(opts.contextDir, CONTEXT_RELATIVE_PATHS.contextIndex);
     const directory = dirname(absolute);
@@ -255,8 +288,16 @@ function writeIndex(opts, content) {
             logger.warn({ err }, "Reconciler failed to snapshot previous context-index.md");
         }
     }
-    writeFileSync(absolute, content, "utf-8");
+    // Mark before the visible-write boundary so FS-watch consumers attribute
+    // the resulting event to the agent. Roll back on failure (C2).
     opts.writeTracker?.markWriting(absolute, content);
+    try {
+        writeFileSync(absolute, content, "utf-8");
+    }
+    catch (writeErr) {
+        opts.writeTracker?.unmark(absolute);
+        throw writeErr;
+    }
     opts.onPromptContextChanged?.(CONTEXT_RELATIVE_PATHS.contextIndex, "reconciler", "quiet", { tierReason: "derived_context_index" });
 }
 function saveSnapshot(db, filePath, content) {
@@ -270,4 +311,3 @@ function persistRunRecord(db, record) {
         logger.warn({ err, record }, "Reconciler run record persistence failed");
     }
 }
-//# sourceMappingURL=reconciler-runner.js.map

package/dist/core/context/reconciler-section.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Reconciler-section block helpers.
+ *
+ * CONTEXT_VAULT_REDESIGN_PLAN.md v4 V15 — the root `<contextDir>/_index.md`
+ * carries both user-curated content and a machine-rebuilt block. The block
+ * is delimited by HTML comments so the user's editor renders it as
+ * Markdown (Obsidian, GitHub) without exposing the markers.
+ *
+ * Both the boot migration (`db/migrations/context-vault-restructure.ts`) and
+ * the runtime reconciler (`core/context/reconciler-runner.ts`) splice the
+ * block via the helpers exported here so the two write paths cannot drift.
+ */
+export declare const RECONCILER_BLOCK_OPEN = "<!-- reconciler-section -->";
+export declare const RECONCILER_BLOCK_CLOSE = "<!-- /reconciler-section -->";
+/**
+ * Matches the entire reconciler-section block — open marker through close
+ * marker, inclusive. `[\s\S]` is required (not `.`) because the block body
+ * spans multiple lines.
+ */
+export declare const RECONCILER_BLOCK_RE: RegExp;
+/**
+ * Splice `blockBody` between `<!-- reconciler-section -->` markers inside
+ * `target`. If the target already contains a block, the body between the
+ * markers is replaced. Otherwise a new block is appended at the end of the
+ * target with a single blank-line separator.
+ *
+ * `blockBody` should be the body content only (no frontmatter, no top-level
+ * heading) — the host file owns those.
+ */
+export declare function mergeReconcilerBlock(target: string, blockBody: string): string;

package/dist/core/context/reconciler-section.js

@@ -0,0 +1,39 @@
+/**
+ * Reconciler-section block helpers.
+ *
+ * CONTEXT_VAULT_REDESIGN_PLAN.md v4 V15 — the root `<contextDir>/_index.md`
+ * carries both user-curated content and a machine-rebuilt block. The block
+ * is delimited by HTML comments so the user's editor renders it as
+ * Markdown (Obsidian, GitHub) without exposing the markers.
+ *
+ * Both the boot migration (`db/migrations/context-vault-restructure.ts`) and
+ * the runtime reconciler (`core/context/reconciler-runner.ts`) splice the
+ * block via the helpers exported here so the two write paths cannot drift.
+ */
+export const RECONCILER_BLOCK_OPEN = "<!-- reconciler-section -->";
+export const RECONCILER_BLOCK_CLOSE = "<!-- /reconciler-section -->";
+/**
+ * Matches the entire reconciler-section block — open marker through close
+ * marker, inclusive. `[\s\S]` is required (not `.`) because the block body
+ * spans multiple lines.
+ */
+export const RECONCILER_BLOCK_RE = /<!--\s*reconciler-section\s*-->[\s\S]*?<!--\s*\/reconciler-section\s*-->/;
+/**
+ * Splice `blockBody` between `<!-- reconciler-section -->` markers inside
+ * `target`. If the target already contains a block, the body between the
+ * markers is replaced. Otherwise a new block is appended at the end of the
+ * target with a single blank-line separator.
+ *
+ * `blockBody` should be the body content only (no frontmatter, no top-level
+ * heading) — the host file owns those.
+ */
+export function mergeReconcilerBlock(target, blockBody) {
+    const block = `${RECONCILER_BLOCK_OPEN}\n${blockBody.trim()}\n${RECONCILER_BLOCK_CLOSE}`;
+    if (RECONCILER_BLOCK_RE.test(target)) {
+        return target.replace(RECONCILER_BLOCK_RE, block);
+    }
+    if (target.length === 0)
+        return `${block}\n`;
+    const sep = target.endsWith("\n") ? "" : "\n";
+    return `${target}${sep}\n${block}\n`;
+}

package/dist/core/context-builder-calendar.d.ts

@@ -0,0 +1,36 @@
+import type Database from "better-sqlite3";
+import type { AgentConfig } from "../config.js";
+import type { ServiceRegistry } from "../services/service-registry.js";
+interface CalendarDeps {
+    db: Database.Database;
+    config: AgentConfig;
+    services: ServiceRegistry;
+}
+/**
+ * Build a `<calendar_events_*>` context block honouring every active
+ * provider's mode.
+ *
+ * docs/design/appendices/routine-data-acquisition.md §6.6 — the block wraps one
+ * `<provider key="…" mode="…">…</provider>` sub-block per active
+ * provider so the parent routine sees a uniform shape regardless of
+ * which provider(s) the operator has configured.
+ *
+ * `prepassCovers` — A8 / Finding 5. When `true`, the caller's
+ * `ROUTINE_WINDOWS` entry includes a calendar row, so the
+ * `routine.fetch_window` pre-pass has already POSTed events to
+ * `/api/observations` for every non-direct provider. Non-direct
+ * provider sub-blocks then emit a "read observations" hint instead
+ * of the legacy "fetch yourself" directive. Direct providers are
+ * unchanged — ContextBuilder still pre-fetches inline events via
+ * `services.calendar` (Google) and emits the fallback hint for
+ * Outlook (no daemon-side service yet). The flag has no effect on
+ * direct-mode sub-blocks. Default `false` for callers that don't
+ * have pre-pass coverage (today_refresh, weekly/monthly_review,
+ * roadmap_refresh).
+ */
+export declare function renderCalendarBlock(deps: CalendarDeps, args: {
+    days: number;
+    blockName: string;
+    prepassCovers?: boolean;
+}): Promise<string>;
+export {};

package/dist/core/context-builder-calendar.js

@@ -0,0 +1,245 @@
+import { getAgentDayBoundsUtc, getIntegrationDescriptor, localDateStr, nowInTimezone, parseSqliteUtcMs, } from "@aitne/shared";
+import { readIntegrations } from "../db/integrations-store.js";
+import { createLogger } from "../logging.js";
+const logger = createLogger("context-builder-calendar");
+/**
+ * Build a `<calendar_events_*>` context block honouring every active
+ * provider's mode.
+ *
+ * docs/design/appendices/routine-data-acquisition.md §6.6 — the block wraps one
+ * `<provider key="…" mode="…">…</provider>` sub-block per active
+ * provider so the parent routine sees a uniform shape regardless of
+ * which provider(s) the operator has configured.
+ *
+ * `prepassCovers` — A8 / Finding 5. When `true`, the caller's
+ * `ROUTINE_WINDOWS` entry includes a calendar row, so the
+ * `routine.fetch_window` pre-pass has already POSTed events to
+ * `/api/observations` for every non-direct provider. Non-direct
+ * provider sub-blocks then emit a "read observations" hint instead
+ * of the legacy "fetch yourself" directive. Direct providers are
+ * unchanged — ContextBuilder still pre-fetches inline events via
+ * `services.calendar` (Google) and emits the fallback hint for
+ * Outlook (no daemon-side service yet). The flag has no effect on
+ * direct-mode sub-blocks. Default `false` for callers that don't
+ * have pre-pass coverage (today_refresh, weekly/monthly_review,
+ * roadmap_refresh).
+ */
+export async function renderCalendarBlock(deps, args) {
+    const { db } = deps;
+    const { days, blockName, prepassCovers = false } = args;
+    const integrations = readIntegrations(db);
+    const { timeMin, timeMax } = computeCalendarWindow(deps, days);
+    const subblocks = [];
+    const googleSub = await renderCalendarProviderBlock(deps, "google_calendar", "Google Calendar", integrations.google_calendar?.mode ?? "disabled", days, timeMin, timeMax, prepassCovers);
+    if (googleSub)
+        subblocks.push(googleSub);
+    const outlookSub = await renderCalendarProviderBlock(deps, "outlook_calendar", "Outlook Calendar", integrations.outlook_calendar?.mode ?? "disabled", days, timeMin, timeMax, prepassCovers);
+    if (outlookSub)
+        subblocks.push(outlookSub);
+    if (subblocks.length === 0) {
+        // Match the legacy single-line shape so existing prose that greps
+        // for `<calendar_status>not available` keeps matching.
+        return `<calendar_status>Calendar service not available. No calendar provider is configured for this window.</calendar_status>`;
+    }
+    return [
+        `<${blockName} days="${days}" timeMin="${timeMin}" timeMax="${timeMax}">`,
+        ...subblocks,
+        `</${blockName}>`,
+    ].join("\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.
+ */
+function computeCalendarWindow(deps, days) {
+    const tz = deps.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(),
+    };
+}
+/**
+ * Emit one provider sub-block for `renderCalendarBlock`. Returns null
+ * when the provider is disabled (or, for native mode, the binding
+ * does not apply to a meaningful path — the agent reads
+ * `<integration_modes>` to decide whether its session backend is the
+ * native one).
+ */
+async function renderCalendarProviderBlock(deps, key, displayName, mode, days, timeMin, timeMax, prepassCovers) {
+    if (mode === "disabled")
+        return null;
+    const open = `  <provider key="${key}" mode="${mode}">`;
+    const close = "  </provider>";
+    // A8 / Finding 5 — when the parent routine's pre-pass owns the
+    // calendar window AND this provider is non-direct, the pre-pass
+    // has already POSTed events to /api/observations. Replace the
+    // legacy "fetch yourself" directive with a hint pointing at
+    // observations so the main routine session never re-drives the
+    // MCP fan-out (the cost regression that motivated this flag).
+    if (prepassCovers && (mode === "delegated" || mode === "native")) {
+        return [
+            open,
+            `${displayName} ${mode} mode — the routine.fetch_window pre-pass`,
+            `posted events for [${timeMin}, ${timeMax}) to /api/observations`,
+            `under source_prefix \`${key}:\`. Read them via:`,
+            `  GET http://localhost:8321/api/observations?pending=true&source_prefix=${key}:&limit=200`,
+            `Consult \`<fetch_report>\` injected above for pre-pass status; on`,
+            `status="failed" or "skipped" treat this provider as unavailable for`,
+            `the window and log a one-line skip to \`## Agent Log\` instead of`,
+            `re-driving the connector yourself. Do NOT call /api/calendar/* or`,
+            `/api/integrations/*/exec — those return 410 in this mode.`,
+            close,
+        ].join("\n");
+    }
+    if (mode === "direct") {
+        // Today only `services.calendar` (Google) is wired. Outlook direct
+        // mode reaches `GET /api/calendar/outlook` from the task flow; the
+        // context block surfaces a service-status hint until a daemon-side
+        // CalendarService for Outlook lands. Either way the agent can fall
+        // back to its own direct REST call from the task flow.
+        if (key === "google_calendar" && deps.services.calendar) {
+            const inline = await fetchCalendarEvents(deps, days);
+            if (inline !== null) {
+                return [open, inline, close].join("\n");
+            }
+        }
+        return [
+            open,
+            `${displayName}: direct mode, daemon service not initialized for this window.`,
+            `Fetch yourself via the task flow's direct-mode endpoint (Google: /api/calendar/events; Outlook: /api/calendar/outlook).`,
+            close,
+        ].join("\n");
+    }
+    if (mode === "delegated") {
+        // CLAUDE.md: "Never hardcode an integration reference outside the
+        // registry." `userManagedConnector` is the registry's source of
+        // truth for whether the daemon ships a `/api/integrations/<key>/
+        // exec` proxy. Reading it from the descriptor means a future
+        // user-managed integration (Proton, custom MCP, etc.) inherits
+        // the right branch without touching this method.
+        const isUserManaged = getIntegrationDescriptor(key).userManagedConnector === true;
+        const lines = [
+            open,
+            `${displayName} is delegated — see \`<integration_modes>\`. Fetch the window`,
+            `(timeMin=${timeMin}, timeMax=${timeMax}) and treat the returned events as`,
+            `the contents of this provider block for the rest of the task flow.`,
+            "",
+            "  Same-backend (delegated_to == your session backend) — use your",
+            `  session's ${displayName} MCP tool (whichever your skills document).`,
+        ];
+        if (!isUserManaged) {
+            lines.push("", "  Cross-backend (delegated_to != your session backend) — call", "  the daemon's task-mode endpoint so the configured account is used:", `    POST http://localhost:8321/api/integrations/${key}/exec`, `      task: List every event between ${timeMin} and ${timeMax}.`, `      outputSchema: { events: [ { id, title, start, end } ] }`, `    Do NOT call /api/calendar/* (returns 410 in delegated mode).`);
+        }
+        else {
+            lines.push("", "  Cross-backend: not available for Outlook (user-managed connector,", "  no daemon proxy). Fall through to the session's MCP regardless.");
+        }
+        lines.push("", "If the call errors out, log one line to `## Agent Log` and proceed", "as if the window were empty.", close);
+        return lines.join("\n");
+    }
+    // mode === "native"
+    return [
+        open,
+        `${displayName} is in native mode — see \`<integration_modes>.${key}_native_to\`.`,
+        `Fetch this window (timeMin=${timeMin}, timeMax=${timeMax}) yourself via your`,
+        `session backend's ${displayName} MCP surface. Do NOT call /api/calendar/*`,
+        `or /api/integrations/*/exec — native mode has no daemon proxy.`,
+        "",
+        `If the native binding does not match your session backend (check`,
+        `\`${key}_native_to\`), treat this provider as unavailable for this turn`,
+        `and log one line to \`## Agent Log\`.`,
+        close,
+    ].join("\n");
+}
+/**
+ * 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 function fetchCalendarEvents(deps, days) {
+    const calendar = deps.services.calendar;
+    if (!calendar)
+        return null;
+    try {
+        const { timeMin, timeMax } = computeCalendarWindow(deps, days);
+        const events = await calendar.listEvents(timeMin, timeMax);
+        if (events.length === 0) {
+            return `Calendar connected (Google Calendar). No events found in the next ${days} days.`;
+        }
+        return formatCalendarEvents(deps, events, days);
+    }
+    catch (err) {
+        logger.warn({ err }, "Failed to fetch calendar events for context");
+        return null;
+    }
+}
+/** Format calendar events grouped by date */
+function formatCalendarEvents(deps, events, days) {
+    const now = new Date();
+    const tz = deps.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 = formatTimeRange(deps, 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" */
+function formatTimeRange(deps, 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 = formatLocalTime(deps, startDate);
+    const endTime = formatLocalTime(deps, endDate);
+    return `${startTime}–${endTime}`;
+}
+function formatLocalTime(deps, date) {
+    const local = nowInTimezone(deps.config.timezone || undefined, date);
+    return `${String(local.hours).padStart(2, "0")}:${String(local.minutes).padStart(2, "0")}`;
+}

package/dist/core/context-builder-conversation.d.ts

@@ -0,0 +1,95 @@
+import type Database from "better-sqlite3";
+import type { Event, MessageEvent } from "@aitne/shared";
+import type { AgentConfig } from "../config.js";
+interface ConversationDeps {
+    db: Database.Database;
+    config: AgentConfig;
+}
+/**
+ * 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.
+ */
+export declare function renderRecentDmActivityBlock(deps: ConversationDeps, windowMinutes: number): string | null;
+/**
+ * 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 `renderRecentDmActivityBlock`:
+ * the briefing must reconstruct topic context from whichever surface
+ * the user has been using, not just the messaging-app one.
+ */
+export declare function renderOwnerDmConversationHistory(deps: ConversationDeps, limit: number): string | null;
+export declare function getConversationHistoryForEvent(deps: ConversationDeps, event: MessageEvent): string | null;
+export declare function renderRecentOtherSurfaceBlock(deps: ConversationDeps, event: MessageEvent): string | null;
+/**
+ * Record an `agent_actions.proactive_forward_injected` row so the
+ * dashboard's audit log shows when a proactive forward (e.g. scheduled
+ * DM, hourly-check notification) was re-presented as conversation
+ * history. Both runtime call sites (`getConversationHistoryForEvent`
+ * and `renderResumeCatchupContext`) live in this file; the export is
+ * kept only for the direct unit-test peer in
+ * `context-builder-conversation.test.ts` that exercises the audit-row
+ * dedup logic in isolation.
+ */
+export declare function logProactiveForwardInjected(db: Database.Database, rows: Array<{
+    sessionId: number;
+    dispatchIds: string[];
+    sessionResumed: boolean;
+}>): void;
+/**
+ * Render a rolling 7-day (or N-day) window of DM conversation-log
+ * summaries for roadmap_refresh. Unlike `buildYesterdayContext`,
+ * 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.
+ */
+export declare function renderRecentDmConversationLog(deps: ConversationDeps, days: number): string;
+/**
+ * DM-HISTORY-CONTINUITY-FIX H-2 — narrow companion to `build()` for the
+ * resume path. Emits only the new information the SDK session does not
+ * already have: proactive forwards (including `scheduled_dm`) that
+ * landed in this scope OR the cross-surface DM scope *after* the
+ * resumed session was started.
+ *
+ * Why this is its own builder, not `build()` with a flag:
+ *   - On resume, the SDK ships the cached system prompt (and the
+ *     `<conversation_history>` / `<recent_other_surface>` blocks it
+ *     was built with) untouched. Concatenating the full `build()`
+ *     output onto the user turn re-bills every always-injected
+ *     block against the user-turn payload, killing prompt-cache
+ *     savings AND duplicating `<conversation_history>` content the
+ *     SDK session already holds.
+ *   - The catchup payload is ~few hundred tokens vs. ~10 K for the
+ *     full build, on a hot path that fires whenever there's a
+ *     recent proactive forward (~half of dashboard turns in
+ *     practice).
+ *
+ * `sessionStartedAtMs` should be the session row's `started_at`
+ * (not `last_message_at`) — `started_at` is fixed at session start
+ * and doesn't race with concurrent inserts. Returns `null` when no
+ * forwards landed after the anchor, or when the event is not a DM
+ * message.
+ */
+export declare function renderResumeCatchupContext(deps: ConversationDeps, event: Event, sessionStartedAtMs: number): Promise<string | null>;
+export {};