@jskit-ai/assistant-core 0.2.43 → 0.2.44

package/CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## Unreleased
 
+- 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.
+- 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.
 - Checking or recovering one message's delivery (`inspectDelivery`, and a send that finds its message already saved) finds that message's turn by its id instead of reading and cloning every turn of the conversation to find it.

package/examples/conversation/package.json

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

package/package.json

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

package/src/client/conversation/AssistantGoalControl.vue

@@ -34,11 +34,16 @@ const statusLabel = computed(() => goal.value?.status === "usageLimited" && goal
 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);
+// 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(createdAt.value)));
+  : Boolean(goal.value && goal.value.status !== "complete" && Number.isFinite(startedAt.value)));
 const elapsed = computed(() => {
   let secondsUsed;
   if (nativeElapsed.value) {
@@ -47,8 +52,8 @@ const elapsed = computed(() => {
     secondsUsed = goal.value.elapsedSeconds + sinceSample;
   } else {
     const end = goal.value?.status === "complete" ? goal.value.sampledAt : now.value;
-    if (!Number.isFinite(createdAt.value) || !Number.isFinite(end)) return "";
-    secondsUsed = (end - createdAt.value) / 1000;
+    if (!Number.isFinite(startedAt.value) || !Number.isFinite(end)) return "";
+    secondsUsed = (end - startedAt.value) / 1000;
   }
   const total = Math.max(0, Math.floor(secondsUsed));
   const seconds = String(total % 60).padStart(2, "0");
@@ -64,7 +69,7 @@ const chipLabel = computed(() => props.state.loading || props.state.available ==
 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, createdAt.value], () => {
+onMounted(() => watch(() => [props.state.enabled, clockRunning.value, goal.value?.elapsedSeconds, goal.value?.sampledAt, startedAt.value], () => {
   clearInterval(timer);
   now.value = Date.now();
   if (props.state.enabled !== false && clockRunning.value) {
@@ -86,7 +91,7 @@ async function cancelGoal() {
 </script>
 
 <template>
-  <v-menu v-if="state && state.enabled !== false" v-model="open" location="top" :close-on-content-click="false">
+  <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" />
@@ -94,7 +99,7 @@ async function cancelGoal() {
         <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">
+    <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="['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>

package/src/client/types.js

@@ -48,7 +48,9 @@
  * @property {boolean} [cancelInterruptsTurn]
  * @property {boolean} [tokenBudgetSupported]
  * @property {string} [error]
- * @property {{ status: string, objective?: string, elapsedSeconds?: number, sampledAt?: number, createdAt?: string } | null} [goal]
+ * @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 {((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

@@ -212,6 +212,9 @@ async function readClaudeHistory(options) {
   const userIds = [];
   let lastUserId = "";
   let goal = null;
+  // The unfinished goal a clear removed: a paused goal's checker is cleared
+  // before its Resume sends the same objective again.
+  let clearedGoal = null;
   let goalStartId = "";
   let goalCommandId = "";
   let frames = [];
@@ -260,6 +263,7 @@ async function readClaudeHistory(options) {
         !frame.parent_tool_use_id && !frame.isMeta && frame.commandRun?.command === "goal" &&
         frame.commandRun.args === "clear" && typeof frame.content === "string" &&
         /^<local-command-stdout>(?:No goal set|Goal cleared: [\s\S]+)<\/local-command-stdout>$/u.test(frame.content)) {
+      if (goal && goal.status !== "complete") clearedGoal = goal;
       goal = null;
       goalStartId = "";
       const command = byId.get(frame.parentUuid);
@@ -282,15 +286,22 @@ async function readClaudeHistory(options) {
         goalStartId = status.sentinel === true && typeof status.met === "boolean" ? frame.uuid || "" : "";
         goalCommandId = "";
       }
-      if (status.met === true && status.sentinel === true) goal = null;
-      else if (status.met === false || status.met === true) {
+      if (status.met === true && status.sentinel === true) {
+        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;
+        // Resume sends the same objective again and Claude starts it anew;
+        // the unfinished goal still started with its first command.
+        const previous = goal || clearedGoal;
         goal = {
-          threadId: options.conversationId, objective: status.condition,
-          createdAt: goal?.objective === status.condition && !status.sentinel ? goal.createdAt : timestamp,
+          threadId: options.conversationId, objective: status.condition, createdAt,
+          startedAt: previous?.objective === status.condition && previous.status !== "complete" ? previous.startedAt : createdAt,
           status: status.met ? "complete" : status.failed === true ? "blocked" : "active", updatedAt: timestamp,
           reason: typeof status.reason === "string" ? status.reason : ""
         };
+        clearedGoal = null;
       }
     }
     // This is native terminal evidence, not an inference from the assistant's

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

@@ -19,6 +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.updatedAt) ? { updatedAt: new Date(goal.updatedAt * 1000).toISOString() } : {})
 } : null;
 const goalCapabilities = Object.freeze({ goals: true, goalBudgets: false,

package/test/assistantGoalControlChip.test.js

@@ -81,6 +81,14 @@ test("an active goal's chip shows its clock, and a finished goal's chip shows ne
   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

@@ -889,10 +889,24 @@ test("long goal objectives keep Start reachable on short phone, tablet and deskt
   const { vite, browser } = await openFixture(t);
   try {
     const objective = "Complete the requested work and verify the result. ".repeat(80).slice(0, 3990);
-    for (const width of [390, 800, 1280]) {
+    for (const width of [320, 390, 800, 1280]) {
       const page = await browser.newPage({ viewport: { width, height: 578 } });
       await page.goto(`${vite.baseURL}/?conversation=1&goal=1`);
       await page.getByRole("button", { name: "Set goal", exact: true }).click();
+      await expect(page.getByRole("textbox", { name: "Goal objective" })).toBeVisible();
+      // The new goal's box fills its menu, which is 360 px wide or as wide as a phone allows.
+      const measure = () => page.locator(".assistant-goal__details").evaluate(card => {
+        const style = getComputedStyle(card);
+        const bounds = card.getBoundingClientRect();
+        return { left: bounds.left, right: bounds.right, card: bounds.width, field: card.querySelector(".v-textarea").getBoundingClientRect().width,
+          inner: card.clientWidth - parseFloat(style.paddingLeft) - parseFloat(style.paddingRight) };
+      });
+      const fills = box => box.card >= Math.min(360, width - 24) - 1 && box.left >= 0 && box.right <= width &&
+        Math.abs(box.field - box.inner) <= 1;
+      await expect.poll(async () => fills(await measure())).toBe(true).catch(async failure => {
+        failure.message += `\nat ${width} px: ${JSON.stringify(await measure())}`;
+        throw failure;
+      });
       await page.getByRole("textbox", { name: "Goal objective" }).fill(objective);
       const start = page.getByRole("button", { name: "Start goal", exact: true });
       await expect(start).toBeInViewport();

package/test/claudeTurn.test.js

@@ -129,6 +129,44 @@ 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-"));
+  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",
+    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);
+});
+
 // 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 => {