@yeaft/webchat-agent 1.0.547 → 1.0.549

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.547",
+  "version": "1.0.549",
   "description": "Remote worker agent for Yeaft Web Code Agent — connects the native Yeaft engine, CLI providers, and workbench tools",
   "main": "index.js",
   "type": "module",

package/yeaft/work-center/action-checkpoint.js

@@ -1,4 +1,5 @@
 const MAX_TOOL_EVENTS = 16;
+const MAX_TOOL_ID_LENGTH = 256;
 const MAX_TOOL_NAME_LENGTH = 80;
 const MAX_RESOURCE_LENGTH = 240;
 const MAX_RESPONSE_LENGTH = 4_000;
@@ -9,27 +10,33 @@ function boundedString(value, maxLength) {
 }
 
 function safeResource(value) {
-  const resource = boundedString(value, MAX_RESOURCE_LENGTH);
-  if (!resource) return '';
+  const raw = typeof value === 'string' ? value.trim() : '';
+  if (!raw) return '';
+  const looksLikeHttpUrl = /^https?:/i.test(raw);
   try {
-    const url = new URL(resource);
+    const url = new URL(raw);
     if (['http:', 'https:'].includes(url.protocol)) {
       return `${url.protocol}//${url.host}${url.pathname}`.slice(0, MAX_RESOURCE_LENGTH);
     }
-  } catch {}
-  return resource;
+    if (looksLikeHttpUrl) return '';
+  } catch {
+    if (looksLikeHttpUrl) return '';
+  }
+  return raw.slice(0, MAX_RESOURCE_LENGTH);
 }
 
 function normalizeToolEvent(value) {
   if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
   const name = boundedString(value.name, MAX_TOOL_NAME_LENGTH);
   if (!name) return null;
-  const event = {
-    name,
-    status: value.status === 'error' ? 'error' : 'completed',
-  };
+  const status = ['running', 'error'].includes(value.status) ? value.status : 'completed';
+  const event = { name, status };
+  const id = boundedString(value.id, MAX_TOOL_ID_LENGTH);
+  if (id) event.id = id;
   const resource = safeResource(value.resource);
   if (resource) event.resource = resource;
+  const startedAt = Number(value.startedAt);
+  if (Number.isFinite(startedAt) && startedAt > 0) event.startedAt = startedAt;
   return event;
 }
 
