memoir-cli 3.6.0 → 3.7.1

package/src/commands/session.js

@@ -0,0 +1,188 @@
+// CLI commands for the session continuity feature.
+//   memoir goal "..."      — set current goal
+//   memoir next "..."      — add a next action
+//   memoir done "..."      — mark a next action complete (removes it)
+//   memoir note "..."      — record a decision (supports --why and --rejected)
+//   memoir ask "..."       — capture an open question
+//   memoir session         — show current session state
+//   memoir session clear   — wipe current (history retained)
+//
+// Every mutator re-renders the pinned block into ~/.claude/CLAUDE.md so Claude
+// picks it up at the next session start.
+
+import chalk from 'chalk';
+import boxen from 'boxen';
+import gradient from 'gradient-string';
+import {
+  readSession,
+  writeSession,
+  addGoal,
+  addNext,
+  completeNext,
+  addNote,
+  addQuestion,
+  getMachineId,
+  paths,
+} from '../session/state.js';
+import { renderSession } from '../session/render.js';
+import { injectInto, detectAvailableTargets } from '../session/inject.js';
+
+// Render + inject into every detected tool. Best-effort; if a tool isn't
+// installed, we just skip it silently (detectAvailableTargets filters).
+async function refreshPinned() {
+  const state = await readSession();
+  const rendered = renderSession(state);
+  const targets = detectAvailableTargets();
+  const updated = [];
+  for (const target of Object.values(targets)) {
+    try {
+      const res = await injectInto(target, rendered);
+      updated.push(res.path);
+    } catch {
+      // Target not writable — skip silently.
+    }
+  }
+  return { state, rendered, updated };
+}
+
+export async function goalCommand(text) {
+  if (!text || !String(text).trim()) {
+    console.log(chalk.yellow('\nUsage: ') + chalk.cyan('memoir goal "your current focus"\n'));
+    return;
+  }
+  await addGoal(String(text).trim());
+  const { updated } = await refreshPinned();
+  console.log('\n' + chalk.green('  ✓ Goal set: ') + chalk.white(text));
+  if (updated.length) console.log(chalk.gray(`    Pinned to: ${updated.join(', ')}\n`));
+}
+
+export async function nextCommand(text) {
+  if (!text || !String(text).trim()) {
+    console.log(chalk.yellow('\nUsage: ') + chalk.cyan('memoir next "the next action"\n'));
+    return;
+  }
+  await addNext(String(text).trim());
+  await refreshPinned();
+  console.log('\n' + chalk.green('  ✓ Added to next: ') + chalk.white(text) + '\n');
+}
+
+export async function doneCommand(text) {
+  if (!text || !String(text).trim()) {
+    console.log(chalk.yellow('\nUsage: ') + chalk.cyan('memoir done "substring of the action"\n'));
+    return;
+  }
+  const before = await readSession();
+  await completeNext(String(text).trim());
+  const after = await readSession();
+  const removed = before.current.next_actions.length - after.current.next_actions.length;
+  if (removed > 0) {
+    await refreshPinned();
+    console.log('\n' + chalk.green(`  ✓ Completed ${removed} action${removed !== 1 ? 's' : ''}\n`));
+  } else {
+    console.log('\n' + chalk.yellow('  No matching action found.\n'));
+  }
+}
+
+export async function noteCommand(text, options = {}) {
+  if (!text || !String(text).trim()) {
+    console.log(chalk.yellow('\nUsage: ') + chalk.cyan('memoir note "the decision" [--why "rationale"] [--rejected "alternative"]\n'));
+    return;
+  }
+  await addNote(String(text).trim(), {
+    why: options.why ? String(options.why).trim() : undefined,
+    rejected: options.rejected ? String(options.rejected).trim() : undefined,
+  });
+  await refreshPinned();
+  console.log('\n' + chalk.green('  ✓ Decision recorded: ') + chalk.white(text));
+  if (options.why) console.log(chalk.gray('    Why: ') + chalk.white(options.why));
+  if (options.rejected) console.log(chalk.gray('    Rejected: ') + chalk.white(options.rejected));
+  console.log('');
+}
+
+export async function askCommand(text) {
+  if (!text || !String(text).trim()) {
+    console.log(chalk.yellow('\nUsage: ') + chalk.cyan('memoir ask "the open question"\n'));
+    return;
+  }
+  await addQuestion(String(text).trim());
+  await refreshPinned();
+  console.log('\n' + chalk.green('  ✓ Question captured: ') + chalk.white(text) + '\n');
+}
+
+export async function sessionShowCommand() {
+  const state = await readSession();
+  const machine = await getMachineId();
+  const goals = state.current.goals;
+  const nexts = state.current.next_actions;
+  const questions = state.current.open_questions;
+  const decisions = state.current.decisions;
+  const history = state.history;
+
+  const body = [];
+  body.push(gradient.pastel('  Session  '));
+  body.push('');
+  body.push(chalk.gray(`  This machine: ${machine.label} (${machine.id.slice(0, 8)})`));
+  body.push(chalk.gray(`  Storage: ${paths.session}`));
+  body.push('');
+
+  if (goals.length === 0) {
+    body.push(chalk.yellow('  No goal set.') + chalk.gray('  Run ') + chalk.cyan('memoir goal "..."'));
+  } else {
+    body.push(chalk.white.bold('  Current goal:'));
+    for (const g of goals) body.push('  ' + chalk.cyan('→ ') + chalk.white(g.text));
+  }
+  body.push('');
+
+  if (nexts.length) {
+    body.push(chalk.white.bold('  Next:'));
+    for (const n of nexts) body.push('  ' + chalk.gray('[ ] ') + chalk.white(n.text));
+    body.push('');
+  }
+
+  if (questions.length) {
+    body.push(chalk.white.bold('  Open questions:'));
+    for (const q of questions) body.push('  ' + chalk.yellow('? ') + chalk.white(q.text));
+    body.push('');
+  }
+
+  if (decisions.length) {
+    body.push(chalk.white.bold('  Recent decisions:'));
+    for (const d of decisions.slice(0, 5)) {
+      let line = '  ' + chalk.green('✓ ') + chalk.white(d.text);
+      if (d.why) line += chalk.gray(` — ${d.why}`);
+      body.push(line);
+    }
+    body.push('');
+  }
+
+  if (history.length) {
+    body.push(chalk.white.bold('  Recent sessions:'));
+    for (const h of history.slice(0, 5)) {
+      const date = (h.date || '').slice(0, 10);
+      const label = state.machines?.[h.machine_id]?.label || '?';
+      const dur = h.duration_min ? chalk.gray(` (${h.duration_min}m)`) : '';
+      body.push('  ' + chalk.gray(`${date} ${label}`) + dur + chalk.gray(': ') + chalk.white(h.summary || '—'));
+    }
+    body.push('');
+  }
+
+  const machineCount = Object.keys(state.machines || {}).length;
+  if (machineCount > 1) {
+    body.push(chalk.gray(`  ${machineCount} machines sync this session.`));
+  }
+
+  console.log('\n' + boxen(body.join('\n'), {
+    padding: { top: 0, bottom: 0, left: 1, right: 1 },
+    borderStyle: 'round',
+    borderColor: 'cyan',
+    dimBorder: true,
+  }) + '\n');
+}
+
+export async function sessionClearCommand() {
+  const state = await readSession();
+  state.current = { goals: [], next_actions: [], open_questions: [], decisions: [] };
+  await writeSession(state);
+  await refreshPinned();
+  console.log('\n' + chalk.green('  ✓ Current session cleared.') + chalk.gray(' History retained.\n'));
+}

