@njeybe/nativ 2.0.0

package/dist/commands/validate.js

@@ -0,0 +1,89 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import pc from 'picocolors';
+export async function runValidate(targetDirArg) {
+    const targetDir = path.resolve(targetDirArg || process.cwd());
+    console.log(pc.bold(pc.cyan(`\n🔍 Validating AI Agent Workflow Contracts in: ${targetDir}\n`)));
+    let hasErrors = false;
+    function checkFile(relPath, isJson = false) {
+        const fullPath = path.join(targetDir, relPath);
+        if (!fs.existsSync(fullPath)) {
+            console.log(pc.red(`  ✖ Missing: ${relPath}`));
+            hasErrors = true;
+            return null;
+        }
+        const content = fs.readFileSync(fullPath, 'utf8');
+        if (content.trim().length === 0) {
+            console.log(pc.yellow(`  ⚠ Empty file: ${relPath}`));
+            return null;
+        }
+        if (isJson) {
+            try {
+                const parsed = JSON.parse(content);
+                console.log(pc.green(`  ✔ Valid JSON: ${relPath}`));
+                return parsed;
+            }
+            catch (err) {
+                console.log(pc.red(`  ✖ Malformed JSON in ${relPath}: ${err.message}`));
+                hasErrors = true;
+                return null;
+            }
+        }
+        console.log(pc.green(`  ✔ Present: ${relPath}`));
+        return content;
+    }
+    // Directives tell agents how to work; they are guidance, not contracts, and GEMINI.md is only an optional adapter guide.
+    console.log(pc.bold('1. Directives:'));
+    const directives = ['AGENTS.md', 'CLAUDE.md', 'GEMINI.md'].filter((f) => fs.existsSync(path.join(targetDir, f)));
+    for (const file of directives)
+        checkFile(file);
+    if (!directives.length) {
+        console.log(pc.yellow('  ⚠ No directive file (AGENTS.md, CLAUDE.md). Agents will not be told the workflow; run `nativ setup` to add them.'));
+    }
+    console.log(pc.bold('\n2. Core Specification Contracts:'));
+    checkFile('.ai/context.md');
+    checkFile('.ai/db_schema.json', true);
+    checkFile('.ai/api_contracts.json', true);
+    checkFile('.ai/ui_specs.md');
+    const plan = checkFile('.ai/master_plan.json', true);
+    if (plan) {
+        if (!Array.isArray(plan.milestones)) {
+            console.log(pc.red('  ✖ .ai/master_plan.json missing `milestones` array'));
+            hasErrors = true;
+        }
+    }
+    const escalationPath = path.join(targetDir, '.ai/escalation.json');
+    if (fs.existsSync(escalationPath)) {
+        const escData = checkFile('.ai/escalation.json', true);
+        if (escData && !Array.isArray(escData.escalations)) {
+            console.log(pc.red('  ✖ .ai/escalation.json missing `escalations` array'));
+            hasErrors = true;
+        }
+    }
+    console.log(pc.bold('\n3. Sub-agent Profiles:'));
+    console.log(pc.dim('  Core Units:'));
+    checkFile('.ai/subagents/database.md');
+    checkFile('.ai/subagents/backend.md');
+    checkFile('.ai/subagents/frontend.md');
+    checkFile('.ai/subagents/qa-tester.md');
+    console.log(pc.dim('  Specialized Units:'));
+    const specializedProfiles = [
+        'flutter-developer.md',
+        'devops-agent.md',
+        'security-auditor.md',
+        'db-migration.md',
+    ];
+    for (const profile of specializedProfiles) {
+        const rel = `.ai/subagents/${profile}`;
+        if (fs.existsSync(path.join(targetDir, rel))) {
+            checkFile(rel);
+        }
+    }
+    if (hasErrors) {
+        console.log(pc.bold(pc.red('\n✖ Workflow contracts validation failed with errors.')));
+        process.exitCode = 1;
+    }
+    else {
+        console.log(pc.bold(pc.green('\n✔ All contracts and specifications are valid and orchestration-ready!\n')));
+    }
+}

