@ericrisco/rsc 3.0.0 → 3.0.2

package/README.md

@@ -442,6 +442,8 @@ new    · clones main    has it all after the first message
 - **When a turn ends**, your changes in those folders are committed as `📝 docs(auto): … [skip ci]`
   and sent to `rsc/knowledge` on `origin`, from whatever branch you are on. If you are on a closed
   `main`, nothing is committed locally: the snapshot is built aside and only goes to `rsc/knowledge`.
+  Knowledge that you or the agent already **committed** on the branch during the turn goes up too —
+  only its `01-TOOLS/` and `02-DOCS/` part, under a `docs(auto) … [skip ci]` message.
 - **Before each message**, what teammates sent is brought into **the branch you are on**, and you are
   told in one line. Only the knowledge folders are touched.
 - **It reaches `main` the normal way.** Your feature branch now carries the team's knowledge, so it
@@ -455,7 +457,7 @@ What it will not do, by design:
 | | |
 | --- | --- |
 | Push to `main` | Never. Only `rsc/knowledge` receives anything. |
-| Push your code or your unpushed commits | Only its own snapshot of the knowledge folders goes up. Your code waits for you. |
+| Push your code or your unpushed commits | Only the knowledge folders go up, even from a commit that also has code. Your code waits for you. |
 | Trigger CI or a deploy | Every automatic commit says `[skip ci]`. |
 | Bring in anybody else's code | Only knowledge paths come down. Code, config and `.claude/` are never pulled. |
 | Sync `02-DOCS/wiki/harness/user-profile.md` | Those are one person's dials. |

