@praneeth_54/agentdoctor 2.0.0 → 2.1.0

package/dist/auth/rbac.js

@@ -0,0 +1,26 @@
+/**
+ * Role-based access control for AgentDoctor surfaces.
+ * Not enterprise SSO — roles are applied after a verified identity (local session or OIDC JWT).
+ */
+export const RBAC_ROLE_RANK = {
+    viewer: 1,
+    developer: 2,
+    reviewer: 3,
+    "policy-admin": 4,
+    admin: 5,
+};
+const PERMISSION_MIN_ROLE = {
+    "read-findings": "viewer",
+    "read-audit": "viewer",
+    "export-reports": "developer",
+    "approve-actions": "reviewer",
+    "manage-policies": "policy-admin",
+    "admin-settings": "admin",
+};
+export function hasRbacPermission(role, permission) {
+    const required = PERMISSION_MIN_ROLE[permission];
+    return (RBAC_ROLE_RANK[role] ?? 0) >= (RBAC_ROLE_RANK[required] ?? 99);
+}
+export function roleAtLeast(role, required) {
+    return (RBAC_ROLE_RANK[role] ?? 0) >= (RBAC_ROLE_RANK[required] ?? 99);
+}

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

@@ -0,0 +1,27 @@
+import { type ExitCode } from "../../types/index.js";
+/**
+ * agentdoctor plan — produce an implementation plan (no writes unless --apply elsewhere).
+ */
+export declare function runPlanCommand(options: {
+    goal: string;
+    root?: string;
+    json?: boolean;
+    approve?: boolean;
+}): Promise<ExitCode>;
+/**
+ * agentdoctor agent — inspect, plan, and (with --approve) mutate via controlled tools.
+ */
+export declare function runAgentCommand(options: {
+    root?: string;
+    goal?: string;
+    tool?: string;
+    toolArgs?: Record<string, unknown>;
+    listTools?: boolean;
+    json?: boolean;
+    approve?: boolean;
+    apply?: boolean;
+    /** JSON array of {name, arguments} for deterministic apply */
+    applyOpsJson?: string;
+    verify?: boolean;
+    runTests?: boolean;
+}): Promise<ExitCode>;

package/dist/cli/commands/agent.js

