mustflow 1.15.97

package/dist/cli/lib/version-sources.js

@@ -0,0 +1 @@
+export { VERSIONING_CONFIG_PATH, VERSION_SOURCE_AUTHORITIES, VERSION_SOURCE_KINDS, detectVersionSourcePaths, detectVersionSources, readDeclaredVersionSources, releaseVersioningIsEnabled, } from '../../core/version-sources.js';

package/dist/core/authority-resolution.js

@@ -0,0 +1,155 @@
+const STATIC_MANAGED_MARKDOWN_EXPECTATIONS = {
+    'AGENTS.md': {
+        docId: 'agents.root',
+        authority: 'binding',
+        lifecycle: 'user-editable',
+    },
+    '.mustflow/skills/INDEX.md': {
+        docId: 'skills.index',
+        authority: 'router',
+        lifecycle: 'mustflow-owned',
+    },
+};
+function toPosixPath(value) {
+    return value.split('\\').join('/');
+}
+export function getManagedMarkdownExpectation(relativePath) {
+    const normalizedPath = toPosixPath(relativePath);
+    const staticExpectation = STATIC_MANAGED_MARKDOWN_EXPECTATIONS[normalizedPath];
+    if (staticExpectation) {
+        return staticExpectation;
+    }
+    const docsMatch = /^\.mustflow\/docs\/([^/]+)\.md$/u.exec(normalizedPath);
+    if (docsMatch) {
+        return {
+            docId: `docs.${docsMatch[1]}`,
+            authority: 'workflow-policy',
+            lifecycle: 'mustflow-owned',
+        };
+    }
+    const contextMatch = /^\.mustflow\/context\/([^/]+)\.md$/u.exec(normalizedPath);
+    if (contextMatch) {
+        const contextName = contextMatch[1].toLowerCase();
+        if (contextName === 'index') {
+            return {
+                docId: 'context.index',
+                authority: 'router',
+                lifecycle: 'mustflow-owned',
+            };
+        }
+        return {
+            docId: `context.${contextName}`,
+            authority: 'contextual',
+            lifecycle: 'user-editable',
+        };
+    }
+    const skillMatch = /^\.mustflow\/skills\/([^/]+)\/SKILL\.md$/u.exec(normalizedPath);
+    if (skillMatch) {
+        return {
+            docId: `skill.${skillMatch[1]}`,
+            authority: 'procedure',
+            lifecycle: 'mustflow-owned',
+        };
+    }
+    return undefined;
+}
+export function formatManagedMarkdownLabel(relativePath, expectation) {
+    return `${expectation.docId} (${toPosixPath(relativePath)})`;
+}
+function getAuthorityBoundary(authority) {
+    switch (authority) {
+        case 'binding':
+            return {
+                role: 'binding repository instruction entry point',
+                canDefine: ['repository-local work rules', 'read order', 'delegation to mustflow workflow files'],
+                cannotDefine: ['host safety overrides', 'command execution permission outside commands.toml', 'facts that contradict current files'],
+            };
+        case 'workflow-policy':
+            return {
+                role: 'shared agent workflow policy',
+                canDefine: ['agent operating loop', 'refresh checkpoints', 'verification and reporting policy'],
+                cannotDefine: ['executable command permission', 'project product facts', 'host safety overrides'],
+            };
+        case 'router':
+            return {
+                role: 'routing index',
+                canDefine: ['which context or skill document to read', 'compact routing metadata'],
+                cannotDefine: ['procedure steps', 'command permission', 'project policy not owned by the router'],
+            };
+        case 'contextual':
+            return {
+                role: 'low-authority project context',
+                canDefine: ['supported project facts', 'known unknowns', 'domain conventions'],
+                cannotDefine: ['command policy', 'file edit prohibitions', 'facts that override code tests or user instructions'],
+            };
+        case 'procedure':
+            return {
+                role: 'repeatable task procedure',
+                canDefine: ['task trigger', 'allowed edit scope', 'verification and reporting shape'],
+                cannotDefine: ['command execution permission', 'repository-wide binding rules', 'facts outside the procedure scope'],
+            };
+        default:
+            return getUnrecognizedBoundary();
+    }
+}
+function getOverviewBoundary() {
+    return {
+        role: 'managed Markdown authority model',
+        canDefine: ['document authority lanes', 'expected frontmatter identity', 'which source should answer which class of question'],
+        cannotDefine: ['runtime command permission outside commands.toml', 'host safety overrides', 'project facts unsupported by current files'],
+    };
+}
+function getUnrecognizedBoundary() {
+    return {
+        role: 'unclassified by mustflow managed Markdown authority',
+        canDefine: [],
+        cannotDefine: ['mustflow document authority', 'command execution permission', 'workflow policy by path alone'],
+    };
+}
+export function explainManagedMarkdownAuthority(relativePath) {
+    const sourceFiles = [
+        'AGENTS.md',
+        '.mustflow/docs/agent-workflow.md',
+        '.mustflow/config/mustflow.toml',
+        '.mustflow/skills/INDEX.md',
+    ];
+    if (!relativePath) {
+        return {
+            kind: 'overview',
+            inputPath: null,
+            decision: 'managed Markdown authority is resolved from document path and expected frontmatter',
+            reason: 'mustflow keeps repository binding rules, workflow policy, context, and procedures in separate authority lanes.',
+            effectiveAction: 'Use the nearest managed document role before deciding whether a file can define rules, context, or procedure steps.',
+            countsAsMustflowVerification: false,
+            sourceFiles,
+            expectation: null,
+            boundary: getOverviewBoundary(),
+        };
+    }
+    const normalizedPath = toPosixPath(relativePath);
+    const expectation = getManagedMarkdownExpectation(normalizedPath);
+    if (!expectation) {
+        return {
+            kind: 'unrecognized',
+            inputPath: normalizedPath,
+            decision: 'no managed Markdown authority expectation applies to this path',
+            reason: 'only AGENTS.md and Markdown documents under .mustflow/docs, .mustflow/context, and .mustflow/skills are classified by this authority resolver.',
+            effectiveAction: 'Treat the file according to the nearest AGENTS.md and repository command contract instead of granting it mustflow document authority.',
+            countsAsMustflowVerification: false,
+            sourceFiles,
+            expectation: null,
+            boundary: getUnrecognizedBoundary(),
+        };
+    }
+    return {
+        kind: 'recognized',
+        inputPath: normalizedPath,
+        decision: `expected ${expectation.docId} with ${expectation.authority} authority`,
+        reason: 'the path matches a managed mustflow document role with a stable identity, authority, and lifecycle.',
+        effectiveAction: `Validate frontmatter mustflow_doc="${expectation.docId}", authority="${expectation.authority}", and lifecycle="${expectation.lifecycle}".`,
+        countsAsMustflowVerification: false,
+        sourceFiles,
+        expectation,
+        boundary: getAuthorityBoundary(expectation.authority),
+    };
+}

