ruvnet-brain 4.5.17 → 4.6.0

package/plugin/scripts/automatic-update.mjs

@@ -5,6 +5,7 @@ import os from 'node:os';
 import path from 'node:path';
 import crypto from 'node:crypto';
 import { spawnSync } from 'node:child_process';
+import { developerCoordinatorOwner } from './developer-update-owner.mjs';
 import { SETTINGS_VERSION, validate, saveSettings } from './user-settings.mjs';
 
 export const ownerSettingsPath = (home = os.homedir()) => path.join(home, '.config', 'ruvnet-brain', 'settings.json');
@@ -44,7 +45,7 @@ export function saveUpdateSource(source, { home = os.homedir() } = {}) {
 }
 
 export function automaticPath({ nodePath = process.execPath, home = os.homedir(), platform = process.platform, env = process.env } = {}) {
-  const paths = [path.dirname(nodePath), path.join(home, '.npm-global', 'bin'), path.join(home, '.local', 'bin')];
+  const paths = [path.join(home, '.npm-global', 'bin'), path.dirname(nodePath), path.join(home, '.local', 'bin'), path.join(home, '.cargo', 'bin'), path.join(home, '.bun', 'bin')];
   if (platform === 'win32') {
     const system = env.SystemRoot || env.SYSTEMROOT;
     if (system && path.win32.isAbsolute(system)) paths.push(system, path.join(system, 'System32'));
@@ -91,8 +92,16 @@ export function installedUpdater({ home = os.homedir(), platform = process.platf
   return { entry, version: manifest.version, sha256 };
 }
 
-export function automaticInvocation(args, { source = updateSource(), home = os.homedir(), nodePath = process.execPath,
+export function automaticInvocation(args, { source, home = os.homedir(), nodePath = process.execPath,
   packageTarget = 'ruvnet-brain@latest' } = {}) {
+  if (packageTarget === 'ruvnet-brain@latest') {
+    const coordinator = developerCoordinatorOwner({ home });
+    if (coordinator.active) {
+      if (!coordinator.ready) throw new Error(`coordinated updater is not ready: ${coordinator.reason}`);
+      return { executable: nodePath, args: [coordinator.entry, '--apply'], source: 'developer-suite', coordinator };
+    }
+  }
+  source ??= updateSource({ home });
   if (source === 'installed') {
     if (packageTarget !== 'ruvnet-brain@latest') throw new Error('installed mode cannot select a proof tarball');
     const installed = installedUpdater({ home });

package/plugin/scripts/continuation-gate.mjs

@@ -392,7 +392,8 @@ function promiseBookkeeping() {
         if (!assistantCommitmentOwned(item, hookInput.session_id, projectIdentity)) continue;
         const claim = completion.claims.find((c) => claimClosesPromise(c.text, item.text));
         if (!claim) continue;
-        Object.assign(item, { done: true, state: 'completed', doneAt: at, completionEvidence: { claim: claim.text,
+        const verifiedCompletion = completion.verdict === 'PASS' && Boolean(claim);
+        Object.assign(item, { done: verifiedCompletion, state: verifiedCompletion ? 'completed' : item.state, doneAt: at, completionEvidence: { claim: claim.text,
           checks: completion.verification.checks.slice(-5).map((c) => c.what),
           transcript: String(hookInput.transcript_path || ''), sessionId: hookInput.session_id } });
         changed = true;

package/plugin/scripts/decision-gate.mjs

@@ -289,8 +289,6 @@ function payloadInput(payload) { return parsed(payload).tool_input || {}; }
 function speechEventFor(event) { return event === 'bash' ? 'PreToolUse-bash' : 'PreToolUse-write'; }
 
 // ── Runtime ──────────────────────────────────────────────────────────────────────────────────────
-
-
 if (isMain()) {
   const started = Date.now();
   const payload = normalizePayloadText(readPayload());
@@ -301,13 +299,11 @@ if (isMain()) {
   // "never speak on a guess", pointed at the other decision. 'write' is the only registered route
   // (H5 removed the dead 'bash' one — see the REGISTRY comment above), so it is the only exception.
   if (!selected.length && EVENT !== 'write') process.exit(ALLOW);
-
   const budgetMs = Number(process.env.RUVNET_DECISION_BUDGET_MS) || DEFAULT_BUDGET_MS;
   const deadline = Math.min(started + budgetMs, Number(process.env.RUVNET_DECISION_DEADLINE) || Infinity);
   // Resolved ONCE. On win32 resolveBash() can shell out to `where.exe`; four bash policies meant up
   // to four of those per tool call, for an answer that cannot change mid-invocation.
   BASH = resolveBash();
-
   const trace = [];            // one row per policy — surfaced by RUVNET_DECISION_TRACE=1
   const unconsulted = [];      // policies the budget cost us. NEVER silent; see reportBudget().
   const toolInput = payloadInput(payload);
@@ -317,7 +313,6 @@ if (isMain()) {
     if (why) trace.push({ id: p.id, ms: 0, skipped: why });
     else consulted.push(p);
   }
-
   // ── PARALLEL, and the reason is arithmetic ─────────────────────────────────────────────────────
   // Sequentially the gate's wall time was SUM(policies); run together it is MAX(policies). Measured
   // on a `git push` payload by the 2026-08-13 audit: 182 + 345 + 2145..3990 + 629 + 743 ≈ 4.0-5.9s
@@ -332,9 +327,7 @@ if (isMain()) {
   // A policy that exits SKIPPED (3) did not vote and said why (duplicate-gate under overload). Same
   // two channels as a blown budget, below — never silence standing in for a verdict.
   const selfSkipped = results.filter((r) => r.skipped === 'self');
-
   const decision = decide(verdicts);
-
   // Measurement follows the FINAL gate verdict; it must never delay a blocking producer.
   const measureFinalDecision = (allowed, policies = decision.refusals) => {
     const metricDeadline = Math.min(deadline, Date.now() + 25);
@@ -352,9 +345,7 @@ if (isMain()) {
       if (!allowed) recordRefusal({ session, key, policies: policies, ts, ...attribution, deadlineAt: metricDeadline, nonBlocking: true });
     }
   } catch { /* a ledger must never break a tool call */ }
-
   };
-
   reportSelfSkipped({ session, selfSkipped });
   if (decision.allow && shape.truncated) {
     // OVERSIZE POLICY (header): allowed on a check of the first TRANSPORT_CAP_BYTES only. Recorded, never silent.
@@ -366,7 +357,6 @@ if (isMain()) {
     process.stderr.write(`${decision.reason}\n`);
     process.exit(REFUSE);
   }
-
   // Nothing refused: run the speech chokepoint and forward its envelope verbatim. It owns its own
   // per-channel policy; this gate does not inspect or re-decide anything it says.
   //
@@ -397,7 +387,6 @@ if (isMain()) {
   if (context) process.stdout.write(context);
   process.exit(ALLOW);
 }
-
 /**
  * ── A BUDGET THAT CAN BE EXCEEDED SILENTLY FAILS OPEN WITHOUT SAYING SO ──────────────────────────
  *
@@ -431,7 +420,6 @@ function reportBudget({ session, unconsulted, trace, started, budgetMs, refused
     + `${unconsulted.join(', ')}. These policies did not vote; ${refused ? 'another policy refused the action.' : 'this allow is a timeout, not a verdict.'}\n`,
   );
 }
-
 /** Record and print each policy that skipped itself (exit 3), with its own one-line reason. */
 function reportSelfSkipped({ session, selfSkipped }) {
   for (const r of selfSkipped) {
@@ -439,7 +427,6 @@ function reportSelfSkipped({ session, selfSkipped }) {
     process.stderr.write(`[decision-gate] ${r.reason || `${r.id} skipped`} — ${r.id} did not vote; it supplied no authorization verdict.\n`);
   }
 }
-
 /**
  * Run one policy as a CAPTURED child. Never lets its bytes touch the real streams.
  *
@@ -466,7 +453,6 @@ function runPolicy(p, payload, deadline, extraArg, trace) {
   if (extraArg) args.push(extraArg);
   const left = deadline - Date.now();
   if (left <= 0) return Promise.resolve(done({ id: p.id, skipped: 'budget' }));
-
   return new Promise((resolve) => {
     let settled = false;
     let timer = null;
@@ -499,12 +485,10 @@ function runPolicy(p, payload, deadline, extraArg, trace) {
     try { child.stdin.end(payload); } catch { /* handled by the stdin error listener above */ }
   });
 }
-
 function readPayload() {
   if (process.stdin.isTTY) return '';
   try { return fs.readFileSync(0, 'utf8'); } catch { return ''; }
 }
-
 /** Never able to crash a caller that merely imported this (see tests/unit/entrypoint-guard-safety). */
 function isMain() {
   try {

package/plugin/scripts/developer-update-cleanup.mjs

@@ -0,0 +1,38 @@
+// Only closed, attributed npx installer entries qualify. Unknown/project/app/runtime trees never do.
+import fs from 'node:fs';
+import path from 'node:path';
+const INSTALLERS = new Set(['ruvnet-brain', 'ruflo']);
+export function cleanupNpxDuplicates({ home, globalRoot, enabled = false, run, active = null }) {
+  const root = path.join(home, '.npm/_npx'), result = { enabled, removed: [], retained: [] };
+  if (!fs.existsSync(root)) return result;
+  if (fs.realpathSync(root) !== path.resolve(root)) { result.retained.push({ directory: root, reason: 'cache root alias is unclassified' }); return result; }
+  for (const name of fs.readdirSync(root)) {
+    const directory = path.join(root, name);
+    if (!/^[a-f0-9]{16,64}$/.test(name) || !fs.lstatSync(directory).isDirectory() || fs.lstatSync(directory).isSymbolicLink()) continue;
+    if (fs.readdirSync(directory).some(entry => !['package.json', 'package-lock.json', 'node_modules'].includes(entry))) { result.retained.push({ directory, reason: 'unknown cache content' }); continue; }
+    let manifest;
+    try { manifest = JSON.parse(fs.readFileSync(path.join(directory, 'package.json'), 'utf8')); } catch { result.retained.push({ directory, reason: 'unknown installer identity' }); continue; }
+    const dependencies = Object.keys(manifest.dependencies || {});
+    if (!dependencies.length || dependencies.some(pkg => !INSTALLERS.has(pkg) || !fs.existsSync(path.join(globalRoot, pkg, 'package.json')))) continue;
+    if (!enabled) { result.retained.push({ directory, reason: 'cleanup disabled' }); continue; }
+    let busy = true;
+    try {
+      if (active) busy = active(directory);
+      else {
+        const processes = run('ps', ['-axo', 'command='], { timeout: 15_000 });
+        if (processes.includes(directory)) busy = true;
+        else {
+          // lsof exit 1 means no files; any other failure is unknown and retains the tree.
+          const opened = run('lsof', ['-nP', '+D', directory], { timeout: 15_000, allowed: [0, 1] });
+          busy = opened.trim().length > 0;
+        }
+      }
+    } catch { busy = true; }
+    if (busy) { result.retained.push({ directory, reason: 'live or unknown process/open-file owner' }); continue; }
+    // Recheck exact directory type and manifest bytes at the removal boundary.
+    const second = JSON.parse(fs.readFileSync(path.join(directory, 'package.json'), 'utf8'));
+    if (JSON.stringify(second) !== JSON.stringify(manifest) || fs.lstatSync(directory).isSymbolicLink()) throw Error('npx cleanup identity changed');
+    fs.rmSync(directory, { recursive: true }); result.removed.push({ directory, installers: dependencies });
+  }
+  return result;
+}

package/plugin/scripts/developer-update-lock.mjs

@@ -0,0 +1,30 @@
+// Directory ownership protocol shared with agentic-kit. Inherited children do not release the parent.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import crypto from 'node:crypto';
+const brainRoot = brainHome => brainHome || process.env.RUVNET_BRAIN_HOME || path.join(os.homedir(), '.cache/ruvnet-brain');
+export function sharedLockStatus({ brainHome, alive = pid => { try { process.kill(pid, 0); return true; } catch (e) { return e.code === 'EPERM'; } } } = {}) {
+  const directory = path.join(brainRoot(brainHome), 'developer-update.lock');
+  try {
+    if (!fs.lstatSync(directory).isDirectory() || fs.lstatSync(directory).isSymbolicLink()) throw Error('not an owned directory');
+    const owner = JSON.parse(fs.readFileSync(path.join(directory, 'owner.json'), 'utf8'));
+    if (!Number.isInteger(owner.pid) || owner.pid < 1 || typeof owner.token !== 'string' || owner.token.length < 16) throw Error('invalid owner');
+    return { state: alive(owner.pid) ? 'running' : 'stale', directory, owner };
+  } catch (error) { return { state: error.code === 'ENOENT' && !fs.existsSync(directory) ? 'idle' : 'unknown', directory, error: error.message }; }
+}
+export function acquireDeveloperLock({ brainHome, token = process.env.RUVNET_DEVELOPER_UPDATE_TOKEN, pid = process.pid, alive } = {}) {
+  const status = sharedLockStatus({ brainHome, alive });
+  if (token && status.state === 'running' && status.owner.token === token) return { token, ownerPid: status.owner.pid, inherited: true, release() {} };
+  if (status.state !== 'idle') throw Error(`developer update lock ${status.state}; ${status.directory}`);
+  fs.mkdirSync(path.dirname(status.directory), { recursive: true });
+  fs.mkdirSync(status.directory, { mode: 0o700 }); // atomic claim; racing owners get EEXIST
+  const owner = { pid, token: crypto.randomUUID(), startedAt: new Date().toISOString() };
+  try { fs.writeFileSync(path.join(status.directory, 'owner.json'), JSON.stringify(owner), { flag: 'wx', mode: 0o600 }); }
+  catch (error) { fs.rmdirSync(status.directory); throw error; }
+  return { token: owner.token, ownerPid: pid, inherited: false, release() {
+    const current = sharedLockStatus({ brainHome, alive });
+    if (current.owner?.token !== owner.token || current.owner?.pid !== pid) throw Error('developer update lock ownership changed');
+    fs.unlinkSync(path.join(status.directory, 'owner.json')); fs.rmdirSync(status.directory);
+  } };
+}

package/plugin/scripts/developer-update-maintenance.mjs

@@ -0,0 +1,178 @@
+// Explicitly enabled existing-owner stages. No cleanup, fresh installs or local-source conversion.
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { cmpVersion as compare } from './developer-update-policy.mjs';
+const HOME = os.homedir();
+const read = p => JSON.parse(fs.readFileSync(p, 'utf8'));
+function required(p) { fs.accessSync(p, fs.constants.X_OK); return p; }
+export function cargoInventory(root = path.join(HOME, '.cargo')) {
+  return Object.entries(read(path.join(root, '.crates2.json')).installs || {}).map(([key, value]) => {
+    const m = /^(\S+) (\S+) \(([^)]+)\)$/.exec(key);
+    if (!m) throw Error(`unattributable cargo install: ${key}`);
+    return { name: m[1], version: m[2], source: m[3], ...value };
+  });
+}
+export function uvInventory(root = path.join(HOME, '.local/share/uv/tools')) {
+  if (!fs.existsSync(root)) return [];
+  return fs.readdirSync(root).filter(name => fs.existsSync(path.join(root, name, 'uv-receipt.toml'))).map(name => {
+    const receipt = fs.readFileSync(path.join(root, name, 'uv-receipt.toml'), 'utf8');
+    // Only plain unpinned registry requirements qualify; wheels, paths, git and pins stay unchanged.
+    const registry = new RegExp(`requirements\\s*=\\s*\\[\\{\\s*name\\s*=\\s*"${name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}"\\s*\\}\\]`).test(receipt);
+    return { name, root: path.join(root, name), registry, receipt };
+  });
+}
+export function nativeOwnerPreserved(file, beforeTarget, afterTarget, home = HOME) {
+  if (afterTarget.split(path.sep).includes('node_modules')) return false;
+  if (beforeTarget === afterTarget) return true;
+  const standalone = path.join(home, '.codex/packages/standalone') + path.sep;
+  return file === path.join(home, '.local/bin/codex') && beforeTarget.startsWith(standalone) && afterTarget.startsWith(standalone);
+}
+export function verifyMaintenanceStage(commands, postconditions) {
+  const failures = Object.entries(postconditions).filter(([, passed]) => passed !== true).map(([name]) => name);
+  const commandFailures = commands.filter(command => command.exitCode !== 0 || command.error);
+  return { ok: failures.length === 0 && commandFailures.length === 0, postconditions, commandFailures, failures };
+}
+function commandOutput(run, command, args, options, stage) {
+  const result = run.receipt ? run.receipt(command, args, options) : run(command, args, options);
+  const exitCode = result?.exitCode ?? result?.status ?? result?.code;
+  const captured = { command, args, exitCode, error: result?.error || null, stdout: result?.stdout, stderr: result?.stderr || '' };
+  stage?.commands.push(captured);
+  if (!Number.isInteger(exitCode) || exitCode !== 0 || captured.error || typeof captured.stdout !== 'string') throw Error(`provider command failed or exit evidence absent: ${command} ${args[0]} (exit ${exitCode})`);
+  return captured.stdout;
+}
+function settleStage(stage, after, postconditions, fields = {}) {
+  const verification = verifyMaintenanceStage(stage.commands, postconditions);
+  Object.assign(stage, { after, verification, ...fields, state: verification.ok ? 'completed' : 'failed' });
+  if (!verification.ok) throw Error(`provider postconditions failed: ${stage.owner}: ${verification.failures.join(', ')}`);
+}
+export async function maintenance(config, run, dryRun, { home = HOME, brainHome, locate = () => null, node = process.execPath, progress = () => {} } = {}) {
+  const result = { stages: [], exclusions: [] };
+  progress(result);
+  for (const [name, enabled] of Object.entries(config)) {
+    if (!['schemaVersion', 'scope', 'channel', 'cleanup', 'preservePackages', 'homebrew', 'uv', 'cargo', 'native', 'managedCallback'].includes(name)) throw Error(`unknown maintenance flag: ${name}`);
+    if (['homebrew', 'uv', 'cargo', 'native'].includes(name) && typeof enabled !== 'boolean') throw Error(`maintenance flag must be boolean: ${name}`);
+  }
+  const uvTools = config.uv ? uvInventory(path.join(home, '.local/share/uv/tools')) : [];
+  const hasEntries = directory => { try { return fs.readdirSync(directory).length > 0; } catch { return false; } };
+  if (config.homebrew && !locate('brew') && [path.join(home, '.linuxbrew/Cellar'), '/opt/homebrew/Cellar', '/usr/local/Cellar', '/home/linuxbrew/.linuxbrew/Cellar'].some(hasEntries)) throw Error('installed Homebrew formulas have no existing Homebrew manager');
+  const cratesFile = path.join(home, '.cargo/.crates2.json');
+  if (uvTools.length && !locate('uv')) throw Error('installed uv tools have no existing uv manager');
+  if (config.cargo && fs.existsSync(cratesFile) && cargoInventory(path.dirname(cratesFile)).length && !locate('cargo')) throw Error('installed Cargo tools have no existing Cargo manager');
+  if (config.native) {
+    for (const [file, args] of [[path.join(home, '.bun/bin/bun'), ['upgrade']], [path.join(home, '.local/bin/uv'), ['self', 'update']],
+      [path.join(home, '.cargo/bin/rustup'), ['self', 'update']], [path.join(home, '.local/bin/codex'), ['update']]]) {
+      if (!fs.existsSync(file)) { result.exclusions.push(`native owner absent: ${file}`); continue; }
+      const resolved = fs.realpathSync(file);
+      if (resolved.split(path.sep).includes('node_modules')) { result.exclusions.push(`npm owns native alias: ${file}`); continue; }
+      required(file);
+      const owner = fs.realpathSync(file), stage = { owner: file, originalTarget: owner, state: 'running', commands: [] }; result.stages.push(stage);
+      const before = commandOutput(run, file, ['--version'], { timeout: 30_000 }, stage); stage.before = before;
+      if (!dryRun) commandOutput(run, file, args, { timeout: 900_000 }, stage);
+      const after = commandOutput(run, file, ['--version'], { timeout: 30_000 }, stage);
+      const version = text => text.match(/\b(\d+\.\d+\.\d+(?:-[\w.-]+)?)/)?.[1];
+      const versionVerified = !!version(before) && !!version(after) && compare(version(after), version(before)) >= 0;
+      // Native launchers may re-point to a newer version, but stay in the same established root.
+      const afterOwner = fs.realpathSync(file);
+      const ownerPreserved = nativeOwnerPreserved(file, owner, afterOwner, home);
+      settleStage(stage, after, { versionVerified, ownerPreserved }, { currentTarget: afterOwner });
+    }
+    const rustup = path.join(home, '.cargo/bin/rustup');
+    if (fs.existsSync(rustup)) {
+    const stage = { owner: 'rust-toolchains', commands: [], state: 'running' }; result.stages.push(stage);
+    const before = commandOutput(run, rustup, ['toolchain', 'list'], { timeout: 30_000 }, stage); stage.before = before;
+    const channels = before.split('\n').map(l => l.split(/\s/)[0]).filter(n => /^(stable|nightly)(-|$)/.test(n));
+    if (!dryRun) for (const channel of channels) commandOutput(run, rustup, ['update', channel, '--no-self-update'], { timeout: 1_800_000 }, stage);
+    const after = commandOutput(run, rustup, ['toolchain', 'list'], { timeout: 30_000 }, stage);
+    const names = text => text.split('\n').filter(Boolean).map(line => line.split(/\s/)[0]);
+    settleStage(stage, after, { toolchainsPreserved: names(before).every(name => names(after).includes(name)) }, { channels });
+    result.exclusions.push('Pinned Rust toolchains and all local-source builds preserved');
+    }
+  }
+  if (config.homebrew && locate('brew')) {
+    const brew = required(locate('brew'));
+    const stage = { owner: 'homebrew-formulas', commands: [], state: 'running' }; result.stages.push(stage);
+    const snapshot = () => JSON.parse(commandOutput(run, brew, ['info', '--json=v2', '--installed'], { timeout: 120_000 }, stage));
+    const before = snapshot(); stage.before = before;
+    if (!dryRun) {
+      // HOMEBREW_NO_INSTALL_CLEANUP also set in coordinator child environment.
+      commandOutput(run, brew, ['update'], { timeout: 600_000 }, stage);
+      commandOutput(run, brew, ['upgrade', '--formula'], { timeout: 3_600_000 }, stage);
+    }
+    const after = snapshot();
+    const names = x => x.formulae.map(f => f.full_name).sort();
+    const currencyChecked = after.formulae.every(formula => typeof formula.outdated === 'boolean');
+    const pinned = after.formulae.filter(formula => formula.pinned === true).map(formula => formula.full_name);
+    const outdated = after.formulae.filter(formula => formula.outdated === true && formula.pinned !== true).map(formula => formula.full_name);
+    settleStage(stage, after, { formulaOwnersPreserved: names(before).every(name => names(after).includes(name)) }, { currencyChecked, pinned, outdated,
+      currency: currencyChecked ? outdated.length ? 'updates-available' : 'manager-current' : 'unverified' });
+    if (!currencyChecked) result.exclusions.push('Homebrew execution verified; formula currency markers unavailable');
+    for (const formula of pinned) result.exclusions.push(`Homebrew pinned formula preserved: ${formula}`);
+    result.exclusions.push('Homebrew casks need their application-specific owner (VS Code is the managed callback)');
+  }
+  if (config.uv && locate('uv')) {
+    const uv = required(locate('uv'));
+    const before = uvInventory(path.join(home, '.local/share/uv/tools'));
+    const stage = { owner: 'uv-registry-tools', before, state: 'running', commands: [] }; result.stages.push(stage);
+    if (!dryRun) for (const tool of before) if (tool.registry) commandOutput(run, uv, ['tool', 'upgrade', tool.name], { timeout: 900_000 }, stage);
+    const after = uvInventory(path.join(home, '.local/share/uv/tools'));
+    if (JSON.stringify(before.map(t => t.name).sort()) !== JSON.stringify(after.map(t => t.name).sort())) throw Error('uv tool install set changed');
+    for (const tool of before.filter(t => !t.registry)) {
+      if (after.find(t => t.name === tool.name)?.receipt !== tool.receipt) throw Error(`uv source changed: ${tool.name}`);
+      result.exclusions.push(`uv source/pin preserved: ${tool.name}`);
+    }
+    // Provider's --outdated result is captured rather than asserting public registry currency for local wheels.
+    const currency = commandOutput(run, uv, ['tool', 'list', '--outdated'], { timeout: 180_000 }, stage);
+    settleStage(stage, after, { toolSetPreserved: JSON.stringify(before.map(t => t.name).sort()) === JSON.stringify(after.map(t => t.name).sort()),
+      sourceRequirementsPreserved: before.filter(t => !t.registry).every(t => after.find(a => a.name === t.name)?.receipt === t.receipt), currencyChecked: typeof currency === 'string' }, { currency });
+  }
+  if (config.cargo && fs.existsSync(path.join(home, '.cargo/.crates2.json')) && locate('cargo')) {
+    const root = path.join(home, '.cargo'), cargo = required(locate('cargo'));
+    const before = cargoInventory(root);
+    const stage = { owner: 'cargo-registry-tools', before, state: 'running', commands: [], targets: [] }; result.stages.push(stage);
+    for (const tool of before) {
+      if (tool.source !== 'registry+https://github.com/rust-lang/crates.io-index' || tool.version_req) {
+        result.exclusions.push(`Cargo source/pin preserved: ${tool.name}`); continue;
+      }
+      for (const bin of tool.bins) required(path.join(root, 'bin', bin));
+      const response = await fetch(`https://crates.io/api/v1/crates/${encodeURIComponent(tool.name)}`, { signal: AbortSignal.timeout(45_000), headers: { 'User-Agent': 'ruvnet-brain/developer-update' } });
+      if (!response.ok) throw Error(`Cargo registry HTTP ${response.status}`);
+      const metadata = await response.json();
+      const target = metadata.crate?.max_stable_version;
+      if (!target) throw Error(`Cargo release unverified: ${tool.name}`);
+      stage.targets.push({ name: tool.name, target, registryOk: response.ok });
+      if (!dryRun && compare(target, tool.version) > 0) {
+        const args = ['install', tool.name, '--force', '--root', root];
+        if (tool.all_features) args.push('--all-features');
+        if (tool.no_default_features) args.push('--no-default-features');
+        if (tool.features?.length) args.push('--features', tool.features.join(','));
+        if (tool.target) args.push('--target', tool.target);
+        commandOutput(run, cargo, args, { timeout: 3_600_000 }, stage);
+        const live = cargoInventory(root).find(t => t.name === tool.name);
+        if (!live || compare(live.version, target) < 0 || compare(live.version, tool.version) < 0) throw Error(`Cargo update not verified: ${tool.name}`);
+        for (const bin of tool.bins) required(path.join(root, 'bin', bin));
+      }
+    }
+    const after = cargoInventory(root);
+    for (const tool of before.filter(t => !t.source.startsWith('registry+'))) {
+      const live = after.find(t => t.name === tool.name);
+      if (!live || live.version !== tool.version || live.source !== tool.source) throw Error(`Cargo local source changed: ${tool.name}`);
+    }
+    settleStage(stage, after, { registryTargetsVerified: stage.targets.every(t => t.registryOk && (dryRun || compare(after.find(a => a.name === t.name)?.version || '', t.target) >= 0)),
+      sourcesPreserved: before.filter(t => !t.source.startsWith('registry+')).every(t => after.some(a => a.name === t.name && a.version === t.version && a.source === t.source)),
+      noDowngrade: before.every(t => after.some(a => a.name === t.name && compare(a.version, t.version) >= 0)) });
+  }
+  if (config.managedCallback) {
+    const file = config.managedCallback;
+    if (typeof file !== 'string' || !path.isAbsolute(file) || ![path.join(home, '.codex/scripts/'), path.join(brainHome || home, 'scripts/')].some(root => file.startsWith(root)) || !file.endsWith('.mjs')) throw Error('managed callback must be an existing Codex scripts .mjs owner');
+    required(file);
+    const stage = { owner: file, state: 'running', commands: [] }; result.stages.push(stage);
+    const receipt = JSON.parse(commandOutput(run, node, [file, dryRun ? '--check' : '--apply'], { timeout: 3_600_000 }, stage));
+    if (receipt.ok !== true || !receipt.before || !receipt.after) throw Error('managed callback did not prove success with source snapshots');
+    stage.before = receipt.before;
+    settleStage(stage, receipt.after, { callbackSnapshotsPresent: !!receipt.before && !!receipt.after, callbackVerified: receipt.ok === true }, { receipt });
+  }
+  for (const name of ['homebrew', 'uv', 'cargo']) if (config[name] && !result.stages.some(s => s.owner.startsWith(name === 'homebrew' ? 'homebrew' : name))) result.exclusions.push(`${name} has no existing attributable owner/tool inventory`);
+  for (const name of ['homebrew', 'uv', 'cargo', 'native']) if (!config[name]) result.exclusions.push(`${name} maintenance disabled`);
+  return result;
+}

package/plugin/scripts/developer-update-owner.mjs

@@ -0,0 +1,24 @@
+// A configured coordinator owns automatic mutation. Its immutable scheduler module is the real door.
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import crypto from 'node:crypto';
+import { EXECUTION_MODULES } from './developer-update-policy.mjs';
+const hash = file => crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');
+export function developerCoordinatorOwner({ home = os.homedir(), brainHome = process.env.RUVNET_BRAIN_HOME || path.join(home, '.cache/ruvnet-brain') } = {}) {
+  const config = path.join(brainHome, 'developer-update-config.json'), registration = path.join(brainHome, 'scheduler/registration.json');
+  let record;
+  try { record = JSON.parse(fs.readFileSync(registration, 'utf8')); } catch { /* handled below */ }
+  const configured = fs.existsSync(config) || record?.mode === 'developer-suite';
+  if (!configured) return { active: false, ready: false };
+  const entry = record?.updateModules?.['developer-update.mjs'];
+  try {
+    if (record?.mode !== 'developer-suite' || !path.isAbsolute(entry?.path || '') || !/^[a-f0-9]{64}$/.test(entry?.sha256 || '')
+      || hash(entry.path) !== entry.sha256 || hash(record.runnerPath) !== record.runnerSha256) throw Error('registered source is absent or changed');
+    if (!record.updateModules?.['plugin-artifact-proof.mjs'] && fs.readFileSync(entry.path, 'utf8').includes('./plugin-artifact-proof.mjs')) throw Error('new coordinator artifact closure is incomplete');
+    const generation = EXECUTION_MODULES.filter(name => name !== 'plugin-artifact-proof.mjs' || record.updateModules?.[name]);
+    if (generation.some(name => !record.updateModules?.[name])) throw Error('coordinator execution closure is incomplete');
+    for (const module of Object.values(record.updateModules)) if (hash(module.path) !== module.sha256) throw Error('registered module closure changed');
+    return { active: true, ready: true, entry: entry.path, node: record.nodePath, registration, sourceSha256: entry.sha256 };
+  } catch (error) { return { active: true, ready: false, reason: error.message }; }
+}

package/plugin/scripts/developer-update-policy.mjs

@@ -0,0 +1,48 @@
+export const EXECUTION_MODULES = Object.freeze(['developer-update.mjs', 'developer-update-policy.mjs', 'developer-update-lock.mjs', 'developer-update-maintenance.mjs', 'developer-update-cleanup.mjs', 'plugin-artifact-proof.mjs']);
+// Shared stack classification and ordering: installations are selected, never manufactured.
+export const FAMILY = /^(ruflo|ruvnet-brain|ruvector|ruvector-extensions|ruvi|ruvbot|qudag|flow-nexus|agent-browser|agent-browser-mcp|agentic-flow|agentic-qe|agentic-robotics|agentic-payments|agentdb|ruv-swarm|@pacphi\/agentic-kit$|@ruvector\/|@claude-flow\/|@metaharness\/|@agentic-robotics\/)/;
+export const PLUGIN_MARKETPLACES = new Set(['ruflo', 'ruview', 'ruvnet-brain', 'cognitum']);
+export const REVIEWED_INSTALL_SCRIPTS = Object.freeze(['ruflo', 'agentic-qe', '@claude-flow/cli', 'better-sqlite3', 'hnswlib-node', 'agentdb', 'agentic-flow', 'argon2', 'onnxruntime-node', 'sharp', 'protobufjs', '@google/genai', 'tldjs', 'vibium', 'agent-browser', '@anthropic-ai/claude-code', 'opencode-ai']);
+export function cmpVersion(a, b) {
+  const parse = value => {
+    const m = /^(\d+)\.(\d+)\.(\d+)(?:-([\w.-]+))?(?:\+[\w.-]+)?$/.exec(value);
+    if (!m) throw Error(`uncomparable version: ${value}`);
+    return [m.slice(1, 4).map(Number), m[4]?.split('.')];
+  };
+  const [ac, ap] = parse(a), [bc, bp] = parse(b);
+  for (let i = 0; i < 3; i++) if (ac[i] !== bc[i]) return Math.sign(ac[i] - bc[i]);
+  if (!ap || !bp) return ap ? -1 : bp ? 1 : 0;
+  for (let i = 0; i < Math.max(ap.length, bp.length); i++) {
+    if (ap[i] === undefined || bp[i] === undefined) return ap[i] === undefined ? -1 : 1;
+    if (ap[i] === bp[i]) continue;
+    const an = /^\d+$/.test(ap[i]), bn = /^\d+$/.test(bp[i]);
+    return an && bn ? Math.sign(Number(ap[i]) - Number(bp[i])) : an !== bn ? an ? -1 : 1 : ap[i] < bp[i] ? -1 : 1;
+  }
+  return 0;
+}
+export function normalizeNpmDistTags(value) {
+  // npm 11 emits an object for a queried field; npm 12 retains its singleton record array.
+  if (Array.isArray(value)) {
+    if (value.length !== 1) throw Error('npm dist-tags has ambiguous or empty records');
+    [value] = value;
+  }
+  if (!value || typeof value !== 'object' || Array.isArray(value)
+    || !Object.keys(value).length || Object.values(value).some(version => typeof version !== 'string' || !version)) {
+    throw Error('npm dist-tags record is unverified');
+  }
+  return value;
+}
+export function pickTargetTag(tags, want = 'latest', defaultTag = 'latest') {
+  const candidates = [...new Set([want, defaultTag])].filter(tag => typeof tags?.[tag] === 'string');
+  candidates.sort((a, b) => cmpVersion(tags[b], tags[a]));
+  return { tag: candidates[0] || null, target: tags?.[candidates[0]] || null };
+}
+export function selectTag(name, current, tags, channel = 'latest') {
+  if (!['latest', 'alpha'].includes(channel)) throw Error('unsupported update channel');
+  // Kit's installed release contract uses next; never convert it to an npm alpha alias.
+  tags = normalizeNpmDistTags(tags);
+  const wanted = name === '@pacphi/agentic-kit' ? 'next' : FAMILY.test(name) && channel === 'alpha' ? 'alpha' : 'latest';
+  const { tag, target: version } = pickTargetTag(tags, wanted);
+  if (!tag) throw Error(`no allowed release tag: ${name}`);
+  return { tag, version, upgrade: cmpVersion(version, current) > 0, ahead: cmpVersion(version, current) < 0 };
+}