@ericrisco/rsc 3.0.1 → 3.0.3

package/README.md

@@ -75,6 +75,27 @@ rsc 3.0 fixes all four, by default, with no new commands to learn:
 | **The agent picks the method** | A simple change takes Fast-Track (one document, proof for every task). Something big or complex takes the spec-driven chain. The agent decides and says why. You still approve *what* gets built: the spec and the clarifications, then step by step or autopilot. | Ask for the other lane |
 | **Knowledge reaches everyone** | `01-TOOLS/` and `02-DOCS/` travel through one exchange branch, `rsc/knowledge`. They go up when your turn ends and come down into whatever branch each person is on. They reach `main` inside your normal pull requests. | `rsc knowledge-sync off` |
 
+**Commit, push and pull request without a prompt each time.** A harness installed from scratch lets
+the agent run `git commit`, `git push` and `gh pr create` without asking, because those are the steps
+that close every lane. A force-push still asks. The guards still decide: a commit on a closed `main` is
+refused whatever the permission says. It is a project decision, saved as `gitPermissions` in
+`.rsc.json`. A clone gets the same setting. A project adopted before this is left as it was until
+someone runs `rsc git-permissions on`.
+
+| Assistant | Where it goes |
+| --- | --- |
+| Claude Code | `.claude/settings.json` → `permissions.allow` (force-push under `ask`). Claude Code applies it once the folder is trusted. |
+| Codex | `.codex/rules/rsc-git.rules` (`prefix_rule`; force-push → `prompt`). Loaded when the project is trusted. |
+| Gemini | `.gemini/settings.json` → `tools.allowed` |
+| OpenCode | `opencode.json` → `permission.bash` (force-push → `ask`) |
+| Cursor | Not covered: its CLI matches only the first word, so allowing a push would allow every git command. |
+
+```bash
+rsc git-permissions status   # decided or not, and wired per assistant
+rsc git-permissions off      # ask again for commit, push and PR (saved in .rsc.json)
+rsc git-permissions on       # turn it on, also for a project adopted before
+```
+
 **How does it know a project is "complex or in production"?** There are two layers. A hook counts
 what anyone can check: a CI setup, a deployment file (`Dockerfile`, `vercel.json`, `fly.toml`…) or
 at least two people in the last 50 commits. If any of those is there, a commit on the default branch

