@yeaft/webchat-agent 1.0.129 → 1.0.130

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.129",
+  "version": "1.0.130",
   "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

@@ -69,12 +69,29 @@ export class WorkflowController {
       workflowTemplate: input.workflowTemplate || 'software-change',
       acceptanceCriteria: Array.isArray(input.acceptanceCriteria) ? input.acceptanceCriteria : [],
     };
-    const firstAction = input.start !== false ? initialActionFor(draft) : null;
+    let firstAction = input.start !== false ? initialActionFor(draft) : null;
+    if (firstAction && draft.reuseMemory !== false) {
+      const context = this.store.getReusableContext(draft.workDir, draft.id);
+      firstAction = {
+        ...firstAction,
+        context,
+        instruction: actionInstruction(firstAction, draft, context),
+      };
+    }
     return this.store.createWorkItem(draft, firstAction);
   }
 
   start(id) {
-    const detail = this.store.startWorkItemAtomic(id, initialActionFor);
+    const detail = this.store.startWorkItemAtomic(id, workItem => {
+      const action = initialActionFor(workItem);
+      if (workItem.reuseMemory === false) return action;
+      const context = this.store.getReusableContext(workItem.workDir, workItem.id);
+      return {
+        ...action,
+        context,
+        instruction: actionInstruction(action, workItem, context),
+      };
+    });
     if (!detail) throw new Error(`WorkItem not found: ${id}`);
     return detail;
   }
@@ -91,6 +108,35 @@ export class WorkflowController {
     return this.store.getWorkItemDetail(id);
   }
 
