mustflow 2.103.21 → 2.103.31

package/templates/default/locales/en/.mustflow/skills/godot-code-change/SKILL.md

@@ -0,0 +1,272 @@
+---
+mustflow_doc: skill.godot-code-change
+locale: en
+canonical: true
+revision: 1
+lifecycle: mustflow-owned
+authority: procedure
+name: godot-code-change
+description: Apply this skill when Godot projects, scenes, nodes, GDScript, C# scripts, Resources, Autoloads, signals, groups, save/load systems, rendering, physics, UI, input, exports, plugins, editor tools, or Godot version migrations are created, changed, reviewed, or upgraded.
+metadata:
+  mustflow_schema: "1"
+  mustflow_kind: procedure
+  pack_id: mustflow.core
+  skill_id: mustflow.core.godot-code-change
+  command_intents:
+    - changes_status
+    - changes_diff_summary
+    - lint
+    - build
+    - test_related
+    - test
+    - docs_validate_fast
+    - mustflow_check
+---
+
+# Godot Code Change
+
+<!-- mustflow-section: purpose -->
+## Purpose
+
+Preserve Godot scene ownership, node lifecycle, Resource sharing, Autoload boundaries, signal flow,
+save/load integrity, rendering budgets, physics stability, export behavior, and version migration
+assumptions while making focused game or editor-tool changes.
+
+Godot work is not "script changes plus some scenes". Many failures come from scene-tree coupling,
+shared Resources mutated as instance state, Autoloads used as global storage, hidden signal
+connections, per-frame tree searches, blocking loads, save files written into `res://`, or renderer
+settings changed without profiling evidence.
+
+<!-- mustflow-section: use-when -->
+## Use When
+
+- `project.godot`, `.tscn`, `.tres`, `.res`, `.gd`, `.gdshader`, `.cs`, export presets, addons,
+  editor plugins, import settings, input maps, autoloads, groups, scenes, nodes, Resources, or
+  Godot-specific tests change.
+- Scene composition, ownership, instancing, inherited scenes, node paths, unique names, exported
+  NodePath references, groups, signals, tweens, animations, UI Controls, Containers, camera,
+  rendering, physics, input, save/load, or export templates are created, changed, reviewed, or
+  upgraded.
+- GDScript typing, `await`, signals, callables, `@onready`, `@export`, `ResourceLoader`,
+  `ResourceSaver`, `FileAccess`, `DirAccess`, `ConfigFile`, threaded loading, or Autoload behavior
+  affects runtime paths.
+- A Godot 3.x to 4.x migration, Godot 4.x minor upgrade, renderer change, platform export change,
+  mobile/XR/input change, or plugin compatibility change is part of the task.
+
+<!-- mustflow-section: do-not-use-when -->
+## Do Not Use When
+
+- The repository does not use Godot and only changes general assets, docs, or game design prose.
+- Generic C#, Rust, C++, JavaScript, or shader code changes have no Godot scene, resource, engine,
+  export, editor, or runtime lifecycle effect; use the matching language or asset skill instead.
+- The task only updates external version prose; use source-freshness guidance unless this procedure
+  itself changes.
+- Generated import files, caches, exported builds, or `.godot/` state should be regenerated by a
+  declared command rather than edited.
+
+<!-- mustflow-section: required-inputs -->
+## Required Inputs
+
+- Godot version, renderer, platform targets, export presets, project settings, input map, autoload
+  list, addon/plugin list, script language mix, and relevant official docs for the version in use.
+- Scene ledger: entry scene, affected `.tscn` files, node ownership, instanced scenes, inherited
+  scenes, unique names, NodePaths, groups, signals, animation players, tweens, UI Containers,
+  physics nodes, cameras, lights, materials, Resources, and save/load participants.
+- Runtime ledger: `_ready`, `_enter_tree`, `_exit_tree`, `_process`, `_physics_process`, input
+  callbacks, threaded loading, timers, deferred calls, scene transitions, queue/free behavior, and
+  profiler or frame-time evidence when performance is claimed.
+- Data ledger: user data paths, save schema version, migration path, atomic write strategy,
+  Resource cache behavior, config defaults, validation rules, and untrusted file boundaries.
+- Configured verification intents.
+
+<!-- mustflow-section: preconditions -->
+## Preconditions
+
+- Read project settings, affected scenes, scripts, Resources, autoload declarations, export presets,
+  and tests before editing.
+- Identify the Godot major/minor version before applying version-specific syntax, migration, or
+  export guidance. Do not mix stable docs for one branch, latest docs for another branch, and blog
+  examples as if they were one source.
+- Apply language-specific skills alongside this skill when C#, C++, Rust/GDExtension, shader, or
+  package/tooling behavior changes outside the Godot boundary.
+- Apply security, data, performance, UI, accessibility, or release skills when the change touches
+  save-file trust, networked games, monetized state, rendering budgets, UI behavior, or export
+  artifacts.
+
+<!-- mustflow-section: allowed-edits -->
+## Allowed Edits
+
+- Keep scenes independently instantiable where practical. Parent nodes may coordinate children, but
+  child scenes should not hard-code distant parents, sibling internals, or `/root/Main` paths.
+- Keep nodes for objects with lifecycle, transforms, notifications, or scene-tree behavior. Use
+  Resources, RefCounted, plain data, or DTOs for definitions and serializable state.
+- Keep Autoloads limited to true process-wide services such as scene transition, save service,
+  audio bus control, settings, telemetry facade, or platform integration.
+- Keep runtime-mutated Resources duplicated, local-to-scene, or separated from authoring data.
+- Keep user-writable data under `user://`, not `res://`.
+- Keep version-specific guidance behind a version gate and omit durable exact "latest" claims unless
+  refreshed from official sources.
+
+<!-- mustflow-section: procedure -->
+## Procedure
+
+1. Read the Godot version, renderer, export targets, project settings, autoload declarations, input
+   map, addon list, affected scenes, scripts, Resources, shaders, import/export files, and tests.
+2. Apply the Version Gate:
+   - identify current Godot major/minor version and whether the project is 3.x, 4.x, or in a
+     migration window;
+   - use official docs for the branch actually in use before applying syntax, API, renderer, export,
+     or migration behavior;
+   - treat stable docs, latest docs, release notes, blog posts, and pasted upgrade notes as
+     different evidence tracks until reconciled;
+   - for 4.x projects, check obsolete 3.x habits such as `yield`, stringly signal connections,
+     renderer assumptions, old physics behavior, and global singleton patterns before copying code.
+3. Build a scene and ownership ledger:
+   - entry scene, world/UI split, instanced subscenes, inherited scenes, lifecycle owner, cleanup
+     owner, injected dependencies, sibling relationships, NodePaths, groups, signals, and public
+     scene contract;
+   - reject distant relative paths, `/root/Main` reach-through, sibling-to-sibling hard references,
+     and child scenes that cannot run or preview outside one parent unless that coupling is
+     intentional and documented.
+4. Review node lifecycle and runtime order:
+   - distinguish `_enter_tree`, `_ready`, `_exit_tree`, `_process`, `_physics_process`, input
+     callbacks, timers, deferred calls, and scene transition timing;
+   - do not assume a new scene is immediately ready after `change_scene_to_*`;
+   - remember that `queue_free()` is deferred deletion, `remove_child()` is detachment, and
+     `replace_by()` does not automatically free the old node.
+5. Review signals, groups, and flow visibility:
+   - use signals for events, not hidden remote commands;
+   - avoid duplicate connections on scene re-entry and lambdas that cannot be disconnected when
+     lifecycle requires cleanup;
+   - prefer typed signal/callable patterns for maintained 4.x code;
+   - treat `call_group` and `set_group` as broad broadcasts that can stutter when used on many
+     nodes; chunk, defer, or queue high-volume work.
+6. Review Autoload and global state:
+   - keep Autoload APIs narrow and service-like;
+   - avoid putting player health, enemy state, UI control state, per-level state, or transient
+     request data into globals;
+   - do not free Autoloads during normal runtime;
+   - ensure scene transitions through an Autoload have an explicit ordering contract.
+7. Review Resources and serialized data:
+   - remember that path-loaded Resources are cached shared references;
+   - never mutate authoring Resources as per-instance runtime state unless they are duplicated or
+     local-to-scene by design;
+   - keep item definitions, tuning tables, materials, and animation data separate from player save
+     state;
+   - avoid using instance overrides as an untracked data-management system.
+8. Review GDScript and language boundaries:
+   - use static typing on long-lived gameplay systems, save DTOs, inventory, combat math, settings,
+     networking, and scene-transition managers;
+   - avoid per-frame `find_child`, `find_children`, and `find_parent`; cache references with
+     `@onready`, unique names, exported references, or dependency injection;
+   - use `_process` only for per-frame behavior, `_physics_process` for fixed-step physics, and
+     input callbacks for input events.
+9. Review save/load, config, and file I/O:
+   - save state snapshots, not raw node trees;
+   - write user data to `user://`;
+   - put schema, game/content version, slot id, timestamps, and migration path at the save root;
+   - use atomic temp, backup, validate, rename style writes when save loss matters;
+   - treat JSON as readable but type-weak; validate parsed data;
+   - avoid object deserialization from untrusted files, especially object-enabled Variant loading;
+   - use `ConfigFile` for settings, with defaults, validation, apply, and batched save behavior.
+10. Review loading, threads, and deferred work:
+    - use threaded resource requests with status polling before getting the loaded resource;
+    - avoid calling blocking loads during gameplay spikes or UI opening;
+    - do not touch active SceneTree nodes directly from background threads; use deferred calls or a
+      main-thread handoff;
+    - guard shared data with a clear ownership or mutex policy.
+11. Review rendering, UI, physics, and input:
+    - require profiler or frame-time evidence before accepting performance claims;
+    - for 3D, check visibility ranges, occlusion, HLOD/LOD, far plane, light counts, shadows,
+      materials, shader variants, particles, MultiMesh usage, and camera cost;
+    - for 2D, check draw calls, canvas layers, custom drawing invalidation, particles, tilemaps,
+      collision shapes, and physics tick stability;
+    - for UI, keep Container layout separate from animation transforms and avoid wrapper-node
+      sprawl when the current version has a cleaner Control transform path;
+    - for mobile/gamepad/XR, check input mode, focus loss, virtual controls, safe areas, and export
+      target behavior.
+12. Review export and plugin surfaces:
+    - keep export presets, export templates, platform architectures, signing, permissions, splash,
+      icon, native plugin, GDExtension, and addon compatibility explicit;
+    - do not edit generated imports, cache state, or exported binaries as source;
+    - verify release-sensitive export changes with configured package/release checks when available.
+13. Choose configured verification intents that cover scene loading, script parsing/type checks,
+    save/load migration, settings validation, scene transitions, rendering smoke, physics/input
+    behavior, export metadata, and package/template sync when available.
+
+<!-- mustflow-section: rejection-criteria -->
+## Review Rejection Criteria
+
+Reject or revise a change when:
+
+- Godot 3.x syntax, signals, renderer, physics, or singleton patterns are applied to a 4.x project
+  without checking the project version.
+- A subscene reaches distant parents, siblings, or `/root/Main` instead of receiving dependencies
+  through its parent, exported references, groups, or a service boundary.
+- Autoload becomes a catch-all for gameplay, UI, level, save, and platform state.
+- Runtime code mutates shared authoring Resources as if each instance owns a copy.
+- Save files are written under `res://`, lack a schema version, or deserialize trusted objects from
+  user-controlled data.
+- `_process` performs tree searches, heavy polling, loading, group broadcasts, or work that belongs
+  in input callbacks, timers, or cached references.
+- Threads touch live SceneTree nodes directly.
+- Scene transition code assumes old and new scenes are available synchronously after the transition
+  call.
+- Rendering, physics, or memory changes claim performance wins without profiler, frame-time, or
+  target-device evidence.
+- Export preset or platform changes omit target architecture, signing, permission, template, or
+  native-plugin impact.
+
+<!-- mustflow-section: postconditions -->
+## Postconditions
+
+- Scene ownership, node lifecycle, signals, groups, Autoloads, Resources, save/load, config,
+  rendering, physics, input, export, and version assumptions are intentional and reported.
+- Runtime-mutated state is separated from authoring Resources and process-wide services.
+- User-writable files, migrations, atomic writes, and untrusted data boundaries are explicit.
+- Version-specific guidance is refreshed from official sources for the project version or omitted
+  from durable claims.
+- Missing scene, save/load, rendering, physics, input, export, or target-device verification is
+  reported.
+
+<!-- mustflow-section: verification -->
+## Verification
+
+Use configured oneshot command intents when available:
+
+- `lint`
+- `build`
+- `test_related`
+- `test`
+- `docs_validate_fast`
+- `mustflow_check`
+
+Report missing Godot editor import, script parse, scene load, save migration, renderer smoke,
+physics/input, export preset, target-device, or release verification intents when relevant.
+
+<!-- mustflow-section: failure-handling -->
+## Failure Handling
+
+- If scene behavior is unclear, build the scene and ownership ledger before changing scripts.
+- If runtime errors mention missing nodes, inspect NodePaths, unique names, scene instancing,
+  lifecycle order, and scene transition timing before adding broader globals.
+- If shared data changes leak across instances, inspect Resource cache, duplication, local-to-scene,
+  instance overrides, and authored-versus-runtime state separation.
+- If save/load fails, inspect path choice, schema version, migration, parse errors, type validation,
+  atomic write behavior, and untrusted object deserialization.
+- If performance cannot be measured by configured intents, report the missing profiler, scene-load,
+  target-device, or export-smoke coverage instead of claiming a performance fix.
+- If official source freshness cannot be checked for a version, release, migration, or export claim,
+  omit the claim from durable skill text and report it as unverified snapshot context.
+
+<!-- mustflow-section: output-format -->
+## Output Format
+
+- Boundary checked
+- Godot version, renderer, scene, node, signal, Resource, Autoload, and lifecycle notes
+- Save/load, config, file I/O, threaded loading, and untrusted data notes
+- Rendering, physics, UI, input, export, plugin, and target-platform notes
+- Files changed
+- Command intents run
+- Skipped checks and reasons
+- Remaining Godot risk