package/manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.0.1",
+  "version": "3.0.3",
   "counts": {
     "skills": 270,
     "agents": 33,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ericrisco/rsc",
-  "version": "3.0.1",
+  "version": "3.0.3",
   "description": "A guided harness builder that turns your goal into a minimal, verified AI-agent setup using strict best practices.",
   "type": "module",
   "bin": {

package/scripts/doctor.js

@@ -256,16 +256,38 @@ export function doctor({ target, home, cwd }) {
     missingCommands,
     commandOrphans,
     commandCollisions: state.commandCollisions || [],
+    // #289 — OpenCode 2.x only loads a plugin from a default export with an id and setup(ctx); the
+    // V1-only files older versions wrote fail to load and nothing on rsc's side noticed. A plugin
+    // without the V2 entry point is a problem, and `sync` rewrites it.
+    opencodePluginsOutdated: target === 'opencode' ? opencodePluginsOutdated(root) : [],
   };
   // #277 — the three "missing" lists share one shape, { id, path, action }, so whoever builds on top
   // of doctor reads them the same way; and `healthy` is what the exit code says.
   for (const [id, e] of Object.entries(state.skills)) {
     for (const f of e.files) if (!existsSync(f)) report.missing.push({ id, path: f, action: 'Run `npx @ericrisco/rsc sync` to restore this managed skill.' });
   }
-  report.healthy = report.hookWired && !report.missing.length && !missingAgents.length && !missingCommands.length;
+  report.healthy = report.hookWired && !report.missing.length && !missingAgents.length && !missingCommands.length
+    && !report.opencodePluginsOutdated.length;
   return report;
 }
 
+/** rsc's OpenCode plugins that OpenCode 2.x cannot load (no default export with id + setup). */
+export function opencodePluginsOutdated(root) {
+  const dir = join(root, '.opencode', 'plugins');
+  const out = [];
+  for (const name of ['rsc-update.js', 'rsc-knowledge.js', 'rsc-memory.js']) {
+    const path = join(dir, name);
+    if (!existsSync(path)) continue;
+    let body = '';
+    try { body = readFileSync(path, 'utf8'); } catch { continue; }
+    if (!/:managed/.test(body)) continue; // hand-written: not ours to judge
+    if (!/export default\s*\{/.test(body) || !/\bsetup\s*\(/.test(body)) {
+      out.push({ path, action: 'OpenCode 2.x cannot load this plugin (V1 API only). Run `npx @ericrisco/rsc@latest sync` to rewrite it.' });
+    }
+  }
+  return out;
+}
+
 // ---------------------------------------------------------------------------------------
 // Context budget — what the harness costs in tokens before the user has typed anything.
 //

package/scripts/install-apply.js

@@ -24,6 +24,7 @@ import {
 } from '../targets/memory.js';
 import { wireUpdate, unwireUpdate, updateManagedPaths, updateArtifactsPresent } from '../targets/update-wiring.js';
 import { wireKnowledge, unwireKnowledge, knowledgeManagedPaths, knowledgeArtifactsPresent } from '../targets/knowledge-wiring.js';
+import { wireGitPermissions, unwireGitPermissions, gitPermissionsPath } from '../targets/git-permissions.js';
 
 const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
 const CLI_VERSION = JSON.parse(readFileSync(join(ROOT, 'package.json'), 'utf8')).version;
@@ -104,6 +105,7 @@ export function managedPathsForInstall({ skillIds, agentIds = [], target, home,
   if (policy?.memory !== false) out.push(...memoryManagedPaths(target, cwd));
   out.push(...updateManagedPaths(target, cwd));
   out.push(...knowledgeManagedPaths(target, cwd));
+  if (gitPermissionsPath(target, cwd)) out.push(gitPermissionsPath(target, cwd)); // backed up before it is merged into
   if (targetHasAgents(target)) {
     const state = readState(paths.stateFile);
     const explicit = [...new Set([...(state.explicitAgents || readManifest(cwd)?.agents || []), ...agentIds])];
@@ -196,7 +198,7 @@ export function hydrateLocalDecisions(cwd, manifest) {
 // 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, agentIds = [], catalogVersion = CLI_VERSION, dropTarget, onboarding }) {
+export function recordInManifest({ cwd, target, skillIds, agentIds = [], catalogVersion = CLI_VERSION, dropTarget, onboarding, gitPermissions }) {
   const prev = readManifest(cwd) || { targets: [], skills: [], agents: [], ownSkills: [], optOuts: [] };
   const { optOuts, tier } = localDecisions(cwd);
   const union = (a, b) => [...new Set([...(a || []), ...(b || [])])].sort();
@@ -215,6 +217,7 @@ export function recordInManifest({ cwd, target, skillIds, agentIds = [], catalog
     tier: tier ?? prev.tier ?? null,
     optOuts: optOuts ?? projectOptOuts(prev.optOuts),
     memory: prev.memory,
+    gitPermissions: gitPermissions ?? prev.gitPermissions,
     onboarding: onboarding ?? prev.onboarding,
   });
 }
@@ -225,6 +228,11 @@ export async function applyInstall({ skillIds = [], agentIds = [], target, home,
   // declaration is the only thing that knows what the team decided) from a built machine (the
   // local markers are the authority, and a pull must not overwrite them).
   const fromScratch = !existsSync(join(cwd, '.rsc'));
+  // Git permissions are on for a project adopted from scratch (no manifest yet); an older project
+  // keeps what it declared, and absent means "never decided": nothing is added or removed there.
+  const declaredGit = readManifest(cwd)?.gitPermissions;
+  const newProject = !existsSync(join(cwd, '.rsc.json'));
+  const gitPermissions = newProject ? true : declaredGit;
   const paths = targetPaths(target, home, cwd);
   const plan = planInstall({ skillIds, target, home, cwd, hooks: policy?.alwaysOn !== false });
   // What this pass prunes, decided BEFORE the backup so the backup holds it: a skill link this
@@ -312,6 +320,8 @@ export async function applyInstall({ skillIds = [], agentIds = [], target, home,
   // the memory, so the memory's policy does not decide it: wired wherever the assistant can run it.
   const knowledgeResult = wireKnowledge(target, cwd);
   state.knowledge = { mode: knowledgeResult.mode, reason: knowledgeResult.reason || null, paths: knowledgeResult.paths };
+  if (gitPermissions === true) state.gitPermissions = wireGitPermissions(target, cwd);
+  else if (gitPermissions === false) { unwireGitPermissions(target, cwd); state.gitPermissions = { mode: 'off' }; }
   const context7OptOut = join(cwd, '.rsc', '.no-context7');
   if (policy?.context7 === false) {
     mkdirSync(dirname(context7OptOut), { recursive: true });
@@ -339,7 +349,7 @@ export async function applyInstall({ skillIds = [], agentIds = [], target, home,
   writeState(paths.stateFile, state);
   mkdirSync(dirname(versionFile(cwd)), { recursive: true });
   writeFileSync(versionFile(cwd), CLI_VERSION + '\n');
-  recordInManifest({ cwd, target, skillIds, agentIds, onboarding });
+  recordInManifest({ cwd, target, skillIds, agentIds, onboarding, gitPermissions });
   // The worktree cleanup's trigger. It lives in `.git/hooks/`, which is NOT cloned, so it has to be
   // (re)written by every operation that touches a user's repo — install, sync and repair all land
   // here. Target-agnostic on purpose: it is a git hook, not an assistant hook, and a cleanup that
@@ -613,6 +623,7 @@ export function removeTargetInstall({ target, home, cwd = process.cwd() }) {
   unwireMemory(target, cwd);
   unwireUpdate(target, cwd);
   unwireKnowledge(target, cwd);
+  unwireGitPermissions(target, cwd);
   rmSync(paths.stateFile, { force: true });
   const gitignore = join(cwd, '.gitignore');
   if (existsSync(gitignore)) {
@@ -723,6 +734,7 @@ export async function purge({ home, cwd = process.cwd(), withDocs = false, dryRu
       removed.push(...unwireMemory(target, cwd));
       removed.push(...unwireUpdate(target, cwd));
       removed.push(...unwireKnowledge(target, cwd));
+      removed.push(...unwireGitPermissions(target, cwd));
     } else {
       removed.push(...memoryArtifactsPresent(target, cwd));
       removed.push(...updateArtifactsPresent(target, cwd));

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', 'agents', 'ownSkills', 'catalogVersion', 'tier', 'optOuts', 'memory', 'onboarding'];
+const KEYS = ['version', 'targets', 'skills', 'agents', 'ownSkills', 'catalogVersion', 'tier', 'optOuts', 'memory', 'gitPermissions', 'onboarding'];
 
 export function readManifest(cwd = process.cwd()) {
   const file = manifestPath(cwd);
@@ -38,6 +38,8 @@ export function readManifest(cwd = process.cwd()) {
     tier: raw.tier ?? null,
     optOuts: raw.optOuts || [],
     memory: raw.memory ?? undefined,
+    // true on a project installed from scratch since 3.0.3; absent on older ones; false once turned off.
+    gitPermissions: typeof raw.gitPermissions === 'boolean' ? raw.gitPermissions : undefined,
     onboarding: raw.onboarding ?? undefined,
   };
 }

package/scripts/rsc.js

@@ -44,7 +44,7 @@ if (['--version', '-v', 'version'].includes(rawArgv[0])) {
 const GLOBAL_VALUE_FLAGS = new Set([
   '--target', '--technical-level', '--accompaniment', '--project-kind', '--goal', '--goal-base64', '--software-scope', '--accept-plan',
 ]);
-const COMMANDS = new Set(['onboard', 'reassess', 'add', 'install', 'consult', 'catalog', 'audit', 'list', 'doctor', 'memory', 'knowledge-sync', 'main', 'isolation', 'sync', 'backups', 'restore', 'upgrade', 'registry', 'worktrees', 'capabilities', 'sello', 'repair', 'uninstall', 'purge']);
+const COMMANDS = new Set(['onboard', 'reassess', 'add', 'install', 'consult', 'catalog', 'audit', 'list', 'doctor', 'memory', 'knowledge-sync', 'git-permissions', 'main', 'isolation', 'sync', 'backups', 'restore', 'upgrade', 'registry', 'worktrees', 'capabilities', 'sello', 'repair', 'uninstall', 'purge']);
 function positionalTokens(input) {
   const out = [];
   for (let i = 0; i < input.length; i++) {
@@ -832,6 +832,36 @@ async function main() {
       process.exitCode = 2;
       return;
     }
+    case 'git-permissions': {
+      // On for a project installed from scratch: the agent commits, pushes and opens the PR without a
+      // prompt each time (a force-push still asks; the guards still apply). A PROJECT decision, saved as
+      // `gitPermissions` in `.rsc.json` so a clone gets the same; an older project starts undecided.
+      const sub = argv[1] || 'status';
+      const root = process.cwd();
+      const { readManifest, writeManifest } = await import('./lib/manifest-file.js');
+      const { gitPermissionsWired, GIT_PERMISSION_TARGETS } = await import('../targets/git-permissions.js');
+      if (sub === 'on' || sub === 'off') {
+        const current = readManifest(root);
+        if (!current) { say('No .rsc.json here: install the harness first (`npx @ericrisco/rsc onboard`).'); process.exitCode = 2; return; }
+        writeManifest(root, { ...current, gitPermissions: sub === 'on' });
+        for (const t of targets) await syncInstalled({ target: t, cwd: root });
+        say(sub === 'on'
+          ? 'rsc git-permissions on: the agent may git commit, git push and gh pr create without asking (a force-push still asks; Cursor is not covered). Commit .rsc.json so the team gets the same decision.'
+          : 'rsc git-permissions off: commit, push and PR ask again, as the assistant does by default. Commit .rsc.json so the team gets the same decision.');
+        return;
+      }
+      if (sub === 'status') {
+        const declared = readManifest(root)?.gitPermissions;
+        return void say(JSON.stringify({
+          declared: declared === undefined ? 'undecided' : declared,
+          wired: Object.fromEntries(targets.filter((t) => GIT_PERMISSION_TARGETS.includes(t)).map((t) => [t, gitPermissionsWired(t, root)])),
+          notCovered: targets.filter((t) => !GIT_PERMISSION_TARGETS.includes(t)),
+        }, null, 2));
+      }
+      say('Use: npx @ericrisco/rsc git-permissions on|off|status');
+      process.exitCode = 2;
+      return;
+    }
     case 'memory': {
       const sub = argv[1] || 'status';
       const root = process.cwd();

package/targets/git-permissions.js

@@ -0,0 +1,151 @@
+// Git permissions: on a harness installed from scratch, the agent may `git commit`, `git push` and
+// `gh pr create` without asking — the three steps that close every lane (branch → commit → push →
+// PR). A force-push still asks wherever the assistant can say so. The guards are untouched: a commit
+// on a closed default branch is still denied by branch-guard, whatever the permission says.
+//
+// A PROJECT decision, recorded as `gitPermissions` in `.rsc.json`: true on a brand-new project, absent
+// on one adopted before this existed (nothing changes there until `rsc git-permissions on`), false
+// after `rsc git-permissions off`. Only rsc's own entries are ever added or removed; whatever the
+// person allowed or denied stays exactly as it was.
+//
+// Cursor is left out on purpose: its CLI matches only the first word (`Shell(git)`), so allowing a
+// push there would allow every git and gh command, `reset --hard` and `repo delete` included.
+import { appendFileSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+
+export const GIT_PERMISSION_TARGETS = Object.freeze(['claude', 'codex', 'gemini', 'opencode']);
+
+const CLAUDE_ALLOW = ['Bash(git commit *)', 'Bash(git push *)', 'Bash(gh pr create *)'];
+// `ask` beats `allow` in Claude Code, and applies to any subcommand of a chain.
+const CLAUDE_ASK = ['Bash(git push --force*)', 'Bash(git push -f*)', 'Bash(git push * --force*)', 'Bash(git push * -f*)'];
+const GEMINI_ALLOW = ['run_shell_command(git commit)', 'run_shell_command(git push)', 'run_shell_command(gh pr create)'];
+// OpenCode: the last matching rule wins, so the force-push asks come after the allows.
+const OPENCODE_BASH = [
+  ['git commit', 'allow'], ['git commit *', 'allow'], ['git push', 'allow'], ['git push *', 'allow'], ['gh pr create *', 'allow'],
+  ['git push --force*', 'ask'], ['git push -f*', 'ask'], ['git push * --force*', 'ask'], ['git push * -f*', 'ask'],
+];
+const CODEX_RULES = `# rsc-git-permissions:managed — written by rsc; \`rsc git-permissions off\` removes it.
+# Commit, push and open a PR without asking; a force-push still asks (the strictest match wins).
+prefix_rule(pattern = ["git", "commit"], decision = "allow", justification = "rsc: close the lane — commit")
+prefix_rule(pattern = ["git", "push"], decision = "allow", justification = "rsc: close the lane — push the branch")
+prefix_rule(pattern = ["gh", "pr", "create"], decision = "allow", justification = "rsc: close the lane — open the PR")
+prefix_rule(pattern = ["git", "push", ["--force", "-f", "--force-with-lease"]], decision = "prompt", justification = "rsc: a force-push rewrites the remote")
+`;
+
+const FILES = Object.freeze({
+  claude: '.claude/settings.json',
+  codex: '.codex/rules/rsc-git.rules',
+  gemini: '.gemini/settings.json',
+  opencode: 'opencode.json',
+});
+
+const git = (cwd, args) => {
+  try { return execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim(); } catch { return null; }
+};
+const rel = (cwd, path) => relative(cwd, path).split(sep).join('/');
+
+/** A file rsc created is kept out of git with the local exclude; one the project tracks is merged into, never hidden. */
+function excludeIfNew(cwd, path) {
+  if (git(cwd, ['rev-parse', '--is-inside-work-tree']) !== 'true') return;
+  if (git(cwd, ['ls-files', '--', rel(cwd, path)])) 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 readJson(path) {
+  if (!existsSync(path)) return {};
+  try {
+    const value = JSON.parse(readFileSync(path, 'utf8'));
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
+  } catch { return null; }
+}
+
+const writeJson = (path, value) => { mkdirSync(dirname(path), { recursive: true }); writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`); };
+const addAll = (list, items) => [...(Array.isArray(list) ? list : []), ...items.filter((i) => !(list || []).includes(i))];
+const dropAll = (list, items) => (Array.isArray(list) ? list.filter((i) => !items.includes(i)) : list);
+
+export function gitPermissionsPath(target, cwd = process.cwd()) {
+  return FILES[target] ? join(cwd, ...FILES[target].split('/')) : null;
+}
+
+/** Add rsc's entries. `{ mode: 'wired' | 'unsupported' | 'config-invalid', path }`. */
+export function wireGitPermissions(target, cwd = process.cwd()) {
+  const path = gitPermissionsPath(target, cwd);
+  if (!path) return { mode: 'unsupported', path: null };
+  if (target === 'codex') {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, CODEX_RULES);
+    excludeIfNew(cwd, path);
+    return { mode: 'wired', path };
+  }
+  const existed = existsSync(path);
+  const config = readJson(path);
+  if (!config) return { mode: 'config-invalid', path }; // never overwrite a file we cannot read
+  if (target === 'claude') {
+    config.permissions ||= {};
+    config.permissions.allow = addAll(config.permissions.allow, CLAUDE_ALLOW);
+    config.permissions.ask = addAll(config.permissions.ask, CLAUDE_ASK);
+  } else if (target === 'gemini') {
+    config.tools ||= {};
+    config.tools.allowed = addAll(config.tools.allowed, GEMINI_ALLOW);
+  } else if (target === 'opencode') {
+    config.permission ||= {};
+    if (typeof config.permission.bash === 'string') return { mode: 'config-invalid', path }; // a blanket rule is the person's call
+    const bash = config.permission.bash && typeof config.permission.bash === 'object' ? config.permission.bash : {};
+    // Re-inserted so the asks stay after the allows (OpenCode: the last matching rule wins).
+    for (const [pattern] of OPENCODE_BASH) delete bash[pattern];
+    for (const [pattern, action] of OPENCODE_BASH) bash[pattern] = action;
+    config.permission.bash = bash;
+    config.$schema ||= 'https://opencode.ai/config.json';
+  }
+  writeJson(path, config);
+  if (!existed && target !== 'claude') excludeIfNew(cwd, path);
+  return { mode: 'wired', path };
+}
+
+/** Remove rsc's entries, and nothing else. Returns the paths it touched. */
+export function unwireGitPermissions(target, cwd = process.cwd()) {
+  const path = gitPermissionsPath(target, cwd);
+  if (!path || !existsSync(path)) return [];
+  if (target === 'codex') {
+    if (!readFileSync(path, 'utf8').includes('rsc-git-permissions:managed')) return [];
+    rmSync(path, { force: true });
+    return [path];
+  }
+  const config = readJson(path);
+  if (!config) return [];
+  if (target === 'claude' && config.permissions) {
+    config.permissions.allow = dropAll(config.permissions.allow, CLAUDE_ALLOW);
+    config.permissions.ask = dropAll(config.permissions.ask, CLAUDE_ASK);
+    for (const k of ['allow', 'ask']) if (Array.isArray(config.permissions[k]) && !config.permissions[k].length) delete config.permissions[k];
+    if (!Object.keys(config.permissions).length) delete config.permissions;
+  } else if (target === 'gemini' && config.tools) {
+    config.tools.allowed = dropAll(config.tools.allowed, GEMINI_ALLOW);
+    if (Array.isArray(config.tools.allowed) && !config.tools.allowed.length) delete config.tools.allowed;
+    if (!Object.keys(config.tools).length) delete config.tools;
+  } else if (target === 'opencode' && config.permission?.bash && typeof config.permission.bash === 'object') {
+    for (const [pattern, action] of OPENCODE_BASH) if (config.permission.bash[pattern] === action) delete config.permission.bash[pattern];
+    if (!Object.keys(config.permission.bash).length) delete config.permission.bash;
+    if (!Object.keys(config.permission).length) delete config.permission;
+  } else return [];
+  writeJson(path, config);
+  return [path];
+}
+
+/** Whether rsc's entries are all there, for `status` and `doctor`. */
+export function gitPermissionsWired(target, cwd = process.cwd()) {
+  const path = gitPermissionsPath(target, cwd);
+  if (!path || !existsSync(path)) return false;
+  if (target === 'codex') return readFileSync(path, 'utf8').includes('rsc-git-permissions:managed');
+  const config = readJson(path) || {};
+  if (target === 'claude') return CLAUDE_ALLOW.every((r) => config.permissions?.allow?.includes(r));
+  if (target === 'gemini') return GEMINI_ALLOW.every((r) => config.tools?.allowed?.includes(r));
+  if (target === 'opencode') return OPENCODE_BASH.every(([p, a]) => config.permission?.bash?.[p] === a);
+  return false;
+}

package/targets/knowledge-wiring.js

@@ -83,24 +83,48 @@ const PLUGIN = `// ${PLUGIN_MARKER}
 // rsc knowledge sync for OpenCode. OpenCode has no prompt event and no channel to the person, so what
 // sync has to say goes to the model, to be relayed. Cheap on every call: the fetch is throttled and
 // every notice is said once. Turn it off with \`rsc knowledge-sync off\`.
+// One file for both plugin APIs (issue #289): V1 calls the named export or server(); V2 reads id + setup.
 import { onRequest, onTurn } from '../../.rsc/knowledge-sync.mjs';
 
+const local = () => process.env.RSC_REMOTE_AGENT !== '1' && process.env.OPENCODE_REMOTE !== '1';
+const tell = (cwd) => {
+  if (!local()) return '';
+  try { const said = onRequest(cwd); return said ? \`Cuéntale esto al usuario en una línea:\\n\${said}\` : ''; } catch { return ''; }
+};
+const turn = (cwd) => { if (local()) { try { onTurn(cwd); } catch { /* fail open */ } } };
+
 export const RscKnowledgePlugin = async ({ directory, worktree }) => {
   const cwd = worktree || directory;
-  const local = () => process.env.RSC_REMOTE_AGENT !== '1' && process.env.OPENCODE_REMOTE !== '1';
   return {
     'experimental.chat.system.transform': async (_input, output) => {
-      if (!local()) return;
-      try {
-        const said = onRequest(cwd);
-        if (said && Array.isArray(output?.system)) output.system.push(\`Cuéntale esto al usuario en una línea:\\n\${said}\`);
-      } catch { /* fail open */ }
-    },
-    event: async ({ event }) => {
-      if (event?.type === 'session.idle' && local()) { try { onTurn(cwd); } catch { /* fail open */ } }
+      const text = tell(cwd);
+      if (text && Array.isArray(output?.system)) output.system.push(text);
     },
+    event: async ({ event }) => { if (event?.type === 'session.idle') turn(cwd); },
   };
 };
+
+// V2 has no session.idle: a turn ends with session.execution.succeeded (or .failed).
+export default {
+  id: 'rsc.knowledge',
+  server: RscKnowledgePlugin,
+  async setup(ctx) {
+    const cwd = ctx.location?.project?.directory || ctx.location?.directory || process.cwd();
+    await ctx.session.hook('context', async (event) => {
+      const text = tell(cwd);
+      if (text && Array.isArray(event?.system)) event.system.push({ type: 'text', text });
+    });
+    const stop = new AbortController();
+    (async () => {
+      try {
+        for await (const event of ctx.event.subscribe({ signal: stop.signal })) {
+          if (event?.type === 'session.execution.succeeded' || event?.type === 'session.execution.failed') turn(cwd);
+        }
+      } catch { /* unloading, or the stream ended: fail open */ }
+    })();
+    return () => stop.abort();
+  },
+};
 `;
 
 export function knowledgeManagedPaths(target, cwd = process.cwd()) {

package/targets/opencode-memory-plugin.js

@@ -1,4 +1,6 @@
 // rsc-memory:managed
+// One file for both OpenCode plugin APIs (issue #289). V1 (1.x) calls the named export, or the default
+// export's server(); V2 (2.x) reads the default export's id + setup(ctx) and ignores the rest.
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { capture, resume } from '../../.rsc/session-memory-core.mjs';
@@ -15,51 +17,94 @@ function memorySettings(cwd) {
 
 function sessionId(input) {
   return input?.sessionID || input?.session_id || input?.event?.properties?.info?.id
-    || input?.event?.properties?.sessionID || null;
+    || input?.event?.properties?.sessionID || input?.event?.data?.sessionID || null;
 }
 
-export const RscMemoryPlugin = async ({ directory, worktree }) => {
-  const cwd = worktree || directory;
+/** What the plugin does, whichever API delivers the moment. `put(text)` adds to the system prompt. */
+function memory(cwd) {
   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);
+    save,
+    context(id, put) {
       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}`;
+        const result = resume({ cwd, target: 'opencode', settings: memorySettings(cwd) });
+        if (result.context) put(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);
+    tool(id, name) {
+      save(id, 'boundary', /write|edit|patch/u.test(String(name || '').toLowerCase()) ? 1 : 0);
     },
-    'experimental.session.compacting': async (input, output) => {
-      const id = sessionId(input);
+    compact(id, put) {
       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);
+        if (result.context) put(result.context);
       } catch { /* fail open */ }
     },
+  };
+}
+
+// ---------------------------------------------------------------- OpenCode 1.x (V1 plugin API)
+
+export const RscMemoryPlugin = async ({ directory, worktree }) => {
+  const m = memory(worktree || directory);
+  return {
+    'experimental.chat.system.transform': async (input, output) => {
+      if (!Array.isArray(output?.system)) return;
+      m.context(sessionId(input), (text) => {
+        if (output.system.length === 0) output.system.push(text);
+        else output.system[0] = `${output.system[0]}\n\n${text}`;
+      });
+    },
+    'tool.execute.after': async (input) => m.tool(sessionId(input), input?.tool),
+    'experimental.session.compacting': async (input, output) => {
+      m.compact(sessionId(input), (text) => { if (Array.isArray(output?.context)) output.context.push(text); });
+    },
     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');
+      if (event?.type === 'session.created') m.save(id, 'start');
+      else if (event?.type === 'file.edited') m.save(id, 'edit', 1);
+      else if (event?.type === 'session.compacted') m.save(id, 'compact');
+      else if (event?.type === 'session.idle') m.save(id, 'turn');
+      else if (event?.type === 'session.deleted') m.save(id, 'sessionEnd');
     },
   };
 };
+
+// ---------------------------------------------------------------- OpenCode 2.x (V2 plugin API)
+// Hooks register through the context; the end of a turn is `session.execution.*` (there is no
+// `session.idle`), and every event carries its session in `data.sessionID`.
+
+const TURN_END = new Set(['session.execution.succeeded', 'session.execution.failed']);
+
+export default {
+  id: 'rsc.memory',
+  server: RscMemoryPlugin,
+  async setup(ctx) {
+    const m = memory(ctx.location?.project?.directory || ctx.location?.directory || process.cwd());
+    const part = (event) => (text) => { if (Array.isArray(event?.system)) event.system.push({ type: 'text', text }); };
+    await ctx.session.hook('context', async (event) => m.context(event?.sessionID, part(event)));
+    await ctx.session.hook('compaction', async (event) => m.compact(event?.sessionID, part(event)));
+    await ctx.tool.hook('execute.after', async (event) => m.tool(event?.sessionID, event?.tool));
+    const stop = new AbortController();
+    (async () => {
+      try {
+        for await (const event of ctx.event.subscribe({ signal: stop.signal })) {
+          const id = event?.data?.sessionID;
+          if (event?.type === 'session.created') m.save(id, 'start');
+          else if (TURN_END.has(event?.type)) m.save(id, 'turn');
+          else if (event?.type === 'session.deleted') m.save(id, 'sessionEnd');
+        }
+      } catch { /* unloading, or the stream ended: fail open */ }
+    })();
+    return () => stop.abort();
+  },
+};

package/targets/update-wiring.js

@@ -78,19 +78,34 @@ const PLUGIN = `// ${PLUGIN_MARKER}
 // rsc update check for OpenCode: checked once per OpenCode run, and the notice goes to the model to be
 // relayed. It rides on EVERY system prompt of the run, not just the first: OpenCode's first call is
 // its title generator, which would swallow a once-only notice before the agent ever sees it.
+// One file for both plugin APIs (issue #289): V1 calls the named export or server(); V2 reads id + setup.
 // Turn auto-update off with .rsc/.no-auto-update.
 import { updateNotice } from '../../.rsc/auto-update.mjs';
 
+const NOTE = '\\nMention this only in your first reply of the session.';
+const check = (cwd) => (process.env.RSC_NO_UPDATE_CHECK ? Promise.resolve('') : updateNotice(cwd).catch(() => ''));
+
 export const RscUpdatePlugin = async ({ directory, worktree }) => {
-  const cwd = worktree || directory;
-  const pending = process.env.RSC_NO_UPDATE_CHECK ? Promise.resolve('') : updateNotice(cwd).catch(() => '');
+  const pending = check(worktree || directory);
   return {
     'experimental.chat.system.transform': async (_input, output) => {
       const said = (await pending).trim();
-      if (said && Array.isArray(output?.system)) output.system.push(said + '\\nMention this only in your first reply of the session.');
+      if (said && Array.isArray(output?.system)) output.system.push(said + NOTE);
     },
   };
 };
+
+export default {
+  id: 'rsc.update',
+  server: RscUpdatePlugin,
+  async setup(ctx) {
+    const pending = check(ctx.location?.project?.directory || ctx.location?.directory || process.cwd());
+    await ctx.session.hook('context', async (event) => {
+      const said = (await pending).trim();
+      if (said && Array.isArray(event?.system)) event.system.push({ type: 'text', text: said + NOTE });
+    });
+  },
+};
 `;
 
 export function updateManagedPaths(target, cwd = process.cwd()) {