@@ -0,0 +1,153 @@
+import { approvePlan, buildAgentPlan, formatAgentPlan } from "../../agent/plan.js";
+import { evaluateApproval, formatApprovalPrompt } from "../../agent/approvals.js";
+import { runCodingLoop } from "../../agent/loop.js";
+import { executeAgentTool, getToolSpec, listAgentToolSpecs, newToolCall, } from "../../agent/tools/index.js";
+import { EXIT_CODES } from "../../types/index.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+import { colors } from "../../utils/colors.js";
+/**
+ * agentdoctor plan — produce an implementation plan (no writes unless --apply elsewhere).
+ */
+export async function runPlanCommand(options) {
+    const root = resolveRepoRoot(options.root ?? process.cwd());
+    const plan = await buildAgentPlan({ root, goal: options.goal });
+    if (options.approve) {
+        const approved = approvePlan(plan, true);
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify({ ...approved, note: "Approval recorded; use agent --apply to mutate" }, null, 2)}\n`);
+        }
+        else {
+            process.stdout.write(formatAgentPlan(approved));
+            process.stdout.write(`${colors.yellow('\nApproval recorded. Use: agentdoctor agent --goal "..." --approve --apply\n')}\n`);
+        }
+        return EXIT_CODES.SUCCESS;
+    }
+    if (options.json) {
+        process.stdout.write(`${JSON.stringify(plan, null, 2)}\n`);
+    }
+    else {
+        process.stdout.write(formatAgentPlan(plan));
+    }
+    return EXIT_CODES.SUCCESS;
+}
+/**
+ * agentdoctor agent — inspect, plan, and (with --approve) mutate via controlled tools.
+ */
+export async function runAgentCommand(options) {
+    const root = resolveRepoRoot(options.root ?? process.cwd());
+    const approvedByHuman = options.approve === true;
+    if (options.listTools) {
+        const tools = listAgentToolSpecs({ includeWrite: true, includeExecute: true });
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify(tools, null, 2)}\n`);
+        }
+        else {
+            process.stdout.write(`\n${colors.bold("AgentDoctor tools")}\n\n`);
+            for (const t of tools) {
+                process.stdout.write(`  [${t.risk}] ${t.name} (${t.category}) — ${t.description}\n`);
+            }
+            process.stdout.write("\n");
+        }
+        return EXIT_CODES.SUCCESS;
+    }
+    if (options.tool) {
+        const name = options.tool;
+        const spec = getToolSpec(name);
+        if (!spec) {
+            process.stderr.write(`Unknown tool: ${name}\n`);
+            return EXIT_CODES.USAGE_ERROR;
+        }
+        const approval = evaluateApproval({ action: `tool:${name}`, risk: spec.risk, toolName: name }, { approvedByHuman });
+        if (approval.needsHumanApproval) {
+            process.stderr.write(formatApprovalPrompt({ action: `tool:${name}`, risk: approval.risk, toolName: name }, approval));
+            process.stderr.write("Re-run with --approve for write/execute tools.\n");
+            return EXIT_CODES.USAGE_ERROR;
+        }
+        const call = newToolCall("cli-agent", name, options.toolArgs ?? {});
+        const result = await executeAgentTool(root, call, {
+            allowWrite: approvedByHuman,
+            allowExecute: approvedByHuman,
+            approvedByHuman,
+        });
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+        }
+        else if (result.ok) {
+            process.stdout.write(`${JSON.stringify(result.data, null, 2)}\n`);
+        }
+        else {
+            process.stderr.write(`Tool failed: ${result.error?.code} — ${result.error?.message}\n`);
+            return EXIT_CODES.INTERNAL_ERROR;
+        }
+        return EXIT_CODES.SUCCESS;
+    }
+    if (options.goal && options.apply) {
+        if (!approvedByHuman) {
+            process.stderr.write("Refusing --apply without --approve (human approval required).\n");
+            return EXIT_CODES.USAGE_ERROR;
+        }
+        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 runCodingLoop({
+            root,
+            goal: options.goal,
+            approvedByHuman: true,
+            ...(toolCalls ? { toolCalls } : {}),
+            verify: options.verify !== false,
+            runTests: options.runTests === true,
+        });
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+        }
+        else {
+            process.stdout.write(result.responseText);
+        }
+        if (result.stoppedReason === "awaiting-approval")
+            return EXIT_CODES.USAGE_ERROR;
+        if (result.stoppedReason === "failed" || result.stoppedReason === "limit") {
+            return EXIT_CODES.INTERNAL_ERROR;
+        }
+        return EXIT_CODES.SUCCESS;
+    }
+    if (options.goal) {
+        return runPlanCommand({
+            goal: options.goal,
+            root,
+            ...(options.json !== undefined ? { json: options.json } : {}),
+            ...(approvedByHuman ? { approve: true } : {}),
+        });
+    }
+    process.stderr.write([
+        "",
+        "AgentDoctor agent (Milestone 4)",
+        "",
+        "Usage:",
+        "  agentdoctor agent --list-tools",
+        "  agentdoctor agent --tool inspect_project [path]",
+        '  agentdoctor plan "Add registration" [path]',
+        "  agentdoctor agent --goal \"Add registration\" --approve --apply --apply-ops '[...]' [path]",
+        "",
+        "Writes require --approve. Unrestricted shell is never exposed.",
+        "",
+    ].join("\n"));
+    return EXIT_CODES.USAGE_ERROR;
+}

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

@@ -0,0 +1,6 @@
+import { type ExitCode } from "../../types/index.js";
+export declare function runArchitectureCommand(options: {
+    action: "init" | "analyze" | "check" | "explain";
+    root?: string;
+    json?: boolean;
+}): Promise<ExitCode>;

package/dist/cli/commands/architecture.js

