auxilo-mcp 0.9.20 → 0.9.22

package/bin/auxilo-cli.js

@@ -299,6 +299,8 @@ async function cmdSetup(flags) {
   console.log('');
   try {
     const { binRoot } = installer.installRunner(HOME);
+    const claudeBin = installer.recordClaudeBin(HOME, process.env.PATH);
+    if (claudeBin !== null) console.log(`  ✓ Claude Code CLI recorded: ${claudeBin}`);
     console.log(`  ✓ Extraction runner installed to ${binRoot}`);
   } catch (err) {
     console.error(`  ✗ Runner install failed: ${err.message}`);

package/lib/installer.js

@@ -84,6 +84,18 @@ function sourceAdapterRows(packageRoot = PACKAGE_ROOT) {
   }
 }
 
+/** Versioned extraction prompt bundle rows, derived so future bundles ship automatically. */
+function promptBundleRows(packageRoot = PACKAGE_ROOT) {
+  try {
+    return fs.readdirSync(path.join(packageRoot, 'scripts', 'prompts'))
+      .filter((f) => f.endsWith('.js'))
+      .sort()
+      .map((f) => [`scripts/prompts/${f}`, `scripts/prompts/${f}`, 0o644]);
+  } catch {
+    return []; // missing dir surfaces as installRunner missing-file errors
+  }
+}
+
 // EXTRACT-PER-CLIENT W1 PART A: extract-local.js now requires
 // './providers/index.js', which requires './claude-code.js' (and will require
 // './codex-cli.js' / './byo-key.js' once PART B/C land) — every file under
@@ -137,6 +149,7 @@ const RUNNER_STACK = Object.freeze([
   // at first extraction; omitting it from the installed stack is a MODULE_NOT_FOUND
   // for every npm-installed user (test/runner-packaging-closure.test.js guards this).
   ['scripts/extract-local.js', 'scripts/extract-local.js', 0o644],
+  ...promptBundleRows(),
   // LW-18 layer 1b: SessionStart held-count notice (shim target).
   ['scripts/review-notice.js', 'scripts/review-notice.js', 0o755],
   ...sourceAdapterRows(),
@@ -1048,6 +1061,29 @@ function writeRunnerConfig(homeDir, patch) {
   return merged;
 }
 
+/** Find the first regular executable in PATH, preserving its symlink path. */
+function findExecutableOnPath(name, envPath, fsImpl = fs) {
+  if (typeof envPath !== 'string' || !envPath) return null;
+  for (const dir of envPath.split(path.delimiter)) {
+    if (!dir) continue;
+    const candidate = path.resolve(dir, name);
+    try {
+      if (!fsImpl.statSync(candidate).isFile()) continue;
+      fsImpl.accessSync(candidate, fs.constants.X_OK);
+      return candidate;
+    } catch (_) { /* missing, inaccessible or non-executable — try the next entry */ }
+  }
+  return null;
+}
+
+/** Setup only: record the user's CLI and confirm the best-effort write persisted. */
+function recordClaudeBin(homeDir, envPath, fsImpl = fs) {
+  const bin = findExecutableOnPath('claude', envPath, fsImpl);
+  if (bin === null) return null;
+  writeRunnerConfig(homeDir, { claude_bin: bin });
+  return readRunnerConfig(homeDir).claude_bin === bin ? bin : null;
+}
+
 // ─── Device-code auth (spec §LW-12 step 2; server.js /auth/device) ──────────
 
 /**
@@ -2375,6 +2411,7 @@ module.exports = {
   DEFAULT_BASE_URL,
   PACKAGE_ROOT,
   RUNNER_STACK,
+  promptBundleRows,
   clientRegistry,
   detectClients,
   clientHasCaptureHookMode,
@@ -2397,6 +2434,8 @@ module.exports = {
   runnerConfigPath,
   readRunnerConfig,
   writeRunnerConfig,
+  findExecutableOnPath,
+  recordClaudeBin,
   writeEnvFile,
   deviceLogin,
   binRootFor,

package/mcp-server.js

@@ -198,7 +198,7 @@ async function postBulkChunks(headers, decisions) {
 }
 
 const server = new Server(
-  { name: 'auxilo', version: '0.9.20' },
+  { name: 'auxilo', version: '0.9.22' },
   {
     capabilities: { tools: {} },
     instructions: `You are connected to Auxilo, a knowledge marketplace where AI agents buy and sell operational learnings.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auxilo-mcp",
-  "version": "0.9.20",
+  "version": "0.9.22",
   "mcpName": "io.github.silent-architects/auxilo",
   "description": "MCP server for Auxilo. Your agent stops solving the same problem twice: auto-extracted learnings, free self-unlocks, and earnings when other agents unlock yours.",
   "main": "mcp-server.js",
@@ -27,6 +27,7 @@
     "scripts/capture-core.js",
     "scripts/extract-local.js",
     "scripts/review-notice.js",
+    "scripts/prompts/",
     "scripts/sources/",
     "scripts/providers/",
     "scripts/hooks/auxilo-extract.sh",

package/scripts/extract-local.js

@@ -25,16 +25,24 @@ const {
 } = require('../lib/extraction-index.js');
 const providers = require('./providers/index.js');
 const claudeCodeProvider = require('./providers/claude-code.js');
+const {
+  CATEGORIES,
+  PRIVATE_CATEGORIES,
+  RETIRED_CATEGORIES,
+  EXTRACTION_PROMPT_BASE,
+  PUBLIC_SCOPE_BLOCK,
+  PRIVATE_SCOPE_BLOCK,
+  QUALITY_RUBRIC_ADDENDUM,
+  PROMPT_SUFFIX,
+  ANCHORED_JUDGE_PROMPT_BASE,
+} = require('./prompts');
 
 // CI-5 (PUNCH-LIST §30, 2026-07-19): Auxilo is TECHNICAL-ONLY. The learning
 // taxonomy is these six tech categories; `communication` and `content-generation`
 // are RETIRED — the server 400s them (CATEGORY_OUT_OF_SCOPE) and this extractor
-// must never emit them. This file ships standalone in the npm package, so the
-// lists are duplicated here from lib/category-scope-migration.js (server truth);
+// must never emit them. The governed prompt bundle carries the client-side copy
+// from lib/category-scope-migration.js (server truth);
 // test/ci5-scope-enforcement.test.js pins the copies equal.
-const CATEGORIES = ['data-processing', 'web-interaction', 'code-execution', 'storage-state', 'payment-financial', 'monitoring'];
-const PRIVATE_CATEGORIES = [...CATEGORIES, 'non-technical'];
-const RETIRED_CATEGORIES = ['communication', 'content-generation'];
 
 /**
  * SPEC3 slice A1 gate — score-at-extraction, ON BY DEFAULT since 0.9.12
@@ -69,37 +77,6 @@ function scoreExtractionEnabled(env = process.env) {
   return !(v === '0' || v === 'false');
 }
 
-const EXTRACTION_PROMPT_BASE = `You are extracting reusable OPERATIONAL LEARNINGS from an AI agent's session transcript, to publish to a PUBLIC knowledge marketplace read by other AI agents.
-
-Extract 0 to 5 GENUINE learnings: non-obvious solutions, workarounds, API quirks, error root-causes, integration gotchas — the kind of thing that cost real debugging or combined multiple sources. SKIP trivial lookups, well-documented standard approaches, opinions, and conversation.
-
-HARD SCOPE RULE — TECHNICAL LEARNINGS ONLY (the marketplace accepts nothing else): extract ONLY technical/operational learnings — APIs, developer tools, code, infrastructure, data pipelines, monitoring/observability, payment/crypto TECHNOLOGY, debugging. NEVER extract interpersonal or communication strategy, copywriting/content/marketing insights, business or negotiation strategy, personal matters, or creative-writing technique — DROP such candidates entirely, do not relabel them. A technical learning about a messaging/email/notification API belongs under "web-interaction" or "code-execution"; content/data pipeline TECH belongs under "data-processing".
-
-SYSTEM-FACT TEST (CI-7): Extract ONLY when a system and a symptom are at the core — an error, an undocumented limitation, a reproducible behavior of an external tool/API/OS. If the candidate is advice about how to work (process, workflow, methodology, decision practice), do NOT extract it. "Odesli cannot resolve Tidal artist URLs" is a learning; "use a two-phase consultation workflow" is not, no matter how well it would score.
-
-MANDATORY SENSITIVITY SELF-SCREEN (the marketplace is PUBLIC): NEVER include secrets, credentials, API keys, tokens, private keys, or seed phrases; personal data (real people's names, emails, phone numbers, wallet addresses); private filesystem paths, internal hostnames, or infrastructure identifiers; proprietary, confidential, or client-specific business content. Rewrite specifics into generic placeholders (/Users/USER/..., API_KEY, "a client") or omit them. If a learning cannot be generalized without leaking private material, DROP it entirely.
-
-Output STRICT JSON ONLY — an object with:
-  "learnings": an array (possibly empty []) of objects with these keys:
-  "title": concise, >= 10 chars
-  "body": >= 50 chars — what was tried, what worked, what failed
-  "category": one of ${JSON.stringify(CATEGORIES)}
-  "tags": array of lowercase keyword strings
-  "task_context": one sentence describing the task
-  "outcome": one of "success","partial","failure","workaround"
-  "dedup_drops": an array (possibly empty []) used ONLY for candidates dropped
-  because they match PREVIOUSLY CAPTURED LESSONS. Each entry must be:
-    {"candidate": <the complete learning object above>,
-     "matched_index_id": "<exact id from the memory list>",
-     "matched_title": "<exact matched title>"}
-  Scope/quality/sensitivity skips are not dedup_drops.`;
-
-const PUBLIC_SCOPE_BLOCK = `HARD SCOPE RULE — TECHNICAL LEARNINGS ONLY (the marketplace accepts nothing else): extract ONLY technical/operational learnings — APIs, developer tools, code, infrastructure, data pipelines, monitoring/observability, payment/crypto TECHNOLOGY, debugging. NEVER extract interpersonal or communication strategy, copywriting/content/marketing insights, business or negotiation strategy, personal matters, or creative-writing technique — DROP such candidates entirely, do not relabel them. A technical learning about a messaging/email/notification API belongs under "web-interaction" or "code-execution"; content/data pipeline TECH belongs under "data-processing".
-
-SYSTEM-FACT TEST (CI-7): Extract ONLY when a system and a symptom are at the core — an error, an undocumented limitation, a reproducible behavior of an external tool/API/OS. If the candidate is advice about how to work (process, workflow, methodology, decision practice), do NOT extract it. "Odesli cannot resolve Tidal artist URLs" is a learning; "use a two-phase consultation workflow" is not, no matter how well it would score.`;
-
-const PRIVATE_SCOPE_BLOCK = `PRIVATE CAPTURE SCOPE — OWNER-ONLY: extract reusable technical OR non-technical operational learnings. Non-technical process, workflow, communication, content, business, or creative learnings may use category "non-technical"; do not drop a genuine reusable candidate solely because it is non-technical. This private lane is never published unless the owner later sanitizes and promotes an item through public review. The mandatory sensitivity screen still applies without exception.`;
-
 function promptBaseForVisibility(captureVisibility) {
   if (captureVisibility !== 'private') return EXTRACTION_PROMPT_BASE;
   return EXTRACTION_PROMPT_BASE
@@ -111,27 +88,6 @@ function promptBaseForVisibility(captureVisibility) {
     .replace(JSON.stringify(CATEGORIES), JSON.stringify(PRIVATE_CATEGORIES));
 }
 
-/** A1: rubric addendum — appended ONLY when scoreExtractionEnabled(). */
-const QUALITY_RUBRIC_ADDENDUM = `
-  "quality_self_assessment": an object scoring the learning honestly on four
-  dimensions, each an INTEGER 1-5: "specificity" (precise and detailed, not
-  vague), "actionability" (another agent can directly use it), "novelty"
-  (non-obvious; an LLM would likely get it wrong), "completeness" (context,
-  reproduction steps, caveats), plus "total" (the exact sum of the four).
-  A learning worth publishing scores at least 14/20 with no dimension below 3.
-  High scores REQUIRE a system+symptom anchor — a named external system and a
-  concrete error/limitation/behavior; process or workflow advice cannot score
-  high no matter how polished (CI-7 system-fact test).
-  If a learning honestly scores below that bar, DROP it from learnings rather
-  than inflating the numbers.`;
-
-const PROMPT_SUFFIX = `
-No prose, no explanation, no markdown code fences — just the raw JSON object
-{"learnings":[...],"dedup_drops":[...]}.
-
-TRANSCRIPT:
-`;
-
 /** Build the extraction prompt for the current (or injected) gate state. */
 function buildExtractionPrompt(opts = {}) {
   const withScore = opts.scoreExtraction !== undefined
@@ -361,18 +317,7 @@ function buildAnchoredJudgePrompt(candidates, indexRows, opts = {}) {
       title: row.title,
     })),
   }));
