synartesis 0.9.0 → 0.9.1

package/CHANGELOG.md

@@ -2,6 +2,69 @@
 
 What changed, and why it mattered. Dates are release dates.
 
+## 0.9.1 — 2026-09-24
+
+This release attacks undo instead of describing it. The new tests generate the
+agent sessions rather than script them, kill undo with SIGKILL partway through,
+and race several agents against one approval. They found five bugs that no
+hand-written scenario had reached.
+
+### Fixed
+
+- **An undo that succeeded could be stuck for good.** A server that applies an
+  inverse and then fails before answering (a crashed handler, a gateway timeout)
+  was read as having refused it. The next attempt found the resource already put
+  back, called that drift, and every attempt after that refused on it. Undo now
+  reads the resource when an inverse errors, and counts it as done when the
+  resource is where that inverse puts it.
+- **An undo killed at the wrong moment could block that action for ever.**
+  Claiming an action and recording which process holds it were two separate
+  writes, though the code's own comment said they were one transaction. A kill
+  between them left an action claimed by nobody, which no later undo could tell
+  from one still in progress. They are now one transaction.
+- **An undo killed while compensating stopped on its own success.** The delete
+  that undoes a create went through, and the resumed undo called the record's
+  absence drift. It now recognises it, but only when the owner is certainly
+  gone and the record is certainly gone. An edit a person made instead still
+  stops it.
+- **Running `install` from your home directory covered servers twice.** There,
+  a client's project config and its global one are the same file. It was listed
+  twice, and every server in it was drafted into the policy a second time under
+  another name.
+- **"Covered, nothing through it yet" about a server in daily use.** The connect
+  screen looked up the last use under the client entry's name, not the name the
+  policy gives the server, and those differ when two clients list a server with
+  the same name.
+- **A policy reading a field every object inherits** (`constructor`,
+  `toString`) resolved to nothing when the record lacked it, instead of saying
+  it was absent. The inverse then quietly left that field out of what it
+  restored.
+
+### Faster
+
+- **Servers start together.** Every path that starts more than one server
+  (a proxy serving several, `undo`, `check`, `pin`) waited for each before
+  starting the next. Three servers that take 800 ms each answered after 2.9 s;
+  now it is under 1.6 s, and the order they are reported in is unchanged.
+- **Each server's tools are listed once at start-up**, not three times.
+
+### Tests
+
+- `tests/stress-undo.test.ts`: random sessions with awkward values (unicode,
+  5,000-character strings, `__proto__`, text that looks like a template), undone
+  through injected crashes before and after writes, undone to random steps, and
+  with a person's edit that must survive.
+- `tests/kill-undo.test.ts`: `synartesis undo` killed with SIGKILL the moment a
+  random number of actions have been undone, again and again, with a real server
+  and store.
+- `tests/race-approval.test.ts`: eight separate agent processes retrying one
+  approved email in the same instant. Exactly one is sent.
+- Direct tests for the code only child processes reached before: which clients
+  are covered, the environment an undo starts a server with, and the Linux
+  notifier.
+- `pnpm stress` runs all three at full strength; `pnpm coverage` reports what
+  the suite reaches.
+
 ## 0.9.0 — 2026-09-24
 
 0.8.4 to 0.8.8 made Synartesis correct once you were using it. This release is

package/README.md

@@ -609,6 +609,18 @@ pnpm check
 Every push runs that on Linux and macOS across Node 22 and 24, plus both demos,
 the installer, and a build of the desktop app.
 
+```bash
+pnpm stress
+```
+
+The same three attacks `check` runs lightly, at full strength: 500 random agent
+sessions, each undone and checked byte for byte against where it started (also
+undone to a random step, and with a person's edit made afterwards that must
+survive); `synartesis undo` killed with SIGKILL at random points 25 times over
+and run again; and eight agents racing one approval, ten times, which must send
+exactly one email. A failure names its seed, and `SYNARTESIS_STRESS_SEED`
+replays it. `pnpm coverage` reports what the suite reaches.
+
 **Windows is built and not tested.** The release attaches a Windows installer,
 and no CI job compiles or exercises it — the test matrix is Linux and macOS. It
 is expected to work, the code has no platform-specific paths outside

