gsd-antigravity-kit 2.0.1 → 2.1.0

package/.agent/skills/gsd/bin/lib/init.cjs

@@ -44,6 +44,22 @@ function withProjectRoot(cwd, result) {
   if (config.response_language) {
   result.response_language = config.response_language;
   }
+  // Inject project identity into all init outputs so handoff blocks
+  // can include project context for cross-session continuity.
+  if (config.project_code) {
+  result.project_code = config.project_code;
+  }
+  // Extract project title from PROJECT.md first H1 heading.
+  const projectMdPath = path.join(planningDir(cwd), 'PROJECT.md');
+  try {
+  if (fs.existsSync(projectMdPath)) {
+    const content = fs.readFileSync(projectMdPath, 'utf8');
+    const h1Match = content.match(/^#\s+(.+)$/m);
+    if (h1Match) {
+    result.project_title = h1Match[1].trim();
+    }
+  }
+  } catch { /* intentionally empty */ }
   return result;
 }
 
@@ -58,6 +74,16 @@ function cmdInitExecutePhase(cwd, phase, includes, raw, options = {}) {
 
   const roadmapPhase = getRoadmapPhaseInternal(cwd, phase);
 
+  // If findPhaseInternal matched an archived phase from a prior milestone, but
+  // the phase exists in the current milestone's ROADMAP.md, ignore the archive
+  // match — we are initializing a new phase in the current milestone that
+  // happens to share a number with an archived one. Without this, phase_dir,
+  // phase_slug and related fields would point at artifacts from a previous
+  // milestone.
+  if (phaseInfo?.archived && roadmapPhase?.found) {
+  phaseInfo = null;
+  }
+
   // Fallback to ROADMAP.md if no phase directory exists yet
   if (!phaseInfo && roadmapPhase?.found) {
   const phaseName = roadmapPhase.phase_name;
@@ -88,6 +114,7 @@ function cmdInitExecutePhase(cwd, phase, includes, raw, options = {}) {
   verifier_model: resolveModelInternal(cwd, 'gsd-verifier'),
 
   // Config flags
+  tdd_mode: options.tdd || config.tdd_mode || false,
   commit_docs: config.commit_docs,
   sub_repos: config.sub_repos,
   parallelization: config.parallelization,
@@ -175,6 +202,16 @@ function cmdInitPlanPhase(cwd, phase, includes, raw, options = {}) {
 
   const roadmapPhase = getRoadmapPhaseInternal(cwd, phase);
 
+  // If findPhaseInternal matched an archived phase from a prior milestone, but
+  // the phase exists in the current milestone's ROADMAP.md, ignore the archive
+  // match — we are planning a new phase in the current milestone that happens
+  // to share a number with an archived one. Without this, phase_dir,
+  // phase_slug, has_context and has_research would point at artifacts from a
+  // previous milestone.
+  if (phaseInfo?.archived && roadmapPhase?.found) {
+  phaseInfo = null;
+  }
+
   // Fallback to ROADMAP.md if no phase directory exists yet
   if (!phaseInfo && roadmapPhase?.found) {
   const phaseName = roadmapPhase.phase_name;
@@ -206,11 +243,18 @@ function cmdInitPlanPhase(cwd, phase, includes, raw, options = {}) {
   checker_model: resolveModelInternal(cwd, 'gsd-plan-checker'),
 
   // Workflow flags
+  tdd_mode: options.tdd || config.tdd_mode || false,
   research_enabled: config.research,
   plan_checker_enabled: config.plan_checker,
   nyquist_validation_enabled: config.nyquist_validation,
   commit_docs: config.commit_docs,
   text_mode: config.text_mode,
+  // Auto-advance config — included so workflows don't need separate config-get
+  // calls for these values, which causes infinite config-read loops on some models
+  // (e.g. Kimi K2.5). See #2192.
+  auto_advance: !!(config.auto_advance),
+  auto_chain_active: !!(config._auto_chain_active),
+  mode: config.mode || 'interactive',
 
   ...buildPhaseBase(phaseInfo),
   padded_phase: phaseInfo?.phase_number ? normalizePhaseName(phaseInfo.phase_number) : null,
@@ -231,6 +275,9 @@ function cmdInitPlanPhase(cwd, phase, includes, raw, options = {}) {
   state_path: toPosixPath(path.relative(cwd, path.join(planningDir(cwd), 'STATE.md'))),
   roadmap_path: toPosixPath(path.relative(cwd, path.join(planningDir(cwd), 'ROADMAP.md'))),
   requirements_path: toPosixPath(path.relative(cwd, path.join(planningDir(cwd), 'REQUIREMENTS.md'))),
+
+  // Pattern mapper output (null until PATTERNS.md exists in phase dir)
+  patterns_path: null,
   };
 
   if (phaseInfo?.directory) {
@@ -258,6 +305,10 @@ function cmdInitPlanPhase(cwd, phase, includes, raw, options = {}) {
     if (reviewsFile) {
     result.reviews_path = toPosixPath(path.join(phaseInfo.directory, reviewsFile));
     }
+    const patternsFile = files.find(f => f.endsWith('-PATTERNS.md') || f === 'PATTERNS.md');
+    if (patternsFile) {
+    result.patterns_path = toPosixPath(path.join(phaseInfo.directory, patternsFile));
+    }
   } catch { /* intentionally empty */ }
   }
 
@@ -533,6 +584,16 @@ function cmdInitVerifyWork(cwd, phase, includes, raw) {
   const config = loadConfig(cwd);
   let phaseInfo = findPhaseInternal(cwd, phase);
 
+  // If findPhaseInternal matched an archived phase from a prior milestone, but
+  // the phase exists in the current milestone's ROADMAP.md, ignore the archive
+  // match — same pattern as cmdInitPhaseOp.
+  if (phaseInfo?.archived) {
+  const roadmapPhase = getRoadmapPhaseInternal(cwd, phase);
+  if (roadmapPhase?.found) {
+    phaseInfo = null;
+  }
+  }
+
   // Fallback to ROADMAP.md if no phase directory exists yet
   if (!phaseInfo) {
   const roadmapPhase = getRoadmapPhaseInternal(cwd, phase);
@@ -803,6 +864,7 @@ function cmdInitMilestoneOp(cwd, includes, raw) {
 
 function cmdInitMapCodebase(cwd, includes, raw) {
   const config = loadConfig(cwd);
+  const now = new Date();
 
   // Check for existing codebase maps
   const codebaseDir = path.join(planningRoot(cwd), 'codebase');
@@ -821,6 +883,10 @@ function cmdInitMapCodebase(cwd, includes, raw) {
   parallelization: config.parallelization,
   subagent_timeout: config.subagent_timeout,
 
+  // Timestamps
+  date: now.toISOString().split('T')[0],
+  timestamp: now.toISOString(),
+
   // Paths
   codebase_dir: '.planning/codebase',
 
@@ -855,6 +921,23 @@ function cmdInitManager(cwd, includes, raw) {
   const phasesDir = paths.phases;
   const isDirInMilestone = getMilestonePhaseFilter(cwd);
 
+  // Pre-compute directory listing once (avoids O(N) readdirSync per phase)
+  const _phaseDirEntries = (() => {
+  try {
+    return fs.readdirSync(phasesDir, { withFileTypes: true })
+    .filter(e => e.isDirectory())
+    .map(e => e.name);
+  } catch { return []; }
+  })();
+
+  // Pre-extract all checkbox states in a single pass (avoids O(N) regex per phase)
+  const _checkboxStates = new Map();
+  const _cbPattern = /-\s*\[(x| )\]\s*.*Phase\s+(\d+[A-Z]?(?:\.\d+)*)[:\s]/gi;
+  let _cbMatch;
+  while ((_cbMatch = _cbPattern.exec(content)) !== null) {
+  _checkboxStates.set(_cbMatch[2], _cbMatch[1].toLowerCase() === 'x');
+  }
+
   const phasePattern = /#{2,4}\s*Phase\s+(\d+[A-Z]?(?:\.\d+)*)\s*:\s*([^\n]+)/gi;
   const phases = [];
   let match;
@@ -885,8 +968,7 @@ function cmdInitManager(cwd, includes, raw) {
   let isActive = false;
 
   try {
-    const entries = fs.readdirSync(phasesDir, { withFileTypes: true });
-    const dirs = entries.filter(e => e.isDirectory()).map(e => e.name).filter(isDirInMilestone);
+    const dirs = _phaseDirEntries.filter(isDirInMilestone);
     const dirMatch = dirs.find(d => phaseTokenMatches(d, normalized));
 
     if (dirMatch) {
@@ -920,10 +1002,8 @@ function cmdInitManager(cwd, includes, raw) {
     }
   } catch { /* intentionally empty */ }
 
-  // Check ROADMAP checkbox status
-  const checkboxPattern = new RegExp(`-\\s*\\[(x| )\\]\\s*.*Phase\\s+${phaseNum.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}[:\\s]`, 'i');
-  const checkboxMatch = content.match(checkboxPattern);
-  const roadmapComplete = checkboxMatch ? checkboxMatch[1] === 'x' : false;
+  // Check ROADMAP checkbox status (pre-extracted above the loop)
+  const roadmapComplete = _checkboxStates.get(phaseNum) || false;
   if (roadmapComplete && diskStatus !== 'complete') {
     diskStatus = 'complete';
   }
@@ -956,6 +1036,17 @@ function cmdInitManager(cwd, includes, raw) {
 
   // Dependency satisfaction: check if all depends_on phases are complete
   const completedNums = new Set(phases.filter(p => p.disk_status === 'complete').map(p => p.number));
+
+  // Also include phases from previously shipped milestones — they are all
+  // complete by definition (a milestone only ships when all phases are done).
+  // rawContent is the full ROADMAP.md (including <details>-wrapped shipped
+  // milestone sections that extractCurrentMilestone strips out).
+  const _allCompletedPattern = /-\s*\[x\]\s*.*Phase\s+(\d+[A-Z]?(?:\.\d+)*)[:\s]/gi;
+  let _allMatch;
+  while ((_allMatch = _allCompletedPattern.exec(rawContent)) !== null) {
+  completedNums.add(_allMatch[1]);
+  }
+
   for (const phase of phases) {
   if (!phase.depends_on || /^none$/i.test(phase.depends_on.trim())) {
     phase.deps_satisfied = true;
@@ -974,15 +1065,10 @@ function cmdInitManager(cwd, includes, raw) {
     : '—';
   }
 
-  // Sliding window: discuss is sequential — only the first undiscussed phase is available
-  let foundNextToDiscuss = false;
   for (const phase of phases) {
-  if (!foundNextToDiscuss && (phase.disk_status === 'empty' || phase.disk_status === 'no_directory')) {
-    phase.is_next_to_discuss = true;
-    foundNextToDiscuss = true;
-  } else {
-    phase.is_next_to_discuss = false;
-  }
+  phase.is_next_to_discuss =
+    (phase.disk_status === 'empty' || phase.disk_status === 'no_directory') &&
+    phase.deps_satisfied;
   }
 
   // Check for WAITING.json signal
@@ -1066,7 +1152,9 @@ function cmdInitManager(cwd, includes, raw) {
   return true;
   });
 
-  const completedCount = phases.filter(p => p.disk_status === 'complete').length;
+  // Exclude backlog phases (999.x) from completion accounting (#2129)
+  const nonBacklogPhases = phases.filter(p => !/^999(?:\.|$)/.test(p.number));
+  const completedCount = nonBacklogPhases.filter(p => p.disk_status === 'complete').length;
 
   // Read manager flags from config (passthrough flags for each step)
   // Validate: flags must be CLI-safe (only --flags, alphanumeric, hyphens, spaces)
@@ -1097,7 +1185,7 @@ function cmdInitManager(cwd, includes, raw) {
   in_progress_count: phases.filter(p => ['partial', 'planned', 'discussed', 'researched'].includes(p.disk_status)).length,
   recommended_actions: filteredActions,
   waiting_signal: waitingSignal,
-  all_complete: completedCount === phases.length && phases.length > 0,
+  all_complete: completedCount === nonBacklogPhases.length && nonBacklogPhases.length > 0,
   project_exists: pathExistsInternal(cwd, '.planning/PROJECT.md'),
   roadmap_exists: true,
   state_exists: true,
@@ -1108,6 +1196,10 @@ function cmdInitManager(cwd, includes, raw) {
 }
 
 function cmdInitProgress(cwd, includes, raw) {
+  try {
+  const { pruneOrphanedWorktrees } = require('./core.cjs');
+  pruneOrphanedWorktrees(cwd);
+  } catch (_) {}
   const config = loadConfig(cwd);
   const milestone = getMilestoneInfo(cwd);
 
@@ -1429,6 +1521,8 @@ function cmdInitRemoveWorkspace(cwd, name, includes, raw) {
  */
 function buildAgentSkillsBlock(config, agentType, projectRoot) {
   const { validatePath } = require('./security.cjs');
+  const os = require('os');
+  const globalSkillsBase = path.join(os.homedir(), '.antigravity', 'skills');
 
   if (!config || !config.agent_skills || !agentType) return '';
 
@@ -1443,6 +1537,37 @@ function buildAgentSkillsBlock(config, agentType, projectRoot) {
   for (const skillPath of skillPaths) {
   if (typeof skillPath !== 'string') continue;
 
+  // Support global: prefix for skills installed at ~/.antigravity/skills/ (#1992)
+  if (skillPath.startsWith('global:')) {
+    const skillName = skillPath.slice(7);
+    // Explicit empty-name guard before regex for clearer error message
+    if (!skillName) {
+    process.stderr.write(`[agent-skills] WARNING: "global:" prefix with empty skill name — skipping\n`);
+    continue;
+    }
+    // Sanitize: skill name must be alphanumeric, hyphens, or underscores only
+    if (!/^[a-zA-Z0-9_-]+$/.test(skillName)) {
+    process.stderr.write(`[agent-skills] WARNING: Invalid global skill name "${skillName}" — skipping\n`);
+    continue;
+    }
+    const globalSkillDir = path.join(globalSkillsBase, skillName);
+    const globalSkillMd = path.join(globalSkillDir, 'SKILL.md');
+    if (!fs.existsSync(globalSkillMd)) {
+    process.stderr.write(`[agent-skills] WARNING: Global skill not found at "~/.antigravity/skills/${skillName}/SKILL.md" — skipping\n`);
+    continue;
+    }
+    // Symlink escape guard: validatePath resolves symlinks and enforces
+    // containment within globalSkillsBase. Prevents a skill directory
+    // symlinked to an arbitrary location from being injected (#1992).
+    const pathCheck = validatePath(globalSkillMd, globalSkillsBase, { allowAbsolute: true });
+    if (!pathCheck.safe) {
+    process.stderr.write(`[agent-skills] WARNING: Global skill "${skillName}" failed path check (symlink escape?) — skipping\n`);
+    continue;
+    }
+    validPaths.push({ ref: `${globalSkillDir}/SKILL.md`, display: `~/.antigravity/skills/${skillName}` });
+    continue;
+  }
+
   // Validate path safety — must resolve within project root
   const pathCheck = validatePath(skillPath, projectRoot);
   if (!pathCheck.safe) {
@@ -1457,12 +1582,12 @@ function buildAgentSkillsBlock(config, agentType, projectRoot) {
     continue;
   }
 
-  validPaths.push(skillPath);
+  validPaths.push({ ref: `${skillPath}/SKILL.md`, display: skillPath });
   }
 
   if (validPaths.length === 0) return '';
 
-  const lines = validPaths.map(p => `- @${p}/SKILL.md`).join('\n');
+  const lines = validPaths.map(p => `- @${p.ref}`).join('\n');
   return `<agent_skills>\nRead these user-configured skills:\n${lines}\n</agent_skills>`;
 }
 
@@ -1486,6 +1611,232 @@ function cmdAgentSkills(cwd, agentType, raw) {
   process.exit(0);
 }
 
+/**
+ * Generate a skill manifest from a skills directory.
+ *
+ * Scans the canonical skill discovery roots and returns a normalized
+ * inventory object with discovered skills, root metadata, and installation
+ * summary flags. A legacy `skillsDir` override is still accepted for focused
+ * scans, but the default mode is multi-root discovery.
+ *
+ * @param {string} cwd - Project root directory
+ * @param {string|null} [skillsDir] - Optional absolute path to a specific skills directory
+ * @returns {{
+ *   skills: Array<{name: string, description: string, triggers: string[], path: string, file_path: string, root: string, scope: string, installed: boolean, deprecated: boolean}>,
+ *   roots: Array<{root: string, path: string, scope: string, present: boolean, skill_count?: number, command_count?: number, deprecated?: boolean}>,
+ *   installation: { gsd_skills_installed: boolean, legacy_antigravity_commands_installed: boolean },
+ *   counts: { skills: number, roots: number }
+ * }}
+ */
+function buildSkillManifest(cwd, skillsDir = null) {
+  const { extractFrontmatter } = require('./frontmatter.cjs');
+  const os = require('os');
+
+  const canonicalRoots = skillsDir ? [{
+  root: path.resolve(skillsDir),
+  path: path.resolve(skillsDir),
+  scope: 'custom',
+  present: fs.existsSync(skillsDir),
+  kind: 'skills',
+  }] : [
+  {
+    root: '.antigravity/skills',
+    path: path.join(cwd, '.antigravity', 'skills'),
+    scope: 'project',
+    kind: 'skills',
+  },
+  {
+    root: '.agents/skills',
+    path: path.join(cwd, '.agents', 'skills'),
+    scope: 'project',
+    kind: 'skills',
+  },
+  {
+    root: '.cursor/skills',
+    path: path.join(cwd, '.cursor', 'skills'),
+    scope: 'project',
+    kind: 'skills',
+  },
+  {
+    root: '.github/skills',
+    path: path.join(cwd, '.github', 'skills'),
+    scope: 'project',
+    kind: 'skills',
+  },
+  {
+    root: '.codex/skills',
+    path: path.join(cwd, '.codex', 'skills'),
+    scope: 'project',
+    kind: 'skills',
+  },
+  {
+    root: '~/.antigravity/skills',
+    path: path.join(os.homedir(), '.antigravity', 'skills'),
+    scope: 'global',
+    kind: 'skills',
+  },
+  {
+    root: '~/.codex/skills',
+    path: path.join(os.homedir(), '.codex', 'skills'),
+    scope: 'global',
+    kind: 'skills',
+  },
+  {
+    root: '.antigravity/get-shit-done/skills',
+    path: path.join(os.homedir(), '.antigravity', 'get-shit-done', 'skills'),
+    scope: 'import-only',
+    kind: 'skills',
+    deprecated: true,
+  },
+  {
+    root: '.antigravity/commands/gsd',
+    path: path.join(os.homedir(), '.antigravity', 'commands', 'gsd'),
+    scope: 'legacy-commands',
+    kind: 'commands',
+    deprecated: true,
+  },
+  ];
+
+  const skills = [];
+  const roots = [];
+  let legacyAntigravityCommandsInstalled = false;
+  for (const rootInfo of canonicalRoots) {
+  const rootPath = rootInfo.path;
+  const rootSummary = {
+    root: rootInfo.root,
+    path: rootPath,
+    scope: rootInfo.scope,
+    present: fs.existsSync(rootPath),
+    deprecated: !!rootInfo.deprecated,
+  };
+
+  if (!rootSummary.present) {
+    roots.push(rootSummary);
+    continue;
+  }
+
+  if (rootInfo.kind === 'commands') {
+    let entries = [];
+    try {
+    entries = fs.readdirSync(rootPath, { withFileTypes: true });
+    } catch {
+    roots.push(rootSummary);
+    continue;
+    }
+
+    const commandFiles = entries.filter(entry => entry.isFile() && entry.name.endsWith('.md'));
+    rootSummary.command_count = commandFiles.length;
+    if (rootSummary.command_count > 0) legacyAntigravityCommandsInstalled = true;
+    roots.push(rootSummary);
+    continue;
+  }
+
+  let entries;
+  try {
+    entries = fs.readdirSync(rootPath, { withFileTypes: true });
+  } catch {
+    roots.push(rootSummary);
+    continue;
+  }
+
+  let skillCount = 0;
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+
+    const skillMdPath = path.join(rootPath, entry.name, 'SKILL.md');
+    if (!fs.existsSync(skillMdPath)) continue;
+
+    let content;
+    try {
+    content = fs.readFileSync(skillMdPath, 'utf-8');
+    } catch {
+    continue;
+    }
+
+    const frontmatter = extractFrontmatter(content);
+    const name = frontmatter.name || entry.name;
+    const description = frontmatter.description || '';
+
+    // Extract trigger lines from body text (after frontmatter)
+    const triggers = [];
+    const bodyMatch = content.match(/^---[\s\S]*?---\s*\n([\s\S]*)$/);
+    if (bodyMatch) {
+    const body = bodyMatch[1];
+    const triggerLines = body.match(/^TRIGGER\s+when:\s*(.+)$/gmi);
+    if (triggerLines) {
+      for (const line of triggerLines) {
+      const m = line.match(/^TRIGGER\s+when:\s*(.+)$/i);
+      if (m) triggers.push(m[1].trim());
+      }
+    }
+    }
+
+    skills.push({
+    name,
+    description,
+    triggers,
+    path: entry.name,
+    file_path: `${entry.name}/SKILL.md`,
+    root: rootInfo.root,
+    scope: rootInfo.scope,
+    installed: rootInfo.scope !== 'import-only',
+    deprecated: !!rootInfo.deprecated,
+    });
+    skillCount++;
+  }
+
+  rootSummary.skill_count = skillCount;
+  roots.push(rootSummary);
+  }
+
+  skills.sort((a, b) => {
+  const rootCmp = a.root.localeCompare(b.root);
+  return rootCmp !== 0 ? rootCmp : a.name.localeCompare(b.name);
+  });
+
+  const gsdSkillsInstalled = skills.some(skill => skill.name.startsWith('gsd-'));
+
+  return {
+  skills,
+  roots,
+  installation: {
+    gsd_skills_installed: gsdSkillsInstalled,
+    legacy_antigravity_commands_installed: legacyAntigravityCommandsInstalled,
+  },
+  counts: {
+    skills: skills.length,
+    roots: roots.length,
+  },
+  };
+}
+
+/**
+ * Command: generate skill manifest JSON.
+ *
+ * Options:
+ *   --skills-dir <path>  Optional absolute path to a single skills directory
+ *   --write              Also write to .planning/skill-manifest.json
+ */
+function cmdSkillManifest(cwd, args, raw) {
+  const skillsDirIdx = args.indexOf('--skills-dir');
+  const skillsDir = skillsDirIdx >= 0 && args[skillsDirIdx + 1]
+  ? args[skillsDirIdx + 1]
+  : null;
+
+  const manifest = buildSkillManifest(cwd, skillsDir);
+
+  // Optionally write to .planning/skill-manifest.json
+  if (args.includes('--write')) {
+  const planningDir = path.join(cwd, '.planning');
+  if (fs.existsSync(planningDir)) {
+    const manifestPath = path.join(planningDir, 'skill-manifest.json');
+    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), 'utf-8');
+  }
+  }
+
+  output(manifest, raw);
+}
+
 module.exports = {
   cmdInitExecutePhase,
   cmdInitPlanPhase,
@@ -1506,4 +1857,6 @@ module.exports = {
   detectChildRepos,
   buildAgentSkillsBlock,
   cmdAgentSkills,
+  buildSkillManifest,
+  cmdSkillManifest,
 };

package/.agent/skills/gsd/bin/lib/intel.cjs

@@ -19,10 +19,10 @@ const crypto = require('crypto');
 const INTEL_DIR = '.planning/intel';
 
 const INTEL_FILES = {
-  files: 'files.json',
-  apis: 'apis.json',
-  deps: 'deps.json',
-  arch: 'arch.md',
+  files: 'file-roles.json',
+  apis: 'api-map.json',
+  deps: 'dependency-graph.json',
+  arch: 'arch-decisions.json',
   stack: 'stack.json'
 };
 
@@ -204,10 +204,8 @@ function intelQuery(term, planningDir) {
   const matches = [];
   let total = 0;
 
-  // Search JSON intel files
+  // Search all JSON intel files
   for (const [_key, filename] of Object.entries(INTEL_FILES)) {
-  if (filename.endsWith('.md')) continue; // Skip arch.md here
-
   const filePath = intelFilePath(planningDir, filename);
   const data = safeReadJson(filePath);
   if (!data) continue;
@@ -219,14 +217,6 @@ function intelQuery(term, planningDir) {
   }
   }
 
-  // Search arch.md
-  const archPath = intelFilePath(planningDir, INTEL_FILES.arch);
-  const archMatches = searchArchMd(archPath, term);
-  if (archMatches.length > 0) {
-  matches.push({ source: INTEL_FILES.arch, entries: archMatches });
-  total += archMatches.length;
-  }
-
   return { matches, term, total };
 }
 
@@ -257,20 +247,10 @@ function intelStatus(planningDir) {
 
   let updatedAt = null;
 
-  if (filename.endsWith('.md')) {
-    // For arch.md, use file mtime
-    try {
-    const stat = fs.statSync(filePath);
-    updatedAt = stat.mtime.toISOString();
-    } catch (_e) {
-    // intentionally silent: fall through on error
-    }
-  } else {
-    // For JSON files, read _meta.updated_at
-    const data = safeReadJson(filePath);
-    if (data && data._meta && data._meta.updated_at) {
+  // All intel files are JSON — read _meta.updated_at
+  const data = safeReadJson(filePath);
+  if (data && data._meta && data._meta.updated_at) {
     updatedAt = data._meta.updated_at;
-    }
   }
 
   let stale = true;
@@ -409,8 +389,7 @@ function intelValidate(planningDir) {
     continue;
   }
 
-  // Skip non-JSON files (arch.md)
-  if (filename.endsWith('.md')) continue;
+  // All intel files are JSON — validate _meta and entries structure
 
   // Parse JSON
   let data;