mcoda 0.1.2 → 0.1.4

package/dist/commands/planning/QaTasksCommand.js

@@ -0,0 +1,293 @@
+import path from "node:path";
+import { QaTasksApi, WorkspaceResolver } from "@mcoda/core";
+import { PathHelper } from "@mcoda/shared";
+const usage = `mcoda qa-tasks [--workspace-root <path>] --project <PROJECT_KEY> [--task <TASK_KEY> ... | --epic <EPIC_KEY> | --story <STORY_KEY>] [--status <STATUS_FILTER>] [--mode auto|manual] [--profile <PROFILE_NAME>] [--level unit|integration|acceptance] [--test-command "<CMD>"] [--agent <NAME>] [--agent-stream true|false] [--create-followup-tasks auto|none|prompt] [--result pass|fail|blocked] [--notes "<text>"] [--evidence-url "<url>"] [--resume <JOB_ID>] [--dry-run] [--json]`;
+const parseBooleanFlag = (value, defaultValue) => {
+    if (value === undefined)
+        return defaultValue;
+    const normalized = value.toLowerCase();
+    if (["false", "0", "no"].includes(normalized))
+        return false;
+    if (["true", "1", "yes"].includes(normalized))
+        return true;
+    return defaultValue;
+};
+export const parseQaTasksArgs = (argv) => {
+    const tasks = [];
+    let workspaceRoot;
+    let projectKey;
+    let epicKey;
+    let storyKey;
+    let statusFilter = ["ready_to_qa"];
+    let mode = "auto";
+    let profileName;
+    let level;
+    let testCommand;
+    let agentName;
+    let agentStream;
+    let followups = "auto";
+    let dryRun = false;
+    let json = false;
+    let debug = false;
+    let noTelemetry = false;
+    let resumeJobId;
+    let result;
+    let notes;
+    let evidenceUrl;
+    let quiet = false;
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg.startsWith("--")) {
+            switch (arg) {
+                case "--workspace-root":
+                    workspaceRoot = argv[i + 1] ? path.resolve(argv[i + 1]) : undefined;
+                    i += 1;
+                    break;
+                case "--project":
+                    projectKey = argv[i + 1];
+                    i += 1;
+                    break;
+                case "--task":
+                    if (argv[i + 1])
+                        tasks.push(argv[i + 1]);
+                    i += 1;
+                    break;
+                case "--epic":
+                    epicKey = argv[i + 1];
+                    i += 1;
+                    break;
+                case "--story":
+                    storyKey = argv[i + 1];
+                    i += 1;
+                    break;
+                case "--status":
+                    statusFilter =
+                        argv[i + 1] && !argv[i + 1].startsWith("--")
+                            ? argv[i + 1].split(",").map((s) => s.trim()).filter(Boolean)
+                            : statusFilter;
+                    i += 1;
+                    break;
+                case "--mode":
+                    mode = argv[i + 1] === "manual" ? "manual" : "auto";
+                    i += 1;
+                    break;
+                case "--profile":
+                    profileName = argv[i + 1];
+                    i += 1;
+                    break;
+                case "--level":
+                    level = argv[i + 1];
+                    i += 1;
+                    break;
+                case "--test-command":
+                    testCommand = argv[i + 1];
+                    i += 1;
+                    break;
+                case "--agent":
+                    agentName = argv[i + 1];
+                    i += 1;
+                    break;
+                case "--agent-stream": {
+                    const next = argv[i + 1];
+                    if (next && !next.startsWith("--")) {
+                        agentStream = parseBooleanFlag(next, true);
+                        i += 1;
+                    }
+                    else {
+                        agentStream = true;
+                    }
+                    break;
+                }
+                case "--create-followup-tasks":
+                    followups = argv[i + 1] ?? "auto";
+                    i += 1;
+                    break;
+                case "--dry-run":
+                    dryRun = true;
+                    break;
+                case "--json":
+                    json = true;
+                    break;
+                case "--debug":
+                    debug = true;
+                    break;
+                case "--no-telemetry":
+                    noTelemetry = true;
+                    break;
+                case "--resume":
+                    resumeJobId = argv[i + 1];
+                    i += 1;
+                    break;
+                case "--result":
+                    result = argv[i + 1];
+                    i += 1;
+                    break;
+                case "--notes":
+                    notes = argv[i + 1];
+                    i += 1;
+                    break;
+                case "--evidence-url":
+                    evidenceUrl = argv[i + 1];
+                    i += 1;
+                    break;
+                case "--quiet":
+                    quiet = true;
+                    break;
+                case "--help":
+                case "-h":
+                    // eslint-disable-next-line no-console
+                    console.log(usage);
+                    process.exit(0);
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+    return {
+        workspaceRoot,
+        projectKey,
+        epicKey,
+        storyKey,
+        taskKeys: tasks,
+        statusFilter,
+        mode,
+        profileName,
+        level,
+        testCommand,
+        agentName,
+        agentStream: agentStream ?? true,
+        createFollowupTasks: followups,
+        dryRun,
+        json,
+        debug,
+        noTelemetry,
+        resumeJobId,
+        result,
+        notes,
+        evidenceUrl,
+        quiet,
+    };
+};
+export class QaTasksCommand {
+    static async run(argv) {
+        const parsed = parseQaTasksArgs(argv);
+        if (parsed.taskKeys.length && (parsed.epicKey || parsed.storyKey)) {
+            // eslint-disable-next-line no-console
+            console.error("Use either --task or --epic/--story, not both.");
+            process.exitCode = 1;
+            return;
+        }
+        if (parsed.mode === "manual" && !parsed.result) {
+            // eslint-disable-next-line no-console
+            console.error("--mode manual requires --result <pass|fail|blocked>.");
+            process.exitCode = 1;
+            return;
+        }
+        if (parsed.mode === "manual" && parsed.result && parsed.result !== "pass" && !parsed.notes && !parsed.evidenceUrl) {
+            // eslint-disable-next-line no-console
+            console.error("--mode manual with fail/blocked requires --notes or --evidence-url.");
+            process.exitCode = 1;
+            return;
+        }
+        const followupMode = parsed.createFollowupTasks === "prompt" && !process.stdout.isTTY ? "auto" : parsed.createFollowupTasks;
+        if (parsed.createFollowupTasks === "prompt" && !process.stdout.isTTY && !parsed.quiet && !parsed.json) {
+            // eslint-disable-next-line no-console
+            console.warn("Non-interactive environment; treating --create-followup-tasks=prompt as auto.");
+        }
+        const workspace = await WorkspaceResolver.resolveWorkspace({
+            cwd: process.cwd(),
+            explicitWorkspace: parsed.workspaceRoot,
+        });
+        const derivedKey = path.basename(workspace.workspaceRoot).replace(/[^a-z0-9]+/gi, "").toLowerCase();
+        const projectKey = parsed.projectKey ?? (derivedKey || undefined);
+        if (!projectKey) {
+            // eslint-disable-next-line no-console
+            console.error("--project is required for qa-tasks.");
+            process.exitCode = 1;
+            return;
+        }
+        try {
+            const result = await QaTasksApi.runQa({
+                workspaceRoot: workspace.workspaceRoot,
+                projectKey,
+                taskKeys: parsed.taskKeys,
+                epicKey: parsed.epicKey,
+                storyKey: parsed.storyKey,
+                statusFilter: parsed.statusFilter,
+                mode: parsed.mode,
+                resumeJobId: parsed.resumeJobId,
+                profileName: parsed.profileName,
+                level: parsed.level,
+                testCommand: parsed.testCommand,
+                agentName: parsed.agentName,
+                agentStream: parsed.agentStream,
+                createFollowupTasks: followupMode,
+                dryRun: parsed.dryRun,
+                result: parsed.result,
+                notes: parsed.notes,
+                evidenceUrl: parsed.evidenceUrl,
+                noTelemetry: parsed.noTelemetry,
+            });
+            if (parsed.debug && !parsed.json && !parsed.quiet) {
+                // eslint-disable-next-line no-console
+                console.log("[debug] options", {
+                    projectKey,
+                    tasks: parsed.taskKeys,
+                    epicKey: parsed.epicKey,
+                    storyKey: parsed.storyKey,
+                    mode: parsed.mode,
+                    profile: parsed.profileName,
+                    level: parsed.level,
+                    testCommand: parsed.testCommand,
+                    followups: followupMode,
+                    dryRun: parsed.dryRun,
+                    noTelemetry: parsed.noTelemetry,
+                });
+            }
+            if (parsed.json) {
+                const payload = {
+                    jobId: result.jobId,
+                    commandRunId: result.commandRunId,
+                    results: result.results,
+                    warnings: result.warnings,
+                };
+                // eslint-disable-next-line no-console
+                console.log(JSON.stringify(payload, null, 2));
+                return;
+            }
+            if (parsed.quiet)
+                return;
+            const dbPath = PathHelper.getWorkspaceDbPath(workspace.workspaceRoot);
+            const lines = [
+                `QA run complete.`,
+                `  Job ID: ${result.jobId}`,
+                `  Command Run: ${result.commandRunId}`,
+                `  Workspace DB: ${dbPath}`,
+            ];
+            if (result.warnings.length) {
+                lines.push(`  Warnings: ${result.warnings.join("; ")}`);
+            }
+            lines.push("Results:");
+            for (const r of result.results) {
+                const bits = [
+                    `${r.taskKey}: ${r.outcome}`,
+                    r.profile ? `profile=${r.profile}` : "",
+                    r.runner ? `runner=${r.runner}` : "",
+                ].filter(Boolean);
+                if (r.followups?.length)
+                    bits.push(`follow-ups=${r.followups.join(",")}`);
+                if (r.artifacts?.length)
+                    bits.push(`artifacts=${r.artifacts.join(",")}`);
+                lines.push(`- ${bits.join(" | ")}`);
+            }
+            // eslint-disable-next-line no-console
+            console.log(lines.join("\n"));
+        }
+        catch (error) {
+            // eslint-disable-next-line no-console
+            console.error(`qa-tasks failed: ${error.message}`);
+            process.exitCode = 1;
+        }
+    }
+}

package/dist/commands/planning/RefineTasksCommand.d.ts

@@ -0,0 +1,30 @@
+import type { RefineStrategy } from "@mcoda/shared";
+interface ParsedRefineArgs {
+    workspaceRoot?: string;
+    projectKey?: string;
+    epicKey?: string;
+    storyKey?: string;
+    taskKeys: string[];
+    statusFilter: string[];
+    maxTasks?: number;
+    strategy?: RefineStrategy;
+    agentName?: string;
+    agentStream: boolean;
+    fromDb: boolean;
+    dryRun: boolean;
+    apply: boolean;
+    resume: boolean;
+    runAll: boolean;
+    batchSize?: number;
+    maxBatches?: number;
+    json: boolean;
+    planIn?: string;
+    planOut?: string;
+    jobId?: string;
+}
+export declare const parseRefineTasksArgs: (argv: string[]) => ParsedRefineArgs;
+export declare class RefineTasksCommand {
+    static run(argv: string[]): Promise<void>;
+}
+export {};
+//# sourceMappingURL=RefineTasksCommand.d.ts.map

package/dist/commands/planning/RefineTasksCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RefineTasksCommand.d.ts","sourceRoot":"","sources":["../../../src/commands/planning/RefineTasksCommand.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAEpD,UAAU,gBAAgB;IACxB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,OAAO,CAAC;IACrB,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,OAAO,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AA8BD,eAAO,MAAM,oBAAoB,GAAI,MAAM,MAAM,EAAE,KAAG,gBAmMrD,CAAC;AAEF,qBAAa,kBAAkB;WAChB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;CAyJhD"}

package/dist/commands/planning/RefineTasksCommand.js

@@ -0,0 +1,365 @@
+import path from "node:path";
+import { RefineTasksService, WorkspaceResolver } from "@mcoda/core";
+const usage = `mcoda refine-tasks --project <PROJECT_KEY> [--workspace-root <PATH>] [--epic <EPIC_KEY>] [--story <STORY_KEY>] [--task <TASK_KEY> ...] [--status <STATUS>] [--max-tasks N] [--strategy split|merge|enrich|estimate|auto] [--agent <NAME>] [--agent-stream [true|false]] [--from-db [true|false]] [--dry-run] [--apply] [--resume|--skip-refined] [--run-all] [--batch-size N] [--max-batches N] [--plan-in <PATH>] [--plan-out <PATH>] [--json]`;
+const parseBooleanFlag = (value, defaultValue) => {
+    if (value === undefined)
+        return defaultValue;
+    const normalized = value.toLowerCase();
+    if (["false", "0", "no"].includes(normalized))
+        return false;
+    if (["true", "1", "yes"].includes(normalized))
+        return true;
+    return defaultValue;
+};
+const parseCsv = (value) => {
+    if (!value)
+        return [];
+    return value
+        .split(",")
+        .map((v) => v.trim())
+        .filter(Boolean);
+};
+const formatCounts = (ops) => {
+    const counts = ops.reduce((acc, op) => {
+        acc[op.op] = (acc[op.op] ?? 0) + 1;
+        return acc;
+    }, {});
+    return Object.entries(counts)
+        .map(([op, count]) => `${op}: ${count}`)
+        .join(", ");
+};
+export const parseRefineTasksArgs = (argv) => {
+    let workspaceRoot;
+    let projectKey;
+    let epicKey;
+    let storyKey;
+    const taskKeys = [];
+    const statusFilter = [];
+    let maxTasks;
+    let strategy;
+    let agentName;
+    let agentStream;
+    let fromDb;
+    let dryRun = false;
+    let apply = false;
+    let resume = false;
+    let runAll = false;
+    let batchSize;
+    let maxBatches;
+    let json = false;
+    let planIn;
+    let planOut;
+    let jobId;
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg.startsWith("--status=")) {
+            const [, raw] = arg.split("=", 2);
+            statusFilter.push(...parseCsv(raw));
+            continue;
+        }
+        if (arg.startsWith("--task=")) {
+            const [, raw] = arg.split("=", 2);
+            if (raw)
+                taskKeys.push(raw);
+            continue;
+        }
+        if (arg.startsWith("--agent-stream=")) {
+            const [, raw] = arg.split("=", 2);
+            agentStream = parseBooleanFlag(raw, true);
+            continue;
+        }
+        if (arg.startsWith("--from-db=")) {
+            const [, raw] = arg.split("=", 2);
+            fromDb = parseBooleanFlag(raw, true);
+            continue;
+        }
+        if (arg.startsWith("--apply=")) {
+            const [, raw] = arg.split("=", 2);
+            apply = parseBooleanFlag(raw, true);
+            continue;
+        }
+        if (arg.startsWith("--resume=")) {
+            const [, raw] = arg.split("=", 2);
+            resume = parseBooleanFlag(raw, true);
+            continue;
+        }
+        if (arg.startsWith("--skip-refined=")) {
+            const [, raw] = arg.split("=", 2);
+            resume = parseBooleanFlag(raw, true);
+            continue;
+        }
+        if (arg.startsWith("--run-all=")) {
+            const [, raw] = arg.split("=", 2);
+            runAll = parseBooleanFlag(raw, true);
+            continue;
+        }
+        switch (arg) {
+            case "--workspace-root":
+                workspaceRoot = argv[i + 1] ? path.resolve(argv[i + 1]) : undefined;
+                i += 1;
+                break;
+            case "--project":
+            case "--project-key":
+                projectKey = argv[i + 1];
+                i += 1;
+                break;
+            case "--epic":
+                epicKey = argv[i + 1];
+                i += 1;
+                break;
+            case "--story":
+                storyKey = argv[i + 1];
+                i += 1;
+                break;
+            case "--task":
+                if (argv[i + 1]) {
+                    taskKeys.push(argv[i + 1]);
+                    i += 1;
+                }
+                break;
+            case "--status":
+                statusFilter.push(...parseCsv(argv[i + 1]));
+                i += 1;
+                break;
+            case "--max-tasks":
+                maxTasks = Number(argv[i + 1]);
+                i += 1;
+                break;
+            case "--strategy":
+                strategy = argv[i + 1];
+                i += 1;
+                break;
+            case "--agent":
+                agentName = argv[i + 1];
+                i += 1;
+                break;
+            case "--agent-stream": {
+                const next = argv[i + 1];
+                if (next && !next.startsWith("--")) {
+                    agentStream = parseBooleanFlag(next, true);
+                    i += 1;
+                }
+                else {
+                    agentStream = true;
+                }
+                break;
+            }
+            case "--from-db": {
+                const next = argv[i + 1];
+                if (next && !next.startsWith("--")) {
+                    fromDb = parseBooleanFlag(next, true);
+                    i += 1;
+                }
+                else {
+                    fromDb = true;
+                }
+                break;
+            }
+            case "--dry-run":
+                dryRun = true;
+                break;
+            case "--apply":
+                apply = true;
+                break;
+            case "--resume":
+            case "--skip-refined":
+                resume = true;
+                break;
+            case "--run-all":
+                runAll = true;
+                break;
+            case "--batch-size":
+                batchSize = Number(argv[i + 1]);
+                i += 1;
+                break;
+            case "--max-batches":
+                maxBatches = Number(argv[i + 1]);
+                i += 1;
+                break;
+            case "--json":
+                json = true;
+                break;
+            case "--plan-in":
+                planIn = argv[i + 1] ? path.resolve(argv[i + 1]) : undefined;
+                i += 1;
+                break;
+            case "--plan-out":
+                planOut = argv[i + 1] ? path.resolve(argv[i + 1]) : undefined;
+                i += 1;
+                break;
+            case "--job-id":
+                jobId = argv[i + 1];
+                i += 1;
+                break;
+            case "--help":
+            case "-h":
+                // eslint-disable-next-line no-console
+                console.log(usage);
+                process.exit(0);
+                break;
+            default:
+                break;
+        }
+    }
+    return {
+        workspaceRoot,
+        projectKey,
+        epicKey,
+        storyKey,
+        taskKeys,
+        statusFilter,
+        maxTasks: Number.isFinite(maxTasks) ? maxTasks : undefined,
+        strategy,
+        agentName,
+        agentStream: agentStream ?? true,
+        fromDb: fromDb ?? true,
+        dryRun,
+        apply,
+        resume,
+        runAll,
+        batchSize: Number.isFinite(batchSize) ? batchSize : undefined,
+        maxBatches: Number.isFinite(maxBatches) ? maxBatches : undefined,
+        json,
+        planIn,
+        planOut,
+        jobId,
+    };
+};
+export class RefineTasksCommand {
+    static async run(argv) {
+        const parsed = parseRefineTasksArgs(argv);
+        if (!parsed.projectKey) {
+            // eslint-disable-next-line no-console
+            console.error("refine-tasks requires --project <PROJECT_KEY>");
+            process.exitCode = 1;
+            return;
+        }
+        if (parsed.apply && parsed.dryRun) {
+            // eslint-disable-next-line no-console
+            console.error("refine-tasks: --apply cannot be used with --dry-run");
+            process.exitCode = 1;
+            return;
+        }
+        if ((parsed.runAll || parsed.resume) && !parsed.apply) {
+            // eslint-disable-next-line no-console
+            console.error("refine-tasks: --run-all/--resume requires --apply (needed for durable progress tracking)");
+            process.exitCode = 1;
+            return;
+        }
+        const workspace = await WorkspaceResolver.resolveWorkspace({
+            cwd: process.cwd(),
+            explicitWorkspace: parsed.workspaceRoot,
+        });
+        const service = await RefineTasksService.create(workspace);
+        try {
+            const baseRequest = {
+                workspace,
+                projectKey: parsed.projectKey,
+                epicKey: parsed.epicKey,
+                storyKey: parsed.storyKey,
+                taskKeys: parsed.taskKeys.length ? parsed.taskKeys : undefined,
+                statusFilter: parsed.statusFilter.length ? parsed.statusFilter : undefined,
+                strategy: parsed.strategy ?? "auto",
+                agentName: parsed.agentName,
+                agentStream: parsed.agentStream,
+                fromDb: parsed.fromDb,
+                dryRun: parsed.dryRun,
+                planInPath: parsed.planIn,
+                planOutPath: parsed.planOut,
+                jobId: parsed.jobId,
+                apply: parsed.apply,
+                excludeAlreadyRefined: parsed.runAll || parsed.resume,
+                allowEmptySelection: parsed.runAll || parsed.resume,
+            };
+            if (parsed.runAll) {
+                const batchSize = parsed.batchSize ?? parsed.maxTasks ?? 250;
+                const maxBatches = parsed.maxBatches ?? Number.POSITIVE_INFINITY;
+                const batches = [];
+                let totalProcessed = 0;
+                let totalAffected = 0;
+                for (let batch = 1; batch <= maxBatches; batch += 1) {
+                    const result = await service.refineTasks({
+                        ...baseRequest,
+                        maxTasks: batchSize,
+                    });
+                    const tasksProcessed = result.summary?.tasksProcessed ?? 0;
+                    const tasksAffected = result.summary?.tasksAffected ?? 0;
+                    const operations = result.plan.operations.length;
+                    if (tasksProcessed === 0 || operations === 0)
+                        break;
+                    totalProcessed += tasksProcessed;
+                    totalAffected += tasksAffected;
+                    batches.push({
+                        batch,
+                        jobId: result.jobId,
+                        commandRunId: result.commandRunId,
+                        tasksProcessed,
+                        tasksAffected,
+                        operations,
+                    });
+                    if (!parsed.json) {
+                        // eslint-disable-next-line no-console
+                        console.log(`Batch ${batch}: Job ${result.jobId}, Command Run ${result.commandRunId}\n` +
+                            `Processed: ${tasksProcessed}, affected: ${tasksAffected}, operations: ${operations}`);
+                    }
+                }
+                if (parsed.json) {
+                    // eslint-disable-next-line no-console
+                    console.log(JSON.stringify({ status: "completed", totalProcessed, totalAffected, batches }, null, 2));
+                }
+                else {
+                    // eslint-disable-next-line no-console
+                    console.log(`Done. Total processed: ${totalProcessed}, total affected: ${totalAffected}`);
+                }
+                return;
+            }
+            const result = await service.refineTasks({
+                ...baseRequest,
+                maxTasks: parsed.maxTasks,
+            });
+            if (parsed.json) {
+                // eslint-disable-next-line no-console
+                console.log(JSON.stringify({
+                    status: result.applied ? "applied" : "dry_run",
+                    summary: result.summary,
+                    plan: result.plan,
+                    warnings: result.plan.warnings ?? [],
+                }, null, 2));
+            }
+            else {
+                const opSummary = formatCounts(result.plan.operations);
+                const summaryLines = [
+                    `Job: ${result.jobId}, Command Run: ${result.commandRunId}`,
+                    `Applied: ${result.applied ? "yes" : "no (dry run)"}`,
+                    `Operations: ${result.plan.operations.length}${opSummary ? ` (${opSummary})` : ""}`,
+                    result.summary
+                        ? `Tasks processed: ${result.summary.tasksProcessed}, affected: ${result.summary.tasksAffected}, story points delta: ${result.summary.storyPointsDelta ?? 0}`
+                        : undefined,
+                    result.createdTasks?.length ? `Created: ${result.createdTasks.join(", ")}` : undefined,
+                    result.updatedTasks?.length ? `Updated: ${result.updatedTasks.join(", ")}` : undefined,
+                    result.cancelledTasks?.length ? `Cancelled: ${result.cancelledTasks.join(", ")}` : undefined,
+                ].filter(Boolean);
+                // eslint-disable-next-line no-console
+                console.log(summaryLines.join("\n"));
+                if (result.plan.warnings && result.plan.warnings.length > 0) {
+                    // eslint-disable-next-line no-console
+                    console.warn(result.plan.warnings.map((w) => `! ${w}`).join("\n"));
+                }
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            // eslint-disable-next-line no-console
+            console.error(`refine-tasks failed: ${message}`);
+            process.exitCode = 1;
+        }
+        finally {
+            try {
+                await service.close();
+            }
+            catch {
+                // ignore close-time errors (e.g., db already closed)
+            }
+        }
+    }
+}