feat: select and switch runtime per session prompt - #283

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

712-719: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Add t.Parallel() to the new parallelizable subtests.

TestHTTPTaskRunLifecycleRoutesRoundTrip and other lifecycle helpers already use t.Parallel() with newIntegrationRuntime(t), indicating the harness supports concurrent subtests. Add t.Parallel() at the start of the closures for the new stream cursor, stop reason, and crash stop reason subtests to keep this package aligned with the default parallel pattern.

🤖 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/httpapi_integration_test.go` around lines 712 - 719, Add
t.Parallel() at the beginning of the closures for the new stream cursor, stop
reason, and crash stop reason subtests, including the test invoking
exerciseHTTPSessionStreamReconnectPreservesCursorWhenNoNewEventsExistYet. Keep
each subtest’s existing body and helper calls unchanged.

Source: Coding guidelines

internal/session/additional_test.go (1)

365-378: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Wrap the new unbound-runtime scenario in its own t.Run("Should ...") subtest.

This adds a new, distinct test case (runtime-bind failure propagation) appended inline to TestPromptErrorPaths rather than as a subtest.

As per path instructions, "MUST use t.Run("Should...") pattern for ALL test cases."

♻️ Suggested wrapping

-	h = newHarness(t)
-	session = createSession(t, h)
-	session.markRuntimeUnbound(time.Now().UTC())
-	if got := session.Info().RuntimeStatus; got != RuntimeStatusUnbound {
-		t.Fatalf("unbound session runtime status = %q, want %q", got, RuntimeStatusUnbound)
-	}
-	bindErr := errors.New("runtime bind unavailable")
-	h.driver.startHook = func(_ acp.StartOpts, _ int) (*fakeProcess, error) {
-		return nil, bindErr
-	}
-	if _, err := h.manager.Prompt(testutil.Context(t), session.ID, "bind-runtime"); !errors.Is(err, bindErr) {
-		t.Fatalf("Prompt(unbound) error = %v, want runtime bind failure", err)
-	}
+	t.Run("Should propagate runtime bind failure for an unbound session", func(t *testing.T) {
+		t.Parallel()
+		h := newHarness(t)
+		session := createSession(t, h)
+		session.markRuntimeUnbound(time.Now().UTC())
+		if got := session.Info().RuntimeStatus; got != RuntimeStatusUnbound {
+			t.Fatalf("unbound session runtime status = %q, want %q", got, RuntimeStatusUnbound)
+		}
+		bindErr := errors.New("runtime bind unavailable")
+		h.driver.startHook = func(_ acp.StartOpts, _ int) (*fakeProcess, error) {
+			return nil, bindErr
+		}
+		if _, err := h.manager.Prompt(testutil.Context(t), session.ID, "bind-runtime"); !errors.Is(err, bindErr) {
+			t.Fatalf("Prompt(unbound) error = %v, want runtime bind failure", err)
+		}
+	})

🤖 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/additional_test.go` around lines 365 - 378, Wrap the
unbound-runtime bind failure scenario in a dedicated t.Run subtest named with
the required “Should ...” pattern within TestPromptErrorPaths. Keep the existing
setup, startHook error injection, Prompt invocation, and assertion together
inside that subtest.

internal/session/manager_start.go (1)

52-55: 📐 Maintainability & Code Quality | 🔵 Trivial | 💤 Low value

Error message is coupled to the helper's current single failure mode.

sessionStartSpecFromMeta today can only fail on speed normalization, so "validate resume speed" is accurate — but the wording will misattribute any future failure added to the shared helper. Prefer a neutral prefix and let the wrapped error carry the specifics.

♻️ Suggested wording

-	spec, err := sessionStartSpecFromMeta(meta, &resolvedWorkspace, cwd)
-	if err != nil {
-		return sessionStartSpec{}, fmt.Errorf("session: validate resume speed for %q: %w", meta.ID, err)
-	}
+	spec, err := sessionStartSpecFromMeta(meta, &resolvedWorkspace, cwd)
+	if err != nil {
+		return sessionStartSpec{}, fmt.Errorf("session: build resume start spec for %q: %w", meta.ID, err)
+	}

