zob-harness 0.15.1 → 0.15.2

package/.pi/extensions/zob-harness/index.ts

@@ -617,6 +617,7 @@ export { ZobPendingReplies } from "./src/domains/coms/coms-v2/pending-replies.js
 export { buildZobLiveResponseCapture, buildZobLiveResponseEnvelope } from "./src/domains/coms/coms-v2/response-capture.js";
 export { appendLiveSendRequestedRef, appendLiveDeliveredStatus, appendLiveRunningStatus, appendLiveCompletedRef, appendLiveErrorStatus, appendPeerStaleStatus } from "./src/domains/coms/coms-v2/ledger-bridge.js";
 export { redactZobComsText, writeZobComsRedactedCapture } from "./src/domains/coms/coms-v2/transcript-capture.js";
+export { annotateZpeerStatus, isZpeerTerminalStatus, shouldAcceptZpeerStatusUpdate, zpeerStatusRank } from "./src/domains/coms/coms-v2/zpeer-status.js";
 export type { ZobLiveEnvelope, ZobLiveEnvelopeType } from "./src/domains/coms/coms-v2/envelope.js";
 export type { ZobComsTranscriptCapturePolicy, ZobComsTranscriptMode, ZobComsTranscriptRetentionClass, ZobComsTransportMode, ZobComsV2Policy, ZobLivePeerCard, ZobLivePeerStatus, ZobLivePresenceSummary, ZobLiveRegistrySnapshot } from "./src/domains/coms/coms-v2/types.js";
 

package/.pi/extensions/zob-harness/src/domains/coms/coms-v2/zpeer-status.ts

@@ -0,0 +1,92 @@
+export interface ZpeerStatusComparable {
+  status?: string;
+  kind?: string;
+  at?: string;
+}
+
+const ZPEER_TERMINAL_STATUSES = new Set([
+  "reply",
+  "completed",
+  "response_sent",
+  "blocked",
+  "error",
+  "timeout",
+  "expired",
+  "required_response_expired",
+]);
+
+const ZPEER_STATUS_RANKS: Record<string, number> = {
+  status: 0,
+  attempt: 5,
+  heartbeat: 5,
+  sent: 10,
+  delivered: 20,
+  urgent_delivered: 25,
+  force_accepted: 25,
+  force_downgraded: 25,
+  required_response_reinject: 30,
+  inbound: 35,
+  prompt_received: 35,
+  waiting: 40,
+  response_sent: 90,
+  reply: 100,
+  completed: 100,
+  blocked: 100,
+  force_blocked: 100,
+  error: 100,
+  timeout: 100,
+  expired: 100,
+  required_response_expired: 100,
+};
+
+function zpeerStatusKey(input: ZpeerStatusComparable): string | undefined {
+  return input.status ?? input.kind;
+}
+
+function parsedTime(value: string | undefined): number | undefined {
+  if (!value) return undefined;
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? parsed : undefined;
+}
+
+export function isZpeerTerminalStatus(status: string | undefined, kind?: string): boolean {
+  const primary = status ?? kind;
+  return Boolean((primary && ZPEER_TERMINAL_STATUSES.has(primary)) || (kind && ZPEER_TERMINAL_STATUSES.has(kind)));
+}
+
+export function zpeerStatusRank(status: string | undefined, kind?: string): number {
+  const primary = status ?? kind;
+  if (primary && ZPEER_STATUS_RANKS[primary] !== undefined) return ZPEER_STATUS_RANKS[primary];
+  if (kind && ZPEER_STATUS_RANKS[kind] !== undefined) return ZPEER_STATUS_RANKS[kind];
+  return 0;
+}
+
+export function shouldAcceptZpeerStatusUpdate(current: ZpeerStatusComparable | undefined, incoming: ZpeerStatusComparable): boolean {
+  if (!current) return true;
+
+  const currentTerminal = isZpeerTerminalStatus(current.status, current.kind);
+  const incomingTerminal = isZpeerTerminalStatus(incoming.status, incoming.kind);
+  if (currentTerminal && !incomingTerminal) return false;
+  if (!currentTerminal && incomingTerminal) return true;
+
+  const currentRank = zpeerStatusRank(current.status, current.kind);
+  const incomingRank = zpeerStatusRank(incoming.status, incoming.kind);
+  if (incomingRank > currentRank) return true;
+  if (incomingRank < currentRank) return false;
+
+  const currentAt = parsedTime(current.at);
+  const incomingAt = parsedTime(incoming.at);
+  if (currentAt !== undefined && incomingAt !== undefined) return incomingAt >= currentAt;
+
+  const currentKey = zpeerStatusKey(current);
+  const incomingKey = zpeerStatusKey(incoming);
+  return currentKey === incomingKey;
+}
+
+export function annotateZpeerStatus<T extends ZpeerStatusComparable>(event: T): T & { terminal: boolean; statusRank: number } {
+  return {
+    ...event,
+    terminal: isZpeerTerminalStatus(event.status, event.kind),
+    statusRank: zpeerStatusRank(event.status, event.kind),
+  };
+}

