mustflow 2.18.3 → 2.18.20

package/README.md

@@ -228,6 +228,10 @@ your-project/
       │  └─ SKILL.md
       ├─ vertical-slice-tdd/
       │  └─ SKILL.md
+      ├─ llm-service-ux-review/
+      │  └─ SKILL.md
+      ├─ search-ad-content-authoring/
+      │  └─ SKILL.md
       ├─ ui-quality-gate/
       │  └─ SKILL.md
       ├─ visual-review-artifact/
@@ -356,6 +360,8 @@ Runnable work is declared in `.mustflow/config/commands.toml` so agents do not g
 
 Development servers, watch modes, browser UIs, interactive commands, and background processes do not run directly. `mf run` also rejects obvious long-running `argv` shapes, such as shell-wrapper background payloads, interpreter loops, package-manager development scripts, watchers, and development servers declared as one-shot commands.
 
+Command environments remove the project-local `node_modules/.bin` path from `PATH` by default. If an intent needs a project dependency binary such as `eslint`, `tsc`, or `vitest`, declare it through the package manager, for example `npm exec eslint -- ...`, `pnpm exec tsc -- --noEmit`, `bun x eslint ...`, or `yarn exec eslint ...`. `mf check --strict` warns when an agent-runnable intent uses a bare executable name that appears under the project-local `.bin` directory.
+
 Use `mf verify --reason <event> --plan-only --json` to inspect matching verification intents, command eligibility, remaining gaps, and missing runnable coverage without executing commands. Use `mf run <intent> --dry-run --json` to inspect one resolved command intent without spawning a process or writing a run receipt. Plan-only verification includes a `decision_graph` that connects changed surfaces, classification reasons, command candidates, eligibility checks, effects, and gaps. When `.mustflow/cache/mustflow.sqlite` is fresh, scheduled entries also include read-only `effectGraph` metadata for write locks and lock conflicts. These graph rows are marked `explanation_only` and never grant command authority; `.mustflow/config/commands.toml` remains the only runnable command source.
 
 Each executed command run writes a run record under `.mustflow/state/runs/run-*` and atomically updates `.mustflow/state/runs/latest.json`. The record includes the intent name, working directory, timeout, exit code, timeout status, and the tail of stdout and stderr.

package/dist/cli/commands/dashboard.js

@@ -1,5 +1,5 @@
 import { randomBytes } from 'node:crypto';
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, readFileSync, statSync } from 'node:fs';
 import http from 'node:http';
 import path from 'node:path';
 import { openPathInFileManager, openUrlInBrowser } from '../lib/browser-open.js';
@@ -14,8 +14,8 @@ import { readGitChangedFiles } from '../lib/git-changes.js';
 import { isRecord, readCommandContract, readPositiveInteger, readString, readStringArray, } from '../lib/command-contract.js';
 import { readDashboardPreferences, updateDashboardPreferences, } from '../lib/dashboard-preferences.js';
 import { DOC_REVIEW_LEDGER_RELATIVE_PATH, isDocReviewStatus, isReviewerKind, listDocReviewEntries, markDocReviewEntry, } from '../lib/doc-review-ledger.js';
-import { inspectManifestLock } from '../lib/manifest-lock.js';
-import { readLatestLocalVerificationReadModelQueries, readLocalCommandEffectGraphs, } from '../lib/local-index.js';
+import { MANIFEST_LOCK_RELATIVE_PATH, inspectManifestLock } from '../lib/manifest-lock.js';
+import { getLocalIndexDatabasePath, readLatestLocalVerificationReadModelQueries, readLocalCommandEffectGraphs, } from '../lib/local-index.js';
 import { readPackageMetadata } from '../lib/package-info.js';
 import { t } from '../lib/i18n.js';
 import { resolveMustflowRoot } from '../lib/project-root.js';
@@ -36,6 +36,61 @@ const RELEASE_FILE_PATTERNS = [
 ];
 const SKILL_INDEX_RELATIVE_PATH = '.mustflow/skills/INDEX.md';
 const LATEST_RUN_RELATIVE_PATH = '.mustflow/state/runs/latest.json';