-  const prompt = `You are a binary deduplication judge for operational learnings.
-For each candidate, decide whether it is a re-statement of ANY listed previously
-captured lesson. The same operational insight in different words is YES.
-A genuinely new fact is NO only when it would change what another agent does.
-
-Return STRICT JSON ONLY:
-{"decisions":[{"candidate_index":0,"duplicate":true,"matched_index_id":"..."}]}
-Return exactly one decision for every candidate_index. When duplicate=false,
-omit matched_index_id. When duplicate=true, matched_index_id MUST be one of that
-candidate's listed ids. No prose and no markdown.
-
-${JSON.stringify(payload)}`;
+  const prompt = `${ANCHORED_JUDGE_PROMPT_BASE}\n\n${JSON.stringify(payload)}`;
   return { prompt, rankings };
 }
 

package/scripts/prompts/extraction.v1.js

@@ -0,0 +1,99 @@
+'use strict';
+
+const PROMPT_BUNDLE_VERSION = '1';
+const ASSEMBLY_CONTRACT_VERSION = '1';
+
+const CATEGORIES = Object.freeze([
+  'data-processing',
+  'web-interaction',
+  'code-execution',
+  'storage-state',
+  'payment-financial',
+  'monitoring',
+]);
+const PRIVATE_CATEGORIES = Object.freeze([
+  'data-processing',
+  'web-interaction',
+  'code-execution',
+  'storage-state',
+  'payment-financial',
+  'monitoring',
+  'non-technical',
+]);
+const RETIRED_CATEGORIES = Object.freeze(['communication', 'content-generation']);
+
+const EXTRACTION_PROMPT_BASE = `You are extracting reusable OPERATIONAL LEARNINGS from an AI agent's session transcript, to publish to a PUBLIC knowledge marketplace read by other AI agents.
+
+Extract 0 to 5 GENUINE learnings: non-obvious solutions, workarounds, API quirks, error root-causes, integration gotchas — the kind of thing that cost real debugging or combined multiple sources. SKIP trivial lookups, well-documented standard approaches, opinions, and conversation.
+
+HARD SCOPE RULE — TECHNICAL LEARNINGS ONLY (the marketplace accepts nothing else): extract ONLY technical/operational learnings — APIs, developer tools, code, infrastructure, data pipelines, monitoring/observability, payment/crypto TECHNOLOGY, debugging. NEVER extract interpersonal or communication strategy, copywriting/content/marketing insights, business or negotiation strategy, personal matters, or creative-writing technique — DROP such candidates entirely, do not relabel them. A technical learning about a messaging/email/notification API belongs under "web-interaction" or "code-execution"; content/data pipeline TECH belongs under "data-processing".
+
+SYSTEM-FACT TEST (CI-7): Extract ONLY when a system and a symptom are at the core — an error, an undocumented limitation, a reproducible behavior of an external tool/API/OS. If the candidate is advice about how to work (process, workflow, methodology, decision practice), do NOT extract it. "Odesli cannot resolve Tidal artist URLs" is a learning; "use a two-phase consultation workflow" is not, no matter how well it would score.
+
+MANDATORY SENSITIVITY SELF-SCREEN (the marketplace is PUBLIC): NEVER include secrets, credentials, API keys, tokens, private keys, or seed phrases; personal data (real people's names, emails, phone numbers, wallet addresses); private filesystem paths, internal hostnames, or infrastructure identifiers; proprietary, confidential, or client-specific business content. Rewrite specifics into generic placeholders (/Users/USER/..., API_KEY, "a client") or omit them. If a learning cannot be generalized without leaking private material, DROP it entirely.
+
+Output STRICT JSON ONLY — an object with:
+  "learnings": an array (possibly empty []) of objects with these keys:
+  "title": concise, >= 10 chars
+  "body": >= 50 chars — what was tried, what worked, what failed
+  "category": one of ["data-processing","web-interaction","code-execution","storage-state","payment-financial","monitoring"]
+  "tags": array of lowercase keyword strings
+  "task_context": one sentence describing the task
+  "outcome": one of "success","partial","failure","workaround"
+  "dedup_drops": an array (possibly empty []) used ONLY for candidates dropped
+  because they match PREVIOUSLY CAPTURED LESSONS. Each entry must be:
+    {"candidate": <the complete learning object above>,
+     "matched_index_id": "<exact id from the memory list>",
+     "matched_title": "<exact matched title>"}
+  Scope/quality/sensitivity skips are not dedup_drops.`;
+
+const PUBLIC_SCOPE_BLOCK = `HARD SCOPE RULE — TECHNICAL LEARNINGS ONLY (the marketplace accepts nothing else): extract ONLY technical/operational learnings — APIs, developer tools, code, infrastructure, data pipelines, monitoring/observability, payment/crypto TECHNOLOGY, debugging. NEVER extract interpersonal or communication strategy, copywriting/content/marketing insights, business or negotiation strategy, personal matters, or creative-writing technique — DROP such candidates entirely, do not relabel them. A technical learning about a messaging/email/notification API belongs under "web-interaction" or "code-execution"; content/data pipeline TECH belongs under "data-processing".
+
+SYSTEM-FACT TEST (CI-7): Extract ONLY when a system and a symptom are at the core — an error, an undocumented limitation, a reproducible behavior of an external tool/API/OS. If the candidate is advice about how to work (process, workflow, methodology, decision practice), do NOT extract it. "Odesli cannot resolve Tidal artist URLs" is a learning; "use a two-phase consultation workflow" is not, no matter how well it would score.`;
+
+const PRIVATE_SCOPE_BLOCK = `PRIVATE CAPTURE SCOPE — OWNER-ONLY: extract reusable technical OR non-technical operational learnings. Non-technical process, workflow, communication, content, business, or creative learnings may use category "non-technical"; do not drop a genuine reusable candidate solely because it is non-technical. This private lane is never published unless the owner later sanitizes and promotes an item through public review. The mandatory sensitivity screen still applies without exception.`;
+
+const QUALITY_RUBRIC_ADDENDUM = `
+  "quality_self_assessment": an object scoring the learning honestly on four
+  dimensions, each an INTEGER 1-5: "specificity" (precise and detailed, not
+  vague), "actionability" (another agent can directly use it), "novelty"
+  (non-obvious; an LLM would likely get it wrong), "completeness" (context,
+  reproduction steps, caveats), plus "total" (the exact sum of the four).
+  A learning worth publishing scores at least 14/20 with no dimension below 3.
+  High scores REQUIRE a system+symptom anchor — a named external system and a
+  concrete error/limitation/behavior; process or workflow advice cannot score
+  high no matter how polished (CI-7 system-fact test).
+  If a learning honestly scores below that bar, DROP it from learnings rather
+  than inflating the numbers.`;
+
+const PROMPT_SUFFIX = `
+No prose, no explanation, no markdown code fences — just the raw JSON object
+{"learnings":[...],"dedup_drops":[...]}.
+
+TRANSCRIPT:
+`;
+
+const ANCHORED_JUDGE_PROMPT_BASE = `You are a binary deduplication judge for operational learnings.
+For each candidate, decide whether it is a re-statement of ANY listed previously
+captured lesson. The same operational insight in different words is YES.
+A genuinely new fact is NO only when it would change what another agent does.
+
+Return STRICT JSON ONLY:
+{"decisions":[{"candidate_index":0,"duplicate":true,"matched_index_id":"..."}]}
+Return exactly one decision for every candidate_index. When duplicate=false,
+omit matched_index_id. When duplicate=true, matched_index_id MUST be one of that
+candidate's listed ids. No prose and no markdown.`;
+
+module.exports = Object.freeze({
+  PROMPT_BUNDLE_VERSION,
+  ASSEMBLY_CONTRACT_VERSION,
+  CATEGORIES,
+  PRIVATE_CATEGORIES,
+  RETIRED_CATEGORIES,
+  EXTRACTION_PROMPT_BASE,
+  PUBLIC_SCOPE_BLOCK,
+  PRIVATE_SCOPE_BLOCK,
+  QUALITY_RUBRIC_ADDENDUM,
+  PROMPT_SUFFIX,
+  ANCHORED_JUDGE_PROMPT_BASE,
+});