package/.pi/extensions/zob-harness/src/domains/coms/coms-v2/zpeer.ts

@@ -10,6 +10,7 @@ import { validateZobComsEdge } from "../../topology/coms.js";
 import { loadTeamDefinition, validateTeamDefinition } from "../../topology/teams.js";
 import { loadZteamManifest, zteamAllowsZpeerContact } from "../zagents.js";
 import { sha256 } from "../../../core/utils/hashing.js";
+import { annotateZpeerStatus } from "./zpeer-status.js";
 
 const DEFAULT_ROOM_ID = "default";
 const ALIAS_PATTERN = /^[a-zA-Z][a-zA-Z0-9_-]{1,31}$/;
@@ -67,6 +68,8 @@ export interface ZpeerSendResult {
   deliveryMethod?: "local_socket" | "tmux_sendkeys";
   fallback_delivery?: boolean;
   best_effort?: boolean;
+  terminal?: boolean;
+  statusRank?: number;
   bodyStored: false;
 }
 
@@ -620,7 +623,7 @@ export async function sendZpeerPrompt(repoRoot: string, self: ZobLivePeerCard, t
       deliveryMethod: result.deliveryMethod,
       fallbackDelivery: result.fallback_delivery,
     });
-    return { roomId, priority, interruptMode, interruptReasonHash, requireResponse: requireResponse || undefined, responseTimeoutMs: requireResponse ? responseTimeoutMs : undefined, maxReinjects: requireResponse ? maxReinjects : undefined, ...result };
+    return annotateZpeerStatus({ roomId, priority, interruptMode, interruptReasonHash, requireResponse: requireResponse || undefined, responseTimeoutMs: requireResponse ? responseTimeoutMs : undefined, maxReinjects: requireResponse ? maxReinjects : undefined, ...result });
   };
 
   if (priority === "force" && !interruptReasonHash) return finish("attempt", { status: "blocked", reason: "force interrupt requires reason hash", targetAlias: targetAlias ?? undefined, taskHash, interruptStatus: "force_blocked", bodyStored: false });

package/.pi/extensions/zob-harness/src/runtime/commands/zlive.ts

@@ -17,6 +17,7 @@ import { loadActiveZagentScopedMode } from "../events.js";
 import { resolveRuleProfile } from "../../domains/governance/rules.js";
 import type { HarnessRuntimeState } from "../state.js";
 import { applyMode, renderHarnessWidget } from "../widget.js";
