mustflow 2.38.0 → 2.58.0

package/README.md

@@ -299,6 +299,9 @@ Automation and agents should use `--json` output or `mf api serve --stdio` JSONL
 ## Command execution policy
 
 Runnable work is declared in `.mustflow/config/commands.toml` so agents do not guess commands.
+New projects start with Bun-backed `test`, `test_related`, and `test_fast` intents so agents can run
+basic verification immediately after `mf init`. Replace those defaults with narrower project-specific
+commands when a repository uses another runner or has a faster related-test entrypoint.
 
 `mf run` executes only commands that meet all these conditions:
 

package/dist/cli/commands/run/executor.js

@@ -3,7 +3,23 @@ import { BoundedOutputBuffer } from '../../../core/bounded-output.js';
 import { createPendingTimeoutTermination, forceTerminateProcessTree, getKillMethod, terminateProcessTree, } from './process-tree.js';
 import { createOutputLimitError, isOutputLimitExceededError, writeOutputLimitTerminationMarker, writeStreamChunk, writeStreamChunkPrefix, } from './output.js';
 const TERMINATION_CONFIRMATION_FALLBACK_MS = 1000;
+function createEmptyOutputSnapshot(maxBytes) {
+    return new BoundedOutputBuffer(maxBytes).toSnapshot();
+}
+function createInvalidExecutableError() {
+    return Object.assign(new Error('Command executable must not be empty'), { code: 'EINVAL' });
+}
 function runSpawnedCommandStreaming(command, cwd, env, timeoutSeconds, killAfterSeconds, maxOutputBytes, stdoutTailBytes, stderrTailBytes, reporter, streamOutput, enforceOutputLimit) {
+    if (command.executable.trim().length === 0) {
+        return Promise.resolve({
+            status: null,
+            signal: null,
+            error: createInvalidExecutableError(),
+            stdout: createEmptyOutputSnapshot(stdoutTailBytes),
+            stderr: createEmptyOutputSnapshot(stderrTailBytes),
+            termination: null,
+        });
+    }
     return new Promise((resolve) => {
         const stdout = new BoundedOutputBuffer(stdoutTailBytes);
         const stderr = new BoundedOutputBuffer(stderrTailBytes);

package/dist/cli/commands/run/process-tree.js

@@ -1,10 +1,13 @@
 import { spawn, spawnSync } from 'node:child_process';
+function windowsTaskkillArgs(pid, signal) {
+    return signal === 'SIGKILL' ? ['/PID', String(pid), '/T', '/F'] : ['/PID', String(pid), '/T'];
+}
 function signalProcessTree(pid, signal) {
     if (!pid || pid <= 0) {
         return;
     }
     if (process.platform === 'win32') {
-        spawnSync('taskkill', ['/PID', String(pid), '/T', '/F'], {
+        spawnSync('taskkill', windowsTaskkillArgs(pid, signal), {
             stdio: 'ignore',
             windowsHide: true,
         });
@@ -35,7 +38,7 @@ function signalProcessTreeNonBlocking(pid, signal) {
         return;
     }
     if (process.platform === 'win32') {
-        const killer = spawn('taskkill', ['/PID', String(pid), '/T', '/F'], {
+        const killer = spawn('taskkill', windowsTaskkillArgs(pid, signal), {
             stdio: 'ignore',
             windowsHide: true,
             detached: true,
@@ -76,7 +79,7 @@ export function forceTerminateProcessTreeNonBlocking(pid) {
     signalProcessTreeNonBlocking(pid, 'SIGKILL');
 }
 export function getKillMethod() {
-    return process.platform === 'win32' ? 'taskkill_process_tree_forced' : 'process_group_sigterm';
+    return process.platform === 'win32' ? 'taskkill_process_tree' : 'process_group_sigterm';
 }
 export function createPendingTimeoutTermination(method, forcedKillAttempted = false) {
     return {

package/dist/cli/commands/verify.js

@@ -206,10 +206,11 @@ async function runVerificationEntriesInParallelChunks(projectRoot, entries, para
         const chunk = entries.slice(index, index + parallelism);
         const batchTracker = startRunWriteBatchTracking(projectRoot, createCommandEnv(projectRoot, { policy: 'minimal', allowlist: [] }));
         const chunkResults = await Promise.all(chunk.map((entry) => runVerificationIntent(entry.intent, lang, verificationPlanId, correlationId, scheduledTestTargets.get(entry.intent) ?? [])));
+        const chunkResultsByIntent = new Map(chunkResults.map((result) => [result.intent, result]));
         const writeDriftByIntent = finishRunWriteBatchTracking(batchTracker, chunk.map((entry) => ({
             intentName: entry.intent,
             declaredPaths: declaredWritePathsForScheduleEntry(entry),
-            observedPaths: observedWriteDriftPaths(chunkResults.find((result) => result.intent === entry.intent)),
+            observedPaths: observedWriteDriftPaths(chunkResultsByIntent.get(entry.intent)),
         })));
         results.push(...chunkResults.map((result) => applyParallelChunkWriteDrift(result, writeDriftByIntent)));
     }
@@ -493,6 +494,7 @@ function createCompletionVerdictForResults(input) {
         failedIntents: input.summary.failed,
         skippedIntents: input.summary.skipped,
         receiptCount: input.results.filter((result) => result.receipt !== null).length,
+        gapCount: input.report.gaps.length,
         sourceAnchorRiskCount: input.sourceAnchorRiskCount,
         scopeDiffRiskCount: input.scopeDiffRiskCount,
         repeatedFailureCount: input.repeatedFailureRisks.length,

package/dist/cli/lib/git-changes.js

@@ -33,7 +33,17 @@ export function readGitChangedFiles(projectRoot) {
             stderr,
         };
     }
-    return { ok: true, files: parseGitStatusOutput(result.stdout) };
+    try {
+        return { ok: true, files: parseGitStatusOutput(result.stdout) };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            message: error instanceof Error ? error.message : String(error),
+            status: result.status,
+            stderr: '',
+        };
+    }
 }
 export function requireGitChangedFiles(projectRoot) {
     const result = readGitChangedFiles(projectRoot);

package/dist/cli/lib/i18n.js

@@ -24,7 +24,7 @@ function interpolate(template, params) {
     });
 }
 export function t(lang, key, params = {}) {
-    return interpolate(MESSAGE_CATALOGS[lang][key] ?? enMessages[key], params);
+    return interpolate(MESSAGE_CATALOGS[lang][key] ?? enMessages[key] ?? key, params);
 }
 export function localeMessage(locale, key, params = {}) {
     return t(isCliLang(locale) ? locale : DEFAULT_CLI_LANG, key, params);

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

@@ -310,10 +310,14 @@ export async function createLocalIndex(projectRoot, options = {}) {
     }
     if (!dryRun && !reusedExisting) {
         const database = new SQL.Database();
-        createSchema(database, capabilities);
-        populateDatabase(database, capabilities, documents, skills, skillRoutes, commandIntents, sourceAnchors, indexedFiles, verificationEvidence, indexMode, sourceScopeHash, includeSource, new Date().toISOString());
-        writeFileInsideWithoutSymlinks(projectRoot, databasePath, database.export());
-        database.close();
+        try {
+            createSchema(database, capabilities);
+            populateDatabase(database, capabilities, documents, skills, skillRoutes, commandIntents, sourceAnchors, indexedFiles, verificationEvidence, indexMode, sourceScopeHash, includeSource, new Date().toISOString());
+            writeFileInsideWithoutSymlinks(projectRoot, databasePath, database.export());
+        }
+        finally {
+            database.close();
+        }
     }
     return {
         schema_version: LOCAL_INDEX_SCHEMA_VERSION,

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

@@ -46,11 +46,25 @@ function populatePathSurfaceReadModel(database) {
         insertPathSurfaceReasons(database, rule.id, 'drift_check', rule.surface.driftChecks);
     }
 }
+function readDocumentTermsByPath(database) {
+    const termsByPath = new Map();
+    for (const row of queryRows(database, 'SELECT document_path, term FROM document_terms ORDER BY document_path, term')) {
+        const documentPath = toSearchString(row.document_path);
+        const term = toSearchString(row.term);
+        const terms = termsByPath.get(documentPath);
+        if (terms) {
+            terms.push(term);
+        }
+        else {
+            termsByPath.set(documentPath, [term]);
+        }
+    }
+    return termsByPath;
+}
 function populateSearchTables(database, capabilities, documents, skills, skillRoutes, commandIntents, sourceAnchors) {
+    const documentTermsByPath = readDocumentTermsByPath(database);
     for (const document of documents) {
-        const documentTerms = queryRows(database, 'SELECT term FROM document_terms WHERE document_path = ? ORDER BY term', [
-            document.path,
-        ]).map((row) => toSearchString(row.term));
+        const documentTerms = documentTermsByPath.get(document.path) ?? [];
         insertSearchNgrams(database, 'document', document.path, [
             document.path,
             document.type,

package/dist/cli/lib/local-index/search-read-model.js

@@ -299,6 +299,7 @@ function collectBoundedDirectSearchDocuments(projectRoot) {
 }
 function searchLocalWorkflowFilesDirectly(projectRoot, databasePath, normalizedQuery, limit, scope) {
     const cacheLayers = readCacheLayerSets(projectRoot);
+    const querySnippetNgrams = buildSearchNgrams([normalizedQuery]);
     const results = [];
     if (scope === 'workflow' || scope === 'all') {
         const documents = collectBoundedDirectSearchDocuments(projectRoot);
@@ -322,7 +323,7 @@ function searchLocalWorkflowFilesDirectly(projectRoot, databasePath, normalizedQ
                 title: document.title,
                 document_type: document.type,
                 ...workflowAuthorityForDocument(document.type),
-                match: getMatchSnippet(fields, normalizedQuery),
+                match: getMatchSnippet(fields, normalizedQuery, querySnippetNgrams),
                 score: scoreMatch(primaryFields, secondaryFields, normalizedQuery),
             }, cacheLayers));
         }
@@ -337,7 +338,7 @@ function searchLocalWorkflowFilesDirectly(projectRoot, databasePath, normalizedQ
                 path: skill.path,
                 title: skill.title,
                 ...skillAuthority(),
-                match: getMatchSnippet(fields, normalizedQuery),
+                match: getMatchSnippet(fields, normalizedQuery, querySnippetNgrams),
                 score: scoreMatch(fields, [], normalizedQuery),
             }, cacheLayers));
         }
@@ -393,6 +394,7 @@ export async function searchLocalIndex(projectRoot, query, options = {}) {
         const stalePaths = getStalePaths(projectRoot, database);
         capabilities = readStoredSearchCapabilities(database);
         const indexedMatches = getIndexedSearchMatches(database, normalizedQuery);
+        const querySnippetNgrams = buildSearchNgrams([normalizedQuery]);
         if (stalePaths.length > 0) {
             throw new Error(`Local mustflow index is stale: ${stalePaths.join(', ')}. Run \`mf index\` before searching. Refresh command: mf index`);
         }
@@ -419,7 +421,7 @@ export async function searchLocalIndex(projectRoot, query, options = {}) {
                     title,
                     document_type: typeValue,
                     ...workflowAuthorityForDocument(typeValue),
-                    match: getMatchSnippet(fields, normalizedQuery),
+                    match: getMatchSnippet(fields, normalizedQuery, querySnippetNgrams),
                     score: scoreIndexedOrTableScan(primaryFields, secondaryFields, normalizedQuery, indexedMatches, indexedMatches.documents, pathValue),
                 }, cacheLayers));
             }
@@ -437,7 +439,7 @@ export async function searchLocalIndex(projectRoot, query, options = {}) {
                     path: pathValue,
                     title,
                     ...skillAuthority(),
-                    match: getMatchSnippet(fields, normalizedQuery),
+                    match: getMatchSnippet(fields, normalizedQuery, querySnippetNgrams),
                     score: scoreIndexedOrTableScan([name, pathValue, title], [], normalizedQuery, indexedMatches, indexedMatches.skills, name),
                 }, cacheLayers));
             }
@@ -468,7 +470,7 @@ export async function searchLocalIndex(projectRoot, query, options = {}) {
                     route_risk: risk,
                     verification_intents: verificationIntents,
                     ...skillAuthority(),
-                    match: getMatchSnippet(fields, normalizedQuery),
+                    match: getMatchSnippet(fields, normalizedQuery, querySnippetNgrams),
                     score: indexedRouteMatch
                         ? Math.max(scoreMatch(primaryFields, secondaryFields, normalizedQuery), 20)
                         : scoreMatch(primaryFields, secondaryFields, normalizedQuery),
@@ -502,7 +504,7 @@ export async function searchLocalIndex(projectRoot, query, options = {}) {
                     effect_paths: effectPaths,
                     effect_modes: effectModes,
                     ...commandIntentAuthority(),
-                    match: getMatchSnippet(fields, normalizedQuery),
+                    match: getMatchSnippet(fields, normalizedQuery, querySnippetNgrams),
                     score: scoreIndexedOrTableScan(primaryFields, secondaryFields, normalizedQuery, indexedMatches, indexedMatches.commandIntents, name),
                 }, cacheLayers));
             }
@@ -532,7 +534,7 @@ export async function searchLocalIndex(projectRoot, query, options = {}) {
                     ...sourceAnchorAuthority(),
                     stale_status: toSearchString(row.status),
                     stale_confidence: Number(row.confidence),
-                    match: getMatchSnippet(fields, normalizedQuery),
+                    match: getMatchSnippet(fields, normalizedQuery, querySnippetNgrams),
                     score: scoreIndexedOrTableScan(primaryFields, secondaryFields, normalizedQuery, indexedMatches, indexedMatches.sourceAnchors, id),
                 }, cacheLayers));
             }

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

@@ -28,13 +28,13 @@ export function buildSearchNgrams(values) {
     }
     return [...grams].sort((left, right) => left.localeCompare(right));
 }
-export function getMatchSnippet(fields, query) {
+export function getMatchSnippet(fields, query, queryNgrams = buildSearchNgrams([query])) {
     const normalized = normalizeSearchText(fields.join(' '));
     const lower = normalized.toLowerCase();
     let start = lower.indexOf(query.toLowerCase());
     let matchLength = query.length;
     if (start === -1) {
-        const [firstGram] = buildSearchNgrams([query]).filter((gram) => lower.includes(gram));
+        const firstGram = queryNgrams.find((gram) => lower.includes(gram));
         if (!firstGram) {
             return truncateSearchMatchSnippet(normalized);
         }

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

@@ -65,12 +65,27 @@ function parseFrontmatter(content) {
     if (!content.startsWith('---')) {
         return {};
     }
-    const end = content.indexOf('\n---', 3);
+    const firstLineEnd = content.indexOf('\n');
+    if (firstLineEnd === -1) {
+        return {};
+    }
+    let end = -1;
+    let lineStart = firstLineEnd + 1;
+    while (lineStart < content.length) {
+        const lineEnd = content.indexOf('\n', lineStart);
+        const nextLineStart = lineEnd === -1 ? content.length : lineEnd + 1;
+        const line = content.slice(lineStart, lineEnd === -1 ? content.length : lineEnd).replace(/\r$/u, '');
+        if (line.trim() === '---') {
+            end = lineStart;
+            break;
+        }
+        lineStart = nextLineStart;
+    }
     if (end === -1) {
         return {};
     }
     const result = {};
-    const rawFrontmatter = content.slice(3, end);
+    const rawFrontmatter = content.slice(firstLineEnd + 1, end);
     for (const line of rawFrontmatter.split(/\r?\n/)) {
         const separatorIndex = line.indexOf(':');
         if (separatorIndex === -1) {

package/dist/cli/lib/mustflow-read.js

@@ -5,7 +5,13 @@ export const MUSTFLOW_TEXT_MAX_BYTES = 1024 * 1024;
 export const MUSTFLOW_TOML_MAX_BYTES = 256 * 1024;
 export const MUSTFLOW_JSON_MAX_BYTES = 1024 * 1024;
 export function mustflowProjectPath(projectRoot, relativePath) {
-    return path.join(projectRoot, ...relativePath.split('/'));
+    const normalizedRoot = path.resolve(projectRoot);
+    const resolvedPath = path.resolve(normalizedRoot, ...relativePath.split('/'));
+    const relative = path.relative(normalizedRoot, resolvedPath);
+    if (relative.startsWith('..') || path.isAbsolute(relative)) {
+        throw new Error(`Path escapes mustflow project root: ${relativePath}`);
+    }
+    return resolvedPath;
 }
 function missingPath(error) {
     return error instanceof Error && 'code' in error && error.code === 'ENOENT';
@@ -14,7 +20,13 @@ export function readMustflowTextFile(projectRoot, relativePath, options = {}) {
     return readUtf8FileInsideWithoutSymlinks(projectRoot, mustflowProjectPath(projectRoot, relativePath), { maxBytes: options.maxBytes ?? MUSTFLOW_TEXT_MAX_BYTES });
 }
 export function readMustflowTextFileResult(projectRoot, relativePath, options = {}) {
-    const filePath = mustflowProjectPath(projectRoot, relativePath);
+    let filePath;
+    try {
+        filePath = mustflowProjectPath(projectRoot, relativePath);
+    }
+    catch (error) {
+        return { ok: false, exists: false, error: error instanceof Error ? error.message : String(error) };
+    }
     if (!existsSync(filePath)) {
         return { ok: false, exists: false, error: null };
     }

package/dist/cli/lib/repo-map.js

@@ -193,6 +193,14 @@ const EXACT_ANCHOR_DESCRIPTIONS = new Map([
     ['.mustflow/docs/agent-workflow.md', 'Shared workflow policy for agent work.'],
     ['.mustflow/skills/INDEX.md', 'Index of available procedural skills.'],
 ]);
+function spawnGitLsFiles(command, args, options) {
+    const result = spawnSync(command, [...args], options);
+    return {
+        status: result.status,
+        error: result.error,
+        stdout: result.stdout,
+    };
+}
 function getStringArray(value) {
     return Array.isArray(value) ? value.filter((entry) => typeof entry === 'string') : [];
 }
@@ -250,8 +258,7 @@ function classifyGitLsFilesFailure(result) {
     return 'error';
 }
 export function discoverGitFilesForRepoMap(projectRoot, options = {}) {
-    const spawnGit = options.spawnGit ??
-        ((command, args, spawnOptions) => spawnSync(command, [...args], spawnOptions));
+    const spawnGit = options.spawnGit ?? spawnGitLsFiles;
     const result = spawnGit('git', ['ls-files', '-z'], {
         cwd: projectRoot,
         encoding: 'utf8',
@@ -413,7 +420,13 @@ function renderDirectoryAnchors(anchors) {
     return lines;
 }
 function hasGitMarker(directoryPath) {
-    return existsSync(path.join(directoryPath, '.git'));
+    try {
+        const marker = lstatSync(path.join(directoryPath, '.git'));
+        return marker.isDirectory() || marker.isFile();
+    }
+    catch {
+        return false;
+    }
 }
 function isRealPathInside(parentRealPath, childRealPath) {
     const relative = path.relative(parentRealPath, childRealPath);

package/dist/cli/lib/templates.js

@@ -304,11 +304,12 @@ export function getTemplateFiles(template, locale = template.manifest.defaultLoc
         const commonPath = path.join(commonRoot, ...relativePath.split('/'));
         const localizedPath = localePath && existsSync(localePath) ? localePath : undefined;
         const fallbackLocalePath = sourceLocalePath && existsSync(sourceLocalePath) ? sourceLocalePath : undefined;
-        const indexSourcePath = localizedPath ?? fallbackLocalePath ?? commonPath;
-        const content = relativePath === '.mustflow/skills/INDEX.md'
-            ? filterSkillIndexContent(readFileSync(indexSourcePath, 'utf8'), selectedSkills)
-            : relativePath === '.mustflow/skills/routes.toml'
-                ? filterSkillRouteMetadataContent(readFileSync(indexSourcePath, 'utf8'), selectedSkills)
+        const commonSourcePath = existsSync(commonPath) ? commonPath : undefined;
+        const selectedSourcePath = localizedPath ?? fallbackLocalePath ?? commonSourcePath;
+        const content = selectedSourcePath && relativePath === '.mustflow/skills/INDEX.md'
+            ? filterSkillIndexContent(readFileSync(selectedSourcePath, 'utf8'), selectedSkills)
+            : selectedSourcePath && relativePath === '.mustflow/skills/routes.toml'
+                ? filterSkillRouteMetadataContent(readFileSync(selectedSourcePath, 'utf8'), selectedSkills)
                 : undefined;
         if (localizedPath) {
             return {
@@ -326,10 +327,10 @@ export function getTemplateFiles(template, locale = template.manifest.defaultLoc
                 content,
             };
         }
-        if (existsSync(commonPath)) {
+        if (commonSourcePath) {
             return {
                 relativePath,
-                sourcePath: commonPath,
+                sourcePath: commonSourcePath,
                 sourceKind: template.manifest.localesRoot ? 'common' : 'legacy',
                 content,
             };

package/dist/cli/lib/validation/constants.js

@@ -172,7 +172,7 @@ export const ALLOWED_TRANSLATION_POLICIES = new Set([
     'update_source_mark_targets_stale',
     'machine_translate_requires_review',
 ]);
-export const RAW_COMMAND_FENCE_PATTERN = /```(?:sh|bash|shell|zsh|powershell|ps1|cmd)\s+[\s\S]*?```/giu;
+export const RAW_COMMAND_FENCE_PATTERN = /```(?:sh|bash|shell|zsh|powershell|ps1|cmd)\s+[\s\S]*?```/iu;
 export const SKILL_COMMAND_PERMISSION_CLAIM_PATTERNS = [
     /\b(?:this\s+skill|skill\s+documents?|skills?)\s+(?:authorizes?|grants?|allows?|permits?)\s+(?:agents?\s+)?(?:to\s+)?(?:run|execute)\b/iu,
     /\b(?:agents?\s+)?(?:may|can|are\s+allowed\s+to|is\s+allowed\s+to|is\s+permitted\s+to|have\s+permission\s+to)\s+(?:run|execute)\s+(?:raw\s+)?(?:shell\s+)?commands?\b/iu,

package/dist/core/active-run-locks.js

@@ -1,7 +1,8 @@
 import { createHash } from 'node:crypto';
-import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync, } from 'node:fs';
+import { existsSync, mkdirSync, readdirSync, renameSync, rmSync, statSync, } from 'node:fs';
 import path from 'node:path';
 import { commandEffectsConflict, normalizeCommandEffects, } from './command-effects.js';
+import { readUtf8FileInsideWithoutSymlinks, writeJsonFileInsideWithoutSymlinks, } from './safe-filesystem.js';
 const ACTIVE_LOCK_SCHEMA_VERSION = '1';
 const ACTIVE_LOCK_KIND = 'active_run_lock';
 const LOCK_ROOT_RELATIVE_PATH = '.mustflow/state/locks';
@@ -9,9 +10,19 @@ const LOCK_MUTEX_STALE_MS = 30_000;
 const LOCK_MUTEX_WAIT_MS = 1_000;
 const LOCK_MUTEX_SLEEP_MS = 25;
 const LOCK_MUTEX_SLEEP_BUFFER = new Int32Array(new SharedArrayBuffer(4));
-const LOCK_MUTEX_RECOVERY_DIRECTORY = 'recovery';
+const LOCK_MUTEX_RECOVERY_DIRECTORY = 'mutex.recovery';
+const ACTIVE_LOCK_RECORD_MAX_BYTES = 256 * 1024;
+const ACTIVE_LOCK_OWNER_MAX_BYTES = 16 * 1024;
 function sleep(milliseconds) {
-    Atomics.wait(LOCK_MUTEX_SLEEP_BUFFER, 0, 0, milliseconds);
+    try {
+        Atomics.wait(LOCK_MUTEX_SLEEP_BUFFER, 0, 0, milliseconds);
+    }
+    catch {
+        const end = Date.now() + milliseconds;
+        while (Date.now() < end) {
+            // Fall back only for short mutex retry delays when Atomics.wait is unavailable on this runtime.
+        }
+    }
 }
 function sha256(value) {
     return createHash('sha256').update(value).digest('hex');
@@ -26,7 +37,7 @@ function activeLockMutexDirectory(projectRoot) {
     return path.join(activeLockRoot(projectRoot), 'mutex');
 }
 function activeLockMutexRecoveryDirectory(mutex) {
-    return path.join(mutex, LOCK_MUTEX_RECOVERY_DIRECTORY);
+    return path.join(path.dirname(mutex), LOCK_MUTEX_RECOVERY_DIRECTORY);
 }
 function normalizeEffect(effect) {
     return {
@@ -121,9 +132,16 @@ function readActiveRecords(projectRoot) {
         return [];
     }
     const records = [];
-    for (const name of readdirSync(directory).filter((entry) => entry.endsWith('.json')).sort()) {
+    const entries = readdirSync(directory, { withFileTypes: true })
+        .filter((entry) => entry.isFile() && entry.name.endsWith('.json'))
+        .map((entry) => entry.name)
+        .sort();
+    for (const name of entries) {
         try {
-            const record = parseRecord(JSON.parse(readFileSync(path.join(directory, name), 'utf8')));
+            const recordPath = path.join(directory, name);
+            const record = parseRecord(JSON.parse(readUtf8FileInsideWithoutSymlinks(directory, recordPath, {
+                maxBytes: ACTIVE_LOCK_RECORD_MAX_BYTES,
+            })));
             if (record) {
                 records.push(record);
             }
@@ -153,9 +171,19 @@ function conflictDetail(current, active) {
 }
 function findConflicts(intentName, effects, records) {
     const conflicts = [];
+    const effectsByLock = new Map();
+    for (const effect of effects) {
+        const existing = effectsByLock.get(effect.lock);
+        if (existing) {
+            existing.push(effect);
+        }
+        else {
+            effectsByLock.set(effect.lock, [effect]);
+        }
+    }
     for (const record of records) {
         for (const activeEffect of commandEffectsFromRecord(record)) {
-            for (const effect of effects) {
+            for (const effect of effectsByLock.get(activeEffect.lock) ?? []) {
                 if (!commandEffectsConflict(effect, activeEffect)) {
                     continue;
                 }
@@ -198,7 +226,9 @@ function createRecord(projectRoot, intentName, effects, commandHash) {
 }
 function readMutexOwner(ownerPath) {
     try {
-        const owner = JSON.parse(readFileSync(ownerPath, 'utf8'));
+        const owner = JSON.parse(readUtf8FileInsideWithoutSymlinks(path.dirname(ownerPath), ownerPath, {
+            maxBytes: ACTIVE_LOCK_OWNER_MAX_BYTES,
+        }));
         if (typeof owner.started_at !== 'string' || typeof owner.token !== 'string') {
             return null;
         }
@@ -249,6 +279,24 @@ function beginMutexRecovery(mutex) {
         rmSync(recoveryPath, { recursive: true, force: true });
     };
 }
+function moveMutexAsideForRecovery(mutex, owner) {
+    const tokenSource = owner ? `${owner.pid}:${owner.startedAt}:${owner.token}` : `${process.pid}:${Date.now()}:${process.hrtime.bigint()}`;
+    const stalePath = path.join(path.dirname(mutex), `mutex.stale-${sha256(tokenSource)}`);
+    try {
+        rmSync(stalePath, { recursive: true, force: true });
+        renameSync(mutex, stalePath);
+        return stalePath;
+    }
+    catch {
+        try {
+            rmSync(stalePath, { recursive: true, force: true });
+        }
+        catch {
+            // Best-effort cleanup for a failed stale mutex move.
+        }
+        return null;
+    }
+}
 function recoverStaleMutexWithOwner(mutex, ownerPath, staleOwner) {
     const releaseRecovery = beginMutexRecovery(mutex);
     if (!releaseRecovery) {
@@ -258,7 +306,11 @@ function recoverStaleMutexWithOwner(mutex, ownerPath, staleOwner) {
         if (!sameMutexOwner(staleOwner, readMutexOwner(ownerPath)) || !mutexOwnerIsStale(staleOwner)) {
             return false;
         }
-        rmSync(mutex, { recursive: true, force: true });
+        const stalePath = moveMutexAsideForRecovery(mutex, staleOwner);
+        if (!stalePath) {
+            return false;
+        }
+        rmSync(stalePath, { recursive: true, force: true });
         return true;
     }
     finally {
@@ -275,7 +327,11 @@ function recoverStaleMutexWithoutOwner(mutex) {
         if (readMutexOwner(ownerPath) !== null) {
             return false;
         }
-        rmSync(mutex, { recursive: true, force: true });
+        const stalePath = moveMutexAsideForRecovery(mutex, null);
+        if (!stalePath) {
+            return false;
+        }
+        rmSync(stalePath, { recursive: true, force: true });
         return true;
     }
     catch {
@@ -291,13 +347,13 @@ function acquireMutex(projectRoot) {
     const ownerPath = path.join(mutex, 'owner.json');
     const ownerToken = sha256(`${process.pid}:${Date.now()}:${process.hrtime.bigint()}`);
     mkdirSync(root, { recursive: true });
-    let startedAt = Date.now();
+    const startedAt = Date.now();
     while (true) {
         try {
             mkdirSync(mutex);
             const ownerRecord = { pid: process.pid, started_at: new Date().toISOString(), token: ownerToken };
             try {
-                writeFileSync(ownerPath, JSON.stringify(ownerRecord, null, 2));
+                writeJsonFileInsideWithoutSymlinks(root, ownerPath, ownerRecord);
             }
             catch (error) {
                 rmSync(mutex, { recursive: true, force: true });
@@ -305,7 +361,9 @@ function acquireMutex(projectRoot) {
             }
             return () => {
                 try {
-                    const owner = JSON.parse(readFileSync(ownerPath, 'utf8'));
+                    const owner = JSON.parse(readUtf8FileInsideWithoutSymlinks(path.dirname(ownerPath), ownerPath, {
+                        maxBytes: ACTIVE_LOCK_OWNER_MAX_BYTES,
+                    }));
                     if (Number(owner.pid) === ownerRecord.pid && owner.token === ownerRecord.token) {
                         rmSync(mutex, { recursive: true, force: true });
                     }
@@ -323,7 +381,6 @@ function acquireMutex(projectRoot) {
                 const owner = readMutexOwner(ownerPath);
                 if (owner) {
                     if (mutexOwnerIsStale(owner) && recoverStaleMutexWithOwner(mutex, ownerPath, owner)) {
-                        startedAt = Date.now();
                         continue;
                     }
                 }
@@ -343,12 +400,10 @@ function acquireMutex(projectRoot) {
                     try {
                         const mutexStat = statSync(mutex);
                         if (Date.now() - mutexStat.mtimeMs > LOCK_MUTEX_STALE_MS && recoverStaleMutexWithoutOwner(mutex)) {
-                            startedAt = Date.now();
                             continue;
                         }
                     }
                     catch {
-                        startedAt = Date.now();
                         continue;
                     }
                 }
@@ -362,7 +417,8 @@ export function inspectActiveRunLocks(projectRoot, contract, intentName) {
     const effects = normalizeCommandEffects(projectRoot, contract, intentName);
     const records = readActiveRecords(projectRoot);
     const staleRecords = records.map(staleRecordFor).filter((record) => record !== null);
-    const liveRecords = records.filter((record) => !staleRecords.some((stale) => stale.runId === record.run_id));
+    const staleRecordIds = new Set(staleRecords.map((stale) => stale.runId));
+    const liveRecords = records.filter((record) => !staleRecordIds.has(record.run_id));
     return {
         conflicts: findConflicts(intentName, effects, liveRecords),
         staleRecords,
@@ -371,7 +427,8 @@ export function inspectActiveRunLocks(projectRoot, contract, intentName) {
 export function listActiveRunLocks(projectRoot) {
     const records = readActiveRecords(projectRoot);
     const staleRecords = records.map(staleRecordFor).filter((record) => record !== null);
-    const activeRecords = records.filter((record) => !staleRecords.some((stale) => stale.runId === record.run_id));
+    const staleRecordIds = new Set(staleRecords.map((stale) => stale.runId));
+    const activeRecords = records.filter((record) => !staleRecordIds.has(record.run_id));
     return {
         records,
         activeRecords,
@@ -404,14 +461,15 @@ export function acquireActiveRunLock(projectRoot, contract, intentName, options
                 removeRecord(projectRoot, staleRecord);
             }
         }
-        const liveRecords = records.filter((record) => !staleRecords.some((stale) => stale.runId === record.run_id));
+        const staleRecordIds = new Set(staleRecords.map((stale) => stale.runId));
+        const liveRecords = records.filter((record) => !staleRecordIds.has(record.run_id));
         const conflicts = findConflicts(intentName, effects, liveRecords);
         if (conflicts.length > 0) {
             return { ok: false, conflicts, recoveredStaleRecords: staleRecords };
         }
         const record = createRecord(projectRoot, intentName, effects, options.commandHash ?? null);
         const recordPath = activeLockRecordPath(projectRoot, record.run_id);
-        writeFileSync(recordPath, JSON.stringify(record, null, 2));
+        writeJsonFileInsideWithoutSymlinks(activeLockDirectory(projectRoot), recordPath, record);
         let released = false;
         return {
             ok: true,

package/dist/core/change-classification.js

@@ -41,6 +41,10 @@ function parseGitPorcelainStatusOutput(output) {
             paths.push(filePath);
         }
         if (status.includes('R') || status.includes('C')) {
+            const targetPath = normalizePorcelainStatusPath(parts[index + 1] ?? '');
+            if (targetPath.length > 0) {
+                paths.push(targetPath);
+            }
             index += 1;
         }
     }