@aitne/daemon 0.1.7 → 0.1.9

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

@@ -0,0 +1,198 @@
+import { getAgentDayBoundsUtc, localDateStr, parseSqliteUtcMs, } from "@aitne/shared";
+import { formatSqliteTimestampForContext, truncateContextText, } from "./context-builder-format.js";
+const YESTERDAY_AGENT_ACTION_LIMIT = 40;
+const YESTERDAY_MESSAGE_LIMIT = 60;
+const YESTERDAY_DM_LOG_LIMIT = 20;
+export async function buildYesterdayContext(deps) {
+    const { db, config } = deps;
+    const tz = config.timezone || undefined;
+    const dayBoundaryHour = 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 = config.timezone || "system";
+    const agentActionTotal = db
+        .prepare(`SELECT COUNT(*) as cnt FROM agent_actions
+         WHERE started_at >= ? AND started_at < ?`)
+        .get(bounds.start, bounds.end).cnt;
+    const agentActionRows = 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 = db
+        .prepare(`SELECT COUNT(*) as cnt FROM messages
+         WHERE timestamp >= ? AND timestamp < ?
+           AND role != 'system'`)
+        .get(bounds.start, bounds.end).cnt;
+    const messageRows = 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 = db
+        .prepare(`SELECT COUNT(*) as cnt FROM dm_conversation_log
+         WHERE created_at >= ? AND created_at < ?`)
+        .get(bounds.start, bounds.end).cnt;
+    const dmLogRows = 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 `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 function buildAgentDayDmContext(deps) {
+    const { db, config } = deps;
+    const tz = config.timezone || undefined;
+    const dayBoundaryHour = config.dayBoundaryHour ?? 4;
+    const bounds = getAgentDayBoundsUtc(tz, dayBoundaryHour);
+    const dayLabel = localDateStr(new Date(parseSqliteUtcMs(bounds.start)), tz);
+    const timezoneLabel = config.timezone || "system";
+    const messageTotal = db
+        .prepare(`SELECT COUNT(*) as cnt FROM messages
+         WHERE timestamp >= ? AND timestamp < ?
+           AND role != 'system'`)
+        .get(bounds.start, bounds.end).cnt;
+    const messageRows = 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 = db
+        .prepare(`SELECT COUNT(*) as cnt FROM dm_conversation_log
+         WHERE created_at >= ? AND created_at < ?`)
+        .get(bounds.start, bounds.end).cnt;
+    const dmLogRows = 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 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 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");
+}

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

@@ -17,140 +17,89 @@ export declare class ContextBuilder implements IContextBuilder {
      * a legacy location.
      */
     private get readableContextDir();
-    build(event: Event): Promise<string>;
+    build(event: Event, opts?: {
+        /**
+         * DM-HISTORY-CONTINUITY-FIX H-3 — when the dispatcher's fresh-execute
+         * branch has already resolved that `requiresHistoryInjection=true`
+         * (dashboard reset-in-place, day-boundary fall-through, etc.), the
+         * cross-session bridge in `buildCrossSessionConversationHistory()`
+         * is the source of truth for *every* prior message in scope. The
+         * active-session-only `<conversation_history>` block would then
+         * duplicate those rows under a second XML tag, with subtly
+         * different rendering. Suppress it on those turns so the two
+         * sources stay mutually exclusive.
+         *
+         * Defaults to `false`; only the dispatcher's fresh-execute call
+         * site for owner / dashboard DMs sets it.
+         */
+        skipActiveHistoryBlock?: boolean;
+    }): Promise<string>;
     /**
-     * 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.
+     * IContextBuilder contract delegate. Full doc + rationale live on
+     * `renderResumeCatchupContext` in `context-builder-conversation.ts`
+     * (the catchup block is conversation-history surface area; the
+     * orchestrator forwards the call so the public interface stays on
+     * this class).
      */
-    private computeCalendarWindow;
+    buildResumeCatchupContext(event: Event, sessionStartedAtMs: number): Promise<string | null>;
     /**
-     * Build a `<calendar_events_…>` context block honouring every active
-     * calendar provider × mode cell.
+     * Slim context for `routine.fetch_window` (Phase 2 — see
+     * docs/design/appendices/fetch-window-cost-reduction.md §5). Emits only the three
+     * blocks the pre-pass session causally depends on:
      *
-     * ROUTINE_DATA_ACQUISITION_DESIGN.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. Per-provider body:
+     *  - `<event_correlation_id>` — required for `/api/observations` POSTs
+     *    so dispatched observations attribute back to the same parent run.
+     *  - `<integration_modes>` — the partial bodies inlined into the
+     *    fetcher's user prompt branch on `direct` / `delegated` / `native`
+     *    per integration; without this block the partial cannot pick a
+     *    mode-arm. Also the only block that reads from the DB on this path.
+     *  - `<acquisition-plan>` — verbatim block from
+     *    `event.data.acquisitionPlanBlock`, assembled by the dispatcher
+     *    before the sub-session spawns. Carries one `<fetch>` row per
+     *    (integration × mode × account) tuple. Absent only on the empty-plan
+     *    short-circuit (`routine-fetch-window-runner.ts:buildFanOutPlanContext`),
+     *    in which case the slim path emits two blocks instead of three.
      *
-     *  - **direct + matching service available** → inline formatted event
-     *    list fetched by the daemon's `services.calendar` (Google today;
-     *    Outlook gets the same path once a dedicated `services.outlookCalendar`
-     *    lands — for now Outlook direct mode emits a service-unavailable
-     *    note so the flow degrades gracefully).
-     *  - **delegated** → a structured directive instructing the agent to
-     *    call the relevant MCP tool (same-backend) or the daemon's
-     *    `/api/integrations/<key>/exec` proxy (cross-backend). For
-     *    `userManagedConnector` providers (Outlook today) the proxy
-     *    branch is suppressed — same-backend and cross-backend collapse
-     *    onto the session's MCP.
-     *  - **native** → directive that points at the session backend's MCP
-     *    only. No daemon proxy: native bindings never fall back to the
-     *    daemon (R7 from the design doc).
-     *  - **disabled** → provider sub-block omitted entirely.
+     * Skipped relative to the wide path (and why each is safe to drop):
+     *  - `<management_mode_degraded>` — fetch_window does not read context
+     *    MD files; degraded mode is informational for vault-touching flows.
+     *  - `<user>` / `<management_rules>` / `<today>` — operator profile +
+     *    rules + day-log are irrelevant to "fetch new messages since X".
+     *  - `<agent_identity>` / `<current_time>` / `<current_agent_day>` —
+     *    the per-fetch `<fetch>` row carries its own `since` / `before`
+     *    timestamps; the fetcher does not introspect "what time is it".
+     *  - `<settings>` / `<output_language_policy>` — output is structural
+     *    JSON (`{fetched, posted, duplicates, errors}`); the language
+     *    policy only governs user-facing prose.
+     *  - `<routine_protocol>` — silent-by-default + "POST /api/notify is
+     *    the only user channel" — fetch_window never POSTs to /api/notify;
+     *    the protocol matters for the parent routine, not the pre-pass.
+     *  - `<obsidian_vault_path>` — fetcher does not touch the vault.
+     *  - `<today_write_lock_id>` / `<roadmap_write_lock_id>` — locks are
+     *    parent-routine concerns; fetcher writes nothing to MD files.
+     *  - `<gate_decision>` / `<fetch_report>` — pre-pass-related blocks
+     *    consumed by the parent routine, not by the pre-pass itself.
      *
-     * When no provider is active, emit the legacy
-     * `<calendar_status>not available</calendar_status>` so routine flows
-     * that branch on the unavailable marker keep working.
-     *
-     * All callers funnel through this method so the three surfaces
-     * (morning / evening / weekly+monthly and the agent-task path) stay
-     * in lock-step when integration handling changes.
-     */
-    /**
-     * Build a `<calendar_events_*>` context block honouring every active
-     * provider's mode.
-     *
-     * `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).
-     */
-    private buildCalendarBlock;
-    /**
-     * Emit one provider sub-block for `buildCalendarBlock`. 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).
-     */
-    private buildCalendarProviderBlock;
-    /**
-     * 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.
+     * Backend-neutral by construction: this string is passed verbatim to
+     * `core.execute(...)` for whichever backend resolved the binding
+     * (`routine-fetch-window-runner.ts:1529`). Same saving lands on Claude
+     * (cache_creation) and on Codex / Gemini / OpenCode (raw input tokens).
      */
