@mcoda/core 0.1.8 → 0.1.11

package/dist/services/planning/RefineTasksService.js

@@ -2,58 +2,162 @@ import path from "node:path";
 import { promises as fs } from "node:fs";
 import { AgentService } from "@mcoda/agents";
 import { DocdexClient } from "@mcoda/integrations";
+import { READY_TO_CODE_REVIEW } from "@mcoda/shared";
 import { GlobalRepository, WorkspaceRepository } from "@mcoda/db";
+import { getCommandRequiredCapabilities, } from "@mcoda/shared";
 import { JobService } from "../jobs/JobService.js";
 import { RoutingService } from "../agents/RoutingService.js";
+import { AgentRatingService } from "../agents/AgentRatingService.js";
+import { classifyTask } from "../backlog/TaskOrderingHeuristics.js";
+import { TaskOrderingService } from "../backlog/TaskOrderingService.js";
 import { createTaskKeyGenerator } from "./KeyHelpers.js";
 const DEFAULT_STRATEGY = "auto";
-const FORBIDDEN_TARGET_STATUSES = new Set(["ready_to_review", "ready_to_qa", "completed"]);
+const FORBIDDEN_TARGET_STATUSES = new Set([READY_TO_CODE_REVIEW, "ready_to_qa", "completed"]);
+const normalizeCreateStatus = (status) => {
+    if (!status)
+        return "not_started";
+    return status.toLowerCase();
+};
 const DEFAULT_MAX_TASKS = 250;
 const MAX_AGENT_OUTPUT_CHARS = 10000000;
 const estimateTokens = (text) => Math.max(1, Math.ceil(text.length / 4));
 const extractJson = (raw) => {
+    const fencedMatches = [...raw.matchAll(/```json([\s\S]*?)```/g)].map((match) => match[1]);
+    const stripped = raw.replace(/<think>[\s\S]*?<\/think>/g, "");
+    const candidates = [...fencedMatches, stripped, raw].filter((candidate) => candidate.trim().length > 0);
+    for (const candidate of candidates) {
+        const parsed = tryParseJson(candidate);
+        if (parsed !== undefined)
+            return parsed;
+    }
+    return undefined;
+};
+const tryParseJson = (value) => {
     try {
-        const fenced = raw.match(/```json([\s\S]*?)```/);
-        const candidate = fenced ? fenced[1] : raw;
-        const start = candidate.indexOf("{");
-        const end = candidate.lastIndexOf("}");
-        if (start === -1 || end === -1 || end <= start)
-            return JSON.parse(raw);
-        return JSON.parse(candidate.slice(start, end + 1));
+        return JSON.parse(value);
     }
     catch {
+        // continue
+    }
+    const objects = extractJsonObjects(value).reverse();
+    for (const obj of objects) {
+        try {
+            return JSON.parse(obj);
+        }
+        catch {
+            // continue
+        }
+    }
+    return undefined;
+};
+const extractJsonObjects = (value) => {
+    const results = [];
+    let depth = 0;
+    let start = -1;
+    let inString = false;
+    let escaped = false;
+    for (let i = 0; i < value.length; i += 1) {
+        const ch = value[i];
+        if (inString) {
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (ch === "\\") {
+                escaped = true;
+                continue;
+            }
+            if (ch === "\"")
+                inString = false;
+            continue;
+        }
+        if (ch === "\"") {
+            inString = true;
+            continue;
+        }
+        if (ch === "{") {
+            if (depth === 0)
+                start = i;
+            depth += 1;
+        }
+        else if (ch === "}") {
+            if (depth === 0)
+                continue;
+            depth -= 1;
+            if (depth === 0 && start >= 0) {
+                results.push(value.slice(start, i + 1));
+                start = -1;
+            }
+        }
+    }
+    return results;
+};
+const normalizePlanJson = (parsed) => {
+    if (!parsed)
         return undefined;
+    if (Array.isArray(parsed)) {
+        return { operations: parsed };
     }
+    if (Array.isArray(parsed.operations))
+        return parsed;
+    if (parsed.op) {
+        return { operations: [parsed] };
+    }
+    return undefined;
 };
 const normalizeOperation = (op) => {
     if (!op || typeof op !== "object")
         return op;
-    if (op.op !== "update_task")
-        return op;
+    const opType = op.op;
     const taskKey = op.taskKey ?? op.key ?? op.task ?? op.targetTaskKey ?? null;
-    const updates = { ...op.updates };
-    const inlineFields = ["title", "description", "acceptanceCriteria", "type", "status", "storyPoints", "priority", "dependsOn", "metadata"];
-    for (const field of inlineFields) {
-        if (op[field] !== undefined && updates[field] === undefined) {
-            updates[field] = op[field];
+    if (opType === "update_task") {
+        const updates = { ...op.updates };
+        const inlineFields = [
+            "title",
+            "description",
+            "acceptanceCriteria",
+            "type",
+            "status",
+            "storyPoints",
+            "priority",
+            "dependsOn",
+            "metadata",
+        ];
+        for (const field of inlineFields) {
+            if (op[field] !== undefined && updates[field] === undefined) {
+                updates[field] = op[field];
+            }
         }
+        return {
+            ...op,
+            taskKey,
+            updates,
+        };
+    }
+    if (opType === "split_task") {
+        const children = Array.isArray(op.children)
+            ? op.children
+            : Array.isArray(op.subtasks)
+                ? op.subtasks
+                : Array.isArray(op.newTasks)
+                    ? op.newTasks
+                    : Array.isArray(op.tasks)
+                        ? op.tasks
+                        : undefined;
+        return {
+            ...op,
+            taskKey,
+            children,
+        };
     }
     return {
         ...op,
         taskKey,
-        updates,
     };
 };
 const safeParsePlan = (content) => {
-    try {
-        const parsed = JSON.parse(content);
-        if (parsed && Array.isArray(parsed.operations))
-            return parsed;
-    }
-    catch {
-        /* ignore */
-    }
-    return undefined;
+    const parsed = extractJson(content);
+    return normalizePlanJson(parsed);
 };
 const formatTaskSummary = (task) => {
     return [
@@ -73,14 +177,17 @@ export class RefineTasksService {
         this.repo = deps.repo;
         this.workspaceRepo = deps.workspaceRepo;
         this.routingService = deps.routingService;
+        this.ratingService = deps.ratingService;
     }
     static async create(workspace) {
         const repo = await GlobalRepository.create();
         const agentService = new AgentService(repo);
         const routingService = await RoutingService.create();
+        const docdexRepoId = workspace.config?.docdexRepoId ?? process.env.MCODA_DOCDEX_REPO_ID ?? process.env.DOCDEX_REPO_ID;
         const docdex = new DocdexClient({
             workspaceRoot: workspace.workspaceRoot,
             baseUrl: workspace.config?.docdexUrl ?? process.env.MCODA_DOCDEX_URL,
+            repoId: docdexRepoId,
         });
         const workspaceRepo = await WorkspaceRepository.create(workspace.workspaceRoot);
         const jobService = new JobService(workspace, workspaceRepo);
@@ -111,13 +218,93 @@ export class RefineTasksService {
         await tryClose(this.routingService);
         await tryClose(this.docdex);
     }
+    async seedPriorities(projectKey) {
+        const ordering = await TaskOrderingService.create(this.workspace, { recordTelemetry: false });
+        try {
+            await ordering.orderTasks({
+                projectKey,
+            });
+        }
+        finally {
+            await ordering.close();
+        }
+    }
     async resolveAgent(agentName) {
-        const resolved = await this.routingService.resolveAgentForCommand({
-            workspace: this.workspace,
-            commandName: "refine-tasks",
-            overrideAgentSlug: agentName,
+        try {
+            const resolved = await this.routingService.resolveAgentForCommand({
+                workspace: this.workspace,
+                commandName: "refine-tasks",
+                overrideAgentSlug: agentName,
+            });
+            return resolved.agent;
+        }
+        catch (error) {
+            const message = error.message ?? "";
+            if (!/No routing defaults/i.test(message)) {
+                throw error;
+            }
+            const requiredCaps = getCommandRequiredCapabilities("refine-tasks");
+            const fallback = await this.selectFallbackAgent(requiredCaps);
+            if (fallback)
+                return fallback;
+            throw new Error(`No routing defaults found for command refine-tasks. ` +
+                `Set a default agent (mcoda agent set-default <NAME> --workspace <PATH>) ` +
+                `or pass --agent <NAME> with ${requiredCaps.length ? `capabilities: ${requiredCaps.join(", ")}` : "required capabilities"}.`);
+        }
+    }
+    async selectFallbackAgent(requiredCaps) {
+        const agents = await this.repo.listAgents();
+        if (!agents.length)
+            return undefined;
+        let healthRows = [];
+        try {
+            healthRows = await this.repo.listAgentHealthSummary();
+        }
+        catch {
+            healthRows = [];
+        }
+        const healthById = new Map(healthRows.map((row) => [row.agentId, row]));
+        const candidates = [];
+        for (const agent of agents) {
+            const health = healthById.get(agent.id);
+            if (health?.status === "unreachable")
+                continue;
+            const caps = await this.repo.getAgentCapabilities(agent.id);
+            const hasCaps = requiredCaps.every((cap) => caps.includes(cap));
+            candidates.push({
+                agent,
+                rating: Number(agent.rating ?? 0),
+                reasoning: Number(agent.reasoningRating ?? 0),
+                cost: Number(agent.costPerMillion ?? 0),
+                hasCaps,
+                slug: agent.slug ?? agent.id,
+            });
+        }
+        if (!candidates.length)
+            return undefined;
+        const eligible = candidates.filter((c) => c.hasCaps);
+        const pool = eligible.length ? eligible : candidates;
+        pool.sort((a, b) => {
+            if (b.rating !== a.rating)
+                return b.rating - a.rating;
+            if (b.reasoning !== a.reasoning)
+                return b.reasoning - a.reasoning;
+            if (a.cost !== b.cost)
+                return a.cost - b.cost;
+            return a.slug.localeCompare(b.slug);
         });
-        return resolved.agent;
+        return pool[0]?.agent;
+    }
+    ensureRatingService() {
+        if (!this.ratingService) {
+            this.ratingService = new AgentRatingService(this.workspace, {
+                workspaceRepo: this.workspaceRepo,
+                globalRepo: this.repo,
+                agentService: this.agentService,
+                routingService: this.routingService,
+            });
+        }
+        return this.ratingService;
     }
     async selectTasks(projectKey, filters) {
         const db = this.workspaceRepo.getDb();
@@ -361,6 +548,7 @@ export class RefineTasksService {
         const updates = seed?.updates ?? seed?.fields ?? {};
         const epic = await ensureEpic();
         const story = await ensureStory(epic.id);
+        const status = normalizeCreateStatus(updates.status);
         const [task] = await this.workspaceRepo.insertTasks([
             {
                 projectId,
@@ -370,7 +558,7 @@ export class RefineTasksService {
                 title: updates.title ?? `Task ${taskKey}`,
                 description: updates.description ?? "",
                 type: updates.type ?? "feature",
-                status: updates.status ?? "not_started",
+                status,
                 storyPoints: updates.storyPoints ?? null,
                 priority: updates.priority ?? null,
                 metadata: updates.metadata ?? undefined,
@@ -391,7 +579,7 @@ export class RefineTasksService {
         const taskList = group.tasks.map((t) => formatTaskSummary(t)).join("\n");
         const constraints = [
             "- Immutable: project_id, epic_id, user_story_id, task keys.",
-            "- Allowed edits: title, description, acceptanceCriteria, metadata/labels, type, priority, storyPoints, status (but NOT ready_to_review/qa/completed).",
+            "- Allowed edits: title, description, acceptanceCriteria, metadata/labels, type, priority, storyPoints, status (but NOT ready_to_code_review/qa/completed).",
             "- Splits: children stay under same story; keep parent unless keepParent=false; child dependsOn must reference existing tasks or siblings.",
             "- Merges: target and sources must be in same story; prefer cancelling redundant sources (status=cancelled) and preserve useful details in target updates.",
             "- Dependencies: maintain DAG; do not introduce cycles or cross-story edges.",
@@ -411,6 +599,8 @@ export class RefineTasksService {
             group.historySummary || "(none)",
             "Constraints:",
             constraints,
+            "Example JSON:",
+            "{\"operations\":[{\"op\":\"update_task\",\"taskKey\":\"web-01-us-01-t01\",\"updates\":{\"title\":\"Refined title\",\"storyPoints\":3}}]}",
             "Return JSON ONLY matching: { \"operations\": [UpdateTaskOp | SplitTaskOp | MergeTasksOp | UpdateEstimateOp] } where each item has an `op` discriminator (update_task|split_task|merge_tasks|update_estimate).",
         ].join("\n\n");
     }
@@ -528,6 +718,20 @@ export class RefineTasksService {
             return existing;
         return { ...(existing ?? {}), ...updates };
     }
+    applyStageMetadata(metadata, content, shouldUpdate) {
+        if (!shouldUpdate)
+            return metadata;
+        const classification = classifyTask({
+            title: content.title,
+            description: content.description ?? undefined,
+            type: content.type ?? undefined,
+        });
+        return {
+            ...(metadata ?? {}),
+            stage: classification.stage,
+            foundation: classification.foundation,
+        };
+    }
     validateOperation(group, op) {
         const allowedOps = new Set(["update_task", "split_task", "merge_tasks", "update_estimate"]);
         if (!op || typeof op.op !== "string" || !allowedOps.has(op.op)) {
@@ -634,6 +838,28 @@ export class RefineTasksService {
         }
         return false;
     }
+    hasDependencyPath(graph, fromKey, toKey) {
+        if (fromKey === toKey)
+            return true;
+        const visited = new Set();
+        const stack = [fromKey];
+        while (stack.length > 0) {
+            const current = stack.pop();
+            if (current === toKey)
+                return true;
+            if (visited.has(current))
+                continue;
+            visited.add(current);
+            const neighbors = graph.get(current);
+            if (!neighbors)
+                continue;
+            for (const next of neighbors) {
+                if (!visited.has(next))
+                    stack.push(next);
+            }
+        }
+        return false;
+    }
     async applyOperations(projectId, jobId, commandRunId, group, operations) {
         const created = [];
         const updated = [];
@@ -645,7 +871,6 @@ export class RefineTasksService {
             let stage = "start";
             const newTasks = [];
             const pendingDeps = [];
-            const dependencyEdges = [];
             try {
                 stage = "load:storyKeys";
                 const storyKeyRows = await this.workspaceRepo.getDb().all(`SELECT key FROM tasks WHERE user_story_id = ?`, group.story.id);
@@ -658,7 +883,13 @@ export class RefineTasksService {
                         if (!target)
                             continue;
                         const before = { ...target };
-                        const metadata = this.mergeMetadata(target.metadata, op.updates.metadata);
+                        const mergedMetadata = this.mergeMetadata(target.metadata, op.updates.metadata);
+                        const contentUpdated = op.updates.title !== undefined || op.updates.description !== undefined || op.updates.type !== undefined;
+                        const metadata = this.applyStageMetadata(mergedMetadata, {
+                            title: op.updates.title ?? target.title,
+                            description: op.updates.description ?? target.description ?? null,
+                            type: op.updates.type ?? target.type ?? null,
+                        }, contentUpdated);
                         const beforeSp = target.storyPoints ?? 0;
                         const afterSp = op.updates.storyPoints ?? target.storyPoints ?? null;
                         storyPointsDelta += (afterSp ?? 0) - (beforeSp ?? 0);
@@ -687,13 +918,22 @@ export class RefineTasksService {
                             continue;
                         if (op.parentUpdates) {
                             const before = { ...target };
+                            const mergedMetadata = this.mergeMetadata(target.metadata, op.parentUpdates.metadata);
+                            const contentUpdated = op.parentUpdates.title !== undefined ||
+                                op.parentUpdates.description !== undefined ||
+                                op.parentUpdates.type !== undefined;
+                            const metadata = this.applyStageMetadata(mergedMetadata, {
+                                title: op.parentUpdates.title ?? target.title,
+                                description: op.parentUpdates.description ?? target.description ?? null,
+                                type: op.parentUpdates.type ?? target.type ?? null,
+                            }, contentUpdated);
                             await this.workspaceRepo.updateTask(target.id, {
                                 title: op.parentUpdates.title ?? target.title,
                                 description: op.parentUpdates.description ?? target.description ?? null,
                                 type: op.parentUpdates.type ?? target.type ?? null,
                                 storyPoints: op.parentUpdates.storyPoints ?? target.storyPoints ?? null,
                                 priority: op.parentUpdates.priority ?? target.priority ?? null,
-                                metadata: this.mergeMetadata(target.metadata, op.parentUpdates.metadata),
+                                metadata,
                             });
                             updated.push(target.key);
                             await this.workspaceRepo.insertTaskRevision({
@@ -705,7 +945,7 @@ export class RefineTasksService {
                                     ...before,
                                     ...op.parentUpdates,
                                     storyPoints: op.parentUpdates.storyPoints ?? before.storyPoints,
-                                    metadata: this.mergeMetadata(before.metadata, op.parentUpdates.metadata),
+                                    metadata,
                                 },
                                 createdAt: new Date().toISOString(),
                             });
@@ -716,6 +956,13 @@ export class RefineTasksService {
                             if (childSp) {
                                 storyPointsDelta += childSp;
                             }
+                            const childMetadata = this.mergeMetadata({}, child.metadata);
+                            const childContent = {
+                                title: child.title,
+                                description: child.description ?? target.description ?? "",
+                                type: child.type ?? target.type ?? "feature",
+                            };
+                            const resolvedChildMetadata = this.applyStageMetadata(childMetadata, childContent, true);
                             const childInsert = {
                                 projectId,
                                 epicId: target.epicId,
@@ -727,7 +974,7 @@ export class RefineTasksService {
                                 status: "not_started",
                                 storyPoints: childSp,
                                 priority: child.priority ?? target.priority ?? null,
-                                metadata: this.mergeMetadata({}, child.metadata),
+                                metadata: resolvedChildMetadata,
                                 assignedAgentId: target.assignedAgentId ?? null,
                                 assigneeHuman: target.assigneeHuman ?? null,
                                 vcsBranch: null,
@@ -740,8 +987,12 @@ export class RefineTasksService {
                             for (const depKey of dependsOn) {
                                 const depTask = taskByKey.get(depKey);
                                 if (depTask) {
-                                    pendingDeps.push({ childKey, dependsOnId: depTask.id, relationType: "blocks" });
-                                    dependencyEdges.push({ from: childKey, to: depTask.key });
+                                    pendingDeps.push({
+                                        childKey,
+                                        dependsOnId: depTask.id,
+                                        dependsOnKey: depTask.key,
+                                        relationType: "blocks",
+                                    });
                                 }
                             }
                             taskByKey.set(childKey, {
@@ -762,13 +1013,20 @@ export class RefineTasksService {
                             continue;
                         if (op.updates) {
                             const before = { ...target };
+                            const mergedMetadata = this.mergeMetadata(target.metadata, op.updates.metadata);
+                            const contentUpdated = op.updates.title !== undefined || op.updates.description !== undefined || op.updates.type !== undefined;
+                            const metadata = this.applyStageMetadata(mergedMetadata, {
+                                title: op.updates.title ?? target.title,
+                                description: op.updates.description ?? target.description ?? null,
+                                type: op.updates.type ?? target.type ?? null,
+                            }, contentUpdated);
                             await this.workspaceRepo.updateTask(target.id, {
                                 title: op.updates.title ?? target.title,
                                 description: op.updates.description ?? target.description ?? null,
                                 type: op.updates.type ?? target.type ?? null,
                                 storyPoints: op.updates.storyPoints ?? target.storyPoints ?? null,
                                 priority: op.updates.priority ?? target.priority ?? null,
-                                metadata: this.mergeMetadata(target.metadata, op.updates.metadata),
+                                metadata,
                             });
                             updated.push(target.key);
                             await this.workspaceRepo.insertTaskRevision({
@@ -780,7 +1038,7 @@ export class RefineTasksService {
                                     ...before,
                                     ...op.updates,
                                     storyPoints: op.updates.storyPoints ?? before.storyPoints,
-                                    metadata: this.mergeMetadata(before.metadata, op.updates.metadata),
+                                    metadata,
                                 },
                                 createdAt: new Date().toISOString(),
                             });
@@ -813,10 +1071,17 @@ export class RefineTasksService {
                         const beforeSp = target.storyPoints ?? 0;
                         const afterSp = op.storyPoints ?? target.storyPoints ?? null;
                         storyPointsDelta += (afterSp ?? 0) - (beforeSp ?? 0);
+                        const contentUpdated = op.type !== undefined;
+                        const metadata = this.applyStageMetadata(target.metadata, {
+                            title: target.title,
+                            description: target.description ?? null,
+                            type: op.type ?? target.type ?? null,
+                        }, contentUpdated);
                         await this.workspaceRepo.updateTask(target.id, {
                             storyPoints: afterSp,
                             type: op.type ?? target.type ?? null,
                             priority: op.priority ?? target.priority ?? null,
+                            metadata: contentUpdated ? metadata : undefined,
                         });
                         updated.push(target.key);
                         await this.workspaceRepo.insertTaskRevision({
@@ -824,11 +1089,30 @@ export class RefineTasksService {
                             jobId,
                             commandRunId,
                             snapshotBefore: { ...target },
-                            snapshotAfter: { ...target, storyPoints: afterSp, type: op.type ?? target.type ?? null, priority: op.priority ?? target.priority ?? null },
+                            snapshotAfter: {
+                                ...target,
+                                storyPoints: afterSp,
+                                type: op.type ?? target.type ?? null,
+                                priority: op.priority ?? target.priority ?? null,
+                                metadata: contentUpdated ? metadata : target.metadata,
+                            },
                             createdAt: new Date().toISOString(),
                         });
                     }
                 }
+                const dependencyGraph = new Map();
+                const addEdge = (from, to) => {
+                    if (!from || !to)
+                        return;
+                    const edges = dependencyGraph.get(from) ?? new Set();
+                    edges.add(to);
+                    dependencyGraph.set(from, edges);
+                };
+                for (const task of group.tasks) {
+                    for (const dep of task.dependencies) {
+                        addEdge(task.key, dep);
+                    }
+                }
                 if (newTasks.length > 0) {
                     stage = "insert:newTasks";
                     const inserted = await this.workspaceRepo.insertTasks(newTasks, false);
@@ -842,7 +1126,27 @@ export class RefineTasksService {
                         }
                     }
                     const deps = [];
+                    const allowedDeps = [];
+                    const skippedDeps = [];
                     for (const dep of pendingDeps) {
+                        if (!dep.dependsOnKey)
+                            continue;
+                        if (this.hasDependencyPath(dependencyGraph, dep.dependsOnKey, dep.childKey)) {
+                            skippedDeps.push({ childKey: dep.childKey, dependsOnKey: dep.dependsOnKey });
+                            continue;
+                        }
+                        addEdge(dep.childKey, dep.dependsOnKey);
+                        allowedDeps.push(dep);
+                    }
+                    if (skippedDeps.length > 0) {
+                        const sample = skippedDeps
+                            .slice(0, 5)
+                            .map((dep) => `${dep.childKey}->${dep.dependsOnKey}`)
+                            .join(", ");
+                        warnings.push(`Skipped ${skippedDeps.length} refine dependencies that would create cycles.` +
+                            (sample ? ` Sample: ${sample}` : ""));
+                    }
+                    for (const dep of allowedDeps) {
                         const childId = idByKey.get(dep.childKey);
                         if (childId) {
                             deps.push({ taskId: childId, dependsOnTaskId: dep.dependsOnId, relationType: dep.relationType });
@@ -855,12 +1159,11 @@ export class RefineTasksService {
                 }
                 // cycle detection on current + new dependencies (by key)
                 const edgeSet = [];
-                for (const task of group.tasks) {
-                    for (const dep of task.dependencies) {
-                        edgeSet.push({ from: task.key, to: dep });
+                for (const [from, deps] of dependencyGraph.entries()) {
+                    for (const dep of deps) {
+                        edgeSet.push({ from, to: dep });
                     }
                 }
-                edgeSet.push(...dependencyEdges);
                 const hasCycle = this.detectCycle(edgeSet);
                 if (hasCycle) {
                     throw new Error("Dependency cycle detected after refinement; aborting apply.");
@@ -987,9 +1290,15 @@ export class RefineTasksService {
             tokensTotal: promptTokens + completionTokens,
             durationSeconds,
             timestamp: new Date().toISOString(),
-            metadata: { command: "refine-tasks", action: "agent_refine", ...(metadata ?? {}) },
+            metadata: {
+                command: "refine-tasks",
+                action: "agent_refine",
+                phase: "agent_refine",
+                attempt: 1,
+                ...(metadata ?? {}),
+            },
         });
-        return { raw: output, promptTokens, completionTokens };
+        return { raw: output, promptTokens, completionTokens, agentId: agent.id };
     }
     async refineTasks(options) {
         const strategy = options.strategy ?? DEFAULT_STRATEGY;
@@ -1025,6 +1334,30 @@ export class RefineTasksService {
                 planOut: options.planOutPath,
             },
         });
+        let ratingAgentId;
+        const maybeRateAgent = async () => {
+            if (!options.rateAgents || !ratingAgentId)
+                return;
+            try {
+                const ratingService = this.ensureRatingService();
+                await ratingService.rate({
+                    workspace: this.workspace,
+                    agentId: ratingAgentId,
+                    commandName: "refine-tasks",
+                    jobId: job.id,
+                    commandRunId: commandRun.id,
+                });
+            }
+            catch (error) {
+                const message = `Agent rating failed: ${error.message ?? String(error)}`;
+                try {
+                    await this.jobService.appendLog(job.id, `${message}\n`);
+                }
+                catch {
+                    /* ignore rating log failures */
+                }
+            }
+        };
         try {
             if (options.fromDb === false) {
                 throw new Error("refine-tasks currently only supports DB-backed selection; set --from-db true");
@@ -1166,17 +1499,30 @@ export class RefineTasksService {
                             await this.logWarningsToTasks(group.tasks.map((t) => t.id), job.id, commandRun.id, docWarnings.join("; "));
                         }
                         const prompt = this.buildStoryPrompt(group, strategy, docSummary);
-                        const { raw } = await this.invokeAgent(options.agentName, prompt, agentStream, job.id, commandRun.id, { epicKey: group.epic.key, storyKey: group.story.key });
-                        const parsed = extractJson(raw);
-                        const ops = parsed?.operations && Array.isArray(parsed.operations) ? parsed.operations : [];
-                        const normalized = ops.map(normalizeOperation);
-                        const filtered = normalized.filter((op) => {
-                            const { valid, reason } = this.validateOperation(group, op);
-                            if (!valid && reason) {
-                                plan.warnings?.push(`Skipped op for story ${group.story.key}: ${reason}`);
+                        const parseOps = (raw) => {
+                            const parsed = normalizePlanJson(extractJson(raw));
+                            const ops = parsed?.operations && Array.isArray(parsed.operations) ? parsed.operations : [];
+                            const normalized = ops.map(normalizeOperation);
+                            return normalized.filter((op) => {
+                                const { valid, reason } = this.validateOperation(group, op);
+                                if (!valid && reason) {
+                                    plan.warnings?.push(`Skipped op for story ${group.story.key}: ${reason}`);
+                                }
+                                return valid;
+                            });
+                        };
+                        const { raw, agentId } = await this.invokeAgent(options.agentName, prompt, agentStream, job.id, commandRun.id, { epicKey: group.epic.key, storyKey: group.story.key });
+                        ratingAgentId = agentId;
+                        let filtered = parseOps(raw);
+                        if (filtered.length === 0) {
+                            const retryPrompt = `${prompt}\n\nRETRY: Your previous response did not match the JSON schema. Return only a JSON object with an operations array (no prose, no markdown, no <think> tags).`;
+                            const retry = await this.invokeAgent(options.agentName, retryPrompt, agentStream, job.id, commandRun.id, { epicKey: group.epic.key, storyKey: group.story.key, retry: true });
+                            ratingAgentId = retry.agentId;
+                            filtered = parseOps(retry.raw);
+                            if (filtered.length === 0) {
+                                plan.warnings?.push(`No valid operations returned for story ${group.story.key}.`);
                             }
-                            return valid;
-                        });
+                        }
                         plan.operations.push(...filtered);
                     }
                     catch (error) {
@@ -1198,7 +1544,7 @@ export class RefineTasksService {
                     return candidate;
                 }
             };
-            const defaultPlanPath = path.join(this.workspace.workspaceRoot, ".mcoda", "tasks", options.projectKey, "refinements", job.id, "plan.json");
+            const defaultPlanPath = path.join(this.workspace.mcodaDir, "tasks", options.projectKey, "refinements", job.id, "plan.json");
             const requestedOutPath = options.planOutPath ? path.resolve(options.planOutPath) : defaultPlanPath;
             const outPath = await ensureUniquePath(requestedOutPath);
             await fs.mkdir(path.dirname(outPath), { recursive: true });
@@ -1222,6 +1568,7 @@ export class RefineTasksService {
                     lastCheckpoint: "no_operations",
                 });
                 await this.jobService.finishCommandRun(commandRun.id, "succeeded");
+                await maybeRateAgent();
                 return {
                     jobId: job.id,
                     commandRunId: commandRun.id,
@@ -1246,6 +1593,7 @@ export class RefineTasksService {
                     lastCheckpoint: "dry_run",
                 });
                 await this.jobService.finishCommandRun(commandRun.id, "succeeded");
+                await maybeRateAgent();
                 return {
                     jobId: job.id,
                     commandRunId: commandRun.id,
@@ -1291,6 +1639,7 @@ export class RefineTasksService {
                 cancelled.push(...x);
                 storyPointsDelta += delta;
             }
+            await this.seedPriorities(options.projectKey);
             await this.jobService.updateJobStatus(job.id, "completed", {
                 payload: {
                     created: created.length,
@@ -1303,6 +1652,7 @@ export class RefineTasksService {
                 lastCheckpoint: "completed",
             });
             await this.jobService.finishCommandRun(commandRun.id, "succeeded");
+            await maybeRateAgent();
             return {
                 jobId: job.id,
                 commandRunId: commandRun.id,