🤖 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_start.go` around lines 52 - 55, Update the error
wrapping in the session-start flow around sessionStartSpecFromMeta to use a
neutral description of the helper failure rather than specifically naming
resume-speed validation, while preserving meta.ID context and the wrapped error.

internal/session/manager_start_meta.go (1)

11-32: 🩺 Stability & Availability | 🔵 Trivial | ⚡ Quick win

Take the workspace by value to remove the nil-deref surface.

Line 32 dereferences workspace unconditionally. The only caller passes &resolvedWorkspace, so it is safe today, but this is a new shared helper and the pointer buys nothing here — the spec stores a copy anyway. Passing by value makes the nil case unrepresentable instead of requiring a guard.

♻️ Proposed signature change

 func sessionStartSpecFromMeta(
 	meta store.SessionMeta,
-	workspace *workspacepkg.ResolvedWorkspace,
+	workspace workspacepkg.ResolvedWorkspace,
 	cwd string,
 ) (sessionStartSpec, error) {

-		workspace:               *workspace,
+		workspace:               workspace,

Caller in internal/session/manager_start.go:

-	spec, err := sessionStartSpecFromMeta(meta, &resolvedWorkspace, cwd)
+	spec, err := sessionStartSpecFromMeta(meta, resolvedWorkspace, cwd)

🤖 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_start_meta.go` around lines 11 - 32, Change
sessionStartSpecFromMeta to accept workspacepkg.ResolvedWorkspace by value
instead of a pointer, and update its caller in the session-start flow to pass
resolvedWorkspace directly. Preserve the existing spec.workspace copy assignment
while eliminating the unconditional pointer dereference.

internal/session/manager_start_test.go (1)

161-192: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Also assert the rolled-back runtime state after a failed initial bind.

The subtest verifies the transcript stays empty but not the rollback invariant introduced by restoreRuntimeBinding — the session should be back to RuntimeStatusUnbound with RuntimeFailure populated, and the durable meta should agree. Without that, a regression that leaves the session stuck in binding would still pass.

💚 Suggested additional assertions

 		if len(page.Entries) != 0 {
 			t.Fatalf("TranscriptPage() entries = %#v, want empty", page.Entries)
 		}
+		live, ok := h.manager.Get(created.ID)
+		if !ok {
+			t.Fatalf("Get(%q) did not find created session", created.ID)
+		}
+		info := live.Info()
+		if info.RuntimeStatus != RuntimeStatusUnbound || info.RuntimeFailure == "" {
+			t.Fatalf(
+				"runtime after failed bind = %q/%q, want unbound with failure detail",
+				info.RuntimeStatus,
+				info.RuntimeFailure,
+			)
+		}
+		if meta := readMeta(t, live.MetaPath()); meta.RuntimeStatus != RuntimeStatusUnbound {
+			t.Fatalf("meta runtime status = %q, want %q", meta.RuntimeStatus, RuntimeStatusUnbound)
+		}

🤖 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_start_test.go` around lines 161 - 192, Extend the
“Should preserve an empty transcript when initial binding fails” test to assert
the rollback state after SendPrompt returns startErr: the session must have
RuntimeStatusUnbound with RuntimeFailure populated, and the durable metadata
must report the same runtime state. Use the existing session/runtime inspection
APIs and meta symbols used by restoreRuntimeBinding, while preserving the
transcript and cleanup assertions.

internal/session/manager_test.go (1)

4488-4492: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Assert the fake driver did not stop the bound process.

proc.done default-case does not make Shutdown() async-stop behavior impossible: driver.Stop() increments stopCalls before calling the hook, so a buggy path can call Stop() and return only after the hook/closure signals shutdown. Add if h.driver.stopCalls != 0 { t.Fatalf("driver stop calls = %d, want 0", h.driver.stopCalls) } alongside the done check.

🤖 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_test.go` around lines 4488 - 4492, Strengthen the
Shutdown() async-stop assertion by checking the fake driver’s stopCalls counter
alongside the proc.done check. In the relevant test, fail when
h.driver.stopCalls is nonzero and report the observed count, ensuring the bound
process was not stopped.

internal/session/manager_prompt_event_storage.go (1)

67-71: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Duplicate prompt-runtime fallback logic between normalizeEvent and enrichRecordedAgentEvent.

Both functions perform the identical "clone snapshot, then fall back to runtimeBindingSnapshot().selection" sequence. Extracting a shared helper would avoid the two call sites silently diverging on a future change.

♻️ Proposed refactor

