devlyn-cli 2.7.0 → 2.8.0

package/benchmark/auto-resolve/fixtures/retired/F37-cli-rule-lookup/verifiers/correctness-small.js

@@ -0,0 +1,84 @@
+'use strict';
+// F37 hidden verifier — one bundled scenario exercising: (1) different
+// events in the same category resolving to different revisions by their
+// own timestamp, (2) the inclusive effectiveAt<=timestamp boundary (an
+// exact match is eligible), (3) the same-effectiveAt tie-break (greatest
+// id wins), (4) unknown_category vs no_effective_rule are distinct and
+// correctly assigned. Resets the seed so this verifier is order-independent
+// from other verifier commands (F35 pattern).
+//
+// Structural equality: object key order is not part of the visible
+// contract; array order is.
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return a.length === b.length && a.every((v, i) => deepEqual(v, b[i]));
+  }
+  if (a && b && typeof a === 'object' && typeof b === 'object' && !Array.isArray(a) && !Array.isArray(b)) {
+    const ka = Object.keys(a).sort();
+    const kb = Object.keys(b).sort();
+    return deepEqual(ka, kb) && ka.every((k) => deepEqual(a[k], b[k]));
+  }
+  return false;
+}
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+const work = process.env.BENCH_WORKDIR;
+const revPath = path.join(work, 'data', 'rule-revisions.json');
+const cli = path.join(work, 'bin', 'cli.js');
+
+const revisions = [
+  { id: 'rev-a2', categoryId: 'cat-A', effectiveAt: 200, discountPct: 20, minPrice: 10 },
+  { id: 'rev-a9', categoryId: 'cat-A', effectiveAt: 300, discountPct: 90, minPrice: 10 },
+  { id: 'rev-a1', categoryId: 'cat-A', effectiveAt: 100, discountPct: 10, minPrice: 10 },
+  { id: 'rev-b1', categoryId: 'cat-B', effectiveAt: 50, discountPct: 0, minPrice: 5 },
+  { id: 'rev-a3', categoryId: 'cat-A', effectiveAt: 300, discountPct: 30, minPrice: 10 },
+];
+fs.writeFileSync(revPath, JSON.stringify(revisions, null, 2) + '\n');
+
+const inputPath = path.join(os.tmpdir(), `price-events-small-${process.pid}.json`);
+fs.writeFileSync(inputPath, JSON.stringify({
+  events: [
+    { id: 'e1', categoryId: 'cat-A', timestamp: 150, basePrice: 100 },
+    { id: 'e2', categoryId: 'cat-A', timestamp: 250, basePrice: 100 },
+    { id: 'e3', categoryId: 'cat-A', timestamp: 200, basePrice: 50 },
+    { id: 'e4', categoryId: 'cat-A', timestamp: 350, basePrice: 100 },
+    { id: 'e5', categoryId: 'cat-B', timestamp: 10, basePrice: 100 },
+    { id: 'e6', categoryId: 'cat-C', timestamp: 1000, basePrice: 100 },
+  ],
+}));
+
+const result = spawnSync('node', [cli, 'price-events', '--input', inputPath], {
+  cwd: work,
+  encoding: 'utf8',
+  maxBuffer: 16 * 1024 * 1024,
+});
+
+let out = null;
+try {
+  out = JSON.parse(result.stdout);
+} catch {
+  out = null;
+}
+
+const expected = {
+  priced: [
+    { id: 'e1', ruleId: 'rev-a1', price: 90 },
+    { id: 'e2', ruleId: 'rev-a2', price: 80 },
+    { id: 'e3', ruleId: 'rev-a2', price: 40 },
+    { id: 'e4', ruleId: 'rev-a9', price: 10 },
+  ],
+  rejected: [
+    { id: 'e5', reason: 'no_effective_rule' },
+    { id: 'e6', reason: 'unknown_category' },
+  ],
+};
+
+const ok = result.status === 0 && result.stderr === '' && deepEqual(out, expected);
+
+console.log(JSON.stringify({ ok, status: result.status, stderr: result.stderr, out, expected }));
+process.exit(ok ? 0 : 1);