package/dist/core/change-classification.js

@@ -0,0 +1,122 @@
+function surface(kind, category, isPublicSurface, validationReasons, affectedContracts, updatePolicy, driftChecks) {
+    return {
+        kind,
+        category,
+        isPublicSurface,
+        validationReasons,
+        affectedContracts,
+        updatePolicy,
+        driftChecks,
+    };
+}
+const UNKNOWN_SURFACE = surface('unclassified_path', 'unknown', false, [], [], 'not_applicable', []);
+const CHANGE_CLASSIFICATION_RULES = [
+    {
+        match: /^README\.md$/u,
+        changeKinds: ['documentation'],
+        surface: surface('readme_page', 'documentation', true, ['docs_change', 'copy_change'], ['public documentation', 'command examples'], 'update', ['link targets', 'command examples', 'package metadata references']),
+    },
+    {
+        match: /^docs-site\/src\/content\/docs\/(?!en\/)[^/]+\//u,
+        changeKinds: ['documentation', 'translation'],
+        surface: surface('docs_site_translation', 'documentation', true, ['docs_change', 'i18n_change'], ['documentation site', 'localized content', 'navigation links'], 'update_or_mark_stale', ['source page parity', 'navigation links', 'localized examples']),
+    },
+    {
+        match: /^docs-site\/src\/content\/docs\//u,
+        changeKinds: ['documentation'],
+        surface: surface('docs_site_page', 'documentation', true, ['docs_change'], ['documentation site', 'navigation links', 'localized content'], 'update', ['navigation links', 'localized copies', 'command examples']),
+    },
+    {
+        match: /^templates\/[^/]+\/locales\/[^/]+\//u,
+        changeKinds: ['installed_template', 'translation'],
+        surface: 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']),
+    },
+    {
+        match: /^templates\/[^/]+\//u,
+        changeKinds: ['installed_template'],
+        surface: 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']),
+    },
+    {
+        match: /^(AGENTS\.md|\.mustflow\/(?:docs|context|skills|config)\/)/u,
+        changeKinds: ['workflow'],
+        surface: 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']),
+    },
+    {
+        match: /^examples\//u,
+        changeKinds: ['example'],
+        surface: surface('example', 'example', true, ['docs_change', 'public_api_change'], ['generated examples', 'human-readable examples'], 'update', ['example commands', 'linked docs', 'public behavior claims']),
+    },
+    {
+        match: /^schemas\//u,
+        changeKinds: ['schema'],
+        surface: surface('schema_contract', 'contract', true, ['public_api_change', 'release_risk'], ['JSON schema', 'machine-readable output contract'], 'update', ['schema tests', 'documented JSON fields', 'package inventory']),
+    },
+    {
+        match: /^package\.json$/u,
+        changeKinds: ['package_metadata'],
+        surface: 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']),
+    },
+    {
+        match: /^tests\/fixtures\//u,
+        changeKinds: ['test_fixture'],
+        surface: surface('test_fixture', 'test', false, ['test_change'], ['regression fixture inputs'], 'not_applicable', ['fixture safety', 'test route coverage']),
+    },
+    {
+        match: /^tests\//u,
+        changeKinds: ['test'],
+        surface: surface('test_contract', 'test', false, ['test_change'], ['test behavior contract'], 'not_applicable', ['related test selection']),
+    },
+    {
+        match: /^(src|scripts)\//u,
+        changeKinds: ['implementation'],
+        surface: surface('implementation', 'code', false, ['code_change'], ['runtime behavior when exported through CLI or package output'], 'not_applicable', ['related tests', 'build output']),
+    },
+];
+function uniqueSorted(values) {
+    return [...new Set(values)].sort((left, right) => left.localeCompare(right));
+}
+function toPosixPath(value) {
+    return value.trim().replaceAll('\\', '/');
+}
+export function normalizeStatusPath(value) {
+    const pathText = toPosixPath(value);
+    const renameTarget = pathText.includes(' -> ') ? (pathText.split(' -> ').pop() ?? pathText) : pathText;
+    return renameTarget.replace(/^"|"$/gu, '');
+}
+export function parseGitStatusOutput(output) {
+    const paths = output
+        .split(/\r?\n/u)
+        .map((line) => line.slice(3))
+        .map(normalizeStatusPath)
+        .filter((line) => line.length > 0);
+    return uniqueSorted(paths);
+}
+export function classifyChangePath(relativePath) {
+    const normalizedPath = normalizeStatusPath(relativePath);
+    const rule = CHANGE_CLASSIFICATION_RULES.find((candidate) => candidate.match.test(normalizedPath));
+    return {
+        path: normalizedPath,
+        changeKinds: rule?.changeKinds ?? ['unknown'],
+        surface: rule?.surface ?? UNKNOWN_SURFACE,
+    };
+}
+export function createChangeClassificationReport(source, relativePaths) {
+    const files = uniqueSorted(relativePaths.map(normalizeStatusPath).filter((filePath) => filePath.length > 0));
+    const classifications = files.map(classifyChangePath);
+    return {
+        source,
+        files,
+        classifications,
+        summary: {
+            fileCount: files.length,
+            publicSurfaceCount: classifications.filter((classification) => classification.surface.isPublicSurface).length,
+            changeKinds: uniqueSorted(classifications.flatMap((classification) => classification.changeKinds)),
+            validationReasons: uniqueSorted(classifications.flatMap((classification) => classification.surface.validationReasons)),
+            updatePolicies: uniqueSorted(classifications
+                .map((classification) => classification.surface.updatePolicy)
+                .filter((updatePolicy) => updatePolicy !== 'not_applicable')),
+            driftChecks: uniqueSorted(classifications.flatMap((classification) => classification.surface.driftChecks)),
+            affectedContracts: uniqueSorted(classifications.flatMap((classification) => classification.surface.affectedContracts)),
+        },
+    };
+}

