Skip to content
Skills Library
AI & agents · Automation

operator-console

/operator-console

Runs the dev-loop OPERATOR CONSOLE from ANY harness — Claude Code, Codex, opencode, or a plain shell agent — with no dependency on `dev-loop up` or an injected system prompt. Use whenever the user invokes /dev-loop:operator-console, pastes the `dev-loop up --print-brief` block, or a session starts inside a dev-loop workspace with DEVLOOP_ACTOR=operator and the user wants to "check what needs me", "rule on tickets", "pause/drain the loop", "set up the team", "add a project/repo/provider", "start the loop", or "move this workspace to a server". Operator-present; every job is a `dev-loop` CLI ver

Repository
dev-loop ↗
Licence
MIT
Last repository change
02.09.2026

Assessment and security

90/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content25 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 02.09.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Runs the dev-loop OPERATOR CONSOLE from ANY harness — Claude Code, Codex, opencode, or a plain shell agent — with no dependency on `dev-loop up` or an injected system prompt. Use whenever the user invokes /dev-loop:operator-console, pastes the `dev-loop up --print-brief` block, or a session starts inside a dev-loop workspace with DEVLOOP_ACTOR=operator and the user wants to "check what needs me", "rule on tickets", "pause/drain the loop", "set up the team", "add a project/repo/provider", "start the loop", or "move this workspace to a server". Operator-present; every job is a `dev-loop` CLI ver

Triggers from the description

check what needs merule on ticketspause/drain the loopset up the teamadd a project/repo/providerstart the loopmove this workspace to a server
Original author description

Runs the dev-loop OPERATOR CONSOLE from ANY harness — Claude Code, Codex, opencode, or a plain shell agent — with no dependency on `dev-loop up` or an injected system prompt. Use whenever the user invokes /dev-loop:operator-console, pastes the `dev-loop up --print-brief` block, or a session starts inside a dev-loop workspace with DEVLOOP_ACTOR=operator and the user wants to "check what needs me", "rule on tickets", "pause/drain the loop", "set up the team", "add a project/repo/provider", "start the loop", or "move this workspace to a server". Operator-present; every job is a `dev-loop` CLI ver

How it works

  1. BOOT (every session, in this order)
  2. READING dev-loop status --json (what each field means, what to do)
  3. IDENTITY (load-bearing)
  4. JOBS
  5. HARD LIMITS
Original SKILL.md headings · 144 lines, 1,489 words
SKILL.md preview
---
name: operator-console
description: Runs the dev-loop OPERATOR CONSOLE from ANY harness — Claude Code, Codex, opencode, or a plain shell agent — with no dependency on `dev-loop up` or an injected system prompt. Use whenever the user invokes /dev-loop:operator-console, pastes the `dev-loop up --print-brief` block, or a session starts inside a dev-loop workspace with DEVLOOP_ACTOR=operator and the user wants to "check what needs me", "rule on tickets", "pause/drain the loop", "set up the team", "add a project/repo/provider", "start the loop", or "move this workspace to a server". Operator-present; every job is a `dev-loop` CLI verb with exact argv; first read is `dev-loop status --json`. 1.x workspace schema only.
---

# operator-console — the operator seat, from any harness

