claude-dev-env 1.94.0 → 2.0.0

package/skills/grokify/evals/run-capability-evals.mjs

@@ -0,0 +1,545 @@
+#!/usr/bin/env node
+/**
+ * Opt-in live Grok capability evals (E1–E5).
+ *
+ * Never wired into package.json `test`. Requires GROK_CAPABILITY_EVALS=1 or --run.
+ */
+import { spawnSync } from 'node:child_process';
+import {
+  existsSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const OPT_IN_ENV = 'GROK_CAPABILITY_EVALS';
+const OPT_IN_VALUE = '1';
+const RUN_FLAG = '--run';
+const GROK_BINARY = process.env.GROK_BIN || 'grok';
+const DEFAULT_MAX_TURNS = 12;
+const SPAWN_MAX_TURNS = 20;
+const SKILL_MAX_TURNS = 16;
+const WRITE_MAX_TURNS = 12;
+const WORKFLOW_MAX_TURNS = 8;
+const PROBE_FILE_NAME = 'capability-probe-write.txt';
+const PROBE_FILE_CONTENTS = 'capability-probe-ok';
+const HOOKS_LOG_NAME = 'hooks.log';
+const HOOKS_LOG_GLOBAL_SETTINGS_MARKER = 'global/settings';
+const HOOKS_LOG_PRE_TOOL_USE_MARKER = 'pre_tool_use';
+const SPAWN_MARKER = 'SPAWN_OK';
+const SPAWN_SUBAGENT_TOOL = 'spawn_subagent';
+const GROK_SPAWN_TIMEOUT_MS = 600000;
+const SPAWN_MAX_BUFFER_BYTES = 20 * 1024 * 1024;
+const WORKFLOW_RESULT_NO_TOOL = 'no_tool';
+const SPAWN_TIMEOUT_ERROR_CODE = 'ETIMEDOUT';
+const ENVELOPE_TEXT_FIELDS_BY_PRIORITY = ['result', 'text', 'message'];
+const STREAM_EVENT_TEXT_FIELDS_BY_PRIORITY = ['result', 'text', 'content'];
+
+const E1_PROMPT = `You are running a capability inventory. Do not edit files.
+
+1. Inspect your available tools.
+2. Check whether agents and skills directories exist under the user's Claude config (typical locations: ~/.claude/agents, ~/.claude/skills).
+
+Reply with ONLY one JSON object and nothing else:
+{
+  "can_spawn_subagent_tool": <true if a spawn_subagent tool is available>,
+  "tool_names": [<string tool names>],
+  "agents_dir_exists": <bool>,
+  "skills_dir_exists": <bool>
+}`;
+
+const E2_PROMPT = `You are measuring spawn_subagent.
+
+1. Use spawn_subagent (or the equivalent agent-spawn tool) once.
+2. Instruct the child to print exactly ${SPAWN_MARKER} on its first line, then list basenames from the agents directory under the user's Claude config (for example ~/.claude/agents).
+3. Wait for the child to finish.
+
+Reply with ONLY one JSON object and nothing else:
+{
+  "spawn_succeeded": <true if the child ran and returned ${SPAWN_MARKER}>,
+  "child_excerpt": "<excerpt of child output that includes its first line>"
+}`;
+
+const E3_PROMPT = `You are measuring skill readability under an agent definition.
+
+1. Read any one skill entrypoint under the user's Claude skills path (for example ~/.claude/skills/*/SKILL.md). Prefer a short file if several exist.
+2. Confirm you loaded an agent definition for this run (this process was started with --agent).
+
+Reply with ONLY one JSON object and nothing else:
+{
+  "skill_read_ok": <true if you read a skill file's contents>,
+  "skill_path": "<path you read or empty string>",
+  "agent_definition_loaded": <true if an agent definition is active>
+}`;
+
+const E4_PROMPT = `You are measuring write capability in the current working directory.
+
+1. Write a file named ${PROBE_FILE_NAME} in the current working directory with exact contents: ${PROBE_FILE_CONTENTS}
+2. Do not write anything else.
+
+Reply with ONLY one JSON object and nothing else:
+{
+  "write_succeeded": <true if the write completed>,
+  "written_path": "<absolute or relative path written>"
+}`;
+
+const E5_PROMPT = `You are measuring whether a Claude/GSD Workflow tool is available.
+
+Inspect your tool list. Do not invent a Workflow tool.
+
+Reply with ONLY one JSON object and nothing else:
+{
+  "has_workflow_tool": <true only if a Workflow tool is present>,
+  "result": <"has_tool" or "no_tool">
+}`;
+
+function isOptedIn(allArguments) {
+  if (allArguments.includes(RUN_FLAG)) {
+    return true;
+  }
+  return process.env[OPT_IN_ENV] === OPT_IN_VALUE;
+}
+
+function printOptInHelp() {
+  console.log(
+    [
+      'Grok capability evals are opt-in only (not part of npm test / CI).',
+      '',
+      'Run with either:',
+      `  ${OPT_IN_ENV}=${OPT_IN_VALUE} node skills/grokify/evals/run-capability-evals.mjs`,
+      '  node skills/grokify/evals/run-capability-evals.mjs --run',
+      '',
+      'See skills/grokify/evals/README.md.',
+    ].join('\n'),
+  );
+}
+
+function mintLeaderSocketPath(runDirectory, evalName) {
+  return join(runDirectory, `leader-${evalName}.sock`);
+}
+
+function writePromptFile(runDirectory, evalName, promptText) {
+  const promptPath = join(runDirectory, `${evalName}-prompt.md`);
+  writeFileSync(promptPath, promptText, 'utf8');
+  return promptPath;
+}
+
+function buildGrokArguments({
+  promptPath,
+  workingDirectory,
+  leaderSocketPath,
+  maxTurns,
+  agentName,
+}) {
+  const allArguments = [
+    '--prompt-file',
+    promptPath,
+    '--cwd',
+    workingDirectory,
+    '--output-format',
+    'json',
+    '--always-approve',
+    '--max-turns',
+    String(maxTurns),
+    '--permission-mode',
+    'bypassPermissions',
+    '--leader-socket',
+    leaderSocketPath,
+  ];
+  if (agentName) {
+    allArguments.push('--agent', agentName);
+  }
+  return allArguments;
+}
+
+function runGrok({
+  promptPath,
+  workingDirectory,
+  leaderSocketPath,
+  maxTurns,
+  agentName,
+}) {
+  const allArguments = buildGrokArguments({
+    promptPath,
+    workingDirectory,
+    leaderSocketPath,
+    maxTurns,
+    agentName,
+  });
+  const processResult = spawnSync(GROK_BINARY, allArguments, {
+    encoding: 'utf8',
+    cwd: workingDirectory,
+    maxBuffer: SPAWN_MAX_BUFFER_BYTES,
+    timeout: GROK_SPAWN_TIMEOUT_MS,
+    windowsHide: true,
+  });
+  return {
+    exitCode: processResult.status,
+    stdout: processResult.stdout || '',
+    stderr: processResult.stderr || '',
+    error: processResult.error || null,
+  };
+}
+
+function isPlainObject(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function extractLastBalancedObject(text) {
+  const doubleQuote = '"';
+  const escapeCharacter = '\\';
+  let isInsideString = false;
+  let isNextCharacterEscaped = false;
+  let openBraceDepth = 0;
+  let objectStartIndex = -1;
+  let lastParsedObject = null;
+  for (let index = 0; index < text.length; index += 1) {
+    const character = text[index];
+    if (isInsideString) {
+      if (isNextCharacterEscaped) {
+        isNextCharacterEscaped = false;
+      } else if (character === escapeCharacter) {
+        isNextCharacterEscaped = true;
+      } else if (character === doubleQuote) {
+        isInsideString = false;
+      }
+      continue;
+    }
+    if (character === doubleQuote) {
+      isInsideString = true;
+    } else if (character === '{') {
+      if (openBraceDepth === 0) {
+        objectStartIndex = index;
+      }
+      openBraceDepth += 1;
+    } else if (character === '}' && openBraceDepth > 0) {
+      openBraceDepth -= 1;
+      if (openBraceDepth === 0) {
+        try {
+          const parsed = JSON.parse(text.slice(objectStartIndex, index + 1));
+          if (isPlainObject(parsed)) {
+            lastParsedObject = parsed;
+          }
+        } catch {
+          // not a JSON object; keep scanning for a later balanced candidate
+        }
+      }
+    }
+  }
+  return lastParsedObject;
+}
+
+export function tryParseJsonObject(text) {
+  const trimmed = text.trim();
+  if (!trimmed) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (isPlainObject(parsed)) {
+      return parsed;
+    }
+  } catch {
+    // fall through to balanced-object extraction
+  }
+  return extractLastBalancedObject(trimmed);
+}
+
+function extractStringField(parsedEnvelope, fieldName) {
+  if (!parsedEnvelope || typeof parsedEnvelope !== 'object') {
+    return null;
+  }
+  const fieldValue = parsedEnvelope[fieldName];
+  if (typeof fieldValue === 'string') {
+    return fieldValue;
+  }
+  return null;
+}
+
+function pickStringFieldByPriority(candidate, fieldNames) {
+  for (const fieldName of fieldNames) {
+    const fieldValue = extractStringField(candidate, fieldName);
+    if (fieldValue !== null) {
+      return fieldValue;
+    }
+  }
+  return null;
+}
+
+export function extractResultText(stdout) {
+  const trimmed = stdout.trim();
+  if (!trimmed) {
+    return '';
+  }
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (Array.isArray(parsed)) {
+      const resultEvent = parsed.findLast(
+        (eachEvent) =>
+          eachEvent &&
+          typeof eachEvent === 'object' &&
+          eachEvent.type === 'result' &&
+          typeof eachEvent.result === 'string',
+      );
+      if (resultEvent) {
+        return resultEvent.result;
+      }
+      const textChunks = [];
+      for (const eachEvent of parsed) {
+        if (!eachEvent || typeof eachEvent !== 'object') {
+          continue;
+        }
+        const eventText = pickStringFieldByPriority(
+          eachEvent,
+          STREAM_EVENT_TEXT_FIELDS_BY_PRIORITY,
+        );
+        if (eventText !== null) {
+          textChunks.push(eventText);
+        }
+      }
+      if (textChunks.length > 0) {
+        return textChunks.join('\n');
+      }
+    }
+    if (parsed && typeof parsed === 'object') {
+      const envelopeText = pickStringFieldByPriority(
+        parsed,
+        ENVELOPE_TEXT_FIELDS_BY_PRIORITY,
+      );
+      if (envelopeText !== null) {
+        return envelopeText;
+      }
+    }
+  } catch {
+    // stdout is plain text
+  }
+  return trimmed;
+}
+
+export function parsePayload(stdout) {
+  const resultText = extractResultText(stdout);
+  return tryParseJsonObject(resultText) || tryParseJsonObject(stdout);
+}
+
+function assertCondition(condition, message) {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+
+function resolveDefaultAgentName() {
+  return process.env.GROK_CAPABILITY_EVAL_AGENT || 'Explore';
+}
+
+function describeLaunchFailure(label, processResult) {
+  const launchError = processResult.error;
+  if (
+    launchError &&
+    typeof launchError === 'object' &&
+    launchError.code === SPAWN_TIMEOUT_ERROR_CODE
+  ) {
+    return `${label}: grok timed out after ${GROK_SPAWN_TIMEOUT_MS}ms`;
+  }
+  if (launchError !== null) {
+    return `${label}: failed to launch grok: ${launchError}`;
+  }
+  return `${label}: grok exit ${processResult.exitCode}\n${processResult.stderr}\n${processResult.stdout}`;
+}
+
+function launchEval(runDirectory, { evalName, promptText, maxTurns, agentName }) {
+  const label = evalName.toUpperCase();
+  const promptPath = writePromptFile(runDirectory, evalName, promptText);
+  const processResult = runGrok({
+    promptPath,
+    workingDirectory: runDirectory,
+    leaderSocketPath: mintLeaderSocketPath(runDirectory, evalName),
+    maxTurns,
+    agentName,
+  });
+  if (processResult.error !== null || processResult.exitCode !== 0) {
+    throw new Error(describeLaunchFailure(label, processResult));
+  }
+  const payload = parsePayload(processResult.stdout);
+  assertCondition(
+    payload !== null,
+    `${label}: could not parse JSON payload from grok output`,
+  );
+  return payload;
+}
+
+function runEvalOne(runDirectory) {
+  const payload = launchEval(runDirectory, {
+    evalName: 'e1',
+    promptText: E1_PROMPT,
+    maxTurns: DEFAULT_MAX_TURNS,
+  });
+  assertCondition(
+    payload.can_spawn_subagent_tool === true,
+    `E1: expected can_spawn_subagent_tool === true, got ${JSON.stringify(payload.can_spawn_subagent_tool)}`,
+  );
+  const allToolNames = Array.isArray(payload.tool_names)
+    ? payload.tool_names.map(String)
+    : [];
+  assertCondition(
+    allToolNames.includes(SPAWN_SUBAGENT_TOOL),
+    `E1: expected tool_names to include ${SPAWN_SUBAGENT_TOOL}, got ${JSON.stringify(allToolNames)}`,
+  );
+  return payload;
+}
+
+function runEvalTwo(runDirectory) {
+  const payload = launchEval(runDirectory, {
+    evalName: 'e2',
+    promptText: E2_PROMPT,
+    maxTurns: SPAWN_MAX_TURNS,
+  });
+  assertCondition(
+    payload.spawn_succeeded === true,
+    `E2: expected spawn_succeeded === true, got ${JSON.stringify(payload.spawn_succeeded)}`,
+  );
+  const childExcerpt =
+    typeof payload.child_excerpt === 'string' ? payload.child_excerpt : '';
+  assertCondition(
+    childExcerpt.includes(SPAWN_MARKER),
+    `E2: expected child_excerpt to include ${SPAWN_MARKER}, got ${JSON.stringify(payload.child_excerpt)}`,
+  );
+  return payload;
+}
+
+function runEvalThree(runDirectory) {
+  const payload = launchEval(runDirectory, {
+    evalName: 'e3',
+    promptText: E3_PROMPT,
+    maxTurns: SKILL_MAX_TURNS,
+    agentName: resolveDefaultAgentName(),
+  });
+  assertCondition(
+    payload.skill_read_ok === true,
+    `E3: expected skill_read_ok === true, got ${JSON.stringify(payload.skill_read_ok)}`,
+  );
+  assertCondition(
+    payload.agent_definition_loaded === true,
+    `E3: expected agent_definition_loaded === true, got ${JSON.stringify(payload.agent_definition_loaded)}`,
+  );
+  return payload;
+}
+
+function runEvalFour(runDirectory) {
+  const payload = launchEval(runDirectory, {
+    evalName: 'e4',
+    promptText: E4_PROMPT,
+    maxTurns: WRITE_MAX_TURNS,
+  });
+  const probePath = join(runDirectory, PROBE_FILE_NAME);
+  assertCondition(
+    existsSync(probePath),
+    `E4: probe file missing under the eval cwd (write_succeeded claim: ${JSON.stringify(payload.write_succeeded)})`,
+  );
+  const probeContents = readFileSync(probePath, 'utf8');
+  assertCondition(
+    probeContents.includes(PROBE_FILE_CONTENTS),
+    `E4: probe file contents mismatch: ${JSON.stringify(probeContents)}`,
+  );
+  const hooksLogPath = join(runDirectory, HOOKS_LOG_NAME);
+  let hooksNote = 'hooks.log not present (soft check skipped)';
+  if (existsSync(hooksLogPath)) {
+    const hooksLogText = readFileSync(hooksLogPath, 'utf8').toLowerCase();
+    const hasGlobalSettings = hooksLogText.includes(
+      HOOKS_LOG_GLOBAL_SETTINGS_MARKER,
+    );
+    const hasPreToolUse = hooksLogText.includes(HOOKS_LOG_PRE_TOOL_USE_MARKER);
+    hooksNote =
+      hasGlobalSettings && hasPreToolUse
+        ? 'hooks.log contains global/settings and pre_tool_use'
+        : 'hooks.log present but missing expected markers (soft)';
+  }
+  return { payload, hooksNote };
+}
+
+export function isWorkflowToolAbsent(payload) {
+  if (!payload || typeof payload !== 'object') {
+    return false;
+  }
+  return (
+    payload.has_workflow_tool === false &&
+    payload.result === WORKFLOW_RESULT_NO_TOOL
+  );
+}
+
+function runEvalFive(runDirectory) {
+  const payload = launchEval(runDirectory, {
+    evalName: 'e5',
+    promptText: E5_PROMPT,
+    maxTurns: WORKFLOW_MAX_TURNS,
+  });
+  assertCondition(
+    isWorkflowToolAbsent(payload),
+    `E5: expected has_workflow_tool === false and result === "no_tool", got ${JSON.stringify(payload)}`,
+  );
+  return payload;
+}
+
+function main() {
+  if (!isOptedIn(process.argv.slice(2))) {
+    printOptInHelp();
+    process.exit(0);
+  }
+
+  const runDirectory = mkdtempSync(join(tmpdir(), 'grok-capability-evals-'));
+  console.log(`run directory: ${runDirectory}`);
+
+  try {
+    console.log('E1 tool inventory...');
+    const e1Payload = runEvalOne(runDirectory);
+    console.log('E1 ok', JSON.stringify(e1Payload));
+
+    console.log('E2 spawn_subagent...');
+    const e2Payload = runEvalTwo(runDirectory);
+    console.log('E2 ok', JSON.stringify(e2Payload));
+
+    console.log('E3 --agent + skill read...');
+    const e3Payload = runEvalThree(runDirectory);
+    console.log('E3 ok', JSON.stringify(e3Payload));
+
+    console.log('E4 probe write...');
+    const e4Outcome = runEvalFour(runDirectory);
+    console.log(
+      'E4 ok',
+      JSON.stringify({
+        payload: e4Outcome.payload,
+        hooksNote: e4Outcome.hooksNote,
+      }),
+    );
+
+    console.log('E5 workflow tool absence...');
+    const e5Payload = runEvalFive(runDirectory);
+    console.log('E5 ok', JSON.stringify(e5Payload));
+
+    console.log('ALL CAPABILITY EVALS PASSED');
+  } catch (failure) {
+    console.error(String(failure && failure.stack ? failure.stack : failure));
+    process.exitCode = 1;
+  } finally {
+    try {
+      rmSync(runDirectory, { recursive: true, force: true });
+    } catch {
+      // best-effort cleanup
+    }
+  }
+}
+
+function isDirectExecution() {
+  const entryArgument = process.argv[1];
+  if (!entryArgument) {
+    return false;
+  }
+  return resolve(fileURLToPath(import.meta.url)) === resolve(entryArgument);
+}
+
+if (isDirectExecution()) {
+  main();
+}

package/skills/orchestrator/SKILL.md

@@ -30,7 +30,7 @@ communication flows through it. It spawns and resumes executor subagents
 — `clean-coder` and the like — and those executors do every bit of the
 execution: the code edits, the build runs, the test runs. The orchestrating
 session drives the plan and routes hard decisions to the shared advisor
-(Claude: warm `session-advisor`; Grok: this session self-as-advisor).
+(Claude: warm `session-advisor`; a third-party host: Claude CLI advisor via the chain runner).
 
 ## Gotchas
 
@@ -43,7 +43,7 @@ session drives the plan and routes hard decisions to the shared advisor
   wasted. Hand every code edit and every build or test run to an executor; keep
   the orchestrating session's own tool use to orchestration and light
   verification reads. Hard decisions go to the shared advisor (Claude:
-  `session-advisor` via SendMessage; Grok: this session inline).
+  `session-advisor` via SendMessage; a third-party host: Claude CLI advisor via the chain).
 - **Flat ad hoc spawns bypass routing.** Every execution task goes through a
   workflow-backed spawn or workflow resume so the required agent type, model,
   prompt packet, and sidecar metadata stay attached to the work.