package/dist/core/change-verification.js

@@ -0,0 +1,80 @@
+import { CHANGE_CLASSIFICATION_SURFACE_AUTHORITY, createPathTarget, } from './surface-decision-model.js';
+import { createVerificationPlan, } from './verification-plan.js';
+import { createVerificationSchedule, } from './verification-scheduler.js';
+export const CHANGE_VERIFICATION_SCHEMA_VERSION = '1';
+function uniqueSorted(values) {
+    return [...new Set(values)].sort((left, right) => left.localeCompare(right));
+}
+function uniqueUpdatePolicies(values) {
+    return uniqueSorted([...values].filter((value) => value !== 'not_applicable'));
+}
+function classificationsForReason(classificationReport, reason) {
+    return classificationReport.classifications.filter((classification) => classification.surface.validationReasons.includes(reason));
+}
+function toSurfaceDecision(classification) {
+    return {
+        target: createPathTarget(classification.path),
+        changeKinds: classification.changeKinds,
+        surface: {
+            kind: classification.surface.kind,
+            category: classification.surface.category,
+            isPublicSurface: classification.surface.isPublicSurface,
+        },
+        reasons: classification.surface.validationReasons,
+        affectedContracts: classification.surface.affectedContracts,
+        driftChecks: classification.surface.driftChecks,
+        authority: CHANGE_CLASSIFICATION_SURFACE_AUTHORITY,
+    };
+}
+function createVerificationRequirement(classificationReport, reason) {
+    const classifications = classificationsForReason(classificationReport, reason);
+    const decisions = classifications.map(toSurfaceDecision);
+    return {
+        reason,
+        files: uniqueSorted(decisions.flatMap((decision) => (decision.target.kind === 'path' ? [decision.target.path] : []))),
+        surfaces: uniqueSorted(decisions.flatMap((decision) => (decision.surface ? [decision.surface.kind] : []))),
+        affectedContracts: uniqueSorted(decisions.flatMap((decision) => decision.affectedContracts ?? [])),
+        driftChecks: uniqueSorted(decisions.flatMap((decision) => decision.driftChecks ?? [])),
+        updatePolicies: uniqueUpdatePolicies(classifications.map((classification) => classification.surface.updatePolicy)),
+        source: 'change_classification',
+    };
+}
+function toChangeVerificationCandidate(reason, candidate) {
+    return {
+        reason,
+        intent: candidate.intent.length > 0 ? candidate.intent : null,
+        status: candidate.status,
+        skipReason: candidate.reason,
+        detail: candidate.detail,
+    };
+}
+function gapForRequirement(requirement, candidates) {
+    const hasRunnableCandidate = candidates.some((candidate) => candidate.reason === requirement.reason && candidate.status === 'runnable');
+    if (hasRunnableCandidate) {
+        return null;
+    }
+    return {
+        reason: requirement.reason,
+        files: requirement.files,
+        surfaces: requirement.surfaces,
+        detail: `No runnable command intents cover required_after = "${requirement.reason}".`,
+    };
+}
+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 gaps = requirements
+        .map((requirement) => gapForRequirement(requirement, candidates))
+        .filter((gap) => gap !== null);
+    return {
+        schema_version: CHANGE_VERIFICATION_SCHEMA_VERSION,
+        source: classificationReport.source,
+        files: classificationReport.files,
+        classification_summary: classificationReport.summary,
+        requirements,
+        candidates,
+        gaps,
+        schedule: createVerificationSchedule(projectRoot, commandContract, candidatePlans),
+    };
+}

