mustflow 2.117.0 → 2.118.0

package/dist/cli/i18n/en.js

@@ -1334,6 +1334,7 @@ Read these files before working:
     "run.help.option.dryRun": "Print a non-executing command plan",
     "run.help.option.planOnly": "Alias for --dry-run",
     "run.help.option.json": "Print the run record or command plan as JSON",
+    "run.help.option.repository": "Select a delegated workspace contract by repository-relative path",
     "run.help.option.wait": "Wait for conflicting active run locks before executing",
     "run.help.option.waitTimeout": "Maximum seconds to wait for active run locks. Default: 300",
     "run.help.option.allowApproval": "Allow this execution to satisfy one approval-gated action such as network_access",

package/dist/cli/i18n/es.js

@@ -1334,6 +1334,7 @@ Lee estos archivos antes de trabajar:
     "run.help.option.dryRun": "Imprime un plan de comando sin ejecutarlo",
     "run.help.option.planOnly": "Alias de --dry-run",
     "run.help.option.json": "Imprime el registro de ejecución o el plan de comando como JSON",
+    "run.help.option.repository": "Selecciona un contrato delegado del workspace mediante una ruta relativa del repositorio",
     "run.help.option.wait": "Espera bloqueos activos en conflicto antes de ejecutar",
     "run.help.option.waitTimeout": "Segundos máximos para esperar bloqueos activos. Predeterminado: 300",
     "run.help.option.allowApproval": "Permite que esta ejecución satisfaga una acción con aprobación como network_access",

package/dist/cli/i18n/fr.js

@@ -1334,6 +1334,7 @@ Lisez ces fichiers avant de travailler :
     "run.help.option.dryRun": "Imprime un plan de commande sans l'exécuter",
     "run.help.option.planOnly": "Alias de --dry-run",
     "run.help.option.json": "Imprime l'enregistrement d'exécution ou le plan de commande en JSON",
+    "run.help.option.repository": "Sélectionne un contrat workspace délégué par chemin relatif du dépôt",
     "run.help.option.wait": "Attend les verrous actifs en conflit avant d'exécuter",
     "run.help.option.waitTimeout": "Nombre maximal de secondes d'attente des verrous actifs. Par défaut : 300",
     "run.help.option.allowApproval": "Autorise cette exécution à satisfaire une action soumise à approbation comme network_access",

package/dist/cli/i18n/hi.js

