backpass 0.1.2 → 0.1.4

package/README.md

@@ -80,15 +80,15 @@ backpass apply     # review each edit, accept or reject, then write
 
 backpass reads the local transcript stores of seven harnesses directly. No API, no upload.
 
-| Harness        | Store                                          | Repo tie                                |
-| -------------- | ---------------------------------------------- | --------------------------------------- |
-| **claude**     | `~/.claude/projects/<munged-cwd>/<uuid>.jsonl` | per-line `cwd`                          |
-| **codex**      | `~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl` | `cwd` + recorded `git.repository_url`   |
-| **pi**         | `~/.pi/agent/sessions/<escaped-cwd>/*.jsonl`   | session-header `cwd`                    |
-| **opencode**   | `~/.local/share/opencode/opencode.db` (sqlite) | `session.directory`                     |
-| **grok**       | `~/.grok/sessions/<encoded-cwd>/<uuid>/`       | `summary.json` `cwd` + `git_remotes`    |
-| **cursor CLI** | `~/.cursor/chats/<md5(cwd)>/<uuid>/`           | `meta.json` `cwd`                       |
-| **hermes**     | `~/.hermes/state.db` (sqlite)                  | CLI prompt cwd / ACP `model_config.cwd` |
+| Harness        | Store                                          | Repo tie                                            |
+| -------------- | ---------------------------------------------- | --------------------------------------------------- |
+| **claude**     | `~/.claude/projects/<munged-cwd>/<uuid>.jsonl` | per-line `cwd`                                      |
+| **codex**      | `~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl` | `cwd` + recorded `git.repository_url`               |
+| **pi**         | `~/.pi/agent/sessions/<escaped-cwd>/*.jsonl`   | session-header `cwd`                                |
+| **opencode**   | `~/.local/share/opencode/opencode.db` (sqlite) | `session.directory`                                 |
+| **grok**       | `~/.grok/sessions/<encoded-cwd>/<uuid>/`       | `summary.json` `cwd` + `git_remotes`                |
+| **cursor CLI** | `~/.cursor/chats/<md5(cwd)>/<uuid>/`           | `meta.json` `cwd`                                   |
+| **hermes**     | `~/.hermes/state.db` (sqlite)                  | session cwd, with CLI prompt / ACP config fallbacks |
 
 Hermes collection includes CLI and ACP sessions only. Gateway, cron, and WhatsApp sessions
 are excluded because their recorded cwd belongs to the shared gateway process, not a project.
@@ -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.2",
+  "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/discovery/adapters/hermes.js

@@ -7,15 +7,15 @@ import { openReadOnly, safeJsonParse } from "./sqlite.js";
  * hermes: ~/.hermes/state.db (sqlite)
  *
  * Observed schema version 13 (upstream is 26; SELECT named columns so additive
- * columns are tolerated). Hermes has no cwd, git branch, or git remote column.
- *
- * Association is recovered only for source in ('cli', 'acp'):
+ * columns are tolerated). v26 adds sessions.cwd; CLI rows leave system_prompt
+ * NULL and store the project path there. ACP still snapshots cwd on
+ * model_config. Prefer the cwd column when present, then the v13 paths:
  *   acp - model_config.cwd when it is an absolute path
  *   cli - first `Current working directory:` / `Working directory:` line in
  *         system_prompt
- * Gateway / cron / whatsapp sessions are skipped: their prompt cwd is the
- * gateway process cwd, not a project, and would pin unrelated sessions to one
- * repo. Sessions with no recoverable cwd are skipped.
+ * Gateway / cron / whatsapp sessions are skipped even if sessions.cwd is set:
+ * their path is the gateway process cwd, not a project, and would pin
+ * unrelated sessions to one repo. Sessions with no recoverable cwd are skipped.
  *
  * Timestamps are epoch seconds; backpass uses milliseconds (x1000).
  * Structured content uses a `\x00json:` prefix; node:sqlite truncates TEXT at
@@ -62,17 +62,25 @@ function cwdFromPrompt(prompt) {
 }
 
 function recoverCwd(row, source) {
+  if (looksAbsolute(row.cwd)) return row.cwd;
   if (source === "acp") return cwdFromConfig(row.model_config);
   if (source === "cli") return cwdFromPrompt(row.system_prompt);
   return null;
 }
 
-function activeMessageFilter(db, alias = "") {
-  const hasActive = db
-    .prepare("PRAGMA table_info(messages)")
+function tableHasColumn(db, table, column) {
+  return db
+    .prepare(`PRAGMA table_info(${table})`)
     .all()
-    .some((column) => column.name === "active");
-  return hasActive ? ` AND ${alias}active = 1` : "";
+    .some((entry) => entry.name === column);
+}
+
+function activeMessageFilter(db, alias = "") {
+  return tableHasColumn(db, "messages", "active") ? ` AND ${alias}active = 1` : "";
+}
+
+function sessionCwdSelect(db) {
+  return tableHasColumn(db, "sessions", "cwd") ? ", s.cwd" : "";
 }
 
 /**
@@ -87,10 +95,11 @@ export async function discover({ cutoffMs } = {}) {
   const cutoffSec = cutoffMs == null ? null : cutoffMs / 1000;
   try {
     const activeFilter = activeMessageFilter(db, "m.");
+    const cwdSelect = sessionCwdSelect(db);
     const rows = db
       .prepare(
         `SELECT s.id, s.source, s.model, s.model_config, s.system_prompt, s.title,
-                s.started_at, s.ended_at,
+                s.started_at, s.ended_at${cwdSelect},
                 MAX(s.started_at,
                     COALESCE(s.ended_at, s.started_at),
                     COALESCE((SELECT MAX(m.timestamp)

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));