@ericrisco/rsc 3.0.16 → 3.0.18

package/manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.0.16",
+  "version": "3.0.18",
   "counts": {
     "skills": 271,
     "agents": 34,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ericrisco/rsc",
-  "version": "3.0.16",
+  "version": "3.0.18",
   "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

@@ -469,12 +469,24 @@ export function ignoreLocalState(cwd = process.cwd(), target) {
   }
 
   const add = wanted.filter((w) => !present.has(norm(w)));
-  if (!add.length) return null;
+  // Every append used to open a new block with its own header, so a project synced across a dozen
+  // versions carried a dozen copies of it. Adjacent rsc blocks are one block: fold them (only our
+  // header lines and the blank seams between our blocks go; every entry stays, in order).
+  const folded = foldIgnoreBlocks(text);
+  if (!add.length) {
+    if (folded === text) return null;
+    try { writeFileSync(gi, folded); return gi; } catch { return null; }
+  }
 
-  // Append only. Never rewrite, never reorder: the rest of that file is theirs.
-  const prefix = text === '' ? '' : (text.endsWith('\n') ? '' : '\n');
+  // Never reorder, never touch a line of theirs. When the file already ends with our block, the new
+  // entries join it; otherwise they open one.
+  const base = folded === '' || folded.endsWith('\n') ? folded : `${folded}\n`;
+  const next = endsWithIgnoreBlock(base)
+    ? `${base}${add.join('\n')}\n`
+    : `${base}${base === '' ? '' : '\n'}${RSC_IGNORE_HEADER}\n${add.join('\n')}\n`;
   try {
-    appendFileSync(gi, `${prefix}\n# rsc local state (hooks, seals, logs) and managed skill links — machine-local\n${add.join('\n')}\n`);
+    if (folded === text && next.startsWith(text)) appendFileSync(gi, next.slice(text.length));
+    else writeFileSync(gi, next);
     if (target) {
       const statePath = targetPaths(target, undefined, cwd).stateFile;
       const state = readState(statePath);
@@ -778,6 +790,41 @@ function emptyConfig(file) {
 
 const RSC_IGNORE_HEADER = '# rsc local state (hooks, seals, logs) and managed skill links — machine-local';
 
+// Merge consecutive rsc blocks into the first: drop a repeated header and the blank seam before it
+// when the block above was ours too. A block of the user's in between ends ours, so nothing of
+// theirs is ever moved or absorbed.
+export function foldIgnoreBlocks(text) {
+  const out = [];
+  let ours = false;
+  let afterBlank = false;
+  for (const line of text.split('\n')) {
+    if (line === RSC_IGNORE_HEADER) {
+      if (ours && afterBlank) {
+        while (out.length && out[out.length - 1].trim() === '') out.pop();
+        afterBlank = false;
+        continue;
+      }
+      ours = true;
+    } else if (line.trim() === '') {
+      afterBlank = true;
+      out.push(line);
+      continue;
+    } else if (afterBlank) {
+      ours = false;
+    }
+    afterBlank = false;
+    out.push(line);
+  }
+  return out.join('\n');
+}
+
+function endsWithIgnoreBlock(text) {
+  const lines = text.replace(/\n+$/, '').split('\n');
+  let i = lines.length - 1;
+  while (i > 0 && lines[i - 1].trim() !== '') i -= 1;
+  return lines[i] === RSC_IGNORE_HEADER;
+}
+
 // Remove the blocks `ignoreLocalState` appended: the header line, the entries under it up to the
 // next blank line, and the blank seam before it. Lines the user wrote are never part of a block.
 function stripIgnoreBlocks(text) {