@@ -1334,6 +1334,7 @@ export const hiMessages = {
     "run.help.option.dryRun": "कमांड चलाए बिना उसका plan प्रिंट करें",
     "run.help.option.planOnly": "--dry-run का alias",
     "run.help.option.json": "Run record या command plan को JSON के रूप में प्रिंट करें",
+    "run.help.option.repository": "repository-relative path से delegated workspace contract चुनें",
     "run.help.option.wait": "चलाने से पहले conflicting active run locks के लिए wait करें",
     "run.help.option.waitTimeout": "active run locks के लिए wait करने की maximum seconds. Default: 300",
     "run.help.option.allowApproval": "इस execution को network_access जैसे approval-gated action को satisfy करने दें",

package/dist/cli/i18n/ko.js

@@ -1334,6 +1334,7 @@ export const koMessages = {
     "run.help.option.dryRun": "실행하지 않고 명령 계획을 출력합니다",
     "run.help.option.planOnly": "--dry-run과 같은 동작입니다",
     "run.help.option.json": "실행 결과 또는 명령 계획을 JSON으로 출력합니다",
+    "run.help.option.repository": "저장소 상대 경로로 위임된 workspace 계약을 선택합니다",
     "run.help.option.wait": "충돌하는 활성 실행 잠금이 풀릴 때까지 기다린 뒤 실행합니다",
     "run.help.option.waitTimeout": "활성 실행 잠금을 기다릴 최대 초입니다. 기본값: 300",
     "run.help.option.allowApproval": "이번 실행에서 network_access 같은 승인 게이트 action 하나를 허용합니다",

package/dist/cli/i18n/zh.js

@@ -1334,6 +1334,7 @@ export const zhMessages = {
     "run.help.option.dryRun": "输出命令计划但不执行",
     "run.help.option.planOnly": "--dry-run 的别名",
     "run.help.option.json": "将运行记录或命令计划输出为 JSON",
+    "run.help.option.repository": "通过仓库相对路径选择委派的工作区契约",
     "run.help.option.wait": "执行前等待冲突的活动运行锁释放",
     "run.help.option.waitTimeout": "等待活动运行锁的最大秒数。默认值：300",
     "run.help.option.allowApproval": "允许本次执行满足一个需要审批的动作，例如 network_access",

package/dist/cli/lib/manifest-lock.js

@@ -107,7 +107,7 @@ export function readManifestLock(projectRoot) {
         return { kind: 'invalid', lockPath, message };
     }
 }
-export function inspectManifestLock(projectRoot) {
+function inspectManifestLockEntries(projectRoot, requiredPaths) {
     const readResult = readManifestLock(projectRoot);
     const changedFiles = [];
     const missingFiles = [];
@@ -124,6 +124,9 @@ export function inspectManifestLock(projectRoot) {
         };
     }
     for (const lockedFile of readResult.lock.files) {
+        if (requiredPaths && !requiredPaths.has(lockedFile.relativePath)) {
+            continue;
+        }
         const filePath = path.join(projectRoot, lockedFile.relativePath);
         try {
             ensureInside(projectRoot, filePath);
@@ -153,3 +156,9 @@ export function inspectManifestLock(projectRoot) {
     }
     return { readResult, changedFiles, missingFiles, issues };
 }
+export function inspectManifestLock(projectRoot) {
+    return inspectManifestLockEntries(projectRoot);
+}
+export function inspectManifestLockPaths(projectRoot, requiredPaths) {
+    return inspectManifestLockEntries(projectRoot, new Set(requiredPaths));
+}

package/dist/cli/lib/repo-map.js

@@ -4,6 +4,7 @@ import path from 'node:path';
 import { toPosixPath } from './filesystem.js';
 import { getRepoMapSourceFingerprint, renderRepoMapFrontmatter, } from './repo-map-frontmatter.js';
 import { writeUtf8FileInsideWithoutSymlinks } from '../../core/safe-filesystem.js';
+import { readWorkspaceCommandAuthorityConfig, } from '../../core/workspace-command-authority.js';
 import { isRecord } from './command-contract.js';
 import { readMustflowTomlFile } from './toml.js';
 const DEFAULT_DEPTH = 3;
@@ -291,6 +292,7 @@ export function getRepoMapConfig(projectRoot) {
     const configuredPriorityPaths = [...getStringArray(parsed.read_order), ...getStringArray(parsed.optional_read_order)];
     const map = isRecord(parsed.map) ? parsed.map : {};
     const workspace = isRecord(parsed.workspace) ? parsed.workspace : {};
+    const workspaceAuthority = readWorkspaceCommandAuthorityConfig(parsed);
     const anchorFiles = getStringArray(map.anchor_files);
     return {
         priorityPaths: configuredPriorityPaths.length > 0 ? configuredPriorityPaths : DEFAULT_PRIORITY_PATHS,
@@ -301,6 +303,9 @@ export function getRepoMapConfig(projectRoot) {
         workspace: {
             enabled: getBoolean(workspace.enabled, false),
             roots: getStringArray(workspace.roots),
+            authorityMode: workspaceAuthority.authorityMode,
+            delegatedContracts: workspaceAuthority.contracts,
+            delegatedContractCount: workspaceAuthority.contracts.length,
             maxDepth: getPositiveInteger(workspace.max_depth, 4),
             maxRepositories: getPositiveInteger(workspace.max_repositories, 50),
             followSymlinks: getBoolean(workspace.follow_symlinks, false),

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

@@ -0,0 +1,136 @@
+import { existsSync, realpathSync } from 'node:fs';
+import path from 'node:path';
+import { readCommandContract, readMustflowConfigIfExists, readScopedCommandContract, } from '../../core/config-loading.js';
+import { readWorkspaceCommandAuthorityConfig, } from '../../core/workspace-command-authority.js';
+import { resolveSafeProjectCwd } from '../../core/command-cwd.js';
+import { normalizeCommandEffects } from '../../core/command-effects.js';
+import { readEffectiveCommandCwd } from '../../core/command-run-constraints.js';
+import { isRecord } from './command-contract.js';
+import { resolveMustflowRoot } from './project-root.js';
+const MUSTFLOW_CONFIG_RELATIVE_PATH = '.mustflow/config/mustflow.toml';
+function toPosixPath(value) {
+    return value.split(path.sep).join('/');
+}
+function normalizeRepositoryOption(value) {
+    return value.trim().replace(/\\/gu, '/').replace(/^\.\//u, '').replace(/\/+$/gu, '');
+}
+function normalizeForContainment(value) {
+    const resolved = path.resolve(value);
+    let canonical = resolved;
+    try {
+        canonical = realpathSync.native(resolved);
+    }
+    catch {
+        // Non-existent effect paths still inherit the canonical project root used to construct them.
+    }
+    return process.platform === 'win32' ? canonical.toLowerCase() : canonical;
+}
+function resolvedPathIsInside(candidate, parent) {
+    const relative = path.relative(normalizeForContainment(parent), normalizeForContainment(candidate));
+    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+function resolveProjectRelativePath(projectRoot, relativePath) {
+    const canonicalRoot = realpathSync.native(path.resolve(projectRoot));
+    return path.resolve(canonicalRoot, ...relativePath.split('/'));
+}
+function findScopeByRepository(contracts, repository) {
+    const normalized = normalizeRepositoryOption(repository);
+    return contracts.find((contract) => contract.repository === normalized);
+}
+function findScopeByStartPath(projectRoot, startPath, contracts) {
+    const resolvedStart = path.resolve(startPath);
+    return [...contracts]
+        .sort((left, right) => right.repository.length - left.repository.length)
+        .find((contract) => resolvedPathIsInside(resolvedStart, resolveProjectRelativePath(projectRoot, contract.repository)));
+}
+function startPathIsInsideWorkspaceRoot(projectRoot, startPath, workspaceRoots) {
+    const resolvedStart = path.resolve(startPath);
+    return workspaceRoots.some((workspaceRoot) => resolvedPathIsInside(resolvedStart, resolveProjectRelativePath(projectRoot, workspaceRoot)));
+}
+function assertScopeRepositoryExists(projectRoot, scope) {
+    const repositoryRoot = resolveProjectRelativePath(projectRoot, scope.repository);
+    if (!resolvedPathIsInside(repositoryRoot, projectRoot)) {
+        throw new Error(`Delegated workspace repository escapes the mustflow root: ${scope.repository}`);
+    }
+    if (!existsSync(repositoryRoot)) {
+        throw new Error(`Delegated workspace repository does not exist: ${scope.repository}`);
+    }
+}
+export function assertScopedCommandIntentIsolation(projectRoot, scope, contract, intentName) {
+    if (!intentName) {
+        return;
+    }
+    const repositoryRoot = resolveProjectRelativePath(projectRoot, scope.repository);
+    const rawIntent = contract.intents[intentName];
+    if (!isRecord(rawIntent)) {
+        return;
+    }
+    const intentCwd = resolveSafeProjectCwd(projectRoot, readEffectiveCommandCwd(contract, rawIntent));
+    if (!resolvedPathIsInside(intentCwd, repositoryRoot)) {
+        throw new Error(`Delegated workspace intent "${intentName}" cwd must stay inside ${scope.repository}`);
+    }
+    for (const effect of normalizeCommandEffects(projectRoot, contract, intentName)) {
+        if (effect.path === null) {
+            continue;
+        }
+        const effectPath = resolveProjectRelativePath(projectRoot, effect.path);
+        if (!resolvedPathIsInside(effectPath, repositoryRoot)) {
+            throw new Error(`Delegated workspace intent "${intentName}" effect path must stay inside ${scope.repository}: ${effect.path}`);
+        }
+    }
+}
+function createScopedContext(projectRoot, mustflowConfig, scope, intentName) {
+    assertScopeRepositoryExists(projectRoot, scope);
+    const contractPath = `.mustflow/config/${scope.file}`;
+    const contract = readScopedCommandContract(projectRoot, scope.file, `workspace:${scope.repository}`, scope.repository);
+    assertScopedCommandIntentIsolation(projectRoot, scope, contract, intentName);
+    return {
+        projectRoot,
+        contract,
+        mustflowConfig,
+        workspaceScope: {
+            repository: scope.repository,
+            contract: contractPath,
+        },
+        trustPaths: [MUSTFLOW_CONFIG_RELATIVE_PATH, contractPath],
+    };
+}
+export function resolveRunCommandContext(options = {}) {
+    const startPath = path.resolve(options.startPath ?? process.cwd());
+    const projectRoot = resolveMustflowRoot(startPath);
+    const mustflowConfig = readMustflowConfigIfExists(projectRoot);
+    const workspaceAuthority = readWorkspaceCommandAuthorityConfig(mustflowConfig);
+    const requestedRepository = options.repository?.trim() ? normalizeRepositoryOption(options.repository) : null;
+    if (workspaceAuthority.authorityMode !== 'delegated_scoped') {
+        if (requestedRepository) {
+            throw new Error('--repo requires [workspace].authority_mode = "delegated_scoped"');
+        }
+        return {
+            projectRoot,
+            contract: readCommandContract(projectRoot),
+            mustflowConfig,
+            workspaceScope: null,
+            trustPaths: undefined,
+        };
+    }
+    const scope = requestedRepository
+        ? findScopeByRepository(workspaceAuthority.contracts, requestedRepository)
+        : findScopeByStartPath(projectRoot, startPath, workspaceAuthority.contracts);
+    if (requestedRepository && !scope) {
+        throw new Error(`No delegated workspace contract is mapped for repository: ${requestedRepository}`);
+    }
+    if (scope) {
+        return createScopedContext(projectRoot, mustflowConfig, scope, options.intentName);
+    }
+    if (startPathIsInsideWorkspaceRoot(projectRoot, startPath, workspaceAuthority.roots)) {
+        const relativeStart = toPosixPath(path.relative(projectRoot, startPath)) || '.';
+        throw new Error(`No delegated workspace contract is mapped for working directory: ${relativeStart}`);
+    }
+    return {
+        projectRoot,
+        contract: readCommandContract(projectRoot),
+        mustflowConfig,
+        workspaceScope: null,
+        trustPaths: [MUSTFLOW_CONFIG_RELATIVE_PATH],
+    };
+}

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

@@ -1,12 +1,17 @@
-import { MANIFEST_LOCK_RELATIVE_PATH, inspectManifestLock } from './manifest-lock.js';
+import { MANIFEST_LOCK_RELATIVE_PATH, inspectManifestLock, inspectManifestLockPaths } from './manifest-lock.js';
 import { readCommandContractIncludePaths } from '../../core/config-loading.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 inspection = inspectManifestLock(projectRoot);
+export function assessRunRootTrust(projectRoot, options = {}) {
+    const scopedRequiredPaths = options.requiredPaths
+        ? [...new Set([...REQUIRED_RUN_TRUST_LOCK_PATHS, ...options.requiredPaths])]
+        : undefined;
+    const inspection = scopedRequiredPaths
+        ? inspectManifestLockPaths(projectRoot, scopedRequiredPaths)
+        : inspectManifestLock(projectRoot);
     const { readResult } = inspection;
     if (readResult.kind === 'present') {
         if (readResult.lock.files.length === 0) {
@@ -18,18 +23,20 @@ export function assessRunRootTrust(projectRoot) {
             };
         }
         const trackedPaths = new Set(readResult.lock.files.map((file) => file.relativePath));
-        let requiredPaths = REQUIRED_RUN_TRUST_LOCK_PATHS;
-        try {
-            requiredPaths = [...REQUIRED_RUN_TRUST_LOCK_PATHS, ...readCommandContractIncludePaths(projectRoot)];
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            return {
-                trusted: false,
-                reason: 'manifest_lock_invalid',
-                manifestLockPath: readResult.lockPath,
-                detail: message,
-            };
+        let requiredPaths = scopedRequiredPaths ?? REQUIRED_RUN_TRUST_LOCK_PATHS;
+        if (!scopedRequiredPaths) {
+            try {
+                requiredPaths = [...REQUIRED_RUN_TRUST_LOCK_PATHS, ...readCommandContractIncludePaths(projectRoot)];
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return {
+                    trusted: false,
+                    reason: 'manifest_lock_invalid',
+                    manifestLockPath: readResult.lockPath,
+                    detail: message,
+                };
+            }
         }
         const missingRequiredPath = requiredPaths.find((relativePath) => !trackedPaths.has(relativePath));
         if (missingRequiredPath) {

package/dist/cli/lib/validation/index.js

@@ -8,6 +8,7 @@ import { formatManagedMarkdownLabel, getManagedMarkdownExpectation, } from '../.
 import { SKILL_INDEX_ROUTE_COLUMN_COUNT, SKILL_INDEX_ROUTE_COLUMNS, SKILL_INDEX_SKILL_PATH_COLUMN_INDEX, findSkillRouteConflictWarnings, findSkillIndexRoutePathColumn, parseSkillIndexRoutes, readBacktickValues, } from '../../../core/skill-route-alignment.js';
 import { validateTemplateVersionSync } from '../../../core/release-version-validation.js';
 import { validateSourceAnchorsInProject } from '../../../core/source-anchor-validation.js';
+import { readWorkspaceCommandAuthorityConfig, WORKSPACE_COMMAND_AUTHORITY_MODES, } from '../../../core/workspace-command-authority.js';
 import { readLocalSourceAnchorCheckWarnings } from '../local-index/index.js';
 import { listFilesRecursive, toPosixPath } from '../filesystem.js';
 import { readGitChangedFiles } from '../git-changes.js';
@@ -85,6 +86,7 @@ function validateMustflowConfig(mustflowToml, issues) {
     if (workspace) {
         validateBooleanField(workspace, 'enabled', '[workspace].enabled', issues);
         const roots = validateWorkspaceRoots(workspace, issues);
+        validateAllowedStringField(workspace, 'authority_mode', '[workspace].authority_mode', new Set(WORKSPACE_COMMAND_AUTHORITY_MODES), issues);
         validatePositiveIntegerField(workspace, 'max_depth', '[workspace].max_depth', issues);
         validatePositiveIntegerField(workspace, 'max_repositories', '[workspace].max_repositories', issues);
         validateBooleanField(workspace, 'follow_symlinks', '[workspace].follow_symlinks', issues);
@@ -92,6 +94,12 @@ function validateMustflowConfig(mustflowToml, issues) {
         if (workspace.enabled === true && roots?.length === 0) {
             issues.push({ message: '[workspace].enabled requires at least one [workspace].roots entry' });
         }
+        try {
+            readWorkspaceCommandAuthorityConfig(mustflowToml);
+        }
+        catch (error) {
+            issues.push({ message: error instanceof Error ? error.message : String(error) });
+        }
     }
     const capabilities = validateTable(mustflowToml, 'capabilities', issues);
     if (capabilities) {

package/dist/core/config-loading.js

@@ -67,11 +67,15 @@ function readCommandIncludePathsFromParsed(root) {
     return normalizedPaths;
 }
 export function readCommandContractIncludePaths(projectRoot) {
+    const parsed = readRootCommandContractToml(projectRoot);
+    return readCommandIncludePathsFromParsed(parsed).map((includePath) => `${COMMANDS_CONFIG_DIRECTORY_RELATIVE_PATH}/${includePath}`);
+}
+function readRootCommandContractToml(projectRoot) {
     const parsed = readMustflowOwnedTomlFile(projectRoot, COMMANDS_CONFIG_RELATIVE_PATH);
     if (!isRecord(parsed)) {
         throw new Error(`${COMMANDS_CONFIG_RELATIVE_PATH} must contain a TOML table`);
     }
-    return readCommandIncludePathsFromParsed(parsed).map((includePath) => `${COMMANDS_CONFIG_DIRECTORY_RELATIVE_PATH}/${includePath}`);
+    return parsed;
 }
 function assertCommandIncludeTable(includePath, parsed) {
     if (!isRecord(parsed)) {
@@ -84,6 +88,13 @@ function assertCommandIncludeTable(includePath, parsed) {
     }
     return parsed;
 }
+function readCommandIncludeTable(projectRoot, includePath) {
+    const normalized = normalizeCommandIncludePath(includePath);
+    if (commandIncludePathIsUnsafe(includePath)) {
+        throw new Error(`Command include path "${includePath}" must be a relative ${COMMAND_INCLUDE_DIRECTORY}/*.toml path under ${COMMANDS_CONFIG_DIRECTORY_RELATIVE_PATH}`);
+    }
+    return assertCommandIncludeTable(normalized, readMustflowOwnedTomlFile(projectRoot, `${COMMANDS_CONFIG_DIRECTORY_RELATIVE_PATH}/${normalized}`));
+}
 function mergeCommandSection(target, source, sectionName, sourceLabel, seenSources) {
     if (source === undefined) {
         return;
@@ -101,10 +112,7 @@ function mergeCommandSection(target, source, sectionName, sourceLabel, seenSourc
     }
 }
 export function readResolvedCommandContractToml(projectRoot) {
-    const parsed = readMustflowOwnedTomlFile(projectRoot, COMMANDS_CONFIG_RELATIVE_PATH);
-    if (!isRecord(parsed)) {
-        throw new Error(`${COMMANDS_CONFIG_RELATIVE_PATH} must contain a TOML table`);
-    }
+    const parsed = readRootCommandContractToml(projectRoot);
     if (hasOwn(parsed, 'intents') && !isRecord(parsed.intents)) {
         throw new Error(`[intents] table in ${COMMANDS_CONFIG_RELATIVE_PATH} must be a TOML table`);
     }
@@ -138,6 +146,99 @@ export function readResolvedCommandContractToml(projectRoot) {
     }
     return merged;
 }
+function commandContractFromParsed(parsed) {
+    if (!isRecord(parsed.intents)) {
+        throw new Error(`Missing [intents] table in ${COMMANDS_CONFIG_RELATIVE_PATH}`);
+    }
+    return {
+        defaults: isRecord(parsed.defaults) ? parsed.defaults : {},
+        intents: parsed.intents,
+        resources: isRecord(parsed.resources) ? parsed.resources : {},
+    };
+}
+function namespaceScopedLock(lockNamespace, lockName) {
+    return `${lockNamespace}::${lockName}`;
+}
+function namespaceScopedIntentLocks(rawIntents, lockNamespace) {
+    if (rawIntents === undefined) {
+        return {};
+    }
+    if (!isRecord(rawIntents)) {
+        throw new Error(`Scoped command contract must contain an [intents] table`);
+    }
+    const intents = {};
+    for (const [intentName, rawIntent] of Object.entries(rawIntents)) {
+        if (!isRecord(rawIntent) || !Array.isArray(rawIntent.effects)) {
+            intents[intentName] = rawIntent;
+            continue;
+        }
+        intents[intentName] = {
+            ...rawIntent,
+            effects: rawIntent.effects.map((rawEffect) => {
+                if (!isRecord(rawEffect) || typeof rawEffect.lock !== 'string') {
+                    return rawEffect;
+                }
+                return {
+                    ...rawEffect,
+                    lock: namespaceScopedLock(lockNamespace, rawEffect.lock),
+                };
+            }),
+        };
+    }
+    return intents;
+}
+function rebaseScopedCwd(repository, rawCwd) {
+    const normalizedCwd = rawCwd.replaceAll('\\', '/');
+    if (path.posix.isAbsolute(normalizedCwd) || path.win32.isAbsolute(rawCwd)) {
+        return rawCwd;
+    }
+    return path.posix.normalize(path.posix.join(repository, normalizedCwd));
+}
+function rebaseScopedCommandContract(contract, repository) {
+    const defaultCwd = readString(contract.defaults, 'default_cwd') ?? '.';
+    const intents = Object.fromEntries(Object.entries(contract.intents).map(([intentName, rawIntent]) => {
+        if (!isRecord(rawIntent)) {
+            return [intentName, rawIntent];
+        }
+        const intentCwd = readString(rawIntent, 'cwd');
+        return [
+            intentName,
+            intentCwd === undefined ? rawIntent : { ...rawIntent, cwd: rebaseScopedCwd(repository, intentCwd) },
+        ];
+    }));
+    return {
+        defaults: {
+            ...contract.defaults,
+            default_cwd: rebaseScopedCwd(repository, defaultCwd),
+        },
+        intents,
+        resources: contract.resources,
+    };
+}
+function namespaceScopedResources(rawResources, lockNamespace) {
+    if (rawResources === undefined) {
+        return {};
+    }
+    if (!isRecord(rawResources)) {
+        throw new Error(`Scoped command contract [resources] must be a TOML table`);
+    }
+    return Object.fromEntries(Object.entries(rawResources).map(([resourceName, resource]) => [
+        namespaceScopedLock(lockNamespace, resourceName),
+        resource,
+    ]));
+}
+export function readRootCommandContract(projectRoot) {
+    return commandContractFromParsed(readRootCommandContractToml(projectRoot));
+}
+export function readScopedCommandContract(projectRoot, includePath, lockNamespace, repository) {
+    const root = readRootCommandContractToml(projectRoot);
+    const fragment = readCommandIncludeTable(projectRoot, includePath);
+    return rebaseScopedCommandContract({
+        defaults: isRecord(root.defaults) ? root.defaults : {},
+        intents: namespaceScopedIntentLocks(fragment.intents, lockNamespace),
+        resources: namespaceScopedResources(fragment.resources, lockNamespace),
+    }, repository);
+}
 export function readMustflowConfig(projectRoot) {
     const parsed = readMustflowOwnedTomlFile(projectRoot, MUSTFLOW_CONFIG_RELATIVE_PATH);
     if (!isRecord(parsed)) {
@@ -150,15 +251,7 @@ export function readMustflowConfigIfExists(projectRoot) {
     return existsSync(configPath) ? readMustflowConfig(projectRoot) : undefined;
 }
 export function readCommandContract(projectRoot) {
-    const parsed = readResolvedCommandContractToml(projectRoot);
-    if (!isRecord(parsed.intents)) {
-        throw new Error(`Missing [intents] table in ${COMMANDS_CONFIG_RELATIVE_PATH}`);
-    }
-    return {
-        defaults: isRecord(parsed.defaults) ? parsed.defaults : {},
-        intents: parsed.intents,
-        resources: isRecord(parsed.resources) ? parsed.resources : {},
-    };
+    return commandContractFromParsed(readResolvedCommandContractToml(projectRoot));
 }
 export function readString(table, key) {
     const value = table[key];

package/dist/core/run-receipt.js

@@ -285,6 +285,7 @@ export function createRunReceipt(input) {
             redaction_kinds: [...redactionState.kinds].sort(),
             fields: [...redactionState.fields].sort(),
         },
+        ...(input.workspaceScope ? { workspace_scope: input.workspaceScope } : {}),
         receipt_path: getReceiptRelativePath(input.receiptPath),
     };
 }

package/dist/core/workspace-command-authority.js

@@ -0,0 +1,98 @@
+import path from 'node:path';
+export const WORKSPACE_COMMAND_AUTHORITY_MODES = ['repository_local', 'delegated_scoped'];
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function normalizeRelativePath(value) {
+    return value.trim().replace(/\\/gu, '/').replace(/\/+$/gu, '');
+}
+function relativePathIsUnsafe(value) {
+    const normalized = normalizeRelativePath(value);
+    const segments = normalized.split('/');
+    return (normalized.length === 0 ||
+        normalized.includes('\0') ||
+        normalized.startsWith('/') ||
+        path.win32.isAbsolute(value) ||
+        path.posix.isAbsolute(normalized) ||
+        segments.some((segment) => segment.length === 0 || segment === '.' || segment === '..'));
+}
+function commandFragmentPathIsUnsafe(value) {
+    const normalized = normalizeRelativePath(value);
+    return relativePathIsUnsafe(value) || !normalized.startsWith('commands/') || !normalized.endsWith('.toml');
+}
+function pathIsInside(candidate, parent) {
+    return candidate === parent || candidate.startsWith(`${parent}/`);
+}
+function readStringArray(value, label) {
+    if (!Array.isArray(value) || value.some((entry) => typeof entry !== 'string')) {
+        throw new Error(`${label} must be a string array`);
+    }
+    return value.map((entry) => normalizeRelativePath(entry));
+}
+function readContracts(value) {
+    if (value === undefined) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        throw new Error('[workspace].contracts must be an array of tables');
+    }
+    const contracts = [];
+    const repositories = new Set();
+    const files = new Set();
+    for (const [index, rawContract] of value.entries()) {
+        if (!isRecord(rawContract)) {
+            throw new Error(`[workspace].contracts[${index}] must be a table`);
+        }
+        const repository = typeof rawContract.repository === 'string' ? normalizeRelativePath(rawContract.repository) : '';
+        const file = typeof rawContract.file === 'string' ? normalizeRelativePath(rawContract.file) : '';
+        if (relativePathIsUnsafe(repository)) {
+            throw new Error(`[workspace].contracts[${index}].repository must be a normalized repository-relative path`);
+        }
+        if (commandFragmentPathIsUnsafe(file)) {
+            throw new Error(`[workspace].contracts[${index}].file must be a normalized commands/*.toml path`);
+        }
+        if (repositories.has(repository)) {
+            throw new Error(`[workspace].contracts contains duplicate repository "${repository}"`);
+        }
+        if (files.has(file)) {
+            throw new Error(`[workspace].contracts contains duplicate file "${file}"`);
+        }
+        repositories.add(repository);
+        files.add(file);
+        contracts.push({ repository, file });
+    }
+    return contracts;
+}
+export function readWorkspaceCommandAuthorityConfig(mustflowConfig) {
+    const root = isRecord(mustflowConfig) ? mustflowConfig : {};
+    const workspace = isRecord(root.workspace) ? root.workspace : {};
+    const enabled = workspace.enabled === true;
+    const roots = workspace.roots === undefined ? [] : readStringArray(workspace.roots, '[workspace].roots');
+    const authorityMode = workspace.authority_mode === undefined ? 'repository_local' : workspace.authority_mode;
+    if (!WORKSPACE_COMMAND_AUTHORITY_MODES.includes(authorityMode)) {
+        throw new Error(`[workspace].authority_mode must be one of: ${WORKSPACE_COMMAND_AUTHORITY_MODES.join(', ')}`);
+    }
+    if (roots.some((rootPath) => relativePathIsUnsafe(rootPath))) {
+        throw new Error('[workspace].roots entries must be normalized repository-relative paths');
+    }
+    const contracts = readContracts(workspace.contracts);
+    if (authorityMode === 'delegated_scoped') {
+        if (!enabled) {
+            throw new Error('[workspace].authority_mode = "delegated_scoped" requires [workspace].enabled = true');
+        }
+        if (roots.length === 0) {
+            throw new Error('[workspace].authority_mode = "delegated_scoped" requires at least one [workspace].roots entry');
+        }
+        for (const contract of contracts) {
+            if (!roots.some((rootPath) => pathIsInside(contract.repository, rootPath))) {
+                throw new Error(`[workspace].contracts repository "${contract.repository}" must stay inside one [workspace].roots entry`);
+            }
+        }
+    }
+    return {
+        enabled,
+        roots,
+        authorityMode: authorityMode,
+        contracts,
+    };
+}

package/package.json

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

package/schemas/run-receipt.schema.json

@@ -76,6 +76,7 @@
     "write_drift": { "$ref": "#/$defs/writeDrift" },
     "performance": { "$ref": "#/$defs/performance" },
     "redaction": { "$ref": "#/$defs/redaction" },
+    "workspace_scope": { "$ref": "#/$defs/workspaceScope" },
     "verification_plan_id": {
       "type": "string",
       "pattern": "^sha256:[0-9a-f]{64}$"
@@ -83,6 +84,15 @@
     "receipt_path": { "type": "string" }
   },
   "$defs": {
+    "workspaceScope": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["repository", "contract"],
+      "properties": {
+        "repository": { "type": "string" },
+        "contract": { "type": "string" }
+      }
+    },
     "output": {
       "type": "object",
       "additionalProperties": false,

package/schemas/workspace-command-catalog.schema.json

@@ -53,6 +53,8 @@
       "properties": {
         "enabled": { "type": "boolean" },
         "roots": { "$ref": "#/$defs/stringArray" },
+        "authority_mode": { "enum": ["repository_local", "delegated_scoped"] },
+        "delegated_contract_count": { "type": "integer", "minimum": 0 },
         "max_depth": { "type": "integer", "minimum": 1 },
         "max_repositories": { "type": "integer", "minimum": 1 },
         "follow_symlinks": { "type": "boolean" },
@@ -119,6 +121,7 @@
       "properties": {
         "relative_path": { "type": "string" },
         "status": { "enum": ["available", "contract_missing", "contract_invalid"] },
+        "command_authority": { "enum": ["repository_local", "delegated_scoped", null] },
         "command_contract": { "$ref": "#/$defs/commandSurface" },
         "intent_count": { "type": "integer", "minimum": 0 },
         "runnable_count": { "type": "integer", "minimum": 0 },