package/dist/commands/verify.d.ts

@@ -0,0 +1,8 @@
+import { BatchVerificationResult } from '../core/verifier.js';
+export interface VerifyOptions {
+    all?: boolean;
+    milestone?: string;
+    json?: boolean;
+    timeout?: number;
+}
+export declare function runVerify(taskId?: string, targetDirArg?: string, options?: VerifyOptions): Promise<BatchVerificationResult>;

package/dist/commands/verify.js

@@ -0,0 +1,65 @@
+import path from 'node:path';
+import pc from 'picocolors';
+import { verifyBatch } from '../core/verifier.js';
+export async function runVerify(taskId, targetDirArg, options = {}) {
+    const targetDir = path.resolve(targetDirArg || process.cwd());
+    const batch = await verifyBatch(targetDir, {
+        taskId,
+        milestoneId: options.milestone,
+        all: options.all,
+        timeout: options.timeout,
+    });
+    if (options.json) {
+        console.log(JSON.stringify(batch, null, 2));
+        if (batch.failed > 0) {
+            process.exitCode = 1;
+        }
+        return batch;
+    }
+    console.log(pc.bold(pc.cyan(`\nVerification Gatekeeper: ${batch.projectName}`)));
+    console.log(pc.dim(`Workspace: ${targetDir}\n`));
+    if (batch.total === 0) {
+        console.log(pc.yellow('No candidate tasks found to verify. Specify a taskId, --milestone, or --all.\n'));
+        return batch;
+    }
+    for (const t of batch.tasks) {
+        const elapsed = (t.result.durationMs / 1000).toFixed(2);
+        if (t.result.skipped) {
+            console.log(pc.dim(`  ○ [${t.taskId}] ${t.title} — no verification command (skipped)`));
+            continue;
+        }
+        if (t.result.success) {
+            console.log(pc.green(`  ✔ [${pc.bold(t.taskId)}] ${t.title}`) +
+                pc.dim(` (${elapsed}s)`) +
+                pc.yellow(` \`${t.result.command}\``));
+        }
+        else {
+            console.log(pc.red(`  ✖ [${pc.bold(t.taskId)}] ${t.title}`) +
+                pc.dim(` (${elapsed}s, exit code: ${t.result.exitCode})`) +
+                pc.yellow(` \`${t.result.command}\``));
+            if (t.result.stderr && t.result.stderr.trim()) {
+                console.log(pc.red(`\n--- [${t.taskId}] stderr ---`));
+                console.log(pc.red(t.result.stderr.trim()));
+            }
+            if (t.result.stdout && t.result.stdout.trim() && !t.result.stderr?.trim()) {
+                console.log(pc.dim(`\n--- [${t.taskId}] stdout ---`));
+                console.log(pc.dim(t.result.stdout.trim()));
+            }
+            if (t.result.error && !t.result.stderr?.includes(t.result.error)) {
+                console.log(pc.red(`\nError: ${t.result.error}`));
+            }
+            console.log('');
+        }
+    }
+    const totalTime = (batch.durationMs / 1000).toFixed(2);
+    console.log(pc.dim('\n────────────────────────────────────────────────────────────────'));
+    const summary = `Tasks: ${batch.total} | Passed: ${batch.passed} | Failed: ${batch.failed} | Skipped: ${batch.skipped} (${totalTime}s)`;
+    if (batch.failed > 0) {
+        console.log(pc.bold(pc.red(`✖ Verification FAILED: ${summary}\n`)));
+        process.exitCode = 1;
+    }
+    else {
+        console.log(pc.bold(pc.green(`✔ Verification PASSED: ${summary}\n`)));
+    }
+    return batch;
+}

package/dist/commands/worktree.d.ts

