@onenomad/engram-mcp 1.1.0 → 2.0.0

package/dist/context-pressure.js

@@ -1,92 +1,92 @@
-/**
- * CONTEXT PRESSURE — self-nudge helper.
- *
- * Engram can't actually read the agent's token budget, but it can return a
- * structured checklist that reminds the agent *what* to do when context is
- * getting heavy. The agent calls this periodically (or after big tool outputs)
- * and gets back a deterministic prompt-injection telling it to write a
- * handoff note and invoke /compact.
- *
- * This exists because self-pacing compaction is a discipline problem — the
- * agent knows it should do it, but needs a loud, structured reminder.
- */
-const PLAN_OK = [
-    'No action required. Continue working.',
-    'Save any new facts, preferences, or decisions to memory_ingest as they emerge.',
-];
-const PLAN_WARM = [
-    'Save any unsaved facts/preferences/decisions to memory_ingest now — do not batch.',
-    'Update session state with current task/decisions via memory_session.',
-    'Continue working but keep tool outputs lean.',
-];
-const PLAN_HOT = [
-    'IMMEDIATELY call memory_handoff_write with a full "where we left off" snapshot.',
-    'Save unsaved facts to memory_ingest.',
-    'After the handoff is written, invoke /compact yourself — do not wait for the system.',
-];
-const PLAN_CRITICAL = [
-    'STOP all other work.',
-    'Call memory_handoff_write RIGHT NOW — reason: "context-pressure". Include currentTask, nextSteps, fileRefs, openQuestions.',
-    'Save any unsaved facts to memory_ingest.',
-    'Tell the user the context is near-full and ask permission to /compact or end the session. If no response, compact anyway — losing the handoff is worse than a surprise compact.',
-];
-// When the agent reports a natural phase boundary (task done, pivoting focus,
-// finishing a subsystem), eat the cache miss now. The pivot will thrash the
-// cache anyway — better to compact with fresh memories and a handoff in hand
-// than ride a bloated window into the next phase.
-const PLAN_PHASE_BOUNDARY = [
-    'Natural phase boundary detected. This is the right moment to compact — pivots thrash the cache anyway.',
-    'Call memory_handoff_write with reason="compact". Include currentTask (the phase just finished), completed, nextSteps (the phase about to start), fileRefs, decisions.',
-    'Save any unsaved facts from the completed phase via memory_ingest.',
-    'Invoke /compact yourself before starting the next phase. Do not carry verbose tool outputs from the finished work into the new one.',
-];
-export function assessPressure(level, reason = '', phaseBoundary = false) {
-    // Phase boundary overrides ok/warm — compact proactively regardless of level.
-    // At hot/critical the phase boundary adds urgency but the existing plan is already strict.
-    if (phaseBoundary && (level === 'ok' || level === 'warm')) {
-        return {
-            level,
-            phaseBoundary: true,
-            reason,
-            actionPlan: PLAN_PHASE_BOUNDARY,
-            reminder: 'Phase boundary. Write handoff, save memories, /compact before pivoting.',
-        };
-    }
-    switch (level) {
-        case 'ok':
-            return {
-                level,
-                phaseBoundary,
-                reason,
-                actionPlan: PLAN_OK,
-                reminder: 'Context healthy. Keep persisting memories as they emerge.',
-            };
-        case 'warm':
-            return {
-                level,
-                phaseBoundary,
-                reason,
-                actionPlan: PLAN_WARM,
-                reminder: 'Context warming. Persist memories now; keep outputs lean.',
-            };
-        case 'hot':
-            return {
-                level,
-                phaseBoundary,
-                reason,
-                actionPlan: phaseBoundary
-                    ? [...PLAN_PHASE_BOUNDARY, ...PLAN_HOT]
-                    : PLAN_HOT,
-                reminder: 'Context HOT. Write handoff note, then /compact. Do not wait.',
-            };
-        case 'critical':
-            return {
-                level,
-                phaseBoundary,
-                reason,
-                actionPlan: PLAN_CRITICAL,
-                reminder: 'CRITICAL: window near full. Write handoff NOW or lose state.',
-            };
-    }
-}
+/**
+ * CONTEXT PRESSURE — self-nudge helper.
+ *
+ * Engram can't actually read the agent's token budget, but it can return a
+ * structured checklist that reminds the agent *what* to do when context is
+ * getting heavy. The agent calls this periodically (or after big tool outputs)
+ * and gets back a deterministic prompt-injection telling it to write a
+ * handoff note and invoke /compact.
+ *
+ * This exists because self-pacing compaction is a discipline problem — the
+ * agent knows it should do it, but needs a loud, structured reminder.
+ */
+const PLAN_OK = [
+    'No action required. Continue working.',
+    'Save any new facts, preferences, or decisions to engram-ingest as they emerge.',
+];
+const PLAN_WARM = [
+    'Save any unsaved facts/preferences/decisions to engram-ingest now — do not batch.',
+    'Update session state with current task/decisions via engram-session.',
+    'Continue working but keep tool outputs lean.',
+];
+const PLAN_HOT = [
+    'IMMEDIATELY call engram-handoff-write with a full "where we left off" snapshot.',
+    'Save unsaved facts to engram-ingest.',
+    'After the handoff is written, invoke /compact yourself — do not wait for the system.',
+];
+const PLAN_CRITICAL = [
+    'STOP all other work.',
+    'Call engram-handoff-write RIGHT NOW — reason: "context-pressure". Include currentTask, nextSteps, fileRefs, openQuestions.',
+    'Save any unsaved facts to engram-ingest.',
+    'Tell the user the context is near-full and ask permission to /compact or end the session. If no response, compact anyway — losing the handoff is worse than a surprise compact.',
+];
+// When the agent reports a natural phase boundary (task done, pivoting focus,
+// finishing a subsystem), eat the cache miss now. The pivot will thrash the
+// cache anyway — better to compact with fresh memories and a handoff in hand
+// than ride a bloated window into the next phase.
+const PLAN_PHASE_BOUNDARY = [
+    'Natural phase boundary detected. This is the right moment to compact — pivots thrash the cache anyway.',
+    'Call engram-handoff-write with reason="compact". Include currentTask (the phase just finished), completed, nextSteps (the phase about to start), fileRefs, decisions.',
+    'Save any unsaved facts from the completed phase via engram-ingest.',
+    'Invoke /compact yourself before starting the next phase. Do not carry verbose tool outputs from the finished work into the new one.',
+];
+export function assessPressure(level, reason = '', phaseBoundary = false) {
+    // Phase boundary overrides ok/warm — compact proactively regardless of level.
+    // At hot/critical the phase boundary adds urgency but the existing plan is already strict.
+    if (phaseBoundary && (level === 'ok' || level === 'warm')) {
+        return {
+            level,
+            phaseBoundary: true,
+            reason,
+            actionPlan: PLAN_PHASE_BOUNDARY,
+            reminder: 'Phase boundary. Write handoff, save memories, /compact before pivoting.',
+        };
+    }
+    switch (level) {
+        case 'ok':
+            return {
+                level,
+                phaseBoundary,
+                reason,
+                actionPlan: PLAN_OK,
+                reminder: 'Context healthy. Keep persisting memories as they emerge.',
+            };
+        case 'warm':
+            return {
+                level,
+                phaseBoundary,
+                reason,
+                actionPlan: PLAN_WARM,
+                reminder: 'Context warming. Persist memories now; keep outputs lean.',
+            };
+        case 'hot':
+            return {
+                level,
+                phaseBoundary,
+                reason,
+                actionPlan: phaseBoundary
+                    ? [...PLAN_PHASE_BOUNDARY, ...PLAN_HOT]
+                    : PLAN_HOT,
+                reminder: 'Context HOT. Write handoff note, then /compact. Do not wait.',
+            };
+        case 'critical':
+            return {
+                level,
+                phaseBoundary,
+                reason,
+                actionPlan: PLAN_CRITICAL,
+                reminder: 'CRITICAL: window near full. Write handoff NOW or lose state.',
+            };
+    }
+}
 //# sourceMappingURL=context-pressure.js.map