package/benchmark/auto-resolve/fixtures/retired/F37-cli-rule-lookup/verifiers/scale.js

@@ -0,0 +1,184 @@
+'use strict';
+// F37 hidden verifier — the performance discriminator. 60,000 rule
+// revisions spread over 4 categories (15,000 revisions/category) and
+// 200,000 events. Every event resolves successfully (no rejections),
+// which keeps the expected output small and the correctness check a
+// direct array comparison; the discriminator is entirely in how the
+// lookup is done, not in exercising the reject paths (those are covered
+// by correctness-small.js).
+//
+// A per-event linear scan of a category's revisions costs on the order of
+// events * revisions-per-category =~ 200,000 * 15,000 = 3e9 comparisons —
+// tens of seconds or more in Node. Grouping by category (near-free) and
+// then binary-searching a sorted per-category list is a few million
+// log-steps — trivially fast. The reference below independently
+// implements the efficient shape (not shared code with the CLI) so it can
+// also serve as ground truth without becoming a second bottleneck. The
+// 15-second hard kill sits far above the efficient solution's expected
+// running time and correspondingly far below any realistic
+// linear-scan running time at these parameters.
+//
+// Revisions are written to `data/rule-revisions.json` in a shuffled
+// (non-category-grouped, non-time-sorted) order via a deterministic
+// permutation, matching the visible "not sorted by category or by time"
+// spec fact and closing a "trust file order" shortcut.
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+const work = process.env.BENCH_WORKDIR;
+const revPath = path.join(work, 'data', 'rule-revisions.json');
+const cli = path.join(work, 'bin', 'cli.js');
+
+const CATS = 4;
+const REVS_PER_CAT = 15000;
+const TOTAL_REVS = CATS * REVS_PER_CAT;
+const EVENTS = 200000;
+const REV_PERMUTE_MULTIPLIER = 39989; // coprime with 60000 (2^5 * 3 * 5^4)
+
+const revisionsInOrder = new Array(TOTAL_REVS);
+let k = 0;
+for (let c = 0; c < CATS; c++) {
+  for (let j = 0; j < REVS_PER_CAT; j++) {
+    revisionsInOrder[k] = {
+      id: `rev-${c}-${j}`,
+      categoryId: `cat-${c}`,
+      effectiveAt: j * 10,
+      discountPct: (j * 7) % 50,
+      minPrice: 100 + ((j * 13) % 900),
+    };
+    k += 1;
+  }
+}
+
+const shuffled = new Array(TOTAL_REVS);
+for (let i = 0; i < TOTAL_REVS; i++) {
+  const pos = (i * REV_PERMUTE_MULTIPLIER) % TOTAL_REVS;
+  shuffled[pos] = revisionsInOrder[i];
+}
+fs.writeFileSync(revPath, JSON.stringify(shuffled));
+
+const events = new Array(EVENTS);
+for (let i = 0; i < EVENTS; i++) {
+  const c = i % CATS;
+  const base = (i * 131) % REVS_PER_CAT;
+  events[i] = {
+    id: `ev-${i}`,
+    categoryId: `cat-${c}`,
+    timestamp: base * 10 + 5,
+    basePrice: 1000 + (i % 500),
+  };
+}
+
+const inputPath = path.join(os.tmpdir(), `price-events-scale-${process.pid}.json`);
+fs.writeFileSync(inputPath, JSON.stringify({ events }));
+
+// Independent reference: group by category, sort each group by
+// (effectiveAt asc, id asc), binary-search the rightmost entry with
+// effectiveAt <= timestamp.
+const groups = new Map();
+for (const rev of revisionsInOrder) {
+  if (!groups.has(rev.categoryId)) groups.set(rev.categoryId, []);
+  groups.get(rev.categoryId).push(rev);
+}
+for (const list of groups.values()) {
+  list.sort((a, b) => a.effectiveAt - b.effectiveAt || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+}
+
+function findRuleIndex(sorted, timestamp) {
+  let lo = 0;
+  let hi = sorted.length - 1;
+  let ans = -1;
+  while (lo <= hi) {
+    const mid = (lo + hi) >> 1;
+    if (sorted[mid].effectiveAt <= timestamp) {
+      ans = mid;
+      lo = mid + 1;
+    } else {
+      hi = mid - 1;
+    }
+  }
+  return ans;
+}
+
+const expectedPriced = new Array(EVENTS);
+let expectedRejectedCount = 0;
+for (let i = 0; i < EVENTS; i++) {
+  const ev = events[i];
+  const group = groups.get(ev.categoryId);
+  if (!group) {
+    expectedRejectedCount += 1;
+    expectedPriced[i] = null;
+    continue;
+  }
+  const idx = findRuleIndex(group, ev.timestamp);
+  if (idx < 0) {
+    expectedRejectedCount += 1;
+    expectedPriced[i] = null;
+    continue;
+  }
+  const rule = group[idx];
+  const price = Math.max(rule.minPrice, Math.round((ev.basePrice * (100 - rule.discountPct)) / 100));
+  expectedPriced[i] = { id: ev.id, ruleId: rule.id, price };
+}
+
+const start = Date.now();
+const result = spawnSync('node', [cli, 'price-events', '--input', inputPath], {
+  cwd: work,
+  encoding: 'utf8',
+  timeout: 15000,
+  killSignal: 'SIGKILL',
+  maxBuffer: 64 * 1024 * 1024,
+});
+const elapsedMs = Date.now() - start;
+
+const timedOut = result.status === null && result.signal !== null;
+
+let out = null;
+if (!timedOut) {
+  try {
+    out = JSON.parse(result.stdout);
+  } catch {
+    out = null;
+  }
+}
+
+let correct = false;
+let mismatch = null;
+if (out && Array.isArray(out.priced) && Array.isArray(out.rejected)) {
+  correct =
+    out.rejected.length === expectedRejectedCount &&
+    out.priced.length === EVENTS - expectedRejectedCount &&
+    out.priced.every((row, i) => {
+      const expected = expectedPriced[i];
+      return expected && row.id === expected.id && row.ruleId === expected.ruleId && row.price === expected.price;
+    });
+  if (!correct) {
+    const firstMismatchIndex = out.priced.findIndex((row, i) => {
+      const expected = expectedPriced[i];
+      return !expected || row.id !== expected.id || row.ruleId !== expected.ruleId || row.price !== expected.price;
+    });
+    mismatch = {
+      pricedLength: out.priced.length,
+      rejectedLength: out.rejected.length,
+      expectedRejectedCount,
+      firstMismatchIndex,
+    };
+  }
+}
+
+const ok = !timedOut && result.status === 0 && result.stderr === '' && correct;
+
+console.log(JSON.stringify({
+  ok,
+  timedOut,
+  elapsedMs,
+  status: result.status,
+  signal: result.signal,
+  stderrLength: result.stderr ? result.stderr.length : 0,
+  correct,
+  mismatch,
+}));
+process.exit(ok ? 0 : 1);

package/benchmark/auto-resolve/fixtures/retired/F37-cli-rule-lookup/verifiers/validation.js

@@ -0,0 +1,74 @@
+'use strict';
+// F37 hidden verifier — validation happens before any pricing decision:
+// malformed event fields use `invalid_input`, duplicate event ids use the
+// distinct `duplicate_event_id` shape, and nothing is priced or printed to
+// stdout in either case. Resets the seed so this verifier is
+// order-independent from other verifier commands.
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+const work = process.env.BENCH_WORKDIR;
+const revPath = path.join(work, 'data', 'rule-revisions.json');
+const cli = path.join(work, 'bin', 'cli.js');
+
+const revisions = [
+  { id: 'rev-a1', categoryId: 'cat-A', effectiveAt: 100, discountPct: 10, minPrice: 10 },
+];
+
+let callCount = 0;
+function runPriceEvents(payload) {
+  fs.writeFileSync(revPath, JSON.stringify(revisions, null, 2) + '\n');
+  callCount += 1;
+  const inputPath = path.join(os.tmpdir(), `price-events-validate-${process.pid}-${callCount}.json`);
+  fs.writeFileSync(inputPath, JSON.stringify(payload));
+  const result = spawnSync('node', [cli, 'price-events', '--input', inputPath], {
+    cwd: work,
+    encoding: 'utf8',
+    maxBuffer: 16 * 1024 * 1024,
+  });
+  let err = null;
+  try {
+    err = JSON.parse(result.stderr);
+  } catch {
+    err = null;
+  }
+  return { result, err };
+}
+
+const failures = [];
+
+function expectInvalidInput(label, payload) {
+  const { result, err } = runPriceEvents(payload);
+  const ok = result.status === 2 && result.stdout === '' && err !== null && err.error === 'invalid_input' && typeof err.reason === 'string';
+  if (!ok) {
+    failures.push({ test: label, status: result.status, stdout: result.stdout, stderr: result.stderr, err });
+  }
+}
+
+expectInvalidInput('events-not-array', { events: 'nope' });
+expectInvalidInput('missing-id', { events: [{ categoryId: 'cat-A', timestamp: 100, basePrice: 10 }] });
+expectInvalidInput('non-integer-timestamp', { events: [{ id: 'e1', categoryId: 'cat-A', timestamp: 1.5, basePrice: 10 }] });
+expectInvalidInput('negative-base-price', { events: [{ id: 'e1', categoryId: 'cat-A', timestamp: 100, basePrice: -1 }] });
+expectInvalidInput('non-string-category', { events: [{ id: 'e1', categoryId: 42, timestamp: 100, basePrice: 10 }] });
+
+// Duplicate event id — distinct error shape.
+{
+  const payload = {
+    events: [
+      { id: 'dup', categoryId: 'cat-A', timestamp: 100, basePrice: 10 },
+      { id: 'dup', categoryId: 'cat-A', timestamp: 200, basePrice: 20 },
+    ],
+  };
+  const { result, err } = runPriceEvents(payload);
+  const ok = result.status === 2 && result.stdout === '' && err !== null && err.error === 'duplicate_event_id' && err.id === 'dup';
+  if (!ok) {
+    failures.push({ test: 'duplicate-event-id', status: result.status, stdout: result.stdout, stderr: result.stderr, err });
+  }
+}
+
+const ok = failures.length === 0;
+console.log(JSON.stringify({ ok, failures }));
+process.exit(ok ? 0 : 1);

package/benchmark/auto-resolve/scripts/pair-rejected-fixtures.sh

@@ -69,6 +69,18 @@ rejected_pair_fixture_reason() {
     F32-*|F32)
       echo "bare 33 / solo_claude 98 in 20260512-f32-subscription-renewal-headroom"
       ;;
+    F34-*|F34)
+      echo "bare 92 / solo_claude 88 in iter-0039-headroom-f34-f35"
+      ;;
+    F35-*|F35)
+      echo "bare 50 / solo_claude 97 in iter-0039-headroom-f34-f35"
+      ;;
+    F36-*|F36)
+      echo "bare 50 / solo_claude 96 with solo timeout in iter-0041-headroom-f36-f37"
+      ;;
+    F37-*|F37)
+      echo "bare 75 / solo_claude 96 with solo invoke failure in iter-0041-headroom-f36-f37"
+      ;;
     S2-*|S2)
       echo "bare 33 / solo_claude 99 with solo timeout in 20260513-s2-inventory-headroom"
       ;;

