agent-org-redesign interpretation (2026-06-10)

agent-org-redesign_diagrams.md

Agent org — operator entry point and flow diagrams (2026-06-10)

Entry point — how the operator gets the ball rolling

1. Open soloterm and select (or create) the project.
2. Spawn the ORCHESTRATOR as a Solo agent: agent tool "Claude" (claude --dangerously-skip-permissions), name it orchestrator, switch it to Opus (/model opus or spawn arg). It MUST be a Solo-managed process — wake timers deliver into its PTY; a plain terminal session cannot be woken.
3. Type one message into its PTY: You are the conductor. Mission: <goal, constraints, repos>. The /orchestrator skill auto-invokes: it anchors the board, plans lanes into todos, spawns Codex workers full-auto, arms idle-wakes, and goes quiet.
4. From then on the operator touches three surfaces only:
   • QUESTIONS pad (+ one notification per blocking item) — decisions the org needs from you;
   • the todo board — live status, milestone comments, verdicts;
   • the orchestrator PTY — your decisions and new missions. Routine progress is never narrated there.

Swimlanes — who does what

flowchart TD
    subgraph OP[Operator]
        A1[Open soloterm project] --> A2[Spawn Claude agent as orchestrator, Opus, Solo-managed]
        A2 --> A3[Message: You are the conductor. Mission: ...]
        A9[Answer QUESTIONS pad / type decisions in orchestrator PTY]
    end
    subgraph ORC[Orchestrator - Claude Opus]
        B1[Anchor: todo_list + list_processes + inbox pad] --> B2[Plan lanes: one todo per lane, body = brief]
        B2 --> B3[Spawn Codex worker per lane + arm timer_fire_when_idle_any]
        B3 --> B4[Sleep: end turn - Stop hook verifies wakes armed]
        B5[Wake: read worker tail + todo comments] --> B6{Worker state?}
        B6 -- done --> B7[Verify claims: re-run command, PR tip SHA, diff] --> B8[Merge or bounce, verdict comment, close worker, complete todo]
        B6 -- blocked/asking --> B9[Answer via send_input - tail check first] --> B4
        B6 -- needs operator --> B10[QUESTIONS pad + one notification] --> B4
        B6 -- dead/stalled --> B11[Dispatch replacer into surviving work] --> B4
        B8 --> B12{Lanes left?}
        B12 -- yes --> B4
        B12 -- no --> B13[Report outcome to operator, clear lane sentinel]
    end
    subgraph WK[Codex workers - full auto]
        C1[Read todo body = brief] --> C2[Implement - skyline tools, shared branch OK]
        C2 --> C3[Gates via build-slot - one compile machine-wide]
        C3 --> C4[Open PR, milestone comments with commands/counts/SHAs]
        C4 --> C5[Go idle]
    end
    A3 --> B1
    B3 --> C1
    C5 -. idle timer fires .-> B5
    B10 -. notification .-> A9
    A9 -. decision .-> B5

Loading

Sequence — one lane end to end

sequenceDiagram
    actor Op as Operator
    participant Orc as Orchestrator (Solo PTY, Opus)
    participant Board as Solo board (todos/pads/timers)
    participant W as Codex worker (--yolo PTY)
    participant BS as build-slot lock
    participant GH as GitHub

    Op->>Orc: You are the conductor. Mission: ...
    Orc->>Board: anchor (todo_list, list_processes, inbox)
    Orc->>Board: todo_create (body = full brief)
    Orc->>W: spawn codex --yolo + pointer: you own todo X
    Orc->>Board: timer_fire_when_idle_any(W -> wake me)
    Note over Orc: ends turn - anti-idle Stop hook checks wakes are armed
    W->>Board: read todo body (brief)
    W->>BS: build-slot cargo clippy/test (queues machine-wide)
    W->>GH: open PR (never merges)
    W->>Board: milestone comments (commands, counts, SHAs)
    Board-->>Orc: timer fires: worker X idle
    Orc->>W: read tail + comments
    Orc->>GH: verify (re-run claim, PR tip contains fix, read diff)
    alt accepted
        Orc->>GH: merge
        Orc->>Board: verdict + todo_complete
        Orc->>W: close_process
    else blocked or asking
        Orc->>W: send_input answer (tail check first)
    else needs operator decision
        Orc->>Board: QUESTIONS pad entry
        Orc-->>Op: one notification
        Op->>Orc: decision
    end

