mustflow 2.22.15 → 2.22.17

package/dist/cli/i18n/hi.js

@@ -20,6 +20,10 @@ export const hiMessages = {
     "value.yes": "हाँ",
     "value.no": "नहीं",
     "value.none": "none",
+    "value.present": "मौजूद",
+    "value.missing": "गुम",
+    "value.passed": "पास",
+    "value.failed": "फेल",
     "command.adapters.summary": "एडाप्टर फ़ाइलें बनाए बिना होस्ट संगतता जाँचें",
     "command.init.summary": "डिफ़ॉल्ट mustflow एजेंट वर्कफ़्लो कॉपी करें",
     "command.check.summary": "mustflow फ़ाइलों की जाँच करें",
@@ -54,6 +58,7 @@ export const hiMessages = {
     "check.help.exit.fail": "सत्यापन विफल हुआ या कमांड को अमान्य इनपुट मिला",
     "check.result.passed": "mustflow check पास हुआ",
     "check.result.strictPassed": "mustflow strict check पास हुआ",
+    "check.result.failed": "mustflow check फेल हुआ: {count} समस्या मिली।",
     "contractLint.help.summary": ".mustflow/config/commands.toml में command-contract errors और warnings जाँचें.",
     "contractLint.help.option.coverage": "change-classification reasons के लिए required_after coverage भी report करें",
     "contractLint.help.option.suggest": "package.json, Makefile, या justfile से non-runnable intent snippets सुझाएँ",
@@ -484,6 +489,10 @@ export const hiMessages = {
     "doctor.section.issueList": "समस्या सूची:",
     "doctor.section.suggestedCommands": "सुझाई गई कमांड:",
     "doctor.actionLabel": "चलाएँ",
+    "doctor.status.ok": "ठीक",
+    "doctor.status.warn": "चेतावनी",
+    "doctor.status.fail": "फेल",
+    "doctor.status.info": "जानकारी",
     "doctor.diagnostic.install": "इंस्टॉल",
     "doctor.diagnostic.validation": "सत्यापन",
     "doctor.diagnostic.skillRoutes": "स्किल रूट",
@@ -662,6 +671,7 @@ export const hiMessages = {
     "run.error.lifecycleNotOneshot": 'अस्वीकृत: कमांड "{intent}" का lifecycle = "{lifecycle}" है; mf run केवल oneshot कमांड चलाता है',
     "run.error.runPolicy": 'mf run के लिए कमांड "{intent}" में run_policy = "agent_allowed" चाहिए',
     "run.error.stdin": 'कमांड "{intent}" को stdin = "closed" सेट करना होगा',
+    "run.error.agentShellRequiresAllow": 'कमांड "{intent}" में mode = "shell" होने पर allow_shell = true सेट होना चाहिए',
     "run.error.timeout": 'कमांड "{intent}" को timeout_seconds परिभाषित करना होगा',
     "run.error.commandSource": 'कमांड "{intent}" को argv या mode = "shell" के साथ cmd परिभाषित करना होगा',
     "run.error.unsafeIntent": 'इंटेंट "{intent}" का नाम सुरक्षित नहीं है। {detail}',
@@ -672,6 +682,8 @@ export const hiMessages = {
     "run.error.blockedLongRunningCommandDetail": "argv में finite one-shot command होना चाहिए, development server, watcher, shell wrapper, interpreter loop, या background process नहीं।",
     "run.error.cwdOutsideProject": 'कमांड "{intent}" का cwd अमान्य है: {detail}',
     "run.error.cwdOutsideProjectDetail": "Intent cwd current root के अंदर रहना चाहिए।",
+    "run.error.invalidTestTarget": 'कमांड "{intent}" को अमान्य test target मिला। {detail}',
+    "run.error.invalidTestTargetDetail": "Test targets relative file paths होने चाहिए और '-' से शुरू नहीं हो सकते।",
     "run.error.maxOutputBytes": 'कमांड "{intent}" में max_output_bytes अमान्य है। {detail}',
     "run.error.maxOutputBytesDetail": "Output limit अनुमत maximum के अंदर रहनी चाहिए।",
     "run.error.conflictingPreviewModes": "--dry-run या --plan-only में से एक इस्तेमाल करें, दोनों नहीं",
@@ -680,6 +692,9 @@ export const hiMessages = {
     "run.error.timedOut": 'कमांड "{intent}" {seconds} सेकंड बाद time out हुई',
     "run.error.outputLimitExceeded": 'कमांड "{intent}" ने max_output_bytes सीमा पार की: {message}',
     "run.error.startFailed": 'कमांड "{intent}" शुरू नहीं हो सकी: {message}',
+    "run.error.activeLockConflict": "mf run {intent} सक्रिय रन लॉक के कारण रुका है: {detail}",
+    "run.error.activeLockConflictDetail": "{lock} सक्रिय intent {intent} से टकराता है (pid {pid})",
+    "run.error.activeLockConflictUnknown": "अज्ञात सक्रिय रन लॉक टकराव",
     "search.help.summary": "mustflow वर्कफ़्लो के लिए स्थानीय SQLite इंडेक्स में खोजें।",
     "search.help.option.limit": "प्रिंट किए जाने वाले परिणामों की संख्या सेट करें। डिफ़ॉल्ट: 10, अधिकतम: 50",
     "search.help.option.scope": "इंडेक्स किए गए वर्कफ़्लो डेटा, source anchors, या दोनों चुनें। डिफ़ॉल्ट: workflow",
@@ -771,6 +786,15 @@ export const hiMessages = {
     "verify.label.planSource": "Plan source",
     "verify.label.status": "Status",
     "verify.label.results": "Results",
+    "verify.label.completionVerdict": "Completion verdict",
+    "verify.label.matched": "Matched",
+    "verify.label.ran": "Ran",
+    "verify.label.passed": "Passed",
+    "verify.label.failed": "Failed",
+    "verify.label.skipped": "Skipped",
+    "verify.label.parallelism": "Parallelism",
+    "verify.label.parallelismNote": "Parallelism note",
+    "verify.parallelism.summary": "requested {requested}, effective {effective}, repository max {repositoryMax}, CPU available {cpuAvailable}, mode {mode}",
     "verify.error.missingReason": "Verification reason missing है",
     "verify.error.conflictingInputs": "--reason, --from-classification, --from-plan, या --changed में से केवल एक इस्तेमाल करें",
     "verify.error.writePlanRequiresChanged": "--write-plan के लिए --changed चाहिए",
@@ -810,6 +834,7 @@ export const hiMessages = {
     "explain.label.publicSurface": "Public surface",
     "explain.label.validationReasons": "Validation reasons",
     "explain.label.affectedContracts": "Affected contracts",
+    "explain.label.blockedRunPlan": "Blocked run plan",
     "explain.error.missingTopic": "Explain topic गुम है",
     "explain.error.missingCommand": "Command intent गुम है",
     "explain.error.missingSkill": "Skill id गुम है",

package/dist/cli/i18n/ko.js

@@ -20,6 +20,10 @@ export const koMessages = {
     "value.yes": "예",
     "value.no": "아니요",
     "value.none": "없음",
+    "value.present": "있음",
+    "value.missing": "없음",
+    "value.passed": "통과",
+    "value.failed": "실패",
     "command.adapters.summary": "어댑터 파일을 만들지 않고 호스트 호환성을 확인합니다",
     "command.init.summary": "기본 mustflow 에이전트 워크플로우를 복사합니다",
     "command.check.summary": "mustflow 파일을 검사합니다",
@@ -54,6 +58,7 @@ export const koMessages = {
     "check.help.exit.fail": "검증 실패 또는 잘못된 입력이 제공되었습니다",
     "check.result.passed": "mustflow 검사 통과",
     "check.result.strictPassed": "mustflow 엄격 검사 통과",
+    "check.result.failed": "mustflow 검사 실패: 문제 {count}개를 찾았습니다.",
     "contractLint.help.summary": ".mustflow/config/commands.toml의 명령 계약 오류와 경고를 확인합니다.",
     "contractLint.help.option.coverage": "변경 분류 이유에 대한 required_after 연결 상태도 보고합니다",
     "contractLint.help.option.suggest": "package.json, Makefile, justfile에서 실행 불가 후보 조각을 제안합니다",
@@ -484,6 +489,10 @@ export const koMessages = {
     "doctor.section.issueList": "문제 목록:",
     "doctor.section.suggestedCommands": "추천 명령:",
     "doctor.actionLabel": "명령",
+    "doctor.status.ok": "정상",
+    "doctor.status.warn": "주의",
+    "doctor.status.fail": "실패",
+    "doctor.status.info": "정보",
     "doctor.diagnostic.install": "설치",
     "doctor.diagnostic.validation": "검증",
     "doctor.diagnostic.skillRoutes": "스킬 라우팅",
@@ -662,6 +671,7 @@ export const koMessages = {
     "run.error.lifecycleNotOneshot": '거부됨: 명령 "{intent}"의 수명 주기(lifecycle)는 "{lifecycle}"입니다. mf run은 일회성(oneshot) 명령만 실행합니다',
     "run.error.runPolicy": '명령 "{intent}"는 mf run에서 실행하려면 run_policy = "agent_allowed"가 필요합니다',
     "run.error.stdin": '명령 "{intent}"는 stdin = "closed"를 설정해야 합니다',
+    "run.error.agentShellRequiresAllow": '명령 "{intent}"는 mode = "shell"일 때 allow_shell = true를 설정해야 합니다',
     "run.error.timeout": '명령 "{intent}"는 timeout_seconds를 정의해야 합니다',
     "run.error.commandSource": '명령 "{intent}"는 argv를 정의하거나 mode = "shell"과 cmd를 함께 정의해야 합니다',
     "run.error.unsafeIntent": '명령 의도 "{intent}"의 이름이 안전하지 않습니다. {detail}',
@@ -672,6 +682,8 @@ export const koMessages = {
     "run.error.blockedLongRunningCommandDetail": "argv는 개발 서버, 감시 명령, 셸 래퍼, 인터프리터 반복 작업, 백그라운드 프로세스가 아니라 끝나는 단발성 명령이어야 합니다.",
     "run.error.cwdOutsideProject": '명령 "{intent}"의 실행 위치(cwd)가 올바르지 않습니다: {detail}',
     "run.error.cwdOutsideProjectDetail": "명령 실행 위치(cwd)는 현재 루트 안에 있어야 합니다.",
+    "run.error.invalidTestTarget": '명령 "{intent}"에 올바르지 않은 테스트 대상이 전달되었습니다. {detail}',
+    "run.error.invalidTestTargetDetail": "테스트 대상은 상대 파일 경로여야 하며 '-'로 시작할 수 없습니다.",
     "run.error.maxOutputBytes": '명령 "{intent}"의 max_output_bytes 값이 올바르지 않습니다. {detail}',
     "run.error.maxOutputBytesDetail": "출력 상한은 허용된 최댓값 안에 있어야 합니다.",
     "run.error.conflictingPreviewModes": "--dry-run과 --plan-only 중 하나만 사용하세요",
@@ -680,6 +692,9 @@ export const koMessages = {
     "run.error.timedOut": '명령 "{intent}"가 {seconds}초 뒤 시간 초과되었습니다',
     "run.error.outputLimitExceeded": '명령 "{intent}"가 max_output_bytes 제한을 넘었습니다: {message}',
     "run.error.startFailed": '명령 "{intent}"를 시작하지 못했습니다: {message}',
+    "run.error.activeLockConflict": "mf run {intent} 실행이 활성 실행 잠금 때문에 차단되었습니다: {detail}",
+    "run.error.activeLockConflictDetail": "{lock} 잠금이 실행 중인 {intent} 의도와 충돌합니다(pid {pid})",
+    "run.error.activeLockConflictUnknown": "알 수 없는 활성 실행 잠금 충돌",
     "search.help.summary": "로컬 SQLite 색인에서 mustflow 워크플로우를 검색합니다.",
     "search.help.option.limit": "출력할 검색 결과 수를 설정합니다. 기본값: 10, 최대: 50",
     "search.help.option.scope": "색인된 워크플로 데이터, 소스 앵커, 또는 둘 다를 선택합니다. 기본값: workflow",
@@ -771,6 +786,15 @@ export const koMessages = {
     "verify.label.planSource": "계획 원본",
     "verify.label.status": "상태",
     "verify.label.results": "결과",
+    "verify.label.completionVerdict": "완료 판정",
+    "verify.label.matched": "일치",
+    "verify.label.ran": "실행",
+    "verify.label.passed": "통과",
+    "verify.label.failed": "실패",
+    "verify.label.skipped": "생략",
+    "verify.label.parallelism": "병렬 실행",
+    "verify.label.parallelismNote": "병렬 실행 참고",
+    "verify.parallelism.summary": "요청 {requested}, 실제 {effective}, 저장소 상한 {repositoryMax}, 사용 가능 CPU {cpuAvailable}, 모드 {mode}",
     "verify.error.missingReason": "검증 이유가 없습니다",
     "verify.error.conflictingInputs": "--reason, --from-classification, --from-plan, --changed 중 하나만 사용하세요",
     "verify.error.writePlanRequiresChanged": "--write-plan에는 --changed가 필요합니다",
@@ -810,6 +834,7 @@ export const koMessages = {
     "explain.label.publicSurface": "공개 표면",
     "explain.label.validationReasons": "검증 이유",
     "explain.label.affectedContracts": "영향받는 계약",
+    "explain.label.blockedRunPlan": "차단된 실행 계획",
     "explain.error.missingTopic": "설명할 주제가 없습니다",
     "explain.error.missingCommand": "설명할 명령 의도가 없습니다",
     "explain.error.missingSkill": "설명할 스킬 식별자가 없습니다",

package/dist/cli/i18n/zh.js

@@ -20,6 +20,10 @@ export const zhMessages = {
     "value.yes": "是",
     "value.no": "否",
     "value.none": "无",
+    "value.present": "存在",
+    "value.missing": "缺失",
+    "value.passed": "通过",
+    "value.failed": "失败",
     "command.adapters.summary": "不生成适配器文件，检查宿主兼容性",
     "command.init.summary": "复制默认的 mustflow 代理工作流",
     "command.check.summary": "验证 mustflow 文件",
@@ -54,6 +58,7 @@ export const zhMessages = {
     "check.help.exit.fail": "验证失败，或命令收到了无效输入",
     "check.result.passed": "mustflow 检查已通过",
     "check.result.strictPassed": "mustflow 严格检查已通过",
+    "check.result.failed": "mustflow 检查失败：发现 {count} 个问题。",
     "contractLint.help.summary": "检查 .mustflow/config/commands.toml 中的命令契约错误和警告。",
     "contractLint.help.option.coverage": "同时报告变更分类原因的 required_after 覆盖情况",
     "contractLint.help.option.suggest": "从 package.json、Makefile 或 justfile 建议不可运行的 intent 片段",
@@ -484,6 +489,10 @@ export const zhMessages = {
     "doctor.section.issueList": "问题列表：",
     "doctor.section.suggestedCommands": "建议命令：",
     "doctor.actionLabel": "运行",
+    "doctor.status.ok": "正常",
+    "doctor.status.warn": "警告",
+    "doctor.status.fail": "失败",
+    "doctor.status.info": "信息",
     "doctor.diagnostic.install": "安装",
     "doctor.diagnostic.validation": "验证",
     "doctor.diagnostic.skillRoutes": "技能路由",
@@ -662,6 +671,7 @@ export const zhMessages = {
     "run.error.lifecycleNotOneshot": '已拒绝：命令 "{intent}" 的 lifecycle = "{lifecycle}"；mf run 只执行 oneshot 命令',
     "run.error.runPolicy": '命令 "{intent}" 需要 run_policy = "agent_allowed" 才能通过 mf run 执行',
     "run.error.stdin": '命令 "{intent}" 必须设置 stdin = "closed"',
+    "run.error.agentShellRequiresAllow": '当 mode = "shell" 时，命令 "{intent}" 必须设置 allow_shell = true',
     "run.error.timeout": '命令 "{intent}" 必须定义 timeout_seconds',
     "run.error.commandSource": '命令 "{intent}" 必须定义 argv，或定义 mode = "shell" 并提供 cmd',
     "run.error.unsafeIntent": '意图 "{intent}" 的名称不安全。{detail}',
@@ -672,6 +682,8 @@ export const zhMessages = {
     "run.error.blockedLongRunningCommandDetail": "argv 必须描述会结束的单次命令，而不是开发服务器、监听命令、shell 包装器、解释器循环或后台进程。",
     "run.error.cwdOutsideProject": '命令 "{intent}" 的 cwd 无效：{detail}',
     "run.error.cwdOutsideProjectDetail": "意图 cwd 必须位于当前根目录内。",
+    "run.error.invalidTestTarget": '命令 "{intent}" 收到无效测试目标。{detail}',
+    "run.error.invalidTestTargetDetail": "测试目标必须是相对文件路径，且不能以 '-' 开头。",
     "run.error.maxOutputBytes": '命令 "{intent}" 的 max_output_bytes 无效。{detail}',
     "run.error.maxOutputBytesDetail": "输出限制必须保持在允许的最大值内。",
     "run.error.conflictingPreviewModes": "只能使用 --dry-run 或 --plan-only，不能同时使用",
@@ -680,6 +692,9 @@ export const zhMessages = {
     "run.error.timedOut": '命令 "{intent}" 在 {seconds} 秒后超时',
     "run.error.outputLimitExceeded": '命令 "{intent}" 超过 max_output_bytes：{message}',
     "run.error.startFailed": '命令 "{intent}" 启动失败：{message}',
+    "run.error.activeLockConflict": "mf run {intent} 被活动运行锁阻止：{detail}",
+    "run.error.activeLockConflictDetail": "{lock} 与活动 intent {intent} 冲突（pid {pid}）",
+    "run.error.activeLockConflictUnknown": "未知的活动运行锁冲突",
     "search.help.summary": "搜索本地 SQLite 索引中的 mustflow 工作流。",
     "search.help.option.limit": "设置要输出的结果数量。默认值：10，最大：50",
     "search.help.option.scope": "选择已索引的工作流数据、源码 anchors，或两者。默认值：workflow",
@@ -771,6 +786,15 @@ export const zhMessages = {
     "verify.label.planSource": "计划来源",
     "verify.label.status": "状态",
     "verify.label.results": "结果",
+    "verify.label.completionVerdict": "完成判定",
+    "verify.label.matched": "匹配",
+    "verify.label.ran": "已运行",
+    "verify.label.passed": "已通过",
+    "verify.label.failed": "已失败",
+    "verify.label.skipped": "已跳过",
+    "verify.label.parallelism": "并行度",
+    "verify.label.parallelismNote": "并行度说明",
+    "verify.parallelism.summary": "请求 {requested}，实际 {effective}，仓库上限 {repositoryMax}，可用 CPU {cpuAvailable}，模式 {mode}",
     "verify.error.missingReason": "缺少验证原因",
     "verify.error.conflictingInputs": "只能使用 --reason、--from-classification、--from-plan 或 --changed 其中之一",
     "verify.error.writePlanRequiresChanged": "--write-plan 需要 --changed",
@@ -810,6 +834,7 @@ export const zhMessages = {
     "explain.label.publicSurface": "公共表面",
     "explain.label.validationReasons": "验证原因",
     "explain.label.affectedContracts": "受影响契约",
+    "explain.label.blockedRunPlan": "被阻止的运行计划",
     "explain.error.missingTopic": "缺少 explain 主题",
     "explain.error.missingCommand": "缺少命令意图",
     "explain.error.missingSkill": "缺少技能标识",

package/dist/cli/index.js

@@ -35,6 +35,7 @@ function getTopLevelHelp(lang) {
             'mf map --write',
             'mf search mustflow_check',
             'mf explain authority AGENTS.md',
+            'mf explain --why-blocked test',
             'mf impact --changed',
             'mf upgrade --dry-run',
             'mf verify --changed --plan-only --json',

package/dist/cli/lib/filesystem.js

@@ -3,7 +3,7 @@ import path from 'node:path';
 export { ensureFileTargetInsideWithoutSymlinks, ensureInside, ensureInsideWithoutSymlinks, readFileInsideWithoutSymlinks, readUtf8FileInsideWithoutSymlinks, writeFileInsideWithoutSymlinks, writeUtf8FileInsideWithoutSymlinks, } from '../../core/safe-filesystem.js';
 import { readFileInsideWithoutSymlinks, writeFileInsideWithoutSymlinks, } from '../../core/safe-filesystem.js';
 export function toPosixPath(value) {
-    return value.split(path.sep).join('/');
+    return value.replace(/\\/gu, '/');
 }
 export function copyFileInsideWithoutSymlinks(sourceParentPath, sourcePath, targetParentPath, targetPath) {
     const content = readFileInsideWithoutSymlinks(sourceParentPath, sourcePath);

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

@@ -1,5 +1,6 @@
 import { spawnSync } from 'node:child_process';
 import { parseGitStatusOutput } from '../../core/change-classification.js';
+import { createCommandEnv } from '../../core/command-env.js';
 const GIT_STATUS_TIMEOUT_MS = 10_000;
 const GIT_STATUS_MAX_BUFFER_BYTES = 16 * 1024 * 1024;
 export class GitChangedFilesError extends Error {
@@ -14,6 +15,7 @@ export function readGitChangedFiles(projectRoot) {
     const result = spawnSync('git', ['status', '--porcelain=v1', '-z', '--untracked-files=all'], {
         cwd: projectRoot,
         encoding: 'utf8',
+        env: createCommandEnv(projectRoot, { policy: 'minimal', allowlist: [] }),
         input: '',
         maxBuffer: GIT_STATUS_MAX_BUFFER_BYTES,
         stdio: ['ignore', 'pipe', 'pipe'],

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

@@ -2311,10 +2311,10 @@ export async function searchLocalIndex(projectRoot, query, options = {}) {
     catch {
         return searchLocalWorkflowFilesDirectly(projectRoot, databasePath, normalizedQuery, limit, scope);
     }
-    const cacheLayers = readCacheLayerSets(projectRoot);
     let capabilities = searchCapabilities(false);
     const results = [];
     try {
+        const cacheLayers = readCacheLayerSets(projectRoot);
         const stalePaths = getStalePaths(projectRoot, database);
         capabilities = readStoredSearchCapabilities(database);
         const indexedMatches = getIndexedSearchMatches(database, normalizedQuery);

package/dist/cli/lib/npm-version-check.js

@@ -1,3 +1,4 @@
+import path from 'node:path';
 const DEFAULT_NPM_REGISTRY_URL = 'https://registry.npmjs.org';
 const DEFAULT_VERSION_CHECK_TIMEOUT_MS = 3_000;
 const PACKAGE_MANAGER_COMMANDS = [
@@ -37,6 +38,7 @@ const PACKAGE_MANAGER_COMMANDS = [
         },
     },
 ];
+const PACKAGE_MANAGER_IDS = PACKAGE_MANAGER_COMMANDS.map((entry) => entry.id);
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -102,23 +104,31 @@ function getTimeoutMs() {
     const parsed = rawValue ? Number(rawValue) : DEFAULT_VERSION_CHECK_TIMEOUT_MS;
     return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : DEFAULT_VERSION_CHECK_TIMEOUT_MS;
 }
-function detectPackageManagerId() {
-    const signals = [
-        process.env.npm_config_user_agent,
-        process.env.npm_execpath,
-        process.execPath,
-        process.argv[1],
-        import.meta.url,
-    ]
-        .filter((signal) => typeof signal === 'string' && signal.length > 0)
-        .map((signal) => signal.toLowerCase());
-    for (const id of ['bun', 'pnpm', 'yarn', 'deno', 'npm']) {
-        if (signals.some((signal) => signal.includes(id))) {
+function packageManagerFromUserAgent(userAgent) {
+    const firstToken = userAgent?.trim().toLowerCase().split(/\s+/u)[0] ?? '';
+    for (const id of PACKAGE_MANAGER_IDS) {
+        if (firstToken === id || firstToken.startsWith(`${id}/`)) {
             return id;
         }
     }
     return null;
 }
+function packageManagerFromExecutablePath(executablePath) {
+    if (!executablePath) {
+        return null;
+    }
+    const normalized = path
+        .basename(executablePath)
+        .toLowerCase()
+        .replace(/\.(?:cmd|ps1|exe|cjs|mjs|js)$/u, '')
+        .replace(/-cli$/u, '');
+    return PACKAGE_MANAGER_IDS.find((id) => normalized === id) ?? null;
+}
+function detectPackageManagerId() {
+    return (packageManagerFromUserAgent(process.env.npm_config_user_agent) ??
+        packageManagerFromExecutablePath(process.env.npm_execpath) ??
+        packageManagerFromExecutablePath(process.execPath));
+}
 function getPackageInstallCommands(packageName) {
     const detectedId = detectPackageManagerId();
     const commands = [...PACKAGE_MANAGER_COMMANDS];

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

@@ -7,6 +7,7 @@ import { inspectActiveRunLocks, } from '../../core/active-run-locks.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 { normalizeSafeTestTargetPath, TEST_TARGET_PATH_ERROR } from '../../core/test-target-paths.js';
 import { evaluateCommandPreconditions, } from '../../core/command-preconditions.js';
 import { t } from './i18n.js';
 function getSuccessExitCodes(intent) {
@@ -28,12 +29,18 @@ function getRelativeProjectPath(projectRoot, targetPath) {
     return relativePath.length > 0 ? toPosixPath(relativePath) : '.';
 }
 function normalizeTestTargets(values) {
-    return [
-        ...new Set((values ?? [])
-            .map((value) => value.trim().replace(/\\/g, '/'))
-            .filter((value) => value.length > 0 && !path.posix.isAbsolute(value) && !path.win32.isAbsolute(value))
-            .filter((value) => value.split('/').every((segment) => segment.length > 0 && segment !== '.' && segment !== '..'))),
-    ].sort((left, right) => left.localeCompare(right));
+    const normalizedValues = [];
+    for (const value of values ?? []) {
+        const normalized = normalizeSafeTestTargetPath(value);
+        if (normalized === null) {
+            return { ok: false, detail: `Test target ${JSON.stringify(value)} is invalid: ${TEST_TARGET_PATH_ERROR}.` };
+        }
+        normalizedValues.push(normalized);
+    }
+    return {
+        ok: true,
+        values: [...new Set(normalizedValues)].sort((left, right) => left.localeCompare(right)),
+    };
 }
 function commandAcceptsTestTargets(intent) {
     return isRecord(intent.selection) && intent.selection.accepts_test_targets === true;
@@ -190,7 +197,13 @@ export function createRunPlan(projectRoot, contract, intentName, options = {}) {
     catch (error) {
         return createBlockedRunPlan(contract, intentName, rawIntent, eligibility, 'cwd_outside_project', error instanceof Error ? error.message : String(error), preconditions);
     }
-    const testTargets = commandAcceptsTestTargets(rawIntent) ? normalizeTestTargets(options.testTargets) : [];
+    const normalizedTestTargets = commandAcceptsTestTargets(rawIntent) ?
+        normalizeTestTargets(options.testTargets) :
+        { ok: true, values: [] };
+    if (!normalizedTestTargets.ok) {
+        return createBlockedRunPlan(contract, intentName, rawIntent, eligibility, 'invalid_test_target', normalizedTestTargets.detail, preconditions);
+    }
+    const testTargets = normalizedTestTargets.values;
     const commandArgv = metadata.commandArgv && testTargets.length > 0 ? [...metadata.commandArgv, ...testTargets] : metadata.commandArgv;
     if (!metadata.timeoutSeconds || !metadata.mode) {
         return createBlockedRunPlan(contract, intentName, rawIntent, eligibility, !metadata.timeoutSeconds ? 'missing_timeout' : 'missing_command_source', !metadata.timeoutSeconds ? 'Intent timeout_seconds is missing or invalid.' : 'Intent does not define argv or shell cmd.', preconditions);

package/dist/cli/lib/run-root-trust.js

@@ -1,8 +1,39 @@
-import { MANIFEST_LOCK_RELATIVE_PATH, readManifestLock } from './manifest-lock.js';
+import { MANIFEST_LOCK_RELATIVE_PATH, inspectManifestLock } from './manifest-lock.js';
 export const ALLOW_UNTRUSTED_ROOT_OPTION = '--allow-untrusted-root';
+const REQUIRED_RUN_TRUST_LOCK_PATHS = [
+    'AGENTS.md',
+    '.mustflow/config/commands.toml',
+];
 export function assessRunRootTrust(projectRoot) {
-    const readResult = readManifestLock(projectRoot);
+    const inspection = inspectManifestLock(projectRoot);
+    const { readResult } = inspection;
     if (readResult.kind === 'present') {
+        if (readResult.lock.files.length === 0) {
+            return {
+                trusted: false,
+                reason: 'manifest_lock_invalid',
+                manifestLockPath: readResult.lockPath,
+                detail: 'Manifest lock must track at least one file.',
+            };
+        }
+        const trackedPaths = new Set(readResult.lock.files.map((file) => file.relativePath));
+        const missingRequiredPath = REQUIRED_RUN_TRUST_LOCK_PATHS.find((relativePath) => !trackedPaths.has(relativePath));
+        if (missingRequiredPath) {
+            return {
+                trusted: false,
+                reason: 'manifest_lock_invalid',
+                manifestLockPath: readResult.lockPath,
+                detail: `Manifest lock must track ${missingRequiredPath}.`,
+            };
+        }
+        if (inspection.issues.length > 0) {
+            return {
+                trusted: false,
+                reason: 'manifest_lock_invalid',
+                manifestLockPath: readResult.lockPath,
+                detail: inspection.issues[0] ?? 'Manifest lock does not match the current workflow files.',
+            };
+        }
         return {
             trusted: true,
             reason: 'manifest_lock_present',

package/dist/cli/lib/validation/test-selection.js

@@ -2,9 +2,19 @@ import { existsSync } from 'node:fs';
 import path from 'node:path';
 import { isRecord } from '../command-contract.js';
 import { readMustflowTomlFile } from '../toml.js';
+import { normalizeSafeTestTargetPath, TEST_TARGET_PATH_ERROR } from '../../../core/test-target-paths.js';
 import { ALLOWED_TEST_SELECTION_RISKS, FORBIDDEN_TEST_SELECTION_COMMAND_AUTHORITY_FIELDS, TEST_SELECTION_CONFIG_PATH, } from './constants.js';
 import { isConfiguredCommandIntent, isDeclaredCommandIntent } from './command-intents.js';
 import { hasOwn, pushStrictIssue, validateAllowedStringField, validateNestedTable, validatePathArrayField, validateRequiredStringField, validateStringArrayField, } from './primitives.js';
+function validateTestTargetPathArrayField(table, key, label, issues) {
+    if (!hasOwn(table, key)) {
+        return;
+    }
+    const value = table[key];
+    if (!Array.isArray(value) || value.length === 0 || !value.every((entry) => normalizeSafeTestTargetPath(entry) !== null)) {
+        issues.push({ message: `${label} ${TEST_TARGET_PATH_ERROR}` });
+    }
+}
 function validateNoTestSelectionCommandAuthorityFields(label, table, issues) {
     for (const field of FORBIDDEN_TEST_SELECTION_COMMAND_AUTHORITY_FIELDS) {
         if (hasOwn(table, field)) {
@@ -59,7 +69,7 @@ function validateTestSelectionRule(rule, index, commandsToml, issues) {
         validateNoTestSelectionCommandAuthorityFields(`${label}.select`, select, issues);
         validateTestSelectionIntentReference(select.intent, `${label}.select.intent`, commandsToml, issues);
         validateTestSelectionIntentReference(select.fallback_intent, `${label}.select.fallback_intent`, commandsToml, issues);
-        validatePathArrayField(select, 'test_targets', `${TEST_SELECTION_CONFIG_PATH} ${label}.select.test_targets`, issues);
+        validateTestTargetPathArrayField(select, 'test_targets', `${TEST_SELECTION_CONFIG_PATH} ${label}.select.test_targets`, issues);
     }
 }
 export function validateStrictTestSelectionConfig(projectRoot, commandsToml, issues) {

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

@@ -195,7 +195,7 @@ function acquireMutex(projectRoot) {
     const root = activeLockRoot(projectRoot);
     const mutex = activeLockMutexDirectory(projectRoot);
     mkdirSync(root, { recursive: true });
-    const startedAt = Date.now();
+    let startedAt = Date.now();
     while (true) {
         try {
             mkdirSync(mutex);
@@ -215,11 +215,13 @@ function acquireMutex(projectRoot) {
                     const staleByAge = Number.isFinite(ownerStartedAt) && Date.now() - ownerStartedAt > LOCK_MUTEX_STALE_MS;
                     if (!isProcessLive(ownerPid) || staleByAge) {
                         rmSync(mutex, { recursive: true, force: true });
+                        startedAt = Date.now();
                         continue;
                     }
                 }
                 catch {
                     rmSync(mutex, { recursive: true, force: true });
+                    startedAt = Date.now();
                     continue;
                 }
                 throw new Error('active_run_lock_mutex_busy');

package/dist/core/command-intent-eligibility.js

@@ -76,6 +76,13 @@ export function evaluateCommandIntentEligibility(intentName, rawIntent) {
             detail: blockedPattern.detail,
         };
     }
+    if (rawIntent.mode === 'shell' && rawIntent.allow_shell !== true) {
+        return {
+            ok: false,
+            code: 'agent_shell_requires_allow',
+            detail: `Agent-runnable shell intent ${intentName} must set allow_shell = true.`,
+        };
+    }
     return {
         ok: true,
         code: 'ok',

package/dist/core/command-preconditions.js

@@ -108,13 +108,14 @@ function listProjectFiles(projectRoot) {
     walk(projectRoot);
     return files.sort((left, right) => left.localeCompare(right));
 }
-function matchingSourceFiles(projectRoot, patterns) {
+function matchingSourceFiles(projectRoot, patterns, context) {
     const safePatterns = patterns.filter((pattern) => !relativePathIsUnsafe(pattern));
     const matchers = safePatterns.map(globToRegExp);
     if (matchers.length === 0) {
         return [];
     }
-    return listProjectFiles(projectRoot).filter((filePath) => matchers.some((matcher) => matcher.test(filePath)));
+    context.projectFiles ??= listProjectFiles(projectRoot);
+    return context.projectFiles.filter((filePath) => matchers.some((matcher) => matcher.test(filePath)));
 }
 function evaluatePathExists(projectRoot, declaration, satisfyIntent) {
     const pathValue = declaration.path;
@@ -158,7 +159,7 @@ function evaluatePathExists(projectRoot, declaration, satisfyIntent) {
         satisfyIntent,
     };
 }
-function evaluateArtifactFreshness(projectRoot, declaration, satisfyIntent) {
+function evaluateArtifactFreshness(projectRoot, declaration, satisfyIntent, context) {
     const artifact = declaration.artifact;
     if (!artifact || declaration.sources.length === 0) {
         return {
@@ -200,7 +201,7 @@ function evaluateArtifactFreshness(projectRoot, declaration, satisfyIntent) {
             satisfyIntent,
         };
     }
-    const sourceFiles = matchingSourceFiles(projectRoot, declaration.sources);
+    const sourceFiles = matchingSourceFiles(projectRoot, declaration.sources, context);
     if (sourceFiles.length === 0) {
         return {
             kind: declaration.kind,
@@ -215,9 +216,26 @@ function evaluateArtifactFreshness(projectRoot, declaration, satisfyIntent) {
         };
     }
     const artifactMtime = statSync(artifactPath).mtimeMs;
-    const newest = sourceFiles
-        .map((source) => ({ source, mtime: statSync(path.join(projectRoot, ...source.split('/'))).mtimeMs }))
-        .sort((left, right) => right.mtime - left.mtime)[0];
+    let newest = null;
+    for (const source of sourceFiles) {
+        const mtime = statSync(path.join(projectRoot, ...source.split('/'))).mtimeMs;
+        if (!newest || mtime > newest.mtime) {
+            newest = { source, mtime };
+        }
+    }
+    if (!newest) {
+        return {
+            kind: declaration.kind,
+            label: declaration.label,
+            status: 'unknown',
+            detail: 'no readable source files matched the freshness precondition.',
+            path: null,
+            artifact,
+            sources: declaration.sources,
+            newestSource: null,
+            satisfyIntent,
+        };
+    }
     const stale = newest.mtime > artifactMtime;
     return {
         kind: declaration.kind,
@@ -238,13 +256,14 @@ export function evaluateCommandPreconditions(projectRoot, contract, intentName)
     if (!isRecord(intent)) {
         return [];
     }
+    const context = { projectFiles: null };
     return readPreconditionDeclarations(intent).map((declaration) => {
         const satisfyIntent = createSatisfyIntentSummary(contract, declaration.satisfyIntent);
         if (declaration.kind === 'path_exists') {
             return evaluatePathExists(projectRoot, declaration, satisfyIntent);
         }
         if (declaration.kind === 'artifact_freshness') {
-            return evaluateArtifactFreshness(projectRoot, declaration, satisfyIntent);
+            return evaluateArtifactFreshness(projectRoot, declaration, satisfyIntent, context);
         }
         return {
             kind: declaration.kind,

package/dist/core/line-endings.js

@@ -1,6 +1,7 @@
 import { spawnSync } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import path from 'node:path';
+import { createCommandEnv } from './command-env.js';
 import { readFileInsideWithoutSymlinks, writeFileInsideWithoutSymlinks } from './safe-filesystem.js';
 const GITATTRIBUTES_PATH = '.gitattributes';
 function toPosixPath(value) {
@@ -18,6 +19,7 @@ function gitList(projectRoot, args) {
     const result = spawnSync('git', [...args, '-z'], {
         cwd: projectRoot,
         encoding: 'buffer',
+        env: createCommandEnv(projectRoot, { policy: 'minimal', allowlist: [] }),
         stdio: ['ignore', 'pipe', 'pipe'],
         windowsHide: true,
     });