package/templates/default/locales/en/.mustflow/skills/hono-code-change/SKILL.md

@@ -2,11 +2,11 @@
 mustflow_doc: skill.hono-code-change
 locale: en
 canonical: true
-revision: 1
+revision: 2
 lifecycle: mustflow-owned
 authority: procedure
 name: hono-code-change
-description: Apply this skill when Hono apps, routes, middleware, validators, RPC clients, bindings, context variables, auth boundaries, or runtime adapters are created or changed.
+description: Apply this skill when Hono apps, route chains, middleware order, validators, RPC or typed clients, OpenAPI schema generation, runtime bindings, context variables, auth, CORS, cookie, header, streaming, WebSocket, cache, static asset, or Cloudflare, Bun, Node, Deno, edge, or serverless adapter boundaries are created or changed.
 metadata:
   mustflow_schema: "1"
   mustflow_kind: procedure
@@ -28,26 +28,29 @@ metadata:
 <!-- mustflow-section: purpose -->
 ## Purpose
 
-Preserve Hono runtime, middleware, validation, context binding, auth, typed route, and response contract boundaries.
+Preserve Hono route registration, runtime adapter, middleware ordering, validation, context binding, auth, typed client, OpenAPI, streaming, cache, static asset, and response contract boundaries.
 
 <!-- mustflow-section: use-when -->
 ## Use When
 
