roadmapsmith 0.9.23 → 0.9.25

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "roadmapsmith",
-  "version": "0.9.23",
-  "description": "One-command evidence-backed ROADMAP.md generator and sync tool for AI coding agents, with shared RoadmapSmith plugin skills for Codex and Claude.",
+  "version": "0.9.25",
+  "description": "One-command evidence-backed ROADMAP.md generator and sync tool for AI coding agents, with shared RoadmapSmith plugin skills for Codex and Claude plus the roadmapsmith status readiness surface.",
   "author": {
     "name": "PapiScholz"
   },

package/.codex-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "roadmapsmith",
-  "version": "0.9.23",
-  "description": "One-command evidence-backed ROADMAP.md generator and sync tool for AI coding agents, with shared RoadmapSmith plugin skills for Codex and Claude.",
+  "version": "0.9.25",
+  "description": "One-command evidence-backed ROADMAP.md generator and sync tool for AI coding agents, with shared RoadmapSmith plugin skills for Codex and Claude plus the roadmapsmith status readiness surface.",
   "author": {
     "name": "PapiScholz"
   },

package/README.md

@@ -120,7 +120,8 @@ roadmapsmith init [--roadmap-file <path>] [--agents-file <path>] [--dry-run]
 roadmapsmith generate [--project-root <path>] [--config <path>] [--roadmap-file <path>] [--dry-run] [--audit] [--full-regen]
 roadmapsmith sync [--roadmap-file <path>] [--project-root <path>] [--config <path>] [--dry-run] [--audit]
 roadmapsmith validate [--roadmap-file <path>] [--project-root <path>] [--config <path>] [--task <id|text>] [--json]
-roadmapsmith doctor [--roadmap-file <path>] [--project-root <path>] [--config <path>] [--json]
+roadmapsmith status [--roadmap-file <path>] [--project-root <path>] [--config <path>] [--json]
+roadmapsmith doctor [--roadmap-file <path>] [--project-root <path>] [--config <path>] [--json]   # compatibility alias
 ```
 
 ## Claude Code native slash commands
@@ -153,7 +154,7 @@ Then restart Codex, open the plugin directory, install `roadmapsmith` from the `
 
 Codex native plugin support means install/enable discovery inside Codex. It is separate from Claude-specific `/reload-skills` behavior, and the VS Code task layer remains the fallback/manual workflow when you are not using the plugin directory.
 
-`roadmapsmith doctor --json` now reports native slash surfaces separately from the VS Code task layer:
+`roadmapsmith status --json` now reports native slash surfaces separately from the VS Code task layer (`doctor --json` remains a compatibility alias):
 
 - `claudeGui`
 - `claudeCli`
@@ -179,7 +180,8 @@ The repo does not remove user-global skills automatically. Use the `doctor` outp
   - code OR test OR artifact evidence required.
   - test evidence required for code tasks when test frameworks are detected.
 - Validation failures in sync write warning lines:
-  - `- ⚠️ attempted but validation failed: <reason>`
+  - `- ⚠️ attempted but validation failed: <reason>` when there is concrete attempt evidence
+  - `- ⚠️ no implementation evidence found yet: <reason>` when there is not
 - Preserves unmanaged markdown content by updating only the managed roadmap block.
 
 ## Defaults

package/bin/cli.js

@@ -31,7 +31,8 @@ function printHelp() {
     '  roadmapsmith generate [--project-root <path>] [--config <path>] [--roadmap-file <path>] [--dry-run] [--audit] [--full-regen]',
     '  roadmapsmith sync [--roadmap-file <path>] [--project-root <path>] [--config <path>] [--dry-run] [--audit]',
     '  roadmapsmith validate [--roadmap-file <path>] [--project-root <path>] [--config <path>] [--task <id|text>] [--json]',
-    '  roadmapsmith doctor [--roadmap-file <path>] [--project-root <path>] [--config <path>] [--json]'
+    '  roadmapsmith status [--roadmap-file <path>] [--project-root <path>] [--config <path>] [--json]',
+    '  roadmapsmith doctor [--roadmap-file <path>] [--project-root <path>] [--config <path>] [--json]   # compatibility alias'
   ].join('\n'));
 }
 
