@ericrisco/rsc 2.0.9 → 2.0.11

package/manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.0.9",
+  "version": "2.0.11",
   "counts": {
     "skills": 273,
     "agents": 33,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ericrisco/rsc",
-  "version": "2.0.9",
+  "version": "2.0.11",
   "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/lib/onboarding-apply.js

@@ -4,6 +4,7 @@ import { dirname, join, relative, resolve, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { applyInstall, pruneSharedBases, removeTargetInstall } from '../install-apply.js';
 import { targetPaths } from '../../targets/index.js';
+import { targetHasAgents } from '../../targets/agents.js';
 import { readState } from './state.js';
 import { readManifest, writeManifest } from './manifest-file.js';
 import { encodeGoal, identifyPlan } from './onboarding.js';
@@ -11,6 +12,22 @@ import { createBackup, restoreBackup } from './backups.js';
 
 const sameSet = (a = [], b = []) => JSON.stringify([...a].sort()) === JSON.stringify([...b].sort());
 
+/**
+ * What THIS target should be holding, which is not the same question as what the project decided.
+ *
+ * The policy is the PROJECT's: "these are the agents this project wants." Whether an assistant can
+ * hold a subagent at all is the TARGET's business, and nine of the seventeen cannot — amp, jules,
+ * zed, antigravity, windsurf, cline, roo, continue and aider have no such concept. The installer
+ * always knew this and correctly wrote none; the verifier did not, and demanded the project's list
+ * from every target, so onboarding could never complete on any of the nine. Since the failure rolls
+ * back, what the person got was empty directory shells and no harness — with a recovery command
+ * that leads straight back to the same wall.
+ *
+ * Asking amp for a subagent is not a divergence. It is a category error, and this is where the two
+ * categories stop being confused.
+ */
+export const expectedAgentsFor = (target, plan) => (targetHasAgents(target) ? (plan.policy.agents || []) : []);
+
 function inside(root, path) {
   return path === root || path.startsWith(`${root}${sep}`);
 }
@@ -92,7 +109,7 @@ export function verifyOnboarding(cwd, plan, planId) {
   for (const target of plan.policy.targets) {
     const state = readState(targetPaths(target, undefined, cwd).stateFile);
     if (!sameSet(Object.keys(state.skills || {}), plan.policy.skills)) differences.push(`${target}: installed skills differ from accepted policy`);
-    if (!sameSet(state.agents || [], plan.policy.agents || [])) differences.push(`${target}: installed agents differ from accepted policy`);
+    if (!sameSet(state.agents || [], expectedAgentsFor(target, plan))) differences.push(`${target}: installed agents differ from accepted policy`);
     if (state.policy?.alwaysOn !== plan.policy.alwaysOn) differences.push(`${target}: always-on policy differs`);
     if (state.policy?.codeHooks !== plan.policy.codeHooks) differences.push(`${target}: code-hook policy differs`);
     if (state.policy?.memory !== plan.policy.memory) differences.push(`${target}: memory policy differs`);

package/targets/session-memory-adapter.mjs

@@ -56,15 +56,35 @@ function hookEventName(target, event, native) {
   return names[event] || event;
 }
 
+const COMPACTION_HINT = 'rsc memory: consider compacting at the next phase boundary; nothing was compacted automatically.';
+
+/**
+ * Two different things used to share one channel, and that is the whole bug.
+ *
+ * The resume CONTEXT is information for the model, and it is only ever produced on `start` —
+ * `SessionStart`, one of the few events whose output may carry `hookSpecificOutput.additionalContext`.
+ * The compaction HINT is a message for the PERSON, and it was going out through the same field on
+ * whatever event happened to be running. On `Stop`, `PreCompact` and `SessionEnd` the client rejects
+ * that outright ("Hook JSON output validation failed — hookSpecificOutput.hookEventName: expected one
+ * of …"), so the hook meant to help ended up printing an error after every turn, and after
+ * `/compact` in particular — which is exactly what the hint had just told the person to run.
+ *
+ * So the hint moves to `systemMessage`, which every event accepts. This needs no table of which
+ * event carries what, and it cannot rot when the client adds an event: anything addressed to the
+ * person travels by the universal channel, and only genuine model context uses the narrow one.
+ */
 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 };
+  const hint = compactionHint ? COMPACTION_HINT : '';
+  if (!context && !hint && !notice) return {};
+  if (target === 'cursor') {
+    const message = [notice, hint].filter(Boolean).join('\n');
+    return { ...(context ? { additional_context: context } : {}), ...(message ? { user_message: message } : {}) };
+  }
+  if (target === 'opencode') return { context, notice: [notice, hint].filter(Boolean).join('\n') || null };
+  const message = [notice, hint].filter(Boolean).join('\n');
   return {
-    ...(notice ? { systemMessage: notice } : {}),
-    ...(extra ? { hookSpecificOutput: { hookEventName: eventName, additionalContext: extra } } : {}),
+    ...(message ? { systemMessage: message } : {}),
+    ...(context ? { hookSpecificOutput: { hookEventName: eventName, additionalContext: context } } : {}),
   };
 }
 
@@ -106,8 +126,13 @@ export function handleLifecycle({ target, event, native = {}, cwd, settings } =
     if (typeof native.cost === 'number') captureInput.cost = native.cost;
     if (Number.isInteger(native.tool_calls)) captureInput.toolCalls = native.tool_calls;
     const captured = capture(captureInput);
+    // `stop_hook_active` is the client saying "this turn is already running BECAUSE a stop hook
+    // asked for it". Speaking again here is how a Stop hook wakes itself: the student's session did
+    // nine rounds of hook → "—" → hook before the client broke the loop. Record the turn, say
+    // nothing.
+    const silenced = event === 'turn' && Boolean(native?.stop_hook_active);
     return {
-      output: nativeOutput(target, eventName, '', captured.notice, captured.compactionHint),
+      output: silenced ? {} : nativeOutput(target, eventName, '', captured.notice, captured.compactionHint),
       capture: captured,
       remote: false,
       degraded: false,

package/targets/session-memory-core.mjs

@@ -352,11 +352,22 @@ export function capture(input = {}) {
   if (errors.length) return { record: null, path: null, notice: null, compactionHint: false, errors };
   atomicJson(recordPath, record);
   existing = record;
+  // Once per session, not once per turn. `editCount` only ever grows, so `editCount >= threshold`
+  // was true for every remaining event of a working afternoon — the twentieth edit turned a useful
+  // nudge into a line after every single turn, for good. Worse, compaction does not reset the
+  // count, so following the advice changed nothing and the hint kept coming.
+  //
+  // The flag lives on the ANCHOR and not on the record on purpose: the record's schema is closed
+  // and every field of it is required, so a new field there would fail validation on every record
+  // already written and `readRecords` would quietly drop the project's whole history.
+  let compactionHint = Boolean(config.compactionHint && editCount >= config.editThreshold);
+  if (compactionHint && anchor.compactionHintedAt) compactionHint = false;
+  else if (compactionHint) atomicJson(anchorPath, { ...anchor, compactionHintedAt: now });
   return {
     record,
     path: recordPath,
     notice: consumeNotice(store),
-    compactionHint: Boolean(config.compactionHint && editCount >= config.editThreshold),
+    compactionHint,
   };
 }