fix: make busy-session inputs durable - #304

web/src/hooks/routes/__tests__/use-session-page-controls.test.tsx (1)

224-246: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Add a negative test for the missing turn fence.

This test proves the positive path: an active turn ID reaches the steer and interrupt mutations. The new guards in use-session-page-controls.ts (Lines 137 and 164) also block both operations when activeTurnId is empty. No test covers that branch, so a regression that drops the guard would still pass.

Add a case that renders with makeSession("active") (no turn ID) and asserts that steerPromptMutation.mutateAsync and interruptPromptMutation.mutateAsync are not called.

💚 Suggested test

+  it("Should block steer and interrupt when no active turn fence exists", async () => {
+    routeHookMocks.auiState.thread.isRunning = true;
+    const { result } = renderControls(makeSession("active"));
+
+    await act(async () => {
+      await result.current.handleSteerPrompt("new constraint");
+      await result.current.handleInterruptPrompt("replace the work");
+    });
+
+    expect(routeHookMocks.steerPromptMutation.mutateAsync).not.toHaveBeenCalled();
+    expect(routeHookMocks.interruptPromptMutation.mutateAsync).not.toHaveBeenCalled();
+  });

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@web/src/hooks/routes/__tests__/use-session-page-controls.test.tsx` around
lines 224 - 246, Add a negative test alongside the existing active-turn test
that renders controls with makeSession("active") and no activeTurnId, invokes
handleSteerPrompt and handleInterruptPrompt, and asserts both
steerPromptMutation.mutateAsync and interruptPromptMutation.mutateAsync are not
called.

web/src/components/assistant-ui/session-composer.tsx (1)

223-237: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Consider gating the queued-row Steer control with the same fence.

Lines 224 and 237 disable the direct Steer and Interrupt buttons when busyInputFenceAvailable is false. The queued-row Steer button in SessionComposerQueuedPrompts is not gated by this flag. handleSteerQueuedPrompt in web/src/hooks/routes/use-session-page-controls.ts (Line 190) returns early when activeTurnId is empty, so a user click on an enabled row control produces no result and no message.

Pass the fence state into the queued-prompt strip so the row control reflects the same precondition.

♻️ Suggested wiring

             <SessionComposerQueuedPrompts
               prompts={queuedPrompts}
               onSteer={onSteerQueuedPrompt!}
               onEdit={handleEditQueuedPrompt}
               onRemove={handleRemoveQueuedPrompt}
-              disabled={isBusyInputPending}
+              disabled={isBusyInputPending}
+              steerDisabled={!busyInputFenceAvailable}
             />

SessionComposerQueuedPrompts then applies steerDisabled only to the Steer control.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@web/src/components/assistant-ui/session-composer.tsx` around lines 223 - 237,
Pass busyInputFenceAvailable from SessionComposer into
SessionComposerQueuedPrompts, and have the queued-row Steer control use it as
steerDisabled. Keep the existing gating for direct Steer and Interrupt buttons
unchanged, and apply the new disabled state only to the queued Steer action.

web/src/hooks/routes/use-session-page-controls.ts (1)

79-85: 🚀 Performance & Scalability | 🔵 Trivial | ⚡ Quick win

Memoize the derived queuedPrompts array.

Lines 79-85 build a new array on every render. The hook returns this array, and SessionThread forwards it to SessionComposer as the queuedPrompts prop. Every render of the session page therefore produces a new prop identity for the composer and for useSessionBusyInputActions. The previous store-owned value kept a stable identity between updates.

Derive the projection with useMemo keyed on the query data.

♻️ Suggested change

-  const queuedPrompts: QueuedPrompt[] =
-    sessionInputs.data?.inputs.map(input => ({
-      id: input.id,
-      mode: input.mode,
-      status: input.status,
-      text: input.text,
-    })) ?? [];
+  const queuedPrompts: QueuedPrompt[] = useMemo(
+    () =>
+      sessionInputs.data?.inputs.map(input => ({
+        id: input.id,
+        mode: input.mode,
+        status: input.status,
+        text: input.text,
+      })) ?? EMPTY_QUEUED_PROMPTS,
+    [sessionInputs.data]
+  );

