@ericrisco/rsc 3.5.0 → 3.6.0

package/manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.5.0",
+  "version": "3.6.0",
   "counts": {
     "skills": 269,
     "agents": 34,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ericrisco/rsc",
-  "version": "3.5.0",
+  "version": "3.6.0",
   "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/install-apply.js

@@ -85,6 +85,7 @@ export function generatedHookFiles({ target, cwd, policy }) {
     join(cwd, '.rsc', 'shell-unwrap.mjs'),
     join(cwd, '.rsc', 'worktree-reaper.mjs'),
     join(cwd, '.rsc', 'auto-update.mjs'),
+    join(cwd, '.rsc', 'memslop-offer.mjs'),
     // team-safe-default: the 3.0 start-up duties and the trunk policy (also read by branch-guard).
     join(cwd, '.rsc', 'team-safe-start.mjs'),
     join(cwd, '.rsc', 'trunk-policy.mjs'),

package/targets/auto-update.mjs

@@ -204,6 +204,14 @@ if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.ur
   const root = (hook ? process.argv[4] : process.argv[2]) || process.cwd();
   let notice = '';
   try { if (!process.env.RSC_NO_UPDATE_CHECK) notice = (await updateNotice(root)).trim(); } catch { /* fail open */ }
+  // Codex has no session-start.mjs: its one SessionStart hook is this one, so the MemSlop offer rides
+  // here (macOS 14+ only, rsc projects only). A sibling loaded lazily; any failure → no offer.
+  if (target === 'codex' && existsSync(join(root, '02-DOCS', 'wiki', 'harness', 'user-profile.md'))) {
+    try {
+      const said = (await import('./memslop-offer.mjs')).memslopNotice().trim();
+      if (said) notice = notice ? `${notice}\n\n${said}` : said;
+    } catch { /* no offer */ }
+  }
   if (!hook && !notice) notice = 'rsc is up to date.';
   process.stdout.write(`${hookOutput(target, notice)}\n`);
 }

package/targets/claude.js

@@ -123,6 +123,8 @@ export function wireHook(paths, sourceMd, policy = {}) {
   copyFileSync(join(HERE, 'worktree-reaper.mjs'), join(paths.projectRoot, '.rsc', 'worktree-reaper.mjs'));
   // session-start imports the shared update check, so it travels as a sibling too.
   copyFileSync(join(HERE, 'auto-update.mjs'), join(paths.projectRoot, '.rsc', 'auto-update.mjs'));
+  // session-start imports the optional MemSlop offer lazily, so it travels as a sibling too.
+  copyFileSync(join(HERE, 'memslop-offer.mjs'), join(paths.projectRoot, '.rsc', 'memslop-offer.mjs'));
   // team-safe-default: the 3.0 start-up duties and the trunk policy they read, as siblings.
   copyFileSync(join(HERE, 'team-safe-start.mjs'), join(paths.projectRoot, '.rsc', 'team-safe-start.mjs'));
   copyFileSync(join(HERE, 'trunk-policy.mjs'), join(paths.projectRoot, '.rsc', 'trunk-policy.mjs'));

package/targets/memslop-offer.mjs

@@ -0,0 +1,98 @@
+// MemSlop offer (macOS only). MemSlop is a menu bar app that closes the dev servers, test browsers and
+// other processes agents leave running. rsc tells the person about it once and, only on a yes, the
+// agent installs it. Shared by session-start (Claude Code) and the Codex SessionStart hook in
+// auto-update.mjs, so it travels as their sibling.
+//
+// Cost for anyone who does not want it: nothing. Off darwin it returns before touching the disk. On
+// macOS it only reads files (no subprocess, no network), and its single side effect is the cadence
+// stamp in ~/.rsc/memslop-offer.json. A "no" is per machine (~/.rsc/.no-memslop), because installing
+// an app is a machine decision; a per-project marker would re-ask in every repo. Silence is not a yes:
+// at most one offer every 7 days and 3 in total. Any error means no notice.
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { homedir, release as osRelease } from 'node:os';
+import { join } from 'node:path';
+
+const MIN_DARWIN = 23; // macOS 14 Sonoma, the oldest MemSlop runs on
+const EVERY_DAYS = 7;
+const MAX_OFFERS = 3;
+
+// RSC_MEMSLOP_HOME exists so tests can point it somewhere disposable (same escape hatch as RSC_SELLO_HOME).
+// An injected home (either way) skips the system /Applications, so a real install cannot leak into a test.
+// RSC_MEMSLOP_PLATFORM / RSC_MEMSLOP_RELEASE let a test run the real hook as another OS.
+export function memslopHome() {
+  return process.env.RSC_MEMSLOP_HOME || homedir();
+}
+
+const statePath = (home) => join(home, '.rsc', 'memslop-offer.json');
+
+// Does this agent config connect MemSlop's session-end hook? Missing file → no. Malformed → throws,
+// which the caller turns into silence.
+function hookConnected(file) {
+  if (!existsSync(file)) return false;
+  const config = JSON.parse(readFileSync(file, 'utf8'));
+  const entries = config?.hooks?.SessionEnd;
+  if (!Array.isArray(entries)) return false;
+  return entries.some((e) => Array.isArray(e?.hooks) && e.hooks.some((h) =>
+    typeof h?.command === 'string' && h.command.includes('memslop') && h.command.includes('hook session-end')));
+}
+
+// 'offer' (not installed), 'connect' (CLI present, a hook missing) or null (opted out, too old, all set).
+export function memslopState(home = memslopHome(), system = !process.env.RSC_MEMSLOP_HOME) {
+  if (existsSync(join(home, '.rsc', '.no-memslop'))) return null;
+  const dirs = (system ? ['/Applications'] : []).concat(join(home, 'Applications'));
+  const app = dirs.map((d) => join(d, 'MemSlop.app')).find((p) => existsSync(p));
+  if (!app) return 'offer';
+  // MemSlop < 1.2 has no command line tool and does not update itself: stay silent.
+  if (!existsSync(join(app, 'Contents', 'Helpers', 'memslop'))) return null;
+  const agents = [['.claude', 'settings.json'], ['.codex', 'hooks.json']];
+  const missing = agents.some(([dir, file]) => existsSync(join(home, dir)) && !hookConnected(join(home, dir, file)));
+  return missing ? 'connect' : null;
+}
+
+const OFFER = `
+===== rsc mem-slop (optional, macOS) =====
+MemSlop is a menu bar app that closes the dev servers, test browsers and other processes
+AI agents leave running. Free, open source; the first day it closes nothing, it only shows
+what it would close and asks.
+ACTION: offer it ONCE, in one line, to the user. On yes, run:
+  curl -fsSL https://raw.githubusercontent.com/ericrisco/mem-slop/main/install.sh | bash
+then \`memslop hooks install\` (also optional; ask). On no, create ~/.rsc/.no-memslop.
+Never install it without that yes.
+=========================================
+`;
+
+const CONNECT = `
+===== rsc mem-slop hooks (optional, macOS) =====
+MemSlop is installed but not connected to every agent here. \`memslop hooks install\` lets it clean
+up the moment a Claude Code or Codex session ends; \`memslop hooks uninstall\` undoes it.
+ACTION: offer it ONCE, in one line, to the user, and run it only on a yes. On no, create ~/.rsc/.no-memslop.
+================================================
+`;
+
+/**
+ * The block to print this session, or ''. Records the offer when it returns one.
+ * `platform`, `release` and `now` are injectable for tests.
+ */
+export function memslopNotice({
+  platform = process.env.RSC_MEMSLOP_PLATFORM || process.platform,
+  release = process.env.RSC_MEMSLOP_RELEASE,
+  home,
+  now = Date.now(),
+} = {}) {
+  if (platform !== 'darwin') return '';
+  try {
+    if (Number.parseInt(release ?? osRelease(), 10) < MIN_DARWIN) return '';
+    const dir = home ?? memslopHome();
+    let seen = { offers: 0, last: null };
+    if (existsSync(statePath(dir))) seen = JSON.parse(readFileSync(statePath(dir), 'utf8'));
+    const offers = Number(seen.offers) || 0;
+    if (offers >= MAX_OFFERS) return '';
+    const last = seen.last ? new Date(seen.last).getTime() : NaN;
+    if (!Number.isNaN(last) && (now - last) / 86400000 < EVERY_DAYS) return '';
+    const state = memslopState(dir, home === undefined && !process.env.RSC_MEMSLOP_HOME);
+    if (!state) return '';
+    mkdirSync(join(dir, '.rsc'), { recursive: true });
+    writeFileSync(statePath(dir), JSON.stringify({ offers: offers + 1, last: new Date(now).toISOString() }) + '\n');
+    return state === 'offer' ? OFFER : CONNECT;
+  } catch { return ''; }
+}

package/targets/opt-outs.js

@@ -39,6 +39,7 @@ export const MACHINE_OPT_OUTS = [
   'context7',   // an MCP connection is machine wiring, and its consent is individual
   'git',        // only fires with no .git/, which a clone cannot be
   'harness',    // "not offered again ON THIS MACHINE" — the bootstrap's own words
+  'memslop',    // an app install is machine wiring, and its consent is individual (~/.rsc/.no-memslop)
   'scope-check',// compares the project and home scopes OF THIS MACHINE
 ];
 

package/targets/session-start.mjs

@@ -212,6 +212,16 @@ then reload the session. If you don't want it here: create .rsc/.no-context7.
 `);
 }
 
+// MemSlop (optional, macOS 14+ only): one offer per machine, a permanent no in ~/.rsc/.no-memslop.
+// Under emitBody so a project wired in both scopes prints it once. The module is a sibling loaded
+// lazily: missing or failing, it stays silent and never takes the other notices down with it.
+if (emitBody && profileExists) {
+  try {
+    const M = await import('./memslop-offer.mjs');
+    process.stdout.write(M.memslopNotice());
+  } catch { /* no notice */ }
+}
+
 // Periodic skill audit: for active rsc projects, nudge to re-audit when the last run
 // is stale (or never ran). Running \`rsc audit\` stamps .rsc/audit.json and silences
 // this for the cadence. Opt out with .rsc/.no-audit.

package/targets/update-wiring.js

@@ -110,8 +110,8 @@ export default {
 `;
 
 export function updateManagedPaths(target, cwd = process.cwd()) {
-  const module = join(cwd, '.rsc', 'auto-update.mjs');
-  return CONFIG[target] ? [module, join(cwd, ...CONFIG[target].split('/'))] : [module];
+  const modules = [join(cwd, '.rsc', 'auto-update.mjs'), join(cwd, '.rsc', 'memslop-offer.mjs')];
+  return CONFIG[target] ? [...modules, join(cwd, ...CONFIG[target].split('/'))] : modules;
 }
 
 /** Wire it. Always: being off is the runtime's `.no-auto-update`, and the check itself stays on. */
@@ -119,8 +119,11 @@ export function wireUpdate(target, cwd = process.cwd()) {
   const module = join(cwd, '.rsc', 'auto-update.mjs');
   mkdirSync(dirname(module), { recursive: true });
   copyFileSync(join(HERE, 'auto-update.mjs'), module);
+  // The Codex hook imports the MemSlop offer lazily, so it travels as a sibling for every target.
+  const offer = join(cwd, '.rsc', 'memslop-offer.mjs');
+  copyFileSync(join(HERE, 'memslop-offer.mjs'), offer);
   if (!CONFIG[target]) {
-    return { mode: target === 'claude' ? 'hook' : 'agent', paths: [module] };
+    return { mode: target === 'claude' ? 'hook' : 'agent', paths: [module, offer] };
   }
   const configPath = join(cwd, ...CONFIG[target].split('/'));
   if (tracked(cwd, configPath)) return { mode: 'agent', reason: 'config-tracked', paths: [module] };