synartesis 0.8.4 → 0.8.6

package/CHANGELOG.md

@@ -2,6 +2,156 @@
 
 What changed, and why it mattered. Dates are release dates.
 
+## 0.8.6 — 2026-09-22
+
+A test I added in 0.8.5 failed the release build. The published package was
+never affected -- tests do not ship -- but the tag produced no GitHub release
+and no installers, so this is 0.8.5 with that test written properly.
+
+### Fixed
+
+- **The new screen budget asserted milliseconds, and milliseconds are a
+  property of the machine.** `tests/screen-budget.test.ts` held a console
+  frame and a watch frame under a stated number of milliseconds. That passed
+  on the machine it was written on and failed on a CI runner twenty minutes
+  later, which is several times slower and shared -- the gate in `release.yml`
+  went red and 0.8.5 never got its installers.
+
+  It asserts two machine-independent things now. A ratio, measured back to
+  back on whatever is running: answering from the indexes against answering
+  by reading every action in every run, which is about 36x here and has to
+  clear 4, because going back to reading the rows scores 1. And a query plan,
+  which is a fact rather than a duration -- the watch screen's newest-first
+  read has to name the index, and must not say `USE TEMP B-TREE FOR ORDER BY`,
+  which is exactly what it said before 0.8.5 added `actions_recent`.
+
+  It also seeds its four thousand actions once for the file rather than once
+  per test, which was most of the runtime and bought nothing: all three
+  questions are read-only.
+
+  The correctness half is new and is the part worth keeping. The two ways of
+  counting -- from the indexes and from the rows -- must agree, because a
+  frame that is fast and wrong is worse than the slow one it replaced.
+
+## 0.8.5 — 2026-09-22
+
+Three states you could get into and not get out of, two screens that read the
+whole journal to draw one frame, and a gate that let two statements through.
+Found by auditing rather than by using it, which is the difference between
+this release and the last one.
+
+### Fixed
+
+- **An undo killed halfway can now be resumed.** An action whose inverse was
+  being sent is marked `rolling_back`, and until now nothing could ever
+  reclaim one: no flag, no command, no amount of waiting. The claim was right
+  to refuse -- sending a second inverse is harmless for a restore and a second
+  real change to the world for a compensation -- but it was refusing because
+  it could not tell a process still working from one that had died, and there
+  was nothing to ask. One Ctrl-C during an undo put an action permanently
+  beyond the command whose whole job is getting back.
+
+  There is a lease now, in a `leases` table, holding the host and process id
+  that took each claim. A claim is reclaimed only on evidence, and only when
+  both questions have answers: the drift check has already proved the inverse
+  never landed (a `rolling_back` row that gets that far has a verified
+  pre-read, or it halts earlier), and the operating system says the process
+  that held it is gone. Anything less certain -- a lease from another machine,
+  a lease taken by a build from before the table existed, no lease at all --
+  still halts, and now says who held it and since when. There is no timeout to
+  tune, so there is no window in which an undo that is merely slow is mistaken
+  for one that died.
+
+  No schema version bump. `CREATE TABLE IF NOT EXISTS` changes no row and no
+  meaning, runs on every open, and an older build opening the same journal
+  neither notices nor cares -- the same argument the indexes have carried
+  since 0.6. A bump would refuse to open every journal already out there,
+  because there is still no migration path.
+
+- **A call whose outcome was never established no longer blocks a whole run
+  for ever.** `pending` means the call went out and nobody can say whether it
+  landed, and undo stops at one rather than produce a state that is neither
+  the before nor the after. That was right and permanent: nothing in the CLI
+  could settle such a row, so one interrupted call blocked the undo of
+  everything older than it, and the only way past was `--to` above it, which
+  abandons the rest.
+
+  `synartesis resolve <action> --applied|--failed` records what a person
+  found, and who they were. It claims nothing else: an action resolved as
+  applied has no inverse, because none was ever resolved, so undo reports it
+  as something it cannot put back and carries on with the rest of the run.
+  Unblocking a run and undoing an action are different things and only the
+  first is on offer. A proxy that comes back and records what it actually saw
+  wins over a person's judgement, because it was there.
+
+- **Ctrl-C during an undo stops between actions instead of wherever it lands.**
+  There was no signal handling in the CLI at all, so an interrupt was node's
+  default: die immediately, including with an inverse in flight, which is the
+  single best way to produce the state the first item above describes. The
+  first Ctrl-C now asks the rollback to stop before it claims the next action
+  and says so; the second is the operating system's. Deliberately not wired to
+  the abort signal that cancels a request in flight -- what is already in the
+  air is allowed to finish and be recorded.
+
+- **A client disconnecting no longer erases that a session was undone.** The
+  proxy ends its run when its client goes away, which says nothing about
+  whether anything was put back -- and it was an unguarded write, so it
+  stamped `complete` straight over the `rolled_back` an undo had just
+  recorded. A session somebody had reversed came back looking untouched.
+
+- **`undo` no longer defaults to a session an agent is still writing to.** The
+  newest run is, by definition, the one a running proxy is using, and `undo`
+  with no id pointed straight at it. A preview is always allowed, because it
+  writes nothing; doing it for real now needs `--yes`, and the refusal names
+  all three ways on. A session whose proxy exited normally is `complete`, so
+  this fires only where something really is unfinished.
+
+- **Two writes the `on_write` gate read as reads.**
+  `WITH x AS (DELETE FROM users RETURNING *) SELECT * FROM x` is an ordinary
+  PostgreSQL data-modifying CTE, and `EXPLAIN ANALYZE DELETE FROM users` runs
+  the statement it claims to be explaining. Both begin with a word on the
+  read list, neither contains a semicolon, and both were passed through
+  ungated while emptying a table. The heuristic's promise is that anything it
+  cannot confidently read as a read is gated; these were read confidently and
+  wrongly. The leading word still decides whether a statement could be a read,
+  and a second pass over it -- with comments and string literals removed, so a
+  keyword cannot hide in either -- decides whether anything in it writes.
+
+  No shipped policy uses `on_write`, so nothing in the box was exposed. The
+  documentation invites you to use it for your own SQL server, which is
+  exactly who this was a hole for.
+
+### Changed
+
+- **The console drew each frame by reading the entire journal.** `runsView`
+  called `getActions` for every session on screen -- every snapshot, result
+  and inverse in each of them, each through a schema parse -- to arrive at two
+  integers per row, eight times a second. `tallyRuns` was added for precisely
+  this and `list` was moved onto it; the console was missed. On a
+  hundred-megabyte journal that was 62ms a frame against a 120ms tick, so half
+  the event loop went on deciding what to draw and keypresses queued behind
+  renders. It is about 2ms now, and what each session still has waiting comes
+  from two partial indexes rather than from its rows.
+
+- **`watch` scanned the whole table to show twelve lines.** `recentActions`
+  orders by time and there was no index on time alone, so every 120ms it read
+  every row in the table -- the ones carrying the snapshots -- and sorted them
+  in a temporary b-tree to return twelve. 7.4ms to 0.03ms on the same journal.
+
+- **A large write no longer pays to canonicalise its own arguments for
+  nothing.** The three lookups that run on the way in to a call each built a
+  canonical form of the arguments before checking whether there was any
+  candidate row to compare it against -- and their indexes are partial
+  precisely so that there almost never is. 23.5ms of pure waste on a
+  ten-megabyte write, gone with an early return.
+
+- **A budget test for both screens.** Every performance test here measured one
+  call against a journal a few hundred rows deep, which is the one shape in
+  which none of the above exists. `tests/screen-budget.test.ts` seeds four
+  thousand actions and holds a console frame and a watch frame to a fraction
+  of their tick, so the next regression is caught by CI rather than by
+  somebody's fan.
+
 ## 0.8.4 — 2026-09-21
 
 Bugs, all of them found by using the thing rather than by a test going red:

package/README.md

@@ -415,6 +415,7 @@ get it if it is not installed.
 | `show <id> --live` | The same, plus what has changed in the world since |
 | `show <id> --full` | Every argument, snapshot and inverse, nothing elided |
 | `gates` / `approve <id>` / `deny <id>` | What is waiting, and answering it |
+| `resolve <id> --applied\|--failed` | Settle a call whose outcome nothing established |
 | `undo <id>` | Reverse a session, newest action first |
 | `undo <id> --dry-run` | Plan it and change nothing |
 | `undo <id> --replan` | Rebuild each undo from the current manifest |
@@ -452,7 +453,10 @@ cannot start a process:** see the [user guide](docs/synartesis-user-guide.md).
 - **An error is not proof that nothing happened.** A timeout or a tool-level
   error after a write leaves the outcome *unknown*, not failed, and undo will
   not step past it. Where a pre-read exists it is consulted to settle the
-  question instead of guessing.
+  question instead of guessing, and where none can settle it, `resolve` is how
+  a person who looked says which way it went -- an action resolved as applied
+  still has no inverse, so undo reports it as something it cannot put back
+  rather than pretending otherwise.
 - **An undo is only as good as the policy that recorded it.** Inverses are
   resolved when the call happens, so a mistake in a manifest is baked into every
   run made under it. `undo --replan` rebuilds them from a corrected one.

package/dist/{chunk-FIOKOIT6.js → chunk-JE7MOCZO.js}

