ruvnet-brain 3.9.85-dev → 3.9.129-dev

package/scripts/dual-host-deliberation.mjs

@@ -0,0 +1,284 @@
+#!/usr/bin/env node
+
+import { createHash } from 'node:crypto';
+import { spawn, spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { probeSubscriptionHosts, subscriptionOnlyEnv } from './subscription-hosts.mjs';
+
+const HOSTS = Object.freeze(['claude-code', 'codex']);
+const HARD_PROBLEM = /\b(adr|architecture|architect|ddd|bounded context|aggregate|agentic[- ]?qe|holistic|security|production|migration|irreversible|threat model|experience)\b/i;
+
+export function hardProblem(task) {
+  return HARD_PROBLEM.test(String(task));
+}
+
+export function chooseRoles(task) {
+  const firstByte = createHash('sha256').update(String(task)).digest()[0];
+  const scribe = HOSTS[firstByte % HOSTS.length];
+  return {
+    scribe,
+    verifier: HOSTS.find((host) => host !== scribe),
+  };
+}
+
+function hostKey(host) {
+  return host === 'claude-code' ? 'claude' : 'codex';
+}
+
+function promptFor(stage, payload) {
+  return [
+    'You are one half of a subscription-only Claude Code and Codex deliberation.',
+    'Do not request or use API keys. Work read-only. Return JSON only.',
+    `Stage: ${stage}`,
+    JSON.stringify(payload),
+  ].join('\n');
+}
+
+function parseCodexJsonl(stdout) {
+  const messages = String(stdout).trim().split('\n').flatMap((line) => {
+    try {
+      const value = JSON.parse(line);
+      return value.type === 'item.completed' && value.item?.type === 'agent_message'
+        ? [value.item.text]
+        : [];
+    } catch {
+      return [];
+    }
+  });
+  return messages.at(-1) ?? stdout;
+}
+
+function parseHostValue(host, stdout) {
+  const raw = host === 'claude-code'
+    ? (() => {
+        try {
+          const envelope = JSON.parse(stdout);
+          return envelope.result ?? envelope;
+        } catch {
+          return stdout;
+        }
+      })()
+    : parseCodexJsonl(stdout);
+  if (typeof raw !== 'string') return raw;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return { text: raw };
+  }
+}
+
+function spawnHost(binary, args, options) {
+  return new Promise((resolve) => {
+    const child = spawn(binary, args, options);
+    let stdout = '';
+    let stderr = '';
+    child.stdout.on('data', (chunk) => { stdout += chunk; });
+    child.stderr.on('data', (chunk) => { stderr += chunk; });
+    child.on('error', (error) => resolve({ status: null, stdout, stderr: error.message }));
+    child.on('close', (status) => resolve({ status, stdout, stderr }));
+  });
+}
+
+export async function runSubscriptionHost(host, stage, payload, { cwd = process.cwd() } = {}) {
+  const prompt = promptFor(stage, payload);
+  const env = subscriptionOnlyEnv();
+  const command = host === 'claude-code'
+    ? {
+        binary: 'claude',
+        args: [
+          '-p', '--output-format', 'json', '--permission-mode', 'plan',
+          '--tools', 'Read,Grep,Glob', '--no-session-persistence', '--effort', 'high', prompt,
+        ],
+      }
+    : {
+        binary: 'codex',
+        args: [
+          'exec', '--ephemeral', '--sandbox', 'read-only', '--color', 'never', '--json',
+          '-m', 'gpt-5.6-sol', '-c', 'model_reasoning_effort="high"', prompt,
+        ],
+      };
+  const result = await spawnHost(command.binary, command.args, { cwd, env, stdio: ['ignore', 'pipe', 'pipe'] });
+  if (result.status !== 0) {
+    return {
+      ok: false,
+      reason: /limit|quota|capacity|usage/i.test(result.stderr)
+        ? 'capacity-limited'
+        : 'host-failed',
+    };
+  }
+  return { ok: true, value: parseHostValue(host, result.stdout) };
+}
+
+export async function persistDeliberationReceipt(receipt, {
+  cwd = process.cwd(),
+  now = Date.now,
+  run = spawnSync,
+} = {}) {
+  const recordedAt = now();
+  const value = {
+    protocol: receipt.protocol,
+    taskHash: receipt.taskHash,
+    hosts: receipt.hosts,
+    roles: receipt.roles,
+    accepted: receipt.accepted === true,
+    verifiedOutcome: receipt.accepted === true,
+    recordedAt: new Date(recordedAt).toISOString(),
+  };
+  const key = `dual-deliberation-${recordedAt}-${receipt.taskHash.slice(0, 12)}`;
+  const result = run('ruflo', [
+    'memory', 'store',
+    '-k', key,
+    '--value', JSON.stringify(value),
+    '--namespace', 'ruvnet-brain',
+    '--path', '.swarm/memory.db',
+    '--no-upsert',
+    '--scan-content',
+  ], {
+    cwd,
+    encoding: 'utf8',
+    env: subscriptionOnlyEnv(),
+    timeout: 15_000,
+  });
+  return result?.status === 0;
+}
+
+function missingHosts(probes) {
+  return HOSTS.filter((host) => !probes[hostKey(host)]?.eligible);
+}
+
+async function singleHostDraft(task, host, context) {
+  const draft = await context.runHost(host, 'proposal', { task, cwd: context.cwd });
+  return {
+    status: draft.ok ? 'degraded' : 'unavailable',
+    dual: false,
+    missing: HOSTS.filter((candidate) => candidate !== host),
+    draft: draft.ok ? draft.value : undefined,
+    learningPersisted: false,
+    verifiedOutcome: false,
+  };
+}
+
+export async function deliberate(task, options = {}) {
+  const probes = options.probes ?? probeSubscriptionHosts();
+  const runHost = options.runHost ?? ((host, stage, payload) => (
+    runSubscriptionHost(host, stage, payload, { cwd: options.cwd })
+  ));
+  const cwd = options.cwd ?? process.cwd();
+  const persist = options.persist ?? ((receipt) => persistDeliberationReceipt(receipt, { cwd }));
+  const eligibleHosts = HOSTS.filter((host) => probes[hostKey(host)]?.eligible);
+
+  if (eligibleHosts.length === 0) {
+    return {
+      status: 'unavailable',
+      dual: false,
+      missing: missingHosts(probes),
+      learningPersisted: false,
+      verifiedOutcome: false,
+    };
+  }
+  if (eligibleHosts.length === 1) {
+    return singleHostDraft(task, eligibleHosts[0], { cwd, runHost });
+  }
+
+  const proposalResults = await Promise.all(HOSTS.map((host) => (
+    runHost(host, 'proposal', { task, cwd })
+  )));
+  const successfulProposals = HOSTS.flatMap((host, index) => (
+    proposalResults[index].ok ? [{ host, value: proposalResults[index].value }] : []
+  ));
+  if (successfulProposals.length < 2) {
+    const host = successfulProposals[0]?.host;
+    if (!host) {
+      return {
+        status: 'unavailable',
+        dual: false,
+        missing: HOSTS,
+        learningPersisted: false,
+        verifiedOutcome: false,
+      };
+    }
+    return {
+      status: 'degraded',
+      dual: false,
+      missing: HOSTS.filter((candidate) => candidate !== host),
+      draft: successfulProposals[0].value,
+      learningPersisted: false,
+      verifiedOutcome: false,
+    };
+  }
+
+  const proposals = Object.fromEntries(successfulProposals.map(({ host, value }) => [host, value]));
+  const critiques = Object.fromEntries(await Promise.all(HOSTS.map(async (host) => {
+    const other = HOSTS.find((candidate) => candidate !== host);
+    const result = await runHost(host, 'critique', { task, proposal: proposals[other] });
+    return [host, result.ok ? result.value : { unavailable: true }];
+  })));
+  const roles = chooseRoles(task);
+  const synthesis = await runHost(roles.scribe, 'synthesis', { task, proposals, critiques });
+  if (!synthesis.ok) {
+    return {
+      status: 'unresolved',
+      dual: true,
+      roles,
+      verifiedOutcome: false,
+      learningPersisted: false,
+    };
+  }
+
+  let artifact = synthesis.value;
+  let verification = await runHost(roles.verifier, 'verify', { task, artifact });
+  if (verification.ok && verification.value?.verdict === 'changes') {
+    const revision = await runHost(roles.scribe, 'revise', {
+      task,
+      artifact,
+      corrections: verification.value.corrections ?? [],
+    });
+    if (revision.ok) {
+      artifact = revision.value;
+      verification = await runHost(roles.verifier, 'reverify', { task, artifact });
+    }
+  }
+
+  const accepted = verification.ok && verification.value?.verdict === 'accept';
+  const receipt = {
+    protocol: 'dual-host-deliberation-v1',
+    taskHash: createHash('sha256').update(String(task)).digest('hex'),
+    hosts: HOSTS,
+    roles,
+    accepted,
+  };
+  const learningPersisted = accepted ? Boolean(await persist(receipt)) : false;
+  return {
+    status: accepted ? 'accepted' : 'unresolved',
+    dual: true,
+    roles,
+    artifact,
+    verification: verification.ok ? verification.value : undefined,
+    verifiedOutcome: accepted,
+    learningPersisted,
+  };
+}
+
+export async function main(argv = process.argv.slice(2), {
+  deliberateFn = deliberate,
+  stdout = process.stdout,
+  stderr = process.stderr,
+} = {}) {
+  const task = argv.join(' ').trim();
+  if (!task) {
+    stderr.write('Usage: dual-host-deliberation.mjs "<hard problem>"\n');
+    return 64;
+  }
+  try {
+    const result = await deliberateFn(task);
+    stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    return result.status === 'accepted' ? 0 : result.status === 'unavailable' ? 3 : 2;
+  } catch (error) {
+    stderr.write(`Dual-host deliberation failed: ${error.message}\n`);
+    return 1;
+  }
+}
+
+if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
+  process.exitCode = await main();
+}

