@jskit-ai/assistant-core 0.2.46 → 0.2.48

package/CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## Unreleased
 
+- A Claude goal's running time no longer counts the time a server was stopped mid-turn. When Claude starts again after a request that was cut off, it saves a "No response requested." placeholder just before the goal continues, and the history reader counted the wait up to that placeholder as work: a restart in the middle of a turn added the whole downtime to the goal's clock. The wait before that placeholder now counts like the wait before an authored message; the cut-off request's unsaved part is not counted.
+- `AssistantGoalControl`'s chip says why a goal stopped in a few words, so it no longer runs across the message box: a goal stopped at its AI account's usage limit reads **Goal paused: usage limit**, or **Goal paused: no credit** when it is out of credit, with the orange paused light, instead of "Waiting: AI usage limit, resets at Wed 09:00" or "Out of credit: top up or switch AI account". Its details say what happened, when the limit resets and what to do. `jskit.assistant.goal.usageLimitedUntil` is replaced by `jskit.assistant.goal.usageLimitedUntilHint`, and `jskit.assistant.goal.outOfCreditHint` is new; `usageLimited`, `outOfCredit` and `usageLimitedHint` are reworded.
 - The Claude engine keeps an application tool result within its tool set's raised `maxToolResultBytes` whole. Claude Code saves an MCP tool result past 50,000 characters, or past its MCP output token cap, to a file and shows the model only a preview, which a tool-free conversation cannot read: a 128 KiB result reached the model as its first 2 KB. A tool set whose result limit is above the default 48 KiB now starts Claude with `MAX_MCP_OUTPUT_TOKENS` at that limit plus 1 KiB, and its application tools declare that many characters as their `anthropic/maxResultSizeChars` (Claude Code allows at most 500,000); a character and a token each cover at least one byte of the result. At the default limit Claude keeps its own. `createClaudeCodeProcess` takes `maximumToolResultBytes`, and conversation tools give engines `maximumResultBytes` beside `maximumArgumentBytes`.
 - A hand-written tool catalogue whose tool sets carry no `limits` keeps the default limits (32 KiB of arguments, 48 KiB of result) instead of every turn with its tools failing with "Cannot read properties of undefined (reading 'maxToolArgumentBytes')". `createServiceToolCatalog`'s module exports `DEFAULT_MAX_TOOL_ARGUMENT_BYTES` and `DEFAULT_MAX_TOOL_RESULT_BYTES`.
 - Each tool set `createServiceToolCatalog` resolves carries its catalogue's `limits` (`maxToolArgumentBytes` and `maxToolResultBytes`), and an application conversation's tools hold calls to that tool set's `maxToolArgumentBytes` and give engines that value as `maximumArgumentBytes`, instead of reading the catalogue's own `limits`. A catalogue that resolves each surface's tool set from a catalogue of its own, as `@jskit-ai/assistant-runtime`'s does, now has each surface's argument limit enforced; its result limit already was, by that surface's catalogue. **Breaking** for a hand-written tool catalogue passed as `toolCatalog`: its `resolveToolSet` returns `limits: { maxToolArgumentBytes }` with its tools.

package/examples/conversation/package.json

