@open-agent-toolkit/cli 0.0.10

package/dist/commands/project/new/scaffold.js

@@ -0,0 +1,177 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { resolveProjectsRoot } from '../../shared/oat-paths.js';
+import { generateStateDashboard } from '../../state/generate.js';
+import { setActiveProject } from '../../../config/oat-config.js';
+import { fileExists } from '../../../fs/io.js';
+const TEMPLATES_BY_MODE = {
+    'spec-driven': [
+        'state.md',
+        'discovery.md',
+        'spec.md',
+        'design.md',
+        'plan.md',
+        'implementation.md',
+    ],
+    quick: ['state.md', 'discovery.md', 'plan.md', 'implementation.md'],
+    import: ['state.md', 'plan.md', 'implementation.md'],
+};
+const STATE_TEMPLATE_BY_MODE = {
+    'spec-driven': {
+        hillCheckpoints: "['discovery', 'spec', 'design']",
+        phase: 'discovery',
+        status: 'Discovery',
+        currentPhase: 'Discovery - Gathering requirements and understanding the problem space',
+        artifacts: [
+            '- **Discovery:** `discovery.md` (in_progress)',
+            '- **Spec:** `spec.md` (scaffolded template — not started)',
+            '- **Design:** `design.md` (scaffolded template — not started)',
+            '- **Plan:** `plan.md` (scaffolded template — not started)',
+            '- **Implementation:** `implementation.md` (scaffolded template — not started)',
+        ],
+        progress: [
+            '- ✓ Discovery started',
+            '- ✓ Downstream lifecycle files scaffolded',
+            '- ⧗ Awaiting user input',
+        ],
+        nextMilestone: 'Complete discovery and move to specification phase',
+    },
+    quick: {
+        hillCheckpoints: '[]',
+        phase: 'discovery',
+        status: 'Discovery',
+        currentPhase: 'Discovery - Gathering requirements for a quick workflow before planning',
+        artifacts: [
+            '- **Discovery:** `discovery.md` (in_progress)',
+            '- **Spec:** N/A (quick mode)',
+            '- **Design:** N/A (quick mode unless lightweight design is needed)',
+            '- **Plan:** `plan.md` (scaffolded template — not started)',
+            '- **Implementation:** `implementation.md` (scaffolded template — not started)',
+        ],
+        progress: [
+            '- ✓ Discovery started',
+            '- ✓ Execution artifacts scaffolded',
+            '- ⧗ Awaiting user input',
+        ],
+        nextMilestone: 'Complete discovery and generate a quick implementation plan',
+    },
+    import: {
+        hillCheckpoints: '[]',
+        phase: 'plan',
+        status: 'Plan Import',
+        currentPhase: 'Plan import - Waiting to normalize an external plan into OAT format',
+        artifacts: [
+            '- **Discovery:** N/A (import mode)',
+            '- **Spec:** N/A (import mode)',
+            '- **Design:** N/A (import mode)',
+            '- **Plan:** `plan.md` (scaffolded template — awaiting imported content)',
+            '- **Implementation:** `implementation.md` (scaffolded template — awaiting imported plan)',
+        ],
+        progress: [
+            '- ✓ Import-mode project scaffolded',
+            '- ✓ Execution artifacts scaffolded',
+            '- ⧗ Awaiting external plan import',
+        ],
+        nextMilestone: 'Run `oat-project-import-plan` to normalize the external plan',
+    },
+};
+function validateProjectName(name) {
+    if (name.startsWith('-')) {
+        throw new Error(`Invalid project name "${name}". Project names must not start with a dash.`);
+    }
+    if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
+        throw new Error(`Invalid project name "${name}". Use only letters, numbers, dash, and underscore.`);
+    }
+}
+function applyTemplateReplacements(template, projectName, today, nowUtc, mode) {
+    const stateContent = STATE_TEMPLATE_BY_MODE[mode];
+    return template
+        .replaceAll('{Project Name}', projectName)
+        .replaceAll('YYYY-MM-DD', today)
+        .replaceAll('{OAT_HILL_CHECKPOINTS}', stateContent.hillCheckpoints)
+        .replaceAll('{OAT_WORKFLOW_MODE}', mode)
+        .replaceAll('{OAT_PHASE}', stateContent.phase)
+        .replaceAll('{OAT_STATUS}', stateContent.status)
+        .replaceAll('{OAT_CURRENT_PHASE}', stateContent.currentPhase)
+        .replaceAll('{OAT_ARTIFACTS}', stateContent.artifacts.join('\n'))
+        .replaceAll('{OAT_PROGRESS}', stateContent.progress.join('\n'))
+        .replaceAll('{OAT_NEXT_MILESTONE}', stateContent.nextMilestone)
+        .replaceAll(/oat_project_created:\s*null/gi, `oat_project_created: "${nowUtc}"`)
+        .replaceAll(/oat_project_state_updated:\s*null/gi, `oat_project_state_updated: "${nowUtc}"`)
+        .replaceAll(/\n?oat_template:\s*true\s*\n/gi, '\n')
+        .replaceAll(/\n?oat_template_name:\s*[^\n]*\n/gi, '\n');
+}
+async function defaultRefreshDashboard(repoRoot) {
+    await generateStateDashboard({ repoRoot });
+}
+async function scaffoldModeTemplates(repoRoot, projectPath, projectName, mode, today, nowUtc) {
+    const templatesDir = join(repoRoot, '.oat', 'templates');
+    const createdFiles = [];
+    const skippedFiles = [];
+    for (const templateFile of TEMPLATES_BY_MODE[mode]) {
+        const src = join(templatesDir, templateFile);
+        const dest = join(repoRoot, projectPath, templateFile);
+        if (await fileExists(dest)) {
+            skippedFiles.push(templateFile);
+            continue;
+        }
+        const template = await readFile(src, 'utf8');
+        const rendered = applyTemplateReplacements(template, projectName, today, nowUtc, mode);
+        await writeFile(dest, rendered, 'utf8');
+        createdFiles.push(templateFile);
+    }
+    return { createdFiles, skippedFiles };
+}
+async function ensureStructure(repoRoot, projectPath, mode) {
+    const projectRoot = join(repoRoot, projectPath);
+    await mkdir(projectRoot, { recursive: true });
+    await mkdir(join(projectRoot, 'reviews'), { recursive: true });
+    await mkdir(join(projectRoot, 'pr'), { recursive: true });
+    if (mode === 'import') {
+        const referencesDir = join(projectRoot, 'references');
+        await mkdir(referencesDir, { recursive: true });
+        const gitkeepPath = join(referencesDir, '.gitkeep');
+        if (!(await fileExists(gitkeepPath))) {
+            await writeFile(gitkeepPath, '', 'utf8');
+        }
+    }
+}
+export async function scaffoldProject(options) {
+    const mode = options.mode ?? 'spec-driven';
+    const setActive = options.setActive ?? true;
+    const refreshDashboard = options.refreshDashboard ?? true;
+    const env = options.env ?? process.env;
+    const now = new Date();
+    const today = options.today ?? now.toISOString().slice(0, 10);
+    const nowUtc = options.nowUtc ?? now.toISOString();
+    validateProjectName(options.projectName);
+    const projectsRoot = await resolveProjectsRoot(options.repoRoot, env);
+    const projectPath = join(projectsRoot, options.projectName);
+    // `--force` is currently accepted for compatibility with the legacy script.
+    // Scaffold behavior is always non-destructive (create missing files only).
+    void options.force;
+    await ensureStructure(options.repoRoot, projectPath, mode);
+    const { createdFiles, skippedFiles } = await scaffoldModeTemplates(options.repoRoot, projectPath, options.projectName, mode, today, nowUtc);
+    if (setActive) {
+        await setActiveProject(options.repoRoot, projectPath);
+    }
+    let dashboardRefreshed = false;
+    if (refreshDashboard) {
+        try {
+            await (options.refreshDashboardCallback ?? defaultRefreshDashboard)(options.repoRoot);
+            dashboardRefreshed = true;
+        }
+        catch (error) {
+            console.error(`Warning: dashboard refresh failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return {
+        mode,
+        projectsRoot,
+        projectPath,
+        createdFiles,
+        skippedFiles,
+        activePointerUpdated: setActive,
+        dashboardRefreshed,
+    };
+}

package/dist/commands/project/open/index.d.ts

@@ -0,0 +1,26 @@
+import { readFile as defaultReadFile, writeFile as defaultWriteFile } from 'node:fs/promises';
+import { buildCommandContext, type CommandContext } from '../../../app/command-context.js';
+import { type GenerateStateResult } from '../../state/generate.js';
+import { type OatLocalConfig } from '../../../config/oat-config.js';
+import { dirExists, fileExists } from '../../../fs/io.js';
+import { Command } from 'commander';
+interface ProjectOpenDependencies {
+    buildCommandContext: (options: Parameters<typeof buildCommandContext>[0]) => CommandContext;
+    resolveProjectRoot: (cwd: string) => Promise<string>;
+    resolveProjectsRoot: (repoRoot: string, env: NodeJS.ProcessEnv) => Promise<string>;
+    readOatLocalConfig: (repoRoot: string) => Promise<OatLocalConfig>;
+    writeOatLocalConfig: (repoRoot: string, config: OatLocalConfig) => Promise<void>;
+    setActiveProject: (repoRoot: string, path: string) => Promise<void>;
+    generateStateDashboard: (options: {
+        repoRoot: string;
+    }) => Promise<GenerateStateResult>;
+    readFile: typeof defaultReadFile;
+    writeFile: typeof defaultWriteFile;
+    dirExists: typeof dirExists;
+    fileExists: typeof fileExists;
+    processEnv: NodeJS.ProcessEnv;
+    now: () => Date;
+}
+export declare function createProjectOpenCommand(overrides?: Partial<ProjectOpenDependencies>): Command;
+export {};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/commands/project/open/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,IAAI,eAAe,EAC3B,SAAS,IAAI,gBAAgB,EAC9B,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EAAE,mBAAmB,EAAE,KAAK,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAYhF,OAAO,EAEL,KAAK,mBAAmB,EACzB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,KAAK,cAAc,EAIpB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AAE/C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAMpC,UAAU,uBAAuB;IAC/B,mBAAmB,EAAE,CACnB,OAAO,EAAE,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC,CAAC,CAAC,KAC/C,cAAc,CAAC;IACpB,kBAAkB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACrD,mBAAmB,EAAE,CACnB,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM,CAAC,UAAU,KACnB,OAAO,CAAC,MAAM,CAAC,CAAC;IACrB,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,gBAAgB,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACpE,sBAAsB,EAAE,CAAC,OAAO,EAAE;QAChC,QAAQ,EAAE,MAAM,CAAC;KAClB,KAAK,OAAO,CAAC,mBAAmB,CAAC,CAAC;IACnC,QAAQ,EAAE,OAAO,eAAe,CAAC;IACjC,SAAS,EAAE,OAAO,gBAAgB,CAAC;IACnC,SAAS,EAAE,OAAO,SAAS,CAAC;IAC5B,UAAU,EAAE,OAAO,UAAU,CAAC;IAC9B,UAAU,EAAE,MAAM,CAAC,UAAU,CAAC;IAC9B,GAAG,EAAE,MAAM,IAAI,CAAC;CACjB;AA+JD,wBAAgB,wBAAwB,CACtC,SAAS,GAAE,OAAO,CAAC,uBAAuB,CAAM,GAC/C,OAAO,CAkBT"}

package/dist/commands/project/open/index.js

@@ -0,0 +1,139 @@
+import { readFile as defaultReadFile, writeFile as defaultWriteFile, } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+import { buildCommandContext } from '../../../app/command-context.js';
+import { getFrontmatterBlock, getFrontmatterField, } from '../../shared/frontmatter.js';
+import { removeFrontmatterField, replaceFrontmatter, upsertFrontmatterField, } from '../../shared/frontmatter-write.js';
+import { resolveProjectsRoot } from '../../shared/oat-paths.js';
+import { readGlobalOptions } from '../../shared/shared.utils.js';
+import { generateStateDashboard as defaultGenerateStateDashboard, } from '../../state/generate.js';
+import { readOatLocalConfig, setActiveProject, writeOatLocalConfig, } from '../../../config/oat-config.js';
+import { dirExists, fileExists } from '../../../fs/io.js';
+import { resolveProjectRoot } from '../../../fs/paths.js';
+import { Command } from 'commander';
+const DEFAULT_DEPENDENCIES = {
+    buildCommandContext,
+    resolveProjectRoot,
+    resolveProjectsRoot,
+    readOatLocalConfig,
+    writeOatLocalConfig,
+    setActiveProject,
+    generateStateDashboard: defaultGenerateStateDashboard,
+    readFile: defaultReadFile,
+    writeFile: defaultWriteFile,
+    dirExists,
+    fileExists,
+    processEnv: process.env,
+    now: () => new Date(),
+};
+async function maybeResumePausedProject(statePath, dependencies) {
+    const stateContent = await dependencies.readFile(statePath, 'utf8');
+    const frontmatter = getFrontmatterBlock(stateContent);
+    if (!frontmatter) {
+        throw new Error(`state.md is missing frontmatter: ${statePath}`);
+    }
+    if (getFrontmatterField(frontmatter, 'oat_lifecycle') !== 'paused') {
+        return false;
+    }
+    let nextBlock = upsertFrontmatterField(frontmatter, 'oat_lifecycle', 'active', true).nextBlock;
+    nextBlock = removeFrontmatterField(nextBlock, 'oat_pause_timestamp');
+    nextBlock = removeFrontmatterField(nextBlock, 'oat_pause_reason');
+    nextBlock = upsertFrontmatterField(nextBlock, 'oat_project_state_updated', dependencies.now().toISOString(), true).nextBlock;
+    if (nextBlock !== frontmatter) {
+        await dependencies.writeFile(statePath, replaceFrontmatter(stateContent, nextBlock), 'utf8');
+    }
+    return true;
+}
+async function runProjectOpen(projectName, options, context, dependencies) {
+    try {
+        const repoRoot = await dependencies.resolveProjectRoot(context.cwd);
+        const projectsRoot = await dependencies.resolveProjectsRoot(repoRoot, dependencies.processEnv);
+        const projectPath = join(projectsRoot, projectName);
+        const fullProjectPath = join(repoRoot, projectPath);
+        if (!(await dependencies.dirExists(fullProjectPath))) {
+            throw new Error(`Project not found: ${projectName}`);
+        }
+        const statePath = join(fullProjectPath, 'state.md');
+        if (!(await dependencies.fileExists(statePath))) {
+            throw new Error(`Project state.md not found: ${statePath}`);
+        }
+        const localConfig = await dependencies.readOatLocalConfig(repoRoot);
+        const previousActiveProject = localConfig.activeProject ?? null;
+        if (previousActiveProject === projectPath) {
+            if (context.json) {
+                context.logger.json({
+                    status: 'ok',
+                    projectName,
+                    projectPath,
+                    previousActiveProject,
+                    resumedFromPaused: false,
+                    reason: options.reason ?? null,
+                    message: 'already active',
+                });
+            }
+            else {
+                context.logger.info(`Project ${projectName} is already active.`);
+            }
+            process.exitCode = 0;
+            return;
+        }
+        const resumedFromPaused = await maybeResumePausedProject(statePath, dependencies);
+        await dependencies.setActiveProject(repoRoot, projectPath);
+        if (localConfig.lastPausedProject === projectPath) {
+            const updatedConfig = await dependencies.readOatLocalConfig(repoRoot);
+            await dependencies.writeOatLocalConfig(repoRoot, {
+                ...updatedConfig,
+                lastPausedProject: null,
+            });
+        }
+        await dependencies.generateStateDashboard({ repoRoot });
+        if (context.json) {
+            context.logger.json({
+                status: 'ok',
+                projectName,
+                projectPath,
+                previousActiveProject,
+                resumedFromPaused,
+                reason: options.reason ?? null,
+            });
+        }
+        else {
+            if (previousActiveProject) {
+                context.logger.info(`Switching from ${basename(previousActiveProject)} to ${projectName}.`);
+            }
+            else {
+                context.logger.info(`Opened project: ${projectName}`);
+            }
+            if (resumedFromPaused) {
+                context.logger.info('Resumed paused project and cleared pause metadata.');
+            }
+            if (options.reason) {
+                context.logger.info(`Reason: ${options.reason}`);
+            }
+        }
+        process.exitCode = 0;
+    }
+    catch (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;
+    }
+}
+export function createProjectOpenCommand(overrides = {}) {
+    const dependencies = {
+        ...DEFAULT_DEPENDENCIES,
+        ...overrides,
+    };
+    return new Command('open')
+        .description('Open or switch to an OAT project')
+        .argument('<name>', 'Project name')
+        .option('--reason <string>', 'Optional reason for opening or switching')
+        .action(async (name, options, command) => {
+        const context = dependencies.buildCommandContext(readGlobalOptions(command));
+        await runProjectOpen(name, options, context, dependencies);
+    });
+}

package/dist/commands/project/pause/index.d.ts

@@ -0,0 +1,27 @@
+import { readFile as defaultReadFile, writeFile as defaultWriteFile } from 'node:fs/promises';
+import { buildCommandContext, type CommandContext } from '../../../app/command-context.js';
+import { type GenerateStateResult } from '../../state/generate.js';
+import { type OatLocalConfig } from '../../../config/oat-config.js';
+import { dirExists, fileExists } from '../../../fs/io.js';
+import { Command } from 'commander';
+interface ProjectPauseDependencies {
+    buildCommandContext: (options: Parameters<typeof buildCommandContext>[0]) => CommandContext;
+    resolveProjectRoot: (cwd: string) => Promise<string>;
+    resolveProjectsRoot: (repoRoot: string, env: NodeJS.ProcessEnv) => Promise<string>;
+    readOatLocalConfig: (repoRoot: string) => Promise<OatLocalConfig>;
+    clearActiveProject: (repoRoot: string, options?: {
+        lastPaused?: string;
+    }) => Promise<void>;
+    generateStateDashboard: (options: {
+        repoRoot: string;
+    }) => Promise<GenerateStateResult>;
+    readFile: typeof defaultReadFile;
+    writeFile: typeof defaultWriteFile;
+    dirExists: typeof dirExists;
+    fileExists: typeof fileExists;
+    processEnv: NodeJS.ProcessEnv;
+    now: () => Date;
+}
+export declare function createProjectPauseCommand(overrides?: Partial<ProjectPauseDependencies>): Command;
+export {};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/commands/project/pause/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,IAAI,eAAe,EAC3B,SAAS,IAAI,gBAAgB,EAC9B,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EAAE,mBAAmB,EAAE,KAAK,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAShF,OAAO,EAEL,KAAK,mBAAmB,EACzB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAEL,KAAK,cAAc,EAEpB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AAE/C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAMpC,UAAU,wBAAwB;IAChC,mBAAmB,EAAE,CACnB,OAAO,EAAE,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC,CAAC,CAAC,KAC/C,cAAc,CAAC;IACpB,kBAAkB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACrD,mBAAmB,EAAE,CACnB,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM,CAAC,UAAU,KACnB,OAAO,CAAC,MAAM,CAAC,CAAC;IACrB,kBAAkB,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,cAAc,CAAC,CAAC;IAClE,kBAAkB,EAAE,CAClB,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE;QAAE,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,KAC9B,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB,sBAAsB,EAAE,CAAC,OAAO,EAAE;QAChC,QAAQ,EAAE,MAAM,CAAC;KAClB,KAAK,OAAO,CAAC,mBAAmB,CAAC,CAAC;IACnC,QAAQ,EAAE,OAAO,eAAe,CAAC;IACjC,SAAS,EAAE,OAAO,gBAAgB,CAAC;IACnC,SAAS,EAAE,OAAO,SAAS,CAAC;IAC5B,UAAU,EAAE,OAAO,UAAU,CAAC;IAC9B,UAAU,EAAE,MAAM,CAAC,UAAU,CAAC;IAC9B,GAAG,EAAE,MAAM,IAAI,CAAC;CACjB;AAyID,wBAAgB,yBAAyB,CACvC,SAAS,GAAE,OAAO,CAAC,wBAAwB,CAAM,GAChD,OAAO,CAsBT"}

package/dist/commands/project/pause/index.js

@@ -0,0 +1,120 @@
+import { readFile as defaultReadFile, writeFile as defaultWriteFile, } from 'node:fs/promises';
+import { join } from 'node:path';
+import { buildCommandContext } from '../../../app/command-context.js';
+import { getFrontmatterBlock } from '../../shared/frontmatter.js';
+import { removeFrontmatterField, replaceFrontmatter, upsertFrontmatterField, } from '../../shared/frontmatter-write.js';
+import { resolveProjectsRoot } from '../../shared/oat-paths.js';
+import { readGlobalOptions } from '../../shared/shared.utils.js';
+import { generateStateDashboard as defaultGenerateStateDashboard, } from '../../state/generate.js';
+import { clearActiveProject, readOatLocalConfig, } from '../../../config/oat-config.js';
+import { dirExists, fileExists } from '../../../fs/io.js';
+import { resolveProjectRoot } from '../../../fs/paths.js';
+import { Command } from 'commander';
+const DEFAULT_DEPENDENCIES = {
+    buildCommandContext,
+    resolveProjectRoot,
+    resolveProjectsRoot,
+    readOatLocalConfig,
+    clearActiveProject,
+    generateStateDashboard: defaultGenerateStateDashboard,
+    readFile: defaultReadFile,
+    writeFile: defaultWriteFile,
+    dirExists,
+    fileExists,
+    processEnv: process.env,
+    now: () => new Date(),
+};
+async function runProjectPause(projectName, options, context, dependencies) {
+    try {
+        const repoRoot = await dependencies.resolveProjectRoot(context.cwd);
+        const projectsRoot = await dependencies.resolveProjectsRoot(repoRoot, dependencies.processEnv);
+        const localConfig = await dependencies.readOatLocalConfig(repoRoot);
+        const activeProject = localConfig.activeProject ?? null;
+        let projectPath;
+        let resolvedProjectName;
+        if (projectName) {
+            projectPath = join(projectsRoot, projectName);
+            resolvedProjectName = projectName;
+        }
+        else {
+            if (!activeProject) {
+                throw new Error('No project specified and no active project');
+            }
+            projectPath = activeProject;
+            resolvedProjectName = projectPath.split('/').at(-1) ?? projectPath;
+        }
+        const fullProjectPath = join(repoRoot, projectPath);
+        if (!(await dependencies.dirExists(fullProjectPath))) {
+            throw new Error(`Project not found: ${resolvedProjectName}`);
+        }
+        const statePath = join(fullProjectPath, 'state.md');
+        if (!(await dependencies.fileExists(statePath))) {
+            throw new Error(`Project state.md not found: ${statePath}`);
+        }
+        const content = await dependencies.readFile(statePath, 'utf8');
+        const frontmatter = getFrontmatterBlock(content);
+        if (!frontmatter) {
+            throw new Error(`state.md is missing frontmatter: ${statePath}`);
+        }
+        let nextBlock = upsertFrontmatterField(frontmatter, 'oat_lifecycle', 'paused', true).nextBlock;
+        const nowIso = dependencies.now().toISOString();
+        nextBlock = upsertFrontmatterField(nextBlock, 'oat_pause_timestamp', nowIso, true).nextBlock;
+        nextBlock = upsertFrontmatterField(nextBlock, 'oat_project_state_updated', nowIso, true).nextBlock;
+        if (options.reason) {
+            nextBlock = upsertFrontmatterField(nextBlock, 'oat_pause_reason', options.reason, true).nextBlock;
+        }
+        else {
+            nextBlock = removeFrontmatterField(nextBlock, 'oat_pause_reason');
+        }
+        if (nextBlock !== frontmatter) {
+            await dependencies.writeFile(statePath, replaceFrontmatter(content, nextBlock), 'utf8');
+        }
+        const pointerCleared = activeProject === projectPath;
+        if (pointerCleared) {
+            await dependencies.clearActiveProject(repoRoot, {
+                lastPaused: projectPath,
+            });
+        }
+        await dependencies.generateStateDashboard({ repoRoot });
+        if (context.json) {
+            context.logger.json({
+                status: 'ok',
+                projectName: resolvedProjectName,
+                projectPath,
+                pointerCleared,
+                reason: options.reason ?? null,
+            });
+        }
+        else {
+            context.logger.info(`Paused project: ${resolvedProjectName}`);
+            if (pointerCleared) {
+                context.logger.info('Cleared active project pointer.');
+            }
+        }
+        process.exitCode = 0;
+    }
+    catch (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;
+    }
+}
+export function createProjectPauseCommand(overrides = {}) {
+    const dependencies = {
+        ...DEFAULT_DEPENDENCIES,
+        ...overrides,
+    };
+    return new Command('pause')
+        .description('Pause an OAT project')
+        .argument('[name]', 'Project name (defaults to active project)')
+        .option('--reason <string>', 'Optional reason to persist in project state')
+        .action(async (name, options, command) => {
+        const context = dependencies.buildCommandContext(readGlobalOptions(command));
+        await runProjectPause(name, options, context, dependencies);
+    });
+}

package/dist/commands/project/set-mode/index.d.ts

@@ -0,0 +1,14 @@
+import { readFile as defaultReadFile, writeFile as defaultWriteFile } from 'node:fs/promises';
+import { buildCommandContext, type CommandContext } from '../../../app/command-context.js';
+import { Command } from 'commander';
+export type ExecutionMode = 'single-thread' | 'subagent-driven';
+interface SetModeDependencies {
+    buildCommandContext: (options: Parameters<typeof buildCommandContext>[0]) => CommandContext;
+    resolveProjectRoot: (cwd: string) => Promise<string>;
+    readFile: typeof defaultReadFile;
+    writeFile: typeof defaultWriteFile;
+    now: () => Date;
+}
+export declare function createProjectSetModeCommand(overrides?: Partial<SetModeDependencies>): Command;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/project/set-mode/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/commands/project/set-mode/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,IAAI,eAAe,EAC3B,SAAS,IAAI,gBAAgB,EAC9B,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EAAE,mBAAmB,EAAE,KAAK,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAYhF,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,MAAM,MAAM,aAAa,GAAG,eAAe,GAAG,iBAAiB,CAAC;AAEhE,UAAU,mBAAmB;IAC3B,mBAAmB,EAAE,CACnB,OAAO,EAAE,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC,CAAC,CAAC,KAC/C,cAAc,CAAC;IACpB,kBAAkB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACrD,QAAQ,EAAE,OAAO,eAAe,CAAC;IACjC,SAAS,EAAE,OAAO,gBAAgB,CAAC;IACnC,GAAG,EAAE,MAAM,IAAI,CAAC;CACjB;AAwID,wBAAgB,2BAA2B,CACzC,SAAS,GAAE,OAAO,CAAC,mBAAmB,CAAM,GAC3C,OAAO,CAeT"}

package/dist/commands/project/set-mode/index.js

@@ -0,0 +1,115 @@
+import { readFile as defaultReadFile, writeFile as defaultWriteFile, } from 'node:fs/promises';
+import { join } from 'node:path';
+import { buildCommandContext } from '../../../app/command-context.js';
+import { getFrontmatterBlock, getFrontmatterField, } from '../../shared/frontmatter.js';
+import { replaceFrontmatter, upsertFrontmatterField, } from '../../shared/frontmatter-write.js';
+import { readGlobalOptions } from '../../shared/shared.utils.js';
+import { readOatLocalConfig } from '../../../config/oat-config.js';
+import { resolveProjectRoot } from '../../../fs/paths.js';
+import { Command } from 'commander';
+const ORCHESTRATION_DEFAULTS = [
+    { field: 'oat_orchestration_merge_strategy', value: 'merge' },
+    { field: 'oat_orchestration_retry_limit', value: '2' },
+    { field: 'oat_orchestration_baseline_policy', value: 'strict' },
+    { field: 'oat_orchestration_unit_granularity', value: 'phase' },
+];
+const DEFAULT_DEPENDENCIES = {
+    buildCommandContext,
+    resolveProjectRoot,
+    readFile: defaultReadFile,
+    writeFile: defaultWriteFile,
+    now: () => new Date(),
+};
+function isExecutionMode(value) {
+    return value === 'single-thread' || value === 'subagent-driven';
+}
+async function runSetMode(modeArg, context, dependencies) {
+    try {
+        if (!isExecutionMode(modeArg)) {
+            throw new Error(`Invalid mode: ${modeArg}. Expected one of: single-thread, subagent-driven.`);
+        }
+        const repoRoot = await dependencies.resolveProjectRoot(context.cwd);
+        const localConfig = await readOatLocalConfig(repoRoot);
+        const activeProject = localConfig.activeProject?.trim();
+        if (!activeProject) {
+            throw new Error('No active project found (.oat/config.local.json has no activeProject).');
+        }
+        const activeProjectPath = join(repoRoot, activeProject);
+        const statePath = join(activeProjectPath, 'state.md');
+        let stateContent;
+        try {
+            stateContent = await dependencies.readFile(statePath, 'utf8');
+        }
+        catch {
+            throw new Error(`Active project state.md not found: ${statePath}`);
+        }
+        const frontmatterBlock = getFrontmatterBlock(stateContent);
+        if (!frontmatterBlock) {
+            throw new Error(`state.md is missing frontmatter: ${statePath}`);
+        }
+        const previousMode = getFrontmatterField(frontmatterBlock, 'oat_execution_mode');
+        let currentBlock = frontmatterBlock;
+        const modeUpdate = upsertFrontmatterField(currentBlock, 'oat_execution_mode', modeArg, true);
+        currentBlock = modeUpdate.nextBlock;
+        const defaultsAdded = [];
+        if (modeArg === 'subagent-driven') {
+            for (const entry of ORCHESTRATION_DEFAULTS) {
+                const update = upsertFrontmatterField(currentBlock, entry.field, entry.value, false);
+                currentBlock = update.nextBlock;
+                if (update.added) {
+                    defaultsAdded.push(entry.field);
+                }
+            }
+        }
+        currentBlock = upsertFrontmatterField(currentBlock, 'oat_project_state_updated', dependencies.now().toISOString(), true).nextBlock;
+        const updatedState = replaceFrontmatter(stateContent, currentBlock);
+        await dependencies.writeFile(statePath, updatedState, 'utf8');
+        if (context.json) {
+            context.logger.json({
+                status: 'ok',
+                mode: modeArg,
+                previousMode: previousMode || null,
+                statePath,
+                projectPath: activeProjectPath,
+                defaultsAdded,
+            });
+        }
+        else {
+            context.logger.info(`Set execution mode to ${modeArg}`);
+            context.logger.info(`Project: ${activeProjectPath}`);
+            context.logger.info(`State: ${statePath}`);
+            if (modeArg === 'subagent-driven') {
+                if (defaultsAdded.length > 0) {
+                    context.logger.info(`Added orchestration defaults: ${defaultsAdded.join(', ')}`);
+                }
+                else {
+                    context.logger.info('Orchestration defaults already present; no defaults added.');
+                }
+            }
+        }
+        process.exitCode = 0;
+    }
+    catch (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;
+    }
+}
+export function createProjectSetModeCommand(overrides = {}) {
+    const dependencies = {
+        ...DEFAULT_DEPENDENCIES,
+        ...overrides,
+    };
+    return new Command('set-mode')
+        .description('Set project implementation execution mode')
+        .argument('<mode>', 'Execution mode: single-thread or subagent-driven')
+        .action(async (mode, _options, command) => {
+        const context = dependencies.buildCommandContext(readGlobalOptions(command));
+        await runSetMode(mode, context, dependencies);
+    });
+}

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

@@ -0,0 +1,4 @@
+import { Command } from 'commander';
+import type { ProvidersInspectDependencies, ProvidersListDependencies, ProvidersSetDependencies } from './providers.types.js';
+export declare function createProvidersCommand(listOverrides?: Partial<ProvidersListDependencies>, inspectOverrides?: Partial<ProvidersInspectDependencies>, setOverrides?: Partial<ProvidersSetDependencies>): Command;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/providers/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIpC,OAAO,KAAK,EACV,4BAA4B,EAC5B,yBAAyB,EACzB,wBAAwB,EACzB,MAAM,mBAAmB,CAAC;AAG3B,wBAAgB,sBAAsB,CACpC,aAAa,GAAE,OAAO,CAAC,yBAAyB,CAAM,EACtD,gBAAgB,GAAE,OAAO,CAAC,4BAA4B,CAAM,EAC5D,YAAY,GAAE,OAAO,CAAC,wBAAwB,CAAM,GACnD,OAAO,CAMT"}

package/dist/commands/providers/index.js

@@ -0,0 +1,11 @@
+import { Command } from 'commander';
+import { createProvidersInspectCommand } from './inspect/inspect.js';
+import { createProvidersListCommand } from './list/list.js';
+import { createProvidersSetCommand } from './set/index.js';
+export function createProvidersCommand(listOverrides = {}, inspectOverrides = {}, setOverrides = {}) {
+    return new Command('providers')
+        .description('Inspect provider capabilities and paths')
+        .addCommand(createProvidersListCommand(listOverrides))
+        .addCommand(createProvidersInspectCommand(inspectOverrides))
+        .addCommand(createProvidersSetCommand(setOverrides));
+}