fix(orchestrator): Harden Grok v2 settlement and steer message visibility

apps/server/src/claudeModelOptions.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it } from "vite-plus/test";
 
 import { ProviderInstanceId, type ModelSelection } from "@t3tools/contracts";
 

apps/server/src/orchestration-v2/Adapters/GrokAdapterV2.test.ts

@@ -2,7 +2,18 @@ import { assert, describe, it } from "@effect/vitest";
 import type * as EffectAcpSchema from "effect-acp/schema";
 
 import { ProviderAdapterV2RuntimePolicy } from "../ProviderAdapter.ts";
-import { AcpProviderCapabilitiesV2, acpPermissionDisposition } from "./AcpAdapterV2.ts";
+import {
+  AcpProviderCapabilitiesV2,
+  acpPermissionDisposition,
+  acpRootSessionUpdateIngestsOutput,
+  acpRootTurnCompletionDrainMs,
+  acpRootTurnHasIngestedOutput,
+  acpRootTurnIsIdle,
+  acpRootTurnLivenessWatchdogDefersForPending,
+  acpRootTurnPromptLivenessMs,
+  acpRootTurnSettleDebounceMs,
+  acpRootTurnShouldRearmRecoveryTimers,
+} from "./AcpAdapterV2.ts";
 import { GrokProviderCapabilitiesV2 } from "./GrokAdapterV2.ts";
 
 function permissionRequest(
@@ -37,6 +48,161 @@ function runtimePolicy(input: {
   });
 }
 