package/benchmark/auto-resolve/scripts/run-fixture.sh

@@ -15,7 +15,7 @@
 set -euo pipefail
 
 usage() {
-  echo "usage: $0 --fixture <FID> --arm <variant|solo_claude|bare|l2_gated|l2_risk_probes|l2_forced> --run-id <ID> [--resolve-skill new] [--dry-run]"
+  echo "usage: $0 --fixture <FID> --arm <variant|solo_claude|bare|l2_gated|l2_risk_probes|l2_forced> --run-id <ID> [--resolve-skill new] [--engines-config '<json>'] [--dry-run]"
   exit 1
 }
 
@@ -47,17 +47,36 @@ kill_worktree_processes() {
 
 FIXTURE=""; ARM=""; RUN_ID=""; DRY_RUN=0
 RESOLVE_SKILL="new"
+ENGINES_CONFIG=""
 while [ $# -gt 0 ]; do
   case "$1" in
     --fixture)        require_value "$1" "${2:-}"; FIXTURE="$2"; shift 2;;
     --arm)            require_value "$1" "${2:-}"; ARM="$2";     shift 2;;
     --run-id)         require_value "$1" "${2:-}"; RUN_ID="$2";  shift 2;;
     --resolve-skill)  require_value "$1" "${2:-}"; RESOLVE_SKILL="$2"; shift 2;;
