@stigmer/runner 3.15.1 → 3.15.2-dev.20260913223433

package/src/harness/__tests__/mount-skills.test.ts

@@ -0,0 +1,169 @@
+/**
+ * Pins the skills phase (`turn-context.ts` `mountSkills`) as the runtime's
+ * one reader of skills for EVERY owner: the root's merged refs and each
+ * sub-agent's own, resolved through one resolver into `TurnSkills`.
+ *
+ * What is asserted: the shape (root vs a map keyed by sub-agent name; no
+ * entry for a sub-agent without refs), that a skill the root and a sub-agent
+ * share is fetched per owner but MOUNTED once (the hash-keyed mount marker,
+ * so the second write is a cache hit), that one owner's failing ref costs
+ * that owner alone (the root's skills stand; the sub-agent gets what
+ * resolved), and that a harness without sub-agents (`capabilities.subAgents`
+ * false) resolves the root only — the flag's first reader. The phase reports
+ * its one label, so the runtime's label list is unchanged.
+ *
+ * The control-plane client is doubled at its module boundary with scripted
+ * skills; `HOME` is the hermetic environment's, so the mounts land under a
+ * temp platform dir and nothing touches the developer's `~/.stigmer`.
+ */
+
+import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { create } from "@bufbuild/protobuf";
+import { AgentExecutionStatusSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
+import { SubAgentSchema } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/spec_pb";
+import { SkillSchema, type Skill } from "@stigmer/protos/ai/stigmer/agentic/skill/v1/api_pb";
+import { ApiResourceReferenceSchema, type ApiResourceReference } from "@stigmer/protos/ai/stigmer/commons/apiresource/io_pb";
+
+import { createHermeticEnvironment } from "../../__test-utils__/hermetic-activity.js";
+import { mockStigmerClient } from "../../__test-utils__/mock-client.js";
+import { testConfig } from "../../__test-utils__/config-fixture.js";
+import { turnInputFixture } from "../../__test-utils__/turn-input-fixture.js";
+import { TimingRecorder } from "../../shared/cold-start-timing.js";
+import { mountSkills, type ResolutionDeps } from "../turn-context.js";
+
+const env = createHermeticEnvironment();
+
+function ref(slug: string): ApiResourceReference {
+  return create(ApiResourceReferenceSchema, { slug, org: "kit-org" });
+}
+
+function skill(slug: string): Skill {
+  return create(SkillSchema, {
+    metadata: { id: `skill-${slug}`, slug, org: "kit-org" },
+    spec: { name: slug, description: `The ${slug} skill`, skillMd: `# ${slug}` },
+    status: { versionHash: `hash-${slug}` },
+  });
+}
+
+/** A client that answers the scripted skills by slug and refuses the rest; every fetch is counted. */
+function skillClient(available: readonly string[]) {
+  const fetches: string[] = [];
+  const client = mockStigmerClient({
+    getSkillByReference: vi.fn(async (r: ApiResourceReference) => {
+      fetches.push(r.slug);
+      if (!available.includes(r.slug)) throw new Error(`skill ${r.slug} not found`);
+      return skill(r.slug);
+    }),
+  });
+  return { client, fetches };
+}
+
+function depsWith(client: ResolutionDeps["client"], sessionId: string): { deps: ResolutionDeps; labels: string[] } {
+  const labels: string[] = [];
+  return {
+    labels,
+    deps: {
+      input: { executionId: `aex-${sessionId}`, threadId: "", turnSeq: 0 },
+      client,
+      config: testConfig({ workspaceRootDir: env.workspaceRootDir }),
+      status: create(AgentExecutionStatusSchema, {}),
+      artifactStorage: undefined,
+      timing: new TimingRecorder(),
+      signal: new AbortController().signal,
+      heartbeat: () => {},
+      enterPhase: () => {},
+      reportProgress: async (label) => {
+        labels.push(label);
+      },
+    },
+  };
+}
+
+function blueprintWith(rootRefs: readonly string[], subAgents: ReadonlyArray<{ name: string; refs: readonly string[] }>) {
+  return turnInputFixture({
+    blueprint: {
+      mergedSkillRefs: rootRefs.map(ref),
+      subAgents: subAgents.map((sa) => create(SubAgentSchema, { name: sa.name, skillRefs: sa.refs.map(ref) })),
+    },
+  }).blueprint;
+}
+
+describe("mountSkills: the runtime resolves every owner's skills", () => {
+  let n = 0;
+  let sessionId: string;
+  let primaryDir: string;
+
+  beforeAll(() => {
+    mkdirSync(env.workspaceRootDir, { recursive: true });
+  });
+  beforeEach(() => {
+    sessionId = `ses-skills-${++n}`;
+    primaryDir = join(env.workspaceRootDir, sessionId);
+    mkdirSync(primaryDir, { recursive: true });
+  });
+  afterAll(() => {
+    env.dispose();
+  });
+
+  it("resolves the root's merged refs and each sub-agent's own, keyed by the sub-agent's name; a sub-agent without refs has no entry", async () => {
+    const { client } = skillClient(["alpha", "beta", "gamma"]);
+    const { deps, labels } = depsWith(client, sessionId);
+    const skills = await mountSkills(deps, {
+      blueprint: blueprintWith(["alpha"], [{ name: "researcher", refs: ["beta", "gamma"] }, { name: "writer", refs: [] }]),
+      sessionId,
+      primaryDir,
+      subAgents: true,
+    });
+    expect(skills.root.map((s) => s.name)).toEqual(["alpha"]);
+    expect([...skills.bySubAgent.keys()]).toEqual(["researcher"]);
+    expect(skills.bySubAgent.get("researcher")!.map((s) => s.name)).toEqual(["beta", "gamma"]);
+    expect(skills.bySubAgent.get("researcher")![0]!.path, "a sub-agent's skill mounts where the root's do").toBe(".stigmer/skills/beta/SKILL.md");
+    expect(labels, "one label for the whole phase").toEqual(["Resolving skills"]);
+  });
+
+  it("a skill the root and a sub-agent share is fetched per owner but mounted once (the second resolution is a mount-cache hit)", async () => {
+    const { client, fetches } = skillClient(["shared"]);
+    const { deps } = depsWith(client, sessionId);
+    const writes = vi.spyOn(await import("../../shared/skill-mount.js"), "writeSkillMount");
+    const skills = await mountSkills(deps, {
+      blueprint: blueprintWith(["shared"], [{ name: "researcher", refs: ["shared"] }]),
+      sessionId,
+      primaryDir,
+      subAgents: true,
+    });
+    expect(skills.root.map((s) => s.name)).toEqual(["shared"]);
+    expect(skills.bySubAgent.get("researcher")!.map((s) => s.name)).toEqual(["shared"]);
+    expect(fetches, "the control plane is asked once per owner").toEqual(["shared", "shared"]);
+    expect(writes, "the mount is written once; the second owner hits the hash-keyed marker").toHaveBeenCalledTimes(1);
+    writes.mockRestore();
+  });
+
+  it("one owner's failing ref costs that owner alone: the root's skills stand and the sub-agent gets what resolved", async () => {
+    const { client } = skillClient(["alpha", "beta"]);
+    const { deps } = depsWith(client, sessionId);
+    const skills = await mountSkills(deps, {
+      blueprint: blueprintWith(["alpha"], [{ name: "researcher", refs: ["missing", "beta"] }]),
+      sessionId,
+      primaryDir,
+      subAgents: true,
+    });
+    expect(skills.root.map((s) => s.name)).toEqual(["alpha"]);
+    expect(skills.bySubAgent.get("researcher")!.map((s) => s.name), "warned and skipped, never thrown").toEqual(["beta"]);
+  });
+
+  it("a harness without sub-agents resolves the root only: no sub-agent ref is fetched", async () => {
+    const { client, fetches } = skillClient(["alpha", "beta"]);
+    const { deps } = depsWith(client, sessionId);
+    const skills = await mountSkills(deps, {
+      blueprint: blueprintWith(["alpha"], [{ name: "researcher", refs: ["beta"] }]),
+      sessionId,
+      primaryDir,
+      subAgents: false,
+    });
+    expect(skills.root.map((s) => s.name)).toEqual(["alpha"]);
+    expect(skills.bySubAgent.size).toBe(0);
+    expect(fetches).toEqual(["alpha"]);
+  });
+});

package/src/harness/__tests__/persist-chokepoint.test.ts

@@ -10,9 +10,11 @@ import { create } from "@bufbuild/protobuf";
 import { AgentExecutionStatusSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
 import { UpdateStatusResponseSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/io_pb";
 import { AgentMessageSchema, ToolCallSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/message_pb";
-import { ExecutionControlSignal, MessageType, ServiceTier, ThinkingMode, ToolCallStatus } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import { ExecutionControlSignal, FileChangeKind, MessageType, ServiceTier, ThinkingMode, ToolCallStatus } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 
 import type { StigmerClient } from "../../client/stigmer-client.js";
+import type { TurnProgress } from "../capture.js";
+import { newProgressCaptureState, type ProgressSubstrate } from "../../shared/filereview/progress.js";
 import { PersistChokepoint } from "../persist-chokepoint.js";
 import { UsageAccumulator } from "../usage-accumulator.js";
 
@@ -43,7 +45,10 @@ function heldClient(answers: ExecutionControlSignal[] = []) {
   return { client, gates, writes };
 }
 
-function chokepointOver(client: StigmerClient, options: { usage?: UsageAccumulator; onPlatformStop?: () => void } = {}) {
+function chokepointOver(
+  client: StigmerClient,
+  options: { usage?: UsageAccumulator; progress?: TurnProgress; onPlatformStop?: () => void } = {},
+) {
   const status = create(AgentExecutionStatusSchema, {});
   const heartbeat = vi.fn();
   const onPlatformStop = options.onPlatformStop ?? vi.fn();
@@ -53,6 +58,7 @@ function chokepointOver(client: StigmerClient, options: { usage?: UsageAccumulat
     status,
     offload: undefined,
     usage: () => options.usage,
+    progress: () => options.progress,
     heartbeat,
     onPlatformStop,
   });
@@ -90,6 +96,36 @@ describe("PersistChokepoint: one write", () => {
     expect(onPlatformStop).toHaveBeenCalledTimes(1);
   });
 
+  it("refreshes file_change_progress from the turn's capture before the write, and re-attaches only when the tree moved", async () => {
+    const { client, gates } = heldClient();
+    const captures: boolean[] = [true, false];
+    const substrate: ProgressSubstrate = {
+      capture: async () => ({
+        delta: { entries: [{ pathBefore: "a.md", pathAfter: "a.md", kind: FileChangeKind.MODIFY, linesAdded: 2, linesRemoved: 0 }] },
+        changed: captures.shift() ?? false,
+      }),
+    };
+    const { chokepoint, status } = chokepointOver(client, {
+      progress: { changeSetId: "aex_test:0", substrate, state: newProgressCaptureState() },
+    });
+
+    const first = chokepoint.write();
+    await vi.waitFor(() => expect(gates).toHaveLength(1));
+    expect(status.fileChangeProgress?.changeSetId, "attached before the bytes leave").toBe("aex_test:0");
+    expect(status.fileChangeProgress?.linesAdded).toBe(2);
+    const attachedAt = status.fileChangeProgress?.capturedAt;
+    gates[0]!.open();
+    await first;
+
+    // The floor (2 s) has not elapsed for the second write: no capture, the
+    // snapshot stands; a capture that reports `changed: false` would stand too.
+    const second = chokepoint.write();
+    await vi.waitFor(() => expect(gates).toHaveLength(2));
+    expect(status.fileChangeProgress?.capturedAt).toBe(attachedAt);
+    gates[1]!.open();
+    await second;
+  });
+
   it("writes no streaming_usage when no turn was reported", async () => {
     const { client, gates } = heldClient();
     const { chokepoint, status } = chokepointOver(client, { usage: new UsageAccumulator() });

package/src/harness/__tests__/run-turn-deterministic.test.ts

@@ -0,0 +1,94 @@
+/**
+ * The turn runtime under a DETERMINISTIC state id, proven without any engine:
+ * the scripted fake adapter declaring `stateIdSource: "deterministic"` (the
+ * native harness's posture — `thread-{sessionId}` exists before any engine
+ * does) through the kit's runtime-side half under `MockActivityEnvironment`.
+ *
+ * `run-turn.test.ts` runs the same half under `engine-minted`; this file is
+ * the other arm of `isReinvocation` (`turn-context.ts`): here the thread id
+ * is present on the FIRST turn, so the runtime's reinvocation fact — the
+ * seed, the reconcile, the exact-apply — must come from the persisted
+ * transcript and from nothing else. Every kit arm that resumes (the approval
+ * round trip) therefore exercises that arm end to end, and the bind arm is
+ * reported SKIPPED (a deterministic harness never binds).
+ *
+ * What is asserted HERE beside the kit are the deterministic FACTS the
+ * engine-minted file cannot show: no session write ever happens (there is
+ * no id to bind), and a first turn with a thread id already present is
+ * still a first turn (nothing seeded, no decision read).
+ *
+ * Its own file, not a second block in `run-turn.test.ts`: the hermetic
+ * environment is created at module level because the subject's `config` is
+ * read at collection time, and the forks pool keeps each file's environment
+ * private.
+ */
+
+import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
+import { ExecutionPhase } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+
+vi.mock("../../client/stigmer-client.js", async () =>
+  (await import("../../__test-utils__/hermetic-activity.js")).hermeticStigmerClientModule(),
+);
+
+import { ScriptedClock, createHermeticEnvironment } from "../../__test-utils__/hermetic-activity.js";
+import { stubRegistryFetch } from "../../__test-utils__/model-registry-fixture.js";
+import { scriptedSubject } from "../../__test-utils__/harness-contract/scripted-adapter.js";
+import {
+  assertApprovalRoundTrip,
+  assertCompletedTurn,
+  describeHarnessRuntimeContract,
+  type RuntimeContractHarness,
+} from "../../__test-utils__/harness-contract/runtime-contract.js";
+
+const TASK_QUEUE = "runtime-deterministic-test-queue";
+
+const env = createHermeticEnvironment();
+const clock = new ScriptedClock();
+const subject = scriptedSubject({
+  pausePrimitive: "interrupt",
+  stateIdSource: "deterministic",
+  config: { workspaceRootDir: env.workspaceRootDir, taskQueue: TASK_QUEUE },
+});
+const harness: RuntimeContractHarness = { subject, env, clock };
+
+describe("run-turn: the deterministic fake adapter through the real runtime", () => {
+  let registry: ReturnType<typeof stubRegistryFetch>;
+
+  beforeAll(() => {
+    registry = stubRegistryFetch();
+    clock.install();
+  });
+
+  afterAll(() => {
+    clock.uninstall();
+    registry.restore();
+    env.dispose();
+  });
+
+  describeHarnessRuntimeContract(harness);
+
+  describe("the deterministic facts", () => {
+    beforeAll(async () => {
+      await subject.adapter.boot(subject.config);
+    });
+
+    it("a first turn with the thread id already present is a first turn: nothing seeded, no session write", async () => {
+      clock.reset();
+      const { driver, final } = await assertCompletedTurn(harness, "det-completed");
+      expect(driver.record.persistedPhases).toEqual([ExecutionPhase.EXECUTION_IN_PROGRESS, ExecutionPhase.EXECUTION_COMPLETED]);
+      expect(driver.record.sessionUpdates, "a deterministic harness never binds a state id").toHaveLength(0);
+      expect(final.messages.length, "the transcript is this turn's alone").toBeGreaterThan(0);
+    });
+
+    it("the approval round trip resumes on the transcript, not the thread id: the WAITING row is carried and settled, and no session write happens", async () => {
+      clock.reset();
+      const { driver } = await assertApprovalRoundTrip(harness, "det-approval");
+      expect(driver.record.persistedPhases).toEqual([
+        ExecutionPhase.EXECUTION_WAITING_FOR_APPROVAL,
+        ExecutionPhase.EXECUTION_IN_PROGRESS,
+        ExecutionPhase.EXECUTION_COMPLETED,
+      ]);
+      expect(driver.record.sessionUpdates).toHaveLength(0);
+    });
+  });
+});

package/src/harness/__tests__/run-turn.test.ts

@@ -38,24 +38,25 @@ vi.mock("../../client/stigmer-client.js", async () =>
 import { ScriptedClock, createHermeticEnvironment } from "../../__test-utils__/hermetic-activity.js";
 import { stubRegistryFetch } from "../../__test-utils__/model-registry-fixture.js";
 import { scriptedSubject } from "../../__test-utils__/harness-contract/scripted-adapter.js";
+import { initGitWorkspace } from "../../__test-utils__/git-workspace-fixture.js";
+import { scenario } from "../../__test-utils__/harness-contract/types.js";
 import {
   COST_CAP_FAKE_PRICE_USD,
   FAILURE_MESSAGES,
-  NEVER_SEEN,
   RUNTIME_SETUP_LABELS,
-  RuntimeExecutionDriver,
   aiMessages,
   assertApprovalRoundTrip,
   assertCompletedTurn,
   assertCostCapTerminates,
   assertFailedSurfaceWritesItsCopy,
+  assertNonExecutingDecisionSettlesSkipped,
   assertRejectedBindFails,
   describeHarnessRuntimeContract,
+  RuntimeExecutionDriver,
   slimOf,
   systemMessages,
   type RuntimeContractHarness,
 } from "../../__test-utils__/harness-contract/runtime-contract.js";
-import { scenario } from "../../__test-utils__/harness-contract/types.js";
 import { TERMINAL_COPY } from "../terminal-table.js";
 
 const TASK_QUEUE = "runtime-test-queue";
@@ -137,29 +138,44 @@ describe("run-turn: the fake adapter through the real runtime", () => {
       expect(aiMessages(final)).toEqual([]);
     });
 
-    it("REJECT of an irreversible action settles the reinvocation FAILED before any engine runs (today's runtime; see F1)", async () => {
-      // The runtime fails a reinvocation that carries any REJECT
-      // (`decideReinvocation`, moved from Cursor's orchestrator). The proto
-      // contract as of #197 — the enum doc, the conformance suite, the native
-      // harness's `reconcileNonExecutingDecisions` — says REJECT denies the
-      // tool and the run continues with the row SKIPPED. This arm pins the
-      // runtime AS IT IS so the S3 change is a visible diff, and is
-      // deliberately NOT in the kit (S2 M4 finding F1, Q-M4-1).
+    it("REJECT continues the run without the tool and the row settles SKIPPED with its reason (stigmer#197; S3 M1, Q-S3-2)", async () => {
+      // Until S3 M1 this arm pinned the opposite: the runtime FAILED a
+      // reinvocation carrying any REJECT (`rejectedByUserArm`, Cursor's
+      // legacy), against the proto's `APPROVAL_ACTION_REJECT` doc, the
+      // conformance suite and the native harness (S2 M4 finding F1, Q-M4-1).
+      // The kit's runtime half now carries the contract for every subject;
+      // what is the fake's own here is the persist cadence around it.
       clock.reset();
-      const driver = new RuntimeExecutionDriver(harness, "fake-reject");
-      const propose = scenario.propose("call-runtime-reject", { kind: "shell", resource: "rm -rf build" });
+      const { driver, final } = await assertNonExecutingDecisionSettlesSkipped(harness, ApprovalAction.REJECT, "fake-reject");
+      expect(driver.record.persistedPhases).toEqual([
+        ExecutionPhase.EXECUTION_WAITING_FOR_APPROVAL,
+        ExecutionPhase.EXECUTION_IN_PROGRESS,
+        ExecutionPhase.EXECUTION_COMPLETED,
+      ]);
+      expect(aiMessages(final)).toContain("Moving on.");
+      expect(systemMessages(final), "no terminal copy: the run ended normally").toEqual([]);
+    });
 
-      const first = await driver.turn([propose]);
+    it("structured output on a file-review-pending turn is resolved before the pause and rides the reconcile's completion (Q-M4-8)", async () => {
+      clock.reset();
+      const driver = new RuntimeExecutionDriver(harness, "fake-review-structured", {
+        structuredOutputSchema: { type: "object", properties: { answer: { type: "number" } }, required: ["answer"] },
+      });
+      initGitWorkspace(driver.workspaceDir, { "README.md": "# kit\n" });
+
+      // The engine edits a file and answers in JSON (tier 1 extracts it; no
+      // LLM is asked), then the runtime pauses for the review.
+      const first = await driver.turn([scenario.flowingWrite("fake-review-structured-w", "answer.md"), scenario.say('{"answer": 42}')]);
       expect(slimOf(subject, first).phase).toBe("EXECUTION_WAITING_FOR_APPROVAL");
-      driver.decide(ApprovalAction.REJECT);
-
-      const second = await driver.turn([scenario.say(NEVER_SEEN)]);
-      expect(slimOf(subject, second).phase).toBe("EXECUTION_FAILED");
-      const final = driver.record.lastFullStatus!;
-      expect(final.error).toBe(TERMINAL_COPY.rejectedByUser.error);
-      expect(systemMessages(final).at(-1)).toBe(TERMINAL_COPY.rejectedByUser.row);
-      expect(final.completedAt).not.toBe("");
-      expect(aiMessages(final)).not.toContain(NEVER_SEEN);
+      expect(driver.record.lastFullStatus?.structuredOutput, "resolved before the WAITING persist").toEqual({ answer: 42 });
+
+      clock.tick();
+      driver.record.decideCapturedFileChanges({ approve: ["answer.md"] }, new Date().toISOString());
+      const second = await driver.turn([]);
+      const slim = slimOf(subject, second);
+      expect(slim.phase).toBe("EXECUTION_COMPLETED");
+      expect(slim.structured, "the pure-reconcile completion carries the answer as a value").toEqual({ answer: 42 });
+      expect(slim.final_text).toBe('{"answer": 42}');
     });
   });
 });

package/src/harness/__tests__/turn-attachments-vision.test.ts

@@ -0,0 +1,80 @@
+/**
+ * Pins which model the attachment phase asks the registry about when it
+ * sizes the vision budget (`turn-context.ts` `resolveTurnAttachments`): the
+ * model the execution named, or the registry's default when it named none —
+ * the model the native harness will build in that case. Before S3 M1 the
+ * phase asked about the raw executionConfig name, so an execution with no
+ * model named asked about `""` (always "unknown", read as sighted) while the
+ * native orchestrator asked about the resolved default (its `setup.ts`,
+ * retired with it).
+ *
+ * The registry module is doubled at its boundary: this test is about WHICH
+ * name is asked, not about the registry's answer. The phase is entered with
+ * no attachments so nothing touches the file system; the budget's decisions
+ * over real images are `shared/__tests__/attachment-vision.test.ts`'s.
+ */
+
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { create } from "@bufbuild/protobuf";
+import { AgentExecutionStatusSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
+import { AgentExecutionSpecSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/spec_pb";
+
+vi.mock("../../shared/model-registry.js", () => ({
+  getDefaultModel: vi.fn(async () => "registry-default-model"),
+  getModelVisionCapability: vi.fn(async () => true),
+}));
+
+import { getDefaultModel, getModelVisionCapability } from "../../shared/model-registry.js";
+import { DEEP_AGENT_VISION_PROFILE } from "../../shared/attachment-vision.js";
+import { TimingRecorder } from "../../shared/cold-start-timing.js";
+import { mockStigmerClient } from "../../__test-utils__/mock-client.js";
+import { testConfig } from "../../__test-utils__/config-fixture.js";
+import { resolveTurnAttachments, type ResolutionDeps } from "../turn-context.js";
+
+function deps(): ResolutionDeps {
+  return {
+    input: { executionId: "aex_1", threadId: "", turnSeq: 0 },
+    client: mockStigmerClient(),
+    config: testConfig(),
+    status: create(AgentExecutionStatusSchema, {}),
+    artifactStorage: undefined,
+    timing: new TimingRecorder(),
+    signal: new AbortController().signal,
+    heartbeat: () => {},
+    enterPhase: () => {},
+    reportProgress: async () => {},
+  };
+}
+
+async function resolveWithModel(modelName: string | undefined): Promise<void> {
+  await resolveTurnAttachments(deps(), {
+    spec: create(AgentExecutionSpecSchema, modelName === undefined ? {} : { executionConfig: { modelName } }),
+    sessionId: "ses_1",
+    primaryDir: "/nowhere",
+    visionProfile: DEEP_AGENT_VISION_PROFILE,
+  });
+}
+
+describe("resolveTurnAttachments: the model the vision budget asks about", () => {
+  beforeEach(() => {
+    vi.mocked(getDefaultModel).mockClear();
+    vi.mocked(getModelVisionCapability).mockClear();
+  });
+
+  it("asks about the model the execution named, without consulting the default", async () => {
+    await resolveWithModel("claude-haiku-4.5");
+    expect(vi.mocked(getModelVisionCapability)).toHaveBeenCalledWith("claude-haiku-4.5");
+    expect(vi.mocked(getDefaultModel)).not.toHaveBeenCalled();
+  });
+
+  it("asks about the registry's default when the execution named none — the model the turn will run on, not the empty string", async () => {
+    await resolveWithModel(undefined);
+    expect(vi.mocked(getDefaultModel)).toHaveBeenCalledTimes(1);
+    expect(vi.mocked(getModelVisionCapability)).toHaveBeenCalledWith("registry-default-model");
+  });
+
+  it("treats an empty model name as none", async () => {
+    await resolveWithModel("");
+    expect(vi.mocked(getModelVisionCapability)).toHaveBeenCalledWith("registry-default-model");
+  });
+});