-- `new Hono`, `app.get`, `app.post`, `app.use`, `c.env`, `c.get`, `c.set`, validators, RPC clients, middleware, adapters, or Hono route tests change.
-- The task touches Cloudflare Workers, Bun, Node, edge-compatible routes, bindings, variables, auth middleware, or response schemas.
+- `new Hono`, `app.route`, `basePath`, `app.get`, `app.post`, `app.use`, wildcard routes, fallback routes, `c.env`, `c.get`, `c.set`, `c.req.valid`, validators, RPC clients, middleware, adapters, or Hono route tests change.
+- The task touches Cloudflare Workers, Bun, Node, Deno, edge-compatible, serverless, SSR, static file, WebSocket, SSE, streaming, cache, cookie, CORS, CSRF, JWT, JWK, header, body-limit, binding, variable, auth middleware, OpenAPI, or response schema behavior.
+- The task exports or consumes `typeof app`, `typeof routes`, `AppType`, `hc`, `InferRequestType`, `InferResponseType`, `ApplyGlobalResponse`, OpenAPI clients, or generated SDKs from Hono routes.
 
 <!-- mustflow-section: do-not-use-when -->
 ## Do Not Use When
 
 - The task only touches framework-agnostic service code behind a Hono handler; use the relevant language or architecture skill.
 - Another HTTP framework is used instead of Hono.