package/scripts/dual-host-suggest.mjs

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+
+import { fileURLToPath } from 'node:url';
+import { hardProblem } from './dual-host-deliberation.mjs';
+import { probeSubscriptionHosts } from './subscription-hosts.mjs';
+
+const HOSTS = Object.freeze([
+  ['claude', 'claude-code'],
+  ['codex', 'codex'],
+]);
+
+export function recommendDualHost(task, options = {}) {
+  if (!hardProblem(task)) {
+    return {
+      action: 'single-host',
+      hardProblem: false,
+      hosts: [],
+      missing: [],
+      billing: 'subscription-only',
+      apiKeyFallback: false,
+    };
+  }
+
+  const probes = options.probes ?? probeSubscriptionHosts();
+  const hosts = HOSTS
+    .filter(([key]) => probes[key]?.eligible)
+    .map(([, host]) => host);
+  const missing = HOSTS
+    .filter(([key]) => !probes[key]?.eligible)
+    .map(([, host]) => host);
+
+  return {
+    action: missing.length === 0 ? 'duel' : 'login-required',
+    hardProblem: true,
+    hosts,
+    missing,
+    billing: 'subscription-only',
+    apiKeyFallback: false,
+  };
+}
+
+export function main(argv = process.argv.slice(2), {
+  probes,
+  stdout = process.stdout,
+  stderr = process.stderr,
+} = {}) {
+  const task = argv.join(' ').trim();
+  if (!task) {
+    stderr.write('Usage: dual-host-suggest.mjs "<task>"\n');
+    return 64;
+  }
+  stdout.write(`${JSON.stringify(recommendDualHost(task, { probes }), null, 2)}\n`);
+  return 0;
+}
+
+if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
+  process.exitCode = main();
+}