package/src/commands/why.js

@@ -0,0 +1,50 @@
+// Decision registry lookup — `memoir why <query>`
+// Search session.json decisions[] by text / why / rejected substring.
+// Returns matching decisions sorted by recency.
+
+import chalk from 'chalk';
+import boxen from 'boxen';
+import { readSession } from '../session/state.js';
+
+function searchDecisions(decisions, query) {
+  if (!query) return decisions;
+  const q = String(query).toLowerCase();
+  return decisions.filter(d => {
+    const haystack = [d.text, d.why, d.rejected].filter(Boolean).join(' ').toLowerCase();
+    return haystack.includes(q);
+  });
+}
+
+export async function whyCommand(query) {
+  const state = await readSession();
+  const decisions = state.current?.decisions || [];
+  const matches = searchDecisions(decisions, query);
+
+  if (matches.length === 0) {
+    const msg = query
+      ? chalk.yellow(`No decisions match "${query}".`) + '\n\n' +
+        chalk.gray('Record one with: ') + chalk.cyan('memoir note "the decision" --why "rationale"')
+      : chalk.yellow('No decisions recorded yet.') + '\n\n' +
+        chalk.gray('Record one with: ') + chalk.cyan('memoir note "the decision" --why "rationale"');
+    console.log('\n' + boxen(msg, { padding: 1, borderStyle: 'round', borderColor: 'yellow' }) + '\n');
+    return;
+  }
+
+  const lines = [chalk.cyan.bold(`${matches.length} decision${matches.length !== 1 ? 's' : ''} matching "${query || '*'}":`)];
+  lines.push('');
+  for (const d of matches) {
+    const date = (d.date || '').slice(0, 10);
+    const label = state.machines?.[d.machine_id]?.label || '';
+    lines.push(chalk.green('  ● ') + chalk.white.bold(d.text));
+    if (d.why) lines.push(chalk.gray('    why: ') + chalk.white(d.why));
+    if (d.rejected) lines.push(chalk.gray('    rejected: ') + chalk.white(d.rejected));
+    if (date) lines.push(chalk.gray(`    ${date}${label ? ` on ${label}` : ''}`));
+    lines.push('');
+  }
+  console.log('\n' + lines.join('\n'));
+}
+
+// Exported for MCP tool
+export function findDecisions(state, query) {
+  return searchDecisions(state.current?.decisions || [], query);
+}

