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

package/dist/harness-runtime/lib/daemon-observation.d.mts

@@ -0,0 +1,2 @@
+export function recoverDaemonReply(root: string, id: string, options?: { timeoutMs?: number | null; signal?: AbortSignal; binding?: Record<string, unknown>; onProgress?: (value: Record<string, unknown>) => void; onOutcome?: (value: Record<string, unknown>) => void; onPendingSettlement?: (value: Record<string, unknown>) => Promise<void>; observationClock?: import("./observation-clock.mjs").ObservationClock }): Promise<Record<string, unknown>>;
+export function retainedDaemonReply(root: string, id: string, binding?: Record<string, unknown>): Promise<{ ready: boolean; outcome: unknown; value?: unknown; settlement?: Record<string, unknown> | null; reason?: string } | null>;

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

@@ -0,0 +1,163 @@
+import net from 'node:net';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { hashJson, writeJsonAtomic } from './runner-events.mjs';
+import { ObservationClock } from './observation-clock.mjs';
+import { canonicalNativeOperation, nativeOperationWait, validateDaemonWait } from './adapter-timeouts.mjs';
+import { assertNativeLine, retainNativeReplyBuffer } from './native-streams.mjs';
+import { operationDirectory, readOperationRecord, readOperationProgress, readOperationWaiting, suspendOperationClock } from './operation-progress.mjs';
+
+const productive = new Set(['session.create', 'session.prompt', 'session.start', 'session.fork', 'session.resume']);
+const fault = (code, message, details) => Object.assign(new Error(message), { code, retryable: false, details });
+export async function retainedDaemonReply(root, id, binding = {}) {
+  const requested = await readOperationRecord(root, id, 'requested.json');
+  if (!requested) return null;
+  if (requested.operation_id !== id || Object.entries(binding).some(([key, value]) => (requested[key] ?? null) !== (value ?? null))) throw fault('operation_conflict', 'retained operation differs from dispatched request', { operation_id: id });
+  const terminal = await readOperationRecord(root, id, 'result.json');
+  if (!terminal) return null;
+  if (['operation_id','daemon_id','operation','params_sha256','owner_id','generation'].some(field=>Object.hasOwn(terminal,field)&&(terminal[field] ?? null)!==(requested[field] ?? null))) throw fault('operation_conflict','native outcome binding differs from original operation',{operation_id:id});
+  if (terminal.state !== 'completed') throw Object.assign(new Error(terminal.error?.message ?? 'native operation failed'), terminal.error);
+  if (Number.isSafeInteger(requested.generation)) try {
+    const fence = JSON.parse(await readFile(path.join(root,'operation-fence.json'),'utf8'));
+    if (fence.daemon_id === requested.daemon_id && fence.generation > requested.generation) throw fault('operation_cancelled','continuation is fenced by newer control',{operation_id:id,native_result:terminal.result});
+  } catch(error) { if (error.code !== 'ENOENT') throw error; }
+  const settlement = await readOperationRecord(root, id, 'settlement.json');
+  try {
+    const daemon = JSON.parse(await readFile(path.join(root,'daemon.json'),'utf8'));
+    if ((daemon.daemon_id ?? daemon.config?.daemonId ?? null)!==requested.daemon_id || (daemon.config?.runtime_owner?.owner_id ?? null)!==(requested.owner_id ?? null) || ['stopping','clean','unclean','cleanup_failed','failed'].includes(daemon.shutdown_state)) return {ready:false,outcome:terminal.result,settlement,reason:'daemon_authority_changed'};
+    if (requested.owner_id) try { process.kill(daemon.pid,0); } catch { return {ready:false,outcome:terminal.result,settlement,reason:'daemon_owner_dead'}; }
+  } catch(error) { if(error.code!=='ENOENT') throw error; if(requested.daemon_id || requested.owner_id) return {ready:false,outcome:terminal.result,settlement,reason:'daemon_absent'}; }
+  if (!['settled', 'not_required'].includes(settlement?.state)) return { ready: false, outcome: terminal.result, settlement };
+  return { ready: true, outcome: terminal.result, settlement, value: settlement.state === 'not_required' ? terminal.result : { ...terminal.result, settlement } };
+}
+export async function recoverDaemonReply(root, id, { timeoutMs = 30_000, signal, binding = {}, onProgress = () => {}, onOutcome = () => {}, onPendingSettlement, observationClock } = {}) {
+  const saved = observationClock ? null : await readOperationRecord(root, id, 'observer-recovery.json') ?? await readOperationRecord(root, id, 'observer-transport.json');
+  signal?.throwIfAborted();
+  const clock = observationClock ?? new ObservationClock({ timeoutMs: saved?.timeout_ms ?? timeoutMs, saved });
+  let lastSequence = clock.progress ?? 0, lastSaved = 0, latestProgress, settlementAttempted = false, settlementError;
+  const exhaustedCursor = clock.progress;
+  let exhausted = clock.observationLost || clock.elapsed >= clock.timeoutMs;
+  for (;;) {
+    signal?.throwIfAborted();
+    const retained = await retainedDaemonReply(root, id, binding);
+    signal?.throwIfAborted();
+    if (retained) {
+      onOutcome(retained.outcome);
+      signal?.throwIfAborted();
+      if (retained.ready) return retained.value;
+    }
+    const progress = await readOperationProgress(root, id, binding);
+    signal?.throwIfAborted();
+    if (progress && progress.sequence > lastSequence) {
+      lastSequence = progress.sequence;
+      const observedAt = Date.parse(progress.observed_at);
+      // The outer cursor counts diagnostics, not durable sequences. A handoff
+      // may recognize a higher sequence with the same already-observed event.
+      if (clock.progressAt === null || observedAt > clock.progressAt) {
+        latestProgress={cursor:progress.sequence,observed_at:observedAt}; onProgress(progress);
+      }
+    }
+    const waiting = await readOperationWaiting(root,id,binding);
+    signal?.throwIfAborted();
+    if (waiting) suspendOperationClock(clock);
+    const sampled = waiting ? false : clock.sample(latestProgress);
+    if (clock.progress !== exhaustedCursor && clock.elapsed < clock.timeoutMs && !clock.observationLost) exhausted = false;
+    const expired = !waiting && (exhausted || sampled);
+    if ((expired || Date.now() - lastSaved >= 1_000) && await readOperationRecord(root,id,'requested.json')) { await writeJsonAtomic(path.join(operationDirectory(root,id),'observer-recovery.json'),clock.state()); lastSaved = Date.now(); }
+    if (expired) {
+      const final = await retainedDaemonReply(root, id, binding);
+      signal?.throwIfAborted();
+      if (final?.ready) return final.value;
+      throw fault(final ? 'settlement_reconciliation_required' : 'operation_observation_lost', 'original operation has no dispatch-ready reply', { operation_id: id, native_outcome: final ? 'completed' : 'unknown', native_result: final?.outcome, settlement: final?.settlement, reason:final?.reason, ...(settlementError ? { settlement_error:settlementError } : {}), state_dir: root });
+    }
+    if (retained && onPendingSettlement && !settlementAttempted && !retained.reason) {
+      settlementAttempted = true;
+      try { await onPendingSettlement(retained); } catch (error) { settlementError = {code:error.code,message:error.message}; }
+      signal?.throwIfAborted();
+      continue;
+    }
+    await new Promise(resolve => setTimeout(resolve, Math.min(100, timeoutMs / 4)));
+  }
+}
+export async function callDaemonObserved({ stateDir, socket, request, responseSchema, harness, timeoutMs }) {
+  request = { ...request, operation: canonicalNativeOperation(harness, request.operation) };
+  validateDaemonWait(harness, request.operation, timeoutMs);
+  assertNativeLine(JSON.stringify(request), 'request');
+  const durable = productive.has(request.operation);
+  const binding = { operation: request.operation, params_sha256: hashJson({ operation: request.operation, params: request.params ?? {} }) };
+  let initialDaemon;
+  if (durable) try {
+    const state = JSON.parse(await readFile(path.join(stateDir,'daemon.json'),'utf8'));
+    initialDaemon = state.daemon_id ?? state.config?.daemonId ?? null;
+    binding.owner_id = state.config?.runtime_owner?.owner_id ?? null;
+  } catch (error) { if (error.code !== 'ENOENT') throw error; }
+  // Reject a reused ID with different inputs before opening a transport.
+  // Otherwise its retained progress can win the race with the daemon's
+  // conflict reply and misclassify a valid old receipt as corrupt progress.
+  if (durable) await retainedDaemonReply(stateDir, request.id, {
+    ...binding, ...(initialDaemon === undefined ? {} : { daemon_id: initialDaemon })
+  });
+  const savedClock = durable ? await readOperationRecord(stateDir,request.id,'observer-transport.json') : null;
+  return await new Promise((resolve, reject) => {
+    const client = net.createConnection(socket);
+    let buffer = '', done = false, polling = false, pollFlight, lastSequence = savedClock?.cursor ?? 0, frozenDaemon = initialDaemon, disconnected = false, latestProgress, lastSaved = 0;
+    const bound = () => ({ ...binding, ...(frozenDaemon === undefined ? {} : { daemon_id: frozenDaemon }) });
+    const nativeWork = nativeOperationWait(harness, request.operation) === 'native-work';
+    let clock = nativeWork ? null : new ObservationClock({ timeoutMs, saved: savedClock });
+    const finish = (error, result) => { if (done) return; done = true; clearInterval(timer); client.destroy(); void Promise.resolve(pollFlight).then(() => error ? reject(error) : resolve(result)); };
+    const reconcile = async error => {
+      if (done) return;
+      try {
+        const reply = durable ? await retainedDaemonReply(stateDir, request.id, bound()) : null;
+        if (reply?.ready) return finish(null, reply.value);
+        if (reply) error = fault('settlement_reconciliation_required', 'native outcome retained; dispatch readiness is not confirmed', { operation_id: request.id, native_outcome: 'completed', native_result: reply.outcome, settlement: reply.settlement, reason:reply.reason, state_dir: stateDir });
+        else if (durable) error = fault(error.code, error.message, { ...error.details, operation_id: request.id, native_outcome: 'unknown', state_dir: stateDir });
+        finish(error);
+      } catch (cause) { finish(cause); }
+    };
+    const poll = () => {
+      if (done || polling) return pollFlight; polling = true;
+      pollFlight = (async () => {
+      try {
+        const progress = durable ? await readOperationProgress(stateDir, request.id, { ...binding, ...(frozenDaemon === undefined ? {} : { daemon_id: frozenDaemon }) }) : null;
+        if (done) return;
+        if (progress && progress.sequence > lastSequence) {
+          frozenDaemon ??= progress.daemon_id; lastSequence = progress.sequence;
+          binding.generation ??= progress.generation;
+          latestProgress = {cursor:progress.sequence,observed_at:Date.parse(progress.observed_at)};
+          process.stderr.write(`${JSON.stringify({ kind: 'operation_progress', ...progress })}\n`);
+        }
+        if (durable && disconnected) {
+          const reply = await retainedDaemonReply(stateDir, request.id, bound());
+          if (reply?.ready) return finish(null, reply.value);
+        }
+        const waiting = durable && await readOperationWaiting(stateDir,request.id,bound());
+        if (done) return;
+        if (clock && waiting) suspendOperationClock(clock);
+        const expired = !waiting && clock?.sample(latestProgress ?? (durable ? undefined : buffer.length || undefined));
+        if (durable && clock && (expired || Date.now()-lastSaved>=1_000) && await readOperationRecord(stateDir,request.id,'requested.json')) { await writeJsonAtomic(path.join(operationDirectory(stateDir,request.id),'observer-transport.json'),clock.state()); lastSaved=Date.now(); }
+        if (expired) await reconcile(fault('daemon_timeout', `${request.operation} timed out`));
+      } catch (error) { finish(error); } finally { polling = false; }
+      })();
+      return pollFlight;
+    };
+    const timer = setInterval(poll, Math.max(1, Math.min(100, (timeoutMs ?? 400) / 4)));
+    client.setEncoding('utf8'); client.on('connect', () => client.write(`${JSON.stringify(request)}\n`));
+    const lost = error => { if (durable) { disconnected = true; clock ??= new ObservationClock({timeoutMs: timeoutMs ?? 30_000,saved:savedClock}); void poll(); } else void reconcile(error); };
+    client.on('error', error => lost(fault('daemon_not_running', error.message)));
+    client.on('end', () => lost(fault('daemon_connection_closed', 'daemon closed before reply')));
+    client.on('close', () => lost(fault('daemon_connection_closed', 'daemon closed before reply')));
+    client.on('data', chunk => { void (async () => {
+      buffer += chunk; if (!retainNativeReplyBuffer(buffer, finish)) return;
+      const at = buffer.indexOf('\n'); if (at < 0) return;
+      try {
+        const response = JSON.parse(buffer.slice(0, at));
+        if (response.schema_id !== responseSchema || response.id !== request.id) throw fault('operation_observation_lost', 'daemon reply identity mismatch');
+        if (!response.ok) return finish(Object.assign(new Error(response.error?.message ?? 'daemon operation failed'), response.error));
+        if (durable && (binding.owner_id && !response.result?.settlement || response.result?.settlement && !['settled','not_required'].includes(response.result.settlement.state))) { disconnected = true; clock ??= new ObservationClock({timeoutMs:savedClock?.timeout_ms ?? timeoutMs ?? 30_000,saved:savedClock}); void poll(); return; }
+        if (durable) { const retained=await retainedDaemonReply(stateDir,request.id,bound()); if(retained) { if(retained.ready) return finish(null,retained.value); disconnected=true; clock ??= new ObservationClock({timeoutMs:timeoutMs ?? 30_000,saved:savedClock}); void poll(); return; } return void reconcile(fault('operation_observation_lost','productive native reply has no durable original receipt')); }
+        finish(null, response.result);
+      } catch (error) { void reconcile(error.code ? error : Object.assign(fault('operation_observation_lost', 'daemon reply could not be decoded', {native_outcome:'unknown'}), {cause:error})); }
+    })(); });
+  });
+}

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