+    --engines-config) require_value "$1" "${2:-}"; ENGINES_CONFIG="$2"; shift 2;;
     --dry-run)        DRY_RUN=1;    shift;;
     *) usage;;
   esac
 done
 [ -n "$FIXTURE" ] && [ -n "$ARM" ] && [ -n "$RUN_ID" ] || usage
+
+# iter-0038: --engines-config stages a machine-config role pin
+# (.devlyn/engines.json) into the arm worktree so engine COMBINATIONS are
+# runnable as variant-class arms without new hardcoded arm names. Existing
+# arm launch commands are untouched when the flag is absent. Fail fast on
+# malformed JSON, and refuse bare (no skills — the config would be dead
+# weight that silently mis-labels the arm as configured).
+if [ -n "$ENGINES_CONFIG" ]; then
+  if [ "$ARM" = "bare" ]; then
+    echo "--engines-config is invalid for the bare arm (no skills consume it)" >&2
+    exit 1
+  fi
+  if ! printf '%s' "$ENGINES_CONFIG" | python3 -c 'import json,sys; json.load(sys.stdin)' 2>/dev/null; then
+    echo "--engines-config is not valid JSON" >&2
+    exit 1
+  fi
+fi
 # iter-0019/0037: 3 smoke arms — variant (L2: Claude orchestrator + risk-probes pair path),
 # solo_claude (L1: Claude orchestrator, codex blocked by shim+wrapper enforcement),
 # bare (L0: direct claude -p, no skill, no codex).
