harnery 0.31.4 → 0.31.5

package/dist/core/agents/rules/stop-hook.d.ts

@@ -15,6 +15,12 @@
  * Pure-prose-turn exemption: when zero `tool.pre_use` events fire in
  * the current turn, rules 1/3 and 3/3 do not apply. Rule 2/3 still applies
  * as a user-visible mobile cue.
+ *
+ * Remediation continuity: an adapter whose Stop channel re-prompts by
+ * submitting a new user message (Cursor's `followup_message`) opens a fresh
+ * turn to repair the previous one. Such a turn inherits the window of the turn
+ * it repairs, so ritual events accumulate instead of alternating. See
+ * `resolveTurnStartMs`.
  */
 export type { VerdictResult } from "./verdict.js";
 import type { VerdictResult } from "./verdict.js";
@@ -43,6 +49,16 @@ export interface StopHookRequest {
      * event capture on: the child stays visible to peers and the coord layer. */
     workflow_child?: boolean;
 }
+/**
+ * Machine marker that opens a Stop-remediation message. Written by
+ * `hooks/adapter/output.ts` on the adapters whose Stop channel is a new user
+ * message, and read back here off `user_prompt.submit.data.prompt_text` to
+ * recognize a turn Harnery itself opened.
+ *
+ * Leading position is deliberate: `prompt_text` is clamped when recorded, so a
+ * trailing marker could be truncated away on a long reason.
+ */
+export declare const STOP_REMEDIATION_MARKER = "[harnery:stop-remediation";
 /**
  * Evaluate the Stop-hook verdict. Returns the first failing rule (or allow
  * when all three pass). Soft-fails open when the event stream isn't

package/dist/core/agents/rules/stop-hook.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stop-hook.d.ts","sourceRoot":"","sources":["../../../../src/core/agents/rules/stop-hook.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAMH,YAAY,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAElD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAclD,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,WAAW,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;4EACwE;IACxE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,+FAA+F;IAC/F,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,0DAA0D;IAC1D,WAAW,CAAC,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IACnD,yFAAyF;IACzF,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;;;;iFAM6E;IAC7E,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AA+BD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,eAAe,GAAG,aAAa,CAmHvF"}
+{"version":3,"file":"stop-hook.d.ts","sourceRoot":"","sources":["../../../../src/core/agents/rules/stop-hook.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAMH,YAAY,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAElD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAclD,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,WAAW,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;4EACwE;IACxE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,+FAA+F;IAC/F,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,0DAA0D;IAC1D,WAAW,CAAC,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IACnD,yFAAyF;IACzF,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;;;;iFAM6E;IAC7E,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AA+BD;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB,8BAA8B,CAAC;AAwEnE;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,eAAe,GAAG,aAAa,CAqHvF"}

package/dist/core/agents/rules/stop-hook.js

@@ -15,6 +15,12 @@
  * Pure-prose-turn exemption: when zero `tool.pre_use` events fire in
  * the current turn, rules 1/3 and 3/3 do not apply. Rule 2/3 still applies
  * as a user-visible mobile cue.
+ *
+ * Remediation continuity: an adapter whose Stop channel re-prompts by
+ * submitting a new user message (Cursor's `followup_message`) opens a fresh
+ * turn to repair the previous one. Such a turn inherits the window of the turn
+ * it repairs, so ritual events accumulate instead of alternating. See
+ * `resolveTurnStartMs`.
  */
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
@@ -23,6 +29,80 @@ function ackSignalFor(adapter) {
     return adapter === "cursor" ? "status_checked" : "status_box_present";
 }
 const RECENT_EVENT_WINDOW_LINES = 5_000;
+/**
+ * Machine marker that opens a Stop-remediation message. Written by
+ * `hooks/adapter/output.ts` on the adapters whose Stop channel is a new user
+ * message, and read back here off `user_prompt.submit.data.prompt_text` to
+ * recognize a turn Harnery itself opened.
+ *
+ * Leading position is deliberate: `prompt_text` is clamped when recorded, so a
+ * trailing marker could be truncated away on a long reason.
+ */
+export const STOP_REMEDIATION_MARKER = "[harnery:stop-remediation";
+/**
+ * The pre-marker message shape, still recognized on purpose.
+ *
+ * A followup already sitting in the stream was written by whichever build was
+ * running when it fired. An agent whose session spans an upgrade would otherwise
+ * keep alternating until the first new-format followup appeared, which is the
+ * exact failure this change removes. Recognizing the older trailing form closes
+ * that rollout window at no cost: it only ever appears in a `prompt_text`
+ * because Harnery put it there.
+ */
+const STOP_REMEDIATION_LEGACY_MARKER = "[agent-hook stop]: rule=";
+/** How far back the remediation walk may travel. Adapters cap their own
+ * followup chains (Cursor's `loop_limit`), and each prompt can appear once per
+ * observing adapter, so this only guards a pathological stream. */
+const MAX_REMEDIATION_WALK_BACK = 16;
+function isStopRemediationPrompt(event) {
+    const text = event.data.prompt_text;
+    if (typeof text !== "string")
+        return false;
+    return text.includes(STOP_REMEDIATION_MARKER) || text.includes(STOP_REMEDIATION_LEGACY_MARKER);
+}
+/**
+ * Start of the window this Stop verdict judges.
+ *
+ * Normally the most recent `user_prompt.submit`. The exception is the
+ * remediation chain: Cursor does not continue a turn on Stop, it auto-submits
+ * our message as a new user turn (`followup_message`). Scoping the verdict to
+ * that new turn alone makes the ritual unsatisfiable in one pass, because
+ * remediation itself runs a tool, so the repair turn needs every rule again
+ * while the signal from the previous turn sits just outside the window. Running
+ * `set-task` then clears rule 3/3 and fails rule 1/3, running `status` clears
+ * 1/3 and fails 3/3, and the pair alternates until the adapter's loop cap.
+ *
+ * Anchoring the window at the last prompt Harnery did not author makes progress
+ * monotonic: each repair adds a signal and none are lost, so the chain ends.
+ * A genuine human prompt always anchors a fresh window, so this cannot be used
+ * to inherit ritual credit across real turns.
+ */
+function resolveTurnStartMs(ownerEvents, nowMs, fallbackMs) {
+    // Honor the cutoff: `now_ms` marks what is relevant yet, so a prompt after it
+    // cannot anchor this turn. In production the cutoff is the clock and nothing
+    // follows it, but a replay over recorded history passes a past cutoff, and an
+    // unclamped search would anchor on a later turn and hand back an empty window.
+    const prompts = ownerEvents.filter((e) => {
+        if (e.event_type !== "user_prompt.submit")
+            return false;
+        const t = Date.parse(e.ts);
+        return Number.isFinite(t) && t <= nowMs;
+    });
+    if (prompts.length === 0)
+        return fallbackMs;
+    let index = prompts.length - 1;
+    let hops = 0;
+    while (index > 0 && hops < MAX_REMEDIATION_WALK_BACK) {
+        const prompt = prompts[index];
+        if (!prompt || !isStopRemediationPrompt(prompt))
+            break;
+        index -= 1;
+        hops += 1;
+    }
+    const anchor = prompts[index];
+    const parsed = anchor ? Date.parse(anchor.ts) : Number.NaN;
+    return Number.isFinite(parsed) ? parsed : fallbackMs;
+}
 /**
  * Evaluate the Stop-hook verdict. Returns the first failing rule (or allow
  * when all three pass). Soft-fails open when the event stream isn't
@@ -81,17 +161,19 @@ export function evaluateStopHook(coordRoot, req) {
         };
     }
     // Turn window: from the most recent user_prompt.submit (this owner) up to
-    // either the explicit now_ms or the last event we see. Fall back to a
+    // either the explicit now_ms or the last event we see, walking back over any
+    // Harnery-authored Stop-remediation prompts so a repair turn is judged
+    // together with the turn it repairs (see `resolveTurnStartMs`). Fall back to a
     // 5-minute window when no user_prompt.submit is in scope (fresh wiring,
     // out-of-window prompt, etc.) so a stale stream doesn't silently pass.
     const nowMs = req.now_ms ?? Date.now();
-    const lastUserPrompt = [...ownerEvents]
-        .reverse()
-        .find((e) => e.event_type === "user_prompt.submit");
-    const startMs = lastUserPrompt ? Date.parse(lastUserPrompt.ts) : nowMs - 5 * 60 * 1000;
+    const startMs = req.turn_window
+        ? req.turn_window.start_ms
+        : resolveTurnStartMs(ownerEvents, nowMs, nowMs - 5 * 60 * 1000);
+    const endMs = req.turn_window ? req.turn_window.end_ms : nowMs;
     const inTurn = ownerEvents.filter((e) => {
         const t = Date.parse(e.ts);
-        return Number.isFinite(t) && t >= startMs && t <= nowMs;
+        return Number.isFinite(t) && t >= startMs && t <= endMs;
     });
     const toolPreUseInTurn = inTurn.some((e) => e.event_type === "tool.pre_use");
     const statusChecked = inTurn.some((e) => e.event_type === "state.status_checked");

package/dist/core/hooks/adapter/output.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"output.d.ts","sourceRoot":"","sources":["../../../../src/core/hooks/adapter/output.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAEnD,MAAM,MAAM,WAAW,GAAG,cAAc,GAAG,kBAAkB,GAAG,eAAe,CAAC;AAEhF,+EAA+E;AAC/E,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAIpF;AAED,qFAAqF;AACrF,wBAAgB,QAAQ,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAI/D;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,CAAC,GAAG,CAAC,CAYjG"}
+{"version":3,"file":"output.d.ts","sourceRoot":"","sources":["../../../../src/core/hooks/adapter/output.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAEnD,MAAM,MAAM,WAAW,GAAG,cAAc,GAAG,kBAAkB,GAAG,eAAe,CAAC;AAEhF,+EAA+E;AAC/E,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAIpF;AAED,qFAAqF;AACrF,wBAAgB,QAAQ,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAI/D;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,CAAC,GAAG,CAAC,CAuBjG"}

package/dist/core/hooks/adapter/output.js

@@ -17,6 +17,8 @@
  * Every helper writes to process.stdout + newline-terminates so callers can
  * fire-and-forget. Empty text → no-op (no JSON written).
  */
+import { STOP_REMEDIATION_MARKER } from "../../agents/rules/stop-hook.js";
+import { resolveBinName } from "../../config.js";
 /** Emit a context-injection (peer table, wiring check, council pending, …). */
 export function emitContext(adapter, event, text) {
     if (!text || text.length === 0)
@@ -56,12 +58,25 @@ export function emitDeny(adapter, reason) {
 export function emitStopBlock(adapter, verdict) {
     if (adapter === "codex")
         return 0;
-    const message = `${verdict.reason ?? "End-of-turn coordination ritual incomplete."}\n[agent-hook stop]: rule=${verdict.rule}`;
+    const reason = verdict.reason ?? "End-of-turn coordination ritual incomplete.";
     if (adapter === "cursor") {
+        // The marker leads the message so the Stop verdict can recognize the turn
+        // Cursor opens from it (`STOP_REMEDIATION_MARKER`), and so the operator can
+        // see in chat that the message came from Harnery rather than from them.
+        // Both commands are named because one message that repairs the whole ritual
+        // ends the chain in a single followup; the failing rule is context.
+        const bin = resolveBinName();
+        const message = [
+            `${STOP_REMEDIATION_MARKER} rule=${verdict.rule}]`,
+            reason,
+            `Repair the ritual in this turn: run \`${bin} agents set-task "<short focus>"\` and then \`${bin} agents status\` as your last tool call.`,
+        ].join("\n");
         process.stdout.write(`${JSON.stringify({ followup_message: message })}\n`);
         return 0;
     }
-    process.stderr.write(`${message}\n`);
+    // Claude Code continues the SAME turn on exit 2, so the single failing rule is
+    // both accurate and sufficient there. Left unchanged deliberately.
+    process.stderr.write(`${reason}\n[agent-hook stop]: rule=${verdict.rule}\n`);
     return 2;
 }
 function buildContextJson(adapter, event, text) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "harnery",
-  "version": "0.31.4",
+  "version": "0.31.5",
   "description": "Multi-agent coordination for AI coding agents - Claude Code, Cursor, and Codex.",
   "license": "MIT",
   "author": "Ryan Kelly",

package/src/core/agents/rules/stop-hook.ts

@@ -15,6 +15,12 @@
  * Pure-prose-turn exemption: when zero `tool.pre_use` events fire in
  * the current turn, rules 1/3 and 3/3 do not apply. Rule 2/3 still applies
  * as a user-visible mobile cue.
+ *
+ * Remediation continuity: an adapter whose Stop channel re-prompts by
+ * submitting a new user message (Cursor's `followup_message`) opens a fresh
+ * turn to repair the previous one. Such a turn inherits the window of the turn
+ * it repairs, so ritual events accumulate instead of alternating. See
+ * `resolveTurnStartMs`.
  */
 
 import { existsSync, readFileSync } from "node:fs";
@@ -89,6 +95,87 @@ function ackSignalFor(adapter?: string): AckSignal {
 
 const RECENT_EVENT_WINDOW_LINES = 5_000;
 
+/**
+ * Machine marker that opens a Stop-remediation message. Written by
+ * `hooks/adapter/output.ts` on the adapters whose Stop channel is a new user
+ * message, and read back here off `user_prompt.submit.data.prompt_text` to
+ * recognize a turn Harnery itself opened.
+ *
+ * Leading position is deliberate: `prompt_text` is clamped when recorded, so a
+ * trailing marker could be truncated away on a long reason.
+ */
+export const STOP_REMEDIATION_MARKER = "[harnery:stop-remediation";
+
+/**
+ * The pre-marker message shape, still recognized on purpose.
+ *
+ * A followup already sitting in the stream was written by whichever build was
+ * running when it fired. An agent whose session spans an upgrade would otherwise
+ * keep alternating until the first new-format followup appeared, which is the
+ * exact failure this change removes. Recognizing the older trailing form closes
+ * that rollout window at no cost: it only ever appears in a `prompt_text`
+ * because Harnery put it there.
+ */
+const STOP_REMEDIATION_LEGACY_MARKER = "[agent-hook stop]: rule=";
+
+/** How far back the remediation walk may travel. Adapters cap their own
+ * followup chains (Cursor's `loop_limit`), and each prompt can appear once per
+ * observing adapter, so this only guards a pathological stream. */
+const MAX_REMEDIATION_WALK_BACK = 16;
+
+function isStopRemediationPrompt(event: CanonicalEvent): boolean {
+  const text = event.data.prompt_text;
+  if (typeof text !== "string") return false;
+  return text.includes(STOP_REMEDIATION_MARKER) || text.includes(STOP_REMEDIATION_LEGACY_MARKER);
+}
+
+/**
+ * Start of the window this Stop verdict judges.
+ *
+ * Normally the most recent `user_prompt.submit`. The exception is the
+ * remediation chain: Cursor does not continue a turn on Stop, it auto-submits
+ * our message as a new user turn (`followup_message`). Scoping the verdict to
+ * that new turn alone makes the ritual unsatisfiable in one pass, because
+ * remediation itself runs a tool, so the repair turn needs every rule again
+ * while the signal from the previous turn sits just outside the window. Running
+ * `set-task` then clears rule 3/3 and fails rule 1/3, running `status` clears
+ * 1/3 and fails 3/3, and the pair alternates until the adapter's loop cap.
+ *
+ * Anchoring the window at the last prompt Harnery did not author makes progress
+ * monotonic: each repair adds a signal and none are lost, so the chain ends.
+ * A genuine human prompt always anchors a fresh window, so this cannot be used
+ * to inherit ritual credit across real turns.
+ */
+function resolveTurnStartMs(
+  ownerEvents: CanonicalEvent[],
+  nowMs: number,
+  fallbackMs: number,
+): number {
+  // Honor the cutoff: `now_ms` marks what is relevant yet, so a prompt after it
+  // cannot anchor this turn. In production the cutoff is the clock and nothing
+  // follows it, but a replay over recorded history passes a past cutoff, and an
+  // unclamped search would anchor on a later turn and hand back an empty window.
+  const prompts = ownerEvents.filter((e) => {
+    if (e.event_type !== "user_prompt.submit") return false;
+    const t = Date.parse(e.ts);
+    return Number.isFinite(t) && t <= nowMs;
+  });
+  if (prompts.length === 0) return fallbackMs;
+
+  let index = prompts.length - 1;
+  let hops = 0;
+  while (index > 0 && hops < MAX_REMEDIATION_WALK_BACK) {
+    const prompt = prompts[index];
+    if (!prompt || !isStopRemediationPrompt(prompt)) break;
+    index -= 1;
+    hops += 1;
+  }
+
+  const anchor = prompts[index];
+  const parsed = anchor ? Date.parse(anchor.ts) : Number.NaN;
+  return Number.isFinite(parsed) ? parsed : fallbackMs;
+}
+
 /**
  * Evaluate the Stop-hook verdict. Returns the first failing rule (or allow
  * when all three pass). Soft-fails open when the event stream isn't
@@ -151,18 +238,20 @@ export function evaluateStopHook(coordRoot: string, req: StopHookRequest): Verdi
   }
 
   // Turn window: from the most recent user_prompt.submit (this owner) up to
-  // either the explicit now_ms or the last event we see. Fall back to a
+  // either the explicit now_ms or the last event we see, walking back over any
+  // Harnery-authored Stop-remediation prompts so a repair turn is judged
+  // together with the turn it repairs (see `resolveTurnStartMs`). Fall back to a
   // 5-minute window when no user_prompt.submit is in scope (fresh wiring,
   // out-of-window prompt, etc.) so a stale stream doesn't silently pass.
   const nowMs = req.now_ms ?? Date.now();
-  const lastUserPrompt = [...ownerEvents]
-    .reverse()
-    .find((e) => e.event_type === "user_prompt.submit");
-  const startMs = lastUserPrompt ? Date.parse(lastUserPrompt.ts) : nowMs - 5 * 60 * 1000;
+  const startMs = req.turn_window
+    ? req.turn_window.start_ms
+    : resolveTurnStartMs(ownerEvents, nowMs, nowMs - 5 * 60 * 1000);
+  const endMs = req.turn_window ? req.turn_window.end_ms : nowMs;
 
   const inTurn = ownerEvents.filter((e) => {
     const t = Date.parse(e.ts);
-    return Number.isFinite(t) && t >= startMs && t <= nowMs;
+    return Number.isFinite(t) && t >= startMs && t <= endMs;
   });
 
   const toolPreUseInTurn = inTurn.some((e) => e.event_type === "tool.pre_use");

package/src/core/hooks/adapter/output.ts

@@ -18,6 +18,8 @@
  * fire-and-forget. Empty text → no-op (no JSON written).
  */
 
+import { STOP_REMEDIATION_MARKER } from "../../agents/rules/stop-hook.ts";
+import { resolveBinName } from "../../config.ts";
 import type { Adapter } from "../events/schema.ts";
 
 export type SystemEvent = "SessionStart" | "UserPromptSubmit" | "SubagentStart";
@@ -61,14 +63,25 @@ export function emitDeny(adapter: Adapter, reason: string): void {
 export function emitStopBlock(adapter: Adapter, verdict: { reason?: string; rule: string }): 0 | 2 {
   if (adapter === "codex") return 0;
 
-  const message = `${
-    verdict.reason ?? "End-of-turn coordination ritual incomplete."
-  }\n[agent-hook stop]: rule=${verdict.rule}`;
+  const reason = verdict.reason ?? "End-of-turn coordination ritual incomplete.";
   if (adapter === "cursor") {
+    // The marker leads the message so the Stop verdict can recognize the turn
+    // Cursor opens from it (`STOP_REMEDIATION_MARKER`), and so the operator can
+    // see in chat that the message came from Harnery rather than from them.
+    // Both commands are named because one message that repairs the whole ritual
+    // ends the chain in a single followup; the failing rule is context.
+    const bin = resolveBinName();
+    const message = [
+      `${STOP_REMEDIATION_MARKER} rule=${verdict.rule}]`,
+      reason,
+      `Repair the ritual in this turn: run \`${bin} agents set-task "<short focus>"\` and then \`${bin} agents status\` as your last tool call.`,
+    ].join("\n");
     process.stdout.write(`${JSON.stringify({ followup_message: message })}\n`);
     return 0;
   }
-  process.stderr.write(`${message}\n`);
+  // Claude Code continues the SAME turn on exit 2, so the single failing rule is
+  // both accurate and sufficient there. Left unchanged deliberately.
+  process.stderr.write(`${reason}\n[agent-hook stop]: rule=${verdict.rule}\n`);
   return 2;
 }