@yeaft/webchat-agent 0.1.854 → 0.1.857

package/{unify → yeaft}/llm/models-dev.js

@@ -25,6 +25,7 @@ const NETWORK_TIMEOUT_MS = 15000;
 const STALE_GRACE_MS = 5 * 60 * 1000; // 5 minutes when serving stale-after-failure
 
 let _memCache = null;
+let _memCachePath = null;
 let _memCacheTime = 0;
 
 function getCachePath(yeaftDir) {
@@ -71,8 +72,10 @@ async function saveDiskCache(yeaftDir, data) {
  * @returns {Promise<object>} provider-id → provider entry; {} on total failure.
  */
 export async function fetchModelsDev({ forceRefresh = false, yeaftDir = null } = {}) {
+  const cachePath = getCachePath(yeaftDir);
+
   // Stage 1: in-memory cache.
-  if (!forceRefresh && _memCache && Date.now() - _memCacheTime < CACHE_TTL_MS) {
+  if (!forceRefresh && _memCache && _memCachePath === cachePath && Date.now() - _memCacheTime < CACHE_TTL_MS) {
     return _memCache;
   }
 
@@ -83,6 +86,7 @@ export async function fetchModelsDev({ forceRefresh = false, yeaftDir = null } =
       const data = await loadDiskCache(yeaftDir);
       if (data && typeof data === 'object') {
         _memCache = data;
+        _memCachePath = cachePath;
         _memCacheTime = Date.now() - age;
         return _memCache;
       }
@@ -99,6 +103,7 @@ export async function fetchModelsDev({ forceRefresh = false, yeaftDir = null } =
       const data = await res.json();
       if (data && typeof data === 'object') {
         _memCache = data;
+        _memCachePath = cachePath;
         _memCacheTime = Date.now();
         await saveDiskCache(yeaftDir, data);
         return data;
@@ -111,15 +116,16 @@ export async function fetchModelsDev({ forceRefresh = false, yeaftDir = null } =
   }
 
   // Stage 4: stale disk cache fallback with short grace TTL so we retry soon.
-  if (!_memCache) {
+  if (!_memCache || _memCachePath !== cachePath) {
     const data = await loadDiskCache(yeaftDir);
     if (data && typeof data === 'object') {
       _memCache = data;
+      _memCachePath = cachePath;
       _memCacheTime = Date.now() - CACHE_TTL_MS + STALE_GRACE_MS;
     }
   }
 
-  return _memCache || {};
+  return _memCachePath === cachePath ? (_memCache || {}) : {};
 }
 
 /**
@@ -156,5 +162,6 @@ export async function listProviderModels(providerId, { yeaftDir = null } = {}) {
  */
 export function _resetMemCache() {
   _memCache = null;
+  _memCachePath = null;
   _memCacheTime = 0;
 }

package/{unify → yeaft}/llm/openai-responses.js

@@ -43,12 +43,12 @@ import {
 const DEFAULT_BASE_URL = 'https://api.openai.com/v1';
 
 /**
- * Feature-flag accessor mirroring anthropic.js. UNIFY_THINKING_V1 is OFF by
+ * Feature-flag accessor mirroring anthropic.js. YEAFT_THINKING_V1 is OFF by
  * default; set env to '1' to enable thinking-mode field translation. Read
  * lazily so tests can flip the flag between calls.
  */
 function thinkingV1Enabled() {
-  return process.env.UNIFY_THINKING_V1 === '1';
+  return process.env.YEAFT_THINKING_V1 === '1';
 }
 
 /**

package/{unify → yeaft}/llm/router.js

@@ -78,7 +78,7 @@ export function inferProtocolFromModelId(modelId) {
  * task-327a: feature-flag accessor. Read lazily so tests can flip.
  */
 function thinkingV1Enabled() {
-  return process.env.UNIFY_THINKING_V1 === '1';
+  return process.env.YEAFT_THINKING_V1 === '1';
 }
 
 /**

package/{unify → yeaft}/mcp.js

@@ -19,7 +19,7 @@
  *
  * Each MCP server communicates via stdio JSON-RPC (MCP protocol).
  *
- * Reference: yeaft-unify-design.md §8, yeaft-unify-core-systems.md §3.2
+ * Reference: yeaft-yeaft-design.md §8, yeaft-yeaft-core-systems.md §3.2
  */
 
 import { spawn } from 'child_process';

package/{unify → 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/{unify → yeaft}/memory/ams-registry.js

@@ -24,7 +24,7 @@
  * the next time the group is opened. Resident layer is derived state
  * (rebuilt every turn from `<scope>/summary.md`) — never persisted.
  *
- * For the single-VP Unify path (no group), the registry uses the literal
+ * For the single-VP Yeaft path (no group), the registry uses the literal
  * key `"default"` so there's still a stable home for AMS state.
  */
 

package/{unify → 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/{unify → 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/{unify → yeaft}/memory/seed-backfill.js

@@ -1,7 +1,7 @@
 /**
  * memory/seed-backfill.js — Run-once backfill of `summary.md` for VPs and
  * groups that were created BEFORE the create-time seed was added (PR
- * "fix-unify-context-and-memory"). Without backfill, an existing user's
+ * "fix-yeaft-context-and-memory"). Without backfill, an existing user's
  * `grp_claude` group and `steve` VP never get a Layer-A resident summary —
  * `engine.#prepareAms` then renders an empty memory section every turn,
  * which is the user-visible Bug #2.
@@ -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/{unify → 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/{unify → yeaft}/memory/store-v2.js

@@ -37,7 +37,7 @@
  *     by `dream-v2/state.js`, not here.
  *   - No LLM calls, no extraction, no summarisation. Pure I/O.
  *
- * Reference: agent/unify/memory/DESIGN-H2-AMS.md.
+ * Reference: agent/yeaft/memory/DESIGN-H2-AMS.md.
  */
 
 import {
@@ -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']);
+/** 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'|'vp'|'group'|'feature'|'topic'} ScopeKind */
+/** @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/{unify → yeaft}/models.js

@@ -1,5 +1,5 @@
 /**
- * models.js — Model ID registry for Yeaft Unify
+ * models.js — Model ID registry for Yeaft Yeaft
  *
  * Maps model IDs (e.g. "gpt-5", "claude-sonnet-4-20250514") to their
  * adapter type, API base URL, and capabilities.
@@ -305,7 +305,7 @@ export function parseModelRef(ref) {
 // ─── task-327a: thinking / reasoning capability ─────────────────
 
 /**
- * Valid effort levels accepted by Unify adapters.
+ * Valid effort levels accepted by Yeaft adapters.
  * @typedef {'low' | 'medium' | 'high' | 'max'} Effort
  */
 
@@ -325,7 +325,7 @@ export const ANTHROPIC_THINKING_BUDGETS = {
 };
 
 /**
- * Map a Unify effort level to the OpenAI reasoning.effort enum. OpenAI does
+ * Map a Yeaft effort level to the OpenAI reasoning.effort enum. OpenAI does
  * not expose a 'max' level — callers that pass 'max' get 'high' (the highest
  * available on that protocol). The router/engine should log this downgrade
  * but the adapter MUST NOT error.

package/{unify → yeaft}/pair-sanitize.js

@@ -3,8 +3,8 @@
  * slice so it can be safely fed to the LLM adapter.
  *
  * Why this exists:
- *   `agent/unify/conversation/persist.js#loadRecentByGroup` and
- *   `agent/unify/history-compact.js#compactHistory` both produce
+ *   `agent/yeaft/conversation/persist.js#loadRecentByGroup` and
+ *   `agent/yeaft/history-compact.js#compactHistory` both produce
  *   sub-slices of a longer message stream. Both paths can — depending on
  *   where the cut lands — produce one of two illegal shapes:
  *     1. A `role: 'tool'` message whose owning assistant `tool_use` is

package/{unify → yeaft}/personas.js

@@ -5,7 +5,7 @@
  * model tier it runs on, and what system prompt it carries.
  *
  * Presets live as markdown files with YAML frontmatter in
- * `agent/unify/templates/personas/*.md`.
+ * `agent/yeaft/templates/personas/*.md`.
  */
 
 import { readFileSync, readdirSync } from 'fs';

package/{unify → yeaft}/prompts.js

@@ -4,7 +4,7 @@
  * Single source of truth for system prompts. Both engine.js and cli.js
  * import buildSystemPrompt() from here. Supports 'en' and 'zh'.
  *
- * Template files from agent/unify/templates/ are loaded once at startup
+ * Template files from agent/yeaft/templates/ are loaded once at startup
  * and used to enrich the system prompt beyond the hardcoded fallbacks.
  *
  * Concept layering (DESIGN-PROMPT §3):

package/{unify → yeaft}/routing/index.js

@@ -6,7 +6,7 @@
  *   - router:     route_forward → coordinator.ingest wrapper with guard,
  *                  self-reject, task.members forwarding, and causedBy chain.
  *
- * See agent/unify/tools/route-forward.js for the VP-facing tool.
+ * See agent/yeaft/tools/route-forward.js for the VP-facing tool.
  */
 
 export {

package/{unify → yeaft}/routing/router.js

@@ -22,7 +22,7 @@
  *   (a) Does NOT touch RoleInstance state machine internals (that's 334c).
  *   (b) Does NOT touch live-diff (334h).
  *   (c) Persistence routes through group.appendMessage via Coordinator.
- *   (d) Tool schema uses defineTool (agent/unify/tools/types.js).
+ *   (d) Tool schema uses defineTool (agent/yeaft/tools/types.js).
  */
 
 import { resolveMemberId } from '../groups/roster.js';