auxilo-mcp 0.9.11 → 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) {
@@ -879,6 +894,20 @@ async function cmdReview(flags) {
 // 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;
@@ -897,6 +926,18 @@ 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 };
@@ -927,6 +968,12 @@ function printCleanLaneStatus(data) {
     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) {
@@ -1011,6 +1058,14 @@ async function cmdCleanLane(flags) {
     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('> ');
@@ -1204,6 +1259,7 @@ if (require.main === module) {
 
 module.exports = {
   parseFlags,
+  runnerSkewLine,
   resolveBaseUrl,
   shortFlags,
   groupSummaryRows,
@@ -1212,4 +1268,8 @@ module.exports = {
   run,
   CLEAN_LANE_AFFIRMATION,
   CLEAN_LANE_UNAVAILABLE,
+  CLEAN_LANE_TERMS_G,
+  CLEAN_LANE_TERMS_G2,
+  CLEAN_LANE_NO_EMAIL_LINE,
+  wrapForTerminal,
 };

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.11' },
+  { 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.

package/package.json

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