package/scripts/prompts/index.js

@@ -0,0 +1,30 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const ACTIVE_BUNDLE_VERSION = '1';
+const BUNDLE_PATHS = Object.freeze({
+  '1': path.join(__dirname, 'extraction.v1.js'),
+});
+
+function bundlePath(version = ACTIVE_BUNDLE_VERSION) {
+  const resolved = BUNDLE_PATHS[String(version)];
+  if (!resolved) throw new Error(`Unknown extraction prompt bundle version: ${version}`);
+  return resolved;
+}
+
+function loadPromptBundle(version = ACTIVE_BUNDLE_VERSION) {
+  return require(bundlePath(version));
+}
+
+function bundleDigest(version = ACTIVE_BUNDLE_VERSION) {
+  return crypto.createHash('sha256').update(fs.readFileSync(bundlePath(version))).digest('hex');
+}
+
+module.exports = Object.freeze({
+  ...loadPromptBundle(),
+  bundleDigest,
+  loadPromptBundle,
+});

package/scripts/providers/claude-code.js

@@ -22,23 +22,56 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 
-/** Resolve the `claude` binary — hook/launchd env may have a minimal PATH. */
+/** Leading major.minor.patch only; unreadable versions retain fallback behavior. */
+function versionParts(version) {
+  const match = typeof version === 'string' && /^(\d+)\.(\d+)\.(\d+)/.exec(version);
+  return match ? match.slice(1).map(Number) : null;
+}
+
+function compareVersions(left, right) {
+  for (let i = 0; i < 3; i += 1) {
+    if (left[i] !== right[i]) return left[i] > right[i] ? 1 : -1;
+  }
+  return 0;
+}
+
+/** Resolve the newest readable CLI — hook/launchd env may have a minimal PATH. */
 function resolveClaudeBin(opts = {}) {
   const homeDir = typeof opts.homeDir === 'string' ? opts.homeDir : os.homedir();
   const existsSync = typeof opts.existsSync === 'function' ? opts.existsSync : fs.existsSync;
+  const readFileSyncImpl = typeof opts.readFileSyncImpl === 'function' ? opts.readFileSyncImpl : fs.readFileSync;
   const candidates = [
     path.join(homeDir, '.claude', 'local', 'claude'),
     '/usr/local/bin/claude',
     '/opt/homebrew/bin/claude',
     path.join(homeDir, '.local', 'bin', 'claude'),
+    path.join(homeDir, '.npm-global', 'bin', 'claude'),
   ];
+  // Read directly: the sweeper install does not include lib/installer.js.
+  try {
+    const config = JSON.parse(readFileSyncImpl(path.join(homeDir, '.auxilo', 'runner-config.json'), 'utf8'));
+    const recorded = config && config.claude_bin;
+    if (typeof recorded === 'string' && path.isAbsolute(recorded) && path.basename(recorded) === 'claude') {
+      candidates.unshift(recorded);
+    }
+  } catch (_) { /* missing/malformed config means no recorded candidate */ }
+
+  let firstExisting;
+  let newest;
+  let newestVersion;
   for (const c of candidates) {
     try {
-      if (existsSync(c)) return c;
+      if (!existsSync(c)) continue;
+      if (!firstExisting) firstExisting = c;
+      const version = versionParts(getClaudeCliVersion(c, opts));
+      if (version && (!newestVersion || compareVersions(version, newestVersion) > 0)) {
+        newest = c;
+        newestVersion = version;
+      }
     } catch (_) { /* ignore */ }
   }
   // Absolute launchd fallbacks are absent; let PATH resolve the final option.
-  return 'claude';
+  return newest || firstExisting || 'claude';
 }
 
 // ─── Child settings/hooks isolation (EXTRACTION-CHILD-HOOKS, PUNCH-LIST P1,