package/dist/core/check-issues.js

@@ -0,0 +1,67 @@
+const CHECK_ISSUE_ID_RULES = [
+    ['mustflow.command_contract.intent_table_missing', /^Missing \[intents\] table in \.mustflow\/config\/commands\.toml$/u],
+    ['mustflow.command_contract.intent_not_table', /^Intent [^\s]+ must be a TOML table$/u],
+    ['mustflow.command_contract.configured_missing_lifecycle', /^Configured intent [^\s]+ must define lifecycle$/u],
+    ['mustflow.command_contract.configured_missing_run_policy', /^Configured intent [^\s]+ must define run_policy$/u],
+    ['mustflow.command_contract.oneshot_missing_timeout', /^Oneshot intent [^\s]+ must define timeout_seconds$/u],
+    ['mustflow.command_contract.oneshot_stdin_not_closed', /^Oneshot intent [^\s]+ must set stdin = "closed"$/u],
+    ['mustflow.command_contract.long_running_agent_allowed', /^Long-running intent [^\s]+ must not use run_policy = "agent_allowed"$/u],
+    ['mustflow.command_contract.executable_source_missing', /^Configured intent [^\s]+ must define argv or mode = "shell" with cmd$/u],
+    ['mustflow.command_contract.shell_background_pattern', /^Shell intent [^\s]+ contains a blocked long-running or background pattern$/u],
+    ['mustflow.command_contract.success_exit_codes_invalid', /^\[commands\.intents\.[^\]]+\]\.success_exit_codes must be an integer array$/u],
+    ['mustflow.command_contract.effects_invalid', /^(?:Strict: )?(?:\[commands\.(?:resources|intents\.[^\]]+\.effects)[^\]]*\]|Command effect for intent [^\s]+ must define path, paths, or lock)/u],
+    ['mustflow.command_contract.effect_path_escape', /^Strict: Command effect path must stay inside the current root:/u],
+    ['mustflow.command_contract.shared_writes_without_effects', /^Strict warning: configured agent-runnable intents .+ share path:.+ through writes without explicit effects or resource locks$/u],
+    ['mustflow.prompt_cache.required', /^Strict: \[prompt_cache\] table is required$/u],
+    ['mustflow.prompt_cache.volatile_in_stable', /^Strict: \[prompt_cache\.layers\.stable\]\.read must not include volatile path /u],
+    ['mustflow.refresh.hash_method_required', /^Strict: \[refresh\]\.default_method should be "hash_check" for cache-friendly refresh$/u],
+    ['mustflow.release.template_version_mismatch', /^Strict: templates\/default\/manifest\.toml version "[^"]+" must match package\.json version "[^"]+" when \[release\.versioning\]\.sync_template_version is true$/u],
+    ['mustflow.release.template_version_ahead', /^Strict: templates\/default\/manifest\.toml version "[^"]+" must not be ahead of package\.json version "[^"]+"$/u],
+    ['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.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],
+    ['mustflow.skill.unknown_command_intent', /^Strict: \.mustflow\/skills\/[^/]+\/SKILL\.md metadata\.command_intents references unknown command intent "[^"]+"$/u],
+    ['mustflow.skill.index_route_unknown_command_intent', /^Strict: \.mustflow\/skills\/INDEX\.md route \.mustflow\/skills\/[^/]+\/SKILL\.md references command intent "[^"]+" not declared by the skill frontmatter$/u],
+    ['mustflow.skill.resource_unknown_command_intent', /^Strict: \.mustflow\/skills\/[^/]+\/resources\.toml script [^\s]+ references unknown command intent "[^"]+"$/u],
+    ['mustflow.source_anchor.invalid_format', /^Strict: source anchor .+ has invalid format:/u],
+    ['mustflow.source_anchor.duplicate_id', /^Strict: source anchor id "[^"]+" is duplicated:/u],
+    ['mustflow.source_anchor.forbidden_instruction', /^Strict: source anchor [^ ]+ in .+ contains agent command or policy instructions/u],
+    ['mustflow.source_anchor.secret_like', /^Strict: source anchor [^ ]+ in .+ contains secret-like text/u],
+    ['mustflow.source_anchor.generated_or_vendor_path', /^Strict: source anchor [^ ]+ is in generated or vendor path /u],
+    ['mustflow.source_anchor.unknown_risk', /^Strict: source anchor [^ ]+ in .+ uses unknown risk tag "[^"]+"$/u],
+    ['mustflow.source_anchor.long_purpose', /^Strict warning: source anchor [^ ]+ in .+ purpose is long/u],
+    ['mustflow.source_anchor.too_many_search_terms', /^Strict warning: source anchor [^ ]+ in .+ has too many search terms/u],
+    ['mustflow.source_anchor.high_density', /^Strict warning: .+ has high source anchor density/u],
+    ['mustflow.source_anchor.high_risk_review', /^Strict warning: source anchor [^ ]+ in .+ uses high-risk tags and needs review:/u],
+    ['mustflow.run_receipt.invalid_json', /^Strict: \.mustflow\/state\/runs\/latest\.json is not valid JSON:/u],
+    ['mustflow.run_receipt.invalid_shape', /^Strict: \.mustflow\/state\/runs\/latest\.json must contain a JSON object$/u],
+    ['mustflow.retention.run_receipt_size_limit', /^Strict: \.mustflow\/state\/runs\/latest\.json exceeds \[retention\.run_receipts\]\.max_file_kb/u],
+    ['mustflow.retention.raw_jsonl_under_mustflow', /^Strict: \.mustflow\/.*\.jsonl is a raw JSONL file under \.mustflow$/u],
+    ['mustflow.local_state.versioned_task_worklog', /^Strict: \.mustflow\/(?:worklogs|plans|tasks|work-items)\/.+ is per-task local state; keep plans and worklogs under ignored local state$/u],
+];
+/**
+ * mf:anchor core.check-issues
+ * purpose: Map check messages to stable machine-readable issue ids and severity metadata.
+ * search: check issue ids, issueDetails, strict warnings
+ * invariant: JSON issue ids stay stable while check implementations move between CLI and core modules.
+ * risk: config
+ */
+export function getCheckIssueId(message) {
+    for (const [id, pattern] of CHECK_ISSUE_ID_RULES) {
+        if (pattern.test(message)) {
+            return id;
+        }
+    }
+    return null;
+}
+export function describeCheckIssues(messages) {
+    return messages.map((message) => ({
+        id: getCheckIssueId(message),
+        severity: message.startsWith('Strict warning: ') ? 'warning' : 'error',
+        mode: message.startsWith('Strict') ? 'strict' : 'base',
+        message,
+    }));
+}

