@deksden-com/dd-flow-cli 0.9.0-beta.152 → 0.9.0-beta.155

package/dist/services/review-fix-stage-results.js

@@ -0,0 +1,86 @@
+import { Ajv2020 } from "ajv/dist/2020.js";
+import { AppError } from "../shared/errors.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+function refuse(reason) {
+    throw new AppError("review_fix_stage_result_invalid", "Review-fix requires its selected findings and original delivered user scope", 2, { reason, effect: "no_effect", ...(reason === "invalid_schema" ? { phase: "prepare", recoverable: true } : {}) });
+}
+/** Proposal validation, not semantic approval or physical reviewer independence.
+ * Registered handlers must assess actual agreement and independent ownership.
+ * There is intentionally no writable scope, specification or SDLC launch field. */
+export function validateReviewFixStageResult(bytes, schemaBytes, binding) {
+    if (!bytes.length || bytes.length > 1024 * 1024 || !schemaBytes.length || schemaBytes.length > 1024 * 1024)
+        refuse("result_exceeds_bound");
+    let result;
+    try {
+        result = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+    }
+    catch {
+        return refuse("invalid_schema");
+    }
+    const validate = (() => {
+        try {
+            const schema = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(schemaBytes));
+            if (schema.$id !== "dd-flow/review-fix-stage-result@1")
+                refuse("frozen_schema_invalid");
+            return new Ajv2020({ strict: true, validateFormats: false }).compile(schema);
+        }
+        catch {
+            return refuse("frozen_schema_invalid");
+        }
+    })();
+    if (!validate(result) || result.schema_id !== "dd-flow/review-fix-stage-result@1" || result.flow_id !== "review-fix"
+        || !result.summary.trim())
+        refuse("invalid_schema");
+    if (result.run_id !== binding.runId || result.stage !== binding.stage || result.input_sha256 !== binding.inputSha256
+        || result.intake_sha256 !== binding.intakeSha256 || result.snapshot_sha256 !== binding.snapshotSha256
+        || result.user_inputs_sha256 !== binding.userInputsSha256
+        || hybridDigest(result.predecessors) !== hybridDigest(binding.predecessors))
+        refuse("foreign_stage_binding");
+    const ids = binding.findingIds;
+    const complete = (items, expected) => {
+        if (new Set(expected).size !== expected.length || items.length !== expected.length
+            || hybridDigest(items.map(item => item.finding_id)) !== hybridDigest(expected))
+            refuse("incomplete_finding_decisions");
+    };
+    if (!ids.length || ids.length > 4096)
+        refuse("selected_findings_required");
+    complete(result.details.decisions, ids);
+    complete(result.details.review, binding.stage === "intake" ? [] : ids);
+    for (const decision of result.details.decisions) {
+        if (!decision.reason.trim())
+            refuse("invalid_schema");
+        if (decision.disposition === "approved") {
+            if (!decision.approval_source || !binding.userSources.some(source => source.role !== "question"
+                && hybridDigest({ root: source.root, path: source.path, sha256: source.sha256 }) === hybridDigest(decision.approval_source)))
+                refuse("approval_not_delivered_by_user");
+        }
+        else if (decision.approval_source !== null)
+            refuse("nonapproved_scope_claim");
+    }
+    if (result.details.review.some(item => !item.reason.trim()))
+        refuse("invalid_schema");
+    return result;
+}
+export function assertReviewFixStageScope(result, prior) {
+    // A real answer delivered during scope-review may revise the intake proposal.
+    // The handler must bind the newly read full input set; handoff cannot revise
+    // an already reviewed decision or silently consume later user messages.
+    const revisedByUser = prior.stage === "intake" && result.stage === "scope-review"
+        && result.user_inputs_sha256 !== prior.user_inputs_sha256;
+    if (result.intake_sha256 !== prior.intake_sha256 || result.snapshot_sha256 !== prior.snapshot_sha256
+        || !revisedByUser && (result.user_inputs_sha256 !== prior.user_inputs_sha256
+            || hybridDigest(result.details.decisions) !== hybridDigest(prior.details.decisions))
+        || prior.details.limitations.some(value => !result.details.limitations.includes(value))
+        || prior.stage === "scope-review" && hybridDigest(result.details.review) !== hybridDigest(prior.details.review))
+        refuse("accepted_scope_changed");
+}
+/** Honest handoff disposition only; even ready still needs explicit formalization. */
+export function reviewFixHandoffDisposition(result) {
+    if (result.stage !== "handoff")
+        refuse("handoff_required");
+    if (result.details.review.some(item => item.verdict === "revise"))
+        return "needs_scope";
+    if (result.details.decisions.some(item => item.disposition === "approved"))
+        return "ready";
+    return result.details.decisions.some(item => item.disposition === "deferred") ? "deferred" : "declined";
+}

package/dist/services/run-control-worker.js