+describe("acpRootTurnSettleDebounceMs", () => {
+  it("allows tool calls to land after a brief assistant preamble", () => {
+    assert.equal(acpRootTurnSettleDebounceMs, 2_000);
+  });
+});
+
+describe("acpRootTurnPromptLivenessMs", () => {
+  it("fails silent post-prompt hangs before the user waits hours", () => {
+    assert.equal(acpRootTurnPromptLivenessMs, 30_000);
+  });
+});
+
+describe("acpRootTurnCompletionDrainMs", () => {
+  it("gives trailing root chunks a short landing window", () => {
+    assert.equal(acpRootTurnCompletionDrainMs, 100);
+  });
+});
+
+describe("acpRootSessionUpdateIngestsOutput", () => {
+  const sessionId = "session-1";
+
+  it("ignores empty assistant chunks used as Grok keepalives", () => {
+    assert.isFalse(
+      acpRootSessionUpdateIngestsOutput({
+        sessionId,
+        update: {
+          sessionUpdate: "agent_message_chunk",
+          content: { type: "text", text: "" },
+        },
+      }),
+    );
+  });
+
+  it("accepts non-empty assistant and reasoning chunks", () => {
+    assert.isTrue(
+      acpRootSessionUpdateIngestsOutput({
+        sessionId,
+        update: {
+          sessionUpdate: "agent_message_chunk",
+          content: { type: "text", text: "hello" },
+        },
+      }),
+    );
+    assert.isTrue(
+      acpRootSessionUpdateIngestsOutput({
+        sessionId,
+        update: {
+          sessionUpdate: "agent_thought_chunk",
+          content: { type: "text", text: "thinking" },
+        },
+      }),
+    );
+  });
+
+  it("accepts tool and plan updates", () => {
+    assert.isTrue(
+      acpRootSessionUpdateIngestsOutput({
+        sessionId,
+        update: {
+          sessionUpdate: "tool_call",
+          toolCallId: "tool-1",
+          title: "Read",
+          kind: "read",
+          status: "pending",
+        },
+      }),
+    );
+    assert.isTrue(
+      acpRootSessionUpdateIngestsOutput({
+        sessionId,
+        update: {
+          sessionUpdate: "plan",
+          entries: [{ content: "Step 1", status: "pending", priority: "medium" }],
+        },
+      }),
+    );
+  });
+});
+
+describe("acpRootTurnHasIngestedOutput", () => {
+  const empty = {
+    assistant: { current: null, nextSegment: 0 },
+    reasoning: { current: null, nextSegment: 0 },
+    tools: new Map(),
+    plan: null,
+  } as const;
+
+  it("is false before any root turn items land", () => {
+    assert.isFalse(acpRootTurnHasIngestedOutput(empty));
+  });
+
+  it("is true once assistant segments have streamed", () => {
+    assert.isTrue(
+      acpRootTurnHasIngestedOutput({
+        ...empty,
+        assistant: { current: null, nextSegment: 1 },
+      }),
+    );
+  });
+});
+
+describe("acpRootTurn recovery timer re-arm", () => {
+  it("re-arms settle and watchdog after pending clears on active turns", () => {
+    assert.isTrue(acpRootTurnShouldRearmRecoveryTimers({ finalized: false, interrupted: false }));
+  });
+
+  it("skips re-arm when the turn is already terminal", () => {
+    assert.isFalse(acpRootTurnShouldRearmRecoveryTimers({ finalized: true, interrupted: false }));
+    assert.isFalse(acpRootTurnShouldRearmRecoveryTimers({ finalized: false, interrupted: true }));
+  });
+
+  it("defers the liveness watchdog tick while approval or user-input is pending", () => {
+    assert.isTrue(acpRootTurnLivenessWatchdogDefersForPending(true));
+    assert.isFalse(acpRootTurnLivenessWatchdogDefersForPending(false));
+  });
+});
+
+describe("acpRootTurnIsIdle", () => {
+  const idle = {
+    finalized: false,
+    interrupted: false,
+    assistantStreamOpen: false,
+    reasoningStreamOpen: false,
+    hasRunningTool: false,
+    hasPendingRuntimeRequest: false,
+    hasToolHistory: false,
+    hasRunningSubagent: false,
+    hasOutput: true,
+  } as const;
+
+  it("is false while assistant text is still streaming", () => {
+    assert.isFalse(acpRootTurnIsIdle({ ...idle, assistantStreamOpen: true }));
+  });
+
+  it("is false while a tool is running", () => {
+    assert.isFalse(acpRootTurnIsIdle({ ...idle, hasRunningTool: true }));
+  });
+
+  it("is false after tool history until the prompt RPC completes", () => {
+    assert.isFalse(acpRootTurnIsIdle({ ...idle, hasToolHistory: true }));
+  });
+
+  it("is false while a native subagent task is still running", () => {
+    assert.isFalse(acpRootTurnIsIdle({ ...idle, hasRunningSubagent: true }));
+  });
+
+  it("is false when only reasoning or tools have streamed", () => {
+    assert.isFalse(acpRootTurnIsIdle({ ...idle, hasOutput: false }));
+  });
+
+  it("is true when root assistant output is quiescent", () => {
+    assert.isTrue(acpRootTurnIsIdle(idle));
+  });
+});
+
 describe("GrokAdapterV2 capabilities", () => {
   it("keeps optional protocol features conservative until a flavor or handshake confirms them", () => {
     assert.isFalse(AcpProviderCapabilitiesV2.sessions.supportsModelSwitchInSession);

apps/server/src/orchestration-v2/Adapters/GrokAdapterV2.ts

@@ -40,6 +40,7 @@ import {
 } from "../ProviderAdapterDriver.ts";
 import {
   AcpProviderCapabilitiesV2,
+  acpRootTurnPromptLivenessMs,
   makeAcpAdapterV2,
   type AcpAdapterV2Flavor,
   type AcpAdapterV2RuntimeInput,
@@ -132,12 +133,16 @@ export function makeGrokAdapterV2(options: GrokAdapterV2Options) {
   const flavor: AcpAdapterV2Flavor = {
     driver: GROK_PROVIDER,
     capabilities: GrokProviderCapabilitiesV2,
+    settleRootTurnWhenIdle: true,
+    interruptPromptOnCancel: false,
+    rootTurnPromptLivenessMs: acpRootTurnPromptLivenessMs,
     resolveModelId: (selection) => resolveGrokAcpBaseModelId(selection.model),
     makeRuntime:
       options.makeRuntime ??
       ((input) =>
         makeGrokAcpRuntime({
           ...input,
+          interruptPromptOnCancel: input.interruptPromptOnCancel ?? false,
           grokSettings: options.settings,
           environment: options.environment,
           childProcessSpawner: options.childProcessSpawner,

apps/server/src/orchestration-v2/ProviderSelectionTransition.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it } from "vite-plus/test";
 
 import {
   type ModelSelection,