package/src/mcp.js

@@ -14,6 +14,19 @@ import os from 'os';
 import { z } from 'zod';
 import { getConfig, listProfiles, getActiveProfileName } from './config.js';
 import { adapters } from './adapters/index.js';
+import {
+  readSession,
+  writeSession,
+  addGoal,
+  addNext,
+  completeNext,
+  addNote,
+  addQuestion,
+  getMachineId,
+} from './session/state.js';
+import { renderSession } from './session/render.js';
+import { injectInto, detectAvailableTargets } from './session/inject.js';
+import { findDecisions } from './commands/why.js';
 
 const home = os.homedir();
 
@@ -518,6 +531,168 @@ server.tool(
   }
 );
 
+// ── Session continuity tools ─────────────────────────────────────────────────
+// These let the AI record its own goals, decisions, and next-actions into
+// session.json — which is auto-rendered into ~/.claude/CLAUDE.md (and other
+// tools in the future) so the next session picks up where this one ended.
+
+async function refreshPinnedBlock() {
+  try {
+    const state = await readSession();
+    const rendered = renderSession(state);
+    for (const target of Object.values(detectAvailableTargets())) {
+      try { await injectInto(target, rendered); } catch {}
+    }
+  } catch {
+    // Best-effort; don't fail the MCP call
+  }
+}
+
+server.tool(
+  'memoir_set_goal',
+  'Set the current goal for this session. Use when the user states what they want to work on, or when a clear focus emerges. Pinned into CLAUDE.md so future sessions see it.',
+  { text: z.string().describe('The goal, one short sentence') },
+  async ({ text }) => {
+    await addGoal(text);
+    await refreshPinnedBlock();
+    return { content: [{ type: 'text', text: `Goal set: ${text}` }] };
+  }
+);
+
+server.tool(
+  'memoir_add_next',
+  'Add a next action to the current session. Use when the user decides on a concrete next step, or when you finish something and the logical next move is clear.',
+  { text: z.string().describe('The action, one short imperative sentence') },
+  async ({ text }) => {
+    await addNext(text);
+    await refreshPinnedBlock();
+    return { content: [{ type: 'text', text: `Next: ${text}` }] };
+  }
+);
+
+server.tool(
+  'memoir_complete_next',
+  'Mark a next action as complete (removes it from the pinned list). Match by substring — pass the relevant keywords, not the whole text.',
+  { match: z.string().describe('Substring to match against existing next actions') },
+  async ({ match }) => {
+    const before = await readSession();
+    const beforeCount = before.current.next_actions.length;
+    await completeNext(match);
+    const after = await readSession();
+    const removed = beforeCount - after.current.next_actions.length;
+    await refreshPinnedBlock();
+    return {
+      content: [{
+        type: 'text',
+        text: removed > 0 ? `Completed ${removed} action(s) matching "${match}"` : `No action matched "${match}"`,
+      }],
+    };
+  }
+);
+
+server.tool(
+  'memoir_note',
+  'Record a decision with optional rationale and rejected alternative. Use when a non-obvious technical or product choice is made — the kind of thing a future session would want to know "why did we do this."',
+  {
+    text: z.string().describe('The decision, one short sentence (what was decided)'),
+    why: z.string().optional().describe('Rationale — why this choice over others'),
+    rejected: z.string().optional().describe('The alternative that was considered and rejected'),
+  },
+  async ({ text, why, rejected }) => {
+    await addNote(text, { why, rejected });
+    await refreshPinnedBlock();
+    const extras = [];
+    if (why) extras.push(`why: ${why}`);
+    if (rejected) extras.push(`rejected: ${rejected}`);
+    return {
+      content: [{ type: 'text', text: `Decision recorded: ${text}${extras.length ? ` (${extras.join('; ')})` : ''}` }],
+    };
+  }
+);
+
+server.tool(
+  'memoir_ask',
+  'Capture an open question for later. Use when the user poses a question you cannot fully answer now, or when an ambiguity surfaces that needs resolution in a future session.',
+  { text: z.string().describe('The open question') },
+  async ({ text }) => {
+    await addQuestion(text);
+    await refreshPinnedBlock();
+    return { content: [{ type: 'text', text: `Question captured: ${text}` }] };
+  }
+);
+
+server.tool(
+  'memoir_session',
+  'Show the current session state — goals, next actions, open questions, recent decisions, recent sessions across machines. Use this to catch up at the start of a session, or when you need to orient yourself on what was decided.',
+  {},
+  async () => {
+    const state = await readSession();
+    const machine = await getMachineId();
+    const goals = state.current.goals.map(g => `- ${g.text}`).join('\n') || '(none)';
+    const nexts = state.current.next_actions.map(n => `- [ ] ${n.text}`).join('\n') || '(none)';
+    const questions = state.current.open_questions.map(q => `- ${q.text}`).join('\n') || '(none)';
+    const decisions = state.current.decisions.slice(0, 5).map(d => {
+      let line = `- ${d.text}`;
+      if (d.why) line += ` — *${d.why}*`;
+      return line;
+    }).join('\n') || '(none)';
+    const history = state.history.slice(0, 5).map(h => {
+      const date = (h.date || '').slice(0, 10);
+      const label = state.machines?.[h.machine_id]?.label || '?';
+      return `- ${date} ${label}: ${h.summary || '—'}`;
+    }).join('\n') || '(none)';
+    const machineList = Object.entries(state.machines || {})
+      .map(([id, m]) => `- ${m.label} (last seen: ${(m.last_seen || '').slice(0, 10)})`)
+      .join('\n') || '(just this one)';
+
+    const text = [
+      `# Memoir session`,
+      `This machine: ${machine.label}`,
+      '',
+      '## Current goal',
+      goals,
+      '',
+      '## Next',
+      nexts,
+      '',
+      '## Open questions',
+      questions,
+      '',
+      '## Recent decisions',
+      decisions,
+      '',
+      '## Recent sessions',
+      history,
+      '',
+      '## Machines syncing this session',
+      machineList,
+    ].join('\n');
+
+    return { content: [{ type: 'text', text }] };
+  }
+);
+
+server.tool(
+  'memoir_why',
+  'Look up past decisions by keyword. Returns the decision text, why it was made, and what alternative was rejected. Use when the user asks "why did we do X" or when you need to avoid re-opening a settled question.',
+  { query: z.string().describe('Keyword or phrase to search in decision text, rationale, or rejected alternative') },
+  async ({ query }) => {
+    const state = await readSession();
+    const matches = findDecisions(state, query);
+    if (matches.length === 0) {
+      return { content: [{ type: 'text', text: `No decisions match "${query}".` }] };
+    }
+    const out = matches.map(d => {
+      const parts = [`● ${d.text}`];
+      if (d.why) parts.push(`  why: ${d.why}`);
+      if (d.rejected) parts.push(`  rejected: ${d.rejected}`);
+      if (d.date) parts.push(`  (${d.date.slice(0, 10)})`);
+      return parts.join('\n');
+    }).join('\n\n');
+    return { content: [{ type: 'text', text: `${matches.length} decision(s) matching "${query}":\n\n${out}` }] };
+  }
+);
+
 // ── Resources ────────────────────────────────────────────────────────────────
 
 // Expose detected tools as browsable resources