@@ -245,7 +246,7 @@ function printHumanStatus(payload) {
 function runStatusCommand(projectRoot, config, flags, options = {}) {
   const roadmapFile = resolveRoadmapFile(projectRoot, config, flags['roadmap-file']);
   const agentsFile = resolveAgentsFile(projectRoot, config, flags['agents-file']);
-  const payload = inspectHostSetup(projectRoot, { roadmapFile, agentsFile });
+  const payload = inspectHostSetup(projectRoot, { roadmapFile, agentsFile, currentCliPath: __filename });
 
   if (options.json) {
     process.stdout.write(JSON.stringify(payload, null, 2) + '\n');
@@ -443,7 +444,7 @@ async function run() {
     return;
   }
 
-  if (effectiveCommand === 'doctor') {
+  if (effectiveCommand === 'status' || effectiveCommand === 'doctor') {
     const projectRoot = path.resolve(String(flags['project-root'] || process.cwd()));
     let ok = true;
     const jsonMode = isEnabled(flags.json);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "roadmapsmith",
-  "version": "0.9.23",
-  "description": "One-command evidence-backed ROADMAP.md generator and sync tool for AI coding agents, with shared RoadmapSmith plugin skills for Codex and Claude.",
+  "version": "0.9.25",
+  "description": "One-command evidence-backed ROADMAP.md generator and sync tool for AI coding agents, with shared RoadmapSmith plugin skills for Codex and Claude plus the roadmapsmith status readiness surface.",
   "main": "src/index.js",
   "bin": {
     "roadmapsmith": "bin/cli.js"

package/skills/roadmap-sync/agents/openai.yaml

@@ -2,6 +2,6 @@
   "interface": {
     "display_name": "Roadmap Sync",
     "short_description": "Legacy root plus policy for evidence-backed ROADMAP.md slash workflows.",
-    "default_prompt": "Prefer /roadmap for discovery, /roadmap-maintain for existing repos, and /roadmap-update for direct sync."
+    "default_prompt": "Prefer /roadmap, /roadmap-status, /roadmap-maintain, and /roadmap-update."
   }
 }

package/skills.json

@@ -22,74 +22,74 @@
     "command": "npx skills add PapiScholz/roadmapsmith --skill '*' -a claude-code",
     "source": "PapiScholz/roadmapsmith",
     "skill": "*",
-    "notes": "Recommended Claude Code install path for native GUI slash commands like /roadmap, /roadmap-zero, /roadmap-maintain, /roadmap-status, /roadmap-init, /roadmap-generate, /roadmap-validate, /roadmap-update, /roadmap-audit, and /roadmap-setup. The legacy /roadmap-sync root remains available for compatibility, especially as /roadmap-sync <action>. Install the roadmapsmith CLI separately for actual command execution, then run /reload-skills and, if applicable, /reload-plugins. Codex native plugin installs use the repo/package .codex-plugin surface instead of this Claude-specific skills CLI path."
+    "notes": "Recommended Claude Code install path for native GUI slash commands like /roadmap, /roadmap-zero, /roadmap-maintain, /roadmap-status, /roadmap-init, /roadmap-generate, /roadmap-validate, /roadmap-update, /roadmap-audit, and /roadmap-setup. The legacy /roadmap-sync root remains available for compatibility, especially as /roadmap-sync <action>. Install the roadmapsmith CLI separately for actual command execution; roadmapsmith status is the visible readiness command and roadmapsmith doctor remains a compatibility alias. Then run /reload-skills and, if applicable, /reload-plugins. Codex native plugin installs use the repo/package .codex-plugin surface instead of this Claude-specific skills CLI path."
   },
   "skills": [
     {
       "name": "roadmap",
       "path": "skills/roadmap",
       "description": "Native slash palette for RoadmapSmith commands and recommended entrypoints across supported hosts.",
-      "version": "0.9.23"
+      "version": "0.9.25"
     },
     {
       "name": "roadmap-zero",
       "path": "skills/roadmap-zero",
       "description": "Native slash entrypoint for the one-command Zero Mode CLI workflow.",
-      "version": "0.9.23"
+      "version": "0.9.25"
     },
     {
       "name": "roadmap-maintain",
       "path": "skills/roadmap-maintain",
       "description": "Native slash entrypoint for the preserve-first generate + sync + audit flow.",
-      "version": "0.9.23"
+      "version": "0.9.25"
     },
     {
       "name": "roadmap-status",
       "path": "skills/roadmap-status",
-      "description": "Native slash readiness check grounded in roadmapsmith doctor JSON.",
-      "version": "0.9.23"
+      "description": "Native slash readiness check grounded in roadmapsmith status JSON.",
+      "version": "0.9.25"
     },
     {
       "name": "roadmap-init",
       "path": "skills/roadmap-init",
       "description": "Native slash entrypoint for creating ROADMAP.md and AGENTS.md.",
-      "version": "0.9.23"
+      "version": "0.9.25"
     },
     {
       "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.23"
+      "version": "0.9.25"
     },
     {
       "name": "roadmap-validate",
       "path": "skills/roadmap-validate",
       "description": "Native slash entrypoint for evidence-backed roadmap validation.",
-      "version": "0.9.23"
+      "version": "0.9.25"
     },
     {
       "name": "roadmap-update",
       "path": "skills/roadmap-update",
       "description": "Native slash entrypoint for applying evidence-backed checklist sync.",
-      "version": "0.9.23"
+      "version": "0.9.25"
     },
     {
       "name": "roadmap-sync",
       "path": "skills/roadmap-sync",
       "description": "Legacy namespaced root plus policy guidance for RoadmapSmith slash workflows.",
-      "version": "0.9.23"
+      "version": "0.9.25"
     },
     {
       "name": "roadmap-audit",
       "path": "skills/roadmap-audit",
       "description": "Native slash entrypoint for the current sync-plus-audit workflow.",
-      "version": "0.9.23"
+      "version": "0.9.25"
     },
     {
       "name": "roadmap-setup",
       "path": "skills/roadmap-setup",
       "description": "Native slash entrypoint for generating RoadmapSmith host integration files.",
-      "version": "0.9.23"
+      "version": "0.9.25"
     }
   ]
 }

package/src/host.js

@@ -921,7 +921,7 @@ function renderVsCodeLauncher() {
     'function explain() {',
     '  console.log(\'RoadmapSmith layers:\\n\');',
     '  console.log(\'1. The roadmap-sync skill guides the agent. It does not add VS Code buttons or install the CLI.\');',
-    '  console.log(\'2. The roadmapsmith CLI executes zero/maintain plus init/generate/validate/sync/setup/doctor, with --full-regen reserved for destructive replacement.\');',
+    '  console.log(\'2. The roadmapsmith CLI executes zero/maintain plus init/generate/validate/sync/setup/status, with doctor kept as a compatibility alias and --full-regen reserved for destructive replacement.\');',
     '  console.log(\'3. roadmapsmith setup makes the CLI visible in VS Code through tasks and optional Claude hook wiring.\\n\');',
     '  console.log(\'Typical VS Code workflow:\');',
     '  console.log(\'- Run "RoadmapSmith: Status" to inspect readiness.\');',
@@ -1020,7 +1020,7 @@ function renderVsCodeLauncher() {
     '}',
     '',
     'function status() {',
-    '  const result = runCli([\'doctor\', \'--project-root\', PROJECT_ROOT, \'--json\'], { capture: true, allowMissingCli: true });',
+    '  const result = runCli([\'status\', \'--project-root\', PROJECT_ROOT, \'--json\'], { capture: true, allowMissingCli: true });',
     '  if (!result || result.missingCli) {',
     '    printMissingCliStatus();',
     '    return;',
@@ -1143,7 +1143,26 @@ function findGlobalRoadmapsmith() {
   return findCommandPath('roadmapsmith');
 }
 
-function detectCliResolution(projectRoot) {
+function isRoadmapsmithCliEntrypoint(filePath) {
+  const normalized = String(filePath || '').replace(/\\/g, '/').toLowerCase();
+  if (!normalized) {
+    return false;
+  }
+  return normalized.endsWith('/roadmap-skill/bin/cli.js')
+    || normalized.endsWith('/roadmapsmith/bin/cli.js')
+    || /(?:^|[\\/])roadmapsmith(?:\.(?:cmd|exe|bat|ps1))?$/.test(normalized);
+}
+
+function detectCliResolution(projectRoot, options = {}) {
+  const currentCliPath = options.currentCliPath || process.argv[1] || null;
+  if (currentCliPath && isRoadmapsmithCliEntrypoint(currentCliPath)) {
+    return {
+      ready: true,
+      kind: 'current-process',
+      path: currentCliPath
+    };
+  }
+
   const workspaceDevCli = path.join(projectRoot, 'roadmap-skill', 'bin', 'cli.js');
   if (fs.existsSync(workspaceDevCli)) {
     return {
@@ -1244,7 +1263,7 @@ function inspectHostSetup(projectRoot, options = {}) {
   const roadmapFile = options.roadmapFile;
   const agentsFile = options.agentsFile;
   const runtime = detectNodeRuntime(options.env || process.env);
-  const cli = detectCliResolution(projectRoot);
+  const cli = detectCliResolution(projectRoot, { currentCliPath: options.currentCliPath });
   const vscode = inspectVsCodeTasks(projectRoot);
   const claude = inspectClaudeSetup(projectRoot);
   const bundle = inspectSharedBundleSurface();

package/src/parser/index.js

@@ -4,7 +4,12 @@ const { slugify } = require('../utils');
 
 const MANAGED_START = '<!-- rs:managed:start -->';
 const MANAGED_END = '<!-- rs:managed:end -->';
-const WARNING_PREFIX = '⚠️ attempted but validation failed:';
+const WARNING_PREFIX = '⚠️';
+const WARNING_REASON_PREFIXES = [
+  'attempted but validation failed:',
+  'no implementation evidence found yet:',
+  'validation failed:'
+];
 
 function getIndentWidth(text) {
   return String(text || '').replace(/\t/g, '    ').length;
@@ -86,7 +91,14 @@ function parseEvidenceLine(content) {
 
 function parseWarningLine(content) {
   if (!content.startsWith(WARNING_PREFIX)) return null;
-  return content.slice(WARNING_PREFIX.length).trim();
+  let normalized = content.slice(WARNING_PREFIX.length).trim();
+  for (const prefix of WARNING_REASON_PREFIXES) {
+    if (normalized.startsWith(prefix)) {
+      normalized = normalized.slice(prefix.length).trim();
+      break;
+    }
+  }
+  return normalized;
 }
 
 function parseBlockedByLine(content) {
@@ -98,6 +110,7 @@ function parseRoadmap(content) {
   const lines = String(content || '').split(/\r?\n/);
   const managedRange = findManagedRange(lines);
   const tasks = [];
+  const implicitIdCounts = new Map();
   let section = '';
 
   for (let index = 0; index < lines.length; index += 1) {
@@ -162,7 +175,12 @@ function parseRoadmap(content) {
       }
     }
 
-    const id = markerId || slugify(text);
+    const baseId = markerId || slugify(text);
+    const nextImplicitCount = markerId ? 1 : (implicitIdCounts.get(baseId) || 0) + 1;
+    if (!markerId) {
+      implicitIdCounts.set(baseId, nextImplicitCount);
+    }
+    const id = markerId || (nextImplicitCount === 1 ? baseId : `${baseId}-${nextImplicitCount}`);
     tasks.push({
       id,
       text,

package/src/slash.js

@@ -16,7 +16,7 @@ const SLASH_ACTIONS = [
   {
     id: 'status',
     description: 'Inspect CLI, roadmap, VS Code task, Codex, and Claude readiness.',
-    classicCliExample: 'roadmapsmith doctor --json',
+    classicCliExample: 'roadmapsmith status --json',
     taskLabel: 'RoadmapSmith: Status'
   },
   {

package/src/sync/index.js

@@ -3,12 +3,113 @@
 const { parseRoadmap } = require('../parser');
 const { ensureTrailingNewline } = require('../utils');
 
+const ATTEMPTED_WARNING_REASON_PREFIX = 'attempted but validation failed:';
+const NO_EVIDENCE_WARNING_REASON_PREFIX = 'no implementation evidence found yet:';
+const WARNING_REASON_PREFIXES = [
+  ATTEMPTED_WARNING_REASON_PREFIX,
+  NO_EVIDENCE_WARNING_REASON_PREFIX,
+  'validation failed:'
+];
+
 function setChecklistState(line, checked) {
   return line.replace(/- \[( |x|X)\]/, `- [${checked ? 'x' : ' '}]`);
 }
 
-function formatWarning(indent, reason) {
-  return `${indent}  - ⚠️ attempted but validation failed: ${reason}`;
+function formatWarning(indent, reason, attempted) {
+  const prefix = attempted ? ATTEMPTED_WARNING_REASON_PREFIX : NO_EVIDENCE_WARNING_REASON_PREFIX;
+  return `${indent}  - ⚠️ ${prefix} ${reason}`;
+}
+
+function isWhitespaceCharacter(char) {
+  return char === ' ' || char === '\t' || char === '\n' || char === '\r' || char === '\f' || char === '\v';
+}
+
+function stripLeadingWarningMarker(value) {
+  let index = 0;
+  const source = String(value || '');
+  while (index < source.length && isWhitespaceCharacter(source[index])) {
+    index += 1;
+  }
+  if (source.slice(index, index + 2) === '⚠️') {
+    index += 2;
+  }
+  while (index < source.length && isWhitespaceCharacter(source[index])) {
+    index += 1;
+  }
+  return source.slice(index);
+}
+
+function splitWarningReasonSegments(value) {
+  const source = String(value || '');
+  const segments = [];
+  let current = '';
+  let index = 0;
+
+  while (index < source.length) {
+    const char = source[index];
+    if (char === ';') {
+      const trimmed = current.trim();
+      if (trimmed) {
+        segments.push(trimmed);
+      }
+      current = '';
+      index += 1;
+      while (index < source.length && isWhitespaceCharacter(source[index])) {
+        index += 1;
+      }
+      continue;
+    }
+
+    current += char;
+    index += 1;
+  }
+
+  const trimmed = current.trim();
+  if (trimmed) {
+    segments.push(trimmed);
+  }
+
+  return segments;
+}
+
+function normalizeWarningReason(reason) {
+  let normalized = String(reason || '').trim();
+  if (!normalized) {
+    return '';
+  }
+
+  normalized = stripLeadingWarningMarker(normalized).trim();
+  for (const prefix of WARNING_REASON_PREFIXES) {
+    const prefixIndex = normalized.indexOf(prefix);
+    if (prefixIndex >= 0) {
+      normalized = normalized.slice(prefixIndex + prefix.length).trim();
+      break;
+    }
+  }
+
+  return normalized;
+}
+
+function normalizeWarningReasons(reasons) {
+  const normalized = [];
+  const seen = new Set();
+  for (const reason of Array.isArray(reasons) ? reasons : [reasons]) {
+    for (const chunk of splitWarningReasonSegments(reason)) {
+      const clean = normalizeWarningReason(chunk);
+      if (!clean || seen.has(clean)) {
+        continue;
+      }
+      seen.add(clean);
+      normalized.push(clean);
+    }
+  }
+  return normalized;
+}
+
+function shouldPreserveExistingWarning(existingReason, newReason) {
+  const cleanExisting = normalizeWarningReason(existingReason);
+  const cleanNew = normalizeWarningReason(newReason) || 'validation failed';
+  return cleanNew === 'validation failed' && cleanExisting && cleanExisting !== cleanNew;
 }
 
 function applySync(content, parsedTasks, results) {
@@ -30,13 +131,13 @@ function applySync(content, parsedTasks, results) {
 
     lines[lineIndex] = setChecklistState(lines[lineIndex], result.passed);
 
-    const reason = result.reasons.join('; ');
-    const warningText = formatWarning(task.indent || '', reason || 'validation failed');
+    const reason = normalizeWarningReasons(result.reasons).join('; ');
+    const warningText = formatWarning(task.indent || '', reason || 'validation failed', result.attempted);
     const hasWarning = task.warningLineIndex != null;
     const warningIndex = hasWarning ? task.warningLineIndex + offset : null;
     const lastChildLineIndex = (task.lastChildLineIndex != null ? task.lastChildLineIndex : task.lineIndex) + offset;
 
-    if (result.passed || !result.attempted) {
+    if (result.passed) {
       if (warningIndex != null && warningIndex >= 0 && warningIndex < lines.length) {
         lines.splice(warningIndex, 1);
         offset -= 1;
@@ -45,11 +146,9 @@ function applySync(content, parsedTasks, results) {
     }
 
     if (warningIndex != null && warningIndex >= 0 && warningIndex < lines.length) {
-      const existingReason = lines[warningIndex].split('validation failed:')[1];
+      const existingReason = normalizeWarningReason(lines[warningIndex]);
       const newReason = reason || 'validation failed';
-      // Preserve existing warning when it's more descriptive than the new generic message.
-      const existingIsMoreSpecific = existingReason && existingReason.trim().length > newReason.length;
-      if (!existingIsMoreSpecific) {
+      if (!shouldPreserveExistingWarning(existingReason, newReason)) {
         lines[warningIndex] = warningText;
       }
     } else {

package/src/validator/index.js

@@ -197,18 +197,9 @@ function hasFileExtension(token) {
 }
 
 function isLikelyPath(token) {
-  if (token.includes('*') || token.includes('?')) return false; // glob/wildcard
-  if (/^\/api\//i.test(token)) return false; // HTTP API route paths are not file paths
-  if (/^\.{1,2}\/|^\//.test(token)) {
-    // Bare "/" or "./" with nothing after is not a real path (e.g. "API / ESC-POS" → "/")
-    return /[A-Za-z0-9_]/.test(token);
-  }
-  if (hasFileExtension(token)) return true;
-  if (KNOWN_PATH_ROOTS.some((root) => token.startsWith(root))) return true;
-  // The ">= 2 slashes" rule was intentionally removed: it caused conceptual slash phrases
-  // like "code/test/artifact" or "build/test/deploy" to be treated as file paths.
-  // Real multi-segment paths are caught by the extension or known-root rules above.
-  return false;
+  if (isRealFilePath(token)) return true;
+  // Preserve the legacy extension-only fallback for standalone path-looking tokens.
+  return hasFileExtension(token);
 }
 
 // Matches standalone filenames without a slash — e.g. "roadmap-skill.config.json",
@@ -230,6 +221,54 @@ function hasKnownFileExtension(token) {
   return KNOWN_FILE_EXTENSIONS.has(token.slice(lastDot).toLowerCase());
 }
 
+function startsWithKnownPathRoot(token) {
+  const normalized = String(token || '').replace(/\\/g, '/').toLowerCase();
+  return KNOWN_PATH_ROOTS.some((root) => normalized.startsWith(root.toLowerCase()));
+}
+
+function isHttpRouteToken(token) {
+  const normalized = String(token || '').trim();
+  if (!normalized) return false;
+  if (/^(GET|POST|PUT|PATCH|DELETE)\s+\/\S+$/i.test(normalized)) {
+    return true;
+  }
+  return /^\/api\//i.test(normalized);
+}
+
+function isMimeTypeToken(token) {
+  return /^[A-Za-z0-9.+-]+\/[A-Za-z0-9.+-]+$/.test(String(token || '').trim());
+}
+
+function looksLikeFormulaToken(token) {
+  return /[=×÷]/.test(String(token || '').trim());
+}
+
+function isRealFilePath(token) {
+  const normalized = String(token || '').trim().replace(/\\/g, '/');
+  if (!normalized) return false;
+  if (normalized.includes('*') || normalized.includes('?')) return false;
+  if (/\s/.test(normalized)) return false;
+  if (looksLikeFormulaToken(normalized)) return false;
+  if (isHttpRouteToken(normalized)) return false;
+
+  const looksLikePath =
+    hasKnownFileExtension(normalized) ||
+    startsWithKnownPathRoot(normalized) ||
+    /^\.{1,2}\//.test(normalized) ||
+    /^\//.test(normalized);
+  if (!looksLikePath) return false;
+
+  if (!hasKnownFileExtension(normalized) && !startsWithKnownPathRoot(normalized) && isMimeTypeToken(normalized)) {
+    return false;
+  }
+
+  if (/^\.{1,2}\/|^\//.test(normalized)) {
+    return /[A-Za-z0-9_]/.test(normalized);
+  }
+
+  return true;
+}
+
 function isAsciiAlphaNumeric(char) {
   if (!char || char.length === 0) return false;
   const code = char.charCodeAt(0);
@@ -278,39 +317,49 @@ function collectPathishTokens(text) {
 // to lineReferenceHints and excluded from hasDirectReferencePass scoring.
 const LINE_REF_RE = /^(.+?):(\d+)(?:-\d+)?$/;
 
+function normalizeExplicitPathCandidate(rawToken) {
+  const clean = stripTrailingPathPunctuation(String(rawToken || '').trim());
+  if (!clean || clean.includes('*') || clean.includes('?')) {
+    return null;
+  }
+
+  const lineMatch = LINE_REF_RE.exec(clean);
+  if (lineMatch) {
+    const linePath = stripTrailingPathPunctuation(lineMatch[1]);
+    if (isRealFilePath(linePath)) {
+      return { path: linePath, isLineReference: true };
+    }
+    return null;
+  }
+
+  if (!isRealFilePath(clean)) {
+    return null;
+  }
+
+  return { path: clean, isLineReference: false };
+}
+
 function extractExplicitPaths(text) {
   const results = new Set();
   const lineReferenceHints = new Set();
 
   const quoted = String(text).match(/`([^`]+)`/g) || [];
   for (const token of quoted) {
-    const clean = token.slice(1, -1);
-    if (clean.includes('*') || clean.includes('?')) continue; // glob
-    const hasSlash = clean.includes('/') || clean.includes('\\');
-    // Require a slash or a known file extension — rejects property access like err.message,
-    // fs.readFileSync, error.stack (whose extensions are not in KNOWN_FILE_EXTENSIONS).
-    if (!hasSlash && !hasKnownFileExtension(clean)) continue;
-    const lineMatch = LINE_REF_RE.exec(clean);
-    if (lineMatch && hasKnownFileExtension(lineMatch[1])) {
-      lineReferenceHints.add(lineMatch[1]);
-      results.add(lineMatch[1]);
-    } else {
-      results.add(clean);
+    const normalized = normalizeExplicitPathCandidate(token.slice(1, -1));
+    if (!normalized) continue;
+    results.add(normalized.path);
+    if (normalized.isLineReference) {
+      lineReferenceHints.add(normalized.path);
     }
   }
 
   for (const word of String(text).split(/\s+/)) {
     if (!word.includes('/')) continue;
-    const token = stripTrailingPathPunctuation(word);
-    if (token.includes('*') || token.includes('?')) continue; // glob
-    const lineMatch = LINE_REF_RE.exec(token);
-    if (lineMatch && hasKnownFileExtension(lineMatch[1])) {
-      if (isLikelyPath(lineMatch[1])) {
-        lineReferenceHints.add(lineMatch[1]);
-        results.add(lineMatch[1]);
-      }
-    } else if (isLikelyPath(token)) {
-      results.add(token);
+    const normalized = normalizeExplicitPathCandidate(word);
+    if (!normalized) continue;
+    results.add(normalized.path);
+    if (normalized.isLineReference) {
+      lineReferenceHints.add(normalized.path);
     }
   }
 
@@ -363,6 +412,14 @@ function isCodeTask(taskText) {
   return CODE_HINTS.some((hint) => normalized.includes(hint));
 }
 
+function isHttpExpectationTask(taskText) {
+  const text = String(taskText || '');
+  if (!/(?:->|→)/.test(text) || !/\bHTTP\s+\d{3}\b/i.test(text)) {
+    return false;
+  }
+  return /\b(?:GET|POST|PUT|PATCH|DELETE)\b/i.test(text) || /\/api\//i.test(text);
+}
+
 function isDocTask(taskText) {
   const normalized = String(taskText).toLowerCase();
   // Use word-boundary matching to avoid substring false positives (e.g. "specific" ≠ "spec").
@@ -373,6 +430,10 @@ function isDocTask(taskText) {
   return /\b(add|create|write|update|init|initialize|introduce|setup|document)\b/.test(normalized);
 }
 
+function isImplementationTask(taskText) {
+  return !isDocTask(taskText) && (isCodeTask(taskText) || taskDescribesChange(taskText));
+}
+
 function findFilesByPathHints(pathHints, fileIndex) {
   const matches = [];
   for (const hint of pathHints) {
@@ -1139,7 +1200,12 @@ function validateTask(task, context, config, plugins) {
     }
   }
 
-  const requiresTest = !task.noTest && context.testFrameworks.length > 0 && isCodeTask(task.text) && !isDocTask(task.text);
+  const requiresTest =
+    !task.noTest &&
+    context.testFrameworks.length > 0 &&
+    isCodeTask(task.text) &&
+    !isDocTask(task.text) &&
+    !isHttpExpectationTask(task.text);
   const configuredRules = Array.isArray(config.validators) ? config.validators : [];
   const pluginRules = collectPluginContributions(plugins || [], 'registerValidators', context);
   let overrideResult = null;
@@ -1177,7 +1243,14 @@ function validateTask(task, context, config, plugins) {
     uniqueReasons = Array.isArray(overrideResult.reasons) ? Array.from(new Set(overrideResult.reasons)) : [];
   }
 
-  const attempted = hasStrongEvidence || hasWeakEvidence || pathHints.length > 0 || symbolHints.length > 0 || authoritativeEvidence.active;
+  const hasConcreteReferenceEvidence = filesFromPaths.length > 0 || filesFromSymbols.length > 0;
+  const hasConcreteAttemptEvidence =
+    authoritativeEvidence.active ||
+    hasRuleGrantedEvidence ||
+    filesFromTests.length > 0 ||
+    hasConcreteReferenceEvidence ||
+    (isDocTask(task.text) && filesFromArtifacts.length > 0);
+  const attempted = hasConcreteAttemptEvidence;
   const { categories: strongEvidenceCategories } = countStrongEvidenceCategories(task.text, evidence);
   const strongEvidenceCount = strongEvidenceCategories.length;
   // Only pure path hints (not line-reference hints like file.ts:169) count as direct evidence.
@@ -1220,6 +1293,7 @@ function validateTask(task, context, config, plugins) {
   // WHERE to implement, not that implementation is done. Unchecked tasks need authoritative
   // evidence, artifact evidence, or strong code+test threshold to pass.
   // Already-checked tasks with found path hints are preserved via shouldPreserveCheckedTask.
+  const hasHighConfidenceImplementationEvidence = meetsStrongThreshold && evidence.code && evidence.test;
   let passed = authoritativeEvidence.passed || hasArtifactTaskPass || hasTrustedRuleEvidencePass || meetsStrongThreshold;
 
   if (!passed && !task.checked && hasDirectReferencePass) {
@@ -1234,30 +1308,29 @@ function validateTask(task, context, config, plugins) {
   // human/agent judgment that the feature is incomplete.
   if (task.warningText && !task.checked && passed && !authoritativeEvidence.passed) {
     passed = false;
-    uniqueReasons.push(task.warningText);
-    uniqueReasons = Array.from(new Set(uniqueReasons));
+    if (uniqueReasons.length === 0) {
+      uniqueReasons.push('validation failed');
+    }
   }
   if (negativeSignalMatches.length > 0) {
     passed = false;
   }
 
-  // Action-verb gate (Causa 3): unchecked tasks that describe a change to be made
-  // (Agregar, Configurar, Add, Fix, Manejo, Recovery path, …) cannot pass on code token overlap alone.
-  // Requires either: an Evidence line (authoritativeEvidence.passed), high-confidence evidence
-  // (code + test), grant-evidence from config (hasTrustedRuleEvidencePass), or canonical artifact
-  // evidence (hasArtifactTaskPass — e.g. "Add SECURITY.md").
+  // Unchecked implementation tasks need explicit evidence or high-confidence implementation
+  // evidence. Weak token overlap, direct file references, or code-only matches are not enough.
   if (
     !task.checked &&
     passed &&
-    taskDescribesChange(task.text) &&
+    isImplementationTask(task.text) &&
     !authoritativeEvidence.passed &&
     !hasTrustedRuleEvidencePass &&
-    !hasArtifactTaskPass
+    !hasArtifactTaskPass &&
+    !hasHighConfidenceImplementationEvidence
   ) {
     passed = false;
-    const actionVerbReason = 'action task requires Evidence line or high-confidence evidence (code + test) to be marked complete';
-    if (!uniqueReasons.includes(actionVerbReason)) {
-      uniqueReasons.push(actionVerbReason);
+    const implementationReason = 'implementation task requires Evidence line or high-confidence evidence (code + test) to be marked complete';
+    if (!uniqueReasons.includes(implementationReason)) {
+      uniqueReasons.push(implementationReason);
     }
   }