devsmind-mcp 2.4.0 → 4.0.0

package/dist/db/activity-graph.js

@@ -0,0 +1,314 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GRAPH_SOURCE_CAVEATS = void 0;
+exports.queryGraphActivityLog = queryGraphActivityLog;
+exports.resolveActivityLog = resolveActivityLog;
+const crypto = __importStar(require("crypto"));
+const database_1 = require("./database");
+const activity_1 = require("./activity");
+/**
+ * The SHARED half of `get_activity_log` — "what changed" reconstructed from committed graph
+ * history instead of this machine's local message store.
+ *
+ * The local log (activity.ts) is gitignored by design: it holds verbatim request text and full
+ * before/after backups, neither of which belongs in a shared repo. The cost of that decision is
+ * that it is empty for everyone except the person who wrote it — a teammate who clones the repo,
+ * or the same developer on a second machine, asks "what changed here lately?" and gets nothing
+ * back, even though `.devmind/history/*.json` has been recording exactly that all along, committed
+ * and pulled.
+ *
+ * This module reconstructs per-commit entries from that shared record so the answer degrades
+ * instead of disappearing. It is a genuinely lossier view, and says so rather than papering over
+ * the difference — see {@link GRAPH_SOURCE_CAVEATS}.
+ *
+ * ── How a commit is recovered ────────────────────────────────────────────────
+ * History is stored per NODE, but `commitStagedChanges` hands one `reasoning` object to
+ * `updateHistory` for every node in the batch, so all of them come back carrying a byte-identical
+ * formatted block. Block text is therefore the primary commit identity.
+ *
+ * `session_id` is deliberately NOT part of that key, despite looking like the obvious
+ * discriminator. The 1-hour merge writes a later block into an EXISTING row and keeps that row's
+ * original session id (`writeHistoryToDisk(latest.id, …, latest.session_id, …)`), so within a
+ * single commit, a node whose row already existed reports the session that created it while a node
+ * getting a fresh row reports the current one. Keying on session would split one real commit in
+ * two — a strictly worse error than the one it would prevent.
+ *
+ * What separates two commits that happen to share reasoning text is TIME. Blocks are stamped
+ * inside `commitStagedChanges`'s synchronous per-node loop, so one commit's blocks land
+ * milliseconds apart, while a repeat of the same text is a separate editing act minutes or hours
+ * later. Grouping therefore cuts on the gap between CONSECUTIVE blocks ({@link COMMIT_CLUSTER_MS}),
+ * never on total span, so a slow many-node commit stays intact however long it ran end to end.
+ *
+ * The irreducible ambiguity: two sessions committing byte-identical reasoning within the same
+ * minute read as one commit. The shared record genuinely does not distinguish them.
+ */
+/**
+ * Longest gap between consecutive same-reasoning blocks that still counts as one commit.
+ *
+ * Sized to sit far above a per-node write (milliseconds) and far below any plausible re-run of the
+ * same reasoning text by a human or an agent. It bounds the gap between neighbours, never the
+ * group's total duration.
+ */
+const COMMIT_CLUSTER_MS = 60_000;
+/** Everything the shared record cannot answer, stated once and attached to any graph-backed
+ * response. Callers act on this data (reverting, attributing, scoping a test pass), so the gaps
+ * have to travel with it — a silently thinner entry reads as an authoritative one. */
+exports.GRAPH_SOURCE_CAVEATS = [
+    'status is always "applied": revert state lives in the local log only, so a reverted change still appears here as applied.',
+    'request is the reasoning block\'s Requirement field, not the verbatim user request — that text is never committed.',
+    'files/node_ids cover only nodes tracked in the graph; whole-file edits that traced to no node are absent.',
+    'developer is null for commits made before a DEVELOPER_NAME was configured.',
+    'session_id names the session that created the history row, which the 1-hour merge can attribute to an earlier session than the one that wrote the change.'
+];
+/** Stable, content-derived id — the same commit must get the same id on every machine that pulls
+ * it, which rules out a random uuid. Prefixed so a graph id is never mistaken for a local message
+ * id by a caller that then tries to `readMessage` it. */
+function graphEntryId(startedAt, blockText) {
+    const hash = crypto.createHash('sha1').update(`${startedAt}\n${blockText}`).digest('hex');
+    return `graph:${hash.slice(0, 32)}`;
+}
+/**
+ * Rebuilds per-commit activity entries from committed history.
+ *
+ * The date bounds are applied twice on purpose: {@link DevMindDatabase.queryHistoryForActivity}
+ * over-selects rows whose accumulation span merely OVERLAPS the window (it cannot see inside the
+ * blob), then each block is tested against its own timestamp here. Filtering only in SQL would
+ * either drop in-window blocks appended to an older row, or admit out-of-window ones from a row
+ * that stayed active — both wrong in a way the caller could not detect.
+ */
+function queryGraphActivityLog(db, opts = {}) {
+    const sinceIso = opts.since ?? (opts.sinceHours !== undefined
+        ? new Date(Date.now() - opts.sinceHours * 3600_000).toISOString()
+        : undefined);
+    const scanLimit = opts.historyScanLimit ?? 5000;
+    const rows = db.queryHistoryForActivity({
+        sessionId: opts.sessionId,
+        since: sinceIso,
+        until: opts.until,
+        limit: scanLimit
+    });
+    const byText = new Map();
+    for (const row of rows) {
+        for (const block of (0, database_1.parseReasoningBlocksTimed)(row.reasoning, row.created_at)) {
+            if (sinceIso && block.at < sinceIso)
+                continue;
+            if (opts.until && block.at > opts.until)
+                continue;
+            const item = { row, at: block.at, parsed: block.parsed };
+            const bucket = byText.get(block.text);
+            if (bucket)
+                bucket.push(item);
+            else
+                byText.set(block.text, [item]);
+        }
+    }
+    // Pass 2 — cut each bucket into commits wherever consecutive blocks fall more than
+    // COMMIT_CLUSTER_MS apart. The ascending sort makes `last_at` a running maximum, so the gap test
+    // only ever measures against the nearest earlier block, never the group's total span.
+    const groups = [];
+    for (const [text, items] of byText) {
+        items.sort((a, b) => a.at.localeCompare(b.at));
+        let group = null;
+        for (const item of items) {
+            if (!group || Date.parse(item.at) - Date.parse(group.last_at) > COMMIT_CLUSTER_MS) {
+                const p = item.parsed;
+                group = {
+                    session_ids: [], seenSessions: new Set(),
+                    block_text: text,
+                    developer: p.developer || null,
+                    // The closest the shared record gets to "what was asked for". The verbatim request is
+                    // local-only, so this is a substitute, not the same field — flagged in the caveats.
+                    request: p.requirement || null,
+                    summary: p.what_changed || p.why || p.goal || '(no summary recorded)',
+                    first_at: item.at,
+                    last_at: item.at,
+                    files: [], node_ids: [], seenFiles: new Set(), seenNodes: new Set(),
+                    edit_count: 0
+                };
+                groups.push(group);
+            }
+            group.last_at = item.at;
+            if (!group.seenSessions.has(item.row.session_id)) {
+                group.seenSessions.add(item.row.session_id);
+                group.session_ids.push(item.row.session_id);
+            }
+            if (!group.seenNodes.has(item.row.node_id)) {
+                group.seenNodes.add(item.row.node_id);
+                group.node_ids.push(item.row.node_id);
+            }
+            // Null when the node was hard-deleted out from under its history. Skipped rather than
+            // recorded as an empty path, but the row still counts toward edit_count: something was
+            // edited, we just can no longer say in which file.
+            if (item.row.file_path && !group.seenFiles.has(item.row.file_path)) {
+                group.seenFiles.add(item.row.file_path);
+                group.files.push(item.row.file_path);
+            }
+            group.edit_count++;
+        }
+    }
+    let entries = groups.map(g => ({
+        // Keyed on the group's start time as well as its text: two separate commits that share
+        // reasoning must not collide on one id, and `first_at` is exactly what told them apart.
+        id: graphEntryId(g.first_at, g.block_text),
+        source: 'graph',
+        session_id: g.session_ids[0],
+        session_ids: g.session_ids,
+        developer: g.developer,
+        created_at: g.first_at,
+        updated_at: g.last_at,
+        request: g.request,
+        summary: g.summary,
+        // Committed history records no revert state — that is a local-log concept. Claiming anything
+        // other than "applied" here would be invention; the caveats say so out loud.
+        status: 'applied',
+        files: g.files,
+        node_ids: g.node_ids,
+        edit_count: g.edit_count
+    }));
+    // The same predicates the local path applies, over the same fields — so a filter means the same
+    // thing regardless of which store answered.
+    if (opts.developer) {
+        const needle = opts.developer.toLowerCase();
+        entries = entries.filter(e => (e.developer ?? '').toLowerCase().includes(needle));
+    }
+    if (opts.requirementContains) {
+        const needle = opts.requirementContains.toLowerCase();
+        entries = entries.filter(e => (e.request ?? '').toLowerCase().includes(needle) || e.summary.toLowerCase().includes(needle));
+    }
+    entries.sort((a, b) => b.created_at.localeCompare(a.created_at));
+    const matched = entries.length;
+    const limited = entries.slice(0, opts.limit ?? 100);
+    const allFiles = new Set();
+    for (const e of limited)
+        for (const f of e.files)
+            allFiles.add(f);
+    return {
+        result: {
+            total_messages: limited.length,
+            total_matched: matched,
+            all_files: Array.from(allFiles),
+            entries: limited
+        },
+        scanTruncated: rows.length >= scanLimit
+    };
+}
+/**
+ * The single read path behind `get_activity_log` — picks a store, or merges both.
+ *
+ * `auto` (the default) answers from the local log and falls through to shared history only when it
+ * produced nothing. That covers the case the local-only design silently failed: a teammate on a
+ * fresh clone, or this developer on another machine.
+ *
+ * It does NOT cover the inverse, which is why `both` exists — once you have any local activity of
+ * your own, `auto` stops short and you never see a teammate's work at all. `both` is the honest
+ * team-wide view: local entries in full fidelity, plus shared history for every commit that did not
+ * happen here.
+ */
+function resolveActivityLog(db, devmindPath, mode, opts = {}) {
+    const withCaveats = (r) => r.entries.some(e => e.source === 'graph') ? { ...r, caveats: exports.GRAPH_SOURCE_CAVEATS } : r;
+    if (mode === 'local') {
+        return { ...(0, activity_1.queryActivityLog)(devmindPath, opts), source: 'local', fell_back: false };
+    }
+    if (mode === 'graph') {
+        const { result, scanTruncated } = queryGraphActivityLog(db, opts);
+        return withCaveats({ ...result, source: 'graph', fell_back: false, history_scan_truncated: scanTruncated });
+    }
+    if (mode === 'auto') {
+        const local = (0, activity_1.queryActivityLog)(devmindPath, opts);
+        if (local.entries.length > 0) {
+            return { ...local, source: 'local', fell_back: false };
+        }
+        const { result, scanTruncated } = queryGraphActivityLog(db, opts);
+        return withCaveats({ ...result, source: 'graph', fell_back: true, history_scan_truncated: scanTruncated });
+    }
+    // mode === 'both'
+    const local = (0, activity_1.queryActivityLog)(devmindPath, opts);
+    const { result: graph, scanTruncated } = queryGraphActivityLog(db, opts);
+    // Read once per call, not per entry: sessions.json can gain a row while this server is running,
+    // so it must not be cached across calls, but it also cannot change midway through one.
+    const localSessionIds = new Set((0, activity_1.readSessions)(devmindPath).map(s => s.id));
+    const me = db.getDeveloperName();
+    const foreign = graph.entries.filter(e => !isOwnWork(e, localSessionIds, me));
+    const merged = [...local.entries, ...foreign]
+        .sort((a, b) => b.created_at.localeCompare(a.created_at))
+        .slice(0, opts.limit ?? 100);
+    const allFiles = new Set();
+    for (const e of merged)
+        for (const f of e.files)
+            allFiles.add(f);
+    return withCaveats({
+        total_messages: merged.length,
+        total_matched: local.total_matched + foreign.length,
+        all_files: Array.from(allFiles),
+        entries: merged,
+        source: 'both',
+        fell_back: false,
+        history_scan_truncated: scanTruncated
+    });
+}
+/**
+ * True when a graph entry describes work that already appears in this machine's local log, and
+ * would therefore be a duplicate in a merged view.
+ *
+ * Both conditions are required, and each covers a hole the other leaves:
+ *
+ * - The session must be one of THIS machine's. Sessions are minted per machine, so a teammate's id
+ *   never collides. Checked against `sessions.json` rather than against the local entries actually
+ *   returned, because those are already narrowed by the caller's filters — a message excluded by a
+ *   date range would stop shadowing its own graph twin and the duplicate would slip through.
+ *
+ * - The developer must not be someone else. This is what the session test alone gets wrong: the
+ *   1-hour merge stamps a block with the row's ORIGINAL session, so a teammate who pulls your
+ *   history and edits the same node within the window gets their work filed under your session id.
+ *   Unlike session_id, the Developer field is written per block, so it survives the merge intact.
+ *
+ * The asymmetry is deliberate. Failing to drop a duplicate shows your own work twice, which is
+ * visible and harmless; dropping too much silently hides a teammate's commit, which is the exact
+ * failure `both` exists to fix. When the two signals disagree, keep the entry.
+ */
+function isOwnWork(entry, localSessionIds, me) {
+    const ids = entry.session_ids || [entry.session_id];
+    if (!ids.some(id => localSessionIds.has(id)))
+        return false;
+    // An unattributed entry on a local session is mine — nothing contradicts the session match.
+    if (!entry.developer)
+        return true;
+    // A NAMED developer must actually be me. Notably not "me is unknown, so assume mine": with no
+    // DEVELOPER_NAME configured there is no identity to match against, and treating every named
+    // commit on a shared session as local is how a teammate's work would disappear.
+    return !!me && entry.developer.toLowerCase() === me.toLowerCase();
+}
+//# sourceMappingURL=activity-graph.js.map

