dotmd-cli 0.28.1 → 0.29.0

package/bin/dotmd.mjs

@@ -571,12 +571,16 @@ Subcommands:
   list                       List pending prompts (default)
   next                       Consume the oldest pending prompt:
                              print body to stdout, flip status to archived
-  use <file>                 Consume a specific prompt (same as next, but
-                             targets <file> instead of picking oldest)
-  archive <file>             Archive a prompt without printing its body
+  use <file-or-slug>         Consume a specific prompt (same as next, but
+                             targets the named prompt instead of picking oldest)
+  archive <file-or-slug>     Archive a prompt without printing its body
   new <slug> [body]          Create a new prompt (alias for
                              \`dotmd new prompt <slug> [body]\`)
 
+\`<file-or-slug>\` accepts: an exact path (with or without .md), a bare
+slug matching a prompt basename, or a unique substring of a prompt
+path. Ambiguous substrings error with the candidate list.
+
 Default prompt statuses: pending, claimed, archived.
 
 Examples:
@@ -586,10 +590,11 @@ Examples:
   dotmd prompts --json                 # JSON output
 
   claude "$(dotmd prompts next)"       # consume oldest pending + run claude
-  claude "$(dotmd prompts use docs/prompts/foo.md)"
+  claude "$(dotmd prompts use resume-foo)"           # by slug
+  claude "$(dotmd prompts use docs/prompts/foo.md)"  # by path
 
   dotmd prompts next --dry-run         # preview without consuming
-  dotmd prompts archive docs/prompts/old.md
+  dotmd prompts archive old-thing
   dotmd prompts new my-prompt "Body text here"`,
 
   stale: `dotmd stale — list stale documents

package/package.json

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

package/src/hud.mjs

@@ -16,9 +16,23 @@ function previewList(items, max = MAX_PREVIEW) {
   return slugs.join(', ') + more;
 }
 
-function findPendingPrompts(config) {
+// Statuses that count as "actionable" for a prompt are derived from config:
+// types.prompt.context.expanded (the statuses the user wants prominently shown).
+// Falls back to ['pending'] when no prompt type is configured (defensive default
+// for stripped-down configs). This means a user who customizes
+// types.prompt.statuses to add e.g. `urgent: { context: 'expanded' }` gets that
+// status surfaced too, without needing a code change.
+export function actionablePromptStatuses(config) {
+  const promptCtx = config.typeContextConfig?.get('prompt');
+  const expanded = promptCtx?.expanded;
+  if (Array.isArray(expanded) && expanded.length > 0) return new Set(expanded);
+  return new Set(['pending']);
+}
+
+function findActionablePrompts(config) {
   const roots = config.docsRoots || (config.docsRoot ? [config.docsRoot] : []);
   const archiveDir = config.archiveDir || 'archived';
+  const actionable = actionablePromptStatuses(config);
   const found = [];
   const seen = new Set();
 
@@ -43,7 +57,7 @@ function findPendingPrompts(config) {
       if (!frontmatter) continue;
       const fm = parseSimpleFrontmatter(frontmatter);
       if (asString(fm.type) !== 'prompt') continue;
-      if (asString(fm.status) !== 'pending') continue;
+      if (!actionable.has(asString(fm.status))) continue;
       found.push(toRepoPath(filePath, config.repoRoot));
     }
   }
@@ -57,7 +71,7 @@ export function buildHud(config) {
   const owned = Object.values(leases).filter(l => l.session === session).map(l => l.path);
   const queued = listQueuedHandoffs(config).map(h => h.repoPath);
   const stale = findStaleLeases(config).map(l => l.path);
-  const prompts = findPendingPrompts(config);
+  const prompts = findActionablePrompts(config);
 
   return { owned, queued, stale, prompts };
 }

package/src/prompts.mjs

@@ -1,4 +1,5 @@
 import { readFileSync, statSync } from 'node:fs';
+import path from 'node:path';
 import { extractFrontmatter, parseSimpleFrontmatter } from './frontmatter.mjs';
 import { asString, toRepoPath, die, resolveDocPath } from './util.mjs';
 import { buildIndex } from './index.mjs';
@@ -74,11 +75,46 @@ function runPromptsNext(argv, config, opts = {}) {
   consumePrompt(head.abs, config, opts);
 }
 
+// Resolve user input to a prompt path. Tries (in order): exact path,
+// path + '.md', exact basename match across type: prompt docs, substring
+// match across type: prompt docs. Returns the absolute path or dies with a
+// helpful message (no match / ambiguous match).
+function resolvePromptInput(input, config) {
+  const direct = resolveDocPath(input, config);
+  if (direct) return direct;
+
+  if (!input.endsWith('.md')) {
+    const withExt = resolveDocPath(input + '.md', config);
+    if (withExt) return withExt;
+  }
+
+  const index = buildIndex(config);
+  const prompts = index.docs.filter(d => d.type === 'prompt');
+  if (prompts.length === 0) die(`No prompts in the index.`);
+
+  const slug = input.replace(/\.md$/, '');
+
+  const byBasename = prompts.filter(d => path.basename(d.path, '.md') === slug);
+  if (byBasename.length === 1) return path.resolve(config.repoRoot, byBasename[0].path);
+  if (byBasename.length > 1) {
+    die(`Multiple prompts match "${input}" by basename:\n${byBasename.map(d => '  ' + d.path).join('\n')}`);
+  }
+
+  const bySubstring = prompts.filter(d =>
+    d.path.includes(slug) || path.basename(d.path).includes(slug),
+  );
+  if (bySubstring.length === 1) return path.resolve(config.repoRoot, bySubstring[0].path);
+  if (bySubstring.length > 1) {
+    die(`Multiple prompts match "${input}":\n${bySubstring.map(d => '  ' + d.path).join('\n')}`);
+  }
+
+  die(`No prompt found matching: ${input}`);
+}
+
 function runPromptsUse(argv, config, opts = {}) {
   const input = argv.find(a => !a.startsWith('-'));
-  if (!input) die('Usage: dotmd prompts use <file>');
-  const filePath = resolveDocPath(input, config);
-  if (!filePath) die(`File not found: ${input}`);
+  if (!input) die('Usage: dotmd prompts use <file-or-slug>');
+  const filePath = resolvePromptInput(input, config);
   consumePrompt(filePath, config, opts);
 }
 
@@ -113,9 +149,8 @@ function consumePrompt(filePath, config, opts) {
 
 function runPromptsArchive(argv, config, opts = {}) {
   const input = argv.find(a => !a.startsWith('-'));
-  if (!input) die('Usage: dotmd prompts archive <file>');
-  const filePath = resolveDocPath(input, config);
-  if (!filePath) die(`File not found: ${input}`);
+  if (!input) die('Usage: dotmd prompts archive <file-or-slug>');
+  const filePath = resolvePromptInput(input, config);
 
   const raw = readFileSync(filePath, 'utf8');
   const { frontmatter } = extractFrontmatter(raw);

package/src/validate.mjs

@@ -6,10 +6,13 @@ import { toRepoPath } from './util.mjs';
 const NOW = new Date();
 
 function isValidStatus(status, root, config, type) {
-  // Union type-specific + root-specific statuses (a doc can satisfy either)
+  // When a doc declares a known type, that type's status set is authoritative.
+  // Falling through to the global union (across all types) would allow a
+  // `type: prompt` doc to carry `status: active` just because `active` is valid
+  // for plans — defeating the purpose of type-scoped vocabularies.
   if (type) {
     const typeSet = config.typeStatuses?.get(type);
-    if (typeSet && typeSet.has(status)) return true;
+    if (typeSet) return typeSet.has(status);
   }
   const rootSet = config.rootValidStatuses?.get(root);
   if (rootSet) return rootSet.has(status);
@@ -27,8 +30,11 @@ export function validateDoc(doc, frontmatter, headingTitle, config) {
   } else if (!isValidStatus(doc.status, doc.root, config, doc.type)) {
     const typeSet = doc.type && config.typeStatuses?.get(doc.type);
     const rootSet = config.rootValidStatuses?.get(doc.root);
-    const combined = new Set([...(typeSet ?? []), ...(rootSet ?? config.validStatuses)]);
-    const hint = `valid: ${[...combined].join(', ')}`;
+    // When the doc has a known type, scope the error hint to that type's vocab.
+    // Otherwise fall back to root-specific or global validStatuses.
+    const hint = typeSet
+      ? `valid for type \`${doc.type}\`: ${[...typeSet].join(', ')}`
+      : `valid: ${[...(rootSet ?? config.validStatuses)].join(', ')}`;
     doc.errors.push({ path: doc.path, level: 'error', message: `Unknown status \`${doc.status}\`; ${hint}.` });
   }