@@ -48,9 +55,25 @@ export function normalizeActionCheckpoint(value) {
 
 export function appendCheckpointToolEvent(checkpoint, event) {
   const current = normalizeActionCheckpoint(checkpoint) || { version: 1, toolEvents: [] };
+  const normalized = normalizeToolEvent(event);
+  if (!normalized) return current;
+  const toolEvents = normalized.id
+    ? current.toolEvents.filter(item => item.id !== normalized.id)
+    : current.toolEvents;
+  return normalizeActionCheckpoint({
+    ...current,
+    toolEvents: [...toolEvents, normalized],
+  });
+}
+
+export function settleCheckpointToolEvents(checkpoint, status = 'error') {
+  const current = normalizeActionCheckpoint(checkpoint);
+  if (!current?.toolEvents.some(event => event.status === 'running')) return current;
   return normalizeActionCheckpoint({
     ...current,
-    toolEvents: [...current.toolEvents, event],
+    toolEvents: current.toolEvents.map(event => (
+      event.status === 'running' ? { ...event, status } : event
+    )),
   });
 }
 

package/yeaft/work-center/projection.js

@@ -10,6 +10,7 @@ import { runMatchesActionIdentity } from './action-identity.js';
 import { normalizeOutputs } from './evidence.js';
 import { taskSpecificActionBrief } from './workflow.js';
 import { buildMainlineProjection } from './mainline-projection.js';
+import { normalizeActionCheckpoint } from './action-checkpoint.js';
 
 const MAX_ACTION_MESSAGE_CHARS = 16_000;
 const MAX_ACTION_DIAGNOSTIC_CHARS = 8_000;
@@ -293,8 +294,13 @@ function normalizeProjectedMessage(message) {
   const text = typeof message.text === 'string'
     ? message.text.trim().slice(0, MAX_ACTION_MESSAGE_CHARS)
     : '';
+  const checkpoint = normalizeActionCheckpoint({ toolEvents: message.toolEvents });
+  const toolEvents = (checkpoint?.toolEvents || []).map((event, index) => ({
+    ...event,
+    id: event.id || `${index}`,
+  }));
   const attachments = projectAttachments(message.attachments);
-  if (!text && attachments.length === 0) return null;
+  if (!text && attachments.length === 0 && toolEvents.length === 0) return null;
   const speaker = message.role === 'user' ? null : projectVpSpeaker(message.speaker);
   return {
     id: String(message.id || ''),
@@ -302,6 +308,7 @@ function normalizeProjectedMessage(message) {
     kind: message.kind === 'input' ? 'input' : 'response',
     status: message.status || null,
     text,
+    toolEvents,
     attachments,
     ...(projectedMessageQuote(message.quote) ? { quote: projectedMessageQuote(message.quote) } : {}),
     createdAt: count(message.createdAt),
@@ -341,6 +348,7 @@ function runResponseMessage(run) {
     kind: 'response',
     status: run.status || 'running',
     text,
+    toolEvents: run.checkpoint?.toolEvents,
     createdAt: count(run.endedAt || run.startedAt),
     updatedAt: count(run.endedAt || run.startedAt),
     progressRevision: count(run.progressRevision),

package/yeaft/work-center/runner.js

@@ -30,6 +30,7 @@ import {
 import {
   appendCheckpointToolEvent,
   renderActionResumeBlock,
+  settleCheckpointToolEvents,
 } from './action-checkpoint.js';
 import { createSkillManager } from '../skills.js';
 import { loadMCPConfig } from '../config.js';
@@ -1303,6 +1304,7 @@ export class WorkItemRunner {
     let checkpoint = null;
     let terminalEngineError = null;
     const toolInputs = new Map();
+    const toolStartedAt = new Map();
     const usageStats = {
       llmRequestCount: 0,
       inputTokens: 0,
@@ -1318,6 +1320,14 @@ export class WorkItemRunner {
       ...executionStats(),
       checkpoint,
     });
+    const settleOpenTools = (status = 'error') => {
+      const settled = settleCheckpointToolEvents(checkpoint, status);
+      const changed = settled !== checkpoint;
+      checkpoint = settled;
+      toolInputs.clear();
+      toolStartedAt.clear();
+      return changed;
+    };
     const reportProgress = (force = false) => {
       if (typeof onProgress !== 'function') return;
       const now = Date.now();
@@ -1472,16 +1482,33 @@ export class WorkItemRunner {
             response: publicWorkItemResponse(event.response),
           });
         }
-        else if (event?.type === 'tool_start') toolInputs.set(event.id, event.input);
+        else if (event?.type === 'tool_start') {
+          const startedAt = Date.now();
+          toolInputs.set(event.id, event.input);
+          toolStartedAt.set(event.id, startedAt);
+          checkpoint = appendCheckpointToolEvent(checkpoint, {
+            id: event.id,
+            name: event.name,
+            status: 'running',
+            resource: checkpointResource(event.name, event.input, workDir),
+            startedAt,
+          });
+          reportProgress(true);
+        }
         else if (event?.type === 'tool_end') {
           toolCount += 1;
           const input = toolInputs.get(event.id);
           toolInputs.delete(event.id);
+          const startedAt = toolStartedAt.get(event.id);
+          toolStartedAt.delete(event.id);
           checkpoint = appendCheckpointToolEvent(checkpoint, {
+            id: event.id,
             name: event.name,
             status: event.isError ? 'error' : 'completed',
             resource: checkpointResource(event.name, input, workDir),
+            startedAt,
           });
+          reportProgress(true);
         }
         else if (event?.type === 'error' && !terminalEngineError) {
           terminalEngineError = event.error instanceof Error
@@ -1523,11 +1550,13 @@ export class WorkItemRunner {
         throw stopped;
       }
     } catch (error) {
+      if (settleOpenTools('error')) reportProgress(true);
       error.workItemExecutionStats = currentProgress();
       throw error;
     } finally {
       try { engine.abort?.('work_item_run_finished'); } catch {}
     }
+    settleOpenTools('error');
     const response = publicWorkItemResponse(text);
     reportProgress(true);
     const submittedPlan = !replanToolEnabled ? planCollector.value : null;

package/yeaft/work-center/store.js

@@ -1742,7 +1742,7 @@ export class WorkItemStore {
 
   #hasBlockingOperation(workItemId, actionId = null) {
     const rows = this.db.prepare(`SELECT idempotency_key FROM operations
-      WHERE work_item_id = ? AND concurrency_policy = 'blocking'
+      WHERE work_item_id = ? AND concurrency_policy = 'blocking' AND operation_type != 'Bash'
         AND (? IS NULL OR action_id IS NULL OR action_id = ?)`)
       .all(workItemId, actionId, actionId);
     return rows.some(row => !this.operationSafeToProceed(row.idempotency_key));
@@ -1805,11 +1805,19 @@ export class WorkItemStore {
       const active = this.#activeRunRow(operation.runId, ownerBootId, leaseEpoch, true);
       if (!active || active.work_item_id !== operation.workItemId
           || active.action_id !== operation.actionId) {
-        this.db.prepare(`UPDATE operations SET effect_status = 'unknown',
-          execution_status = 'hazardous_orphan', effect_cutoff = ?, result = ?, completed_at = ?,
+        const settled = operation.operationType === 'Bash'
+          && ['applied', 'not_applied', 'failed_no_effect'].includes(effectStatus);
+        this.db.prepare(`UPDATE operations SET effect_status = ?,
+          execution_status = ?, effect_cutoff = ?, result = ?, completed_at = ?,
           updated_at = ? WHERE idempotency_key = ? AND execution_status = 'running'
           AND owner_boot_id = ? AND owner_lease_epoch = ?`).run(
-          stringify({ status: 'stale', closureType: 'late_completion', closedAt: now }),
+          settled ? effectStatus : 'unknown',
+          settled ? 'quiescent' : 'hazardous_orphan',
+          stringify({
+            status: settled ? 'current' : 'stale',
+            closureType: settled ? 'late_settled_completion' : 'late_completion',
+            closedAt: now,
+          }),
           stringify({ attemptedEffectStatus: effectStatus, reportedResult: result }),
           now, now, idempotencyKey, ownerBootId, leaseEpoch,
         );
@@ -1830,6 +1838,19 @@ export class WorkItemStore {
   recoverOperations() {
     return withTransaction(this.db, () => {
       const now = this.now();
+      const reconciled = this.db.prepare(`UPDATE operations SET
+        effect_status = json_extract(result, '$.attemptedEffectStatus'),
+        execution_status = 'quiescent', effect_cutoff = ?, completed_at = COALESCE(completed_at, ?),
+        updated_at = ? WHERE operation_type = 'Bash'
+        AND execution_status = 'hazardous_orphan' AND effect_status = 'unknown'
+        AND json_extract(result, '$.attemptedEffectStatus') IN
+          ('applied', 'not_applied', 'failed_no_effect')`).run(
+        stringify({
+          status: 'current', closureType: 'recovered_late_settled_completion', closedAt: now,
+        }),
+        now,
+        now,
+      );
       const unstarted = this.db.prepare(`UPDATE operations SET effect_status = 'failed_no_effect',
         execution_status = 'quiescent', effect_cutoff = ?, result = ?, completed_at = ?, updated_at = ?
         WHERE effect_status = 'pending' AND execution_status = 'not_started'`).run(
@@ -1842,7 +1863,7 @@ export class WorkItemStore {
         effect_cutoff = ?, updated_at = ? WHERE execution_status IN ('running', 'cancel_requested')`).run(
         stringify({ status: 'stale', closureType: 'restart_unknown', closedAt: now }), now,
       );
-      return Number(unstarted.changes) + Number(hazardous.changes);
+      return Number(reconciled.changes) + Number(unstarted.changes) + Number(hazardous.changes);
     });
   }
 
@@ -4631,6 +4652,7 @@ export class WorkItemStore {
             SELECT 1 FROM operations unsafe_operation
             WHERE unsafe_operation.work_item_id = w.id
               AND unsafe_operation.concurrency_policy = 'blocking'
+              AND unsafe_operation.operation_type != 'Bash'
               AND unsafe_operation.effect_status NOT IN ('applied', 'not_applied', 'failed_no_effect')
           )
           AND NOT EXISTS (