@yeaft/webchat-agent 1.0.134 → 1.0.135

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.134",
+  "version": "1.0.135",
   "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/controller.js

@@ -32,6 +32,8 @@ function normalizeTerminalResult(result, action) {
       ? result.reviewDecision
       : null,
     contractPatch: normalizeContractPatch(result.contractPatch),
+    loopCount: Math.max(0, Number(result.loopCount) || 0),
+    toolCount: Math.max(0, Number(result.toolCount) || 0),
   };
   if (normalized.outcome === 'waiting' && !normalized.waitingReason) {
     throw new Error('waiting outcome requires waitingReason');

package/yeaft/work-center/projection.js

@@ -3,77 +3,74 @@ function currentAction(detail) {
   return detail.actions.find(action => action.id === detail.currentActionId) || null;
 }
 
-function projectAction(action) {
+function count(value) {
+  return Math.max(0, Number(value) || 0);
+}
+
+function actionExecutionStats(action, runs) {
+  const matchingRuns = Array.isArray(runs)
+    ? runs.filter(run => run?.actionId === action?.id)
+    : [];
+  if (matchingRuns.length === 0) {
+    return {
+      loopCount: count(action?.loopCount),
+      toolCount: count(action?.toolCount),
+    };
+  }
+  return matchingRuns.reduce((total, run) => ({
+    loopCount: total.loopCount + count(run.loopCount),
+    toolCount: total.toolCount + count(run.toolCount),
+  }), { loopCount: 0, toolCount: 0 });
+}
+
+function projectAssignmentPolicy(policy) {
+  if (!policy || typeof policy !== 'object') return null;
+  return {
+    mode: policy.mode || null,
+    fixedVpId: policy.fixedVpId || null,
+  };
+}
+
+function projectAction(action, runs) {
   if (!action) return null;
+  const stats = actionExecutionStats(action, runs);
   return {
     id: action.id,
-    workItemId: action.workItemId,
     sequence: action.sequence,
     type: action.type,
     stageId: action.stageId || action.type,
-    assignmentPolicy: action.assignmentPolicy || null,
-    modelPolicy: action.modelPolicy || null,
+    assignmentPolicy: projectAssignmentPolicy(action.assignmentPolicy),
     requiredRole: action.requiredRole || '',
     status: action.status,
-    attempt: action.attempt,
-    maxAttempts: action.maxAttempts,
-    currentRunId: action.currentRunId || null,
-    createdAt: action.createdAt,
-    updatedAt: action.updatedAt,
+    loopCount: stats.loopCount,
+    toolCount: stats.toolCount,
   };
 }
 
-function projectRun(run) {
-  if (!run) return null;
-  return {
-    id: run.id,
-    actionId: run.actionId,
-    workItemId: run.workItemId,
-    status: run.status,
-    startedAt: run.startedAt,
-    expiresAt: run.expiresAt,
-    endedAt: run.endedAt || null,
-    summary: run.summary || '',
-    evidence: Array.isArray(run.evidence) ? run.evidence : [],
-    waitingReason: run.waitingReason || '',
-    error: run.error || '',
-    reviewDecision: run.reviewDecision || null,
-    roleSnapshot: run.roleSnapshot ? {
-      id: run.roleSnapshot.id,
-      actionType: run.roleSnapshot.actionType,
-      selectionReason: run.roleSnapshot.selectionReason,
-    } : null,
-    vpSnapshot: run.vpSnapshot ? {
-      id: run.vpSnapshot.id,
-      name: run.vpSnapshot.name || run.vpSnapshot.id,
-      nameZh: run.vpSnapshot.nameZh || '',
-      role: run.vpSnapshot.role || '',
-      roleZh: run.vpSnapshot.roleZh || '',
-    } : null,
-    modelSnapshot: run.modelSnapshot ? {
-      id: run.modelSnapshot.id,
-      provider: run.modelSnapshot.provider || null,
-      effort: run.modelSnapshot.effort || null,
-      source: run.modelSnapshot.source || null,
-    } : null,
-  };
+function projectActionStats(detail) {
+  if (!Array.isArray(detail?.actions)) return [];
+  return detail.actions.map(action => {
+    const projected = projectAction(action, detail.runs);
+    return {
+      id: projected.id,
+      status: projected.status,
+      loopCount: projected.loopCount,
+      toolCount: projected.toolCount,
+    };
+  });
 }
 
-function projectEvent(event) {
-  if (!event) return null;
-  return {
-    id: event.id,
-    workItemId: event.workItemId,
-    actionId: event.actionId || null,
-    runId: event.runId || null,
-    type: event.type,
-    createdAt: event.createdAt,
-  };
+function waitingReason(detail) {
+  if (typeof detail?.waitingReason === 'string') return detail.waitingReason;
+  if (detail?.status !== 'waiting' || !Array.isArray(detail.runs)) return '';
+  return detail.runs.find(run => (
+    run?.actionId === detail.currentActionId && typeof run.waitingReason === 'string'
+  ))?.waitingReason || '';
 }
 
 /**
- * Authenticated browser detail DTO. Execution-only snapshots, VP persona,
- * tool policy, prompts, event data, and local filesystem paths never cross the wire.
+ * Authenticated browser detail DTO. Execution records stay Agent-local; the
+ * browser receives only Action status and aggregate Loop/tool counts.
  */
 export function projectWorkItemDetail(detail) {
   if (!detail) return null;
@@ -86,21 +83,21 @@ export function projectWorkItemDetail(detail) {
     workflowTemplate: detail.workflowTemplate,
     status: detail.status,
     currentActionId: detail.currentActionId || null,
-    currentRunId: detail.currentRunId || null,
     reuseMemory: detail.reuseMemory !== false,
+    waitingReason: waitingReason(detail),
     origin: detail.origin?.sessionId ? { sessionId: detail.origin.sessionId } : null,
     linkedSessionIds: Array.isArray(detail.linkedSessionIds) ? detail.linkedSessionIds : [],
     createdAt: detail.createdAt,
     updatedAt: detail.updatedAt,
-    actions: Array.isArray(detail.actions) ? detail.actions.map(projectAction) : [],
-    runs: Array.isArray(detail.runs) ? detail.runs.map(projectRun) : [],
-    events: Array.isArray(detail.events) ? detail.events.map(projectEvent) : [],
+    actions: Array.isArray(detail.actions)
+      ? detail.actions.map(action => projectAction(action, detail.runs))
+      : [],
   };
 }
 
 /**
- * Browser event projection. This deliberately excludes local filesystem paths,
- * Run evidence/tool output, prompts, model snapshots, and execution errors.
+ * Browser list projection. This deliberately excludes local filesystem paths
+ * and all Run-level execution detail.
  */
 export function projectWorkItemSummary(detail) {
   if (!detail) return null;
@@ -120,6 +117,7 @@ export function projectWorkItemSummary(detail) {
     };
   }
   const action = currentAction(detail);
+  const projectedAction = action ? projectAction(action, detail.runs) : null;
   return {
     id: detail.id,
     revision: detail.revision,
@@ -127,12 +125,12 @@ export function projectWorkItemSummary(detail) {
     goal: detail.goal,
     status: detail.status,
     currentActionId: detail.currentActionId || null,
-    currentAction: action ? {
-      id: action.id,
-      type: action.type,
-      stageId: action.stageId || action.type,
-      assignmentMode: action.assignmentPolicy?.mode || (action.requiredRole ? 'fixed' : null),
-      status: action.status,
+    currentAction: projectedAction ? {
+      id: projectedAction.id,
+      type: projectedAction.type,
+      stageId: projectedAction.stageId,
+      assignmentMode: projectedAction.assignmentPolicy?.mode || (projectedAction.requiredRole ? 'fixed' : null),
+      status: projectedAction.status,
     } : null,
     origin: detail.origin?.sessionId ? { sessionId: detail.origin.sessionId } : null,
     linkedSessionIds: Array.isArray(detail.linkedSessionIds) ? detail.linkedSessionIds : [],
@@ -144,6 +142,9 @@ export function projectWorkItemSummary(detail) {
 export function projectWorkCenterEvent(event) {
   return {
     type: event?.type || 'work_item.updated',
-    workItem: projectWorkItemSummary(event?.workItem),
+    workItem: {
+      ...projectWorkItemSummary(event?.workItem),
+      actionStats: projectActionStats(event?.workItem),
+    },
   };
 }

package/yeaft/work-center/runner.js

@@ -298,6 +298,8 @@ export class WorkItemRunner {
     });
 
     let text = '';
+    let loopCount = 0;
+    let toolCount = 0;
     try {
       for await (const event of engine.query({
         prompt: `${action.instruction}${completionContract(action)}`,
@@ -309,13 +311,22 @@ export class WorkItemRunner {
         userAlreadyPersisted: true,
         collabToolPolicy: 'single-vp',
       })) {
+        if (event?.type === 'loop') loopCount += 1;
+        else if (event?.type === 'tool_end') toolCount += 1;
         if (typeof event?.text === 'string') text += event.text;
         else if (typeof event?.delta === 'string') text += event.delta;
         else if (typeof event?.content === 'string' && event.type === 'assistant') text += event.content;
       }
+    } catch (error) {
+      error.workItemExecutionStats = { loopCount, toolCount };
+      throw error;
     } finally {
       try { engine.abort?.('work_item_run_finished'); } catch {}
     }
-    return parseStructuredResult(text, action.type);
+    return {
+      ...parseStructuredResult(text, action.type),
+      loopCount,
+      toolCount,
+    };
   }
 }

package/yeaft/work-center/store.js

@@ -4,7 +4,7 @@ import { dirname, resolve } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { normalizeEvidence } from './evidence.js';
 
-const SCHEMA_VERSION = 3;
+const SCHEMA_VERSION = 4;
 const OPEN_ACTION_STATUSES = "'ready','running','waiting'";
 const MAX_REUSABLE_CONTEXT_ITEMS = 12;
 
@@ -91,6 +91,8 @@ function mapRun(row) {
     error: row.error || null,
     reviewDecision: row.review_decision || null,
     contractPatch: parseJson(row.contract_patch, null),
+    loopCount: Math.max(0, Number(row.loop_count) || 0),
+    toolCount: Math.max(0, Number(row.tool_count) || 0),
   };
 }
 
@@ -202,7 +204,9 @@ export class WorkItemStore {
         waiting_reason TEXT,
         error TEXT,
         review_decision TEXT,
-        contract_patch TEXT
+        contract_patch TEXT,
+        loop_count INTEGER NOT NULL DEFAULT 0,
+        tool_count INTEGER NOT NULL DEFAULT 0
       );
       CREATE TABLE IF NOT EXISTS events (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -249,6 +253,12 @@ export class WorkItemStore {
     if (!hasColumn(this.db, 'runs', 'contract_patch')) {
       this.db.exec('ALTER TABLE runs ADD COLUMN contract_patch TEXT');
     }
+    if (!hasColumn(this.db, 'runs', 'loop_count')) {
+      this.db.exec('ALTER TABLE runs ADD COLUMN loop_count INTEGER NOT NULL DEFAULT 0');
+    }
+    if (!hasColumn(this.db, 'runs', 'tool_count')) {
+      this.db.exec('ALTER TABLE runs ADD COLUMN tool_count INTEGER NOT NULL DEFAULT 0');
+    }
     if (!hasColumn(this.db, 'work_items', 'workflow_snapshot')) {
       this.db.exec('ALTER TABLE work_items ADD COLUMN workflow_snapshot TEXT');
     }
@@ -780,8 +790,8 @@ export class WorkItemStore {
       }
       const now = this.now();
       this.db.prepare(`UPDATE runs SET status = ?, ended_at = ?, summary = ?, evidence = ?,
-        waiting_reason = ?, error = ?, review_decision = ?, contract_patch = ?
-        WHERE id = ?`).run(
+        waiting_reason = ?, error = ?, review_decision = ?, contract_patch = ?,
+        loop_count = ?, tool_count = ? WHERE id = ?`).run(
         result.outcome,
         now,
         result.summary || '',
@@ -790,6 +800,8 @@ export class WorkItemStore {
         result.error || null,
         result.reviewDecision || null,
         stringify(result.contractPatch || null),
+        Math.max(0, Number(result.loopCount) || 0),
+        Math.max(0, Number(result.toolCount) || 0),
         runId,
       );
       this.onTransitionStep?.('after_run_update');

package/yeaft/work-center/watcher.js

@@ -105,6 +105,8 @@ export class WorkItemWatcher {
         summary: '',
         evidence: [],
         error: err?.message || String(err),
+        loopCount: err?.workItemExecutionStats?.loopCount || 0,
+        toolCount: err?.workItemExecutionStats?.toolCount || 0,
       };
     }
     if (signal.aborted) return;