mustflow 2.39.1 → 2.58.1

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;
         }
     }

package/dist/core/command-contract-rules.js

@@ -41,7 +41,7 @@ export const LONG_RUNNING_COMMAND_TEXT_PATTERNS = [
     /\bturbo\s+dev\b/iu,
     /\btsx\s+(?:watch|--watch|-w)\b/iu,
     /\bcargo\s+(?:watch|tauri\s+dev)\b/iu,
-    /\bzig\s+build\b(?=.*(?:--watch|-w|\bwatch\b))/iu,
+    /\bzig\s+build\b(?=[^\r\n;&|]*?(?:--watch(?:=|\b)|-w\b|\bwatch\b))/iu,
     /\btauri\s+dev\b/iu,
     /\bgh\s+(?:run\s+watch|codespace\s+ssh|codespace\s+logs\b.*(?:--follow|-f))\b/iu,
     /\bdeno\s+(?:serve|task\s+(?:dev|start|serve|watch|preview)|run\b.*(?:--watch|-w))\b/iu,

package/dist/core/command-contract-validation.js

@@ -546,6 +546,6 @@ export function validateCommandContractStrictDefaults(projectRoot, commandsToml)
     issues.push(...validateCommandEnvInheritanceWarnings(commandsToml));
     issues.push(...validateProjectLocalBinWarnings(projectRoot, commandsToml));
     issues.push(...validateCommandEffects(projectRoot, commandsToml));
-    issues.push(...validateCommandEffectLockWarnings(commandsToml));
+    issues.push(...validateCommandEffectLockWarnings(projectRoot, commandsToml));
     return issues;
 }

package/dist/core/command-cwd.js

@@ -13,10 +13,21 @@ export function resolveSafeProjectCwd(projectRoot, rawCwd) {
     const cwd = rawCwd ?? '.';
     const resolved = path.resolve(projectRoot, cwd);
     const rootRealPath = realpathSync.native(projectRoot);
-    if (!existsSync(resolved) || !statSync(resolved).isDirectory()) {
+    try {
+        if (!existsSync(resolved) || !statSync(resolved).isDirectory()) {
+            throw new Error();
+        }
+    }
+    catch {
+        throw new Error(`Intent cwd must stay inside the current root and resolve to an existing directory: ${cwd}`);
+    }
+    let cwdRealPath;
+    try {
+        cwdRealPath = realpathSync.native(resolved);
+    }
+    catch {
         throw new Error(`Intent cwd must stay inside the current root and resolve to an existing directory: ${cwd}`);
     }
-    const cwdRealPath = realpathSync.native(resolved);
     if (!isInsideOrEqual(rootRealPath, cwdRealPath)) {
         throw new Error(`Intent cwd must stay inside the current root and resolve to an existing directory: ${cwd}`);
     }

package/dist/core/command-effects.js

@@ -161,11 +161,16 @@ export function validateCommandEffects(projectRoot, commandsToml) {
     }
     return issues;
 }
-export function validateCommandEffectLockWarnings(commandsToml) {
+export function validateCommandEffectLockWarnings(projectRoot, commandsToml) {
     const issues = [];
     if (!commandsToml || !isRecord(commandsToml.intents)) {
         return issues;
     }
+    const commandContract = {
+        defaults: isRecord(commandsToml.defaults) ? commandsToml.defaults : {},
+        intents: commandsToml.intents,
+        resources: isRecord(commandsToml.resources) ? commandsToml.resources : {},
+    };
     const lockToIntents = new Map();
     for (const [intentName, intent] of Object.entries(commandsToml.intents)) {
         if (!isRecord(intent)) {
@@ -177,9 +182,22 @@ export function validateCommandEffectLockWarnings(commandsToml) {
             Array.isArray(intent.effects)) {
             continue;
         }
-        for (const rawPath of readStringArray(intent, 'writes') ?? []) {
-            const lock = pathLockKey(rawPath);
-            lockToIntents.set(lock, [...(lockToIntents.get(lock) ?? []), intentName]);
+        let effects;
+        try {
+            effects = normalizeCommandEffects(projectRoot, commandContract, intentName).filter((effect) => effect.source === 'writes');
+        }
+        catch {
+            continue;
+        }
+        for (const effect of effects) {
+            const lock = effect.lock;
+            const intents = lockToIntents.get(lock);
+            if (intents) {
+                intents.push(intentName);
+            }
+            else {
+                lockToIntents.set(lock, [intentName]);
+            }
         }
     }
     for (const [lock, intents] of lockToIntents) {

package/dist/core/command-env.js

@@ -105,14 +105,16 @@ function removeProjectLocalBinFromPath(env, projectRoot) {
     const pathKey = getPathEnvKey(env);
     const currentPath = env[pathKey];
     if (!currentPath) {
-        return env;
+        return { ...env };
     }
     const localBinPath = path.join(projectRoot, 'node_modules', '.bin');
-    env[pathKey] = currentPath
-        .split(path.delimiter)
-        .filter((entry) => entry.length > 0 && !sameResolvedPath(entry, localBinPath))
-        .join(path.delimiter);
-    return env;
+    return {
+        ...env,
+        [pathKey]: currentPath
+            .split(path.delimiter)
+            .filter((entry) => entry.length > 0 && !sameResolvedPath(entry, localBinPath))
+            .join(path.delimiter),
+    };
 }
 export function resolveCommandEnv(contract, intent) {
     const policy = readEnvPolicy(intent) ?? readEnvPolicy(contract.defaults) ?? DEFAULT_COMMAND_ENV_POLICY;

package/dist/core/command-preconditions.js

@@ -84,6 +84,10 @@ function globToRegExp(pattern) {
             expression += '[^/]*';
             continue;
         }
+        if (character === '?') {
+            expression += '[^/]';
+            continue;
+        }
         expression += escapeRegExp(character);
     }
     return new RegExp(`${expression}$`, 'u');
@@ -219,10 +223,32 @@ function evaluateArtifactFreshness(projectRoot, declaration, satisfyIntent, cont
             satisfyIntent,
         };
     }
-    const artifactMtime = statSync(artifactPath).mtimeMs;
+    let artifactMtime;
+    try {
+        artifactMtime = statSync(artifactPath).mtimeMs;
+    }
+    catch {
+        return {
+            kind: declaration.kind,
+            label: declaration.label,
+            status: 'missing',
+            detail: `artifact "${artifact}" is missing.`,
+            path: null,
+            artifact,
+            sources: declaration.sources,
+            newestSource: null,
+            satisfyIntent,
+        };
+    }
     let newest = null;
     for (const source of sourceFiles) {
-        const mtime = statSync(path.join(projectRoot, ...source.split('/'))).mtimeMs;
+        let mtime;
+        try {
+            mtime = statSync(path.join(projectRoot, ...source.split('/'))).mtimeMs;
+        }
+        catch {
+            continue;
+        }
         if (!newest || mtime > newest.mtime) {
             newest = { source, mtime };
         }

package/dist/core/completion-verdict.js

@@ -219,7 +219,7 @@ export function createVerifyCompletionVerdict(input) {
             failed_intents: normalizedInput.failedIntents,
             skipped_intents: normalizedInput.skippedIntents,
             receipt_count: normalizedInput.receiptCount,
-            gap_count: normalizedInput.skippedIntents,
+            gap_count: normalizedInput.gapCount ?? 0,
             source_anchor_risk_count: normalizedInput.sourceAnchorRiskCount ?? 0,
             scope_diff_risk_count: normalizedInput.scopeDiffRiskCount ?? 0,
             repeated_failure_count: normalizedInput.repeatedFailureCount ?? 0,

package/dist/core/line-endings.js

@@ -21,6 +21,7 @@ function gitList(projectRoot, args) {
         encoding: 'buffer',
         env: createCommandEnv(projectRoot, { policy: 'minimal', allowlist: [] }),
         stdio: ['ignore', 'pipe', 'pipe'],
+        timeout: 30_000,
         windowsHide: true,
     });
     if (result.status !== 0) {
@@ -71,19 +72,22 @@ function detectLineEnding(buffer) {
     return crlfCount === lfCount ? 'crlf' : 'mixed';
 }
 function normalizeLf(buffer) {
-    const bytes = [];
+    const bytes = Buffer.allocUnsafe(buffer.length);
+    let writeIndex = 0;
     for (let index = 0; index < buffer.length; index += 1) {
         const byte = buffer[index];
         if (byte === 0x0d) {
-            bytes.push(0x0a);
+            bytes[writeIndex] = 0x0a;
+            writeIndex += 1;
             if (buffer[index + 1] === 0x0a) {
                 index += 1;
             }
             continue;
         }
-        bytes.push(byte);
+        bytes[writeIndex] = byte;
+        writeIndex += 1;
     }
-    return Buffer.from(bytes);
+    return bytes.subarray(0, writeIndex);
 }
 export function inspectLineEndings(projectRoot, mode, options = {}) {
     const root = path.resolve(projectRoot);

package/dist/core/safe-filesystem.js

@@ -14,7 +14,15 @@ function tempFilePath(targetPath) {
     return path.join(path.dirname(targetPath), `.${path.basename(targetPath)}.${suffix}.tmp`);
 }
 function sleep(milliseconds) {
-    Atomics.wait(WRITE_SLEEP_BUFFER, 0, 0, milliseconds);
+    try {
+        Atomics.wait(WRITE_SLEEP_BUFFER, 0, 0, milliseconds);
+    }
+    catch {
+        const end = Date.now() + milliseconds;
+        while (Date.now() < end) {
+            // Fall back only for short retry delays when Atomics.wait is unavailable on this runtime.
+        }
+    }
 }
 function isRetryableWindowsRenameError(error) {
     if (process.platform !== 'win32' || !error || typeof error !== 'object' || !('code' in error)) {

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

@@ -131,7 +131,13 @@ export function validateSourceAnchorsInProject(projectRoot) {
     const anchorsById = new Map();
     for (const relativePath of sourceFiles) {
         const absolutePath = path.join(projectRoot, ...relativePath.split('/'));
-        const content = readFileSync(absolutePath, 'utf8');
+        let content;
+        try {
+            content = readFileSync(absolutePath, 'utf8');
+        }
+        catch {
+            continue;
+        }
         const anchors = parseSourceAnchorsInContent(relativePath, content);
         issues.push(...validateSourceAnchorDensity(relativePath, content, anchors));
         for (const anchor of anchors) {

package/dist/core/source-anchors.js

@@ -321,10 +321,16 @@ export function collectSourceAnchorSummaries(projectRoot) {
     const anchors = [];
     for (const relativePath of listSourceAnchorFiles(projectRoot)) {
         const filePath = path.join(projectRoot, ...relativePath.split('/'));
-        if (!existsSync(filePath) || !statSync(filePath).isFile()) {
+        let content;
+        try {
+            if (!existsSync(filePath) || !statSync(filePath).isFile()) {
+                continue;
+            }
+            content = readFileSync(filePath, 'utf8');
+        }
+        catch {
             continue;
         }
-        const content = readFileSync(filePath, 'utf8');
         for (const anchor of parseSourceAnchorsInContent(relativePath, content)) {
             if (!anchor.idValid || sourceAnchorTextContainsSecretLike(anchor.rawText)) {
                 continue;

package/dist/core/verification-scheduler.js

@@ -19,12 +19,18 @@ function toScheduleEffect(effect) {
 function isObject(value) {
     return !!value && typeof value === 'object';
 }
+function isMissingPathError(error) {
+    return error instanceof Error && 'code' in error && error.code === 'ENOENT';
+}
 function readJsonFile(projectRoot, filePath) {
     try {
         return JSON.parse(readUtf8FileInsideWithoutSymlinks(projectRoot, filePath, { maxBytes: MUSTFLOW_JSON_MAX_BYTES }));
     }
-    catch {
-        return null;
+    catch (error) {
+        if (isMissingPathError(error)) {
+            return null;
+        }
+        throw error;
     }
 }
 function getUndeclaredWriteIntent(value) {

package/package.json

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