@@ -0,0 +1,47 @@
+export interface WorktreeCreateOptions {
+    json?: boolean;
+}
+export interface WorktreeCreateResult {
+    success: boolean;
+    taskId: string;
+    branch: string;
+    worktreeDir: string;
+    aiMounted: boolean;
+    message: string;
+}
+export declare function runWorktreeCreate(taskId: string, targetDirArg?: string, options?: WorktreeCreateOptions): Promise<WorktreeCreateResult | null>;
+export interface WorktreeInfo {
+    path: string;
+    head: string;
+    branch: string;
+    isAgentWorktree: boolean;
+    taskId?: string;
+}
+export declare function runWorktreeList(targetDirArg?: string, options?: {
+    json?: boolean;
+}): Promise<WorktreeInfo[]>;
+export interface WorktreeMergeOptions {
+    force?: boolean;
+    json?: boolean;
+}
+export interface WorktreeMergeResult {
+    success: boolean;
+    taskId: string;
+    branch: string;
+    merged: boolean;
+    /** Uncommitted agent work was committed on the agent branch before merging. */
+    committedPendingWork?: boolean;
+    message: string;
+}
+export declare function runWorktreeMerge(taskId: string, targetDirArg?: string, options?: WorktreeMergeOptions): Promise<WorktreeMergeResult | null>;
+export interface WorktreeRemoveOptions {
+    force?: boolean;
+    json?: boolean;
+}
+export declare function runWorktreeRemove(taskId: string, targetDirArg?: string, options?: WorktreeRemoveOptions): Promise<{
+    success: boolean;
+    taskId: string;
+    branch: string;
+    removed: boolean;
+    message: string;
+} | null>;

package/dist/commands/worktree.js