@@ -15,16 +15,57 @@ import { interruptControlledSessions, observeControlledSessions, recordRunContro
 import { recoveryGuard, recordRecoveryCapture, sealRunRecovery } from "./run-recovery.js";
 import { createEvalRunSnapshot, verifyRecoverySnapshot } from "./eval-snapshots.js";
 import { recoveryObservationBudget, renewRecoveryObservation, withRecoveryObservation } from "./recovery-observation-budget.js";
+import { acceptedTechnicalWorkControl } from "./controller-result-authority.js";
+import { resumeRunController } from "./run-controller-recovery.js";
+import { managedDaemonExecutionAbsent, readNativeDaemonState } from "./managed-daemon-binding.js";
 export async function reconcileRunControl(context, input) {
     const status = runControlStatus(context, input);
     const control = status.control;
-    if (!control?.current || !["requested", "settled"].includes(control.status))
+    if (!control?.current || !["requested", "settled", "resuming"].includes(control.status))
         throw new AppError("run_control_state_changed", "Reconciliation requires the current draining/sealed control", 1);
     renewRecoveryObservation({}, input.requestId); // Validate before claiming anything.
     if (control.status === "requested")
         await launchControlWorker(context, { ...input, reconcileId: input.requestId });
+    else
+        await reconcileAcceptedTechnicalWork(context, input);
     return runControlStatus(context, input);
 }
+/** Explicit, repeatable reconciliation; never converts a human pause to resume. */
+async function reconcileAcceptedTechnicalWork(context, input) {
+    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
+    const row = context.db.get("SELECT * FROM run_controllers WHERE project_id=? AND run_id=? AND status NOT IN ('completed','cancelled','superseded')", [project.id, input.runId]);
+    if (!row)
+        return;
+    const requestId = `technical-work:${crypto.createHash("sha256").update(input.controlId).digest("hex")}`;
+    const control = context.db.get("SELECT status,recovery_id FROM run_controls WHERE control_id=? AND project_id=? AND run_id=?", [input.controlId, project.id, input.runId]);
+    const guard = recoveryGuard(context, project.id, input.runId);
+    if (!control || !guard || control.recovery_id !== guard.recovery_id)
+        return;
+    if (control.status === "settled") {
+        if (!acceptedTechnicalWorkControl(context, row, input.controlId))
+            return;
+        try {
+            const state = JSON.parse(row.state_json), session = state.sessions[state.current_session];
+            const manifest = JSON.parse(row.manifest_json);
+            const resourceContext = { ...context, env: { ...context.env, DD_FLOW_RESOURCE_HOME: manifest.resource_home } };
+            if (readNativeDaemonState(session.state_dir).shutdown_state !== "clean" || !managedDaemonExecutionAbsent(resourceContext, { stateDir: session.state_dir, projectId: row.project_id, runId: row.run_id, ownerId: session.owner.owner_id }))
+                return;
+        }
+        catch {
+            return;
+        }
+        const validate = () => {
+            const current = context.db.get("SELECT * FROM run_controllers WHERE controller_id=?", [row.controller_id]);
+            return Boolean(current && current.owner_token === row.owner_token && current.generation === row.generation && acceptedTechnicalWorkControl(context, current, input.controlId));
+        };
+        await resumeRunController(context, { projectRoot: input.projectRoot, runId: input.runId, controlId: input.controlId, requestId, waitMs: 0 }, validate);
+    }
+    else if (control.status === "resuming" && guard.generation === row.generation && ["sealed", "resuming", "recovered"].includes(guard.status)) {
+        const operation = context.db.get("SELECT status FROM run_controller_operations WHERE controller_id=? AND generation=? AND json_extract(input_json,'$.action')='control_resume' AND json_extract(input_json,'$.request_id')=? AND json_extract(input_json,'$.control_id')=?", [row.controller_id, row.generation, requestId, input.controlId]);
+        if (operation?.status === "accepted")
+            await resumeRunController(context, { projectRoot: input.projectRoot, runId: input.runId, controlId: input.controlId, requestId, waitMs: 0 });
+    }
+}
 /** The caller publishes intent and launches a control owner; it never owns drain. */
 export async function requestRunControl(context, input) {
     if (input.waitMs !== undefined && (!Number.isSafeInteger(input.waitMs) || input.waitMs < 0 || input.waitMs > 60_000))

package/dist/services/run-control.js

@@ -1,6 +1,7 @@
 import { setFlowRunRecoveryPaused } from "./runs.js";
 import crypto from "node:crypto";
 import { nativeShutdownConfirmed } from "../harness-runtime/lib/native-children.mjs";
+import { readTechnicalNotes, recordTechnicalNote } from "./technical-notes.js";
 import fs from "node:fs";
 import { ensureRunControlStorage } from "../storage/database.js";
 import { canonicalPath, resolveProjectRoot } from "../storage/paths.js";
@@ -17,13 +18,15 @@ import { controlStatusReceipt } from "./run-control-receipt.js";
 import { assertNativeCancellationReceipt, cancelControlledNativeSession, inspectControlledNativeSession } from "./native-session-control.js";
 import { terminalControllerFinalization } from "./run-controller-state.js";
 import { canonicalNativeOperation } from "../harness-runtime/lib/adapter-timeouts.mjs";
-import { requireManagedDaemonBinding } from "./managed-daemon-binding.js";
+import { requireManagedDaemonBinding, managedDaemonExecutionAbsent } from "./managed-daemon-binding.js";
+import { controllerObligationAccepted, technicalDependencyControl } from "./controller-result-authority.js";
+import { requireController } from "./run-controller-state.js";
 /** Durable projection only: status never probes a provider or acquires an owner. */
 export function runControlStatus(context, input) {
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
     // One read snapshot prevents a concurrent stop/resume from mixing generations
     // across the request, arbiter and worker projections. Savepoints also nest.
-    return context.db.readSnapshot(() => readControlStatus(context, input, project));
+    return context.db.readSnapshot(() => ({ ...readControlStatus(context, input, project), technical_notes: readTechnicalNotes(context, project.id, input.runId) }));
 }
 function readControlStatus(context, input, project) {
     const run = context.db.get("SELECT status FROM runs WHERE project_id = ? AND id = ?", [project.id, input.runId]);
@@ -78,6 +81,7 @@ async function reconcileOwnedSessions(context, input, interrupt, boundary) {
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
     const control = input.controlId ? context.db.get("SELECT * FROM run_controls WHERE project_id = ? AND run_id = ? AND control_id = ?", [project.id, input.runId, input.controlId]) : undefined;
     const request = control && JSON.parse(control.request_json);
+    const technicalPause = Boolean(control && technicalDependencyControl(context, project.id, input.runId, control.control_id));
     const pauseEscalated = control?.action === "pause" && request?.escalate === "interrupt" && Number.isSafeInteger(request.grace_ms) && Date.now() >= Date.parse(control.created_at) + request.grace_ms;
     if (boundary ? interrupt || control : !control || interrupt && !(control.action === "stop" || pauseEscalated) || control.status !== "requested")
         throw new AppError("run_control_invalid_state", "Interrupt requires the current stop intent or its explicitly elapsed pause escalation", 1);
@@ -293,6 +297,29 @@ async function reconcileOwnedSessions(context, input, interrupt, boundary) {
     const nativeVersions = new Map();
     for (const [directory, { state, records }] of daemonInventories) {
         let failedStart = null;
+        // Snapshot execution safety is not a claim of clean native shutdown.
+        // A technical pause can seal after its real writer is gone even when the
+        // third-party session/card never acknowledged completion.
+        const physicalContext = { ...context, env: { ...context.env, DD_FLOW_RESOURCE_HOME: registeredProcesses.find(item => records.includes(item.record))?.home ?? resourceHome(context) } };
+        let executionAbsent = false;
+        if ((boundary || technicalPause) && !interrupt && !conflicts.has(directory) && !unsafeDaemons.has(canonicalPath(directory, false))) {
+            try {
+                executionAbsent = managedDaemonExecutionAbsent(physicalContext, { stateDir: directory, projectId: project.id, runId: input.runId });
+            }
+            catch { /* Unknown physical ownership remains on strict reconciliation. */ }
+        }
+        if (executionAbsent) {
+            const leader = records.find(record => record.kind.endsWith("-daemon") && record.id === state.resource_process?.id && record.pid === state.pid && record.lease_token === state.resource_process.lease_token);
+            if (leader && (state.daemon_id ?? state.config?.daemonId)) {
+                nativeVersions.set(directory, nativeInventoryVersion(directory));
+                closedDaemons.set(directory, { source: "owned_execution_absent", daemon_id: state.daemon_id ?? state.config?.daemonId,
+                    session_ids: state.sessions.map(item => typeof item === "string" ? item : adapterSessionId(item)), execution_settled: true,
+                    native_cleanup_confirmed: state.shutdown_state === "clean", processes: records.map(record => managedProcessBinding(record, registeredProcesses.find(item => item.record === record).home)) });
+                if (state.shutdown_state !== "clean")
+                    recordTechnicalNote(context, project.id, input.runId, { code: "native_cleanup_pending_after_execution_exit", message: "Owned execution is physically absent; native cleanup acknowledgement remains unavailable.", phase: "capture_observation", generation: recoveryGuard(context, project.id, input.runId)?.generation ?? 0, resource_identity: directory, diagnostic_reference: directory, consequence: "cleanup_pending" });
+                continue;
+            }
+        }
         // Explicit stop can reconcile a retired owner whose last bookkeeping ACK
         // failed. This is physical retirement, not a fabricated clean shutdown.
         if (control?.action === "stop" && state.shutdown_state === "cleanup_failed")
@@ -450,6 +477,11 @@ async function reconcileOwnedSessions(context, input, interrupt, boundary) {
             if (!Array.isArray(args) || args.some(value => typeof value !== "string") || !saved.state_dir || !saved.executable || saved.owner !== operation.controller_id || conflicts.has(saved.state_dir) || directoryAdapters.get(saved.state_dir) !== saved.executable)
                 throw new AppError("controller_operation_binding_unknown", "Unfinished controller operation has no matching frozen runtime binding", 1);
             const method = `${args[0]}.${args[1] === "status" ? "inspect" : args[1]}`;
+            if ((boundary || technicalPause) && closedDaemons.get(saved.state_dir)?.source === "owned_execution_absent"
+                && (["daemon.stop", "session.cancel", "session.inspect"].includes(method)
+                    || saved.obligation && controllerObligationAccepted(context, requireController(context, operation.controller_id), saved.obligation))) {
+                return { operation_id: operation.operation_id, status: "completed", receipt: { source: "accepted_boundary_execution_absent", native_outcome: "unavailable", cleanup_pending: true } };
+            }
             if (!["session.create", "session.prompt", "session.start", "session.fork", "session.cancel", "session.resume", "session.inspect", "daemon.start", "daemon.stop"].includes(method))
                 throw new AppError("controller_operation_receipt_required", "Unfinished controller operation needs its original receipt", 1);
             const target = args.includes("--session-id") ? args[args.indexOf("--session-id") + 1] : null;
@@ -1032,7 +1064,7 @@ export function runControlDirective(context, projectId, runId) {
     return { control_id: current.control_id, action: current.action, status: current.status, stop_turn: true, instruction: "The operator has fenced this RUN. Preserve the recorded result and end this Turn now. Do not start another Work, check, Stage or provider operation, and do not wait for resume in a sleep loop. Only the runtime may authorize continuation.", acknowledged: false, settled: false };
 }
 /** The durable fence is committed before observation, steering or interruption. */
-export function recordRunControlIntent(context, input) {
+export function recordRunControlIntent(context, input, onRecorded) {
     if (!/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(input.requestId) || !["pause", "stop"].includes(input.action)
         || input.graceMs !== undefined && (!Number.isSafeInteger(input.graceMs) || input.graceMs < 0 || input.graceMs > 3_600_000)
         || input.force !== undefined && typeof input.force !== "boolean"
@@ -1045,11 +1077,14 @@ export function recordRunControlIntent(context, input) {
     const requestHash = crypto.createHash("sha256").update(JSON.stringify(request)).digest("hex");
     ensureRunControlStorage(context.db);
     return context.db.writeTransaction(() => {
+        // Internal SQL-only metadata can be published atomically with the intent,
+        // before any detached control worker observes it. A throw rolls back both.
+        const publish = (receipt) => { onRecorded?.(receipt); return receipt; };
         const existing = context.db.get("SELECT * FROM run_controls WHERE project_id = ? AND run_id = ? AND request_id = ?", [project.id, input.runId, input.requestId]);
         if (existing) {
             if (existing.request_hash !== requestHash)
                 throw new AppError("runtime_request_conflict", "Control request id has different inputs", 1);
-            return { ok: true, control_id: existing.control_id, recovery_id: existing.recovery_id, action: existing.action, status: existing.status, reused: true };
+            return publish({ ok: true, control_id: existing.control_id, recovery_id: existing.recovery_id, action: existing.action, status: existing.status, reused: true });
         }
         const run = context.db.get("SELECT status FROM runs WHERE project_id = ? AND id = ?", [project.id, input.runId]);
         if (!run)
@@ -1087,6 +1122,6 @@ export function recordRunControlIntent(context, input) {
       WHERE r.project_id = ? AND r.id = ? AND json_extract(stage.value, '$.status') = 'running'
         AND EXISTS (SELECT 1 FROM run_control_admissions a JOIN sessions s ON s.session_id = a.session_id AND s.project_id = r.project_id WHERE a.control_id = ? AND s.current_stage = json_extract(stage.value, '$.stage'))`, [controlId, controlId, project.id, input.runId, controlId]);
         setFlowRunRecoveryPaused(context, project.id, input.runId, true);
-        return { ok: true, control_id: controlId, recovery_id: recoveryId, generation, action: input.action, status: "requested", settled: false };
+        return publish({ ok: true, control_id: controlId, recovery_id: recoveryId, generation, action: input.action, status: "requested", settled: false });
     });
 }

package/dist/services/run-controller-adapter.js

@@ -13,6 +13,8 @@ import { retainedDaemonReply } from "../harness-runtime/lib/daemon-observation.m
 import { readOperationRecord } from "../harness-runtime/lib/operation-progress.mjs";
 import { readNativeDaemonState } from "./managed-daemon-binding.js";
 import { validateCheckEnvironment } from "./check-environment.js";
+import { controllerObligationAccepted, lateNativeFailure } from "./controller-result-authority.js";
+import { recordTechnicalNote } from "./technical-notes.js";
 /** A paused RUN admits only its controller's exact accepted answer Turn. */
 export function controllerHitlAdmission(context, record, input) {
     if (input.operation !== "session.prompt" || !input.operationId || !input.promptSha256)
@@ -286,11 +288,16 @@ async function awaitSettlement(context, row, manifest, session, executable, args
     }
     return adapterSessionId(current) ? { ...initial, ...current, ...(initial.assistant_text !== undefined ? { assistant_text: initial.assistant_text } : {}) } : { ...initial, settlement: settlement(current) };
 }
-export async function controllerAdapter(context, row, manifest, session, args, assertOwner, retainedOperationId, signal, reconfirmOwner) {
+export async function controllerAdapter(context, row, manifest, session, args, assertOwner, retainedOperationId, signal, reconfirmOwner, obligation) {
     const executable = manifest.adapters[runtimeHarness(session.profile)].executable;
     const promptFile = args.indexOf("--prompt-file"), inlinePrompt = args.indexOf("--prompt");
     const promptSha256 = promptFile >= 0 ? digestBytes(fs.readFileSync(args[promptFile + 1])) : inlinePrompt >= 0 ? digestBytes(args[inlinePrompt + 1] ?? "") : undefined;
-    const input = { executable, args, owner: session.owner.owner_id, state_dir: session.state_dir, ...(args[0] === "session" && args[1] === "prompt" && promptSha256 ? { prompt_sha256: promptSha256 } : {}) };
+    const priorInput = retainedOperationId ? context.db.get("SELECT input_json FROM run_controller_operations WHERE operation_id=? AND controller_id=? AND generation=?", [retainedOperationId, row.controller_id, row.generation]) : undefined;
+    const effectiveObligation = priorInput ? JSON.parse(priorInput.input_json).obligation : obligation;
+    // Committing an answer resumes a Stage; it does not finish the semantic
+    // work owed by that prompt. Preserve its provider error for same-Session recovery.
+    const acceptedPromptBoundary = (expected) => controllerObligationAccepted(context, row, expected.action === "resume" ? { ...expected, action: "finish" } : expected);
+    const input = { executable, args, owner: session.owner.owner_id, state_dir: session.state_dir, ...(args[0] === "session" && args[1] === "prompt" && promptSha256 ? { prompt_sha256: promptSha256 } : {}), ...(effectiveObligation ? { obligation: effectiveObligation } : {}) };
     const prepared = retainedOperationId ? [] : context.db.all("SELECT operation_id FROM run_controller_operations WHERE controller_id = ? AND generation = ? AND input_hash = ? AND status = 'dispatching' AND json_extract(input_json, '$.dispatch_phase') = 'prepared'", [row.controller_id, row.generation, digest(input)]);
     if (prepared.length > 1)
         throw new AppError("controller_operation_conflict", "Multiple prepared intents require explicit reconciliation", 1);
@@ -369,6 +376,14 @@ export async function controllerAdapter(context, row, manifest, session, args, a
             recoveredOperation = true;
         }
         validateReceipt(receipt, session, args);
+        const hookDiagnostics = Array.isArray(receipt.native_hook_diagnostics) ? receipt.native_hook_diagnostics : [];
+        if (hookDiagnostics.some(item => item && typeof item === "object" && ["native_hook_timeout", "native_hook_failed"].includes(String(item.code)))) {
+            recordTechnicalNote(context, row.project_id, row.run_id, { code: "native_hook_observation_unavailable",
+                message: "Native hook observation failed; the actual lifecycle command remains authoritative.", phase: "native_observation",
+                generation: row.generation, ...(effectiveObligation?.stage ? { stage: effectiveObligation.stage } : {}),
+                harness: runtimeHarness(session.profile), source_operation_id: operationId, resource_identity: session.state_dir,
+                diagnostic_reference: session.journal, consequence: "none" });
+        }
         retainPhase("receipt_observed");
         const persistReceipt = () => {
             const changed = context.db.run("UPDATE run_controller_operations SET receipt_json = ?, updated_at = ? WHERE operation_id = ? AND controller_id = ? AND generation = ? AND EXISTS (SELECT 1 FROM run_controllers WHERE controller_id = ? AND owner_token = ? AND generation = ?)", [JSON.stringify(receipt), context.now(), operationId, row.controller_id, row.generation, row.controller_id, row.owner_token, row.generation]);
@@ -376,7 +391,13 @@ export async function controllerAdapter(context, row, manifest, session, args, a
                 throw new AppError("controller_owner_mismatch", "Controller lost ownership before receipt retention", 1);
         };
         persistReceipt();
-        if (["pending", "blocked"].includes(String(settlement(receipt)?.state))) {
+        if (["pending", "blocked"].includes(String(settlement(receipt)?.state)) && effectiveObligation && acceptedPromptBoundary(effectiveObligation)) {
+            // Required semantic work is already committed. Keep the honest pending
+            // native proof for resource cleanup without holding its accepted result.
+            recordTechnicalNote(context, row.project_id, row.run_id, { code: "accepted_boundary_native_settlement_pending", message: "The assigned result is committed; native settlement remains pending.", phase: "native_observation", generation: row.generation, stage: effectiveObligation.stage, harness: runtimeHarness(session.profile), source_operation_id: operationId, diagnostic_reference: session.state_dir, consequence: "cleanup_pending" });
+            receipt = { ...receipt, accepted_boundary: effectiveObligation };
+        }
+        else if (["pending", "blocked"].includes(String(settlement(receipt)?.state))) {
             const recovered = await awaitSettlement(context, row, manifest, session, executable, args, operationId, receipt, assertOwner, signal);
             receipt = recovered;
         }
@@ -389,6 +410,19 @@ export async function controllerAdapter(context, row, manifest, session, args, a
         return receipt;
     }
     catch (error) {
+        // A lost provider/transport acknowledgement cannot revoke the exact
+        // boundary already accepted by the engine. Identity/integrity failures
+        // and unfinished siblings remain on the existing recovery path.
+        const expected = effectiveObligation;
+        if (expected && lateNativeFailure(error, session.id) && acceptedPromptBoundary(expected)) {
+            assertOwner?.();
+            const receipt = { adapter_session_id: session.id, accepted_boundary: expected, native_observation_unavailable: true, settlement: { state: "pending", reason: "native_observation_unavailable" } };
+            const completed = context.db.run("UPDATE run_controller_operations SET status='completed',receipt_json=?,error_json=NULL,updated_at=? WHERE operation_id=? AND controller_id=? AND generation=? AND EXISTS (SELECT 1 FROM run_controllers WHERE controller_id=? AND owner_token=? AND generation=?)", [JSON.stringify(receipt), context.now(), operationId, row.controller_id, row.generation, row.controller_id, row.owner_token, row.generation]);
+            if (completed.changes !== 1)
+                throw new AppError("controller_owner_mismatch", "Controller lost ownership before accepting the committed boundary", 1);
+            recordTechnicalNote(context, row.project_id, row.run_id, { code: "accepted_boundary_native_observation_unavailable", message: "The assigned result is committed; the native acknowledgement is unavailable.", phase: "native_observation", generation: row.generation, stage: expected.stage, harness: runtimeHarness(session.profile), source_operation_id: operationId, diagnostic_reference: session.state_dir, consequence: "cleanup_pending" });
+            return receipt;
+        }
         try {
             context.db.run("UPDATE run_controller_operations SET status = CASE WHEN status = 'dispatching' AND ? <> 'prepared' THEN 'outcome_unknown' ELSE status END, error_json = ?, updated_at = ? WHERE operation_id = ? AND controller_id = ? AND generation = ? AND EXISTS (SELECT 1 FROM run_controllers WHERE controller_id = ? AND owner_token = ? AND generation = ?)", [phase ?? "legacy_unknown", JSON.stringify(errorRecord(error)), context.now(), operationId, row.controller_id, row.generation, row.controller_id, row.owner_token, row.generation]);
         }

package/dist/services/run-controller-process.js

@@ -7,6 +7,7 @@ import { validateCheckEnvironment } from "./check-environment.js";
 import { getResourceDatabase } from "../storage/database.js";
 import { finishManagedProcess, managedProcessRuntimeHome, managedProcessStatus, processIsAlive, processStartedAt, processTreeIsAlive, registerManagedProcess } from "./managed-processes.js";
 import { setFlowRunRecoveryPaused } from "./runs.js";
+import { physicalStartup } from "./physical-startup.js";
 import { assertRunMutationAllowed, assertRunRecoveryAllowed, recoveryGuard } from "./run-recovery.js";
 import { requireRun, requireController, controllerReceipt, appendEvent, digest, errorRecord } from "./run-controller-state.js";
 const launchId = (row) => `${row.controller_id}:owner-launch:${digest(row.owner_token)}`;
@@ -15,6 +16,8 @@ const birth = () => ({ pid: process.pid, pid_started_at: processStartedAt(proces
 const dead = (value) => Boolean(value && Number.isSafeInteger(value.pid) && value.pid > 0 && typeof value.pid_started_at === "string" && value.pid_started_at && !processIsAlive(value));
 /** Called inside the RUN intent transaction, before the client can disappear. */
 export function recordControllerLauncher(context, row, retired, identity = birth()) {
+    if (!identity.pid_started_at)
+        throw new AppError("process_ownership_unknown", "Controller launcher requires an observed physical identity", 1, { phase: "process_confirmation", effect: "no_effect", native_dispatch_started: false, reason: "physical_identity_unavailable" });
     const request = { action: "controller_owner_launch", owner_id: launchId(row) };
     const receipt = { ...identity, registration: "controller_self@1", ...(retired ? { retired_process: { id: retired.id, lease_token: retired.lease_token, pid: retired.pid, pid_started_at: retired.pid_started_at } } : {}) };
     const now = context.now();
@@ -72,12 +75,18 @@ function retire(context, row, identity) {
         throw new AppError("controller_owner_unsettled", "Prior controller identity is not proven dead and retired", 1);
 }
 /** Retry only before productive admission, with exact prior birth and journal CAS. */
-function prepareSpawn(context, row) {
+async function prepareSpawn(context, row) {
     const launch = launchRecord(context, row);
     if (!launch || launch.value.dispatch_ready || !["starting", "running", "recovery_required"].includes(row.status))
         return null;
+    const launcher = await physicalStartup(context.databaseDeadlineAt).birth(() => {
+        const current = requireController(context, row.controller_id);
+        if (current.owner_token !== row.owner_token || current.generation !== row.generation)
+            throw new AppError("controller_owner_mismatch", "Controller launch owner changed during physical observation", 1);
+        assertLaunchAllowed(context, current);
+    });
     const resourceContext = { ...context, env: { ...context.env, DD_FLOW_RESOURCE_HOME: JSON.parse(row.manifest_json).resource_home } };
-    const ours = launch.value.pid === process.pid && launch.value.pid_started_at === processStartedAt(process.pid);
+    const ours = launch.value.pid === launcher.pid && launch.value.pid_started_at === launcher.pid_started_at;
     let token = row.owner_token;
     if (!ours) {
         if (row.owner_pid) {
@@ -115,7 +124,6 @@ function prepareSpawn(context, row) {
         return null;
     if (launch.value.retired_process)
         retire(resourceContext, row, launch.value.retired_process);
-    const launcher = birth();
     return context.db.writeTransaction(() => {
         assertLaunchAllowed(context, row);
         const changed = context.db.run(`UPDATE run_controllers SET owner_token = ?, owner_pid = NULL, process_id = NULL, process_lease_token = NULL, status = 'starting', last_error_json = NULL, updated_at = ?
@@ -165,7 +173,7 @@ export function markControllerDispatchReady(context, row) {
     context.db.run("UPDATE run_controller_operations SET receipt_json = json_set(receipt_json, '$.dispatch_ready', json('true')), updated_at = ? WHERE operation_id = ?", [context.now(), launchId(row)]);
 }
 export async function spawnController(context, row) {
-    const admitted = prepareSpawn(context, row);
+    const admitted = await prepareSpawn(context, row);
     if (!admitted)
         return controllerReceipt(requireController(context, row.controller_id));
     row = admitted;

package/dist/services/run-controller-recovery.js

@@ -18,16 +18,19 @@ import { controllerAdapter, controllerEnvironment, sessionArguments } from "./ru
 import { runHarnessAdapter } from "./harness-adapter.js";
 import { continueProviderCapacity } from "./provider-capacity.js";
 import { spawnController, recordControllerLauncher } from "./run-controller-process.js";
-import { readNativeDaemonState, requireManagedDaemonBinding } from "./managed-daemon-binding.js";
+import { readNativeDaemonState, requireManagedDaemonBinding, managedDaemonExecutionAbsent } from "./managed-daemon-binding.js";
 import { managedInvocationContext } from "./lifecycle-invocations.js";
 import { runControlStatus } from "./run-control.js";
 import { runtimeBudgetStatus, waitForRuntimeScopeRecovery } from "./runtime-budget.js";
 import { prepareControllerPublication } from "./run-controller-capture.js";
+import { technicalDependencyControl } from "./controller-result-authority.js";
+import { recordTechnicalNote } from "./technical-notes.js";
+import { setFlowRunRecoveryPaused } from "./runs.js";
 /** CLI observation is bounded; the physical controller owns the recovery work. */
-export async function resumeRunController(context, input) {
+export async function resumeRunController(context, input, validate) {
     if (input.waitMs !== undefined && (!Number.isSafeInteger(input.waitMs) || input.waitMs < 0 || input.waitMs > 60_000))
         throw new AppError("usage", "--wait-ms must be between 0 and 60000", 2);
-    const intent = recordControllerResume(context, input);
+    const intent = prepareControllerResume(context, input, validate)();
     const manifest = JSON.parse(intent.controller.manifest_json);
     const resourceContext = { ...context, env: { ...context.env, DD_FLOW_RESOURCE_HOME: manifest.resource_home } };
     await spawnController(resourceContext, intent.controller);
@@ -44,7 +47,7 @@ export function recordControllerResume(context, input) {
 }
 /** Verify immutable recovery evidence before a caller reserves the registry
  * writer. The returned operation rechecks SQL ownership under the RUN CAS. */
-export function prepareControllerResume(context, input) {
+export function prepareControllerResume(context, input, validate) {
     if (!/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(input.requestId) || !input.controlId.trim())
         throw new AppError("usage", "Resume requires request-id and the exact source control", 2);
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
@@ -97,6 +100,8 @@ export function prepareControllerResume(context, input) {
                     throw new AppError("runtime_request_conflict", "Resume request id has different inputs", 1);
                 return { controller: requireController(context, row.controller_id), operationId };
             }
+            if (validate && !validate())
+                throw new AppError("run_control_superseded", "Technical recovery evidence changed before resume admission", 1);
             const current = recoveryGuard(context, project.id, run.id);
             if (current?.recovery_id !== guard.recovery_id || current.generation !== guard.generation || current.status !== "sealed" || current.capture_path !== guard.capture_path)
                 throw new AppError("run_control_superseded", "Control changed before resume could be accepted", 1);
@@ -146,6 +151,39 @@ export async function resumeControllerSession(context, row, manifest, state, ass
     assertRecoveryOwner();
     const readDaemon = () => readNativeDaemonState(session.state_dir);
     const { state: retired, process: record } = requireManagedDaemonBinding(executionContext, { stateDir: session.state_dir, projectId: row.project_id, runId: row.run_id, ownerId: session.owner.owner_id });
+    const run = requireRun(context, row.project_id, row.run_id);
+    const boundary = JSON.parse(run.index_json).stage_runs.find(stage => stage.stage === state.stage && ["done", "skipped"].includes(stage.status));
+    if (boundary && technicalDependencyControl(context, row.project_id, row.run_id, recovery.control_id) && !scopeControl) {
+        if (!managedDaemonExecutionAbsent(executionContext, { stateDir: session.state_dir, projectId: row.project_id, runId: row.run_id, ownerId: session.owner.owner_id }))
+            throw new AppError("recovery_native_shutdown_unproven", "Technical boundary recovery still has an unknown or live owned writer", 1);
+        const assertPublication = prepareControllerPublication(executionContext, row, assertPhysicalOwner);
+        context.db.writeTransaction(() => {
+            assertPublication();
+            assertRecoveryOwner(false);
+            if (requireRun(context, row.project_id, row.run_id).index_json !== run.index_json)
+                throw new AppError("controller_boundary_changed", "Accepted boundary changed before technical continuation", 1);
+            const now = context.now();
+            if (context.db.run("UPDATE run_recovery_guards SET status='recovered',resumed_at=?,updated_at=? WHERE recovery_id=? AND generation=? AND status='sealed'", [now, now, recovery.recovery_id, row.generation]).changes !== 1)
+                throw new AppError("run_recovery_generation_stale", "Technical boundary no longer owns its sealed recovery", 1);
+            if (context.db.run("UPDATE run_controls SET status='resumed',updated_at=? WHERE control_id=? AND status='resuming'", [now, recovery.control_id]).changes !== 1)
+                throw new AppError("run_control_superseded", "Technical recovery control changed before continuation", 1);
+            const receipt = { schema_id: "dd-flow/technical-boundary-resume@1", resumed: true, recovery_id: recovery.recovery_id, stage: boundary.stage, attempt: boundary.attempt, native_cleanup_confirmed: retired.shutdown_state === "clean", native_model_call: false };
+            if (context.db.run("UPDATE run_controller_operations SET status='completed',receipt_json=?,updated_at=? WHERE operation_id=? AND controller_id=? AND generation=? AND status='accepted'", [JSON.stringify(receipt), now, recovery.operation_id, row.controller_id, row.generation]).changes !== 1)
+                throw new AppError("run_control_superseded", "Technical recovery operation changed before continuation", 1);
+            session.retired = true;
+            session.cleanup_pending = retired.shutdown_state !== "clean";
+            state.current_session = null;
+            state.last_continuation = null;
+            delete state.last_receipt;
+            delete state.recovery;
+            setFlowRunRecoveryPaused(context, row.project_id, row.run_id, false);
+            saveState(context, row, state);
+            appendEvent(context, row.controller_id, "technical_boundary_resumed", { ...receipt, control_id: recovery.control_id, state_dir: session.state_dir });
+        });
+        if (retired.shutdown_state !== "clean")
+            recordTechnicalNote(context, row.project_id, row.run_id, { code: "native_cleanup_pending_after_execution_exit", message: "The accepted Stage continues in a fresh Session; old native cleanup remains unconfirmed.", phase: "recovery", generation: row.generation, resource_identity: session.state_dir, diagnostic_reference: session.state_dir, consequence: "cleanup_pending" });
+        return;
+    }
     const call = (args, operationId) => controllerAdapter(executionContext, row, manifest, session, args, assertRecoveryOwner, operationId);
     if (processTreeIsAlive(record)) {
         const stopped = await call(["daemon", "stop", "--state-dir", session.state_dir, "--json"]);
@@ -157,8 +195,10 @@ export async function resumeControllerSession(context, row, manifest, state, ass
             assertRecoveryOwner();
         }
     }
-    if (processTreeIsAlive(record) || readDaemon().shutdown_state !== "clean")
-        throw new AppError("recovery_native_shutdown_unproven", "The previous native daemon is not proven clean and closed", 1);
+    if (processTreeIsAlive(record))
+        throw new AppError("recovery_native_shutdown_unproven", "The previous native daemon still owns execution", 1);
+    if (readDaemon().shutdown_state !== "clean")
+        throw new AppError("recovery_native_shutdown_unproven", "An unfinished coordinator requires its retained native Session to be cleanly resumable", 1);
     assertRecoveryOwner();
     session.stopped = false;
     saveState(context, row, state);

package/dist/services/run-controller-state.js

@@ -2,6 +2,7 @@ import crypto from "node:crypto";
 import { AppError, errorRecord as structuredErrorRecord } from "../shared/errors.js";
 import { runtimeHarness } from "./execution-policy.js";
 import { managedProcessRuntimeHome, managedProcessStatus, processTreeIsAlive } from "./managed-processes.js";
+import { readTechnicalNotes } from "./technical-notes.js";
 export function requireRun(context, projectId, runId) {
     const run = context.db.get("SELECT id, project_id, flow_kind, project_root, workspace_root, run_root, status, index_json FROM runs WHERE project_id = ? AND id = ?", [projectId, runId]);
     if (!run?.run_root)
@@ -14,10 +15,10 @@ export function requireController(context, id) {
         throw new AppError("not_found", "Managed controller was not found", 1, { controller_id: id });
     return row;
 }
-export function controllerReceipt(row) {
+export function controllerReceipt(row, context) {
     const state = JSON.parse(row.state_json);
     const manifest = JSON.parse(row.manifest_json);
-    return { ok: true, schema_id: "dd-flow/run-controller-receipt@1", controller: { controller_id: row.controller_id, request_id: row.request_id, project_id: row.project_id, run_id: row.run_id, generation: row.generation, runtime_budget: manifest.budget ?? null, status: row.status, process_id: row.process_id, owner_pid: row.owner_pid, state_dir: row.state_dir, stage: state.stage, sessions: state.sessions.map(session => ({ session_id: session.id, harness: runtimeHarness(session.profile), profile_id: session.profile.id, state_dir: session.state_dir, journal: session.journal, stopped: session.stopped === true })), error: row.last_error_json ? JSON.parse(row.last_error_json) : null } };
+    return { ok: true, schema_id: "dd-flow/run-controller-receipt@1", ...(context ? { technical_notes: readTechnicalNotes(context, row.project_id, row.run_id) } : {}), controller: { controller_id: row.controller_id, request_id: row.request_id, project_id: row.project_id, run_id: row.run_id, generation: row.generation, runtime_budget: manifest.budget ?? null, status: row.status, process_id: row.process_id, owner_pid: row.owner_pid, state_dir: row.state_dir, stage: state.stage, sessions: state.sessions.map(session => ({ session_id: session.id, harness: runtimeHarness(session.profile), profile_id: session.profile.id, state_dir: session.state_dir, journal: session.journal, stopped: session.stopped === true, ...(session.cleanup_pending ? { cleanup_pending: true } : {}) })), error: row.last_error_json ? JSON.parse(row.last_error_json) : null } };
 }
 /** Read-only causal diagnostics, not a settlement or capture authorization. */
 export function terminalControllerFinalization(context, project, runId, runStatus) {