dotmd-cli 0.64.0 → 0.64.2

package/README.md

@@ -9,6 +9,7 @@ Index, query, validate, and lifecycle-manage any collection of `.md` files — p
 ```bash
 npm install -g dotmd-cli    # global — use `dotmd` anywhere
 npm install -D dotmd-cli    # project devDep — use via npm scripts
+npx dotmd-cli init          # try it without installing — scaffold a repo first
 # requires Node.js >= 20
 ```
 
@@ -27,6 +28,19 @@ The plugin bundles the hooks (`SessionStart`/`SubagentStart` priming, a `PreTool
 
 > **Upgrading to 0.57.0+:** per-repo `.claude/commands/{plans,docs,baton}.md` scaffolding is retired — that guidance now ships via the plugin's workflow skill and `/plans`, `/docs`, `/prompts`, `/baton` commands. On the next `dotmd hud` (SessionStart), dotmd removes those generated files (only banner-stamped `<!-- dotmd-generated -->` ones — your hand-authored command files are never touched). If you'd committed them, you'll see deletions to commit — that's expected. Run `claude plugin update dotmd@dotmd` to pick up `/baton`.
 
+### Updating
+
+The CLI and the Claude Code plugin are versioned in lockstep but ship as separate artifacts, so upgrading one can leave the other behind. `dotmd update` keeps them aligned:
+
+```bash
+dotmd update                 # update both: npm CLI + the plugin
+dotmd update --check         # report CLI vs plugin versions, change nothing (no network)
+dotmd update --cli-only      # just the npm CLI
+dotmd update --plugin-only   # just the plugin (what to run after a plain npm upgrade)
+```
+
+`--plugin-only` is the usual fixup: after `npm i -g dotmd-cli@latest` the CLI is fresh but the plugin is stale, so run `dotmd update --plugin-only`, then restart the session (or `/reload-plugins`).
+
 ## Quick Start
 
 ```bash
@@ -338,6 +352,18 @@ Each built-in type has a template baked in:
 | `doc` | `docs/<slug>.md` | Overview → Version History → Related (build-up shape lite) |
 | `prompt` | `docs/prompts/<slug>.md` | Body is required (see [Saved Prompts](#saved-prompts)) |
 
+**Plan body variants (plans only).** The default `plan` template is the full build-up shape. For a smaller plan, or the recurring audit shape, pass one body-variant flag:
+
+- `--lite` / `--minimal` — Problem → Phases → Version History (drops Goals / Non-Goals / What Exists Today / Constraints / Decisions / Deferred / Closeout).
+- `--audit` / `--findings` — Problem → Findings (ranked) → Suggested order → Open Questions, for "I investigated X, here's what I found" plans.
+
+```bash
+dotmd new plan quick-fix --lite
+dotmd new plan perf-audit --audit
+```
+
+To scaffold an ordered sprint or a coordination map instead, see [Runlists](#runlists-ordered-groups-of-plans) (`--runlist a,b,c` / `--coordination`). The body variants and the hub flags are all mutually exclusive — a plan has exactly one body shape.
+
 Add custom types via `templates` in your config:
 
 ```js

package/bin/dotmd.mjs

@@ -255,6 +255,7 @@ Create & Export:
 
 Setup:
   init                              Create starter config + docs directory
+  update [--check|--cli-only|--plugin-only]  Update the CLI + Claude Code plugin (--check reports skew, no network)
   statuses [list|add|set|remove|migrate]  Manage per-project status taxonomy
   help statuses                     Full status vocabulary + unstuck-actions + transitions
   watch [command]                   Re-run a command on file changes
@@ -857,6 +858,20 @@ Scaffolding runlists (plans only):
   dotmd new plan auth-revamp --runlist extract,rewrite,cleanup
   dotmd new plan platform --coordination
 
+Plan body variants (plans only — pick one body shape):
+  --lite / --minimal   Trimmed plan: Problem → Phases → Version History. Drops
+                       the full build-up scaffold (Goals / Non-Goals / What
+                       Exists Today / Constraints / Decisions / Deferred /
+                       Closeout) for a quick plan that doesn't need it.
+  --audit / --findings Audit plan: Problem → Findings (ranked) → Suggested order
+                       → Open Questions. The "investigated X, here's what I
+                       found" shape, instead of build-up phases.
+  (The body variants and \`--runlist\`/\`--coordination\` are all mutually
+  exclusive — a plan has exactly one body shape.)
+
+  dotmd new plan quick-fix --lite
+  dotmd new plan perf-audit --audit
+
 Other options:
   --status <s>         Set initial status (defaults to first valid status for the type)
   --title <t>          Override the auto-derived title

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dotmd-cli",
-  "version": "0.64.0",
+  "version": "0.64.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/init.mjs

@@ -190,9 +190,15 @@ function generateDetectedConfig(scan, rootPath) {
     lines.push('');
   }
 
-  if (scan.surfaces.size > 0) {
+  if (scan.surfaces.size > 0 || scan.modules.size > 0) {
     lines.push('export const taxonomy = {');
-    lines.push(`  surfaces: [${[...scan.surfaces].sort().map(s => `'${s}'`).join(', ')}],`);
+    // Emit the full detected set so every existing doc passes — taxonomy
+    // enforcement only flags values outside the list, and the scan collected
+    // all of them. New surfaces/modules added later warn until appended here.
+    if (scan.surfaces.size > 0)
+      lines.push(`  surfaces: [${[...scan.surfaces].sort().map(s => `'${s}'`).join(', ')}],`);
+    if (scan.modules.size > 0)
+      lines.push(`  modules: [${[...scan.modules].sort().map(m => `'${m}'`).join(', ')}],`);
     lines.push('};');
     lines.push('');
   }

package/src/new.mjs

@@ -350,6 +350,73 @@ graph pick it up. -->
 `;
 }
 
+// Body for a `--lite` plan: the full build-up scaffold (Goals / Non-Goals /
+// What Exists Today / Constraints / Decisions / Open Questions / Deferred /
+// Closeout) is stripped down to the essentials — Problem → Phases → Version
+// History — for a quick plan that doesn't need the full ceremony.
+function litePlanBody(title, bodyInput, today) {
+  return `
+# ${title}
+
+> One-paragraph problem statement: what this plan is for, why now.
+
+## Problem
+
+${bodyInput?.trim() ?? ''}
+
+## Phases
+
+<!-- Status markers in heading text: ⬜ not started · 🟡 in progress (pickup
+targets this) · ✅ shipped · ⏭ skipped · 🚧 blocked. -->
+
+### Phase 1 — <title> ⬜
+
+
+
+## Version History
+
+- **${today}** Created.
+`;
+}
+
+// Body for an `--audit` plan: the recurring "investigated X, here's what I
+// found" shape — ranked findings with impact tags, a suggested order to act on
+// them, and open questions. The build-up phases scaffold doesn't fit audits
+// (e.g. the onboarding audit), which is why this shape recurs by hand.
+function auditPlanBody(title, bodyInput, today) {
+  return `
+# ${title}
+
+> One-paragraph: what was audited, and the headline finding.
+
+## Problem
+
+${bodyInput?.trim() ?? ''}
+
+## Findings (ranked)
+
+### 1. <finding> [impact]
+
+
+
+### 2. <finding> [impact]
+
+
+
+## Suggested order
+
+1. <which finding to act on first, and why>
+
+## Open Questions
+
+
+
+## Version History
+
+- **${today}** Created (audit).
+`;
+}
+
 // Minimal child plan stub for a scaffolded runlist child. parent_plan points
 // back at the hub (same dir) so \`dotmd doctor\` is satisfied and the reverse
 // link/graph work; status starts `planned` (queued behind the hub).
@@ -402,11 +469,15 @@ export async function runNew(argv, config, opts = {}) {
   let showFiles = opts.showFiles ?? false;
   let runlistArg = null;     // --runlist a,b,c  → sprint hub + child stubs
   let coordination = false;  // --coordination   → coordination hub skeleton
+  let lite = false;          // --lite/--minimal → trimmed plan body
+  let audit = false;         // --audit/--findings → ranked-findings plan body
   for (let i = 0; i < argv.length; i++) {
     if (argv[i] === '--status' && argv[i + 1]) { status = argv[++i]; continue; }
     if (argv[i] === '--title' && argv[i + 1]) { title = argv[++i]; continue; }
     if (argv[i] === '--runlist' && argv[i + 1]) { runlistArg = argv[++i]; continue; }
     if (argv[i] === '--coordination') { coordination = true; continue; }
+    if (argv[i] === '--lite' || argv[i] === '--minimal') { lite = true; continue; }
+    if (argv[i] === '--audit' || argv[i] === '--findings') { audit = true; continue; }
     // --body is the canonical flag; --message is a back-compat alias.
     if ((argv[i] === '--body' || argv[i] === '--message') && argv[i + 1]) {
       bodyFlagName = argv[i];
@@ -474,16 +545,28 @@ export async function runNew(argv, config, opts = {}) {
     die(`Invalid status \`${status}\` for type \`${typeName}\`\nValid: ${[...effective].join(', ')}`);
   }
 
-  // Runlist/coordination hubs are a plan shape, not a separate type. Guard the
-  // flags to type plan and reject the contradictory combination (a sprint
-  // `runlist:` array vs a prose-first coordination map are different shapes).
+  // Runlist/coordination hubs and the --lite/--audit variants are all plan
+  // *body shapes*, not separate types. Guard them to type plan and reject any
+  // combination — a plan has exactly one body shape (a sprint `runlist:` array,
+  // a prose-first coordination map, a trimmed lite plan, or a ranked-findings
+  // audit are mutually exclusive).
   const isRunlistHub = runlistArg !== null;
   const isCoordinationHub = coordination;
-  if ((isRunlistHub || isCoordinationHub) && typeName !== 'plan') {
-    die(`--${isRunlistHub ? 'runlist' : 'coordination'} only applies to plans. Use: dotmd new plan <name> --${isRunlistHub ? 'runlist a,b,c' : 'coordination'}`);
-  }
-  if (isRunlistHub && isCoordinationHub) {
-    die('--runlist and --coordination are mutually exclusive: a sprint runlist hub carries an ordered `runlist:` array; a coordination hub is a prose-first map (`execution_mode: coordination`). Pick one.');
+  const isLite = lite;
+  const isAudit = audit;
+  const planShapes = [
+    ['--runlist', isRunlistHub],
+    ['--coordination', isCoordinationHub],
+    ['--lite', isLite],
+    ['--audit', isAudit],
+  ].filter(([, on]) => on);
+  if (planShapes.length > 0 && typeName !== 'plan') {
+    const flag = planShapes[0][0];
+    const usage = flag === '--runlist' ? '--runlist a,b,c' : flag;
+    die(`${flag} only applies to plans. Use: dotmd new plan <name> ${usage}`);
+  }
+  if (planShapes.length > 1) {
+    die(`${planShapes.map(([f]) => f).join(' and ')} are mutually exclusive — a plan has one body shape. Pick one.`);
   }
   const runlistTokens = isRunlistHub
     ? runlistArg.split(',').map(s => s.trim()).filter(Boolean)
@@ -652,6 +735,8 @@ export async function runNew(argv, config, opts = {}) {
     let body;
     if (isRunlistHub) body = runlistHubBody(docTitle, slug, runlistChildren, bodyInput, today);
     else if (isCoordinationHub) body = coordinationHubBody(docTitle, bodyInput, today);
+    else if (isLite) body = litePlanBody(docTitle, bodyInput, today);
+    else if (isAudit) body = auditPlanBody(docTitle, bodyInput, today);
     else body = template.body(docTitle, tmplCtx);
     content = `---\n${fm}\n---\n${body}`;
   }
@@ -669,7 +754,11 @@ export async function runNew(argv, config, opts = {}) {
     rootHint = `Root: ${chosenLabel} (others: ${others.join(', ')} — pass --root <name> to change)\n`;
   }
 
-  const hubKind = isRunlistHub ? ' (runlist hub)' : isCoordinationHub ? ' (coordination hub)' : '';
+  const hubKind = isRunlistHub ? ' (runlist hub)'
+    : isCoordinationHub ? ' (coordination hub)'
+    : isLite ? ' (lite plan)'
+    : isAudit ? ' (audit plan)'
+    : '';
 
   if (dryRun) {
     process.stdout.write(`${dim('[dry-run]')} Would create: ${repoPath}\n`);