total-recall-brain 3.8.1 → 3.10.0

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "total-recall-brain",
-  "version": "3.8.1",
+  "version": "3.10.0",
   "description": "Sovereign AI system — database-free, SSSS-powered personal intelligence engine deployable to any POSIX host.",
   "type": "module",
   "bin": {
-    "total-recall": "./bin/total-recall.mjs",
-    "antigravity": "./bin/antigravity.mjs"
+    "total-recall": "bin/total-recall.mjs",
+    "antigravity": "bin/antigravity.mjs"
   },
   "files": [
     "bin/",
@@ -56,6 +56,7 @@
   },
   "homepage": "https://github.com/gregiteen/total-recall#readme",
   "dependencies": {
+    "@ssss/cli": "github:gregiteen/ssss#v0.4.0",
     "bcrypt": "^6.0.0",
     "cookie-parser": "^1.4.7",
     "cors": "^2.8.6",
@@ -64,9 +65,9 @@
     "gray-matter": "^4.0.3",
     "jsonwebtoken": "^9.0.3",
     "natural": "^8.1.1",
+    "ws": "^8.18.0",
     "yaml": "^2.9.0",
-    "zod": "^4.4.3",
-    "ws": "^8.18.0"
+    "zod": "^4.4.3"
   },
   "devDependencies": {
     "skills": "^1.5.7",

package/scaffold/.agent/skills/total-recall/SKILL.md

@@ -1,5 +1,6 @@
 ---
 name: total-recall
+provenance: total-recall
 description: "Use this skill as the master guide to understand the entire Total Recall Sovereign AI OS setup, VFS topologies, SSSS protocol, CLI parameter reference, troubleshooting, and automated upstream repository sync. MANDATORY: Read this file before attempting major setup modifications or diagnoses."
 ---
 

package/scaffold/.agent/skills/total-recall/skills/{cli-agents → tr-cli-agents}/SKILL.md

@@ -1,5 +1,6 @@
 ---
-name: cli-agents
+name: tr-cli-agents
+provenance: total-recall
 description: "Orchestrate headlessly spawned CLI agents from the central registry."
 ---
 
@@ -12,7 +13,7 @@ This system skill governs the discovery, configuration, and execution of headles
 ## 🎯 SYSTEM OVERVIEW
 
 The CLI Agent Dispatch Engine parses agent profiles from the central registry file:
-`.agent/skills/total-recall/skills/cli-agents/agents.yml`
+`.agent/skills/total-recall/skills/tr-cli-agents/agents.yml`
 
 ```mermaid
 flowchart TD

package/scaffold/.agent/skills/total-recall/skills/{research → tr-research}/SKILL.md

@@ -1,6 +1,7 @@
 ---
 type: skill
-name: research
+name: tr-research
+provenance: total-recall
 description: "Use this skill when queueing, searching, and managing long-horizon background research projects via the Total Recall REST API."
 ---
 

package/scaffold/.agent/skills/total-recall/skills/{skill → tr-skill}/SKILL.md

@@ -1,5 +1,6 @@
 ---
-name: skill
+name: tr-skill
+provenance: total-recall
 description: "Use this skill when creating, auditing, or modifying any skill in the .agent/skills/ ecosystem. MANDATORY: You MUST read the full SKILL.md file before executing."
 ---
 
@@ -186,7 +187,7 @@ Contains standalone prompt files for subtasks that can be delegated to parallel
 
 ### Quick method (script):
 ```bash
-bash .agent/skills/skill/scripts/create-skill.sh my-new-skill
+bash .agent/skills/tr-skill/scripts/create-skill.sh my-new-skill
 ```
 
 ### Manual method:

package/scaffold/.agent/skills/total-recall/skills/{skill → tr-skill}/evals/evals.json

@@ -2,19 +2,19 @@
   {
     "id": "skill-eval-1",
     "description": "SKILL.md exists",
-    "command": "test -f .agent/skills/skill/SKILL.md",
+    "command": "test -f .agent/skills/tr-skill/SKILL.md",
     "expected_exit_code": 0
   },
   {
     "id": "skill-eval-2",
     "description": "Evals validation",
-    "command": "test -f .agent/skills/skill/scripts/run-evals.mjs",
+    "command": "test -f .agent/skills/tr-skill/scripts/run-evals.mjs",
     "expected_exit_code": 0
   },
   {
     "id": "skill-eval-3",
     "description": "Optimization enforcement",
-    "command": "test -f .agent/skills/skill/scripts/enforce-skill-optimization.mjs",
+    "command": "test -f .agent/skills/tr-skill/scripts/enforce-skill-optimization.mjs",
     "expected_exit_code": 0
   }
 ]

package/scaffold/.agent/skills/total-recall/skills/{skill → tr-skill}/hooks/on-skill-add.sh

@@ -10,5 +10,5 @@ SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
 ROOT="$(cd "$SCRIPT_DIR/../../../.." && pwd)"
 
 echo "🔄 OnSkillAdd hook triggered — regenerating skill index..."
-node "$ROOT/.agent/skills/skill/scripts/update-skill-index.mjs"
+node "$ROOT/.agent/skills/tr-skill/scripts/update-skill-index.mjs"
 echo "✅ Routing table and INSTRUCTIONS.md updated."

package/scaffold/.agent/skills/total-recall/skills/{skill → tr-skill}/hooks/on-skill-delete.sh

@@ -10,5 +10,5 @@ SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
 ROOT="$(cd "$SCRIPT_DIR/../../../.." && pwd)"
 
 echo "🧹 OnSkillDelete hook triggered — cleaning skill index..."
-node "$ROOT/.agent/skills/skill/scripts/update-skill-index.mjs"
+node "$ROOT/.agent/skills/tr-skill/scripts/update-skill-index.mjs"
 echo "✅ Routing table and INSTRUCTIONS.md cleaned."

package/scaffold/.agent/skills/total-recall/skills/{skill → tr-skill}/scripts/create-skill.sh

@@ -1,8 +1,8 @@
 #!/bin/bash
 # create-skill.sh — Scaffold a new Dev Skill from the template
 #
-# Usage: bash .agent/skills/skill/scripts/create-skill.sh <skill-name>
-# Example: bash .agent/skills/skill/scripts/create-skill.sh my-new-skill
+# Usage: bash .agent/skills/tr-skill/scripts/create-skill.sh <skill-name>
+# Example: bash .agent/skills/tr-skill/scripts/create-skill.sh my-new-skill
 
 set -euo pipefail
 
@@ -60,6 +60,6 @@ echo ""
 echo "📝 Next steps:"
 echo "  1. Edit $TARGET/SKILL.md with real instructions"
 echo "  2. Write a trigger-optimized description in the frontmatter"
-echo "  3. Run: node .agent/skills/skill/scripts/update-skill-index.mjs"
+echo "  3. Run: node .agent/skills/tr-skill/scripts/update-skill-index.mjs"
 echo ""
 echo "🏁 Done."

package/scaffold/.agent/skills/total-recall/skills/{skill → tr-skill}/scripts/find-skills.mjs

@@ -77,6 +77,7 @@ export function parseFindOutput(rawOutput) {
 
     const name = skillMatch[1];
     const installs = parseInstalls(skillMatch[2], skillMatch[3] || '');
+    const installsStr = `${skillMatch[2]}${skillMatch[3] || ''}`;
 
     // Next non-empty line should be the URL (prefixed with └ or similar box-drawing chars)
     let url = '';
@@ -92,12 +93,19 @@ export function parseFindOutput(rawOutput) {
       break; // only check the very next non-empty line
     }
 
-    results.push({ name, installs, url });
+    results.push({ name, installs, installsStr, url });
   }
 
   return results;
 }
 
+function formatInstalls(installs) {
+  if (installs >= 1_000_000_000) return `${(installs / 1_000_000_000).toFixed(1).replace(/\.0$/, '')}B`;
+  if (installs >= 1_000_000) return `${(installs / 1_000_000).toFixed(1).replace(/\.0$/, '')}M`;
+  if (installs >= 1_000) return `${(installs / 1_000).toFixed(1).replace(/\.0$/, '')}K`;
+  return String(installs);
+}
+
 // ─── Live Registry Search ───────────────────────────────────────────────────
 
 /**
@@ -122,3 +130,19 @@ export function searchRegistry(query, { timeoutMs = 15_000 } = {}) {
     return [];
   }
 }
+
+/**
+ * Search skills.sh and sort by absolute install count, highest first.
+ *
+ * @param {string} query
+ * @param {object} [options]
+ * @returns {Array<{ name: string, installs: number, installsStr: string, url: string }>}
+ */
+export function searchAndSort(query, options = {}) {
+  return searchRegistry(query, options)
+    .map(result => ({
+      ...result,
+      installsStr: result.installsStr || formatInstalls(result.installs || 0),
+    }))
+    .sort((a, b) => (b.installs || 0) - (a.installs || 0));
+}

package/scaffold/.agent/skills/total-recall/skills/tr-skill/scripts/install-skill.mjs

@@ -0,0 +1,117 @@
+/**
+ * install-skill.mjs — safe wrapper around the Skills CLI installer.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { scanDirectory, formatReport } from './scan-skill.mjs';
+
+const BLOCKED_SOURCE_CHARS = /[\0\r\n;&|<>`$]/;
+
+export function validateSkillSource(source) {
+  if (typeof source !== 'string') return false;
+  const trimmed = source.trim();
+  if (!trimmed || trimmed.length > 500) return false;
+  return !BLOCKED_SOURCE_CHARS.test(trimmed);
+}
+
+export function inferSkillName(source) {
+  const trimmed = String(source || '').trim().replace(/\/+$/, '');
+  if (!trimmed) return null;
+  if (!trimmed.startsWith('git@') && trimmed.includes('@')) {
+    return trimmed.split('@').pop() || null;
+  }
+  const last = trimmed.split('/').filter(Boolean).pop();
+  return last ? last.replace(/\.git$/i, '') : null;
+}
+
+function uniqueExistingDirs(paths) {
+  const seen = new Set();
+  const dirs = [];
+  for (const candidate of paths) {
+    if (!candidate) continue;
+    const resolved = path.resolve(candidate);
+    if (seen.has(resolved) || !fs.existsSync(resolved)) continue;
+    seen.add(resolved);
+    dirs.push(resolved);
+  }
+  return dirs;
+}
+
+export function installedSkillCandidates(source, { cwd = process.cwd(), agentDir = path.join(cwd, '.agent') } = {}) {
+  const skillName = inferSkillName(source);
+  if (!skillName) return [];
+  return [
+    path.join(agentDir, 'skills', skillName),
+    path.join(cwd, '.agent', 'skills', skillName),
+    path.join(cwd, '.agents', 'skills', skillName),
+    path.join(cwd, '.claude', 'skills', skillName),
+  ];
+}
+
+/**
+ * Install a skill with the Skills CLI, then scan installed script files.
+ *
+ * @param {string} source skills add source, e.g. owner/repo@skill or URL
+ * @param {object} [options]
+ * @param {string} [options.cwd]
+ * @param {string} [options.agentDir]
+ * @param {boolean} [options.dryRun=false]
+ * @returns {{ success: boolean, source: string, command?: string[], findings?: Array, error?: string }}
+ */
+export function installSkill(source, options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const agentDir = options.agentDir || path.join(cwd, '.agent');
+  const normalized = String(source || '').trim();
+
+  if (!validateSkillSource(normalized)) {
+    const error = 'Invalid skill source. Use a repository, URL, git source, local path, or owner/repo@skill without shell metacharacters.';
+    console.error(`❌ ${error}`);
+    return { success: false, source: normalized, error };
+  }
+
+  const command = ['npx', '-y', 'skills', 'add', normalized, '-y'];
+  if (options.dryRun) {
+    return { success: true, source: normalized, command };
+  }
+
+  console.log(`📦 Installing skill: ${normalized}`);
+  const child = spawnSync(command[0], command.slice(1), {
+    cwd,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+
+  if (child.stdout) process.stdout.write(child.stdout);
+  if (child.stderr) process.stderr.write(child.stderr);
+
+  if (child.error || child.status !== 0) {
+    const error = child.error?.message || `skills CLI exited with status ${child.status}`;
+    console.error(`❌ Skill installation failed: ${error}`);
+    return { success: false, source: normalized, command, error };
+  }
+
+  const installedDirs = uniqueExistingDirs(installedSkillCandidates(normalized, { cwd, agentDir }));
+  const findings = installedDirs.flatMap(dir => scanDirectory(dir));
+  const report = formatReport(findings);
+  console.log(report.trimEnd());
+
+  if (findings.some(f => f.severity === 'CRITICAL')) {
+    const error = 'Installed skill contains critical scanner findings.';
+    console.error(`❌ ${error}`);
+    return { success: false, source: normalized, command, findings, error };
+  }
+
+  const compile = spawnSync('npx', ['total-recall', 'compile'], {
+    cwd,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+    env: { ...process.env, AGENT_DIR: agentDir },
+  });
+  if (compile.status !== 0) {
+    console.warn('⚠️  Skill installed, but surface recompilation returned a warning.');
+  }
+
+  return { success: true, source: normalized, command, findings };
+}

package/scaffold/.agent/skills/total-recall/skills/{skill → tr-skill}/scripts/scan-skill.mjs

@@ -205,3 +205,23 @@ export function formatReport(findings) {
 
   return report;
 }
+
+/**
+ * CLI-friendly scanner entrypoint.
+ *
+ * @param {string} targetDir
+ * @returns {{ success: boolean, findings: Array, report: string }}
+ */
+export function runScan(targetDir) {
+  if (!targetDir || !fs.existsSync(targetDir)) {
+    const report = `Skill directory not found: ${targetDir}\n`;
+    console.error(report.trim());
+    return { success: false, findings: [], report };
+  }
+
+  const findings = scanDirectory(targetDir);
+  const report = formatReport(findings);
+  const blocked = findings.some(f => f.severity === 'CRITICAL');
+  console.log(report.trimEnd());
+  return { success: !blocked, findings, report };
+}

package/scaffold/.agent/skills/total-recall/skills/{ssss → tr-ssss}/SKILL.md

@@ -1,5 +1,6 @@
 ---
-name: ssss
+name: tr-ssss
+provenance: total-recall
 description: "Use this skill to inspect, validate, write, and manage SSSS primitives, memory nodes, operation envelopes, scope overlays, projections, and VFS specifications in the Total Recall reference kernel. MANDATORY: Read this file before editing SSSS files or code."
 ---
 
@@ -12,9 +13,16 @@ schema/reference files.
 
 ## Ground Truth
 
-The vendor-neutral contract is `references/ssss-spec.md`. If this skill conflicts
-with the spec, correct this skill unless the implementation has intentionally
-advanced beyond the vendored spec and the difference is documented here.
+The vendor-neutral contract is now a published package, **`@ssss/cli`** (pinned to
+**`v0.4.0`**; source <https://github.com/gregiteen/ssss>), declared in
+`package.json`. `references/ssss-spec.md` is the local mirror. The canon owns the
+spec (§5.5 portability, §6 Operation Contract incl. `delete`, §16 the `.ucw` bundle
+format, §17 provisioning), the core registry (`@ssss/cli/registry/core.json`: 13
+document + 5 contract primitives), the reference engine, and the conformance
+fixtures. Total Recall's kernel was the engine the canon's reference implementation
+was harvested from; keep them aligned. If this skill conflicts with the canon,
+correct this skill unless the implementation has intentionally advanced beyond it
+and the difference is documented here.
 
 Current local implementation entry points:
 
@@ -27,6 +35,32 @@ Current local implementation entry points:
 - `src/core/vector-store.mjs` and `src/core/semantic-index.mjs` — canonical
   search/index path.
 
+## Using the `@ssss/cli` CLI
+
+`@ssss/cli` ships a `ssss` command (available via `npx`, since it's a dependency).
+It operates on a **vault directory** of Markdown files and `.ucw` bundles, using
+the canon's own reference engine — separate from this kernel's `processOperation`.
+Use it for bundle/tenant tooling and conformance; for in-kernel memory writes keep
+using `writeNodeValidated()` / `processOperation()`.
+
+```bash
+npx ssss help                  # list doc topics; e.g. `ssss help portability|bundle|provisioning`
+npx ssss <command> --help      # flags for any command
+
+# Vault → bundle → vault lifecycle (§16/§17)
+npx ssss export <vault-dir> --profile sale --out pack.ucw.json   # backup | template | sale
+npx ssss validate pack.ucw.json                                  # schema + portability + content hash
+npx ssss inspect  pack.ucw.json --files                          # manifest, inventory, params, steps
+npx ssss provision pack.ucw.json --param domain=acme.live --out plan.json   # pure: params + links → envelopes
+npx ssss import   pack.ucw.json --vault ./new-vault --param domain=acme.live  # idempotent replay
+
+npx ssss conformance --engine  # replay the canonical fixtures + round-trip the reference bundle
+```
+
+`export` is pure/deterministic and `template`/`sale` drop every `tenant_private`
+file (§5.5). Note: the canon's `.ucw` bundle (§16) is distinct from §7.4's OKF
+memory-vault `importBundle`/`exportBundle` in `repo-expert`.
+
 ## Current Contract
 
 All agent-generated mutations must flow through the SSSS operation pipeline:
@@ -45,17 +79,16 @@ processOperation(envelope, vaultRoot, options)
 Use `writeNodeValidated()` for Total Recall memory writes. Do not call raw
 `writeNode()` or write files directly when an agent is mutating an SSSS vault.
 
-Total Recall currently implements these envelope types in
+Total Recall implements all four canonical envelope types in
 `processOperation()`:
 
 - `operation` — full file create/replace.
 - `patch` — partial frontmatter/body merge.
 - `event` — append-only JSON event payload.
-
-The UltraChat host also models a `delete` envelope. Do not claim or use `delete`
-inside the Total Recall kernel until `src/core/schema.mjs` and
-`src/core/operation-validator.mjs` implement and test it. For memory removal, use
-the CLI/API forget/archive flow.
+- `delete` — remove a replace-type VFS file (SSSS spec §6.2). Refuses to delete
+  append-type documents (`conversation`, `run`), and emits an auditable deletion
+  event so history is never lost. Idempotent. For *memory* removal, still prefer
+  the CLI/API forget/archive flow over a raw `delete` envelope.
 
 Use `dry_run: true` for preflight validation when constructing writes from model
 output.
@@ -157,7 +190,7 @@ spec and tests are updated together.
 Validate an individual SSSS Markdown file with:
 
 ```bash
-node .agent/skills/ssss/scripts/validate-schema.mjs <path-to-node.md>
+node .agent/skills/tr-ssss/scripts/validate-schema.mjs <path-to-node.md>
 ```
 
 Run focused kernel tests after changing the operation contract, schema registry,
@@ -168,9 +201,17 @@ npx vitest run \
   src/core/schema.spec.mjs \
   src/core/operation-validator.spec.mjs \
   src/core/total-recall-memory-validator.spec.mjs \
-  src/core/vault-cache.spec.mjs
+  src/core/vault-cache.spec.mjs \
+  src/core/ssss-conformance.bridge.spec.mjs
 ```
 
+The **conformance bridge** (`src/core/ssss-conformance.bridge.spec.mjs`) runs the
+canonical fixtures from `@ssss/cli` through this kernel's `processOperation` and
+asserts every canonical core primitive is present in `SSSS_SCHEMAS`. It proves the
+kernel implements the *same* standard as the festech and UltraChat hosts. If you
+change the operation contract or the registry, keep this green; to adopt a newer
+standard, bump the `@ssss/cli` pin and re-run it.
+
 ## Do Not
 
 - Do not write agent mutations directly to vault files.
@@ -179,8 +220,7 @@ npx vitest run \
 - Do not collapse `global`/`project` or `system`/`account`/`workspace` scope
   boundaries.
 - Do not represent copied seeded skills as canonical system primitives.
-- Do not claim Total Recall supports `delete` envelopes until the implementation
-  supports them.
+- Do not delete append-type documents (`conversation`, `run`); they are immutable.
 - Do not add host-specific required fields to the vendor-neutral spec unless they
   are being standardized.
 
@@ -188,7 +228,10 @@ npx vitest run \
 
 | For | Read |
 | --- | --- |
-| SSSS standard | `references/ssss-spec.md` |
+| Upstream canon (package) | `@ssss/cli` (`v0.4.0`, github:gregiteen/ssss) |
+| Canonical core registry | `@ssss/cli/registry/core.json` |
+| Conformance bridge | `src/core/ssss-conformance.bridge.spec.mjs` |
+| SSSS standard (local mirror) | `references/ssss-spec.md` |
 | Implemented schemas | `src/core/schema.mjs` |
 | Operation pipeline | `src/core/operation-validator.mjs` |
 | Validated memory writes | `src/core/validated-write.mjs` |

package/src/cli/connect.mjs

@@ -4,6 +4,7 @@ import path from 'node:path';
 import { agentDir as configAgentDir, brainDir as configBrainDir, xdgConfigHome, trBrain, trPat } from '../core/config.mjs';
 import { fileURLToPath } from 'node:url';
 import { resolveAgentDir, getBothBrains, detectProjectBrain } from './agent-dir.mjs';
+import { discoverRepoSkills, projectSkillsAsCommands } from './skill-projection.mjs';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 // Resolve templates dir relative to this file (src/cli/ → ../../templates/)
@@ -52,24 +53,37 @@ const CLIENTS = {
     label: 'Claude Code',
     mode: 'symlink',
     target: 'CLAUDE.md',
-    writeSlashCommands: true
+    writeSlashCommands: true,
+    // Project-scoped: repo skills are repo-specific. Claude Code discovers
+    // these as native skills / slash commands under <project>/.claude/skills/.
+    skillsProjection: { scope: 'project', dir: path.join('.claude', 'skills') }
   },
   codex: {
     label: 'Codex',
     mode: 'symlink',
-    target: 'AGENTS.md'
+    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') }
   },
   antigravity: {
     label: 'Antigravity',
     mode: 'symlink',
     target: '.agents/rules/AGENTS.md',
-    writeSlashCommands: true
+    writeSlashCommands: true,
+    // Antigravity CLI (the Agent Skills standard) reads project workspace skills
+    // from <project>/.agents/skills/ and turns each into a /name slash command.
+    skillsProjection: { scope: 'project', dir: path.join('.agents', 'skills') }
   },
   gemini: {
     label: 'Gemini',
     mode: 'symlink',
     target: '.agents/rules/GEMINI.md',
-    writeSlashCommands: true
+    writeSlashCommands: true,
+    // Gemini CLI reads project workspace skills from <project>/.agents/skills/
+    // (the same Agent Skills location Antigravity uses) and turns each into a
+    // /name slash command.
+    skillsProjection: { scope: 'project', dir: path.join('.agents', 'skills') }
   },
   aider: {
     label: 'Aider',
@@ -293,7 +307,12 @@ function writeSymlinkProjection(cwd, preset, opts) {
       fs.rmSync(targetPath, { force: true, recursive: true });
     }
   }
-  fs.symlinkSync('INSTRUCTIONS.md', targetPath);
+  // Ensure the parent dir exists (nested targets like .agents/rules/AGENTS.md)
+  // and point the symlink at INSTRUCTIONS.md using a path relative to the
+  // link's own directory, so nested projections don't dangle.
+  fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+  const linkTarget = path.relative(path.dirname(targetPath), instructionsPath);
+  fs.symlinkSync(linkTarget, targetPath);
   return { targetPath, action: 'symlinked' };
 }
 
@@ -844,6 +863,29 @@ 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.
+  if (preset.skillsProjection) {
+    const skills = discoverRepoSkills(agentDir);
+    if (skills.length > 0) {
+      const destDir = preset.skillsProjection.scope === 'home'
+        ? path.join(os.homedir(), preset.skillsProjection.dir)
+        : path.join(cwd, preset.skillsProjection.dir);
+      const skillResults = projectSkillsAsCommands(destDir, skills, opts);
+      result.skill_commands = skillResults;
+      const fresh = skillResults.filter(r => r.action === 'linked');
+      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')
+        );
+      }
+    }
+  }
+
   // Record this client in the registry so `status` can report freshness
   registerClient(brainDir, opts.client, preset, result.projection?.targetPath || null);
 

package/src/cli/init.mjs

@@ -30,6 +30,7 @@ import path from 'node:path';
 import os from 'node:os';
 import { fileURLToPath } from 'node:url';
 import { exec, spawn, spawnSync } from 'node:child_process';
+import { projectSkillsForScope, detectActiveSkillTargets } from './skill-projection.mjs';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const ROOT = path.join(__dirname, '..', '..');
@@ -83,7 +84,8 @@ function parseArgs(args) {
     domain: null,
     tunnelName: null,
     tunnelCredentials: null,
-    yes: false
+    yes: false,
+    force: false
   };
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
@@ -97,6 +99,7 @@ function parseArgs(args) {
     else if (arg === '--tunnel-name') opts.tunnelName = args[++i];
     else if (arg === '--tunnel-credentials') opts.tunnelCredentials = args[++i];
     else if (arg === '--yes' || arg === '-y') opts.yes = true;
+    else if (arg === '--force') opts.force = true;
   }
   return opts;
 }
@@ -474,7 +477,7 @@ export default async function init(args) {
   }
 
   // ── Symlink nested brain skills to top-level .agent/skills/ ──
-  // Skills inside the brain (e.g. .agent/skills/total-recall/skills/ssss/) are
+  // Skills inside the brain (e.g. .agent/skills/total-recall/skills/tr-ssss/) are
   // invisible to IDEs because they only scan .agent/skills/<name>/ one level
   // deep. Create symlinks so they appear as slash commands.
   const nestedSkillsDir = path.join(brainDir, 'skills');
@@ -498,6 +501,43 @@ export default async function init(args) {
     }
   }
 
+  // ── Step 3.7: Project skills as slash commands 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.
+  const skillScope = isProject ? 'project' : 'global';
+  logStep('3.7/4', `Projecting ${skillScope} skills as slash commands (IDEs in use)`);
+  if (opts.dryRun) {
+    const targets = detectActiveSkillTargets({ scope: skillScope, cwd });
+    for (const t of targets.filter(t => t.supported)) {
+      const destLabel = t.destDir ? path.relative(cwd, t.destDir) || t.destDir : '(n/a)';
+      log(`  ${t.active ? 'would wire' : 'available (opt-in)'}: ${t.label} → ${destLabel}/`);
+    }
+  } else {
+    try {
+      const { skills, wired, available } = projectSkillsForScope({
+        scope: skillScope, cwd, agentDir, opts: { force: opts.force }
+      });
+      if (skills.length === 0) {
+        log('  No skills found yet — author one under .agent/skills/<name>/SKILL.md');
+      } else if (wired.length === 0) {
+        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;
+          logOk(`${t.label}: ${n} skill(s) → ${path.relative(cwd, t.destDir) || t.destDir}/`);
+        }
+        log(`  Slash commands: ${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>\``);
+        }
+      }
+    } catch (err) {
+      logWarn(`Could not project skills into IDEs: ${err.message}`);
+    }
+  }
+
   // ── Step 4: Run compile to inject memory block into existing IDE files ──
   logStep('4/4', 'Compiling vault and injecting into IDE instruction files');