+import { recordZpeerRuntimeEvent } from "../zpeer-events.js";
 
 function zpeerCommandProfileId(ctx: ExtensionCommandContext): string {
   const sessionIdentity = ctx.sessionManager.getSessionFile() ?? ctx.sessionManager.getSessionId();
@@ -1140,18 +1141,21 @@ async function executeZteamTmuxActionPlan(_repoRoot: string, plan: ZteamTmuxActi
 }
 
 export function registerZliveCommands(pi: ExtensionAPI, state: HarnessRuntimeState): void {
-  const rememberZpeerEvent = (event: { kind: NonNullable<typeof state.zobLive.lastEvent>["kind"]; roomId?: string; fromAlias?: string; toAlias?: string; status: string; reason?: string; msgId?: string; taskHash?: string; outputHash?: string; priority?: ZpeerInterruptPriority; interruptMode?: ZpeerInterruptMode; interruptStatus?: ZpeerInterruptStatus }): void => {
-    state.zobLive.lastEvent = { ...event, at: new Date().toISOString(), localOnly: true, networkEnabled: false, bodyStored: false };
+  const rememberZpeerEvent = (event: { kind: NonNullable<typeof state.zobLive.lastEvent>["kind"]; roomId?: string; fromAlias?: string; toAlias?: string; status: string; reason?: string; msgId?: string; taskHash?: string; outputHash?: string; priority?: ZpeerInterruptPriority; interruptMode?: ZpeerInterruptMode; interruptStatus?: ZpeerInterruptStatus }): NonNullable<typeof state.zobLive.lastEvent> | undefined => {
+    const recorded = recordZpeerRuntimeEvent(state, event);
+    return recorded.accepted ? recorded.event : undefined;
   };
 
-  const emitZpeerEvent = (event: Parameters<typeof rememberZpeerEvent>[0]): void => {
-    rememberZpeerEvent(event);
+  const emitZpeerEvent = (event: Parameters<typeof rememberZpeerEvent>[0]): boolean => {
+    const recorded = rememberZpeerEvent(event);
+    if (!recorded) return false;
     void pi.sendMessage({
       customType: "zob-zpeer-event",
       content: `ZPeer ${event.kind} ${event.fromAlias ? `@${event.fromAlias}` : "?"} → ${event.toAlias ? `@${event.toAlias}` : "?"} ${event.status}`,
       display: true,
-      details: { ...state.zobLive.lastEvent },
+      details: { ...recorded },
     }, { triggerTurn: false });
+    return true;
   };
 
   pi.registerCommand("zagent", {
@@ -1682,6 +1686,7 @@ export function registerZliveCommands(pi: ExtensionAPI, state: HarnessRuntimeSta
           maxReinjects: sendMode.maxReinjects,
           onFeedback: (feedback) => {
             feedbackEmittedTerminal = feedback.result.status === "waiting" || feedback.result.status === "reply" || feedback.result.status === "completed" || feedback.result.status === "blocked" || feedback.result.status === "error" || feedback.result.status === "timeout" || feedback.result.status === "expired" || feedback.result.status === "required_response_expired";
+            if (feedback.kind === "waiting" && (sendMode.requireResponse === true || sendMode.mode !== "async")) return;
             const feedbackRoomId = feedback.result.roomId ?? eventRoomId;
             emitZpeerEvent({ kind: feedback.kind, roomId: feedbackRoomId, fromAlias: state.zobLive.peerCard ? peerAliasInRoom(state.zobLive.peerCard, feedbackRoomId) ?? eventFromAlias : eventFromAlias, toAlias: feedback.result.targetAlias ?? targetAlias, status: feedback.result.status, reason: feedback.result.reason, msgId: feedback.result.msgId, taskHash: feedback.result.taskHash, outputHash: feedback.result.outputHash, priority: feedback.result.priority ?? sendMode.priority, interruptMode: feedback.result.interruptMode ?? sendMode.interruptMode, interruptStatus: feedback.result.interruptStatus });
           },

package/.pi/extensions/zob-harness/src/runtime/events.ts

@@ -40,6 +40,7 @@ import { capturePlanArtifact } from "./plan-capture.js";
 import { redactPlanTodosBlockForDisplay } from "../domains/plan/plan-todos.js";
 import { applyMode, renderHarnessWidget } from "./widget.js";
 import { createStopRestoreCandidate, markStopRestoreAssistantMessage, markStopRestoreToolVisible } from "./stop-restore.js";
+import { recordZpeerRuntimeEvent } from "./zpeer-events.js";
 
 function safelyUpdateZobLivePeer(repoRoot: string, action: "register" | "touch" | "unregister"): void {
   try {
@@ -51,14 +52,8 @@ function safelyUpdateZobLivePeer(repoRoot: string, action: "register" | "touch"
   }
 }
 
-function setZpeerLastEvent(state: HarnessRuntimeState, event: Omit<ZobLiveLastEvent, "at" | "localOnly" | "networkEnabled" | "bodyStored"> & { at?: string }): void {
-  state.zobLive.lastEvent = {
-    ...event,
-    at: event.at ?? new Date().toISOString(),
-    localOnly: true,
-    networkEnabled: false,
-    bodyStored: false,
-  };
+function setZpeerLastEvent(state: HarnessRuntimeState, event: Omit<ZobLiveLastEvent, "at" | "localOnly" | "networkEnabled" | "bodyStored" | "terminal" | "statusRank" | "superseded" | "supersededByStatus"> & { at?: string }): ZobLiveLastEvent {
+  return recordZpeerRuntimeEvent(state, event).event;
 }
 
 function clearPassivePeerWaitForResponse(state: HarnessRuntimeState, envelope: { msgId?: string; runId?: string; sender?: string; type?: string }): void {
@@ -1060,7 +1055,10 @@ async function sendInboundZobLiveResponse(pi: ExtensionAPI, state: HarnessRuntim
   const activeInbound = activeZpeerInboundForResponse(state);
   const inbound = activeInbound ?? state.zobLive.inbound;
   if (!inbound || inbound.responseSent || !inbound.envelope.replyEndpoint) return;
-  if (activeInbound?.requiredResponseStatus === "expired") return;
+  // ZOB-COMS-GUARDS: a late reply after expiry is now permitted (the watchdog
+  // already stopped reinjecting; sender-side pendingReplies resolves to no-op).
+  // Dropping this early-out recovers nudge/reply paths (e.g. a late oracle
+  // review) without weakening the real anti-abuse (reinject cap + sender expire).
   if (state.zobLive.inboundByMsgId && !activeInbound) return;
   const responseText = latestAssistantText(event);
   if (!responseText.trim()) return;
@@ -1118,7 +1116,7 @@ export function registerHarnessEvents(pi: ExtensionAPI, state: HarnessRuntimeSta
     const taskHash = typeof details.taskHash === "string" ? details.taskHash : undefined;
     const outputHash = typeof details.outputHash === "string" ? details.outputHash : undefined;
     const route = fromAlias || toAlias ? `${fromAlias ? `@${fromAlias}` : "?"} → ${toAlias ? `@${toAlias}` : "?"}` : "room status";
-    const statusColor = status === "completed" || status === "sent" || status === "prompt_received" || status === "response_sent" ? "success" : status === "blocked" || status === "timeout" || status === "error" || status === "required_response_expired" ? "warning" : "muted";
+    const statusColor = status === "reply" || status === "completed" || status === "sent" || status === "delivered" || status === "prompt_received" || status === "response_sent" ? "success" : status === "blocked" || status === "timeout" || status === "error" || status === "expired" || status === "required_response_expired" ? "warning" : "muted";
     const line = [
       theme.fg("accent", "◆ ZPeer"),
       theme.fg("muted", kind),

package/.pi/extensions/zob-harness/src/runtime/state.ts

@@ -49,6 +49,10 @@ export interface ZobLiveLastEvent {
   priority?: ZpeerInterruptPriority;
   interruptMode?: ZpeerInterruptMode;
   interruptStatus?: ZpeerInterruptStatus;
+  terminal?: boolean;
+  statusRank?: number;
+  superseded?: boolean;
+  supersededByStatus?: string;
   at: string;
   localOnly: true;
   networkEnabled: false;
@@ -98,6 +102,7 @@ export interface ZobLiveRuntimeState {
   inboundQueue?: string[];
   activeInboundMsgId?: string;
   lastEvent?: ZobLiveLastEvent;
+  latestZpeerEventByMsgId?: Record<string, ZobLiveLastEvent>;
   passivePeerWait?: ZobPassivePeerWaitState;
   leaseOwned?: boolean;
   leaseStatus?: "owned" | "blocked" | "unavailable";

package/.pi/extensions/zob-harness/src/runtime/tools-coms.ts

@@ -34,11 +34,23 @@ import {
 } from "../domains/topology/coms.js";
 import { loadTeamDefinition, validateTeamDefinition } from "../domains/topology/teams.js";
 import type { HarnessRuntimeState } from "./state.js";
+import { isCurrentZpeerRuntimeEvent, recordZpeerRuntimeEvent } from "./zpeer-events.js";
 
 const SHA256_HEX = /^[a-f0-9]{64}$/i;
-const ZPEER_AGENT_ASK_RATE_LIMIT_PER_MINUTE = 50;
-const ZPEER_AGENT_URGENT_RATE_LIMIT_PER_MINUTE = 10;
-const ZPEER_AGENT_FORCE_RATE_LIMIT_PER_MINUTE = 3;
+// ZOB-COMS-GUARDS: per-agent zpeer rate caps are env-configurable with a finite
+// ceiling (never Infinity) so trusted closed topologies (e.g. project-transposer's
+// 64-agent fan-out) don't trip the default 50/10/3 while real floods are still
+// bounded. Defaults unchanged for open/hostile topologies.
+const clampRate = (v: string | undefined, fallback: number): number => Math.max(1, Math.min(1000, Number.parseInt(v ?? "") || fallback));
+const ZPEER_AGENT_ASK_RATE_LIMIT_PER_MINUTE = clampRate(process.env.ZOB_ZPEER_ASK_RATE_LIMIT_PER_MINUTE, 50);
+const ZPEER_AGENT_URGENT_RATE_LIMIT_PER_MINUTE = clampRate(process.env.ZOB_ZPEER_URGENT_RATE_LIMIT_PER_MINUTE, 10);
+const ZPEER_AGENT_FORCE_RATE_LIMIT_PER_MINUTE = clampRate(process.env.ZOB_ZPEER_FORCE_RATE_LIMIT_PER_MINUTE, 3);
+// ZOB-COMS-GUARDS: the loop-keyword block (reject any zpeer_ask whose message
+// text contains 'zpeer_ask'/'/zpeer') over-fires on trusted topologies whose
+// prompts legitimately quote these tokens. Env-bypassed for trusted topologies;
+// default (unset) keeps current behavior for open/hostile use. Genuine anti-loop
+// (duplicate guard below + reinject cap + sender-side expire) is preserved.
+const ZPEER_RECURSION_KEYWORD_GUARD_DISABLED = /^(1|true|yes|on)$/i.test(process.env.ZOB_ZPEER_DISABLE_RECURSION_KEYWORD_GUARD ?? "");
 
 type ZpeerFallbackHookFn = ZpeerFallbackDelivery;
 
@@ -141,7 +153,7 @@ function zpeerAskGuardBlock(state: HarnessRuntimeState, params: ZpeerAskToolPara
   if (selfAlias && zpeerAliasesEquivalent(targetAlias, selfAlias)) return "cannot send to self";
   const roomId = safeZpeerRoomId(params.roomId) ?? currentRoomId;
   if (params.roomId && !safeZpeerRoomId(params.roomId)) return "invalid room id";
-  if (/\b(zpeer_ask|\/zpeer)\b/i.test(params.message)) return "loop guard blocked recursive ZPeer instruction";
+  if (!ZPEER_RECURSION_KEYWORD_GUARD_DISABLED && /\b(zpeer_ask|\/zpeer)\b/i.test(params.message)) return "loop guard blocked recursive ZPeer instruction";
   const messageHash = sha256(params.message);
   const now = Date.now();
   const windowMs = 60_000;
@@ -275,16 +287,29 @@ export function registerComsTools(pi: ExtensionAPI, state?: HarnessRuntimeState)
       const requestedFromAlias = peerAliasInRoom(self, requestedRoomId) ?? self.zpeerAlias;
       const interrupt = normalizeZpeerInterrupt(params);
       const guardReason = interrupt.error ?? zpeerAskGuardBlock(state, params, requestedFromAlias, requestedRoomId, interrupt.priority);
-      const emitZpeerAskEvent = (event: { kind: NonNullable<HarnessRuntimeState["zobLive"]["lastEvent"]>["kind"]; status: string; reason?: string; msgId?: string; roomId?: string; taskHash?: string; outputHash?: string; interruptStatus?: ZpeerInterruptStatus }): void => {
+      const queuedZpeerEvents: Array<{ event: NonNullable<HarnessRuntimeState["zobLive"]["lastEvent"]>; content: string; details: Record<string, unknown> }> = [];
+      const flushZpeerAskEvents = async (): Promise<void> => {
+        for (const queued of queuedZpeerEvents) {
+          if (!isCurrentZpeerRuntimeEvent(state, queued.event)) continue;
+          await Promise.resolve(pi.sendMessage({
+            customType: "zob-zpeer-event",
+            content: queued.content,
+            display: true,
+            details: queued.details,
+          }, { triggerTurn: false }));
+        }
+      };
+      const emitZpeerAskEvent = (event: { kind: NonNullable<HarnessRuntimeState["zobLive"]["lastEvent"]>["kind"]; status: string; reason?: string; msgId?: string; roomId?: string; taskHash?: string; outputHash?: string; interruptStatus?: ZpeerInterruptStatus }): boolean => {
         const eventRoomId = event.roomId ?? requestedRoomId;
         const fromAlias = peerAliasInRoom(self, eventRoomId) ?? requestedFromAlias;
-        state.zobLive.lastEvent = { kind: event.kind, roomId: eventRoomId, fromAlias, toAlias: targetAlias, status: event.status, reason: event.reason, msgId: event.msgId, taskHash: event.taskHash, outputHash: event.outputHash, priority: interrupt.priority, interruptMode: interrupt.interruptMode, interruptStatus: event.interruptStatus, at: new Date().toISOString(), localOnly: true, networkEnabled: false, bodyStored: false };
-        void pi.sendMessage({
-          customType: "zob-zpeer-event",
+        const recorded = recordZpeerRuntimeEvent(state, { kind: event.kind, roomId: eventRoomId, fromAlias, toAlias: targetAlias, status: event.status, reason: event.reason, msgId: event.msgId, taskHash: event.taskHash, outputHash: event.outputHash, priority: interrupt.priority, interruptMode: interrupt.interruptMode, interruptStatus: event.interruptStatus });
+        if (!recorded.accepted) return false;
+        queuedZpeerEvents.push({
+          event: recorded.event,
           content: `ZPeer agent-request @${fromAlias ?? "?"} → @${targetAlias} ${event.status}`,
-          display: true,
-          details: { ...state.zobLive.lastEvent, source: "agent-request", mode, priority: interrupt.priority, interruptMode: interrupt.interruptMode, bodyStored: false, localOnly: true, networkEnabled: false },
-        }, { triggerTurn: false });
+          details: { ...recorded.event, source: "agent-request", mode, priority: interrupt.priority, interruptMode: interrupt.interruptMode, bodyStored: false, localOnly: true, networkEnabled: false },
+        });
+        return true;
       };
       const taskHash = params.message.trim() ? sha256(params.message) : undefined;
       if (guardReason) {
@@ -293,6 +318,7 @@ export function registerComsTools(pi: ExtensionAPI, state?: HarnessRuntimeState)
         const result = { schema: "zob.zpeer-ask-result.v1", status: "blocked", reason: guardReason, targetAlias, taskHash, priority: interrupt.priority, interruptMode: interrupt.interruptMode, interruptStatus, bodyStored: false };
         emitZpeerAskEvent({ kind: "blocked", status: "blocked", reason: guardReason, taskHash, interruptStatus });
         pi.appendEntry("zob-zpeer", { schema: "zob.zpeer-ask.v1", action: "agent_request_blocked", mode, status: "blocked", priority: interrupt.priority, interruptMode: interrupt.interruptMode, interruptStatus, reasonHash: sha256(guardReason), targetAliasHash: sha256(targetAlias), roomIdHash: sha256(requestedRoomId), taskHash, reasonInputHash: params.reason ? sha256(params.reason) : undefined, interruptReasonHash: interrupt.interruptReasonHash, localOnly: true, networkEnabled: false, bodyStored: false, promptBodiesStored: false, outputBodiesStored: false, generatedAt: new Date().toISOString() });
+        await flushZpeerAskEvents();
         return { content: [{ type: "text", text: `zpeer_ask blocked: ${guardReason}` }], details: result };
       }
       const timeoutMs = boundedZpeerAskTimeoutMs(mode, params.timeoutMs);
@@ -323,6 +349,7 @@ export function registerComsTools(pi: ExtensionAPI, state?: HarnessRuntimeState)
         ? `\n\nTransient ZPeer reply (not stored in .pi/coms):\n${result.transientResponse}`
         : "";
       const interruptSuffix = result.interruptStatus ? ` interrupt=${result.interruptStatus}` : interrupt.priority !== "normal" ? ` priority=${interrupt.priority}` : "";
+      await flushZpeerAskEvents();
       return { content: [{ type: "text", text: ok ? `zpeer_ask ${result.status}: @${result.targetAlias ?? targetAlias}${interruptSuffix}${result.outputHash ? ` outputHash=${result.outputHash}` : ""}${passiveWaitSuffix}${transientReplyText}` : `zpeer_ask ${result.status}: ${result.reason ?? "see metadata"}${interruptSuffix}` }], details: { schema: "zob.zpeer-ask-result.v1", mode, ...result } };
     },
   });
@@ -338,7 +365,13 @@ export function registerComsTools(pi: ExtensionAPI, state?: HarnessRuntimeState)
       const responseText = params.message ?? "";
       const outputHash = responseText.trim() ? sha256(responseText) : undefined;
       const inbound = msgId ? state?.zobLive.inboundByMsgId?.[msgId] : undefined;
-      const block = !state ? "zpeer runtime state unavailable" : !msgId ? "msgId is required" : !responseText.trim() ? "message is required" : !inbound ? "no active inbound ZPeer message for msgId" : inbound.responseSent || inbound.requiredResponseStatus === "replied" ? "ZPeer msgId already answered" : inbound.requiredResponseStatus === "expired" ? "ZPeer msgId required response already expired" : !inbound.envelope.replyEndpoint ? "ZPeer inbound msgId has no reply endpoint" : undefined;
+      const block = !state ? "zpeer runtime state unavailable" : !msgId ? "msgId is required" : !responseText.trim() ? "message is required" : !inbound ? "no active inbound ZPeer message for msgId" : inbound.responseSent || inbound.requiredResponseStatus === "replied" ? "ZPeer msgId already answered" : // ZOB-COMS-GUARDS: a late reply after the requireResponse watchdog expired is
+// now PERMITTED. The watchdog already stops reinjecting once reinjectCount hits
+// maxReinjects (events.ts) and the sender's pendingReplies entry resolves to a
+// no-op on a late envelope, so a late reply is harmless at the sender and
+// recovers nudge/reply paths (e.g. a late oracle review). The 'replied' /
+// responseSent guard above still prevents double-replies.
+!inbound.envelope.replyEndpoint ? "ZPeer inbound msgId has no reply endpoint" : undefined;
       if (block) {
         pi.appendEntry("zob-zpeer", { schema: "zob.zpeer-reply.v1", action: "reply_blocked", status: "blocked", reasonHash: sha256(block), msgId, outputHash, localOnly: true, networkEnabled: false, bodyStored: false, promptBodiesStored: false, outputBodiesStored: false, generatedAt: new Date().toISOString() });
         return { content: [{ type: "text", text: `zpeer_reply blocked: ${block}` }], details: { schema: "zob.zpeer-reply-result.v1", status: "blocked", reason: block, msgId, outputHash, bodyStored: false, localOnly: true, networkEnabled: false } };
@@ -357,8 +390,8 @@ export function registerComsTools(pi: ExtensionAPI, state?: HarnessRuntimeState)
         state.zobLive.activeInboundMsgId = undefined;
         state.zobLive.inboundQueue = (state.zobLive.inboundQueue ?? []).filter((candidate) => candidate !== inbound.envelope.msgId);
         const roomId = inbound.envelope.runId?.startsWith("zpeer:") ? inbound.envelope.runId.slice("zpeer:".length) : undefined;
-        state.zobLive.lastEvent = { kind: "response_sent", roomId, fromAlias: inbound.envelope.receiver, toAlias: inbound.envelope.sender, status: "response_sent", msgId: inbound.envelope.msgId, taskHash: inbound.envelope.taskHash, outputHash, priority: inbound.priority, interruptMode: inbound.interruptMode, at: new Date().toISOString(), localOnly: true, networkEnabled: false, bodyStored: false };
-        void pi.sendMessage({ customType: "zob-zpeer-event", content: "ZPeer explicit reply sent", display: true, details: { ...state.zobLive.lastEvent } }, { triggerTurn: false });
+        const recorded = recordZpeerRuntimeEvent(state, { kind: "response_sent", roomId, fromAlias: inbound.envelope.receiver, toAlias: inbound.envelope.sender, status: "response_sent", msgId: inbound.envelope.msgId, taskHash: inbound.envelope.taskHash, outputHash, priority: inbound.priority, interruptMode: inbound.interruptMode });
+        if (recorded.accepted) void pi.sendMessage({ customType: "zob-zpeer-event", content: "ZPeer explicit reply sent", display: true, details: { ...recorded.event } }, { triggerTurn: false });
         pi.appendEntry("zob-zpeer", { schema: "zob.zpeer-reply.v1", action: "reply", status: "response_sent", msgId: inbound.envelope.msgId, taskHash: inbound.envelope.taskHash, outputHash, priority: inbound.priority, interruptMode: inbound.interruptMode, localOnly: true, networkEnabled: false, bodyStored: false, promptBodiesStored: false, outputBodiesStored: false, generatedAt: new Date().toISOString() });
         return { content: [{ type: "text", text: `zpeer_reply sent: msgId=${inbound.envelope.msgId} outputHash=${outputHash}` }], details: { schema: "zob.zpeer-reply-result.v1", status: "response_sent", msgId: inbound.envelope.msgId, taskHash: inbound.envelope.taskHash, outputHash, bodyStored: false, localOnly: true, networkEnabled: false } };
       } catch (error) {

package/.pi/extensions/zob-harness/src/runtime/zpeer-events.ts

@@ -0,0 +1,53 @@
+import { annotateZpeerStatus, shouldAcceptZpeerStatusUpdate } from "../domains/coms/coms-v2/zpeer-status.js";
+import type { HarnessRuntimeState, ZobLiveLastEvent } from "./state.js";
+
+export type ZpeerRuntimeEventInput = Omit<ZobLiveLastEvent, "at" | "localOnly" | "networkEnabled" | "bodyStored" | "terminal" | "statusRank" | "superseded" | "supersededByStatus"> & { at?: string };
+
+export interface ZpeerRuntimeEventRecordResult {
+  accepted: boolean;
+  event: ZobLiveLastEvent;
+  current?: ZobLiveLastEvent;
+}
+
+function materializeZpeerRuntimeEvent(event: ZpeerRuntimeEventInput): ZobLiveLastEvent {
+  return annotateZpeerStatus({
+    ...event,
+    at: event.at ?? new Date().toISOString(),
+    localOnly: true as const,
+    networkEnabled: false as const,
+    bodyStored: false as const,
+  });
+}
+
+export function recordZpeerRuntimeEvent(state: HarnessRuntimeState, event: ZpeerRuntimeEventInput): ZpeerRuntimeEventRecordResult {
+  const next = materializeZpeerRuntimeEvent(event);
+  if (!next.msgId) {
+    state.zobLive.lastEvent = next;
+    return { accepted: true, event: next };
+  }
+
+  state.zobLive.latestZpeerEventByMsgId ??= {};
+  const current = state.zobLive.latestZpeerEventByMsgId[next.msgId];
+  if (!shouldAcceptZpeerStatusUpdate(current, next)) {
+    return {
+      accepted: false,
+      current,
+      event: {
+        ...next,
+        superseded: true,
+        supersededByStatus: current?.status,
+      },
+    };
+  }
+
+  state.zobLive.latestZpeerEventByMsgId[next.msgId] = next;
+  state.zobLive.lastEvent = next;
+  return { accepted: true, event: next, current: next };
+}
+
+export function isCurrentZpeerRuntimeEvent(state: HarnessRuntimeState, event: ZobLiveLastEvent): boolean {
+  if (!event.msgId) return true;
+  const current = state.zobLive.latestZpeerEventByMsgId?.[event.msgId];
+  if (!current) return true;
+  return current.at === event.at && current.status === event.status && current.kind === event.kind;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zob-harness",
-  "version": "0.15.1",
+  "version": "0.15.2",
   "type": "module",
   "description": "A governed Agent Factory for Pi: launch communicating agent teams, run tmux-backed factories, validate artifacts, and package repeatable workflows.",
   "license": "MIT",