@@ -164,6 +183,14 @@ if [ "$ARM" = "variant" ] || [ "$ARM" = "solo_claude" ] \
   if [ -f "$REPO_ROOT/CLAUDE.md" ]; then
     cp "$REPO_ROOT/CLAUDE.md" "$WORK_DIR/CLAUDE.md"
   fi
+  # iter-0038: stage the engine role pin (validated above) pre-baseline.
+  # test-repo/.gitignore covers .devlyn, so it never enters scaffold commits
+  # or arm diffs. A verbatim copy lands in RESULT_DIR as run evidence.
+  if [ -n "$ENGINES_CONFIG" ]; then
+    mkdir -p "$WORK_DIR/.devlyn"
+    printf '%s\n' "$ENGINES_CONFIG" > "$WORK_DIR/.devlyn/engines.json"
+    printf '%s\n' "$ENGINES_CONFIG" > "$RESULT_DIR/engines-config.json"
+  fi
   # Stage the codex PATH shim. Required for both variant (route to monitored
   # wrapper) and solo_claude (CODEX_BLOCKED enforcement at PATH layer).
   if command -v codex >/dev/null 2>&1; then
@@ -405,6 +432,17 @@ EOF
     # OLD branch and this is now the only non-F9 path.
     mkdir -p "$WORK_DIR/docs/roadmap/phase-1"
     cp "$SPEC" "$WORK_DIR/docs/roadmap/phase-1/$FIXTURE.md"