package/manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.0.0",
+  "version": "3.0.2",
   "counts": {
     "skills": 270,
     "agents": 33,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ericrisco/rsc",
-  "version": "3.0.0",
+  "version": "3.0.2",
   "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/targets/knowledge-sync.mjs

@@ -104,7 +104,7 @@ const worktreeBlob = (root, path) => (existsSync(join(root, path)) ? line(root,
 function readState(root) {
   let s = {};
   try { s = JSON.parse(readFileSync(join(root, '.rsc', STATE), 'utf8')); } catch { /* first run */ }
-  return { announced: false, seen: null, queue: [], ours: [], notices: [], lastFetch: 0, snap: null, ...s };
+  return { announced: false, seen: null, queue: [], ours: [], notices: [], lastFetch: 0, snap: null, head: null, ...s };
 }
 
 function writeState(root, s) {
@@ -232,6 +232,26 @@ export function commitLocal(root, s) {
   return sha;
 }
 
+/**
+ * Knowledge the agent (or the person) committed on the branch since the last turn goes up too. Without
+ * this only what was still uncommitted when the turn ended travelled, and an agent that commits its
+ * feature document with its code in one long turn left nothing to send (E2E 2026-10-04). The first
+ * time, and after a branch switch, it starts where the branch left the remote default branch.
+ */
+export function queueCommitted(root, s) {
+  const branch = line(root, ['rev-parse', '--abbrev-ref', 'HEAD']);
+  if (!branch || branch === 'HEAD') return;
+  const head = line(root, ['rev-parse', 'HEAD']);
+  const def = defaultBranch(root);
+  const remoteDef = def && line(root, ['rev-parse', '--verify', '--quiet', `refs/remotes/origin/${def}`]);
+  const valid = s.head && line(root, ['rev-parse', '--verify', '--quiet', `${s.head}^{commit}`])
+    && run(root, ['merge-base', '--is-ancestor', s.head, head]).ok;
+  const from = valid ? s.head : (remoteDef && line(root, ['merge-base', 'HEAD', remoteDef]));
+  if (!head || !from || from === head) return;
+  const commits = git(root, ['rev-list', '--reverse', '--no-merges', `${from}..${head}`, '--', ...KNOWLEDGE]).split('\n').filter(Boolean);
+  for (const c of commits) if (!s.queue.includes(c) && !s.ours.includes(c)) s.queue.push(c);
+}
+
 // ------------------------------------------------------------------ network: up
 
 /**
@@ -241,7 +261,9 @@ export function commitLocal(root, s) {
  */
 function replay(root, base, sha, ours = []) {
   if (!line(root, ['rev-parse', '--verify', '--quiet', `${sha}^`])) return null;
-  const patch = run(root, ['diff-tree', '-p', '--binary', '--full-index', `${sha}^`, sha], { timeout: NET_TIMEOUT_MS });
+  // Only the knowledge paths: a commit of the agent's own on a branch also carries code, and code never
+  // travels this way.
+  const patch = run(root, ['diff-tree', '-p', '--binary', '--full-index', `${sha}^`, sha, '--', ...KNOWLEDGE], { timeout: NET_TIMEOUT_MS });
   if (!patch.ok) return null;
   if (!patch.out.trim()) return line(root, ['rev-parse', `${base}^{tree}`]);
   const env = { GIT_INDEX_FILE: join(root, '.rsc', 'knowledge-sync.index') };
@@ -250,7 +272,7 @@ function replay(root, base, sha, ours = []) {
     // File by file: one that is already there as it should be is skipped, not read as a clash (a
     // teammate's change taken uncommitted on a closed trunk comes back up in the next snapshot), and
     // one real clash does not hold back the rest of the patch's reasoning.
-    const files = zlist(git(root, ['diff-tree', '--no-commit-id', '--name-only', '--no-renames', '-r', '-z', `${sha}^`, sha]));
+    const files = zlist(git(root, ['diff-tree', '--no-commit-id', '--name-only', '--no-renames', '-r', '-z', `${sha}^`, sha, '--', ...KNOWLEDGE])).filter(isKnowledge);
     for (const f of files) {
       const next = blob(root, sha, f);
       const there = blob(root, base, f);
@@ -304,13 +326,19 @@ export function ship(root, s) {
       if (!line(root, ['rev-parse', '--verify', '--quiet', `${sha}^{commit}`])) continue; // rewritten away
       const tree = replay(root, base, sha, s.ours);
       if (tree === null) {
-        const files = zlist(git(root, ['diff-tree', '--no-commit-id', '--name-only', '-r', '-z', sha]));
+        const files = zlist(git(root, ['diff-tree', '--no-commit-id', '--name-only', '-r', '-z', sha, '--', ...KNOWLEDGE])).filter(isKnowledge);
         note(s, `No he podido subir ${listed(files)}: choca con un cambio que ya está en ${KNOWLEDGE_BRANCH}. ` +
           'Tu versión sigue aquí; hay que juntarlas a mano.');
         continue;
       }
       if (tree === line(root, ['rev-parse', `${base}^{tree}`])) { kept.push(sha); continue; } // already there
-      const [name, email, date, ...body] = git(root, ['log', '-1', '--format=%an%n%ae%n%aI%n%B', sha]).split('\n');
+      const [name, email, date, ...rest] = git(root, ['log', '-1', '--format=%an%n%ae%n%aI%n%B', sha]).split('\n');
+      // A commit of somebody's own (code + docs) goes up as its knowledge part, under a message that
+      // says so and carries [skip ci]: its own message would describe code that is not there, and
+      // would run CI on the exchange branch.
+      const body = rest.join('\n').includes(SKIP_CI) ? rest : [
+        `📝 docs(auto): ${summary(zlist(git(root, ['diff-tree', '--no-commit-id', '--name-only', '-r', '-z', sha, '--', ...KNOWLEDGE])).filter(isKnowledge))} ${SKIP_CI}`,
+        '', `Desde: ${rest[0] || sha.slice(0, 7)}`];
       base = git(root, ['commit-tree', tree, '-p', base, '-F', '-'], {
         input: body.join('\n'),
         env: { GIT_AUTHOR_NAME: name, GIT_AUTHOR_EMAIL: email, GIT_AUTHOR_DATE: date },
@@ -448,7 +476,9 @@ export function onTurn(root, { spawnShip = true } = {}) {
   try {
     if (inactiveReason(root) || busy(root)) return;
     const pending = locked(root, (s) => {
+      try { queueCommitted(root, s); } catch { /* the next turn looks again */ }
       try { commitLocal(root, s); } catch (e) { note(s, `La sincronización del conocimiento no pudo comitear: ${clean(e.message, 160)}`); }
+      s.head = line(root, ['rev-parse', '--verify', '--quiet', 'HEAD']) || s.head;
       return s.queue.length;
     });
     if (pending && spawnShip) background(root, 'ship');

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()) {