claude-dev-env 1.93.1 → 1.95.0

package/skills/orchestrator/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: orchestrator
 description: >-
-  Advisor-orchestrator mode: plan and delegate while workflow-backed agents
+  Orchestrator mode: plan and delegate while workflow-backed agents
   execute; a shared session-advisor answers hard decisions with endorse,
   correction, plan, or stop. Triggers: '/orchestrator', 'orchestrator
   strategy', 'run with an orchestrator', 'executor-advisor mode',
@@ -24,13 +24,13 @@ than a solo frontier agent held to the same verification rigor, with
 Claude Code has no `multiagent` coordinator field or Managed-Agents-style
 `create_agent`/`send_to_agent` primitives; this skill reaches the same
 shape with the tools Claude Code already has. Under this skill the session
-is the advisor-orchestrator. In Claude Code the user always talks to the session and never to a
+is the orchestrator. In Claude Code the user always talks to the session and never to a
 subagent, so the session is the user's sole interface: all user-facing
 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`; Grok: 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; Grok: 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 Grok) 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 Grok 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`,
@@ -79,17 +79,24 @@ session drives the plan and routes hard decisions to the shared advisor
    On a **Claude host**, follow the Warm-up procedure in that doc (Agent spawn
    of `session-advisor`). Compute the model floor as the max of the
    orchestrating session's own tier and the highest model in the Workflow Agent
-   Routing table below (today: max(Sonnet, Opus) = Opus). 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).
+   Routing table below (for example, max(Sonnet, Opus) = Opus when those are
+   the tiers in play). That floor is a lower bound only — the Claude spawn walk
+   tries top-down from Fable down to that floor per
+   [`_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 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 **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 (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
+   (Grok). When the CLI chain cannot bind, fail closed and report to the user
+   — do not answer the four signals as this Grok 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
@@ -108,10 +115,13 @@ session drives the plan and routes hard decisions to the shared advisor
 
    **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
+   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.
 
@@ -169,8 +179,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.
+  Grok, 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 Grok), reuse warm agents. Triggers:
   '/orchestrator-refresh'.
 ---
 
@@ -12,24 +12,28 @@ 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 Grok host.
 
-1. **You are the advisor-orchestrator.** Orchestrate and hold the user
-   conversation; spawn executor subagents to do all the work — every code edit
-   and build or test run.
+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
+   test run.
 2. **Hard decisions go to the shared advisor.**
    - **Claude host:** executors consult the warm `session-advisor` via
      `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.
+   - **Grok 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 Grok 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 Grok 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.

package/skills/pr-converge/CLAUDE.md

@@ -28,4 +28,4 @@ Drives a draft PR to convergence by driving the internal passes to clean first
 - All findings and PR reports state verified facts only — no hedging language.
 - The GitHub MCP (`pull_request_read`, `pull_request_review_write`) is the primary path for PR inspection; `gh api` is the fallback.
 - Three step-scoped agents (`fix_executor`, `thread_sweep`, `copilot_watch`) persist across ticks via the `persistent_agents` map in loop state; each tick resumes them with `SendMessage` and spawns a fresh named agent when a stored id is dead.
-- The tick delegates shared mechanics to five sibling sub-skills: `reviewer-gates` (opt-out, Copilot quota, Bugbot trigger), `pr-scope-resolve` (target resolution), `pr-fix-protocol` (fix sequence + unresolved-thread sweep), `post-audit-findings` (audit posting), and `pr-loop-lifecycle` (run open/close).
+- The tick delegates shared mechanics to three sibling sub-skills: `reviewer-gates` (opt-out, Copilot quota, Bugbot trigger), `pr-fix-protocol` (fix sequence + unresolved-thread sweep), and `pr-loop-lifecycle` (run open/close). Target resolution happens inline in `reference/per-tick.md` Steps 1 and 1.5. Audit posting follows the `_shared/pr-loop/post-audit-thread-contract.md` contract, run through `_shared/pr-loop/scripts/post_audit_thread.py`.