mustflow 1.18.16 → 1.30.0

package/dist/core/adapter-compatibility.js

@@ -0,0 +1,235 @@
+import { existsSync, lstatSync, readFileSync, readdirSync } from 'node:fs';
+import path from 'node:path';
+const ADAPTER_SCHEMA_VERSION = '1';
+const MAX_HOST_INSTRUCTION_BYTES = 256 * 1024;
+const MAX_CURSOR_RULE_FILES = 100;
+const HOST_INSTRUCTION_FILES = [
+    { host: 'claude_code', path: 'CLAUDE.md' },
+    { host: 'gemini_cli', path: 'GEMINI.md' },
+    { host: 'github_copilot', path: '.github/copilot-instructions.md' },
+];
+const ADAPTER_SURFACE_DEFINITIONS = [
+    { host: 'claude_code', path: 'CLAUDE.md', kind: 'host_instruction_file' },
+    { host: 'gemini_cli', path: 'GEMINI.md', kind: 'host_instruction_file' },
+    { host: 'github_copilot', path: '.github/copilot-instructions.md', kind: 'host_instruction_file' },
+    { host: 'cursor', path: '.cursor/rules/', kind: 'host_instruction_file' },
+    { host: 'generic', path: '.vscode/settings.json', kind: 'editor_settings' },
+    { host: 'generic', path: '.github/workflows/', kind: 'ci_configuration' },
+    { host: 'generic', path: 'Makefile', kind: 'command_adapter' },
+    { host: 'generic', path: 'justfile', kind: 'command_adapter' },
+    { host: 'generic', path: 'Justfile', kind: 'command_adapter' },
+    { host: 'generic', path: 'Taskfile.yml', kind: 'command_adapter' },
+    { host: 'generic', path: 'package.json#scripts', kind: 'package_manager_scripts' },
+];
+const HOST_AGENT_CONFLICT_PATTERNS = [
+    /\bignore\s+AGENTS\.md\b/iu,
+    /\bdo\s+not\s+(?:read|follow|use)\s+AGENTS\.md\b/iu,
+    /\boverride\s+AGENTS\.md\b/iu,
+    /\binstead\s+of\s+AGENTS\.md\b/iu,
+    /\bAGENTS\.md\s+(?:does\s+not|doesn't)\s+apply\b/iu,
+];
+const DIRECT_COMMAND_PATTERNS = [
+    /\b(?:npm|pnpm|bun|yarn)\s+(?:run\s+)?(?:test|build|lint|check)\b/iu,
+    /\bdeno\s+task\b/iu,
+    /\bcargo\s+(?:test|build|check|clippy)\b/iu,
+    /\bgo\s+test\b/iu,
+    /\bmake\s+[A-Za-z0-9_-]+\b/iu,
+    /\bjust\s+[A-Za-z0-9_-]+\b/iu,
+];
+function toPosixPath(value) {
+    return value.split(path.sep).join('/');
+}
+function resolveProjectPath(projectRoot, relativePath) {
+    return path.join(projectRoot, ...relativePath.split('/'));
+}
+function fileExists(projectRoot, relativePath) {
+    return existsSync(resolveProjectPath(projectRoot, relativePath));
+}
+function packageScriptsExist(projectRoot) {
+    const packageJsonPath = resolveProjectPath(projectRoot, 'package.json');
+    if (!existsSync(packageJsonPath)) {
+        return false;
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+        return !!parsed.scripts && typeof parsed.scripts === 'object';
+    }
+    catch {
+        return false;
+    }
+}
+function surfaceExists(projectRoot, surfacePath) {
+    if (surfacePath === 'package.json#scripts') {
+        return packageScriptsExist(projectRoot);
+    }
+    const relativePath = surfacePath.endsWith('/') ? surfacePath.slice(0, -1) : surfacePath;
+    return fileExists(projectRoot, relativePath);
+}
+function makeHostFile(definition, status) {
+    return {
+        host: definition.host,
+        path: definition.path,
+        status,
+        instruction_role: 'host_instruction',
+        authority: 'host_specific',
+        mustflow_authority: 'advisory',
+        lifecycle: 'user_editable',
+        generated_by_mustflow: false,
+        binding_to_host: status === 'present',
+        mustflow_command_authority: false,
+    };
+}
+function makeFinding(severity, code, pathValue, message, requiredChange) {
+    return {
+        severity,
+        code,
+        path: pathValue,
+        message,
+        required_change: requiredChange,
+    };
+}
+function readHostInstruction(projectRoot, relativePath) {
+    const fullPath = resolveProjectPath(projectRoot, relativePath);
+    if (!existsSync(fullPath)) {
+        return { status: 'absent', text: null };
+    }
+    try {
+        const stat = lstatSync(fullPath);
+        if (stat.isSymbolicLink()) {
+            return {
+                status: 'symlink_not_read',
+                text: null,
+                finding: makeFinding('warning', 'host_instruction_symlink_not_read', relativePath, 'Host instruction path is a symbolic link, so mustflow did not read its target.', false),
+            };
+        }
+        if (!stat.isFile()) {
+            return {
+                status: 'unreadable',
+                text: null,
+                finding: makeFinding('warning', 'host_instruction_not_regular_file', relativePath, 'Host instruction path exists but is not a regular file.', false),
+            };
+        }
+        if (stat.size > MAX_HOST_INSTRUCTION_BYTES) {
+            return {
+                status: 'too_large_not_read',
+                text: null,
+                finding: makeFinding('warning', 'host_instruction_too_large_not_read', relativePath, 'Host instruction file is larger than the read limit, so mustflow reported metadata only.', false),
+            };
+        }
+        return { status: 'present', text: readFileSync(fullPath, 'utf8') };
+    }
+    catch {
+        return {
+            status: 'unreadable',
+            text: null,
+            finding: makeFinding('warning', 'host_instruction_unreadable', relativePath, 'Host instruction file could not be read.', false),
+        };
+    }
+}
+function collectCursorRuleDefinitions(projectRoot) {
+    const cursorRulesPath = resolveProjectPath(projectRoot, '.cursor/rules');
+    if (!existsSync(cursorRulesPath)) {
+        return [];
+    }
+    try {
+        const stat = lstatSync(cursorRulesPath);
+        if (!stat.isDirectory() || stat.isSymbolicLink()) {
+            return [{ host: 'cursor', path: '.cursor/rules/' }];
+        }
+        return readdirSync(cursorRulesPath, { withFileTypes: true })
+            .filter((entry) => entry.isFile() && (entry.name.endsWith('.md') || entry.name.endsWith('.mdc')))
+            .map((entry) => ({ host: 'cursor', path: `.cursor/rules/${entry.name}` }))
+            .sort((left, right) => left.path.localeCompare(right.path))
+            .slice(0, MAX_CURSOR_RULE_FILES);
+    }
+    catch {
+        return [{ host: 'cursor', path: '.cursor/rules/' }];
+    }
+}
+function inspectHostInstruction(definition, text) {
+    if (!text) {
+        return [];
+    }
+    const findings = [
+        makeFinding('info', 'host_instruction_present', definition.path, 'Host-specific instruction file is present. It may guide that host, but it is not mustflow command authority.', false),
+    ];
+    if (HOST_AGENT_CONFLICT_PATTERNS.some((pattern) => pattern.test(text))) {
+        findings.push(makeFinding('warning', 'host_instruction_conflicts_with_agents', definition.path, 'Host instruction appears to tell agents to ignore or override AGENTS.md. Resolve the instruction conflict before relying on the host adapter.', true));
+    }
+    if (DIRECT_COMMAND_PATTERNS.some((pattern) => pattern.test(text))) {
+        findings.push(makeFinding('warning', 'host_instruction_direct_command_hint', definition.path, 'Host instruction mentions direct tool commands. Agents must still use configured mustflow command intents for project verification.', false));
+    }
+    return findings;
+}
+function buildAdapterSurfaces(projectRoot) {
+    return ADAPTER_SURFACE_DEFINITIONS.map((definition) => ({
+        host: definition.host,
+        path: definition.path,
+        kind: definition.kind,
+        present: surfaceExists(projectRoot, definition.path),
+        generated_by_mustflow: false,
+        generation_policy: 'explicit_user_request_only',
+        mustflow_command_authority: false,
+    }));
+}
+export function inspectAdapterCompatibility(projectRoot) {
+    const hostDefinitions = [...HOST_INSTRUCTION_FILES, ...collectCursorRuleDefinitions(projectRoot)];
+    const hostFiles = [];
+    const findings = [
+        makeFinding('info', 'command_authority_boundary', '.mustflow/config/commands.toml', 'Project command authority remains .mustflow/config/commands.toml; host-specific files cannot authorize command execution.', false),
+        makeFinding('info', 'adapter_generation_not_default', null, 'mustflow does not generate host adapters, editor settings, CI files, Makefile, justfile, Taskfile.yml, or package-manager scripts by default.', false),
+        makeFinding('info', 'runtime_policy_not_repo_visible', null, 'Host approval and sandbox policies are runtime settings, so this report can only inspect repository-visible compatibility hints.', false),
+    ];
+    for (const definition of hostDefinitions) {
+        const read = readHostInstruction(projectRoot, definition.path);
+        hostFiles.push(makeHostFile(definition, read.status));
+        if (read.finding) {
+            findings.push(read.finding);
+        }
+        findings.push(...inspectHostInstruction(definition, read.text));
+    }
+    const adapterSurfaces = buildAdapterSurfaces(projectRoot);
+    const compatibilityNotes = findings.filter((finding) => !finding.required_change);
+    const requiredChanges = findings.filter((finding) => finding.required_change);
+    const doesNotGenerate = ADAPTER_SURFACE_DEFINITIONS.map((definition) => definition.path);
+    return {
+        schema_version: ADAPTER_SCHEMA_VERSION,
+        command: 'adapters_status',
+        ok: true,
+        mustflow_root: projectRoot,
+        agents_file: {
+            path: 'AGENTS.md',
+            present: fileExists(projectRoot, 'AGENTS.md'),
+            authority: 'binding',
+            lifecycle: 'user_editable',
+            generated_by_mustflow: fileExists(projectRoot, '.mustflow/config/manifest.lock.toml'),
+        },
+        summary: {
+            host_instruction_files: hostFiles.filter((file) => file.status === 'present').length,
+            adapter_surfaces_present: adapterSurfaces.filter((surface) => surface.present).length,
+            compatibility_notes: compatibilityNotes.length,
+            conflicts: requiredChanges.filter((finding) => finding.code === 'host_instruction_conflicts_with_agents').length,
+            required_changes: requiredChanges.length,
+        },
+        host_files: hostFiles,
+        adapter_surfaces: adapterSurfaces,
+        findings,
+        compatibility_notes: compatibilityNotes,
+        required_changes: requiredChanges,
+        runtime_policy: {
+            approval_policy: 'not_repo_visible',
+            sandbox_policy: 'not_repo_visible',
+            stricter_than_mustflow: 'unknown',
+            note: 'Repository files cannot prove host runtime approval or sandbox strictness.',
+        },
+        boundaries: {
+            command_authority: '.mustflow/config/commands.toml',
+            host_files_are_command_authority: false,
+            adapter_generation: 'explicit_user_request_only',
+            does_not_generate: doesNotGenerate,
+        },
+    };
+}
+export function formatAdapterPath(relativePath) {
+    return toPosixPath(relativePath);
+}

package/dist/core/change-classification.js

@@ -1,3 +1,8 @@
+export const PUBLIC_SURFACE_UPDATE_POLICIES = [
+    'update',
+    'update_or_mark_stale',
+    'not_applicable',
+];
 function surface(kind, category, isPublicSurface, validationReasons, affectedContracts, updatePolicy, driftChecks) {
     return {
         kind,
@@ -28,6 +33,7 @@ const CHANGE_CLASSIFICATION_RULES = [
     rule('installed_template_translation', /^templates\/[^/]+\/locales\/[^/]+\//u, ['installed_template', 'translation'], surface('installed_template_translation', 'installed-template', true, ['i18n_change', 'template_version_change'], ['installed template files', 'localized workflow documents', 'template i18n metadata'], 'update_or_mark_stale', ['template i18n metadata', 'localized frontmatter', 'source revision'])),
     rule('installed_template', /^templates\/[^/]+\//u, ['installed_template'], surface('installed_template', 'installed-template', true, ['template_version_change', 'packaging_change'], ['installed template files', 'package contents', 'template manifest'], 'update', ['template manifest', 'package inventory', 'localized copies'])),
     rule('workflow_root', /^(AGENTS\.md|\.mustflow\/(?:docs|context|skills|config)\/)/u, ['workflow'], surface('workflow_root', 'workflow', true, ['mustflow_docs_change', 'mustflow_config_change'], ['agent workflow contract', 'command contract', 'installed workflow files'], 'update', ['strict workflow validation', 'installed template parity', 'skill route alignment'])),
+    rule('host_instruction', /^(CLAUDE\.md|GEMINI\.md|\.github\/copilot-instructions\.md|\.cursor\/rules\/[^/]+\.(?:md|mdc))$/u, ['workflow', 'host_instruction'], surface('host_instruction', 'workflow', true, ['mustflow_docs_change'], ['host instruction compatibility', 'agent workflow contract', 'command contract boundary'], 'update_or_mark_stale', ['host instruction conflicts', 'command contract boundary'])),
     rule('example', /^examples\//u, ['example'], surface('example', 'example', true, ['docs_change', 'public_api_change'], ['generated examples', 'human-readable examples'], 'update', ['example commands', 'linked docs', 'public behavior claims'])),
     rule('schema_contract', /^schemas\//u, ['schema'], surface('schema_contract', 'contract', true, ['public_api_change', 'release_risk'], ['JSON schema', 'machine-readable output contract'], 'update', ['schema tests', 'documented JSON fields', 'package inventory'])),
     rule('package_metadata', /^package\.json$/u, ['package_metadata'], surface('package_metadata', 'release', true, ['package_metadata_change', 'release_risk'], ['npm package metadata', 'published package contents'], 'update', ['package metadata tests', 'version source discovery', 'published file inventory'])),
@@ -73,6 +79,9 @@ export function listChangeClassificationRuleDescriptors() {
         surface: classificationRule.surface,
     }));
 }
+export function listChangeClassificationValidationReasons() {
+    return uniqueSorted(CHANGE_CLASSIFICATION_RULES.flatMap((classificationRule) => classificationRule.surface.validationReasons));
+}
 export function createChangeClassificationReport(source, relativePaths) {
     const files = uniqueSorted(relativePaths.map(normalizeStatusPath).filter((filePath) => filePath.length > 0));
     const classifications = files.map(classifyChangePath);

package/dist/core/change-verification.js

@@ -1,5 +1,6 @@
 import { CHANGE_CLASSIFICATION_SURFACE_AUTHORITY, createPathTarget, } from './surface-decision-model.js';
 import { createVerificationPlan, } from './verification-plan.js';
+import { createVerificationDecisionGraph, } from './verification-decision-graph.js';
 import { createVerificationSchedule, } from './verification-scheduler.js';
 export const CHANGE_VERIFICATION_SCHEMA_VERSION = '1';
 function uniqueSorted(values) {
@@ -62,11 +63,16 @@ function gapForRequirement(requirement, candidates) {
 }
 export function createChangeVerificationReport(classificationReport, commandContract, projectRoot) {
     const requirements = classificationReport.summary.validationReasons.map((reason) => createVerificationRequirement(classificationReport, reason));
-    const candidatePlans = requirements.flatMap((requirement) => createVerificationPlan(commandContract, requirement.reason).candidates);
-    const candidates = requirements.flatMap((requirement) => createVerificationPlan(commandContract, requirement.reason).candidates.map((candidate) => toChangeVerificationCandidate(requirement.reason, candidate)));
+    const plans = requirements.map((requirement) => ({
+        requirement,
+        candidates: createVerificationPlan(commandContract, requirement.reason).candidates,
+    }));
+    const candidatePlans = plans.flatMap((plan) => plan.candidates);
+    const candidates = plans.flatMap((plan) => plan.candidates.map((candidate) => toChangeVerificationCandidate(plan.requirement.reason, candidate)));
     const gaps = requirements
         .map((requirement) => gapForRequirement(requirement, candidates))
         .filter((gap) => gap !== null);
+    const schedule = createVerificationSchedule(projectRoot, commandContract, candidatePlans);
     return {
         schema_version: CHANGE_VERIFICATION_SCHEMA_VERSION,
         source: classificationReport.source,
@@ -75,6 +81,7 @@ export function createChangeVerificationReport(classificationReport, commandCont
         requirements,
         candidates,
         gaps,
-        schedule: createVerificationSchedule(projectRoot, commandContract, candidatePlans),
+        schedule,
+        decision_graph: createVerificationDecisionGraph(commandContract, requirements, candidates, gaps, schedule),
     };
 }

package/dist/core/check-issues.js

@@ -20,6 +20,10 @@ const CHECK_ISSUE_ID_RULES = [
     ['mustflow.release.template_version_intentionally_unchanged', /^Strict warning: templates\/default\/manifest\.toml version "[^"]+" is older than package\.json version "[^"]+"; this is allowed only when the installed template surface is unchanged$/u],
     ['mustflow.preferences.release_versioning_contract_authority', /^Strict: \[preferences\.release\.versioning\]\.[a-z_]+ cannot define version sources or release authority; use \.mustflow\/config\/versioning\.toml or \.mustflow\/config\/commands\.toml$/u],
     ['mustflow.preferences.verification_selection_command_authority', /^Strict: \[preferences\.verification\.selection\]\.[a-z_]+ cannot define command authority; use \.mustflow\/config\/commands\.toml$/u],
+    ['mustflow.contract_model.deferred_policy', /^Strict: \.mustflow\/config\/policy\.toml is deferred; use narrow candidate contract files instead$/u],
+    ['mustflow.contract_model.command_authority_field', /^Strict: \.mustflow\/config\/(?:changes|surfaces)\.toml .+ cannot define command authority; use \.mustflow\/config\/commands\.toml$/u],
+    ['mustflow.contract_model.invalid_match_kind', /^Strict: \.mustflow\/config\/(?:changes|surfaces)\.toml rules\[\d+\]\.match\.kind must be "exact", "prefix", or "glob"; regular expressions are deferred$/u],
+    ['mustflow.contract_model.invalid_shape', /^Strict: \.mustflow\/config\/(?:changes|surfaces)\.toml .+(?:must be|must define|is not allowed)/u],
     ['mustflow.skill.procedure_only', /^Strict: \.mustflow\/skills\/[^/]+\/SKILL\.md metadata\.mustflow_kind must be "procedure"$/u],
     ['mustflow.skill.raw_command_block', /^Strict: \.mustflow\/skills\/[^/]+\/SKILL\.md contains a raw shell command block; reference command intents instead$/u],
     ['mustflow.skill.command_permission_claim', /^Strict: \.mustflow\/skills\/[^/]+\/SKILL\.md claims command execution permission; keep permissions in \.mustflow\/config\/commands\.toml$/u],

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

@@ -1,4 +1,5 @@
 import { COMMAND_LIFECYCLES, COMMAND_RUN_POLICIES, LONG_RUNNING_LIFECYCLES, isRecord, } from './config-loading.js';
+import { COMMAND_ENV_POLICIES } from './command-env.js';
 import { COMMAND_EFFECT_CONCURRENCY, COMMAND_EFFECT_MODES, COMMAND_EFFECT_TYPES, validateCommandEffectLockWarnings, validateCommandEffects, } from './command-effects.js';
 import { commandIntentHasBlockedShellBackgroundPattern, commandIntentHasCommandSource, commandIntentNameIsSafe, } from './command-contract-rules.js';
 function commandContractIssue(message) {
@@ -31,6 +32,15 @@ function validateStringField(table, key, label, issues) {
         issues.push(commandContractIssue(`${label} must be a string`));
     }
 }
+function validateStringArrayField(table, key, label, issues) {
+    if (!hasOwn(table, key)) {
+        return;
+    }
+    const value = table[key];
+    if (!Array.isArray(value) || value.some((entry) => typeof entry !== 'string' || entry.trim().length === 0)) {
+        issues.push(commandContractIssue(`${label} must be a string array`));
+    }
+}
 function validatePositiveIntegerField(table, key, label, issues) {
     if (hasOwn(table, key) && !isPositiveInteger(table[key])) {
         issues.push(commandContractIssue(`${label} must be a positive integer`));
@@ -57,6 +67,8 @@ function validateCommandDefaults(commandsToml, issues) {
     validateStringField(defaults, 'default_cwd', '[commands.defaults].default_cwd', issues);
     validateStringField(defaults, 'stdin', '[commands.defaults].stdin', issues);
     validateStringField(defaults, 'on_timeout', '[commands.defaults].on_timeout', issues);
+    validateAllowedStringField(defaults, 'env_policy', '[commands.defaults].env_policy', COMMAND_ENV_POLICIES, issues);
+    validateStringArrayField(defaults, 'env_allowlist', '[commands.defaults].env_allowlist', issues);
     validatePositiveIntegerField(defaults, 'default_timeout_seconds', '[commands.defaults].default_timeout_seconds', issues);
     validatePositiveIntegerField(defaults, 'max_output_bytes', '[commands.defaults].max_output_bytes', issues);
     validatePositiveIntegerField(defaults, 'kill_after_seconds', '[commands.defaults].kill_after_seconds', issues);
@@ -115,6 +127,8 @@ function validateCommandIntent(intentName, intent, issues) {
     validateStringField(intent, 'status', `[commands.intents.${intentName}].status`, issues);
     validateAllowedStringField(intent, 'lifecycle', `[commands.intents.${intentName}].lifecycle`, COMMAND_LIFECYCLES, issues);
     validateAllowedStringField(intent, 'run_policy', `[commands.intents.${intentName}].run_policy`, COMMAND_RUN_POLICIES, issues);
+    validateAllowedStringField(intent, 'env_policy', `[commands.intents.${intentName}].env_policy`, COMMAND_ENV_POLICIES, issues);
+    validateStringArrayField(intent, 'env_allowlist', `[commands.intents.${intentName}].env_allowlist`, issues);
     if (intent.status !== 'configured') {
         return;
     }

package/dist/core/command-cwd.js

@@ -1,12 +1,24 @@
+import { existsSync, realpathSync, statSync } from 'node:fs';
 import path from 'node:path';
+function normalizeForContainment(value) {
+    const normalized = path.resolve(value);
+    return process.platform === 'win32' ? normalized.toLowerCase() : normalized;
+}
+function isInsideOrEqual(parent, child) {
+    const normalizedParent = normalizeForContainment(parent);
+    const normalizedChild = normalizeForContainment(child);
+    return normalizedChild === normalizedParent || normalizedChild.startsWith(`${normalizedParent}${path.sep}`);
+}
 export function resolveSafeProjectCwd(projectRoot, rawCwd) {
     const cwd = rawCwd ?? '.';
     const resolved = path.resolve(projectRoot, cwd);
-    const root = path.resolve(projectRoot);
-    const resolvedLower = resolved.toLowerCase();
-    const rootLower = root.toLowerCase();
-    if (resolvedLower !== rootLower && !resolvedLower.startsWith(`${rootLower}${path.sep}`)) {
-        throw new Error(`Intent cwd must stay inside the current root: ${cwd}`);
+    const rootRealPath = realpathSync.native(projectRoot);
+    if (!existsSync(resolved) || !statSync(resolved).isDirectory()) {
+        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}`);
     }
-    return resolved;
+    return cwdRealPath;
 }

package/dist/core/command-env.js

@@ -0,0 +1,91 @@
+import path from 'node:path';
+import { readString, readStringArray } from './config-loading.js';
+export const COMMAND_ENV_POLICIES = new Set(['inherit', 'minimal', 'allowlist']);
+export const DEFAULT_COMMAND_ENV_POLICY = 'inherit';
+const BASE_MINIMAL_ENV_KEYS = [
+    'CI',
+    'COLORTERM',
+    'COMSPEC',
+    'ComSpec',
+    'FORCE_COLOR',
+    'HOME',
+    'HOMEDRIVE',
+    'HOMEPATH',
+    'LANG',
+    'LC_ALL',
+    'NO_COLOR',
+    'PATHEXT',
+    'Path',
+    'SystemRoot',
+    'TEMP',
+    'TERM',
+    'TMP',
+    'TMPDIR',
+    'USERPROFILE',
+    'WINDIR',
+    'windir',
+];
+function getPathEnvKey(env) {
+    return Object.keys(env).find((key) => key.toLowerCase() === 'path') ?? 'PATH';
+}
+function sameResolvedPath(left, right) {
+    const resolvedLeft = path.resolve(left);
+    const resolvedRight = path.resolve(right);
+    return process.platform === 'win32'
+        ? resolvedLeft.toLowerCase() === resolvedRight.toLowerCase()
+        : resolvedLeft === resolvedRight;
+}
+function uniqueEnvNames(values) {
+    return [...new Set(values.map((value) => value.trim()).filter((value) => value.length > 0))].sort((left, right) => left.localeCompare(right));
+}
+function readEnvPolicy(table) {
+    if (!table) {
+        return undefined;
+    }
+    const value = readString(table, 'env_policy');
+    return value && COMMAND_ENV_POLICIES.has(value) ? value : undefined;
+}
+function readEnvAllowlist(table) {
+    return table ? (readStringArray(table, 'env_allowlist') ?? []) : [];
+}
+function pickEnv(source, names) {
+    const output = {};
+    for (const name of names) {
+        const value = source[name];
+        if (value !== undefined) {
+            output[name] = value;
+        }
+    }
+    return output;
+}
+function removeProjectLocalBinFromPath(env, projectRoot) {
+    const pathKey = getPathEnvKey(env);
+    const currentPath = env[pathKey];
+    if (!currentPath) {
+        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;
+}
+export function resolveCommandEnv(contract, intent) {
+    const policy = readEnvPolicy(intent) ?? readEnvPolicy(contract.defaults) ?? DEFAULT_COMMAND_ENV_POLICY;
+    const allowlist = policy === 'allowlist'
+        ? uniqueEnvNames([...readEnvAllowlist(contract.defaults), ...readEnvAllowlist(intent)])
+        : [];
+    return {
+        policy,
+        allowlist,
+    };
+}
+export function createCommandEnv(projectRoot, resolution, sourceEnv = process.env) {
+    const pathKey = getPathEnvKey(sourceEnv);
+    const minimalKeys = uniqueEnvNames([...BASE_MINIMAL_ENV_KEYS, pathKey]);
+    const env = resolution.policy === 'inherit'
+        ? { ...sourceEnv }
+        : pickEnv(sourceEnv, resolution.policy === 'allowlist' ? [...minimalKeys, ...resolution.allowlist] : minimalKeys);
+    return removeProjectLocalBinFromPath(env, projectRoot);
+}