dotmd-cli 0.39.0 → 0.39.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dotmd-cli",
-  "version": "0.39.0",
+  "version": "0.39.2",
   "description": "CLI for managing markdown documents with YAML frontmatter — index, query, validate, graph, export, Notion sync, AI summaries.",
   "type": "module",
   "license": "MIT",

package/src/claude-commands.mjs

@@ -20,7 +20,7 @@ const VERSION_REGEX = /<!-- dotmd-generated: ([\d.]+) -->/;
 const SLASH_DESCRIPTIONS = {
   plans: "dotmd-managed plan briefing for this repo. Use when the user asks what's on the plate, references a plan slug, queues work, or wants to pick up / release / archive a plan.",
   docs: "dotmd-managed docs briefing for this repo. Use when the user asks to list, scaffold, query, validate, archive, or rename non-plan docs (reference docs, ADRs, RFCs, design notes), or asks how the dotmd doc lifecycle works here.",
-  baton: "Wrap the current session cleanly: update the in-flight plan, save ONE resume prompt via 'dotmd new prompt', release the lease. Use when the user says hand off / save a resume / wrap up, or when context is getting tight.",
+  baton: "Save a resume prompt for the held plan and release the lease — the minimum handoff. Use when the user says hand off / save a resume / wrap up, or when context is getting tight.",
 };
 
 function frontmatterFor(name) {
@@ -67,13 +67,17 @@ function generatePlansCommand(config) {
 
 function generateBatonCommand() {
   const lines = [...frontmatterFor('baton'), VERSION_MARKER, ''];
-  lines.push('You are wrapping this session. Hand the baton cleanly to the next one.');
+  lines.push('Wrap this session. Minimum required (two commands):');
   lines.push('');
-  lines.push('1. **Update the in-flight plan.** Find it via `dotmd plans --status in-session`. Edit its `current_state:` / `next_step:` frontmatter so they reflect where things actually stand. If status should change (shipped → archive, stuck on a human decision → awaiting, etc.), transition with `dotmd status <file> <status>` — or `dotmd archive <file>` if work is done.');
+  lines.push('1. **Save the resume prompt.** `dotmd new prompt resume-<plan-slug>` with a 10-20 line body via heredoc: the next concrete decision plus any gotchas. NOT a recap of the plan body. The saved prompt IS the handoff — never print it into chat for copy-paste.');
   lines.push('');
-  lines.push('2. **Save ONE lean handoff prompt.** Run `dotmd new prompt resume-<plan-slug>` with a body of ~10-20 lines: point at the plan file, name the next concrete decision, flag any gotchas. Do NOT recap the plan body (the plan is for that). Do NOT print the handoff into chat for the user to copy-paste — the saved prompt is the handoff.');
+  lines.push('2. **Release the lease.** `dotmd release` — or `dotmd archive <file>` if the work is fully shipped (archive auto-releases).');
   lines.push('');
-  lines.push('3. **Release the lease.** `dotmd release` (skip if `dotmd archive` already closed out — archive auto-releases).');
+  lines.push('Optional, only when genuinely needed:');
+  lines.push('- Status really changed (paused / awaiting / partial / blocked): `dotmd status <file> <status>` BEFORE `dotmd release`.');
+  lines.push('- Plan dashboard text is misleading the user: edit `next_step:` in the plan frontmatter. Cosmetic — the next session reads the resume prompt, not the plan frontmatter.');
+  lines.push('');
+  lines.push('If you don\'t already know which plan you hold: `dotmd hud --json` and read `.owned`. Do NOT use `dotmd plans --status in-session` — that lists every session\'s holdings, not just yours.');
   lines.push('');
   lines.push('The next session\'s `dotmd hud` (SessionStart hook) surfaces the pending prompt automatically.');
   lines.push('');

package/src/new.mjs

@@ -265,17 +265,37 @@ export async function runNew(argv, config, opts = {}) {
 
   // Fail-fast when the user passes body input to a template that doesn't
   // consume it — silently discarding heredoc content is the worst UX.
-  // Templates opt in via `acceptsBody: true` or `requiresBody: true`. All
-  // built-in templates (doc, plan, prompt) accept body; this guard fires
-  // only for custom templates that opt out.
+  // Templates opt in via `acceptsBody: true` or `requiresBody: true`.
   if (bodyInput !== null && !template.acceptsBody && !template.requiresBody) {
-    const accepting = Object.entries(BUILTIN_TEMPLATES)
-      .filter(([, t]) => t.acceptsBody || t.requiresBody)
-      .map(([n]) => n);
+    const configTemplates = config.raw?.templates ?? {};
+    // Compute the accepting list from the RESOLVED set (config merged over
+    // built-ins) so the hint doesn't contradict the rejection.
+    const resolvedNames = new Set([...Object.keys(BUILTIN_TEMPLATES), ...Object.keys(configTemplates)]);
+    const accepting = [...resolvedNames]
+      .filter(n => n !== typeName)
+      .filter(n => {
+        const t = resolveTemplate(n, config);
+        return t.acceptsBody || t.requiresBody;
+      });
     const hint = accepting.length > 0
       ? ` Templates that accept body input: ${accepting.join(', ')}.`
       : '';
-    die(`\`${typeName}\` template does not accept body input, but body was passed via ${bodyInputSource}.${hint}\nEither drop the body, switch to a template that accepts it, or set \`acceptsBody: true\` on your custom \`${typeName}\` template in dotmd.config.mjs.`);
+
+    // Override-of-builtin diagnosis: the most common cause is a project
+    // dotmd.config.mjs that copy-pasted a stripped-down `plan` template
+    // and dropped the body-acceptance contract. Name that explicitly so
+    // an agent can self-fix without spelunking the config.
+    const builtin = BUILTIN_TEMPLATES[typeName];
+    const isOverride = Boolean(configTemplates[typeName] && builtin);
+    const builtinAccepts = Boolean(builtin && (builtin.acceptsBody || builtin.requiresBody));
+    let cause;
+    if (isOverride && builtinAccepts) {
+      const where = config.configPath ? toRepoPath(config.configPath, config.repoRoot) : 'dotmd.config.mjs';
+      cause = `Your config (${where}) overrides the built-in \`${typeName}\` template, and the override drops body acceptance.\nFix: in that override, add \`acceptsBody: true\` AND interpolate \`\${ctx?.bodyInput?.trim() ?? ''}\` into your \`body\` fn (e.g., inside \`## Problem\`). Or drop the override to use the built-in.`;
+    } else {
+      cause = `Either drop the body, switch to a template that accepts it, or set \`acceptsBody: true\` on your custom \`${typeName}\` template in dotmd.config.mjs.`;
+    }
+    die(`\`${typeName}\` template does not accept body input, but body was passed via ${bodyInputSource}.${hint}\n${cause}`);
   }
 
   // If name contains path separators, split into directory prefix and basename
@@ -379,10 +399,39 @@ export async function runNew(argv, config, opts = {}) {
 }
 
 function resolveTemplate(name, config) {
-  // Config templates take priority
   const configTemplates = config.raw?.templates ?? {};
-  if (configTemplates[name]) return configTemplates[name];
-  if (BUILTIN_TEMPLATES[name]) return BUILTIN_TEMPLATES[name];
+  const override = configTemplates[name];
+  const builtin = BUILTIN_TEMPLATES[name];
+
+  if (override) {
+    if (!builtin) return { ...override, _overridesBuiltin: false };
+    // Partial-override DX: shallow-merge built-in under override so missing
+    // fields (description, dir, targetRoot, defaultStatus, frontmatter, body,
+    // acceptsBody, requiresBody) fall back to the built-in. Anything the
+    // override explicitly declares wins.
+    const merged = { ...builtin, ...override, _overridesBuiltin: true };
+
+    // Body-loss guard: if the override supplies its OWN body fn but doesn't
+    // explicitly opt in to body acceptance, the inherited built-in
+    // `acceptsBody`/`requiresBody` could let body input flow into a custom
+    // body fn that doesn't honor `ctx.bodyInput` — silently discarding the
+    // heredoc, the worst-UX bug fix #9 was added to prevent. Strip the
+    // inherited flags so the fail-fast guard fires. EXCEPT when the custom
+    // body fn references `bodyInput` itself, in which case it's clearly
+    // body-aware and inheriting acceptsBody is the agent-first move.
+    const overrodeBody = typeof override.body === 'function';
+    const declaredAcceptance = override.acceptsBody !== undefined || override.requiresBody !== undefined;
+    if (overrodeBody && !declaredAcceptance) {
+      const bodyAware = /bodyInput/.test(override.body.toString());
+      if (!bodyAware) {
+        merged.acceptsBody = undefined;
+        merged.requiresBody = undefined;
+      }
+    }
+    return merged;
+  }
+
+  if (builtin) return builtin;
 
   const available = [...new Set([...Object.keys(BUILTIN_TEMPLATES), ...Object.keys(configTemplates)])];
   die(`Unknown type: ${name}\nAvailable: ${available.join(', ')}`);