Twelve questions, and the three modules nothing called
In August, u/WillowEmberly posted twelve questions about Starfish's governance model. They were not the usual questions. Every audit we had run — the MOSAIC paper sweep, the persona threat model, our own four-sweep self-audit — asked whether a control existed for a given attack. These asked what each control does at its edges.
That turned out to be a different question with different answers. Here they are as posed:
- Which guarantees depend on application semantics rather than independent isolation?
- Which controls share upstream assumptions?
- What happens when telemetry disappears rather than reports failure?
- What authority increases when configuration is absent?
- Which recovery paths bypass forward-path governance?
- Who verifies the verifier?
- Which components can still become indispensable chokepoints?
- What happens if the audit subsystem itself becomes unavailable?
- Can an operator distinguish control absent, disabled, failed, and not applicable?
- How much of the security model survives if the model learns the policy implementation?
- Which controls reduce probability of harm versus actually reduce available authority?
- What is the smallest exploit chain from model output to irreversible host effect?
We answered them against the code, not the design docs — compiling and driving the real modules in a scratch harness, with probe transcripts reproduced inline. The write-up is preserved in the present tense of the review, describing the code as the reviewer found it, because that is the honest way to publish it.
Question 3 was the sharpest, and the answer was a defect
"What happens when telemetry disappears rather than reports failure?"
Starfish handles damage to the audit log well. Mid-file corruption enters safe mode. A torn tail enters safe mode. Tail truncation is caught by a head anchor written alongside the log. All of that was tested and worked.
Deleting the log outright was undetected. Recovery was gated on the log or the segment index existing, so with the file simply gone, the anchor — the one artifact proving events had ever existed — was never read. Integrity reported clean. verify() returned true. The sequence number restarted at zero.
PROBE A anchor on disk = {"seq":1,"headHash":"9d127e14b4a3..."}
PROBE A integrity after log deletion = {"ok":true,"reason":"clean"}
PROBE A verify() = true
PROBE A seq restarts at = 0
The anchor proving one event existed was sitting in the same directory, unread. It is total absence that is indistinguishable from a fresh install.
Then the second finding, which is why this one is worth a whole section. With the audit file absent, the security monitor returned all-zero counters and zero findings — and reconcile({allClear: true}) passed. The watcher-discrepancy alarm, the control whose entire job is catching a compromised watcher reporting all-clear, was disarmed by the same deletion it exists to detect.
Both are fixed: recovery always runs, an anchor with no log reports audit-deleted and boots into safe mode, and a log that existed and is now gone is a critical audit-vanished finding that reconciliation refuses to corroborate.
The self-indictment is the useful part. Our own boot code had already got this reasoning right for state files — an UNREADABLE sentinel distinct from absent, added precisely because a swallowing loader conflated them. That reasoning was correct and was simply never applied to the audit log itself.
An operator's explicit rule, silently voided by a friction setting
A convenience profile converted a PDP ask into allow for in-boundary writes, keyed only on "is this an ask, and is it a write." The PDP's decision shape could not distinguish routine medium-risk write from an operator wrote a policy rule explicitly demanding review. Both are {allow: false, ask: true}.
writes=ask -> {"permissionDecision":"ask", "reason":"policy requires human review (ask)"}
writes=auto -> {"permissionDecision":"allow", "reason":"in-boundary write auto-allowed (backed up)"}
Same policy both times. An operator wrote a rule demanding review, and a friction setting elsewhere in the config silently voided it.
The fix adds askOrigin: 'risk' | 'policy' | 'floor' to the decision, and only 'risk' is relaxable. Which is a small type change carrying a real principle: a decision needs to record why it became an ask, or downstream code cannot tell operator intent from routine friction.
The same profile justified itself on the grounds that writes were backed up first. The backup was best-effort, its return value was not checked before allowing, and failure rendered identically to not-applicable — a bare boolean where false meant both "no existing file to back up" and "the backup threw." So an unrecoverable overwrite was logged as new file. An operator reading that log could not tell a safe creation from a destroyed original. Now tri-state: backed | not-applicable | failed, and failed escalates rather than auto-allowing.
The finding that changed how we test
Three of the ten were the same failure mode, and it is not a bug in the usual sense.
- Scope non-deviation — the D1–D4 contract check, seal verification, budget metering. Seven green tests. Zero production callers.
- The monitor's sweep — every runtime rule we have: probing, enumeration, boundary-escape, watcher-discrepancy. Invoked only by its own conformance suite.
- Registry integrity re-check — the out-of-band-edit detector. One caller, in a test.
All three passed CI continuously while being inert in the shipped product.
The scope case is the instructive one, because it explains why it stayed unwired for months rather than being an oversight. The contract ledger fails closed when a task has no contract — correctly. And nothing issued contracts. Turning the gate on would have denied every call in the system. The missing piece was an issuer, not a flag. Meanwhile the site described non-deviation as a live control.
The fix is a contract issuer that auto-derives from what governance already knows, so nobody hand-authors one: permitted tools from the agent's declared tools, path scope from the union of the boundary roots, call budget from config. With one asymmetry worth noting — command permissions are the one place derivation tightens: an auto-derived contract permits no commands until the task names them. Issuance is idempotent, so an approval replayed after a restart does not fail the task, and contracts persist and restore, because an in-flight task returning from a restart contract-less would have every call denied and the gate would look broken rather than fail-safe.
It also ships with an applicability mode rather than a boolean, and the middle rung is the whole design: a call carrying a task id must have a contract or it is denied; a call with no task id has no mission to deviate from and falls through to standing grants, boundary and floors. Conflating that with "no task, no tool" — a different control that already exists — would have made non-deviation impossible to enable without also mandating task binding everywhere.
A test that reads source, because only source can testify
The durable output of this release is 107 lines of test that would have caught three of the ten findings.
reachability.conformance.test.ts walks every shipped .ts file under packages/, excludes test files and type declarations, strips comments, and asserts that each enforcement control is referenced from a non-test file. It checks that the monitor's sweep has a production caller, that registry re-attestation has one, that the PDP source itself references the catastrophic-shell and blocked-host floors, and that boot both constructs the scope issuer and derives its posture from the live gate.
That last assertion has a detail worth keeping. Its first version scanned raw source — and tripped on the comment in boot.ts explaining the old defect. A test failing on its own documentation. Hence stripComments, and a note preserved in the file: an over-broad source assertion is its own kind of false signal.
It is deliberately a source-level check rather than a runtime one, because the failure mode is an absent call site, and only the source can testify to that.
The blind spot was wider than governance
Wiring the release script surfaced a fourth instance of the same shape, outside the governance layer entirely. Our TypeScript config, test config, dependency-direction lint and IP scan all scoped to packages/. The Azure and Foundry tree sits outside it.
So 22 files of Marketplace-facing TypeScript were checked by nothing, and five smoke tests had never been executed by anything. All now covered and wired into CI — and everything passed first run. The code was fine. It was simply unguarded, which is exactly why nobody noticed.
The exploit chain, and what it cost to close
Question 12 asked for the smallest chain from model output to irreversible host effect. The answer was two hops, no human, at Medium risk tolerance:
step1 fs.write evil.test.js -> allow (medium, score 40)
step2 run_tests -> allow (high, score 60)
Medium's ceiling is 70. Writing a file inside the project boundary is legitimate. Running the test suite is the tool doing exactly its job — the runner executes what it discovers, including the file just written. Neither hop subverts anything. Only the sequence is an attack, and per-call risk scoring cannot see a sequence.
The fix tracks, per task, which files a governed write actually produced, and if an exec tool would execute one of them, that call requires a human — and risk tolerance cannot satisfy it. Same floor pattern as the existing secret-read check: a floor is a thing that convenience settings may not lift.
Deliberately an escalation, not a denial. Writing a test and then running it is ordinary developer work; what is removed is the ability to close that loop with nobody watching. One approval, once.
The runner-file predicate is over-inclusive on purpose, and the reasoning is stated in the source: a false positive costs one operator approval, a false negative costs arbitrary code execution. The asymmetry decides the tuning. Scoping is per-task, because the dangerous property is that the same unit of work both authored and ran the code — a file written by an earlier, separately-approved task is part of the project, and treating it as tainted forever would make the control unusable.
What did not change
The conclusion of question 12 stands exactly as written. Self-authored execution gates a sequence; it is not a boundary. Once code executes as the user, every in-process control is moot.
That is the T-25 residual, and it is now the only headline one. No amount of further in-process work moves that line — which is why it stays the headline rather than being quietly absorbed into a list of fixes.
Question 10's answer also stands: the heuristic layer does not survive a reader. The risk regexes, the catastrophic-shell denylist, the egress scan and the new runner predicates are denylists, and a denylist you have read is a puzzle, not a wall. The controls that do survive are the authority-reducing ones — boundary containment, default-deny, the rule that memory content can never authorize a tool call, the deletion hard rules, the exec templates, and now scope contracts. The architecture separates those two classes cleanly, which is good. The marketing should not average them.
Three behaviour changes came with the release, and one is a genuine removal of capability: a catastrophic shell command is now refused rather than escalated. If you relied on approving one, you cannot any more.
Why this is worth writing up at all
Ten findings, nine of which were not previously tracked. Four were defects our own green suite had never caught. That is not a comfortable thing to publish, and publishing it is the point: a governance product that cannot show you where its own edges were is not one to trust with a boundary.
The most valuable output is not any individual fix. It is that we now have a test asserting our controls are reached, and a standing awareness that the gap between "design intent" and "wired reality" is a category of defect our previous test strategy was structurally unable to see.
Thanks to u/WillowEmberly, whose questions produced two of the findings and prompted everything else here.