@ericrisco/rsc 1.1.6 → 1.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ericrisco/rsc",
-  "version": "1.1.6",
+  "version": "1.2.1",
   "description": "Eric Risco's agent-skills catalog as a granular, self-recommending CLI installer.",
   "type": "module",
   "bin": {
@@ -19,10 +19,11 @@
     "knowledge:doctor": "node scripts/knowledge-doctor.js",
     "spec:gate": "node scripts/spec-gate.js",
     "routing:audit": "node scripts/routing-audit.js",
+    "originality:check": "node scripts/originality-check.js",
     "test": "node --test",
     "coverage": "c8 --reporter=text node --test",
     "version": "npm run manifest && git add manifest.json",
-    "prepublishOnly": "npm run manifest && npm run validate && npm run drift:check"
+    "prepublishOnly": "npm run manifest && npm run validate && npm run drift:check && npm run originality:check"
   },
   "dependencies": {
     "@iarna/toml": "^2.2.5",

package/schema/ecc-originality.json

@@ -0,0 +1,16 @@
+{
+  "schemaVersion": 1,
+  "source": "https://github.com/affaan-m/everything-claude-code",
+  "revision": "90430ab3a716e12a9c6770802efa352098735f24",
+  "generatedAt": "2026-09-02",
+  "included": [
+    "agents/**",
+    "commands/**"
+  ],
+  "ngramSize": 8,
+  "normalization": "NFKC lowercase; Unicode letters/numbers plus _+.#/-; whitespace joined",
+  "fingerprintFormat": "first 64 bits of SHA-256, sorted big-endian; collisions fail closed",
+  "fingerprintCount": 93337,
+  "dataSha256": "2025038e308e097c1d478c6eeeabf34dd35e6affa7abb20c3b31cf0fdde63463",
+  "exemptions": []
+}

package/scripts/build-manifest.js

@@ -4,6 +4,8 @@ import { fileURLToPath } from 'node:url';
 import Ajv from 'ajv';
 import { parseFrontmatter } from './lib/frontmatter.js';
 import { fenceBalance } from './lib/skill-lint.js';
+import { allAgentNames, agentByName } from '../targets/agents.js';
+import { fixedCommands, resolveCommands } from '../targets/commands.js';
 
 const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
 const SKILLS = join(ROOT, 'skills');
@@ -32,7 +34,45 @@ export function buildManifest() {
       profiles: fm.profiles || [],
     };
   }).sort((a, b) => a.id.localeCompare(b.id));
-  return { version, counts: { skills: skills.length }, skills };
+  const agents = allAgentNames().map((id) => {
+    const agent = agentByName(id);
+    return {
+      id,
+      description: agent.desc,
+      role: agent.role || (id === 'developer' ? 'developer' : 'refuter'),
+      tier: agent.tier || 'balanced',
+      tools: agent.tools || null,
+      skills: agent.skills || [],
+    };
+  }).sort((a, b) => a.id.localeCompare(b.id));
+  // Cursor exposes every command kind, so resolving the complete catalog through
+  // that target gives the target-neutral public inventory: fixed entries plus all
+  // stack aliases, without introducing a second alias table.
+  const commands = resolveCommands({
+    target: 'cursor',
+    skills: ids,
+    agents: allAgentNames(),
+    memoryMode: 'full',
+  }).map((command) => ({
+    id: command.name,
+    description: command.description,
+    kind: command.kind,
+    backing: command.backing,
+  }));
+  const sourceReceipts = JSON.parse(readFileSync(join(ROOT, 'targets', 'agent-sources.json'), 'utf8'));
+  return {
+    version,
+    counts: {
+      skills: skills.length,
+      agents: agents.length,
+      commands: commands.length,
+      fixedCommands: fixedCommands().length,
+    },
+    skills,
+    agents,
+    commands,
+    sourceReceipts,
+  };
 }
 
 export function validateFrontmatter() {
@@ -102,11 +142,11 @@ function main() {
     let current = '';
     try { current = readFileSync(out, 'utf8'); } catch { /* missing */ }
     if (current !== json) { console.error('manifest.json is stale — run `npm run manifest`'); process.exit(1); }
-    console.log(`manifest OK (${manifest.counts.skills} skills)`);
+    console.log(`manifest OK (${manifest.counts.skills} skills, ${manifest.counts.agents} agents, ${manifest.counts.commands} commands)`);
     return;
   }
   writeFileSync(out, json);
-  console.log(`wrote manifest.json (${manifest.counts.skills} skills)`);
+  console.log(`wrote manifest.json (${manifest.counts.skills} skills, ${manifest.counts.agents} agents, ${manifest.counts.commands} commands)`);
 }
 
 if (import.meta.url === `file://${process.argv[1]}`) main();

