@deksden-com/dd-flow-cli 0.9.0-beta.124 → 0.9.0-beta.127

package/dist/harness-runtime/lib/dd-zcode.mjs

@@ -1,15 +1,17 @@
-import { observedTimeout } from "./observation-clock.mjs";
+import { ObservationClock, observedTimeout, validateObservationDuration } from "./observation-clock.mjs";
 import { ToolObservations, acpToolObservation, zcodePhysicalSession } from "./tool-observations.mjs";
-import { invokeNativeHook } from "./native-hook-command.mjs";
-import { parseLifecycleCommand, continuationCommand } from "./lifecycle-command.mjs";
+import { hookBudget, invokeNativeHook } from "./native-hook-command.mjs";
+import { parseLifecycleCommand, continuationCommand, commandOption } from "./lifecycle-command.mjs";
 import { spawn } from "node:child_process";
 import { createHash } from "node:crypto";
 import { appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
-import readline from "node:readline";
 import { closeBridgeProcess } from "./managed-daemon.mjs";
-import { errorRecord } from "./operation-errors.mjs";
+import { errorRecord, isProvenShellCorrection } from "./operation-errors.mjs";
 import { checkObservedProfile, observeModel, observedFields } from "./model-observations.mjs";
+import { commandText } from "./process-json.mjs";
+import { readNativeLines, streamNativeDiagnostics, nativeObservationError } from "./native-streams.mjs";
+import { operationProgressReporter } from "./operation-progress.mjs";
 
 import { readZcodeUsage } from "./zcode-usage.mjs";
 const ZCODE_HARNESS_CONTRACT = "dd-zcode-harness@1";
@@ -18,11 +20,11 @@ export const supportedZcodeHarnessContract = contract => [ZCODE_HARNESS_CONTRACT
 // request.  Keep the original correlation slot briefly so a slow native
 // response (especially cold-start/session creation) can still settle it.
 const LATE_RESPONSE_GRACE_MS = 5_000;
+// Only the owned lifecycle transport can attest a persisted CLI barrier.
+// Model text and arbitrary callback error.details cannot grant correction.
+const correctableLifecycleErrors = new WeakSet();
 
 function fail(message, code) { const error = new Error(message); if (code) error.code = code; throw error; }
-function fatalLifecycleError(error) {
-  return ["invocation_unknown", "invocation_identity_mismatch", "invocation_identity_conflict", "invocation_receipt_missing", "invocation_command_mismatch", "invocation_scope_mismatch", "invocation_generation_stale", "invocation_expired", "zcode_parent_identity_missing", "zcode_tool_identity_conflict", "native_hook_timeout", "native_hook_failed", "native_hook_response_invalid", "hook_storage_unprepared", "storage_write_failed"].includes(error?.code);
-}
 function absolute(value, label) { if (!value || !path.isAbsolute(value)) fail(`${label} must be an absolute path`); return path.resolve(value); }
 function text(value, label) { if (typeof value !== "string" || !value.trim()) fail(`${label} is required`); return value.trim(); }
 function now() { return new Date().toISOString(); }
@@ -39,27 +41,12 @@ function executable(command, args = []) {
 
 async function commandOutput(command, args) {
   const target = executable(command, args);
-  return await new Promise((resolve, reject) => {
-    const child = spawn(target.command, target.args, { stdio: ["ignore", "pipe", "pipe"] });
-    let stdout = ""; let stderr = "";
-    child.stdout.setEncoding("utf8").on("data", (chunk) => (stdout += chunk));
-    child.stderr.setEncoding("utf8").on("data", (chunk) => (stderr += chunk));
-    child.on("error", reject);
-    child.on("close", (code) => code === 0 ? resolve(stdout.trim()) : reject(new Error(stderr.trim() || `${target.command} exited ${code}`)));
-  });
+  return await commandText(target.command, target.args, { phase: "native-version" });
 }
 
 async function runWithStdin(command, args, stdin, env = {}) {
   const target = executable(command, args);
-  return await new Promise((resolve, reject) => {
-    const child = spawn(target.command, target.args, { env: { ...process.env, ...env }, stdio: ["pipe", "pipe", "pipe"] });
-    let stdout = ""; let stderr = "";
-    child.stdout.setEncoding("utf8").on("data", (chunk) => (stdout += chunk));
-    child.stderr.setEncoding("utf8").on("data", (chunk) => (stderr += chunk));
-    child.on("error", reject);
-    child.on("close", (code) => code === 0 ? resolve(stdout.trim()) : reject(new Error(stderr.trim() || `${target.command} exited ${code}`)));
-    child.stdin.end(stdin);
-  });
+  return await commandText(target.command, target.args, { input: stdin, env, phase: "usage-ingest" });
 }
 
 class Journal {
@@ -73,6 +60,7 @@ class Journal {
     if (!this.file) return;
     const line = JSON.stringify({ order: ++this.order, observed_at: now(), kind, payload });
     this.pending = this.pending.then(() => appendFile(this.file, `${line}\n`));
+    void this.pending.catch(() => {});
     return this.pending;
   }
   writeInbound(payload, method) {
@@ -110,6 +98,7 @@ class Journal {
       }
       await appendFile(this.file, `${line}\n`);
     });
+    void this.pending.catch(() => {});
     return this.pending;
   }
   async flush() { await this.pending; }
@@ -158,8 +147,11 @@ export class AcpBridge {
   }
 
   configure(options) { this.options = { ...this.options, ...options }; }
-  registerModelSession(adapterId, sessionId, requested, parentSessionId = null, armed = true) {
-    this.modelSessions.set(adapterId, { sessionId, requested, parentSessionId, armed });
+  registerModelSession(adapterId, sessionId, requested, parentSessionId = null, armed = true, bindCurrentRequest = false) {
+    const parentAdapter = parentSessionId ? [...this.modelSessions].find(([key, value]) => key === parentSessionId || value.sessionId === parentSessionId)?.[0] : null;
+    const parentRequest = this.activityOwner(parentAdapter);
+    const prior = this.modelSessions.get(adapterId);
+    this.modelSessions.set(adapterId, { sessionId, requested, parentSessionId, armed, parentRequestId: prior && !bindCurrentRequest ? prior.parentRequestId ?? null : parentRequest?.id ?? null });
   }
   async recordModel(adapterId, observed, source) {
     const identity = this.modelSessions.get(adapterId); if (!identity) return;
@@ -183,15 +175,15 @@ export class AcpBridge {
     const target = executable(this.options.bin, this.options.commandArgs ?? ["server"]);
     const cwd = this.options.cwd ? absolute(this.options.cwd, "--cwd") : process.cwd();
     this.child = spawn(target.command, target.args, { cwd, detached: process.platform !== "win32", stdio: ["pipe", "pipe", "pipe"], env: { ...process.env, ...(this.options.env ?? {}) } });
-    this.child.stderr.setEncoding("utf8").on("data", (chunk) => { this.bridgeStderr += String(chunk); this.journal.write("bridge_stderr", { text: String(chunk) }); });
+    this.diagnostics = streamNativeDiagnostics(this.child.stderr, async chunk => { this.bridgeStderr = (this.bridgeStderr + chunk).slice(-65_536); await this.journal.write("bridge_stderr", { text: chunk }); }, error => this.rejectAll(error));
     this.child.stdin?.on("error", (error) => {
       error.details = { system_code: error.code ?? null };
       error.code = "bridge_pipe_broken";
       this.rejectAll(error);
     });
     this.child.on("error", (error) => { error.code ??= "bridge_exited"; this.rejectAll(error); });
-    this.child.on("exit", (code) => { const error = new Error(`zcode-acp exited ${code}${this.bridgeStderr.trim() ? `: ${this.bridgeStderr.trim()}` : ""}`); error.code = "bridge_exited"; this.rejectAll(error); });
-    readline.createInterface({ input: this.child.stdout }).on("line", (line) => this.receive(line));
+    this.child.on("close", code => { void Promise.all([this.nativeDrain, this.diagnostics]).then(() => { const error = new Error(`zcode-acp exited ${code}${this.bridgeStderr.trim() ? `: ${this.bridgeStderr.trim()}` : ""}`); error.code = "bridge_exited"; this.rejectAll(error); }); });
+    this.nativeDrain = readNativeLines(this.child.stdout, async line => { this.receive(line); await this.journal.flush(); }, error => this.rejectAll(error));
     if (this.options.onSpawn) await this.options.onSpawn(this.child);
     return await this.request("initialize", {
       protocolVersion: 1,
@@ -206,15 +198,23 @@ export class AcpBridge {
     const request = message.id !== undefined ? this.pending.get(message.id) : null;
     const expired = message.id !== undefined ? this.expiredRequests.get(message.id) : null;
     const isResponse = message.id !== undefined && !message.method;
+    const rejected = isResponse && this.rejectedHookRequests?.get(message.id);
+    if (rejected) {
+      this.rejectedHookRequests.delete(message.id);
+      const terminal = { request_id: message.id, method: rejected.method, session_id: rejected.sessionId, terminal_response: message };
+      rejected.error.details = { ...rejected.error.details, native_terminal_after_hook_failure: terminal };
+      try { void Promise.resolve(this.journal.write("native_terminal_after_hook_failure", terminal)).catch(storage => { rejected.error.cleanup_error ??= errorRecord(storage); }); }
+      catch (storage) { rejected.error.cleanup_error ??= errorRecord(storage); }
+    }
     if (!isResponse || request) this.journal.writeInbound(message, request?.method);
-    if (typeof message.params?.sessionId === "string" && isProductiveSessionNotification(message)) this.sessionActivity.set(message.params.sessionId, Date.now());
+    if (typeof message.params?.sessionId === "string" && isProductiveSessionNotification(message)) this.observeActivity(message.params.sessionId, message.params.update);
     const update = message.params?.update;
     // ZCode emits this as `session/update`; Grok Build wraps the same ACP
     // payload in `_x.ai/session_notification`.  Preserve either provider's
     // native error before its generic JSON-RPC terminal response arrives.
     if (typeof message.params?.sessionId === "string" && update?.sessionUpdate === "retry_state" && update.type === "failed") {
       for (const pending of this.pending.values()) {
-        if (pending.method === "session/prompt" && pending.sessionId === message.params.sessionId) pending.providerError = update;
+        if (pending.method === "session/prompt" && pending.sessionId === message.params.sessionId && !pending.providerError) pending.providerError = { ...update, observed_at: now(), provider_session_id: pending.sessionId, source: message.method };
       }
     }
     if (message.method === "session/update" && message.params?.update?.sessionUpdate === "agent_message_chunk" && message.params.update.content?.type === "text") {
@@ -236,17 +236,21 @@ export class AcpBridge {
       const pending = Promise.resolve().then(() => observer(message)).catch(async error => {
         // A validated no-effect rejection is returned through the invocation
         // ledger. It is evidence, not a poisoned ACP Session.
-        const fatal = fatalLifecycleError(error);
         const current = this.options.onLifecycleNotification === observer;
-        if (current && (!this.notificationError || fatal && !fatalLifecycleError(this.notificationError) && this.notificationError.code !== "profile_integrity_violation")) this.notificationError = error;
+        const correctable = current && correctableLifecycleErrors.has(error);
+        if (current && !correctable) {
+          this.lifecycleFailure ??= this.notificationError?.code === "profile_integrity_violation" ? this.notificationError : error;
+          this.notificationError = this.lifecycleFailure;
+        }
         // A missing/foreign authority is not a recoverable CLI validation
         // result. Stop admitting productive requests immediately; the managed
         // controller still owns physical stop/drain and evidence capture.
-        if (fatal && current) this.rejectAll(this.notificationError ?? error);
+        if (current && !correctable) this.rejectAll(this.notificationError);
         try {
-          await this.journal.write("notification_failure", { code: error.code ?? "invocation_observation_failed", message: error.message, ...(error.details ? { details: error.details } : {}),
-            session_id: message.params?.sessionId ?? null, tool_call_id: update?.toolCallId ?? null, event_time: now(), delivery_stage: "lifecycle_receipt", completeness: "incomplete" });
+          await hookBudget(1_000, null).run(() => this.journal.write("notification_failure", { ...errorRecord(error),
+            session_id: message.params?.sessionId ?? null, tool_call_id: update?.toolCallId ?? null, event_time: now(), delivery_stage: "lifecycle_receipt", completeness: "incomplete" }), "failure_persistence");
         } catch (persistenceError) {
+          if (current) this.notificationError ??= persistenceError;
           process.stderr.write(`${JSON.stringify({ code: error.code, message: error.message, persistence_error: persistenceError.message })}\n`);
         }
       });
@@ -276,6 +280,7 @@ export class AcpBridge {
         error.code = unknown ? nativeCode : /payment required|quota|usage balance exhausted|insufficient.?credit|billing/i.test(messageText) ? "provider_quota_exhausted" : /rate.?limit|too many requests/i.test(messageText) ? "provider_rate_limited" : /\b429\b/.test(messageText) ? "provider_limit_unknown" : "acp_request_failed";
         error.retryable = error.code === "provider_rate_limited";
         error.details = { acp_code: message.error.code ?? null,
+          observed_at: provider?.observed_at ?? now(), provider_session_id: pending.sessionId ?? null, source: "acp.error_response", request_id: message.id,
           terminal_response: { method: pending.method, session_id: pending.sessionId, request_id: message.id },
           ...(data ? { native: data } : {}), ...(details ? { provider_details: details } : {}), ...(providerDetails ? { provider_update: provider } : {}) };
         pending.reject(error);
@@ -300,6 +305,60 @@ export class AcpBridge {
     this.toolObservations.add(acpToolObservation(message, { harness: this.options.observationHarness ?? "zcode-acp", rootSessionId }));
   }
 
+  observeActivity(sessionId, update) {
+    const observedAt = Date.now(), seen = new Set();
+    let adapterId = sessionId;
+    // ACP has no Turn ID: scope direct notifications to the active request on
+    // this connection, and descendants to their parent's dispatch generation.
+    const owner = this.activityOwner(adapterId);
+    if (!owner) return;
+    if (["tool_call", "tool_call_update"].includes(update?.sessionUpdate)) {
+      const toolId = update.toolCallId;
+      if (!toolId) return;
+      owner.toolProgress ??= new Map();
+      const signature = JSON.stringify({ status: update.status, kind: update.kind, title: update.title, content: update.content, rawInput: update.rawInput, rawOutput: update.rawOutput });
+      const key = `${sessionId}:${toolId}`, previous = owner.toolProgress.get(key);
+      if (previous === signature) return;
+      // An empty update is only a replay/metadata snapshot, not tool work.
+      if (update.sessionUpdate === "tool_call_update" && !update.status && !update.content?.length && update.rawInput === undefined && update.rawOutput === undefined) return;
+      if (owner.toolProgress.size >= 1_024 && !owner.toolProgress.has(key)) return;
+      owner.toolProgress.set(key, signature);
+    }
+    while (adapterId && !seen.has(adapterId)) {
+      seen.add(adapterId);
+      const pending = [...this.pending.values()].find(value => value.method === "session/prompt" && value.sessionId === adapterId);
+      if (pending) {
+        pending.progress = { cursor: (pending.progress?.cursor ?? 0) + 1, observed_at: observedAt };
+        const rejectObservation = cause => {
+          if (this.pending.get(pending.id) !== pending) return;
+          clearTimeout(pending.timer); if (pending.idleTimer) clearInterval(pending.idleTimer);
+          this.pending.delete(pending.id); pending.reject(nativeObservationError(cause));
+        };
+        void pending.publish("native_progress", { native_request_id: String(pending.id), session_id: adapterId, observed_at: new Date(observedAt).toISOString() }).catch(rejectObservation);
+        this.sessionActivity.set(adapterId, observedAt);
+        void Promise.resolve(this.options.onActivity?.({ sessionId: adapterId, requestId: pending.id, progress: pending.progress })).catch(rejectObservation);
+      }
+      const child = this.modelSessions.get(adapterId), parent = child?.parentSessionId;
+      const next = parent ? [...this.modelSessions].find(([key, value]) => key === parent || value.sessionId === parent)?.[0] : null;
+      const parentPending = this.activityOwner(next);
+      adapterId = parentPending?.id === child?.parentRequestId ? next : null;
+    }
+  }
+
+  activityOwner(sessionId) {
+    const path = [], seen = new Set();
+    while (sessionId && !seen.has(sessionId)) {
+      seen.add(sessionId);
+      const pending = [...this.pending.values()].find(value => value.method === "session/prompt" && value.sessionId === sessionId);
+      if (pending) return path.every(child => child.parentRequestId === pending.id) ? pending : null;
+      const identity = this.modelSessions.get(sessionId);
+      if (!identity?.parentSessionId) return null;
+      path.push(identity);
+      sessionId = [...this.modelSessions].find(([key, value]) => key === identity.parentSessionId || value.sessionId === identity.parentSessionId)?.[0];
+    }
+    return null;
+  }
+
   toolSummary(sessionId) {
     return this.toolObservations.summary(this.modelSessions.get(sessionId)?.sessionId ?? sessionId);
   }
@@ -330,7 +389,9 @@ export class AcpBridge {
   }
 
   request(method, params = {}, timeoutMs = 30_000, { idleSessionId = null, idleTimeoutMs = null, inactivityMode = "reject" } = {}) {
-    if ((this.notificationError?.code === "profile_integrity_violation" || fatalLifecycleError(this.notificationError)) && ["session/new", "session/prompt", "session/fork"].includes(method)) return Promise.reject(this.notificationError);
+    if (timeoutMs !== null) validateObservationDuration(timeoutMs);
+    if (idleTimeoutMs !== null) validateObservationDuration(idleTimeoutMs);
+    if ((this.lifecycleFailure || this.notificationError?.code === "profile_integrity_violation") && ["session/new", "session/prompt", "session/fork"].includes(method)) return Promise.reject(this.lifecycleFailure ?? this.notificationError);
     if (this.inactivityError && ["session/new", "session/prompt", "session/fork"].includes(method)) return Promise.reject(this.inactivityError);
     const id = this.nextId++;
     return new Promise((resolve, reject) => {
@@ -354,39 +415,32 @@ export class AcpBridge {
             this.expiredRequests.set(id, { method, sessionId: params.sessionId ?? null });
             while (this.expiredRequests.size > 128) this.expiredRequests.delete(this.expiredRequests.keys().next().value);
             finish(timeoutError);
-          }, LATE_RESPONSE_GRACE_MS);
-        }, timeoutMs)
+          }, LATE_RESPONSE_GRACE_MS, { progress: () => pending.progress });
+        }, timeoutMs, { progress: () => this.pending.get(id)?.progress })
         : null;
       const validIdleTimeout = Number.isFinite(idleTimeoutMs) && idleTimeoutMs > 0 ? idleTimeoutMs : null;
       if (idleSessionId) this.sessionActivity.set(idleSessionId, Date.now());
-      let lastTimerAt = Date.now();
-      let resumedAt = null;
-      let inactivityRecorded = false;
+      const clock = validIdleTimeout ? new ObservationClock({ timeoutMs: validIdleTimeout,
+        onGap: gap => this.journal.write("observation_gap", { ...gap, method, request_id: id, session_id: idleSessionId }) }) : null;
+      let checking = false, quietCursor = null;
       const checkIdle = async () => {
-        if (!this.pending.has(id)) return;
-        const observedAt = Date.now();
-        const observationGapMs = observedAt - lastTimerAt;
-        lastTimerAt = observedAt;
-        // A host pause makes wall time jump while this process cannot observe
-        // native progress. Keep the SAME native request alive so its late
-        // result can still be persisted. Grant one fresh observation window;
-        // do not rewrite provider activity or resend the request.
-        if (observationGapMs > 60_000) {
-          resumedAt = observedAt;
-          this.journal.write("observation_gap", { method, request_id: id, session_id: idleSessionId, observation_gap_ms: observationGapMs, observed_at: new Date(observedAt).toISOString() });
-          return;
-        }
-        const lastActivity = this.sessionActivity.get(idleSessionId) ?? Date.now();
-        if (observedAt - Math.max(lastActivity, resumedAt ?? lastActivity) < validIdleTimeout || inactivityRecorded) return;
-        // ACP silence is diagnostic only. A native child can be computing while
-        // its Session is non-resident and therefore unsubscribable.
-        inactivityRecorded = true;
-        this.journal.write("inactivity_detected", { method, request_id: id, session_id: idleSessionId, last_activity_at: new Date(lastActivity).toISOString(), idle_timeout_ms: validIdleTimeout, observed_at: new Date(observedAt).toISOString() });
-        if (inactivityMode !== "diagnostic") {
-          finish(Object.assign(new Error(`${method} received no session update for ${validIdleTimeout}ms`), { code: "subject_liveness_timeout", details: { session_id: idleSessionId, last_activity_at: new Date(lastActivity).toISOString(), idle_timeout_ms: validIdleTimeout } }));
-          return;
-        }
-        await this.options.onInactivity?.({ method, requestId: id, sessionId: idleSessionId, lastActivityAt: lastActivity, idleTimeoutMs: validIdleTimeout });
+        const pending = this.pending.get(id);
+        if (!pending || checking || !clock.sample(pending.progress)) return;
+        const cursor = pending.progress?.cursor ?? 0;
+        if (quietCursor === cursor) return;
+        quietCursor = cursor; checking = true;
+        const lastActivity = this.sessionActivity.get(idleSessionId) ?? pending.dispatchedAt;
+        try {
+          this.journal.write("inactivity_detected", { method, request_id: id, session_id: idleSessionId, last_activity_at: new Date(lastActivity).toISOString(), idle_timeout_ms: validIdleTimeout, observed_at: now() });
+          if (inactivityMode === "diagnostic") await this.options.onInactivity?.({ method, requestId: id, sessionId: idleSessionId, lastActivityAt: lastActivity, idleTimeoutMs: validIdleTimeout, cursor });
+          const current = this.pending.get(id);
+          if (current !== pending || (current.progress?.cursor ?? 0) !== cursor || !clock.sample(current.progress)) return;
+          this.expiredRequests.set(id, { method, sessionId: pending.sessionId });
+          finish(Object.assign(new Error(`${method} native outcome cannot be confirmed after ${validIdleTimeout}ms of silence`), { code: clock.observationLost ? "operation_observation_lost" : "subject_liveness_timeout", details: { request_id: id, session_id: idleSessionId, last_activity_at: new Date(lastActivity).toISOString(), idle_timeout_ms: validIdleTimeout, native_outcome: "unknown" } }));
+        } catch (error) {
+          const current = this.pending.get(id);
+          if (current === pending && (current.progress?.cursor ?? 0) === cursor) finish(Object.assign(new Error("ACP inactivity reconciliation could not confirm the native outcome"), { code: "operation_observation_lost", details: { request_id: id, session_id: idleSessionId, native_outcome: "unknown", observation_error: errorRecord(error) }, cause: error }));
+        } finally { checking = false; }
       };
       const idleTimer = validIdleTimeout ? setInterval(() => {
         void checkIdle().catch((error) => {
@@ -397,8 +451,9 @@ export class AcpBridge {
           void this.journal.write("inactivity_observation_failure", { method, request_id: id, session_id: idleSessionId, error: { code: error?.code ?? "inactivity_observation_failed", message: error?.message ?? String(error) } }).catch(() => {});
         });
       }, Math.max(10, Math.min(1_000, Math.floor(validIdleTimeout / 4)))) : null;
-      this.pending.set(id, { resolve, reject, timer, idleTimer, method, sessionId: params.sessionId ?? null });
+      this.pending.set(id, { id, resolve, reject, timer, idleTimer, method, sessionId: params.sessionId ?? null, dispatchedAt: Date.now(), publish: operationProgressReporter() });
       this.send({ jsonrpc: "2.0", id, method, params });
+      if (method === "session/prompt") this.journal.write("native_dispatch", { operation_id: this.dispatchOperationId ?? process.env.DD_EVAL_OPERATION_ID ?? null, session_id: params.sessionId, native_request_id: id });
     });
   }
 
@@ -414,8 +469,18 @@ export class AcpBridge {
     try { stdin.write(`${JSON.stringify(message)}\n`); }
     catch (error) { error.details = { system_code: error.code ?? null }; error.code = "bridge_pipe_broken"; this.rejectAll(error); throw error; }
   }
-  rejectAll(error) { for (const pending of this.pending.values()) { clearTimeout(pending.timer); if (pending.idleTimer) clearInterval(pending.idleTimer); pending.reject(error); } this.pending.clear(); }
+  rejectAll(error) {
+    for (const [id, pending] of this.pending) {
+      if (this.notificationError === error && pending.method === "session/prompt") {
+        this.rejectedHookRequests ??= new Map(); this.rejectedHookRequests.set(id, { method: pending.method, sessionId: pending.sessionId, error });
+        if (this.rejectedHookRequests.size > 32) this.rejectedHookRequests.delete(this.rejectedHookRequests.keys().next().value);
+      }
+      clearTimeout(pending.timer); if (pending.idleTimer) clearInterval(pending.idleTimer); pending.reject(error);
+    }
+    this.pending.clear();
+  }
   async flush() {
+    if (this.notificationError) throw this.notificationError;
     try { await Promise.all([...this.lifecycleNotifications]); await this.notifications; await this.journal.flush(); }
     catch (error) { throw this.notificationError ?? error; }
     if (this.notificationError) throw this.notificationError;
@@ -425,8 +490,10 @@ export class AcpBridge {
     // Productive notification failures belong to flush()/the original Turn.
     // Draining them must not relabel a successful physical shutdown as failed.
     return await closeBridgeProcess(this, async () => {
+      await Promise.all([this.nativeDrain, this.diagnostics]);
       await Promise.allSettled([...this.lifecycleNotifications, this.notifications]);
-      await this.journal.flush();
+      if (this.notificationError) await hookBudget(1_000, null).run(() => this.journal.flush(), "failure_drain");
+      else await this.journal.flush();
     });
   }
 }
@@ -439,8 +506,8 @@ function isProductiveSessionNotification(message) {
   // synthetic flag through the ACP wire contract.
   if (update?.sessionUpdate === "heartbeat" || update?.type === "heartbeat") return false;
   if (update?.sessionUpdate === "agent_thought_chunk" && typeof update?.messageId === "string" && update.messageId.startsWith("thinking_")) return false;
-  if ((update?.sessionUpdate === "status" || update?.type === "status") && update?.status === "running") return false;
-  return true;
+  if (["agent_message_chunk", "agent_thought_chunk"].includes(update?.sessionUpdate)) return update.content?.type === "text" && typeof update.content.text === "string" && update.content.text.length > 0;
+  return ["agent_message_chunk", "agent_thought_chunk", "tool_call", "tool_call_update"].includes(update?.sessionUpdate);
 }
 
 // The qualified bridge encodes exactly providerId\\modelId; no other suffix or
@@ -472,16 +539,14 @@ async function resume(bridge, sessionId, cwd) {
 /** Ended children are paginated by the native API (20 by default). A partial
  * directory is never settlement evidence, including during teardown. */
 export async function readZcodeSubagents(bridge, sessionId, timeoutMs = 30_000, retained = false) {
-  const deadline = performance.now() + timeoutMs;
+  const clock = new ObservationClock({ timeoutMs });
   const cursors = new Set(), ended = new Map();
   let first, cursor;
   for (;;) {
-    const remaining = deadline - performance.now();
-    if (remaining <= 0) fail("ZCode child observation deadline expired", "native_topology_incomplete");
-    const response = await bridge.request(retained ? "zcode/session/retainedSubagents" : "zcode/session/subagents", { sessionId, ...(cursor ? { endedCursor: cursor } : {}) }, remaining);
+    if (clock.sample()) fail("ZCode child observation is unavailable", "operation_observation_lost");
+    const response = await bridge.request(retained ? "zcode/session/retainedSubagents" : "zcode/session/subagents", { sessionId, ...(cursor ? { endedCursor: cursor } : {}) }, timeoutMs);
     if (retained && response?.sessionId !== sessionId) fail("Retained ZCode child directory has a foreign Session identity", "native_topology_incomplete");
     const page = retained ? response.topology : response;
-    if (performance.now() >= deadline) fail("ZCode child observation deadline expired", "native_topology_incomplete");
     if (!page || !Array.isArray(page.running)) fail("ZCode child directory is unavailable", "native_topology_incomplete");
     if (!first) first = page;
     if (!page.ended) {
@@ -503,6 +568,8 @@ export async function readZcodeSubagents(bridge, sessionId, timeoutMs = 30_000,
     }
     if (typeof cursor !== "string" || cursors.has(cursor) || !Number.isSafeInteger(first.revision)) fail("ZCode child pagination has no advancing, versioned cursor", "native_topology_incomplete");
     cursors.add(cursor);
+    if (cursors.size > 1_024) fail("ZCode child pagination exceeds its bounded directory limit", "native_topology_incomplete");
+    clock.sample(cursor);
   }
 }
 
@@ -564,12 +631,11 @@ export function zcodeChildSessionIds(snapshot) {
 // No resolve/read/subagents extension here: those may implicitly resume.
 export async function observeClosedZcodeTree(bridge, root, retainedChildren = [], neverPromptedRootProof = null) {
   const pending = new Set([root, ...retainedChildren]), residents = [], snapshots = [];
-  const deadline = performance.now() + 30_000;
+  const clock = new ObservationClock({ timeoutMs: 30_000 });
   try {
     for (const sessionId of pending) {
-      if (pending.size > 1024 || performance.now() >= deadline) throw new Error("Closed tree observation limit exceeded");
-      const timeout = () => Math.max(1, Math.min(5000, deadline - performance.now()));
-      const resident = await bridge.request("zcode/session/resident", { sessionId }, timeout());
+      if (pending.size > 1024 || clock.sample()) throw new Error("Closed tree observation limit exceeded");
+      const resident = await bridge.request("zcode/session/resident", { sessionId }, 5_000);
       if (resident?.sessionId !== sessionId || typeof resident.resident !== "boolean") throw new Error("Invalid residency identity or state");
       residents.push(resident);
       // A newly allocated root is not durable in ZCode until its first prompt.
@@ -581,7 +647,7 @@ export async function observeClosedZcodeTree(bridge, root, retainedChildren = []
         snapshots.push({ sessionId, childSessionIds: [], running: [], ended: {total:0,items:[]}, provenance: neverPromptedRootProof });
         continue;
       }
-      const tree = await readZcodeSubagents(bridge, sessionId, deadline - performance.now(), true);
+      const tree = await readZcodeSubagents(bridge, sessionId, 30_000, true);
       if (!Array.isArray(tree?.childSessionIds)
         || tree.childSessionIds.some(id => typeof id !== "string" || !id || id === sessionId)
         || !Array.isArray(tree?.running) || !Array.isArray(tree?.ended?.items)
@@ -589,11 +655,12 @@ export async function observeClosedZcodeTree(bridge, root, retainedChildren = []
         || tree.ended.total > tree.childSessionIds.length
         || [...tree.running, ...tree.ended.items].some(child => !tree.childSessionIds.includes(child?.childSessionId))) throw new Error("Incomplete retained native topology");
       snapshots.push({ sessionId, ...tree });
+      clock.sample(sessionId);
       for (const child of tree.childSessionIds) pending.add(child);
     }
     return { topology: { root_session_id: root, child_session_ids: [...pending].filter(id => id !== root), complete: true }, residents, snapshots, settled: residents.every(item => item.resident === false) };
   } catch (error) {
-    return { topology: { root_session_id: root, child_session_ids: [...pending].filter(id => id !== root), complete: false }, residents, snapshots, settled: false, observation_error: { code: error.code ?? "topology_observation_failed", message: error.message } };
+    return { topology: { root_session_id: root, child_session_ids: [...pending].filter(id => id !== root), complete: false }, residents, snapshots, settled: false, observation_error: errorRecord(error) };
   }
 }
 
@@ -608,7 +675,7 @@ async function cancelTree(bridge, sessionId, before, providerSessionId, retained
     const taskId = child.taskId ?? child.agentId;
     if (taskId) {
       try { cancellations.push(await bridge.request("session/cancelBackgroundTask", { sessionId, taskId })); }
-      catch (error) { cancellations.push({ taskId, cancelled: false, error: { code: error.code ?? "cancel_failed", message: error.message } }); }
+      catch (error) { cancellations.push({ taskId, cancelled: false, error: errorRecord(error) }); }
     }
   }
   // ZCode's stop is deliberately idempotent. A stop acknowledgement is not a
@@ -621,8 +688,8 @@ async function cancelTree(bridge, sessionId, before, providerSessionId, retained
     await new Promise((resolve) => setTimeout(resolve, 1000));
     const timeout = Math.max(1, deadline - Date.now());
     [after, read] = await Promise.all([
-      readZcodeSubagents(bridge, sessionId, timeout).catch(error => ({ observation_error: { code: error.code, message: error.message } })),
-      bridge.request("zcode/session/read", { sessionId }, timeout).catch(error => ({ observation_error: { code: error.code, message: error.message } })),
+      readZcodeSubagents(bridge, sessionId, timeout).catch(error => ({ observation_error: errorRecord(error) })),
+      bridge.request("zcode/session/read", { sessionId }, timeout).catch(error => ({ observation_error: errorRecord(error) })),
     ]);
     root_status = read?.projection?.status ?? read?.session?.status ?? null;
     remember(after);
@@ -635,7 +702,7 @@ async function cancelTree(bridge, sessionId, before, providerSessionId, retained
   }
   let close = null;
   try { close = await bridge.request("zcode/session/close", { sessionId }); }
-  catch (error) { close = { closed: false, error: { code: error.code ?? "close_failed", message: error.message } }; }
+  catch (error) { close = { closed: false, error: errorRecord(error) }; }
   const observation = close?.closed === true ? await observeClosedZcodeTree(bridge, providerSessionId, [...knownChildren], neverPromptedRootProof ? {...neverPromptedRootProof,close_confirmed:true} : null)
     : { topology: { root_session_id: providerSessionId, child_session_ids: [...knownChildren], complete: false }, settled: false };
   return { cancellations, before, after, root_status, cancellation_requested: true, close_requested: true, close, ...observation };
@@ -719,10 +786,10 @@ function requireJournal(options) { absolute(options.journal, "--journal"); }
 function receipt(options, value) { return options.daemonId ? { daemon_id: options.daemonId, ...value } : value; }
 
 async function withBridge(options, operation) {
-  const bridge = new AcpBridge(options); let primary;
-  try { const initialized = await bridge.start(); const result = await operation(bridge, initialized); await bridge.flush(); return result; }
-  catch (error) { primary = error; throw error; }
-  finally { try { await bridge.close(); } catch (error) { if (!primary) throw error; primary.cleanup_error = errorRecord(error); primary.details = { ...primary.details, cleanup_error: primary.cleanup_error }; } }
+  const bridge = new AcpBridge(options); let primary, result;
+  try { const initialized = await bridge.start(); result = await operation(bridge, initialized); await bridge.flush(); return result; }
+  catch (error) { primary = result === undefined ? error : nativeObservationError(error, { result }); throw primary; }
+  finally { try { await bridge.close(); } catch (error) { if (!primary) throw nativeObservationError(error, result === undefined ? {} : { result }); primary.cleanup_error = errorRecord(error); primary.details = { ...primary.details, cleanup_error: primary.cleanup_error }; } }
 }
 
 function flowForwarder(options, rootProviderSessionId, bridge) {
@@ -744,16 +811,22 @@ function flowForwarder(options, rootProviderSessionId, bridge) {
 export async function zcodeInvocationObserver(options, rootProviderSessionId, send = invokeNativeHook) {
   if (!options.ddFlowBin) return async () => {};
   const owners = new Map();
-  const remember = message => {
+  const remember = (message, mandatory = false) => {
     const update = message.params?.update;
     if (message.method !== "session/update" || update?.sessionUpdate !== "tool_call") return null;
     if (options.adapterSessionId && message.params?.sessionId !== options.adapterSessionId) return null;
     const native = update._meta?.zcodeRuntime ?? {};
     const session = zcodePhysicalSession(update, rootProviderSessionId);
-    if (!session) throw Object.assign(new Error("Native subagent event has no physical child identity"), { code: "zcode_child_identity_missing" });
+    if (!session) {
+      if (mandatory) throw Object.assign(new Error("Native subagent event has no physical child identity"), { code: "zcode_child_identity_missing" });
+      return null;
+    }
     const key = update.toolCallId;
     if (!key || typeof session !== "string") return null;
-    if (owners.has(key) && owners.get(key) !== session) throw Object.assign(new Error("Native tool id has conflicting Session ownership"), { code: "zcode_tool_identity_conflict" });
+    if (owners.has(key) && owners.get(key) !== session) {
+      if (mandatory) throw Object.assign(new Error("Native tool id has conflicting Session ownership"), { code: "zcode_tool_identity_conflict" });
+      return null;
+    }
     owners.set(key, session);
     return { update, native, session };
   };
@@ -766,21 +839,35 @@ export async function zcodeInvocationObserver(options, rootProviderSessionId, se
       }
     } catch (error) { if (error.code !== "ENOENT") throw error; }
   }
+  // The same native Session can host several Turns. Retained tool IDs belong
+  // to earlier Turns; a delayed duplicate cannot reject a new prompt waiter.
+  const priorTools = new Set(owners.keys());
   return async message => {
-    const facts = remember(message);
+    if (priorTools.has(message.params?.update?.toolCallId)) return;
+    const candidate = message.params?.update, command = candidate?.rawInput?.command ?? candidate?.rawInput?.cmd;
+    const shell = ["Bash", "bash", "execute"].includes(candidate?._meta?.claudeCode?.toolName) && typeof command === "string";
+    const analysis = shell ? parseLifecycleCommand(command) : null;
+    const mandatory = shell && (analysis.kind !== "none" || ["lifecycle", "auxiliary"].includes(analysis.participation) || continuationCommand(command));
+    const facts = remember(message, mandatory);
     if (!facts || !options.ddFlowBin) return;
-    const { update, native, session } = facts;
-    const command = update.rawInput?.command ?? update.rawInput?.cmd;
-    const toolName = update._meta?.claudeCode?.toolName;
-    if (!["Bash", "bash", "execute"].includes(toolName) || typeof command !== "string") return;
-    const analysis = parseLifecycleCommand(command);
-    if (analysis.kind === "none" && !analysis.unresolved && !continuationCommand(command)) return;
+    const { native, session } = facts;
+    if (!mandatory) return;
     const parent = session === rootProviderSessionId ? null : owners.get(native.parentToolCallId);
     if (session !== rootProviderSessionId && !parent) throw Object.assign(new Error("Native child has no confirmed immediate parent tool owner"), { code: "zcode_parent_identity_missing" });
-    await send({ bin: options.ddFlowBin, home: options.ddFlowHome,
-      args: ["zcode", "event", "handle", "--project-root", options.projectRoot ?? options.cwd, "--json"],
-      payload: { ...message, _meta: { ddZcode: { daemonId: options.daemonId, rootProviderSessionId, parentProviderSessionId: parent } } },
-    });
+    try {
+      await send({ bin: options.ddFlowBin, home: options.ddFlowHome,
+        args: ["zcode", "event", "handle", "--project-root", options.projectRoot ?? options.cwd, "--json"],
+        payload: { ...message, _meta: { ddZcode: { daemonId: options.daemonId, rootProviderSessionId, parentProviderSessionId: parent } } },
+      });
+    } catch (error) {
+      const details = error.details;
+      // Issued-ID commands cannot cross the CLI CAS without the receipt.
+      // This proof concerns lifecycle effects only, never shell-prefix replay.
+      if (analysis.kind !== "none" && commandOption(analysis.invocation, "invocation-id")
+        && isProvenShellCorrection(error)
+        && details.issued_invocation_id === commandOption(analysis.invocation, "invocation-id")) correctableLifecycleErrors.add(error);
+      throw error;
+    }
   };
 }
 
@@ -918,19 +1005,20 @@ export async function promptSessionWithBridge(bridge, options) {
   catch (error) { initial_usage_error = { code: error.code ?? "usage_observation_failed", message: error.message ?? String(error) }; }
   // This is the request budget. ACP silence is observed separately and must
   // never turn a long native child request into a fabricated provider failure.
-  const timeoutMs = options.timeoutMs === undefined ? 1_800_000 : options.timeoutMs;
+  const timeoutMs = null;
   const textCursor = bridge.assistantTextCursor(identity.adapterSessionId);
   options.assertDispatch?.();
+  bridge.dispatchOperationId = options.operationId;
   const turn = await bridge.request("session/prompt", { sessionId: identity.adapterSessionId, prompt: [{ type: "text", text: prompt }] }, timeoutMs, {
     idleSessionId: identity.adapterSessionId,
-    idleTimeoutMs: options.livenessTimeoutMs ?? null,
+    idleTimeoutMs: options.livenessTimeoutMs ?? 600_000,
     inactivityMode: "diagnostic",
   });
   const stopReason = typeof turn?.stopReason === "string" ? turn.stopReason : null;
   const completionEvidence = turn?._meta?.zcodeCompletionEvidence;
   if (completionEvidence === "inferred" || completionEvidence === "failed") {
     let observationError = null;
-    try { await bridge.flush(); } catch (error) { observationError = { code: error.code ?? "zcode_post_turn_observation_failed", message: error.message ?? String(error) }; }
+    try { await bridge.flush(); } catch (error) { observationError = errorRecord(error); }
     const error = new Error(`ZCode completion is ${completionEvidence}, not a confirmed successful native turn`);
     error.code = completionEvidence === "inferred" ? "native_outcome_unknown" : "zcode_turn_not_completed";
     error.retryable = false;
@@ -942,7 +1030,7 @@ export async function promptSessionWithBridge(bridge, options) {
     // collect live evidence first: ordinary inspection is allowed to recover
     // an evicted Session, which would undo the just-confirmed close.
     let observationError = null;
-    try { await bridge.flush(); } catch (error) { observationError = { code: error.code ?? "zcode_post_turn_observation_failed", message: error.message ?? String(error) }; }
+    try { await bridge.flush(); } catch (error) { observationError = errorRecord(error); }
     const error = new Error(`ZCode ended the provider request with ${stopReason}, not end_turn`);
     error.code = stopReason === "cancelled" ? "zcode_turn_cancelled" : "zcode_turn_not_completed";
     error.details = { stop_reason: stopReason, provider_session_id: identity.providerSessionId, adapter_session_id: identity.adapterSessionId, ...(observationError ? { observation_error: observationError } : {}) };
@@ -954,7 +1042,8 @@ export async function promptSessionWithBridge(bridge, options) {
     const error = new Error("ZCode completed the native turn, but post-turn observation failed");
     error.code = "native_outcome_observation_failed";
     error.retryable = false;
-    error.details = { native_outcome: { stop_reason: stopReason ?? "end_turn", completion_evidence: completionEvidence ?? "native" }, provider_session_id: identity.providerSessionId, adapter_session_id: identity.adapterSessionId, observation_error: { code: cause.code ?? "zcode_post_turn_observation_failed", message: cause.message ?? String(cause) } };
+    error.cause = cause;
+    error.details = { native_outcome: { status: "completed", stop_reason: stopReason ?? "end_turn", completion_evidence: completionEvidence ?? "native" }, provider_session_id: identity.providerSessionId, adapter_session_id: identity.adapterSessionId, observation_error: errorRecord(cause) };
     throw error;
   }
   evidence.tool_calls = bridge.toolSummary(identity.adapterSessionId);
@@ -987,7 +1076,7 @@ export async function cancelSession(options) {
 export async function cancelSessionWithBridge(bridge, options) {
   requireJournal(options);
   const identity = await controlledIdentity(bridge, options);
-  const before = await readZcodeSubagents(bridge, identity.adapterSessionId).catch(error => ({ observation_error: { code: error.code, message: error.message } }));
+  const before = await readZcodeSubagents(bridge, identity.adapterSessionId).catch(error => ({ observation_error: errorRecord(error) }));
   return receipt(options, { harness: "zcode-acp", provider_session_id: identity.providerSessionId, adapter_session_id: identity.adapterSessionId, ...await cancelTree(bridge, identity.adapterSessionId, before, identity.providerSessionId, options.knownChildSessionIds, options.neverPromptedRootProof) });
 }
 

package/dist/harness-runtime/lib/lease-renewal.d.mts

@@ -0,0 +1,8 @@
+export const RENEWAL_POLICY: Readonly<{ budgetMs: number; attemptMs: number }>;
+export type RenewalState = { uncertainSince: number | null; attempt: number; exhausted: boolean };
+export function createRenewalState(): RenewalState;
+export function renewalRemaining(state: RenewalState, now?: number): number;
+export function renewalFailure(state: RenewalState, now?: number): number;
+export function renewalDelay(state: RenewalState): number;
+export function renewalConfirmed(state: RenewalState, now?: number): boolean;
+export function maintenanceRetryable(error: unknown): boolean;