+func ensurePromptRuntime(event acp.AgentEvent, session *Session) acp.AgentEvent {
+	if session == nil || event.PromptRuntimeSnapshot() != nil {
+		return event
+	}
+	return event.WithPromptRuntime(promptRuntimeFromSelection(session.runtimeBindingSnapshot().selection))
+}

Then in normalizeEvent:

-		if normalized.PromptRuntimeSnapshot() == nil {
-			normalized = normalized.WithPromptRuntime(
-				promptRuntimeFromSelection(session.runtimeBindingSnapshot().selection),
-			)
-		}
+		normalized = ensurePromptRuntime(normalized, session)

And in enrichRecordedAgentEvent:

-	enriched = enriched.WithPromptRuntime(event.PromptRuntimeSnapshot())
-	if enriched.PromptRuntimeSnapshot() == nil {
-		enriched = enriched.WithPromptRuntime(promptRuntimeFromSelection(session.runtimeBindingSnapshot().selection))
-	}
+	enriched = enriched.WithPromptRuntime(event.PromptRuntimeSnapshot())
+	enriched = ensurePromptRuntime(enriched, session)

Also applies to: 172-175

🤖 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_prompt_event_storage.go` around lines 67 - 71,
Extract the duplicated prompt-runtime fallback sequence from normalizeEvent and
enrichRecordedAgentEvent into a shared helper that preserves the existing
snapshot check, cloning behavior, and runtimeBindingSnapshot().selection
fallback. Replace both call sites with the helper so future changes apply
consistently.

internal/store/types_session.go (1)

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

Consider requiring RuntimeFailure when status is failed.

validateSessionRuntime (in internal/store/session_runtime.go) enforces that a failed runtime status carries a non-empty SessionRuntimeTransition, but nothing enforces that RuntimeFailure (the failure detail string) is also non-empty in that case. A session could persist RuntimeStatus: SessionRuntimeFailed with an empty RuntimeFailure, making the failure undiagnosable downstream (CLI/API/observe surfaces).

If RuntimeFailure is meant to always describe why binding failed, add that requirement alongside the existing transition check.

♻️ Possible fix

 func validateSessionRuntime(status SessionRuntimeStatus, transition SessionRuntimeTransition) error {
 	...
 	if status == SessionRuntimeFailed && strings.TrimSpace(string(transition)) == "" {
 		return fmt.Errorf("store: failed session runtime requires a transition strategy")
 	}
+	return nil
+}

Note: this would need to thread RuntimeFailure into validateSessionRuntime's signature (or a sibling check in types_session.go), since it currently only receives status and transition.

Also applies to: 111-116

🤖 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/types_session.go` around lines 59 - 70, Update
validateSessionRuntime and its callers to also receive RuntimeFailure, and
require it to be non-empty whenever RuntimeStatus is SessionRuntimeFailed,
alongside the existing transition validation. Preserve current validation for
other statuses and ensure the Session struct validation path passes its
RuntimeFailure value through.

web/src/systems/network/mocks/fixtures.ts (1)

28-39: 📐 Maintainability & Code Quality | 🔵 Trivial | 💤 Low value

Consolidate the duplicate sessionRuntime mock helper.

@/systems/session/mocks/fixtures.ts already exports an equivalent sessionRuntime(provider, acpCaps?) helper, while web/src/systems/network/mocks/fixtures.ts re-implements it privately. Re-export or import a single shared helper so the runtime mock shape does not drift between fixtures.

