mustflow 2.115.3 → 2.115.5

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.3",
+  "version": "2.115.5",
   "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 = 228
+revision = 229
 translations = {}
 
 [documents."skill.adapter-boundary"]
@@ -1164,7 +1164,7 @@ translations = {}
 [documents."skill.release-publish-change"]
 source = "locales/en/.mustflow/skills/release-publish-change/SKILL.md"
 source_locale = "en"
-revision = 2
+revision = 3
 translations = {}
 
 [documents."skill.security-privacy-review"]

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

@@ -2,7 +2,7 @@
 mustflow_doc: skills.index
 locale: en
 canonical: true
-revision: 228
+revision: 229
 authority: router
 lifecycle: mustflow-owned
 ---
@@ -632,7 +632,7 @@ routes. Event routes stay inactive until their event occurs.
 | `README.md` is created, restructured, or substantially rewritten | `.mustflow/skills/readme-authoring/SKILL.md` | User request, existing README if any, repository evidence, nearest instructions, and command contracts | `README.md` and directly linked public docs | invented project claims, marketing drift, or loss of human-authored intent | `docs_validate_fast`, `mustflow_check` | Evidence-based README changes, preserved or deferred sections, verification notes |
 | README content is generated, reviewed, or audited for unsupported AI-generated claims, fake commands, invented environment variables, README-as-investment-deck overclaim, unshipped roadmap-as-current wording, fake or internal-demo usage examples, TODO/temporary/internal-state wording, executable install/run/test/build contracts, pasteable examples, public API examples, security exposure, performance, platform support, license, trademark, copyright, credit, attribution, roadmap, architecture, or file-tree explanations | `.mustflow/skills/readme-evidence-gate/SKILL.md` | README draft or sections, evidence ledger, repository files, package manager metadata, lockfiles, `bin`, `exports`, public exports, command sources, CLI parser/help/output evidence, config/env sources, support and badge evidence, tests, license and notice files, SPDX identifiers, source headers, package metadata, contributor and trademark evidence, CI matrices, Dockerfiles, benchmarks, maintained docs, screenshots, `.env.example`, code-block execution policy, clean-environment evidence, secret-scanning policy, and external or AI source text | README wording and directly synchronized README examples, docs links, placeholder examples, code-block labels, legal/credit wording, or screenshot guidance | hallucinated README contract, fake quick-start, invented env/API, subjective maintenance-debt prose, unsupported pasteable snippet, untested executable README contract, OS-shell mismatch, missing server readiness, unsupported security/performance/platform/license/trademark claim, mixed roadmap/current support, hidden internal demo prerequisite, unsupported badge or support claim, real-looking fake key, API key in URL query, internal URL, private IP, production path, pasteable production command, unsafe screenshot, or speculative file tree | `docs_validate_fast`, `test_related`, `test_release`, `mustflow_check` | README evidence ledger, claims kept/qualified/moved/removed, subjective phrases converted, overclaim/support/badge/failure-path checks, executable-command and clean-environment checks, pasteable contract checks, legal/SPDX/NOTICE/trademark/credit checks, security exposure checks, unsupported claims found, verification notes, and remaining README evidence risk |
 | Release notes, changelog entries, public change summaries, release preparation copy, or package release wording are drafted or revised | `.mustflow/skills/release-notes-authoring/SKILL.md` | User-provided change summary, current diff summary, release audience, public surfaces, version source, and command contract entries | Release notes, changelog entries, release preparation notes, and directly synchronized docs or package metadata | invented release history, inflated public claims, internal noise, stale version or migration notes, or unverified release evidence | `changes_status`, `changes_diff_summary`, `docs_validate_fast`, `test_release`, `mustflow_check` | Release audience, categorized notes, excluded internal changes, version or migration checks, verification, skipped release-history checks, and remaining release-note risk |