package/dist/{chunk-AEEKBR5D.js → chunk-H4SPMXQW.js}

@@ -51,11 +51,10 @@ function launch(command, args) {
   } catch {
   }
 }
-function desktopNotifier(env = process.env) {
+function desktopNotifier(env = process.env, os = platform()) {
   if (env["SYNARTESIS_NOTIFY"] === "0") {
     return SILENT;
   }
-  const os = platform();
   if (os === "darwin") {
     return (notice) => {
       const { title, body } = words(notice);
@@ -901,7 +900,7 @@ var SqliteJournal = class {
    * resource is contested.
    */
   markRollingBack(actionId, from = ["applied"]) {
-    return this.#run("markRollingBack", () => {
+    return this.#run("markRollingBack", () => this.#db.transaction(() => {
       const slots = from.map(() => "?").join(",");
       const result = this.#db.prepare(
         `UPDATE actions SET status = 'rolling_back' WHERE id = ? AND status IN (${slots})`
@@ -915,7 +914,7 @@ var SqliteJournal = class {
                pid = excluded.pid, claimed_at = excluded.claimed_at`
       ).run(actionId, hostname(), process.pid, (/* @__PURE__ */ new Date()).toISOString());
       return true;
-    });
+    }).immediate());
   }
   leaseFor(actionId) {
     return this.#run("leaseFor", () => {
@@ -1530,7 +1529,7 @@ function walk(current, parts, at, reference) {
       return walk(current[segment.index], parts, at + 1, reference);
     }
     case "key": {
-      if (typeof current !== "object" || !(segment.key in current)) {
+      if (typeof current !== "object" || !Object.hasOwn(current, segment.key)) {
         throw new ManifestError(`${reference} is unresolvable: ${segment.key} is absent`);
       }
       const next = Object.getOwnPropertyDescriptor(current, segment.key)?.value;
@@ -2072,6 +2071,11 @@ function explainPins(server, faults) {
 
 // src/manifest/verify.ts
 import { z as z3 } from "zod";
+async function listAll(upstreams) {
+  return new Map(
+    await Promise.all(upstreams.map(async (upstream) => [upstream.name, await toolShapes(upstream)]))
+  );
+}
 var listSchema = z3.looseObject({
   tools: z3.array(
     z3.looseObject({
@@ -2103,11 +2107,11 @@ async function toolShapes(upstream) {
   } while (cursor !== void 0);
   return shapes;
 }
-async function verifyAgainstServers(upstreams, manifest) {
+async function verifyAgainstServers(upstreams, manifest, listed) {
   const shapes = /* @__PURE__ */ new Map();
   const available = /* @__PURE__ */ new Map();
   for (const upstream of upstreams) {
-    const advertised = await toolShapes(upstream);
+    const advertised = listed?.get(upstream.name) ?? await toolShapes(upstream);
     shapes.set(upstream.name, advertised);
     available.set(upstream.name, new Set(advertised.map((tool) => tool.name)));
   }
@@ -2154,10 +2158,11 @@ async function verifyAgainstServers(upstreams, manifest) {
     );
   }
 }
-async function withoutMissingTools(upstreams, manifest) {
+async function withoutMissingTools(upstreams, manifest, listed) {
   const available = /* @__PURE__ */ new Map();
   for (const upstream of upstreams) {
-    available.set(upstream.name, new Set((await toolShapes(upstream)).map((tool) => tool.name)));
+    const advertised = listed?.get(upstream.name) ?? await toolShapes(upstream);
+    available.set(upstream.name, new Set(advertised.map((tool) => tool.name)));
   }
   const missing = (qualified) => {
     const target = splitQualified(qualified);
@@ -2537,6 +2542,31 @@ function refusal(error) {
   }
   return void 0;
 }
+async function startTogether(items, start2) {
+  const settled2 = await Promise.allSettled(
+    items.map(async (item) => ({ item, upstream: await start2(item) }))
+  );
+  const started = [];
+  const failed = [];
+  items.forEach((item, index) => {
+    const result = settled2[index];
+    if (result?.status === "fulfilled") {
+      started.push(result.value.upstream);
+    } else if (result !== void 0) {
+      failed.push({ item, error: result.reason });
+    }
+  });
+  return { started, failed };
+}
+async function startAll(items, start2) {
+  const { started, failed } = await startTogether(items, start2);
+  const first = failed[0];
+  if (first !== void 0) {
+    await Promise.all(started.map((upstream) => upstream.close().catch(() => void 0)));
+    throw first.error;
+  }
+  return started;
+}
 
 // src/install/clients.ts
 import { existsSync as existsSync3, readFileSync as readFileSync2, readdirSync, renameSync, rmSync, unlinkSync, writeFileSync } from "fs";
@@ -2854,7 +2884,15 @@ function discover(cwd) {
       sites.push({ client, label: LABELS[client], format: "json", path, scope, at: ["mcpServers"] });
     }
   }
-  return sites;
+  const seen = /* @__PURE__ */ new Set();
+  return sites.filter((site) => {
+    const key = `${resolve2(site.path)}\0${site.at.join("\0")}`;
+    if (seen.has(key)) {
+      return false;
+    }
+    seen.add(key);
+    return true;
+  });
 }
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -3891,6 +3929,7 @@ export {
   splitQualified,
   fingerprint,
   pinBlock,
+  listAll,
   toolShapes,
   verifyAgainstServers,
   withoutMissingTools,
@@ -3918,6 +3957,8 @@ export {
   differing,
   declaredNames,
   connectUpstream,
+  startTogether,
+  startAll,
   LOOKED_FOR,
   CLIENT_IDS,
   isClientId,
@@ -3932,4 +3973,4 @@ export {
   applyUninstall,
   clientEnvFor
 };
-//# sourceMappingURL=chunk-AEEKBR5D.js.map
+//# sourceMappingURL=chunk-H4SPMXQW.js.map

package/dist/cli.js

@@ -33,6 +33,7 @@ import {
   isClientId,
   isWrapped,
   labelFor,
+  listAll,
   loadManifest,
   observeState,
   openJournal,
@@ -48,6 +49,8 @@ import {
   serversAt,
   splitQualified,
   standing,
+  startAll,
+  startTogether,
   style,
   toPayload,
   toResolvedRead,
@@ -59,7 +62,7 @@ import {
   verifyAgainstServers,
   warnUntested,
   wasRefused
-} from "./chunk-AEEKBR5D.js";
+} from "./chunk-H4SPMXQW.js";
 import {
   DriftConflict,
   ManifestError,
@@ -372,7 +375,11 @@ ${seen}` : seen;
       }
       if (sameState(current, recordedPost.data)) {
         verified = true;
-      } else if (sameState(current, intendedAfterInverse(action))) {
+      } else if (sameState(current, intendedAfterInverse(action)) || // An inverse this undo sent before it was killed, whose owner is gone:
+      // the resource having reached the state it produces is the inverse
+      // having landed. Found by SIGKILLing undo mid-compensation: the delete
+      // had gone through, and every later attempt called its absence drift.
+      action.status === "rolling_back" && journal.leaseFor(action.id)?.alive === false && looksUndone(current, action)) {
         steps.push({
           ...describeStep(action),
           kind: "already-reverted",
@@ -487,6 +494,19 @@ ${seen}` : seen;
       journal.markRolledBack(action.id);
       continue;
     }
+    const landed = outcome.rejected && recordedPost.success && verifyRead.success ? await landedAnyway(router, toResolvedRead(verifyRead.data), recordedPost.data, action, signal) : void 0;
+    if (landed !== void 0) {
+      journal.markRolledBack(action.id);
+      steps[steps.length - 1] = {
+        ...describeStep(action),
+        kind: "revert",
+        reason: landed,
+        verified,
+        plan,
+        note: `the server reported an error (${truncated(outcome.message)}), but the resource had changed as this inverse changes it`
+      };
+      continue;
+    }
     const halt = new RollbackHalted(action.seq, outcome.message);
     if (outcome.rejected) {
       journal.markInverseRejected(action.id, halt.message);
@@ -544,6 +564,28 @@ function overwriteText(current, action) {
   }
   return changedLines(current, intended2);
 }
+async function landedAnyway(router, read, post, action, signal) {
+  let now;
+  try {
+    now = await observeState(router, read, signal);
+  } catch {
+    return void 0;
+  }
+  if (sameState(now, post)) {
+    return void 0;
+  }
+  return looksUndone(now, action) ? "done, despite the server reporting an error" : void 0;
+}
+function looksUndone(now, action) {
+  const intended2 = intendedAfterInverse(action);
+  if (intended2 !== void 0) {
+    return sameState(now, intended2);
+  }
+  return action.class === "compensable" && !now.present;
+}
+function truncated(text) {
+  return text.length > 160 ? `${text.slice(0, 157)}...` : text;
+}
 function intendedAfterInverse(action) {
   return action.snapshot === void 0 ? void 0 : { present: true, value: action.snapshot };
 }
@@ -1278,7 +1320,9 @@ function scan(journal, cwd) {
     }
     const connections = Object.entries(servers).map(([server, entry]) => {
       const covered = isWrapped(entry);
-      const lastSeen = seen.get(server);
+      const args = entry.args ?? [];
+      const named = covered && args.includes("--server") ? args[args.indexOf("--server") + 1] : void 0;
+      const lastSeen = seen.get(named ?? server);
       return {
         client: site.client,
         scope: site.scope,
@@ -2254,14 +2298,16 @@ async function startAsTheClientWould(manifestPath, name, spec, session) {
 async function runPin(argv) {
   const path = findManifest(flag(argv, "--manifest"));
   const manifest = loadManifest(path);
-  const shapes = /* @__PURE__ */ new Map();
+  let shapes = /* @__PURE__ */ new Map();
   const upstreams = [];
   try {
-    for (const [name, spec] of Object.entries(manifest.servers)) {
-      const upstream = await startAsTheClientWould(path, name, spec);
-      upstreams.push(upstream);
-      shapes.set(name, await toolShapes(upstream));
-    }
+    upstreams.push(
+      ...await startAll(
+        Object.entries(manifest.servers),
+        ([name, spec]) => startAsTheClientWould(path, name, spec)
+      )
+    );
+    shapes = await listAll(upstreams);
   } finally {
     for (const upstream of upstreams) {
       await upstream.close();
@@ -2321,13 +2367,17 @@ async function runCheck(argv) {
   const offered = /* @__PURE__ */ new Map();
   const trustedReads = /* @__PURE__ */ new Map();
   try {
-    for (const [name, spec] of Object.entries(manifest.servers)) {
-      upstreams.push(await startAsTheClientWould(path, name, spec));
-    }
-    await verifyAgainstServers(upstreams, manifest);
+    upstreams.push(
+      ...await startAll(
+        Object.entries(manifest.servers),
+        ([name, spec]) => startAsTheClientWould(path, name, spec)
+      )
+    );
+    const listed = await listAll(upstreams);
+    await verifyAgainstServers(upstreams, manifest, listed);
     const resolver = createPolicyResolver(manifest);
     for (const upstream of upstreams) {
-      const shapes = await toolShapes(upstream);
+      const shapes = listed.get(upstream.name) ?? [];
       const trusted = shapes.filter(
         (tool) => tool.readOnly === true && trustsMarks(manifest, upstream.name) && !resolver.resolve(`${upstream.name}.${tool.name}`).matched
       ).map((tool) => tool.name);
@@ -3663,19 +3713,14 @@ function report(result, alreadyForcing = false, as = "") {
 }
 async function withUpstreams(manifestPath, use, only, session) {
   const manifest = loadManifest(manifestPath);
-  const upstreams = [];
-  const missing = [];
+  const wanted = Object.entries(manifest.servers).filter(([name]) => only === void 0 || only.has(name));
+  const { started, failed } = await startTogether(
+    wanted,
+    ([name, spec]) => startAsTheClientWould(manifestPath, name, spec, session)
+  );
+  const upstreams = [...started];
+  const missing = failed.map(({ item: [name], error }) => `${name}: ${describe(error)}`);
   try {
-    for (const [name, spec] of Object.entries(manifest.servers)) {
-      if (only !== void 0 && !only.has(name)) {
-        continue;
-      }
-      try {
-        upstreams.push(await startAsTheClientWould(manifestPath, name, spec, session));
-      } catch (error) {
-        missing.push(`${name}: ${describe(error)}`);
-      }
-    }
     if (upstreams.length === 0 && missing.length > 0) {
       throw new ManifestError(`no server could be started. ${missing.join("; ")}`);
     }

package/dist/proxy.js

@@ -14,6 +14,7 @@ import {
   findManifest,
   fingerprint2 as fingerprint,
   isDisconnected,
+  listAll,
   loadManifest,
   mark,
   observeState,
@@ -23,8 +24,8 @@ import {
   qualify,
   refusal,
   runRead,
+  startAll,
   toPayload,
-  toolShapes,
   trustsMarks,
   ungoverned,
   untested,
@@ -33,7 +34,7 @@ import {
   warnUntested,
   withIdempotencyKey,
   withoutMissingTools
-} from "./chunk-AEEKBR5D.js";
+} from "./chunk-H4SPMXQW.js";
 import {
   SnapshotError,
   UpstreamError,
@@ -1303,8 +1304,8 @@ async function main() {
   const upstreams = [];
   const key = journal.fingerprintKey();
   const startedWith = /* @__PURE__ */ new Map();
+  upstreams.push(...await startAll([...wanted], ([name, spec]) => connectUpstream(name, spec, { env: source })));
   for (const [name, spec] of wanted) {
-    upstreams.push(await connectUpstream(name, spec, { env: source }));
     let client;
     try {
       client = source.kind === "inherit" ? clientEnvFor(argv.manifest, name)?.env : void 0;
@@ -1316,7 +1317,8 @@ async function main() {
       fingerprints: fingerprint(key, upstreamEnv(name, spec, source), declaredNames(spec, client))
     });
   }
-  const { manifest: served, disabled } = await withoutMissingTools(upstreams, manifest);
+  const listed = await listAll(upstreams);
+  const { manifest: served, disabled } = await withoutMissingTools(upstreams, manifest, listed);
   for (const line of disabled) {
     log.warn(line);
   }
@@ -1325,14 +1327,15 @@ async function main() {
     argv.server === void 0 ? served : {
       ...served,
       tools: served.tools.filter((rule) => rule.match.startsWith(`${String(argv.server)}.`))
-    }
+    },
+    listed
   );
   const uncovered = ungoverned(
     served,
-    new Map(await Promise.all(upstreams.map(async (upstream) => [
+    new Map(upstreams.map((upstream) => [
       upstream.name,
-      (await toolShapes(upstream)).filter((tool) => !(tool.readOnly === true && trustsMarks(served, upstream.name))).map((tool) => tool.name)
-    ])))
+      (listed.get(upstream.name) ?? []).filter((tool) => !(tool.readOnly === true && trustsMarks(served, upstream.name))).map((tool) => tool.name)
+    ]))
   );
   for (const entry of uncovered) {
     log.warn(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "synartesis",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "description": "An undo layer for AI agents.",
   "type": "module",
   "private": false,
@@ -58,6 +58,8 @@
     "demo": "tsup --silent && ./demo/filesystem-demo.sh",
     "demo:memory": "tsup --silent && ./demo/memory-demo.sh",
     "check": "pnpm build && pnpm typecheck && pnpm lint && pnpm test",
+    "stress": "tsup --silent && SYNARTESIS_STRESS_SESSIONS=500 SYNARTESIS_KILL_ROUNDS=25 SYNARTESIS_RACE_ROUNDS=10 vitest run tests/stress-undo.test.ts tests/kill-undo.test.ts tests/race-approval.test.ts",
+    "coverage": "tsup --silent && vitest run --testTimeout=240000 --coverage --coverage.provider=v8 --coverage.include='src/**' --coverage.reportOnFailure",
     "prepublishOnly": "pnpm check"
   },
   "dependencies": {
@@ -93,6 +95,7 @@
     "@types/react": "^19.3.0",
     "@types/react-dom": "^19.3.0",
     "@vitejs/plugin-react": "^6.1.1",
+    "@vitest/coverage-v8": "4.1.11",
     "electron": "^44.3.0",
     "electron-builder": "^26.15.3",
     "eslint": "^10.8.1",