@@ -105,27 +138,35 @@ function _resetSettingSourcesCacheForTests() {
   cachedSettingSourcesUnsupported = undefined;
 }
 
-// ─── CLI version, for diagnostics only (no subprocess spawn) ───────────────
+// ─── CLI version, for selection, auth gating and provenance (no spawn) ──────
 //
 // Resolves the installed package's own package.json version by following the
 // resolved binary's real path (e.g. `/usr/local/bin/claude` -> `.../
 // node_modules/@anthropic-ai/claude-code/cli.js`) and reading the sibling
-// package.json — filesystem-only, so it never adds a spawn to the extraction
+// package.json, or the named parent package for the native bin/claude.exe
+// layout — filesystem-only, so it never adds a spawn to the extraction
 // path (verified live: realpath + package.json read, no `claude --version`
 // call). Best-effort: any failure (bare `claude` unresolved via PATH, an
-// install layout that doesn't carry a sibling package.json, a fixture path in
+// install layout that doesn't carry either package.json, a fixture path in
 // tests) yields null, never throws.
 function getClaudeCliVersion(bin, opts = {}) {
   const realpathSyncImpl = typeof opts.realpathSyncImpl === 'function' ? opts.realpathSyncImpl : fs.realpathSync;
   const readFileSyncImpl = typeof opts.readFileSyncImpl === 'function' ? opts.readFileSyncImpl : fs.readFileSync;
   try {
     const real = realpathSyncImpl(bin);
-    const pkgPath = path.join(path.dirname(real), 'package.json');
-    const pkg = JSON.parse(readFileSyncImpl(pkgPath, 'utf8'));
-    return pkg && typeof pkg.version === 'string' ? pkg.version : null;
+    const dir = path.dirname(real);
+    for (const [pkgDir, requireName] of [[dir, false], [path.dirname(dir), true]]) {
+      try {
+        const pkg = JSON.parse(readFileSyncImpl(path.join(pkgDir, 'package.json'), 'utf8'));
+        if (pkg && typeof pkg.version === 'string' && (!requireName || pkg.name === '@anthropic-ai/claude-code')) {
+          return pkg.version;
+        }
+      } catch (_) { /* unreadable sibling may still have a valid parent */ }
+    }
   } catch {
-    return null;
+    /* unresolved binary */
   }
+  return null;
 }
 
 // ─── Env scrub (EXTRACT-TOOLS-LOCK, PUNCH-LIST) ────────────────────────────