🤖 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/systems/network/mocks/fixtures.ts` around lines 28 - 39, Remove the
private sessionRuntime implementation from the network mock fixtures and reuse
the exported sessionRuntime helper from the session mock fixtures via import or
re-export. Update references in the network fixtures to use that shared helper
while preserving the existing provider and acpCaps behavior.

internal/daemon/native_tools_test.go (1)

5589-5599: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Unconditional <-promptAccepted hangs the suite when the prompt call fails early.

If session_prompt is rejected before reaching SendPromptFn (schema/policy/workspace change), promptAccepted is never closed and the test blocks until the package timeout instead of reporting the failure. Select over the call result as well.

♻️ Fail fast instead of blocking

-		<-promptAccepted
-		select {
-		case call := <-promptCalls:
-			t.Fatalf("Registry.Call(session_prompt) returned before its live stream closed: %#v", call)
-		default:
-		}
+		select {
+		case <-promptAccepted:
+		case call := <-promptCalls:
+			t.Fatalf("Registry.Call(session_prompt) returned before submission: %#v", call)
+		case <-time.After(10 * time.Second):
+			t.Fatal("Registry.Call(session_prompt) never reached SendPrompt")
+		}
+		select {
+		case call := <-promptCalls:
+			t.Fatalf("Registry.Call(session_prompt) returned before its live stream closed: %#v", call)
+		default:
+		}

🤖 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 5589 - 5599, Update the
test flow around promptAccepted and promptCalls so it does not unconditionally
block on the acceptance signal. Select between promptCalls and promptAccepted,
immediately fail the test with the returned error when
Registry.Call(session_prompt) rejects before reaching SendPromptFn, and retain
the existing live-stream closure assertion for successfully accepted prompts.

web/src/components/assistant-ui/session-prompt-dispatch-store.ts (1)

47-52: 🩺 Stability & Availability | 🔵 Trivial | ⚡ Quick win

requestStarted silently orphans an in-flight controller.

If a second dispatch starts before the first completes, the previous AbortController is dropped without abort(), so the first request keeps running and its later requestCompleted is discarded (controller mismatch). Consider aborting the superseded controller and bumping generation, mirroring pendingCanceled.

♻️ Abort the superseded controller

-      requestStarted: (context, event) => ({
-        ...context,
-        canceled: false,
-        controller: event.controller,
-        pending: true,
-      }),
+      requestStarted: (context, event, enqueue) => {
+        const previous = context.controller;
+        if (previous !== null && previous !== event.controller) {
+          enqueue.effect(() => previous.abort());
+        }
+        return {
+          ...context,
+          canceled: false,
+          controller: event.controller,
+          generation: previous === null ? context.generation : context.generation + 1,
+          pending: true,
+        };
+      },

🤖 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-prompt-dispatch-store.ts` around
lines 47 - 52, Update requestStarted to abort any existing context.controller
before replacing it with event.controller, and increment generation when
superseding an in-flight request, mirroring pendingCanceled. Preserve the new
request’s pending state and controller while ensuring the prior request is
canceled and cannot leave stale work running.

web/src/components/assistant-ui/hooks/use-session-composer-state.ts (1)

56-65: 🩺 Stability & Availability | 🔵 Trivial

Synchronize draft updates with live composer text before applying persisted state.

composerDraftChanged is synchronous, so the current keystroke path doesn’t drop characters. But if draft persistence is made async/debounced later, this effect can apply a lagging draftText and overwrite the live input; keep the persisted draft out of the setText call when it cannot stay in sync with the user’s current text.

🤖 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/hooks/use-session-composer-state.ts` around
lines 56 - 65, Update the useLayoutEffect synchronization logic in the session
composer state hook so persisted draftText is not passed to
aui.composer().setText when it may be stale relative to the live composer text;
validate or synchronize the current composer text before applying persisted
state, while preserving the existing session hydration guard and normal draft
restoration behavior.

web/src/systems/session/hooks/use-session-prompt-runtime.ts (1)

18-20: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Reuse the exported SessionRuntimeEffective alias instead of re-deriving it.

web/src/systems/session/types.ts (line 15) now exports exactly this type; the inline import("../types") form duplicates it and will drift.

♻️ Suggested change

-type SessionRuntimeEffective = NonNullable<
-  NonNullable<import("../types").SessionPayload["runtime"]>["effective"]
->;
+import type { SessionRuntimeEffective } from "../types";

(place the import with the other ../types imports)

🤖 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/systems/session/hooks/use-session-prompt-runtime.ts` around lines 18
- 20, Update the session prompt runtime type references to import and reuse the
exported SessionRuntimeEffective alias from ../types alongside the existing type
imports, then remove the locally re-derived alias definition.

web/src/systems/session/hooks/use-session-create-dialog.ts (2)

114-118: 🎯 Functional Correctness | 🔵 Trivial | ⚡ Quick win

Missing agent aborts submit with no user feedback.

Unlike the participation and workspace-path branches, an empty agentName returns silently and leaves submitError untouched, so the dialog appears inert. Route it through validationFailed for consistency.

🛠️ Suggested fix

-    if (agentName.length === 0) return;
+    if (agentName.length === 0) {
+      store.trigger.validationFailed({ message: "Select an agent to start a session." });
+      return;
+    }

