root/fusion
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix: reserve and clear task worktrees correctly

Browse Source
This commit is contained in:
gsxdsm
2026-04-05 20:56:58 -07:00
parent 97eecb1b65
commit fc47b6eb01
8 changed files with 207 additions and 23 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
.changeset/reserve-worktree-before-in-progress.md Normal file
View File

@@ -0,0 +1,5 @@
---
"@gsxdsm/fusion": patch
---
Reserve a task worktree path before moving it into in-progress so active tasks do not appear without an assigned worktree.

28
packages/core/src/store.test.ts
View File

@@ -2971,6 +2971,34 @@ Task with acceptance criteria
expect(duplicated.status).toBeUndefined();
});
it("clears nullable execution fields via updateTask(null)", async () => {
const task = await store.createTask({ description: "Test clear nullable execution fields", column: "todo" });
await store.updateTask(task.id, {
worktree: "/some/path",
branch: "fusion/fn-001",
baseBranch: "main",
baseCommitSha: "abc123",
status: "executing",
error: "boom",
});
const updated = await store.updateTask(task.id, {
worktree: null,
branch: null,
baseBranch: null,
baseCommitSha: null,
status: null,
error: null,
});
expect(updated.worktree).toBeUndefined();
expect(updated.branch).toBeUndefined();
expect(updated.baseBranch).toBeUndefined();
expect(updated.baseCommitSha).toBeUndefined();
expect(updated.status).toBeUndefined();
expect(updated.error).toBeUndefined();
});
it("does NOT copy dependencies", async () => {
const dep = await store.createTask({ description: "Dependency" });
const task = await store.createTask({ description: "Test task", dependencies: [dep.id] });

26
packages/core/src/store.ts
View File

@@ -1016,7 +1016,7 @@ export class TaskStore extends EventEmitter<TaskStoreEvents> {
async updateTask(
id: string,
updates: { title?: string; description?: string; prompt?: string; worktree?: string; status?: string | null; dependencies?: string[]; blockedBy?: string | null; paused?: boolean; baseBranch?: string; branch?: string; baseCommitSha?: string; size?: "S" | "M" | "L"; reviewLevel?: number; mergeRetries?: number; stuckKillCount?: number | null; recoveryRetryCount?: number | null; nextRecoveryAt?: string | null; modelProvider?: string | null; modelId?: string | null; validatorModelProvider?: string | null; validatorModelId?: string | null; error?: string | null; summary?: string | null; sessionFile?: string | null; workflowStepResults?: import("./types.js").WorkflowStepResult[] | null; modifiedFiles?: string[] | null; missionId?: string | null; sliceId?: string | null },
updates: { title?: string; description?: string; prompt?: string; worktree?: string | null; status?: string | null; dependencies?: string[]; blockedBy?: string | null; paused?: boolean; baseBranch?: string | null; branch?: string | null; baseCommitSha?: string | null; size?: "S" | "M" | "L"; reviewLevel?: number; mergeRetries?: number; stuckKillCount?: number | null; recoveryRetryCount?: number | null; nextRecoveryAt?: string | null; modelProvider?: string | null; modelId?: string | null; validatorModelProvider?: string | null; validatorModelId?: string | null; error?: string | null; summary?: string | null; sessionFile?: string | null; workflowStepResults?: import("./types.js").WorkflowStepResult[] | null; modifiedFiles?: string[] | null; missionId?: string | null; sliceId?: string | null },
): Promise<Task> {
return this.withTaskLock(id, async () => {
// Validate that task doesn't depend on itself
@@ -1034,7 +1034,11 @@ export class TaskStore extends EventEmitter<TaskStoreEvents> {
if (updates.title !== undefined) task.title = updates.title;
if (updates.description !== undefined) task.description = updates.description;
if (updates.worktree !== undefined) task.worktree = updates.worktree;
if (updates.worktree === null) {
task.worktree = undefined;
} else if (updates.worktree !== undefined) {
task.worktree = updates.worktree;
}
// Detect new dependencies being added to a todo task → auto-move to triage
let movedToTriage = false;
if (updates.dependencies !== undefined) {
@@ -1064,9 +1068,21 @@ export class TaskStore extends EventEmitter<TaskStoreEvents> {
task.blockedBy = updates.blockedBy;
}
if (updates.paused !== undefined) task.paused = updates.paused || undefined;
if (updates.baseBranch !== undefined) task.baseBranch = updates.baseBranch;
if (updates.branch !== undefined) task.branch = updates.branch;
if (updates.baseCommitSha !== undefined) task.baseCommitSha = updates.baseCommitSha;
if (updates.baseBranch === null) {
task.baseBranch = undefined;
} else if (updates.baseBranch !== undefined) {
task.baseBranch = updates.baseBranch;
}
if (updates.branch === null) {
task.branch = undefined;
} else if (updates.branch !== undefined) {
task.branch = updates.branch;
}
if (updates.baseCommitSha === null) {
task.baseCommitSha = undefined;
} else if (updates.baseCommitSha !== undefined) {
task.baseCommitSha = updates.baseCommitSha;
}
if (updates.size !== undefined) task.size = updates.size;
if (updates.reviewLevel !== undefined) task.reviewLevel = updates.reviewLevel;
if (updates.mergeRetries !== undefined) task.mergeRetries = updates.mergeRetries;

24
packages/dashboard/src/routes.test.ts
View File

@@ -701,10 +701,10 @@ describe("POST /tasks/:id/retry", () => {
expect(res.status).toBe(200);
expect(store.updateTask).toHaveBeenCalledWith("KB-001", {
status: undefined,
error: undefined,
worktree: undefined,
branch: undefined,
status: null,
error: null,
worktree: null,
branch: null,
});
expect(store.moveTask).toHaveBeenCalledWith("KB-001", "todo");
});
@@ -734,10 +734,10 @@ describe("POST /tasks/:id/retry", () => {
expect(res.status).toBe(200);
expect(store.updateTask).toHaveBeenCalledWith("KB-001", {
status: undefined,
error: undefined,
worktree: undefined,
branch: undefined,
status: null,
error: null,
worktree: null,
branch: null,
});
expect(store.moveTask).toHaveBeenCalledWith("KB-001", "todo");
});
@@ -755,10 +755,10 @@ describe("POST /tasks/:id/retry", () => {
expect(res.status).toBe(200);
expect(store.updateTask).toHaveBeenCalledWith("KB-001", {
status: undefined,
error: undefined,
worktree: undefined,
branch: undefined,
status: null,
error: null,
worktree: null,
branch: null,
});
expect(store.moveTask).toHaveBeenCalledWith("KB-001", "todo");
expect(store.logEntry).toHaveBeenCalledWith("KB-001", "Retry requested from dashboard");

8
packages/dashboard/src/routes.ts
View File

@@ -1794,10 +1794,10 @@ export function createApiRoutes(store: TaskStore, options?: ServerOptions): Rout
return;
}
await scopedStore.updateTask(req.params.id, {
status: undefined,
error: undefined,
worktree: undefined,
branch: undefined,
status: null,
error: null,
worktree: null,
branch: null,
});
await scopedStore.logEntry(req.params.id, "Retry requested from dashboard");
const updated = await scopedStore.moveTask(req.params.id, "todo");

72
packages/engine/src/scheduler.test.ts
View File

@@ -538,6 +538,78 @@ describe("Scheduler", () => {
});
});
describe("worktree reservation", () => {
it("assigns a planned worktree path before moving a task to in-progress", async () => {
vi.mocked(existsSync).mockReturnValue(true);
vi.mocked(readFile).mockResolvedValue("# Task\nDo something");
const task = createMockTask({ id: "FN-010", column: "todo" });
const updateTask = vi.fn().mockResolvedValue(undefined);
const moveTask = vi.fn().mockResolvedValue(undefined);
const store = createMockStore({
listTasks: vi.fn().mockResolvedValue([task]),
getSettings: vi.fn().mockResolvedValue({ maxConcurrent: 2, maxWorktrees: 4, worktreeNaming: "task-id" }),
updateTask,
moveTask,
});
const scheduler = new Scheduler(store);
(scheduler as any).running = true;
await scheduler.schedule();
expect(updateTask).toHaveBeenCalledWith("FN-010", {
status: null,
blockedBy: null,
baseBranch: undefined,
worktree: "/test/project/.worktrees/fn-010",
});
expect(moveTask).toHaveBeenCalledWith("FN-010", "in-progress");
expect(updateTask.mock.invocationCallOrder[0]).toBeLessThan(moveTask.mock.invocationCallOrder[0]);
});
it("reserves unique random worktree names within the same scheduling pass", async () => {
vi.mocked(existsSync).mockReturnValue(true);
vi.mocked(readFile).mockResolvedValue("# Task\nDo something");
const randomSpy = vi.spyOn(Math, "random")
.mockReturnValueOnce(0)
.mockReturnValueOnce(0)
.mockReturnValueOnce(0)
.mockReturnValueOnce(0);
const updateTask = vi.fn().mockResolvedValue(undefined);
const moveTask = vi.fn().mockResolvedValue(undefined);
const store = createMockStore({
listTasks: vi.fn().mockResolvedValue([
createMockTask({ id: "FN-011", column: "todo" }),
createMockTask({ id: "FN-012", column: "todo" }),
]),
getSettings: vi.fn().mockResolvedValue({ maxConcurrent: 4, maxWorktrees: 4, worktreeNaming: "random" }),
updateTask,
moveTask,
});
const scheduler = new Scheduler(store);
(scheduler as any).running = true;
await scheduler.schedule();
expect(updateTask).toHaveBeenNthCalledWith(1, "FN-011", {
status: null,
blockedBy: null,
baseBranch: undefined,
worktree: "/test/project/.worktrees/amber-aspen",
});
expect(updateTask).toHaveBeenNthCalledWith(2, "FN-012", {
status: null,
blockedBy: null,
baseBranch: undefined,
worktree: "/test/project/.worktrees/amber-aspen-2",
});
randomSpy.mockRestore();
});
});
describe("semaphore integration", () => {
it("respects semaphore available count", async () => {
const semaphore = {

53
packages/engine/src/scheduler.ts
View File

@@ -3,6 +3,7 @@ import { existsSync } from "node:fs";
import { readFile } from "node:fs/promises";
import { join } from "node:path";
import type { AgentSemaphore } from "./concurrency.js";
import { generateReservedWorktreeName, slugify } from "./worktree-names.js";
import { schedulerLog } from "./logger.js";
import { type PrMonitor, type PrComment } from "./pr-monitor.js";
import { getCurrentGitHubRepo } from "./github.js";
@@ -348,6 +349,39 @@ export class Scheduler {
return pathsOverlap(a, b);
}
/**
* Reserve the worktree path a task will use before it enters in-progress.
* This prevents tasks from appearing active without an assigned worktree.
*/
private planWorktreePath(
task: Task,
naming: string | undefined,
reservedNames: Set<string>,
): string {
if (task.worktree) {
const existingName = task.worktree.split("/").pop();
if (existingName) reservedNames.add(existingName);
return task.worktree;
}
let worktreeName: string;
switch (naming || "random") {
case "task-id":
worktreeName = task.id.toLowerCase();
break;
case "task-title":
worktreeName = slugify(task.title || task.description.slice(0, 60));
break;
case "random":
default:
worktreeName = generateReservedWorktreeName(this.store.getRootDir(), reservedNames);
break;
}
reservedNames.add(worktreeName);
return join(this.store.getRootDir(), ".worktrees", worktreeName);
}
/**
* Run one scheduling pass.
*
@@ -521,6 +555,11 @@ export class Scheduler {
// Resolve dependency order among todo tasks
const ordered = resolveDependencyOrder(todo);
let started = 0;
const reservedWorktreeNames = new Set(
tasks
.map((task) => task.worktree?.split("/").pop())
.filter((name): name is string => Boolean(name)),
);
for (const taskId of ordered) {
const task = tasks.find((t) => t.id === taskId)!;
@@ -571,10 +610,20 @@ export class Scheduler {
// Dependencies met — resolve base branch from in-review deps
const baseBranch = this.resolveBaseBranch(task, tasks);
const plannedWorktree = this.planWorktreePath(
task,
settings.worktreeNaming,
reservedWorktreeNames,
);
// Clear status and move to in-progress
// Clear status, reserve worktree path, and then move to in-progress
schedulerLog.log(`Starting ${task.id}: ${task.title || task.id} (deps satisfied)`);
await this.store.updateTask(task.id, { status: null, blockedBy: null, baseBranch: baseBranch ?? undefined });
await this.store.updateTask(task.id, {
status: null,
blockedBy: null,
baseBranch: baseBranch ?? undefined,
worktree: plannedWorktree,
});
await this.store.moveTask(task.id, "in-progress");
this.options.onSchedule?.(task);
started++;

14
packages/engine/src/worktree-names.ts
View File

@@ -61,12 +61,26 @@ export function slugify(str: string): string {
* @returns A unique worktree directory name (not a full path)
*/
export function generateWorktreeName(rootDir: string): string {
return generateReservedWorktreeName(rootDir);
}
/**
* Generate a unique worktree directory name while also avoiding names that
* have been reserved in-memory but may not exist on disk yet.
*/
export function generateReservedWorktreeName(
rootDir: string,
reservedNames: Set<string> = new Set(),
): string {
const adjective = ADJECTIVES[Math.floor(Math.random() * ADJECTIVES.length)];
const noun = NOUNS[Math.floor(Math.random() * NOUNS.length)];
const baseName = `${adjective}-${noun}`;
const worktreesDir = join(rootDir, ".worktrees");
const existing = getExistingWorktreeNames(worktreesDir);
for (const reserved of reservedNames) {
existing.add(reserved);
}
if (!existing.has(baseName)) {
return baseName;