synartesis 0.6.18 → 0.6.20

package/CHANGELOG.md

@@ -2,6 +2,61 @@
 
 What changed, and why it mattered. Dates are release dates.
 
+## 0.6.20 — 2026-09-15
+
+### Fixed
+
+- **The undo preview showed a write nobody confirmed as one that was
+  confirmed.** A tool call can land and then fail to say so -- the server
+  writes the record and times out, or answers with an error on its way out.
+  Synartesis already handled this correctly: it refuses to read `isError` as a
+  promise that nothing happened, reads the resource back, and records the
+  change so it stays recoverable. What it did not do was say so afterwards.
+  The row that came out of that path carried no trace of it at all -- the
+  refusal was written to the log, which nobody reads, at the moment it
+  happens, which is not the moment it matters -- so `undo --dry-run` printed
+  `revert ... state matches; applying inverse`, character for character what a
+  confirmed write prints. The row now records how it was established, and the
+  preview prints it under the step as `caveat`. Same in the app's
+  `preview_undo`, so a model cannot describe an inferred write to somebody as
+  a confirmed one.
+
+- **A halt that named the consequence and hid the cause.** Where the transport
+  failed and the read-back proved the write had landed, undo correctly stopped
+  rather than reverting on an unverified assumption -- but said only "the
+  post-state was never captured, so drift could not be ruled out", which reads
+  as a missed reading. The reason there was no reading, which the row knew all
+  along, is now printed with it.
+
+- An action whose outcome is unknown was told it got that way because "the
+  process died mid-call". A timeout, or an error the read-back could not
+  settle, arrives in exactly the same state and was told the same wrong story.
+  It now says what is actually known, and the row's own error says which of
+  them it was.
+
+## 0.6.19 — 2026-09-15
+
+### Fixed
+
+- **Both guides showed output the command no longer produces.** The worked
+  examples of `show` were still the pre-0.6.18 single-line row, and the session
+  lists were still the pre-0.6.17 table of full uuids -- in the runbook, whose
+  pdf had just been rebuilt from that stale text, and in the user guide, whose
+  pdf had not been rebuilt at all, so the two shipped documents disagreed with
+  each other as well as with the terminal. Regenerated from real runs and both
+  pdfs built together.
+
+- **Four tap targets touching on a phone.** A rule added with the last release
+  set `gap:0` on the screenshot tabs, overriding the deliberate `gap:8px` set
+  with the two columns further up the same stylesheet. The buttons carry their
+  own border, so the four of them closed into one block with doubled seams and
+  no separation between adjacent targets. Measured at 375px: they abutted
+  exactly, at x=22 and x=188 across a width of 166.
+
+- `badgeOf` and `statusOf` took a `pad` that defaulted to true, and the one
+  call site of each passes it explicitly -- so the default could never apply,
+  and it was the wrong answer for the ordinary case anyway. Required now.
+
 ## 0.6.18 — 2026-09-15
 
 A pass over the terminal and the site, most of it drafted by another model and

package/dist/cli.js