Add import { useMemo } from "react"; and a module-level const EMPTY_QUEUED_PROMPTS: QueuedPrompt[] = [];.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@web/src/hooks/routes/use-session-page-controls.ts` around lines 79 - 85,
Memoize the derived queuedPrompts projection in the useSessionPageControls hook
using useMemo, keyed on sessionInputs.data, and reuse a module-level
EMPTY_QUEUED_PROMPTS fallback so the returned array identity remains stable when
no inputs exist. Add the required React import and preserve the existing field
mapping.

internal/api/httpapi/handlers_test.go (1)

2735-2736: 📐 Maintainability & Code Quality | 🔵 Trivial | 💤 Low value

Add t.Parallel() to the outer test function.

TestSessionInputHandlersExposeAuthoritativeQueueMutations does not call t.Parallel(). The subtests share the mutable captures replaceOpts and promoteOpts, so the subtests must stay sequential. The outer function can still run in parallel with other tests.

♻️ Proposed change

 func TestSessionInputHandlersExposeAuthoritativeQueueMutations(t *testing.T) {
+	t.Parallel()
 	now := time.Date(2026, 8, 3, 18, 0, 0, 0, time.UTC)

As per coding guidelines: "use t.Run("Should …"), default t.Parallel".

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@internal/api/httpapi/handlers_test.go` around lines 2735 - 2736, Add
t.Parallel() at the beginning of
TestSessionInputHandlersExposeAuthoritativeQueueMutations, while leaving its
subtests sequential because they share the mutable replaceOpts and promoteOpts
captures.

Source: Coding guidelines

internal/daemon/native_session_input.go (2)

79-99: 🚀 Performance & Scalability | 🔵 Trivial | 💤 Low value

Validate the body fields before the workspace and session lookup.

sessionInputReplace resolves the workspace and verifies session ownership first, then validates text, message_id, and idempotency_key. sessionPrompt in internal/daemon/native_session_mutation.go validates the required strings first and resolves the workspace afterwards. Aligning the order removes a workspace resolution and a session lookup for malformed requests. sessionInputPromote has the same ordering.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@internal/daemon/native_session_input.go` around lines 79 - 99, In the
sessionInputReplace flow, validate text, message_id, and idempotency_key with
requiredNativeString before calling nativeSessionInputMutationScope; then
perform the workspace/session lookup and replacement unchanged. Apply the same
validation-before-lookup ordering to sessionInputPromote, matching
sessionPrompt.

---

60-63: 📐 Maintainability & Code Quality | 🔵 Trivial | 💤 Low value

Rename the loop variable to avoid shadowing input.

The loop variable input shadows the decoded request struct input declared at line 48. The code is correct, but the two values have different types and meanings.

♻️ Proposed change

 	payloads := make([]contract.SessionInputPayload, 0, len(inputs))
-	for _, input := range inputs {
-		payloads = append(payloads, core.SessionInputPayloadFromSession(input))
+	for _, pending := range inputs {
+		payloads = append(payloads, core.SessionInputPayloadFromSession(pending))
 	}

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@internal/daemon/native_session_input.go` around lines 60 - 63, Rename the
range variable in the payload-building loop within the native session input
handler so it no longer shadows the decoded request struct input; update the
corresponding SessionInputPayloadFromSession argument while preserving the
existing behavior.

internal/daemon/native_tools_test.go (1)

5603-5634: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Add a case for the missing expected_turn_id guard.

This test covers the success path for steer mode with expected_turn_id set. sessionPrompt in internal/daemon/native_session_mutation.go lines 99-106 rejects steer and interrupt mode when expected_turn_id is blank. No test exercises that rejection. Add a case that calls ToolIDSessionPrompt with "mode":"steer" and no expected_turn_id, and assert the invalid-input reason plus zero SendPrompt calls.

Do you want me to generate that test case?