@@ -0,0 +1,109 @@
+import { EXIT_CODES } from "../../types/index.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+import { buildIntelligenceGraph } from "../../intelligence/graph/build.js";
+import { buildC4Views } from "../../architecture/c4.js";
+import { checkArchitectureAtRoot, explainArchitecture, initArchitecture, loadArchitectureContract, } from "../../architecture/contract.js";
+function printJson(value) {
+    process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+export async function runArchitectureCommand(options) {
+    const root = resolveRepoRoot(options.root ?? process.cwd());
+    try {
+        switch (options.action) {
+            case "init": {
+                const written = await initArchitecture(root);
+                if (options.json)
+                    printJson({ path: written, createdOrExisting: true });
+                else
+                    process.stdout.write(`Architecture contract at ${written}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "analyze": {
+                const graph = await buildIntelligenceGraph({ root, mode: "auto" });
+                const views = buildC4Views(graph);
+                const loaded = await loadArchitectureContract(root);
+                const check = await checkArchitectureAtRoot(root, graph);
+                const payload = {
+                    c4: {
+                        levels: views.map((v) => v.level),
+                        views,
+                        label: "Inferred/proposed from graph evidence — not approved architecture facts",
+                    },
+                    contract: loaded
+                        ? {
+                            path: loaded.path,
+                            version: loaded.contract.version,
+                            layerCount: loaded.contract.layers.length,
+                            forbiddenCount: loaded.contract.forbidden.length,
+                            allowedCount: loaded.contract.allowed.length,
+                        }
+                        : null,
+                    check: {
+                        violations: check.violations.length,
+                        importEdgesChecked: check.importEdgesChecked,
+                        limitations: check.limitations,
+                    },
+                };
+                if (options.json)
+                    printJson(payload);
+                else {
+                    process.stdout.write([
+                        "AgentDoctor architecture analyze",
+                        `  C4 views: ${views.map((v) => v.level).join(", ")} (inferred)`,
+                        loaded
+                            ? `  contract: ${loaded.path} (layers=${loaded.contract.layers.length}, forbidden=${loaded.contract.forbidden.length})`
+                            : "  contract: none (run architecture init)",
+                        `  check violations: ${check.violations.length} (edges=${check.importEdgesChecked})`,
+                    ].join("\n") + "\n");
+                }
+                return EXIT_CODES.SUCCESS;
+            }
+            case "check": {
+                const graph = await buildIntelligenceGraph({ root, mode: "auto" });
+                const check = await checkArchitectureAtRoot(root, graph);
+                if (options.json)
+                    printJson(check);
+                else {
+                    process.stdout.write([
+                        "AgentDoctor architecture check",
+                        `  contract: ${check.contractPath ?? "none"}`,
+                        `  import edges checked: ${check.importEdgesChecked}`,
+                        `  violations: ${check.violations.length}`,
+                        ...check.violations
+                            .slice(0, 30)
+                            .map((v) => `    - [${v.kind}] ${v.ruleId}: ${v.fromPath} → ${v.toPath} (${v.fromLayer}→${v.toLayer})`),
+                        ...check.limitations.map((l) => `  limitation: ${l}`),
+                    ].join("\n") + "\n");
+                }
+                if (check.violations.some((v) => v.kind === "forbidden")) {
+                    return EXIT_CODES.ISSUES_OR_THRESHOLD;
+                }
+                return EXIT_CODES.SUCCESS;
+            }
+            case "explain": {
+                const loaded = await loadArchitectureContract(root);
+                const graph = await buildIntelligenceGraph({ root, mode: "auto" });
+                const check = await checkArchitectureAtRoot(root, graph);
+                if (options.json) {
+                    printJson({
+                        contract: loaded?.contract ?? null,
+                        path: loaded?.path ?? null,
+                        check,
+                        explanation: explainArchitecture(loaded?.contract ?? null, check),
+                    });
+                }
+                else {
+                    process.stdout.write(explainArchitecture(loaded?.contract ?? null, check));
+                }
+                return EXIT_CODES.SUCCESS;
+            }
+            default:
+                console.error(`Error: unknown architecture action`);
+                return EXIT_CODES.USAGE_ERROR;
+        }
+    }
+    catch (error) {
+        console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+        return EXIT_CODES.INTERNAL_ERROR;
+    }
+}

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

@@ -0,0 +1,67 @@
+export declare function runChangeAnalyzeCommand(options: {
+    root: string;
+    since?: string;
+    coverage?: string;
+    json?: boolean;
+}): Promise<number>;
+export declare function runChangeVerifyCommand(options: {
+    root: string;
+    since?: string;
+    changeId?: string;
+    coverage?: string;
+    json?: boolean;
+}): Promise<number>;
+export declare function runChangeExplainCommand(options: {
+    root: string;
+    since?: string;
+    changeId?: string;
+    coverage?: string;
+    json?: boolean;
+}): Promise<number>;
+export declare function runChangeDiffCommand(options: {
+    root: string;
+    since?: string;
+    changeId?: string;
+    json?: boolean;
+}): Promise<number>;
+export declare function runChangeStatusCommand(options: {
+    root: string;
+    changeId?: string;
+    json?: boolean;
+}): Promise<number>;
+export declare function runEvidenceInspectCommand(options: {
+    root: string;
+    changeId: string;
+    json?: boolean;
+}): Promise<number>;
+export declare function runEvidenceVerifyCommand(options: {
+    root: string;
+    changeId: string;
+    json?: boolean;
+}): Promise<number>;
+export declare function runProofBuildCommand(options: {
+    root: string;
+    changeId: string;
+    json?: boolean;
+}): Promise<number>;
+export declare function runProofInspectCommand(options: {
+    root: string;
+    id: string;
+    json?: boolean;
+}): Promise<number>;
+export declare function runProofExplainCommand(options: {
+    root: string;
+    id: string;
+    json?: boolean;
+}): Promise<number>;
+export declare function runProofVerifyCommand(options: {
+    root: string;
+    id: string;
+    json?: boolean;
+}): Promise<number>;
+export declare function runProofExportCommand(options: {
+    root: string;
+    id: string;
+    out: string;
+    json?: boolean;
+}): Promise<number>;

package/dist/cli/commands/assurance.js

@@ -0,0 +1,210 @@
+import { analyzeChange, changeStatus, diffChange, explainChange, inspectEvidence, verifyChange, verifyEvidence, } from "../../assurance/change.js";
+import { buildProofFromEvidence, explainProof, exportProof, inspectProof, verifyProof, } from "../../assurance/proof.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 runChangeAnalyzeCommand(options) {
+    try {
+        const assessment = await analyzeChange({
+            root: options.root,
+            ...(options.since ? { since: options.since } : {}),
+            ...(options.coverage ? { coveragePath: options.coverage } : {}),
+        });
+        emit(Boolean(options.json), assessment, [
+            `Change assessment ${assessment.changeId}`,
+            `  files: ${assessment.changedFiles.length}`,
+            `  symbols: ${assessment.changedSymbols.length}`,
+            `  testImpact: ${assessment.testImpact.mode} (${assessment.testImpact.confidence})`,
+            `  verificationStatus: ${assessment.verificationStatus}`,
+            `  Next: agentdoctor change verify${options.since ? ` --since ${options.since}` : ""}`,
+        ].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 runChangeVerifyCommand(options) {
+    try {
+        const { assessment, manifest } = await verifyChange({
+            root: options.root,
+            ...(options.since ? { since: options.since } : {}),
+            ...(options.changeId ? { changeId: options.changeId } : {}),
+            ...(options.coverage ? { coveragePath: options.coverage } : {}),
+        });
+        emit(Boolean(options.json), { assessment, manifest }, [
+            `Evidence produced for ${assessment.changeId}`,
+            `  directory: ${assessment.evidence.directory}`,
+            `  files: ${assessment.evidence.files?.join(", ") ?? ""}`,
+            `  verificationStatus: ${assessment.verificationStatus}`,
+            `  Next: agentdoctor evidence verify ${assessment.changeId}`,
+        ].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 runChangeExplainCommand(options) {
+    try {
+        const assessment = await analyzeChange({
+            root: options.root,
+            ...(options.since ? { since: options.since } : {}),
+            ...(options.changeId ? { changeId: options.changeId } : {}),
+            ...(options.coverage ? { coveragePath: options.coverage } : {}),
+        });
+        const text = explainChange(assessment);
+        emit(Boolean(options.json), { assessment, explanation: text }, text);
+        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 runChangeDiffCommand(options) {
+    try {
+        const diff = await diffChange({
+            root: options.root,
+            ...(options.since ? { since: options.since } : {}),
+            ...(options.changeId ? { changeId: options.changeId } : {}),
+        });
+        emit(Boolean(options.json), diff, [
+            `Change diff${diff.changeId ? ` (${diff.changeId})` : ""}`,
+            `  base → target: ${diff.baseRevision ?? "(wt)"} → ${diff.targetRevision ?? "?"}`,
+            `  files: +${diff.summary.added} ~${diff.summary.modified} -${diff.summary.deleted} ?${diff.summary.untracked}`,
+            diff.stat ? `\n${diff.stat}` : "  (no git --stat output)",
+        ].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 runChangeStatusCommand(options) {
+    try {
+        const status = await changeStatus({
+            root: options.root,
+            ...(options.changeId ? { changeId: options.changeId } : {}),
+        });
+        emit(Boolean(options.json), status, [
+            `Change status${status.changeId ? `: ${status.changeId}` : " (no evidence)"}`,
+            `  evidence: ${status.evidencePresent ? status.evidenceDirectory : "none"}`,
+            `  verificationStatus: ${status.verificationStatus}`,
+            `  proof: ${status.proofPresent ? status.proofId : "none"}`,
+            `  note: ${status.integrityNote}`,
+        ].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 runEvidenceInspectCommand(options) {
+    const result = await inspectEvidence({ root: options.root, changeId: options.changeId });
+    if (!result.ok) {
+        process.stderr.write(`Error: ${result.error ?? "evidence not found"}\n`);
+        return EXIT_CODES.USAGE_ERROR;
+    }
+    emit(Boolean(options.json), result, [
+        `Evidence ${options.changeId}`,
+        `  directory: ${result.directory}`,
+        `  files: ${result.presentFiles.join(", ")}`,
+        `  manifestStatus: ${result.manifest?.verificationStatus ?? "missing"}`,
+    ].join("\n"));
+    return EXIT_CODES.SUCCESS;
+}
+export async function runEvidenceVerifyCommand(options) {
+    const result = await verifyEvidence({ root: options.root, changeId: options.changeId });
+    emit(Boolean(options.json), result, [
+        `Evidence verify ${options.changeId}`,
+        `  status: ${result.verificationStatus}`,
+        ...result.checked.map((c) => `  ${c.match ? "OK" : "FAIL"} ${c.name}`),
+    ].join("\n"));
+    if (!result.ok) {
+        return EXIT_CODES.ISSUES_OR_THRESHOLD;
+    }
+    return EXIT_CODES.SUCCESS;
+}
+export async function runProofBuildCommand(options) {
+    try {
+        const proof = await buildProofFromEvidence(options.root, options.changeId);
+        emit(Boolean(options.json), proof, [
+            `ChangeProof ${proof.proofId}`,
+            `  changeId: ${proof.changeId}`,
+            `  integrityStatus: ${proof.integrityStatus}`,
+            `  engineeringChecksStatus: ${proof.engineeringChecksStatus}`,
+            `  verificationState: ${proof.verificationState}`,
+            `  correctnessStatus: ${proof.correctnessStatus}`,
+        ].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 runProofInspectCommand(options) {
+    const result = await inspectProof(options.root, options.id);
+    if (!result.ok || !result.proof) {
+        process.stderr.write(`Error: ${result.error ?? "proof not found"}\n`);
+        return EXIT_CODES.USAGE_ERROR;
+    }
+    emit(Boolean(options.json), result, [
+        `Proof ${result.proof.proofId}`,
+        `  changeId: ${result.proof.changeId}`,
+        `  integrityStatus: ${result.proof.integrityStatus}`,
+        `  engineeringChecksStatus: ${result.proof.engineeringChecksStatus}`,
+        `  verificationState: ${result.proof.verificationState}`,
+        `  correctnessStatus: ${result.proof.correctnessStatus}`,
+        `  path: ${result.path}`,
+    ].join("\n"));
+    return EXIT_CODES.SUCCESS;
+}
+export async function runProofExplainCommand(options) {
+    const result = await inspectProof(options.root, options.id);
+    if (!result.ok || !result.proof) {
+        process.stderr.write(`Error: ${result.error ?? "proof not found"}\n`);
+        return EXIT_CODES.USAGE_ERROR;
+    }
+    const text = explainProof(result.proof);
+    emit(Boolean(options.json), { proof: result.proof, explanation: text }, text);
+    return EXIT_CODES.SUCCESS;
+}
+export async function runProofVerifyCommand(options) {
+    const result = await verifyProof(options.root, options.id);
+    emit(Boolean(options.json), result, [
+        `Proof verify ${options.id}`,
+        `  integrityStatus: ${result.integrityStatus}`,
+        `  engineeringChecksStatus: ${result.engineeringChecksStatus}`,
+        `  verificationState: ${result.verificationState}`,
+        `  correctnessStatus: ${result.correctnessStatus}`,
+        ...result.checked.map((c) => `  ${c.match ? "OK" : "FAIL"} ${c.name}`),
+    ].join("\n"));
+    return result.ok ? EXIT_CODES.SUCCESS : EXIT_CODES.ISSUES_OR_THRESHOLD;
+}
+export async function runProofExportCommand(options) {
+    const result = await exportProof(options.root, options.id, options.out);
+    if (!result.ok) {
+        process.stderr.write(`Error: ${result.error ?? "export failed"}\n`);
+        return EXIT_CODES.USAGE_ERROR;
+    }
+    emit(Boolean(options.json), result, `Exported proof to ${result.path}`);
+    return EXIT_CODES.SUCCESS;
+}

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

@@ -0,0 +1,14 @@
+import { type ExitCode } from "../../types/index.js";
+export declare function runAskCommand(options: {
+    question: string;
+    root?: string;
+    json?: boolean;
+    /** Test-only: force mock provider */
+    useMock?: boolean;
+}): Promise<ExitCode>;
+export declare function runChatCommand(options: {
+    root?: string;
+    /** Non-interactive scripted lines (tests) */
+    scriptedInputs?: string[];
+    useMock?: boolean;
+}): Promise<ExitCode>;