+- The task only updates external framework version prose; use `source-freshness-check` unless the Hono procedure itself changes.
 
 <!-- mustflow-section: required-inputs -->
 ## Required Inputs
 
-- Package metadata, TypeScript config, runtime adapter config, worker or server entrypoint, routes, middleware, env/binding types, schemas, client types, and tests.
-- Target runtime matrix: Cloudflare, Bun, Node, edge-compatible, or single runtime.
-- Existing response envelope and error contract.
+- Package metadata, TypeScript config, runtime adapter config, worker or server entrypoint, route modules, middleware registration, env and binding types, context variables, schemas, validators, client type exports, OpenAPI generation, generated SDKs, and tests.
+- Target runtime matrix: Cloudflare Workers or Pages, Bun, Node with `@hono/node-server`, Deno, Lambda or other serverless adapter, edge-compatible, or single runtime.
+- Existing response envelope, status-code contract, error contract, CORS, cookie, header, cache, streaming, WebSocket, static file, body-size, and upload behavior.
+- Official or repository-local source evidence before preserving exact latest-version, patch-note, or adapter-behavior claims.
 
 <!-- mustflow-section: preconditions -->
 ## Preconditions
@@ -55,6 +58,7 @@ Preserve Hono runtime, middleware, validation, context binding, auth, typed rout
 - Confirm runtime before using platform APIs.
 - Identify `Bindings` for runtime-provided values and `Variables` for request-local middleware values.
 - Identify auth, validation, and error response boundaries before adding routes.