@@ -54,15 +54,15 @@ session drives the plan and routes hard decisions to the shared advisor
   spawn returns an `agentId` (format `a...-...`); keep it so `SendMessage` can
   reach that agent later. A named agent is reachable by name.
 - **Only the orchestrating session owns the shared advisor's lifecycle.** An
-  executor that finds the advisor unreachable (Claude warm agent, or this
-  session on Grok) reports that upward; it never spawns a replacement itself.
+  executor that finds the advisor unreachable (Claude warm agent, or Claude
+  CLI bind on a third-party host) reports that upward; it never spawns a replacement itself.
 
 ## Process
 
 1. **Check whether the refresh loop is already running this
    session.** If it is, do not schedule a second loop. Reuse any live
-   shared advisor bind (Claude warm `session-advisor`, or Grok self-bind —
-   run step 3 only when none exists yet), then skip straight to step 4.
+   shared advisor bind (Claude warm `session-advisor`, or a third-party host's
+   Claude CLI bind — run step 3 only when none exists yet), then skip straight to step 4.
 
 2. **Register the discipline reminder.** By default, schedule it with
    `ScheduleWakeup` at `delaySeconds: 1200`, prompt `/orchestrator-refresh`,
@@ -85,15 +85,18 @@ session drives the plan and routes hard decisions to the shared advisor
    [`_shared/advisor/advisor-protocol.md`](../../_shared/advisor/advisor-protocol.md);
    it is not a "spawn only at the floor" rule. Paste the **Claude host**
    Advisor block from that doc, with the resolved agent name filled in, into
