@cat-factory/prompt-fragments 1.0.0 → 1.0.2

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2026 Igor Savin
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2026 Igor Savin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,42 +1,163 @@
-# @cat-factory/prompt-fragments
-
-The **built-in tier** of best-practice prompt fragments — small, curated guidance
-snippets that get folded into an agent's system prompt at run time
-(`composeSystemPrompt`). This package is **plain, build-static data**: no I/O, no
-framework. It is the source of truth for the shipped defaults and the seed for the
-tenant-scoped [prompt-fragment library](../../docs/adr/0006-prompt-fragment-library.md).
-
-## What's here
-
-- `src/collections/*.ts` — fragments authored per topic. Today: `node`, `react`,
-  `acceptance`. Each exports an array of `PromptFragment`.
-- `src/index.ts` — merges the collections into a single `FRAGMENTS` registry plus
-  `FRAGMENTS_BY_ID` and `getFragment(id)` for O(1) lookup during composition.
-
-A `PromptFragment` (shape defined in [`@cat-factory/contracts`](../contracts))
-carries an `id`, `version`, `title`, optional `category`, a `summary` (used by the
-relevance selector), the `body` (injected text), and an optional `appliesTo`
-hint (`blockTypes` / `agentKinds`).
-
-## How it's used
-
-- The Worker serves this catalog **read-only** at `GET /prompt-fragments`; the SPA
-  shows it in the per-block fragment picker.
-- A block stores selected `fragmentIds[]`; at run time core composes the chosen
-  bodies into the system prompt.
-- When the optional library is enabled, this becomes the **built-in tier** of a
-  three-tier merge (built-in ∪ account ∪ workspace); ids here can be shadowed or
-  suppressed by higher tiers. See
-  [ADR 0006](../../docs/adr/0006-prompt-fragment-library.md).
-
-## Adding a collection
-
-1. Create `src/collections/<topic>.ts` and export an array of `PromptFragment`.
-2. Spread it into `FRAGMENTS` in `src/index.ts`.
-3. Keep ids **globally unique and stable** — blocks persist them, so a renamed id
-   silently drops a selection (unknown ids are skipped, never error).
-
-```bash
-pnpm --filter @cat-factory/prompt-fragments build       # tsc → dist/
-pnpm --filter @cat-factory/prompt-fragments typecheck
-```
+# @cat-factory/prompt-fragments
+
+The **built-in tier** of best-practice prompt fragments: small, curated guidance
+snippets that get folded into an agent's system prompt at run time
+(`composeSystemPrompt`). This package is **plain, build-static data**: no I/O, no
+framework. It is the source of truth for the shipped defaults and the seed for the
+tenant-scoped [prompt-fragment library](https://github.com/kibertoad/cat-factory/blob/main/backend/docs/adr/0006-prompt-fragment-library.md).
+
+## What's here
+
+- `src/collections/*.ts`: fragments authored per topic. Today: `node`, `react`,
+  `acceptance`, `design`, `style`, `migration`. Each exports an array of `PromptFragment`.
+- `src/index.ts`: merges the collections into a single `FRAGMENTS` registry plus
+  `FRAGMENTS_BY_ID` and `getFragment(id)` for O(1) lookup during composition.
+
+A `PromptFragment` (shape defined in [`@cat-factory/contracts`](https://github.com/kibertoad/cat-factory/tree/main/backend/packages/contracts))
+carries an `id`, `version`, `title`, optional `category`, a `summary` (used by the
+relevance selector), the `body` (injected text), an optional condensed `brief`
+(see below), and an optional `appliesTo` hint (`blockTypes` / `agentKinds`).
+
+## How it's used
+
+- The Worker serves this catalog **read-only** at `GET /prompt-fragments`; the SPA
+  shows it in the per-block fragment picker.
+- A block stores selected `fragmentIds[]`; at run time core composes the chosen
+  bodies into the system prompt. Each standard is folded as its **own delimited,
+  title-labelled block** (`<best-practice-standard id="…" title="…">`) rather than one
+  concatenated blob, so an agent can tell the standards apart and cite one by its title
+  (`composeSystemPrompt` / `composeBlockSystemPrompt` in `@cat-factory/agents`). The
+  code + PR **review** agents additionally report per-standard **adherence** (a 1–10
+  rating + related findings) back on the step, surfaced in run details.
+- When the optional library is enabled, this becomes the **built-in tier** of a
+  three-tier merge (built-in ∪ account ∪ workspace); ids here can be shadowed or
+  suppressed by higher tiers. See
+  [ADR 0006](https://github.com/kibertoad/cat-factory/blob/main/backend/docs/adr/0006-prompt-fragment-library.md).
+
+### Two-tier bodies: `body` and `brief`
+
+An **implementer** kind (`coder` / `fixer` / `ci-fixer` / `conflict-resolver`: the kinds
+carrying the `brief-standards` trait) runs a long agentic loop whose system prompt, standards
+included, is re-sent on **every turn**. Those kinds fold a fragment's optional `brief` (the
+same standard stated tersely) instead of its full `body`. Reviewer / planner / investigator
+kinds keep the full text: they run few turns and benefit from it when judging built work.
+
+Two rules govern authoring one:
+
+- **A `brief` must not drop a rule, only its elaboration.** It is the same standard compressed,
+  not a subset: an agent folding the brief is held to everything the body demands.
+- **`brief` travels WITH the body it condenses** and is never re-resolved by id downstream. A
+  higher tier that overrides a built-in id supplies its OWN brief (or none), so the override's
+  own text is folded, never the built-in's condensed text over a tenant's standard.
+
+Omitting `brief` is always safe: the full `body` is used for every kind, unchanged. Fragments
+that can reach an implementer kind carry one; the ones scoped to `spec-writer` / `playwright` /
+document-authoring kinds (which are not implementers) deliberately do not.
+
+Every fragment in **this** package is comfortably under `FRAGMENT_BRIEF_MIN_BODY_CHARS`, so the
+auto-condensation below never acts on the shipped catalog: keep it that way by writing a brief
+by hand when a built-in grows past ~1,500 characters.
+
+### Where a brief comes from at run time
+
+The built-in `brief` above is only the first of three answers. For a fragment resolved through
+the tenant library ([ADR 0006](https://github.com/kibertoad/cat-factory/blob/main/backend/docs/adr/0006-prompt-fragment-library.md)) the resolution
+order is:
+
+1. **The winning tier's linked `brief`**: a built-in's, or the one a tenant authored on its own
+   managed row (the library editor's short-version field, or a repo-sourced guideline file's
+   `brief:` frontmatter key).
+2. **A model-GENERATED condensation**, for a body over `FRAGMENT_BRIEF_MIN_BODY_CHARS` that has
+   no linked brief. Produced once on the first implementer dispatch that folds it, persisted, and
+   **regenerated whenever the body changes**: a library edit, a repo resync, or a living
+   document re-resolved at run time.
+3. **Nothing**: the full `body` is folded for every kind, which is also where every failure on
+   that path lands (no model wired, an unreadable store, a refused condensation).
+
+Design, decisions and gotchas:
+[`docs/initiatives/auto-generated-fragment-briefs.md`](https://github.com/kibertoad/cat-factory/blob/main/docs/initiatives/auto-generated-fragment-briefs.md).
+
+## Programmatic deployment seams (custom fragments + per-task-type defaults)
+
+A deployment (local **or** hosted) extends the fragment behaviour through the app-owned
+`PromptFragmentRegistry` (kernel), injected BY REFERENCE into the facade it builds. No fork, no
+rebuild, no per-workspace UI.
+
+> **This replaced two MODULE GLOBALS** (`registerPromptFragment` and
+> `registerTaskTypeDefaultFragments`), and the reason is worth stating because it is invisible from
+> inside this repo. Their correctness depended on every reader resolving the same physical copy of
+> this package. A `workspace:*` dependency publishes as an EXACT version, so a consumer floating the
+> range onto a newer patch gets TWO copies: the registration lands in one, the server reads the
+> other, and every task of the deployment's operation is seeded with ids that fold nothing. The only
+> signal was one boot warning, which is also the warning a typo produces.
+
+- **Build the registry**: `promptFragmentRegistryWithBuiltins()` (this package) news one carrying
+  the shipped catalog and its built-in per-type defaults; `defaultPromptFragmentRegistry()` (kernel)
+  news an EMPTY one, which is how a deployment says it wants only its own standards. The built-ins
+  install through the registry's ordinary public methods, so the platform exercises a consumer's own
+  seam on every boot and it cannot rot for consumers only.
+- **Add custom fragments to the universal pool**: `registry.register(fragment)` /
+  `registry.registerAll(fragments)`. Every `GET /prompt-fragments` catalog read and every run-time
+  body lookup then sees them; re-registering an id REPLACES the entry of that id, so a deployment
+  refines a shipped standard in place.
+- **Mark fragments as the default for a BUILT-IN task type**:
+  `registry.registerTaskTypeDefaults(taskType, fragmentIds)`. Every **new** task of that type
+  (`document`, `review`, `feature`, …) is then seeded with those fragments onto its own
+  `fragmentIds` at creation, beside whatever it inherits from its service. Seeding is server-side
+  and authoritative: it applies even for tasks created via the public API with no create-form picker.
+
+  **Registering a type REPLACES its built-in set rather than unioning with it.** The module-global
+  seam unioned silently, which meant a deployment could not remove a shipped default however it
+  wrote the call. Spread `DEFAULT_DOCUMENT_STYLE_FRAGMENT_IDS` into your own list to keep both,
+  which says so in the code.
+
+  **A deployment's OWN (namespaced) task type does not use this seam.** It declares
+  `defaultFragmentIds` (and `conditionalFragmentIds`, for standing context that depends on the
+  answers a case supplies) on its own registration, where boot validation can see the ids and warn
+  on one the code pool does not resolve. That declaration is one third of a **reusable operation**:
+  see [`backend/docs/reusable-operations.md`](https://github.com/kibertoad/cat-factory/blob/main/backend/docs/reusable-operations.md).
+
+- **A code-registered fragment may NOT carry a `documentRef`.** Every code registration lands on the
+  `builtin` tier, whose live resolution needs a connection workspace a deployment-wide registration
+  cannot name, so boot REFUSES it (`fragment_document_ref_unsupported`) rather than carrying it,
+  rendering it as live in the library UI, and ignoring it at run time (which is what it did).
+  Register the body inline, or create the fragment at the ACCOUNT tier with a fetch-via workspace.
+
+```ts
+// deployment entry, before start()/startLocal()
+import { promptFragmentRegistryWithBuiltins } from '@cat-factory/prompt-fragments'
+
+const promptFragmentRegistry = promptFragmentRegistryWithBuiltins()
+promptFragmentRegistry.registerAll([
+  {
+    id: 'org.review-checklist',
+    version: '1.0.0',
+    title: 'Review checklist',
+    summary: 'Our PR review bar.',
+    body: '- Check error handling…',
+  },
+])
+// every new REVIEW task starts with this guidance
+promptFragmentRegistry.registerTaskTypeDefaults('review', ['org.review-checklist'])
+
+// …and the SAME instance goes into the facade, which is the whole point.
+start({ promptFragmentRegistry /* …the rest */ })
+```
+
+**In MOTHERSHIP mode the pool is read from the mothership**, not from the node's own registry: the
+standards are org state, and a node one build behind would otherwise fold different guidance than
+the deployment registered. A failed read THROWS rather than answering with an empty pool, because
+"the mothership is unreachable" and "this deployment registers no standards" are the same value and
+opposite facts. Boot warns and names any fragments registered on a mothership-mode node.
+
+## Adding a collection
+
+1. Create `src/collections/<topic>.ts` and export an array of `PromptFragment`.
+2. Spread it into `FRAGMENTS` in `src/index.ts`.
+3. Keep ids **globally unique and stable**: blocks persist them, so a renamed id
+   silently drops a selection (unknown ids are skipped, never error).
+
+```bash
+pnpm --filter @cat-factory/prompt-fragments build       # tsc → dist/
+pnpm --filter @cat-factory/prompt-fragments typecheck
+```

package/dist/collections/acceptance.d.ts

@@ -0,0 +1,3 @@
+import type { PromptFragment } from '@cat-factory/contracts';
+export declare const acceptanceFragments: PromptFragment[];
+//# sourceMappingURL=acceptance.d.ts.map

package/dist/collections/acceptance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"acceptance.d.ts","sourceRoot":"","sources":["../../src/collections/acceptance.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAU5D,eAAO,MAAM,mBAAmB,EAAE,cAAc,EAuD/C,CAAA"}

package/dist/collections/acceptance.js

@@ -0,0 +1,63 @@
+// Best-practice fragments for the acceptance-testing track: authoring the
+// structured Given/When/Then acceptance scenarios as part of the service spec (the
+// `spec-writer`), and turning the derived Gherkin into runnable tests (the
+// `playwright` step). The runnable-tests step uses Playwright for user-facing blocks
+// and the project's own test framework for backend blocks, so there is one fragment
+// per surface, scoped by block type. Selected per block, these bodies are injected
+// verbatim into the relevant agents' system prompts.
+export const acceptanceFragments = [
+    {
+        id: 'acceptance.scenarios',
+        version: '1.0.0',
+        title: 'Acceptance scenarios',
+        category: 'Acceptance testing',
+        summary: 'Given/When/Then scenarios tied to requirements, asserting observable behaviour.',
+        body: [
+            'Acceptance scenario standards:',
+            '- Trace every scenario back to a stated requirement; do not test behaviour nobody asked for.',
+            '- Write each scenario as a titled Given / When / Then with a single clear When and concrete, observable Then assertions.',
+            '- Cover the happy path, the meaningful alternative flows, error handling and boundary conditions — in that order of priority.',
+            '- Keep scenarios independent and deterministic: each sets up its own state and asserts user-visible outcomes, never internals.',
+            '- Call out any requirement that is ambiguous or untestable instead of guessing at the intended behaviour.',
+        ].join('\n'),
+        appliesTo: { agentKinds: ['spec-writer'] },
+    },
+    {
+        id: 'playwright.e2e',
+        version: '1.0.0',
+        title: 'Playwright end-to-end tests',
+        category: 'Acceptance testing',
+        summary: 'User-facing locators, web-first assertions, isolated and idempotent test files.',
+        body: [
+            'Playwright end-to-end test standards:',
+            '- Map one `test` to one acceptance scenario and name it after the scenario so coverage is traceable.',
+            '- Be additive: only add tests for scenarios that lack one; never duplicate or silently rewrite an existing test.',
+            '- Select elements by user-facing locators (getByRole, getByLabel, getByText), not brittle CSS or XPath.',
+            '- Rely on web-first auto-retrying assertions (expect(locator)…) and await every action; never use fixed sleeps.',
+            '- Keep each test isolated and deterministic — fresh state per test, no ordering dependencies between tests.',
+            '- Target the environment URL from the run context and read credentials from the harness; never hard-code secrets or hosts.',
+        ].join('\n'),
+        appliesTo: { blockTypes: ['frontend', 'environment'], agentKinds: ['playwright'] },
+    },
+    {
+        id: 'acceptance.backend-tests',
+        version: '1.0.0',
+        title: 'Backend acceptance tests',
+        category: 'Acceptance testing',
+        summary: "Acceptance tests in the project's own framework, driven through public backend interfaces.",
+        body: [
+            'Backend acceptance test standards:',
+            "- Write the tests with the project's existing test framework — discover it from the repo (test config, dev dependencies, the tests already present); do not introduce a new framework, and do not use Playwright or a browser for behaviour with no UI.",
+            '- Map one test to one acceptance scenario and name it after the scenario so coverage is traceable.',
+            '- Be additive: only add tests for scenarios that lack one; never duplicate or silently rewrite an existing test.',
+            '- Drive the system through its outermost public interface (HTTP/API calls, queue messages, exported functions) and assert on observable behaviour, never on internals.',
+            '- Keep each test isolated and deterministic — fresh state per test, no ordering dependencies; await async work instead of fixed sleeps.',
+            '- Target the system at the URL / entry point from the run context and read credentials from the harness; never hard-code secrets or hosts.',
+        ].join('\n'),
+        appliesTo: {
+            blockTypes: ['service', 'api', 'database', 'queue', 'integration', 'external'],
+            agentKinds: ['playwright'],
+        },
+    },
+];
+//# sourceMappingURL=acceptance.js.map

package/dist/collections/acceptance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"acceptance.js","sourceRoot":"","sources":["../../src/collections/acceptance.ts"],"names":[],"mappings":"AAEA,0EAA0E;AAC1E,mFAAmF;AACnF,2EAA2E;AAC3E,qFAAqF;AACrF,oFAAoF;AACpF,mFAAmF;AACnF,qDAAqD;AAErD,MAAM,CAAC,MAAM,mBAAmB,GAAqB;IACnD;QACE,EAAE,EAAE,sBAAsB;QAC1B,OAAO,EAAE,OAAO;QAChB,KAAK,EAAE,sBAAsB;QAC7B,QAAQ,EAAE,oBAAoB;QAC9B,OAAO,EAAE,iFAAiF;QAC1F,IAAI,EAAE;YACJ,gCAAgC;YAChC,8FAA8F;YAC9F,0HAA0H;YAC1H,+HAA+H;YAC/H,gIAAgI;YAChI,2GAA2G;SAC5G,CAAC,IAAI,CAAC,IAAI,CAAC;QACZ,SAAS,EAAE,EAAE,UAAU,EAAE,CAAC,aAAa,CAAC,EAAE;KAC3C;IACD;QACE,EAAE,EAAE,gBAAgB;QACpB,OAAO,EAAE,OAAO;QAChB,KAAK,EAAE,6BAA6B;QACpC,QAAQ,EAAE,oBAAoB;QAC9B,OAAO,EAAE,iFAAiF;QAC1F,IAAI,EAAE;YACJ,uCAAuC;YACvC,sGAAsG;YACtG,kHAAkH;YAClH,yGAAyG;YACzG,iHAAiH;YACjH,6GAA6G;YAC7G,4HAA4H;SAC7H,CAAC,IAAI,CAAC,IAAI,CAAC;QACZ,SAAS,EAAE,EAAE,UAAU,EAAE,CAAC,UAAU,EAAE,aAAa,CAAC,EAAE,UAAU,EAAE,CAAC,YAAY,CAAC,EAAE;KACnF;IACD;QACE,EAAE,EAAE,0BAA0B;QAC9B,OAAO,EAAE,OAAO;QAChB,KAAK,EAAE,0BAA0B;QACjC,QAAQ,EAAE,oBAAoB;QAC9B,OAAO,EACL,4FAA4F;QAC9F,IAAI,EAAE;YACJ,oCAAoC;YACpC,yPAAyP;YACzP,oGAAoG;YACpG,kHAAkH;YAClH,wKAAwK;YACxK,yIAAyI;YACzI,4IAA4I;SAC7I,CAAC,IAAI,CAAC,IAAI,CAAC;QACZ,SAAS,EAAE;YACT,UAAU,EAAE,CAAC,SAAS,EAAE,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,aAAa,EAAE,UAAU,CAAC;YAC9E,UAAU,EAAE,CAAC,YAAY,CAAC;SAC3B;KACF;CACF,CAAA"}

package/dist/collections/design.d.ts

@@ -0,0 +1,28 @@
+import type { PromptFragment } from '@cat-factory/contracts';
+/**
+ * The one fragment that tells an agent how to consume materialised design context.
+ *
+ * Named as a constant because the ENGINE folds it by presence rather than by selection: a run whose
+ * resolved context carries a design-origin document gets it automatically
+ * ({@link withDesignContextFragment}). Before that it was auto-selected by nothing — the `appliesTo`
+ * selector below is a management-surface hint the run path never drove, the fragment is in no seed pin
+ * set, and basic mode hides the per-task fragment picker — so the standard case (a designer links a
+ * Figma frame and starts a run) executed with a design context file on disk and no instruction
+ * anywhere to honour it.
+ */
+export declare const DESIGN_CONTEXT_FRAGMENT_ID = "design.context";
+/**
+ * The applicable fragment ids for a run, plus `design.context` when that run actually carries a
+ * design document. PURE, and the ONLY place the presence rule lives.
+ *
+ * A deterministic presence rule at prompt assembly, deliberately NOT a revival of the retired
+ * `appliesTo` run-path selector: the trigger is the design document the run resolved, so it cannot
+ * drift from what is on disk — whereas a `blockTypes: ['frontend']` selector both misses a design
+ * linked to an unlabelled task and fires on a frontend task with no design at all.
+ *
+ * Appended LAST and only when not already present, so a workspace that pins the fragment explicitly
+ * (or overrides it in its own catalog) keeps its position and its single entry.
+ */
+export declare function withDesignContextFragment(ids: readonly string[], hasDesignContext: boolean): string[];
+export declare const designFragments: PromptFragment[];
+//# sourceMappingURL=design.d.ts.map

package/dist/collections/design.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"design.d.ts","sourceRoot":"","sources":["../../src/collections/design.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAQ5D;;;;;;;;;;GAUG;AACH,eAAO,MAAM,0BAA0B,mBAAmB,CAAA;AAE1D;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,CACvC,GAAG,EAAE,SAAS,MAAM,EAAE,EACtB,gBAAgB,EAAE,OAAO,GACxB,MAAM,EAAE,CAGV;AAED,eAAO,MAAM,eAAe,EAAE,cAAc,EA+B3C,CAAA"}

package/dist/collections/design.js

@@ -0,0 +1,65 @@
+// Best-practice fragment for working from linked design context. Source-neutral: every
+// design document source (Figma, Zeplin, …) materialises its frames/screens, component
+// inventory and design tokens into `.cat-context/*.md` in the SAME shape (`## <block>`
+// blocks, a global `### Components`, `### Design tokens`, optional `### References`), so
+// one fragment serves them all — the agent doesn't need to know which tool authored it.
+/**
+ * The one fragment that tells an agent how to consume materialised design context.
+ *
+ * Named as a constant because the ENGINE folds it by presence rather than by selection: a run whose
+ * resolved context carries a design-origin document gets it automatically
+ * ({@link withDesignContextFragment}). Before that it was auto-selected by nothing — the `appliesTo`
+ * selector below is a management-surface hint the run path never drove, the fragment is in no seed pin
+ * set, and basic mode hides the per-task fragment picker — so the standard case (a designer links a
+ * Figma frame and starts a run) executed with a design context file on disk and no instruction
+ * anywhere to honour it.
+ */
+export const DESIGN_CONTEXT_FRAGMENT_ID = 'design.context';
+/**
+ * The applicable fragment ids for a run, plus `design.context` when that run actually carries a
+ * design document. PURE, and the ONLY place the presence rule lives.
+ *
+ * A deterministic presence rule at prompt assembly, deliberately NOT a revival of the retired
+ * `appliesTo` run-path selector: the trigger is the design document the run resolved, so it cannot
+ * drift from what is on disk — whereas a `blockTypes: ['frontend']` selector both misses a design
+ * linked to an unlabelled task and fires on a frontend task with no design at all.
+ *
+ * Appended LAST and only when not already present, so a workspace that pins the fragment explicitly
+ * (or overrides it in its own catalog) keeps its position and its single entry.
+ */
+export function withDesignContextFragment(ids, hasDesignContext) {
+    if (!hasDesignContext || ids.includes(DESIGN_CONTEXT_FRAGMENT_ID))
+        return [...ids];
+    return [...ids, DESIGN_CONTEXT_FRAGMENT_ID];
+}
+export const designFragments = [
+    {
+        id: DESIGN_CONTEXT_FRAGMENT_ID,
+        version: '1.0.0',
+        title: 'Design context',
+        category: 'Design',
+        summary: 'Build UI from the linked design (Figma, Zeplin, …): reuse existing components and honour design tokens.',
+        body: [
+            'A design for this task has been materialised into the `.cat-context/` directory: one or more',
+            '`## <frame/screen>` blocks (each with a `### Layout` and/or `### Text content`), a global',
+            '`### Components` inventory, and `### Design tokens`. When implementing UI, use it as the source of',
+            'truth for structure and styling:',
+            '- Read each block’s `### Layout` as the component/element structure to build — follow its nesting and naming.',
+            '- Before creating a new component, check the `### Components` inventory against the components that already',
+            '  exist in this repository and REUSE the existing one when it matches; do not reinvent it.',
+            '- Honour the `### Design tokens` values (colours, spacing, typography) instead of hard-coding ad-hoc',
+            '  values; map them to the project’s existing token/theme system where one exists.',
+            '- `### Text content` is the screen’s copy/intent, not markup to paste verbatim.',
+            '- Any `### References` URL (e.g. a rendered preview) is reference-only — do not depend on fetching it; the',
+            '  textual layout/text/tokens above are the authoritative description.',
+        ].join('\n'),
+        brief: 'Design context: build UI from the `.cat-context/` design — follow each block’s `### Layout` for structure; reuse an existing repo component before creating one from the `### Components` inventory; honour `### Design tokens` via the project’s theme system instead of ad-hoc values; `### Text content` is copy, not markup; `### References` URLs are reference-only.',
+        // No `appliesTo`. The selector this fragment used to carry (`blockTypes: ['frontend']`) was
+        // wrong in both directions (it missed a design linked to an unlabelled task and fired on a
+        // frontend task with no design), and {@link withDesignContextFragment} replaced it. Leaving it
+        // beside the presence rule would keep the old behaviour alive wherever `appliesTo` is still
+        // read (the deterministic selector, the catalog gate, the management surface, which would go on
+        // labelling this frontend-only while the engine folds it for any block type carrying a design).
+    },
+];
+//# sourceMappingURL=design.js.map

package/dist/collections/design.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"design.js","sourceRoot":"","sources":["../../src/collections/design.ts"],"names":[],"mappings":"AAEA,uFAAuF;AACvF,uFAAuF;AACvF,uFAAuF;AACvF,yFAAyF;AACzF,wFAAwF;AAExF;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,gBAAgB,CAAA;AAE1D;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,yBAAyB,CACvC,GAAsB,EACtB,gBAAyB;IAEzB,IAAI,CAAC,gBAAgB,IAAI,GAAG,CAAC,QAAQ,CAAC,0BAA0B,CAAC;QAAE,OAAO,CAAC,GAAG,GAAG,CAAC,CAAA;IAClF,OAAO,CAAC,GAAG,GAAG,EAAE,0BAA0B,CAAC,CAAA;AAC7C,CAAC;AAED,MAAM,CAAC,MAAM,eAAe,GAAqB;IAC/C;QACE,EAAE,EAAE,0BAA0B;QAC9B,OAAO,EAAE,OAAO;QAChB,KAAK,EAAE,gBAAgB;QACvB,QAAQ,EAAE,QAAQ;QAClB,OAAO,EACL,yGAAyG;QAC3G,IAAI,EAAE;YACJ,8FAA8F;YAC9F,2FAA2F;YAC3F,oGAAoG;YACpG,kCAAkC;YAClC,+GAA+G;YAC/G,6GAA6G;YAC7G,4FAA4F;YAC5F,sGAAsG;YACtG,mFAAmF;YACnF,iFAAiF;YACjF,4GAA4G;YAC5G,uEAAuE;SACxE,CAAC,IAAI,CAAC,IAAI,CAAC;QACZ,KAAK,EACH,4WAA4W;QAC9W,4FAA4F;QAC5F,2FAA2F;QAC3F,+FAA+F;QAC/F,4FAA4F;QAC5F,gGAAgG;QAChG,gGAAgG;KACjG;CACF,CAAA"}

package/dist/collections/migration.d.ts

@@ -0,0 +1,20 @@
+import type { PromptFragment } from '@cat-factory/contracts';
+export declare const migrationFragments: PromptFragment[];
+/**
+ * The ids of the migration fragments, in catalog order — the single source of truth for "which
+ * best-practice fragments a technological migration applies by default". Derived from
+ * {@link migrationFragments} so it can never drift from the definitions. Consumed by the
+ * `preset_tech_migration` preset's descriptor `defaultFragmentIds` (T8, the workspace default set).
+ */
+export declare const MIGRATION_FRAGMENT_IDS: readonly string[];
+/**
+ * The migration fragment ids that apply to `agentKind`, in catalog order — the subset whose
+ * `appliesTo.agentKinds` includes the kind (a fragment with no `appliesTo` restriction applies to
+ * all). This RESPECTS each fragment's declared scoping, which the manual per-block `fragmentIds`
+ * pin path does NOT (the run-time resolver folds pinned bodies in unconditionally — only the
+ * automatic service-fragment selector consults `appliesTo`). `seedMigrationPlan` (T7) stamps this
+ * per item keyed off the item's PRIMARY producer (`coder` for coding items, `doc-writer` for the
+ * document items), so a doc task no longer receives the coding-only behaviour-preservation standard.
+ */
+export declare function migrationFragmentIdsFor(agentKind: string): string[];
+//# sourceMappingURL=migration.d.ts.map

package/dist/collections/migration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migration.d.ts","sourceRoot":"","sources":["../../src/collections/migration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAsB5D,eAAO,MAAM,kBAAkB,EAAE,cAAc,EA+D9C,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,EAAE,SAAS,MAAM,EAAwC,CAAA;AAE5F;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAInE"}

package/dist/collections/migration.js

@@ -0,0 +1,99 @@
+// Best-practice fragments for a TECHNOLOGICAL MIGRATION — swapping a load-bearing
+// technology (a database engine, a framework major, a language runtime, a core
+// library) behind a behaviour-preservation safety net. These are the default
+// fragments the `preset_tech_migration` initiative preset applies to the coding,
+// testing and document agents it spawns, so each body is written to steer WHATEVER
+// agent carries out a slice of a migration — hence the deliberately broad `appliesTo`
+// (a migration touches services, APIs, databases and libraries alike).
+//
+// Three concerns, one fragment each:
+//   - `migration.discipline`             — the invariant methodology (blast zone →
+//     coverage → transition → delivery → decommission; coverage BEFORE delivery).
+//   - `migration.behaviour-preservation` — how to pin observable behaviour so the
+//     swap is provably behaviour-neutral (outcomes at a seam, never internals).
+//   - `migration.confidence-case`        — the authoring standard for the
+//     evidence-backed coverage/confidence proof a human audits before delivery.
+//
+// The deep, phase-by-phase methodology (what a blast-zone report must enumerate, item
+// granularity) lives code-side in the preset's `promptAdditions`, NOT here — these are
+// the durable standards an agent follows while doing the work.
+export const migrationFragments = [
+    {
+        id: 'migration.discipline',
+        version: '1.0.0',
+        title: 'Migration discipline',
+        category: 'Migration',
+        summary: 'Know the blast zone, pin behaviour before the swap, deliver incrementally, then remove the old path.',
+        body: [
+            'Technological-migration discipline:',
+            '- What makes a migration safe is the discipline around it, not the code change: know the blast zone, pin behaviour, then swap — in that order.',
+            '- Establish the full blast zone before touching anything: every directly affected touchpoint AND its transitive reach (callers of callers, config, scheduled jobs, ops tooling, CI).',
+            '- Pin observable behaviour with tests BEFORE the swap. Coverage comes before delivery — never migrate code whose behaviour is not already characterised and green on the current technology.',
+            '- Decide the degree of backwards compatibility deliberately (big-bang vs dual-run vs adapter layer) and state it; do not let it emerge by accident.',
+            '- Deliver in small increments grouped by area, keeping the behaviour suite green on both the old and the new technology throughout — a red suite halts the migration.',
+            '- Finish the job: prove parity on the new target, flip the defaults, and REMOVE the old path. A migration that leaves the legacy code and its dependencies behind is not done.',
+            '- Record every non-obvious choice (a strategy per object, a retained legacy path, a compat posture) as an explicit decision, not a silent edit.',
+        ].join('\n'),
+        brief: 'Migration discipline: establish the full blast zone (incl. transitive callers, config, jobs, CI) first; pin observable behaviour with green tests BEFORE the swap; state the compatibility posture deliberately; deliver in small increments keeping the suite green on both technologies; finish by proving parity, flipping defaults and REMOVING the old path; record every non-obvious choice as an explicit decision.',
+        appliesTo: { agentKinds: ['spec-writer', 'architect', 'coder', 'tester', 'doc-writer'] },
+    },
+    {
+        id: 'migration.behaviour-preservation',
+        version: '1.0.0',
+        title: 'Behaviour preservation',
+        category: 'Migration',
+        summary: 'Pin observable outcomes at a seam above the swapped layer — never assert internals or vendor mechanics.',
+        body: [
+            'Behaviour-preservation standards for a migration:',
+            '- Write characterization tests at a seam ABOVE the layer being swapped (the API / service / repository boundary) so they survive the swap unchanged and prove the new technology behaves identically.',
+            '- Assert observable OUTCOMES, never internals or mechanisms: do not assert raw vendor error codes, implicit result ordering, or locking/isolation mechanics — assert the outcome a caller sees (the mapped error, an explicitly ordered result, the final committed state).',
+            '- Preserve the edge-case semantics that silently differ between technologies: NULL vs empty string, numeric/datetime precision and rounding, string collation and case/trailing-space comparison, pagination stability, and any identity/sequence values that leak into responses.',
+            '- Keep set-based work set-based. When replacing a set-based operation (a bulk statement, a set-based stored procedure) with application code, express it as one batched operation — NEVER an app-side per-row loop, which is an N+1 regression the old path did not have.',
+            '- Establish the baseline first: the behaviour suite must be green on the CURRENT technology before any migration code lands, so a later failure unambiguously means the swap changed behaviour.',
+            '- Be additive and traceable: add tests for behaviour that lacks coverage, name each test after the behaviour it pins, and never weaken or delete an existing assertion to make the new target pass.',
+        ].join('\n'),
+        brief: 'Behaviour preservation: characterize at a seam ABOVE the swapped layer so tests survive it; assert observable outcomes, never vendor error codes, implicit ordering or locking mechanics; preserve silently-differing edge semantics (NULL vs empty, precision/rounding, collation, pagination stability, leaked identity values); keep set-based work batched, never an app-side per-row loop; baseline green on the current technology first; be additive — never weaken an assertion to make the new target pass.',
+        appliesTo: { agentKinds: ['spec-writer', 'coder', 'tester', 'playwright'] },
+    },
+    {
+        id: 'migration.confidence-case',
+        version: '1.0.0',
+        title: 'Confidence-case authoring',
+        category: 'Migration',
+        summary: 'Author the coverage proof as evidence a human audits: per-touchpoint named tests, justified gaps, safety nets.',
+        body: [
+            'Confidence-case authoring standard:',
+            'The confidence case is an evidence-backed proof that coverage is sufficient for delivery — a human reviews and challenges it, they do not re-derive the sweep. Every claim must be grounded; hand-waving is grounds for rejection, not a passing case. Structure it as:',
+            '1. Expected blast zone — recap the touchpoint inventory and call out any deltas discovered since it was written.',
+            '2. Coverage grounding — a per-touchpoint map: each inventory row to the NAMED tests that cover it and WHAT observable behaviour each test pins. Cite real test names and real touchpoints; a row with no evidence is a gap, not covered.',
+            '3. Gaps and waivers — every uncovered or partially-covered touchpoint, each with an explicit justification, bounded by the stated coverage bar (strict = every touchpoint has a named covering test; pragmatic = waivers allowed, each justified).',
+            '4. Risk mitigations — what was done to reduce the migration risk (staged rollout, seam isolation, rehearsal).',
+            '5. Safety nets and safeguards — the dual-target test harness, the CI legs, the rollback / compatibility posture, and the gated delivery batches.',
+            '- Be the single writer of the confidence-case document: append to it, never fork a parallel copy, and keep it the one source of the safety argument.',
+        ].join('\n'),
+        brief: 'Confidence case: an evidence-backed proof a human audits, not a re-derivation — cover (1) expected blast zone plus deltas found since, (2) per-touchpoint coverage grounded in NAMED real tests and what each pins (an ungrounded row is a gap), (3) gaps/waivers each justified against the stated coverage bar, (4) risk mitigations, (5) safety nets (dual-target harness, CI legs, rollback posture, gated batches). Append to the one document; never fork a parallel copy.',
+        appliesTo: { agentKinds: ['coder', 'doc-writer'] },
+    },
+];
+/**
+ * The ids of the migration fragments, in catalog order — the single source of truth for "which
+ * best-practice fragments a technological migration applies by default". Derived from
+ * {@link migrationFragments} so it can never drift from the definitions. Consumed by the
+ * `preset_tech_migration` preset's descriptor `defaultFragmentIds` (T8, the workspace default set).
+ */
+export const MIGRATION_FRAGMENT_IDS = migrationFragments.map((f) => f.id);
+/**
+ * The migration fragment ids that apply to `agentKind`, in catalog order — the subset whose
+ * `appliesTo.agentKinds` includes the kind (a fragment with no `appliesTo` restriction applies to
+ * all). This RESPECTS each fragment's declared scoping, which the manual per-block `fragmentIds`
+ * pin path does NOT (the run-time resolver folds pinned bodies in unconditionally — only the
+ * automatic service-fragment selector consults `appliesTo`). `seedMigrationPlan` (T7) stamps this
+ * per item keyed off the item's PRIMARY producer (`coder` for coding items, `doc-writer` for the
+ * document items), so a doc task no longer receives the coding-only behaviour-preservation standard.
+ */
+export function migrationFragmentIdsFor(agentKind) {
+    return migrationFragments
+        .filter((f) => !f.appliesTo?.agentKinds || f.appliesTo.agentKinds.includes(agentKind))
+        .map((f) => f.id);
+}
+//# sourceMappingURL=migration.js.map

package/dist/collections/migration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"migration.js","sourceRoot":"","sources":["../../src/collections/migration.ts"],"names":[],"mappings":"AAEA,kFAAkF;AAClF,+EAA+E;AAC/E,6EAA6E;AAC7E,iFAAiF;AACjF,mFAAmF;AACnF,sFAAsF;AACtF,uEAAuE;AACvE,EAAE;AACF,qCAAqC;AACrC,mFAAmF;AACnF,kFAAkF;AAClF,kFAAkF;AAClF,gFAAgF;AAChF,0EAA0E;AAC1E,gFAAgF;AAChF,EAAE;AACF,sFAAsF;AACtF,uFAAuF;AACvF,+DAA+D;AAE/D,MAAM,CAAC,MAAM,kBAAkB,GAAqB;IAClD;QACE,EAAE,EAAE,sBAAsB;QAC1B,OAAO,EAAE,OAAO;QAChB,KAAK,EAAE,sBAAsB;QAC7B,QAAQ,EAAE,WAAW;QACrB,OAAO,EACL,sGAAsG;QACxG,IAAI,EAAE;YACJ,qCAAqC;YACrC,gJAAgJ;YAChJ,sLAAsL;YACtL,8LAA8L;YAC9L,qJAAqJ;YACrJ,uKAAuK;YACvK,gLAAgL;YAChL,iJAAiJ;SAClJ,CAAC,IAAI,CAAC,IAAI,CAAC;QACZ,KAAK,EACH,4ZAA4Z;QAC9Z,SAAS,EAAE,EAAE,UAAU,EAAE,CAAC,aAAa,EAAE,WAAW,EAAE,OAAO,EAAE,QAAQ,EAAE,YAAY,CAAC,EAAE;KACzF;IACD;QACE,EAAE,EAAE,kCAAkC;QACtC,OAAO,EAAE,OAAO;QAChB,KAAK,EAAE,wBAAwB;QAC/B,QAAQ,EAAE,WAAW;QACrB,OAAO,EACL,yGAAyG;QAC3G,IAAI,EAAE;YACJ,mDAAmD;YACnD,uMAAuM;YACvM,6QAA6Q;YAC7Q,oRAAoR;YACpR,2QAA2Q;YAC3Q,iMAAiM;YACjM,qMAAqM;SACtM,CAAC,IAAI,CAAC,IAAI,CAAC;QACZ,KAAK,EACH,sfAAsf;QACxf,SAAS,EAAE,EAAE,UAAU,EAAE,CAAC,aAAa,EAAE,OAAO,EAAE,QAAQ,EAAE,YAAY,CAAC,EAAE;KAC5E;IACD;QACE,EAAE,EAAE,2BAA2B;QAC/B,OAAO,EAAE,OAAO;QAChB,KAAK,EAAE,2BAA2B;QAClC,QAAQ,EAAE,WAAW;QACrB,OAAO,EACL,gHAAgH;QAClH,IAAI,EAAE;YACJ,qCAAqC;YACrC,yQAAyQ;YACzQ,kHAAkH;YAClH,0OAA0O;YAC1O,oPAAoP;YACpP,+GAA+G;YAC/G,kJAAkJ;YAClJ,sJAAsJ;SACvJ,CAAC,IAAI,CAAC,IAAI,CAAC;QACZ,KAAK,EACH,kdAAkd;QACpd,SAAS,EAAE,EAAE,UAAU,EAAE,CAAC,OAAO,EAAE,YAAY,CAAC,EAAE;KACnD;CACF,CAAA;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAsB,kBAAkB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAA;AAE5F;;;;;;;;GAQG;AACH,MAAM,UAAU,uBAAuB,CAAC,SAAiB;IACvD,OAAO,kBAAkB;SACtB,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,EAAE,UAAU,IAAI,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;SACrF,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAA;AACrB,CAAC"}

package/dist/collections/node.d.ts

@@ -0,0 +1,3 @@
+import type { PromptFragment } from '@cat-factory/contracts';
+export declare const nodeFragments: PromptFragment[];
+//# sourceMappingURL=node.d.ts.map

package/dist/collections/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../src/collections/node.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAM5D,eAAO,MAAM,aAAa,EAAE,cAAc,EAqCzC,CAAA"}

package/dist/collections/node.js

@@ -0,0 +1,40 @@
+// Best-practice fragments for Node.js / backend work. Each fragment's `body` is
+// injected verbatim into the agent system prompt when selected, so keep it
+// concise, imperative and standalone.
+export const nodeFragments = [
+    {
+        id: 'node.performance',
+        version: '1.0.0',
+        title: 'Node.js performance',
+        category: 'Node',
+        summary: 'Avoid event-loop blocking, stream large payloads, cache hot paths.',
+        body: [
+            'Node.js performance standards:',
+            '- Never block the event loop: move CPU-bound work to worker threads or break it into async chunks.',
+            '- Prefer streaming (Readable/Writable streams) over buffering large payloads in memory.',
+            '- Reuse connections and clients (HTTP agents, DB pools); do not create them per request.',
+            '- Cache expensive, idempotent computations and hot lookups; set explicit TTLs.',
+            '- Measure before optimising: profile with --prof / clinic and quote concrete numbers, not guesses.',
+        ].join('\n'),
+        brief: 'Node performance: never block the event loop (offload CPU-bound work); stream large payloads instead of buffering; reuse pooled clients/connections; cache hot idempotent lookups with TTLs; profile before optimising.',
+        appliesTo: { blockTypes: ['service', 'api', 'queue', 'integration'] },
+    },
+    {
+        id: 'node.best-practices',
+        version: '1.0.0',
+        title: 'Node.js best practices',
+        category: 'Node',
+        summary: 'Async/await error handling, config via env, structured logging, graceful shutdown.',
+        body: [
+            'Node.js best practices:',
+            '- Use async/await with explicit try/catch; never leave promises unhandled.',
+            '- Read configuration from the environment; never hard-code secrets or hosts.',
+            '- Validate all external input at the boundary before it reaches domain logic.',
+            '- Emit structured (JSON) logs with correlation ids; do not log secrets.',
+            '- Handle SIGTERM/SIGINT for graceful shutdown: stop accepting work, drain, then exit.',
+        ].join('\n'),
+        brief: 'Node best practices: async/await with try/catch (no unhandled promises); config from env, never hard-code secrets; validate external input at the boundary; structured logs with correlation ids, never secrets; graceful SIGTERM/SIGINT shutdown.',
+        appliesTo: { blockTypes: ['service', 'api', 'queue', 'integration', 'external'] },
+    },
+];
+//# sourceMappingURL=node.js.map

package/dist/collections/node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.js","sourceRoot":"","sources":["../../src/collections/node.ts"],"names":[],"mappings":"AAEA,gFAAgF;AAChF,2EAA2E;AAC3E,sCAAsC;AAEtC,MAAM,CAAC,MAAM,aAAa,GAAqB;IAC7C;QACE,EAAE,EAAE,kBAAkB;QACtB,OAAO,EAAE,OAAO;QAChB,KAAK,EAAE,qBAAqB;QAC5B,QAAQ,EAAE,MAAM;QAChB,OAAO,EAAE,oEAAoE;QAC7E,IAAI,EAAE;YACJ,gCAAgC;YAChC,oGAAoG;YACpG,yFAAyF;YACzF,0FAA0F;YAC1F,gFAAgF;YAChF,oGAAoG;SACrG,CAAC,IAAI,CAAC,IAAI,CAAC;QACZ,KAAK,EACH,yNAAyN;QAC3N,SAAS,EAAE,EAAE,UAAU,EAAE,CAAC,SAAS,EAAE,KAAK,EAAE,OAAO,EAAE,aAAa,CAAC,EAAE;KACtE;IACD;QACE,EAAE,EAAE,qBAAqB;QACzB,OAAO,EAAE,OAAO;QAChB,KAAK,EAAE,wBAAwB;QAC/B,QAAQ,EAAE,MAAM;QAChB,OAAO,EAAE,oFAAoF;QAC7F,IAAI,EAAE;YACJ,yBAAyB;YACzB,4EAA4E;YAC5E,8EAA8E;YAC9E,+EAA+E;YAC/E,yEAAyE;YACzE,uFAAuF;SACxF,CAAC,IAAI,CAAC,IAAI,CAAC;QACZ,KAAK,EACH,oPAAoP;QACtP,SAAS,EAAE,EAAE,UAAU,EAAE,CAAC,SAAS,EAAE,KAAK,EAAE,OAAO,EAAE,aAAa,EAAE,UAAU,CAAC,EAAE;KAClF;CACF,CAAA"}

package/dist/collections/react.d.ts

@@ -0,0 +1,3 @@
+import type { PromptFragment } from '@cat-factory/contracts';
+export declare const reactFragments: PromptFragment[];
+//# sourceMappingURL=react.d.ts.map

package/dist/collections/react.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.d.ts","sourceRoot":"","sources":["../../src/collections/react.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAI5D,eAAO,MAAM,cAAc,EAAE,cAAc,EAmB1C,CAAA"}

package/dist/collections/react.js

@@ -0,0 +1,21 @@
+// Best-practice fragments for React / frontend work.
+export const reactFragments = [
+    {
+        id: 'react.state-management',
+        version: '1.0.0',
+        title: 'React state management',
+        category: 'React',
+        summary: 'Keep state local, lift only when shared, derive instead of duplicating.',
+        body: [
+            'React state management standards:',
+            '- Keep state as local as possible; lift it up only when two components genuinely share it.',
+            '- Derive values during render instead of storing duplicated/denormalised state.',
+            '- Reach for a global store only for truly cross-cutting state; prefer context/props otherwise.',
+            '- Keep server state (fetched data) separate from UI state; use a data-fetching cache for it.',
+            '- Make effects depend on exactly what they use, and clean them up to avoid leaks.',
+        ].join('\n'),
+        brief: 'React state: keep it local, lift only when genuinely shared; derive during render instead of duplicating; global store only for cross-cutting state; keep server state separate (data-fetching cache); effects depend on exactly what they use and clean up.',
+        appliesTo: { blockTypes: ['frontend'] },
+    },
+];
+//# sourceMappingURL=react.js.map

package/dist/collections/react.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.js","sourceRoot":"","sources":["../../src/collections/react.ts"],"names":[],"mappings":"AAEA,qDAAqD;AAErD,MAAM,CAAC,MAAM,cAAc,GAAqB;IAC9C;QACE,EAAE,EAAE,wBAAwB;QAC5B,OAAO,EAAE,OAAO;QAChB,KAAK,EAAE,wBAAwB;QAC/B,QAAQ,EAAE,OAAO;QACjB,OAAO,EAAE,yEAAyE;QAClF,IAAI,EAAE;YACJ,mCAAmC;YACnC,4FAA4F;YAC5F,iFAAiF;YACjF,gGAAgG;YAChG,8FAA8F;YAC9F,mFAAmF;SACpF,CAAC,IAAI,CAAC,IAAI,CAAC;QACZ,KAAK,EACH,8PAA8P;QAChQ,SAAS,EAAE,EAAE,UAAU,EAAE,CAAC,UAAU,CAAC,EAAE;KACxC;CACF,CAAA"}

package/dist/collections/style.d.ts

@@ -0,0 +1,11 @@
+import type { PromptFragment } from '@cat-factory/contracts';
+export declare const styleFragments: PromptFragment[];
+/**
+ * The style fragments a NEW document task is pre-seeded with (default-on, user-removable
+ * like any block pin). The source of truth for "which style fragments a document task
+ * starts with" — the board service seeds these onto a document task's `fragmentIds` at
+ * creation, so the `doc-aware` authoring/review kinds fold them in without the prompt
+ * hard-coding the guidance.
+ */
+export declare const DEFAULT_DOCUMENT_STYLE_FRAGMENT_IDS: readonly string[];
+//# sourceMappingURL=style.d.ts.map

package/dist/collections/style.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"style.d.ts","sourceRoot":"","sources":["../../src/collections/style.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAY5D,eAAO,MAAM,cAAc,EAAE,cAAc,EA4C1C,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,mCAAmC,EAAE,SAAS,MAAM,EAGhE,CAAA"}

package/dist/collections/style.js

@@ -0,0 +1,64 @@
+// Universal WRITING-STYLE fragments for the document-authoring track. Unlike the
+// technical collections (node/react/acceptance/design), these are source- and
+// stack-neutral: they govern HOW prose is written, not what a service is built with.
+// They fold into the document-authoring kinds via the `doc-aware` trait (the same
+// engine path `code-aware` uses for the technical fragments), and are pre-selected by
+// default on a document task (see `DEFAULT_DOCUMENT_STYLE_FRAGMENT_IDS`), user-removable
+// like any block pin. Because the `doc-reviewer` companion also carries `doc-aware`, the
+// SAME bodies reach it as review criteria — style guidance is both an instruction to the
+// writer and a check by the reviewer.
+export const styleFragments = [
+    {
+        id: 'style.anti-llmisms',
+        version: '1.0.0',
+        title: 'Avoid LLM tells',
+        category: 'Writing style',
+        summary: 'Cut the machine-written tells: filler adverbs, hedging, throat-clearing, bullet inflation.',
+        body: [
+            'Write like a human editor, not a language model. Avoid the tells that mark machine-written prose:',
+            '- Drop filler intensifiers and cliches: "delve", "crucial", "vital", "seamless", "robust",',
+            '  "leverage", "utilize" (write "use"), "in the realm of", "navigate the landscape",',
+            '  "it is important to note", "it is worth noting", "when it comes to".',
+            '- Cut throat-clearing and hedging: "In today\'s fast-paced world", "As we all know",',
+            '  "It goes without saying", "Needless to say", "Arguably", "In conclusion". State the point.',
+            '- No summary that merely restates what was just said, and no section that only previews',
+            '  the next one. Every paragraph must add information.',
+            '- Do not inflate into bullet lists what is a sentence, and do not end every bullet with a',
+            '  parallel flourish. Use a list only for genuinely enumerable items.',
+            '- Do not overuse em-dashes, rhetorical questions, or the "It\'s not just X, it\'s Y" frame.',
+            '- Prefer plain, specific words over vague grandeur. Concrete nouns and real numbers beat',
+            '  adjectives. If a sentence survives deletion with no loss of meaning, delete it.',
+        ].join('\n'),
+    },
+    {
+        id: 'style.concise-actionable',
+        version: '1.0.0',
+        title: 'Concise and actionable',
+        category: 'Writing style',
+        summary: 'Lead with the point, active voice, one idea per paragraph; every recommendation names an actor and an action.',
+        body: [
+            'Write to be read fast and acted on:',
+            '- Lead with the conclusion. Put the answer, decision, or recommendation in the first',
+            '  sentence of a section, then support it. Do not build up to it.',
+            '- Active voice, present tense, second person where you address the reader. Name the actor:',
+            '  "the operator restarts the worker", not "the worker should be restarted".',
+            '- One idea per paragraph; one job per sentence. Break a long sentence into short ones.',
+            '- Every recommendation is actionable: it names WHO does WHAT, and when it applies. Replace',
+            '  "consideration should be given to caching" with "cache the catalog response for 60s".',
+            '- Prefer concrete examples, commands, and tables over abstract description.',
+            '- Cut ruthlessly. Say it once, in the fewest words that stay precise. Length is not thoroughness.',
+        ].join('\n'),
+    },
+];
+/**
+ * The style fragments a NEW document task is pre-seeded with (default-on, user-removable
+ * like any block pin). The source of truth for "which style fragments a document task
+ * starts with" — the board service seeds these onto a document task's `fragmentIds` at
+ * creation, so the `doc-aware` authoring/review kinds fold them in without the prompt
+ * hard-coding the guidance.
+ */
+export const DEFAULT_DOCUMENT_STYLE_FRAGMENT_IDS = [
+    'style.anti-llmisms',
+    'style.concise-actionable',
+];
+//# sourceMappingURL=style.js.map

package/dist/collections/style.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"style.js","sourceRoot":"","sources":["../../src/collections/style.ts"],"names":[],"mappings":"AAEA,iFAAiF;AACjF,8EAA8E;AAC9E,qFAAqF;AACrF,kFAAkF;AAClF,sFAAsF;AACtF,yFAAyF;AACzF,yFAAyF;AACzF,yFAAyF;AACzF,sCAAsC;AAEtC,MAAM,CAAC,MAAM,cAAc,GAAqB;IAC9C;QACE,EAAE,EAAE,oBAAoB;QACxB,OAAO,EAAE,OAAO;QAChB,KAAK,EAAE,iBAAiB;QACxB,QAAQ,EAAE,eAAe;QACzB,OAAO,EACL,4FAA4F;QAC9F,IAAI,EAAE;YACJ,mGAAmG;YACnG,4FAA4F;YAC5F,qFAAqF;YACrF,wEAAwE;YACxE,sFAAsF;YACtF,8FAA8F;YAC9F,yFAAyF;YACzF,uDAAuD;YACvD,2FAA2F;YAC3F,sEAAsE;YACtE,6FAA6F;YAC7F,0FAA0F;YAC1F,mFAAmF;SACpF,CAAC,IAAI,CAAC,IAAI,CAAC;KACb;IACD;QACE,EAAE,EAAE,0BAA0B;QAC9B,OAAO,EAAE,OAAO;QAChB,KAAK,EAAE,wBAAwB;QAC/B,QAAQ,EAAE,eAAe;QACzB,OAAO,EACL,+GAA+G;QACjH,IAAI,EAAE;YACJ,qCAAqC;YACrC,sFAAsF;YACtF,kEAAkE;YAClE,4FAA4F;YAC5F,6EAA6E;YAC7E,wFAAwF;YACxF,4FAA4F;YAC5F,yFAAyF;YACzF,6EAA6E;YAC7E,mGAAmG;SACpG,CAAC,IAAI,CAAC,IAAI,CAAC;KACb;CACF,CAAA;AAED;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,mCAAmC,GAAsB;IACpE,oBAAoB;IACpB,0BAA0B;CAC3B,CAAA"}

package/dist/index.d.ts

@@ -0,0 +1,39 @@
+import type { PromptFragment } from '@cat-factory/contracts';
+import { PromptFragmentRegistry } from '@cat-factory/kernel';
+export type { PromptFragment } from '@cat-factory/contracts';
+export declare const FRAGMENTS: PromptFragment[];
+export { styleFragments, DEFAULT_DOCUMENT_STYLE_FRAGMENT_IDS } from './collections/style.js';
+export { BUILTIN_TASK_TYPE_DEFAULTS } from './task-type-defaults.js';
+export { MIGRATION_FRAGMENT_IDS, migrationFragmentIdsFor } from './collections/migration.js';
+export { DESIGN_CONTEXT_FRAGMENT_ID, withDesignContextFragment } from './collections/design.js';
+/** Fragments keyed by id for O(1) lookup during prompt composition. */
+export declare const FRAGMENTS_BY_ID: ReadonlyMap<string, PromptFragment>;
+/**
+ * A {@link PromptFragmentRegistry} carrying the SHIPPED catalog and its built-in per-task-type
+ * default sets. Each facade's composition root news one, and a deployment registers its own
+ * standards onto the same instance by reference.
+ *
+ * The built-ins install through the registry's ordinary public methods rather than being baked in,
+ * which is the `defaultGateRegistry()` ⇄ `@cat-factory/gates` shape: the platform exercises the
+ * consumer's own seam on every boot, so it cannot rot for consumers only. Registration order is
+ * what makes a deployment's re-registration of a shipped id an override, so the built-ins go first.
+ *
+ * This replaced two module globals (`registerPromptFragment`'s map and
+ * `registerTaskTypeDefaultFragments`') whose correctness depended on every reader resolving the
+ * same physical copy of this package. A `workspace:*` dependency publishes as an EXACT version, so
+ * a consumer floating the range onto a newer patch got two copies: the registration landed in one,
+ * the server read the other, and every task of the deployment's operation was seeded with ids that
+ * folded nothing. Injection by reference makes that unrepresentable.
+ */
+export declare function promptFragmentRegistryWithBuiltins(): PromptFragmentRegistry;
+/**
+ * Resolve a fragment from the SHIPPED catalog by id, or `undefined`.
+ *
+ * Strictly the built-ins: a deployment's own fragments live on the injected registry, and the
+ * paths still calling this are the ones with no registry in hand (a prompt composed outside a
+ * container, a test harness). That narrowing is deliberate rather than a leftover. Before it,
+ * this function silently answered from a module global that a second copy of the package would
+ * have left empty, which is the whole failure the registry removes.
+ */
+export declare function getFragment(id: string): PromptFragment | undefined;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAY,MAAM,wBAAwB,CAAA;AACtE,OAAO,EAAE,sBAAsB,EAAiC,MAAM,qBAAqB,CAAA;AAkB3F,YAAY,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAE5D,eAAO,MAAM,SAAS,EAAE,cAAc,EAOrC,CAAA;AAKD,OAAO,EAAE,cAAc,EAAE,mCAAmC,EAAE,MAAM,wBAAwB,CAAA;AAG5F,OAAO,EAAE,0BAA0B,EAAE,MAAM,yBAAyB,CAAA;AAKpE,OAAO,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAA;AAI5F,OAAO,EAAE,0BAA0B,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAA;AAE/F,uEAAuE;AACvE,eAAO,MAAM,eAAe,EAAE,WAAW,CAAC,MAAM,EAAE,cAAc,CAE/D,CAAA;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,kCAAkC,IAAI,sBAAsB,CAO3E;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAElE"}

package/dist/index.js

@@ -0,0 +1,73 @@
+import { PromptFragmentRegistry, defaultPromptFragmentRegistry } from '@cat-factory/kernel';
+import { BUILTIN_TASK_TYPE_DEFAULTS } from './task-type-defaults.js';
+import { acceptanceFragments } from './collections/acceptance.js';
+import { designFragments } from './collections/design.js';
+import { migrationFragments } from './collections/migration.js';
+import { nodeFragments } from './collections/node.js';
+import { reactFragments } from './collections/react.js';
+import { styleFragments } from './collections/style.js';
+export const FRAGMENTS = [
+    ...nodeFragments,
+    ...reactFragments,
+    ...acceptanceFragments,
+    ...designFragments,
+    ...styleFragments,
+    ...migrationFragments,
+];
+// Re-export the writing-style collection + the document-task style defaults so a consumer (the
+// board service seeding a new document task's fragments, the docs-refresh preset building its
+// `styleFragments` form options) draws on the same source of truth the catalog is built from.
+export { styleFragments, DEFAULT_DOCUMENT_STYLE_FRAGMENT_IDS } from './collections/style.js';
+// The built-in per-task-type default sets, installed onto a registry by
+// `promptFragmentRegistryWithBuiltins` below.
+export { BUILTIN_TASK_TYPE_DEFAULTS } from './task-type-defaults.js';
+// Re-export the migration fragment ids so the `preset_tech_migration` preset draws its default
+// fragment set from the same source of truth the catalog is built from: `MIGRATION_FRAGMENT_IDS`
+// (T8's descriptor `defaultFragmentIds`) + `migrationFragmentIdsFor` (T7's `seedMigrationPlan`,
+// which stamps the per-agent-kind subset that respects each fragment's `appliesTo`).
+export { MIGRATION_FRAGMENT_IDS, migrationFragmentIdsFor } from './collections/migration.js';
+// The design-context fragment's id + the engine's presence rule for folding it: a run whose resolved
+// context carries a design-origin document reads the guidance automatically, rather than depending on
+// a human having ticked it in a picker basic mode does not show.
+export { DESIGN_CONTEXT_FRAGMENT_ID, withDesignContextFragment } from './collections/design.js';
+/** Fragments keyed by id for O(1) lookup during prompt composition. */
+export const FRAGMENTS_BY_ID = new Map(FRAGMENTS.map((fragment) => [fragment.id, fragment]));
+/**
+ * A {@link PromptFragmentRegistry} carrying the SHIPPED catalog and its built-in per-task-type
+ * default sets. Each facade's composition root news one, and a deployment registers its own
+ * standards onto the same instance by reference.
+ *
+ * The built-ins install through the registry's ordinary public methods rather than being baked in,
+ * which is the `defaultGateRegistry()` ⇄ `@cat-factory/gates` shape: the platform exercises the
+ * consumer's own seam on every boot, so it cannot rot for consumers only. Registration order is
+ * what makes a deployment's re-registration of a shipped id an override, so the built-ins go first.
+ *
+ * This replaced two module globals (`registerPromptFragment`'s map and
+ * `registerTaskTypeDefaultFragments`') whose correctness depended on every reader resolving the
+ * same physical copy of this package. A `workspace:*` dependency publishes as an EXACT version, so
+ * a consumer floating the range onto a newer patch got two copies: the registration landed in one,
+ * the server read the other, and every task of the deployment's operation was seeded with ids that
+ * folded nothing. Injection by reference makes that unrepresentable.
+ */
+export function promptFragmentRegistryWithBuiltins() {
+    const registry = defaultPromptFragmentRegistry();
+    registry.registerAll(FRAGMENTS);
+    for (const [taskType, ids] of Object.entries(BUILTIN_TASK_TYPE_DEFAULTS)) {
+        if (ids)
+            registry.registerTaskTypeDefaults(taskType, ids);
+    }
+    return registry;
+}
+/**
+ * Resolve a fragment from the SHIPPED catalog by id, or `undefined`.
+ *
+ * Strictly the built-ins: a deployment's own fragments live on the injected registry, and the
+ * paths still calling this are the ones with no registry in hand (a prompt composed outside a
+ * container, a test harness). That narrowing is deliberate rather than a leftover. Before it,
+ * this function silently answered from a module global that a second copy of the package would
+ * have left empty, which is the whole failure the registry removes.
+ */
+export function getFragment(id) {
+    return FRAGMENTS_BY_ID.get(id);
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,sBAAsB,EAAE,6BAA6B,EAAE,MAAM,qBAAqB,CAAA;AAC3F,OAAO,EAAE,0BAA0B,EAAE,MAAM,yBAAyB,CAAA;AACpE,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAA;AACjE,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAA;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAA;AAC/D,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AACvD,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAavD,MAAM,CAAC,MAAM,SAAS,GAAqB;IACzC,GAAG,aAAa;IAChB,GAAG,cAAc;IACjB,GAAG,mBAAmB;IACtB,GAAG,eAAe;IAClB,GAAG,cAAc;IACjB,GAAG,kBAAkB;CACtB,CAAA;AAED,+FAA+F;AAC/F,8FAA8F;AAC9F,8FAA8F;AAC9F,OAAO,EAAE,cAAc,EAAE,mCAAmC,EAAE,MAAM,wBAAwB,CAAA;AAC5F,wEAAwE;AACxE,8CAA8C;AAC9C,OAAO,EAAE,0BAA0B,EAAE,MAAM,yBAAyB,CAAA;AACpE,+FAA+F;AAC/F,iGAAiG;AACjG,gGAAgG;AAChG,qFAAqF;AACrF,OAAO,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAA;AAC5F,qGAAqG;AACrG,sGAAsG;AACtG,iEAAiE;AACjE,OAAO,EAAE,0BAA0B,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAA;AAE/F,uEAAuE;AACvE,MAAM,CAAC,MAAM,eAAe,GAAwC,IAAI,GAAG,CACzE,SAAS,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC,CAAC,CACrD,CAAA;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,kCAAkC;IAChD,MAAM,QAAQ,GAAG,6BAA6B,EAAE,CAAA;IAChD,QAAQ,CAAC,WAAW,CAAC,SAAS,CAAC,CAAA;IAC/B,KAAK,MAAM,CAAC,QAAQ,EAAE,GAAG,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,0BAA0B,CAAC,EAAE,CAAC;QACzE,IAAI,GAAG;YAAE,QAAQ,CAAC,wBAAwB,CAAC,QAAoB,EAAE,GAAG,CAAC,CAAA;IACvE,CAAC;IACD,OAAO,QAAQ,CAAA;AACjB,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,WAAW,CAAC,EAAU;IACpC,OAAO,eAAe,CAAC,GAAG,CAAC,EAAE,CAAC,CAAA;AAChC,CAAC"}

package/dist/task-type-defaults.d.ts

@@ -0,0 +1,4 @@
+import type { TaskType } from '@cat-factory/contracts';
+/** The built-in per-task-type defaults shipped with the catalog (today: document only). */
+export declare const BUILTIN_TASK_TYPE_DEFAULTS: Partial<Record<TaskType, readonly string[]>>;
+//# sourceMappingURL=task-type-defaults.d.ts.map

package/dist/task-type-defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-type-defaults.d.ts","sourceRoot":"","sources":["../src/task-type-defaults.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAA;AA0BtD,2FAA2F;AAC3F,eAAO,MAAM,0BAA0B,EAAE,OAAO,CAAC,MAAM,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC,CAEnF,CAAA"}

package/dist/task-type-defaults.js

@@ -0,0 +1,28 @@
+import { DEFAULT_DOCUMENT_STYLE_FRAGMENT_IDS } from './collections/style.js';
+// ---------------------------------------------------------------------------
+// The BUILT-IN per-task-type default best-practice fragment ids.
+//
+// The fragments a NEW task of a given type (`document`, `review`, `feature`, …) is pre-seeded
+// with at creation. The board service unions these onto a task's `fragmentIds` when it is created
+// (alongside whatever the task inherits from its service or an explicit create-form pick), so
+// every new task of that type starts with the guidance without any per-block or per-workspace
+// configuration.
+//
+// A DEPLOYMENT declares its own through the app-owned registry
+// (`promptFragmentRegistry.registerTaskTypeDefaults('review', [...ids])`), which is what this
+// module used to hold as a second module global beside the fragment pool, with the identical
+// two-physical-copies hazard. The built-in sets below are installed onto that same registry by
+// `promptFragmentRegistryWithBuiltins()`, through the same public method, so the platform and a
+// consumer exercise one code path.
+//
+// Registering a task type REPLACES its set rather than unioning with these, which is a behaviour
+// change from the module-global seam and the honest one: a deployment's declaration is its final
+// answer, and the previous silent union meant a deployment could not remove a shipped default
+// however it wrote the call. A deployment that wants the writing-style set alongside its own
+// spreads `DEFAULT_DOCUMENT_STYLE_FRAGMENT_IDS` into its own list, which says so in the code.
+// ---------------------------------------------------------------------------
+/** The built-in per-task-type defaults shipped with the catalog (today: document only). */
+export const BUILTIN_TASK_TYPE_DEFAULTS = {
+    document: DEFAULT_DOCUMENT_STYLE_FRAGMENT_IDS,
+};
+//# sourceMappingURL=task-type-defaults.js.map

package/dist/task-type-defaults.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-type-defaults.js","sourceRoot":"","sources":["../src/task-type-defaults.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mCAAmC,EAAE,MAAM,wBAAwB,CAAA;AAE5E,8EAA8E;AAC9E,iEAAiE;AACjE,EAAE;AACF,8FAA8F;AAC9F,kGAAkG;AAClG,8FAA8F;AAC9F,8FAA8F;AAC9F,iBAAiB;AACjB,EAAE;AACF,+DAA+D;AAC/D,8FAA8F;AAC9F,6FAA6F;AAC7F,+FAA+F;AAC/F,gGAAgG;AAChG,mCAAmC;AACnC,EAAE;AACF,iGAAiG;AACjG,iGAAiG;AACjG,8FAA8F;AAC9F,6FAA6F;AAC7F,8FAA8F;AAC9F,8EAA8E;AAE9E,2FAA2F;AAC3F,MAAM,CAAC,MAAM,0BAA0B,GAAiD;IACtF,QAAQ,EAAE,mCAAmC;CAC9C,CAAA"}

package/package.json

@@ -1,7 +1,12 @@
 {
   "name": "@cat-factory/prompt-fragments",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Curated, versioned best-practice prompt fragments injected into agent system prompts.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kibertoad/cat-factory.git",
+    "directory": "backend/packages/prompt-fragments"
+  },
   "files": [
     "dist"
   ],
@@ -19,13 +24,17 @@
     "access": "public"
   },
   "dependencies": {
-    "@cat-factory/contracts": "1.0.0"
+    "@cat-factory/contracts": "0.256.0",
+    "@cat-factory/kernel": "0.255.0"
   },
   "devDependencies": {
-    "typescript": "^5.6.0"
+    "typescript": "7.0.2",
+    "vitest": "^4.1.10"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "typecheck": "tsc -p tsconfig.json --noEmit"
+    "build": "tsc -b tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest",
+    "test:run": "vitest run"
   }
 }