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

package/CHANGELOG.md

@@ -1,5 +1,63 @@
 # @deksden-com/dd-flow-cli
 
+## 0.9.0-beta.133
+
+### Patch Changes
+
+- Use the exact retained committed lease for admission and capacity waits,
+  rather than an expired daemon-state snapshot.
+- Validate direct check runner evidence contracts before PLAN/Work admission.
+- beta.132 is retained as a superseded local candidate; review found the stale
+  admission horizon before release or scored E2E.
+
+## 0.9.0-beta.132
+
+### Patch Changes
+
+- Preserve structured CLI failure receipts when valid setup-phase diagnostics
+  precede the error envelope; reject malformed/error-bearing phase records.
+- beta.131 remains an unaccepted immutable local candidate; its full gate
+  exposed this parsing defect before engine promotion.
+
+## 0.9.0-beta.131
+
+### Patch Changes
+
+- Bound maintenance to verified lease authority, reconcile settled unknown
+  heartbeat acknowledgements without replay, and separate resource/RUN effects.
+- Keep scope-free maintenance cold imports narrow; finish observes its own
+  settlement window after the preceding flight.
+- Retain bound structured test outcomes and progress with profile@7, preserving
+  profile@6 compatibility. Route tooling/unknown failures away from product repair.
+
+## 0.9.0-beta.130
+
+### Patch Changes
+
+- Bind AGY startup observation to its actual daemon configuration, preserve
+  explicit OpenCode observation windows and retain the last confirmed setup phase.
+- beta.129 remained an unaccepted local candidate; its failed native gate is
+  retained separately rather than reissued under a different artifact digest.
+
+## 0.9.0-beta.129
+
+### Patch Changes
+
+- Observe setup phases across engine admission and all native daemon startups;
+  retain operation-bound progress and distinguish silence from observation loss.
+- Run engine health/bind/fork probes and managed tooling asynchronously outside
+  storage writers, preserving dependency failures, cancellation and owned cleanup.
+- Stream ZCode binary identity and preserve startup progress through EVAL control.
+
+## 0.9.0-beta.128
+
+### Patch Changes
+
+- Separate cold maintenance CLI imports from storage inactivity. Start the short
+  sliding storage window only after request-bound readiness, retaining the finite
+  ownership horizon and unknown-write recovery. Diagnose startup versus storage
+  expiry and preserve exact registration operation identity.
+
 ## 0.9.0-beta.127
 
 ### Patch Changes

package/dist/build-info.json

@@ -1,15 +1,15 @@
 {
   "cli_package": "@deksden-com/dd-flow-cli",
-  "cli_version": "0.9.0-beta.127",
-  "cli_commit": "8c98b4fa9e0f69be85ef616d7c7c3dac884fc0f5",
-  "built_at": "2026-10-11T11:57:17.805Z",
+  "cli_version": "0.9.0-beta.133",
+  "cli_commit": "43d88ec57e1b100fa29f31be925d6abfc976e7a2",
+  "built_at": "2026-10-12T17:50:10.957Z",
   "built_with_canon": {
     "version": "4.1.2",
     "commit": "2ba0b9ceedf8e4544ad9566c240ef37ea5e8d099",
     "flow_contract": "dd-flow-canonical-2026-08",
-    "repo_root": "/Users/deksden/.dd-eval/qualification/cp-214-release-canon",
-    "memorybank_root": "/Users/deksden/.dd-eval/qualification/cp-214-release-canon/.memory-bank",
-    "flow_root": "/Users/deksden/.dd-eval/qualification/cp-214-release-canon/.memory-bank/dd-flow",
+    "repo_root": "/Users/deksden/Documents/_Projects/_worktrees/dd-memorybank-081-canon",
+    "memorybank_root": "/Users/deksden/Documents/_Projects/_worktrees/dd-memorybank-081-canon/.memory-bank",
+    "flow_root": "/Users/deksden/Documents/_Projects/_worktrees/dd-memorybank-081-canon/.memory-bank/dd-flow",
     "layout": "dot_memory_bank"
   }
 }

package/dist/cli/command-inputs.js