-   every executor's spawn prompt. On a **Grok host**, skip that spawn — use
-   the protocol's self-as-advisor path (this session *is* the advisor; single
-   tier `Grok`, attempt result `self`). Paste the **Grok host** Advisor block
-   from that doc into every executor's spawn prompt — never the Claude
-   SendMessage block. Every row in the routing table is a consumer of the
-   shared advisor, not just this session. The orchestrating session owns the
-   shared advisor's lifecycle end to end (spawn or self-bind, drift handling
-   per the shared doc, shutdown at task end); executors only ever SendMessage
-   the warm agent (Claude) or report to this session (Grok).
+   every executor's spawn prompt. On a **third-party host**, skip the Agent spawn —
+   bind a max-tier Claude advisor through the protocol's CLI Claude-chain path
+   (Fable high, then Opus max; `claude_chain_runner.py` for account usage
+   failover). Paste the **Third-party host** Advisor block from that doc into every
+   executor's spawn prompt — never the Claude SendMessage block. Every row in
+   the routing table is a consumer of the shared advisor, not just this
+   session. The orchestrating session owns the shared advisor's lifecycle end
+   to end (Agent spawn or CLI bind, drift handling per the shared doc,
+   shutdown at task end); executors only ever SendMessage the warm agent
+   (Claude) or report to this session so it can consult the CLI advisor
+   (a third-party host). When the CLI chain cannot bind, fail closed and report
+   to the user — do not answer the four signals as this third-party session.
 
 4. **Orchestrate the task.** Hold the plan and the user conversation. Execute
    workflow-backed spawns or resumes using the routing table below, and keep