@@ -1,15 +1,123 @@
 import { createHash } from "node:crypto";
+import { lstatSync } from "node:fs";
 import { mkdir, readFile, readdir, link, unlink, open } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
 import path from "node:path";
 import { hashJson, writeJsonAtomic } from "./runner-events.mjs";
-import { errorRecord, isObservationLoss, reportedError } from "./operation-errors.mjs";
+import { errorRecord, isObservationLoss, isProvenShellCorrection, reportedError } from "./operation-errors.mjs";
 import { assertDaemonOwnership, budgetObservationScope, releaseBudgetObservation, completeBudgetOperation } from "./managed-daemon.mjs";
 import { readModelObservations, modelAttribution } from "./model-observations.mjs";
+import { publishOperationProgress, publishOperationWaiting, withOperationProgress } from './operation-progress.mjs';
 
 const productive = new Set(["session.create", "session.prompt", "session.start", "session.fork", "session.resume"]);
 const controls = new Map();
 const dispatchGenerations = new Map();
+const shutdowns = new Map();
+const settlements = new Map();
+
+// Progress is not outcome authority. Once native effect is retained, a failed
+// diagnostic write must keep its identity and prohibit redispatch.
+async function publishRetainedProgress(root, id, phase, result, metadata) {
+  try { return await publishOperationProgress(root, id, phase, metadata); }
+  catch (cause) {
+    throw Object.assign(new Error('native outcome retained but operation progress could not be published'), {
+      code: 'operation_observation_lost', retryable: false, cause,
+      details: { operation_id: id, state_dir: root, native_outcome: 'completed', native_result: result, progress_error: errorRecord(cause) }
+    });
+  }
+}
+
+export function assertDaemonDispatch(root) {
+  const stop = shutdowns.get(root);
+  if (stop?.pending || stop?.committed) throw Object.assign(new Error("daemon shutdown fences productive dispatch"), { code: "daemon_stopping" });
+}
+export function assertDaemonRestartable(state) {
+  if (["unclean", "cleanup_failed", "stopping"].includes(state?.shutdown_state)) throw Object.assign(new Error("previous daemon shutdown is unresolved; do not restart a native bridge for cleanup"), { code: "daemon_state_terminal", details: { daemon_id: state.daemon_id ?? state.config?.daemonId, shutdown_state: state.shutdown_state } });
+}
+export function commitDaemonShutdown(root) {
+  if (typeof root !== 'string') return; // In-memory adapter diagnostics own no daemon endpoint.
+  const fence = shutdowns.get(root) ?? { pending: 0 };
+  fence.committed = true; shutdowns.set(root, fence);
+}
+
+/** The same incarnation may retry remaining cleanup, never a native Turn. */
+export async function completeDaemonShutdown(root, state, persist, prepare, phases) {
+  const daemonId = state.daemon_id ?? state.config?.daemonId;
+  let shutdown = state.shutdown;
+  if (!shutdown || shutdown.daemon_id !== daemonId) shutdown = { schema_id: "dd-flow/daemon-shutdown@1", daemon_id: daemonId, generation: dispatchGenerations.get(root) ?? 0, phases: {} };
+  shutdown = { ...shutdown, required_phases: ["tree", ...phases.map(([phase]) => phase)] };
+  try {
+    if (!shutdown.phases.tree) {
+      const result = await prepare();
+      shutdown = { ...shutdown, phases: { tree: true }, tree_observed_at: new Date().toISOString(), result: result ?? { clean: true } };
+      commitDaemonShutdown(root);
+      await persist({ shutdown, shutdown_state: "stopping", active_tree: false });
+    }
+    commitDaemonShutdown(root);
+    for (const [phase, action] of phases) {
+      if (shutdown.phases[phase]) continue;
+      await action();
+      shutdown = { ...shutdown, phases: { ...shutdown.phases, [phase]: true } };
+      await persist({ shutdown });
+    }
+    const result = { ...shutdown.result, daemon_id: daemonId, stopped: true, settled: true, shutdown_contract: "dd-flow/daemon-shutdown@1", _shutdown: true };
+    await persist({ shutdown, shutdown_state: result.clean === true ? "clean" : "unclean", active_tree: false, stopped_at: new Date().toISOString(), cleanup_error: null });
+    return result;
+  } catch (error) {
+    if (error.code === "tree_not_settled" && !shutdowns.get(root)?.committed) throw error;
+    try { await persist({ shutdown_state: "cleanup_failed", cleanup_error: errorRecord(error) }); }
+    catch (storage) { error.details = { ...error.details, persistence_error: errorRecord(storage) }; }
+    throw error;
+  }
+}
+
+const daemonConnections = new WeakMap();
+export function trackDaemonConnections(server) {
+  const sockets = new Set(); daemonConnections.set(server, sockets);
+  server.once("listening", () => {
+    const endpoint = server.address();
+    if (typeof endpoint !== "string") return;
+    try { const info = lstatSync(endpoint); daemonEndpoints.set(server, { endpoint, dev: info.dev, ino: info.ino }); }
+    catch (error) { daemonEndpoints.set(server, { endpoint, error }); }
+  });
+  server.on("connection", socket => { sockets.add(socket); socket.on("error", () => {}); socket.once("close", () => sockets.delete(socket)); });
+}
+const daemonEndpoints = new WeakMap();
+
+/** Retire the listener after durable publication, before ACK; no provider IO. */
+export function retireDaemonEndpoint(server, exitCode = 0) {
+  if (!server.listening) return;
+  const retained = daemonEndpoints.get(server);
+  let endpointError = retained?.error;
+  if (retained && !endpointError) {
+    try {
+      const current = lstatSync(retained.endpoint);
+      if (current.dev !== retained.dev || current.ino !== retained.ino || !current.isSocket()) endpointError = Object.assign(new Error("daemon endpoint was replaced; refusing to unlink another listener"), { code: "daemon_endpoint_identity_mismatch", details: { socket: retained.endpoint, phase: "retire_listener" } });
+    } catch (error) { if (error.code !== "ENOENT") endpointError = error; }
+  }
+  if (endpointError) {
+    // libuv's close unlinks by pathname, not inode. Exit without closing its
+    // listener handle when the name belongs to a different incarnation.
+    const timer = setTimeout(() => { for (const socket of daemonConnections.get(server) ?? []) socket.destroy(); process.exit(1); }, 1_000);
+    timer.unref();
+    throw endpointError;
+  }
+  const timer = setTimeout(() => { for (const socket of daemonConnections.get(server) ?? []) socket.destroy(); }, 1_000);
+  timer.unref();
+  server.close(() => { clearTimeout(timer); process.exit(exitCode); });
+}
+
+export async function retireFailedDaemon(server, state, error, persist) {
+  // An already-finished registry lease cannot own a listening productive daemon.
+  if (state.shutdown?.phases?.daemon_resource) {
+    // Durable result publication and listener retirement occur after the
+    // cleanup helper returns. Their failures still invalidate overall clean.
+    if (persist) try { await persist({ shutdown_state: "cleanup_failed", cleanup_error: errorRecord(error) }); }
+    catch (storage) { error.details = { ...error.details, persistence_error: errorRecord(storage) }; }
+    process.stderr.write(`${JSON.stringify({ shutdown_failure: errorRecord(error) })}\n`);
+    try { retireDaemonEndpoint(server, 1); } catch { /* Retirement already scheduled a nonzero exit without unlinking a foreign endpoint. */ }
+  }
+}
 
 async function controlDispatch(root, request, action) {
   const key = request.operation === "daemon.stop" ? `stop:${request.params?.cancelTree === true}` : `cancel:${request.params?.sessionId ?? ""}`;
@@ -21,8 +129,11 @@ async function controlDispatch(root, request, action) {
   const predecessors = key.startsWith("stop:") ? [...pending.values()] : [];
   const promise = (async () => { await Promise.allSettled(predecessors); return await action(); })();
   pending.set(key, promise);
-  try { return await promise; }
-  finally { pending.delete(key); if (!pending.size) controls.delete(root); }
+  let completed = false;
+  try { const result = await promise; completed = true; return result; }
+  // Successful whole-tree stop remains idempotent for this daemon lifetime.
+  // Durable publication for a concurrent caller may arrive after cleanup ends.
+  finally { if (!completed || !key.startsWith('stop:')) { pending.delete(key); if (!pending.size) controls.delete(root); } }
 }
 function location(root, id) {
   if (typeof id !== "string" || !id) throw Object.assign(new Error("operation id is required"), { code: "operation_id_required" });
@@ -37,26 +148,48 @@ export async function inspectDaemonOperation(root, id) {
   if (!requested) throw Object.assign(new Error("daemon operation is not recorded"), { code: "operation_not_found", details: { operation_id: id } });
   const settlement = await read(path.join(directory, "settlement.json"));
   const hookFailures = [];
+  const hookCorrections = [];
+  const hookDiagnostics = [];
   for (const name of await readdir(path.join(directory, "hooks")).catch(error => { if (error.code === "ENOENT") return []; throw error; })) {
     if (!/^[A-Za-z0-9-]{1,128}\.json$/.test(name)) continue;
     const binding = await read(path.join(directory, "hooks", name));
     if (binding?.schema_id !== "dd-flow/hook-request@1" || binding.request_id !== name.slice(0, -5) || binding.operation_id !== id || binding.daemon_id !== requested.daemon_id) continue;
-    const failure = await read(path.join(root, "hook-failures", name));
+    let failure;
+    try { failure = await read(path.join(root, "hook-failures", name)); }
+    catch (error) { hookDiagnostics.push({ code: "native_hook_receipt_invalid", message: error.message, request_id: binding.request_id, effect: "unknown", receipt_bound: false }); continue; }
     if (failure?.request_id !== binding.request_id || typeof failure.code !== "string" || typeof failure.message !== "string") continue;
-    hookFailures.push({ code: failure.code, message: failure.message, observed_at: failure.observed_at ?? null, details: { ...failure.details, ...binding, effect: "unknown" } });
+    if (binding.command_sha256 && JSON.stringify(failure.native_hook_binding) !== JSON.stringify(binding)) continue;
+    const correction = isProvenShellCorrection(failure);
+    (correction ? hookCorrections : hookFailures).push({ ...errorRecord(failure), observed_at: failure.observed_at ?? null, details: { ...failure.details, native_hook_binding: binding, effect: correction ? "no_effect" : "unknown" } });
   }
   hookFailures.sort((a, b) => String(a.observed_at ?? "").localeCompare(String(b.observed_at ?? "")));
   // Admission failure is causal evidence, not proof that the native tree stopped.
-  return { ...requested, ...(await read(path.join(directory, "result.json")) ?? await read(path.join(directory, "interrupted.json")) ?? await read(path.join(directory, "observation-lost.json")) ?? { state: "running" }), ...(settlement ? { settlement } : {}), ...(hookFailures[0] ? { primary_error: hookFailures[0] } : {}) };
+  return { ...requested, ...(await read(path.join(directory, "result.json")) ?? await read(path.join(directory, "interrupted.json")) ?? await read(path.join(directory, "observation-lost.json")) ?? { state: "running" }), ...(settlement ? { settlement } : {}), ...(hookFailures[0] ? { primary_error: hookFailures[0] } : {}), ...(hookCorrections.length ? { hook_corrections: hookCorrections } : {}), ...(hookDiagnostics.length ? { hook_diagnostics: hookDiagnostics.slice(0, 16) } : {}) };
 }
 
 /** Retry only the bookkeeping that follows a durable productive receipt.
  * This is intentionally separate from dispatch: it never invokes a native
  * prompt/create/fork operation, so recovery cannot duplicate agent work. */
 export async function settleDaemonOperation(root, id) {
+  const key = `${root}\0${id}`;
+  if (settlements.has(key)) return await settlements.get(key);
+  const pending = settleOriginalOperation(root, id);
+  settlements.set(key, pending);
+  try { return await pending; } finally { if (settlements.get(key) === pending) settlements.delete(key); }
+}
+async function settleOriginalOperation(root, id) {
   const current = await inspectDaemonOperation(root, id);
   if (current.state !== "completed") return current;
-  if (current.settlement?.state === "settled") return current;
+  if (['settled', 'not_required'].includes(current.settlement?.state)) return current;
+  const daemon = await read(path.join(root, 'daemon.json'));
+  const daemonId = daemon?.daemon_id ?? daemon?.config?.daemonId ?? null;
+  const fence = await read(path.join(root, 'operation-fence.json'));
+  const generation = dispatchGenerations.get(root) ?? (fence?.daemon_id === daemonId ? fence.generation : 0);
+  if (current.daemon_id !== (daemon?.daemon_id ?? daemon?.config?.daemonId ?? null)
+    || current.owner_id !== undefined && current.owner_id !== (daemon?.config?.runtime_owner?.owner_id ?? null)
+    || current.generation !== undefined && current.generation !== generation
+    || ['stopping','clean','unclean','cleanup_failed','failed'].includes(daemon?.shutdown_state)) throw Object.assign(new Error('settlement authority changed'), { code: 'settlement_reconciliation_required' });
+  assertDaemonDispatch(root);
   let settlement;
   try {
     settlement = await completeBudgetOperation(root, {
@@ -97,7 +230,7 @@ export async function interruptDaemonOperation(root, id, barrier) {
 /** At-most-once dispatch and a durable terminal reply, including when the socket
  * observer disconnects. Recovery reads this receipt; it never resends a prompt. */
 export async function durableDaemonDispatch(root, request, action, observe) {
-  if (request.operation === "operation.inspect") return await inspectDaemonOperation(root, request.params?.operationId);
+  if (request.operation === "operation.inspect") return request.params?.settle === true ? await settleDaemonOperation(root, request.params?.operationId) : await inspectDaemonOperation(root, request.params?.operationId);
   if (request.operation === "daemon.status") {
     const result = await action();
     if (!result?.config?.journal) return result;
@@ -121,16 +254,24 @@ export async function durableDaemonDispatch(root, request, action, observe) {
   const control = ["daemon.stop", "session.cancel"].includes(request.operation);
   if (!productive.has(request.operation) && !control) return await action();
   const generation = dispatchGenerations.get(root) ?? 0;
-  if (control) dispatchGenerations.set(root, generation + 1);
-  const assertCurrent = () => { if (generation !== (dispatchGenerations.get(root) ?? 0)) throw Object.assign(new Error("control cancelled a queued productive dispatch"), { code: "operation_cancelled" }); };
-  const result = await journalDispatch(root, request, async () => {
+  if (control) { dispatchGenerations.set(root, generation + 1); const state = await read(path.join(root,'daemon.json')); await writeJsonAtomic(path.join(root,'operation-fence.json'), { generation: generation + 1, daemon_id: state?.daemon_id ?? state?.config?.daemonId ?? null }); }
+  const assertCurrent = () => { assertDaemonDispatch(root); if (generation !== (dispatchGenerations.get(root) ?? 0)) throw Object.assign(new Error("control cancelled a queued productive dispatch"), { code: "operation_cancelled" }); };
+  const stop = request.operation === "daemon.stop" ? (shutdowns.get(root) ?? { pending: 0, committed: false }) : null;
+  if (stop) { stop.pending++; shutdowns.set(root, stop); }
+  let result;
+  try { result = await journalDispatch(root, request, async () => {
     // Persist before admission so a racing fence can observe the writer.
-    if (!control) await assertDaemonOwnership(root, { "operation-id": request.id, operation: request.operation, "native-session-id": request.params?.sessionId, "prompt-sha256": typeof request.params?.prompt === "string" ? createHash("sha256").update(request.params.prompt).digest("hex") : undefined }, assertCurrent);
+    if (!control) await assertDaemonOwnership(root, { "operation-id": request.id, operation: request.operation, "native-session-id": request.params?.sessionId, "prompt-sha256": typeof request.params?.prompt === "string" ? createHash("sha256").update(request.params.prompt).digest("hex") : undefined }, assertCurrent, phase => publishOperationProgress(root, request.id, phase), receipt => publishOperationWaiting(root,request.id,receipt));
     if (!control) assertCurrent();
-    return control ? await controlDispatch(root, request, action) : await action();
-  });
+    await publishOperationProgress(root, request.id, 'native_dispatched');
+    return await withOperationProgress(root, request.id, () => control ? controlDispatch(root, request, action) : action());
+  }); } catch (error) {
+    if (control) controls.get(root)?.delete(request.operation === 'daemon.stop' ? `stop:${request.params?.cancelTree === true}` : `cancel:${request.params?.sessionId ?? ''}`);
+    throw error;
+  } finally { if (stop) { stop.pending--; if (!stop.pending && !stop.committed) shutdowns.delete(root); } }
   if (control) return result;
   let settlement;
+  await publishRetainedProgress(root, request.id, 'settlement_started', result);
   try {
     settlement = await completeBudgetOperation(root, request, result, observe);
   } catch (error) {
@@ -140,6 +281,7 @@ export async function durableDaemonDispatch(root, request, action, observe) {
   catch (error) {
     settlement = { state: "blocked", reason: "settlement_storage_error", observed_at: new Date().toISOString(), error: errorRecord(error) };
   }
+  await publishRetainedProgress(root, request.id, settlement?.state === 'settled' || settlement?.state === 'not_required' ? 'settlement_completed' : 'settlement_pending', result);
   return settlement?.state === "not_required" || !result || typeof result !== "object" || Array.isArray(result)
     ? result
     : { ...result, settlement };
@@ -172,7 +314,7 @@ async function journalDispatch(root, request, action) {
   const daemon = await read(path.join(root, "daemon.json"));
   const startup = request.operation === "daemon.start";
   const daemonId = daemon?.daemon_id ?? daemon?.config?.daemonId ?? null;
-  await writeJsonAtomic(temporary, { schema_id: "dd-flow/daemon-operation@1", operation_id: request.id, operation: request.operation, session_id: request.params?.sessionId ?? null, daemon_id: startup ? null : daemonId, ...(startup ? { predecessor_daemon_id: daemonId, launch: request.params?.launch } : {}), params_sha256: fingerprint, requested_at: new Date().toISOString() });
+  await writeJsonAtomic(temporary, { schema_id: "dd-flow/daemon-operation@1", operation_id: request.id, operation: request.operation, session_id: request.params?.sessionId ?? null, daemon_id: startup ? null : daemonId, owner_id: daemon?.config?.runtime_owner?.owner_id ?? null, generation: dispatchGenerations.get(root) ?? 0, ...(startup ? { predecessor_daemon_id: daemonId, launch: request.params?.launch } : {}), params_sha256: fingerprint, requested_at: new Date().toISOString() });
   try {
     await link(temporary, path.join(directory, "requested.json"));
   } catch (error) {
@@ -184,6 +326,7 @@ async function journalDispatch(root, request, action) {
     throw Object.assign(new Error("provider operation has no confirmed terminal result; inspect the existing operation instead of resending it"), { code: "operation_observation_lost", details: { operation_id: request.id, receipt_directory: directory } });
   } finally { await unlink(temporary); }
   let result;
+  await publishOperationProgress(root, request.id, 'accepted');
   try {
     result = await action();
   }
@@ -203,6 +346,7 @@ async function journalDispatch(root, request, action) {
     if (cause?.code === "operation_interrupted" || cause?.code === "operation_terminal_conflict") throw cause;
     throw Object.assign(new Error("provider returned but the durable reply could not be saved; do not resend the operation"), { code: "operation_observation_lost", cause, details: { operation_id: request.id, receipt_directory: directory } });
   }
+  await publishRetainedProgress(root, request.id, 'native_outcome_retained', result, { session_id: result?.session_id ?? result?.sessionId });
   return result;
 }