Cyberine — Supported Features
Static feature catalog. This file is the canonical, living list of what Cyberine (AI Agent Solution) supports today. When a feature ships, add a row here (and keep
USAGE.mdfor the step-by-step recipes). It renders as the Features page of the site undersite/- runnpm run docs:dev(ornpm run docs:build) to preview the whole site.
Cyberine is a vendor-independent, multi-provider AI agent orchestrator (ports-and-adapters): dispatch one task to N agents — raw-API loop workers and/or headless CLI coding agents — judge the results, and ship the winner. It can be used standalone as a day-to-day coding agent (a Claude Code / Codex replacement) that prioritizes zero-marginal-cost subscription workers.
Global CLI (cyberine)
| Command | What it does |
|---|---|
cyberine setup [--status] | Guided onboarding: configure provider API keys, pick + pin a chat model, print available workers. Re-runnable, idempotent. |
cyberine auth <login|list|status|logout> [provider] | Manage provider credentials in ~/.cyberine/.env with live validation; key values never printed. |
cyberine agents [--once|--json] | Interactive fleet TUI of every run across all projects (--once = plain-text list for scripts; --json = structured JSON array with per-worker waitingFor when blocked). |
cyberine run "<task>" | Dispatch a task to the fleet and judge the results (one-shot, foreground). |
cyberine run --bg "<task>" | Detached background run; returns a runId immediately, survives the terminal closing. Auto-routes the fleet. |
cyberine run --mode compete|swarm | Operating mode preset wired end-to-end into the engine: compete caps fleet to all eligible workers + [diff, behavior] judge chain + verifyCmd gate active; swarm caps to one worker + [diff] chain + no verifyCmd gate. |
cyberine wait <runId> | Event-driven block until a background run reaches a terminal state; exits 0 (done), 1 (run failed/cancelled), 124 (timeout), 125 (watcher crashed / could not observe). |
cyberine digest <runId> | Compact one-screen summary of a run: state, verdict, winner, diffstat, outcome summary; no raw diff. |
cyberine land <runId...> [--dry-run] | Batch-land dogfood runs: wait → digest → apply+commit per run → one final typecheck. |
cyberine apply <runId> [--dry-run] [--step <id>] [--commit] [-m <msg>] | Land a code run's winning diff onto the working tree; --commit also stages and commits it. |
cyberine chat | Planner REPL: brainstorm/sharpen a task with a model, then /run it to the fleet. Sessions persist. |
cyberine chat sessions | --continue | --resume <id> | --task "<text>" | List, reopen, resume, or auto-submit a chat session. |
cyberine route "<task>" | Dry-run the router: print the classified tier/kind, the chosen fleet, and per-worker reasons — no dispatch. |
cyberine models [<provider>] / cyberine model which|use|reset | Offline model catalog: list providers/models, resolve active model, switch via ~/.cyberine/.env upsert. |
cyberine cost [<runId>] [--days N] | Spend ledger: per-run / per-day / per-provider token + $ cost, including premium-subscription savings. |
cyberine credits [list] | List tracked provider balances: balance / estimated-spent / remaining / status (ok / low / exhausted). |
cyberine credits set <provider> <usd> | Seed or reset a provider's balance (resets estimated spend to $0). |
cyberine credits add <provider> <usd> | Top-up a provider's balance without resetting estimated spend. |
cyberine credits reset <provider> | Remove a provider from the ledger (revert to unlimited / no gate). |
cyberine eval [--compare] | Replay stored runs against current fleet/judge config; report win-rate, cost, gate-pass-rate vs baseline. |
cyberine group <which|list|runs|chats> | Inspect project groups that share runs, chats, and memory across linked directories. |
cyberine memory <list|show|search|issues|chain|rebuild> | Inspect long-term memory: records, search, the issue ledger, run lineage, index rebuild. |
cyberine tasks [--all] | Print the task board, same as cyberine tasks status; read-only. The legacy .local/dogfood/backlog-*.md listing is cyberine tasks dogfood [--all] (k0zd1). |
cyberine skill list|show | Discover and inspect Claude-Code-compatible SKILL.md files (global + project scopes). |
cyberine wf list|save <name> <path>|run <name|path> | Saved workflow registry under ~/.cyberine/workflows/; scripts callable inline via workflow() host function; step-resume via --resume. |
| Project-local workflow override | <repo>/.cyberine/workflows/<name>.ts takes precedence over ~/.cyberine/workflows/<name>.ts; cyberine wf list merges both dirs with project entries shadowing global. Resolution order: literal path > project > global. |
cyberine wf author [--bg] "<task>" | Dynamic workflow authoring: planner writes a workflow script at runtime, typecheck-gates it, then dispatches. |
cyberine wf show <path> | Print a workflow script's meta + phase list without running it. |
cyberine tui [<runId>|--dir] | Open the fleet TUI scoped to one project. |
cyberine plugin install [--copy|--force] | Wire the bundled Claude Code plugin: one symlink into ~/.claude/skills/cyberine, exposing ten skills (/cyberine:help, /cyberine:init, /cyberine:run, /cyberine:autopilot, /cyberine:plan, /cyberine:ask, /cyberine:tasks, /cyberine:research, /cyberine:handoff, /cyberine:end) and the bundled MCP server. |
cyberine plugin status | Report whether the Claude Code plugin is loaded and which skills are accessible. |
cyberine plugin list|info|doctor|install|remove|enable|disable | General plugin lifecycle: install extension plugins from local path or git, enable/disable, inspect, health-check. |
cyberine reap [--dry-run] | Sweep the global registry for stuck runs (engine alive, no events.jsonl progress for CYBERINE_STUCK_IDLE_MS, or past CYBERINE_STUCK_WALL_MS wall-clock cap). Cooperative teardown: SIGTERM → CYBERINE_STUCK_GRACE_MS → SIGKILL; marks run cancelled with killed:stuck provenance; tombstones from cyberine agents. |
cyberine plans list [--all] / cyberine plans show <slug> | Read-only browser over the traceable plan files written by cyberine chat plan mode. list shows this project's plans newest-first (id · created · status · description from frontmatter; --all includes superseded); show resolves a partial topic-slug and prints frontmatter facts (session_id, run_ids[], status, approved_mode) + the markdown body. Reads ~/.cyberine/plans/<project-slug>/ and <cwd>/.cyberine/plans/ when CYBERINE_PLANS_DIR is set. |
cyberine doctor (T540) | Unified health check (also /doctor in chat): node version, config validity across layers, store sanity, provider keys presence, gateway reachability, CLI worker availability, fleet.json drift, MCP, hook executability — [PASS]/[WARN]/[FAIL] lines with fix hints, exit code reflects failures. |
| Run-corruption visibility (T674) | The doctor's run-store check opens each registry record's own <runsDir>/<runId>/run.json and flags corrupt/unparseable run.json files distinctly from corrupt registry records (tombstoned runs skipped; missing run.json reported as its own orphaned-record flavor); the same count from RunStore.list() renders live as a warn-tone corrupt stat in the fleet TUI header (local mode), and the store's aggregated stderr warning is deduped per distinct corrupted-id set instead of re-firing every poll. Smoke: npm run selftest:doctor-run-corruption. |
Claude Code integration
| Feature | What it does |
|---|---|
| Claude Code plugin | One-command setup: cyberine plugin install wires the bundled plugin into ~/.claude/skills/cyberine (symlink by default, copy option for symlink-unsafe hosts), exposing all ten skills + the bundled MCP server without needing separate skill install / mcp install steps. |
| Eight bundled skills | /cyberine:help (free, model-invocable front door that routes plain language anchored on "cyberine" to the right leaf below and asks before any leaf spends), /cyberine:init (is this repo ready for Cyberine), /cyberine:run (dispatch to Claude subscription seats), /cyberine:autopilot (agent-driven task board), /cyberine:plan (generate competing task lists, written to the board as backlog), /cyberine:ask (settle blocking decisions, one verdict), /cyberine:tasks (converge conversation work onto the board), /cyberine:research (cited web-research fleet: plan -> search -> verify -> synthesize). All reachable with / trigger once the plugin is installed. |
| Bundled MCP server | The plugin bundles the orchestration MCP server (cyberine-mcp), exposing every orchestrate() tool (read-only agent tools, code-implementation tools, run lifecycle tools) without needing a separate MCP server registration step. Accessed by the bundled skills and the web dashboard. |
| Plugin status reporting | cyberine plugin status reports whether the plugin is loaded and which skills are accessible; cyberine doctor includes a claude-code: section flagging missing/stale/loaded plugin + skills state; the bare cyberine command nudges an authed user with cyberine plugin install when the plugin is not wired. |
Cost-aware routing (standalone / "prioritize free")
| Feature | What it does |
|---|---|
| Marginal-cost cost model | Each worker carries costModel (subscription / metered / free-local) + priorityRank. Routing prefers zero-marginal-cost workers over pay-per-token ones. |
| Preferred pool | Every worker whose costModel is subscription (e.g. claude, codex, muse), plus metered CLI agents at costClass 1 — always eligible, never excluded for cost. Retired workers (opencode-deepseek, opencode-kimi, …) drop out of the pool entirely. |
| QA vs code routing | A question gets ONE subscription worker (no race); a code task races the whole available preferred pool, DiffJudge picks the winner. |
| Native-API as last resort | Metered loop-* / gemini workers are auto-selected only when no preferred-pool worker is available (else opt-in via CYBERINE_BUILD_FLEET). |
| Auto mode-routing | Swarm-then-compete escalation: trivial tasks go swarm (single cheap worker, fast), complex tasks escalate to compete (full fleet race). The mode preset is wired into WorkflowEngine via WorkflowEngineOpts.preset and drives fleet size cap, judge chain, verify gate, and governor initialisation. |
| Availability-filtered candidates | The router only considers workers actually usable now (logged-in CLIs + key-configured loop workers), so the fallback is real. |
| Subscription billing | Spawned claude / codex workers scrub the metered API-key env var when a sub exists, so they bill the flat subscription, not per-token. |
| Deterministic, no-LLM classifier | Question/edit-verb/size heuristics (English + Vietnamese) — reproducible routing with explainable reasons. |
| Worker ELO track-record | Per-worker win/loss history in ~/.cyberine/worker-track-record.jsonl; informs fleet selection and routing over time. |
Smart (LLM-as-router) (CYBERINE_SMART_ROUTER) | Opt-in: when enabled, an LLM call (CYBERINE_ROUTER_MODEL / CYBERINE_ROUTER_BASE_URL) picks workers from the available set after the deterministic classifier runs; the LLM pick is validated and falls back to the deterministic result if invalid. Off by default. |
Budget admission / smart spawn (CYBERINE_SMART_SPAWN) | On by default (CYBERINE_SMART_SPAWN=0 disables). Gates new worker spawns against current credit balances and concurrency headroom before dispatch; surfaces a capacity-wall signal for chunked handoff when the fleet is full. |
Fleet budget caps — mid-run abort (CYBERINE_MAX_BUDGET_USD / CYBERINE_FLEET_USD_CAP / Task.maxBudgetUsd) | Per-worker + per-fleet USD caps checked between tool rounds against each worker's live costUsd; on breach the worker(s) checkpoint to status='partial' (output + usage preserved, judge still sees the partial diff). Tighter cap wins; reuses estimateCostUsd (no rate-table dup). TUI shows a live spent/cap (NN%) meter on capped runs (warn tone >= 80%). Distinct from the cross-run CYBERINE_DAILY_USD_CAP dispatch-time hard-stop. |
| Per-tier model variant resolution | Workers that declare variants.flash / variants.reasoning in their profile get the appropriate model id auto-selected based on the classified task tier (trivial/standard -> flash; complex -> reasoning). Env-key overrides (e.g. DEEPSEEK_MODEL) always win and are preserved in route audit output. |
| Enabled means used for every role (khv45) | Enabling a worker in fleet.json is consent to use it for planning, task splitting, reviewing and judging, not only implementing — there is no separate consent field, acknowledgement or prompt. With the defaults, the design/review/plan steps dispatch the strongest ENABLED workers by the model strength table (top band, widened until at least two compete), the implement step dispatches the cost-class-1 workers, and the judge chain is ordered by strength with an API backend ahead of a CLI-spawn judge at equal strength. A fleet whose enabled workers are all cheap-class is unchanged. Every run records a note naming the picked workers and any subscription the thinking steps bill. cyberine fleet disable <provider> takes a worker out of every role; routing.steps and routing.judges still override everything. Replaced the pre-2026-09-17 import-time ban on subscription workers in the design step. |
Fleet policy file (fleet.json + cyberine fleet) | Optional user-editable policy file (project .cyberine/fleet.json full-replaces global ~/.cyberine/fleet.json) declaring which providers/models are active (replace semantics) and which model handles each task-kind (qa/code-small/code-large). Manage via cyberine fleet init/list/enable/disable/set-default/set-model/route/doctor/edit. Holds policy only, never keys; precedence CLI flag > env > fleet.json > built-in; absent file = unchanged behavior. |
Worker fleet (adapters)
| Worker / adapter | What it is |
|---|---|
LoopAgentAdapter | Model-level tool-calling loop against any OpenAI-compatible endpoint (DeepSeek direct, OpenRouter, Moonshot/Kimi, Ollama, LiteLLM gateway, native Anthropic). Sandbox-pinned. |
CliAgentAdapter | Spawns a headless CLI coding agent: claude, codex, opencode (deepseek/kimi), gemini. Host-sandbox wrapped. |
| Key-only loop workers | loop-deepseek-build, loop-openrouter-build, loop-kimi-build, loop-ollama-build, loop-claude-native-build — zero CLI install, need only an API key. |
| Ollama Cloud provider | Hosted Ollama inference (https://ollama.com/v1, requires OLLAMA_CLOUD_API_KEY). Compare-fleet adapter loop-ollama-cloud; build worker loop-ollama-cloud-build (opt-in via CYBERINE_BUILD_FLEET). Cloud models carry a :cloud suffix (qwen3-coder:480b-cloud, gpt-oss:120b-cloud, gpt-oss:20b-cloud, deepseek-v3.1:671b-cloud). Separate env vars from local Ollama — not keyless, not localhost. See docs/providers/ollama-cloud.md. |
| Command Code provider | Command Code Provider API (https://api.commandcode.ai/provider/v1, requires CMD_API_KEY) as the key-only build worker loop-commandcode-build, billed against the subscription credit windows rather than the daily money cap. :free model ids record zero cost; claude-* ids are refused at registration; off-plan and unsupported-model refusals cool the worker down instead of retrying. cyberine route prints the remaining credits and both usage windows from the /alpha/billing/credits endpoint; a closed window drops paid-model Command Code workers from the candidate set until it resets (free models stay eligible), and a 429 parks the worker until the reset the refusal names instead of retrying. The command-code CLI worker runs Command Code's own harness (command-code -p --yolo) inside the host sandbox with a narrow ~/.commandcode write grant, maps the NDJSON result's usage and cache reads, treats a non-success subtype as an error, cools down on an auth failure, returns partial at --max-turns, and draws the same credit windows through the same gate (CYBERINE_COMMANDCODE_MODEL, CYBERINE_COMMANDCODE_MAX_TURNS). A free lane, loop-commandcode-free-build, binds whichever zero-credit models the live catalog lists (no id in code), is routed for qa and code-small, and takes the paid worker's place in an explicit fleet while the paid worker is parked. See docs/providers/command-code.md. |
| Gateway loop workers | loop-claude-build, loop-gpt-build — Claude/GPT via the LiteLLM gateway through one OpenAI-compatible loop. |
| CLI coding agents | claude, codex, opencode-deepseek, opencode-kimi (dead/self-skipping since 2026-08-25), gemini — full project-aware tool harnesses. |
| Headless login gating | A CLI worker is only spawned when it is installed AND authenticated; missing ones are skipped with a note. |
| Host sandbox | CLI workers run wrapped in a host sandbox when available (Seatbelt / bubblewrap); CYBERINE_TASK_TRUSTED=false makes a sandbox mandatory. |
| OpenCode worktree config-lock | Before spawning an opencode worker, a minimal opencode.json (locked model + permissions) is written into the worker's worktree dir, so opencode's upward config traversal can't inherit a conflicting .opencode/opencode.json from an ancestor repo and override Cyberine's chosen model. opencode-only; other adapters unaffected. |
Shared OpenAI client (makeOpenAIClient) | Every OpenAI-wire client (chat planner, judges, loop workers, oracle, memory, web) is built through one factory — the single, mandatory construction point for new OpenAI(...) in the repo. On openai SDK ^7.x (since 2026-09-03, task kwed4) it passes options straight through with keep-alive on; the SDK's native-fetch transport does not have the keep-alive/socket-reuse bug 4.x had, so no transport override is needed. |
| Anthropic model catalog | Catalog + pricing cover claude-fable-5-1/claude-fable-5 (1M ctx, $10/$50), claude-opus-5/claude-opus-4-8 (1M ctx, $5/$25), claude-sonnet-5 (1M ctx, $2/$10, the default claude worker), claude-sonnet-4-6 (1M ctx, $3/$15), claude-haiku-4-5 (200K, $1/$5) — all selectable as worker models. |
| Connection-failure cooldown | A refused/unreachable endpoint (a local gateway or Ollama that is not running, DNS miss, timeout) records a short 5-minute cooldown after its first failure, so a configured-but-down worker drops out of the fleet instead of erroring on every dispatch — then rejoins once reachable. Tunable via CYBERINE_QUOTA_COOLDOWN_CONNECTION_MS. |
| CLI flag-compat diagnosis (T656) | An older installed claude/codex/gemini that rejects a version-gated flag Cyberine passes (e.g. codex --dangerously-bypass-hook-trust, claude --exclude-dynamic-system-prompt-sections) surfaces a named, diagnosable error — flag, owning task, known-good CLI version, disable knob — instead of a bare unknown option exit. Registry: CLI_FLAG_COMPAT in src/adapters/CliAgentAdapter.ts; smoke: npm run selftest:cli-flag-compat. Also wires the T626/T628/T631 opt-ins to reachable env knobs: CYBERINE_CLAUDE_CAPTURE_SUBAGENT_TEXT, CYBERINE_CLAUDE_OUTPUT_SCHEMA, CYBERINE_CODEX_OUTPUT_SCHEMA. |
code_execution job control (kc8cn) | A Python snippet can start a background job via call_tool('run_bash', ..., background=True) and list/read/kill it with call_tool('bash_jobs', ...) in the same snippet; the snippet-side tool registry mirrors the adapter-level run_bash/bash_jobs pairing. Also fixes the macOS Seatbelt path that made every snippet-side call_tool fail. Smoke: npm run selftest:codeexec-bash-jobs. |
| Per-run background-job reaping (k8w8k) | Background jobs die when the worker run that started them ends (per-run ownership token, not cwd-keyed); a nested delegate_subtask inherits its parent's token and never reaps, so a subagent returning cannot kill the parent's live jobs. Process-exit reaper + 30-minute ceiling remain as backstops. Smoke: npm run selftest:per-run-reap. |
Judges
| Judge | What it does |
|---|---|
ConsensusJudge | Pure majority vote across candidate outputs. |
LlmJudge | An LLM scores and ranks the candidates. Reasoning judge models (e.g. deepseek-v4-flash) get a 2048-token budget so reasoning_content doesn't starve the verdict JSON, falls back to reasoning_content when visible content is empty, and retries once with a strict-JSON reprompt before degrading to the safe first-result default — so a real rationale is produced instead of silently ruling for the first candidate. |
AdversarialJudge | N skeptics try to refute each candidate before it wins. |
DiffJudge | Applies each candidate diff in a throwaway worktree, gates on apply-cleanly + typecheck, and disqualifies no-op (empty) diffs — the implementer-fleet winner picker. |
| Default judge chain by strength (khv45) | Without routing.judges, the backends are ordered by the strength of the model each would use, preferring a vendor no candidate worker runs, and putting an API backend ahead of a CLI-spawn judge at equal strength. An enabled claude / claude-<seat> entry is a default candidate instead of a routing.judges-only opt-in, so a seats-only fleet gets llm-judge and adversarial back. Each backend's billing class comes from src/core/billingClass.ts and lands in run.json judging.backends[].billingClass — informational, it never adds or drops a candidate. |
BehaviorJudge | Gates the winning diff on a project-defined verifyCmd (e.g. npm run typecheck); scores apply-cleanly + typecheck + custom verify; used by compete mode and DiffJudge tie-break. |
Engine & workflows
| Feature | What it does |
|---|---|
WorkflowEngine | Runs multi-step DAG workflow definitions; per-step workers, judges, and dependency wiring. |
| Worktree isolation | Steps marked isolate: true give each worker a detached git worktree off HEAD and capture its diff — no live-tree clobbering. |
| Per-step model override | A WorkflowStep.model field overrides the dispatched loop worker's model for that step only (cheap model for grunt steps, expensive for a gated verify) — threads through Task.modelOverride to LoopAgentAdapter; absent = unchanged worker default. |
implementTaskWorkflow | The standing design -> implement fleet: plan, then the writing fleet competes in isolated worktrees, DiffJudge picks the winning diff. Used by cyberine run code tasks. |
| Imperative workflow script runtime | A meta + default async module shape runs through WorkflowScriptRuntime with host.agent(), host.parallel(), host.pipeline(), host.phase(), host.budget helpers; auto-detected by npm run wf. |
| Workflow journal + resume | Each imperative run journals step results; --resume replays cached steps and re-runs only changed/new ones. |
| Nested + saved workflows | workflow(name) inside a script delegates to a named saved workflow; cyberine wf save registers scripts in ~/.cyberine/workflows/. |
Token budget (CYBERINE_WF_BUDGET) | Per-script token ceiling; host.budget.spent() / host.budget.remaining() introspectable at runtime; auto-stops before ceiling. |
Concurrency governor (CYBERINE_MAX_CONCURRENT) | Global cap on simultaneously-running workers with backpressure queuing; prevents runaway fan-out. |
flow-dream-consolidate workflow | RETIRED 2026-09-09 (k0wf7, operator decision). It was the June port of the operator's private flow-dream memory-hygiene flow, decision-only (its write phases were never built), never run outside three smoke runs, and already a different design from the engine the operator rewrote in July. Cleaning ~/.claude/memory is Claude Code tooling's job; Cyberine's own memory lives at ~/.cyberine/memory/ (see Long-term memory) and stays vendor-independent so the same orchestrator serves Codex or any other CLI. src/workflows/ is gone with it. The generic <repo>/.cyberine/workflows/ override (see the cyberine wf row) is unrelated and still supported. |
| Write-set disjointness enforcement | The swarm scheduler detects overlapping file claims across parallel steps and serializes conflicting batches — no silent merge conflicts. |
| Early-kill for compete mode (M6) | Once the first candidate passes the BehaviorJudge gate in compete mode, remaining in-flight workers are aborted rather than run to timeout. |
awaitRun workflow step | A step delegates to a child background run and blocks on its completion envelope via the message bus; child's summary flows into dependent steps. |
autoEvolveWorkflow | Built-in self-improvement workflow: a read-only worker authors a spec, the writing fleet implements it in isolated worktrees, DiffJudge gates the winner. |
npm run wf -- <def.ts> | Run any workflow definition. |
| Lifecycle hooks | Claude-Code-style hooks (PreDispatch, etc.) with an exit-code contract; can block or rewrite a dispatch. |
Worker quota cooldown circuit-breaker (CYBERINE_QUOTA_COOLDOWN) | Workers that return 402/429/auth errors are placed in a per-error-type cooldown (configurable via CYBERINE_QUOTA_COOLDOWN_RATELIMIT_MS, _CREDITS_MS, _AUTH_MS, _CLI_MS); excluded from dispatch until the window expires. cyberine cooldown [clear [workerId]] lists or clears active cooldowns. Set CYBERINE_QUOTA_COOLDOWN=0 to bypass entirely. |
High-risk mode (CYBERINE_HIGH_RISK) | Setting CYBERINE_HIGH_RISK=1 (or cyberine run --high-risk) escalates the run to the L3 adversarial judge tier: an AdversarialJudge runs skeptic workers against each candidate before a winner is accepted. Forwarded to child background runs automatically. |
Swarm grouping knobs (CYBERINE_SWARM_GROUP_BY / CYBERINE_SWARM_LANES / CYBERINE_SWARM_MAX_LANE_SIZE) | Fine-tune swarm lane packing: CYBERINE_SWARM_GROUP_BY controls edge type (files = file-overlap only, deps = dependency edges too); CYBERINE_SWARM_LANES overrides the lane count cap; CYBERINE_SWARM_MAX_LANE_SIZE sets the split-warning threshold above which a lane is flagged as too large. |
Repo briefing (CYBERINE_REPO_BRIEFING) | Loop workers receive a repo-structure preamble before each task (default on in a git repo). Set CYBERINE_REPO_BRIEFING=0 to disable. |
Autopilot session driver (createSessionDriver) | Drives ONE long-lived Claude Code session turn by turn over claude -p + --resume, reporting the exact context after every turn (input_tokens + cache_read_input_tokens + cache_creation_input_tokens) plus cost, duration and the model that actually answered. Typed failures, a LIVENESS watchdog (khgxt, 2026-09-06: a turn is killed only when stdout AND every descendant process stay quiet for stallTimeoutMs, never for running long; turnTimeoutMs is an opt-in cap), and an optional per-turn series at .local/runs/<runId>/autopilot.jsonl. Prompt and result content never reach the terminal or disk unless debug is set. No policy: it measures, the caller decides. |
--engine claude reads a scope: --area <tag> and an explicit task-id list | Shipped |
| Batch deferrals and unreachable named ids are reported, never dropped | Shipped |
Self-evolve loop
| Feature | What it does |
|---|---|
| Plan -> execute -> re-plan loop | The cyberine evolve command runs continuous improvement cycles: plan tasks, gate execution via judge verdicts, re-plan from results. Two entry cases (cold goal via --goal, or existing backlog via --from-backlog) feed the same loop. |
| Domain-group model | Tasks are organized into domain groups with disjoint write-sets, so parallel workers never touch the same files. |
| Trust gate | A cycle advances a task only when a judge picks a winner AND that winner's diff applies cleanly + typechecks. Worker self-claims are never trusted. An untrusted task (CYBERINE_TASK_TRUSTED=false) is always classified high-risk and the L3 adversarial gate becomes mandatory: with no adversarial judge available the winner is rejected, never auto-merged on L1/L2 alone (guarded by npm run selftest:trust-untrusted). |
| Stop modes | until-done (default) stops when every group backlog is drained; continuous-evolution keeps looping, mining each cycle's diff for fix tasks and (with --grow) proposing new features. |
| CLI surfaces | cyberine evolve start, cyberine evolve status, cyberine evolve steer, cyberine evolve stop. |
| Chat integration | The planner can start/steer a session via start_evolve_session / steer_evolve_session tools; /evolve shows status, /evolve steer <text>, /evolve stop. |
MessageBus
| Feature | What it does |
|---|---|
| File message bus | JSONL mailboxes under ~/.cyberine/bus/; relay run:completed envelopes to the dispatching chat session and parent runs. CYBERINE_BUS_BACKEND=none degrades to poll. |
| Mid-flight steer | ControlMessage (stop / steer) sent to a run's inbox; the step loop checks it between steps and either halts or redirects. |
| Chat run-completion report | Chat sessions subscribe to the bus; a background run's completion summary is pushed to the chat that launched it. |
| MCP bus tools | npm run mcp exposes send_message, poll_inbox, query_runs over the MCP protocol alongside the orchestrate tool. |
Team presence / roster (T564/T565, src/store/presence.ts) | Lightweight cross-run, cross-project roster: each live process (run, chat session, worker, MCP server) announces itself under ~/.cyberine/bus/presence/, heartbeats, and tombstones on graceful exit. cyberine chat joins on start; /team (chat slash command) and the MCP list_team tool both read the live roster (name, team, role, capabilities, last-heartbeat age) filtered to non-stale, non-tombstoned entries. /team send resolves a target by name, then role, then falls back to a team broadcast; /team join/leave mutate this session's team tag and re-announce immediately. Inbound teammate messages (T565/T566) surface live in the chat transcript without blocking the input loop or a mid-stream reply. |
Store & memory
| Feature | What it does |
|---|---|
RunStore | Persists each run under .local/runs/<runId>/ (run.json + events.jsonl). |
Worker waitingFor field | Optional string on WorkerRun set while the worker is stalled; explains the blocker (governor queue, pending upstream dep). Cleared on resume or termination. Surfaced in cyberine agents --json and TUI run-detail. |
GlobalRegistry | Cross-project run index under $CYBERINE_HOME (~/.cyberine), powering cyberine agents. |
ChatSessionStore | Persists chat sessions (naming, history, resume) under $CYBERINE_HOME/chat-sessions/. Active permissionMode is saved on the record for session resume. |
planStore | Writes traceable plan-mode markdown files: ~/.cyberine/plans/<project-slug>/<YYYYMMDD-HHMMSS>__<topic-slug>.md (or <cwd>/.cyberine/plans/ when CYBERINE_PLANS_DIR is set). YAML frontmatter carries session_id, run_ids[], status, approved_mode, cwd. updatePlanRunIds / updatePlanStatus keep the frontmatter in sync as runs are dispatched. |
| Long-term memory | MemoryStore records run outcomes + an issue ledger; a MEMORY preamble is injected into dispatched tasks; cyberine memory inspects it. |
| Run lineage | Parent / chat-session / previous / root run links for dispatch-chain provenance. |
| Worker track-record | Per-worker win/loss/cost history in ~/.cyberine/worker-track-record.jsonl; feeds router selection and routing decisions. |
| Cost ledger | Per-run token + dollar cost persisted in run.json; aggregated by cyberine cost; premium savings (sub vs metered) tracked separately. |
Credit ledger (cyberine credits) | Optional per-provider balance tracking in ~/.cyberine/credits.json; estimated spend decrements after each run (conservative round-up); workers below CYBERINE_CREDIT_MIN_USD are down-ranked; hard 402/quota errors zero the provider balance immediately. Providers with no entry are unlimited (default unchanged). |
cyberine eval replay harness | Replay past runs against a new fleet/judge/verifyCmd config without re-running workers; reports win-rate, cost-rate, gate-pass-rate vs baseline. |
Claude Code memory adapter (CYBERINE_CC_MEMORY), opt-in | Cyberine's memory is its own ~/.cyberine/memory/; a Claude Code memory folder is an optional adapter, read (preamble) and written (handoff-cyberine_<slug>.md on completion) ONLY when named by CYBERINE_CC_MEMORY=<path> or a .local/cc-memory file. Since 2026-09-09 (kmspc) there is no ~/.claude/memory fallback: unconfigured means untouched, pinned by selftest:memory-containment. |
| Project groups | Link directories via ~/.cyberine/groups.json; runs, chats, and memory collaborate across sibling repos; cyberine group manages. |
| ContextQ / MCP memory backend | OPTIONAL, config-selected long-term-memory augmentation via HTTP /api or MCP /mcp; the local store stays canonical and degrades gracefully offline. |
| ContextBrain — Code-Context 3-Act seam (T441/T454) | Separate port (src/core/contextBrain.ts) behind WorkflowEngine / AutonomyLoop's boot/recall/carry acts. createContextBrain() auto-selects between LocalBrain (default, fully offline: repo skeleton + git co-change signal + local MemoryStore lessons) and ContextQBrain (CYBERINE_CONTEXTQ=1: POST /api/agent/boot for repo-map + lessons, POST /api/retrieve for kNN recall on verify failure, POST /api/contexts/bulk-upsert to carry the post-judge capsule) — same env switch as the memory backend above, LocalBrain's output always computed first as the offline floor. |
| Hard spend cap — race-free ceiling (T482/T575) | Opt-in (CYBERINE_SPEND_CAP_USD, unset/0 = disabled) append-then-verify reservation gate (src/store/spendCap.ts) closing the soft per-provider credit-ledger race: every dispatch reserves before running, re-reads the fully folded cumulative total, and denies over-cap. Gates both dispatch choke points (Orchestrator.dispatch, WorkflowEngine.runWorker) identically. T575 made the cumulative total self-tracked (recordRealizedSpend, no credits set balance required) and added event-log rotation/compaction (CYBERINE_SPENDCAP_ROTATION_BYTES, default 256 KB) carrying forward any still-open reservation. Reservation TTL via CYBERINE_SPEND_CAP_TTL_MS (default 10 min) auto-frees budget if a worker is killed. |
TUI
| Feature | What it does |
|---|---|
Fleet hub (cyberine agents) | Grouped runs list, run detail, folder picker, compose panel, quick reply, chats view — modelled on best-in-class fleet views. |
| Confluence ring brand mark | Welcome screens (hub + chat) show the Cyberine mark: an open ring in the theme accent, one arc and a centre diamond in TONE.verified (many attempts in, one verified out), as two-tone half-block pixel art on HalfBlockCanvas + HalfBlockMascot. The same geometry drives the website and dashboard marks (site/scripts/gen-mark.mjs). Replaced the eclipse mark 2026-09-25. |
Chat REPL (cyberine chat) | Planner with a real dispatch tool, slash commands, session resume, ghost-text completion, queued-message steering, cost/usage display. |
| Chat markdown rendering | Assistant replies render as terminal markdown: headings (H1–H4), bold/italic/bold-italic/TONE.code), [label](url) links + bare autolinks, fenced code with syntax + diff highlighting, GFM tables (aligned columns, styled header, cell truncation), nested ordered/unordered lists (indent-aware, +/en-dash markers), task-list checkboxes (- [ ]/- [x]), blockquotes, and rules. Leaked tool-call protocol markup (<invoke>/<tool_calls>/DeepSeek <｜…｜> tokens) is stripped before display without harming legit angle brackets. |
| Chat slash commands | /run, /steer, /skill, /backlog [run <n...>], /land <runId...>, /workflow author, /model, /copy, /clear, /resume, /style, /cost, /agents, /version, /mdtest (one-screen markdown render gallery for eyeballing the renderer), /team (T564/T565 — roster / directed send / join-leave / inbound recap, see MessageBus table). |
| Multimodal dispatch (T417-multimodal-dispatch) | A pasted image (Ctrl+V) reaches BACKGROUND-dispatched workers, not just the in-chat planner turn: /run, dispatch_run/dispatch_tasks, and the Ctrl+B streaming handoff all persist the attachment into the dispatched run's own directory (.local/runs/<runId>/attachments/, type- and size-validated) and forward it as a CYBERINE_TASK_IMAGES manifest. Vision-capable loop workers get a real image_url content part; codex (the one CLI with a native image flag) gets it on argv via -i <path>; every other CLI worker gets a readable-path note in its prompt; a text-only loop worker keeps the pre-existing text-note fallback. Shipped 2026-09-03 (kqgcj). Pinned by npm run selftest:multimodal-dispatch (positive-controlled). |
| Chat planner provider tuning | DeepSeek-direct planner turns run with thinking mode disabled (thinking: {type:'disabled'}, provider-gated): tool calls stay clean and the final answer returns in the content channel (a bright answer bubble) instead of being routed into reasoning_content (which rendered as a dim [thinking] block and tripped a thinking-mode reasoning-replay HTTP 400). |
Standby worker pool (CYBERINE_STANDBY_POOL / --standby) | Opt-in pre-warmed worker pool for cyberine chat: declare a slot spec (e.g. opencode-build:2,loop-deepseek:1), workers pre-provision git worktrees before any task arrives. /run claims an idle slot first and injects CYBERINE_STANDBY_WORKTREE so WorkflowEngine reuses the warmed tree instead of cold-provisioning. Pool state (idle/busy counts) shown in the chat status line and in cyberine agents --once output. On exit the pool drains gracefully (worktrees reset to HEAD, handed to the reaper). Default = no pool; behavior byte-for-byte unchanged when unset. |
Permission mode (--permission-mode / CYBERINE_CHAT_PERMISSION_MODE) | Claude-Code-style dispatch-gating layer for cyberine chat. Six modes: default (confirm before dispatch), acceptEdits (auto-approve edits, bounded by deny floor + host sandbox), plan (never dispatches — writes a traceable plan file and stops), auto (fully autonomous, same bounds), bypassPermissions (skip all permission checks), dontAsk (silently refuses non-pre-approved actions). Shift+Tab cycles default -> acceptEdits -> plan. Active mode shown in the chat status line. Mode persists on the session record and is restored on --resume. |
| Chat input affordances | !-prefixed shell escape, Ctrl+R reverse history, Shift+Tab plan/build toggle, @-file picker with line-range support and auto-expansion. |
| Persistent input history | Chat prompt history survives session restart; Ctrl+R fuzzy-searches prior prompts. |
| Ghost-text completion | Dim suffix completing from prompt history; Right-arrow to accept. |
| Queued-message steering | Prompts typed while a reply streams are queued; Esc peels the last queued prompt; second Esc after queue-empty interrupts the stream. |
Mouse wheel scroll (CYBERINE_MOUSE=1) | SGR mouse mode in chat TUI; wheel events translate to transcript scroll. |
/resume inline picker | Fuzzy filter of prior chat sessions; Enter to resume, Esc for a fresh session. |
| Real cost in chat statusline | Provider-reported $cost displayed in the statusline; context bar ████░░░░ N% with amber warning at ~85 % used (bar hidden below ~60 %). |
| TUI progress phase groups | host.phase(title) in workflow scripts emits group header rows in the fleet list, grouping related steps visually. |
Run source tag | Runs display their origin (Chat, Cli, Sample, or workflow kind) as a tag column in the fleet list. |
| Themes & responsiveness | Theme tokens (dark/light/ansi), alternate screen, OSC titles, narrow-width degradation. Boxed panels use a top+bottom rule only (no left/right borders) with padding re-tuned to match. |
| Interactive dispatch | New-session flow picks a folder and launches a chat; /run dispatches to the auto-routed fleet and reports completion (with an cyberine apply hint for code runs). |
OS desktop notification (CYBERINE_NOTIFY) | System notification on run completion (default on; CYBERINE_NOTIFY=0 to disable). |
Terminal bell (CYBERINE_BELL) | Bell on run completion (default on; CYBERINE_BELL=0 to disable). |
| Worker toast notifications | Transient overlay toasts on worker done/error/cancelled transitions. |
Fleet TUI Ctrl+X tombstone | Remove a finished run from the registry history (two-press confirm). |
Agents-as-chat unified list (c) | The fleet TUI's agents view merges runs + chat sessions into ONE folder-grouped list (buildConversations, ConversationList) instead of two separate screens — 1 agent = 1 chat. ⏎ on a run row opens it as a read-only, live-updating chat transcript (runToChatMessages, reusing the same <Transcript> a live chat renders); ⏎ on a chat row resumes it as before. One control surface (x stop, m ping/steer) works identically from the list row and from inside the open transcript. |
| Esc-Esc previous-message recall (T523) | With an empty input box, a fast double-Esc recalls the most recent submitted prompt for editing (repeat steps further back, like Claude Code); sends as a new message, never a retroactive replace. |
| Readline residual keys (T522) | Alt+Y kill-ring yank-pop cycling + Ctrl+F char-forward on top of the already-shipped Ctrl+A/E/K/U/W/Y set; delta-vs-CC audit captured in .local/research/cc-parity/. |
# quick-remember shortcut (T524) | Input starting with # routes straight to the /remember store with a confirmation chip; bare #foo still goes to the planner. |
vim mode /vim (T525) | Opt-in NORMAL/INSERT modal editing in the chat input (h l j k w b e 0 $ x dd dw cw i a A I o O + counts), NORMAL/INSERT badge in the frame corner, persisted via chat.vimMode. Default OFF. |
| Auto-generated session titles (T526) | After the first exchange, a background call to the cheapest configured provider writes a <=6-word title (placeholder = first-line truncation); /rename pins forever; CYBERINE_CHAT_AUTOTITLE=0 opts out. |
| Fork-on-resume (T528) | Ctrl+F in the /resume picker / session browser, or cyberine chat --resume <id> --fork: clones the session into a new id ("(fork)" suffix), original untouched. |
Checkpoints + /rewind (T527) | One checkpoint per user turn (message index + dispatched runs + shadow-git file refs where they exist); /rewind truncates the transcript back and offers file restore ONLY behind an explicit confirm. |
/bg background surface (T529) | Lists detached runs + !&-spawned background shells with status/elapsed, kill, and tail actions; !& cmd is the new background shell escape. |
| Context bar CC thresholds (T530) | The status-line context meter stays hidden until ~60% used, flips to warn color at ~85%, and marks the auto-compact trigger point; single-knob CONTEXT_BAR in theme/env. |
/context breakdown (T531) | Static report of context composition (system prompt, memory preamble, tool schemas, todo, transcript) as proportional bars with token counts, consistent with the auto-compaction estimator. |
| Statusline command contract (T532) | CYBERINE_STATUSLINE_CMD (or config statusline.command) now receives a JSON snapshot on stdin and re-runs on a ~300ms debounce in chat (fleet hub keeps the 30s poll); errors fall back silently. |
| Update notifier (T533) | Once-a-day version-freshness check on TUI/chat start (git tag or npm registry by install shape); one muted "update available" line; CYBERINE_NO_UPDATE_CHECK=1 opts out; never blocks startup. |
| Local notifications (T534) | Terminal bell / OS notification (osascript / notify-send) when a run finishes, input is awaited, or a long turn completes; `CYBERINE_NOTIFICATIONS=bell |
| Keybinding namespaces (T535) | ~/.cyberine/keybindings.json gains fleet.* / chat.* namespaces (bare ids stay back-compat); 11 chat actions + fleet actions remappable with conflict warnings at load. |
/permissions /hooks /mcp viewers (T536-T538) | Read-only views of the active permission policy (with per-layer provenance), configured lifecycle hooks + recent firings, and MCP server status with retry/details actions. |
/output-style presets (T539) | Named system-prompt overlays for the planner (default/concise/explanatory + user-defined in config outputStyles), persisted per session, separate from the /style verbosity toggle. |
| Per-language syntax highlighting (T541) | Fenced code blocks highlight per language (ts/js/tsx/json/bash/python/go/rust/sql/yaml) via lowlight, cached once per block, CYBERINE_SYNTAX_HIGHLIGHT=0 opt-out; diff fences keep the diff path. |
| Fleet TUI profiling report (T547) | CYBERINE_PROFILE=1 now prints the checkpoint table on genuine fleet-TUI quit too (not just chat/loop), skipping interactive-session handoff cycles. |
Performance & smoothness
| Feature | What it does |
|---|---|
Profiling (CYBERINE_PROFILE) | profileCheckpoint/profileReport util gated behind CYBERINE_PROFILE=1: prints a per-phase timing table for chat boot (session-resolve, planner-resolve, render) and per-round loop metrics (TTFT, per-tool durations). Zero allocation overhead when unset. |
| Adaptive prompt-cache policy | Provider-aware cache policy (src/core/cachePolicy.ts): DeepSeek rides server-side auto-cache via a guaranteed byte-stable prefix; Anthropic-routed calls inject cache_control: {type: ephemeral} on the trailing system block + tool definitions, default 5-min TTL latching to 1h once the session reaches 8 model turns, with all cache params sticky-latched per session so the prefix never reorders mid-session. |
| Streaming budget-exhausted fallback | The budget-exhausted final completion streams token-by-token (stream: true + per-chunk emit) like the main loop — no non-streaming completion path remains in the loop adapter. |
| Speculative tool executor | The loop adapter dispatches a tool the instant its tool_use block is known-complete mid-stream (new tool_calls index => prior call complete; finish_reason=tool_calls => last call complete, dedup-guarded), gated on the Tool port canParallel flag (read-only tools overlap + run early; write tools serialize in model order). Tool-result messages reassemble by tool_call_id in original order. DeepSeek-direct gets thinking: {type:disabled} auto-injected when tools are present; degrades to post-stream parallel-within-turn for any provider lacking a mid-stream boundary. |
| 2-tier parallel startup | Chat + fleet-hub boot run independent critical-path I/O concurrently (session load, planner/provider resolve, UI settings + groups), render the shell ASAP, then fire deferred non-critical work (memory preamble, MCP discovery) post-first-paint. |
| Live-tail tokens in fleet TUI | A running worker's tokens appear live in the fleet TUI run-detail: in-process runs subscribe to a token bus directly; bg runs file-tail events.jsonl (token deltas batched at 50ms to avoid disk thrash). New token:delta event kind, backward-compatible with existing projection/replay consumers. |
useDeferredValue render isolation | The fleet runs-list and chat transcript snapshot use useDeferredValue so burst updates do not freeze input; the actively-streaming line stays on the priority (non-deferred) path. |
Rules & skills
| Feature | What it does |
|---|---|
Rules system (CYBERINE_RULES) | Global ~/.cyberine/rules/*.md + project .cyberine/rules/*.md injected as RULES preamble before dispatched tasks; path-gated rules via paths: frontmatter. |
| Skills system | Claude-Code-compatible SKILL.md format; `cyberine skill list |
Backlog tasks (cyberine tasks dogfood) | Read-only listing of open items from .local/dogfood/backlog-*.md; surfaced in chat via /backlog run <n...>. |
/cyberine:run Claude Code skill | Plugin skill (plugin/skills/run/, formerly cyberine-seat) mapping a plain-language Claude-subscription-seat request onto the exact cyberine run/wait/digest/apply invocation; discovers declared seat names via cyberine fleet doctor rather than assuming any. |
Plugins
| Feature | What it does |
|---|---|
Plugin manifest (cyberine-plugin.json) | Declares plugin kind (mcp for declarative out-of-process / code for in-process), display name, env-var requirements, and optional entry path. |
Declarative MCP plugin (kind mcp) | Cyberine connects to the plugin's MCP server out-of-process via McpToolAdapter; tools are namespaced and exposed to loop workers. Safe default: no code runs in-process. |
Code plugin (kind code) | In-process plugin; confirmed install prompt (shows kind, source, env requirements, --dangerously-skip-permissions warning) unless --yes flag is passed. |
| Trusted-dir gate | Plugins only load from ~/.cyberine/plugins (or CYBERINE_PLUGINS_DIR); the project working directory and task-writable paths are never scanned — one boundary, no drift. |
cyberine plugin doctor | Health-check all installed plugins: declared env vars, missing binaries, manifest validation errors. |
Three bundled skills renamed: seat -> run, decide -> ask, brainstorm -> plan | Shipped |
/cyberine:help -- the eighth bundled skill, a free front door | Shipped |
The plugin ships NO hooks: plugin/hooks/ removed and refused | Shipped |
Web UI (cyberine web)
| Feature | What it does |
|---|---|
| Browser fleet monitor + chat | Dependency-free node:http server serving a no-build SPA: 3-pane shell, live SSE run list, run detail with steer/stop/reap, chat planner with ask_user parity, Cmd-K search, OpenAPI /doc. |
| URL navigation (hash router) | Deep-linkable views (#/runs/<id>, #/chat/<id>, #/queue); browser Back/Forward walk the view history; all selection paths route through the hash. Shipped 2026-07-10. |
| Keyboard list navigation | ArrowUp/Down or j/k move a sidebar selection highlight, Enter opens, Esc closes overlays — TUI parity. Shipped 2026-07-10. |
| Full CRUD parity with the TUI | Run delete (registry tombstone), chat session create/rename/fork/delete, queue list + pending-entry delete (advisory-lock-guarded) — via DELETE /api/runs/:id, /api/chat/sessions CRUD, `GET |
| Queue view | Sidebar entry with live pending-count badge; status chips, runId links, per-row confirm-delete, 5s polling while open. Shipped 2026-07-10. |
| OAuth login/logout (SaaS auth) | GitHub + Google (OIDC/PKCE) login for the web UI via operator-supplied OAuth apps; hashed-at-rest cookie sessions with TTL, CSRF double-submit, deny-by-default CYBERINE_OAUTH_ALLOWED allowlist, GET /api/me, audit-logged logins. Login state is bound to the browser via a short-lived HttpOnly cookie checked at /auth/callback (RFC 9700 login-CSRF protection); Google logins are rejected unless the provider reports email_verified. Activation: CYBERINE_WEB_REQUIRE_AUTH=1 or non-loopback bind + configured provider; loopback stays open by default. Bearer API tokens keep working for programmatic access. Fail-closed gap: a non-loopback bind with neither an OAuth provider configured nor CYBERINE_WEB_REQUIRE_AUTH=1 refuses GET /api/* with 503 AUTH_SETUP_REQUIRED instead of serving it unauthenticated (a valid bearer token still works); mutating routes on any non-loopback bind have always required a bearer token. Shipped 2026-07-10, fail-closed gap + login-CSRF/email-verify hardening added 2026-07-11 (T596/T597). |
Strict CSP (no 'unsafe-inline') | Every response carries Content-Security-Policy with script-src 'self' and style-src 'self' plus one sha256 hash for the placeholder page's <style> block — an injected inline script or on*-handler attribute no longer executes. The dashboard markup has zero inline handlers/styles (addEventListener wiring + app.css classes); regression-guarded by npm run selftest:csp-inline-guard. Shipped 2026-08-20 (T676). |
Other entry points
| Entry point | What it does |
|---|---|
npm run cli -- --json "<task>" | One task -> every available adapter -> judge verdicts, as JSON. |
npm run mcp | Expose the orchestrator itself as an MCP server (orchestrate + bus tools). |
npm run demo | Multi-adapter compare demo. |
npm run typecheck | tsc --noEmit — the single build gate. |
npm run selftest:dep-audit | Recurring dependency-audit gate: red on any HIGH+ advisory with an in-range npm audit fix, warn-only on deferred major upgrades (vite/esbuild/vitepress trio). Since 2026-08-29 it discovers EVERY package-lock.json in the repo and audits each with an explicit cwd, reporting per-tree counts -- it previously ran npm audit with no cwd, so site/'s 701 dependencies had never been audited by anything; the site CI job now runs the site-scoped form too. Shipped 2026-08-20 (T673), multi-tree 2026-08-29 (T707). |
npm run sweep | The full selftest sweep, with a machine-readable SKIP channel. Discovers every selftest:* script from package.json, classifies on the exit code (0 pass / 78 skip / other fail), prints counts that add up, and FAILS when the observed skip set differs -- either direction -- from expectedSkips[<platform>] in scripts/selftest-manifest.json. Replaces a bash loop inside ci.yml that treated exit 0 as the only success signal and printed all N selftests passed using the DISCOVERED count, so a smoke that ran zero assertions counted as green (CI run 33106474716 skipped the whole host-sandbox class and still passed). Shipped 2026-08-29 (T707). |
npm run selftest:gate-list-drift | Security-gate drift check. scripts/selftest-manifest.json declares the security/data-integrity smoke set; this asserts the TRACKED .claude/rules/push-gates.md precondition 3 equals it, that ci.yml runs no runtime smoke or sweep (only the static drift checks), that every declared and every expected-skip name resolves to a real script, and that the local enforcement exists (sweep stamp writer, executable .githooks/pre-push, prepare wiring core.hooksPath). Shipped 2026-08-29 (T707) against the gitignored user-git-workflow.md and ci.yml's gate loop, where the rule comparison was UNVERIFIED on every runner; retargeted 2026-09-07 with the code-only CI cut. |
npm run selftest:sandbox-deny / -devnull / -symlink | Host-sandbox regression guards, executable on Linux CI since 2026-08-29. All three were Seatbelt-only and printed SKIP on every runner (ubuntu-latest detects docker, because seatbelt is darwin-only and runsc/bwrap were absent), so ~15 credential-exfil assertions plus the only end-to-end write confinement check never ran while the gate recorded a pass -- a class that had already regressed three times. CI now installs bubblewrap; each smoke has a bubblewrap arm asserting the same outcome by the other mechanism (confinement by non-binding rather than by deny-list), probes that the backend actually works before asserting, places fixtures off /tmp (bubblewrap binds it read-write), and exits 78 rather than 0 when no backend exists. Verified on a real Linux kernel with bwrap 0.8.0. Shipped 2026-08-29 (T707). |
npm run selftest:no-hard-reset | Selftest-suite hardening: no script under scripts/ may run a destructive git op (reset --hard, checkout -- ., clean -f, stash drop) against the live checkout; only worktree/tmp-scoped targets or an explicit // destructive-git-ok: comment pass. The t276 trust-regression smoke no longer hard-resets the repo root on porcelain drift (it had wiped uncommitted files). Shipped 2026-08-21 (kxbxj). |
npm run selftest:opus-catalog | Anthropic Opus 5 catalog: claude-opus-5 (1M ctx, 128K out) added to modelCatalog.ts + modelPricing.ts at the live-verified standard rate $5/$25 (the Claude Code release note's $10/$50 is fast mode), alongside the still-cataloged claude-opus-4-8; no worker default changed (Sonnet 5 stays). Same pass corrected claude-sonnet-5 to its now-permanent $2/$10. Smoke guards both ids, the standard-vs-fast rate, and that the invitation-only claude-mythos-* ids are NOT cataloged. Shipped 2026-08-21 (k3kbw). |
npm run selftest:deepseek-peak-pricing | DeepSeek peak/off-peak pricing, time-of-day-aware: the direct deepseek-v4-pro/deepseek-v4-flash rows in modelPricing.ts carry off-peak base + peak rates (peak = 01:00-04:00 and 06:00-10:00 UTC, live since 2026-08-16); getModelPricing()/computeChatCost() resolve from an optional Date (default now). The spend-cap path was fixed too: creditLedger.estimateCostUsd() accepts modelId + at and bills at the per-model rate when known (LoopAgentAdapter passes its model), and the deepseek provider fallback was raised to the peak v4-pro rate so it never under-counts. Also corrected deepseek.md: reasoning_effort is a top-level request field (none/low/medium/high/xhigh/max). Shipped 2026-08-21 (knk0q). |
npm run selftest:opencode-config-guard | OpenCode config known-key guard: the per-worker opencode.json the opencode adapter generates (T493) is checked at generation time against the top-level keys of opencode's published schema (https://opencode.ai/config.json), failing closed with the offending key named -- needed because opencode v1.18.16+ silently ignores unknown top-level fields instead of erroring. Generator extracted as buildOpenCodeWorkerConfig(); config content and argv unchanged. Shipped 2026-08-21 (km8aw, guard half; the binary upgrade from 1.17.10 is a separate operator decision). |
npm run selftest:opencode-parse | OpenCode --format json parse contract + drift guard: parseOpenCodeStdout coalesces streamed text parts by part.id, reads step_finish tokens/cost, degrades a tool-only run to a (no assistant text captured ...) summary instead of dumping raw NDJSON, and (2026-08-22) surfaces error events instead of swallowing them plus reports SCHEMA DRIFT naming the unrecognised event types when zero events match a known type -- the stream is unversioned, and before this an upstream envelope rename degraded silently to status:'success' with usage:undefined, so a build worker could write real diffs and report nothing. 21 fixture checks, no spawn. Shipped 2026-06-09, hardened 2026-08-22 (cyber-06). |
npm run docs:dev | Run the Next.js + Fumadocs docs site locally, hot-reloading (this catalog + USAGE + provider/design pages). VitePress was retired 2026-09-25 (T670). |
npm run docs:build | Build the static Next site to site/out/ (npm --prefix site run build under the hood). |
npm run docs:preview | Serve the pre-built static Next export (site/out/) locally for a production-accurate review. |
| Docs-site discoverability | On the Next site (site/), NOT the retired VitePress config this row used to describe: pageMetadata() (site/src/lib/metadata.ts) gives every docs route and all 6 marketing routes real og:title/og:description/og:image/twitter:* tags against a per-route card (og-default for docs, a named card per marketing route), sourced from frontmatter title/description with a site-tagline fallback. site/src/app/robots.ts emits Allow: / unconditionally and site/src/app/sitemap.ts enumerates every marketing + docs route; both are static Next metadata routes, not a bespoke buildEnd() hook. CYBERINE_DOCS_ORIGIN gates every absolute URL: sitemap.xml's entries (empty list when unset, rather than emitting relative URLs), the robots.txt Sitemap: line, canonical + og:url, and metadataBase-resolved og:image. Unset builds correctly with those omitted rather than shipping a placeholder domain; npm run site:deploy sets it to https://cyberine.dev, live since 2026-10-01 (T671). Shipped 2026-08-23 (cyber-010), rebuilt for the Next stack 2026-08-29 (T701). |
| External MCP consumption | Cyberine consumes any external MCP server's tools via McpToolAdapter; tools are namespaced mcp__<server>__<tool>; stdio + HTTP transports; configured via CYBERINE_MCP_SERVERS or CYBERINE_MCP_CONFIG. |
npm run selftest:footprint-corpus | Task-footprint estimator guard: asserts loadCorpus() actually reads run history (confidence rises above the 0.2 fallback and the numbers track the samples), that CYBERINE_RUNS_DIR re-scopes it, and (k5m89) that the typical-case fields are the MEDIAN not the mean, that a worker with >= 3 samples is keyed on its own history while a thinner one falls back to the blend, that an agentId@suffix folds onto its base worker, and that both admission bounds are p90. Exists because the estimator was dead from the day it was written -- a lazy require('node:fs') in an ESM package threw on every call and a bare catch swallowed it, so planBudget never once used real history. Every assertion positive-controlled by reverting the fix. Shipped 2026-08-23 (cyber-009), calibrated 2026-08-23 (cyber-010). |
npm run selftest:sync-output | DEC 2026 synchronized-output shim contract: makeSyncStdout() re-implements Node's Writable.write() overload normalisation by hand and fronts every Ink stdout write, previously with zero coverage. Asserts the bytes that reach the stream for string / buffer / empty / encoding / callback shapes, and that write(chunk, cb) still fires. No TTY -- writes into a PassThrough. Positive-controlled. Shipped 2026-08-23 (cyber-009). |
| DeepSeek-backed Codex worker (recipe) | Documented, NO-GO as standing worker |
| Thinking-model stuck detection | Shipped |
| Design-step fleet redundancy | Shipped |
DeepSeek user_id request isolation | Shipped |
| RunStore corruption scoping | Shipped |
Worker retirement (RETIRED_WORKERS) | Shipped |
Spawned-CLI PWD sync | Shipped |
opencode2 build-fleet worker | Shipped |
Seatbelt /dev/null write exception (ka8vw) | Shipped |
Claude cold-spawn --no-session-persistence | Shipped |
| Run.json structural validation | Shipped |
MCP orchestrate non-blocking transport | Shipped |
| Selectable Moonshot judge backend | Shipped (code-only, unverified live) |
| Daily-cap admission reservation | Shipped |
| Spend-cap selftest isolation | Fixed |
| Website rebuild: Next.js + Fumadocs site | Shipped |
| Owned design token system, theme-aware | Shipped |
| Self-hosted typefaces, zero third-party requests | Shipped |
| Six-route marketing surface with four signature moves | Shipped |
| Committed design QA gate | Shipped |
| Cyberine visual asset kit | Shipped |
| Web gate: one canonical path, no cross-origin writes, no fail-open bind | Fixed |
| Spend-cap truth: what counts, what is covered, what is held | Shipped |
| MCP auth gate covers all eleven dispatch/mutating/read surfaces | Shipped |
| MCP surface hardening: crash-resume durability, real install path, credential-scoped MCP-client spawns, honest dispatch errors | Fixed |
| Host-sandbox confinement: config writes, host credentials, grandchildren, fail-closed code_execution | Fixed |
| ToolContext identity and bounds: per-worker jobs, live budgets, reaping in every adapter | Fixed |
| Provider circuit breaker, bounded retry, and behavioural coverage for the untested stores and web routes | Shipped |
| KEYMAP-V2: chord notation, a context axis, and a structural guard for the TUI keymap | Shipped |
KEYMAP-WORKFLOW-CONTEXT: a dedicated Workflow context closes the khh09 follow-up | Shipped |
Swarm chunk dependsOn edges actually order execution | Fixed |
| ACCENT budget: two claims per screen, enforced against a rendered frame | Shipped |
KEYMAP-FLEET-ACTIONS: fleet.filter / fleet.hideFolder close the km09f follow-up | Shipped |
| FLEET-BENCH: a versioned coding suite that scores solve rate and dollars per task | Shipped |
| OPENAI-SDK-7-MIGRATION: drop the keepAlive:false workaround | Shipped |
Divider dim opt-in, light-weight rule glyph, and a doubled fleet-header rule removed | Fixed |
OpenTelemetry GenAI export -- CYBERINE_OTEL_ENDPOINT | Shipped |
| BOLD budget: one bold per region, owned by a single component | Shipped |
| Border vocabulary recorded as a decision: corner-less, one archetype, dead one deleted | Shipped |
| WIDE-BREAKPOINT: at 140 columns the hub splits into list and preview panes | Shipped |
| SMOKE-SKIP-ON-DEPLETED-CREDIT: live-provider refusal is a skip, not a fail | Fixed |
| One dot separator, no raw colour literal, no doubled hue | Fixed |
| Muse Code (Meta) as a CLI build-fleet worker | Shipped |
| Session handles: a unique, typeable name per live session, run and worker | Shipped |
@ mention completes live sessions, and the planner can message one | Shipped |
| Fleet TUI team-roster overlay, and a decision recorded for every other input | Shipped |
| Board record corrected: durable teammates ARE built; the addressability boundary is now stated | Fixed |
| Site QA: the last MEDIUM closed, and heading order promoted to a hard gate | Fixed |
claude-fable-5-1 in the catalog and pricing, with its cache anomaly recorded | Fixed |
| Claude workers deny prompts instead of hanging on a host that does not exist | Fixed |
| Duplicate-handle sends fan out and say so; Claude Code's ask-which-one declined | Shipped |
OpenRouter ~...-latest alias: decision re-confirmed, and it serves nothing | Fixed |
| The sweep names the failing check, and the swarm flake's leading theory is disproved | Fixed |
| Two sweep failures diagnosed the hour the reporting landed: a load-sensitive bound and a spacing regression | Fixed |
| The awaitRun flake was the assertion, not the system: no bus-latency defect exists | Fixed |
| MCP runs on the split 2.x SDK, and the audit that predicted a breaking rewrite was wrong | Shipped |
| A visual settings screen: four tabs, 39 knobs, and a gate that fails on a switch wired to nothing | Shipped |
CI on main was red for a day on a platform-specific npx install, not a code defect | Fixed |
cyberine tasks calibrate — declared effort vs measured context tokens | Shipped |
| Task-boundary policy — three tiers, evaluated only when a task finishes | Shipped |
| cyberine writes the task board on its own: the deterministic nf-tasks core, ported | Shipped |
TASKS-INTEROP-SMOKE: cross-implementation board interop, plus a spec-conformant cyberine init seed | Shipped |
Handoff bridge — an autopilot session hands off through amemoria, then bootstraps the next one | Shipped |
cyberine autopilot — the whole session -> handoff -> session loop, bounded and audited | Shipped |
First-party Telegram alerts (CYBERINE_TELEGRAM_BOT_TOKEN + CYBERINE_TELEGRAM_CHAT_ID) | Shipped |
Foreground cyberine run auto-routes a build fleet for code tasks (fleet.json map, then router; dead routes dropped; exit 2 when nothing routable) | Shipped |
Foreground cyberine run with a build fleet runs the implement-task workflow: per-worker worktrees, DiffJudge, run.json + cyberine apply | Shipped |
Judge backend fallback on 402/429/auth (deepseek-direct -> openrouter), judges abstain instead of crowning candidate 0, [verdict:positional] + state: done (unjudged) | Shipped |
CYBERINE_DEBUG_HANDLES=1 active-handle dump; foreground run shuts the LSP registry down so the process exits after state: done | Shipped |
opencode workers retired (opencode-deepseek, default-compare opencode); implement/swarm review pools no longer name opencode | Shipped |
CI is code-only: selftests job + security loop + bubblewrap probes removed from ci.yml (~20 min -> ~3.5 min per push); the sweep runs locally, writes .local/selftest-stamp/<sha>.json, and tracked .githooks/pre-push (wired by npm run prepare) refuses a push to main without an ok stamp; push preconditions and CI facts moved from the skill-regenerated user-git-workflow.md to tracked .claude/rules/push-gates.md + ci.md; T414-B (subscription allowlist) deleted from selftest:fleet-whitelist as an environment fact dressed as a code check | Shipped |
cyberine run --image <path> (repeatable) — image input on the one-command path; image tasks pin the vision-capable fleet and orchestrate() drops text-only workers via AgentInfo.acceptsImages | Shipped |
cyberine cost <runId> shows a per-worker prompt-cache hit % and a token-weighted run aggregate | Shipped |
MCP caller identity read from the per-request envelope (ctx.mcpReq.envelope), getClientVersion() only as the 2025-era fallback | Shipped |
| SecurityJudge pattern smoke (hostile + benign fixture per pattern, positive-controlled per pattern) and a URL-packed exfiltration heuristic with a host-anchored registry allowlist | Shipped |
CYBERINE_CLAUDE_BASH_OUTPUT_MAX_CHARS caps a claude build worker's bash output via inline --settings (verified on 2.1.263: unset delivers 60k chars whole, 2000 delivers 2,048 + a notice) | Shipped |
Measured boundary: a claude build worker's Agent subagents do not inherit the appended/overriding system prompt; an --agents override of general-purpose would, but --safe-mode (T492) drops it | Documented |
CLI-worker liveness: claude system/thinking_tokens (rate-limited per 500 tokens) and compact_boundary map to heartbeat progress events, so the reaper's idle clock sees a thinking or just-compacted worker as alive | Shipped |
Autopilot --driver stream — one steerable claude child per SESSION, and a SendMessage from any Claude session lands as an operator turn | Shipped |
cyberine autopilot --driver bg — the driven session is a real claude agents fleet row, steerable mid-run | Shipped |
cyberine autopilot --bg IS a claude agents fleet row by default, steerable from peek/attach | Shipped |
Every launchBackgroundRun dispatch (cyberine run --bg, chat /run, the queue consumer, awaitRun steps) tries a claude agents fleet row before the old detached child, by DEFAULT, with a read-only operator-input channel | Shipped |
CYBERINE_CLAUDE_WORKER_MODE=bg — the claude build worker is a daemon-supervised claude agents fleet row (cyberine-w-<runId8>-<slot>) instead of an opaque -p child | Shipped |
A task's model: tier reaches the model that answers on every autopilot driver, and a mixed-tier board's session cost is stated in the plan | Shipped |
Adapter liveness: cyberine doctor --liveness, GET /api/adapters/liveness and a fourth overview column report whether an adapter is FUNDED, not merely keyed | Shipped |
The autopilot's overshoot past --max-hours is BOUNDED and stated as a number, not left open-ended | Shipped |
| The attached autopilot's fleet-row detail line is printable ASCII by contract, and its first stdout write is newline-guarded | Shipped |
cyberine autopilot --on-drained brainstorm drafts the next batch as BACKLOG tasks when the board runs out of runnable work, instead of exiting | Shipped |
cyberine autopilot --batch N — one turn takes N disjoint tasks and fans each out to its own worktree agent, with subagent spend measured | Shipped |
| Adversarial review of the day's five commits found and fixed a FALSE wall-clock guarantee, a false-ok in the liveness table, an unbounded metered-spend loop and a prompt-deep promote gate | Shipped |
Three narrow board-write gaps found by review: converge validates status, brainstorm ids are checked against the board, and a flag no longer swallows the next flag | Shipped |
The autopilot's wall-clock bound now covers EVERY phase of a --driver bg turn, not just its measured phase | Shipped |
A --bg turn left unfinished at blocked is a named needs-input failure, not a success | Shipped |
| Autopilot backs off on a held turn instead of re-prompting at once; held turns do not count toward the turn ceiling | Shipped |
cyberine daemon --help prints usage and exits before any pidfile or loop | Shipped |
A handoff file that stabilises empty or without Where:/Next: or frontmatter is rejected with HandoffFileIncompleteError | Shipped |
| Attached mode strips CSI/SS3 escapes and control bytes from operator lines; attach writes nothing to stdout | Shipped |
A cli-unavailable cooldown is re-probed with the login check before it is honoured; a passing probe clears it, and doctor clears one it can disprove | Shipped |
Autopilot cold start reads the newest project handoff for session 1 and carries repeat-fail counts across invocations in .local/autopilot/history.json | Shipped |
--driver bg re-probes the subscription quota at session boundaries (reading older than 1m) and turn boundaries (older than 10m) through the same fold as a stream turn | Shipped |
| DeepSeek key-loop workers get an out-of-credits cooldown from the free balance endpoint whenever liveness is collected | Shipped |
Aborting a claude --bg worker inside the spawn window stops its job instead of orphaning it under the daemon | Shipped |
A spawned claude worker no longer inherits CLAUDE_CODE_OAUTH_TOKEN; the seat it bills is an explicit makeClaudeAdapter({ oauthToken }) choice | Shipped |
| Multi-seat Claude dispatch: declare per-account token files once, pin or fan out a build across seats | Shipped |
cyberine run --bg on a seat-pinned fleet detaches through Cyberine's own child instead of a claude --bg fleet row | Shipped |
Claude Code first-run wiring: cyberine skill install/mcp install, a doctor claude-code: section, and a bare-invocation nudge | Shipped |
cyberine init pins a project fleet.json after writing config.json | Shipped |
cyberine autopilot readiness: a non-git-repo refusal, a backlog-aware dry-run hint, and a ## 0. Readiness skill table | Shipped |
The global cyberine shim runs a built artifact, never the live working tree | Shipped |
cyberine wait reports four outcomes: done, run-failed, timeout, watcher-died | Shipped |
Artifact swap is atomic, snapshot contents come from HEAD, and wait prefers state over deadline | Shipped |
build.fleet from config.json is a preference resolved against fleet.json; /cyberine:seat pins the routed seat | Shipped |
First-run readiness: unborn-HEAD refusal, .local/ gitignored on seed, empty-board message, seats-only build.fleet alignment | Shipped |
/cyberine:seat applies the winner by default; preview is the opt-in | Shipped |
claude plugin eval suite for the bundled plugin | Shipped |
/cyberine:dispatch retired; the cheap lane is plain cyberine run --cheap | Shipped |
/cyberine:setup renamed /cyberine:init; plugin eval suite executed and rewritten | Shipped |
cyberine autopilot context window follows the model | Shipped |
cyberine autopilot --handoff checkpoint -- mechanical checkpoint from the agent's own STATE trailer | Shipped |
Spike kcgg5: one session + /compact vs fresh session + checkpoint -- fresh wins, flag removed | Shipped |
Exhausted Claude seat detected from api_retry; spawn abandoned, cooldown until the real reset | Shipped |
| AdversarialJudge skeptic reasons | Shipped |
| DiffJudge verdict names each rejected candidate and git's apply-failure detail | Shipped |
CLI worker timeout is CYBERINE_CLI_TIMEOUT_MS; OPENCODE_TIMEOUT_MS kept as a deprecated alias | Shipped |
| Handoff selection ranks by filename date, not raw mtime | Shipped |
| Quota reading attribution | Shipped |
Loop workers cool down until the provider's retry-after | Shipped |
HTTP message-bus backend (CYBERINE_BUS_BACKEND=http), hub-and-spoke cross-machine comms behind cyberine web | Shipped |
Pre-emptive seat rotation on allowed_warning | Shipped |
| CC-memory preamble handoff selection also ranks by filename date | Shipped |
/cyberine:tasks plugin skill -- the judgement half over the board writer | Shipped |
Autopilot's quota preflight and session drivers also abandon an api_retry-exhausted seat | Shipped |
cyberine init --vibe-rule bundles the vibe-coding rule template | Shipped |
| Bundled plugin skills carry no dependency on the author's private tooling | Shipped |
| Builtin handoff writer replaces the hard amemoria requirement | Shipped |
Cyberine rules replace --vibe-rule with asked, config-recorded consent | Shipped |
Board parity with upstream 2026-09-14: completed: baked from the flip epoch, damaged-bracket tolerance, doctor section 8 | Shipped |
| Board parity with upstream 2026-09-16: extras-reader tolerance, one status list, measured fence and field-order fixtures | Shipped |
Sweep stamp bound to the machine that swept it: .local/selftest-stamp/<host>/<sha>.json + a recorded host, verified by scripts/sweep-stamp.mjs from .githooks/pre-push | Shipped |
A non-success Claude result subtype fails the run instead of landing as an empty success | Shipped |
Submodule-scoped board listing: cyberine next / chat /next inside a manifest-less submodule show only tasks whose path: lands in it, --all restores | Shipped |
Worker env provenance: every toolingSnapshot records the launch-inherited CLAUDE_CODE_* / ANTHROPIC_* keys and whether the run was launched from a Claude Code session | Shipped |
| Foreign text fenced before every prompt: worker outputs, diffs, command output, web and search results, teammate notes, stored memory, CC handoff | Shipped |
Chat @ trigger and insertion aligned with Claude Code 2.1.273 as measured on a real terminal: quoted @"path with spaces" opens and completes, whitespace paths insert quoted | Shipped |
| Global shim resolves the artifact symlink to its real path, so Ink surfaces compile with the automatic JSX runtime again | Shipped |
Chat input keys aligned with Claude Code 2.1.273 as measured on a real terminal: Ctrl+W to whitespace, Ctrl+C discards text into the kill ring, Ctrl+C double-press exit actually works, Esc Esc on empty opens rewind | Shipped |
cyberine init wires what it DETECTED: one evidence-based detector, a detected default preset, and a setup --status detection table | Shipped |
fleet.json provider keys say CLI or API: API twins of a CLI worker end in -api (command-code-api, command-code-api-free, muse-api, gemini-api, claude-api, claude-api-gateway, openai-api, openai-api-gateway), fleet list gains a TRANSPORT column, and fleet doctor names the CLI twin that makes a keyless API provider optional and the pinned step that will skip a worker with no key or login | Shipped |
Sweep flake ledger: every sweep appends failedNames to .local/selftest-stamp/<host>/ledger.jsonl, the stamp records failedNames, and npm run sweep:flakes ranks smokes by failures and flags a same-SHA pass-later as a load flake; every in-process git worktree add/remove in one repo now shares one chain, judges and the standby pool included | Shipped |
npm platform gaps closed: x64 binaries on Bun's -baseline runtime, darwin-x64 compiled on a pinned Bun 1.4.2 when the running Bun is older, and the launcher refuses musl Linux by name instead of spawning a glibc binary | Shipped (unreleased; needs a version bump and republish) |
Chat planner add_tasks tool: cyberine chat writes a brainstormed task list onto the repo's board through the converge-apply writer, so chat -> board -> cyberine autopilot is one flow | Shipped |
Autopilot hands off only through the builtin writer; the amemoria handoff mode is renamed offload | Shipped |
| Plugin SessionEnd capture hook dropped; the headless handoff writer runs hookless | Shipped |
cyberine end inside an instruction runs to completion unasked | Fixed |
| Secret redaction covers Basic auth, percent-encoded tokens, zero-width-split key names and URL passwords | Fixed |
cyberine doctor flags a coexisting TaskBoard plugin | Shipped |
| TaskBoard bundle split under the plugin directory's 256 KiB file limit | Shipped |
npm run plugin:export for the plugin directory repo | Shipped |
| The site is live at cyberine.dev | Shipped |
| One-line installer at cyberine.dev/install.sh | Shipped |
| SEO pass for cyberine.dev | Shipped |
| Run-record site design | Shipped |
| Site figures cite a real run | Fixed |
| Docs Trust column coloured by its role | Shipped |