@@ -345,6 +386,10 @@ function detectBillingHelperConfigured(opts = {}) {
 function checkAuthStatus(opts = {}) {
   const spawnSyncImpl = typeof opts.spawnSyncImpl === 'function' ? opts.spawnSyncImpl : spawnSync;
   const bin = typeof opts.claudeBin === 'string' ? opts.claudeBin : resolveClaudeBin(opts);
+  const version = versionParts(getClaudeCliVersion(bin, opts));
+  // Older CLIs treat `auth status` as a model prompt. Unknown versions retain
+  // the existing probe; only a known-old build can safely skip it here.
+  if (version && compareVersions(version, [2, 1, 41]) < 0) return 'unknown';
   let res;
   try {
     res = spawnSyncImpl(bin, ['auth', 'status'], {

package/scripts/runner.js

@@ -850,15 +850,36 @@ const SWEEPER_LABEL = 'io.auxilo.sweeper';
  */
 function sweeperManifest(repoRoot = path.resolve(__dirname, '..')) {
   const sourceRows = [];
+  const promptRows = [];
+  const providerRows = [];
+  const providerSchemaRows = [];
   try {
     for (const f of fs.readdirSync(path.join(repoRoot, 'scripts', 'sources')).filter(f => f.endsWith('.js')).sort()) {
       sourceRows.push([`scripts/sources/${f}`, `scripts/sources/${f}`, 0o644]);
     }
   } catch { /* missing dir surfaces as missing-file errors below */ }
+  try {
+    for (const f of fs.readdirSync(path.join(repoRoot, 'scripts', 'prompts')).filter(f => f.endsWith('.js')).sort()) {
+      promptRows.push([`scripts/prompts/${f}`, `scripts/prompts/${f}`, 0o644]);
+    }
+  } catch { /* missing dir surfaces as missing-file errors below */ }
+  try {
+    for (const f of fs.readdirSync(path.join(repoRoot, 'scripts', 'providers')).filter(f => f.endsWith('.js')).sort()) {
+      providerRows.push([`scripts/providers/${f}`, `scripts/providers/${f}`, 0o644]);
+    }
+  } catch { /* missing dir surfaces as missing-file errors below */ }
+  try {
+    for (const f of fs.readdirSync(path.join(repoRoot, 'scripts', 'providers', 'schemas')).filter(f => f.endsWith('.json')).sort()) {
+      providerSchemaRows.push([`scripts/providers/schemas/${f}`, `scripts/providers/schemas/${f}`, 0o644]);
+    }
+  } catch { /* missing dir surfaces as missing-file errors below */ }
   return [
     ['scripts/auxilo-sweeper-wrapper.sh', 'auxilo-sweeper-wrapper.sh', 0o755],
     ['scripts/runner.js', 'scripts/runner.js', 0o755],
     ...sourceRows,
+    ...promptRows,
+    ...providerRows,
+    ...providerSchemaRows,
     ['lib/sensitivity-filter.js', 'lib/sensitivity-filter.js', 0o644],
     ['lib/extraction-index.js', 'lib/extraction-index.js', 0o644],
     ['lib/similarity.js', 'lib/similarity.js', 0o644],