mustflow 2.115.1 → 2.115.4

package/dist/cli/lib/local-index/constants.js

@@ -1,4 +1,4 @@
-export const LOCAL_INDEX_SCHEMA_VERSION = '20';
+export const LOCAL_INDEX_SCHEMA_VERSION = '21';
 export const LOCAL_INDEX_PARSER_VERSION = '1';
 export const DEFAULT_DATABASE_RELATIVE_PATH = '.mustflow/cache/mustflow.sqlite';
 export const LATEST_RUN_STATE_RELATIVE_PATH = '.mustflow/state/runs/latest.json';

package/dist/cli/lib/local-index/freshness.js

@@ -1,6 +1,6 @@
-import { LOCAL_INDEX_SCHEMA_VERSION } from './constants.js';
+import { DEFAULT_DATABASE_RELATIVE_PATH, LOCAL_INDEX_SCHEMA_VERSION } from './constants.js';
 import { hasTable, queryRows, readMetadataValue, toSearchString } from './database-read.js';
-import { normalizeIndexedFileSourceScope, readIndexedFileRecord } from './source-index.js';
+import { collectSourceAnchorCandidatePaths, getSourceScopeHash, normalizeIndexedFileSourceScope, readIndexedFileRecord, readLocalIndexSourceConfig, } from './source-index.js';
 import { collectDocuments } from './workflow-documents.js';
 export function readStoredSchemaVersion(database) {
     return readMetadataValue(database, 'schema_version');
@@ -11,46 +11,76 @@ export function getStalePaths(projectRoot, database, options = {}) {
     if (schemaVersion !== LOCAL_INDEX_SCHEMA_VERSION) {
         return ['.mustflow/cache/mustflow.sqlite'];
     }
-    if (hasTable(database, 'indexed_files')) {
-        const stalePaths = new Set();
-        const indexedRows = queryRows(database, 'SELECT path, source_scope, content_hash FROM indexed_files');
-        const indexedPaths = new Set(indexedRows.map((row) => toSearchString(row.path)));
-        for (const row of indexedRows) {
-            const indexedPath = toSearchString(row.path);
-            const sourceScope = normalizeIndexedFileSourceScope(toSearchString(row.source_scope));
-            if (!includeState && sourceScope === 'state') {
-                continue;
-            }
-            try {
-                const current = readIndexedFileRecord(projectRoot, indexedPath, sourceScope);
-                if (current.contentHash !== toSearchString(row.content_hash)) {
-                    stalePaths.add(indexedPath);
-                }
-            }
-            catch {
+    if (!hasTable(database, 'indexed_files') ||
+        !hasTable(database, 'indexed_source_candidates') ||
+        !hasTable(database, 'source_anchors') ||
+        !hasTable(database, 'source_anchor_status')) {
+        return [DEFAULT_DATABASE_RELATIVE_PATH];
+    }
+    const stalePaths = new Set();
+    const indexedRows = queryRows(database, 'SELECT path, source_scope, content_hash FROM indexed_files');
+    const indexedPaths = new Set(indexedRows.map((row) => toSearchString(row.path)));
+    const indexedSourcePaths = new Set(queryRows(database, 'SELECT path FROM indexed_source_candidates').map((row) => toSearchString(row.path)));
+    for (const sourcePath of indexedSourcePaths) {
+        if (!indexedPaths.has(sourcePath)) {
+            stalePaths.add(sourcePath);
+        }
+    }
+    for (const row of indexedRows) {
+        const indexedPath = toSearchString(row.path);
+        const sourceScope = normalizeIndexedFileSourceScope(toSearchString(row.source_scope));
+        if (!includeState && sourceScope === 'state') {
+            continue;
+        }
+        try {
+            const current = readIndexedFileRecord(projectRoot, indexedPath, sourceScope);
+            if (current.contentHash !== toSearchString(row.content_hash)) {
                 stalePaths.add(indexedPath);
             }
         }
-        for (const document of collectDocuments(projectRoot)) {
-            if (!indexedPaths.has(document.path)) {
-                stalePaths.add(document.path);
-            }
+        catch {
+            stalePaths.add(indexedPath);
         }
-        return Array.from(stalePaths).sort((left, right) => left.localeCompare(right));
     }
-    const indexedRows = queryRows(database, 'SELECT path, content_hash FROM documents');
-    const indexedHashes = new Map(indexedRows.map((row) => [toSearchString(row.path), toSearchString(row.content_hash)]));
-    const currentDocuments = collectDocuments(projectRoot);
-    const currentHashes = new Map(currentDocuments.map((document) => [document.path, document.contentHash]));
-    const stalePaths = new Set();
-    for (const [indexedPath, indexedHash] of indexedHashes) {
-        if (currentHashes.get(indexedPath) !== indexedHash) {
-            stalePaths.add(indexedPath);
+    for (const document of collectDocuments(projectRoot)) {
+        if (!indexedPaths.has(document.path)) {
+            stalePaths.add(document.path);
         }
     }
-    for (const currentPath of currentHashes.keys()) {
-        if (!indexedHashes.has(currentPath)) {
-            stalePaths.add(currentPath);
+    const sourceIndexEnabledValue = readMetadataValue(database, 'source_index_enabled');
+    if (sourceIndexEnabledValue !== 'true' && sourceIndexEnabledValue !== 'false') {
+        stalePaths.add(DEFAULT_DATABASE_RELATIVE_PATH);
+    }
+    else {
+        const sourceIndexEnabled = sourceIndexEnabledValue === 'true';
+        const hasIndexedSourceScope = indexedRows.some((row) => normalizeIndexedFileSourceScope(toSearchString(row.source_scope)) === 'source_anchor');
+        const hasSourceAnchorRows = hasTable(database, 'source_anchors') && queryRows(database, 'SELECT id FROM source_anchors LIMIT 1').length > 0;
+        if (!sourceIndexEnabled && (indexedSourcePaths.size > 0 || hasIndexedSourceScope || hasSourceAnchorRows)) {
+            stalePaths.add(DEFAULT_DATABASE_RELATIVE_PATH);
+        }
+        try {
+            const sourceConfig = readLocalIndexSourceConfig(projectRoot);
+            const storedSourceScopeHash = readMetadataValue(database, 'source_scope_hash');
+            const currentSourceScopeHash = getSourceScopeHash(sourceIndexEnabled, sourceConfig);
+            if (storedSourceScopeHash !== currentSourceScopeHash) {
+                stalePaths.add(DEFAULT_DATABASE_RELATIVE_PATH);
+            }
+            if (sourceIndexEnabled) {
+                const currentSourcePaths = new Set(collectSourceAnchorCandidatePaths(projectRoot, sourceConfig));
+                for (const sourcePath of currentSourcePaths) {
+                    if (!indexedSourcePaths.has(sourcePath)) {
+                        stalePaths.add(sourcePath);
+                    }
+                }
+                for (const sourcePath of indexedSourcePaths) {
+                    if (!currentSourcePaths.has(sourcePath)) {
+                        stalePaths.add(sourcePath);
+                    }
+                }
+            }
+        }
+        catch {
+            stalePaths.add(DEFAULT_DATABASE_RELATIVE_PATH);
         }
     }
     return Array.from(stalePaths).sort((left, right) => left.localeCompare(right));

package/dist/cli/lib/local-index/index.js

@@ -158,6 +158,14 @@ function indexedFilesMatch(database, currentFiles) {
     }
     return true;
 }
+function indexedSourceCandidatesMatch(database, currentPaths) {
+    if (!hasTable(database, 'indexed_source_candidates')) {
+        return false;
+    }
+    const storedPaths = new Set(queryRows(database, 'SELECT path FROM indexed_source_candidates').map((row) => toSearchString(row.path)));
+    const currentPathSet = new Set(currentPaths);
+    return storedPaths.size === currentPathSet.size && [...storedPaths].every((storedPath) => currentPathSet.has(storedPath));
+}
 const INDEXED_FILE_MTIME_TOLERANCE_MS = 1;
 function indexedFileMtimeMsEqual(storedMtimeMs, currentMtimeMs) {
     return storedMtimeMs !== null && Math.abs(storedMtimeMs - currentMtimeMs) <= INDEXED_FILE_MTIME_TOLERANCE_MS;
@@ -183,8 +191,8 @@ function indexedFileMetadataMatch(database, currentFiles) {
     }
     return true;
 }
-async function readIncrementalPreflightReuse(SQL, databasePath, projectRoot, currentFiles, sourceScopeHash, dryRun, indexMode) {
-    if (!currentFiles) {
+async function readIncrementalPreflightReuse(SQL, databasePath, projectRoot, currentFiles, currentSourceCandidatePaths, sourceScopeHash, dryRun, indexMode) {
+    if (!currentFiles || !currentSourceCandidatePaths) {
         return { result: null, rebuildReason: null };
     }
     if (!existsSync(databasePath)) {
@@ -205,6 +213,9 @@ async function readIncrementalPreflightReuse(SQL, databasePath, projectRoot, cur
         if (!hasTable(database, 'indexed_files')) {
             return { result: null, rebuildReason: 'indexed_files_missing' };
         }
+        if (!indexedSourceCandidatesMatch(database, currentSourceCandidatePaths)) {
+            return { result: null, rebuildReason: 'source_scope_mismatch' };
+        }
         if (!indexedFileMetadataMatch(database, currentFiles)) {
             return { result: null, rebuildReason: 'file_fingerprint_mismatch' };
         }
@@ -225,7 +236,7 @@ async function readIncrementalPreflightReuse(SQL, databasePath, projectRoot, cur
         database?.close();
     }
 }
-async function readIncrementalReuseDecision(SQL, databasePath, currentFiles, sourceScopeHash) {
+async function readIncrementalReuseDecision(SQL, databasePath, currentFiles, currentSourceCandidatePaths, sourceScopeHash) {
     if (!existsSync(databasePath)) {
         return { reusable: false, rebuildReason: 'missing_index', capabilities: null };
     }
@@ -244,6 +255,9 @@ async function readIncrementalReuseDecision(SQL, databasePath, currentFiles, sou
         if (!hasTable(database, 'indexed_files')) {
             return { reusable: false, rebuildReason: 'indexed_files_missing', capabilities: null };
         }
+        if (!indexedSourceCandidatesMatch(database, currentSourceCandidatePaths)) {
+            return { reusable: false, rebuildReason: 'source_scope_mismatch', capabilities: null };
+        }
         if (!indexedFilesMatch(database, currentFiles)) {
             return { reusable: false, rebuildReason: 'file_fingerprint_mismatch', capabilities: null };
         }
@@ -284,7 +298,7 @@ export async function createLocalIndex(projectRoot, options = {}) {
     capabilityDatabase.close();
     if (incremental) {
         const preflightFiles = collectFastPreflightIndexedFileMetadataRecords(projectRoot, includeSource, sourceConfig);
-        const preflightReuse = await readIncrementalPreflightReuse(SQL, databasePath, projectRoot, preflightFiles, sourceScopeHash, dryRun, indexMode);
+        const preflightReuse = await readIncrementalPreflightReuse(SQL, databasePath, projectRoot, preflightFiles?.records ?? null, preflightFiles?.sourceCandidatePaths ?? null, sourceScopeHash, dryRun, indexMode);
         if (preflightReuse.result) {
             return preflightReuse.result;
         }
@@ -307,16 +321,16 @@ export async function createLocalIndex(projectRoot, options = {}) {
     const verificationEvidence = createVerificationEvidenceIndex(projectRoot);
     const indexedFiles = collectIndexedFileRecords(projectRoot, documents, sourceAnchors, sourceAnchorCandidatePaths);
     if (incremental) {
-        const reuseDecision = await readIncrementalReuseDecision(SQL, databasePath, indexedFiles, sourceScopeHash);
+        const reuseDecision = await readIncrementalReuseDecision(SQL, databasePath, indexedFiles, sourceAnchorCandidatePaths, sourceScopeHash);
         reusedExisting = reuseDecision.reusable;
-        rebuildReason = reuseDecision.rebuildReason ?? rebuildReason;
+        rebuildReason = reuseDecision.reusable ? null : (reuseDecision.rebuildReason ?? rebuildReason);
         capabilities = reuseDecision.capabilities ?? capabilities;
     }
     if (!dryRun && !reusedExisting) {
         const database = new SQL.Database();
         try {
             createSchema(database, capabilities);
-            populateDatabase(database, capabilities, documents, skills, skillRoutes, commandIntents, sourceAnchors, indexedFiles, verificationEvidence, indexMode, sourceScopeHash, includeSource, new Date().toISOString());
+            populateDatabase(database, capabilities, documents, skills, skillRoutes, commandIntents, sourceAnchors, indexedFiles, sourceAnchorCandidatePaths, verificationEvidence, indexMode, sourceScopeHash, includeSource, new Date().toISOString());
             writeFileInsideWithoutSymlinks(projectRoot, databasePath, database.export());
         }
         finally {
@@ -702,10 +716,13 @@ export async function readLocalSourceAnchorCheckWarnings(projectRoot) {
         if (readMetadataValue(database, 'source_index_enabled') !== 'true') {
             return [];
         }
-        if (!hasTable(database, 'indexed_files') || !hasTable(database, 'source_anchors') || !hasTable(database, 'source_anchor_status')) {
+        if (!hasTable(database, 'indexed_files') ||
+            !hasTable(database, 'indexed_source_candidates') ||
+            !hasTable(database, 'source_anchors') ||
+            !hasTable(database, 'source_anchor_status')) {
             return ['source anchor local index is missing source-anchor tables; refresh with mf index --source'];
         }
-        const indexedSourcePaths = new Set(queryRows(database, 'SELECT path FROM indexed_files WHERE source_scope = "source_anchor"')
+        const indexedSourcePaths = new Set(queryRows(database, 'SELECT path FROM indexed_source_candidates')
             .map((row) => toSearchString(row.path))
             .filter(Boolean));
         const staleSourcePaths = getStalePaths(projectRoot, database, { includeState: false }).filter((stalePath) => indexedSourcePaths.has(stalePath));

package/dist/cli/lib/local-index/populate.js

@@ -172,7 +172,7 @@ function rollbackTransaction(database) {
         // Keep the original indexing failure as the actionable error.
     }
 }
-export function populateDatabase(database, capabilities, documents, skills, skillRoutes, commandIntents, sourceAnchors, indexedFiles, verificationEvidence, indexMode, sourceScopeHash, sourceIndexEnabled, indexedAt) {
+export function populateDatabase(database, capabilities, documents, skills, skillRoutes, commandIntents, sourceAnchors, indexedFiles, indexedSourceCandidates, verificationEvidence, indexMode, sourceScopeHash, sourceIndexEnabled, indexedAt) {
     const sourceAnchorRiskSignals = createSourceAnchorRiskSignals(sourceAnchors);
     database.run('BEGIN TRANSACTION');
     try {
@@ -223,6 +223,9 @@ export function populateDatabase(database, capabilities, documents, skills, skil
                 LOCAL_INDEX_PARSER_VERSION,
             ]);
         }
+        for (const sourceCandidatePath of indexedSourceCandidates) {
+            database.run('INSERT INTO indexed_source_candidates (path) VALUES (?)', [sourceCandidatePath]);
+        }
         for (const document of documents) {
             database.run('INSERT INTO documents (path, type, title, locale, revision, content_hash, content_snippet) VALUES (?, ?, ?, ?, ?, ?, ?)', [
                 document.path,

package/dist/cli/lib/local-index/schema.js

@@ -1,5 +1,10 @@
 import { SEARCH_BACKEND_FTS5 } from './constants.js';
 export function createSchema(database, capabilities) {
+    database.run('PRAGMA foreign_keys = ON');
+    const [foreignKeyResult] = database.exec('PRAGMA foreign_keys');
+    if (foreignKeyResult?.values[0]?.[0] !== 1) {
+        throw new Error('SQLite foreign-key enforcement is unavailable for the local index.');
+    }
     database.run(`
 CREATE TABLE metadata (
   key TEXT PRIMARY KEY,
@@ -17,6 +22,11 @@ CREATE TABLE indexed_files (
   parser_version TEXT NOT NULL
 );
 
+CREATE TABLE indexed_source_candidates (
+  path TEXT PRIMARY KEY,
+  FOREIGN KEY (path) REFERENCES indexed_files(path) ON UPDATE RESTRICT ON DELETE RESTRICT
+);
+
 CREATE TABLE documents (
   path TEXT PRIMARY KEY,
   type TEXT NOT NULL,

package/dist/cli/lib/local-index/source-index.js

@@ -1,11 +1,34 @@
-import { existsSync, readFileSync, statSync } from 'node:fs';
+import { existsSync, statSync } from 'node:fs';
 import path from 'node:path';
 import { isRecord, readStringArray } from '../command-contract.js';
+import { MUSTFLOW_TEXT_MAX_BYTES, mustflowProjectPath } from '../mustflow-read.js';
 import { readMustflowTomlFile } from '../toml.js';
+import { ensureInsideWithoutSymlinks, readFileInsideWithoutSymlinks } from '../../../core/safe-filesystem.js';
 import { listSourceAnchorFiles } from '../../../core/source-anchors.js';
 import { INDEX_CONFIG_RELATIVE_PATH, LATEST_RUN_STATE_RELATIVE_PATH, MUSTFLOW_RELATIVE_PATH, SOURCE_INDEX_MAX_FILE_BYTES, } from './constants.js';
 import { sha256Bytes, sha256Text } from './hashing.js';
 import { getExistingIndexablePaths } from './workflow-documents.js';
+function indexedProjectPath(projectRoot, relativePath) {
+    if (relativePath.length === 0 ||
+        relativePath.includes('\0') ||
+        relativePath.includes('\\') ||
+        path.posix.isAbsolute(relativePath) ||
+        path.win32.isAbsolute(relativePath)) {
+        throw new Error(`Indexed file path must be a canonical project-relative path: ${relativePath}`);
+    }
+    const segments = relativePath.split('/');
+    if (segments.some((segment) => segment.length === 0 || segment === '.' || segment === '..')) {
+        throw new Error(`Indexed file path must be a canonical project-relative path: ${relativePath}`);
+    }
+    const fullPath = mustflowProjectPath(projectRoot, relativePath);
+    ensureInsideWithoutSymlinks(projectRoot, fullPath);
+    return fullPath;
+}
+function readIndexedFileBytes(projectRoot, relativePath) {
+    return readFileInsideWithoutSymlinks(projectRoot, indexedProjectPath(projectRoot, relativePath), {
+        maxBytes: MUSTFLOW_TEXT_MAX_BYTES,
+    });
+}
 function readIndexToml(projectRoot) {
     const indexConfigPath = path.join(projectRoot, ...INDEX_CONFIG_RELATIVE_PATH.split('/'));
     if (!existsSync(indexConfigPath)) {
@@ -69,13 +92,13 @@ export function readIndexedFileRecord(projectRoot, relativePath, sourceScope, co
     const metadata = readIndexedFileMetadataRecord(projectRoot, relativePath, sourceScope);
     return {
         ...metadata,
-        contentHash: contentHash ?? sha256Bytes(readFileSync(path.join(projectRoot, ...relativePath.split('/')))),
+        contentHash: contentHash ?? sha256Bytes(readIndexedFileBytes(projectRoot, relativePath)),
     };
 }
 function hashIndexedFileMetadataRecord(projectRoot, metadata) {
     return {
         ...metadata,
-        contentHash: sha256Bytes(readFileSync(path.join(projectRoot, ...metadata.path.split('/')))),
+        contentHash: sha256Bytes(readIndexedFileBytes(projectRoot, metadata.path)),
     };
 }
 function tryHashIndexedFileMetadataRecord(projectRoot, metadata) {
@@ -92,8 +115,11 @@ export function hashIndexedFileMetadataRecords(projectRoot, metadataRecords) {
         .filter((record) => Boolean(record));
 }
 export function readIndexedFileMetadataRecord(projectRoot, relativePath, sourceScope) {
-    const fullPath = path.join(projectRoot, ...relativePath.split('/'));
+    const fullPath = indexedProjectPath(projectRoot, relativePath);
     const stats = statSync(fullPath);
+    if (!stats.isFile()) {
+        throw new Error(`Indexed path must be a regular file: ${relativePath}`);
+    }
     return {
         path: relativePath,
         sourceScope,
@@ -117,10 +143,7 @@ export function collectIndexedFileRecords(projectRoot, documents, sourceAnchors,
     const sourcePaths = new Set([...sourceAnchorCandidatePaths, ...sourceAnchors.map((anchor) => anchor.path)]);
     for (const anchorPath of [...sourcePaths].sort((left, right) => left.localeCompare(right))) {
         if (!records.has(anchorPath)) {
-            const record = tryReadIndexedFileRecord(projectRoot, anchorPath, 'source_anchor');
-            if (record) {
-                records.set(anchorPath, record);
-            }
+            records.set(anchorPath, readIndexedFileRecord(projectRoot, anchorPath, 'source_anchor'));
         }
     }
     if (existsSync(path.join(projectRoot, ...LATEST_RUN_STATE_RELATIVE_PATH.split('/')))) {
@@ -132,19 +155,25 @@ export function collectIndexedFileRecords(projectRoot, documents, sourceAnchors,
     return [...records.values()].sort((left, right) => left.path.localeCompare(right.path));
 }
 export function collectSourceAnchorCandidatePaths(projectRoot, sourceConfig) {
-    return listSourceAnchorFiles(projectRoot, {
+    const paths = listSourceAnchorFiles(projectRoot, {
         ...sourceConfig,
         excludeGeneratedOrVendor: true,
     });
+    for (const relativePath of paths) {
+        indexedProjectPath(projectRoot, relativePath);
+    }
+    return paths;
 }
 export function collectFastPreflightIndexedFileMetadataRecords(projectRoot, includeSource, sourceConfig) {
     const records = new Map();
+    let sourceCandidatePaths = [];
     for (const relativePath of getExistingIndexablePaths(projectRoot)) {
         records.set(relativePath, readIndexedFileMetadataRecord(projectRoot, relativePath, 'workflow'));
     }
     if (includeSource) {
         try {
-            for (const sourcePath of collectSourceAnchorCandidatePaths(projectRoot, sourceConfig)) {
+            sourceCandidatePaths = collectSourceAnchorCandidatePaths(projectRoot, sourceConfig);
+            for (const sourcePath of sourceCandidatePaths) {
                 if (!records.has(sourcePath)) {
                     records.set(sourcePath, readIndexedFileMetadataRecord(projectRoot, sourcePath, 'source_anchor'));
                 }
@@ -157,5 +186,8 @@ export function collectFastPreflightIndexedFileMetadataRecords(projectRoot, incl
     if (existsSync(path.join(projectRoot, ...LATEST_RUN_STATE_RELATIVE_PATH.split('/')))) {
         records.set(LATEST_RUN_STATE_RELATIVE_PATH, readIndexedFileMetadataRecord(projectRoot, LATEST_RUN_STATE_RELATIVE_PATH, 'state'));
     }
-    return [...records.values()].sort((left, right) => left.path.localeCompare(right.path));
+    return {
+        records: [...records.values()].sort((left, right) => left.path.localeCompare(right.path)),
+        sourceCandidatePaths,
+    };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mustflow",
-  "version": "2.115.1",
+  "version": "2.115.4",
   "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 = 226
+revision = 228
 translations = {}
 
 [documents."skill.adapter-boundary"]
@@ -146,7 +146,7 @@ translations = {}
 [documents."skill.module-boundary-review"]
 source = "locales/en/.mustflow/skills/module-boundary-review/SKILL.md"
 source_locale = "en"
-revision = 3
+revision = 5
 translations = {}
 
 [documents."skill.change-blast-radius-review"]
@@ -589,7 +589,7 @@ translations = {}
 [documents."skill.dependency-reality-check"]
 source = "locales/en/.mustflow/skills/dependency-reality-check/SKILL.md"
 source_locale = "en"
-revision = 7
+revision = 9
 translations = {}
 
 [documents."skill.dependency-upgrade-review"]

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

@@ -2,7 +2,7 @@
 mustflow_doc: skills.index
 locale: en
 canonical: true
-revision: 226
+revision: 228
 authority: router
 lifecycle: mustflow-owned
 ---
@@ -547,7 +547,7 @@ routes. Event routes stay inactive until their event occurs.
 | Browser automation, UI automation, Playwright, Selenium, Puppeteer, WebDriver, computer-use or browser-driving agents, visual browser verification, flaky selectors, page readiness, authentication state, CAPTCHA or anti-bot handling, rate limits, screenshot checks, retry, timeout, human approval, or browser automation observability is created, changed, reviewed, triaged, or reported | `.mustflow/skills/browser-automation-reliability-review/SKILL.md` | Automation intent ledger, state ledger, readiness ledger, selector and action ledger, auth and identity ledger, external pressure ledger, verification ledger, agent and approval ledger, changed files, and command contract entries | Browser automation state machines, locator contracts, test IDs, accessible names, readiness assertions, frame and popup handlers, input verification, auth fixtures, per-worker account isolation, retry classification, timeout hierarchy, idempotency checks, rate-limit handling, approval gates, manual fallback states, traces, screenshots, redaction, cleanup, tests, docs, route metadata, and directly synchronized templates | sleep-as-readiness, `networkidle` faith, flaky selector string patch, hidden duplicate DOM, skeleton-as-content, stale element handle, force-click default, shared mutable account, CAPTCHA bypass, anti-bot evasion, retry storm, non-idempotent replay, timeout layer mismatch, screenshot-as-business-proof, unredacted trace data, page prompt injection, stale approval resume, coordinate click drift, or unverified browser success claim | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `docs_validate_fast`, `test_release`, `mustflow_check` | Browser automation surface reviewed, browser-versus-API boundary, automation owner, state/readiness/locator/actionability/auth/rate-limit/retry/timeout/idempotency decisions, screenshot and business-success evidence, agent page-content trust, approval and resume checks, verification, and remaining browser automation reliability risk |
 | Agent evaluation loops, trace or trajectory grading, LLM judges, verifier agents, outcome scoring, tool-call prechecks or postchecks, eval datasets, golden or dirty sets, pass@k or pass^k metrics, shadow environments, production-monitoring-to-eval pipelines, or agent regression gates are created, changed, reviewed, or reported | `.mustflow/skills/agent-eval-integrity-review/SKILL.md` | Outcome ledger, trace ledger, oracle ledger, tool-boundary ledger, dataset ledger, metric ledger, environment ledger, monitoring ledger, privacy ledger, changed files, and command contract entries | Outcome oracles, trace schemas, trajectory graders, deterministic checkers, model-judge rubrics, human-review sampling, tool prechecks and postchecks, tool-result evidence packets, eval fixtures, golden and dirty sets, shadow-environment adapters, monitoring-to-eval candidate flows, tests, docs, route metadata, and directly synchronized templates | final-answer-only scoring, LLM judge as sole oracle, reasoning claim treated as evidence, self-reflection certifying success, missing final environment state, ungraded unsafe trajectory, missing tool precheck or postcheck, brittle exact tool-order assertion, uncalibrated judge drift, pass@k masking unreliable pass^k, dirty set gating flakiness, raw trace data leak, or production failure not entering evals | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `docs_validate_fast`, `test_release`, `mustflow_check` | Agent eval-integrity surface reviewed, outcome oracle, final-state and trajectory checks, deterministic/model/human oracle split, tool boundary evidence, golden/dirty/capability/regression metrics, shadow environment, monitoring-to-eval loop, trace privacy, verification, and remaining agent eval-integrity risk |
 | Code review or implementation needs abstraction-boundary triage for deciding whether a helper, interface, adapter, service, policy object, strategy, mapper, DTO, base class, component, or shared module should exist, stay duplicated, be inlined, move side effects out of the core path, preserve layer import contracts, or delete generated boilerplate after refactoring | `.mustflow/skills/abstraction-boundary-review/SKILL.md` | User goal, current diff or target files, change-reason ledger, future-change scenarios, domain vocabulary, ownership map, candidate boundary ledger, public-promise ledger, side-effect ledger, test-shape ledger, layer-contract ledger, layer-integrity ledger, type-existence ledger, public-contract ledger, existing helpers or patterns, and configured command intents | Local abstractions, deliberate duplication, policy owners, adapters, mappers, result or variant types, side-effect shells, capability-named ports, interface narrowing, pass-through layer removal, import-direction repair, DTO or ORM boundary repair, exception translation, transaction-owner clarification, boilerplate deletion, behavior-focused tests, route metadata, and directly synchronized docs or templates | visual-duplication DRY, different domain meanings merged, one-caller interface theater, vague Service, Manager, Helper, Util, Common, Base, or Abstract names, future-only interfaces, fake DDD for CRUD, mode flag helper, excessive DTO conversion, provider error erasure, DI or config larger than logic, hidden proxy or event-bus work, scattered business rule, external SDK or DB row leakage, full-server policy tests, raw payloads deep in app code, provider errors leaking outward, hardcoded policy values, dependency direction inversion, domain importing infrastructure, application importing concrete infrastructure, presentation calling repositories or gateways directly, public contract drift, transaction owner drift, or mocks on private choreography | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `test_audit`, `docs_validate_fast`, `test_release`, `mustflow_check` | Abstraction boundary reviewed, change reason and future scenarios, same-concept gate, candidates compared, public promise and owners, layer dependency contract, layer-integrity report, type-existence and deletion-pass result, over- and under-abstraction findings, test shape, verification, and remaining reversibility risk |
-| Code review or implementation needs module-boundary triage for change spread, change axes, stability direction, co-change clusters, data ownership, policy ownership, failure ownership, import direction, circular dependencies, DTO leakage, shared/common/utils growth, mock-heavy tests, repeated policy conditions, enum interpretation, repository business logic, anemic domain, domain-to-I/O leakage, transaction boundary mismatch, technical event names, public module API bloat, caller sequencing, premature common helpers, bug/fix distance, config ownership, log responsibility, exception translation, cache invalidation ownership, repeated authorization checks, frontend/backend policy leakage, time policy, batch or worker bypass, shallow modules, or temporary-code accumulation | `.mustflow/skills/module-boundary-review/SKILL.md` | Change reason, change-axis ledger, changed-file spread, co-change evidence, module graph evidence, stability evidence, change-simulation evidence, ownership evidence, test evidence, and configured command intents | Policy ownership, DTO boundaries, mapper boundaries, module public APIs, import direction, config injection, exception translation, cache invalidation ownership, authorization checks, event facts, worker entrypoints, stability-direction repair, shallow-wrapper removal, focused tests, and directly synchronized docs or templates | layer-name theater, role-sliced files that always change together, technical layer split mistaken for change unit, lower-level modules knowing high-level policy, stable policy importing volatile provider details, circular dependency, DTO infection, ownerless shared helper, broad noun module, thin forwarding files, public API wider than hidden behavior, mock-heavy rule tests, copied policy condition, enum rule scatter, repository-owned business rule, service-only domain, domain I/O coupling, cross-owner transaction, table-change event, exposed internals, caller order dependency, unsafe reuse, repeated temporary branch, bug/fix distance, config chaos, misleading logs, leaked provider or DB errors, stale cache owner drift, copied auth checks, frontend reconstructing backend policy, inconsistent time rules, worker bypass, or random capability loss when a module is removed | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `docs_validate_fast`, `test_release`, `mustflow_check` | Module boundary reviewed, change-spread and co-change evidence, change simulations, stability direction, owner and import findings, shallow module findings, boundary fixes or recommendation, evidence level, verification, and remaining module-boundary risk |
+| Code review or implementation needs module-boundary triage for change spread, change axes, stability direction, co-change clusters, monorepo package direction, package roles, workspace tags, TypeScript path alias boundaries, compile-success versus allowed-dependency confusion, data ownership, policy ownership, failure ownership, import direction, cross-package deep imports, package exports, circular dependencies, DTO leakage, shared/common/utils growth, mock-heavy tests, repeated policy conditions, enum interpretation, repository business logic, anemic domain, domain-to-I/O leakage, transaction boundary mismatch, technical event names, public module API bloat, caller sequencing, premature common helpers, bug/fix distance, config ownership, log responsibility, exception translation, cache invalidation ownership, repeated authorization checks, frontend/backend policy leakage, time policy, batch or worker bypass, shallow modules, or temporary-code accumulation | `.mustflow/skills/module-boundary-review/SKILL.md` | Change reason, change-axis ledger, changed-file spread, co-change evidence, module and package graph evidence, package role and platform tags, `tsconfig.paths`, bundler and test resolver aliases, affected build/test graph evidence, deploy or prune artifact expectations, stability evidence, change-simulation evidence, ownership evidence, test evidence, and configured command intents | Policy ownership, DTO boundaries, mapper boundaries, module public APIs, package `exports`, import direction, workspace dependency direction, package tag constraints, path-alias reach-through repair, config injection, exception translation, cache invalidation ownership, authorization checks, event facts, worker entrypoints, stability-direction repair, shallow-wrapper removal, focused tests, and directly synchronized docs or templates | layer-name theater, role-sliced files that always change together, technical layer split mistaken for change unit, TypeScript path alias mistaken for an architecture boundary, compiling import treated as an authorized dependency, relative sibling package reach-through, app package imported by reusable code, stable package importing volatile app, route, database, provider, or UI details, feature-to-feature internal import, UI kit knowing business state, package deep import, broad export map, root barrel cycle, circular dependency, DTO infection, ownerless shared helper, broad `types` bucket, broad noun module, thin forwarding files, public API wider than hidden behavior, mock-heavy rule tests, copied policy condition, enum rule scatter, repository-owned business rule, service-only domain, domain I/O coupling, cross-owner transaction, table-change event, exposed internals, caller order dependency, unsafe reuse, repeated temporary branch, bug/fix distance, config chaos, misleading logs, leaked provider or DB errors, stale cache owner drift, copied auth checks, frontend reconstructing backend policy, inconsistent time rules, worker bypass, or random capability loss when a module is removed | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `docs_validate_fast`, `test_release`, `mustflow_check` | Module boundary reviewed, change-spread and co-change evidence, monorepo package graph evidence, resolver graph evidence, change simulations, stability direction, owner and import findings, shallow module findings, boundary fixes or recommendation, evidence level, verification, and remaining module-boundary risk |
 | Code review or implementation needs change-blast-radius triage for maintainability risk from unpredictable next-change spread, historical co-change spread, one change reason scattered across files, multiple change reasons in one file, controller workflow leakage, junk-drawer service names, boolean mode flags, trash-can option objects, scattered domain rules, scattered authorization, hidden state transitions, direct time or randomness, unclear transaction boundaries, external API and DB coupling, retry without idempotency, cache-as-truth decisions, config flag combinations, tenant or partner hardcoding, legacy branches in the core path, DTO/entity/view model mixing, ambiguous nullable values, swallowed exceptions, low-context logs, implementation-coupled tests, mock-heavy tests, decorative abstractions, premature DRY, hidden ordering dependency, invisible event contracts, migration/runtime compatibility, or hard-to-delete features | `.mustflow/skills/change-blast-radius-review/SKILL.md` | User goal, current diff or target files, change-reason ledger, historical co-change ledger, blast-radius ledger, ownership ledger, deleteability ledger, test and operations evidence, and configured command intents | Policy ownership, workflow boundaries, explicit modes, option-object narrowing, authorization owner, state-transition owner, transaction and retry/idempotency boundaries, cache truth boundary, config and tenant variation isolation, legacy adapters, DTO mapping ownership, result types, traceable logs, behavior-focused tests, event contracts, migration compatibility notes, and directly synchronized docs or templates | clean-code theater, unpredictable edit spread, repeated cross-repo co-change, unrelated reasons in one file, controller as boss, junk-drawer service, boolean maze, option combinatorics, copied policy, copied auth, scattered status writes, hidden time or random, partial data after failure, duplicate side effect, stale cache authority, untested flag product, hardcoded customer branch, legacy core pollution, object-language mixing, nullable ambiguity, false success, useless logs, brittle process tests, five-mock class, decorative interface, wrong DRY, order-sensitive line shuffle, ghost event coupling, deploy gamble, or feature that cannot be deleted cleanly | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `test_audit`, `docs_validate_fast`, `test_release`, `mustflow_check` | Change blast radius reviewed, next likely change and owner, historical co-change evidence, spread and deletion path, maintainability findings, fixes or recommendation, verification, and remaining change-spread risk |
 | Code review or implementation needs business-rule-leakage triage for money, permission, ownership, state, settlement, discount, coupon, refund, inventory, notification, subscription, visibility, eligibility, expiry, price, tax, fee, points, reports, tenant scope, UI-only guards, controller eligibility checks, direct status assignment, query predicates as policy, list/detail scope mismatch, admin path bypass, batch hidden policy, tests at the wrong layer, duplicated business constants, date or timezone policy drift, ambiguous `isActive` or `canUse`, authentication/authorization/eligibility mixing, ownership boundary drift, broad update DTOs, PATCH null semantics, mapper logic, default-value drift, misleading error messages, swallowed business failures, transaction/action mismatch, event timing, duplicate requests, webhook trust, out-of-order events, cache-as-rule, search index drift, report or settlement SQL, public text drift, or other bypass entrances | `.mustflow/skills/business-rule-leakage-review/SKILL.md` | User goal, current diff or target files, rule ledger, entrypoint ledger, enforcement ledger, consistency ledger, state/transaction/event/idempotency/default/error evidence, and configured command intents | Shared policy/domain/application/database rule owner, server-side enforcement, reusable query scopes, list/detail consistency, update field restrictions, PATCH intent models, mechanical mappers, default ownership, visible failures, transaction and event boundaries, idempotency, webhook verification, search/detail rechecks, report calculation owners, focused tests, and directly synchronized docs or templates | clean code with leaked money rule, client-only rule, controller judge, scattered status assignment, missing query predicate, URL detail bypass, admin bypass, batch bypass, misplaced test, magic policy number, timezone cutoff drift, vague helper meaning, auth/eligibility blur, user-vs-tenant ownership hole, mass update, PATCH null corruption, mapper policy, default mismatch, error-text lie, false success, half-committed business action, pre-commit event, duplicate refund or coupon use, trusted webhook, stale event transition, wrong cache viewer, dead search result, settlement query drift, support macro drift, or uninspected entrypoint | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `test_audit`, `docs_validate_fast`, `test_release`, `mustflow_check` | Business rule leakage reviewed, source of truth and entrypoints, enforcement and bypass findings, consistency notes, fixes or recommendation, verification, and remaining rule-leakage risk |
 | Payment, checkout, authorization, capture, refund, partial refund, subscription, invoice, credit note, receipt, tax document, trial, grace period, coupon, promotion, inventory reservation, fulfillment, entitlement, settlement, fee, payout, chargeback, dispute, fraud review, card testing, provider webhook, payment session, payment link, payment-provider integration, admin manual payment change, payment log, PCI-sensitive data handling, or payment-related test needs payment-integrity triage for duplicate, late, out-of-order, wrong-actor, wrong-amount, wrong-currency, timeout, retry, idempotency, ledger, reconciliation, or audit risk | `.mustflow/skills/payment-integrity-review/SKILL.md` | User goal, current diff or target files, money-event ledger, provider interaction ledger, state-transition ledger, idempotency and uniqueness ledger, amount and currency ledger, invoice/receipt/tax ledger, dispute and fraud ledger, ownership ledger, fulfillment and entitlement ledger, webhook and retry ledger, audit and sensitive-data ledger, existing tests, and configured command intents | Payment state machines, server-side amount calculation, invoice and line-item snapshots, minor-unit money handling, tax snapshots and reversals, receipt delivery tracking, object ownership checks, idempotency keys, provider ID uniqueness, webhook raw-body signature verification, webhook event dedupe, queue handoff, one-time fulfillment, async payment handling, authorization/capture distinctions, refund/dispute/subscription transitions, inventory and coupon reservation, timeout and retry classification, payout reconciliation, append-only ledgers, secret and payment-data redaction, fraud and card-testing defenses, admin audit trails, stale payment endpoint cleanup notes, focused nightmare-path tests, and directly synchronized docs or templates | paid-boolean shortcut, client-trusted amount, wrong-owner order/payment/refund/subscription ID, amount drift, float money math, missing idempotency, per-retry UUID idempotency, missing provider uniqueness, duplicate webhook, out-of-order webhook, JSON-parsed webhook signature breakage, disabled webhook signature, success-page-as-proof, double fulfillment, async payment premature fulfillment, authorized-treated-as-captured, double refund, missing refund-dispute collision policy, missing tax reversal, receipt delivery gap, chargeback evidence gap, subscription period-only active check, inventory oversell, coupon double spend or lost coupon, timeout-treated-as-failure, blind retry, mutable ledger, payout-as-revenue confusion, card testing exposure, card data logging, test/live secret mix, unaudited admin override, stale payment API, or happy-path-only payment tests | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `test_audit`, `docs_validate_fast`, `test_release`, `mustflow_check` | Payment integrity reviewed, money-event/provider/state/idempotency/amount/invoice/receipt/tax/ownership/fulfillment/webhook/dispute/fraud/payout/audit map, findings, fixes or recommendation, nightmare-path evidence, verification, and remaining payment-integrity risk |
@@ -671,7 +671,7 @@ routes. Event routes stay inactive until their event occurs.
 | Keyword search, full-text search, Elasticsearch, OpenSearch, Lucene-style indexing, search APIs, indexing pipelines, source maps, metadata taxonomy, negative metadata, exact keyword fields, aliases, bulk indexing, refresh visibility, analyzers, mappings, synonyms, autocomplete, pagination, shard failures, search quality, or search performance are created, changed, reviewed, or failing | `.mustflow/skills/search-index-integrity-review/SKILL.md` | Symptom classification, source-to-search ledger, query contract ledger, index contract ledger with taxonomy/source-map fields, metadata key budget, stable source/doc/chunk ids, lifecycle and effective-date fields, quality ledger, performance ledger, privacy ledger, changed files, and command contract entries | Search canaries, indexing ledgers, bulk item error handling, alias checks, mapping and analyzer fixtures, metadata taxonomy checks, frontmatter schema checks, controlled-vocabulary fixtures, exact-keyword fixtures, negative-metadata filters, filter-only versus LLM-visible metadata checks, exact-versus-full-text tests, tenant and permission filters, golden-set tests, synonym regression tests, pagination guards, query and miss-log metrics, docs, and directly synchronized templates | cluster-green theater, batch-level bulk success, source/index count illusion, write alias drift, partial shard result, direct/API/UI mismatch, wrong keyword/text field, analyzer drift, uncontrolled tag vocabulary, unbounded metadata keys, file path treated as status, synonym regression, negative metadata ignored, missing source map, stale index hash, rank eyeballing, profile misuse, query fingerprint leak, shard fan-out, cache-only benchmark, refresh overuse, segment merge backlog, disk watermark write block, deep pagination, oversized fetch, or private query/document leak | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `docs_validate_fast`, `test_release`, `mustflow_check` | Search index integrity reviewed, source-to-search/query/index/quality/performance/privacy ledgers, taxonomy/metadata-budget/exact-keyword/source-map/query-log findings, fix or recommendation, evidence level, verification, and remaining search-index risk |
 | Vector search, semantic search, RAG retrieval, embedding generation, preprocessing, chunking, contextual headers, synthetic questions, chunk text variants, vector schema, collection, namespace, tenant, named vector, metadata payload, filter, ANN index, exact-versus-approximate search, hybrid search, reranking, recall, latency, quantization, HNSW, IVF, pgvector, Qdrant, Milvus, Weaviate, OpenSearch kNN, or retrieval golden-set behavior is created, changed, reviewed, or failing | `.mustflow/skills/vector-search-integrity-review/SKILL.md` | Retrieval symptom, query contract ledger, ingestion ledger with stable source/doc/chunk ids, parent document genealogy, text variants and hashes, quality ledger, performance ledger, privacy ledger, changed files, and command contract entries | Embedding, preprocessing, and chunker versioning, vector validation, deterministic ids, contextual retrieval headers, synthetic question fields, original/index/prompt/embedding text separation, namespace and tenant selection, metadata payload field typing, metadata indexes, ACL prefilters, filter construction, exact-search checks, ANN parameters, lexical safeguards for exact identifiers, hybrid score ledgers, RRF or MMR settings, reranker candidates, golden-set tests, synthetic fixtures, metrics, docs, and directly synchronized templates | vector-DB scapegoating, wrong embedding dimension, model revision drift, contextual retrieval text treated as source, synthetic question cited as evidence, unstable source/doc/chunk lineage, tiny chunk subject loss, huge chunk semantic averaging, overlap top-k duplication, filter post-candidate loss, metadata type drift, ACL applied after retrieval, tenant leak, duplicate chunk ids, stale deletes, content hash or embedding hash drift, metric or normalization mismatch, ANN tuning before exact-search proof, quantization recall loss, reranker candidate starvation, hybrid score misuse, exact identifiers smoothed into embedding-only text, deep ANN pagination, raw vector or document leak, or unmeasured p95 latency | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `docs_validate_fast`, `test_release`, `mustflow_check` | Vector search integrity reviewed, retrieval/query/ingestion/quality/performance/privacy ledgers, exact-versus-ANN/filter/text-variant/contextual-header/lineage/hybrid/rerank findings, fix or recommendation, evidence level, verification, and remaining vector-search risk |
 | Dependency versions, lockfiles, package-manager metadata, workspace constraints, runtime engines, peer dependencies, optional dependencies, security advisory fixes, vulnerability scanner alerts, generated dependency output, framework plugins, dev servers, test runners, TypeScript compiler tracks, CI actions, Docker base images, package manager behavior, or toolchain versions are upgraded, downgraded, pinned, widened, regenerated, reviewed, or reported | `.mustflow/skills/dependency-upgrade-review/SKILL.md` | Dependency name, old and new versions or ranges, direct or transitive path, ecosystem and package manager, declaration files, lockfiles, runtime or toolchain files, advisory or release-note evidence, exploit preconditions, generated outputs, callers, docs, package output, Docker, CI, dev-server or test-UI exposure, protocol role, or TypeScript compiler-track surfaces, and command contract entries | Package declarations, lockfiles, generated outputs, compatibility code, tests, docs, package metadata, Docker or CI files, dev-server/test-runner config notes, TypeScript compiler-track notes, and directly synchronized examples | lockfile churn, hidden transitive replacement, peer or engine break, module-format drift, native or optional package break, framework or generator output drift, devDependency advisory dismissed despite exposure, unsafe broad security update, weakened tests, Docker or CI runtime drift, protocol DoS misclassified, TS7 RC over-adoption, TS7 nightly over-adoption, or unreviewed supply-chain change | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `docs_validate_fast`, `test_release`, `mustflow_check` | Upgrade reason, ecosystem surface, direct and transitive graph changes, compatibility classification, runtime/peer/engine/module/feature/platform/generated-output/compiler-track risks, advisory exploit preconditions, synchronized surfaces, verification, and remaining dependency-upgrade risk |
-| Dependency, package, runtime, framework, tool, command, plugin, service, platform capability, supported-version policy, security patch path, ecosystem maturity claim, maintainer-risk assumption, runtime portability claim, edge or serverless compatibility claim, critical-path library choice, package script, lifecycle hook, binary download, lockfile, audit result, or supply-chain-sensitive dependency surface is assumed, added, removed, imported, invoked, installed, audited, or documented | `.mustflow/skills/dependency-reality-check/SKILL.md` | Assumed dependency or capability, declaration files, version or feature expectation, role criticality, supported-version or end-of-life evidence, patchability expectation, runtime compatibility boundary, maintainer and ecosystem evidence when available, lockfile entry, package script or lifecycle hook, audit or provenance evidence, and relevant command intents | Package metadata, lockfiles, imports, scripts, command contracts, docs, tests, runtime policy notes, portability notes, and reports | unavailable dependency, hallucinated or lookalike package, fragile single-maintainer core dependency, experimental technology in a survival path, unsupported runtime, unclear security patch path, runtime-specific API leakage into core logic, stale version claim, lifecycle script risk, audit suppression, lockfile drift, or install guidance mismatch | `changes_status`, `changes_diff_summary`, `build`, `test_release`, `mustflow_check` | Dependency checked, ecosystem and maintainer-risk boundary reviewed, supported-version, patchability, and runtime-portability boundary reviewed, supply-chain surface reviewed, declarations synchronized, verification, and remaining dependency risk |
+| Dependency, package, workspace package contract, `package.json` dependency role, runtime, framework, tool, command, plugin, service, platform capability, package `exports`, package `imports`, public type dependency, peer host contract, optional integration, workspace protocol range, TypeScript path alias, build graph edge, test graph edge, deploy or prune package edge, release graph edge, supported-version policy, security patch path, ecosystem maturity claim, maintainer-risk assumption, runtime portability claim, edge or serverless compatibility claim, critical-path library choice, package script, lifecycle hook, binary download, lockfile, audit result, or supply-chain-sensitive dependency surface is assumed, added, removed, imported, invoked, installed, audited, or documented | `.mustflow/skills/dependency-reality-check/SKILL.md` | Assumed dependency or capability, package role, declaration files, emitted JS imports, public declaration files, `dependencies`/`devDependencies`/`peerDependencies`/optional metadata, workspace ranges, package `exports` and `imports`, `tsconfig.paths`, bundler and test resolver aliases, package manager graph, affected build/test graph evidence, deploy or prune artifact expectations, release graph evidence, version or feature expectation, role criticality, supported-version or end-of-life evidence, patchability expectation, runtime compatibility boundary, maintainer and ecosystem evidence when available, lockfile entry, package script or lifecycle hook, audit or provenance evidence, and relevant command intents | Package metadata, lockfiles, imports, scripts, command contracts, docs, tests, package entrypoints, public declaration files, boundary lint rules, task graph inputs, deploy or prune smoke surfaces, release graph notes, runtime policy notes, portability notes, and reports | unavailable dependency, hallucinated or lookalike package, TypeScript path alias hiding a missing package dependency, source alias bypassing package `exports`, package manager graph mismatch, affected build or test cache false green, pruned or deployed artifact missing a dependency, root-hoisted undeclared dependency, transitive dependency use, runtime import hidden in `devDependencies`, public type dependency hidden from consumers, host singleton installed as a direct dependency, peer missing local dev dependency, optional integration dragging unused hosts, broad package export, workspace range too tight for publish policy, fragile single-maintainer core dependency, experimental technology in a survival path, unsupported runtime, unclear security patch path, runtime-specific API leakage into core logic, stale version claim, lifecycle script risk, audit suppression, lockfile drift, or install guidance mismatch | `changes_status`, `changes_diff_summary`, `build`, `test_release`, `mustflow_check` | Dependency checked, package contract and public API boundary reviewed, resolver/build/test/deploy/release graph alignment reviewed, ecosystem and maintainer-risk boundary reviewed, supported-version, patchability, and runtime-portability boundary reviewed, supply-chain surface reviewed, declarations synchronized, verification, and remaining dependency risk |
 | Generated or edited code, configuration, CI workflows, package metadata, install instructions, examples, Docker images, framework setup, runtime declarations, toolchain declarations, TypeScript compiler-track references, Go release or framework references, Java/JDK GA, LTS, JEP, JVM, GC, or toolchain references, Rust release or MSRV references, or migration-sensitive snippets introduce explicit external version references, action refs, package ranges, runtime versions, framework majors, Docker image tags, or scaffold commands that may be stale | `.mustflow/skills/version-freshness-check/SKILL.md` | Versioned reference, owning files, repository version policy, approved freshness source, compatibility context, migration risk, TypeScript compiler track, Go toolchain/framework track, Java JDK/toolchain/bytecode/JEP track, or Rust MSRV/toolchain track when relevant, and command contract entries | Package metadata, lockfiles, CI workflows, Dockerfiles, runtime files, framework config, docs, examples, templates, tests, and version-decision reports | stale default version, false latest claim, accidental major migration, repository policy mismatch, unsupported generated example, TypeScript RC/nightly/API-track confusion, Java latest-GA/LTS/runtime/JEP/preview/incubator confusion, Rust stable/nightly/MSRV confusion, floating-tag drift, or unverified security/support claim | `changes_status`, `changes_diff_summary`, `build`, `test_related`, `docs_validate_fast`, `test_release`, `mustflow_check` | Versioned surfaces checked, repository policy and freshness source, selected version track, compatibility classification, TypeScript stable/RC/nightly/API-track, Go runtime/framework, Java GA/LTS/runtime/JEP/toolchain, and Rust stable/nightly/MSRV split when relevant, approval need, synchronized surfaces, verification, and remaining version-freshness risk |
 | External systems, protocols, SDKs, databases, webhooks, queues, files, object storage, signed upload or download URLs, caches, API response models, framework requests or responses, server actions, route handlers, edge functions, worker handlers, AI models, browser storage, search engines, analytics tools, email platforms, no-code tools, observability backends, trace or request context, provider data, or volatile component implementations cross the core boundary or need stable port/adapter translation, change isolation, error mapping, timeout, retry, circuit-breaker, bulkhead, idempotency, reconciliation, security, core-state ownership, vendor portability, or observability handling | `.mustflow/skills/adapter-boundary/SKILL.md` | External system or protocol, inbound/outbound direction, delivery boundary, internal use case, local port/adapter patterns, provider risk, provider failure policy, core-state ownership risk, vendor portability risk, observability identifier policy, API contract risk, change-isolation ledger, preserved consumer contract, changed files, and command contract entries | Ports, adapters, mappers, controllers, workers, stores, gateways, response mappers, telemetry mappers, timeout and retry policies, circuit breakers, bulkhead boundaries, tests, fixtures, assembly wiring, and directly synchronized docs or templates | provider leakage, caller churn from adapter-only changes, framework business-rule leakage, telemetry backend leakage, storage-key leakage, screen-shaped API coupling, pass-through wrapper, SaaS dashboard as truth source, search or analytics policy leakage, queue contract leakage, unclassified external failure, duplicate side effect, unsafe retry, missing timeout, missing circuit breaker, missing bulkhead, unresolved unknown provider outcome, broken identifier propagation, secret or personal-data leak, or untested integration drift | `changes_status`, `changes_diff_summary`, `test_related`, `test`, `lint`, `build`, `docs_validate_fast`, `test_release`, `mustflow_check` | Boundary classification, change-isolation ledger, preserved consumer contract, delivery adapter responsibility, internal port, provider containment, core-state ownership, vendor portability, validation and mapping, API response mapping, observability identifier flow, timeout/retry/circuit-breaker/bulkhead/idempotency handling, reconciliation behavior, security notes, verification, and remaining provider risk |
 | Third-party SDK or external API integration, review, debugging, upgrade, webhook handling, auth scope change, sandbox or production setup, provider SDK version change, API version migration, rate-limit handling, retry policy, idempotency key usage, pagination, provider error mapping, request id logging, changelog review, deprecation response, or provider operational-readiness test needs production integration review | `.mustflow/skills/third-party-api-integration-review/SKILL.md` | Provider and SDK/API ledger, source-of-truth docs, auth and scope ledger, operation and side-effect ledger, webhook ledger, error and observability ledger, changelog or migration evidence, existing fakes or sandbox tests, and configured command intents | Provider adapters, wrappers, typed request and response models, error mappers, timeout and retry policies, rate-limit handling, idempotency key handling, pagination handling, webhook signature verification and dedupe, redacted observability, sandbox tests, fixtures, runbooks, migration notes, and directly synchronized docs or templates | demo-only integration, stale provider docs, SDK/API drift, sandbox-production mixup, hardcoded secret, overbroad scope, token refresh gap, missing timeout, infinite retry, retrying permanent errors, mutating retry without idempotency, per-attempt idempotency key, 429 retry storm, ignored Retry-After, offset pagination assumption, raw provider error leak, string-only provider error, missing request id, trusted webhook payload, JSON-parsed signature breakage, duplicate webhook side effect, event-order assumption, success redirect as proof, unhandled unknown provider outcome, dashboard-only setting, untested SDK upgrade, or happy-path-only sandbox test | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `test_audit`, `docs_validate_fast`, `test_release`, `mustflow_check` | Third-party integration reviewed, provider source-of-truth and SDK/API version evidence, auth/environment/scope decisions, timeout/retry/rate-limit/idempotency/pagination decisions, webhook delivery and dedupe checks, error and observability mapping, tests or missing evidence, verification, and remaining provider operational risk |

package/templates/default/locales/en/.mustflow/skills/dependency-reality-check/SKILL.md

@@ -2,11 +2,11 @@
 mustflow_doc: skill.dependency-reality-check
 locale: en
 canonical: true
-revision: 7
+revision: 9
 lifecycle: mustflow-owned
 authority: procedure
 name: dependency-reality-check
-description: Apply this skill when a task assumes, adds, removes, imports, invokes, installs, audits, or documents a package, runtime, framework, tool, command, service, platform capability, supported-version policy, security patch path, ecosystem maturity claim, maintainer-risk assumption, runtime portability claim, edge or serverless compatibility claim, critical-path dependency choice, or experimental technology placement, especially for AI-suggested dependencies, core backend stack choices, or supply-chain-sensitive changes.
+description: Apply this skill when a task assumes, adds, removes, imports, invokes, installs, audits, or documents a package, runtime, framework, tool, command, service, platform capability, workspace package contract, package.json dependency role, peer dependency contract, public type dependency, export/import boundary, TypeScript path alias, build/test/release package graph edge, supported-version policy, security patch path, ecosystem maturity claim, maintainer-risk assumption, runtime portability claim, edge or serverless compatibility claim, critical-path dependency choice, or experimental technology placement, especially for AI-suggested dependencies, monorepo package metadata, core backend stack choices, or supply-chain-sensitive changes.
 metadata:
   mustflow_schema: "1"
   mustflow_kind: procedure
@@ -31,6 +31,13 @@ Prevent code, docs, tests, and final reports from assuming unavailable packages,
 ## Use When
 
 - A change adds, removes, renames, imports, invokes, or documents a dependency, tool, runtime, command, plugin, service, or platform feature.
+- A JavaScript or TypeScript workspace package changes `package.json`, `exports`, `imports`,
+  `dependencies`, `devDependencies`, `peerDependencies`, `peerDependenciesMeta`,
+  `optionalDependencies`, workspace protocol ranges, public declaration types, package entrypoints,
+  or package-boundary import rules.
+- A JavaScript or TypeScript change relies on `tsconfig.paths`, bundler aliases, test resolver
+  aliases, TypeScript project references, task graph selection, affected builds, package pruning,
+  deploy output, or release tooling to prove that an import is valid.
 - An AI-generated patch, assistant suggestion, copied snippet, or generated docs introduce a package name that could be hallucinated, misspelled, abandoned, lookalike, or unnecessary.
 - A change adds package-manager scripts, package lifecycle hooks, build downloads, binary installers, lockfile changes, audit suppression, vulnerability scanner output, or CI dependency gates.
 - A solution relies on a package manager, binary, environment variable, browser API, operating-system command, hosted service, or optional integration.
@@ -57,6 +64,14 @@ Prevent code, docs, tests, and final reports from assuming unavailable packages,
 
 - The dependency, tool, command, runtime, service, or platform capability being assumed.
 - Package, lock, config, import, script, command-intent, or documentation files that declare or reference it.
+- For JavaScript or TypeScript monorepos: package role (app, library, plugin, tooling package),
+  package-manager workspace protocol, package boundary, package `exports` and `imports`, public
+  declaration files, emitted JavaScript imports, peer host package, and whether the package is
+  published, packed, bundled, deployed, or only used inside the repository.
+- TypeScript, bundler, and test resolver evidence when aliases are involved: `baseUrl`, `paths`,
+  package self-reference, project references, Vite/Jest/Vitest/Webpack aliases, and whether emitted
+  JavaScript, declarations, package manager installs, task graphs, and release tools resolve the
+  same package edge.
 - The minimum version, capability, or availability claim if one is required.
 - Registry name, package scope, lockfile entry, provenance or maintainer expectation, install script risk, and whether the dependency is runtime, development, fixture-only, transitive, or optional.
 - Dependency role criticality: decorative utility, product-experience feature, operational support, or survival path such as identity, money, durable data, permissions, security, migrations, deployment, queues, or file ownership.
@@ -87,7 +102,30 @@ Prevent code, docs, tests, and final reports from assuming unavailable packages,
 
 1. Name the assumed dependency or capability and where the task relies on it.
 2. Check the repository declarations first: package metadata, lockfiles, config files, imports, command intents, docs, and templates.
+   - In monorepos, treat each package's `package.json` as that package's external contract, not as
+     a convenience install list. Check the package that owns the import, not only the workspace root.
+   - Classify the package before classifying its dependencies: final app, published library,
+     framework/plugin package, internal package, tooling package, or test/fixture-only package.
+   - For package-boundary changes, inspect emitted JS imports, generated declaration files,
+     `exports`, `imports`, self-reference tests or examples, workspace ranges, and package manager
+     behavior for pack/publish/deploy output.
+   - Treat `tsconfig.paths` as a TypeScript resolver hint, not as a dependency declaration, package
+     manager edge, runtime rewrite, or public boundary rule. If a path alias points at a sibling
+     package's `src/`, the package graph may be lying even when typecheck is green.
 3. Decide whether the dependency is present, absent, optional, transitive, host-provided, or external.
+   - If emitted JavaScript imports a package, it is normally a runtime dependency of the emitting
+     package unless it is bundled, externalized by a documented host contract, or intentionally peer.
+   - If a public `.d.ts` type references an external package, consumers need that type dependency
+     through `dependencies` or a documented `peerDependencies` contract. Do not hide public type
+     requirements in `devDependencies`.
+   - If the dependency is a host singleton such as React, Vue, ESLint, Vite, Webpack, Fastify,
+     NestJS, Prisma, a bundler plugin host, or another framework/runtime host, prefer a
+     `peerDependencies` contract plus local `devDependencies` for this package's tests and builds.
+   - If the package supports optional host integrations, prefer optional peer metadata for
+     consumer-provided hosts. Use `optionalDependencies` only for direct runtime dependencies that
+     the code can safely conditionally load and survive without.
+   - If a package imports a dependency only because another dependency currently brings it transitively,
+     treat that as an undeclared dependency bug rather than a valid declaration.
 4. For AI-suggested names, check for hallucination and lookalike risk before accepting the import: exact package name, namespace, known local precedent, lockfile presence, and whether an existing dependency already solves the need.
 5. If present, verify that the requested capability and version expectation match the declared dependency.
 6. If absent, prefer an existing local alternative. Add a new dependency only when it is necessary, within the task scope, and reflected in the package metadata and lockfile policy.
@@ -105,14 +143,44 @@ Prevent code, docs, tests, and final reports from assuming unavailable packages,
     - Core and application code should not depend on Node-only APIs, Bun or Deno globals, edge-only globals, framework request objects, ORM clients, environment variables, or platform-specific queue and storage clients.
     - Delivery and infrastructure layers may use runtime or framework capabilities, but the choice should be visible as an adapter decision rather than scattered through use cases.
     - Treat Web-standard frameworks or adapters as a portability aid, not as proof that domain code is portable if provider SDKs, ORM clients, filesystem calls, or platform bindings still leak inward.
-12. Evaluate ecosystem maturity when the task depends on it: production examples, searchable error solutions, migration notes, security-response history, version stability, plugin ecosystem, older issue answers, support availability, and whether the direction is likely to hold over the next release cycles.
-13. For small libraries, accept them only when they are small in role as well as code: simple, understandable, peripheral, safe to fork or reimplement, and not directly touching secrets, personal data, money, permissions, migrations, durable state, or security.
-14. For vulnerability or audit output, separate runtime dependencies from fixture-only or intentionally vulnerable samples. Do not weaken audit gates, delete lockfiles, or add broad suppressions without a repository-owned reason.
-15. For new dependencies, prefer pinned or lockfile-backed versions according to project policy. Avoid widening ranges or removing lockfiles to satisfy generated code.
-16. Do not introduce new package-manager wrappers, vulnerability scanners, registry queries, or install commands inside this skill. Use configured command intents or report the missing verification surface.
-17. If external source material is copied or closely adapted, activate `provenance-license-gate` for source, license, attribution, and copy-extent decisions before preserving the material.
-18. Keep all dependency-facing surfaces aligned: package metadata, lockfiles when intentionally updated, command contract, docs, tests, and installation notes.
-19. Run the narrowest configured verification that proves the dependency path used by the change.
+12. For monorepo package contracts, inspect import and export boundaries before accepting the
+    dependency shape.
+    - Outside a package, imports should use the package name and an explicitly exported entrypoint,
+      not relative paths into sibling packages, `src/`, `dist/`, or internal folders.
+    - `exports` should expose intentional public entrypoints. Broad globs such as `./*` need a
+      package-level reason because they turn internal file layout into public API.
+    - Internal package aliases should use package-private `imports` mappings when the runtime and
+      toolchain support them. Do not make internal aliases look like public workspace packages.
+    - Keep runtime exports and type exports aligned. A subpath that exists at runtime but not in
+      declarations, or vice versa, is a consumer contract drift.
+    - Treat `export *` barrels as possible public API leaks. Public exports should name the symbols
+      the package commits to supporting.
+   - Choose `workspace:*`, `workspace:^`, or another workspace range according to release policy:
+      lockstep packages can use exact workspace coupling, while independently versioned public
+      packages usually need a range that survives publish or pack output.
+    - Root overrides and resolutions are emergency graph controls, not a substitute for correcting
+      each package's own declarations.
+13. Align package, build, test, deploy, and release graphs before accepting a monorepo import.
+    - A compiling import is not proof that the consuming package declared the dependency. Check the
+      consuming package's manifest and the package manager workspace graph.
+    - Do not rely on root `node_modules`, root `dependencies`, broad `paths`, or transitive installs
+      as proof that a package can survive production install, prune, deploy, pack, or publish output.
+    - When a package imports another workspace package, prefer the real package name plus
+      `workspace:` protocol where the package manager supports it. Plain semver for internal
+      packages can hide registry fallback or stale publish behavior.
+    - Check whether task selection, affected tests, build cache keys, Docker or package pruning, and
+      release tooling can see the same dependency edge. If the edge exists only in TypeScript
+      aliases, the graph is incomplete.
+    - Keep root dependency declarations for repository tooling unless the root itself is the
+      runtime package. Runtime imports belong to the package that emits or bundles them.
+14. Evaluate ecosystem maturity when the task depends on it: production examples, searchable error solutions, migration notes, security-response history, version stability, plugin ecosystem, older issue answers, support availability, and whether the direction is likely to hold over the next release cycles.
+15. For small libraries, accept them only when they are small in role as well as code: simple, understandable, peripheral, safe to fork or reimplement, and not directly touching secrets, personal data, money, permissions, migrations, durable state, or security.
+16. For vulnerability or audit output, separate runtime dependencies from fixture-only or intentionally vulnerable samples. Do not weaken audit gates, delete lockfiles, or add broad suppressions without a repository-owned reason.
+17. For new dependencies, prefer pinned or lockfile-backed versions according to project policy. Avoid widening ranges or removing lockfiles to satisfy generated code.
+18. Do not introduce new package-manager wrappers, vulnerability scanners, registry queries, or install commands inside this skill. Use configured command intents or report the missing verification surface.
+19. If external source material is copied or closely adapted, activate `provenance-license-gate` for source, license, attribution, and copy-extent decisions before preserving the material.
+20. Keep all dependency-facing surfaces aligned: package metadata, lockfiles when intentionally updated, command contract, docs, tests, installation notes, package `exports`, public declaration files, self-reference examples, workspace constraints, boundary lint rules, task graph inputs, deploy/prune smoke surfaces, and release graph evidence.
+21. Run the narrowest configured verification that proves the dependency path used by the change.
 
 <!-- mustflow-section: postconditions -->
 ## Postconditions
@@ -122,6 +190,11 @@ Prevent code, docs, tests, and final reports from assuming unavailable packages,
 - Runtime and framework choices identify supported-version policy, end-of-life exposure, security patch path, smoke-test surface, deployment and rollback route, and whether experimental choices are isolated from survival paths.
 - Runtime portability claims identify which APIs are confined to delivery or infrastructure and which would force core or application code to change when moving between Node, Bun, Deno, serverless functions, or edge runtime.
 - New dependency requirements are reflected in the appropriate metadata and public documentation.
+- Workspace package contracts reflect real consumers: emitted runtime imports, public type imports,
+  peer hosts, optional integrations, workspace ranges, `exports`, and boundary lint rules agree
+  instead of relying on root hoisting or transitive dependencies.
+- TypeScript path aliases, bundler aliases, test resolvers, package manager workspace edges, task
+  graphs, deploy/prune artifacts, and release tooling agree or the remaining graph drift is named.
 - The final report states whether the dependency was existing, added, optional, unavailable, or intentionally not verified.
 
 <!-- mustflow-section: verification -->

package/templates/default/locales/en/.mustflow/skills/module-boundary-review/SKILL.md

@@ -2,11 +2,11 @@
 mustflow_doc: skill.module-boundary-review
 locale: en
 canonical: true
-revision: 3
+revision: 5
 lifecycle: mustflow-owned
 authority: procedure
 name: module-boundary-review
-description: Apply this skill when code is created, changed, reviewed, or reported and module separation, cohesion, coupling, change axes, stability direction, data ownership, rule ownership, failure ownership, import direction, circular dependency, DTO leakage, shared/common/utils growth, mock-heavy tests, repeated policy conditions, enum interpretation, repository business logic, anemic domain, domain-to-I/O leakage, transaction boundary mismatch, event naming, public API bloat, caller sequencing, premature reuse, co-change history, bug/fix distance, config ownership, log responsibility, exception translation, cache invalidation ownership, repeated authorization checks, frontend/backend policy leakage, time policy, batch or worker bypass, shallow modules, or temporary-code accumulation can make a change spread beyond its real owner.
+description: Apply this skill when code is created, changed, reviewed, or reported and module or monorepo package separation, cohesion, coupling, change axes, stability direction, package dependency direction, TypeScript path alias boundaries, compile-success versus allowed-dependency confusion, data ownership, rule ownership, failure ownership, import direction, circular dependency, DTO leakage, shared/common/utils growth, cross-package deep imports, package exports, workspace boundary rules, mock-heavy tests, repeated policy conditions, enum interpretation, repository business logic, anemic domain, domain-to-I/O leakage, transaction boundary mismatch, event naming, public API bloat, caller sequencing, premature reuse, co-change history, bug/fix distance, config ownership, log responsibility, exception translation, cache invalidation ownership, repeated authorization checks, frontend/backend policy leakage, time policy, batch or worker bypass, shallow modules, or temporary-code accumulation can make a change spread beyond its real owner.
 metadata:
   mustflow_schema: "1"
   mustflow_kind: procedure
@@ -42,6 +42,10 @@ who must change, who owns the data, who owns the failure, and who should not nee
   services, repositories, validators, mappers, helpers, shared utilities, DTOs, domain models,
   policies, use cases, workers, batches, events, caches, permissions, config reads, or public module
   APIs.
+- A monorepo package graph, workspace dependency direction, package `exports`, cross-package import,
+  deep import, TypeScript `paths` alias, package tag, module-boundary lint rule, TypeScript project
+  reference, affected build/test graph, package deploy/prune surface, or shared/common package is
+  created, changed, reviewed, or reported.
 - A change touches several folders, layers, or modules for one reason, or several differently named
   files repeatedly change together.
 - A review claims that layering, clean architecture, DDD, modular monolith, feature folders,
@@ -85,6 +89,12 @@ who must change, who owns the data, who owns the failure, and who should not nee
   history showing files that usually move together.
 - Module graph evidence: imports, exports, public APIs, call sites, dependency direction, cycles,
   shared helpers, DTO flow, and configuration reads.
+- Monorepo package graph evidence when relevant: each package's role (app, feature, domain, data
+  access, UI, util, tooling), domain scope, runtime platform, package `dependencies`,
+  `peerDependencies`, `devDependencies`, `exports`, `imports`, TypeScript project references,
+  `tsconfig.paths` aliases, bundler and test resolver aliases, package-manager workspace protocol,
+  affected build/test graph, deploy or prune artifact expectations, release graph evidence,
+  boundary lint constraints, and package-level cycle reports.
 - Stability evidence: which modules many callers rely on, which modules change because external
   details move, and whether dependencies point toward the more stable policy owner rather than the
   more volatile implementation detail.
@@ -148,6 +158,14 @@ who must change, who owns the data, who owns the failure, and who should not nee
    - Prefer volatility names and business capabilities, such as pricing policy, payment provider,
      subscription lifecycle, invoice rendering, fraud check, fulfillment handoff, or entitlement
      decision, over role-sliced layer names when those better predict future edits.
+   - In monorepos, assign package roles before accepting an edge. Apps assemble and should not be
+     imported. Domain or policy packages should not know UI, router, database, provider SDK, or
+     framework request details. Infrastructure packages may depend on domain-owned ports or types,
+     but domain packages should not depend on infrastructure implementations.
+   - Treat `shared`, `common`, `utils`, and broad `types` packages as suspect until their scope,
+     layer, and runtime platform are explicit. Split shared concepts by reason to change, such as
+     shared-kernel, shared-ui, shared-config, shared-testing, or domain-owned contracts, rather than
+     by "used in many places".
 3. Check import direction.
    - Infrastructure or low-level modules should not know high-level business use case names unless
      the repository intentionally uses that inversion.
@@ -160,6 +178,21 @@ who must change, who owns the data, who owns the failure, and who should not nee
    - Prefer interfaces or ports owned by the using side when the abstraction protects stable policy
      code from an unstable provider, database, queue, cache, filesystem, network, framework, or UI
      detail.
+   - For monorepos, prefer dependency direction from volatile assembly code toward stable policy or
+     contract code. A stable package importing a fast-changing app, route, UI flow, database adapter,
+     or external API client is a boundary smell even when the folder layout looks layered.
+   - Feature packages should not import each other's internals. If two features need to communicate,
+     look for a missing contract, event, port, or shared lower-level policy package before accepting
+     a direct feature-to-feature edge.
+   - UI kit packages should stay ignorant of business state, routes, auth stores, billing enums, API
+     error shapes, and domain policies. Feature code owns visibility and policy decisions; UI
+     packages render props and callbacks.
+   - Treat "the import compiles" as weak evidence. TypeScript path aliases, editor autocomplete, and
+     root `node_modules` can make an illegal package edge look available while package ownership,
+     deploy output, build cache, and release order remain wrong.
+   - If an import crosses a package boundary through a relative path, `src/`, `dist/`, or an alias
+     that points at another package's source, review it as a boundary violation candidate even when
+     local typecheck and tests pass.
 4. Treat cycles as boundary failure until proven harmless.
    - If A imports B and B imports A, identify the missing concept, ownership decision, event, port, or
      data-flow direction.
@@ -167,6 +200,11 @@ who must change, who owns the data, who owns the failure, and who should not nee
    - When the repository declares `.mustflow/config/module-boundaries.toml`, use the read-only
      `code/module-boundary` script-pack report as executable evidence before relying on prose-only
      boundary claims.
+   - Workspace dependency cycles, even type-only cycles, are package-boundary evidence. `import type`
+     can remove a runtime edge but does not erase architectural knowledge or public declaration
+     coupling.
+   - If a cycle exists between packages, identify the missing lower-level contract package,
+     shared protocol, event, or ownership decision instead of adding a larger shared bucket.
 5. Trace DTO infection.
    - API response DTOs, request DTOs, ORM rows, provider payloads, and UI view models should not
      become domain, repository, batch, worker, or event models by default.
@@ -221,8 +259,19 @@ who must change, who owns the data, who owns the failure, and who should not nee
     - A good module should have a small door and a deeper inside. If most files only expose one-line
       forwarding methods, wrapper services, or renamed CRUD calls, treat the split as shallow module
       theater until a real hidden decision or variation point is named.
-    - A public API wider than the behavior it hides is usually not a boundary; it is implementation
-      leakage with extra navigation.
+   - A public API wider than the behavior it hides is usually not a boundary; it is implementation
+     leakage with extra navigation.
+   - For packages, treat `package.json` `exports` as the public API, not the folder tree. External
+     callers should use package names and intentional subpath exports, not relative paths into
+     sibling packages, `src/`, `dist/`, or internal files.
+   - Do not use `tsconfig.paths` as a substitute for `exports`, `imports`, package self-reference,
+     workspace dependency declarations, or module-boundary lint rules. Path aliases can shorten
+     names inside an app, but they should not define cross-package public API.
+   - Broad export maps such as `./*`, root barrels that `export *`, and package-internal code that
+     imports its own root barrel are public API leak or cycle signals until proven intentional.
+   - Runtime entrypoints and type declarations should expose the same shape. A runtime export with no
+     matching type export, or a public type path with no runtime entrypoint, means consumers see a
+     different contract in the editor and in production.
 16. Check reuse claims.
     - "Used in many places" is not enough reason to extract a common helper.
     - Reuse is safe only when the callers change for the same reason. Similar code from different
@@ -264,9 +313,16 @@ who must change, who owns the data, who owns the failure, and who should not nee
     - Name the three modules or abstractions most likely to rot first.
     - For each, name the change request that would break it, the owner that would cause the change,
       and whether the blast stays inside one module.
-    - Remove or redesign shallow wrappers, central managers, enum-switch strategies, provider-shaped
-      "neutral" ports, configuration-driven logic hiding, event-bus call hiding, and CRUD stamp
-      modules when they fail the attack.
+   - Remove or redesign shallow wrappers, central managers, enum-switch strategies, provider-shaped
+     "neutral" ports, configuration-driven logic hiding, event-bus call hiding, and CRUD stamp
+     modules when they fail the attack.
+   - In a monorepo, attack the package graph too: add a new route, swap a provider, change a domain
+     rule, split a UI component, or publish a library package. If those changes require deep imports,
+     root-hoisted undeclared dependencies, app imports from shared code, or cross-feature internals,
+     the package boundary is not carrying its weight.
+   - Attack the resolver graph too: remove the root install crutch, pack or prune the target package,
+     and ask whether TypeScript, bundler, test runner, task graph, and release tooling still agree on
+     the same edge. If only `paths` knows the edge, the boundary is paper-thin.
 24. Decide the smallest response.
     - If evidence is strong and the edit is in scope, make the smallest boundary fix.
     - If the fix would be broad, report the module boundary risk and the first safe split point.
@@ -287,6 +343,9 @@ who must change, who owns the data, who owns the failure, and who should not nee
 - Shallow module signals such as role-sliced CRUD layers, one-line wrappers, provider-shaped ports,
   ownerless managers, event-bus call hiding, config-hidden logic, and public API bloat are removed,
   justified, or reported.
+- Package-boundary signals such as path-alias reach-through, relative sibling imports, deep source
+  imports, root-hoisted undeclared dependencies, and compile-only imports are fixed, justified, or
+  reported with their graph risk.
 - Any new abstraction hides a named responsibility and reduces caller knowledge, change spread, or
   test mock cost.
 - Behavior, public contracts, permissions, data ownership, and failure semantics remain intact or

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

@@ -262,7 +262,7 @@ applies_to_reasons = ["unknown_change", "code_change", "behavior_change", "test_
 category = "general_code"
 route_type = "adjunct"
 priority = 70
-applies_to_reasons = ["unknown_change", "code_change", "behavior_change", "test_change", "public_api_change", "performance_change", "security_change", "privacy_change", "data_change"]
+applies_to_reasons = ["unknown_change", "code_change", "behavior_change", "test_change", "public_api_change", "performance_change", "security_change", "privacy_change", "data_change", "package_metadata_change"]
 
 [routes."change-blast-radius-review"]
 category = "general_code"
@@ -856,7 +856,7 @@ applies_to_reasons = ["code_change", "docs_change", "security_change", "package_
 category = "data_external"
 route_type = "adjunct"
 priority = 45
-applies_to_reasons = ["code_change", "docs_change", "security_change"]
+applies_to_reasons = ["unknown_change", "code_change", "docs_change", "security_change", "package_metadata_change", "release_risk"]
 
 [routes."version-freshness-check"]
 category = "data_external"

package/templates/default/manifest.toml

@@ -1,6 +1,6 @@
 id = "default"
 name = "default"
-version = "2.115.1"
+version = "2.115.4"
 description = "Minimal workflow for LLM agents to read, edit, and verify their work in a repository."
 common_root = "common"
 locales_root = "locales"