@@ -203,6 +203,7 @@ var NOTHING_RECORDED_YET = [
 
 // src/journal/journal.ts
 import { chmodSync, existsSync as existsSync2, mkdirSync } from "fs";
+import { hostname } from "os";
 import { dirname as dirname2 } from "path";
 import Database from "better-sqlite3";
 import { z } from "zod";
@@ -257,6 +258,37 @@ CREATE TABLE IF NOT EXISTS actions (
   UNIQUE(run_id, seq)
 );
 
+-- Who is currently sending an inverse for an action, so that a dead owner can
+-- be told from a live one.
+--
+-- Without this, a row left in rolling_back by an undo that was killed could
+-- never be reclaimed by anything. The claim exists to stop two undos each
+-- sending the same inverse -- harmless for a restore, a second real change to
+-- the world for a compensation -- and refusing was the only safe answer to
+-- "is somebody still working on this?" when there was no way to ask. So an
+-- action could be stranded permanently by one Ctrl-C, on the command whose
+-- entire job is getting back. rollback.ts said as much in a comment: there is
+-- no lease to consult, and inventing a schema for one is a separate piece of
+-- work. This is that table.
+--
+-- Not a schema version bump, on the same argument the indexes above make: a
+-- table nothing older reads changes no row and no meaning, IF NOT EXISTS makes
+-- it idempotent, and an older build opening the same file afterwards neither
+-- notices nor cares -- it simply goes on refusing to reclaim, which is what it
+-- did before. A bump would refuse to open every journal already out there.
+--
+-- host and pid together, because a pid is only meaningful on the machine that
+-- issued it, and journals are shared. claimed_at is for the message rather
+-- than the decision: liveness is asked of the operating system, not inferred
+-- from a clock, so there is no timeout to tune and no window in which a slow
+-- undo is mistaken for a dead one.
+CREATE TABLE IF NOT EXISTS leases (
+  action_id  TEXT PRIMARY KEY REFERENCES actions(id),
+  host       TEXT NOT NULL,
+  pid        INTEGER NOT NULL,
+  claimed_at TEXT NOT NULL
+);
+
 CREATE INDEX IF NOT EXISTS actions_by_run ON actions(run_id, seq);
 
 -- Deliberately not a schema version bump. Adding an index changes no row and
@@ -342,6 +374,43 @@ CREATE INDEX IF NOT EXISTS actions_writes ON actions(run_id, seq)
 -- changes, no meaning changes, IF NOT EXISTS makes it idempotent, and an older
 -- build opening the same file afterwards neither notices nor cares.
 CREATE INDEX IF NOT EXISTS actions_seen ON actions(server, ts);
+
+-- The twin of actions_undoable, and partial for the same reason. The console
+-- asks, of every session, two questions: is there anything here an undo would
+-- reverse, and is there anything here a person still has to decide. The first
+-- is actions_undoable above; this is the second. It was being answered by
+-- materialising every action in every run -- snapshots, results and inverses,
+-- each through a zod parse -- eight times a second, to arrive at two integers
+-- per row. Measured on forty runs of five hundred actions with two-kilobyte
+-- snapshots, a hundred-megabyte journal: 62ms a frame, which on a 120ms tick
+-- is half the event loop spent deciding what to draw, so keypresses queued
+-- behind renders and the screen felt stuck.
+--
+-- The inverse_json test is in the predicate rather than in the query, so the
+-- count never reaches into a row: an unrecoverable action with no inverse is
+-- not a decision anybody can act on, and telling the two apart is exactly
+-- what cost the frame.
+--
+-- Added the same way as the ones above and for the same reason: no row
+-- changes, no meaning changes, IF NOT EXISTS makes it idempotent, and an older
+-- build opening the same file afterwards neither notices nor cares.
+CREATE INDEX IF NOT EXISTS actions_conflicted ON actions(run_id)
+  WHERE status = 'unrecoverable' AND inverse_json IS NOT NULL;
+
+-- The one query the seven above left behind, and the one running most often.
+-- recentActions asks for the newest twelve rows by time, and the watch screen
+-- asks it every 120ms. There was no index on ts alone -- actions_gated leads
+-- with status and actions_seen leads with server, so neither can serve a bare
+-- ORDER BY ts -- which left a full scan plus a temporary b-tree over a table
+-- whose rows carry the snapshots, to return twelve of them. The columns are
+-- in the same order the query sorts by, so sqlite walks this backwards and
+-- stops at the limit. Measured on forty runs of five hundred actions with
+-- two-kilobyte snapshots, a hundred-megabyte journal: 7.4ms to 0.03ms.
+--
+-- Added the same way as the ones above and for the same reason: no row
+-- changes, no meaning changes, IF NOT EXISTS makes it idempotent, and an older
+-- build opening the same file afterwards neither notices nor cares.
+CREATE INDEX IF NOT EXISTS actions_recent ON actions(ts, seq);
 `;
 
 // src/journal/journal.ts
@@ -354,6 +423,22 @@ var runSchema = z.object({
   status: z.enum(["active", "complete", "rolled_back", "partial"])
 });
 var seenSchema = z.object({ server: z.string(), ts: z.string() });
+var countedSchema = z.object({ run_id: z.string(), n: z.number() });
+var leaseSchema = z.object({
+  action_id: z.string(),
+  host: z.string(),
+  pid: z.number(),
+  claimed_at: z.string()
+});
+function running(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    const code = typeof error === "object" && error !== null && "code" in error ? error.code : void 0;
+    return code !== "ESRCH";
+  }
+}
 var tallySchema = z.object({
   run_id: z.string(),
   actions: z.number(),
@@ -397,6 +482,13 @@ function decode(value) {
 function orUndefined(value) {
   return value === null ? void 0 : value;
 }
+function sameCall(rows, args) {
+  if (rows.length === 0) {
+    return void 0;
+  }
+  const wanted = canonical(args ?? {});
+  return rows.find((row) => canonical(row.args) === wanted);
+}
 function toRun(raw) {
   const row = runSchema.parse(raw);
   return {
@@ -494,9 +586,14 @@ var SqliteJournal = class {
     });
     return id;
   }
-  endRun(runId, status) {
+  endRun(runId, status, from) {
     this.#run("endRun", () => {
-      this.#db.prepare("UPDATE runs SET ended_at = ?, status = ? WHERE id = ?").run((/* @__PURE__ */ new Date()).toISOString(), status, runId);
+      if (from === void 0) {
+        this.#db.prepare("UPDATE runs SET ended_at = ?, status = ? WHERE id = ?").run((/* @__PURE__ */ new Date()).toISOString(), status, runId);
+        return;
+      }
+      const allowed = from.map(() => "?").join(", ");
+      this.#db.prepare(`UPDATE runs SET ended_at = ?, status = ? WHERE id = ? AND status IN (${allowed})`).run((/* @__PURE__ */ new Date()).toISOString(), status, runId, ...from);
     });
   }
   closeAbandonedRun(runId) {
@@ -606,6 +703,9 @@ var SqliteJournal = class {
   markFailed(actionId, error) {
     this.#settle("markFailed", actionId, "failed", ["pending", "gated", "approved"], error);
   }
+  settleByHand(actionId, outcome, note) {
+    return this.#claim("settleByHand", actionId, outcome, ["pending"], note);
+  }
   /**
    * The call was interrupted, so whether the upstream applied it is genuinely
    * unknown. The row deliberately stays `pending`: recording it as failed
@@ -635,10 +735,38 @@ var SqliteJournal = class {
       const result = this.#db.prepare(
         `UPDATE actions SET status = 'rolling_back' WHERE id = ? AND status IN (${slots})`
       ).run(actionId, ...from);
-      return result.changes === 1;
+      if (result.changes !== 1) {
+        return false;
+      }
+      this.#db.prepare(
+        `INSERT INTO leases (action_id, host, pid, claimed_at) VALUES (?, ?, ?, ?)
+             ON CONFLICT(action_id) DO UPDATE SET host = excluded.host,
+               pid = excluded.pid, claimed_at = excluded.claimed_at`
+      ).run(actionId, hostname(), process.pid, (/* @__PURE__ */ new Date()).toISOString());
+      return true;
     });
   }
+  leaseFor(actionId) {
+    return this.#run("leaseFor", () => {
+      const raw = this.#db.prepare("SELECT * FROM leases WHERE action_id = ?").get(actionId);
+      if (raw === void 0) {
+        return void 0;
+      }
+      const row = leaseSchema.parse(raw);
+      return {
+        host: row.host,
+        pid: row.pid,
+        claimedAt: row.claimed_at,
+        alive: row.host === hostname() ? running(row.pid) : void 0
+      };
+    });
+  }
+  /** Releases a claim. Safe to call when there is none. */
+  #release(actionId) {
+    this.#db.prepare("DELETE FROM leases WHERE action_id = ?").run(actionId);
+  }
   markRolledBack(actionId) {
+    this.#release(actionId);
     this.#settle("markRolledBack", actionId, "rolled_back", [
       "rolling_back",
       "applied",
@@ -652,6 +780,7 @@ var SqliteJournal = class {
    * was briefly unwell, and rollback is expected to be retried (D7).
    */
   markInverseRejected(actionId, error) {
+    this.#release(actionId);
     this.#settle("markInverseRejected", actionId, "applied", ["rolling_back"], error);
   }
   /**
@@ -724,6 +853,12 @@ var SqliteJournal = class {
       return move.immediate();
     });
   }
+  listPending() {
+    return this.#run(
+      "listPending",
+      () => this.#db.prepare("SELECT * FROM actions WHERE status = 'pending' ORDER BY ts").all().map(toAction)
+    );
+  }
   listGated() {
     return this.#run(
       "listGated",
@@ -739,8 +874,7 @@ var SqliteJournal = class {
               AND approved_at >= ?
             ORDER BY approved_at DESC`
       ).all(query.server, query.tool, query.notBefore).map(toAction);
