auxilo-mcp 0.9.11 → 0.9.13

package/lib/installer.js

@@ -55,6 +55,44 @@ function sourceAdapterRows(packageRoot = PACKAGE_ROOT) {
   }
 }
 
+// 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
+// scripts/providers/ must ship the same way scripts/sources/ does, or an
+// npm-installed user's first extraction is a MODULE_NOT_FOUND
+// (test/runner-packaging-closure.test.js guards this).
+function providerAdapterRows(packageRoot = PACKAGE_ROOT) {
+  try {
+    return fs.readdirSync(path.join(packageRoot, 'scripts', 'providers'))
+      .filter((f) => f.endsWith('.js'))
+      .sort()
+      .map((f) => [`scripts/providers/${f}`, `scripts/providers/${f}`, 0o644]);
+  } catch {
+    return []; // missing dir surfaces as installRunner missing-file errors
+  }
+}
+
+// EXTRACT-PER-CLIENT W1 PART B: codex-cli.js reads its two JSON-Schema hint
+// files at runtime via a path relative to itself (scripts/providers/schemas/
+// *.schema.json), NOT via require() — providerAdapterRows() above only
+// enumerates *.js in scripts/providers/ itself (non-recursive), so the
+// schemas/ subdirectory would silently NOT reach an npm-installed user's
+// ~/.auxilo/bin without its own enumeration here. installRunner copies files
+// one at a time (no directory copy), so every schema file needs its own row,
+// same as providerAdapterRows()'s .js rows — this is the "check whether it
+// enumerates the directory or a list" case turning out to be "neither yet;
+// add the enumeration."
+function providerSchemaRows(packageRoot = PACKAGE_ROOT) {
+  try {
+    return fs.readdirSync(path.join(packageRoot, 'scripts', 'providers', 'schemas'))
+      .filter((f) => f.endsWith('.json'))
+      .sort()
+      .map((f) => [`scripts/providers/schemas/${f}`, `scripts/providers/schemas/${f}`, 0o644]);
+  } catch {
+    return []; // missing dir surfaces as installRunner missing-file errors
+  }
+}
+
 /**
  * Runner stack shipped in the npm tarball and copied into <home>/.auxilo/bin,
  * preserving relative layout so runner.js's requires resolve
@@ -73,6 +111,8 @@ const RUNNER_STACK = Object.freeze([
   // LW-18 layer 1b: SessionStart held-count notice (shim target).
   ['scripts/review-notice.js', 'scripts/review-notice.js', 0o755],
   ...sourceAdapterRows(),
+  ...providerAdapterRows(),
+  ...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],
@@ -792,10 +832,18 @@ exit 0
  * relative layout runner.js requires. Missing package files throw — the lib
  * never calls process.exit.
  *
+ * CLEAN-LANE-FLIP Phase B: the install also stamps <bin>/VERSION with the
+ * package version read from <packageRoot>/package.json at install time, so
+ * `auxilo status` can tell a stale copied stack from the CLI that is running
+ * (npx resolves a fresh auxilo-mcp; ~/.auxilo/bin keeps whatever setup last
+ * copied). VERSION is a stamp, not a stack row — it is deliberately NOT in
+ * RUNNER_STACK (test/runner-packaging-closure.test.js walks the require
+ * closure against the stack, and a version file is not code).
+ *
  * @param {string} homeDir
  * @param {object} [opts]
  * @param {string} [opts.packageRoot=PACKAGE_ROOT]
- * @returns {{ binRoot: string, hookPath: string, installed: string[] }}
+ * @returns {{ binRoot: string, hookPath: string, versionPath: string, version: string, installed: string[] }}
  */
 function installRunner(homeDir, opts = {}) {
   if (!homeDir) throw new Error('installRunner: homeDir is required');
@@ -820,7 +868,55 @@ function installRunner(homeDir, opts = {}) {
   fs.chmodSync(hookPath, 0o755);
   installed.push(hookPath);
 
-  return { binRoot, hookPath, installed };
+  const version = packageVersion(packageRoot);
+  const versionPath = runnerVersionPath(homeDir);
+  fs.writeFileSync(versionPath, `${version}\n`);
+  fs.chmodSync(versionPath, 0o644);
+  installed.push(versionPath);
+
+  return { binRoot, hookPath, versionPath, version, installed };
+}
+
+// ─── Runner-stack freshness (CLEAN-LANE-FLIP Phase B) ───────────────────────
+
+/** <home>/.auxilo/bin/VERSION — the package version installRunner last copied. */
+function runnerVersionPath(homeDir) {
+  return path.join(binRootFor(homeDir), 'VERSION');
+}
+
+/** Package version as shipped in <packageRoot>/package.json (throws if unreadable). */
+function packageVersion(packageRoot = PACKAGE_ROOT) {
+  const pkg = JSON.parse(fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf-8'));
+  if (!pkg || typeof pkg.version !== 'string' || !pkg.version) {
+    throw new Error(`packageVersion: no version in ${path.join(packageRoot, 'package.json')}`);
+  }
+  return pkg.version;
+}
+
+/** Installed runner stamp, or null when the stamp is missing/unreadable (pre-0.9.12 installs). */
+function installedRunnerVersion(homeDir) {
+  try {
+    const v = fs.readFileSync(runnerVersionPath(homeDir), 'utf-8').trim();
+    return v || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Compare the copied runner stack against the running package.
+ *
+ * @param {string} homeDir
+ * @param {object} [opts]
+ * @param {string} [opts.packageRoot=PACKAGE_ROOT]
+ * @returns {{ installed: string|null, package: string, skew: boolean }}
+ *   skew is true when the stamp is missing OR differs from the package version.
+ */
+function runnerVersionSkew(homeDir, opts = {}) {
+  if (!homeDir) throw new Error('runnerVersionSkew: homeDir is required');
+  const installed = installedRunnerVersion(homeDir);
+  const pkg = packageVersion(opts.packageRoot || PACKAGE_ROOT);
+  return { installed, package: pkg, skew: installed !== pkg };
 }
 
 // ─── Claude Code hook registration (spec §LW-12 step 4) ─────────────────────
@@ -1704,6 +1800,10 @@ module.exports = {
   hookScriptPathFor,
   renderHookScript,
   installRunner,
+  runnerVersionPath,
+  packageVersion,
+  installedRunnerVersion,
+  runnerVersionSkew,
   registerClaudeCodeHook,
   removeClaudeCodeHook,
   captureShimPath,

package/mcp-server.js

@@ -198,7 +198,7 @@ async function postBulkChunks(headers, decisions) {
 }
 
 const server = new Server(
-  { name: 'auxilo', version: '0.9.11' },
+  { name: 'auxilo', version: '0.9.13' },
   {
     capabilities: { tools: {} },
     instructions: `You are connected to Auxilo, a knowledge marketplace where AI agents buy and sell operational learnings.
@@ -211,9 +211,9 @@ TECHNICAL SCOPE (hard rule — the server refuses anything else): Auxilo accepts
 
 QUALITY GATE: Before submitting, self-assess on four dimensions (1-5 each): Specificity, Actionability, Novelty, Completeness. Only submit if total >= 14/20 and no single dimension is below 3.
 
-SENSITIVITY SELF-SCREEN (MANDATORY — you are the LLM, so YOU screen before submitting; the marketplace is public): A learning must be GENERALIZABLE operational knowledge, not private context. NEVER submit: secrets, credentials, API keys, tokens, private keys, wallet 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 belonging to you or your operator. Rewrite specifics into generic placeholders (e.g. /Users/USER/..., API_KEY, "a client") or omit them. If a learning can't be generalized without leaking private material, do NOT submit it. When in doubt, leave it out.
+SENSITIVITY SELF-SCREEN (MANDATORY — you are the LLM, so YOU screen before submitting; the Auxilo marketplace is public): A learning must be GENERALIZABLE operational knowledge, not private context. NEVER submit: secrets, credentials, API keys, tokens, private keys, wallet 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 belonging to you or your operator. Rewrite specifics into generic placeholders (e.g. /Users/USER/..., API_KEY, "a client") or omit them. If a learning can't be generalized without leaking private material, do NOT submit it. When in doubt, leave it out.
 
-RATE AFTER YOU USE: After unlocking and applying a learning from the marketplace, rate it 1-5 using auxilo_rate. This keeps the marketplace quality high.
+RATE AFTER YOU USE: After unlocking and applying a learning from the Auxilo marketplace, rate it 1-5 using auxilo_rate. This keeps the Auxilo marketplace quality high.
 
 DEDUP BEFORE SUBMITTING: Search auxilo_knowledge for your topic before contributing to avoid duplicates.
 
@@ -274,7 +274,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
     },
     {
       name: 'auxilo_contribute',
-      description: 'Submit TECHNICAL operational knowledge you discovered during this session to the Auxilo marketplace. WHEN TO USE: Call this AFTER you solve a non-trivial TECHNICAL problem that required debugging, experimentation, or combining information from multiple sources. Call it when you discover undocumented behavior, a workaround, or a subtle edge case. Do NOT call it for trivial lookups or standard documentation answers. SCOPE (hard rule — the server refuses out-of-scope submissions with CATEGORY_OUT_OF_SCOPE): technical learnings ONLY — APIs, developer tools, code, infrastructure, data pipelines, monitoring, payment/crypto technology, debugging. NEVER submit interpersonal/communication strategy, copywriting/content/marketing insights, business or negotiation strategy, personal matters, or creative-writing technique. A technical learning about a messaging/email/notification API belongs under web-interaction or code-execution; content/data pipeline tech belongs under data-processing. QUALITY GATE: Self-assess on Specificity, Actionability, Novelty, Completeness (1-5 each) and ALWAYS include your scores in quality_self_assessment — a submission WITHOUT it is held for manual review instead of publishing seamlessly. Only submit if total >= 14/20, no dimension below 3 (the server quarantines below-floor submissions for review). DEDUP: Search auxilo_knowledge first to avoid duplicates. SENSITIVITY (mandatory self-screen): never include secrets, credentials, API keys, PII, private filesystem paths, or proprietary/client business content — generalize to placeholders or omit; this is a PUBLIC marketplace. PRICING: Leave unlock_price unset to let the dynamic pricing engine calculate automatically (recommended). If setting manually: $0.05-$0.10 common techniques, $0.10-$1.00 specific solutions, $1.00-$10.00 novel discoveries, $10.00-$50.00 breakthroughs. Minimum $0.05, maximum $50.00. Free to submit — you earn 70% when others unlock. If the result is status pending_review, follow its how_to_review instructions (self-approval via `auxilo review`, the dashboard queue, or GET /account/pending).',
+      description: 'Submit TECHNICAL operational knowledge you discovered during this session to the Auxilo marketplace. WHEN TO USE: Call this AFTER you solve a non-trivial TECHNICAL problem that required debugging, experimentation, or combining information from multiple sources. Call it when you discover undocumented behavior, a workaround, or a subtle edge case. Do NOT call it for trivial lookups or standard documentation answers. SCOPE (hard rule — the server refuses out-of-scope submissions with CATEGORY_OUT_OF_SCOPE): technical learnings ONLY — APIs, developer tools, code, infrastructure, data pipelines, monitoring, payment/crypto technology, debugging. NEVER submit interpersonal/communication strategy, copywriting/content/marketing insights, business or negotiation strategy, personal matters, or creative-writing technique. A technical learning about a messaging/email/notification API belongs under web-interaction or code-execution; content/data pipeline tech belongs under data-processing. QUALITY GATE: Self-assess on Specificity, Actionability, Novelty, Completeness (1-5 each) and ALWAYS include your scores in quality_self_assessment — a submission WITHOUT it is held for manual review instead of publishing seamlessly. Only submit if total >= 14/20, no dimension below 3 (the server quarantines below-floor submissions for review). DEDUP: Search auxilo_knowledge first to avoid duplicates. SENSITIVITY (mandatory self-screen): never include secrets, credentials, API keys, PII, private filesystem paths, or proprietary/client business content — generalize to placeholders or omit; this is a PUBLIC Auxilo marketplace. PRICING: Leave unlock_price unset to let the dynamic pricing engine calculate automatically (recommended). If setting manually: $0.05-$0.10 common techniques, $0.10-$1.00 specific solutions, $1.00-$10.00 novel discoveries, $10.00-$50.00 breakthroughs. Minimum $0.05, maximum $50.00. Free to submit — you earn 70% when others unlock. If the result is status pending_review, follow its how_to_review instructions (self-approval via `auxilo review`, the dashboard queue, or GET /account/pending).',
       inputSchema: {
         type: 'object',
         properties: {
@@ -337,7 +337,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
     },
     {
       name: 'auxilo_rate',
-      description: 'Rate a learning 1-5 after using it. WHEN TO USE: After you unlock and apply knowledge from auxilo_unlock, always come back and rate it. Your rating helps other agents find the best knowledge and deprioritizes low-quality submissions. This is how the marketplace stays useful. Free. One rating slot per account per learning: re-rating REPLACES your prior score, it never counts twice (CH-6). REQUIRES: your API key (run `npx auxilo setup` if unset) and a prior unlock of this learning by your account — only verified purchasers can rate (LW-7).',
+      description: 'Rate a learning 1-5 after using it. WHEN TO USE: After you unlock and apply knowledge from auxilo_unlock, always come back and rate it. Your rating helps other agents find the best knowledge and deprioritizes low-quality submissions. This is how the Auxilo marketplace stays useful. Free. One rating slot per account per learning: re-rating REPLACES your prior score, it never counts twice (CH-6). REQUIRES: your API key (run `npx auxilo setup` if unset) and a prior unlock of this learning by your account — only verified purchasers can rate (LW-7).',
       inputSchema: {
         type: 'object',
         properties: {
@@ -432,7 +432,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
     },
     {
       name: 'auxilo_review',
-      description: 'Review YOUR OWN pending-review learnings (from background extraction) so they can be approved to the public marketplace, rejected, or kept private. Account-scoped: only the authenticated account\'s own pending items are ever visible or affected. ACTIONS: "list" returns the triage summary (counts incl. by_signal + compact rows with quality score, lane, a one-sentence why for flagged items, and platform screen verdicts: injection, content sensitivity, near-duplicate). "approve" / "reject" apply explicit decisions to the ids you pass (the operator must have named or confirmed these items). "keep_private" finalizes one id or the selected lane (needs_your_eyes by default): it stays yours; owner-only recall at $0; never published. Bulk keep_private is DRY-RUN BY DEFAULT and uses the same selection helper as the CLI. "approve_clean" selects every item that passed ALL platform screens AND has quality >= min_quality (default 14/20); it is DRY-RUN BY DEFAULT and returns exactly what WOULD be approved. "reject_by_signal" bulk-rejects every pending item carrying one flag signal (e.g. social_handle) — REJECT ONLY (items stay private; there is deliberately no bulk approve by class): the operator must confirm the signal AND its by_signal count from "list", and you pass that count as expected_count — the server refuses if the live selection differs. "sanitize" resubmits ONE operator-corrected item through EVERY screen with lineage (the original is retired to private, reason sanitize-resubmit; the replacement is ALWAYS held for the operator\'s explicit approval — never auto-published): only call it with a correction the operator reviewed. CONSENT CONTRACT: nothing goes public without the contributor\'s explicit approval. Before executing approve_clean or bulk keep_private, show the operator the dry-run list and count, then call again with dry_run:false, confirm:true, and expected_count set to the dry-run count. The server also enforces a counted-confirmation gate on every bulk call. Requires your configured API key (or session_token).',
+      description: 'Review YOUR OWN pending-review learnings (from background extraction) so they can be approved to the public Auxilo marketplace, rejected, or kept private. Account-scoped: only the authenticated account\'s own pending items are ever visible or affected. ACTIONS: "list" returns the triage summary (counts incl. by_signal + compact rows with quality score, lane, a one-sentence why for flagged items, and platform screen verdicts: injection, content sensitivity, near-duplicate). "approve" / "reject" apply explicit decisions to the ids you pass (the operator must have named or confirmed these items). "keep_private" finalizes one id or the selected lane (needs_your_eyes by default): it stays yours; owner-only recall at $0; never published. Bulk keep_private is DRY-RUN BY DEFAULT and uses the same selection helper as the CLI. "approve_clean" selects every item that passed ALL platform screens AND has quality >= min_quality (default 14/20); it is DRY-RUN BY DEFAULT and returns exactly what WOULD be approved. "reject_by_signal" bulk-rejects every pending item carrying one flag signal (e.g. social_handle) — REJECT ONLY (items stay private; there is deliberately no bulk approve by class): the operator must confirm the signal AND its by_signal count from "list", and you pass that count as expected_count — the server refuses if the live selection differs. "sanitize" resubmits ONE operator-corrected item through EVERY screen with lineage (the original is retired to private, reason sanitize-resubmit; the replacement is ALWAYS held for the operator\'s explicit approval — never auto-published): only call it with a correction the operator reviewed. CONSENT CONTRACT: nothing goes public without the contributor\'s explicit approval. Before executing approve_clean or bulk keep_private, show the operator the dry-run list and count, then call again with dry_run:false, confirm:true, and expected_count set to the dry-run count. The server also enforces a counted-confirmation gate on every bulk call. Requires your configured API key (or session_token).',
       inputSchema: {
         type: 'object',
         properties: {
@@ -456,7 +456,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
     },
     {
       name: 'get_knowledge_stats',
-      description: 'Get knowledge marketplace statistics — total learnings, unlocks, contributors, and top categories. Free.',
+      description: 'Get Auxilo knowledge statistics — total learnings, unlocks, contributors, and top categories. Free.',
       inputSchema: { type: 'object', properties: {} },
     },
   ],
@@ -794,7 +794,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             min_quality: plan.min_quality,
             submitted: decisions.length,
             ...totals,
-            note: 'Approved items are now PUBLIC on the marketplace. Screen-flagged and below-threshold items remain pending for individual review.',
+            note: 'Approved items are now PUBLIC on the Auxilo marketplace. Screen-flagged and below-threshold items remain pending for individual review.',
           });
         }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auxilo-mcp",
-  "version": "0.9.11",
+  "version": "0.9.13",
   "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",
@@ -25,6 +25,7 @@
     "scripts/extract-local.js",
     "scripts/review-notice.js",
     "scripts/sources/",
+    "scripts/providers/",
     "scripts/hooks/auxilo-extract.sh",
     "README.md",
     "LICENSE"