feat(runner): every approval gate leaves a durable interaction row

Author: mmabrouk

api/oss/tests/pytest/unit/sessions/test_interactions_dispatcher.py

@@ -5,6 +5,9 @@
 
 from unittest.mock import AsyncMock, MagicMock
 
+from oss.src.apis.fastapi.sessions.models import SessionInteractionCreateRequest
+from oss.src.core.sessions.interactions.dtos import SessionInteractionKind
+
 from oss.src.tasks.asyncio.sessions.interactions_dispatcher import (
     InteractionsDispatcher,
 )
@@ -31,6 +34,19 @@ def _make_interaction(*, with_refs=True):
     )
 
 
+def test_create_request_accepts_omitted_workflow_references():
+    request = SessionInteractionCreateRequest(
+        session_id="sess-no-refs",
+        turn_id="turn-no-refs",
+        token="token-no-refs",
+        kind=SessionInteractionKind.user_approval,
+        data={"request": {"tool": "bash", "args": {"command": "pwd"}}},
+    )
+
+    assert request.data is not None
+    assert request.data.references is None
+
+
 async def test_respond_fallback_calls_invoke_when_no_dispatch_fn():
     interaction = _make_interaction()
     project_id = uuid4()
@@ -60,6 +76,35 @@ async def test_respond_fallback_calls_invoke_when_no_dispatch_fn():
     assert invoke_kwargs["user_id"] == user_id
 
 
+async def test_respond_without_references_builds_a_safe_reference_less_request():
+    interaction = _make_interaction(with_refs=False)
+    project_id = uuid4()
+    user_id = uuid4()
+
+    interactions_service = MagicMock()
+    interactions_service.fetch_interaction = AsyncMock(return_value=interaction)
+
+    workflows_service = MagicMock()
+    workflows_service.invoke_workflow = AsyncMock(return_value=SimpleNamespace())
+
+    worker = InteractionsDispatcher(
+        workflows_service=workflows_service,
+        interactions_service=interactions_service,
+    )
+
+    await worker.respond(
+        project_id=project_id,
+        user_id=user_id,
+        interaction_id=interaction.id,
+        answer={"approved": True},
+    )
+
+    workflows_service.invoke_workflow.assert_awaited_once()
+    invoke_request = workflows_service.invoke_workflow.await_args.kwargs["request"]
+    assert invoke_request.references is None
+    assert invoke_request.session_id == interaction.session_id
+
+
 async def test_respond_detached_calls_dispatch_fn_not_invoke():
     interaction = _make_interaction()
     project_id = uuid4()

docs/design/agent-workflows/projects/sessions-takeover/arda-handoff.md

@@ -239,28 +239,33 @@ Out of scope for now: session deletion and live mid-turn attach.
 - PR #5382 and PR #5436 descriptions, for the exact shape of what merges beneath you. Your
   own PR #5426 description, for the record of what you built and where each piece landed.
 
