Documentation menu
On this page

skep version history

This is the release-by-release landing record that used to live in the README. The README stays focused on the current operator path; this file keeps the historical implementation notes.

The public repository opens at v1.0.1, because that is what the code is: pyproject.toml and skep.__version__ both said 1.0.1 when the repo was published. v1.0.0 was tagged only in the private development history, which stays private (LAUNCH-1-L3).

v0.1.0 (first public release)

The first public release is the launch baseline: sandboxed worker execution, independent re-verification, patch approval, durable audit evidence, learned approval templates, a Claude Code adapter, and a static launch page with a demo GIF.

What works:

  • macOS Seatbelt and Linux bubblewrap sandbox backends.
  • Inline approvals with approve-once, approve-and-remember, deny, and skip.
  • Learned template auto-match for similar later runs in the same repo.
  • skep review <task_id> evidence review and --approve branch landing.
  • skep --version, skep doctor, source install, package build, and release workflows.

Known launch limits:

  • Source install is the documented path until the v0.1.0 package is published.
  • Claude Code is the shipped real-agent adapter; Codex and Aider adapters were planned, not included. (Both shipped later, in v33 — Aider pinned to --no-auto-commit so it can never slip a commit past the approval gate.)
  • Template narrowing, ledger UI, scheduled autonomous launch stories, and hosted service work are post-launch roadmap items.

v1 (spine)

One worker, one lifecycle, proven end-to-end: create worktree -> mint contract task -> spawn the worker with a strict env allowlist -> watch deadline + heartbeats -> ingest verified result + event log -> durable audit record -> teardown. Including the death path: hung workers are killed on heartbeat loss, crashed workers get a supervisor-synthesized terminal event, and orphaned worktrees are swept on startup and after every terminal.

  • The supervisor store supplies the brain-stem (run records, approval queue, audit trail, and evidence indexing; see docs/adr/0003).
  • Skep's first-party coding worker supplies the hands (invoked as a subprocess; it edits, runs, verifies, and never commits).
  • The internal worker contract is the nervous system: JSON task in, NDJSON events out, verified result + evidence at the end.

v2 (landing)

  • Physically enforced boundary (Q1). Workers run under a macOS Seatbelt profile (sandbox-exec): outbound network and writes outside the worktree are physically denied, proven by escape tests and the full suite running the real worker sandboxed (docs/adr/0005). Scope, stated honestly: writes + network are enforced; reads are not confined (the G2 env allowlist already closes secret-env exposure); per-domain network allowlists need v3's proxy/container layer (Seatbelt filters by IP/port, not domain).
  • Re-verification (G10). A completed claim is not trusted: the supervisor re-applies the patch to a clean worktree and re-runs the worker's own recorded verification command under the sandbox, comparing exit codes (docs/adr/0006). A worker that claims "passed" but whose patch fails is caught and flagged ("NOT CONFIRMED") in status and review.
  • Auto-approval rules (D3, mechanism). Declarative rules can auto-apply a patch when conditions hold: verification + re-verification passed, no risk flags, diff in scope (docs/adr/0007). Built and tested in v2 but dormant by default (no rules -> the human loop is unchanged); active for real workloads in v3. Every auto-approval is audit-recorded auto:<rule>.
  • True suspend/resume (Q8). skep review <id> --approve on a suspended (pending_approval) task resumes it: a fresh run carrying the granted verdict
    • resume_of that proceeds past the policy gate (docs/adr/0008), instead of v1's re-run-from-scratch. Zero schema change (both fields were reserved at v0.1).
  • Usage accounting (G8). The worker meters provider calls + tokens into the reserved result.usage; the supervisor records it per task and shows it in status / review with an aggregate footer, so cost is answerable (docs/adr/0009). (cost_usd awaits a price map.)

v3 (landing)

The nightly dependency/audit bot (use case U1) is the spine. Every v3 piece is proven in one offline, deterministic acceptance demo (make u1):

  • Contract v0.2 (additive minor bump). worker_kind is now an open caste registry (D2) and permissions.network a per-task domain allowlist (D1, where [] means deny all). Every v0.1 envelope still parses; both consumers run >=0.1,<0.3.
  • Storage gate (G4). SQLite-WAL, single writer (not Postgres): made concurrency-safe for parallel dispatch and stress-proven (docs/adr/0010).
  • Network allowlist, physically enforced (D1). A per-task CONNECT-filtering proxy admits only allowlisted domains, and Seatbelt pins the worker's only egress to it: closing the v2 "Seatbelt can't filter DNS" gap on macOS without containers (docs/adr/0011). skep run --network pypi.org.
  • A second worker caste (D2): audit. A deterministic, LLM-free contract worker that bumps flagged dependency pins and re-runs the suite: dispatched by caste, re-verified (G10) like any worker. skep run --caste audit.
  • Scheduling (docs/adr/0012). skep schedule add ... --every 1d + skep tick (cron-driven; skep is not a daemon). Parallel dispatch runs a fleet of workers at once over the single-writer store.
  • GitHub PR + auto-approval active (D3, docs/adr/0013). skep tick --auto-approve auto-lands a safe fix (verified, re-verified, no risk flags, manifest-only) on a branch, never a push to the default branch; a major-version bump is risk-flagged and filed for review. review --approve --pr opens the PR.
  • Containers (Q1-B / G3, docs/adr/0014). A worker runs in a container with the same host proxy enforcing D1, proven live (make container, opt-in). The egress pin (iptables in the container netns) and a container spawner backend are honestly logged as the remaining subset; the v0.1.0 launch baseline now has Linux/macOS CI.

v3.5 (landing)