+    # iter-0049: fixtures keep spec.md prose-only (expected.json is the real
+    # carrier, validated separately by lint-fixtures.sh) but spec-verify-check.py
+    # now locates the visible ## Verification prose via a <!-- devlyn:verification -->
+    # sentinel rather than the English header text. Inject it into the WORK_DIR
+    # copy only, so risk-probe derived_from substring matching still finds the
+    # section during a run; the source fixture repo stays untouched.
+    if ! grep -q '<!-- devlyn:verification -->' "$WORK_DIR/docs/roadmap/phase-1/$FIXTURE.md"; then
+      sed -i.bak 's/^## Verification\b/<!-- devlyn:verification -->\n## Verification/' \
+        "$WORK_DIR/docs/roadmap/phase-1/$FIXTURE.md"
+      rm -f "$WORK_DIR/docs/roadmap/phase-1/$FIXTURE.md.bak"
+    fi
     cat > "$PROMPT_FILE" <<EOF
 Use the \`/devlyn:resolve --spec docs/roadmap/phase-1/$FIXTURE.md ${ENGINE_CLAUSE}\` skill to implement the spec. ${ENGINE_PROMPT_HINT}
 

package/benchmark/auto-resolve/scripts/test-lint-fixtures.sh

@@ -387,7 +387,7 @@ status=$?
 set -e
 [ "$status" -ne 0 ]
 grep -Fq 'spec-verify-check --check-expected failed' "$TMP/spec-verify-check-expected-fail.out"
-grep -Fq 'unless sibling spec.md declares all Requirements are pure-design' "$TMP/spec-verify-check-expected-fail.out"
+grep -Fq 'unless spec.expected.json declares "pure_design": true' "$TMP/spec-verify-check-expected-fail.out"
 
 write_fixture "Add idempotency handling for duplicate requests."
 

package/bin/devlyn.js

@@ -14,7 +14,8 @@ const PKG = require('../package.json');
 // directory. Single source of truth so codex/omp/pi stay in lockstep — adding a
 // skill here installs it everywhere. Standards skills (code-*, root-cause-*,
 // ui-*) stay Claude-core-only, matching the pre-existing Codex bundle.
-const DEVLYN_CORE_SKILLS = ['devlyn:resolve', 'devlyn:ideate', 'devlyn:design-ui', '_shared'];
+const DEVLYN_CORE_SKILLS = ['devlyn:resolve', 'devlyn:ideate', 'devlyn:design-ui', 'devlyn:engines', 'devlyn:queue', '_shared'];
+const DEVLYN_SKILL_DIR_STAMP = '__DEVLYN_SKILL_DIR__';
 
 // Cross-agent shared skills directory read by BOTH oh-my-pi and Pi. Verified
 // from the omp binary's skill-provider strings ("skills from .agents/skills —
@@ -340,6 +341,40 @@ function copyRecursive(src, dest, baseDir) {
   }
 }
 
+function shellDoubleQuoteDefault(value) {
+  if (value.includes('\n')) {
+    throw new Error(`Cannot stamp skill path with newline: ${value}`);
+  }
+  return value.replace(/[\\$"`}]/g, '\\$&');
+}
+
+function stampInstalledSkillDir(rootDir, skillDir) {
+  // Stamp ONLY the assignment-default occurrence. The sentinel comparison
+  // literal on the guard line must stay intact: stamping it makes the guard
+  // compare the stamped default to itself and false-positive
+  // BLOCKED:shared-dir-unresolved on every codex/omp run that executes the
+  // block (CLAUDE_SKILL_DIR unset) — iter-0040 R3 latent finding.
+  const assignmentStamp = '${CLAUDE_SKILL_DIR:-' + DEVLYN_SKILL_DIR_STAMP + '}';
+  const stampedAssignment = '${CLAUDE_SKILL_DIR:-' + shellDoubleQuoteDefault(skillDir) + '}';
+
+  function visit(current) {
+    const stats = fs.statSync(current);
+    if (stats.isDirectory()) {
+      for (const item of fs.readdirSync(current)) {
+        visit(path.join(current, item));
+      }
+      return;
+    }
+    if (path.extname(current) !== '.md') return;
+
+    const content = fs.readFileSync(current, 'utf8');
+    if (!content.includes(assignmentStamp)) return;
+    fs.writeFileSync(current, content.split(assignmentStamp).join(stampedAssignment));
+  }
+
+  visit(rootDir);
+}
+
 // Dev artifacts that live under config/skills/ but must never ship or install.
 // Mirrors the `!` exclusions in package.json files[].
 const UNSHIPPED_SKILL_DIRS = new Set([
@@ -551,6 +586,11 @@ function installSkillsForCLI(cliKey) {
     fs.mkdirSync(cli.skillsDir, { recursive: true });
   }
 
+  const removed = cleanupDeprecated(path.dirname(cli.skillsDir));
+  if (removed > 0) {
+    log(`\n🧹 Cleaned up ${removed} deprecated file${removed > 1 ? 's' : ''}`, 'yellow');
+  }
+
   let copied = 0;
   for (const skillName of cli.skillsToInstall) {
     const src = path.join(sourceSkillsDir, skillName);
@@ -562,6 +602,7 @@ function installSkillsForCLI(cliKey) {
       fs.rmSync(dest, { recursive: true, force: true });
     }
     copyRecursive(src, dest, cli.skillsDir);
+    stampInstalledSkillDir(dest, dest);
     copied++;
     log(`  → ${cli.skillsDir.replace(os.homedir(), '~')}/${skillName}`, 'dim');
   }

package/config/skills/_shared/adapters/README.md

@@ -42,6 +42,13 @@ Specific patterns the official guide warns about for this model.
 
 Keep each section to ≤ 8 lines. Adapters are deltas, not full prompts. If an adapter grows past ~80 lines, the content probably belongs in canonical body.
 
+## Role-scoped and non-agentic adapters
+
+Adapters may add two more sections beyond the base format:
+
+- **`## Role eligibility`** — fixed ASCII fields, one per line: `executor: yes|no`, `pair_judge: yes|no`. Absent section = eligible for both roles (every adapter shipped before iter-0051). Present only when a backend is structurally unable to fill a role — e.g. a completion-only local model has no tool/file-edit access, so it declares `executor: no`. `_shared/engine-preflight.md` and `/devlyn:engines` read this section as a structured marker, not prose, so it validates mechanically.
+- **`## Invocation`** — for backends called over an API instead of a CLI: the concrete request shape (endpoint, JSON body, timeout) and the adapter-declared availability probe (`_shared/engine-preflight.md#role-resolution`'s "an adapter may declare a different probe" hook).
+
 ## When to add a new adapter
 
 A new adapter file ships when:

package/config/skills/_shared/adapters/claude.md

@@ -2,6 +2,53 @@
 
 > Source: <https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/claude-prompting-best-practices>
 
+## Invocation
+
+Orchestrator-side contract for spawning a Claude judge from a non-Claude
+orchestrator (Codex CLI, oh-my-pi) — the reverse-direction counterpart of
+`_shared/codex-config.md`. Source: <https://code.claude.com/docs/en/headless>
+and <https://code.claude.com/docs/en/cli-reference>.
+
+**Availability probe**: `command -v claude >/dev/null 2>&1`; record
+`claude --version` as evidence. The probe is necessary, not sufficient:
+`claude -p` needs network access to the Anthropic API, so a network-denying
+sandbox (e.g. Codex CLI's default `workspace-write`) fails the spawn even
+though the binary resolves. A failed spawn is the same fail-closed class as a
+failed probe (`_shared/engine-preflight.md`): explicit route →
+`BLOCKED:claude-unavailable`; automatic escalation → solo + reported skip.
+
+**Read-only pair-JUDGE call** (bounded by the VERIFY pair contract — at most
+two targeted probes; the invoking phase sets `--effort`, pair-JUDGE uses
+`medium`):
+
+```bash
+claude -p "<judge prompt>" \
+  --permission-mode dontAsk \
+  --allowedTools "Read,Grep,Glob,Bash(<repo test command> *)" \
+  --setting-sources project --strict-mcp-config --mcp-config '{"mcpServers":{}}' \
+  --effort medium \
+  > .devlyn/claude-judge.stdout 2> .devlyn/claude-judge.stderr
+```
+
+- Omit `--model` — the CLI's configured default is used (zero-touch, same
+  rule as codex-config.md's "omit `-m`").
+- `dontAsk` denies anything not allowlisted (official guide: "denies
+  anything not in your permissions.allow rules or the read-only command
+  set — useful for locked-down CI runs"); in `-p` mode a denied tool call
+  fails without prompting, so the child can never hang on a permission ask.
+- The `--setting-sources project --strict-mcp-config --mcp-config
+  '{"mcpServers":{}}'` trio is the hermetic-child pattern: no user-global
+  settings, hooks, or MCP servers. `--bare` is NOT used — it skips
+  OAuth/keychain reads and requires `ANTHROPIC_API_KEY`, which
+  subscription-auth machines do not have.
+- Findings come back as JSONL on stdout (same emission shape as the Codex
+  direction); the orchestrator writes the canonical
+  `.devlyn/verify.pair.findings.jsonl`. Raw stdout stays diagnostic at
+  `.devlyn/claude-judge.stdout`; `verify-merge-findings.py` blocks the run
+  if stdout contains findings the canonical file lacks.
+- Do not pipe stdout (`| tail`, `| grep`); capture to file. Non-zero exit or
+  empty stdout → spawn failure, fail closed per the probe rule above.
+
 ## Identity
 
 You are Claude by Anthropic. Anthropic's prompt-engineering guide for this model governs your behavior on top of the canonical phase prompt below. When the canonical body and this header conflict on tactics, the canonical body wins on what to deliver; this header wins on how to deliver it.

package/config/skills/_shared/adapters/omp.md

@@ -0,0 +1,17 @@
+# oh-my-pi adapter
+
+## Identity
+
+You are the model running behind the `omp` CLI. Follow the canonical phase prompt exactly; this adapter exists so oh-my-pi can be selected as a first-class native task worker by `/devlyn:resolve`.
+
+## Output Discipline
+
+Keep phase output machine-consumable and concise. Write the artifacts the canonical body names, update `.devlyn/pipeline.state.json` only where that phase owns the state write, and avoid narrative outside the required phase result.
+
+## Validation Pattern
+
+When the canonical body names deterministic commands, run those commands and trust their exit codes. Do not replace BUILD_GATE, phase gates, or VERIFY mechanical checks with same-context judgment.
+
+## Fresh Context
+
+Each native `task` tool invocation with a fresh `context` is a fresh phase worker. Do not call `/devlyn:resolve` recursively from inside a phase prompt; execute only the phase body you received.

package/config/skills/_shared/archive_run.py

@@ -56,7 +56,9 @@ PER_RUN_PATTERNS = (
     # ("pair_judge findings archive distinguishable") would false-fail on
     # every paired fixture without this glob.
     "verify-judge-*.md",
-    "codex-judge.*",
+    # *-judge.*: every engine's pair-judge stdout/stderr capture
+    # (codex-judge.*, claude-judge.* — adapters/claude.md ## Invocation).
+    "*-judge.*",
 )
 
 SAFE_RUN_ID_RE = re.compile(r"^[A-Za-z0-9_.-]+$")
@@ -140,12 +142,14 @@ def self_test() -> int:
             "verify-merge.summary.json",
             "codex-judge.stdout",
             "codex-judge.summary.json",
+            "claude-judge.stdout",
+            "claude-judge.stderr",
         ):
             (devlyn / name).write_text("{}\n", encoding="utf-8")
         run_id = read_run_id(devlyn)
         assert run_id == "run-1", run_id
         moved = move_artifacts(devlyn, devlyn / "runs" / run_id)
-        assert moved >= 6, moved
+        assert moved >= 8, moved
         for name in (
             "pipeline.state.json",
             "risk-probes.jsonl",
@@ -153,6 +157,8 @@ def self_test() -> int:
             "verify-merge.summary.json",
             "codex-judge.stdout",
             "codex-judge.summary.json",
+            "claude-judge.stdout",
+            "claude-judge.stderr",
         ):
             assert (devlyn / "runs" / run_id / name).is_file(), name