total-recall-brain 3.28.0 → 3.28.2

package/frontend/src/App.spec.tsx

@@ -11,6 +11,10 @@ vi.mock('./api', () => ({
   fetchHealth: vi.fn(),
   getApiBase: vi.fn(),
   setApiBase: vi.fn(),
+  // App calls fetchPlugins() on mount. A mock module that omits it makes
+  // vitest throw "No fetchPlugins export is defined on the ./api mock", which
+  // unmounts the whole tree and left every assertion staring at an empty div.
+  fetchPlugins: vi.fn().mockResolvedValue([]),
 }));
 
 vi.mock('./utils/onboarding', () => ({

package/frontend/src/pages/PluginsPage.spec.tsx

@@ -1,5 +1,6 @@
 import { describe, it, expect, vi } from 'vitest';
 import { render, screen } from '@testing-library/react';
+import { MemoryRouter } from 'react-router-dom';
 import PluginsPage from './PluginsPage';
 
 // Mock fetch globally
@@ -11,7 +12,14 @@ globalThis.fetch = mockFetch as unknown as typeof fetch;
 
 describe('PluginsPage', () => {
   it('renders plugins page', () => {
-    render(<PluginsPage />);
-    expect(screen.getByText(/Plugin/i)).toBeInTheDocument();
+    // PluginsPage reads useSearchParams(), so it must be rendered inside a
+    // Router — without one react-router throws and nothing mounts.
+    render(
+      <MemoryRouter>
+        <PluginsPage />
+      </MemoryRouter>,
+    );
+    // getByText(/Plugin/i) matched both the heading and the install button.
+    expect(screen.getByRole('heading', { name: /Plugins/i })).toBeInTheDocument();
   });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "total-recall-brain",
-  "version": "3.28.0",
+  "version": "3.28.2",
   "description": "Personal AI system — database-free, SSSS-powered intelligence engine deployable to any POSIX host.",
   "type": "module",
   "workspaces": [

package/scaffold/openwiki/README.md

@@ -0,0 +1,10 @@
+# OpenWiki
+
+Portable knowledge documentation for this Total Recall brain.
+
+| Layer | Purpose |
+|-------|---------|
+| **Memory vault** | SSSS nodes (rules, prefs, facts) — machine-enforceable |
+| **OpenWiki** | Human/agent docs (architecture, how-tos, stack notes) |
+
+OpenWiki ships with Total Recall. Edit freely; do not put secrets here.

package/scaffold/openwiki/architecture.md

@@ -0,0 +1,5 @@
+# Architecture (this brain)
+
+Describe the systems this brain cares about: repos, stacks, deploy targets.
+
+Project brains should document the local codebase; the global brain documents cross-repo identity and preferences.

package/scaffold/openwiki/ide.md

@@ -0,0 +1,10 @@
+# IDE personalization
+
+```bash
+npx total-recall connect claude-code   # CLAUDE.md
+npx total-recall connect codex         # AGENTS.md
+npx total-recall connect cursor        # .cursor/rules/
+npx total-recall connect gemini        # GEMINI.md
+```
+
+Total Recall only writes inside managed inject markers. Your local rules stay intact.

package/scaffold/openwiki/memory.md

@@ -0,0 +1,11 @@
+# Memory
+
+Use the Total Recall CLI for durable memory:
+
+```bash
+npx total-recall remember invariant "Never commit secrets." --importance 5
+npx total-recall recall "secrets"
+npx total-recall compile
+```
+
+Categories: invariants, preferences, facts, decisions, patterns, anti-patterns, concepts, lore.

package/scaffold/openwiki/secrets.md

@@ -0,0 +1,7 @@
+# Secrets & API keys
+
+Store credentials in Total Recall's secrets store (`config/secrets.enc` / future CLI).
+
+**Never** put API keys in openwiki pages or compiled IDE instruction files.
+
+Planned CLI surface (TR_CORE_FOCUS Phase 4): `secret set|list|rotate|audit` and usage/cost meters.

package/scaffold/openwiki/skills.md

@@ -0,0 +1,7 @@
+# Skills
+
+- **Total Recall skill** (only nested agent skill): `.agent/skills/total-recall/SKILL.md`
+- **User skills**: `.agent/skills/<name>/SKILL.md` — project or global
+- **TR modules** (not skills): `.agent/skills/total-recall/modules/` — internal docs/scripts
+
+TR will track skill installs across repos and support adaptive deploy (see TR_CORE_FOCUS).

package/src/cli/connect.mjs

@@ -79,6 +79,13 @@ const CLIENTS = {
     // Cline uses a .clinerules/ directory (primary); plain markdown, no frontmatter.
     target: path.join('.clinerules', 'total-recall.md'),
     render: instructions => instructions,
+    // Cline scans <project>/.clinerules/skills, <project>/.cline/skills,
+    // <project>/.claude/skills and <project>/.agents/skills (plus the global
+    // ~/.cline/skills and ~/.agents/skills). Only .clinerules/.cline/.agents are
+    // scanned by the `next` (SDK) bundle too — .claude/skills is VS Code-bundle
+    // only — so project into .agents/skills, which is also where Cline's own
+    // "New skill..." writes and where the codex/gemini/antigravity presets land.
+    skillsProjection: { scope: 'project', dir: path.join('.agents', 'skills') },
   },
   'claude-code': {
     label: 'Claude Code',
@@ -93,9 +100,8 @@ const CLIENTS = {
     label: 'Codex',
     mode: 'symlink',
     target: 'AGENTS.md',
-    // Codex only discovers skills globally under $CODEX_HOME/skills (~/.codex/skills).
-    // There is no project-local skills dir, so this projection is global by necessity.
-    skillsProjection: { scope: 'home', dir: path.join('.codex', 'skills') }
+    // Codex discovers repository skills in <project>/.agents/skills.
+    skillsProjection: { scope: 'project', dir: path.join('.agents', 'skills') }
   },
   antigravity: {
     label: 'Antigravity',
@@ -954,8 +960,7 @@ export default async function connect(args) {
     }
   }
 
-  // Project repo skills as native slash commands via the Agent Skills standard.
-  // Each <agentDir>/skills/<name>/SKILL.md becomes /<name> in the target IDE.
+  // Project repo skills into the target IDE's Agent Skills directory.
   if (preset.skillsProjection) {
     const skills = discoverRepoSkills(agentDir);
     if (skills.length > 0) {
@@ -964,14 +969,14 @@ export default async function connect(args) {
         : path.join(cwd, preset.skillsProjection.dir);
       const skillResults = projectSkillsAsCommands(destDir, skills, opts);
       result.skill_commands = skillResults;
-      const fresh = skillResults.filter(r => r.action === 'linked');
+      const fresh = skillResults.filter(r => r.action === 'linked' || r.action === 'copied');
       if (fresh.length > 0) {
         const destLabel = preset.skillsProjection.scope === 'home'
           ? destDir
           : (path.relative(cwd, destDir) || destDir);
         result.notes.push(
-          `  Repo skills projected as slash commands → ${destLabel}/:\n` +
-          fresh.map(r => `    /${r.name}`).join('\n')
+          `  Repo skills projected → ${destLabel}/:\n` +
+          fresh.map(r => `    ${r.name}`).join('\n')
         );
       }
     }

package/src/cli/init.mjs

@@ -77,28 +77,52 @@ function copyDirMerge(src, dest, dryRun) {
  * Ship openwiki with the brain (global or project). Prefer packaged templates;
  * fall back to a minimal set of pages so every brain has docs.
  */
-function ensureOpenWiki(brainDir, isProject, dryRun) {
-  const wikiDir = path.join(brainDir, 'openwiki');
-  const templateRoot = path.join(ROOT, 'templates', 'openwiki');
-  if (ensureDir(wikiDir, dryRun)) {
-    logOk(`Created openwiki at ${path.relative(process.cwd(), wikiDir) || wikiDir}`);
+async function ensureOpenWiki(brainDir, isProject, dryRun) {
+  const wikiDirs = [path.join(brainDir, 'openwiki')];
+  if (isProject) {
+    wikiDirs.push(path.join(process.cwd(), 'openwiki'));
   }
-  if (fs.existsSync(templateRoot)) {
-    copyDirMerge(templateRoot, wikiDir, dryRun);
-  } else {
-    // Minimal fallback pages when templates/ not packaged yet
-    const pages = {
-      'README.md': `# OpenWiki\n\nPortable knowledge docs for this Total Recall brain (${isProject ? 'project' : 'global'}).\n\n- Not the SSSS memory vault — use vault nodes for rules/facts.\n- Use these pages for architecture, stack, and how-to knowledge.\n`,
-      'memory.md': `# Memory\n\nHow this brain stores invariants, preferences, and facts.\n\nUse \`npx total-recall remember\` / \`recall\` / \`compile\`.\n`,
-      'ide.md': `# IDE personalization\n\nConnect surfaces with \`npx total-recall connect <ide>\`.\nInjected blocks live inside BEGIN/END INJECTED MEMORY markers only.\n`,
-      'skills.md': `# Skills\n\nUser skills live in \`.agent/skills/<name>/\` (siblings of total-recall).\nTotal Recall tracks and deploys skills; it does not nest product skills inside itself.\n`,
-      'secrets.md': `# Secrets\n\nAPI keys and credentials belong in the encrypted secrets store — never in openwiki or instruction shims.\n`,
-    };
-    for (const [name, body] of Object.entries(pages)) {
-      const dest = path.join(wikiDir, name);
-      if (fs.existsSync(dest)) continue;
-      if (!dryRun) fs.writeFileSync(dest, body);
-      logOk(`Seeded openwiki/${name}`);
+  const templateRoot = fs.existsSync(path.join(ROOT, 'scaffold', 'openwiki'))
+    ? path.join(ROOT, 'scaffold', 'openwiki')
+    : path.join(ROOT, 'templates', 'openwiki');
+
+  for (const wikiDir of wikiDirs) {
+    if (ensureDir(wikiDir, dryRun)) {
+      logOk(`Created openwiki at ${path.relative(process.cwd(), wikiDir) || wikiDir}`);
+    }
+    if (fs.existsSync(templateRoot)) {
+      copyDirMerge(templateRoot, wikiDir, dryRun);
+    } else {
+      // Minimal fallback pages when templates/ not packaged yet
+      const pages = {
+        'README.md': `# OpenWiki\n\nPortable knowledge docs for this Total Recall brain (${isProject ? 'project' : 'global'}).\n\n- Not the SSSS memory vault — use vault nodes for rules/facts.\n- Use these pages for architecture, stack, and how-to knowledge.\n`,
+        'architecture.md': `# Architecture\n\nComponent overview, domain boundaries, and runtime execution flow.\n`,
+        'stack.md': `# Stack\n\nRuntime dependencies, frameworks, and system tools.\n`,
+        'memory.md': `# Memory\n\nHow this brain stores invariants, preferences, and facts.\n\nUse \`npx total-recall remember\` / \`recall\` / \`compile\`.\n`,
+        'ide.md': `# IDE personalization\n\nConnect surfaces with \`npx total-recall connect <ide>\`.\nInjected blocks live inside BEGIN/END INJECTED MEMORY markers only.\n`,
+        'skills.md': `# Skills\n\nUser skills live in \`.agent/skills/<name>/\` (siblings of total-recall).\nTotal Recall tracks and deploys skills; it does not nest product skills inside itself.\n`,
+        'secrets.md': `# Secrets\n\nAPI keys and credentials belong in the encrypted secrets store — never in openwiki or instruction shims.\n`,
+      };
+      for (const [name, body] of Object.entries(pages)) {
+        const dest = path.join(wikiDir, name);
+        if (fs.existsSync(dest)) continue;
+        if (!dryRun) fs.writeFileSync(dest, body);
+        logOk(`Seeded openwiki/${name}`);
+      }
+    }
+  }
+
+  // Auto-ingest into memory graph when project is initialized
+  if (isProject && !dryRun) {
+    try {
+      const { runOpenWikiIngest } = await import('./ingest-openwiki.mjs');
+      const targetWiki = path.join(process.cwd(), 'openwiki');
+      if (fs.existsSync(targetWiki)) {
+        await runOpenWikiIngest([targetWiki], { silent: true });
+        logOk('Ingested openwiki into semantic knowledge graph');
+      }
+    } catch {
+      // Best-effort ingestion
     }
   }
 }
@@ -574,15 +598,15 @@ export default async function init(args) {
   // This is the non-interactive openwiki path. External `openwiki --init` is optional
   // and only offered interactively (that CLI has no --yes flag).
   logStep('3.6/4', 'Ensuring openwiki is present');
-  ensureOpenWiki(brainDir, isProject, opts.dryRun);
+  await ensureOpenWiki(brainDir, isProject, opts.dryRun);
 
-  // ── Step 3.7: Project skills as slash commands into the IDEs in use ──
+  // ── Step 3.7: Project skills into the IDEs in use ──
   // Scope matches the brain: `init --project` projects PROJECT skills into the
   // repo's IDE skill dirs for IDEs actually used here (.claude/, .agents/, or
   // the current process); `init` projects GLOBAL skills into installed IDEs'
-  // global skill dirs. Codex (global-only) is opt-in for project skills.
+  // global skill dirs. Codex discovers project skills in .agents/skills.
   const skillScope = isProject ? 'project' : 'global';
-  logStep('3.7/4', `Projecting ${skillScope} skills as slash commands (IDEs in use)`);
+  logStep('3.7/4', `Projecting ${skillScope} skills (IDEs in use)`);
   if (opts.dryRun) {
     const targets = detectActiveSkillTargets({ scope: skillScope, cwd });
     for (const t of targets.filter(t => t.supported)) {
@@ -600,10 +624,10 @@ export default async function init(args) {
         log(`  No in-use IDE detected for ${skillScope} skills — run \`npx total-recall connect <ide>\` to wire them.`);
       } else {
         for (const t of wired) {
-          const n = t.results.filter(r => ['linked', 'exists', 'source'].includes(r.action)).length;
+          const n = t.results.filter(r => ['linked', 'copied', 'exists', 'source'].includes(r.action)).length;
           logOk(`${t.label}: ${n} skill(s) → ${path.relative(cwd, t.destDir) || t.destDir}/`);
         }
-        log(`  Slash commands: ${skills.map(s => '/' + s.name).join(', ')}`);
+        log(`  Discoverable skills: ${skills.map(s => s.name).join(', ')}`);
         if (available.length > 0) {
           log(`  Also available (opt-in): ${available.map(t => t.clients.join('/')).join(', ')} — \`npx total-recall connect <ide>\``);
         }

package/src/cli/skill-projection.mjs

@@ -2,8 +2,8 @@
  * Scope-aware skill → slash-command projection.
  *
  * A "repo skill" is any <skills-root>/<name>/SKILL.md directory (the Agent
- * Skills standard). Each IDE turns such a directory into a /<name> slash
- * command, but every IDE looks in a *different* place, and the right place
+ * Skills standard). Each IDE discovers skills in a different place, and that
+ * place
  * depends on the *scope* of the skill:
  *
  *   PROJECT skills (authored in <repo>/.agent/skills or <repo>/.agents/skills)
@@ -16,9 +16,9 @@
  *       machine. They are available in every repo.
  *
  * This mirrors the brain model: `init --project` ⇒ project skills; `init`
- * (global) ⇒ global skills. Codex has no project-local skills dir (it only
- * reads ~/.codex/skills globally), so it participates in GLOBAL projection only;
- * pushing project skills to Codex is opt-in via `connect codex`.
+ * (global) ⇒ global skills. Codex discovers project skills in
+ * <repo>/.agents/skills and global skills in ~/.codex/skills. In Codex,
+ * /skills opens the picker and $skill-name explicitly invokes a skill.
  */
 import fs from 'node:fs';
 import os from 'node:os';
@@ -54,9 +54,7 @@ export const IDE_SKILLS = [
     id: 'codex',
     label: 'Codex',
     clients: ['codex'],
-    // Codex only discovers skills globally under ~/.codex/skills. There is no
-    // project-local dir, so project skills are opt-in (namespaced) via connect.
-    project: null,
+    project: { dir: ['.agents', 'skills'], markers: ['.agents', 'AGENTS.md'], env: ['CODEX_HOME'] },
     global:  { dir: ['.codex', 'skills'], markers: ['.codex'] }
   },
   {
@@ -90,9 +88,25 @@ function pathExists(filePath) {
 // to heal back onto the canonical source, even without --force.
 const AUTO_GENERATED_MARKER = '**Auto-generated** by `npx total-recall';
 
+// Written into a skill directory that projectSkillsAsCommands had to COPY
+// (no symlink support — Windows without Developer Mode, some network/FAT
+// volumes). A real directory carrying this file is Total Recall's own
+// projection, never a user's skill, so it is refreshed on every run.
+export const PROJECTION_MARKER_FILE = '.total-recall-projection.json';
+
+function isProjectedCopy(entryPath) {
+  try {
+    return fs.statSync(entryPath).isDirectory()
+      && fs.existsSync(path.join(entryPath, PROJECTION_MARKER_FILE));
+  } catch {
+    return false;
+  }
+}
+
 function isStaleGeneratedDir(entryPath) {
   try {
     if (!fs.statSync(entryPath).isDirectory()) return false;
+    if (isProjectedCopy(entryPath)) return true;
     const content = fs.readFileSync(path.join(entryPath, 'SKILL.md'), 'utf8');
     return content.includes(AUTO_GENERATED_MARKER);
   } catch {
@@ -101,21 +115,55 @@ function isStaleGeneratedDir(entryPath) {
 }
 
 /**
- * Skill source roots, in priority order. The canonical Total Recall location
- * (.agent/skills, singular) wins, but we also scan the Antigravity-native
- * .agents/skills (plural) so a skill authored in either place is discovered.
+ * Put one skill at linkPath so the IDE can discover it:
+ *   1. a symlink RELATIVE to the destination dir — the projection then survives
+ *      `git clone`, a moved checkout, or a different home directory (an absolute
+ *      link only works on the machine that wrote it);
+ *   2. on Windows a directory junction (no Developer Mode / admin needed; Node
+ *      resolves the target to an absolute path itself);
+ *   3. when the filesystem refuses links at all, a real COPY of the skill
+ *      directory tagged with PROJECTION_MARKER_FILE so later runs refresh it.
+ */
+function placeSkill(skillDir, linkPath) {
+  const source = path.resolve(skillDir);
+  const relativeTarget = path.relative(path.dirname(path.resolve(linkPath)), source) || '.';
+  try {
+    if (process.platform === 'win32') {
+      fs.symlinkSync(source, linkPath, 'junction');
+    } else {
+      fs.symlinkSync(relativeTarget, linkPath);
+    }
+    return 'linked';
+  } catch (err) {
+    const noLinks = ['EPERM', 'EACCES', 'ENOTSUP', 'EOPNOTSUPP', 'EINVAL', 'ENOSYS'];
+    if (!noLinks.includes(err?.code)) throw err;
+  }
+  fs.cpSync(source, linkPath, { recursive: true, dereference: true });
+  fs.writeFileSync(
+    path.join(linkPath, PROJECTION_MARKER_FILE),
+    JSON.stringify({ source: relativeTarget, projected_at: new Date().toISOString() }, null, 2) + '\n'
+  );
+  return 'copied';
+}
+
+/**
+ * Skill source roots, in priority order. The Total Recall location
+ * (.agent/skills, singular) wins, followed by repo-authored skills/ and
+ * already-projected .agents/skills. This avoids treating projected links as
+ * the source when the original is available.
  */
 export function skillSourceRoots(agentDir) {
   const roots = [path.join(agentDir, 'skills')];
   const parent = path.dirname(agentDir);
   if (path.basename(agentDir) === '.agent') {
+    roots.push(path.join(parent, 'skills'));
     roots.push(path.join(parent, '.agents', 'skills'));
   }
   return roots;
 }
 
 /**
- * Discover repo skills to expose as slash commands.
+ * Discover repo skills to expose to IDEs.
  * Every <root>/<name>/ directory containing a SKILL.md is a skill. When the
  * same name appears in more than one source root, the canonical root wins.
  */
@@ -141,7 +189,8 @@ export function discoverRepoSkills(agentDir) {
 }
 
 /**
- * Symlink each discovered skill dir into one IDE's Agent-Skills directory.
+ * Project each discovered skill dir into one IDE's Agent-Skills directory
+ * (relative symlink, Windows junction, or a marked copy — see placeSkill).
  * Idempotent, self-healing, and strictly additive: a symlink that is broken or
  * stale is refreshed even without --force; a *real* (non-symlink) entry is
  * never clobbered unless --force (so a user's own skill always wins a name
@@ -165,7 +214,10 @@ export function projectSkillsAsCommands(destDir, skills, opts = {}) {
     if (pathExists(linkPath)) {
       const stat = fs.lstatSync(linkPath);
       if (stat.isSymbolicLink()) {
-        const current = path.resolve(path.dirname(linkPath), fs.readlinkSync(linkPath));
+        // Relative links resolve against the link's own directory; Windows
+        // junctions read back with a \\?\ long-path prefix that must be dropped.
+        const raw = fs.readlinkSync(linkPath).replace(/^\\\\\?\\/, '');
+        const current = path.resolve(path.dirname(linkPath), raw);
         if (current === wantTarget && fs.existsSync(linkPath) && !opts.force) {
           written.push({ name: skill.name, action: 'exists' });
           continue;
@@ -178,8 +230,7 @@ export function projectSkillsAsCommands(destDir, skills, opts = {}) {
         fs.rmSync(linkPath, { recursive: true, force: true });
       }
     }
-    fs.symlinkSync(skill.skillDir, linkPath);
-    written.push({ name: skill.name, action: 'linked' });
+    written.push({ name: skill.name, action: placeSkill(skill.skillDir, linkPath) });
   }
   return written;
 }

package/src/cli/status.mjs

@@ -20,13 +20,8 @@ import fs from 'node:fs';
 import crypto from 'node:crypto';
 import { loadQueue } from '../core/research-queue.mjs';
 
-import { agentDir, brainDir, totalRecallToken } from '../core/config.mjs';
-
-const AGENT_DIR = agentDir;
-const BRAIN_CONFIG = path.join(brainDir, 'config', 'brain.json');
-const SYNC_STATE = path.join(brainDir, 'config', 'sync-state.json');
-const CLIENTS_REGISTRY = path.join(brainDir, 'config', 'clients.json');
-const INSTRUCTIONS_FILE = path.join(AGENT_DIR, 'INSTRUCTIONS.md');
+import { totalRecallToken } from '../core/config.mjs';
+import { resolveBrainDir } from './agent-dir.mjs';
 
 function parseArgs(args) {
   const opts = { json: false, brain: null, token: null, help: false };
@@ -55,21 +50,21 @@ function printHelp() {
 `);
 }
 
-function loadBrainConfig() {
-  if (!fs.existsSync(BRAIN_CONFIG)) return null;
-  try { return JSON.parse(fs.readFileSync(BRAIN_CONFIG, 'utf8')); }
+function loadBrainConfig(brainConfigPath) {
+  if (!fs.existsSync(brainConfigPath)) return null;
+  try { return JSON.parse(fs.readFileSync(brainConfigPath, 'utf8')); }
   catch { return null; }
 }
 
-function loadSyncState() {
-  if (!fs.existsSync(SYNC_STATE)) return {};
-  try { return JSON.parse(fs.readFileSync(SYNC_STATE, 'utf8')); }
+function loadSyncState(syncStatePath) {
+  if (!fs.existsSync(syncStatePath)) return {};
+  try { return JSON.parse(fs.readFileSync(syncStatePath, 'utf8')); }
   catch { return {}; }
 }
 
-function loadClientsRegistry() {
-  if (!fs.existsSync(CLIENTS_REGISTRY)) return {};
-  try { return JSON.parse(fs.readFileSync(CLIENTS_REGISTRY, 'utf8'))?.clients || {}; }
+function loadClientsRegistry(clientsRegistryPath) {
+  if (!fs.existsSync(clientsRegistryPath)) return {};
+  try { return JSON.parse(fs.readFileSync(clientsRegistryPath, 'utf8'))?.clients || {}; }
   catch { return {}; }
 }
 
@@ -90,21 +85,31 @@ function sha256(buf) {
   return crypto.createHash('sha256').update(buf).digest('hex');
 }
 
-async function probeBrain(brainUrl, token) {
+async function probeBrain(brainUrl, token, brainId) {
   const headers = {};
   if (token) headers.Authorization = `Bearer ${token}`;
   const out = { reachable: false, instructions_sha256: null, instructions_bytes: null, error: null };
   try {
-    const res = await fetch(`${brainUrl.replace(/\/$/, '')}/api/instructions`, { headers });
+    const url = new URL(`${brainUrl.replace(/\/$/, '')}/api/instructions`);
+    if (brainId) url.searchParams.set('brain', brainId);
+    const res = await fetch(url, { headers });
     if (!res.ok) {
       out.error = `HTTP ${res.status}`;
       return out;
     }
-    const body = await res.json();
+    const contentType = res.headers?.get?.('content-type') || '';
+    const body = contentType.includes('application/json') ? await res.json() : null;
     out.reachable = true;
-    out.instructions_sha256 = body.sha256 || null;
-    out.instructions_bytes = body.bytes || null;
-    out.modified = body.modified || null;
+    if (body) {
+      out.instructions_sha256 = body.sha256 || (body.content ? sha256(body.content) : null);
+      out.instructions_bytes = body.bytes || (body.content ? Buffer.byteLength(body.content) : null);
+      out.modified = body.modified || null;
+    } else {
+      const content = await res.text();
+      out.instructions_sha256 = sha256(content);
+      out.instructions_bytes = Buffer.byteLength(content);
+      out.modified = res.headers?.get?.('last-modified') || null;
+    }
   } catch (err) {
     out.error = err.message;
   }
@@ -115,9 +120,12 @@ export default async function statusCmd(args) {
   const opts = parseArgs(args);
   if (opts.help) { printHelp(); return; }
 
-  const brainConfig = loadBrainConfig();
-  const syncState = loadSyncState();
-  const clientsRegistry = loadClientsRegistry();
+  const brainDir = resolveBrainDir();
+  const agentDir = path.dirname(path.dirname(brainDir));
+  const instructionsFile = path.join(path.dirname(agentDir), 'INSTRUCTIONS.md');
+  const brainConfig = loadBrainConfig(path.join(brainDir, 'config', 'brain.json'));
+  const syncState = loadSyncState(path.join(brainDir, 'config', 'sync-state.json'));
+  const clientsRegistry = loadClientsRegistry(path.join(brainDir, 'config', 'clients.json'));
   const brainUrl = opts.brain || brainConfig?.url || null;
   const token = opts.token || brainConfig?.token || totalRecallToken || null;
 
@@ -175,11 +183,11 @@ export default async function statusCmd(args) {
   } catch {}
 
   let localInstructions = null;
-  if (fs.existsSync(INSTRUCTIONS_FILE)) {
-    const buf = fs.readFileSync(INSTRUCTIONS_FILE);
-    const stat = fs.statSync(INSTRUCTIONS_FILE);
+  if (fs.existsSync(instructionsFile)) {
+    const buf = fs.readFileSync(instructionsFile);
+    const stat = fs.statSync(instructionsFile);
     localInstructions = {
-      path: INSTRUCTIONS_FILE,
+      path: instructionsFile,
       sha256: sha256(buf),
       bytes: stat.size,
       modified: stat.mtime.toISOString()
@@ -188,14 +196,17 @@ export default async function statusCmd(args) {
 
   let remote = null;
   if (brainUrl) {
-    remote = await probeBrain(brainUrl, token);
+    const brainId = brainConfig?.layer === 'project' && brainConfig?.name
+      ? `project:${brainConfig.name}`
+      : null;
+    remote = await probeBrain(brainUrl, token, brainId);
   }
 
   const inSync = !!(localInstructions && remote?.instructions_sha256 &&
     remote.instructions_sha256 === localInstructions.sha256);
 
   const instructionsMtime = localInstructions
-    ? fs.statSync(INSTRUCTIONS_FILE).mtimeMs
+    ? fs.statSync(instructionsFile).mtimeMs
     : null;
   const clientProjections = projectionsStatus(clientsRegistry, instructionsMtime);