@ericrisco/rsc 1.1.6 → 1.2.1

package/targets/commands.js

@@ -0,0 +1,212 @@
+import { existsSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { agentByName, allAgentNames } from './agents.js';
+
+const COMMAND_TARGETS = Object.freeze({
+  claude: { dir: '.claude/commands', ext: '.md', format: 'claude', skillsAreCommands: true },
+  cursor: { dir: '.cursor/commands', ext: '.md', format: 'plain' },
+  gemini: { dir: '.gemini/commands', ext: '.toml', format: 'gemini' },
+  opencode: { dir: '.opencode/commands', ext: '.md', format: 'opencode' },
+  copilot: { dir: '.github/prompts', ext: '.prompt.md', format: 'copilot' },
+  windsurf: { dir: '.windsurf/workflows', ext: '.md', format: 'windsurf' },
+  cline: { dir: '.clinerules/workflows', ext: '.md', format: 'plain', invocationSuffix: '.md' },
+  roo: { dir: '.roo/commands', ext: '.md', format: 'roo' },
+});
+
+export const COMMAND_TARGET_IDS = Object.freeze(Object.keys(COMMAND_TARGETS));
+export const targetHasCommands = (target) => Boolean(COMMAND_TARGETS[target]);
+
+const delegate = (kind, backing) => `Delegate this request to the ${backing} ${kind}. Pass the invocation arguments unchanged: {{ARGS}}\nDo not reproduce that ${kind}'s method here; load it and follow its own stopping and verification rules.`;
+
+const skillCommand = (name, backing = name) => ({
+  name,
+  kind: 'skill',
+  backing,
+  description: `Run the ${backing} skill through a short, non-duplicating entry point.`,
+  body: delegate('skill', backing),
+});
+
+const FIXED_COMMANDS = Object.freeze([
+  ...['specify', 'clarify', 'plan', 'tasks', 'analyze', 'implement', 'verify', 'review', 'ship', 'debug'].map((name) => skillCommand(name)),
+  {
+    name: 'build-fix', kind: 'resolver-selector', backing: 'build-resolver',
+    description: 'Route a build failure to the installed stack resolver without guessing.',
+    body: `Use an installed build-resolver for this failure: {{ARGS}}\nChoose from diagnostic text and affected paths. If more than one remains plausible, list the candidates and ask the user; never dispatch at random.`,
+  },
+  skillCommand('refactor-clean', 'simplify-code'),
+  {
+    name: 'test-coverage', kind: 'testing-skill', backing: 'testing-*',
+    description: 'Delegate coverage work to the installed stack testing skill.',
+    body: delegate('skill', 'testing-*'),
+  },
+  skillCommand('update-docs', 'knowledge-ops'),
+  {
+    name: 'checkpoint', kind: 'capability', backing: 'sello',
+    description: 'Freeze the current candidate for review and seal it only after the required lenses approve.',
+    body: `Use the sello backing for this checkpoint: {{ARGS}}\nRun \`npx @ericrisco/rsc sello freeze\`, complete the required review, then run \`sello approve\` only with the observed lenses. Do not treat freeze as approval.`,
+  },
+  skillCommand('harness-audit', 'harness'),
+  skillCommand('security-scan', 'security-scan'),
+  {
+    name: 'learn', kind: 'memory', backing: 'memory:learn',
+    description: 'Propose one local lesson; saving still requires individual explicit approval.',
+    body: `Invoke memory:learn for exactly one proposed lesson: {{ARGS}}\nAfter individual explicit approval, run \`npx @ericrisco/rsc memory learn\` with its text, evidence, scope, confidence and \`--approve\`. Without that approval, write nothing.`,
+  },
+  {
+    name: 'save-session', kind: 'memory', backing: 'memory:save',
+    description: 'Force a local deterministic session checkpoint.',
+    body: `Invoke memory:save with the current local session identifiers: {{ARGS}}\nRun \`npx @ericrisco/rsc memory save --session <id>\`. Persist only allowed git and SDD ledger metadata; never include conversation or file content.`,
+  },
+  {
+    name: 'resume-session', kind: 'memory', backing: 'memory:resume',
+    description: 'Read the bounded local continuation record for this branch and worktree.',
+    body: `Invoke memory:resume for the current branch and worktree: {{ARGS}}\nRun \`npx @ericrisco/rsc memory resume\`. Label a nearby branch result as nearby; never merge it silently into the exact continuation.`,
+  },
+]);
+
+export const fixedCommands = () => FIXED_COMMANDS.map((command) => ({ ...command }));
+export const fixedCommandNames = () => FIXED_COMMANDS.map((command) => command.name);
+
+function withBacking(command, backing, body) {
+  return { ...command, backing, body: body || command.body.replace(command.backing, backing) };
+}
+
+function fixedFor({ target, skills, agents, memoryMode }) {
+  const spec = COMMAND_TARGETS[target];
+  if (!spec) return [];
+  const skillSet = new Set(skills);
+  const resolverIds = agents.filter((id) => agentByName(id)?.role === 'build-resolver');
+  const testing = skills.filter((id) => id.startsWith('testing-')).sort();
+  const out = [];
+  for (const command of FIXED_COMMANDS) {
+    if (command.kind === 'skill') {
+      if (!skillSet.has(command.backing) || spec.skillsAreCommands) continue;
+      out.push({ ...command });
+    } else if (command.kind === 'testing-skill') {
+      if (!testing.length || spec.skillsAreCommands) continue;
+      out.push(withBacking(command, testing[0]));
+    } else if (command.kind === 'resolver-selector') {
+      if (!resolverIds.length) continue;
+      const backing = resolverIds.length === 1 ? resolverIds[0] : 'build-resolver';
+      const candidates = resolverIds.join(', ');
+      out.push(withBacking(command, backing,
+        `Choose the matching installed build-resolver from: ${candidates}. Pass the failure and invocation arguments unchanged: {{ARGS}}\nUse diagnostics and affected paths. If the choice is ambiguous, list candidates and ask; never dispatch at random.`));
+    } else if (command.kind === 'memory') {
+      if (!['full', 'assisted'].includes(memoryMode)) continue;
+      out.push({ ...command });
+    } else {
+      out.push({ ...command });
+    }
+  }
+  return out;
+}
+
+function stackAliases({ skills, agents }) {
+  const skillSet = new Set(skills);
+  const out = [];
+  for (const id of agents) {
+    const agent = agentByName(id);
+    if (!agent || !['reviewer', 'build-resolver'].includes(agent.role) || !agent.skills?.length) continue;
+    const installedAliases = agent.skills.filter((skill) => skillSet.has(skill));
+    const aliases = installedAliases.length ? installedAliases : [agent.skills[0]];
+    const suffix = agent.role === 'reviewer' ? 'review' : 'build';
+    for (const skill of aliases) {
+      out.push({
+        name: `${skill}-${suffix}`,
+        kind: 'agent',
+        backing: id,
+        description: `Delegate ${skill} ${suffix} work to the installed ${id} agent.`,
+        body: delegate('agent', id),
+      });
+    }
+  }
+  return out;
+}
+
+export function resolveCommands({ target, skills = [], agents = [], memoryMode = 'unsupported' }) {
+  if (!targetHasCommands(target)) return [];
+  const byName = new Map();
+  for (const command of [...fixedFor({ target, skills, agents, memoryMode }), ...stackAliases({ skills, agents })]) {
+    byName.set(command.name, command);
+  }
+  return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+
+export function validateCommandCatalog(definitions = FIXED_COMMANDS) {
+  const errors = [];
+  const seen = new Set();
+  for (const command of definitions) {
+    const prefix = command?.name || '<unnamed>';
+    if (!command?.name || seen.has(command.name)) errors.push(`${prefix}: unique name required`);
+    seen.add(command?.name);
+    if (!command?.backing || !command?.body?.includes(command.backing)) errors.push(`${prefix}: body must name its exact backing`);
+    if ((command?.body || '').split('\n').length > 40) errors.push(`${prefix}: body exceeds 40 lines`);
+    if (/everything[- ]claude|affaan|worldflow/iu.test(`${command?.description || ''}\n${command?.body || ''}`)) errors.push(`${prefix}: foreign project vocabulary`);
+  }
+  return errors;
+}
+
+export function commandPath(target, cwd, name) {
+  const spec = COMMAND_TARGETS[target];
+  return spec ? join(cwd, ...spec.dir.split('/'), `${name}${spec.ext}`) : null;
+}
+
+function renderArgs(target, body) {
+  const placeholder = target === 'claude' || target === 'opencode' ? '$ARGUMENTS'
+    : target === 'gemini' ? '{{args}}'
+      : 'any text following the slash command';
+  return body.replaceAll('{{ARGS}}', placeholder);
+}
+
+function markdown(command, target) {
+  const body = renderArgs(target, command.body);
+  if (target === 'cursor' || target === 'cline') return `# /${command.name}\n\n${command.description}\n\n${body}\n`;
+  if (target === 'windsurf') return `# /${command.name}\n\n${command.description}\n\n1. ${body.replaceAll('\n', '\n2. ')}\n`;
+  const fm = ['---', `description: "${command.description.replaceAll('"', '\\"')}"`, 'argument-hint: "[arguments]"'];
+  if (target === 'copilot') fm.push('mode: agent');
+  if (target === 'opencode' && command.kind === 'agent') fm.push(`agent: ${command.backing}`);
+  fm.push('---', '');
+  return `${fm.join('\n')}${body}\n`;
+}
+
+function render(command, target) {
+  if (target !== 'gemini') return markdown(command, target);
+  const body = renderArgs(target, command.body);
+  return `description = ${JSON.stringify(command.description)}\nprompt = ${JSON.stringify(body)}\n`;
+}
+
+export function reconcileCommands(target, cwd, previousNames = [], desiredCommands = []) {
+  if (!targetHasCommands(target)) return { written: [], removed: [], collisions: [], names: [] };
+  const previous = new Set(previousNames);
+  const desiredNames = new Set(desiredCommands.map((command) => command.name));
+  const removed = [];
+  for (const name of previous) {
+    if (desiredNames.has(name)) continue;
+    const path = commandPath(target, cwd, name);
+    if (path && existsSync(path)) { rmSync(path, { force: true }); removed.push(path); }
+  }
+  const written = [];
+  const collisions = [];
+  const names = [];
+  for (const command of desiredCommands) {
+    const path = commandPath(target, cwd, command.name);
+    if (existsSync(path) && !previous.has(command.name)) {
+      collisions.push(path);
+      continue;
+    }
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, render(command, target));
+    written.push(path);
+    names.push(command.name);
+  }
+  return { written, removed, collisions, names };
+}
+
+export function allPotentialCommandNames() {
+  const names = new Set(fixedCommandNames());
+  // Every stack alias follows directly from catalog metadata; no second mapping.
+  const agents = allAgentNames();
+  const skills = [...new Set(agents.flatMap((id) => agentByName(id)?.skills || []))];
+  for (const command of stackAliases({ skills, agents })) names.add(command.name);
+  return [...names];
+}

package/targets/memory.js

@@ -0,0 +1,276 @@
+import {
+  appendFileSync, copyFileSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync,
+} from 'node:fs';
+import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+export { handleLifecycle, contextFromNativeOutput } from './session-memory-adapter.mjs';
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const NEEDLE = '.rsc/session-memory-adapter.mjs';
+const PLUGIN_MARKER = 'rsc-memory:managed';
+
+export const MEMORY_TARGETS = Object.freeze({
+  claude: 'full',
+  codex: 'full',
+  // Cursor documents sessionStart as fire-and-forget. Its best-effort hook is useful,
+  // but only the always-on rule can make the read-before-action obligation explicit.
+  cursor: 'assisted',
+  gemini: 'full',
+  opencode: 'full',
+});
+
+const CONFIG = Object.freeze({
+  claude: '.claude/settings.local.json',
+  codex: '.codex/hooks.json',
+  cursor: '.cursor/hooks.json',
+  gemini: '.gemini/settings.json',
+  opencode: '.opencode/plugins/rsc-memory.js',
+});
+
+export const memoryModeFor = (target) => MEMORY_TARGETS[target] || 'unsupported';
+
+export function memoryEnabledForProject(cwd = process.cwd()) {
+  try { return JSON.parse(readFileSync(join(cwd, '.rsc.json'), 'utf8')).memory !== false; } catch { return true; }
+}
+
+function git(cwd, args) {
+  try { return execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim(); } catch { return null; }
+}
+
+function rel(cwd, path) {
+  return relative(cwd, path).split(sep).join('/');
+}
+
+function tracked(cwd, path) {
+  const output = git(cwd, ['ls-files', '--', rel(cwd, path)]);
+  return Boolean(output);
+}
+
+function exclude(cwd, path) {
+  if (git(cwd, ['rev-parse', '--is-inside-work-tree']) !== 'true') return;
+  const value = git(cwd, ['rev-parse', '--git-path', 'info/exclude']);
+  if (!value) return;
+  const file = isAbsolute(value) ? value : resolve(cwd, value);
+  const pattern = `/${rel(cwd, path)}`;
+  mkdirSync(dirname(file), { recursive: true });
+  const body = existsSync(file) ? readFileSync(file, 'utf8') : '';
+  if (!body.split('\n').includes(pattern)) appendFileSync(file, `${body && !body.endsWith('\n') ? '\n' : ''}${pattern}\n`);
+}
+
+function readConfig(path) {
+  if (!existsSync(path)) return {};
+  try { return JSON.parse(readFileSync(path, 'utf8')); } catch { return null; }
+}
+
+function validHookConfig(config) {
+  if (!config || typeof config !== 'object' || Array.isArray(config)) return false;
+  if (!Object.hasOwn(config, 'hooks')) return true;
+  if (!config.hooks || typeof config.hooks !== 'object' || Array.isArray(config.hooks)) return false;
+  return Object.values(config.hooks).every(Array.isArray);
+}
+
+function handler(target, event) {
+  const unixScript = target === 'claude'
+    ? '"${CLAUDE_PROJECT_DIR}/.rsc/session-memory-adapter.mjs"'
+    : target === 'codex'
+      ? '"$(git rev-parse --show-toplevel)/.rsc/session-memory-adapter.mjs"'
+      : '".rsc/session-memory-adapter.mjs"';
+  const value = {
+    type: 'command',
+    command: `node ${unixScript} ${target} ${event}`,
+    timeout: target === 'gemini' ? 5000 : event === 'end' && target === 'codex' ? 3 : 5,
+  };
+  if (target === 'codex') {
+    value.commandWindows = `node \"$((git rev-parse --show-toplevel).Trim())/.rsc/session-memory-adapter.mjs\" ${target} ${event}`;
+    value.additionalContextLimit = 1400;
+  }
+  if (target === 'gemini') value.name = `rsc-memory-${event}`;
+  return value;
+}
+
+const nestedEvents = {
+  claude: [
+    ['SessionStart', 'start'], ['UserPromptSubmit', 'request'], ['PostToolUse', 'edit', 'Edit|Write|NotebookEdit'],
+    ['PostToolUse', 'boundary', 'Bash'], ['Stop', 'turn'], ['PreCompact', 'compact'], ['SessionEnd', 'end'],
+  ],
+  codex: [
+    ['SessionStart', 'start', 'startup|resume|clear|compact'], ['UserPromptSubmit', 'request'],
+    ['PostToolUse', 'edit', 'apply_patch|Edit|Write'], ['PostToolUse', 'boundary', 'Bash'],
+    ['Stop', 'turn'], ['PreCompact', 'compact'], ['SessionEnd', 'end'],
+  ],
+  gemini: [
+    ['SessionStart', 'start'], ['BeforeAgent', 'request'], ['AfterTool', 'edit', 'write_file|replace'],
+    ['AfterTool', 'boundary', 'run_shell_command'], ['AfterAgent', 'turn'], ['PreCompress', 'compact'], ['SessionEnd', 'end'],
+  ],
+};
+
+const cursorEvents = [
+  ['sessionStart', 'start'], ['beforeSubmitPrompt', 'request'], ['afterFileEdit', 'edit'],
+  ['afterShellExecution', 'boundary'], ['afterAgentResponse', 'turn'], ['preCompact', 'compact'], ['sessionEnd', 'end'],
+];
+
+function stripManaged(config) {
+  if (!validHookConfig(config) || !config.hooks) return config;
+  for (const event of Object.keys(config.hooks)) {
+    config.hooks[event] = (config.hooks[event] || []).filter((entry) => !JSON.stringify(entry).replaceAll('\\\\', '/').includes(NEEDLE));
+    if (!config.hooks[event].length) delete config.hooks[event];
+  }
+  if (!Object.keys(config.hooks).length) delete config.hooks;
+  return config;
+}
+
+function writeJsonWiring(target, path, config) {
+  stripManaged(config);
+  config.hooks ||= {};
+  if (target === 'cursor') {
+    config.version ||= 1;
+    for (const [event, operation] of cursorEvents) {
+      config.hooks[event] ||= [];
+      const entry = handler(target, operation);
+      delete entry.type;
+      delete entry.timeout;
+      config.hooks[event].push(entry);
+    }
+  } else {
+    for (const [event, operation, matcher] of nestedEvents[target]) {
+      config.hooks[event] ||= [];
+      config.hooks[event].push({ ...(matcher ? { matcher } : {}), hooks: [handler(target, operation)] });
+    }
+  }
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(config, null, 2)}\n`);
+}
+
+function commonPaths(cwd) {
+  return [
+    join(cwd, '.rsc', 'session-memory-core.mjs'),
+    join(cwd, '.rsc', 'session-memory-adapter.mjs'),
+    join(cwd, '.rsc', 'session-memory.mjs'),
+  ];
+}
+
+export function memoryManagedPaths(target, cwd = process.cwd()) {
+  if (!MEMORY_TARGETS[target]) return [];
+  const paths = [...commonPaths(cwd), join(cwd, ...CONFIG[target].split('/'))];
+  if (target === 'cursor') paths.push(join(cwd, '.cursor', 'rules', 'rsc-memory.mdc'));
+  return paths;
+}
+
+export function wireMemory(target, cwd = process.cwd()) {
+  const mode = memoryModeFor(target);
+  if (mode === 'unsupported') return { mode, reason: 'no-local-lifecycle', paths: [] };
+  if (!memoryEnabledForProject(cwd)) {
+    unwireMemory(target, cwd);
+    return { mode: 'disabled', reason: 'project-disabled', paths: [] };
+  }
+  const configPath = join(cwd, ...CONFIG[target].split('/'));
+  if (tracked(cwd, configPath)) return { mode: 'degraded', reason: 'config-tracked', paths: [] };
+  const config = target === 'opencode' ? null : readConfig(configPath);
+  if (target !== 'opencode' && !validHookConfig(config)) return { mode: 'degraded', reason: 'config-invalid', paths: [] };
+  if (target === 'opencode' && existsSync(configPath) && !readFileSync(configPath, 'utf8').includes(PLUGIN_MARKER)) {
+    return { mode: 'degraded', reason: 'plugin-collision', paths: [] };
+  }
+  const assistedRule = join(cwd, '.cursor', 'rules', 'rsc-memory.mdc');
+  if (target === 'cursor' && tracked(cwd, assistedRule)) return { mode: 'degraded', reason: 'rule-tracked', paths: [] };
+  if (target === 'cursor' && existsSync(assistedRule) && !readFileSync(assistedRule, 'utf8').includes('rsc-memory:managed')) {
+    return { mode: 'degraded', reason: 'rule-collision', paths: [] };
+  }
+
+  const [core, adapter, cli] = commonPaths(cwd);
+  mkdirSync(dirname(core), { recursive: true });
+  copyFileSync(join(HERE, 'session-memory-core.mjs'), core);
+  copyFileSync(join(HERE, 'session-memory-adapter.mjs'), adapter);
+  copyFileSync(join(HERE, 'session-memory.mjs'), cli);
+  if (target === 'opencode') {
+    mkdirSync(dirname(configPath), { recursive: true });
+    copyFileSync(join(HERE, 'opencode-memory-plugin.js'), configPath);
+  } else {
+    writeJsonWiring(target, configPath, config);
+  }
+  if (target === 'cursor') {
+    mkdirSync(dirname(assistedRule), { recursive: true });
+    writeFileSync(assistedRule, `---\ndescription: Read rsc local continuation before the first action in a new desktop session.\nalwaysApply: true\n---\n<!-- rsc-memory:managed -->\nOn the first turn of a local desktop session, run \`node .rsc/session-memory.mjs resume\` and read its \`context\` field before acting. Skip this rule for background or cloud agents.\n`);
+  }
+  const paths = memoryManagedPaths(target, cwd);
+  for (const path of paths) exclude(cwd, path);
+  return {
+    mode,
+    reason: target === 'codex' ? 'hook-trust-required' : target === 'cursor' ? 'start-hook-fire-and-forget' : 'wired',
+    paths,
+  };
+}
+
+export function inspectMemoryWiring(target, cwd = process.cwd(), recorded = null, installed = false) {
+  const supportedMode = memoryModeFor(target);
+  if (supportedMode === 'unsupported') return { supportedMode, mode: 'unsupported', status: 'unsupported', reason: 'no-local-lifecycle', missing: [], tracked: [] };
+  const mode = recorded?.mode || 'not-installed';
+  if (mode === 'disabled' || !memoryEnabledForProject(cwd)) {
+    return { supportedMode, mode: 'disabled', status: 'disabled', reason: 'project-disabled', missing: [], tracked: [] };
+  }
+  // A capability that has never been installed is absent, not broken. Keep the
+  // degraded state for pre-memory installs so `sync` can repair those projects.
+  if (!recorded && !installed) {
+    return { supportedMode, mode, status: 'not-installed', reason: 'not-wired', missing: [], tracked: [] };
+  }
+  const paths = recorded?.paths?.length ? recorded.paths : memoryManagedPaths(target, cwd);
+  const configPath = join(cwd, ...CONFIG[target].split('/'));
+  const cursorRule = join(cwd, '.cursor', 'rules', 'rsc-memory.mdc');
+  const missing = paths.filter((path) => {
+    if (!existsSync(path)) return true;
+    if (path === configPath) {
+      const body = readFileSync(path, 'utf8').replaceAll('\\', '/');
+      return target === 'opencode' ? !body.includes(PLUGIN_MARKER) : !body.includes(NEEDLE);
+    }
+    if (target === 'cursor' && path === cursorRule) return !readFileSync(path, 'utf8').includes(PLUGIN_MARKER);
+    return false;
+  });
+  const trackedPaths = paths.filter((path) => tracked(cwd, path));
+  const status = mode === 'degraded' || mode === 'not-installed' || missing.length || trackedPaths.length ? 'degraded' : 'ready';
+  return {
+    supportedMode,
+    mode,
+    status,
+    reason: mode === 'degraded' ? (recorded?.reason || 'adapter-degraded')
+      : trackedPaths.length ? 'memory-path-tracked'
+        : missing.length ? 'memory-path-missing'
+          : recorded?.reason || 'wired',
+    missing,
+    tracked: trackedPaths,
+    action: status === 'degraded' ? 'Run `npx @ericrisco/rsc sync`; if a config is tracked, move memory hooks to an untracked local config first.' : null,
+    trustRequired: target === 'codex' && status === 'ready',
+  };
+}
+
+export function unwireMemory(target, cwd = process.cwd()) {
+  if (!MEMORY_TARGETS[target]) return [];
+  const path = join(cwd, ...CONFIG[target].split('/'));
+  const touched = [];
+  if (target === 'opencode') {
+    if (existsSync(path) && readFileSync(path, 'utf8').includes(PLUGIN_MARKER)) { rmSync(path, { force: true }); touched.push(path); }
+  } else {
+    const raw = existsSync(path) ? readFileSync(path, 'utf8') : '';
+    const config = raw.replaceAll('\\\\', '/').includes(NEEDLE) ? readConfig(path) : null;
+    if (config) { stripManaged(config); writeFileSync(path, `${JSON.stringify(config, null, 2)}\n`); touched.push(path); }
+  }
+  if (target === 'cursor') {
+    const rule = join(cwd, '.cursor', 'rules', 'rsc-memory.mdc');
+    if (existsSync(rule) && readFileSync(rule, 'utf8').includes('rsc-memory:managed')) { rmSync(rule, { force: true }); touched.push(rule); }
+  }
+  return touched;
+}
+
+export function memoryArtifactsPresent(target, cwd = process.cwd()) {
+  if (!MEMORY_TARGETS[target]) return [];
+  const out = commonPaths(cwd).filter(existsSync);
+  const config = join(cwd, ...CONFIG[target].split('/'));
+  if (existsSync(config)) {
+    const body = readFileSync(config, 'utf8').replaceAll('\\\\', '/');
+    if (body.includes(NEEDLE) || body.includes(PLUGIN_MARKER)) out.push(config);
+  }
+  if (target === 'cursor') {
+    const rule = join(cwd, '.cursor', 'rules', 'rsc-memory.mdc');
+    if (existsSync(rule) && readFileSync(rule, 'utf8').includes('rsc-memory:managed')) out.push(rule);
+  }
+  return out;
+}