🤖 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/systems/session/hooks/use-session-create-dialog.ts` around lines 114
- 118, Update submit in use-session-create-dialog so an empty trimmed agentName
calls validationFailed before returning, instead of silently returning. Preserve
the existing validation flow and feedback behavior used by the participation and
workspace-path checks.

---

96-97: 📐 Maintainability & Code Quality | 🔵 Trivial | 💤 Low value

selectedAgent lookup no longer changes the result.

selectedAgent?.name can only ever be draft.agentName (the predicate matches on that name), so the fallback makes the lookup redundant now that first-agent defaulting is gone. Either drop the lookup or use selectedAgent for validation (e.g. reject an agent that isn't in agentList).

🤖 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/systems/session/hooks/use-session-create-dialog.ts` around lines 96 -
97, The selectedAgent lookup in the session creation dialog is redundant because
its name always equals draft.agentName when found. Remove selectedAgent and
derive selectedAgentName directly from draft.agentName, unless the flow needs to
validate membership in agentList; do not retain the current no-op fallback.

web/src/systems/session/hooks/__tests__/use-session-prompt-runtime.test.tsx (1)

43-50: 📐 Maintainability & Code Quality | 🔵 Trivial | 💤 Low value

Type authState with the payload's auth-state union.

authState: string plus the as ProviderSummary cast lets invalid states compile, weakening the fixture as a contract check.

♻️ Suggested typing

