clementine-agent 1.18.27 → 1.18.29

package/dist/cli/dashboard.js

@@ -7044,6 +7044,93 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
             res.status(500).json({ error: String(err) });
         }
     });
+    // Commitments — durable promises tracked across sessions.
+    app.get('/api/memory/commitments', async (req, res) => {
+        try {
+            const gateway = await getGateway();
+            const store = gateway.assistant?.memoryStore;
+            if (!store || typeof store.listCommitments !== 'function') {
+                res.status(503).json({ error: 'Commitments store not available' });
+                return;
+            }
+            const status = req.query.status ? String(req.query.status) : 'open';
+            const owner = req.query.owner ? String(req.query.owner) : undefined;
+            const overdueOnly = String(req.query.overdueOnly ?? '') === '1';
+            const limit = Math.min(parseInt(String(req.query.limit ?? '50'), 10) || 50, 500);
+            const commitments = store.listCommitments({
+                status: ['open', 'done', 'cancelled'].includes(status) ? status : 'open',
+                owner: owner === 'user' || owner === 'clementine' ? owner : undefined,
+                overdueOnly,
+                limit,
+            });
+            res.json({ ok: true, commitments });
+        }
+        catch (err) {
+            res.status(500).json({ error: String(err) });
+        }
+    });
+    app.post('/api/memory/commitments/action', async (req, res) => {
+        try {
+            const gateway = await getGateway();
+            const store = gateway.assistant?.memoryStore;
+            if (!store || typeof store.updateCommitmentStatus !== 'function') {
+                res.status(503).json({ error: 'Commitments store not available' });
+                return;
+            }
+            const id = Number(req.body?.id);
+            const action = String(req.body?.action ?? '');
+            if (!Number.isInteger(id) || id <= 0) {
+                res.status(400).json({ error: 'id required' });
+                return;
+            }
+            let updated = false;
+            if (action === 'done' || action === 'cancelled' || action === 'reopen') {
+                updated = store.updateCommitmentStatus(id, { status: action === 'reopen' ? 'open' : action });
+            }
+            else if (action === 'snooze') {
+                const hours = Number(req.body?.hours ?? 24);
+                const until = new Date(Date.now() + Math.max(1, hours) * 3600_000).toISOString();
+                updated = store.updateCommitmentStatus(id, { snoozeUntilIso: until });
+            }
+            else {
+                res.status(400).json({ error: 'invalid action' });
+                return;
+            }
+            res.json({ ok: updated });
+        }
+        catch (err) {
+            res.status(500).json({ error: String(err) });
+        }
+    });
+    // Recent episodes — durable consolidated session summaries.
+    app.get('/api/memory/episodes', async (req, res) => {
+        try {
+            const gateway = await getGateway();
+            const store = gateway.assistant?.memoryStore;
+            if (!store || typeof store.listRecentEpisodes !== 'function') {
+                res.status(503).json({ error: 'Episodes store not available' });
+                return;
+            }
+            const limit = Math.min(parseInt(String(req.query.limit ?? '30'), 10) || 30, 200);
+            const sessionKey = req.query.session ? String(req.query.session) : undefined;
+            const sinceParam = req.query.since ? String(req.query.since) : '';
+            // since: '24h' | '7d' | '30d' | '' (all) | ISO string
+            let sinceIso;
+            if (sinceParam === '24h')
+                sinceIso = new Date(Date.now() - 24 * 3600_000).toISOString();
+            else if (sinceParam === '7d')
+                sinceIso = new Date(Date.now() - 7 * 24 * 3600_000).toISOString();
+            else if (sinceParam === '30d')
+                sinceIso = new Date(Date.now() - 30 * 24 * 3600_000).toISOString();
+            else if (sinceParam)
+                sinceIso = sinceParam;
+            const episodes = store.listRecentEpisodes({ limit, sessionKey, sinceIso });
+            res.json({ ok: true, episodes });
+        }
+        catch (err) {
+            res.status(500).json({ error: String(err) });
+        }
+    });
     // Coverage + recall telemetry for both chunks and transcripts. Powers the
     // Memory Coverage card showing whether dense recall is actually earning its
     // keep on the current corpus.