package/src/session/inject.js

@@ -0,0 +1,117 @@
+// Inject / update the pinned session block in target files.
+//
+// Primary target: ~/.claude/CLAUDE.md (user-global, always loaded by Claude Code
+// regardless of MEMORY.md truncation).
+//
+// Rules:
+// - If markers are present, replace the block in place. Nothing else is touched.
+// - If markers are absent, prepend the block at the top of the file (after any
+//   leading frontmatter or title line).
+// - If the file doesn't exist, create it containing only the block.
+// - Never touch content outside the markers.
+
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import { BLOCK_START, BLOCK_END } from './render.js';
+
+const home = os.homedir();
+const isWin = process.platform === 'win32';
+const appData = process.env.APPDATA || path.join(home, 'AppData', 'Roaming');
+
+// Every target that memoir knows how to inject the pinned block into.
+// Added when we extend cross-tool support. Each target is a single file path.
+//
+// Claude:   ~/.claude/CLAUDE.md                (always loaded by Claude Code)
+// Cursor:   ~/.cursor/rules/memoir-session.mdc (global user rules — auto-loaded)
+// Windsurf: {AppSupport}/Windsurf/User/memoir-session.md (user-global instructions)
+// Gemini:   ~/.gemini/GEMINI.md                (user-global)
+export const INJECTION_TARGETS = {
+  claude:   path.join(home, '.claude', 'CLAUDE.md'),
+  cursor:   path.join(home, '.cursor', 'rules', 'memoir-session.mdc'),
+  windsurf: isWin
+    ? path.join(appData, 'Windsurf', 'User', 'memoir-session.md')
+    : path.join(home, 'Library', 'Application Support', 'Windsurf', 'User', 'memoir-session.md'),
+  gemini:   path.join(home, '.gemini', 'GEMINI.md'),
+};
+
+// Returns the target paths whose parent infrastructure exists — i.e. the tool
+// is actually installed. Avoids creating empty tool dirs for tools the user
+// doesn't use.
+export function detectAvailableTargets() {
+  const detectors = {
+    claude:   path.join(home, '.claude'),
+    cursor:   path.join(home, '.cursor'),
+    windsurf: isWin
+      ? path.join(appData, 'Windsurf', 'User')
+      : path.join(home, 'Library', 'Application Support', 'Windsurf', 'User'),
+    gemini:   path.join(home, '.gemini'),
+  };
+  const available = {};
+  for (const [name, dir] of Object.entries(detectors)) {
+    try {
+      if (fs.existsSync(dir)) available[name] = INJECTION_TARGETS[name];
+    } catch {}
+  }
+  return available;
+}
+
+// Pattern that matches the whole block including markers. Tolerant of the
+// marker text evolving across versions — anchors on `memoir:session-block`.
+const BLOCK_RE = /<!--\s*memoir:session-block[^>]*-->[\s\S]*?<!--\s*\/memoir:session-block\s*-->/;
+
+export async function injectInto(targetPath, renderedBlock) {
+  await fs.ensureDir(path.dirname(targetPath));
+
+  let content = '';
+  let existed = false;
+  try {
+    content = await fs.readFile(targetPath, 'utf8');
+    existed = true;
+  } catch {
+    // Doesn't exist yet — will create.
+  }
+
+  const updated = applyBlock(content, renderedBlock, existed);
+
+  // Atomic write
+  const tmp = `${targetPath}.tmp-${process.pid}`;
+  await fs.writeFile(tmp, updated);
+  await fs.move(tmp, targetPath, { overwrite: true });
+
+  return { path: targetPath, created: !existed, replaced: existed && BLOCK_RE.test(content) };
+}
+
+// Apply the block to existing content. Exported for tests.
+export function applyBlock(content, renderedBlock, existed = true) {
+  if (!existed || content.trim() === '') {
+    // Fresh file — block only, plus a trailing newline for poetry.
+    return renderedBlock + '\n';
+  }
+
+  if (BLOCK_RE.test(content)) {
+    // Replace in place.
+    return content.replace(BLOCK_RE, renderedBlock);
+  }
+
+  // No existing block — prepend. Preserve any H1 title at the top by placing
+  // the block immediately after it. Otherwise put it at the very top.
+  const h1Match = content.match(/^(#\s.+\n+)/);
+  if (h1Match) {
+    return h1Match[1] + renderedBlock + '\n\n' + content.slice(h1Match[1].length);
+  }
+  return renderedBlock + '\n\n' + content;
+}
+
+// Remove the block, if present. Used when user wants memoir to stop managing CLAUDE.md.
+export async function uninjectFrom(targetPath) {
+  if (!await fs.pathExists(targetPath)) return { removed: false };
+  const content = await fs.readFile(targetPath, 'utf8');
+  if (!BLOCK_RE.test(content)) return { removed: false };
+  // Strip the block and any trailing blank lines that follow it
+  const cleaned = content.replace(BLOCK_RE, '').replace(/\n{3,}/g, '\n\n').trimStart();
+  const tmp = `${targetPath}.tmp-${process.pid}`;
+  await fs.writeFile(tmp, cleaned);
+  await fs.move(tmp, targetPath, { overwrite: true });
+  return { removed: true };
+}

package/src/session/render.js

@@ -0,0 +1,114 @@
+// Render session state → pinned markdown block.
+// The block is wrapped in <!-- memoir:session-block v1 --> markers so inject.js
+// can find and replace it without touching anything else in CLAUDE.md.
+
+export const BLOCK_START = '<!-- memoir:session-block v1 — managed by memoir, edit via `memoir goal/next/note` -->';
+export const BLOCK_END = '<!-- /memoir:session-block -->';
+
+const MAX_RENDERED_GOALS = 2;
+const MAX_RENDERED_NEXT = 6;
+const MAX_RENDERED_QUESTIONS = 4;
+const MAX_RENDERED_DECISIONS = 5;
+const MAX_RENDERED_HISTORY = 5;
+
+export function renderSession(state) {
+  if (!state) return renderEmpty();
+
+  const lines = [BLOCK_START, '## 🎯 Continuing from where we left off', ''];
+
+  const goals = (state.current?.goals || []).slice(0, MAX_RENDERED_GOALS);
+  const nexts = (state.current?.next_actions || []).slice(-MAX_RENDERED_NEXT).reverse();
+  const questions = (state.current?.open_questions || []).slice(-MAX_RENDERED_QUESTIONS).reverse();
+  const decisions = (state.current?.decisions || []).slice(0, MAX_RENDERED_DECISIONS);
+  const history = (state.history || []).slice(0, MAX_RENDERED_HISTORY);
+
+  const everythingEmpty = !goals.length && !nexts.length && !questions.length && !decisions.length && !history.length;
+  if (everythingEmpty) return renderEmpty();
+
+  // Goals — show current goal prominently
+  if (goals.length === 1) {
+    lines.push(`**Current goal:** ${goals[0].text}${machineTag(goals[0], state)}`);
+    lines.push('');
+  } else if (goals.length > 1) {
+    lines.push('**Goals:**');
+    for (const g of goals) lines.push(`- ${g.text}${machineTag(g, state)}`);
+    lines.push('');
+  }
+
+  // Next actions — checkbox format so they read as actionable
+  if (nexts.length) {
+    lines.push('**Next:**');
+    for (const n of nexts) {
+      lines.push(`- [ ] ${n.text}${machineTag(n, state)}`);
+    }
+    lines.push('');
+  }
+
+  // Open questions
+  if (questions.length) {
+    lines.push('**Open questions:**');
+    for (const q of questions) lines.push(`- ${q.text}${machineTag(q, state)}`);
+    lines.push('');
+  }
+
+  // Recent decisions
+  if (decisions.length) {
+    lines.push('**Recent decisions:**');
+    for (const d of decisions) {
+      let line = `- ${d.text}`;
+      if (d.why) line += ` — *${d.why}*`;
+      line += machineTag(d, state);
+      lines.push(line);
+    }
+    lines.push('');
+  }
+
+  // Recent session history — machine-tagged so user sees cross-machine trail
+  if (history.length) {
+    lines.push('**Recent sessions:**');
+    for (const h of history) {
+      const date = (h.date || '').slice(0, 10);
+      const machineLabel = labelFor(h.machine_id, state) || 'unknown';
+      const dur = h.duration_min ? ` (${formatDuration(h.duration_min)})` : '';
+      const summary = h.summary || '—';
+      lines.push(`- ${date} ${machineLabel}${dur}: ${summary}`);
+    }
+    lines.push('');
+  }
+
+  lines.push(BLOCK_END);
+  return lines.join('\n');
+}
+
+function machineTag(item, state) {
+  if (!item?.machine_id) return '';
+  const label = labelFor(item.machine_id, state);
+  // Only show machine tag if we have more than one machine — otherwise it's noise
+  const machineCount = Object.keys(state?.machines || {}).length;
+  if (machineCount <= 1 || !label) return '';
+  return ` _(${label})_`;
+}
+
+function labelFor(machineId, state) {
+  if (!machineId) return null;
+  return state?.machines?.[machineId]?.label || null;
+}
+
+function formatDuration(min) {
+  if (!min || min <= 0) return '';
+  if (min < 60) return `${min}m`;
+  const h = Math.floor(min / 60);
+  const m = min % 60;
+  return m ? `${h}h ${m}m` : `${h}h`;
+}
+
+function renderEmpty() {
+  return [
+    BLOCK_START,
+    '## 🎯 Continuing from where we left off',
+    '',
+    '_No session context yet. Set one with:_ `memoir goal "your current focus"`',
+    '',
+    BLOCK_END,
+  ].join('\n');
+}