@jskit-ai/assistant-core 0.1.226 → 0.1.227

package/examples/conversation/package.json

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

package/fixtures/responsive-assistant/ConversationFixture.vue

@@ -70,10 +70,11 @@ const models = reactive({
 const goalEnabled = ref(new URLSearchParams(location.search).has("goal"));
 const goal = ref(null);
 const goalState = reactive({
-  enabled: goalEnabled, goal,
-  set(input) { goal.value = { ...input, status: "active", elapsedSeconds: 0, sampledAt: Date.now() }; },
+  enabled: goalEnabled, goal, 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() { goal.value = { ...goal.value, status: "active", sampledAt: Date.now() }; }
+  resume() { phase.value = "active"; goal.value = { ...goal.value, status: "active", reason: "", sampledAt: Date.now() }; },
+  cancel() { goal.value = null; phase.value = "idle"; }
 });
 const adapter = reactive({
   delivery: previewFixture ? previewDelivery : undefined,
@@ -177,6 +178,7 @@ const adapter = reactive({
         <button v-if="supportEnabled" @click="customActivity = !customActivity">Custom activity</button>
         <button v-if="capabilitiesEnabled" @click="finishUploads">Finish uploads</button>
         <button @click="goalEnabled = !goalEnabled">Toggle goals</button>
+        <button v-if="goal" @click="goal = { ...goal, status: 'blocked', reason: 'An explanation of the blocker. '.repeat(200) }">Block goal with long explanation</button>
         <template v-if="previewFixture">
           <button @click="temporaryWords = 'Exact temporary words'; temporaryPresent = true; temporaryEditing = false">Add temporary message</button>
           <button @click="newerWords = 'Keep newer live words'; newerPresent = true; newerEditing = false">Add newer temporary message</button>

package/fixtures/responsive-assistant/DeliveryFixture.vue

@@ -4,6 +4,7 @@ import AssistantConversationElement from "../../src/client/conversation/Assistan
 import { createAssistantMessageDelivery } from "../../src/client/conversation/messageDelivery.js";
 
 const recoveryFixture = new URLSearchParams(location.search).has("recovery");
+const acceptedFixture = new URLSearchParams(location.search).has("accepted-history");
 const draft = ref("");
 const turns = ref([]);
 const requests = ref([]);
@@ -43,6 +44,13 @@ if (recoveryFixture) {
   ];
   delivery.state.messages.push({ id: "uncertain", text: "Discard failed attempt", status: "uncertain", error: "Lost response", createdAt: at("05") });
 }
+if (acceptedFixture) {
+  turns.value = [{ turnId: "later", assistant: { text: "Later assistant reply", at: "2026-10-16T11:56:00.000Z" } }];
+  delivery.state.messages.push(
+    { id: "accepted-old", text: "Earlier accepted message", status: "accepted", createdAt: "2026-10-16T11:04:00.000Z" },
+    { id: "queued", text: "Still queued", status: "pending", createdAt: "2026-10-16T11:03:00.000Z" }
+  );
+}
 const adapter = reactive({
   delivery, attachments,
   conversation: { cancellableDelivery: recoveryFixture, turns, visible: true, scrollKey: "delivery", welcomeMessage: "Start a conversation." },
@@ -57,6 +65,7 @@ const adapter = reactive({
   <v-app>
     <main class="fixture">
       <nav>
+        <button v-if="acceptedFixture" @click="turns.unshift({ turnId: 'earlier', user: { messageId: 'accepted-old', text: 'Earlier accepted message', at: '2026-10-16T11:05:00.000Z' } })">Load accepted history</button>
         <button @click="pendingRequest.reject(new Error('Delivery unavailable.'))">Fail request</button>
         <button @click="accept">Accept request</button>
         <button @click="attachments.attachments.push({ attachmentId: 'new-file', fileName: 'next.txt' }); configuration = { tone: 'detailed' }">Prepare newer input</button>

package/package.json

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

package/src/client/conversation/AssistantConversationElement.vue

@@ -195,6 +195,9 @@ const observedAvatarElements = new Set();
 function measureAvatarSpace() {
   const root = container.value;
   if (!root || !slots.avatar) return;
+  const warning = root.querySelector(".assistant-transcript__error");
+  const warningBottom = warning ? warning.getBoundingClientRect().bottom - root.getBoundingClientRect().top + root.scrollTop : 0;
+  root.style.setProperty("--assistant-conversation-warning-bottom", `${warningBottom}px`);
   const rootStyle = getComputedStyle(root);
   let occupied = parseFloat(rootStyle.paddingTop) + parseFloat(rootStyle.paddingBottom);
   for (const element of observedAvatarElements) {
@@ -216,6 +219,8 @@ function observeAvatarSpace() {
     !element.classList.contains("assistant-conversation__avatar") && !element.classList.contains("assistant-conversation__transcript"));
   const elements = new Set([container.value, ...fixedElements]);
   if (avatarControls.value) elements.add(avatarControls.value);
+  const warning = container.value.querySelector(".assistant-transcript__error");
+  if (warning) elements.add(warning);
   for (const element of observedAvatarElements) {
     if (!elements.has(element)) {
       avatarObserver.unobserve(element);
@@ -390,9 +395,7 @@ defineExpose({ focus: () => input.value?.focus(), submit, stop });
 .assistant-conversation__preview-actions { display: flex; justify-content: flex-end; }
 .assistant-conversation { position: relative; display: flex; flex-direction: column; min-height: 0; min-width: 0; height: 100%; gap: 0; container: assistant-conversation / inline-size; }
 .assistant-conversation--error { overflow-y: auto; }
-.assistant-conversation__avatar { position: absolute; top: 0; right: 0; z-index: 3; max-width: 100%; min-width: 0; }
-.assistant-conversation--error .assistant-conversation__avatar { position: relative; align-self: flex-end; flex: 0 0 auto; }
-.assistant-conversation--error .assistant-conversation__avatar-controls { position: static; }
+.assistant-conversation__avatar { position: absolute; top: var(--assistant-conversation-warning-bottom, 0px); right: 0; z-index: 3; max-width: 100%; min-width: 0; }
 .assistant-conversation__avatar-controls { position: absolute; top: 0; right: 100%; display: flex; align-items: center; justify-content: flex-end; min-height: 44px; }
 .assistant-conversation__avatar--hidden .assistant-conversation__avatar-controls { right: 0; }
 .assistant-conversation__avatar-size { min-width: 44px; min-height: 44px; }
@@ -400,7 +403,7 @@ defineExpose({ focus: () => input.value?.focus(), submit, stop });
 .assistant-conversation__avatar-size-disc--minimise { background: rgba(var(--v-theme-primary), .12); }
 .assistant-conversation__avatar-presentation { display: flex; flex-direction: column; align-items: center; min-width: 0; }
 .assistant-conversation__avatar-tools { display: flex; align-items: center; gap: 0; }
-.assistant-conversation__avatar-visual { display: flex; justify-content: center; min-height: 0; overflow: hidden; }
+.assistant-conversation__avatar-visual { display: flex; justify-content: center; min-height: 0; overflow: hidden; contain: layout paint; }
 .assistant-conversation__avatar-visual :deep(> *) { max-width: 100%; max-height: 100%; }
 .assistant-conversation__goal { display: flex; justify-content: flex-end; flex: 0 0 auto; }
 .assistant-conversation__transcript { flex: 1 1 auto; min-height: 0; }

package/src/client/conversation/AssistantGoalControl.vue

@@ -8,15 +8,28 @@ 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 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");
+const nativeElapsed = computed(() => Number.isFinite(goal.value?.elapsedSeconds));
+const createdAt = computed(() => typeof goal.value?.createdAt === "string" ? Date.parse(goal.value.createdAt) : NaN);
+const elapsedLabel = computed(() => nativeElapsed.value ? "Running time" : "Elapsed since goal started (including pauses)");
+const clockRunning = computed(() => nativeElapsed.value ? running.value && Number.isFinite(goal.value?.sampledAt)
+  : Boolean(goal.value && goal.value.status !== "complete" && Number.isFinite(createdAt.value)));
 const elapsed = computed(() => {
-  if (!Number.isFinite(goal.value?.elapsedSeconds)) return "";
-  const sinceSample = running.value && Number.isFinite(goal.value.sampledAt)
-    ? Math.max(0, now.value - goal.value.sampledAt) / 1000 : 0;
-  const total = Math.max(0, Math.floor(goal.value.elapsedSeconds + sinceSample));
+  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(createdAt.value) || !Number.isFinite(end)) return "";
+    secondsUsed = (end - createdAt.value) / 1000;
+  }
+  const total = Math.max(0, Math.floor(secondsUsed));
   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}`;
@@ -24,10 +37,10 @@ const elapsed = computed(() => {
 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], () => {
+onMounted(() => watch(() => [props.state?.enabled, clockRunning.value, goal.value?.elapsedSeconds, goal.value?.sampledAt, createdAt.value], () => {
   clearInterval(timer);
   now.value = Date.now();
-  if (props.state?.enabled !== false && running.value && Number.isFinite(goal.value?.sampledAt)) {
+  if (props.state?.enabled !== false && clockRunning.value) {
     timer = setInterval(() => { now.value = Date.now(); }, 1000);
   }
 }, { immediate: true, flush: "sync" }));
@@ -36,31 +49,31 @@ watch(() => props.state?.enabled, enabled => { if (enabled === false) open.value
 async function setGoal() {
   if (!canSet.value || props.state.pending || !objective.value.trim() || !validBudget.value) return;
   const result = await props.state.set({ objective: objective.value.trim(), ...(props.state.tokenBudgetSupported === false || tokenBudget.value === "" ? {} : { tokenBudget: Number(tokenBudget.value) }) });
-  if (result !== false && !props.state.error) { objective.value = ""; tokenBudget.value = ""; }
+  if (result !== false && result?.ok !== false && !props.state.error) { objective.value = ""; tokenBudget.value = ""; open.value = false; }
 }
 </script>
 
 <template>
   <v-menu v-if="state && state.enabled !== false" v-model="open" location="top" :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, 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" />
+      <v-btn v-bind="menuProps" class="assistant-goal" size="small" variant="text" :aria-label="label" :title="[label, elapsed && `${elapsedLabel}: ${elapsed}`, goal?.objective].filter(Boolean).join('\n')">
+        <span v-if="goal" class="assistant-goal__light" :class="{ 'assistant-goal__light--running': running, 'assistant-goal__light--working': working, 'assistant-goal__light--paused': goal.status === 'paused' }" aria-hidden="true" />
         <span class="assistant-goal__label">{{ state.loading ? '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>
     <v-card class="assistant-goal__details pa-3" max-width="360">
       <strong role="status">{{ label }}</strong>
-      <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.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="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">{{ elapsedLabel }}: {{ elapsed }}</p>
       <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-textarea v-model="objective" label="Goal objective" rows="2" max-rows="4" 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.action === 'set' ? 'Starting…' : 'Start goal' }}</v-btn>
       </form>
@@ -73,12 +86,13 @@ async function setGoal() {
 <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; animation: assistant-goal-flash 1.5s ease-in-out infinite; }
+.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--paused { background: #ef6c00; box-shadow: 0 0 0 3px #ef6c0020; }
 .assistant-goal__elapsed { margin-inline-start: 0.45rem; }
-.assistant-goal__details { overflow-wrap: anywhere; }
+.assistant-goal__details { overflow-wrap: anywhere; min-height: 0; max-height: calc(100dvh - 24px); }
 .assistant-goal__form { display: grid; gap: 0.75rem; }
 @keyframes assistant-goal-flash { 50% { opacity: 0.3; } }
 @container assistant-conversation (max-width: 26rem) { .assistant-goal__elapsed { display: none; } }
-@media (prefers-reduced-motion: reduce) { .assistant-goal__light--running { animation: none; } }
+@media (prefers-reduced-motion: reduce) { .assistant-goal__light--working { animation: none; } }
 </style>

package/src/client/conversation/AssistantTranscript.vue

@@ -41,18 +41,20 @@
     <v-alert
       v-if="error"
       class="assistant-transcript__error"
+      :icon="false"
       density="compact"
       type="warning"
       variant="tonal"
     >
       <div class="assistant-transcript__error-content">
-        <span>{{ error }}</span>
         <v-btn
-          v-if="errorReloadable && !reloadable" :disabled="reloading" :min-height="48" size="small"
+          v-if="errorReloadable && !reloadable" :disabled="reloading" :min-height="32" size="small"
+          :aria-label="reloading ? 'Reloading chat' : 'Reload chat'"
           type="button" variant="text" @click="emit('reload')"
         >
-          Reload chat
+          {{ reloading ? 'Reloading…' : 'Reload chat' }}
         </v-btn>
+        <span>{{ error }}</span>
       </div>
     </v-alert>
 
@@ -608,13 +610,15 @@ 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),
+        sortAt: turn.optimistic && turn.optimistic.status !== "accepted" && 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.
   // Local queued timestamps can precede an earlier message's native admission.
-  // Keep their supplied positions, along with undated notices.
+  // Keep unconfirmed messages in their supplied positions, along with undated
+  // notices. Accepted local copies join chronology even before history arrives.
   const dated = candidates.filter(entry => Number.isFinite(entry.sortAt))
     .sort((a, b) => a.sortAt - b.sortAt)[Symbol.iterator]();
   const entries = [];
@@ -1130,15 +1134,18 @@ watch(() => props.visible, (visible) => {
 }
 
 .assistant-transcript__error {
+  position: relative;
+  z-index: 4;
+  background: rgb(var(--v-theme-surface));
+  padding: 0.25rem 0.5rem;
   font-size: 0.85rem;
   min-width: 0;
   overflow-wrap: anywhere;
 }
 
 .assistant-transcript__error-content {
-  align-items: flex-start;
+  align-items: center;
   display: flex;
-  flex-direction: column;
   gap: 0.5rem;
 }
 

package/src/client/conversation/useAssistantAttachments.js

@@ -217,6 +217,9 @@ function useAssistantAttachments({
   if (![maxBytes, maxItems, uploadConcurrency].every(value => Number.isSafeInteger(value) && value > 0)) {
     throw new TypeError("Attachment limits must be positive integers.");
   }
+  const maxSizeLabel = maxBytes % (1024 * 1024) === 0
+    ? `${maxBytes / (1024 * 1024)} MiB`
+    : `${maxBytes / 1_000_000} MB`;
   const attachments = ref([]);
   const queueItems = ref([]);
   const dragDepth = ref(0);
@@ -585,7 +588,7 @@ function useAssistantAttachments({
       return waiter.promise;
     }
     if (row.size > maxBytes) {
-      row.error = `${row.fileName} is larger than the ${maxBytes / 1_000_000} MB attachment limit.`;
+      row.error = `${row.fileName} is larger than the ${maxSizeLabel} attachment limit.`;
       row.failureStage = "validation";
       row.phase = "failed";
       reportAttachmentError(row.error, "Attachment upload failed.", { notify: false });
@@ -767,7 +770,7 @@ function useAssistantAttachments({
     row.size = Number(preparedFile.size) || 0;
     row.totalBytes = row.size;
     if (row.size > maxBytes) {
-      row.error = `${row.fileName} is larger than the ${maxBytes / 1_000_000} MB attachment limit.`;
+      row.error = `${row.fileName} is larger than the ${maxSizeLabel} attachment limit.`;
       row.failureStage = "validation";
       row.phase = "failed";
       settleWaiter(row, null, waiter);
@@ -881,7 +884,7 @@ function useAssistantAttachments({
       const waiter = row.waiter;
       waiters.push(waiter.promise);
       if (row.size > maxBytes) {
-        row.error = `${row.fileName} is larger than the ${maxBytes / 1_000_000} MB attachment limit.`;
+        row.error = `${row.fileName} is larger than the ${maxSizeLabel} attachment limit.`;
         row.failureStage = "validation";
         row.phase = "failed";
         settleWaiter(row, null);

package/src/server/conversation/claudeClient.js

@@ -66,6 +66,7 @@ function createClaudeJsonClient({ stream, onEvent = async () => {}, onControlReq
   const incoming = new Map();
   let failure = null;
   let closed = false;
+  let supportsSendNow = false;
   let writes = Promise.resolve();
   let events = Promise.resolve();
   let queuedEventBytes = 0;
@@ -105,18 +106,23 @@ function createClaudeJsonClient({ stream, onEvent = async () => {}, onControlReq
   async function request(request, options = {}) {
     if (failure || closed) throw failure || claudeProtocolError("Claude connection is closed.");
     const requestId = randomUUID();
+    function progress(stage) {
+      try { options.onProgress?.(stage); }
+      catch { /* Diagnostic observers cannot change protocol completion. */ }
+    }
     let timer;
     const response = new Promise((resolve, reject) => {
       timer = setTimeout(() => {
         requests.delete(requestId);
         reject(claudeProtocolError(`Claude ${request.subtype} timed out.`, "assistant_claude_control_timeout"));
       }, options.timeoutMs ?? timeoutMs);
-      requests.set(requestId, { resolve, reject });
+      requests.set(requestId, { resolve, reject, received: () => progress("response_received") });
     });
     // Install both observers before a write can fail or an immediate reply arrives.
     try {
+      progress("requested");
       const [, result] = await Promise.all([
-        write({ type: "control_request", request_id: requestId, request }), response
+        write({ type: "control_request", request_id: requestId, request }).then(() => progress("written")), response
       ]);
       return result;
     } finally {
@@ -163,6 +169,7 @@ function createClaudeJsonClient({ stream, onEvent = async () => {}, onControlReq
           const pending = requests.get(response?.request_id);
           if (!pending) continue; // A timed-out request may still get a reply.
           requests.delete(response.request_id);
+          pending.received();
           if (response.subtype === "success") pending.resolve(response.response || {});
           else pending.reject(claudeProtocolError(String(response.error || "Claude control request failed.")));
         } else if (frame.type === "control_request") {
@@ -170,6 +177,9 @@ function createClaudeJsonClient({ stream, onEvent = async () => {}, onControlReq
         } else if (frame.type === "control_cancel_request") {
           incoming.get(frame.request_id)?.controller.abort(claudeProtocolError("Claude cancelled this control request."));
         } else {
+          if (frame.type === "system" && frame.subtype === "init") {
+            supportsSendNow = frame.capabilities?.includes("interrupt_send_now_v1") === true;
+          }
           const bytes = Buffer.byteLength(JSON.stringify(frame));
           queuedEventBytes += bytes;
           if (queuedEventBytes > 2 * CLAUDE_JSON_MAX_FRAME_BYTES) {
@@ -204,13 +214,20 @@ function createClaudeJsonClient({ stream, onEvent = async () => {}, onControlReq
 
   return Object.freeze({
     completion,
-    initialize: ({ hooks } = {}) => request({ subtype: "initialize", ...(hooks ? { hooks } : {}) }),
+    supportsSendNow: () => supportsSendNow,
+    initialize: ({ hooks } = {}, options) => request({ subtype: "initialize", ...(hooks ? { hooks } : {}) }, options),
     interrupt: () => request({ subtype: "interrupt" }),
     request,
     whenRequestsIdle: () => Promise.all([...incoming.values()].map(pending => pending.done)),
-    send(message, { messageId = randomUUID(), sessionId = "" } = {}) {
-      return write({ type: "user", uuid: messageId, session_id: sessionId,
+    async send(message, { messageId = randomUUID(), sessionId = "", sendNow = false } = {}) {
+      // Older CLIs treat this control as a plain Stop, cancelling background
+      // workers. Require the native capability before writing either frame.
+      if (sendNow && !supportsSendNow) throw Object.assign(
+        claudeProtocolError("This Claude version does not support targeted Send now."), { delivery: "not-sent" }
+      );
+      await write({ type: "user", uuid: messageId, session_id: sessionId,
         parent_tool_use_id: null, message: { role: "user", content: message } });
+      if (sendNow) await request({ subtype: "interrupt", send_now: true, message_uuid: messageId });
     },
     close() {
       closed = true;

package/src/server/conversation/claudeHistory.js

@@ -72,15 +72,25 @@ function claudeMessageBlocks(frame, { includeNested = false, commentary = false
   if (frame.type !== "assistant" || frame.parent_tool_use_id && !includeNested) return [];
   const content = frame.message?.content;
   if (!Array.isArray(content)) return [];
+  // Claude's native placeholder classifier excludes this non-error synthetic
+  // carrier after an interrupted request. Real model replies and API errors
+  // with the same wording remain ordinary output.
+  if (frame.message.model === "<synthetic>" && !frame.isApiErrorMessage && content.length === 1 &&
+      content[0]?.type === "text" && content[0].text === "No response requested.") return [];
   // Native frames split one API message into blocks with distinct UUIDs.
   const messageId = frame.uuid || frame.message.id;
   if (!messageId) return [];
+  const command = frame.local_command_run?.command;
+  const output = /^<local-command-(stdout|stderr)>/u.exec(frame.local_command_source || "")?.[1];
   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() ? [{
       id: `claude_${messageId}_${index}`, text, complete: true,
-      role: block.type === "thinking" ? "thinking" : commentary ? "commentary" : "assistant"
+      role: block.type === "thinking" ? "thinking" : commentary ? "commentary" : "assistant",
+      ...(typeof command === "string" && command && output ? {
+        data: { native: { engineId: "claude", type: "assistant", command, output } }
+      } : {})
     }] : [];
   });
 }
@@ -89,6 +99,7 @@ async function readClaudeHistory(options) {
   const file = await claudeHistoryPath(options);
   const inspected = {
     ...(options.includeUserMessages ? { userMessages: [] } : {}),
+    ...(options.includeCommandMessages ? { commandMessages: [] } : {}),
     ...(options.includeFinalCarriers ? { completedResults: [], failedResults: [], structuredOutputs: [] } : {})
   };
   if (!file || file.size === 0) return { exists: false, messages: [], userIds: [], text: "", ...inspected };
@@ -97,6 +108,8 @@ async function readClaudeHistory(options) {
   const userIds = [];
   let lastUserId = "";
   let goal = null;
+  let goalStartId = "";
+  let goalCommandId = "";
   const frames = [];
   const byId = new Map();
   let leafUuid = "";
@@ -133,19 +146,60 @@ async function readClaudeHistory(options) {
   }
   for (const frame of frames) {
     if (rewound && frame.uuid && !retained.has(frame.uuid)) continue;
+    // 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.
+    // Ordinary model text is never goal-state evidence.
+    if (frame.type === "system" && frame.subtype === "local_command" &&
+        !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)) {
+      goal = null;
+      goalStartId = "";
+      const command = byId.get(frame.parentUuid);
+      goalCommandId = command?.type === "user" && !command.isMeta && !command.parent_tool_use_id
+        ? command.uuid : "";
+    }
+    if (options.includeCommandMessages && frame.type === "system" && frame.subtype === "local_command" &&
+        frame.uuid && !frame.parent_tool_use_id && !frame.isMeta &&
+        typeof frame.commandRun?.command === "string" && frame.commandRun.command) {
+      const output = typeof frame.content === "string"
+        ? /^<local-command-(stdout|stderr)>([\s\S]*)<\/local-command-\1>$/u.exec(frame.content) : null;
+      if (output) inspected.commandMessages.push({ id: `claude_${frame.uuid}_0`, text: output[2],
+        data: { native: { engineId: "claude", type: "system", subtype: "local_command",
+          command: frame.commandRun.command, output: output[1] } } });
+    }
     const status = frame.attachment;
-    if (status?.type === "goal_status" && typeof status.condition === "string") {
+    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 || "" : "";
+        goalCommandId = "";
+      }
       if (status.met === true && status.sentinel === true) goal = null;
       else if (status.met === false || status.met === true) {
         const timestamp = Date.parse(frame.timestamp) / 1000;
         goal = {
           threadId: options.conversationId, objective: status.condition,
           createdAt: goal?.objective === status.condition && !status.sentinel ? goal.createdAt : timestamp,
-          status: status.met ? "complete" : "active", updatedAt: timestamp,
+          status: status.met ? "complete" : status.failed === true ? "blocked" : "active", updatedAt: timestamp,
           reason: typeof status.reason === "string" ? status.reason : ""
         };
       }
     }
+    // This is native terminal evidence, not an inference from the assistant's
+    // answer or its wording. Retain it across process and application restarts.
+    if (goal?.status === "active" && frame.type === "system" && frame.subtype === "informational" &&
+        !frame.parent_tool_use_id && typeof frame.content === "string" &&
+        /^A hook blocked the turn from ending \d+ consecutive times — overriding and ending turn\./u.test(frame.content)) {
+      goal = { ...goal, status: "blocked", updatedAt: Date.parse(frame.timestamp) / 1000,
+        reason: ["Claude stopped after repeated attempts to continue the unfinished goal. Resolve the blocker, then resume the goal.", goal.reason].filter(Boolean).join("\n\n") };
+    }
+    // Native /goal appends its sentinel before the authored command, whose
+    // parent identifies that exact attachment. A later evaluation keeps it.
+    if (frame.type === "user" && !frame.isMeta && frame.uuid && goalStartId && frame.parentUuid === goalStartId) {
+      goalCommandId = frame.uuid;
+    }
     if (frame.type === "user" && !frame.isMeta && frame.uuid &&
         (typeof frame.message?.content === "string" || frame.message?.content?.some((block) => block.type === "text"))) {
       userIds.push(frame.uuid);
@@ -182,10 +236,13 @@ async function readClaudeHistory(options) {
       }
     }
     for (const message of claudeMessageBlocks(frame, { commentary: toolMessages.has(frame.message?.id) })) {
-      messages.set(message.id, { ...message, userId: lastUserId });
+      messages.set(message.id, { ...message, userId: lastUserId,
+        ...(frame.message.content.length === 1 && typeof frame.message.id === "string" && frame.message.id &&
+            Number.isSafeInteger(frame.apiBlockIndex) && frame.apiBlockIndex >= 0
+          ? { outputId: `claude_${frame.message.id}_${frame.apiBlockIndex}` } : {}) });
     }
   }
-  return { exists: true, messages: [...messages.values()], userIds, goal, ...inspected,
+  return { exists: true, messages: [...messages.values()], userIds, goal, goalCommandId, ...inspected,
     text: [...messages.values()].filter((message) => message.role === "assistant" && message.userId === lastUserId)
       .map((message) => message.text).join("\n") };
 }

package/src/server/conversation/claudeProcess.js

@@ -240,7 +240,7 @@ export function createClaudeAccountQueries({ createProcess, accountIdentity, pro
     accountProcessStops.delete(native);
   }
 
-  async function readAccountProcess(identity, expectedRevision, read) {
+  async function readAccountProcess(identity, expectedRevision, purpose, read) {
     assertCurrent(expectedRevision);
     for (const native of accountProcessStops) await stopAccountProcess(native);
     assertCurrent(expectedRevision);
@@ -256,7 +256,7 @@ export function createClaudeAccountQueries({ createProcess, accountIdentity, pro
     cancelled.promise.catch(() => {});
     let native;
     try {
-      native = owned?.process || await createProcess({ signal: controller.signal });
+      native = owned?.process || await createProcess({ signal: controller.signal, purpose });
       controller.signal.throwIfAborted();
       return await Promise.race([read(native), cancelled.promise]);
     } finally {
@@ -274,7 +274,7 @@ export function createClaudeAccountQueries({ createProcess, accountIdentity, pro
       assertCurrent(expectedRevision);
       if (!catalog || catalog.identity !== identity || Date.now() - catalog.at > 600_000) {
         if (!catalogStarts.has(identity)) catalogStarts.set(identity, (async () => {
-          const value = await readAccountProcess(identity, expectedRevision, (native) => native.initialization);
+          const value = await readAccountProcess(identity, expectedRevision, "catalogue", (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 };
@@ -292,7 +292,7 @@ export function createClaudeAccountQueries({ createProcess, accountIdentity, pro
       if (planUsage?.identity === identity && Date.now() - planUsage.checkedAt < 60_000) return planUsage;
       if (planUsagePending.has(identity)) return planUsagePending.get(identity);
       const pending = (async () => {
-        const value = await readAccountProcess(identity, expectedRevision, (native) => native.client.request(
+        const value = await readAccountProcess(identity, expectedRevision, "usage", (native) => native.client.request(
           { subtype: "get_usage", skip_behaviors: true }));
         if (identity !== await accountIdentity(context)) return { status: "unavailable", windows: [] };
         assertCurrent(expectedRevision);
@@ -317,7 +317,8 @@ export function createClaudeAccountQueries({ createProcess, accountIdentity, pro
 /** Native startup and handshake; an execution host owns processes and their identity. */
 export async function createClaudeCodeProcess({
   command = "claude", execution = createLocalConversationExecution(), env = process.env,
-  workdir, onEvent, onControlRequest, onFailure, onStarted, executionLimits, signal, commandWrapper, ...options
+  workdir, onEvent, onControlRequest, onFailure, onStarted, executionLimits, signal, commandWrapper,
+  initializationTimeoutMs = 30_000, onInitializationProgress, ...options
 } = {}) {
   if (commandWrapper !== undefined) validateCommandWrapper(commandWrapper);
   const environment = { ...env, DISABLE_AUTOUPDATER: "1" };
@@ -358,7 +359,7 @@ export async function createClaudeCodeProcess({
     signal?.addEventListener("abort", abort, { once: true });
     const initializing = client.initialize(commandWrapper ? { hooks: {
       PreToolUse: [{ matcher: "^Bash$", hookCallbackIds: ["jskit-command-wrapper"], timeout: 30 }]
-    } } : {});
+    } } : {}, { timeoutMs: initializationTimeoutMs, onProgress: onInitializationProgress });
     const initialization = await (native.exited ? Promise.race([
       initializing,
       native.exited.then(processExit => {