package/scripts/doctor.js

@@ -10,7 +10,11 @@ import { SDD_GATE_TEXT } from '../targets/hook-once.mjs';
 import { isEnabled, checkSello, readSello, countFindings, readEffectiveConfig, validateRiskConfig } from '../targets/sello.mjs';
 import { designIdentity } from './lib/design-identity.js';
 import { startingPointSummary } from './lib/starting-point.js';
-import { countGaps } from './lib/capabilities.js';
+import { countGaps, listSkills, listAgents } from './lib/capabilities.js';
+import { resolveCommands, commandPath, targetHasCommands } from '../targets/commands.js';
+import { inspectMemoryWiring } from '../targets/memory.js';
+import { metricsSummary } from '../targets/session-memory-core.mjs';
+import { agentPath } from '../targets/agents.js';
 
 // The sello's health, surfaced where the user already looks (spec: non-blocking
 // findings live in the project and are SUMMARIZED here, never nagged about).
@@ -81,6 +85,42 @@ export function doctor({ target, home, cwd }) {
   const state = readState(paths.stateFile);
   const manifest = loadManifest();
   const backups = listBackups({ cwd: root });
+  const memory = inspectMemoryWiring(
+    target,
+    root,
+    state.memory,
+    Boolean(Object.keys(state.skills || {}).length || state.agents?.length || state.commands?.length),
+  );
+  if (state.memory && !['unsupported', 'disabled'].includes(memory.mode)) {
+    const hasStore = existsSync(join(root, '.rsc', 'memory', 'sessions'))
+      || existsSync(join(root, '02-DOCS', 'raw', 'worklog', '.rsc-memory', 'sessions'));
+    try {
+      memory.metrics = hasStore
+        ? metricsSummary({ cwd: root })
+        : { sessions: [], total: { cost: null, toolCalls: null }, knownTotal: { cost: 0, toolCalls: 0 }, unknown: { cost: 0, toolCalls: 0 } };
+    } catch { memory.metrics = { sessions: [], total: { cost: null, toolCalls: null }, knownTotal: { cost: 0, toolCalls: 0 }, unknown: { cost: 0, toolCalls: 0 } }; }
+  }
+  const actualSkills = listSkills({ target, home, cwd: root }).map((entry) => entry.id);
+  const actualAgents = listAgents({ target, home, cwd: root }).agents.map((entry) => entry.id);
+  const desiredCommands = new Set(resolveCommands({
+    target,
+    skills: actualSkills,
+    agents: actualAgents,
+    memoryMode: memory.status === 'ready' ? memory.mode : 'degraded',
+  }).map((command) => command.name));
+  const missingCommands = [];
+  const commandOrphans = [];
+  if (targetHasCommands(target)) {
+    for (const id of state.commands || []) {
+      const path = commandPath(target, root, id);
+      if (!path || !existsSync(path)) missingCommands.push({ id, path, action: 'Run `npx @ericrisco/rsc sync` to restore this managed command.' });
+      else if (!desiredCommands.has(id)) commandOrphans.push({ id, path, action: 'Restore its backing skill/agent with `rsc add`, or run `rsc sync` to reconcile it.' });
+    }
+  }
+  const missingAgents = (state.agents || []).filter((id) => {
+    const path = agentPath(target, root, id);
+    return path && !existsSync(path);
+  }).map((id) => ({ id, action: 'Run `npx @ericrisco/rsc sync` to restore this managed agent.' }));
   const report = {
     target,
     installed: Object.keys(state.skills),
@@ -108,6 +148,12 @@ export function doctor({ target, home, cwd }) {
     gitmojiGuard: existsSync(join(root, '.rsc', '.no-gitmoji')) ? 'opted-out' : 'armed',
     // Counted, never interpreted — by spec, the gap log's reader is the user.
     automationGaps: countGaps(root),
+    memory,
+    missingAgents,
+    agentCollisions: state.agentCollisions || [],
+    missingCommands,
+    commandOrphans,
+    commandCollisions: state.commandCollisions || [],
   };
   for (const [id, e] of Object.entries(state.skills)) {
     for (const f of e.files) if (!existsSync(f)) report.missing.push(`${id}:${f}`);

package/scripts/install-apply.js

@@ -1,13 +1,22 @@
 #!/usr/bin/env node
 import { rmSync, existsSync, cpSync, mkdirSync, readFileSync, writeFileSync, appendFileSync, readdirSync } from 'node:fs';
-import { join, dirname, basename, relative, sep } from 'node:path';
+import { join, dirname, relative, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { planInstall } from './install-plan.js';
 import { targetPaths, writeSkill, wireHook, unwireHook, baseDir, TARGET_IDS } from '../targets/index.js';
-import { targetHasAgents, writeAgents, removeAgents, agentPath, agentNames } from '../targets/agents.js';
+import {
+  targetHasAgents, reconcileAgents, agentPath, agentNames,
+  resolveAgentNames, agentByName, readDeveloperTier,
+} from '../targets/agents.js';
 import { readState, writeState } from './lib/state.js';
 import { readManifest, writeManifest } from './lib/manifest-file.js';
 import { createBackup } from './lib/backups.js';
+import {
+  targetHasCommands, resolveCommands, reconcileCommands, commandPath,
+} from '../targets/commands.js';
+import {
+  wireMemory, unwireMemory, memoryManagedPaths, memoryModeFor, memoryEnabledForProject, memoryArtifactsPresent,
+} from '../targets/memory.js';
 
 const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
 const CLI_VERSION = JSON.parse(readFileSync(join(ROOT, 'package.json'), 'utf8')).version;
@@ -68,11 +77,29 @@ function generatedHookFiles({ target, cwd }) {
   ];
 }
 
-export function managedPathsForInstall({ skillIds, target, home, cwd }) {
+export function managedPathsForInstall({ skillIds, agentIds = [], target, home, cwd }) {
   const paths = targetPaths(target, home, cwd);
   const plan = planInstall({ skillIds, target, home, cwd });
   const out = [paths.stateFile, versionFile(cwd), baseVersionsFile(cwd)];
-  if (targetHasAgents(target)) out.push(...agentNames().map((n) => agentPath(target, cwd, n)), join(cwd, '.rsc', 'developer.json'));
+  out.push(...memoryManagedPaths(target, cwd));
+  if (targetHasAgents(target)) {
+    const state = readState(paths.stateFile);
+    const explicit = [...new Set([...(state.explicitAgents || readManifest(cwd)?.agents || []), ...agentIds])];
+    const desired = resolveAgentNames([...Object.keys(state.skills || {}), ...skillIds], explicit);
+    out.push(...[...new Set([...(state.agents || []), ...desired])].map((n) => agentPath(target, cwd, n)), join(cwd, '.rsc', 'developer.json'));
+  }
+  if (targetHasCommands(target)) {
+    const state = readState(paths.stateFile);
+    const explicit = [...new Set([...(state.explicitAgents || readManifest(cwd)?.agents || []), ...agentIds])];
+    const desiredAgents = resolveAgentNames([...Object.keys(state.skills || {}), ...skillIds], explicit);
+    const desiredCommands = resolveCommands({
+      target,
+      skills: [...new Set([...Object.keys(state.skills || {}), ...skillIds])],
+      agents: desiredAgents,
+      memoryMode: memoryEnabledForProject(cwd) ? memoryModeFor(target) : 'disabled',
+    });
+    out.push(...[...new Set([...(state.commands || []), ...desiredCommands.map((command) => command.name)])].map((name) => commandPath(target, cwd, name)));
+  }
   for (const step of plan) {
     if (step.kind === 'skill') {
       out.push(step.to, baseDir(step.id, cwd));
@@ -102,8 +129,8 @@ function localDecisions(cwd) {
 // into codex on a machine that already had claude is adding, not replacing. Union, sorted
 // where order carries no meaning, so the file stays diffable and a merge conflict stays
 // readable.
-export function recordInManifest({ cwd, target, skillIds, catalogVersion = CLI_VERSION, dropTarget }) {
-  const prev = readManifest(cwd) || { targets: [], skills: [], ownSkills: [], optOuts: [] };
+export function recordInManifest({ cwd, target, skillIds, agentIds = [], catalogVersion = CLI_VERSION, dropTarget }) {
+  const prev = readManifest(cwd) || { targets: [], skills: [], agents: [], ownSkills: [], optOuts: [] };
   const { optOuts, tier } = localDecisions(cwd);
   const union = (a, b) => [...new Set([...(a || []), ...(b || [])])].sort();
   return writeManifest(cwd, {
@@ -113,18 +140,20 @@ export function recordInManifest({ cwd, target, skillIds, catalogVersion = CLI_V
     // have every clone rebuild a harness that was deliberately abandoned.
     targets: union(prev.targets, [target]).filter((t) => t !== dropTarget),
     skills: union(prev.skills, skillIds),
+    agents: union(prev.agents, agentIds),
     ownSkills: prev.ownSkills || [],
     catalogVersion,
     tier: tier ?? prev.tier ?? null,
     optOuts: optOuts.length ? optOuts : (prev.optOuts || []),
+    memory: prev.memory,
   });
 }
 
-export async function applyInstall({ skillIds, target, home, cwd = process.cwd(), operation = 'install', dryRun = false }) {
+export async function applyInstall({ skillIds = [], agentIds = [], target, home, cwd = process.cwd(), operation = 'install', dryRun = false }) {
   const paths = targetPaths(target, home, cwd);
   const plan = planInstall({ skillIds, target, home, cwd });
-  const managedPaths = managedPathsForInstall({ skillIds, target, home, cwd });
-  if (dryRun) return { dryRun: true, skills: skillIds, paths: managedPaths };
+  const managedPaths = managedPathsForInstall({ skillIds, agentIds, target, home, cwd });
+  if (dryRun) return { dryRun: true, skills: skillIds, agents: agentIds, paths: managedPaths };
   const state = readState(paths.stateFile);
   const backup = createBackup({ cwd, operation, target, paths: managedPaths, cliVersion: CLI_VERSION });
   // Decide base refresh per skill (see baseVersionsFile): a base is re-materialized when
@@ -150,15 +179,34 @@ export async function applyInstall({ skillIds, target, home, cwd = process.cwd()
   //
   // The recorded names come from what was WRITTEN, not from a hardcoded list: a state entry
   // naming an agent whose file never landed answers "you have it" for something absent.
+  const explicit = [...new Set([...(state.explicitAgents || readManifest(cwd)?.agents || []), ...agentIds])].sort();
+  const desiredAgents = resolveAgentNames(Object.keys(state.skills || {}), explicit);
+  const previousAgents = state.agents || [];
   if (targetHasAgents(target)) {
-    const written = writeAgents(target, cwd);
-    state.agents = written.map((f) => basename(f).split('.')[0]);
+    const agentResult = reconcileAgents(target, cwd, readDeveloperTier(cwd), previousAgents, desiredAgents);
+    state.agents = agentResult.names;
+    state.agentCollisions = agentResult.collisions;
+  } else {
+    state.agents = [];
+    state.agentCollisions = [];
   }
+  state.explicitAgents = explicit;
+  const memoryResult = wireMemory(target, cwd);
+  state.memory = { mode: memoryResult.mode, reason: memoryResult.reason, paths: memoryResult.paths };
+  const desiredCommands = resolveCommands({
+    target,
+    skills: Object.keys(state.skills || {}),
+    agents: state.agents,
+    memoryMode: state.memory?.mode || 'unsupported',
+  });
+  const commandResult = reconcileCommands(target, cwd, state.commands || [], desiredCommands);
+  state.commands = commandResult.names;
+  state.commandCollisions = commandResult.collisions;
   state.version = CLI_VERSION;
   writeState(paths.stateFile, state);
   mkdirSync(dirname(versionFile(cwd)), { recursive: true });
   writeFileSync(versionFile(cwd), CLI_VERSION + '\n');
-  recordInManifest({ cwd, target, skillIds });
+  recordInManifest({ cwd, target, skillIds, agentIds });
   ignoreLocalState(cwd, target);
   return { ...state, backup };
 }
@@ -196,7 +244,14 @@ export function ignoreLocalState(cwd = process.cwd(), target) {
     // repo. The declaration that does travel is .rsc.json, in the root.
     wanted.push(rel(paths.stateFile));
     // Subagents are catalog content, re-materialised by every install and sync.
-    for (const f of agentNames()) wanted.push(rel(agentPath(target, cwd, f)));
+    for (const name of readState(paths.stateFile).agents || []) {
+      const file = agentPath(target, cwd, name);
+      if (file) wanted.push(rel(file));
+    }
+    for (const name of readState(paths.stateFile).commands || []) {
+      const file = commandPath(target, cwd, name);
+      if (file) wanted.push(rel(file));
+    }
   }
   // `.rsc`, `/.rsc` and `.rsc/` are the same rule to git. Normalising both ends is what
   // keeps this idempotent against a .gitignore a human wrote in their own spelling.
@@ -224,7 +279,26 @@ export function listInstalled({ target, home, cwd = process.cwd() }) {
   return Object.keys(readState(paths.stateFile).skills);
 }
 
-export async function uninstall({ skillIds, target, home, cwd = process.cwd(), dryRun }) {
+export function listInstalledAgents({ target, home, cwd = process.cwd() }) {
+  const state = readState(targetPaths(target, home, cwd).stateFile);
+  const explicit = new Set(state.explicitAgents || []);
+  return (state.agents || []).map((id) => {
+    const agent = agentByName(id);
+    return {
+      id,
+      source: agentNames().includes(id) ? 'base' : explicit.has(id) ? 'explicit' : 'skill',
+      skills: agent?.skills || [],
+    };
+  });
+}
+
+export function listInstalledCommands({ target, home, cwd = process.cwd() }) {
+  const state = readState(targetPaths(target, home, cwd).stateFile);
+  return (state.commands || []).map((id) => ({ id, path: commandPath(target, cwd, id) }))
+    .filter((entry) => entry.path && existsSync(entry.path));
+}
+
+export async function uninstall({ skillIds = [], agentIds = [], target, home, cwd = process.cwd(), dryRun }) {
   const paths = targetPaths(target, home, cwd);
   const state = readState(paths.stateFile);
   const removed = [];
@@ -237,9 +311,19 @@ export async function uninstall({ skillIds, target, home, cwd = process.cwd(), d
       removed.push(f);
     }
   }
-  if (!removed.length) return removed;
-  if (dryRun) return removed;
-  createBackup({ cwd, operation: 'uninstall', target, paths: managedPaths, cliVersion: CLI_VERSION });
+  const previousExplicit = state.explicitAgents || readManifest(cwd)?.agents || [];
+  const nextExplicit = previousExplicit.filter((id) => !agentIds.includes(id));
+  const remainingSkillIds = Object.keys(state.skills || {}).filter((id) => !skillIds.includes(id));
+  const desiredAgents = resolveAgentNames(remainingSkillIds, nextExplicit);
+  const staleAgents = (state.agents || []).filter((id) => !desiredAgents.includes(id));
+  for (const id of staleAgents) {
+    const file = agentPath(target, cwd, id);
+    if (file) { managedPaths.push(file); removed.push(file); }
+  }
+  const explicitChanged = nextExplicit.length !== previousExplicit.length;
+  if (!removed.length && !explicitChanged) return removed;
+  if (dryRun) return [...new Set(removed)];
+  createBackup({ cwd, operation: 'uninstall', target, paths: [...new Set(managedPaths)], cliVersion: CLI_VERSION });
   for (const id of skillIds) {
     const entry = state.skills[id];
     if (!entry) continue;
@@ -248,8 +332,28 @@ export async function uninstall({ skillIds, target, home, cwd = process.cwd(), d
     }
     delete state.skills[id];
   }
+  const agentResult = reconcileAgents(target, cwd, readDeveloperTier(cwd), state.agents || [], desiredAgents);
+  state.agents = agentResult.names;
+  state.agentCollisions = agentResult.collisions;
+  state.explicitAgents = nextExplicit;
+  const desiredCommands = resolveCommands({
+    target,
+    skills: remainingSkillIds,
+    agents: state.agents,
+    memoryMode: state.memory?.mode || 'unsupported',
+  });
+  const commandResult = reconcileCommands(target, cwd, state.commands || [], desiredCommands);
+  removed.push(...commandResult.removed);
+  state.commands = commandResult.names;
+  state.commandCollisions = commandResult.collisions;
   writeState(paths.stateFile, state);
-  return removed;
+  const manifest = readManifest(cwd);
+  if (manifest) writeManifest(cwd, {
+    ...manifest,
+    skills: manifest.skills.filter((id) => !skillIds.includes(id)),
+    agents: manifest.agents.filter((id) => !agentIds.includes(id)),
+  });
+  return [...new Set(removed)];
 }
 
 export async function syncInstalled({ target, home, cwd = process.cwd(), dryRun = false }) {
@@ -260,17 +364,20 @@ export async function syncInstalled({ target, home, cwd = process.cwd(), dryRun
   // declares a harness and has none. The committed manifest is exactly the declaration
   // to rebuild from, and it is sitting right there.
   const ids = Object.keys(state.skills || {});
-  const declared = ids.length ? ids : (readManifest(cwd)?.skills || []);
-  if (!declared.length) return dryRun ? { dryRun: true, synced: [], paths: [] } : { synced: [], backup: null };
+  const manifest = readManifest(cwd);
+  const declared = ids.length ? ids : (manifest?.skills || []);
+  const declaredAgents = state.explicitAgents?.length ? state.explicitAgents : (manifest?.agents || []);
+  if (!declared.length && !declaredAgents.length) return dryRun ? { dryRun: true, synced: [], syncedAgents: [], paths: [] } : { synced: [], syncedAgents: [], backup: null };
   if (dryRun) {
     return {
       dryRun: true,
       synced: declared,
-      paths: managedPathsForInstall({ skillIds: declared, target, home, cwd }),
+      syncedAgents: declaredAgents,
+      paths: managedPathsForInstall({ skillIds: declared, agentIds: declaredAgents, target, home, cwd }),
     };
   }
-  const nextState = await applyInstall({ skillIds: declared, target, home, cwd, operation: 'sync' });
-  return { synced: declared, backup: nextState.backup };
+  const nextState = await applyInstall({ skillIds: declared, agentIds: declaredAgents, target, home, cwd, operation: 'sync' });
+  return { synced: declared, syncedAgents: declaredAgents, backup: nextState.backup };
 }
 
 // Remove EVERYTHING rsc put in this project: installed skills across all targets,
@@ -293,20 +400,30 @@ export async function purge({ home, cwd = process.cwd(), withDocs = false, dryRu
       for (const id of Object.keys(state.skills || {})) {
         for (const f of state.skills[id].files || []) drop(f, true);
       }
+      for (const name of state.commands || []) {
+        const file = commandPath(target, cwd, name);
+        if (file) drop(file);
+      }
+      for (const name of state.agents || []) {
+        const file = agentPath(target, cwd, name);
+        if (file) drop(file);
+      }
       drop(paths.stateFile);
     }
-    // unwireHook mutates files, so only run it for real (dry runs skip it).
-    if (!dryRun) removed.push(...unwireHook(target, paths));
-    // Remove the subagents this catalog installed — and only those. An uninstaller that takes
-    // an agent the user wrote by hand is worse than one that leaves residue.
-    for (const n of agentNames()) {
-      const agentFile = agentPath(target, cwd, n);
-      if (agentFile) drop(agentFile);
+    // Unwiring mutates shared config files, so only run it for real (dry runs report
+    // those files without touching them).
+    if (!dryRun) {
+      removed.push(...unwireHook(target, paths));
+      removed.push(...unwireMemory(target, cwd));
+    } else {
+      removed.push(...memoryArtifactsPresent(target, cwd));
     }
+    // A lost state file also loses proof of ownership. Leave same-named user files
+    // behind rather than guessing from a catalog id and deleting their work.
   }
   drop(join(cwd, '.rsc'), true);
   if (withDocs) drop(join(cwd, '02-DOCS'), true);
-  return removed;
+  return [...new Set(removed)];
 }
 
 if (import.meta.url === `file://${process.argv[1]}`) {

package/scripts/lib/capabilities.js

@@ -25,6 +25,9 @@ import { homedir } from 'node:os';
 import { loadManifest } from './manifest.js';
 import { targetPaths } from '../../targets/index.js';
 import { developerAgentPath, targetHasAgents } from '../../targets/agents.js';
+import { targetHasCommands, commandPath } from '../../targets/commands.js';
+import { inspectMemoryWiring } from '../../targets/memory.js';
+import { readState } from './state.js';
 
 // AGENT_TARGETS is not exported, so derive dir + extension from the one path helper
 // that owns it — duplicating that table is how two copies drift apart. The extension
@@ -101,6 +104,14 @@ export function listSkills({ target, home, cwd = process.cwd() } = {}) {
   return out.sort((a, b) => a.id.localeCompare(b.id) || a.scope.localeCompare(b.scope));
 }
 
+export function listCommands({ target, cwd = process.cwd() } = {}) {
+  if (!targetHasCommands(target)) return { supported: false, commands: [] };
+  const state = readState(targetPaths(target, undefined, cwd).stateFile);
+  const commands = (state.commands || []).map((id) => ({ id, path: commandPath(target, cwd, id) }))
+    .filter((entry) => entry.path && existsSync(entry.path));
+  return { supported: true, commands };
+}
+
 // Keep the discriminator: a description's value is its `NOT x (that is y)` boundary,
 // so never cut it off. Trim the middle instead when the whole thing is long.
 export function shortDesc(d, limit = 220) {
@@ -124,6 +135,8 @@ export function capabilities({ target, home, cwd = process.cwd(), full = false }
   const skills = listSkills({ target, home, cwd });
   const installedIds = new Set(skills.map((s) => s.id));
   const { supported, agents } = listAgents({ target, home, cwd });
+  const commandReport = listCommands({ target, cwd });
+  const state = readState(targetPaths(target, home, cwd).stateFile);
   return {
     target,
     agentsSupported: supported,
@@ -133,6 +146,14 @@ export function capabilities({ target, home, cwd = process.cwd(), full = false }
       .map((s) => (full ? { id: s.id, description: shortDesc(s.description) } : { id: s.id }))
       .sort((a, b) => a.id.localeCompare(b.id)),
     agents,
+    commandsSupported: commandReport.supported,
+    commands: commandReport.commands,
+    memory: inspectMemoryWiring(
+      target,
+      cwd,
+      state.memory,
+      Boolean(Object.keys(state.skills || {}).length || state.agents?.length || state.commands?.length),
+    ),
   };
 }
 

package/scripts/lib/manifest-file.js

@@ -15,7 +15,7 @@ import { join } from 'node:path';
 export const MANIFEST = '.rsc.json';
 export const manifestPath = (cwd = process.cwd()) => join(cwd, MANIFEST);
 
-const KEYS = ['version', 'targets', 'skills', 'ownSkills', 'catalogVersion', 'tier', 'optOuts'];
+const KEYS = ['version', 'targets', 'skills', 'agents', 'ownSkills', 'catalogVersion', 'tier', 'optOuts', 'memory'];
 
 export function readManifest(cwd = process.cwd()) {
   const file = manifestPath(cwd);
@@ -32,10 +32,12 @@ export function readManifest(cwd = process.cwd()) {
     version: raw.version ?? 1,
     targets: raw.targets || [],
     skills: raw.skills || [],
+    agents: raw.agents || [],
     ownSkills: raw.ownSkills || [],
     catalogVersion: raw.catalogVersion ?? null,
     tier: raw.tier ?? null,
     optOuts: raw.optOuts || [],
+    memory: raw.memory ?? undefined,
   };
 }
 
@@ -45,6 +47,7 @@ export function writeManifest(cwd, manifest) {
   const out = {};
   for (const k of KEYS) if (manifest[k] !== undefined) out[k] = manifest[k];
   out.version ??= 1;
+  out.agents ??= [];
   const ordered = {};
   for (const k of KEYS) if (out[k] !== undefined) ordered[k] = out[k];
   const file = manifestPath(cwd);