ruvnet-brain 4.5.16 → 4.6.0

package/scripts/onboarding-console.mjs

@@ -19,6 +19,7 @@
 //   • Bind 127.0.0.1 only; mint a random per-launch token; every mutating POST must echo it (else 403).
 
 import http from 'node:http';
+import { createSuiteUpdater } from './console-suite-update.mjs';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
@@ -27,6 +28,7 @@ import { fileURLToPath } from 'node:url';
 import { spawnSync, execFileSync, spawn } from 'node:child_process';
 
 import { auditModel, installedVersion } from './stack-sync.mjs';
+import { acquireDeveloperLock } from '../plugin/scripts/developer-update-lock.mjs';
 import { candidateRoots, findStores, findProjects, diagnose } from './memory-doctor.mjs';
 import { buildStackRecommendations, buildWiringRecommendations, summarizeWiring, scoreMemoryHealth, buildHealthRecommendations, buildCapabilityRecommendations } from './console-engine.mjs';
 import { planFor } from './remedy-registry.mjs';
@@ -659,7 +661,7 @@ function gatherSavings({ repo = REPO } = {}) {
 const CONFIG_SCHEMA = [
   { key: 'openrouterKey', label: 'OpenRouter API key', type: 'secret', secret: true, help: 'Unlocks cheap-model routing and the self-improvement loop. Stored only in your user folder.' },
   { key: 'provider', label: 'Your model house', type: 'enum', options: ['auto', 'anthropic', 'openai', 'codex', 'google', 'xai'], help: 'Which stack is yours? Sets your frontier model + savings baseline — Claude → Fable 5, ChatGPT → GPT-5.6 Sol, Codex → Sol, Gemini → 3.1 Pro, Grok → 4.5. “auto” detects from your keys.' },
-  { key: 'nightly', label: 'Nightly brain refresh', type: 'bool', help: 'Rebuild the knowledge base from pinned versions overnight so answers stay current.' },
+  { key: 'nightly', label: 'Nightly coordinated updates', type: 'bool', help: 'Run the same update coordinator overnight using your saved release policy and tool scope.' },
   { key: 'routing', label: 'Token-smart routing', type: 'enum', options: ['auto', 'off'], help: 'Send cheap, mechanical tasks to smaller, cheaper models automatically.' },
   { key: 'qeFleet', label: 'On-demand QE test fleet', type: 'bool', help: 'Let RuvNet Brain spin up an Agentic-QE test fleet when you ask it to.' },
 ];
@@ -805,7 +807,7 @@ function gatherConfig() {
   if (!schedule.artifact.supported) {
     unavailable.push({
       key: 'nightly',
-      label: 'Nightly brain refresh',
+      label: 'Nightly coordinated updates',
       reason: schedule.evidence,
     });
   }
@@ -1596,15 +1598,17 @@ export function settleRefreshState({ currentRunId, runId, code = 0, signal = nul
   if (code !== 0 || signal) return classifyRefreshState({ failed: signal ? `signal ${signal}` : `exit ${code}`, runId });
   return Object.freeze({ status: 'settled', runId, error: null });
 }
-function kickRefreshDetailed({ force = false } = {}) {
+let FOLLOW_UP_REFRESH = null;
+export function kickRefreshDetailed({ force = false, followUp = false, cwd = process.cwd(), spawnRefresh = spawn } = {}) {
   if (process.env.RUVNET_CONSOLE_DISABLE_BACKGROUND_REFRESH === '1') {
     REFRESH_STATE = classifyRefreshState({ disabled: true });
     return REFRESH_STATE;
   }
   const now = Date.now();
   if (REFRESH_CHILD && now - LAST_REFRESH_KICK < REFRESH_WEDGED_MS) {
+    if (followUp) FOLLOW_UP_REFRESH = { cwd, spawnRefresh };
     REFRESH_STATE = classifyRefreshState({ running: true, runId: REFRESH_STATE.runId });
-    return REFRESH_STATE;
+    return FOLLOW_UP_REFRESH ? { ...REFRESH_STATE, queued: true } : REFRESH_STATE;
   }
   if (!force && now - LAST_REFRESH_KICK < 15000) {
     REFRESH_STATE = classifyRefreshState({ debounced: true, runId: REFRESH_STATE.runId });
@@ -1622,10 +1626,19 @@ function kickRefreshDetailed({ force = false } = {}) {
     // inherit it. Machine-level caches (stack/activity/trust) don't depend on cwd, so this is safe
     // for them; it only fixes the project-scoped ones. NOT a change to the withhold-vs-recompute
     // contract (the 2026-07-17 outage) — only to which project the background compute is about.
-    const child = spawn(process.execPath, [SELF, '--refresh-cache'], { detached: true, stdio: 'ignore', cwd: process.cwd() });
+    const child = spawnRefresh(process.execPath, [SELF, '--refresh-cache'], { detached: true, stdio: 'ignore', cwd });
     REFRESH_CHILD = child;
     const runId = `${process.pid}-${now}`;
     REFRESH_STATE = classifyRefreshState({ runId });
+    const drainFollowUp = () => {
+      const queued = FOLLOW_UP_REFRESH;
+      FOLLOW_UP_REFRESH = null; // Any number of forced mutations coalesce into one scan.
+      if (!queued) return;
+      // The old child may have published after the mutation withdrew its earlier snapshot.
+      // Withdraw again only after that writer has exited, before the post-mutation child starts.
+      expireCachesEmbedding([STATE_CACHE, STACK_CACHE, MEMORY_CACHE, CAPABILITY_CACHE]);
+      kickRefreshDetailed({ ...queued, force: true });
+    };
     // unref() only releases the event-loop hold; these listeners still fire while the server lives.
     child.on('exit', (code, signal) => {
       // An older child can exit after a newer run has started. It may only settle its own run.
@@ -1633,12 +1646,14 @@ function kickRefreshDetailed({ force = false } = {}) {
       if (!settled) return;
       REFRESH_CHILD = null;
       REFRESH_STATE = settled;
+      drainFollowUp();
     });
     child.on('error', (error) => {
       const settled = settleRefreshState({ currentRunId: REFRESH_STATE.runId, runId, code: 1, signal: error?.message || error });
       if (!settled) return;
       REFRESH_CHILD = null;
       REFRESH_STATE = settled;
+      drainFollowUp();
     });
     child.unref();   // let it outlive this request; it writes the caches and exits on its own
     return REFRESH_STATE;
@@ -1813,7 +1828,7 @@ function serveCached(res, file, decorate = (d) => d, scopeKey = null) {
 
   // WARM — including over-ceiling. Never compute inline here; hand back what we measured, say when,
   // and let the detached child produce the next one.
-  const fresh = freshnessOf(c.at);
+  const fresh = { ...freshnessOf(c.at), ...(FOLLOW_UP_REFRESH ? { stale: true, refreshQueued: true } : {}) };
   kickRefresh();
   return sendJSON(res, 200, {
     ...decorate(c.data),
@@ -2922,9 +2937,15 @@ function undo(undoToken) {
   // re-applies an old state over whatever the user has done since. The replay guard at the top of
   // this function covers all kinds; these calls are what arm it.
   if (entry.kind === 'reinstall-version' && entry.pkg && entry.prevVersion) {
-    const r = spawnSync('npm', ['install', '-g', '--prefix', NPM_PREFIX, `${entry.pkg}@${entry.prevVersion}`], { encoding: 'utf8', timeout: 15 * 60 * 1000 });
-    if (r.status === 0) markUndoConsumed(undoToken);
-    return { ok: r.status === 0, log: r.status === 0 ? `reinstalled ${entry.pkg}@${entry.prevVersion}` : (r.stderr || '').slice(-800) };
+    let lock;
+    try {
+      lock = acquireDeveloperLock();
+      const r = spawnSync('npm', ['install', '-g', '--prefix', NPM_PREFIX, `${entry.pkg}@${entry.prevVersion}`], { encoding: 'utf8', timeout: 15 * 60 * 1000,
+        env: { ...process.env, RUVNET_DEVELOPER_UPDATE_TOKEN: lock.token } });
+      if (r.status === 0) markUndoConsumed(undoToken);
+      return { ok: r.status === 0, log: r.status === 0 ? `reinstalled ${entry.pkg}@${entry.prevVersion}` : (r.stderr || '').slice(-800) };
+    } catch (error) { return { ok: false, log: error.message }; }
+    finally { lock?.release(); }
   }
   if (entry.kind === 'restore-backup' && entry.project) {
     const dir = resolveProjectDir(entry.project);
@@ -3068,6 +3089,7 @@ function openBrowser(url) {
   }
 }
 function startServer({ port = Number(process.env.CONSOLE_PORT) || 7411, open = false, cwd = process.cwd() } = {}) {
+  const suiteUpdater = createSuiteUpdater({ home: CONSOLE_ROOT, brainHome: process.env.RUVNET_BRAIN_HOME || path.join(CONSOLE_ROOT, '.cache/ruvnet-brain'), markNightly: () => saveConfig({ nightly: true }) });
   const controlToken = crypto.randomBytes(24).toString('hex');
   let activeRuntime = null;
   let receiptFile = null;
@@ -3100,7 +3122,7 @@ function startServer({ port = Number(process.env.CONSOLE_PORT) || 7411, open = f
       if (req.method === 'GET' && url === '/api/state') {
         // project-scoped: never serve another project's cached state. The measuring lives in the
         // --refresh-cache child; this handler only ever reads a file and stamps the token on it.
-        return serveCached(res, STATE_CACHE, (d) => ({ ...d, token: TOKEN }), cwd);
+        return serveCached(res, STATE_CACHE, (d) => ({ ...d, token: TOKEN, suiteUpdate: suiteUpdater.state() }), cwd);
       }
       // ── /api/capabilities — "what do I own, and is it on?" ──────────────────────────────────────
       //
@@ -3142,7 +3164,8 @@ function startServer({ port = Number(process.env.CONSOLE_PORT) || 7411, open = f
         // the request path before the instant-open fix.
         return serveCached(res, STACK_CACHE);
       }
-      if (req.method === 'GET' && url === '/api/activity') return sendJSON(res, 200, gatherActivity(cwd));
+      if (req.method === 'GET' && url === '/api/suite-update') return sendJSON(res, 200, suiteUpdater.state());
+      if (req.method === 'GET' && url === '/api/activity') return sendJSON(res, 200, { ...gatherActivity(cwd), suiteUpdate: suiteUpdater.state() });
       if (req.method === 'GET' && url === '/api/lessons') return sendJSON(res, 200, gatherLessons());
       if (req.method === 'GET' && url === '/api/trust') return sendJSON(res, 200, await gatherTrust());
       if (req.method === 'GET' && url === '/tips') { req.url = '/tips.html'; return serveStatic(req, res); }
@@ -3153,6 +3176,12 @@ function startServer({ port = Number(process.env.CONSOLE_PORT) || 7411, open = f
       if (req.method === 'POST') {
         const body = await readBody(req);
         if (body.token !== TOKEN) return sendJSON(res, 403, { error: 'bad or missing token' });
+        if (url === '/api/suite-update') {
+          const origin = req.headers.origin;
+          if (origin && origin !== `http://${req.headers.host}`) return sendJSON(res, 403, { error: 'forbidden origin' });
+          const result = suiteUpdater.start(body.channel);
+          return sendJSON(res, result.status || (result.ok ? 202 : 500), result);
+        }
         if (url === '/api/apply') return sendJSON(res, 200, apply(Array.isArray(body.ids) ? body.ids : []));
         if (url === '/api/save-config') return sendJSON(res, 200, saveConfig(body.values || {}));
         if (url === '/api/save-advocacy') return sendJSON(res, 200, saveAdvocacy(body.values || {}));
@@ -3178,7 +3207,7 @@ function startServer({ port = Number(process.env.CONSOLE_PORT) || 7411, open = f
           //     refresh that did not start must not report that it did, so `started` is the child's
           //     real answer, not a constant.
           expireCachesEmbedding([STATE_CACHE, STACK_CACHE, MEMORY_CACHE, CAPABILITY_CACHE]);
-          const refresh = kickRefreshDetailed({ force: true });
+          const refresh = kickRefreshDetailed({ force: true, followUp: true, cwd });
           return sendJSON(res, 200, { ok: refresh.status !== 'failed', started: refresh.status === 'started', refreshing: refresh.status === 'started' || refresh.status === 'already-running', refresh });
         }
         if (url === '/api/undo') return sendJSON(res, 200, undo(body.undoToken));

package/scripts/practical-rule-selector.mjs

@@ -0,0 +1,51 @@
+// One deterministic advisory selector. Existing safety gates remain independently authoritative.
+import fs from 'node:fs';
+import crypto from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+const catalogFile = fileURLToPath(new URL('../config/practical-rule-catalog.json', import.meta.url));
+export const RULE_PHASES = Object.freeze(['planning','mutation','execution','checks','review','completion','recovery','compaction','release','memory','learning','evaluation','grounding','maintenance']);
+const ACTIONS = new Set(['read','write','delete','implementation','source-inspection','architecture','source-change','memory-recall','memory-opt-out','checkpoint','recover','learn','capture','evaluate','rollback','model-call','dispatch','parallel-dispatch','privacy','ownership','config-change','unfinished-work','stalled','blocked','publish','version','build','knowledge','search','update','doctor','disk','check']);
+let loaded;
+function freeze(value) { if (value && typeof value === 'object') { Object.values(value).forEach(freeze); Object.freeze(value); } return value; }
+export function loadPracticalCatalog() {
+  if (loaded) return loaded;
+  const bytes = fs.readFileSync(catalogFile); if (bytes.length > 512 * 1024) throw Error('Practical catalog exceeds bounded configuration size');
+  const data = JSON.parse(bytes), ids = new Set();
+  if (data.kind !== 'approved-practical-action-catalog' || data.rules?.length !== 100 || !/^[a-f0-9]{64}$/.test(data.auditSha256)) throw Error('Invalid source-bound practical catalog');
+  for (const r of data.rules) {
+    if (!/^P\d{3}$/.test(r.id) || r.cohort !== 'approved-practical' || ids.has(r.id) || !r.sourceRuleIds?.length || typeof r.actionRule !== 'string'
+      || r.applicability.phases.some(p => !RULE_PHASES.includes(p)) || r.applicability.actions.some(a => !ACTIONS.has(a))) throw Error('Invalid approved practical rule');
+    ids.add(r.id);
+  }
+  loaded = freeze({ data, projectionSha256: crypto.createHash('sha256').update(bytes).digest('hex') }); return loaded;
+}
+
+export function selectPracticalRules({ phase, actions = [], maxContextBytes = 2048, maxRules = 6 } = {}, catalog = loadPracticalCatalog()) {
+  const base = { schemaVersion: 1, delivery: 'ADVISORY_ONLY', enforcement: 'NOT_ASSERTED_BY_SELECTOR',
+    catalogAuditSha256: catalog.data.auditSha256, projectionSha256: catalog.projectionSha256,
+    phase: RULE_PHASES.includes(phase) ? phase : null, actions: [], selectedIds: [], deferredIds: [], context: '' };
+  if (!RULE_PHASES.includes(phase)) return { ...base, status: 'UNKNOWN_PHASE', reason: 'No broad fallback or all-rules injection' };
+  if (!Array.isArray(actions) || actions.length > 16 || actions.some(a => !ACTIONS.has(a))) return { ...base, actions: [], status: 'UNKNOWN_ACTION', reason: 'Explicit supported action scope required' };
+  if (!Number.isInteger(maxContextBytes) || maxContextBytes < 128 || maxContextBytes > 8192 || !Number.isInteger(maxRules) || maxRules < 1 || maxRules > 12) throw Error('Invalid practical context budget');
+  const applicable = catalog.data.rules.filter(r => r.cohort === 'approved-practical' && /^P\d{3}$/.test(r.id)
+    && r.sourceRuleIds?.length && r.applicability.phases.includes(phase)
+    && (!r.applicability.actions.length || r.applicability.actions.some(a => actions.includes(a))))
+    .sort((a,b) => a.applicability.priority - b.applicability.priority || a.id.localeCompare(b.id));
+  const header = 'Applicable action guidance only; selecting a rule does not enforce it or replace existing gates.\n';
+  let context = header; const selected = [], deferred = [];
+  for (const rule of applicable) {
+    const line = `[${rule.id}; declared ${rule.declaredEnforcement.kind}; advisory] ${rule.actionRule}\n`;
+    if (selected.length >= maxRules || Buffer.byteLength(context + line) > maxContextBytes) { deferred.push(rule.id); continue; }
+    selected.push(rule); context += line;
+  }
+  return { ...base, actions: [...new Set(actions)].sort(), status: selected.length ? 'SELECTED' : applicable.length ? 'BUDGET_DEFERRED' : 'NO_APPLICABLE_RULES',
+    selectedIds: selected.map(r => r.id), deferredIds: deferred, context: selected.length ? context : '',
+    contextBytes: selected.length ? Buffer.byteLength(context) : 0 };
+}
+
+export function practicalSelectionReceipt(selection) {
+  return { schemaVersion: 1, phase: selection.phase, actions: selection.actions, status: selection.status,
+    selectedIds: selection.selectedIds, deferredIds: selection.deferredIds, catalogAuditSha256: selection.catalogAuditSha256,
+    projectionSha256: selection.projectionSha256, contextBytes: selection.contextBytes ?? 0,
+    delivery: 'ADVISORY_ONLY', enforcement: 'NOT_ASSERTED_BY_SELECTOR' };
+}

package/scripts/product-integrity-contract.mjs

@@ -12,6 +12,8 @@ import {
 export const PRODUCT_INTEGRITY_SCHEMA_VERSION = 1;
 export const PRODUCT_INTEGRITY_TEST_CLASSES = Object.freeze(['essential', 'supporting', 'obsolete']);
 export const PRODUCT_INTEGRITY_PROOF_STRENGTH = Object.freeze(['unit', 'integration', 'packed-artifact', 'candidate-host', 'public-byte']);
+const TRACE_SCOPE = 'contract-and-source-byte-inventory';
+const TRACE_UNTESTED = Object.freeze(['semantic-review', 'behavior-execution']);
 export const PRODUCT_INTEGRITY_PROCESSES = Object.freeze([
   { id: 'SourceCoverage', upstream: [] }, { id: 'CorpusGeneration', upstream: ['SourceCoverage'] },
   { id: 'ReleaseProjection', upstream: ['CorpusGeneration'] }, { id: 'RefreshLifecycle', upstream: ['ReleaseProjection'] },
@@ -119,19 +121,23 @@ export function productIntegrityGovernedPaths(contract = validateProductIntegrit
 export function buildProductIntegrityTrace({ root = '.', sourceSha, contract = validateProductIntegrityContract(), inventory } = {}) {
   if (!/^[a-f0-9]{40}$/.test(String(sourceSha || ''))) throw new Error('product integrity trace requires an exact source SHA');
   const validated = validateProductIntegrityContract(contract);
-  const unsigned = { schemaVersion: 1, kind: 'ruvnet-brain-product-integrity-trace', sourceSha, contractSha256: digest(validated), sourceScope: buildSourceScopeReceipt({ root, sourceSha, governedPaths: productIntegrityGovernedPaths(validated), inventory }), contract: validated, verdict: 'PASS', untested: [] };
+  const unsigned = { schemaVersion: 2, kind: 'ruvnet-brain-product-integrity-trace', sourceSha, contractSha256: digest(validated), sourceScope: buildSourceScopeReceipt({ root, sourceSha, governedPaths: productIntegrityGovernedPaths(validated), inventory }), contract: validated, verdict: 'PASS',
+    evidenceScope: TRACE_SCOPE, semanticReviewVerified: false, behaviorVerified: false, untested: [...TRACE_UNTESTED] };
   return { ...unsigned, traceSha256: digest(unsigned) };
 }
 export function validateProductIntegrityTrace(trace, { root = '.', sourceSha = trace?.sourceSha, inventory } = {}) {
   const { traceSha256, ...unsigned } = trace || {};
-  if (trace?.schemaVersion !== 1 || trace?.kind !== 'ruvnet-brain-product-integrity-trace' || trace.sourceSha !== sourceSha || trace.verdict !== 'PASS' || canonicalJson(trace.untested) !== '[]' || trace.contractSha256 !== digest(trace.contract) || traceSha256 !== digest(unsigned)) throw new Error('product integrity trace identity is invalid');
+  if (trace?.schemaVersion !== 2 || trace?.kind !== 'ruvnet-brain-product-integrity-trace' || trace.sourceSha !== sourceSha || trace.verdict !== 'PASS'
+    || trace.evidenceScope !== TRACE_SCOPE || trace.semanticReviewVerified !== false || trace.behaviorVerified !== false
+    || canonicalJson(trace.untested) !== canonicalJson(TRACE_UNTESTED) || trace.contractSha256 !== digest(trace.contract) || traceSha256 !== digest(unsigned)) throw new Error('product integrity trace identity is invalid or legacy');
   validateSourceScopeReceipt(trace.sourceScope, { root, inventory });
   const rebuilt = buildProductIntegrityTrace({ root, sourceSha, contract: trace.contract, inventory });
   if (canonicalJson(rebuilt) !== canonicalJson(trace)) throw new Error('product integrity trace differs from the exact source');
   return trace;
 }
 export function renderProductIntegrityTraceMarkdown(contract = validateProductIntegrityContract()) {
-  const lines = ['# ADR-072 generated traceability', '', '> Generated from `scripts/product-integrity-contract.mjs`; do not hand-edit.', '', '## Processes', '', '| Process | Upstream | Owns | Contributes |', '|---|---|---|---|'];
+  const lines = ['# ADR-072 generated traceability', '', '> Generated from `scripts/product-integrity-contract.mjs`; do not hand-edit.', '',
+    '> This lists declared proof boundaries. A generated trace PASS verifies contract structure and exact source bytes; semantic review and behavior execution remain unverified.', '', '## Processes', '', '| Process | Upstream | Owns | Contributes |', '|---|---|---|---|'];
   for (const row of contract.processes) lines.push(`| ${row.id} | ${row.upstream.join(', ') || '—'} | ${row.owns.join(', ') || '—'} | ${row.contributes.join(', ') || '—'} |`);
   lines.push('', '## Obligations', '', '| ID | Statement | Owner | Contributors |', '|---|---|---|---|');
   for (const row of contract.obligations) lines.push(`| ${row.id} | ${row.statement} | ${row.owner} | ${row.contributors.join(', ') || '—'} |`);
@@ -170,7 +176,8 @@ export function runProductIntegrityCli(argv = process.argv.slice(2), io = { stdo
   const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..'); const sourceSha = valueAfter(argv, '--source-sha'); const out = valueAfter(argv, '--out');
   if (argv.includes('--trace') && sourceSha && out) { fs.writeFileSync(path.resolve(out), `${canonicalJson(buildProductIntegrityTrace({ root, sourceSha }))}\n`, { flag: 'wx', mode: 0o600 }); return 0; }
   const verify = valueAfter(argv, '--verify-trace');
-  if (verify && sourceSha) { const trace = JSON.parse(fs.readFileSync(path.resolve(verify), 'utf8')); validateProductIntegrityTrace(trace, { root, sourceSha }); io.stdout.write(`${canonicalJson({ verdict: 'PASS', traceSha256: trace.traceSha256 })}\n`); return 0; }
+  if (verify && sourceSha) { const trace = JSON.parse(fs.readFileSync(path.resolve(verify), 'utf8')); validateProductIntegrityTrace(trace, { root, sourceSha }); io.stdout.write(`${canonicalJson({ verdict: 'PASS', evidenceScope: TRACE_SCOPE,
+    semanticReviewVerified: false, behaviorVerified: false, traceSha256: trace.traceSha256 })}\n`); return 0; }
   throw new Error('invalid product integrity argument combination');
 }
 if (((() => { try { return process.argv[1] && fs.realpathSync(process.argv[1]) === fs.realpathSync(fileURLToPath(import.meta.url)); } catch { return false; } })())) { try { process.exitCode = runProductIntegrityCli(); } catch (error) { console.error(`[product-integrity-contract] ${error.message}`); process.exitCode = 1; } }

package/scripts/release-qualification-contract.mjs

@@ -1,6 +1,15 @@
 // Reviewed stabilization release boundaries. Legacy tests remain developer diagnostics.
 export const RELEASE_REQUIREMENTS = Object.freeze({
   "source": [
+    {
+      "id": "source-bound-installed-update-coordinator",
+      "reason": "Allowed channels and immutable Claude artifact paths reject downgrades, ambiguous registry records, changed bytes, extra active resources and escape paths; Console success requires the exact launched source closure. POSIX owner fixtures additionally enforce original-prefix installs, existing-tool-only policy, shared locks and source-bound scheduler receipts",
+      "files": ["tests/unit/developer-update-policy-portable.test.mjs", "tests/unit/plugin-artifact-proof.test.mjs", "tests/unit/console-suite-update.test.mjs"],
+      "platformFiles": {
+        "linux": ["tests/unit/developer-update.test.mjs"],
+        "macos": ["tests/unit/developer-update.test.mjs"]
+      }
+    },
     {
       "id": "installer-release-argument-safety",
       "reason": "Incomplete named releases refuse before network or settings writes; valid named releases and installer help retain their contracts",
@@ -282,6 +291,11 @@ export const RELEASE_REQUIREMENTS = Object.freeze({
     }
   ],
   "integration": [
+    {
+      "id": "authenticated-update-coordinator-interface",
+      "reason": "The actual Console server reports unrun status without policy writes, rejects absent tokens, cross-origin requests and invalid policies, and refuses a second updater while the shared lock is owned",
+      "files": ["tests/integration/console-suite-update-endpoint.test.mjs"]
+    },
     {
       "id": "managed-checker-kernel-boundary",
       "reason": "Native read-only sandbox denies acceptance-script writes outside the authorized project",

package/scripts/remedy-registry.mjs

@@ -236,6 +236,7 @@ export function sampleIdFor(remedy) {
   switch (remedy.key) {
     case 'memory-index': return 'repair:memory-index';
     case 'learning-flush': return 'learning:flush';
+    case 'learning-legacy-user-flush': return 'learning:flush-legacy-user';
     case 'learning-train': return 'learning:train';
     case 'distill-fleet': return 'learning:distill-fleet';
     case 'enable-memory-distillation': return 'enable:memory-distillation';

package/scripts/source-scope-receipt.mjs

@@ -58,10 +58,13 @@ export function buildSourceScopeReceipt({ root, governedPaths, sourceSha = null,
   const missing = governed.filter((relative) => !inventorySet.has(relative));
   if (missing.length) throw new Error(`governed source is outside repository inventory: ${missing.join(', ')}`);
   const byPath = new Map(files.map((row) => [row.path, row]));
-  const governedFiles = governed.map((relative) => ({ ...byPath.get(relative), readComplete: true }));
+  // Hashing reads bytes; it does not inspect meaning or execute reviewed behavior.
+  const governedFiles = governed.map((relative) => ({ ...byPath.get(relative), bytesReadComplete: true }));
   const body = {
-    schemaVersion: 1,
+    schemaVersion: 2,
     kind: 'ruvnet-brain-source-scope-receipt',
+    evidenceScope: 'complete-repository-byte-inventory',
+    semanticReview: { status: 'UNKNOWN', performed: false },
     sourceSha,
     repository: { fileCount: files.length, inventorySha256: digest(files) },
     governed: { fileCount: governedFiles.length, files: governedFiles },
@@ -70,9 +73,11 @@ export function buildSourceScopeReceipt({ root, governedPaths, sourceSha = null,
 }
 
 export function validateSourceScopeReceipt(receipt, { root, inventory = gitInventory } = {}) {
-  if (receipt?.schemaVersion !== 1 || receipt?.kind !== 'ruvnet-brain-source-scope-receipt'
+  if (receipt?.schemaVersion !== 2 || receipt?.kind !== 'ruvnet-brain-source-scope-receipt'
+    || receipt.evidenceScope !== 'complete-repository-byte-inventory'
+    || canonicalJson(receipt.semanticReview) !== canonicalJson({ status: 'UNKNOWN', performed: false })
     || !Number.isInteger(receipt.repository?.fileCount) || !Array.isArray(receipt.governed?.files)
-    || receipt.governed.files.some((row) => row.readComplete !== true)) throw new Error('source scope receipt is malformed');
+    || receipt.governed.files.some((row) => row.bytesReadComplete !== true || Object.hasOwn(row, 'readComplete'))) throw new Error('source scope receipt is malformed or legacy; rebuild byte inventory evidence');
   if (digest(payload(receipt)) !== receipt.receiptSha256) throw new Error('source scope receipt digest mismatch');
   const rebuilt = buildSourceScopeReceipt({ root, sourceSha: receipt.sourceSha,
     governedPaths: receipt.governed.files.map(({ path: relative }) => relative), inventory });

package/scripts/stack-sync.mjs

@@ -36,6 +36,9 @@ import { spawnSync } from 'node:child_process';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import { runDeveloperUpdate, readDeveloperUpdateConfig } from '../plugin/scripts/developer-update.mjs';
+import { FAMILY, PLUGIN_MARKETPLACES, cmpVersion, pickTargetTag, normalizeNpmDistTags } from '../plugin/scripts/developer-update-policy.mjs';
+export { FAMILY, PLUGIN_MARKETPLACES, cmpVersion, pickTargetTag, normalizeNpmDistTags } from '../plugin/scripts/developer-update-policy.mjs';
 
 const HOME = os.homedir();
 
@@ -78,9 +81,9 @@ const RECEIPT = path.join(HOME, '.cache/ruvnet-brain/stack-sync-receipt.json');
 const PLUGINS_DIR = path.join(HOME, '.claude', 'plugins');
 
 // The tag policy. ONE table — the single source of truth for "what SHOULD be installed".
-// The orchestration core tracks alpha (rUv ships fast: 3.26 -> 3.28 inside one 18-hour window).
-// Everything else tracks latest. Unlisted packages get DEFAULT_TAG.
-export const TAG_POLICY = { ruflo: 'alpha', '@claude-flow/cli': 'alpha' };
+// The recommended default is latest. The canonical owner config can explicitly select alpha.
+// Unlisted packages still get DEFAULT_TAG; installed Kit retains next/latest ordering.
+export const TAG_POLICY = { ruflo: 'latest', '@claude-flow/cli': 'latest' };
 export const DEFAULT_TAG = 'latest';
 
 // Resolve a package's TARGET version to the NEWEST of its candidate tags — the policy tag AND latest —
@@ -91,19 +94,10 @@ export const DEFAULT_TAG = 'latest';
 // 3.32.0 @alpha target, so it correctly refused to downgrade and never chased 3.32.7). Considering both
 // tags and taking the higher version fixes that in EITHER direction: alpha-leads → track alpha;
 // latest-leads → track latest. You are never left behind the newest thing rUv actually published.
-export function pickTargetTag(tags, want, defaultTag = DEFAULT_TAG) {
-  if (!tags) return { tag: null, target: null };
-  const candidates = [...new Set([want, defaultTag])].filter((t) => tags[t]);
-  let tag = null, target = null;
-  for (const t of candidates) {
-    if (target === null || cmpVersion(tags[t], target) > 0) { tag = t; target = tags[t]; }
-  }
-  return { tag, target };
-}
 
 // What counts as "the stack": an explicit allow-list pattern, not a loose scope match, so a stray
 // package can never be swept into a global install by accident.
-export const FAMILY = /^(ruflo|ruvector|ruvector-extensions|ruvi|ruvbot|qudag|flow-nexus|agent-browser|agent-browser-mcp|agentic-flow|agentic-qe|agentic-robotics|agentic-payments|ruv-swarm|@ruvector\/|@claude-flow\/|@metaharness\/|@agentic-robotics\/)/;
+
 
 // The plugin side of the same allow-list intent (ISSUE #22). Plugin identifiers are marketplace
 // names (`ruflo-core`, `ruvnet-brain`, `cog-beehive-monitor`), NOT npm package names, so FAMILY
@@ -114,7 +108,7 @@ export const FAMILY = /^(ruflo|ruvector|ruvector-extensions|ruvi|ruvbot|qudag|fl
 // stray third-party plugin can never be swept into the RuvNet stack by accident. FAMILY is still
 // applied as a secondary matcher, so a future rUv plugin shipped through a different marketplace is
 // still counted.
-export const PLUGIN_MARKETPLACES = new Set(['ruflo', 'ruview', 'ruvnet-brain', 'cognitum']);
+
 
 const log = (m) => console.log(m);
 const die = (m) => { console.error(`\n  FAILED: ${m}`); process.exit(1); };
@@ -123,30 +117,7 @@ const die = (m) => { console.error(`\n  FAILED: ${m}`); process.exit(1); };
 // Prerelease-aware per semver: a prerelease sorts BEFORE its release (3.28.0-alpha.1 < 3.28.0),
 // and numeric identifiers compare numerically — alpha.9 < alpha.10, which a string compare gets
 // backwards, and a string compare is precisely the bug this whole file exists to kill.
-export function cmpVersion(a, b) {
-  const split = (v) => {
-    const [core, pre] = String(v).split('-');
-    return [core.split('.').map((n) => parseInt(n, 10) || 0), pre ? pre.split('.') : null];
-  };
-  const [ac, ap] = split(a);
-  const [bc, bp] = split(b);
-  for (let i = 0; i < 3; i++) {
-    const d = (ac[i] || 0) - (bc[i] || 0);
-    if (d !== 0) return d < 0 ? -1 : 1;
-  }
-  if (!ap && !bp) return 0;
-  if (ap && !bp) return -1;
-  if (!ap && bp) return 1;
-  for (let i = 0; i < Math.max(ap.length, bp.length); i++) {
-    const x = ap[i], y = bp[i];
-    if (x === undefined) return -1;
-    if (y === undefined) return 1;
-    const nx = /^\d+$/.test(x), ny = /^\d+$/.test(y);
-    if (nx && ny) { const d = parseInt(x, 10) - parseInt(y, 10); if (d) return d < 0 ? -1 : 1; }
-    else if (x !== y) return x < y ? -1 : 1;
-  }
-  return 0;
-}
+
 export const isBehind = (installed, target) => cmpVersion(installed, target) < 0;
 
 export function installedVersion(pkg, lib = GLOBAL_LIB) {
@@ -219,7 +190,7 @@ function listInstalled({ lib = GLOBAL_LIB, pluginsDir = PLUGINS_DIR } = {}) {
 function registryTags(pkg) {
   const r = spawnSync('npm', ['view', pkg, 'dist-tags', '--json'], { encoding: 'utf8', timeout: 30000 });
   if (r.status !== 0 || !r.stdout) return null;
-  try { return JSON.parse(r.stdout); } catch { return null; }
+  try { return normalizeNpmDistTags(JSON.parse(r.stdout)); } catch { return null; }
 }
 
 // A second copy of a stack package in the npx cache can only ever SHADOW the global one.
@@ -251,13 +222,13 @@ export function findShadows(npxCache = NPX_CACHE, lib = GLOBAL_LIB) {
 // isBehind — this function assigns a state label, it does not compare versions itself except through
 // the single comparator. Extracted so audit() (CLI, may exit) and auditModel() (embedders, never
 // exits) share ONE classification, never two that can drift.
-export function classify(pkgs) {
+export function classify(pkgs, { channel = readDeveloperUpdateConfig().channel } = {}) {
   return pkgs.map((p) => {
     // Installed records prove presence, not marketplace currency.
     if (p.source === 'plugin') {
       return { ...p, tag: 'plugin', target: null, state: p.installed ? 'INSTALLED_UNVERIFIED' : 'BROKEN', evidence: 'local install record only; marketplace revision not checked' };
     }
-    const want = TAG_POLICY[p.name] || DEFAULT_TAG;
+    const want = p.name === '@pacphi/agentic-kit' ? 'next' : channel === 'alpha' && FAMILY.test(p.name) ? 'alpha' : DEFAULT_TAG;
     const tags = registryTags(p.name);
     // Newest of {policy tag, latest} — see pickTargetTag: "track @alpha" alone pinned the core behind
     // @latest on 2026-07-18. A package with no alpha tag falls through to latest.
@@ -348,95 +319,11 @@ function report({ rows, shadows, stale }) {
   return { behind: rows.filter((r) => r.state === 'BEHIND'), broken: rows.filter((r) => r.state === 'BROKEN'), stale };
 }
 
-function writeReceipt(a, installed, purged) {
-  fs.mkdirSync(path.dirname(RECEIPT), { recursive: true });
-  fs.writeFileSync(RECEIPT, JSON.stringify({
-    at: new Date().toISOString(), installed, purged,
-    packages: a.rows.map((r) => ({ name: r.name, version: r.installed, state: r.state })),
-  }, null, 2));
-}
-
-// EXCLUSIVE LOCK. (Adversarial review, 2026-07-14.) Nothing stopped the nightly job and a manual
-// run (or two Claude Code windows) from both running `npm install -g` on the same package at the
-// same instant. Two concurrent installs interleaving in one node_modules dir is how you get a
-// half-written package — which is almost certainly how @ruvector/edge-net ended up present-but-
-// versionless with an orphaned `sharp` inside it. O_EXCL is atomic; a stale lock from a crashed
-// run is reclaimed after 20 minutes (longer than the npm timeout).
-const LOCK = path.join(HOME, '.cache/ruvnet-brain/stack-sync.lock');
-function acquireLock() {
-  fs.mkdirSync(path.dirname(LOCK), { recursive: true });
-  try {
-    fs.writeFileSync(LOCK, JSON.stringify({ pid: process.pid, at: Date.now() }), { flag: 'wx' });
-  } catch (e) {
-    if (e.code !== 'EEXIST') throw e;
-    let held = {};
-    try { held = JSON.parse(fs.readFileSync(LOCK, 'utf8')); } catch { /* unparseable = stale */ }
-    const ageMin = (Date.now() - (held.at ?? 0)) / 60000;
-    if (ageMin < 20) {
-      die(`another stack-sync is running (pid ${held.pid}, started ${ageMin.toFixed(1)}m ago).\n` +
-          `   Refusing to run two installers at once — that is how packages get half-written.`);
-    }
-    fs.writeFileSync(LOCK, JSON.stringify({ pid: process.pid, at: Date.now() }));
-  }
-  const release = () => { try { fs.unlinkSync(LOCK); } catch { /* already gone */ } };
-  process.on('exit', release);
-  process.on('SIGINT', () => { release(); process.exit(130); });
-  process.on('SIGTERM', () => { release(); process.exit(143); });
-}
-
-function sync({ dryRun = false } = {}) {
-  if (!dryRun) acquireLock();
-  const a = audit();
-  const { behind, broken, stale } = report(a);
-  const toInstall = [...behind, ...broken.filter((r) => r.target)].map((r) => `${r.name}@${r.target}`);
-
-  if (!toInstall.length && !stale.length) {
-    log(`  No npm repair selected. Audit: ${JSON.stringify(summarizeAudit(a))}`);
-    if (!dryRun) writeReceipt(a, [], []);
-    process.exitCode = summarizeAudit(a).exitCode;
-    return;
-  }
-  if (dryRun) {
-    if (toInstall.length) log(`  would install: ${toInstall.join(' ')}`);
-    if (stale.length) log(`  would purge ${stale.length} stale npx shadow(s)`);
-    return;
-  }
-
-  // INSTALL FIRST, PURGE SECOND. (Adversarial review, 2026-07-14.) The first version purged the
-  // shadows before installing — so a failed install left the user with their shadows gone AND the
-  // global not yet fixed: strictly WORSE than when they started, with no way back. A repair step
-  // that can leave you worse off than not running it is not a repair.
-  if (toInstall.length) {
-    log(`  installing: ${toInstall.join(' ')}`);
-    const r = spawnSync('npm', ['install', '-g', '--prefix', PREFIX, ...toInstall],
-      { stdio: 'inherit', timeout: 15 * 60 * 1000 });
-    if (r.status !== 0) die(`npm install -g exited ${r.status}; the stack is NOT synced. Shadows left untouched.`);
-  }
-
-  const purged = [];
-  for (const s of stale) {
-    // Purge the whole npx dir: it is a disposable resolution cache (npm re-creates it on demand),
-    // and a mixed-version dir is exactly how a stale transitive copy survives a targeted delete.
-    try { fs.rmSync(s.dir, { recursive: true, force: true }); purged.push(`${s.name}@${s.version}`); } catch { /* best effort */ }
-  }
-  if (purged.length) log(`  purged ${purged.length} stale shadow(s): ${purged.join(', ')}`);
-
-  // VERIFY AGAINST THE DISK. An installer that trusts its own exit code is a hope, not a guarantee:
-  // the old nightly printed "auto-update finished cleanly" from npm's status alone, which is exactly
-  // how a stack rots while every log line insists it is healthy.
-  const wrong = [];
-  for (const r of [...behind, ...broken]) {
-    if (!r.target) continue;
-    const now = installedVersion(r.name);
-    if (now !== r.target) wrong.push(`${r.name}: expected ${r.target}, disk says ${now ?? 'MISSING'}`);
-  }
-  if (wrong.length) die(`npm reported success but THE DISK DISAGREES:\n   - ${wrong.join('\n   - ')}`);
-
-  const after = audit();
-  writeReceipt(after, toInstall, purged);
-  process.exitCode = summarizeAudit(after).exitCode;
-  log(`  Remaining audit: ${JSON.stringify(summarizeAudit(after))}`);
-  log(`\n  synced ${toInstall.length} package(s); purged ${purged.length} shadow(s); verified against disk.`);
+async function sync({ dryRun = false } = {}) {
+  const config = readDeveloperUpdateConfig();
+  const receipt = await runDeveloperUpdate({ mode: dryRun ? 'check' : 'apply', config });
+  log(`Coordinated update ${receipt.state}; ${receipt.steps.length} installed package owners checked.`);
+  if (receipt.coverage.notes.length) log(`Excluded or preserved: ${receipt.coverage.notes.join('; ')}`);
 }
 
 // Importable as a module by the tests; only acts when run as a CLI.
@@ -451,13 +338,13 @@ if (process.argv[1] && path.resolve(process.argv[1]).endsWith('stack-sync.mjs'))
     if (summary.shadows) log('  Cached copies are present; inspect invocation paths before removing any cache. No copies removed by audit.');
     process.exitCode = summary.exitCode;
   } else if (args.includes('--sync')) {
-    sync({ dryRun: args.includes('--dry-run') });
+    sync({ dryRun: args.includes('--dry-run') }).catch(error => { console.error(error.message); process.exitCode = 1; });
   } else {
     log(`
   stack-sync — one global copy of the RuvNet stack. Correct. Provable.
 
     --audit     report drift; exit 1 if anything is behind, broken, or shadowed
-    --sync      install what is BEHIND (never downgrades), purge npx shadows, verify against disk
+    --sync      update existing owners through the shared coordinator; cleanup is explicit
     --dry-run   with --sync: say what it would do, change nothing
 
   Tag policy: ${JSON.stringify(TAG_POLICY)}; everything else @${DEFAULT_TAG}