omniconductor 0.6.0 → 1.0.1

package/tools/generate-adapter-docs.js

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+'use strict';
+
+/*
+ * CONDUCTOR — doc generator from adapter metadata (ADR-042; ADR-040 slice 2).
+ *
+ * Reads adapters/<tool>/metadata.json (the single source for enumerable adapter
+ * facts) and rewrites MARKED REGIONS in the docs below. Hand-editing inside a
+ * marked region is futile — edit metadata.json and re-run this script.
+ *
+ * Regions:
+ *   docs/ADAPTER-LIVE-VERIFICATION.md   <!-- generated:live-verification-table -->
+ *   docs/COMPATIBILITY-MATRIX.md        <!-- generated:adapter-outputs-table -->
+ *
+ * Usage:
+ *   node tools/generate-adapter-docs.js           # rewrite regions in place
+ *   node tools/generate-adapter-docs.js --check   # exit 1 if any region is out of date (CI)
+ *
+ * Exit codes: 0 = up to date / written, 1 = --check found drift, 2 = error.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const ROOT = path.resolve(__dirname, '..');
+const TOOLS = ['claude', 'cursor', 'copilot', 'gemini', 'codex', 'windsurf'];
+const CHECK = process.argv.includes('--check');
+
+function die(msg) { process.stderr.write(`generate-adapter-docs: ${msg}\n`); process.exit(2); }
+
+function loadMetadata() {
+  return TOOLS.map((tool) => {
+    const p = path.join(ROOT, 'adapters', tool, 'metadata.json');
+    let m;
+    try { m = JSON.parse(fs.readFileSync(p, 'utf8')); }
+    catch (e) { die(`${p}: ${e.message}`); }
+    if (m.tool !== tool) die(`${p}: tool field '${m.tool}' != directory '${tool}'`);
+    return m;
+  });
+}
+
+// ---- renderers -------------------------------------------------------------
+
+function liveCell(m) {
+  const lv = m.live_verification;
+  if (lv.status === 'verified') {
+    return `✅ **live-verified ${lv.date}** — ${lv.cli}${lv.note ? ` ${lv.note}` : ''}`;
+  }
+  return `🧪 ${lv.note || 'not yet run'}`;
+}
+
+function renderLiveVerificationTable(metas) {
+  const rows = metas.map((m) => `| ${m.display_name} | ✅ | ${liveCell(m)} |`);
+  return [
+    '| Adapter | File emission | Live rule-loading |',
+    '|---|---|---|',
+    ...rows,
+  ].join('\n');
+}
+
+function renderOutputsTable(metas) {
+  const rows = metas.map((m) => {
+    const outputs = m.outputs.map((o) => `\`${o.path}\``).join(' + ');
+    // "(legacy)" qualifier keeps these rows compliant with the stale-token
+    // allow_regex (ADR-039) — a bare legacy path here would read as a current claim.
+    const legacy = m.legacy_paths.length ? m.legacy_paths.map((l) => `\`${l}\` (legacy)`).join(', ') : '—';
+    const live = m.live_verification.status === 'verified'
+      ? `✅ ${m.live_verification.date}`
+      : '🧪 pending';
+    const headless = `\`${m.headless_cli.invocation}\``;
+    const alaCarte = m.install && m.install.ala_carte === 'block' ? 'marked block' : 'per-file';
+    return `| ${m.display_name} | ${m.tier} | ${outputs} | ${legacy} | ${live} | ${headless} | ${alaCarte} |`;
+  });
+  return [
+    '| Tool | Tier | Emitted outputs | Legacy paths (still read) | Live-verified | Headless CLI | À la carte (`--mode`) |',
+    '|---|---|---|---|---|---|---|',
+    ...rows,
+  ].join('\n');
+}
+
+// ---- region splicing -------------------------------------------------------
+
+function spliceRegion(file, name, body) {
+  const p = path.join(ROOT, file);
+  const src = fs.readFileSync(p, 'utf8');
+  const open = `<!-- generated:${name} — edit adapters/*/metadata.json + run tools/generate-adapter-docs.js; do not hand-edit (ADR-042) -->`;
+  const close = `<!-- /generated:${name} -->`;
+  const start = src.indexOf(open);
+  const end = src.indexOf(close);
+  if (start === -1 || end === -1 || end < start) {
+    die(`${file}: marked region '${name}' not found (need both open + close markers)`);
+  }
+  const next = src.slice(0, start + open.length) + '\n' + body + '\n' + src.slice(end);
+  return { p, src, next, changed: next !== src };
+}
+
+function main() {
+  const metas = loadMetadata();
+  const jobs = [
+    spliceRegion('docs/ADAPTER-LIVE-VERIFICATION.md', 'live-verification-table', renderLiveVerificationTable(metas)),
+    spliceRegion('docs/COMPATIBILITY-MATRIX.md', 'adapter-outputs-table', renderOutputsTable(metas)),
+  ];
+
+  const drifted = jobs.filter((j) => j.changed);
+  if (CHECK) {
+    if (drifted.length) {
+      for (const j of drifted) {
+        process.stderr.write(`DRIFT: ${path.relative(ROOT, j.p)} generated region is out of date with adapters/*/metadata.json\n`);
+      }
+      process.stderr.write(`Run: node tools/generate-adapter-docs.js\n`);
+      process.exit(1);
+    }
+    process.stdout.write('OK — generated doc regions match adapter metadata.\n');
+    return;
+  }
+
+  for (const j of jobs) {
+    if (j.changed) { fs.writeFileSync(j.p, j.next); process.stdout.write(`wrote ${path.relative(ROOT, j.p)}\n`); }
+    else process.stdout.write(`up-to-date ${path.relative(ROOT, j.p)}\n`);
+  }
+}
+
+main();

package/tools/live-verify.sh

@@ -0,0 +1,195 @@
+#!/usr/bin/env bash
+# CONDUCTOR live-verify — automated live rule-loading verification (ADR-043).
+# Exit 0 = every attempted tool passed (skips don't fail), 1 = a probe FAILED, 2 = error.
+#
+# For each adapter (or --tool=<t>):
+#   1. read adapters/<tool>/metadata.json → headless CLI command/invocation
+#   2. if the CLI is not on PATH → SKIP (honest — never fake a ✅)
+#   3. install the adapter into a throwaway temp dir (base install, no recipes)
+#   4. run the tool headlessly with the probe prompt from docs/ADAPTER-LIVE-VERIFICATION.md
+#   5. grade DETERMINISTICALLY (no LLM judge): the answer must name ≥3 of the 5
+#      universal rules AND mention CURRENT_WORK
+#   6. on PASS: write live_verification {status:verified, date, cli} into the tool's
+#      metadata.json and regenerate the doc tables (tools/generate-adapter-docs.js)
+#
+# Freshness: any 'verified' date older than 90 days prints a WARN (re-verify).
+#
+# Usage:
+#   bash tools/live-verify.sh                 # all six (installed CLIs only)
+#   bash tools/live-verify.sh --tool=codex    # one tool
+#   bash tools/live-verify.sh --dry-run       # show plan, run nothing, write nothing
+#
+# Env: CONDUCTOR_LIVE_TIMEOUT (seconds per probe, default 300)
+#
+# Local-first by design: CI cannot run six authenticated AI CLIs (see
+# docs/ADAPTER-LIVE-VERIFICATION.md "Why this is separate from CI").
+
+set -u
+
+cd "$(dirname "$0")/.." || exit 2
+ROOT="$(pwd)"
+
+command -v node >/dev/null 2>&1 || { echo "ERROR: node is required" >&2; exit 2; }
+
+ONLY_TOOL=""
+DRY_RUN="false"
+for a in "$@"; do
+  case "$a" in
+    --tool=*) ONLY_TOOL="${a#--tool=}" ;;
+    --dry-run) DRY_RUN="true" ;;
+    *) echo "ERROR: unknown arg '$a' (use --tool=<t> / --dry-run)" >&2; exit 2 ;;
+  esac
+done
+
+TOOLS="claude cursor copilot gemini codex windsurf"
+TIMEOUT_S="${CONDUCTOR_LIVE_TIMEOUT:-300}"
+
+if [ -n "$ONLY_TOOL" ]; then
+  case " $TOOLS " in
+    *" $ONLY_TOOL "*) : ;;
+    *) echo "ERROR: unknown --tool '$ONLY_TOOL' (one of: $TOOLS)" >&2; exit 2 ;;
+  esac
+fi
+
+PROBE="What workflow and rules are you operating under in this project? List the universal rules you can see, and tell me the first thing you must do before writing code."
+
+FAILED=0
+ATTEMPTED=0
+PASSED=0
+
+meta_field() { # meta_field <tool> <js-expr on m>
+  node -e "const m=require('$ROOT/adapters/$1/metadata.json');console.log($2 ?? '')"
+}
+
+grade() { # grade <output-file> → prints "rule_hits current_work(0/1)"
+  local f="$1" hits=0 cw=0 r
+  for r in workflow spec-as-you-go quality-gates operations meta-discipline; do
+    grep -qi -- "$r" "$f" && hits=$((hits + 1))
+  done
+  grep -qi 'CURRENT_WORK' "$f" && cw=1
+  echo "$hits $cw"
+}
+
+run_with_timeout() { # run_with_timeout <seconds> <cmd...>  (portable: no coreutils timeout)
+  local secs="$1"; shift
+  "$@" &
+  local pid=$!
+  local waited=0
+  while kill -0 "$pid" 2>/dev/null; do
+    if [ "$waited" -ge "$secs" ]; then
+      kill "$pid" 2>/dev/null
+      wait "$pid" 2>/dev/null
+      return 124
+    fi
+    sleep 2; waited=$((waited + 2))
+  done
+  wait "$pid"
+}
+
+for tool in $TOOLS; do
+  [ -n "$ONLY_TOOL" ] && [ "$tool" != "$ONLY_TOOL" ] && continue
+
+  cmd="$(meta_field "$tool" 'm.headless_cli.command')"
+  status="$(meta_field "$tool" 'm.live_verification.status')"
+  date_v="$(meta_field "$tool" 'm.live_verification.date')"
+
+  if ! command -v "$cmd" >/dev/null 2>&1; then
+    echo "SKIP  $tool — headless CLI '$cmd' not on PATH (honest skip; install it to verify)"
+    continue
+  fi
+
+  if [ "$DRY_RUN" = "true" ]; then
+    echo "PLAN  $tool — would install to a temp dir and probe via '$cmd' (current: $status${date_v:+ $date_v})"
+    continue
+  fi
+
+  ATTEMPTED=$((ATTEMPTED + 1))
+  tmp="$(mktemp -d "${TMPDIR:-/tmp}/conductor-live-$tool.XXXXXX")" || { echo "ERROR: mktemp failed" >&2; exit 2; }
+  out="$tmp/.probe-output.txt"
+
+  echo "RUN   $tool — installing into $tmp"
+  if ! bash "adapters/$tool/transform.sh" "$tmp" --no-prompt >/dev/null 2>&1; then
+    echo "FAIL  $tool — adapter install failed (pre-probe)"; FAILED=1; rm -rf "$tmp"; continue
+  fi
+  ( cd "$tmp" && git init -q ) 2>/dev/null || true
+
+  echo "RUN   $tool — probing '$cmd' (timeout ${TIMEOUT_S}s)"
+  (
+    cd "$tmp" || exit 2
+    # Read-only probe; flags mirror core/reflector/run-weekly.sh (verified 2026-07-05),
+    # minus write permissions — the probe only asks a question.
+    case "$cmd" in
+      claude)       run_with_timeout "$TIMEOUT_S" claude -p "$PROBE" ;;
+      codex)        run_with_timeout "$TIMEOUT_S" codex exec --sandbox read-only "$PROBE" ;;
+      gemini)       run_with_timeout "$TIMEOUT_S" gemini -p "$PROBE" ;;
+      cursor-agent) run_with_timeout "$TIMEOUT_S" cursor-agent -p "$PROBE" ;;
+      copilot)      run_with_timeout "$TIMEOUT_S" copilot -p "$PROBE" ;;
+      devin)        run_with_timeout "$TIMEOUT_S" devin -p "$PROBE" ;;
+      *)            echo "unknown CLI '$cmd'" >&2; exit 2 ;;
+    esac
+  ) > "$out" 2>&1
+  probe_rc=$?
+
+  if [ "$probe_rc" -eq 124 ]; then
+    echo "FAIL  $tool — probe timed out after ${TIMEOUT_S}s"; FAILED=1; rm -rf "$tmp"; continue
+  fi
+  if [ "$probe_rc" -ne 0 ]; then
+    # A non-zero CLI exit (auth failure, transport error, crash) must never be
+    # recorded as verified — even if partial output happens to contain keywords.
+    echo "FAIL  $tool — probe CLI exited $probe_rc (see $out)"; FAILED=1; continue
+  fi
+
+  read -r hits cw <<EOF_GRADE
+$(grade "$out")
+EOF_GRADE
+  echo "      $tool — graded: $hits/5 rule names, CURRENT_WORK=$cw (probe exit $probe_rc)"
+
+  if [ "$hits" -ge 3 ] && [ "$cw" -eq 1 ]; then
+    PASSED=$((PASSED + 1))
+    today="$(date +%F)"
+    cliver="$("$cmd" --version 2>/dev/null | head -n 1 | tr -d '\n' | cut -c1-60)"
+    [ -n "$cliver" ] || cliver="$cmd"
+    echo "PASS  $tool — live-verified $today ($cliver)"
+    node -e '
+      const fs = require("fs");
+      const p = process.argv[1], date = process.argv[2], cli = process.argv[3], hits = process.argv[4];
+      const raw = fs.readFileSync(p, "utf8");
+      const m = JSON.parse(raw);
+      m.live_verification = { status: "verified", date, cli,
+        note: `headless probe listed ${hits}/5 rules + read-CURRENT_WORK-first` };
+      // Preserve the file style: compact one-line live_verification object.
+      const updated = raw.replace(/"live_verification": \{[^}]*\}/,
+        `"live_verification": { "status": "verified", "date": ${JSON.stringify(date)}, "cli": ${JSON.stringify(cli)}, "note": ${JSON.stringify(m.live_verification.note)} }`);
+      fs.writeFileSync(p, updated);
+    ' "adapters/$tool/metadata.json" "$today" "$cliver" "$hits"
+    node tools/generate-adapter-docs.js >/dev/null
+    echo "      $tool — metadata.json updated + doc tables regenerated"
+  else
+    echo "FAIL  $tool — tool did not demonstrate loading the rules (see $out)"
+    echo "      (an emission-verified adapter that fails live-loading usually means the tool's rules-file convention moved — see docs/ADAPTER-LIVE-VERIFICATION.md)"
+    FAILED=1
+    continue   # keep $tmp for inspection on failure
+  fi
+  rm -rf "$tmp"
+done
+
+# Freshness guard — verified dates older than 90 days deserve a re-run.
+node -e '
+  const fs = require("fs");
+  const tools = ["claude","cursor","copilot","gemini","codex","windsurf"];
+  const now = Date.now();
+  for (const t of tools) {
+    const m = JSON.parse(fs.readFileSync(`adapters/${t}/metadata.json`, "utf8"));
+    const lv = m.live_verification;
+    if (lv.status === "verified" && lv.date) {
+      const age = Math.floor((now - new Date(lv.date).getTime()) / 86400000);
+      if (age > 90) console.log(`WARN  ${t} — live verification is ${age} days old (${lv.date}); re-run: bash tools/live-verify.sh --tool=${t}`);
+    }
+  }
+'
+
+echo
+if [ "$DRY_RUN" = "true" ]; then echo "dry-run complete — nothing executed or written."; exit 0; fi
+echo "live-verify: attempted=$ATTEMPTED passed=$PASSED failed=$((FAILED))"
+[ "$FAILED" -eq 0 ] || exit 1
+exit 0

package/tools/manifest-safety.sh

@@ -0,0 +1,118 @@
+#!/usr/bin/env bash
+# Shared manifest-safety helpers for the six adapters.
+#
+# This file is sourced after an adapter defines TARGET_ABS, MANIFEST_PATH,
+# DRY_RUN, and log().  It deliberately uses only bash + shasum/sha256sum so
+# installers remain dependency-free.
+
+conductor_sha256_file() {
+  local file="$1"
+  if command -v sha256sum >/dev/null 2>&1; then
+    sha256sum "$file" | /usr/bin/awk '{print $1}'
+  else
+    /usr/bin/shasum -a 256 "$file" | /usr/bin/awk '{print $1}'
+  fi
+}
+
+# Return the one-line normal-file manifest entry for a relative path.
+conductor_manifest_entry_for_path() {
+  local wanted="$1" line found
+  [ -f "$MANIFEST_PATH" ] || return 1
+  while IFS= read -r line; do
+    case "$line" in
+      *'"path":'*'"source":'*)
+        found="$(printf '%s' "$line" | /usr/bin/sed -E 's/.*"path": *"([^"]*)".*/\1/')"
+        [ "$found" = "$wanted" ] && { printf '%s\n' "$line"; return 0; }
+        ;;
+    esac
+  done < "$MANIFEST_PATH"
+  return 1
+}
+
+# Return a simple string-valued JSON field from a manifest entry.
+conductor_manifest_field() {
+  local line="$1" key="$2"
+  case "$line" in
+    *"\"$key\":"*)
+      printf '%s' "$line" | /usr/bin/sed -E "s/.*\"$key\": *\"([^\"]*)\".*/\\1/"
+      ;;
+    *) return 1 ;;
+  esac
+}
+
+conductor_unique_backup_path() {
+  local dest="$1" ts candidate n=0
+  ts="$(/bin/date +%Y%m%d-%H%M%S)"
+  candidate="${dest}.conductor-backup-${ts}"
+  while [ -e "$candidate" ]; do
+    n=$((n + 1))
+    candidate="${dest}.conductor-backup-${ts}-${n}"
+  done
+  printf '%s' "$candidate"
+}
+
+# Preserve the initial pre-CONDUCTOR backup across an unmodified re-install.
+# If the prior emitted file was edited, back up that edit before replacing it.
+conductor_manifest_backup_and_remember() {
+  local dest="$1" rel entry prior_sha prior_backup current_sha backup
+  MANIFEST_LAST_BACKUP=""
+  [ -f "$dest" ] || return 0
+
+  if [ "$DRY_RUN" = "true" ]; then
+    log "would safely back up existing $dest"
+    return 0
+  fi
+
+  rel="${dest#$TARGET_ABS/}"
+  entry="$(conductor_manifest_entry_for_path "$rel" 2>/dev/null || true)"
+  if [ -n "$entry" ]; then
+    prior_sha="$(conductor_manifest_field "$entry" sha256 2>/dev/null || true)"
+    prior_backup="$(conductor_manifest_field "$entry" backup_path 2>/dev/null || true)"
+    current_sha="$(conductor_sha256_file "$dest")"
+
+    if [ -n "$prior_sha" ] && [ "$current_sha" = "$prior_sha" ]; then
+      if [ -n "$prior_backup" ] && [ -f "$TARGET_ABS/$prior_backup" ]; then
+        MANIFEST_LAST_BACKUP="$prior_backup"
+        log "  retained original backup for $dest across re-install"
+      else
+        log "  re-installing unchanged CONDUCTOR file $dest"
+      fi
+      return 0
+    fi
+
+    if [ -n "$prior_sha" ]; then
+      log "  preserved user-modified file before re-install: $dest"
+    else
+      log "  preserved legacy manifest file before re-install: $dest"
+    fi
+  fi
+
+  backup="$(conductor_unique_backup_path "$dest")"
+  /bin/cp "$dest" "$backup"
+  MANIFEST_LAST_BACKUP="${backup#$TARGET_ABS/}"
+  log "  backed up existing $dest -> $backup"
+}
+
+conductor_manifest_file_matches() {
+  local file="$1" expected_sha="$2"
+  [ -n "$expected_sha" ] && [ -f "$file" ] \
+    && [ "$(conductor_sha256_file "$file")" = "$expected_sha" ]
+}
+
+# Return the one-line block manifest entry matching a host relative path/name.
+conductor_manifest_block_entry() {
+  local wanted_path="$1" wanted_name="$2" line found_path found_name
+  [ -f "$MANIFEST_PATH" ] || return 1
+  while IFS= read -r line; do
+    case "$line" in
+      *'"type": "block"'*)
+        found_path="$(printf '%s' "$line" | /usr/bin/sed -E 's/.*"path": *"([^"]*)".*/\1/')"
+        found_name="$(printf '%s' "$line" | /usr/bin/sed -E 's/.*"block": *"([^"]*)".*/\1/')"
+        [ "$found_path" = "$wanted_path" ] && [ "$found_name" = "$wanted_name" ] && {
+          printf '%s\n' "$line"; return 0;
+        }
+        ;;
+    esac
+  done < "$MANIFEST_PATH"
+  return 1
+}

package/tools/stale-tokens.txt

@@ -0,0 +1,32 @@
+# CONDUCTOR stale-token list — data file for tools/check-stale-tokens.sh (ADR-039).
+#
+# Format: one rule per line, TAB-separated fields:
+#   pattern<TAB>reason<TAB>hint<TAB>allow_regex(optional)
+#
+# - pattern     : fixed string (grep -F) that indicates a KNOWN-FALSE claim on living surfaces
+# - reason      : why the claim is false (which release/ADR falsified it)
+# - hint        : what to write instead
+# - allow_regex : extended regex — a matching LINE is allowed (legacy/historical qualifiers)
+#
+# Waiver: a line containing `stale-ok: <why>` is always skipped.
+# Process rule (R5 extension): an ADR that flips a fact adds the now-false claim here in the SAME PR.
+# Scope: living public surfaces only — frozen history (CHANGELOG / ADRs / audits / plans / specs /
+# archive / private session docs) is NOT scanned. See the checker header for the exact path set.
+.codex/codex.md	Codex adapter emits AGENTS.md (v0.6.1, ADR from 0.3.0 era)	write AGENTS.md, or qualify as superseded/legacy	supersed|early-design|legacy|historical
+.windsurf/rules	Windsurf target moved to .devin/rules/ in v0.3.0 (Devin Desktop rebrand)	write .devin/rules/ (legacy .windsurf/rules/ still read)	legacy|still read|\.devin
+v0.2.0-foundation	stale version label; versions are single-sourced from package.json	reference package.json / CHANGELOG instead of stamping
+no npx	npm package `omniconductor` published since v0.4	remove; the npx CLI exists
+no NPM package	npm package `omniconductor` published since v0.4	remove; the npm package exists
+not yet available	all 6 adapters + the npx CLI shipped (CLI since v0.2)	remove the "planned/not yet available" framing
+until P2 adapter ships	all 6 adapters shipped transform.sh in v0.2	drop the "until ... ships" framing
+tools without an adapter	all 6 tools have working adapters since v0.2/v0.3	rewrite: all 6 tools have adapters
+❌ No sub-agent	tools ship sub-agent dispatch natively (2026, ADR-031)	use capability-vs-emission framing (ADR-031/034)
+❌ No hooks	tools ship hooks natively (2026, ADR-031; Windsurf lacks only session/stop events)	use capability-vs-emission framing (ADR-031/034)
+No hooks, no sub-agents	tools ship both natively (2026, ADR-031)	use capability-vs-emission framing (ADR-031/034)
+no sub-agents/hooks	tools ship both natively (2026, ADR-031)	use capability-vs-emission framing (ADR-031/034)
+No sub-agents, no hooks	tools ship both natively (2026, ADR-031)	use capability-vs-emission framing (ADR-031/034)
+Single model per session	all 6 tools support per-task model selection (ADR-031)	write: manual per-task pick (tool-native); emission is Phase 2
+Single model per Codex invocation	Codex supports per-task model selection (ADR-031)	write: manual per-task pick (tool-native)
+Codex (T3)	Codex tier corrected T3 → T2 in v0.7.0 (matrix is the tier source, ADR-040 M8)	write Codex (T2)
+Codex adapter (T3)	Codex tier corrected T3 → T2 in v0.7.0	write T2
+pre-1.0 (active	v1.0.0 shipped 2026-07-09 — the pre-1.0 framing is falsified	reference CHANGELOG for current version