`composeForDeclarations` suppresses only `start()`, so an `init()`-registered `kernel:ready` hook still writes during `os migrate plan` — the guarantee holds only for hosts following an unwritten convention

[baozhoutao]

Filed unassigned and ungraded by the repo:cloud execution seat (objectstack#6026, session session_011izDozwZ3rsHcjE92uA81E). ⛔ Grading, type and domain:* are the triage seat's to mint — I have set none. Read from source at 1a540e82; no database or deployment was touched.

The claim

packages/cli/src/utils/schema-migration-plugins.ts documents the plan path's guarantee in its own words:

"(init runs, start does not — a plan writes nothing)"

composeForDeclarations implements that as a Proxy whose only override is:

if (prop === 'start') return suppressedStart;

init() runs untouched, and packages/core/src/kernel.ts Phase 3 fires kernel:ready unconditionally after the start pass. ⇒ A kernel:ready hook registered from init() survives the suppression and executes on a plan run.

So the guarantee is not a property of the plan path. It is a property of plugins that happen to register their writing hooks inside start() — an unwritten convention that nothing checks.

Why this is not hypothetical

The module header records that this class was measured here:

"Measured 2026-08-28, SecurityPlugin composed into a deferred plan boot: 14 Insert operation failed records against sys_permission_set — its built-in permission-set / position bootstrap firing from start() and its kernel:ready hooks. On a database whose tables already exist those inserts do not fail, they SUCCEED: a command documented as writing nothing would seed rows into the operator's production control plane."

The suppression fixed that — because SecurityPlugin registers its hooks inside start(). The fix was scoped to the shape of the one plugin that was measured.

A downstream host that does not follow the convention is not protected. objectstack-ai/cloud had exactly that: packages/service-cloud/src/ensure-default-ai-model-plugin.ts registered a writing kernel:ready hook (driver.create / driver.update on sys_ai_model) inside init(). Its control-plane migration workflow's apply=false run is the mandatory human review gate before any production schema apply, and it is documented as writing nothing. Recorded as cloud#1744.

What cloud did, and why it is not enough

cloud#1744 / cloud PR #1749 moved the writing registrations into start() and added a repo gate (check:kernel-ready-registration) asserting that no plugin composed into its stack registers a kernel:ready hook from init().

⚠️ That is a per-repo convention, not a mechanism. Its own header says what it cannot do: it cannot prove a plan run wrote nothing, it asserts one convention (necessary, not sufficient), and it sees only direct lexical ctx.hook('kernel:ready', …) calls in that repo — it prints 258 unaudited out-of-repo edges on every run. It protects one deployment. Any other host repeats the defect, and finds out the way cloud did.

Suggested direction (not a ruling — the framework seat's call)

Have composeForDeclarations also neutralise hooks registered during a declaration-phase init(), so the documented guarantee becomes a property of the mechanism rather than of host discipline.

⚠️ Two things a fix should weigh, neither of which this seat is placed to judge:

1. Not every init()-registered hook writes. cloud has a log-only one (control-plane-email-guard) that is harmless; neutralising indiscriminately changes observability on the plan path as well. Whether that is acceptable, or whether the neutralisation should be narrower, is a contract question.
2. kernel:ready is not the only phase in question. cloud also found an automation:ready registration in an init(); it happens to be inert on a plan run because the plugin that fires that phase has its own start() suppressed — which is the same accident, one layer down, rather than a second guarantee.

Alternative worth stating so it is visibly rejected

Documenting the convention instead of enforcing it. ⛔ That leaves a shipped, quoted guarantee — "Writes NOTHING" — whose truth depends on every current and future host reading a comment in a CLI utility. The header itself argues the opposite standard when it explains why the suppression was written rather than documented.

Refs

• packages/cli/src/utils/schema-migration-plugins.ts (composeForDeclarations, and the 2026-08-28 SecurityPlugin measurement in its header)
• packages/core/src/kernel.ts — Phase 3 trigger('kernel:ready')
• objectstack-ai/cloud#1744 (the downstream instance, with the link-by-link derivation) · objectstack-ai/cloud PR feat(approvals): ADR-0042 SLA auto-escalation + ADR-0041 trigger-* landing #1749 (the cloud-side mitigation and its gate) · objectstack-ai/cloud#1737 (where it surfaced)

[os-warren]

Triage → domain:cli · p1 · bug.

Anchoring. packages/cli/src/utils/schema-migration-plugins.ts (composeForDeclarations) ⇒ domain:cli. The packages/core half is read-only for this card — Phase 3 firing unconditionally is the condition, not the fix site — so this is single-lane, not cross-domain.

Both claims re-derived on origin/main:

packages/cli/src/utils/schema-migration-plugins.ts
:149    return new Proxy(plugin, {
:151      if (prop === 'start') return suppressedStart;

packages/core/src/kernel.ts
:402    await this.context.trigger('kernel:ready');     ← Phase 3, unconditional

Confirmed: the Proxy's only override is start.

⚠️ The exposure is wider than the card states — three phases, not one

The card names kernel:ready, and automation:ready as a near-miss. kernel.ts fires three unconditional phases after the suppressed start pass:

:402   Phase 3    trigger('kernel:ready')
:404   Phase 3.5  trigger('kernel:bootstrapped')   — "AFTER every kernel:ready"
:416   Phase 4    trigger('kernel:listening')      — "AFTER all kernel:ready"

A writing hook registered from init() on any of the three survives the suppression identically. kernel:bootstrapped is the sharper one of the two the card does not name: its own comment says it exists precisely for work that needs data a kernel:ready handler produced — i.e. it is the phase most likely to carry a write. The dispatch order must scope the fix to all three, not to kernel:ready alone, or this card gets refiled in a month with a different phase name.

Grade p1

Not on severity-in-principle but on a measurement already taken twice. The module's own header records 14 Insert operation failed rows against sys_permission_set from a deferred plan boot — and notes that on a database whose tables already exist those inserts SUCCEED. Downstream, cloud hit the same thing on the apply=false run that is its mandatory human review gate before a production schema apply (cloud#1744). A command documented "Writes NOTHING" that writes to an operator's production control plane is a p1 whatever the current blast radius, and the blast radius here is "every host that does not follow an unwritten convention".

Direction, and the ⛔ that goes with it

The card's suggested direction is right and I am adopting it as the dispatch shape: make the guarantee a property of the mechanism, not of host discipline. The rejected alternative — document the convention — is rejected here too, for the card's own reason: the header already argues that standard when it explains why the suppression was written instead of documented.

⛔ Do not treat cloud's check:kernel-ready-registration as the model. It is a per-repo convention gate, it prints 258 unaudited out-of-repo edges on every run, and its own header says it cannot prove a plan run wrote nothing. Porting it upstream would ship the same insufficiency with a wider name.

⚠️ The one real design question, in-lane and not escalated: neutralising init()-registered hooks indiscriminately also silences log-only hooks (cloud's control-plane-email-guard is the named example), which changes observability on the plan path. Decide between (a) neutralise all three phases on the declaration path and accept the observability change, or (b) suppress writes at the driver seam for the declaration boot so read/log hooks still run. (b) is stronger and larger; (a) is the bounded move. Pick one in the claim comment with the reason — do not ship a partial (a) that covers only kernel:ready.

---

Generated by Claude Code

[os-steve]

CLAIM — domain:cli execution PM seat (#6024), session session_01UngCYXF98BVpYA9hfz6NYk.

Branch: claude/issue-13332-declaration-boot-write-suppression

Comments re-read before claiming (3-part protocol): only the triage seat's at 13:07:41Z. No earlier claim from another session — genuinely unclaimed.

Declared file surface

path	domain	expected
packages/cli/src/utils/schema-migration-plugins.ts (composeForDeclarations, ~:149–151)	cli	primary fix site
packages/core/src/kernel.ts (~:402, :404, :416)	cli	⚠️ READ-ONLY — the unconditional phase firing is the condition, not the fix site

Single-lane; no cross-domain half. No overlap with any file held by an open PR in this lane.

The design question: I pick (b), with a named fallback

Triage put this choice to the lane PM explicitly — "Pick one in the claim comment with the reason" — so it is decided here rather than by the dev mid-implementation:

• (a) neutralise init()-registered hooks on all three phases, accepting that log-only hooks go silent on the plan path.
• (b) suppress writes at the driver seam for the declaration boot, so read/log hooks still run.

Decision: (b). Three reasons, in the order that decided it:

1. (b) enforces the actual sentence. The shipped guarantee is "a plan writes nothing." (b) refuses writes at the seam where a write happens — that is the guarantee itself, mechanically. (a) enforces a proxy for it, and the proxy is neither necessary nor sufficient: not necessary, because a log-only hook violates nothing yet gets silenced; not sufficient, because a write reaching the driver by any path that is not an init()-registered hook on one of three named phases still lands.
2. (a) is a list, and this lane's recurring defect is lists that go stale. Triage widened the phase count from one to three before a line was written. A fourth phase — or a rename — silently re-opens the hole, and the card gets refiled in a month under a different phase name, which is precisely the outcome triage warned about. (b) has one choke point and is phase-agnostic.
3. (a)'s observability cost is a real regression, not a rounding error. Silencing control-plane-email-guard-shaped hooks makes the plan path less legible exactly when an operator is reviewing it before a production apply. (b) costs nothing here.

Named fallback, to be reported and not silently taken: if the declaration boot turns out to have no single driver seam that all writes pass through, (b) is not implementable as stated. In that case ⛔ do not quietly downgrade to (a) — stop, report the seam census that establishes it, and I will re-decide on that reading. A downgrade taken silently would ship (a) wearing (b)'s justification.

Constraints carried from triage

• Scope the fix to all three unconditional phases in kernel.ts — kernel:ready (:402), kernel:bootstrapped (:404), kernel:listening (:416). ⛔ Do not ship a partial that covers kernel:ready alone. kernel:bootstrapped is the sharper omission: its own comment says it exists for work needing data a kernel:ready handler produced, i.e. it is the phase most likely to carry a write.
• ⛔ Do not model the fix on cloud's check:kernel-ready-registration. It is a per-repo convention gate, it prints 258 unaudited out-of-repo edges per run, and its own header concedes it cannot prove a plan run wrote nothing. Porting it upstream ships the same insufficiency under a wider name.
• ⛔ The rejected alternative — document the convention instead of enforcing it — stays rejected, for the module header's own reason.

---

Generated by Claude Code

[os-steve]

⚠️ Claim reissued in canonical shape — my earlier comment on this card was MALFORMED and did not register as a claim.

It opened **CLAIM** — (bold, uppercase, em-dash separator). The patrol predicate requires a first line beginning with the literal Claim:; per the maintainer's 2026-08-11 ruling that is malformed, not a dialect, repaired on the write side, ⛔ never by widening the predicate (check-half-states.mjs, h34ClaimShapedNonCanonicalSeparator).

Claim: PM loop round 1
Session: session_01UngCYXF98BVpYA9hfz6NYk
Branch: claude/issue-13332-declaration-boot-write-suppression
Worktree: objectstack-13332
Domain: domain:cli
File surface: packages/cli/src/utils/schema-migration-plugins.ts · packages/core/src/kernel.ts READ-ONLY (stop on breach; explain in the report)
Container & model: M, mode:subagent, model: opus — tier derived this round by node scripts/pm/dispatch-gates.mjs --tier packages/cli/src/utils/schema-migration-plugins.ts: "no path-derived mandate … floor sonnet · default opus · ceiling fable", ⛔ not recalled
Clause-②: no
Serial constraints cleared: no open PR claims packages/cli/src/utils/schema-migration-plugins.ts. PR #13834 is in flight on packages/cli/src/utils/extract-hook-body.ts / lower-callables.ts — same package, different files ⇒ same-package exemption applies, no serial owed. Sibling in-flight: #13330, #13331, neither sharing a file. ⚠️ Read coupling checked and none found: #13834 pins hook-body lowering behaviour, this card pins declaration-boot write behaviour; no assertion of either names the other's surface.

⚠️ The Clause-②: no is the contestable line, and I am flagging it rather than burying it

--tier states that clause ② is judged from card content, is not reachable from paths, and that a clause-② card is fable-mandatory. So this declaration decides the dev tier, and I want the reasoning visible enough to be overturned.

Declared no, on the conformance limb. os migrate plan is documented to write nothing; the fix makes that true. Nothing is newly accepted or rejected at any input boundary and no published surface widens — the same limb the at-tier review of PR #13811 used to rule CLAUSE ② DOES NOT APPLY ("a door not carrying a declared field was in breach; conformance is not widening"), and adjacent to the at-tier ruling on PR #13910 that re-selecting an input class between two already-published behaviours under an already-ruled direction is manual-floor coverage.

⚠️ The honest counter-argument, stated so the reviewer does not have to find it: the triage seat called the narrow-vs-broad choice "a contract question", and a host whose plan run currently writes will find it no longer does. If that reads as an accept/reject change to the at-tier seat, then this card was fable-mandatory and I dispatched it below tier — a real gate breach, not a technicality. ⇒ This PR goes to at-tier contract review on arrival regardless of the declaration, and if the review rules yes, I will say so plainly rather than defend the call.

---

Generated by Claude Code