@@ -14998,6 +15085,39 @@ if('serviceWorker' in navigator){navigator.serviceWorker.getRegistrations().then
                 <div class="skel-block" style="padding:14px"><div class="skel-row med"></div><div class="skel-row short"></div></div>
               </div>
             </div>
+            <div class="card" style="margin-bottom:14px">
+              <div class="card-header" style="display:flex;align-items:center;justify-content:space-between;gap:8px;flex-wrap:wrap">
+                <span>Open commitments</span>
+                <div style="display:flex;align-items:center;gap:8px">
+                  <select id="commitments-filter-status" onchange="refreshCommitments()" style="font-size:12px;padding:4px 6px;border:1px solid var(--border);border-radius:4px;background:var(--bg-input);color:var(--text)">
+                    <option value="open" selected>Open</option>
+                    <option value="done">Done</option>
+                    <option value="cancelled">Cancelled</option>
+                  </select>
+                  <span style="font-size:11px;color:var(--text-muted)">Promises tracked across sessions</span>
+                </div>
+              </div>
+              <div class="card-body" id="panel-commitments" style="padding:0">
+                <div class="skel-block" style="padding:14px"><div class="skel-row med"></div><div class="skel-row short"></div></div>
+              </div>
+            </div>
+            <div class="card" style="margin-bottom:14px">
+              <div class="card-header" style="display:flex;align-items:center;justify-content:space-between;gap:8px;flex-wrap:wrap">
+                <span>Recent episodes</span>
+                <div style="display:flex;align-items:center;gap:8px">
+                  <select id="episodes-filter-since" onchange="refreshRecentEpisodes()" style="font-size:12px;padding:4px 6px;border:1px solid var(--border);border-radius:4px;background:var(--bg-input);color:var(--text)">
+                    <option value="24h">Last 24h</option>
+                    <option value="7d" selected>Last 7d</option>
+                    <option value="30d">Last 30d</option>
+                    <option value="">All</option>
+                  </select>
+                  <span style="font-size:11px;color:var(--text-muted)">Consolidated session summaries</span>
+                </div>
+              </div>
+              <div class="card-body" id="panel-recent-episodes" style="padding:0">
+                <div class="skel-block" style="padding:14px"><div class="skel-row med"></div><div class="skel-row short"></div></div>
+              </div>
+            </div>
             <div class="card">
               <div class="card-header" style="display:flex;align-items:center;justify-content:space-between">
                 <span>Self-correction (supersedes)</span>
@@ -18508,6 +18628,8 @@ function switchTab(group, tab) {
       // Consolidated Memory tab: search results + stats + MEMORY.md + recent writes + supersedes + coverage strip.
       refreshMemory();
       if (typeof refreshRecentWrites === 'function') refreshRecentWrites();
+      if (typeof refreshRecentEpisodes === 'function') refreshRecentEpisodes();
+      if (typeof refreshCommitments === 'function') refreshCommitments();
       if (typeof refreshSupersedes === 'function') refreshSupersedes();
       if (typeof refreshCoverageStrip === 'function') refreshCoverageStrip();
     }
@@ -24865,6 +24987,8 @@ async function submitQuickAddMemory() {
     setTimeout(function() {
       closeQuickAddMemory();
       if (typeof refreshRecentWrites === 'function') refreshRecentWrites();
+      if (typeof refreshRecentEpisodes === 'function') refreshRecentEpisodes();
+      if (typeof refreshCommitments === 'function') refreshCommitments();
       if (typeof refreshMemory === 'function') refreshMemory();
     }, 600);
   } catch (err) {
@@ -25018,6 +25142,133 @@ async function refreshRecentWrites() {
   }
 }
 
+async function refreshCommitments() {
+  var el = document.getElementById('panel-commitments');
+  if (!el) return;
+  try {
+    var sel = document.getElementById('commitments-filter-status');
+    var status = sel ? sel.value : 'open';
+    var r = await apiFetch('/api/memory/commitments?limit=50&status=' + encodeURIComponent(status));
+    var d = await r.json();
+    if (!d.ok || !Array.isArray(d.commitments)) {
+      el.innerHTML = '<div class="empty-state" style="padding:14px">' + esc(d.error || 'No data') + '</div>';
+      return;
+    }
+    if (d.commitments.length === 0) {
+      el.innerHTML = '<div class="empty-state" style="padding:14px">No commitments. They land automatically when you say things like "I\\'ll fix that tomorrow" or "remind me to call them Friday".</div>';
+      return;
+    }
+    var html = '<table class="data-table" style="width:100%">';
+    html += '<thead><tr>'
+      + '<th style="width:80px">Owner</th>'
+      + '<th>Promise</th>'
+      + '<th style="width:140px">Due</th>'
+      + '<th style="width:100px">Source</th>'
+      + '<th style="width:200px">Actions</th>'
+      + '</tr></thead><tbody>';
+    var nowMs = Date.now();
+    for (var i = 0; i < d.commitments.length; i++) {
+      var c = d.commitments[i];
+      var ownerLabel = c.owner === 'clementine' ? 'I' : 'You';
+      var ownerColor = c.owner === 'clementine' ? '#a78bfa' : '#10b981';
+      var dueText = '—';
+      var dueColor = 'var(--text-muted)';
+      if (c.dueAt) {
+        try {
+          var dueMs = new Date(c.dueAt).getTime();
+          var deltaMs = dueMs - nowMs;
+          dueText = new Date(c.dueAt).toLocaleString();
+          if (deltaMs < 0) { dueText = 'OVERDUE — ' + dueText; dueColor = '#ef4444'; }
+          else if (deltaMs < 86_400_000) { dueColor = '#f59e0b'; }
+        } catch { dueText = c.dueAt; }
+      } else if (c.dueHint) {
+        dueText = c.dueHint;
+      }
+      var actions = '';
+      if (c.status === 'open') {
+        actions = '<button class="btn-sm" onclick="commitmentAction(' + c.id + ', \\'done\\')">Done</button>'
+          + ' <button class="btn-sm" onclick="commitmentAction(' + c.id + ', \\'snooze\\', 24)" title="Snooze 24h">Snooze</button>'
+          + ' <button class="btn-sm" onclick="commitmentAction(' + c.id + ', \\'cancelled\\')">Cancel</button>';
+      } else {
+        actions = '<button class="btn-sm" onclick="commitmentAction(' + c.id + ', \\'reopen\\')">Reopen</button>';
+      }
+      html += '<tr>'
+        + '<td style="font-size:11px;color:' + ownerColor + ';font-weight:600">' + ownerLabel + '</td>'
+        + '<td style="font-size:12px">' + esc(c.text) + '</td>'
+        + '<td style="font-size:11px;color:' + dueColor + '">' + esc(dueText) + '</td>'
+        + '<td style="font-size:11px;color:var(--text-muted)">' + esc(c.source) + '</td>'
+        + '<td>' + actions + '</td>'
+        + '</tr>';
+    }
+    html += '</tbody></table>';
+    el.innerHTML = html;
+  } catch (err) {
+    el.innerHTML = '<div class="empty-state" style="padding:14px">Failed to load: ' + esc(String(err)) + '</div>';
+  }
+}
+
+async function commitmentAction(id, action, hours) {
+  try {
+    var body = { id: id, action: action };
+    if (hours) body.hours = hours;
+    var r = await apiJson('POST', '/api/memory/commitments/action', body);
+    if (r.error) { toast('Action failed: ' + r.error, 'error'); return; }
+    toast('Commitment ' + action, 'success');
+    refreshCommitments();
+  } catch (err) {
+    toast('Failed: ' + String(err), 'error');
+  }
+}
+
+async function refreshRecentEpisodes() {
+  var el = document.getElementById('panel-recent-episodes');
+  if (!el) return;
+  try {
+    var sel = document.getElementById('episodes-filter-since');
+    var since = sel ? sel.value : '7d';
+    var url = '/api/memory/episodes?limit=30' + (since ? '&since=' + encodeURIComponent(since) : '');
+    var r = await apiFetch(url);
+    var d = await r.json();
+    if (!d.ok || !Array.isArray(d.episodes)) {
+      el.innerHTML = '<div class="empty-state" style="padding:14px">' + esc(d.error || 'No data') + '</div>';
+      return;
+    }
+    if (d.episodes.length === 0) {
+      el.innerHTML = '<div class="empty-state" style="padding:14px">No episodes yet. They land automatically when a session has been idle for ~20 min with at least 3 exchanges.</div>';
+      return;
+    }
+    var html = '<table class="data-table" style="width:100%">';
+    html += '<thead><tr>'
+      + '<th style="width:120px">When</th>'
+      + '<th style="width:160px">Session</th>'
+      + '<th>Summary</th>'
+      + '<th style="width:140px">Topics</th>'
+      + '<th style="width:120px">Outcome</th>'
+      + '<th style="width:50px;text-align:right">Open</th>'
+      + '</tr></thead><tbody>';
+    for (var i = 0; i < d.episodes.length; i++) {
+      var ep = d.episodes[i];
+      var when = '';
+      try { when = new Date(ep.createdAt + 'Z').toLocaleString(); } catch { when = ep.createdAt; }
+      var topics = (ep.topics || []).slice(0, 3).map(esc).join(', ');
+      var openCount = (ep.openLoops || []).length;
+      var openColor = openCount > 0 ? '#f59e0b' : 'var(--text-muted)';
+      html += '<tr>'
+        + '<td style="font-size:11px;color:var(--text-muted)">' + esc(when) + '</td>'
+        + '<td style="font-size:11px">' + esc(ep.sessionKey) + '</td>'
+        + '<td style="font-size:12px">' + esc(ep.summary) + '</td>'
+        + '<td style="font-size:11px;color:var(--text-muted)">' + (topics || '—') + '</td>'
+        + '<td style="font-size:11px">' + esc(ep.outcome || '—') + '</td>'
+        + '<td style="text-align:right;font-weight:600;color:' + openColor + '">' + openCount + '</td>'
+        + '</tr>';
+    }
+    html += '</tbody></table>';
+    el.innerHTML = html;
+  } catch (err) {
+    el.innerHTML = '<div class="empty-state" style="padding:14px">Failed to load: ' + esc(String(err)) + '</div>';
+  }
+}
+
 async function memoryHealthAction(action, extra) {
   var labels = { 'janitor': 'cleanup', 'rebuild-fts': 'FTS rebuild', 'fix-orphans': 'orphan fix', 'install-dense-model': 'local embedding model install/verify', 'reembed-dense': 'dense embedding backfill' };
   if (!confirm('Run ' + (labels[action] || action) + ' now?')) return;

package/dist/gateway/active-context.d.ts

@@ -7,7 +7,7 @@
  * run logs into the model.
  */
 export interface ActiveContextItem {
-    source: 'notification' | 'background-task' | 'unleashed' | 'turn-ledger';
+    source: 'notification' | 'background-task' | 'unleashed' | 'turn-ledger' | 'commitment';
     label: string;
     detail: string;
     priority: number;
@@ -39,6 +39,19 @@ export interface ActiveContextOptions {
         embedded: number;
         total: number;
     };
+    /**
+     * Open commitments tied to this session (or owner-wide). Caller looks
+     * these up via store.listCommitments and threads them through so
+     * active-context.ts stays free of the store dependency.
+     */
+    openCommitments?: Array<{
+        id: number;
+        owner: 'user' | 'clementine';
+        text: string;
+        dueAt: string | null;
+        dueHint: string | null;
+        sessionKey: string | null;
+    }>;
 }
 export declare function buildActiveContextSnapshot(sessionKey: string, opts: ActiveContextOptions): ActiveContextSnapshot;
 //# sourceMappingURL=active-context.d.ts.map

package/dist/gateway/active-context.js

@@ -271,6 +271,36 @@ function turnLedgerItems(surfaceHistory) {
         greetingEligible: false,
     }));
 }