-function provider(name: string, authState: string): ProviderSummary {
+function provider(
+  name: string,
+  authState: NonNullable<ProviderSummary["auth_status"]>["state"]
+): ProviderSummary {

🤖 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/systems/session/hooks/__tests__/use-session-prompt-runtime.test.tsx`
around lines 43 - 50, Update the provider fixture helper’s authState parameter
to use the payload’s auth-state union type rather than string, and remove the
broad ProviderSummary cast so invalid states are rejected at compile time while
preserving the existing fixture fields.

web/src/systems/session/contexts/session-prompt-runtime-context.tsx (1)

22-29: 🚀 Performance & Scalability | 🔵 Trivial | 💤 Low value

input is recreated each render, so the sync effect runs on every render.

sessionPromptRuntimeInput returns a fresh object, so [input, store] never stays stable. Correctness is saved only by sameInput no-op inside the store. Memoizing on the primitive inputs keeps the effect a genuine external-system sync.

♻️ Suggested memoization

-  const input = sessionPromptRuntimeInput(session, canPrompt);
+  const input = useMemo(() => sessionPromptRuntimeInput(session, canPrompt), [session, canPrompt]);

(add useMemo to the React import)

🤖 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/systems/session/contexts/session-prompt-runtime-context.tsx` around
lines 22 - 29, Memoize the input created by sessionPromptRuntimeInput in the
session prompt runtime context using useMemo, with its primitive source values
as dependencies. Keep the existing store binding and inputUpdated effect
unchanged so the effect only synchronizes when the underlying input values
change.

web/src/systems/session/hooks/__tests__/use-session-create-dialog.test.tsx (1)

227-229: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Ordering assertion inside the navigate mock can be swallowed.

If this expect throws, the rejection is handled by the store's navigation execution path and the test may still pass. Assert ordering explicitly instead.

♻️ Deterministic ordering assertion

-    mockNavigate.mockImplementation(async () => {
-      expect(mockActivateWorkspace).toHaveBeenCalledWith(sessionInOtherWorkspace);
-    });
+    mockNavigate.mockResolvedValue(undefined);

and after waitFor:

expect(mockActivateWorkspace).toHaveBeenCalledWith(sessionInOtherWorkspace);
expect(mockActivateWorkspace.mock.invocationCallOrder[0]).toBeLessThan(
  mockNavigate.mock.invocationCallOrder[0]
);

🤖 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/systems/session/hooks/__tests__/use-session-create-dialog.test.tsx`
around lines 227 - 229, Move the activation assertion out of the mockNavigate
implementation in the session creation dialog test so failures cannot be
swallowed by the navigation execution path. After the existing waitFor, assert
mockActivateWorkspace was called with sessionInOtherWorkspace and explicitly
verify its first invocation order precedes mockNavigate’s first invocation using
their invocationCallOrder values.

Fix all unresolved CodeRabbit comments on this PR:

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

internal/store/store_helpers_test.go (1)

160-201: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Run the added table cases in parallel.

These cases execute serially because the shared t.Run body does not call t.Parallel(). Add it there; the validation closures only read immutable fixtures.

As per coding guidelines, “Go tests must use Should … subtest names, default to 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/store/store_helpers_test.go` around lines 160 - 201, Add
t.Parallel() to the shared t.Run body that executes these validation table
cases, while preserving the existing “Should …” subtest names and validation
behavior.

Source: Coding guidelines

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

998-1059: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Wrap this scenario in a Should … subtest.

The updated integration scenario runs directly in TestGlobalDBRegisterUpdateAndListSessions; move its body into t.Run("Should persist runtime replacement fields", ...).

As per path instructions, “MUST use t.Run("Should...") pattern for ALL test cases.”

🤖 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_test.go` around lines 998 - 1059, Wrap the
runtime replacement persistence scenario in
TestGlobalDBRegisterUpdateAndListSessions inside a t.Run subtest named "Should
persist runtime replacement fields". Move the related setup, updates,
ListSessions call, and assertions into that subtest while preserving their
behavior and ensuring the required Should-prefixed pattern is used.

Source: Path instructions

internal/session/manager_transition_test.go (1)

52-58: 🎯 Functional Correctness | 🔵 Trivial | 🏗️ Heavy lift

Exercise a bound runtime before asserting propagation.

createSession is promptless/unbound, and the catalog was registered from the same info before stopping. This equality check still passes if the update omits runtime fields. Bind non-default provider/model/status data first and assert a non-nil SpeedResolution too.

As per path instructions, “MUST test meaningful business logic” and “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/session/manager_transition_test.go` around lines 52 - 58, Strengthen
the propagation test around createSession and the stopping catalog by binding
non-default provider, model, and runtime status data before issuing the stop
request, rather than relying on the promptless unbound session. Extend the
assertion to require a non-nil SpeedResolution and verify its propagated value,
ensuring the test fails when runtime-field propagation is omitted.

Source: Path instructions

web/src/components/assistant-ui/hooks/use-session-composer-state.ts (1)

57-66: 📐 Maintainability & Code Quality | 🔵 Trivial | 💤 Low value

Local composerText shadows the state selector value.

Line 59 declares composerText inside the effect while line 20 already binds a composerText from useAuiState. Renaming the local (e.g. currentComposerText) makes the hydration guard easier to read and avoids accidental use of the stale render-scoped value later.

♻️ Suggested rename

-    const composerText = aui.composer().getState().text;
-    if (sameSession && composerText !== hydratedDraftTextRef.current) {
+    const currentComposerText = aui.composer().getState().text;
+    if (sameSession && currentComposerText !== hydratedDraftTextRef.current) {
       return;
     }

🤖 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/hooks/use-session-composer-state.ts` around
lines 57 - 66, Rename the local composer text variable inside the
useLayoutEffect in useSessionComposerState, such as to currentComposerText, and
update the sameSession hydration guard to use it; leave the composerText value
returned by useAuiState unchanged.

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

2635-2638: 📐 Maintainability & Code Quality | 🔵 Trivial | 💤 Low value

Drop the redundant loop-variable copy.

Since Go 1.22 loop variables are per-iteration, so testCase := testCase is unnecessary.

♻️ Suggested cleanup

 	for _, testCase := range testCases {
-		testCase := testCase
 		t.Run(testCase.name, 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/api/httpapi/handlers_test.go` around lines 2635 - 2638, Remove the
redundant testCase := testCase assignment in the testCases loop while keeping
the parallel subtest structure and existing test behavior unchanged.

internal/session/manager_prompt_event_storage.go (1)

74-80: 📐 Maintainability & Code Quality | 🔵 Trivial | 💤 Low value

Clarify the snapshot materialization.

WithPromptRuntime(event.PromptRuntimeSnapshot()) creates a new event with a cloned snapshot payload. If that cloning is intentional, add a short comment; otherwise this assignment can be omitted.

🤖 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_prompt_event_storage.go` around lines 74 - 80,
Clarify the intent of the initial assignment in promptRuntimeFallbackForEvent:
if cloning event.PromptRuntimeSnapshot() via WithPromptRuntime is required, add
a brief comment explaining the snapshot materialization; otherwise remove that
assignment while preserving the existing nil-session and fallback behavior.

Fix all unresolved CodeRabbit comments on this PR:

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