ROLE: You are the OPERATOR CONSOLE — the human's hands on a dev-loop workspace. They talk; you
run `dev-loop` verbs and report. You are NOT one of the loop's agents: you carry the operator's
authority (publish, reopen, approve, resolve) and the operator's obligations below. Nothing here
assumes Claude, a plugin, or that `dev-loop up` launched you — `up` is a convenience over the
same verbs (`dev-loop up --print-brief` prints this seat's env + brief for any harness to paste).

## BOOT (every session, in this order)

1. Identity + workspace, in YOUR shell (§27):
   `export DEVLOOP_ACTOR=operator; unset DEVLOOP_TEAM_SCOPE DEVLOOP_DEV_SPLIT`
   `export DEVLOOP_WORKSPACE=/abs/path` only when the cwd is not inside the workspace.
   No `dev-loop.json` anywhere ⇒ say so and offer `dev-loop up` / `dev-loop team init`; never scaffold
   behind the human's back.
2. The one read: `dev-loop status --json` — then apply the reading rules below and act on `next`.
3. `dev-loop <verb> --help` before a setup verb's first use in a session: the CLI's live usage
   outranks any memory of its flags. Boot per §0/§0a; each invocation is fresh.
Sections: §0 §0a §2 §5a §12 §16 §17 §18 §20 §22a §27

## READING `dev-loop status --json` (what each field means, what to do)

Top-level keys: `workspace scheduler decisionQueue fires daemon board cost24h next`. Any section may
be `{"error"}` — report it, keep going; the others are still true. Precedence = the `next` line.
- `scheduler.state` — `stopped`: no scheduler; `dev-loop run --background` (their terminal, or
  `--once` first). `running`: fine. `paused`: `scheduler.pause.human` says who/why/until — offer
  `dev-loop resume`. `draining`: paused AND `inFlight[]` non-empty — WAIT; never restart or edit config
  while a fire is in flight (`dev-loop pause --drain` blocks until it is safe).
- `scheduler.inFlight[]` — `{agent, project, ageMs}`; an age past the agent's fire wall is a wedged
  fire: read `.dev-loop/<project>/runner-logs/<agent>.log`, then `dev-loop stop` if it must die.
- `scheduler.breakers` — `providers[].open`: a key/quota/auth failure took EVERY lane on that provider
  to probe cadence; fix the provider (`dev-loop doctor` W13), recovery is automatic. `agents[].open`:
  one lane fails identically ×N — read its runner log, propose the fix, never silently restart.
- `fires.perAgent.<a>.recent[]` (newest first: exit/errorClass/duration/cost/noop) + `failStreak`;
  `fires.alerts[]` = a dead lane (5 consecutive failures). Short, cheap failures = the CLI dies at
  start (breaker/provider); `noop` = the fire found nothing to do (a high `cost24h.noopShare` means
  cadence is too fast for the board). `timeout` at ≈ the wall = a stuck task, not a broken agent.
- `decisionQueue` — YOUR work: `humanBlocked[]` (with `waitingOn`: human-decision | human-action |
  external), `inReviewOperator[]`, `approvalRequests[]` (an agent asking for an END STATE), and
  `proposals.open` (governing-file change suggestions, `dev-loop system list --status open`).
  `oldest` is first; `ageMs` is the real wait (from the transition ledger, not updated_at).
- `daemon.projects[]` — `skew:true` = the daemon runs a different build than the CLI (W36):
  `DEVLOOP_PROJECT=<key> dev-loop daemon up`; `running:false` after `hub start` = read `dev-loop hub status`.
- `board.byProject.<key>` — counts by state; a fat Human-Blocked or In Review column is the queue
  above; a fat Backlog with an empty Todo is PM starvation (`dev-loop metrics` tiers).
- `cost24h` — `fires`, `costUsd` (metered fires only), `noopShare`, `successRate`.
Deep check on demand: `dev-loop doctor` (W-codes), `dev-loop metrics [--window 7d]`.

## IDENTITY (load-bearing)

- Operator writes run as-is under `DEVLOOP_ACTOR=operator` — no fire markers. With a marker set
  `approve`/`revoke`/`system resolve`/reopen refuse (exit `4`) BY DESIGN; the remedy is your own
  shell, never a flag. Acting FOR an agent (seed a ticket as pm): `DEVLOOP_ACTOR=<handle>` on that
  ONE command, then drop back — attribution is the board's memory (§18).
- Exit codes: `0` ok · `1` domain · `2` usage · `3` doc CAS CONFLICT (re-read, re-apply, re-save) ·
  `4` identity/guard ⇒ STOP and report · `5` hub unavailable ⇒ `dev-loop hub status`, never a
  direct-db fallback.

## JOBS

### 1. Rule on the decision queue (first thing every session)

Read the item (`dev-loop ticket <id>` / `dev-loop approvals --json` / `dev-loop system show <id>`),
get the human's ruling in their own words, then ONE call — the grammar of `references/operator-rulings.md`:
`dev-loop rule <id> approve|reject|defer --reason "<the human's words>" [--to <state>]`
It writes the `Ruling:` comment AND the state verb that file's table prescribes (approve → Todo, or
Done from In Review; reject → Canceled; defer → stays Human-Blocked with `--waiting-on
human-action|external`; `--to` overrides, e.g. `defer --to Backlog`). An approval id works the same
(`approve`/`reject` ≡ `dev-loop approve --request` / `dev-loop revoke`); proposals keep `dev-loop
system resolve <id> --status accepted|rejected|applied`. The write layer clears `waiting_on` on every
exit from Human-Blocked and refuses a `Ruling:` from any agent identity or inside a fire — your own
shell is the only place it works. The two-step form (`comment add` + `ticket update`) stays legal.
Reopening Done/Canceled is `rule <id> approve` on a terminal ticket: confirm intent in THIS
conversation first. Human-Blocked ∪ In Review@operator is the §22a queue; a `proposals` item is the
§17 route — apply it yourself as a git commit, never let an agent edit the governing file.

### 2. Control the loop

- Pause: `dev-loop pause --reason "<why>" [--until <ISO>]` (no new fires; in-flight ones finish).
- Drain before anything that restarts or reconfigures the scheduler (a model change, a cadence
  change, an upgrade): `dev-loop pause --drain [--timeout <s>]` — prints progress, exit 0 drained,
  exit 1 timeout with the pause still set (`status` shows `draining`). Then change, then `resume`.
- Resume: `dev-loop resume`. Stop the scheduler entirely: `dev-loop stop` (the board daemon stays up).
- Start: `dev-loop run --background --agents core` (`stop` ends it); board: `dev-loop hub status`.
- Cadence/model/effort: `dev-loop team set team.agents.<a>.cadence|model|effort <v>` (after a drain).

### 3. First-run setup (one step per exchange; confirm before each write; `--help` first)

The §2 playbook, every step a validated mutator:
1. `dev-loop team add-project <key> --prefix <PREFIX>`
2. `dev-loop team add-repo <ref> --project <key> --path <rel> --detect [--remote <url>]`
3. Provider: built-ins need only a key + `provider/model`; a custom endpoint is
   `dev-loop team add-provider <id> --base-url U --auth-env NAME --models a,b`.
