Practical notes for repeated, reliable use.
Start the PlatformDeployment stack (SwitchBoard must be healthy before any task):
cd ~/Documents/GitHub/PlatformDeployment
./scripts/up.shup.sh starts SwitchBoard, optionally Plane, and all OperationsCenter watcher
roles (including intake). No manual worker start needed.
Confirm readiness:
console status
console providersconsole status checks SwitchBoard health, OperationsCenter reachability,
watcher role status, and the most recent run.
console providers shows which backend binaries are installed and available.
Expected: SwitchBoard OK, OperationsCenter OK, intake running, at least one lane binary available.
Interactive wizard (recommended):
console runPrompts for repo → task type → goal, then writes to ~/.console/queue/.
OperationsCenter's intake role picks it up, elaborates it using .console/
context and recent commits, and drives execution.
Non-interactive fast path:
console run --goal "Fix the login bug" --task-type bug --repo MyRepoCheck what's queued:
console queueconsole runwrites~/.console/queue/<uuid>.json- intake role detects the file (inotifywait or 10s poll)
- intake loads
.console/task.md,.console/backlog.md, recent commits from the target repo - intake elaborates the raw goal into a scoped
PlanningContext - planning → SwitchBoard routing → adapter execution
- Result written to
~/.console/operations_center/runs/<run_id>/ - Queue file deleted on success (left on disk if intake fails)
OperationsCenter runs several background watcher roles. up.sh starts them all;
down.sh stops them.
console workers status # check all roles
console workers start # start (if not already running)
console workers stop # stop all roles
console workers restart # restartThe intake role is the one that processes your queue submissions. The other
roles (goal, test, improve, propose, review, spec) are the
autonomous planning loop.
Most recent run:
console lastAll fields + recent run list:
console last --allList of recent runs (newest first):
console runsLimit to last 5:
console runs --limit 5Machine-readable:
console last --json
console runs --jsonBrowse artifact files directly:
ls ~/.console/operations_center/runs/
ls ~/.console/operations_center/runs/<run_id>/Each run directory contains:
proposal.json TaskProposal
decision.json LaneDecision
execution_request.json ExecutionRequest
result.json ExecutionResult
run_metadata.json run id, lane, status, timestamp
console run returns a specific exit code to allow scripting:
| Code | Meaning |
|---|---|
| 0 | Task queued successfully |
| 1 | Cancelled, missing input, or unknown repo/type |
Execution outcomes are recorded in run artifacts — console last shows the result.
There are two separate autonomy surfaces. They are not interchangeable.
console cycle |
OperationsCenter autonomy cycle | |
|---|---|---|
| What it does | Observes the repo, proposes one task, delegates it for execution | Runs the OperationsCenter planning loop — creates Plane board tasks |
| Executes code? | Yes — goes through the full pipeline to an adapter | No direct execution; produces Plane task proposals |
| Creates Plane tasks? | No | Yes |
| Stops automatically? | Yes — one cycle, then exits | Yes — one cycle per invocation |
| When to use | You want one self-driven code change executed now | You want the planner to queue work on the board |
Run console cycle for immediate local execution.
Run python -m operations_center.entrypoints.autonomy_cycle.main (from the OperationsCenter repo) for board-driven planning.
Each run gets a unique UUID-based run ID. Directories never overwrite each other.
Failed runs remain as failure_category=backend_error or partial directories. They do not affect subsequent runs.
console last and console runs sort by written_at timestamp in the metadata — newest run is always correct regardless of directory naming.
Runs accumulate indefinitely. To prune old runs:
console clean --keep 10 # keep 10 most recent, delete the rest
console clean --dry-run # preview what would be deletedOr manually:
ls -lt ~/.console/operations_center/runs/ # newest first
rm -rf ~/.console/operations_center/runs/<run_id>Queue files that failed intake are left at ~/.console/queue/ — inspect and
delete manually:
console queue
rm ~/.console/queue/<id>.jsonIntake not picking up tasks:
console workers status # check if intake is running
console workers restart # restart all rolesSwitchBoard unreachable:
console status # confirm
cd ~/Documents/GitHub/PlatformDeployment && ./scripts/up.shRun failed (backend not installed):
failure_category=backend_error is expected when a backend binary (kodo,
aider, etc.) is not installed. The intake and planning pipeline ran correctly —
only the final adapter invocation failed.
Run these in order to confirm the system is working:
console status # stack + OperationsCenter + watchers + binaries
console providers # backend binary readiness
console run --goal "smoke test" \
--task-type chore \
--repo OperatorConsole # submit to queue
console queue # confirm it's queued
console last # confirm a run was recorded (after intake picks it up)console demoRuns all six steps: preflight → stack → health → route → planning → execution.
| Limit | Detail |
|---|---|
| Single machine only | No distributed or multi-user support |
| intake requires inotify-tools | Install with sudo apt install inotify-tools; falls back to 10s polling without it |
| Backend binary required for execution | Execution without kodo/aider records backend_error — not a pipeline bug |
| SwitchBoard must be running | All routing calls fail if PlatformDeployment stack is down |
| No run search | console runs shows recent runs by time; no filtering by status or goal |
| Partial runs counted | console runs shows partial artifacts alongside complete runs |
| Queue files persist on intake failure | Inspect ~/.console/queue/ and remove manually |