-## 6. Two questions Mahmoud wants your read on
-
-Neither is settled. Your view as the frontend owner is why he is asking.
-
-### 6.1 The streams-table rename
-
-The table named `session_streams` stores no streamed frames; the architecture document opens
-by killing exactly that mental model (architecture document, page 1, mental model 2). It
-holds liveness and ownership, and it now also carries the session identity, the `name` and
-`description` header. The name misleads on both counts. The open question is whether to rename
-the table so its name matches what it holds. You read and write this row from the frontend
-(session fetch, and the rename UI you are about to wire in task 4), so the churn and the
-clarity both land partly on you. Weigh in on whether the rename is worth it and what the name
-should be.
-
-### 6.2 The interactions guard ruling
-
-The runner refuses to create an interaction row when the run context carries no
-`workflow_revision` reference, because the respond path could not re-invoke anything without
-it. The consequence is that gates in that state are answerable in-band only and are invisible
-to any interactions-plane inbox; a real QA session had approval records but zero interaction
-rows for exactly this reason (architecture document, section 5, "Sharp edges"). The open
-question is whether to keep that guard as is, accepting that some gates never get a durable
-interaction row, or to relax it. It matters to any future approval-inbox surface, which is
-your territory. Weigh in on which way it should go.
+## 6. Where the open questions landed, and the one Mahmoud wants your proposal on
+
+Two questions this document originally left open were ruled by Mahmoud on 2026-07-21, so
+you inherit the answers rather than the debates.
+
+**The streams table keeps its name.** `session_streams` stays as it is. Since the name
+misleads (the table stores no streamed frames; it holds liveness, ownership, and the
+session's name and description header), keep the architecture document nearby when working
+against it: the row is the session header plus status, and only the service read that
+overlays the live Redis state tells the truth about liveness.
+
+**The interactions guard is relaxed: every gate gets a durable row.** Today the runner
+skips creating the interaction row when the run context carries no `workflow_revision`
+reference, which leaves those gates invisible to any future inbox and without an audit
+trail. The ruling: create the row anyway, with the reference left empty when absent. The
+runner-side change is queued on our side; what it means for you is that the future inbox
+must tolerate and sensibly display rows that cannot be attributed to an agent (group them
+under the session).
+
+### The question that is yours: what should rejecting one card do to its siblings?
+
+Today rejecting an approval card rejects only that card; other pending cards stay open.
+OpenCode ships the opposite policy: one rejection cancels every pending card in the
+session, on the reasoning that a rejection means "stop what you are doing" rather than "no
+to this one thing" (see the OpenCode comparison in this folder, the approval flow section).
+That policy would also have turned the db58551b incident's dead conversation into a clean
+stop. Mahmoud's ruling is that this is a product-feel call on your surface, and he wants
+your proposal: keep per-card rejection, adopt the cascade, or something between (for
+example, cascade only when the rejection carries no message). Bring the UX reasoning with
+the proposal.

services/runner/src/sessions/interactions.ts

@@ -18,9 +18,7 @@ type Reference = { id?: string; slug?: string; version?: string };
 
 export type InteractionData = {
   request?: { tool: string; args: unknown };
-  // The workflow references that identify which revision THIS turn is running, so the
-  // respond invoke re-resolves the SAME workflow. We store the references (pointers), not
-  // the revision data itself — respond resolves the live revision from them at invoke time.
+  // Optional attribution for out-of-band re-invocation; inbox/audit rows exist without it.
   references?: Record<string, Reference>;
 };
 

services/runner/tests/unit/session-keepalive-approval.test.ts

@@ -1585,6 +1585,148 @@ describe("runTurn: real approval park + respondPermission resume", () => {
     await env.destroy();
   });
 
+  it("creates and resolves a durable gate row without workflow context", async () => {
+    const posted: Array<{ url: string; body: Record<string, unknown> }> = [];
+    const fetchSpy = vi
+      .spyOn(globalThis, "fetch")
+      .mockImplementation(async (input, init) => {
+        posted.push({
+          url: String(input),
+          body: JSON.parse(init?.body as string) as Record<string, unknown>,
+        });
+        return new Response(JSON.stringify({ ok: true }), { status: 200 });
+      });
+
+    try {
+      const { calls, deps, captured } = pausableHarness();
+      deps.hydrateHarnessSessionFromDurable = async () => {};
+      const noWorkflowRequest: AgentRunRequest = {
+        ...engineReq,
+        ...auth,
+        sessionId: "sess-no-workflow",
+        turnId: "turn-no-workflow-start",
+      };
+      const acquired = await acquireEnvironment(noWorkflowRequest, deps);
+      assert.equal(acquired.ok, true);
+      if (!acquired.ok) return;
+      const env = acquired.env;
+
+      const firstTurn = runTurn(
+        env,
+        noWorkflowRequest,
+        undefined,
+        undefined,
+        { approvalParkMode: true },
+      );
+      await flush();
+      captured.onEvent!(
+        updateEvent({
+          sessionUpdate: "tool_call",
+          toolCallId: "tc-no-workflow",
+          title: "commit",
+          rawInput: { message: "hi" },
+        }),
+      );
+      captured.onPermissionRequest!({
+        id: "perm-no-workflow",
+        availableReplies: ["once", "reject"],
+        toolCall: {
+          toolCallId: "tc-no-workflow",
+          name: "commit",
+          rawInput: { message: "hi" },
+        },
+      });
+      const paused = await firstTurn;
+      assert.equal(paused.stopReason, "paused");
+      await flush();
+
+      const createCall = posted.find(({ url }) =>
+        url.endsWith("/sessions/interactions/"),
+      );
+      assert.ok(createCall);
+      assert.equal(createCall.body["session_id"], "sess-no-workflow");
+      assert.equal(createCall.body["turn_id"], "turn-no-workflow-start");
+      const createData = createCall.body["data"] as Record<string, unknown>;
+      assert.equal("references" in createData, false);
+
+      const parked = env.parkedApprovals.get("tc-no-workflow");
+      assert.ok(parked);
+      assert.ok(parked.promptPromise);
+      env.clearTurn();
+      const resumedTurn = runTurn(
+        env,
+        approveResume(true, {
+          sessionId: "sess-no-workflow",
+          turnId: "turn-no-workflow-resume",
+        }),
+        undefined,
+        undefined,
+        {
+          approvalParkMode: true,
+          resume: {
+            decisions: [
+              {
+                permissionId: parked.permissionId,
+                reply: "once",
+                toolCallId: parked.toolCallId,
+                toolName: parked.toolName,
+                args: parked.args,
+                interactionToken: parked.interactionToken,
+                promptPromise: parked.promptPromise,
+              },
+            ],
+            carriedForward: [],
+          },
+        },
+      );
+      for (
+        let attempt = 0;
+        attempt < 10 &&
+        !posted.some(({ url }) =>
+          url.endsWith("/sessions/interactions/transition"),
+        );
+        attempt += 1
+      ) {
+        await flush();
+      }
+
+      const resolveCall = posted.find(({ url }) =>
+        url.endsWith("/sessions/interactions/transition"),
+      );
+      assert.ok(
+        resolveCall,
+        JSON.stringify({ posted, permissionReplies: calls.permissionReplies }),
+      );
+      assert.deepEqual(resolveCall.body, {
+        session_id: "sess-no-workflow",
+        token: parked.interactionToken,
+        status: "resolved",
+        resolution: {
+          verdict: "approved",
+          tool_call_id: "tc-no-workflow",
+        },
+      });
+
+      captured.onEvent!(
+        updateEvent({
+          sessionUpdate: "tool_call_update",
+          toolCallId: "tc-no-workflow",
+          status: "completed",
+          content: "committed",
+        }),
+      );
+      calls.resolvePrompt!({
+        stopReason: "complete",
+        usage: { inputTokens: 1, outputTokens: 1 },
+      });
+      const resumed = await resumedTurn;
+      assert.equal(resumed.ok, true);
+      await env.destroy();
+    } finally {
+      fetchSpy.mockRestore();
+    }
+  });
+
   it("preserves a denied call failed frame while a sibling gate is carried", async () => {
     const { calls, deps, captured } = pausableHarness();
     const acquired = await acquireEnvironment(engineReq, deps);