@jskit-ai/assistant-core 0.2.41 → 0.2.43

package/examples/conversation/package.json

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

package/locales/en.json

@@ -112,6 +112,7 @@
         "goal": "Goal",
         "loading": "Loading goal…",
         "objective": "Goal objective",
+        "outOfCredit": "Out of credit: top up or switch AI account",
         "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.",
@@ -126,7 +127,9 @@
         "starting": "Starting…",
         "tokenBudget": "Token budget (optional)",
         "unavailable": "Goal unavailable",
-        "usageLimited": "Goal waiting for allowance"
+        "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}"
       },
       "longText": {
         "details": "Details",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/assistant-core",
-  "version": "0.2.41",
+  "version": "0.2.43",
   "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.210",
+    "@jskit-ai/resource-core": "0.1.211",
     "@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.19",
-    "@jskit-ai/kernel": "0.2.19",
+    "@jskit-ai/http-runtime": "0.2.20",
+    "@jskit-ai/kernel": "0.2.20",
     "vue": "^3.5.13",
     "vuetify": "^4.3.0"
   },

package/src/client/conversation/AssistantGoalControl.vue

@@ -20,9 +20,19 @@ const running = computed(() => goal.value?.status === "active");
 const working = computed(() => running.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");
-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")
+// 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).
+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 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 })
     : 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);
 const nativeElapsed = computed(() => Number.isFinite(goal.value?.elapsedSeconds));
 const createdAt = computed(() => typeof goal.value?.createdAt === "string" ? Date.parse(goal.value.createdAt) : NaN);
 const elapsedLabel = computed(() => nativeElapsed.value ? t("jskit.assistant.goal.runningTime") : t("jskit.assistant.goal.elapsedSinceStart"));
@@ -45,6 +55,11 @@ const elapsed = computed(() => {
   const minutes = Math.floor(total / 60);
   return minutes < 60 ? `${minutes}:${seconds}` : `${Math.floor(minutes / 60)}:${String(minutes % 60).padStart(2, "0")}:${seconds}`;
 });
+// The chip says plainly when a goal is not running (paused, blocked or waiting)
+// and shows its clock only while it runs; the details keep the elapsed time.
+const WAITING_STATUSES = Object.freeze(["paused", "blocked", "usageLimited", "budgetLimited"]);
+const chipLabel = computed(() => props.state.loading || props.state.available === false || starting.value ||
+  WAITING_STATUSES.includes(goal.value?.status) ? label.value : t(goal.value ? "jskit.assistant.goal.goal" : "jskit.assistant.goal.set"));
 // readable-check: allow method-probe - optional operation: a goal state without set() does not allow starting a goal, so Start stays disabled
 const canSet = computed(() => !props.state.loading && props.state.available !== false && typeof props.state.set === "function" && (!goal.value || goal.value.status === "complete"));
 const validBudget = computed(() => props.state.tokenBudgetSupported === false || tokenBudget.value === "" || (Number.isSafeInteger(Number(tokenBudget.value)) && Number(tokenBudget.value) > 0));