+const COMMANDS_RELATIVE_PATH = '.mustflow/config/commands.toml';
+const AGENTS_RELATIVE_PATH = 'AGENTS.md';
+const STATUS_BLOCK_CACHE_TTL_MS = 750;
+const dashboardStatusBlockCache = new Map();
+function dashboardStatusBlockCacheKey(projectRoot, blockName) {
+    return `${path.resolve(projectRoot)}\0${blockName}`;
+}
+function readFileSignature(filePath) {
+    try {
+        const stat = statSync(filePath);
+        return `${stat.mtimeMs}:${stat.size}`;
+    }
+    catch {
+        return 'missing';
+    }
+}
+function readProjectFileSignature(projectRoot, relativePath) {
+    return `${relativePath}=${readFileSignature(path.join(projectRoot, ...relativePath.split('/')))}`;
+}
+function readStatusBlockSignature(projectRoot, relativePaths) {
+    return relativePaths.map((relativePath) => readProjectFileSignature(projectRoot, relativePath)).join('|');
+}
+function readLocalIndexSignature(projectRoot) {
+    return `local_index=${readFileSignature(getLocalIndexDatabasePath(projectRoot))}`;
+}
+function readDashboardStatusBlock(projectRoot, blockName, signature, readBlock) {
+    const key = dashboardStatusBlockCacheKey(projectRoot, blockName);
+    const cached = dashboardStatusBlockCache.get(key);
+    const now = Date.now();
+    if (cached && cached.signature === signature && cached.expiresAt > now) {
+        return cached.value;
+    }
+    const value = readBlock();
+    dashboardStatusBlockCache.set(key, {
+        signature,
+        expiresAt: Date.now() + STATUS_BLOCK_CACHE_TTL_MS,
+        value,
+    });
+    return value;
+}
+async function readDashboardStatusBlockAsync(projectRoot, blockName, signature, readBlock) {
+    const key = dashboardStatusBlockCacheKey(projectRoot, blockName);
+    const cached = dashboardStatusBlockCache.get(key);
+    const now = Date.now();
+    if (cached && cached.signature === signature && cached.expiresAt > now) {
+        return cached.value;
+    }
+    const value = await readBlock();
+    dashboardStatusBlockCache.set(key, {
+        signature,
+        expiresAt: Date.now() + STATUS_BLOCK_CACHE_TTL_MS,
+        value,
+    });
+    return value;
+}
 function readFrontmatterLines(content) {
     if (!content.startsWith('---')) {
         return [];
@@ -677,16 +732,17 @@ function renderRunHistoryResponse(projectRoot) {
 }
 async function renderStatusResponse(projectRoot) {
     const context = getAgentContext(projectRoot);
-    const manifest = inspectManifestLock(projectRoot);
+    const manifest = readDashboardStatusBlock(projectRoot, 'manifest', readStatusBlockSignature(projectRoot, [MANIFEST_LOCK_RELATIVE_PATH]), () => inspectManifestLock(projectRoot));
     const lock = manifest.readResult.kind === 'present' ? manifest.readResult.lock : undefined;
-    const activeDocuments = listDocReviewEntries(projectRoot);
-    const rawCommandContract = readDashboardCommandContract(projectRoot);
-    const commandContract = await renderCommandContractResponse(projectRoot, rawCommandContract);
+    const activeDocuments = readDashboardStatusBlock(projectRoot, 'doc_review', readStatusBlockSignature(projectRoot, [DOC_REVIEW_LEDGER_RELATIVE_PATH]), () => listDocReviewEntries(projectRoot));
+    const rawCommandContractSignature = readStatusBlockSignature(projectRoot, [COMMANDS_RELATIVE_PATH]);
+    const rawCommandContract = readDashboardStatusBlock(projectRoot, 'raw_command_contract', rawCommandContractSignature, () => readDashboardCommandContract(projectRoot));
+    const commandContract = await readDashboardStatusBlockAsync(projectRoot, 'command_contract', `${rawCommandContractSignature}|${readLocalIndexSignature(projectRoot)}`, () => renderCommandContractResponse(projectRoot, rawCommandContract));
     const gitChangedFilesResult = readGitChangedFiles(projectRoot);
     const gitChangedFiles = gitChangedFilesResult.ok ? gitChangedFilesResult.files : [];
     const packageMetadata = readPackageMetadata();
     const verification = createDashboardVerificationSnapshot(projectRoot, rawCommandContract, commandContract.intents, gitChangedFiles, manifest.changedFiles, manifest.missingFiles);
-    const readModel = await readLatestLocalVerificationReadModelQueries(projectRoot);
+    const readModel = await readDashboardStatusBlockAsync(projectRoot, 'verification_read_model', readLocalIndexSignature(projectRoot), () => readLatestLocalVerificationReadModelQueries(projectRoot));
     return {
         schema_version: '1',
         command: 'dashboard status',
@@ -696,12 +752,12 @@ async function renderStatusResponse(projectRoot) {
         release: {
             package_name: packageMetadata.name,
             package_version: packageMetadata.version,
-            version_sources: detectVersionSources(projectRoot),
+            version_sources: readDashboardStatusBlock(projectRoot, 'version_sources', readStatusBlockSignature(projectRoot, ['package.json']), () => detectVersionSources(projectRoot)),
             release_sensitive_changed_files: matchingFiles(gitChangedFiles, RELEASE_FILE_PATTERNS),
         },
-        update: renderUpdateResponse(projectRoot),
-        run_history: renderRunHistoryResponse(projectRoot),
-        skills: renderSkillsResponse(projectRoot),
+        update: readDashboardStatusBlock(projectRoot, 'update', readStatusBlockSignature(projectRoot, [AGENTS_RELATIVE_PATH, MANIFEST_LOCK_RELATIVE_PATH]), () => renderUpdateResponse(projectRoot)),
+        run_history: readDashboardStatusBlock(projectRoot, 'run_history', readStatusBlockSignature(projectRoot, [LATEST_RUN_RELATIVE_PATH]), () => renderRunHistoryResponse(projectRoot)),
+        skills: readDashboardStatusBlock(projectRoot, 'skills', readStatusBlockSignature(projectRoot, [SKILL_INDEX_RELATIVE_PATH]), () => renderSkillsResponse(projectRoot)),
         tracked_files: lock?.files.length ?? 0,
         changed_files: manifest.changedFiles,
         missing_files: manifest.missingFiles,

package/dist/cli/commands/init.js

@@ -1,9 +1,9 @@
-import { copyFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import path from 'node:path';
 import { stdin as processStdin, stdout as processStdout } from 'node:process';
 import { createInterface } from 'node:readline/promises';
 import { printUsageError, renderHelp } from '../lib/cli-output.js';
-import { ensureFileTargetInsideWithoutSymlinks, ensureInside, readUtf8FileInsideWithoutSymlinks, writeUtf8FileInsideWithoutSymlinks, } from '../lib/filesystem.js';
+import { copyFileInsideWithoutSymlinks, ensureFileTargetInsideWithoutSymlinks, ensureInside, readUtf8FileInsideWithoutSymlinks, writeUtf8FileInsideWithoutSymlinks, } from '../lib/filesystem.js';
 import { localeMessage, t } from '../lib/i18n.js';
 import { isLocaleTag } from '../lib/locale-tags.js';
 import { MANIFEST_LOCK_RELATIVE_PATH, sha256File } from '../lib/manifest-lock.js';
@@ -463,8 +463,11 @@ function parseOptions(args, reporter, lang) {
         preferenceOverrides,
     };
 }
-function sameTemplateFileContent(projectRoot, source, targetPath) {
-    return (source.content ?? readFileSync(source.sourcePath, 'utf8')) === readUtf8FileInsideWithoutSymlinks(projectRoot, targetPath);
+function readTemplateSourceText(templateRoot, sourcePath) {
+    return readUtf8FileInsideWithoutSymlinks(templateRoot, sourcePath);
+}
+function sameTemplateFileContent(projectRoot, templateRoot, source, targetPath) {
+    return (source.content ?? readTemplateSourceText(templateRoot, source.sourcePath)) === readUtf8FileInsideWithoutSymlinks(projectRoot, targetPath);
 }
 function formatLocaleChoice(locale) {
     const label = LOCALE_LABELS[locale] ?? locale;
@@ -605,11 +608,11 @@ async function promptInitOptions(template, options, reporter, lang) {
 function escapeRegExp(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
-function planStatus(projectRoot, source, targetPath, options) {
+function planStatus(projectRoot, templateRoot, source, targetPath, options) {
     if (!existsSync(targetPath)) {
         return 'create';
     }
-    if (sameTemplateFileContent(projectRoot, source, targetPath)) {
+    if (sameTemplateFileContent(projectRoot, templateRoot, source, targetPath)) {
         return 'unchanged';
     }
     if (options.force) {
@@ -620,17 +623,15 @@ function planStatus(projectRoot, source, targetPath, options) {
     }
     return 'conflict';
 }
-function writeTemplateFile(projectRoot, source, targetPath) {
+function writeTemplateFile(projectRoot, templateRoot, source, targetPath) {
     if (source.content !== undefined) {
         writeUtf8FileInsideWithoutSymlinks(projectRoot, targetPath, source.content);
         return;
     }
-    ensureFileTargetInsideWithoutSymlinks(projectRoot, targetPath, { allowMissingLeaf: true });
-    mkdirSync(path.dirname(targetPath), { recursive: true });
-    copyFileSync(source.sourcePath, targetPath);
+    copyFileInsideWithoutSymlinks(templateRoot, source.sourcePath, projectRoot, targetPath);
 }
 function writePlannedFile(projectRoot, file) {
-    writeTemplateFile(projectRoot, file, file.targetPath);
+    writeTemplateFile(projectRoot, file.sourceRoot, file, file.targetPath);
 }
 function gitignoreFragmentPath(template) {
     return path.join(template.templateRoot, template.manifest.commonRoot, GITIGNORE_FRAGMENT_RELATIVE_PATH);
@@ -646,11 +647,11 @@ function mergeGitignoreContent(existingContent, fragmentContent) {
     }
     return `${existingContent.trimEnd()}\n\n${normalizedFragment}\n`;
 }
-function planGitignoreStatus(projectRoot, sourcePath, targetPath) {
+function planGitignoreStatus(projectRoot, sourceRoot, sourcePath, targetPath) {
     if (!existsSync(targetPath)) {
         return 'create';
     }
-    const mergedContent = mergeGitignoreContent(readUtf8FileInsideWithoutSymlinks(projectRoot, targetPath), readFileSync(sourcePath, 'utf8'));
+    const mergedContent = mergeGitignoreContent(readUtf8FileInsideWithoutSymlinks(projectRoot, targetPath), readTemplateSourceText(sourceRoot, sourcePath));
     return mergedContent === readUtf8FileInsideWithoutSymlinks(projectRoot, targetPath) ? 'unchanged' : 'merge';
 }
 function renderPlanVerb(status) {
@@ -699,10 +700,11 @@ function buildPlannedFiles(template, selectedLocale, targetRoot, options) {
         return {
             relativePath: source.relativePath,
             sourcePath: source.sourcePath,
+            sourceRoot: template.templateRoot,
             sourceKind: source.sourceKind,
             content: source.content,
             targetPath,
-            status: planStatus(targetRoot, source, targetPath, options),
+            status: planStatus(targetRoot, template.templateRoot, source, targetPath, options),
             lock: true,
         };
     });
@@ -714,9 +716,10 @@ function buildPlannedFiles(template, selectedLocale, targetRoot, options) {
     plannedFiles.push({
         relativePath: GITIGNORE_RELATIVE_PATH,
         sourcePath,
+        sourceRoot: template.templateRoot,
         sourceKind: 'common',
         targetPath,
-        status: planGitignoreStatus(targetRoot, sourcePath, targetPath),
+        status: planGitignoreStatus(targetRoot, template.templateRoot, sourcePath, targetPath),
         lock: false,
     });
     return plannedFiles;
@@ -730,10 +733,7 @@ function backupConflictingFiles(projectRoot, conflicts) {
     for (const conflict of conflicts) {
         const backupPath = path.join(backupRoot, conflict.relativePath);
         ensureInside(backupRoot, backupPath);
-        ensureFileTargetInsideWithoutSymlinks(projectRoot, conflict.targetPath);
-        ensureFileTargetInsideWithoutSymlinks(projectRoot, backupPath, { allowMissingLeaf: true });
-        mkdirSync(path.dirname(backupPath), { recursive: true });
-        copyFileSync(conflict.targetPath, backupPath);
+        copyFileInsideWithoutSymlinks(projectRoot, conflict.targetPath, projectRoot, backupPath);
     }
     return backupRoot;
 }
@@ -960,7 +960,7 @@ export async function runInit(args, reporter, lang = 'en') {
         if (file.status === 'merge') {
             ensureFileTargetInsideWithoutSymlinks(targetRoot, file.targetPath);
             const mergedContent = file.relativePath === GITIGNORE_RELATIVE_PATH
-                ? mergeGitignoreContent(readUtf8FileInsideWithoutSymlinks(targetRoot, file.targetPath), readFileSync(file.sourcePath, 'utf8'))
+                ? mergeGitignoreContent(readUtf8FileInsideWithoutSymlinks(targetRoot, file.targetPath), readTemplateSourceText(file.sourceRoot, file.sourcePath))
                 : mergeAgentsContent(readUtf8FileInsideWithoutSymlinks(targetRoot, file.targetPath), selectedLocale);
             writeUtf8FileInsideWithoutSymlinks(targetRoot, file.targetPath, mergedContent);
             merged += 1;

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

@@ -1,8 +1,9 @@
 import { spawn } from 'node:child_process';
 import { BoundedOutputBuffer } from '../../../core/bounded-output.js';
-import { createPendingTimeoutTermination, forceTerminateProcessTreeNonBlocking, getKillMethod, terminateProcessTreeNonBlocking, } from './process-tree.js';
+import { createPendingTimeoutTermination, forceTerminateProcessTree, getKillMethod, terminateProcessTree, } from './process-tree.js';
 import { createOutputLimitError, isOutputLimitExceededError, writeStreamChunk } from './output.js';
-function runSpawnedCommandStreaming(command, cwd, env, timeoutSeconds, maxOutputBytes, stdoutTailBytes, stderrTailBytes, reporter, streamOutput, enforceOutputLimit) {
+const TERMINATION_CONFIRMATION_FALLBACK_MS = 1000;
+function runSpawnedCommandStreaming(command, cwd, env, timeoutSeconds, killAfterSeconds, maxOutputBytes, stdoutTailBytes, stderrTailBytes, reporter, streamOutput, enforceOutputLimit) {
     return new Promise((resolve) => {
         const stdout = new BoundedOutputBuffer(stdoutTailBytes);
         const stderr = new BoundedOutputBuffer(stderrTailBytes);
@@ -13,6 +14,9 @@ function runSpawnedCommandStreaming(command, cwd, env, timeoutSeconds, maxOutput
         let stdoutBytes = 0;
         let stderrBytes = 0;
         let timeout;
+        let forceKillTimeout;
+        let terminationFallbackTimeout;
+        let terminationStarted = false;
         let termination = null;
         const child = spawn(command.executable, command.args ?? [], {
             cwd,
@@ -23,7 +27,7 @@ function runSpawnedCommandStreaming(command, cwd, env, timeoutSeconds, maxOutput
             detached: process.platform !== 'win32',
         });
         childPid = child.pid;
-        const finish = (status, signal) => {
+        const finish = (status, signal, terminationConfirmed = true) => {
             if (settled) {
                 return;
             }
@@ -31,6 +35,19 @@ function runSpawnedCommandStreaming(command, cwd, env, timeoutSeconds, maxOutput
             if (timeout) {
                 clearTimeout(timeout);
             }
+            if (forceKillTimeout) {
+                clearTimeout(forceKillTimeout);
+            }
+            if (terminationFallbackTimeout) {
+                clearTimeout(terminationFallbackTimeout);
+            }
+            const confirmedTermination = termination ?
+                {
+                    ...termination,
+                    confirmed: terminationConfirmed,
+                    cleanup_pending: !terminationConfirmed,
+                } :
+                null;
             resolve({
                 status: timedOut ? null : status,
                 signal: timedOut ? null : signal,
@@ -38,20 +55,42 @@ function runSpawnedCommandStreaming(command, cwd, env, timeoutSeconds, maxOutput
                 stdout: stdout.toSnapshot(),
                 stderr: stderr.toSnapshot(),
                 pid: childPid,
-                termination,
+                termination: confirmedTermination,
             });
         };
+        const beginTermination = () => {
+            if (terminationStarted) {
+                return;
+            }
+            terminationStarted = true;
+            child.stdout?.destroy();
+            child.stderr?.destroy();
+            terminateProcessTree(childPid);
+            const forceAfterMs = killAfterSeconds * 1000;
+            forceKillTimeout = setTimeout(() => {
+                if (termination) {
+                    termination = {
+                        ...termination,
+                        forced_kill_attempted: true,
+                    };
+                }
+                forceTerminateProcessTree(childPid);
+            }, forceAfterMs);
+            terminationFallbackTimeout = setTimeout(() => {
+                child.unref();
+                finish(null, null, false);
+            }, forceAfterMs + TERMINATION_CONFIRMATION_FALLBACK_MS);
+        };
         const stopForOutputLimit = (stream) => {
             if (settled || childError) {
                 return;
             }
             childError = createOutputLimitError(stream, maxOutputBytes);
-            child.stdout?.destroy();
-            child.stderr?.destroy();
-            child.unref();
-            terminateProcessTreeNonBlocking(childPid);
-            forceTerminateProcessTreeNonBlocking(childPid);
-            finish(null, null);
+            if (timeout) {
+                clearTimeout(timeout);
+                timeout = undefined;
+            }
+            beginTermination();
         };
         child.stdout?.on('data', (chunk) => {
             stdout.append(chunk);
@@ -80,22 +119,20 @@ function runSpawnedCommandStreaming(command, cwd, env, timeoutSeconds, maxOutput
             finish(status, signal);
         });
         timeout = setTimeout(() => {
+            if (settled || childError) {
+                return;
+            }
             timedOut = true;
-            child.stdout?.destroy();
-            child.stderr?.destroy();
-            child.unref();
             termination = createPendingTimeoutTermination(getKillMethod());
-            terminateProcessTreeNonBlocking(childPid);
-            forceTerminateProcessTreeNonBlocking(childPid);
-            finish(null, null);
+            beginTermination();
         }, timeoutSeconds * 1000);
     });
 }
-export function runArgvCommandStreaming(command, cwd, env, timeoutSeconds, maxOutputBytes, stdoutTailBytes, stderrTailBytes, reporter, streamOutput, enforceOutputLimit) {
-    return runSpawnedCommandStreaming({ executable: command?.executable ?? '', args: command?.args ?? [], shell: command?.shell ?? false }, cwd, env, timeoutSeconds, maxOutputBytes, stdoutTailBytes, stderrTailBytes, reporter, streamOutput, enforceOutputLimit);
+export function runArgvCommandStreaming(command, cwd, env, timeoutSeconds, killAfterSeconds, maxOutputBytes, stdoutTailBytes, stderrTailBytes, reporter, streamOutput, enforceOutputLimit) {
+    return runSpawnedCommandStreaming({ executable: command?.executable ?? '', args: command?.args ?? [], shell: command?.shell ?? false }, cwd, env, timeoutSeconds, killAfterSeconds, maxOutputBytes, stdoutTailBytes, stderrTailBytes, reporter, streamOutput, enforceOutputLimit);
 }
-export function runShellCommandStreaming(command, cwd, env, timeoutSeconds, maxOutputBytes, stdoutTailBytes, stderrTailBytes, reporter, streamOutput, enforceOutputLimit) {
-    return runSpawnedCommandStreaming({ executable: command ?? '', shell: true }, cwd, env, timeoutSeconds, maxOutputBytes, stdoutTailBytes, stderrTailBytes, reporter, streamOutput, enforceOutputLimit);
+export function runShellCommandStreaming(command, cwd, env, timeoutSeconds, killAfterSeconds, maxOutputBytes, stdoutTailBytes, stderrTailBytes, reporter, streamOutput, enforceOutputLimit) {
+    return runSpawnedCommandStreaming({ executable: command ?? '', shell: true }, cwd, env, timeoutSeconds, killAfterSeconds, maxOutputBytes, stdoutTailBytes, stderrTailBytes, reporter, streamOutput, enforceOutputLimit);
 }
 export function getRunStatus(error, exitCode, successExitCodes) {
     const errorWithCode = error;

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

@@ -78,13 +78,13 @@ export function forceTerminateProcessTreeNonBlocking(pid) {
 export function getKillMethod() {
     return process.platform === 'win32' ? 'taskkill_process_tree' : 'process_group_sigterm';
 }
-export function createPendingTimeoutTermination(method) {
+export function createPendingTimeoutTermination(method, forcedKillAttempted = false) {
     return {
         reason: 'timeout',
         method,
         graceful_signal: 'SIGTERM',
         forced_signal: 'SIGKILL',
-        forced_kill_attempted: true,
+        forced_kill_attempted: forcedKillAttempted,
         confirmed: false,
         cleanup_pending: true,
     };

package/dist/cli/commands/run.js

@@ -5,14 +5,13 @@ import { readCommandContract, readMustflowConfigIfExists } from '../../core/conf
 import { resolveRunReceiptRetentionPolicy } from '../../core/retention-policy.js';
 import { t } from '../lib/i18n.js';
 import { resolveMustflowRoot } from '../lib/project-root.js';
-import { createRunPlan, createRunPreview, isMustflowBuiltinIntent, renderRunPreviewText, } from '../lib/run-plan.js';
+import { createRunPlan, createRunPreview, renderRunPreviewText, } from '../lib/run-plan.js';
 import { writeRunReceipt, } from '../../core/run-receipt.js';
 import { recordRunPerformanceHistory } from '../../core/run-performance-history.js';
 import { RunProfiler } from '../../core/run-profile.js';
 import { finishRunWriteTracking, startRunWriteTracking } from '../../core/run-write-drift.js';
-import { runBuiltinArgvInProcess } from './run/builtin-dispatch.js';
 import { getRunStatus, runArgvCommandStreaming, runShellCommandStreaming } from './run/executor.js';
-import { emitOutput } from './run/output.js';
+import { emitOutput, isOutputLimitExceededError } from './run/output.js';
 import { createPendingTimeoutTermination, getKillMethod, terminateProcessTree } from './run/process-tree.js';
 import { assembleRunReceipt } from './run/receipt.js';
 function getRunPlanDetail(plan, lang, fallbackKey) {
@@ -179,18 +178,12 @@ export async function runRun(args, reporter, lang = 'en', options = {}) {
     const childStartedAtMs = performance.now();
     const startedAt = new Date();
     const result = await profiler.measureAsync('child_command', async () => {
-        if (plan.commandArgv && isMustflowBuiltinIntent(plan.intent)) {
-            const builtinResult = await runBuiltinArgvInProcess(plan.commandArgv, plan.cwd, lang);
-            if (builtinResult) {
-                return builtinResult;
-            }
-        }
         if (plan.commandArgv) {
             streamedOutput = !json;
-            return runArgvCommandStreaming(plan.argvCommand, plan.cwd, env, plan.timeoutSeconds, plan.maxOutputBytes, stdoutTailBytes, stderrTailBytes, reporter, !json, json);
+            return runArgvCommandStreaming(plan.argvCommand, plan.cwd, env, plan.timeoutSeconds, plan.killAfterSeconds, plan.maxOutputBytes, stdoutTailBytes, stderrTailBytes, reporter, !json, true);
         }
         streamedOutput = !json;
-        return runShellCommandStreaming(plan.shellCommand, plan.cwd, env, plan.timeoutSeconds, plan.maxOutputBytes, stdoutTailBytes, stderrTailBytes, reporter, !json, json);
+        return runShellCommandStreaming(plan.shellCommand, plan.cwd, env, plan.timeoutSeconds, plan.killAfterSeconds, plan.maxOutputBytes, stdoutTailBytes, stderrTailBytes, reporter, !json, true);
     });
     const childDurationMs = performance.now() - childStartedAtMs;
     const finishedAt = new Date();
@@ -247,6 +240,10 @@ export async function runRun(args, reporter, lang = 'en', options = {}) {
             reporter.stderr(t(lang, 'run.error.timedOut', { intent: intentName, seconds: plan.timeoutSeconds }));
             return 1;
         }
+        if (isOutputLimitExceededError(result.error)) {
+            reporter.stderr(t(lang, 'run.error.outputLimitExceeded', { intent: intentName, message: result.error.message }));
+            return 1;
+        }
         reporter.stderr(t(lang, 'run.error.startFailed', { intent: intentName, message: result.error.message }));
         return 1;
     }

package/dist/cli/commands/update.js

@@ -1,7 +1,7 @@
 import { createHash } from 'node:crypto';
-import { copyFileSync, existsSync, mkdirSync } from 'node:fs';
+import { existsSync } from 'node:fs';
 import path from 'node:path';
-import { ensureFileTargetInsideWithoutSymlinks, ensureInside, writeUtf8FileInsideWithoutSymlinks, } from '../lib/filesystem.js';
+import { copyFileInsideWithoutSymlinks, ensureFileTargetInsideWithoutSymlinks, ensureInside, writeUtf8FileInsideWithoutSymlinks, } from '../lib/filesystem.js';
 import { MANIFEST_LOCK_RELATIVE_PATH, readManifestLock, sha256File } from '../lib/manifest-lock.js';
 import { printUsageError, renderHelp } from '../lib/cli-output.js';
 import { t } from '../lib/i18n.js';
@@ -70,14 +70,12 @@ function lockedTemplateSkillNames(files) {
 function getInstalledTemplateFiles(projectRoot, template, lock) {
     return getTemplateFiles(template, lock.templateLocale ?? template.manifest.defaultLocale, lock.templateProfile ?? template.manifest.defaultProfile, { extraSkillNames: lockedTemplateSkillNames(lock.files) });
 }
-function writeTemplateFile(projectRoot, source, targetPath) {
+function writeTemplateFile(projectRoot, templateRoot, source, targetPath) {
     if (source.content !== undefined) {
         writeUtf8FileInsideWithoutSymlinks(projectRoot, targetPath, source.content);
         return;
     }
-    ensureFileTargetInsideWithoutSymlinks(projectRoot, targetPath, { allowMissingLeaf: true });
-    mkdirSync(path.dirname(targetPath), { recursive: true });
-    copyFileSync(source.sourcePath, targetPath);
+    copyFileInsideWithoutSymlinks(templateRoot, source.sourcePath, projectRoot, targetPath);
 }
 function templateTargetSafetyIssue(projectRoot, targetPath, allowMissingLeaf) {
     try {
@@ -223,7 +221,7 @@ function copyTemplateFile(projectRoot, relativePath) {
     ensureInside(template.templateRoot, source.sourcePath);
     ensureInside(projectRoot, targetPath);
     ensureFileTargetInsideWithoutSymlinks(projectRoot, targetPath, { allowMissingLeaf: true });
-    writeTemplateFile(projectRoot, source, targetPath);
+    writeTemplateFile(projectRoot, template.templateRoot, source, targetPath);
 }
 function backupUpdateFiles(projectRoot, items, reporter, lang) {
     const updateItems = items.filter((item) => item.action === 'update');
@@ -237,10 +235,7 @@ function backupUpdateFiles(projectRoot, items, reporter, lang) {
         const backupPath = path.join(backupRoot, item.relativePath);
         ensureInside(projectRoot, sourcePath);
         ensureInside(backupRoot, backupPath);
-        ensureFileTargetInsideWithoutSymlinks(projectRoot, sourcePath);
-        ensureFileTargetInsideWithoutSymlinks(projectRoot, backupPath, { allowMissingLeaf: true });
-        mkdirSync(path.dirname(backupPath), { recursive: true });
-        copyFileSync(sourcePath, backupPath);
+        copyFileInsideWithoutSymlinks(projectRoot, sourcePath, projectRoot, backupPath);
     }
     reporter.stdout(t(lang, 'update.backup.files', {
         count: updateItems.length,

package/dist/cli/i18n/en.js

@@ -672,6 +672,7 @@ Read these files before working:
     "run.error.maxOutputBytesDetail": "The output limit must stay within the allowed maximum.",
     "run.error.conflictingPreviewModes": "Use either --dry-run or --plan-only, not both",
     "run.error.timedOut": 'Command "{intent}" timed out after {seconds} seconds',
+    "run.error.outputLimitExceeded": 'Command "{intent}" exceeded max_output_bytes: {message}',
     "run.error.startFailed": 'Command "{intent}" failed to start: {message}',
     "search.help.summary": "Search the local SQLite index for the mustflow workflow.",
     "search.help.option.limit": "Set the number of results to print. Default: 10, max: 50",

package/dist/cli/i18n/es.js

@@ -672,6 +672,7 @@ Lee estos archivos antes de trabajar:
     "run.error.maxOutputBytesDetail": "El límite de salida debe permanecer dentro del máximo permitido.",
     "run.error.conflictingPreviewModes": "Usa --dry-run o --plan-only, no ambos",
     "run.error.timedOut": 'El comando "{intent}" agotó el tiempo después de {seconds} segundos',
+    "run.error.outputLimitExceeded": 'El comando "{intent}" superó max_output_bytes: {message}',
     "run.error.startFailed": 'No se pudo iniciar el comando "{intent}": {message}',
     "search.help.summary": "Busca en el índice SQLite local del flujo de trabajo mustflow.",
     "search.help.option.limit": "Define la cantidad de resultados que se imprimen. Predeterminado: 10, máximo: 50",

package/dist/cli/i18n/fr.js

@@ -672,6 +672,7 @@ Lisez ces fichiers avant de travailler :
     "run.error.maxOutputBytesDetail": "La limite de sortie doit rester dans le maximum autorisé.",
     "run.error.conflictingPreviewModes": "Utilisez --dry-run ou --plan-only, pas les deux",
     "run.error.timedOut": 'La commande "{intent}" a expiré après {seconds} secondes',
+    "run.error.outputLimitExceeded": 'La commande "{intent}" a dépassé max_output_bytes : {message}',
     "run.error.startFailed": 'Impossible de démarrer la commande "{intent}" : {message}',
     "search.help.summary": "Recherche dans l'index SQLite local du flux de travail mustflow.",
     "search.help.option.limit": "Définit le nombre de résultats à imprimer. Par défaut : 10, max : 50",

package/dist/cli/i18n/hi.js

@@ -672,6 +672,7 @@ export const hiMessages = {
     "run.error.maxOutputBytesDetail": "Output limit अनुमत maximum के अंदर रहनी चाहिए।",
     "run.error.conflictingPreviewModes": "--dry-run या --plan-only में से एक इस्तेमाल करें, दोनों नहीं",
     "run.error.timedOut": 'कमांड "{intent}" {seconds} सेकंड बाद time out हुई',
+    "run.error.outputLimitExceeded": 'कमांड "{intent}" ने max_output_bytes सीमा पार की: {message}',
     "run.error.startFailed": 'कमांड "{intent}" शुरू नहीं हो सकी: {message}',
     "search.help.summary": "mustflow वर्कफ़्लो के लिए स्थानीय SQLite इंडेक्स में खोजें।",
     "search.help.option.limit": "प्रिंट किए जाने वाले परिणामों की संख्या सेट करें। डिफ़ॉल्ट: 10, अधिकतम: 50",

package/dist/cli/i18n/ko.js

@@ -672,6 +672,7 @@ export const koMessages = {
     "run.error.maxOutputBytesDetail": "출력 상한은 허용된 최댓값 안에 있어야 합니다.",
     "run.error.conflictingPreviewModes": "--dry-run과 --plan-only 중 하나만 사용하세요",
     "run.error.timedOut": '명령 "{intent}"가 {seconds}초 뒤 시간 초과되었습니다',
+    "run.error.outputLimitExceeded": '명령 "{intent}"가 max_output_bytes 제한을 넘었습니다: {message}',
     "run.error.startFailed": '명령 "{intent}"를 시작하지 못했습니다: {message}',
     "search.help.summary": "로컬 SQLite 색인에서 mustflow 워크플로우를 검색합니다.",
     "search.help.option.limit": "출력할 검색 결과 수를 설정합니다. 기본값: 10, 최대: 50",

package/dist/cli/i18n/zh.js

@@ -672,6 +672,7 @@ export const zhMessages = {
     "run.error.maxOutputBytesDetail": "输出限制必须保持在允许的最大值内。",
     "run.error.conflictingPreviewModes": "只能使用 --dry-run 或 --plan-only，不能同时使用",
     "run.error.timedOut": '命令 "{intent}" 在 {seconds} 秒后超时',
+    "run.error.outputLimitExceeded": '命令 "{intent}" 超过 max_output_bytes：{message}',
     "run.error.startFailed": '命令 "{intent}" 启动失败：{message}',
     "search.help.summary": "搜索本地 SQLite 索引中的 mustflow 工作流。",
     "search.help.option.limit": "设置要输出的结果数量。默认值：10，最大：50",

package/dist/cli/lib/dashboard-export.js

@@ -4,6 +4,7 @@ import { createDashboardCompletionVerdict } from '../../core/completion-verdict.
 import { createDashboardEvidenceModel } from '../../core/verification-evidence.js';
 import { redactSecretLikeText } from '../../core/secret-redaction.js';
 import { ensureFileTargetInsideWithoutSymlinks, ensureInside, toPosixPath, writeUtf8FileInsideWithoutSymlinks, } from './filesystem.js';
+import { safeJsonForInlineScript } from './html-json.js';
 export class DashboardExportPathError extends Error {
     targetPath;
     constructor(targetPath) {
@@ -634,7 +635,7 @@ export function renderDashboardExportHtml(snapshot) {
     const graphSummary = asRecord(harnessVerification.decision_graph_summary);
     const harnessRunHistory = asRecord(harnessReport.run_history);
     const harnessDocsReview = asRecord(harnessReport.docs_review);
-    const embeddedJson = JSON.stringify(snapshot).replace(/</gu, '\\u003c');
+    const embeddedJson = safeJsonForInlineScript(snapshot);
     return `<!doctype html>
 <html lang="en">
 <head>

package/dist/cli/lib/dashboard-html/locale-bootstrap.js

@@ -1,8 +1,9 @@
 import { getDashboardLocaleBundle } from '../dashboard-locale.js';
+import { safeJsonForInlineScript } from '../html-json.js';
 export function createDashboardLocaleBootstrap() {
     const localeBundle = getDashboardLocaleBundle();
     return {
-        serializedLocaleBundle: JSON.stringify(localeBundle),
-        serializedAvailableLocales: JSON.stringify(localeBundle.locales),
+        serializedLocaleBundle: safeJsonForInlineScript(localeBundle),
+        serializedAvailableLocales: safeJsonForInlineScript(localeBundle.locales),
     };
 }

package/dist/cli/lib/dashboard-html/template.js

@@ -1,3 +1,4 @@
+import { safeJsonForInlineScript } from '../html-json.js';
 import { renderDashboardClientScript } from './client-script.js';
 import { createDashboardLocaleBootstrap } from './locale-bootstrap.js';
 import { renderDashboardStyles } from './styles.js';
@@ -12,10 +13,10 @@ function escapeHtml(value) {
 export function renderDashboardHtml(snapshot, token, statusSnapshot, docReviewSnapshot) {
     const root = escapeHtml(snapshot.projectRoot);
     const preferencesPath = escapeHtml(snapshot.preferencesPath);
-    const serializedSnapshot = JSON.stringify(snapshot);
-    const serializedStatusSnapshot = JSON.stringify(statusSnapshot);
-    const serializedDocReviewSnapshot = JSON.stringify(docReviewSnapshot);
-    const serializedToken = JSON.stringify(token);
+    const serializedSnapshot = safeJsonForInlineScript(snapshot);
+    const serializedStatusSnapshot = safeJsonForInlineScript(statusSnapshot);
+    const serializedDocReviewSnapshot = safeJsonForInlineScript(docReviewSnapshot);
+    const serializedToken = safeJsonForInlineScript(token);
     const { serializedLocaleBundle, serializedAvailableLocales } = createDashboardLocaleBootstrap();
     return `<!doctype html>
 <html lang="en">