+- Refresh official package or vendor sources before preserving exact "latest", release-date, or security-patch claims; otherwise keep those facts out of the skill or mark them as snapshot-only in the report.
 
 <!-- mustflow-section: allowed-edits -->
 ## Allowed Edits
@@ -63,26 +67,33 @@ Preserve Hono runtime, middleware, validation, context binding, auth, typed rout
 - Register middleware in an order that preserves logging, CORS, security headers, body limits, auth, validation, and handler behavior.
 - Trust only validated request data in handlers.
 - Keep success and failure envelopes consistent.
+- Keep route type exports, RPC clients, OpenAPI documents, generated SDKs, tests, and docs synchronized when public API behavior changes.
 
 <!-- mustflow-section: procedure -->
 ## Procedure
 
-1. Read app entrypoint, runtime adapter, route modules, middleware, schemas, client type exports, and tests.
-2. Map the route boundary: method, path, runtime, auth, params, query, headers, cookies, body, variables, bindings, response statuses, and content types.
-3. Do not put Node-only, Bun-only, or Cloudflare-only APIs in shared routes.
-4. Keep auth middleware above protected routes and wildcard or fallback routes after specific routes.
-5. Separate `Bindings` from `Variables`; do not store request-local state in globals.
-6. Use validator output rather than rereading unvalidated request bodies.
-7. Preserve typed route or RPC inference by keeping handler responses in the framework's typed response path.
-8. Choose configured verification intents that cover type checks, route tests, auth failure, validation failure, and runtime env mocks when available.
+1. Read app entrypoint, runtime adapter, route modules, middleware, schemas, validator helpers, OpenAPI setup, client type exports, generated clients, and tests.
+2. Map the route boundary: method, path, registration order, runtime, auth, params, query, headers, cookies, body, variables, bindings, response statuses, content types, cache headers, streaming mode, and public client surface.
+3. Treat Hono route order as behavior. Keep specific routes before wildcard or fallback routes; check `route()`, `basePath()`, `mount`, optional params, regexp params, static routes, and fallback registration for shadowing or doubled prefixes.
+4. Keep auth, CORS, CSRF, secure headers, body limit, cookie, JWT, JWK, cache, ETag, compression, and logging middleware in an order that matches the security and observability boundary.
+5. For CORS with credentials, require an explicit origin allowlist or exact origin callback; do not rely on wildcard origin behavior or loose suffix checks.
+6. Separate `Bindings` from `Variables`; do not store request-local auth, user, session, tenant, or trace state in globals, module singletons, or runtime-wide mutable objects.
+7. Use `createMiddleware<{ Variables }>()` or route-local generics for context values that depend on middleware execution. Avoid `ContextVariableMap` unless the value is truly available for every request path.
+8. Use `c.req.valid(...)` output rather than rereading unvalidated request bodies. Remember that request bodies are one-shot, query and params are strings, header validator keys are lowercase, and `json` or `form` validators need the matching `Content-Type`.
+9. For multipart uploads, large JSON, webhooks, raw-body signatures, and file routes, check parser shape, body limits, runtime limits, storage limits, repeated-field behavior, and raw request cloning before changing handlers.
+10. Preserve typed route, RPC, and SDK inference by exporting the route chain actually used by `hc<AppType>()`, keeping handler responses on typed `c.json(payload, status)` paths, and avoiding broad `Context` handler extraction that drops path, validator, or response types.
+11. Keep runtime validation schema, OpenAPI schema, response schema, generated SDKs, and Hono RPC types from becoming separate truths. Choose one canonical contract and verify drift with tests or snapshots when available.
+12. Do not put Node-only, Bun-only, Cloudflare-only, Deno-only, Lambda-only, static-serving, connection-info, WebSocket, or filesystem APIs in shared route modules. Keep runtime entry files thin and pass plain config or adapter functions into shared app code.
+13. For streaming, SSE, WebSocket, cache, ETag, static file, and SSR or JSX routes, check cancellation, abort handling, backpressure, already-started-response errors, header retention, path traversal, cache key and `Vary`, repeated `Set-Cookie`, and adapter header normalization.
+14. Choose configured verification intents that cover type checks, route tests, auth failure, validation failure, CORS/cookie/header behavior, streaming or WebSocket behavior, OpenAPI or SDK generation, and runtime env mocks when available.
 
 <!-- mustflow-section: postconditions -->
 ## Postconditions
 
 - Runtime-specific APIs are isolated.