+function commitmentItems(opts) {
+    const list = opts.openCommitments ?? [];
+    if (list.length === 0)
+        return [];
+    const nowMs = opts.now ?? Date.now();
+    const dayMs = 24 * 60 * 60 * 1000;
+    return list.slice(0, 10).map((c) => {
+        const dueMs = c.dueAt ? Date.parse(c.dueAt) : NaN;
+        const overdue = Number.isFinite(dueMs) && dueMs < nowMs;
+        const dueWithin24 = Number.isFinite(dueMs) && dueMs >= nowMs && dueMs - nowMs <= dayMs;
+        let priority = 60;
+        if (overdue)
+            priority = 90;
+        else if (dueWithin24)
+            priority = 80;
+        else if (c.dueHint)
+            priority = 70;
+        const ownerLabel = c.owner === 'clementine' ? 'I committed' : 'You committed';
+        const dueLabel = overdue ? ' (overdue)' : dueWithin24 ? ' (due within 24h)' : c.dueHint ? ` (${c.dueHint})` : '';
+        return {
+            source: 'commitment',
+            label: `${ownerLabel}${dueLabel}`,
+            detail: cap(c.text),
+            priority,
+            timestamp: c.dueAt ?? undefined,
+            sourceId: `commitment:${c.id}`,
+            greetingEligible: overdue || dueWithin24,
+        };
+    });
+}
 function formatPromptBlock(items, coverage) {
     if (items.length === 0)
         return null;
@@ -312,6 +342,7 @@ export function buildActiveContextSnapshot(sessionKey, opts) {
         ...notificationItems(sessionKey, opts),
         ...unleashedItems(opts, surfaceHistory),
         ...turnLedgerItems(surfaceHistory),
+        ...commitmentItems(opts),
     ]
         .sort((a, b) => {
         const priority = b.priority - a.priority;

package/dist/gateway/commitments.d.ts

@@ -0,0 +1,38 @@
+import type { MemoryStore } from '../memory/store.js';
+export type CommitmentOwner = 'user' | 'clementine';
+export interface DetectedCommitment {
+    text: string;
+    owner: CommitmentOwner;
+    dueHint?: string;
+    dueAt?: string;
+}
+export declare function fingerprintCommitment(sessionKey: string, owner: CommitmentOwner, normalizedText: string): string;
+/**
+ * Parse a relative date phrase into an ISO datetime. Returns null when the
+ * phrase isn't recognized; callers fall back to storing the raw `dueHint`
+ * so the model still sees the deadline. Default time-of-day for date-only
+ * phrases is 17:00 local (5pm) — close enough for "by Friday" semantics
+ * without forcing the user to be precise.
+ */
+export declare function parseRelativeDue(phrase: string, now?: Date): string | null;
+/**
+ * Scan a single turn for commitment phrases. Returns at most one commitment
+ * per turn — the first strong match wins. Returning multiple per turn is
+ * possible but tends to over-fire; we'd rather miss one and let the LLM
+ * extractor catch it during consolidation.
+ */
+export declare function detectCommitmentInTurn(text: string, role: string): DetectedCommitment | null;
+/**
+ * Persist a detected commitment via the store, deduping on a stable
+ * fingerprint. Designed to be called from the chat path; failures are
+ * swallowed because commitment recording must never break a turn.
+ */
+export declare function recordDetectedCommitment(store: MemoryStore, sessionKey: string, detected: DetectedCommitment, meta: {
+    source: string;
+    transcriptId?: number;
+    episodeId?: number;
+}): {
+    id: number;
+    created: boolean;
+} | null;
+//# sourceMappingURL=commitments.d.ts.map

package/dist/gateway/commitments.js

@@ -0,0 +1,172 @@
+/**
+ * Commitments — first-class promises ("I'll fix the dashboard tomorrow",
+ * "remind me to call them Friday"). Lives alongside conversation-learning
+ * but tracks durable, actionable items that need surfacing in greetings
+ * until they're done or cancelled.
+ *
+ * Two ingest paths share a fingerprint-based dedupe so the same promise
+ * never gets recorded twice:
+ *
+ *   1. Per-turn regex detector (this file) — runs synchronously on user
+ *      and assistant turns. High-precision: matches obvious phrasings only,
+ *      to avoid spamming on every "I'll think about it" pleasantry.
+ *
+ *   2. LLM extraction during episodic consolidation — catches multi-turn
+ *      and implicit commitments the regex misses. Runs after the session
+ *      has been idle, so it sees the full context.
+ *
+ * Date parsing is intentionally tiny — we recognize common phrases
+ * ("tomorrow", "by Friday", "in 3 days", "next week") without pulling in
+ * a chrono dep. Anything we can't parse stays as `dueHint` text and is
+ * still surfaceable; it just doesn't drive overdue prioritization.
+ */
+import { createHash } from 'node:crypto';
+export function fingerprintCommitment(sessionKey, owner, normalizedText) {
+    const key = `${sessionKey}|${owner}|${normalizedText}`;
+    return createHash('sha1').update(key).digest('hex').slice(0, 16);
+}
+function normalizeText(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^\p{L}\p{N}]+/gu, ' ')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .slice(0, 200);
+}
+const DAYS = ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday'];
+/**
+ * Parse a relative date phrase into an ISO datetime. Returns null when the
+ * phrase isn't recognized; callers fall back to storing the raw `dueHint`
+ * so the model still sees the deadline. Default time-of-day for date-only
+ * phrases is 17:00 local (5pm) — close enough for "by Friday" semantics
+ * without forcing the user to be precise.
+ */
+export function parseRelativeDue(phrase, now = new Date()) {
+    if (!phrase)
+        return null;
+    const text = phrase.toLowerCase().trim();
+    const today = new Date(now.getFullYear(), now.getMonth(), now.getDate(), 17, 0, 0, 0);
+    if (/^today$/.test(text) || /\bby today\b/.test(text) || /\bend of (?:the )?day\b/.test(text) || /\beod\b/.test(text)) {
+        return today.toISOString();
+    }
+    if (/^tomorrow$|by tomorrow|tomorrow morning|tomorrow night|tomorrow evening/.test(text)) {
+        const d = new Date(today);
+        d.setDate(d.getDate() + 1);
+        return d.toISOString();
+    }
+    if (/\bnext week\b/.test(text)) {
+        const d = new Date(today);
+        d.setDate(d.getDate() + 7);
+        return d.toISOString();
+    }
+    if (/\bend of (?:the )?week\b/.test(text)) {
+        const d = new Date(today);
+        const daysToFri = (5 - d.getDay() + 7) % 7;
+        d.setDate(d.getDate() + (daysToFri === 0 ? 0 : daysToFri));
+        return d.toISOString();
+    }
+    const inN = text.match(/\bin (\d+) (day|days|week|weeks|hour|hours)\b/);
+    if (inN) {
+        const n = parseInt(inN[1], 10);
+        const unit = inN[2];
+        const d = new Date(now);
+        if (unit.startsWith('hour'))
+            d.setHours(d.getHours() + n);
+        else if (unit.startsWith('week'))
+            d.setDate(d.getDate() + 7 * n);
+        else
+            d.setDate(d.getDate() + n);
+        return d.toISOString();
+    }
+    for (let i = 0; i < DAYS.length; i++) {
+        const re = new RegExp(`\\b(?:by |on )?${DAYS[i]}\\b`);
+        if (re.test(text)) {
+            const d = new Date(today);
+            const delta = (i - d.getDay() + 7) % 7;
+            d.setDate(d.getDate() + (delta === 0 ? 7 : delta));
+            return d.toISOString();
+        }
+    }
+    return null;
+}
+/**
+ * Match phrases that signal a real promise. We're deliberately strict:
+ * "I'll think about it", "I'll see what I can do", and other hedges are
+ * not commitments. We require an action verb after "I'll/I will" and a
+ * recognizable object phrase, OR an explicit "remind me to" / "by [day]".
+ */
+const STRONG_USER_PATTERNS = [
+    // "I'll fix that tomorrow", "I'll send the doc by Friday"
+    /\bi(?:'| wi)ll\s+(?!think|see|try)([a-z][a-z'-]*\s+(?:[\w'-]+\s+){0,8}[\w'-]+)/i,
+    // "I need to ship this by Friday"
+    /\bi need to\s+([\w'-]+(?:\s+[\w'-]+){1,10})/i,
+    // "remind me to email them tomorrow"
+    /\bremind me to\s+([\w'-]+(?:\s+[\w'-]+){1,10})/i,
+    // "I should follow up Friday"
+    /\bi should\s+([\w'-]+(?:\s+[\w'-]+){1,10})/i,
+];
+const STRONG_ASSISTANT_PATTERNS = [
+    // "I'll fix that tonight" — Clementine self-committing.
+    /\bi(?:'| wi)ll\s+(?!think|see|try|let)([a-z][a-z'-]*\s+(?:[\w'-]+\s+){0,8}[\w'-]+)/i,
+];
+const DUE_HINT_RE = /\b(today|tomorrow|next week|end of (?:the )?week|end of day|eod|by (?:the )?(?:end of (?:the )?(?:day|week)|monday|tuesday|wednesday|thursday|friday|saturday|sunday|tomorrow|today|next week)|on (?:monday|tuesday|wednesday|thursday|friday|saturday|sunday)|in \d+ (?:day|days|week|weeks|hour|hours))\b/i;
+/**
+ * Scan a single turn for commitment phrases. Returns at most one commitment
+ * per turn — the first strong match wins. Returning multiple per turn is
+ * possible but tends to over-fire; we'd rather miss one and let the LLM
+ * extractor catch it during consolidation.
+ */
+export function detectCommitmentInTurn(text, role) {
+    if (!text || text.length < 8)
+        return null;
+    const isAssistant = role === 'assistant';
+    const patterns = isAssistant ? STRONG_ASSISTANT_PATTERNS : STRONG_USER_PATTERNS;
+    let matchedAction = null;
+    for (const pat of patterns) {
+        const m = text.match(pat);
+        if (m && m[1]) {
+            matchedAction = m[0].trim();
+            break;
+        }
+    }
+    if (!matchedAction)
+        return null;
+    // Truncate the surrounding sentence so the commitment text stays tight.
+    // Strip punctuation noise but keep the original case for the saved text.
+    const sentence = (text.match(new RegExp(`[^.!?\\n]*${matchedAction.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}[^.!?\\n]*`, 'i')) ?? [matchedAction])[0].trim();
+    const cleaned = sentence.replace(/\s+/g, ' ').slice(0, 220);
+    const hintMatch = cleaned.match(DUE_HINT_RE);
+    const dueHint = hintMatch ? hintMatch[0] : undefined;
+    const dueAt = dueHint ? parseRelativeDue(dueHint) ?? undefined : undefined;
+    return {
+        text: cleaned,
+        owner: isAssistant ? 'clementine' : 'user',
+        dueHint,
+        dueAt,
+    };
+}
+/**
+ * Persist a detected commitment via the store, deduping on a stable
+ * fingerprint. Designed to be called from the chat path; failures are
+ * swallowed because commitment recording must never break a turn.
+ */
+export function recordDetectedCommitment(store, sessionKey, detected, meta) {
+    try {
+        const fingerprint = fingerprintCommitment(sessionKey, detected.owner, normalizeText(detected.text));
+        return store.upsertCommitment({
+            fingerprint,
+            source: meta.source,
+            owner: detected.owner,
+            text: detected.text,
+            sessionKey,
+            transcriptId: meta.transcriptId ?? null,
+            episodeId: meta.episodeId ?? null,
+            dueAt: detected.dueAt ?? null,
+            dueHint: detected.dueHint ?? null,
+        });
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=commitments.js.map

package/dist/gateway/episodic-consolidation.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Episodic consolidation — turn raw transcript ranges into durable, indexed
+ * episodes that hybrid recall can surface across sessions.
+ *
+ * Why not just keep transcripts? Transcripts are noisy and minute-grained.
+ * "What did we decide about auth?" should match a clean summary of the
+ * decision, not the eight messages where we worked toward it. Episodes
+ * compress a session range into {summary, topics, entities, outcome,
+ * openLoops}, persist that to the episodes table, and also write the
+ * summary into chunks so PR-1's hybrid recall picks them up automatically.
+ *
+ * The pass is driven by the heartbeat: every few minutes we look for
+ * sessions that have been idle for ≥20 min with ≥3 new exchanges and
+ * consolidate up to a small bounded number per pass to keep LLM cost
+ * predictable.
+ */
+import Anthropic from '@anthropic-ai/sdk';
+import type { MemoryStore } from '../memory/store.js';
+import { type CommitmentOwner } from './commitments.js';
+export interface EpisodicConsolidationOptions {
+    /** Minutes of inactivity before a session becomes consolidation-eligible. */
+    idleMinutes?: number;
+    /** Minimum turns since last cursor for a session to qualify. */
+    minExchanges?: number;
+    /** Cap LLM calls per pass to bound cost. */
+    maxSessionsPerPass?: number;
+    /** How long to back off after a consolidation failure for a session. */
+    failBackoffMinutes?: number;
+    /** Override Anthropic client (used by tests). */
+    anthropicClient?: Pick<Anthropic, 'messages'>;
+    /** Override the model id (used by tests). */
+    model?: string;
+    /** Wallclock now() — used by tests for deterministic timestamps. */
+    now?: () => Date;
+}
+export interface ExtractedCommitment {
+    text: string;
+    owner: CommitmentOwner;
+    dueHint?: string;
+}
+export interface EpisodeExtraction {
+    summary: string;
+    topics: string[];
+    entities: string[];
+    outcome: string;
+    openLoops: string[];
+    commitments: ExtractedCommitment[];
+}
+interface CandidateRow {
+    sessionKey: string;
+    startTranscriptId: number;
+    endTranscriptId: number;
+    startedAt: string;
+    endedAt: string;
+    exchanges: number;
+}
+export interface ConsolidationPassResult {
+    consolidated: number;
+    failed: number;
+    skipped: number;
+    candidates: number;
+}
+/** Parse the model's output as JSON, tolerating leading/trailing whitespace and
+ *  occasional code fences. Returns null on any structural problem. */
+export declare function parseEpisodeJson(raw: string): EpisodeExtraction | null;
+/**
+ * Consolidate a single candidate session range. Returns the new episode id
+ * + chunk id on success, or null on failure (the caller bumps the failure
+ * cursor so we don't retry every tick).
+ */
+export declare function consolidateOneSession(store: MemoryStore, candidate: CandidateRow, opts?: EpisodicConsolidationOptions): Promise<{
+    episodeId: number;
+    chunkId: number | null;
+} | null>;
+/**
+ * Run one bounded consolidation pass. Designed to be called from the
+ * heartbeat tick — quick to no-op when nothing's eligible, capped at
+ * `maxSessionsPerPass` LLM calls when work exists.
+ */
+export declare function runEpisodicConsolidationPass(store: MemoryStore, opts?: EpisodicConsolidationOptions): Promise<ConsolidationPassResult>;
+export {};
+//# sourceMappingURL=episodic-consolidation.d.ts.map