@yeaft/webchat-agent 1.0.190 → 1.0.192

package/yeaft/web-bridge.js

@@ -53,7 +53,7 @@ import {
   resolveSessionYeaftDir,
 } from './sessions/session-crud.js';
 import { openSession, loadSessionMeta } from './sessions/session-store.js';
-import { loadSessionConfig, resolveSessionConfig, SessionConfigError } from './sessions/session-config.js';
+import { loadSessionConfig, normalizeSessionConfig, resolveSessionConfig, SessionConfigError } from './sessions/session-config.js';
 import { updateSessionConfig } from './sessions/session-crud.js';
 import { createCoordinator } from './sessions/coordinator.js';
 import { seedDefaultSession } from './sessions/seed-default.js';
@@ -131,49 +131,93 @@ function applyLiveLanguage(language) {
   try { session?.engine?.setLanguage?.(language); } catch { /* best-effort */ }
 }
 
-function refreshLiveSessionConfig() {
-  if (!session) return;
-  try {
-    const freshConfig = loadConfig({ dir: liveConfigRoot() });
-    const freshModels = Array.isArray(freshConfig.availableModels) ? freshConfig.availableModels : [];
-    session.config.availableModels = freshModels;
-    if (freshConfig.language) {
-      applyLiveLanguage(freshConfig.language);
-    }
-    if (freshConfig.model && !freshModels.some(m => modelRefMatchesAvailable(m, session.config.model))) {
-      session.config.model = freshConfig.primaryModel || freshConfig.model;
-    }
-    if (freshConfig.providers) {
-      session.config.providers = freshConfig.providers;
-      if (typeof session.adapter?.refreshProviders === 'function') {
-        session.adapter.refreshProviders(freshConfig.providers);
-      }
-    }
-  } catch (err) {
-    console.warn('[Yeaft] refresh live session config failed:', err?.message || err);
+function modelRefIdentity(value) {
+  const text = String(value || '');
+  const slash = text.indexOf('/');
+  return slash < 0
+    ? { provider: '', modelId: text }
+    : { provider: text.slice(0, slash), modelId: text.slice(slash + 1) };
+}
+
+function modelRefsEquivalent(left, right) {
+  if (!left || !right) return false;
+  if (left === right) return true;
+  const a = modelRefIdentity(left);
+  const b = modelRefIdentity(right);
+  if (a.modelId !== b.modelId) return false;
+  return !a.provider || !b.provider || a.provider === b.provider;
+}
+
+function resolveLiveSessionConfig(baseConfig, sessionId, options = {}) {
+  const configRoot = baseConfig?.dir || liveConfigRoot();
+  const sessionConfig = normalizeSessionConfig(configRoot, sessionId, baseConfig, options);
+  return resolveSessionConfig(baseConfig, sessionConfig);
+}
+
+let sessionConfigRefreshRevision = 0;
+
+/** Reload the Agent-owned config and install it into every live Engine. */
+export async function refreshLiveSessionConfig(options = {}) {
+  sessionConfigRefreshRevision += 1;
+  if (!session && sessionLoadPromise) {
+    // The loader may run its own catch-up refresh, but it does not know this
+    // config transaction's pre-save default. Wait for it, then continue once
+    // with the original normalization input.
+    await sessionLoadPromise;
+  }
+
+  const configRoot = liveConfigRoot();
+  const freshConfig = loadConfig({ dir: configRoot });
+  const previousDefaultModel = options.previousDefaultModel
+    || session?.config?.primaryModel
+    || session?.config?.model
+    || null;
+  // Normalize disk state even before the runtime is loaded. The config-save
+  // transaction supplies the pre-write default so legacy automatic seeds can
+  // become inheritance without depending on page/session lifecycle.
+  for (const row of snapshotSessions(configRoot)) {
+    normalizeSessionConfig(configRoot, row.id, freshConfig, { previousDefaultModel });
+  }
+  if (!session) return freshConfig;
+
+  const liveSession = session;
+  const currentConfig = liveSession.config || {};
+  const runtimeOnly = {};
+  for (const key of ['serverMode', '_readOnly', 'modelEffort']) {
+    if (Object.prototype.hasOwnProperty.call(currentConfig, key)) runtimeOnly[key] = currentConfig[key];
+  }
+  const inheritedAgentDefault = !currentConfig.model
+    || modelRefsEquivalent(currentConfig.model, currentConfig.primaryModel);
+  const nextModel = inheritedAgentDefault
+    ? (freshConfig.primaryModel || freshConfig.model)
+    : currentConfig.model;
+  const nextConfig = { ...freshConfig, ...runtimeOnly, model: nextModel };
+  const vpConfigSnapshots = [];
+  for (const [key, engine] of vpEngines) {
+    const separator = key.indexOf('::');
+    if (separator < 1) continue;
+    const sessionId = key.slice(0, separator);
+    vpConfigSnapshots.push({
+      key,
+      engine,
+      config: resolveLiveSessionConfig(nextConfig, sessionId, { previousDefaultModel }),
+    });
   }
-}
 
-function defaultSessionModelConfig(baseConfig) {
-  const config = baseConfig || session?.config || {};
-  const out = {};
-  const model = typeof config.primaryModel === 'string' && config.primaryModel.trim()
-    ? config.primaryModel.trim()
-    : (typeof config.model === 'string' && config.model.trim() ? config.model.trim() : '');
-  if (model) out.model = model;
-  if (typeof config.modelEffort === 'string' && config.modelEffort.trim()) {
-    out.modelEffort = config.modelEffort.trim();
+  if (typeof liveSession.adapter?.refreshProviders === 'function') {
+    liveSession.adapter.refreshProviders(freshConfig.providers || []);
   }
-  return out;
+  for (const key of Object.keys(currentConfig)) delete currentConfig[key];
+  Object.assign(currentConfig, nextConfig);
+  liveSession.engine?.refreshConfig?.(currentConfig);
+  for (const { key, engine, config } of vpConfigSnapshots) {
+    engine.refreshConfig?.(config);
+    vpEngineConfigKeys.set(key, engineConfigKey(config));
+  }
+  if (freshConfig.language) applyLiveLanguage(freshConfig.language);
+  return currentConfig;
 }
 
-function withDefaultSessionConfig(payload) {
-  const next = payload && typeof payload === 'object' ? { ...payload } : {};
-  const existing = next.config && typeof next.config === 'object' ? next.config : {};
-  const seeded = { ...defaultSessionModelConfig(), ...existing };
-  if (Object.keys(seeded).length > 0) next.config = seeded;
-  return next;
-}
 
 /** Test-only: replace the lightweight VP thread classifier. */
 export function __testSetThreadClassifier(fn) {
@@ -210,7 +254,11 @@ function scheduleYeaftLoadHistoryMetadataReplay(sessionId) {
   setTimeout(async () => {
     try {
       if (!replaySession) return;
-      refreshLiveSessionConfig();
+      try {
+        await refreshLiveSessionConfig();
+      } catch (err) {
+        console.warn('[Yeaft] load-history config refresh failed:', err?.message || err);
+      }
       let projectRuntime = null;
       if (sessionId) {
         try {
@@ -517,6 +565,7 @@ function engineConfigKey(config) {
     fastModel: config?.fastModel || '',
     fastModelId: config?.fastModelId || '',
     fallbackModel: config?.fallbackModel || '',
+    providers: Array.isArray(config?.providers) ? config.providers : [],
   });
 }
 
@@ -833,7 +882,7 @@ function queryTimeoutMsForSessionConfig(config = null) {
 function queryTimeoutMsForSession(sessionId = null) {
   if (!sessionId || !session) return queryTimeoutMsForSessionConfig(session?.config);
   try {
-    return queryTimeoutMsForSessionConfig(resolveSessionConfig(session.config, loadSessionConfig(liveConfigRoot(), sessionId)));
+    return queryTimeoutMsForSessionConfig(resolveLiveSessionConfig(session.config, sessionId));
   } catch {
     return queryTimeoutMsForSessionConfig(session?.config);
   }
@@ -1337,8 +1386,7 @@ export function __testGroupHistory(sessionId) {
 
 export function __testResolveVpEffectiveConfig(sessionId) {
   if (!session) return null;
-  const sessionConfigRoot = liveConfigRoot();
-  return resolveSessionConfig(session.config, loadSessionConfig(sessionConfigRoot, sessionId));
+  return resolveLiveSessionConfig(session.config, sessionId);
 }
 
 /**
@@ -1466,9 +1514,7 @@ function getOrCreateVpEngine(sessionId, vpId, threadId = 'main') {
   // Per-session config overlay (v1: model only). Falls back to the
   // session's user-level config when no override is set. Session config is
   // always resolved from the agent-local root; project `.yeaft` is ignored.
-  const sessionConfigRoot = liveConfigRoot();
-  const groupCfg = loadSessionConfig(sessionConfigRoot, sessionId);
-  const effectiveConfig = resolveSessionConfig(session.config, groupCfg);
+  const effectiveConfig = resolveLiveSessionConfig(session.config, sessionId);
   const configKey = engineConfigKey(effectiveConfig);
   let eng = vpEngines.get(key);
   if (eng && vpEngineConfigKeys.get(key) === configKey) return eng;
@@ -2684,7 +2730,7 @@ export function handleYeaftCreateSession(msg) {
   const payload = (msg && msg.payload) || {};
   try {
     const yeaftDir = ctx.CONFIG?.yeaftDir;
-    const group = createSessionFromSpec(yeaftDir, withDefaultSessionConfig(payload));
+    const group = createSessionFromSpec(yeaftDir, payload);
     recordAgentSessionCreated();
     group.config = loadSessionConfig(yeaftDir, group.id);
     sendSessionCrudResult({ op: 'create', requestId, ok: true, session: group });
@@ -4212,6 +4258,7 @@ export async function ensureSessionLoaded(opts = {}) {
   if (sessionLoadPromise) return sessionLoadPromise;
 
   sessionLoadPromise = (async () => {
+    const bootConfigRevision = sessionConfigRefreshRevision;
     const yeaftDir = ctx.CONFIG?.yeaftDir;
     const normalizedWorkDir = normalizeSessionWorkDir(opts?.workDir || opts?.sessionMeta?.workDir);
     session = await loadSession({
@@ -4223,6 +4270,11 @@ export async function ensureSessionLoaded(opts = {}) {
     });
 
     installYeaftRuntimeBridge(session);
+    // A save may complete after loadSession read config.json but before this
+    // runtime became visible. Refresh before any status/session_ready emit.
+    if (sessionConfigRefreshRevision !== bootConfigRevision) {
+      await refreshLiveSessionConfig();
+    }
 
     try {
       if (session.engine && typeof session.engine.setSubAgentEventSink === 'function') {

package/yeaft/work-center/projection.js

@@ -5,7 +5,7 @@ import {
   sanitizeDebugValue,
   sanitizeDiagnosticText,
 } from './debug-projection.js';
-import { normalizeActionBrief } from './workflow.js';
+import { taskSpecificActionBrief } from './workflow.js';
 
 const MAX_ACTION_MESSAGE_CHARS = 16_000;
 const MAX_ACTION_DIAGNOSTIC_CHARS = 8_000;
@@ -277,7 +277,7 @@ function projectAction(action, runs, events, includeBody = true) {
   if (!action) return null;
   const execution = actionExecution(action, runs, events, includeBody);
   const alreadyProjected = !Array.isArray(runs) && Array.isArray(action.messages);
-  const brief = alreadyProjected ? (action.brief || null) : normalizeActionBrief(action.brief, action.type);
+  const brief = taskSpecificActionBrief(action.brief, action.type);
   const projectedBrief = includeBody || !brief
     ? brief
     : Object.fromEntries(Object.entries(brief).map(([key, value]) => [

package/yeaft/work-center/runner.js

@@ -301,7 +301,7 @@ export function createSubmitWorkItemPlanTool({ vps, collector, isRunActive }) {
   const catalogDescription = `Action types: ${actionTypes.join(', ')}. Available VPs: ${vpCatalog.map(vp => `${vp.id} (${vp.role || vp.area || 'VP'}; ${vp.traits.join(', ') || 'no traits'})`).join('; ')}.`;
   return defineTool({
     name: 'SubmitWorkItemPlan',
-    description: `Submit the complete initial WorkItem contract and executable Action DAG. This tool records a Run-local proposal only; Work Center validates and persists it in the current Run finalization transaction. ${catalogDescription}`,
+    description: `Submit the complete initial WorkItem contract and executable Action DAG. Every Action must describe this WorkItem's concrete objective, repository-aware approach, and verifiable expected outcome; never copy generic Action-type text. The reference workflow catalog does not replace this Action list. This tool records a Run-local proposal only; Work Center validates and persists it in the current Run finalization transaction. ${catalogDescription}`,
     parameters: {
       type: 'object',
       additionalProperties: false,
@@ -1028,7 +1028,7 @@ export class WorkItemRunner {
     }
     return {
       ...parsedResult,
-      response,
+      response: response || parsedResult.summary,
       ...executionStats(),
       checkpoint,
     };

package/yeaft/work-center/workflow.js

@@ -62,6 +62,13 @@ function defaultActionBrief(type) {
   return { objective, approach, expectedOutcome };
 }
 
+function hasCompleteActionBrief(value) {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    && ['objective', 'approach', 'expectedOutcome'].every(key => (
+      typeof value[key] === 'string' && value[key].trim()
+    ));
+}
+
 export function normalizeActionBrief(value, type) {
   const source = value && typeof value === 'object' && !Array.isArray(value) ? value : {};
   const defaults = defaultActionBrief(type);
@@ -73,6 +80,13 @@ export function normalizeActionBrief(value, type) {
   ]));
 }
 
+export function taskSpecificActionBrief(value, type) {
+  if (!hasCompleteActionBrief(value)) return null;
+  const brief = normalizeActionBrief(value, type);
+  const defaults = defaultActionBrief(type);
+  return Object.keys(defaults).every(key => brief[key] !== defaults[key]) ? brief : null;
+}
+
 const DEFAULT_SOFTWARE_CHANGE_STAGES = Object.freeze([
   {
     id: 'triage', name: 'Triage', type: 'triage',
@@ -353,18 +367,13 @@ export function resolvePlanningWorkflowSnapshot(settings, requestedWorkItemType
     ...workflow,
     workItemType: workflow.workItemType || workflow.id,
   }));
-  const matchingTemplate = requestedType
-    ? actionTemplates.find(template => template.workItemType === requestedType)
-    : null;
-  if (matchingTemplate) return matchingTemplate;
-
   const catalog = actionTemplates
     .map(template => `${template.workItemType}: ${template.name} (${template.stages.map(stage => stage.type).join(' -> ')})`)
     .join('\n');
   const typeInstruction = requestedType
     ? `The user explicitly selected workItemType "${requestedType}". Keep that exact type.`
     : 'Infer one specific workItemType from the contract.';
-  const triageInstruction = `${normalized.actionInstructions.triage}\n\n${typeInstruction}\nReusable Action templates:\n${catalog || '(none)'}\nIf the final type matches a reusable template, return its workItemType and omit actions so Work Center can apply that frozen template. Otherwise generate the smallest reliable graph of 1 to 8 Actions. Split independent work into separate Actions and declare dependsOnActionIds. Use workspaceMode read for analysis, isolated-write for independent Git changes, integrate for an integrate Action that combines isolated-write dependencies, and shared for serial side effects. Non-Git or dirty workspaces are serialized automatically. Every generated Action must state objective, approach, expectedOutcome, capability, dependencies, and workspaceMode. The objective, approach, and expectedOutcome must be specific to this WorkItem and that Action: describe the concrete work, the repository-aware execution method, and the verifiable result that will guide the executor. Generic Action-type boilerplate is invalid. Add only Actions required by this task. Do not copy a generic workflow.`;
+  const triageInstruction = `${normalized.actionInstructions.triage}\n\n${typeInstruction}\nReference workflow catalog:\n${catalog || '(none)'}\nUse the catalog only to understand established task categories and sequencing patterns. Always submit the smallest reliable graph of 1 to 8 task-specific Actions; never omit Actions or copy template brief text. Split independent work into separate Actions and declare dependsOnActionIds. Use workspaceMode read for analysis, isolated-write for independent Git changes, integrate for an integrate Action that combines isolated-write dependencies, and shared for serial side effects. Non-Git or dirty workspaces are serialized automatically. Every generated Action must state objective, approach, expectedOutcome, capability, dependencies, and workspaceMode. The objective, approach, and expectedOutcome must be specific to this WorkItem and that Action: describe the concrete work, the repository-aware execution method, and the verifiable result that will guide the executor. Generic Action-type boilerplate is invalid. Add only Actions required by this task. Do not copy a generic workflow.`;
   return normalizeWorkflowDefinition({
     id: 'ai-planned',
     name: 'AI planned',
@@ -434,25 +443,8 @@ export function applyGeneratedPlan(workItem, rawPlan, options = {}) {
   }
   const reservedStageIds = new Set((options.reservedStageIds || [])
     .map(id => String(id || '').trim()).filter(Boolean));
-  const reusableTemplate = source.actionTemplates.find(template => template.workItemType === workItemType);
-  if (reusableTemplate) {
-    const templateActions = reusableTemplate.stages.filter(stage => stage.type !== 'triage');
-    if (templateActions.length === 0) {
-      throw new Error(`Reusable Action template "${workItemType}" has no executable Actions`);
-    }
-    const reusedStageId = templateActions.find(stage => reservedStageIds.has(stage.id))?.id;
-    if (reusedStageId) {
-      throw new Error(`AI-planned Action id reuses historical stage identity: ${reusedStageId}`);
-    }
-    return normalizeWorkflowDefinition({
-      ...source,
-      workItemType,
-      actionTemplates: [],
-      stages: [source.stages[0], ...templateActions],
-    });
-  }
   if (!Array.isArray(rawPlan.actions) || rawPlan.actions.length < 1 || rawPlan.actions.length > 8) {
-    throw new Error('AI-planned triage requires between 1 and 8 Actions when no reusable template exists');
+    throw new Error('AI-planned triage requires between 1 and 8 task-specific Actions');
   }
   const availableVpIds = Array.isArray(options.availableVpIds)
     ? new Set(options.availableVpIds.map(id => String(id || '').trim()).filter(Boolean))