auxilo-mcp 0.9.10 → 0.9.12

package/bin/auxilo-cli.js

@@ -493,6 +493,10 @@ async function cmdStatus() {
   console.log(`Account mode: ${s.accountMode}`);
   console.log(`Kill-switch sentinel: ${s.sentinel ? 'present (extraction enabled)' : 'absent (extraction disabled)'}`);
   console.log(`Runner installed: ${s.runnerInstalled ? 'yes (~/.auxilo/bin)' : 'no'}`);
+  if (s.runnerInstalled) {
+    const line = runnerSkewLine(installer.runnerVersionSkew(HOME));
+    if (line) console.log(line);
+  }
   console.log(`SessionEnd hook: ${s.hookInstalled ? 'installed' : 'not installed'}${s.hookRegistered ? ', registered in Claude Code settings' : ''}`);
   for (const c of s.clients.filter((c) => c.captureHook)) {
     console.log(`Capture hooks: ${c.name} (${c.captureEvent}, ${c.captureRegistered ? 'registered' : 'not registered'})`);
@@ -501,6 +505,17 @@ async function cmdStatus() {
   console.log(`Pending upload queue: ${s.pendingCount} file(s)\n`);
 }
 
+/**
+ * CLEAN-LANE-FLIP Phase B: ONE line when ~/.auxilo/bin/VERSION is missing or
+ * differs from this CLI's package version; null when the stack is current.
+ * `setup` is idempotent and re-copies the stack, so that is the remedy.
+ */
+function runnerSkewLine(skew) {
+  if (!skew || !skew.skew) return null;
+  const installed = skew.installed ? `v${skew.installed}` : 'unstamped (pre-0.9.12)';
+  return `  ⚠ Installed runner is ${installed} (package v${skew.package}) — run: npx auxilo setup`;
+}
+
 // ─── auxilo disable ─────────────────────────────────────────────────────────
 
 async function cmdDisable(flags) {
@@ -860,6 +875,238 @@ async function cmdReview(flags) {
   console.log(`\nReview complete: approved ${approved}, kept private ${keptPrivate}, rejected ${rejected}, skipped ${skipped} of ${ordered.length}.`);
 }
 
+// ─── auxilo clean-lane (SPEC3-C1 standing consent; CLEAN-LANE-FLIP Phase A) ──
+//
+// GOV-3 (ratified language, Gate-A 2026-09-05): `grant` runs ONLY on a TTY and
+// requires the human to TYPE the affirmation sentence verbatim — no --yes, no
+// flag. The TTY gate + verbatim affirmation prevent ACCIDENTAL enrollment and
+// create a hash-chained record of a DELIBERATE act by the credential holder.
+// That record is EVIDENTIARY, not preventive: it is not a defense against a
+// holder of the account's contribute-scoped key, who can reach the same routes
+// directly. `status` / `revoke` are non-interactive.
+// While the server flag is off the routes answer the catch-all 404 and every
+// subcommand prints "not yet available" (exit 0).
+//
+// The sentence below MIRRORS lib/clean-lane.js CLEAN_LANE_AFFIRMATION. It is
+// a literal here only because lib/clean-lane.js is server-side and not in the
+// published package's files[]; test/clean-lane-phase-a.test.js pins the two
+// byte-equal. The consent VERSION is never a client literal — it always comes
+// from GET /account/clean-lane (consent_version_current).
+const CLEAN_LANE_AFFIRMATION = 'I understand and choose auto-publish for qualifying extracted learnings.';
+const CLEAN_LANE_UNAVAILABLE = 'Auto-publish for clean learnings is not yet available on this account.';
+// CLEAN-LANE-FLIP Phase B (legal; DRAFT pending Tyler): the full text of ToS
+// §5.9.3(g) (plus its ratchet paragraph) prints ABOVE the affirmation prompt —
+// counsel condition: the enrollment surface must show what "qualifying",
+// revocation and the 7-day retraction mean, on both the dashboard and CLI
+// paths. Same package-boundary reason as the affirmation: these literals are
+// pinned byte-equal to docs/TERMS-OF-SERVICE.md and public/dashboard.html by
+// test/clean-lane-phase-b-legal.test.js. Edit the Terms first, then mirror.
+const CLEAN_LANE_TERMS_G = '(g) Standing publication consent (optional). Standing publication consent is off by default. A Builder may turn it on by an affirmative act — a dashboard setting, or a terminal command that requires typing the affirmation sentence shown on that screen. Auxilo records that act, the affirmation, and the consent-text version in a durable, hash-chained consent log, retained for the life of the account plus three (3) years under subsection (b). While it is on, a Learning submitted through Autonomous Extraction is published without separate per-item approval only if it passes every Platform screen and the quality threshold the Builder chose at activation. An account\'s first public Learning is never published this way; it is held for operator review under Section 4.1. Auxilo records each such publication in the Builder\'s dashboard and returns a notice in the response to the submission that produced it; each is retractable for seven (7) days under Section 5.9.4. If more than five percent (5%) of a Builder\'s Learnings published this way in any thirty (30) day period are retracted, Auxilo freezes the feature for that account until the Builder turns it on again. A Builder may turn it off at any time, effective immediately for later submissions; doing so does not affect Learnings already published. Subsection (c) applies in full to every Learning so published.';
+const CLEAN_LANE_TERMS_G2 = 'The quality threshold in effect for a Builder is the one that Builder selected, and Auxilo will not broaden the conditions under which a Learning qualifies for publication under this subsection without recording a new consent; Auxilo may make those conditions stricter at any time.';
+// CLEAN-LANE-FLIP Phase B (notice hardening): the no-email enrollment line —
+// GOV-2 counsel draft §6 read #2 "move 3" — printed verbatim before the
+// affirmation prompt on every enrollment surface. Byte-equal to the dashboard's
+// #clean-lane-no-email-line (test/clean-lane-phase-b-notice.test.js).
+const CLEAN_LANE_NO_EMAIL_LINE = 'You will not receive an email for these. Publications appear in your dashboard and in the response to the session that submitted them. The 7-day retraction window runs from publication.';
+const CLEAN_LANE_MIN_QUALITY_MIN = 14;
+const CLEAN_LANE_MIN_QUALITY_MAX = 20;
+const CLEAN_LANE_MIN_QUALITY_DEFAULT = 16;
+
+const CLEAN_LANE_EXPLAINER = `
+Auto-publish clean learnings
+
+When this is on, a learning is published without waiting for your review
+only when all three hold: it was extracted by your own model, every server
+screen came back clean, and its quality score is at or above the threshold
+you set.
+
+What is never auto-published: your first public learning (it waits for
+operator review), anything a screen flags, anything below your threshold,
+and anything after an auto-freeze. Every auto-published learning can be
+retracted for 7 days (\`npx auxilo review\` or your dashboard).
+`;
+
+/** Word-wrap a single paragraph at `width` columns (whitespace only; no word is altered). */
+function wrapForTerminal(paragraph, width = 78) {
+  const lines = [];
+  let line = '';
+  for (const word of paragraph.split(' ')) {
+    if (line && (line.length + 1 + word.length) > width) { lines.push(line); line = word; }
+    else line = line ? `${line} ${word}` : word;
+  }
+  if (line) lines.push(line);
+  return lines.map((l) => `  ${l}`).join('\n');
+}
+
+async function cleanLaneRequest({ apiKey, baseUrl, method, route, body }) {
+  const url = `${String(baseUrl).replace(/\/+$/, '')}${route}`;
+  const headers = { 'X-API-Key': apiKey };
+  if (body !== undefined) headers['Content-Type'] = 'application/json';
+  const res = await fetch(url, {
+    method,
+    headers,
+    ...(body !== undefined && { body: JSON.stringify(body) }),
+  });
+  let data = {};
+  try { data = await res.json(); } catch { /* non-JSON body */ }
+  return { status: res.status, ok: res.ok, data: data || {} };
+}
+
+function printCleanLaneStatus(data) {
+  const active = data.clean_lane_active === true;
+  console.log(`Auto-publish clean learnings: ${active ? 'ON' : 'OFF'}`);
+  if (active) {
+    console.log(`  since:            ${data.last_action_at || 'unknown'}`);
+    console.log(`  quality at least: ${data.min_auto_publish_quality}`);
+    console.log(`  consent version:  ${data.consent_version_recorded || data.consent_version_current}`);
+  } else if (data.last_action === 'freeze') {
+    console.log(`  FROZEN: ${data.freeze_reason || 'unknown reason'} (${data.last_action_at || 'unknown time'})`);
+    console.log('  Nothing auto-publishes until you grant consent again: npx auxilo clean-lane grant');
+  } else if (data.last_action === 'revoke') {
+    console.log(`  revoked at: ${data.last_action_at || 'unknown'}`);
+  } else if (data.last_action === 'grant') {
+    console.log(`  a grant exists under consent version ${data.consent_version_recorded} but the current version is ${data.consent_version_current}; re-grant to re-activate.`);
+  }
+  console.log(`  current consent version: ${data.consent_version_current}`);
+  // CLEAN-LANE-FLIP Phase B (notice hardening): the unread count, printed only
+  // when > 0. Nothing here acknowledges it — only the dashboard button does.
+  const unread = data.unacknowledged_publications;
+  if (Number.isInteger(unread) && unread > 0) {
+    console.log(`  auto-published since you last checked: ${unread} (review and acknowledge them in your dashboard)`);
+  }
+}
+
+async function cmdCleanLane(flags) {
+  const sub = process.argv[3];
+  if (!['status', 'grant', 'revoke'].includes(sub)) {
+    if (sub) console.error(`Unknown clean-lane subcommand: ${sub}`);
+    usage('clean-lane');
+    process.exit(sub ? 1 : 0);
+  }
+
+  // The TTY gate runs BEFORE credentials and BEFORE any network call: a
+  // piped or scripted stdin can never reach the grant.
+  if (sub === 'grant' && !process.stdin.isTTY) {
+    console.error('auxilo clean-lane grant must be run by a person in an interactive terminal. It does not accept piped input, and there is no flag that skips typing the consent sentence.');
+    process.exit(1);
+  }
+
+  const creds = installer.readCredentials(HOME);
+  if (!creds || !creds.api_key) {
+    console.error('Not logged in. Run `npx auxilo setup` first.');
+    process.exit(1);
+  }
+  const baseUrl = resolveBaseUrl(flags);
+  const apiKey = creds.api_key;
+
+  let status;
+  try {
+    status = await cleanLaneRequest({ apiKey, baseUrl, method: 'GET', route: '/account/clean-lane' });
+  } catch (err) {
+    console.error(`Could not reach the server: ${err.message}`);
+    process.exit(1);
+  }
+  if (status.status === 404) {
+    console.log(CLEAN_LANE_UNAVAILABLE);
+    return;
+  }
+  if (!status.ok) {
+    console.error(`Could not read auto-publish status (HTTP ${status.status}): ${status.data.error || 'unknown error'}`);
+    process.exit(1);
+  }
+
+  if (sub === 'status') {
+    printCleanLaneStatus(status.data);
+    return;
+  }
+
+  if (sub === 'revoke') {
+    let res;
+    try {
+      res = await cleanLaneRequest({ apiKey, baseUrl, method: 'POST', route: '/account/clean-lane/revoke', body: {} });
+    } catch (err) {
+      console.error(`Could not reach the server: ${err.message}`);
+      process.exit(1);
+    }
+    if (res.status === 404) { console.log(CLEAN_LANE_UNAVAILABLE); return; }
+    if (!res.ok) {
+      console.error(`Revoke failed (HTTP ${res.status}): ${res.data.error || 'unknown error'}`);
+      process.exit(1);
+    }
+    console.log(res.data.message || 'Auto-publish is now OFF.');
+    return;
+  }
+
+  // ── grant: explainer → threshold → the sentence, typed verbatim ──────────
+  console.log(CLEAN_LANE_EXPLAINER);
+  if (status.data.clean_lane_active === true) {
+    console.log(`Auto-publish is already ON (quality at least ${status.data.min_auto_publish_quality}, since ${status.data.last_action_at}). Granting again records a fresh consent row with the threshold you choose now.\n`);
+  } else if (status.data.last_action === 'freeze') {
+    console.log(`Auto-publish is FROZEN: ${status.data.freeze_reason || 'unknown reason'}. Granting again re-activates it.\n`);
+  }
+
+  let minQuality = CLEAN_LANE_MIN_QUALITY_DEFAULT;
+  for (;;) {
+    const answer = await ask(`Publish only when the quality score is at least [${CLEAN_LANE_MIN_QUALITY_MIN}-${CLEAN_LANE_MIN_QUALITY_MAX}, default ${CLEAN_LANE_MIN_QUALITY_DEFAULT}]: `);
+    if (answer === '') break;
+    const n = parseInt(answer, 10);
+    if (Number.isInteger(n) && String(n) === answer && n >= CLEAN_LANE_MIN_QUALITY_MIN && n <= CLEAN_LANE_MIN_QUALITY_MAX) {
+      minQuality = n;
+      break;
+    }
+    if (readlineEnded) { console.log('Aborted. Nothing changed.'); return; }
+    console.log(`Enter a whole number from ${CLEAN_LANE_MIN_QUALITY_MIN} to ${CLEAN_LANE_MIN_QUALITY_MAX}.`);
+  }
+
+  // The consent text itself, verbatim (word-wrapped for the terminal only), before the sentence.
+  console.log('\nTerms of Service, Section 5.9.3(g): the consent you are giving\n');
+  console.log(wrapForTerminal(CLEAN_LANE_TERMS_G));
+  console.log('');
+  console.log(wrapForTerminal(CLEAN_LANE_TERMS_G2));
+  console.log(`\nFull Terms: ${baseUrl}/terms`);
+  // The no-email line, verbatim, directly before the affirmation prompt.
+  console.log(`\n${wrapForTerminal(CLEAN_LANE_NO_EMAIL_LINE)}`);
+  console.log('\nTo turn on auto-publish, type this sentence exactly as written, then press Enter:');
+  console.log(`\n  ${CLEAN_LANE_AFFIRMATION}\n`);
+  const typed = await ask('> ');
+  if (typed !== CLEAN_LANE_AFFIRMATION) {
+    console.log('The sentence did not match. Aborted. Nothing changed.');
+    return;
+  }
+
+  let res;
+  try {
+    res = await cleanLaneRequest({
+      apiKey,
+      baseUrl,
+      method: 'POST',
+      route: '/account/clean-lane/grant',
+      body: {
+        consent_version: status.data.consent_version_current,
+        agree: true,
+        affirmation: typed, // what the human typed, transmitted verbatim
+        min_auto_publish_quality: minQuality,
+      },
+    });
+  } catch (err) {
+    console.error(`Could not reach the server: ${err.message}`);
+    process.exit(1);
+  }
+  if (res.status === 404) { console.log(CLEAN_LANE_UNAVAILABLE); return; }
+  if (res.status === 409) {
+    console.error('The consent version changed on the server while you were reading. Run `npx auxilo clean-lane grant` again.');
+    process.exit(1);
+  }
+  if (!res.ok) {
+    console.error(`Grant failed (HTTP ${res.status}): ${res.data.error || 'unknown error'}`);
+    process.exit(1);
+  }
+  console.log(`\n${res.data.message || 'Auto-publish is now ON.'}`);
+  console.log(`  quality at least: ${res.data.min_auto_publish_quality}`);
+  console.log(`  consent version:  ${res.data.consent_version}`);
+  console.log('  Turn it off any time: npx auxilo clean-lane revoke');
+}
+
 // ─── Entry point ────────────────────────────────────────────────────────────
 
 function usage(command) {
@@ -903,6 +1150,18 @@ them private or sanitize-promote a corrected replacement.`,
     disable: `Usage: auxilo disable [--base-url <url>]
 
 Disable background extraction locally and optionally revoke server consent.`,
+    'clean-lane': `Usage: auxilo clean-lane <status|grant|revoke> [--base-url <url>]
+
+Auto-publish clean learnings (standing consent). While the feature is not yet
+available on your account every subcommand says so and changes nothing.
+
+  status   Show whether auto-publish is on, the quality threshold, and the
+           consent version.
+  grant    Turn it on. Interactive ONLY: you choose the threshold and then
+           TYPE the consent sentence exactly. No flag or piped input can do
+           this for you.
+  revoke   Turn it off (one step, no confirmation). Already-published
+           learnings keep their 7-day retraction window.`,
   };
   if (command && blocks[command]) {
     console.log(`\n${blocks[command]}\n`);
@@ -951,6 +1210,9 @@ Commands:
             skips that step.
   disable   Turn off background extraction (local kill-switch; optional
             server-side consent revoke).
+  clean-lane <status|grant|revoke>
+            Auto-publish clean learnings (standing consent). grant is
+            interactive only: you type the consent sentence yourself.
 
 Docs: https://auxilo.io · API: ${installer.DEFAULT_BASE_URL}
 `);
@@ -959,7 +1221,7 @@ Docs: https://auxilo.io · API: ${installer.DEFAULT_BASE_URL}
 async function main() {
   const cmd = process.argv[2];
   const subcommandHelp = ['help', '--help', '-h'].includes(process.argv[3]);
-  if (['setup', 'init', 'status', 'review', 'disable'].includes(cmd) && subcommandHelp) {
+  if (['setup', 'init', 'status', 'review', 'disable', 'clean-lane'].includes(cmd) && subcommandHelp) {
     return usage(cmd);
   }
   const flags = parseFlags(process.argv);
@@ -969,6 +1231,7 @@ async function main() {
     case 'status': return cmdStatus(flags);
     case 'review': return cmdReview(flags);
     case 'disable': return cmdDisable(flags);
+    case 'clean-lane': return cmdCleanLane(flags);
     case 'help': case '--help': case '-h': case undefined: return usage();
     default:
       console.error(`Unknown command: ${cmd}`);
@@ -996,10 +1259,17 @@ if (require.main === module) {
 
 module.exports = {
   parseFlags,
+  runnerSkewLine,
   resolveBaseUrl,
   shortFlags,
   groupSummaryRows,
   printSummaryTable,
   usage,
   run,
+  CLEAN_LANE_AFFIRMATION,
+  CLEAN_LANE_UNAVAILABLE,
+  CLEAN_LANE_TERMS_G,
+  CLEAN_LANE_TERMS_G2,
+  CLEAN_LANE_NO_EMAIL_LINE,
+  wrapForTerminal,
 };

package/lib/extraction-index.js

@@ -140,6 +140,20 @@ function localIndexRow(learning, response = {}, opts = {}) {
     ...(typeof response.status === 'string' && VALID_STATUSES.has(response.status) && {
       status: response.status,
     }),
+    // CLEAN-LANE-FLIP Phase A2: persist the standing-consent publish stamps the
+    // /learn response carries (published_via / standing_consent_version /
+    // retractable_until) so the SessionStart rollup (scripts/review-notice.js)
+    // can count clean-lane publishes from the local index. Spread only when
+    // present as non-empty strings; absent on every non-clean-lane response.
+    ...(typeof response.published_via === 'string' && response.published_via && {
+      published_via: response.published_via,
+    }),
+    ...(typeof response.standing_consent_version === 'string' && response.standing_consent_version && {
+      standing_consent_version: response.standing_consent_version,
+    }),
+    ...(typeof response.retractable_until === 'string' && response.retractable_until && {
+      retractable_until: response.retractable_until,
+    }),
   };
 }
 

package/lib/installer.js

@@ -792,10 +792,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 +828,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 +1760,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.10' },
+  { name: 'auxilo', version: '0.9.12' },
   {
     capabilities: { tools: {} },
     instructions: `You are connected to Auxilo, a knowledge marketplace where AI agents buy and sell operational learnings.
@@ -384,7 +384,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
     },
     {
       name: 'auxilo_contributor',
-      description: 'Check earnings for a contributor wallet. Shows total earned, per-learning breakdown. Free.',
+      description: 'Check aggregate earnings totals for a contributor wallet. Per-learning earnings require the authenticated auxilo_account_earnings tool. Free.',
       inputSchema: {
         type: 'object',
         properties: {
@@ -408,7 +408,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
     },
     {
       name: 'auxilo_account_earnings',
-      description: 'View earnings for your authenticated Auxilo account. Authenticates with your configured API key automatically, or pass a session_token (JWT). Returns total gross, contributor share, pending balance, total withdrawn, whether withdrawal is available (can_withdraw), and held_pending_assent — undisbursable receipts recorded before you accepted the current Terms, released to your withdrawable balance when you accept via auxilo_accept_terms. Earnings from on-chain-settled sales are paid to your wallet at sale time and appear in settlement history, not in pending balance. Free.',
+      description: 'View aggregate and per-learning earnings for your authenticated Auxilo account. Authenticates with your configured API key automatically, or pass a session_token (JWT). Returns total gross, contributor share, pending balance, total withdrawn, whether withdrawal is available (can_withdraw), and held_pending_assent — undisbursable receipts recorded before you accepted the current Terms, released to your withdrawable balance when you accept via auxilo_accept_terms. Earnings from on-chain-settled sales are paid to your wallet at sale time and appear in settlement history, not in pending balance. Free.',
       inputSchema: {
         type: 'object',
         properties: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auxilo-mcp",
-  "version": "0.9.10",
+  "version": "0.9.12",
   "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",

package/scripts/extract-local.js

@@ -36,20 +36,36 @@ const PRIVATE_CATEGORIES = [...CATEGORIES, 'non-technical'];
 const RETIRED_CATEGORIES = ['communication', 'content-generation'];
 
 /**
- * SPEC3 slice A1 gate — score-at-extraction, BUILT BUT DARK by default.
+ * SPEC3 slice A1 gate — score-at-extraction, ON BY DEFAULT since 0.9.12
+ * (CLEAN-LANE-FLIP Phase B). Explicit opt-out only: AUXILO_SCORE_EXTRACTION=0
+ * (or 'false') disables scoring; any other value, including unset, scores.
  *
- * ┌─ CRITICAL SEQUENCING CONSTRAINT (SPEC3-BUILDER-REVIEW-LOOP §3.1/§8) ──────┐
- * │ Under a server WITHOUT the B1 extraction-channel hold, a clean /learn     │
- * │ submission carrying a floor-passing quality_self_assessment publishes    │
- * │ IMMEDIATELY (seamlessEligible). Turning this gate on against such a      │
- * │ server silently flips hook extraction from "everything held" to "clean   │
- * │ items auto-publish" — an unrecorded consent change (2026-06-10 class).   │
- * │ Do NOT set AUXILO_SCORE_EXTRACTION=1 until the server holds              │
- * │ submission_channel:'extraction' items behind standing consent (B1).      │
- * └───────────────────────────────────────────────────────────────────────────┘
+ * ┌─ SEQUENCING CONSTRAINT — SATISFIED (SPEC3-BUILDER-REVIEW-LOOP §3.1/§8) ──┐
+ * │ This gate shipped dark (opt-in via AUXILO_SCORE_EXTRACTION=1) because   │
+ * │ under a server WITHOUT the B1 extraction-channel hold, a clean /learn    │
+ * │ submission carrying a floor-passing quality_self_assessment published   │
+ * │ IMMEDIATELY (seamlessEligible) — arming scoring would have silently      │
+ * │ flipped hook extraction from "everything held" to "clean items           │
+ * │ auto-publish", an unrecorded consent change (2026-06-10 class).          │
+ * │                                                                          │
+ * │ B1 SHIPPED (lib/clean-lane.js; server.js /learn): every submission       │
+ * │ carrying submission_channel:'extraction' (runner.js stamps it            │
+ * │ unconditionally) is HELD with reason 'standing_consent_off' unless the   │
+ * │ account holds an active standing-consent grant — regardless of the       │
+ * │ score. The server brake, not the absence of a score, is what keeps       │
+ * │ unconsented items out of the catalog, so default-on scoring is safe:     │
+ * │ the score can only move a held item into the ready_to_publish lane (one  │
+ * │ counted approve away) or, under an active grant, into the clean lane the │
+ * │ contributor explicitly opted into. Without a score every extraction      │
+ * │ submission held awaiting_quality forever, so a stock install could never │
+ * │ enter the clean lane at all — that was the Phase B defect this closes.   │
+ * └──────────────────────────────────────────────────────────────────────────┘
  */
 function scoreExtractionEnabled(env = process.env) {
-  return env.AUXILO_SCORE_EXTRACTION === '1';
+  const raw = env.AUXILO_SCORE_EXTRACTION;
+  if (raw === undefined || raw === null) return true;
+  const v = String(raw).trim().toLowerCase();
+  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.
@@ -662,11 +678,55 @@ async function runAnchoredJudge(candidates, indexState, opts = {}) {
 
 /**
  * Extract learnings locally. Returns { learnings: [...] } or { learnings: [], skipped }.
- * Claude Code and Codex rollout captures use the existing client-local Claude
- * extractor; other clients rely on the agent's proactive auxilo_contribute
- * (MCP) call.
+ *
+ * EXT-GATE: every capture source id runs the client-local extractor. The
+ * extractor is transcript-text based (buildExtractionPrompt carries no
+ * per-source branch), so nothing here depends on WHICH client captured.
+ * Unknown ids still short-circuit: a `--source` value the registry does not
+ * know is a misconfigured shim, not a client, and the skip message below is
+ * matched by runner.js and test/uc6-codex-capture.test.js — do not change it.
+ *
+ * The list is static on purpose: lib/installer.js is not in RUNNER_STACK, so
+ * this file cannot enumerate the registry at runtime. The closure test
+ * (test/ext-gate-closure.test.js) derives the expected set from the two live
+ * enumerations — scripts/sources/*.js adapter ids ∪ installer hook-client
+ * source ids — and is the authority; a new adapter or hook client that is not
+ * added here turns CI red.
  */
-const EXTRACTABLE_SOURCES = new Set(['claude-code', 'codex-cli']);
+const EXTRACTABLE_SOURCE_IDS = Object.freeze([
+  'antigravity',
+  'claude-code',
+  'cline',
+  'codex-cli',
+  'continue',
+  'copilot',
+  'cursor',
+  'factory',
+  'gemini-cli',
+  'openclaw',
+  'roo-code',
+  'windsurf',
+]);
+
+// Gate-A 2026-09-05: the exported set is IMMUTABLE. It stays a real Set (same
+// name, `.has()` / iteration / `instanceof Set` unchanged) but its own
+// add/delete/clear shadow the prototype's and throw, so no importer can widen
+// or narrow the allowlist at runtime — the frozen id array above is the only
+// source and the closure test is the only authority.
+function immutableSet(ids) {
+  const set = new Set(ids);
+  const refuse = (op) => function () {
+    throw new TypeError(`EXTRACTABLE_SOURCES is immutable (${op} refused)`);
+  };
+  Object.defineProperties(set, {
+    add: { value: refuse('add'), writable: false, configurable: false, enumerable: false },
+    delete: { value: refuse('delete'), writable: false, configurable: false, enumerable: false },
+    clear: { value: refuse('clear'), writable: false, configurable: false, enumerable: false },
+  });
+  return Object.freeze(set);
+}
+
+const EXTRACTABLE_SOURCES = immutableSet(EXTRACTABLE_SOURCE_IDS);
 
 async function extractLocally(transcript, sourceType, opts = {}) {
   if (sourceType && !EXTRACTABLE_SOURCES.has(sourceType)) {
@@ -780,7 +840,7 @@ async function extractLocally(transcript, sourceType, opts = {}) {
 }
 
 module.exports = {
-  extractLocally, extractWithClaudeCode, checkClaudeAuthStatus,
+  extractLocally, extractWithClaudeCode, checkClaudeAuthStatus, EXTRACTABLE_SOURCES, EXTRACTABLE_SOURCE_IDS,
   parseLearnings, parseExtractionOutput, resolveClaudeBin,
   CATEGORIES, PRIVATE_CATEGORIES, RETIRED_CATEGORIES,
   EXTRACTION_PROMPT, buildExtractionPrompt, scoreExtractionEnabled,

package/scripts/review-notice.js

@@ -24,6 +24,13 @@
  *   - Count source: GET /account/pending/summary with the credentials from
  *     ~/.auxilo/credentials.json; 3.5s abort so session start is never held
  *     hostage by a slow network.
+ *   - Standing-consent rollup (CLEAN-LANE-FLIP Phase A, SPEC3-C1 §4.3): ONE
+ *     more count-only line when the LOCAL submitted-learnings log
+ *     (~/.auxilo/extracted-index.jsonl, lib/extraction-index.js) holds rows
+ *     stamped published_via = clean_lane_standing_consent since the last
+ *     notice. Zero platform cost; reaches the human in their own client.
+ *     Suppression and the last-notice stamp are shared with the held-count
+ *     line (one state file, one 4h window).
  *
  * Self-contained (fs/path/os + global fetch) — ships in RUNNER_STACK to
  * ~/.auxilo/bin/scripts/ and must not require anything outside that layout
@@ -86,6 +93,61 @@ function renderNotice(count) {
   return `Auxilo: ${count} learning(s) held for your review — run auxilo_review (MCP) or \`npx auxilo review\`.`;
 }
 
+/**
+ * Stamp lib/clean-lane.js writes on lane publishes (PUBLISHED_VIA_CLEAN_LANE).
+ * A literal here because this script is self-contained (RUNNER_STACK layout);
+ * test/clean-lane-phase-a.test.js pins the two byte-equal.
+ */
+const PUBLISHED_VIA_CLEAN_LANE = 'clean_lane_standing_consent';
+
+/** Local submitted-learnings log (lib/extraction-index.js DEFAULT_INDEX_PATH). */
+function submittedIndexPath(homeDir) {
+  return path.join(auxiloDir(homeDir), 'extracted-index.jsonl');
+}
+
+/** Read the local log; absent/unreadable → []; malformed lines skipped. */
+function readSubmittedRows(homeDir) {
+  let raw;
+  try {
+    raw = fs.readFileSync(submittedIndexPath(homeDir), 'utf-8');
+  } catch {
+    return [];
+  }
+  const rows = [];
+  for (const line of String(raw).split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const row = JSON.parse(trimmed);
+      if (row && typeof row === 'object') rows.push(row);
+    } catch { /* skip */ }
+  }
+  return rows;
+}
+
+/**
+ * Pure: how many local rows were published under standing consent AFTER
+ * `sinceIso` (the last notice stamp). No stamp → every such row counts.
+ */
+function countStandingConsentPublishes(rows, sinceIso) {
+  const since = sinceIso ? Date.parse(sinceIso) : NaN;
+  let n = 0;
+  for (const row of rows || []) {
+    if (!row || row.published_via !== PUBLISHED_VIA_CLEAN_LANE) continue;
+    if (Number.isFinite(since)) {
+      const t = Date.parse(row.submitted_at);
+      if (!Number.isFinite(t) || t <= since) continue;
+    }
+    n += 1;
+  }
+  return n;
+}
+
+/** The rollup line. Count only — same contract as renderNotice. */
+function renderStandingConsentNotice(count) {
+  return `Auxilo: ${count} learning(s) auto-published under your standing consent (retract within 7 days: npx auxilo review).`;
+}
+
 /** Load credentials; null when absent/malformed/keyless. */
 function readCredentials(homeDir) {
   try {
@@ -125,18 +187,26 @@ async function main() {
   const creds = readCredentials(homeDir);
   if (!creds) return;
 
-  if (!shouldNotify(readState(homeDir))) return;
+  const state = readState(homeDir);
+  if (!shouldNotify(state)) return;
 
   const count = await fetchPendingCount(creds);
-  if (count == null || count <= 0) return;
+  const autoPublished = countStandingConsentPublishes(readSubmittedRows(homeDir), state.last_notice_at);
+
+  const lines = [];
+  if (count != null && count > 0) lines.push(renderNotice(count));
+  if (autoPublished > 0) lines.push(renderStandingConsentNotice(autoPublished));
+  if (lines.length === 0) return;
 
-  process.stdout.write(renderNotice(count) + '\n');
+  process.stdout.write(lines.join('\n') + '\n');
   writeState(homeDir);
 }
 
 module.exports = {
   shouldNotify, renderNotice, readState, writeState, readCredentials,
   fetchPendingCount, NOTICE_SUPPRESSION_MS, FETCH_TIMEOUT_MS,
+  PUBLISHED_VIA_CLEAN_LANE, submittedIndexPath, readSubmittedRows,
+  countStandingConsentPublishes, renderStandingConsentNotice,
 };
 
 if (require.main === module) {