-| Release publishing, package registry publication, remote release channels, Git tags, GitHub Releases, release assets, npm, PyPI, crates.io, Go modules, Docker images, Homebrew formulae or casks, app updater metadata, version bump decisions, artifact inspection, post-publish smoke tests, rollback or yanking plans, or user installation paths are created, changed, reviewed, or reported | `.mustflow/skills/release-publish-change/SKILL.md` | Release target, version, channel, package name, module path, image name, tag, artifact names, expected assets, public contract source, artifact inspection method, remote publication surface, recovery model, and command contract entries | Version metadata, release workflows, package manifests, artifact manifests, changelog or release-preparation docs, package tests, install-smoke expectations, release validation tests, and installed-template metadata | local-only release claim, wrong version bump, stale artifact, registry overwrite assumption, missing asset, bad checksum or signature, moved Go tag, unverified Docker digest, updater metadata breakage, missing user-path smoke test, or false rollback claim | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `docs_validate_fast`, `test_release`, `mustflow_check` | Release target, version and channel, public API classification, artifact inspection evidence, remote publication state, user-path smoke result, synchronized surfaces, recovery classification, verification, and remaining release-publish risk |
+| Release publishing, package registry publication, remote release channels, Git tags, GitHub Releases, release assets, npm, PyPI, crates.io, Go modules, Docker images, Homebrew formulae or casks, app updater metadata, version bump decisions, artifact inspection, post-publish smoke tests, rollback or yanking plans, or user installation paths are created, changed, reviewed, or reported | `.mustflow/skills/release-publish-change/SKILL.md` | Release target, exact immutable version, channel, package name, module path, image name, tag, artifact names, expected assets, public contract source, artifact inspection method, remote publication surface, consumer environment, public entrypoints, recovery model, and command contract entries | Version metadata, release workflows, package manifests, artifact manifests, changelog or release-preparation docs, package tests, install-smoke expectations, release validation tests, and installed-template metadata | local-only release claim, wrong version bump, stale artifact, cache-only or internal-entrypoint-only smoke, registry overwrite assumption, missing asset, bad checksum or signature, moved Go tag, unverified Docker digest, updater metadata breakage, missing user-path smoke test, or false rollback claim | `changes_status`, `changes_diff_summary`, `lint`, `build`, `test_related`, `test`, `docs_validate_fast`, `test_release`, `mustflow_check` | Release target, exact version and channel, public API classification, artifact inspection evidence, remote publication state, public-entrypoint user-path smoke and environment evidence, synchronized surfaces, recovery classification, verification, and remaining release-publish risk |
 | Search-friendly ad-supported articles, blog posts, guides, reviews, comparisons, FAQs, or evergreen content are planned, written, edited, reviewed, or reported | `.mustflow/skills/search-ad-content-authoring/SKILL.md` | Search intent, reader task, content type, source freshness needs, monetization constraints, article draft or outline, and command contract entries | Article outlines, headings, paragraphs, tables, lists, FAQs, images, links, disclosures, content docs, templates, tests, and reports | keyword stuffing, thin filler, misleading ad adjacency, stale policy or ranking claims, unsupported revenue claims, accessibility or layout instability, or copied competitor content | `changes_status`, `changes_diff_summary`, `docs_validate_fast`, `test_release`, `mustflow_check` | Search intent, outline shape, content structure checks, source freshness, ad layout and trust checks, omitted or verified claims, verification, and remaining content risk |
 | Documentation review queue entries or selected docs need prose cleanup for LLM-like wording, AI-slop signals, low-specificity boilerplate, literal translation, unnatural tone, Korean technical translationese, or domain-term drift | `.mustflow/skills/docs-prose-review/SKILL.md` | Review queue entry or selected document path, review comment if present, target language, audience or genre, domain terminology, reviewer metadata | Selected documentation file and review ledger entry | meaning drift, fake authorship attribution, invented evidence, over-editing, or stale queue state | `docs_validate`, `mustflow_check` | Prose issues fixed, preserved technical meaning, recorded review status, verification notes |
 | Korean or English prose is supplied to extract reusable elegant wording candidates, store selected modular phrase fragments, polish prose with a curated phrase bank, or improve wording for report-style answers, final reports, GitHub issue bodies, pull request descriptions, review replies, maintainer-facing comments, release or update notes, documentation prose, summaries, or explanatory writing after the facts are established | `.mustflow/skills/writing-elegance/SKILL.md` | Source text, mode, target register, target surface, user keep or reject choices, current phrase bank when storing or applying expressions, owning workflow skill when evidence or repository policy matters, and command contract entries when files change | Candidate tables, selected phrase-bank entries, polished report or GitHub wording, `references/phrase-bank.md`, synchronized template copy, route metadata, template manifest, i18n metadata, and directly tied tests | over-specific sentence capture, proper-name leakage, private detail storage, ornamental wording, technical meaning drift, docs-prose-review overlap, GitHub quality-gate overlap, release-note authority drift, completion-evidence drift, phrase-bank bloat, or skipped template sync | `changes_status`, `changes_diff_summary`, `docs_validate_fast`, `test_release`, `mustflow_check` | Mode, target surface, candidate table or stored entries, entries kept or rejected, phrase-bank updates or polish boundary, owning skill applied or deferred, template sync, verification, and remaining style or specificity risk |

package/templates/default/locales/en/.mustflow/skills/release-publish-change/SKILL.md

@@ -2,7 +2,7 @@
 mustflow_doc: skill.release-publish-change
 locale: en
 canonical: true
-revision: 2
+revision: 3
 lifecycle: mustflow-owned
 authority: procedure
 name: release-publish-change
@@ -60,7 +60,7 @@ The release is not done when tests pass locally, a version string changes, or a
   and whether each belongs to publication, branch CI, tag CI, release asset generation, or another
   independent verification path.
 - Recovery model: unpublish, yank, deprecate, republish with new version, move channel pointer, revoke asset, restore from backup, or forward fix.
