[Bug]: Mobile queue sheet silently refuses Resume queue on a usage-limited thread #35554

#!/bin/sh
set -eu
# Run from a checkout with its locked dependencies installed, or pass its root as $1.
checkout=${1:-$(pwd)}
fixture=$(mktemp -d "${TMPDIR:-/tmp}/queue-sheet-repro.XXXXXX")
mkdir -p "$fixture/userhome" "$fixture/tmp" "$fixture/t3"
test_file="$checkout/apps/server/src/orchestration-v2/runtimeLayer.test.ts"
cp "$test_file" "$fixture/original.test.ts"
cleanup() { cp "$fixture/original.test.ts" "$test_file"; rm -rf "$fixture"; }
trap cleanup EXIT HUP INT TERM
cat >> "$test_file" <<'VERIFY_TEST'

import { deriveThreadQueueWorkflowState as verifyQueueWorkflow } from "../../../../packages/client-runtime/src/state/threadWorkflows.ts";

const emitVerify = (...args: unknown[]) => process.stdout.write(args.map(String).join(" ") + "\n");

it.layer(layerTest)("queue sheet resume reproduction", (it) => {
  it.effect.each(([
    ["startup", "usage_limit"],
    ["startup", "provider_error"],
    ["stop", "usage_limit"],
    ["stop", "provider_error"],
  ] as const).map(([trigger, failureClass]) => ({ trigger, failureClass })))("$trigger after $failureClass", ({ trigger, failureClass }) => Effect.gen(function* () {
    const orchestrator = yield* Orchestrator.OrchestratorV2;
    const events = yield* EventSink.EventSinkV2;
    const recovery = yield* ProviderRuntimeRecoveryService.ProviderRuntimeRecoveryService;
    const threadId = ThreadId.make(`verify-sheet:${trigger}:${failureClass}`);
    yield* orchestrator.dispatch({
      type: "thread.create", createdBy: "user", creationSource: "mobile",
      commandId: CommandId.make(`${threadId}:create`), threadId,
      projectId: ProjectId.make(`${threadId}:project`), title: "Queue verification",
      modelSelection, runtimeMode: "full-access", interactionMode: "default",
      branch: null, worktreePath: process.cwd(),
    });
    for (const index of [0, 1]) {
      yield* orchestrator.dispatch({
        type: "message.dispatch", createdBy: "user", creationSource: "mobile",
        commandId: CommandId.make(`${threadId}:message:${index}`), threadId,
        messageId: MessageId.make(`${threadId}:message:${index}`),
        text: index === 0 ? "Start" : "Follow up", attachments: [], modelSelection,
        dispatchMode: { type: index === 0 ? "start_immediately" : "queue_after_active" },
      });
    }
    const active = (yield* orchestrator.getThreadProjection(threadId)).runs.find(r => r.status === "starting")!;
    assert.isDefined(active);
    const now = yield* DateTime.now;
    yield* events.write({ events: [
      {
        id: EventId.make(`${threadId}:error`), type: "turn-item.updated", threadId,
        runId: active.id, nodeId: active.rootNodeId!, providerInstanceId: active.providerInstanceId,
        occurredAt: now,
        payload: {
          id: TurnItemId.make(`${threadId}:error`), type: "error", threadId,
          runId: active.id, nodeId: active.rootNodeId!, providerThreadId: active.providerThreadId,
          providerTurnId: null, nativeItemRef: null, parentItemId: null, ordinal: 2,
          status: "failed", title: "Provider failure", startedAt: now, completedAt: now, updatedAt: now,
          failure: { class: failureClass, message: "Provider failed.", code: "provider_failed", retryable: null,
            ...(failureClass === "usage_limit" ? { resetAt: null } : {}) },
        },
      },
      {
        id: EventId.make(`${threadId}:failed`), type: "run.updated", threadId,
        runId: active.id, providerInstanceId: active.providerInstanceId, occurredAt: now,
        payload: { ...active, status: "failed", completedAt: now },
      },
    ] });
    yield* orchestrator.resumeQueuedRuns;
    const before = yield* orchestrator.getThreadProjection(threadId);
    emitVerify("VERIFY_BEFORE", trigger, failureClass, JSON.stringify(before.runs.map(r => [r.status, r.queueHeld === true])));
    if (trigger === "startup") yield* recovery.reconcile("startup");
    else yield* orchestrator.dispatch({ type: "thread.stop", commandId: CommandId.make(`${threadId}:stop`), threadId });
    const projection = yield* orchestrator.getThreadProjection(threadId);
    const workflow = verifyQueueWorkflow(projection);
    const shell = (yield* orchestrator.getShellSnapshot()).threads.find(t => t.id === threadId)!;
    const visible = workflow.isHeld && workflow.queuedRuns.length > 0;
    assert.isTrue(visible);
    assert.equal(shell.lastErrorClass, failureClass);
    const outcome = yield* orchestrator.dispatch({
      type: "queue.resume", commandId: CommandId.make(`${threadId}:resume`), threadId,
    }).pipe(
      Effect.as("RESUMED"),
      Effect.catchTag("OrchestratorDispatchError", error => Effect.succeed(`REJECTED: ${String(error.cause)}`)),
    );
    const after = yield* orchestrator.getThreadProjection(threadId);
    const unchanged = JSON.stringify(projection.runs) === JSON.stringify(after.runs);
    emitVerify("VERIFY_RESULT", JSON.stringify({ trigger, failureClass,
      runs: projection.runs.map(r => [r.status, r.queueHeld === true]),
      lastErrorClass: shell.lastErrorClass, queuedCount: workflow.queuedRuns.length,
      isHeld: workflow.isHeld, sheetButtonVisible: visible, outcome, queueUnchanged: unchanged }));
    if (failureClass === "usage_limit") {
      assert.equal(outcome, "REJECTED: Continue the limited thread before resuming its queue.");
      assert.isTrue(unchanged);
      yield* orchestrator.dispatch({
        type: "message.dispatch", createdBy: "user", creationSource: "mobile",
        commandId: CommandId.make(`${threadId}:continue`), threadId,
        messageId: MessageId.make(`${threadId}:continue`), manualContinuationOfRunId: active.id,
        text: "Continue where you left off.", attachments: [], modelSelection,
        dispatchMode: { type: "start_immediately" },
      });
      yield* orchestrator.dispatch({type: "queue.resume", commandId: CommandId.make(`${threadId}:resume-after-continue`), threadId});
      const continued = yield* orchestrator.getThreadProjection(threadId);
      assert.isTrue(continued.runs.some(r => r.id !== active.id && r.status === "starting"));
      assert.isFalse(continued.runs.some(r => r.status === "queued" && r.queueHeld === true));
      emitVerify("VERIFY_WORKAROUND", trigger, "manual continuation then queue.resume succeeded; queued follow-up retained and unheld");
    } else {
      assert.equal(outcome, "RESUMED");
      assert.isFalse(after.runs.some(r => r.status === "queued" && r.queueHeld === true));
    }
  }));
});
VERIFY_TEST
cd "$checkout"
printf 'Revision: '
git rev-parse HEAD
set +e
env -u NODE_ENV HOME="$fixture/userhome" TMPDIR="$fixture/tmp" T3CODE_HOME="$fixture/t3" PATH="$checkout/node_modules/.bin:$PATH" vp test run apps/server/src/orchestration-v2/runtimeLayer.test.ts -t "queue sheet resume reproduction" > "$fixture/test.log" 2>&1
result=$?
set -e
cat "$fixture/test.log"
[ "$result" -eq 0 ] || exit "$result"
[ "$(grep -c 'VERIFY_RESULT' "$fixture/test.log")" -eq 4 ]
[ "$(grep -c 'VERIFY_WORKAROUND' "$fixture/test.log")" -eq 2 ]
printf '%s\n' 'DEFECT PRESENT: all held usage-limited queues reject the visible sheet action; all provider-error controls and all manual-continuation workarounds succeed.'