mustflow 2.116.0 → 2.116.2

package/dist/core/source-anchors.js

@@ -116,6 +116,14 @@ function sourceAnchorPathPartIsIgnored(part, ignoredDirectoryNames) {
     return (ignoredDirectoryNames.has(part) ||
         SOURCE_ANCHOR_DEFAULT_EXCLUDED_PATH_PREFIXES.some((prefix) => part.startsWith(prefix)));
 }
+function directoryIsLinkedGitCheckout(directoryPath) {
+    try {
+        return statSync(path.join(directoryPath, '.git')).isFile();
+    }
+    catch {
+        return false;
+    }
+}
 function listFilesRecursive(root, options, current = root, depth = 0) {
     if (!existsSync(current)) {
         return [];
@@ -123,6 +131,9 @@ function listFilesRecursive(root, options, current = root, depth = 0) {
     if (depth > MAX_SOURCE_ANCHOR_DIRECTORY_DEPTH) {
         return [];
     }
+    if (depth > 0 && directoryIsLinkedGitCheckout(current)) {
+        return [];
+    }
     let currentRealPath;
     try {
         currentRealPath = realpathSync(current);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mustflow",
-  "version": "2.116.0",
+  "version": "2.116.2",
   "description": "Agent workflow documents and CLI for mustflow repository roots.",
   "type": "module",
   "license": "MIT-0",

package/templates/default/i18n.toml

@@ -62,7 +62,7 @@ translations = {}
 [documents."skills.index"]
 source = "locales/en/.mustflow/skills/INDEX.md"
 source_locale = "en"
-revision = 245
+revision = 277
 translations = {}
 
 [documents."skill.ada-code-change"]
@@ -191,6 +191,18 @@ source_locale = "en"
 revision = 1
 translations = {}
 
+[documents."skill.two-phase-transition-integrity-review"]
+source = "locales/en/.mustflow/skills/two-phase-transition-integrity-review/SKILL.md"
+source_locale = "en"
+revision = 2
+translations = {}
+
+[documents."skill.session-handoff-integrity-review"]
+source = "locales/en/.mustflow/skills/session-handoff-integrity-review/SKILL.md"
+source_locale = "en"
+revision = 2
+translations = {}
+
 [documents."skill.durable-workflow-orchestration"]
 source = "locales/en/.mustflow/skills/durable-workflow-orchestration/SKILL.md"
 source_locale = "en"
@@ -254,7 +266,7 @@ translations = {}
 [documents."skill.file-upload-security-review"]
 source = "locales/en/.mustflow/skills/file-upload-security-review/SKILL.md"
 source_locale = "en"
-revision = 1
+revision = 3
 translations = {}
 
 [documents."skill.error-message-integrity-review"]
@@ -434,7 +446,31 @@ translations = {}
 [documents."skill.parser-engineering-review"]
 source = "locales/en/.mustflow/skills/parser-engineering-review/SKILL.md"
 source_locale = "en"
-revision = 1
+revision = 4
+translations = {}
+
+[documents."skill.name-resolution-integrity-review"]
+source = "locales/en/.mustflow/skills/name-resolution-integrity-review/SKILL.md"
+source_locale = "en"
+revision = 2
+translations = {}
+
+[documents."skill.compiler-engineering-review"]
+source = "locales/en/.mustflow/skills/compiler-engineering-review/SKILL.md"
+source_locale = "en"
+revision = 6
+translations = {}
+
+[documents."skill.interpreter-engineering-review"]
+source = "locales/en/.mustflow/skills/interpreter-engineering-review/SKILL.md"
+source_locale = "en"
+revision = 2
+translations = {}
+
+[documents."skill.formal-verification-review"]
+source = "locales/en/.mustflow/skills/formal-verification-review/SKILL.md"
+source_locale = "en"
+revision = 2
 translations = {}
 
 [documents."skill.type-state-modeling-review"]
@@ -446,7 +482,25 @@ translations = {}
 [documents."skill.race-condition-review"]
 source = "locales/en/.mustflow/skills/race-condition-review/SKILL.md"
 source_locale = "en"
-revision = 3
+revision = 4
+translations = {}
+
+[documents."skill.input-event-synchronization-review"]
+source = "locales/en/.mustflow/skills/input-event-synchronization-review/SKILL.md"
+source_locale = "en"
+revision = 2
+translations = {}
+
+[documents."skill.modal-loop-reentrancy-review"]
+source = "locales/en/.mustflow/skills/modal-loop-reentrancy-review/SKILL.md"
+source_locale = "en"
+revision = 2
+translations = {}
+
+[documents."skill.ui-dispatch-lifecycle-review"]
+source = "locales/en/.mustflow/skills/ui-dispatch-lifecycle-review/SKILL.md"
+source_locale = "en"
+revision = 2
 translations = {}
 
 [documents."skill.async-timing-boundary-review"]
@@ -506,7 +560,7 @@ translations = {}
 [documents."skill.idempotency-integrity-review"]
 source = "locales/en/.mustflow/skills/idempotency-integrity-review/SKILL.md"
 source_locale = "en"
-revision = 2
+revision = 3
 translations = {}
 
 [documents."skill.retry-policy-integrity-review"]
@@ -1051,7 +1105,7 @@ translations = {}
 [documents."skill.cross-platform-filesystem-safety"]
 source = "locales/en/.mustflow/skills/cross-platform-filesystem-safety/SKILL.md"
 source_locale = "en"
-revision = 7
+revision = 9
 translations = {}
 
 [documents."skill.pure-core-imperative-shell"]
@@ -1323,6 +1377,18 @@ source_locale = "en"
 revision = 2
 translations = {}
 
+[documents."skill.fuzz-harness-review"]
+source = "locales/en/.mustflow/skills/fuzz-harness-review/SKILL.md"
+source_locale = "en"
+revision = 2
+translations = {}
+
+[documents."skill.input-boundary-validation-review"]
+source = "locales/en/.mustflow/skills/input-boundary-validation-review/SKILL.md"
+source_locale = "en"
+revision = 1
+translations = {}
+
 [documents."skill.test-maintenance"]
 source = "locales/en/.mustflow/skills/test-maintenance/SKILL.md"
 source_locale = "en"

package/templates/default/locales/en/.mustflow/skills/INDEX.md

@@ -2,7 +2,7 @@
 mustflow_doc: skills.index
 locale: en
 canonical: true
-revision: 245
+revision: 277
 authority: router
 lifecycle: mustflow-owned
 ---
@@ -177,8 +177,9 @@ refer to `AGENTS.md` and `.mustflow/config/commands.toml` to implement the most
   production guardrails, PII masking, admin sessions, or MFA need control-plane safety review.
 - Use `file-upload-security-review` as an adjunct when file uploads, imports, attachments,
   direct-to-storage uploads, remote file fetches, archive extraction, previews, thumbnails,
-  conversions, scanner gates, storage keys, signed URLs, downloads, browser headers, or uploaded
-  filename display need full file-lifecycle security review.
+  conversions, scanner gates, immutable object versions, decoded-media budgets, storage keys,
+  signed URLs, downloads, browser headers, or uploaded filename display need full file-lifecycle
+  security review.
 - Use `error-message-integrity-review` as an adjunct when error messages, codes, logs, validation
   failures, parse failures, public/internal error mapping, provider errors, retryability, support
   IDs, structured diagnostics, redaction, or troubleshooting text need recoverability and evidence
@@ -360,6 +361,9 @@ refer to `AGENTS.md` and `.mustflow/config/commands.toml` to implement the most
 - Use `security-flow-review` as an adjunct when security review needs source-to-sink tracing across
   authorization, object ownership, tenant scoping, mass assignment, injection inputs, SSRF, files,
   browser rendering, tokens, fail-open behavior, queued work, races, or supply-chain execution.
+- Use `input-boundary-validation-review` as an adjunct when untrusted bytes or text cross decoding,
+  Unicode canonicalization, duplicate or coercion policy, full parsing, schema, semantic,
+  authorization, resource-budget, or structured execution boundaries.
 - Use `testability-boundary-review` as an adjunct when review needs to expose hidden decision
   inputs, direct time or randomness, direct I/O, constructor side effects, static or singleton
   state, mock-heavy tests, sleeps, framework magic, reflection-only tests, or other code shapes
@@ -371,9 +375,15 @@ refer to `AGENTS.md` and `.mustflow/config/commands.toml` to implement the most
 - Use `quadratic-scan-review` as an adjunct when the suspected performance smell is specifically
   hidden O(N^2) work from repeated scans, membership checks, code joins, helper-body lookups,
   render-time lookup, resolver fan-out, repeated sort, or copy accumulation over growing data.
-- Use `parser-engineering-review` as an adjunct when lexer, grammar, CST or AST lowering, operator
-  binding, recovery, incremental parsing, Unicode positions, large-input limits, hostile-input
-  budgets, or parser fuzzing needs implementation or review.
+- Use `parser-engineering-review` as an adjunct when lexer, grammar, lossless CST, surface AST or HIR
+  lowering, tree visitor, transformer or rewriter behavior, persistent syntax identity, tree
+  serialization or compatibility, tree verification, trivia and source origins, operator binding,
+  recovery, incremental parsing, Unicode positions, large-input limits, hostile-input budgets, or
+  parser fuzzing needs implementation or review.
+- Use `fuzz-harness-review` as an adjunct when a coverage-guided target, deterministic reset,
+  property or differential oracle, corpus, dictionary, custom mutator, instrumentation or feedback
+  mode, stateful sequence, sanitizer lane, exact crash minimization, CI corpus lifecycle, coverage
+  plateau, or artifact-triage path needs implementation or review.
 - Use `type-state-modeling-review` as an adjunct when code review needs to make impossible
   domain states, invalid ID or unit swaps, nullable/status contradictions, unsafe DTO boundaries,
   or cast-heavy models unrepresentable by type shape.
@@ -556,6 +566,8 @@ routes. Event routes stay inactive until their event occurs.
 | --- | --- | --- | --- | --- | --- | --- |
 | Code changes need review before report | `.mustflow/skills/code-review/SKILL.md` | Diff and task goal | Changed files | behavior and regression | `test`, `test_related`, `test_audit`, `lint` | Findings or no-issue note |
 | One logical operation commits durable state and separately publishes, projects, calls, or writes another independently committed system, including database-plus-broker delivery, CDC, relay workers, or materialized projections | `.mustflow/skills/dual-write-consistency/SKILL.md` | Operation identity, local commit boundary, external delivery boundary, ordering rule, crash matrix, durable handoff records, retry and dedupe policy, reconciliation owner, and configured command intents | Transactional outbox or inbox records, CDC or relay ownership, stable event and operation IDs, delivery state, idempotent application, retry classification, reconciliation queries or jobs, crash-point tests, and directly synchronized docs or templates | commit succeeded but publish vanished, publish happened before rollback, duplicate relay delivery, reordered projection, ambiguous provider outcome, poison event, non-atomic completion marker, unreconciled split state, or false exactly-once claim | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `test_audit`, `docs_validate_fast`, `test_release`, `mustflow_check` | Dual-write boundary, commit and delivery authorities, crash matrix, convergence protocol, reconciliation evidence, verification, and remaining divergence risk |
+| A state, session, resource, writer, leader, configuration, file set, payment, or ownership pointer is admitted or prepared and later committed, activated, recovered, reversed, or compensated through one durable authority decision | `.mustflow/skills/two-phase-transition-integrity-review/SKILL.md` | Authority, execution, and observer-knowledge states; operation, attempt, participant, effect, decision, resource, generation, idempotency, and protocol identities; immutable admission snapshot; active slot; commit predicate; timeout matrix; recovery owner; journal; failure matrix; and configured command intents | Durable admission promise, reversible reservations, conditional commit decision, authority pointer and generation, roll-forward effects, fencing, stable status lookup and result replay, reconciler ownership, admission backpressure, idempotent release, compensation operation, outbox or inbox evidence, protocol-version recovery, invariant checker, and directly synchronized docs or templates | timeout stored as failure, observer UNKNOWN changing authority, mutable participant set, irreversible admission effect, commit decision conflated with effect completion, post-commit abort, retry creating a second operation, ambiguous provider call replayed blindly, stale recovery worker, over-release, unowned limbo, blind operator force, protocol-version drift, success log before durability, safety-only testing, or silent liveness failure | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `test_audit`, `docs_validate_fast`, `test_release`, `mustflow_check` | Admission contract, durable decision and roll-forward boundary, state axes and identities, ambiguity and recovery protocol, backpressure and operator evidence, journal and fault evidence, verification, and remaining transition risk |
+| A live user, service, device, game, remote-control, streaming, or AI-agent session moves between processes, nodes, runtimes, regions, edges, or agents while commands, effects, output, authorization, approvals, or state changes can remain in flight | `.mustflow/skills/session-handoff-integrity-review/SKILL.md` | Session owner instance, epoch, lease, grant, policy, connection generation, handoff, attempt, phase, command, effect, artifact, approval, output, and state-version identities; protocol state machine; transfer-class inventory; snapshot revision or multi-store cursor vector; range inclusivity; tombstones and expiry; schema and required features; manifest and hashes; bidirectional sequence and application ACK; replay window; command and tool ledgers; target acceptance; commit predicate; fence and router map; deadline and retry owner; context envelope; credential exchange; reconciler; transition audit; fault schedule; history properties; and configured command intents | Single-writer admission, revisioned snapshot and ordered catch-up, coherent cursor vectors, versioned tombstones, absolute expiry, immutable manifests, shadow target validation, fresh grant and policy evaluation, target-bound one-time resume credentials, explicit acceptance, atomic owner and epoch commit, sink-level fencing, stable command and effect receipts, durable application acknowledgments, bounded replay and resume-too-old recovery, versioned caches, lock reacquisition, drained redirector, make-before-break with one write epoch, typed AI context envelope, pending-approval preservation, scoped secret references, status-query recovery, quarantined ambiguity, complete message or media cutover, append-only owner audit, deterministic failpoints, and synchronized docs or templates | blob-copy-as-handoff, dual writers, revisionless or wall-clock-aligned multi-store snapshot, ambiguous cursor inclusivity, lost tombstone, reset TTL, silent schema reinterpretation, health-as-readiness, stale authorization snapshot, copied bearer or refresh credential, signature-only token validation, handoff recorded as new authentication, missing revocation propagation, target execution before commit, lease-only stale-owner defense, sticky route as authority, transport write as application ACK, one bidirectional sequence, unbounded or silent-short replay, overlapping connections with two writers, socket-buffer migration, partial compressed-message or codec cutover, replayable early-data side effect, timeout stored as failure, old-owner rollback after commit, command replay without receipt lookup, pending approval becoming permission, final-row-only testing, or nonterminal orphan handoff | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `test_audit`, `docs_validate_fast`, `test_release`, `mustflow_check` | Session-handoff boundary, owner/epoch/lease/state/cursor/tombstone/expiry/schema/grant/policy/credential/connection/ACK/replay/command/effect/artifact/context/approval/tool/output/deadline/recovery/audit/fault/history evidence, fixes or recommendation, verification, and remaining split-brain, loss, duplicate-effect, authorization, stream, privacy, or liveness risk |
 | One business outcome spans multiple persisted commands, entities, services, callbacks, timers, approvals, retries, or compensations and must resume after process loss or deployment | `.mustflow/skills/durable-workflow-orchestration/SKILL.md` | Business outcome, workflow instance identity, step and effect ledger, persisted state and version, trigger and timer inputs, retry and compensation rules, terminal states, migration policy, and configured command intents | Durable workflow state, deterministic step transitions, stable command and effect IDs, checkpoints, timers, approval records, retry classification, compensation order, stuck-work recovery, version migration, replay fixtures, and directly synchronized docs or templates | memory-only progress, duplicate step after resume, callback race, stale timer, lost approval, compensation in the wrong order, unversioned in-flight state, nonterminal limbo, or deployment breaking active runs | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `test_audit`, `docs_validate_fast`, `test_release`, `mustflow_check` | Workflow boundary, instance and state model, step/effect/compensation ownership, resume and migration behavior, verification, and remaining durable-workflow risk |
 | Runs, attempts, leases, approvals, checkpoints, effects, receipts, terminal outcomes, resume, reconciliation, or replay require append-only execution truth rather than ordinary logs or handoff summaries | `.mustflow/skills/execution-ledger-integrity-review/SKILL.md` | Run and attempt identity, event sequence, lease and fencing data, checkpoint model, effect identity, approval binding, receipt contract, terminal-state rules, replay policy, and configured command intents | Append-only execution events, monotonic sequence guards, attempt and lease identity, effect intent and receipt records, approval linkage, terminal-state derivation, replay and reconciliation logic, tamper or gap checks, focused fixtures, and directly synchronized docs or templates | overwritten run status, receipt without effect identity, late worker write, duplicate terminal outcome, sequence gap, reused approval, log treated as authority, replay repeating a committed effect, or reconciliation hiding uncertainty | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `test_audit`, `docs_validate_fast`, `test_release`, `mustflow_check` | Execution-ledger boundary, identity and sequence model, effects and receipts, terminal derivation, replay evidence, verification, and remaining ledger-truth risk |
 | One runtime parent starts concurrent child tasks, workers, coroutines, threads, goroutines, or agent-runtime children and correctness depends on bounded fan-out, joining, cancellation, deadline propagation, sibling failure policy, cleanup, or rejecting late results | `.mustflow/skills/structured-concurrency-supervision-review/SKILL.md` | Parent and child ownership tree, spawn sites, join boundary, deadline and cancellation model, sibling failure policy, resource budget, late-result fence, cleanup path, deterministic test evidence, and configured command intents | Task groups or nurseries, bounded child creation, owned cancellation scopes, explicit joins, propagated deadlines, sibling-failure aggregation, cleanup guarantees, late-result rejection, deterministic supervision tests, and directly synchronized docs or templates | orphan child, fire-and-forget mutation, parent success before child completion, swallowed cancellation, unbounded fan-out, sibling failure loss, leaked permit, deadline not propagated, late child overwriting newer state, or shutdown without join | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `test_audit`, `docs_validate_fast`, `test_release`, `mustflow_check` | Supervision tree, join and cancellation policy, fan-out and deadline bounds, sibling failure and cleanup behavior, deterministic evidence, verification, and remaining structured-concurrency risk |
@@ -587,9 +599,13 @@ routes. Event routes stay inactive until their event occurs.
 | API endpoints, handlers, controllers, resolvers, serializers, mappers, service methods, middleware, webhook receivers, backend-for-frontend paths, admin APIs, or route-level request paths need latency review for repeated work inside one request | `.mustflow/skills/api-request-performance-review/SKILL.md` | API request boundary, Request cost ledger, route span, DB query count, Redis count, external API calls, pool acquire wait, transaction scope, cache hit or miss, payload and response bytes, serialization time, ORM behavior, correctness boundaries, and configured command intents | Projection narrowing, query-count or lazy-loading guards, bounded batching, request-scope memoization, Redis `MGET` or pipeline use, app-side filtering or sorting cleanup, transaction narrowing, route-level observability, focused tests, and directly synchronized docs or templates | per-request I/O fan-out, ORM serializer lazy loading, eager-load row explosion, `SELECT *`, app-side filtering after overfetch, deep `OFFSET`, expensive `COUNT(*)`, index mismatch for `WHERE` plus `ORDER BY` plus `LIMIT`, external API inside transaction, pool acquire wait hidden behind fast queries, Redis loop, cache miss amplification, repeated JSON serialization, huge response bytes, CPU-heavy request work, Node flame graph gap, Go pprof gap, MongoDB `explain()` gap, or missing OpenTelemetry span evidence | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `docs_validate_fast`, `test_release`, `mustflow_check` | API request path reviewed, Request cost ledger, route-level DB/Redis/external/cache/serialization/CPU findings, evidence level, verification, and remaining API request performance risk |
 | Code review or implementation needs cache-integrity triage for cache key truth, viewer context, query normalization, key versioning, TTL and jitter, soft and hard TTL, stale-while-revalidate, stampede protection, negative caching, invalidation ordering, update races, list or page caches, tag invalidation, local L1 and external L2 caches, Redis fallback, value size, eviction policy, TTL-less keys, `KEYS *`, hot keys, Redis Cluster hash tags, HTTP `Vary`, `no-cache`, `no-store`, permission caches, cache warming, observability, or cache failure tests | `.mustflow/skills/cache-integrity-review/SKILL.md` | Cache surface, source of truth, cached value, key dimensions, freshness contract, failure and concurrency contract, observability evidence, and configured command intents | Cache key construction, query normalization, key versioning, TTL and jitter, soft or hard TTL behavior, stale serve, singleflight or request coalescing, negative-cache policy, invalidation order, version checks, tag invalidation, bounded fallback, cache warming, observability, focused tests, and directly synchronized docs or templates | stale data spread, tenant or permission leak, wrong viewer response, cache key collision or explosion, old schema read after deploy, synchronized expiry bomb, thundering herd, temporary failure cached as truth, delete-before-commit resurrection, stale overwrite, list invalidation drift, page duplicate or gap, global flush pressure, L1/L2 split brain, Redis outage killing DB, hit-rate-only blind spot, oversized values, eviction surprise, stateful TTL-less cache, production `KEYS *`, hot-key overload, broken cluster distribution, wrong HTTP cache reuse, stale auth cache, cold-start source surge, or happy-path-only cache test | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `docs_validate_fast`, `test_release`, `mustflow_check` | Cache surface reviewed, source truth and key dimensions, TTL/invalidation/fallback decisions, Redis/HTTP/permission/cache-layer checks, evidence level, verification, and remaining cache-integrity risk |
 | Code review or implementation specifically needs to catch hidden O(N^2), pairwise work, repeated membership checks, map/filter/find/includes chains, code joins by ID, duplicate removal with index search, sorted-array linear search, repeated sort, reducer spread, string concatenation, JSON comparison, helper-hidden full-list scans, ORM lazy loading, GraphQL resolver fan-out, render-time lookup, tree or graph parent-child scans, event-history scans, interval all-pairs checks, or incremental updates that recompute whole state | `.mustflow/skills/quadratic-scan-review/SKILL.md` | Outer work, inner work, data shape, join or membership key, semantic contract, evidence level, and configured command intents | Set or Map lookup, grouping maps, parent-to-children maps, composite keys, sorted merge, single-pass aggregation, database-side joins, focused behavior tests, and bounded complexity notes tied to the repeated scan | disguised nested loop, same collection rescanned per item, array membership over growing data, ID join without index, duplicate-removal O(N^2), sorted linear search, sort inside loop, copy accumulation, JSON stringify comparison, helper-body scan, ORM N+1, resolver fan-out, render jank, graph traversal slowdown, event-history rescan, interval all-pairs leak, or small-list excuse without a hard cap | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `docs_validate_fast`, `test_release`, `mustflow_check` | Repeated path, outer and inner counts, data-growth classification, hidden scan findings, chosen index or intentional all-pairs decision, semantics preserved, evidence level, verification, and remaining quadratic-scan risk |
-| Lexer, tokenizer, grammar, parser, CST, AST lowering, operator table, formatter grouping, error recovery, incremental parser, Unicode source position, large-input behavior, parser resource limit, or parser fuzzing needs implementation, review, debugging, or claim validation | `.mustflow/skills/parser-engineering-review/SKILL.md` | Parser role, byte and text boundary, output contract, compatibility surface, lexer and grammar, tree and lowering model, incremental snapshot model, diagnostics, budgets, fixtures, and configured command intents | Explicit source units, progress invariants, lossless CST, separate lowering, executable binding powers, bounded recovery, context convergence, immutable snapshots, shared ParseBudget, chunk and edit differential tests, structured mutation, and directly synchronized docs or templates | zero-width lexer loop, raw/cooked span drift, CST source loss, AST/semantic collapse, wrong associativity, formatter disagreement, speculative side effect, recovery loop or cascade, fixed-radius invalidation, stale snapshot publish, UTF-8/UTF-16 confusion, surrogate split, deep or wide bomb, ReDoS, expansion bomb, unbounded token or node retention, validation/execution parser split, or throughput-only proof | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `test_audit`, `docs_validate_fast`, `test_release`, `mustflow_check` | Parser boundary and compatibility, source/token/tree/operator/recovery/incremental/Unicode/storage/budget decisions, positive and adversarial evidence, verification, and remaining parser risk |
+| The same hostname, variable, function, type, macro, module, package, class, dependency coordinate, repository label, or import resolves differently by requester, execution space, resolver API, scope, namespace, lookup phase, search path, route, condition, variant, loader, proxy, cache, platform, or build lane; including NSS status actions, split DNS, recursive versus authoritative DNS, delegation or glue, DoH, search suffixes, proxy-side DNS, negative caching, address selection, connection reuse, container or cluster name scope, language shadowing, temporal dead zones, associated or delayed lookup, macro hygiene, conditional exports, duplicate module instances, class-loader identity, peer contexts, package-manager mediation, build variants, repository mappings, or stale resolver caches | `.mustflow/skills/name-resolution-integrity-review/SKILL.md` | Exact input and expected identity; requester and execution-space capsule; resolver API, identity and mode; resolution ledger covering normalized and expanded candidates, namespaces, phases, search or route graph, recursive and authoritative boundaries, delegation, precedence, filters, rejection reasons, fallback and stop condition; resolved, loaded and behavioral identity; returned and selected address, actual connection and reuse state; cache layer, key, value, freshness and provenance; controlled comparison; domain contract; and configured command intents | Structured resolver traces, explicit qualification or aliases, lookup and import fixes, resolver conditions, loader ownership, cache-key or invalidation repair, package declarations after handoff, generated-name hygiene, positive and wrong-but-successful fixtures, runbook evidence, and directly synchronized docs or templates | direct query treated as application proof, host shell treated as container proof, spelling treated as identity, resolver API or NSS action hidden, search expansion hidden, split DNS flattened to a server list, configured servers assumed equivalent, recursive cache conflated with authoritative or delegation state, proxy resolution side guessed, TTL treated as a global propagation timer, cache flushed before capture, negative or stale result collapsed, returned addresses conflated with the actual or reused connection, lookup success conflated with reachability, outer binding assumed before inner initialization, namespace or lookup phase omitted, candidate selection hidden, lockfile treated as module instance proof, equal version treated as equal peer or feature context, equal class name treated as equal loader identity, compile alias treated as runtime dependency, clean build used as cache localization, or one build lane treated as deploy proof | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `test_audit`, `docs_validate_fast`, `test_release`, `mustflow_check` | Resolution claim and failure class; requester and execution space; original, expanded, qualified and selected names; resolver API, stages, candidates, precedence, filters and rejections; recursive, authoritative and delegation evidence; cache and freshness evidence; resolved, selected-address, actual-connection, reuse, loaded and behavioral identities; first divergent stage and owner; verification; and remaining identity, cache, environment or downstream risk |
+| Lexer, tokenizer, grammar, parser, lossless CST, surface AST, AST-to-HIR lowering, tree visitor, transformer or transactional rewriter, persistent syntax identity, tree serialization or compatibility format, tree schema or verifier, trivia or syntax-origin model, operator table, formatter grouping, error recovery, incremental parser, Unicode source position, large-input behavior, parser resource limit, or parser fuzzing needs implementation, review, debugging, or claim validation | `.mustflow/skills/parser-engineering-review/SKILL.md` | Parser role, byte and text boundary, output and compatibility contract, lexer and grammar, CST-to-AST loss ledger, surface AST and HIR boundary, node schema and absence states, syntax origins, traversal order and edge model, typed transformation results, rewrite conflict and termination policy, snapshot handles, preserved-analysis ledger, artifact lifetime and wire schema, compatibility window, decode budgets and validation layers, tree and side-table identity, lowering and verifier model, incremental snapshot model, diagnostics, fixtures, and configured command intents | Explicit source units, progress invariants, lossless CST, surface AST and core separation, read-only visitors, immutable structural transforms, transactional rewrite commits, typed edit results, deterministic conflict resolution, bounded rewrite epochs, generation-checked handles, conservative analysis invalidation, bounded two-phase decode, schema evolution, deterministic encoding, cross-version matrices, typed absence and error states, deterministic trivia attachment, origin maps, evaluation-order-safe lowering, closed node schemas, phase-specific verifiers, executable binding powers, bounded recovery, context convergence, immutable snapshots, shared ParseBudget, chunk and edit differential tests, structured mutation, and directly synchronized docs or templates | zero-width lexer loop, raw/cooked span drift, CST source loss, visitor mutating the traversed snapshot, inserted children revisited accidentally, null conflating keep/delete/error, rewrite conflicts resolved by registration order, partial commit exposure, rewrite oscillation, stale node handles, NodeId conflated with pointer/span/hash, syntax reuse treated as semantic-cache proof, tree ownership edges mixed with cyclic reference graphs, memory layout serialized as wire format, schema numbers reused, missing versus default presence collapsed, unbounded decode allocation, partially linked graph exposed, decoder success called phase validity, nondeterministic encoding, compatibility claimed without reader/writer matrix, parser wrappers leaking into public AST, AST and semantic layers collapsed, missing syntax forged into valid values, punctuation or grouping semantics erased, trivia attached nondeterministically, sugar lowering duplicates evaluation, receiver or scope identity lost, stale side-table generation, unverified lowering output, wrong associativity, formatter disagreement, speculative side effect, recovery loop or cascade, fixed-radius invalidation, stale snapshot publish, UTF-8/UTF-16 confusion, surrogate split, deep or wide bomb, ReDoS, expansion bomb, unbounded token or node retention, validation/execution parser split, or throughput-only proof | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `test_audit`, `docs_validate_fast`, `test_release`, `mustflow_check` | Parser boundary and compatibility; source, token, CST, surface AST, HIR, lowering, origin, traversal, transformation, rewrite, handle, invalidation, serialization, compatibility, tree identity, verifier, operator, recovery, incremental, Unicode, storage and budget decisions; positive and adversarial evidence; verification; and remaining parser risk |
+| Compiler semantic analysis, AST/HIR/typed-HIR/MIR/LIR boundaries, IR semantic contracts, semantic/storage/ABI/machine type transitions, ownership or borrow capabilities, lifetime/allocation/view/provenance models, scoped or generation-tracked analysis facts, effect/capture/speculation models, progressive lowering, mixed-level legality, CFG or SSA construction and destruction, phi and edge semantics, canonical forms, staged verifiers, analysis preservation, pass prerequisites or ordering, optimization, code generation, object formats, symbol namespaces, archive extraction, section reachability, relocation, static or dynamic binding, visibility, export or import policy, name mangling, ABI, plugin interfaces, dynamic loading, debug symbols, DWARF, PDB, dSYM, unwind metadata, stripping, dead-code elimination, identical-code folding, LTO, crash symbolication, symbol stores, linking, diagnostics, compiler test strategy, well-defined generators, differential or metamorphic testing, determinism, miscompile reproduction, reduction, or compiler-correctness claims need implementation, review, debugging, or validation | `.mustflow/skills/compiler-engineering-review/SKILL.md` | Frozen compiler and build universe; expected defined semantics; IR layer ledger covering information, invariants, consumers, effects, identities, verifier, lowering, serialization and target entry; fact ledger covering origin, domain, scope, allocation epoch, generation, proven/assumed/unknown/contradicted status, consumer and preserve/recompute/weaken/drop transitions; ownership ledger covering non-forgeable capability flow, pointer and view aliases, borrow intervals, function ownership ABI and exceptional paths; pass pipeline ledger covering prerequisites, canonical-form windows, invalidation, budgets, instrumentation and interaction evidence; CFG, SSA, phi, edge and parallel-copy contracts; staged structural, semantic, ownership, effect, layout and refinement verifiers; link and ABI ledger covering platform object contract, regular and loader-visible symbol namespaces, ordered inputs, archive extraction, section roots, relocation ownership, dynamic dependencies, binding time, export/import allowlists, language ABI options and toolchain identity; debug-artifact ledger covering runtime/public/debug/unwind/source assets, final binary and architecture identity, load address, separated-debug association, lineage, access and retention; crash-symbolication ledger covering capture format, precise versus return address, inline chain, source mapping, symbolicator and immutable store canary; test ladder; differential lineage; exact interestingness predicate; first divergence; diagnostic, ABI, object, linker and target evidence; and configured command intents | IR semantic and effect specifications, explicit representation conversions, ownership capabilities and borrow-flow values, lifetime and allocation-epoch state, provenance and scoped alias facts, fact-generation and metadata-transition rules, stage allowlists, schema-derived builders, negative verifier mutation fixtures, semantic refinement checks, layer and lowering contracts, legal mixed states, source-origin chains, deterministic replay formats, CFG and SSA repair, phi and edge handling, parallel-copy destruction, canonical-form ownership, transactional analysis updates, pass contract graphs, bounded cleanup cycles, information-aware ordering, instrumentation placement, stage-local artifacts, translation validation, ordered link-input captures, archive-member and section-reachability traces, relocation assertions, final export and dependency diffs, versioned C plugin-table probes, loader activation and retirement evidence, immutable symbol packages, source bundles, crash module ledgers, strip and elimination stage traces, ICF and LTO preservation evidence, external symbolication canaries, direct regressions, focused tests, and synchronized docs or templates | IR treated as a node schema or fact database, representation changed in place, ownership represented by a copyable flag, borrow permission conflated with alias possibility, destructor position conflated with lifetime, address conflated with allocation identity or provenance, alias fact missing domain/scope/epoch, facts merged by union, stale fact missing generation, metadata copied without a transition rule, missing effects treated as pure, one global verifier weakened for every stage, malformed IR crashing its printer, invalid IR easy to construct, DataLayout or ABI unchecked, verifier lacking negative mutations, structural validity called semantic preservation, CFG mutation publishing stale analyses, canonical form maintained without a consumer, phi inputs keyed only by predecessor block, unsafe phi-to-select conversion, sequential copies breaking SSA destruction, pass prerequisites missing, cleanup oscillation, target information arriving at the wrong level, instrumentation observing the wrong program, regular symbols mistaken for runtime exports, archive contents mistaken for extracted members, member extraction conflated with section survival, relocation inferred from disassembly, static selection conflated with loader binding, C linkage mistaken for a complete ABI, accidental exports, exported writable data, ambient transitive dependencies, lazy binding mistaken for load proof, loader namespace mistaken for sandbox, unsafe plugin unload, all symbol assets collapsed into one flag, commit or filename used as symbol key, release symbols rebuilt later, split debug discarded as cache, crash-handler symbolication, precise and return addresses conflated, strip modes applied to relocatable inputs, compiler DCE conflated with LTO or section collection, compiler-used mistaken for linker-retained, function address used as identity under ICF, LTO cache used as binary identity, optimized-out state fabricated, unversioned plugin tables, or isolated pass tests hiding pipeline interaction | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `test_audit`, `docs_validate_fast`, `test_release`, `mustflow_check` | Compiler claim and definedness; IR layer, representation, ownership, borrow, lifetime, allocation, provenance, fact-origin, scope, epoch, generation, status and metadata-transition decisions; staged verifier and semantic-refinement evidence; CFG, SSA, phi, edge, loop-closure and destruction evidence; canonical-form, analysis-transaction, pass-contract, ordering, budget, instrumentation and interaction evidence; test ladder and oracle decisions; reproduction universe, exact oracle, stage and first-divergence result; object-format, symbol-namespace, archive-selection, section-reachability, relocation, visibility, export/import, static/dynamic binding, full ABI, plugin-versioning and lifecycle, runtime/public/debug/unwind/source assets, binary identity, stripping, DCE, ICF, LTO, crash-capture, symbol-store, source-retrieval, symbolication-canary, linker and target evidence; verification; and remaining compiler-correctness risk |
+| AST interpreter, bytecode compiler or virtual machine, evaluator, rule engine, scripting runtime, typed executable IR, semantic type or runtime value model, operator dispatch, resolver, lexical scope, closure, upvalue, nonlocal completion, structured guest diagnostic, VM garbage collector, root or write barrier, weak container or finalizer, semantic oracle, source mapping, native function boundary, deterministic execution, sandbox budget, compiled-code cache, or interpreter performance needs implementation, review, debugging, or validation | `.mustflow/skills/interpreter-engineering-review/SKILL.md` | Language-semantics matrix; semantic type, runtime kind and storage-tag separation; conversion graph and operator algorithm; assignment-place and typed-IR decisions; execution pipeline; resolver, frame and closure lifetime; completion and evaluation order; structured diagnostic and recovery provenance; source snapshots and logical stacks; root, safepoint, barrier, moving-handle, generation, weak, finalizer and external-resource contract; canonical outcome and independent oracle; native boundary; deterministic services; resource budgets; engine, bytecode, cache and performance evidence; and configured command intents | Executable AST or typed IR, centralized values and sentinels, directed conversions, handled-declined-thrown dispatch, resolved places, slots, cells and upvalues, bytecode and verifier, structured diagnostics, safe renderer, logical guest stacks, VM root and handle APIs, collector barriers, weak or ephemeron processing, staged shutdown, heap stress, canonical outcomes, semantic properties and metamorphic relations, structure-aware reducers, native adapters, deterministic services, budgets, versioned caches, guarded specialization, focused tests, and synchronized docs or templates | semantic type coupled to storage tag, universal coercion, host operator leakage, compound target evaluated twice, decline confused with throw, evaluator and bytecode re-resolving overloads, forged internal sentinel, address-based identity, unsafe diagnostic renderer, stale source fix, recovery cascade, root or safepoint omission, partial-object tracing, barrier bypass, lost old-to-young edge, broken ephemeron fixed point, resurrection or refcount reentrancy, finalizer-only resources, unspecified input used as differential oracle, shared-bug engine agreement, reducer changing failure identity, harness state leak, stale metaobject cache, timeout-only sandbox, or optimization before profiling | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `test_audit`, `docs_validate_fast`, `test_release`, `mustflow_check` | Guest semantic, type-kind-storage, conversion, operator, place and Value decisions; binding, completion and evaluation order; structured diagnostic, source and logical-stack evidence; closure, root, barrier, weak, finalizer and resource lifetime; canonical oracle, property, differential, reduction and replay evidence; native, deterministic-service and budget policy; engine, cache and performance evidence; verification; and remaining interpreter risk |
+| Formal specification, Hoare-style contract, weakest precondition, loop or object invariant, termination variant, ghost or old state, frame condition, state/action/trace invariant, inductive strengthening, safety or liveness property, fairness assumption, concurrent history, linearizability, stuttering refinement, concurrency or failure model checker, bounded model checker, state-space reduction, SMT encoding, theorem prover, proof assistant, proof trust boundary, counterexample, assumption manifest, verification debt, proof-cost metric, or formal-verification CI claim needs implementation, review, debugging, or validation | `.mustflow/skills/formal-verification-review/SKILL.md` | Exact quantified claim and observation; model-to-implementation ledger; state, action, trace and relational properties; inductive invariant obligations; abstraction direction; nondeterministic schedules, failures and external outcomes; linearizable histories; atomicity and reduction soundness; weak-memory boundary; caller and callee contracts; numeric, memory, alias and lifetime semantics; scope, context-switch, failure, unwind, trace and resource bounds; solver theories and result taxonomy; trusted computing base; assumption manifest; counterexample replay; refinement map; model-based test bridge; proof-cost and debt baselines; cadence; and configured command intents | Formal specs, contracts, lemmas, proof harnesses, state models, history and refinement artifacts, runtime boundary guards, trusted stubs, assumption manifests, counterexample and regression fixtures, scope and bound ladders, reduction configuration, solver encodings and structured results, model-derived tests, proof metrics, vacuity and sensitivity checks, compatibility obligations, debt ratchets, focused tests, and synchronized docs or templates | whole-system correctness overclaim, final-state invariant hiding a forbidden history, non-inductive safety claim, under-approximation called proof, unjustified atomic action, fairness deleting starvation, linearization point asserted without history refinement, sequential-consistency proof applied to weak-memory code, stale or duplicate network behavior omitted, crash boundary erased, unsound symmetry or partial-order reduction, lossy search called exhaustive, small scope generalized without cutoff, wrong SMT theory, array bounds omitted, quantifier instability hidden, unsat core called certificate, unknown or timeout mapped green, hidden axiom or FFI stub, counterexample not replayed, prose-only refinement map, stronger precondition or weaker postcondition unnoticed, proof debt growth, cost explosion, or retry-until-proof-passes | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `test_audit`, `docs_validate_fast`, `test_release`, `mustflow_check` | Formal claim and observation; property layers and inductive obligations; model map, abstraction and omissions; history, refinement, atomicity and reduction evidence; concurrency, network, crash and weak-memory decisions; contract, numeric, memory and failure obligations; solver encoding, result taxonomy, assumptions and trusted base; counterexample replay and model-based test evidence; compatibility, proof-cost, debt and cadence decisions; verification; and remaining formal-verification risk |
 | Code review or implementation needs type modeling to make impossible states unrepresentable, including branded IDs, unit and currency types, boolean flag clusters, broad string statuses, nullable state fields, raw external data, partial update inputs, DTO/domain/response mixing, broad maps, `any`, casts, non-null assertions, Result error variants, non-empty collections, permission capabilities, lifecycle timestamps, or exhaustiveness | `.mustflow/skills/type-state-modeling-review/SKILL.md` | Domain invariant, current type surface, construction path, boundary map, exhaustiveness surface, and configured command intents | Branded types, newtypes, wrappers, literal unions, sealed or discriminated variants, parsers, constructors, validators, DTO boundary splits, focused tests, and directly synchronized docs or templates | swapped IDs, unit or currency confusion, contradictory boolean flags, status drift, optional-field invalid state, raw DTO leakage, unsafe `Partial<T>`, domain/API/DB coupling, broad `Record<string, unknown>`, `any` spread, cast cover-up, non-null assertion crash, untyped Result errors, empty collection invariant leak, permission boolean drift, lifecycle timestamp contradiction, or missed exhaustive case | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `docs_validate_fast`, `test_release`, `mustflow_check` | Type surface reviewed, impossible states found or ruled out, boundary and construction path tightened, exhaustiveness and tests checked, verification, and remaining impossible-state risk |
-| Code review or implementation needs race-condition triage for shared state observed across interleaving execution flows, including check-then-act, read-modify-write, stale reads after `await`, I/O, callbacks or events, lock scope or global lock order, `tryLock`, timeout, retry, cache miss fill, lazy initialization, double-checked locking, atomics, memory ordering, DB transaction isolation, conditional updates, unique constraints, distributed locks, idempotency, filesystem exists/open, atomic create or rename, outbox ordering, queue duplicates or reordering, concurrent same-user work, shutdown, cancellation, timers, close/send races, shared collections, iterator snapshots, object reuse, fake immutability, sleep-based race tests, log ordering, or status values without transitions | `.mustflow/skills/race-condition-review/SKILL.md` | Shared state surface, invariant, interleaving points, synchronization or transaction boundary, retry and idempotency policy, event, queue, timer, cancellation and shutdown paths, collection or object ownership, evidence level, and configured command intents | Atomic conditional update, atomic create, compare-and-swap, lock scope or lock-order fix, unique constraint, row lock, idempotency guard, singleflight, outbox or inbox guard, state transition guard, snapshot iteration, ownership split, focused concurrency tests, and directly synchronized docs or templates | check-then-act, lost update, stale read after await, torn invariant, callback under lock, deadlock, retry duplication, cache stampede, double init, unsafe atomic assumption, isolation mismatch, app-only uniqueness, broken distributed lock, duplicate side effect, event/state split brain, queue duplicate or out-of-order damage, shutdown drop, cancellation completion race, old timer update, double close, send after close, shared collection mutation, pooled object corruption, fake immutable mutation, sleep-test false confidence, log-order lie, or state value race | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `docs_validate_fast`, `test_release`, `mustflow_check` | Shared state and invariant reviewed, interleaving ledger, atomicity and synchronization findings, stale-read and ordering checks, tests or evidence level, verification, and remaining race-condition risk |
+| Code review, implementation, or incident reproduction needs race-condition triage for shared state observed across interleaving execution flows, including logical race versus data-race classification, forbidden outcomes, deterministic gates, schedule exploration or replay, happens-before evidence, check-then-act, read-modify-write, stale reads after `await`, lock scope or order, mutex, semaphore, condition, channel, atomics, memory ordering, CAS, ABA, reclamation, linearizability, DB races, distributed locks, queues, shutdown, cancellation, object reuse, or schedule-sensitive tests | `.mustflow/skills/race-condition-review/SKILL.md` | Shared-state and backing-storage ownership map, invariant and forbidden outcome, defect class, actor and arbiter model, interleaving points, synchronization boundary, incident and environment capsule, seed plus schedule decision trace, atomic ordering and linearization point, reclamation rule, retry and idempotency policy, durable-boundary semantics, and configured command intents | Deterministic actor gates, minimized input and schedule, per-actor bounded evidence, happens-before graph, correct primitive and ownership boundary, conditional update or transaction, publication ordering, ABA and reclamation guard, linearizability history check, focused concurrency tests, and directly synchronized docs or templates | race detector treated as logical-safety proof, unexecuted schedule gap, non-replayable seed, sleep-only reproduction, logger-created synchronization, alias or backing-store miss, torn invariant, lost wakeup, semaphore ownership error, buffered send mistaken for processing, CAS side-effect replay, relaxed publication bug, ABA address reuse, tag wrap, premature reclaim, final-state-only oracle, stale read, duplicate side effect, or false race-free claim | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `docs_validate_fast`, `test_release`, `mustflow_check` | Defect class and forbidden outcome, incident capsule, ownership and actor model, schedule and happens-before evidence, primitive and memory-model findings, minimized reproducer, verification, and remaining race-condition risk |
 | Code, tests, docs, or reports add, change, review, justify, or debug arbitrary sleeps, fixed delays, `setTimeout`, timer waits, event-loop yields, microtask or next-tick waits, render-frame or after-paint waits, CI waits, readiness polling, startup waits, file flush waits, worker readiness, Promise completion claims, async one-time side effects, or eventual-consistency waits | `.mustflow/skills/async-timing-boundary-review/SKILL.md` | Wait surface, intended condition, boundary class, available completion signal, caller ownership, test evidence, and command contract entries | Timing helpers, async flow, lifecycle waits, readiness probes, bounded polling, fake-time tests, stream/filesystem/process/worker/server/database/queue/index/device waits, and directly synchronized docs or templates | tuned millisecond threshold, sleep as readiness, Promise that only schedules work, one-time side-effect scope drift, render-before-layout measurement, stream or file durability lie, process or server ready guess, replica/search/queue visibility race, unbounded polling, timeout layering bug, CI-only flake, or sleep-based proof | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `docs_validate_fast`, `test_release`, `mustflow_check` | Waits classified, completion signal chosen or missing, fixed waits removed or bounded, Promise/once/render/I/O/external checks, verification, skipped timing diagnostics, and remaining async timing risk |
 | Code review or implementation needs concurrency-invariant triage for shared ownership and primitive discipline when correctness depends on time-order changes, including hidden writes in getters, lazy initialization, check-then-act, read-modify-write, exact lock identity, lock scope, lock order, callbacks under lock, condition-variable `while` predicates, lost notifications, atomics mixed with ordinary state, CAS ABA, double-checked locking, object publication before construction completes, fake immutability, concurrent collection iteration, cache stampede, application-only uniqueness, transaction isolation, distributed lock lease expiry, fencing tokens, idempotency keys, duplicate queue delivery, explicit state-machine transitions, scheduler overlap, shutdown drain, resource release after acquire, thread-local leakage, async `await` interleavings, or sleep-based concurrency tests | `.mustflow/skills/concurrency-invariant-review/SKILL.md` | Shared state inventory, owner decision, invariant, time-order table, lock identity and order, condition predicate, atomic and memory-visibility story, transaction and distributed lease boundary, duplicate execution rule, shutdown and thread-local context, test evidence, and configured command intents | Single-writer ownership, immutable snapshot, scoped lock, global lock order, condition predicate loop, atomic conditional write, transaction or row lock, unique constraint, idempotency record, fencing token, queue dedupe, state transition guard, scheduler ownership, shutdown drain, context cleanup, deterministic interleaving test, and directly synchronized docs or templates | ownerless shared state, read-only helper hidden write, torn invariant, different locks guarding one fact, too-narrow lock, too-wide lock, deadlock order, callback under lock, lost notification, spurious wakeup, atomic-only cover-up, ABA, unsafe publication, half-constructed object, fake immutable mutation, collection mutation during iteration, cache stampede, duplicate insert across service instances, isolation mismatch, expired distributed lock owner, duplicate side effect, queue redelivery damage, status backtracking, scheduler double-run, dropped in-flight work, leaked permit, thread-local tenant leak, stale value after await, or sleep-test false confidence | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `docs_validate_fast`, `test_release`, `mustflow_check` | Shared inventory and owners reviewed, invariant and time-order table, primitive-discipline findings, fixes or recommendations, deterministic evidence level, verification, and remaining concurrency-invariant risk |
 | Code review or implementation needs failure-integrity triage for exception or failure handling that can produce false success, swallowed exceptions, log-and-continue paths, ambiguous `null`, `false`, or empty defaults, `finally` masking, transaction commit after caught failure, external side-effect ordering bugs, retry without idempotency, missing timeouts, cancellation swallowing, unobserved async failures, queue ack/nack mistakes, lost causes, leaked internal errors, mixed business and system failures, partial state, lock or resource leaks on failure paths, unsafe parsing defaults, fail-open authorization, unsafe cache or fallback defaults, unstable public error messages, or missing failure-path observability | `.mustflow/skills/failure-integrity-review/SKILL.md` | Failure surface, truth surface, state-change ledger, error classification, transaction and side-effect boundary, retry, timeout, cancellation, queue, cleanup, public error, redaction, observability, and configured command intents | Failure propagation, typed error value, rollback or compensation, idempotency guard, timeout and retry budget, cancellation propagation, ack/nack and dead-letter policy, cause preservation, stable public error code, safe logging or metrics, fail-closed behavior, resource cleanup, focused failure-path tests, and directly synchronized docs or templates | broad catch, swallowed exception, false success, false empty data, cleanup masking original error, partial commit, unknown provider outcome, duplicate side effect, retry storm, hung dependency, ignored cancellation, unobserved background failure, dropped queue message, poison message loop, lost stack cause, internal error leak, client string-branching, business/system failure confusion, stuck processing state, unreleased lock, unclosed handle, dangerous default value, fail-open permission, unsafe fallback, invisible compensation failure, or no operator signal | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `docs_validate_fast`, `test_release`, `mustflow_check` | Failure surface and lie reviewed, state-change and truth ledger, swallowed or false-success findings, rollback/retry/fallback/observability decisions, tests or evidence level, verification, and remaining failure-integrity risk |
@@ -599,7 +615,7 @@ routes. Event routes stay inactive until their event occurs.
 | Code review, implementation, runbook work, or release preparation needs deployment-rollout safety review for server, backend, worker, scheduler, queue, cron, container, VM, serverless, DB migration, config, feature flag, cache, deployment pipeline, release envelope, image digest, deployment history, traffic rollback, canary, rollback, health check, readiness/liveness/startup probe, graceful shutdown, artifact promotion, release observability, or post-deploy smoke behavior where the deploy must be rolled out, stopped, observed, and rolled back safely | `.mustflow/skills/deployment-rollout-safety-review/SKILL.md` | Deployment resource ledger, release envelope, artifact identity, environment promotion path, deployment model, compatibility matrix, config diff, migration order, rollback history, traffic rollback path, cache and message compatibility, probe model, shutdown and drain behavior, canary cohort, version-split telemetry, stop conditions, rollback limits, synthetic transactions, post-deploy metrics, and configured command intents | Runbooks, release checklists, pipeline metadata, smoke tests, probe tests, config validation, feature-flag defaults, cache-key versions, worker-drain handling, deployment attribution, rollback compatibility notes, focused tests, and directly synchronized templates | unknown blast radius, missing release id, mutable latest tag, tag without digest, per-environment rebuild drift, deleted rollout history, cold old version, traffic rollback tied to rebuild, code and migration lockstep, destructive rollback SQL overclaim, missing PITR practice, config in-place mutation, missing startup config validation, process-only health check, readiness/liveness/startup probe collapse, liveness restart loop, ungraceful shutdown, load balancer drain shorter than app shutdown, worker work loss, non-idempotent queue retry, N-1 message incompatibility, unknown event poison message, missing external compensation, API N-1 or N+1 break, missing kill switch, unsafe flag fallback, vague canary cohort, global-average canary metrics, no automatic stop condition, read-only smoke, log format alert breakage, blanket cache flush, scheduler duplicate execution, CRD or operator downgrade break, missing deployment lock, production command without dry-run, or code-only rollback overclaim | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `docs_validate_fast`, `test_release`, `mustflow_check` | Deployment rollout boundary reviewed, resource ledger and release envelope, artifact identity, config/migration/cache/queue/API/probe/shutdown/canary/rollback/observation findings, verification, and remaining deployment-rollout risk |
 | Code review, implementation, runbook work, or infrastructure review needs cloud-cost-guardrail review for cloud accounts, projects, subscriptions, environments, Kubernetes namespaces, serverless, databases, object storage, block storage, snapshots, NAT, private endpoints, public IPs, egress, CDN, logs, metrics, traces, autoscaling, quotas, budgets, tags, temporary resources, container registries, Marketplace, LLM APIs, external APIs, or third-party SaaS where spend must be attributed, capped, lifecycle-managed, alerted, and safely stoppable before a silent bill explosion | `.mustflow/skills/cloud-cost-guardrail-review/SKILL.md` | Cost surface ledger, budget actual and forecast thresholds, automated non-production action path, account or project isolation, quota and cap model, tag taxonomy, temporary resource expiration, network cost model, telemetry cost model, storage lifecycle model, commitment baseline, Marketplace or LLM usage limits, and configured command intents | Cost guardrail docs, infrastructure policy files, review checklists, tag schemas, quota notes, budget-action runbooks, cleanup rules, retention defaults, autoscale caps, Kubernetes ResourceQuota and LimitRange notes, registry lifecycle policies, provider usage caps, focused tests, and directly synchronized templates. CI runner minutes, workflow matrix cost, artifact retention, cache quota, and release asset handoff route to `ci-pipeline-triage` first | notification-only budget, imagined hard spending limit, mixed prod and dev account, over-wide service quota, missing owner tag, tag-key chaos, no expires_at, stopped VM with NAT or DB still running, unbounded autoscale, missing Kubernetes ResourceQuota, inflated requests growing nodes, cloud-native service through NAT, untracked egress, cross-AZ surprise, idle public IPv4, no CDN cache cost control, log ingest flood, infinite retention, high-cardinality metric label, unbounded flow or audit logs, object lifecycle missing, cold-storage minimum-duration trap, stale block volume type, snapshot landfill, sticky DB storage growth, unbounded registry images, premature commitment, stateful spot misuse, unmonitored Marketplace or LLM spend, CI billing routed to broad cloud review before localizing workflow cost, or no safe cost stop runbook | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `docs_validate_fast`, `test_release`, `mustflow_check` | Cloud cost boundary reviewed, cost surface ledger, budget and action model, isolation/quota/tag/autoscale/Kubernetes/network/telemetry/storage/registry/commitment/spot/Marketplace/LLM/SaaS guardrail findings, manual-only provider checks, verification, and remaining cloud-cost risk |
 | Code review or implementation needs rate-limit integrity triage for rate limits, throttling, quotas, API usage limits, request costs, token bucket, leaky bucket, fixed window, sliding window counter, sliding window log, GCRA, Redis counters, Lua or EVAL updates, CDN or WAF limits, gateway limits, service limits, tenant, user, API key, route group, IP, 429, `Retry-After`, `RateLimit`, shadow mode, operator reset, async enqueue, cached-hit counting, or concurrency-limit overlap that must protect a named resource without bypass, unfairness, counter drift, storage growth, retry storms, or misleading client hints | `.mustflow/skills/rate-limit-integrity-review/SKILL.md` | Protected resource ledger, cost-weighted request ledger, layer model, key model, algorithm and storage model, failure mode model, response contract, observability and operator evidence, and configured command intents | Protected-resource definitions, request cost weights, per-key policy, layered limit placement, route-template keys, atomic counter updates, TTLs, storage-time use, fail-open or fail-closed policy, blocked-decision cache, shadow mode, 429 response shape, observability fields, operator lookup or reset behavior, focused tests, and directly synchronized docs or templates | algorithm-first limiter, request-count-only quota, IP-only authenticated key, raw URL key explosion, missing identity-header policy, fixed-window boundary burst, costly sliding-window log on hot paths, non-atomic Redis read-modify-write, missing counter TTL, Redis Cluster hash-slot failure, app-server clock reset drift, process-local global quota, approximate edge limit treated as precise, hidden fail-open, free failed responses, rate versus concurrency confusion, unhelpful or leaky 429, synchronized retry wave, unsafe allow-decision cache, no shadow-mode ramp, missing policy id logs, raw Redis reset, unlimited async enqueue, cached CDN hit ambiguity, or rate limit treated as authorization or hard cost control | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `docs_validate_fast`, `test_release`, `mustflow_check` | Rate-limit policy boundary reviewed, protected resource and cost/layer/key/storage/fail-mode/response/operator model mapped, evidence level, verification, and remaining rate-limit-integrity risk |
-| Code review or implementation needs idempotency-integrity triage for repeated requests, retries, duplicate POST/PATCH/DELETE calls, webhooks, provider callbacks, queue redelivery, scheduler or batch reruns, double clicks, app restarts, timeout recovery, external API callbacks, or duplicate business commands that can apply the same logical operation more than once | `.mustflow/skills/idempotency-integrity-review/SKILL.md` | Operation identity ledger, side-effect ledger, durable dedupe evidence, duplicate response policy, concurrency and recovery evidence, queue/webhook/scheduler/batch evidence, test evidence, and configured command intents | Durable idempotency records, request body hash checks, user and tenant binding, operation-type and target-resource binding, unique constraints, atomic insert-or-return behavior, state guards, affected-row checks, inbox and outbox records, applied-event ledgers, provider result lookup, response replay, processing lease recovery, focused duplicate tests, and directly synchronized docs or templates | POST-only assumption, idempotency key without durable storage, key not bound to payload or actor, memory-only or Redis-TTL-only dedupe, app-only `exists` then `insert`, missing unique index, duplicate success response drift, failed-attempt caching mistake, timeout treated as failure, external API before local operation record, provider idempotency used as internal proof, unconditional status update, duplicate increment, DELETE side-effect replay, GET hidden mutation, queue ack before durable commit, queue redelivery damage, webhook replay or stale event overwrite, scheduler rerun duplication, missing outbox or inbox, double compensation, stuck `PROCESSING`, lock-only proof, frontend-only debounce, or missing duplicate-path tests | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `docs_validate_fast`, `test_release`, `mustflow_check` | Idempotency boundary reviewed, logical operation and duplicate sources mapped, operation identity/payload/response/recovery evidence, durable dedupe and side-effect findings, tests or evidence level, verification, and remaining idempotency-integrity risk |
+| Code review or implementation needs idempotency-integrity triage for repeated or out-of-order requests, retries, webhooks, queue delivery, scheduler or batch reruns, callbacks, timeout recovery, duplicate business commands, stale asynchronous completions, aggregate sequence gaps, or old decisions that can repeat effects or overwrite newer authority | `.mustflow/skills/idempotency-integrity-review/SKILL.md` | Operation, attempt, event, message, effect, actor, tenant, target, and provider identity ledger; canonical payload binding; ordering aggregate and scope; state, version, sequence, generation, and fence authority; durable dedupe; response replay; recovery; queue, webhook, scheduler, and batch evidence; test evidence; and configured command intents | Stable cross-retry operation identity, distinct attempt and effect IDs, canonical payload conflict checks, unique non-null durable admission, atomic insert-or-return, aggregate versions, bounded gap handling, conditional state or fence writes, affected-row decisions, inbox and outbox records, result lookup and replay, processing recovery, invariant reconciliation, adversarial duplicate and stale-order tests, and directly synchronized docs or templates | per-retry operation ID, nullable uniqueness key, key not bound to payload or actor, memory-only or TTL-only dedupe, app-only check-then-insert, global-order assumption, timestamp or serial ID as causality, unowned sequence gap, unconditional late write, blind CAS retry, cancellation as rollback, single-flight as correctness, lock without fencing, ambiguous effect replay, queue settlement split, duplicate compensation, or ordinary tests presented as concurrency proof | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `docs_validate_fast`, `test_release`, `mustflow_check` | Idempotency boundary reviewed, logical operation and attempts, duplicate sources, ordering aggregate and authority token, gap and stale-result policy, durable dedupe and replay, external-effect and reconciliation findings, adversarial evidence, verification, and remaining idempotency-integrity risk |
 | Code review or implementation needs retry-policy integrity triage for retry loops, SDK retry configs, client middleware, `while true`, `for (;;)`, recursive retry, `maxAttempts`, `maxRetries`, `maxElapsedTime`, deadline, timeout, sleep, backoff, jitter, `Retry-After`, retry predicates, layered retries, circuit breakers, bulkheads, token buckets, queue redelivery, broker retry, cancellation-aware sleep, or retry observability that can amplify failures, duplicate side effects, hide permanent errors, exhaust pools, or overload dependencies | `.mustflow/skills/retry-policy-integrity-review/SKILL.md` | Retry surface, layered retry ledger, attempt budget, retry predicate, side-effect and idempotency ledger, backoff and jitter policy, overload and throttling evidence, observability and test evidence, and configured command intents | Bounded attempts, max elapsed time, per-attempt timeout, total deadline, cancellation propagation, retry predicates, exponential backoff with jitter, `Retry-After` parsing and clamping, idempotency key reuse, dependency-specific policy, retry wrapper diagnostics, per-attempt logs and metrics, focused retry tests, and directly synchronized docs or templates | retry amplification, infinite retry, capped backoff without stop condition, timeout gap for DNS, TLS, pool wait, streaming, or parsing, fixed-sleep herd behavior, broad catch-and-retry, permanent error retry, unknown-outcome replay, new idempotency key per attempt, key not bound to actor or payload, retry inside transaction or lock, pool starvation, unlimited parallel retry, stale per-key failure counter, global limiter unfairness, wrong circuit breaker or bulkhead order, wrapper losing cause/status/retry-after/request id, committed-response retry, non-replayable streaming body retry, app-plus-broker retry multiplication, cancellation-ignoring sleep, generic dependency policy, missing retry metrics, or happy-path-only retry tests | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `docs_validate_fast`, `test_release`, `mustflow_check` | Retry policy boundary reviewed, layer multiplication and attempt budget mapped, timeout/backoff/predicate/idempotency/throttling findings, evidence level, verification, and remaining retry-policy-integrity risk |
 | Code review or implementation needs queue-processing integrity triage for queues, streams, pub/sub handlers, workers, task runners, consumers, producers, webhook handoffs, DLQ replayers, retry workers, ack, nack, reject, delete, visibility timeout, offset commit, publisher confirm, prefetch, batch commit, rebalance, FIFO message group, deduplication, or worker-loss behavior that can lose messages, duplicate side effects, hide poison messages, reorder state, exhaust consumers, or falsely claim processing success | `.mustflow/skills/queue-processing-integrity-review/SKILL.md` | Broker and delivery model, success boundary, producer boundary, consumer state ledger, failure and retry policy, concurrency and ordering evidence, observability evidence, test evidence, and configured command intents | Settlement timing, publisher confirmation, outbox or inbox record, durable message key, conditional state transition, bounded retry and DLQ policy, visibility extension, prefetch and concurrency bounds, rebalance handling, shutdown drain, focused queue replay tests, and directly synchronized docs or templates | ack-before-work, catch-and-ack, finally-ack, auto-ack, stale receipt handle, premature offset commit, batch partial-failure skip, unbounded requeue, poison-message loop, unsafe visibility timeout, in-flight saturation, FIFO group misuse, worker-loss false success, producer publish split, side-effect duplication, missing rebalance fence, unlimited parallelism, DLQ bucket without replay policy, or missing decision-point observability | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `docs_validate_fast`, `test_release`, `mustflow_check` | Queue processing boundary reviewed, broker model and settlement evidence, producer/consumer/retry/DLQ/order/concurrency findings, evidence level, verification, and remaining queue-processing-integrity risk |
 | Code review or implementation needs transaction-boundary integrity triage for transactions, ORM atomic blocks, unit-of-work code, database write paths, service workflows, command handlers, webhook processors, queue consumers, framework transaction annotations, isolation levels, lock usage, rollback behavior, after-commit side effects, outbox patterns, retry handling, or transactional tests that can break a business invariant even when a transaction exists | `.mustflow/skills/transaction-boundary-integrity-review/SKILL.md` | Business invariant, transaction boundary, decision ledger, durable guard evidence, framework behavior, side-effect ledger, failure and retry evidence, test evidence, and configured command intents | Whole read-decision-write transaction boundaries, durable constraints, atomic upsert or conditional update, affected-row checks, version checks, correct lock target, transaction narrowing, after-commit or outbox side effects, idempotent retry classification, focused tests, and directly synchronized docs or templates | app-only `exists()` or `count` guard, stale read-decision-write, absent-row `FOR UPDATE` gap, `SKIP LOCKED` consistency misuse, READ COMMITTED snapshot myth, REPEATABLE READ engine mismatch, SERIALIZABLE without full retry, deadlock or serialization failure treated as plain 500, swallowed rollback trigger, Spring `rollbackFor` miss, self-invocation bypass, `readOnly` write assumption, inner rollback-only surprise, `REQUIRES_NEW` pool pressure, `NESTED` savepoint confusion, Django nested `atomic()` durability myth, pre-commit email/cache/queue side effect, HTTP API inside transaction, Hibernate flush-as-commit confusion, SQLAlchemy implicit transaction surprise, missing optimistic lock, advisory lock scope leak, wrong transaction manager, or transactional test hiding commit behavior | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `docs_validate_fast`, `test_release`, `mustflow_check` | Transaction boundary reviewed, invariant and decision ledger, durable-guard/lock/isolation/retry/rollback/side-effect findings, evidence level, verification, and remaining transaction-boundary integrity risk |
@@ -653,6 +669,7 @@ routes. Event routes stay inactive until their event occurs.
 | User requirements, acceptance criteria, issue reports, bug reports, product notes, compatibility promises, or examples must be preserved as regression coverage before or during implementation | `.mustflow/skills/requirement-regression-guard/SKILL.md` | Requirement source, observable behavior, existing tests or fixtures, implementation scope, changed files, and command contract entries | Focused tests, fixtures, examples, schemas, docs, and implementation changes directly tied to the requirement | untested requirement, invented acceptance criteria, weakened tests, hidden behavior drift, or unverifiable implementation claim | `changes_status`, `changes_diff_summary`, `test_related`, `test`, `test_audit`, `docs_validate_fast`, `test_release`, `mustflow_check` | Requirement sources, coverage map, guards added or reused, implementation changes, deferred requirements, verification, and remaining regression risk |
 | The user explicitly requests TDD, test-first work, red-green-refactor, RED/GREEN, or one observable behavior slice at a time | `.mustflow/skills/vertical-slice-tdd/SKILL.md` | TDD trigger, first behavior contract, existing tests, expected RED category, baseline status, and command contract entries | One focused test or fixture, the smallest implementation for the current slice, and directly synchronized docs when needed | invalid RED, broad slice, premature refactor, unrelated cleanup, or verification claim without configured command evidence | `changes_status`, `changes_diff_summary`, `test_related`, `test_audit`, `test`, `lint`, `build`, `mustflow_check` | Slice scope, existing coverage, RED category evidence, GREEN verification, refactors after GREEN, deferred slices, and remaining TDD risk |
 | New tests or test cases are designed, TDD RED or GREEN evidence is reported, or test-case choices are made for requirements, bugs, refactors, security boundaries, schemas, templates, or public docs | `.mustflow/skills/test-design-guard/SKILL.md` | Contract source, existing coverage, intended RED evidence, candidate cases, baseline status, and command contract entries | Tests, fixtures, helpers, and directly synchronized contract docs | invalid RED, happy-path-only coverage, speculative edge cases, weak assertions, mock-only confidence, or implementation-detail coupling | `test_related`, `test_audit`, `test`, `lint`, `build`, `test_release`, `mustflow_check` | RED category, selected test shape, evidence-backed cases, rejected speculation, verification objective, commands, and remaining test-design risk |
+| A coverage-guided fuzz target, persistent harness, property-based generator integration, differential or metamorphic oracle, corpus, dictionary, custom mutator, sanitizer lane, instrumentation or feedback setup, stateful campaign, crash minimization, CI corpus lifecycle, coverage plateau, non-reproducible artifact, or fuzzing-effectiveness claim is created, changed, reviewed, debugged, or reported | `.mustflow/skills/fuzz-harness-review/SKILL.md` | Target and stage matrix, deterministic entropy and reset model, semantic result envelope, property and divergence identifiers, oracle and resource ledger, input lanes, instrumentation boundary, reproduction capsule, exact minimization predicate, sanitizer lanes, seed/coverage/crash/regression asset policy, CI cadence, and configured command intents | Owned fuzz targets, deterministic adapters, property entropy decoders, result envelopes, stable invariant IDs, shadow models, custom mutators and shrinkers, dictionaries, bounded seed or regression corpora, sanitizer and instrumentation config, reproduction metadata, corpus staging or promotion rules, focused tests, docs, and directly synchronized templates | coverage-as-oracle, semantic distance as failure, second randomness source, over-normalized differential result, two-implementation majority proof, shared-model bug, unstable property identity, any-crash minimization, trigger/detection/root-cause confusion, unsymbolized dedup, flaky artifact deletion, sanitizer pile-up, generic UB coverage claim, corpus and regression conflation, concurrent cross-engine corpus writes, schema-less corpus, secret-bearing seed, live-target fuzzing, or unconfigured long-running campaign | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `test_audit`, `docs_validate_fast`, `test_release`, `mustflow_check` | Fuzzing claim and target matrix, determinism and reset result, semantic oracle and property identity, input-lane and sanitizer decisions, exact reproduction and minimization result, CI asset lifecycle, configured verification, missing campaign evidence, and remaining fuzz-harness risk |
 | Test-suite runtime, CI feedback latency, test selection, shard balance, worker scheduling, retry policy, flaky-test handling, fixture setup, database or container test lifecycle, coverage or artifact overhead, test-result caching, test discovery, or test performance claims are planned, edited, reviewed, or reported | `.mustflow/skills/test-suite-performance-review/SKILL.md` | Suite surface, timing ledger, p50 and p95 evidence, selection ledger, isolation ledger, resource ledger, cache ledger, and command contract entries | Test timing collection, selected-test manifests, dependency-to-test maps, shard and worker scheduling, fixture lifecycle, DB/container setup, fake timers, stubs, cache keys, coverage defaults, CI reports, docs, and directly synchronized templates | faster-but-weaker verification, selector without full fallback, import-only impact analysis, cache false hit, volatile cache key, cold-cache theater, full discovery scan, per-test process startup, file-count sharding, idle workers, resource contention, shared DB schema, fixed sleeps, external internet dependency, hidden time/random/locale input, artifact tax, retry hiding real failure, or permanent flaky quarantine | `changes_status`, `changes_diff_summary`, `build`, `test_related`, `test`, `test_audit`, `docs_validate_fast`, `test_release`, `mustflow_check` | Suite surface, feedback goal, timing bottleneck, selection and fallback policy, scheduling and resource-token decisions, fixture and isolation notes, cache and retry policy, artifact policy, speed evidence, verification, and remaining test-suite performance risk |
 | Tests are added, updated, removed, or audited | `.mustflow/skills/test-maintenance/SKILL.md` | Changed behavior or stale-test evidence | Test files and related source | contract drift | `test`, `test_related`, `test_audit`, `snapshot_update`, `lint`, `build` | Test rationale and verification |
 
@@ -679,7 +696,8 @@ routes. Event routes stay inactive until their event occurs.
 | Authentication, authorization, permission, effective-permission decision, role, RBAC/ABAC policy, tenant, organization or team membership, session, cookie, JWT, refresh token, OAuth/OIDC, MFA, passkey, account recovery, API key, route guard, admin, impersonation, database policy, object-level access control, or permission cache behavior is created or changed | `.mustflow/skills/auth-permission-change/SKILL.md` | Actors, principals, permission decision tuple, effective permissions, tenants, organizations, teams, resources, actions, context, auth middleware, sessions, cookies, tokens, refresh-token store, OAuth/OIDC, MFA/passkeys, API keys, route guards, server policy, DB policy, role matrix, audit, and tests | Auth middleware, policy functions, controllers, services, jobs, webhooks, database queries, RLS, UI guards, audit logs, docs, migrations, and tests | authentication treated as authorization, role column mistaken for effective permission, unexplained allow or deny, client guard trusted as security, object-level authorization bypass, cross-tenant leak, stale token or cache permission, refresh-token reuse gap, account-recovery privilege escalation, over-broad admin/API-key scope, or missing denial tests | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `docs_validate_fast`, `test_release`, `mustflow_check` | Auth/authz boundary, principal/tenant/resource/action/context, effective permission, policy version, decision explanation, revocation window, policy source of truth, server/database enforcement, client UX-only guards, account-takeover response, denial coverage, verification, and remaining permission risk |
 | API security review needs api-access-control triage for BOLA or IDOR, effective permission decisions, broken authentication, object-level authorization, object-property authorization, function-level authorization, request-supplied user, tenant, role, or owner identifiers, tenant isolation, scoped admin, list/detail mismatch, write permissions, mass assignment, DTO exposure, client-only admin, temporary public holes, router order, GraphQL resolvers, batch APIs, exports, downloads, previews, signed storage URLs, cache keys, async job revalidation, webhook ownership mapping, OAuth or OIDC confusion, JWT verification, stale token claims, session rotation, cookie flags, reauthentication, reset tokens, account enumeration, automation defense, internal identity planes, or denial-case matrices | `.mustflow/skills/api-access-control-review/SKILL.md` | User goal, current diff or target files, subject-object-action-context ledger, decision explanation ledger, object authorization ledger, property authorization ledger, function authorization ledger, authentication proof ledger, denial evidence, and configured command intents | Server-side object checks, tenant-scoped lookups, relationship checks, function-level checks, property allowlists, DTO mappers, signed URL scoping, cache-key dimensions, worker revalidation, webhook ownership mapping, token/session/cookie hardening, reauthentication gates, enumeration-safe responses, rate limits, audit logs, focused denial tests, and directly synchronized docs or templates | login-as-authorization, request-owned identity trust, findById before owner check, role-only admin, unexplainable allow/deny decision, list/detail authorization drift, read/write permission confusion, mass assignment, entity DTO leak, client-only admin, permitAll leak, route shadowing, resolver bypass, batch item bypass, export/download bypass, signed URL bypass, tenantless query or cache, stale queue permission, webhook ownership confusion, OAuth/OIDC token confusion, decoded-but-unverified JWT, stale token claim, session fixation, weak cookie, missing reauth, reusable reset token, account enumeration, automation abuse, internal account exposure, or happy-path-only auth tests | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `test_audit`, `docs_validate_fast`, `test_release`, `mustflow_check` | API access control reviewed, subject/object/action/field/tenant map, effective permission and decision-explanation findings, object/property/function/auth findings, fixes or recommendation, denial evidence, verification, and remaining API access-control risk |
 | Admin panel, backoffice tool, support console, operator dashboard, staff API, internal dashboard, admin RBAC or ABAC, scoped operator role, audit log, object change history, impersonation, dangerous action, approval flow, export, import, bulk operation, admin search or filter, production guardrail, PII masking, admin session, MFA, or operational-evidence work needs admin-control-plane safety triage | `.mustflow/skills/admin-control-plane-safety-review/SKILL.md` | User goal, current diff or target files, admin actor and session ledger, permission ledger, resource and field ledger, dangerous action ledger, audit and change-history ledger, impersonation ledger, search/filter/export/import/bulk ledger, role matrix, admin docs, runbooks, existing tests, and configured command intents | Scoped admin permission checks, trusted-layer enforcement, server-side field allowlists, tenant-scoped lookups, step-up authentication, dangerous-action previews and confirmations, approval gates, audit records, change-history records, impersonation controls, export/import controls, bulk dry-run and job controls, search and filter limits, production guardrails, focused hostile-path tests, and directly synchronized docs or templates | single `is_admin` shortcut, UI-only admin gate, hidden button trusted as security, support bypass, role-only operator permission, missing explicit deny, missing admin MFA or step-up, audit log confused with change history, editable audit trail, impersonation without actor and subject, export-as-harmless-read, unlimited PII CSV, import mass assignment, bulk click without dry run, preview payload trusted at execution, missing idempotency, no cancel or partial-failure report, production/staging confusion, unmasked sensitive search, unaudited PII read, or happy-path-only admin tests | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `test_audit`, `docs_validate_fast`, `test_release`, `mustflow_check` | Admin control plane reviewed, operator persona and environment scope, effective permission and trusted enforcement findings, admin session and production guardrails, audit versus change-history findings, impersonation/dangerous-action/export/import/bulk/search/filter findings, hostile-path evidence, verification, and remaining admin-control-plane risk |
-| File upload, import, attachment, direct-to-storage upload, remote file fetch, archive extraction, thumbnail, preview, image resize, OCR, media transcode, document conversion, antivirus scan, CDR, file metadata, storage key, public file URL, signed upload URL, signed download URL, CDN delivery, file download, uploaded filename display, or file lifecycle test needs file-upload-security triage across validation, storage, processing, serving, and cleanup | `.mustflow/skills/file-upload-security-review/SKILL.md` | User goal, current diff or target files, upload entrypoint ledger, file identity ledger, validation ledger, processing ledger, serving ledger, existing tests or abuse cases, storage policy evidence, and configured command intents | Server-side type allowlists, decoded and normalized filename checks, generated storage keys, path containment checks, overwrite protection, upload size and count limits, quota checks, quarantine states, scanner gates, parser sandboxing, archive extraction guards, CSV formula neutralization, metadata stripping, image rewriting, signed URL constraints, download authorization, response headers, filename encoding, audit logs, cleanup rules, focused denial tests, and directly synchronized docs or templates | client-only file restriction, trusted MIME label, extension check before normalization, blocklist-only type policy, original-name-only validation, user-controlled storage key, path traversal, long-name exception leak, overwrite or key guessing, executable web-root storage, web-server handler execution, magic-byte theater, polyglot file, metadata payload, active SVG or HTML, unsafe PDF or Office preview, Zip Slip, decompression bomb, CSV formula injection, remote fetch SSRF, scan-after-publication gap, unsandboxed parser, weak presigned URL policy, direct-to-storage pre-scan publication, tenant key collision, missing download authorization, unsafe response header, filename XSS or header injection, chunk assembly bypass, quota bypass, orphan file leak, or happy-path-only upload tests | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `test_audit`, `docs_validate_fast`, `test_release`, `mustflow_check` | File upload security reviewed, upload/file identity/storage/validation/processing/serving/cleanup map, findings, fixes or recommendation, denial evidence, verification, and remaining file-upload security risk |
+| Untrusted bytes, text, URL components, headers, query parameters, structured payloads, identifiers, filenames, filters, sort keys, template values, process arguments, or database inputs cross decoding, normalization, parsing, schema, semantic, authorization, resource, or execution boundaries | `.mustflow/skills/input-boundary-validation-review/SKILL.md` | Entry points, representation ledger, decoder and parser policies, field identity policy, schema and coercion rules, authorization handoff, structured sinks, resource budgets, positive and denial fixtures, and configured command intents | Strict decoders, field-specific canonicalizers, duplicate-aware parsers, schemas, DTOs, typed query or command compilers, safe sink adapters, resource budgets, focused denial and differential tests, docs, and directly synchronized templates | double decode, malformed-encoding repair, validation-execution split, global sanitizer, denylist-as-gate, partial regex match, Unicode identity collision, duplicate winner drift, scalar-array coercion, unknown-field fail-open, parser differential, SQL or NoSQL grammar injection, process option injection, path or template injection, expansion bomb, partial side effect, or authorization on a different identity | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `test_audit`, `docs_validate_fast`, `test_release`, `mustflow_check` | Representation ledger, decoder/canonicalization/parser/schema/budget decisions, syntax-semantic-authority separation, structured sink decision, denial and differential evidence, verification, and remaining input-boundary risk |
+| File upload, import, attachment, direct-to-storage upload, remote file fetch, archive extraction, thumbnail, preview, image resize, OCR, media transcode, document conversion, antivirus scan, CDR, file metadata, storage key, public file URL, signed upload URL, signed download URL, CDN delivery, file download, uploaded filename display, or file lifecycle test needs file-upload-security triage across validation, storage, processing, serving, and cleanup | `.mustflow/skills/file-upload-security-review/SKILL.md` | User goal, current diff or target files, upload entrypoint ledger, storage-access ledger with opaque ids, authorization tuples and exact keys or root capabilities, file identity and byte-lineage ledger, immutable quarantine and approved object versions and digests, validation ledger, decoded-resource ledger, processing ledger, remote-fetch resolution and redirect ledger, serving ledger, existing tests or abuse cases, storage policy evidence, and configured command intents | Opaque-id APIs, server-side type allowlists, decoded and normalized filename checks, generated exact storage keys, root-capability containment, overwrite protection, immutable object binding, quarantine states, scanner gates, parser sandboxing and budgets, archive entry and actual-byte guards, image rewriting, remote-fetch address pinning and redirect revalidation, signed URL constraints, download authorization, response headers, audit logs, cleanup rules, focused denial tests, and directly synchronized docs or templates | client-only file restriction, trusted MIME label, blocklist-only type policy, path-shaped public API, user-controlled storage key, prefix authorization, path traversal, overwrite or key guessing, executable web-root storage, magic-byte theater, polyglot file, unbounded decoded pixels or frames, active SVG or HTML, unsafe PDF or Office preview, Zip Slip, archive special entry, order-dependent entry, metadata restoration, sparse-size bypass, declared-size trust, decompression bomb, remote fetch SSRF, DNS or redirect rebinding, credential forwarding, scan-after-publication gap, inspected-versus-served object swap, unsandboxed parser, weak presigned URL policy, tenant key collision, missing download authorization, unsafe response header, static fallback or raw-name log injection, chunk assembly bypass, quota bypass, orphan file leak, or happy-path-only upload tests | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `test_audit`, `docs_validate_fast`, `test_release`, `mustflow_check` | File upload security reviewed, opaque-id and storage-access boundary, upload and byte-lineage map, immutable object version and digest binding, decoded-resource and remote-fetch ledgers, validation/processing/serving/cleanup findings, denial evidence, verification, and remaining file-upload security risk |
 | Code review or implementation needs security-flow triage by tracing values from source to sink across authorization, object ownership, tenant scoping, IDOR or BOLA risk, list/detail/export scope, state-changing permissions, mass assignment, admin-only surfaces, cache keys, sort/filter/field injection inputs, ORM raw paths, shell wrappers, SSRF, file upload and extraction, path traversal, development server file serving, privileged test or browser UI APIs, XSS, CSRF, OAuth, reset tokens, JWTs, cookies, cryptography, logs, fail-open error handling, queued work, race conditions, or supply-chain and CI/CD paths | `.mustflow/skills/security-flow-review/SKILL.md` | User goal, current diff or target files, security claim, source-to-sink map, actor and resource map, read and write surfaces, framework escape hatches, dev-server host and filesystem policy, privileged test UI APIs, existing tests or scanner findings, and configured command intents | Server-side ownership checks, tenant-scoped queries, allowlisted updates, cache-key dimensions, URL and path validation, parser or renderer boundaries, dev-server read-only/write/execute gates, upload and extraction limits, token validation, cookie flags, fail-closed error handling, queue revalidation, idempotency, focused tests, and directly synchronized docs or templates | dangerous-keyword theater, authentication treated as authorization, UUID-as-lock assumption, list/detail scope drift, export over-disclosure, state change via raw body status, mass assignment, frontend-only admin gate, cache viewer leak, ORDER BY injection, ORM raw escape hatch, shell wrapper injection, SSRF, unsafe upload preview, Zip Slip, decompression bomb, path traversal, Windows ADS or 8.3 alias bypass, exposed dev-server file read, exposed test UI write or rerun API, XSS, CSRF, weak OAuth state, reset-token reuse, stale JWT claims, broad cookie domain, custom crypto, token or PII logging, missing security logs, fail-open permission, stale queued permission, duplicate money or entitlement effect, postinstall or CI secret exposure | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `docs_validate_fast`, `test_release`, `mustflow_check` | Security flow reviewed, source/sink/actor/resource/tenant map, authorization and ownership notes, input/file/network/browser/token/cookie/crypto/log/fail-open/async/race/cache/dev-server/test-UI/supply-chain findings, fixes or recommendation, tests or invariant evidence, verification, and remaining security-flow risk |
 | Code, configuration, docs, templates, logs, telemetry, traces, baggage, behavior analytics, credentials, data flows, data residency policy, region or processing-location claims, AI-generated code, authentication, authorization, client-only permission checks, admin operations, audit logs, cache policy, cache-as-authority decisions, claim or policy data, comparison or affiliate data, user-generated content, sessions, tokens, uploads, downloads, signed URLs, API responses, webhooks, job queues, external API call records, external requests, third-party data-use terms, runtime security patch policy, vulnerability scanner advisories, development servers, test UI servers, deployment settings, dependencies, cryptography, secure transport, scanner gates, security invariants, or agent configuration affect secrets, personal data, retention, access control, vendor disclosure, or external disclosure | `.mustflow/skills/security-privacy-review/SKILL.md` | Changed files, sensitive surfaces, actor and resource owner, data-owner boundary, data residency and processing-location boundary, runtime patch boundary, dev-server host or privileged API boundary, AI gateway or budget boundary, server-side authorization rule, file upload/download boundary, API response field boundary, behavior analytics surface, trace or baggage surface, webhook or external-call record surface, admin operation surface, audit-log surface, cache visibility and authority policy, claim or affiliate policy surface, session or token surface, external target, dependency source, advisory exploit preconditions, third-party data-use or terms surface, cryptography or transport surface, scanner evidence, agent-tool permission, deployment setting, project secret and privacy rules, public or packaged surfaces, and command contract entries | Sensitive data handling, authorization, admin operations, data residency, runtime patchability, dev-server file-serving and privileged API gates, AI budget records, behavior analytics, observability identifiers, webhook receipts, external-call records, dead-letter records, audit logs, shared-cache behavior, cache-authority behavior, claim and affiliate disclosure, sessions, tokens, inputs, files, signed URLs, API responses, logs, receipts, generated state, docs, templates, package metadata, deployment settings, and reports | secret leak, personal-data exposure, access-control bypass, client-trusted role or owner value, unsafe admin action, private file exposure, exposed local tool API, over-broad API response, shared-cache leak, unsafe cache authority, unprovable data location, unpatchable runtime, devDependency alert dismissed despite network exposure, privacy-heavy telemetry, unsafe baggage propagation, unsafe webhook payload retention, unsafe external request, supply-chain drift, weak cryptography, insecure transport, protocol parser DoS, over-privileged agent, risky third-party terms, or misleading privacy claim | `changes_status`, `changes_diff_summary`, `docs_validate_fast`, `test_release`, `mustflow_check` | Sensitive surfaces reviewed, data residency, runtime patchability, dev-server/test-UI exposure, AI hard-limit, behavior analytics, observability, and audit boundaries, webhook, external-call, and dead-letter boundaries, cache authority and disclosure boundaries, assumptions checked, disclosure and retention paths, authorization, file, API response, third-party terms, and external-boundary notes, verification, and remaining security or privacy risk |
 | Real or plausible secrets, tokens, credentials, private keys, passwords, session values, service-account values, connection strings, signing secrets, webhook secrets, certificate keys, recovery codes, or production-like credential material appear in files, artifacts, logs, command output, screenshots, fixtures, docs, templates, package output, caches, run receipts, or final reports | `.mustflow/skills/secret-exposure-response/SKILL.md` | Exposure surface, secret type without value, tracked/generated/public/package status, allowed remediation scope, rotation or revocation boundary, and command contract entries | Redaction, omission, placeholder replacement, docs, fixtures, templates, examples, package inputs, generated artifacts, and final report wording | repeated exposure, false fake-value claim, redaction mistaken for revocation, package leak, screenshot leak, history exposure, or secret printed in reports | `changes_status`, `changes_diff_summary`, `docs_validate_fast`, `test_release`, `mustflow_check` | Exposure surfaces reviewed, secret value omitted, remediation made, remaining rotation/revocation/history/external risks, verification, and remaining exposure risk |
@@ -713,7 +731,7 @@ routes. Event routes stay inactive until their event occurs.
 | Microsoft Edge WebView2 SDK or Runtime selection, `CoreWebView2Environment`, custom initialization, UDFs, profiles, web messages, host objects, document or frame trust, navigation, popups, downloads, permissions, process failures, memory, performance, Evergreen or Fixed Version deployment, WPF, WinForms, WinUI, or Win32 behavior is created, changed, reviewed, debugged, or upgraded | `.mustflow/skills/webview2-code-change/SKILL.md` | Host/Runtime, environment/UDF/profile, trust/bridge/navigation, lifecycle, failure, and performance ledgers; official source evidence; changed files; and command contract entries | Initialization, environment registry, UDF/profile policy, bridge handlers, navigation/frame policy, popup/download/permission lifecycle, process recovery, memory/performance diagnostics, Runtime update, packaging, tests, and docs | implicit `Source` initialization, UDF deletion retry, SDK/Runtime confusion, untrusted native RPC, prefix origin check, broad host object, stale navigation result, leaked event/deferral/child/download, recovery loop, process-count theater, timing misdiagnosis, Evergreen update not adopted, or unowned Fixed Runtime patching | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `docs_validate_fast`, `mustflow_check` | Host/SDK/Runtime/distribution decision, environment/UDF/profile/process/document ownership, bridge/navigation/lifecycle/security/memory/performance findings, verification, and remaining WebView2 risk |
 | Hetzner Cloud or Dedicated infrastructure, hcloud or API integrations, Terraform provider resources, servers, networks, load balancers, firewalls, IPs, placement groups, volumes, backups, Object Storage, Storage Box, cloud-init, Docker or Coolify hosting, Kubernetes CCM or CSI integration, monitoring, recovery, capacity, cost, or Hetzner-related deployment tests are created, changed, reviewed, debugged, migrated, or upgraded | `.mustflow/skills/hetzner-cloud-change/SKILL.md` | Target repository and environment, Hetzner project or account boundary, infrastructure source and state owner, resource and credential ledger, failure domains, traffic and storage model, container data paths, guest network owner, CCM/CSI compatibility, RPO/RTO, workload and capacity evidence, current official provider facts, changed files, and command contract entries | Hetzner IaC, provider integrations, bootstrap config, images, guest networking, container mounts, orchestration drivers, application resilience code, health checks, monitoring, tests, fixtures, runbooks, architecture docs, cost guardrails, and directly synchronized templates | Placement Group treated as an availability zone, Firewall allowlists treated as overrides, outbound or existing-session semantics ignored, label selection treated as applied state, private Network treated as encrypted or filtered, L3 Network treated as VLAN, competing DHCP owners, load balancer or Floating IP treated as automatic location failover, DDoS filtering treated as WAF or origin authentication, Docker named volume treated as Hetzner Volume, missing mount creating fresh state, Object Storage treated as POSIX, unpinned CCM/CSI compatibility, replicated storage or server Backup treated as independent backup, provider-only monitoring or recovery control, unfenced IP move, untested private-only recovery, irreversible rescale, architecture mismatch, arbitrary performance thresholds, destructive raw-device benchmark, powered-off resource assumed free, stale price or limit, autonomous cleanup, or local validation claimed as live provider state | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `docs_validate_fast`, `test_release`, `mustflow_check` | Hetzner boundary and resource ledger, refreshed provider facts and integration versions, failure-domain/network/firewall/credential/storage/mount/backup/restore decisions, compute/performance/capacity/cost evidence, state layers verified, files changed, command intents run, manual provider checks, and remaining Hetzner risk |
 | File path handling, cross-platform path behavior, path helpers, safe filesystem wrappers, clone or checkout destinations, scaffold roots, temp or cache paths, atomic writes, locks, archive extraction, uploads, downloads, scanners, CLI/API/schema path contracts, snapshots, generated outputs, or package artifact paths are created, changed, reviewed, or reported | `.mustflow/skills/file-path-cross-platform-change/SKILL.md` | Path ledger, trust classes, accepted path representation, base root, path helpers, safe filesystem wrappers, clone/checkout/scaffold/install/extract outputs, staging and promotion policy, temp/cache helpers, lock policy, archive policy, upload/download policy, scanner policy, CLI/API/schema/snapshot/generated/package surfaces, platform expectations, failure taxonomy, and command contract entries | Path validators, helpers, wrappers, schemas, CLI/API parsing, snapshots, fixtures, docs, tests, generated-output paths, package artifact paths, clone or scaffold destinations, archive extraction, scanner bounds, temp/cache handling, locks, and cleanup code | path traversal, base containment bypass, drive-relative path bug, reserved-name bug, case-collision bug, Unicode-collision bug, Git checkout path-length failure misreported as network or auth, unsafe archive extraction, non-atomic write claim, stale lock, scanner loop, partial-output cleanup data loss, user-selected destination deletion, path contract drift, or package artifact path drift | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `docs_validate_fast`, `test_release`, `mustflow_check` | Path contract, path ledger, trust classes, root policy, preflight/staging/promotion decisions, Windows/macOS/Linux/archive/upload/download/scanner/lock/temp/cache/atomic/cleanup decisions, failure taxonomy, synchronized contract surfaces, verification, and remaining path risk |
-| File paths, directories, symlinks, real paths, traversal, NTFS alternate data streams, Windows 8.3 short names, Windows namespace prefixes, atomic writes, file copies, generated outputs, temporary files, clone or checkout materialization, cleanup, or Windows/POSIX filesystem behavior are created, changed, reviewed, or reported | `.mustflow/skills/cross-platform-filesystem-safety/SKILL.md` | Path inputs, base directory, trust boundary, symlink policy, write or cleanup strategy, clone/checkout/scaffold/install/extract path budget, app-owned staging boundary, platform expectations, ADS and short-name behavior, failure taxonomy, and command contract entries | Path validation, file helpers, copy/update/delete code, clone/scaffold/archive cleanup code, scan bounds, dev-server or file-serving deny checks, fixtures, tests, docs, and templates | path traversal, symlink escape, unsafe overwrite, Windows ADS bypass, 8.3 short-name bypass, namespace-prefix bypass, platform-only behavior, stale output, path-length or filename-length misclassification, watcher/resource misclassification, or cleanup data loss | `changes_status`, `changes_diff_summary`, `test_related`, `docs_validate_fast`, `test_release`, `mustflow_check` | Path trust classes, root boundary, symlink/write/delete/scan decisions, ADS and short-name handling, preflight and staging boundaries, clone/scaffold/extract classification, platform assumptions, verification, and remaining filesystem risk |
+| File paths, URI path components, directories, file descriptors or handles, symlinks, hard links, reparse points, junctions, mounts, traversal, archive extraction, atomic writes, queued file work, clone or checkout materialization, cleanup, or Windows/POSIX filesystem behavior are created, changed, reviewed, or reported | `.mustflow/skills/cross-platform-filesystem-safety/SKILL.md` | Representation and decode ledger, immutable segment policy, trusted root descriptor or handle, runtime and provider capability, opened-object identity, symlink, hard-link, reparse and mount policy, same-handle operation ledger, archive destination graph and metadata policy, write or cleanup strategy, path budget, platform expectations, failure taxonomy, and command contract entries | Path parsing and validation, descriptor-relative, handle-based or verified runtime root helpers, copy/update/delete code, archive plan and metadata enforcement, clone staging, queued object identities, scan bounds, fixtures, tests, docs, and templates | decode-order bypass, normalize-prefix theater, symlink or mount escape, hard-link alias, reparse or junction escape, TOCTOU reopen race, runtime fallback overclaim, archive order or sparse-budget bypass, unsafe overwrite, Windows namespace or ADS bypass, stale queued path, platform-only behavior, or cleanup data loss | `changes_status`, `changes_diff_summary`, `test_related`, `docs_validate_fast`, `test_release`, `mustflow_check` | Representation-to-opened-object chain, trusted root and runtime capability, same-descriptor or same-handle continuity, archive graph and metadata policy, link/mount/create/publish/delete/queue decisions, platform assumptions, verification, and remaining filesystem risk |
 | Child processes, shell or argv execution, built-in command reruns, Git/package-manager/scaffolder failures, timeouts, process trees, output limits, streaming, environment policy, command eligibility, failure classification, command-line length limits, or execution receipts are created, changed, reviewed, or reported | `.mustflow/skills/process-execution-safety/SKILL.md` | Execution path, timeout, output limit, stdin, argv and shell command-length budget, environment, cwd, process tree behavior, failure taxonomy, receipt and write-tracking expectations, and command contract entries | Process execution code, process-tree helpers, output buffers, environment creation, eligibility checks, failure classifiers, receipts, tests, and docs | runaway process, unbounded output, leaked environment, argv-too-long failure, shell-command-too-long failure, inconsistent JSON/text execution, false cleanup claim, Git checkout path failure misreported as network or auth, blind retry, diagnostic loss, or unreliable receipt | `changes_status`, `changes_diff_summary`, `test_related`, `test_release`, `mustflow_check` | Execution surface, timeout/output/environment/process-tree boundaries, argv and shell length handling, failure classification, diagnostic preservation, receipt consistency, tests, verification, and remaining process risk |
 | Core or application logic creates, imports, resolves, or hides external dependencies such as databases, SDKs, clocks, random generators, configuration, loggers, framework objects, filesystems, queues, AI clients, or payment/email providers | `.mustflow/skills/dependency-injection/SKILL.md` | Target code area, hidden dependency, intended business capability, layer ownership, local port/adapter patterns, changed files, and command contract entries | Core logic signatures, ports, adapters, assembly roots, tests, and directly synchronized docs or templates | hidden global state, untestable business logic, provider leakage, lifecycle drift, or service-locator coupling | `changes_status`, `changes_diff_summary`, `test_related`, `test`, `lint`, `build`, `docs_validate_fast`, `test_release`, `mustflow_check` | Dependency boundary, direct dependencies found, injection style, ports/adapters, assembly boundary, tests or fakes, verification, and remaining dependency leakage |
 | Code, data, schema, configuration, file layout, template, content frontmatter, file-to-database, URL, slug, lifecycle, asset, claim or fact extraction, API projection compatibility, public identifier changes, provider id mappings, event-schema changes, observability identifier continuity, deployment-state reproduction, generated-state, backup or restore proof, semantic export, import, platform exit, or cache migrations are planned, edited, documented, or reported | `.mustflow/skills/migration-safety-check/SKILL.md` | Source state, target state, migration surface owner, identity, lifecycle, asset, claim, export/import reconstruction shape, URL continuity, API projection expectations, public id mapping, provider id mapping, event schema versioning, observability identifier continuity, deployment-state reproduction, cache key versioning, restore evidence, idempotency, rollback, dry-run, compatibility, and command contract entries | Migration plans, compatibility notes, lock metadata, docs, tests, templates, generated state, redirects, assets, exports, imports, deployment notes, observability continuity notes, caches, restore notes, and reports | irreversible migration, data loss, incomplete export, broken links, identity drift, provider-id lock-in, lost asset originals, API contract break, event-schema ambiguity, broken traceability, dashboard-only operating state, cache-key drift, untested restore, or false migration-success claim | `changes_status`, `changes_diff_summary`, `docs_validate_fast`, `test_release`, `mustflow_check` | Migration surface, source and target state, identity, lifecycle, asset, claim, URL, API, event, observability, deployment-state, cache, restore, and export/import continuity, idempotency, rollback, metadata updates, verification, and remaining migration risk |
@@ -805,6 +823,14 @@ routes. Event routes stay inactive until their event occurs.
 | Skill procedures or routes are created or maintained, or their conditional, exception-bearing, authority-sensitive, universal, completion, or cross-repository verification claims need logical review | `.mustflow/skills/skill-authoring/SKILL.md` | Repeated task evidence, selected repository boundary, explicit parent dependencies, nearby rules, positive cases, boundary cases, and counterexamples | `.mustflow/skills/**` | overlap, command drift, cross-root verification inheritance, converse inference, unbounded quantifier, contradictory branch, flat authority ranking, unreachable stop state, or unobservable postcondition | `mustflow_check`, `docs_validate` | Skill route and procedure changes, logical consistency and repository-boundary result, counterexamples checked, and claims narrowed |
 | Agent A designs and Agent B implements from a versioned handoff, private `.agent` planning files, local-only ignored design state, manifest/plan/state ledgers, startup gates, allowed-path gates, blocker/deviation ledgers, or completion gates | `.mustflow/skills/design-implementation-handoff/SKILL.md` | Target repository, Agent A and Agent B surfaces, privacy mode, public behavior source, private handoff paths, ownership, allowed and forbidden paths, task dependencies, verification expectations, and remote-agent transfer boundary | `AGENTS.md`, public spec files, private `.agent` handoff files, ignore or exclude guidance, handoff templates, instruction artifacts, tests, docs, and directly synchronized workflow surfaces | hidden-only product contract, private-file leak, remote agent missing local context, plan/state version drift, Agent B editing Agent A-owned files, overly broad allowed paths, unbacked ignored files, or false completion evidence | `changes_status`, `changes_diff_summary`, `docs_validate_fast`, `mustflow_check` | Handoff mode, public versus private file split, Agent A/B ownership, startup and task gates, ignore or exclude decision, remote-agent limitation, verification gates, and remaining privacy or handoff risk |
 | Work instructions for coding agents, Codex tasks, work orders, issues, PR requests, automations, implementation briefs, reviews, proofs, cleanup tasks, or operational-readiness tasks are drafted, reviewed, or improved | `.mustflow/skills/task-instruction-authoring/SKILL.md` | Target agent surface, task family, goal, scope, constraints, durable rules, risk class, verification expectations, and required output | Instruction artifacts, work-order bodies, issue bodies, templates, docs, skills, checklists, and directly synchronized workflow surfaces | vague goal, delegated product decision, missing acceptance evidence, unsafe raw command, proof theater, review blade drift, overlong one-off policy, or operational-readiness gap | `changes_status`, `changes_diff_summary`, `docs_validate_fast`, `mustflow_check` | Instruction family, missing decisions, final instruction or rubric, durable guidance decision, verification expectations, and remaining ambiguity or operational risk |
+
+### General Code Change
+
+| Trigger | Skill Document | Required Input | Edit Scope | Risk | Verification Intents | Expected Output |
+| --- | --- | --- | --- | --- | --- | --- |
+| Keyboard, mouse, pointer, touch, pen, wheel, gamepad, raw input, remote desktop, cloud gaming, remote KVM, focus, capture, IME, clipboard, surface switching, coalesced events, frame or tick input, or replay code needs synchronization review because input can be lost, duplicated, reordered, delayed, looped, merged, routed elsewhere, or delivered after its authority generation ended | `.mustflow/skills/input-event-synchronization-review/SKILL.md` | Source and remote interaction ledgers; immutable envelope; event lineage; session, path, surface, focus, transform, composition and clipboard generations; semantic delivery class; deadline and supersession; ordering and gap recovery; ownership arbitration; acknowledgment layers; reducer and immutable batches; causal diagnostics; replay evidence; and configured command intents | Single normalization ingress, semantic transport classes, bounded dedupe/reorder and time debt, snapshots and repairs, receive/apply/present acknowledgments, origin-lineage loop guards, per-owner held state, fenced interaction leases, reconnect neutralization, confirmed focus, one IME authority, versioned composition and clipboard, surface barriers, capture-to-present traces, virtual-clock replay, adversarial fixtures, and synchronized docs or templates | transport ACK as application proof, one ordered backlog, stale continuous replay, predicted input made authoritative, capture/apply feedback loop, timing-based injection suppression, global reentry boolean, ownerless held state, timestamp arbitration, reconnect without neutralization, collapsed focus layers, dual IME authority, stale composition range, clipboard echo or bulk-input blockage, old-surface coordinates, mean-latency theater, content-heavy logs, or non-replayable diagnosis | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `test_audit`, `docs_validate_fast`, `test_release`, `mustflow_check` | Input synchronization boundary reviewed, local and remote source/envelope/identity/order/gap/lifecycle/reducer/transport/lineage/loop/ownership/focus/IME/clipboard/surface/acknowledgment/diagnostic/replay evidence, fixes or recommendation, verification, and remaining input-event risk |
+| Desktop or embedded UI code uses blocking dialogs, nested event loops, message pumping, synchronous UI waits, run-loop modes, dispatcher frames, local loops, synchronous cross-thread messages or RPC, portal requests, tracking loops, or callbacks that can reenter before the outer handler returns | `.mustflow/skills/modal-loop-reentrancy-review/SKILL.md` | Outer handler and stack, modal session and parent depth, owner and request identity, held locks and partial invariants, dispatch sources and contexts, run-loop mode and priority, wait-for graph, session-specific exit token, completion and commit authority, owner-disable and capture lease, object and collection lifetime, input generation, hidden/closed/reuse state, deferred destruction, platform matrix, diagnostics, tests, and configured command intents | Pre-pump admission, coherent snapshots, nonblocking result APIs, session-scoped TryComplete, one commit observer, session-specific loop exit, owner-disable accounting, weak-reference and generation guards, idempotent cleanup, stale-input invalidation, presentation after callback return, request state machine, capability-bearing picker results, low-overhead modal spans, wait and causal graphs, deterministic reentry fixtures, and synchronized docs or templates | modal treated as app pause, guard assigned after pumping, recursive lock as fix, half-applied invariant, disabled-button-only duplicate guard, caller deleted during modal, iterator invalidation, double commit, Boolean modal ownership, focus mutation during construction, hidden dialog reused as new, outer finally double cleanup, wrong-loop exit, deferred-delete lifetime assumption, stale post-modal input, sync-over-async wait, inactive mode starvation, or tracing-created deadlock | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `test_audit`, `docs_validate_fast`, `test_release`, `mustflow_check` | Modal-loop reentrancy boundary reviewed, outer stack/session/depth/owner/request/invariant/context/wait/exit/completion/commit/disable/capture/lifetime/deferred-delete/input-generation/platform/state/cancellation/capability/diagnostic evidence, fixes or recommendation, verification, and remaining reentrancy risk |
+| Desktop, mobile, embedded, or rich-client UI code owns thread-affine UI objects, native handles or peers, bound models, mutable toolkit resources, worker objects, or event loops, or posts work through Invoke, BeginInvoke, Dispatcher, SynchronizationContext, runLater, main queues, actors, progress reporters, bindings, timers, observables, or background-result callbacks | `.mustflow/skills/ui-dispatch-lifecycle-review/SKILL.md` | UI event-thread and per-instance owner identity, affinity creation and migration rules, native handle or peer creation point, object graph and bound-model ownership, pure-data transfer boundary, await continuation destination, event-loop availability, dispatch mode and priority, enqueue/start/apply/present stages, operation and view identities, attachment epoch, immutable payload, freshness and edit versions, cancellation ownership, close and deletion state, subscriptions and gates, shutdown order, wait graph, queue pressure, responsiveness traces, tests, and configured command intents | Explicit owner and handle-creation assertions, pure immutable worker payloads, owner-context resource creation and deletion, application-time generation guards, immutable snapshots, conditional UI reduction, edit-conflict policy, attachment epochs, owner-scoped cancellation, batched state transitions, coalesced progress, asynchronous close state machine, compare-by-owner cleanup, lifetime subscriptions, ordered shutdown, loop-liveness checks, queue and wait telemetry, controllable dispatcher, virtual clock, deterministic fixtures, and synchronized docs or templates | main-thread-as-UI-proof, type-level affinity assumption, lazy native handle creation on a worker, getter-as-passive-read, worker mutation of bound collections, mutable toolkit resource transfer, synchronization context as identity card, wrapper object assumed to live in its worker thread, deferred deletion on a stopped loop, dispatch-as-safety proof, same-queue synchronous dispatch, sync-over-async, missing terminal completion, circular bounded-queue backpressure, timer eligibility treated as execution time, post success treated as execution or lifetime proof, pre-enqueue-only liveness check, mutable closure capture, stale user-edit overwrite, canceled queued callback, reused handle generation, zombie subscriptions, shutdown tearing dependencies, low-CPU misdiagnosis, or repetition-count proof | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `test_audit`, `docs_validate_fast`, `test_release`, `mustflow_check` | UI dispatch and affinity lifecycle reviewed, event-thread/instance-owner/handle/object-graph/model/resource/continuation/loop/dispatch/operation/view/payload/freshness/cancellation/deletion/shutdown/wait/pressure/diagnostic evidence, fixes or recommendation, verification, and remaining UI-affinity risk |
 When introducing a new skill, link it here and define the specific trigger and route fields.
 Avoid including raw shell commands in skill documents; instead, reference the command intent
 names as defined in `.mustflow/config/commands.toml`.