-- Configured command intents for build, package inspection, release verification, docs validation, and user installation or updater smoke test. If no such intent exists, report the missing intent instead of inventing a raw command.
+- Configured command intents for build, package inspection, release verification, docs validation, and user installation or updater smoke test. For post-publish checks, also identify the exact immutable version, intended registry or channel, consumer environment, public entrypoints, and runtime or platform evidence. If no such intent exists, report the missing intent instead of inventing a raw command.
 
 <!-- mustflow-section: preconditions -->
 ## Preconditions
@@ -101,6 +101,14 @@ The release is not done when tests pass locally, a version string changes, or a
    - GitHub Releases depend on Git tags, but release assets, checksums, signatures, and release body are separate evidence surfaces.
    - App updater channels depend on metadata and signature state, not only uploaded installers.
 5. For npm-style package publication, verify package metadata, packed file list, entrypoints, bin links, README, LICENSE, access, provenance or trusted publisher setup, registry target, and exact published version behavior through configured intents.
+   - Keep pre-publish packed-artifact checks separate from post-publish registry checks. A local tarball or workspace install does not prove that the immutable registry version users receive is installable.
+   - Run the post-publish smoke in a fresh consumer root outside the source checkout. Install the exact immutable name and version from the intended registry without workspace links or local archive fallbacks.
+   - Use a fresh or isolated package-manager cache strategy and prefer current registry metadata. A cache-only success is not independent remote-channel evidence.
+   - Disable lifecycle scripts by default so a package cannot repair missing build output during installation. If lifecycle scripts are an intentional public contract, test that behavior separately with the required sandbox and approval boundary.
+   - Execute the public command shims, exported entrypoints, or documented import path that users invoke. Calling an internal module file directly does not prove that package-manager shims, aliases, permissions, or entry metadata work.
+   - Exercise every documented command alias that is part of the release contract, then run one minimal documented workflow that crosses initialization or configuration validation when applicable.
+   - Retry only bounded transient registry conditions such as propagation delay, throttling, or transport reset. Do not retry authentication, package metadata, entrypoint, or runtime failures into a false pass.
+   - Keep temporary state owned and removable, preserve the primary failure if cleanup also fails, and report the exact package version, registry, package-manager version, runtime, operating system, and public entrypoints exercised.
 6. For PyPI-style publication, verify source distribution, wheel contents, metadata, Python version constraints, entrypoints, README rendering, filename uniqueness, and install smoke path through configured intents.
 7. For crates.io-style publication, verify manifest metadata, include and exclude rules, packaged file list, feature combinations, docs expectations, and yank-forward-fix policy.
 8. For Go modules, treat the Git tag as the release. Verify module path, semantic tag, major-version path rules, tag target commit, proxy/cache implications, and module consumer smoke path. Do not move or delete tags as a casual recovery shortcut.
@@ -137,7 +145,7 @@ The release is not done when tests pass locally, a version string changes, or a
 - Remote publication status is classified as not started, prepared, published, verified, failed, yanked, deprecated, superseded, or unknown.
 - Branch, tag, and publication workflow checks are classified separately as green, failing, pending,
   skipped, not applicable, or unknown.
-- User installation, pull, download, or updater smoke test status is known or explicitly reported as skipped.
+- Independent consumer-root installation, pull, download, or updater smoke status through public entrypoints is known with environment evidence, or explicitly reported as skipped.
 - Recovery plan matches the channel's actual permanence and rules.
 
 <!-- mustflow-section: verification -->
@@ -155,7 +163,7 @@ Use configured oneshot command intents when available:
 - `test_release`
 - `mustflow_check`
 
-Prefer configured release, package-inspection, artifact-inspection, install-smoke, updater-smoke, checksum, signature, provenance, or registry-verification intents when the command contract exposes them.
+Prefer configured release, package-inspection, artifact-inspection, install-smoke, updater-smoke, checksum, signature, provenance, or registry-verification intents when the command contract exposes them. A local packed-artifact check may support pre-publish confidence, but it does not satisfy an independent post-publish installation claim.
 
 Do not infer package manager, registry, Docker, Git, Homebrew, or updater commands from project files. If the needed intent is missing, report the missing command contract instead of writing a raw command into the skill or final release procedure.
 
@@ -180,7 +188,7 @@ Do not infer package manager, registry, Docker, Git, Homebrew, or updater comman
 - Artifact contents inspected
 - Remote publication state
 - Branch, tag, and publication check-suite state
-- User installation, download, pull, or updater smoke path result
+- User installation, download, pull, or updater smoke result, including exact immutable version, registry or channel, public entrypoints, package manager, runtime, operating system, retry outcome, and skipped platforms
 - Synchronized version, docs, manifest, workflow, and test surfaces
 - Recovery or rollback classification
 - Command intents run

package/templates/default/manifest.toml

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