@yeaft/webchat-agent 1.0.457 → 1.0.458

package/local-runtime/version.json

@@ -1 +1 @@
-{"version":"1.0.457"}
+{"version":"1.0.458"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.457",
+  "version": "1.0.458",
   "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/segment-extract.js

@@ -1,9 +1,9 @@
 /**
  * dream/segment-extract.js.
  *
- * Extract atomic evidence segments for scopes touched by a Dream pass and
- * persist them through memory/segment-store. Dream Apply separately maintains
- * canonical content.md and the short catalog summary.md.
+ * Extract atomic evidence segments only for scopes successfully touched by a
+ * Dream pass and persist them through memory/segment-store. Dream Apply
+ * separately maintains canonical content.md and the short catalog summary.md.
  */
 
 import { readScope, writeScope } from '../memory/segment-store.js';
@@ -144,7 +144,7 @@ function templateVarsForScope(scope, sessionId) {
 }
 
 function normalizeTargetScopes(sessionId, targets) {
-  const out = new Set(['user', `sessions/${sessionId}`, `sessions/${sessionId}/user`]);
+  const out = new Set();
   for (const target of targets) {
     if (typeof target !== 'string') continue;
     const clean = target.trim();

package/yeaft/dream/triage.js

@@ -1,3 +1,5 @@
+import { inspect } from 'util';
+
 import { isValidTopic } from '../memory/store.js';
 /**
  * dream/triage.js.
@@ -6,9 +8,10 @@ import { isValidTopic } from '../memory/store.js';
  * The decision is two-staged on purpose:
  *
  *   1. **Hard rules** (this module, no LLM): everything we can determine
- *      from message metadata. Always include the active session, every VP
- *      that spoke as an assistant in the diff, and `user` (so painted-over
- *      user-profile signals can't be missed). (Feature scope was dropped
+ *      from message metadata. Always include the active session and every VP
+ *      that spoke as an assistant in the diff. User-profile scopes are not a
+ *      structural property, so they are added only when soft classification
+ *      confirms a durable profile signal. (Feature scope was dropped
  *      2026-05-13 along with the rest of the Feature system.)
  *
  *   2. **Soft classification** (LLM, two passes):
@@ -18,14 +21,15 @@ import { isValidTopic } from '../memory/store.js';
  *                              it to an exact existing path or propose
  *                              a new ≤2-level path.
  *
- *      VP / group are deliberately NOT asked of the LLM — Hard Rules
+ *      VP / Session are deliberately NOT asked of the LLM — Hard Rules
  *      already cover them, and giving the LLM a chance to drop a
  *      structurally-required scope would weaken the contract.
  *
- *      `user_profile_signals === true` does not need Pass-2 either: the
- *      Hard Rule already added `user` and Apply itself decides whether
- *      to actually rewrite anything (an UPDATE with no relevant content
- *      reads as a no-op rewrite of the existing memory).
+ *      `user_profile_signals === true` does not need Pass-2: it directly
+ *      adds the global `user` scope and, for a real collaborative Session,
+ *      the Session-local `sessions/<id>/user` scope. Keeping those scopes
+ *      out when the classifier says false avoids two Apply rewrites and two
+ *      extraction requests for ordinary task-focused conversation.
  *
  * The LLM is injected as a callable: `llm({ pass, prompt, system })` →
  * Promise<string>. Tests pass a stub; runner injects the real adapter.
@@ -63,8 +67,8 @@ export function applyHardRules({ sessionId, chatId, messages }) {
   const out = new Map();
   const add = (scope) => { if (!out.has(scope)) out.set(scope, { kind: 'update', scope }); };
 
-  // global user is always in.
-  add('user');
+  // User-profile scopes are content-dependent and are added by soft
+  // classification only when the diff contains a durable profile signal.
 
   // chat path takes precedence: chat sessions have no collaborative session context.
   if (chatId) {
@@ -84,7 +88,6 @@ export function applyHardRules({ sessionId, chatId, messages }) {
   // active collaborative session, except the virtual _no-session bucket.
   if (sessionId && sessionId !== '_no-session') {
     add(`sessions/${sessionId}`);
-    add(`sessions/${sessionId}/user`);
   }
 
   for (const m of (messages || [])) {
@@ -159,18 +162,21 @@ export async function classifySoft({ root, sessionId, messages, topicSummaries,
   const pass1Prompt = buildPass1Prompt({ sessionId, messages, topicSummaries, language, maxPromptChars });
   const pass1Raw = await llm({ pass: 'triage-pass1', prompt: pass1Prompt, system: triageSystem(language) });
   const pass1 = parseJsonSafe(pass1Raw);
+  if (!isValidPass1(pass1)) {
+    throw triageContractError('Pass-1', pass1Raw);
+  }
   const out = [];
 
-  // user_profile_signals: covered by hard rules; we only emit explicit
-  // user action here when Pass-1 says yes (idempotent if hard rules
-  // already added it).
-  if (pass1 && pass1.user_profile_signals === true) {
+  // User-profile scopes are expensive shared-memory rewrites, not structural
+  // Session scopes. Route to them only when Pass-1 finds a durable signal.
+  if (pass1.user_profile_signals) {
     out.push({ kind: 'update', scope: 'user' });
+    if (sessionId && sessionId !== '_no-session') {
+      out.push({ kind: 'update', scope: `sessions/${sessionId}/user` });
+    }
   }
 
-  const topicDescriptions = (pass1 && Array.isArray(pass1.topics)) ? pass1.topics : [];
-  for (const description of topicDescriptions) {
-    if (typeof description !== 'string' || !description.trim()) continue;
+  for (const description of pass1.topics) {
     const pass2Prompt = buildPass2Prompt({
       description: description.trim(),
       existingTopics: topicSummaries || [],
@@ -179,20 +185,18 @@ export async function classifySoft({ root, sessionId, messages, topicSummaries,
     });
     const pass2Raw = await llm({ pass: 'triage-pass2', prompt: pass2Prompt, system: triageSystem(language) });
     const pass2 = parseJsonSafe(pass2Raw);
-    if (!pass2 || !pass2.decision) continue;
+    if (!isValidPass2(pass2, { sessionId, topicSummaries })) {
+      throw triageContractError('Pass-2', pass2Raw);
+    }
     if (pass2.decision === 'none') continue;
-    const path = String(pass2.path || '').trim();
-    if (!path) continue;
-    const segs = path.split('/').filter(Boolean);
-    if (!sessionId || sessionId === '_no-session') continue;
-    if (!isValidTopic({ kind: 'session-topic', sessionId, path: segs })) continue;
+    const path = pass2.path;
     const redirected = root
-      ? resolveTopicRedirect(root, sessionId, segs.join('/'))
-      : segs.join('/');
+      ? resolveTopicRedirect(root, sessionId, path)
+      : path;
     const scope = `sessions/${sessionId}/topic/${redirected}`;
     if (pass2.decision === 'match') {
       out.push({ kind: 'update', scope });
-    } else if (pass2.decision === 'new') {
+    } else {
       out.push({ kind: 'create', scope });
     }
   }
@@ -268,6 +272,58 @@ function oneLine(s) {
   return String(s || '').replace(/\s+/g, ' ').trim().slice(0, 200);
 }
 
+function isPlainObject(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function hasExactKeys(value, expected) {
+  const keys = Object.keys(value).sort();
+  return keys.length === expected.length && keys.every((key, index) => key === expected[index]);
+}
+
+function isValidPass1(value) {
+  if (!isPlainObject(value)
+    || !hasExactKeys(value, ['topics', 'trivial_only', 'user_profile_signals'])
+    || typeof value.user_profile_signals !== 'boolean'
+    || typeof value.trivial_only !== 'boolean'
+    || !Array.isArray(value.topics)
+    || !value.topics.every(topic => typeof topic === 'string' && topic.trim().length > 0)) {
+    return false;
+  }
+  return !value.trivial_only || (!value.user_profile_signals && value.topics.length === 0);
+}
+
+function isValidPass2(value, { sessionId, topicSummaries }) {
+  if (!isPlainObject(value) || !['match', 'new', 'none'].includes(value.decision)) return false;
+  if (value.decision === 'none') {
+    return hasExactKeys(value, ['decision']);
+  }
+  if (!hasExactKeys(value, ['decision', 'path'])
+    || !sessionId
+    || sessionId === '_no-session'
+    || typeof value.path !== 'string'
+    || value.path !== value.path.trim()) {
+    return false;
+  }
+  const path = value.path;
+  const segments = path.split('/');
+  if (!isValidTopic({ kind: 'session-topic', sessionId, path: segments })) return false;
+  const pathExists = (topicSummaries || []).some(topic => topic?.path === path);
+  return value.decision === 'match' ? pathExists : !pathExists;
+}
+
+function triageContractError(pass, raw) {
+  const err = new Error(`triage: ${pass} returned malformed JSON`);
+  err.rawSnippet = rawResponseSnippet(raw);
+  return err;
+}
+
+function rawResponseSnippet(raw) {
+  if (typeof raw === 'string') return raw.slice(0, 1000);
+  if (raw == null) return String(raw);
+  return inspect(raw, { depth: 2, maxArrayLength: 10, breakLength: 120 }).slice(0, 1000);
+}
+
 /** Lenient JSON parse: tolerate fenced ```json blocks. Returns null on failure. */
 export function parseJsonSafe(raw) {
   if (typeof raw !== 'string') return null;