@@ -111,11 +114,14 @@ session drives the plan and routes hard decisions to the shared advisor
    - The chosen approach is being reconsidered.
 
    **Claude host:** consult the shared `session-advisor` via `SendMessage`.
-   **Grok host:** executors report to this orchestrating session; this session
-   answers the four signals inline (self-as-advisor — no Agent, no
-   SendMessage-to-`session-advisor`). Every consult gets back one of four
-   signals (ENDORSE, CORRECTION, PLAN, or STOP). See
-   `agents/session-advisor.md` for what each signal means and
+   **Third-party host:** executors report to this orchestrating session; this session
+   consults the bound Claude CLI advisor (`claude_chain_runner.py` +
+   `--resume`) and relays the four-signal reply (no Agent-tool
+   `session-advisor`, no SendMessage to one). Every consult gets back one of
+   four signals (ENDORSE, CORRECTION, PLAN, or STOP). When the CLI advisor is
+   unreachable, fail closed and surface that to the user — do not invent a
+   signal as this session. See `agents/session-advisor.md` for what each
+   signal means and
    [`_shared/advisor/advisor-protocol.md`](../../_shared/advisor/advisor-protocol.md)
    for the consult format.
 
@@ -147,6 +153,10 @@ Routing rules:
   it.
 - Exploration workflows return file paths, line numbers, and direct evidence;
   they do not write code or mutate repo state.
