@yeaft/webchat-agent 0.1.856 → 0.1.857

package/package.json

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

package/yeaft/compact/orchestrator.js

@@ -28,7 +28,6 @@
  */
 
 import { groupTurns, pickCoolingGroups, indicesFromGroups } from './turn-group.js';
-import { writeSummary } from '../memory/store-v2.js';
 
 /**
  * @typedef {{
@@ -57,7 +56,7 @@ import { writeSummary } from '../memory/store-v2.js';
  *   nextMessages: object[],
  * }>}
  */
-export async function runCompact({ messages, keepHot = 10, taskId = null, root, hooks }) {
+export async function runCompact({ messages, keepHot = 10, hooks }) {
   if (!Array.isArray(messages)) {
     throw new Error('runCompact: messages array required');
   }
@@ -104,17 +103,12 @@ export async function runCompact({ messages, keepHot = 10, taskId = null, root,
     archiveResults.push({ ...g, turnId: r?.turnId });
   }
 
-  // Track 2 — refresh task summary if applicable.
-  let taskSummaryRefreshed = false;
-  if (taskId && root && typeof hooks.refreshTaskSummary === 'function') {
-    const prior = typeof hooks.readPriorTaskSummary === 'function'
-      ? await hooks.readPriorTaskSummary() : '';
-    const next = await hooks.refreshTaskSummary(coolingMessages, prior);
-    if (typeof next === 'string' && next.trim()) {
-      await writeSummary({ kind: 'feature', id: taskId }, next, { root });
-      taskSummaryRefreshed = true;
-    }
-  }
+  // Track 2 — task summary refresh: removed. The legacy `feature/<id>` root
+  // scope was dropped along with the Feature system (2026-05-13); under the
+  // group-isolated layout feature summaries would live at
+  // `group/<g>/feature/<id>/` and are written by dream, not by post-turn
+  // compact. Engine no longer passes `taskId`/`root` to this orchestrator.
+  const taskSummaryRefreshed = false;
 
   // Track 3 — memory extraction.
   let extractedCount = 0;

package/yeaft/dream-v2/apply.js

@@ -120,12 +120,28 @@ export function targetToScope(target) {
   if (!target || typeof target !== 'string') throw new Error('apply.targetToScope: target required');
   if (target === 'user') return { kind: 'user' };
   const segs = target.split('/').filter(Boolean);
-  const head = segs[0];
-  if (head === 'vp' && segs.length === 2) return { kind: 'vp', id: segs[1] };
-  if (head === 'group' && segs.length === 2) return { kind: 'group', id: segs[1] };
-  if (head === 'feature' && segs.length === 2) return { kind: 'feature', id: segs[1] };
-  if (head === 'topic' && (segs.length === 2 || segs.length === 3)) {
-    return { kind: 'topic', path: segs.slice(1) };
+  // Legacy scopes — explicitly rejected. Old data lives under .legacy/.
+  if (segs[0] === 'vp' || segs[0] === 'feature' || segs[0] === 'topic') {
+    throw new Error(`apply.targetToScope: legacy root scope ${JSON.stringify(target)} rejected — use group/<g>/${segs[0]}/...`);
+  }
+  if (segs[0] === 'group') {
+    if (segs.length === 2) return { kind: 'group', id: segs[1] };
+    // group/<g>/user
+    if (segs.length === 3 && segs[2] === 'user') {
+      return { kind: 'group-user', groupId: segs[1] };
+    }
+    // group/<g>/vp/<v>
+    if (segs.length === 4 && segs[2] === 'vp') {
+      return { kind: 'group-vp', groupId: segs[1], id: segs[3] };
+    }
+    // group/<g>/feature/<f>
+    if (segs.length === 4 && segs[2] === 'feature') {
+      return { kind: 'group-feature', groupId: segs[1], id: segs[3] };
+    }
+    // group/<g>/topic/<l1>[/<l2>]
+    if (segs[2] === 'topic' && (segs.length === 4 || segs.length === 5)) {
+      return { kind: 'group-topic', groupId: segs[1], path: segs.slice(3) };
+    }
   }
   throw new Error(`apply.targetToScope: malformed target ${JSON.stringify(target)}`);
 }
@@ -252,11 +268,12 @@ export async function applyMergedTarget(merged, opts) {
 
 function scopeRelDir(scope) {
   switch (scope.kind) {
-    case 'user':    return 'user';
-    case 'vp':      return `vp/${scope.id}`;
-    case 'group':   return `group/${scope.id}`;
-    case 'feature': return `feature/${scope.id}`;
-    case 'topic':   return `topic/${scope.path.join('/')}`;
+    case 'user':          return 'user';
+    case 'group':         return `group/${scope.id}`;
+    case 'group-user':    return `group/${scope.groupId}/user`;
+    case 'group-vp':      return `group/${scope.groupId}/vp/${scope.id}`;
+    case 'group-feature': return `group/${scope.groupId}/feature/${scope.id}`;
+    case 'group-topic':   return `group/${scope.groupId}/topic/${scope.path.join('/')}`;
     default: throw new Error(`apply.scopeRelDir: unknown kind ${scope.kind}`);
   }
 }

package/yeaft/dream-v2/prompts/index.js

@@ -41,8 +41,15 @@ const FILES = {
 export function extractTemplateForScope(scope) {
   if (!scope || typeof scope !== 'string') return 'extractTopic';
   if (scope === 'user') return 'extractUser';
-  if (scope.startsWith('vp/')) return 'extractVp';
+  // Nested group-isolated scopes must be matched BEFORE the bare `group/<g>`
+  // branch so VPs/topics/features under a group don't get the group template.
+  if (/^group\/[^/]+\/vp\//.test(scope)) return 'extractVp';
+  if (/^group\/[^/]+\/topic\//.test(scope)) return 'extractTopic';
+  if (/^group\/[^/]+\/user(?:\/|$)/.test(scope)) return 'extractUser';
   if (scope.startsWith('group/')) return 'extractGroup';
+  // Legacy top-level vp/topic scopes (archived to .legacy/ on boot — kept
+  // here defensively in case something still constructs the old strings).
+  if (scope.startsWith('vp/')) return 'extractVp';
   if (scope.startsWith('topic/')) return 'extractTopic';
   return 'extractTopic';
 }

package/yeaft/dream-v2/runner.js

@@ -95,9 +95,14 @@ export async function runDream(opts) {
   const processedGroups = [];
 
   // 2. per-group: skip / segment / triage
-  const topicSummaries = opts.listTopicSummaries
-    ? await safeCall(opts.listTopicSummaries, [])
-    : await defaultListTopicSummaries(opts.root, opts.language).catch(() => []);
+  // Topic summaries are now per-group (group/<g>/topic/...), so resolve
+  // them inside the per-group loop instead of once up front.
+  const resolveTopicSummaries = async (groupId) => {
+    if (opts.listTopicSummaries) {
+      return await safeCall(() => opts.listTopicSummaries(groupId), []);
+    }
+    return await defaultListTopicSummaries(opts.root, groupId, opts.language).catch(() => []);
+  };
 
   for (const groupId of groupIds) {
     // Current-group manual dream passes are the one case where scopeFilter
@@ -152,6 +157,7 @@ export async function runDream(opts) {
 
     let actions;
     try {
+      const topicSummaries = await resolveTopicSummaries(groupId);
       actions = await triageGroupSegments({
         groupId,
         segments,
@@ -304,11 +310,12 @@ async function safeCall(fn, fallback) {
   }
 }
 
-async function defaultListTopicSummaries(root, language) {
+async function defaultListTopicSummaries(root, groupId, language) {
   const all = await listScopes({ root });
   const out = [];
   for (const sc of all) {
-    if (sc.kind !== 'topic') continue;
+    if (sc.kind !== 'group-topic') continue;
+    if (sc.groupId !== groupId) continue;
     const summary = await readSummary(sc, { root, language });
     out.push({ path: sc.path.join('/'), summary });
   }

package/yeaft/dream-v2/triage.js

@@ -62,20 +62,24 @@ export function applyHardRules({ groupId, messages }) {
   const out = new Map();
   const add = (scope) => { if (!out.has(scope)) out.set(scope, { kind: 'update', scope }); };
 
-  // user is always in.
+  // global user is always in.
   add('user');
 
-  // active group, except the virtual _no-group bucket.
-  if (groupId && groupId !== '_no-group') add(`group/${groupId}`);
+  // active group + its per-group user layer, except the virtual _no-group bucket.
+  if (groupId && groupId !== '_no-group') {
+    add(`group/${groupId}`);
+    add(`group/${groupId}/user`);
+  }
 
   for (const m of (messages || [])) {
     if (!m || typeof m !== 'object') continue;
-    // Active VP: any assistant message's vpId.
+    // Active VP: any assistant message's vpId — now group-internal.
     if (m.role === 'assistant') {
       const vp = m.vpId || (m.author && /^vp:(.+)$/.exec(m.author)?.[1]);
-      if (vp && /^[A-Za-z0-9_\-.一-鿿]+$/.test(vp)) add(`vp/${vp}`);
+      if (vp && /^[A-Za-z0-9_\-.一-鿿]+$/.test(vp) && groupId && groupId !== '_no-group') {
+        add(`group/${groupId}/vp/${vp}`);
+      }
     }
-    // (Active feature scope was dropped 2026-05-13 with the Feature system.)
   }
 
   return Array.from(out.values());
@@ -161,8 +165,9 @@ export async function classifySoft({ groupId, messages, topicSummaries, llm, lan
     const path = String(pass2.path || '').trim();
     if (!path) continue;
     const segs = path.split('/').filter(Boolean);
-    if (!isValidTopic({ kind: 'topic', path: segs })) continue;
-    const scope = `topic/${segs.join('/')}`;
+    if (!groupId || groupId === '_no-group') continue;
+    if (!isValidTopic({ kind: 'group-topic', groupId, path: segs })) continue;
+    const scope = `group/${groupId}/topic/${segs.join('/')}`;
     if (pass2.decision === 'match') {
       out.push({ kind: 'update', scope });
     } else if (pass2.decision === 'new') {

package/yeaft/engine.js

@@ -569,8 +569,8 @@ export class Engine {
       groupId
         ? readScopeSummary({ kind: 'group', id: groupId }, { root: memoryRoot, language }).catch(() => '')
         : Promise.resolve(''),
-      vpId
-        ? readScopeSummary({ kind: 'vp', id: vpId }, { root: memoryRoot, language }).catch(() => '')
+      vpId && groupId
+        ? readScopeSummary({ kind: 'group-vp', groupId, id: vpId }, { root: memoryRoot, language }).catch(() => '')
         : Promise.resolve(''),
     ];
     const [user, group, vp] = await Promise.all(tasks);

package/yeaft/groups/pre-flow.js

@@ -167,6 +167,15 @@ export function selectRespondingVps(input) {
  */
 function scopeHeading(scope) {
   if (scope === 'user') return '## Memory: User';
+  // Nested group scopes first.
+  let m = /^group\/([^/]+)\/vp\/(.+)$/.exec(scope);
+  if (m) return `## Memory: VP ${m[2]}`;
+  m = /^group\/([^/]+)\/user$/.exec(scope);
+  if (m) return `## Memory: Group ${m[1]} (user)`;
+  m = /^group\/([^/]+)\/feature\/(.+)$/.exec(scope);
+  if (m) return `## Memory: Feature ${m[2]}`;
+  m = /^group\/([^/]+)\/topic\/(.+)$/.exec(scope);
+  if (m) return `## Memory: Topic ${m[2]}`;
   if (scope.startsWith('group/')) return `## Memory: Group ${scope.slice(6)}`;
   if (scope.startsWith('vp/')) return `## Memory: VP ${scope.slice(3)}`;
   if (scope.startsWith('feature/')) return `## Memory: Feature ${scope.slice(8)}`;
@@ -238,8 +247,11 @@ export function formatPickedForInjection(picked) {
  */
 export function buildRelevantScopes({ groupId, vpId, extra } = {}) {
   const scopes = ['user'];
-  if (groupId) scopes.push(`group/${groupId}`);
-  if (vpId) scopes.push(`vp/${vpId}`);
+  if (groupId) {
+    scopes.push(`group/${groupId}`);
+    scopes.push(`group/${groupId}/user`);
+    if (vpId) scopes.push(`group/${groupId}/vp/${vpId}`);
+  }
   if (Array.isArray(extra)) {
     for (const s of extra) {
       if (s && !scopes.includes(s)) scopes.push(s);

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 };
 }