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

chore(engine): remove workflow-step mock routing + stale FN-5482 docs

Browse Source 
Drops the "workflow-step" MockSessionPurpose enum value and the
workflowStepId / workflowStepTemplateId plumbing through
agent-runtime, agent-session-helpers, mock-provider, executor, and
merger. The seeded-workflow-prompts script loses its FN-5205
rationale comment + test (no longer applicable now that workflow
steps run through the regular session purposes).

Also strips the stale FN-5482 architecture-invariant bullet from
AGENTS.md and the corresponding audit-event line from
docs/architecture.md (the self-healing reclaim invariant they
described no longer holds).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
gsxdsm
2026-05-23 03:09:00 -07:00
parent ba6b41f533
commit 2209c57dd6
14 changed files with 23 additions and 302 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
packages/engine/src/__tests__/agent-session-helpers.test.ts
View File

@@ -126,26 +126,6 @@ describe("createResolvedAgentSession", () => {
}),
);
});
it("forwards workflow step runtime context fields to mock sessions", async () => {
const { createResolvedAgentSession } = await import("../agent-session-helpers.js");
const result = await createResolvedAgentSession({
sessionPurpose: "executor",
pluginRunner: undefined,
cwd: "/tmp/project",
systemPrompt: "system",
defaultProvider: "mock",
runtimeContext: {
workflowStepId: "WS-004",
workflowStepTemplateId: "browser-verification",
},
});
const mockMeta = (result.session as unknown as { __mock?: { workflowStepId?: string; workflowStepTemplateId?: string } }).__mock;
expect(mockMeta?.workflowStepId).toBe("WS-004");
expect(mockMeta?.workflowStepTemplateId).toBe("browser-verification");
});
});
describe("resolveMergerSessionModel", () => {

32
packages/engine/src/__tests__/mock-provider.test.ts
View File

@@ -27,7 +27,6 @@ import {
clearMockScript,
resetMockScripts,
setMockScript,
resolveMockScript,
} from "../providers/mock-provider.js";
function createTool(name: string, execute = vi.fn().mockResolvedValue({ content: [], details: {} })): ToolDefinition {
@@ -68,7 +67,6 @@ describe("MockAgentRuntime", () => {
["merger", []],
["heartbeat", []],
["validation", []],
["workflow-step", []],
] as const)("runs the default %s script deterministically", async (sessionPurpose, expectedCalls) => {
const runtime = new MockAgentRuntime();
const { cwd, taskDir, taskId } = await createWorkspace();
@@ -130,34 +128,6 @@ describe("MockAgentRuntime", () => {
if (sessionPurpose === "reviewer" || sessionPurpose === "validation") {
expect(onText).toHaveBeenCalledWith(expect.stringContaining("Verdict: APPROVE"));
}
if (sessionPurpose === "workflow-step") {
expect(onText).toHaveBeenCalledWith(expect.stringContaining('{"verdict":"APPROVE","notes":""}'));
}
});
it("resolves mock script overrides by specificity precedence", async () => {
const defaultScript = resolveMockScript({ sessionPurpose: "workflow-step" });
const purposeOnly = { run: vi.fn(async () => undefined) };
const templateOnly = { run: vi.fn(async () => undefined) };
const taskOnly = { run: vi.fn(async () => undefined) };
const taskAndTemplate = { run: vi.fn(async () => undefined) };
setMockScript({ sessionPurpose: "workflow-step" }, purposeOnly);
setMockScript({ sessionPurpose: "workflow-step", workflowStepTemplateId: "browser-verification" }, templateOnly);
setMockScript({ sessionPurpose: "workflow-step", taskId: "FN-1" }, taskOnly);
setMockScript({ sessionPurpose: "workflow-step", taskId: "FN-1", workflowStepTemplateId: "browser-verification" }, taskAndTemplate);
expect(resolveMockScript({ sessionPurpose: "workflow-step", taskId: "FN-1", workflowStepTemplateId: "browser-verification" })).toBe(taskAndTemplate);
expect(resolveMockScript({ sessionPurpose: "workflow-step", taskId: "FN-1", workflowStepTemplateId: "other-template" })).toBe(taskOnly);
expect(resolveMockScript({ sessionPurpose: "workflow-step", taskId: "FN-2", workflowStepTemplateId: "browser-verification" })).toBe(templateOnly);
expect(resolveMockScript({ sessionPurpose: "workflow-step", taskId: "FN-2", workflowStepTemplateId: "other-template" })).toBe(purposeOnly);
expect(resolveMockScript({ sessionPurpose: "workflow-step" })).toBe(purposeOnly);
clearMockScript({ sessionPurpose: "workflow-step", taskId: "FN-1", workflowStepTemplateId: "browser-verification" });
clearMockScript({ sessionPurpose: "workflow-step", taskId: "FN-1" });
clearMockScript({ sessionPurpose: "workflow-step", workflowStepTemplateId: "browser-verification" });
clearMockScript({ sessionPurpose: "workflow-step" });
expect(resolveMockScript({ sessionPurpose: "workflow-step" })).toBe(defaultScript);
});
it("prefers a task-scoped override over the default script", async () => {
@@ -230,7 +200,7 @@ describe("MockAgentRuntime", () => {
throw new Error("https.request should not be called");
});
for (const sessionPurpose of ["executor", "triage", "reviewer", "merger", "heartbeat", "validation", "workflow-step"] as const) {
for (const sessionPurpose of ["executor", "triage", "reviewer", "merger", "heartbeat", "validation"] as const) {
const { cwd, taskId } = await createWorkspace(`FN-${sessionPurpose}`);
const { session } = await runtime.createSession({
cwd,

127
packages/engine/src/__tests__/workflow-step-test-mode.test.ts
View File

@@ -1,127 +0,0 @@
import { beforeEach, describe, expect, it, vi } from "vitest";
import "./executor-test-helpers.js";
import { TaskExecutor, parseWorkflowStepVerdict } from "../executor.js";
import { mockedCreateFnAgent, createMockStore, resetExecutorMocks } from "./executor-test-helpers.js";
function buildTask() {
return {
id: "FN-5205",
title: "Workflow test",
description: "",
column: "in-progress" as const,
dependencies: [],
steps: [{ name: "Preflight", status: "done" as const }],
currentStep: 0,
log: [],
enabledWorkflowSteps: ["WS-004"],
createdAt: new Date().toISOString(),
updatedAt: new Date().toISOString(),
};
}
function buildStep() {
return {
id: "WS-004",
templateId: "browser-verification",
name: "Browser Verification",
mode: "prompt",
toolMode: "readonly",
prompt: "verify",
gateMode: "gate",
enabled: true,
createdAt: new Date().toISOString(),
updatedAt: new Date().toISOString(),
};
}
function scriptedSession(output: string) {
const subscribers: Array<(event: any) => void> = [];
return {
state: {},
subscribe: (cb: (event: any) => void) => subscribers.push(cb),
prompt: vi.fn(async () => {
subscribers.forEach((cb) => cb({ type: "message_update", assistantMessageEvent: { type: "text_delta", delta: output } }));
}),
dispose: vi.fn(),
getSessionStats: () => ({ tokens: { input: 100, output: 50, cacheRead: 0, cacheWrite: 0 } }),
};
}
describe("workflow-step test mode routing", () => {
beforeEach(() => {
resetExecutorMocks();
});
it("FN-5205 test mode browser verification defaults to APPROVE", async () => {
const store = createMockStore();
const task = buildTask();
store.getTask.mockResolvedValue(task as any);
store.getWorkflowStep.mockResolvedValue(buildStep() as any);
vi.spyOn(TaskExecutor.prototype as any, "captureModifiedFiles").mockResolvedValue([]);
mockedCreateFnAgent.mockResolvedValue({ session: scriptedSession('{"verdict":"APPROVE","notes":""}\n') as any, sessionFile: undefined } as any);
const executor = new TaskExecutor(store as any, "/tmp/test", {} as any);
const result = await (executor as any).runWorkflowSteps(task as any, "/tmp/test", { testMode: true, defaultProvider: "anthropic", defaultModelId: "claude-sonnet-4-5" });
expect(result.allPassed).toBe(true);
const args = mockedCreateFnAgent.mock.calls.at(-1)?.[0] as any;
expect(args?.defaultProvider).toBe("mock");
expect(args?.defaultModelId).toBe("scripted");
expect(args?.runtimeContext).toEqual({ workflowStepId: "WS-004", workflowStepTemplateId: "browser-verification" });
const parsed = parseWorkflowStepVerdict('{"verdict":"APPROVE","notes":""}');
expect(parsed?.verdict).toBe("APPROVE");
});
it("test mode per-template REVISE override blocks merge path", async () => {
const store = createMockStore();
const task = buildTask();
store.getTask.mockResolvedValue(task as any);
store.getWorkflowStep.mockResolvedValue(buildStep() as any);
vi.spyOn(TaskExecutor.prototype as any, "captureModifiedFiles").mockResolvedValue([]);
mockedCreateFnAgent.mockResolvedValue({ session: scriptedSession('{"verdict":"REVISE","notes":"forced FAIL via FN-5205 override"}\n') as any, sessionFile: undefined } as any);
const executor = new TaskExecutor(store as any, "/tmp/test", {} as any);
const result = await (executor as any).runWorkflowSteps(task as any, "/tmp/test", { testMode: true, defaultProvider: "anthropic", defaultModelId: "claude-sonnet-4-5" });
expect(result).toEqual(expect.objectContaining({ allPassed: false, revisionRequested: true, stepName: "Browser Verification" }));
expect(String((result as any).feedback)).toContain("forced FAIL");
});
it("test mode off preserves real-provider selection while forwarding template context", async () => {
const store = createMockStore();
const task = buildTask();
store.getTask.mockResolvedValue(task as any);
store.getWorkflowStep.mockResolvedValue(buildStep() as any);
const executor = new TaskExecutor(store as any, "/tmp/test", {} as any);
mockedCreateFnAgent.mockResolvedValue({ session: scriptedSession('{"verdict":"APPROVE","notes":""}\n') as any, sessionFile: undefined } as any);
await (executor as any).executeWorkflowStep(task as any, buildStep() as any, "/tmp/test", {
defaultProvider: "anthropic",
defaultModelId: "claude-sonnet-4-5",
}, undefined);
const args = mockedCreateFnAgent.mock.calls.at(-1)?.[0] as any;
expect(args?.defaultProvider).toBe("anthropic");
expect(args?.runtimeContext?.workflowStepTemplateId).toBe("browser-verification");
});
it("FN-5205 mock workflow-step path does not spawn browser harness or bash tools", async () => {
const store = createMockStore();
const task = buildTask();
store.getWorkflowStep.mockResolvedValue(buildStep() as any);
mockedCreateFnAgent.mockResolvedValue({ session: scriptedSession('{"verdict":"APPROVE","notes":""}\n') as any, sessionFile: undefined } as any);
const executor = new TaskExecutor(store as any, "/tmp/test", {} as any);
await (executor as any).executeWorkflowStep(task as any, buildStep() as any, "/tmp/test", { testMode: true, defaultProvider: "mock", defaultModelId: "scripted" }, undefined);
const args = mockedCreateFnAgent.mock.calls.at(-1)?.[0] as any;
expect(args?.tools).toBe("readonly");
expect((args?.customTools ?? []).some((tool: { name?: string }) => {
const name = String(tool.name ?? "");
return name === "bash" || name === "Bash" || name.startsWith("agent-browser");
})).toBe(false);
});
});