@aitne/daemon 0.1.8 → 0.1.10

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

@@ -0,0 +1,444 @@
+import { formatSqliteDatetime, isMessageEvent, parseSqliteUtcMs, } from "@aitne/shared";
+import { formatForwardSuffix, getProactiveForwardType, isProactiveForwardMetadata, metadataDispatchIds, parseMessageMetadata, } from "./channel-timeline.js";
+import { OWNER_DM_SCOPE, OWNER_SCOPE_KEY, DASHBOARD_CHAT_SCOPE, DASHBOARD_SCOPE_KEY, getConversationScope, } from "../messaging/constants.js";
+import { createLogger } from "../logging.js";
+import { formatSqliteTimestampForContext, truncateContextText, truncateForBlock, } from "./context-builder-format.js";
+const logger = createLogger("context-builder-conversation");
+// Per-block ceiling for `renderRecentDmConversationLog`. Kept in lock-step
+// with `YESTERDAY_DM_LOG_LIMIT` in `context-builder-yesterday.ts` — pre-
+// split both renderers shared a single module constant, so any cap change
+// must move both files together to preserve byte-identical output across
+// the morning-routine yesterday block AND the roadmap-refresh rolling
+// window. Diverging the two would silently regress one surface.
+const RECENT_DM_LOG_LIMIT = 20;
+/**
+ * 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 function renderRecentDmActivityBlock(deps, windowMinutes) {
+    const { db } = deps;
+    const sinceUtc = formatSqliteDatetime(new Date(Date.now() - windowMinutes * 60_000));
+    const rows = 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 `renderRecentDmActivityBlock`:
+ * the briefing must reconstruct topic context from whichever surface
+ * the user has been using, not just the messaging-app one.
+ */
+export function renderOwnerDmConversationHistory(deps, limit) {
+    const { db } = deps;
+    const rows = 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"
+            ? formatForwardSuffix(parseMessageMetadata(r.metadata))
+            : "";
+        return `[${r.timestamp}] [${r.role}]${forwardSuffix}: ${truncateForBlock(r.content, 400)}`;
+    })
+        .join("\n");
+}
+export function getConversationHistoryForEvent(deps, event) {
+    const { db, config } = deps;
+    const maxMessages = 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 = 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 = 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 = 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" ? formatForwardSuffix(metadata) : "";
+        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) {
+        logProactiveForwardInjected(db, proactiveRows);
+    }
+    return lines.join("\n");
+}
+export function renderRecentOtherSurfaceBlock(deps, event) {
+    const { db, config } = deps;
+    if (!event.isDm || event.intent === "docs_qa")
+        return null;
+    const windowMinutes = 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 = resolveOtherDmScope(scope);
+    if (!other)
+        return null;
+    const sinceUtc = formatSqliteDatetime(new Date(Date.now() - windowMinutes * 60_000));
+    const rows = 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;
+}
+/**
+ * Map a DM-scope identifier to the cross-surface scope/key pair the
+ * other owner-facing surface listens on. `owner_dm` ↔ `dashboard_chat`;
+ * anything else (e.g. `docs_qa`) returns `null` so callers can skip the
+ * cross-surface read. Shared by `renderRecentOtherSurfaceBlock` and
+ * `renderResumeCatchupContext`, which both need to fan out one extra
+ * read whenever the owner is mid-conversation on the other surface.
+ */
+function resolveOtherDmScope(scope) {
+    if (scope === OWNER_DM_SCOPE) {
+        return { scope: DASHBOARD_CHAT_SCOPE, scopeKey: DASHBOARD_SCOPE_KEY };
+    }
+    if (scope === DASHBOARD_CHAT_SCOPE) {
+        return { scope: OWNER_DM_SCOPE, scopeKey: OWNER_SCOPE_KEY };
+    }
+    return 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 function logProactiveForwardInjected(db, rows) {
+    const sessionId = rows[rows.length - 1]?.sessionId;
+    if (sessionId === undefined)
+        return;
+    const dispatchIds = [
+        ...new Set(rows.flatMap((row) => row.dispatchIds)),
+    ];
+    try {
+        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");
+    }
+}
+/**
+ * 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 function renderRecentDmConversationLog(deps, days) {
+    const { db, config } = deps;
+    const timezoneLabel = 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 = db
+        .prepare(`SELECT COUNT(*) as cnt FROM dm_conversation_log
+           WHERE created_at >= ? AND created_at < ?`)
+        .get(startSqlite, endSqlite).cnt;
+    const rows = 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, RECENT_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");
+}
+/**
+ * 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 async function renderResumeCatchupContext(deps, event, sessionStartedAtMs) {
+    if (!isMessageEvent(event) || !event.isDm)
+        return null;
+    const { db } = deps;
+    const { scope, scopeKey } = getConversationScope({
+        platform: event.platform,
+        channel: event.channel,
+        threadId: event.threadId,
+        isDm: true,
+        intent: event.intent,
+    });
+    const other = resolveOtherDmScope(scope);
+    const sinceUtc = formatSqliteDatetime(new Date(sessionStartedAtMs));
+    const scopeFilters = [
+        { scope, scopeKey },
+    ];
+    if (other)
+        scopeFilters.push(other);
+    const placeholders = scopeFilters
+        .map(() => "(s.scope = ? AND s.scope_key = ?)")
+        .join(" OR ");
+    const params = [];
+    for (const filter of scopeFilters) {
+        params.push(filter.scope, filter.scopeKey);
+    }
+    params.push(sinceUtc);
+    const rows = db
+        .prepare(`SELECT
+           m.session_id,
+           m.role,
+           m.content,
+           m.platform,
+           m.timestamp,
+           m.metadata,
+           s.scope,
+           s.backend_session_id
+         FROM messages m
+         JOIN conversation_sessions s ON m.session_id = s.id
+         WHERE (${placeholders})
+           AND m.role = 'assistant'
+           AND m.timestamp > ?
+         ORDER BY m.timestamp ASC, m.id ASC
+         LIMIT 30`)
+        .all(...params);
+    const forwards = rows.filter((r) => isProactiveForwardMetadata(parseMessageMetadata(r.metadata)));
+    if (forwards.length === 0)
+        return null;
+    const proactiveRows = [];
+    const lines = forwards.map((r) => {
+        const metadata = parseMessageMetadata(r.metadata);
+        proactiveRows.push({
+            sessionId: r.session_id,
+            dispatchIds: metadataDispatchIds(metadata),
+            sessionResumed: r.backend_session_id !== null,
+        });
+        const suffix = formatForwardSuffix(metadata);
+        const scopeTag = r.scope === scope ? "this surface" : "other surface";
+        return `[${r.timestamp}] [assistant → ${r.platform}, ${scopeTag}]${suffix}: ${r.content}`;
+    });
+    if (proactiveRows.length > 0) {
+        logProactiveForwardInjected(db, proactiveRows);
+    }
+    return [
+        "<proactive_forwards_since_last_turn>",
+        "Background notifications and scheduled DMs dispatched on your",
+        "behalf while this session was idle. The owner has now replied —",
+        "these may or may not be the referent of that reply.",
+        ...lines,
+        "</proactive_forwards_since_last_turn>",
+    ].join("\n");
+}

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

@@ -0,0 +1,8 @@
+/**
+ * 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.
+ */
+export declare function truncateForBlock(value: string, max: number): string;
+export declare function formatSqliteTimestampForContext(timestamp: string, timezone: string): string;
+export declare function truncateContextText(text: string, maxChars: number): string;

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

@@ -0,0 +1,22 @@
+import { nowInTimezone, parseSqliteUtcMs } from "@aitne/shared";
+/**
+ * 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.
+ */
+export function truncateForBlock(value, max) {
+    const oneLine = value.replace(/\s+/g, " ").trim();
+    if (oneLine.length <= max)
+        return oneLine;
+    return `${oneLine.slice(0, max - 1)}…`;
+}
+export 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")}`;
+}
+export function truncateContextText(text, maxChars) {
+    const compact = text.replace(/\s+/g, " ").trim();
+    if (compact.length <= maxChars)
+        return compact;
+    return `${compact.slice(0, maxChars - 3)}...`;
+}

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

