@awebai/oats 0.39.3 → 0.39.4

package/docs/execution-targets.md

@@ -142,9 +142,32 @@ oats session attach --home /abs/home
 - **input** submits UTF-8 text (stdin or `--text-file`, at most 256 KiB, no
   NUL) followed by Enter, as a bracketed paste. The text is never run by a
   shell. A fallback shell, a stopped session or a split
-  tmux window is refused. `submitted: true` means the terminal accepted the
-  text, not that the agent processed it. Wake schedules and messaging
-  capabilities use this command ([schedules.md](schedules.md)).
+  tmux window is refused. The text is pasted once. Enter waits for the pane to
+  settle (two identical captures, at least about 200 ms, longer for a larger
+  paste, at most 2 s), and is judged by whether it changed the bottom 15 lines
+  of the pane. The comparison is of bytes only, and the pane's text is never
+  interpreted. Trailing spaces are ignored. When the pane was seen to change
+  size (a resize, or a second client attaching), a reflow of the same content
+  is not a change either: each side's content must already be on the other
+  side's screen or in its history, so content that appeared or disappeared
+  still counts. An Enter that changed nothing was swallowed, and is resent
+  after a backoff, at most 3 Enters in total. The answer adds:
+  - `submitted: true, verified: true`: an Enter was taken.
+  - `submitted: false, verified: true, reason: "enter-not-taken"`: none of the
+    3 Enters changed the pane. The text stays in the agent's input box; it is
+    not pasted again.
+  - `submitted: true, verified: false`: a capture failed, so no further Enter
+    was sent and the last one was not judged. As before, this means the
+    terminal accepted the keys. When the pane cannot be read before the first
+    resend, exactly one Enter was sent.
+
+  `submitted` never means the agent processed the text. A pane that changes
+  for another reason after Enter (a spinner, a clock, a human typing) reads as
+  taken. A harness that shows no visible reaction to Enter receives up to two
+  extra Enters; real harnesses (claude, codex, pi) redraw on submit. A call takes at most about 4 s plus its tmux calls. A failed paste or
+  key send is `E_SESSION_INPUT_FAILED`, with no retry. Wake schedules and
+  messaging capabilities use this command ([schedules.md](schedules.md)); a
+  wake schedule records any answer as delivered.
 - **attach** is interactive and takes no `--json`. It opens a temporary tmux
   session linked to the agent's window alone.
   Closing the viewer leaves the agent running.

package/docs/release-notes/v0.39.4.md

@@ -0,0 +1,22 @@
+# OATS 0.39.4
+
+## Fixed
+
+- **`oats session input` no longer reports an unsent message as submitted.**
+  After a large bracketed paste, Claude Code could swallow the Enter that
+  followed it at once, leaving the text in the agent's input box until someone
+  pressed Enter, while the command answered `submitted: true` (#562). Enter
+  now waits for the pane to settle, and is judged by whether it changed the
+  bottom of the pane. This is a byte comparison that ignores trailing spaces,
+  and also ignores a reflow when the pane was seen to change size, as when
+  OATS Desktop attaches. The pane's text is never interpreted. A swallowed
+  Enter is resent with a backoff, at most 3 in total, and the text is never
+  pasted again. The answer gains `verified`: `true` when the comparison
+  judged the Enter, `false` when a capture failed (then no further Enter is
+  sent, and `submitted: true` keeps its old meaning). When no Enter is taken
+  the answer is `submitted: false, verified: true, reason: "enter-not-taken"`;
+  a consumer that requires `submitted: true`, such as the aw wake broker, then
+  reports a failed delivery instead of a silent one. A harness that shows no
+  visible reaction to Enter receives up to two extra Enters; real harnesses
+  (claude, codex, pi) redraw on submit. A call now takes up to about 4 s. See
+  [execution targets](../execution-targets.md).

package/lib/session-input.mjs

@@ -49,18 +49,104 @@ export function inspectSessionTarget(target, io) {
   }
   return { backend: "tmux", present: dead === "0", state, paneId };
 }