@@ -375,7 +375,12 @@ function classify(action, replanning, goAhead) {
     case "pending":
       return {
         kind: "halt",
-        reason: "outcome unknown: the process died mid-call, so whether this applied cannot be determined",
+        // Not "the process died mid-call". That is one of the ways a row ends
+        // up here; a server that timed out, or answered with an error the
+        // read-back could not settle, arrives in exactly the same state and is
+        // told the same wrong story. The row's own error says which it was,
+        // and the halt prints it directly underneath.
+        reason: "outcome unknown: the call went out and its outcome was never established, so whether this applied cannot be determined",
         verified: false
       };
     case "gated":
@@ -452,7 +457,14 @@ ${seen}` : seen;
     if (!parsedPlan.success) {
       const approved = action.approvedBy === void 0 ? "" : `, approved by ${action.approvedBy}`;
       const reason = action.class === "irreversible" ? `cannot be undone${approved}; left in place` : `no usable inverse was recorded${action.error === void 0 ? "" : `: ${action.error}`}; left in place`;
-      steps.push({ ...describeStep(action), kind: "permanent", reason, verified: false });
+      const unconfirmed = action.class === "irreversible" ? caveat(action) : void 0;
+      steps.push({
+        ...describeStep(action),
+        kind: "permanent",
+        reason,
+        verified: false,
+        ...unconfirmed === void 0 ? {} : { note: unconfirmed }
+      });
       leftInPlace = true;
       continue;
     }
@@ -517,13 +529,23 @@ ${seen}` : seen;
     }
     if (!verified && action.class === "reversible" && !force) {
       const reason = unverifiedBecause(action);
+      const because = caveat(action);
       halted = {
         seq: action.seq,
         reason,
-        detail: "Without it there is no way to tell this resource from one somebody has edited since, so the recorded value was not written.",
+        detail: (because === void 0 ? "" : `${because}
+
+`) + "Without it there is no way to tell this resource from one somebody has edited since, so the recorded value was not written.",
         conflict: true
       };
-      steps.push({ ...describeStep(action), kind: "halt", reason, verified: false, plan });
+      steps.push({
+        ...describeStep(action),
+        kind: "halt",
+        reason,
+        verified: false,
+        plan,
+        ...because === void 0 ? {} : { note: because }
+      });
       break;
     }
     if (!verified && action.status === "rolling_back") {
@@ -539,13 +561,15 @@ ${seen}` : seen;
       const after = intendedAfterInverse(action);
       projected.set(resourceKey(toResolvedRead(verifyRead.data)), after ?? UNFORESEEABLE);
     }
+    const recordedWith = caveat(action);
     steps.push({
       ...describeStep(action),
       kind: "revert",
       reason: verified ? "state matches; applying inverse" : forcedOver ?? unverifiedBecause(action),
       verified,
       plan,
-      ...rebuilt.inverse === void 0 ? {} : { replanned: true }
+      ...rebuilt.inverse === void 0 ? {} : { replanned: true },
+      ...recordedWith === void 0 ? {} : { note: recordedWith }
     });
     if (dryRun) {
       continue;
@@ -613,6 +637,9 @@ ${seen}` : seen;
 function unverifiedBecause(action) {
   return action.verify === void 0 ? "no read declared for this tool, so drift could not be ruled out -- a `verify` read in its policy would give it one" : "the post-state was never captured, so drift could not be ruled out";
 }
+function caveat(action) {
+  return action.status === "applied" && action.error !== void 0 && action.error !== "" ? action.error : void 0;
+}
 function describeStep(action) {
   return { seq: action.seq, server: action.server, tool: action.tool };
 }
@@ -3524,12 +3551,12 @@ var CLASS_MARK = {
   unclassified: "?"
 };
 var BADGE_WIDTH = "irreversible".length + 2;
-function badgeOf(action, pad2 = true) {
+function badgeOf(action, pad2) {
   const name = `${CLASS_MARK[action.class]} ${action.class}`;
   const plain = pad2 ? name.padEnd(BADGE_WIDTH) : name;
   return action.class === "irreversible" ? style.accent(plain) : style.quiet(plain);
 }
-function statusOf(action, pad2 = true) {
+function statusOf(action, pad2) {
   const label = labelFor(action);
   const text = pad2 ? label.padEnd(13) : label;
   if (wasRefused(action)) {
@@ -3783,6 +3810,11 @@ function report(result, alreadyForcing = false, as = "") {
     out(
       `  ${style.quiet(String(step.seq).padStart(3))}  ${kind} ${style.strong(`${step.server}.${step.tool}`)}  ${style.quiet(step.reason)}${unverified}`
     );
+    if (step.note !== void 0 && step.kind !== "halt") {
+      for (const [at, line2] of wrapped(step.note, 62).entries()) {
+        out(`       ${at === 0 ? style.accent("caveat") : "      "}  ${style.quiet(line2)}`);
+      }
+    }
     if (step.plan !== void 0 && step.kind === "revert") {
       const verb = `${step.replanned === true ? "replanned, " : ""}${result.dryRun ? "would call" : "called"}`;
       out(

package/dist/proxy.js

@@ -755,6 +755,7 @@ function createProxyServer(options) {
           const result = await route.upstream.client.request(forwarded, PassthroughResult, {
             signal: extra.signal
           });
+          let inferred;
           const refused = refusal(result);
           if (refused !== void 0) {
             const settled = policy.refusal === "clean" ? "none" : await whatHappened(router, probe, priorState, extra.signal);
@@ -774,6 +775,7 @@ function createProxyServer(options) {
               );
               return result;
             }
+            inferred = `the upstream answered with an error and the change was established by reading the resource back, so nothing confirmed it: ${refused}`;
             log?.warn(
               { seq: pending.seq, tool: route.tool, reason: refused },
               "the upstream reported an error after changing the resource"
@@ -781,6 +783,9 @@ function createProxyServer(options) {
           }
           const context = { args, snapshot, result: toPayload(result) };
           const warnings = [];
+          if (inferred !== void 0) {
+            warnings.push(inferred);
+          }
           if (missingPriorState !== void 0) {
             warnings.push(
               `no prior state existed, so there is nothing to restore: ${missingPriorState}`

package/package.json

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