mustflow 1.18.0 → 1.18.14

package/dist/core/change-classification.js

@@ -10,67 +10,30 @@ function surface(kind, category, isPublicSurface, validationReasons, affectedCon
     };
 }
 const UNKNOWN_SURFACE = surface('unclassified_path', 'unknown', false, [], [], 'not_applicable', []);
+function rule(id, match, changeKinds, surfaceContract) {
+    return {
+        id,
+        patternKind: 'regexp',
+        pattern: match.source,
+        patternFlags: match.flags,
+        match,
+        changeKinds,
+        surface: surfaceContract,
+    };
+}
 const CHANGE_CLASSIFICATION_RULES = [
-    {
-        match: /^README\.md$/u,
-        changeKinds: ['documentation'],
-        surface: surface('readme_page', 'documentation', true, ['docs_change', 'copy_change'], ['public documentation', 'command examples'], 'update', ['link targets', 'command examples', 'package metadata references']),
-    },
-    {
-        match: /^docs-site\/src\/content\/docs\/(?!en\/)[^/]+\//u,
-        changeKinds: ['documentation', 'translation'],
-        surface: surface('docs_site_translation', 'documentation', true, ['docs_change', 'i18n_change'], ['documentation site', 'localized content', 'navigation links'], 'update_or_mark_stale', ['source page parity', 'navigation links', 'localized examples']),
-    },
-    {
-        match: /^docs-site\/src\/content\/docs\//u,
-        changeKinds: ['documentation'],
-        surface: surface('docs_site_page', 'documentation', true, ['docs_change'], ['documentation site', 'navigation links', 'localized content'], 'update', ['navigation links', 'localized copies', 'command examples']),
-    },
-    {
-        match: /^templates\/[^/]+\/locales\/[^/]+\//u,
-        changeKinds: ['installed_template', 'translation'],
-        surface: surface('installed_template_translation', 'installed-template', true, ['i18n_change', 'template_version_change'], ['installed template files', 'localized workflow documents', 'template i18n metadata'], 'update_or_mark_stale', ['template i18n metadata', 'localized frontmatter', 'source revision']),
-    },
-    {
-        match: /^templates\/[^/]+\//u,
-        changeKinds: ['installed_template'],
-        surface: surface('installed_template', 'installed-template', true, ['template_version_change', 'packaging_change'], ['installed template files', 'package contents', 'template manifest'], 'update', ['template manifest', 'package inventory', 'localized copies']),
-    },
-    {
-        match: /^(AGENTS\.md|\.mustflow\/(?:docs|context|skills|config)\/)/u,
-        changeKinds: ['workflow'],
-        surface: surface('workflow_root', 'workflow', true, ['mustflow_docs_change', 'mustflow_config_change'], ['agent workflow contract', 'command contract', 'installed workflow files'], 'update', ['strict workflow validation', 'installed template parity', 'skill route alignment']),
-    },
-    {
-        match: /^examples\//u,
-        changeKinds: ['example'],
-        surface: surface('example', 'example', true, ['docs_change', 'public_api_change'], ['generated examples', 'human-readable examples'], 'update', ['example commands', 'linked docs', 'public behavior claims']),
-    },
-    {
-        match: /^schemas\//u,
-        changeKinds: ['schema'],
-        surface: surface('schema_contract', 'contract', true, ['public_api_change', 'release_risk'], ['JSON schema', 'machine-readable output contract'], 'update', ['schema tests', 'documented JSON fields', 'package inventory']),
-    },
-    {
-        match: /^package\.json$/u,
-        changeKinds: ['package_metadata'],
-        surface: surface('package_metadata', 'release', true, ['package_metadata_change', 'release_risk'], ['npm package metadata', 'published package contents'], 'update', ['package metadata tests', 'version source discovery', 'published file inventory']),
-    },
-    {
-        match: /^tests\/fixtures\//u,
-        changeKinds: ['test_fixture'],
-        surface: surface('test_fixture', 'test', false, ['test_change'], ['regression fixture inputs'], 'not_applicable', ['fixture safety', 'test route coverage']),
-    },
-    {
-        match: /^tests\//u,
-        changeKinds: ['test'],
-        surface: surface('test_contract', 'test', false, ['test_change'], ['test behavior contract'], 'not_applicable', ['related test selection']),
-    },
-    {
-        match: /^(src|scripts)\//u,
-        changeKinds: ['implementation'],
-        surface: surface('implementation', 'code', false, ['code_change'], ['runtime behavior when exported through CLI or package output'], 'not_applicable', ['related tests', 'build output']),
-    },
+    rule('readme_page', /^README\.md$/u, ['documentation'], surface('readme_page', 'documentation', true, ['docs_change', 'copy_change'], ['public documentation', 'command examples'], 'update', ['link targets', 'command examples', 'package metadata references'])),
+    rule('docs_site_translation', /^docs-site\/src\/content\/docs\/(?!en\/)[^/]+\//u, ['documentation', 'translation'], surface('docs_site_translation', 'documentation', true, ['docs_change', 'i18n_change'], ['documentation site', 'localized content', 'navigation links'], 'update_or_mark_stale', ['source page parity', 'navigation links', 'localized examples'])),
+    rule('docs_site_page', /^docs-site\/src\/content\/docs\//u, ['documentation'], surface('docs_site_page', 'documentation', true, ['docs_change'], ['documentation site', 'navigation links', 'localized content'], 'update', ['navigation links', 'localized copies', 'command examples'])),
+    rule('installed_template_translation', /^templates\/[^/]+\/locales\/[^/]+\//u, ['installed_template', 'translation'], surface('installed_template_translation', 'installed-template', true, ['i18n_change', 'template_version_change'], ['installed template files', 'localized workflow documents', 'template i18n metadata'], 'update_or_mark_stale', ['template i18n metadata', 'localized frontmatter', 'source revision'])),
+    rule('installed_template', /^templates\/[^/]+\//u, ['installed_template'], surface('installed_template', 'installed-template', true, ['template_version_change', 'packaging_change'], ['installed template files', 'package contents', 'template manifest'], 'update', ['template manifest', 'package inventory', 'localized copies'])),
+    rule('workflow_root', /^(AGENTS\.md|\.mustflow\/(?:docs|context|skills|config)\/)/u, ['workflow'], surface('workflow_root', 'workflow', true, ['mustflow_docs_change', 'mustflow_config_change'], ['agent workflow contract', 'command contract', 'installed workflow files'], 'update', ['strict workflow validation', 'installed template parity', 'skill route alignment'])),
+    rule('example', /^examples\//u, ['example'], surface('example', 'example', true, ['docs_change', 'public_api_change'], ['generated examples', 'human-readable examples'], 'update', ['example commands', 'linked docs', 'public behavior claims'])),
+    rule('schema_contract', /^schemas\//u, ['schema'], surface('schema_contract', 'contract', true, ['public_api_change', 'release_risk'], ['JSON schema', 'machine-readable output contract'], 'update', ['schema tests', 'documented JSON fields', 'package inventory'])),
+    rule('package_metadata', /^package\.json$/u, ['package_metadata'], surface('package_metadata', 'release', true, ['package_metadata_change', 'release_risk'], ['npm package metadata', 'published package contents'], 'update', ['package metadata tests', 'version source discovery', 'published file inventory'])),
+    rule('test_fixture', /^tests\/fixtures\//u, ['test_fixture'], surface('test_fixture', 'test', false, ['test_change'], ['regression fixture inputs'], 'not_applicable', ['fixture safety', 'test route coverage'])),
+    rule('test_contract', /^tests\//u, ['test'], surface('test_contract', 'test', false, ['test_change'], ['test behavior contract'], 'not_applicable', ['related test selection'])),
+    rule('implementation', /^(src|scripts)\//u, ['implementation'], surface('implementation', 'code', false, ['code_change'], ['runtime behavior when exported through CLI or package output'], 'not_applicable', ['related tests', 'build output'])),
 ];
 function uniqueSorted(values) {
     return [...new Set(values)].sort((left, right) => left.localeCompare(right));
@@ -100,6 +63,16 @@ export function classifyChangePath(relativePath) {
         surface: rule?.surface ?? UNKNOWN_SURFACE,
     };
 }
+export function listChangeClassificationRuleDescriptors() {
+    return CHANGE_CLASSIFICATION_RULES.map((classificationRule) => ({
+        id: classificationRule.id,
+        patternKind: classificationRule.patternKind,
+        pattern: classificationRule.pattern,
+        patternFlags: classificationRule.patternFlags,
+        changeKinds: classificationRule.changeKinds,
+        surface: classificationRule.surface,
+    }));
+}
 export function createChangeClassificationReport(source, relativePaths) {
     const files = uniqueSorted(relativePaths.map(normalizeStatusPath).filter((filePath) => filePath.length > 0));
     const classifications = files.map(classifyChangePath);

package/dist/core/command-classification.js

@@ -4,7 +4,6 @@ const IN_PROCESS_MUSTFLOW_BUILTIN_COMMANDS = new Set([
     'classify',
     'context',
     'doctor',
-    'explain',
     'help',
     'impact',
     'line-endings',
@@ -12,7 +11,6 @@ const IN_PROCESS_MUSTFLOW_BUILTIN_COMMANDS = new Set([
     'status',
     'update',
     'version-sources',
-    'verify',
 ]);
 export function isMustflowBinName(command) {
     return MUSTFLOW_BIN_NAMES.has(command.toLowerCase());

package/dist/core/source-anchor-status.js

@@ -1,7 +1,7 @@
 import { createHash } from 'node:crypto';
 import { existsSync, readFileSync, statSync } from 'node:fs';
 import path from 'node:path';
-import { listSourceAnchorFiles, parseSourceAnchorsInContent, splitSourceAnchorList, } from './source-anchors.js';
+import { listSourceAnchorFiles, parseSourceAnchorsInContent, sourceAnchorTextContainsSecretLike, splitSourceAnchorList, } from './source-anchors.js';
 import { extractSourceAnchorSymbol, } from './source-anchor-symbols.js';
 const HIGH_RISK_SOURCE_ANCHOR_TAGS = new Set([
     'authn',
@@ -210,16 +210,16 @@ function findUniqueSymbolCandidate(previous, currentRecords) {
  * invariant: Status records are derived search metadata and do not grant command or verification authority.
  * risk: cache, config
  */
-export function collectSourceAnchorIndexRecords(projectRoot, previousSnapshots = []) {
+export function collectSourceAnchorIndexRecords(projectRoot, previousSnapshots = [], fileOptions = {}) {
     const currentRecords = [];
-    for (const relativePath of listSourceAnchorFiles(projectRoot)) {
+    for (const relativePath of listSourceAnchorFiles(projectRoot, fileOptions)) {
         const filePath = path.join(projectRoot, ...relativePath.split('/'));
         if (!existsSync(filePath) || !statSync(filePath).isFile()) {
             continue;
         }
         const content = readFileSync(filePath, 'utf8');
         for (const anchor of parseSourceAnchorsInContent(relativePath, content)) {
-            if (!anchor.idValid) {
+            if (!anchor.idValid || sourceAnchorTextContainsSecretLike(anchor.rawText)) {
                 continue;
             }
             const search = splitSourceAnchorList(anchor.fields.get('search'));

package/dist/core/source-anchor-validation.js

@@ -1,6 +1,6 @@
 import { readFileSync } from 'node:fs';
 import path from 'node:path';
-import { SOURCE_ANCHOR_ALLOWED_RISKS, listSourceAnchorFiles, parseSourceAnchorsInContent, sourceAnchorPathIsGeneratedOrVendor, splitSourceAnchorList, } from './source-anchors.js';
+import { SOURCE_ANCHOR_ALLOWED_RISKS, listSourceAnchorFiles, parseSourceAnchorsInContent, sourceAnchorPathIsGeneratedOrVendor, sourceAnchorTextContainsSecretLike, splitSourceAnchorList, } from './source-anchors.js';
 export const SOURCE_ANCHOR_IGNORED_DIRECTORIES = new Set([
     '.git',
     '.mustflow',
@@ -38,10 +38,6 @@ const SOURCE_ANCHOR_FORBIDDEN_INSTRUCTION_PATTERNS = [
     /\bthis\s+anchor\s+(?:authorizes|grants|allows)\b.*\b(?:agents?|commands?|validation|verification)\b/iu,
     /\b(?:command_intents?|required_after|run_policy|argv|cmd|permissions?|allowed_edits|skip_validation|agent_action)\s*[:=]/iu,
 ];
-const SOURCE_ANCHOR_SECRET_LIKE_PATTERNS = [
-    /\b(?:api[_-]?key|api[_-]?token|access[_-]?token|auth[_-]?token|secret|password|passwd|private[_-]?key)\b\s*[:=]\s*["']?[A-Za-z0-9_./+=:-]{8,}/iu,
-    /\b(?:sk-[A-Za-z0-9]{16,}|ghp_[A-Za-z0-9]{20,}|xox[baprs]-[A-Za-z0-9-]{20,}|AKIA[0-9A-Z]{16})\b/u,
-];
 function sourceAnchorIssue(message) {
     return { severity: 'error', message };
 }
@@ -65,7 +61,7 @@ function validateSourceAnchor(anchor) {
     if (SOURCE_ANCHOR_FORBIDDEN_INSTRUCTION_PATTERNS.some((pattern) => pattern.test(anchor.rawText))) {
         issues.push(sourceAnchorIssue(`source anchor ${label} contains agent command or policy instructions`));
     }
-    if (SOURCE_ANCHOR_SECRET_LIKE_PATTERNS.some((pattern) => pattern.test(anchor.rawText))) {
+    if (sourceAnchorTextContainsSecretLike(anchor.rawText)) {
         issues.push(sourceAnchorIssue(`source anchor ${label} contains secret-like text`));
     }
     for (const field of anchor.unsupportedFields) {

package/dist/core/source-anchors.js

@@ -44,6 +44,10 @@ export const SOURCE_ANCHOR_ALLOWED_RISKS = new Set([
     'xss',
 ]);
 export const SOURCE_ANCHOR_ID_PATTERN = /^[a-z0-9][a-z0-9.-]{0,95}$/u;
+export const SOURCE_ANCHOR_SECRET_LIKE_PATTERNS = [
+    /\b(?:api[_-]?key|api[_-]?token|access[_-]?token|auth[_-]?token|secret|password|passwd|private[_-]?key)\b\s*[:=]\s*["']?[A-Za-z0-9_./+=:-]{8,}/iu,
+    /\b(?:sk-[A-Za-z0-9]{16,}|ghp_[A-Za-z0-9]{20,}|xox[baprs]-[A-Za-z0-9-]{20,}|AKIA[0-9A-Z]{16})\b/u,
+];
 function toPosixPath(value) {
     return value.split(path.sep).join('/');
 }
@@ -68,11 +72,82 @@ function listFilesRecursive(root, ignoredDirectoryNames, current = root) {
     }
     return files.sort((left, right) => left.localeCompare(right));
 }
+function escapeRegExp(value) {
+    return value.replace(/[\\^$.*+?()[\]{}|]/gu, '\\$&');
+}
+function globToRegExp(pattern) {
+    const normalized = toPosixPath(pattern).replace(/^\/+/u, '');
+    let source = '^';
+    for (let index = 0; index < normalized.length;) {
+        const current = normalized[index];
+        const next = normalized[index + 1];
+        const afterNext = normalized[index + 2];
+        if (current === '*' && next === '*') {
+            if (afterNext === '/') {
+                source += '(?:.*/)?';
+                index += 3;
+                continue;
+            }
+            source += '.*';
+            index += 2;
+            continue;
+        }
+        if (current === '*') {
+            source += '[^/]*';
+            index += 1;
+            continue;
+        }
+        if (current === '?') {
+            source += '[^/]';
+            index += 1;
+            continue;
+        }
+        source += escapeRegExp(current ?? '');
+        index += 1;
+    }
+    return new RegExp(`${source}$`, 'u');
+}
+function matchesAnyGlob(relativePath, patterns) {
+    return patterns.some((pattern) => pattern.test(relativePath));
+}
+function normalizeSourceAnchorExtension(value) {
+    const normalized = value.trim().toLowerCase();
+    if (normalized.length === 0) {
+        return null;
+    }
+    return normalized.startsWith('.') ? normalized : `.${normalized}`;
+}
+function normalizeAllowedExtensions(allowedExtensions) {
+    if (!allowedExtensions) {
+        return SOURCE_ANCHOR_EXTENSIONS;
+    }
+    const normalized = [...allowedExtensions]
+        .map((extension) => normalizeSourceAnchorExtension(extension))
+        .filter((extension) => Boolean(extension));
+    return normalized.length > 0 ? new Set(normalized) : SOURCE_ANCHOR_EXTENSIONS;
+}
+function mergeIgnoredDirectoryNames(ignoredDirectoryNames) {
+    return new Set([...(ignoredDirectoryNames ?? []), ...SOURCE_ANCHOR_DEFAULT_EXCLUDED_PATH_PARTS]);
+}
+function fileIsWithinSizeLimit(root, relativePath, maxFileBytes) {
+    if (typeof maxFileBytes !== 'number' || !Number.isFinite(maxFileBytes) || maxFileBytes <= 0) {
+        return true;
+    }
+    const filePath = path.join(root, ...relativePath.split('/'));
+    return statSync(filePath).size <= maxFileBytes;
+}
 export function listSourceAnchorFiles(root, options = {}) {
-    const ignoredDirectoryNames = options.ignoredDirectoryNames ?? SOURCE_ANCHOR_DEFAULT_EXCLUDED_PATH_PARTS;
+    const ignoredDirectoryNames = mergeIgnoredDirectoryNames(options.ignoredDirectoryNames);
+    const allowedExtensions = normalizeAllowedExtensions(options.allowedExtensions);
+    const include = (options.include ?? []).map((pattern) => globToRegExp(pattern));
+    const exclude = (options.exclude ?? []).map((pattern) => globToRegExp(pattern));
     return listFilesRecursive(root, ignoredDirectoryNames)
         .map((relativePath) => toPosixPath(relativePath))
-        .filter((relativePath) => SOURCE_ANCHOR_EXTENSIONS.has(path.posix.extname(relativePath)));
+        .filter((relativePath) => allowedExtensions.has(path.posix.extname(relativePath)))
+        .filter((relativePath) => options.excludeGeneratedOrVendor !== true || !sourceAnchorPathIsGeneratedOrVendor(relativePath))
+        .filter((relativePath) => include.length === 0 || matchesAnyGlob(relativePath, include))
+        .filter((relativePath) => exclude.length === 0 || !matchesAnyGlob(relativePath, exclude))
+        .filter((relativePath) => fileIsWithinSizeLimit(root, relativePath, options.maxFileBytes));
 }
 export function stripSourceAnchorCommentPrefix(line) {
     return line
@@ -113,6 +188,9 @@ export function sourceAnchorPathIsGeneratedOrVendor(relativePath) {
     }
     return parts.some((part) => SOURCE_ANCHOR_GENERATED_PATH_PARTS.has(part));
 }
+export function sourceAnchorTextContainsSecretLike(value) {
+    return SOURCE_ANCHOR_SECRET_LIKE_PATTERNS.some((pattern) => pattern.test(value));
+}
 export function parseSourceAnchorsInContent(relativePath, content) {
     const lines = content.split(/\r?\n/);
     const anchors = [];
@@ -174,7 +252,7 @@ export function collectSourceAnchorSummaries(projectRoot) {
         }
         const content = readFileSync(filePath, 'utf8');
         for (const anchor of parseSourceAnchorsInContent(relativePath, content)) {
-            if (!anchor.idValid) {
+            if (!anchor.idValid || sourceAnchorTextContainsSecretLike(anchor.rawText)) {
                 continue;
             }
             anchors.push({

package/package.json

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

package/schemas/change-verification-report.schema.json

@@ -134,6 +134,97 @@
         },
         "source": {
           "const": "change_classification"
+        },
+        "surfaceReadModels": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/localPathSurfaceReadModel"
+          }
+        }
+      }
+    },
+    "localPathSurfaceReadModel": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "source",
+        "status",
+        "databasePath",
+        "indexFresh",
+        "stalePaths",
+        "inputPath",
+        "match",
+        "refreshHint"
+      ],
+      "properties": {
+        "source": { "const": "local_index" },
+        "status": { "enum": ["fresh", "missing", "stale", "unreadable"] },
+        "databasePath": { "type": "string" },
+        "indexFresh": { "type": "boolean" },
+        "stalePaths": {
+          "type": "array",
+          "items": { "type": "string" }
+        },
+        "inputPath": { "type": ["string", "null"] },
+        "match": {
+          "anyOf": [
+            { "type": "null" },
+            { "$ref": "#/$defs/localPathSurfaceRuleMatch" }
+          ]
+        },
+        "refreshHint": { "type": ["string", "null"] }
+      }
+    },
+    "localPathSurfaceRuleMatch": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "ruleId",
+        "patternKind",
+        "pattern",
+        "patternFlags",
+        "changeKinds",
+        "surface"
+      ],
+      "properties": {
+        "ruleId": { "type": "string" },
+        "patternKind": { "type": "string" },
+        "pattern": { "type": "string" },
+        "patternFlags": { "type": "string" },
+        "changeKinds": {
+          "type": "array",
+          "items": { "type": "string" }
+        },
+        "surface": {
+          "type": "object",
+          "additionalProperties": false,
+          "required": [
+            "kind",
+            "category",
+            "isPublicSurface",
+            "validationReasons",
+            "affectedContracts",
+            "updatePolicy",
+            "driftChecks"
+          ],
+          "properties": {
+            "kind": { "type": "string" },
+            "category": { "type": "string" },
+            "isPublicSurface": { "type": "boolean" },
+            "validationReasons": {
+              "type": "array",
+              "items": { "type": "string" }
+            },
+            "affectedContracts": {
+              "type": "array",
+              "items": { "type": "string" }
+            },
+            "updatePolicy": { "enum": ["update", "update_or_mark_stale", "not_applicable"] },
+            "driftChecks": {
+              "type": "array",
+              "items": { "type": "string" }
+            }
+          }
         }
       }
     },
@@ -271,6 +362,109 @@
           "items": {
             "$ref": "#/$defs/verificationScheduleConflict"
           }
+        },
+        "effectGraph": {
+          "$ref": "#/$defs/commandEffectGraph"
+        }
+      }
+    },
+    "commandEffectGraph": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "source",
+        "status",
+        "databasePath",
+        "indexFresh",
+        "stalePaths",
+        "writeLocks",
+        "lockConflicts",
+        "refreshHint"
+      ],
+      "properties": {
+        "source": { "const": "local_index" },
+        "status": { "enum": ["fresh", "missing", "stale", "unreadable"] },
+        "databasePath": { "type": "string" },
+        "indexFresh": { "type": "boolean" },
+        "stalePaths": {
+          "type": "array",
+          "items": { "type": "string" }
+        },
+        "writeLocks": {
+          "type": "array",
+          "items": { "$ref": "#/$defs/commandWriteLock" }
+        },
+        "lockConflicts": {
+          "type": "array",
+          "items": { "$ref": "#/$defs/commandLockConflict" }
+        },
+        "refreshHint": { "type": ["string", "null"] }
+      }
+    },
+    "commandWriteLock": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["lock", "paths", "modes", "sources", "concurrencies", "effectCount"],
+      "properties": {
+        "lock": { "type": "string" },
+        "paths": {
+          "type": "array",
+          "items": { "type": "string" }
+        },
+        "modes": {
+          "type": "array",
+          "items": { "type": "string" }
+        },
+        "sources": {
+          "type": "array",
+          "items": { "type": "string" }
+        },
+        "concurrencies": {
+          "type": "array",
+          "items": { "type": "string" }
+        },
+        "effectCount": { "type": "integer" }
+      }
+    },
+    "commandLockConflict": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "intent",
+        "lock",
+        "paths",
+        "modes",
+        "concurrencies",
+        "conflictingPaths",
+        "conflictingModes",
+        "conflictingConcurrencies"
+      ],
+      "properties": {
+        "intent": { "type": "string" },
+        "lock": { "type": "string" },
+        "paths": {
+          "type": "array",
+          "items": { "type": "string" }
+        },
+        "modes": {
+          "type": "array",
+          "items": { "type": "string" }
+        },
+        "concurrencies": {
+          "type": "array",
+          "items": { "type": "string" }
+        },
+        "conflictingPaths": {
+          "type": "array",
+          "items": { "type": "string" }
+        },
+        "conflictingModes": {
+          "type": "array",
+          "items": { "type": "string" }
+        },
+        "conflictingConcurrencies": {
+          "type": "array",
+          "items": { "type": "string" }
         }
       }
     },

package/schemas/context-report.schema.json

@@ -306,14 +306,42 @@
     "taskContextLayer": {
       "type": "object",
       "additionalProperties": false,
-      "required": ["cache_layer", "read_policy", "sources"],
+      "required": ["cache_layer", "read_policy", "sources", "local_index"],
       "properties": {
         "cache_layer": { "const": "task" },
         "read_policy": { "type": ["string", "null"] },
         "sources": {
           "type": "array",
           "items": { "type": "string" }
-        }
+        },
+        "local_index": { "$ref": "#/$defs/promptCacheLocalIndex" }
+      }
+    },
+    "promptCacheLocalIndex": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "source",
+        "status",
+        "database_path",
+        "index_fresh",
+        "stale_paths",
+        "search_backend",
+        "search_fts5_available",
+        "refresh_hint"
+      ],
+      "properties": {
+        "source": { "const": "local_index" },
+        "status": { "enum": ["fresh", "missing", "stale", "unreadable"] },
+        "database_path": { "type": "string" },
+        "index_fresh": { "type": "boolean" },
+        "stale_paths": {
+          "type": "array",
+          "items": { "type": "string" }
+        },
+        "search_backend": { "type": ["string", "null"], "enum": ["fts5", "table_scan", null] },
+        "search_fts5_available": { "type": ["boolean", "null"] },
+        "refresh_hint": { "type": ["string", "null"] }
       }
     },
     "volatileSuffixLayer": {