mustflow 2.22.1 → 2.22.2

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

@@ -76,7 +76,7 @@ export function forceTerminateProcessTreeNonBlocking(pid) {
     signalProcessTreeNonBlocking(pid, 'SIGKILL');
 }
 export function getKillMethod() {
-    return process.platform === 'win32' ? 'taskkill_process_tree' : 'process_group_sigterm';
+    return process.platform === 'win32' ? 'taskkill_process_tree_forced' : 'process_group_sigterm';
 }
 export function createPendingTimeoutTermination(method, forcedKillAttempted = false) {
     return {

package/dist/cli/commands/run.js

@@ -78,6 +78,12 @@ function reportRunPlanFailure(plan, reporter, lang) {
     }
     reporter.stderr(renderCliError(message, 'mf help commands', lang));
 }
+function writeLatestProfile(profiler, options, input) {
+    if (options.writeLatestProfile === false) {
+        return;
+    }
+    profiler.writeLatest(input);
+}
 export function getRunHelp(lang = 'en') {
     return renderHelp({
         usage: 'mf run <intent> [options]',
@@ -151,7 +157,7 @@ export async function runRun(args, reporter, lang = 'en', options = {}) {
                 reporter.stdout(renderRunPreviewText(plan, previewMode, lang));
             }
         });
-        profiler.writeLatest({
+        writeLatestProfile(profiler, options, {
             projectRoot,
             intent: intentName,
             status: plan.ok ? 'previewed' : 'blocked',
@@ -161,7 +167,7 @@ export async function runRun(args, reporter, lang = 'en', options = {}) {
     }
     if (!plan.ok) {
         reportRunPlanFailure(plan, reporter, lang);
-        profiler.writeLatest({
+        writeLatestProfile(profiler, options, {
             projectRoot,
             intent: intentName,
             status: 'blocked',
@@ -221,8 +227,10 @@ export async function runRun(args, reporter, lang = 'en', options = {}) {
     if (options.writeLatestReceipt !== false) {
         profiler.measure('receipt_write', () => writeRunReceipt(projectRoot, receipt));
     }
-    profiler.measure('performance_history_write', () => recordRunPerformanceHistory(projectRoot, receipt));
-    profiler.writeLatest({
+    if (options.recordPerformanceHistory !== false) {
+        profiler.measure('performance_history_write', () => recordRunPerformanceHistory(projectRoot, receipt));
+    }
+    writeLatestProfile(profiler, options, {
         projectRoot,
         intent: intentName,
         status: runStatus,

package/dist/cli/commands/verify.js

@@ -632,6 +632,8 @@ async function runVerificationIntent(intent, lang, verificationPlanId, testTarge
     const output = createBufferedOutput();
     const exitCode = await runRun([intent, '--json'], output.reporter, lang, {
         writeLatestReceipt: false,
+        writeLatestProfile: false,
+        recordPerformanceHistory: false,
         testTargets,
         additionalDeclaredWritePaths,
     });

package/dist/cli/lib/run-plan.js

@@ -5,13 +5,10 @@ import { resolveCommandEnv } from '../../core/command-env.js';
 import { evaluateCommandIntentEligibility, } from '../../core/command-intent-eligibility.js';
 import { isRecord, readPositiveInteger, readString, readStringArray, } from '../../core/config-loading.js';
 import { DEFAULT_COMMAND_MAX_OUTPUT_BYTES, COMMAND_OUTPUT_LIMIT_SCOPE, MAX_COMMAND_OUTPUT_BYTES, commandMaxOutputBytesLimitMessage, } from '../../core/command-output-limits.js';
+import { normalizeSuccessExitCodes } from '../../core/success-exit-codes.js';
 import { t } from './i18n.js';
 function getSuccessExitCodes(intent) {
-    const value = intent.success_exit_codes;
-    if (!Array.isArray(value) || value.length === 0 || value.some((entry) => !Number.isInteger(entry))) {
-        return [0];
-    }
-    return value.map(Number);
+    return normalizeSuccessExitCodes(intent.success_exit_codes);
 }
 function readBoolean(intent, key) {
     const value = intent[key];

package/dist/core/check-issues.js

@@ -10,7 +10,10 @@ const CHECK_ISSUE_ID_RULES = [
     ['mustflow.command_contract.executable_source_missing', /^Configured intent [^\s]+ must define argv or mode = "shell" with cmd$/u],
     ['mustflow.command_contract.shell_background_pattern', /^Shell intent [^\s]+ contains a blocked long-running or background pattern$/u],
     ['mustflow.command_contract.long_running_command_pattern', /^Intent [^\s]+ contains a blocked long-running or background command pattern$/u],
-    ['mustflow.command_contract.success_exit_codes_invalid', /^\[commands\.intents\.[^\]]+\]\.success_exit_codes must be an integer array$/u],
+    [
+        'mustflow.command_contract.success_exit_codes_invalid',
+        /^\[commands\.intents\.[^\]]+\]\.success_exit_codes must be a non-empty integer array with values from 0 through 255$/u,
+    ],
     ['mustflow.command_contract.effects_invalid', /^(?:Strict: )?(?:\[commands\.(?:resources|intents\.[^\]]+\.effects)[^\]]*\]|Command effect for intent [^\s]+ must define path, paths, or lock)/u],
     ['mustflow.command_contract.effect_path_escape', /^Strict: Command effect path must stay inside the current root:/u],
     ['mustflow.command_contract.shared_writes_without_effects', /^Strict warning: configured agent-runnable intents .+ share path:.+ through writes without explicit effects or resource locks$/u],

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

@@ -11,9 +11,15 @@ const INTERPRETER_EVALUATION_FLAGS = new Map([
     ['ruby', new Set(['-e'])],
     ['perl', new Set(['-e'])],
 ]);
+const INTERPRETER_LONG_RUNNING_MODULES = new Map([
+    ['python', new Set(['http.server', 'simplehttpserver'])],
+    ['python3', new Set(['http.server', 'simplehttpserver'])],
+    ['py', new Set(['http.server', 'simplehttpserver'])],
+]);
 const PACKAGE_SCRIPT_RUNNERS = new Set(['bun', 'npm', 'pnpm', 'yarn']);
 const LONG_RUNNING_PACKAGE_SCRIPTS = new Set(['dev', 'start', 'serve', 'watch', 'preview']);
 const LONG_RUNNING_EXECUTABLES = new Set(['nodemon', 'pm2', 'serve', 'http-server', 'live-server', 'webpack-dev-server']);
+const PACKAGE_EXEC_RUNNERS = new Set(['npx', 'bunx']);
 const ATTACHED_EVALUATION_FLAGS = new Set(['-command', '-commandwithargs']);
 export const BACKGROUND_SHELL_PATTERNS = [
     /(?:^|[^&])&(?!&)\s*$/u,
@@ -28,6 +34,12 @@ export const BACKGROUND_SHELL_PATTERNS = [
 ];
 export const LONG_RUNNING_COMMAND_TEXT_PATTERNS = [
     /\b(?:npm|pnpm|bun|yarn)\s+(?:run\s+)?(?:dev|start|serve|watch|preview)\b/iu,
+    /\b(?:npx|bunx)\s+(?:-[^\s]+\s+)*(?:vite|nodemon|pm2|serve|http-server|live-server|webpack-dev-server)\b/iu,
+    /\b(?:npm|pnpm|yarn)\s+(?:exec|x|dlx)\s+(?:-[^\s]+\s+)*(?:vite|nodemon|pm2|serve|http-server|live-server|webpack-dev-server)\b/iu,
+    /\bnext\s+(?:dev|start)\b/iu,
+    /\bturbo\s+dev\b/iu,
+    /\btsx\s+(?:watch|--watch|-w)\b/iu,
+    /\b(?:python|python3|py)\s+-m\s+(?:http\.server|SimpleHTTPServer)\b/u,
     /\b(?:nohup|disown)\b/iu,
     /(?:^|[^&])&(?!&)\s*$/u,
     /\bsetInterval\s*\(/u,
@@ -85,22 +97,35 @@ function readPackageScriptName(command, args) {
     }
     return null;
 }
-function argvHasBlockedLongRunningPattern(argv) {
-    const [rawCommand = '', ...args] = argv;
-    const command = normalizeExecutableName(rawCommand);
-    const shellPayload = SHELL_WRAPPER_COMMANDS.has(command) ? findFlagPayload(argv, SHELL_EVALUATION_FLAGS) : null;
-    if (shellPayload && (shellCommandHasBlockedBackgroundPattern(shellPayload) || commandTextHasLongRunningPattern(shellPayload))) {
-        return `shell wrapper payload contains a blocked long-running or background pattern: ${shellPayload}`;
+function findFirstNonOptionArgument(args) {
+    for (let index = 0; index < args.length; index += 1) {
+        const argument = args[index] ?? '';
+        if (argument === '--') {
+            const value = args[index + 1];
+            return value ? { value, index: index + 1 } : null;
+        }
+        if (argument.length > 0 && !argument.startsWith('-')) {
+            return { value: argument, index };
+        }
     }
-    const interpreterFlags = INTERPRETER_EVALUATION_FLAGS.get(command);
-    const interpreterPayload = interpreterFlags ? findFlagPayload(argv, interpreterFlags) : null;
-    if (interpreterPayload && commandTextHasLongRunningPattern(interpreterPayload)) {
-        return `interpreter evaluation payload contains a blocked long-running pattern: ${interpreterPayload}`;
+    return null;
+}
+function readPackageExecCommand(command, args) {
+    if (PACKAGE_EXEC_RUNNERS.has(command)) {
+        const target = findFirstNonOptionArgument(args);
+        return target ? { command: normalizeExecutableName(target.value), args: args.slice(target.index + 1) } : null;
     }
-    const packageScriptName = readPackageScriptName(command, args);
-    if (packageScriptName && LONG_RUNNING_PACKAGE_SCRIPTS.has(packageScriptName)) {
-        return `package-manager script "${packageScriptName}" is commonly long-running`;
+    if (command === 'npm' && ['exec', 'x'].includes(args[0] ?? '')) {
+        const target = findFirstNonOptionArgument(args.slice(1));
+        return target ? { command: normalizeExecutableName(target.value), args: args.slice(target.index + 2) } : null;
+    }
+    if ((command === 'pnpm' || command === 'yarn') && ['exec', 'dlx'].includes(args[0] ?? '')) {
+        const target = findFirstNonOptionArgument(args.slice(1));
+        return target ? { command: normalizeExecutableName(target.value), args: args.slice(target.index + 2) } : null;
     }
+    return null;
+}
+function longRunningExecutableDetail(command, args) {
     if (LONG_RUNNING_EXECUTABLES.has(command)) {
         return `executable "${command}" is commonly long-running`;
     }
@@ -116,8 +141,45 @@ function argvHasBlockedLongRunningPattern(argv) {
     if (command === 'tsc' && (args.includes('--watch') || args.includes('-w'))) {
         return 'tsc watch mode is long-running';
     }
+    if (command === 'tsx' && ['watch', '--watch', '-w'].includes(args[0] ?? '')) {
+        return `tsx ${args[0]} is commonly long-running`;
+    }
+    if (command === 'turbo' && args[0] === 'dev') {
+        return 'turbo dev is commonly long-running';
+    }
     return null;
 }
+function argvHasBlockedLongRunningPattern(argv) {
+    const [rawCommand = '', ...args] = argv;
+    const command = normalizeExecutableName(rawCommand);
+    const shellPayload = SHELL_WRAPPER_COMMANDS.has(command) ? findFlagPayload(argv, SHELL_EVALUATION_FLAGS) : null;
+    if (shellPayload && (shellCommandHasBlockedBackgroundPattern(shellPayload) || commandTextHasLongRunningPattern(shellPayload))) {
+        return `shell wrapper payload contains a blocked long-running or background pattern: ${shellPayload}`;
+    }
+    const interpreterFlags = INTERPRETER_EVALUATION_FLAGS.get(command);
+    const interpreterPayload = interpreterFlags ? findFlagPayload(argv, interpreterFlags) : null;
+    if (interpreterPayload && commandTextHasLongRunningPattern(interpreterPayload)) {
+        return `interpreter evaluation payload contains a blocked long-running pattern: ${interpreterPayload}`;
+    }
+    const interpreterModules = INTERPRETER_LONG_RUNNING_MODULES.get(command);
+    const moduleFlagIndex = args.indexOf('-m');
+    const moduleName = moduleFlagIndex >= 0 ? args[moduleFlagIndex + 1]?.toLowerCase() : null;
+    if (moduleName && interpreterModules?.has(moduleName)) {
+        return `interpreter module "${moduleName}" is commonly long-running`;
+    }
+    const packageScriptName = readPackageScriptName(command, args);
+    if (packageScriptName && LONG_RUNNING_PACKAGE_SCRIPTS.has(packageScriptName)) {
+        return `package-manager script "${packageScriptName}" is commonly long-running`;
+    }
+    const packageExecCommand = readPackageExecCommand(command, args);
+    if (packageExecCommand) {
+        const detail = longRunningExecutableDetail(packageExecCommand.command, packageExecCommand.args);
+        if (detail) {
+            return `package-manager exec target ${detail}`;
+        }
+    }
+    return longRunningExecutableDetail(command, args);
+}
 export function commandIntentBlockedCommandPattern(intent) {
     if (intent.mode === 'shell' && typeof intent.cmd === 'string' && shellCommandHasBlockedBackgroundPattern(intent.cmd)) {
         return {

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

@@ -5,6 +5,7 @@ import { COMMAND_ENV_POLICIES, DEFAULT_COMMAND_ENV_POLICY } from './command-env.
 import { COMMAND_EFFECT_CONCURRENCY, COMMAND_EFFECT_MODES, COMMAND_EFFECT_TYPES, validateCommandEffectLockWarnings, validateCommandEffects, } from './command-effects.js';
 import { commandIntentBlockedCommandPattern, commandIntentHasCommandSource, commandIntentNameIsSafe, } from './command-contract-rules.js';
 import { MAX_COMMAND_OUTPUT_BYTES, commandMaxOutputBytesLimitMessage } from './command-output-limits.js';
+import { SUCCESS_EXIT_CODES_CONTRACT_DESCRIPTION, successExitCodesAreValid } from './success-exit-codes.js';
 function commandContractIssue(message) {
     return { message };
 }
@@ -197,9 +198,8 @@ function validateCommandIntent(intentName, intent, issues) {
         issues.push(commandContractIssue(`Intent ${intentName} contains a blocked long-running or background command pattern`));
     }
     if (hasOwn(intent, 'success_exit_codes')) {
-        const value = intent.success_exit_codes;
-        if (!Array.isArray(value) || value.length === 0 || value.some((entry) => !Number.isInteger(entry))) {
-            issues.push(commandContractIssue(`[commands.intents.${intentName}].success_exit_codes must be an integer array`));
+        if (!successExitCodesAreValid(intent.success_exit_codes)) {
+            issues.push(commandContractIssue(`[commands.intents.${intentName}].success_exit_codes must be ${SUCCESS_EXIT_CODES_CONTRACT_DESCRIPTION}`));
         }
     }
     validateCommandIntentEffects(intentName, intent, issues);

package/dist/core/command-effects.js

@@ -13,8 +13,11 @@ function normalizeRelativePath(rawPath) {
 function pathLockKey(relativePath) {
     return `path:${normalizeRelativePath(relativePath)}`;
 }
-function validateEffectPath(projectRoot, intent, rawPath) {
-    const cwd = resolveSafeProjectCwd(projectRoot, readString(intent, 'cwd'));
+function readEffectiveCommandCwd(commandContract, intent) {
+    return readString(intent, 'cwd') ?? readString(commandContract.defaults, 'default_cwd') ?? '.';
+}
+function validateEffectPath(projectRoot, commandContract, intent, rawPath) {
+    const cwd = resolveSafeProjectCwd(projectRoot, readEffectiveCommandCwd(commandContract, intent));
     const resolved = path.resolve(cwd, rawPath);
     const root = path.resolve(projectRoot);
     const relative = path.relative(root, resolved);
@@ -83,7 +86,7 @@ function normalizeDeclaredEffect(projectRoot, commandContract, intentName, inten
         ];
     }
     return paths.map((rawPath) => {
-        const normalizedPath = validateEffectPath(projectRoot, intent, rawPath);
+        const normalizedPath = validateEffectPath(projectRoot, commandContract, intent, rawPath);
         return {
             intent: intentName,
             source: 'effects',
@@ -95,10 +98,10 @@ function normalizeDeclaredEffect(projectRoot, commandContract, intentName, inten
         };
     });
 }
-function normalizeWritesEffect(projectRoot, intentName, intent) {
+function normalizeWritesEffect(projectRoot, commandContract, intentName, intent) {
     const writes = readStringArray(intent, 'writes') ?? [];
     return writes.map((rawPath) => {
-        const normalizedPath = validateEffectPath(projectRoot, intent, rawPath);
+        const normalizedPath = validateEffectPath(projectRoot, commandContract, intent, rawPath);
         return {
             intent: intentName,
             source: 'writes',
@@ -119,7 +122,7 @@ export function normalizeCommandEffects(projectRoot, commandContract, intentName
     if (Array.isArray(rawEffects) && rawEffects.length > 0) {
         return rawEffects.flatMap((effect) => isRecord(effect) ? normalizeDeclaredEffect(projectRoot, commandContract, intentName, intent, effect) : []);
     }
-    return normalizeWritesEffect(projectRoot, intentName, intent);
+    return normalizeWritesEffect(projectRoot, commandContract, intentName, intent);
 }
 export function commandEffectsConflict(left, right) {
     if (left.lock !== right.lock) {

package/dist/core/contract-lint.js

@@ -7,6 +7,7 @@ import { MAX_COMMAND_OUTPUT_BYTES } from './command-output-limits.js';
 import { commandEffectsConflict, normalizeCommandEffects } from './command-effects.js';
 import { listChangeClassificationValidationReasons } from './change-classification.js';
 import { parseSkillIndexRoutes } from './skill-route-alignment.js';
+import { SUCCESS_EXIT_CODES_CONTRACT_DESCRIPTION, successExitCodesAreValid as successExitCodeValuesAreValid, } from './success-exit-codes.js';
 const CONTRACT_LINT_SOURCE_FILES = [
     '.mustflow/config/commands.toml',
     '.mustflow/docs/agent-workflow.md',
@@ -65,7 +66,7 @@ function readBoolean(intent, key) {
 }
 function successExitCodesAreValid(intent) {
     const value = intent.success_exit_codes;
-    return value === undefined || (Array.isArray(value) && value.every((entry) => Number.isInteger(entry)));
+    return value === undefined || successExitCodeValuesAreValid(value);
 }
 function writesAreValid(intent) {
     const value = intent.writes;
@@ -331,7 +332,7 @@ function lintIntent(name, value, issues) {
         pushIssue(issues, 'error', 'long_running_command_pattern', name, `Intent ${name} contains a blocked long-running or background command pattern.`);
     }
     if (!successExitCodesAreValid(value)) {
-        pushIssue(issues, 'error', 'invalid_success_exit_codes', name, `Intent ${name} success_exit_codes must be an integer array.`);
+        pushIssue(issues, 'error', 'invalid_success_exit_codes', name, `Intent ${name} success_exit_codes must be ${SUCCESS_EXIT_CODES_CONTRACT_DESCRIPTION}.`);
     }
     if (!writesAreValid(value)) {
         pushIssue(issues, 'error', 'invalid_writes', name, `Intent ${name} writes must be a string array.`);

package/dist/core/run-write-drift.js

@@ -7,7 +7,7 @@ const MAX_SNAPSHOT_FILES = 20_000;
 const MAX_REPORTED_PATHS = 200;
 const GIT_STATUS_TIMEOUT_MS = 10_000;
 const GIT_STATUS_MAX_BUFFER_BYTES = 16 * 1024 * 1024;
-const GIT_STATUS_UNTRACKED_MODE = 'normal';
+const GIT_STATUS_UNTRACKED_MODE = 'all';
 const MAX_HASH_BYTES = 5 * 1024 * 1024;
 const RECURSIVE_SNAPSHOT_ENV = 'MUSTFLOW_WRITE_DRIFT_SNAPSHOT';
 const EXCLUDED_DIRECTORY_NAMES = new Set(['.git', 'node_modules']);
@@ -150,7 +150,7 @@ function captureGitStatusSnapshot(projectRoot) {
     return {
         status: 'partial',
         entries,
-        reason: 'git_status_untracked_files_normal',
+        reason: 'git_status_untracked_files_all',
         source: 'git_status',
     };
 }

package/dist/core/success-exit-codes.js

@@ -0,0 +1,18 @@
+export const MIN_SUCCESS_EXIT_CODE = 0;
+export const MAX_SUCCESS_EXIT_CODE = 255;
+export const SUCCESS_EXIT_CODES_CONTRACT_DESCRIPTION = `a non-empty integer array with values from ${MIN_SUCCESS_EXIT_CODE} through ${MAX_SUCCESS_EXIT_CODE}`;
+export function successExitCodeIsValid(value) {
+    return (typeof value === 'number' &&
+        Number.isInteger(value) &&
+        value >= MIN_SUCCESS_EXIT_CODE &&
+        value <= MAX_SUCCESS_EXIT_CODE);
+}
+export function successExitCodesAreValid(value) {
+    return Array.isArray(value) && value.length > 0 && value.every(successExitCodeIsValid);
+}
+export function normalizeSuccessExitCodes(value) {
+    if (!successExitCodesAreValid(value)) {
+        return [0];
+    }
+    return [...new Set(value.map(Number))].sort((left, right) => left - right);
+}

package/package.json

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

package/templates/default/manifest.toml

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