+- Fan-out worker fleets use the **grok-spawn** skill when that skill is
+  installed and grok is usable (`grok_worker_preflight.py` soft gate). The
+  Claude Code Agent tool remains the Claude-host alternative for in-process
+  workers.
 
 ## Agent reuse (non-negotiable)
 
@@ -173,8 +183,8 @@ Routing rules:
   session (see
   [`_shared/advisor/advisor-protocol.md`](../../_shared/advisor/advisor-protocol.md))
   — on Claude, executors consult a warm `session-advisor` via SendMessage; on
-  Grok, this session is the advisor and executors report here. Executors never
-  spawn or respawn the advisor.
+  a third-party host, executors report here and this session relays the Claude CLI advisor.
+  Executors never spawn or respawn the advisor.
 - Reuse a warm agent over a cold spawn whenever one holds relevant context.
 
 ## File Index

package/skills/orchestrator-refresh/SKILL.md

@@ -4,7 +4,7 @@ description: >-
   Fired by the /orchestrator loop reminder about every 20 minutes to
   re-assert the advisor discipline mid-run: orchestrate, route hard decisions
   to the shared advisor (ENDORSE / CORRECTION / PLAN / STOP — SendMessage on
-  Claude, self-as-advisor on Grok), reuse warm agents. Triggers:
+  Claude, Claude CLI chain on a third-party host), reuse warm agents. Triggers:
   '/orchestrator-refresh'.
 ---
 
