@open-agent-toolkit/cli 0.1.32 → 0.1.34

package/dist/commands/doctor/index.js

@@ -3,9 +3,10 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { buildCommandContext, } from '../../app/command-context.js';
 import { compareVersions } from '../init/tools/shared/version.js';
-import { runPjmDoctorChecks } from '../pjm/doctor.js';
+import { createPjmDisabledCheck, runPjmDoctorChecks, } from '../pjm/doctor.js';
 import { getSkillVersion } from '../shared/frontmatter.js';
 import { readGlobalOptions, resolveConcreteScopes, } from '../shared/shared.utils.js';
+import { readOatConfig } from '../../config/oat-config.js';
 import { resolveAssetsRoot } from '../../fs/assets.js';
 import { resolveProjectRoot, resolveScopeRoot } from '../../fs/paths.js';
 import TOML from '@iarna/toml';
@@ -126,6 +127,7 @@ function createDependencies() {
         checkProviders: checkProvidersDefault,
         readFile: async (path) => readFile(path, 'utf8'),
         resolveAssetsRoot,
+        readOatConfig,
         runPjmDoctorChecks,
         // Default binding remains self-contained, but still honors the caller-
         // provided pathExists dependency from runChecksForScope when available.
@@ -342,8 +344,15 @@ async function runChecksForScope(scope, scopeRoot, dependencies) {
             }
         }
         const repoReferenceRoot = join(scopeRoot, '.oat', 'repo');
-        if (await dependencies.pathExists(repoReferenceRoot)) {
-            checks.push(...(await dependencies.runPjmDoctorChecks(repoReferenceRoot)));
+        const config = await dependencies.readOatConfig(scopeRoot);
+        const projectManagementEnabled = config.tools?.['project-management'] === true;
+        if (projectManagementEnabled) {
+            checks.push(...(await dependencies.runPjmDoctorChecks(repoReferenceRoot, {
+                projectManagementEnabled: true,
+            })));
+        }
+        else if (await dependencies.pathExists(repoReferenceRoot)) {
+            checks.push(createPjmDisabledCheck());
         }
     }
     return checks;

package/dist/commands/gate/index.d.ts

