fix(lobster): preserve explicit empty managed flow state

LiLan0125 · LiLan0125 · commit 6f2177f2ac8a · 2026-07-08T13:42:28.000+08:00
diff --git a/extensions/lobster/src/lobster-tool.test.ts b/extensions/lobster/src/lobster-tool.test.ts
@@ -323,6 +323,41 @@ describe("lobster plugin tool", () => {
     expect(mutation.applied).toBe(true);
   });
 
+  it("preserves explicit empty flow state in managed TaskFlow run mode", async () => {
+    const runner = {
+      run: vi.fn().mockResolvedValue({
+        ok: true,
+        status: "ok",
+        output: [],
+        requiresApproval: null,
+      }),
+    };
+    const taskFlow = createFakeTaskFlow();
+
+    const tool = createLobsterTool(fakeApi(), { runner, taskFlow });
+    await tool.execute("call-managed-run-empty-state", {
+      action: "run",
+      pipeline: "noop",
+      flowControllerId: "tests/lobster",
+      flowGoal: "Run Lobster workflow",
+      flowStateJson: "{}",
+    });
+
+    expect(taskFlow.createManaged).toHaveBeenCalledWith({
+      controllerId: "tests/lobster",
+      goal: "Run Lobster workflow",
+      currentStep: "run_lobster",
+      stateJson: {},
+    });
+    expect(runner.run).toHaveBeenCalledWith({
+      action: "run",
+      pipeline: "noop",
+      cwd: process.cwd(),
+      timeoutMs: 20_000,
+      maxStdoutBytes: 512_000,
+    });
+  });
+
   it("rejects managed TaskFlow params when no bound taskFlow runtime is available", async () => {
     const tool = createLobsterTool(fakeApi(), {
       runner: { run: vi.fn() },
diff --git a/extensions/lobster/src/lobster-tool.ts b/extensions/lobster/src/lobster-tool.ts
@@ -102,21 +102,22 @@ function parseOptionalFlowStateJson(value: unknown): JsonLike | undefined {
     return undefined;
   }
   try {
-    const parsed = JSON.parse(trimmed) as JsonLike;
-    if (
-      parsed !== null &&
-      typeof parsed === "object" &&
-      !Array.isArray(parsed) &&
-      Object.keys(parsed).length === 0
-    ) {
-      return undefined;
-    }
-    return parsed;
+    return JSON.parse(trimmed) as JsonLike;
   } catch {
     throw new Error("flowStateJson must be valid JSON");
   }
 }
 
+function isEmptyJsonObject(value: JsonLike | undefined): boolean {
+  return (
+    value !== undefined &&
+    value !== null &&
+    typeof value === "object" &&
+    !Array.isArray(value) &&
+    Object.keys(value).length === 0
+  );
+}
+
 function parseRunFlowParams(params: Record<string, unknown>): ManagedFlowRunParams | null {
   const controllerId = readOptionalTrimmedString(params.flowControllerId, "flowControllerId");
   const goal = readOptionalTrimmedString(params.flowGoal, "flowGoal");
@@ -125,13 +126,14 @@ function parseRunFlowParams(params: Record<string, unknown>): ManagedFlowRunPara
   const stateJson = parseOptionalFlowStateJson(params.flowStateJson);
   const resumeFlowId = readOptionalTrimmedString(params.flowId, "flowId");
   const resumeRevision = readOptionalNumber(params.flowExpectedRevision, "flowExpectedRevision");
+  const stateJsonSignalsRunMode = stateJson !== undefined && !isEmptyJsonObject(stateJson);
 
   const hasRunFields =
     controllerId !== undefined ||
     goal !== undefined ||
     currentStep !== undefined ||
     waitingStep !== undefined ||
-    stateJson !== undefined;
+    stateJsonSignalsRunMode;
 
   if (!hasRunFields) {
     return null;
@@ -175,7 +177,8 @@ function parseResumeFlowParams(params: Record<string, unknown>): ManagedFlowResu
     return null;
   }
   const stateJson = parseOptionalFlowStateJson(params.flowStateJson);
-  if (runControllerId !== undefined || runGoal !== undefined || stateJson !== undefined) {
+  const stateJsonDisallowed = stateJson !== undefined && !isEmptyJsonObject(stateJson);
+  if (runControllerId !== undefined || runGoal !== undefined || stateJsonDisallowed) {
     throw new Error("resume action does not accept flowControllerId, flowGoal, or flowStateJson");
   }
   if (!flowId) {
