@jskit-ai/assistant-core 0.1.226 → 0.1.228

package/src/shared/conversation/longTextBlocks.js

@@ -209,10 +209,6 @@ function parsePipeTableAt(lines = [], startIndex = 0) {
   if (!headers || !alignments || headers.length !== alignments.length) {
     return null;
   }
-  if (!headers.some((header) => header)) {
-    return null;
-  }
-
   const rows = [];
   let rowIndex = startIndex + 2;
   while (rowIndex < lines.length) {

package/test/assistantScroll.browser.test.js

@@ -716,6 +716,42 @@ test("working state appears before output and suggestion agents and activity ren
 });
 
 
+test("long goal objectives keep Start reachable on short phone, tablet and desktop screens", {
+  skip: !RUN_BROWSER_TEST,
+  timeout: 60_000
+}, async () => {
+  const vite = await startViteFixture({ fixtureRoot: FIXTURE_ROOT });
+  const browser = await chromium.launch(createChromiumLaunchOptions());
+  try {
+    const objective = "Complete the requested work and verify the result. ".repeat(80).slice(0, 3990);
+    for (const width of [390, 800, 1280]) {
+      const page = await browser.newPage({ viewport: { width, height: 578 } });
+      await page.goto(`${vite.baseURL}/?conversation=1&goal=1`);
+      await page.getByRole("button", { name: "Set goal", exact: true }).click();
+      await page.getByRole("textbox", { name: "Goal objective" }).fill(objective);
+      const start = page.getByRole("button", { name: "Start goal", exact: true });
+      await expect(start).toBeInViewport();
+      await expect.poll(() => start.evaluate(element => {
+        const bounds = element.getBoundingClientRect();
+        return bounds.top >= 0 && bounds.bottom <= innerHeight &&
+          element.contains(document.elementFromPoint(bounds.x + bounds.width / 2, bounds.y + bounds.height / 2));
+      })).toBe(true);
+      assert.ok(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth));
+      await page.screenshot({ path: `/tmp/jskit-goal-long-objective-${width}.png` });
+      await start.click();
+      const running = page.getByRole("button", { name: "Goal running", exact: true });
+      await expect(running).toHaveAttribute("aria-expanded", "false");
+      await running.click();
+      await expect(page.locator(".assistant-goal__details").getByText(objective, { exact: true })).toHaveText(objective);
+      await expect(page.getByRole("button", { name: "Pause goal", exact: true })).toBeInViewport();
+      await page.close();
+    }
+  } finally {
+    await browser.close();
+    await stopProcess(vite);
+  }
+});
+
 test("optional goals show running and paused lights, count only active time, and adapt to pane width", {
   skip: !RUN_BROWSER_TEST,
   timeout: 60_000
@@ -733,13 +769,20 @@ test("optional goals show running and paused lights, count only active time, and
     await page.getByRole("textbox", { name: "Goal objective" }).fill("Complete the shared assistant.");
     await page.getByRole("spinbutton", { name: "Token budget (optional)" }).fill("10000");
     await page.getByRole("button", { name: "Start goal", exact: true }).click();
-    await expect(page.getByText("Complete the shared assistant.", { exact: true })).toBeVisible();
+    await page.clock.runFor(250);
+    await expect(page.getByRole("button", { name: "Goal running", exact: true })).toHaveAttribute("aria-expanded", "false");
+    await expect(page.getByRole("textbox", { name: "Goal objective" })).toBeHidden();
     await input.click();
     await input.fill("Preserve this draft and caret");
     await input.evaluate(element => element.setSelectionRange(5, 9));
     const light = page.locator(".assistant-goal__light");
     await expect(light).toHaveCSS("background-color", "rgb(211, 47, 47)");
     await expect(light).toHaveCSS("animation-name", /^assistant-goal-flash/u);
+    await page.getByRole("button", { name: "External idle", exact: true }).evaluate(element => element.click());
+    await expect(light).toHaveCSS("animation-name", "none");
+    await expect(light).toHaveCSS("background-color", "rgb(211, 47, 47)");
+    await page.getByRole("button", { name: "External active", exact: true }).evaluate(element => element.click());
+    await expect(light).toHaveCSS("animation-name", /^assistant-goal-flash/u);
     const elapsed = page.locator(".assistant-goal__elapsed");
     await page.clock.fastForward(65_000);
     await expect(elapsed).toHaveText("1:05");
@@ -766,6 +809,23 @@ test("optional goals show running and paused lights, count only active time, and
     await page.getByRole("button", { name: "Goal running", exact: true }).click();
     await page.clock.runFor(250);
     await expect(page.getByText("Running time: 1:10", { exact: true })).toBeVisible();
+    await input.click();
+    await page.clock.runFor(250);
+    await page.setViewportSize({ width: 1280, height: 577 });
+    await page.getByRole("button", { name: "Block goal with long explanation", exact: true }).click();
+    await expect(light).toHaveCSS("animation-name", "none");
+    await page.getByRole("button", { name: "Goal blocked", exact: true }).click();
+    await page.clock.runFor(250);
+    for (const name of ["Pause goal", "Resume goal", "Cancel goal"]) {
+      const button = page.getByRole("button", { name, exact: true });
+      await expect(button).toBeInViewport();
+      const bounds = await button.boundingBox();
+      assert.ok(bounds.y >= 0 && bounds.y + bounds.height <= 577, `${name} is fully visible without scrolling`);
+    }
+    await page.getByRole("button", { name: "Pause goal", exact: true }).click();
+    await expect(page.getByRole("button", { name: "Goal paused", exact: true })).toBeVisible();
+    await page.getByRole("button", { name: "Resume goal", exact: true }).click();
+    await expect(page.getByRole("button", { name: "Pause goal", exact: true })).toBeVisible();
     await page.getByRole("button", { name: "Toggle goals" }).evaluate(element => element.click());
     await expect(page.locator(".assistant-goal")).toHaveCount(0);
     await expect(page.getByRole("button", { name: "Pause goal", exact: true })).toBeHidden();
@@ -868,6 +928,7 @@ test("an optional avatar clamps in a short conversation without consuming its pr
       };
       assert.equal(Math.round((await panel.boundingBox()).width), 320);
       assert.equal(Math.round((await panel.boundingBox()).height), 420);
+      await expect(artwork).toHaveCSS("contain", "layout paint");
       await expect.poll(async () => (await artwork.boundingBox()).height).toBeGreaterThan(64);
       assert.ok((await artwork.boundingBox()).height <= 96, "Compact artwork preserves the existing short-container clamp");
       await page.getByRole("button", { name: "Resize height", exact: true }).evaluate(element => element.click());
@@ -1160,6 +1221,7 @@ test("connection warnings keep avatar controls and Reload reachable without repl
     for (const width of [320, 800]) {
       const page = await browser.newPage({ viewport: { width, height: 1000 } });
       await page.goto(`${vite.baseURL}/?conversation=1&avatar=1&avatarTools=1&update-errors=1`);
+      await page.locator(".fixture").evaluate(element => { element.style.width = "100%"; });
       const external = name => page.getByRole("button", { name, exact: true }).evaluate(element => element.click());
       await external("Resize height");
       const conversation = page.locator(".assistant-conversation");
@@ -1179,14 +1241,25 @@ test("connection warnings keep avatar controls and Reload reachable without repl
       let reloads = 0;
       for (const size of ["standard", "large", "hidden"]) {
         await page.getByRole("combobox", { name: "Avatar preference", exact: true }).selectOption(size);
+        // Establish the reading position after changing the fixture-only avatar preference.
+        await body.evaluate(element => { element.scrollTop = 420; });
+        await expect.poll(() => body.evaluate(element => element.scrollTop)).toBe(420);
         await external("Show update error");
         await expect(conversation).toHaveClass(/assistant-conversation--error/u);
-        await expect(avatar).toHaveCSS("position", "relative");
+        await expect(avatar).toHaveCSS("position", "absolute");
         await expect(banner).toContainText("Conversation updates are temporarily unavailable.");
         await expect(reload).toBeVisible();
         const avatarBox = await avatar.boundingBox();
         const bannerBox = await banner.boundingBox();
-        assert.ok(avatarBox.y + avatarBox.height <= bannerBox.y, "The entire avatar and its controls stay above the warning");
+        assert.ok(avatarBox.y >= bannerBox.y + bannerBox.height - 1, "The compact warning stays above the overlaid avatar");
+        const transcriptBox = await page.locator(".assistant-transcript").boundingBox();
+        assert.ok(bannerBox.y < transcriptBox.y + 12, "Avatar height cannot push the warning below the top of chat");
+        assert.ok(bannerBox.width >= transcriptBox.width - 20, "Warning spans the chat width across the avatar area");
+        const wordsBox = await banner.locator(".assistant-transcript__error-content > span").boundingBox();
+        const reloadBox = await reload.boundingBox();
+        assert.ok(reloadBox.x + reloadBox.width <= wordsBox.x, "Reload stays left of the status text");
+        if (size === "standard") await page.screenshot({ path: `/tmp/sas25-connection-${width}.png` });
+        assert.ok(bannerBox.height < (width === 320 ? 150 : 75), `The row wraps compactly instead of reserving avatar height: width=${width}, height=${bannerBox.height}`);
         const controls = size === "hidden"
           ? [page.getByRole("button", { name: "Retained avatar control", exact: true }), page.getByRole("button", { name: "Show avatar", exact: true })]
           : [page.getByRole("button", { name: "Avatar tool", exact: true }), page.getByRole("button", { name: "Minimise avatar", exact: true })];

package/test/claudeClient.test.js

@@ -32,6 +32,47 @@ function fakeStream(onWrite) {
   } });
 }
 
+test("Claude initialization diagnostics distinguish a held write from its matched response without affecting completion", async t => {
+  for (const responseFirst of [false, true]) await t.test(`response first: ${responseFirst}`, async () => {
+    const entered = Promise.withResolvers();
+    let finishWrite;
+    const stages = [];
+    const stream = new Duplex({ read() {}, write(chunk, _encoding, callback) {
+      finishWrite = () => { finishWrite = undefined; callback(); };
+      entered.resolve(JSON.parse(String(chunk)));
+    } });
+    const client = createClaudeJsonClient({ stream });
+    let settled = false;
+    const initialization = client.initialize({}, { onProgress(stage) {
+      stages.push(stage);
+      throw new Error("Diagnostic observer failed");
+    } }).then(result => { settled = true; return result; });
+    try {
+      const frame = await entered.promise;
+      assert.deepEqual(stages, ["requested"]);
+      const reply = requestId => stream.push(`${JSON.stringify({ type: "control_response", response: {
+        subtype: "success", request_id: requestId, response: { privateValue: "secret" }
+      } })}\n`);
+      reply("unmatched");
+      await new Promise(resolve => setImmediate(resolve));
+      assert.deepEqual(stages, ["requested"]);
+      if (responseFirst) reply(frame.request_id);
+      else finishWrite();
+      await new Promise(resolve => setImmediate(resolve));
+      assert.deepEqual(stages, ["requested", responseFirst ? "response_received" : "written"]);
+      assert.equal(settled, false, "both the write and matching response remain required");
+      if (responseFirst) finishWrite();
+      else reply(frame.request_id);
+      assert.deepEqual(await initialization, { privateValue: "secret" });
+      assert.deepEqual(stages, ["requested", ...(responseFirst ? ["response_received", "written"] : ["written", "response_received"])]);
+    } finally {
+      finishWrite?.();
+      client.close();
+      await client.completion;
+    }
+  });
+});
+
 test("Claude controls correlate out-of-order replies and events apply backpressure", async () => {
   const requests = [];
   const observed = [];
@@ -228,3 +269,35 @@ test("unregistered headless controls are denied and repeated active control IDs
   second.close();
   await second.completion;
 });
+
+test("Claude targeted Send now writes its named input first and preserves ordinary Stop", async () => {
+  const writes = [];
+  const stream = fakeStream((frame, socket) => {
+    writes.push(frame);
+    if (frame.type === "control_request") socket.push(`${JSON.stringify({ type: "control_response", response: {
+      subtype: "success", request_id: frame.request_id, response: { send_now: "delivering", still_queued: ["follow-up"] }
+    } })}\n`);
+  });
+  const client = createClaudeJsonClient({ stream });
+  try {
+    assert.equal(client.supportsSendNow(), false);
+    stream.push(`${JSON.stringify({ type: "system", subtype: "init", capabilities: ["interrupt_send_now_v1"] })}\n`);
+    await new Promise(resolve => setImmediate(resolve));
+    assert.equal(client.supportsSendNow(), true);
+    await client.send("New instruction", { messageId: "follow-up", sessionId: "session", sendNow: true });
+    assert.deepEqual(writes.map(frame => frame.type), ["user", "control_request"]);
+    assert.deepEqual(writes[1].request, { subtype: "interrupt", send_now: true, message_uuid: "follow-up" });
+    await client.interrupt();
+    assert.deepEqual(writes.at(-1).request, { subtype: "interrupt" }, "Explicit Stop is still a Stop");
+  } finally { client.close(); }
+});
+
+test("Claude never sends an unsupported Send now that an older CLI would interpret as Stop", async () => {
+  const writes = [];
+  const stream = fakeStream(frame => writes.push(frame));
+  const client = createClaudeJsonClient({ stream });
+  try {
+    await assert.rejects(client.send("Keep workers", { sendNow: true }), /does not support.*Send now/);
+    assert.equal(writes.length, 0, "Capability failure precedes both input and control writes");
+  } finally { client.close(); }
+});

package/test/claudeConversationSession.test.js

@@ -72,6 +72,20 @@ test("Claude exposes the durable native identity before dispatch and respects a
   } finally { await provider.dispose(); }
 });
 
+test("Claude rejects a finished-turn steer before admission and permits the same ordinary message once", async t => {
+  const f = await fixture(t);
+  await f.conversation.send(input);
+  await f.conversation.wait();
+  const next = { messageId: "late-steer", text: "Keep working", steer: true };
+  await assert.rejects(f.conversation.send(next), { code: "conversation_steer_turn_finished", delivery: "not-sent" });
+  assert.equal((await f.trace()).filter(row => row.frame?.type === "user").length, 1);
+  const { steer, ...ordinary } = next;
+  await f.conversation.send(ordinary);
+  await f.conversation.wait();
+  await f.conversation.send(ordinary);
+  assert.equal((await f.trace()).filter(row => row.frame?.type === "user").length, 2);
+});
+
 test("native Claude coding tools require the server-side host grant", async t => {
   const f = await fixture(t, { nativeTools: true });
   await f.conversation.send(input);
@@ -358,7 +372,7 @@ async function fixture(t, options = {}) {
   function runtime() {
     const value = createConversationRuntime({ engine: "claude", storage, authorize: options.authorize || (() => true), actions: options.actions,
       connections: options.connections, attachments: options.attachments, persistCommentary: options.persistCommentary,
-      host: { workdir: directory, env, commands: { claude: command }, execution: options.execution, nativeTools: options.nativeTools, commandWrapper: options.commandWrapper },
+      host: { workdir: directory, env, commands: { claude: command }, allowAccountChange: options.allowAccountChange, execution: options.execution, nativeTools: options.nativeTools, commandWrapper: options.commandWrapper },
       limits: { admissionTimeoutMs: 150, ...options.limits } });
     runtimes.push(value);
     return value;
@@ -367,7 +381,7 @@ async function fixture(t, options = {}) {
   const conversation = await first.open({ id: "conversation", configuration: options.configuration || configuration, context: options.context });
   return { directory, storage, account, runtime, first, conversation,
     driverOptions: { connections: options.connections,
-      host: { workdir: directory, env, commands: { claude: command }, execution: options.execution, nativeTools: options.nativeTools, commandWrapper: options.commandWrapper },
+      host: { workdir: directory, env, commands: { claude: command }, allowAccountChange: options.allowAccountChange, execution: options.execution, nativeTools: options.nativeTools, commandWrapper: options.commandWrapper },
       limits: { admissionTimeoutMs: 150, ...options.limits } },
     async trace() { return (await readFile(trace, "utf8")).trim().split("\n").map(line => JSON.parse(line)); } };
 }
@@ -487,6 +501,10 @@ test("native Send retries inspect the durable prompt receipt before duplicate ha
   assert.equal(Object.hasOwn((await f.conversation.read()).pendingRequest, "message"), false);
   await f.first.close();
   const resumed = await f.runtime().open({ id: "conversation" });
+  const uncertain = await resumed.read();
+  assert.equal(uncertain.status, "unconfirmed");
+  assert.equal(uncertain.pendingRequest.messageId, request.messageId);
+  assert.match(uncertain.error, /previous submission was interrupted/);
   assert.equal((await resumed.send(request)).status, "accepted");
   const recovered = await resumed.wait();
   assert.equal(recovered.status, "ready");
@@ -496,6 +514,33 @@ test("native Send retries inspect the durable prompt receipt before duplicate ha
   assert.equal((await resumed.send(request)).duplicate, true);
 });
 
+test("reopening an undispatched Claude reservation does not invent an uncertain-delivery warning", async t => {
+  const f = await fixture(t, { environment: { TEST_REJECT_EFFORT: "low" } });
+  await f.conversation.configure({ effort: "low" });
+  const request = { messageId: "never-dispatched", text: "Keep this original request", origin: "application" };
+  await assert.rejects(f.conversation.send(request), /Settings rejected/);
+  await f.conversation.wait();
+  const readRequest = () => f.storage.read("conversation", async tx => (await tx.readMetadata()).runtime.request);
+  const saved = await readRequest();
+  assert.equal(saved.attempted, false);
+  assert.equal((await f.trace()).filter(row => row.frame?.type === "user").length, 0);
+  await f.first.close();
+  const resumed = await f.runtime().open({ id: "conversation" });
+  const state = await resumed.read();
+  assert.equal(state.status, "ready");
+  assert.equal(state.pendingRequest, null);
+  assert.equal(state.error, "");
+  assert.equal(state.conversationLog.length, 0);
+  assert.deepEqual(await readRequest(), { ...saved,
+    error: "The previous submission was interrupted. Check delivery before submitting it again." },
+  "Projection must retain the original reservation, including its dispatch evidence");
+  await resumed.configure({ effort: "high" });
+  await resumed.send(request);
+  await resumed.wait();
+  assert.equal((await f.trace()).filter(row => row.frame?.type === "user").length, 1,
+    "Only an explicit send dispatches the retained request");
+});
+
 test("native changeover keeps the prepared prompt frozen across rejection, transcript edits and retry", async t => {
   const f = await fixture(t, { environment: { TEST_REJECT_EFFORT: "low" } });
   await f.conversation.send(input);
@@ -593,6 +638,9 @@ test("cancel drains native work and allows a subsequent request in the same conv
   assert.equal((await f.conversation.read()).status, "working");
   assert.deepEqual(await f.conversation.cancel(), { stopped: true });
   assert.equal((await f.conversation.read()).conversationLog[0].metadata.runtime.status, "cancelled");
+  await assert.rejects(f.conversation.send({ messageId: "late-after-stop", text: "Do more", steer: true }), {
+    code: "conversation_not_steerable", delivery: "not-sent"
+  });
   const binding = await f.storage.read("conversation", async tx => (await tx.readMetadata()).runtime.binding);
   assert.equal(binding.executionId, "");
   await f.conversation.send(input);
@@ -759,6 +807,53 @@ test("changed native login cannot continue another account's conversation", asyn
   assert.equal((await f.conversation.read()).conversationLog.length, 1);
 });
 
+test("workspace-authorized Claude account changes retire the old process and resume native history", async t => {
+  const f = await fixture(t, { allowAccountChange: true });
+  await f.conversation.send(input);
+  await f.conversation.wait();
+  const before = await f.storage.read("conversation", async tx => (await tx.readMetadata()).runtime.binding);
+  await writeFile(f.account, "different@example.test");
+  await f.conversation.send({ messageId: "second", text: "Continue with the current account" });
+  const state = await f.conversation.wait();
+  const after = await f.storage.read("conversation", async tx => (await tx.readMetadata()).runtime.binding);
+  const starts = (await f.trace()).filter(row => row.args?.includes("--print"));
+  assert.equal(starts.length, 2, "The old account's process cannot be reused");
+  assert.equal(starts[1].args[starts[1].args.indexOf("--resume") + 1], before.conversationId);
+  assert.equal(after.conversationId, before.conversationId);
+  assert.notEqual(after.accountIdentity, before.accountIdentity);
+  assert.equal(state.conversationLog.length, 2);
+  assert.equal(state.conversationLog[0].assistant.text, "Answer: Hello");
+  assert.equal(state.conversationLog[1].assistant.text, "Answer: Continue with the current account");
+});
+
+test("workspace-authorized Claude account changes cannot promote an account before verified stop", async t => {
+  const local = createLocalConversationExecution();
+  const nativeIds = new Set();
+  let allowStop = true;
+  const execution = {
+    async start(options) {
+      const native = await local.start(options);
+      if (options.args.includes("--print")) nativeIds.add(native.id);
+      return native;
+    },
+    stop: id => !allowStop && nativeIds.has(id) ? Promise.resolve({ scopeEmpty: false }) : local.stop(id)
+  };
+  const f = await fixture(t, { execution, allowAccountChange: true });
+  await f.conversation.send(input);
+  await f.conversation.wait();
+  const before = await f.storage.read("conversation", async tx => (await tx.readMetadata()).runtime.binding);
+  await writeFile(f.account, "different@example.test");
+  allowStop = false;
+  try {
+    await assert.rejects(f.conversation.send({ messageId: "second", text: "Continue" }), /cleanup could not be confirmed/);
+    assert.deepEqual(await f.storage.read("conversation", async tx => (await tx.readMetadata()).runtime.binding), before);
+    assert.equal((await f.trace()).filter(row => row.frame?.type === "user").length, 1);
+  } finally { allowStop = true; }
+  assert.deepEqual(await f.conversation.cancel(), { stopped: true });
+  await f.conversation.send({ messageId: "second", text: "Continue" });
+  assert.equal((await f.conversation.wait()).conversationLog[1].assistant.text, "Answer: Continue");
+});
+
 // Ported from the production provider's control-order case. The common fixture
 // observes native JSON controls instead of the application's provider wrapper.
 test("Claude changes provider controls before model and keeps the native conversation", async t => {
@@ -1081,8 +1176,15 @@ test("Claude accepts a goal during an active turn through the existing steering
 test("Claude rejects reserved goals and waits for ordinary Send to deliver a replacement briefing", async t => {
   const f = await fixture(t);
   let state = await f.conversation.read();
-  await assert.rejects(f.conversation.updateGoal({ action: "set", objective: "clear", messageId: "reserved",
-    expectedSegmentId: state.segmentId }), /goal condition/u);
+  for (const objective of ["clear", "stop", "off", "reset", "none", "cancel"]) {
+    await assert.rejects(f.conversation.updateGoal({ action: "set", objective, messageId: `reserved-${objective}`,
+      expectedSegmentId: state.segmentId }), {
+      code: "conversation_invalid_goal", statusCode: 400, delivery: "not-sent"
+    });
+  }
+  assert.equal((await f.trace()).filter(row => row.frame?.type === "user").length, 0,
+    "reserved conditions are rejected before native dispatch, not uncertain sends");
+  assert.equal((await f.conversation.read()).conversationLog.length, 0);
   await f.conversation.send(input);
   state = await f.conversation.wait();
   await f.conversation.replace({ operationId: "renew-goal", reason: "renewal", expectedSegmentId: state.segmentId });
@@ -1806,6 +1908,20 @@ test("completed Claude external account changes refuse repeatedly without finger
   } finally { await f.close(); }
 });
 
+test("workspace-authorized account adoption never rebinds a completed Claude receipt", async t => {
+  const f = await completedEnvelopeFixture(t, { allowAccountChange: true });
+  try {
+    const receipt = await f.complete();
+    const before = await f.storage.read("conversation", async tx => (await tx.readMetadata()).runtime.binding);
+    await writeFile(f.account, "different@example.test");
+    for (let attempt = 0; attempt < 2; attempt++) {
+      await assert.rejects(f.prepare(receipt), /different account or provider connection/);
+      assert.deepEqual(await f.storage.read("conversation", async tx => (await tx.readMetadata()).runtime.binding), before);
+    }
+    assert.equal(f.effects(), 0);
+  } finally { await f.close(); }
+});
+
 test("completed Claude account inspection never creates a missing historical fingerprint", async t => {
   const f = await completedEnvelopeFixture(t);
   try {

package/test/claudeProcess.test.js

@@ -303,6 +303,42 @@ test("Claude observes parent exit after initialization even while a child retain
   assert.equal(failures, 1);
 });
 
+test("Claude host startup budget allows slow initialization and still bounds failed startup", async t => {
+  t.mock.timers.enable({ apis: ["setTimeout"] });
+  const { PassThrough, Writable } = await import("node:stream");
+  for (const responds of [true, false]) {
+    const requested = Promise.withResolvers();
+    const stdout = new PassThrough();
+    const stdin = new Writable({ write(chunk, _encoding, done) {
+      requested.resolve(JSON.parse(chunk.toString())); done();
+    } });
+    const stops = [];
+    const pending = createClaudeCodeProcess({ initializationTimeoutMs: 90_000, execution: {
+      async start() { return { id: "cold-start", stdin, stdout }; },
+      async stop(id) { stops.push(id); return { scopeEmpty: true }; }
+    } });
+    let settled = false;
+    void pending.then(() => { settled = true; }, () => { settled = true; });
+    const frame = await requested.promise;
+    t.mock.timers.tick(45_000);
+    await new Promise(resolve => setImmediate(resolve));
+    assert.equal(settled, false, "Cold initialization survives the ordinary control deadline");
+    if (responds) {
+      stdout.write(JSON.stringify({ type: "control_response", response: {
+        subtype: "success", request_id: frame.request_id, response: {}
+      } }) + "\n");
+      await (await pending).stop();
+    } else {
+      const rejected = assert.rejects(pending, error =>
+        error.code === "assistant_claude_control_timeout" && error.stopProof.scopeEmpty === true);
+      t.mock.timers.tick(45_000);
+      await rejected;
+    }
+    assert.deepEqual(stops, ["cold-start"]);
+    stdout.destroy(); stdin.destroy();
+  }
+});
+
 test("Claude initialization rejects confirmed execution exit before half-open protocol EOF", async () => {
   const { PassThrough, Writable } = await import("node:stream");
   for (const cleanup of ["verified", "unconfirmed", "rejected"]) {
@@ -440,6 +476,31 @@ test("Claude account queries isolate concurrent identities and deduplicate each
   }
 });
 
+test("Claude account queries label temporary startup without changing cached process reuse", async () => {
+  const starts = [];
+  let stops = 0;
+  const queries = createClaudeAccountQueries({
+    accountIdentity: async () => "private-account-identity",
+    createProcess(input) {
+      starts.push(input);
+      return {
+        initialization: { models: [] },
+        client: { request: async () => ({ rate_limits_available: false }) },
+        async stop() { stops++; return { scopeEmpty: true }; }
+      };
+    }
+  });
+  for (const method of ["readCatalogue", "readPlanUsage"]) {
+    await queries[method]({});
+    await queries[method]({});
+  }
+  assert.deepEqual(starts.map(input => input.purpose), ["catalogue", "usage"]);
+  assert.ok(starts.every(input => input.signal instanceof AbortSignal));
+  assert.ok(starts.every(input => Object.keys(input).sort().join() === "purpose,signal"));
+  assert.equal(stops, 2);
+  await queries.invalidate();
+});
+
 test("account invalidation cancels held startup and usage without stopping a borrowed conversation", async () => {
   for (const phase of ["startup", "owned usage", "borrowed usage"]) {
     const started = Promise.withResolvers();