@dorokuma/herdsman-pi 0.13.3 → 0.13.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dorokuma/herdsman-pi",
-  "version": "0.13.3",
+  "version": "0.13.5",
   "description": "Pi extension bridge for Herdsman agent history.",
   "type": "module",
   "keywords": [

package/src/turn-signal.ts

@@ -4,7 +4,7 @@ export const TURN_SIGNAL_TIMEOUT_MS = 3_000;
 export const TURN_SIGNAL_POLL_MS = 50;
 export const TURN_SIGNAL_TAIL_CHARS = 8_000;
 
-export type TurnCompletionCheckReason = "already_written" | "new_content" | "timeout" | "unavailable";
+export type TurnCompletionCheckReason = "already_written" | "timeout" | "unavailable";
 
 export type TurnCompletionCheck = {
   confirmed: boolean;
@@ -56,11 +56,30 @@ function defaultProbe(): SessionWriteProbe {
 /**
  * Bounded confirmation that the final assistant message reached the Pi session
  * file before the extension signals the daemon. The message may already be on
- * disk when the `message_end` hook fires (checked via the file tail containing
- * the expected text or its distinctive ending); otherwise the file size is
- * polled until new content appears. A timeout (or an unavailable file) still
- * resolves so the caller can signal with the actual status instead of hanging
- * forever.
+ * disk when the `message_end` hook fires; otherwise the file tail is polled
+ * until the expected text (or its JSONL-escaped form) appears.
+ *
+ * The root cause of the mismatches this guards against is the source of
+ * `expectedText`, not the tail it is compared to: the extension reports the
+ * *sanitized* text it saw at `message_end` (`assistantMessageText` in
+ * `index.ts` runs the body through `sanitizeText`), while rewrite-type
+ * extensions (e.g. `no-tables` turning `### X` into bold or tables into
+ * bullets, plus link handling) keep rewriting the transcript that lands on disk
+ * *after* that hook. The client-side text and the on-disk original are therefore
+ * systematically inconsistent, and the disk original is the authoritative body —
+ * never the reported guess. "The file grew" was only a secondary mechanism that
+ * let such a mismatch be *confirmed* instead of caught (tool results, streamed
+ * partials and any other session write also grow the file): that is how
+ * mismatch signals ended up as empty `agent.done` releases (sample figures and
+ * the caveats around them live in
+ * `.agents/notes/20261002-empty-wake-expectedtext-rootcause.md`). The
+ * daemon's `expected_text_mismatch` arm now trusts the on-disk body, so a
+ * timeout here degrades honestly instead of blanking it. Do not trace this back
+ * to tail guessing alone.
+ *
+ * A timeout (or an unavailable file) still resolves so the caller can signal
+ * with the actual status instead of hanging forever, and it now reports
+ * `confirmed: false` honestly instead of fabricating a confirmation.
  */
 export async function confirmSessionWrite(input: {
   expectedText: string;
@@ -75,8 +94,14 @@ export async function confirmSessionWrite(input: {
   const expectedText = input.expectedText.trim();
   const deadline = Date.now() + timeoutMs;
   const candidate = expectedText.length > 200 ? expectedText.slice(-200) : expectedText;
+  // The session file is JSONL, so the written text is escaped (`\n`, `\"`,
+  // `\\`). Matching the raw candidate only would miss every multi-line final
+  // message, so the escaped form of the same suffix is accepted as well.
+  const escapedCandidate = JSON.stringify(candidate).slice(1, -1);
   const containsText = (tail: string | null) =>
-    tail !== null && candidate.length > 0 && tail.includes(candidate);
+    tail !== null &&
+    candidate.length > 0 &&
+    (tail.includes(candidate) || tail.includes(escapedCandidate));
 
   const initialSize = probe.size(input.path);
   if (initialSize === null) return { confirmed: false, reason: "unavailable" };
@@ -85,8 +110,6 @@ export async function confirmSessionWrite(input: {
   }
   while (Date.now() < deadline) {
     await probe.sleep(pollMs);
-    const size = probe.size(input.path);
-    if (size !== null && size > initialSize) return { confirmed: true, reason: "new_content" };
     if (containsText(probe.readTail(input.path, TURN_SIGNAL_TAIL_CHARS))) {
       return { confirmed: true, reason: "already_written" };
     }

package/src/wake.ts

@@ -117,7 +117,20 @@ export function formatAgentOutcomeUpdates(outcomes: AgentOutcome[]): string {
     const pane = outcome.paneId ?? "unknown";
     if (outcome.kind === "failed") {
       const reason = outcome.reason && outcome.reason.length > 0 ? outcome.reason : "(unknown)";
-      return `- failed ${identity} ${pane}\n  reason: ${reason}`;
+      // A failed round can still have produced assistant text before it failed; a
+      // reason-only line left that body invisible to the orchestrator. But the
+      // body of a `failed` / `discarded` outcome is not this round's output:
+      // `#appendPlanFailedEvent` / `#appendPlanDiscardedEvent` pass the plan
+      // baseline snapshot (`plan.compactHistory`, written once at plan creation),
+      // which may hold an earlier round's answer (see the plan-baseline notes).
+      // Rendering it as `last assistant:` read as "this round produced this", so
+      // the label says pre-round. The wire record carries no assistant `ref`, so
+      // same-source cannot be decided here without widening the daemon payload;
+      // the label is therefore always explicit (and only dropped when the body is
+      // empty, keeping the reason-only line byte-for-byte unchanged).
+      const body =
+        outcome.text.length > 0 ? `\n  last assistant (pre-round): ${outcome.text}` : "";
+      return `- failed ${identity} ${pane}\n  reason: ${reason}${body}`;
     }
     const excerpt = outcome.text.length > 0 ? outcome.text : "(no assistant message)";
     return `- ${outcome.kind} ${identity} ${pane}\n  last assistant: ${excerpt}\n  event: ${outcome.eventId}`;