@boyingliu01/xp-gate 0.19.3 → 0.20.0

package/lib/init.js

@@ -143,7 +143,7 @@ function generateManifest(srcDir, projectRoot) {
   const githooksDir = path.join(projectRoot, 'githooks');
 
   // Hooks
-  ['pre-commit', 'pre-push'].forEach(hook => {
+  ['pre-commit', 'pre-push', 'post-merge'].forEach(hook => {
     const hookPath = path.join(hooksDir, hook);
     if (fs.existsSync(hookPath)) {
       const stat = fs.statSync(hookPath);
@@ -204,7 +204,7 @@ function generateGlobalManifest(srcDir) {
   };
 
   // Global hooks
-  ['pre-commit', 'pre-push'].forEach(hook => {
+  ['pre-commit', 'pre-push', 'post-merge'].forEach(hook => {
     const hookPath = path.join(GLOBAL_HOOKS_DIR, hook);
     if (fs.existsSync(hookPath)) {
       const stat = fs.statSync(hookPath);
@@ -516,7 +516,7 @@ async function installLocal(args) {
 
   injectKarpathyPrinciples(projectRoot);
   configureOpenCodePlugin(srcDir, projectRoot);
-  configureQoderDelphiAgents(srcDir, projectRoot);
+  deployQoderDelphiAgents(srcDir, projectRoot);
 
   // Auto-register TUI plugin globally (idempotent)
   try {
@@ -593,6 +593,10 @@ async function setupGlobal(args) {
   // missing register/network must not break global setup.
   installModuleRuntimeDeps(CONFIG_DIR);
 
+  // Qoder loads user-level custom agents from ~/.qoder/agents/, so a global
+  // setup must deploy the Delphi expert templates there as well.
+  deployQoderDelphiAgents(srcDir, HOME_DIR);
+
   console.log('[setup-global] Configuring git...');
   const { execSync } = require('child_process');
   try {
@@ -636,50 +640,197 @@ async function setupGlobal(args) {
   return 0;
 }
 
+/**
+ * Qoder Custom Agents must bind their model as "[DisplayName](modelId)"; a bare
+ * model name makes Qoder silently fall back to the session model, which would
+ * collapse the three Delphi experts onto one model. Paired quotes only, and
+ * matched only inside the frontmatter block so example lines in the body cannot
+ * satisfy it. Unquoted is rejected: the docs require the paired-quote form, an
+ * unquoted link is not a legal YAML scalar, and accepting it would let a
+ * hand-edited file pass the audit while Qoder reads something else.
+ */
+const QODER_MODEL_BINDING = /^model:[ \t]*(?:"\[[^"\]]+\]\(([A-Za-z0-9_.-]+)\)"|'\[[^'\]]+\]\(([A-Za-z0-9_.-]+)\)')[ \t]*$/m;
+
+/**
+ * @param {string} file - agent markdown file
+ * @returns {string|null} the bound modelId, or null when the binding is missing/invalid
+ */
+function readQoderModelId(file) {
+  let frontmatter;
+  try {
+    const lines = fs.readFileSync(file, 'utf8').split(/\r?\n/);
+    if (lines[0].trim() !== '---') return null;
+    const end = lines.indexOf('---', 1);
+    if (end === -1) return null;
+    frontmatter = lines.slice(1, end).join('\n');
+  } catch {
+    return null;
+  }
+  const match = QODER_MODEL_BINDING.exec(frontmatter);
+  return match ? (match[1] || match[2]) : null;
+}
+
+function warnUnusableQoderAgent(file, boundId, bundledId) {
+  if (boundId === null) {
+    console.warn(`  ⚠ ${file} does not bind a model as "[Name](modelId)".`);
+    console.warn('    Qoder will silently run this expert on the session model, which breaks');
+    console.warn("    Delphi's three-distinct-models contract.");
+  } else {
+    console.warn(`  ⚠ ${file} binds "${boundId}" but this xp-gate version pins "${bundledId}".`);
+    console.warn('    A stale or hand-edited binding leaves the expert on a model this review');
+    console.warn('    contract was never validated against.');
+  }
+  console.warn('    Delete the file, re-run `xp-gate init` (or `--global`), then restart the');
+  console.warn('    Qoder session so the agent registry reloads.');
+}
+
+/**
+ * Report already-deployed agents whose binding is missing, stale or hand-diverged.
+ * Runs even when the bundled templates are unreadable — a broken install is exactly
+ * the case where the user needs the repair hint.
+ *
+ * @param {string} agentsDestDir - deployed agents directory
+ * @param {Object<string, string|null>|null} bundled - modelId per bundled template, null if unbundled
+ */
+function auditDeployedQoderAgents(agentsDestDir, bundled) {
+  if (!fs.existsSync(agentsDestDir)) return;
+  for (const file of fs.readdirSync(agentsDestDir).filter(f => f.endsWith('.md'))) {
+    // Unrelated user agents are none of our business; only Delphi experts are.
+    if (!file.startsWith('delphi-') && !(bundled && file in bundled)) continue;
+    const destFile = path.join(agentsDestDir, file);
+    const boundId = readQoderModelId(destFile);
+    const bundledId = bundled ? bundled[file] : undefined;
+    if (boundId === null || (bundledId !== undefined && bundledId !== boundId)) {
+      warnUnusableQoderAgent(destFile, boundId, bundledId);
+    }
+  }
+}
+
+/**
+ * Read the bundled agent templates and extract the modelId each one binds.
+ *
+ * @param {string} agentSrcDir - bundled plugins/qoder/agents directory
+ * @returns {Object<string, string|null>|null} file → modelId, null when not bundled
+ */
+function readBundledQoderTemplates(agentSrcDir) {
+  if (!fs.existsSync(agentSrcDir)) return null;
+  const bundled = {};
+  for (const file of fs.readdirSync(agentSrcDir).filter(f => f.endsWith('.md'))) {
+    bundled[file] = readQoderModelId(path.join(agentSrcDir, file));
+  }
+  return bundled;
+}
+
+/**
+ * Copy missing templates into the agents dir, refusing any that lack a valid binding.
+ *
+ * @param {string} agentSrcDir - bundled plugins/qoder/agents directory
+ * @param {string} agentsDestDir - deployed agents directory
+ * @param {Object<string, string|null>|null} bundled - file → modelId, null when not bundled
+ * @returns {{deployed: number, skipped: number, rejected: number}}
+ */
+function deployQoderTemplates(agentSrcDir, agentsDestDir, bundled) {
+  const summary = { deployed: 0, skipped: 0, rejected: 0 };
+  if (!bundled) return summary;
+  fs.mkdirSync(agentsDestDir, { recursive: true });
+  for (const file of Object.keys(bundled)) {
+    const srcFile = path.join(agentSrcDir, file);
+    if (fs.existsSync(path.join(agentsDestDir, file))) {
+      summary.skipped++; // Don't overwrite user customizations
+      continue;
+    }
+    if (bundled[file] === null) {
+      console.warn(`  ⚠ Bundled agent template ${srcFile} has no valid model binding; skipped.`);
+      summary.rejected++;
+      continue;
+    }
+    fs.copyFileSync(srcFile, path.join(agentsDestDir, file));
+    summary.deployed++;
+  }
+  return summary;
+}
+
+/**
+ * @param {{deployed: number, skipped: number, rejected: number}} summary
+ * @param {string} agentsDestDir - deployed agents directory
+ * @param {number} templateCount - templates found in the bundle
+ */
+function reportQoderAgentDeployment(summary, agentsDestDir, templateCount) {
+  if (summary.deployed > 0) {
+    console.log(`  Qoder Delphi agents: deployed ${summary.deployed} agent(s) to ${agentsDestDir}`);
+  }
+  if (summary.skipped > 0) {
+    console.log(`  Qoder Delphi agents: ${summary.skipped} existing agent(s) preserved`);
+  }
+  if (summary.rejected > 0) {
+    console.warn(`  Qoder Delphi agents: ${summary.rejected} bundled template(s) rejected (invalid model binding)`);
+  }
+  if (templateCount === 0 && summary.deployed === 0 && summary.skipped === 0 && summary.rejected === 0) {
+    console.log('  Qoder Delphi agents: no agent templates found');
+  }
+}
+
+/**
+ * A legal binding is not an executed binding: measured on 2026-09-23, Qoder's
+ * subagent dispatch adopts the agent persona but pins the model to the session's.
+ * Without this line a user leaves `init` believing the three-model contract holds.
+ */
+function warnQoderBindingBoundary() {
+  console.warn('  ⚠ Platform boundary: Qoder Custom Agent dispatch does not adopt the model');
+  console.warn('    bindings declared in these agent files. Every expert still runs on the');
+  console.warn('    current session model, so the native path is a same-model three-persona');
+  console.warn("    self-check. Delphi's three-distinct-models contract");
+  console.warn('    requires an external provider configured in .delphi-config.json.');
+}
+
 /**
  * Deploy Qoder-native Delphi review agents when platform is Qoder.
- * Copies agent templates from the bundled qoder plugin to the project's
- * .qoder/agents/ directory. Idempotent — never overwrites existing files.
+ * Copies agent templates from the bundled qoder plugin into <targetRoot>/.qoder/agents/
+ * — the project dir for local init, the home dir for global init (Qoder reads
+ * user-level agents from ~/.qoder/agents/). Idempotent — never overwrites existing files.
  *
  * @param {string} srcDir - npm package source directory
- * @param {string} projectRoot - user's project root
+ * @param {string} targetRoot - project root (local) or home directory (global)
  */
-function configureQoderDelphiAgents(srcDir, projectRoot) {
+function configureQoderDelphiAgents(srcDir, targetRoot) {
   const platform = detectPlatform();
   if (platform !== 'qoder') {
-    return; // Not Qoder — skip (OpenCode uses .delphi-config.json instead)
+    console.log(`  Qoder Delphi agents: SKIP (platform detected: ${platform})`);
+    return; // Not Qoder — OpenCode uses .delphi-config.json instead
   }
 
   const agentSrcDir = path.join(srcDir, 'plugins', 'qoder', 'agents');
-  if (!fs.existsSync(agentSrcDir)) {
-    console.log('  Qoder Delphi agents: SKIP (templates not bundled)');
-    return;
-  }
+  const agentsDestDir = path.join(targetRoot, '.qoder', 'agents');
 
-  const agentsDestDir = path.join(projectRoot, '.qoder', 'agents');
-  fs.mkdirSync(agentsDestDir, { recursive: true });
-
-  const agentFiles = fs.readdirSync(agentSrcDir).filter(f => f.endsWith('.md'));
-  let deployed = 0;
-  let skipped = 0;
-  for (const file of agentFiles) {
-    const destFile = path.join(agentsDestDir, file);
-    if (fs.existsSync(destFile)) {
-      skipped++;
-      continue; // Don't overwrite user customizations
-    }
-    fs.copyFileSync(path.join(agentSrcDir, file), destFile);
-    deployed++;
+  const bundled = readBundledQoderTemplates(agentSrcDir);
+  if (!bundled) {
+    console.warn('  Qoder Delphi agents: SKIP (templates not bundled — reinstall xp-gate)');
   }
 
-  if (deployed > 0) {
-    console.log(`  Qoder Delphi agents: deployed ${deployed} agent(s) to .qoder/agents/`);
+  const summary = deployQoderTemplates(agentSrcDir, agentsDestDir, bundled);
+  auditDeployedQoderAgents(agentsDestDir, bundled);
+  // 'templates not bundled' already explains a null bundle; a second,
+  // contradictory 'no agent templates found' would muddy the same fact.
+  if (bundled) {
+    reportQoderAgentDeployment(summary, agentsDestDir, Object.keys(bundled).length);
   }
-  if (skipped > 0) {
-    console.log(`  Qoder Delphi agents: ${skipped} existing agent(s) preserved`);
+  if (summary.deployed + summary.skipped > 0) {
+    warnQoderBindingBoundary();
   }
-  if (deployed === 0 && skipped === 0) {
-    console.log('  Qoder Delphi agents: no agent templates found');
+}
+
+/**
+ * Best-effort wrapper: a failed or partially readable agents dir must never
+ * abort the surrounding setup after hooks/adapters/modules are already copied.
+ *
+ * @param {string} srcDir - npm package source directory
+ * @param {string} targetRoot - project root (local) or home directory (global)
+ */
+function deployQoderDelphiAgents(srcDir, targetRoot) {
+  try {
+    configureQoderDelphiAgents(srcDir, targetRoot);
+  } catch (err) {
+    console.warn(`  Qoder Delphi agents: SKIP (deployment failed: ${err && err.message ? err.message : String(err)})`);
   }
 }
 
@@ -771,4 +922,4 @@ function injectKarpathyPrinciples(projectRoot) {
   }
 }
 
-module.exports = { init, promptBootstrap, installModuleRuntimeDeps };
+module.exports = { init, promptBootstrap, installModuleRuntimeDeps, deployQoderDelphiAgents, configureQoderDelphiAgents, readQoderModelId };

package/lib/install-cmd.js

@@ -28,7 +28,7 @@ async function install(args = []) {
     return code;
   }
 
-  // Post-install: run doctor --fix to verify and auto-repair
+  // Post-install: run doctor --fix to verify and report
   console.log('\n━━━ Post-Install Health Check ━━━\n');
   const { doctor } = require('./doctor.js');
   const doctorCode = await doctor(['--fix']);
@@ -36,11 +36,14 @@ async function install(args = []) {
   if (doctorCode === 0) {
     console.log('\n✓ Installation complete and verified!');
   } else {
-    console.log('\n⚠ Installation complete, but some issues remain.');
-    console.log('  Run "xp-gate doctor" for details.');
+    // Doctor findings (hook/module drift needing a human judgement, #495) are
+    // diagnostics about the environment, not a failed install. Returning its
+    // code made `xp-gate install && next-step` fail on a successful install (#503).
+    console.log('\n⚠ Installation complete, but doctor reported issues.');
+    console.log('  Review them with "xp-gate doctor" — the install itself succeeded.');
   }
 
-  return doctorCode;
+  return 0;
 }
 
 module.exports = { install };

package/lib/install-skill.js

@@ -1,10 +1,6 @@
 const fs = require('fs');
 const path = require('path');
-const https = require('https');
-const http = require('http');
-const { execSync } = require('child_process');
 const { checkDeps } = require('./detect-deps.js');
-const { downloadFromGitHub } = require('./download-skill.js');
 const { rollback } = require('./rollback.js');
 const { HOME_DIR, CONFIG_DIR, detectPlatform } = require('./shared-paths.js');
 const { copyDirRecursive } = require('./shared-utils');
@@ -20,6 +16,9 @@ function getSkillsDir() {
   return path.join(HOME_DIR, '.config', 'opencode', 'skills');
 }
 
+// The npm package ships the canonical skill content; `files` includes skills/.
+const BUNDLED_SKILLS_DIR = path.join(__dirname, '..', 'skills');
+
 function getCliVersion() {
   try {
     const versionFile = path.join(__dirname, '..', '..', '..', 'VERSION');
@@ -29,24 +28,20 @@ function getCliVersion() {
   }
 }
 
-const SKILLS_REGISTRY = {
-  'admin-template-guidelines': { repo: 'boyingliu01/xp-gate', path: 'skills/admin-template-guidelines' },
-  'batch-grill-me': { repo: 'boyingliu01/xp-gate', path: 'skills/batch-grill-me' },
-  'clipboard-vision': { repo: 'boyingliu01/xp-gate', path: 'skills/clipboard-vision' },
-  'delphi-review': { repo: 'boyingliu01/xp-gate', path: 'skills/delphi-review' },
-  'domain-modeling': { repo: 'boyingliu01/xp-gate', path: 'skills/domain-modeling' },
-  'grill-with-docs': { repo: 'boyingliu01/xp-gate', path: 'skills/grill-with-docs' },
-  'grilling': { repo: 'boyingliu01/xp-gate', path: 'skills/grilling' },
-  'improve-codebase-architecture': { repo: 'boyingliu01/xp-gate', path: 'skills/improve-codebase-architecture' },
-  'ralph-loop': { repo: 'boyingliu01/xp-gate', path: 'skills/ralph-loop' },
-  'sprint-flow': { repo: 'boyingliu01/xp-gate', path: 'skills/sprint-flow' },
-  'test-driven-development': { repo: 'boyingliu01/xp-gate', path: 'skills/test-driven-development' },
-  'test-specification-alignment': { repo: 'boyingliu01/xp-gate', path: 'skills/test-specification-alignment' },
-  'to-issues': { repo: 'boyingliu01/xp-gate', path: 'skills/to-issues' }
-};
+// The table used to be a second, hand-maintained list of installable skills that
+// could only ever lag behind the bundle. The bundle is the contract now: a skill
+// the installed package does not carry is not installable, and must be answered
+// by updating the package rather than by pulling a mismatched copy off GitHub.
+function bundledSkills() {
+  if (!fs.existsSync(BUNDLED_SKILLS_DIR)) return [];
+  return fs
+    .readdirSync(BUNDLED_SKILLS_DIR, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory() && fs.existsSync(path.join(BUNDLED_SKILLS_DIR, entry.name, 'SKILL.md')))
+    .map((entry) => entry.name);
+}
 
 async function installSkill(name, options = {}) {
-  const { offline = false, verbose = false, force = false } = options;
+  const { verbose = false, force = false } = options;
 
   const platform = detectPlatform();
   const depCheck = await checkDeps(platform);
@@ -64,8 +59,18 @@ async function installSkill(name, options = {}) {
     }
   }
 
-  const skillInfo = validateSkillRegistry(name);
-  if (!skillInfo) return 1;
+  // Checked before any destructive step, because backupExisting() rmSyncs the
+  // target directory: a skill this package does not carry must never be
+  // installed by wiping what the user already has.
+  const available = bundledSkills();
+  if (!available.includes(name)) {
+    console.error(`Error: Unknown skill: ${name}`);
+    console.error(
+      `xp-gate ${getCliVersion()} bundles: ${available.join(', ')}. ` +
+      'Update the package (npm install -g @boyingliu01/xp-gate@latest) if you need ' + name + '.'
+    );
+    return 1;
+  }
 
   const targetDir = path.join(getSkillsDir(), name);
   const dupError = checkDuplicateInstall(targetDir, force);
@@ -79,7 +84,7 @@ async function installSkill(name, options = {}) {
   backupExisting(targetDir, installId, backupDir);
 
   try {
-    const result = await performInstall(skillInfo, name, targetDir, offline, verbose);
+    const result = await performInstall(name, targetDir, verbose);
     if (result !== 0) return result;
     return 0;
   } catch (err) {
@@ -89,16 +94,6 @@ async function installSkill(name, options = {}) {
   }
 }
 
-function validateSkillRegistry(name) {
-  const skillInfo = SKILLS_REGISTRY[name];
-  if (!skillInfo) {
-    console.error(`Error: Unknown skill: ${name}`);
-    console.error('Available skills: ' + Object.keys(SKILLS_REGISTRY).join(', '));
-    return null;
-  }
-  return skillInfo;
-}
-
 function checkDuplicateInstall(targetDir, force) {
   if (fs.existsSync(targetDir) && !force) {
     return `Error: ${path.basename(targetDir)} is already installed\nUse --force to overwrite`;
@@ -115,38 +110,22 @@ function backupExisting(targetDir, installId, backupDir) {
   }
 }
 
-async function performInstall(skillInfo, name, targetDir, offline, verbose) {
+async function performInstall(name, targetDir, verbose) {
   console.log(`Installing ${name}...`);
 
-  const skillUrl = `https://raw.githubusercontent.com/${skillInfo.repo}/main/${skillInfo.path}/SKILL.md`;
-  const targetFile = path.join(targetDir, 'SKILL.md');
-  fs.mkdirSync(path.dirname(targetFile), { recursive: true });
-
-  let downloaded = false;
-  if (!offline) {
-    try {
-      await downloadFile(skillUrl, targetFile, verbose);
-      downloaded = true;
-    } catch (err) {
-      if (verbose) console.warn(`Download failed: ${err.message}`);
-    }
-  }
-
-  if (!downloaded) {
-    if (offline) {
-      console.error(`Error: --offline specified but ${name} not in cache`);
-      return 2;
-    }
-    console.error(`Error: Failed to download ${name}`);
-    console.error('Check network connection');
-    return 1;
-  }
+  // The package ships skills/<name>/ with its references/, templates/ and
+  // scripts/, and that copy is what doctor compares against. A single SKILL.md
+  // downloaded from `main` used to be the whole install, so 8 of 13 skills
+  // landed without the files their own SKILL.md tells the agent to read,
+  // update-skill wiped complete directories down to that one file, and the
+  // installed content drifted from the CLI version (#416).
+  copyDirRecursive(path.join(BUNDLED_SKILLS_DIR, name), targetDir);
 
   ensureConfigDir();
-  
+
   // Read actual CLI version from VERSION file
   const version = getCliVersion();
-  
+
   updateConfig({
     installedSkills: {
       ...(getConfig().installedSkills || {}),
@@ -159,42 +138,6 @@ async function performInstall(skillInfo, name, targetDir, offline, verbose) {
   return 0;
 }
 
-async function downloadFile(url, dest, verbose) {
-  return new Promise((resolve, reject) => {
-    const file = fs.createWriteStream(dest);
-
-    const protocol = url.startsWith('https') ? https : http;
-
-    if (verbose) console.log(`Downloading ${url}...`);
-
-    protocol.get(url, { timeout: 30000 }, (response) => {
-      if (response.statusCode === 301 || response.statusCode === 302) {
-        const redirectUrl = response.headers.location;
-        file.close();
-        fs.unlinkSync(dest);
-        downloadFile(redirectUrl, dest, verbose).then(resolve).catch(reject);
-        return;
-      }
-
-      if (response.statusCode !== 200) {
-        file.close();
-        reject(new Error(`HTTP ${response.statusCode}`));
-        return;
-      }
-
-      response.pipe(file);
-      file.on('finish', () => {
-        file.close();
-        resolve();
-      });
-    }).on('error', (err) => {
-      file.close();
-      if (fs.existsSync(dest)) fs.unlinkSync(dest);
-      reject(err);
-    });
-  });
-}
-
 function ensureConfigDir() {
   fs.mkdirSync(CONFIG_DIR, { recursive: true });
 }

package/lib/language-tools.js

@@ -406,6 +406,72 @@ const LANGUAGE_REGISTRY = {
   },
 };
 
+/**
+ * Directories that must never drive language detection: dependency trees ship
+ * .sh and .ps1 files of their own, which would label every Node project a Shell
+ * project.
+ */
+const IGNORED_SCAN_DIRS = new Set(['.git', 'node_modules', 'dist', 'build', 'out', 'coverage', '.stryker-tmp', '.next']);
+
+// A bounded scan, not a full walk: detection only needs to know whether an
+// extension occurs at all, and huge monorepos must not pay for every file.
+const EXTENSION_SCAN_LIMIT = 2000;
+
+function extensionsPresentIn(projectRoot) {
+  const extensions = new Set();
+  const pending = [projectRoot];
+  let inspected = 0;
+
+  while (pending.length > 0 && inspected < EXTENSION_SCAN_LIMIT) {
+    const dir = pending.pop();
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    // Sorted: readdir order is filesystem-dependent, and a bounded scan that
+    // stops at an entry count must give the same answer on every machine
+    // (Round 1: feasibility FC-03, architecture MI-01).
+    entries.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+    for (const entry of entries) {
+      if (inspected >= EXTENSION_SCAN_LIMIT) break;
+      inspected += 1;
+      if (entry.isDirectory()) {
+        if (!IGNORED_SCAN_DIRS.has(entry.name)) pending.push(path.join(dir, entry.name));
+        continue;
+      }
+      const ext = path.extname(entry.name).slice(1).toLowerCase();
+      if (ext) extensions.add(ext);
+    }
+  }
+
+  return extensions;
+}
+
+/**
+ * Read the --languages selection, in either accepted form.
+ * `--languages=<a,b>` and `--languages <a,b>`; a bare `--languages`, and an
+ * inline `--languages=` with an empty value, both fall back to auto-detection
+ * rather than selecting a language named ''.
+ * @param {string[]} args
+ * @returns {string[]|null}
+ */
+function parseLanguageFlag(args) {
+  const inline = args.find((arg) => arg.startsWith('--languages='));
+  let value;
+  if (inline !== undefined) {
+    value = inline.slice('--languages='.length);
+  } else {
+    const index = args.indexOf('--languages');
+    const following = index === -1 ? undefined : args[index + 1];
+    value = following && !following.startsWith('-') ? following : undefined;
+  }
+  if (value === undefined) return null;
+  const picked = value.split(',').filter(Boolean);
+  return picked.length > 0 ? picked : null;
+}
+
 /**
  * Detect languages used in the current project.
  * @param {string} projectRoot - Project root directory
@@ -415,6 +481,14 @@ function detectProjectLanguages(projectRoot) {
   const detected = new Set();
   const configFiles = {};
 
+  // Scanned lazily: the extension fallback is only consulted for languages that
+  // have no config file to look for, and the scan is bounded, not a full walk.
+  let scannedExtensions = null;
+  const extensionSeen = (ext) => {
+    if (scannedExtensions === null) scannedExtensions = extensionsPresentIn(projectRoot);
+    return scannedExtensions.has(ext);
+  };
+
   for (const [lang, def] of Object.entries(LANGUAGE_REGISTRY)) {
     const foundConfigs = [];
     
@@ -443,6 +517,13 @@ function detectProjectLanguages(projectRoot) {
     if (foundConfigs.length > 0) {
       detected.add(lang);
       configFiles[lang] = foundConfigs;
+    } else if (def.configFiles.length === 0 && def.extensions.some(extensionSeen)) {
+      // Shell and PowerShell have no package-manager manifest to key off, so file
+      // extensions are their only possible signal (#468). Languages that do have
+      // config files keep using them: their extension lists are broad (IaC lists
+      // yaml/yml), and matching on those would make every repo with a CI YAML an
+      // Infrastructure-as-Code project.
+      detected.add(lang);
     }
   }
 
@@ -692,8 +773,7 @@ async function handleDetectLanguages(args) {
 async function handleCheckTools(args) {
   const projectRoot = process.cwd();
   const jsonOutput = args.includes('--json');
-  const langsArg = args.find(a => a.startsWith('--languages='));
-  let languages = langsArg ? langsArg.split('=')[1].split(',') : null;
+  let languages = parseLanguageFlag(args);
 
   // Auto-detect if no languages specified
   if (!languages) {
@@ -761,8 +841,7 @@ async function handleInstallTools(args) {
   const projectRoot = process.cwd();
   const dryRun = args.includes('--dry-run');
   const autoYes = args.includes('--yes') || args.includes('-y');
-  const langsArg = args.find(a => a.startsWith('--languages='));
-  let languages = langsArg ? langsArg.split('=')[1].split(',') : null;
+  let languages = parseLanguageFlag(args);
 
   // Auto-detect if no languages specified
   if (!languages) {

package/lib/mattpocock-license-verdict.json

@@ -2,6 +2,6 @@
   "verdict": "PASS",
   "license_type": "MIT",
   "sha256": "0e7ac423bf2c6e223b7c5b156f8cf72da49d748e56a1641402c31f22ad07dbb5",
-  "checked_at": "2026-09-24T04:13:16.240Z",
+  "checked_at": "2026-10-08T07:48:14.654Z",
   "source": "network"
 }

package/lib/shared-paths.js

@@ -24,11 +24,14 @@ const GLOBAL_MODULES_DIR = path.join(CONFIG_DIR, 'modules');
 
 /**
  * Detect which AI agent platform is currently in use.
- * Mirrors detectPlatform() in detect-deps.js to avoid circular deps.
+ * This is the single implementation; detect-deps.js re-exports it (#424).
  * @returns {'opencode' | 'claude-code' | 'qoder'}
  */
 function detectPlatform() {
-  if (fs.existsSync(path.join(HOME_DIR, '.qoder', 'skills'))) return 'qoder';
+  // Any ~/.qoder content counts as Qoder: a brand-new install has no skills/
+  // subdirectory yet, so a skills-only marker misdetects it as opencode and
+  // configureQoderDelphiAgents deploys zero Delphi agents (#424).
+  if (fs.existsSync(path.join(HOME_DIR, '.qoder'))) return 'qoder';
   if (fs.existsSync(path.join(HOME_DIR, '.claude', 'skills'))) return 'claude-code';
   return 'opencode';
 }