-    private fetchCalendarEvents;
-    /** Format calendar events grouped by date */
-    private formatCalendarEvents;
-    /** Format event time range as "HH:MM–HH:MM" or "All day" */
-    private formatTimeRange;
-    private formatLocalTime;
+    private buildFetchWindowContext;
     /**
-     * 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.
+     * Render the `<integration_modes ... />` element used by both the wide
+     * build path and the fetch_window slim path. Centralised so the slim
+     * path cannot drift from the wide path's attribute shape — both routes
+     * read from the same `readIntegrations(db)` snapshot and emit
+     * `key="mode"` plus the optional `_delegated_to` / `_native_backend`
+     * attributes per state.
      */
-    private buildRecentDmActivityBlock;
+    private buildIntegrationModesBlock;
     /**
-     * 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.
+     * Bundle the three deps `renderCalendarBlock` consumes into one
+     * object literal so callers in `build()` don't repeat the spread at
+     * every site.
      */
-    private buildOwnerDmConversationHistory;
-    private getConversationHistory;
-    private buildRecentOtherSurfaceBlock;
-    private logProactiveForwardInjected;
+    private calendarDeps;
     private readFile;
-    private buildActiveProjectsSection;
-    /**
-     * 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.
-     */
-    private buildRecentDmConversationLog;
-    private buildYesterdaySqliteContext;
-    /**
-     * 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).
-     */
-    private buildAgentDayDmContext;
 }
-//# sourceMappingURL=context-builder.d.ts.map