-- Middleware order and auth boundary are clear.
-- Request validation and response envelope are preserved.
-- Typed route or RPC contract impact is reported.
+- Middleware order, route order, and auth boundary are clear.
+- Request validation, body parsing, header/cookie/CORS/cache, and response envelope behavior are preserved.
+- Typed route, RPC, OpenAPI, generated SDK, and runtime adapter contract impact is reported.
 
 <!-- mustflow-section: verification -->
 ## Verification
@@ -96,21 +107,24 @@ Use configured oneshot command intents when available:
 - `docs_validate_fast`
 - `mustflow_check`
 
-Report missing multi-runtime or route-level verification intents when relevant.
+Report missing multi-runtime, route-level, streaming, WebSocket, OpenAPI, SDK, or adapter verification intents when relevant.
 
 <!-- mustflow-section: failure-handling -->
 ## Failure Handling
 
 - If runtime target is unclear, inspect adapter and deployment config before editing.
 - If a route needs a broader permission, binding, or auth change, switch to the relevant security or contract skill.
-- If typed route inference breaks, repair schema and response shape before adding more routes.
+- If typed route inference breaks, repair the route chain, validator, schema, and response shape before adding more routes.
+- If official source freshness cannot be checked for a version, release, or security-patch claim, omit the claim from durable skill text and report it as unverified snapshot context.
+- If streaming, WebSocket, cache, static, or adapter-specific behavior cannot be tested by configured intents, report the missing runtime smoke coverage.
 
 <!-- mustflow-section: output-format -->
 ## Output Format
 
 - Boundary checked
-- Runtime and middleware notes
-- Validation and response contract notes
+- Runtime, adapter, route-order, and middleware notes
+- Validation, RPC, OpenAPI, SDK, and response contract notes
+- CORS, cookie, header, cache, streaming, WebSocket, static, or SSR notes when touched
 - Files changed
 - Command intents run
 - Skipped checks and reasons