@@ -0,0 +1,35 @@
+import { type CommandContext, type GlobalOptions } from '../../app/command-context.js';
+import { type ExecTarget, type OatConfig, type OatLocalConfig, type UserConfig } from '../../config/oat-config.js';
+import { type ResolvedConfig } from '../../config/resolve.js';
+import { Command } from 'commander';
+interface GateCommandDependencies {
+    buildCommandContext: (options: GlobalOptions) => CommandContext;
+    resolveProjectRoot: (cwd: string) => Promise<string>;
+    readOatConfig: (repoRoot: string) => Promise<OatConfig>;
+    writeOatConfig: (repoRoot: string, config: OatConfig) => Promise<void>;
+    readOatLocalConfig: (repoRoot: string) => Promise<OatLocalConfig>;
+    writeOatLocalConfig: (repoRoot: string, config: OatLocalConfig) => Promise<void>;
+    readUserConfig: (userConfigDir: string) => Promise<UserConfig>;
+    writeUserConfig: (userConfigDir: string, config: UserConfig) => Promise<void>;
+    resolveEffectiveConfig: (repoRoot: string, userConfigDir: string, env: NodeJS.ProcessEnv) => Promise<ResolvedConfig>;
+    runProcess: (command: string, args: string[], options: ProcessRunOptions) => Promise<ProcessRunResult>;
+    processEnv: NodeJS.ProcessEnv;
+}
+interface ProcessRunOptions {
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    purpose: 'host-detection' | 'availability' | 'execute';
+    stdio: 'ignore' | 'inherit';
+}
+interface ProcessRunResult {
+    exitCode: number;
+}
+type CrossProviderAvoid = 'same-runtime' | 'none';
+export interface SelectedExecTarget {
+    id: string;
+    target: ExecTarget;
+}
+export declare function selectExecTarget(registry: Readonly<Record<string, ExecTarget>>, currentRuntime: string, avoid: CrossProviderAvoid): SelectedExecTarget | null;
+export declare function createGateCommand(overrides?: Partial<GateCommandDependencies>): Command;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/gate/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/gate/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,aAAa,EACnB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAQL,KAAK,UAAU,EAIf,KAAK,SAAS,EACd,KAAK,cAAc,EACnB,KAAK,UAAU,EAEhB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAIL,KAAK,cAAc,EACpB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,UAAU,uBAAuB;IAC/B,mBAAmB,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,cAAc,CAAC;IAChE,kBAAkB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACrD,aAAa,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,SAAS,CAAC,CAAC;IACxD,cAAc,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACvE,kBAAkB,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,cAAc,CAAC,CAAC;IAClE,mBAAmB,EAAE,CACnB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,cAAc,KACnB,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB,cAAc,EAAE,CAAC,aAAa,EAAE,MAAM,KAAK,OAAO,CAAC,UAAU,CAAC,CAAC;IAC/D,eAAe,EAAE,CAAC,aAAa,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9E,sBAAsB,EAAE,CACtB,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,MAAM,EACrB,GAAG,EAAE,MAAM,CAAC,UAAU,KACnB,OAAO,CAAC,cAAc,CAAC,CAAC;IAC7B,UAAU,EAAE,CACV,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,EAAE,iBAAiB,KACvB,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAC/B,UAAU,EAAE,MAAM,CAAC,UAAU,CAAC;CAC/B;AAmCD,UAAU,iBAAiB;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC,UAAU,CAAC;IACvB,OAAO,EAAE,gBAAgB,GAAG,cAAc,GAAG,SAAS,CAAC;IACvD,KAAK,EAAE,QAAQ,GAAG,SAAS,CAAC;CAC7B;AAED,UAAU,gBAAgB;IACxB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,KAAK,kBAAkB,GAAG,cAAc,GAAG,MAAM,CAAC;AAKlD,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,UAAU,CAAC;CACpB;AAmWD,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,EAC9C,cAAc,EAAE,MAAM,EACtB,KAAK,EAAE,kBAAkB,GACxB,kBAAkB,GAAG,IAAI,CAE3B;AA2SD,wBAAgB,iBAAiB,CAC/B,SAAS,GAAE,OAAO,CAAC,uBAAuB,CAAM,GAC/C,OAAO,CAoIT"}

package/dist/commands/gate/index.js