package/dist/core/command-classification.js

@@ -0,0 +1,22 @@
+const MUSTFLOW_BIN_NAMES = new Set(['mf', 'mustflow']);
+const IN_PROCESS_MUSTFLOW_BUILTIN_COMMANDS = new Set([
+    'check',
+    'classify',
+    'context',
+    'doctor',
+    'explain',
+    'help',
+    'impact',
+    'line-endings',
+    'map',
+    'status',
+    'update',
+    'version-sources',
+    'verify',
+]);
+export function isMustflowBinName(command) {
+    return MUSTFLOW_BIN_NAMES.has(command.toLowerCase());
+}
+export function canRunMustflowBuiltinInProcess(command) {
+    return command !== undefined && IN_PROCESS_MUSTFLOW_BUILTIN_COMMANDS.has(command);
+}

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

@@ -0,0 +1,27 @@
+import { readString, readStringArray } from './config-loading.js';
+const SAFE_COMMAND_INTENT_NAME_PATTERN = /^[A-Za-z0-9_-]+$/u;
+export const BACKGROUND_SHELL_PATTERNS = [
+    /\s&\s*$/u,
+    /\bnohup\b/iu,
+    /\bdisown\b/iu,
+    /\bStart-Process\b/iu,
+    /\bstart\s+/iu,
+    /\bxdg-open\b/iu,
+    /\bopen\s+/iu,
+    /\bchrome(?:\.exe)?\b/iu,
+    /\bchromium(?:\.exe)?\b/iu,
+];
+export function commandIntentNameIsSafe(intentName) {
+    return SAFE_COMMAND_INTENT_NAME_PATTERN.test(intentName);
+}
+export function commandIntentHasCommandSource(intent) {
+    const argv = readStringArray(intent, 'argv');
+    const shellCommand = intent.mode === 'shell' ? readString(intent, 'cmd') : undefined;
+    return Boolean((argv && argv.length > 0) || shellCommand);
+}
+export function shellCommandHasBlockedBackgroundPattern(command) {
+    return BACKGROUND_SHELL_PATTERNS.some((pattern) => pattern.test(command));
+}
+export function commandIntentHasBlockedShellBackgroundPattern(intent) {
+    return intent.mode === 'shell' && typeof intent.cmd === 'string' && shellCommandHasBlockedBackgroundPattern(intent.cmd);
+}