As per path instructions: "Verify tests can fail when business logic changes".

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@internal/daemon/native_tools_test.go` around lines 5603 - 5634, Add a test
case alongside the existing session_prompt steer-mode success test that calls
ToolIDSessionPrompt with mode "steer" but omits expected_turn_id, then assert
the invalid-input error reason and verify SendPrompt is not called. Ensure the
test fails if the expected_turn_id validation in sessionPrompt is removed or
bypassed.

Source: Path instructions

internal/api/core/session_prompt.go (1)

24-27: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Use shared status constants or define them with SendPromptResult.

internal/session defines BusyInputModeQueue, BusyInputModeInterrupt, and BusyInputModeSteer constants, but SendPromptResult.Status uses the string literals "queued", "steering", and "interrupting" directly. Add exported status constants and use them from internal/session/manager_busy_input.go and internal/api/core/session_prompt.go so a rename cannot silently return 200 instead of 202.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@internal/api/core/session_prompt.go` around lines 24 - 27, Define exported
status constants alongside SendPromptResult for the queued, steering, and
interrupting values, then replace the corresponding string literals in
internal/session/manager_busy_input.go and the status check in session_prompt.go
with those constants. Preserve the existing 202 behavior for these statuses and
the Replayed condition.

internal/extension/contract/host_api.go (1)

161-164: 📐 Maintainability & Code Quality | 🔵 Trivial | 💤 Low value

Consider one shared mode type across request and result.

SessionsPromptParams.Mode uses apicontract.PromptMode. SessionPromptResult.Mode and SessionInput.Mode use session.BusyInputMode (see internal/extension/contract/host_api_results.go lines 56 and 78). Extension authors then see two different Go types for the same wire concept, and internal/extension/host_api_sessions.go line 123 converts through string. Align both sides on one contract type if the wire values are identical.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@internal/extension/contract/host_api.go` around lines 161 - 164, Use one
shared mode type for the request and result contracts: update
SessionPromptResult.Mode and SessionInput.Mode to use apicontract.PromptMode,
matching SessionsPromptParams.Mode, and remove the unnecessary string conversion
in the related session handling flow.

internal/extension/host_api_sessions.go (1)

292-314: 📐 Maintainability & Code Quality | 🔵 Trivial | 💤 Low value

Add a forward runtime-payload conversion helper.

internal/api/contract/prompt_runtime_selection.go only exposes PromptRuntimeSelectionFromPayload, while internal/extension/host_api_sessions.go still initializes PromptRuntimeSelectionPayload field by field. Add an exported forward conversion in the contract package and call it here so future payload changes stay in one place.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@internal/extension/host_api_sessions.go` around lines 292 - 314, Add an
exported conversion helper in prompt_runtime_selection.go that converts the
contract’s PromptRuntimeSelectionPayload into the internal runtime selection
type, complementing PromptRuntimeSelectionFromPayload. Update
hostAPISessionInputFromPending to use this helper instead of constructing
PromptRuntimeSelectionPayload field by field, while preserving nil handling.

internal/store/globaldb/global_db_session_prompt_admission_queue.go (1)

284-312: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Extract the admission status strings into named constants.

"queued", "interrupting", and "steering" are inline literals here. They form a wire-visible vocabulary that the HTTP, UDS, CLI, and web layers project. The output schema in internal/tools/builtin/sessions.go line 339 declares status as a plain string with no enum, so nothing pins these values. A typo or a divergent literal in another layer would not fail a build or a test.

Declare the values next to the other session input constants in internal/store/session_input_queue.go and reference them from every producer and consumer.

♻️ Proposed refactor

Add the constants in internal/store/session_input_queue.go:

const (
	SessionPromptAdmissionStatusQueued       = "queued"
	SessionPromptAdmissionStatusInterrupting = "interrupting"
	SessionPromptAdmissionStatusSteering     = "steering"
)

Then use them here:

-	status := "queued"
+	status := store.SessionPromptAdmissionStatusQueued
 	if entry.Mode == store.SessionInputQueueModeInterrupt {
-		status = "interrupting"
+		status = store.SessionPromptAdmissionStatusInterrupting
 	}

 	return store.SessionPromptAdmissionResult{
-		Status:          "steering",
+		Status:          store.SessionPromptAdmissionStatusSteering,
 		Mode:            store.SessionInputQueueModeSteer,

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@internal/store/globaldb/global_db_session_prompt_admission_queue.go` around
lines 284 - 312, The admission status strings are inline literals and need a
shared wire-level vocabulary. Define SessionPromptAdmissionStatusQueued,
SessionPromptAdmissionStatusInterrupting, and
SessionPromptAdmissionStatusSteering alongside the session input constants in
session_input_queue.go, then replace the literals in queuedPromptAdmissionResult
and stagedPromptAdmissionResult and update every other producer and consumer to
reference these constants.

internal/tools/builtin/builtin_test.go (1)

1492-1529: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Split the requiresExpectedTurn flag from the output-schema choice.

requiresExpectedTurn controls two unrelated things. At line 1517 it selects the expected_turn_id assertion. At line 1526 it also selects which output envelope the helper verifies. Because of that coupling, assertSessionInputPromoteSchema must call assertSessionPromptMutationOutputSchema itself at line 1489, while assertSessionInputReplaceSchema depends on the helper's implicit branch. The responsibility split between caller and helper is asymmetric and is not visible from the parameter name.

A future mutation tool that requires expected_turn_id and returns the input envelope cannot be expressed with this signature.

Keep the input assertions in the helper and move the output assertion to each caller.

♻️ Proposed refactor

 func assertSessionInputReplaceSchema(t *testing.T, descriptor toolspkg.Descriptor) {
 	t.Helper()
 	assertSessionInputMutationSchema(t, descriptor, []string{
 		"idempotency_key", "message_id", "queue_entry_id", "session_id", "text", "workspace",
 	}, []string{"session_id", "queue_entry_id", "text", "message_id", "idempotency_key"}, false)
+	assertSessionInputOutputSchema(t, descriptor.ID.String()+" output", descriptor.OutputSchema)
 }

 	if requiresExpectedTurn {
 		var expectedTurn nativeObjectSchema
 		if err := json.Unmarshal(input.Properties["expected_turn_id"], &expectedTurn); err != nil {
 			t.Fatalf("%s expected_turn_id schema unmarshal error = %v", descriptor.ID, err)
 		}
 		if expectedTurn.Type != "string" || expectedTurn.MinLength != 1 {
 			t.Fatalf("%s expected_turn_id schema = %#v, want non-empty string", descriptor.ID, expectedTurn)
 		}
 	}
-	if !requiresExpectedTurn {
-		assertSessionInputOutputSchema(t, descriptor.ID.String()+" output", descriptor.OutputSchema)
-	}
 }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@internal/tools/builtin/builtin_test.go` around lines 1492 - 1529, Remove the
output-schema branching from assertSessionInputMutationSchema, leaving it
responsible only for input and expected_turn_id assertions. Update each caller,
including assertSessionInputPromoteSchema and assertSessionInputReplaceSchema,
to explicitly invoke the appropriate output-schema assertion so expected_turn_id
validation is independent of the returned envelope.

internal/session/inputqueue/queue.go (1)

243-248: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Consider one insert-parameter struct instead of adjacent positional strings.

newInsert now takes sessionID, text, mode, delivery, and targetTurnID as five adjacent strings, and prepareAdmittedEntry forwards four of them. A swapped argument compiles without error and writes wrong queue metadata. A small parameter struct removes that risk and keeps the call sites readable.

♻️ Sketch of the parameter struct

+type insertSpec struct {
+	SessionID    string
+	Text         string
+	Mode         string
+	Delivery     string
+	TargetTurnID string
+	Generation   int64
+	Runtime      store.SessionInputRuntime
+}
+
-func (s *Service) newInsert(
-	sessionID string,
-	text string,
-	mode string,
-	delivery string,
-	targetTurnID string,
-	generation int64,
-	runtime store.SessionInputRuntime,
-) (store.SessionInputQueueInsert, error) {
+func (s *Service) newInsert(spec insertSpec) (store.SessionInputQueueInsert, error) {

Also applies to: 358-366

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@internal/session/inputqueue/queue.go` around lines 243 - 248, Replace the
adjacent string parameters for newInsert and prepareAdmittedEntry with a single
named parameter struct containing sessionID, text, mode, delivery, and
targetTurnID. Update prepareAdmittedEntry and all newInsert call sites to
populate and consume the struct by field, preserving the existing queue metadata
values and behavior.

internal/session/manager_busy_input_test.go (1)

1812-1814: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Add t.Parallel() to the new top-level test function.

TestManagerPendingInputPromotionReplay marks only the subtest as parallel. The neighboring suites, such as TestManagerPromptAdmissionReplay at line 222 and TestManagerBusyInputPromptAdmissionReplay at line 330, call t.Parallel() on the outer function too.

As per coding guidelines: "use t.Run("Should …"), default t.Parallel".

♻️ Proposed change

 func TestManagerPendingInputPromotionReplay(t *testing.T) {
+	t.Parallel()
+
 	t.Run("Should replay promotion after the replacement turn starts without interrupting it again", func(t *testing.T) {

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@internal/session/manager_busy_input_test.go` around lines 1812 - 1814, Add
t.Parallel() at the start of TestManagerPendingInputPromotionReplay, before its
subtest declaration, matching the parallel execution pattern used by the
neighboring top-level test functions.

Source: Coding guidelines

internal/session/inputqueue/mutation.go (1)

15-112: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Consider one shared mutation helper for Replace and PromoteToSteer.

Both methods repeat the same nine steps and differ only in mode, delivery, target turn, and the store call. A single private helper keeps the replay, insert-building, and identity assignment in one place, and it reduces the seven-parameter signatures.

♻️ Sketch of a shared helper

type mutationSpec struct {
	sessionID      string
	entryID        string
	text           string
	targetTurnID   string
	messageID      string
	idempotencyKey string
	mode           string
	delivery       string
}

func (s *Service) mutate(
	ctx context.Context,
	spec mutationSpec,
	apply func(context.Context, string, string, store.SessionInputQueueInsert) (store.SessionInputQueueEntry, bool, error),
) (store.SessionInputQueueEntry, bool, error) {
	// trim, replay, build insert, then call apply
}

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@internal/session/inputqueue/mutation.go` around lines 15 - 112, Extract the
shared mutation flow from Replace and PromoteToSteer into a private mutate
helper, using a mutationSpec to carry their differing session, entry, text,
target-turn, identity, mode, and delivery values. Keep trimming, replayMutation,
Get, newInsert, replacement identity assignment, and error propagation in the
helper, while passing the operation-specific store behavior through the apply
callback. Update both methods to construct the appropriate spec and delegate to
mutate.

internal/store/globaldb/queries/session_input.sql (1)

15-15: 🗄️ Data Integrity & Integration | 🔵 Trivial | ⚡ Quick win

Anchor dispatch order to the store constant.

internal/store/globaldb/queries/session_input.sql has the same 'interrupt_then_prompt' literal in GetNextDispatchableSessionInput, PeekNextSessionInput, and ListPendingSessionInputs. Add one store test that inserts an older queued input and a newer SessionInputDeliveryInterruptThenPrompt input, then checks that the interrupting input is the one dispatched. If the literal and store.SessionInputDeliveryInterruptThenPrompt drift later, the test fails before runtime priority is lost.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@internal/store/globaldb/queries/session_input.sql` at line 15, Replace the
duplicated 'interrupt_then_prompt' SQL literal in
GetNextDispatchableSessionInput, PeekNextSessionInput, and
ListPendingSessionInputs with the store constant
SessionInputDeliveryInterruptThenPrompt, and add one store test inserting an
older queued input plus a newer interrupt-then-prompt input that verifies the
interrupting input is dispatched first.

internal/store/globaldb/schema/definitions/20_sessions.sql (1)

183-183: 🚀 Performance & Scalability | 🔵 Trivial | ⚡ Quick win

Make the pending index match the queue ordering.

idx_session_input_queue_pending is created as (session_id, status, delivery, enqueued_at, id), while dispatch queries order by CASE delivery ..., enqueued_at, and id. A plain delivery column does not match that CASE delivery ordering, so add the expression to the covered query/index chain or switch the queues to delivery DESC ordering so the index can serve dispatch.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@internal/store/globaldb/schema/definitions/20_sessions.sql` at line 183,
Update idx_session_input_queue_pending and the corresponding dispatch query
ordering so they use the same delivery ordering semantics: either index the CASE
delivery expression used by dispatch, or change the queue ordering to delivery
DESC consistently. Preserve the existing enqueued_at and id ordering and ensure
the index column/order matches the final query exactly.

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes