mustflow 2.38.0 → 2.58.0

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.38.0",
+  "version": "2.58.0",
   "description": "Agent workflow documents and CLI for mustflow repository roots.",
   "type": "module",
   "license": "MIT-0",

package/templates/default/common/.mustflow/config/commands.toml

@@ -25,24 +25,48 @@ description = "Generated mustflow SQLite local index under .mustflow/cache/."
 concurrency = "exclusive_writer"
 
 [intents.test]
-status = "unknown"
-description = "Run the test suite."
-reason = "This repository has not declared its test command yet."
-agent_action = "do_not_guess_report_missing"
-required_after = ["code_change", "behavior_change"]
+status = "configured"
+lifecycle = "oneshot"
+run_policy = "agent_allowed"
+description = "Run the default Bun test suite."
+argv = ["bun", "test"]
+cwd = "."
+timeout_seconds = 600
+stdin = "closed"
+success_exit_codes = [0]
+writes = []
+network = false
+destructive = false
+required_after = ["release_risk", "cross_cutting_code_change", "full_test_request"]
 
 [intents.test_related]
-status = "unknown"
-description = "Run tests directly related to changed files."
-reason = "This repository has not declared its related-test command yet."
-agent_action = "do_not_guess_report_missing"
+status = "configured"
+lifecycle = "oneshot"
+run_policy = "agent_allowed"
+description = "Run the default Bun test suite for changed code when no narrower test command exists."
+argv = ["bun", "test"]
+cwd = "."
+timeout_seconds = 600
+stdin = "closed"
+success_exit_codes = [0]
+writes = []
+network = false
+destructive = false
 required_after = ["code_change", "behavior_change", "test_change"]
 
 [intents.test_fast]
-status = "unknown"
-description = "Run the fast test baseline."
-reason = "This repository has not declared its fast-test command yet."
-agent_action = "do_not_guess_report_missing"
+status = "configured"
+lifecycle = "oneshot"
+run_policy = "agent_allowed"
+description = "Run the default Bun test suite as the fast baseline until the repository narrows it."
+argv = ["bun", "test"]
+cwd = "."
+timeout_seconds = 600
+stdin = "closed"
+success_exit_codes = [0]
+writes = []
+network = false
+destructive = false
 required_after = ["low_risk_code_change", "copy_change", "i18n_change", "unknown_change"]
 
 [intents.test_coverage]
@@ -57,7 +81,7 @@ status = "unknown"
 description = "Inspect stale or redundant test candidates."
 reason = "This repository has not declared its test-audit command yet."
 agent_action = "do_not_guess_report_missing"
-required_after = ["test_change", "behavior_removed", "public_api_change"]
+required_after = []
 
 [intents.test_release]
 status = "unknown"
@@ -85,7 +109,7 @@ status = "unknown"
 description = "Run linting or static analysis."
 reason = "This repository has not declared its lint command yet."
 agent_action = "do_not_guess_report_missing"
-required_after = ["code_change", "style_change"]
+required_after = []
 
 [intents.line_endings_check]
 status = "configured"