devlyn-cli 4.1.0 → 4.2.0

package/bin/instructions.js

@@ -119,6 +119,18 @@ function instructionParagraphs(text) {
   return paragraphs;
 }
 
+// Claude Code expands an `@AGENTS.md` import line, except inside a fenced code block.
+function importsAgentsMd(text) {
+  let fence = null;
+  for (const line of text.replace(/^\uFEFF/, '').split(/\r?\n/)) {
+    const marker = /^ {0,3}(`{3,}|~{3,})/.exec(line)?.[1];
+    if (marker && !fence) fence = marker;
+    else if (marker && marker[0] === fence[0] && marker.length >= fence.length && /^ {0,3}(?:`+|~+)\s*$/.test(line)) fence = null;
+    else if (!fence && line.trimEnd() === '@AGENTS.md') return true;
+  }
+  return false;
+}
+
 function customInstructions(text, name, template, managed = false) {
   const known = new Set([
     ...legacyTemplates.paragraphs[name],
@@ -168,7 +180,9 @@ function retainFile(file, bytes) {
   }
 }
 
-function updateInstructions(name) {
+// `withBlock` false removes the devlyn defaults the file holds, keeping everything else. `write` false writes nothing
+// and returns whether the file needs an update, a merge included.
+function updateInstructions(name, initial = '', withBlock = true, write = true) {
   const templatePath = path.join(__dirname, '..', name);
   const template = fs.readFileSync(templatePath, 'utf8');
   if (template.includes(BEGIN) || template.includes(END)) {
@@ -187,16 +201,18 @@ function updateInstructions(name) {
     throw new InstructionError(`Instruction file must be a regular file; preserved: ${dest}. Move it aside and rerun, then merge your shared rules outside the managed block.`);
   }
   const before = exists ? fs.readFileSync(dest) : Buffer.alloc(0);
-  let current;
+  let current = initial;
   try {
-    current = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(before);
+    if (exists) current = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(before);
   } catch (cause) {
     throw new InstructionError(`${name} must be UTF-8; original preserved. Convert its encoding and rerun installation.`, { cause });
   }
   const eol = current.match(/\r?\n/)?.[0] || '\n';
   const block = managedBlock(template, eol);
+  const inserted = withBlock ? block : '';
   const recovery = path.join(process.cwd(), '.devlyn', 'instructions');
   const conflict = (reason) => {
+    if (!write) return true;
     const incoming = path.join(recovery, `${name}.${digest(block)}.incoming`);
     const backup = path.join(recovery, `${name}.${digest(before)}.backup`);
     const guide = path.join(recovery, `${name}.${digest(before)}.${digest(block)}.merge.md`);
@@ -231,8 +247,11 @@ function updateInstructions(name) {
     const custom = digest(normalize(previous)) === start[1] ? ''
       : customInstructions(previous, name,
         'Project-specific instructions outside this managed block take precedence over these defaults.\n\n' + template, true);
+    const after = current.slice(end.index + end[0].length);
     content = current.slice(0, start.index + (start[0].startsWith('\uFEFF') ? 1 : 0))
-      + custom + (custom ? eol : '') + block + current.slice(end.index + end[0].length);
+      + custom + (custom ? eol : '') + inserted + after;
+    // A block removed from the end takes along the blank lines that set it apart.
+    if (!inserted && !after) content = content.replace(/(\r?\n)(?:\r?\n)+$/, '$1');
   } else {
     const normalized = normalize(template);
     const bodyStart = normalized.indexOf('## North Star\n');
@@ -246,14 +265,15 @@ function updateInstructions(name) {
     if (ranges.length === 1 && !LEGACY.test(current.slice(0, ranges[0].start)
         + ranges[0].custom + current.slice(ranges[0].end))) {
       const { start, end, custom } = ranges[0];
-      content = current.slice(0, start) + custom + block + current.slice(end);
+      content = current.slice(0, start) + custom + inserted + current.slice(end);
     } else {
       const custom = customInstructions(current, name, template);
-      content = custom + (custom ? eol + eol : '') + block;
+      content = custom + (custom && inserted ? eol + eol : '') + inserted;
     }
   }
   const bytes = Buffer.from(content);
   if (bytes.equals(before)) return false;
+  if (!write) return true;
   if (exists) {
     const backup = path.join(recovery, `${name}.${digest(before)}.backup`);
     retainFile(backup, before);
@@ -270,8 +290,9 @@ function updateInstructions(name) {
   } finally {
     if (fs.existsSync(temp)) fs.unlinkSync(temp);
   }
-  console.log(`  → Updated Devlyn defaults in ${name}; project-specific instructions preserved`);
+  console.log(!exists ? `  → Created ${name}`
+    : `  → ${withBlock ? 'Updated Devlyn defaults in' : 'Removed Devlyn defaults from'} ${name}; project-specific instructions preserved`);
   return true;
 }
 
-module.exports = { updateInstructions, InstructionError, instructionParagraphs, holdsDevlynDefaults };
+module.exports = { updateInstructions, InstructionError, instructionParagraphs, holdsDevlynDefaults, importsAgentsMd };

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

@@ -1,92 +1,15 @@
 # Claude adapter
 
-> 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>.
+A Claude executor starts as
+`claude -p "<prompt>" --dangerously-skip-permissions --add-dir "<common git dir>"`,
+where `<common git dir>` is `git rev-parse --path-format=absolute --git-common-dir`:
+a linked task worktree commits there.
 
 **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
-python3 "$DEVLYN_SHARED_DIR/run-bounded.py" 600 --stdin-file "<judge-prompt-file>" --record-transport -- claude -p \
-  --permission-mode dontAsk \
-  --tools "Read,Grep,Glob" --allowedTools "Read,Grep,Glob" \
-  --setting-sources project --strict-mcp-config --mcp-config '{"mcpServers":{}}' \
-  --effort medium \
-  > .devlyn/claude-judge.stdout 2> .devlyn/claude-judge.stderr
-```
-
-- Write the complete prompt as exact UTF-8 file bytes; no positional prompt or shell substitution. With `--record-transport`, the runner snapshots stdin and exclusively creates `<judge-prompt-file>.transport.json` to bind actual native argv and delivered bytes; an existing carrier rejects dispatch. Preserve it for explicit judge-role authentication. Ordinary `--stdin-file` reads require no output or writable input directory; without it, stdin remains DEVNULL.
-- 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.
-- Exit 124 is a wall-budget abort (terminates the native child process tree; POSIX process group) → the orchestrator
-  writes `.devlyn/verify.pair.timeout.json`; budget abort ≠ availability failure
-  and the fail-closed availability rules above are unchanged.
-- Do not pipe stdout (`| tail`, `| grep`); capture to file. Non-zero exit other
-  than 124 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.
-
-## Output discipline
-
-You calibrate response length to task complexity automatically — keep simple lookups short, scale up only when the task warrants it. Do NOT pad with context the user didn't ask for. When the canonical body sets a structural format (XML, JSON, sections), follow it literally; do not silently restructure.
-
-## Examples and structure
-
-When prompt maintenance adds examples for Claude, prefer concise positive examples over lists of negative prohibitions. Wrap examples in `<example>` tags (or `<examples>` for several) so examples stay distinct from instructions and variable inputs.
-
-## Tool-use posture
-
-When the canonical body lists tools, use them when their result would change your answer. Make independent tool calls in parallel; chain only when one depends on another's output. Do not narrate "I'll now call X" preambles unless the canonical body requests progress updates.
-
-## Effort and autonomy
-
-For long-horizon coding, review, and agentic runs, assume the harness selected `high` or `xhigh` effort unless told otherwise. Spend that depth on upfront task/constraint understanding and end-state verification, not on verbose narration. If the user or orchestrator gives a complete task in one turn, proceed autonomously instead of requiring progressive clarification.
-
-## Anti-patterns
-
-You interpret instructions literally and explicitly. The official guide is explicit about three failure modes:
-
-1. **Review-prompt self-filtering**: when the canonical body asks for findings, report every issue you find — including low-severity and low-confidence ones; do not filter for importance or confidence. The harness has a separate filter step.
-2. **Subagent spawning**: do NOT spawn a subagent for work you can complete in a single response. Spawn only when the canonical body explicitly requests it OR when fanning out across independent items.
-3. **Overengineering**: do NOT add files, abstractions, error handling, validation, or "future flexibility" beyond what the spec asks. A bug fix doesn't need surrounding cleanup. The right complexity is the minimum needed for the current task.
-
-You do NOT need stronger imperatives ("CRITICAL!", "YOU MUST!") to follow rules. Normal phrasing is sufficient.
-
-## Explicit role capability
-
-`role-config.py` validates explicit CLI judge effort against this bounded native capability declaration. Source: Claude Code2.1.263 built-in Fable5.1 metadata (native SHA ef5d2909c8af49f31ab6d5487e90316777bc2fac170adfe8160716caa8aaf4f9, byte157907500; effort/max/xhigh gates159068038/159068443/159068839). This is option support, not model fitness. Unknown version/model effort support fails with actionable unsupported-role-option. Model-only requests pass the exact ID to the native CLI without this effort table and still require matching native result evidence; engine-only defaults remain available. Native Agent workers have no validated exact-model/effort transport here, so explicit worker fields are rejected instead of switching channels.
-
-<!-- devlyn-effort 2.1.263 claude-fable-5-1 low,medium,high,xhigh,max -->
-
-For an explicit CLI judge profile, use the resolved `--model`/`--effort` in the bounded read-only invocation and add `--output-format json`. Follow the canonical resolve `JUDGE_STEM` round-scoped argv/prompt/raw capture and `judge-role-evidence.py` derivation contract. Only its exact derived result goes to the findings collector; never feed the JSON wrapper directly. Omitted options keep that role’s existing defaults.
+`claude -p` needs network access to the Anthropic API, so in a network-denying
+sandbox (e.g. Codex CLI's default `workspace-write`) it fails even though the
+binary resolves. A drain blocks when the executor cannot start, and a task
+whose executor exits without a submission waits for the next drain.

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

@@ -1,34 +1,14 @@
-# Codex (OpenAI) adapter
-
-> Source: <https://developers.openai.com/api/docs/guides/prompt-guidance?model=gpt-5.5>
-
-## Identity
-
-You are OpenAI's Codex model. OpenAI's prompt-guidance for this model governs your behavior on top of the canonical phase prompt below.
-
-## Output discipline
-
-Your default is efficient, direct, task-oriented. The canonical body specifies the outcome and constraints; you choose the efficient path. Do not over-specify process steps when an outcome is clearly stated. Use Markdown only where it carries structure (`inline code`, code fences, short lists/tables); otherwise favor short paragraphs and natural transitions. When `text.verbosity` is `low`, prefer even shorter responses.
-
-## Tool-use posture
-
-Resolve the request in the fewest useful tool loops without sacrificing correctness. For retrieval tasks: start with one broad search using short discriminative keywords; make another retrieval call only when the top results don't answer the core question or a required fact / parameter / source is missing. For tool-heavy tasks, start with a brief preamble: a one-line acknowledgment of the request and the first step you'll take.
-
-For a constrained-read VERIFY packet, judge the supplied material without tools; missing or unbound inputs require a verdict-binding BLOCKED finding. Keep the read-only sandbox and bounded review. Otherwise, for VERIFY JUDGE retrieval, batch related reads. After sealed parity proves a
-canonical file and its `.agents` mirror are byte-identical, inspect the
-canonical file only. Open self-test bodies or MECHANICAL raw streams only for a
-named clause that remains unresolved after the broad pass.
-
-## Anti-patterns
-
-The official guide warns explicitly about carrying over instructions from older prompt stacks — earlier models needed more help, and process-heavy directives now narrow GPT-5.5's search space.
-
-1. **Avoid absolute imperatives for judgment calls.** ALWAYS / NEVER / must / only are reserved for true safety invariants and required output fields. For judgment calls, use decision rules with conditions ("when X, do Y"). The canonical body uses this style; do not promote softer guidance to absolute rules.
-2. **Don't over-specify process when the destination is clear.** If the canonical body names the outcome, choose the path; do not narrate every step.
-3. **Stop rules are explicit.** When the canonical body or the harness asks you to stop / abstain / ask, follow the stop rule rather than retrying loops indefinitely. Loop-minimization does not outrank correctness or required citation.
-
-## Prompt-maintenance cue
-
-When asked to improve a failed prompt, act as a metaprompter for itself: name the observed failure, then propose the smallest instruction to add, remove, or relocate. Prefer subtractive changes before adding new rules; keep the canonical body model-neutral and put only GPT-specific tactics in this adapter.
-
-Do not narrate internal deliberation. State results and decisions directly.
+# Codex adapter
+
+## Invocation
+
+A Codex executor runs through `_shared/codex-monitored.sh`, never a raw or piped
+`codex exec`: `bash "$DEVLYN_SHARED_DIR/codex-monitored.sh" <arguments for codex exec> "<prompt>"`.
+The `workspace-write` sandbox keeps `.git` read-only, so an executor that commits adds as
+writable roots the common Git directory (`git rev-parse --path-format=absolute --git-common-dir`)
+plus, in a linked worktree, its own Git directory (`git rev-parse --path-format=absolute --git-dir`),
+listed exactly because the sandbox protects it even under a listed parent. It also
+denies network, which installing a new dependency needs:
+`-s workspace-write -c 'sandbox_workspace_write.writable_roots=["<git dir>","<worktree git dir>"]' -c 'sandbox_workspace_write.network_access=true'`.
+Deliver a multiline prompt as exact file bytes: set `DEVLYN_CODEX_PROMPT_FILE=<file>`
+and pass the sole prompt argument `-`.

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

@@ -1,13 +1,3 @@
 # 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.
-
-## 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.
+Engine `omp`, the oh-my-pi CLI.

package/config/skills/_shared/codex-monitored.sh

@@ -22,9 +22,9 @@
 #      (Round 2 finding #1 fix: shim alone does not defeat `| tail`; the
 #      wrapper must reject the pipe shape directly.)
 #   2. Closes stdin unless DEVLYN_CODEX_PROMPT_FILE supplies the sole prompt.
-#   3. Streams codex stdout to OUR stdout line-by-line — the orchestrator reads
-#      stdout as the subagent reply (per `_shared/codex-config.md`) so we MUST
-#      NOT swallow it (e.g. `tail -n 200`). codex stderr forwards to OUR stderr.
+#   3. Streams codex stdout to OUR stdout line-by-line — the caller reads
+#      stdout as the Codex reply, so we MUST NOT swallow it (e.g.
+#      `tail -n 200`). codex stderr forwards to OUR stderr.
 #   4. Emits a `[codex-monitored] heartbeat` line every CODEX_MONITORED_HEARTBEAT
 #      seconds (default 30s) on STDERR while codex is alive. Heartbeat-on-stderr
 #      keeps the orchestrator's combined-output stream non-silent without
@@ -47,18 +47,10 @@
 #                                     CODEX_REAL_BIN when set, else `codex`.
 #                                     Set this when the shim has put us first
 #                                     on PATH.
-#   CODEX_MONITORED_ISOLATED       — set non-empty for bounded read-only
-#                                     probe/judge calls that must ignore
-#                                     user config, project rules, session
-#                                     persistence, and hook side effects.
 #   CODEX_MONITORED_ALLOW_PIPED    — set non-empty to skip the pipe-stdout
 #                                     refusal. Reserved for tests; don't use
 #                                     in skill prompts.
 #   DEVLYN_CODEX_PROMPT_FILE      — exact binary stdin prompt; requires sole `-`.
-#   DEVLYN_INVOCATION_*             — run/phase/round/workdir/prompt/session/
-#                                     receipt identity. When any is set, all
-#                                     are required and the wrapper seals a
-#                                     canonical invocation receipt.
 
 set -uo pipefail
 
@@ -120,45 +112,6 @@ require_positive_int() {
 require_positive_int CODEX_MONITORED_HEARTBEAT "$HEARTBEAT_SEC"
 require_nonnegative_int CODEX_MONITORED_TIMEOUT_SEC "$TIMEOUT_SEC"
 
-RECEIPT_ENABLED=""
-for receipt_value in \
-  "${DEVLYN_INVOCATION_RUN_ID:-}" \
-  "${DEVLYN_INVOCATION_PHASE:-}" \
-  "${DEVLYN_INVOCATION_ROUND:-}" \
-  "${DEVLYN_INVOCATION_WORKDIR:-}" \
-  "${DEVLYN_INVOCATION_PROMPT_FILE:-}" \
-  "${DEVLYN_INVOCATION_SESSION_FILE:-}" \
-  "${DEVLYN_INVOCATION_RECEIPT:-}"; do
-  if [ -n "$receipt_value" ]; then
-    RECEIPT_ENABLED=1
-  fi
-done
-if [ -n "$RECEIPT_ENABLED" ]; then
-  for receipt_name in \
-    DEVLYN_INVOCATION_RUN_ID DEVLYN_INVOCATION_PHASE DEVLYN_INVOCATION_ROUND \
-    DEVLYN_INVOCATION_WORKDIR DEVLYN_INVOCATION_PROMPT_FILE \
-    DEVLYN_INVOCATION_SESSION_FILE DEVLYN_INVOCATION_RECEIPT; do
-    eval "receipt_value=\${$receipt_name:-}"
-    if [ -z "$receipt_value" ]; then
-      printf '[codex-monitored] error: %s is required for invocation receipt\n' \
-        "$receipt_name" >&2
-      exit 64
-    fi
-  done
-  require_nonnegative_int DEVLYN_INVOCATION_ROUND "$DEVLYN_INVOCATION_ROUND"
-fi
-
-if [ -n "${CODEX_MONITORED_ISOLATED:-}" ]; then
-  CODEX_ARGS=(
-    --ignore-user-config
-    --ignore-rules
-    --ephemeral
-    --disable codex_hooks
-    --disable hooks
-    "${CODEX_ARGS[@]}"
-  )
-fi
-
 # --- Pipe-stdout refusal (iter-0009 R2 finding #1) -------------------------
 # `[ -p /dev/stdout ]` is the POSIX test for "is fd 1 a FIFO/pipe". Verified
 # correct on macOS via lsof: distinguishes piped (`| cat`) from redirected
@@ -266,9 +219,6 @@ trap cleanup EXIT
 
 printf '[codex-monitored] start: ts=%s heartbeat=%ds timeout=%ss bin=%s\n' \
   "$(date -u +%FT%TZ)" "$HEARTBEAT_SEC" "$TIMEOUT_SEC" "$CODEX_BIN" >&2
-if [ -n "${CODEX_MONITORED_ISOLATED:-}" ]; then
-  printf '[codex-monitored] isolated=1\n' >&2
-fi
 
 RECEIPT_HELPER="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/invocation-receipt.py"
 # Native Python owns Windows PIDs and the timeout tree; MSYS PIDs are different.
@@ -304,7 +254,7 @@ if [ -n "$TIMEOUT_FLAG" ] && [ -f "$TIMEOUT_FLAG" ]; then
   EXIT=124
 fi
 
-if [ -n "$RECEIPT_ENABLED" ] || [ -n "${DEVLYN_CODEX_PROMPT_FILE:-}" ]; then
+if [ -n "${DEVLYN_CODEX_PROMPT_FILE:-}" ]; then
   python3 "$RECEIPT_HELPER" complete-dispatch --exit-code "$EXIT" || exit 64
 fi
 

package/config/skills/_shared/engine-doctor.sh

@@ -5,25 +5,18 @@
 # just what's pinned. This script never writes .devlyn/engines.json, never
 # installs anything, never changes pin validation — it only reports.
 #
-# CATALOG NOTE: `pi` (bin/devlyn.js's Pi/earendil-works install target) has
-# no verified CLI binary name anywhere in this repo — its own installer
-# detect() only checks project marker files, never shells out to a binary.
-# Fabricating a `command -v pi` check would be a guess this repo's evidence
-# rule forbids, so its binary column reports "unknown" rather than "no".
-#
 # macOS-safe bash 3.2: no associative arrays, no mapfile/readarray.
 set -uo pipefail
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")" && pwd)"
 ADAPTERS_DIR="$SCRIPT_DIR/adapters"
 
-TARGETS=(claude codex grok omp pi)
-KINDS=(cli-engine cli-engine cli-engine cli-engine orchestrator-only)
-BINARIES=(claude codex grok omp "")
+TARGETS=(claude codex omp pi)
+KINDS=(cli-engine cli-engine cli-engine orchestrator-only)
+BINARIES=(claude codex omp "")
 INSTALL_HINTS=(
   "see https://docs.anthropic.com/en/docs/claude-code"
   "npm install -g @openai/codex"
-  "see https://docs.x.ai/build/overview (install + browser auth)"
   "brew install can1357/tap/omp"
   ""
 )
@@ -39,72 +32,39 @@ check_adapter() {
   if [ -f "$ADAPTERS_DIR/$1.md" ]; then printf 'yes'; else printf 'no'; fi
 }
 
-check_role() {
-  # $1 = adapter file path. Reads the optional `## Role eligibility` fixed
-  # ASCII fields (_shared/adapters/README.md); absent file or section = both
-  # roles eligible by default (every adapter shipped before iter-0051).
+check_executor() {
+  # $1 = adapter file path. An adapter may declare the fixed ASCII field
+  # `executor: no` under `## Role eligibility`; otherwise it can execute.
   [ -f "$1" ] || { printf 'n/a'; return; }
-  local exec_ok='yes' judge_ok='yes'
-  grep -q '^executor: no' "$1" 2>/dev/null && exec_ok='no'
-  grep -q '^pair_judge: no' "$1" 2>/dev/null && judge_ok='no'
-  if [ "$exec_ok" = 'yes' ] && [ "$judge_ok" = 'yes' ]; then printf 'executor+judge'
-  elif [ "$judge_ok" = 'yes' ]; then printf 'judge-only'
-  elif [ "$exec_ok" = 'yes' ]; then printf 'executor-only'
-  else printf 'none'
-  fi
+  if grep -q '^executor: no' "$1" 2>/dev/null; then printf 'no'; else printf 'yes'; fi
 }
 
-printf '%-8s %-17s %-8s %-8s %-14s %-12s %s\n' \
-  'target' 'kind' 'binary' 'adapter' 'role' 'pin_eligible' 'note'
-
-pin_eligible_count=0
-missing_hints=()
+printf '%-8s %-17s %-8s %-8s %-9s %s\n' \
+  'target' 'kind' 'binary' 'adapter' 'executor' 'note'
 
 for i in "${!TARGETS[@]}"; do
   target="${TARGETS[$i]}"
   kind="${KINDS[$i]}"
   binary="$(check_binary "${BINARIES[$i]}")"
   adapter="$(check_adapter "$target")"
-  role="$(check_role "$ADAPTERS_DIR/$target.md")"
-
-  pin_eligible='no'
-  case "$kind" in
-    cli-engine) [ "$binary" = 'yes' ] && [ "$adapter" = 'yes' ] && pin_eligible='yes' ;;
-  esac
+  executor="$(check_executor "$ADAPTERS_DIR/$target.md")"
 
   note='-'
   case "$kind" in
     cli-engine)
-      if [ "$pin_eligible" = 'yes' ]; then
-        pin_eligible_count=$((pin_eligible_count + 1))
-      elif [ "$binary" = 'no' ]; then
+      if [ "$binary" = 'no' ]; then
         note="not installed; ${INSTALL_HINTS[$i]}"
-        missing_hints+=("$target: ${INSTALL_HINTS[$i]}")
-      else
-        note="binary present, no adapter — ship _shared/adapters/$target.md"
+      elif [ "$adapter" = 'no' ]; then
+        note="binary present, no adapter — reinstall devlyn-cli, whose releases ship the adapters"
+      elif [ "$executor" = 'no' ]; then
+        note='adapter declares executor: no'
       fi
       ;;
     orchestrator-only)
-      note='informational only; not a routable role engine — no verified CLI binary or adapter'
+      note='informational only; not a routable engine — no verified CLI binary or adapter'
       ;;
   esac
 
-  [ "$target" = 'grok' ] && note='not emission-certified; BLOCKED pair source'
-
-  printf '%-8s %-17s %-8s %-8s %-14s %-12s %s\n' \
-    "$target" "$kind" "$binary" "$adapter" "$role" "$pin_eligible" "$note"
+  printf '%-8s %-17s %-8s %-8s %-9s %s\n' \
+    "$target" "$kind" "$binary" "$adapter" "$executor" "$note"
 done
-
-printf '\n'
-if [ "$pin_eligible_count" -lt 2 ]; then
-  printf 'Recommendation: only %d adapter-valid engine(s) available. VERIFY pair-judge and\n' "$pin_eligible_count"
-  printf 'risk-probe escalation need a second, genuinely different model to check against —\n'
-  printf 'iter-0045 found different model tiers hit different failure-mode blind spots (not\n'
-  printf 'that any arbitrary second model helps); with fewer than 2, those routes can never\n'
-  printf 'fire and every run stays solo. Add one of:\n'
-  for hint in "${missing_hints[@]}"; do
-    printf '  - %s\n' "$hint"
-  done
-else
-  printf 'Pair-judge diversity: %d adapter-valid engines available.\n' "$pin_eligible_count"
-fi

package/config/skills/_shared/engine-preflight.md

@@ -1,61 +1,29 @@
-# Shared — Engine Pre-flight
+# Shared — Executor Pre-flight
 
-Used by `/devlyn-resolve` and `/devlyn-ideate`. One shared availability rule so every skill routes identically.
+Used by `/devlyn-ideate` and `/devlyn-engines`: one rule for which engine executes implementation work and what happens when it is missing.
 
-## Rule
+## Selection
 
-Each skill resolves the effective engine from its own SKILL.md default plus any explicit `--engine` flag passed by the user. `/devlyn-resolve` also computes the default VERIFY-pair route and conditional risk-probe requirements before the phase that needs the OTHER engine.
+The executor is the `executor` pin in `.devlyn/engines.json` at the checkout root (set with `/devlyn-engines executor <name>`), else the CLI the user opened. A linked worktree or subdirectory has no pin unless one is set there. Pi and Grok have no executor adapter, so a drain from them needs a claude, codex or omp pin. Keys earlier releases wrote for retired pipeline roles (`pair_judge_priority`, `roles`) stay as written and select nothing: a worker profile never becomes the executor.
 
-Engine requirements have two classes:
+Before dispatching to the executor, run:
 
-- **Explicit routes** — `--engine`, `--risk-probes`, `--pair-verify`, configured executor/role/priority pins. These are promises. If the required engine is unavailable, fail closed with `BLOCKED:<engine>-unavailable` and never downgrade to solo.
-- **Automatic routes** — high-risk risk-probes remain conditional; VERIFY pair-JUDGE is selected by default unless `--no-pair` was passed. Both require an available OTHER engine. If it is absent, proceed solo and report the skipped route and reason. This is route selection, not a fallback.
-
-## Role resolution
-
-The orchestrator is the CLI the user opened. PLAN remains orchestrator-fixed. Resolve the legacy executor as explicit `--engine` > `cwd/.devlyn/engines.json` `executor` > the invoking skill's supported default. BUILD_GATE runs commands in the orchestrator without a separate model; risk-probe derivation keeps its existing route.
-
-The role profiles and `--role-config` below apply only to `/devlyn-resolve`; `/devlyn-ideate` keeps its existing `--engine` / legacy executor selection and never inherits worker/judge profiles. `role-config.py` is resolve’s deterministic resolver. Optional project `roles.worker`, `roles.primary_judge`, and `roles.pair_judge` each require `engine` and accept exact `model`/`effort`; `/devlyn-resolve --role-config <path>` supplies the same `{"roles": {...}}` object for one run. Each entry replaces the entire lower entry. Worker/primary precedence is run role > `--engine` engine-only > project role > legacy executor. Pair precedence is run role > project role > existing `pair_judge_priority`/binary complement. An absent primary profile follows the legacy executor, not the worker profile. No parent/global devlyn config lookup.
-
-Worker controls IMPLEMENT, its included code/doc cleanup, and their repair rounds only; owner CLEANUP performs artifact/invariant checks without a worker dispatch; primary/pair control VERIFY only. OTHER must differ from the resolved primary engine. Explicit same-engine pair is invalid; a legacy priority list skips the primary. `--no-pair` does not dispatch or check availability of an unused pair. Configured pins remain explicit promises, while an unconfigured unavailable automatic OTHER records its solo reason.
-
-Before the first phase, `/devlyn-resolve` freezes resolution with `state-phase-write.py --freeze-roles`; subsequent status/dispatch reads that state instead of mutable config. `state.engine` stays the legacy executor. The resolver rejects statically unsupported selected channel fields before PLAN, and validates adapter names and the existing ASCII `executor: yes|no` / `pair_judge: yes|no` eligibility markers; absent eligibility section means both. Malformed configuration fails with `BLOCKED:invalid-engine-config`.
-
-Before each affected worker/judge, read `role-config.py --state .devlyn/pipeline.state.json --role <role> [--resolved-model <inherited-exact-model>]`. It returns source/channel, requested values and argv additions. Explicit Codex options require current version-matching native model metadata; refresh the native CLI's cache when missing/stale. Explicit Claude judge effort requires the adapter's version/exact-model capability declaration; model-only selection passes the exact ID without that effort declaration and validates the native result. No model/effort fields means unchanged phase defaults. Unknown support fails with `BLOCKED:unsupported-role-option`; no clamp, fallback or invented model identity. Native Agent workers reject unsupported explicit Claude fields without switching to a CLI worker. Show inherited/unknown values honestly; availability is not role fitness.
-
-Engine-only adapter routes remain supported according to existing eligibility. New adapters do not automatically gain explicit model/effort mappings. Status reports unavailable pins and unresolved legacy channels without weakening run freeze/dispatch. CLI presence is not authentication. Status never launches a model, changes user configuration or promotes a default.
-
-When a run or phase requires engine `<name>` (claude, codex, omp, or any adapter-backed engine), before spawning that phase:
+```sh
+python3 "$DEVLYN_SHARED_DIR/role-config.py" --workdir <project> --default-engine <this CLI> --select
+```
 
-1. Run the adapter's availability probe — default `command -v <name> >/dev/null 2>&1`; an adapter's `## Invocation` section may declare a stricter contract (e.g. `adapters/claude.md`: the probe is necessary but not sufficient under a network-denying sandbox, so a failed spawn is handled identically to a failed probe).
-2. On failure -> set the current phase/run verdict to `BLOCKED:<name>-unavailable`, preserve the failed check evidence, and show the adapter's setup guidance: install/configure that CLI, run its auth/login flow, verify `<name> --version`, then rerun. If the user intentionally wants solo VERIFY, they may rerun with `--no-pair`.
-3. On success -> proceed with the original engine value.
+A pin is a promise. When the pinned engine's CLI is unavailable, the command exits 1 with `BLOCKED:<engine>-unavailable`: stop, preserve the evidence, and show the setup guidance — install and authenticate that CLI, verify `<engine> --version`, rerun. Never substitute another engine. A malformed file, or a name without an executor-eligible adapter, is `BLOCKED:invalid-engine-config`. CLI presence is not authentication, and status never launches a model.
 
-Never prompt the user mid-pipeline. Missing engines for explicit routes are BLOCKED states, not silent fallbacks. Missing OTHER engines for automatic escalations are reported solo-skips, not fallbacks — the auto route was never selected.
+## Engines
 
-Per-skill defaults: `/devlyn-resolve` uses Claude for IMPLEMENT when the orchestrator has Claude Code's native Agent primitive; Codex CLI and oh-my-pi orchestrators use their own fresh worker as the default route (Codex child process, omp native `task`) so implementation and independent verification retain structural isolation. PLAN uses the owner context; BUILD_GATE/CLEANUP use owner commands. VERIFY invokes the OTHER engine by default when available unless `--no-pair` was passed. `/devlyn-ideate` defaults to Claude; `--engine` selects the elicitation/normalization adapter, not an automatic cross-model challenge phase. Any future ideate read-only critique must follow `_shared/codex-config.md` isolation rules. Each SKILL.md flag block is source of truth for that skill's default.
+An engine is pinnable when `_shared/adapters/<name>.md` exists and does not declare `executor: no` under `## Role eligibility`. Adapters ship with devlyn-cli releases, and a reinstall replaces `_shared`. An adapter's `## Invocation` says how to start it. On native Windows, use native Node/npm and Python (`python3` on PATH), with Git for Windows Bash for the shipped shell wrapper.
 
-## What a skill must report after a BLOCKED engine check
+## Reporting a blocked engine
 
-When an engine required by the selected route or default VERIFY pair route is absent, the final user-facing report/summary shows the requested route, the missing engine, and setup steps:
+The final report names the selected engine, the verdict and the setup steps; it never reports a downgraded success:
 
 ```
-Engine: claude + codex pair required
+Engine: codex (pinned executor)
 Verdict: BLOCKED:codex-unavailable
-Setup: install/configure Codex CLI; run the current Codex auth/login flow; verify `codex --version`; rerun. Use `--no-pair` only for an intentional solo VERIFY run.
+Setup: install/configure Codex CLI; run the current Codex auth/login flow; verify `codex --version`; rerun.
 ```
-
-Do not report a downgraded successful run when a required engine is missing.
-
-## Canonical cross-engine invocations
-
-For native Windows, use native Node/npm and Python (`python3` on PATH), with Git for Windows Bash for the shipped shell wrapper. Supported npm engine shims resolve to native argv; unsupported/malformed shims fail visibly. Deliver multiline prompts from files: Codex uses `DEVLYN_CODEX_PROMPT_FILE` with explicit `-`; Claude uses `run-bounded.py 600 --stdin-file <prompt-file> --record-transport -- claude -p`. Retain generated transport evidence. A policy-denied Codex judge read uses the complete inline no-tools packet in `_shared/codex-config.md#constrained-windows-judge-reads`, keeping read-only isolation and the selected role.
-
-After the availability check passes, Codex keeps the monitored `codex-monitored.sh`
-path; every other resolved OTHER engine follows `_shared/adapters/<name>.md`
-`## Invocation`. Capture `.devlyn/<name>-judge.stdout`, then normalize it with
-`collect-codex-findings.py --devlyn-dir "<abs repo>/.devlyn" --stdout-file
-<name>-judge.stdout`. A non-zero collector exit writes no canonical findings:
-the pair source is `BLOCKED` for `verify.pair.emission-contract`, and unparsed
-stdout remains diagnostic-only rather than being merged. On exit 124, the
-timeout marker's `engine` field is the resolved `<name>`.