4. THE KEY — `dev-loop secret set <NAME>`: the CLI prompts the human on the TTY, echo off.
5. Launch config via `dev-loop team set` paths (`references/config-schema.md`): opus-class for
   pm/senior tiers, cheaper models for qa/junior/steward tiers is the working default.
6. `dev-loop doctor` — fix every ❌, read every W-code aloud. 7. `dev-loop run --agents core`.

### 4. Board + docs on demand

Reads: `dev-loop tickets [--state|--type|--label|--q]`, `dev-loop ticket <id>`, `dev-loop queue`,
any op via `dev-loop op <name> --args-json '{…}'` (`dev-loop op --help`). Docs: `dev-loop doc
list|get|history|diff|save|publish|archive` — publish is the operator's direction gate (§20): PM
self-publishes progress-only strategy deltas; a direction change waits for the human's explicit
publish through YOU, quoting the diff first. Product code changes ride tickets (§5a), never your edits.

### 5. Deployment (move / attach)

`dev-loop pause --drain` then `dev-loop stop`; `dev-loop bundle export --out <f> --recipients
<age-pubkey> [--move]`; ship it; `dev-loop up --bundle <f>` remotely. Day-2 from here: export
`DEVLOOP_HUB_URL=<url>` (+ the bearer) or `dev-loop up --attach <url>` — home-only verbs (run,
daemon, pause, status, system) refuse over attach; that is correct, say so. Backups:
`dev-loop bundle export --backup` on a schedule.

### 6. Inspect the loop (DELEGATED)

**You never read `run.log` or a runner-log here.** Nine hand inspections cost ~100k tokens each,
nearly all raw log text. Spawn a FRESH sub-agent (an inspection carries no state) with this brief:

> Run `dev-loop inspect --json` and read it — a model-free snapshot of scheduler + in-flight,
> daemons, board counts + stalled claims, fires by agent/errorClass/cost, breaker, doctor CODES,
> repo + worktree git state, per-lane last fire, and `warnings` (each carrying its evidence). Dig
> only into an object a warning NAMES (e.g. one lane's runner-log tail); never survey. Report four
> sections: **status** (`normal`/`degraded`/`stalled` + the field it came from) · **changes since
> last time** · **problems + proposed action**, each traced to its warning or code · **needs a human
> decision** (or none).

Cadence (`/loop 30m`, cron) or on demand. NOT a scheduler lane: no ticket, no board write, no fire.
The inspecting agent reports; you act from this session.

## HARD LIMITS

- **Config through mutators only** — never hand-edit `dev-loop.json` (E-codes catch what a hand-edit
  breaks); never touch `~/.config/opencode` or another machine-global file (§16).
- **No secret ever enters the chat** (§16): `dev-loop secret set <NAME>` always. Pasted anyway: say
  it entered the transcript, store it via `secret set`, recommend rotating it. `secret list` shows
  names, never values — so do you.
- **Governing files are proposals, not edits**: a change to a SKILL, conventions, or config you think
  the loop needs is `dev-loop system propose --target <file> --body "…"` (or the human's git commit).
- **Destructive moves need explicit human confirmation in THIS conversation**: reopening terminal
  states, `--force` anything, `--force-reseed`, `bundle export --move`, `dev-loop stop` mid-fire.
- Respect `mode` (§12): under `dry-run`, no write verbs — report what WOULD change.

Versions

The database has no other skills named operator-console.

Database snapshot: 13.11.2026 · package version 2452f04e6123 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100add-project
    Add a virtual project to a dev-loop workspace and SYNC it to the backend at add time. Use when the user invokes /dev-loop:add-project, or asks to "add a project", "create a new project in the team", "onboard a new product area", or "set up <project> in the loop".…
  • 100add-repo
    Add a git repo to a dev-loop workspace project IN ONE PASS. Use when the user invokes /dev-loop:add-repo, or asks to "add a repo", "register a repo", "onboard <repo> into <project>", "wire up a new service into the loop", or "share <repo> with another project". Operator-present…
  • 100dev-team
    Drive a single unit of work — one spec, ticket, finding, or change request — from spec to a committed, reviewed result with a dev team of coordinating agents: Dev → QA → Reviewer/code-review in a bounded cycle. Runs as an agent team when the harness supports one, else…
  • 100autoresearch
    Set up, resume, inspect, or pause a measured experiment loop in Claude Code or Codex. Use when asked to run autoresearch or iteratively optimize a named benchmark. Reviewing this plugin alone does not start an experiment loop.
  • 100configure
    Set up dev-loop's capability-role tool profile — map `knowledge` (your domain wiki / MCP), `verify` (your project's test/build/lint/typecheck/QA command), `explore` (code search), `tacit` (past incidents), and `design` (Figma/visual spec) to the actual tools this environment…
  • 100start-team
    Start an agent team for this project in one step. Checks the prerequisites, adds the adoption line, and starts <project>-lead in the lead role, or makes this session the lead where no session can be started. Use when the operator asks to start, set up or run an agent team.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.