package/dist/handoff.d.ts

@@ -1,53 +1,53 @@
-/**
- * HANDOFF NOTES — "where we left off" lifeline for cross-session continuity.
- *
- * Unlike diary entries (free-form journal) or session-state (ephemeral scratchpad),
- * handoffs are *structured* resume-from-here snapshots written immediately before
- * context compaction or session end. If the context window fills before compaction
- * runs, the user abandons the chat — the handoff is the ONLY way to continue in
- * a fresh session without re-explaining everything.
- *
- * Schema is opinionated on purpose: a fresh agent can pick up from any field
- * without hunting through prose.
- */
-export interface HandoffNote {
-    /** ISO timestamp of when this handoff was written */
-    timestamp: string;
-    /** Optional human-friendly checkpoint name (e.g. "engram-named-checkpoints"). Allows list-and-pick resume across many saved sessions. */
-    name?: string;
-    /** Session or conversation identifier */
-    sessionId: string | null;
-    /** Why the handoff was written: compact, session-end, manual, context-pressure */
-    reason: 'compact' | 'session-end' | 'manual' | 'context-pressure';
-    /** One-sentence description of the active task */
-    currentTask: string;
-    /** What's already been completed in this session */
-    completed: string[];
-    /** The very next concrete action(s) to take on resume */
-    nextSteps: string[];
-    /** Unresolved questions, blockers, or decisions awaiting user input */
-    openQuestions: string[];
-    /** File paths (ideally path:line) the next agent needs to look at */
-    fileRefs: string[];
-    /** Key decisions made this session that shape future work */
-    decisions: string[];
-    /** Anything else the next agent MUST know — hidden constraints, quirks, gotchas */
-    notes: string;
-}
-/**
- * Write a handoff note. Persists BOTH JSON (machine-readable) and markdown (human-readable).
- */
-export declare function writeHandoff(dataDir: string, note: Omit<HandoffNote, 'timestamp'>): HandoffNote;
-export declare function readHandoff(dataDir: string, identifier?: string): HandoffNote | null;
-export interface HandoffListEntry {
-    stamp: string;
-    timestamp: string;
-    reason: string;
-    currentTask: string;
-    name?: string;
-}
-/**
- * List handoff checkpoints, newest first. Includes the optional `name` so a
- * caller can present a list-and-pick UI keyed on either stamp or name.
- */
-export declare function listHandoffs(dataDir: string, limit?: number): HandoffListEntry[];
+/**
+ * HANDOFF NOTES — "where we left off" lifeline for cross-session continuity.
+ *
+ * Unlike diary entries (free-form journal) or session-state (ephemeral scratchpad),
+ * handoffs are *structured* resume-from-here snapshots written immediately before
+ * context compaction or session end. If the context window fills before compaction
+ * runs, the user abandons the chat — the handoff is the ONLY way to continue in
+ * a fresh session without re-explaining everything.
+ *
+ * Schema is opinionated on purpose: a fresh agent can pick up from any field
+ * without hunting through prose.
+ */
+export interface HandoffNote {
+    /** ISO timestamp of when this handoff was written */
+    timestamp: string;
+    /** Optional human-friendly checkpoint name (e.g. "engram-named-checkpoints"). Allows list-and-pick resume across many saved sessions. */
+    name?: string;
+    /** Session or conversation identifier */
+    sessionId: string | null;
+    /** Why the handoff was written: compact, session-end, manual, context-pressure */
+    reason: 'compact' | 'session-end' | 'manual' | 'context-pressure';
+    /** One-sentence description of the active task */
+    currentTask: string;
+    /** What's already been completed in this session */
+    completed: string[];
+    /** The very next concrete action(s) to take on resume */
+    nextSteps: string[];
+    /** Unresolved questions, blockers, or decisions awaiting user input */
+    openQuestions: string[];
+    /** File paths (ideally path:line) the next agent needs to look at */
+    fileRefs: string[];
+    /** Key decisions made this session that shape future work */
+    decisions: string[];
+    /** Anything else the next agent MUST know — hidden constraints, quirks, gotchas */
+    notes: string;
+}
+/**
+ * Write a handoff note. Persists BOTH JSON (machine-readable) and markdown (human-readable).
+ */
+export declare function writeHandoff(dataDir: string, note: Omit<HandoffNote, 'timestamp'>): HandoffNote;
+export declare function readHandoff(dataDir: string, identifier?: string): HandoffNote | null;
+export interface HandoffListEntry {
+    stamp: string;
+    timestamp: string;
+    reason: string;
+    currentTask: string;
+    name?: string;
+}
+/**
+ * List handoff checkpoints, newest first. Includes the optional `name` so a
+ * caller can present a list-and-pick UI keyed on either stamp or name.
+ */
+export declare function listHandoffs(dataDir: string, limit?: number): HandoffListEntry[];

