@deksden-com/dd-flow-cli 0.9.0-beta.143 → 0.9.0-beta.145

package/dist/harness-runtime/lib/delegation-instructions.mjs

@@ -60,7 +60,7 @@ export function delegationContract(harness) {
   return `dd-flow/delegation/${key}@${["codex", "opencode"].includes(key) ? 2 : 1}`;
 }
 
-export const lifecycleCommandCompletionInstruction = "Run runtime-issued lifecycle CLI calls in the foreground, never with a native background or detached-shell option. A shell tool may yield before the lifecycle process exits. Retain and poll its exact process/session handle to completion, including inside a tool wrapper; empty interim output is not a CLI result. If a wrapper returns 'Script running with cell ID …', use that wrapper's wait tool to finish the same cell before expecting an inner shell session handle; do not execute the command again. Read final stdout or response_file before deciding continuation, and never reissue the command while it is pending.";
+export const lifecycleCommandCompletionInstruction = "Run runtime-issued lifecycle CLI calls in the foreground, never with a native background or detached-shell option. A shell tool may yield before the lifecycle process exits. Retain and poll its exact process/session handle to completion, including inside a tool wrapper; empty interim output is not a CLI result. If a wrapper returns 'Script running with cell ID …', use that wrapper's wait tool to finish the same cell before expecting an inner shell session handle; do not execute the command again. Read final stdout or response_file before deciding continuation, and never reissue the command while it is pending. When the result provides prompt_delivery, read its complete plain Markdown file at prompt_delivery.path before working; it contains the current instructions, unlike the historical prompt_path. If delivery publication is pending, stop for reconciliation without repeating the accepted command.";
 
 export const lifecycleRetryInstruction = `${lifecycleCommandCompletionInstruction} A failure is not permission to replay a lifecycle command. For proven effect=no_effect with recoverable=true and retry_command, correct the input and execute that exact issued successor. A check failure can retain receipts while leaving Work running: correct the evidenced cause first, then use the CLI's exact retry_command for an intentional fresh check attempt; never replay a check merely because Work is unsettled. If a successful CODE finish returns outcome=verification_required, inspect the retained receipts, update its verification file, and use only next.finish_command: the Stage is still running and the previous invocation ID is consumed. If continuation.kind=repair_required, or a successful result has outcome=repair_required and a repair Work ID, end this Turn for the registered repair child; use any retry_command only after that repair settles and verification is refreshed. Unknown effects require reconciliation, never replay. A committed effect without an explicit continuation is not retryable. A native shell launch refusal before the CLI starts permits correcting only that shell-form error and retrying the same exact command. Otherwise report the primary error and stop; never invent IDs, call hooks directly, or run status as a substitute.`;
 

package/dist/harness-runtime/lib/entity-references.d.mts

@@ -0,0 +1,2 @@
+export function shortEntityReference(id: string): string;
+export function entityReferenceVariants(id: string): string[];

package/dist/harness-runtime/lib/entity-references.mjs

@@ -0,0 +1,9 @@
+/** Stable model-facing reference for persisted project, RUN and Work IDs. */
+export function shortEntityReference(id) {
+  return /^(?:PRJ|RUN|WRK)-\d{3,}(?:-|$)/.exec(id)?.[0]?.replace(/-$/, "") ?? id;
+}
+
+/** Accepted spellings of one already-resolved entity. Wrong full slugs stay distinct. */
+export function entityReferenceVariants(id) {
+  return [...new Set([id, shortEntityReference(id)])];
+}

package/dist/harness-runtime/lib/managed-daemon.mjs

@@ -409,21 +409,28 @@ export async function closeManagedBridge(config, state, bridge) {
   await finishDaemonProcess(config, state.provider_process, "stopped", "daemon_stopped");
 }
 
