ruvnet-brain 4.5.4 → 4.5.5

package/scripts/release-qualification-contract.mjs

@@ -47,6 +47,39 @@ export const RELEASE_REQUIREMENTS = Object.freeze({
         "tests/unit/forge-update-apply-rollback.test.mjs"
       ]
     },
+    {
+      "id": "approved-native-routing",
+      "reason": "Current owner allocations, classification floors, native model and effort support, subscription auth and ordinary allowance gate actual stdin dispatch without expanding spend",
+      "files": [
+        "tests/unit/model-router-engine.test.mjs",
+        "tests/unit/model-router-enforcement.test.mjs",
+        "tests/unit/native-subscription-usage.test.mjs",
+        "tests/unit/model-router-agent-hook.test.mjs"
+      ]
+    },
+    {
+      "id": "same-session-native-transport",
+      "reason": "Codex and Claude native JSONL preserve context, UTF-8, control progress, cancellation and deferred FIFO while binding each new turn to an approved native route",
+      "files": [
+        "tests/unit/model-routing-gateway.test.mjs",
+        "tests/unit/model-routing-launchers.test.mjs"
+      ]
+    },
+    {
+      "id": "weekly-routing-evidence",
+      "reason": "Weekly native dispatch requires allowance and trusted tool denial; bounded completions, source fencing and qualified promotion preserve original owner approval and reject requested-only identity",
+      "files": [
+        "tests/unit/model-weekly-assessment.test.mjs",
+        "tests/unit/model-weekly-analyst.test.mjs",
+        "tests/unit/model-weekly-cycle.test.mjs",
+        "tests/unit/model-weekly-qualification.test.mjs",
+        "tests/unit/model-native-qualification.test.mjs",
+        "tests/unit/model-native-catalog.test.mjs",
+        "tests/unit/user-model-prompt-hook.test.mjs",
+        "tests/unit/model-routing-policy-promotion.test.mjs",
+        "tests/unit/codex-hook-trust.test.mjs"
+      ]
+    },
     {
       "id": "native-scheduler",
       "reason": "Owned scheduler lifecycle, execution identity, measured no-op and signed installed coverage",
@@ -135,6 +168,14 @@ export const RELEASE_REQUIREMENTS = Object.freeze({
         "tests/integration/build-bundle-fence.test.mjs"
       ]
     },
+    {
+      "id": "installed-routing-and-hook-trust",
+      "reason": "Actual installer update converges managed routing while preserving private overrides; POSIX archive and native metadata subprocess probes bind authorized hook trust to verified released bytes and preserve concurrent or disabled owner state",
+      "files": [
+        "tests/unit/model-router-update-convergence.test.mjs",
+        "tests/unit/codex-hook-trust-reconcile.test.mjs"
+      ]
+    },
     {
       "id": "native-codex-discovery",
       "reason": "Actual Codex plugin discovery and repair preserve explicit disabled state",

package/scripts/security-guidance-codex-compat.mjs

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+/**
+ * Explicit local repair for the Codex cache copy of security-guidance 2.0.9.
+ * Dry run by default; --apply is required. No plugin trust/settings changes.
+ * Codex 0.160.0's installed post-tool-use.command.output rejects metrics and
+ * rewakeSummary; its parser also rejects updatedMCPToolOutput semantically.
+ * This source-bound patch routes telemetry to the plugin's existing debug log,
+ * preserves security controls/context, and leaves other events/review logic intact.
+ * Future versions or different source bytes require a new reviewed compatibility
+ * patch. A successful repair is not native execution evidence or future-update support.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import crypto from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+
+export const COMPATIBILITY = Object.freeze({
+  version: '2.0.9', nativeContract: 'Codex 0.160.0 PostToolUse',
+  originalSha256: '2766399e43bd923ed786f8bb0fcbf6d2055b3ad4ef79ec73f722be19122de1f8',
+  patchedSha256: '4bba541507b54b6b1f882ac13d49be9b8ea865b4e3dc3fd870820a3b48749de1',
+  patchSha256: '49f0c628775d9b12a5b50ea5d3072a031c3a2e986fee050dd80f46c044677a35',
+});
+const PATCH = fileURLToPath(new URL('../config/hook-compat/security-guidance-2.0.9.patch', import.meta.url));
+const sha256 = (bytes) => crypto.createHash('sha256').update(bytes).digest('hex');
+const noFollow = fs.constants.O_NOFOLLOW;
+
+function requireRegularPath(file) {
+  let current = path.parse(file).root;
+  for (const segment of file.slice(current.length).split(path.sep)) {
+    current = path.join(current, segment);
+    const stat = fs.lstatSync(current);
+    if (stat.isSymbolicLink()) throw new Error(`Refusing symlink: ${current}`);
+    if (current !== file && !stat.isDirectory()) throw new Error(`Not a directory: ${current}`);
+    if (current === file && !stat.isFile()) throw new Error(`Not a regular file: ${file}`);
+  }
+}
+
+function readRegular(file) {
+  requireRegularPath(file);
+  if (noFollow === undefined) throw new Error('O_NOFOLLOW is required for this repair');
+  const fd = fs.openSync(file, fs.constants.O_RDONLY | noFollow);
+  try {
+    const stat = fs.fstatSync(fd);
+    if (!stat.isFile()) throw new Error(`Not a regular file: ${file}`);
+    return { bytes: fs.readFileSync(fd), stat };
+  } finally { fs.closeSync(fd); }
+}
+
+/** Apply only the checked-in exact-context hunks, without invoking patch/git/Python. */
+export function applyCompatibilityPatch(original) {
+  const patch = readRegular(PATCH).bytes;
+  if (sha256(patch) !== COMPATIBILITY.patchSha256) throw new Error('Compatibility patch digest mismatch');
+  if (sha256(original) !== COMPATIBILITY.originalSha256) throw new Error('Original source digest mismatch');
+  const source = original.toString('utf8').split('\n');
+  const lines = patch.toString('utf8').split('\n');
+  const result = [];
+  let cursor = 0;
+  for (let i = 2; i < lines.length; i++) {
+    const header = /^@@ -(\d+),(\d+) \+(\d+),(\d+) @@/.exec(lines[i]);
+    if (!header) { if (!lines[i]) continue; throw new Error('Unexpected patch structure'); }
+    const start = Number(header[1]) - 1;
+    if (start < cursor) throw new Error('Overlapping patch hunks');
+    result.push(...source.slice(cursor, start)); cursor = start;
+    let oldCount = 0; let newCount = 0;
+    while (i + 1 < lines.length && !lines[i + 1].startsWith('@@ ') && lines[i + 1] !== '') {
+      const line = lines[++i]; const type = line[0]; const content = line.slice(1);
+      if (![' ', '-', '+'].includes(type)) throw new Error('Unsupported patch line');
+      if (type !== '+') {
+        if (source[cursor++] !== content) throw new Error('Compatibility patch context mismatch');
+        oldCount++;
+      }
+      if (type !== '-') { result.push(content); newCount++; }
+    }
+    if (oldCount !== Number(header[2]) || newCount !== Number(header[4])) throw new Error('Patch hunk count mismatch');
+  }
+  result.push(...source.slice(cursor));
+  const patched = Buffer.from(result.join('\n'));
+  if (sha256(patched) !== COMPATIBILITY.patchedSha256) throw new Error('Patched source digest mismatch');
+  return patched;
+}
+
+function syncDirectory(dir) {
+  const fd = fs.openSync(dir, fs.constants.O_RDONLY | noFollow);
+  try { fs.fsyncSync(fd); } finally { fs.closeSync(fd); }
+}
+
+export function repairSecurityGuidance({ codexHome = process.env.CODEX_HOME || path.join(os.homedir(), '.codex'), apply = false } = {}) {
+  if (!path.isAbsolute(codexHome) || path.normalize(codexHome).split(path.sep).includes('.claude')) {
+    throw new Error('An absolute Codex home is required; Claude cache repair is forbidden');
+  }
+  const target = path.join(codexHome, 'plugins/cache/claude-plugins-official/security-guidance', COMPATIBILITY.version, 'hooks/security_reminder_hook.py');
+  const original = readRegular(target);
+  const digest = sha256(original.bytes);
+  const receipt = { target, compatibility: COMPATIBILITY, sourceSha256: digest, apply, status: 'dry-run' };
+  if (digest === COMPATIBILITY.patchedSha256) return { ...receipt, status: 'already-patched' };
+  if (digest !== COMPATIBILITY.originalSha256) throw new Error(`Unknown security-guidance source: ${digest}; refusing to patch ${target}`);
+  const patched = applyCompatibilityPatch(original.bytes);
+  if (!apply) return receipt;
+  const dir = path.dirname(target);
+  const backup = `${target}.${COMPATIBILITY.originalSha256}.original`;
+  let fd;
+  try {
+    fd = fs.openSync(backup, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL | noFollow, 0o600);
+    fs.writeFileSync(fd, original.bytes);
+    fs.fchmodSync(fd, (original.stat.mode & 0o444) || 0o400);
+    fs.fsyncSync(fd);
+  } catch (error) {
+    if (error.code !== 'EEXIST') throw error;
+    if (sha256(readRegular(backup).bytes) !== digest) throw new Error('Existing immutable backup digest mismatch');
+  } finally { if (fd !== undefined) fs.closeSync(fd); }
+  syncDirectory(dir);
+  const temporary = path.join(dir, `.security-guidance-compat-${crypto.randomUUID()}.tmp`);
+  try {
+    fd = fs.openSync(temporary, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL | noFollow, 0o600);
+    try {
+      fs.writeFileSync(fd, patched);
+      fs.fchmodSync(fd, original.stat.mode & 0o777);
+      fs.fsyncSync(fd);
+    } finally { fs.closeSync(fd); }
+    const current = readRegular(target);
+    if (current.stat.dev !== original.stat.dev || current.stat.ino !== original.stat.ino || sha256(current.bytes) !== digest) {
+      throw new Error('Plugin source changed during repair; refusing replacement');
+    }
+    fs.renameSync(temporary, target);
+    syncDirectory(dir);
+  } finally { if (fs.existsSync(temporary)) fs.unlinkSync(temporary); }
+  return { ...receipt, status: 'patched', backup, patchedSha256: sha256(readRegular(target).bytes) };
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  try {
+    const args = process.argv.slice(2);
+    let codexHome; let apply = false;
+    for (let i = 0; i < args.length; i++) {
+      if (args[i] === '--apply') apply = true;
+      else if (args[i] === '--codex-home' && args[i + 1]) codexHome = args[++i];
+      else throw new Error(`Unknown argument: ${args[i]}`);
+    }
+    console.log(JSON.stringify(repairSecurityGuidance({ codexHome, apply }), null, 2));
+  } catch (error) { console.error(error.message); process.exitCode = 1; }
+}

package/scripts/user-model-prompt-hook.mjs

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+// Per-user prompt guidance. Execution is enforced separately by the managed dispatcher.
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { spawnSync } from 'node:child_process';
+import { pathToFileURL } from 'node:url';
+import { maybeLaunchWeeklyCycle } from './model-weekly-cycle.mjs';
+
+export const PRESENTATION = 'For terminal briefings: give concise executive status; use narrow padded ASCII tables with borders, plain cell text, aligned columns and short rows. Never send pipe-delimited Markdown tables to this terminal. Use short lists when a table would wrap. Do not flood the response with commands or technical logs.';
+
+export function promptContext(payload, { routerDir = path.join(os.homedir(), '.claude/model-router'), run = spawnSync, now = Date.now(), cycle = maybeLaunchWeeklyCycle } = {}) {
+  const lines = [PRESENTATION];
+  const weekly = cycle({ routerDir, now });
+  if (weekly.status === 'current' && weekly.reviewRequired === false) lines.push(`Weekly model-release check current (${weekly.checkedAt}); retain the approved policy. Full assessment runs only for newly discovered OpenAI or Anthropic models. This is not a semantic-review or promotion claim.`);
+  else if (weekly.launched) lines.push(weekly.reviewRequired
+    ? 'A new model release requires assessment; the bounded review is pending and the approved policy remains active.'
+    : 'A lightweight weekly model-release check started; no full assessment is required unless a new relevant model is found.');
+  else if (weekly.status === 'blocked') lines.push(`Weekly model-release check needs attention: ${weekly.reason || 'verification unavailable'}. Retain the approved policy; do not claim no changes or a completed review.`);
+  const harness = payload?.host === 'claude-code' ? 'claude-code' : 'codex';
+  const prompt = typeof payload?.prompt === 'string' ? payload.prompt : '';
+  let policy;
+  try { policy = JSON.parse(fs.readFileSync(path.join(routerDir, 'routing-policy.json'), 'utf8')); } catch { /* report absence below */ }
+  const reviewed = Date.parse(policy?.reviewedAt);
+  const age = now - reviewed;
+  const configuredMaxAge = policy?.maxAgeMs ?? 604800000;
+  const maxAge = Math.min(configuredMaxAge, 604800000);
+  const current = policy?.schemaVersion === 1 && Number.isSafeInteger(configuredMaxAge) && configuredMaxAge > 0 && Number.isFinite(reviewed) && age >= 0;
+  if (current && age > maxAge) lines.push('Policy approval is older than seven days. Retain the owner-approved allocation and its original date; verify native availability before every launch. Age alone does not trigger reassessment.');
+  lines.push(current ? `Model routing policy reviewed ${policy.reviewedAt}; consult this user's policy for every delegated launch.` : 'Model routing policy is missing or invalid. Establish a valid approved policy before managed dispatch.');
+  if (current && prompt && prompt.length <= 65536) {
+    const engine = path.join(routerDir, 'bin/model-router-engine.mjs');
+    const result = run(process.execPath, [engine, '--harness', harness, '--policy-only', '--json'], {
+      input: prompt, encoding: 'utf8', timeout: 1500, maxBuffer: 16384,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    try {
+      const route = JSON.parse(result.stdout || '');
+      if (result.status === 0 && /^[a-zA-Z0-9._-]+$/.test(route.model || '') && ['low', 'medium', 'high', 'xhigh', 'max'].includes(route.effort)) {
+        lines.push(`This prompt's managed route: ${route.model}, effort ${route.effort}. Use the managed dispatcher for actual launch enforcement. This hook supplies context; it does not switch the active parent model.`);
+      } else lines.push('Prompt routing was not verified; do not infer an automatic model switch.');
+    } catch { lines.push('Prompt routing was not verified; do not infer an automatic model switch.'); }
+  }
+  return lines.join('\n');
+}
+
+export function envelope(context) {
+  return { hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext: context } };
+}
+
+async function main() {
+  let input = '';
+  const timer = setTimeout(() => process.stdin.destroy(), 1000);
+  try {
+    for await (const chunk of process.stdin) {
+      input += chunk;
+      if (input.length > 65536) { input = ''; break; }
+    }
+  } catch { /* fail open with presentation guidance */ }
+  clearTimeout(timer);
+  let payload = {};
+  try { payload = JSON.parse(input); } catch { /* malformed input never launches a model */ }
+  if (process.argv.includes('--claude')) payload.host = 'claude-code';
+  process.stdout.write(JSON.stringify(envelope(promptContext(payload))) + '\n');
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href) {
+  main().catch(() => process.stdout.write(JSON.stringify(envelope(PRESENTATION)) + '\n'));
+}