scai 0.1.178 → 1.0.0

package/dist/__tests__/agents/decideNextAction.test.js

@@ -0,0 +1,1662 @@
+// Verifies the typed next-action bridge normalizes selector output and can trigger initial search/verify/research/plan seeding.
+// Pass example: missing bootstrap evidence becomes run-search before deeper loop work.
+import { describe, expect, it } from "vitest";
+import { buildAllowedNextActions, buildNextActionInput, decideNextAction, validateNextActionDecision, } from "../../agents/decideNextAction.js";
+describe("decideNextAction", () => {
+    it("returns complete when the selector marks the task complete", async () => {
+        const context = {
+            task: {
+                id: 1,
+                projectId: 1,
+                status: "active",
+                initialQuery: "Explain MainAgent.ts",
+                createdAt: "now",
+                updatedAt: "now",
+                currentStep: { taskId: 1, filePath: "/repo/MainAgent.ts", status: "pending" },
+                steps: [
+                    { taskId: 1, filePath: "__research__/impact-map", status: "completed", action: "research-impact-map" },
+                    { taskId: 1, filePath: "/repo/MainAgent.ts", status: "pending", action: "work" },
+                ],
+            },
+            initContext: {
+                userQuery: "Explain MainAgent.ts",
+                relatedFiles: ["/repo/MainAgent.ts"],
+            },
+            analysis: {
+                runtimeState: {
+                    phase: "execute",
+                    lane: "explicit-target",
+                    status: "active",
+                },
+                readiness: {
+                    decision: "ready",
+                    confidence: 0.95,
+                },
+                executionPolicy: {
+                    phaseAllowed: { analysis: true, planning: true, transform: false, write: false },
+                    routeAllowed: { searchExpand: false, research: true, transform: false },
+                    scopeType: "single-file",
+                    scopeBand: "single-file",
+                    executionRequired: ["/repo/MainAgent.ts"],
+                    explorationCandidates: [],
+                    executionLock: { enabled: false, files: [] },
+                    executionReady: true,
+                    explorationReady: false,
+                    policyNotes: [],
+                },
+            },
+        };
+        const decision = await decideNextAction(context, {
+            runSelection: async (ctx) => {
+                ctx.analysis || (ctx.analysis = {});
+                ctx.analysis.iterationReasoning = {
+                    summary: "done",
+                    nextAction: "complete",
+                    rationale: "Objective satisfied.",
+                    confidence: 0.99,
+                };
+            },
+        });
+        expect(decision.action).toBe("complete");
+        expect(decision.reason).toBe("Objective satisfied.");
+        expect(context.analysis.nextActionDecision).toEqual(decision);
+        expect(context.analysis.nextActionValidation).toEqual({
+            accepted: true,
+            normalizedAction: "complete",
+        });
+    });
+    it("normalizes invalid selector actions to continue", async () => {
+        const context = {
+            task: {
+                id: 1,
+                projectId: 1,
+                status: "active",
+                initialQuery: "Explain MainAgent.ts",
+                createdAt: "now",
+                updatedAt: "now",
+                currentStep: { taskId: 1, filePath: "/repo/MainAgent.ts", status: "pending" },
+                steps: [
+                    { taskId: 1, filePath: "__research__/impact-map", status: "completed", action: "research-impact-map" },
+                    { taskId: 1, filePath: "/repo/MainAgent.ts", status: "pending", action: "work" },
+                ],
+            },
+            initContext: {
+                userQuery: "Explain MainAgent.ts",
+                relatedFiles: ["/repo/MainAgent.ts"],
+            },
+            analysis: {
+                runtimeState: {
+                    phase: "execute",
+                    lane: "coding",
+                    status: "active",
+                },
+                readiness: {
+                    decision: "ready",
+                    confidence: 0.95,
+                },
+                executionPolicy: {
+                    phaseAllowed: { analysis: true, planning: true, transform: true, write: true },
+                    routeAllowed: { searchExpand: false, research: true, transform: true },
+                    scopeType: "single-file",
+                    scopeBand: "single-file",
+                    executionRequired: ["/repo/MainAgent.ts"],
+                    explorationCandidates: [],
+                    executionLock: { enabled: false, files: [] },
+                    executionReady: true,
+                    explorationReady: false,
+                    policyNotes: [],
+                },
+            },
+        };
+        const decision = await decideNextAction(context, {
+            runSelection: async (ctx) => {
+                ctx.analysis || (ctx.analysis = {});
+                ctx.analysis.iterationReasoning = {
+                    summary: "bad",
+                    nextAction: "redo-step",
+                    rationale: "Validation wants a redo.",
+                    confidence: 0.6,
+                };
+            },
+        });
+        expect(decision.action).toBe("continue");
+        expect(decision.reason).toBe("Validation wants a redo.");
+        expect(context.analysis.nextActionValidation).toEqual({
+            accepted: false,
+            normalizedAction: "continue",
+            rejectionReason: "Unsupported next action: redo-step",
+        });
+    });
+    it("returns run-search when initial search is still needed", async () => {
+        const context = {
+            task: {
+                id: 1,
+                projectId: 1,
+                status: "active",
+                initialQuery: "Refactor MainAgent.ts",
+                createdAt: "now",
+                updatedAt: "now",
+                steps: [],
+            },
+            analysis: {
+                runtimeState: {
+                    phase: "execute",
+                    lane: "coding",
+                    status: "active",
+                },
+            },
+        };
+        const decision = await decideNextAction(context, {
+            runSelection: async (ctx) => {
+                ctx.analysis || (ctx.analysis = {});
+                ctx.analysis.iterationReasoning = {
+                    summary: "continue",
+                    nextAction: "continue",
+                    rationale: "Need the initial bootstrap search first.",
+                    confidence: 0.7,
+                };
+            },
+        });
+        expect(decision).toEqual({
+            action: "run-search",
+            reason: "Initial evidence bootstrap has not run yet; run search before verify or execution seeding.",
+            confidence: 0.93,
+            source: "reason-next-step-selection",
+        });
+        expect(buildAllowedNextActions(context)).toEqual(["run-search"]);
+    });
+    it("suppresses repeated empty search and advances to verify instead", () => {
+        const context = {
+            task: {
+                id: 1,
+                projectId: 1,
+                status: "active",
+                initialQuery: "summarize architecture",
+                createdAt: "now",
+                updatedAt: "now",
+                steps: [],
+            },
+            initContext: {
+                userQuery: "summarize architecture",
+            },
+            analysis: {
+                recentActionWindow: {
+                    entries: [{
+                            taskId: 1,
+                            actionKind: "search-db",
+                            target: "summarize architecture",
+                            reason: "Initial search",
+                            outcome: "empty",
+                            summary: "Search found nothing useful.",
+                            touchedFiles: [],
+                            createdAt: "now",
+                        }],
+                },
+            },
+        };
+        expect(buildAllowedNextActions(context)).toEqual(["run-verify"]);
+    });
+    it("forces rework-scope only when recovery evaluation explicitly requests it", async () => {
+        const targetFile = "/repo/README.md";
+        const context = {
+            task: {
+                id: 1,
+                projectId: 1,
+                status: "active",
+                initialQuery: "Refactor MainAgent.ts",
+                createdAt: "now",
+                updatedAt: "now",
+                currentStep: { taskId: 1, filePath: targetFile, status: "pending" },
+                steps: [],
+            },
+            analysis: {
+                recoveryEvaluation: {
+                    decision: "rework-scope",
+                    reason: "Quick read shows the target is wrong.",
+                    targetFile,
+                    evaluatedAt: "now",
+                    sourceAction: "read-file",
+                },
+            },
+        };
+        const decision = await decideNextAction(context, {
+            runSelection: async (ctx) => {
+                ctx.analysis || (ctx.analysis = {});
+                ctx.analysis.iterationReasoning = {
+                    summary: "continue",
+                    nextAction: "continue",
+                    rationale: "Keep going.",
+                    confidence: 0.3,
+                };
+            },
+        });
+        expect(buildAllowedNextActions(context)).toEqual(["rework-scope"]);
+        expect(decision.action).toBe("rework-scope");
+        expect(decision.reason).toContain("wrong");
+    });
+    it("includes recent action history in next-action input", () => {
+        const context = {
+            task: {
+                id: 1,
+                projectId: 1,
+                status: "active",
+                initialQuery: "Explain MainAgent.ts",
+                createdAt: "now",
+                updatedAt: "now",
+                steps: [],
+            },
+            analysis: {
+                recentActionWindow: {
+                    entries: [{
+                            taskId: 1,
+                            actionKind: "semanticAnalysis",
+                            target: "/repo/MainAgent.ts",
+                            reason: "Inspect current file",
+                            outcome: "success",
+                            summary: "Semantic analysis completed.",
+                            touchedFiles: ["/repo/MainAgent.ts"],
+                            createdAt: "now",
+                        }],
+                },
+            },
+        };
+        expect(buildNextActionInput(context).recentActionWindow?.entries).toHaveLength(1);
+    });
+    it("uses guardState as the authoritative source for forced bridge actions", () => {
+        const context = {
+            task: {
+                id: 1,
+                projectId: 1,
+                status: "active",
+                initialQuery: "summarize architecture",
+                createdAt: "now",
+                updatedAt: "now",
+                steps: [],
+            },
+            analysis: {
+                guardState: {
+                    lane: "evidence",
+                    readiness: "ready",
+                    continuationMode: "can-research",
+                    allowSearchExpand: true,
+                    allowResearch: true,
+                    allowTransform: false,
+                    executionReady: false,
+                    executionLockEnabled: false,
+                    executionRequired: [],
+                },
+            },
+        };
+        expect(buildAllowedNextActions(context)).toEqual(["seed-research"]);
+        expect(buildNextActionInput(context).guardState?.continuationMode).toBe("can-research");
+    });
+    it("keeps forced run-search when the selector tries to complete with no scoped files", async () => {
+        const context = {
+            task: {
+                id: 1,
+                projectId: 1,
+                status: "active",
+                initialQuery: "summarize this repo architecture and identify weak coupling points",
+                createdAt: "now",
+                updatedAt: "now",
+                steps: [],
+            },
+            initContext: {
+                userQuery: "summarize this repo architecture and identify weak coupling points",
+                relatedFiles: [],
+            },
+            analysis: {
+                guardState: {
+                    lane: "evidence",
+                    readiness: "ready",
+                    continuationMode: "need-search",
+                    allowSearchExpand: true,
+                    allowResearch: true,
+                    allowTransform: false,
+                    executionReady: false,
+                    executionLockEnabled: false,
+                    executionRequired: [],
+                },
+                runtimeState: {
+                    phase: "execute",
+                    lane: "evidence",
+                    status: "active",
+                },
+                scopeType: "repo-wide",
+                focus: {
+                    selectedFiles: [],
+                    candidateFiles: [],
+                    executionRequired: [],
+                    explorationCandidates: [],
+                },
+                routingDecision: {
+                    decision: "needs-info",
+                    allowSearch: true,
+                    allowResearch: true,
+                    allowTransform: false,
+                    scopeLocked: false,
+                    confidence: 0.88,
+                    rationale: "repo-wide needs info",
+                },
+                executionPolicy: {
+                    phaseAllowed: { analysis: true, planning: true, transform: false, write: false },
+                    routeAllowed: { searchExpand: true, research: true, transform: false },
+                    scopeType: "repo-wide",
+                    scopeBand: "repo-wide",
+                    executionRequired: [],
+                    explorationCandidates: [],
+                    executionLock: { enabled: false, files: [], reason: "transform-blocked-by-guards" },
+                    executionReady: false,
+                    explorationReady: false,
+                    policyNotes: [],
+                },
+            },
+            workingFiles: [],
+        };
+        const decision = await decideNextAction(context);
+        expect(buildAllowedNextActions(context)).toEqual(["run-search"]);
+        expect(decision).toEqual({
+            action: "run-search",
+            reason: "Initial evidence bootstrap has not run yet; run search before verify or execution seeding.",
+            confidence: 0.93,
+            source: "reason-next-step-selection",
+        });
+        expect(context.analysis.nextActionValidation).toEqual({
+            accepted: true,
+            normalizedAction: "run-search",
+        });
+    });
+    it("keeps forced run-search when the selector tries to expand scope", async () => {
+        const context = {
+            task: {
+                id: 1,
+                projectId: 1,
+                status: "active",
+                initialQuery: "Refactor MainAgent.ts",
+                createdAt: "now",
+                updatedAt: "now",
+                steps: [],
+            },
+            analysis: {
+                runtimeState: {
+                    phase: "execute",
+                    lane: "coding",
+                    status: "active",
+                },
+            },
+        };
+        const decision = await decideNextAction(context, {
+            runSelection: async (ctx) => {
+                ctx.analysis || (ctx.analysis = {});
+                ctx.analysis.iterationReasoning = {
+                    summary: "expand",
+                    nextAction: "expand-scope",
+                    rationale: "Try broader exploration first.",
+                    confidence: 0.8,
+                };
+            },
+        });
+        expect(decision.action).toBe("run-search");
+        expect(context.analysis.nextActionValidation).toEqual({
+            accepted: true,
+            normalizedAction: "run-search",
+        });
+    });
+    it("returns run-verify when execution is not ready yet", async () => {
+        const context = {
+            task: {
+                id: 1,
+                projectId: 1,
+                status: "active",
+                initialQuery: "Refactor MainAgent.ts",
+                createdAt: "now",
+                updatedAt: "now",
+                steps: [],
+            },
+            initContext: {
+                userQuery: "Refactor MainAgent.ts",
+                relatedFiles: ["/repo/a.ts"],
+            },
+            analysis: {
+                runtimeState: {
+                    phase: "execute",
+                    lane: "coding",
+                    status: "active",
+                },
+                readiness: {
+                    decision: "not-ready",
+                    confidence: 0.45,
+                },
+                executionPolicy: {
+                    phaseAllowed: { analysis: true, planning: true, transform: true, write: true },
+                    routeAllowed: { searchExpand: false, research: true, transform: true },
+                    scopeType: "single-file",
+                    scopeBand: "single-file",
+                    executionRequired: ["/repo/a.ts"],
+                    explorationCandidates: [],
+                    executionLock: { enabled: false, files: [] },
+                    executionReady: false,
+                    explorationReady: false,
+                    policyNotes: [],
+                },
+            },
+        };
+        const decision = await decideNextAction(context, {
+            runSelection: async (ctx) => {
+                ctx.analysis || (ctx.analysis = {});
+                ctx.analysis.iterationReasoning = {
+                    summary: "continue",
+                    nextAction: "continue",
+                    rationale: "Need stronger evidence first.",
+                    confidence: 0.7,
+                };
+            },
+        });
+        expect(decision).toEqual({
+            action: "run-verify",
+            reason: "Execution is not ready yet; run verify before seeding research or execution work.",
+            confidence: 0.92,
+            source: "reason-next-step-selection",
+        });
+        expect(buildAllowedNextActions(context)).toEqual(["run-verify"]);
+    });
+    it("does not return run-verify when readiness is ready and research is still allowed", async () => {
+        const context = {
+            task: {
+                id: 1,
+                projectId: 1,
+                status: "active",
+                initialQuery: "summarize this repo architecture and identify weak coupling points",
+                createdAt: "now",
+                updatedAt: "now",
+                steps: [],
+            },
+            initContext: {
+                userQuery: "summarize this repo architecture and identify weak coupling points",
+                relatedFiles: ["/repo/README.md"],
+            },
+            analysis: {
+                scopeType: "repo-wide",
+                runtimeState: {
+                    phase: "execute",
+                    lane: "evidence",
+                    status: "active",
+                },
+                readiness: {
+                    decision: "ready",
+                    confidence: 0.95,
+                },
+                executionPolicy: {
+                    phaseAllowed: { analysis: true, planning: true, transform: false, write: false },
+                    routeAllowed: { searchExpand: true, research: true, transform: false },
+                    scopeType: "repo-wide",
+                    scopeBand: "single-file",
+                    executionRequired: ["/repo/README.md"],
+                    explorationCandidates: ["/repo/AGENTS.md"],
+                    executionLock: { enabled: false, files: [], reason: "transform-blocked-by-guards" },
+                    executionReady: false,
+                    explorationReady: true,
+                    policyNotes: [],
+                },
+            },
+        };
+        const decision = await decideNextAction(context, {
+            runSelection: async (ctx) => {
+                ctx.analysis || (ctx.analysis = {});
+                ctx.analysis.iterationReasoning = {
+                    summary: "continue",
+                    nextAction: "continue",
+                    rationale: "Research should run next.",
+                    confidence: 0.8,
+                };
+            },
+        });
+        expect(buildAllowedNextActions(context)).toEqual(["seed-research"]);
+        expect(decision.action).toBe("seed-research");
+    });
+    it("does not return run-verify when readiness is ready and transform is disallowed", async () => {
+        const context = {
+            task: {
+                id: 1,
+                projectId: 1,
+                status: "active",
+                initialQuery: "Explain architecture",
+                createdAt: "now",
+                updatedAt: "now",
+                steps: [
+                    { taskId: 1, filePath: "__research__/impact-map", status: "pending", action: "research-impact-map" },
+                ],
+            },
+            initContext: {
+                userQuery: "Explain architecture",
+                relatedFiles: ["/repo/README.md"],
+            },
+            analysis: {
+                scopeType: "repo-wide",
+                runtimeState: {
+                    phase: "execute",
+                    lane: "evidence",
+                    status: "active",
+                },
+                readiness: {
+                    decision: "ready",
+                    confidence: 0.95,
+                },
+                executionPolicy: {
+                    phaseAllowed: { analysis: true, planning: true, transform: false, write: false },
+                    routeAllowed: { searchExpand: true, research: false, transform: false },
+                    scopeType: "repo-wide",
+                    scopeBand: "single-file",
+                    executionRequired: ["/repo/README.md"],
+                    explorationCandidates: [],
+                    executionLock: { enabled: false, files: [], reason: "transform-blocked-by-guards" },
+                    executionReady: false,
+                    explorationReady: false,
+                    policyNotes: [],
+                },
+            },
+        };
+        expect(buildAllowedNextActions(context)).toEqual(["seed-plan"]);
+    });
+    it("keeps forced run-verify when the selector tries to complete without grounded evidence", async () => {
+        const context = {
+            task: {
+                id: 1,
+                projectId: 1,
+                status: "active",
+                initialQuery: "Refactor MainAgent.ts",
+                createdAt: "now",
+                updatedAt: "now",
+                steps: [],
+            },
+            initContext: {
+                userQuery: "Refactor MainAgent.ts",
+                relatedFiles: ["/repo/a.ts"],
+            },
+            analysis: {
+                runtimeState: {
+                    phase: "execute",
+                    lane: "evidence",
+                    status: "active",
+                },
+                readiness: {
+                    decision: "not-ready",
+                    confidence: 0.45,
+                },
+                executionPolicy: {
+                    phaseAllowed: { analysis: true, planning: true, transform: true, write: true },
+                    routeAllowed: { searchExpand: false, research: true, transform: true },
+                    scopeType: "single-file",
+                    scopeBand: "single-file",
+                    executionRequired: ["/repo/a.ts"],
+                    explorationCandidates: [],
+                    executionLock: { enabled: false, files: [] },
+                    executionReady: false,
+                    explorationReady: false,
+                    policyNotes: [],
+                },
+            },
+        };
+        const decision = await decideNextAction(context, {
+            runSelection: async (ctx) => {
+                ctx.analysis || (ctx.analysis = {});
+                ctx.analysis.iterationReasoning = {
+                    summary: "done",
+                    nextAction: "complete",
+                    rationale: "Pretend we are already done.",
+                    confidence: 0.8,
+                };
+            },
+        });
+        expect(decision.action).toBe("run-verify");
+        expect(decision.reason).toBe("Execution is not ready yet; run verify before seeding research or execution work.");
+        expect(context.analysis.nextActionValidation).toEqual({
+            accepted: true,
+            normalizedAction: "run-verify",
+        });
+    });
+    it("returns seed-research when research is allowed and no research step exists yet", async () => {
+        const context = {
+            task: {
+                id: 1,
+                projectId: 1,
+                status: "active",
+                initialQuery: "Refactor MainAgent.ts",
+                createdAt: "now",
+                updatedAt: "now",
+                steps: [],
+            },
+            initContext: {
+                userQuery: "Refactor MainAgent.ts",
+                relatedFiles: ["/repo/a.ts"],
+            },
+            analysis: {
+                runtimeState: {
+                    phase: "execute",
+                    lane: "coding",
+                    status: "active",
+                },
+                readiness: {
+                    decision: "ready",
+                    confidence: 0.95,
+                },
+                executionPolicy: {
+                    phaseAllowed: { analysis: true, planning: true, transform: true, write: true },
+                    routeAllowed: { searchExpand: false, research: true, transform: true },
+                    scopeType: "single-file",
+                    scopeBand: "single-file",
+                    executionRequired: ["/repo/a.ts"],
+                    explorationCandidates: [],
+                    executionLock: { enabled: false, files: [] },
+                    executionReady: true,
+                    explorationReady: false,
+                    policyNotes: [],
+                },
+            },
+            executionControl: {
+                mode: "transform",
+                constraints: {
+                    allowFileWrites: true,
+                    allowPlanning: true,
+                    allowAnalysis: true,
+                },
+            },
+        };
+        const decision = await decideNextAction(context, {
+            runSelection: async (ctx) => {
+                ctx.analysis || (ctx.analysis = {});
+                ctx.analysis.iterationReasoning = {
+                    summary: "keep going",
+                    nextAction: "continue",
+                    rationale: "Work can continue after research.",
+                    confidence: 0.7,
+                };
+            },
+        });
+        expect(decision).toEqual({
+            action: "seed-research",
+            reason: "No research step exists yet; seed research before execution planning.",
+            confidence: 0.9,
+            source: "reason-next-step-selection",
+        });
+        expect(buildAllowedNextActions(context)).toEqual(["seed-research"]);
+    });
+    it("preserves give-up when the selector explicitly bypasses a singleton seed-research menu", async () => {
+        const context = {
+            task: {
+                id: 1,
+                projectId: 1,
+                status: "active",
+                initialQuery: "Refactor MainAgent.ts",
+                createdAt: "now",
+                updatedAt: "now",
+                steps: [],
+            },
+            initContext: {
+                userQuery: "Refactor MainAgent.ts",
+                relatedFiles: ["/repo/a.ts"],
+            },
+            analysis: {
+                runtimeState: {
+                    phase: "execute",
+                    lane: "coding",
+                    status: "active",
+                },
+                readiness: {
+                    decision: "ready",
+                    confidence: 0.95,
+                },
+                executionPolicy: {
+                    phaseAllowed: { analysis: true, planning: true, transform: true, write: true },
+                    routeAllowed: { searchExpand: false, research: true, transform: true },
+                    scopeType: "single-file",
+                    scopeBand: "single-file",
+                    executionRequired: ["/repo/a.ts"],
+                    explorationCandidates: [],
+                    executionLock: { enabled: false, files: [] },
+                    executionReady: true,
+                    explorationReady: false,
+                    policyNotes: [],
+                },
+            },
+        };
+        const decision = await decideNextAction(context, {
+            runSelection: async (ctx) => {
+                ctx.analysis || (ctx.analysis = {});
+                ctx.analysis.iterationReasoning = {
+                    summary: "give-up",
+                    nextAction: "give-up",
+                    rationale: "Abort before research starts.",
+                    confidence: 0.8,
+                };
+            },
+        });
+        expect(decision.action).toBe("seed-research");
+        expect(decision.reason).toBe("No research step exists yet; seed research before execution planning.");
+        expect(context.analysis.nextActionValidation).toEqual({
+            accepted: true,
+            normalizedAction: "seed-research",
+        });
+    });
+    it("returns seed-plan only after research seeding is not needed", async () => {
+        const context = {
+            task: {
+                id: 1,
+                projectId: 1,
+                status: "active",
+                initialQuery: "Refactor MainAgent.ts",
+                createdAt: "now",
+                updatedAt: "now",
+                steps: [
+                    { taskId: 1, filePath: "__research__/impact-map", status: "pending", action: "research-impact-map" },
+                ],
+            },
+            initContext: {
+                userQuery: "Refactor MainAgent.ts",
+                relatedFiles: ["/repo/a.ts"],
+            },
+            analysis: {
+                runtimeState: {
+                    phase: "execute",
+                    lane: "coding",
+                    status: "active",
+                },
+                readiness: {
+                    decision: "ready",
+                    confidence: 0.95,
+                },
+                executionPolicy: {
+                    phaseAllowed: { analysis: true, planning: true, transform: true, write: true },
+                    routeAllowed: { searchExpand: false, research: true, transform: true },
+                    scopeType: "single-file",
+                    scopeBand: "single-file",
+                    executionRequired: ["/repo/a.ts"],
+                    explorationCandidates: [],
+                    executionLock: { enabled: false, files: [] },
+                    executionReady: true,
+                    explorationReady: false,
+                    policyNotes: [],
+                },
+            },
+            executionControl: {
+                mode: "transform",
+                constraints: {
+                    allowFileWrites: true,
+                    allowPlanning: true,
+                    allowAnalysis: true,
+                },
+            },
+        };
+        const decision = await decideNextAction(context, {
+            runSelection: async (ctx) => {
+                ctx.analysis || (ctx.analysis = {});
+                ctx.analysis.iterationReasoning = {
+                    summary: "continue",
+                    nextAction: "continue",
+                    rationale: "Research exists, so planning should seed execution work next.",
+                    confidence: 0.88,
+                };
+            },
+        });
+        expect(decision.action).toBe("seed-plan");
+        expect(decision.reason).toBe("No eligible execution step exists yet; seed the current execution plan first.");
+        expect(buildAllowedNextActions(context)).toEqual(["seed-plan"]);
+    });
+    it("returns continue when research steps already exist", async () => {
+        const context = {
+            task: {
+                id: 1,
+                projectId: 1,
+                status: "active",
+                initialQuery: "Refactor MainAgent.ts",
+                createdAt: "now",
+                updatedAt: "now",
+                currentStep: { taskId: 1, filePath: "/repo/a.ts", status: "pending" },
+                steps: [
+                    { taskId: 1, filePath: "__research__/impact-map", status: "completed", action: "research-impact-map" },
+                    { taskId: 1, filePath: "/repo/a.ts", status: "pending", action: "work" },
+                ],
+            },
+            initContext: {
+                userQuery: "Refactor MainAgent.ts",
+                relatedFiles: ["/repo/a.ts"],
+            },
+            analysis: {
+                runtimeState: {
+                    phase: "execute",
+                    lane: "coding",
+                    status: "active",
+                },
+                readiness: {
+                    decision: "ready",
+                    confidence: 0.95,
+                },
+                executionPolicy: {
+                    phaseAllowed: { analysis: true, planning: true, transform: true, write: true },
+                    routeAllowed: { searchExpand: false, research: true, transform: true },
+                    scopeType: "single-file",
+                    scopeBand: "single-file",
+                    executionRequired: ["/repo/a.ts"],
+                    explorationCandidates: [],
+                    executionLock: { enabled: false, files: [] },
+                    executionReady: true,
+                    explorationReady: false,
+                    policyNotes: [],
+                },
+            },
+            executionControl: {
+                mode: "transform",
+                constraints: {
+                    allowFileWrites: true,
+                    allowPlanning: true,
+                    allowAnalysis: true,
+                },
+            },
+        };
+        const decision = await decideNextAction(context, {
+            runSelection: async (ctx) => {
+                ctx.analysis || (ctx.analysis = {});
+                ctx.analysis.iterationReasoning = {
+                    summary: "continue",
+                    nextAction: "continue",
+                    rationale: "Pending execution step is ready.",
+                    confidence: 0.88,
+                };
+            },
+        });
+        expect(decision.action).toBe("continue");
+        expect(decision.reason).toBe("Pending execution step is ready.");
+        expect(decision.targetFile).toBe("/repo/a.ts");
+    });
+    it("does not return run-verify once the initial verify bridge has been consumed", async () => {
+        const context = {
+            task: {
+                id: 1,
+                projectId: 1,
+                status: "active",
+                initialQuery: "Refactor MainAgent.ts",
+                createdAt: "now",
+                updatedAt: "now",
+                steps: [],
+            },
+            initContext: {
+                userQuery: "Refactor MainAgent.ts",
+                relatedFiles: ["/repo/a.ts"],
+            },
+            analysis: {
+                runtimeState: {
+                    phase: "execute",
+                    lane: "coding",
+                    status: "active",
+                },
+                readiness: {
+                    decision: "not-ready",
+                    confidence: 0.4,
+                },
+                executionPolicy: {
+                    phaseAllowed: { analysis: true, planning: true, transform: true, write: true },
+                    routeAllowed: { searchExpand: false, research: true, transform: true },
+                    scopeType: "single-file",
+                    scopeBand: "single-file",
+                    executionRequired: ["/repo/a.ts"],
+                    explorationCandidates: [],
+                    executionLock: { enabled: false, files: [] },
+                    executionReady: false,
+                    explorationReady: false,
+                    policyNotes: [],
+                },
+            },
+            executionControl: {
+                mode: "transform",
+                constraints: {
+                    allowFileWrites: true,
+                    allowPlanning: true,
+                    allowAnalysis: true,
+                },
+            },
+        };
+        const decision = await decideNextAction(context, {
+            allowRunSearch: false,
+            allowRunVerify: false,
+            runSelection: async (ctx) => {
+                ctx.analysis || (ctx.analysis = {});
+                ctx.analysis.iterationReasoning = {
+                    summary: "continue",
+                    nextAction: "continue",
+                    rationale: "No execution step exists yet.",
+                    confidence: 0.5,
+                };
+            },
+        });
+        expect(decision.action).toBe("seed-research");
+        expect(decision.reason).toBe("No research step exists yet; seed research before execution planning.");
+    });
+    it("returns run-search before run-verify when both would otherwise apply", async () => {
+        const context = {
+            task: {
+                id: 1,
+                projectId: 1,
+                status: "active",
+                initialQuery: "Refactor MainAgent.ts",
+                createdAt: "now",
+                updatedAt: "now",
+                steps: [],
+            },
+            analysis: {
+                runtimeState: {
+                    phase: "execute",
+                    lane: "coding",
+                    status: "active",
+                },
+                readiness: {
+                    decision: "not-ready",
+                    confidence: 0.4,
+                },
+                executionPolicy: {
+                    phaseAllowed: { analysis: true, planning: true, transform: true, write: true },
+                    routeAllowed: { searchExpand: false, research: true, transform: true },
+                    scopeType: "single-file",
+                    scopeBand: "single-file",
+                    executionRequired: ["/repo/a.ts"],
+                    explorationCandidates: [],
+                    executionLock: { enabled: false, files: [] },
+                    executionReady: false,
+                    explorationReady: false,
+                    policyNotes: [],
+                },
+            },
+        };
+        const decision = await decideNextAction(context, {
+            runSelection: async (ctx) => {
+                ctx.analysis || (ctx.analysis = {});
+                ctx.analysis.iterationReasoning = {
+                    summary: "continue",
+                    nextAction: "continue",
+                    rationale: "Bootstrap search should happen before verify.",
+                    confidence: 0.7,
+                };
+            },
+        });
+        expect(decision.action).toBe("run-search");
+    });
+    it("returns seed-research before seed-plan once verify is ready", async () => {
+        const context = {
+            task: {
+                id: 1,
+                projectId: 1,
+                status: "active",
+                initialQuery: "Refactor MainAgent.ts",
+                createdAt: "now",
+                updatedAt: "now",
+                steps: [],
+            },
+            initContext: {
+                userQuery: "Refactor MainAgent.ts",
+                relatedFiles: ["/repo/a.ts"],
+            },
+            analysis: {
+                runtimeState: {
+                    phase: "execute",
+                    lane: "coding",
+                    status: "active",
+                },
+                readiness: {
+                    decision: "ready",
+                    confidence: 0.95,
+                },
+                executionPolicy: {
+                    phaseAllowed: { analysis: true, planning: true, transform: true, write: true },
+                    routeAllowed: { searchExpand: false, research: true, transform: true },
+                    scopeType: "single-file",
+                    scopeBand: "single-file",
+                    executionRequired: ["/repo/a.ts"],
+                    explorationCandidates: [],
+                    executionLock: { enabled: false, files: [] },
+                    executionReady: true,
+                    explorationReady: false,
+                    policyNotes: [],
+                },
+            },
+            executionControl: {
+                mode: "transform",
+                constraints: {
+                    allowFileWrites: true,
+                    allowPlanning: true,
+                    allowAnalysis: true,
+                },
+            },
+        };
+        const decision = await decideNextAction(context, {
+            runSelection: async (ctx) => {
+                ctx.analysis || (ctx.analysis = {});
+                ctx.analysis.iterationReasoning = {
+                    summary: "continue",
+                    nextAction: "continue",
+                    rationale: "Verify is done, so seed research next.",
+                    confidence: 0.7,
+                };
+            },
+        });
+        expect(decision.action).toBe("seed-research");
+    });
+    it("does not return run-verify once readiness is already ready", async () => {
+        const context = {
+            task: {
+                id: 1,
+                projectId: 1,
+                status: "active",
+                initialQuery: "Refactor MainAgent.ts",
+                createdAt: "now",
+                updatedAt: "now",
+                steps: [
+                    { taskId: 1, filePath: "__research__/impact-map", status: "pending", action: "research-impact-map" },
+                ],
+            },
+            initContext: {
+                userQuery: "Refactor MainAgent.ts",
+                relatedFiles: ["/repo/a.ts"],
+            },
+            analysis: {
+                runtimeState: {
+                    phase: "execute",
+                    lane: "coding",
+                    status: "active",
+                },
+                readiness: {
+                    decision: "ready",
+                    confidence: 0.95,
+                },
+                executionPolicy: {
+                    phaseAllowed: { analysis: true, planning: true, transform: true, write: true },
+                    routeAllowed: { searchExpand: false, research: true, transform: true },
+                    scopeType: "single-file",
+                    scopeBand: "single-file",
+                    executionRequired: ["/repo/a.ts"],
+                    explorationCandidates: [],
+                    executionLock: { enabled: false, files: [] },
+                    executionReady: true,
+                    explorationReady: false,
+                    policyNotes: [],
+                },
+            },
+            executionControl: {
+                mode: "transform",
+                constraints: {
+                    allowFileWrites: true,
+                    allowPlanning: true,
+                    allowAnalysis: true,
+                },
+            },
+        };
+        const decision = await decideNextAction(context, {
+            runSelection: async (ctx) => {
+                ctx.analysis || (ctx.analysis = {});
+                ctx.analysis.iterationReasoning = {
+                    summary: "continue",
+                    nextAction: "continue",
+                    rationale: "Verify is already ready.",
+                    confidence: 0.7,
+                };
+            },
+        });
+        expect(decision.action).toBe("seed-plan");
+        expect(decision.reason).toBe("No eligible execution step exists yet; seed the current execution plan first.");
+    });
+    it("does not return run-search once the initial search bridge has been consumed", async () => {
+        const context = {
+            task: {
+                id: 1,
+                projectId: 1,
+                status: "active",
+                initialQuery: "Refactor MainAgent.ts",
+                createdAt: "now",
+                updatedAt: "now",
+                steps: [],
+            },
+            initContext: {
+                userQuery: "Refactor MainAgent.ts",
+                relatedFiles: ["/repo/a.ts"],
+            },
+            analysis: {
+                runtimeState: {
+                    phase: "execute",
+                    lane: "coding",
+                    status: "active",
+                },
+                readiness: {
+                    decision: "not-ready",
+                    confidence: 0.4,
+                },
+                executionPolicy: {
+                    phaseAllowed: { analysis: true, planning: true, transform: true, write: true },
+                    routeAllowed: { searchExpand: false, research: true, transform: true },
+                    scopeType: "single-file",
+                    scopeBand: "single-file",
+                    executionRequired: ["/repo/a.ts"],
+                    explorationCandidates: [],
+                    executionLock: { enabled: false, files: [] },
+                    executionReady: false,
+                    explorationReady: false,
+                    policyNotes: [],
+                },
+            },
+        };
+        const decision = await decideNextAction(context, {
+            allowRunSearch: false,
+            runSelection: async (ctx) => {
+                ctx.analysis || (ctx.analysis = {});
+                ctx.analysis.iterationReasoning = {
+                    summary: "continue",
+                    nextAction: "continue",
+                    rationale: "Search already happened, so verify should run next.",
+                    confidence: 0.7,
+                };
+            },
+        });
+        expect(decision.action).toBe("run-verify");
+    });
+    it("does not return run-search when explicit-target seeding already satisfies bootstrap", async () => {
+        const context = {
+            task: {
+                id: 1,
+                projectId: 1,
+                status: "active",
+                initialQuery: "Refactor MainAgent.ts",
+                createdAt: "now",
+                updatedAt: "now",
+                steps: [],
+            },
+            analysis: {
+                intent: {
+                    resolvedTargetFiles: ["/repo/a.ts"],
+                },
+                runtimeState: {
+                    phase: "execute",
+                    lane: "explicit-target",
+                    status: "active",
+                },
+                readiness: {
+                    decision: "not-ready",
+                    confidence: 0.4,
+                },
+                executionPolicy: {
+                    phaseAllowed: { analysis: true, planning: true, transform: true, write: true },
+                    routeAllowed: { searchExpand: false, research: true, transform: true },
+                    scopeType: "single-file",
+                    scopeBand: "single-file",
+                    executionRequired: ["/repo/a.ts"],
+                    explorationCandidates: [],
+                    executionLock: { enabled: false, files: [] },
+                    executionReady: false,
+                    explorationReady: false,
+                    policyNotes: [],
+                },
+            },
+        };
+        const decision = await decideNextAction(context, {
+            runSelection: async (ctx) => {
+                ctx.analysis || (ctx.analysis = {});
+                ctx.analysis.iterationReasoning = {
+                    summary: "continue",
+                    nextAction: "continue",
+                    rationale: "Explicit target already supplies the bootstrap path.",
+                    confidence: 0.7,
+                };
+            },
+        });
+        expect(decision.action).toBe("run-verify");
+    });
+    it("does not return seed-plan once the loop has already consumed the initial planning bridge", async () => {
+        const context = {
+            task: {
+                id: 1,
+                projectId: 1,
+                status: "active",
+                initialQuery: "Refactor MainAgent.ts",
+                createdAt: "now",
+                updatedAt: "now",
+                steps: [
+                    { taskId: 1, filePath: "__research__/impact-map", status: "pending", action: "research-impact-map" },
+                ],
+            },
+            initContext: {
+                userQuery: "Refactor MainAgent.ts",
+                relatedFiles: ["/repo/a.ts"],
+            },
+            analysis: {
+                runtimeState: {
+                    phase: "execute",
+                    lane: "coding",
+                    status: "active",
+                },
+                readiness: {
+                    decision: "ready",
+                    confidence: 0.95,
+                },
+                executionPolicy: {
+                    phaseAllowed: { analysis: true, planning: true, transform: true, write: true },
+                    routeAllowed: { searchExpand: false, research: true, transform: true },
+                    scopeType: "single-file",
+                    scopeBand: "single-file",
+                    executionRequired: ["/repo/a.ts"],
+                    explorationCandidates: [],
+                    executionLock: { enabled: false, files: [] },
+                    executionReady: true,
+                    explorationReady: false,
+                    policyNotes: [],
+                },
+            },
+            executionControl: {
+                mode: "transform",
+                constraints: {
+                    allowFileWrites: true,
+                    allowPlanning: true,
+                    allowAnalysis: true,
+                },
+            },
+        };
+        const decision = await decideNextAction(context, {
+            allowSeedPlan: false,
+            runSelection: async (ctx) => {
+                ctx.analysis || (ctx.analysis = {});
+                ctx.analysis.iterationReasoning = {
+                    summary: "continue",
+                    nextAction: "continue",
+                    rationale: "No execution step exists yet.",
+                    confidence: 0.5,
+                };
+            },
+        });
+        expect(decision.action).toBe("continue");
+    });
+    it("captures pending and completed steps in the typed next-action input", () => {
+        const input = buildNextActionInput({
+            task: {
+                id: 1,
+                projectId: 1,
+                status: "active",
+                initialQuery: "Explain MainAgent.ts",
+                createdAt: "now",
+                updatedAt: "now",
+                currentStep: { taskId: 1, filePath: "/repo/a.ts", status: "pending" },
+                steps: [
+                    { taskId: 1, filePath: "/repo/a.ts", status: "pending", action: "work" },
+                    { taskId: 1, filePath: "/repo/b.ts", status: "completed", action: "work" },
+                ],
+            },
+            analysis: {
+                runtimeState: {
+                    phase: "execute",
+                    lane: "coding",
+                    status: "active",
+                },
+                attemptCounters: {
+                    retriesByTarget: {
+                        "/repo/a.ts": 2,
+                    },
+                },
+            },
+        });
+        expect(input.allowedActions).toEqual([
+            "run-search",
+        ]);
+        expect(input.pendingSteps).toEqual([
+            { filePath: "/repo/a.ts", action: "work", status: "pending" },
+        ]);
+        expect(input.completedSteps).toEqual([
+            { filePath: "/repo/b.ts", action: "work", status: "completed" },
+        ]);
+        expect(input.retryCounters).toEqual({ "/repo/a.ts": 2 });
+    });
+    it("uses the non-bridge control menu once no bridge action applies", () => {
+        const context = {
+            task: {
+                id: 1,
+                projectId: 1,
+                status: "active",
+                initialQuery: "Refactor MainAgent.ts",
+                createdAt: "now",
+                updatedAt: "now",
+                currentStep: { taskId: 1, filePath: "/repo/a.ts", status: "pending" },
+                steps: [
+                    { taskId: 1, filePath: "__research__/impact-map", status: "completed", action: "research-impact-map" },
+                    { taskId: 1, filePath: "/repo/a.ts", status: "pending", action: "work" },
+                ],
+            },
+            initContext: {
+                userQuery: "Refactor MainAgent.ts",
+                relatedFiles: ["/repo/a.ts"],
+            },
+            analysis: {
+                runtimeState: {
+                    phase: "execute",
+                    lane: "coding",
+                    status: "active",
+                },
+                readiness: {
+                    decision: "ready",
+                    confidence: 0.95,
+                },
+                executionPolicy: {
+                    phaseAllowed: { analysis: true, planning: true, transform: true, write: true },
+                    routeAllowed: { searchExpand: false, research: true, transform: true },
+                    scopeType: "single-file",
+                    scopeBand: "single-file",
+                    executionRequired: ["/repo/a.ts"],
+                    explorationCandidates: [],
+                    executionLock: { enabled: false, files: [] },
+                    executionReady: true,
+                    explorationReady: false,
+                    policyNotes: [],
+                },
+            },
+        };
+        expect(buildAllowedNextActions(context)).toEqual([
+            "continue",
+            "expand-scope",
+            "rework-scope",
+            "request-feedback",
+            "complete",
+            "give-up",
+        ]);
+    });
+    it("normalizes globally valid but disallowed selector actions to continue", async () => {
+        const context = {
+            task: {
+                id: 1,
+                projectId: 1,
+                status: "active",
+                initialQuery: "Refactor MainAgent.ts",
+                createdAt: "now",
+                updatedAt: "now",
+                currentStep: { taskId: 1, filePath: "/repo/a.ts", status: "pending" },
+                steps: [
+                    { taskId: 1, filePath: "__research__/impact-map", status: "completed", action: "research-impact-map" },
+                    { taskId: 1, filePath: "/repo/a.ts", status: "pending", action: "work" },
+                ],
+            },
+            initContext: {
+                userQuery: "Refactor MainAgent.ts",
+                relatedFiles: ["/repo/a.ts"],
+            },
+            analysis: {
+                runtimeState: {
+                    phase: "execute",
+                    lane: "coding",
+                    status: "active",
+                },
+                readiness: {
+                    decision: "ready",
+                    confidence: 0.95,
+                },
+                executionPolicy: {
+                    phaseAllowed: { analysis: true, planning: true, transform: true, write: true },
+                    routeAllowed: { searchExpand: false, research: true, transform: true },
+                    scopeType: "single-file",
+                    scopeBand: "single-file",
+                    executionRequired: ["/repo/a.ts"],
+                    explorationCandidates: [],
+                    executionLock: { enabled: false, files: [] },
+                    executionReady: true,
+                    explorationReady: false,
+                    policyNotes: [],
+                },
+            },
+        };
+        const decision = await decideNextAction(context, {
+            runSelection: async (ctx) => {
+                ctx.analysis || (ctx.analysis = {});
+                ctx.analysis.iterationReasoning = {
+                    summary: "bad",
+                    nextAction: "run-verify",
+                    rationale: "Try to force verify anyway.",
+                    confidence: 0.7,
+                };
+            },
+        });
+        expect(decision.action).toBe("continue");
+        expect(context.analysis.nextActionValidation).toEqual({
+            accepted: false,
+            normalizedAction: "continue",
+            rejectionReason: "Action not allowed in current menu: run-verify",
+        });
+    });
+    it("keeps forced run-search when the selector tries to complete in an evidence lane", async () => {
+        const context = {
+            task: {
+                id: 1,
+                projectId: 1,
+                status: "active",
+                initialQuery: "Summarize architecture",
+                createdAt: "now",
+                updatedAt: "now",
+                steps: [],
+            },
+            analysis: {
+                runtimeState: {
+                    phase: "execute",
+                    lane: "evidence",
+                    status: "active",
+                },
+            },
+        };
+        const decision = await decideNextAction(context, {
+            runSelection: async (ctx) => {
+                ctx.analysis || (ctx.analysis = {});
+                ctx.analysis.iterationReasoning = {
+                    summary: "done",
+                    nextAction: "complete",
+                    rationale: "No further loop work is needed.",
+                    confidence: 0.99,
+                };
+            },
+        });
+        expect(decision.action).toBe("run-search");
+        expect(decision.reason).toBe("Initial evidence bootstrap has not run yet; run search before verify or execution seeding.");
+        expect(context.analysis.nextActionValidation).toEqual({
+            accepted: true,
+            normalizedAction: "run-search",
+        });
+    });
+    it("allows terminal bypass for continuity-local answers", async () => {
+        const context = {
+            task: {
+                id: 1,
+                projectId: 1,
+                status: "active",
+                initialQuery: "what should we do next?",
+                createdAt: "now",
+                updatedAt: "now",
+                steps: [],
+            },
+            analysis: {
+                guardState: {
+                    lane: "resume-continuity",
+                    readiness: "ready",
+                    continuationMode: "need-search",
+                    allowSearchExpand: true,
+                    allowResearch: false,
+                    allowTransform: false,
+                    executionReady: false,
+                    executionLockEnabled: false,
+                    executionRequired: [],
+                },
+                resumeIntent: {
+                    kind: "continuity-next-step",
+                    fastTrackEligible: true,
+                    answerFromResumeOnly: false,
+                    relevantResumeFiles: ["/repo/cli/src/agents/MainAgent.ts"],
+                    rationale: "resume",
+                },
+                continuityDecision: {
+                    kind: "direct-synthesized-answer",
+                    answerNow: true,
+                    fallbackRequired: false,
+                    rationale: "resume answer is local",
+                },
+            },
+        };
+        const decision = await decideNextAction(context, {
+            runSelection: async (ctx) => {
+                ctx.analysis || (ctx.analysis = {});
+                ctx.analysis.iterationReasoning = {
+                    summary: "done",
+                    nextAction: "complete",
+                    rationale: "Resume state already answers this.",
+                    confidence: 0.99,
+                };
+            },
+        });
+        expect(decision.action).toBe("complete");
+        expect(decision.reason).toBe("Resume state already answers this.");
+    });
+    it("allows terminal bypass for explicit-target answers that already have grounded evidence", async () => {
+        const targetFile = "/repo/MainAgent.ts";
+        const context = {
+            task: {
+                id: 1,
+                projectId: 1,
+                status: "active",
+                initialQuery: "Explain MainAgent.ts",
+                createdAt: "now",
+                updatedAt: "now",
+                steps: [],
+            },
+            initContext: {
+                userQuery: "Explain MainAgent.ts",
+                relatedFiles: [targetFile],
+            },
+            analysis: {
+                focus: {
+                    selectedFiles: [targetFile],
+                    resolvedTargetFiles: [targetFile],
+                    candidateFiles: [],
+                },
+                guardState: {
+                    lane: "explicit-target",
+                    readiness: "not-ready",
+                    continuationMode: "need-verify",
+                    allowSearchExpand: false,
+                    allowResearch: false,
+                    allowTransform: false,
+                    executionReady: false,
+                    executionLockEnabled: false,
+                    executionRequired: [targetFile],
+                },
+                readiness: {
+                    decision: "not-ready",
+                    confidence: 0.45,
+                },
+                executionPolicy: {
+                    phaseAllowed: { analysis: true, planning: true, transform: false, write: false },
+                    routeAllowed: { searchExpand: false, research: false, transform: false },
+                    scopeType: "single-file",
+                    scopeBand: "single-file",
+                    executionRequired: [targetFile],
+                    explorationCandidates: [],
+                    executionLock: { enabled: false, files: [] },
+                    executionReady: false,
+                    explorationReady: false,
+                    policyNotes: [],
+                },
+                verify: {
+                    byFile: {
+                        [targetFile]: {
+                            isRelevant: true,
+                            fileConfidence: 0.91,
+                        },
+                    },
+                },
+            },
+        };
+        const decision = await decideNextAction(context, {
+            runSelection: async (ctx) => {
+                ctx.analysis || (ctx.analysis = {});
+                ctx.analysis.iterationReasoning = {
+                    summary: "done",
+                    nextAction: "complete",
+                    rationale: "Exact-target evidence is already grounded enough.",
+                    confidence: 0.96,
+                };
+            },
+        });
+        expect(decision.action).toBe("complete");
+        expect(decision.reason).toBe("Exact-target evidence is already grounded enough.");
+    });
+    it("forces the singleton bridge when the selector emits a disallowed global action", async () => {
+        const context = {
+            task: {
+                id: 1,
+                projectId: 1,
+                status: "active",
+                initialQuery: "Summarize architecture",
+                createdAt: "now",
+                updatedAt: "now",
+                steps: [],
+            },
+            analysis: {
+                runtimeState: {
+                    phase: "execute",
+                    lane: "evidence",
+                    status: "active",
+                },
+            },
+        };
+        const decision = await decideNextAction(context, {
+            runSelection: async (ctx) => {
+                ctx.analysis || (ctx.analysis = {});
+                ctx.analysis.iterationReasoning = {
+                    summary: "bad",
+                    nextAction: "expand-scope",
+                    rationale: "Try to skip straight to expansion.",
+                    confidence: 0.6,
+                };
+            },
+        });
+        expect(decision).toEqual({
+            action: "run-search",
+            reason: "Initial evidence bootstrap has not run yet; run search before verify or execution seeding.",
+            confidence: 0.93,
+            source: "reason-next-step-selection",
+        });
+        expect(context.analysis.nextActionValidation).toEqual({
+            accepted: true,
+            normalizedAction: "run-search",
+        });
+    });
+});
+describe("validateNextActionDecision", () => {
+    it("accepts current loop actions and defaults missing actions to continue", () => {
+        expect(validateNextActionDecision("give-up")).toEqual({
+            accepted: true,
+            normalizedAction: "give-up",
+        });
+        expect(validateNextActionDecision("run-search")).toEqual({
+            accepted: true,
+            normalizedAction: "run-search",
+        });
+        expect(validateNextActionDecision("run-verify", ["continue"])).toEqual({
+            accepted: false,
+            normalizedAction: "continue",
+            rejectionReason: "Action not allowed in current menu: run-verify",
+        });
+        expect(validateNextActionDecision("run-verify")).toEqual({
+            accepted: true,
+            normalizedAction: "run-verify",
+        });
+        expect(validateNextActionDecision("seed-research")).toEqual({
+            accepted: true,
+            normalizedAction: "seed-research",
+        });
+        expect(validateNextActionDecision("seed-plan")).toEqual({
+            accepted: true,
+            normalizedAction: "seed-plan",
+        });
+        expect(validateNextActionDecision(undefined)).toEqual({
+            accepted: false,
+            normalizedAction: "continue",
+            rejectionReason: "Missing next action from iteration reasoning",
+        });
+    });
+});
+//# sourceMappingURL=decideNextAction.test.js.map