package/templates/default/locales/en/.mustflow/skills/routes.toml

@@ -528,6 +528,18 @@ route_type = "primary"
 priority = 85
 applies_to_reasons = ["code_change", "public_api_change", "test_change"]
 
+[routes."axum-code-change"]
+category = "general_code"
+route_type = "primary"
+priority = 85
+applies_to_reasons = ["code_change", "behavior_change", "public_api_change", "test_change", "docs_change", "performance_change", "security_change", "privacy_change", "data_change", "package_metadata_change", "release_risk"]
+
+[routes."godot-code-change"]
+category = "general_code"
+route_type = "primary"
+priority = 85
+applies_to_reasons = ["code_change", "behavior_change", "public_api_change", "test_change", "docs_change", "performance_change", "security_change", "privacy_change", "data_change", "ui_change", "package_metadata_change", "release_risk"]
+
 [routes."dart-code-change"]
 category = "general_code"
 route_type = "primary"
@@ -538,13 +550,13 @@ applies_to_reasons = ["code_change", "public_api_change", "test_change"]
 category = "general_code"
 route_type = "primary"
 priority = 85
-applies_to_reasons = ["code_change", "public_api_change", "security_change"]
+applies_to_reasons = ["code_change", "behavior_change", "public_api_change", "test_change", "docs_change", "performance_change", "security_change", "privacy_change", "package_metadata_change", "release_risk"]
 
 [routes."elysia-code-change"]
 category = "general_code"
 route_type = "primary"
 priority = 85
-applies_to_reasons = ["code_change", "public_api_change", "security_change"]
+applies_to_reasons = ["code_change", "behavior_change", "public_api_change", "test_change", "docs_change", "performance_change", "security_change", "privacy_change", "package_metadata_change", "release_risk"]
 
 [routes."source-anchor-authoring"]
 category = "general_code"
@@ -988,7 +1000,13 @@ applies_to_reasons = ["ui_change", "code_change", "public_api_change"]
 category = "ui_assets"
 route_type = "primary"
 priority = 85
-applies_to_reasons = ["ui_change", "docs_change", "code_change", "behavior_change", "migration_change", "package_metadata_change"]
+applies_to_reasons = ["ui_change", "docs_change", "code_change", "behavior_change", "public_api_change", "data_change", "security_change", "privacy_change", "performance_change", "test_change", "migration_change", "package_metadata_change", "release_risk"]
+
+[routes."babylon-code-change"]
+category = "ui_assets"
+route_type = "primary"
+priority = 85
+applies_to_reasons = ["ui_change", "code_change", "behavior_change", "public_api_change", "data_change", "security_change", "privacy_change", "performance_change", "test_change", "docs_change", "migration_change", "package_metadata_change", "release_risk"]
 
 [routes."react-code-change"]
 category = "ui_assets"
@@ -996,11 +1014,17 @@ route_type = "primary"
 priority = 85
 applies_to_reasons = ["ui_change", "code_change", "behavior_change", "public_api_change", "data_change", "security_change", "privacy_change", "performance_change", "test_change", "package_metadata_change", "release_risk"]
 
+[routes."vue-code-change"]
+category = "ui_assets"
+route_type = "primary"
+priority = 85
+applies_to_reasons = ["ui_change", "code_change", "behavior_change", "public_api_change", "data_change", "security_change", "privacy_change", "performance_change", "test_change", "package_metadata_change", "release_risk"]
+
 [routes."svelte-code-change"]
 category = "ui_assets"
 route_type = "primary"
 priority = 85
-applies_to_reasons = ["ui_change", "code_change", "behavior_change", "public_api_change", "data_change", "security_change", "privacy_change", "test_change", "package_metadata_change"]
+applies_to_reasons = ["ui_change", "code_change", "behavior_change", "public_api_change", "data_change", "security_change", "privacy_change", "performance_change", "test_change", "docs_change", "migration_change", "package_metadata_change", "release_risk"]
 
 [routes."pattern-scout"]
 category = "architecture_patterns"