Repository navigation
refactor!: remove the Block Tune tool kind - #193
Merged
Merged
Conversation
Contributor
Unit Tests
Mutation Tests
|
gohabereg
force-pushed
the
feat/plugin-block-data
branch
from
October 9, 2026 23:06
2a57836 to
cd8d3c1
Compare
gohabereg
force-pushed
the
feat/remove-block-tunes
branch
from
October 9, 2026 23:06
cafb423 to
46e05e9
Compare
gohabereg
force-pushed
the
feat/plugin-block-data
branch
from
October 10, 2026 01:16
cd8d3c1 to
544ca4f
Compare
gohabereg
force-pushed
the
feat/remove-block-tunes
branch
from
October 10, 2026 01:16
46e05e9 to
7cbecaf
Compare
gohabereg
force-pushed
the
feat/plugin-block-data
branch
from
October 13, 2026 16:09
544ca4f to
dd75828
Compare
gohabereg
force-pushed
the
feat/remove-block-tunes
branch
from
October 13, 2026 16:09
7cbecaf to
02eff13
Compare
Contributor
There was a problem hiding this comment.
🟢 Approval recommended
The intentional breaking removal is consistent across contracts, core wiring, dependents, and regression tests, with no blocking issues identified.
0 open findings
What changed in this PR
Removes the unused Block Tune tool kind, continuing #189’s move toward plugin-based block settings. Model-layer changes remain in #192.
Changes:
- Removes tune contracts, facades, options, and registration paths.
- Adds removal guards and coverage for remaining tool kinds.
- Updates documentation and implementation tasks.
| File | Description |
|---|---|
| packages/sdk/src/tools/ToolsCollection.ts | Removes the tune collection view. |
| packages/sdk/src/tools/ToolsCollection.spec.ts | Tests remaining views and tune removal. |
| packages/sdk/src/tools/facades/index.ts | Removes tune facade exports and union member. |
| packages/sdk/src/tools/facades/BlockTuneFacade.ts | Deletes the unused facade. |
| packages/sdk/src/tools/facades/BlockToolFacade.ts | Removes tune collections and options. |
| packages/sdk/src/tools/facades/BaseToolFacade.ts | Removes tune types and predicate. |
| packages/sdk/src/tools/facades/BaseToolFacade.spec.ts | Guards removed SDK APIs. |
| packages/sdk/src/entities/MenuConfig.ts | Updates menu documentation. |
| packages/sdk/src/entities/index.ts | Removes tune contract exports. |
| packages/sdk/src/entities/EntityType.ts | Removes ToolType.Tune. |
| packages/sdk/src/entities/BlockTune.ts | Deletes tune contracts. |
| packages/sdk/src/entities/BlockTool.ts | Removes the tune option. |
| packages/sdk/src/entities/BaseTool.ts | Narrows option types to remaining kinds. |
| packages/sdk/src/api/BlocksAPI.ts | Removes tune references from commented API. |
| packages/plugins/shortcuts-plugin/src/index.ts | Removes unused tune shortcut stub. |
| packages/core/src/tools/ToolsManager.ts | Removes the tune collection getter. |
| packages/core/src/tools/ToolsFactory.ts | Removes tune facade construction. |
| packages/core/src/tools/ToolsFactory.spec.ts | Tests factory behavior for remaining kinds. |
| packages/core/src/index.ts | Removes tune registration and preparation. |
| packages/core/src/index.spec.ts | Tests plugin routing and collection removal. |
| openspec/changes/remove-block-tunes/tasks.md | Records completed implementation tasks. |
| docs/README.md | Updates supported tool contracts. |
| docs/plugins.md | Explains plugin-based tune replacement. |
| docs/diagrams/plugin-lifecycle-flow.mmd | Removes tune lifecycle paths. |
🧠 Review effort: Balanced
💡 Add a code-review agent skill or configure MCP servers for context-aware, tailored reviews. Learn more in the docs.
gohabereg
force-pushed
the
feat/plugin-block-data
branch
from
October 16, 2026 23:01
dd75828 to
d555032
Compare
gohabereg
force-pushed
the
feat/remove-block-tunes
branch
3 times, most recently
from
October 17, 2026 18:52
119c8bf to
36fa683
Compare
gohabereg
force-pushed
the
feat/plugin-block-data
branch
from
October 17, 2026 18:52
24efab2 to
7aefa42
Compare
neSpecc
approved these changes
Oct 30, 2026
Reversean
approved these changes
Nov 3, 2026
Renames the model's tune vocabulary so per-block extra data belongs to
plugins rather than to a dedicated Block Tune entity:
- BlockTune entity -> PluginDataNode, with key deletion when a value is set
to undefined and an isEmpty getter
- TuneIndex -> PluginDataIndex, serialized as {"k":"plugin",...,"plugin":...}
- TuneModifiedEvent -> PluginDataModifiedEvent, BlockTuneEvents ->
PluginDataEvents
- BlockTuneName/BlockTuneSerialized -> PluginDataName/PluginDataSerialized
- the serialized block key `tunes` -> `plugins`
Behavior changes beyond the rename:
- BlockNode.updatePluginData creates a missing entry instead of throwing. The
node is created empty and its listener attached before the first update,
because PluginDataNode dispatches synchronously.
- entries live in a null-prototype record, and an empty plugin name throws, so
a document-supplied name like __proto__ is stored as plain data
- empty entries are left out of serialization
- EditorDocument.modifyData applies a Modified change addressed by a
PluginDataIndex, so undo/redo and remote operations can replay plugin data
- the bubbled event carries the acting user from the context instead of a
hardcoded 'user'
BREAKING CHANGE: the serialized block key `tunes` is now `plugins`, and the
serialized index kind "tune" is now "plugin".
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
- re-export the renamed model types (PluginDataName, PluginDataSerialized, PluginDataIndex, PluginDataModifiedEvent, createPluginDataName) - declare EditorjsPluginDataMap, a third augmentable map alongside EditorjsPluginApiMap and ToolPluginOptionsMap, and resolve a plugin's data shape through PluginDataFor<Id>. An undeclared id falls back to a plain record rather than never, since per-block data is often stored by a plugin that has no reason to publish its shape. - add BlocksAPI.getPluginData / updatePluginData and a `plugins` map on insert Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
- BlocksAPI.getPluginData / updatePluginData, backed by BlocksManager, with the acting user defaulting to the configured one - insert() accepts a `plugins` map, and convert() carries plugin data over to the converted block - fix insert() dropping the block's data: BlocksManager spread `...data` into the block init while BlockNode reads a nested `data` key, so inserting with data silently produced an empty block. `plugins` is passed as its own key. - fix BlocksAPI.insert not forwarding `focus`, `plugins` and `userId` - add UndoRedoManager integration tests over a real model: undoing a first write removes the entry, redo restores it, and undoing one key leaves the plugin's other keys untouched - fix the BlocksAPI integration spec wiring a second, empty model into the API, which made every direct model read in it see an empty document Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
- map PluginDataModifiedEvent to a Modify operation carrying the new and previous values, instead of logging it as an unknown event type - add a PluginDataIndex branch to OperationsTransformer#applyTransformation, which dispatches on the against-operation's index kind and previously threw 'Unsupported index type'. Without it the first remote plugin data change threw in OTClient's pending-operation reduce, in transformStacks for every remote event, and in ot-server's conflicting-operation reduce. - widen ModifyOperationData's payload from Record<any, any> to unknown, so a scalar plugin data value is representable, and narrow the two payload length reads that relied on the old type - move the ot-server fixtures off the `tunes` key Two concurrent writes to the same key stay untransformed: server order decides and the last applied one wins. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Mutation testing (scoped to the changed files, as CI does) pointed at four real gaps: - BlocksManager.insert: nothing asserted that block data is nested under a `data` key rather than spread, nor that the plugins map is forwarded and omitted when absent - convertBlock: nothing covered carrying plugin data to the converted block - EditorDocument.modifyData: the PluginDataIndex branch had no model-level test - BlockNode: the initial-data path of plugin node creation was unasserted Fixing the last one surfaced a bug in BlockNode.serialized: it assigned entries into a plain object, so a plugin named `__proto__` set the object's prototype instead of becoming a key and vanished from the serialized block. The entry map is now built with Object.fromEntries. The previous test only passed because its expected literal was broken the same way — writing the key as a computed property, to satisfy the naming-convention lint rule, is what exposed it. Scores for the changed files: model 90.38 (threshold 75), core 86.72, collaboration-manager 52.08 (threshold 0, unchanged file-level scores). No surviving mutants remain on lines this branch touched. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
composeDataFromVersion2 dropped each v2 block's `tunes` silently. It now maps them onto the v3 `plugins` key: - names are kept verbatim, so a v3 plugin that adopts a v2 tune's name finds its data without a rename table - object data is copied key by key - a primitive, an array or null goes under the `value` key, since a plugin entry is a key/value map while v2 tune data is any JSON value - a block with no tunes, or an empty map, produces no `plugins` key - the entry map is built with Object.fromEntries, so a tune named `__proto__` survives instead of setting a prototype Adds the file's first spec, including the converter's existing data handling, and an integration test taking a v2 document through the converter into the model and reading it back with api.blocks.getPluginData. The spec stubs DOMParser, which the pre-existing inline-fragment extraction needs and this package's node test environment lacks. That extraction stays untested, so the file's mutation score is low (25%, threshold 0) — it simply had no spec at all before. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
- model.md, events.md, index-serialization.md: PluginDataNode, PluginDataIndex (`k: "plugin"` with `plugin`/`key` fields), PluginDataModifiedEvent, and Index.pluginData - plugins.md: a new "Per-block plugin data" section for plugin authors — the two API calls, the EditorjsPluginDataMap augmentation, and the behaviors that bite (key removal, per-key undo granularity, last-writer-wins on the same key, preserved data for unregistered plugins, move/convert/split, v2 carry over) — plus the two new api.blocks rows and the third type map - diagrams: model-tree-structure, events-catalog, architecture-overview - docs-updater agent: map the renamed model entity to docs/model.md Mentions of the Block Tune *tool kind* stay: they belong to remove-block-tunes. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Every task is done except the final one, which is the ready-to-archive signal: leaving it unchecked keeps the archive gate quiet until a maintainer comments /archive on the PR, per CONTRIBUTING. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Six comments added by this change ran to three. Same content, tightened: the v2 tune mapping, the BlockNode class doc and its `#plugins` field, the `updatePluginData` contract and `PluginDataFor`'s fallback. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
`PluginDataNode.update` dispatched unconditionally, carried over from `BlockTune`, where it was nearly harmless because tunes were rarely written. `updatePluginData` is now a public API that plugins call on every toggle, and each event becomes an operation for collaborators and a step on the undo stack — so re-applying the state a plugin just read filled the undo stack with entries that undo nothing. Storing the value a key already holds, or removing a key that is not there, now returns before dispatching. The removal case needs the extra clause: both sides are `undefined` whether the key is absent or present holding `undefined`, and only the latter is a real change. Also locks down the wire format for a removal, which has no test today: the payload is `undefined`, `JSON.stringify` drops the key outright, and the removal survives only because reading a missing key gives `undefined` back. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Two clients writing the same plugin data key left one of them on a value the server does not hold. Remote operations are transformed against the pending local ones, and the plugin data path returned them untouched, so the client with an unsent write applied the incoming value over its own -- and since its operation is never echoed back to it, nothing restored what the server ended up with. The rule is now the one #transformAgainstDataOperation already applies to data values: an against-operation with no revision counts as the later of the two, and the operation being transformed becomes Neutral. It is scoped to the same block, plugin and key, since nothing else describes the same value. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Plugin names and the keys inside an entry are document data, and both could collide with the prototype. PluginDataNode kept its keys on a plain object while the block's own plugin store already used a null prototype. A `__proto__` key loaded from a document reached the prototype setter instead of becoming an own property and vanished from serialization; a first write to a key like `toString` read the inherited function as its previous value and put that on the undo stack and the wire. The record is now copied onto a null prototype, as the outer store is. `serialized` handed out the live record, so `getPluginData` and `api.document.data` both exposed an untracked write path into the Model. Read, change, write back -- the obvious way to use the two methods together -- changed the document on the read and then emitted nothing, because the no-op guard found the value already updated. Callers get a detached copy. BlocksManager.getPluginData indexed the serialized map directly, so a plugin named toString or constructor read back as the inherited function rather than undefined. It checks for an own entry first. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
The cases asserting that a plugin data operation is left alone checked only that its type was still Modify. That says it was not neutralised and nothing more: with the untransformed branch returning an operation whose block index was shifted by 99, all thirty cases still passed. Comparing the serialized form covers the index, both payloads, the user and the revision in one assertion. The two serialization cases were named after a metaphor rather than what they do, which is a JSON round-trip standing in for what reaches the OT server. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
A plugin that wrote an object kept a reference into the Model: editing it moved the document with no write at all, and the write-back that should have announced the change found the value unchanged and emitted nothing -- no operation for collaborators, no step to undo. The data a node was constructed with was shared the same way, down from a loaded document. Incoming values are now cloned on the way in and for the event payload, since an operation and an undo step both outlive the call that recorded them. Because what is stored is therefore a copy, the no-op guard compares structurally; `deepEqual` moves into its own util for `isSameInlineData` to share, and reports a value whose state is not in its own keys -- a `Date`, a `Map` -- as different rather than as equal to any other of its kind. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
`againstRevision > operation.rev!` was false whenever the left side came off an undo or redo stack, because those entries are built from model events and never carry a revision. The entry survived, so undoing a local first write to a key a collaborator had since overwritten wrote `prevPayload` over their value and deleted it. An operation with no revision of its own now loses to whatever it is transformed against, which in that path is only ever an operation the model has already applied. Server operations always carry a revision, so nothing else reaches the comparison without one. `#transformAgainstDataOperation` has the same hole for `data` values on `main`; it belongs with the other pre-existing OT defects on the board rather than in this PR. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
…ata follow-ups The spec change for the stack is merged, so this round's delta specs land here, with the code that implements them, rather than in a spec PR of their own. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
gohabereg
force-pushed
the
feat/remove-block-tunes
branch
from
November 5, 2026 01:55
36fa683 to
973d1c7
Compare
gohabereg
force-pushed
the
feat/plugin-block-data
branch
from
November 5, 2026 01:55
7aefa42 to
384329c
Compare
Scoped mutation runs over the files this round touched left six survivors. Four are now dead:
- The array-vs-record kind check in `deepEqual` was only tested with `[]` against `{}`, which
returns `false` either way. An array and an array-like record agree on `length` and on every
index, so `{ length: 0 }` is the case that tells the branch apart.
- Array lengths were only compared for arrays that also differed in content, so a matching
prefix of a longer array went untested.
- The `||` in the kind guard short-circuits the same way as `&&` when neither side is keyed,
which is all the `Date`-against-`Date` cases did. Mixed sides are what it guards.
- Removing a key that is present and explicitly holds `undefined` -- which only a loaded
document can produce -- is a real change that no test covered, though the comment beside the
no-op guard has described it since the write-that-changes-nothing round.
The four left on `copyValue`'s guard all amount to cloning when nothing needs it, which is
observable only for a value that cannot be cloned at all. Tightening that is a contract change
rather than a test gap, so it stays as it is. `model` scores 94% over these files against a
threshold of 75%, with `deepEqual.ts` and `isSameInlineData.ts` at 100%.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
gohabereg
force-pushed
the
feat/remove-block-tunes
branch
from
November 5, 2026 02:02
973d1c7 to
e163fa1
Compare
… acknowledged `#sendNextOperation` shifted an operation off `#pendingOperations` in order to send it, and only pushed it to `#resolvedOperations` -- which nothing reads -- once the server acknowledged it. For the whole round trip the operation was in neither place, and `#onMessage` transforms incoming operations against `#pendingOperations` alone: a collaborator's write to the same value arriving in that window was transformed against nothing, applied over the local one, and never corrected, since a client's own operations are not echoed back to it. The convergence rule added earlier covered only the window before an operation is sent, which is a microtask, while this one is a full round trip -- so it is the window a simultaneous pair of `updatePluginData` calls actually lands in. `openspec/specs/collaboration-manager/spec.md` already required this behaviour; the code did not conform. Safety rests on the server ordering its messages: while an acknowledgement is outstanding, every remote operation delivered was ordered before the local one, so neutralising it is correct, and once it arrives, everything after it was ordered later and applies normally. Reading the head without removing it meant two concurrent `send` calls would both read the same operation and send it twice, so `#awaitingAcknowledgement` is now claimed before the first await. The guard on the acknowledgement handler also carries more weight than it did: mistaking a remote operation for the acknowledgement would now drop a still-in-flight operation from the pending list, reopening the window this closes, so it has a test of its own. The tests also close a hole they uncovered: nothing checked that sending ever resumes after an acknowledgement, only that a queued operation is held back while one is in flight -- so the acknowledgement gate could have latched shut permanently with the suite still green. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
…ta follow-ups The convergence rule said "unsent" where it meant "unacknowledged", which is the distinction the round turned on. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
A registered tune got a `BlockTuneFacade` built and sorted into `ToolsManager.blockTunes`, and nothing ever read it — no adapter, no rendering, no model wiring. It was a second, half-built way to do what a plugin now does, so it goes rather than stays as an alternative to document around. Removed from `sdk`: `ToolType.Tune`, the `BlockTune*` contracts and `BlockTuneFacade`, `BaseToolFacade#isTune()`, `ToolsCollection#blockTunes`, `ToolTypeToOptions[ToolType.Tune]`, and the tune members of the `ToolConstructable`/`ToolFacadeClass` unions. The per-tool allow-list goes too — `BlockToolOptionKey.Tunes`, `UserToolOptions.EnabledBlockTunes`, `BlockToolFacade#enabledBlockTunes` and `BlockToolFacade#tunes` — because per-tool filtering belongs to the providers, which get `tool` in their context. If integrators want the allow-list back it returns through `options.plugins['block-settings']`, not as a member of the tool contract. Removed from `core`: the Tune branch of `use()`, the `getAll(ToolType.Tune)` preparation step, the Tune case in `ToolsFactory` and `ToolsManager#blockTunes`. `shortcuts-plugin` loses its never-called `#processBlockTune`. The removal is guarded by compile-time assertions rather than runtime ones: under `ts-jest` a stale `@ts-expect-error` is itself a diagnostic, so each directive fails the suite while the name it points at exists. `BlockToolOptions['tunes']` is the one member that cannot be asserted — the interface carries an open index signature for tool-author options, so every key resolves. BREAKING CHANGE: registering a tune through `core.use()` or setting a tool's `tunes` option no longer compiles. Write a plugin instead: it puts an item in the block settings menu and stores state as per-block plugin data. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
`docs/plugins.md` loses the registration-table row and gains a line pointing a would-be tune author at the block settings menu and per-block plugin data instead; `docs/README.md` and the plugin-lifecycle diagram drop their `BlockTune` / `ToolType.Tune` / `blockTunes` mentions. Two live specs are hand-edited because the mechanical archive fold only rewrites `### Requirement:` blocks: the `sdk` **Purpose** preamble, and the `shortcuts-plugin` reserved-work note, which now reserves shortcuts for block settings items rather than for block tunes. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
`ToolsFactory#getConstructor` had no coverage at all, so the switch this branch removed the Tune case from was unguarded: a mutant collapsing the remaining Inline case survived. The new spec pins both remaining kinds to their facades, along with the `defaultBlock` flag, the options handed to the facade, and the unregistered-tool error. `ToolsFactory.ts` now scores 100 on mutation testing, up from 40. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Task 4.5 stays open: closing PR #157 with links to its three replacement changes is a public comment, so it waits for the maintainer. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
`MenuConfig` still advertised itself as the shape for "Block Tune's render()", the last reference in shipped source to the tool kind this change removes. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
gohabereg
force-pushed
the
feat/remove-block-tunes
branch
from
November 8, 2026 13:47
e163fa1 to
e2760fa
Compare
Member
Author
|
/archive plugin-block-data |
Contributor
|
❌ |
Archive the change implemented in #192 and sync its delta specs into the main specs. Restore the original title of the sdk "Plugin package augments both maps" scenario in the delta so the archive does not read the rename as a dropped scenario, and fill the Purpose of the new plugin-block-data spec from the proposal. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01TffpCm82NH5xXR1yeBew6Q
Archive the change and sync its core and sdk deltas into the main specs. The sdk Purpose preamble was already updated by hand earlier in this PR, as the proposal asked. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01TffpCm82NH5xXR1yeBew6Q
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01TffpCm82NH5xXR1yeBew6Q
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Implements the
remove-block-tuneschange from #189. Stacked on #192 — this diff is only the tool-kind removal.The Block Tune tool kind is dead weight. A registered tune gets a
BlockTuneFacadebuilt and sorted intoToolsManager.blockTunes, and then nothing ever reads it: no adapter, no rendering, no core wiring. So deleting it breaks no working feature — it just removes the half-wired second way to build what plugins now do, and with it the extension point #157 grew an adapter and a manager around.What's in it
ToolType.Tune, theBlockTune*entity exports andBlockTuneFacade, plus everything referencing them:BaseToolFacade#isTune(),ToolsCollection#blockTunes(its only consumer),BlockTuneConstructorfromToolConstructable,BlockTuneFacadefromToolFacadeClass,ToolTypeToOptions[ToolType.Tune],BlockToolOptionKey.Tunesand itsBlockToolOptionsmember,UserToolOptions.EnabledBlockTunes, andBlockToolFacade#tunes/#enabledBlockTunes.Core#use, thegetAll(ToolType.Tune)preparation step, the Tune case inToolsFactory, andToolsManager#blockTunes.shortcuts-plugin. Its dead#processBlockTuneand theBlockTuneFacadeimport go with the facade."Tune" becomes a UI term only: a former tune is written as a plugin that uses plugin data and the block-settings API.
How the removals are tested
Each deleted name is guarded by a
@ts-expect-erroron its import specifier. Underts-jesta stale directive is itself a diagnostic (TS2578), so every one of these fails the suite the moment its name comes back — the assertions are live, not decorative. I verified that by temporarily pointing one directive at an existing export and confirming it fired.One name resisted:
BlockToolOptions['tunes']can't be asserted gone, because the interface carries an open[key: string]: unknownindex signature for tool-author options, so any key resolves.BlockToolOptionKey.Tunesis the removable surface and is asserted instead; the spec notes this.New specs for
ToolsCollectionandToolsFactory. The latter had zero coverage, which let a mutant collapsing the remaining Inline case survive — it's now at 100% mutation score.Breaking (pre-1.0)
Anything that registers a tune via
core.use()or sets a tool'stunesoption. The model layer's tune vocabulary is renamed by #192, not here.Notes for review
Task 4.5 — commenting on #157 to point at the three replacement changes — is left unchecked on purpose; that's a public comment on someone else's PR and wants a human to send it.
Verified:
yarn buildandyarn lintclean, 1,048 tests passing,openspec validate remove-block-tunes --type changepasses, archive gate OK.🤖 Generated with Claude Code