backpass 0.1.3 → 0.1.4

package/README.md

@@ -241,6 +241,11 @@ a headless box or `--no-open` just hands you the link.
 There is no DEFER button, and it isn't missing: **rejections are remembered.** A rejected
 edit is not proposed again unless materially new evidence arrives.
 
+The live budget gauge is not just a readout. Apply rechecks the accepted subset against
+the same budget gate as synthesis: stay under the cap, or shrink if the file is already
+over. An incompatible set writes nothing and does not record rejections, so you can pick
+a compatible set and try again.
+
 ```sh
 backpass apply --no-ui     # same decision, in the terminal
 backpass apply --no-open   # print the surface URL, don't launch a browser

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backpass",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "packageManager": "pnpm@11.5.0",
   "description": "Gradient descent for your agent memory - analyzes past agent session transcripts and proposes evidence-backed edits to AGENTS.md / CLAUDE.md",
   "type": "module",

package/src/apply/writer.js

@@ -1,17 +1,54 @@
 import fs from "node:fs";
 import path from "node:path";
 
-import { applyEdit } from "../proposal.js";
-import { budgetStatus } from "../tokens.js";
+import { applyEdit, projectWithDecisions } from "../proposal.js";
+import { budgetGateKind, budgetStatus } from "../tokens.js";
 import { recordRejection } from "../state.js";
 import { writeSkill } from "../skills.js";
 
+function acceptedSubsetBudgetFailure({ proposal, accepted, repo, capTokens }) {
+  if (!accepted.length) return null;
+
+  const relative = proposal.memoryFile.path;
+  const absolute = path.join(repo.root, relative);
+  if (!fs.existsSync(absolute)) return null;
+
+  const before = fs.readFileSync(absolute, "utf8");
+  const { budget } = projectWithDecisions(
+    before,
+    accepted,
+    accepted.map((edit) => edit.id),
+    capTokens,
+  );
+  const gate = budgetGateKind(budget);
+  if (gate === "cap") {
+    return {
+      file: relative,
+      error:
+        `accepted edits leave ${relative} at ${budget.projected} tokens, ${budget.over} over the ` +
+        `${capTokens}-token budget; choose a compatible set of edits`,
+    };
+  }
+  if (gate === "shrink") {
+    return {
+      file: relative,
+      error:
+        `${relative} is already ${budget.current - capTokens} tokens over the ${capTokens}-token budget, ` +
+        `so accepted edits must shrink it, but they change it by ${budget.delta >= 0 ? "+" : ""}${budget.delta} ` +
+        "tokens; choose a compatible set of edits",
+    };
+  }
+  return null;
+}
+
 /**
  * The only place in backpass that writes to the repo.
  *
  * Everything upstream is read-only analysis; a run only changes the weights here, after
- * a human accepted specific edits. Writes are grouped per file so a memory file is
- * rewritten once, atomically, rather than edit by edit.
+ * a human accepted specific edits. The accepted subset is rechecked with the same
+ * cap/shrink budget gate as the full proposal (`budgetGateKind`); a failing subset
+ * returns with no writes and no rejection ledger. Writes are grouped per file so a
+ * memory file is rewritten once, atomically, rather than edit by edit.
  */
 export function applyDecisions({ proposal, decisions, repo, state, config, dryRun = false }) {
   const accepted = proposal.edits.filter((e) => decisions[e.id] === "accepted");
@@ -25,8 +62,20 @@ export function applyDecisions({ proposal, decisions, repo, state, config, dryRu
     warnings: [],
     accepted: accepted.length,
     rejected: rejected.length,
+    rejectionsRecorded: false,
   };
 
+  const budgetFailure = acceptedSubsetBudgetFailure({
+    proposal,
+    accepted,
+    repo,
+    capTokens: config.budgetTokens,
+  });
+  if (budgetFailure) {
+    results.failed.push(budgetFailure);
+    return results;
+  }
+
   for (const edit of accepted) {
     if (!byFile.has(edit.file)) byFile.set(edit.file, []);
     byFile.get(edit.file).push(edit);
@@ -76,6 +125,7 @@ export function applyDecisions({ proposal, decisions, repo, state, config, dryRu
     const rejections = state.readRejections();
     for (const edit of rejected) recordRejection(edit, rejections);
     state.writeRejections(rejections);
+    results.rejectionsRecorded = true;
   }
 
   return results;

package/src/commands/apply.js

@@ -10,7 +10,8 @@ import { budgetBar, formatTokens } from "../tokens.js";
  *
  * By default it serves the shipped static template through lavish-axi and waits for one
  * structured decision vector; `--no-ui` keeps the same ACCEPT/REJECT decision in the
- * terminal.
+ * terminal. `applyDecisions` revalidates the accepted subset against the budget before
+ * writing; a failing set records no rejections.
  */
 export async function cmdApply(ctx) {
   const { config, repo } = ctx;
@@ -97,7 +98,7 @@ export async function cmdApply(ctx) {
     out(`  ${color.red("failed")} ${failure.file}${failure.edit ? ` (${failure.edit})` : ""}: ${failure.error}`);
   }
 
-  if (results.rejected) {
+  if (results.rejectionsRecorded) {
     out(color.dim("  rejections recorded - they will not be re-proposed without new evidence"));
   }
   if (!results.written.length && !results.skills.length) out("  nothing written");

package/src/proposal.js

@@ -1,9 +1,10 @@
 import { renderHunkLines } from "./diff.js";
-import { budgetStatus, estimateTokens } from "./tokens.js";
+import { budgetGateKind, budgetStatus, estimateTokens } from "./tokens.js";
 
 /**
  * The proposal model: what a synthesis pass is allowed to produce, and the mechanical
- * gates it must clear before a human ever sees it (design sections 3, 6, 7).
+ * gates it must clear before a human ever sees it (design sections 3, 6, 7). The
+ * budget gate (`budgetGateKind`) runs again on the accepted subset at apply.
  *
  * The synthesis agent edits a staging copy of the memory file natively
  * (`src/workspace.js`); backpass measures the result as anchored hunks (`src/diff.js`)
@@ -355,12 +356,13 @@ export function buildProposal(rawResult, context) {
   budget.mode = memoryFile.tokens > config.budgetTokens ? "shrink" : "cap";
   budget.startedOverBudget = budget.mode === "shrink";
 
-  if (budget.mode === "cap" && !budget.withinBudget) {
+  const gate = budgetGateKind(budget);
+  if (gate === "cap") {
     violations.push(
       `applying every proposed edit leaves ${memoryFile.path} at ${budget.projected} tokens, ` +
         `${budget.over} over the ${config.budgetTokens}-token budget`,
     );
-  } else if (budget.mode === "shrink" && budget.delta >= 0) {
+  } else if (gate === "shrink") {
     violations.push(
       `${memoryFile.path} is already ${budget.current - config.budgetTokens} tokens over the ` +
         `${config.budgetTokens}-token budget, so this run must shrink it, but the proposed edits ` +

package/src/tokens.js

@@ -40,6 +40,13 @@ export function budgetStatus(currentText, projectedText, capTokens) {
   };
 }
 
+/** Cap: stay under. Shrink: already over, so the delta must be negative. */
+export function budgetGateKind(budget) {
+  if (budget.current <= budget.capTokens && !budget.withinBudget) return "cap";
+  if (budget.current > budget.capTokens && budget.delta >= 0) return "shrink";
+  return null;
+}
+
 /** Fixed-width ASCII gauge for `backpass status`. */
 export function budgetBar(status, width = 32) {
   const filled = Math.min(width, Math.round(status.utilization * width));