@@ -12,8 +12,8 @@ description: >-
 
 Detect the host profile first (see Host profiles in
 [`_shared/advisor/advisor-protocol.md`](../../_shared/advisor/advisor-protocol.md)).
-Re-assert the discipline for that host only — do not invent a Claude
-`session-advisor` spawn on a Grok host.
+Re-assert the discipline for that host only — do not invent an Agent-tool
+Claude `session-advisor` spawn on a third-party host.
 
 1. **You are the orchestrator.** Orchestrate and hold the user conversation;
    spawn executor subagents to do all the work — every code edit and build or
@@ -23,13 +23,17 @@ Re-assert the discipline for that host only — do not invent a Claude
      `SendMessage` and receive one of four signals — ENDORSE, CORRECTION, PLAN,
      or STOP. The orchestrating session routes its own hard decisions the same
      way and keeps its tool use to orchestration and light verification reads.
-   - **Grok host:** this session *is* the advisor (self-as-advisor). Do **not**
-     spawn `session-advisor` and do **not** tell executors to SendMessage a
-     separate advisor agent. Executors report blockers to this session; answer
-     with ENDORSE / CORRECTION / PLAN / STOP inline.
+   - **Third-party host:** the advisor is a max-tier Claude CLI bind owned by this
+     session (`claude_chain_runner.py`, Fable high then Opus max). Do **not**
+     spawn `session-advisor` via Agent and do **not** tell executors to
+     SendMessage a separate advisor agent. Executors report blockers to this
+     session; consult the Claude CLI advisor and relay ENDORSE / CORRECTION /
+     PLAN / STOP. When the CLI bind is unreachable, fail closed and report to
+     the user — do not answer the four signals as this third-party session.
 3. **Resume before you spawn.** `SendMessage` an existing *executor* agent by
    name or `agentId` to reuse its warm context; prefer that over a cold spawn.
-   (On Grok this is executor reuse only — not an advisor spawn.)
+   (On a third-party host this is executor reuse only — advisor re-bind stays on the CLI
+   chain path in the shared protocol.)
 4. **Fresh spawn only for a genuine task switch.** No tool compacts or clears a
    subagent's context, so a clean context comes from a fresh spawn — never tell
    an agent to compact.