@@ -128,11 +128,11 @@ export const commandInputs = {
     "runtime process stop": route(0, "id lease-token", "grace-ms"),
     "runtime process register": route(0, "kind owner", "id lease-ms budget-json project-id run pid process-group-id owner-pid work check operation stdout stderr harness dispatch-barrier role state-dir adapter-executable"),
     "runtime process confirm": route(0, "id lease-token pid", "owner-pid lease-ms process-group-id"),
-    "runtime process heartbeat": route(0, "id lease-token", "lease-ms"),
+    "runtime process heartbeat": route(0, "id lease-token", "lease-ms registration-sha256"),
     "runtime process admission": route(0, "id lease-token owner state-dir", "daemon-id operation-id operation native-session-id prompt-sha256"),
     "runtime process release-turn": route(0, "id lease-token owner daemon-id", "operation-id observation-file"),
     "runtime process finish": route(0, "id lease-token state", "reason", "", "", { state: ["stopped", "failed"] }),
-    "runtime process status": route(0),
+    "runtime process status": route(0, "", "id lease-token registration-sha256"),
     "runtime process reconcile": route(0, "owner", "grace-ms"),
     "lane status": route(0, project, "lane"),
     "lane waiters": route(0, project, "lane"),

package/dist/cli/run-cli.js

@@ -344,7 +344,7 @@ async function runCliRequest(args, io, env) {
         if (!retainedOutcome && !preparedInput)
             preparedInput = await prepareCliInput(invocationArgs, dispatchContext, io, scopeProjectRoot, output.responseFile);
         if (!retainedOutcome)
-            preflightCliCompatibility(dispatchContext, invocationArgs, env, scopeProjectRoot);
+            await preflightCliCompatibility(dispatchContext, invocationArgs, env, scopeProjectRoot);
         if (!retainedOutcome) {
             const command = !invocationId ? nativeCommand : quote(["dd-flow", ...dispatchArgs]);
             const event = !invocationId ? nativeEvent : null;
@@ -937,7 +937,7 @@ async function prepareCliInputValue(args, context, io, scopeProjectRoot, respons
     if (route.key === "run override")
         prepareFlowRunCompletion(context, runOverrideInput(parsed));
     if (route.key === "engine bind-run")
-        prepared.engineBind = prepareRunEngineBind(context, engineBindInput(parsed));
+        prepared.engineBind = await prepareRunEngineBind(context, engineBindInput(parsed));
     if (route.key === "worktree create")
         prepared.worktreeCreate = prepareWorktreeCreate(context, { protocolId: requiredOption(parsed, "protocol-id"), projectRoot: requiredScopeProjectRoot(scopeProjectRoot, "worktree create"), branch: requiredOption(parsed, "branch"), base: requiredOption(parsed, "base"), path: requiredOption(parsed, "path") });
     if (route.key === "worktree bootstrap")
@@ -1792,7 +1792,7 @@ async function dispatch(args, context, io, scopeProjectRoot = null, classificati
         }
         if (!bootstrap && stage === "protocolize" && isVnextProtocolizeRun(context, { projectRoot, runId: requiredPosition(parsed, 0, "run-id") })) {
             hookEventId ??= claimVnextStageStart(requiredPosition(parsed, 0, "run-id"));
-            return attachExternalStageContext(startVnextProtocolize(context, { projectRoot, runId: requiredPosition(parsed, 0, "run-id"), hookEventId, ...(contextSha256 ? { contextSha256 } : {}), ...(externalContext ? { externalContext } : {}) }, prepared.protocolizeStart), externalContext);
+            return attachExternalStageContext(await startVnextProtocolize(context, { projectRoot, runId: requiredPosition(parsed, 0, "run-id"), hookEventId, ...(contextSha256 ? { contextSha256 } : {}), ...(externalContext ? { externalContext } : {}) }, prepared.protocolizeStart), externalContext);
         }
         if (!bootstrap && stage === "plan" && isVnextPlanRun(context, { projectRoot, runId: requiredPosition(parsed, 0, "run-id") })) {
             hookEventId ??= claimVnextStageStart(requiredPosition(parsed, 0, "run-id"));
@@ -2698,7 +2698,7 @@ function dispatchCmux(context, parsed) {
     }
     throw new AppError("usage", `Unknown integration cmux action: ${action}`, 2);
 }
-function dispatchDashboard(context, command, parsed) {
+async function dispatchDashboard(context, command, parsed) {
     const action = dashboardAction(command);
     if (command === "data") {
         const target = resolveDashboardTarget(context, {
@@ -2733,7 +2733,7 @@ function dispatchDashboard(context, command, parsed) {
             projectRoot: optionalOption(parsed, "project-root"),
             protocol: optionalOption(parsed, "protocol")
         });
-        return withDashboardGuidance(action, target, openDashboardForResolvedTarget(context, target, parsed));
+        return withDashboardGuidance(action, target, await openDashboardForResolvedTarget(context, target, parsed));
     }
     if (command === "refresh") {
         const open = optionalOption(parsed, "open");
@@ -2747,7 +2747,7 @@ function dispatchDashboard(context, command, parsed) {
             protocol: optionalOption(parsed, "protocol"),
             all: hasOption(parsed, "all")
         });
-        return withDashboardGuidance(action, target, refreshDashboardForResolvedTarget(context, target, parsed, open));
+        return withDashboardGuidance(action, target, await refreshDashboardForResolvedTarget(context, target, parsed, open));
     }
     if (command === "refresh-global") {
         const target = resolveDashboardTarget(context, { action: "refresh", global: true });

package/dist/cli/runtime-maintenance-diagnostics.js

@@ -11,7 +11,7 @@ export function runtimeMaintenanceDiagnostics(args, deadline, write) {
     const request = requests.getStore();
     const option = (name) => { const at = args.indexOf(`--${name}`); return at < 0 ? undefined : args[at + 1]; };
     const safe = (value) => typeof value === "string" && /^[A-Za-z0-9:._-]{1,128}$/.test(value) ? value : undefined;
-    const identity = { action: safe(args[2]), process_id: safe(option("id")), operation_id: safe(option("operation-id")), native_dispatch_started: false };
+    const identity = { action: safe(args[2]), process_id: safe(option("id")), operation_id: safe(option("operation-id") ?? option("operation")), native_dispatch_started: false };
     let previous = "", count = 0, committed = false;
     const phase = (name, details = {}) => {
         const key = `${details.store_kind ?? ""}:${name}`;

package/dist/cli/runtime-maintenance-ingress.js

@@ -16,9 +16,11 @@ export async function runRuntimeMaintenanceIngress(args, env = process.env, io =
         const diagnostics = runtimeMaintenanceDiagnostics(args, deadline, line => io.stderr.write(line));
         let context;
         try {
-            const [{ createContext }, { prepareCommandRoute }, { resolveCommandProjectRoot, resolveCommandPaths }, processCommands] = await Promise.all([
-                import("../runtime/context.js"), import("./command-inputs.js"), import("../services/command-context.js"), import("./runtime-process.js")
+            const [{ createContext }, { prepareCommandRoute }, { resolveCommandProjectRoot, resolveCommandPaths }, processCommands, { preflightCliCompatibility }] = await Promise.all([
+                import("../runtime/context.js"), import("./command-inputs.js"), import("../services/command-context.js"), import("./runtime-process.js"),
+                import("../services/compatibility-preflight.js")
             ]);
+            diagnostics.phase("imports_ready");
             const invocation = args.filter(arg => arg !== "--json");
             const options = { databaseDeadlineAt: deadline, resourceDatabaseMode: args[2] === "register" ? "initialize" : args[2] === "status" ? "read_existing" : "prepared_existing" };
             context = createContext({ ...env, DD_FLOW_INVOCATION_READONLY: args[2] === "status" ? "1" : undefined }, "read_existing", undefined, options);
@@ -28,8 +30,7 @@ export async function runRuntimeMaintenanceIngress(args, env = process.env, io =
             const prepared = processCommands.prepareRuntimeProcess(context, route.key, route.parsed);
             // Preserve the common compatibility gate; this is not a second dispatch
             // implementation or permission granted by the ingress predicate.
-            const { preflightCliCompatibility } = await import("../services/compatibility-preflight.js");
-            preflightCliCompatibility(context, routedArgs, env, root);
+            await preflightCliCompatibility(context, routedArgs, env, root);
             const result = await processCommands.dispatchRuntimeProcess(context, args[2], route.parsed, prepared);
             const receipt = result;
             const expiry = receipt?.lease_expires_at ?? receipt?.process?.lease_expires_at;

package/dist/cli/runtime-process.js

@@ -5,6 +5,7 @@ import { recoveryGuard, assertRunMutationAllowed } from "../services/run-recover
 import { recoveryRuntimeAdmission } from "../services/run-recovery-guard.js";
 import { prepareManagedProcessRegistration, prepareManagedProcessConfirmation, prepareManagedProcessHeartbeat, prepareManagedProcessFinish, prepareManagedProcessStopOperation, prepareManagedProcessReconcile, stopManagedProcess, confirmManagedProcess, finishManagedProcess, renewManagedProcess, assertManagedProcessAdmission, managedProcessRuntimeHome, managedProcessStatus, processIsAlive, reconcileExpiredManagedProcesses, registerManagedProcess } from "../services/managed-processes.js";
 import { admitRuntimeCheck, parseRuntimeBudget, reserveProviderTurn, releaseProviderTurns, prepareProviderTurnRelease } from "../services/runtime-budget.js";
+import { managedProcessBinding, resourceHome } from "../services/managed-processes.js";
 function runtimeProcessStopInput(parsed) {
     const graceMs = optionalNumber(parsed, "grace-ms");
     return { id: requiredOption(parsed, "id"), leaseToken: requiredOption(parsed, "lease-token"), ...(graceMs !== undefined ? { graceMs } : {}) };
@@ -80,6 +81,12 @@ export async function dispatchRuntimeProcess(context, action, parsed, prepared =
     if (action === "confirm")
         return { ok: true, process: confirmManagedProcess(context, runtimeProcessConfirmationInput(parsed)) };
     if (action === "heartbeat") {
+        const hash = optionalOption(parsed, "registration-sha256");
+        if (hash) {
+            const record = managedProcessStatus(context).find(value => value.id === requiredOption(parsed, "id"));
+            if (!/^[a-f0-9]{64}$/.test(hash) || !record || managedProcessBinding(record, resourceHome(context)).registration_sha256 !== hash)
+                throw new AppError("process_maintenance_receipt_invalid", "Heartbeat registration changed", 1);
+        }
         const receipt = renewManagedProcess(context, runtimeProcessHeartbeatInput(parsed));
         return { ...receipt, ok: receipt.owned };
     }
@@ -120,8 +127,26 @@ export async function dispatchRuntimeProcess(context, action, parsed, prepared =
     }
     if (action === "finish")
         return { ok: finishManagedProcess(context, runtimeProcessFinishInput(parsed)) };
-    if (action === "status")
-        return { ok: true, processes: managedProcessStatus(context) };
+    if (action === "status") {
+        const id = optionalOption(parsed, "id"), token = optionalOption(parsed, "lease-token"), hash = optionalOption(parsed, "registration-sha256");
+        if (!id && !token && !hash)
+            return { ok: true, processes: managedProcessStatus(context) };
+        if (!id || !token || !hash || !/^[a-f0-9]{64}$/.test(hash))
+            throw new AppError("usage", "Exact status requires id, lease-token and registration-sha256", 2);
+        const record = managedProcessStatus(context).find(value => value.id === id);
+        if (!record || record.lease_token !== token || managedProcessBinding(record, resourceHome(context)).registration_sha256 !== hash || record.state !== "running" || !processIsAlive(record))
+            throw new AppError("process_maintenance_receipt_invalid", "Readback binding or physical owner changed", 1);
+        assertManagedProcessAdmission(context, record);
+        const metadata = JSON.parse(record.metadata_json);
+        if (record.project_id && record.run_id) {
+            if (metadata.run_admitted !== true || !Number.isSafeInteger(metadata.run_generation))
+                throw new AppError("run_recovery_guarded", "Readback has no admitted generation", 1);
+            assertRunMutationAllowed(context, record.project_id, record.run_id, metadata.run_generation);
+            if (managedProcessRuntimeHome(record, context) !== context.ddFlowHome)
+                throw new AppError("process_runtime_scope_mismatch", "Readback belongs to another engine home", 1);
+        }
+        return { ok: true, process_id: id, lease_expires_at: record.lease_expires_at, registration_sha256: hash, readback: true };
+    }
     if (action === "reconcile")
         return { ok: true, processes: await reconcileExpiredManagedProcesses(context, requiredOption(parsed, "owner"), optionalNumber(parsed, "grace-ms")) };
     throw new AppError("usage", "Usage: dd-flow runtime process <start|stop|register|confirm|heartbeat|admission|finish|status|reconcile>", 2);

package/dist/cli.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { isNativeHookIngress } from "./cli/native-hook-ingress.js";
 import { isRuntimeMaintenanceIngress, runRuntimeMaintenanceIngress } from "./cli/runtime-maintenance-ingress.js";
+import { publishSetup } from './harness-runtime/lib/setup-progress.mjs';
 const args = process.argv.slice(2);
 const managedHook = Boolean(process.env.DD_FLOW_CODEX_STATE_DIR) && args.slice(0, 3).join(" ") === "codex hook handle" && !args.includes("--help") && !args.includes("-h");
 const exitCode = isRuntimeMaintenanceIngress(args, process.env)
@@ -9,5 +10,10 @@ const exitCode = isRuntimeMaintenanceIngress(args, process.env)
         ? await (await import("./cli/hook-ingress.js")).runHookIngress(args)
         : isNativeHookIngress(args) && !args.includes("--help") && !args.includes("-h")
             ? await (await import("./cli/native-hook-ingress.js")).runNativeHookIngress(args)
-            : await (await import("./cli/run-cli.js")).runCli(args);
+            : await (async () => {
+                publishSetup('ingress_entered');
+                const cli = await import('./cli/run-cli.js');
+                publishSetup('imports_ready');
+                return await cli.runCli(args);
+            })();
 process.exitCode = exitCode;

package/dist/harness-runtime/lib/dd-agy-daemon.mjs

@@ -1,3 +1,4 @@
+import { SETUP_STARTUP_MS, startupObserver, observationDetails } from './setup-progress.mjs';
 import { callDaemonObserved } from './daemon-observation.mjs';
 import { operationProgressReporter } from './operation-progress.mjs';
 import { captureDispatchGuard, cancelPendingDispatch } from "./dispatch-fence.mjs";
@@ -201,7 +202,7 @@ export async function startDaemon(options) {
   const log = await open(paths.log, "a", 0o600), child = spawn(process.execPath, [config.entryPath, "daemon", "serve", "--state-dir", paths.dir], { cwd: config.cwd, env: sanitizedEnv(config), detached: true, stdio: ["ignore", log.fd, log.fd] }); child.unref(); await log.close();
   try {
     await confirmDaemonProcess(config, resourceProcess, child);
-    const startupClock = new ObservationClock({ timeoutMs: 30_000 }); while (!startupClock.sample()) { await new Promise(resolve => setTimeout(resolve, 100));
+    const startupClock = new ObservationClock({ timeoutMs: SETUP_STARTUP_MS }); const startupProgress = startupObserver(paths.dir, config.daemonId); while (!startupClock.sample(await startupProgress())) { await new Promise(resolve => setTimeout(resolve, 100));
       const persisted = await readState(paths.dir);
       if (persisted?.shutdown_state === "failed") {
         const failure = persisted.startup_error ?? {};
@@ -209,7 +210,7 @@ export async function startDaemon(options) {
       }
       try { const status = await callDaemon(paths.dir, "daemon.status", {}, 1000); if (status.provider_ready) return status; } catch (error) { if (!["daemon_not_running","daemon_timeout"].includes(error.code)) throw error; }
     }
-    throw new DaemonError("daemon_start_failed", "Antigravity daemon did not become ready", true);
+    throw Object.assign(new DaemonError("daemon_start_failed", "Antigravity daemon did not become ready", true), { details: observationDetails(startupClock, 'daemon-start', child.pid) });
   } catch (error) {
     await cleanupFailedDaemonStart(config, resourceProcess, child, error, () => readState(paths.dir), config.daemonId);
     throw error;
@@ -322,7 +323,7 @@ export class Runtime {
     catch (error) { await cleanupFailedStart(this.config, providerProcess, this.child, error); throw error; }
     finally { allowProviderFinalization(); }
     let readyTimer;
-    try { return await Promise.race([this.readyPromise, new Promise((_, reject) => { readyTimer = observedTimeout(() => reject(new DaemonError("agy_init_timeout", "Antigravity init timed out", true)), 30_000); })]); }
+    try { return await Promise.race([this.readyPromise, new Promise((_, reject) => { readyTimer = observedTimeout(() => reject(new DaemonError("agy_init_timeout", "Antigravity init timed out", true)), SETUP_STARTUP_MS, { progress: () => this.lastActivityAt }); })]); }
     finally { clearTimeout(readyTimer); }
   }
   async drain(readyResolve) { let index; while ((index = this.buffer.indexOf("\n")) >= 0) { const line = this.buffer.slice(0, index).trim(); this.buffer = this.buffer.slice(index + 1); if (!line) continue; let event; try { event = JSON.parse(line); } catch { await this.journal("invalid_json", { line: line.slice(0, 1000) }); continue; }

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

@@ -1,6 +1,7 @@
 import { mkdtemp, rm } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+import { SETUP_STARTUP_MS } from './setup-progress.mjs';
 
 import { checkObservedProfile } from "./model-observations.mjs";
 
@@ -24,7 +25,7 @@ export function executable(bin, args = []) {
 }
 
 export async function runAgy(bin, args, options = {}) {
-  const stdout = await commandText(bin, args, { cwd: options.cwd, env: options.env, input: options.stdin ?? "", timeoutMs: options.timeoutMs, phase: "native-doctor" });
+  const stdout = await commandText(bin, args, { cwd: options.cwd, env: options.env, input: options.stdin ?? "", timeoutMs: options.timeoutMs, startupMs: options.startupMs ?? options.timeoutMs ?? SETUP_STARTUP_MS, phase: "native-doctor" });
   return { stdout, stderr: "", code: 0 };
 }
 
@@ -48,8 +49,8 @@ export function assertProfile(requested, observed) { return checkObservedProfile
 export async function doctor(options = {}) {
   const bin = options.bin ?? process.env.DD_AGY_BIN ?? "agy", temporary = await mkdtemp(path.join(os.tmpdir(), "dd-agy-doctor-"));
   try {
-    const version = (await runAgy(bin, ["--version"], { timeoutMs: AGY_VERSION_TIMEOUT_MS })).stdout.trim();
-    const models = await runAgy(bin, [`--gemini_dir=${temporary}`, "--app_data_dir=runtime", "models"], { timeoutMs: options.timeoutMs ?? 30_000 });
+    const version = (await runAgy(bin, ["--version"], { timeoutMs: AGY_VERSION_TIMEOUT_MS, startupMs: options.timeoutMs ?? SETUP_STARTUP_MS })).stdout.trim();
+    const models = await runAgy(bin, [`--gemini_dir=${temporary}`, "--app_data_dir=runtime", "models"], { timeoutMs: options.timeoutMs ?? 30_000, startupMs: options.timeoutMs ?? SETUP_STARTUP_MS });
     const modelIds = models.stdout.split(/\r?\n/).map(line => line.split(/\s+/)[0]).filter(Boolean);
     if (!modelIds.includes(options.model ?? DEFAULT_MODEL)) throw new AgyError("agy_model_unavailable", `required Antigravity model is unavailable: ${options.model ?? DEFAULT_MODEL}`);
     return { compatible: true, observed_runtime: { agy: version, dd_harness_contract: "dd-agy-harness@1" }, isolation: { gemini_dir: "verified", app_data_dir: "verified" }, auth: "available", models: modelIds };

package/dist/harness-runtime/lib/dd-codex-daemon.mjs

@@ -1,3 +1,4 @@
+import { SETUP_STARTUP_MS, startupObserver, observationDetails } from './setup-progress.mjs';
 import { callDaemonObserved } from './daemon-observation.mjs';
 import { admitNativeRequestBuffer } from "./native-streams.mjs";
 import { captureDispatchGuard, cancelPendingDispatch } from "./dispatch-fence.mjs";
@@ -87,7 +88,7 @@ export async function startDaemon(options) {
   if (previous?.shutdown_state === "clean") await authorizeRetainedDaemonResume(paths.dir, previous, options.sessionId, config);
   await removeSocket(paths.socket); const resourceProcess = await registerDaemonProcess(config, { kind: "codex-daemon", owner: `codex:${path.basename(paths.dir)}`, operation: `codex-daemon:${path.basename(paths.dir)}`, stdout: paths.log, stderr: paths.log }); const state = { schema_id: stateSchema, daemon_id: randomUUID(), pid: null, cwd: config.cwd, journal: config.journal, config, socket: paths.socket, started_at: new Date().toISOString(), shutdown_state: "starting", sessions: previous?.sessions ?? [], resource_process: resourceProcess }; await writeState(paths.state, state);
   const log = await open(paths.log, "a", 0o600); const child = spawn(process.execPath, [options.entryPath, "daemon", "serve", "--state-dir", paths.dir], { cwd: config.cwd, detached: true, stdio: ["ignore", log.fd, log.fd] }); child.unref(); await log.close();
-  try { await confirmDaemonProcess(config, resourceProcess, child); const startupClock = new ObservationClock({ timeoutMs: 60_000 }); while (!startupClock.sample()) { await new Promise((resolve) => setTimeout(resolve, 100)); try { return await callDaemon(paths.dir, "daemon.status", {}, 5_000); } catch (error) { if (!["daemon_not_running", "daemon_timeout"].includes(error.code)) throw error; } } throw Object.assign(new Error("daemon did not become ready"), { code: "daemon_start_failed" }); }
+  try { await confirmDaemonProcess(config, resourceProcess, child); const startupClock = new ObservationClock({ timeoutMs: SETUP_STARTUP_MS }); const startupProgress = startupObserver(paths.dir, state.daemon_id); while (!startupClock.sample(await startupProgress())) { await new Promise((resolve) => setTimeout(resolve, 100)); try { return await callDaemon(paths.dir, "daemon.status", {}, 5_000); } catch (error) { if (!["daemon_not_running", "daemon_timeout"].includes(error.code)) throw error; } } throw Object.assign(new Error("daemon did not become ready"), { code: "daemon_start_failed", details: observationDetails(startupClock, "daemon-start", child.pid) }); }
   catch (error) { await cleanupFailedDaemonStart(config, resourceProcess, child, error, () => readState(paths.state), state.daemon_id); throw error; }
 }
 export async function stopDaemon(options) { const timeoutMs = options.timeoutMs ?? 30_000; return await confirmDaemonStopped(() => callDaemon(options.stateDir, "daemon.stop", { cancelTree: options.cancelTree === true }, timeoutMs), locations(options.stateDir).socket, timeoutMs, { readState: () => readState(locations(options.stateDir).state) }); }

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

@@ -11,6 +11,7 @@ import { observeModel } from "./model-observations.mjs";
 import { classifyCodexItem } from "./tool-observations.mjs";
 import { readNativeLines, streamNativeDiagnostics, nativeObservationError } from "./native-streams.mjs";
 import { operationProgressReporter } from "./operation-progress.mjs";
+import { publishSetup } from './setup-progress.mjs';
 
 const LATE_RESPONSE_GRACE_MS = 5_000;
 const CODEX_SESSION_CONFIG = Object.freeze({
@@ -75,7 +76,9 @@ export class CodexBridge {
     this.child.on("close", code => { void Promise.all([this.nativeDrain, this.diagnostics]).then(() => this.rejectAll(Object.assign(new Error(`Codex app-server exited ${code}${this.stderr.trim() ? `: ${this.stderr.trim()}` : ""}`), { code: "bridge_exited" }))); });
     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);
+    publishSetup('probe_started', 'codex-initialize');
     await this.request("initialize", { clientInfo: { name: "dd-codex", version: "0.1.0" }, capabilities: { optOutNotificationMethods: [], experimentalApi: true } });
+    publishSetup('native_initialized', 'codex-initialize');
   }
 
   receive(line) {
@@ -501,7 +504,7 @@ function threadReceipt(thread) {
 }
 
 export async function doctor(options = {}) {
-  const codex_cli = parseCodexCliVersion(await commandText(options.bin ?? process.env.DD_CODEX_BIN ?? "codex", ["--version"]));
+  const codex_cli = parseCodexCliVersion(await commandText(options.bin ?? process.env.DD_CODEX_BIN ?? "codex", ["--version"], { phase: 'native-version' }));
   return await withBridge(options, async () => ({ harness: "codex-desktop", app_server: "available", observed_runtime: { codex_cli, dd_harness_contract: "dd-codex-harness@1" }, requested_profile: profile(options), observed_at: now() }));
 }
 

package/dist/harness-runtime/lib/dd-droid-daemon.mjs

@@ -1,3 +1,4 @@
+import { SETUP_STARTUP_MS, startupObserver, observationDetails } from './setup-progress.mjs';
 import { callDaemonObserved } from './daemon-observation.mjs';
 import { admitNativeRequestBuffer, nativeObservationError } from "./native-streams.mjs";
 import { createHash, randomUUID } from "node:crypto";
@@ -44,9 +45,9 @@ export async function startDaemon(options) {
   const log = await open(paths.log, "a", 0o600); const child = spawn(process.execPath, [config.entryPath, "daemon", "serve", "--state-dir", paths.dir], { cwd: config.cwd, detached: true, stdio: ["ignore", log.fd, log.fd] }); child.unref(); await log.close();
   try {
     await confirmDaemonProcess(config, resource, child);
-    const startupClock = new ObservationClock({ timeoutMs: 30_000 });
-    while (!startupClock.sample()) { await new Promise(resolve => setTimeout(resolve, 100)); const saved = await readJson(paths.state); if (saved?.startup_error) throw Object.assign(new Error(saved.startup_error.message), saved.startup_error); try { return await callDaemon(paths.dir, "daemon.status", {}, 1_000); } catch (error) { if (!["daemon_not_running", "daemon_timeout"].includes(error.code)) throw error; } }
-    throw new DroidError("daemon_start_failed", "Droid daemon did not become ready");
+    const startupClock = new ObservationClock({ timeoutMs: SETUP_STARTUP_MS }); const startupProgress = startupObserver(paths.dir, config.daemonId);
+    while (!startupClock.sample(await startupProgress())) { await new Promise(resolve => setTimeout(resolve, 100)); const saved = await readJson(paths.state); if (saved?.startup_error) throw Object.assign(new Error(saved.startup_error.message), saved.startup_error); try { return await callDaemon(paths.dir, "daemon.status", {}, 1_000); } catch (error) { if (!["daemon_not_running", "daemon_timeout"].includes(error.code)) throw error; } }
+    throw Object.assign(new DroidError("daemon_start_failed", "Droid daemon did not become ready"), { details: observationDetails(startupClock, 'daemon-start', child.pid) });
   } catch (error) { await cleanupFailedStart(config, resource, child, error); throw error; }
 }
 export async function stopDaemon(options) { return await confirmDaemonStopped(() => callDaemon(options.stateDir, "daemon.stop", { cancelTree: options.cancelTree === true }, 30_000), droidPaths(options.stateDir).socket, 30_000, { readState: () => readJson(droidPaths(options.stateDir).state) }); }

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

@@ -65,7 +65,7 @@ export async function prepareDroidHome(config) {
 export async function removeDroidAuth(config) {
   for (const name of ["auth.encrypted", "auth.v2.key", "auth.v2.file", "auth.json"]) await unlink(path.join(config.home, ".factory", name)).catch(error => { if (error.code !== "ENOENT") throw error; });
 }
-export async function droidVersion(bin) { const target = executable(bin, ["--version"]); return await commandText(target.command, target.args, { timeoutMs: 10_000, phase: "native-version" }); }
+export async function droidVersion(bin) { const target = executable(bin, ["--version"]); return await commandText(target.command, target.args, { phase: "native-version" }); }
 
 /** The qualified OpenAI profile reports uncached input separately from caches;
  * output already includes thinking. Keep native counters alongside normalization. */

package/dist/harness-runtime/lib/dd-grok-daemon.mjs

@@ -1,3 +1,4 @@
+import { SETUP_STARTUP_MS, startupObserver, observationDetails } from './setup-progress.mjs';
 import { callDaemonObserved } from './daemon-observation.mjs';
 import { canonicalNativeOperation } from './adapter-timeouts.mjs';
 import { admitNativeRequestBuffer } from "./native-streams.mjs";
@@ -174,7 +175,7 @@ export async function startDaemon(options) {
   const daemonId = randomUUID();
   const state = { descendants: previous?.descendants ?? [], schema_id: STATE_SCHEMA, daemon_id: daemonId, pid: null, socket: paths.socket, started_at: new Date().toISOString(), shutdown_state: "starting", active_tree: false, recovery_status: previous?.shutdown_state === "running" ? "recovered_idle" : "clean_start", auth_status: copiedAuth ? "copied" : "absent", ...(importedSession ? { imported_session: importedSession } : {}), versions: versions.versions, config_isolation: configIsolation, config: { ...config, daemonId }, sessions: importedSession ? [{ provider_session_id: importedSession.provider_session_id, adapter_session_id: importedSession.provider_session_id, parent_provider_session_id: null, root_provider_session_id: importedSession.provider_session_id, cwd: importedSession.source_cwd }] : (previous?.sessions ?? []), resource_process: resourceProcess };
   await writeState(paths.state, state); const log = await open(paths.log, "a", 0o600); const child = spawn(process.execPath, [absolute(options.entryPath, "dd-grok entry"), "daemon", "serve", "--state-dir", paths.dir], { cwd: config.cwd, env: isolatedEnv(state.config), detached: true, stdio: ["ignore", log.fd, log.fd] }); child.unref(); await log.close();
-  try { await confirmDaemonProcess(config, resourceProcess, child); const startupClock = new ObservationClock({ timeoutMs: 120_000 }); while (!startupClock.sample()) { await new Promise((resolve) => setTimeout(resolve, 100)); const failure = grokStartupFailure(await readState(paths.dir)); if (failure) throw failure; try { const status = await callDaemon(paths.dir, "daemon.ready", {}, 5000); if (status.ready) return status; } catch (error) { if (error.code !== "daemon_not_running" && error.code !== "daemon_timeout") throw error; } } throw new DaemonError("daemon_start_failed", "daemon did not become ready", true); }
+  try { await confirmDaemonProcess(config, resourceProcess, child); const startupClock = new ObservationClock({ timeoutMs: SETUP_STARTUP_MS }); const startupProgress = startupObserver(paths.dir, state.daemon_id); while (!startupClock.sample(await startupProgress())) { await new Promise((resolve) => setTimeout(resolve, 100)); const failure = grokStartupFailure(await readState(paths.dir)); if (failure) throw failure; try { const status = await callDaemon(paths.dir, "daemon.ready", {}, 5000); if (status.ready) return status; } catch (error) { if (error.code !== "daemon_not_running" && error.code !== "daemon_timeout") throw error; } } throw Object.assign(new DaemonError("daemon_start_failed", "daemon did not become ready", true), { details: observationDetails(startupClock, 'daemon-start', child.pid) }); }
   catch (error) { await cleanupFailedDaemonStart(config, resourceProcess, child, error, () => readState(paths.dir), daemonId); throw error; }
 }
 export async function stopDaemon(options) { const timeoutMs = options.timeoutMs ?? 30_000; return await confirmDaemonStopped(() => callDaemon(options.stateDir, "daemon.stop", { cancelTree: options.cancelTree === true }, timeoutMs), locations(options.stateDir).socket, timeoutMs, { readState: () => readState(options.stateDir) }); }

package/dist/harness-runtime/lib/dd-opencode-daemon.mjs

@@ -1,3 +1,4 @@
+import { SETUP_STARTUP_MS, startupObserver, observationDetails } from './setup-progress.mjs';
 import { callDaemonObserved } from './daemon-observation.mjs';
 import { admitNativeRequestBuffer } from "./native-streams.mjs";
 import { captureDispatchGuard, cancelPendingDispatch } from "./dispatch-fence.mjs";
@@ -26,8 +27,9 @@ async function readState(dir) { try { return JSON.parse(await readFile(locations
 async function removeSocket(paths) { try { if (!(await lstat(paths.socket)).isSocket()) throw new DaemonError("unsafe_socket", "refusing to replace non-socket daemon path"); await unlink(paths.socket); } catch (error) { if (error.code !== "ENOENT") throw error; } }
 function executable(bin, args = []) { return /\.[cm]?js$/.test(bin) ? { command: process.execPath, args: [bin, ...args] } : { command: bin, args }; }
 function isolatedEnv(config) { return { ...process.env, XDG_DATA_HOME: config.dataHome, XDG_CONFIG_HOME: config.configHome, XDG_CACHE_HOME: config.cacheHome, OPENCODE_CONFIG_DIR: config.adapterDir, OPENCODE_DISABLE_PROJECT_CONFIG: "1", OPENCODE_SERVER_PASSWORD: config.password, ...(config.ddFlowHome ? { DD_FLOW_HOME: config.ddFlowHome } : {}), ...(config.resourceHome ? { DD_FLOW_RESOURCE_HOME: config.resourceHome } : {}), ...(config.ddFlowBin ? { DD_OPENCODE_DD_FLOW_BIN: config.ddFlowBin, DD_OPENCODE_NODE_BIN: process.execPath, DD_OPENCODE_PROJECT_ROOT: config.projectRoot } : {}), DD_OPENCODE_DAEMON_ID: config.daemonId, DD_OPENCODE_PROVIDER: config.provider, DD_OPENCODE_MODEL: config.model, DD_OPENCODE_VARIANT: config.variant, DD_OPENCODE_AGENT: config.agent, DD_OPENCODE_SERVER_VERSION: config.version ?? "unknown", DD_OPENCODE_PLUGIN_SHA256: config.pluginSha256 ?? "unknown" }; }
-export async function run(bin, args, config, { stdin, timeoutMs = 30_000 } = {}) {
-  return await commandText(bin, args, { cwd: config.cwd, env: isolatedEnv(config), input: stdin ?? null, timeoutMs, phase: "native-utility" });
+export async function run(bin, args, config, options = {}) {
+  const { stdin, timeoutMs = 30_000, startupMs = options.timeoutMs ?? SETUP_STARTUP_MS } = options;
+  return await commandText(bin, args, { cwd: config.cwd, env: isolatedEnv(config), input: stdin ?? null, timeoutMs, startupMs, phase: args.includes('--version') ? 'native-version' : 'native-utility' });
 }
 async function forwardUsage(config, sessionId, snapshot) {
   if (!config.ddFlowBin) return;
@@ -70,7 +72,7 @@ export async function startDaemon(options) {
   const resourceProcess = await registerDaemonProcess(config, { kind: "opencode-daemon", owner: `opencode:${path.basename(paths.dir)}`, operation: `opencode-daemon:${path.basename(paths.dir)}`, stdout: paths.log, stderr: paths.log });
   const state = { schema_id: STATE_SCHEMA, daemon_id: daemonId, shutdown_state: "starting", active_tree: false, auth_status: config.authStatus, versions: { opencode: config.version }, config, sessions: imported ? [{ provider_session_id: imported.provider_session_id, parent_provider_session_id: null, root_provider_session_id: imported.provider_session_id, cwd: config.cwd }] : (previous?.sessions ?? []), resource_process: resourceProcess }; await writeJson(paths.state, state);
   const log = await open(paths.log, "a", 0o600), entry = absolute(options.entryPath, "dd-opencode entry"); const child = spawn(process.execPath, [entry, "daemon", "serve", "--state-dir", paths.dir], { cwd: config.cwd, env: isolatedEnv(config), detached: true, stdio: ["ignore", log.fd, log.fd] }); child.unref(); await log.close();
-  try { await confirmDaemonProcess(config, resourceProcess, child); const startupClock = new ObservationClock({ timeoutMs: 20_000 }); while (!startupClock.sample()) { await new Promise(resolve => setTimeout(resolve, 100)); try { return await callDaemon(paths.dir, "daemon.status", {}, 1000); } catch (error) { if (!["daemon_not_running","daemon_timeout"].includes(error.code)) throw error; } } throw new DaemonError("daemon_start_failed", "daemon did not become ready", true); }
+  try { await confirmDaemonProcess(config, resourceProcess, child); const startupClock = new ObservationClock({ timeoutMs: SETUP_STARTUP_MS }); const startupProgress = startupObserver(paths.dir, state.daemon_id); while (!startupClock.sample(await startupProgress())) { await new Promise(resolve => setTimeout(resolve, 100)); try { return await callDaemon(paths.dir, "daemon.status", {}, 1000); } catch (error) { if (!["daemon_not_running","daemon_timeout"].includes(error.code)) throw error; } } throw Object.assign(new DaemonError("daemon_start_failed", "daemon did not become ready", true), { details: observationDetails(startupClock, 'daemon-start', child.pid) }); }
   catch (error) { await cleanupFailedStart(config, resourceProcess, child, error); throw error; }
 }
 export const stopDaemon = async options => { const timeoutMs = options.timeoutMs ?? 30_000; return await confirmDaemonStopped(() => callDaemon(options.stateDir, "daemon.stop", { cancelTree: options.cancelTree === true }, timeoutMs), locations(options.stateDir).socket, timeoutMs, { readState: () => readState(options.stateDir) }); };
@@ -223,7 +225,7 @@ export async function serveDaemon(stateDir) {
     scheduleDaemonProcessHeartbeat(state.config, state.resource_process);
     scheduleDaemonProcessHeartbeat(state.config, providerProcess);
     state.provider_process = providerProcess; state.provider_pid = child.pid; await writeJson(paths.state, state);
-    const client = new OpenCodeClient({ baseUrl: `http://127.0.0.1:${port}`, password: state.config.password, directory: state.config.cwd }); const startupClock = new ObservationClock({ timeoutMs: 15_000 }); while (!startupClock.sample()) { try { await client.health(); break; } catch { await new Promise(resolve => setTimeout(resolve, 100)); } } await client.health(); const runtime = new Runtime(paths, state, client, child, providerProcess); await removeSocket(paths);
+    const client = new OpenCodeClient({ baseUrl: `http://127.0.0.1:${port}`, password: state.config.password, directory: state.config.cwd }); const startupProgress = startupObserver(paths.dir, state.daemon_id); const startupClock = new ObservationClock({ timeoutMs: SETUP_STARTUP_MS }); while (!startupClock.sample(await startupProgress())) { try { await client.health(); break; } catch { await new Promise(resolve => setTimeout(resolve, 100)); } } await client.health(); const runtime = new Runtime(paths, state, client, child, providerProcess); await removeSocket(paths);
     const server = net.createServer(connection => {
       connection.setEncoding("utf8"); let buffer = "", consumed = false;
       connection.on("data", chunk => {

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

@@ -1,3 +1,4 @@
+import { SETUP_STARTUP_MS, startupObserver, observationDetails } from './setup-progress.mjs';
 import { callDaemonObserved } from './daemon-observation.mjs';
 import { admitNativeRequestBuffer } from "./native-streams.mjs";
 import { ObservationClock } from "./observation-clock.mjs";
@@ -180,13 +181,13 @@ export async function startDaemon(options) {
   await log.close();
   try {
     await confirmDaemonProcess(config, resourceProcess, child);
-    const startupClock = new ObservationClock({ timeoutMs: 30_000 });
-    while (!startupClock.sample()) {
+    const startupClock = new ObservationClock({ timeoutMs: SETUP_STARTUP_MS }); const startupProgress = startupObserver(paths.dir, state.daemon_id);
+    while (!startupClock.sample(await startupProgress())) {
       await new Promise((resolve) => setTimeout(resolve, 100));
       try { return await callDaemon(paths.dir, "daemon.status", {}, 1000); }
       catch (error) { if (error.code !== "daemon_not_running" && error.code !== "daemon_timeout") throw error; }
     }
-    throw new DaemonError("daemon_start_failed", "daemon did not become ready", true);
+    throw Object.assign(new DaemonError("daemon_start_failed", "daemon did not become ready", true), { details: observationDetails(startupClock, 'daemon-start', child.pid) });
   } catch (error) {
     await cleanupFailedDaemonStart(config, resourceProcess, child, error, () => readState(paths.dir), state.daemon_id);
     throw error;

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

@@ -4,6 +4,8 @@ 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 { createReadStream } from 'node:fs';
+import { publishSetup, SETUP_STARTUP_MS } from './setup-progress.mjs';
 import { appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { closeBridgeProcess } from "./managed-daemon.mjs";
@@ -185,11 +187,14 @@ export class AcpBridge {
     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", {
+    publishSetup('probe_started', 'native-initialize');
+    const initialized = await this.request("initialize", {
       protocolVersion: 1,
       clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, elicitation: { form: {} } },
       clientInfo: this.options.clientInfo ?? { name: "dd-zcode", version: "0.1.0" },
-    }, this.options.initializeTimeoutMs ?? 30_000);
+    }, this.options.initializeTimeoutMs ?? SETUP_STARTUP_MS);
+    publishSetup('native_initialized', 'native-initialize');
+    return initialized;
   }
 
   receive(line) {
@@ -931,8 +936,12 @@ export async function doctor(options = {}) {
   const ddHarness = await commandOutput(options.bin, ["--dd-harness-version"]);
   const zcodePath = options.zcodePath ?? process.env.ZCODE_BIN ?? process.env.ZCODE_PATH ?? "/Applications/ZCode.app/Contents/Resources/glm/zcode.cjs";
   const zcode = await commandOutput(zcodePath, ["--version"]);
-  const native = await readFile(zcodePath);
-  const sha256 = createHash("sha256").update(native).digest("hex");
+  const hash = createHash('sha256'); let bytes = 0;
+  for await (const chunk of createReadStream(zcodePath)) {
+    hash.update(chunk); bytes += chunk.length;
+    if (bytes % (4 * 1024 * 1024) < chunk.length) publishSetup('identity_digest_progress', bytes);
+  }
+  const sha256 = hash.digest('hex'); publishSetup('identity_digest_completed');
   const qualification = zcodeLifecycleQualification(sha256, zcodeAcpCommit, ddHarness);
   return { compatible: qualification.status === "qualified", contract_supported: supportedZcodeHarnessContract(ddHarness), lifecycle_qualification: qualification, observed_runtime: { zcode, zcode_acp: zcodeAcp, zcode_acp_commit: zcodeAcpCommit, dd_harness_contract: ddHarness } };
 }

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

@@ -1,8 +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 const RENEWAL_POLICY: Readonly<{ startupMs: number; budgetMs: number; attemptMs: number; safetyMs: number }>;
+export type RenewalState = { uncertainSince: number | null; attempt: number; exhausted: boolean; leaseExpiresAt: string | null };
+export function createRenewalState(options?: { leaseExpiresAt?: string | null }): RenewalState;
+export function renewalRemaining(state: RenewalState, now?: number, wallNow?: 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 renewalConfirmed(state: RenewalState, now?: number, leaseExpiresAt?: string | null): boolean;
 export function maintenanceRetryable(error: unknown): boolean;

package/dist/harness-runtime/lib/lease-renewal.mjs

@@ -1,19 +1,32 @@
 /** Shared policy only; transports and owner-specific fences stay at callsites. */
-export const RENEWAL_POLICY = Object.freeze({ budgetMs: 30_000, attemptMs: 5_000 });
-export function createRenewalState() { return { uncertainSince: null, attempt: 0, exhausted: false }; }
-export function renewalRemaining(state, now = performance.now()) {
-  const remaining = state.exhausted ? 0 : state.uncertainSince === null ? RENEWAL_POLICY.budgetMs : Math.max(0, RENEWAL_POLICY.budgetMs - (now - state.uncertainSince));
+export const RENEWAL_POLICY = Object.freeze({ startupMs: 120_000, budgetMs: 126_000, attemptMs: 5_000, safetyMs: 1_000 });
+export function createRenewalState({ leaseExpiresAt = null } = {}) { return { uncertainSince: null, attempt: 0, exhausted: false, leaseExpiresAt }; }
+export function renewalRemaining(state, now = performance.now(), wallNow = Date.now()) {
+  const expiry = Date.parse(state.leaseExpiresAt ?? "");
+  const budget = Number.isFinite(expiry) ? Math.max(0, expiry - wallNow - RENEWAL_POLICY.safetyMs) : state.leaseExpiresAt != null ? 0 : RENEWAL_POLICY.budgetMs;
+  const remaining = state.exhausted ? 0 : Number.isFinite(expiry) || state.uncertainSince === null ? budget : Math.max(0, budget - (now - state.uncertainSince));
   if (remaining === 0) state.exhausted = true;
   return remaining;
 }
 export function renewalFailure(state, now = performance.now()) { state.uncertainSince ??= now; state.attempt++; return renewalRemaining(state, now); }
 export function renewalDelay(state) { return Math.min(2_000, 250 * 2 ** Math.min(3, Math.max(0, state.attempt - 1))); }
-export function renewalConfirmed(state, now = performance.now()) { if (!renewalRemaining(state, now)) return false; state.uncertainSince = null; state.attempt = 0; return true; }
+export function renewalConfirmed(state, now = performance.now(), leaseExpiresAt = null) {
+  // Caller verifies exact owner/fence. A committed receipt, not elapsed time,
+  // establishes the new authority horizon.
+  if (leaseExpiresAt !== null) {
+    const expiry = Date.parse(leaseExpiresAt);
+    if (!Number.isFinite(expiry) || expiry <= Date.now() + RENEWAL_POLICY.safetyMs) return false;
+    state.leaseExpiresAt = leaseExpiresAt; state.exhausted = false;
+  }
+  if (!renewalRemaining(state, now)) return false;
+  state.uncertainSince = null; state.attempt = 0; return true;
+}
 export function maintenanceRetryable(error) {
   let retryable = false;
   // Inspect only bounded typed causes from our maintenance transport, never text.
   for (let depth = 0; error && depth < 8; depth++, error = error.cause ?? error.details?.cause) {
     if (error.details?.cleanup_unconfirmed === true) return false;
+    if (error.details?.effect === "unknown") return false;
     if (["process_lease_lost", "controller_lease_lost", "process_maintenance_receipt_invalid", "runtime_owner_mismatch"].includes(error.code)) return false;
     if (error.code === "process_ownership_unknown" && error.details?.reason === "physical_identity_unavailable" && ["process_confirmation", "observer_registration"].includes(error.details.phase) && error.details.effect === "no_effect" && error.details.native_dispatch_started === false) retryable = true;
     if (["process_heartbeat_timeout", "process_maintenance_timeout", "hook_deadline_exceeded", "native_hook_timeout", "SQLITE_BUSY", "SQLITE_LOCKED"].includes(error.code)) retryable = true;

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

@@ -2,6 +2,7 @@ import type { ChildProcess } from "node:child_process";
 type RuntimeConfig = Record<string, unknown>;
 type ProcessBinding = { id: string; lease_token: string; kind?: string; lease_expires_at?: string; registration_sha256?: string };
 export function runtimeProcess(config: RuntimeConfig, action: string, options?: Record<string, unknown>, transport?: { timeoutMs?: number; signal?: AbortSignal }): Promise<Record<string, unknown> | null>;
+export function readbackDaemonProcess(config: RuntimeConfig, record: ProcessBinding, transport?: { signal?: AbortSignal }): Promise<Record<string, unknown>>;
 export function registerDaemonProcess(config: RuntimeConfig, input: { kind: string; [key: string]: unknown }): Promise<ProcessBinding | null>;
 export function confirmDaemonProcess(config: RuntimeConfig, record: ProcessBinding | null | undefined, child: Pick<ChildProcess, "pid"> | null | undefined): Promise<void>;
 export function assertDaemonOwnership(stateDir: string, dispatch?: Record<string, unknown>, assertCurrent?: () => void): Promise<void>;