@praneeth_54/agentdoctor 2.0.0 → 2.1.0

package/dist/cli/commands/chat.js

@@ -0,0 +1,155 @@
+import readline from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { ChatService, CHAT_PROVIDER_NONE_MESSAGE, formatChatResponseForCli, } from "../../agent/chat/index.js";
+import { MockModelProvider, createModelProvider, loadAiConfig } from "../../ai/index.js";
+import { EXIT_CODES } from "../../types/index.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+import { colors } from "../../utils/colors.js";
+function printBanner(options) {
+    const lines = [
+        "",
+        colors.bold("AgentDoctor Project Chat"),
+        "",
+        `Project:`,
+        `  ${options.name}`,
+        `  ${options.root}`,
+        "",
+        `Detected:`,
+        `  ${(options.languages.length ? options.languages : ["(none)"]).join(", ")}`,
+        `  frameworks: ${(options.frameworks.length ? options.frameworks : ["(none)"]).join(", ")}`,
+        "",
+        `AI:`,
+        `  ${options.providerLabel}`,
+        "",
+        "Ask questions about your project.",
+        "",
+        "Commands:",
+        "  /help     Show help",
+        "  /project  Project summary",
+        "  /context  Context used for last answer",
+        "  /clear    Clear conversation memory",
+        "  /exit     Leave chat",
+        "",
+        "Milestone 2 does not edit files or run commands.",
+        "",
+    ];
+    process.stdout.write(`${lines.join("\n")}\n`);
+}
+function printHelp() {
+    process.stdout.write([
+        "",
+        "Ask natural-language questions about this repository.",
+        "Answers use project evidence (Brain/graph/context) when available.",
+        "",
+        "Truth labels: VERIFIED | INFERRED | UNKNOWN | EXTERNAL",
+        "",
+        "Examples:",
+        "  Explain my project.",
+        "  How does authentication work?",
+        "  Explain this like I'm a beginner.",
+        "",
+    ].join("\n"));
+}
+export async function runAskCommand(options) {
+    const root = resolveRepoRoot(options.root ?? process.cwd());
+    const provider = options.useMock ? new MockModelProvider() : createModelProvider(loadAiConfig());
+    const chat = new ChatService({
+        root,
+        provider,
+        persistAudit: !options.useMock,
+    });
+    try {
+        const response = await chat.ask(options.question);
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify(response, null, 2)}\n`);
+        }
+        else {
+            process.stdout.write(formatChatResponseForCli(response));
+        }
+        if (response.status === "provider-none")
+            return EXIT_CODES.USAGE_ERROR;
+        if (response.status === "provider-error" || response.status === "failed") {
+            return EXIT_CODES.INTERNAL_ERROR;
+        }
+        return EXIT_CODES.SUCCESS;
+    }
+    finally {
+        await chat.end();
+    }
+}
+export async function runChatCommand(options) {
+    const root = resolveRepoRoot(options.root ?? process.cwd());
+    const provider = options.useMock ? new MockModelProvider() : createModelProvider(loadAiConfig());
+    const chat = new ChatService({
+        root,
+        provider,
+        persistAudit: !options.useMock,
+    });
+    const started = await chat.start();
+    printBanner({
+        root: started.summary.root,
+        name: started.summary.name,
+        providerLabel: started.providerLabel,
+        languages: started.summary.languages,
+        frameworks: started.summary.frameworks,
+    });
+    if (provider.id === "none" && !options.useMock) {
+        process.stdout.write(`${CHAT_PROVIDER_NONE_MESSAGE}\n`);
+        await chat.end();
+        return EXIT_CODES.USAGE_ERROR;
+    }
+    const scripted = options.scriptedInputs ? [...options.scriptedInputs] : undefined;
+    const rl = scripted === undefined
+        ? readline.createInterface({ input, output, terminal: Boolean(output.isTTY) })
+        : undefined;
+    const readLine = async () => {
+        if (scripted) {
+            if (scripted.length === 0)
+                return null;
+            return scripted.shift() ?? null;
+        }
+        const answer = await rl.question("You:\n> ");
+        return answer;
+    };
+    try {
+        while (true) {
+            const raw = await readLine();
+            if (raw === null)
+                break;
+            const line = raw.trim();
+            if (!line)
+                continue;
+            if (line === "/exit" || line === "exit" || line === "quit") {
+                process.stdout.write("Goodbye.\n");
+                break;
+            }
+            if (line === "/help" || line === "help") {
+                printHelp();
+                continue;
+            }
+            if (line === "/project") {
+                process.stdout.write(await chat.formatProject());
+                continue;
+            }
+            if (line === "/context") {
+                process.stdout.write(chat.formatContext());
+                continue;
+            }
+            if (line === "/clear") {
+                chat.clearMemory();
+                process.stdout.write("Conversation memory cleared.\n");
+                continue;
+            }
+            const response = await chat.ask(line);
+            process.stdout.write(chat.formatResponse(response));
+            if (response.status === "provider-error") {
+                // stay in loop; user may fix provider elsewhere
+            }
+        }
+        return EXIT_CODES.SUCCESS;
+    }
+    finally {
+        rl?.close();
+        await chat.end();
+    }
+}

package/dist/cli/commands/complete.js

@@ -183,11 +183,11 @@ export async function runV2SurfaceCommand(options) {
                 return EXIT_CODES.SUCCESS;
             }
             case "impact": {
-                const impact = await analyzeTestImpact(root);
+                const impact = await analyzeTestImpact({ root });
                 if (options.json)
                     printJson({ kind: "test-impact", contractsVersion: CONTRACTS_VERSION, impact });
                 else
-                    process.stdout.write(`impact recommendedTests=${impact.recommendedTests.length}\n`);
+                    process.stdout.write(`impact mode=${impact.mode} recommendedTests=${impact.recommendedTests.length}\n`);
                 return EXIT_CODES.SUCCESS;
             }
             case "refactor-impact": {

package/dist/cli/commands/learn.d.ts

@@ -0,0 +1,12 @@
+import { type ExitCode } from "../../types/index.js";
+export declare function runLearnCommand(options: {
+    root?: string;
+    mode?: string;
+    viva?: boolean;
+    docs?: boolean;
+    build?: string;
+    approve?: boolean;
+    applyOpsJson?: string;
+    json?: boolean;
+    useMock?: boolean;
+}): Promise<ExitCode>;

package/dist/cli/commands/learn.js

@@ -0,0 +1,107 @@
+import { MockModelProvider, createModelProvider, loadAiConfig } from "../../ai/index.js";
+import { StudentService } from "../../agent/student.js";
+import { parseAgentMode, defaultStudentMode } from "../../agent/modes.js";
+import { EXIT_CODES } from "../../types/index.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+export async function runLearnCommand(options) {
+    const root = resolveRepoRoot(options.root ?? process.cwd());
+    const mode = parseAgentMode(options.mode) ?? defaultStudentMode();
+    const provider = options.useMock ? new MockModelProvider() : createModelProvider(loadAiConfig());
+    const resolvedMode = options.build
+        ? mode === "LEARN"
+            ? "BUILD_WITH_ME"
+            : mode
+        : options.viva || options.docs
+            ? "LEARN"
+            : mode;
+    const student = new StudentService({
+        root,
+        provider,
+        mode: resolvedMode,
+    });
+    try {
+        if (options.build) {
+            let toolCalls;
+            if (options.applyOpsJson) {
+                try {
+                    const parsed = JSON.parse(options.applyOpsJson);
+                    if (!Array.isArray(parsed))
+                        throw new Error("expected array");
+                    toolCalls = parsed.map((item) => {
+                        const row = item;
+                        if (!row.name || typeof row.name !== "string")
+                            throw new Error("ops need name");
+                        return {
+                            name: row.name,
+                            arguments: row.arguments ?? {},
+                        };
+                    });
+                }
+                catch (error) {
+                    process.stderr.write(`Invalid --apply-ops JSON: ${error instanceof Error ? error.message : String(error)}\n`);
+                    return EXIT_CODES.USAGE_ERROR;
+                }
+            }
+            const result = await student.buildFeature({
+                goal: options.build,
+                approvedByHuman: options.approve === true,
+                ...(toolCalls ? { toolCalls } : {}),
+            });
+            if (options.json) {
+                process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+            }
+            else {
+                process.stdout.write(result.explanation);
+                if (result.status === "awaiting-approval") {
+                    process.stdout.write("\nRe-run with --approve to execute the coding loop.\n");
+                }
+                else if (result.coding) {
+                    process.stdout.write(result.evidenceText);
+                }
+                else {
+                    process.stdout.write(`${result.evidenceText}\n`);
+                }
+            }
+            if (result.status === "awaiting-approval" || result.status === "mode_forbidden") {
+                return EXIT_CODES.USAGE_ERROR;
+            }
+            if (result.status === "failed" || result.status === "limit") {
+                return EXIT_CODES.INTERNAL_ERROR;
+            }
+            return EXIT_CODES.SUCCESS;
+        }
+        if (options.viva) {
+            const questions = await student.generateVivaQuestions();
+            if (options.json)
+                process.stdout.write(`${JSON.stringify({ mode, questions }, null, 2)}\n`);
+            else {
+                process.stdout.write("\nViva questions (grounded in detected stack):\n\n");
+                for (const [i, q] of questions.entries())
+                    process.stdout.write(`  ${i + 1}. ${q}\n`);
+                process.stdout.write("\n");
+            }
+            return EXIT_CODES.SUCCESS;
+        }
+        if (options.docs) {
+            const sections = await student.generateProjectDocumentation();
+            if (options.json)
+                process.stdout.write(`${JSON.stringify({ mode, sections }, null, 2)}\n`);
+            else {
+                for (const s of sections) {
+                    process.stdout.write(`\n[${s.truth}] ${s.title}\n${s.body}\n`);
+                }
+                process.stdout.write("\n");
+            }
+            return EXIT_CODES.SUCCESS;
+        }
+        const explained = await student.explainProject();
+        if (options.json)
+            process.stdout.write(`${JSON.stringify({ mode, ...explained }, null, 2)}\n`);
+        else
+            process.stdout.write(explained.text);
+        return EXIT_CODES.SUCCESS;
+    }
+    finally {
+        await student.end();
+    }
+}

package/dist/cli/commands/platform.d.ts

@@ -12,4 +12,6 @@ export declare function runPlatformCommand(options: {
     actionType?: string;
     sessionId?: string;
     failClosed?: boolean;
+    coverage?: string;
+    since?: string;
 }): Promise<ExitCode>;

package/dist/cli/commands/platform.js

@@ -38,7 +38,11 @@ export async function runPlatformCommand(options) {
                 return EXIT_CODES.SUCCESS;
             }
             case "test-impact": {
-                const report = await analyzeTestImpact(root);
+                const report = await analyzeTestImpact({
+                    root,
+                    ...(options.coverage ? { coveragePath: options.coverage } : {}),
+                    ...(options.since ? { since: options.since } : {}),
+                });
                 const out = await persistTestImpactReport(root, report);
                 if (options.json)
                     printJson({ ...report, reportPath: out });

package/dist/cli/commands/policy-graph-run.d.ts

@@ -0,0 +1,40 @@
+export declare function runGraphSurfaceCommand(options: {
+    action: "build" | "update" | "rebuild" | "status" | "show";
+    root: string;
+    mode?: string;
+    json?: boolean;
+}): Promise<number>;
+export declare function runPolicyCheckCommand(options: {
+    root: string;
+    command: string;
+    json?: boolean;
+    failClosed?: boolean;
+}): Promise<number>;
+export declare function runPolicyExplainCommand(options: {
+    root: string;
+    command: string;
+    json?: boolean;
+    failClosed?: boolean;
+}): Promise<number>;
+export declare function runPolicyEnforceCommand(options: {
+    root: string;
+    command: string;
+    execute?: boolean;
+    json?: boolean;
+    failClosed?: boolean;
+}): Promise<number>;
+export declare function runRunExplainCommand(options: {
+    root: string;
+    command: string;
+    json?: boolean;
+    failClosed?: boolean;
+    shell?: boolean;
+}): Promise<number>;
+export declare function runRunCommand(options: {
+    root: string;
+    argv: string[];
+    shell?: boolean;
+    timeoutMs?: number;
+    json?: boolean;
+    failClosed?: boolean;
+}): Promise<number>;

package/dist/cli/commands/policy-graph-run.js

@@ -0,0 +1,200 @@
+import { evaluateAgentAction, EVALUATE_ONLY } from "../../platform/firewall/evaluate.js";
+import { runControlledCommand } from "../../enforcement/runner.js";
+import { graphBuild, graphRebuild, graphStatus, graphUpdate, } from "../../intelligence/graph/incremental.js";
+import { buildIntelligenceGraph } from "../../intelligence/graph/build.js";
+import { EXIT_CODES } from "../../types/index.js";
+function emit(json, value, human) {
+    if (json) {
+        process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+    }
+    else {
+        process.stdout.write(`${human}\n`);
+    }
+}
+export async function runGraphSurfaceCommand(options) {
+    try {
+        const mode = options.mode ?? "auto";
+        if (options.action === "status") {
+            const status = await graphStatus({ root: options.root });
+            emit(Boolean(options.json), status, [
+                `Graph index ${status.present ? "present" : "missing"}`,
+                `  path: ${status.path}`,
+                `  nodes=${status.nodeCount} edges=${status.edgeCount} files=${status.fileCount}`,
+                `  builder=${status.builder ?? "n/a"}`,
+                `  stale=${status.staleFiles.length} missing=${status.missingFiles.length}`,
+                status.corrupt ? `  corrupt: ${status.error}` : "",
+            ]
+                .filter(Boolean)
+                .join("\n"));
+            return EXIT_CODES.SUCCESS;
+        }
+        if (options.action === "update") {
+            const result = await graphUpdate({ root: options.root, mode });
+            emit(Boolean(options.json), result, `graph update rebuilt=${result.rebuilt} reason=${result.reason} changed=${result.changedFiles.length} nodes=${result.snapshot.nodes.length}`);
+            return EXIT_CODES.SUCCESS;
+        }
+        if (options.action === "rebuild") {
+            const result = await graphRebuild({ root: options.root, mode });
+            emit(Boolean(options.json), result, `graph rebuild nodes=${result.snapshot.nodes.length} edges=${result.snapshot.edges.length} builder=${result.snapshot.builder}`);
+            return EXIT_CODES.SUCCESS;
+        }
+        // build / show (backward-compat one-shot)
+        if (options.action === "show") {
+            const graph = await buildIntelligenceGraph({ root: options.root, mode });
+            emit(Boolean(options.json), graph, `graph builder=${graph.builder} nodes=${graph.nodes.length} edges=${graph.edges.length} astFiles=${graph.astFilesParsed}`);
+            return EXIT_CODES.SUCCESS;
+        }
+        const result = await graphBuild({ root: options.root, mode });
+        emit(Boolean(options.json), result, `graph build nodes=${result.snapshot.nodes.length} edges=${result.snapshot.edges.length} builder=${result.snapshot.builder} path=${result.path}`);
+        return EXIT_CODES.SUCCESS;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`Error: ${message}\n`);
+        return EXIT_CODES.INTERNAL_ERROR;
+    }
+}
+export async function runPolicyCheckCommand(options) {
+    try {
+        const verdict = await evaluateAgentAction(options.root, {
+            actionId: `policy-check-${Date.now()}`,
+            agentId: "cli",
+            timestamp: new Date().toISOString(),
+            type: "shell",
+            params: { command: options.command },
+            repositoryRoot: options.root,
+        }, { failClosed: options.failClosed === true });
+        emit(Boolean(options.json), { ...verdict, notice: EVALUATE_ONLY }, `policy check decision=${verdict.decision} risk=${verdict.riskLevel}\n  ${verdict.reason}\n  ${EVALUATE_ONLY}`);
+        return EXIT_CODES.SUCCESS;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`Error: ${message}\n`);
+        return EXIT_CODES.INTERNAL_ERROR;
+    }
+}
+export async function runPolicyExplainCommand(options) {
+    try {
+        const verdict = await evaluateAgentAction(options.root, {
+            actionId: `policy-explain-${Date.now()}`,
+            agentId: "cli",
+            timestamp: new Date().toISOString(),
+            type: "shell",
+            params: { command: options.command },
+            repositoryRoot: options.root,
+        }, { failClosed: options.failClosed === true });
+        const explanation = {
+            command: options.command,
+            decision: verdict.decision,
+            reason: verdict.reason,
+            policyId: verdict.policyId ?? null,
+            riskLevel: verdict.riskLevel,
+            approvalStatus: verdict.approvalStatus,
+            executionResult: verdict.executionResult,
+            notice: EVALUATE_ONLY,
+            meaning: verdict.decision === "allow"
+                ? "Allowlisted or matched an allow rule — still evaluate-only unless agentdoctor run / enforce --execute is used."
+                : verdict.decision === "block" || verdict.decision === "deny-network"
+                    ? "Would be blocked by AgentDoctor-controlled runner if executed through it."
+                    : "Requires human approval or further policy before controlled execution.",
+        };
+        emit(Boolean(options.json), explanation, [
+            `policy explain: ${options.command}`,
+            `  decision: ${verdict.decision}`,
+            `  policyId: ${verdict.policyId ?? "n/a"}`,
+            `  risk: ${verdict.riskLevel}`,
+            `  reason: ${verdict.reason}`,
+            `  ${explanation.meaning}`,
+        ].join("\n"));
+        return EXIT_CODES.SUCCESS;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`Error: ${message}\n`);
+        return EXIT_CODES.INTERNAL_ERROR;
+    }
+}
+export async function runPolicyEnforceCommand(options) {
+    try {
+        const result = await runControlledCommand({
+            root: options.root,
+            command: options.command,
+            executeIfAllowed: options.execute === true,
+            failClosed: options.failClosed === true,
+        });
+        emit(Boolean(options.json), result, [
+            `policy enforce decision=${result.decision.decision} status=${result.decision.executionStatus}`,
+            `  enforced=${result.enforced}`,
+            `  ${result.notice}`,
+        ].join("\n"));
+        return EXIT_CODES.SUCCESS;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`Error: ${message}\n`);
+        return EXIT_CODES.INTERNAL_ERROR;
+    }
+}
+export async function runRunExplainCommand(options) {
+    try {
+        const { explainControlledRun } = await import("../../enforcement/runner.js");
+        const explanation = await explainControlledRun({
+            root: options.root,
+            command: options.command,
+            failClosed: options.failClosed === true,
+            useShell: options.shell === true,
+        });
+        emit(Boolean(options.json), explanation, [
+            `run explain: ${explanation.command}`,
+            `  decision: ${explanation.decision}`,
+            `  policyId: ${explanation.policyId ?? "n/a"}`,
+            `  risk: ${explanation.riskLevel}`,
+            `  wouldExecute: ${explanation.wouldExecute}`,
+            `  ${explanation.meaning}`,
+            `  ${explanation.notice}`,
+        ].join("\n"));
+        return EXIT_CODES.SUCCESS;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`Error: ${message}\n`);
+        return EXIT_CODES.INTERNAL_ERROR;
+    }
+}
+export async function runRunCommand(options) {
+    try {
+        if (!options.argv.length) {
+            process.stderr.write("Error: provide a command after -- (e.g. agentdoctor run -- npm --version)\n");
+            return EXIT_CODES.USAGE_ERROR;
+        }
+        const result = await runControlledCommand({
+            root: options.root,
+            argv: options.argv,
+            executeIfAllowed: true,
+            useShell: options.shell === true,
+            ...(options.timeoutMs !== undefined ? { timeoutMs: options.timeoutMs } : {}),
+            failClosed: options.failClosed === true,
+        });
+        emit(Boolean(options.json), result, [
+            `run decision=${result.decision.decision} status=${result.decision.executionStatus}`,
+            `  exitCode=${result.exitCode ?? "n/a"} durationMs=${result.durationMs ?? "n/a"}`,
+            `  ${result.notice}`,
+            result.stdout ? `--- stdout ---\n${result.stdout}` : "",
+            result.stderr ? `--- stderr ---\n${result.stderr}` : "",
+        ]
+            .filter(Boolean)
+            .join("\n"));
+        if (result.decision.executionStatus === "blocked-by-enforcement") {
+            return EXIT_CODES.ISSUES_OR_THRESHOLD;
+        }
+        if (result.decision.executionStatus === "execution-failed") {
+            return EXIT_CODES.INTERNAL_ERROR;
+        }
+        return EXIT_CODES.SUCCESS;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`Error: ${message}\n`);
+        return EXIT_CODES.INTERNAL_ERROR;
+    }
+}

package/dist/cli/commands/workspace.d.ts

@@ -0,0 +1,9 @@
+export declare function runWorkspaceCommand(options: {
+    action: "init" | "add" | "list" | "status" | "remove";
+    root: string;
+    name?: string;
+    id?: string;
+    repositoryRoot?: string;
+    allowCrossRead?: boolean;
+    json?: boolean;
+}): Promise<number>;

package/dist/cli/commands/workspace.js

@@ -0,0 +1,82 @@
+import { EXIT_CODES } from "../../types/index.js";
+import { addRepositoryToWorkspace, initWorkspace, listWorkspaces, removeWorkspace, workspaceStatus, } from "../../workspace/index.js";
+function emit(json, value, human) {
+    if (json) {
+        process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+    }
+    else {
+        process.stdout.write(`${human}\n`);
+    }
+}
+export async function runWorkspaceCommand(options) {
+    try {
+        const controlRoot = options.root;
+        switch (options.action) {
+            case "init": {
+                if (!options.name?.trim()) {
+                    process.stderr.write("Error: workspace init requires --name\n");
+                    return EXIT_CODES.USAGE_ERROR;
+                }
+                const ws = await initWorkspace({
+                    controlRoot,
+                    name: options.name,
+                    ...(options.id ? { id: options.id } : {}),
+                    ...(options.repositoryRoot ? { repositoryRoot: options.repositoryRoot } : {}),
+                    allowCrossRead: options.allowCrossRead === true,
+                });
+                emit(Boolean(options.json), ws, `workspace init id=${ws.id} name=${ws.name} roots=${ws.repositoryRoots.length} allowCrossRead=${ws.allowCrossRead}`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "add": {
+                if (!options.id?.trim() || !options.repositoryRoot?.trim()) {
+                    process.stderr.write("Error: workspace add requires --id and --repo\n");
+                    return EXIT_CODES.USAGE_ERROR;
+                }
+                const ws = await addRepositoryToWorkspace({
+                    controlRoot,
+                    workspaceId: options.id,
+                    repositoryRoot: options.repositoryRoot,
+                });
+                emit(Boolean(options.json), ws, `workspace add id=${ws.id} roots=${ws.repositoryRoots.join(", ")}`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "list": {
+                const list = await listWorkspaces(controlRoot);
+                emit(Boolean(options.json), { workspaces: list }, list.length === 0
+                    ? "No workspaces under .agentdoctor/workspaces/"
+                    : list
+                        .map((w) => `${w.id}\t${w.name}\troots=${w.repositoryRoots.length}\tcrossRead=${w.allowCrossRead}`)
+                        .join("\n"));
+                return EXIT_CODES.SUCCESS;
+            }
+            case "status": {
+                if (!options.id?.trim()) {
+                    process.stderr.write("Error: workspace status requires --id\n");
+                    return EXIT_CODES.USAGE_ERROR;
+                }
+                const status = await workspaceStatus(controlRoot, options.id);
+                emit(Boolean(options.json), status, status.ok
+                    ? `workspace ${options.id} ok roots=${status.workspace?.repositoryRoots.length ?? 0}`
+                    : `workspace ${options.id} ${status.error ?? "degraded"} missing=${status.missingRoots.join(", ") || "none"}`);
+                return status.ok ? EXIT_CODES.SUCCESS : EXIT_CODES.ISSUES_OR_THRESHOLD;
+            }
+            case "remove": {
+                if (!options.id?.trim()) {
+                    process.stderr.write("Error: workspace remove requires --id\n");
+                    return EXIT_CODES.USAGE_ERROR;
+                }
+                const removed = await removeWorkspace(controlRoot, options.id);
+                emit(Boolean(options.json), { removed, id: options.id }, removed ? `workspace removed ${options.id}` : `workspace not found ${options.id}`);
+                return removed ? EXIT_CODES.SUCCESS : EXIT_CODES.ISSUES_OR_THRESHOLD;
+            }
+            default:
+                process.stderr.write("Error: unknown workspace action\n");
+                return EXIT_CODES.USAGE_ERROR;
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`Error: ${message}\n`);
+        return EXIT_CODES.INTERNAL_ERROR;
+    }
+}