ADR 0059 — policy v3: one decide(), layer-aware ceilings, scoped grants
Status: accepted for rounds P2-1..P4-2, with the operator decisions of
2026-11-10 (below). Implemented so far: P3-1 (policy_v3.decide(),
load_stack, the label vocabulary, the SCOPE_ACTIONS unmatched table and
the rotated decision log, wired to REST / CLI / hook / ACP — ES-F6, ES-F7)
P3-2 (the Queen's file and shell lanes, decisions #1 and #2 —
ES-F15–ES-F20), P3-3 (read_url, search_web, MCP and browse —
ES-F21–ES-F24), P3-4 (scoped grants — ES-F25–ES-F27), P3-5 (the
write-time check and replay — ES-F28–ES-F31), P4-1 (the trifecta guard
— ES-F28–ES-F32; the two rounds were cut from the same commit, so their fix
numbers overlap), P4-2 (fewer, better cards — ES-F33–ES-F38) and P3-6
(the tool surface follows policy — ES-F39–ES-F47).
Related: ADR 0022 (one schema), ADR 0026 (operator policy), ADR 0050
(one verb, three faces). Ledger numbers are the edge-sweep ledger's; file
anchors are at origin/main ff9f344 unless marked r1 (origin/es-policy-r1
@ bdc1e44) and may have moved since.
Question
Edge-sweep lanes F1, F3, M2 and M3 ran on the real model and showed that skep has no single policy. Five decision paths each compose a different subset of the nine layers, and every one of them has its own private fallback for "no rule matched":
| Path | Composes | Unmatched means | Evidence |
|---|---|---|---|
Queen file reads (fileio.py:67) |
global + overlay + baseline, role via tighten_autonomy |
operator roots allow, else card (a private fallback) | f1-01: REST/CLI deny the same repo file |
Queen shell (tools.py:2691) |
global (allows stripped) + baseline (allows stripped, ES-F3/F7) | card | f1-26: a baseline deny was dropped until ES-F7 |
read_url / MCP / browse (tools.py:2570, mcp_client.py:485) |
global doc only, no baseline | card / a name-substring risk ladder (mcp_client.py:115) |
f1-20: budget_transfer ran with no card; f1-27: a denied host was fetched |
search_web (tools.py:3469) |
operator policy, no role | — | f1-35 |
REST / CLI / hook / ACP (actions.py:1897,1956) |
floor → baseline guard → run view or operator doc → role → chain | deny | f1-01, NEW-F1L-04 = B77 |
Results seen live: the faces disagreed on 6 of 19 probe classes (f1-01); about
9 of the ~23 cards in F1's session were noise (cards that could not succeed,
repeat cards after a grant, "remembered" receipts that stored nothing); the
three most dangerous actions of that session (an MCP money transfer, a
private-file → search_web chain, a host-wide fetch grant) got no card.
When a card failed, the model asked policy_why / policy_rsop, got answers
that matched neither the card nor each other, and spent 5–6 extra tool calls
per incident (f1-15, f1-17). One decision function fixes UX as well as safety.
B12, root-caused (it drives V6/V7)
_within_delegation (actions.py:4374) decides every host in the worker's
compiled permissions.network under the chain, and drops any row that the
chain made stricter (narrowed_by, :4411; the drop at :4455). The
provider host was merged into that list by resolve_run_policy
(policy_resolver.py:702) before narrowing, so it goes through the same check.
- The worker's own row (
_decision_record,actions.py:1956): when the home has nobaseline_guardreason fornetwork(actions.py:1989), the run view decides. It sees the merged host as a compilednet:<host>rule →allow(f1-30:allow trusted_local_dev/net:localhost). - The delegator
queen@builder(_queen_chain,tools.py:2560): the builder role coversnetwork connect *withnet-gatedask (role_covers,roles.py:236), so its bound isrequire_approval(roles.py:319). That is stricter than allow, so the row becomesexceeds_delegatorand the host is dropped. - The worker:
llm_plan.py:213→:296"provider host … not in the task network allowlist". The registry hosts (pypi etc.) are kept because the builder role allows them, so the list isn't empty. - Retry with
network=["localhost"]: an explicit network skips the v23-F5 registry merge (policy_resolver.py:724-735), the provider host is dropped again, and the list is empty →llm_plan.py:294"require a task network allowlist".
When it fires: (a) the dispatch carries a chain from a role chat, or a
worker role (REST and CLI too, not only chat: narrowed_by also fires
on the worker's role), and (b) the home has no no_baseline guard for
network. That means an approved baseline, or an upgraded home that isn't
zero-state (policy_layers.py:152,174). The provider host doesn't matter:
ollama.com falls under * exactly like localhost does.
Why M2 (Mac) didn't reproduce it: M2's home was never onboarded (no
onboard/policy approve in its notes; created by first use, so
fresh_home_seeded_at is set, store.py:869). On a zero-state home every
network row, the worker's and the delegator's alike, is
require_approval baseline/no_baseline. The ranks are equal, so nothing is
"narrowed" and every host is kept. M2's role-less chat (a) passed no chain
at all. F1's homes were onboarded with --template … --yes, so they have a
locked baseline. To confirm on the Mac: SKEP_HOME=~/.cache/skep-sweep/m2/home skep policy baseline status should print no baseline. New row (B147, P1,
I5): on a zero-state home, delegation narrows nothing at all.
Also false today: the docstring at actions.py:4386 says a dropped host makes
"the worker then card for it". For network it doesn't. capabilities.py:809-818
asks only when the allowlist is empty; a host missing from a non-empty list
is a flat deny.
Decision
D1 (V1). One decide() every face calls
policy_v3.decide(req, *, stack, role, chain, face, taint) -> Verdict.
req = (scope, action, value, attrs). attrs carries facts the matcher
needs: the resolved path, the URL's parts, the argv segments, an MCP
readonly flag. Verdict = {verdict, layer, rule_id, decided_by, chain, deferred, tier}. It is pure over a Stack loaded once per request by
load_stack(store, home, repo=, chat=). Every call appends to
audit/policy/decisions.jsonl (rotated at 10 MB), which V11's replay needs.
| Face | Today | Routes through decide() as |
|---|---|---|
| read_file / search_files | fileio.py:67 |
filesystem.read, face=queen |
| run_shell / start_process / stop_process | tools.py:2691, :5127 |
shell.run / run_background / run_repo |
| read_url (grant + card lanes) | tools.py:2570, :3671 |
network.fetch, attrs=url |
| search_web | tools.py:3469 |
network.search, with role and taint |
| call_mcp_tool, browser | mcp_client.py:485 |
mcp.call / browse.*, attrs.readonly |
| dispatch_run, quick_edit, run_code, batch_dispatch | actions.py:4570 (no chain: B22) |
dispatch.delegate with chain, then D3 compiles the permissions |
| every other mutating tool | tools.py:5127 → None → card |
the TOOL_SCOPES map or ALWAYS_CARDS (D7) |
| REST decide, CLI decide/why, hook, ACP | actions.py:1897, app.py:735, cli_cmds.py:2695, acp/govern.py:114, policy_why :2181 |
the same call, face=advisory/hard |
run compile (serve, CLI skep run, scheduler, resume) |
resolve_run_policy + per-face provider merges (scheduler.py:213, cli_cmds.py:775,841) |
one compile_permissions() that calls decide() per host and prefix |
| worker capabilities | the compiled task.permissions |
unchanged shape: it consumes the compiled artifact (see Disagreements) |
| unattended turns (prompt schedules, continuations, channels without confirm) | the refusal set in chat.py | face=headless: ask → deny |
Deleted: the MCP name-substring ladder (mcp_client.py:115), the browse
ladder (:109), _fetch_grant_lane's private global-only resolve,
_OPERATOR_LANES special-casing (actions.py:1891), the role-less search
call, and decision #7's "a delegator's unset is deny" (roles.py:236;
unmatched is now ask, so the child gets a deferred ask). Turned into
rules: operator roots become generated global allows
filesystem read <root>/**. The Queen guard, git floor and secret floor
become the floor layer, evaluated first, as today. The v83-F9 repo pen
becomes the unmatched default of shell.run_repo. Kept outside
decide(): no_such_path (a validity check, not authorization), the
sandbox walls (I12), the patch card and G10 (I1, I2).
"Unmatched" means one thing: each (scope, action) in SCOPE_ACTIONS
carries its unmatched verdict. It is ask everywhere except
shell.run_repo, which is deny. REST, CLI, hook and Queen all read the
same table (fixes B77).
D2 (V2). Deny > ask > allow, layer-aware
Inside a layer, the most specific rule wins (so pypi.org allow beats *
ask inside the builder template). Across layers, each layer's hit is
classified as follows:
| Layer | Can grant | Binds as a ceiling |
|---|---|---|
| floor | never | always deny |
global document (skep setup) + overlay |
yes only while no baseline is locked; tighten-only after (B30) | denies, non-* asks |
| template = the locked baseline | yes | denies, non-* asks |
| role (chat or worker) | never (as today's tighten) |
denies, non-* asks |
| phase / group / project | yes | denies, non-* asks |
| grant (once/session/project/global, D4) | yes | never |
| dispatch (a card-approved manifest, D6) | yes, for that task | — |
| delegation chain | never | the delegator's verdict; its ask passes as deferred (D3) |
A * ask is a default, not a ceiling. shell-learnable *,
net-gated *, net-fetch-gated * and mcp-gated * say "ask unless
someone granted this". A grant answers them. A deny or a named ask binds.
Order: floor deny → any binding deny → any binding ask → any allow from a
granting layer → defaults and unmatched (ask, or the SCOPE_ACTIONS verdict)
→ delegation cap → taint (D5) → face (headless: ask → deny). decided_by is
always <layer>[:<name>]/<rule_id>: floor/, global/, template:builder/,
role:assistant/, group:node-dev/, project:<id>/, grant:session/<id>,
dispatch:<task>/, delegation:queen@builder/…, default/unmatched,
taint/…. That is one vocabulary instead of four (B79). The card's why-line
is rendered from it, which kills the false "no policy rule covers this tool"
at onboard.py:580.
This fixes B56 (a learned grant answers the role's * ask) and B30 (a stale
setup document can't lift the baseline), and B12's chain half follows from it.
D3 (V6 + V7). Supervisor resources; ask delegates as a deferred approval
- V6a, this ADR.
Permissionsgainsprovider_hosts: list[str](each entryhost:port).compile_permissionsfills it fromconfigured_provider_hostsforneeds_providercastes. An external engine gets only its ownnetwork_host(B140)._within_delegationnever sees it, because skep's own LLM endpoint isn't a grant the chain holds. llm_plan/document/reviewer checkprovider_hosts ∪ network. The netproxy admits a provider entry by exacthost:port, solocalhoststops opening every loopback port (f1-30). This closes B12. - V6b, deferred: the worker never holds the key. netproxy is a CONNECT
tunnel, so it can't inject a header into TLS. Masking needs a
supervisor-side relay that the worker reaches over plain HTTP and that
forwards over TLS with the key. That needs its own design (sandbox
loopback, B05). Until then
llm-secretstays readable to LLM castes only (B125). - V7. A narrowed host or prefix is no longer dropped. It moves to
Permissions.network_ask/shell_ask.capabilities.py:809returnsrequire_approval(the same gate path asnetwork_allowlist_missing). The card names the chain ("worker@builder asks network.connect X — delegated by queen@builder, which would itself ask"). The approval is bound to(task_id, capability, value)and dies with the run. Approving the dispatch manifest (D6) pre-answers the listed asks. On a headless face the deferred ask is a deny. B147 is fixed because decide()'s delegation cap compares verdicts, not the baseline-guard placeholder.
D4 (V8). Scoped, expiring grants
Grants are LearnedRules with three new fields: lifetime, matcher, and
bound (repo/project_id/chat_id). They stay in the one learned list,
so this adds no new store.
| Lifetime | Lives | Bound to | Offered by default |
|---|---|---|---|
| once | the card itself, no row | — | always |
| session | until serve restarts | chat (Queen) / repo (worker, read only since ES-F293): B39 | yes (default, Queen cards) |
| project | durable | project_id | worker cards, Queen in a repo context |
| global | durable | — | only untainted, only after V11 passes |
| Matcher | Matches | Fixes |
|---|---|---|
exact_argv |
normalized argv; a compound line stores one grant per segment, offered only if every segment is grantable | B04, B61 |
host |
an exact host (network.connect) |
— |
subdomain |
*.x.com: exactly one label, never crosses a dot |
— |
path_prefix |
realpath prefix on a directory boundary | read widening (V4) |
url_prefix |
scheme + host + path prefix; the query must be empty or identical to the card's | B74 / NEW-F1L-05 |
mcp_tool / mcp_server_reads |
server:tool / readonly tools of one server (F3 lesson 4) |
B09 noise |
Never offered: *, a bare scope, a guarded class (remote git, outbound
content, dangerous prefixes). Fixes:
- B59: a keep on a subject that is already granted upgrades its lifetime in place and returns it.
- B21:
start_processstoresrun_background. - B18: worker "Allow & remember" writes a
projectgrant, not the enforcedallowed_shell_commandsknob (actions.py:3506). - B101: on
no_baseline, grants apply (each is a human's explicit approval) and everything else asks. Tampered: nothing applies. - B23: see D6. At decide time, a grant that intersects a binding deny is ignored and logged, not raised through every lane.
- B32: a keep the tool can't honour is a 400 naming the tool's ALWAYS_CARDS reason.
D5 (V9). Trifecta guard: two taint bits plus provenance
chats.taint holds two bits. Each bit records the first message id that
set it.
| Bit | Set by |
|---|---|
private |
a Queen read resolved outside the operator roots (card-confirmed or grant-allowed), any run_shell/start_process output, a search_files hit outside the roots |
untrusted |
results of read_url, search_web, browse, MCP calls (except operator-flagged trusted servers); chat rows whose provenance isn't operator or queen (webhook, channel non-operator, script output) |
| State | Effect at decide() |
|---|---|
| private only | egress that carries model-chosen text (network.search, network.fetch, outbound mcp.call) → ask, even if granted |
| untrusted only | consequential actions (every mutating tool, dispatch, non-read MCP) → ask, even if granted |
| both | all of the above plus every egress → ask; tier HIGH; keep offers shrink to once |
A tainted chat is never offered project/global egress grants. A dispatch
records the chat's taint on its decision, and the run card shows it.
Provenance (B26): chat_messages.provenance takes one of operator,
queen, tool, webhook:<id>, channel:<platform>:<user>, schedule:<id>
or worker:<task>. Webhook text is stored as role=user, never
assistant (webhooks.py:150). Replay wraps every non-operator, non-queen
row in <untrusted source="…"> inside a user turn, and its presence sets
untrusted. The observer and curator read only operator and queen rows
(the B113 class).
D6 (V10 + V11). Fewer, better cards; analysis on every write
- Manifest card at dispatch: the dispatch card lists the compiled hosts,
network_ask, shell prefixes, write roots, engine, mode, verify pin, chain and taint. One approval covers them, and anything outside them gets a per-call gate card. - Folding: pending cards with the same
(tool, scope, matcher subject)in one chat fold into one card with an item list. Confirm or deny resolves them all. HIGH cards never fold. - Tiers:
- LOW runs without a card (granted, inside the roots).
- MEDIUM gets the ordinary card.
- HIGH looks different, offers no keep beyond
once, never folds and is never channel-confirmable. HIGH covers: script schedules (create, replace-by-name,chain), any doubly tainted action, non-read MCP on a server without trust, policy writes, engine change,network ["*"],register_mcp_server, forge install, and pack promotion. - The script-schedule card (F3 lesson 1) shows the command, interval, scrubbed env list, the next 3 fire times and chain targets, and states "runs as you, on this host, unattended, until disabled".
- Success measure: re-run F1's t01–t24 and M3's card script. Noise
cards are those whose confirm returns a refusal, cards whose subject a
live grant covered at proposal time, and keep receipts that stored
nothing. Target: noise = 0 (from ~9), total cards ≤ 12 (from ~23), and
the three dangerous actions each get a HIGH card. A test computes the
counts from
chat_actions+decisions.jsonl. - V11 on every policy write:
learn_policy_rule(actions.py:4672),set_operator_policy_rule(:3926),PUT /api/policy, group set/attach,project setup,skep setup --template, and baseline approve/reapprove. Each one builds the would-be stack and runs §5.4 checks 1–6. A failure rejects with the deny's name (B23 write half). Each write also replays the last 200decisions.jsonlrows against the new stack and shows what flips on the card ("now allows 3 past asks: …").skep setup --templatekeeps learned grants and shows them in its diff (B38).
D7 (V12). Tool surface follows policy; roles everywhere
- Hide tools: a tool is hidden from a chat when decide() is a binding
deny for its scope/action for every value (assistant:
dispatch_run,quick_edit; B22). - Map every mutating tool: each one maps to
TOOL_SCOPES(tool → scope, action, value extractor) or sits inALWAYS_CARDSwith a one-line reason. A test fails on any unmapped mutating tool (B32). - Truthful descriptions: each description gets a generated "In this chat:" line rendered from decide() (e.g. "reads inside ~/repos run; elsewhere asks; credential files never"). A test pins the rendering, so the line can't drift from the policy (B33 class).
- B20:
set_operator_policyacceptsshell, with exact-argv allows and any denies, written to aqueen.shelloverlay. That is also the only sanctioned home for a Queen host-shell deny (NEW-F1L-01's gap). - Roles (B55):
create_chatrequires a role. Channel chats (channels/runtime.py:171) getassistant(F3 lesson 5). Analysis chats (chat.py:2222) getoperator. Hermes-import (hermes_cmds.py:233) and the policy-baseline chat (actions.py:2058) get the default role.role_for_chatmaps a legacy NULL role to the default role; with no default recorded it usesassistant. - B78: search_web takes the role and taint (D1).
Rejected
- Keep five lanes and patch each (what PRs #56–#61 did): every patch opened a sibling hole (ES-F3 stripped denies → B72). Faces that disagree are themselves the bug.
- A literal deny > ask > allow across all layers: a template's
*ask would out-rank every project and learned allow. That makes B18 and B56 permanent and the card loop pointless. Hence "*ask is a default". - Workers call decide() per command over IPC: it needs a worker → serve channel, which B05/B51 just closed. The compiled artifact is the contract.
- Credential injection at netproxy: impossible through a TLS CONNECT tunnel (V6b).
- A new grants table: the learned list with three fields carries the same data, and one store keeps I5 plain.
Disagreements with the plan's V-list
- B12's ledger text: the provider host is irrelevant. The switch is the baseline state (zero-state homes mask it), REST/CLI with a worker role hit it too, and the retry fails because the host is dropped again into an empty list.
- V7 is mostly built:
within_delegatoralready passes an ask. The defect is_within_delegationturning "narrowed" into "dropped", and the worker denying a host missing from a non-empty list. - V1 "worker caps call decide()": no (see Rejected).
- V2 as written breaks the card loop (see Rejected).
- V6's credential masking needs a relay, so it splits into V6a/V6b.
- V9 with only the "both bits" rule misses f1-07 (private read + search, no untrusted content), so the table has single-bit rows.
Consequences
- One verdict per action on every face.
skep policy whynames the layer, rule and chain the Queen used. - Behaviour changes that operators will see (each one is listed by the
migration dry-run):
- grants now work in role chats;
- a stale setup document stops granting once a baseline is locked;
- REST and the hook answer ask where they said deny;
- search_web asks after a shell or outside-roots read;
- assistant chats lose
dispatch_run; - channel chats become
assistant.
decisions.jsonlgrows with every Queen call (it rotates).- V6b and the per-server MCP "trust reads" UI are follow-ups.
Migration
| Home state | What v3 does |
|---|---|
Locked baseline with the legacy fs-read * (f1-06) |
template_layer() drops an exact legacy filesystem read * allow from a baseline that names a shipped template, after verify (narrowing only). doctor says so. --reapprove --template adopts the shipped file. |
No policy_engine_v2_scopes (B31) |
v3 has no v1/v2 split, so every scope routes through decide(). The setting is ignored and then removed. |
| Learned rules | Shell rules → exact_argv, global. A compound pattern splits per segment, and one that can't be granted is dropped and logged. Host-wide fetch grants → host matcher, labelled legacy-host and listed by doctor; taint still gates them. |
| Worker session tier | Cleared at restart anyway; new grants are repo-bound. |
Project knob allowed_shell_commands |
Still read; new remembers go to project grants. |
| Groups (ADR 0048) | Unchanged; they are a granting layer, and V11 runs on their writes. |
| NULL-role chats | Default role (D7). |
skep policy migrate --dry-run replays the home's decisions.jsonl
(V11's replay) under v3 and prints every flip. onboard --check and doctor
print the same summary. skep policy approve --reapprove gains --diff,
which shows the V11 flips before it re-locks.
Test plan
- §5.4 property test, extended: template × role(none + 3) × face × taint × chain depth(0, 1). Checks 1–6 are unreachable. Check 5 covers "a child never holds an allow its delegator lacks"; the child may hold a deferred ask.
- Cross-face equality: f1-01's 19 probes × 5 homes give one verdict and
one
decided_byacross Queen, REST, CLI, hook and ACP. - Regressions, one per ledger row: B12 (role chat + locked baseline,
localhostandollama.com), B147, B56, B59, B21, B61, B74, B39, B18, B101, B23, B30, B31, B77, B78, B79, B20, B22, B32, B55, B26, B75/f1-07. - Card-noise metric test (D6) over a scripted F1 transcript.
- Every gate in CLAUDE.md, plus
pytest -m smoke.
Implementation rounds (each ≤ ~600 lines, shippable alone)
| # | Round | Closes |
|---|---|---|
| P2-1 | V6a: provider_hosts, host:port matching, external engines get only their own host |
B12, B147-partial, B140 (merge) |
| P2-2 | V7: network_ask/shell_ask, chain-naming gate cards, headless deny; dispatch_run_decision consults the chain |
B12 residue, B22 (card half), B147 |
| P3-1 | policy_v3.decide() + load_stack + labels + SCOPE_ACTIONS unmatched table, wired to REST/CLI/hook/ACP only; decision log |
B77, B79, B34 rest |
| P3-2 | Queen file + shell lanes → decide(); operator roots as rules; *-ask-is-default; global doc tighten-only under a baseline |
B30, B56 (shell), B31, B01-upgraded |
| P3-3 | read_url, search_web, MCP, browse → decide(); ladders deleted | B29, B09 residue, B78, B56 (network) |
| P3-4 | V8 grants: fields, matchers, lifetimes, the remember paths (Queen + worker + session tier) | B04 rest, B18, B21, B39, B59, B61, B74, B101, B32 |
| P3-5 | V11: write-time checks on every writer, replay diff on cards, migrate --dry-run, --reapprove --diff |
B23, B38, B31 signal |
| P3-6 | V12: hidden tools, TOOL_SCOPES/ALWAYS_CARDS, generated descriptions, set_operator_policy shell, roles at chat creation |
B20, B22, B32, B33 class, B55, NEW-F1L-01 |
| P4-1 | V9: taint bits, provenance column, replay wrapping, observer filter | B26, B75, f1-07 |
| P4-2 | V10: manifest card, folding, HIGH tier, script-schedule card, noise metric | F1 noise, F3 lesson 1, B111 (card half) |
P2-1/P2-2 don't need decide() and ship first. P3-1 must land before P3-2–6. P4 needs P3-3 (taint is a decide() input).
Invariants touched
I5 (one boundary, no private fallbacks), I6 (headless ask → deny, HIGH never
channel-confirmable), I8 (one label vocabulary, honest receipts), I9
(generated descriptions, a hidden tool beats one that can't succeed), I12
(provider hosts as host:port, V6b), I13 (every face's decision recorded).
I1, I2 and I4 are untouched: the floor and the patch card stay above
decide().
Operator decisions (2026-11-10)
- A catch-all
askis a default, not a ceiling. Approved grants (session/project/always) answer a role's or baseline'sask *; explicit denies and the floor still win. Closes B56, B18. - Under a locked baseline, the
skep setupdocument can only tighten. Closes B30. Old allows stop granting on homes that also have a baseline. - Any
run_shelloutput sets the chat's "read private" taint, so latersearch_web/read_urlin that chat card. Closes the f1-07 leak. - Every role-less chat →
assistant. This includes channel chats, analysis chats and legacy chats. It is stricter than the ADR's proposal (analysis → operator, legacy → default role); the operator chose the strictest option. Closes B55. - Not asked; the ADR default stands: V6b (proxy-held provider key) is deferred until a relay exists.
Implementation status
P3-1 — implemented (ES-F6, ES-F7)
src/skep/supervisor/policy_v3.py. REST policy/decide, skep policy decide / why, GET /api/policy/why, the policy_why read tool, the
Claude Code hook, skep acp govern and the dispatch's delegation narrowing
call decide(). Unmatched: ask (deny for shell.run_repo), B77. Labels:
B79, B34. The decision log redacts inline credentials and rotates at 10 MB.
Deliberately not yet: decision #1 (* ask is a default) and #2 (global
document tighten-only), which change verdicts and belong to P3-2; taint
and tier (P4); a chat= stack input (P3-2). Still as before, though D1
lists them as gone: network.search / fetch answer from the operator
document (policy_v3.OPERATOR_LANES, moved, not deleted); a delegator whose
role has no rule holds deny (decision #7, roles.within_delegator); a
request carries no attrs.
P2-1 — implemented
Permissions.provider_hosts (host:port, contract 0.3.6), filled by
provider_hosts_for() and overwritten in run_task; the delegation
narrowing never sees it. B12, B140 (merge half). Not done: loopback stayed
open to every port but serve's (v115-F9) until D6 closed it (ES-F91, row
R2a); V6b (the worker never holds the key).
P2-2 — implemented
network_ask / shell_ask (contract 0.3.7): a grant the chain turns into
an ask is the worker's deferred ask where a human answers, approve-once for
that run; a deny, a headless dispatch, a wildcard and a guarded prefix are
dropped. dispatch_run_decision consults the chain (B22, card half). With
P3-1's unmatched = ask, a per-dispatch network host no rule covers is a
deferred ask on a delegated run, or dropped where no human answers. B147
(ES-F45, after P4-2's manifest): on a home with no approved baseline a
delegated worker's grants are deferred asks where a human answers (dropped
where none can); the dispatch card lists them and the desk's confirm answers
them for that run, so a sandboxed install reaches its registry; a chat
dispatch the project would auto-allow cards anyway when its sandboxed run
would ask about a host (manifest_asks), on every home (workspace mode has
no proxy; a shell ask is the worker's own card). Since ES-F150 (D23)
quick_edit, batch_dispatch (one manifest per run, a team's under its manager
hop) and forge_tool cards carry the same manifest and the desk confirm
answers each run's listed asks; an auto-allowed quick_edit or batch whose
sandboxed run would ask cards first; a first forge card lists nothing (its
confirm sets the forge repo up, which decides the hosts). Not done: the
proxy cards no ask host the card did not list.
P3-2 — implemented (ES-F15–ES-F20)
read_file / search_files decide filesystem.read, run_shell /
start_process / stop_process shell.run / run_background /
run_repo, through decide() (policy_v3.queen_decide, actor queen in
the decision log): the verdict and decided_by REST, the CLI and the hook
give with no repo. D2 inside decide(): per layer the most specific rule
wins; across layers any deny, then any named ask binds; decision #1 — a
role's catch-all * ask yields to the Queen's learned grant
(grant:session / grant:global on the operator lane, shell and filesystem
only) (B56) — not to the worker session tier (the run lane's
grant:session, a prefix held for every repo, B39, which stays open), and
not yet to a fetch or MCP grant (P3-3); decision #2 — under a locked
baseline the setup document's allows leave the operator lane (B30). Operator
roots are generated global/operator-root rules, consulted where no
explicit rule matched (the fallback they replace, so they never outrank
one). B31: the operator lane composes the baseline in every scope. B23 /
§5.4 #6: a learned rule inside a deny is ignored and named
(ignored_grants), not raised. B01-upgraded: template_layer drops a
legacy filesystem read *; doctor and onboard --check say so, and when
setup-document allows stopped granting. A frozen table
(tests/fixtures/policy_v3/pre_p3_2_queen_verdicts.json) holds the lanes to
their pre-P3-2 answers. Differs from the D2 table, on purpose: only a grant
answers a role's * ask — a template, phase, group or project allow does
not yet (the round's rule: no loosening but a human's grant); the operator
overlay (set_operator_policy) still grants under a baseline — decision #2
names only the setup document. Not yet: face=headless is no decide()
input (unattended turns keep chat.py's refusal, unchanged); baseline_guard
still reads policy_engine_v2_scopes for no_baseline; the repo pen's
background refusal and no_such_path stay outside decide(); read_url /
search_web / MCP / browse (P3-3), the run compile and the ops bounds still
read the setup document's allows and raise on B23.
P3-3 — implemented (ES-F21–ES-F24)
read_url decides network.fetch <host>, search_web network.search (value
ddgs, never the query), call_mcp_tool mcp.call / email.read·send /
browse.read·act (value server:tool, never the arguments), through
decide() with the chat's role (policy_v3.queen_decide, actor queen).
read_url's card lane re-decides after the confirm (a deny refuses and
nothing is fetched, f1-27) and every redirect hop re-decides (the granted
lane follows allowed hops only; the card lane refuses a denied hop, where it
followed every hop before). The baseline reaches all four (B29), a tampered
or zero-state home asks, a learned grant answers a role's catch-all
net-fetch-gated / mcp-gated ask (B56, network half), search_web follows
the role (B78). read_only is a decide() input (REST read_only, CLI
--read-only): the server's readOnlyHint plus a leading read verb, an
email read, a browse page-state read. A template mcp.call allow grants
only a read-only tool (calendar:* covers the calendar server's reads,
never delete_event: B09 residue); an unmatched read-only request answers
default/read-only allow, the read default the ladder held. Deleted:
_fetch_grant_lane (the global-document-only resolve), the role-less search
call, _mcp_scope_lane (the MCP risk ladder's and the browse ladder's
decision halves; classify_mcp_risk / classify_browse_action stay, as
inputs), roles.tighten_autonomy. A frozen table
(tests/fixtures/policy_v3/pre_p3_3_net_verdicts.json) holds the lanes to
their pre-P3-3 answers. Differs from D1, on purpose: OPERATOR_LANES stays
— the Claude Code hook's WebFetch / WebSearch from a checkout would
otherwise be decided by the worker's run policy; the operator overlay's
network fetch allows (set_operator_policy) do not grant read_url yet
(operator decision, policy_v3.operator_lane): recorded and named by
policy why (overlay_fetch_allow), while its fetch denies and asks bind.
Not yet: grant matchers and lifetimes (a fetch grant still covers its whole
host, any path or port — B74 is P3-4); taint (P4-1); HIGH cards for non-read
MCP (P4-2); face=headless (unattended turns keep chat.py's refusal); the
decision log does not record read_only; no MCP server trust flag exists to
probe. Old helpers that keep callers: resolve_operator_policy
(rsop_view's operator section, set_operator_policy_rule's deny vetting,
policy_golden), queen_global_document / queen_template_layer
(policy_v3.operator_lane, resolve_operator_policy,
policy_layers.operator_layers).
P3-4 — implemented (ES-F25–ES-F27)
LearnedRule gains lifetime (session / project / global; once
writes no row), matcher and bound (repo / project_id / chat_id) on
the one learned list; a row without them loads as it always matched
(lifetime_of / matcher_of: session by provenance else global; shell
exact_argv, network host labelled legacy-host, else glob) and an
unbound row applies everywhere it did. Every remember path writes one: a
Queen card keep (remember_action_for_session) — read_url a url_prefix
(scheme + host[:port] + the path's directory, the card's query or none; dot
segments, userinfo and backslashes never match: B74), run_shell exact_argv
per segment of a compound line, offered only if every segment is grantable
(B61), start_process run_background (B21); session is bound to the chat
(B39), always is global and unbound. A worker plain approve was a session
grant bound to the repo (B39: the global session_allowed_shell_commands
tier is no longer read or written) until ES-F293 (D43): it is now one
decision and writes no grant, since the gate card offers none; "Allow & remember", --allow-command,
the ledger remember and allow_shell_command repo= write a project grant
bound to the project, or the repo when it has none (B18: not the knob a
locked baseline enforces) — both argv prefixes in the compiled allowlist
(worker_shell_grants, minus any a setup-document or baseline shell deny
intersects), unchanged in meaning. A keep on a subject already held upgrades
it in place or reports what holds (B59). decide() takes chat= (via
load_stack) and url= (REST and the CLI pass a URL as the network
value); in a line with a lone & a run grant covers nothing (B21); on
no_baseline a grant-labelled allow on the operator lane applies, still
under every deny and named ask (B101); a tampered baseline applies nothing.
A keep the card cannot honour is a 400 before it runs, and card.keep lists
only the keeps the server honours (B32, item 10). Receipts carry lifetime,
matcher, bound, status; allow-command answers remembered: project:<id> / repo:<path>. skep doctor lists legacy-host fetch grants.
A frozen table (tests/fixtures/policy_v3/pre_p3_4_grant_verdicts.json)
holds every grant kind to its pre-P3-4 answers. Wider, by decision: B101 (81
zero-home cells), B18 (one cell per locked home) — and the kept subject
itself where the keep used to store something that never matched (B21: the
start_process command; B61: the compound line and its segments). Not done:
the subdomain, path_prefix, mcp_tool matchers (MCP grants stay a
glob); the allow-host worker remember and the ledger's network remember
now store a project grant on network.connect <host> too (ES-F48, B18's
network half: bound to the project or the repo, read by the run compile,
dropped there under a setup-document or baseline connect deny, receipts name
the binding); the Claude Code hook decides WebFetch by host, so a
url_prefix grant does not cover it (stricter); redirect hops are decided
by host only; project lifetime is not offered on Queen cards; legacy
unbound session rows keep matching until the serve restart drops them.
P3-5 — implemented (ES-F28–ES-F31)
One write-time check, policy_write.vet_write, called by every policy
writer before it stores anything: store_grant (so learn_policy_rule /
allow_fetch_domain / allow_mcp_tool, every card keep, the worker plain
approve and "Allow & remember"), set_operator_policy_rule, update_policy
(PUT /api/policy, set_policy, the knobs skep setup --template writes,
onboard's sandbox knob), set_policy_group, attach_policy_group, project
setup (setup_project_record), skep setup --template's document, and
baseline approve / --reapprove (REST, CLI, the card, onboard). It composes
the WOULD-BE operator stack (the store's settings with the write's pending
values over them, a candidate baseline composed as template_layer will
compose it once locked) and runs §5.4 checks 1, 2, 3 and 6; a finding the
current stack does not already hold refuses the write
(PolicyWriteRejected, a 400 on REST and chat) naming the rule and layer
and what would be accepted, and nothing is written. 1: an explicit read
allow (not a generated operator root) matching a secret-floor probe. 2: a
read allow whose literal directory lies outside every operator root, while
decide() allows network fetch, connect or search to an unnamed host. 3:
decide() allows a probe install or networked line on the Queen's host
shell (run or run_background). 6: a new allow — a grant (vetted unbound) or
an overlay rule — intersecting a deny of the setup document, overlay,
baseline or the confirming chat's role, or the floor (B23 write half).
Deleted: the three private vetting paths (store_grant's and
_denied_grant's resolve() + LearnedRuleRejected,
set_operator_policy_rule's resolve_operator_policy deny scan and its
dry-run that refused a deny over a learned grant). A deny is always
accepted: a grant it newly shadows is a warning, decide() ignores it as
before. Each write replays the last 200 decisions.jsonl rows (.1 first)
under the current and the would-be stack and reports the flips, by count,
with rule ids and two short examples each; advisory, never blocking. A
policy-write card is checked at PROPOSAL (tools.policy_write_preview): a
refused one gets no card, the model gets the refusal (B22's lesson); a
passed one carries replay and policy_warnings; a keep-able card carries
the replay of an always keep, or only once with keep_refused when the
check refuses its grants. B38: skep setup --template keeps every learned
grant, the Queen's and the workers', and lists them in its diff; one the new
document's denies collide with is dropped with a line naming the deny. skep policy migrate --dry-run replays the log under today's stack against each
row's logged verdict, lists the §5.4 combinations the home already holds and
the B31 upgrade (a locked baseline on a home whose policy_engine_v2_scopes
misses scopes), and writes nothing; doctor and onboard --check print its
one line when there is something to say. skep policy approve --diff shows
the replay before the lock. B82: PUT /api/policy keeps
card_timeout_seconds and answers 400 naming an unknown key. Differs from
§5.4 / D6, on purpose: check 2 counts network search as egress (the f1-07
pair), so with the default operator document's net:search * allow, a new
read allow outside the operator roots is refused until search is denied;
check 3 is probed through decide(), so an exact-argv grant of one line
passes (a human approved that line). Not here: check 4 is the sandbox's (its
probe tests); check 5 is _within_delegation at dispatch. The run lane
(groups, project overlays, knobs) carries no rule checks 1–3 read, so its
writers run the check on an unchanged operator stack. Replay limits, counted
as "not replayable" with the reason, never guessed: rows decided in a repo
(the run lane is not replayed), delegated rows, values the log redacted,
read_only requests (the fact is not logged), network.fetch (the URL a
url_prefix grant needs is not logged), rows a chat-bound session grant
decided (the chat is not logged), unreadable rows; rotation beyond .1 is
gone. Not done: grant writes stay an unlocked read-modify-write on one
setting (a compare-and-set in store_grant would need the store to expose a
conditional set_setting); check 1 probes fixed paths (a rule covering only
some repo's .env passes; the floor still denies the read); the replay does
not record the chat or URL to make those rows replayable.
P4-1 — implemented (ES-F28–ES-F32)
chats.taint holds two bits, private and untrusted, each the id of the
first message that set it (additive column, NULL = no taint; sticky — only
the operator's /trust clears them (ES-F58: the web and terminal decks,
POST /api/chats/{id}/trust, an interactive skep trust; never a model
tool, a chat's shell or schedule, a clarification button, a channel or an
unattended turn; recorded in audit/policy/taint-cleared.jsonl and a system
line, and rows up to trusted_through stay wrapped but no longer set a
bit), compaction never touches them, a serve restart reloads them). Fail
closed: a missing chat or an unreadable value reads as both bits. decide()
applies them last before the face (policy_v3.taint_verdict, from
Stack.taint, loaded by load_stack(chat=)): only an allow moves, to an
ask labelled taint/private-egress (private: network.search /
network.fetch, a non-read mcp.call, email.send, browse.act),
taint/untrusted-action (untrusted: the shell lanes, a non-read MCP call,
and every Queen mutation allowed outside decide() — an auto-dispatch,
quick_edit, run_code, batch_dispatch, remember — asked as
dispatch.delegate) or taint/trifecta (both: those plus every egress, the
card tier: high, keeps once only). A deny (the floor too) stays a deny;
an ask keeps its own label; the delegation-cap recursion runs untainted.
REST, the CLI, the hook and ACP carry no chat: no taint. Set by
(serve/taint.py): private — a read_file resolved outside the operator
roots, search_files hits outside them, any run_shell / start_process /
read_process_log output (decision #3), an email read; untrusted — read_url,
search_web and every MCP reply (no trust flag exists), and every row whose
provenance is not operator / queen / tool (set in the same write); a read of
another chat (search_chats, get_chat_messages, get_chat_context) or an
analyst's answer carries that chat's bits; analysts start with the
delegating chat's bits. Not set by: a read inside the roots, a refused read,
a tool that failed. A live turn cards a taint-asked search_web (one taint
card per tool per round, the rest wait); an unattended or /btw turn refuses
it and says why. A tainted chat is offered no standing fetch grant and no
session keep its own taint would ask past (the 400 and card.keep come from
one function). Provenance (B26): chat_messages.provenance (NULL reads as
the role's author: nothing is retroactively tainted); webhook rows are
user / webhook:<name>, script output schedule:<name>, a continuation's
worker summary worker:<task> with skep's prompt as queen (B37);
allow-listed channel authors stay operator (strangers never reach a chat,
B114). Replay wraps outside rows in <untrusted source="…"> user turns
(inner tags neutralised) plus one system line; the digest keeps them
wrapped. The observer and the conversation drafter read only operator rows
(B113). A dispatch records the chat's bits (constraints.chat_taint), shown
on the run card. A frozen table
(tests/fixtures/policy_v3/pre_p4_1_taint_verdicts.json) is byte-identical
with taint none. Since ES-F50–F52: notes, tasks and memory proposals carry
the writing chat's bits (webhook and script-schedule notes untrusted),
approved memory is operator-trusted and carries none; get_run /
await_runs / list_runs and reads under the home's results/ and
worktrees/ set untrusted, the store and audit/ set private;
policy_why / policy_rsop answer for the asking chat. Since ES-F100–F102:
a /trust that clears untrusted covers the finish notice of the chat's
runs still in flight (non-terminal, a gate pause excluded) — the
worker:<task> row stays wrapped but sets no bit, at write or on replay;
the covered ids live in the chat's taint record (trusted_runs), in
taint-cleared.jsonl (runs) and on the receipt (covers_runs).
Worker-written memory carries memory_items.provenance (worker:<task>:
the run harvester, curator observations; additive, NULL = operator) and
rides the prompt wrapped with the system line — the memory block,
list_memory / search_memory results, the briefing digest's observation
lines, and every later run's injected memory
(policy_resolver.resolve_injected_memory, so the task envelope and the
builtin worker's prompt; ES-F181 — the CLI engines get no injected memory) —
setting no bit. A turn from a messenger, and the follow-up after a channel
confirm, decide with durable grants only (policy_v3.CHANNEL_CHATS, like
W24's unattended mark). Not done: a per-server MCP trust flag; taint into
workers; the worker run's injected memory is not wrapped; a shell egress
(curl -d) under private only is not gated (D5 names no shell row); HIGH
beyond the doubly tainted card and card folding are P4-2.
P4-2 — implemented (ES-F33–ES-F38)
HIGH (cards.high_tier, one function the card and every confirm call):
a doubly tainted chat; a script schedule, a chained schedule, a schedule
replacing a script by name; a non-read MCP call not allowed by exact
server:tool (no per-server trust flag exists — the operator's
allow_mcp_tool grant naming the tool is the one trust mark; a glob grant
is not); the policy writes (set_operator_policy, set_policy,
approve_policy_baseline, the allow_* grants, apply_policy_preset,
copy_project_policy, group set/attach/detach, set_role;
revoke_policy_rule narrows and stays ordinary; a card keep=always stays
the operator's choice on an ordinary card — a channel confirm never names a
keep); an explicit engine; network '*' from the call or the compiled
manifest; register_mcp_server / setup_browser; promote_tool;
promote_skill_pack. A HIGH card says so in words, holds once (a wider keep
is a 400), never folds, is never auto-allowed (a grant or auto-dispatch
allow cards as tier/high; decide() is untouched) and no messenger can
confirm it: ChatEngine.verdict_events refuses a channel: actor with a
403 naming the web UI and the taint, so Discord (button, reaction, /skep approve), Slack and Telegram all reach the refusal; the ticker still
expires one; skep chat --yes leaves one for a named confirm. Folding
(cards.fold_subject): read_url by origin, a taint-asked search_web by
lane, keyed with the rule that asked; nothing else. Folds live for one model
round; the card is emitted when the round closes and nothing can confirm
before (a card the running turn raised waits for that turn:
chat._OPEN_CARDS), so no item joins a card already shown; the one claim
(PR #61) resolves every item once. Script-schedule card: command,
interval, the env names the script gets (scheduler.script_env), the next
three runs (scheduler.next_fire_times), the chain walked, what it
replaces, "runs as you, on this host, unattended, until disabled". Manifest
(actions.dispatch_manifest, side-effect-free): hosts, provider hosts,
deferred asks, shell prefixes, write roots, engine, mode, verify pin, chain,
taint — recorded on the card; the operator confirming it at the web UI or
CLI answers the asks it LISTED for that run (moved into that run's
allowlist, constraints.manifest_preanswered); a channel confirm, an
auto-allowed and a headless dispatch answer nothing; a dispatch the policy
refuses outright is answered at proposal, not carded.
chat_actions.card_json (nullable, added in place) holds what the server
recorded. Noise metric (test_card_noise.py, F1's t01–t24 on the
fixture home): 17 cards, noise 1 — set_operator_policy scope=shell cards
and is refused on confirm (B20, P3-6). Targets: noise 0 missed by that one
card; total ≤ 12 missed (17: each remaining card is a first-time question in
its own chat — F1's repeat and dead-end cards are gone); the MCP transfer is
HIGH; private file → search is one folded MEDIUM card with the taint line
(D5: HIGH needs both bits); the host-wide fetch grant can no longer come
from a read_url keep (P3-4 stores a URL prefix) and its one remaining path,
allow_fetch_domain, is HIGH. start_research carries the same manifest
(ES-F70, L23: its source hosts the role asks on are listed and the desk
confirm answers them, so a builder chat's research run reaches its own
sources). Since ES-F150 (D23) quick_edit, batch_dispatch and
forge_tool carry it too (see P2-2). Not done: a per-server MCP trust flag;
folding of anything but read_url and search_web; a fold across rounds (by
design).
P3-6 — implemented (ES-F39–ES-F47)
Map (B32): tools.TOOL_SCOPES (tool → scope, action, value: read_file /
search_files filesystem.read, run_shell shell.run, start_process /
stop_process shell.run_background, read_url network.fetch, search_web
network.search, call_mcp_tool mcp.call, and the six worker dispatchers
filesystem.write workspace through the chat's chain) or
tools.ALWAYS_CARDS (every other mutating tool, with the reason no rule or
keep governs it; a refused keep shows it); a test fails on a mutating tool
in neither. Roles (B55, decision #4): every chat the code creates
records a role — POST /api/chats with no pick and no default, or role: "", is assistant (default_role falls back to it), as are channel,
analysis, hermes-import and policy-baseline chats; the web picker drops "no
role" for new chats. A chat whose stored role is NULL (made before every
chat recorded one) reads as assistant (roles.role_for_chat,
chat.chat_role) on every face — a turn, /btw, a run-finish continuation,
an unattended tick, a channel; no chat (REST, the CLI, the hook) is still no
role. Stored rows are not rewritten: skep role use builder --chat <id> or
/role builder gives the tools back; doctor and onboard --check count
such chats ("run as assistant") and name that command; the web picker labels
one "role: assistant (none stored)". The P3-4 / P3-3 / P4-1 frozen grids'
"-" row meant a chat with no role layer, so it is now a chat in a custom
role that binds no template (tests/supervisor/conftest.no_layer_role):
every grants and net-lane cell holds; the taint grid's "-" dispatch cells
deny (decision #7: a layer-less hop delegates no write; 60 per home); the
surface grid's NULL web chat equals the assistant row cell for cell
(superseded by D14: the role is conftest.no_template_role, it acts as
assistant, and the grants and taint grids' "-" cells are the assistant
row's). Hide (B22 residue, I9): a tool whose map entry the chat's role
denies for every value (roles.role_denies_every; role-only, never taint or
turn state) is left out of the specs and the tool index, never described,
and refused if called anyway (role.deny.tool_hidden, saying what to do) on
every home — a lane that refuses keeps its own words, one that would card or
allow is overruled (W2: where the run policy cannot resolve a dispatch, a
tampered baseline or the assistant baseline's gated repo, the hidden
dispatch tools used to card and fail on confirm; the surface grid's 7 and
the taint grid's 72 such cells now deny). A role that hides tools adds one
prompt line naming them and what to do instead; the static research sentence
and the read_url / search_web descriptions say "where start_research is
offered" (W3). Of the shipped roles only assistant hides anything:
dispatch_run, quick_edit, run_code, batch_dispatch, start_research,
forge_tool (start_research and forge_tool no longer card and 403). A custom
role with no policy_layer hides the same six (its hop delegates no write,
decision #7) and otherwise has the baseline's Queen lanes with no role layer
— what every role-less chat had before P3-6 (superseded by D14: such a role
acts as assistant). dispatch_run role= and a batch member's role= are
refused at proposal when that worker role may not write the workspace. B20
/ NEW-F1L-01: set_operator_policy scope=shell — an allow stores exactly
what an approved run_shell keep=always stores (exact argv per segment,
global, through vet_write, revocable), refused for a prefix, an
interpreter (a versioned name too: python3.12), a launcher that runs the
command after it (nice, timeout, busybox, …), an environment
assignment, a network or remote-acting tool (gh, docker, kubectl,
cloud CLIs, open), privilege (su, pkexec, doas), a package install
or fetch-and-run (npm ci, uvx, pnpm dlx), find -exec/-delete, git
configuration (git -c, git config), remote git, sh -c and opaque
lines, a credential path, and any newline or #, answered at proposal (a
denylist: an exact line it does not name — a task runner such as make test
— stores, on a HIGH card); a deny lands in the overlay's shell scope (the
Queen's lanes only), may be a prefix, binds and beats grants. Card-noise
metric: 17 cards, noise 0. Lines (B33 class): read_file, search_files,
run_shell, start_process, read_url, search_web and call_mcp_tool end with an
"In this chat:" line rendered from decide() for the role and home (no
chat: no taint, no chat-bound grant; nothing logged). A frozen table
(tests/fixtures/policy_v3/pre_p3_6_surface_verdicts.json, 6 homes × 7 chat
kinds × every tool) holds the surface to its pre-P3-6 answers. Differs from
D7, on purpose: decision #4 overrides D7's role bullets (analysis is
assistant, not operator); the "queen.shell overlay" is the overlay's
existing shell scope for denies and the one learned list for allows (the
overlay is already Queen-only; an allow there would match as a prefix);
dispatch_run carries no generated line (its gate is the project's posture;
the fresh-chat floor stays pinned). Not done: builder and operator chats
measure ~25.5K / ~25.4K against the 25.1K fresh-chat pin, which measures a
fresh (assistant) chat only.
Hardening B — implemented (ES-F45–ES-F53)
HIGH also covers provider changes (set_assistant_model with a base URL
or another protocol, add_provider, use_provider) and a script schedule
brought back (set_schedule_enabled enabled=true, run_schedule_now). Folds:
an item that raises after an earlier item ran ends the card failed, the
rest interrupted, never re-run. Manifest: also read roots, env
allowlist, git mutation, plugin risks, allowed tools, auto-apply;
submit_run and dispatch_manifest share actions.compile_run; the
confirm recompiles, judges HIGH on the fresh manifest and refuses (409,
stale) one that widens what the card showed. Policy writes take one
in-process lock (policy_write.policy_write) across read → check → write;
the policy document and the overlay are written compare-and-set
(RunStore.compare_and_set_setting, 5 retries) against the CLI racing
serve; the replay runs after the lock. Operator roots:
registry.too_broad_root (/, /home, /Users, the home directory, any
ancestor of it or of the skep store) on every binding face; project setup's
write check sees the would-be roots (check 1 refuses a root holding a
secret-floor path). Check 2 warns (operator decision): the write lands
with a policy_warnings line. Replay: the line carries counts and the
deciding layers, never a logged value or a rule id (a learned rule id is
scope:action:<pattern>); values are plain text and only migrate --dry-run
prints them; the log records chat and a fetch's url directory (no query,
no userinfo), so fetch rows and chat-bound grants replay. Discord: a
reaction or bare /skep approve|deny resolves a card only when exactly one
waits. Not done: group, project and baseline writes from the CLI racing
serve are not compare-and-set; a chat row on a baseline write and a fetch
whose query was dropped are not replayed.
Shell policy (2026-11-13) — implemented (ES-F80–ES-F84, D14: ES-F86–ES-F88)
Operator decisions of 2026-11-13. D11: the Queen's run_shell /
start_process / stop_process and a chat-proposed script schedule (at
proposal and on confirm) refuse, with no card, every skep the floor reads
(bare, a path, uv run, uvx, python -m, a launcher, sh -c, a
pipeline) and every line naming a path under the skep home (<SKEP_HOME>,
the supervisor home's parent in the shipped layout, minus its repos
clones; relative paths judged against the cwd, a bare word only when it
exists there), pointing at get_run, policy_why, read_file
(shell_prefixes.queen_skep_refusal); skep trust / skep chat keep
ES-F58's words; the hook and REST keep the narrower trust floor. D12:
under a shell deny or named ask binding the action, a shell fed on stdin (… | sh, sh <<<, a here-doc, bash -s) and inline interpreter code (python3 -c,
node -e, perl -e, ruby -e) are allowed by nothing and ask with the
ES-F60 note naming the denies (or the named asks) — the card's risk line,
keep once only, a wider named keep a 400; eval payloads are read like
sh -c, so eval curl x is refused by a curl deny. D13: a standing
shell allow (set_operator_policy scope=shell, any action, or a run_shell /
start_process keep always) names only read-only inspection, read-only git
or a listed test runner, after the old refusals (so python -m pytest,
refused before, stays refused: nothing widens); held grants keep matching
and doctor / policy migrate --dry-run list the ones a new allow would
refuse. D7: with an approved baseline (tampered too)
set_operator_policy refuses every allow, at proposal, naming skep policy approve; denies land; card keeps unchanged. D17: too_broad_root also
refuses the system top-level folders, /Volumes and any mount point. Moved
cells, each with a sentence in its test: test_taint_v3 inline-code rows
(D12), test_card_noise t12 and t18 and its counts (D7, D13),
test_tool_surface_v3 B20 tests (D7: on the same home with no baseline; D13
lines), test_policy_write_v3 / test_net_lanes_v3 set_operator_policy
rows (D7). D14: a custom role naming no template acts as assistant —
Role.template is the bound template or assistant, and Role.layer(),
the one place every reader of a chat's role (chat, unattended and channel
turns, dispatch, manager@role hops, policy why / explain, the
hidden-tool list) builds the role layer, always builds one, labelled
role:<name>; every chat now has a role layer (no chat — REST, the CLI, the
hook — still has none). skep doctor names each such role in one line until
it gets a template (a role file that does not load it names instead: every
chat's own tools refuse until it loads); role list and explain say it
acts as assistant. Moved cells (D14): every chat - cell of
pre_p3_4_grant_verdicts.json (234 changed) and
pre_p4_1_taint_verdicts.json (141 changed) is the assistant cell
relabelled role:notemplate/ (the fixture role is now
conftest.no_template_role); pre_p3_3_net_verdicts.json keeps its - row
as the no-role record of the pre-P3-3 grant matcher. The taint grid's
no-layer:dispatch class is gone (its - dispatch is the assistant row's
hidden:dispatch) and its D5 counts drop the layer-less row's extra allows;
tests that needed a lane alone use real states (granted probes in an
assistant chat, operator's missing shell.run_background rule for decision #7,
the secret floor for a dropped deny).
Hardening C — implemented (ES-F100–ES-F106)
Field test part B re-test (L3r, L6, L29) and operator decisions D3, D15,
D16, D18 (2026-11-13). D3: /trust covers the finish notice of runs in
flight (P4-1 row). D15: worker memory marked and wrapped (P4-1 row). D16:
channel turns ignore session keeps (P4-1 row). L3r: an unattended turn
runs a file read decide() allows (filesystem.read) as an attended turn
does; it still executes no mutation. L6: a mirrored worker gate card
records the gate's decision, so its why-line names what the worker asked;
the web gate card shows it. L29: a confirmed result says the card's tier
(tier: HIGH / tier: normal). D18: a verdict while another turn runs
is claimed, executed and stored at once (the one claim stays; it waits only
for a sibling card still executing, so two cards of one chat never run side
by side); the model's follow-up waits for the turn on a thread and runs
unattended, after a queen line naming the verdict, and only if no card is
pending then; a waiting follow-up is held on its card row
(chat_actions.follow_up, ES-F109) and claimed when it starts, so a serve
restart runs one not yet started, once, and never one already started. A
card the running turn raised, and a legacy card whose call has no id, still
answer 409. Every stored tool call now has an id (skep mints one when the
provider sends none), so a result written mid-turn pairs with its own call;
the five strict fakes pass a verdict mid-turn, two verdicts, a folded card,
a verdict racing the turn's end and a restart (test_provider_replay). Not
done: the strict fakes reuse one call id per protocol, so result-to-call
pairing across rounds is pinned on ollama only. A queued follow-up after a
messenger click replies in that conversation (ES-F180: pushed as kind
reply, which notification_level never filters, like an in-turn reply),
and still runs unattended, so D16 holds for it.
R2a (operator decisions 2026-11-13) — implemented (ES-F90–)
D5 (ES-F90): a dispatch's explicit network ADDS to the project's hosts
(default, registries, remembered hosts); [] still means only the worker's
own LLM, omitting it still means the project's hosts; a named list on a
project whose hosts are * stays the named list (the stricter reading). The
card names what the list adds (network_added); network_dropped now only
applies to []. The ceilings (project policy, role chain, locked baseline)
bind as before. D6 (ES-F91, supersedes v115-F9): loopback is closed to a
sandboxed worker except its local provider's port and the project policy's
loopback_ports (registry knob, project layer; skep project setup --loopback-port,
chat setup_project policy_overrides); serve's port never opens.
Permissions.loopback_ports (contract 0.3.8) carries the project's list;
netproxy.run_loopback_ports adds a local provider's port and drops
serve's, and the Seatbelt profile, the proxy (admit_target), netshim
(bubblewrap) and the worker's fetch gate all read that one set. The manifest
and card show it; re-verification gets the project's ports; a closed port's
refusal names the port and the setup command; doctor and policy migrate --dry-run
name projects that open none. Not done: a bubblewrap * run shares the
host's network namespace, so its loopback is not port-filtered (needs a
netns plus the proxy); the diagnose and forged-tool sandboxes get no project
ports (closed). D9 (ES-F92): on a home with no approved baseline where
no_baseline binds (zero_state_home), skep run --role / skep team
print the hosts the run would ask about and ask y/n on a terminal (yes =
_preanswer, recorded as manifest_preanswered); off a terminal they
refuse naming --answer-host. POST /api/runs with a role (or chain) and
POST /api/teams refuse with a 400 listing them unless answer_hosts names
a subset of the manifest's asks (actions.answered_hosts,
team_manifests). The proxy's 403 for an unanswered ask names every face's
way to answer, not a dispatch card. An upgraded home with no baseline is
unchanged: its asks are a role's own and the worker cards them. D10
(ES-F93): a role chain never holds network * (unchanged); when the run's
network is * (the project's default_network or the dispatch's own list)
and the chain leaves it no hosts, the manifest's network_note (card: web,
channels, terminal) and the run's dispatch note say in one line that the run
holds no hosts, why, and to name the hosts instead. D21 (ES-F94): a
worker's shell may create a new .env / .env.<name> inside its worktree
from a template (.example, .sample, .template, .dist, by name and
realpath), as plain cp A B or cp -n A B with a destination that does not
exist (secret_floor.creates_dotenv_from_template); reading, printing,
copying out, overwriting and every other shape stay under the floor.
What ADR 0059 still leaves open
Collected from the rows above:
- Roles: Builder and operator tool surfaces sit above the fresh-chat
byte pin (P3-6);
face=headlessis nodecide()input — unattended turns keep chat.py's refusal (P3-2, P3-3). - Lanes outside
decide(): the run compile and the ops bounds read the setup document's allows and raise on B23;baseline_guardstill readspolicy_engine_v2_scopes; the repo pen's background refusal andno_such_path(P3-2).OPERATOR_LANESstays, and overlaynetwork fetchallows do not grant read_url (P3-3). Only a human's grant answers a role's*ask — not a template, phase, group or project allow (P3-2). - Grants: no
subdomain,path_prefixormcp_toolmatchers; the hook decides WebFetch by host; redirect hops are decided by host;projectlifetime is not offered on Queen cards; legacy unbound session rows match until restart (P3-4). Check 1 probes fixed paths (P3-5). - Taint: no per-server MCP trust flag; no taint into workers; worker
memory in a worker's injected context is not wrapped (Hardening C); a
shell egress under
privateonly is not gated (P4-1). - Cards: a first forge_tool card shows no manifest (the forge is set up on confirm); folding covers only read_url and search_web (P4-2).
- Workers and egress: loopback is closed but for a local provider's port
and the project's
loopback_ports(D6), except a bubblewrap*run, which shares the host's loopback; V6b (the worker never holds the provider key) is deferred until a relay exists (P2-1, decision #5); the proxy cards no ask host for a subprocess that the dispatch card did not list (P2-2). - Shell policy (2026-11-13): the hook and REST refuse only
skep trust/skep chat, not every skep line or skep-home path (D11 binds the Queen's lanes); a skep run hidden in backticks or$(…)is not seen by D11 (its card shows the raw line);set_operator_policytakesallow/denyonly, so D7's "add an ask" has no verb; D13'spython -m pyteststays refused by the older interpreter rule. - Not verified this round: P3-1's note that a delegator whose role has
no rule holds
deny(decision #7,roles.within_delegator).