979cf115d9
The merge splits the large monolithic `executor.test.ts` into seven focused test suites covering core logic, pause behavior, prompt handling, recovery, review verdicts, step sessions, and worktree operations, and adds shell context hook plumbing across the dashboard, desktop, and mobile packages to Fusion-Task-Id: FN-3720
2160 lines
76 KiB
TypeScript
2160 lines
76 KiB
TypeScript
// -nocheck
|
|
/* eslint-disable -eslint/no-unused-vars */
|
|
import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
|
|
import "./executor-test-helpers.js";
|
|
import { AgentSemaphore } from "../concurrency.js";
|
|
import { detectReviewHandoffIntent, determineRevisionResetStart } from "../executor.js";
|
|
import { TaskExecutor, buildExecutionPrompt } from "../executor.js";
|
|
import { createFnAgent } from "../pi.js";
|
|
import { reviewStep as mockedReviewStepFn } from "../reviewer.js";
|
|
import { execSync } from "node:child_process";
|
|
import { findWorktreeUser, aiMergeTask } from "../merger.js";
|
|
import { WorktreePool } from "../worktree-pool.js";
|
|
import { generateWorktreeName, slugify } from "../worktree-names.js";
|
|
import type { Task, TaskDetail } from "@fusion/core";
|
|
import { SessionManager } from "@mariozechner/pi-coding-agent";
|
|
import { StepSessionExecutor } from "../step-session-executor.js";
|
|
import { executorLog } from "../logger.js";
|
|
import { withRateLimitRetry } from "../rate-limit-retry.js";
|
|
import { runVerificationCommand as mockedRunVerificationCommand } from "../verification-utils.js";
|
|
import {
|
|
createMockStore,
|
|
mockedCreateFnAgent,
|
|
mockedSessionManager,
|
|
mockedGenerateWorktreeName,
|
|
mockedFindWorktreeUser,
|
|
mockedStepSessionExecutor,
|
|
mockedWithRateLimitRetry,
|
|
mockedExecSync,
|
|
mockedExistsSync,
|
|
mockExecuteAll,
|
|
mockTerminateAllSessions,
|
|
mockCleanup,
|
|
resetExecutorMocks,
|
|
} from "./executor-test-helpers.js";
|
|
|
|
const mockedReviewStep = vi.mocked(mockedReviewStepFn);
|
|
|
|
function createMockTaskDetail(overrides: Partial<TaskDetail> = {}): TaskDetail {
|
|
return {
|
|
id: "FN-001",
|
|
title: "Test Task",
|
|
description: "A test task",
|
|
column: "in-progress",
|
|
dependencies: [],
|
|
steps: [],
|
|
currentStep: 0,
|
|
log: [],
|
|
prompt: "# test\n## Steps\n### Step 0: Preflight\n- [ ] check",
|
|
createdAt: new Date().toISOString(),
|
|
updatedAt: new Date().toISOString(),
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
describe("buildExecutionPrompt", () => {
|
|
it("includes attachment section with absolute paths for image attachments", () => {
|
|
const task = createMockTaskDetail({
|
|
attachments: [
|
|
{ filename: "abc123-screenshot.png", originalName: "screenshot.png", mimeType: "image/png", size: 2048, createdAt: new Date().toISOString() },
|
|
],
|
|
});
|
|
const result = buildExecutionPrompt(task, "/home/user/project");
|
|
|
|
expect(result).toContain("## Attachments");
|
|
expect(result).toContain("**screenshot.png** (screenshot)");
|
|
expect(result).toContain("/home/user/project/.fusion/tasks/FN-001/attachments/abc123-screenshot.png");
|
|
});
|
|
|
|
it("includes attachment section with absolute paths for text attachments", () => {
|
|
const task = createMockTaskDetail({
|
|
attachments: [
|
|
{ filename: "def456-error.log", originalName: "error.log", mimeType: "text/plain", size: 512, createdAt: new Date().toISOString() },
|
|
],
|
|
});
|
|
const result = buildExecutionPrompt(task, "/home/user/project");
|
|
|
|
expect(result).toContain("## Attachments");
|
|
expect(result).toContain("**error.log** (text/plain)");
|
|
expect(result).toContain("read for context");
|
|
expect(result).toContain("/home/user/project/.fusion/tasks/FN-001/attachments/def456-error.log");
|
|
});
|
|
|
|
it("includes both image and text attachments", () => {
|
|
const task = createMockTaskDetail({
|
|
attachments: [
|
|
{ filename: "abc-shot.png", originalName: "shot.png", mimeType: "image/png", size: 1024, createdAt: new Date().toISOString() },
|
|
{ filename: "def-config.json", originalName: "config.json", mimeType: "application/json", size: 256, createdAt: new Date().toISOString() },
|
|
],
|
|
});
|
|
const result = buildExecutionPrompt(task, "/home/user/project");
|
|
|
|
expect(result).toContain("**shot.png** (screenshot)");
|
|
expect(result).toContain("**config.json** (application/json)");
|
|
});
|
|
|
|
it("rewrites project-root absolute paths to the active worktree", () => {
|
|
const task = createMockTaskDetail({
|
|
prompt: [
|
|
"# test",
|
|
"## Context to Read First",
|
|
"- `/home/user/project/web/app/page.tsx`",
|
|
"- `/home/user/project/.fusion/memory/`",
|
|
"## Steps",
|
|
"### Step 0: Preflight",
|
|
"- [ ] inspect `/home/user/project/web/app/layout.tsx`",
|
|
].join("\n"),
|
|
});
|
|
|
|
const result = buildExecutionPrompt(
|
|
task,
|
|
"/home/user/project",
|
|
undefined,
|
|
"/home/user/project/.worktrees/happy-robin",
|
|
);
|
|
|
|
expect(result).toContain("/home/user/project/.worktrees/happy-robin/web/app/page.tsx");
|
|
expect(result).toContain("/home/user/project/.worktrees/happy-robin/web/app/layout.tsx");
|
|
expect(result).toContain("/home/user/project/.fusion/memory/");
|
|
expect(result).not.toContain("/home/user/project/.worktrees/happy-robin/.fusion/memory/");
|
|
});
|
|
|
|
it("omits attachment section when no attachments", () => {
|
|
const task = createMockTaskDetail({ attachments: [] });
|
|
const result = buildExecutionPrompt(task, "/home/user/project");
|
|
|
|
expect(result).not.toContain("## Attachments");
|
|
});
|
|
|
|
it("omits attachment section when attachments is undefined", () => {
|
|
const task = createMockTaskDetail();
|
|
const result = buildExecutionPrompt(task);
|
|
|
|
expect(result).not.toContain("## Attachments");
|
|
});
|
|
|
|
it("omits attachment section when rootDir is not provided", () => {
|
|
const task = createMockTaskDetail({
|
|
attachments: [
|
|
{ filename: "abc.png", originalName: "test.png", mimeType: "image/png", size: 1024, createdAt: new Date().toISOString() },
|
|
],
|
|
});
|
|
const result = buildExecutionPrompt(task);
|
|
|
|
expect(result).not.toContain("## Attachments");
|
|
});
|
|
|
|
it("includes Project Commands section with test command when settings.testCommand is set", () => {
|
|
const task = createMockTaskDetail();
|
|
const result = buildExecutionPrompt(task, "/home/user/project", {
|
|
testCommand: "pnpm test",
|
|
} as any);
|
|
|
|
expect(result).toContain("## Project Commands");
|
|
expect(result).toContain("- **Test:** `pnpm test`");
|
|
expect(result).not.toContain("- **Build:**");
|
|
});
|
|
|
|
it("includes Project Commands section with build command when settings.buildCommand is set", () => {
|
|
const task = createMockTaskDetail();
|
|
const result = buildExecutionPrompt(task, "/home/user/project", {
|
|
buildCommand: "pnpm build",
|
|
} as any);
|
|
|
|
expect(result).toContain("## Project Commands");
|
|
expect(result).toContain("- **Build:** `pnpm build`");
|
|
expect(result).not.toContain("- **Test:**");
|
|
});
|
|
|
|
it("includes both commands when both are set", () => {
|
|
const task = createMockTaskDetail();
|
|
const result = buildExecutionPrompt(task, "/home/user/project", {
|
|
testCommand: "pnpm test",
|
|
buildCommand: "pnpm build",
|
|
} as any);
|
|
|
|
expect(result).toContain("## Project Commands");
|
|
expect(result).toContain("- **Test:** `pnpm test`");
|
|
expect(result).toContain("- **Build:** `pnpm build`");
|
|
});
|
|
|
|
it("tells executors to fix quality-gate failures even outside initial file scope", () => {
|
|
const task = createMockTaskDetail();
|
|
const result = buildExecutionPrompt(task, "/home/user/project", {
|
|
testCommand: "pnpm test",
|
|
buildCommand: "pnpm build",
|
|
} as any);
|
|
|
|
expect(result).toContain("fix failures even when that requires edits outside the original File Scope");
|
|
expect(result).toContain("If the repo has a typecheck command, run it before `fn_task_done()`");
|
|
expect(result).toContain("not for fixes required to get tests, build, or typecheck back to green");
|
|
});
|
|
|
|
it("requires resolving ALL test failures, including unrelated or pre-existing ones", () => {
|
|
const task = createMockTaskDetail();
|
|
const result = buildExecutionPrompt(task, "/home/user/project", {
|
|
testCommand: "pnpm test",
|
|
buildCommand: "pnpm build",
|
|
} as any);
|
|
|
|
// The stricter language must be present to prevent "unrelated failure" deferrals
|
|
expect(result).toContain("Resolve ALL test failures");
|
|
expect(result).toContain("even if they appear unrelated or pre-existing");
|
|
expect(result).toContain("accumulate technical debt");
|
|
expect(result).toContain("Investigate and fix or suppress them");
|
|
expect(result).toContain("do not defer them to a separate task");
|
|
});
|
|
|
|
it("includes source issue reference in commit instruction when task has github sourceIssue", () => {
|
|
const task = createMockTaskDetail({
|
|
sourceIssue: {
|
|
provider: "github",
|
|
repository: "runfusion/fusion",
|
|
externalIssueId: "2915",
|
|
issueNumber: 2915,
|
|
},
|
|
} as any);
|
|
|
|
const result = buildExecutionPrompt(task, "/home/user/project");
|
|
expect(result).toContain('git commit -m "feat(FN-001): complete Step N — description" -m "Ref: runfusion/fusion#2915"');
|
|
});
|
|
|
|
it("falls back to externalIssueId for commit source issue reference when issueNumber is missing", () => {
|
|
const task = createMockTaskDetail({
|
|
sourceIssue: {
|
|
provider: "github",
|
|
repository: "runfusion/fusion",
|
|
externalIssueId: "2915",
|
|
},
|
|
} as any);
|
|
|
|
const result = buildExecutionPrompt(task, "/home/user/project");
|
|
expect(result).toContain('git commit -m "feat(FN-001): complete Step N — description" -m "Ref: runfusion/fusion#2915"');
|
|
});
|
|
|
|
it("omits source issue reference from commit instruction when sourceIssue is missing", () => {
|
|
const task = createMockTaskDetail();
|
|
const result = buildExecutionPrompt(task, "/home/user/project");
|
|
|
|
expect(result).toContain('git commit -m "feat(FN-001): complete Step N — description"');
|
|
expect(result).not.toContain(' -m "Ref:');
|
|
});
|
|
|
|
it("omits Project Commands section when neither command is set", () => {
|
|
const task = createMockTaskDetail();
|
|
const result = buildExecutionPrompt(task, "/home/user/project", {} as any);
|
|
|
|
expect(result).not.toContain("## Project Commands");
|
|
});
|
|
|
|
it("omits Project Commands section when settings is undefined", () => {
|
|
const task = createMockTaskDetail();
|
|
const result = buildExecutionPrompt(task);
|
|
|
|
expect(result).not.toContain("## Project Commands");
|
|
});
|
|
|
|
it("includes Steering Comments section when steeringComments has entries", () => {
|
|
const task = createMockTaskDetail({
|
|
steeringComments: [
|
|
{
|
|
id: "1",
|
|
text: "Please handle the edge case",
|
|
createdAt: new Date().toISOString(),
|
|
author: "user" as const,
|
|
},
|
|
],
|
|
});
|
|
const result = buildExecutionPrompt(task);
|
|
|
|
expect(result).toContain("## Steering Comments");
|
|
expect(result).toContain("**user**");
|
|
expect(result).toContain("> Please handle the edge case");
|
|
expect(result).toContain("The following comments were added by the user during execution");
|
|
});
|
|
|
|
it("formats multiple steering comments correctly", () => {
|
|
const now = new Date();
|
|
const task = createMockTaskDetail({
|
|
steeringComments: [
|
|
{
|
|
id: "1",
|
|
text: "First comment",
|
|
createdAt: new Date(now.getTime() - 60000).toISOString(), // 1 minute ago
|
|
author: "user" as const,
|
|
},
|
|
{
|
|
id: "2",
|
|
text: "Second comment",
|
|
createdAt: now.toISOString(),
|
|
author: "agent" as const,
|
|
},
|
|
],
|
|
});
|
|
const result = buildExecutionPrompt(task);
|
|
|
|
expect(result).toContain("**user**");
|
|
expect(result).toContain("**agent**");
|
|
expect(result).toContain("> First comment");
|
|
expect(result).toContain("> Second comment");
|
|
});
|
|
|
|
it("omits Steering Comments section when steeringComments is empty", () => {
|
|
const task = createMockTaskDetail({ steeringComments: [] });
|
|
const result = buildExecutionPrompt(task);
|
|
|
|
expect(result).not.toContain("## Steering Comments");
|
|
});
|
|
|
|
it("omits Steering Comments section when steeringComments is undefined", () => {
|
|
const task = createMockTaskDetail();
|
|
const result = buildExecutionPrompt(task);
|
|
|
|
expect(result).not.toContain("## Steering Comments");
|
|
});
|
|
|
|
it("includes only the 10 most recent steering comments", () => {
|
|
const steeringComments = Array.from({ length: 15 }, (_, i) => ({
|
|
id: `${i}`,
|
|
text: `Comment ${i}`,
|
|
createdAt: new Date().toISOString(),
|
|
author: "user" as const,
|
|
}));
|
|
|
|
const task = createMockTaskDetail({ steeringComments });
|
|
const result = buildExecutionPrompt(task);
|
|
|
|
// Should include comments 5-14 (the 10 most recent), not 0-4
|
|
expect(result).toContain("> Comment 5");
|
|
expect(result).toContain("> Comment 14");
|
|
expect(result).not.toContain("> Comment 0");
|
|
expect(result).not.toContain("> Comment 4");
|
|
});
|
|
|
|
it("end-to-end: steering comments are fully injected into execution prompt with correct format", () => {
|
|
const now = new Date();
|
|
const task = createMockTaskDetail({
|
|
id: "FN-123",
|
|
title: "Verify Steering Feature",
|
|
steeringComments: [
|
|
{
|
|
id: "sc-001",
|
|
text: "Please ensure all edge cases are handled in the validation logic",
|
|
createdAt: new Date(now.getTime() - 120000).toISOString(),
|
|
author: "user" as const,
|
|
},
|
|
{
|
|
id: "sc-002",
|
|
text: "Consider adding unit tests for the new utility function",
|
|
createdAt: new Date(now.getTime() - 60000).toISOString(),
|
|
author: "agent" as const,
|
|
},
|
|
{
|
|
id: "sc-003",
|
|
text: "Don't forget to update the documentation before completing",
|
|
createdAt: now.toISOString(),
|
|
author: "user" as const,
|
|
},
|
|
],
|
|
});
|
|
|
|
const result = buildExecutionPrompt(task, "/project", { testCommand: "pnpm test" } as any);
|
|
|
|
// Verify section header exists
|
|
expect(result).toContain("## Steering Comments");
|
|
|
|
// Verify explanatory header text
|
|
expect(result).toContain("The following comments were added by the user during execution");
|
|
expect(result).toContain("Consider adjusting your approach or replanning remaining steps based on this feedback");
|
|
|
|
// Verify all three comments appear with correct author badges
|
|
expect(result).toContain("**user**");
|
|
expect(result).toContain("**agent**");
|
|
|
|
// Verify quoted text format
|
|
expect(result).toContain("> Please ensure all edge cases are handled in the validation logic");
|
|
expect(result).toContain("> Consider adding unit tests for the new utility function");
|
|
expect(result).toContain("> Don't forget to update the documentation before completing");
|
|
|
|
// Verify timestamp formatting appears (either relative like "2m ago" or absolute)
|
|
// The formatTimestamp function returns relative times for recent comments
|
|
expect(result).toMatch(/\*\*user\*\* — \d+m? ago/);
|
|
|
|
// Verify the section appears in the expected location (after progress section, before review level)
|
|
const steeringSectionIndex = result.indexOf("## Steering Comments");
|
|
const reviewLevelIndex = result.indexOf("## Review level");
|
|
expect(steeringSectionIndex).toBeGreaterThan(0);
|
|
expect(reviewLevelIndex).toBeGreaterThan(steeringSectionIndex);
|
|
});
|
|
|
|
it("passes settings to buildExecutionPrompt in TaskExecutor.execute()", async () => {
|
|
const store = createMockStore();
|
|
store.getSettings.mockResolvedValue({
|
|
maxConcurrent: 2,
|
|
maxWorktrees: 4,
|
|
pollIntervalMs: 15000,
|
|
groupOverlappingFiles: false,
|
|
autoMerge: false,
|
|
testCommand: "npm test",
|
|
buildCommand: "npm run build",
|
|
});
|
|
|
|
const mockPrompt = vi.fn().mockResolvedValue(undefined);
|
|
mockedCreateFnAgent.mockResolvedValue({
|
|
session: {
|
|
prompt: mockPrompt,
|
|
dispose: vi.fn(),
|
|
},
|
|
} as any);
|
|
|
|
const executor = new TaskExecutor(store, "/tmp/test");
|
|
await executor.execute({
|
|
id: "FN-001",
|
|
title: "Test",
|
|
description: "Test",
|
|
column: "in-progress",
|
|
dependencies: [],
|
|
steps: [],
|
|
currentStep: 0,
|
|
log: [],
|
|
createdAt: new Date().toISOString(),
|
|
updatedAt: new Date().toISOString(),
|
|
});
|
|
|
|
// Called four times: initial execution + 3 retries when agent finishes without fn_task_done
|
|
expect(mockPrompt).toHaveBeenCalledTimes(4);
|
|
const agentPrompt = mockPrompt.mock.calls[0][0];
|
|
expect(agentPrompt).toContain("## Project Commands");
|
|
expect(agentPrompt).toContain("- **Test:** `npm test`");
|
|
expect(agentPrompt).toContain("- **Build:** `npm run build`");
|
|
});
|
|
|
|
describe("memoryEnabled setting", () => {
|
|
it("includes memory instructions when memoryEnabled: true", () => {
|
|
const task = createMockTaskDetail();
|
|
const result = buildExecutionPrompt(task, "/project", {
|
|
memoryEnabled: true,
|
|
} as any);
|
|
expect(result).toContain("Execute this task.");
|
|
expect(result).toContain("## Project Memory");
|
|
expect(result).toContain(".fusion/memory/");
|
|
});
|
|
|
|
it("excludes memory instructions when memoryEnabled: false", () => {
|
|
const task = createMockTaskDetail();
|
|
const result = buildExecutionPrompt(task, "/project", {
|
|
memoryEnabled: false,
|
|
} as any);
|
|
expect(result).toContain("Execute this task.");
|
|
expect(result).not.toContain("## Project Memory");
|
|
});
|
|
|
|
it("includes memory instructions when memoryEnabled is undefined (default enabled)", () => {
|
|
const task = createMockTaskDetail();
|
|
const result = buildExecutionPrompt(task, "/project", {} as any);
|
|
expect(result).toContain("Execute this task.");
|
|
expect(result).toContain("## Project Memory");
|
|
expect(result).toContain(".fusion/memory/");
|
|
});
|
|
|
|
it("includes selective memory write instruction for durable learnings at end of execution", () => {
|
|
const task = createMockTaskDetail();
|
|
const result = buildExecutionPrompt(task, "/project", {
|
|
memoryEnabled: true,
|
|
} as any);
|
|
// Should instruct selective writes, not unconditional appends
|
|
expect(result).toMatch(/skip.*memory.*update|selectively|durable.*learnings/i);
|
|
expect(result).toMatch(/end of execution|before calling.*fn_task_done/i);
|
|
// Should distinguish agent-private vs project-shared memory scope
|
|
expect(result).toContain('fn_memory_append(scope="agent")');
|
|
expect(result).toContain('fn_memory_append(scope="project")');
|
|
// Should forbid task-specific trivia
|
|
expect(result).toMatch(/avoid.*trivia|task-specific.*trivia|per-task.*log/i);
|
|
// Should allow consolidation/editing
|
|
expect(result).toMatch(/consolidate|update.*refine.*existing|edit.*existing/i);
|
|
});
|
|
|
|
it("uses project-root memory path not worktree-local path", () => {
|
|
const task = createMockTaskDetail();
|
|
const result = buildExecutionPrompt(task, "/project", {
|
|
memoryEnabled: true,
|
|
} as any);
|
|
expect(result).toContain("`.fusion/memory/`");
|
|
});
|
|
});
|
|
|
|
describe("memoryBackendType setting", () => {
|
|
it("includes .fusion/memory/ for file backend", () => {
|
|
const task = createMockTaskDetail();
|
|
const result = buildExecutionPrompt(task, "/project", {
|
|
memoryEnabled: true,
|
|
memoryBackendType: "file",
|
|
} as any);
|
|
expect(result).toContain("## Project Memory");
|
|
// Check that the Project Memory section contains .fusion/memory/
|
|
const memorySectionMatch = result.match(/## Project Memory\n([\s\S]*?)(?=\n## [^#]|$)/);
|
|
expect(memorySectionMatch).toBeTruthy();
|
|
expect(memorySectionMatch![1]).toContain(".fusion/memory/");
|
|
});
|
|
|
|
it("includes read-only wording for readonly backend without write directives in memory section", () => {
|
|
const task = createMockTaskDetail();
|
|
const result = buildExecutionPrompt(task, "/project", {
|
|
memoryEnabled: true,
|
|
memoryBackendType: "readonly",
|
|
} as any);
|
|
expect(result).toContain("## Project Memory");
|
|
// Extract the Project Memory section
|
|
const memorySectionMatch = result.match(/## Project Memory\n([\s\S]*?)(?=\n## [^#]|$)/);
|
|
expect(memorySectionMatch).toBeTruthy();
|
|
const memorySection = memorySectionMatch![1];
|
|
// Should NOT contain write/update directives in the memory section
|
|
expect(memorySection).not.toMatch(/write.*memory|update.*memory/i);
|
|
// Should NOT contain the specific file path in the memory section
|
|
expect(memorySection).not.toContain(".fusion/memory/");
|
|
});
|
|
|
|
it("does not include .fusion/memory/ in Project Memory section for qmd backend", () => {
|
|
const task = createMockTaskDetail();
|
|
const result = buildExecutionPrompt(task, "/project", {
|
|
memoryEnabled: true,
|
|
memoryBackendType: "qmd",
|
|
} as any);
|
|
expect(result).toContain("## Project Memory");
|
|
// Extract the Project Memory section
|
|
const memorySectionMatch = result.match(/## Project Memory\n([\s\S]*?)(?=\n## [^#]|$)/);
|
|
expect(memorySectionMatch).toBeTruthy();
|
|
const memorySection = memorySectionMatch![1];
|
|
// QMD should NOT unconditionally reference .fusion/memory/ in the memory section
|
|
expect(memorySection).not.toContain(".fusion/memory/");
|
|
expect(memorySection).toContain("fn_memory_search");
|
|
expect(memorySection).toContain("fn_memory_get");
|
|
});
|
|
|
|
it("QMD prompt has actionable memory instructions", () => {
|
|
const task = createMockTaskDetail();
|
|
const result = buildExecutionPrompt(task, "/project", {
|
|
memoryEnabled: true,
|
|
memoryBackendType: "qmd",
|
|
} as any);
|
|
expect(result).toContain("## Project Memory");
|
|
// Extract the Project Memory section
|
|
const memorySectionMatch = result.match(/## Project Memory\n([\s\S]*?)(?=\n## [^#]|$)/);
|
|
expect(memorySectionMatch).toBeTruthy();
|
|
const memorySection = memorySectionMatch![1];
|
|
// QMD should NOT contain .fusion/memory/
|
|
expect(memorySection).not.toContain(".fusion/memory/");
|
|
expect(memorySection).toContain("fn_memory_search");
|
|
// Contains "end of execution" write guidance
|
|
expect(memorySection).toMatch(/end of execution/i);
|
|
});
|
|
|
|
it("excludes memory section when memoryEnabled: false regardless of backend", () => {
|
|
const task = createMockTaskDetail();
|
|
const result = buildExecutionPrompt(task, "/project", {
|
|
memoryEnabled: false,
|
|
memoryBackendType: "file",
|
|
} as any);
|
|
expect(result).toContain("Execute this task.");
|
|
expect(result).not.toContain("## Project Memory");
|
|
});
|
|
});
|
|
|
|
describe("commit author attribution", () => {
|
|
it("includes default author in commit instruction when commitAuthorEnabled is true", () => {
|
|
const task = createMockTaskDetail();
|
|
const result = buildExecutionPrompt(task, "/project", {
|
|
commitAuthorEnabled: true,
|
|
} as any);
|
|
expect(result).toContain('--author="Fusion <noreply@runfusion.ai>"');
|
|
});
|
|
|
|
it("includes custom author name and email in commit instruction", () => {
|
|
const task = createMockTaskDetail();
|
|
const result = buildExecutionPrompt(task, "/project", {
|
|
commitAuthorEnabled: true,
|
|
commitAuthorName: "CustomBot",
|
|
commitAuthorEmail: "bot@example.com",
|
|
} as any);
|
|
expect(result).toContain('--author="CustomBot <bot@example.com>"');
|
|
});
|
|
|
|
it("omits author from commit instruction when commitAuthorEnabled is false", () => {
|
|
const task = createMockTaskDetail();
|
|
const result = buildExecutionPrompt(task, "/project", {
|
|
commitAuthorEnabled: false,
|
|
} as any);
|
|
expect(result).not.toContain("--author");
|
|
// Should still contain commit instruction without author
|
|
expect(result).toContain("git commit -m");
|
|
});
|
|
|
|
it("uses default author when commitAuthorEnabled is true but name/email are undefined", () => {
|
|
const task = createMockTaskDetail();
|
|
const result = buildExecutionPrompt(task, "/project", {
|
|
commitAuthorEnabled: true,
|
|
commitAuthorName: undefined,
|
|
commitAuthorEmail: undefined,
|
|
} as any);
|
|
expect(result).toContain('--author="Fusion <noreply@runfusion.ai>"');
|
|
});
|
|
|
|
it("uses default author when settings is undefined", () => {
|
|
const task = createMockTaskDetail();
|
|
const result = buildExecutionPrompt(task, "/project");
|
|
expect(result).toContain('--author="Fusion <noreply@runfusion.ai>"');
|
|
});
|
|
|
|
it("uses default author when settings is empty object", () => {
|
|
const task = createMockTaskDetail();
|
|
const result = buildExecutionPrompt(task, "/project", {} as any);
|
|
expect(result).toContain('--author="Fusion <noreply@runfusion.ai>"');
|
|
});
|
|
});
|
|
});
|
|
|
|
// Import the summarizeToolArgs helper directly (not affected by mocks above)
|
|
describe("summarizeToolArgs", () => {
|
|
// Dynamic import to avoid mock interference
|
|
let summarizeToolArgs: (name: string, args?: Record<string, unknown>) => string | undefined;
|
|
|
|
beforeEach(async () => {
|
|
const mod = await vi.importActual<typeof import("../executor.js")>("../executor.js");
|
|
summarizeToolArgs = mod.summarizeToolArgs;
|
|
});
|
|
|
|
it("returns command for bash tool", () => {
|
|
expect(summarizeToolArgs("Bash", { command: "ls -la" })).toBe("ls -la");
|
|
expect(summarizeToolArgs("bash", { command: "echo hello" })).toBe("echo hello");
|
|
});
|
|
|
|
it("returns long bash commands in full without truncation", () => {
|
|
const longCmd = "a".repeat(100);
|
|
const result = summarizeToolArgs("Bash", { command: longCmd });
|
|
expect(result).toBe(longCmd);
|
|
});
|
|
|
|
it("returns path for read/edit/write tools", () => {
|
|
expect(summarizeToolArgs("Read", { path: "src/types.ts" })).toBe("src/types.ts");
|
|
expect(summarizeToolArgs("edit", { path: "src/store.ts" })).toBe("src/store.ts");
|
|
expect(summarizeToolArgs("Write", { path: "out.txt", content: "data" })).toBe("out.txt");
|
|
});
|
|
|
|
it("returns first string arg for unknown tools", () => {
|
|
expect(summarizeToolArgs("fn_task_update", { step: 1, status: "done" })).toBe("done");
|
|
});
|
|
|
|
it("returns undefined when no args provided", () => {
|
|
expect(summarizeToolArgs("Bash")).toBeUndefined();
|
|
expect(summarizeToolArgs("Bash", {})).toBeUndefined();
|
|
});
|
|
|
|
it("returns undefined when no string args found", () => {
|
|
expect(summarizeToolArgs("unknown", { count: 42, flag: true })).toBeUndefined();
|
|
});
|
|
});
|
|
|
|
describe("TaskExecutor pause behavior", () => {
|
|
beforeEach(() => {
|
|
resetExecutorMocks();
|
|
mockedExistsSync.mockReturnValue(true);
|
|
});
|
|
|
|
it("terminates agent and moves task to todo when paused during execution", async () => {
|
|
const store = createMockStore();
|
|
const disposeFn = vi.fn();
|
|
|
|
mockedCreateFnAgent.mockImplementation(async () => {
|
|
return {
|
|
session: {
|
|
prompt: vi.fn().mockImplementation(async () => {
|
|
// Simulate pause happening during agent execution
|
|
store._trigger("task:updated", { id: "FN-001", paused: true, column: "in-progress" });
|
|
// Simulate the dispose causing an error (session terminated)
|
|
throw new Error("Session terminated");
|
|
}),
|
|
dispose: disposeFn,
|
|
},
|
|
} as any;
|
|
});
|
|
|
|
const executor = new TaskExecutor(store, "/tmp/test");
|
|
await executor.execute({
|
|
id: "FN-001",
|
|
title: "Test",
|
|
description: "Test",
|
|
column: "in-progress",
|
|
dependencies: [],
|
|
steps: [],
|
|
currentStep: 0,
|
|
log: [],
|
|
createdAt: new Date().toISOString(),
|
|
updatedAt: new Date().toISOString(),
|
|
});
|
|
|
|
// Should move to todo, NOT mark as failed. This path (agent threw mid-
|
|
// execution while paused) explicitly nukes worktree+branch — work is
|
|
// discarded — so it must NOT flag preserveResumeState.
|
|
expect(store.moveTask).toHaveBeenCalledWith("FN-001", "todo");
|
|
expect(store.updateTask).not.toHaveBeenCalledWith("FN-001", { status: "failed" });
|
|
});
|
|
|
|
it("does not move to in-review when paused during execution (graceful session end)", async () => {
|
|
const store = createMockStore();
|
|
|
|
mockedCreateFnAgent.mockImplementation(async () => {
|
|
return {
|
|
session: {
|
|
prompt: vi.fn().mockImplementation(async () => {
|
|
// Simulate pause — session ends gracefully (no throw)
|
|
store._trigger("task:updated", { id: "FN-001", paused: true, column: "in-progress" });
|
|
}),
|
|
dispose: vi.fn(),
|
|
},
|
|
} as any;
|
|
});
|
|
|
|
const executor = new TaskExecutor(store, "/tmp/test");
|
|
await executor.execute({
|
|
id: "FN-001",
|
|
title: "Test",
|
|
description: "Test",
|
|
column: "in-progress",
|
|
dependencies: [],
|
|
steps: [],
|
|
currentStep: 0,
|
|
log: [],
|
|
createdAt: new Date().toISOString(),
|
|
updatedAt: new Date().toISOString(),
|
|
});
|
|
|
|
// Should NOT move to in-review (paused tasks skip that logic)
|
|
expect(store.moveTask).not.toHaveBeenCalledWith("FN-001", "in-review");
|
|
// Should move to todo instead (regression: was stranding in in-progress).
|
|
// Pause-graceful path flags preserveResumeState so the bounce keeps
|
|
// the worktree and accumulated step progress.
|
|
expect(store.moveTask).toHaveBeenCalledWith("FN-001", "todo", { preserveResumeState: true });
|
|
expect(store.updateTask).not.toHaveBeenCalledWith("FN-001", { status: "failed" });
|
|
});
|
|
|
|
it("moves paused task to todo when session ends gracefully (regression for FN-827)", async () => {
|
|
const store = createMockStore();
|
|
const disposeFn = vi.fn();
|
|
|
|
mockedCreateFnAgent.mockImplementation(async () => {
|
|
return {
|
|
session: {
|
|
prompt: vi.fn().mockImplementation(async () => {
|
|
// Simulate pause during execution — session ends gracefully (no throw)
|
|
store._trigger("task:updated", { id: "FN-805", paused: true, column: "in-progress" });
|
|
// No error thrown — this is the "graceful exit" path
|
|
}),
|
|
dispose: disposeFn,
|
|
},
|
|
} as any;
|
|
});
|
|
|
|
const stuckTaskDetector = { trackTask: vi.fn(), untrackTask: vi.fn(), recordActivity: vi.fn() } as any;
|
|
|
|
const executor = new TaskExecutor(store, "/tmp/test", { stuckTaskDetector });
|
|
await executor.execute({
|
|
id: "FN-805",
|
|
title: "Stranded task",
|
|
description: "A task that was paused and stranded",
|
|
column: "in-progress",
|
|
dependencies: [],
|
|
steps: [],
|
|
currentStep: 0,
|
|
log: [],
|
|
createdAt: new Date().toISOString(),
|
|
updatedAt: new Date().toISOString(),
|
|
});
|
|
|
|
// The critical fix: task must end in todo, not stranded in in-progress.
|
|
// The pause path must also flag preserveResumeState so the move does not
|
|
// wipe accumulated step progress and the worktree pointer.
|
|
expect(store.moveTask).toHaveBeenCalledWith("FN-805", "todo", { preserveResumeState: true });
|
|
// Should NOT be marked as failed
|
|
expect(store.updateTask).not.toHaveBeenCalledWith("FN-805", expect.objectContaining({ status: "failed" }));
|
|
// Should log the pause event
|
|
expect(store.logEntry).toHaveBeenCalledWith("FN-805", expect.stringContaining("Execution paused"));
|
|
// Session should be disposed
|
|
expect(disposeFn).toHaveBeenCalled();
|
|
// Stuck detector should have untracked the task
|
|
expect(stuckTaskDetector.untrackTask).toHaveBeenCalledWith("FN-805");
|
|
});
|
|
|
|
it("handles rapid pause→unpause without duplicate executor runs", async () => {
|
|
const store = createMockStore();
|
|
const disposeFn = vi.fn();
|
|
let promptCallCount = 0;
|
|
|
|
mockedCreateFnAgent.mockImplementation(async () => {
|
|
return {
|
|
session: {
|
|
prompt: vi.fn().mockImplementation(async () => {
|
|
promptCallCount++;
|
|
// Simulate pause during execution
|
|
store._trigger("task:updated", { id: "FN-001", paused: true, column: "in-progress" });
|
|
// Simulate rapid unpause while executor is still handling the pause
|
|
store._trigger("task:updated", { id: "FN-001", paused: undefined, column: "in-progress" });
|
|
// Session ends gracefully (no throw)
|
|
}),
|
|
dispose: disposeFn,
|
|
},
|
|
} as any;
|
|
});
|
|
|
|
const executor = new TaskExecutor(store, "/tmp/test");
|
|
await executor.execute({
|
|
id: "FN-001",
|
|
title: "Rapid pause/unpause",
|
|
description: "Test rapid pause then unpause",
|
|
column: "in-progress",
|
|
dependencies: [],
|
|
steps: [],
|
|
currentStep: 0,
|
|
log: [],
|
|
createdAt: new Date().toISOString(),
|
|
updatedAt: new Date().toISOString(),
|
|
});
|
|
|
|
// The task should still be moved to todo exactly once (the pause took effect)
|
|
// Even if unpause happened rapidly, the session was already disposed
|
|
const todoCalls = store.moveTask.mock.calls.filter(
|
|
(call: any[]) => call[0] === "FN-001" && call[1] === "todo",
|
|
);
|
|
expect(todoCalls.length).toBe(1);
|
|
// Should NOT have duplicate in-review calls
|
|
const inReviewCalls = store.moveTask.mock.calls.filter(
|
|
(call: any[]) => call[0] === "FN-001" && call[1] === "in-review",
|
|
);
|
|
expect(inReviewCalls.length).toBe(0);
|
|
// Agent should only have been prompted once
|
|
expect(promptCallCount).toBe(1);
|
|
});
|
|
|
|
it("skips paused tasks during resumeOrphaned", async () => {
|
|
const store = createMockStore();
|
|
store.listTasks.mockResolvedValue([
|
|
{ id: "FN-001", column: "in-progress", paused: true, title: "Paused task", steps: [], description: "", dependencies: [] },
|
|
{ id: "FN-002", column: "in-progress", paused: false, title: "Active task", steps: [], description: "", dependencies: [] },
|
|
]);
|
|
|
|
mockedCreateFnAgent.mockResolvedValue({
|
|
session: {
|
|
prompt: vi.fn().mockResolvedValue(undefined),
|
|
dispose: vi.fn(),
|
|
},
|
|
} as any);
|
|
|
|
const executor = new TaskExecutor(store, "/tmp/test");
|
|
await executor.resumeOrphaned();
|
|
|
|
// Only KB-002 should be resumed (KB-001 is paused)
|
|
expect(store.logEntry).toHaveBeenCalledWith("FN-002", "Resumed after engine restart");
|
|
expect(store.logEntry).not.toHaveBeenCalledWith("FN-001", expect.anything());
|
|
});
|
|
|
|
it("skips resumeOrphaned entirely while enginePaused is active", async () => {
|
|
const store = createMockStore();
|
|
store.getSettings.mockResolvedValue({
|
|
maxConcurrent: 2,
|
|
maxWorktrees: 4,
|
|
pollIntervalMs: 15000,
|
|
autoMerge: false,
|
|
enginePaused: true,
|
|
globalPause: false,
|
|
});
|
|
|
|
const executor = new TaskExecutor(store, "/tmp/test");
|
|
await executor.resumeOrphaned();
|
|
|
|
expect(store.listTasks).not.toHaveBeenCalled();
|
|
expect(store.logEntry).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("resumes unpaused in-progress task with no active session", async () => {
|
|
const store = createMockStore();
|
|
const disposeFn = vi.fn();
|
|
|
|
mockedCreateFnAgent.mockImplementation(async () => ({
|
|
session: {
|
|
prompt: vi.fn().mockResolvedValue(undefined),
|
|
dispose: disposeFn,
|
|
},
|
|
}) as any);
|
|
|
|
const _executor = new TaskExecutor(store, "/tmp/test");
|
|
|
|
// Simulate unpause of an in-progress task that has no active session
|
|
// (e.g., engine restarted while task was paused in-progress)
|
|
store._trigger("task:updated", {
|
|
id: "FN-001",
|
|
paused: undefined,
|
|
column: "in-progress",
|
|
description: "Test task",
|
|
title: "Resumed task",
|
|
dependencies: [],
|
|
steps: [],
|
|
currentStep: 0,
|
|
log: [],
|
|
createdAt: new Date().toISOString(),
|
|
updatedAt: new Date().toISOString(),
|
|
});
|
|
|
|
// Wait for async execution to start
|
|
await new Promise((r) => setTimeout(r, 50));
|
|
|
|
// Agent created at least twice: initial resume + retry when agent finishes without fn_task_done
|
|
// (async worktree validation may allow additional retry cycles within the timeout)
|
|
expect(mockedCreateFnAgent.mock.calls.length).toBeGreaterThanOrEqual(2);
|
|
expect(store.logEntry).toHaveBeenCalledWith("FN-001", "Resuming execution after unpause", undefined, undefined);
|
|
});
|
|
|
|
it("does not resume unpaused in-progress task while global pause is active", async () => {
|
|
const store = createMockStore();
|
|
store.getSettings.mockResolvedValue({
|
|
maxConcurrent: 2,
|
|
maxWorktrees: 4,
|
|
pollIntervalMs: 15000,
|
|
autoMerge: false,
|
|
globalPause: true,
|
|
enginePaused: false,
|
|
});
|
|
|
|
mockedCreateFnAgent.mockImplementation(async () => ({
|
|
session: {
|
|
prompt: vi.fn().mockResolvedValue(undefined),
|
|
dispose: vi.fn(),
|
|
},
|
|
}) as any);
|
|
|
|
const executor = new TaskExecutor(store, "/tmp/test");
|
|
|
|
store._trigger("task:updated", {
|
|
id: "FN-001",
|
|
paused: undefined,
|
|
column: "in-progress",
|
|
description: "Test task",
|
|
title: "Paused runtime task",
|
|
dependencies: [],
|
|
steps: [],
|
|
currentStep: 0,
|
|
log: [],
|
|
createdAt: new Date().toISOString(),
|
|
updatedAt: new Date().toISOString(),
|
|
});
|
|
|
|
await new Promise((r) => setTimeout(r, 20));
|
|
|
|
expect(executor).toBeTruthy();
|
|
expect(mockedCreateFnAgent).not.toHaveBeenCalled();
|
|
expect(store.logEntry).not.toHaveBeenCalledWith("FN-001", "Resuming execution after unpause", undefined, undefined);
|
|
});
|
|
|
|
it("does not recursively resume when resume logging emits task updated", async () => {
|
|
const store = createMockStore();
|
|
const task = {
|
|
id: "FN-001",
|
|
paused: undefined,
|
|
column: "in-progress",
|
|
description: "Test task",
|
|
title: "Resumed task",
|
|
dependencies: [],
|
|
steps: [],
|
|
currentStep: 0,
|
|
log: [],
|
|
createdAt: new Date().toISOString(),
|
|
updatedAt: new Date().toISOString(),
|
|
};
|
|
|
|
mockedCreateFnAgent.mockImplementation(async () => ({
|
|
session: {
|
|
prompt: vi.fn().mockResolvedValue(undefined),
|
|
dispose: vi.fn(),
|
|
},
|
|
}) as any);
|
|
|
|
let emittedUpdateFromLog = false;
|
|
store.logEntry.mockImplementation(async (_id: string, action: string) => {
|
|
if (action === "Resuming execution after unpause" && !emittedUpdateFromLog) {
|
|
emittedUpdateFromLog = true;
|
|
store._trigger("task:updated", { ...task, updatedAt: new Date().toISOString() });
|
|
}
|
|
});
|
|
|
|
new TaskExecutor(store, "/tmp/test");
|
|
store._trigger("task:updated", task);
|
|
|
|
await new Promise((r) => setTimeout(r, 50));
|
|
|
|
const resumeLogCalls = store.logEntry.mock.calls.filter(
|
|
([id, action]: [string, string]) => id === "FN-001" && action === "Resuming execution after unpause",
|
|
);
|
|
expect(resumeLogCalls).toHaveLength(1);
|
|
});
|
|
|
|
it("clears stale failed state before resuming unpaused in-progress task", async () => {
|
|
const store = createMockStore();
|
|
|
|
mockedCreateFnAgent.mockImplementation(async () => ({
|
|
session: {
|
|
prompt: vi.fn().mockResolvedValue(undefined),
|
|
dispose: vi.fn(),
|
|
},
|
|
}) as any);
|
|
|
|
const _executor = new TaskExecutor(store, "/tmp/test");
|
|
|
|
store._trigger("task:updated", {
|
|
id: "FN-001",
|
|
paused: undefined,
|
|
column: "in-progress",
|
|
status: "failed",
|
|
error: "Request was aborted.",
|
|
description: "Test task",
|
|
title: "Resumed task",
|
|
dependencies: [],
|
|
steps: [],
|
|
currentStep: 0,
|
|
log: [],
|
|
createdAt: new Date().toISOString(),
|
|
updatedAt: new Date().toISOString(),
|
|
});
|
|
|
|
await new Promise((r) => setTimeout(r, 30));
|
|
|
|
expect(store.updateTask).toHaveBeenCalledWith("FN-001", { status: null, error: null });
|
|
expect(store.logEntry).toHaveBeenCalledWith("FN-001", "Resuming execution after unpause", undefined, undefined);
|
|
});
|
|
|
|
it("clears stale failed state before resuming orphaned in-progress task", async () => {
|
|
const store = createMockStore();
|
|
store.listTasks.mockResolvedValue([
|
|
{
|
|
id: "FN-001",
|
|
column: "in-progress",
|
|
paused: false,
|
|
status: "failed",
|
|
error: "Request was aborted.",
|
|
title: "Active task",
|
|
steps: [],
|
|
description: "",
|
|
dependencies: [],
|
|
},
|
|
]);
|
|
|
|
mockedCreateFnAgent.mockResolvedValue({
|
|
session: {
|
|
prompt: vi.fn().mockResolvedValue(undefined),
|
|
dispose: vi.fn(),
|
|
},
|
|
} as any);
|
|
|
|
const executor = new TaskExecutor(store, "/tmp/test");
|
|
await executor.resumeOrphaned();
|
|
|
|
expect(store.updateTask).toHaveBeenCalledWith("FN-001", { status: null, error: null });
|
|
expect(store.logEntry).toHaveBeenCalledWith("FN-001", "Resumed after engine restart");
|
|
});
|
|
|
|
it("does not duplicate execution when unpausing already-executing task", async () => {
|
|
const store = createMockStore();
|
|
const disposeFn = vi.fn();
|
|
|
|
mockedCreateFnAgent.mockImplementation(async () => ({
|
|
session: {
|
|
prompt: vi.fn().mockImplementation(async () => {
|
|
// Simulate rapid unpause during execution — should NOT start a second run
|
|
store._trigger("task:updated", {
|
|
id: "FN-001",
|
|
paused: undefined,
|
|
column: "in-progress",
|
|
});
|
|
// Wait a bit to let the unpause handler run
|
|
await new Promise((r) => setTimeout(r, 10));
|
|
}),
|
|
dispose: disposeFn,
|
|
},
|
|
}) as any);
|
|
|
|
const executor = new TaskExecutor(store, "/tmp/test");
|
|
await executor.execute({
|
|
id: "FN-001",
|
|
title: "Already executing",
|
|
description: "Test no duplicate",
|
|
column: "in-progress",
|
|
dependencies: [],
|
|
steps: [],
|
|
currentStep: 0,
|
|
log: [],
|
|
createdAt: new Date().toISOString(),
|
|
updatedAt: new Date().toISOString(),
|
|
});
|
|
|
|
// At least two agent creations (initial + retry without fn_task_done), but no duplicate from the unpause event
|
|
// (async worktree validation may allow additional retry cycles)
|
|
expect(mockedCreateFnAgent.mock.calls.length).toBeGreaterThanOrEqual(2);
|
|
});
|
|
|
|
it("does not resume unpaused task that is not in-progress", async () => {
|
|
const store = createMockStore();
|
|
|
|
mockedCreateFnAgent.mockImplementation(async () => ({
|
|
session: {
|
|
prompt: vi.fn().mockResolvedValue(undefined),
|
|
dispose: vi.fn(),
|
|
},
|
|
}) as any);
|
|
|
|
const _executor = new TaskExecutor(store, "/tmp/test");
|
|
|
|
// Unpause a todo task — executor should NOT try to execute it
|
|
store._trigger("task:updated", {
|
|
id: "FN-001",
|
|
paused: undefined,
|
|
column: "todo",
|
|
});
|
|
|
|
await new Promise((r) => setTimeout(r, 20));
|
|
|
|
// No agent should have been created
|
|
expect(mockedCreateFnAgent).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("does not resume unpaused task that still has an active session", async () => {
|
|
const store = createMockStore();
|
|
const disposeFn = vi.fn();
|
|
|
|
let promptResolve: () => void;
|
|
const promptPromise = new Promise<void>((r) => { promptResolve = r; });
|
|
|
|
mockedCreateFnAgent.mockImplementation(async () => ({
|
|
session: {
|
|
prompt: vi.fn().mockImplementation(async () => {
|
|
// Simulate unpause while session is still active (should be a no-op)
|
|
store._trigger("task:updated", {
|
|
id: "FN-001",
|
|
paused: undefined,
|
|
column: "in-progress",
|
|
});
|
|
await new Promise((r) => setTimeout(r, 10));
|
|
}),
|
|
dispose: disposeFn,
|
|
},
|
|
}) as any);
|
|
|
|
const executor = new TaskExecutor(store, "/tmp/test");
|
|
|
|
// Start execution — session will be active
|
|
const executePromise = executor.execute({
|
|
id: "FN-001",
|
|
title: "Active session",
|
|
description: "Test active session unpause",
|
|
column: "in-progress",
|
|
dependencies: [],
|
|
steps: [],
|
|
currentStep: 0,
|
|
log: [],
|
|
createdAt: new Date().toISOString(),
|
|
updatedAt: new Date().toISOString(),
|
|
});
|
|
|
|
await executePromise;
|
|
|
|
// Four agent sessions (initial + 3 retries without fn_task_done) — the unpause during active session was a no-op
|
|
expect(mockedCreateFnAgent).toHaveBeenCalledTimes(4);
|
|
});
|
|
|
|
it("uses SessionManager.create for fresh execution and persists sessionFile", async () => {
|
|
const store = createMockStore();
|
|
const sessionFilePath = "/tmp/sessions/session_123.jsonl";
|
|
|
|
mockedCreateFnAgent.mockResolvedValue({
|
|
session: {
|
|
prompt: vi.fn().mockResolvedValue(undefined),
|
|
dispose: vi.fn(),
|
|
},
|
|
sessionFile: sessionFilePath,
|
|
} as any);
|
|
|
|
const executor = new TaskExecutor(store, "/tmp/test");
|
|
await executor.execute({
|
|
id: "FN-001",
|
|
title: "Fresh task",
|
|
description: "Test fresh session",
|
|
column: "in-progress",
|
|
dependencies: [],
|
|
steps: [],
|
|
currentStep: 0,
|
|
log: [],
|
|
createdAt: new Date().toISOString(),
|
|
updatedAt: new Date().toISOString(),
|
|
});
|
|
|
|
// Should use SessionManager.create for fresh execution
|
|
expect(mockedSessionManager.create).toHaveBeenCalledWith(
|
|
expect.stringContaining(".worktrees"),
|
|
);
|
|
expect(mockedSessionManager.open).not.toHaveBeenCalled();
|
|
|
|
// Should persist the session file path on the task
|
|
expect(store.updateTask).toHaveBeenCalledWith("FN-001", { sessionFile: sessionFilePath });
|
|
});
|
|
|
|
it("uses SessionManager.open to resume session when task has sessionFile", async () => {
|
|
const store = createMockStore();
|
|
const sessionFilePath = "/tmp/sessions/session_123.jsonl";
|
|
const resumePromptFn = vi.fn().mockResolvedValue(undefined);
|
|
|
|
// existsSync must return true for the session file
|
|
mockedExistsSync.mockReturnValue(true);
|
|
|
|
mockedCreateFnAgent.mockResolvedValue({
|
|
session: {
|
|
prompt: resumePromptFn,
|
|
dispose: vi.fn(),
|
|
},
|
|
sessionFile: sessionFilePath,
|
|
} as any);
|
|
|
|
const executor = new TaskExecutor(store, "/tmp/test");
|
|
await executor.execute({
|
|
id: "FN-001",
|
|
title: "Resumed task",
|
|
description: "Test session resume",
|
|
column: "in-progress",
|
|
dependencies: [],
|
|
steps: [],
|
|
currentStep: 0,
|
|
log: [],
|
|
sessionFile: sessionFilePath,
|
|
createdAt: new Date().toISOString(),
|
|
updatedAt: new Date().toISOString(),
|
|
});
|
|
|
|
// Should use SessionManager.open for the initial resumed execution
|
|
expect(mockedSessionManager.open).toHaveBeenCalledWith(sessionFilePath);
|
|
|
|
// The first createFnAgent call should use the opened session manager
|
|
const firstCall = mockedCreateFnAgent.mock.calls[0][0] as any;
|
|
expect(firstCall.sessionManager).toBeDefined();
|
|
|
|
// The log should indicate resume
|
|
expect(store.logEntry).toHaveBeenCalledWith(
|
|
"FN-001",
|
|
expect.stringContaining("Resumed agent session after unpause"),
|
|
undefined,
|
|
expect.objectContaining({ agentId: "executor" }),
|
|
);
|
|
});
|
|
|
|
it("preserves sessionFile when task is paused (graceful exit)", async () => {
|
|
const store = createMockStore();
|
|
const sessionFilePath = "/tmp/sessions/session_456.jsonl";
|
|
|
|
mockedCreateFnAgent.mockImplementation(async () => ({
|
|
session: {
|
|
prompt: vi.fn().mockImplementation(async () => {
|
|
// Simulate pause — session ends gracefully
|
|
store._trigger("task:updated", { id: "FN-001", paused: true, column: "in-progress" });
|
|
}),
|
|
dispose: vi.fn(),
|
|
},
|
|
sessionFile: sessionFilePath,
|
|
}) as any);
|
|
|
|
const executor = new TaskExecutor(store, "/tmp/test");
|
|
await executor.execute({
|
|
id: "FN-001",
|
|
title: "Pauseable task",
|
|
description: "Test session file preserved on pause",
|
|
column: "in-progress",
|
|
dependencies: [],
|
|
steps: [],
|
|
currentStep: 0,
|
|
log: [],
|
|
createdAt: new Date().toISOString(),
|
|
updatedAt: new Date().toISOString(),
|
|
});
|
|
|
|
// Session file should NOT be cleared when paused
|
|
const clearCalls = store.updateTask.mock.calls.filter(
|
|
(call: any[]) => call[0] === "FN-001" && call[1]?.sessionFile === null,
|
|
);
|
|
expect(clearCalls.length).toBe(0);
|
|
|
|
// Task should be moved to todo (ready for resume) with preserveResumeState
|
|
// so step progress and the worktree survive the pause→unpause hop.
|
|
expect(store.moveTask).toHaveBeenCalledWith("FN-001", "todo", { preserveResumeState: true });
|
|
});
|
|
|
|
it("falls back to fresh session when sessionFile no longer exists on disk", async () => {
|
|
const store = createMockStore();
|
|
const staleSessionFile = "/tmp/sessions/deleted_session.jsonl";
|
|
|
|
// Session file does NOT exist on disk
|
|
mockedExistsSync.mockImplementation(
|
|
(p) => p !== staleSessionFile,
|
|
);
|
|
|
|
mockedCreateFnAgent.mockResolvedValue({
|
|
session: {
|
|
prompt: vi.fn().mockResolvedValue(undefined),
|
|
dispose: vi.fn(),
|
|
},
|
|
sessionFile: "/tmp/sessions/new_session.jsonl",
|
|
} as any);
|
|
|
|
const executor = new TaskExecutor(store, "/tmp/test");
|
|
await executor.execute({
|
|
id: "FN-001",
|
|
title: "Stale session",
|
|
description: "Test stale session file fallback",
|
|
column: "in-progress",
|
|
dependencies: [],
|
|
steps: [],
|
|
currentStep: 0,
|
|
log: [],
|
|
sessionFile: staleSessionFile,
|
|
createdAt: new Date().toISOString(),
|
|
updatedAt: new Date().toISOString(),
|
|
});
|
|
|
|
// Should fall back to SessionManager.create (not open)
|
|
expect(mockedSessionManager.create).toHaveBeenCalled();
|
|
expect(mockedSessionManager.open).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
describe("swallowed async store failure observability", () => {
|
|
beforeEach(() => {
|
|
resetExecutorMocks();
|
|
mockedWithRateLimitRetry.mockImplementation((fn: () => Promise<unknown>) => fn());
|
|
});
|
|
|
|
it("logs warning when rate-limit retry logEntry fails in step-session mode", async () => {
|
|
const warnSpy = vi.spyOn(executorLog, "warn");
|
|
const store = createMockStore();
|
|
|
|
store.getSettings.mockResolvedValue({
|
|
maxConcurrent: 2,
|
|
maxWorktrees: 4,
|
|
pollIntervalMs: 15000,
|
|
groupOverlappingFiles: false,
|
|
autoMerge: false,
|
|
runStepsInNewSessions: true,
|
|
maxParallelSteps: 2,
|
|
});
|
|
store.getTask.mockResolvedValue({
|
|
id: "FN-001",
|
|
title: "Rate-limit step-session task",
|
|
description: "Rate-limit diagnostics",
|
|
column: "in-progress",
|
|
dependencies: [],
|
|
steps: [{ name: "Step 0", status: "pending" }],
|
|
currentStep: 0,
|
|
log: [],
|
|
prompt: "# test\n## Steps\n### Step 0: Preflight\n- [ ] check",
|
|
createdAt: new Date().toISOString(),
|
|
updatedAt: new Date().toISOString(),
|
|
baseCommitSha: "abc123",
|
|
enabledWorkflowSteps: [],
|
|
});
|
|
|
|
mockExecuteAll.mockResolvedValue([{ stepIndex: 0, success: true, retries: 0 }]);
|
|
|
|
store.logEntry.mockImplementation(async (_taskId: string, message: string) => {
|
|
if (message.includes("Rate limited — retry")) {
|
|
throw new Error("step-session retry log failure");
|
|
}
|
|
return undefined;
|
|
});
|
|
|
|
mockedWithRateLimitRetry.mockImplementationOnce((async (
|
|
fn: () => Promise<unknown>,
|
|
options?: { onRetry?: (attempt: number, delayMs: number, error: Error) => void },
|
|
) => {
|
|
options?.onRetry?.(2, 4_000, new Error("rate limit"));
|
|
return fn();
|
|
}) as typeof withRateLimitRetry);
|
|
|
|
const executor = new TaskExecutor(store, "/tmp/test");
|
|
await expect(executor.execute({
|
|
id: "FN-001",
|
|
title: "Rate-limit step-session task",
|
|
description: "Rate-limit diagnostics",
|
|
column: "in-progress",
|
|
dependencies: [],
|
|
steps: [{ name: "Step 0", status: "pending" }],
|
|
currentStep: 0,
|
|
log: [],
|
|
createdAt: new Date().toISOString(),
|
|
updatedAt: new Date().toISOString(),
|
|
})).resolves.toBeUndefined();
|
|
|
|
expect(store.moveTask).toHaveBeenCalledWith("FN-001", "in-review");
|
|
expect(warnSpy).toHaveBeenCalledWith(
|
|
expect.stringContaining("FN-001 failed to log rate-limit retry: step-session retry log failure"),
|
|
);
|
|
|
|
warnSpy.mockRestore();
|
|
});
|
|
|
|
it("logs warning when rate-limit retry logEntry fails in main-agent mode", async () => {
|
|
const warnSpy = vi.spyOn(executorLog, "warn");
|
|
const store = createMockStore();
|
|
let capturedCustomTools: Array<{ name: string; execute: (callId: string, args: Record<string, unknown>) => Promise<unknown> }> = [];
|
|
|
|
store.logEntry.mockImplementation(async (_taskId: string, message: string) => {
|
|
if (message.includes("Rate limited — retry")) {
|
|
throw new Error("main-agent retry log failure");
|
|
}
|
|
return undefined;
|
|
});
|
|
|
|
mockedCreateFnAgent.mockImplementation((async (opts: { customTools?: typeof capturedCustomTools }) => {
|
|
capturedCustomTools = opts.customTools ?? [];
|
|
return {
|
|
session: {
|
|
prompt: vi.fn().mockImplementation(async () => {
|
|
const taskDoneTool = capturedCustomTools.find((tool) => tool.name === "fn_task_done");
|
|
if (taskDoneTool) {
|
|
await taskDoneTool.execute("call-1", { summary: "done" });
|
|
}
|
|
}),
|
|
dispose: vi.fn(),
|
|
subscribe: vi.fn(),
|
|
on: vi.fn(),
|
|
sessionManager: { getLeafId: vi.fn().mockReturnValue("leaf-1") },
|
|
state: {},
|
|
},
|
|
sessionFile: "/tmp/sessions/main-agent-rate-limit.jsonl",
|
|
};
|
|
}) as any);
|
|
|
|
mockedWithRateLimitRetry.mockImplementationOnce((async (
|
|
fn: () => Promise<unknown>,
|
|
options?: { onRetry?: (attempt: number, delayMs: number, error: Error) => void },
|
|
) => {
|
|
options?.onRetry?.(1, 3_000, new Error("rate limit"));
|
|
return fn();
|
|
}) as typeof withRateLimitRetry);
|
|
|
|
const executor = new TaskExecutor(store, "/tmp/test");
|
|
await expect(executor.execute({
|
|
id: "FN-001",
|
|
title: "Rate-limit main-agent task",
|
|
description: "Rate-limit diagnostics",
|
|
column: "in-progress",
|
|
dependencies: [],
|
|
steps: [{ name: "Step 0", status: "pending" }],
|
|
currentStep: 0,
|
|
log: [],
|
|
createdAt: new Date().toISOString(),
|
|
updatedAt: new Date().toISOString(),
|
|
})).resolves.toBeUndefined();
|
|
|
|
expect(store.moveTask).toHaveBeenCalledWith("FN-001", "in-review");
|
|
expect(warnSpy).toHaveBeenCalledWith(
|
|
expect.stringContaining("FN-001 failed to log rate-limit retry: main-agent retry log failure"),
|
|
);
|
|
|
|
warnSpy.mockRestore();
|
|
});
|
|
|
|
it("logs warning when sessionFile update fails during retry", async () => {
|
|
const warnSpy = vi.spyOn(executorLog, "warn");
|
|
const store = createMockStore();
|
|
const retrySessionFilePath = "/tmp/sessions/retry-failed.jsonl";
|
|
|
|
store.updateTask.mockImplementation(async (_taskId: string, patch: Record<string, unknown>) => {
|
|
if (patch?.sessionFile === retrySessionFilePath) {
|
|
throw new Error("retry sessionFile write failed");
|
|
}
|
|
return {};
|
|
});
|
|
|
|
mockedCreateFnAgent
|
|
.mockResolvedValueOnce({
|
|
session: {
|
|
prompt: vi.fn().mockResolvedValue(undefined),
|
|
dispose: vi.fn(),
|
|
},
|
|
sessionFile: "/tmp/sessions/initial.jsonl",
|
|
} as any)
|
|
.mockResolvedValueOnce({
|
|
session: {
|
|
prompt: vi.fn().mockResolvedValue(undefined),
|
|
dispose: vi.fn(),
|
|
},
|
|
sessionFile: retrySessionFilePath,
|
|
} as any);
|
|
|
|
const executor = new TaskExecutor(store, "/tmp/test");
|
|
await expect(executor.execute({
|
|
id: "FN-001",
|
|
title: "Retry session task",
|
|
description: "Session retry diagnostics",
|
|
column: "in-progress",
|
|
dependencies: [],
|
|
steps: [],
|
|
currentStep: 0,
|
|
log: [],
|
|
createdAt: new Date().toISOString(),
|
|
updatedAt: new Date().toISOString(),
|
|
})).resolves.toBeUndefined();
|
|
|
|
expect(mockedCreateFnAgent.mock.calls.length).toBeGreaterThanOrEqual(2);
|
|
expect(warnSpy).toHaveBeenCalledWith(
|
|
expect.stringContaining("FN-001 failed to persist retry sessionFile: retry sessionFile write failed"),
|
|
);
|
|
|
|
warnSpy.mockRestore();
|
|
});
|
|
|
|
it("logs warning when sessionFile clear fails on completion", async () => {
|
|
const warnSpy = vi.spyOn(executorLog, "warn");
|
|
const store = createMockStore();
|
|
let capturedCustomTools: any[] = [];
|
|
|
|
store.updateTask.mockImplementation(async (_taskId: string, patch: Record<string, unknown>) => {
|
|
if (patch?.sessionFile === null) {
|
|
throw new Error("session clear failed");
|
|
}
|
|
return {};
|
|
});
|
|
|
|
mockedCreateFnAgent.mockImplementation((async (opts: any) => {
|
|
capturedCustomTools = opts.customTools || [];
|
|
return {
|
|
session: {
|
|
prompt: vi.fn().mockImplementation(async () => {
|
|
const taskDoneTool = capturedCustomTools.find((tool: any) => tool.name === "fn_task_done");
|
|
if (taskDoneTool) {
|
|
await taskDoneTool.execute("call-1", { summary: "done" });
|
|
}
|
|
}),
|
|
dispose: vi.fn(),
|
|
},
|
|
sessionFile: "/tmp/sessions/clear-test.jsonl",
|
|
};
|
|
}) as any);
|
|
|
|
const executor = new TaskExecutor(store, "/tmp/test");
|
|
await expect(executor.execute({
|
|
id: "FN-001",
|
|
title: "Session clear task",
|
|
description: "Session clear diagnostics",
|
|
column: "in-progress",
|
|
dependencies: [],
|
|
steps: [],
|
|
currentStep: 0,
|
|
log: [],
|
|
createdAt: new Date().toISOString(),
|
|
updatedAt: new Date().toISOString(),
|
|
})).resolves.toBeUndefined();
|
|
|
|
expect(store.moveTask).toHaveBeenCalledWith("FN-001", "in-review");
|
|
expect(warnSpy).toHaveBeenCalledWith(
|
|
expect.stringContaining("FN-001 failed to clear sessionFile: session clear failed"),
|
|
);
|
|
|
|
warnSpy.mockRestore();
|
|
});
|
|
|
|
it("logs warning when child agent deletion fails during cleanup", async () => {
|
|
vi.useFakeTimers();
|
|
const warnSpy = vi.spyOn(executorLog, "warn");
|
|
|
|
try {
|
|
const store = createMockStore();
|
|
const agentStore = {
|
|
updateAgentState: vi.fn().mockResolvedValue(undefined),
|
|
deleteAgent: vi.fn().mockRejectedValue(new Error("delete failed")),
|
|
};
|
|
|
|
const executor = new TaskExecutor(store, "/tmp/test", {
|
|
agentStore: agentStore as any,
|
|
});
|
|
|
|
(executor as any).childSessions.set("child-007", {
|
|
dispose: vi.fn(),
|
|
});
|
|
|
|
await (executor as any).terminateChildAgent("child-007");
|
|
await Promise.resolve();
|
|
|
|
expect(warnSpy).toHaveBeenCalledWith(
|
|
expect.stringContaining("Failed to delete spawned agent child-007: delete failed"),
|
|
);
|
|
} finally {
|
|
warnSpy.mockRestore();
|
|
vi.useRealTimers();
|
|
}
|
|
});
|
|
});
|
|
|
|
describe("TaskExecutor executor model hot-swap", () => {
|
|
const buildUpdatedTask = (overrides: Partial<Task> = {}): Task => ({
|
|
id: "FN-001",
|
|
title: "Model task",
|
|
description: "Test model updates",
|
|
column: "in-progress",
|
|
paused: false,
|
|
dependencies: [],
|
|
steps: [],
|
|
currentStep: 0,
|
|
log: [],
|
|
createdAt: new Date().toISOString(),
|
|
updatedAt: new Date().toISOString(),
|
|
...overrides,
|
|
});
|
|
|
|
const flushTaskUpdated = async () => {
|
|
await new Promise((resolve) => setTimeout(resolve, 20));
|
|
};
|
|
|
|
beforeEach(() => {
|
|
resetExecutorMocks();
|
|
});
|
|
|
|
it("hot-swaps executor model on active session when modelProvider/modelId change", async () => {
|
|
const store = createMockStore();
|
|
const setModel = vi.fn().mockResolvedValue(undefined);
|
|
const findModel = vi.fn().mockReturnValue({
|
|
provider: { name: "openai" },
|
|
id: "gpt-4o",
|
|
name: "GPT-4o",
|
|
});
|
|
|
|
const executor = new TaskExecutor(store, "/tmp/test");
|
|
(executor as any)._modelRegistry = { find: findModel };
|
|
(executor as any).activeSessions.set("FN-001", {
|
|
session: { setModel, dispose: vi.fn() },
|
|
seenSteeringIds: new Set(),
|
|
lastResolvedModelProvider: "anthropic",
|
|
lastResolvedModelId: "claude-sonnet-4-5",
|
|
lastTaskModelProvider: "anthropic",
|
|
lastTaskModelId: "claude-sonnet-4-5",
|
|
lastAssignedAgentId: null,
|
|
});
|
|
|
|
store._trigger("task:updated", buildUpdatedTask({
|
|
modelProvider: "openai",
|
|
modelId: "gpt-4o",
|
|
}));
|
|
|
|
await flushTaskUpdated();
|
|
|
|
expect(setModel).toHaveBeenCalledTimes(1);
|
|
expect(setModel).toHaveBeenCalledWith(expect.objectContaining({
|
|
provider: expect.objectContaining({ name: "openai" }),
|
|
id: "gpt-4o",
|
|
}));
|
|
expect(store.logEntry).toHaveBeenCalledWith("FN-001", "Model changed to openai/gpt-4o", undefined, undefined);
|
|
});
|
|
|
|
it("does not attempt hot-swap when no active session exists", async () => {
|
|
const store = createMockStore();
|
|
const setModel = vi.fn().mockResolvedValue(undefined);
|
|
|
|
new TaskExecutor(store, "/tmp/test");
|
|
|
|
store._trigger("task:updated", buildUpdatedTask({
|
|
modelProvider: "openai",
|
|
modelId: "gpt-4o",
|
|
}));
|
|
|
|
await flushTaskUpdated();
|
|
|
|
expect(setModel).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("does not hot-swap when model fields are unchanged", async () => {
|
|
const store = createMockStore();
|
|
const setModel = vi.fn().mockResolvedValue(undefined);
|
|
const findModel = vi.fn();
|
|
|
|
const executor = new TaskExecutor(store, "/tmp/test");
|
|
(executor as any)._modelRegistry = { find: findModel };
|
|
(executor as any).activeSessions.set("FN-001", {
|
|
session: { setModel, dispose: vi.fn() },
|
|
seenSteeringIds: new Set(),
|
|
lastResolvedModelProvider: "anthropic",
|
|
lastResolvedModelId: "claude-sonnet-4-5",
|
|
lastTaskModelProvider: "anthropic",
|
|
lastTaskModelId: "claude-sonnet-4-5",
|
|
lastAssignedAgentId: null,
|
|
});
|
|
|
|
store._trigger("task:updated", buildUpdatedTask({
|
|
modelProvider: "anthropic",
|
|
modelId: "claude-sonnet-4-5",
|
|
}));
|
|
|
|
await flushTaskUpdated();
|
|
|
|
expect(findModel).not.toHaveBeenCalled();
|
|
expect(setModel).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("hot-swaps to project default override when task override is cleared", async () => {
|
|
const store = createMockStore();
|
|
const setModel = vi.fn().mockResolvedValue(undefined);
|
|
const findModel = vi.fn().mockReturnValue({
|
|
provider: { name: "openai" },
|
|
id: "gpt-4o",
|
|
name: "GPT-4o",
|
|
});
|
|
|
|
store.getSettings.mockResolvedValue({
|
|
executionProvider: undefined,
|
|
executionModelId: undefined,
|
|
executionGlobalProvider: undefined,
|
|
executionGlobalModelId: undefined,
|
|
defaultProviderOverride: "openai",
|
|
defaultModelIdOverride: "gpt-4o",
|
|
defaultProvider: "anthropic",
|
|
defaultModelId: "claude-sonnet-4-5",
|
|
});
|
|
|
|
const executor = new TaskExecutor(store, "/tmp/test");
|
|
(executor as any)._modelRegistry = { find: findModel };
|
|
(executor as any).activeSessions.set("FN-001", {
|
|
session: { setModel, dispose: vi.fn() },
|
|
seenSteeringIds: new Set(),
|
|
lastResolvedModelProvider: "anthropic",
|
|
lastResolvedModelId: "claude-sonnet-4-5",
|
|
lastTaskModelProvider: "anthropic",
|
|
lastTaskModelId: "claude-sonnet-4-5",
|
|
lastAssignedAgentId: null,
|
|
});
|
|
|
|
store._trigger("task:updated", buildUpdatedTask({
|
|
modelProvider: undefined,
|
|
modelId: undefined,
|
|
}));
|
|
|
|
await flushTaskUpdated();
|
|
|
|
expect(findModel).toHaveBeenCalledWith("openai", "gpt-4o");
|
|
expect(setModel).toHaveBeenCalledTimes(1);
|
|
});
|
|
|
|
it("falls back to global default when project default override pair is incomplete", async () => {
|
|
const store = createMockStore();
|
|
const setModel = vi.fn().mockResolvedValue(undefined);
|
|
const findModel = vi.fn().mockReturnValue({
|
|
provider: { name: "anthropic" },
|
|
id: "claude-sonnet-4-5",
|
|
name: "Claude Sonnet",
|
|
});
|
|
|
|
store.getSettings.mockResolvedValue({
|
|
executionProvider: undefined,
|
|
executionModelId: undefined,
|
|
executionGlobalProvider: undefined,
|
|
executionGlobalModelId: undefined,
|
|
defaultProviderOverride: "openai",
|
|
defaultModelIdOverride: undefined,
|
|
defaultProvider: "anthropic",
|
|
defaultModelId: "claude-sonnet-4-5",
|
|
});
|
|
|
|
const executor = new TaskExecutor(store, "/tmp/test");
|
|
(executor as any)._modelRegistry = { find: findModel };
|
|
(executor as any).activeSessions.set("FN-001", {
|
|
session: { setModel, dispose: vi.fn() },
|
|
seenSteeringIds: new Set(),
|
|
lastResolvedModelProvider: "openai",
|
|
lastResolvedModelId: "gpt-4o",
|
|
lastTaskModelProvider: "openai",
|
|
lastTaskModelId: "gpt-4o",
|
|
lastAssignedAgentId: null,
|
|
});
|
|
|
|
store._trigger("task:updated", buildUpdatedTask({
|
|
modelProvider: undefined,
|
|
modelId: undefined,
|
|
}));
|
|
|
|
await flushTaskUpdated();
|
|
|
|
expect(findModel).toHaveBeenCalledWith("anthropic", "claude-sonnet-4-5");
|
|
expect(setModel).toHaveBeenCalledTimes(1);
|
|
});
|
|
|
|
it("logs error and continues when setModel fails", async () => {
|
|
const store = createMockStore();
|
|
const setModel = vi.fn().mockRejectedValue(new Error("API key not found"));
|
|
const findModel = vi.fn().mockReturnValue({
|
|
provider: { name: "openai" },
|
|
id: "gpt-4o",
|
|
name: "GPT-4o",
|
|
});
|
|
|
|
const executor = new TaskExecutor(store, "/tmp/test");
|
|
(executor as any)._modelRegistry = { find: findModel };
|
|
(executor as any).activeSessions.set("FN-001", {
|
|
session: { setModel, dispose: vi.fn() },
|
|
seenSteeringIds: new Set(),
|
|
lastResolvedModelProvider: "anthropic",
|
|
lastResolvedModelId: "claude-sonnet-4-5",
|
|
lastTaskModelProvider: "anthropic",
|
|
lastTaskModelId: "claude-sonnet-4-5",
|
|
lastAssignedAgentId: null,
|
|
});
|
|
|
|
store._trigger("task:updated", buildUpdatedTask({
|
|
modelProvider: "openai",
|
|
modelId: "gpt-4o",
|
|
}));
|
|
|
|
await flushTaskUpdated();
|
|
|
|
expect(store.logEntry).toHaveBeenCalledWith("FN-001", "Model change failed: API key not found", undefined, undefined);
|
|
expect((executor as any).activeSessions.has("FN-001")).toBe(true);
|
|
});
|
|
|
|
it("does not attempt hot-swap on paused task", async () => {
|
|
const store = createMockStore();
|
|
const setModel = vi.fn().mockResolvedValue(undefined);
|
|
const dispose = vi.fn();
|
|
const findModel = vi.fn();
|
|
|
|
const executor = new TaskExecutor(store, "/tmp/test");
|
|
(executor as any)._modelRegistry = { find: findModel };
|
|
(executor as any).activeSessions.set("FN-001", {
|
|
session: { setModel, dispose },
|
|
seenSteeringIds: new Set(),
|
|
lastResolvedModelProvider: "anthropic",
|
|
lastResolvedModelId: "claude-sonnet-4-5",
|
|
lastTaskModelProvider: "anthropic",
|
|
lastTaskModelId: "claude-sonnet-4-5",
|
|
lastAssignedAgentId: null,
|
|
});
|
|
|
|
store._trigger("task:updated", buildUpdatedTask({
|
|
paused: true,
|
|
modelProvider: "openai",
|
|
modelId: "gpt-4o",
|
|
}));
|
|
|
|
await flushTaskUpdated();
|
|
|
|
expect(dispose).toHaveBeenCalledTimes(1);
|
|
expect(findModel).not.toHaveBeenCalled();
|
|
expect(setModel).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
describe("TaskExecutor task:updated listener guards", () => {
|
|
it("catches and logs errors from async task:updated operations", async () => {
|
|
const store = createMockStore();
|
|
const terminateError = new Error("terminate failed");
|
|
const terminateAllSessions = vi.fn().mockRejectedValue(terminateError);
|
|
|
|
const executor = new TaskExecutor(store, "/tmp/test");
|
|
(executor as any).activeStepExecutors.set("FN-001", {
|
|
terminateAllSessions,
|
|
});
|
|
|
|
const taskUpdatedHandler = (store.on as unknown as ReturnType<typeof vi.fn>).mock.calls
|
|
.find((call: any[]) => call[0] === "task:updated")?.[1];
|
|
|
|
expect(taskUpdatedHandler).toBeTypeOf("function");
|
|
|
|
await expect(taskUpdatedHandler({
|
|
id: "FN-001",
|
|
title: "Guard test",
|
|
description: "Guard test",
|
|
column: "in-progress",
|
|
paused: true,
|
|
dependencies: [],
|
|
steps: [],
|
|
currentStep: 0,
|
|
log: [],
|
|
createdAt: new Date().toISOString(),
|
|
updatedAt: new Date().toISOString(),
|
|
} satisfies Task)).resolves.toBeUndefined();
|
|
|
|
expect(terminateAllSessions).toHaveBeenCalledTimes(1);
|
|
expect(executorLog.error).toHaveBeenCalledWith("Uncaught error in task:updated listener:", terminateError);
|
|
});
|
|
});
|
|
|
|
describe("TaskExecutor global pause behavior", () => {
|
|
beforeEach(() => {
|
|
resetExecutorMocks();
|
|
mockedExistsSync.mockReturnValue(true);
|
|
});
|
|
|
|
it("disposes all active sessions when settings:updated fires with globalPause: true", async () => {
|
|
const store = createMockStore();
|
|
const disposeFn1 = vi.fn();
|
|
const disposeFn2 = vi.fn();
|
|
let callCount = 0;
|
|
|
|
mockedCreateFnAgent.mockImplementation(async () => {
|
|
callCount++;
|
|
const dispose = callCount === 1 ? disposeFn1 : disposeFn2;
|
|
return {
|
|
session: {
|
|
prompt: vi.fn().mockImplementation(async () => {
|
|
// Wait for the global pause to fire; only fire once for first task
|
|
if (callCount === 2) {
|
|
store._trigger("settings:updated", {
|
|
settings: { globalPause: true },
|
|
previous: { globalPause: false },
|
|
});
|
|
}
|
|
throw new Error("Session terminated");
|
|
}),
|
|
dispose,
|
|
},
|
|
} as any;
|
|
});
|
|
|
|
const executor = new TaskExecutor(store, "/tmp/test");
|
|
|
|
// Execute two tasks concurrently
|
|
await Promise.all([
|
|
executor.execute({
|
|
id: "FN-001", title: "T1", description: "T", column: "in-progress",
|
|
dependencies: [], steps: [], currentStep: 0, log: [],
|
|
createdAt: new Date().toISOString(), updatedAt: new Date().toISOString(),
|
|
}),
|
|
executor.execute({
|
|
id: "FN-002", title: "T2", description: "T", column: "in-progress",
|
|
dependencies: [], steps: [], currentStep: 0, log: [],
|
|
createdAt: new Date().toISOString(), updatedAt: new Date().toISOString(),
|
|
}),
|
|
]);
|
|
|
|
// Both tasks should be moved to todo (not marked as failed)
|
|
expect(store.moveTask).toHaveBeenCalledWith("FN-001", "todo");
|
|
expect(store.moveTask).toHaveBeenCalledWith("FN-002", "todo");
|
|
expect(store.updateTask).not.toHaveBeenCalledWith("FN-001", { status: "failed" });
|
|
expect(store.updateTask).not.toHaveBeenCalledWith("FN-002", { status: "failed" });
|
|
});
|
|
|
|
it("moves paused tasks to todo (not marked as failed)", async () => {
|
|
const store = createMockStore();
|
|
|
|
mockedCreateFnAgent.mockImplementation(async () => ({
|
|
session: {
|
|
prompt: vi.fn().mockImplementation(async () => {
|
|
store._trigger("settings:updated", {
|
|
settings: { globalPause: true },
|
|
previous: { globalPause: false },
|
|
});
|
|
throw new Error("Session terminated");
|
|
}),
|
|
dispose: vi.fn(),
|
|
},
|
|
} as any));
|
|
|
|
const executor = new TaskExecutor(store, "/tmp/test");
|
|
await executor.execute({
|
|
id: "FN-001", title: "Test", description: "T", column: "in-progress",
|
|
dependencies: [], steps: [], currentStep: 0, log: [],
|
|
createdAt: new Date().toISOString(), updatedAt: new Date().toISOString(),
|
|
});
|
|
|
|
expect(store.moveTask).toHaveBeenCalledWith("FN-001", "todo");
|
|
expect(store.updateTask).not.toHaveBeenCalledWith("FN-001", { status: "failed" });
|
|
});
|
|
|
|
it("defers completion handoff when global pause hits after fn_task_done", async () => {
|
|
const store = createMockStore();
|
|
let globalPause = false;
|
|
store.getSettings.mockImplementation(async () => ({
|
|
maxConcurrent: 2,
|
|
maxWorktrees: 4,
|
|
pollIntervalMs: 15000,
|
|
autoMerge: false,
|
|
globalPause,
|
|
enginePaused: false,
|
|
}));
|
|
|
|
mockedCreateFnAgent.mockImplementation(async (opts: any) => {
|
|
const customTools = opts.customTools || [];
|
|
return {
|
|
session: {
|
|
prompt: vi.fn().mockImplementation(async () => {
|
|
const taskDoneTool = customTools.find((t: any) => t.name === "fn_task_done");
|
|
if (taskDoneTool) {
|
|
await taskDoneTool.execute("tool-1", {});
|
|
}
|
|
globalPause = true;
|
|
store._trigger("settings:updated", {
|
|
settings: { globalPause: true },
|
|
previous: { globalPause: false },
|
|
});
|
|
throw new Error("Session terminated");
|
|
}),
|
|
dispose: vi.fn(),
|
|
subscribe: vi.fn(),
|
|
on: vi.fn(),
|
|
sessionManager: { getLeafId: vi.fn().mockReturnValue("leaf-1") },
|
|
state: {},
|
|
},
|
|
} as any;
|
|
});
|
|
|
|
const executor = new TaskExecutor(store, "/tmp/test");
|
|
await executor.execute({
|
|
id: "FN-001", title: "Test", description: "T", column: "in-progress",
|
|
dependencies: [], steps: [{ name: "Step 1", status: "pending" }], currentStep: 0, log: [],
|
|
createdAt: new Date().toISOString(), updatedAt: new Date().toISOString(),
|
|
});
|
|
|
|
expect(store.moveTask).not.toHaveBeenCalledWith("FN-001", "in-review");
|
|
expect(store.moveTask).not.toHaveBeenCalledWith("FN-001", "todo");
|
|
expect(
|
|
store.logEntry.mock.calls.some(
|
|
([id, action]: [string, string]) =>
|
|
id === "FN-001" && action.includes("Completion handoff deferred — global pause active"),
|
|
),
|
|
).toBe(true);
|
|
});
|
|
|
|
it("parks todo tasks in in-progress when fn_task_done is called during global pause", async () => {
|
|
const store = createMockStore();
|
|
let capturedCustomTools: any[] = [];
|
|
|
|
const todoTask = {
|
|
id: "FN-001",
|
|
title: "Test",
|
|
description: "T",
|
|
prompt: "# test\n## Steps\n### Step 0: Preflight\n- [ ] check",
|
|
column: "todo",
|
|
paused: true,
|
|
dependencies: [],
|
|
steps: [{ name: "Step 1", status: "pending" }],
|
|
currentStep: 0,
|
|
log: [],
|
|
createdAt: new Date().toISOString(),
|
|
updatedAt: new Date().toISOString(),
|
|
};
|
|
|
|
store.getTask.mockResolvedValue(todoTask);
|
|
store.getSettings.mockResolvedValue({
|
|
maxConcurrent: 2,
|
|
maxWorktrees: 4,
|
|
pollIntervalMs: 15000,
|
|
autoMerge: false,
|
|
globalPause: true,
|
|
enginePaused: false,
|
|
});
|
|
store.moveTask.mockImplementation(async (_id: string, to: string) => ({ ...todoTask, column: to, paused: undefined }));
|
|
|
|
mockedCreateFnAgent.mockImplementation((async (opts: any) => {
|
|
capturedCustomTools = opts.customTools || [];
|
|
return {
|
|
session: {
|
|
prompt: vi.fn().mockImplementation(async () => {
|
|
const taskDoneTool = capturedCustomTools.find((tool: any) => tool.name === "fn_task_done");
|
|
if (taskDoneTool) {
|
|
await taskDoneTool.execute("call-1", { summary: "done" });
|
|
}
|
|
}),
|
|
dispose: vi.fn(),
|
|
},
|
|
};
|
|
}) as any);
|
|
|
|
const executor = new TaskExecutor(store, "/tmp/test");
|
|
await executor.execute(todoTask as any);
|
|
|
|
expect(store.updateTask).not.toHaveBeenCalledWith("FN-001", { paused: false, status: null });
|
|
expect(store.updateTask).toHaveBeenCalledWith("FN-001", { status: null });
|
|
expect(store.moveTask).toHaveBeenCalledWith("FN-001", "in-progress");
|
|
expect(store.moveTask).not.toHaveBeenCalledWith("FN-001", "in-review");
|
|
expect(store.logEntry).toHaveBeenCalledWith(
|
|
"FN-001",
|
|
expect.stringContaining("fn_task_done called while task was in todo during pause"),
|
|
);
|
|
expect(
|
|
store.logEntry.mock.calls.some(
|
|
([id, action]: [string, string]) =>
|
|
id === "FN-001" && action.includes("Completion handoff deferred — global pause active"),
|
|
),
|
|
).toBe(true);
|
|
});
|
|
|
|
it("takes no action when globalPause remains false", async () => {
|
|
const store = createMockStore();
|
|
const disposeFn = vi.fn();
|
|
let capturedCustomTools: any[] = [];
|
|
|
|
mockedCreateFnAgent.mockImplementation((async (opts: any) => {
|
|
capturedCustomTools = opts.customTools || [];
|
|
return {
|
|
session: {
|
|
prompt: vi.fn().mockImplementation(async () => {
|
|
store._trigger("settings:updated", {
|
|
settings: { globalPause: false },
|
|
previous: { globalPause: false },
|
|
});
|
|
const taskDoneTool = capturedCustomTools.find((tool: any) => tool.name === "fn_task_done");
|
|
if (taskDoneTool) {
|
|
await taskDoneTool.execute("call-1", { summary: "done" });
|
|
}
|
|
}),
|
|
dispose: disposeFn,
|
|
},
|
|
};
|
|
}) as any);
|
|
|
|
const executor = new TaskExecutor(store, "/tmp/test");
|
|
await executor.execute({
|
|
id: "FN-001", title: "Test", description: "T", column: "in-progress",
|
|
dependencies: [], steps: [], currentStep: 0, log: [],
|
|
createdAt: new Date().toISOString(), updatedAt: new Date().toISOString(),
|
|
});
|
|
|
|
// Should move to in-review (normal completion), not todo
|
|
expect(store.moveTask).toHaveBeenCalledWith("FN-001", "in-review");
|
|
expect(store.moveTask).not.toHaveBeenCalledWith("FN-001", "todo");
|
|
});
|
|
|
|
it("takes no action when globalPause transitions from true to true", async () => {
|
|
const store = createMockStore();
|
|
let capturedCustomTools: any[] = [];
|
|
|
|
mockedCreateFnAgent.mockImplementation((async (opts: any) => {
|
|
capturedCustomTools = opts.customTools || [];
|
|
return {
|
|
session: {
|
|
prompt: vi.fn().mockImplementation(async () => {
|
|
store._trigger("settings:updated", {
|
|
settings: { globalPause: true },
|
|
previous: { globalPause: true },
|
|
});
|
|
const taskDoneTool = capturedCustomTools.find((tool: any) => tool.name === "fn_task_done");
|
|
if (taskDoneTool) {
|
|
await taskDoneTool.execute("call-1", { summary: "done" });
|
|
}
|
|
}),
|
|
dispose: vi.fn(),
|
|
},
|
|
};
|
|
}) as any);
|
|
|
|
const executor = new TaskExecutor(store, "/tmp/test");
|
|
await executor.execute({
|
|
id: "FN-001", title: "Test", description: "T", column: "in-progress",
|
|
dependencies: [], steps: [], currentStep: 0, log: [],
|
|
createdAt: new Date().toISOString(), updatedAt: new Date().toISOString(),
|
|
});
|
|
|
|
// Should move to in-review (normal completion), not todo
|
|
expect(store.moveTask).toHaveBeenCalledWith("FN-001", "in-review");
|
|
expect(store.moveTask).not.toHaveBeenCalledWith("FN-001", "todo");
|
|
});
|
|
});
|
|
|