@@ -0,0 +1,396 @@
+import { execSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import pc from 'picocolors';
+import { resolveProjectRoot, linkWorktreeAiDirectory, safeUnlinkWorktreeAiDirectory, linkWorktreeNodeModules, safeUnlinkWorktreeNodeModules, } from '../core/root-resolver.js';
+import { CircuitBreaker } from '../governor/index.js';
+import { mergeAgentWorktree, WorktreeMergeError } from '../core/worktree-merge.js';
+function isGitRepo(targetDir) {
+    try {
+        execSync('git rev-parse --is-inside-work-tree', { cwd: targetDir, stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function loadPlan(rootDir) {
+    const planPath = path.join(rootDir, '.ai', 'master_plan.json');
+    if (!fs.existsSync(planPath))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(planPath, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+export async function runWorktreeCreate(taskId, targetDirArg, options = {}) {
+    const rootDir = resolveProjectRoot(targetDirArg);
+    if (!isGitRepo(rootDir)) {
+        const msg = `Not a git repository: ${rootDir}`;
+        if (options.json) {
+            console.log(JSON.stringify({ success: false, error: msg }, null, 2));
+        }
+        else {
+            console.error(pc.red(`\n✖ ${msg}`));
+            console.log(pc.yellow('Git must be initialized to use worktree features.\n'));
+        }
+        process.exitCode = 1;
+        return null;
+    }
+    const plan = loadPlan(rootDir);
+    if (plan) {
+        let taskExists = false;
+        for (const m of plan.milestones) {
+            if (m.tasks.some((t) => t.id === taskId)) {
+                taskExists = true;
+                break;
+            }
+        }
+        if (!taskExists && !options.json) {
+            console.log(pc.yellow(`⚠ Warning: Task [${taskId}] is not declared in .ai/master_plan.json.`));
+        }
+    }
+    const worktreeDir = path.join(rootDir, '.worktrees', `task-${taskId}`);
+    const branchName = `agent/task-${taskId}`;
+    if (fs.existsSync(path.join(worktreeDir, '.git'))) {
+        // A real worktree: make sure its mounts survived (they are the first thing a manual cleanup removes).
+        const aiMounted = linkWorktreeAiDirectory(worktreeDir, rootDir);
+        linkWorktreeNodeModules(worktreeDir, rootDir);
+        const msg = `Worktree already exists at: ${worktreeDir}`;
+        if (options.json) {
+            console.log(JSON.stringify({ success: true, taskId, branch: branchName, worktreeDir, alreadyExists: true, aiMounted, message: msg }, null, 2));
+        }
+        else {
+            console.log(pc.yellow(`\n⚠ ${msg}\n`));
+        }
+        return { success: true, taskId, branch: branchName, worktreeDir, aiMounted, message: msg };
+    }
+    if (fs.existsSync(worktreeDir)) {
+        // Left behind by a manual or interrupted cleanup: git no longer knows it. An empty shell is safe
+        // to clear; anything with files in it may be someone's work, so stop instead of deleting it.
+        safeUnlinkWorktreeNodeModules(worktreeDir);
+        safeUnlinkWorktreeAiDirectory(worktreeDir);
+        if (fs.readdirSync(worktreeDir).length > 0) {
+            const msg = `${worktreeDir} exists but is not a git worktree and still contains files. Move or delete it, then retry.`;
+            if (options.json) {
+                console.log(JSON.stringify({ success: false, error: msg }, null, 2));
+            }
+            else {
+                console.error(pc.red(`\n✖ ${msg}\n`));
+            }
+            process.exitCode = 1;
+            return null;
+        }
+        fs.rmdirSync(worktreeDir);
+    }
+    try {
+        if (!options.json) {
+            console.log(pc.cyan(`\n🌿 Spawning isolated Git Worktree for Task [${taskId}]...`));
+        }
+        fs.mkdirSync(path.join(rootDir, '.worktrees'), { recursive: true });
+        // Prune stale git worktrees so git worktree add does not fail on orphaned records
+        try {
+            execSync('git worktree prune', { cwd: rootDir, stdio: 'ignore' });
+        }
+        catch { }
+        // The agent branch outlives a manually deleted worktree folder; reuse it (keeping its commits)
+        // instead of failing on "a branch named ... already exists".
+        let branchExists = true;
+        try {
+            execSync(`git rev-parse --verify --quiet "refs/heads/${branchName}"`, { cwd: rootDir, stdio: 'ignore' });
+        }
+        catch {
+            branchExists = false;
+        }
+        execSync(branchExists ? `git worktree add "${worktreeDir}" "${branchName}"` : `git worktree add "${worktreeDir}" -b "${branchName}"`, {
+            cwd: rootDir,
+            stdio: options.json ? 'pipe' : 'inherit',
+        });
+        if (branchExists && !options.json) {
+            console.log(pc.dim(`  Reused existing branch ${branchName} (its earlier commits are kept).`));
+        }
+        // Link/mount .ai contract directory into the worktree
+        const aiMounted = linkWorktreeAiDirectory(worktreeDir, rootDir);
+        linkWorktreeNodeModules(worktreeDir, rootDir);
+        const result = {
+            success: true,
+            taskId,
+            branch: branchName,
+            worktreeDir,
+            aiMounted,
+            message: `Worktree for ${taskId} created successfully`,
+        };
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.log(pc.bold(pc.green(`\n✔ Worktree created successfully!`)));
+            console.log(pc.dim('  Branch:     ') + pc.cyan(branchName));
+            console.log(pc.dim('  Location:   ') + pc.white(worktreeDir));
+            console.log(pc.dim('  .ai Mount:  ') + (aiMounted ? pc.green('Linked to project root') : pc.dim('Resolved dynamically')));
+            console.log(pc.dim('\nExecution Instructions:'));
+            console.log(pc.white(`  Run your agent in: ${worktreeDir}`));
+            console.log(pc.dim(`  When completed and verified, merge with: `) + pc.cyan(`nativ worktree merge ${taskId}\n`));
+        }
+        return result;
+    }
+    catch (err) {
+        const msg = `Failed to create git worktree: ${err.message}`;
+        if (options.json) {
+            console.log(JSON.stringify({ success: false, error: msg }, null, 2));
+        }
+        else {
+            console.error(pc.red(`\n✖ ${msg}\n`));
+        }
+        process.exitCode = 1;
+        return null;
+    }
+}
+export async function runWorktreeList(targetDirArg, options = {}) {
+    const rootDir = resolveProjectRoot(targetDirArg);
+    if (!isGitRepo(rootDir)) {
+        if (options.json) {
+            console.log(JSON.stringify({ success: false, error: 'Not a git repository' }, null, 2));
+        }
+        else {
+            console.error(pc.red(`\n✖ Not a git repository: ${rootDir}\n`));
+        }
+        process.exitCode = 1;
+        return [];
+    }
+    try {
+        const raw = execSync('git worktree list --porcelain', { cwd: rootDir, encoding: 'utf8' });
+        const worktrees = [];
+        const blocks = raw.trim().split('\n\n');
+        for (const block of blocks) {
+            const lines = block.split('\n');
+            let wtPath = '';
+            let head = '';
+            let branch = '';
+            for (const line of lines) {
+                if (line.startsWith('worktree '))
+                    wtPath = line.substring(9).trim();
+                else if (line.startsWith('HEAD '))
+                    head = line.substring(5).trim();
+                else if (line.startsWith('branch '))
+                    branch = line.substring(7).trim().replace('refs/heads/', '');
+            }
+            if (wtPath) {
+                const isAgent = wtPath.includes('.worktrees') || branch.startsWith('agent/task-');
+                const match = branch.match(/^agent\/task-(.+)$/);
+                worktrees.push({
+                    path: wtPath,
+                    head,
+                    branch: branch || 'detached',
+                    isAgentWorktree: isAgent,
+                    taskId: match ? match[1] : undefined,
+                });
+            }
+        }
+        if (options.json) {
+            console.log(JSON.stringify(worktrees, null, 2));
+            return worktrees;
+        }
+        console.log(pc.bold(pc.cyan('\n🌿 Active Git Worktrees:')));
+        worktrees.forEach((wt, index) => {
+            if (wt.isAgentWorktree) {
+                console.log(pc.green(`  ▶ [${wt.taskId || 'agent'}] `) + pc.white(wt.branch) + pc.dim(` (${wt.path})`));
+            }
+            else {
+                // git always lists the main worktree first; any other non-agent entry was added outside nativ.
+                console.log(pc.dim(`  • [${index === 0 ? 'main' : 'linked'}] `) + pc.white(wt.branch) + pc.dim(` (${wt.path})`));
+            }
+        });
+        console.log();
+        return worktrees;
+    }
+    catch (err) {
+        if (options.json) {
+            console.log(JSON.stringify({ success: false, error: err.message }, null, 2));
+        }
+        else {
+            console.error(pc.red(`\n✖ Failed to list worktrees: ${err.message}\n`));
+        }
+        process.exitCode = 1;
+        return [];
+    }
+}
+export async function runWorktreeMerge(taskId, targetDirArg, options = {}) {
+    const rootDir = resolveProjectRoot(targetDirArg);
+    if (!isGitRepo(rootDir)) {
+        const msg = `Not a git repository: ${rootDir}`;
+        if (options.json) {
+            console.log(JSON.stringify({ success: false, error: msg }, null, 2));
+        }
+        else {
+            console.error(pc.red(`\n✖ ${msg}\n`));
+        }
+        process.exitCode = 1;
+        return null;
+    }
+    // ─── Safe Merge Gatekeeper ─────────────────────────────────────────────────
+    if (!options.force) {
+        // Check 1: Verify task status in master_plan.json
+        const plan = loadPlan(rootDir);
+        if (plan) {
+            let foundTask = null;
+            for (const m of plan.milestones) {
+                const t = m.tasks.find((task) => task.id === taskId);
+                if (t) {
+                    foundTask = t;
+                    break;
+                }
+            }
+            if (foundTask && foundTask.status !== 'completed') {
+                const msg = `[GATEKEEPER REJECTED] Task '${taskId}' has status '${foundTask.status}'. Only tasks verified and marked 'completed' may be merged. (Use --force to override)`;
+                if (options.json) {
+                    console.log(JSON.stringify({ success: false, error: msg, status: foundTask.status }, null, 2));
+                }
+                else {
+                    console.error(pc.red(`\n✖ ${msg}`));
+                    console.log(pc.yellow(`Complete task verification first with:\n  nativ task complete ${taskId}\n`));
+                }
+                process.exitCode = 1;
+                return null;
+            }
+        }
+        // Check 2: Verify Governor Circuit Breaker is not tripped
+        const breaker = CircuitBreaker.getStatus(rootDir, taskId);
+        if (breaker.tripped) {
+            const msg = `[GATEKEEPER REJECTED] Task '${taskId}' has a tripped Circuit Breaker in the Contract Governor. Active escalation must be resolved before merging.`;
+            if (options.json) {
+                console.log(JSON.stringify({ success: false, error: msg, circuitBreaker: breaker }, null, 2));
+            }
+            else {
+                console.error(pc.red(`\n✖ ${msg}\n`));
+            }
+            process.exitCode = 1;
+            return null;
+        }
+    }
+    else if (!options.json) {
+        console.log(pc.yellow(`⚠ Safe Merge Gatekeeper bypassed via --force.`));
+    }
+    const worktreeDir = path.join(rootDir, '.worktrees', `task-${taskId}`);
+    const branchName = `agent/task-${taskId}`;
+    try {
+        if (!options.json) {
+            console.log(pc.cyan(`\n🔀 Merging worktree for Task [${taskId}]...`));
+        }
+        // Commits any uncommitted agent work, merges, and only then removes the worktree and branch.
+        const outcome = mergeAgentWorktree(rootDir, taskId);
+        if (!options.json) {
+            if (outcome.committedPendingWork) {
+                console.log(pc.yellow(`  ✔ Committed uncommitted agent work on ${branchName} before merging (${outcome.pendingCommit?.slice(0, 7)})`));
+            }
+            console.log(pc.green(`  ✔ Merged branch ${pc.bold(branchName)} into current branch`));
+            console.log(outcome.cleanedUp ? pc.dim(`  ✔ Removed ${worktreeDir} and branch ${branchName}`) : pc.yellow(`  ⚠ ${outcome.message}`));
+        }
+        const result = {
+            success: true,
+            taskId,
+            branch: branchName,
+            merged: true,
+            committedPendingWork: outcome.committedPendingWork,
+            message: outcome.cleanedUp ? `Task [${taskId}] worktree cleanly merged` : outcome.message,
+        };
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.log(pc.bold(pc.green(`\n✔ Task [${taskId}] worktree cleanly merged!\n`)));
+        }
+        return result;
+    }
+    catch (err) {
+        const msg = `Failed to merge worktree: ${err.message}`;
+        const workPreserved = err instanceof WorktreeMergeError ? err.workPreserved : undefined;
+        if (options.json) {
+            console.log(JSON.stringify({ success: false, error: msg, ...(workPreserved !== undefined ? { workPreserved } : {}) }, null, 2));
+        }
+        else {
+            console.error(pc.red(`\n✖ ${msg}\n`));
+        }
+        process.exitCode = 1;
+        return null;
+    }
+}
+export async function runWorktreeRemove(taskId, targetDirArg, options = {}) {
+    const rootDir = resolveProjectRoot(targetDirArg);
+    if (!isGitRepo(rootDir)) {
+        const msg = `Not a git repository: ${rootDir}`;
+        if (options.json) {
+            console.log(JSON.stringify({ success: false, error: msg }, null, 2));
+        }
+        else {
+            console.error(pc.red(`\n✖ ${msg}\n`));
+        }
+        process.exitCode = 1;
+        return null;
+    }
+    const worktreeDir = path.join(rootDir, '.worktrees', `task-${taskId}`);
+    const branchName = `agent/task-${taskId}`;
+    try {
+        if (!options.json) {
+            console.log(pc.yellow(`\n🗑 Cleaning up worktree for Task [${taskId}] without merging...`));
+        }
+        if (fs.existsSync(worktreeDir)) {
+            safeUnlinkWorktreeNodeModules(worktreeDir);
+            safeUnlinkWorktreeAiDirectory(worktreeDir);
+            try {
+                execSync(`git worktree remove "${worktreeDir}" --force`, { cwd: rootDir, stdio: options.json ? 'pipe' : 'inherit' });
+            }
+            catch { }
+            try {
+                execSync('git worktree prune', { cwd: rootDir, stdio: 'ignore' });
+            }
+            catch { }
+            if (fs.existsSync(worktreeDir)) {
+                try {
+                    fs.rmSync(worktreeDir, { recursive: true, force: true });
+                }
+                catch { }
+            }
+            if (!options.json) {
+                console.log(pc.dim(`  ✔ Removed worktree directory: ${worktreeDir}`));
+            }
+        }
+        // Delete branch
+        try {
+            execSync(`git branch -D "${branchName}"`, { cwd: rootDir, stdio: 'ignore' });
+            if (!options.json) {
+                console.log(pc.dim(`  ✔ Discarded branch ${branchName}`));
+            }
+        }
+        catch {
+            // Ignore if branch doesn't exist
+        }
+        const result = {
+            success: true,
+            taskId,
+            branch: branchName,
+            removed: true,
+            message: `Worktree for Task [${taskId}] removed`,
+        };
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.log(pc.green(`\n✔ Worktree for Task [${taskId}] successfully removed.\n`));
+        }
+        return result;
+    }
+    catch (err) {
+        const msg = `Failed to remove worktree: ${err.message}`;
+        if (options.json) {
+            console.log(JSON.stringify({ success: false, error: msg }, null, 2));
+        }
+        else {
+            console.error(pc.red(`\n✖ ${msg}\n`));
+        }
+        process.exitCode = 1;
+        return null;
+    }
+}

package/dist/core/benchmark.d.ts

@@ -0,0 +1,57 @@
+export interface BenchmarkScenarioResult {
+    id: string;
+    name: string;
+    description: string;
+    status: 'passed' | 'failed';
+    durationMs: number;
+    operations: number;
+    throughputOpsPerSec: number;
+    assertionsPassed: number;
+    assertionsFailed: number;
+    details: Record<string, any>;
+    errors?: string[];
+}
+export interface BenchmarkSummary {
+    totalScenarios: number;
+    passedScenarios: number;
+    failedScenarios: number;
+    score: number;
+    totalDurationMs: number;
+    totalOperations: number;
+    averageThroughputOpsPerSec: number;
+}
+export interface BenchmarkReport {
+    version: string;
+    timestamp: string;
+    environment: {
+        platform: string;
+        nodeVersion: string;
+        cpuCount: number;
+        arch: string;
+    };
+    summary: BenchmarkSummary;
+    scenarios: BenchmarkScenarioResult[];
+}
+export interface BenchmarkOptions {
+    scenario?: string;
+    concurrency?: number;
+    output?: string;
+    json?: boolean;
+    verbose?: boolean;
+}
+/**
+ * Creates an isolated scratch workspace for benchmarking with valid .ai/ contracts.
+ */
+export declare function createBenchmarkSandbox(): string;
+/**
+ * Resilient sandbox cleanup handling Windows NTFS delayed locks.
+ */
+export declare function cleanupSandbox(dir: string): void;
+/**
+ * Main benchmark execution coordinator.
+ */
+export declare function runBenchmarks(options?: BenchmarkOptions): Promise<BenchmarkReport>;
+/**
+ * Formats the benchmark report for high-readability CLI output.
+ */
+export declare function formatBenchmarkReport(report: BenchmarkReport): string;