@yeaft/webchat-agent 0.1.856 → 0.1.859

package/yeaft/init.js

@@ -2,7 +2,7 @@
  * init.js — Yeaft directory structure initialization
  *
  * Ensures ~/.yeaft/ and all required subdirectories exist.
- * Creates default config.md, MEMORY.md, chat/index.md, and group/index.md if missing.
+ * Creates default config.md, MEMORY.md, and chat/index.md if missing.
  */
 
 import { existsSync, mkdirSync, writeFileSync, accessSync, constants } from 'fs';
@@ -77,10 +77,7 @@ const SUBDIRS = [
   'chat/messages',
   'chat/cold',
   'chat/blobs',
-  'group/messages',
-  'group/cold',
-  'group/blobs',
-  'group/compact',
+  'groups',
   'memory/entries',
   'tasks',
   'skills',
@@ -200,12 +197,10 @@ export function initYeaftDir(dir) {
     created.push(memoryPath);
   }
 
-  for (const mode of ['chat', 'group']) {
-    const indexPath = join(root, mode, 'index.md');
-    if (!existsSync(indexPath)) {
-      safeWriteFile(indexPath, DEFAULT_CONVERSATION_INDEX, warnings);
-      created.push(indexPath);
-    }
+  const chatIndexPath = join(root, 'chat', 'index.md');
+  if (!existsSync(chatIndexPath)) {
+    safeWriteFile(chatIndexPath, DEFAULT_CONVERSATION_INDEX, warnings);
+    created.push(chatIndexPath);
   }
 
   // mcp.json.example — reference template for MCP server configuration

package/yeaft/memory/adjust.js

@@ -28,6 +28,7 @@
  */
 
 import { approxTokens } from './budget.js';
+import { isVpForeign } from './store-v2.js';
 
 /**
  * @typedef {object} AdjustTriggerInput
@@ -104,10 +105,7 @@ function firstSentence(body) {
 }
 
 function isOwnOrNonVp(scope, ownVpId) {
-  if (!scope.startsWith('vp/')) return true;
-  if (!ownVpId) return true;
-  const other = scope.slice(3).split('/')[0];
-  return other === ownVpId;
+  return !isVpForeign(scope, ownVpId);
 }
 
 /**

package/yeaft/memory/ams.js

@@ -17,6 +17,7 @@
  */
 
 import { approxTokens, packWithinBudget } from './budget.js';
+import { isVpForeign } from './store-v2.js';
 
 const RECENT_DEFAULT_CAPACITY = 64;
 
@@ -189,9 +190,6 @@ export class ActiveMemorySet {
   // ────────────────────────── privacy ──────────────────────────
 
   _isForeignVp(scope) {
-    if (!scope || !scope.startsWith('vp/')) return false;
-    if (!this.ownVpId) return false;        // no own id → no filtering
-    const other = scope.slice(3).split('/')[0];
-    return other !== this.ownVpId;
+    return isVpForeign(scope, this.ownVpId);
   }
 }

package/yeaft/memory/preflow.js

@@ -17,6 +17,7 @@
 
 import { extractKeywords } from './keywords.js';
 import { approxTokens } from './budget.js';
+import { isVpForeign } from './store-v2.js';
 
 /**
  * @typedef {object} PreflowOptions
@@ -118,12 +119,7 @@ export function buildFtsQuery(keywords) {
  * @returns {string[]}
  */
 export function filterScopes(scopes, ownVpId) {
-  return scopes.filter(s => {
-    if (!s.startsWith('vp/')) return true;
-    if (!ownVpId) return true;
-    const other = s.slice(3).split('/')[0];
-    return other === ownVpId;
-  });
+  return scopes.filter(s => !isVpForeign(s, ownVpId));
 }
 
 /**

package/yeaft/memory/seed-backfill.js

@@ -15,7 +15,7 @@
  * a permission error must NEVER prevent the session from loading.
  */
 
-import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, statSync } from 'fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, statSync, renameSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
 import { parseRoleMd } from '../vp/vp-store.js';
@@ -292,3 +292,43 @@ export function runSummaryBackfill({ yeaftDir, libDir, root = DEFAULT_MEMORY_ROO
   }
   return { migrate, vp, group };
 }
+
+/**
+ * archiveLegacyScopes(root) — one-shot migration for the group-isolated
+ * memory refactor. The legacy flat layout had `vp/<id>/`, `feature/<id>/`,
+ * and `topic/<l1>[/<l2>]/` directories at the memory root; the new layout
+ * tucks each into `group/<g>/{vp,feature,topic}/...`. Per user directive
+ * "硬切，老的就不要了" — we do NOT migrate per-record, we just move the
+ * top-level dirs to `<root>/.legacy/<kind>/` once. They are never read
+ * again; this is forensics-only.
+ *
+ * Idempotent: a second invocation is a no-op when no legacy dirs remain at
+ * the root. If `.legacy/<kind>/` already exists, the new move is suffixed
+ * with a timestamp so re-attempts after a partial first run don't clobber.
+ *
+ * @param {string} root  memory root (typically <yeaftDir>/memory)
+ * @returns {{moved: string[]}}
+ */
+export function archiveLegacyScopes(root) {
+  const moved = [];
+  if (!root || !existsSync(root)) return { moved };
+  const legacyRoot = join(root, '.legacy');
+  for (const kind of ['vp', 'feature', 'topic']) {
+    const src = join(root, kind);
+    if (!existsSync(src)) continue;
+    try {
+      mkdirSync(legacyRoot, { recursive: true });
+      let dst = join(legacyRoot, kind);
+      if (existsSync(dst)) {
+        const ts = new Date().toISOString().replace(/[:.]/g, '-');
+        dst = `${dst}.${ts}`;
+      }
+      // eslint-disable-next-line global-require
+      renameSync(src, dst);
+      moved.push(kind);
+    } catch (err) {
+      console.warn(`[seed-backfill] archiveLegacyScopes(${kind}) failed:`, err?.message || err);
+    }
+  }
+  return { moved };
+}

package/yeaft/memory/segment.js

@@ -51,7 +51,7 @@ export const KIND_VALUES = new Set([
   'fact', 'preference', 'decision', 'lesson', 'relation', 'goal', 'context',
 ]);
 
-const SCOPE_RE = /^(user|vp\/[\w-]+|group\/[\w-]+|feature\/[\w-]+|topic\/[\w-]+(?:\/[\w-]+)?)$/;
+const SCOPE_RE = /^(user|group\/[\w-]+(?:\/(?:user|vp\/[\w-]+|feature\/[\w-]+|topic\/[\w-]+(?:\/[\w-]+)?))?)$/;
 
 /**
  * Compute a stable id from segment content. Same body + scope + kind →

package/yeaft/memory/store-v2.js

@@ -54,16 +54,24 @@ import { homedir } from 'os';
 /** Default memory root. Tests override via `opts.root`. */
 export const DEFAULT_MEMORY_ROOT = join(homedir(), '.yeaft', 'memory');
 
-/** Scope kinds recognised by v2. */
-export const SCOPE_KINDS = Object.freeze(['user', 'vp', 'group', 'feature', 'topic']);
-
-/** @typedef {'user'|'vp'|'group'|'feature'|'topic'} ScopeKind */
+/** Scope kinds recognised by v2 (group-isolated layout). */
+export const SCOPE_KINDS = Object.freeze([
+  'user',
+  'group',
+  'group-user',
+  'group-vp',
+  'group-feature',
+  'group-topic',
+]);
+
+/** @typedef {'user'|'group'|'group-user'|'group-vp'|'group-feature'|'group-topic'} ScopeKind */
 
 /**
  * @typedef {Object} Scope
  * @property {ScopeKind} kind
- * @property {string} [id]      — required for vp / group / feature
- * @property {string[]} [path]  — required for topic; 1–2 segments
+ * @property {string} [id]        — required for group; for group-vp / group-feature the per-kind id
+ * @property {string} [groupId]   — required for every group-* kind
+ * @property {string[]} [path]    — required for group-topic; 1–2 segments
  */
 
 /**
@@ -81,25 +89,38 @@ export function scopeDir(scope) {
   switch (scope.kind) {
     case 'user':
       return 'user';
-    case 'vp':
-      if (!scope.id) throw new Error('scopeDir: vp scope requires id');
-      assertSafeSegment(scope.id, 'vp.id');
-      return `vp/${scope.id}`;
     case 'group':
       if (!scope.id) throw new Error('scopeDir: group scope requires id');
       assertSafeSegment(scope.id, 'group.id');
       return `group/${scope.id}`;
-    case 'feature':
-      if (!scope.id) throw new Error('scopeDir: feature scope requires id');
-      assertSafeSegment(scope.id, 'feature.id');
-      return `feature/${scope.id}`;
-    case 'topic': {
+    case 'group-user': {
+      if (!scope.groupId) throw new Error('scopeDir: group-user scope requires groupId');
+      assertSafeSegment(scope.groupId, 'group-user.groupId');
+      return `group/${scope.groupId}/user`;
+    }
+    case 'group-vp': {
+      if (!scope.groupId) throw new Error('scopeDir: group-vp scope requires groupId');
+      if (!scope.id) throw new Error('scopeDir: group-vp scope requires id');
+      assertSafeSegment(scope.groupId, 'group-vp.groupId');
+      assertSafeSegment(scope.id, 'group-vp.id');
+      return `group/${scope.groupId}/vp/${scope.id}`;
+    }
+    case 'group-feature': {
+      if (!scope.groupId) throw new Error('scopeDir: group-feature scope requires groupId');
+      if (!scope.id) throw new Error('scopeDir: group-feature scope requires id');
+      assertSafeSegment(scope.groupId, 'group-feature.groupId');
+      assertSafeSegment(scope.id, 'group-feature.id');
+      return `group/${scope.groupId}/feature/${scope.id}`;
+    }
+    case 'group-topic': {
+      if (!scope.groupId) throw new Error('scopeDir: group-topic scope requires groupId');
+      assertSafeSegment(scope.groupId, 'group-topic.groupId');
       const segs = Array.isArray(scope.path) ? scope.path : [];
       if (segs.length === 0 || segs.length > 2) {
-        throw new Error('scopeDir: topic.path must have 1 or 2 segments');
+        throw new Error('scopeDir: group-topic.path must have 1 or 2 segments');
       }
-      for (const s of segs) assertSafeSegment(s, 'topic.path');
-      return `topic/${segs.join('/')}`;
+      for (const s of segs) assertSafeSegment(s, 'group-topic.path');
+      return `group/${scope.groupId}/topic/${segs.join('/')}`;
     }
     default:
       throw new Error(`scopeDir: unknown kind ${JSON.stringify(scope.kind)}`);
@@ -140,7 +161,8 @@ function assertSafeSegment(s, ctx) {
  * @returns {boolean}
  */
 export function isValidTopic(scope) {
-  if (!scope || scope.kind !== 'topic') return false;
+  if (!scope || scope.kind !== 'group-topic') return false;
+  if (!scope.groupId || typeof scope.groupId !== 'string') return false;
   if (!Array.isArray(scope.path)) return false;
   if (scope.path.length < 1 || scope.path.length > 2) return false;
   for (const s of scope.path) {
@@ -155,7 +177,9 @@ export function isValidTopic(scope) {
 // ─── ACL ───────────────────────────────────────────────────────
 
 /**
- * The single ACL: `vp/<other>` is foreign when `currentVpId` is given.
+ * The single ACL: `group/<g>/vp/<other>` is foreign when `currentVpId` is given.
+ * Across groups, every `group/<g>/vp/...` path is foreign by construction
+ * (the calling VP only runs inside its own group dir).
  *
  * @param {string} relPath
  * @param {string} currentVpId
@@ -163,7 +187,7 @@ export function isValidTopic(scope) {
  */
 export function isVpForeign(relPath, currentVpId) {
   if (!relPath || !currentVpId) return false;
-  const m = /^vp\/([^/]+)(?:\/|$)/.exec(relPath);
+  const m = /^group\/[^/]+\/vp\/([^/]+)(?:\/|$)/.exec(relPath);
   if (!m) return false;
   return m[1] !== currentVpId;
 }
@@ -403,18 +427,17 @@ export async function ensureScope(scope, opts = {}) {
 
 /**
  * Enumerate all scopes present on disk. Returns Scope shapes that round-trip
- * back through `scopeDir`. Used by Triage to list candidate
- * scopes for a group's diff.
+ * back through `scopeDir`. Used by Triage to list candidate scopes.
  *
  * Walks shallowly:
- *   user/                       → { kind: 'user' }
- *   vp/<id>/                    → { kind: 'vp', id }
- *   group/<id>/                 → { kind: 'group', id }
- *   feature/<id>/               → { kind: 'feature', id }
- *   topic/<l1>/[<l2>/]          → { kind: 'topic', path: [...] }
+ *   user/                                  → { kind: 'user' }
+ *   group/<g>/                             → { kind: 'group', id: g }
+ *   group/<g>/user/                        → { kind: 'group-user', groupId: g }
+ *   group/<g>/vp/<v>/                      → { kind: 'group-vp', groupId: g, id: v }
+ *   group/<g>/feature/<f>/                 → { kind: 'group-feature', groupId: g, id: f }
+ *   group/<g>/topic/<l1>[/<l2>]/           → { kind: 'group-topic', groupId: g, path: [...] }
  *
- * Skips entries that are not directories, and any name that fails segment
- * validation (e.g. accidental `.tmp.*` files at scope root, dotfiles).
+ * Skips `.legacy/` and any dotfile / unsafe segment.
  *
  * @param {{ root?: string }} [opts]
  * @returns {Promise<Scope[]>}
@@ -427,53 +450,77 @@ export async function listScopes(opts = {}) {
   // user/
   if (existsSync(join(root, 'user'))) out.push({ kind: 'user' });
 
-  // vp/, group/, feature/ — single-level ids
-  for (const kind of ['vp', 'group', 'feature']) {
-    const dir = join(root, kind);
-    let names;
-    try { names = await fsp.readdir(dir, { withFileTypes: true }); }
-    catch (err) {
-      if (err && err.code === 'ENOENT') continue;
-      throw err;
+  // group/<g>/...
+  const groupRoot = join(root, 'group');
+  let groups;
+  try { groups = await fsp.readdir(groupRoot, { withFileTypes: true }); }
+  catch (err) {
+    if (err && err.code === 'ENOENT') return out;
+    throw err;
+  }
+
+  for (const gent of groups) {
+    if (!gent.isDirectory()) continue;
+    if (gent.name.startsWith('.')) continue;
+    if (!isSafeId(gent.name)) continue;
+    const g = gent.name;
+    out.push({ kind: 'group', id: g });
+    const gAbs = join(groupRoot, g);
+
+    // group/<g>/user/
+    if (existsSync(join(gAbs, 'user'))) {
+      out.push({ kind: 'group-user', groupId: g });
     }
-    for (const ent of names) {
-      if (!ent.isDirectory()) continue;
-      const id = ent.name;
-      if (!isSafeId(id)) continue;
-      out.push({ kind, id });
+
+    // group/<g>/vp/<v>/  and  group/<g>/feature/<f>/
+    for (const kind of ['vp', 'feature']) {
+      const dir = join(gAbs, kind);
+      let names;
+      try { names = await fsp.readdir(dir, { withFileTypes: true }); }
+      catch (err) {
+        if (err && err.code === 'ENOENT') continue;
+        throw err;
+      }
+      for (const ent of names) {
+        if (!ent.isDirectory()) continue;
+        if (!isSafeId(ent.name)) continue;
+        out.push({
+          kind: kind === 'vp' ? 'group-vp' : 'group-feature',
+          groupId: g,
+          id: ent.name,
+        });
+      }
     }
-  }
 
-  // topic/<l1>/[<l2>/]
-  const topicDir = join(root, 'topic');
-  let l1s;
-  try { l1s = await fsp.readdir(topicDir, { withFileTypes: true }); }
-  catch (err) {
-    if (err && err.code === 'ENOENT') l1s = [];
-    else throw err;
-  }
-  for (const l1ent of l1s) {
-    if (!l1ent.isDirectory()) continue;
-    if (!isSafeId(l1ent.name)) continue;
-    const l1 = l1ent.name;
-    // Read l2 entries; if l1 itself contains memory.md, treat as 1-level topic
-    const l1abs = join(topicDir, l1);
-    let l2s;
-    try { l2s = await fsp.readdir(l1abs, { withFileTypes: true }); }
-    catch { l2s = []; }
-    let hasL2 = false;
-    for (const l2ent of l2s) {
-      if (!l2ent.isDirectory()) continue;
-      if (!isSafeId(l2ent.name)) continue;
-      out.push({ kind: 'topic', path: [l1, l2ent.name] });
-      hasL2 = true;
+    // group/<g>/topic/<l1>/[<l2>/]
+    const topicDir = join(gAbs, 'topic');
+    let l1s;
+    try { l1s = await fsp.readdir(topicDir, { withFileTypes: true }); }
+    catch (err) {
+      if (err && err.code === 'ENOENT') l1s = [];
+      else throw err;
     }
-    // 1-level topic: present iff l1 has memory.md or summary.md directly
-    if (!hasL2) {
-      const hasMemory = existsSync(join(l1abs, 'memory.md'));
-      const hasSummary = existsSync(join(l1abs, 'summary.md'));
-      if (hasMemory || hasSummary) {
-        out.push({ kind: 'topic', path: [l1] });
+    for (const l1ent of l1s) {
+      if (!l1ent.isDirectory()) continue;
+      if (!isSafeId(l1ent.name)) continue;
+      const l1 = l1ent.name;
+      const l1abs = join(topicDir, l1);
+      let l2s;
+      try { l2s = await fsp.readdir(l1abs, { withFileTypes: true }); }
+      catch { l2s = []; }
+      let hasL2 = false;
+      for (const l2ent of l2s) {
+        if (!l2ent.isDirectory()) continue;
+        if (!isSafeId(l2ent.name)) continue;
+        out.push({ kind: 'group-topic', groupId: g, path: [l1, l2ent.name] });
+        hasL2 = true;
+      }
+      if (!hasL2) {
+        const hasMemory = existsSync(join(l1abs, 'memory.md'));
+        const hasSummary = existsSync(join(l1abs, 'summary.md'));
+        if (hasMemory || hasSummary) {
+          out.push({ kind: 'group-topic', groupId: g, path: [l1] });
+        }
       }
     }
   }

package/yeaft/session.js

@@ -45,7 +45,7 @@ import { ToolUsageStats } from './stats/tool-usage.js';
 import { ensureDefaultGroupIfEmpty } from './groups/group-crud.js';
 import { seedDefaultVps } from './vp/seed-defaults.js';
 import { topUpDefaultVps } from './vp/seed-topup.js';
-import { runSummaryBackfill } from './memory/seed-backfill.js';
+import { runSummaryBackfill, archiveLegacyScopes } from './memory/seed-backfill.js';
 import { createV2DreamScheduler, bootInitEmptyGroups, bootCatchUpStaleDream } from './dream-v2/session-wiring.js';
 import { openSegmentIndex } from './memory/index-db.js';
 import { syncAll as syncSegmentIndex } from './memory/segment-sync.js';
@@ -235,6 +235,16 @@ export async function loadSession(options = {}) {
       const indexPath = join(yeaftDir, 'memory', 'index.db');
       memoryIndex = openSegmentIndex(indexPath);
       const memoryRoot = join(yeaftDir, 'memory');
+      // One-shot migration to the group-isolated memory layout: move any
+      // remaining top-level vp/ feature/ topic/ dirs into .legacy/ before
+      // we open the FTS index and re-sync from disk.
+      try {
+        archiveLegacyScopes(memoryRoot);
+      } catch (archiveErr) {
+        if (config.debug) {
+          console.warn(`[Yeaft] legacy scope archive warning: ${archiveErr?.message || archiveErr}`);
+        }
+      }
       try {
         syncSegmentIndex(memoryRoot, memoryIndex);
       } catch (syncErr) {

package/yeaft/vp/vp-crud.js

@@ -23,7 +23,6 @@ import { join } from 'path';
 import { homedir } from 'os';
 import { validateVpId } from '../groups/ids.js';
 import { DEFAULT_VP_LIB_DIR, parseRoleMd } from './vp-store.js';
-import { seedSummaryIfMissingSync, removeScopeDirSync } from '../memory/store-v2.js';
 import { VP_STUB_MARKER } from '../memory/seed-backfill.js';
 import { STOCK_VP_IDS } from './stock-ids.js';
 
@@ -178,22 +177,9 @@ export function createVp(payload, options = {}) {
   mkdirSync(join(dir, 'memory'), { recursive: true });
   writeFileSync(vpRolePathFor(libDir, vpId), buildRoleMd({ ...payload, vpId }), 'utf-8');
 
-  // Seed the VP's Layer-A resident summary so the first session has SOMETHING
-  // for engine.#loadLayerASummaries to read. Without this, fresh VPs have
-  // an empty memory section in the system prompt until Dream-v2 runs (which
-  // requires a non-empty diff stream — i.e. several turns of activity).
-  // We only seed when the file is missing/empty: this is safe to re-run and
-  // never clobbers Dream-v2 writes. Failures are best-effort: a memory-root
-  // permission failure must NOT break VP creation.
-  try {
-    seedSummaryIfMissingSync(
-      { kind: 'vp', id: vpId },
-      buildVpSeedSummary({ ...payload, vpId }),
-      { root: memoryRoot },
-    );
-  } catch (err) {
-    console.warn(`[vp-crud] failed to seed summary.md for ${vpId}:`, err?.message || err);
-  }
+  // Note: VP memory is now per-group (group/<g>/vp/<vpId>/...) — no global
+  // VP scope to seed at create time. Per-group summaries spring into being
+  // when dream first writes for that VP inside a group.
 
   return { vpId, dir };
 }
@@ -258,13 +244,10 @@ export function deleteVp(vpId, options = {}) {
     throw new VpCrudError('not_found', vpId);
   }
   rmSync(dir, { recursive: true, force: true });
-  // Cascade: drop the VP's memory scope so a recreate with the same id
-  // starts clean. Best-effort — never let memory cleanup fail the CRUD op.
-  try {
-    removeScopeDirSync({ kind: 'vp', id: vpId }, { root: memoryRoot });
-  } catch (err) {
-    console.warn(`[vp-crud] failed to remove memory dir for ${vpId}:`, err?.message || err);
-  }
+  // VP memory is per-group now (group/<g>/vp/<id>/...). We deliberately do
+  // NOT cascade-delete across every group dir on disk — that would couple
+  // VP CRUD to the group registry. Stale per-group VP scopes get pruned by
+  // dream's natural rewrite cycle, or by group deletion.
   return { vpId };
 }