Loading

Worker lifecycle states

stateDiagram-v2
    [*] --> Dispatched: todo body written, worker spawned, wake armed
    Dispatched --> Working: brief read, first tool call (orchestrator verifies within ~3 min)
    Working --> Idle: turn finished / question posted
    Idle --> Verified: orchestrator wake - claims re-run, PR checked
    Idle --> Working: answer / next phase via send_input
    Working --> Dead: crash, kill, context exhaustion
    Dead --> Replaced: replacer inherits todo trail + committed WIP
    Replaced --> Working
    Verified --> [*]: merge or bounce, verdict, close_process, todo_complete

Loading

Ghost-probe — distinguishing TUI suggestion placeholders from real operator typing (added 2026-06-10)

Claude Code renders SUGGESTION PLACEHOLDERS on idle prompt lines (ghost text the operator accepts with Tab/→) that are byte-identical to typed text in Solo's rendered tail. Under the no-fusion law this forced agents to either falsely hold deliveries (placeholder read as typing) or risk fusing into real input. Field-validated discriminator, now encoded in CLAUDE.md and the orchestrator / solo-worker / tester skills:

1. ZERO-TOUCH FIRST — get_process_raw_output: a ghost's raw prompt line is ❯ EMPTY; the suggestion is drawn out-of-band and only composited in the rendered view. (Positional inference — Solo strips the dim SGR styling that would otherwise mark it.)
2. DETERMINISTIC PROBE — send ONE space (send_input bytes [32], no Enter) and read the returned tail: a GHOST VANISHES instantly; REAL typing is RETAINED and grows by the space. Then backspace (bytes [127]) restores either state exactly — net zero.
3. Signature bonus: a ghost RE-RENDERS once the line empties again; real text never reappears from nothing.
4. Guard rails: probe ONCE, never in a loop; text already changing between two reads is live typing — never probe, never send.

Validated live 2026-06-10 on an actual placeholder ("commit this", Solo process claude-code--230): space → vanished; backspace → re-rendered. Residual: the probe itself is a one-keystroke injection (content-neutral, reverted) sharing the race window the rule exists to prevent — hence zero-touch first. PRODUCT FIX FILED: Solo feature request (submitted by operator 2026-06-10) for input_line_state: empty | suggestion | typed (+ optional input_line_text, last_keystroke_age_ms) on get_process_status — the read-side half; send_input input-line protection remains the write-side half.

Residual risks (known, accepted, with mitigations)

• Stop-hook gate blocks only the FIRST stop per turn — it is a per-turn speed bump, not a wall; it re-fires at every turn end, so neglect keeps getting re-prompted.
• Solo timer delivery into the orchestrator PTY does not tail-check; an operator mid-typing in that PTY when a timer fires can still be fused from Solo's side (product fix pending; timer payloads kept to one line).
• build-slot stale-lock reclaim has a small TOCTOU window between the staleness check and rm/mkdir; dead-owner pid check first + 2h TTL make it improbable on a single machine.
• Codex compliance with build-slot is prose (AGENTS.md), not mechanism RESOLVED 2026-06-10: execpolicy rules (~/.codex/rules/default.rules) now forbid bare cargo/go compiles with justifications naming the build-slot fix, ban nextest in any wrapping, and were empirically proven to bind even under --yolo (router-layer rejection; Codex self-corrects to the wrapped form).
• Codex quota exhaustion is detected reactively (a failing spawn/turn wakes the orchestrator, which falls back to Sonnet); there is no proactive quota probe.

agent-org-redesign_interpretation.md

Agent org redesign — orchestrator's interpretation of the operator request (2026-06-10)

Operator: Jonas. Context: the previous multi-agent setup (Claude orchestrator + standing roles + Codex/Solo workers, documented in gist 3784c06a93442497843229371dd3e025) worked but burned tokens on scheduled check-ins and ceremony, and the orchestrator narrated to the operator instead of following up on its workers. This document is the new system's spec, as interpreted and implemented by the redesigning agent.

The request, in total