@@ -8,14 +8,14 @@
     "build": "vite build"
   },
   "dependencies": {
-    "@jskit-ai/assistant-core": "0.2.46",
-    "@jskit-ai/http-runtime": "0.2.20",
-    "@jskit-ai/kernel": "0.2.20",
+    "@jskit-ai/assistant-core": "0.2.48",
+    "@jskit-ai/http-runtime": "0.2.21",
+    "@jskit-ai/kernel": "0.2.21",
     "@jskit-ai/material-web": "0.1.5",
     "vue": "^3.5.13",
     "vuetify": "^4.0.0",
-    "@jskit-ai/connectors-core": "0.2.28",
-    "@jskit-ai/connectors-catalog": "0.2.28"
+    "@jskit-ai/connectors-core": "0.2.29",
+    "@jskit-ai/connectors-catalog": "0.2.29"
   },
   "devDependencies": {
     "@vitejs/plugin-vue": "^6.0.7",

package/fixtures/responsive-assistant/ConversationFixture.vue

@@ -188,6 +188,10 @@ const adapter = reactive({
         <button @click="goalEnabled = !goalEnabled">Toggle goals</button>
         <button v-if="goal" @click="goal = { ...goal, status: 'blocked', reason: 'An explanation of the blocker. '.repeat(200) }">Block goal with long explanation</button>
         <button v-if="goal" @click="goal = { ...goal, status: 'complete' }">Complete goal</button>
+        <button v-if="goal" @click="goal = { ...goal, status: 'usageLimited', resetsAt: Math.floor(Date.now() / 1000) + 3 * 24 * 60 * 60, outOfCredit: false }">Stop goal at usage limit</button>
+        <button v-if="goal" @click="goal = { ...goal, status: 'usageLimited', resetsAt: undefined, outOfCredit: false }">Stop goal at usage limit without reset</button>
+        <button v-if="goal" @click="goal = { ...goal, status: 'usageLimited', resetsAt: undefined, outOfCredit: true }">Stop goal out of credit</button>
+        <button v-if="goal" @click="goal = { ...goal, status: 'budgetLimited' }">Stop goal at budget</button>
         <template v-if="previewFixture">
           <button @click="temporaryWords = 'Exact temporary words'; temporaryPresent = true; temporaryEditing = false">Add temporary message</button>
           <button @click="newerWords = 'Keep newer live words'; newerPresent = true; newerEditing = false">Add newer temporary message</button>

package/locales/en.json

@@ -113,7 +113,8 @@
         "notRunning": "Goal not running",
         "notRunningHint": "Nothing is working on this goal right now. Your next message continues it.",
         "objective": "Goal objective",
-        "outOfCredit": "Out of credit: top up or switch AI account",
+        "outOfCredit": "Goal paused: no credit",
+        "outOfCreditHint": "The AI account is out of credit. The goal does not continue by itself: top up or switch AI account, then choose Resume goal.",
         "pause": "Pause goal",
         "pauseInterruptsTurn": "Pause stops the current turn and keeps the goal for later.",
         "pausePreventsTurns": "Pausing prevents further automatic turns. Use Stop to interrupt the current turn.",
@@ -128,9 +129,9 @@
         "starting": "Starting…",
         "tokenBudget": "Token budget (optional)",
         "unavailable": "Goal unavailable",
-        "usageLimited": "Waiting: AI usage limit",
-        "usageLimitedHint": "The goal does not continue by itself. Choose Resume goal once the AI account can work again.",
-        "usageLimitedUntil": "Waiting: AI usage limit, resets at {time}"
+        "usageLimited": "Goal paused: usage limit",
+        "usageLimitedHint": "The AI account reached its usage limit. The goal does not continue by itself: choose Resume goal once the AI account can work again.",
+        "usageLimitedUntilHint": "The AI account reached its usage limit, which resets at {time}. The goal does not continue by itself: choose Resume goal once it resets."
       },
       "longText": {
         "details": "Details",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/assistant-core",
-  "version": "0.2.46",
+  "version": "0.2.48",
   "type": "module",
   "scripts": {
     "test": "jskit test"
@@ -52,7 +52,7 @@
     "@ai-sdk/togetherai": "^3.0.49",
     "@ai-sdk/xai": "^4.0.58",
     "@jskit-ai/agent": "0.1.3",
-    "@jskit-ai/resource-core": "0.1.211",
+    "@jskit-ai/resource-core": "0.1.212",
     "@openrouter/ai-sdk-provider": "^3.0.0",
     "ai": "^7.0.152",
     "json-rest-schema": "^1.0.20",
@@ -60,8 +60,8 @@
     "ws": "^8.20.1"
   },
   "peerDependencies": {
-    "@jskit-ai/http-runtime": "0.2.20",
-    "@jskit-ai/kernel": "0.2.20",
+    "@jskit-ai/http-runtime": "0.2.21",
+    "@jskit-ai/kernel": "0.2.21",
     "vue": "^3.5.13",
     "vuetify": "^4.3.0"
   },

package/src/client/conversation/AssistantGoalControl.vue

@@ -22,18 +22,22 @@ const active = computed(() => goal.value?.status === "active");
 const running = computed(() => active.value && props.state.working === true);
 // A Start stays Starting… until the server's goal shows it, even while closed.
 const starting = computed(() => props.state.action === "set");
-// A goal waiting at its AI account's limit names it, with the reset time when
-// the engine reports one (with its day when that is not today).
+// A goal waiting at its AI account's limit says why in a few words; its details
+// say when the limit resets (with its day when that is not today) and what to do.
 const resetTime = computed(() => {
   if (!Number.isSafeInteger(goal.value?.resetsAt)) return "";
   const reset = new Date(goal.value.resetsAt * 1000);
   const time = `${String(reset.getHours()).padStart(2, "0")}:${String(reset.getMinutes()).padStart(2, "0")}`;
   return reset.toDateString() === new Date().toDateString() ? time : `${reset.toLocaleDateString(undefined, { weekday: "short" })} ${time}`;
 });
+const limitHint = computed(() => goal.value?.status !== "usageLimited" ? ""
+  : goal.value.outOfCredit ? t("jskit.assistant.goal.outOfCreditHint")
+    : resetTime.value ? t("jskit.assistant.goal.usageLimitedUntilHint", { time: resetTime.value }) : t("jskit.assistant.goal.usageLimitedHint"));
+// Every status label is a few words, as the chip shows it beside the message
+// box: what happened, when it continues and what to do belong in the details.
 const statusLabel = computed(() => goal.value?.status === "usageLimited" && goal.value.outOfCredit ? t("jskit.assistant.goal.outOfCredit")
-  : goal.value?.status === "usageLimited" && resetTime.value ? t("jskit.assistant.goal.usageLimitedUntil", { time: resetTime.value })
-    : active.value && !running.value ? t("jskit.assistant.goal.notRunning")
-      : t(Object.hasOwn(STATUS_KEYS, goal.value?.status ?? "") ? STATUS_KEYS[goal.value.status] : "jskit.assistant.goal.set"));
+  : active.value && !running.value ? t("jskit.assistant.goal.notRunning")
+    : t(Object.hasOwn(STATUS_KEYS, goal.value?.status ?? "") ? STATUS_KEYS[goal.value.status] : "jskit.assistant.goal.set"));
 const label = computed(() => props.state.loading ? t("jskit.assistant.goal.loading") : props.state.available === false ? t("jskit.assistant.goal.unavailable")
   : starting.value ? t("jskit.assistant.goal.starting") : statusLabel.value);
 // The clock is the time spent working on the goal: the engine's running time
@@ -89,13 +93,13 @@ async function cancelGoal() {
   <v-menu v-if="state && state.enabled !== false" v-model="open" location="top" width="360" max-width="calc(100vw - 24px)" :close-on-content-click="false">
     <template #activator="{ props: menuProps }">
       <v-btn v-bind="menuProps" class="assistant-goal" size="small" variant="text" :aria-label="label" :title="[label, elapsedText, goal?.objective].filter(Boolean).join('\n')">
-        <span v-if="goal" class="assistant-goal__light" :class="{ 'assistant-goal__light--running': running, 'assistant-goal__light--paused': goal.status === 'paused' }" aria-hidden="true" />
+        <span v-if="goal" class="assistant-goal__light" :class="{ 'assistant-goal__light--running': running, 'assistant-goal__light--paused': ['paused', 'usageLimited'].includes(goal.status) }" aria-hidden="true" />
         <span class="assistant-goal__label">{{ chipLabel }}</span>
         <span v-if="elapsed && running" class="assistant-goal__elapsed" aria-hidden="true">{{ elapsed }}</span>
       </v-btn>
     </template>
     <v-card class="assistant-goal__details pa-3">
-      <strong role="status">{{ label }}</strong>
+      <strong role="status" class="me-2">{{ label }}</strong>
       <v-btn v-if="(active || (state.pauseBlocked && ['blocked', 'usageLimited'].includes(goal?.status))) && state.pause" size="small" :disabled="state.stopPending" @click="state.pause()">{{ state.action === 'pause' ? t('jskit.assistant.goal.pausing') : t('jskit.assistant.goal.pause') }}</v-btn>
       <v-btn v-if="['paused', 'blocked', 'usageLimited'].includes(goal?.status) && state.resume" size="small" :disabled="state.pending" @click="state.resume()">{{ state.action === 'resume' ? t('jskit.assistant.goal.resuming') : t('jskit.assistant.goal.resume') }}</v-btn>
       <v-btn v-if="goal && goal.status !== 'complete' && state.cancel" color="error" size="small" variant="text" :disabled="state.stopPending" @click="cancelGoal">{{ state.action === 'cancel' ? t('jskit.assistant.goal.cancelling') : t('jskit.assistant.goal.cancel') }}</v-btn>
@@ -103,7 +107,7 @@ async function cancelGoal() {
       <p v-if="goal?.reason" class="text-body-small my-2">{{ goal.reason }}</p>
       <p v-if="elapsed" class="text-body-small my-2">{{ elapsedText }}</p>
       <p v-if="active && !running" class="text-body-small my-2">{{ t('jskit.assistant.goal.notRunningHint') }}</p>
-      <p v-if="goal?.status === 'usageLimited'" class="text-body-small mt-2">{{ t('jskit.assistant.goal.usageLimitedHint') }}</p>
+      <p v-if="limitHint" class="text-body-small mt-2">{{ limitHint }}</p>
       <p v-if="active || goal?.status === 'paused'" class="text-body-small mt-2">{{ state.pauseInterruptsTurn ? t('jskit.assistant.goal.pauseInterruptsTurn') : t('jskit.assistant.goal.pausePreventsTurns') }}</p>
       <p v-if="goal && goal.status !== 'complete' && state.cancel" class="text-body-small mt-2">{{ state.cancelInterruptsTurn ? t('jskit.assistant.goal.cancelInterruptsTurn') : t('jskit.assistant.goal.cancelRemovesGoal') }}</p>
       <form v-if="canSet" class="assistant-goal__form mt-2" @submit.prevent="setGoal">

package/src/server/conversation/claudeHistory.js

@@ -99,15 +99,20 @@ async function claudeHistoryPath({ configRoot, workdir, conversationId }) {
   return null;
 }
 
+// Claude saves this non-error synthetic carrier when it starts again after an
+// interrupted request: a stopped request, or a process that ended mid-turn. Its
+// native placeholder classifier uses this exact provenance; real model replies
+// and API errors with the same wording remain ordinary output.
+function claudeNoResponsePlaceholder(frame) {
+  const content = frame.message?.content;
+  return frame.type === "assistant" && frame.message?.model === "<synthetic>" && !frame.isApiErrorMessage &&
+    Array.isArray(content) && content.length === 1 && content[0]?.type === "text" && content[0].text === "No response requested.";
+}
+
 function claudeMessageBlocks(frame, { includeNested = false, commentary = false } = {}) {
   if (frame.type !== "assistant" || frame.parent_tool_use_id && !includeNested) return [];
   const content = frame.message?.content;
-  if (!Array.isArray(content)) return [];
-  // Claude's native placeholder classifier excludes this non-error synthetic
-  // carrier after an interrupted request. Real model replies and API errors
-  // with the same wording remain ordinary output.
-  if (frame.message.model === "<synthetic>" && !frame.isApiErrorMessage && content.length === 1 &&
-      content[0]?.type === "text" && content[0].text === "No response requested.") return [];
+  if (!Array.isArray(content) || claudeNoResponsePlaceholder(frame)) return [];
   // Native frames split one API message into blocks with distinct UUIDs.
   const messageId = frame.uuid || frame.message.id;
   if (!messageId) return [];
@@ -277,10 +282,12 @@ async function readClaudeHistory(options) {
     // Claude saves its history as it works, so the time up to each frame it
     // saves itself is the goal's running time. The wait before a message the
     // person or the host sent (between turns, while paused, or across a
-    // restart) is not.
+    // restart) is not, nor the wait before the placeholder Claude saves when it
+    // starts again after an interrupted request: that spans a stopped server.
     const at = ["user", "assistant", "attachment", "system"].includes(frame.type) ? Date.parse(frame.timestamp) / 1000 : NaN;
     if (Number.isFinite(at)) {
-      const waited = claudeAuthoredMessage(frame) || frame.type === "attachment" && commandedSentinels.has(frame.uuid);
+      const waited = claudeAuthoredMessage(frame) || claudeNoResponsePlaceholder(frame) ||
+        frame.type === "attachment" && commandedSentinels.has(frame.uuid);
       if (goal?.status === "active" && !waited && at > lastAt) goal.timeUsedSeconds += at - lastAt;
       lastAt = Number.isFinite(lastAt) ? Math.max(lastAt, at) : at;
       if (goal?.status === "active") goal.updatedAt = lastAt;

package/test/assistantGoalControlChip.test.js

@@ -9,21 +9,32 @@ import { renderToString } from "vue/server-renderer";
 const controlUrl = new URL("../src/client/conversation/AssistantGoalControl.vue", import.meta.url).href;
 const textUrl = new URL("../src/client/i18n.js", import.meta.url).href;
 
-async function importControl() {
+const TEXT_SOURCES = Object.freeze({
+  // Each text shows as its key, with any parameters.
+  keys: "export function useJskitText() { return { t: (key, params) => params ? `${key}(${Object.values(params).join(\"=\")})` : key }; }",
+  // The real English texts, as en.json words them.
+  english: `const texts = ${readFileSync(new URL("../locales/en.json", import.meta.url), "utf8")};
+export function useJskitText() {
+  return { t: (key, params = {}) => key.split(".").reduce((value, part) => value?.[part], texts)
+    .replace(/\\{(\\w+)\\}/gu, (_match, name) => String(params[name])) };
+}`
+});
+
+/** The control, compiled with its texts from one of TEXT_SOURCES. */
+async function importControl(texts = "keys") {
   const hooks = registerHooks({
     load(url, context, nextLoad) {
-      if (url === textUrl) {
-        return { format: "module", shortCircuit: true, source:
-          "export function useJskitText() { return { t: (key, params) => params ? `${key}(${Object.values(params).join(\"=\")})` : key }; }" };
-      }
-      if (url !== controlUrl) return nextLoad(url, context);
-      const { descriptor } = parse(readFileSync(new URL(url), "utf8"));
-      return { format: "module", shortCircuit: true,
-        source: compileScript(descriptor, { id: "assistant-goal-chip", inlineTemplate: true }).content };
+      const [file, query = ""] = url.split("?");
+      const source = new URLSearchParams(query).get("text");
+      if (file === textUrl && source) return { format: "module", shortCircuit: true, source: TEXT_SOURCES[source] };
+      if (file !== controlUrl || !source) return nextLoad(url, context);
+      const { descriptor } = parse(readFileSync(new URL(file), "utf8"));
+      const compiled = compileScript(descriptor, { id: "assistant-goal-chip", inlineTemplate: true }).content;
+      return { format: "module", shortCircuit: true, source: compiled.replace('from "../i18n.js"', `from "../i18n.js?text=${source}"`) };
     }
   });
   try {
-    return (await import(controlUrl)).default;
+    return (await import(`${controlUrl}?text=${texts}`)).default;
   } finally {
     hooks.deregister();
   }
@@ -71,7 +82,7 @@ test("an active goal looks running, with its clock counting on from its running
   assert.equal(running.label, "jskit.assistant.goal.goal");
   assert.match(running.chip, /<span class="assistant-goal__elapsed" aria-hidden="true">2:10:0\d<\/span>/u);
   assert.match(running.chip, /assistant-goal__light--running/u);
-  assert.match(running.panel, /role="status">jskit\.assistant\.goal\.running</u);
+  assert.match(running.panel, /role="status"[^>]*>jskit\.assistant\.goal\.running</u);
   // Between turns, or after a restart before its continuation starts, nothing
   // works on it: the chip says so, with no red light and no clock, and its
   // running time stays where the work stopped.
@@ -97,7 +108,7 @@ test("an active goal looks running, with its clock counting on from its running
   assert.equal(none.label, "jskit.assistant.goal.set");
 });
 
-test("a goal waiting at its AI account's limit names the limit and when it resets, and Resume is the person's to press", async () => {
+test("a goal stopped at its AI account's limit says so in a few words; its details say when the limit resets and what to do", async () => {
   const control = await importControl();
   const reset = new Date();
   reset.setSeconds(0, 0);
@@ -105,23 +116,68 @@ test("a goal waiting at its AI account's limit names the limit and when it reset
   const waiting = { objective: "Finish every check", status: "usageLimited", createdAt: startedTwoHoursAgo, resetsAt: reset.getTime() / 1000 };
   // Claude's goals can be paused while they wait; the chip shows no clock.
   const claude = await render(control, waiting, { pauseBlocked: true });
-  assert.equal(claude.label, `jskit.assistant.goal.usageLimitedUntil(${time})`);
-  assert.doesNotMatch(claude.chip, /assistant-goal__elapsed|assistant-goal__light--running/u);
-  assert.match(claude.panel, new RegExp(`role="status">jskit\\.assistant\\.goal\\.usageLimitedUntil\\(${time}\\)<`, "u"));
-  for (const action of ["pause", "resume", "cancel", "usageLimitedHint"]) {
+  assert.equal(claude.label, "jskit.assistant.goal.usageLimited");
+  assert.doesNotMatch(claude.chip, /assistant-goal__elapsed|assistant-goal__light--running|usageLimitedUntilHint/u);
+  assert.match(claude.chip, /assistant-goal__light--paused/u, "a goal stopped at its limit shows the paused light");
+  assert.match(claude.panel, /role="status"[^>]*>jskit\.assistant\.goal\.usageLimited</u);
+  assert.match(claude.panel, new RegExp(`jskit\\.assistant\\.goal\\.usageLimitedUntilHint\\(${time}\\)<`, "u"));
+  for (const action of ["pause", "resume", "cancel"]) {
     assert.match(claude.panel, new RegExp(`jskit\\.assistant\\.goal\\.${action}<`, "u"), `a waiting Claude goal offers ${action}`);
   }
   // Codex refuses Pause while it waits, so its control offers only Resume and Cancel.
   const codex = await render(control, waiting);
   assert.doesNotMatch(codex.panel, /jskit\.assistant\.goal\.pause</u);
   assert.match(codex.panel, /jskit\.assistant\.goal\.resume</u);
-  // A reset on another day names its day.
+  // A reset on another day names its day, in the details.
   const later = await render(control, { ...waiting, resetsAt: waiting.resetsAt + 3 * 24 * 60 * 60 });
-  assert.equal(later.label, `jskit.assistant.goal.usageLimitedUntil(${new Date((waiting.resetsAt + 3 * 24 * 60 * 60) * 1000)
-    .toLocaleDateString(undefined, { weekday: "short" })} ${time})`);
-  // Without a reset time it waits for the person; out of credit says what to do.
-  assert.equal((await render(control, { ...waiting, resetsAt: undefined })).label, "jskit.assistant.goal.usageLimited");
+  assert.equal(later.label, "jskit.assistant.goal.usageLimited");
+  assert.match(later.panel, new RegExp(`usageLimitedUntilHint\\(${new Date((waiting.resetsAt + 3 * 24 * 60 * 60) * 1000)
+    .toLocaleDateString(undefined, { weekday: "short" })} ${time}\\)<`, "u"));
+  // Without a reset time it waits for the person; out of credit says what to do, in the details.
+  const unknown = await render(control, { ...waiting, resetsAt: undefined });
+  assert.equal(unknown.label, "jskit.assistant.goal.usageLimited");
+  assert.match(unknown.panel, /jskit\.assistant\.goal\.usageLimitedHint</u);
   const credit = await render(control, { ...waiting, resetsAt: undefined, outOfCredit: true }, { pauseBlocked: true });
   assert.equal(credit.label, "jskit.assistant.goal.outOfCredit");
+  assert.match(credit.panel, /jskit\.assistant\.goal\.outOfCreditHint</u);
   assert.match(credit.panel, /jskit\.assistant\.goal\.resume</u);
 });
+
+// The chip sits beside the message box, on a phone too: each of its labels is a
+// few words, and anything longer (why, until when, what to do) is in the details.
+const CHIP_LABEL_MAX_CHARACTERS = 24;
+
+test("every goal chip label is a few words, while the details explain a stop in full", async () => {
+  const control = await importControl("english");
+  const reset = Math.floor(Date.now() / 1000) + 3 * 24 * 60 * 60;
+  const goal = { objective: "Finish every check. ".repeat(40), createdAt: startedTwoHoursAgo, ...worked };
+  const states = [
+    ["no goal", null, {}],
+    ["loading", null, { loading: true }],
+    ["unavailable", null, { available: false, error: "The goal could not be read. Wait for the assistant connection and try again." }],
+    ["starting", null, { action: "set" }],
+    ["running", { ...goal, status: "active" }, { working: true }],
+    ["not running after an error", { ...goal, status: "active" }, { error: "Goal continuation after restart failed: the AI is busy. Vibe64 tries again shortly." }],
+    ["paused", { ...goal, status: "paused" }, {}],
+    ["blocked", { ...goal, status: "blocked", reason: "An explanation of the blocker. ".repeat(40) }, {}],
+    ["at its usage limit", { ...goal, status: "usageLimited", resetsAt: reset }, { pauseBlocked: true }],
+    ["at its usage limit with no reset time", { ...goal, status: "usageLimited" }, { pauseBlocked: true }],
+    ["out of credit", { ...goal, status: "usageLimited", outOfCredit: true }, { pauseBlocked: true }],
+    ["at its token budget", { ...goal, status: "budgetLimited" }, {}],
+    ["complete", { ...goal, status: "complete" }, {}]
+  ];
+  for (const [name, value, state] of states) {
+    const { chip, label, panel } = await render(control, value, state);
+    assert.ok(label.length <= CHIP_LABEL_MAX_CHARACTERS, `a goal ${name} has a short chip label, not "${label}"`);
+    // The chip's visible text (its tooltip may say more).
+    const shown = chip.replace(/<[^>]*>/gu, " ").replace(/\s+/gu, " ").trim();
+    assert.doesNotMatch(shown, /Finish every check|explanation of the blocker|tries again|could not be read/u, `a goal ${name} keeps its text out of the chip`);
+    if (state.error) assert.match(panel, /role="alert"/u, `a goal ${name} shows its error in the details`);
+  }
+  const limited = await render(control, { ...goal, status: "usageLimited", resetsAt: reset }, { pauseBlocked: true });
+  assert.equal(limited.label, "Goal paused: usage limit");
+  assert.match(limited.panel, /The AI account reached its usage limit, which resets at [^.]+\. The goal does not continue by itself: choose Resume goal once it resets\./u);
+  const credit = await render(control, { ...goal, status: "usageLimited", outOfCredit: true }, { pauseBlocked: true });
+  assert.equal(credit.label, "Goal paused: no credit");
+  assert.match(credit.panel, /The AI account is out of credit\. The goal does not continue by itself: top up or switch AI account, then choose Resume goal\./u);
+});

package/test/assistantScroll.browser.test.js

@@ -1028,6 +1028,57 @@ test("optional goals show running, not running and paused lights, count only wor
 });
 
 
+test("a stopped goal's chip says why in a few words on one line, at desktop and phone widths, and its details explain the stop", {
+  skip: !RUN_BROWSER_TEST,
+  timeout: 60_000
+}, async (t) => {
+  const { vite, browser } = await openFixture(t);
+  try {
+    for (const width of [1280, 390]) {
+      const page = await browser.newPage({ viewport: { width, height: 844 } });
+      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("Complete the shared assistant.");
+      await page.getByRole("button", { name: "Start goal", exact: true }).click();
+      await expect(page.getByRole("button", { name: "Goal running", exact: true })).toHaveAttribute("aria-expanded", "false");
+      for (const [stop, chipText, details] of [
+        ["Stop goal at usage limit", "Goal paused: usage limit",
+          /The AI account reached its usage limit, which resets at \S+ \d\d:\d\d\. The goal does not continue by itself/u],
+        ["Stop goal at usage limit without reset", "Goal paused: usage limit", /The AI account reached its usage limit\. The goal does not continue by itself/u],
+        ["Stop goal out of credit", "Goal paused: no credit", /The AI account is out of credit\. The goal does not continue by itself: top up or switch AI account/u],
+        ["Stop goal at budget", "Goal budget reached", /Complete the shared assistant\./u],
+        ["Block goal with long explanation", "Goal blocked", /An explanation of the blocker\./u]
+      ]) {
+        await page.getByRole("button", { name: stop, exact: true }).evaluate(element => element.click());
+        const chip = page.getByRole("button", { name: chipText, exact: true });
+        await expect(chip.locator(".assistant-goal__label")).toHaveText(chipText);
+        // One line, shown whole (no ellipsis), inside the conversation's width.
+        const fit = () => chip.evaluate(element => {
+          const label = element.querySelector(".assistant-goal__label");
+          const lines = document.createRange();
+          lines.selectNodeContents(label);
+          const pane = element.closest(".assistant-conversation") || document.body;
+          return { lines: new Set(Array.from(lines.getClientRects(), rect => Math.round(rect.top))).size,
+            whole: label.scrollWidth <= label.clientWidth, inside: element.getBoundingClientRect().right <= pane.getBoundingClientRect().right + 0.5 };
+        });
+        await expect.poll(fit).toEqual({ lines: 1, whole: true, inside: true }).catch(async failure => {
+          failure.message += `\n${stop} at ${width} px: ${JSON.stringify(await fit())}`;
+          throw failure;
+        });
+        await chip.click();
+        const panel = page.locator(".assistant-goal__details");
+        await expect(panel.getByRole("status")).toHaveText(chipText);
+        await expect(panel).toContainText(details);
+        await page.keyboard.press("Escape");
+        await expect(panel).toBeHidden();
+      }
+      await page.close();
+    }
+  } finally {
+    await browser.close();
+  }
+});
+
 test("shared model choices and file delivery preserve a responsive composer", {
   skip: !RUN_BROWSER_TEST,
   timeout: 60_000

package/test/claudeTurn.test.js

@@ -150,6 +150,9 @@ function claudeGoalFrames(condition) {
     local(`${prefix}-set`, `${prefix}-command`, seconds + 0.003, condition, `Goal set: ${condition}`),
     { type: "user", uuid: `${prefix}-meta`, parentUuid: `${prefix}-set`, timestamp: at(seconds + 0.004), isMeta: true, message: { role: "user", content: "Work on the goal." } }];
   return { at, set, answer, attachment, command, local, sentinel,
+    // Claude 2.1.322 saves this when it starts again after a request a restart cut off.
+    placeholder: (uuid, parentUuid, seconds) => ({ type: "assistant", uuid, parentUuid, timestamp: at(seconds), isApiErrorMessage: false,
+      message: { id: `api-${uuid}`, model: "<synthetic>", role: "assistant", content: [{ type: "text", text: "No response requested." }] } }),
     toolUse: (uuid, parentUuid, seconds) => answer(uuid, parentUuid, seconds, [{ type: "tool_use", id: `tool-${uuid}`, name: "Bash", input: { command: "npm test" } }]),
     toolResult: (uuid, parentUuid, seconds) => ({ type: "user", uuid, parentUuid, timestamp: at(seconds),
       message: { role: "user", content: [{ type: "tool_result", tool_use_id: `tool-${parentUuid}`, content: "ok" }] }, toolUseResult: { stdout: "ok" } }),
@@ -215,8 +218,10 @@ test("a Claude goal's running time counts only the time Claude spent working, ca
   assert.equal(Math.round(goal.timeUsedSeconds), 100);
   assert.equal(goal.updatedAt, Date.parse(f.at(3600)) / 1000, "its running time is current as of the latest history");
   await append(f.answer("next-answer", "next", 3630));
-  // The server stopped mid-turn; its restart sends the goal again an hour later. That gap does not count.
-  await append(f.toolUse("cut", "next-answer", 3640), f.set("restart", "cut", 7200), f.answer("restart-answer", "restart-meta", 7260));
+  // The server stopped mid-turn; its restart sends the goal again an hour later. That gap does not
+  // count, though Claude saves its no-response placeholder for the cut-off request just before.
+  await append(f.toolUse("cut", "next-answer", 3640), f.placeholder("cut-placeholder", "cut", 7199.7),
+    f.set("restart", "cut-placeholder", 7200), f.answer("restart-answer", "restart-meta", 7260));
   assert.equal(Math.round((await read()).timeUsedSeconds), 100 + 40 + 60);
   // Compacting the context is work, and timestamps running backwards subtract nothing.
   await append(f.compaction("restart-answer", 7300), f.answer("compacted", "credential", 7320));