roadmapsmith 0.9.37 → 0.9.39

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "roadmapsmith",
-  "version": "0.9.37",
+  "version": "0.9.39",
   "description": "Evidence-backed ROADMAP.md workflows for AI coding agents, with canonical RoadmapSmith status and maintain surfaces plus advanced sync/generate tools and legacy compatibility aliases.",
   "author": {
     "name": "PapiScholz"

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "roadmapsmith",
-  "version": "0.9.37",
+  "version": "0.9.39",
   "description": "Evidence-backed ROADMAP.md workflows for AI coding agents, with canonical RoadmapSmith status and maintain surfaces plus advanced sync/generate tools and legacy compatibility aliases.",
   "author": {
     "name": "PapiScholz"

package/bin/cli.js

@@ -29,8 +29,8 @@ function printHelp() {
     '  Canonical commands:',
     '  roadmapsmith zero [--project-root <path>] [--config <path>] [--product-name <text>] [--primary-user <text>] [--problem-statement <text>] [--target-outcome <text>] [--anti-goal <text> ...] [--preferred-stack <text>] [--constraint <text> ...] [--done-criterion <text> ...]',
     '  roadmapsmith maintain [--project-root <path>] [--config <path>] [--roadmap-file <path>] [--dry-run] [--full-regen] [--refresh-annotations]',
-    '  roadmapsmith status [--roadmap-file <path>] [--project-root <path>] [--config <path>] [--json]',
-    '  roadmapsmith validate [--roadmap-file <path>] [--project-root <path>] [--config <path>] [--task <id|text>] [--json] [--strict]',
+    '  roadmapsmith status [--roadmap-file <path>] [--project-root <path>] [--config <path>] [--json] [--no-vscode]',
+    '  roadmapsmith validate [--roadmap-file <path>] [--project-root <path>] [--config <path>] [--task <id|text>] [--json] [--strict] [--hide-planned]',
     '  roadmapsmith update [--task <stable-id> --evidence <text>] [--roadmap-file <path>] [--project-root <path>] [--config <path>] [--dry-run]',
     '  roadmapsmith setup [--project-root <path>] [--config <path>] [--editor vscode] [--hosts <codex,claude>] [--dry-run]',
     '',
@@ -58,6 +58,9 @@ function isEnabled(value) {
 }
 
 function formatResultLine(task, result) {
+  if (result.planned) {
+    return `PLAN [${task.id}] ${task.text}`;
+  }
   const diagnostics = Array.isArray(result.diagnostics) ? result.diagnostics : [];
   const primaryError = diagnostics.find((item) => item.severity === 'error');
   const warnings = diagnostics.filter((item) => item.severity === 'warning');
@@ -322,6 +325,8 @@ function runSyncCommand(projectRoot, config, flags, options = {}) {
     console.log(writeResult.changed ? `Updated ${roadmapFile}` : `No changes for ${roadmapFile}`);
   }
 
+  // options.audit (distinct from flags.audit early return above): used only by
+  // runMaintainCommand to print audit summary AFTER mutating ROADMAP.md.
   if (options.audit) {
     const audit = auditValidation(syncTasks, results, changes);
     printAudit(audit);
@@ -412,19 +417,21 @@ function printHumanStatus(payload) {
   console.log(`CLI resolution: ${payload.cli.kind}${payload.cli.path ? ` (${payload.cli.path})` : ''}${payload.cli.ready ? '' : ' [missing]'}`);
   console.log(`Roadmap file: ${payload.roadmap.exists ? 'ready' : 'missing'} (${payload.roadmap.path})`);
   console.log(`Agent rules: ${payload.agents.exists ? 'ready' : 'missing'} (${payload.agents.path})`);
-  console.log(`VS Code launcher: ${payload.vscode.launcher.exists ? 'ready' : 'missing'} (${payload.vscode.launcher.path})`);
-  console.log(`VS Code task wrappers: ${payload.vscode.wrappers.ready ? 'ready' : 'incomplete'} (${payload.vscode.wrappers.presentCount}/${payload.vscode.wrappers.expectedCount} files)`);
-  console.log(`VS Code tasks: ${payload.vscode.tasks.ready ? 'ready' : 'incomplete'} (${payload.vscode.tasks.presentLabels.length}/${payload.vscode.tasks.expectedLabels.length} tasks)`);
-  console.log(`Node runtime: ${payload.runtime.ready ? `ready (${payload.runtime.kind}${payload.runtime.path ? `: ${payload.runtime.path}` : ''})` : 'missing'}`);
-  if (!payload.vscode.tasks.ready && payload.vscode.tasks.missingLabels.length > 0) {
-    console.log(`Missing VS Code tasks: ${payload.vscode.tasks.missingLabels.join(', ')}`);
-  }
-  if (Array.isArray(payload.vscode.tasks.missingAdvancedLabels) && payload.vscode.tasks.missingAdvancedLabels.length > 0) {
-    console.log(`Missing advanced VS Code tasks: ${payload.vscode.tasks.missingAdvancedLabels.join(', ')}`);
-  }
-  if (!payload.vscode.wrappers.ready) {
-    console.log(`Missing task wrapper files: ${payload.vscode.wrappers.missingPaths.join(', ')}`);
+  if (!payload.vscode.skipped) {
+    console.log(`VS Code launcher: ${payload.vscode.launcher.exists ? 'ready' : 'missing'} (${payload.vscode.launcher.path})`);
+    console.log(`VS Code task wrappers: ${payload.vscode.wrappers.ready ? 'ready' : 'incomplete'} (${payload.vscode.wrappers.presentCount}/${payload.vscode.wrappers.expectedCount} files)`);
+    console.log(`VS Code tasks: ${payload.vscode.tasks.ready ? 'ready' : 'incomplete'} (${payload.vscode.tasks.presentLabels.length}/${payload.vscode.tasks.expectedLabels.length} tasks)`);
+    if (!payload.vscode.tasks.ready && payload.vscode.tasks.missingLabels.length > 0) {
+      console.log(`Missing VS Code tasks: ${payload.vscode.tasks.missingLabels.join(', ')}`);
+    }
+    if (Array.isArray(payload.vscode.tasks.missingAdvancedLabels) && payload.vscode.tasks.missingAdvancedLabels.length > 0) {
+      console.log(`Missing advanced VS Code tasks: ${payload.vscode.tasks.missingAdvancedLabels.join(', ')}`);
+    }
+    if (!payload.vscode.wrappers.ready) {
+      console.log(`Missing task wrapper files: ${payload.vscode.wrappers.missingPaths.join(', ')}`);
+    }
   }
+  console.log(`Node runtime: ${payload.runtime.ready ? `ready (${payload.runtime.kind}${payload.runtime.path ? `: ${payload.runtime.path}` : ''})` : 'missing'}`);
   console.log(`Codex readiness: ${payload.hosts.codex.ready ? 'ready' : 'needs setup'} (${payload.hosts.codex.message})`);
   console.log(`Claude readiness: ${payload.hosts.claude.ready ? 'ready' : 'needs setup'} (${payload.hosts.claude.message})`);
   printReadinessSummary(payload.summary);
@@ -434,15 +441,20 @@ function printHumanStatus(payload) {
   if (!payload.cli.ready) {
     console.log('\nInstalling the skill alone does not expose the CLI in VS Code. Install the CLI and rerun roadmapsmith setup.');
   }
-  if (!payload.runtime.ready) {
+  if (!payload.vscode.skipped && !payload.runtime.ready) {
     console.log('\nThe VS Code task runtime is missing. Install Node.js or set ROADMAPSMITH_NODE, then rerun RoadmapSmith: Status.');
   }
 }
 
+function shouldSkipVscode(projectRoot, flags) {
+  return isEnabled(flags['no-vscode']) || !fs.existsSync(path.join(projectRoot, '.vscode'));
+}
+
 function runStatusCommand(projectRoot, config, flags, options = {}) {
+  const skipVscode = shouldSkipVscode(projectRoot, flags);
   const roadmapFile = resolveRoadmapFile(projectRoot, config, flags['roadmap-file']);
   const agentsFile = resolveAgentsFile(projectRoot, config, flags['agents-file']);
-  const payload = inspectHostSetup(projectRoot, { roadmapFile, agentsFile, currentCliPath: __filename });
+  const payload = inspectHostSetup(projectRoot, { roadmapFile, agentsFile, currentCliPath: __filename, skipVscode });
 
   if (options.json) {
     process.stdout.write(JSON.stringify(payload, null, 2) + '\n');
@@ -450,7 +462,7 @@ function runStatusCommand(projectRoot, config, flags, options = {}) {
     printHumanStatus(payload);
   }
 
-  const ready = payload.cli.ready && payload.roadmap.exists && payload.agents.exists && payload.vscode.tasks.ready && payload.runtime.ready && payload.claude.ready;
+  const ready = payload.cli.ready && payload.roadmap.exists && payload.agents.exists && (payload.vscode.skipped || payload.vscode.tasks.ready) && payload.runtime.ready && payload.claude.ready;
   if (!ready) {
     process.exitCode = 1;
   }
@@ -661,7 +673,12 @@ async function run() {
     const results = validateTasks(tasks, validationContext, config, validationContext.plugins);
 
     const minRank = CONFIDENCE_RANK[config.validation && config.validation.minimumConfidence] ?? 0;
-    const visibleTasks = tasks.filter((task) => (CONFIDENCE_RANK[results[task.id].confidence] ?? 0) >= minRank);
+    const hidePlanned = isEnabled(flags['hide-planned']);
+    const visibleTasks = tasks.filter((task) => {
+      if ((CONFIDENCE_RANK[results[task.id].confidence] ?? 0) < minRank) return false;
+      if (hidePlanned && results[task.id].planned) return false;
+      return true;
+    });
 
     if (isEnabled(flags.json)) {
       const payload = visibleTasks.map((task) => ({ task, result: results[task.id] }));
@@ -672,7 +689,7 @@ async function run() {
       });
     }
 
-    const failed = visibleTasks.some((task) => !results[task.id].passed);
+    const failed = visibleTasks.some((task) => !results[task.id].passed && !results[task.id].planned);
     if (failed) {
       process.exitCode = 1;
     }
@@ -681,6 +698,7 @@ async function run() {
 
   if (effectiveCommand === 'status' || effectiveCommand === 'doctor') {
     const projectRoot = path.resolve(String(flags['project-root'] || process.cwd()));
+    const skipVscode = shouldSkipVscode(projectRoot, flags);
     let ok = true;
     const jsonMode = isEnabled(flags.json);
     const log = jsonMode ? () => {} : console.log;
@@ -718,7 +736,7 @@ async function run() {
     let hostStatus = null;
     if (config) {
       try {
-        hostStatus = inspectHostSetup(projectRoot, { roadmapFile, agentsFile });
+        hostStatus = inspectHostSetup(projectRoot, { roadmapFile, agentsFile, skipVscode });
       } catch (error) {
         logError(`[fail] Host integration error: ${error.message}`);
         ok = false;
@@ -733,35 +751,37 @@ async function run() {
         ok = false;
       }
 
-      if (hostStatus.vscode.launcher.exists) {
-        log(`[ok] VS Code launcher found: ${hostStatus.vscode.launcher.path}`);
-      } else {
-        logError(`[fail] VS Code launcher missing: ${hostStatus.vscode.launcher.path}`);
-        ok = false;
-      }
-
-      if (hostStatus.vscode.wrappers.ready) {
-        log(`[ok] VS Code task wrappers ready: ${hostStatus.vscode.wrappers.presentCount}/${hostStatus.vscode.wrappers.expectedCount} files`);
-      } else {
-        logError(`[fail] VS Code task wrappers incomplete: missing ${hostStatus.vscode.wrappers.missingPaths.join(', ') || 'wrapper files'}`);
-        ok = false;
-      }
-
-      if (hostStatus.vscode.tasks.ready) {
-        log(`[ok] VS Code tasks ready: ${hostStatus.vscode.tasks.presentLabels.length}/${hostStatus.vscode.tasks.expectedLabels.length} tasks`);
-      } else {
-        logError(`[fail] VS Code tasks incomplete: missing ${hostStatus.vscode.tasks.missingLabels.join(', ') || 'managed labels'}`);
-        ok = false;
-      }
-      if (Array.isArray(hostStatus.vscode.tasks.missingAdvancedLabels) && hostStatus.vscode.tasks.missingAdvancedLabels.length > 0) {
-        log(`[warn] Advanced VS Code tasks missing: ${hostStatus.vscode.tasks.missingAdvancedLabels.join(', ')}`);
-      }
-
-      if (hostStatus.runtime.ready) {
-        log(`[ok] Node runtime: ${hostStatus.runtime.kind}${hostStatus.runtime.path ? ` (${hostStatus.runtime.path})` : ''}`);
-      } else {
-        logError('[fail] Node runtime missing for VS Code task execution');
-        ok = false;
+      if (!skipVscode) {
+        if (hostStatus.vscode.launcher.exists) {
+          log(`[ok] VS Code launcher found: ${hostStatus.vscode.launcher.path}`);
+        } else {
+          logError(`[fail] VS Code launcher missing: ${hostStatus.vscode.launcher.path}`);
+          ok = false;
+        }
+
+        if (hostStatus.vscode.wrappers.ready) {
+          log(`[ok] VS Code task wrappers ready: ${hostStatus.vscode.wrappers.presentCount}/${hostStatus.vscode.wrappers.expectedCount} files`);
+        } else {
+          logError(`[fail] VS Code task wrappers incomplete: missing ${hostStatus.vscode.wrappers.missingPaths.join(', ') || 'wrapper files'}`);
+          ok = false;
+        }
+
+        if (hostStatus.vscode.tasks.ready) {
+          log(`[ok] VS Code tasks ready: ${hostStatus.vscode.tasks.presentLabels.length}/${hostStatus.vscode.tasks.expectedLabels.length} tasks`);
+        } else {
+          logError(`[fail] VS Code tasks incomplete: missing ${hostStatus.vscode.tasks.missingLabels.join(', ') || 'managed labels'}`);
+          ok = false;
+        }
+        if (Array.isArray(hostStatus.vscode.tasks.missingAdvancedLabels) && hostStatus.vscode.tasks.missingAdvancedLabels.length > 0) {
+          log(`[warn] Advanced VS Code tasks missing: ${hostStatus.vscode.tasks.missingAdvancedLabels.join(', ')}`);
+        }
+
+        if (hostStatus.runtime.ready) {
+          log(`[ok] Node runtime: ${hostStatus.runtime.kind}${hostStatus.runtime.path ? ` (${hostStatus.runtime.path})` : ''}`);
+        } else {
+          logError('[fail] Node runtime missing for VS Code task execution');
+          ok = false;
+        }
       }
 
       if (hostStatus.claude.ready) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roadmapsmith",
-  "version": "0.9.37",
+  "version": "0.9.39",
   "description": "Evidence-backed ROADMAP.md workflows for AI coding agents, with canonical RoadmapSmith status and maintain surfaces plus advanced sync/generate tools and legacy compatibility aliases.",
   "main": "src/index.js",
   "bin": {

package/skills.json

@@ -28,67 +28,67 @@
       "name": "roadmap",
       "path": "skills/roadmap",
       "description": "Native slash palette for RoadmapSmith commands and recommended entrypoints across supported hosts.",
-      "version": "0.9.37"
+      "version": "0.9.39"
     },
     {
       "name": "roadmap-zero",
       "path": "skills/roadmap-zero",
       "description": "Native slash entrypoint for Zero Mode, including non-interactive config-plus-flag discovery.",
-      "version": "0.9.37"
+      "version": "0.9.39"
     },
     {
       "name": "roadmap-maintain",
       "path": "skills/roadmap-maintain",
       "description": "Native slash entrypoint for conservative managed-block maintenance plus sync and audit output.",
-      "version": "0.9.37"
+      "version": "0.9.39"
     },
     {
       "name": "roadmap-status",
       "path": "skills/roadmap-status",
       "description": "Native slash readiness check grounded in roadmapsmith status JSON.",
-      "version": "0.9.37"
+      "version": "0.9.39"
     },
     {
       "name": "roadmap-init",
       "path": "skills/roadmap-init",
       "description": "Native slash entrypoint for creating ROADMAP.md and AGENTS.md.",
-      "version": "0.9.37"
+      "version": "0.9.39"
     },
     {
       "name": "roadmap-generate",
       "path": "skills/roadmap-generate",
       "description": "Native slash entrypoint for managed roadmap updates that require --full-regen before destructive replacement.",
-      "version": "0.9.37"
+      "version": "0.9.39"
     },
     {
       "name": "roadmap-validate",
       "path": "skills/roadmap-validate",
       "description": "Native slash entrypoint for evidence-backed roadmap validation.",
-      "version": "0.9.37"
+      "version": "0.9.39"
     },
     {
       "name": "roadmap-update",
       "path": "skills/roadmap-update",
       "description": "Native slash entrypoint for evidence-backed inline annotation refresh and verified single-task completion.",
-      "version": "0.9.37"
+      "version": "0.9.39"
     },
     {
       "name": "roadmap-sync",
       "path": "skills/roadmap-sync",
       "description": "DEPRECATED legacy compatibility root; use roadmap-maintain or roadmap-update.",
-      "version": "0.9.37"
+      "version": "0.9.39"
     },
     {
       "name": "roadmap-audit",
       "path": "skills/roadmap-audit",
       "description": "Native slash entrypoint for the advanced sync-plus-audit mutating summary workflow.",
-      "version": "0.9.37"
+      "version": "0.9.39"
     },
     {
       "name": "roadmap-setup",
       "path": "skills/roadmap-setup",
       "description": "Native slash entrypoint for generating RoadmapSmith host integration files.",
-      "version": "0.9.37"
+      "version": "0.9.39"
     }
   ]
 }

package/src/generator/index.js

@@ -61,10 +61,17 @@ function detectModules(files) {
     }
   }
 
+  for (const file of files) {
+    const parts = file.split('/');
+    if (parts.length === 2 && parts[1] === '__init__.py' && parts[0] && !GENERIC_MODULE_NAMES.has(parts[0])) {
+      modules.add(parts[0]);
+    }
+  }
+
   return Array.from(modules).sort((left, right) => left.localeCompare(right));
 }
 
-function detectCommands(files) {
+function detectCommands(files, projectRoot) {
   const commands = new Set();
   for (const file of files) {
     if (file.startsWith('bin/')) {
@@ -74,6 +81,44 @@ function detectCommands(files) {
       commands.add(file.split('/')[1] || file);
     }
   }
+  if (projectRoot) {
+    let pkgContent = null;
+    try {
+      pkgContent = fs.readFileSync(path.join(projectRoot, 'package.json'), 'utf8');
+    } catch (err) {
+      if (err.code !== 'ENOENT') {
+        process.stderr.write(`roadmapsmith: failed to read package.json: ${err.message}\n`);
+      }
+    }
+    if (pkgContent) {
+      try {
+        const pkg = JSON.parse(pkgContent);
+        if (pkg.bin) {
+          const binNames = typeof pkg.bin === 'string'
+            ? [path.basename(projectRoot)]
+            : Object.keys(pkg.bin);
+          for (const name of binNames) commands.add(name);
+        }
+      } catch (err) {
+        process.stderr.write(`roadmapsmith: failed to parse package.json: ${err.message}\n`);
+      }
+    }
+    let tomlContent = null;
+    try {
+      tomlContent = fs.readFileSync(path.join(projectRoot, 'pyproject.toml'), 'utf8');
+    } catch (err) {
+      if (err.code !== 'ENOENT') {
+        process.stderr.write(`roadmapsmith: failed to read pyproject.toml: ${err.message}\n`);
+      }
+    }
+    if (tomlContent) {
+      for (const sectionMatch of tomlContent.matchAll(/\[(?:project\.scripts|tool\.poetry\.scripts)\]([\s\S]*?)(?:\n\[|$)/g)) {
+        for (const entryMatch of sectionMatch[1].matchAll(/^([\w-]+)\s*=/gm)) {
+          commands.add(entryMatch[1]);
+        }
+      }
+    }
+  }
   return Array.from(commands).sort((left, right) => left.localeCompare(right));
 }
 
@@ -144,7 +189,7 @@ function scanProject(projectRoot) {
   const languages = detectLanguages(files);
   const testFrameworks = detectTestFrameworks(projectRoot, files);
   const modules = detectModules(files);
-  const commands = detectCommands(files);
+  const commands = detectCommands(files, projectRoot);
   const todos = collectTodoHints(projectRoot, files);
   const codeTodos = collectCodeTodoHints(projectRoot, files);
   const workspaces = detectWorkspaces(projectRoot, files);
@@ -183,6 +228,25 @@ function toCandidate(text, phase, priority, source = 'default') {
   };
 }
 
+function buildDoneCriteriaCandidates(zeroModeConfig) {
+  if (!Array.isArray(zeroModeConfig.doneCriteria) || zeroModeConfig.doneCriteria.length === 0) {
+    return [];
+  }
+  return zeroModeConfig.doneCriteria.map((criterion) => {
+    const phaseMatch = String(criterion).match(/^\s*\[(P[0-2])\]\s*/i);
+    const phase = phaseMatch ? phaseMatch[1].toUpperCase() : 'P0';
+    const text = phaseMatch ? criterion.slice(phaseMatch[0].length).trim() : criterion;
+    return {
+      id: slugify(`zm-${text}`),
+      text,
+      phase,
+      priority: phase,
+      checked: false,
+      source: 'doneCriteria'
+    };
+  });
+}
+
 function hasSubstantiveManagedBlock(parsedRoadmap) {
   if (!parsedRoadmap || !parsedRoadmap.managedRange) {
     return false;
@@ -203,8 +267,9 @@ function stripTrailingBlankLines(lines) {
   return next;
 }
 
-function renderAdditionTask(task) {
-  return `- [ ] ${task.text} <!-- rs:task=${task.id} -->`;
+function renderAdditionTask(task, planned = false) {
+  const flag = planned ? ' planned' : '';
+  return `- [ ] ${task.text} <!-- rs:task=${task.id}${flag} -->`;
 }
 
 function isGenericPreserveModeCandidate(candidate) {
@@ -215,6 +280,7 @@ function buildManagedAdditionsLines(tasks, options = {}) {
   const groups = groupByPhase(tasks);
   const lines = [];
   const includeSectionHeading = options.includeSectionHeading !== false;
+  const plannedById = options.plannedById || {};
 
   if (includeSectionHeading) {
     lines.push(`## ${ADDITIONS_SECTION_TITLE}`);
@@ -227,7 +293,7 @@ function buildManagedAdditionsLines(tasks, options = {}) {
     }
     lines.push(`### Phase ${phase}`);
     for (const task of groups[phase]) {
-      lines.push(renderAdditionTask(task));
+      lines.push(renderAdditionTask(task, Boolean(plannedById[task.id])));
     }
     lines.push('');
   }
@@ -400,12 +466,13 @@ function findPhaseSectionRange(lines, managedRange, phase) {
   };
 }
 
-function buildPreserveModeInsertions(parsedRoadmap, tasks) {
+function buildPreserveModeInsertions(parsedRoadmap, tasks, plannedById = {}) {
   const managedTasks = sortTasksByPhaseAndText(tasksInManagedBlock(parsedRoadmap));
   const groups = groupByPhase(tasks);
   const lines = parsedRoadmap.lines;
   const insertions = [];
   const fallbackTasks = [];
+  const renderTask = (t) => renderAdditionTask(t, Boolean(plannedById[t.id]));
 
   for (const phase of PHASE_ORDER) {
     const phaseTasks = sortTasksByPhaseAndText(groups[phase] || []);
@@ -423,7 +490,7 @@ function buildPreserveModeInsertions(parsedRoadmap, tasks) {
       }, null);
       insertions.push({
         index: anchor.lastChildLineIndex + 1,
-        lines: phaseTasks.map(renderAdditionTask)
+        lines: phaseTasks.map(renderTask)
       });
       continue;
     }
@@ -436,7 +503,7 @@ function buildPreserveModeInsertions(parsedRoadmap, tasks) {
       }
       insertions.push({
         index: insertionIndex,
-        lines: phaseTasks.map(renderAdditionTask)
+        lines: phaseTasks.map(renderTask)
       });
       continue;
     }
@@ -445,7 +512,7 @@ function buildPreserveModeInsertions(parsedRoadmap, tasks) {
   }
 
   if (fallbackTasks.length > 0) {
-    const fallbackLines = buildManagedAdditionsLines(fallbackTasks, { includeSectionHeading: true });
+    const fallbackLines = buildManagedAdditionsLines(fallbackTasks, { includeSectionHeading: true, plannedById });
     insertions.push({
       index: parsedRoadmap.managedRange.end,
       lines: ['', ...fallbackLines]
@@ -455,13 +522,13 @@ function buildPreserveModeInsertions(parsedRoadmap, tasks) {
   return insertions.sort((left, right) => right.index - left.index);
 }
 
-function insertPreserveModeTasks(existingContent, parsedRoadmap, tasks) {
+function insertPreserveModeTasks(existingContent, parsedRoadmap, tasks, plannedById = {}) {
   if (!parsedRoadmap || !parsedRoadmap.managedRange || tasks.length === 0) {
     return existingContent;
   }
 
   const nextLines = parsedRoadmap.lines.slice();
-  const insertions = buildPreserveModeInsertions(parsedRoadmap, tasks);
+  const insertions = buildPreserveModeInsertions(parsedRoadmap, tasks, plannedById);
   for (const insertion of insertions) {
     nextLines.splice(insertion.index, 0, ...insertion.lines);
   }
@@ -637,7 +704,7 @@ function buildSteps(phases, config) {
   }));
 }
 
-function createModel(scan, tasks, config, customSections, checkedById) {
+function createModel(scan, tasks, config, customSections, checkedById, plannedById = {}) {
   const phases = groupByPhase(tasks);
 
   const implemented = [
@@ -728,7 +795,9 @@ function createModel(scan, tasks, config, customSections, checkedById) {
     successCriteria,
     customSections,
     customPhases: config.customPhases || [],
-    checkedById
+    moduleMetadata: config.moduleMetadata || {},
+    checkedById,
+    plannedById
   });
 }
 
@@ -757,8 +826,10 @@ function generateRoadmapDocument(options) {
   const scan = scanProject(projectRoot);
   const existing = parseRoadmap(existingContent);
   const existingCheckedById = {};
+  const existingPlannedById = {};
   for (const task of existing.tasks) {
     existingCheckedById[task.id] = task.checked;
+    if (task.planned) existingPlannedById[task.id] = true;
   }
   const existingManagedTasks = tasksInManagedBlock(existing);
 
@@ -814,7 +885,14 @@ function generateRoadmapDocument(options) {
 
   const baseCandidates = buildDefaultCandidates(scan, config);
   const matcherCandidates = applyTaskMatchers(scan, config);
-  const allCandidates = dedupeTasks([...baseCandidates, ...matcherCandidates, ...pluginTaskCandidates]);
+  const doneCriteriaCandidates = buildDoneCriteriaCandidates(zeroModeConfig);
+  const allCandidates = dedupeTasks([...doneCriteriaCandidates, ...baseCandidates, ...matcherCandidates, ...pluginTaskCandidates]);
+
+  const plannedById = { ...existingPlannedById };
+  for (const candidate of doneCriteriaCandidates) {
+    const isNew = !findBestTaskMatch(candidate, existingManagedTasks, { allowFuzzy: true });
+    if (isNew) plannedById[candidate.id] = true;
+  }
 
   if (hasSubstantiveManagedBlock(existing) && preserveManagedBlock && !forceFullRegenerate) {
     const unmatchedCandidates = allCandidates.filter((candidate) => {
@@ -829,7 +907,7 @@ function generateRoadmapDocument(options) {
       return existingContent;
     }
 
-    return insertPreserveModeTasks(existingContent, existing, preserveModeCandidates);
+    return insertPreserveModeTasks(existingContent, existing, preserveModeCandidates, plannedById);
   }
 
   if (hasSubstantiveManagedBlock(existing) && !forceFullRegenerate) {
@@ -840,7 +918,7 @@ function generateRoadmapDocument(options) {
     allowFuzzy: true,
     includeUnmatchedExisting: false
   });
-  const model = createModel(scan, merged, config, [profileSection, ...generatedZeroModeSection, ...configSections, ...pluginSections], existingCheckedById);
+  const model = createModel(scan, merged, config, [profileSection, ...generatedZeroModeSection, ...configSections, ...pluginSections], existingCheckedById, plannedById);
   const profile = config.roadmapProfile || 'compact';
   const managedBody = renderBody(model, profile);
 

package/src/host.js

@@ -1318,7 +1318,10 @@ function inspectHostSetup(projectRoot, options = {}) {
   const agentsFile = options.agentsFile;
   const runtime = detectNodeRuntime(options.env || process.env);
   const cli = detectCliResolution(projectRoot, { currentCliPath: options.currentCliPath });
-  const vscode = inspectVsCodeTasks(projectRoot);
+  const skipVscode = Boolean(options.skipVscode);
+  const vscode = skipVscode
+    ? { skipped: true, launcher: { path: null, exists: false }, wrappers: { expectedCount: 2, presentCount: 0, ready: false, windows: { path: null, exists: false }, posix: { path: null, exists: false }, missingPaths: [] }, tasks: { path: null, exists: false, ready: false, expectedLabels: [], advancedLabels: [], presentLabels: [], missingLabels: [], missingAdvancedLabels: [] } }
+    : inspectVsCodeTasks(projectRoot);
   const claude = inspectClaudeSetup(projectRoot);
   const bundle = inspectSharedBundleSurface();
   const codexNative = inspectCodexPluginState(projectRoot, options);

package/src/model.js

@@ -23,7 +23,8 @@ function createRoadmapModel(input) {
     successCriteria: input.successCriteria || [],
     customSections: input.customSections || [],
     customPhases: input.customPhases || [],
-    checkedById: input.checkedById || {}
+    checkedById: input.checkedById || {},
+    plannedById: input.plannedById || {}
   };
 }
 

package/src/parser/index.js

@@ -147,6 +147,7 @@ function parseRoadmap(content) {
 
     const { indent, checked, text, markerId, markerFlags } = taskLine;
     const noTest = /\brs:no-test\b/i.test(markerFlags);
+    const isPlanned = /\bplanned\b/i.test(markerFlags);
     const kindMatch = markerFlags.match(/\brs:kind=(\S+)/i);
     const taskKind = kindMatch ? kindMatch[1].toLowerCase() : null;
     const verifiedByMatch = markerFlags.match(/\brs:verified-by=(\S+)/i);
@@ -247,6 +248,7 @@ function parseRoadmap(content) {
       blockedByIds,
       markerId,
       noTest,
+      planned: isPlanned,
       kind: taskKind,
       verifiedBy: taskVerifiedBy,
       indent,

package/src/renderer/compact.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const { slugify, ensureTrailingNewline } = require('../utils');
-const { taskLine, checkedState } = require('./helpers');
+const { taskLine, checkedState, plannedState } = require('./helpers');
 
 function renderCompact(model) {
   const lines = [];
@@ -22,17 +22,17 @@ function renderCompact(model) {
   lines.push('');
   lines.push('### Phase P0 (Critical)');
   for (const task of model.phases.P0) {
-    lines.push(taskLine(task));
+    lines.push(taskLine(task, plannedState(model, task.id)));
   }
   lines.push('');
   lines.push('### Phase P1 (Important)');
   for (const task of model.phases.P1) {
-    lines.push(taskLine(task));
+    lines.push(taskLine(task, plannedState(model, task.id)));
   }
   lines.push('');
   lines.push('### Phase P2 (Optimization)');
   for (const task of model.phases.P2) {
-    lines.push(taskLine(task));
+    lines.push(taskLine(task, plannedState(model, task.id)));
   }
   lines.push('');
 

package/src/renderer/helpers.js

@@ -1,7 +1,8 @@
 'use strict';
 
-function taskLine(task) {
-  return `- [${task.checked ? 'x' : ' '}] ${task.text} <!-- rs:task=${task.id} -->`;
+function taskLine(task, planned = false) {
+  const flag = planned ? ' planned' : '';
+  return `- [${task.checked ? 'x' : ' '}] ${task.text} <!-- rs:task=${task.id}${flag} -->`;
 }
 
 function sectionHeader(n, title) {
@@ -12,8 +13,12 @@ function checkedState(model, id) {
   return Boolean(model.checkedById && model.checkedById[id]);
 }
 
+function plannedState(model, id) {
+  return Boolean(model.plannedById && model.plannedById[id]);
+}
+
 function priorityLabel(priority) {
   return priority ? `\`[${priority}]\`` : '';
 }
 
-module.exports = { taskLine, sectionHeader, checkedState, priorityLabel };
+module.exports = { taskLine, sectionHeader, checkedState, plannedState, priorityLabel };

package/src/renderer/professional.js

@@ -1,14 +1,15 @@
 'use strict';
 
 const { slugify, ensureTrailingNewline } = require('../utils');
-const { sectionHeader, checkedState, priorityLabel } = require('./helpers');
+const { sectionHeader, checkedState, plannedState, priorityLabel } = require('./helpers');
 
 function taskLineWithPriority(task, model) {
   const pri = task.priority ? `${priorityLabel(task.priority)} ` : '';
   const id = task.id || `prof-task-${slugify(task.text || String(task))}`;
   const text = task.text || String(task);
   const checked = task.checked || checkedState(model, id);
-  return `- [${checked ? 'x' : ' '}] ${pri}${text} <!-- rs:task=${id} -->`;
+  const plannedFlag = plannedState(model, id) ? ' planned' : '';
+  return `- [${checked ? 'x' : ' '}] ${pri}${text} <!-- rs:task=${id}${plannedFlag} -->`;
 }
 
 function exitLine(item, phN, stN, model) {
@@ -203,70 +204,6 @@ function renderSection5Milestones(model, lines) {
   }
 }
 
-const MODULE_METADATA = {
-  generator: {
-    state: 'Compact and professional profiles supported; Phase→Step→Task model implemented.',
-    tasks: [
-      { text: 'Improve Phase→Step→Task model inference quality', priority: 'P0', id: 'prof-mat-generator-improve-phase-step-task-inference' },
-      { text: 'Add scan-driven task suggestions per detected module', priority: 'P1', id: 'prof-mat-generator-scan-driven-task-suggestions' }
-    ]
-  },
-  parser: {
-    state: 'Parses managed blocks, rs:task IDs, and checked state.',
-    tasks: [
-      { text: 'Add parser validation for Phase→Step hierarchy markers', priority: 'P1', id: 'prof-mat-parser-phase-hierarchy-validation' },
-      { text: 'Improve section boundary detection for professional format', priority: 'P1', id: 'prof-mat-parser-professional-section-detection' }
-    ]
-  },
-  renderer: {
-    state: 'Dispatcher supports compact, professional, and enterprise (error) profiles.',
-    tasks: [
-      { text: 'Add snapshot regression fixtures for compact and professional', priority: 'P0', id: 'prof-mat-renderer-snapshot-regression-fixtures' },
-      { text: 'Harden priority label rendering for edge cases', priority: 'P1', id: 'prof-mat-renderer-priority-label-edge-cases' }
-    ]
-  },
-  validator: {
-    state: 'Evidence-based validation against file, symbol, and test presence.',
-    tasks: [
-      { text: 'Extend validator to verify Phase→Step→Task IDs survive sync', priority: 'P1', id: 'prof-mat-validator-phase-step-task-id-sync' },
-      { text: 'Add validation coverage for professional profile task IDs', priority: 'P1', id: 'prof-mat-validator-professional-task-id-coverage' }
-    ]
-  },
-  match: {
-    state: 'Task similarity matching with edit-distance threshold.',
-    tasks: [
-      { text: 'Tune similarity threshold to reduce false-positive merges', priority: 'P0', id: 'prof-mat-match-tune-similarity-threshold' }
-    ]
-  },
-  sync: {
-    state: 'Applies validation outcomes to ROADMAP.md and can append warning lines for failed attempts.',
-    tasks: [
-      { text: 'Define explicit contract for sync, sync --audit, and future promote-only flows', priority: 'P0', id: 'prof-mat-sync-define-command-contract' },
-      { text: 'Separate mutating sync behavior from future read-only audit mode', priority: 'P0', id: 'prof-mat-sync-separate-mutation-from-read-only-audit' },
-      { text: 'Expose weak-evidence, documentation-only, and structural-mismatch findings in audit output', priority: 'P1', id: 'prof-mat-sync-expose-rich-audit-findings' },
-      { text: 'Claude PostToolUse hook must invoke the CLI without relying on bare "node" in PATH', priority: 'P0', id: 'prof-mat-sync-claude-hook-avoid-bare-node-path' },
-      { text: 'Claude PostToolUse hook must fail visibly when sync execution fails', priority: 'P0', id: 'prof-mat-sync-claude-hook-fail-visibly-on-sync-error' },
-      { text: 'Claude PostToolUse hook must keep lock-file cleanup on both success and failure', priority: 'P1', id: 'prof-mat-sync-claude-hook-cleanup-lockfile-on-both-paths' },
-      { text: 'Differentiate write-time hook sync from commit-time pre-commit sync in the command contract', priority: 'P1', id: 'prof-mat-sync-differentiate-write-time-and-pre-commit-sync' }
-    ]
-  },
-  config: {
-    state: 'Supports roadmapProfile, product block, milestones, phaseTemplates, plugins.',
-    tasks: [
-      { text: 'Add JSON schema validation for roadmap-skill.config.json', priority: 'P1', id: 'prof-mat-config-json-schema-validation' },
-      { text: 'Add init --professional or init --with-config bootstrap flow', priority: 'P0', id: 'prof-mat-config-add-init-with-config-bootstrap-flow' },
-      { text: 'Honor versioned roadmap config instead of regenerating from defaults', priority: 'P1', id: 'prof-mat-config-honor-versioned-config-before-defaults' },
-      { text: 'Define manual-to-managed migration flow and drift warnings between skill and CLI guidance', priority: 'P1', id: 'prof-mat-config-define-manual-to-managed-migration-and-drift-warnings' }
-    ]
-  },
-  io: {
-    state: 'Scans files, detects languages, test frameworks, commands, modules.',
-    tasks: [
-      { text: 'Improve module detection for monorepo workspace layouts', priority: 'P2', id: 'prof-mat-io-monorepo-workspace-detection' }
-    ]
-  }
-};
-
 function renderSection6MaturityPath(model, lines) {
   lines.push(sectionHeader(6, 'Command-by-Command / Module-by-Module Maturity Path'));
   lines.push('');
@@ -275,31 +212,40 @@ function renderSection6MaturityPath(model, lines) {
 
   if (allAreas.length === 0) {
     const id = 'prof-mat-identify-boundaries';
-    lines.push(`- [${checkedState(model, id) ? 'x' : ' '}] \`[P1]\` Identify command/module boundaries for the next increment <!-- rs:task=${id} -->`);
+    const implSummary = (model.currentState && model.currentState.implementedSummary) || '';
+    const hasDetectedFiles = /^[1-9]/.test(implSummary);
+    const taskText = hasDetectedFiles
+      ? `Define module boundaries (scanner detected files but no top-level structure)`
+      : `Identify command/module boundaries for the next increment`;
+    lines.push(`- [${checkedState(model, id) ? 'x' : ' '}] \`[P1]\` ${taskText} <!-- rs:task=${id} -->`);
     lines.push('');
     return;
   }
 
+  const moduleMetadata = (model.moduleMetadata && typeof model.moduleMetadata === 'object') ? model.moduleMetadata : {};
+
   for (const area of allAreas) {
     const rawName = area.replace(/^(Module:|Command:)\s*/i, '').trim();
-    const meta = MODULE_METADATA[rawName.toLowerCase()];
+    const meta = moduleMetadata[rawName.toLowerCase()];
     const displayName = rawName;
 
     lines.push(`### ${displayName}`);
     lines.push('');
-    if (meta) {
+    if (meta && typeof meta === 'object') {
       lines.push(`**Current state:** ${meta.state}`);
       lines.push('');
-      for (const task of meta.tasks) {
+      for (const task of (Array.isArray(meta.tasks) ? meta.tasks : [])) {
         lines.push(`- [${checkedState(model, task.id) ? 'x' : ' '}] ${priorityLabel(task.priority)} ${task.text} <!-- rs:task=${task.id} -->`);
       }
     } else {
       const isCommand = /^Command:/i.test(area);
       const kind = isCommand ? 'command' : 'module';
-      const nextId = `prof-mat-${slugify(rawName)}-define-maturity-criteria`;
+      const docId = `prof-mat-${slugify(rawName)}-document-api`;
+      const testId = `prof-mat-${slugify(rawName)}-add-test-coverage`;
       lines.push(`**Current state:** ${kind} detected in scan.`);
       lines.push('');
-      lines.push(`- [${checkedState(model, nextId) ? 'x' : ' '}] \`[P1]\` Define maturity criteria and testability gates for ${displayName} <!-- rs:task=${nextId} -->`);
+      lines.push(`- [${checkedState(model, docId) ? 'x' : ' '}] \`[P1]\` Document ${displayName} public API <!-- rs:task=${docId} -->`);
+      lines.push(`- [${checkedState(model, testId) ? 'x' : ' '}] \`[P1]\` Add test coverage for ${displayName} <!-- rs:task=${testId} -->`);
     }
     lines.push('');
   }

package/src/utils.js

@@ -15,8 +15,7 @@ function slugify(text) {
   return String(text || '')
     .toLowerCase()
     .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-+|-+$/g, '')
-    .replace(/-{2,}/g, '-') || 'task';
+    .replace(/^-|-$/g, '') || 'task';
 }
 
 function normalizeText(text) {

package/src/validator/index.js

@@ -450,11 +450,7 @@ function normalizePathCandidateToken(rawToken) {
   if (!stripped) {
     return '';
   }
-  const normalized = stripped.replace(/\\/g, '/');
-  if (/^~\//.test(normalized)) {
-    return normalized;
-  }
-  return normalized.replace(/^~(?=\/)/, '~');
+  return stripped.replace(/\\/g, '/');
 }
 
 function isExternalPathToken(token) {
@@ -1860,6 +1856,22 @@ function buildDiscoveredEvidenceLine(evidence) {
 }
 
 function validateTask(task, context, config, plugins) {
+  if (task.planned) {
+    return {
+      passed: true,
+      planned: true,
+      confidence: 'low',
+      attempted: false,
+      reasons: [],
+      evidence: { code: false, test: false, artifact: false, files: [], codeFiles: [], testFiles: [], weakPathFiles: [], weakPathContentTokens: [], artifactFiles: [], heuristicArtifacts: [], symbols: [], structuralEvidence: null, authoritative: false, authoritativeFiles: [], authoritativeSummaries: [] },
+      diagnostics: [],
+      verificationRecipe: null,
+      staleEvidenceDetected: false,
+      staleEvidenceResolved: false,
+      generatedTestEvidence: null
+    };
+  }
+
   if (task.verifiedBy === 'human') {
     const hasEvidenceLine = Array.isArray(task.evidenceLines) &&
       task.evidenceLines.some((e) => e.text && e.text.trim().length > 0);