+  guide(id, input = {}) {
+    const guidance = typeof input.guidance === 'string' ? input.guidance.trim().slice(0, 8_000) : '';
+    if (!guidance) throw new Error('guidance is required');
+    const expected = {
+      actionId: typeof input.actionId === 'string' ? input.actionId : '',
+      revision: Number(input.revision),
+    };
+    if (!expected.actionId || !Number.isInteger(expected.revision)) {
+      throw new Error('actionId and revision are required for guidance');
+    }
+    const detail = this.store.addActionGuidance(id, guidance, expected, (workItem, previous) => {
+      const context = [...(previous.context || []), {
+        type: 'guidance',
+        role: 'user',
+        summary: guidance,
+        evidence: [],
+      }];
+      const step = { type: previous.type, requiredRole: previous.requiredRole };
+      return {
+        ...step,
+        context,
+        instruction: actionInstruction(step, workItem, context),
+        maxAttempts: previous.maxAttempts || 2,
+      };
+    });
+    if (!detail) throw new Error(`WorkItem not found: ${id}`);
+    return detail;
+  }
+
   retry(id, input = {}) {
     const answer = typeof input.answer === 'string' ? input.answer.trim().slice(0, 8_000) : '';
     const detail = this.store.retryWorkItemAtomic(id, (workItem, previous, previousRun) => {

package/yeaft/work-center/runner.js

@@ -54,6 +54,21 @@ function canonicalWorkDir(workDir) {
   return realpathSync(workDir);
 }
 
+export function resolveWorkItemWorkDir(workItem, defaultWorkDir) {
+  if (typeof workItem?.workspaceKey === 'string' && workItem.workspaceKey) {
+    const expected = path.resolve(workItem.workspaceKey);
+    const actual = canonicalWorkDir(expected);
+    if (actual !== expected) {
+      throw new Error('WorkItem canonical workspace identity changed; update its workDir before retrying');
+    }
+    return expected;
+  }
+  if (typeof workItem?.workDir === 'string' && workItem.workDir.trim()) {
+    throw new Error('WorkItem has no canonical workspace identity; update its workDir before retrying');
+  }
+  return canonicalWorkDir(path.resolve(defaultWorkDir || process.cwd()));
+}
+
 function assertPathInside(toolName, workDir, value) {
   const resolved = path.resolve(workDir, value);
   if (!isPathInsideOrEqual(workDir, resolved)) {
@@ -203,8 +218,7 @@ export class WorkItemRunner {
 
   async run({ workItem, action, run, signal, ownerBootId }) {
     const runtime = await this.runtimeProvider();
-    const rawWorkDir = workItem.workDir || runtime.defaultWorkDir || process.cwd();
-    const workDir = canonicalWorkDir(path.resolve(rawWorkDir));
+    const workDir = resolveWorkItemWorkDir(workItem, runtime.defaultWorkDir);
     const vp = copyVp(this.registry.getVp(action.requiredRole));
     if (!vp) {
       const error = new Error(`Required Work Center role is unavailable: ${action.requiredRole}`);
@@ -260,7 +274,6 @@ export class WorkItemRunner {
     });
 
     let text = '';
-    const toolEvidence = [];
     try {
       for await (const event of engine.query({
         prompt: `${action.instruction}${completionContract(action)}`,
@@ -275,18 +288,10 @@ export class WorkItemRunner {
         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;
-        if (event?.type === 'tool_end') {
-          toolEvidence.push({
-            tool: event.name,
-            isError: !!event.isError,
-          });
-        }
       }
     } finally {
       try { engine.abort?.('work_item_run_finished'); } catch {}
     }
-    const result = parseStructuredResult(text, action.type);
-    result.evidence = [...result.evidence, ...toolEvidence].slice(-100);
-    return result;
+    return parseStructuredResult(text, action.type);
   }
 }

package/yeaft/work-center/service.js

@@ -47,6 +47,7 @@ export class WorkCenterService {
             : [],
           workflowTemplate: payload.workflowTemplate || 'software-change',
           workDir: typeof payload.workDir === 'string' ? payload.workDir.trim() : '',
+          reuseMemory: payload.reuseMemory !== false,
           origin: payload.origin && typeof payload.origin === 'object'
             ? {
                 sessionId: typeof payload.origin.sessionId === 'string' ? payload.origin.sessionId : null,
@@ -82,6 +83,17 @@ export class WorkCenterService {
         this.#emit({ type: 'work_item.cancelled', workItem: detail });
         return detail;
       }
+      case 'guide': {
+        const id = requiredString(payload.id, 'id');
+        const detail = this.controller.guide(id, {
+          guidance: typeof payload.guidance === 'string' ? payload.guidance : '',
+          actionId: typeof payload.actionId === 'string' ? payload.actionId : '',
+          revision: payload.revision,
+        });
+        this.watcher.abortInvalidWorkItemRuns(id);
+        this.#emit({ type: 'action.guidance_added', workItem: detail });
+        return detail;
+      }
       case 'retry': {
         const detail = this.controller.retry(requiredString(payload.id, 'id'), {
           answer: typeof payload.answer === 'string' ? payload.answer : '',

package/yeaft/work-center/store.js

@@ -1,11 +1,17 @@
 import { DatabaseSync } from 'node:sqlite';
-import { mkdirSync } from 'node:fs';
-import { dirname } from 'node:path';
+import { mkdirSync, realpathSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { normalizeEvidence } from './evidence.js';
 
-const SCHEMA_VERSION = 2;
+const SCHEMA_VERSION = 3;
 const OPEN_ACTION_STATUSES = "'ready','running','waiting'";
+const MAX_REUSABLE_CONTEXT_ITEMS = 12;
+
+function canonicalWorkspaceKey(workDir) {
+  if (typeof workDir !== 'string' || !workDir.trim()) return '';
+  try { return realpathSync(resolve(workDir.trim())); } catch { return ''; }
+}
 
 function parseJson(value, fallback) {
   if (typeof value !== 'string' || !value) return fallback;
@@ -29,6 +35,8 @@ function mapWorkItem(row) {
     currentActionId: row.current_action_id || null,
     currentRunId: row.current_run_id || null,
     workDir: row.work_dir || '',
+    workspaceKey: row.workspace_key || '',
+    reuseMemory: row.reuse_memory !== 0,
     origin: parseJson(row.origin, null),
     linkedSessionIds: parseJson(row.linked_session_ids, []),
     createdAt: row.created_at,
@@ -142,6 +150,8 @@ export class WorkItemStore {
         current_action_id TEXT,
         current_run_id TEXT,
         work_dir TEXT NOT NULL DEFAULT '',
+        workspace_key TEXT NOT NULL DEFAULT '',
+        reuse_memory INTEGER NOT NULL DEFAULT 1,
         origin TEXT,
         linked_session_ids TEXT NOT NULL DEFAULT '[]',
         created_at INTEGER NOT NULL,
@@ -202,7 +212,20 @@ export class WorkItemStore {
     `);
 
     // The feature shipped first as an unmerged PR, but keep the store tolerant
-    // of a v1 database created by a review build.
+    // of databases created by review builds.
+    if (!hasColumn(this.db, 'work_items', 'workspace_key')) {
+      withTransaction(this.db, () => {
+        this.db.exec("ALTER TABLE work_items ADD COLUMN workspace_key TEXT NOT NULL DEFAULT ''");
+        const update = this.db.prepare('UPDATE work_items SET workspace_key = ? WHERE id = ?');
+        for (const row of this.db.prepare("SELECT id, work_dir FROM work_items WHERE work_dir != ''").all()) {
+          const workspaceKey = canonicalWorkspaceKey(row.work_dir);
+          if (workspaceKey) update.run(workspaceKey, row.id);
+        }
+      });
+    }
+    if (!hasColumn(this.db, 'work_items', 'reuse_memory')) {
+      this.db.exec('ALTER TABLE work_items ADD COLUMN reuse_memory INTEGER NOT NULL DEFAULT 1');
+    }
     if (!hasColumn(this.db, 'actions', 'context')) {
       this.db.exec("ALTER TABLE actions ADD COLUMN context TEXT NOT NULL DEFAULT '[]'");
     }
@@ -244,11 +267,12 @@ export class WorkItemStore {
     return withTransaction(this.db, () => {
       const now = this.now();
       const id = input.id || randomUUID();
+      const workspaceKey = canonicalWorkspaceKey(input.workDir);
       this.db.prepare(`INSERT INTO work_items
         (id, revision, title, goal, acceptance_criteria, workflow_template, status,
-         current_action_id, current_run_id, work_dir, origin, linked_session_ids,
+         current_action_id, current_run_id, work_dir, workspace_key, reuse_memory, origin, linked_session_ids,
          created_at, updated_at)
-        VALUES (?, 1, ?, ?, ?, ?, ?, NULL, NULL, ?, ?, ?, ?, ?)`).run(
+        VALUES (?, 1, ?, ?, ?, ?, ?, NULL, NULL, ?, ?, ?, ?, ?, ?, ?)`).run(
         id,
         input.title,
         input.goal,
@@ -256,6 +280,8 @@ export class WorkItemStore {
         input.workflowTemplate || 'software-change',
         firstAction ? 'ready' : 'draft',
         input.workDir || '',
+        workspaceKey,
+        input.reuseMemory === false ? 0 : 1,
         stringify(input.origin || null),
         stringify(input.linkedSessionIds || []),
         now,
@@ -366,6 +392,64 @@ export class WorkItemStore {
     };
   }
 
+  getReusableContext(workDir, excludeWorkItemId = null) {
+    const workspaceKey = canonicalWorkspaceKey(workDir);
+    if (!workspaceKey) return [];
+    const rows = this.db.prepare(`SELECT r.*, a.type AS action_type, a.required_role,
+        w.title AS source_title
+      FROM runs r
+      JOIN actions a ON a.id = r.action_id
+      JOIN work_items w ON w.id = r.work_item_id
+      WHERE w.workspace_key = ? AND w.reuse_memory = 1 AND w.id != ? AND w.status = 'done'
+        AND r.status = 'completed' AND length(trim(COALESCE(r.summary, ''))) > 0
+      ORDER BY r.ended_at DESC, r.started_at DESC
+      LIMIT ?`).all(workspaceKey, excludeWorkItemId || '', MAX_REUSABLE_CONTEXT_ITEMS);
+    return rows.reverse().map(row => {
+      const run = mapRun(row);
+      return {
+        type: row.action_type,
+        role: row.required_role,
+        summary: run.summary,
+        evidence: run.evidence,
+        reviewDecision: run.reviewDecision,
+        sourceTitle: row.source_title,
+      };
+    });
+  }
+
+  addActionGuidance(id, guidance, expected, makeAction) {
+    return withTransaction(this.db, () => {
+      const workItem = this.getWorkItem(id);
+      if (!workItem) return null;
+      if (workItem.currentActionId !== expected.actionId || workItem.revision !== expected.revision) {
+        throw new Error('Action changed before guidance was applied; refresh and try again');
+      }
+      if (!['ready', 'running'].includes(workItem.status)) {
+        throw new Error(`WorkItem in ${workItem.status} cannot accept Action guidance`);
+      }
+      const previous = workItem.currentActionId ? this.getAction(workItem.currentActionId) : null;
+      if (!previous || !['ready', 'running'].includes(previous.status)) {
+        throw new Error('WorkItem has no active Action for guidance');
+      }
+      const now = this.now();
+      this.#invalidateExecution(
+        workItem,
+        'superseded',
+        'superseded',
+        'Action restarted after user guidance',
+        now,
+      );
+      const action = this.#insertAction(id, {
+        ...makeAction(workItem, previous),
+        contractRevision: workItem.revision,
+      }, this.#nextSequence(id), now);
+      this.db.prepare(`UPDATE work_items SET status = 'ready', current_action_id = ?,
+        current_run_id = NULL, updated_at = ? WHERE id = ?`).run(action.id, now, id);
+      this.appendEvent(id, 'action.guidance_added', { guidance }, { actionId: action.id });
+      return this.getWorkItemDetail(id);
+    });
+  }
+
   #invalidateExecution(workItem, actionStatus, runStatus, reason, now) {
     if (workItem.currentRunId) {
       this.db.prepare(`UPDATE runs SET status = ?, ended_at = ?, error = ?
@@ -403,11 +487,12 @@ export class WorkItemStore {
         );
       }
       this.db.prepare(`UPDATE work_items SET title = ?, goal = ?, acceptance_criteria = ?,
-        work_dir = ?, revision = ?, updated_at = ? WHERE id = ?`).run(
+        work_dir = ?, workspace_key = ?, revision = ?, updated_at = ? WHERE id = ?`).run(
         next.title,
         next.goal,
         stringify(next.acceptanceCriteria),
         next.workDir,
+        canonicalWorkspaceKey(next.workDir),
         revision,
         now,
         id,

package/yeaft/work-center/workflow.js

@@ -54,9 +54,10 @@ function renderContext(context = []) {
     const decision = entry.reviewDecision ? `\nReview decision: ${entry.reviewDecision}` : '';
     const waitingReason = entry.waitingReason ? `\nWaiting reason: ${entry.waitingReason}` : '';
     const answer = entry.answer ? `\nUser answer: ${entry.answer}` : '';
-    return `### ${entry.type} (${entry.role || 'unknown role'})\n${entry.summary || '(no summary)'}${decision}${waitingReason}${answer}${evidence}`;
+    const source = entry.sourceTitle ? ` from ${entry.sourceTitle}` : '';
+    return `### ${entry.type}${source} (${entry.role || 'unknown role'})\n${entry.summary || '(no summary)'}${decision}${waitingReason}${answer}${evidence}`;
   });
-  return `\n\nPrior Action results:\n${blocks.join('\n\n')}`;
+  return `\n\nReusable Work Center context and prior Action results:\n${blocks.join('\n\n')}`;
 }
 
 export function actionInstruction(step, workItem, context = []) {