1. REVIEW the existing user-scope machinery: CLAUDE.md, the role skills (orchestrator, solo-worker, builder, replacer, supervisor, questioner, outside-auditor, observer, reporter, groundskeeper), the hooks, and the Codex-side config — then rebuild it, from scratch if needed.
2. FIX the two field failures: (a) token burn from cadence-scheduled check-ins (supervisor ~10 min cycles, outside-auditor ~30 min cold respawns, questioner 2-min pad polls); (b) the orchestrator narrating to the operator while NOT following up on workers — no verdict when a worker finished, lanes idling unattended.
3. KEEP the build constraint: this is an 8GB machine — cargo builds and test suites must never run concurrently; funnel or queue them.
4. ENFORCE BY MECHANISM: the smarter models are strong-willed and ignore prose rules in skills; rules that matter must be hooks, locks, and timers, not paragraphs.
5. TOOLING: every agent uses the skyline MCP tools unless skyline genuinely lacks the capability. Multiple workers MAY work the same branch concurrently — skyline's hash-guarded edits are designed for cooperative writing.
6. WORKERS: Codex agents are the primary implementers, spawned with full-auto flags so the operator never clicks permission prompts; they program "all the things" until the Codex 5h/weekly quota is exhausted, then Sonnet Solo agents take over. The orchestrator stays on Opus (operator decision; Fable was offered as an alternative).
7. NO ultracode / Workflow-tool orchestration, and NO blind subagents: every delegated worker must be observable and steerable by its dispatcher (a Solo PTY process), never a fire-and-forget background agent.
8. NEXT (separate effort): point the rebuilt org at the open skyline issue backlog.

What was built

ARCHITECTURE — two live tiers, event-driven, zero cadence timers:

• One orchestrator (Claude, Opus) on soloterm: dispatches, verifies, merges, keeps the board. Never writes feature code, never compiles, never narrates routine beats.
• N Codex workers, full-auto: spawn_agent(codex, extra_args=["--ask-for-approval","never","--sandbox","danger-full-access"]) for lanes; codex exec --dangerously-bypass-approvals-and-sandbox for one-shots. Sonnet Solo agents as quota fallback.
• Dispatch = one atomic beat: brief written into the Solo todo BODY -> worker spawned with a ~5-line pointer -> timer_fire_when_idle_any armed on the worker so the orchestrator is WOKEN when the worker goes idle -> todo in_progress.
• All standing oversight roles RETIRED: supervisor, questioner, outside-auditor, observer, reporter, builder, groundskeeper (skills archived to ~/.claude/skills-archive/). An /org-audit skill exists for on-demand cold reviews — invoked by the operator only, never scheduled.

MECHANISMS replacing prose (and replacing the retired roles):

