@armstrongnate/april 0.1.3 → 0.1.4

package/dist/session/herdr.js

@@ -35,11 +35,45 @@ async function waitForAgentReady(paneId, attempts = 10, intervalMs = 1000) {
     log.warn(`Agent in pane ${paneId} never reported a known status; proceeding anyway`);
 }
 const SUBMIT_SETTLE_MS = 1000;
+const INJECT_ATTEMPTS = 4;
 /** Read a pane's current agent status (undefined if unavailable). */
 async function paneStatus(paneId) {
     const res = await herdrRequest("pane.get", { pane_id: paneId });
     return res.pane?.agent_status;
 }
+/** A status that means the agent left the input box and picked up the prompt. */
+function isAccepted(status) {
+    return status !== undefined && status !== "idle" && status !== "unknown";
+}
+const normalizeWhitespace = (text) => text.replace(/\s+/g, " ");
+/**
+ * A short, wrap-safe slice of the prompt to look for in the pane's input box.
+ * Kept brief (and whitespace-normalized) so terminal wrapping or the `❯ `
+ * prefix don't break the substring match against what pane.read returns.
+ */
+function promptSignature(prompt) {
+    return normalizeWhitespace(prompt).trim().slice(0, 24);
+}
+/** Visible (on-screen) text of a pane; "" if it can't be read. */
+async function readVisible(paneId) {
+    try {
+        const res = await herdrRequest("pane.read", {
+            pane_id: paneId,
+            source: "visible",
+        });
+        return res.read?.text ?? "";
+    }
+    catch {
+        // transient; treat as "can't confirm"
+        return "";
+    }
+}
+/** Whether our prompt text currently appears in the pane (i.e. the input box). */
+async function promptIsVisible(paneId, signature) {
+    if (!signature)
+        return true;
+    return normalizeWhitespace(await readVisible(paneId)).includes(signature);
+}
 /**
  * Wait for the agent to leave `idle` — confirmation that the Enter submitted
  * and the agent picked up the prompt. `working`/`blocked`/`done` all mean the
@@ -48,8 +82,7 @@ async function paneStatus(paneId) {
 async function confirmSubmitted(paneId, attempts = 6, intervalMs = 500) {
     for (let i = 0; i < attempts; i++) {
         try {
-            const status = await paneStatus(paneId);
-            if (status && status !== "idle" && status !== "unknown")
+            if (isAccepted(await paneStatus(paneId)))
                 return true;
         }
         catch {
@@ -59,21 +92,53 @@ async function confirmSubmitted(paneId, attempts = 6, intervalMs = 500) {
     }
     return false;
 }
-async function submit(paneId, text) {
-    // send_text writes the raw text; send_keys ["Enter"] submits it as a real
-    // key event. The settle delay between them is load-bearing — see the header
-    // note: without it the Enter is swallowed by Claude's paste burst and the
-    // prompt just sits in the input box (mirrors april's tmux text-then-C-m wait).
-    await herdrRequest("pane.send_text", { pane_id: paneId, text });
-    await delay(SUBMIT_SETTLE_MS);
-    await herdrRequest("pane.send_keys", { pane_id: paneId, keys: ["Enter"] });
-    // Confirm via herdr's own agent_status that the prompt was accepted. If the
-    // agent is still idle, the Enter didn't take — resend it once. Resending
-    // Enter on an already-submitted (empty) input box is a harmless no-op.
-    if (await confirmSubmitted(paneId))
-        return;
-    log.warn(`Agent in pane ${paneId} still idle after submit; resending Enter`);
-    await herdrRequest("pane.send_keys", { pane_id: paneId, keys: ["Enter"] });
+/**
+ * Inject the prompt and verify the agent actually picked it up, retrying around
+ * the two misfires documented in the header. Returns the agent status when we
+ * stop so the caller can log the outcome.
+ *
+ * The loop is self-correcting: each pass first checks whether the agent is
+ * already working (a prior Enter landed even if its confirm timed out — never
+ * retype into a running agent), then ensures the text is in the box (typing it
+ * only if absent, so retries can't duplicate it), then submits and confirms.
+ */
+async function injectPrompt(paneId, prompt) {
+    const signature = promptSignature(prompt);
+    for (let attempt = 1; attempt <= INJECT_ATTEMPTS; attempt++) {
+        const status = await paneStatus(paneId).catch(() => undefined);
+        if (isAccepted(status)) {
+            if (attempt > 1)
+                log.info(`Agent in pane ${paneId} accepted the prompt (status: ${status})`);
+            return status;
+        }
+        // 1. Ensure our text is in the input box — type it only if it isn't there,
+        //    so a retry after a failed submit doesn't append a second copy.
+        if (!(await promptIsVisible(paneId, signature))) {
+            await herdrRequest("pane.send_text", { pane_id: paneId, text: prompt });
+            await delay(SUBMIT_SETTLE_MS);
+        }
+        // 2. Still not there → a Claude startup screen ate the burst. Dismiss it
+        //    with Enter and loop to retype. (That Enter may instead have submitted
+        //    real text on a flaky read, so re-check status before retrying.)
+        if (!(await promptIsVisible(paneId, signature))) {
+            log.warn(`Prompt text not visible in pane ${paneId} input (attempt ${attempt}/${INJECT_ATTEMPTS}); dismissing startup screen and retrying`);
+            await herdrRequest("pane.send_keys", { pane_id: paneId, keys: ["Enter"] });
+            await delay(SUBMIT_SETTLE_MS);
+            const dismissed = await paneStatus(paneId).catch(() => undefined);
+            if (isAccepted(dismissed))
+                return dismissed;
+            continue;
+        }
+        // 3. Text is in the box — submit it and confirm via agent_status.
+        await herdrRequest("pane.send_keys", { pane_id: paneId, keys: ["Enter"] });
+        if (await confirmSubmitted(paneId)) {
+            const accepted = await paneStatus(paneId).catch(() => undefined);
+            log.info(`Prompt submitted to pane ${paneId} on attempt ${attempt} (status: ${accepted ?? "unknown"})`);
+            return accepted;
+        }
+        log.warn(`Agent in pane ${paneId} still idle after Enter (attempt ${attempt}/${INJECT_ATTEMPTS}); will retry`);
+    }
+    return paneStatus(paneId).catch(() => undefined);
 }
 export const herdrBackend = {
     async listSessions() {
@@ -128,10 +193,15 @@ export const herdrBackend = {
             }
         }
         log.info(`Started agent in herdr workspace "${name}" (pane ${paneId})`);
-        // Wait until the agent is up, then inject the prompt.
+        // Wait until the agent is up, then inject the prompt and verify it landed.
         await waitForAgentReady(paneId);
-        await submit(paneId, prompt);
-        log.info(`Prompt sent to herdr workspace "${name}"`);
+        const status = await injectPrompt(paneId, prompt);
+        if (isAccepted(status)) {
+            log.info(`Prompt delivered to herdr workspace "${name}" — agent is ${status} (pane ${paneId})`);
+        }
+        else {
+            log.error(`Prompt may NOT have been accepted in herdr workspace "${name}" — agent status "${status ?? "unavailable"}" after ${INJECT_ATTEMPTS} attempts (pane ${paneId}). The session likely needs manual attention.`);
+        }
     },
     async kill(name) {
         const ws = await findByLabel(name);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@armstrongnate/april",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "She does all the work so you don't have to. Watches GitHub issues and spawns coding-agent sessions (Claude Code or Codex) to work them.",
   "type": "module",
   "bin": {