package/targets/opencode-memory-plugin.js

@@ -0,0 +1,65 @@
+// rsc-memory:managed
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { capture, resume } from '../../.rsc/session-memory-core.mjs';
+
+function memorySettings(cwd) {
+  try {
+    const value = JSON.parse(readFileSync(join(cwd, '.rsc.json'), 'utf8')).memory;
+    if (value === false) return { enabled: false };
+    return value && typeof value === 'object' ? value : {};
+  } catch {
+    return {};
+  }
+}
+
+function sessionId(input) {
+  return input?.sessionID || input?.session_id || input?.event?.properties?.info?.id
+    || input?.event?.properties?.sessionID || null;
+}
+
+export const RscMemoryPlugin = async ({ directory, worktree }) => {
+  const cwd = worktree || directory;
+  const injected = new Set();
+  const local = () => process.env.RSC_REMOTE_AGENT !== '1' && process.env.OPENCODE_REMOTE !== '1';
+  const save = (id, event, editDelta = 0) => {
+    if (!id || !local()) return;
+    try { capture({ cwd, sessionId: id, target: 'opencode', event, editDelta, settings: memorySettings(cwd) }); } catch { /* fail open */ }
+  };
+
+  return {
+    'experimental.chat.system.transform': async (input, output) => {
+      const id = sessionId(input);
+      if (!id || injected.has(id) || !local()) return;
+      injected.add(id);
+      try {
+        const config = memorySettings(cwd);
+        save(id, 'start');
+        const result = resume({ cwd, target: 'opencode', settings: config });
+        if (!result.context || !Array.isArray(output?.system)) return;
+        if (output.system.length === 0) output.system.push(result.context);
+        else output.system[0] = `${output.system[0]}\n\n${result.context}`;
+      } catch { /* fail open */ }
+    },
+    'tool.execute.after': async (input) => {
+      const tool = String(input?.tool || '').toLowerCase();
+      save(sessionId(input), 'boundary', /write|edit|patch/u.test(tool) ? 1 : 0);
+    },
+    'experimental.session.compacting': async (input, output) => {
+      const id = sessionId(input);
+      save(id, 'compact');
+      try {
+        const result = resume({ cwd, target: 'opencode', settings: memorySettings(cwd) });
+        if (result.context && Array.isArray(output?.context)) output.context.push(result.context);
+      } catch { /* fail open */ }
+    },
+    event: async ({ event }) => {
+      const id = sessionId({ event });
+      if (event?.type === 'session.created') save(id, 'start');
+      else if (event?.type === 'file.edited') save(id, 'edit', 1);
+      else if (event?.type === 'session.compacted') save(id, 'compact');
+      else if (event?.type === 'session.idle') save(id, 'turn');
+      else if (event?.type === 'session.deleted') save(id, 'sessionEnd');
+    },
+  };
+};