package/dist/db/activity-graph.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity-graph.js","sourceRoot":"","sources":["../../src/db/activity-graph.ts"],"names":[],"mappings":"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"}

package/dist/db/activity.d.ts

@@ -0,0 +1,221 @@
+/**
+ * The local, gitignored activity log — sessions and messages, grouped for the Activity page.
+ *
+ * Everything here lives under `.devmind/local/`, which `devsmind init` adds to `.devmind/.gitignore`
+ * (see [[cli/init.ts]]). It never gets pushed: message text is only ever meaningful on the machine
+ * that wrote it, and the point of this store is to be a working-tree time machine for one
+ * developer, not a second copy of the shared graph. Committed history in `.devmind/history/*.json`
+ * is untouched by anything in this file — a message's `edits[]` is a self-contained backup, not a
+ * reference into committed data, so revert never depends on (or corrupts) what the team shares.
+ *
+ * JSON on disk, one file per message plus one sessions index — same shape of storage as staging.ts,
+ * same atomic temp+rename write, deliberately no new SQLite tables: this data has no reason to
+ * survive a `brain.db` rebuild via anything other than being read back from these files.
+ */
+/**
+ * `'partial'` means some but not all of a message's edits are reverted — the result of reverting
+ * one file, or one single edit, within a message rather than the whole thing. Whole-message
+ * revert/un-revert (message-revert.ts) still exists and still flips every edit at once; this
+ * status is what lets the UI (and the un-revert ordering rule) tell "fully reverted" apart from
+ * "partially reverted via a more surgical action."
+ */
+export type MessageStatus = 'applied' | 'partial' | 'reverted';
+export interface MessageEdit {
+    /** Stable identity for this one edit — what a single-edit revert/un-revert targets. */
+    id: string;
+    node_id: string;
+    file_path: string;
+    at: string;
+    before: string;
+    after: string;
+    /** True once this specific edit has been reverted (via any granularity). Absent/false = applied. */
+    reverted?: boolean;
+}
+/** A message's status is derived from its edits, not tracked independently — this is the one
+ * place that mapping happens, so whole-message and granular (file/edit) revert paths can't drift
+ * out of sync with each other. */
+export declare function deriveStatus(edits: MessageEdit[]): MessageStatus;
+export interface ActivityMessage {
+    id: string;
+    session_id: string;
+    developer: string | null;
+    created_at: string;
+    updated_at: string;
+    /** The user's original request, when the caller supplied one. Null degrades to `summary` only. */
+    request: string | null;
+    /** Short machine-generated label (from the commit's reasoning), always present. */
+    summary: string;
+    status: MessageStatus;
+    edits: MessageEdit[];
+    /**
+     * Which of this message's edits have already been turned into workflow steps.
+     *
+     * Tracked as EDIT IDS rather than a "synced: true" flag because a message keeps growing after it
+     * is tagged — `recordMessage` appends edits to an existing message when consecutive commits share
+     * a request, and the revert engine rewrites `edits` in place. A boolean would permanently strand
+     * everything added after the moment it was set; a list of consumed ids means a re-sync is a true
+     * no-op and a message that grew produces a delta step.
+     */
+    workflow_sync?: {
+        workflow_id: string;
+        step_ids: string[];
+        synced_edit_ids: string[];
+    }[];
+}
+export interface ActivitySession {
+    id: string;
+    developer: string | null;
+    started_at: string;
+    last_active: string;
+    message_ids: string[];
+    /** Human-readable name for the session, set at `start_session` time. Shown on the Activity page. */
+    label?: string;
+    /**
+     * The workflow this session is currently working on, or absent/null when unbound.
+     *
+     * Deliberately LOCAL. A workflow is a shared record, but "which one am I on right now" is a
+     * property of the reader, not the thing being read — the previous design kept one global pointer
+     * that synced through git, so two sessions (or two teammates) silently took it from each other
+     * mid-work and logged their commits onto the wrong timeline.
+     */
+    workflow_id?: string | null;
+}
+/** Exported so other `.devmind/local/`-based stores (e.g. `feedback.ts`) share the same directory
+ * and gitignore convention instead of re-deriving it. */
+export declare function localDir(devmindPath: string): string;
+/**
+ * Collapse a `.gitignore` line to what git actually reads it as, so `local`, `local/`, `/local`
+ * and `/local/` all compare equal — they name the same directory. Exported because `devsmind
+ * init` tops the same file up from its own entry list, and the two must agree on "is this
+ * already ignored?": comparing raw strings meant a hand-written `local` went unrecognized and a
+ * second `local/` got appended underneath it on every run.
+ */
+export declare function normalizeIgnoreEntry(line: string): string;
+/** Exported for reuse by other `.devmind/local/` stores — see {@link localDir}. */
+export declare function ensureGitignored(devmindPath: string): void;
+export declare function readSessions(devmindPath: string): ActivitySession[];
+/**
+ * The only way a session comes into being — called by the `start_session` tool. Idempotent: calling
+ * it again with an id that already exists (a client retrying a dropped response) just no-ops rather
+ * than clobbering `started_at` or the messages already linked to it.
+ */
+export declare function createSession(devmindPath: string, sessionId: string, developer: string | null, label?: string): ActivitySession;
+/**
+ * Binds this session to a workflow, or unbinds it when `workflowId` is null.
+ *
+ * Creates the session row if it does not exist yet, mirroring `createSession`'s upsert shape — an
+ * agent can legitimately bind before its first commit has created anything.
+ */
+export declare function bindSessionWorkflow(devmindPath: string, sessionId: string, workflowId: string | null, developer?: string | null): ActivitySession;
+/** The workflow this session is bound to right now, or null. */
+export declare function readSessionWorkflow(devmindPath: string, sessionId: string): string | null;
+/**
+ * The workflow most recently worked on from this machine — what a fresh session offers to continue.
+ *
+ * Derived, not stored: the newest session that carries a binding. A separate "last workflow"
+ * field would be a second copy of a fact already recorded here, and second copies drift — which is
+ * precisely the failure the global active pointer this replaces kept producing.
+ *
+ * `excludeSessionId` skips the session asking the question, so a session that already bound itself
+ * does not get offered its own binding back as a suggestion.
+ */
+export declare function lastBoundWorkflowId(devmindPath: string, excludeSessionId?: string): string | null;
+export declare function readMessage(devmindPath: string, messageId: string): ActivityMessage | null;
+/** Every message, newest-created first — the read path for the Activity page and the CLI. */
+export declare function listMessages(devmindPath: string): ActivityMessage[];
+/**
+ * Where one activity entry was reconstructed from.
+ *
+ * `'local'` is this machine's message store — verbatim request text, per-edit before/after, and a
+ * live revert status. `'graph'` is the committed history every teammate shares, which carries less
+ * (see db/activity-graph.ts) but is the ONLY thing a fresh clone has. Reported per entry so a
+ * merged listing never leaves the caller guessing which fields are trustworthy.
+ */
+export type ActivitySource = 'local' | 'graph';
+/** One message's changes, shaped for `get_activity_log` — the per-commit "what changed" view. */
+export interface ActivityLogEntry {
+    id: string;
+    /** Always `'local'` from this file; graph-derived entries are built in db/activity-graph.ts. */
+    source: ActivitySource;
+    session_id: string;
+    /** Graph-derived entries only. Committed history stores the session that CREATED each row, not
+     * the one that wrote each block (the 1-hour merge reuses the original), so one reconstructed
+     * commit can legitimately cite more than one — `session_id` is just the first of these. Absent
+     * on local entries, where a message belongs to exactly one session. */
+    session_ids?: string[];
+    developer: string | null;
+    created_at: string;
+    updated_at: string;
+    request: string | null;
+    summary: string;
+    status: MessageStatus;
+    /** Deduped, first-touched order — every file this message touched. This is the field the old
+     * `get_developer_activity`/`get_changes_by_requirement` never carried (only `get_recent_changes`
+     * did, and only without a developer filter) — the actual gap this tool closes. */
+    files: string[];
+    /** Deduped graph node ids this message touched. */
+    node_ids: string[];
+    edit_count: number;
+}
+export interface ActivityLogResult {
+    /** How many entries this response actually carries — i.e. after `limit` was applied. */
+    total_messages: number;
+    /** How many entries MATCHED the filters, before `limit` truncated them. Without this,
+     * `total_messages` alone makes a capped result indistinguishable from a complete one — the same
+     * honesty contract `nodes_total`/`getHistoryPage().total` keep elsewhere. */
+    total_matched: number;
+    /** Every distinct file touched across ALL returned entries, flattened — "give me every file
+     * that changed" in one list, e.g. to scope a test-writing pass, without walking `entries`
+     * yourself. */
+    all_files: string[];
+    entries: ActivityLogEntry[];
+}
+/**
+ * Queries the local activity log — the one place `developer`, a time window, a specific session,
+ * AND the actual files touched all already live together (`ActivityMessage`/`MessageEdit`, see
+ * this file's module doc). This is what `get_activity_log` (MCP) wraps; it replaces three
+ * narrower, non-composable tools that each only covered one dimension: `get_recent_changes` had
+ * dates + files but no developer filter, `get_developer_activity` had a developer filter but no
+ * date range and no files, `get_changes_by_requirement` had neither dates nor files. All three
+ * filters compose here (AND'd together) since they're all just predicates over the same message
+ * list.
+ */
+export declare function queryActivityLog(devmindPath: string, opts?: {
+    /** Case-insensitive substring match against `developer`. */
+    developer?: string;
+    sessionId?: string;
+    /** Lookback window in hours — convenience for "the last N hours/days". Ignored when `since`
+     * is also given. */
+    sinceHours?: number;
+    /** ISO timestamp lower bound (inclusive) — takes priority over `sinceHours` when both given. */
+    since?: string;
+    /** ISO timestamp upper bound (inclusive). */
+    until?: string;
+    /** Case-insensitive substring match against `request` OR `summary` — the requirement/ticket
+     * lookup `get_changes_by_requirement` used to do, now against the actual verbatim user
+     * request text rather than a reasoning-block LIKE search. */
+    requirementContains?: string;
+    limit?: number;
+}): ActivityLogResult;
+export interface RecordMessageParams {
+    session_id: string;
+    developer: string | null;
+    /** Explicit continuation target — set when the caller already knows which message this extends. */
+    message_id?: string;
+    /** The user's original request text, when the caller has it. */
+    request?: string | null;
+    summary: string;
+    edits: MessageEdit[];
+}
+/**
+ * Records a commit's edits against a message, creating or continuing one.
+ *
+ * Continuation, in priority order: an explicit `message_id`; else the session's newest message,
+ * when its `request` text matches this commit's (consecutive saves for the same ask collapse into
+ * one message); else a new message. A caller with no `request` at all always gets a new message
+ * per commit — there is nothing to match on, so grouping degrades to "one message per save" rather
+ * than guessing.
+ */
+export declare function recordMessage(devmindPath: string, params: RecordMessageParams): ActivityMessage;
+/** Persists a message after its status/edits were mutated in place (by the revert engine). */
+export declare function saveMessage(devmindPath: string, message: ActivityMessage): void;