-export function scheduleDaemonProcessHeartbeat(config, record) {
+export function scheduleDaemonProcessHeartbeat(config, record, { signal } = {}) {
   if (!record?.id || !record.lease_token) return;
   const key = leaseKey(config, record);
-  if (leases.has(key)) return;
-  const lease = { pending: null, error: null, timer: null, lost: false, closing: false, expiresAt: Date.parse(record.lease_expires_at ?? ""), renewal: createRenewalState({ leaseExpiresAt: record.lease_expires_at }), stateDir: path.resolve(config.runtime_owner?.state_dir ?? config.stateDir ?? config.cwd), config, record };
+  if (leases.has(key)) {
+    if (signal && leases.get(key).signal !== signal) throw Object.assign(new Error("Heartbeat cancellation owner differs from the retained lease"), { code: "process_maintenance_signal_conflict" });
+    return;
+  }
+  const lease = { pending: null, error: null, timer: null, lost: false, closing: false, signal, expiresAt: Date.parse(record.lease_expires_at ?? ""), renewal: createRenewalState({ leaseExpiresAt: record.lease_expires_at }), stateDir: path.resolve(config.runtime_owner?.state_dir ?? config.stateDir ?? config.cwd), config, record };
   leases.set(key, lease);
   // Retry no-effect contention inside the same authority episode while native
   // work is active; scheduling ticks are not ownership evidence.
   lease.timer = setInterval(() => reconfirmLease(lease, () => {}).catch(() => {}), 60_000);
   lease.timer.unref();
+  if (signal) {
+    signal.addEventListener("abort", () => clearInterval(lease.timer), { once: true });
+    if (signal.aborted) clearInterval(lease.timer);
+  }
 }
 
-export async function heartbeatDaemonProcess(config, record) {
+export async function heartbeatDaemonProcess(config, record, { signal } = {}) {
   if (!record?.id || !record.lease_token) return;
-  scheduleDaemonProcessHeartbeat(config, record);
+  scheduleDaemonProcessHeartbeat(config, record, { signal });
   const lease = leases.get(leaseKey(config, record));
   if (lease.closing) throw Object.assign(new Error("Managed process is closing"), { code: "process_closing" });
   if (lease.lost) throw lease.error;
@@ -435,7 +442,7 @@ export async function heartbeatDaemonProcess(config, record) {
   lease.pending = (async () => {
     try {
       lease.renewal.uncertainSince ??= performance.now();
-      const result = await runtimeProcess(config, "heartbeat", { id: record.id, "lease-token": record.lease_token, "lease-ms": 300_000 }, { timeoutMs: renewalRemaining(lease.renewal) });
+      const result = await runtimeProcess(config, "heartbeat", { id: record.id, "lease-token": record.lease_token, "lease-ms": 300_000 }, { timeoutMs: renewalRemaining(lease.renewal), signal: lease.signal });
       if (result?.ok === false) {
         lease.lost = true; clearInterval(lease.timer);
         throw Object.assign(new Error("managed process lease is no longer owned; new productive operations are blocked"), { code: "process_lease_lost", details: { process_id: record.id } });

package/dist/harness-runtime/lib/native-hook-command.mjs

@@ -37,7 +37,7 @@ export async function writeNativeHookFailure(stateDir, binding, error, budget) {
   if (!binding?.request_id || !/^[A-Za-z0-9-]{1,128}$/.test(binding.request_id)) return;
   await budget.run(() => writeJsonAtomic(path.join(stateDir, "hook-failures", `${binding.request_id}.json`), {
     ...errorRecord(error), request_id: binding.request_id, observed_at: new Date().toISOString(), native_hook_binding: binding,
-  }), "failure_receipt");
+  }, () => budget.remaining("failure_receipt_commit")), "failure_receipt");
 }
 
 /** Read only requests accepted for this exact live operation, never scan a mailbox. */
@@ -74,7 +74,7 @@ export function hookBudget(timeoutMs = 25_000, deadlineAt = process.env.DD_FLOW_
   return { deadlineAt: Math.floor(Date.now() + duration), remaining, async run(action, phase) {
     const timeoutMs = remaining(phase);
     let timer;
-    try { return await Promise.race([Promise.resolve().then(action), new Promise((_, reject) => { timer = setTimeout(() => reject(Object.assign(new Error(`Native hook deadline exceeded during ${phase}`), { code: "native_hook_timeout", details: { phase, effect: "unknown" } })), timeoutMs); })]); }
+    try { return await Promise.race([Promise.resolve().then(() => { remaining(phase); return action(); }), new Promise((_, reject) => { timer = setTimeout(() => reject(Object.assign(new Error(`Native hook deadline exceeded during ${phase}`), { code: "native_hook_timeout", details: { phase, effect: "unknown" } })), timeoutMs); })]); }
     finally { clearTimeout(timer); }
   } };
 }
@@ -241,8 +241,8 @@ function hookDiagnostics(stderr) {
   }).slice(-16);
 }
 
-export async function invokeNativeHook({ bin, args, nodeBin, payload, home, cwd, env, timeoutMs = 15_000 }) {
-  const output = await runBoundedCommand({ bin, args, nodeBin, input: `${JSON.stringify(payload)}\n`, cwd, env: { ...env, DD_FLOW_HOME: home }, timeoutMs });
+export async function invokeNativeHook({ bin, args, nodeBin, payload, home, cwd, env, timeoutMs = 25_000 }) {
+  const output = await runBoundedCommand({ bin, args, nodeBin, input: `${JSON.stringify(payload)}\n`, cwd, env: { ...env, DD_FLOW_HOME: home }, timeoutMs, cleanupWithinBudget: true });
   let result;
   try { result = JSON.parse(output); } catch { throw Object.assign(new Error("Invalid native hook JSON response"), { code: "native_hook_response_invalid" }); }
   if (result?.ok === false && typeof result.error?.code === "string") throw Object.assign(new Error(result.error.message ?? "Native hook failed"), { code: result.error.code, details: result.error.details });

package/dist/harness-runtime/lib/opencode-plugin.mjs

@@ -33,16 +33,16 @@ export function makeOpenCodePlugin(binding, invoke = invokeNativeHook, resolve =
       try {
         const result = await invoke({ bin: binding.ddFlowBin, nodeBin: binding.nodeBin,
           args: ["opencode", "event", "handle", "--project-root", binding.projectRoot, "--json"],
-          payload: { ...payload, native_hook_binding: identity.nativeHookBinding }, home: binding.ddFlowHome, timeoutMs: budget.remaining("admission", 15000) });
+          payload: { ...payload, native_hook_binding: identity.nativeHookBinding }, home: binding.ddFlowHome, timeoutMs: budget.remaining("admission") });
         await budget.run(() => resolve(binding.stateDir, "hook.verify", { binding: identity.nativeHookBinding }, budget.remaining("generation")), "generation");
         if (result?.permissionDecision === "deny" || result?.hookSpecificOutput?.permissionDecision === "deny") throw Object.assign(new Error("dd-flow denied native shell admission"), { code: "native_hook_rejected" });
         return result;
       } catch (error) {
         error.details = { ...error.details, native_hook_binding: identity.nativeHookBinding, ...(payload.phase === "after" ? { effect: "unknown", tool_outcome: payload.outcome } : {}) };
-        try { await writeNativeHookFailure(binding.stateDir, identity.nativeHookBinding, error, hookBudget(1_000, null)); await resolve(binding.stateDir, "hook.failed", {}, 1_000); }
+        try { await writeNativeHookFailure(binding.stateDir, identity.nativeHookBinding, error, budget); await resolve(binding.stateDir, "hook.failed", {}, budget.remaining("failure_notification")); }
         catch (storage) {
           error.details.receipt_error = { code: storage.code ?? "hook_receipt_write_failed", message: storage.message };
-          try { await resolve(binding.stateDir, "hook.failed", { binding: identity.nativeHookBinding, failure: errorRecord(error) }, 1_000); }
+          try { await resolve(binding.stateDir, "hook.failed", { binding: identity.nativeHookBinding, failure: errorRecord(error) }, budget.remaining("failure_notification")); }
           catch (notify) { error.details.receipt_error.notification_error = notify.code ?? "hook_notification_failed"; }
         }
         throw error;

package/dist/harness-runtime/lib/operation-errors.mjs

@@ -35,7 +35,7 @@ function boundedText(value, budget, limit = 16000) {
 // Lifecycle controls are not optional diagnostics. Reserve them before bulk
 // messages/details, including nested typed causes, without copying authority
 // that was truncated into a different command or continuation receipt.
-const operationalDetailKeys = ["phase", "effect", "recoverable", "retryable_no_effect", "handoff_required", "storage_retry", "repeated_without_progress", "cleanup_unconfirmed", "native_dispatch_started", "disposition", "cli_admission_barrier", "native_pre_cli_refusal", "issued_invocation_id", "invocation_id", "event_key", "refusal_event_key", "hook_event_id", "work_id", "hook_retry_signature", "rejection_signature", "retry_command", "repair_command", "continuation", "retry_instruction", "recovery_instruction", "authority_truncated"];
+const operationalDetailKeys = ["phase", "effect", "recoverable", "retryable_no_effect", "handoff_required", "storage_retry", "repeated_without_progress", "cleanup_unconfirmed", "native_dispatch_started", "disposition", "cli_admission_barrier", "native_pre_cli_refusal", "issued_invocation_id", "invocation_id", "event_key", "refusal_event_key", "hook_event_id", "work_id", "hook_retry_signature", "rejection_signature", "retry_command", "repair_command", "continuation", "retry_instruction", "correction_instruction", "recovery_instruction", "authority_truncated"];
 function operationalDetails(value, budget) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return null;
   const entries = [];

package/dist/harness-runtime/lib/provider-overload-policy.d.mts

@@ -3,9 +3,11 @@ export const MAX_OVERLOAD_RETRIES: 2;
 export const MAX_RETRY_AFTER_MS: 30000;
 export function classifyProviderError(native: unknown): string;
 export function safeProviderError(native: unknown): Record<string, unknown>;
-export type CapacityRefusal = { policy: string; ordinal: number; session_id: string; turn_id: string; first_observed_at: string; native_terminal_at?: string; native_terminal_basis?: string };
+export type RequestProof = { kind: "native_turn"; session_id: string; turn_id: string } | { kind: "stream_request"; daemon_instance: string; connection_id: string; operation_id: string; turn_generation: number; session_id: string; outbound_position: number; terminal_position: number };
+export function streamRequestKey(proof: unknown): string | null;
+export type CapacityRefusal = { policy: string; ordinal: number; session_id: string; turn_id: string; request_key?: string; request_proof?: RequestProof; first_observed_at: string; native_terminal_at?: string; native_terminal_basis?: string };
 export function parseCapacityOperation(id: string): { root: string; ordinal: number };
-export function normalizeProviderFailure(error: unknown, sessionId?: string, turnId?: string): null | { code: string; session_id: string; turn_id: string; native_error: Record<string, unknown>; observed_at: unknown; terminal_at: unknown; native_turn_items: unknown; primary_error: { details?: Record<string, unknown> } };
+export function normalizeProviderFailure(error: unknown, sessionId?: string, turnId?: string): null | { code: string; session_id: string; turn_id: string; request_key: string; request_proof: RequestProof; native_error: Record<string, unknown>; observed_at: unknown; terminal_at: unknown; native_turn_items: unknown; primary_error: { details?: Record<string, unknown> } };
 export function terminalProviderOverload(error: unknown, sessionId?: string, turnId?: string): boolean;
 export function nativeItemsSettled(items: unknown): boolean;
 export function capacityBackoff(error: unknown, ordinal: number, now?: number, random?: () => number): number;

package/dist/harness-runtime/lib/provider-overload-policy.mjs

@@ -11,10 +11,10 @@ export function classifyProviderError(native) {
   const code = [native.code, native.type, native.codexErrorInfo?.code ?? native.codexErrorInfo].filter(value => typeof value === "string").join(" ");
   const message = String(native.message ?? "");
   const text = `${code} ${message}`;
-  const status = Number(native.status ?? native.statusCode ?? native.status_code ?? native.http_status);
+  const status = Number(native.status ?? native.statusCode ?? native.status_code ?? native.http_status ?? /\(code (\d{3})\)/i.exec(message)?.[1]);
   if (status === 402 || /quota|usageLimitExceeded|sessionBudgetExceeded|billing|payment.required|balance.exhausted|insufficient.credit|resource_exhausted.*limit/i.test(text)) return "provider_quota_exhausted";
   if (status === 401 || status === 403 || /provider_auth_failed|invalid.api.key|authentication|unauthorized|eligib|forbidden|access.denied|rejected.this.account/i.test(text)) return "provider_auth_failed";
-  if (/provider_capacity_transient|serverOverloaded|model.?capacity|at capacity|server.overload|model.overload|server.?busy/i.test(text) || /(?:^|\s)overloaded_error(?:\s|$)/i.test(code) || status === 503 || status === 529) return "provider_capacity_transient";
+  if (/provider_capacity_transient|serverOverloaded|model.?capacity|at capacity|no capacity available for model|server.overload|model.overload|server.?busy/i.test(text) || /(?:^|\s)overloaded_error(?:\s|$)/i.test(code) || status === 503 || status === 529) return "provider_capacity_transient";
   if (/rateLimitExceeded|rate.limit/i.test(text) && (native.retryAfter !== undefined || native.retry_after !== undefined || Object.keys(native.headers ?? {}).some(key => key.toLowerCase() === "retry-after"))) return "provider_rate_limited";
   return status === 429 || /provider_limit_unknown|\b429\b|rateLimitExceeded|rate.limit/i.test(text) ? "provider_limit_unknown" : "provider_failed";
 }
@@ -45,6 +45,15 @@ export function parseCapacityOperation(id) {
   return { root: match[1], ordinal };
 }
 
+/** Local ordered-stream identity is not a native Turn ID. */
+export function streamRequestKey(proof) {
+  if (proof?.kind !== "stream_request" || ![proof.daemon_instance, proof.connection_id, proof.operation_id, proof.session_id].every(value => typeof value === "string" && value)
+    || !Number.isSafeInteger(proof.turn_generation) || proof.turn_generation < 1
+    || !Number.isSafeInteger(proof.outbound_position) || proof.outbound_position < 1
+    || !Number.isSafeInteger(proof.terminal_position) || proof.terminal_position <= proof.outbound_position) return null;
+  return JSON.stringify(["stream_request", proof.daemon_instance, proof.connection_id, proof.operation_id, proof.session_id, proof.turn_generation, proof.outbound_position, proof.terminal_position]);
+}
+
 export function normalizeProviderFailure(error, expectedSessionId, expectedTurnId) {
   let current = error;
   for (let depth = 0; depth < 4 && current && typeof current === "object"; depth++) {
@@ -52,14 +61,17 @@ export function normalizeProviderFailure(error, expectedSessionId, expectedTurnI
     // refusal. Never classify transport loss or an active native retry here.
     if (current.code === "provider_capacity_transient" || current.code === "provider_rate_limited") {
       const details = current.details ?? {};
+      const streamKey = details.native_source === "agy.result" && details.turn_id === undefined && details.native_turn_id === undefined ? streamRequestKey(details.request_proof) : null;
+      const turnKey = streamKey ?? details.turn_id;
       if (!["opencode.v2.session.execution", "agy.result", "acp.error_response", "droid.agent_turn_outcome", "grok.subagent.event"].includes(details.native_source) || details.terminal_status !== "failed"
         || details.will_retry === true || details.native_retry_active === true || details.provider_error?.willRetry === true
         || details.provider_error && !["provider_capacity_transient", "provider_rate_limited"].includes(classifyProviderError(details.provider_error))
         || typeof details.provider_session_id !== "string" || !details.provider_session_id
-        || typeof details.turn_id !== "string" || !details.turn_id || details.native_turn_id !== details.turn_id
+        || typeof turnKey !== "string" || !turnKey || (streamKey ? details.request_proof.session_id !== details.provider_session_id || details.native_turn_id !== undefined : details.native_turn_id !== details.turn_id)
         || expectedSessionId !== undefined && details.provider_session_id !== expectedSessionId
-        || expectedTurnId !== undefined && details.turn_id !== expectedTurnId) return null;
-      return { code: "serverOverloaded", session_id: details.provider_session_id, turn_id: details.turn_id,
+        || expectedTurnId !== undefined && turnKey !== expectedTurnId) return null;
+      return { code: "serverOverloaded", session_id: details.provider_session_id, turn_id: turnKey, request_key: turnKey,
+        request_proof: streamKey ? details.request_proof : { kind: "native_turn", session_id: details.provider_session_id, turn_id: details.turn_id },
         native_error: details.provider_error ?? { type: details.native_error_type, status: details.http_status }, observed_at: details.observed_at ?? null,
         terminal_at: null, terminal_basis: null, native_turn_items: details.native_turn_items ?? null, primary_error: current };
     }
@@ -70,7 +82,7 @@ export function normalizeProviderFailure(error, expectedSessionId, expectedTurnI
         || expectedSessionId !== undefined && details.provider_session_id !== expectedSessionId
         || typeof details.turn_id !== "string" || !details.turn_id || details.native_turn_id !== details.turn_id
         || expectedTurnId !== undefined && details.turn_id !== expectedTurnId || typeof code !== "string") return null;
-      return { code, session_id: details.provider_session_id, turn_id: details.turn_id, native_error: native,
+      return { code, session_id: details.provider_session_id, turn_id: details.turn_id, request_key: details.turn_id, request_proof: { kind: "native_turn", session_id: details.provider_session_id, turn_id: details.turn_id }, native_error: native,
         observed_at: details.observed_at ?? null, terminal_at: details.terminal_at ?? null, terminal_basis: details.terminal_basis ?? null,
         native_turn_items: details.native_turn_items ?? null, primary_error: current };
     }
@@ -118,6 +130,7 @@ export function refusalObservation(error, ordinal, firstObservedAt) {
     throw policyError("capacity_continuation_conflict", "Native refusal observation time is invalid or changed");
   const native = failure.terminal_at && Date.parse(failure.terminal_at);
   return { policy: CAPACITY_POLICY, ordinal, session_id: failure.session_id, turn_id: failure.turn_id,
+    request_key: failure.request_key, request_proof: failure.request_proof,
     first_observed_at: firstObservedAt, ...(Number.isFinite(native) && typeof failure.terminal_basis === "string" && failure.terminal_basis ? { native_terminal_at: failure.terminal_at, native_terminal_basis: failure.terminal_basis } : {}) };
 }
 

package/dist/harness-runtime/lib/runner-events.mjs

@@ -22,13 +22,15 @@ export function sha256(value) {
 
 export function hashJson(value) { return sha256(canonicalJson(value)); }
 
-export async function writeJsonAtomic(file, value) {
+export async function writeJsonAtomic(file, value, beforeCommit = () => {}) {
+  beforeCommit();
   await mkdir(path.dirname(file), { recursive: true });
   const temporary = `${file}.${process.pid}.${randomUUID()}.tmp`;
   try {
     const payload = await open(temporary, "wx", 0o600);
     try { await payload.writeFile(`${JSON.stringify(value, null, 2)}\n`); await payload.sync(); }
     finally { await payload.close(); }
+    beforeCommit();
     await rename(temporary, file);
     const directory = await open(path.dirname(file), "r");
     try { await directory.sync(); }

package/dist/harness-runtime/lib/setup-progress.mjs

@@ -1,19 +1,21 @@
 import { readFile } from 'node:fs/promises';
 import path from 'node:path';
+import { randomUUID } from 'node:crypto';
 export const SETUP_STARTUP_MS = 120_000;
 export const SETUP_QUIET_MS = 30_000;
 export const setupPhases = new Set(['ingress_entered', 'imports_ready', 'probe_started', 'probe_completed', 'dependency_check_completed', 'transfer_progress', 'identity_digest_progress', 'identity_digest_completed', 'native_initialized', 'ready']);
 export function setupReporter(operationId = process.env.DD_EVAL_OPERATION_ID) {
   if (!operationId) return () => {};
-  let sequence = 0;
+  let sequence = 0; const producerId = randomUUID();
   return (phase, step = null) => {
     if (!setupPhases.has(phase)) throw new Error('Invalid setup phase');
-    process.stderr.write(JSON.stringify({ kind: 'setup_phase', operation_id: operationId, phase, step, sequence: ++sequence, observed_at: new Date().toISOString() }) + '\n');
+    process.stderr.write(JSON.stringify({ kind: 'setup_phase', operation_id: operationId, producer_id: producerId, phase, step, sequence: ++sequence, observed_at: new Date().toISOString() }) + '\n');
   };
 }
 export const publishSetup = setupReporter();
 export function isSetupPhase(value) {
   return value?.kind === 'setup_phase' && typeof value.operation_id === 'string' && value.operation_id.length > 0 && setupPhases.has(value.phase)
+    && (!Object.hasOwn(value, 'producer_id') || typeof value.producer_id === 'string' && value.producer_id.length > 0 && value.producer_id.length <= 128)
     && Number.isSafeInteger(value.sequence) && value.sequence > 0 && value.sequence <= 1_000_000
     && (value.step === null || typeof value.step === 'string' && value.step.length <= 4096 || Number.isSafeInteger(value.step) && value.step >= 0)
     && typeof value.observed_at === 'string' && Number.isFinite(Date.parse(value.observed_at))
@@ -36,13 +38,13 @@ export function startupObserver(stateDir, daemonId) {
   };
 }
 export function setupObserver(operationId) {
-  const startedAt = Date.now(); let sequence = 0; const markers = new Set();
+  const startedAt = Date.now(); const sequences = new Map(), markers = new Set();
   return value => {
     if (typeof operationId !== 'string' || markers.size >= 4096 || !isSetupPhase(value) || value.operation_id !== operationId
-      || value.sequence <= sequence || Date.parse(value.observed_at) < startedAt || Date.parse(value.observed_at) > Date.now()) return false;
-    const marker = JSON.stringify([value.phase, value.step]);
+      || value.sequence <= (sequences.get(value.producer_id ?? null) ?? 0) || Date.parse(value.observed_at) < startedAt || Date.parse(value.observed_at) > Date.now()) return false;
+    const marker = JSON.stringify([value.producer_id ?? null, value.phase, value.step]);
     if (markers.has(marker)) return false;
-    markers.add(marker); sequence = value.sequence; return true;
+    markers.add(marker); sequences.set(value.producer_id ?? null, value.sequence); return true;
   };
 }
 export function observationDetails(clock, phase, pid) {