-      const wanted = canonical(query.args ?? {});
-      return rows.find((row) => canonical(row.args) === wanted);
+      return sameCall(rows, query.args);
     });
   }
   findGated(query) {
@@ -750,8 +884,7 @@ var SqliteJournal = class {
             WHERE run_id = ? AND server = ? AND tool = ? AND status = 'gated'
             ORDER BY seq`
       ).all(query.runId, query.server, query.tool).map(toAction);
-      const wanted = canonical(query.args ?? {});
-      return rows.find((row) => canonical(row.args) === wanted);
+      return sameCall(rows, query.args);
     });
   }
   findPending(query) {
@@ -761,8 +894,7 @@ var SqliteJournal = class {
             WHERE run_id = ? AND server = ? AND tool = ? AND status = 'pending'
             ORDER BY seq`
       ).all(query.runId, query.server, query.tool).map(toAction);
-      const wanted = canonical(query.args ?? {});
-      return rows.find((row) => canonical(row.args) === wanted);
+      return sameCall(rows, query.args);
     });
   }
   getAction(actionId) {
@@ -827,6 +959,30 @@ var SqliteJournal = class {
       return tally;
     });
   }
+  standingPerRun() {
+    return this.#run("standingPerRun", () => {
+      const standing2 = /* @__PURE__ */ new Map();
+      const count = (sql, field) => {
+        for (const raw of this.#db.prepare(sql).all()) {
+          const row = countedSchema.parse(raw);
+          const at = standing2.get(row.run_id) ?? { undoable: 0, conflicted: 0 };
+          at[field] = row.n;
+          standing2.set(row.run_id, at);
+        }
+      };
+      count(
+        `SELECT run_id, COUNT(*) AS n FROM actions INDEXED BY actions_undoable
+          WHERE status = 'applied' AND inverse_json IS NOT NULL GROUP BY run_id`,
+        "undoable"
+      );
+      count(
+        `SELECT run_id, COUNT(*) AS n FROM actions INDEXED BY actions_conflicted
+          WHERE status = 'unrecoverable' AND inverse_json IS NOT NULL GROUP BY run_id`,
+        "conflicted"
+      );
+      return standing2;
+    });
+  }
   /**
    * The newest run that still holds something an undo would put back.
    *
@@ -2015,4 +2171,4 @@ export {
   observeState,
   connectStdioUpstream
 };
-//# sourceMappingURL=chunk-FIOKOIT6.js.map
+//# sourceMappingURL=chunk-JE7MOCZO.js.map

package/dist/cli.js

@@ -39,7 +39,7 @@ import {
   verifyAgainstServers,
   warnUntested,
   wasRefused
-} from "./chunk-FIOKOIT6.js";
+} from "./chunk-JE7MOCZO.js";
 import {
   DriftConflict,
   ManifestError,
@@ -366,6 +366,15 @@ var toolResult = z2.looseObject({ isError: z2.boolean().default(false) });
 function sameState(a, b) {
   return canonical(a) === canonical(b);
 }
+function held(lease) {
+  if (lease === void 0) {
+    return "No lease is recorded against it, so it was claimed by a build from before leases existed and there is no way from here to tell a live owner from a dead one. ";
+  }
+  if (lease.alive === void 0) {
+    return `It was claimed by process ${String(lease.pid)} on ${lease.host} at ${lease.claimedAt}, and this is not that machine, so whether it is still running cannot be asked from here. `;
+  }
+  return `It is held by process ${String(lease.pid)} on ${lease.host}, claimed at ${lease.claimedAt}, and that process is still running. `;
+}
 function classify(action, replanning, goAhead) {
   switch (action.status) {
     case "rolled_back":
@@ -436,6 +445,14 @@ async function rollback(options) {
   let leftInPlace = false;
   const projected = /* @__PURE__ */ new Map();
   for (const action of inScope) {
+    if (options.interrupt?.aborted === true) {
+      halted = {
+        seq: action.seq,
+        reason: "interrupted, so this and everything before it were left as they are",
+        detail: "Nothing was half applied: the stop was taken between actions. Run undo again to carry on."
+      };
+      break;
+    }
     let forcedOver;
     if (action.class === "readonly") {
       steps.push({ ...describeStep(action), kind: "skip", reason: "readonly", verified: true });
@@ -574,14 +591,20 @@ ${seen}` : seen;
     if (dryRun) {
       continue;
     }
-    const claimable = force || policies !== void 0 ? ["applied", "unrecoverable"] : ["applied"];
+    const lease = action.status === "rolling_back" ? journal.leaseFor(action.id) : void 0;
+    const abandoned = verified && lease?.alive === false;
+    const claimable = [
+      "applied",
+      ...force || policies !== void 0 ? ["unrecoverable"] : [],
+      ...abandoned ? ["rolling_back"] : []
+    ];
     const claimed = journal.markRollingBack(action.id, claimable);
     if (!claimed) {
-      const reason = action.status === "rolling_back" ? "an inverse for this action was already sent and never finished; whether another undo still holds it cannot be told from here" : "another undo is already working on this action";
+      const reason = action.status === "rolling_back" ? "an inverse for this action was already sent and never finished, and the undo that sent it is still running" : "another undo is already working on this action";
       halted = {
         seq: action.seq,
         reason,
-        detail: action.status === "rolling_back" ? "Nothing here can tell a live owner from a dead one, and this build has no lease to consult. Read the action with `show --live`: if the resource still shows the agent's write, the inverse never landed." : ""
+        detail: action.status === "rolling_back" ? held(lease) + "Read the action with `show --live`: if the resource still shows the agent's write, the inverse never landed." : ""
       };
       steps[steps.length - 1] = {
         ...describeStep(action),
@@ -2099,36 +2122,28 @@ function runsView(journal, screen, options) {
     ];
   }
   const at = Math.min(screen.cursor, runs.length - 1);
+  const tally2 = journal.tallyRuns();
   return runs.map((run, index) => {
-    const actions = journal.getActions(run.id);
-    const held = actions.filter((action) => action.status === "gated").length;
+    const counts = tally2.get(run.id);
+    const total = counts?.actions ?? 0;
+    const held2 = counts?.waiting ?? 0;
     const here = index === at && canPress(options);
     const name = (run.label ?? "an agent").padEnd(24);
-    const note = held === 0 ? "" : `  ${style.accent(`${String(held)} awaiting approval`)}`;
-    return `  ${here ? style.accent(CURSOR) : " "} ${here ? style.accent(name) : style.strong(name)} ${style.quiet(shortTime(run.startedAt).trimEnd().padEnd(13))}  ${style.quiet(run.status.padEnd(11))} ${style.quiet(counted(actions.length, "action"))}${note}`;
+    const note = held2 === 0 ? "" : `  ${style.accent(`${String(held2)} awaiting approval`)}`;
+    return `  ${here ? style.accent(CURSOR) : " "} ${here ? style.accent(name) : style.strong(name)} ${style.quiet(shortTime(run.startedAt).trimEnd().padEnd(13))}  ${style.quiet(run.status.padEnd(11))} ${style.quiet(counted(total, "action"))}${note}`;
   });
 }
-function standing2(actions) {
-  let undoable = 0;
-  let conflicted = 0;
-  for (const action of actions) {
-    if (action.inverse === void 0) {
-      continue;
-    }
-    if (action.status === "applied") {
-      undoable += 1;
-    } else if (action.status === "unrecoverable") {
-      conflicted += 1;
-    }
-  }
-  return { undoable, conflicted };
+var NOTHING = { undoable: 0, conflicted: 0 };
+function standing2(journal, runId) {
+  return journal.standingPerRun().get(runId) ?? NOTHING;
 }
 function elsewhere(journal, exceptId) {
+  const perRun = journal.standingPerRun();
   for (const run of [...journal.listRuns()].reverse()) {
     if (run.id === exceptId) {
       continue;
     }
-    const found = standing2(journal.getActions(run.id));
+    const found = perRun.get(run.id) ?? NOTHING;
     if (found.undoable > 0 || found.conflicted > 0) {
       return run;
     }
@@ -2369,7 +2384,7 @@ async function openConsole(options) {
     if (run === void 0) {
       return [];
     }
-    const here = standing2(ready.getActions(run.id));
+    const here = standing2(ready, run.id);
     const id = run.id.slice(0, 8);
     if (here.undoable > 0) {
       return [
@@ -2590,7 +2605,7 @@ async function openConsole(options) {
         if (ready === void 0 || run === void 0) {
           return;
         }
-        const here = standing2(ready.getActions(run.id));
+        const here = standing2(ready, run.id);
         if (here.undoable === 0 && here.conflicted === 0) {
           say(nothingToUndo(ready, run));
           return;
@@ -2612,7 +2627,7 @@ async function openConsole(options) {
         if (ready === void 0 || run === void 0) {
           return;
         }
-        const here = standing2(ready.getActions(run.id));
+        const here = standing2(ready, run.id);
         if (here.undoable === 0 && here.conflicted === 0) {
           say(nothingToUndo(ready, run));
           return;
@@ -2786,6 +2801,7 @@ var COMMANDS = `
   synartesis watch [--by <name>] [--journal <path>]
   synartesis approve [actionId|--all] [--by <name>] [--journal <path>]
   synartesis deny [actionId|--all] [--by <name>] [--reason <text>] [--journal <path>]
+  synartesis resolve [actionId] --applied|--failed [--by <name>] [--reason <text>]
   synartesis undo [runId] [--to <seq>] [--dry-run] [--replan] [--force [--yes]]
                           [--manifest <path>] [--journal <path>]
 
@@ -2801,6 +2817,14 @@ this command. Both share one journal, so either can undo what the other did.
 close ends a run left active by a proxy that was killed; nothing guesses at
 that, since several proxies can share one journal.
 
+resolve settles a call whose outcome was never established -- a proxy killed
+mid-write, or a server that answered too late. undo stops at one of those
+rather than guess, and stopping there used to be permanent: it blocked
+everything older in the same run. Only a person can say which way it went, so
+this records that they said it, and who. An action resolved as applied still
+has no inverse, so undo will report it as something it cannot put back and
+carry on with the rest.
+
 prune reclaims space. Putting a file back means keeping what was in it, so a
 journal grows at several times what an agent writes and never shrinks by
 itself. Nothing still active or still waiting on a person is ever pruned.
@@ -2829,6 +2853,8 @@ resource back as the run left it and --replan, or --force to overwrite.
   --once      watch prints the current state and exits
   --json      machine-readable output for list, show and gates
   --dry-run   read current state and print the plan without changing anything
+  --applied   resolve: the call did land, though nothing recorded it
+  --failed    resolve: the call never landed
   --replan    rebuild each undo from the current manifest, for a run recorded
               under a policy that turned out to be wrong
   --force     undo even where the resource changed after the run. On its own it
@@ -3010,7 +3036,7 @@ async function runCheck(argv) {
   out(`  ${style.quiet("guarded ")} ${style.accent(String(gated))}`);
   const pinned = Object.entries(manifest.pins ?? {});
   const servers = Object.keys(manifest.servers);
-  const unpinned = servers.filter((name) => !pinned.some(([held]) => held === name));
+  const unpinned = servers.filter((name) => !pinned.some(([held2]) => held2 === name));
   out(
     `  ${style.quiet("pinned  ")} ${pinned.length === 0 ? style.quiet("nothing -- run `synartesis pin`") : pinned.map(([name, tools]) => `${name} (${String(Object.keys(tools).length)})`).join(", ") + (unpinned.length === 0 ? "" : style.quiet(`; not ${unpinned.join(", ")}`))}`
   );
@@ -3330,6 +3356,7 @@ ${listed(matches)}`,
 }
 var RUN = { one: "run", many: "runs" };
 var WAITING = { one: "action awaiting approval", many: "actions awaiting approval" };
+var UNSETTLED = { one: "action whose outcome is unknown", many: "actions whose outcome is unknown" };
 process.stdout.on("error", (error) => {
   if (error.code === "EPIPE") {
     process.exit(0);
@@ -3736,6 +3763,52 @@ function runPrune(argv, journal, journalPath) {
   out("");
   return 0;
 }
+function runResolve(argv, journal) {
+  const applied = argv.includes("--applied");
+  const failed = argv.includes("--failed");
+  if (applied === failed) {
+    throw new UsageError(
+      "resolve needs exactly one of --applied (the call landed) or --failed (it never did)"
+    );
+  }
+  const by = flag(argv, "--by") ?? process.env["USER"] ?? process.env["LOGNAME"] ?? "unknown";
+  const why = flag(argv, "--reason");
+  const given = positional(argv)[1];
+  if (given !== void 0) {
+    const already = journal.getAction(given);
+    if (already !== void 0 && already.status !== "pending") {
+      process.stderr.write(
+        `synartesis: ${given} is not waiting to be resolved (it is ${labelFor(already)})
+`
+      );
+      return 1;
+    }
+  }
+  const action = pick(journal.listPending(), given, UNSETTLED);
+  const outcome = applied ? "applied" : "failed";
+  const note = `resolved as ${outcome} by ${by}` + (why === void 0 ? "" : `: ${why}`);
+  if (!journal.settleByHand(action.id, outcome, note)) {
+    const now = journal.getAction(action.id);
+    process.stderr.write(
+      `synartesis: ${action.id} was settled by the proxy first (it is ${now?.status ?? "gone"})
+`
+    );
+    return 1;
+  }
+  out("");
+  out(
+    `  ${style.accent(outcome)} ${style.strong(`${action.server}.${action.tool}`)} ${style.quiet(action.id.slice(0, 8))}`
+  );
+  out("");
+  out(
+    `  ${style.quiet(
+      applied ? "Undo will now pass it, and report it as something it cannot put back:" : "Undo will now pass it, as a call that never applied:"
+    )}`
+  );
+  out(`  ${style.strong(`${cliCommand()} undo ${action.runId.slice(0, 8)}`)}`);
+  out("");
+  return 0;
+}
 function runClose(argv, journal) {
   const all = journal.listRuns();
   const given = positional(argv)[1];
@@ -3970,6 +4043,22 @@ async function withUpstreams(manifestPath, use, only) {
     }
   }
 }
+function stopOnInterrupt() {
+  const stopping = new AbortController();
+  let asked = false;
+  for (const sign of ["SIGINT", "SIGTERM"]) {
+    process.once(sign, () => {
+      if (asked) {
+        process.exit(130);
+      }
+      asked = true;
+      stopping.abort();
+      out("");
+      out(`  ${style.quiet("stopping after this action; press again to stop now")}`);
+    });
+  }
+  return stopping.signal;
+}
 function serversUsedBy(journal, runId) {
   return new Set(journal.getActions(runId).map((action) => action.server));
 }
@@ -3983,7 +4072,8 @@ async function performUndo(manifestPath, journal, runId, options) {
       ...options.toSeq === void 0 ? {} : { toSeq: options.toSeq },
       ...options.replan === true ? { replanWith: manifest } : {},
       dryRun: options.dryRun,
-      ...options.force === true ? { force: true } : {}
+      ...options.force === true ? { force: true } : {},
+      interrupt: stopOnInterrupt()
     }),
     // A replan re-resolves inverses from the current policy, which may name a
     // server this run never used; everything else needs only what it touched.
@@ -3994,11 +4084,20 @@ async function runUndo(argv, journal) {
   const rawTo = flag(argv, "--to");
   const toSeq = rawTo === void 0 ? void 0 : Number(rawTo);
   if (toSeq !== void 0 && (!Number.isInteger(toSeq) || toSeq < 1)) {
-    throw new UsageError("--to needs a positive whole number");
+    throw new UsageError("--to needs a positive whole number", false);
   }
   const given = positional(argv)[1];
   const chosen = pick([...journal.listRuns()].reverse(), given, RUN, true);
   const runId = chosen.id;
+  if (journal.getRun(runId)?.status === "active" && !argv.includes("--yes") && !argv.includes("--dry-run")) {
+    throw new UsageError(
+      `${runId.slice(0, 8)} has not ended, so an agent may still be writing to it.
+  See what an undo would do:  ${cliCommand()} undo ${runId.slice(0, 8)} --dry-run
+  If its proxy is gone:       ${cliCommand()} close ${runId.slice(0, 8)}
+  Undo it anyway:             ${cliCommand()} undo ${runId.slice(0, 8)} --yes`,
+      false
+    );
+  }
   if (given === void 0) {
     const actions = journal.getActions(runId);
     const left = actions.filter(
@@ -4118,6 +4217,7 @@ var KNOWN_COMMANDS = [
   "watch",
   "approve",
   "deny",
+  "resolve",
   "undo",
   "help",
   "version"
@@ -4141,6 +4241,9 @@ var FLAGS = /* @__PURE__ */ new Set([
   "--dry-run",
   "--replan",
   "--reason",
+  // resolve: which way the unknown outcome actually went.
+  "--applied",
+  "--failed",
   "--force",
   "--yes",
   "--older-than",
@@ -4314,6 +4417,8 @@ ${COMMANDS}`);
         return runPrune(argv, journal, journalPath);
       case "gates":
         return runGates(journal, asJson);
+      case "resolve":
+        return runResolve(argv, journal);
       case "approve":
         return runDecision(argv, journal, true);
       case "deny":

package/dist/proxy.js

@@ -25,7 +25,7 @@ import {
   verifyAgainstServers,
   warnUntested,
   withIdempotencyKey
-} from "./chunk-FIOKOIT6.js";
+} from "./chunk-JE7MOCZO.js";
 import {
   SnapshotError,
   UpstreamError,
@@ -256,12 +256,19 @@ import { z } from "zod";
 
 // src/gate/heuristic.ts
 var READ_ONLY = /^(select|with|show|explain|describe|desc|values|table)\b/;
+var WRITES = /\b(insert|update|delete|merge|upsert|replace|truncate|drop|alter|create|grant|revoke|vacuum|attach|detach|reindex|call|do|copy|lock|pragma|into)\b/;
+function code(text) {
+  return text.replace(/--[^\n]*/g, " ").replace(/\/\*[\s\S]*?\*\//g, " ").replace(/'(?:[^']|'')*'/g, " ").replace(/"(?:[^"]|"")*"/g, " ").trim();
+}
 function isReadOnlyStatement(text) {
-  const stripped = text.replace(/--[^\n]*/g, " ").replace(/\/\*[\s\S]*?\*\//g, " ").trim();
+  const stripped = code(text);
   if (!READ_ONLY.test(stripped.toLowerCase())) {
     return false;
   }
-  return stripped.replace(/;\s*$/, "").indexOf(";") === -1;
+  if (stripped.replace(/;\s*$/, "").indexOf(";") !== -1) {
+    return false;
+  }
+  return !WRITES.test(stripped.toLowerCase());
 }
 function shouldGateOnWrite(args) {
   if (typeof args !== "object" || args === null) {
@@ -344,8 +351,8 @@ function neverDispatched(error) {
   if (message.includes("Not connected")) {
     return true;
   }
-  const code = isRecord(error) ? error["code"] : void 0;
-  return code === ErrorCode.MethodNotFound || code === ErrorCode.InvalidParams || code === ErrorCode.InvalidRequest || code === ErrorCode.ParseError;
+  const code2 = isRecord(error) ? error["code"] : void 0;
+  return code2 === ErrorCode.MethodNotFound || code2 === ErrorCode.InvalidParams || code2 === ErrorCode.InvalidRequest || code2 === ErrorCode.ParseError;
 }
 var SYNARTESIS_INSTRUCTIONS = [
   "These tools are guarded by Synartesis, which records every change so it can be undone later.",
@@ -1078,7 +1085,7 @@ function createProxyServer(options) {
   server.onclose = () => {
     connected = false;
     if (runId !== void 0) {
-      journal.endRun(runId, "complete");
+      journal.endRun(runId, "complete", ["active"]);
       runId = void 0;
     }
     previousOnClose?.();
@@ -1259,7 +1266,7 @@ async function main() {
   }
   const proxy = build();
   let shuttingDown = false;
-  const shutdown = (code) => {
+  const shutdown = (code2) => {
     if (shuttingDown) {
       return;
     }
@@ -1274,7 +1281,7 @@ async function main() {
         await upstream.close();
       }
       journal.close();
-      process.exit(code);
+      process.exit(code2);
     })();
   };
   process.on("SIGINT", () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "synartesis",
-  "version": "0.8.4",
+  "version": "0.8.6",
   "description": "An undo layer for AI agents.",
   "type": "module",
   "private": false,