@yeaft/webchat-agent 1.0.174 → 1.0.177

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.174",
+  "version": "1.0.177",
   "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/dream/state.js

@@ -248,20 +248,26 @@ export async function readScopeDreamMarker(memoryMdAbsPath) {
  */
 export function withDreamMarker(memoryMd, fields) {
   const block = renderDreamBlock(fields);
-  const body = String(memoryMd || '');
-  if (body.includes(DREAM_BLOCK_OPEN) && body.includes(DREAM_BLOCK_CLOSE)) {
-    // Replace existing block.
-    return body.replace(
-      new RegExp(`${escapeRe(DREAM_BLOCK_OPEN)}[\\s\\S]*?${escapeRe(DREAM_BLOCK_CLOSE)}`),
-      block,
-    );
-  }
+  const body = stripDreamMarker(memoryMd);
   // Append. Ensure exactly one newline before the block.
   const trimmed = body.replace(/\s+$/, '');
   const sep = trimmed.length === 0 ? '' : '\n\n';
   return `${trimmed}${sep}${block}\n`;
 }
 
+/**
+ * Remove all per-scope dream-state blocks from a markdown blob.
+ *
+ * @param {string} body
+ * @returns {string}
+ */
+export function stripDreamMarker(body) {
+  return String(body || '').replace(
+    new RegExp(`${escapeRe(DREAM_BLOCK_OPEN)}[\\s\\S]*?${escapeRe(DREAM_BLOCK_CLOSE)}`, 'g'),
+    '',
+  ).trim();
+}
+
 /**
  * Extract the contents of the dream-state block (between the two HTML
  * comments). Returns null if the block isn't present.

package/yeaft/engine.js

@@ -32,6 +32,7 @@ import { archiveTurn } from './archive/turn-archive.js';
 import { archiveToolResults } from './archive/tool-results.js';
 import { readSummary as readScopeSummary } from './memory/store.js';
 import { runAdjust } from './memory/adjust.js';
+import { cleanMemoryPromptText } from './memory/prompt-cleanup.js';
 import { isVpSeedBackfillStub } from './memory/seed-backfill.js';
 import { runStopHooks } from './stop-hooks.js';
 import { perfNowMs, recordAgentPerfTrace } from './perf-trace.js';
@@ -389,13 +390,17 @@ export function shouldAllowGroupReflection({
 export function buildResidentEntries(args) {
   const summaries = (args && args.summaries) || {};
   const out = [];
-  if (summaries.user) out.push({ scope: 'user', summary: summaries.user });
-  if (args.sessionId && summaries.session) {
-    out.push({ scope: `sessions/${args.sessionId}`, summary: summaries.session });
+  const userSummary = cleanMemoryPromptText(summaries.user);
+  const sessionSummary = cleanMemoryPromptText(summaries.session);
+  const vpSummary = cleanMemoryPromptText(summaries.vp);
+  if (userSummary) out.push({ scope: 'user', summary: userSummary });
+  if (args.sessionId && sessionSummary) {
+    out.push({ scope: `sessions/${args.sessionId}`, summary: sessionSummary });
   }
   if (args.sessionId && Array.isArray(summaries.topics)) {
     for (const topic of summaries.topics) {
-      if (topic?.scope && topic?.summary) out.push({ scope: topic.scope, summary: topic.summary });
+      const summary = cleanMemoryPromptText(topic?.summary);
+      if (topic?.scope && summary) out.push({ scope: topic.scope, summary });
     }
   }
   // VP per-session isolation (2026-06-09): the VP summary scope MUST be
@@ -407,8 +412,8 @@ export function buildResidentEntries(args) {
   // by id rather than by full scope path. The session-qualified form
   // makes the per-session boundary explicit and matches the on-disk
   // layout 1:1.
-  if (args.sessionId && args.ownVpId && summaries.vp && !isVpSeedBackfillStub(summaries.vp)) {
-    out.push({ scope: `sessions/${args.sessionId}/vp/${args.ownVpId}`, summary: summaries.vp });
+  if (args.sessionId && args.ownVpId && vpSummary && !isVpSeedBackfillStub(vpSummary)) {
+    out.push({ scope: `sessions/${args.sessionId}/vp/${args.ownVpId}`, summary: vpSummary });
   }
   return out;
 }
@@ -1940,8 +1945,8 @@ export class Engine {
         ))
         .map(e => ({
           scope: e.scope,
-          summary: String(e.summary).slice(0, 4000),
-          truncated: String(e.summary).length > 4000,
+          summary: String(e.summary),
+          truncated: false,
           source: 'resident-summary',
         }))
       : [];

package/yeaft/memory/ams.js

@@ -16,7 +16,8 @@
  * vpId at construction.
  */
 
-import { approxTokens, packWithinBudget } from './budget.js';
+import { approxTokens } from './budget.js';
+import { cleanMemoryPromptText, isDuplicateMemoryText, rememberMemoryText } from './prompt-cleanup.js';
 import { isVpForeign } from './store.js';
 
 const RECENT_DEFAULT_CAPACITY = 64;
@@ -69,8 +70,9 @@ export class ActiveMemorySet {
     this._resident.clear();
     for (const e of entries) {
       if (this._isForeignVp(e.scope)) continue;
-      if (!e.summary) continue;
-      this._resident.set(e.scope, e.summary);
+      const summary = cleanMemoryPromptText(e.summary);
+      if (!summary) continue;
+      this._resident.set(e.scope, summary);
     }
   }
 
@@ -85,8 +87,10 @@ export class ActiveMemorySet {
   touchRecent(seg) {
     if (!seg || !seg.id) return;
     if (this._isForeignVp(seg.scope)) return;
+    const body = cleanMemoryPromptText(seg.body);
+    if (!body) return;
     if (this._recent.has(seg.id)) this._recent.delete(seg.id);
-    this._recent.set(seg.id, { seg, ts: Date.now() });
+    this._recent.set(seg.id, { seg: { ...seg, body }, ts: Date.now() });
     while (this._recent.size > this.recentCapacity) {
       const firstKey = this._recent.keys().next().value;
       this._recent.delete(firstKey);
@@ -104,7 +108,9 @@ export class ActiveMemorySet {
     this._onDemand.clear();
     for (const seg of segments) {
       if (this._isForeignVp(seg.scope)) continue;
-      this._onDemand.set(seg.id, seg);
+      const body = cleanMemoryPromptText(seg.body);
+      if (!body) continue;
+      this._onDemand.set(seg.id, { ...seg, body });
     }
   }
 
@@ -116,7 +122,9 @@ export class ActiveMemorySet {
   addOnDemand(segments) {
     for (const seg of segments) {
       if (this._isForeignVp(seg.scope)) continue;
-      this._onDemand.set(seg.id, seg);
+      const body = cleanMemoryPromptText(seg.body);
+      if (!body) continue;
+      this._onDemand.set(seg.id, { ...seg, body });
     }
   }
 
@@ -139,31 +147,40 @@ export class ActiveMemorySet {
    * @returns {AmsSnapshot}
    */
   snapshot() {
+    const seenPromptText = new Set();
+
     // Resident: pack scopes by priority order (caller provides via insert
     // order — current group's own vp first, then user, etc.).
-    const resEntries = [...this._resident.entries()].map(([scope, summary]) => ({
-      scope, summary,
-    }));
-    const { picked: resPicked, cost: resCost } = packWithinBudget(
-      resEntries, this.budget.resident,
-      e => approxTokens(e.summary),
-    );
+    const { picked: resPicked, cost: resCost } = pickMemoryItems({
+      items: [...this._resident.entries()].map(([scope, summary]) => ({
+        scope, summary: cleanMemoryPromptText(summary),
+      })),
+      budget: this.budget.resident,
+      seen: seenPromptText,
+      textOf: e => e.summary,
+      costOf: e => approxTokens(e.summary),
+    });
 
     // Recent: insertion order is oldest-first; we want newest first.
-    const recentArr = [...this._recent.values()]
-      .reverse()
-      .map(e => e.seg);
-    const { picked: recPicked, cost: recCost } = packWithinBudget(
-      recentArr, this.budget.recent,
-      seg => approxTokens(seg.body),
-    );
+    const { picked: recPicked, cost: recCost } = pickMemoryItems({
+      items: [...this._recent.values()]
+        .reverse()
+        .map(e => ({ ...e.seg, body: cleanMemoryPromptText(e.seg?.body) })),
+      budget: this.budget.recent,
+      seen: seenPromptText,
+      textOf: seg => seg.body,
+      costOf: seg => approxTokens(seg.body),
+    });
 
     // OnDemand: insertion order from caller (already FTS-ranked).
-    const odArr = [...this._onDemand.values()];
-    const { picked: odPicked, cost: odCost } = packWithinBudget(
-      odArr, this.budget.onDemand,
-      seg => approxTokens(seg.body),
-    );
+    const { picked: odPicked, cost: odCost } = pickMemoryItems({
+      items: [...this._onDemand.values()]
+        .map(seg => ({ ...seg, body: cleanMemoryPromptText(seg?.body) })),
+      budget: this.budget.onDemand,
+      seen: seenPromptText,
+      textOf: seg => seg.body,
+      costOf: seg => approxTokens(seg.body),
+    });
 
     return {
       resident: resPicked,
@@ -193,3 +210,18 @@ export class ActiveMemorySet {
     return isVpForeign(scope, this.ownVpId);
   }
 }
+
+function pickMemoryItems({ items, budget, seen, textOf, costOf }) {
+  const picked = [];
+  let cost = 0;
+  for (const item of items) {
+    const text = textOf(item);
+    if (!text || isDuplicateMemoryText(text, seen)) continue;
+    const itemCost = costOf(item);
+    if (cost + itemCost > budget) continue;
+    picked.push(item);
+    cost += itemCost;
+    rememberMemoryText(text, seen);
+  }
+  return { picked, cost };
+}

package/yeaft/memory/prompt-cleanup.js

@@ -0,0 +1,87 @@
+/**
+ * memory/prompt-cleanup.js — prompt-facing memory text hygiene.
+ *
+ * Disk memory can carry operational metadata such as the per-scope Dream
+ * marker. That metadata is useful for schedulers, not for the model. Keep the
+ * storage schema compatible and clean only at read / prompt boundaries.
+ */
+
+const DREAM_STATE_BLOCK_RE = /<!--\s*dream-state\s*-->[\s\S]*?<!--\s*\/dream-state\s*-->/gi;
+
+/**
+ * Remove Dream scheduler metadata blocks from memory text.
+ *
+ * @param {string} text
+ * @returns {string}
+ */
+export function stripDreamStateBlocks(text) {
+  return String(text || '').replace(DREAM_STATE_BLOCK_RE, '').trim();
+}
+
+/**
+ * Clean text before it is eligible for prompt injection.
+ *
+ * @param {string} text
+ * @returns {string}
+ */
+export function cleanMemoryPromptText(text) {
+  return stripDreamStateBlocks(text)
+    .replace(/[ \t]+\n/g, '\n')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+}
+
+/**
+ * Normalized key for conservative prompt dedupe. This is intentionally simple:
+ * exact semantic clustering belongs in Dream; prompt assembly only removes
+ * obvious repeats and near-contained copies.
+ *
+ * @param {string} text
+ * @returns {string}
+ */
+export function memoryDedupeKey(text) {
+  return cleanMemoryPromptText(text)
+    .toLowerCase()
+    .replace(/[`*_>#\-\[\]().,，。:：;；!！?？"'“”‘’]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+/**
+ * Whether a candidate is redundant with text already emitted to the prompt.
+ * Does not mutate `seen`; call `rememberMemoryText` only after the candidate
+ * is actually selected into the snapshot.
+ *
+ * @param {string} candidate
+ * @param {Set<string>} seen
+ * @returns {boolean}
+ */
+export function isDuplicateMemoryText(candidate, seen) {
+  const key = memoryDedupeKey(candidate);
+  if (!key) return true;
+  if (seen.has(key)) return true;
+
+  // Avoid dropping tiny generic snippets via containment. A candidate is
+  // redundant only when already-selected text covers it. If the candidate is
+  // longer and contains the selected text, keep it: actual memory often carries
+  // details that a resident summary compressed away.
+  if (key.length >= 80) {
+    for (const existing of seen) {
+      if (existing.length >= 80 && existing.includes(key)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+/**
+ * Mark text as emitted to the prompt for later dedupe checks.
+ *
+ * @param {string} text
+ * @param {Set<string>} seen
+ */
+export function rememberMemoryText(text, seen) {
+  const key = memoryDedupeKey(text);
+  if (key) seen.add(key);
+}

package/yeaft/memory/segment-store.js

@@ -19,6 +19,7 @@ import {
   readdirSync, statSync, renameSync,
 } from 'node:fs';
 import { join, dirname, relative, sep } from 'node:path';
+import { stripDreamStateBlocks } from './prompt-cleanup.js';
 import { parseSegments, serializeSegments } from './segment.js';
 
 /**
@@ -32,7 +33,7 @@ export function readScope(memoryRoot, scope) {
   const path = scopeFilePath(memoryRoot, scope);
   if (!existsSync(path)) return [];
   const text = readFileSync(path, 'utf8');
-  return parseSegments(text, { defaultScope: scope });
+  return parseSegments(stripDreamStateBlocks(text), { defaultScope: scope });
 }
 
 /**

package/yeaft/work-center/controller.js

@@ -202,6 +202,9 @@ export class WorkflowController {
         assignmentPolicy: previous.assignmentPolicy,
         modelPolicy: previous.modelPolicy,
         requiredRole: previous.requiredRole,
+        dependsOnStageIds: previous.dependsOnStageIds,
+        workspaceMode: previous.workspaceMode,
+        changesRequestedStageId: previous.changesRequestedStageId,
         brief: previous.brief,
       };
       return {
@@ -237,7 +240,12 @@ export class WorkflowController {
     if (!['waiting', 'needs_attention'].includes(workItem.status)) {
       throw new Error(`WorkItem in ${workItem.status} cannot accept Action input`);
     }
-    if (workItem.currentActionId !== input.actionId || workItem.revision !== input.revision) {
+    const targetAction = this.store.getAction(input.actionId);
+    const graphMode = workItem.workflowSnapshot?.executionMode === 'graph';
+    const targetMatches = graphMode
+      ? targetAction?.workItemId === id && ['waiting', 'failed'].includes(targetAction.status)
+      : workItem.currentActionId === input.actionId;
+    if (!targetMatches || workItem.revision !== input.revision) {
       throw new Error('Action changed before input was applied; refresh and try again');
     }
     return this.retry(id, {
@@ -337,7 +345,7 @@ export class WorkflowController {
       ({ action, workItem }) => {
         if (result.outcome === 'waiting') {
           return {
-            actionStatus: 'completed',
+            actionStatus: 'waiting',
             workItemStatus: 'waiting',
             keepCurrentAction: true,
             eventType: 'action.waiting',

package/yeaft/work-center/store.js

@@ -770,21 +770,35 @@ export class WorkItemStore {
         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, {
+      const revision = workItem.revision + 1;
+      const replacement = {
         ...makeAction(workItem, previous),
-        contractRevision: workItem.revision,
-      }, this.#nextSequence(id), now);
+        contractRevision: previous.contractRevision,
+      };
+      let action;
+      if (workItem.workflowSnapshot?.executionMode === 'graph') {
+        action = this.#resetGraphFromStage(
+          id,
+          previous.stageId,
+          replacement,
+          'Action restarted after user guidance',
+          now,
+        );
+      } else {
+        this.#invalidateExecution(
+          workItem,
+          'superseded',
+          'superseded',
+          'Action restarted after user guidance',
+          now,
+        );
+        action = this.#insertAction(id, replacement, this.#nextSequence(id), now);
+      }
       this.db.prepare(`UPDATE work_items SET status = 'ready', current_action_id = ?,
-        current_run_id = NULL, attachments = ?, updated_at = ? WHERE id = ?`).run(
+        current_run_id = NULL, attachments = ?, revision = ?, updated_at = ? WHERE id = ?`).run(
         action.id,
         stringify(Array.isArray(attachments) ? attachments : workItem.attachments),
+        revision,
         now,
         id,
       );
@@ -922,19 +936,29 @@ export class WorkItemStore {
       if (!['waiting', 'needs_attention'].includes(workItem.status)) {
         throw new Error(`WorkItem in ${workItem.status} does not need retry`);
       }
+      const graphMode = workItem.workflowSnapshot?.executionMode === 'graph';
+      let previous = workItem.currentActionId ? this.getAction(workItem.currentActionId) : null;
       if (options.expected) {
-        if (workItem.currentActionId !== options.expected.actionId || workItem.revision !== options.expected.revision) {
+        const expectedAction = this.getAction(options.expected.actionId);
+        const expectedMatches = graphMode
+          ? expectedAction?.workItemId === id && ['waiting', 'failed'].includes(expectedAction.status)
+          : workItem.currentActionId === options.expected.actionId;
+        if (!expectedMatches || workItem.revision !== options.expected.revision) {
           throw new Error('Action changed before input was applied; refresh and try again');
         }
+        previous = expectedAction;
       }
-      const previous = workItem.currentActionId ? this.getAction(workItem.currentActionId) : null;
       const previousRun = previous
         ? mapRun(this.db.prepare(`SELECT * FROM runs WHERE work_item_id = ? AND action_id = ?
             AND status != 'running' ORDER BY ended_at DESC, started_at DESC LIMIT 1`).get(id, previous.id))
         : null;
       const now = this.now();
-      const replacement = makeAction(workItem, previous, previousRun);
-      if (workItem.workflowSnapshot?.executionMode === 'graph') {
+      const revision = options.expected ? workItem.revision + 1 : workItem.revision;
+      const replacement = {
+        ...makeAction(workItem, previous, previousRun),
+        contractRevision: previous?.contractRevision ?? workItem.revision,
+      };
+      if (graphMode) {
         if (!previous) throw new Error('WorkItem graph retry target is missing');
         const action = this.#resetGraphFromStage(
           id,
@@ -944,18 +968,29 @@ export class WorkItemStore {
           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, 'work_item.retried', { targetStageId: action.stageId }, { actionId: action.id });
+          current_run_id = NULL, attachments = ?, revision = ?, updated_at = ? WHERE id = ?`).run(
+          action.id,
+          stringify(Array.isArray(options.attachments) ? options.attachments : workItem.attachments),
+          revision,
+          now,
+          id,
+        );
+        const inputEvent = options.inputEvent && typeof options.inputEvent === 'object'
+          ? options.inputEvent
+          : null;
+        if (inputEvent) {
+          this.appendEvent(id, 'action.input_added', inputEvent, { actionId: action.id });
+        } else {
+          this.appendEvent(id, 'work_item.retried', { targetStageId: action.stageId }, { actionId: action.id });
+        }
         return this.getWorkItemDetail(id);
       }
-      const action = this.#insertAction(id, {
-        ...replacement,
-        contractRevision: workItem.revision,
-      }, this.#nextSequence(id), now);
+      const action = this.#insertAction(id, replacement, this.#nextSequence(id), now);
       this.db.prepare(`UPDATE work_items SET status = 'ready', current_action_id = ?,
-        current_run_id = NULL, attachments = ?, updated_at = ? WHERE id = ?`).run(
+        current_run_id = NULL, attachments = ?, revision = ?, updated_at = ? WHERE id = ?`).run(
         action.id,
         stringify(Array.isArray(options.attachments) ? options.attachments : workItem.attachments),
+        revision,
         now,
         id,
       );