brand-manager-worker 0.2.0 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brand-manager-worker",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "The Goose Tools brand-deal worker \u2014 your computer reads your brand email and drafts replies in your voice for goosetools.com, using your own Claude account. Drafts only; it never sends.",
   "repository": {
     "type": "git",

package/worker/compact.js

@@ -37,6 +37,48 @@ export const COMPACTABLE = [
 
 const ARCHIVE_DIR = join(BRAND_DIR, "archive");
 
+/**
+ * A free filename. The stamp used to be the date alone, so a second
+ * compaction on the same day overwrote the first archive — replacing the true
+ * original with an already-compacted copy and quietly destroying the only
+ * record of what was dropped.
+ */
+function archivePathFor(target) {
+  const stamp = new Date().toISOString().slice(0, 10);
+  let candidate = join(ARCHIVE_DIR, `${target}-${stamp}.md`);
+  for (let n = 2; existsSync(candidate); n += 1) {
+    candidate = join(ARCHIVE_DIR, `${target}-${stamp}-${n}.md`);
+  }
+  return candidate;
+}
+
+// Compaction can land a file just above the threshold — negotiation.md came
+// out at 48KB against a 40KB line. Without a memory of that, every scan
+// forever would re-compact it: an agent call each time, for a file that is
+// already as small as it gets. So a file is left alone after a compaction
+// until it has actually grown again.
+const STATE_PATH = () => join(ARCHIVE_DIR, ".compact-state.json");
+const REGROWTH = 1.15;
+
+function readState() {
+  try {
+    return JSON.parse(readFileSync(STATE_PATH(), "utf8"));
+  } catch {
+    return {};
+  }
+}
+
+function noteCompaction(target, size) {
+  try {
+    const state = readState();
+    state[target] = { size, at: new Date().toISOString() };
+    mkdirSync(ARCHIVE_DIR, { recursive: true });
+    writeFileSync(STATE_PATH(), JSON.stringify(state, null, 2));
+  } catch {
+    // A missing note only costs one redundant compaction; never fail over it.
+  }
+}
+
 export function sizeOf(path) {
   try {
     return statSync(path).size;
@@ -46,7 +88,14 @@ export function sizeOf(path) {
 }
 
 export function oversized() {
-  return COMPACTABLE.filter(({ path }) => sizeOf(path) > COMPACT_THRESHOLD);
+  const state = readState();
+  return COMPACTABLE.filter(({ target, path }) => {
+    const size = sizeOf(path);
+    if (size <= COMPACT_THRESHOLD) return false;
+    const last = state[target];
+    // Already squeezed and hasn't meaningfully regrown — nothing left to win.
+    return !last?.size || size > last.size * REGROWTH;
+  });
 }
 
 const prompt = (label, body) =>
@@ -100,33 +149,36 @@ export async function compactFile({ target, path }) {
   );
   const after = typeof out?.markdown === "string" ? out.markdown.trim() : "";
 
+  // A transient failure (bad output, timeout) must stay retryable — the file
+  // is over budget and we want another go. Only the deterministic refusals
+  // below get remembered, because re-asking would refuse identically.
   if (!after) return { target, ok: false, error: "no parseable rewrite" };
 
   // Guards. An agent asked to shrink a file can decide to summarize it, and a
   // 3KB precis of 66KB of learned voice is a catastrophic, silent loss — the
   // archive would be the only copy and nobody would notice for weeks.
   if (after.length < before.length * 0.25) {
-    return {
+    return refuse(
       target,
-      ok: false,
-      error: `refused: ${before.length} -> ${after.length} bytes looks like a summary, not a rewrite`,
-    };
+      before.length,
+      `${before.length} -> ${after.length} bytes looks like a summary, not a rewrite`,
+    );
   }
   if (after.length >= before.length) {
-    return { target, ok: false, error: "refused: no smaller than the original" };
+    return refuse(target, before.length, "no smaller than the original");
   }
   // The headings are the file's skeleton; losing most of them means it was
   // restructured rather than compacted.
   const headingsBefore = (before.match(/^##\s/gm) ?? []).length;
   const headingsAfter = (after.match(/^##\s/gm) ?? []).length;
   if (headingsBefore >= 4 && headingsAfter < 2) {
-    return { target, ok: false, error: "refused: lost the section structure" };
+    return refuse(target, before.length, "lost the section structure");
   }
 
   mkdirSync(ARCHIVE_DIR, { recursive: true });
-  const stamp = new Date().toISOString().slice(0, 10);
-  writeFileSync(join(ARCHIVE_DIR, `${target}-${stamp}.md`), before);
+  writeFileSync(archivePathFor(target), before);
   writeFileSync(path, `${after}\n`);
+  noteCompaction(target, after.length);
 
   return {
     target,
@@ -139,6 +191,16 @@ export async function compactFile({ target, path }) {
   };
 }
 
+/**
+ * A refusal the agent would repeat verbatim if asked again. Remember the size
+ * so the file isn't re-attempted every scan — it becomes eligible again only
+ * once it has genuinely regrown.
+ */
+function refuse(target, size, why) {
+  noteCompaction(target, size);
+  return { target, ok: false, error: `refused: ${why}` };
+}
+
 /**
  * Compact anything over the threshold. Called at the END of a scan, once —
  * not per thread, so a scan pays for at most one of these and only on the day