@@ -75,18 +90,19 @@ async function cancelGoal() {
     <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--working': working, 'assistant-goal__light--paused': goal.status === 'paused' }" aria-hidden="true" />
-        <span class="assistant-goal__label">{{ state.loading ? t('jskit.assistant.goal.loading') : state.available === false ? t('jskit.assistant.goal.unavailable') : starting ? t('jskit.assistant.goal.starting') : goal ? t('jskit.assistant.goal.goal') : t('jskit.assistant.goal.set') }}</span>
-        <span v-if="elapsed && goal.status !== 'complete'" class="assistant-goal__elapsed" aria-hidden="true">{{ elapsed }}</span>
+        <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" max-width="360">
       <strong role="status">{{ label }}</strong>
-      <v-btn v-if="(running || (state.pauseBlocked && goal?.status === 'blocked')) && 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="(running || (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>
       <p v-if="goal" class="my-2">{{ goal.objective }}</p>
       <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="goal?.status === 'usageLimited'" class="text-body-small mt-2">{{ t('jskit.assistant.goal.usageLimitedHint') }}</p>
       <p v-if="running || 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">
@@ -110,6 +126,9 @@ async function cancelGoal() {
 .assistant-goal__details { overflow-wrap: anywhere; min-height: 0; max-height: calc(100dvh - 24px); }
 .assistant-goal__form { display: grid; gap: 0.75rem; }
 @keyframes assistant-goal-flash { 50% { opacity: 0.3; } }
-@container assistant-conversation (max-width: 26rem) { .assistant-goal__elapsed { display: none; } }
+@container assistant-conversation (max-width: 26rem) {
+  .assistant-goal__elapsed { display: none; }
+  .assistant-goal__label { max-width: 10rem; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+}
 @media (prefers-reduced-motion: reduce) { .assistant-goal__light--working { animation: none; } }
 </style>

package/src/client/types.js

@@ -43,7 +43,7 @@
  * @property {boolean} [working]
  * @property {boolean} [pending]
  * @property {boolean} [stopPending]
- * @property {boolean} [pauseBlocked] True when a blocked goal can still be paused.
+ * @property {boolean} [pauseBlocked] True when a goal that is not running (blocked, or waiting at its usage limit) can still be paused.
  * @property {boolean} [pauseInterruptsTurn]
  * @property {boolean} [cancelInterruptsTurn]
  * @property {boolean} [tokenBudgetSupported]

package/src/server/conversation/claudeHistory.js

@@ -301,6 +301,21 @@ async function readClaudeHistory(options) {
       goal = { ...goal, status: "blocked", updatedAt: Date.parse(frame.timestamp) / 1000,
         reason: ["Claude stopped after repeated attempts to continue the unfinished goal. Resolve the blocker, then resume the goal.", goal.reason].filter(Boolean).join("\n\n") };
     }
+    // Claude's own API-error message ends the goal's turn at the account's
+    // usage limit (with its reset time) or an exhausted credit balance. The
+    // goal waits there until a later answer shows the account working again.
+    if (["active", "usageLimited"].includes(goal?.status) && frame.type === "assistant" &&
+        !frame.parent_tool_use_id && !frame.isSidechain) {
+      const outOfCredit = frame.isApiErrorMessage === true && frame.error === "billing_error";
+      const limited = outOfCredit || (frame.isApiErrorMessage === true &&
+        ["usage_limit_reached", "model_requires_usage_credits"].includes(frame.apiError));
+      if (limited || (goal.status === "usageLimited" && frame.isApiErrorMessage !== true)) {
+        const resetsAt = frame.apiErrorParams?.rate_limit_info?.resetsAt;
+        const { resetsAt: _resetsAt, outOfCredit: _outOfCredit, ...rest } = goal;
+        goal = { ...rest, status: limited ? "usageLimited" : "active", updatedAt: Date.parse(frame.timestamp) / 1000,
+          ...(outOfCredit ? { outOfCredit: true } : limited && Number.isSafeInteger(resetsAt) && resetsAt > 0 ? { resetsAt } : {}) };
+      }
+    }
     // Native /goal appends its sentinel before the authored command, whose
     // parent identifies that exact attachment. A later evaluation keeps it.
     if (frame.type === "user" && !frame.isMeta && frame.uuid && goalStartId && frame.parentUuid === goalStartId) {

package/src/server/conversation/claudeTurn.js

@@ -118,26 +118,27 @@ export async function runClaudeRenewalTurn(conversation, {
  * @param {{
  *   conversationId: string,
  *   readHistory: () => Promise<Record<string, any>>,
- *   readState: () => { running: boolean, active: boolean },
  *   interrupt: () => Promise<unknown>,
  *   send: (input: Record<string, any>) => Promise<unknown>,
  *   readRetainedGoal: () => Record<string, any> | null,
  *   saveRetainedGoal: (goal: Record<string, any>) => Promise<void>
  * }} options
  */
-export function createClaudeConversationGoals({ conversationId, readHistory, readState, interrupt, send, readRetainedGoal, saveRetainedGoal }) {
+export function createClaudeConversationGoals({ conversationId, readHistory, interrupt, send, readRetainedGoal, saveRetainedGoal }) {
   // These checks run before interrupt/send. Native execution and receipt
   // failures keep their own codes and must not be treated as safe rejections.
   const goalError = (message, { messageCode }) => Object.assign(
     new AppError(400, message, { code: "conversation_invalid_goal", messageCode }), { delivery: "not-sent" });
 
+  // Only a retained Pause is paused. A goal whose turn has ended keeps
+  // Claude's checker armed: the next turn, or a host's restart recovery,
+  // continues it, so between turns it stays active unless its history shows
+  // it complete, blocked or waiting at the account's usage limit.
   async function read(history = null) {
     const { goal = null } = history || await readHistory();
     const retained = readRetainedGoal();
     if (retained) return { ...retained };
-    const state = readState();
-    return goal ? { ...goal, status: ["complete", "blocked"].includes(goal.status) ? goal.status :
-      state.running && state.active ? "active" : "paused" } : null;
+    return goal ? { ...goal, status: ["complete", "blocked", "usageLimited"].includes(goal.status) ? goal.status : "active" } : null;
   }
 
   async function update(input = {}, { interrupt: interruptGoal = interrupt, send: sendGoal = send, signal } = {}) {
@@ -386,7 +387,6 @@ export function createClaudeConversationOwner({
         try { await store.save(entry); }
         catch (error) { Object.assign(entry, previous); throw error; }
       },
-      readState: () => ({ running: Boolean(entry.process), active: isTurnActive(entry) }),
       interrupt: () => interrupt(entry), send: input => delivery.send(entry, input) });
     entries.set(key, entry);
     await store.save(entry);

package/test/assistantGoalControlChip.test.js

@@ -0,0 +1,111 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { readFileSync } from "node:fs";
+import { registerHooks } from "node:module";
+import { compileScript, parse } from "@vue/compiler-sfc";
+import { createSSRApp, defineComponent, h } from "vue";
+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 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 };
+    }
+  });
+  try {
+    return (await import(controlUrl)).default;
+  } finally {
+    hooks.deregister();
+  }
+}
+
+const slotted = tag => defineComponent({ setup: (_props, { slots }) => () => h(tag, slots.default?.()) });
+
+/** The chip (the menu's activator) and the details panel of one goal state. */
+async function render(control, goal, state = {}) {
+  const app = createSSRApp({ render: () => h(control, { state: { enabled: true, goal, pause() {}, resume() {}, cancel() {}, ...state } }) });
+  app.component("VMenu", defineComponent({ setup: (_props, { slots }) => () => h("div", [
+    h("div", { class: "chip" }, slots.activator?.({ props: {} })), h("div", { class: "panel" }, slots.default?.())
+  ]) }));
+  app.component("VBtn", slotted("button"));
+  app.component("VCard", slotted("div"));
+  app.component("VTextarea", defineComponent({ render: () => null }));
+  app.component("VTextField", defineComponent({ render: () => null }));
+  const html = await renderToString(app);
+  const chip = /<div class="chip">([\s\S]*?)<\/div><div class="panel">/u.exec(html)[1];
+  const panel = html.slice(html.indexOf('<div class="panel">'));
+  return { chip, label: /<span class="assistant-goal__label">([^<]*)<\/span>/u.exec(chip)[1], panel };
+}
+
+const startedTwoHoursAgo = new Date(Date.now() - 2 * 60 * 60 * 1000).toISOString();
+
+test("a paused, blocked or waiting goal's chip says so and shows no running clock; its details keep the elapsed time", async () => {
+  const control = await importControl();
+  for (const [status, key] of [["paused", "jskit.assistant.goal.paused"], ["blocked", "jskit.assistant.goal.blocked"],
+    ["usageLimited", "jskit.assistant.goal.usageLimited"], ["budgetLimited", "jskit.assistant.goal.budgetLimited"]]) {
+    // Claude supplies only its creation time, so its clock is wall time since the goal started.
+    const { chip, label, panel } = await render(control, { objective: "Finish every check", status, createdAt: startedTwoHoursAgo });
+    assert.equal(label, key, `a ${status} goal's chip names its state`);
+    assert.doesNotMatch(chip, /assistant-goal__elapsed/u, `a ${status} goal's chip shows no clock`);
+    assert.match(panel, /jskit\.assistant\.goal\.elapsed\(jskit\.assistant\.goal\.elapsedSinceStart=2:00:0\d\)/u,
+      `a ${status} goal's details keep the elapsed time`);
+  }
+  // A native running time (Codex) stops counting while paused; the chip still shows no clock.
+  const native = await render(control, { objective: "Finish every check", status: "paused", elapsedSeconds: 125, sampledAt: Date.now() });
+  assert.equal(native.label, "jskit.assistant.goal.paused");
+  assert.doesNotMatch(native.chip, /assistant-goal__elapsed/u);
+  assert.match(native.panel, /jskit\.assistant\.goal\.runningTime=2:05/u);
+});
+
+test("an active goal's chip shows its clock, and a finished goal's chip shows neither state nor clock", async () => {
+  const control = await importControl();
+  const active = await render(control, { objective: "Finish every check", status: "active", createdAt: startedTwoHoursAgo });
+  assert.equal(active.label, "jskit.assistant.goal.goal");
+  assert.match(active.chip, /<span class="assistant-goal__elapsed" aria-hidden="true">2:00:0\d<\/span>/u);
+  assert.match(active.chip, /assistant-goal__light--running/u);
+  const complete = await render(control, { objective: "Finish every check", status: "complete", createdAt: startedTwoHoursAgo,
+    sampledAt: Date.now() });
+  assert.equal(complete.label, "jskit.assistant.goal.goal");
+  assert.doesNotMatch(complete.chip, /assistant-goal__elapsed/u);
+  const none = await render(control, null);
+  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 () => {
+  const control = await importControl();
+  const reset = new Date();
+  reset.setSeconds(0, 0);
+  const time = `${String(reset.getHours()).padStart(2, "0")}:${String(reset.getMinutes()).padStart(2, "0")}`;
+  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.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.
+  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");
+  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\.resume</u);
+});

package/test/assistantScroll.browser.test.js

@@ -956,9 +956,14 @@ test("optional goals show running and paused lights, count only active time, and
     await page.getByRole("button", { name: "Pause goal", exact: true }).click();
     await expect(light).toHaveCSS("background-color", "rgb(239, 108, 0)");
     await expect(light).toHaveCSS("animation-name", "none");
-    const pausedTime = await elapsed.textContent();
+    // A paused goal's chip says so without a clock; its open details keep the running time, which stops.
+    await expect(elapsed).toHaveCount(0);
+    await expect(page.locator(".assistant-goal .assistant-goal__label")).toHaveText("Goal paused");
+    const pausedTime = page.locator(".assistant-goal__details").getByText(/^Running time: /u);
+    const pausedText = await pausedTime.textContent();
     await page.clock.fastForward(120_000);
-    await expect(elapsed).toHaveText(pausedTime);
+    await expect(pausedTime).toHaveText(pausedText);
+    await expect(elapsed).toHaveCount(0);
     await page.getByRole("button", { name: "Resume goal", exact: true }).click();
     await page.clock.fastForward(5_000);
     await expect(elapsed).toHaveText("1:10");

package/test/claudeTurn.test.js

@@ -129,6 +129,45 @@ test("Claude successful native clear removes a failed goal without a clearing se
   assert.equal((await readClaudeHistory(options)).goal.objective, "Next checks", "a later goal still wins");
 });
 
+// Claude 2.1.308 history at a hosted goal's usage limit (2026-11-10), and the
+// message Claude Code writes when the account's credit balance is too low.
+test("Claude's own limit message makes its goal wait, with the reset time, until a later answer", async t => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "claude-limit-goal-"));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  const directory = path.join(root, "projects", root.replace(/[^a-zA-Z0-9]/gu, "-"));
+  await mkdir(directory, { recursive: true });
+  const conversationId = "1d6f6949-185c-46b2-9475-a9f080d505f2";
+  const file = path.join(directory, `${conversationId}.jsonl`);
+  const options = { configRoot: root, workdir: root, conversationId };
+  const append = (...frames) => writeFile(file, frames.map(JSON.stringify).join("\n") + "\n", { flag: "a" });
+  const limit = { type: "assistant", uuid: "limit", timestamp: "2026-11-10T04:54:47.014Z", isApiErrorMessage: true,
+    error: "rate_limit", apiError: "usage_limit_reached",
+    apiErrorParams: { rate_limit_info: { status: "rejected", resetsAt: 1794286800, rateLimitType: "five_hour" } },
+    message: { model: "<synthetic>", role: "assistant", content: [{ type: "text", text: "You've hit your session limit · resets 5am (UTC)" }] } };
+  const answer = { type: "assistant", uuid: "answer", timestamp: "2026-11-10T05:01:00.000Z",
+    message: { role: "assistant", content: [{ type: "text", text: "Continuing the checks." }] } };
+  await append({ type: "attachment", uuid: "goal", timestamp: "2026-11-10T04:00:00.000Z",
+    attachment: { type: "goal_status", condition: "Finish all checks", met: false, sentinel: true } },
+  { ...limit, uuid: "nested", parent_tool_use_id: "child" }, { ...limit, uuid: "sidechain", isSidechain: true },
+  { ...limit, uuid: "other-error", apiError: "max_output_tokens" });
+  assert.equal((await readClaudeHistory(options)).goal.status, "active", "a helper's limit or another API error is not the goal's");
+  await append(limit);
+  const waiting = (await readClaudeHistory(options)).goal;
+  assert.equal(waiting.status, "usageLimited");
+  assert.equal(waiting.resetsAt, 1794286800);
+  assert.equal(waiting.objective, "Finish all checks");
+  await append(answer);
+  const resumed = (await readClaudeHistory(options)).goal;
+  assert.equal(resumed.status, "active", "an answer after the reset shows the account working again");
+  assert.equal("resetsAt" in resumed, false);
+  await append({ ...limit, uuid: "credit", error: "billing_error", apiError: undefined, apiErrorParams: undefined,
+    message: { ...limit.message, content: [{ type: "text", text: "Credit balance is too low" }] } });
+  const credit = (await readClaudeHistory(options)).goal;
+  assert.equal(credit.status, "usageLimited");
+  assert.equal(credit.outOfCredit, true);
+  assert.equal("resetsAt" in credit, false);
+});
+
 test("Claude local-command error output stays distinguishable and result-only success retains provenance", async () => {
   const { turn, send, events } = fixture();
   await send();
@@ -2976,6 +3015,44 @@ test("Pausing an idle Claude goal retires its warm process before the next ordin
 });
 
 
+// A hosted goal (2026-11-10): the account hit its usage limit, the turn ended
+// with the checker still armed and the control read "paused", so the person
+// saw it paused while a restart resumed it and ran ~20 continuation turns.
+test("A Claude goal whose turn ended without Pause is active, at its usage limit it waits; Pause sends nothing and the next start clears it locally", { timeout: 5_000 }, async t => {
+  const f = await publishedClaudeFixture(t);
+  await f.owner.updateGoal(f.entry, { action: "set", objective: "Finish all checks", messageId: "limited-goal" });
+  await f.behavior.goalAttachmentWork;
+  await f.frame({ type: "result", subtype: "success", result: "Partial progress" });
+  assert.equal(f.entry.turn.active, false);
+  assert.equal((await f.owner.readGoal(f.entry)).goal.status, "active",
+    "nothing paused it: the next turn's checker, or a restart, continues it");
+  // Claude ends the next turn at the account's usage limit, as its history records.
+  const history = path.join(f.context.workdir, "projects", f.context.workdir.replace(/[^a-zA-Z0-9]/gu, "-"),
+    `${f.entry.process.options.sessionId}.jsonl`);
+  await appendFile(history, JSON.stringify({ type: "assistant", uuid: "limit", timestamp: new Date().toISOString(),
+    isApiErrorMessage: true, error: "rate_limit", apiError: "usage_limit_reached",
+    apiErrorParams: { rate_limit_info: { status: "rejected", resetsAt: 1794286800 } },
+    message: { role: "assistant", content: [{ type: "text", text: "You've hit your session limit · resets 5am (UTC)" }] } }) + "\n");
+  const goal = (await f.owner.readGoal(f.entry)).goal;
+  assert.equal(goal.status, "usageLimited");
+  assert.equal(goal.resetsAt, 1794286800);
+  await f.owner.stopConversation(f.entry, "The application stopped.");
+  assert.equal(f.entry.process, null);
+  assert.equal((await f.owner.readGoal(f.entry)).goal.status, "usageLimited", "a stopped process keeps the goal waiting");
+  const inputs = f.behavior.nativeInputs.length;
+  const processes = f.processes.length;
+  await f.owner.updateGoal(f.entry, { action: "pause", ...goal });
+  assert.equal((await f.owner.readGoal(f.entry)).goal.status, "paused");
+  assert.equal(f.behavior.nativeInputs.length, inputs, "Pause sends nothing to Claude");
+  assert.equal(f.processes.length, processes, "Pause starts no Claude process");
+  await f.send("person-after-pause");
+  assert.deepEqual(f.behavior.nativeInputs.slice(inputs), ["/goal clear", "Explain"],
+    "the next start stands the native goal down with Claude's local command before the person's own message");
+  assert.equal((await f.owner.readGoal(f.entry)).goal.status, "paused");
+  await f.frame({ type: "result", subtype: "success", result: "Ordinary answer" });
+});
+
+
 test("Claude Block refuses absent reasons and stale identity before interrupting", { timeout: 5_000 }, async t => {
   const f = await publishedClaudeFixture(t);
   await f.owner.updateGoal(f.entry, { action: "set", objective: "Finish checks", messageId: "block-validation" });