package/targets/session-memory-adapter.mjs

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve, join } from 'node:path';
+import { capture, resume } from './session-memory-core.mjs';
+
+const LOCAL_TARGETS = new Set(['claude', 'codex', 'cursor', 'gemini', 'opencode']);
+
+function projectSettings(cwd) {
+  try {
+    const manifest = JSON.parse(readFileSync(join(cwd, '.rsc.json'), 'utf8'));
+    if (manifest.memory === false) return { enabled: false };
+    return manifest.memory && typeof manifest.memory === 'object' ? manifest.memory : {};
+  } catch {
+    return {};
+  }
+}
+
+function sessionId(native, target) {
+  return native?.session_id || native?.sessionId || native?.sessionID || native?.conversation_id
+    || native?.thread_id || `${target}-${process.ppid}`;
+}
+
+function isRemote(target, native) {
+  if (target === 'cursor' && (native?.is_background_agent === true || native?.isBackgroundAgent === true)) return true;
+  return process.env.RSC_REMOTE_AGENT === '1'
+    || process.env.CURSOR_CLOUD_AGENT === '1'
+    || process.env.CODEX_CLOUD_AGENT === '1';
+}
+
+function hookEventName(target, event, native) {
+  if (native?.hook_event_name) return native.hook_event_name;
+  const names = {
+    start: target === 'cursor' ? 'sessionStart' : 'SessionStart',
+    request: target === 'gemini' ? 'BeforeAgent' : 'UserPromptSubmit',
+    edit: target === 'cursor' ? 'afterFileEdit' : target === 'gemini' ? 'AfterTool' : 'PostToolUse',
+    boundary: target === 'cursor' ? 'afterShellExecution' : target === 'gemini' ? 'AfterTool' : 'PostToolUse',
+    turn: target === 'cursor' ? 'afterAgentResponse' : target === 'gemini' ? 'AfterAgent' : 'Stop',
+    compact: target === 'cursor' ? 'preCompact' : target === 'gemini' ? 'PreCompress' : 'PreCompact',
+    end: target === 'cursor' ? 'sessionEnd' : 'SessionEnd',
+  };
+  return names[event] || event;
+}
+
+function nativeOutput(target, eventName, context = '', notice = null, compactionHint = false) {
+  const hint = compactionHint ? 'rsc memory: consider compacting at the next phase boundary; nothing was compacted automatically.' : '';
+  const extra = [context, hint].filter(Boolean).join('\n');
+  if (!extra && !notice) return {};
+  if (target === 'cursor') return { ...(extra ? { additional_context: extra } : {}), ...(notice ? { user_message: notice } : {}) };
+  if (target === 'opencode') return { context: extra, notice };
+  return {
+    ...(notice ? { systemMessage: notice } : {}),
+    ...(extra ? { hookSpecificOutput: { hookEventName: eventName, additionalContext: extra } } : {}),
+  };
+}
+
+export function contextFromNativeOutput(target, output = {}) {
+  if (target === 'cursor') return output.additional_context || '';
+  if (target === 'opencode') return output.context || '';
+  return output.hookSpecificOutput?.additionalContext || '';
+}
+
+export function handleLifecycle({ target, event, native = {}, cwd, settings } = {}) {
+  try {
+    if (!LOCAL_TARGETS.has(target)) throw new Error(`unsupported memory target: ${target}`);
+    if (isRemote(target, native)) return { output: {}, capture: null, remote: true, degraded: false };
+    const project = resolve(cwd || native.cwd || process.env.RSC_PROJECT_CWD || process.cwd());
+    if (!existsSync(project)) throw new Error('project directory unavailable');
+    const config = settings || projectSettings(project);
+    if (config.enabled === false) return { output: {}, capture: null, remote: false, degraded: false };
+    const id = sessionId(native, target);
+    const eventName = hookEventName(target, event, native);
+    if (event === 'start') {
+      const started = capture({ cwd: project, sessionId: id, target, event: 'start', settings: config });
+      const resumed = resume({ cwd: project, target, settings: config });
+      return {
+        output: nativeOutput(target, eventName, resumed.context),
+        capture: started,
+        resume: resumed,
+        remote: false,
+        degraded: false,
+      };
+    }
+    const captureInput = {
+      cwd: project,
+      sessionId: id,
+      target,
+      event: event === 'end' ? 'sessionEnd' : event,
+      editDelta: event === 'edit' ? 1 : 0,
+      settings: config,
+    };
+    if (typeof native.cost === 'number') captureInput.cost = native.cost;
+    if (Number.isInteger(native.tool_calls)) captureInput.toolCalls = native.tool_calls;
+    const captured = capture(captureInput);
+    return {
+      output: nativeOutput(target, eventName, '', captured.notice, captured.compactionHint),
+      capture: captured,
+      remote: false,
+      degraded: false,
+    };
+  } catch (error) {
+    return { output: {}, capture: null, remote: false, degraded: true, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+function stdinJson() {
+  try {
+    const raw = readFileSync(0, 'utf8');
+    return raw.trim() ? JSON.parse(raw) : {};
+  } catch {
+    return {};
+  }
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const result = handleLifecycle({ target: process.argv[2], event: process.argv[3], native: stdinJson() });
+  process.stdout.write(`${JSON.stringify(result.output)}\n`);
+}