@@ -0,0 +1,500 @@
+import { spawn } from 'node:child_process';
+import { join } from 'node:path';
+import { buildCommandContext, } from '../../app/command-context.js';
+import { readGlobalOptions } from '../shared/shared.utils.js';
+import { BUILTIN_EXEC_TARGETS, readOatConfig, readOatLocalConfig, readUserConfig, writeOatConfig, writeOatLocalConfig, writeUserConfig, } from '../../config/oat-config.js';
+import { resolveEffectiveConfig, resolveExecTargets, resolveGate, } from '../../config/resolve.js';
+import { resolveProjectRoot } from '../../fs/paths.js';
+import { Command } from 'commander';
+const DEFAULT_DEPENDENCIES = {
+    buildCommandContext,
+    resolveProjectRoot,
+    readOatConfig,
+    writeOatConfig,
+    readOatLocalConfig,
+    writeOatLocalConfig,
+    readUserConfig,
+    writeUserConfig,
+    resolveEffectiveConfig,
+    runProcess: runChildProcess,
+    processEnv: process.env,
+};
+const VALID_ON_FAILURE = ['block', 'prompt', 'warn'];
+const VALID_WRITE_LAYERS = [
+    'shared',
+    'local',
+    'user',
+];
+const VALID_CROSS_PROVIDER_AVOIDS = [
+    'same-runtime',
+    'none',
+];
+async function runChildProcess(command, args, options) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            cwd: options.cwd,
+            env: options.env,
+            stdio: options.stdio,
+        });
+        child.on('error', reject);
+        child.on('close', (code) => {
+            resolve({ exitCode: code ?? 1 });
+        });
+    });
+}
+function isGateWriteLayer(value) {
+    return VALID_WRITE_LAYERS.includes(value);
+}
+function writeError(context, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (context.json) {
+        context.logger.json({ status: 'error', message });
+    }
+    else {
+        context.logger.error(message);
+    }
+    process.exitCode = 1;
+}
+function writeJsonValue(context, payload) {
+    if (context.json) {
+        context.logger.json(payload);
+        return;
+    }
+    context.logger.info(JSON.stringify(payload, null, 2));
+}
+function writeSuccess(context, payload) {
+    if (context.json) {
+        context.logger.json({ status: 'ok', ...payload });
+        return;
+    }
+    context.logger.info(JSON.stringify({ status: 'ok', ...payload }, null, 2));
+}
+function trimRequired(value, label) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        throw new Error(`${label} must be a non-empty string.`);
+    }
+    return trimmed;
+}
+function parseLayer(value) {
+    const layer = value?.trim() || 'user';
+    if (!isGateWriteLayer(layer)) {
+        throw new Error('--layer must be one of shared | local | user; auto is not supported for gate writes.');
+    }
+    return layer;
+}
+function parseCrossProviderAvoid(value) {
+    const avoid = value?.trim() || 'same-runtime';
+    if (!VALID_CROSS_PROVIDER_AVOIDS.includes(avoid)) {
+        throw new Error('--avoid must be one of same-runtime | none.');
+    }
+    return avoid;
+}
+function parseOnFailure(value) {
+    if (!value || !VALID_ON_FAILURE.includes(value)) {
+        throw new Error('--on-failure must be one of block | prompt | warn.');
+    }
+    return value;
+}
+function parsePositiveInteger(value, flag, defaultValue) {
+    if (value === undefined) {
+        return defaultValue;
+    }
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 1) {
+        throw new Error(`${flag} must be an integer greater than or equal to 1.`);
+    }
+    return parsed;
+}
+function parseNumericFlag(value, flag, defaultValue) {
+    if (value === undefined) {
+        return defaultValue;
+    }
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed)) {
+        throw new Error(`${flag} must be a finite number.`);
+    }
+    return parsed;
+}
+function parseArgvJson(value, flag) {
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch (error) {
+        const detail = error instanceof Error ? `: ${error.message}` : '';
+        throw new Error(`${flag} must be valid JSON${detail}`, { cause: error });
+    }
+    if (!Array.isArray(parsed) ||
+        parsed.length === 0 ||
+        !parsed.every((item) => typeof item === 'string') ||
+        !parsed[0]?.trim()) {
+        throw new Error(`${flag} must be a non-empty JSON array of strings whose first item is not empty.`);
+    }
+    return [...parsed];
+}
+function parseOptionalArgvJson(value, flag) {
+    return value === undefined ? undefined : parseArgvJson(value, flag);
+}
+function parseGateConfig(options) {
+    if (options.disable) {
+        return null;
+    }
+    return {
+        command: trimRequired(options.command ?? '', '--command'),
+        onFailure: parseOnFailure(options.onFailure),
+        maxAttempts: parsePositiveInteger(options.maxAttempts, '--max-attempts', 2),
+        ...(options.description?.trim()
+            ? { description: options.description.trim() }
+            : {}),
+    };
+}
+function parseExecTargetConfig(options) {
+    if (options.disable) {
+        return null;
+    }
+    const baseCommandJson = options.baseCommandJson;
+    if (baseCommandJson === undefined) {
+        throw new Error('--base-command-json is required unless --disable is set.');
+    }
+    return {
+        runtime: trimRequired(options.runtime ?? '', '--runtime'),
+        baseCommand: parseArgvJson(baseCommandJson, '--base-command-json'),
+        priority: parseNumericFlag(options.priority, '--priority', 0),
+        ...(options.hostDetectionJson !== undefined
+            ? {
+                hostDetectionCommand: parseOptionalArgvJson(options.hostDetectionJson, '--host-detection-json'),
+            }
+            : {}),
+        ...(options.availabilityJson !== undefined
+            ? {
+                availabilityCommand: parseOptionalArgvJson(options.availabilityJson, '--availability-json'),
+            }
+            : {}),
+    };
+}
+function updateWorkflowGates(config, update) {
+    return {
+        ...config,
+        workflow: {
+            ...config.workflow,
+            gates: update(config.workflow?.gates ?? {}),
+        },
+    };
+}
+function setSkillGate(config, skillName, gate) {
+    return updateWorkflowGates(config, (gates) => ({
+        ...gates,
+        skills: {
+            ...gates.skills,
+            [skillName]: gate,
+        },
+    }));
+}
+function unsetSkillGate(config, skillName) {
+    return updateWorkflowGates(config, (gates) => {
+        const skills = { ...gates.skills };
+        delete skills[skillName];
+        return {
+            ...gates,
+            skills,
+        };
+    });
+}
+function setExecTarget(config, targetId, target) {
+    return updateWorkflowGates(config, (gates) => ({
+        ...gates,
+        execTargets: {
+            ...gates.execTargets,
+            [targetId]: target,
+        },
+    }));
+}
+function unsetExecTarget(config, targetId) {
+    return updateWorkflowGates(config, (gates) => {
+        const execTargets = { ...gates.execTargets };
+        delete execTargets[targetId];
+        return {
+            ...gates,
+            execTargets,
+        };
+    });
+}
+async function readEffectiveConfig(context, dependencies) {
+    const repoRoot = await dependencies.resolveProjectRoot(context.cwd);
+    const userConfigDir = join(context.home, '.oat');
+    return dependencies.resolveEffectiveConfig(repoRoot, userConfigDir, dependencies.processEnv);
+}
+function sortedExecTargetEntries(registry) {
+    return Object.entries(registry)
+        .map(([id, target]) => ({ id, target }))
+        .sort((left, right) => {
+        const priority = right.target.priority - left.target.priority;
+        return priority === 0 ? left.id.localeCompare(right.id) : priority;
+    });
+}
+function cloneExecTarget(target) {
+    return {
+        runtime: target.runtime,
+        baseCommand: [...target.baseCommand],
+        priority: target.priority,
+        ...(target.hostDetectionCommand
+            ? { hostDetectionCommand: [...target.hostDetectionCommand] }
+            : {}),
+        ...(target.availabilityCommand
+            ? { availabilityCommand: [...target.availabilityCommand] }
+            : {}),
+    };
+}
+function argvHead(argv) {
+    return [argv[0] ?? '', argv.slice(1)];
+}
+function listExecTargetCandidates(registry, currentRuntime, avoid) {
+    const shouldAvoidSameRuntime = avoid === 'same-runtime' && currentRuntime !== 'unknown';
+    return sortedExecTargetEntries(registry)
+        .filter(({ target }) => !shouldAvoidSameRuntime || target.runtime !== currentRuntime)
+        .map(({ id, target }) => ({ id, target: cloneExecTarget(target) }));
+}
+export function selectExecTarget(registry, currentRuntime, avoid) {
+    return listExecTargetCandidates(registry, currentRuntime, avoid)[0] ?? null;
+}
+async function checkArgv(argv, purpose, context, dependencies) {
+    const [command, args] = argvHead(argv);
+    if (!command) {
+        return false;
+    }
+    try {
+        const result = await dependencies.runProcess(command, args, {
+            cwd: context.cwd,
+            env: dependencies.processEnv,
+            purpose,
+            stdio: 'ignore',
+        });
+        return result.exitCode === 0;
+    }
+    catch {
+        return false;
+    }
+}
+async function resolveCurrentRuntime(currentRuntime, context, dependencies) {
+    const override = currentRuntime?.trim();
+    if (override) {
+        return override;
+    }
+    for (const { target } of sortedExecTargetEntries(BUILTIN_EXEC_TARGETS)) {
+        if (target.hostDetectionCommand &&
+            (await checkArgv(target.hostDetectionCommand, 'host-detection', context, dependencies))) {
+            return target.runtime;
+        }
+    }
+    return 'unknown';
+}
+async function selectAvailableExecTarget(registry, currentRuntime, avoid, context, dependencies) {
+    for (const candidate of listExecTargetCandidates(registry, currentRuntime, avoid)) {
+        const availabilityCommand = candidate.target.availabilityCommand;
+        if (!availabilityCommand ||
+            (await checkArgv(availabilityCommand, 'availability', context, dependencies))) {
+            return candidate;
+        }
+    }
+    return null;
+}
+async function executeTarget(selected, prompt, context, dependencies) {
+    const [command, baseArgs] = argvHead(selected.target.baseCommand);
+    if (!command) {
+        throw new Error(`Exec target "${selected.id}" has an empty base command.`);
+    }
+    try {
+        const result = await dependencies.runProcess(command, [...baseArgs, ...prompt], {
+            cwd: context.cwd,
+            env: dependencies.processEnv,
+            purpose: 'execute',
+            stdio: 'inherit',
+        });
+        return result.exitCode;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to launch exec target "${selected.id}" (${command}): ${message}`, { cause: error });
+    }
+}
+function noEligibleTargetMessage(currentRuntime, avoid) {
+    return `No eligible gate exec target found for current runtime "${currentRuntime}" with --avoid ${avoid}. Install or configure an alternate runtime, rerun with --avoid none, or pin a target with --target <id>.`;
+}
+async function updateConfigLayer(context, layer, dependencies, mutate) {
+    const repoRoot = await dependencies.resolveProjectRoot(context.cwd);
+    const userConfigDir = join(context.home, '.oat');
+    if (layer === 'shared') {
+        const config = await dependencies.readOatConfig(repoRoot);
+        await dependencies.writeOatConfig(repoRoot, mutate(config));
+        return;
+    }
+    if (layer === 'local') {
+        const config = await dependencies.readOatLocalConfig(repoRoot);
+        await dependencies.writeOatLocalConfig(repoRoot, mutate(config));
+        return;
+    }
+    const config = await dependencies.readUserConfig(userConfigDir);
+    await dependencies.writeUserConfig(userConfigDir, mutate(config));
+}
+async function runResolve(skillName, context, dependencies) {
+    try {
+        const effective = await readEffectiveConfig(context, dependencies);
+        writeJsonValue(context, resolveGate(effective, skillName));
+        process.exitCode = 0;
+    }
+    catch (error) {
+        writeError(context, error);
+    }
+}
+async function runGateSet(skillName, options, context, dependencies) {
+    try {
+        const layer = parseLayer(options.layer);
+        const normalizedSkill = trimRequired(skillName, '<skill>');
+        const gate = parseGateConfig(options);
+        await updateConfigLayer(context, layer, dependencies, (config) => setSkillGate(config, normalizedSkill, gate));
+        writeSuccess(context, { layer, skill: normalizedSkill, gate });
+        process.exitCode = 0;
+    }
+    catch (error) {
+        writeError(context, error);
+    }
+}
+async function runGateUnset(skillName, options, context, dependencies) {
+    try {
+        const layer = parseLayer(options.layer);
+        const normalizedSkill = trimRequired(skillName, '<skill>');
+        await updateConfigLayer(context, layer, dependencies, (config) => unsetSkillGate(config, normalizedSkill));
+        writeSuccess(context, { layer, skill: normalizedSkill });
+        process.exitCode = 0;
+    }
+    catch (error) {
+        writeError(context, error);
+    }
+}
+async function runTargetSet(targetId, options, context, dependencies) {
+    try {
+        const layer = parseLayer(options.layer);
+        const normalizedTargetId = trimRequired(targetId, '<id>');
+        const target = parseExecTargetConfig(options);
+        await updateConfigLayer(context, layer, dependencies, (config) => setExecTarget(config, normalizedTargetId, target));
+        writeSuccess(context, { layer, target: normalizedTargetId, value: target });
+        process.exitCode = 0;
+    }
+    catch (error) {
+        writeError(context, error);
+    }
+}
+async function runTargetUnset(targetId, options, context, dependencies) {
+    try {
+        const layer = parseLayer(options.layer);
+        const normalizedTargetId = trimRequired(targetId, '<id>');
+        await updateConfigLayer(context, layer, dependencies, (config) => unsetExecTarget(config, normalizedTargetId));
+        writeSuccess(context, { layer, target: normalizedTargetId });
+        process.exitCode = 0;
+    }
+    catch (error) {
+        writeError(context, error);
+    }
+}
+async function runCrossProviderExec(prompt, options, context, dependencies) {
+    try {
+        const effective = await readEffectiveConfig(context, dependencies);
+        const targets = resolveExecTargets(effective);
+        const explicitTarget = options.target?.trim();
+        if (explicitTarget) {
+            const target = targets[explicitTarget];
+            if (!target) {
+                throw new Error(`Unknown exec target "${explicitTarget}".`);
+            }
+            process.exitCode = await executeTarget({ id: explicitTarget, target: cloneExecTarget(target) }, prompt, context, dependencies);
+            return;
+        }
+        const avoid = parseCrossProviderAvoid(options.avoid);
+        const currentRuntime = await resolveCurrentRuntime(options.currentRuntime, context, dependencies);
+        const selected = await selectAvailableExecTarget(targets, currentRuntime, avoid, context, dependencies);
+        if (!selected) {
+            throw new Error(noEligibleTargetMessage(currentRuntime, avoid));
+        }
+        process.exitCode = await executeTarget(selected, prompt, context, dependencies);
+    }
+    catch (error) {
+        writeError(context, error);
+    }
+}
+export function createGateCommand(overrides = {}) {
+    const dependencies = {
+        ...DEFAULT_DEPENDENCIES,
+        ...overrides,
+    };
+    const cmd = new Command('gate').description('Resolve and manage workflow gate configuration');
+    cmd
+        .command('resolve')
+        .description('Print the resolved gate configuration for a skill')
+        .argument('<skill>', 'Gate-aware skill name')
+        .action(async (skillName, _options, command) => {
+        const context = dependencies.buildCommandContext(readGlobalOptions(command));
+        await runResolve(skillName, context, dependencies);
+    });
+    cmd
+        .command('set')
+        .description('Set a skill gate in a concrete config layer')
+        .argument('<skill>', 'Gate-aware skill name')
+        .option('--command <command>', 'Gate command to run')
+        .option('--description <description>', 'Gate purpose and follow-up notes')
+        .option('--on-failure <mode>', 'Failure behavior: block, prompt, or warn')
+        .option('--max-attempts <count>', 'Maximum block remediation attempts')
+        .option('--disable', 'Disable this skill gate in the selected layer')
+        .option('--layer <layer>', 'Config layer to write: shared, local, or user')
+        .action(async (skillName, options, command) => {
+        const context = dependencies.buildCommandContext(readGlobalOptions(command));
+        await runGateSet(skillName, options, context, dependencies);
+    });
+    cmd
+        .command('unset')
+        .description('Remove a skill gate entry from a concrete config layer')
+        .argument('<skill>', 'Gate-aware skill name')
+        .option('--layer <layer>', 'Config layer to write: shared, local, or user')
+        .action(async (skillName, options, command) => {
+        const context = dependencies.buildCommandContext(readGlobalOptions(command));
+        await runGateUnset(skillName, options, context, dependencies);
+    });
+    cmd
+        .command('cross-provider-exec')
+        .description('Run a prompt through an alternate configured runtime target')
+        .option('--target <id>', 'Run this exact exec target')
+        .option('--avoid <mode>', 'Avoidance mode: same-runtime or none')
+        .option('--current-runtime <runtime>', 'Override detected runtime for testing or manual routing')
+        .argument('<prompt...>', 'Prompt arguments appended to the target command')
+        .action(async (prompt, options, command) => {
+        const context = dependencies.buildCommandContext(readGlobalOptions(command));
+        await runCrossProviderExec(prompt, options, context, dependencies);
+    });
+    const target = new Command('target').description('Manage gate execution targets');
+    target
+        .command('set')
+        .description('Set an exec target in a concrete config layer')
+        .argument('<id>', 'Exec target id')
+        .option('--runtime <runtime>', 'Logical runtime family')
+        .option('--base-command-json <json>', 'JSON argv array for the base command')
+        .option('--host-detection-json <json>', 'JSON argv array for host detection')
+        .option('--availability-json <json>', 'JSON argv array for availability')
+        .option('--priority <number>', 'Target priority, higher wins')
+        .option('--disable', 'Disable this exec target in the selected layer')
+        .option('--layer <layer>', 'Config layer to write: shared, local, or user')
+        .action(async (targetId, options, command) => {
+        const context = dependencies.buildCommandContext(readGlobalOptions(command));
+        await runTargetSet(targetId, options, context, dependencies);
+    });
+    target
+        .command('unset')
+        .description('Remove an exec target entry from a concrete config layer')
+        .argument('<id>', 'Exec target id')
+        .option('--layer <layer>', 'Config layer to write: shared, local, or user')
+        .action(async (targetId, options, command) => {
+        const context = dependencies.buildCommandContext(readGlobalOptions(command));
+        await runTargetUnset(targetId, options, context, dependencies);
+    });
+    cmd.addCommand(target);
+    return cmd;
+}

package/dist/commands/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/commands/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAwBzC,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAsBvD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/commands/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAyBzC,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAuBvD"}

package/dist/commands/index.js

@@ -4,6 +4,7 @@ import { createConfigCommand } from './config/index.js';
 import { createDecisionCommand } from './decision/index.js';
 import { createDocsCommand } from './docs/index.js';
 import { createDoctorCommand } from './doctor/index.js';
+import { createGateCommand } from './gate/index.js';
 import { createIndexCommand } from './index-cmd/index.js';
 import { createInitCommand } from './init/index.js';
 import { createInstructionsCommand } from './instructions/index.js';
@@ -26,6 +27,7 @@ export function registerCommands(program) {
     program.addCommand(createStatusCommand());
     program.addCommand(createSyncCommand());
     program.addCommand(createConfigCommand());
+    program.addCommand(createGateCommand());
     program.addCommand(createLocalCommand());
     program.addCommand(createProvidersCommand());
     program.addCommand(createRemoveCommand());

package/dist/commands/internal/validate-oat-skills.d.ts

@@ -1,9 +1,12 @@
 import { type CommandContext, type GlobalOptions } from '../../app/command-context.js';
+import { type ResolvedConfig } from '../../config/resolve.js';
 import { type ValidateOatSkillsOptions, type ValidateOatSkillsResult } from '../../validation/index.js';
 import { Command } from 'commander';
 interface ValidateOatSkillsDependencies {
     buildCommandContext: (options: GlobalOptions) => CommandContext;
     validateOatSkills: (repoRoot: string, options?: ValidateOatSkillsOptions) => Promise<ValidateOatSkillsResult>;
+    resolveEffectiveConfig: (repoRoot: string, userConfigDir: string, env?: NodeJS.ProcessEnv) => Promise<ResolvedConfig>;
+    env?: NodeJS.ProcessEnv;
 }
 export declare function createValidateOatSkillsCommand(overrides?: Partial<ValidateOatSkillsDependencies>): Command;
 export {};

package/dist/commands/internal/validate-oat-skills.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validate-oat-skills.d.ts","sourceRoot":"","sources":["../../../src/commands/internal/validate-oat-skills.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,aAAa,EACnB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAEL,KAAK,wBAAwB,EAC7B,KAAK,uBAAuB,EAC7B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,UAAU,6BAA6B;IACrC,mBAAmB,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,cAAc,CAAC;IAChE,iBAAiB,EAAE,CACjB,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,wBAAwB,KAC/B,OAAO,CAAC,uBAAuB,CAAC,CAAC;CACvC;AAkED,wBAAgB,8BAA8B,CAC5C,SAAS,GAAE,OAAO,CAAC,6BAA6B,CAAM,GACrD,OAAO,CAkBT"}
+{"version":3,"file":"validate-oat-skills.d.ts","sourceRoot":"","sources":["../../../src/commands/internal/validate-oat-skills.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,aAAa,EACnB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAEL,KAAK,cAAc,EACpB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAEL,KAAK,wBAAwB,EAC7B,KAAK,uBAAuB,EAE7B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,UAAU,6BAA6B;IACrC,mBAAmB,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,cAAc,CAAC;IAChE,iBAAiB,EAAE,CACjB,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,wBAAwB,KAC/B,OAAO,CAAC,uBAAuB,CAAC,CAAC;IACtC,sBAAsB,EAAE,CACtB,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,MAAM,EACrB,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,KACpB,OAAO,CAAC,cAAc,CAAC,CAAC;IAC7B,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;CACzB;AA+HD,wBAAgB,8BAA8B,CAC5C,SAAS,GAAE,OAAO,CAAC,6BAA6B,CAAM,GACrD,OAAO,CAkBT"}