@@ -0,0 +1,11 @@
+/**
+ * Render the `<active_projects>` body — a sorted bullet list of the
+ * non-archived project summaries pulled from
+ * `${contextDir}/${CONTEXT_RELATIVE_PATHS.projects.dir}/*.md`.
+ *
+ * Returns `null` when the directory is absent, contains no eligible
+ * files, or `contextDir` itself is `null` (degraded mode). Callers
+ * wrap the returned body in the surrounding `<active_projects>` XML
+ * tag.
+ */
+export declare function renderActiveProjectsSection(contextDir: string | null): Promise<string | null>;

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

@@ -0,0 +1,102 @@
+import { readFile } from "node:fs/promises";
+import { existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { CONTEXT_RELATIVE_PATHS } from "./context-paths.js";
+/**
+ * Render the `<active_projects>` body — a sorted bullet list of the
+ * non-archived project summaries pulled from
+ * `${contextDir}/${CONTEXT_RELATIVE_PATHS.projects.dir}/*.md`.
+ *
+ * Returns `null` when the directory is absent, contains no eligible
+ * files, or `contextDir` itself is `null` (degraded mode). Callers
+ * wrap the returned body in the surrounding `<active_projects>` XML
+ * tag.
+ */
+export async function renderActiveProjectsSection(contextDir) {
+    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 readProjectFile(contextDir, 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");
+}
+async function readProjectFile(contextDir, name) {
+    const fullPath = join(contextDir, CONTEXT_RELATIVE_PATHS.projects.dir, name);
+    if (!existsSync(fullPath))
+        return null;
+    try {
+        return await readFile(fullPath, "utf-8");
+    }
+    catch {
+        return null;
+    }
+}
+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, "");
+}

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

@@ -0,0 +1,30 @@
+import type Database from "better-sqlite3";
+import type { AgentConfig } from "../config.js";
+interface YesterdayDeps {
+    db: Database.Database;
+    config: AgentConfig;
+}
+export declare function buildYesterdayContext(deps: YesterdayDeps): Promise<{
+    agentActions: string;
+    messages: string;
+    dmConversationLog: string;
+}>;
+/**
+ * Current-agent-day variant of `buildYesterdayContext` 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).
+ */
+export declare function buildAgentDayDmContext(deps: YesterdayDeps): {
+    messages: string;
+    dmConversationLog: string;
+};
+/**
+ * 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.
+ */
+export declare function truncateAgentLog(content: string, maxEntries: number): string;
+export {};