Workflow templates: user-authored, parameterized task recipes (use case U2; the human-authored precursor to v4's skill registry). A template names the instructions and the v3 knobs (caste, repo, network, env, budget) with {{param}} placeholders; instantiating it mints a completely normal task, so this is zero contract change (docs/adr/0015).

skep template add dep-audit --caste audit \
  --instructions "Audit {{ project }} dependencies and bump known advisories." \
  --param project                       # or: skep template add --from audit.toml
skep template list | show dep-audit

skep run --template dep-audit ~/code/acme --param project=acme   # on demand
skep schedule add nightly ~/code/acme --template dep-audit \
  --param project=acme --every 1d                                # bind to a schedule
skep tick                                                        # "run the audit template"

A schedule bound to a template is a live reference: tick re-instantiates the current template each time, then dispatches through the same spine (sandbox, D1, G10, D3). Proven end-to-end, offline, in make templates (author once -> run on demand and schedule; both G10-confirmed).

v4 (landing)

Learned skills: generated task recipes with a draft -> tested -> approved promotion pipeline (docs/adr/0016). v3.5 was the human-authored floor; v4 adds the learning loop on top, with the honesty kept front and center: the "learning" is a deterministic heuristic generalizer, not a trained model, and the real substance is the governance: a test gate and a human-approval gate. A candidate never self-promotes.

skep run ~/code/acme  "Audit acme dependencies and bump known advisories."  --caste audit
skep run ~/code/globex "Audit globex dependencies and bump known advisories." --caste audit
# ...skep noticed you keep doing the same shape of work:
skep skill propose                       # generalize successful, G10-confirmed runs -> a draft
skep skill list | show <name>            # the candidate + its evidence
skep skill test <name> ~/code/foo --param arg1=foo   # the G10 test gate: pass -> 'tested'
skep skill approve <name> --as dep-audit             # HUMAN gate -> joins the registry
skep run --template dep-audit ~/code/bar --param arg1=bar   # then run/schedule it like any template
  • Generation (skills.py) clusters completed + G10-confirmed runs by their fixed knobs and instruction shape, and extracts the parts that vary into {{argN}} parameters. Deterministic and conservative: it names slots structurally (arg1, not project), refuses over-general or mixed clusters, and proposes nothing when in doubt. It is honest heuristic pattern-extraction, not ML.
  • Two gates with teeth. skill test instantiates a draft and dispatches it through the same run_task spine; it is promoted to tested only if the run completes and the supervisor re-verifies it (G10). A failed test is auto-rejected (auto:test-gate, fail-closed). skill approve is the only path into the registry, and only a human walks it.
  • Unified registry. An approved skill is inserted into the same v3.5 templates library, tagged provenance="learned", and is run/scheduled by the unchanged spine. Nothing downstream branches on provenance: it is a tag, not a fork. Candidates live in a separate table until approved, so an unapproved one is structurally unable to run.
  • Audit trail. Every promotion and rejection is recorded in the existing approval queue with the actor (operator or auto:test-gate) and the evidence it passed on.

Proven end-to-end, offline, in make skills: from observed runs -> generate -> test -> human-approve -> run and schedule like a template. A candidate that fails its test, or is denied, never enters the registry. Zero contract change: a learned skill is still just a template -> a normal task.

v5 (landing)

The face and the box: a web UI served by the supervisor itself (docs/adr/0017), and the whole thing packaged as one container image (docs/adr/0018). A user who has never opened a terminal runs one command, opens a browser, and operates the full loop: assign -> watch the events stream live -> approve / deny / open a PR -> edit templates, learned skills, schedules, policies, and the worker model. Zero contract change: the UI is an API layer over the same core the CLI calls; both surfaces stay.

# After the first public version tag publishes an image:
docker run -d -p 8765:8765 -v skep-data:/data \
  -e ANTHROPIC_API_KEY ghcr.io/anmolnoor/skep        # or: docker compose up -d
docker logs <container> | grep "access token"        # paste it into the browser
open http://localhost:8765
  • skep serve: a FastAPI daemon over the existing core: thin handlers (validate -> call the core -> JSON), POST /api/runs answering 202 + task id while the run continues on a background pool, SSE event streaming (live worktree tail during the run, audit trail after ingest), and an in-process scheduler ticker that replaces cron inside the container.
  • Same gates, new surface. Approve over HTTP is the CLI's exact semantics: a completed run's patch lands on skep/<task_id> (Q5, patch-as-approval); a suspended run resumes past the gate with the granted verdict (Q8). G10 re-verification and the D1 allowlist are enforced in the core beneath both.
  • Mutable, persisted settings: the one structural change to existing code: a settings table + rebuild-and-swap of the still-frozen SupervisorConfig, so a policy or model edit applies to the next run and survives restarts.
  • Auth: a first-boot token in the boot log gates every /api/* route; the browser authenticates SSE by cookie (EventSource cannot set headers).
  • One volume. Everything lives under SKEP_HOME=/data/skep: store, audit evidence, cloned repos (/api/repos clones by URL; no host paths needed), model settings, and the token. The container is disposable; the volume is not.
  • The honest Linux posture: the container is the isolation boundary; the D1 proxy enforces the allowlist but the iptables egress pin is still future work, and mounting the docker socket (root-equivalent) is refused (docs/adr/0018).

Proven offline in make serve: boot -> token auth -> assign over HTTP -> SSE-stream the run -> approve -> the fix is on a branch with main untouched -> policy edit round-trips. make image builds the box from this Skep checkout; CI boot-checks it and publishes to GHCR on version tags.

v6 (landing)

The voice: chat with the Queen's own model, in the browser (docs/adr/0019). A Chat workspace talks to any Ollama-API endpoint (Ollama Cloud or a local daemon), and the model gets gated hands over the supervisor. Zero contract change; the worker's provider (A6) is untouched.

  • Setup is the exact flow you'd want: Settings -> paste base URL + API key -> Test & save connection -> the live model list appears -> pick the default. The key is the one deliberate G2 exception: a 0600 llm-secret file beside the serve token, never in SQLite, never in any GET response; SKEP_LLM_API_KEY overrides it.
  • Durable sessions. Chats and every message persist in the store; replies stream token-by-token (SSE over fetch); a refresh replays the conversation. Chats title themselves; a per-chat model can override the default.
  • Reads run free, mutations confirm-carded. The model may always look (runs, approvals, policy, templates, skills, schedules, repos). It can only propose set_policy / approve_review / deny_review / dispatch_run: each proposal is a card in the chat, nothing executes until you click Approve, and a confirmed action runs the same actions.py verbs, and lands in the same audit trail, as the buttons in the UI, as actor chat-user. The model never holds the trigger.

v7 Stage A (landing)

More local-model protocols: the same chat workspace can now speak either native Ollama or OpenAI-compatible chat APIs (LM Studio, vLLM, OpenRouter-style servers) by selecting the protocol in Settings. serve/llm.py normalizes model listing, SSE chat chunks, and streamed OpenAI tool-call argument deltas so the existing confirm-card gate is unchanged. Proven with a fake OpenAI-compatible server over localhost: config/test/model-list round-trip plus a streamed set_policy tool call that pauses as the same confirmation card.

v7 Stage B (landing)

Notes & Tasks: a lightweight workspace plus chat tools for local intent. Notes and todo tasks live in the supervisor store, with REST routes and browser CRUD. Chat can freely add_note, add_task, and complete_task because those only change inert local state and are audit-recorded as chat-user; set_task_due, delete_note, and delete_task remain confirmation-carded because they schedule future behavior or destroy data (docs/adr/0020).

v8 (landing)

In-repo coding worker: the default coding worker dispatches python -m skep.workers.coding unless --worker-cmd or SKEP_WORKER_CMD explicitly names another adapter. Relative --home paths are resolved at startup so sandbox evidence paths are absolute.

  • Assistant-config bootstrap. If no worker profile.json exists, the worker reads the saved assistant LLM config and 0600 llm-secret from SKEP_HOME. An explicit worker provider profile still wins.
  • Provider network default. Coding runs dispatched through serve inherit the configured provider host in their network allowlist when the request omits network; an explicit network: [] still means deny all.
  • Capability registry. File writes, verification shell commands, git gates, and network fetches are explicit worker capabilities with event evidence.

v19 (first-session friction fixes)

Twelve fixes derived from a live field test where one "add a README" task took 74 chat messages, 12 runs, and 6 manual approvals. Contract bumped to 0.2.1 (additive/optional only — the claude adapter's >=0.1,<0.3 range still holds).

  • F1 — Batch plan approval. A tool plan is pre-flighted before step 0: every not-yet-run non-verify shell.run step that needs approval is collected into ONE approval.requested gate carrying the full command list, and one approval grants them all on the single resume. The field-test add-README chain collapses from 5 runs + 4 approvals to 2 runs + 1 approval.
  • F2 — Provider host always in the allowlist. resolve_run_policy merges the configured LLM provider host into every coding run's network on all creation paths (chat, API, CLI, scheduler, resume), not only when network was unset.
  • F3 — No git push from the worker. git push/pull/fetch are denied at the worker before any grant, removed from the git preset, rejected by the policy editor, and swept out of poisoned stores. Landing stays patch → approve → skep/<task_id> branch.
  • F4 — Safe "remember command". Remembering persists the exact normalized command (drops a git -C <path> pair), refuses remote-git, runs the too-broad guard, and prefers the repo's bound project policy over the global setting.
  • F5 — Detached-HEAD worktree context. The worker prompt states it runs in an isolated detached-HEAD worktree, and git checkout/switch are denied with a teaching message (the git checkout -- <path> restore form stays legal).
  • F6 — Exit-code verification. A run passes on the verify command's exit code alone; a wrong expected_stdout guess is a note, never a failure.
  • F7 — One recovery replan. A failed command or a denied step feeds the real error back to the model for one corrected plan instead of an instant death.
  • F8 — Superseded runs. Approving a run supersedes it (new terminal state); the successor's worktree stays in the durable orphan-sweep keep-set, and superseded runs leave the pending counts and the default status listing.
  • F9 — Unified provider config. UI provider setup writes through to profile.json, so skep doctor agrees with the daemon; the worker's profile path falls back to the daemon secret, and doctor prints an advisory when only the sqlite store is configured.
  • F10 — Visibility-aware polling. The dashboard skips polling while hidden, backs off on failure, and the store checkpoints (truncates) the WAL on startup.
  • F11 — Deterministic allowlist. The resolved network is sorted + deduped (byte-equal task.json for equal inputs), and the dispatch decision records the requested vs resolved lists as a reproducibility breadcrumb.
  • F12 — Remediation hints. Known failure classes render a one-line "what to do next" in the run view and in chat.

v9–v17 (the roadmap, landed 2026-07-08)

Nine versions implemented in one unattended run; the authoritative per-step record is plans/EXECUTION_LEDGER.md. Headlines: contract v0.2/v0.3 (network allowlist, open castes, plugins), the autonomy scorecard (v12), curated durable memory (v13), the provider registry + routing engine (v14), nodes + governed local ops (v15), channel adapters (v16), MCP-as-capability and deep research (v17). v18 (public release) was deliberately not executed; its mechanics landed later via v27/v37.

v20 (landing-funnel fixes, 2026-07-08)

Six fixes from the v19 re-test: landing branch validation + named landing branches, supervisor-side baseline diffs, re-verification warnings surfaced at landing, reverification_summary on every run view.

v21 (the vestigial commit tail, 2026-07-08)

One fix: a worker commit tail is requested ONLY by contract intent (requested_actions=["git.commit"]) — instruction keywords are inert, so "…commit to branch X" no longer costs a second run and a second approval.

v22 (deterministic baselines, 2026-07-08)

Runs pin their baseline to the repo's default branch (not the operator's checkout); worker-side git-commit denial is a capability guard (is_worker_commit_command); the Queen gets repo_state eyes.

v23 (policy that actually applies, 2026-07-09)

Effective-policy resolution per repo (/api/repos/{name}/effective-policy), managed repos root, trusted-dev registry hosts, the auto_approve deprecation notice, land_run as a shared verb.

v24 (scheduler blind spots, 2026-07-10 area, landed 2026-07-09)

Dispatch ref + append-landing semantics, scheduler repo_slug binding, idempotent project setup (seeds_skipped). The maintain-phase integration branch was deferred here and landed as v30.

v25 (the command deck + local work, 2026-07-10)

Deterministic /commands in the chat composer (operator-sourced cards, actor operator-command), /workon local-dir on-ramp (confirmed git baseline + trusted project), and the drift pin that keeps the deck table and its executor one surface.

v26 (live channels, 2026-07-10)

ChatEngine extracted (one turn loop, many faces); Telegram long-polling live; Slack signed webhooks live; channel identities allow-listed and fail-closed; only low-risk actions channel-confirmable.

v27 (public release mechanics, 2026-07-10)

scripts/install.sh, ADR index, release runbook, version reconciled to 1.0.1; the PyPI publish step wired but parked pending a trusted publisher (operator action).

v28 (Linux egress parity, 2026-07-10)

netshim + AF_UNIX proxy bridge under bubblewrap: per-domain egress is now ENFORCEABLE on Linux, closing the long-standing v14-7 skip; the suite's last allowed failure retired — fully green everywhere since.

v29 (governed web reading, 2026-07-10)

network.read as a governed capability over the existing fetch gate; HTML→text extraction (deliberately naive tag-strip, upgrade path noted).

v30 (maintain-phase integration branch, 2026-07-10)

Maintain-phase auto-apply accumulates on ONE skep/maintain branch (project policy auto_apply_branch, skep/ namespace enforced); approvals.landing_branch persisted so applied_branch is accurate on every landing path. main never advances automatically.

v31 (skill distribution, 2026-07-10)

Signed skill bundles (skill export / skill import --approve with a human gate), canonical bytes + signature verification, REST preview/export routes.

v32 (gated ops execution, 2026-07-10)

ops_executor executes ops plans for real behind ops run --approve (last-guard re-validation), closing v15's dry-run-only partial.

v33 (more agent adapters, 2026-07-10)

AdapterSpec + cli_adapter extraction; Codex and Aider adapters shipped (Aider pinned to --no-auto-commit so it can never slip a commit past the gate); bonus first-party Ollama LLM-planning worker.

v34 (worker PATH hygiene, 2026-07-10)

The supervisor's venv is stripped from worker PATH (system toolchains resolve for real); LLM plan semantic validation moved to parse time.

v35 (plan only)

"Chat as a narrated timeline" was designed but never implemented — see the v39 audit; it remains a standing arc.

v36 (plan only)

"Policy-First Skep" (unified policy schema, decided_by, MCP fail-closed wiring, templates) was designed but never implemented — see the v39 audit; its fail-closed kernel landed as v39-F1, the rest remains a standing arc.

v37 (landing)

Closing the product gap (the 2026-07-10 comparison review's open items):

  • F1 — Publish rehearsal. A manual-only TestPyPI lane in release.yml exercises the exact trusted-publisher OIDC path with zero public commitment; the package/GitHub-release job is now explicitly tags-only. scripts/mirror-demo-repo.sh mirrors examples/skep-demo (never pushes without --push). docs/releases/README.md gains the go/no-go runbook: everything below the operator's risk acceptance is a numbered command.
  • F2 — Docs curation. docs/README.md is the curated index (a test pins that every doc is listed); the landing page links the docs; SECURITY.md and GitHub issue templates exist. No site generator — GitHub renders markdown.
  • F3 — Onboarding wizard. skep setup --personal on a TTY with no provider flags asks for provider/model/endpoint and the API-key env var NAME (never the key). Flags, env vars, and non-TTY stdin behave exactly as before.
  • F4 — Discord, live. A gateway websocket thread (new dep: websockets) beside the Telegram poller: messages run real Queen turns, confirm cards render as embeds, ✅/❌ reactions and embed buttons resolve through the same fail-closed channel gate as Slack buttons — shell/policy cards are never channel-confirmable. live: true for all three channels, and the posture docs say exactly what runs.
  • F5 — ADR 0021. Interactive browser automation deferred with named revisit triggers; v29's governed network.read covers the read use case.

v38 (landing)

The terminal face — skep chat, a REPL client of the serve daemon over the same token-gated HTTP+SSE surface as the web UI (same gates, same actors, same audit rows; the REPL never opens the store):

  • F1 — REPL core. ServeClient + SSE parser + streaming turn renderer; --chat/--continue sessions; readline history and editing; daemon down is a teaching error, never a shadow dispatcher.
  • F2 — Cards inline. Confirmation cards pause at the prompt: [y] confirm [n] deny [s] skip; skipped cards stay pending and resolvable in the web UI (one store, two surfaces).
  • F3 — The deck in the terminal. The same 12 /commands as the web composer, tab-completed; mutations audit under operator-command; two drift pins keep the Python deck, its executor, and the web deck identical.
  • F4 — Run telemetry inline. Confirmed dispatches auto-tail run events at the prompt; Ctrl-C stops watching, not the run; approval gates prompt right there and resumed successors are tailed too.
  • F5 — Banner + --oneshot. Entry banner says what needs a human; --oneshot is the scripting face (stream one reply, exit 0, cards skipped and reported by id).

v39 (landing)

The reconciliation round — closing the gaps a full plan audit (v1–v38) surfaced the day v38 landed:

  • F1 — MCP fails closed. An MCP tool name the risk heuristic cannot classify now requires approval instead of riding the read auto-allow; granting the unknown risk is an explicit policy act.
  • F2 — Stale claims healed. Three modules stopped claiming the Linux per-domain egress gap that v28 closed; pinned so it cannot regress.
  • F3 — One contract range. SUPPORTED_CONTRACT_RANGE is declared once, in the contract package; six importers, drift-pinned.
  • F4 — Routing wired. resolve_routed_provider (built in v14, never called) now runs at dispatch: the decision is recorded on the run and an ollama-protocol profile configures the first-party worker via env — without ever widening the run's network grant.
  • F5 — History matches git. v9–v36 landing entries backfilled (v35/v36 marked plan-only), stale launch-doc claims corrected, and a pin keeps every future round in this file.

v40 (landing)

The standing arcs executed — v35 (chat as a narrated timeline) and v36 (policy-first), the two plans the v39 audit found designed-but-unbuilt:

  • F1–F4 (v35). The web chat reads like a document: consecutive tool calls fold into one deterministic activity row; supervisor tools summarize from result json; dispatched workers stream live INSIDE the chat (heartbeats, commands with failures and output tails, a read-only approval pointer, a diffstat pill) with refresh converging live and replay; prose styling and mobile output scrolling finish the reading.
  • F5–F6. ADR 0022 and policy_schema: one unified scope-policy schema (coding/shell/filesystem/network/mcp), default deny, deny-wins-ties, decided_by on every decision, learned rules that can never promote into denied space (the worker-git floor sits above the schema).
  • F7–F9. resolve_run_policy compiles the schema — the contract's Permissions is the compiled artifact (zero behavior change, corpus untouched); decided_by threads worker events → approvals → views (contract 0.3.1); the ops engine reads its bounds from the document's scopes.
  • F10. MCP goes live, fail-closed: registered servers persist, the Queen can discover and call MCP tools, unknown tools card, explicit denies refuse without a card, allow-always writes a vetted learned rule.
  • F11–F13. Four templates as data with golden resolved fixtures; skep setup --template previews, applies, and diffs switches (v19 replay pinned at one run / one approval); user-facing vocabulary becomes Policy / Scope / Gate / Template / Audit.

The v36 Stage F Hermes-replacement field test remains operator-owned and pending — it is the release bar, whatever the suites say.

v41 (landing)

The last code seams — the three items the remaining-work ledger named as the whole code backlog; after this round what's left is Stage F and the publish ritual, both operator-owned:

  • F1 — conversational scheduling. propose_schedule joins the chat tools (always cards — the set_policy shape; the create mirrors POST /api/schedules, trust stays at tick time) and /schedule lands on both command decks (web + skep chat), so "check my repo every morning" said in chat becomes a confirmed, ticking schedule.
  • F2 — Telegram inline approvals. The third transport of the v16 posture: low-risk cards carry an inline Confirm/Deny keyboard when channel_can_confirm is on (default off — byte-identical to v40 otherwise), resolved through the same shared fail-closed gate as Slack buttons and Discord components. A press is admitted only when BOTH the card's chat AND the pressing user are allow-listed (equal in the operator's DM; a group bystander fails closed). Shell/policy/patch cards never grow buttons anywhere.
  • F3 — email scope live (resolves ADR 0022 N1). email gains read/send; a registered MCP server may bind scope: email, and its tools decide under that scope — read-shaped names flow as email/read, everything else (unknown included) cards as email/send. Hard denies refuse inline and survive confirmation; learned allow-always rules land in the server's scope, vetted against every deny. locked-down / personal-dev / homelab-ops gate email like they gate mcp; assistant keeps its risk-ladder character (reads flow, sends card). Binding a real mail server is the operator's half; the path is proven against the fake.

v42 (landing)

The researcher caste actually runs — field test 2026-07-14: the first real start_research was rejected, because v17 Step 5 shipped run_research as a fetcher-injected library with no runnable contract worker and no caste registration, so every research run fell back to the default coding worker and was refused on arrival:

  • F1 — researcher contract worker + registration. workers/researcher.py gains the standard --headless contract entrypoint (the audit/curator skeleton) around the existing run_research: sources are the allow-listed hosts, fetched via stdlib urllib + html_to_text (v29-F1) inside the sandboxed allowlist, artifacts are .artifacts/report.{md,html} + sources.json (never a patch — nothing lands), and verification is honest (zero fetched sources → failed, never a completed claim). build_config registers the caste; the deep-research template's instructions now describe the real mechanism instead of a tool the worker doesn't call. Deterministic and LLM-free — a research run needs no provider.
  • F2 — reports carry the fetched content. The first real run completed but answered nothing: excerpt-only report lines, plus two sources 403-ing urllib's default User-Agent. Reports gain a ## Content section with the readable page text (10k cap per source); fetches send a browser-like UA suffixed skep-researcher — the allowlist, not the UA string, is the security boundary.

v43 (2026-07-14 → 2026-07-15)

Research as a daily driver — field test 2026-07-14, session 2 (plan: plans/v43/README.md; F5/F6 landed same-day, F1–F4 completed 2026-07-15 after the v44 run):

  • F5 — note-kind schedules (operator request, landed first). "Send me a joke every 30 seconds" had no home: every schedule was a repo-bound worker dispatch. worker_kind="note" is now a schedule kind the tick resolves by posting the instructions text as an inert note (actor schedule:<name>, state note_posted, a health success) — no repo, no worker, no policy surface. Chat propose_schedule and POST /api/schedules accept caste note with repo optional; worker schedules still require one. The text is static — a recurring reminder, not generated content.
  • F6 — note schedules deliver into the creating chat. Operator, same session: reminders in a panel you don't watch aren't reminders. Schedules gain a nullable chat_id; a propose_schedule confirmed in a chat binds to it (threaded supervisor-side through execute_mutation — the model never names the target), and the tick posts the text as an assistant message there, falling back to the inert note when the chat is gone or the schedule was created outside chat (API/CLI).
  • F1 — report.html is dark-mode + tables natively. run_research emits a self-contained styled document (inline dark CSS, sources as a real status/url/evidence table, per-source content sections); every escape pin holds and report.md is unchanged. The restyle-coding-run class dies.
  • F2 — reports delivered to ~/.skep/workspace/<slug>/. On completion the supervisor copies report.md/report.html/sources.json to a kebab-slugged, collision-proof directory and records it as a workspace_delivery artifact get_run quotes verbatim. The copy-run pattern (and its shell approvals) is gone.
  • F3 — the empty-file chain, reconstructed then closed. The audit trail of 019f6222-298f shows a +placeholder patch passing an existence-only test -f verify, then a copy run reading a baseline without the file (0 bytes). Fix at the worker's verification evaluation: a PASSED outcome is rejected when the run's ENTIRE output is empty files; the copy-run half died with F2. Full addendum in plans/v43/README.md.
  • F4 — heartbeat progress in the dispatching chat. Ephemeral SSE status lines (GET /api/chats/{id}/status, every Nth heartbeat, default 2, 0 disables, never a transcript row) plus one PERSISTED honest failure line — state and reason — pushed into the dispatching chat (and its messenger via v44-F2) the moment a chat-dispatched run dies.

v44 (2026-07-15)

Hermes parity — skep as the daily driver (plan: plans/v44/README.md). The operator retired the Hermes agent; the ten deployed-Hermes features skep lacked, rebuilt at skep's posture. Landed fix-by-fix, gates green each step:

  • F1 — Discord routing parity. require_mention (threads skep created and DMs exempt), auto_thread per routed mention (session rebinds to the thread), and a user-level allowed_users allowlist on top of the channel one — all fail-closed, decided in the pure v16 adapter.
  • F2 — outbound push. channels/outbound.py + the scheduler's notify hook: scheduled/system messages bound to a messenger chat are pushed OUT over the existing REST sends. schedules.once + start_at make one-shot reminders honest.
  • F3 — inbound webhooks. POST /hooks/{name} (outside the token gate; GitHub HMAC or constant-time shared secret), {a.b.c} templates, delivery as a notification into the bound chat — never a model turn. Operator-only management via /api/webhooks + a settings card.
  • F4 — script-kind schedules. The --no-agent cron lane: sh -c on the supervisor host at tick time, output capped and delivered like a note tick; non-zero exit is an honest health failure. Creation is operator- gated (model proposals always card with the command verbatim).
  • F5 — discord_admin. discord_delete_message / discord_timeout_member as ordinary confirm-carded tools, deliberately NOT channel-confirmable — a hijacked Discord account can't confirm its own moderation.
  • F6 — skep skill import-md. Hermes SKILL.md packs become v31 registry skills through the SAME grant gate; shipped scripts grant NOTHING unless each is explicitly --allow-scripted.
  • F7 — podman sandbox backend. Opt-in sandbox_backend=podman: skeleton rootfs overlay + host toolchain RO binds (bwrap semantics in container terms), --network=none deny-all, domain lists fail closed, loud fallback to the native backend — never toward no sandbox. Live smoke proves no route out on this host.
  • F8 — search_web. Keyless Queen-side READ tool (DuckDuckGo HTML); discovered hosts only become an egress allowlist by riding a start_research confirm card — the proxy's exactness guarantee is untouched.
  • F9 — image input in chat. Raw-bytes upload, magic-byte sniffed, 5 MiB cap; composer picker + paste; thumbnails in the transcript; images reach the model only when the new llm vision flag is on (honest text placeholder otherwise); Discord attachments ride the same path.
  • F10 — personalities. Per-chat style preamble (three presets + custom:), APPENDED to the operative prompt and never overriding it; /personality on both decks, confirm-carded.

A concurrent session landed the chat-source UI arc in the same window (chats.source column + backfill, faces stamping their source, the sidebar grouping non-web chats) under its own v44-F1..F3 labels — same version, different fix track; plans/EXECUTION_LEDGER.md disambiguates by commit.

v45 (2026-07-15)

Search parity with Hermes + a live smoke lane (plan: plans/v45/README.md). Comparing v44-F8 against the deployed Hermes search stack showed three gaps: no snippets (the small Queen picked sources on titles alone), rate-limit anomaly pages degrading to a silent [], and one hand-rolled regex against one endpoint. And nothing proved the feature surface against the real ollama backend.

  • F1 — search_web speaks ddgs. The ddgs package (Hermes' own free backend) replaces the regex scrape: {title, url, host, snippet} rows, multi-engine rotation, transport failures raise WebSearchError (the tool wrapper still degrades to a clean tool error), and a per-call worker thread enforces a hard 30s wall-clock cap — Hermes' #36776 lesson: the ddgs retry loop has no overall bound. Zero hits is a result; a transport failure is an error; never conflated. Posture unchanged: READ tool, discovered hosts still only become egress by riding a start_research card.
  • F2 — live feature smokes. tests/external/test_feature_smokes.py (existing external_app opt-in): LLM probe, chat turn, read-tool lane, live search with snippets, card deny AND confirm + ticker note delivery, memory propose→approve→search, research card carrying discovered hosts, and skep chat --oneshot against a real serve subprocess. 8/8 green with the operator's key (glm-5.2:cloud), alongside the pre-existing whole-app coding E2E.

Field evidence (2026-07-15): a real research request through the terminal face flowed search → snippet-rich source table → start_research card → confirm → sandboxed researcher (allowlist blocked a stackademic→medium redirect, as designed) → cited report delivered under workspace/<slug>/. Field finding for v46: the researcher fetches allowlist homepages, not the specific article URLs the search discovered — the card carries hosts only; report quality pays for it.

v46 (2026-07-15)

Research reads the articles; the Queen never replies with nothing (plan: plans/v46/README.md). Both fixes close the v45 field findings.

  • F1 — seed URLs into research runs. start_research gains optional seed_urls; they ride the deep-research template's new Sources: line and the researcher fetches THOSE URLs instead of each allowlist host's homepage (parse_sources, falling back to homepages for free-form dispatches and pre-v46 schedules). The allowlist stays the only egress boundary — an off-list seed is refused and recorded, pinned by test. The card now shows the exact reading list beside the egress hosts.
  • F2 — thinking-only turns surface the thinking. glm sometimes streams a terse reply entirely into the thinking channel; both turn paths now fall back to the thinking text when content is empty and no tools were called, emitting it as a live content delta. The v45 live-smoke workaround is reverted — visible text is the pin again.

Field evidence (2026-07-15): a live research run's card carried 8 article URLs; sources.json shows 6 fetched verbatim (reddit/x.com bot-block, recorded as unreachable), and the report body carries the actual free-threading HOWTO text instead of homepage boilerplate. Full external_app lane 10/10 with the real key (Docker test N/A — podman).

v47 (2026-07-15)

Operator-verb completion under the same spine (plan: plans/v47/README.md). The operator's prioritized backlog — every new verb a MUTATING carded chat tool through the existing confirm/audit flow, no side channels; workers still cannot touch git remotes; the channel confirm allow-list stays {dispatch_run, scheduled_result_ack} (pinned).

  • F1 — schedule CRUD honesty. delete_schedule + set_schedule_enabled over the existing store verbs.
  • F2 — MCP unregister. unregister_mcp_server + remove_mcp_server (learned scope rules kept, and the description says so).
  • F3 — open_pr. actions.open_pr_for_run = land_run's pending-or-new landing + the (now shared) PR assembly; the route behavior is unchanged.
  • F4 — read_url. Queen search ≠ Queen fetch: the card shows the exact URL and NOTHING is fetched until confirm; http(s) only, 64KiB/10k-char caps, html_to_text.
  • F5 — merge_pr. github.merge_pull_request (gh, honest failure). The ONLY base-branch advance, web-UI-confirmed only.
  • F6 — digest schedules. Caste 'digest' composes pending approvals / recent run states / schedule health / memory proposals at tick time, delivered like a note tick (chat + outbound push). Delivery tail for note/script/digest is one shared helper.
  • F7 — opt-in completion notify. notify_run_completion setting (default OFF) + carded toggle; completed runs get the v43-F4 one-line + push treatment when on.
  • F8 — Discord typing. Field report: replies "just appeared". _TypingPulse re-fires POST /channels/{id}/typing every ~8s around the gateway turn; injectable, swallowed failures, never blocks a reply.

Live evidence (2026-07-15, throwaway home + glm-5.2:cloud): digest schedule proposed → confirmed → ticked → "skep digest" in the chat; delete_schedule card emptied the schedule list; read_url card returned the actual whatsnew/3.13 page text (10k chars) only after confirm.

v48 (2026-07-16)

Field-test hardening: worker LLM reliability + deck honesty (plan: plans/v48/README.md; source: reports/field-test-2026-07-15.md, a Hermes agent end-to-end test of 15 surfaces — 13 passed, and the misses are these fixes). The headline: every LLM coding-plan run was failing on ollama.com's intermittent streaming 404, so skep's primary value proposition was down while the whole supervisor spine kept working as designed.

  • F1 — provider stream retry. ollama.com intermittently 404s streaming POST /api/chat requests that succeed on the next attempt; the worker's plan request rode the same no-retry chat_stream as the Queen. Both protocols now open the stream through _open_stream_lines — up to 3 attempts on transient statuses ({404, 408, 429, 500, 502, 503, 504}), linear backoff. The status check precedes any yielded line, so a retry can never replay partial output.
  • F2 — setup rejects a pasted key. --api-key-env with a literal API key corrupted profile.json (the worker skipped the llm-secret fallback and failed auth). run_personal_setup now requires an env-var-name shape and says the correction without echoing the secret.
  • F3 — deny resolves the run. All four deny paths route through store.resolve_approval, which resolved the approval row but left the run in pending_approval forever — doctor kept flagging denied runs as stale. Deny now transitions a gated run to rejected (unless another approval is still pending); denying a landing review of a completed run still refuses only the landing.
  • F4 — path-bound repos over HTTP. {name:path} on /api/repos/{name}/state|effective-policy: the ASGI server decodes %2F, so the single-segment converter could never match a /workon absolute path — the deck's /state and /policy 404ed for every workon workspace.
  • F5 — oneshot deck parity. --oneshot "/help" went to the model; /-input now runs the same client-side deck as the REPL and web composer, with proposed cards left pending (EOF = skip, never act).

Not fixed on purpose: personality adherence (the style preamble injection is correct; glm-5.2 following it weakly is a model property, revisit with an A/B observation). v49 seeds from the report: a worker-path LLM health check in doctor, and a worker dry-run mode.

v49 (2026-07-16)

The worker-path doctor + the last chat-surface gaps (plan: plans/v49/README.md; sources: the v48 ledger seeds and reports/real-user-simulation-2026-07-15.md, an 11/12 simulation that also field-confirmed v48 — its 7 rejected runs are F3 denies working).

  • F1 — doctor checks the WORKER provider path. The hardcoded available via supervisor stub becomes a real check: resolve the provider exactly as a run would (worker_provider_from_home, incl. the api_key_env trap and llm-secret fallback) and probe the endpoint with the worker's own credentials. The dry-run seed is folded here (sandbox was already a doctor check; the audit caste exercises the no-LLM pipeline; the missing signal was only this credential path).
  • F2 — allow_shell_command chat tool. "Add pytest to the allowlist" works from chat: union-of-one through the same guard as the presets, never a replace. Found while testing: a leading sudo/doas laundered every deny in the shared guard (sudo git push was allowlistable); privilege escalation is now rejected first, on every surface.
  • F3 — the confirm stream carries the card's result. Both verdict streams open with the same tool event free-executing tools emit; API consumers no longer watch a continuation with no outcome.
  • F4 — memory classes discoverable from chat. The list_memory_proposals description enumerates MEMORY_CLASSES itself and names the skep memory propose command.

v50 (2026-07-16)

The oneshot card cliff (plan: plans/v50/README.md; source: reports/black-box-user-test-2026-07-15.md — a pure chat user: reads are excellent, but "why can't I just say yes right here?").

  • F1 — oneshot resolves cards at a TTY. Oneshot sends through ChatRepl.send, the exact REPL resolution path with the house [y/n/s] prompt. Without a TTY, EOF reads as skip (never act) — cron and pipes keep the old contract. No --yes flag, deliberately: blanket pre-approval of an unseen card is a shadow permission system.
  • F2 — --continue / --chat compose with --oneshot. Real continuity: oneshot resolves its chat like the REPL (--chat wins, then --continue, else a fresh chat). The flagless cron default is unchanged.
  • F3 — the pending-card hint is actionable. The skipped-card message names the serve URL and the exact resume command instead of a URL-less "resolve it in the web UI".
  • F4 — ask on ambiguity. One system-prompt sentence: with more than one plausible project match, ask which one before dispatching.

Recorded, not fixed: the Queen occasionally re-asking for context already in the transcript is a glm-5.2 property; revisit on a model upgrade.

v51 (2026-07-16)

Closing the Hermes gap, governed (plan: plans/v51/README.md; source: the skep↔Hermes gap analysis + the 2026-07-16 REPL field-test seeds). The Queen becomes a more capable agent by getting GOVERNED versions of each Hermes capability — never raw tools.

  • F0 — /approve and /deny accept the pending-card id. The field-test bug: the pending-card hint printed an id no deck command accepted.
  • F1 — search_chats. FTS5 over the durable transcript (external-content table + triggers, one-time backfill); "what did we decide last week?" is now answerable.
  • F2 — Queen file reads (ADR 0023). read_file + search_files behind the filesystem scope: operator roots read in the turn, any other path cards on the exact resolved path, an explicit deny never cards. Writes deferred until observed demand.
  • F3 — run_code via the script caste (ADR 0024, contract 0.3.2). Inline code runs as a sandboxed worker: deny-all egress, file-not-string execution, output as the tool result, no path to a commit. Auto-runs exactly where dispatch_run would auto-dispatch.
  • F4 — skill management from chat. view free (grants visible); create/patch/delete carded; chat skills carry zero grants by construction.
  • F5 — batch_dispatch (ADR 0025). Up to 3 parallel runs, one card showing all, auto only when every member matches; each run is independently governed and audited.
  • F6 — the script-schedule watchdog. Reality check recorded: v44-F4 already shipped script schedules; the missing piece was silence on empty success (failures still post, named).
  • F7 — ask_clarifying_question. A turn-ending prompt: the question is a normal assistant message plus web-UI choice buttons; the next message answers it.

Cut on purpose: browser automation — ADR 0021's trigger has not fired; a gap analysis is not a failed inventoried action.

v52 (2026-07-17)

Operator-policy resolution: the Queen's standing policy (plan: plans/v52/README.md, reconciled from the v51-review draft; ADR 0026). Before v52, "Queen-side" meant "no policy applies" for network tools. The verified leak that shaped the design: the stored global document also feeds ops-worker bounds, so Queen-only rules need a document workers never read.

  • F1 — the operator-policy document. operator_policy_document in settings; default allows exactly keyless web search (net:search). The search action joins the network scope (ddgs rotates engines — no domain pattern could honestly govern it; the v41-F3 email precedent).
  • F2 — resolve_operator_policy. Composes the global document with the operator overlay via the native resolve(base, overlays); deny wins ties across both; per-call load (the draft's cache holder was dropped — the house pattern is per-call policy consults).
  • F3 — the Queen's scoped tools go through it. File reads keep their v51-F2 semantics exactly (empty overlay ≡ global document) and gain operator-document rules; search_web runs only on an allow, named in the result; read_url stays card-gated with audit-only domain attribution (Option A — the card is the human gate).
  • F4 — set_operator_policy. Carded edits bounded to the scopes the Queen consults; allows cannot reach into composed deny space; denies that would strand a learned rule fail a dry-run composition at write time.
  • F5 — decided_by everywhere. Every scoped Queen tool result names the rule that admitted it; the transcript is the audit record.

v53 (2026-07-17)

The Queen learns: skills from conversation, memory in chat, identity, voice, and cron chaining (plan: plans/v53/README.md — review-corrected before implementation; sources: the 9-item Hermes-vs-skep comparison and the operator's priorities; ADRs 0027–0031). Six review corrections were applied to the draft plan first: the curator surfaces instead of archiving, the observer is opt-in and heuristic-first, the persona is capped and bridge-labeled, the per-schedule model field was cut (YAGNI), the memory label reuses the context-NOT-authority phrasing, and the voice privacy claims were rewritten (edge-tts is Microsoft CLOUD, not local; Chrome STT is Google-cloud-backed).

  • F2 — memory in every chat turn (ADR 0027). Approved global memory_items ride the system prompt: class-prioritized, ~2k-token cap, context-NOT-authority label. The Queen is the same person across chats.
  • F4 — persona.md (ADR 0028). One capped identity file leads the prompt, always followed by the rules-win bridge line; carded set_persona + /persona in both decks.
  • F3 — session browse. list_chats, get_chat_messages (paginated, truncated), chat_id-scoped search_chats.
  • F7 — the skill index (ADR 0027). Registry templates, names + one line each, capped; full recipes load on demand via view_skill.
  • F1 — conversation skills (ADR 0029). Opt-in heuristic observer on the ticker proposes DRAFTS from multi-tool turns; skill approve admits conversation drafts without the (meaningless) worker test; the curator surfaces stale drafts in the digest and never acts.
  • F5 — cron context chaining (ADR 0030). Schedule B reads A's last output as labeled context (stdin for scripts); acyclic, depth ≤ 3, validated at creation; synchronous castes source, task castes consume.
  • F6 — voice (ADR 0031). Web-first mic + spoken replies (honest cloud tooltips); config-gated server TTS (default none; piper local, edge/openai labeled cloud) with Discord voice-message delivery; messenger STT deferred with a named trigger.

v54 (2026-07-17)

Confirmation cards grow up: auto-deny, verdicts, plain English — and one PR per topic (plan: plans/v54/README.md — review-corrected before implementation; source: the 2026-07-17 field-test screenshots and the operator's words; ADRs 0032–0034). Plan corrections first: ADRs renumbered to 0032–0034, duplicated sections removed, stale anchors re-pinned, F1's settings surface completed, F3's channel change cut (wrong renderer), F4 re-scoped onto the v24-F1 append mechanism.

  • F1 — card auto-deny on timeout (ADR 0032). A proposed card older than card_timeout_seconds (default 300; 0 disables; full policy surface) is DENIED by a ticker sweep — never confirmed: the model never holds the trigger. Transcript + channel push like a manual deny; a manual verdict racing the sweep always wins.
  • F3 — human-readable cards (ADR 0033). Cards show the tool's plain-English spec description and labeled key-value args instead of a raw name + raw JSON, on the live event, the replay, and the command deck alike. Derived, never stored.
  • F2 — verdicts instead of dimmed buttons. Resolved cards hide the button row and show ✓ Approved / ✗ Denied (✓ Confirmed / ✗ Canceled); a failed verdict call leaves the card pending with buttons back.
  • F4 — multi-run PR grouping (ADR 0034). open_pr with task_ids
    • title lands related same-repo runs as commits on one skep/<slug> branch and opens ONE PR carrying every run's evidence. Presentation, not governance; the system prompt teaches the Queen when to group.

v55 (2026-07-18)

The stale clone: repo freshness, boundary teaching, policy copy — and the chat stops going blank (plan: plans/v55/README.md; source: the 2026-07-17/18 field test — branches pushed to GitHub after registration were invisible, and the Queen recommended two impossible fixes (allowlist git fetch, a schedule-script sandbox escape) while missing register_repo; ADRs 0035–0036).

  • F1 — refresh_repo (ADR 0035). The supervisor finally mans the remote_git_managed_by_supervisor station: git fetch --prune + fast-forward of the default branch on a managed clone — mirroring upstream, never landing work. Carded chat tool + HTTP route, honest report (updated refs, behind counts, or why it refused).
  • F2 — dispatch auto-fetch + origin/<ref> fallback (ADR 0035). Runs against registered repos fetch first (offline-tolerant, managed clones only), and a branch that exists only as origin/<name> is now dispatchable — worktree add --detach does no remote DWIM, the hidden second half of the field failure.
  • F3 — boundary teaching. allow_shell_command names every forbidden git verb (fetch/pull were missing — the exact hole); register_repo is THE clone path; the system prompt carries the operator's checklist: registered? → on latest? → dispatch with ref.
  • F4 — copy_project_policy (ADR 0036). "Govern this project like that one" in one card: copies only the policy overlay, keeps the target's identity, phase, pack, and bindings.
  • F5 — repo_state sees the remote. remote_branches, last_fetched, behind_origin — "is it on the latest code?" is one read tool away; the unknown-ref error teaches refresh_repo.
  • F6 — policy preflight. Before dispatching, the Queen compares the task's needs with effective_policy and says "not possible under the current policy" + proposes the fix card — never dispatches into a known gate.
  • F7 — the chat narrates its silent gaps. A pulsing .chat-working line ("Ran repo_state — thinking…") fills the blank stretch between a tool result and the next model token; client-side only.

v56 (2026-07-18)

Per-chat context that fits, approvals that arrive (plan: plans/v56/README.md; source: operator asks after v55 — "fix the context on per chat", "sometimes approval don't hit the chat; stale somewhere" — grounded in two code audits; ADRs 0037–0038). The audits found the Queen resending the entire transcript every round into a window ollama silently truncated (no num_ctx, ~14k-token fixed floor, fictional meter), and gated runs notifying nobody.

  • F1 — the window is explicit (ADR 0037). llm_num_ctx (default 16384) rides every ollama call as options.num_ctx; openai-compat servers manage their own.
  • F2 — bounded replay + rolling compaction (ADR 0037). The store keeps the full transcript forever; the model gets a budgeted slice — prior-turn tool results capped with an honest marker, overflow folded into a deterministic per-chat digest riding the system prompt.
  • F3 — the meter tells the truth. Chat detail carries the context the NEXT turn will send (same math as the replay); the composer renders it and stops guessing.
  • F4 — chats bind to their project. Dispatch/workon stamp chats.project_id; that project's scoped memory finally rides the prompt beside the global items.
  • F5 — gated runs announce themselves (ADR 0038). pending_approval lands one transcript line + channel push naming the reason and /approve <review_id>; get_run guidance says WAITING ON THE OPERATOR instead of leaving the approvals array to be noticed.
  • F6 — the badge poll refreshes what it counts (ADR 0038). The approvals list, Home panel, and card-locked composers re-render within one 5s poll cycle of the truth changing — including cards resolved in another tab or by the auto-deny sweep.
  • F7 — the status stream stops missing fast transitions (ADR 0038). The tracked set re-derives every iteration with a grace window; runs gating faster than the subscribe still report, and the v53-era approvals-test flake dies at the root.

v57 (2026-07-18)

The complete git surface: branches, PRs, worktrees (plan: plans/v57/README.md; source: the operator's ask — "create all the tools regarding the git / pr / merge and all we gonna need to work with git and worktrees"; ADR 0039). Rulebook: reads free, mutations carded, remote ops on operator credentials only, no force flags anywhere, workers untouched.

  • F1 git_log / F2 git_diff — history of any ref and a capped, honestly-truncated diff (default <default>...HEAD) so a landing branch is reviewable from chat.
  • F3 list_worktrees — git worktrees joined with run states: "what is skep physically working on right now."
  • F4 list_prs — the PR queue via gh on operator credentials, honest failure without gh/auth.
  • F5 create_branch / F6 delete_branch / F7 push_branch — the carded branch lifecycle: create refuses existing names, delete refuses the default branch and unmerged work (safe form only), push refuses the default branch and never forces.
  • F8 unregister_repo — chat parity with the HTTP delete, plus the in-flight-run guard both now share.

v58 (2026-07-18)

close_pr — the un-merge verb (source: the operator's ask — "create the delete branch and delete pr"; delete_branch already landed in v57-F6, and the v57 ledger had deferred close_pr until the first field test that wanted it).

  • F1 close_pr — gh pr close on operator credentials, carded like every mutation. Reversible by design: the branch and commits stay (optional delete_branch=true sweeps the branch via gh), a closed PR reopens on GitHub — so it rides the standard card, same tier as delete_branch. No ADR: no new rule, just the existing card law.
  • F2 preflight waits for the verdict — the checklist's policy preflight now ends "propose the fix BEFORE any run, then wait for that card's verdict"; the day's field data showed a clean auto-dispatch stalling on an unannounced mid-run shell gate.
  • F3 big asks decompose — each dispatch_run carries ONE step a worker can finish and verify alone; dispatch → get_run → next.
  • F4 provider retry — chat_stream_with_retry: transient failures (connection lost, timeout, 5xx/429) get 3 attempts; 4xx fails fast; a stream that already yielded never restarts (half-replies are kept, the error stays honest). Every engine provider call rides the seam — a source pin enforces it.
  • F5 anti-confabulation — state reports (repos, runs, approvals, schedules, history) require a tool result from the conversation; empty results are reported as "nothing found"; identifiers are never invented. Field case: a seven-run history confabulated for an unregistered repo.
  • F6 the question always rides — current-turn tool results cap at 8000 chars (honest marker); the newest user message is pinned into the replay unconditionally. Field case: a ~50KB list_runs result evicted the question and the model answered nonsense.
  • F7 repo_state 404s for ghosts — a name resolving to a nonexistent path gets a 404 with the register_repo/workon teach instead of empty repo state.

v59 (2026-07-18)

First-boot field test: lost landings, silent failures, weak-model workers (source: fresh-machine field test — three verified docs patches finished invisible and unlanded, four runs died on provider flakes, the Queen doom-looped over identical reads and invented paths; plan plans/v59/README.md carries the full reconstruction).

  • F1 run list shows landing state — applied_branch + unlanded_patch on every listed run, plus list-level guidance naming land_run when finished work is not on any branch yet.
  • F2 unlanded patch notifies — a completed run whose patch has not landed always sends one line (+ outbound push) naming land_run and the file count; patchless completions stay opt-in.
  • F3 failure reasons travel — the failed transition row carries the envelope's verification details, and the chat notification falls back to them; "no detail recorded" no longer hides a real error.
  • F4 worker transport retries — a dropped/reset provider connection retries up to twice with backoff; every attempted call counts in provider_calls.
  • F5 plan repair + verify injection — three repair rounds for invalid plan JSON (repair prompt carries a minimal valid example); a file-writing plan that forgot verification gets a default read-only listing injected instead of failing (G10 re-verification still governs; resumed checkpoints refuse synthesized steps).
  • F6 provider health probes run — the serve ticker probes provider health on an interval (the v14 checks finally have a caller); routing distinguishes "never probed" from "probed and failing".
  • F7 unchanged-repeat breaker — an identical read call returning an identical result gets a nudge; two ignored nudges force a text answer. Changed results never nudge (polling stays legitimate).
  • F8 task-id prefix resolution — require_run resolves the chat's own truncated id rendering (unique >=8-char prefix); ambiguous prefixes 409 naming candidates.
  • F9 no cards for ghost paths — a nonexistent path outside the operator roots fails fast with no confirmation card; deny payloads carry the specifics so the model corrects course.
  • F10 restart recovery — serve startup reaps runs stranded by a supervisor death: valid late-deposited envelopes ingest through the standard path with G10 re-verification, the rest become an honest worker_crashed(supervisor_restart); the dispatching chat hears either way.

v60 (2026-07-18, F1)

The confirm-stream flicker (source: same-evening field test — an approved card's continuation streamed while the v56-F6 badge poll saw "no proposed cards" and re-rendered the whole view; the model's follow-up card landed in detached DOM and auto-denied unseen).

  • F1 poll defers to the live stream — a module-level chatStreamActive flag, set for the duration of every chat stream (message or verdict) and cleared in its finally; the poll's card-unlock branch skips while it is up. The stream already reconciles the composer itself. Cards resolved from a second tab, the deck, or the auto-deny sweep still refresh the view — idle-only.
  • F2 remote-base precheck (2026-07-19) — open_pr probes git ls-remote --heads origin <base> before any side effect; an empty GitHub repo gets a one-line teach (push main once yourself — skep never pushes a default branch) instead of a pushed branch followed by GraphQL soup.
  • F3 patch-less group members skip with a note (2026-07-19) — a grouped open_pr lands every member with a patch and names the rest in skipped_no_patch instead of failing the whole approved card; an all-patch-less group fails at once naming every member.

v61 (2026-07-19, F1)

The unroutable auto-dispatch (source: store forensics on the 2026-07-18 docs field test — the three silent patches v59-F2 was built for were auto-dispatched, so no chat_actions row existed and chat_for_task could not route their notifications; the fix as shipped would still have been silent for its own motivating case).

  • F1 auto-allowed mutations record their action row, born resolved — record_resolved_chat_action inserts the row already confirmed (resolved_at set, decided_by naming the allowing rule); the chat stream's auto-allow branch calls it with the execution payload. chat_for_task now routes auto-dispatched runs, so the v59-F2 unlanded-patch call-to-action, the v59-F3 failure lines, and the v56-F7 status stream reach the dispatching chat. No transient proposed state: the auto-deny sweep and the badge poll never see a phantom card, and the transcript replay renders only proposed rows as cards.

v62 (2026-07-19, F1–F3)

The silent turn (source: same-morning field test — three prompts answered with "Let me pull the data…" + tools and then nothing; the v59-F7 off-ramp fired but its terminal branches persisted no message, and the only error signal was a transient toast).

  • F1 no turn ends silently — a provider drop with nothing collected persists "the provider dropped before any reply arrived — the tool results above stand"; the forced-summary pass keeps its text when the model attempts another tool call (previously discarded) and persists a cap line when nothing arrived at all. Confirm continuations inherit via turn_events.
  • F2 the forced-final pass carries an instruction — one trailing system message: summarize in one or two short lines, name each run's state (done / failed / still pending), no promises.
  • F3 inline think tags are stripped at aggregation — spans (including stray closers and unclosed openers) move to the thinking channel instead of masquerading as the reply.

v63 (2026-07-19→20, F1–F4)

The second smoke test (source: two field tests 2026-07-19 on two stores — the Linux taskmate build whose verify hit the sandbox wall, and a macOS end-to-end landing that exposed the oneshot approval regress and the sweep's "timed out" lie; the 2026-07-18 docs-run deaths re-anchored from the audit trail).

  • /approve finds its card in any chat — the pending-card id resolves cross-chat (flagless oneshot mints a fresh chat, so the hint's id was never in "this" one), and an operator-typed /approve|/deny with an explicit id auto-confirms its own command card instead of minting a card no EOF stdin can answer. Scripted approval completes; unnamed cards still skip on EOF.
  • Resolution elsewhere reconciles the cards — resolve_approval supersedes the proposed cards asking the question it just answered, with an honest "resolved elsewhere: approved by …, applied on …" tool row; the auto-deny sweep records superseded, never "timed out", when the underlying review or run already fell.
  • A string verify.argv verifies — shlex-split like shell.run's command string; unusable strings on file-writing plans fall to the v59-F5 default listing, and G10 re-verification still governs what "verified" means.
  • The planner prompt states the sandbox walls — workspace-only writes, HOME not writable, allowlisted network, verify within them; permission-shaped verify failures feed the same teach into the v19-F7 recovery replan.

v64 (2026-07-20, F1–F4)

The verify step is the weak link (source: second smoke test 2026-07-20 — two runs wrote correct patches and died on their own verify commands: pytest in a pytest-less sandbox, a -c one-liner that cannot parse; the Queen burned four approval rounds granting verify commands that never gate).

  • A failed verify earns the one recovery replan — same _PlanRecoverable as a failed work step, both plan paths; the model may fix the verify command or the code; a second failure is terminal; G10 still governs "verified".
  • The Queen learns verify commands never gate — the allow_shell_command description and effective_policy both teach the shell_verify fast-path; the description's example is no longer the one command that never needs it.
  • The too-broad rejection teaches the acceptable shape — narrow with arguments; bare interpreters and -c/-lc forms can never be allowlisted; verify commands never need the allowlist.
  • The prompt states the toolchain — only the system toolchain exists in the sandbox; verify with the stdlib, prefer a script file over a -c one-liner; missing-module stderr aims the recovery replan at the toolchain.

v65 (2026-07-20, F1–F2)

Re-verify tells the truth about patch-less runs (source: operator field test — a no-change audit run wore the lying-worker shape: "unavailable / not confirmed / no patch artifact", plus a "re-ran" that never ran; 58 of 94 reverification rows ever recorded were this).

  • not_applicable joins the reverify vocabulary — a run that claimed no changed files has nothing to re-verify (benign); claimed changes WITHOUT a patch artifact gets a louder detail; an absent result envelope keeps today's shape. confirmed stays 0 everywhere.
  • The surfaces stop crying wolf — "re-ran" only when exit codes exist; the approve-surface warning quotes what actually happened instead of pointing at a ghost patch; DO-NOT-TRUST keeps its teeth for every genuinely unconfirmed state.

v66 (2026-07-20, F1–F3)

Approvals reach Discord (source: operator report — a Discord thread locked behind web-UI round-trips for every read_url card).

  • The confirm gate admits skep's own threads — a session binding to the card's own chat is the admission auto_thread ids can never get from the static allowlist; foreign bindings and strangers still fail closed.
  • read_url and start_research become channel-confirmable — the v16 line holds: shell, policy, landing, git stay web-UI-only.
  • The web-UI-only card carries its link — the Discord embed and the pending-card lock message both name the web UI URL; the lock message offers the buttons too.

v67 (2026-07-20, F1–F7)

The backlog lands, round one (source: docs/invariants.md Part II — the refinement backlog; this round is every prompt-, deck-, or message-shaped item, with the architecture-scale items staged for their own designs).

  • SKEP.md repo briefing — a repo-authored briefing rides every worker planning prompt ahead of the snapshot, authoritative for how to verify in that repo.
  • The ask-list — multi-ask prompts become a numbered list the Queen tracks to done/blocked; a dropped ask is visible, not silent.
  • /btw — a read-only side question in both decks: no cards, no mutations, runs beside a pending confirmation.
  • Denies that teach — path, network, and plugin denies name the acceptable shape instead of a bare no.
  • Descriptions with when-NOT — the six high-traffic card classes teach when not to reach for them and their one known trap.
  • Acceptance-check-first — dispatches state 'verify by …' up front, in the checklist, the tool description, and the seeded maintenance templates.
  • Repair boundaries pinned — malformed model output feeds back at both boundaries; nothing hard-fails on the first bad shape.

v68 (2026-07-20, F1–F2)

The hollow pass (source: the SKEP.md briefing A/B smoke test — the briefing demonstrably fixed verify choice; its first attempt exposed a run that read two files, wrote nothing, and passed).

  • A hollow plan can never pass — a non-empty all-reads tool plan repairs or fails honestly; completed+passed with changed_files=[] on a write task is no longer a reachable outcome.
  • check.py is the canonical scratch check — overwritten per task; the repo briefing decides whether it stays.

v69 (2026-07-20, F1-F8)

The loop (source: ADR 0040 and the invariants backlog — reactive execution, steering, and the honest corrections).

  • The react protocol and executor — an opt-in bounded act-observe loop: one action per turn through the full capability gate, denies as teaching observations, budgets binding, hollow traces failing, the same verification brain and G10 as the plan path, and approval gates that suspend to a conversation checkpoint and resume in place.
  • Mid-run steering — /steer drops operator input into a running react loop as its next observation; input never authority.
  • Crash evidence survives — per-round checkpoints salvaged by crash ingest; the audit trail shows where a dead loop stopped.
  • The record corrected itself — R6 compaction was already built (v56); R9's foundation already exists; marked, not rebuilt.

v70 (2026-07-20/21, F1–F8)

The stalled turn and the readable schedule (source: field test 2026-07-20, chat 73d93f04 — reconstructed from the store alone; field addendum 2026-07-21, chat 4121496a — the morning-ritual hunt).

  • A stall is not an answer — a round with no user-facing text and no tool call gets one nudge, then the forced text-only pass; a turn can no longer end on an unexecuted plan.
  • The serve log exists — skep serve writes <home>/serve.log (rotating) regardless of the launch shell; the access token stays stdout-only.
  • worker_protocol reaches dispatch — react is a project-policy choice (fail-closed validation), with skep run --planning-protocol as the per-run override; ADR 0040's loop closes.
  • The schedule's recipe is readable — list_schedules shows caste and (capped) instructions; the Queen stops hunting old chats for a script the store already holds.
  • run_schedule_now — one carded verb makes an enabled schedule due; the ticker dispatches it on its next tick with the schedule's own delivery and health tracking. Run-now moves WHEN, never HOW.
  • Read repeats survive the turn boundary — seen_reads is seeded from the transcript tail, so "yes do it" can no longer re-arm the same search cycle as fresh diligence; the v59-F7 nudge and off-ramp fire on the first cross-turn repeat.
  • The plan-failure record names its reason — the summary carries the final validation error (or the hollow teach) everywhere only the summary shows; 'LLM coding plan failed.' alone blamed nothing.
  • The prompt states the isolation boundary — every run has a private /tmp and filesystem; content reaches a worker inline in the dispatch instructions or through the repo, never via /tmp paths.

v71 (2026-07-20, F1–F6)

The forge and the daily companion (source: the Stage F gap analysis — docs/field-tests/hermes-replacement.md + the operator's gap list; motive: skep authors its own MCP tools and keeps them).

  • The forge — skep authors, lands, trials, and registers its own MCP tool servers: a coding run writes one stdlib-only Python file in <skep home>/forge; the patch lands via normal approval; promote_tool runs a sandboxed no-network trial (tools/list + a zero-argument self_test) and, on the confirmed card, installs and registers it as an ordinary stdio MCP server. Suspension deregisters; rollback is terminal. The v17 plugin lifecycle finally has its consumer.
  • The browser is an MCP server — scope browse for e.g. npx @playwright/mcp: page-state reads flow, every page act (navigation included) cards until allowed; doctor warns when the launcher is missing. See docs/browser.md.
  • await_runs — dispatch → await → synthesize: block on up to 5 runs and collect each run's view; timeouts report live snapshots honestly.
  • The Obsidian vault bridge — carded sync_notes writes notes as markdown into <vault>/skep/; hand-edited files are never overwritten (conflicts land as .skep-conflict.md siblings).
  • The observation memory class — curator-written without a proposal because it grants nothing and expires (14-day TTL, swept on the tick with an honest 'expired' event); durable memory keeps its human gate.
  • run_code latency measured — p50 0.20s over 20 real sandboxed dispatches; the "heavyweight" gap claim closed as a no-op. Desktop / computer use stays a recorded deferral until Stage F evidence exists.

v72 (2026-07-20/21, F1–F8)

The daily driver (source: the operator's all-day-assistant gap list; seed evidence in docs/competitive-analysis.md — "it's a content gap, not a design gap").

  • The brain dial — the assistant LLM grows a third protocol, anthropic (Messages API, translated at the client boundary), and a carded set_assistant_model verb (saved default or one chat). Default workers inherit the saved config, so one dial upgrades both brains. See docs/brain.md.
  • The document caste is real — drafts and summaries as deliverables: .artifacts/draft.md, nothing ever lands, acceptance from the task's Must include: line, workspace grounding via Files:.
  • Push, don't poll — finished (R5) — scheduled-run terminals, schedule auto-disables, G10 re-verify disagreements, and provider health transitions all reach the operator unasked; the deliberately-quiet list is on the record.
  • The observation harvest — v71's observation lane finally has feeders: observation-phrased chat lines and run terminals become expiring, grant-free memory on the tick; the digest remembers the week.
  • First-party mail + calendar MCP servers — stdlib-only, forge- shaped, zero permission logic: email reads flow, sending always cards; calendar is read-only ICS. See docs/assistant-tools.md.
  • The pocket story — docs/mobile.md says out loud what was already true: the messenger apps are the mobile face; four pinned confirmable action classes, everything else web-UI with the URL in the embed.
  • allow_fetch_domain — a carded standing grant reads one exact host without per-URL cards; redirects re-decide every hop; deny always wins. One-turn article summaries on granted domains.
  • Same-worktree crash resume (R8 closed) — a crash that left a checkpoint keeps its worktree, says so in the crash push, and the carded resume_run continues in place from the cursor (or honestly replays from step 0 when the tree is gone).

v73 (2026-07-21, F1–F11)

The field answers back (source: the v72 field test on a frontier-class Queen + the operator's four-model morning — both reports in docs/field-tests/; every remaining failure was infrastructure, not model).

  • Reads fit their own replay cap — list_schedules is compact by default with a name= detail step; oversized JSON tool results are chopped at a valid-JSON boundary with a marker that names how to narrow; a fixture audit pins the big reads under the cap.
  • The operator's clock — the pinned prompt carries local time + UTC offset each turn; "what ran at 5:20 am" is answerable on any model.
  • The wedged chat heals — a provider 4xx gets ONE halved retry; a success records the chat's provider ceiling and compaction holds the chat under it from then on. The shrink is on the transcript; the second-failure line teaches.
  • /resume joins the deck — model-free crash recovery on the web deck, the REPL, and /help; the crash push names it.
  • list_repos sees workon dirs — clones and workon-bound workspaces, labeled by source; deleted dirs drop out.
  • Final-pass guards — an echoed internal instruction is replaced by the honest line; text-shaped tool-call JSON becomes a teaching line offering the model dial; neither executes anything.
  • Never card into a missing path — dispatch_run and workon share one resolver: a missing directory is refused before any card, with one story.
  • The literal Must include: example — shown in the dispatch manual; the document worker names prose-only acceptance honestly.
  • The react fate line — "continuing in place from the saved round", never "cursor None".
  • R9 closed (Part II complete) — the composition record is pinned: three workers, three worktrees, three approvals, main never advancing. Every 2026-survey refinement is now landed or closed.

v74 (2026-07-21, F1–F5)

The window and the index (source: the operator's context-meter reading — a brand-new chat at ~96% context used at its first message. Measured: 54,079-char tool specs + ~6,000-char prompt against a 16,384-token default window = a 92% fixed floor before the operator types a word).

  • The num_ctx dial reaches the settings UI — the API had carried it since v56-F1; the settings card now has the field (empty = auto), the note names the budget math (chars ≈ tokens x 4, all protocols) and the wire truth (ollama-only).
  • Auto-size from the live model — config save and set_assistant_model probe ollama's /api/show (architecture-prefixed .context_length), cache per model, and resolve override → detected (capped at 65,536 — the replay budget is a cost dial, and the operator's explicit override is uncapped) → default. Detection failure never breaks a save; num_ctx_source says which rule is in effect. A chat pinned to a bigger model budgets like one.
  • The tool index — the 54KB of tool schemas stopped riding every round. Indexed delivery (default) sends a categorized one-line index (~11KB, generated from the registry at import time — it cannot drift), full schemas for the 11-tool core set plus this chat's described-active tools, and describe_tools(names) for on-demand schemas (persisted on chats.active_tools_json). Authority does not move: the executor dispatches on the name, an indexed-but-inactive read executes when called, mutations still card, deny space stays unreachable. The unknown-tool error teaches; llm_tool_delivery: full is the one-flip escape hatch. Fresh-chat floor: ~60KB → ~24KB (pinned ≤ 25KB); with the auto window, first-message load ~96% → ~9%.
  • The meter splits the floor from the conversation — context_view returns the floor in parts (tool surface, prompt, digest) plus the window source; the composer ring renders floor (amber) vs conversation (green), and hovering opens a breakdown popover: % used, a filled/empty bar, exact token numbers, free space.
  • One "You can reach:" roof — the F3 tool index, the v53-F7 skill index, and the registered MCP server ids fold into a single prompt section, each naming its detail verb (describe_tools / view_skill / list_mcp_tools). Live registries feed it: a new tool, skill, or server appears with zero prompt edits.
  • The local usage tally (F6, operator ask) — ollama.com exposes NO account usage API (ollama/ollama#15663), so skep counts its own requests at the engine choke point (ollama's final-chunk token counts) into llm_usage (8-day retention) and serves rolling 5h/7d windows at /api/llm/usage. The context popover and the settings card show the tally, labeled as a local count with ollama.com/settings named as the authoritative meter.

v75 (2026-07-21, F1–F8)

The shell holds (source: the 2026-07-21 design review + build spec, corrected by the upgrade plan's 12 corrections and ground-truthed at 993e315; direction: Option A "Refine the Hive" + the command palette).

  • Foundation — six additive tokens (clay --accent-2, card/raised elevation, fast/normal motion, --radius-xl); the rail groups into daily / manage / configure; shared relativeTime, buildTabBar (panels persist across switches, render-once), buildFilterBar, buildSparkline. Every pre-v75 token and pinned anchor survives.
  • codeChrome deleted — the two always-disabled composer pills were a broken promise (I9); the real code-context status row stays. The structure pin moved with the change, re-pinned to absence (C4).
  • Settings → five tabs — Assistant / Worker / Channels / Webhooks / Repos, lazy-rendered one tab at a time, with per-session tab memory and a Channels status summary that claims only enabled / live / secret_configured (I8). The v74 num_ctx dial rides Assistant unchanged.
  • Runs → cards — filter tabs with live counts; run cards keep the searchable class, superseded dimming (v19-F8), verify badges, and the autonomy summary as a pill; the "All" view groups by state with the unclaimed remainder under Other — grouped, never dropped (I8).
  • Policies → four sections — Execution defaults open; Security / Advanced / Auto-approval collapsed; every field carries a one-line help hint (I9); the shell-command editor is argv-safe (C8): one row per command as its exact JSON array, raw-JSON escape hatch, no whitespace splitting anywhere.
  • Run detail → timeline + tabs — a visual timeline (canonical path, failure tail, unmodeled states APPENDED in arrival order — C6); Events / Commands / Policy / Transitions as persistent tabbed panels (the live SSE log keeps streaming under a hidden tab; the raw transitions log stays reachable, I8); a copy-ID button.
  • Templates & Skills → two tabs — authored vs learned; template cards with a Use → #/assign?template= link (route regex tolerates the query; parsing ships v76-F4); the skill stepper renders ONLY the lifecycle skills.py produces (draft → tested → approved, rejected as the failure branch) — the spec's invented states refused (I8).
  • The ⌘K palette — the topbar hint stops lying (C3/I9): a real overlay with one entry per page + run-id jump; every entry is a location.hash navigation, and a region test pins the palette free of api(/streamSse( calls — it can never mutate (I5/I6).

v76 (2026-07-21, F1–F8)

The morning view (source: the second half of the 2026-07-21 design round, corrected plan C1–C12; the review's core complaint for these pages — "no narrative, no 'what happened while you were away'").

  • Home answers the morning question — an activity feed (runs + approvals merge, approvals stamped requested_at — C5), a next-3 schedule strip, a 20-run verify sparkline on the pass-rate tile, "Active schedules" replacing the total-runs tile, and a welcome-back banner that counts ONLY terminal runs since the last visit (I8) behind a 4h localStorage threshold.
  • The Queen tile — model + live dot in the topbar; liveness rides the existing poll, the hover names only sourced facts (window, num_ctx_source, tool delivery, 5h request tally — C10); hidden until its data arrives.
  • Projects stop being write-only — cards with phase badges (the four real phases) and a #/projects/:id detail page composing three existing endpoints client-side; the effective-policy JSON stays reachable on the page that owns it.
  • Assign guides — 3 steps (repo+instructions open, template optional, advanced collapsed with field-help), execution mode visible beside Dispatch (the review's KEEP), a form-echo preview line, and ?template= prefill closing the v75-F7 link contract (C9); unknown templates teach.
  • Approvals order themselves — priority sort (high→medium→low, oldest first within a tier), type filters via approvalKind, a requested_at waiting clock (urgent past 1h; visibility, never authority), and an empty state that points at review work.
  • Schedules read as countdowns — relative next-run (past = "overdue", absolute on hover), health banners only on actual failure (warn at 3 consecutive), inline disable at 5 through the EXISTING PATCH toggle, with the ticker's own auto-disable-at-5 named honestly.
  • Notes & Tasks grow up — markdown-rendered notes with #tag pills and a filter, checkbox tasks grouped Overdue → Due today → Upcoming → No due date → Done(collapsed), and the explicit run:<id> token linking runs (no bare-hex guessing — I8).
  • Memory shows its shape — class chips lockstep-pinned against the store's 7 MEMORY_CLASSES (the spec's invented classes refused), count+size, proposal age; the chat sidebar gains client-side search and localStorage pinning with a pinned-first section.

v77 (2026-07-21, F1–F5)

The terminal face: the CLI round (source: design review §5 / build spec §7, ground-truth-corrected — the CLI has carried the full command deck since v48-F5; this round completes it and gives the REPL honest eyes).

  • Confirm cards carry weight — boxed rendering on a TTY with ANSI-safe width math; args never truncated; NO_COLOR governs color, not structure; piped output stays byte-identical (the v50-F1 script contract).
  • The prompt answers "how full am I, on which model?" — model: … · ctx: NN% · you ›, threshold-colored (green <60, amber 60–79, red ≥80), reading the same context_view as the web meter; readline-safe via \001…\002; cached per model turn; a failed refresh falls back to the bare glyph.
  • The deck completes — /status (the banner, re-runnable), /model (effective model; with a name, cards set_assistant_model — scope chat by default), /exit, /replay; the web↔CLI parity pin re-pinned around an explicit CLI_ONLY set, each member documented by its web equivalent.
  • Tool calls read as threads — ▸ name + a deterministic result summary read off recorded JSON (✗ errors unmissable, ✓ counts, run ids), identical live and replayed; never model text.
  • Ids are handles — task ids OSC 8-link to their run page (full ids — operators copy them into /land //steer //resume); resuming a chat prints one summary line naming what was withheld and the command that shows it, instead of twenty messages of scroll.

v78 (2026-07-21, F1–F6)

The gateways grow up (source: design review §6 / build spec §8, C7-scoped into its own server-side plan; two review proposals rejected by name — channel-side landing authority in any spelling).

  • A volume dial per channel — notification_level (all/approvals/none) enforced once at the outbound choke point; it can only silence delivery, never allow anything, and the chat row + web UI record everything at every level; confirm cards are in-turn replies and never consult it.
  • States wear their color everywhere — one STATE_EMOJI map, prefixed at the source (run_terminal_text), inherited by the web transcript, all three channels, and the scheduler funnel.
  • Discord shows results with dignity — terminal pushes carry a color-coded embed (house palette) beside the honest text line, with the supervisor's summary, the re-verify verdict only when the store holds one, and a link to #/runs/<id>; a vanished run degrades to plain text.
  • /skep without a model turn — status and runs answer straight from the store; approve/deny are a third spelling of the existing button, through the same fail-closed gate (shell/policy/landing stay web-only); strangers get silence; registration is one idempotent bulk PUT whose 403 names the missing invite scope.
  • Telegram renders the Queen's markdown — bold, code, and fences in MarkdownV2 with everything else escaped; a rejected parse resends the same message plain — formatting never costs a message.
  • Slack stops burying the channel — pushes thread under the operator's latest message via the captured thread_ts; terminal runs arrive as rich blocks whose only button is a URL ("Open in web UI") — a link, not a verb.

v79 (2026-07-22, F1–F5)

The field-test five (source: chat-store forensics 2026-07-21 — 11 chats, 1,088 messages, 106 runs; the five failures ranked by operator pain, each traced to file:line before the plan was written).

  • Empty remotes stop eating days — registering an empty GitHub repo now pushes the synthesized baseline (create-only), and carded push_baseline repairs repos already in the trap; the PR error teaches the in-skep path.
  • Approvals are a ledger the Queen can read — the last 10 resolved verdicts ride list_approvals with who/when/where-landed, and runs expose their resume chain in both directions.
  • read_file follows the work — an explicit ref or an automatic fall-back to the project's landing branch; the miss error names the branches instead of lying "not a file".
  • Tokens are counted where they're spent — worker runs report real prompt/completion counts into task_usage; absent counts stay None.
  • Loops hit a wall — an identical read already nudged this turn is refused without executing; the turn ends in an answer, not a poll.

v80 (2026-07-22, F1–F2)

The Streamable HTTP MCP runner (source: I10 seed — the http transport had been config-only since v17; registered remote servers were dead rows).

  • Remote MCP servers are callable — runner_for_config speaks the MCP Streamable HTTP transport: session-aware JSON-RPC POSTs, JSON or SSE responses, honest MCPErrors for dead URLs and legacy /sse-only servers; the policy/card path is untouched.
  • The tool description tells the truth — "config-only in v1" is gone; the description names the endpoint shape instead.

v81 (2026-07-22, F1–F15)

The field-test fourteen (+1) (source: I10 seed — the 2026-07-22 dogfooding day; 15 findings reconstructed with file:line anchors, one was opt-in-by-design and needed no code).

  • Landing tells the truth and protects the right branch — the default-branch guard reads the repo's real default, not the checkout; a failed apply denies its approval with the reason; runs pin their base commit so stale lands are flagged before approval and named in the failure; a checked-out target refuses with the remedy.
  • The Queen picks landing branches from a menu — skep/<task_id> or the project's auto_apply_branch; invented names are rejected with the menu. PR surfaces read the persisted landing branch.
  • G10 alarms only on real risk — a patch-less run reads "nothing to re-verify", never NOT CONFIRMED.
  • run_code deliverables survive — script-written files are declared, delivered to ~/.skep/workspace/<slug>/, and named in the tool result.
  • Surface gaps closed — reopen_task, list_notes paging with honest totals, the dispatch deny lists registered repos, /repos and list_repos agree, /skills in both decks, --oneshot --yes for card-gated scripting.
  • Pending cards always appear — the web UI reconciles cards after a dropped stream and on the poll; verified in a real browser.
  • Global auto_approve is inert — per-project maintain is the only auto-apply ramp.

v82 (2026-07-22, F1)

The loopback guard (source: the stranded Air branch local/v70-F4-context-meter — the one salvageable idea after v74 superseded it).

  • A local daemon's window is the operator's call — loopback ollama is never probed or auto-matched; num_ctx there is pre-allocated KV-cache RAM, and the conservative default stands until the operator dials it. Remote detection, the anthropic floor, and the explicit override are unchanged.

v83 (2026-07-22, F1–F15)

Hermes parity, governed (source: the 2026-07-22 comparison — close the day-to-day gap, keep every wall).

  • All 27 Hermes tools have a skep disposition — direct read, granted lane, card, or governed equivalent; none direct-executes from the model's hand. read_url returns markdown with a granted-lane budget; run_code has a sandboxed 10s fast lane; run_shell/ start_process/stop_process/quick_edit/delegate_analysis/remember/ get_chat_context/setup_browser join the surface.
  • Prompt schedules — "every morning summarize yesterday" as a read-only, store-reads-only Queen turn (ADR 0042 names the unattended-injection surface it closes).
  • The shelf has books — 37 zero-grant seed skills load at startup (ADR 0043: operator copies win, deletes tombstone) and a shipped yt_transcript seed tool promotes through the forge's own trial+card.
  • The freeze — Stage F runs against v83; the hotfix line is dated before the outcome.

v84 (2026-07-22, F0–F8)

The phase-2 shelf, review-corrected (source: the v84 plan review — seven amendments folded in before execution; the freeze point moved to v84 on the record).

  • 39 new seeds (productivity, email, social, MLOps, ML models, creative) bring the shelf to 76 — every one zero-grant, parsing, and lockstep-checked against the tool surface.
  • Grant hygiene is law, not style — a shelf-wide test pins that seeds only name multi-token read-verb prefix grants; mutation verbs never appear in a grant; curl is never a write path.
  • Outbound content has a mechanism (ADR 0044) — posting/send prefixes are never-grantable at every persist lane; posts always run carded with the verbatim payload in the argv; pre-v84 grants swept.
  • The document toolchain is stated — documents/ocr extras plus an honest per-library presence block in the planning prompt; the tesseract probe is functional (A4).
  • hermes-import — memory/skills/sessions stage behind the existing gates with per-class batch review and visible [hermes-import] provenance in search; ~/.hermes is retirable.

v85 (2026-07-23, F1–F7)

The shelf points outward (source: the Pi comparison — two adoptions, operator-directed; supersedes v84's "v85 waits for Stage F" note).

  • Agent Skills standard — real-world frontmatter parses (quotes, block scalars, wrapped lines); skep skill shelf add ~/.claude/skills registers external shelves synced at serve start under the seed rules (zero-grant, tombstones, operator wins), provenance external.
  • The pack ladder (ADR 0045) — script-shipping packs are packages: they draft onto the v17 lifecycle (import-md --allow-script, or auto-draft on shelf sync) and reach the registry only through a parse-only trial plus a human action (skep skill promote / promote_skill_pack card). Suspension removes the registry skill (registered ⟺ active); rollback is terminal.
  • Grants become real — activation snapshots the pack and rewrites script grants onto .skep-skill/<id>/…; dispatch materializes the snapshot into the run workspace, so the granted argv and the file agree on every sandbox backend.
  • The fresh-chat floor pin re-measured 26KB → 26.5KB (two new tools).

v86 (2026-07-23, F1–F2)

Approval memory (source: operator request — "approve = session, approve always = always").

  • The session tier (ADR 0046) — a plain approve on a shell-gate card now persists the command for the serve session (session_allowed_shell_commands, merged read-side at the one _shell_allowlist_for choke point; cleared and logged at startup). Remote-git, dangerous, and outbound-content classes never persist — they stay approve-once. "Approve & remember" remains the only path to permanence, and the durable union writers cannot absorb session entries.

v87 (2026-07-23, F0–F8)

The 2026-07-23 field test (source: one day driving the youtube-summary skill through three Queen models; plan plans/v87/README.md). Two gate fixups rode ahead of the round: the fastlane escape test aimed at a sandbox-allowed temp root, and reconcile now reaps zombie children (kill(0) cannot tell a zombie from a live process — the row lied "running" forever).

  • F1 resolver — bare repo names resolve clone-slug → workon binding → host path; the daemon's CWD never participates (serve launched from the checkout turned "skep-workspace" into a nonexistent path while the binding sat unconsulted).
  • F2 gate cards in chat — a pending gate plants an actionable approve_review card in the dispatching chat (source='gate'): Approve rides the /approve verb, Deny denies the review (v48-F3), any other surface's resolution supersedes it (v63-F2), the timeout sweep skips it, and it never locks the composer.
  • F3 channel health — "never configured" stated in those words: skep channel status, configured/last_delivery/gateway fields on GET /api/channels, delivery-miss logging, gateway session breadcrumbs. (The field's "Discord doesn't work" was an unconfigured channel presenting as breakage.)
  • F4 verify before victory — get_run carries patch_digest (per-file counts + first added lines, capped, drops stated) for completed runs; the unlanded-patch notification names the changed files; success-shaped prose about an untouched deliverable draws ONE verify nudge (I2, Queen-side).
  • F5 fabrication is a failure — the worker prompt names invented content a FAILED run and requires verify to prove derivation; dispatch_run/POST /api/runs gain per-run protocol='react' for fetch-then-synthesize tasks (plan-mode plans before the data exists and can only fabricate); create_skill teaches the classification.
  • F6 env bootstrap — allow_env_bootstrap grants uv venv/uv pip install/python3 -m venv/python3 -m pip install in one card through the standard guards; the worker prompt states the host's actual Python toolchain (bare pip does not exist on macOS).
  • F7 the wait names itself — turn_status events ('thinking', 'running ') on the message stream; the web working-line adds a browser-side elapsed counter, the terminal prints a dim marker. await_runs kept its v71-F3 cap + honest partial unchanged.

v88 (2026-07-25, F1–F5)

A trace, not a field test (source: an operator-directed walk of dispatch → capability gate → verify → land, checked against docs/invariants.md Part I; plan plans/v88/README.md). The structural posture held — the git denies fire before the verify fast-path and before any allowlist or grant, the same prefixes can never be persisted as standing grants, sudo/doas is refused first because every deny below keys on argv[0], the Queen is bound to the worker's list (v83-F9), and landing always takes a fresh non-default branch. Two documented claims turned out stronger than their code, and two chat-UI complaints from the same session rode along.

  • F1 one sidebar row height — loose chat rows are direct children of the column-flex .chat-sidebar and shrank below content height once the list overflowed; pinned and terminal/discord-grouped rows sit a level deeper and did not. flex: none; height: 32px.
  • F2 the sidebar collapses — a toggle in the existing .chat-toolbar flips .sidebar-hidden on .chat-layout (the same display:none the mobile breakpoint used), persisted in localStorage like the v76-F8 pins (I11).
  • F3 await_runs can say a run failed — the failed-run coaching existed but was wired only into get_run, while await_runs (the tool the Queen blocks in) hand-rolled two branches covering no terminal failure. A dead run arrived as a bare settled: true, so the Queen reported nothing and retried nothing. Settled runs now carry verification_details and the shared per-run guidance; the duplicated pending_approval string is deleted (I8, I9). Automatic re-dispatch was deliberately not added — that is a policy decision, and the actual defect was that nothing said the run had died.
  • F4 the project pins what verification means (I2) — G10 re-ran the command the worker nominated, so a worker verifying with true earned confirmed=True for a broken patch and, under a require_reverified rule, an automatic landing. A verify_command project-policy key now outranks the worker's nomination, resolved inside run_task so the resume and skill-test paths cannot silently downgrade G10, re-resolved on crash recovery, and the re-verification detail always names which command was re-run (I8). Unpinned projects keep the old fallback.
  • F5 I4 says what the code guarantees — narrowed to remotes and branch-switching, which are absolute; staging and committing are denied through shell.run but grantable through the explicit-intent git.stage/git.commit capability path, and that is safe because the worktree is disposable and the patch diffs against the startup baseline — not because it is absolute. I1 is what makes a worker-side commit consequence-free.

v89 (2026-07-25, F1)

A race the v88 gate caught (source: test_parallel.py failing 1 run in 3 during the v88 gate, never in isolation; plan plans/v89/README.md). Pre-existing, not a v88 regression — v88 touched no worktree, threading or sweep code, though its extra store read in run_task shifted thread timing enough to widen an already-live window.

  • F1 the orphan sweep and worktree creation are mutually exclusive — run_task takes its keep-set snapshot before it mints a task id and before _ACTIVE registers the shield, so a parallel sibling's sweep could walk the directory, find a worktree whose git worktree add had printed "Preparing worktree" but not yet checked out, and delete it — killing the run with "fatal: this operation must be run in a work tree". _ActiveWorktrees locked each operation, but snapshot → walk → remove and register → create are sequences, and per-operation locking cannot exclude one sequence from another. A TREE_LOCK in worktree.py is now held across each whole sequence — including the keep-set snapshot, which reopens the window if taken outside it — at all three sweep sites, at the register+create pair, and in reverify.py's creator.

No authority changes: this is a lock around existing filesystem bookkeeping. Keep-set semantics are untouched, so preserved pending-gate worktrees (I1's resume path) and salvaged crash checkpoints (v72-F8) behave exactly as before.

v90 (2026-07-25, F1–F5)

Three operator asks and one decision (plan plans/v90/README.md): no way to run Claude Code as a worker; the approval card said the same thing three ways and never named the risk; an approval already given was asked for again. Plus the operator's answer to v88-F4's open question — phase-targeted defaults rather than global.

  • F2 the card says one thing per line — a server-side summary: headline (the argv, URL or branch verbatim), purpose (the tool description's first sentence), and risk — or no risk line at all, because an invented risk is as bad as a buried one. The risk text is drawn from the guard classes the policy engine actually consults (outbound content/ADR 0044, privilege escalation, ops-mutating) plus membership classes for publishing, landing, policy and destructive verbs. The model-facing description and the raw argument dump move behind a details disclosure.
  • F3 a repeat approval is honored once and shown — confirming a card now writes a session-provenance rule onto the same learned list the always tier uses, so resolve() composes it unchanged and nothing can be learned into denied space. Repeats auto-resolve through the decision functions that already existed. Never-grantable classes (remote git, dangerous prefixes, outbound content) stay approve-once. A grant-covered action now leaves a receipt — the same headline and risk, no buttons — because silence was indistinguishable from nothing having happened (I8). Also fixed: a worker read approved network hosts from the current verdict only, so approving host A then host B dropped A and it was asked for again.
  • F4 the auto-landing lane requires a pinned verify_command — maintain is the only lane that lands without a human, and it accepted any confirmed re-verification, including one earned by re-running true. It now requires the project to have said what verification means. An unpinned project is not blocked; its patch simply waits for a human. (The "missing key named on the record" half of this claim was not true until v106-F11 wrote the block reason to the audit trail — v90 shipped the enforcement, not the visibility.)
  • F1 CLI-agent engines become selectable (ADR 0047) — the Claude Code, Codex and Aider adapters have been complete since v33 and unreachable because nothing mapped a name to them. A coding_engine project-policy key now chooses one, skep doctor reports which binaries are present, and the engine's API host is merged into the allowlist. A CLI engine requires a pinned verify_command, because its own verification is git diff --check — whitespace. The boundary is stated, not assumed: an external agent's commands do not pass skep's capability layer; the sandbox is what confines it. ADR 0047 tables which wall enforces what and names the cost — a CLI engine cannot commit because its worktree is disposable, and cannot reach a remote because the network pin excludes one, rather than because a deny fires. I1 is untouched and is what makes both consequence-free.

v91 (2026-07-25, F1–F2)

The pin nothing was setting (operator ask; plan plans/v91/README.md). v88-F4 gave a project the power to say what verification means and v90 made that pin mandatory on the two lanes where its absence is fatal — but no setup path ever wrote one, so every ordinary run still re-ran the command the worker nominated for itself. This is the alternative v90 deferred with a reason ("a confidently wrong inferred command is worse than none, and it deserves its own round"); the option v90 rejected — refusing to confirm any worker-nominated verification anywhere — stays rejected.

  • F1 setup pins a verify_command by default — inferred from the repo's own declared entry point, reading the same explicit toolchain table that has seeded the shell allowlist since v23-F4, at the same already-confirmed moment. Conservative by construction, because a pin that cannot pass is indistinguishable from a broken patch: make test only when the target is declared, uv run pytest/pytest only when a test tree exists (pytest with no tests exits 5, which reverify reads as failed), npm test only for a real script (npm init's placeholder exits 1 and is refused by name). Nothing detected means no pin and the pre-v91 fallback, unchanged. The pin now survives a phase change — phase defaults carry none, and the move into maintain is the move into the only lane that lands without a human. The three setup-preview surfaces (CLI, cli_chat, app.js) state which command G10 will re-run, including when the answer is the worker's own, since the weaker guarantee has to be legible at the moment of confirmation (I8). Existing projects are not rewritten: skep doctor names the ones still on the fallback, what it costs them, and how to fix it (I9).

  • F2 the card's purpose line stops speaking to the model (field report: a land_run card whose what-is-this-for line read "PROPOSE landing a completed run's patch (requires user confirmation)"). v90-F2 derives that line from the tool description's first sentence, and the mutating descriptions open with a wrapper written to steer the Queen, not to inform the human. purpose() now strips the wrapper at the presentation layer — descriptions stay untouched, they are load-bearing model prompts — and the sentence splitter no longer ends at "e.g."/"i.e.". The land_run card now reads "Landing a completed run's patch." over its risk line (I8).

v92 (2026-07-26, F1–F3)

The chat shows who is working, and since when (field test 2026-07-26, chat 39bc00e2; plan plans/v92/README.md). The operator approved a gated run's shell request; the run was re-dispatched server-side, completed three seconds later, and the 🟢 patch-ready call to action was persisted — while the open chat rendered none of it. The record was honest and the surface hid it (I8): no lane reopened the status stream after the approval, the v43-F4 status line only moved on heartbeat boundaries, and a completion born outside a live stream waited for a manual reload.

  • F1 the worker loader — the shared status line becomes one pulsing row per live run this chat owns: worker <id>… · <phase> · <elapsed>, a link to the run page, ticking every second in the browser while the server stays the authority (each SSE status event resyncs the clock from the run's own event timestamps, so the timer counts from dispatch). A live dispatch tool result seeds its row at 0s instantly; replay never seeds (a historical result may be long terminal — the stream resyncs any still-active run). Terminal events clear the row and now announce completions too, deduped across the v56-F7 replay window, and — never mid-stream, never over a draft — redraw the view so the stored call-to-action line appears without a reload (v81-F13-style). Route teardown closes the status stream and the ticker.

  • F2 the Queen loader carries its start time — every showWorking phase stamps its start clock the moment it begins and ticks from the first second: "Running dispatch_run… · 11:17 · 5s". The v87-F7 3-second threshold goes; the start stamp anchors phases too short to count. Phase vocabulary, turn_status, and the ticker structure are unchanged.

  • F3 every dispatch-capable lane reopens the status stream — the incident's trigger: watchStatus() ran only at chat open and after a deliver() turn, so the /approve that re-dispatched the run left nobody subscribed. Card verdicts and every deck command now reopen the stream; idempotent, since watchStatus closes its predecessor and a chat with no runs streams nothing.

v93 (2026-07-26, F1)

An approval covers its bare-flag variants (operator request; plan plans/v93/README.md). A command was approved, ran, failed, and the worker's retry — same command, same operands, different flags (pytest -x tests/foo.py → pytest -vv tests/foo.py) — re-carded the operator inside the session that just approved it, because approval coverage was an exact token-prefix match everywhere it is consulted.

  • F1 bare-flag variants of an approved command are covered — after the exact-prefix lanes miss, a second lane in the one shell-decision funnel (ShellExecPlugin.decision, I5) asks whether the candidate's positional skeleton — bare flags stripped, everything from a literal -- on kept verbatim — is identical to an approved entry's. A bare flag is -letters/--word only: glued values (--index-url=http://x, -o/tmp/x, -d@file) keep their token, so no payload rides a "flag" past an approval, and a separated flag value reads as a positional and blocks the match. git, find, sudo, doas never match the lane (a bare flag alone flips those between read and destroy); every hard deny still precedes it (I4). Both grant tiers get the lane — resume grants and the merged allowlist carrying the v86-F1 session tier — the ledger keeps the verbatim approval (I13), and a variant match declares itself: reason …shell_command_flag_variant / …shell_allowlist_flag_variant, detail naming the covering command (I8).

v94 (2026-07-26, F1–F7)

The claude_code engine actually works end to end (live field test, operator-requested; plan plans/v94/README.md). Four dispatches against a fresh uv sample repo surfaced the whole chain: the engine could not authenticate (env scrub), could not edit (headless permissions), was SIGKILLed mid-run (no heartbeats), ran on the naked host in workspace mode, had no operator surface to select it, the preview lied about the inferred verify pin, and the ONE run that produced a perfect patch was rendered NOT CONFIRMED because uv run pytest cannot run under the deny-all reverify profile. Acceptance after the fixes: the same task, zero workaround flags — sandboxed dispatch, patch produced at 58s, G10 passed [confirmed] on the pinned command, landed on skep/<task> by human approval.

  • F1 the adapter grants Claude Code its hands — --permission-mode acceptEdits joins the headless argv; --print cannot prompt, so every write was rejected and the engine could never patch. The sandbox is the wall, not Claude's prompts (ADR 0047).
  • F2 the adapter heartbeats while the agent thinks — a timer thread emits contract HEARTBEAT events every 5s during the agent subprocess; the event stream takes a lock. The monitor's 3×heartbeat kill rule is untouched — the adapter finally honors it.
  • F3 an engine declares the env it cannot run without — CodingEngine.env_vars, merged at resolution like the API host (ADR 0047 §3): claude_code needs USER/LOGNAME for its macOS keychain lookup; the baseline is PATH+HOME. Identity names, never secrets; G2 intact.
  • F4 an external engine only ever runs inside the sandbox — the resolver coerces execution mode to sandbox (the coerced mode is the shown mode, I8); dispatch backs it for every caller and refuses to run with no usable backend instead of falling back to the naked host (I9/I12).
  • F5 the operator can choose the engine — skep project setup/preview --engine NAME, validated against the registry at setup time; previously only tests ever wrote coding_engine.
  • F6 the preview tells the truth about the pin it inferred — the summary printer read a key the preview payload never carried and printed "none detected" over a freshly inferred pin; it now reads the project dict, correct on both paths.
  • F7 G10 can confirm a uv-pinned project — re-verify primes the baseline env (before the patch applies, so patch code never gets the network), then runs the pinned command offline with a workspace-local uv cache (UV_NO_SYNC). The shared host cache stays unwritten; a failed prime reads "unavailable", never patch guilt.

v95 (2026-07-27, F1–F4)

Engine selection reaches the chat (live field test, operator-requested; plan plans/v95/README.md). The operator tried to set up a project from chat with Claude Code as the engine; the Queen sent policy_overrides as a JSON string and confirm died with a 500 at .items(). Beyond the crash, "run THIS task with claude_code/codex" had no chat-shaped path at all — the engine was a project-policy key only. A gate casualty rode along: a v74 usage test carried a hardcoded date that aged out of its own 7-day window six days after it was written.

  • F1 the usage-window test stops carrying a time bomb — the backdated row is now relative to datetime.now(UTC); the suite no longer goes red by calendar (I10).
  • F2 object-typed tool args tolerate the JSON-string variant — _object_arg decodes a stringified policy_overrides / create_schedule.params / call_mcp_tool.arguments and refuses garbage honestly naming the key (I9), a card error instead of an AttributeError 500 (I8). _call_args already handled the whole-blob-as-string variant; nested params now match.
  • F3 engine is a per-dispatch knob on dispatch_run — threaded through submit_run → resolve_run_policy ABOVE the v90/v94 guard block: same single validation point (I5), unknown names fail closed naming the request (I9), external engines still require the pinned verify_command (I2), forced sandbox + host/env merges intact (I12). An explicit choice joins the explicit-overrides tuple and always cards (I6/I7). Fresh-chat floor re-measured 26.5KB → 27KB.
  • F4 setup_project takes engine first-class from chat — the CLI's --engine (v94-F5) mirrored onto the chat tool: validated at setup naming the choices on a typo, folded into policy_overrides.coding_engine (same write path, I5); an explicit override beats the sugar.

v96 (2026-07-27, F1–F5)

The chat cockpit (operator-requested design round; plan plans/v96/README.md, co-designed in session with v97 — modular policy groups — planned behind it). The chat page had no project awareness: the composer's status row scraped tool results for a branch-looking string, the server had no operator-visible chat→project binding, and push/PR required deck incantations with task ids.

  • F1 effective_policy_view names engine, protocol, and the verify pin — coding_engine, worker_protocol, verify_command join the one policy read every surface shares; unpinned verify renders an explicit (worker-nominated fallback) marker, never blank (I2/I8).
  • F2 a chat knows its project — plan corrected during execution: the column already existed (chats.project_id, v56-F4, auto-bound on dispatch/workon); what was missing was every surface. Now: PUT /api/chats/{id}/project (operator/UI only — the Queen reads, never writes, I6; refusals name the known projects, I9), the chat GET returns a chat_project_view (name, phase, engine, repo; a deleted project renders unbound, I8), one chat_project_line in the pinned prompt so the Queen defaults repo/project args to the binding, and deck /policy /state default to the bound repo.
  • F3 the composer strip becomes real — project selector + branch/policy/engine pills reading server truth (effective-policy + repo state), CSS-only popovers on the existing context-popover pattern; the transcript-scrape heuristic (projectChangeSignal) is deleted with its render sites; an unresolved policy renders AS unresolved (I8).
  • F4 Push and Open PR, one card each — the verbs existed carded since v47/v57; push_branch + open_pr join COMMAND_TOOL_NAMES (the only gate that stood between them and the operator-command path), open_pr gains branch mode (branch+repo → push an existing local branch and PR it; selector refusal names all three modes, I9), and two strip buttons propose the cards — the card stays the confirmation (I6/I7); both verbs stay web-UI-only.
  • F5 push_branch pushes the checked-out branch (live-verify find, I10: the verify-skill acceptance run WAS the reproduction) — v57-F7's guard ORed in default_branch, which actually returns the CURRENT checkout, so push_branch refused whatever branch you were on; dormant while only landing branches were pushed, fatal to the Push button. Both push-path guards now compare against repo_default_branch only — the check that means the I1 line. delete_branch keeps its clause (refusing to delete the checkout is correct).

Verified end-to-end against a throwaway home: strip renders bound project/branch/policy/engine with popovers, Push card really lands the branch on a bare origin, Open PR cards and denies honestly.

v97 (2026-07-27, F1–F6, ADR 0048)

Modular policy groups (operator-requested, co-designed in the v96 session; plan plans/v97/README.md). Policy becomes modular: define a convenience-grant bundle once (network hosts, shell prefixes, env vars, budgets, engine), name it, attach it to any number of projects, edit it in ONE place and every attached project follows on its next dispatch — with a copy-on-write fork for "change it for THIS project only".

  • F1 groups exist — policy_groups settings blob; write-time vetting with the same validators project policy passes (I5) incl. dangerous_prefix_reason (I4); trust-ramp keys ungroupable by construction, refused naming the groupable set (I9); builtins python-bootstrap / node-dev merged read-side (edit materializes a copy, delete reverts — builtins revert, never vanish).
  • F2 live composition — one merge point (run_policy_for_repo): defaults → phase → groups (attach order) → project overlay. List keys union; project scalars beat any group. The v90/v94 engine guard runs AFTER composition (a grouped engine still needs the verify pin, still forces sandbox — I2/I12); a dangling attach fails the dispatch closed naming the group (peeks keep working via a breadcrumb); delete-while- attached refuses naming the projects.
  • F3 the five verbs — set_policy_group (with fork_from/ repoint_project — the whole copy-on-write fork is ONE carded action, validated entirely before the first write), delete_policy_group, attach_policy_group, detach_policy_group, list_policy_groups. Card risk lines say which shape is in play (in-place reaches every attached project; a fork leaves the source untouched, I8). Fresh-chat floor re-measured 27KB → 27.5KB (the ritual, not a surprise).
  • F4 setup suggests, never attaches — setup_project groups= / CLI --group attach explicitly (same sugar shape as engine=); the toolchain sniff SUGGESTS builtins on preview/setup results (I6: suggested ≠ applied); a typo'd group refuses at setup naming the known set.
  • F5 the surfaces — effective_policy_view.policy_groups carries each attached group WITH its grants ("why is this host allowed" has an answer, I8); #/policies grows the groups editor with the "Save as new group" toggle (context-sensitive default: pre-checked when opened from a project's view while the group serves >1 project); project detail links edit-in-context; the v96 strip's policy popover lists attached groups. Operator-direct routes incl. an atomic fork endpoint.
  • F6 group verbs join COMMAND_TOOL_NAMES (acceptance find — the v96-F4 lesson relearned; the acceptance run IS the reproduction, I10).

Verified live end-to-end: carded attach to backend+frontend → both resolve the group host; edit once → both follow; fork with repoint → frontend on the fork, backend untouched; delete-while-attached refuses naming projects; trust-ramp group refused at write. Not exercised live: a full sandbox dispatch with python-bootstrap (composition + allowlist union is unit-tested; v94-F7 offline re-verify untouched).

v98 (2026-07-27, F1–F3)

The ECC harvest, and the seed that lied (operator-requested survey of github.com/affaan-m/ECC — 281 external Agent Skills, MIT; plan plans/v98/README.md). The survey's finding is mostly negative and that is the useful part: skep's own 76-seed shelf (ADR 0043) already covers nine of the twelve candidates in a better-adapted form, and verbatim import is rejected on shape — 281 descriptions flood a small Queen's index, the bodies run 200–800 lines against a house format of ~25, and they name ECC agents and slash commands that do not exist here (the preset-hallucination class, I9). Three things survived, and checking for overlap turned up a real defect.

  • F1 the defect — orchestrate-cli-coding-agent told the Queen to send one brief to different backends via batch_dispatch; the batch task-item schema had no engine, so the closest reachable behavior was N runs on the same engine, silently. v95-F3/F4 threaded engine= into submit_run and dispatch_run_decision; batch_dispatch is the OTHER caller of both and was never updated — the v96-F4 / v97-F6 lesson in a third shape. Per-member engine now passes through both call sites with no new guard, because the member takes the same path a single dispatch takes: resolve_engine refuses an unknown name, an explicit engine cards the whole batch, and the v90/v94 verify_command + sandbox block runs per member (I5, I2, I6/I7). test_every_seed_names_only_tools_that_exist could not have caught this — it cross-checks tool NAMES, not the arguments a seed instructs.
  • F2 compare-coding-engines — the one ECC idea skep had no procedure for: four engines and a coding_engine key, and no evidence-based way to choose. Built on F1; scored on reverification.confirmed (the supervisor's re-run of the pinned command), never on verification_outcome, the worker's own claim — ranking engines on that measures confidence, not correctness (I2). Refuses to run without a pinned verify_command, since a CLI engine's built-in verify is git diff --check and every engine would "pass" (ADR 0047). orchestrate-cli-coding-agent gains the engine: argument and a pointer to its new sibling — the two answer different questions and each now says which.
  • F3 the two content gaps — security-audit (repo-wide sweep anchored to real input paths, ranked by reachability, one dispatch per fix) and production-readiness (ship-or-block triage from local evidence only, I11; audits only boundaries that exist in the repo; refuses the uniformly-green report, I8). Distilled from ECC's security-review and production-audit into the house format, zero-grant, adapted-from credit in the description.

Shelf: 76 → 79 seeds. No new ADR — F1 is a bug inside ADR 0047's engine surface, F2/F3 are shelf content under ADR 0043. Not exercised live: a real three-engine bake-off (the per-member engine thread-through is unit-tested; claude_code/codex need their binaries and a pinned project).

v99 (2026-07-27, F1–F3)

The index is a map, not a manual (found while checking v98's acceptance; plan plans/v99/README.md). The Queen's prompt showed 20 of 91 skills and the fresh-chat floor measured 27,345 of its 27,500 pin — 155 chars of headroom, about one schema property. Both are the same mistake: the prompt spent its budget on depth (truncated prose about a few things) where it should spend it on coverage (the existence of every thing). A name the model never sees cannot be asked about; describe_tools / view_skill make depth one call away, but nothing makes an unlisted name discoverable.

  • F1 the tool index — 13,019 → 8,351 chars, all 112 tools kept. Summaries were 60% of the block: PROPOSE opened 67 descriptions and a (requires …confirmation…) clause appeared in 64, so the 80-char cap truncated mid-boilerplate. Now four mechanical rules, no per-tool curation: * marks MUTATING_TOOL_NAMES membership with the legend stated once; core tools render name-only (their full schema is in the same request — zero loss, provably); a gloss whose tokens are a subset of the name's is dropped; gloss 80 → 44 chars and arg lists cap at 6 with …. The marker is more honest than the prose: six tools in that set never said PROPOSE, so the old index under-reported the confirmation path (I8). The legend deliberately says "cards UNLESS project policy auto-allows" — read_file is in the set and routinely auto-allowed.
  • F2 the skill index — every template by name, no cap, no overflow line: 1,645 chars for all 91 against 2,121 for 20. The cap traded coverage for depth and lost both; every v98 seed sat behind "… and 71 more". Comma packing is safe for skill names and was measured and REJECTED for tools, whose arg lists contain commas.
  • F3 the ratchet — floor pin 27.5KB → 23KB, the first downward move after five upward ones (25 → 26 → 26.5 → 27 → 27.5), plus the reach block 13.5KB → 9KB. Measured floor is now 22,677.

Net: the fresh-chat floor drops 4,668 chars (17%) while the model sees 91 skills instead of 20. No new ADR — this is v74-F3's progressive-disclosure design carried through to its encoding. Not exercised live: how the small Queen routes with names-only skills (the field test is whether view_skill call rate rises).

v100 (2026-07-28, F1–F10)

Three sources, one round, and the field test found the rest (plan plans/v100/README.md). F1–F5 were planned: the four ECC ideas v98 cut for size, and skep's own open R13. F6–F8 were reconstructed from the audit trail of two dead claude_code runs. F9 and F10 were found by running v100's own acceptance against the live operator home — the round auditing itself.

The field-test story is one story. Two runs on skep-benchmarks failed within five seconds of each other at ~180s, reporting agent exited 1. Claude Code was blamed for two days. The truth was three defects stacked:

  • F6 the proxy was cutting the wire. _TUNNEL_TIMEOUT = 120.0 was applied with settimeout to both ends of a CONNECT tunnel — but that bounds a single recv, not an idle connection. HTTP is request/response, so the client→upstream direction is silent for the whole of every response; 120s in, the forward pipe raised TimeoutError, set the shared done, and closed the tunnel while the response was still streaming, under except OSError: pass so nothing recorded it. An undocumented 120-second ceiling on any single model response. Now _TUNNEL_POLL = 5.0: a timeout means "nothing to relay yet", every other OSError still tears down, and the idle direction retires in ≤5s instead of ≤120s — better shutdown latency from the same edit. The plain-HTTP path had the same defect with a worse constant (10s, silently TRUNCATING the body) and is fixed with it; patching only the path the field test named would have left its sibling broken.
  • F7 the resolved allowlist was a list of characters. default_network was stored double-encoded — a JSON string — so list(policy["default_network"]) iterated it into 28 single characters. Every real host in the resolved list came from somewhere else, and the two the operator configured (youtube.com, www.youtube.com) were never granted since 2026-07-26. Two unguarded boundaries, one edit each: update_policy now validates both list fields (the REST route is typed, but the chat set_policy tool hands it raw args), and policy_view guards like its neighbours. Deliberately no json.loads on read — repairing malformed authorization data is how a validator becomes a parser (I5). Nothing widened: domain_allowed needs an exact match, so the characters never matched a host. The damage was to the truth of the record, which is the product.
  • F8 agent exited 1 threw away the agent's own words. _run captured stdout, stderr and both tails into the event log and the adapter dropped them at the one place the operator reads. details now carries a 200-char tail, stderr-first with a stdout fallback — claude --print reports API errors on stdout, which is exactly why this cost two days.

Then the acceptance went to run itself and found two more:

  • F9 No surface but chat could re-dispatch on a named engine (skep run has no --engine; POST /api/runs never passed the field submit_run has taken since v90), and moving the engine onto the project dropped the verify_command pin — which no CLI or REST surface could set, while policy_resolver.py:543 refuses to run an external engine without one. A refusal naming a way forward the operator did not have. --verify-command on project setup/preview, engine on the REST dispatch; every wall stays in the resolver.
  • F10 project setup on an existing project re-installed it: bindings wiped and re-added, policy rebuilt from phase defaults that cover four keys. Every other key an operator ever set was silently destroyed by a re-run that changed one flag. v24-F4 wrote the right rule for seeded templates and it never reached the project's own record. Now: stored → phase defaults → explicit overrides, and bindings replace only the kinds supplied.

Acceptance, live. Run 019fa8de — the brief that died twice at ~180s — ran 555.6 seconds on claude_code and exited 0, re-verified against the pinned python3 verify_plan.py, and auto-landed on skep/maintain. A dispatched run's task.json now carries seven real hosts and zero characters. A forced failure reports agent exited 127: [Errno 2] No such file or directory: 'aider'.

The planned half:

  • F1–F4 the shelf, 79 → 83 seeds: audit-an-agent-stack (audit the assembled payload and one reconstructed run, not the templates), write-an-adr, council (three lenses briefed to disagree, one verdict), and postmortem-a-run — which is F6–F8 written as a procedure. Skill index 1,422 → 1,485 chars against its 2,400 bound; the fresh-chat floor stays inside v99-F3's 23KB pin.
  • F5 closes R13. A pack declaring self_test: now has that command RUN, in a sandboxed no-network script run, extracted at the same .skep-skill/<pack_id>/ path a real run uses, printing the forge's own evidence line so trial_verdict reads it unchanged. A pack declaring nothing still promotes on the syntax smoke and the evidence says level: "syntax" — the gap closes either by running the check or by saying plainly that none ran. The v36-F3 shadow-permissions guard caught the first attempt building its own Permissions; the trial now requests and the resolver decides.

No new ADR — ADR 0045's ceiling bullet is amended (R13 is its own named upgrade path), F1–F4 are shelf content under ADR 0043, and F6–F10 are bug fixes to existing decisions. Not exercised live: a real self-test pack promotion end to end (the harness is executed for real in tests; the dispatch seam is stubbed).

v101 (2026-07-29, F1–F14; F15/F16 landed in v106)

The caste roster becomes a registry (ADR 0049): the contract owns the names, castes.py owns routing and description, a test pins the two sets equal, and every surface reads the registry. The verifier and reviewer castes become real workers; the store records worker_kind and the RESOLVED coding_engine on every run (I8). The UI gains its type/spacing scale, accessibility floor, two breakpoints and the .chip primitive, all linted; GET /api/workers and the Assign panel expose the whole roster; the Queen's dispatch enums generate from it. Setup writes the slug binding it always implied, and an un-runnable inferred pin is refused by the same host probes that seeded it (F14).

Part E (F15 tool-call pairing, F16 the close_pr card) entered the plan mid-round and did NOT ship with v101 — recorded complete by mistake, found by the 2026-07-29 audit, landed as v106-F4/F5. The plan's own words for F15: "the one fix here that should not be dropped."

v103 (2026-07-29, F1–F5)

The git surface round. Mid-turn steering is queued with a receipt instead of discarded (and the queue state's declaration order is pinned — a TDZ stopped the chat rendering entirely once). merge_branch lands supervisor-side, carded, refusing the default branch, conflict-aborting in a temp worktree. F3 closed a live hole: git merge, rebase, cherry-pick, revert and reset --hard were never denied to workers — one broad allowlist entry would have let a worker merge another branch into its worktree, and the patch (diffing against the baseline) would land that work under the wrong approval. Denied with the rest, before the verify fast-path and every grant lane; the Queen is bound by the same predicates; stored grants are swept, not grandfathered.

v104 (2026-07-29, F0–F5, ADR 0050)

One verb, three faces. The surface-parity gate (tests/supervisor/test_surface_parity.py) turns "someone will notice the next chat-only verb in a field test" into "the next gap fails a gate" — on first run it reported 35 of 74 mutating verbs faceless, not the estimated fifteen. skep branch, skep pr, and skep repo refresh close the git family's operator half; two REST routes give the web UI branch create/merge; every remaining chat-only verb sits in CHAT_ONLY with a written reason. ADR 0050 makes it a rule: a new mutating verb ships with its operator face or its recorded exemption.

v105 (2026-07-29, F1)

The conversation continues when the work does: a completed run's owning chat gets one unattended, read-only continuation turn — fact-seeded, once per run, mutations card instead of executing (the pinned test proves a scripted dispatch_run becomes a CARD). continue_chat_after_run opts out.

v1.0.1 — the public launch (2026-07-30)

The first public release: the repository opens here (see the top of this file), published to PyPI and as a GitHub release on 2026-07-30. Everything above this line is the internal history that led to it.

v106 (2026-07-29, F1–F12)

The audit round — seeded not by a field test but by a nine-agent plan-vs-code audit of v85–v105 plus a read-only reconstruction of the live home's week. The code was faithful; the felt breakage was operational. F1 gives per-run toolchain state a writable home inside the sandbox wall (CLAUDE_CONFIG_DIR, npm_config_cache → <workspace>/.toolchain/) — Claude Code's Bash tool and npm both died against a read-only $HOME. F2 heartbeats through long shell commands (three workers killed at exactly 3×10s mid-npm-install). F3 stops "could not re-verify" covering for "ran and FAILED", puts the unconfirmed verdict on the pending approval card, and makes an unavailable outcome ride the ready-to-land line. F4/F5 land v101's Part E. F6 re-clocks card timeouts to operator absence. F7 gives run_code a 600s ceiling. F8 teaches doctor to name umbrella and dead registrations. F9 adds yarn's registry to node-dev and stops the UI 404-polling diffs that don't exist. F10 writes the four tests the plans named and nobody wrote — its CLI-reference drift gate flagged eight undocumented command groups on first run. F11 implements v90's unkept visibility clauses (grant tier + time on the receipt, blocked auto-apply reasons on the audit trail, the ADR 0046 amendment). F12 is this file catching up.

v1.0.2 — the v106 audit round (2026-08-03)

The published form of the v106 round above (its release notes count the fixes as F1–F13), plus parallel CI. Published to PyPI and as a GitHub release on 2026-08-03.

v107 — the kept worktree (2026-08-03)

The first public-tree plan round, seeded entirely by the 2026-08-03 dogfood arc (the day the v106 port shipped as 1.0.2 and skep started fixing skep with Claude Code as its own worker). F1: failed and unconfirmed-completed runs keep their worktree — the keep answer for a completed run is deferred until re-verification writes the confirmed bit; a failed run's retry resumes into its warm tree (no checkpoint needed — the tree IS the value); a 24h TTL sweep on the ticker collects what nobody resumes. F2: diagnose_run — one bounded, always-carded command inside a kept worktree, sandboxed like re-verification, with a REST face (POST /api/runs/{id}/diagnose); the Queen finally gets "re-run the failing test, show me" without a terminal. F3: TMPDIR moves inside the wall (workspace .toolchain/tmp for workers, a worktree-local dir for re-verify) — the "~184 tests blocked by network isolation" was a misdiagnosis, bwrap already brings loopback up; the nested-bwrap /tmp mask was the whole story, and with it fixed the skep suite passes inside the sandbox, making G10 confirmable for skep-shaped repos. Plus the re-run now gets the run's own wall-clock budget (the flat 300s cap timed out healthy 10-minute suites), and the plugin scratch copy learned to exclude bookkeeping dirs. Recorded seed: macOS seatbelt's bare (deny network*) blocks loopback binds — unverified from a Linux host.

v108 — the provider shelf (2026-08-05)

Hermes parity as data: the operator's archived assistant reached ~28 model providers; skep's registry (v14) reached four — and recon showed the registry itself was a facade (no surface could write a profile, allowed_network_hosts was stored but read by nothing, and every inference path collapsed onto the single llm-secret). F1 fixes the six truths the plumbing was lying about: the probe bridge gains anthropic (profiles could never probe healthy), phantom gemini leaves the vocabulary, the profile host list actually reaches the v19-F2 egress merge, the reviewer caste stops starving (the merge gate reads needs_provider), registry api_key_env gets the v48-F2 name guard, and the protocol vocabulary derives from ONE Literal (test_protocol_vocabulary pins every surface). F2 gives the registry its operator face — add/use/remove as one actions.py verb each with CLI, REST, and carded chat forms (ADR 0050); use writes through to the saved assistant config so activation is something the Queen actually speaks. F5/F6 add the two missing wire protocols: the OpenAI Responses API and AWS Bedrock Converse with a hand-rolled, test-vector- pinned SigV4 (no boto3) plus a binary eventstream decoder. F3 ships the preset catalog (~30 rows mined from the operator's own ~/.hermes: OpenRouter, DeepSeek, GLM, Kimi, MiniMax, Copilot, Bedrock, Google via its OpenAI-compatible endpoint, …) — every registration prints its egress truth, provenance lands as source=preset:, azure demands its per-resource URL instead of guessing. F4 ends the one-secret era: per-profile 0600 key files (env NAME → own file → legacy) honored by chat, workers, probes, and /api/llm/models, with stdin-only CLI entry and a write-only key route. F7 automates the one subscription auth that needs no borrowed identity — the GitHub Copilot token exchange (your own GitHub token becomes a short-lived in-memory bearer). F8 adds skep provider login: RFC 8628 device flow with the OPERATOR'S client id — skep ships none, ever (ADR 0051). F9 is the face polish: a preset picker in both LLM forms, docs, and this entry. The chat floor pin moved 24KB → 24.5KB for the four registry verbs + two protocol enums.

v109 — one question asked once (2026-08-05)

Seeded by the 2026-08-03 blog-post session read straight out of the store: two byte-equivalent land_run cards confirmed 67 s apart, three approval surfaces for one landing with no shared words, three fresh dispatches for one fix-chain while the v107 kept-tree machinery sat unused — and, found in the same rows, cd <repo> && git checkout … && sed -i … executed from chat with exit 0. F1: guards judge SEGMENTS, not lines — command lines split at shell operators, bash -c payloads and env prefixes unwrap, and the deny fires on any segment, on both lanes (the same shape also closed the worker's wrapped-git and verify-fast-path holes); what cannot be statically read fails closed on the persist/worker lanes and cards on the queen lane. F2: proposal-time dedup — an identical pending proposal hands the model the pending card with the protocol spelled out; a changed proposal for the same subject supersedes honestly; gate mirrors and operator cards are never superseded by a model proposal. F3: landing approvals are titled land "<brief>" → <branch>, review cards headline the reason instead of a UUID, and land_run's result says done-means-done. F4/F5: a per-project uv/npm cache mounted through the sandbox wall (re-verify primes against the same cache; grandchild processes finally inherit TMPDIR/UV_CACHE_DIR). F6: dispatch surfaces hint at kept worktrees before a fresh dispatch redoes the work. F7/F8: approve-and-remember reaches network hosts (project default_network, allow-host faces), and the ledger closes its loop — the Nth identical approval carries a nudge, GET /api/ledger/suggestions derives the standing offers on read, remembering through any door marks every matching ledger row. F9: the Policies workspace shows every tier, learned/session rules become listable and revocable (carded from chat, with an honest narrowing risk line), and RSoP provenance answers "who decided each key" on project detail. F10: the catastrophic floor — rm on roots, mkfs, dd onto devices, shutdown, fork bombs — refused everywhere with one laugh and one honest line, never allowlistable, learnable, or grandfathered, on the same only-ever-grows footing as the git guards. The fresh-chat floor re-measured to 24.5KB (the round paid byte-for-byte first: F7 folded its tool into allow_command_review, F6 trimmed). Also: the main branch arrived with a failing release-checklist pin from the README front-page rewrite — repaired first, per the no-pre-existing-failures rule.

v110 — the subject table lied (2026-08-09, F1–F2)

Two chat-card fixes from the first days on the public tree. F1: the card subject table keyed merge_pr/close_pr on the wrong argument, so a card could headline one PR and act on another — it now keys on the real pr arg. F2: a card that dies server-side drops its buttons instead of offering a confirm that can no longer land. (A separate "fleet sync" branch also wore the v110 number; it was closed unmerged and never shipped.)

v111 — doctor sees what serve sees (2026-08-12, F1–F6)

F1: skep serve loads ~/.skep/serve.env at startup, so engine auth env can live beside the store instead of the shell that happened to start the daemon. F2–F6: skep doctor reads the live memory store rather than a retired path, probes each engine's auth env (not just its binary — and it counts serve.env), gives the codex entry the v94-F3/v106-F1 treatment it never had, and names the store files retired layouts left behind.

v112 — the keep choice on the card (2026-08-12, F1–F3)

F1: the keep choice (once, session, always) rides the card confirm itself, so one click records both the decision and how long it stands. F2: the evidence bundle is offered at decision time, not only built afterwards. F3: the ledger's remember nudge gets a face on the Approvals view.

v113 — the restart: skep maintains skep (2026-10-21)

After two months unreleased, the operator restarted by registering skep as its own maintain project and landing the open Dependabot alerts through skep's own cards — A0 found the provider key dead for inference while doctor said ready (fixed as v115-F5); A4, the starlette bump, was the first real self-maintenance run and took eight attempts, each one a v115 fix (PR #29 is the patch skep landed on itself). The ACP adapter (Part B) stayed open on the Restart Plan — it shipped as the ACP governor (acp-governor B0–B2 and v1.2.0 below); A7/A8 hygiene and record catch-up land with this release.

v114 — the policy engine under a hostile operator (2026-10-21, F1–F5)

A field test that tried to make the Queen misbehave. F1: the Queen shell guard judges the command's targets, not only its cwd (shell.deny.repo_ target; a nine-probe table test). F2: persist_remembered_command is the one writer of a remembered command, and CLI, REST and chat all name the tier. F3: --yes is one consent, never a standing grant and never a policy write; terminal confirms carry keep=once; policy cards are marked and left pending. F4: a plan step must be a step, and the run summary is built from what ran. F5: a denied non-verify step no longer kills a plan run, and a resume resumes. F6–F14 were cut into v115 and v116.

v115 — the record tells the truth (2026-10-21/22, F1–F16)

Sixteen fixes, eleven of them found by skep's own self-maintenance attempts on the starlette bump. F1: a resumed parent is superseded on every face and the run page names its successor. F2: skep run tails only its own dispatch's events. F3: terminal-chat receipts say what the verdict was and why; /approve and /deny find a card across chats. F4: CLI approve persists the landing branch. F5: doctor probes a real completion and reconciles the two model truths. F6: the worker's per-command cap follows the task budget, and a timeout is a failed command. F7: a CLI resume keeps the run's execution mode. F8: a worker gets a startup allowance before its first event (the CI flake class, root-caused). F9: loopback is not egress. F10: a live worktree's own paths are not dead-worktree references. F11: the suite survives the environment a skep worker gives it. F12: a failed re-verification keeps what the re-run said (reverify.output.txt in the audit dir). F13: a lockfile patch is re-verified against its own dependencies. F14: Unix-domain sockets are files, not egress — the seatbelt profile says so. F15: the landing lane judges the patch (git apply --numstat), never the worker's claim. F16: skep run lands maintain patches on the project's integration branch, with auto_apply_branch read from project policy. PRs #21–#31.

v116 — every refusal teaches, every verb has one face (2026-10-22, F1–F4)

F1: an engine pin never wins silently — --worker-cmd under an external pin refuses naming both, skep run --engine is the explicit override, and dispatch pre-checks the engine's auth env and asks doctor's question. F2: one name, two repos — a bare name that matches both a clone and a bound dir is a 409, and neither path may claim the other's name. F3: the repo-cwd denial leads with the read lanes, then the write lanes, then the standing rule. F4: skep repo list, group usage for the channel/ops/repo groups, skill shelf list, and complete_task says it records rather than does. PR #32.

policy-engine-rewrite P0–P3 — one policy engine (2026-10-22)

The operator's decision (.10x/decisions/cto/policy-engine-rewrite.md, ADR drafts 0052/0053): the four policy systems become one, by strangler. P0: a registry of every policy key, a characterization harness that freezes the real home's seven projects as golden files, and a resultant- policy view with the override chain plus a why query on chat, REST and CLI. P1: engine v2 — one layer stack where each statement sets, extends or clears (the golden proved a project list REPLACES the global one while groups extend it, so union is a statement mode), enforced refuses lower layers by name, the floor stays outside; the reader derives layers from today's stores without rewriting them; a per-scope kill switch (policy_engine_v2_scopes, default off) routes flipped scopes through v2 with every flip in <audit>/policy/engine-flips.jsonl; parity is proven with all seven scopes flipped. P2: the Policies page gains a registry- driven "Resolve & edit" tier. P3: decide() reachable from outside — POST /api/policy/decide, skep policy decide|hook (the Claude Code PreToolUse hook) — every verdict recorded, and the floor consulted before any document so git push is denied, never asked. PR #33.

v1.1.0 — the policy engine (2026-10-22)

The first release since 1.0.2 (2026-08-03): v107–v116 and the policy- engine rewrite P0–P3 above. Operator note: the engine switch ships OFF — flip shell first, after the golden parity suite is green; install the Claude Code hook from docs/policy-hook.md. Linux/macOS CI gates stay the same, with job timeouts so an unreachable apt mirror fails in minutes.

acp-governor B0–B2 — skep governs agents inside other clients (2026-11-06)

ADR draft 0054 (Restart Plan Part B, re-scoped against P3): skep ships as a transparent ACP proxy any ACP client spawns in place of the agent, answering the permission hop from decide(). B0: T3 Code's recorded transcripts vendored with notice, and eight live taps of @agentclientprotocol/claude-agent-acp 0.101.0 and codex-acp 2.5.0 (v1 and v2, default and asking modes) written up as the wire table in tests/fixtures/acp/README.md — both adapters speak v2 when offered, the default modes (Claude auto, Codex agent) never ask, Claude's first announce has an empty rawInput, Codex's v2 request shell-quotes the command, a shell redirect is a write the filesystem scope never sees, and options are chosen by kind, never position (grok lists allow_always first). B1-1: the I/O-free proxy core — every unclaimed line relayed as its original bytes, ids never renumbered, cancels bound to their direction. B1-2: workspace_value lifted to policy_paths with the symlink escape pinned, and the mapper — session state joined on toolCallId, per-agent presets as data rows, an unreadable call forwarded with the missing field named. B1-3: skep acp govern (allow selects allow_once, explicit or floor deny reject_once, everything else forwarded to the human, never an "always") and skep acp doctor; on ACP v1 with a client that advertised fs/terminal the hard ring passes only allow (A10, no human hop to forward to). B1-4: skep policy decisions on three faces, observed and forwarded rows counted apart from decisions (A9). The Day 5 live smoke under T3-shaped asking modes: Claude's Write allowed from fs: workspace, Codex's rm -rf build forwarded to the human, git push floor-denied for both before the client saw it, and read-only commands observed unasked. Review findings folded in before each commit (cancel direction, a shutdown abort when the agent exits first, a floor bypass through unquoted hard-ring args, observed rows only for calls that ran unasked). B2: fresh homes start with shell+filesystem on engine v2 (A6), skep acp install-hint prints T3's Local ACP command rows, and docs/acp-governor.md says what each ring does and does not see.

acp-governor B3 — the field test in T3 Code (2026-11-06)

T3 Code (Beta) with two Local ACP command providers on the branch binary, a throwaway repo bound to a demo group. Findings and fixes, on the same branch since 1.2.0 is untagged: B3-F1 install-hint prints one argument per line (the a | b | c line was pasted into one T3 row). B3-F2 every session opener binds cwd — T3 respawns the agent after idle and continues with session/load, so resumed turns decided against repo "" — and a v1 load's replayed history is not written as observed rows (A11). B3-F7 a chained shell line (ls -la; rm -rf build) is decided one simple command at a time with the least favourable segment deciding; command substitution and sh -c are opaque and match nothing — the prefix matcher had allowed the whole line by its first word for the hook and the governor, where a real shell runs it. B3-F8 SKEP_ACP_TRACE records the wire inside a client in the fixture envelope. Observed on the wire: in Claude's auto (T3's default) the agent never asks, so skep only observes; T3's Manual mode is Claude's default and asks; the agent bundled rm -rf build && … git push into one command and the floor denied the lot before T3 saw it. B3-F9 the replay window runs from any continuing opener to the client's next session/prompt — T3 races the opener's answer against two seconds of replay silence and may send its config and prompt first. B3-F10 a run-detail read tolerates a worktree swept under it (CI macOS). B3-F11 the first turn recorded inside T3 with the trace on (2026-11-09, tests/fixtures/acp/claude-agent-acp/t3-v2-resume-ask.ndjson, a golden): T3 speaks v2 and continues a thread with session/resume, and claude-agent-acp replays the thread's history on it too — seven replayed calls, zero observed rows; then git status observed, rm -rf build forwarded to the human (allow once), git push floor-denied.

v1.2.0 — the ACP governor (2026-11-09)

Published 2026-11-09; the release commit is dated 2026-11-06.

The acp-governor B0–B2 work above: skep acp govern|doctor|install-hint and skep policy decisions. Operator notes: a fresh home starts with shell and filesystem on engine v2; an existing home keeps its switch. Install with pipx install skep && skep acp doctor -- npx -y @agentclientprotocol/claude-agent-acp. ADR draft 0054 moves to docs/adr/ on acceptance.

first-run O1 — three templates in the layer format + skep policy explain (2026-11-09)

ADR 0056 D3. src/skep/supervisor/policy_templates/{builder,operator,assistant}.json are engine v2 layers — rules AND knobs (default_network, allowed_shell_commands, which the registry now lets the template layer carry) — each a complete baseline candidate for O2. personal-dev → builder, homelab-ops → operator (read-only inspection instead of the developer toolchain; GitHub fetch allowlist), assistant reshaped (calendar and notes MCP tools and mail reads flow, sends ask, repo writes denied); locked-down has no file — it is the no_baseline zero state O2/O5 ship. The four old names are aliases until 1.3.0 and print a deprecation line; skep setup --template writes the template's own knobs instead of deriving them from its rules. skep policy explain <template|baseline|role:NAME> renders the layer as a Markdown allow / ask / deny table grouped by scope — the rule ids why prints, the floor rows labelled "always denied", a settings block per scope — on three faces: the CLI, GET /api/policy/explain, and the chat policy_explain read. The harness (tests/supervisor/test_policy_templates.py) proves golden parity with each template as the baseline, catalogue membership, no floor grant, the B3 demo sequence under builder (pnpm test allow · rm ask · git push deny) and every alias.

first-run O2 — the locked baseline (2026-11-09)

ADR 0056 D1/D2, the one new mechanism of the first-run plan. skep policy approve [--template NAME | --file PATH] [--reapprove] [--yes] shows the explain table, takes a typed yes, and writes <home>/policy/baseline.json (0444, a courtesy), baseline.lock and a baseline_approved row in <audit>/policy/baseline-approvals.jsonl — SHA-256 over the loaded layer as sorted-key JSON carrying schema_version (policy_baseline.py). The baseline populates the registry's existing template layer with every set setting enforced (ADR 0053 D4); its rules ride the same slot. verify() runs in the v2 reader (policy_layers.py), mtime-cached, so policy_decide, the hook, acp govern and serve startup share it: Tampered (or a missing lock, or both files gone with an approval on record) fails closed with baseline_tampered — ask on the advisory ring, deny on the governor's hard ring, dispatch refused, the Queen's own lanes asking — with one card per tamper event (debounced through the ledger) and why printing baseline: TAMPERED since <time>. A schema bump with unchanged content cards a re-approval instead of tripping. skep policy baseline status|diff, skep policy explain baseline; REST POST /api/policy/baseline/approve, GET /api/policy/baseline; chat approve_policy_baseline (always cards) and policy_explain baseline. No baseline: byte-identical goldens; the no_baseline zero state is one constant (policy_baseline.NO_BASELINE_REASON) for O5 to flip.

first-run O3 — skep onboard (2026-11-09)

ADR 0056 D7/D8. skep onboard is the guided form of skep setup: ① model (local-Ollama probe, the v37-F3 wizard, a test call, the preset's egress line) → ② work directory (created if missing, registered through project setup with its inferred verify_command) → ③ sandbox backend (auto, podman or none; docker is reported, not offered — skep has no docker backend) → ④ template (the three explain tables, default assistant, locked through O2's approve path after a typed yes) → ⑤ role (the three template names until R1), recorded in ~/.skep/first_run.json {started_at, turns_seen, verdicts_seen, dismissed, role}; then it attaches to (or starts) skep serve and opens skep chat unless --no-chat. Each step is a function in supervisor/onboard.py writing its record to ~/.skep/onboard.json; re-running resumes at the first incomplete step (a tampered baseline sends it back to ④), and a flag that differs from a finished step re-runs it. sandbox_backend accepts none: runtime treats it like auto (never weaker), and the baseline onboard locks turns every allowed write/edit into an ask (fs-workspace-unsandboxed, coding-workspace-unsandboxed). skep onboard --check is skep doctor plus baseline hash, engine v2 scopes, sandbox backend, workdir, model, steps, and the egress-truth block ending telemetry: none; exit 0 only when all are ready. Web face: a "First run" card on the /setup page over GET /api/onboard, /api/onboard/check|sandboxes|template and POST /api/onboard/{step} — the same functions (test_surface_parity ONBOARD_VERBS).

first-run O5 — fresh homes ask until a baseline is approved (2026-11-09)

ADR 0056 D2 "Zero state". A home whose sqlite file did not exist is seeded with every scope in SCOPES on engine v2 (was shell + filesystem) and a fresh_home_seeded_at setting. policy_layers.zero_state_home is the one rule: a home the store seeded itself, or one where skep onboard has started (onboard.json), answers every decision in an engine-v2 scope ask with reason no_baseline while nothing is approved — on all four paths (policy_decide, skep policy hook, skep acp govern, the Queen's standing policy), through the same fail-closed guard O2 built (baseline_guard, now a scope → reason map). The floor stays above it. A home that predates O5 keeps today's behaviour exactly — an upgrade must not turn a running daily driver into a wall of asks — and skep doctor / skep onboard --check print no baseline approved — run skep policy approve --template <name> or skep onboard. why names no_baseline. skep acp install-hint opens with the locked baseline (template, approval time, short sha256) or run skep onboard first — the governor answers from an approved baseline; onboard --check's engine v2 probe is ready only with every scope routed. The golden files re-froze with only the seeded switch list moving.

v1.2.1 — first-run: onboard onto a locked baseline (2026-11-09, never published; shipped in v1.4.1)

Never tagged, released or uploaded: this work first shipped in v1.4.1 on 2026-11-16.

The first-run O1, O2, O3 and O5 work above, as a patch release. What an operator sees:

  • skep onboard (or skep onboard --template builder --yes) takes a fresh install from nothing to a locked policy baseline in five resumable steps; skep onboard --check is skep doctor plus the onboard rings and the egress truth.
  • Three templates — builder, operator, assistant — replace the four old documents (aliases until 1.3.0); skep policy explain <name> prints each as an allow / ask / deny table.
  • skep policy approve --template NAME locks the baseline (<home>/policy/baseline.json + baseline.lock + the approvals ledger); an edit fails closed with baseline_tampered until skep policy approve --reapprove.
  • A fresh install asks for everything until a baseline is approved (no_baseline); an existing home keeps deciding as before and is told how to approve one.
  • skep acp install-hint names the baseline the governor answers from.

Air smoke (docs/acp-governor.md): pipx install skep && skep onboard --template builder --yes, then skep acp install-hint.

first-run O4 — first-run transparency (2026-11-09)

ADR 0056 D6. While ~/.skep/first_run.json (O3's record, extended) is not dismissed, serve/chat.py first_run_events — wrapped around the one SSE choke point every chat turn and card verdict streams through — adds a one-line why to every verdict card (receipt, denial, confirm card), read off the decision the card already carries (rule, layer, reason), and ends each turn with a tally event (skep: N allowed · N asked · N denied) that bumps turns_seen / verdicts_seen. The turn that first crosses 10 turns or 25 verdicts carries the offer to turn it down. skep chat and the web chat render both; skep onboard --quiet | --verbose and POST /api/onboard/transparency flip dismissed (operator faces only, ONBOARD_VERBS). Rendering only: no new rows, no new verdicts. The tally counts the turn's own decisions, because the Queen's chat verdicts are not in decisions.jsonl. A home with no first_run.json streams exactly as before.

first-run R1 — roles as records (2026-11-09)

ADR 0055 D1–D3. A role is a record — {name, policy_layer, system_prompt, default_castes, voice} in supervisor/roles.py — and a policy context: builder, operator and assistant ship bound 1:1 to the templates of the same name; custom roles load from ~/.skep/roles/*.json. LAYERS gains role after template; the role layer only tightens (the stricter of the stack's verdict and the role's own stands) and the floor is above every role. policy_decide / policy_why take role on all three faces and decided_by names role:<name>. A chat runs in one role — its prompt, its voice, and the Queen's own tool lanes (mutation_execution_decision tightens run_shell, read_file, read_url, MCP calls under it); set_role card, /role on both decks, skep role list|show|use, and a role picker on new chats defaulting to the role skep onboard recorded.

first-run R2 — delegation is subset-only (2026-11-09)

ADR 0055 D4. policy_decide(delegation_chain=["actor@role", …]), outermost first: the innermost delegator's own effective verdict — down the same path, under its role, bounded by the hops above it — is one more tightening; when it decides, the row says exceeds_delegator and decided_by names the hop. A delegator that would itself ask passes on an ask; one whose role has no rule for the action (unset) holds nothing (decision #7). The floor is above every chain; an empty chain is today byte for byte. submit_run drops the worker's shell prefixes and egress hosts beyond the delegator (each drop a ledger row) and refuses a writer the delegator may not be; the Queen's dispatch lanes pass queen@<chat role>. why --delegated-by shows the chain.

first-run R3 — the Queen delegates: manager → team under roles (2026-11-09)

ADR 0055 D5. A worker is dispatched with its own role — role on the chat's dispatch_run and per task in batch_dispatch, on POST /api/runs beside delegation_chain, and skep run --role NAME --delegated-by ACTOR@ROLE — and holds its role ∩ its delegator's, the drops recorded under its role. Every delegated or role-bearing dispatch writes one source: delegated row (the delegator, worker@<role>, role, the chain, the task) and carries delegation (chain, role, team) on its dispatch decision; the web run card and detail, the chat lines, skep chat's /runs and skep review show queen@operator → worker@builder. A team run is v51's batch with a manager as the dispatcher — the chat's batch_dispatch manager=, POST /api/teams, skep team --manager ROLE --task REPO INSTRUCTIONS: members run under [<dispatcher>, manager@<role>], the one two-hop chain a dispatch accepts; deeper chains, a manager not innermost and any worker@ hop refuse. The team is one ledger thread (skep policy decisions --team ID). A delegated run's remembered-approval resume keeps its narrowing and its chain. The operator's dependabot loop (Queen operator → worker builder) is pinned end to end with the fake worker; the live run is the operator's.

v1.3.0 — first-run: roles and delegation (2026-11-09, never published; shipped in v1.4.1)

Never tagged, released or uploaded: this work first shipped in v1.4.1 on 2026-11-16.

The first-run O4, R1, R2 and R3 work above, as a minor release. What an operator sees:

  • A chat runs in a role (builder, operator, assistant, or a custom one): the picker on a new chat, /role, skep role use. The role is a policy layer that only tightens the approved baseline, and skep policy why --role names it.
  • The Queen dispatches under its role, and a worker it dispatches holds no more than it does: exceeds_delegator rows, why --delegated-by.
  • Workers take an explicit role (skep run --role, dispatch_run role=) and a team run — a manager in a role fanning out to up to three workers — is skep team / batch_dispatch manager= / POST /api/teams, one ledger thread. Run cards show the chain.
  • New chats show a one-line why on every verdict card and a turn tally until dismissed (skep onboard --quiet).

The four pre-1.2.1 template names are still accepted as aliases in 1.3.0 (ADR 0056 open question 3 proposed retiring them here; not done in R3).

v1.4.0 — the edge sweep (2026-11-15, never published; shipped in v1.4.1)

Tagged 2026-11-15, but its release gate failed and nothing was published: this work shipped in v1.4.1 on 2026-11-16.

1.3.0 was bumped but never tagged, so this is the first published release since 1.2.0 and carries both: the roles-and-delegation work above, and the edge sweep, a live-model campaign against the policy engine, the sandbox and the landing path (#56–#90). What an operator sees:

  • One decision point. REST, CLI, hooks, ACP, the Queen's file and shell lanes, read_url, search_web, MCP and browser calls all decide through one policy_v3.decide(). A deny binds every spelling of a command, reaches through sh -c, and a policy write is checked before it lands.
  • Taint asks before acting. A chat that has read private data or taken in outside content asks before it sends or acts; /trust clears a chat's taint. High-risk cards need your desk, repeated asks fold into one card, and a dispatch card lists what the run will get.
  • A stricter sandbox. It fails closed; it hides rc files, login stores, unused LLM keys, agent sockets and ssh-agent; a git hook can't escape it, and on Linux Landlock confines the worker. An engine's own sandbox is switched off under skep's (codex/claude_code). An opt-in provider-key relay (provider_key_relay, default off, ADR 0062) keeps the provider key out of the worker, and codex can run on a ChatGPT plan login.
  • No unverified landing. A shell worker needs a pinned verify command, landing can't half-fail beside worktree cleanup, and approvals claim a card atomically before they act.
  • Honest output. Logs and cards mask secrets and channel tokens, skep doctor and the decision log report what actually happened, follow-ups survive a restart, and skep's own log lines reach serve.log.
  • Tests. The web UI's JavaScript runs under node --test, and CI fails a PR with changed lines no test runs (diff coverage ≥ 90%).

The four pre-1.2.1 template names are still accepted as aliases.

v1.4.1 — the release gate runs a real sandbox (2026-11-16)

Published 2026-11-16: the first release since 1.2.0, carrying the 1.2.1, 1.3.0 and 1.4.0 work above.

The v1.4.0 tag was pushed, but its release gate failed and nothing was published, so 1.4.1 is the published form of 1.4.0, with one fix to the gate. scripts/linux-sandbox-docker-smoke.sh runs bwrap as root inside a container. Root's bwrap creates namespaces directly, which needs CAP_SYS_ADMIN and CAP_NET_ADMIN; Docker drops both and its default seccomp and AppArmor profiles refuse the mounts. Before ES-F1 skep then ran the worker unconfined and the smoke passed without testing a sandbox; since ES-F1 it fails closed, which is what failed the 1.4.0 gate. The smoke now gives its one throwaway container those two capabilities with both profiles lifted.

Getting that far exposed a real bug: the Docker image had no ps, which the monitor and run re-adoption call, so a sandboxed run in the published image crashed. The image now installs procps.

v118 — the Queen on a ChatGPT plan (2026-11-16)

ADR 0063. An operator with a ChatGPT plan and no OpenAI API key can run the Queen on it: the openai-codex preset ("ChatGPT plan (Codex login)") talks the Responses protocol to chatgpt.com/backend-api/codex with the Codex CLI's access token, read from $CODEX_HOME/auth.json and never refreshed or written. F1 makes that login the only credential a chatgpt.com profile has (never its key file, llm-secret or an env var; set-key refuses it) and names the fix when it is missing, expiring or refused. F2 adds the two wire differences: store: false on the body and the listing's client_version query and slug shape; other providers' bodies are pinned byte-identical. F3 is the preset and its egress line and card. F4 keeps the login the Queen's alone: workers, the reviewer caste and the key relay keep the provider they had, and no run is routed or pinned to chatgpt.com.

v119 — the main key stays on its own endpoint (2026-11-17)

F1 closes a leak from v108-F4. A provider profile with no key of its own fell back to the legacy llm-secret / SKEP_LLM_API_KEY whatever its host, and the ticker's health sweep probed every profile, so the main key went to each keyless profile's endpoint every five minutes. The legacy secret now goes only to the endpoint it was saved for: the saved base URL, or, with none saved or the Queen on the ChatGPT plan (ADR 0063), the workers' profile.json endpoint. That covers the health probe, the chat resolver and the worker's own fallback. A profile elsewhere is called without a key, which is right for a local server. A remote one fails, and the health row and skep doctor say to give it its own key (skep provider set-key <id>). A single-provider home whose saved base URL and profile.json agree, which is every home configured through the daemon, is unchanged.

v1.4.2 — a thread-first web UI, the Queen on a ChatGPT plan (2026-11-18)

Everything merged since 1.4.1 (#93, #94, #101):

  • v117: a chat keeps the project you pick and starts in workspace; the Queen can create projects.
  • v118: the Queen runs on a ChatGPT plan, with the Codex login as a provider.
  • v119: the main key stays on its own endpoint.
  • v120-F1: zsh here-documents work inside the macOS sandbox (TMPPREFIX is set beside TMPDIR; /tmp stays closed).
  • H1, H1-G, Graphite A: the web UI is thread-first (sidebar, Inbox, context panel) in the Graphite look; Policies opens on what agents may do, and Settings and Setup are one place each.

v1.5.0 — the daily driver: alarms, a policy tree, workers that land (2026-11-19)

Everything merged since 1.4.2 (#102, #104–#114):

  • graphite-nav (#102): the sidebar's bottom links become one Settings gear, with every page inside it.
  • v121 (#104): when a scheduled prompt tries an off-menu tool call, an alarm goes to the chat's bound channel; Telegram link previews are off so they can't leak notes; script and chained schedule output is marked private and untrusted when a chat reads it.
  • v122 (#105): research, YouTube transcripts and a 16:30 mail summary (python -m skep.mcp_servers.mail --digest 5) work from your phone.
  • v123 (#106): a schedule can only narrow what its workers may do.
  • v124 (#107): Policies gains a browsable tree that explains the shipped rules, and "Test an action" can check a role or a role-bound schedule.
  • v126 (#108): unedited seed skills refresh, template grant changes are audited, and worker-written memory stays out of the Queen's automatic context.
  • v127 (#109, #112): workers that can do the work they are given; re-verify installs Node dependencies from a supported lockfile for a recognized verify command. --auto-approve is retired: it still parses and has no effect; a patch lands without a click only when the project turns on auto_apply_verified_patch and pins a real check.
  • docs-site (#110, #111): the website is rebuilt on Astro, every claim checked against the code; the hand-written site is gone.
  • v128 (#113, #114): fixes from a browser field test of the Queen: it calls tools in parallel on the ChatGPT plan again, /workon moves the chat onto its new project, and object results in commands and cards show labeled fields instead of a raw JSON dump.

v1.6.0 — your phone runs skep: one conversation, HIGH-risk approvals, /update (2026-11-20)

Everything merged since 1.5.0 (#116–#119):

  • v129 (#116): a Telegram-bound chat is one conversation. Replies to turns started in the web UI reach Telegram (a chat that has read private files sends only a line saying the reply stayed in the web UI), the Queen's follow-on card after a button press arrives on the phone, and a card that blocks the chat is sent again when you write from the phone; a card the phone can confirm shows what it acts on.
  • docs (#117): a guide to running skep always-on on an Ubuntu 24.04 server (docs/guide-ubuntu-server.md).
  • self-update (#118): serve checks PyPI every 12 hours and announces a newer release once; /update on Telegram (which needs channel_can_confirm on) installs it with the tool that installed skep (pipx or uv tool), checks that skep --version reports the new version, and restarts.
  • v130 (#119): a person you name as a channel's admin can approve HIGH-risk cards from Telegram, Discord or Slack (a card folding more items than a messenger can show in full still needs the web UI); the chat shows live thinking/working status; the channel deck gains /stop, /btw, /approve, /deny, /compact, /usage and /model, with command menus generated from it; Telegram photos reach the model.