auxilo-mcp 0.9.2 → 0.9.3

package/lib/installer.js

@@ -36,6 +36,24 @@ const DEFAULT_BASE_URL = 'https://auxilo.io';
 /** Root of the installed npm package (or the repo, when run from a clone). */
 const PACKAGE_ROOT = path.resolve(__dirname, '..');
 
+/**
+ * Source-adapter rows for the runner stack, DERIVED by enumerating
+ * scripts/sources/*.js (UC-3): a new adapter file is automatically shipped —
+ * the d8c7099 bug class (adapter added, manifest not) is structurally
+ * impossible for the sources dir. Mirrored by runner.js sweeperManifest();
+ * the manifest-closure test asserts both stay complete.
+ */
+function sourceAdapterRows(packageRoot = PACKAGE_ROOT) {
+  try {
+    return fs.readdirSync(path.join(packageRoot, 'scripts', 'sources'))
+      .filter((f) => f.endsWith('.js'))
+      .sort()
+      .map((f) => [`scripts/sources/${f}`, `scripts/sources/${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
@@ -51,12 +69,9 @@ 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],
-  ['scripts/sources/source.interface.js', 'scripts/sources/source.interface.js', 0o644],
-  ['scripts/sources/claude-code.js', 'scripts/sources/claude-code.js', 0o644],
-  ['scripts/sources/openclaw.js', 'scripts/sources/openclaw.js', 0o644],
-  ['scripts/sources/gemini-cli.js', 'scripts/sources/gemini-cli.js', 0o644],
-  ['scripts/sources/antigravity.js', 'scripts/sources/antigravity.js', 0o644],
-  ['scripts/sources/generic-jsonl.js', 'scripts/sources/generic-jsonl.js', 0o644],
+  // LW-18 layer 1b: SessionStart held-count notice (shim target).
+  ['scripts/review-notice.js', 'scripts/review-notice.js', 0o755],
+  ...sourceAdapterRows(),
   ['lib/sensitivity-filter.js', 'lib/sensitivity-filter.js', 0o644],
 ]);
 
@@ -89,6 +104,21 @@ const RUNNER_STACK = Object.freeze([
  * @param {object} [opts.env=process.env]            For %APPDATA% on win32.
  * @returns {Array<object>} registry entries (detected or not)
  */
+/**
+ * VS Code-family globalStorage dirs for an extension publisher id, per
+ * platform (UC-3 poll-source detection: Cline / Roo Code). Any-of probing —
+ * Code, Code - Insiders, VSCodium.
+ */
+function vscodeGlobalStorageDirs(homeDir, platform, env, publisherDirs) {
+  const apps = ['Code', 'Code - Insiders', 'VSCodium'];
+  const userDirs = platform === 'darwin'
+    ? apps.map((a) => path.join(homeDir, 'Library', 'Application Support', a, 'User'))
+    : platform === 'win32'
+      ? apps.map((a) => path.join(env.APPDATA || path.join(homeDir, 'AppData', 'Roaming'), a, 'User'))
+      : apps.map((a) => path.join(homeDir, '.config', a, 'User'));
+  return userDirs.flatMap((u) => publisherDirs.map((p) => path.join(u, 'globalStorage', p)));
+}
+
 function clientRegistry(homeDir, opts = {}) {
   if (!homeDir) throw new Error('clientRegistry: homeDir is required');
   const platform = opts.platform || process.platform;
@@ -138,6 +168,24 @@ function clientRegistry(homeDir, opts = {}) {
       mcp: false,
       hooks: false,
     },
+    // ── UC-3 poll-based sources (no MCP config; sweeper adapters) ───────────
+    {
+      id: 'cline',
+      name: 'Cline (VS Code)',
+      detectDirs: vscodeGlobalStorageDirs(homeDir, platform, env, ['saoudrizwan.claude-dev']),
+      configPath: null, // poll-based source adapter (scripts/sources/cline.js)
+      mcp: false,
+      hooks: false,
+    },
+    {
+      id: 'roo-code',
+      name: 'Roo Code (VS Code)',
+      detectDirs: vscodeGlobalStorageDirs(homeDir, platform, env,
+        ['rooveterinaryinc.roo-cline', 'rooveterinaryinc.roo-code']),
+      configPath: null, // poll-based source adapter (scripts/sources/roo-code.js)
+      mcp: false,
+      hooks: false,
+    },
     // ── UC-0 additions (config paths web-verified June 2026, BUILD-SPEC-UNIVERSAL-CLIENTS §5) ──
     {
       id: 'windsurf',
@@ -544,11 +592,19 @@ function writeCredentials(homeDir, creds) {
  *
  * @param {object} opts
  * @param {string}   [opts.baseUrl=DEFAULT_BASE_URL]
+ * @param {string}   [opts.scope]               Wave 3.4 (D2/NF-3): requested key scope
+ *                                              (read | earnings-read | contribute). Omitted →
+ *                                              no request body at all (exact pre-3.4 wire
+ *                                              shape; server mints 'contribute').
+ * @param {string}   [opts.label]               Wave 3.4: requested key label (`auxilo init`).
  * @param {Function} [opts.fetchImpl=fetch]    Injectable for tests.
  * @param {Function} [opts.onCode]             (userCode, verificationUrl) → void; print/open browser.
  * @param {Function} [opts.sleep]              (ms) → Promise; injectable for tests.
  * @param {number}   [opts.maxWaitMs=600000]   10 min TTL (server DEVICE_CODE_TTL).
- * @returns {Promise<{ api_key: string, account_id: string, email: string, base_url: string }>}
+ * @returns {Promise<{ api_key: string, account_id: string, email: string, base_url: string,
+ *                     scope?: string, label?: string }>}
+ *   scope/label are the server's echo of what was ACTUALLY minted (absent on
+ *   pre-Wave-3.4 servers — callers requesting a scope should compare and warn).
  * @throws Error on expired code, HTTP failure, or timeout.
  */
 async function deviceLogin(opts = {}) {
@@ -557,10 +613,17 @@ async function deviceLogin(opts = {}) {
   const sleep = opts.sleep || ((ms) => new Promise((r) => setTimeout(r, ms)));
   const maxWaitMs = opts.maxWaitMs !== undefined ? opts.maxWaitMs : 600000;
 
-  const res = await fetchImpl(`${baseUrl}/auth/device`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-  });
+  // Wave 3.4: send a body ONLY when a scope/label was requested — an omitted
+  // body keeps the exact pre-3.4 request shape (and old servers ignore the
+  // body entirely, minting the historical contribute-scoped Device Login Key).
+  const init = { method: 'POST', headers: { 'Content-Type': 'application/json' } };
+  if (opts.scope !== undefined || opts.label !== undefined) {
+    const body = {};
+    if (opts.scope !== undefined) body.scope = opts.scope;
+    if (opts.label !== undefined) body.label = opts.label;
+    init.body = JSON.stringify(body);
+  }
+  const res = await fetchImpl(`${baseUrl}/auth/device`, init);
   if (!res.ok) throw new Error(`Device code request failed (HTTP ${res.status})`);
   const device = await res.json();
   // A-1: device_code is the secret polling credential; user_code is the human
@@ -590,6 +653,10 @@ async function deviceLogin(opts = {}) {
         account_id: status.account_id,
         email: status.email,
         base_url: baseUrl,
+        // Wave 3.4: server echo of the minted scope/label (undefined on
+        // pre-3.4 servers — callers compare against the request and warn).
+        scope: status.scope,
+        label: status.label,
       };
     }
     if (status.status === 'expired') {
@@ -600,6 +667,50 @@ async function deviceLogin(opts = {}) {
   throw new Error('Timed out waiting for device authorization (10 minutes).');
 }
 
+// ─── Env-file writer (Wave 3.4 / NF-3 `auxilo init --env-file`) ─────────────
+
+/**
+ * Write (or update in place) an env file with the minted key. Idempotent:
+ * existing AUXILO_API_KEY / AUXILO_BASE_URL lines are REPLACED, never
+ * duplicated; every other line is preserved byte-for-byte. New files are
+ * created 0600; existing files are chmod'd 0600 before the secret lands
+ * (same tmp(0600)+rename discipline as writeCredentials).
+ *
+ * @param {string} filePath  Absolute or cwd-relative env file path.
+ * @param {{ api_key: string, base_url?: string }} values
+ * @returns {{ path: string, created: boolean }}
+ */
+function writeEnvFile(filePath, values) {
+  if (!filePath) throw new Error('writeEnvFile: filePath is required');
+  if (!values || !values.api_key) throw new Error('writeEnvFile: values.api_key is required');
+
+  const existed = fs.existsSync(filePath);
+  let lines = [];
+  if (existed) {
+    fs.chmodSync(filePath, 0o600);
+    lines = fs.readFileSync(filePath, 'utf-8').split('\n');
+    // Drop a single trailing empty line so we can re-append cleanly.
+    if (lines.length && lines[lines.length - 1] === '') lines.pop();
+  }
+
+  const upsert = (name, value) => {
+    const rendered = `${name}=${value}`;
+    const idx = lines.findIndex((l) => l.startsWith(`${name}=`) || l.startsWith(`export ${name}=`));
+    if (idx === -1) lines.push(rendered);
+    else lines[idx] = lines[idx].startsWith('export ') ? `export ${rendered}` : rendered;
+  };
+  upsert('AUXILO_API_KEY', values.api_key);
+  if (values.base_url) upsert('AUXILO_BASE_URL', values.base_url);
+
+  const dir = path.dirname(filePath);
+  if (dir && dir !== '.') fs.mkdirSync(dir, { recursive: true });
+  const tmp = `${filePath}.tmp`;
+  fs.writeFileSync(tmp, lines.join('\n') + '\n', { mode: 0o600 });
+  fs.renameSync(tmp, filePath);
+  fs.chmodSync(filePath, 0o600);
+  return { path: filePath, created: !existed };
+}
+
 // ─── Runner install (spec §LW-12 step 3; layout per P1-13) ──────────────────
 
 function binRootFor(homeDir) {
@@ -782,6 +893,52 @@ function registerClaudeCodeHook(homeDir) {
   return { changed: true, hookCmd, removedLegacy: removedLegacy.filter((c) => c !== hookCmd) };
 }
 
+/**
+ * UC-1a: remove every Auxilo extraction entry from Claude Code's SessionEnd
+ * hooks — bare-string legacy entries AND structured command entries, while
+ * preserving non-Auxilo commands sharing a matcher group. Used by the setup
+ * consent=No path so no capture artifact remains (including ones left by
+ * earlier installs that wrote hooks pre-consent).
+ *
+ * Idempotent; missing settings file is a no-op; malformed JSON throws (B15).
+ *
+ * @returns {{ changed: boolean, removed: string[] }}
+ */
+function removeClaudeCodeHook(homeDir) {
+  if (!homeDir) throw new Error('removeClaudeCodeHook: homeDir is required');
+  const settingsPath = path.join(homeDir, '.claude', 'settings.json');
+  if (!fs.existsSync(settingsPath)) return { changed: false, removed: [] };
+
+  const settings = readClientConfig(settingsPath);
+  if (!settings.hooks || !Array.isArray(settings.hooks.SessionEnd)) {
+    return { changed: false, removed: [] };
+  }
+
+  const removed = [];
+  const kept = [];
+  for (const entry of settings.hooks.SessionEnd) {
+    if (typeof entry === 'string' && entry.includes('auxilo-extract')) {
+      removed.push(entry);
+      continue;
+    }
+    if (entry && typeof entry === 'object' && Array.isArray(entry.hooks)) {
+      const auxilo = entry.hooks.filter(isAuxiloCommandHook);
+      if (auxilo.length > 0) {
+        removed.push(...auxilo.map((h) => h.command));
+        const rest = entry.hooks.filter((h) => !isAuxiloCommandHook(h));
+        if (rest.length > 0) kept.push({ ...entry, hooks: rest });
+        continue;
+      }
+    }
+    kept.push(entry);
+  }
+
+  if (removed.length === 0) return { changed: false, removed: [] };
+  settings.hooks.SessionEnd = kept;
+  writeJsonAtomic(settingsPath, settings);
+  return { changed: true, removed };
+}
+
 // ─── UC-1 capture-hook registration ─────────────────────────────────────────
 //
 // Per-client session-end hooks that pipe the client's hook JSON into the
@@ -800,6 +957,16 @@ function captureShimPath(homeDir, sourceId) {
   return path.join(binRootFor(homeDir), `auxilo-capture-${sourceId}.sh`);
 }
 
+/**
+ * Shell-quote a literal for generated bash: single-quoted, embedded single
+ * quotes escaped as '\''. UC-1a L2: paths were previously interpolated inside
+ * double quotes, so a homeDir containing `"`, `$`, or backticks broke (or
+ * worse, executed inside) the generated script.
+ */
+function shellQuote(s) {
+  return `'${String(s).replace(/'/g, `'\\''`)}'`;
+}
+
 /**
  * Generate the capture shim body. stdin (the client's hook JSON) passes
  * straight through `exec` to capture-core.js; the PATH export covers GUI-
@@ -810,7 +977,7 @@ function renderCaptureShim(homeDir, sourceId) {
   return `#!/bin/bash
 # Auxilo capture shim (${sourceId}) — generated by \`auxilo setup\` (UC-1).
 export PATH="/opt/homebrew/bin:/usr/local/bin:$PATH"
-exec /usr/bin/env node "${corePath}" --source ${sourceId}
+exec /usr/bin/env node ${shellQuote(corePath)} --source ${shellQuote(sourceId)}
 `;
 }
 
@@ -1073,6 +1240,208 @@ function installCaptureHooks(homeDir, clients, opts = {}) {
   return results;
 }
 
+// ─── UC-1a capture-hook removal (consent=No cleanup) ────────────────────────
+//
+// Setup previously wrote capture hooks into third-party client configs BEFORE
+// the consent prompt (boundary smell + uninstall surprise — GOV-3 L1). The
+// fix is two-sided: bin/auxilo-cli.js now writes hooks only AFTER consent=yes,
+// and the No path calls these removers so no hook artifact remains — including
+// artifacts left by earlier installs that wrote pre-consent.
+
+/** Strip every auxilo-capture entry from a flat hook array; drop empty result. */
+function stripFlatHookArray(arr) {
+  if (!Array.isArray(arr)) return arr;
+  return arr.filter((e) => !(e && typeof e === 'object' && isAuxiloCaptureCommand(e.command)));
+}
+
+/** Strip auxilo-capture inner hooks from matcher groups; drop groups left empty. */
+function stripGroupHookArray(arr) {
+  if (!Array.isArray(arr)) return arr;
+  const kept = [];
+  for (const group of arr) {
+    if (group && typeof group === 'object' && Array.isArray(group.hooks)) {
+      const rest = group.hooks.filter((h) => !(h && isAuxiloCaptureCommand(h.command)));
+      if (rest.length === 0 && group.hooks.length > 0) continue; // group was all ours
+      kept.push(rest.length === group.hooks.length ? group : { ...group, hooks: rest });
+      continue;
+    }
+    kept.push(group);
+  }
+  return kept;
+}
+
+/**
+ * Remove the UC-1 capture hook for one client: strip the config entry (per
+ * the client's dialect) and delete the per-source shim. Idempotent — absent
+ * artifacts report changed:false. Malformed config JSON throws (B15 — caller
+ * skips loudly).
+ *
+ * @returns {{ changed: boolean, hookPath: string, configPath: string }}
+ */
+function removeCaptureHook(client, homeDir) {
+  if (!homeDir) throw new Error('removeCaptureHook: homeDir is required');
+  if (!client || !client.captureHook || !client.captureConfigPath) {
+    throw new Error(`removeCaptureHook: client ${client && client.id} has no capture-hook support`);
+  }
+  const sourceId = client.sourceId || client.id;
+  const shimPath = captureShimPath(homeDir, sourceId);
+  let changed = false;
+
+  if (fs.existsSync(client.captureConfigPath)) {
+    if (client.id === 'copilot-cli') {
+      // Drop-in file we own entirely — delete it.
+      fs.unlinkSync(client.captureConfigPath);
+      changed = true;
+    } else {
+      changed = patchJsonHookConfig(client.captureConfigPath, (config) => {
+        if (client.id === 'antigravity') {
+          delete config['auxilo-capture']; // we own only this top-level key
+          return;
+        }
+        if (!config.hooks || typeof config.hooks !== 'object') return;
+        for (const event of Object.keys(config.hooks)) {
+          const arr = config.hooks[event];
+          if (!Array.isArray(arr)) continue;
+          const flat = stripFlatHookArray(arr);
+          config.hooks[event] = stripGroupHookArray(flat);
+        }
+      });
+    }
+  }
+
+  if (fs.existsSync(shimPath)) {
+    fs.unlinkSync(shimPath);
+    changed = true;
+  }
+
+  return { changed, hookPath: shimPath, configPath: client.captureConfigPath };
+}
+
+/**
+ * Remove capture hooks for every captureHook-capable client in `clients`.
+ * Per-client try/catch (B15 skip-loudly), mirroring installCaptureHooks.
+ *
+ * @returns {Array<{ id, name, changed?, hookPath?, configPath?, error? }>}
+ */
+function removeCaptureHooks(homeDir, clients) {
+  if (!homeDir) throw new Error('removeCaptureHooks: homeDir is required');
+  const results = [];
+  for (const client of (clients || []).filter((c) => c && c.captureHook)) {
+    try {
+      results.push({ id: client.id, name: client.name, ...removeCaptureHook(client, homeDir) });
+    } catch (err) {
+      results.push({ id: client.id, name: client.name, error: err.message });
+    }
+  }
+  return results;
+}
+
+// ─── SessionStart held-count notice (LW-18 layer 1b) ────────────────────────
+//
+// A structured Claude Code SessionStart hook that runs
+// scripts/review-notice.js (count-only, fail-silent, ≤1 notice per 4h — the
+// script owns all of that; see its header for the threat-model contract).
+// NOT a capture hook: it reads the account's pending count from the server
+// and never touches transcripts, so it installs at setup step 4 independent
+// of extraction consent (the review queue also holds MCP contributions).
+
+/** Absolute path of the SessionStart notice shim. */
+function noticeShimPath(homeDir) {
+  return path.join(binRootFor(homeDir), 'auxilo-review-notice.sh');
+}
+
+/** Marker every notice entry carries (registration + removal + status probe). */
+function isAuxiloNoticeCommand(cmd) {
+  return typeof cmd === 'string' && cmd.includes('auxilo-review-notice');
+}
+
+/** Generate the notice shim body (fail-silent: always exits 0). */
+function renderNoticeShim(homeDir) {
+  const noticePath = path.join(binRootFor(homeDir), 'scripts', 'review-notice.js');
+  return `#!/bin/bash
+# Auxilo SessionStart review notice — generated by \`auxilo setup\` (LW-18).
+# Count-only pending-review notice; fail-silent (never blocks session start).
+export PATH="/opt/homebrew/bin:/usr/local/bin:$PATH"
+/usr/bin/env node ${shellQuote(noticePath)} 2>/dev/null
+exit 0
+`;
+}
+
+/**
+ * Register the SessionStart notice: write the shim (0755) and patch
+ * <home>/.claude/settings.json hooks.SessionStart[] to contain exactly one
+ * STRUCTURED Auxilo entry ({hooks:[{type:'command',command}]}) — bare-string
+ * entries are silently ignored by Claude Code (the LW-17 0.8.1 lesson).
+ * Idempotent; stale auxilo-review-notice references replaced; non-Auxilo
+ * SessionStart hooks preserved; malformed settings throws (B15).
+ *
+ * @returns {{ changed: boolean, hookCmd: string }}
+ */
+function registerClaudeCodeSessionStartNotice(homeDir) {
+  if (!homeDir) throw new Error('registerClaudeCodeSessionStartNotice: homeDir is required');
+  const settingsPath = path.join(homeDir, '.claude', 'settings.json');
+  const hookCmd = noticeShimPath(homeDir);
+
+  // Shim first (its own idempotency: rewritten only when stale).
+  const body = renderNoticeShim(homeDir);
+  let shimChanged = false;
+  if (!fs.existsSync(hookCmd) || fs.readFileSync(hookCmd, 'utf-8') !== body) {
+    fs.mkdirSync(path.dirname(hookCmd), { recursive: true });
+    fs.writeFileSync(hookCmd, body);
+    fs.chmodSync(hookCmd, 0o755);
+    shimChanged = true;
+  }
+
+  const settings = readClientConfig(settingsPath);
+  if (!settings.hooks) settings.hooks = {};
+  if (!Array.isArray(settings.hooks.SessionStart)) settings.hooks.SessionStart = [];
+
+  const kept = [];
+  let alreadyExact = false;
+  for (const entry of settings.hooks.SessionStart) {
+    if (typeof entry === 'string' && isAuxiloNoticeCommand(entry)) continue; // dead bare-string form
+    if (entry && typeof entry === 'object' && Array.isArray(entry.hooks)) {
+      const ours = entry.hooks.filter((h) => h && isAuxiloNoticeCommand(h.command));
+      if (ours.length > 0) {
+        if (entry.hooks.length === 1 && ours[0].command === hookCmd && ours[0].type === 'command') {
+          alreadyExact = true;
+        }
+        const rest = entry.hooks.filter((h) => !(h && isAuxiloNoticeCommand(h.command)));
+        if (rest.length > 0) kept.push({ ...entry, hooks: rest });
+        continue;
+      }
+    }
+    kept.push(entry);
+  }
+
+  if (alreadyExact && kept.length === settings.hooks.SessionStart.length - 1) {
+    return { changed: shimChanged, hookCmd };
+  }
+
+  settings.hooks.SessionStart = [...kept, { hooks: [{ type: 'command', command: hookCmd }] }];
+  writeJsonAtomic(settingsPath, settings);
+  return { changed: true, hookCmd };
+}
+
+/**
+ * Read-only probe for `auxilo status`: notice counts as registered when the
+ * shim exists AND a STRUCTURED SessionStart entry references it. Never throws.
+ */
+function sessionStartNoticeRegistered(homeDir) {
+  try {
+    if (!fs.existsSync(noticeShimPath(homeDir))) return false;
+    const settings = JSON.parse(
+      fs.readFileSync(path.join(homeDir, '.claude', 'settings.json'), 'utf-8')
+    );
+    return Array.isArray(settings.hooks && settings.hooks.SessionStart) &&
+      settings.hooks.SessionStart.some((e) =>
+        e && typeof e === 'object' && Array.isArray(e.hooks) &&
+        e.hooks.some((h) => h && isAuxiloNoticeCommand(h.command)));
+  } catch {
+    return false;
+  }
+}
+
 // ─── Consent (spec §LW-12 step 5; server.js POST /extract/consent) ──────────
 
 /**
@@ -1222,6 +1591,8 @@ async function getStatus(homeDir, opts = {}) {
     runnerInstalled,
     hookInstalled: fs.existsSync(hookPath),
     hookRegistered,
+    // LW-18 layer 1b: SessionStart held-count notice
+    noticeRegistered: sessionStartNoticeRegistered(homeDir),
     lastSweep,
     pendingCount,
   };
@@ -1315,17 +1686,26 @@ module.exports = {
   credentialsPath,
   readCredentials,
   writeCredentials,
+  writeEnvFile,
   deviceLogin,
   binRootFor,
   hookScriptPathFor,
   renderHookScript,
   installRunner,
   registerClaudeCodeHook,
+  removeClaudeCodeHook,
   captureShimPath,
   renderCaptureShim,
+  shellQuote,
   registerCaptureHook,
   captureHookRegistered,
   installCaptureHooks,
+  removeCaptureHook,
+  removeCaptureHooks,
+  noticeShimPath,
+  renderNoticeShim,
+  registerClaudeCodeSessionStartNotice,
+  sessionStartNoticeRegistered,
   recordConsent,
   sentinelPath,
   sentinelPresent,

package/mcp-server.js

@@ -160,7 +160,7 @@ async function postBulkChunks(headers, decisions) {
 }
 
 const server = new Server(
-  { name: 'auxilo', version: '0.9.2' },
+  { name: 'auxilo', version: '0.9.3' },
   {
     capabilities: { tools: {} },
     instructions: `You are connected to Auxilo, a knowledge marketplace where AI agents buy and sell operational learnings.
@@ -295,7 +295,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.',
+      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. 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: {
@@ -736,12 +736,12 @@ if (require.main !== module) {
   return;
 }
 
-// ─── CLI delegation (LW-17) ────────────────────────────────────────────────────
-// `npx auxilo-mcp setup|status|review|disable` runs the full turnkey CLI.
+// ─── CLI delegation (LW-17; init added Wave 3.4/NF-3) ─────────────────────────
+// `npx auxilo-mcp setup|init|status|review|disable` runs the full turnkey CLI.
 // npx resolves PACKAGE names, not bin aliases — the documented `npx auxilo
 // setup` 404s until the `auxilo` npm package name is claimed, so the package
 // bin must handle these commands itself.
-if (['setup', 'status', 'review', 'disable'].includes(process.argv[2])) {
+if (['setup', 'init', 'status', 'review', 'disable'].includes(process.argv[2])) {
   require('./bin/auxilo-cli.js').run();
   return; // module-level return in CommonJS stops the MCP server from starting
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auxilo-mcp",
-  "version": "0.9.2",
+  "version": "0.9.3",
   "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",
@@ -17,6 +17,7 @@
     "scripts/runner.js",
     "scripts/capture-core.js",
     "scripts/extract-local.js",
+    "scripts/review-notice.js",
     "scripts/sources/",
     "scripts/hooks/auxilo-extract.sh",
     "README.md",
@@ -49,6 +50,8 @@
   "homepage": "https://auxilo.io",
   "license": "MIT",
   "dependencies": {
+    "@aws-sdk/client-s3": "^3.1090.0",
+    "@aws-sdk/lib-storage": "^3.1090.0",
     "@modelcontextprotocol/sdk": "^1.0.0",
     "stripe": "^17.0.0",
     "viem": "^2.46.3"
@@ -56,4 +59,4 @@
   "devDependencies": {
     "proxyquire": "^2.1.3"
   }
-}
+}