@jskit-ai/assistant-core 0.2.45 → 0.2.46

package/CHANGELOG.md

@@ -2,8 +2,12 @@
 
 ## Unreleased
 
+- 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.
-- A Claude goal's clock counts from its first start: Resume and restart recovery send the same unfinished objective again, which Claude starts anew, so the clock went back to zero after every Pause and Resume and after a server restart. The Claude history keeps that first start, also across the clear that suspends a paused goal's checker, and the goal value carries it as `startedAt` (ISO), which `AssistantGoalControl` counts its wall-clock time from (else `createdAt`). A goal finished or cancelled and then set again starts a new clock.
+- A Claude goal keeps its identity when Claude compacts its context. Claude re-attaches the unfinished goal with a `goal_status` sentinel that no `/goal` command follows, and the history read it as a new start, so the goal's `createdAt` and id moved and a host's restart recovery refused it as a changed goal. Only a sentinel that its own authored `/goal` command names as parent starts the goal again; a re-attached one keeps `createdAt`, the id and `goalCommandId`.
+- A Claude goal carries `timeUsedSeconds`, the time Claude spent working on it, current as of its `updatedAt`, as a Codex goal does: the time up to each history frame Claude saved itself, never the wait before a message the person or the host sent (between turns, while paused, or across a restart), with file order winning over timestamps that run slightly backwards. Resume, restart recovery and compaction carry it on; a new goal starts from zero. It replaces `startedAt` (0.2.44), whose wall-clock time counted idle, paused and restart time.
+- `AssistantGoalControl` looks running (red flashing light, clock beside it) only while the conversation works on an active goal. An active goal with nothing working on it says **Goal not running**, with no red light and no clock, and its details say the next message continues it, beside any error. Its clock is the goal's running time (`elapsedSeconds` as of `sampledAt`), counting on only while running, from the later of the sample and the turn start the control saw; a goal without a running time shows none, and the wall-clock fallback and `jskit.assistant.goal.elapsedSinceStart` are removed.
 - The goal menu is 360 pixels wide, or the screen's width less the menu's 12-pixel margins on a narrower phone (the menu's `width` and `max-width`), so the new-goal objective box fills it instead of shrinking to its label.
 - `assistantConversationListItemOutputValidator` (from `@jskit-ai/assistant-core/shared`) is one conversation of `assistantContract`'s `conversationsList`, the record without its `metadata`; the contract's list output is built from it, and `@jskit-ai/assistant-runtime`'s conversations list route serializes its items with it.
 - `createConversationStorage`'s `write` saves nothing when its callback called no write method: the adapter's `writeRecord` does not run, so file storage no longer rewrites and flushes the whole conversation file, or creates an empty one for a missing conversation, when a write only looked (a delivery check, a message already saved), and the saved record stays cached.

package/examples/conversation/package.json

@@ -8,7 +8,7 @@
     "build": "vite build"
   },
   "dependencies": {
-    "@jskit-ai/assistant-core": "0.2.45",
+    "@jskit-ai/assistant-core": "0.2.46",
     "@jskit-ai/http-runtime": "0.2.20",
     "@jskit-ai/kernel": "0.2.20",
     "@jskit-ai/material-web": "0.1.5",

package/fixtures/responsive-assistant/ConversationFixture.vue

@@ -1,5 +1,5 @@
 <script setup>
-import { computed, reactive, ref } from "vue";
+import { computed, reactive, ref, watch } from "vue";
 import { createAssistantMessageDelivery } from "../../src/client/conversation/messageDelivery.js";
 import AssistantConversationElement from "../../src/client/conversation/AssistantConversationElement.vue";
 import { useAssistantAttachments } from "../../src/client/conversation/useAssistantAttachments.js";
@@ -69,11 +69,19 @@ const models = reactive({
 });
 const goalEnabled = ref(new URLSearchParams(location.search).has("goal"));
 const goal = ref(null);
+// As a server does: a goal's running time counts only while a turn works on
+// it, and is read again when a turn ends, not when one starts.
+let turnStartedAt = null;
+const worked = () => turnStartedAt === null ? 0 : (Date.now() - turnStartedAt) / 1000;
+watch(() => phase.value === "active", working => {
+  if (!working && goal.value?.status === "active") goal.value = { ...goal.value, elapsedSeconds: goal.value.elapsedSeconds + worked(), sampledAt: Date.now() };
+  turnStartedAt = working ? Date.now() : null;
+});
 const goalState = reactive({
   enabled: goalEnabled, goal, pauseBlocked: true, working: computed(() => phase.value === "active"),
-  set(input) { phase.value = "active"; goal.value = { ...input, status: "active", elapsedSeconds: 0, sampledAt: Date.now() }; },
-  pause() { goal.value = { ...goal.value, status: "paused", elapsedSeconds: goal.value.elapsedSeconds + (Date.now() - goal.value.sampledAt) / 1000, sampledAt: Date.now() }; },
-  resume() { phase.value = "active"; goal.value = { ...goal.value, status: "active", reason: "", sampledAt: Date.now() }; },
+  set(input) { phase.value = "active"; turnStartedAt = Date.now(); goal.value = { ...input, status: "active", elapsedSeconds: 0, sampledAt: Date.now() }; },
+  pause() { goal.value = { ...goal.value, status: "paused", elapsedSeconds: goal.value.elapsedSeconds + worked(), sampledAt: Date.now() }; turnStartedAt = null; },
+  resume() { phase.value = "active"; turnStartedAt = Date.now(); goal.value = { ...goal.value, status: "active", reason: "", sampledAt: Date.now() }; },
   cancel() { goal.value = null; phase.value = "idle"; }
 });
 const adapter = reactive({

package/locales/en.json

@@ -108,9 +108,10 @@
         "cancelling": "Cancelling…",
         "complete": "Goal complete",
         "elapsed": "{label}: {elapsed}",
-        "elapsedSinceStart": "Elapsed since goal started (including pauses)",
         "goal": "Goal",
         "loading": "Loading goal…",
+        "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",
         "pause": "Pause goal",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/assistant-core",
-  "version": "0.2.45",
+  "version": "0.2.46",
   "type": "module",
   "scripts": {
     "test": "jskit test"

package/src/client/conversation/AssistantGoalControl.vue

@@ -16,8 +16,10 @@ const objective = ref("");
 const tokenBudget = ref("");
 const now = ref(Date.now());
 const goal = computed(() => props.state.loading || props.state.available === false ? null : props.state.goal);
-const running = computed(() => goal.value?.status === "active");
-const working = computed(() => running.value && props.state.working === true);
+const active = computed(() => goal.value?.status === "active");
+// An active goal runs only while its conversation is working; between turns,
+// or before a restart's continuation starts, nothing is working on it.
+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
@@ -30,46 +32,39 @@ const resetTime = computed(() => {
 });
 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"));
+    : 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);
-const nativeElapsed = computed(() => Number.isFinite(goal.value?.elapsedSeconds));
-// A goal resumed by sending it again (Claude) keeps the time its first start
-// gave it, so its clock carries on across Pause, Resume and a server restart.
-const startedAt = computed(() => {
-  const value = goal.value?.startedAt ?? goal.value?.createdAt;
-  return typeof value === "string" ? Date.parse(value) : NaN;
-});
-const elapsedLabel = computed(() => nativeElapsed.value ? t("jskit.assistant.goal.runningTime") : t("jskit.assistant.goal.elapsedSinceStart"));
-const elapsedText = computed(() => elapsed.value ? t("jskit.assistant.goal.elapsed", { label: elapsedLabel.value, elapsed: elapsed.value }) : "");
-const clockRunning = computed(() => nativeElapsed.value ? running.value && Number.isFinite(goal.value?.sampledAt)
-  : Boolean(goal.value && goal.value.status !== "complete" && Number.isFinite(startedAt.value)));
+// The clock is the time spent working on the goal: the engine's running time
+// as of sampledAt, plus the time since while the conversation works on it. It
+// never counts idle, paused or restart time, and carries on from its total.
+// A turn seen starting after the sample counts from that start, not from the
+// older sample; a turn already working when the control appeared trusts it.
+const workingSince = ref(-Infinity);
+watch(running, (value, previous) => { if (value && previous === false) workingSince.value = Date.now(); }, { flush: "sync" });
+const elapsedText = computed(() => elapsed.value ? t("jskit.assistant.goal.elapsed", { label: t("jskit.assistant.goal.runningTime"), elapsed: elapsed.value }) : "");
+const clockRunning = computed(() => running.value && Number.isFinite(goal.value?.elapsedSeconds) && Number.isFinite(goal.value?.sampledAt));
 const elapsed = computed(() => {
-  let secondsUsed;
-  if (nativeElapsed.value) {
-    const sinceSample = running.value && Number.isFinite(goal.value.sampledAt)
-      ? Math.max(0, now.value - goal.value.sampledAt) / 1000 : 0;
-    secondsUsed = goal.value.elapsedSeconds + sinceSample;
-  } else {
-    const end = goal.value?.status === "complete" ? goal.value.sampledAt : now.value;
-    if (!Number.isFinite(startedAt.value) || !Number.isFinite(end)) return "";
-    secondsUsed = (end - startedAt.value) / 1000;
-  }
-  const total = Math.max(0, Math.floor(secondsUsed));
+  if (!Number.isFinite(goal.value?.elapsedSeconds)) return "";
+  const since = clockRunning.value ? Math.max(goal.value.sampledAt, workingSince.value) : now.value;
+  const total = Math.max(0, Math.floor(goal.value.elapsedSeconds + Math.max(0, now.value - since) / 1000));
   const seconds = String(total % 60).padStart(2, "0");
   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.
+// The chip says plainly when a goal is not running (paused, blocked, waiting,
+// or active with nothing working on it) and shows its clock only while it
+// runs; the details keep the running 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"));
+  WAITING_STATUSES.includes(goal.value?.status) || (active.value && !running.value) ? 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));
 let timer;
-onMounted(() => watch(() => [props.state.enabled, clockRunning.value, goal.value?.elapsedSeconds, goal.value?.sampledAt, startedAt.value], () => {
+onMounted(() => watch(() => [props.state.enabled, clockRunning.value, goal.value?.elapsedSeconds, goal.value?.sampledAt], () => {
   clearInterval(timer);
   now.value = Date.now();
   if (props.state.enabled !== false && clockRunning.value) {
@@ -94,21 +89,22 @@ 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--working': working, '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': goal.status === 'paused' }" 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>
-      <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="(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>
       <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="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="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="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">
         <v-textarea v-model="objective" :label="t('jskit.assistant.goal.objective')" rows="2" max-rows="4" maxlength="4000" auto-grow :disabled="state.pending" hide-details />
@@ -124,8 +120,7 @@ async function cancelGoal() {
 <style scoped>
 .assistant-goal { text-transform: none; flex-shrink: 0; font-variant-numeric: tabular-nums; }
 .assistant-goal__light { width: 0.625rem; height: 0.625rem; border-radius: 50%; margin-inline-end: 0.45rem; background: currentColor; }
-.assistant-goal__light--running { background: #d32f2f; box-shadow: 0 0 0 3px #d32f2f20; }
-.assistant-goal__light--working { animation: assistant-goal-flash 1.5s ease-in-out infinite; }
+.assistant-goal__light--running { background: #d32f2f; box-shadow: 0 0 0 3px #d32f2f20; animation: assistant-goal-flash 1.5s ease-in-out infinite; }
 .assistant-goal__light--paused { background: #ef6c00; box-shadow: 0 0 0 3px #ef6c0020; }
 .assistant-goal__elapsed { margin-inline-start: 0.45rem; }
 .assistant-goal__details { overflow-wrap: anywhere; min-height: 0; max-height: calc(100dvh - 24px); }
@@ -135,5 +130,5 @@ async function cancelGoal() {
   .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; } }
+@media (prefers-reduced-motion: reduce) { .assistant-goal__light--running { animation: none; } }
 </style>

package/src/client/types.js

@@ -48,9 +48,9 @@
  * @property {boolean} [cancelInterruptsTurn]
  * @property {boolean} [tokenBudgetSupported]
  * @property {string} [error]
- * @property {{ status: string, objective?: string, elapsedSeconds?: number, sampledAt?: number, createdAt?: string,
- *   startedAt?: string } | null} [goal] Without a native running time, its clock counts from startedAt (when the
- *   unfinished goal first started, through any Resume), else createdAt.
+ * @property {{ status: string, objective?: string, elapsedSeconds?: number, sampledAt?: number, createdAt?: string } | null} [goal]
+ *   elapsedSeconds is the time spent working on the goal as of sampledAt (milliseconds); its clock adds the time
+ *   since only while the conversation is working on an active goal.
  * @property {((input: { objective: string, tokenBudget?: number }) => unknown) | null} [set]
  *   Starts a goal; absent while starting one is not allowed, so Start stays disabled.
  * @property {() => unknown} [pause]

package/src/server/conversation/claudeHistory.js

@@ -30,6 +30,19 @@ function claudeUserText(content) {
     .filter((block) => block.type === "text" && typeof block.text === "string").map((block) => block.text).join("\n\n");
 }
 
+// A message the person or the host sent, a native /goal command among them.
+// Claude's own notes, compaction summary and interrupt marker are not.
+function claudeAuthoredMessage(frame) {
+  if (frame.type !== "user" || frame.isMeta || frame.isCompactSummary || frame.parent_tool_use_id) return false;
+  const text = claudeUserText(frame.message?.content);
+  return Boolean(text) && !/^\[Request interrupted by user/u.test(text);
+}
+
+// Native /goal saves its sentinel, then the authored command naming that
+// sentinel as its parent. Claude re-attaches an unfinished goal with a
+// sentinel after compacting its context, and no command follows that one.
+const GOAL_COMMAND_PATTERN = /^\s*(?:<command-name>\/goal<\/command-name>|\/goal(?:\s|$))/u;
+
 async function archivedClaudeProjectDirectory(workdir) {
   const canonical = await realpath(workdir).catch((error) => {
     if (error.code === "ENOENT") return workdir;
@@ -221,6 +234,10 @@ async function readClaudeHistory(options) {
   const byId = new Map();
   let leafUuid = "";
   let rewound = false;
+  const commandedSentinels = new Set();
+  // The newest frame time so far. File order wins over timestamps, which can
+  // run slightly backwards between adjacent frames.
+  let lastAt = NaN;
   // Snapshot the file length. A writer can be in the middle of its last frame;
   // Live history reads allow that unfinished tail. Stopped maintenance can
   // require the existing strict parser without changing live observation.
@@ -232,6 +249,8 @@ async function readClaudeHistory(options) {
   }
   for (const frame of frames) {
     if (frame.uuid) byId.set(frame.uuid, frame);
+    if (claudeAuthoredMessage(frame) && frame.parentUuid &&
+        GOAL_COMMAND_PATTERN.test(claudeUserText(frame.message?.content))) commandedSentinels.add(frame.parentUuid);
     if (["user", "assistant"].includes(frame.type) && frame.uuid) leafUuid = frame.uuid;
     if (frame.type === "last-prompt" && frame.leafUuid) {
       leafUuid = frame.leafUuid;
@@ -255,6 +274,17 @@ async function readClaudeHistory(options) {
   }
   for (const frame of frames) {
     if (rewound && frame.uuid && !retained.has(frame.uuid)) continue;
+    // 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.
+    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);
+      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;
+    }
     // The exact native local-command receipt owns clear identity. Claude may
     // insert a caveat between the sentinel and authored command, or omit the
     // sentinel after an impossible evaluation. Neither case changes delivery.
@@ -282,22 +312,28 @@ async function readClaudeHistory(options) {
     const status = frame.attachment;
     if (frame.type === "attachment" && !frame.parent_tool_use_id &&
         status?.type === "goal_status" && typeof status.condition === "string") {
-      if (status.sentinel === true || goal?.objective !== status.condition) {
-        goalStartId = status.sentinel === true && typeof status.met === "boolean" ? frame.uuid || "" : "";
+      // A sentinel no command follows re-attaches the unfinished goal after
+      // Claude compacts its context: it stays the same goal, with its identity.
+      const sentinel = status.sentinel === true && !(status.met === false && status.failed !== true &&
+        goal?.objective === status.condition && goal.status !== "complete" && !commandedSentinels.has(frame.uuid));
+      if (sentinel || goal?.objective !== status.condition) {
+        goalStartId = sentinel && typeof status.met === "boolean" ? frame.uuid || "" : "";
         goalCommandId = "";
       }
-      if (status.met === true && status.sentinel === true) {
+      if (status.met === true && sentinel) {
         if (goal && goal.status !== "complete") clearedGoal = goal;
         goal = null;
       } else if (status.met === false || status.met === true) {
         const timestamp = Date.parse(frame.timestamp) / 1000;
-        const createdAt = goal?.objective === status.condition && !status.sentinel ? goal.createdAt : timestamp;
+        const createdAt = goal?.objective === status.condition && !sentinel ? goal.createdAt : timestamp;
         // Resume sends the same objective again and Claude starts it anew;
-        // the unfinished goal still started with its first command.
+        // the unfinished goal keeps the running time it already had.
         const previous = goal || clearedGoal;
+        const carried = previous?.objective === status.condition &&
+          (previous.status !== "complete" || previous.createdAt === createdAt);
         goal = {
           threadId: options.conversationId, objective: status.condition, createdAt,
-          startedAt: previous?.objective === status.condition && previous.status !== "complete" ? previous.startedAt : createdAt,
+          timeUsedSeconds: carried ? previous.timeUsedSeconds : 0,
           status: status.met ? "complete" : status.failed === true ? "blocked" : "active", updatedAt: timestamp,
           reason: typeof status.reason === "string" ? status.reason : ""
         };

package/src/server/conversation/claudeProcess.js

@@ -6,7 +6,7 @@ import { homedir } from "node:os";
 import path from "node:path";
 import { createClaudeJsonClient } from "./claudeClient.js";
 import { createLocalConversationExecution } from "./localExecution.js";
-import { CLAUDE_APPLICATION_TOOL_SERVER } from "./claudeTools.js";
+import { CLAUDE_APPLICATION_TOOL_SERVER, claudeToolResultAllowance } from "./claudeTools.js";
 import { nativeCommandHook, validateCommandWrapper } from "./commandWrapper.js";
 
 const statusReads = new Map();
@@ -545,15 +545,18 @@ export function createClaudeAccountQueries({
  * @param {Record<string, any>} [options.commandWrapper]
  * @param {number} [options.initializationTimeoutMs]
  * @param {(stage: string) => void} [options.onInitializationProgress]
+ * @param {number} [options.maximumToolResultBytes] The application tool set's result limit, which the process's MCP output cap must hold.
  */
 export async function createClaudeCodeProcess({
   command = "claude", execution = createLocalConversationExecution(), env,
   workdir, onEvent, onControlRequest, onFailure = ignoreProcessFailure, onStarted = ignoreProcessStart, executionLimits, signal,
-  commandWrapper, initializationTimeoutMs = 30_000, onInitializationProgress, ...options
+  commandWrapper, initializationTimeoutMs = 30_000, onInitializationProgress, maximumToolResultBytes, ...options
 }) {
   if (!env) throw new TypeError("createClaudeCodeProcess requires the application's environment, such as process.env.");
   if (commandWrapper !== undefined) validateCommandWrapper(commandWrapper);
   const environment = { ...env, DISABLE_AUTOUPDATER: "1" };
+  const resultAllowance = claudeToolResultAllowance(maximumToolResultBytes);
+  if (resultAllowance) environment.MAX_MCP_OUTPUT_TOKENS = String(resultAllowance);
   for (const name of ["DBUS_SESSION_BUS_ADDRESS", "DBUS_STARTER_ADDRESS", "DBUS_STARTER_BUS_TYPE",
     "CLAUDECODE", "CLAUDE_CODE_ENTRYPOINT"]) delete environment[name];
   let native;

package/src/server/conversation/claudeProcessStart.js

@@ -59,8 +59,11 @@ export function createClaudeProcessStart({
     let startupCleanup;
     let startedExecutionId;
     const processToken = {};
+    // A process's MCP output cap is set when it starts, so its tool list declares the same result
+    // limit: the one of the application tools it starts for.
+    entry.toolResultBytes = entry.command?.tools?.maximumResultBytes;
     try { entry.process = await createProcess({ ...options,
-      workdir: entry.nativeWorkdir, sessionId: entry.id, resume: entry.sent,
+      workdir: entry.nativeWorkdir, sessionId: entry.id, resume: entry.sent, maximumToolResultBytes: entry.toolResultBytes,
       onStarted: async (executionId, stop) => {
         startedExecutionId = executionId;
         if (typeof stop === "function") {
@@ -114,7 +117,8 @@ export function createClaudeProcessStart({
           const owner = active?.nativeOwner;
           const work = applicationCall.run({ entry, command: active, owner,
             toolUseId: request.message?.params?._meta?.["claudecode/toolUseId"] },
-          () => claudeApplicationToolResponse(request, { schemas: entry.toolSchemas || [], turn: active, signal,
+          () => claudeApplicationToolResponse(request, { schemas: entry.toolSchemas || [], maximumResultBytes: entry.toolResultBytes,
+            turn: active, signal,
             ...(suppliedTools ? {
               assertCurrent(native) {
                 if (!currentApplicationCommand(entry, active, owner) || active.nativeOwner !== owner ||

package/src/server/conversation/claudeTools.js

@@ -1,7 +1,22 @@
 import { isDeepStrictEqual } from "node:util";
+import { DEFAULT_MAX_TOOL_RESULT_BYTES } from "../lib/serviceToolCatalog.js";
 
 export const CLAUDE_APPLICATION_TOOL_SERVER = "application";
 
+/**
+ * How large an application tool result Claude must keep whole, in characters and in tokens, or null
+ * to keep Claude's own limits. Claude Code saves an MCP tool result longer than its tool's declared
+ * maxResultSizeChars (50,000 characters unless declared, at most 500,000) or past
+ * MAX_MCP_OUTPUT_TOKENS (25,000 unless set, or raised by Claude's own configuration) to a file, and
+ * the model sees only a preview of it. A tool set whose result limit is above the catalogue's default
+ * 48 KiB raises both to that limit, since a character and a token each cover at least one byte, with
+ * 1 KiB for the result's {"ok":true,"result":…} envelope. At the default, Claude keeps its own.
+ * @param {number | undefined} maximumResultBytes The tool set's result limit.
+ */
+export function claudeToolResultAllowance(maximumResultBytes) {
+  return maximumResultBytes > DEFAULT_MAX_TOOL_RESULT_BYTES ? maximumResultBytes + 1024 : null;
+}
+
 /** A call from tools the conversation owns needs no supplied owner's check. */
 function acceptNativeCall() {}
 
@@ -12,6 +27,7 @@ function ignoreExecutionFailure() {}
 // is no listening socket or separate tool process. The shared executor owns effects.
 export async function claudeApplicationToolResponse(request, {
   schemas,
+  maximumResultBytes,
   turn,
   signal,
   assertCurrent = acceptNativeCall,
@@ -31,10 +47,12 @@ export async function claudeApplicationToolResponse(request, {
     case "ping":
       result = {};
       break;
-    case "tools/list":
+    case "tools/list": {
+      const allowance = claudeToolResultAllowance(maximumResultBytes);
       result = { tools: schemas.map(({ function: tool }) => ({ name: tool.name, description: tool.description,
-        inputSchema: tool.parameters })) };
+        inputSchema: tool.parameters, ...(allowance ? { _meta: { "anthropic/maxResultSizeChars": allowance } } : {}) })) };
       break;
+    }
     case "tools/call": {
       const params = message.params;
       const id = params?._meta?.["claudecode/toolUseId"];

package/src/server/conversation/conversationTurns.js

@@ -292,6 +292,7 @@ function createConversationTurns({ storage, streams, events, entries, reads, del
       const history = activeHistory.filter(inSegment);
       prepareTools(initial);
       const tools = initial.tools && { descriptors: initial.tools.descriptors, schemas: initial.tools.schemas, maximumArgumentBytes: initial.tools.maximumArgumentBytes,
+        maximumResultBytes: initial.tools.maximumResultBytes,
         execute(input, options) {
           const request = toolOwners.get(input.id) || (options?.messageId ? active.requests.get(options.messageId) : active.request);
           if (!request?.accepted) throw new Error("The application tool does not belong to an admitted message.");

package/src/server/conversation/providers/claudeDriver.js

@@ -19,7 +19,7 @@ const nativeInput = input => input.content?.length ? [...(input.text ? [{ type:
 const claudeGoalValue = (goal, conversationId) => goal ? { ...goal,
   id: hash([conversationId, goal.createdAt, goal.objective]),
   ...(Number.isFinite(goal.createdAt) ? { createdAt: new Date(goal.createdAt * 1000).toISOString() } : {}),
-  ...(Number.isFinite(goal.startedAt) ? { startedAt: new Date(goal.startedAt * 1000).toISOString() } : {}),
+  ...(Number.isFinite(goal.timeUsedSeconds) ? { timeUsedSeconds: Math.floor(goal.timeUsedSeconds) } : {}),
   ...(Number.isFinite(goal.updatedAt) ? { updatedAt: new Date(goal.updatedAt * 1000).toISOString() } : {})
 } : null;
 const goalCapabilities = Object.freeze({ goals: true, goalBudgets: false,

package/src/server/conversation/tools.js

@@ -1,4 +1,5 @@
 import { isDeepStrictEqual } from "node:util";
+import { DEFAULT_MAX_TOOL_ARGUMENT_BYTES, DEFAULT_MAX_TOOL_RESULT_BYTES } from "../lib/serviceToolCatalog.js";
 
 const unknownOutcome = "The application operation did not return a verified result. Inspect its target before requesting another execution.";
 
@@ -17,7 +18,7 @@ const TRANSIENT_HOOKS = new Set([authorizeTransientCall, saveTransientCalls, ann
  * One turn's application calls. Native/API adapters only transport these calls.
  * @param {object} options
  * @param {import("../types.js").ServiceToolCatalog} options.catalog
- * @param {{ tools: object[], limits: { maxToolArgumentBytes: number } }} [options.toolSet] A tool set resolved earlier for this turn.
+ * @param {{ tools: object[], limits?: { maxToolArgumentBytes?: number, maxToolResultBytes?: number } }} [options.toolSet] A tool set resolved earlier for this turn.
  * @param {object} options.context The caller context the calls run as.
  * @param {() => Promise<object>} [options.prepareContext] Maps the context again before each call.
  * @param {AbortSignal} options.signal
@@ -42,8 +43,10 @@ export function createConversationTools({ catalog, toolSet: retainedToolSet, con
   // readable-check: allow method-probe - input validation: an optional context mapper must be a function
   if (prepareContext !== undefined && typeof prepareContext !== "function") throw new TypeError("Application tool context requires a server-owned mapper.");
   const toolSet = retainedToolSet ?? catalog.resolveToolSet(context, { discoveryOnly });
-  // The tool set's own limit: a surface-aware catalogue resolves each surface's set with that surface's.
-  const maximumArgumentBytes = toolSet.limits.maxToolArgumentBytes;
+  // The tool set's own limits: a surface-aware catalogue resolves each surface's set with that surface's.
+  // A hand-written catalogue's tool sets may carry none, and keep the catalogue's defaults.
+  const maximumArgumentBytes = toolSet.limits?.maxToolArgumentBytes ?? DEFAULT_MAX_TOOL_ARGUMENT_BYTES;
+  const maximumResultBytes = toolSet.limits?.maxToolResultBytes ?? DEFAULT_MAX_TOOL_RESULT_BYTES;
   const calls = new Map(structuredClone(previousCalls).map(call => [call.id, call]));
   let pending = Promise.resolve();
   let requested = 0;
@@ -120,6 +123,7 @@ export function createConversationTools({ catalog, toolSet: retainedToolSet, con
     schemas: toolSet.tools.map(catalog.toOpenAiToolSchema),
     execute,
     maximumArgumentBytes,
+    maximumResultBytes,
     records
   });
 }

package/src/server/lib/serviceToolCatalog.js

@@ -679,4 +679,4 @@ function createServiceToolCatalog(
   });
 }
 
-export { createServiceToolCatalog, DISCOVERY_TOOL_DESCRIPTORS };
+export { createServiceToolCatalog, DEFAULT_MAX_TOOL_ARGUMENT_BYTES, DEFAULT_MAX_TOOL_RESULT_BYTES, DISCOVERY_TOOL_DESCRIPTORS };

package/test/assistantGoalControlChip.test.js

@@ -48,47 +48,55 @@ async function render(control, goal, state = {}) {
 }
 
 const startedTwoHoursAgo = new Date(Date.now() - 2 * 60 * 60 * 1000).toISOString();
+// Two hours spent working, sampled ten minutes ago.
+const worked = { elapsedSeconds: 2 * 60 * 60, sampledAt: Date.now() - 10 * 60 * 1000 };
 
-test("a paused, blocked or waiting goal's chip says so and shows no running clock; its details keep the elapsed time", async () => {
+test("a paused, blocked or waiting goal's chip says so and shows no running clock; its details keep the running 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 });
+    const { chip, label, panel } = await render(control, { objective: "Finish every check", status, createdAt: startedTwoHoursAgo, ...worked },
+      { working: true });
     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`);
+    assert.doesNotMatch(chip, /assistant-goal__elapsed|assistant-goal__light--running/u, `a ${status} goal's chip shows no clock`);
+    assert.match(panel, /jskit\.assistant\.goal\.elapsed\(jskit\.assistant\.goal\.runningTime=2:00:00\)/u,
+      `a ${status} goal's details keep the running time, without the time since`);
   }
-  // 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 () => {
+test("an active goal looks running, with its clock counting on from its running time, only while its conversation works on it", 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() });
+  const goal = { objective: "Finish every check", status: "active", createdAt: startedTwoHoursAgo, ...worked };
+  const running = await render(control, goal, { working: true });
+  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);
+  // 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.
+  const idle = await render(control, goal);
+  assert.equal(idle.label, "jskit.assistant.goal.notRunning");
+  assert.doesNotMatch(idle.chip, /assistant-goal__elapsed|assistant-goal__light--running/u);
+  assert.match(idle.panel, /jskit\.assistant\.goal\.runningTime=2:00:00\)/u);
+  assert.match(idle.panel, /jskit\.assistant\.goal\.notRunningHint</u);
+  assert.match(idle.panel, /jskit\.assistant\.goal\.pause</u, "a goal that is not running can still be paused");
+  // The reason it stopped (a restart's continuation that failed) shows with it.
+  const failed = await render(control, goal, { error: "The goal could not continue. Vibe64 tries again shortly." });
+  assert.equal(failed.label, "jskit.assistant.goal.notRunning");
+  assert.match(failed.panel, /role="alert"[^>]*>The goal could not continue\. Vibe64 tries again shortly\.</u);
+  // A goal with no running time shows no clock rather than counting wall time.
+  const untimed = await render(control, { objective: "Finish every check", status: "active", createdAt: startedTwoHoursAgo }, { working: true });
+  assert.doesNotMatch(untimed.chip, /assistant-goal__elapsed/u);
+  assert.doesNotMatch(untimed.panel, /runningTime/u);
+  const complete = await render(control, { objective: "Finish every check", status: "complete", ...worked });
   assert.equal(complete.label, "jskit.assistant.goal.goal");
   assert.doesNotMatch(complete.chip, /assistant-goal__elapsed/u);
+  assert.match(complete.panel, /runningTime=2:00:00\)/u);
   const none = await render(control, null);
   assert.equal(none.label, "jskit.assistant.goal.set");
 });
 
-test("a resumed goal's clock counts from its first start, not from the Resume that sent it again", async () => {
-  const control = await importControl();
-  const resumed = await render(control, { objective: "Finish every check", status: "active",
-    createdAt: new Date(Date.now() - 5 * 60 * 1000).toISOString(), startedAt: startedTwoHoursAgo });
-  assert.match(resumed.chip, /<span class="assistant-goal__elapsed" aria-hidden="true">2:00:0\d<\/span>/u);
-  assert.match(resumed.panel, /jskit\.assistant\.goal\.elapsedSinceStart=2:00:0\d/u);
-});
-
 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();

package/test/assistantScroll.browser.test.js

@@ -930,7 +930,7 @@ test("long goal objectives keep Start reachable on short phone, tablet and deskt
   }
 });
 
-test("optional goals show running and paused lights, count only active time, and adapt to pane width", {
+test("optional goals show running, not running and paused lights, count only working time, and adapt to pane width", {
   skip: !RUN_BROWSER_TEST,
   timeout: 60_000
 }, async (t) => {
@@ -953,14 +953,20 @@ test("optional goals show running and paused lights, count only active time, and
     await input.fill("Preserve this draft and caret");
     await input.evaluate(element => element.setSelectionRange(5, 9));
     const light = page.locator(".assistant-goal__light");
+    const elapsed = page.locator(".assistant-goal__elapsed");
     await expect(light).toHaveCSS("background-color", "rgb(211, 47, 47)");
     await expect(light).toHaveCSS("animation-name", /^assistant-goal-flash/u);
+    // With nothing working on it, the active goal says so: no red light, no
+    // clock, and the idle time does not count.
     await page.getByRole("button", { name: "External idle", exact: true }).evaluate(element => element.click());
+    await expect(page.locator(".assistant-goal .assistant-goal__label")).toHaveText("Goal not running");
     await expect(light).toHaveCSS("animation-name", "none");
-    await expect(light).toHaveCSS("background-color", "rgb(211, 47, 47)");
+    await expect(light).not.toHaveCSS("background-color", "rgb(211, 47, 47)");
+    await expect(elapsed).toHaveCount(0);
+    await page.clock.fastForward(30_000);
     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 expect(elapsed).toHaveText("0:00");
     await page.clock.fastForward(65_000);
     await expect(elapsed).toHaveText("1:05");
     await expect(input).toBeFocused();

package/test/claudeConversationSession.test.js

@@ -6,6 +6,7 @@ import path from "node:path";
 import { createConversationRuntime, createFileConversationStorage, upgradeConversationRuntimeState } from "../src/server/conversation/index.js";
 import { createLocalConversationExecution } from "../src/server/conversation/localExecution.js";
 import { createClaudeConversationDriver } from "../src/server/conversation/providers/claudeDriver.js";
+import { createServiceToolCatalog } from "../src/server/lib/serviceToolCatalog.js";
 import { conversationRequestText } from "../src/server/conversation/continuity.js";
 import { createActionCatalogue } from "@jskit-ai/kernel/server/actions";
 import { createSchema } from "json-rest-schema";
@@ -360,6 +361,12 @@ async function fixture(t, options = {}) {
           input: { hook_event_name: "PreToolUse", tool_name: "Bash", tool_input: { command: "pwd", timeout: 100 } } });
         answer.message.content[0].text = JSON.stringify(output);
       }
+      if (text === "limits") {
+        // What Claude would hold the application tools' results to: their declared size and its MCP output cap.
+        const listed = await request({ subtype: "mcp_message", server_name: "application", message: { jsonrpc: "2.0", id: "list", method: "tools/list" } });
+        answer.message.content[0].text = JSON.stringify({ cap: process.env.MAX_MCP_OUTPUT_TOKENS ?? null,
+          sizes: listed.mcp_response.result.tools.map(tool => tool._meta?.["anthropic/maxResultSizeChars"] ?? null) });
+      }
       if (text === "tools" || text === "foreign-tool") {
         let sequence = 0;
         const invoke = async (name, input) => {
@@ -406,6 +413,7 @@ async function fixture(t, options = {}) {
     CLAUDE_CONFIG_DIR: path.join(directory, "claude"), TEST_TRACE: trace, TEST_ACCOUNT: account, ...options.environment };
   function runtime() {
     const value = createConversationRuntime({ engine: "claude", storage, authorize: options.authorize || (() => true), actions: options.actions,
+      toolCatalog: options.toolCatalog,
       connections: options.connections, attachments: options.attachments, persistCommentary: options.persistCommentary,
       host: { workdir: directory, env, commands: { claude: command }, allowAccountChange: options.allowAccountChange, execution: options.execution, nativeTools: options.nativeTools, commandWrapper: options.commandWrapper },
       limits: { admissionTimeoutMs: 150, ...options.limits } });
@@ -723,6 +731,26 @@ test("Claude uses shared discovery and durable application results across native
   assert.equal(starts[0].args[starts[0].args.indexOf("--session-id") + 1], starts[1].args[starts[1].args.indexOf("--resume") + 1]);
 });
 
+test("Claude keeps a raised result limit's results whole: its tools declare that size and its process's MCP output cap fits it", async t => {
+  const context = { actor: { id: "owner" }, surface: "app", permissions: ["numbers.read"] };
+  const actions = applicationActions(async () => ({ value: 42 }));
+  const limits = async toolCatalog => {
+    const f = await fixture(t, { context, toolCatalog });
+    await f.conversation.send({ messageId: "limits", text: "limits" });
+    const result = await f.conversation.wait();
+    assert.equal(result.conversationLog[0].metadata.runtime.status, "complete");
+    return JSON.parse(result.conversationLog[0].assistant.text);
+  };
+  const raised = await limits(createServiceToolCatalog(actions, { maxToolResultBytes: 128 * 1024 }));
+  assert.equal(raised.cap, String(128 * 1024 + 1024));
+  assert.ok(raised.sizes.length > 0);
+  assert.deepEqual(raised.sizes, raised.sizes.map(() => 128 * 1024 + 1024));
+  // At the default limit, Claude keeps its own.
+  const ordinary = await limits(createServiceToolCatalog(actions));
+  assert.equal(ordinary.cap, process.env.MAX_MCP_OUTPUT_TOKENS ?? null);
+  assert.deepEqual(ordinary.sizes, ordinary.sizes.map(() => null));
+});
+
 test("Claude rejects an application call without the preceding native tool identity", async t => {
   let executions = 0;
   const f = await fixture(t, {

package/test/claudeProcess.test.js

@@ -77,6 +77,28 @@ test("standalone Claude startup uses the supplied execution host and carries its
   assert.deepEqual(await native.stop(), { scopeEmpty: true, exited: true });
 });
 
+test("a Claude process for a raised tool result limit has an MCP output cap that every result within it fits", { skip: process.platform === "win32" }, async (t) => {
+  const setup = await fixture(t, `
+    import { createInterface } from "node:readline";
+    createInterface({ input: process.stdin }).on("line", line => {
+      const frame = JSON.parse(line);
+      if (frame.type === "control_request") process.stdout.write(JSON.stringify({ type: "control_response", response: {
+        subtype: "success", request_id: frame.request_id, response: { cap: process.env.MAX_MCP_OUTPUT_TOKENS ?? null } } }) + "\\n");
+    });
+  `);
+  const cap = async (maximumToolResultBytes, env = setup.env) => {
+    const native = await createClaudeCodeProcess({ ...setup, env, maximumToolResultBytes });
+    t.after(() => native.stop());
+    return native.initialization.cap;
+  };
+  // A token covers at least one byte of a result's text, and 1 KiB covers its envelope.
+  assert.equal(await cap(128 * 1024), String(128 * 1024 + 1024));
+  assert.equal(await cap(1024 * 1024), String(1024 * 1024 + 1024));
+  // At the default 48 KiB or less, or with no tools, Claude's own cap stays.
+  const hostCap = { ...setup.env, MAX_MCP_OUTPUT_TOKENS: "30000" };
+  for (const bytes of [48 * 1024, 16 * 1024, undefined]) assert.equal(await cap(bytes, hostCap), "30000");
+});
+
 test("failed native initialization stops its owned process and reports the protocol failure", { skip: process.platform === "win32" }, async (t) => {
   const setup = await fixture(t, 'process.stdin.once("data", () => process.stdout.write("invalid frame\\n"));');
   await assert.rejects(createClaudeCodeProcess(setup), /invalid UTF-8 or JSON/);

package/test/claudeTurn.test.js

@@ -129,42 +129,116 @@ 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");
 });
 
-test("a resumed Claude goal keeps the time it first started, across the clear before Resume", async t => {
-  const root = await mkdtemp(path.join(os.tmpdir(), "claude-goal-start-"));
+// Frame shapes from a hosted Claude goal's history (Claude 2.1.3xx, 2026-11-11):
+// the /goal command's sentinel comes first in the file, its authored command
+// (a string with command tags) names it as parent with a slightly earlier
+// timestamp, and an auto-compaction re-attaches the goal with a sentinel that
+// no command follows, after a summary timestamped before its boundary.
+function claudeGoalFrames(condition) {
+  const at = (seconds) => new Date(Date.parse("2026-11-11T07:00:00.000Z") + seconds * 1000).toISOString();
+  const sentinel = (uuid, parentUuid, seconds) => ({ type: "attachment", uuid, parentUuid, timestamp: at(seconds),
+    attachment: { type: "goal_status", condition, met: false, sentinel: true } });
+  const command = (uuid, parentUuid, seconds, args = condition) => ({ type: "user", uuid, parentUuid, timestamp: at(seconds),
+    isMeta: false, promptId: `prompt-${uuid}`, message: { role: "user", content: `<command-name>/goal</command-name>\n            <command-message>goal</command-message>\n            <command-args>${args}</command-args>` } });
+  const local = (uuid, parentUuid, seconds, args, output) => ({ type: "system", subtype: "local_command", uuid, parentUuid,
+    timestamp: at(seconds), isMeta: false, level: "info", commandRun: { command: "goal", args }, content: `<local-command-stdout>${output}</local-command-stdout>` });
+  const answer = (uuid, parentUuid, seconds, content = [{ type: "text", text: "Progress report" }]) => ({ type: "assistant", uuid, parentUuid,
+    timestamp: at(seconds), message: { id: `api-${uuid}`, role: "assistant", content } });
+  const attachment = (uuid, parentUuid, seconds, type) => ({ type: "attachment", uuid, parentUuid, timestamp: at(seconds), attachment: { type } });
+  const set = (prefix, parent, seconds) => [sentinel(`${prefix}-sentinel`, parent, seconds + 0.002),
+    command(`${prefix}-command`, `${prefix}-sentinel`, seconds),
+    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,
+    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" } }),
+    message: (uuid, parentUuid, seconds, text) => ({ type: "user", uuid, parentUuid, timestamp: at(seconds), message: { role: "user", content: text } }),
+    compaction: (parent, seconds) => [
+      { type: "system", subtype: "compact_boundary", uuid: "boundary", parentUuid: null, logicalParentUuid: parent, timestamp: at(seconds + 0.295), compactMetadata: { trigger: "auto" } },
+      attachment("instructions", "boundary", seconds + 0.296, "instructions"),
+      { type: "user", uuid: "summary", parentUuid: "instructions", timestamp: at(seconds - 0.069), isCompactSummary: true, isVisibleInTranscriptOnly: true,
+        message: { role: "user", content: "This session is being continued from a previous conversation." } },
+      attachment("model", "summary", seconds + 0.2, "model"),
+      sentinel("reattached", "model", seconds + 0.203),
+      attachment("credential", "reattached", seconds + 0.204, "credential_org")] };
+}
+
+test("a Claude goal Claude re-attaches after compacting its context stays the same goal; only its own /goal command starts it again", async t => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "claude-goal-compaction-"));
+  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-a9f080d505f3";
+  const file = path.join(directory, `${conversationId}.jsonl`);
+  const options = { configRoot: root, workdir: root, conversationId };
+  const append = (...frames) => writeFile(file, frames.flat().map(JSON.stringify).join("\n") + "\n", { flag: "a" });
+  const f = claudeGoalFrames("Continue till all of the pending items are at 100%");
+  await append(f.set("first", "start", 0), f.answer("first-answer", "first-meta", 60));
+  // The person's Resume while it was active sends the same objective again: a new start.
+  await append(f.set("resumed", "first-answer", 600), f.toolUse("working", "resumed-meta", 700));
+  const resumed = await readClaudeHistory(options);
+  assert.equal(resumed.goal.createdAt, Date.parse(f.at(600.002)) / 1000);
+  assert.equal(resumed.goalCommandId, "resumed-command");
+  await append(f.compaction("working", 9000), f.answer("after-compaction", "credential", 9100));
+  const compacted = await readClaudeHistory(options);
+  assert.equal(compacted.goal.status, "active");
+  assert.equal(compacted.goal.createdAt, resumed.goal.createdAt, "the re-attached goal keeps the identity a restart's recovery saved");
+  assert.equal(compacted.goalCommandId, "resumed-command");
+  // A /goal command for the same objective after the compaction starts it again.
+  await append(f.set("again", "after-compaction", 9200));
+  const again = await readClaudeHistory(options);
+  assert.equal(again.goal.createdAt, Date.parse(f.at(9200.002)) / 1000);
+  assert.equal(again.goalCommandId, "again-command");
+  // An ordinary message after a sentinel is not that sentinel's /goal command.
+  await append(f.sentinel("bare", "again-meta", 9300), f.message("bare-reply", "bare", 9301, "Goal noted"));
+  assert.equal((await readClaudeHistory(options)).goal.createdAt, again.goal.createdAt);
+});
+
+test("a Claude goal's running time counts only the time Claude spent working, carried across a restart, a compaction, Pause and Resume", async t => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "claude-goal-time-"));
   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 = "6b1f2c9e-4d3a-4c1b-9e7f-2a5d8c0b1e3f";
   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 goal = (uuid, timestamp, condition, extra = {}) => ({ type: "attachment", uuid, timestamp,
-    attachment: { type: "goal_status", condition, met: false, sentinel: true, ...extra } });
-  const first = Date.parse("2026-11-11T07:00:00.000Z") / 1000;
-  await append(goal("set", "2026-11-11T07:00:00.000Z", "Finish all checks"));
-  // Restart recovery sends the same objective again while the goal still runs.
-  await append(goal("recovered", "2026-11-11T07:30:00.000Z", "Finish all checks"));
-  let read = (await readClaudeHistory(options)).goal;
-  assert.equal(read.createdAt, Date.parse("2026-11-11T07:30:00.000Z") / 1000);
-  assert.equal(read.startedAt, first);
-  // A paused goal's checker is cleared when its process starts; Resume sends it again.
-  await append({ type: "system", subtype: "local_command", uuid: "suspended", timestamp: "2026-11-11T08:00:00.000Z",
-    commandRun: { command: "goal", args: "clear" }, content: "<local-command-stdout>Goal cleared: Finish all checks</local-command-stdout>" });
-  assert.equal((await readClaudeHistory(options)).goal, null);
-  await append(goal("resumed", "2026-11-11T08:05:00.000Z", "Finish all checks"));
-  read = (await readClaudeHistory(options)).goal;
-  assert.equal(read.status, "active");
-  assert.equal(read.startedAt, first, "Resume after the clear keeps the first start");
-  await append({ type: "attachment", uuid: "done", timestamp: "2026-11-11T09:00:00.000Z",
+  const append = (...frames) => writeFile(file, frames.flat().map(JSON.stringify).join("\n") + "\n", { flag: "a" });
+  const f = claudeGoalFrames("Finish all checks");
+  const read = async () => (await readClaudeHistory(options)).goal;
+  // Ten seconds' thinking, a one-minute tool run and thirty seconds' answer.
+  await append(f.set("set", "start", 0), f.toolUse("tool", "set-meta", 10), f.toolResult("result", "tool", 70), f.answer("report", "result", 100));
+  assert.equal(Math.round((await read()).timeUsedSeconds), 100);
+  // An hour between turns waits for the person's next message and does not count.
+  await append(f.message("next", "report", 3600, "Keep going"));
+  let goal = await read();
+  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));
+  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));
+  assert.equal(Math.round((await read()).timeUsedSeconds), 200 + 60);
+  // Pause clears Claude's checker; Resume sends it again half an hour later. Neither wait counts.
+  await append(f.command("pause", "compacted", 7400, "clear"), f.local("cleared", "pause", 7400.01, "clear", "Goal cleared: Finish all checks"));
+  assert.equal(await read(), null);
+  await append(f.set("resume", "cleared", 9000), f.answer("resume-answer", "resume-meta", 9030));
+  goal = await read();
+  assert.equal(goal.status, "active");
+  assert.equal(Math.round(goal.timeUsedSeconds), 260 + 30);
+  assert.equal(goal.updatedAt, Date.parse(f.at(9030)) / 1000);
+  // Finishing keeps the total; a new goal starts from zero.
+  await append({ type: "attachment", uuid: "done", parentUuid: "resume-answer", timestamp: f.at(9040),
     attachment: { type: "goal_status", condition: "Finish all checks", met: true } });
-  assert.equal((await readClaudeHistory(options)).goal.startedAt, first);
-  // A finished goal set again, or another objective, starts its own clock.
-  await append(goal("again", "2026-11-11T09:10:00.000Z", "Finish all checks"));
-  assert.equal((await readClaudeHistory(options)).goal.startedAt, Date.parse("2026-11-11T09:10:00.000Z") / 1000);
-  await append({ type: "attachment", uuid: "cleared", timestamp: "2026-11-11T09:20:00.000Z",
-    attachment: { type: "goal_status", condition: "Finish all checks", met: true, sentinel: true } },
-  goal("other", "2026-11-11T09:30:00.000Z", "Write the release notes"));
-  assert.equal((await readClaudeHistory(options)).goal.startedAt, Date.parse("2026-11-11T09:30:00.000Z") / 1000);
+  goal = await read();
+  assert.equal(goal.status, "complete");
+  assert.equal(Math.round(goal.timeUsedSeconds), 300);
+  await append(claudeGoalFrames("Write the release notes").set("other", "done", 9100), f.answer("other-answer", "other-meta", 9110));
+  goal = await read();
+  assert.equal(goal.objective, "Write the release notes");
+  assert.equal(Math.round(goal.timeUsedSeconds), 10);
 });
 
 // Claude 2.1.308 history at a hosted goal's usage limit (2026-11-10), and the

package/test/conversationTools.test.js

@@ -360,7 +360,7 @@ test("failed reservations and oversized arguments cannot reach application execu
   assert.equal(executions, 0);
 });
 
-test("the resolved tool set's argument limit is the one its calls are held to and the one engines are given", async () => {
+test("the resolved tool set's limits are the ones its calls are held to and the ones engines are given", async () => {
   const lengths = [];
   const actions = createActionCatalogue();
   actions.register({ contributorId: "test.documents", domain: "test", actions: [{
@@ -372,7 +372,8 @@ test("the resolved tool set's argument limit is the one its calls are held to an
   }] });
   // One catalogue per surface behind one, as assistant-runtime's surface-aware catalogue is:
   // the app surface allows 64 KiB of arguments, home keeps the default 32 KiB.
-  const surfaces = { app: createServiceToolCatalog(actions, { maxToolArgumentBytes: 64 * 1024 }), home: createServiceToolCatalog(actions) };
+  const surfaces = { app: createServiceToolCatalog(actions, { maxToolArgumentBytes: 64 * 1024, maxToolResultBytes: 96 * 1024 }),
+    home: createServiceToolCatalog(actions) };
   const catalog = {
     resolveToolSet: (toolContext, options) => surfaces[toolContext.surface].resolveToolSet(toolContext, options),
     toOpenAiToolSchema: surfaces.home.toOpenAiToolSchema,
@@ -383,13 +384,51 @@ test("the resolved tool set's argument limit is the one its calls are held to an
   const proposal = name => ({ id: "propose", name, arguments: JSON.stringify({ text: "x".repeat(40 * 1024) }) });
   const app = tools("app");
   assert.equal(app.maximumArgumentBytes, 64 * 1024);
+  assert.equal(app.maximumResultBytes, 96 * 1024);
   assert.deepEqual(await app.execute(proposal(app.descriptors[0].name)), { ok: true, result: { length: 40 * 1024 } });
   const home = tools("home");
   assert.equal(home.maximumArgumentBytes, 32 * 1024);
+  assert.equal(home.maximumResultBytes, 48 * 1024);
   await assert.rejects(home.execute(proposal(home.descriptors[0].name)), { message: "The application tool arguments exceed their size limit." });
   assert.deepEqual(lengths, [40 * 1024]);
 });
 
+test("a hand-written catalogue whose tool sets carry no limits keeps the default limits, and its API turns run", { timeout: 30_000 }, async t => {
+  const executed = [];
+  const tool = { name: "numbers_add", description: "Adds two numbers.",
+    parameters: { type: "object", properties: { left: { type: "number" }, right: { type: "number" } } } };
+  const toolCatalog = {
+    resolveToolSet: () => ({ tools: [tool] }),
+    toOpenAiToolSchema: descriptor => ({ type: "function", function: { name: descriptor.name, description: descriptor.description,
+      parameters: descriptor.parameters } }),
+    async executeToolCall({ toolName, argumentsText }) {
+      executed.push([toolName, argumentsText]);
+      return { ok: true, result: { total: 5 } };
+    }
+  };
+  const requests = [];
+  const runtime = createConversationRuntime({ storage: createMemoryConversationStorage(), toolCatalog, authorize: () => true,
+    connections: { resolve: async () => ({ providerId: "test", model: "exact-model", sdkPackage: "@ai-sdk/openai-compatible", apiKey: "test", baseURL: "http://test.invalid/v1" }) },
+    fetch: (_url, request) => {
+      requests.push(JSON.parse(request.body));
+      return response(requests.length === 1 ? { name: tool.name } : {});
+    } });
+  t.after(() => runtime.close());
+  const conversation = await runtime.open({ id: "hand-written", context, configuration });
+  await conversation.send(message);
+  const result = await conversation.wait();
+  assert.equal(result.error, "");
+  assert.equal(result.conversationLog[0].assistant.text, "The total is five.");
+  assert.deepEqual(result.conversationLog[0].metadata.applicationTools[0].result, { ok: true, result: { total: 5 } });
+  assert.deepEqual(executed, [[tool.name, call.arguments]]);
+
+  const tools = createConversationTools({ catalog: toolCatalog, context, signal: new AbortController().signal, transient: true });
+  assert.equal(tools.maximumArgumentBytes, 32 * 1024);
+  assert.equal(tools.maximumResultBytes, 48 * 1024);
+  await assert.rejects(tools.execute({ id: "large", name: tool.name, arguments: JSON.stringify({ text: "x".repeat(32 * 1024) }) }),
+    { message: "The application tool arguments exceed their size limit." });
+});
+
 test("closing a native tool connection prevents queued calls while retaining an invoked result", async () => {
   const entered = Promise.withResolvers(), complete = Promise.withResolvers();
   let executions = 0;