@triflux/remote 10.50.1 → 10.51.0

package/hub/team/swarm-preflight.mjs

@@ -1,366 +0,0 @@
-// hub/team/swarm-preflight.mjs — PRD swarm preflight report/gate (#188)
-// Predicts launch-time blockers before any worker session or worktree spawn.
-
-import { execFileSync } from "node:child_process";
-import { resolve } from "node:path";
-import { readHosts, resolveHost } from "@triflux/core/hub/lib/hosts-compat.mjs";
-import { whichCommand } from "@triflux/core/hub/platform.mjs";
-import { MCP_CATALOG } from "./mcp-selector.mjs";
-import { DEFAULT_SENSITIVE_DENY } from "./swarm-locks.mjs";
-import { planSwarm } from "./swarm-planner.mjs";
-
-const AGENT_COMMANDS = Object.freeze({
-  codex: "codex",
-  gemini: "agy",
-  antigravity: "agy",
-  agy: "agy",
-  claude: "claude",
-});
-
-function unique(values) {
-  return [...new Set(values.filter(Boolean))];
-}
-
-function normalizePath(filePath) {
-  return String(filePath || "")
-    .replace(/\\/g, "/")
-    .replace(/^\.\//u, "");
-}
-
-function isSensitiveFile(filePath, sensitiveDeny = DEFAULT_SENSITIVE_DENY) {
-  const path = normalizePath(filePath);
-  const files = new Set(sensitiveDeny.files || []);
-  const prefixes = sensitiveDeny.prefixes || [];
-  return files.has(path) || prefixes.some((prefix) => path.startsWith(prefix));
-}
-
-function planToJson(plan) {
-  return {
-    totalShards: plan.shards.length,
-    shards: plan.shards.map((s) => ({
-      name: s.name,
-      agent: s.agent,
-      host: s.host || null,
-      files: [...s.files],
-      mcp: [...s.mcp],
-      depends: [...s.depends],
-      critical: s.critical,
-    })),
-    leaseMap: Object.fromEntries(plan.leaseMap),
-    mcpManifest: Object.fromEntries(plan.mcpManifest),
-    mergeOrder: [...plan.mergeOrder],
-    criticalShards: [...plan.criticalShards],
-    conflicts: [...plan.conflicts],
-    remoteSuggestion: plan.remoteSuggestion,
-  };
-}
-
-function makeCheck(name, ok, details = {}) {
-  return { name, ok: Boolean(ok), ...details };
-}
-
-function buildLeaseTable(plan, repoRoot) {
-  return plan.shards.map((shard) => ({
-    shard: shard.name,
-    host: shard.host || null,
-    worktreePath: resolve(repoRoot, ".codex-swarm", `wt-${shard.name}`),
-    files: [...shard.files],
-  }));
-}
-
-function checkSensitive(plan, sensitiveDeny) {
-  const matches = [];
-  for (const shard of plan.shards) {
-    for (const file of shard.files) {
-      if (!isSensitiveFile(file, sensitiveDeny)) continue;
-      matches.push({
-        shard: shard.name,
-        file,
-        kind: "sensitive-planned-lease",
-        severity: "warning",
-      });
-    }
-  }
-  return makeCheck("sensitiveDeny", true, { matches });
-}
-
-function parseTrackedStatus(rawStatus) {
-  const files = [];
-  const records = String(rawStatus || "").split("\0");
-  for (let index = 0; index < records.length; index++) {
-    const record = records[index];
-    if (record.length < 4) continue;
-    const status = record.slice(0, 2);
-    files.push(normalizePath(record.slice(3)));
-    if (/[RC]/u.test(status) && records[index + 1]) {
-      files.push(normalizePath(records[++index]));
-    }
-  }
-  return unique(files);
-}
-
-function checkRootDirtyLease(plan, repoRoot, deps = {}) {
-  const gitStatus =
-    deps.gitStatus ||
-    ((cwd) =>
-      execFileSync(
-        "git",
-        ["status", "--porcelain=v1", "-z", "--untracked-files=no"],
-        { cwd, encoding: "utf8", windowsHide: true },
-      ));
-  const dirtyFiles = parseTrackedStatus(gitStatus(repoRoot));
-  const leasedFiles = unique(
-    [...plan.leaseMap.values()].flat().map(normalizePath),
-  );
-  const leaseSet = new Set(leasedFiles);
-  const overlappingFiles = dirtyFiles.filter((file) => leaseSet.has(file));
-
-  return makeCheck("rootDirtyLease", overlappingFiles.length === 0, {
-    dirtyFiles,
-    leasedFiles,
-    overlappingFiles,
-  });
-}
-
-function checkHosts(plan, repoRoot) {
-  const registry = readHosts(repoRoot);
-  const missing = [];
-  const capabilityWarnings = [];
-
-  for (const shard of plan.shards) {
-    if (!shard.host) continue;
-    const resolvedHost = resolveHost(shard.host, repoRoot);
-    if (!resolvedHost) {
-      missing.push({ shard: shard.name, host: shard.host });
-      continue;
-    }
-    const capabilities = resolvedHost.host.capabilities || [];
-    if (shard.agent && !capabilities.includes(shard.agent)) {
-      capabilityWarnings.push({
-        shard: shard.name,
-        host: shard.host,
-        agent: shard.agent,
-        capabilities,
-      });
-    }
-  }
-
-  return makeCheck("hosts", missing.length === 0, {
-    registryPath: registry.path,
-    missing,
-    warnings: capabilityWarnings,
-  });
-}
-
-function checkLocalWorkerClis(plan, deps = {}) {
-  const which = deps.whichCommand || whichCommand;
-  const missing = [];
-  const present = [];
-  const checked = new Map();
-
-  for (const shard of plan.shards) {
-    if (shard.host) continue;
-    const command = AGENT_COMMANDS[shard.agent] || shard.agent;
-    if (!command) {
-      missing.push({ shard: shard.name, agent: shard.agent, command: null });
-      continue;
-    }
-    if (!checked.has(command)) {
-      checked.set(command, which(command, deps.whichOptions || {}));
-    }
-    const path = checked.get(command);
-    if (path)
-      present.push({ shard: shard.name, agent: shard.agent, command, path });
-    else missing.push({ shard: shard.name, agent: shard.agent, command });
-  }
-
-  return makeCheck("workerCli", missing.length === 0, { present, missing });
-}
-
-function checkMcp(plan) {
-  const catalog = new Map(MCP_CATALOG.map((entry) => [entry.name, entry]));
-  const unknown = [];
-  const incompatible = [];
-
-  for (const shard of plan.shards) {
-    for (const server of shard.mcp) {
-      const entry = catalog.get(server);
-      if (!entry) {
-        unknown.push({ shard: shard.name, server });
-        continue;
-      }
-      if (
-        ["codex", "gemini"].includes(shard.agent) &&
-        !entry.cli.includes(shard.agent)
-      ) {
-        incompatible.push({
-          shard: shard.name,
-          agent: shard.agent,
-          server,
-          supportedCli: [...entry.cli],
-        });
-      }
-    }
-  }
-
-  return makeCheck("mcp", incompatible.length === 0, { unknown, incompatible });
-}
-
-function collectMessages(checks) {
-  const errors = [];
-  const warnings = [];
-
-  const leases = checks.leases;
-  for (const conflict of leases.conflicts || []) {
-    errors.push(
-      `lease conflict: ${conflict.file} assigned to ${conflict.shards.join(", ")}`,
-    );
-  }
-
-  const hosts = checks.hosts;
-  for (const missing of hosts.missing || []) {
-    errors.push(
-      `missing host: shard ${missing.shard} references ${missing.host}`,
-    );
-  }
-  for (const warn of hosts.warnings || []) {
-    warnings.push(
-      `host capability warning: ${warn.host} does not advertise ${warn.agent} for shard ${warn.shard}`,
-    );
-  }
-
-  const workerCli = checks.workerCli;
-  for (const missing of workerCli.missing || []) {
-    errors.push(
-      `missing local worker CLI: shard ${missing.shard} requires ${missing.command || missing.agent}`,
-    );
-  }
-
-  const mcp = checks.mcp;
-  for (const item of mcp.incompatible || []) {
-    errors.push(
-      `MCP incompatibility: ${item.server} is not supported by ${item.agent} for shard ${item.shard}`,
-    );
-  }
-  for (const item of mcp.unknown || []) {
-    warnings.push(
-      `unknown MCP server: ${item.server} requested by shard ${item.shard}`,
-    );
-  }
-
-  const sensitive = checks.sensitiveDeny;
-  for (const item of sensitive.matches || []) {
-    warnings.push(
-      `sensitive path planned lease: ${item.file} owned by shard ${item.shard}`,
-    );
-  }
-
-  const rootDirtyLease = checks.rootDirtyLease;
-  if (rootDirtyLease && !rootDirtyLease.ok) {
-    errors.push(
-      `rootDir tracked changes overlap shard leases: ${rootDirtyLease.overlappingFiles.join(", ")}`,
-    );
-  }
-
-  return { errors: unique(errors), warnings: unique(warnings) };
-}
-
-/**
- * Build a no-side-effect preflight report for a swarm PRD.
- *
- * @param {string} prdPath
- * @param {object} [opts]
- * @param {string} [opts.repoRoot]
- * @param {object} [opts.deps]
- * @returns {object}
- */
-export function runSwarmPreflight(prdPath, opts = {}) {
-  const repoRoot = opts.repoRoot || process.cwd();
-  const absPrd = resolve(prdPath);
-  const sensitiveDeny = opts.sensitiveDeny || DEFAULT_SENSITIVE_DENY;
-  let plan;
-
-  try {
-    plan = (opts.deps?.planSwarm || planSwarm)(absPrd, { repoRoot });
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return {
-      ok: false,
-      verdict: "no-go",
-      prdPath: absPrd,
-      repoRoot,
-      checks: {
-        plan: makeCheck("plan", false, { error: message }),
-      },
-      errors: [message],
-      warnings: [],
-      plan: null,
-      leaseTable: [],
-    };
-  }
-
-  const checks = {
-    plan: makeCheck("plan", true),
-    leases: makeCheck("leases", plan.conflicts.length === 0, {
-      conflicts: [...plan.conflicts],
-    }),
-    rootDirtyLease: checkRootDirtyLease(plan, repoRoot, opts.deps),
-    sensitiveDeny: checkSensitive(plan, sensitiveDeny),
-    hosts: checkHosts(plan, repoRoot),
-    workerCli: checkLocalWorkerClis(plan, opts.deps),
-    mcp: checkMcp(plan),
-  };
-  const { errors, warnings } = collectMessages(checks);
-  const ok = Object.values(checks).every((check) => check.ok);
-
-  return {
-    ok,
-    verdict: ok ? "go" : "no-go",
-    prdPath: absPrd,
-    repoRoot,
-    checks,
-    errors,
-    warnings,
-    plan: planToJson(plan),
-    leaseTable: buildLeaseTable(plan, repoRoot),
-  };
-}
-
-export function formatPreflightReport(report) {
-  const lines = [`SWARM PREFLIGHT: ${report.verdict.toUpperCase()}`];
-
-  if (report.plan) {
-    lines.push(`PRD: ${report.prdPath}`);
-    lines.push(`Shards: ${report.plan.totalShards}`);
-    lines.push("");
-    lines.push("Lease table:");
-    for (const lease of report.leaseTable) {
-      const host = lease.host ? ` @${lease.host}` : "";
-      lines.push(`  - ${lease.shard}${host}`);
-      lines.push(`    worktree: ${lease.worktreePath}`);
-      lines.push(
-        `    files: ${lease.files.length ? lease.files.join(", ") : "(none)"}`,
-      );
-    }
-  }
-
-  lines.push("");
-  lines.push("Checks:");
-  for (const [name, check] of Object.entries(report.checks || {})) {
-    lines.push(`  ${check.ok ? "✓" : "✗"} ${name}`);
-  }
-
-  if (report.errors?.length) {
-    lines.push("");
-    lines.push("Blocking errors:");
-    for (const error of report.errors) lines.push(`  - ${error}`);
-  }
-
-  if (report.warnings?.length) {
-    lines.push("");
-    lines.push("Warnings:");
-    for (const warning of report.warnings) lines.push(`  - ${warning}`);
-  }
-
-  return `${lines.join("\n")}\n`;
-}

package/hub/team/swarm-reconciler.mjs

@@ -1,242 +0,0 @@
-// hub/team/swarm-reconciler.mjs — Redundant execution + result reconciliation
-// For critical shards: launches primary + verifier sessions, compares results,
-// applies conservative adoption (fewer changes wins) or HITL fallback.
-// v2 (Synapse): parses X-Intent trailers to route complementary/contradictory
-// commits through intent-aware paths before falling back to conservative logic.
-
-import { execFile } from "node:child_process";
-
-import { classifyIntentPair, parseIntentTrailer } from "./swarm-intent.mjs";
-
-/**
- * Compare two shard results and decide which to accept.
- * Strategy: conservative adoption — the result with fewer changed files wins.
- * If results are identical (same diff), primary is accepted.
- * If they diverge significantly, mark for HITL review.
- *
- * @param {object} primaryResult — { branchName, worktreePath, status }
- * @param {object} verifierResult — { branchName, worktreePath, status }
- * @param {object} [opts]
- * @param {string} [opts.rootDir=process.cwd()]
- * @param {number} [opts.maxDivergenceFiles=5] — beyond this, trigger HITL
- * @returns {Promise<ReconcileDecision>}
- */
-export async function reconcile(primaryResult, verifierResult, opts = {}) {
-  const { rootDir = process.cwd(), maxDivergenceFiles = 5 } = opts;
-
-  // If either failed, pick the one that succeeded
-  if (
-    primaryResult.status !== "completed" &&
-    verifierResult.status === "completed"
-  ) {
-    return decision("verifier", "primary_failed", verifierResult);
-  }
-  if (
-    verifierResult.status !== "completed" &&
-    primaryResult.status === "completed"
-  ) {
-    return decision("primary", "verifier_failed", primaryResult);
-  }
-  if (
-    primaryResult.status !== "completed" &&
-    verifierResult.status !== "completed"
-  ) {
-    return decision("none", "both_failed", null);
-  }
-
-  // Both completed — compare diffs
-  const primaryDiff = await getDiffStat(primaryResult.branchName, rootDir);
-  const verifierDiff = await getDiffStat(verifierResult.branchName, rootDir);
-
-  // Identical diffs → accept primary (no divergence)
-  if (primaryDiff.hash === verifierDiff.hash) {
-    return decision("primary", "identical", primaryResult);
-  }
-
-  // Intent-aware classification: parse X-Intent trailers from both commits.
-  // When both commits carry an intent, route contradictory pairs to HITL and
-  // complementary (non-overlapping) pairs to a merge-friendly path. Missing or
-  // malformed trailers fall through to the existing divergence/conservative
-  // adoption logic below.
-  const [primaryMsg, verifierMsg] = await Promise.all([
-    getCommitMessage(primaryResult.branchName, rootDir),
-    getCommitMessage(verifierResult.branchName, rootDir),
-  ]);
-
-  const primaryIntent = parseIntentTrailer(primaryMsg);
-  const verifierIntent = parseIntentTrailer(verifierMsg);
-
-  if (primaryIntent && verifierIntent) {
-    const classification = classifyIntentPair(primaryIntent, verifierIntent);
-
-    if (classification.relation === "contradictory") {
-      return {
-        selected: "hitl",
-        reason: `intent_contradictory: ${classification.reason}`,
-        result: null,
-        requiresManualReview: true,
-        intentClassification: classification,
-        primaryIntent,
-        verifierIntent,
-        primary: {
-          filesChanged: primaryDiff.filesChanged,
-          linesChanged: primaryDiff.linesChanged,
-        },
-        verifier: {
-          filesChanged: verifierDiff.filesChanged,
-          linesChanged: verifierDiff.linesChanged,
-        },
-      };
-    }
-
-    if (classification.relation === "complementary") {
-      return {
-        selected: "complementary",
-        reason: `intent_complementary: ${classification.reason}`,
-        result: { primary: primaryResult, verifier: verifierResult },
-        requiresManualReview: false,
-        intentClassification: classification,
-        primaryIntent,
-        verifierIntent,
-        shouldAttemptMerge: true,
-        primary: {
-          filesChanged: primaryDiff.filesChanged,
-          linesChanged: primaryDiff.linesChanged,
-        },
-        verifier: {
-          filesChanged: verifierDiff.filesChanged,
-          linesChanged: verifierDiff.linesChanged,
-        },
-      };
-    }
-
-    // complementary-risky / independent → fall through to existing logic.
-  }
-
-  // Compute divergence
-  const divergence = Math.abs(
-    primaryDiff.filesChanged - verifierDiff.filesChanged,
-  );
-
-  // High divergence → HITL
-  if (divergence > maxDivergenceFiles) {
-    return {
-      selected: "hitl",
-      reason: `divergence_too_high (${divergence} files differ)`,
-      result: null,
-      requiresManualReview: true,
-      primary: {
-        filesChanged: primaryDiff.filesChanged,
-        linesChanged: primaryDiff.linesChanged,
-      },
-      verifier: {
-        filesChanged: verifierDiff.filesChanged,
-        linesChanged: verifierDiff.linesChanged,
-      },
-    };
-  }
-
-  // Conservative adoption: fewer changes wins
-  if (primaryDiff.linesChanged <= verifierDiff.linesChanged) {
-    return decision("primary", "conservative_adoption", primaryResult);
-  }
-  return decision("verifier", "conservative_adoption", verifierResult);
-}
-
-function decision(selected, reason, result) {
-  return {
-    selected,
-    reason,
-    result,
-    requiresManualReview: selected === "hitl" || selected === "none",
-    primary: null,
-    verifier: null,
-  };
-}
-
-/**
- * Read the HEAD commit message of a branch.
- *
- * @param {string} branch
- * @param {string} cwd
- * @returns {Promise<string>}
- */
-async function getCommitMessage(branch, cwd) {
-  try {
-    const msg = await gitExec(["log", "-1", "--format=%B", branch], cwd);
-    return msg;
-  } catch {
-    return "";
-  }
-}
-
-/**
- * Get diff statistics for a branch relative to its merge-base.
- *
- * @param {string} branch
- * @param {string} cwd
- * @returns {Promise<{ filesChanged: number, linesChanged: number, hash: string }>}
- */
-async function getDiffStat(branch, cwd) {
-  try {
-    const stat = await gitExec(
-      ["diff", "--stat", "--numstat", `${branch}~1..${branch}`],
-      cwd,
-    );
-    const lines = stat.split("\n").filter(Boolean);
-    let filesChanged = 0;
-    let linesChanged = 0;
-
-    for (const line of lines) {
-      const match = line.match(/^(\d+)\s+(\d+)\s+/);
-      if (match) {
-        filesChanged++;
-        linesChanged += Number(match[1]) + Number(match[2]);
-      }
-    }
-
-    // Get tree hash for identity comparison
-    const hash = await gitExec(["rev-parse", `${branch}^{tree}`], cwd);
-
-    return { filesChanged, linesChanged, hash: hash.trim() };
-  } catch {
-    return { filesChanged: 0, linesChanged: 0, hash: "" };
-  }
-}
-
-function gitExec(args, cwd) {
-  return new Promise((res, rej) => {
-    execFile(
-      "git",
-      args,
-      { cwd, windowsHide: true, timeout: 15_000 },
-      (err, stdout) => {
-        if (err) rej(err);
-        else res(stdout);
-      },
-    );
-  });
-}
-
-/**
- * Build session configs for redundant execution (primary + verifier).
- *
- * @param {object} shard — from SwarmPlan
- * @param {string} runId
- * @returns {{ primaryId: string, verifierId: string }}
- */
-export function buildRedundantIds(shard, runId) {
-  return {
-    primaryId: `${runId}-${shard.id}-primary`,
-    verifierId: `${runId}-${shard.id}-verifier`,
-  };
-}
-
-/**
- * Check if a shard should use redundant execution.
- * @param {object} shard
- * @returns {boolean}
- */
-export function shouldRunRedundant(shard) {
-  return shard.critical === true;
-}