fix(server): preserve approval answers through provider acknowledgements

apps/server/src/orchestration-v2/testkit/OpenCodeReplayFixtures.integration.test.ts

@@ -1,4 +1,5 @@
-import { describe, it } from "@effect/vitest";
+import { projectionFor } from "./fixtures/shared.ts";
+import { assert, describe, it } from "@effect/vitest";
 import type { ProviderReplayEntry } from "@t3tools/contracts";
 import * as Effect from "effect/Effect";
 
@@ -59,6 +60,68 @@ describe("OpenCode replay fixtures", () => {
         }),
       }),
   );
+  it.effect("keeps an OpenCode decline when the turn ends without acknowledgement", () => {
+    const fixture = findReplayFixture("opencode_child_approval");
+    const provider = fixture?.providers.find((candidate) => candidate.driver === "opencode");
+    assert.isDefined(fixture);
+    assert.isDefined(provider);
+    return runReplayFixture({
+      harness: OpenCodeOrchestratorReplayHarness,
+      fixtureName: fixture.name,
+      buildInput: () => ({
+        ...fixture.buildInput(),
+        steps: fixture
+          .buildInput()
+          .steps.map((step) =>
+            step.type === "approve_next_runtime_request" ? { ...step, decision: "decline" } : step,
+          ),
+      }),
+      driver: {
+        ...provider,
+        assertOutput: (result) => {
+          const projection = projectionFor(result, fixture.name);
+          assert.lengthOf(projection.runtimeRequests, 1);
+          const request = projection.runtimeRequests[0]!;
+          assert.deepInclude(request, { status: "resolved", decision: "decline" });
+          assert.equal(
+            projection.nodes.find((node) => node.id === request.nodeId)?.status,
+            "cancelled",
+          );
+          assert.equal(
+            projection.turnItems.find((item) => item.nodeId === request.nodeId)?.status,
+            "cancelled",
+          );
+          assert.equal(projection.runs.at(-1)?.status, "completed");
+        },
+      },
+      transformTranscript: (transcript) => {
+        assert.isTrue(
+          transcript.entries.some(
+            (entry) => entry.type === "expect_outbound" && entry.label === "permission.reply",
+          ),
+        );
+        assert.isTrue(
+          transcript.entries.some(
+            (entry) => entry.type === "emit_inbound" && entry.label === "child.permission.replied",
+          ),
+        );
+        return {
+          ...transcript,
+          entries: transcript.entries
+            .filter(
+              (entry) =>
+                entry.type !== "emit_inbound" || entry.label !== "child.permission.replied",
+            )
+            .map((entry) => {
+              if (entry.type !== "expect_outbound" || entry.label !== "permission.reply")
+                return entry;
+              const frame = entry.frame as { readonly input: object };
+              return { ...entry, frame: { ...frame, input: { ...frame.input, reply: "reject" } } };
+            }),
+        };
+      },
+    });
+  });
 });
 
 function undecodableEvent(entry: ProviderReplayEntry): ProviderReplayEntry {

apps/server/src/orchestration-v2/testkit/fixtures/muse_permission/output.ts

@@ -38,6 +38,14 @@ export function assertMusePermissionOutput(
       ["command", "resolved", "decline"],
     ],
   );
+  for (const request of requests) {
+    const status = request.decision === "decline" ? "cancelled" : "completed";
+    assert.equal(projection.nodes.find((node) => node.id === request.nodeId)?.status, status);
+    assert.equal(
+      projection.turnItems.find((item) => item.nodeId === request.nodeId)?.status,
+      status,
+    );
+  }
   const approval = projection.turnItems.find((item) => item.type === "approval_request");
   const options = approval?.type === "approval_request" ? (approval.options ?? []) : [];
   assert.includeDeepMembers(

apps/server/src/orchestration-v2/testkit/fixtures/opencode_child_approval/output.ts

@@ -33,6 +33,8 @@ export function assertOpenCodeChildApprovalOutput(
   assert.lengthOf(requests, 1);
   assert.equal(requests[0]?.kind, "command");
   assert.equal(requests[0]?.status, "resolved");
+  assert.equal(requests[0]?.decision, "accept");
+  assert.equal(projection.nodes.find((node) => node.id === approval.nodeId)?.status, "completed");
 
   assert.lengthOf(projection.subagents, 1);
   assert.equal(projection.subagents[0]?.status, "completed");

apps/server/src/orchestration-v2/testkit/fixtures/plan_questions/opencode_output.ts

@@ -4,6 +4,7 @@ import type { ProviderReplayTranscript } from "@t3tools/contracts";
 import type { OrchestratorV2ScenarioResult } from "../../OrchestratorScenario.ts";
 import { assertPlanQuestionsOutputBase } from "./codex_output.ts";
 import { projectionFor } from "../shared.ts";
+import { planQuestionsInput } from "./input.ts";
 
 export function assertOpenCodePlanQuestionsOutput(
   result: OrchestratorV2ScenarioResult,
@@ -14,6 +15,15 @@ export function assertOpenCodePlanQuestionsOutput(
   const requestItem = projection.turnItems.find((item) => item.type === "user_input_request");
   assert.equal(requestItem?.questions[0]?.id, "question-0-schema-vs-flexibility");
   assert.equal(requestItem?.status, "completed");
+  const answer = planQuestionsInput().steps.find(
+    (step) => step.type === "answer_next_user_input_request",
+  );
+  assert.isDefined(answer);
+  assert.deepEqual(projection.runtimeRequests[0]?.answers, answer.answers);
+  assert.equal(
+    projection.nodes.find((node) => node.id === requestItem?.nodeId)?.status,
+    "completed",
+  );
   assert.lengthOf(
     projection.turnItems.filter(
       (item) => item.type === "dynamic_tool" && item.toolName === "question",