@yeaft/webchat-agent 0.1.771 → 0.1.773

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.771",
+  "version": "0.1.773",
   "description": "Remote agent for Yeaft WebChat — connects worker machines to the central server",
   "main": "index.js",
   "type": "module",

package/unify/groups/group-crud.js

@@ -32,10 +32,19 @@
  *   'reserved'/'invalid_vp_id'/... — bubbled from ids.js validators
  */
 
-import { existsSync, renameSync, rmSync, readdirSync, statSync } from 'fs';
+import {
+  existsSync,
+  renameSync,
+  rmSync,
+  readdirSync,
+  statSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+} from 'fs';
 import { randomBytes } from 'crypto';
 import { homedir } from 'os';
-import { join } from 'path';
+import { isAbsolute, join, resolve } from 'path';
 import {
   openGroup, createGroup, listGroups, loadGroupMeta,
 } from './group-store.js';
@@ -87,10 +96,77 @@ export class GroupCrudError extends Error {
   }
 }
 
-function groupsRoot(yeaftDir) {
+const GROUP_WORKDIR_REGISTRY = 'group-workdirs.json';
+
+export function groupsRoot(yeaftDir) {
   return join(yeaftDir, 'groups');
 }
 
+export function normalizeWorkDir(workDir) {
+  const raw = String(workDir || '').trim();
+  if (!raw) return '';
+  return isAbsolute(raw) ? raw : resolve(raw);
+}
+
+export function yeaftDirForWorkDir(workDir) {
+  const normalized = normalizeWorkDir(workDir);
+  return normalized ? join(normalized, '.yeaft') : '';
+}
+
+function registryPath(yeaftDir) {
+  return join(yeaftDir, GROUP_WORKDIR_REGISTRY);
+}
+
+export function readWorkDirRegistry(yeaftDir) {
+  if (!yeaftDir) return {};
+  const file = registryPath(yeaftDir);
+  if (!existsSync(file)) return {};
+  try {
+    const parsed = JSON.parse(readFileSync(file, 'utf8'));
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function writeWorkDirRegistry(yeaftDir, registry) {
+  if (!yeaftDir) return;
+  mkdirSync(yeaftDir, { recursive: true });
+  writeFileSync(registryPath(yeaftDir), `${JSON.stringify(registry, null, 2)}\n`);
+}
+
+export function registerGroupWorkDir(defaultYeaftDir, groupId, workDir) {
+  const normalized = normalizeWorkDir(workDir);
+  if (!defaultYeaftDir || !groupId || !normalized) return;
+  const registry = readWorkDirRegistry(defaultYeaftDir);
+  registry[groupId] = normalized;
+  writeWorkDirRegistry(defaultYeaftDir, registry);
+}
+
+export function unregisterGroupWorkDir(defaultYeaftDir, groupId) {
+  if (!defaultYeaftDir || !groupId) return;
+  const registry = readWorkDirRegistry(defaultYeaftDir);
+  if (!Object.prototype.hasOwnProperty.call(registry, groupId)) return;
+  delete registry[groupId];
+  writeWorkDirRegistry(defaultYeaftDir, registry);
+}
+
+export function resolveGroupYeaftDir(defaultYeaftDir, groupId) {
+  if (!defaultYeaftDir || !groupId) return defaultYeaftDir;
+  const defaultGroupDir = join(groupsRoot(defaultYeaftDir), groupId);
+  if (existsSync(defaultGroupDir) && loadGroupMeta(defaultGroupDir)) return defaultYeaftDir;
+
+  const registry = readWorkDirRegistry(defaultYeaftDir);
+  const workDir = normalizeWorkDir(registry[groupId]);
+  if (workDir) {
+    const candidate = yeaftDirForWorkDir(workDir);
+    const candidateDir = join(groupsRoot(candidate), groupId);
+    if (existsSync(candidateDir) && loadGroupMeta(candidateDir)) return candidate;
+  }
+
+  return defaultYeaftDir;
+}
+
 /** Build a safe group id from a display name (slug + ulid-lite suffix). */
 export function makeGroupId(name) {
   const slug = String(name || 'group')
@@ -146,11 +222,13 @@ export function ensureDefaultGroupIfEmpty(yeaftDir, options = {}) {
  * we do NOT auto-expand to the full VP library here. That's D1's job only.
  *
  * @param {string} yeaftDir
- * @param {{name:string, roster?:string[], defaultVpId?:string|null}} spec
- * @returns {{id:string, name:string, roster:string[], defaultVpId:string|null}}
+ * @param {{name:string, roster?:string[], defaultVpId?:string|null, workDir?:string}} spec
+ * @returns {{id:string, name:string, roster:string[], defaultVpId:string|null, workDir?:string}}
  */
 export function createGroupFromSpec(yeaftDir, spec, options = {}) {
-  const memoryRoot = options.memoryRoot || DEFAULT_MEMORY_ROOT;
+  const normalizedWorkDir = normalizeWorkDir(spec && spec.workDir);
+  const groupYeaftDir = normalizedWorkDir ? yeaftDirForWorkDir(normalizedWorkDir) : yeaftDir;
+  const memoryRoot = options.memoryRoot || (groupYeaftDir ? join(groupYeaftDir, 'memory') : DEFAULT_MEMORY_ROOT);
   const name = String(spec && spec.name || '').trim();
   if (!name) throw new GroupCrudError('invalid_name', null, 'group name required');
 
@@ -174,15 +252,16 @@ export function createGroupFromSpec(yeaftDir, spec, options = {}) {
   if (!defaultVpId) defaultVpId = roster[0] || null;
 
   const id = makeGroupId(name);
-  const root = groupsRoot(yeaftDir);
+  const root = groupsRoot(groupYeaftDir);
   if (existsSync(join(root, id))) {
     // Extremely unlikely (ulid suffix), but surface deterministically.
     throw new GroupCrudError('duplicate', id);
   }
 
-  const handle = createGroup(root, { id, name, roster, defaultVpId });
+  const handle = createGroup(root, { id, name, roster, defaultVpId, workDir: normalizedWorkDir });
   const meta = handle.getMeta();
   handle.close();
+  if (normalizedWorkDir) registerGroupWorkDir(yeaftDir, id, normalizedWorkDir);
 
   // Seed Layer-A resident summary so the first session has memory content
   // even before Dream-v2 has run. No-op if a summary.md already exists.
@@ -243,7 +322,8 @@ export function updateGroupAnnouncement(yeaftDir, groupId, text) {
  * own second-confirm modal (acceptance #4 in task-334-slice-specs.md 334m).
  */
 export function archiveGroup(yeaftDir, groupId) {
-  const root = groupsRoot(yeaftDir);
+  const groupYeaftDir = resolveGroupYeaftDir(yeaftDir, groupId);
+  const root = groupsRoot(groupYeaftDir);
   const srcDir = join(root, groupId);
   if (!existsSync(srcDir) || !loadGroupMeta(srcDir)) {
     throw new GroupCrudError('not_found', groupId);
@@ -253,6 +333,7 @@ export function archiveGroup(yeaftDir, groupId) {
   const suffix = randomBytes(2).toString('hex');
   const dstDir = join(root, `.archived-${ts}-${suffix}-${groupId}`);
   renameSync(srcDir, dstDir);
+  unregisterGroupWorkDir(yeaftDir, groupId);
   return { groupId, archivedAs: dstDir };
 }
 
@@ -269,8 +350,9 @@ export function archiveGroup(yeaftDir, groupId) {
  * delete cleans up legacy state too.
  */
 export function deleteGroup(yeaftDir, groupId, options = {}) {
-  const memoryRoot = options.memoryRoot || DEFAULT_MEMORY_ROOT;
-  const root = groupsRoot(yeaftDir);
+  const groupYeaftDir = resolveGroupYeaftDir(yeaftDir, groupId);
+  const memoryRoot = options.memoryRoot || (groupYeaftDir ? join(groupYeaftDir, 'memory') : DEFAULT_MEMORY_ROOT);
+  const root = groupsRoot(groupYeaftDir);
   const srcDir = join(root, groupId);
   const liveExists = existsSync(srcDir) && !!loadGroupMeta(srcDir);
 
@@ -307,6 +389,7 @@ export function deleteGroup(yeaftDir, groupId, options = {}) {
     console.warn(`[group-crud] failed to remove memory dir for ${groupId}:`, err?.message || err);
   }
 
+  unregisterGroupWorkDir(yeaftDir, groupId);
   return { groupId, deleted: true, legacyCleanedUp: legacyDirs.length };
 }
 
@@ -382,8 +465,9 @@ export function setGroupDefaultVp(yeaftDir, groupId, vpId) {
   }
 }
 
-function requireGroup(yeaftDir, groupId) {
-  const root = groupsRoot(yeaftDir);
+export function requireGroup(yeaftDir, groupId) {
+  const groupYeaftDir = resolveGroupYeaftDir(yeaftDir, groupId);
+  const root = groupsRoot(groupYeaftDir);
   const dir = join(root, groupId);
   if (!existsSync(dir) || !loadGroupMeta(dir)) {
     throw new GroupCrudError('not_found', groupId);
@@ -393,7 +477,18 @@ function requireGroup(yeaftDir, groupId) {
 
 /** Convenience: snapshot all non-archived groups for WS broadcast. */
 export function snapshotGroups(yeaftDir) {
-  return listGroups(groupsRoot(yeaftDir));
+  const byId = new Map();
+  for (const group of listGroups(groupsRoot(yeaftDir))) {
+    byId.set(group.id, group);
+  }
+  const registry = readWorkDirRegistry(yeaftDir);
+  for (const [groupId, workDir] of Object.entries(registry)) {
+    const groupYeaftDir = yeaftDirForWorkDir(workDir);
+    const dir = join(groupsRoot(groupYeaftDir), groupId);
+    const meta = existsSync(dir) ? loadGroupMeta(dir) : null;
+    if (meta) byId.set(meta.id, meta);
+  }
+  return Array.from(byId.values()).sort((a, b) => String(a.createdAt || '').localeCompare(String(b.createdAt || '')));
 }
 
 export { DEFAULT_GROUP_ID };

package/unify/groups/group-store.js

@@ -139,6 +139,7 @@ export function createGroup(groupsRoot, spec) {
     roster,
     defaultVpId: spec.defaultVpId || null,
     announcement: typeof spec.announcement === 'string' ? spec.announcement : '',
+    workDir: typeof spec.workDir === 'string' ? spec.workDir.trim() : '',
     createdAt: spec.createdAt || new Date().toISOString(),
   };
   h.saveMeta(meta);
@@ -153,9 +154,10 @@ export function loadGroupMeta(dir) {
     const raw = readFileSync(path, 'utf8');
     const parsed = JSON.parse(raw);
     validateMeta(parsed);
-    // Legacy groups created before the announcement field was added are
-    // forward-compat: missing field reads back as empty string.
+    // Legacy groups created before optional fields were added are
+    // forward-compat: missing fields read back as safe empty strings.
     if (typeof parsed.announcement !== 'string') parsed.announcement = '';
+    if (typeof parsed.workDir !== 'string') parsed.workDir = '';
     return parsed;
   } catch {
     return null;
@@ -192,6 +194,9 @@ function validateMeta(meta) {
   if (meta.announcement != null && typeof meta.announcement !== 'string') {
     throw new Error('group.announcement must be string');
   }
+  if (meta.workDir != null && typeof meta.workDir !== 'string') {
+    throw new Error('group.workDir must be string');
+  }
 }
 
 /**

package/unify/web-bridge.js

@@ -41,6 +41,8 @@ import {
   removeMember,
   setGroupDefaultVp,
   snapshotGroups,
+  resolveGroupYeaftDir,
+  groupsRoot,
 } from './groups/group-crud.js';
 import { openGroup, loadGroupMeta } from './groups/group-store.js';
 import { createCoordinator } from './groups/coordinator.js';
@@ -55,6 +57,23 @@ import { createVpStatusBroker } from './vp-status-broker.js';
 /** @type {import('./session.js').Session | null} */
 let session = null;
 
+/**
+ * Tracks scoped-dream triggers that are currently inflight, keyed by
+ * groupId. Used by `handleUnifyDreamTrigger` to reject any overlapping
+ * scoped trigger rather than racing the sink-wrapping logic against
+ * itself.
+ *
+ * Cross-group overlap is rejected (not just same-group): under the
+ * existing dream scheduler a second concurrent trigger silently shares
+ * the first's inflight promise and dropped its own scope filter. So
+ * "B during A's run" doesn't actually produce a separate scoped pass
+ * for B — letting B install a second sink wrapper would only mis-stamp
+ * A's events with B's groupId. Rejecting B with an explicit error is
+ * the honest answer; the user can re-click after A settles.
+ * @type {Set<string>}
+ */
+const inflightScopedDreamGroups = new Set();
+
 /**
  * Single in-flight AbortController. A new user message cancels the prior
  * round (if any). H2.f.2: replaces the per-thread Map.
@@ -980,6 +999,7 @@ function sendGroupRosterChanged(group) {
     name: group.name,
     roster: group.roster,
     defaultVpId: group.defaultVpId,
+    workDir: group.workDir || '',
   });
 }
 
@@ -1007,8 +1027,7 @@ export function handleUnifyCreateGroup(msg) {
   const payload = (msg && msg.payload) || {};
   try {
     const yeaftDir = ctx.CONFIG?.yeaftDir;
-    const memoryRoot = yeaftDir ? join(yeaftDir, 'memory') : undefined;
-    const group = createGroupFromSpec(yeaftDir, payload, memoryRoot ? { memoryRoot } : {});
+    const group = createGroupFromSpec(yeaftDir, payload);
     sendGroupCrudResult({ op: 'create', requestId, ok: true, group });
     sendGroupSnapshotBroadcast();
   } catch (err) {
@@ -1090,8 +1109,7 @@ export function handleUnifyDeleteGroup(msg) {
   const groupId = msg && msg.groupId;
   try {
     const yeaftDir = ctx.CONFIG?.yeaftDir;
-    const memoryRoot = yeaftDir ? join(yeaftDir, 'memory') : undefined;
-    const result = deleteGroup(yeaftDir, groupId, memoryRoot ? { memoryRoot } : {});
+    const result = deleteGroup(yeaftDir, groupId);
     // Cascade: remove every persisted message stamped with this group id.
     // Hard delete (per user spec): no soft-archive, the bytes are gone.
     // Skipped silently if the session/store isn't initialized — the next
@@ -1185,9 +1203,23 @@ export function installUnifyRuntimeBridge(s) {
   if (!s) return;
 
   // Forward dream pipeline progress events to the web debug panel.
+  //
+  // Group-id stamping is NO LONGER done here. It used to be: this sink
+  // read a module-level `activeScopedDreamGroupId` that
+  // `handleUnifyDreamTrigger({groupId})` parked before awaiting the
+  // scope-filtered pass. That created a race when two scoped triggers
+  // overlapped (auto-tick during a manual click; or two manual clicks
+  // for different groups): the second handler's `finally` could clear
+  // the module slot while the first run was still emitting events,
+  // dropping the stamp from the tail of the first pass. The new design:
+  // `handleUnifyDreamTrigger` wraps THIS sink for the lifetime of the
+  // trigger to inject `groupId` per-call (see that function below). The
+  // base sink is intentionally a pure passthrough.
   s._dreamProgressSink = (evt) => {
     try {
-      sendUnifyEvent({ type: 'dream_progress', ...evt });
+      const out = { type: 'dream_progress', ...evt };
+      const tag = evt && evt.groupId ? { groupId: evt.groupId } : {};
+      sendUnifyEvent(out, tag);
     } catch { /* never let event delivery throw */ }
   };
 
@@ -1601,15 +1633,17 @@ export async function handleUnifyGroupChat(msg) {
   // seedFailed separately so a seed crash surfaces a different message
   // than a genuinely-missing group.
   let groupHandle = null;
+  let groupRoot = null;
   let seedFailed = false;
   try {
-    const root = join(yeaftDir, 'groups');
-    const dir = join(root, groupId);
+    const groupYeaftDir = resolveGroupYeaftDir(yeaftDir, groupId);
+    groupRoot = groupsRoot(groupYeaftDir);
+    const dir = join(groupRoot, groupId);
     if (existsSync(dir) && loadGroupMeta(dir)) {
-      groupHandle = openGroup(root, groupId);
+      groupHandle = openGroup(groupRoot, groupId);
     } else if (groupId === 'grp_default') {
       try {
-        const seeded = seedDefaultGroup(yeaftDir, { memoryRoot: join(yeaftDir, 'memory') });
+        const seeded = seedDefaultGroup(groupYeaftDir, { memoryRoot: join(groupYeaftDir, 'memory') });
         groupHandle = seeded.group;
       } catch (seedErr) {
         seedFailed = true;
@@ -1624,7 +1658,7 @@ export async function handleUnifyGroupChat(msg) {
 
   if (!groupHandle) {
     const errText = seedFailed
-      ? `⚠️ Failed to seed default group ${groupId} — check ~/.yeaft/ permissions.`
+      ? `⚠️ Failed to seed default group ${groupId} — check group .yeaft permissions.`
       : `⚠️ Group ${groupId} not found.`;
     sendUnifyOutput({
       type: 'assistant',
@@ -1652,7 +1686,7 @@ export async function handleUnifyGroupChat(msg) {
       }
       if (rosterMutated) {
         try { groupHandle.close && groupHandle.close(); } catch { /* best-effort */ }
-        groupHandle = openGroup(join(yeaftDir, 'groups'), groupId);
+        groupHandle = openGroup(groupRoot, groupId);
         sendGroupRosterChanged(groupHandle.getMeta());
       }
     }
@@ -1661,7 +1695,7 @@ export async function handleUnifyGroupChat(msg) {
       try {
         setGroupDefaultVp(yeaftDir, groupId, meta2.roster[0]);
         try { groupHandle.close && groupHandle.close(); } catch { /* best-effort */ }
-        groupHandle = openGroup(join(yeaftDir, 'groups'), groupId);
+        groupHandle = openGroup(groupRoot, groupId);
         sendGroupRosterChanged(groupHandle.getMeta());
         rosterMutated = true;
       } catch { /* best-effort */ }
@@ -2660,6 +2694,46 @@ export async function handleUnifyDreamTrigger(msg = {}) {
     return;
   }
 
+  // Concurrent-trigger guard for scoped runs. Two scoped clicks (same
+  // group or different) overlapping the same inflight pass used to set
+  // the module-level groupId slot, race the sink wrapping, and let the
+  // second `finally` restore the original sink while the first run was
+  // still emitting events. We now refuse any second scoped trigger
+  // while ANY scoped pass is inflight — the scheduler already
+  // short-circuits the underlying run for same-group, and a different
+  // group's filter would have been silently dropped anyway (see
+  // dream-v2/schedule.js inflight reuse), so the user-facing semantics
+  // are unchanged ("you already asked").
+  if (groupId && inflightScopedDreamGroups.size > 0) {
+    sendToServer({
+      type: 'unify_dream_result',
+      ...tag,
+      success: false,
+      error: 'A dream pass is already running.',
+    });
+    return;
+  }
+
+  // Per-call sink wrapper. For scoped runs we install a closure that
+  // injects this trigger's groupId onto top-level events the runner
+  // emits without one (start/merge/done), then delegates to the
+  // original passthrough sink. The wrapper lives only for the lifetime
+  // of this trigger and is restored in `finally`; concurrent calls for
+  // OTHER groupIds chain (last-installed wins) but each restoration
+  // unwinds back to its predecessor.
+  const originalSink = session?._dreamProgressSink;
+  if (groupId && typeof originalSink === 'function') {
+    inflightScopedDreamGroups.add(groupId);
+    session._dreamProgressSink = (evt) => {
+      try {
+        const stamped = evt && evt.groupId
+          ? evt
+          : { ...evt, groupId };
+        originalSink(stamped);
+      } catch { /* never let event delivery throw */ }
+    };
+  }
+
   try {
     sendToServer({
       type: 'unify_dream_status',
@@ -2678,6 +2752,7 @@ export async function handleUnifyDreamTrigger(msg = {}) {
     const targets = Array.isArray(result?.targets) ? result.targets : [];
     const entriesCreated = targets.filter(t => t && t.status === 'done').length;
     const lastDreamAt = result?.startedAt || new Date().toISOString();
+    const success = !result.error && !result.skipped;
 
     // Spread `result` FIRST so derived fields (success, entriesCreated,
     // lastDreamAt) authoritatively shadow anything the runner might grow
@@ -2685,11 +2760,19 @@ export async function handleUnifyDreamTrigger(msg = {}) {
     // { groups, targets, startedAt, error?, skipped? }) but the failure
     // mode of the alternative ordering is silent — review feedback from
     // PR #743.
+    //
+    // This `unify_dream_result` envelope is the SOLE terminal signal for
+    // a dream pass. The chat-store projects it into BOTH `unifyDreamLatest`
+    // (final tally row) AND `unifyDreamEvents` (ring-buffer terminal
+    // marker), so we no longer mirror a synthetic `phase:'result'`
+    // dream_progress event — that mirror used to race the
+    // `unifyDreamLatest` writer and flip the success row back to
+    // 'running' (Critical reviewer finding pre-merge).
     sendToServer({
       type: 'unify_dream_result',
       ...tag,
       ...result,
-      success: !result.error && !result.skipped,
+      success,
       entriesCreated,
       lastDreamAt,
     });
@@ -2700,6 +2783,12 @@ export async function handleUnifyDreamTrigger(msg = {}) {
       success: false,
       error: err?.message || String(err),
     });
+  } finally {
+    // Restore the original sink and release the per-group inflight lock.
+    if (groupId && typeof originalSink === 'function') {
+      session._dreamProgressSink = originalSink;
+      inflightScopedDreamGroups.delete(groupId);
+    }
   }
 }