@stigmer/server 3.14.0-dev.20260910084630

package/src/temporal/agentexecution/__tests__/activities.test.ts

@@ -0,0 +1,352 @@
+/**
+ * Server-side activity tests — pins the contracts of activities.ts:
+ *
+ *   - UpdateExecutionStatus owns only the payload boundary: it decodes
+ *     the proto-JSON status into a typed UpdateStatus input and hands it
+ *     to the in-process status edge (stigmer#979) — the lane's answer,
+ *     success or ConnectError, IS the activity's outcome. The lane itself
+ *     (transport, interceptors, handler, merge, hooks, broadcast) is
+ *     pinned end to end in own-behalf-status-writes.test.ts;
+ *   - LoadAgentExecution returns proto-JSON that survives the payload
+ *     boundary INCLUDING int64 fields (the bigint rule: a Message
+ *     instance would crash the default converter);
+ *   - ReadHarnessStateId's empty-input and not-found contracts (Go
+ *     read_harness_state_id.go);
+ *   - DeleteExecutionContext delegates to #15's idempotent seam;
+ *   - CompleteExternalActivity: empty-token skip, base64 token decode,
+ *     error-over-result precedence — the DD-001 lane Go cannot deliver
+ *     (oss#861), so the ERROR path is the load-bearing assertion.
+ */
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { create, fromJson, toJson } from "@bufbuild/protobuf";
+import type { JsonValue } from "@bufbuild/protobuf";
+import { Code, ConnectError } from "@connectrpc/connect";
+import type { Client } from "@temporalio/client";
+import { afterEach, describe, expect, it } from "vitest";
+
+import {
+  AgentExecutionSchema,
+  AgentExecutionStatusSchema,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
+import { ExecutionPhase } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import type { AgentExecutionUpdateStatusInput } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/io_pb";
+import { UpdateStatusResponseSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/io_pb";
+import { ExecutionContextSchema } from "@stigmer/protos/ai/stigmer/agentic/executioncontext/v1/api_pb";
+import { SessionSchema } from "@stigmer/protos/ai/stigmer/agentic/session/v1/api_pb";
+import { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
+
+import { createLogger } from "../../../boot/logger.js";
+import { SqliteStore } from "../../../store/sqlite/store.js";
+import type { Store } from "../../../store/interface.js";
+import { createAgentExecutionActivities } from "../activities.js";
+import type { ExecutionStatusWriter } from "../activities.js";
+import {
+  COMPLETE_EXTERNAL_ACTIVITY_NAME,
+  LOAD_AGENT_EXECUTION_ACTIVITY_NAME,
+  READ_HARNESS_STATE_ID_ACTIVITY_NAME,
+  UPDATE_EXECUTION_STATUS_ACTIVITY_NAME,
+} from "../names.js";
+import { DELETE_EXECUTION_CONTEXT_ACTIVITY_NAME } from "../../../domain/executioncontext/temporal/delete-execution-context.js";
+
+const silentLogger = createLogger({
+  level: "error",
+  pretty: false,
+  write: () => {},
+});
+
+const cleanups: Array<() => Promise<void> | void> = [];
+afterEach(async () => {
+  for (const cleanup of cleanups.splice(0)) {
+    await cleanup();
+  }
+});
+
+interface CompletionCall {
+  readonly kind: "complete" | "fail";
+  readonly taskToken: Buffer;
+  readonly payload: unknown;
+}
+
+function newFixture() {
+  const dir = mkdtempSync(path.join(tmpdir(), "activities-test-"));
+  const store: Store = SqliteStore.open(
+    path.join(dir, "activities.sqlite"),
+    silentLogger,
+  );
+  cleanups.push(async () => {
+    await store.close();
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  const completions: CompletionCall[] = [];
+  const stubClient = {
+    activity: {
+      complete: async (taskToken: Buffer, payload: unknown): Promise<void> => {
+        completions.push({ kind: "complete", taskToken, payload });
+      },
+      fail: async (taskToken: Buffer, error: unknown): Promise<void> => {
+        completions.push({ kind: "fail", taskToken, payload: error });
+      },
+    },
+  } as unknown as Client;
+
+  // The in-process status edge as a recording fake: these are UNIT pins
+  // of the activity's payload boundary, so the lane is a seam here (the
+  // real lane is exercised in own-behalf-status-writes.test.ts).
+  const writes: AgentExecutionUpdateStatusInput[] = [];
+  let writerFault: ConnectError | undefined;
+  const statusWriter: ExecutionStatusWriter = {
+    updateStatus: (input) => {
+      if (writerFault !== undefined) {
+        return Promise.reject(writerFault);
+      }
+      writes.push(input);
+      return Promise.resolve(create(UpdateStatusResponseSchema));
+    },
+  };
+
+  const activities = createAgentExecutionActivities({
+    store,
+    logger: silentLogger,
+    statusWriter: () => statusWriter,
+    client: () => stubClient,
+  });
+  return {
+    store,
+    activities,
+    completions,
+    writes,
+    failWriterWith(error: ConnectError): void {
+      writerFault = error;
+    },
+  };
+}
+
+async function saveExecution(
+  store: Store,
+  id: string,
+  phase = ExecutionPhase.EXECUTION_IN_PROGRESS,
+): Promise<void> {
+  await store.saveResource(
+    ApiResourceKind.agent_execution,
+    id,
+    AgentExecutionSchema,
+    create(AgentExecutionSchema, {
+      apiVersion: "agentic.stigmer.ai/v1",
+      kind: "AgentExecution",
+      metadata: { id, name: "test-exec", org: "test-org" },
+      spec: { agentId: "agt_1", sessionId: "ses_1" },
+      status: {
+        phase,
+        streamingUsage: { totalTokens: 1234n, estimatedCostUsd: 0.05 },
+      },
+    }),
+  );
+}
+
+describe("UpdateExecutionStatus activity", () => {
+  it("decodes the proto-JSON status into a typed UpdateStatus input for the in-process edge", async () => {
+    const { activities, writes } = newFixture();
+    const update = create(AgentExecutionStatusSchema, {
+      phase: ExecutionPhase.EXECUTION_FAILED,
+      error: "boom",
+      // An int64 field crossing the payload boundary as JSON and coming
+      // back typed — the bigint rule the module header states.
+      streamingUsage: { totalTokens: 1234n },
+    });
+
+    await (
+      activities[UPDATE_EXECUTION_STATUS_ACTIVITY_NAME] as (
+        id: string,
+        status: JsonValue,
+      ) => Promise<void>
+    )("aex_upd_1", toJson(AgentExecutionStatusSchema, update));
+
+    expect(writes).toHaveLength(1);
+    expect(writes[0]?.executionId).toBe("aex_upd_1");
+    expect(writes[0]?.status?.phase).toBe(ExecutionPhase.EXECUTION_FAILED);
+    expect(writes[0]?.status?.error).toBe("boom");
+    expect(writes[0]?.status?.streamingUsage?.totalTokens).toBe(1234n);
+  });
+
+  it("fails as an ordinary activity error on malformed status JSON, before the edge is reached", async () => {
+    const { activities, writes } = newFixture();
+    await expect(
+      (
+        activities[UPDATE_EXECUTION_STATUS_ACTIVITY_NAME] as (
+          id: string,
+          status: JsonValue,
+        ) => Promise<void>
+      )("aex_upd_bad", { phase: { not: "a phase" } }),
+    ).rejects.toThrow();
+    expect(writes).toHaveLength(0);
+  });
+
+  it("surfaces the edge's ConnectError as the activity's failure (the lane's NotFound for a deleted execution)", async () => {
+    const { activities, failWriterWith } = newFixture();
+    failWriterWith(
+      new ConnectError("AgentExecution not found: aex_missing", Code.NotFound),
+    );
+    await expect(
+      (
+        activities[UPDATE_EXECUTION_STATUS_ACTIVITY_NAME] as (
+          id: string,
+          status: JsonValue,
+        ) => Promise<void>
+      )("aex_missing", { phase: "EXECUTION_FAILED" }),
+    ).rejects.toThrow(/not.?found/i);
+  });
+});
+
+describe("LoadAgentExecution activity", () => {
+  it("returns proto-JSON whose int64 fields survive the payload boundary", async () => {
+    const { store, activities } = newFixture();
+    await saveExecution(store, "aex_load_1");
+
+    const raw = (await (
+      activities[LOAD_AGENT_EXECUTION_ACTIVITY_NAME] as (
+        id: string,
+      ) => Promise<JsonValue>
+    )("aex_load_1")) as Record<string, JsonValue>;
+
+    // The wire form must be plain JSON — bigint would crash the default
+    // payload converter's JSON.stringify.
+    expect(() => JSON.stringify(raw)).not.toThrow();
+    const parsed = fromJson(AgentExecutionSchema, raw);
+    expect(parsed.metadata?.id).toBe("aex_load_1");
+    expect(parsed.status?.streamingUsage?.totalTokens).toBe(1234n);
+  });
+
+  it("throws on an unknown execution", async () => {
+    const { activities } = newFixture();
+    await expect(
+      (
+        activities[LOAD_AGENT_EXECUTION_ACTIVITY_NAME] as (
+          id: string,
+        ) => Promise<JsonValue>
+      )("aex_absent"),
+    ).rejects.toThrow();
+  });
+});
+
+describe("ReadHarnessStateId activity", () => {
+  it("returns empty for an empty session id without error", async () => {
+    const { activities } = newFixture();
+    await expect(
+      (
+        activities[READ_HARNESS_STATE_ID_ACTIVITY_NAME] as (
+          sessionId: string,
+        ) => Promise<string>
+      )(""),
+    ).resolves.toBe("");
+  });
+
+  it("returns the stored harness_state_id", async () => {
+    const { store, activities } = newFixture();
+    await store.saveResource(
+      ApiResourceKind.session,
+      "ses_h1",
+      SessionSchema,
+      create(SessionSchema, {
+        apiVersion: "agentic.stigmer.ai/v1",
+        kind: "Session",
+        metadata: { id: "ses_h1", name: "s", org: "o" },
+        spec: { agentInstanceId: "ain_1", harnessStateId: "cursor-agent-42" },
+      }),
+    );
+    await expect(
+      (
+        activities[READ_HARNESS_STATE_ID_ACTIVITY_NAME] as (
+          sessionId: string,
+        ) => Promise<string>
+      )("ses_h1"),
+    ).resolves.toBe("cursor-agent-42");
+  });
+
+  it("fails on a missing session with the pinned message shape", async () => {
+    const { activities } = newFixture();
+    await expect(
+      (
+        activities[READ_HARNESS_STATE_ID_ACTIVITY_NAME] as (
+          sessionId: string,
+        ) => Promise<string>
+      )("ses_missing"),
+    ).rejects.toThrow(/load session ses_missing for harness_state_id/);
+  });
+});
+
+describe("DeleteExecutionContext activity", () => {
+  it("deletes the ExecutionContext for the execution and is idempotent", async () => {
+    const { store, activities } = newFixture();
+    await store.saveResource(
+      ApiResourceKind.execution_context,
+      "ectx_1",
+      ExecutionContextSchema,
+      create(ExecutionContextSchema, {
+        apiVersion: "agentic.stigmer.ai/v1",
+        kind: "ExecutionContext",
+        metadata: { id: "ectx_1", name: "ec", org: "o" },
+        spec: { executionId: "aex_del_1" },
+      }),
+    );
+
+    const remove = activities[DELETE_EXECUTION_CONTEXT_ACTIVITY_NAME] as (
+      executionId: string,
+    ) => Promise<void>;
+    await remove("aex_del_1");
+    await expect(
+      store.getResource(
+        ApiResourceKind.execution_context,
+        "ectx_1",
+        ExecutionContextSchema,
+      ),
+    ).rejects.toThrow();
+    // Best-effort seam: a second delete (nothing left) must not throw.
+    await expect(remove("aex_del_1")).resolves.toBeUndefined();
+  });
+});
+
+describe("CompleteExternalActivity", () => {
+  type CompleteFn = (input: {
+    callbackToken: string;
+    result?: unknown;
+    errorMessage?: string;
+  }) => Promise<void>;
+
+  it("skips an empty token (backward compatibility)", async () => {
+    const { activities, completions } = newFixture();
+    await (activities[COMPLETE_EXTERNAL_ACTIVITY_NAME] as CompleteFn)({
+      callbackToken: "",
+    });
+    expect(completions).toHaveLength(0);
+  });
+
+  it("completes with the result, decoding the base64 token", async () => {
+    const { activities, completions } = newFixture();
+    const token = Buffer.from("task-token-1");
+    await (activities[COMPLETE_EXTERNAL_ACTIVITY_NAME] as CompleteFn)({
+      callbackToken: token.toString("base64"),
+      result: { agent_execution_id: "aex_1" },
+    });
+    expect(completions).toHaveLength(1);
+    expect(completions[0]!.kind).toBe("complete");
+    expect(Buffer.compare(completions[0]!.taskToken, token)).toBe(0);
+    expect(completions[0]!.payload).toEqual({ agent_execution_id: "aex_1" });
+  });
+
+  it("fails with the error message — and error takes precedence over result (DD-001, oss#861)", async () => {
+    const { activities, completions } = newFixture();
+    await (activities[COMPLETE_EXTERNAL_ACTIVITY_NAME] as CompleteFn)({
+      callbackToken: Buffer.from("task-token-2").toString("base64"),
+      result: { should: "be ignored" },
+      errorMessage: "agent execution failed: boom",
+    });
+    expect(completions).toHaveLength(1);
+    expect(completions[0]!.kind).toBe("fail");
+    expect((completions[0]!.payload as Error).message).toBe(
+      "agent execution failed: boom",
+    );
+  });
+});

package/src/temporal/agentexecution/__tests__/dispatch.test.ts

@@ -0,0 +1,336 @@
+/**
+ * Dispatch-resolution tests — ports
+ * pkg/domain/agentexecution/temporal/dispatch_test.go case-for-case: the
+ * queue-routing modes (global vs session), the harness/execution-target
+ * extraction with the session-not-found degrade, the UNSPECIFIED-target
+ * resolution against the config default, and the sandbox-affinity
+ * override lane (opaque queue pass-through with forced LOCAL target so
+ * cloud sandbox provisioning never triggers, and NATIVE-harness default
+ * when the session is absent). Go's private resolveTaskQueue cases are
+ * asserted through resolveActivityTaskQueue — the public boundary is the
+ * contract.
+ */
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { create } from "@bufbuild/protobuf";
+import { afterEach, describe, expect, it } from "vitest";
+
+import { SessionSchema } from "@stigmer/protos/ai/stigmer/agentic/session/v1/api_pb";
+import {
+  ExecutionTarget,
+  Harness,
+} from "@stigmer/protos/ai/stigmer/agentic/session/v1/enum_pb";
+import { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
+
+import { createLogger } from "../../../boot/logger.js";
+import {
+  AgentExecutionTemporalConfig,
+  DEFAULT_EXECUTION_TARGET_CLOUD,
+  DEFAULT_EXECUTION_TARGET_LOCAL,
+  ROUTING_GLOBAL,
+  ROUTING_SESSION,
+} from "../../../domain/agentexecution/temporal/config.js";
+import { SqliteStore } from "../../../store/sqlite/store.js";
+import type { Store } from "../../../store/interface.js";
+import { formatSessionTaskQueue, resolveActivityTaskQueue } from "../dispatch.js";
+import { DEFAULT_ACTIVITY_TASK_QUEUE } from "../names.js";
+
+const silentLogger = createLogger({
+  level: "error",
+  pretty: false,
+  write: () => {},
+});
+
+const cleanups: Array<() => Promise<void> | void> = [];
+afterEach(async () => {
+  for (const cleanup of cleanups.splice(0)) {
+    await cleanup();
+  }
+});
+
+function newStore(): Store {
+  const dir = mkdtempSync(path.join(tmpdir(), "dispatch-test-"));
+  const store = SqliteStore.open(path.join(dir, "dispatch_test.sqlite"), silentLogger);
+  cleanups.push(async () => {
+    await store.close();
+    rmSync(dir, { recursive: true, force: true });
+  });
+  return store;
+}
+
+async function saveSession(
+  store: Store,
+  id: string,
+  harness: Harness,
+  executionTarget = ExecutionTarget.UNSPECIFIED,
+): Promise<void> {
+  await store.saveResource(
+    ApiResourceKind.session,
+    id,
+    SessionSchema,
+    create(SessionSchema, {
+      apiVersion: "agentic.stigmer.ai/v1",
+      kind: "Session",
+      metadata: { id, name: "test-session", org: "test-org" },
+      spec: { agentInstanceId: "test-instance", harness, executionTarget },
+    }),
+  );
+}
+
+function globalConfig(): AgentExecutionTemporalConfig {
+  return new AgentExecutionTemporalConfig(
+    "agent_execution_stigmer",
+    DEFAULT_ACTIVITY_TASK_QUEUE,
+    ROUTING_GLOBAL,
+    DEFAULT_EXECUTION_TARGET_LOCAL,
+  );
+}
+
+function sessionConfig(): AgentExecutionTemporalConfig {
+  return new AgentExecutionTemporalConfig(
+    "agent_execution_stigmer",
+    DEFAULT_ACTIVITY_TASK_QUEUE,
+    ROUTING_SESSION,
+    DEFAULT_EXECUTION_TARGET_LOCAL,
+  );
+}
+
+function cloudConfig(): AgentExecutionTemporalConfig {
+  return new AgentExecutionTemporalConfig(
+    "agent_execution_stigmer",
+    DEFAULT_ACTIVITY_TASK_QUEUE,
+    ROUTING_SESSION,
+    DEFAULT_EXECUTION_TARGET_CLOUD,
+  );
+}
+
+describe("formatSessionTaskQueue", () => {
+  it.each([
+    ["ses_01arz3ndektsv4rrffq69g5fav", "session:ses_01arz3ndektsv4rrffq69g5fav"],
+    ["ses_abc123", "session:ses_abc123"],
+    ["any-arbitrary-id", "session:any-arbitrary-id"],
+  ])("formats %s", (sessionId, want) => {
+    expect(formatSessionTaskQueue(sessionId)).toBe(want);
+  });
+});
+
+describe("resolveActivityTaskQueue — global routing", () => {
+  it("no session ID — returns default queue with NATIVE harness", async () => {
+    const store = newStore();
+    const result = await resolveActivityTaskQueue(store, "", globalConfig(), "", silentLogger);
+    expect(result.taskQueue).toBe(DEFAULT_ACTIVITY_TASK_QUEUE);
+    expect(result.harness).toBe(Harness.NATIVE);
+  });
+
+  it("session not found — returns default queue without error", async () => {
+    const store = newStore();
+    const result = await resolveActivityTaskQueue(
+      store,
+      "nonexistent-session",
+      globalConfig(),
+      "",
+      silentLogger,
+    );
+    expect(result.taskQueue).toBe(DEFAULT_ACTIVITY_TASK_QUEUE);
+  });
+
+  it("valid session — returns default queue even with session present", async () => {
+    const store = newStore();
+    await saveSession(store, "ses_global_test", Harness.CURSOR);
+    const result = await resolveActivityTaskQueue(
+      store,
+      "ses_global_test",
+      globalConfig(),
+      "",
+      silentLogger,
+    );
+    expect(result.taskQueue, "global routing must always return default queue").toBe(
+      DEFAULT_ACTIVITY_TASK_QUEUE,
+    );
+    expect(result.harness).toBe(Harness.CURSOR);
+  });
+});
+
+describe("resolveActivityTaskQueue — session routing", () => {
+  it("no session ID — falls back to default queue", async () => {
+    const store = newStore();
+    const result = await resolveActivityTaskQueue(store, "", sessionConfig(), "", silentLogger);
+    expect(result.taskQueue).toBe(DEFAULT_ACTIVITY_TASK_QUEUE);
+    expect(result.harness).toBe(Harness.NATIVE);
+  });
+
+  it("valid session ID — returns per-session queue", async () => {
+    const store = newStore();
+    const sessionId = "ses_01arz3ndektsv4rrffq69g5fav";
+    await saveSession(store, sessionId, Harness.NATIVE);
+    const result = await resolveActivityTaskQueue(
+      store,
+      sessionId,
+      sessionConfig(),
+      "",
+      silentLogger,
+    );
+    expect(result.taskQueue).toBe(`session:${sessionId}`);
+    expect(result.harness).toBe(Harness.NATIVE);
+  });
+
+  it("session not found — still returns per-session queue with NATIVE default", async () => {
+    const store = newStore();
+    const sessionId = "ses_nonexistent";
+    const result = await resolveActivityTaskQueue(
+      store,
+      sessionId,
+      sessionConfig(),
+      "",
+      silentLogger,
+    );
+    expect(result.taskQueue).toBe(`session:${sessionId}`);
+    expect(result.harness, "NATIVE default when session not found").toBe(Harness.NATIVE);
+  });
+
+  it("CURSOR harness — returns per-session queue with correct harness", async () => {
+    const store = newStore();
+    const sessionId = "ses_cursor_session";
+    await saveSession(store, sessionId, Harness.CURSOR);
+    const result = await resolveActivityTaskQueue(
+      store,
+      sessionId,
+      sessionConfig(),
+      "",
+      silentLogger,
+    );
+    expect(result.taskQueue).toBe(`session:${sessionId}`);
+    expect(result.harness).toBe(Harness.CURSOR);
+  });
+
+  it("custom runner queue used as the empty-session fallback", async () => {
+    const store = newStore();
+    const config = new AgentExecutionTemporalConfig(
+      "agent_execution_stigmer",
+      "custom_queue",
+      ROUTING_SESSION,
+      DEFAULT_EXECUTION_TARGET_LOCAL,
+    );
+    const result = await resolveActivityTaskQueue(store, "", config, "", silentLogger);
+    expect(result.taskQueue).toBe("custom_queue");
+  });
+});
+
+describe("resolveActivityTaskQueue — execution target", () => {
+  it("session with LOCAL target returns LOCAL in result", async () => {
+    const store = newStore();
+    await saveSession(store, "ses_local", Harness.NATIVE, ExecutionTarget.LOCAL);
+    const result = await resolveActivityTaskQueue(
+      store,
+      "ses_local",
+      sessionConfig(),
+      "",
+      silentLogger,
+    );
+    expect(result.executionTarget).toBe(ExecutionTarget.LOCAL);
+  });
+
+  it("session with CLOUD target returns CLOUD in result", async () => {
+    const store = newStore();
+    await saveSession(store, "ses_cloud", Harness.NATIVE, ExecutionTarget.CLOUD);
+    const result = await resolveActivityTaskQueue(
+      store,
+      "ses_cloud",
+      sessionConfig(),
+      "",
+      silentLogger,
+    );
+    expect(result.executionTarget).toBe(ExecutionTarget.CLOUD);
+  });
+
+  it("session with UNSPECIFIED target resolves based on config", async () => {
+    const store = newStore();
+    await saveSession(store, "ses_unspecified", Harness.NATIVE);
+    const result = await resolveActivityTaskQueue(
+      store,
+      "ses_unspecified",
+      cloudConfig(),
+      "",
+      silentLogger,
+    );
+    expect(result.executionTarget, "CLOUD from config default").toBe(ExecutionTarget.CLOUD);
+  });
+
+  it("activity_task_queue override routes to the parent workflow sandbox", async () => {
+    const store = newStore();
+    const sessionId = "ses_override_test";
+    await saveSession(store, sessionId, Harness.CURSOR);
+    const override = "wfexec:wfx_parent_abc123";
+    const result = await resolveActivityTaskQueue(
+      store,
+      sessionId,
+      sessionConfig(),
+      override,
+      silentLogger,
+    );
+    expect(result.taskQueue).toBe(override);
+    expect(result.harness, "the session's harness still resolves").toBe(Harness.CURSOR);
+    expect(result.executionTarget, "LOCAL — no provisioning needed").toBe(ExecutionTarget.LOCAL);
+  });
+
+  it("activity_task_queue override with no session still works", async () => {
+    const store = newStore();
+    const override = "wfexec:wfx_no_session";
+    const result = await resolveActivityTaskQueue(
+      store,
+      "",
+      cloudConfig(),
+      override,
+      silentLogger,
+    );
+    expect(result.taskQueue).toBe(override);
+    expect(result.harness, "default NATIVE harness").toBe(Harness.NATIVE);
+    expect(result.executionTarget, "LOCAL — sandbox already exists").toBe(ExecutionTarget.LOCAL);
+  });
+
+  it("surfaces non-NotFound store failures with the pinned dispatch message", async () => {
+    const store = newStore();
+    await store.close();
+    // The message text is contract: the create step maps it VERBATIM to
+    // FailedPrecondition (Go's ResolveActivityTaskQueue boundary).
+    await expect(
+      resolveActivityTaskQueue(store, "ses_any", sessionConfig(), "", silentLogger),
+    ).rejects.toThrow(/^failed to load session for dispatch: /);
+  });
+
+  it("empty override falls through to normal routing", async () => {
+    const store = newStore();
+    const sessionId = "ses_no_override";
+    await saveSession(store, sessionId, Harness.NATIVE);
+    const result = await resolveActivityTaskQueue(
+      store,
+      sessionId,
+      sessionConfig(),
+      "",
+      silentLogger,
+    );
+    expect(result.taskQueue).toBe(formatSessionTaskQueue(sessionId));
+  });
+});
+
+describe("AgentExecutionTemporalConfig.resolveExecutionTarget", () => {
+  it.each([
+    ["LOCAL passes through", ExecutionTarget.LOCAL, globalConfig(), ExecutionTarget.LOCAL],
+    ["CLOUD passes through", ExecutionTarget.CLOUD, globalConfig(), ExecutionTarget.CLOUD],
+    [
+      "UNSPECIFIED resolves to LOCAL when default is local",
+      ExecutionTarget.UNSPECIFIED,
+      sessionConfig(),
+      ExecutionTarget.LOCAL,
+    ],
+    [
+      "UNSPECIFIED resolves to CLOUD when default is cloud",
+      ExecutionTarget.UNSPECIFIED,
+      cloudConfig(),
+      ExecutionTarget.CLOUD,
+    ],
+  ] as const)("%s", (_name, target, config, want) => {
+    expect(config.resolveExecutionTarget(target)).toBe(want);
+  });
+});