+// Submit verification (#562). A harness can swallow an Enter that lands while
+// it is still handling a large bracketed paste, leaving the text unsent in its
+// input box. So the pane is left to settle before Enter, and Enter is judged by
+// whether it changed the bottom of the screen: a byte comparison only, never a
+// reading of any harness's UI, and the pane's text is never acted on.
+const SETTLE_FLOOR_MS = 200, SETTLE_MS_PER_KIB = 3, SETTLE_CAP_MS = 2000, SETTLE_POLL_MS = 100;
+const VERIFY_MS = 300, RESEND_BACKOFF_MS = [300, 600]; // at most 3 Enters in total
+const REGION_LINES = 15, HISTORY_LINES = 200;
+const GEOMETRY = "#{pane_width}x#{pane_height}";
+const realSleep = (ms) => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+/** One look at the pane, or null when it cannot be read: `region`, the bottom
+ *  15 lines of the visible pane (trailing blank rows dropped, and each line's
+ *  trailing spaces, which a redraw pads differently); `all`, the
+ *  visible pane with up to 200 lines of history above it; and `size`, the
+ *  pane's geometry, read before and after the capture in the same tmux call
+ *  (null when it moved in between). */
+function capturePane(target, paneId, io) {
+  try {
+    const lines = tmux(target, ["display-message", "-p", "-t", paneId, GEOMETRY, ";",
+      "capture-pane", "-p", "-J", "-t", paneId, "-S", `-${HISTORY_LINES}`, ";",
+      "display-message", "-p", "-t", paneId, GEOMETRY], io).split("\n");
+    if (lines.at(-1) === "") lines.pop();
+    const first = lines.shift(), last = lines.pop();
+    if (!/^\d+x\d+$/.test(first) || !/^\d+x\d+$/.test(last)) return null;
+    for (let i = 0; i < lines.length; i++) lines[i] = lines[i].trimEnd();
+    while (lines.length && !lines.at(-1)) lines.pop();
+    return { size: first === last ? first : null, region: lines.slice(-REGION_LINES).join("\n"), all: lines.join("\n") };
+  } catch { return null; }
+}
+const sameLook = (a, b) => a.size === b.size && a.region === b.region;
+/** Width-independent text: each run of one box-drawing character kept as one,
+ *  so a rule of any length reads the same, then whitespace dropped. Runs are
+ *  collapsed first, so a glyph is never merged with a rule on the next line. */
+const flat = (text) => text.replace(/([\u2500-\u257f])\1+/g, "$1").replace(/\s+/g, "");
+/** Whether the pane after Enter shows what it showed before. On a pane of the
+ *  same size this is exact bytes. Only when its size was seen to change (a
+ *  resize, a second client attaching) is a reflow allowed for: then the two
+ *  bottom regions must agree at the bottom, and each must already be present,
+ *  width aside, in the other's capture with history, so content that appeared
+ *  or disappeared still reads as a change. */
+function unchanged(a, b) {
+  if (a.size !== null && a.size === b.size) return a.region === b.region;
+  const x = flat(a.region), y = flat(b.region);
+  if (!x || !y) return x === y;
+  return (x.endsWith(y) || y.endsWith(x)) && flat(b.all).includes(x) && flat(a.all).includes(y);
+}
+/** Paste `text` and submit it with Enter. Answers `submitted` (the Enter was
+ *  taken, or sent unjudged) and `verified` (whether the screen comparison
+ *  judged it); `reason: "enter-not-taken"` only with `submitted: false`. A
+ *  failed paste or key send throws; a failed capture never does. */
 export function inputSessionTarget(target, text, io) {
   const state = inspectSessionTarget(target, io);
   if (!state.present || state.state === "shell") throw new Error(`cannot submit input: session is ${state.state}`);
+  const sleep = io?.sleep || realSleep, now = io?.now || Date.now;
   // Bracketed paste preserves multiline input as one user message. No text
   // is evaluated by a shell or interpreted as tmux key names.
   const buffer = `oats-${randomUUID()}`;
   try {
     tmux(target, ["load-buffer", "-b", buffer, "-"], { ...io, input: text });
     tmux(target, ["paste-buffer", "-p", "-b", buffer, "-t", state.paneId], io);
-    tmux(target, ["send-keys", "-t", state.paneId, "Enter"], io);
   } finally {
     try { tmux(target, ["delete-buffer", "-b", buffer], io); } catch { /* already consumed or disconnected */ }
   }
-  return { ...state, submitted: true };
+  const enter = () => tmux(target, ["send-keys", "-t", state.paneId, "Enter"], io);
+  // Settle: wait a floor scaled by paste size, then until two consecutive
+  // captures are identical, giving up at the cap. The last capture is A.
+  const started = now();
+  sleep(Math.min(SETTLE_CAP_MS, SETTLE_FLOOR_MS + Math.ceil(Buffer.byteLength(text) / 1024) * SETTLE_MS_PER_KIB));
+  let before = capturePane(target, state.paneId, io);
+  while (before !== null && now() - started < SETTLE_CAP_MS) {
+    sleep(SETTLE_POLL_MS);
+    const next = capturePane(target, state.paneId, io);
+    const settled = next !== null && sameLook(next, before);
+    before = next;
+    if (settled) break;
+  }
+  enter();
+  // An unreadable pane gets no further keys: the terminal accepted them, unjudged.
+  if (before === null) return { ...state, submitted: true, verified: false };
+  // Changed content means the Enter was taken (or the pane moved for an
+  // unrelated reason, such as a spinner, a clock or a human typing: read as
+  // taken, no worse than not looking). Unchanged content means it was
+  // swallowed: any reaction, a dialog included, would have changed it, so a
+  // resend is safe. A reflow alone, on a pane seen to change size, is not a
+  // change. The screen is looked at again after each backoff, so an Enter
+  // taken late is not followed by another. A capture that fails stops the
+  // retries: no further Enter is sent.
+  for (let enters = 1; ; enters++) {
+    for (const wait of [VERIFY_MS, RESEND_BACKOFF_MS[enters - 1]]) {
+      if (wait === undefined) break;
+      sleep(wait);
+      const after = capturePane(target, state.paneId, io);
+      if (after === null) return { ...state, submitted: true, verified: false };
+      if (!unchanged(before, after)) return { ...state, submitted: true, verified: true };
+    }
+    if (enters > RESEND_BACKOFF_MS.length) break;
+    enter();
+  }
+  // The text stays in the input box; it is never pasted again.
+  return { ...state, submitted: false, verified: true, reason: "enter-not-taken" };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awebai/oats",
-  "version": "0.39.3",
+  "version": "0.39.4",
   "description": "OATS (Open Agent Team Specification) — durable souls, disposable instances, targetable capability packages, and the runtime-neutral oats CLI/kernel.",
   "keywords": [
     "agents",