• Anti-idle Stop hook (~/.claude/hooks/org-stop-gate.sh + org-lane-mark.sh): any Claude session that has spawned Solo workers gets its first attempt to idle BLOCKED with a checklist — read finished workers and deliver verdicts now, re-arm wakes for running workers, route operator questions to the QUESTIONS pad. Second stop passes (loop-safe). This makes "orchestrator idles while workers wait" structurally impossible — the previous supervisor's main job, for free.
• Build funnel without a builder agent: ~/.local/bin/build-slot — a machine-wide mkdir lock (/tmp/skylence-build.lock, interoperable with skyline_run's lock_path) that every compiling command runs through. One compile at a time is now a property of the machine, not a discipline. Verified: serializes, propagates exit codes, reclaims stale/dead-owner locks.
• Skyline mandate hooks (pre-existing, kept): PreToolUse denies built-in Read/Edit/Write/Grep in favor of skyline tools.
• cargo-nextest stays HARD-BANNED by hook (it froze the machine once); lifting it is a one-line operator decision, deliberately not made unilaterally. Targeted cargo test -p <crate> through build-slot is the sanctioned path.

REWRITTEN DOCTRINE (lean, ~10x smaller than before):

• /orchestrator — the event-driven loop (anchor, atomic dispatch, sleep, wake, verify-then-verdict), worker recipes, brief template, merge discipline, operator interface (decisions only; questions via pad + one notification).
• /solo-worker — fallback Claude worker conduct: verification-ready claims, WIP commits at every boundary, same-branch etiquette, no sub-delegation.
• /replacer — successor pickup from durable state: contract, handover, tree verification, baseline, pickup comment.
• /org-audit — on-demand outside look; any cadence timer found anywhere is itself a finding.
• ~/.codex/AGENTS.md — Codex worker conduct: todo-body briefs via solo MCP, milestone comments, build-slot law, nextest ban, skyline-first tooling, shared-branch etiquette, incident-before-recovery, secrets hygiene.
• ~/.claude/CLAUDE.md — builder-authority paragraph superseded by build-slot serialization; role-playbook paragraph updated; no-blind-delegation recorded as standing order.

Design rationale in one line each

• Cadence check-ins pay tokens for the common case (nothing happened); idle-wake timers pay only when something did.
• A lock is a cheaper queue than an agent: the builder role was a token-funded mutex.
• Prose doesn't bind strong-willed models; hooks bind every model equally, including Opus.
• Observability over fan-out: a worker the orchestrator can read and steer beats three it cannot.
• The board (todos + comments) is the org's memory; chat is for the operator's decisions only.

agent-org-update-2026-07-06_decay-planner-capacity-peers.md

Agent org — update 2026-07-06: conduct decay, planner role, capacity gate, peer orgs (v1.6.0 → v1.8.0)

Three plugin releases in one day, all operator-ordered, all ported across the three variants (claude / codex / antigravity) plus the bundled Codex conduct pack (codex/AGENTS.md — the LIVE worker conduct for codex lanes). Every mechanism below was bench-tested before commit (hook executions, probe runs on the target Mac Mini); the one thing not yet observed live is a real compaction firing the new hook (see residual risks).

release	claude	codex	antigravity	commit	what
2026-07-06 a	1.6.0	0.7.0	0.5.0	34cffe1	conduct-decay counters, merge-safety rules, workers-never-compile drift reconciled
2026-07-06 b	1.7.0	0.8.0	0.6.0	9ba560c	PLANNER role + model ladder, orchestrator only delegates
2026-07-06 c	1.8.0	0.9.0	0.7.0	03d0d10	capacity spawn gate, peer-orchestrator doctrine, singleton planner, skybox-first orientation

1. Conduct decay counters (v1.6.0)

Field pattern that forced this: long orchestrator sessions get dumber — the role skill's text is among the first things compaction evicts, the degraded agent cannot feel its own degradation, and the operator ended up ordering successions by hand (proc 861, 2026-07-06 ~05:15Z). Self-reflection alone cannot fix a session that no longer remembers it should self-reflect, so the counters are MECHANICAL, layered from harness-side (survives anything) to prose-side (cheap, best-effort):

1. org-conduct-refresh.sh — NEW third hook, SessionStart matcher compact. Fires from the harness, so it works regardless of context state. In org sessions (SOLO_PROCESS_ID set, or the org-lane-mark flag file) it injects: re-invoke your role skill, re-ANCHOR from the board, the summary keeps facts not conduct and its claims are hearsay until a board read confirms them. Inert everywhere else. (The codex variant already had a SessionStart re-injection hook — the claude variant, the one actually conducting, had nothing.)
2. ANCHOR now opens with CONDUCT FIRST: skill text not literally in context → re-invoke before touching the board.
3. WAKE-CLOSE RETROSPECTIVE (standing law): every turn that handled a wake ends by replaying the beat against the loop — claims verified before accept? close-out (process + worktree + branch) done at DONE? every running worker re-armed? anything narrated that belonged on the board? One miss → fix now + re-read the skill. TWO misses in one session → decay has outrun refresh, succeed immediately.
4. Succession triggers widened: ~95% context became ~90% OR compaction-near OR the two-miss rule; the HANDOFF pad gains a mandatory RETRO section (what drifted, which rules emerged, where they now live).
5. SELF-AMENDING DOCTRINE (standing law): a hard-won rule goes into the RETRO section the moment it proves out, and if it should bind future org instances it becomes a lane to PR it into the plugin skills — institutionalizing what predecessor sessions did by hand.
6. org-stop-gate gained item (0): conduct re-read before the anti-idle checklist.

flowchart TD
    C["compaction fires"] --> H["org-conduct-refresh hook<br/>SessionStart:compact — harness-side,<br/>immune to context state"]
    H --> R["re-invoke role skill"]
    R --> A["re-ANCHOR from board<br/>(summary = hearsay)"]
    W["every handled wake"] --> RETRO{"wake-close retrospective:<br/>verified? closed out? re-armed?<br/>board, not memory?"}
    RETRO -- "miss" --> FIX["fix NOW + re-read skill"]
    RETRO -- "2nd miss this session" --> S["SUCCESSION, immediately"]
    CTX["~90% context or compaction near"] --> S
    S --> HP["HANDOFF pad + RETRO section"] --> CLR["/clear in the SAME PTY"] --> RE["re-invoke /orchestrator<br/>(timers + notify-backs survive)"]

Loading

Merge-safety rules landed in the same release (all from the 2026-07-05/06 field session): read the FULL PR diff before squash-merge (a squash ships EVERYTHING on the branch — one PR silently carried a sibling lane's ungated commits); stacked PRs auto-close when their base branch deletes (re-target/rebase before deleting a base); gate on the branch tip AFTER rebasing onto current main; fmt --check runs INLINE before the build-slot cycle (a fmt bounce must never cost a compile slot); CI waits get a browser tab for the operator + ONE long fallback wake, never short polls; second review is MANDATORY over ~150 changed lines or on release/auth/data-integrity/parser-resolution surfaces; a first send to a fresh PTY counts only when the tail shows PROCESSING, not your text echoed back.

Workers-never-compile drift, reconciled: the claude variant had the law (2026-07-04), but the codex + antigravity variants AND the live ~/.codex/AGENTS.md conduct pack still told workers "every compiling command through build-slot" — i.e. worker compiles, merely serialized. All surfaces now agree: workers edit + commit + push only (skyline_diagnostics allowed); the orchestrator runs the single gate at feature-end.

flowchart LR
    W1["lane A: edit + commit + push"] --> BR["shared feature branch"]
    W2["lane B: edit + commit + push"] --> BR
    BR --> RB["rebase onto current main<br/>(green on stale base proves nothing)"]
    RB --> FMT["fmt --check INLINE<br/>(compiles nothing)"]
    FMT --> GATE["build-slot clippy + test<br/>backgrounded, tee queried"]
    GATE -- "red" --> BOUNCE["bounce to lane as an EDIT<br/>(never a worker build)"]
    GATE -- "green" --> DIFF["read FULL PR diff<br/>unrecognized commit → STOP"]
    DIFF --> MERGE["merge + delete branch<br/>(verify deletion — gh fails silently<br/>when a worktree holds it)"]

Loading

2. Planner role + model ladder (v1.7.0, singleton in v1.8.0)

Operator order: the orchestrator does not plan. A dedicated PLANNER authors program structure; the orchestrator verifies the plan like any lane deliverable and executes it mechanically. Depth budget moves to the planner; conducting is mechanical and stays cheap.

era	planner	orchestrator
Fable 5 available	claude --model fable + /effort max	opus, MEDIUM effort
Fable gone	opus + /effort max	opus, LOWEST effort

The planner is a MACHINE-WIDE SINGLETON (v1.8.0): at most one across ALL Solo projects. Discover-or-spawn: sweep every project for a live planner agent; one exists → route the request to it (planning-request todo on YOUR board, pointer names project id + todo id; busy → timer_fire_when_idle_any queues the send). Only spawn when none lives anywhere, capacity-gated. It closes at DONE only when no org has a request queued — on a busy machine it serves requests back-to-back and the close-out duty rides the last one.

Plan contract (the orchestrator bounces holes back, never patches): GitHub epic + child issues (criteria paired with exact proving checks, skybox impact evidence attached), one dispatch-ready todo brief per lane, the blocker graph as the ONLY ordering (unblocked ⇒ parallel by construction — a missing edge is a race the planner authored), and a PLAN pad with waves, critical path, gate points.

sequenceDiagram
    participant OP as Operator
    participant O as Orchestrator — opus, cheap
    participant P as Planner — singleton, max effort
    participant B as Board + GitHub
    participant W as Workers
    OP->>O: mission
    O->>O: singleton sweep — list_projects × list_processes
    alt planner alive somewhere
        O->>P: pointer — project id + todo id (wake-on-idle if busy)
    else none anywhere
        O->>O: capacity-gate
        O->>P: spawn, send /effort max, then pointer
    end
    P->>B: skybox grounding, then epic + child issues + briefs + blocker graph + PLAN pad
    P-->>O: PLAN READY, with counts
    O->>O: verify plan; spot-check impact claims; bounce holes
    O->>W: dispatch EVERY unblocked todo (each spawn capacity-gated)
    W-->>O: DONE → verify → todo_complete → next wave unblocks
    Note over O,W: blocker graph = program counter; board = program

Loading

3. Capacity spawn gate (v1.8.0)

Solo agents cost ~0.5-1 GB RSS each and an OOM freeze on the 8GB Mac Mini kills every lane at once — deferring one spawn is always cheaper. scripts/capacity-probe.sh (macOS-only for now; all three variants) measures reclaimable RAM (free + inactive + purgeable + speculative pages), the kernel's own pressure level (kern.memorystatus_vm_pressure_level: 1 normal / 2 warn / 4 critical — it can only WORSEN the byte-math verdict, never improve it), swap used, and the live claude/codex process count + combined RSS. First line VERDICT=GREEN|YELLOW|RED <reason>; the exit code IS the verdict (0/1/2; 3 = non-mac, treat as YELLOW). Tunables: SOLO_CAP_GREEN_GB (2.0), SOLO_CAP_RED_GB (1.0).

Field test at commit time (the target machine itself): VERDICT=YELLOW reclaimable 1.12GB < 2.0GB with pressure 2, swap 3.2G, 6 agent processes at 0.59GB RSS — a true verdict, and the RED + pressure-escalation branches were forced via the tunables and behaved.

The paired capacity-check skill sets conduct: probe before EVERY spawn and BETWEEN batch spawns (each spawn changes the answer); the old "never serialize on machine limits" is now "never on IMAGINED machine limits — the MEASURED verdict is the one machine limit that binds", so the gate bounds fan-out without re-legitimizing serial dispatch.

flowchart TD
    SPAWN["spawn intent<br/>(worker / planner / reviewer / codex exec)"] --> PROBE["capacity-probe.sh<br/>reclaimable RAM + kernel pressure<br/>+ swap + live agent RSS"]
    PROBE -- "GREEN — exit 0" --> GO["spawn<br/>(re-probe between batch spawns)"]
    PROBE -- "YELLOW — exit 1" --> FREE{"close-out debts<br/>to pay?"}
    FREE -- "yes: finished lane open,<br/>idle proc, orphan worktree" --> PAY["pay them NOW"] --> PROBE
    FREE -- "no" --> DEFER["defer: ONE one-shot wake<br/>naming the deferred dispatch<br/>(event, never a poll)"]
    PROBE -- "RED — exit 2" --> STOP["NO spawns: sweep own lanes,<br/>inbox peer orgs to sweep too"]
    STOP -- "persists with work queued" --> ESC["escalate to operator<br/>with probe output pasted"]

Loading

4. Peer orchestrators (v1.8.0)

Named failure mode: orchestrators silo on their own workers; cross-org information moved only when the operator relayed it. Now doctrine — peers coordinate DIRECTLY. Discovery is part of ANCHOR (list_projects; a peer = a project with a live conductor agent). The channel is durable-first: write into the PEER's ORCHESTRATOR-INBOX pad (every solo tool takes a project_id override), signed from proj-<N> orchestrator, <date -u>, full IDs and links because the peer has none of your context; send_input is allowed only as a doorbell afterwards ("inbox: item from proj N") under the same no-fusion + ghost-probe law as worker PTYs. Incoming peer items rank WITH worker wakes; replies go to the sender's inbox; accepted cross-org work becomes a lane on your own board.

Four MUST-WRITE events (events, never cadences): (1) shared resources — RAM (a RED capacity verdict is broadcast so peers sweep too), build-slot load, the shared planner, production daemons, release channels; (2) cross-repo impact — your lane changes something a peer dogfoods or depends on (skybox impact/group_impact names the victims); (3) machine-wide incidents — freeze, OOM, daemon outage: inbox ALL peers with the evidence path; (4) overlap — before dispatching into a repo a peer plausibly owns, read their board first and coordinate instead of duplicating. Peers send requests, never orders; deadlocks go to the operator via QUESTIONS.

flowchart LR
    subgraph P3["project 3 org"]
        O3["orchestrator 3"] --- I3[("ORCHESTRATOR-INBOX 3")]
    end
    subgraph P7["project 7 org"]
        O7["orchestrator 7"] --- I7[("ORCHESTRATOR-INBOX 7")]
    end
    O3 -- "write item, project_id override<br/>signed + full IDs" --> I7
    O3 -. "doorbell: ONE send_input<br/>(no-fusion + ghost-probe)" .-> O7
    O7 -- "reply" --> I3
    PL["shared singleton PLANNER<br/>+ shared RAM + build-slot + daemons"] --- O3
    PL --- O7

Loading

5. Skybox-first orientation (v1.8.0)

Operator finding: orchestrators and planners chronically underuse the skybox code graph — plans and merge verdicts were grep-grounded at best. Now doctrine on both roles. PLANNER: read skybox://guide once; verify every target repo is indexed and FRESH (repo_status/list_repos, else index_repo + wait_for_job — a stale graph lies); per surface a lane touches run query → context, then impact (upstream, d=1 = guaranteed breaks), route_map/tool_map for API surfaces, group_impact across repos. Blast radius DRIVES the plan: high fan-in surfaces get their own lane + mandatory-reviewer flag, upstream dependents become blocker edges, cross-repo effects become sibling lanes; every child issue carries its impact evidence. skyline reads come AFTER skybox says where to look. ORCHESTRATOR: spot-check the planner's impact claims before executing; before any non-trivial merge, impact the changed surfaces (an unexplained dependent ⇒ bounce or add the reviewer); keep the graph fresh at big merges (detect_changes, reindex after).

flowchart LR
    G["skybox://guide"] --> F{"repo indexed<br/>+ fresh?"}
    F -- "no" --> IX["index_repo + wait_for_job"] --> Q
    F -- "yes" --> Q["query → context<br/>per touched surface"]
    Q --> IMP["impact upstream d=1<br/>route_map / tool_map / group_impact"]
    IMP --> PLAN["lanes + blocker edges<br/>+ reviewer flags + issue evidence"]
    PLAN --> MC["orchestrator re-runs impact pre-merge:<br/>claims proven or busted"]

Loading

Operator quickstart deltas

• Spawn the orchestrator as before, but set effort per the ladder: /effort medium while Fable 5 exists (planner on fable), /effort low once the planner is also opus. /effort max belongs to the planner only.
• Update the installed plugin (1.5.1 → 1.8.0) + /reload-plugins; the compaction hook only arms in sessions started after the update.
• The machine's capacity verdict is one command: sh <plugin>/scripts/capacity-probe.sh — the same output the org acts on.

Residual risks (known, accepted, with mitigations)

• The SessionStart:compact hook has not yet fired on a REAL compaction (hook tested by direct execution with both gate states; matcher mirrors the codex variant's field-running SessionStart hook). First live compaction on ≥1.6.0 is the validation; the ANCHOR conduct-first check covers a hook no-fire.
• The wake-close retrospective is prose, not mechanism — a sufficiently degraded orchestrator can skip the retrospective it no longer remembers. Layering (hook → stop-gate item 0 → two-miss succession) bounds the damage; if field sessions still drift after refreshes, the next step is more harness-side enforcement, not more prose.
• capacity-probe reads RSS, which undercounts swapped/compressed agent memory (observed: 6 agents at only 0.59GB RSS while swap held 3.2GB); the kernel pressure level and swap figure compensate — pressure ALWAYS escalates the verdict.
• The singleton planner is convention-enforced (discover-or-spawn), not locked: two orchestrators racing the same "none alive" observation could double-spawn. Mitigations: the sweep-first rule, the fixed process name planner, capacity gate slowing the race; Solo lock_acquire is the hardening path if it ever happens in the field.
• /effort max delivery into the planner PTY is a send like any other — verify-after-send applies; a stuck effort command silently leaves the planner at default effort.
• Max effort does not exempt the planner from decay: the conduct-refresh order and mid-lane re-read rules bind it like every role.