package/dist/handoff.js

@@ -1,157 +1,157 @@
-import { readFileSync, writeFileSync, renameSync, existsSync, mkdirSync, readdirSync } from 'node:fs';
-import { join } from 'node:path';
-function handoffDir(dataDir) {
-    return join(dataDir, 'handoffs');
-}
-function stampFilename() {
-    // YYYY-MM-DD_HH-MM-SS — safe for filenames, chronologically sortable
-    return new Date().toISOString().replace(/[:.]/g, '-').replace('T', '_').split('-').slice(0, 6).join('-');
-}
-function handoffJsonPath(dataDir, stamp) {
-    return join(handoffDir(dataDir), `${stamp}.json`);
-}
-function handoffMdPath(dataDir, stamp) {
-    return join(handoffDir(dataDir), `${stamp}.md`);
-}
-/**
- * Write a handoff note. Persists BOTH JSON (machine-readable) and markdown (human-readable).
- */
-export function writeHandoff(dataDir, note) {
-    const dir = handoffDir(dataDir);
-    if (!existsSync(dir))
-        mkdirSync(dir, { recursive: true });
-    const timestamp = new Date().toISOString();
-    const full = { ...note, timestamp };
-    const stamp = stampFilename();
-    // Atomic write for the JSON+MD pair. Two non-atomic writeFileSync
-    // calls in a row could leave a JSON file with no markdown sibling
-    // (or vice versa) on crash, breaking the pairing readHandoff
-    // relies on. Stage both as .tmp first, then rename both -- minimizes
-    // the crash window to the gap between two consecutive renameSync
-    // calls (sub-millisecond). True cross-file atomicity isn't
-    // expressible in POSIX; this is the best practical approximation.
-    const jsonPath = handoffJsonPath(dataDir, stamp);
-    const mdPath = handoffMdPath(dataDir, stamp);
-    writeFileSync(`${jsonPath}.tmp`, JSON.stringify(full, null, 2), 'utf-8');
-    writeFileSync(`${mdPath}.tmp`, formatHandoffMarkdown(full), 'utf-8');
-    renameSync(`${jsonPath}.tmp`, jsonPath);
-    renameSync(`${mdPath}.tmp`, mdPath);
-    return full;
-}
-/**
- * Read the most recent handoff, or a specific one by stamp or name.
- *
- * Identifier resolution order:
- *   1. No identifier → latest timestamped handoff
- *   2. Identifier matches stamp regex → load by stamp
- *   3. Otherwise → scan handoff JSONs for `name` field match (newest match wins)
- */
-// Timestamped handoff filenames look like "2026-04-22_14-32-05-123Z" (what
-// stampFilename() produces). The rolling `session-checkpoint.json` written
-// by engram_stop_hook.sh does NOT match this shape, so it won't shadow real
-// handoffs when readHandoff() picks the latest.
-const STAMP_RE = /^\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2}/;
-export function readHandoff(dataDir, identifier) {
-    const dir = handoffDir(dataDir);
-    if (!existsSync(dir))
-        return null;
-    if (!identifier) {
-        const allJson = readdirSync(dir).filter(f => f.endsWith('.json'));
-        const timestamped = allJson.filter(f => STAMP_RE.test(f)).sort().reverse();
-        const pick = timestamped[0] ?? allJson.sort().reverse()[0];
-        if (!pick)
-            return null;
-        return loadHandoffFile(handoffJsonPath(dataDir, pick.replace(/\.json$/, '')));
-    }
-    if (STAMP_RE.test(identifier)) {
-        return loadHandoffFile(handoffJsonPath(dataDir, identifier));
-    }
-    // Name lookup — scan newest first, return first hit.
-    const stamps = readdirSync(dir)
-        .filter(f => f.endsWith('.json'))
-        .map(f => f.replace(/\.json$/, ''))
-        .sort()
-        .reverse();
-    for (const stamp of stamps) {
-        const note = loadHandoffFile(handoffJsonPath(dataDir, stamp));
-        if (note?.name === identifier)
-            return note;
-    }
-    return null;
-}
-function loadHandoffFile(path) {
-    if (!existsSync(path))
-        return null;
-    try {
-        return JSON.parse(readFileSync(path, 'utf-8'));
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * List handoff checkpoints, newest first. Includes the optional `name` so a
- * caller can present a list-and-pick UI keyed on either stamp or name.
- */
-export function listHandoffs(dataDir, limit = 10) {
-    const dir = handoffDir(dataDir);
-    if (!existsSync(dir))
-        return [];
-    const stamps = readdirSync(dir)
-        .filter(f => f.endsWith('.json'))
-        .map(f => f.replace(/\.json$/, ''))
-        .sort()
-        .reverse()
-        .slice(0, limit);
-    const results = [];
-    for (const stamp of stamps) {
-        try {
-            const note = JSON.parse(readFileSync(handoffJsonPath(dataDir, stamp), 'utf-8'));
-            results.push({
-                stamp,
-                timestamp: note.timestamp,
-                reason: note.reason,
-                currentTask: note.currentTask,
-                ...(note.name ? { name: note.name } : {}),
-            });
-        }
-        catch {
-            // Skip malformed
-        }
-    }
-    return results;
-}
-function formatHandoffMarkdown(note) {
-    const lines = [
-        `# Handoff — ${note.name ?? note.timestamp}`,
-        '',
-        note.name ? `**Name:** ${note.name}` : '',
-        `**Reason:** ${note.reason}`,
-        `**Timestamp:** ${note.timestamp}`,
-        note.sessionId ? `**Session:** ${note.sessionId}` : '',
-        '',
-        '## Current Task',
-        note.currentTask || '_unspecified_',
-        '',
-    ];
-    if (note.completed.length) {
-        lines.push('## Completed', ...note.completed.map(c => `- ${c}`), '');
-    }
-    if (note.nextSteps.length) {
-        lines.push('## Next Steps', ...note.nextSteps.map(s => `- ${s}`), '');
-    }
-    if (note.openQuestions.length) {
-        lines.push('## Open Questions', ...note.openQuestions.map(q => `- ${q}`), '');
-    }
-    if (note.fileRefs.length) {
-        lines.push('## File Refs', ...note.fileRefs.map(f => `- ${f}`), '');
-    }
-    if (note.decisions.length) {
-        lines.push('## Decisions', ...note.decisions.map(d => `- ${d}`), '');
-    }
-    if (note.notes.trim()) {
-        lines.push('## Notes', note.notes.trim(), '');
-    }
-    return lines.filter((l, i, a) => !(l === '' && a[i - 1] === '')).join('\n');
-}
+import { readFileSync, writeFileSync, renameSync, existsSync, mkdirSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+function handoffDir(dataDir) {
+    return join(dataDir, 'handoffs');
+}
+function stampFilename() {
+    // YYYY-MM-DD_HH-MM-SS — safe for filenames, chronologically sortable
+    return new Date().toISOString().replace(/[:.]/g, '-').replace('T', '_').split('-').slice(0, 6).join('-');
+}
+function handoffJsonPath(dataDir, stamp) {
+    return join(handoffDir(dataDir), `${stamp}.json`);
+}
+function handoffMdPath(dataDir, stamp) {
+    return join(handoffDir(dataDir), `${stamp}.md`);
+}
+/**
+ * Write a handoff note. Persists BOTH JSON (machine-readable) and markdown (human-readable).
+ */
+export function writeHandoff(dataDir, note) {
+    const dir = handoffDir(dataDir);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    const timestamp = new Date().toISOString();
+    const full = { ...note, timestamp };
+    const stamp = stampFilename();
+    // Atomic write for the JSON+MD pair. Two non-atomic writeFileSync
+    // calls in a row could leave a JSON file with no markdown sibling
+    // (or vice versa) on crash, breaking the pairing readHandoff
+    // relies on. Stage both as .tmp first, then rename both -- minimizes
+    // the crash window to the gap between two consecutive renameSync
+    // calls (sub-millisecond). True cross-file atomicity isn't
+    // expressible in POSIX; this is the best practical approximation.
+    const jsonPath = handoffJsonPath(dataDir, stamp);
+    const mdPath = handoffMdPath(dataDir, stamp);
+    writeFileSync(`${jsonPath}.tmp`, JSON.stringify(full, null, 2), 'utf-8');
+    writeFileSync(`${mdPath}.tmp`, formatHandoffMarkdown(full), 'utf-8');
+    renameSync(`${jsonPath}.tmp`, jsonPath);
+    renameSync(`${mdPath}.tmp`, mdPath);
+    return full;
+}
+/**
+ * Read the most recent handoff, or a specific one by stamp or name.
+ *
+ * Identifier resolution order:
+ *   1. No identifier → latest timestamped handoff
+ *   2. Identifier matches stamp regex → load by stamp
+ *   3. Otherwise → scan handoff JSONs for `name` field match (newest match wins)
+ */
+// Timestamped handoff filenames look like "2026-04-22_14-32-05-123Z" (what
+// stampFilename() produces). The rolling `session-checkpoint.json` written
+// by engram_stop_hook.sh does NOT match this shape, so it won't shadow real
+// handoffs when readHandoff() picks the latest.
+const STAMP_RE = /^\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2}/;
+export function readHandoff(dataDir, identifier) {
+    const dir = handoffDir(dataDir);
+    if (!existsSync(dir))
+        return null;
+    if (!identifier) {
+        const allJson = readdirSync(dir).filter(f => f.endsWith('.json'));
+        const timestamped = allJson.filter(f => STAMP_RE.test(f)).sort().reverse();
+        const pick = timestamped[0] ?? allJson.sort().reverse()[0];
+        if (!pick)
+            return null;
+        return loadHandoffFile(handoffJsonPath(dataDir, pick.replace(/\.json$/, '')));
+    }
+    if (STAMP_RE.test(identifier)) {
+        return loadHandoffFile(handoffJsonPath(dataDir, identifier));
+    }
+    // Name lookup — scan newest first, return first hit.
+    const stamps = readdirSync(dir)
+        .filter(f => f.endsWith('.json'))
+        .map(f => f.replace(/\.json$/, ''))
+        .sort()
+        .reverse();
+    for (const stamp of stamps) {
+        const note = loadHandoffFile(handoffJsonPath(dataDir, stamp));
+        if (note?.name === identifier)
+            return note;
+    }
+    return null;
+}
+function loadHandoffFile(path) {
+    if (!existsSync(path))
+        return null;
+    try {
+        return JSON.parse(readFileSync(path, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * List handoff checkpoints, newest first. Includes the optional `name` so a
+ * caller can present a list-and-pick UI keyed on either stamp or name.
+ */
+export function listHandoffs(dataDir, limit = 10) {
+    const dir = handoffDir(dataDir);
+    if (!existsSync(dir))
+        return [];
+    const stamps = readdirSync(dir)
+        .filter(f => f.endsWith('.json'))
+        .map(f => f.replace(/\.json$/, ''))
+        .sort()
+        .reverse()
+        .slice(0, limit);
+    const results = [];
+    for (const stamp of stamps) {
+        try {
+            const note = JSON.parse(readFileSync(handoffJsonPath(dataDir, stamp), 'utf-8'));
+            results.push({
+                stamp,
+                timestamp: note.timestamp,
+                reason: note.reason,
+                currentTask: note.currentTask,
+                ...(note.name ? { name: note.name } : {}),
+            });
+        }
+        catch {
+            // Skip malformed
+        }
+    }
+    return results;
+}
+function formatHandoffMarkdown(note) {
+    const lines = [
+        `# Handoff — ${note.name ?? note.timestamp}`,
+        '',
+        note.name ? `**Name:** ${note.name}` : '',
+        `**Reason:** ${note.reason}`,
+        `**Timestamp:** ${note.timestamp}`,
+        note.sessionId ? `**Session:** ${note.sessionId}` : '',
+        '',
+        '## Current Task',
+        note.currentTask || '_unspecified_',
+        '',
+    ];
+    if (note.completed.length) {
+        lines.push('## Completed', ...note.completed.map(c => `- ${c}`), '');
+    }
+    if (note.nextSteps.length) {
+        lines.push('## Next Steps', ...note.nextSteps.map(s => `- ${s}`), '');
+    }
+    if (note.openQuestions.length) {
+        lines.push('## Open Questions', ...note.openQuestions.map(q => `- ${q}`), '');
+    }
+    if (note.fileRefs.length) {
+        lines.push('## File Refs', ...note.fileRefs.map(f => `- ${f}`), '');
+    }
+    if (note.decisions.length) {
+        lines.push('## Decisions', ...note.decisions.map(d => `- ${d}`), '');
+    }
+    if (note.notes.trim()) {
+        lines.push('## Notes', note.notes.trim(), '');
+    }
+    return lines.filter((l, i, a) => !(l === '' && a[i - 1] === '')).join('\n');
+}
 //# sourceMappingURL=handoff.js.map