@jskit-ai/assistant-core 0.1.223 → 0.1.225

package/examples/conversation/package.json

@@ -8,7 +8,7 @@
     "build": "vite build"
   },
   "dependencies": {
-    "@jskit-ai/assistant-core": "0.1.223",
+    "@jskit-ai/assistant-core": "0.1.225",
     "@jskit-ai/http-runtime": "0.1.242",
     "@jskit-ai/kernel": "0.1.244",
     "@mdi/js": "^7.4.47",

package/fixtures/responsive-assistant/DeliveryFixture.vue

@@ -26,8 +26,9 @@ const delivery = createAssistantMessageDelivery({ deliver(payload) {
 } });
 function accept() {
   const payload = requests.value.at(-1);
-  turns.value = [...turns.value, { turnId: payload.messageId, user: { messageId: payload.messageId, text: payload.message },
-    assistant: { text: "Accepted once." } }];
+  const at = new Date().toISOString();
+  turns.value = [...turns.value, { turnId: payload.messageId, user: { messageId: payload.messageId, text: payload.message, at },
+    assistant: { text: "Accepted once.", at } }];
   pendingRequest.resolve({ ok: true });
 }
 if (recoveryFixture) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/assistant-core",
-  "version": "0.1.223",
+  "version": "0.1.225",
   "type": "module",
   "scripts": {
     "test": "node --test --test-concurrency=1"

package/src/client/conversation/AssistantGoalControl.vue

@@ -6,9 +6,9 @@ const open = ref(false);
 const objective = ref("");
 const tokenBudget = ref("");
 const now = ref(Date.now());
-const goal = computed(() => props.state?.goal);
+const goal = computed(() => props.state?.loading || props.state?.available === false ? null : props.state?.goal);
 const running = computed(() => goal.value?.status === "active");
-const label = computed(() => ({
+const label = computed(() => props.state?.loading ? "Loading goal…" : props.state?.available === false ? "Goal unavailable" : ({
   active: "Goal running", paused: "Goal paused", blocked: "Goal blocked",
   usageLimited: "Goal waiting for allowance", budgetLimited: "Goal budget reached", complete: "Goal complete"
 })[goal.value?.status] || "Set goal");
@@ -21,7 +21,7 @@ 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}`;
 });
-const canSet = computed(() => typeof props.state?.set === "function" && (!goal.value || goal.value.status === "complete"));
+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, running.value, goal.value?.elapsedSeconds, goal.value?.sampledAt], () => {
@@ -45,7 +45,7 @@ async function setGoal() {
     <template #activator="{ props: menuProps }">
       <v-btn v-bind="menuProps" class="assistant-goal" size="small" variant="text" :aria-label="label" :title="[label, elapsed && `${elapsed} running time`, goal?.objective].filter(Boolean).join('\n')">
         <span v-if="goal" class="assistant-goal__light" :class="{ 'assistant-goal__light--running': running, 'assistant-goal__light--paused': goal.status === 'paused' }" aria-hidden="true" />
-        <span class="assistant-goal__label">{{ goal ? 'Goal' : 'Set goal' }}</span>
+        <span class="assistant-goal__label">{{ state.loading ? 'Loading goal…' : state.available === false ? 'Goal unavailable' : goal ? 'Goal' : 'Set goal' }}</span>
         <span v-if="elapsed" class="assistant-goal__elapsed" aria-hidden="true">{{ elapsed }}</span>
       </v-btn>
     </template>
@@ -54,15 +54,15 @@ async function setGoal() {
       <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">Running time: {{ elapsed }}</p>
-      <v-btn v-if="running && state.pause" size="small" :disabled="state.pending" @click="state.pause()">{{ state.pending ? 'Pausing…' : 'Pause goal' }}</v-btn>
-      <v-btn v-else-if="['paused', 'blocked', 'usageLimited'].includes(goal?.status) && state.resume" size="small" :disabled="state.pending" @click="state.resume()">{{ state.pending ? 'Resuming…' : 'Resume goal' }}</v-btn>
-      <v-btn v-if="goal && goal.status !== 'complete' && state.cancel" color="error" size="small" variant="text" :disabled="state.pending" @click="state.cancel()">Cancel goal</v-btn>
+      <v-btn v-if="running && state.pause" size="small" :disabled="state.pending" @click="state.pause()">{{ state.action === 'pause' ? 'Pausing…' : 'Pause goal' }}</v-btn>
+      <v-btn v-else-if="['paused', 'blocked', 'usageLimited'].includes(goal?.status) && state.resume" size="small" :disabled="state.pending" @click="state.resume()">{{ state.action === 'resume' ? 'Resuming…' : 'Resume goal' }}</v-btn>
+      <v-btn v-if="goal && goal.status !== 'complete' && state.cancel" color="error" size="small" variant="text" :disabled="state.pending" @click="state.cancel()">{{ state.action === 'cancel' ? 'Cancelling…' : 'Cancel goal' }}</v-btn>
       <p v-if="running || goal?.status === 'paused'" class="text-body-small mt-2">{{ state.pauseInterruptsTurn ? 'Pause stops the current turn and keeps the goal for later.' : 'Pausing prevents further automatic turns. Use Stop to interrupt the current turn.' }}</p>
       <p v-if="goal && goal.status !== 'complete' && state.cancel" class="text-body-small mt-2">{{ state.cancelInterruptsTurn ? 'Cancel stops the current turn and clears the goal.' : 'Cancel removes this goal. Use Stop to interrupt a turn already running.' }}</p>
       <form v-if="canSet" class="assistant-goal__form mt-2" @submit.prevent="setGoal">
         <v-textarea v-model="objective" label="Goal objective" rows="2" maxlength="4000" auto-grow :disabled="state.pending" hide-details />
         <v-text-field v-if="state.tokenBudgetSupported !== false" v-model="tokenBudget" label="Token budget (optional)" type="number" min="1" step="1" :disabled="state.pending" :error="!validBudget" hide-details />
-        <v-btn type="submit" size="small" :disabled="state.pending || !objective.trim() || !validBudget">{{ state.pending ? 'Starting…' : 'Start goal' }}</v-btn>
+        <v-btn type="submit" size="small" :disabled="state.pending || !objective.trim() || !validBudget">{{ state.action === 'set' ? 'Starting…' : 'Start goal' }}</v-btn>
       </form>
       <p v-if="state.error" role="alert" class="text-error text-body-small mt-2">{{ state.error }}</p>
       <slot :goal="goal" />

package/src/client/conversation/AssistantTranscript.vue

@@ -608,16 +608,18 @@ const displayEntries = computed(() => {
       }, key);
       if (!displayed) continue;
       candidates.push({ key, role, turn: { ...turn, turnId }, message: displayed,
+        sortAt: turn.optimistic && turn.optimistic.id === message.messageId ? NaN : Date.parse(message.at),
         delivery: role === "user" ? userDelivery : null });
     }
   }
   // Native streaming turns and saved authored turns can arrive independently.
-  // Only dated entries participate; undated notices retain their original slot.
-  const dated = candidates.filter(entry => Number.isFinite(Date.parse(entry.message.at)))
-    .sort((a, b) => Date.parse(a.message.at) - Date.parse(b.message.at))[Symbol.iterator]();
+  // Local queued timestamps can precede an earlier message's native admission.
+  // Keep their supplied positions, along with undated notices.
+  const dated = candidates.filter(entry => Number.isFinite(entry.sortAt))
+    .sort((a, b) => a.sortAt - b.sortAt)[Symbol.iterator]();
   const entries = [];
   for (const candidate of candidates) {
-    const entry = Number.isFinite(Date.parse(candidate.message.at)) ? dated.next().value : candidate;
+    const entry = Number.isFinite(candidate.sortAt) ? dated.next().value : candidate;
     const previous = entries.at(-1);
     if (entry.role === "thinking" && previous?.role === "thinking") previous.messages.push({ ...entry.message, key: entry.key });
     else entries.push({ ...entry, ...(entry.role === "thinking" ? { messages: [{ ...entry.message, key: entry.key }] } : {}) });

package/src/server/conversation/agentRun.js

@@ -63,6 +63,18 @@ export function conversationAgentRunEvent(previous, normalizedRunId, {
   return record;
 }
 
+/** Explicit offline copy only: the destination has no inherited execution. */
+export function prepareCopiedConversationAgentRun(run, { at }) {
+  const active = runStateIsActive(run.state);
+  if (!active && run.providerGoalStatus !== "active") return structuredClone(run);
+  return conversationAgentRunEvent(run, run.id, {
+    event: { at, kind: "development-copy", message: "Copied into a stopped development environment." },
+    patch: { state: active ? "interrupted" : run.state, providerPhase: "",
+      ...(active ? { providerStatus: "interrupted", pendingUserMessageClientIds: [], finishedAt: at } : {}),
+      ...(run.providerGoalStatus === "active" ? { providerGoalStatus: "paused" } : {}) }
+  });
+}
+
 /** The original native run occupies its bound conversation segment. Reading a
  * binding without a run never constructs historical ownership or writes state.
  */

package/src/server/conversation/claudeHistory.js

@@ -68,14 +68,14 @@ async function claudeHistoryPath({ configRoot, workdir, conversationId }) {
   return null;
 }
 
-function claudeMessageBlocks(frame, { includeNested = false } = {}) {
+function claudeMessageBlocks(frame, { includeNested = false, commentary = false } = {}) {
   if (frame.type !== "assistant" || frame.parent_tool_use_id && !includeNested) return [];
   const content = frame.message?.content;
   if (!Array.isArray(content)) return [];
   // Native frames split one API message into blocks with distinct UUIDs.
   const messageId = frame.uuid || frame.message.id;
   if (!messageId) return [];
-  const commentary = content.some((block) => block.type === "tool_use");
+  commentary ||= content.some((block) => block.type === "tool_use");
   return content.flatMap((block, index) => {
     const text = block.type === "thinking" ? block.thinking : block.type === "text" ? block.text : "";
     return typeof text === "string" && text.trim() ? [{
@@ -125,6 +125,12 @@ async function readClaudeHistory(options) {
       leafUuid = byId.get(leafUuid)?.parentUuid;
     }
   }
+  const toolMessages = new Set();
+  for (const frame of frames) {
+    if (rewound && frame.uuid && !retained.has(frame.uuid)) continue;
+    if (frame.type === "assistant" && !frame.parent_tool_use_id && frame.message?.id &&
+        frame.message.content?.some(block => block.type === "tool_use")) toolMessages.add(frame.message.id);
+  }
   for (const frame of frames) {
     if (rewound && frame.uuid && !retained.has(frame.uuid)) continue;
     const status = frame.attachment;
@@ -175,7 +181,7 @@ async function readClaudeHistory(options) {
         }
       }
     }
-    for (const message of claudeMessageBlocks(frame)) {
+    for (const message of claudeMessageBlocks(frame, { commentary: toolMessages.has(frame.message?.id) })) {
       messages.set(message.id, { ...message, userId: lastUserId });
     }
   }

package/src/server/conversation/claudeProcess.js

@@ -220,10 +220,17 @@ export function claudeCatalogueModels(initialization) {
 export function createClaudeAccountQueries({ createProcess, accountIdentity, processes = () => [], isClosing = () => false }) {
   const error = message => Object.assign(new Error(message), { code: "claude_account_query_failed" });
   const accountProcessStops = new Set();
+  const accountReads = new Set();
   let catalog;
-  let catalogStart;
+  const catalogStarts = new Map();
   let planUsage;
-  let planUsagePending;
+  const planUsagePending = new Map();
+  let revision = 0;
+
+  function assertCurrent(expectedRevision) {
+    if (expectedRevision !== revision) throw error("Claude account query was cancelled for reconnection.");
+    if (isClosing()) throw error("Claude is reconnecting.");
+  }
 
   async function stopAccountProcess(native) {
     accountProcessStops.add(native);
@@ -231,50 +238,73 @@ export function createClaudeAccountQueries({ createProcess, accountIdentity, pro
     accountProcessStops.delete(native);
   }
 
-  async function readAccountProcess(identity, read) {
-    if (isClosing()) throw error("Claude is reconnecting.");
+  async function readAccountProcess(identity, expectedRevision, read) {
+    assertCurrent(expectedRevision);
     for (const native of accountProcessStops) await stopAccountProcess(native);
+    assertCurrent(expectedRevision);
     const owned = [...processes()].find((entry) =>
       entry.process && !entry.stopping && entry.accountIdentity === identity);
-    if (owned) return read(owned.process);
-    const native = await createProcess();
+    const controller = new AbortController();
+    accountReads.add(controller);
+    const cancelled = Promise.withResolvers();
+    const abort = () => cancelled.reject(controller.signal.reason);
+    controller.signal.addEventListener("abort", abort, { once: true });
+    // Startup owns its abort and exit proof before it can return a process.
+    // Observe cancellation while awaiting that factory as well.
+    cancelled.promise.catch(() => {});
+    let native;
     try {
-      return await read(native);
+      native = owned?.process || await createProcess({ signal: controller.signal });
+      controller.signal.throwIfAborted();
+      return await Promise.race([read(native), cancelled.promise]);
     } finally {
-      await stopAccountProcess(native);
+      accountReads.delete(controller);
+      controller.signal.removeEventListener("abort", abort);
+      if (native && !owned) await stopAccountProcess(native);
     }
   }
 
   return Object.freeze({
     async readCatalogue(context) {
-      if (isClosing()) throw error("Claude is reconnecting.");
+      const expectedRevision = revision;
+      assertCurrent(expectedRevision);
       const identity = await accountIdentity(context);
+      assertCurrent(expectedRevision);
       if (!catalog || catalog.identity !== identity || Date.now() - catalog.at > 600_000) {
-        catalogStart ||= (async () => {
-          const value = await readAccountProcess(identity, (native) => native.initialization);
+        if (!catalogStarts.has(identity)) catalogStarts.set(identity, (async () => {
+          const value = await readAccountProcess(identity, expectedRevision, (native) => native.initialization);
           if (identity !== await accountIdentity(context)) throw error("The signed-in Claude account changed. Refresh the model list.");
+          assertCurrent(expectedRevision);
           catalog = { at: Date.now(), identity, value };
-        })().finally(() => { catalogStart = null; });
-        await catalogStart;
+          return value;
+        })().finally(() => { catalogStarts.delete(identity); }));
+        return catalogStarts.get(identity);
       }
       return catalog.value;
     },
     async readPlanUsage(context) {
+      const expectedRevision = revision;
+      assertCurrent(expectedRevision);
       const identity = await accountIdentity(context);
+      assertCurrent(expectedRevision);
       if (planUsage?.identity === identity && Date.now() - planUsage.checkedAt < 60_000) return planUsage;
-      if (planUsagePending) return planUsagePending;
-      planUsagePending = (async () => {
-        const value = await readAccountProcess(identity, (native) => native.client.request(
+      if (planUsagePending.has(identity)) return planUsagePending.get(identity);
+      const pending = (async () => {
+        const value = await readAccountProcess(identity, expectedRevision, (native) => native.client.request(
           { subtype: "get_usage", skip_behaviors: true }));
         if (identity !== await accountIdentity(context)) return { status: "unavailable", windows: [] };
+        assertCurrent(expectedRevision);
         planUsage = { ...claudePlanUsage(value), identity };
         return planUsage;
-      })().finally(() => { planUsagePending = null; });
-      return planUsagePending;
+      })().finally(() => { planUsagePending.delete(identity); });
+      planUsagePending.set(identity, pending);
+      return pending;
     },
     invalidateUsage() { planUsage = null; },
     async invalidate() {
-      await Promise.allSettled([catalogStart, planUsagePending]);
+      revision++;
+      for (const controller of accountReads) controller.abort(error("Claude account query was cancelled for reconnection."));
+      await Promise.allSettled([...catalogStarts.values(), ...planUsagePending.values()]);
       catalog = null;
       planUsage = null;
       for (const native of accountProcessStops) await stopAccountProcess(native);
@@ -313,7 +343,8 @@ export async function createClaudeCodeProcess({
       env: environment, stream: true, limits: executionLimits });
     await onStarted?.(native.id, stop);
     signal?.throwIfAborted();
-    client = createClaudeJsonClient({ stream: Duplex.from({ readable: native.stdout, writable: native.stdin }), onEvent, onFailure,
+    const stream = Duplex.from({ readable: native.stdout, writable: native.stdin });
+    client = createClaudeJsonClient({ stream, onEvent, onFailure,
       onControlRequest(request, context) {
         if (request.subtype === "hook_callback" && commandWrapper && request.callback_id === "jskit-command-wrapper") {
           return nativeCommandHook(commandWrapper, request.input);
@@ -334,6 +365,15 @@ export async function createClaudeCodeProcess({
         });
       })
     ]) : initializing);
+    // Children can retain stdout after the parent exits. Keep observing the
+    // execution receipt after startup instead of waiting forever for pipe EOF.
+    if (native.exited) void native.exited.then(processExit => {
+      if (!stopped && !stopping) stream.destroy(Object.assign(new Error("Claude exited unexpectedly."), {
+        code: "assistant_claude_observation_lost", processExit
+      }));
+    }, error => {
+      if (!stopped && !stopping) stream.destroy(error);
+    });
     return { client, initialization, executionId: native.id, stop };
   } catch (error) {
     // A rejected start may already own an execution and its cleanup proof.