@deksden-com/dd-flow-cli 0.9.0-beta.104 → 0.9.0-beta.106

package/dist/services/lifecycle-invocations.js

@@ -6,7 +6,7 @@ import { setTimeout as delay } from "node:timers/promises";
 import { AppError, errorRecord } from "../shared/errors.js";
 import { shortEntityReference } from "../shared/entity-references.js";
 import { resolveWorkReference } from "../storage/work-references.js";
-import { commandOption, continuationCommand, lifecycleCommandFromPayload, parseLifecycleCommand, shellSuffixOffset } from "./lifecycle-command.js";
+import { commandOption, commandPosition, continuationCommand, lifecycleCommandFromPayload, parseLifecycleCommand, shellSuffixOffset } from "./lifecycle-command.js";
 import { requireProjectByRoot } from "./projects.js";
 import { assertRunMutationAllowed, assertStageSettlementAllowed, assertWorkSettlementAllowed, recoveryGuard } from "./run-recovery.js";
 import { readNativeDaemonState, requireManagedDaemonBinding } from "./managed-daemon-binding.js";
@@ -20,6 +20,7 @@ import { isRegisteredRepair } from "./repair-intents.js";
 import { stageAttempt } from "./stage-work-graph.js";
 import { contextualPathOptionsForLifecycle } from "../cli/command-inputs.js";
 import { canonicalPath } from "../storage/paths.js";
+import { runtimeCommand } from "./runtime-command.js";
 /** Auxiliary commands have no invocation capability, but may not escape their
  * native daemon's project/RUN. Context aliases never grant mutation authority. */
 export function assertAuxiliaryCommandScope(context, command, projectRoot) {
@@ -98,11 +99,15 @@ function invocation(command) {
     }
     return parsed.invocation;
 }
+function launchExpression(parsed) {
+    const executable = parsed.executable === "$DD_FLOW_BIN" ? '"$DD_FLOW_BIN"' : quote([parsed.executable]);
+    return parsed.launcher ? `${quote([parsed.launcher])} ${executable}` : executable;
+}
 // Input data may be supplied later (stdin/file contents); authority is bound to
 // the exact operation and literal argv. Existing lifecycle validation owns data.
 function fingerprint(parsed) {
     const projected = publicInvocationArgs(parsed);
-    const publicParsed = invocation(`${quote([parsed.executable])} ${quoteModelFacingArgs(projected)}`);
+    const publicParsed = invocation(`${launchExpression(parsed)} ${quoteModelFacingArgs(projected)}`);
     const options = [...publicParsed.args.options].filter(([key]) => !["invocation-id", "hook-event-id", "json", "progress-jsonl"].includes(key))
         .map(([key, values]) => [key, key === "reason" ? ["<semantic-reason>"] : values.map(value => normalizedInvocationValue(key, value))])
         .sort(([a], [b]) => a.localeCompare(b));
@@ -194,7 +199,7 @@ function withoutInvocationId(command, aliases) {
             argv[index] = normalizedInvocationValue("positional", argv[index]);
     }
     const env = Object.fromEntries(Object.entries(parsed.env).filter(([key]) => !["DD_FLOW_INVOCATION_SCOPE", "DD_FLOW_HOME", "DD_FLOW_BIN"].includes(key)));
-    const executable = parsed.env.DD_FLOW_BIN || parsed.executable === "$DD_FLOW_BIN" ? '"$DD_FLOW_BIN"' : quote([parsed.executable]);
+    const executable = launchExpression(parsed);
     const prefix = Object.entries(env).map(([key, value]) => `${key}=${quote([value])}`).join(" ");
     const suffix = command.slice(shellSuffixOffset(command)).trimStart();
     return `${prefix ? `${prefix} ` : ""}${executable}${argv.length ? ` ${quoteModelFacingArgs(argv)}` : ""}${suffix ? ` ${suffix}` : ""}`.trim();
@@ -205,8 +210,35 @@ function publicInvocationCommand(context, row, command) {
     const rendered = renderInvocationCommand(row, command);
     const scope = JSON.parse(row.scope_json);
     const run = scope.runId ? context.db.get("SELECT workspace_root, run_root FROM runs WHERE id = ?", [scope.runId]) : undefined;
+    context.captureLifecycleAssignment?.(row.id);
     return withoutInvocationId(rendered, { project: scope.projectRoot, ...(run?.workspace_root ? { workspace: run.workspace_root } : {}), ...(run?.run_root ? { run: run.run_root } : {}) });
 }
+/** Bind issued commands to the exact bytes sent to the model, not to an
+ * internal marker which is intentionally absent from that prompt. */
+export function bindLifecyclePacketAssignments(context, prompt, ids) {
+    const unique = [...new Set(ids)];
+    if (!unique.length)
+        return;
+    const digest = crypto.createHash("sha256").update(prompt).digest("hex");
+    context.db.writeTransaction(() => {
+        for (const id of unique) {
+            const row = load(context, id);
+            if (row.status !== "issued")
+                throw new AppError("invocation_packet_conflict", "Packet contains a lifecycle assignment already in flight", 1, { invocation_id: id });
+            context.db.run("INSERT OR IGNORE INTO lifecycle_packet_assignments (packet_sha256, invocation_id) VALUES (?, ?)", [digest, id]);
+        }
+    });
+}
+/** Stage renderers issue their commands before the final packet is assembled.
+ * Bind only issued commands visibly present in that exact published packet. */
+export function bindLifecyclePublishedPacket(context, prompt) {
+    const scope = context.env.DD_FLOW_INVOCATION_SCOPE;
+    if (!scope)
+        return;
+    const issued = context.db.all("SELECT * FROM lifecycle_invocations WHERE scope_json = ? AND status = 'issued' ORDER BY rowid", [scope]);
+    const ids = issued.filter(row => prompt.includes(publicInvocationCommand(context, row, retainedCommandWithoutInvocationId(row)))).map(row => row.id);
+    bindLifecyclePacketAssignments(context, prompt, ids);
+}
 function retainedCommandWithoutInvocationId(row) {
     const marker = ` --invocation-id ${row.id}`;
     const at = row.command.indexOf(marker);
@@ -248,7 +280,7 @@ function canonicalManagedCommand(context, command, scope) {
     const argv = expandLifecycleInvocationArgs(context, parsed.argv, scope, parsed.operation);
     const env = { ...parsed.env, DD_FLOW_INVOCATION_SCOPE: JSON.stringify(scope) };
     const prefix = Object.entries(env).map(([key, value]) => `${key}=${quote([value])}`).join(" ");
-    const executable = parsed.executable === "$DD_FLOW_BIN" ? '"$DD_FLOW_BIN"' : quote([parsed.executable]);
+    const executable = launchExpression(parsed);
     const suffix = command.slice(shellSuffixOffset(command)).trimStart();
     return `${prefix} ${executable}${argv.length ? ` ${quote(argv)}` : ""}${suffix ? ` ${suffix}` : ""}`.trim();
 }
@@ -391,9 +423,29 @@ export function observeLifecycleCommand(context, command, nativeEvent) {
             return;
         const error = outcome.error ? errorRecord(outcome.error) : undefined;
         const correctable = error && isCorrectableLifecycleRejection(error.code, error.details);
-        const record = { ...anchor, ...(error ? { error } : outcome), effect: error ? error.details.effect ?? (correctable ? "no_effect" : "unknown") : "committed", disposition: error ? auxiliary ? "pending_continuation" : correctable ? "correctable" : "fatal" : "completed" };
+        const correlationKey = parsed.kind === "standalone" ? fingerprint(parsed.invocation)
+            : JSON.stringify([auxiliary.operation, auxiliary.operation === "stage_block" ? auxiliary.args.positional[2] ?? null : auxiliary.args.options.get("run")?.[0] ?? null, auxiliary.args.options.get("stage")?.[0] ?? null]);
+        const record = { ...anchor, correlation_key: correlationKey, ...(parsed.kind === "standalone" ? { fingerprint: correlationKey } : {}), ...(error ? { error } : outcome), effect: error ? error.details.effect ?? (correctable ? "no_effect" : "unknown") : "committed", disposition: error ? auxiliary ? "pending_continuation" : correctable ? "correctable" : "fatal" : "completed" };
         try {
             context.db.writeTransaction(() => {
+                if (error && parsed.kind === "standalone" && !auxiliary && !invocationId && !context.env.DD_FLOW_INVOCATION_SCOPE
+                    && error.details.effect === "no_effect" && isRetryableLifecycleRejection(error.code, error.details)
+                    && !isRegisteredRepair(context, error.details.continuation, { projectId: anchor.project_id, runId: anchor.run_id })) {
+                    const signature = preparationRejectionSignature(new AppError(error.code, error.message, 1, error.details));
+                    error.details.hook_retry_signature = signature;
+                    const repeated = context.db.get("SELECT 1 FROM hook_events WHERE project_id = ? AND id <> ? AND json_extract(outcome_json, '$.run_id') = ? AND json_extract(outcome_json, '$.generation') = ? AND json_extract(outcome_json, '$.operation') = ? AND json_extract(outcome_json, '$.error.details.hook_retry_signature') = ? LIMIT 1", [anchor.project_id, anchor.hook_event_id, anchor.run_id, anchor.generation, anchor.operation, signature]);
+                    if (!repeated) {
+                        const argv = parsed.invocation.argv.filter((value, index, all) => value !== "--hook-event-id" && all[index - 1] !== "--hook-event-id" && value !== "--invocation-id" && all[index - 1] !== "--invocation-id");
+                        error.details.retry_command = runtimeCommand(context, argv);
+                        error.details.retry_instruction = "Correct the evidenced input, then run retry_command once as a standalone command in this Session. The rejected attempt had no lifecycle effect.";
+                        error.details.recoverable = true;
+                    }
+                    else {
+                        error.details.recoverable = false;
+                        error.details.repeated_without_progress = true;
+                        record.disposition = "fatal";
+                    }
+                }
                 const retained = context.db.get("SELECT outcome_json FROM hook_events WHERE id = ?", [anchor.hook_event_id]);
                 const previous = retained?.outcome_json ? JSON.parse(retained.outcome_json) : null;
                 if (previous?.storage_retry === 1)
@@ -457,7 +509,7 @@ export function lifecycleRetryCommands(context, stage) {
 }
 export function managedInvocationContext(context, input) {
     const env = { ...context.env, DD_FLOW_CURRENT_INVOCATION: undefined, DD_FLOW_INVOCATION_SCOPE: undefined };
-    if (input.harness !== "zcode-acp" && input.harness !== "codex-desktop")
+    if (!["zcode-acp", "codex-desktop", "grok-acp", "antigravity-cli"].includes(input.harness))
         return { ...context, env };
     const project = requireProjectByRoot(context, input.projectRoot);
     const { state, process: daemon } = requireManagedDaemonBinding(context, { stateDir: input.stateDir, projectId: project.id, runId: input.runId });
@@ -467,7 +519,7 @@ export function managedInvocationContext(context, input) {
     // Codex owns a single root Session per controller and persists that root as
     // a string. Child agent_id values arrive later through the native hook and
     // are checked against this root scope; they are not controller Sessions.
-    const rootSessionId = input.harness === "codex-desktop"
+    const rootSessionId = input.harness !== "zcode-acp"
         ? (typeof session === "string" ? session : session?.root_provider_session_id ?? session?.provider_session_id ?? null)
         : (typeof session === "string" ? null : session?.root_provider_session_id ?? null);
     if (!state.daemon_id || !rootSessionId)
@@ -569,8 +621,7 @@ const receiptTimeout = (id) => ({ code: "invocation_receipt_timeout", message: "
 export function settleLifecycleRejection(context, id, error) {
     storage(context);
     const details = { ...error.details };
-    context.db.beginWriteTransaction();
-    try {
+    context.db.writeTransaction(() => {
         const prior = load(context, id);
         if (prior.status !== "executing")
             throw new AppError("invocation_settlement_conflict", "Attempt is no longer executing", 1, { invocation_id: id });
@@ -593,18 +644,20 @@ export function settleLifecycleRejection(context, id, error) {
             details.recovery_instruction = "Do not retry this command in the current Session. End the coordinator Turn; the controller will launch the already-registered Work in a fresh child Session.";
         }
         settleLifecycleInvocation(context, id, { error: { ...error, details } });
-        context.db.exec("COMMIT");
-        Object.assign(error.details, details);
-    }
-    catch (error) {
-        context.db.exec("ROLLBACK");
-        throw error;
-    }
+    });
+    Object.assign(error.details, details);
 }
 /** Recovery preserves the original packet as evidence. Only its retained,
  * never-executed commands receive new authority; unknown effects never replay. */
+export function hasLifecyclePacketAssignments(context, originalPrompt) {
+    const digest = crypto.createHash("sha256").update(originalPrompt).digest("hex");
+    return Boolean(context.db.get("SELECT 1 FROM lifecycle_packet_assignments WHERE packet_sha256 = ? LIMIT 1", [digest]));
+}
 export function recoverLifecycleCommands(context, originalPrompt, scope) {
-    const ids = [...new Set([...originalPrompt.matchAll(/--invocation-id ([0-9a-f-]{36})\b/g)].map(match => match[1]))];
+    const digest = crypto.createHash("sha256").update(originalPrompt).digest("hex");
+    const ids = context.db.all("SELECT invocation_id FROM lifecycle_packet_assignments WHERE packet_sha256 = ? ORDER BY rowid", [digest]).map(row => row.invocation_id);
+    if (!ids.length)
+        throw new AppError("invocation_recovery_unbound", "Original packet has no verified lifecycle assignment binding; reconcile it before continuing", 1);
     const recovered = [];
     for (const id of ids) {
         let prior = load(context, id);
@@ -633,7 +686,7 @@ export function recoverLifecycleCommands(context, originalPrompt, scope) {
             throw new AppError("invocation_command_invalid", "Retained command lost its exact invocation marker", 1);
         argv.splice(at, 2);
         const env = { ...parsed.env, DD_FLOW_INVOCATION_SCOPE: JSON.stringify(scope) };
-        const command = `${Object.entries(env).map(([key, value]) => `${key}=${quote([value])}`).join(" ")} ${quote([parsed.executable, ...argv])} ${prior.command.slice(shellSuffixOffset(prior.command))}`.trim();
+        const command = `${Object.entries(env).map(([key, value]) => `${key}=${quote([value])}`).join(" ")} ${launchExpression(parsed)} ${quote(argv)} ${prior.command.slice(shellSuffixOffset(prior.command))}`.trim();
         const prepared = managedLifecycleCommand({ ...context, env: { ...context.env, DD_FLOW_INVOCATION_SCOPE: JSON.stringify(scope), DD_FLOW_CURRENT_INVOCATION: undefined } }, command);
         recovered.push({ invocation_id: id, status: "replaced_unexecuted", command: prepared });
     }
@@ -677,8 +730,10 @@ export function assertLifecycleInvocationCurrent(context, scope, command) {
     if (guard?.status === "draining" && guard.generation === scope.generation + 1) {
         if (workId && ["work_finish", "work_fail"].includes(parsed.operation))
             return assertWorkSettlementAllowed(context, project.id, scope.runId, workId);
-        if (parsed.operation === "stage_finish")
-            return assertStageSettlementAllowed(context, project.id, scope.runId, commandOption(parsed, "stage") ?? "");
+        if (parsed.operation === "stage_finish") {
+            assertStageSettlementAllowed(context, project.id, scope.runId, commandOption(parsed, "stage") ?? "");
+            return;
+        }
     }
     if ((guard?.generation ?? 0) !== scope.generation)
         throw new AppError("invocation_generation_stale", "Lifecycle attempt belongs to another recovery generation", 1);
@@ -753,11 +808,112 @@ function checkNativeIdentity(scope, identity, id) {
         throw new AppError("invocation_identity_mismatch", "Native identity does not belong to the issued managed scope", 1, { invocation_id: id });
     }
 }
+function managedNativeOwner(context, identity, harness, projectId) {
+    const owners = [];
+    const hasTable = (name) => Boolean(context.db.get("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?", [name]));
+    if (hasTable("run_controllers")) {
+        const controllers = context.db.all("SELECT c.run_id, r.status AS run_status, c.status, c.generation, c.state_json FROM run_controllers c JOIN runs r ON r.project_id = c.project_id AND r.id = c.run_id WHERE c.project_id = ?", [projectId]);
+        for (const controller of controllers) {
+            if (!controller.state_json.includes(identity.rootSessionId))
+                continue;
+            const state = JSON.parse(controller.state_json);
+            for (const [index, session] of (state.sessions ?? []).entries()) {
+                if (session.id !== identity.rootSessionId)
+                    continue;
+                owners.push({ runId: controller.run_id, rootSessionId: session.id,
+                    stateDir: session.state_dir, harness: runtimeHarness(session.profile), generation: controller.generation,
+                    active: ["running", "paused", "waiting_for_user", "blocked"].includes(controller.run_status)
+                        && !["completed", "cancelled", "superseded"].includes(controller.status)
+                        && state.current_session === index && session.stopped !== true });
+            }
+        }
+    }
+    if (hasTable("work_launches")) {
+        const launches = context.db.all("SELECT w.run_id, r.status AS run_status, l.work_id, l.operation_id, l.status, l.state_dir, l.provider_session_id, l.profile_json FROM work_launches l JOIN works w ON w.work_id = l.work_id JOIN runs r ON r.project_id = w.project_id AND r.id = w.run_id WHERE w.project_id = ? AND l.provider_session_id = ?", [projectId, identity.rootSessionId]);
+        for (const launch of launches) {
+            // Cooperative pause/drain may retain an admitted Work settlement while
+            // the RUN is paused; only terminal RUN states retire its native root.
+            const active = ["running", "paused", "waiting_for_user", "blocked"].includes(launch.run_status)
+                && ["launching", "start_requested"].includes(launch.status);
+            if (!active)
+                throw new AppError("invocation_scope_unproven", "External Work native root is no longer active", 1, { effect: "no_effect" });
+            const profile = JSON.parse(launch.profile_json);
+            const owner = profile.runtime_adapter?.owner;
+            if (!owner || owner.owner_id !== `run:${launch.run_id}:work:${launch.work_id}` || owner.project_id !== projectId
+                || owner.run_id !== launch.run_id || owner.work_id !== launch.work_id || owner.operation_id !== launch.operation_id || owner.state_dir !== launch.state_dir) {
+                throw new AppError("invocation_scope_unproven", "External Work has no matching persisted runtime owner", 1, { effect: "no_effect" });
+            }
+            owners.push({ runId: launch.run_id, rootSessionId: launch.provider_session_id, stateDir: launch.state_dir,
+                harness: runtimeHarness(profile.worker), ownerId: owner.owner_id, active });
+        }
+    }
+    if (hasTable("merge_requests")) {
+        const requests = context.db.all("SELECT m.merge_request_id, m.run_id, r.status AS run_status, m.status, m.executor_work_id, m.dispatch_owner, m.dispatch_lease_token, m.adapter_receipt_json FROM merge_requests m JOIN runs r ON r.project_id = m.project_id AND r.id = m.run_id WHERE m.project_id = ? AND m.execution_route = 'server' AND CASE WHEN json_valid(m.adapter_receipt_json) THEN json_extract(m.adapter_receipt_json, '$.session_id') = ? ELSE 0 END", [projectId, identity.rootSessionId]);
+        for (const request of requests) {
+            const active = ["running", "paused", "waiting_for_user", "blocked"].includes(request.run_status)
+                && ["dispatching", "active", "waiting_user", "action_required", "recovery_required"].includes(request.status);
+            if (!active)
+                throw new AppError("invocation_scope_unproven", "Server MERGE native root is no longer active", 1, { effect: "no_effect" });
+            const receipt = JSON.parse(request.adapter_receipt_json);
+            if (receipt.controller_id) {
+                const controller = context.db.get("SELECT generation, status, state_json FROM run_controllers WHERE controller_id = ? AND project_id = ? AND run_id = ?", [receipt.controller_id, projectId, request.run_id]);
+                const state = controller && JSON.parse(controller.state_json);
+                const session = state?.current_session === undefined || state.current_session === null ? undefined : state.sessions?.[state.current_session];
+                if (!request.dispatch_lease_token || request.dispatch_owner !== receipt.controller_id
+                    || !controller || ["completed", "cancelled", "superseded"].includes(controller.status)
+                    || state?.merge_claim?.request_id !== request.merge_request_id || state.merge_claim.token !== request.dispatch_lease_token
+                    || state.merge_claim.work_id !== request.executor_work_id || !session || session.stopped === true
+                    || session.id !== receipt.session_id || session.state_dir !== receipt.state_dir || !receipt.profile
+                    || JSON.stringify(session.profile) !== JSON.stringify(receipt.profile)) {
+                    throw new AppError("invocation_scope_unproven", "Controller MERGE root does not match its dispatch lease and retained Session", 1, { effect: "no_effect" });
+                }
+                // The controller Session above is already an owner candidate; its
+                // daemon binding and generation are checked once in the common loop.
+                continue;
+            }
+            const owner = receipt.owner;
+            if (!receipt.session_id || !receipt.state_dir || !receipt.profile || !owner
+                || owner.owner_id !== `run:${request.run_id}:merge:${request.merge_request_id}` || owner.project_id !== projectId
+                || owner.run_id !== request.run_id || owner.work_id !== request.executor_work_id || owner.state_dir !== receipt.state_dir
+                || owner.operation_id !== `${request.merge_request_id}:${request.dispatch_lease_token}`) {
+                throw new AppError("invocation_scope_unproven", "Server MERGE has no matching persisted runtime owner", 1, { effect: "no_effect" });
+            }
+            owners.push({ runId: request.run_id, rootSessionId: receipt.session_id, stateDir: receipt.state_dir,
+                harness: runtimeHarness(receipt.profile), ownerId: owner.owner_id, active });
+        }
+    }
+    for (const owner of owners) {
+        if (!owner.active)
+            throw new AppError("invocation_scope_unproven", "Managed native root is no longer active", 1, { effect: "no_effect" });
+        if (owner.harness !== harness)
+            throw new AppError("invocation_scope_unproven", "Native root belongs to another managed harness", 1, { effect: "no_effect" });
+        const binding = requireManagedDaemonBinding(context, { stateDir: owner.stateDir, projectId, runId: owner.runId, ...(owner.ownerId ? { ownerId: owner.ownerId } : {}) });
+        if (binding.process.kind !== (harness === "grok-acp" ? "grok-daemon" : "agy-daemon")) {
+            throw new AppError("invocation_scope_unproven", "Native daemon kind differs from its persisted harness", 1, { effect: "no_effect" });
+        }
+        if (binding.state.daemon_id !== identity.daemonId)
+            throw new AppError("invocation_scope_unproven", "Native daemon differs from its persisted launch", 1, { effect: "no_effect" });
+        const root = binding.state.sessions?.some(native => typeof native === "string" ? native === identity.rootSessionId
+            : native.provider_session_id === identity.rootSessionId && (native.root_provider_session_id ?? identity.rootSessionId) === identity.rootSessionId);
+        const generation = JSON.parse(binding.process.metadata_json).run_generation;
+        if (!root || !Number.isSafeInteger(generation) || generation < 0 || owner.generation !== undefined && generation !== owner.generation) {
+            throw new AppError("invocation_scope_unproven", "Managed native root or RUN generation is not persisted", 1, { effect: "no_effect" });
+        }
+        return { projectId, runId: owner.runId, generation };
+    }
+    return null;
+}
+/** recordReceipt is a synchronous SQL-only hook ingress callback. Native
+ * adapters must prepare any filesystem or process evidence before calling. */
 export function observeLifecycleInvocation(context, input) {
     storage(context);
     const supplied = input.id ? context.db.get("SELECT * FROM lifecycle_invocations WHERE id = ?", [input.id]) : undefined;
     const analysis = parseLifecycleCommand(input.command);
     if (analysis.kind !== "standalone" || analysis.invocation.wrapped) {
+        if (analysis.kind !== "none" && ["grok-acp", "antigravity-cli"].includes(input.harness ?? "") && input.projectId
+            && managedNativeOwner(context, input.identity, input.harness, input.projectId)) {
+            throw new AppError("invocation_command_invalid", "Managed native lifecycle call must be one direct standalone command", 1, { phase: "prepare", effect: "no_effect", recoverable: false });
+        }
         const eventKey = input.recordReceipt();
         if (analysis.kind !== "none") {
             const retained = context.db.get("SELECT outcome_json FROM hook_events WHERE event_key = ?", [eventKey]);
@@ -797,6 +953,16 @@ export function observeLifecycleInvocation(context, input) {
     // public ID is corrected only by an exact operation/target match inside the
     // trusted native root. Never fuzzy-match UUID text or select a global latest.
     const initial = supplied ?? (candidates.length === 1 ? candidates[0] : undefined);
+    const owner = ["grok-acp", "antigravity-cli"].includes(input.harness ?? "") && input.projectId
+        ? managedNativeOwner(context, input.identity, input.harness, input.projectId) : null;
+    if (owner) {
+        if (!initial)
+            throw new AppError("invocation_assignment_missing", "Managed native lifecycle call has no issued assignment", 1, { effect: "no_effect", recoverable: false });
+        const scope = JSON.parse(initial.scope_json);
+        if (requireProjectByRoot(context, scope.projectRoot).id !== owner.projectId || scope.runId !== owner.runId || scope.generation !== owner.generation) {
+            throw new AppError("invocation_scope_mismatch", "Native daemon owner does not match issued RUN authority", 1, { effect: "no_effect", recoverable: false });
+        }
+    }
     if (!initial) {
         const eventKey = input.recordReceipt();
         if (candidates.length > 1)
@@ -814,21 +980,16 @@ export function observeLifecycleInvocation(context, input) {
     const identity = input.identity;
     checkNativeIdentity(scope, identity, initial.id);
     const identityJson = JSON.stringify([identity.daemonId, identity.rootSessionId, identity.sessionId, identity.parentSessionId, identity.toolCallId]);
-    context.db.beginWriteTransaction();
-    try {
+    return context.db.writeTransaction(() => {
         const row = context.db.get("SELECT * FROM lifecycle_invocations WHERE id = ?", [initial.id]);
-        if (row.status === "settled") {
-            context.db.exec("COMMIT");
+        if (row.status === "settled")
             return { eventKey: row.event_key, duplicate: true, ...resolved };
-        }
         // Observation records native facts only. CLI owns deadline, argument and
         // RUN-state validation, including decisions about retrying an invocation.
         if (row.status === "expired" || (row.deadline !== null && row.deadline <= Date.now() && !row.event_key)) {
-            context.db.exec("COMMIT");
             return { eventKey: row.event_key, duplicate: true, ...resolved };
         }
         if (row.identity_json === identityJson) {
-            context.db.exec("COMMIT");
             return { eventKey: row.event_key, duplicate: true, ...resolved };
         }
         const eventKey = input.recordReceipt({ projectRoot: scope.projectRoot, runId: scope.runId, command: initial.command });
@@ -846,15 +1007,10 @@ export function observeLifecycleInvocation(context, input) {
         // is safe. Keep the newest receipt until the CLI claims the attempt. The
         // observed -> executing compare-and-swap remains the exactly-once boundary.
         const updated = context.db.run("UPDATE lifecycle_invocations SET identity_json = ?, event_key = ?, status = 'observed', updated_at = ? WHERE id = ? AND status IN ('issued', 'observed')", [identityJson, eventKey, context.now(), initial.id]);
-        context.db.exec("COMMIT");
         // Once execution has been claimed, later PreToolUse observations are
         // retained as hook evidence but cannot replace the executor's receipt.
         return { eventKey: updated.changes === 1 ? eventKey : row.event_key, duplicate: updated.changes !== 1, ...resolved };
-    }
-    catch (error) {
-        context.db.exec("ROLLBACK");
-        throw error;
-    }
+    });
 }
 /** Correlate exact native argv for diagnostics, independently of assignment
  * matching. A hook-added event key must name the same persisted native call. */
@@ -894,15 +1050,17 @@ export function observedLifecycleNativeEvent(context, command, daemonId) {
     return matches.length === 1 ? { project_id: matches[0].project_id, id: matches[0].id } : null;
 }
 /** Keep shell diagnostics distinct from genuinely absent native delivery. */
-export function observedLifecycleDiagnostic(context, command, daemonId) {
+export function observedLifecycleDiagnostic(context, command, daemonId, invocationId) {
     const analysis = parseLifecycleCommand(command);
     if (analysis.kind !== "standalone")
         return null;
     const commandFingerprint = fingerprint(analysis.invocation);
-    const rows = context.db.all("SELECT event_key, outcome_json FROM hook_events WHERE daemon_id = ? AND status = 'observed' AND outcome_json IS NOT NULL ORDER BY id DESC LIMIT 20", [daemonId]).flatMap(row => {
+    const issuedAt = invocationId ? context.db.get("SELECT created_at FROM lifecycle_invocations WHERE id = ?", [invocationId])?.created_at : undefined;
+    const rows = context.db.all(`SELECT id, event_key, outcome_json FROM hook_events WHERE daemon_id = ? AND status = 'observed' AND outcome_json IS NOT NULL
+      ${issuedAt ? "AND created_at >= ?" : ""} ORDER BY id DESC LIMIT 20`, issuedAt ? [daemonId, issuedAt] : [daemonId]).flatMap(row => {
         try {
             const outcome = JSON.parse(row.outcome_json);
-            return outcome.lifecycle_observation?.command_fingerprint === commandFingerprint ? [{ ...outcome.lifecycle_observation, event_key: row.event_key }] : [];
+            return outcome.lifecycle_observation?.command_fingerprint === commandFingerprint ? [{ ...outcome.lifecycle_observation, event_key: row.event_key, hook_event_id: row.id }] : [];
         }
         catch {
             return [];
@@ -944,23 +1102,58 @@ export function observedLifecycleInvocation(context, command, daemonId) {
         throw new AppError("invocation_ambiguous", "More than one observed lifecycle attempt matches this command", 1, { effect: "no_effect", matches: matches.map(row => row.id) });
     return { id: matches[0].id, scope: JSON.parse(matches[0].scope_json) };
 }
-/** Replace presentation argv with the exact retained machine assignment.
- * Public semantic arguments are already covered by the projected fingerprint;
- * any explicitly repeated private value must agree instead of being ignored. */
+/** Restore private assignment arguments without discarding the provider's
+ * verified public input. The fingerprint deliberately projects semantic
+ * values such as a Work failure reason and a Work result-file path. */
 export function resolveObservedLifecycleArgs(context, id, actualArgs) {
     const row = context.db.get("SELECT * FROM lifecycle_invocations WHERE id = ?", [id]);
     if (!row)
         throw new AppError("invocation_unknown", "Lifecycle invocation is not registered", 1, { invocation_id: id });
-    const retained = invocation(row.command), actual = invocation(`${quote([retained.executable])} ${quoteModelFacingArgs(actualArgs)}`);
+    const retained = invocation(row.command), actual = invocation(`${launchExpression(retained)} ${quoteModelFacingArgs(actualArgs)}`);
     if (fingerprint(actual) !== row.fingerprint)
         throw new AppError("invocation_command_mismatch", "Lifecycle command does not match its issued assignment", 2, { phase: "prepare", effect: "no_effect", recoverable: true });
     for (const key of runtimeOwnedOptions[retained.operation] ?? []) {
         const supplied = commandOption(actual, key), expected = commandOption(retained, key);
-        if (supplied !== undefined && normalizedInvocationValue(key, supplied) !== normalizedInvocationValue(key, expected ?? "")) {
+        const exactInput = ["result-file", "decision-file", "verification-file"].includes(key);
+        const actualValue = exactInput && supplied !== undefined
+            ? commandOption(invocation(`${launchExpression(retained)} ${quote(expandLifecycleInvocationArgs(context, actual.argv, JSON.parse(row.scope_json), retained.operation))}`), key)
+            : supplied;
+        if (supplied !== undefined && (exactInput ? path.resolve(actualValue ?? "") !== path.resolve(expected ?? "")
+            : normalizedInvocationValue(key, supplied) !== normalizedInvocationValue(key, expected ?? ""))) {
             throw new AppError("invocation_argument_mismatch", `--${key} is owned by the managed assignment and does not match it`, 2, { phase: "prepare", effect: "no_effect", recoverable: true, parameter: key });
         }
     }
-    return [...retained.argv];
+    const argv = [...retained.argv];
+    const publicKey = retained.operation === "work_fail" ? "reason" : retained.operation === "work_finish" ? "result-file" : null;
+    if (publicKey && commandOption(actual, publicKey) !== undefined) {
+        const index = argv.indexOf(`--${publicKey}`);
+        if (index >= 0 && index + 1 < argv.length)
+            argv[index + 1] = commandOption(actual, publicKey);
+        else {
+            const inline = argv.findIndex(value => value.startsWith(`--${publicKey}=`));
+            if (inline >= 0)
+                argv[inline] = `--${publicKey}=${commandOption(actual, publicKey)}`;
+        }
+    }
+    return argv;
+}
+/** Once native admission is committed, retain the actual public semantics so
+ * an authorized successor cannot silently revert to the issued placeholder. */
+export function retainObservedLifecycleSemantics(context, id, argv) {
+    const row = context.db.get("SELECT * FROM lifecycle_invocations WHERE id = ?", [id]);
+    if (!row || row.status !== "executing")
+        throw new AppError("invocation_settlement_conflict", "Lifecycle attempt is not executing", 1, { invocation_id: id });
+    const parsed = invocation(row.command);
+    if (!["work_fail", "work_finish"].includes(parsed.operation))
+        return;
+    const prefix = Object.entries(parsed.env).map(([key, value]) => `${key}=${quote([value])}`).join(" ");
+    const executable = launchExpression(parsed);
+    const suffix = row.command.slice(shellSuffixOffset(row.command)).trimStart();
+    const command = `${prefix ? `${prefix} ` : ""}${executable} ${quote(argv)}${suffix ? ` ${suffix}` : ""}`;
+    checkCommand(row, command);
+    if (context.db.run("UPDATE lifecycle_invocations SET command = ?, updated_at = ? WHERE id = ? AND status = 'executing'", [command, context.now(), id]).changes !== 1) {
+        throw new AppError("invocation_settlement_conflict", "Lifecycle attempt changed before its public input was retained", 1, { invocation_id: id });
+    }
 }
 export function settleLifecyclePreparationRejection(context, id, error) {
     return context.db.writeTransaction(() => {
@@ -994,7 +1187,7 @@ export function settleLifecyclePreparationRejection(context, id, error) {
     });
 }
 function preparationRejectionSignature(error) {
-    const omitted = new Set(["retry_command", "retry_instruction", "invocation_id", "hook_event_id", "rejection_signature"]);
+    const omitted = new Set(["retry_command", "retry_instruction", "invocation_id", "hook_event_id", "rejection_signature", "hook_retry_signature"]);
     const normalize = (value) => {
         if (Array.isArray(value))
             return value.map(normalize);
@@ -1005,11 +1198,45 @@ function preparationRejectionSignature(error) {
     return crypto.createHash("sha256").update(JSON.stringify([error.code, normalize(error.details)])).digest("hex");
 }
 export function currentLifecycleFailure(context, input) {
+    if (input.turn !== undefined) {
+        const hooks = context.db.all(`SELECT id, outcome_json FROM hook_events
+      WHERE json_extract(outcome_json, '$.run_id') = ? AND json_extract(outcome_json, '$.generation') = ?
+        AND json_extract(outcome_json, '$.stage') = ? AND json_extract(outcome_json, '$.controller_turn') = ?
+        ${input.projectId ? "AND project_id = ?" : ""}
+      ORDER BY id DESC`, [input.runId, input.generation, input.stage, input.turn, ...(input.projectId ? [input.projectId] : [])]);
+        const completed = new Set();
+        const activeAttempt = input.projectId ? stageAttempt(context, input.projectId, input.runId, input.stage) : null;
+        for (const hook of hooks) {
+            let outcome;
+            try {
+                outcome = JSON.parse(hook.outcome_json);
+            }
+            catch {
+                continue;
+            }
+            if (activeAttempt && outcome.attempt && outcome.attempt !== activeAttempt)
+                continue;
+            const key = JSON.stringify([outcome.operation ?? "", outcome.session_id ?? null, outcome.correlation_key ?? outcome.fingerprint ?? hook.id]);
+            if (outcome.disposition === "completed") {
+                completed.add(key);
+                continue;
+            }
+            if (completed.has(key) || !outcome.error?.code)
+                continue;
+            const continuation = outcome.error.details?.continuation;
+            if (continuation && typeof continuation === "object"
+                && continuation.run_id === input.runId
+                && continuation.stage === input.stage
+                && isRegisteredRepair(context, continuation, input.projectId ? { projectId: input.projectId, runId: input.runId } : undefined))
+                continue;
+            return { code: outcome.error.code, message: outcome.error.message ?? "Lifecycle command failed", details: outcome.error.details ?? {}, hook_event_id: hook.id };
+        }
+    }
     const attempts = context.db.all("SELECT * FROM lifecycle_invocations ORDER BY updated_at DESC, rowid DESC");
     const scoped = attempts.filter(row => {
         try {
             const scope = JSON.parse(row.scope_json);
-            return scope.runId === input.runId && scope.generation === input.generation;
+            return scope.runId === input.runId && scope.generation === input.generation && (!input.projectRoot || scope.projectRoot === input.projectRoot);
         }
         catch {
             return false;
@@ -1018,7 +1245,9 @@ export function currentLifecycleFailure(context, input) {
     const fingerprints = [...new Set(scoped.map(row => row.fingerprint))];
     for (const fingerprint of fingerprints) {
         const rows = scoped.filter(row => row.fingerprint === fingerprint);
-        if (rows.some(row => ["issued", "observed", "executing"].includes(row.status)))
+        // An issued successor has not performed the correction. Once the Turn
+        // ended it cannot erase the predecessor's actual rejection.
+        if (rows.some(row => ["observed", "executing"].includes(row.status)))
             continue;
         const row = rows.find(candidate => candidate.status === "settled");
         if (!row)
@@ -1039,9 +1268,23 @@ export function currentLifecycleFailure(context, input) {
         catch {
             continue;
         }
-        const stage = parsed.operation.startsWith("merge_") ? "merge" : commandOption(parsed, "stage");
+        let stage = parsed.operation.startsWith("merge_") ? "merge" : commandOption(parsed, "stage");
+        if (!stage && parsed.operation.startsWith("work_") && input.runId) {
+            try {
+                const work = resolveWorkReference(context, commandPosition(parsed, 0) ?? "", { runId: input.runId });
+                const membership = context.db.get("SELECT stage FROM stage_work_memberships WHERE run_id = ? AND work_id = ? ORDER BY rowid DESC LIMIT 1", [input.runId, work.work_id]);
+                stage = membership?.stage;
+            }
+            catch { /* A stale or unbound Work is not evidence for this Stage. */ }
+        }
         if (stage !== input.stage)
             continue;
+        const continuation = outcome.error.details?.continuation;
+        if (continuation && typeof continuation === "object"
+            && continuation.run_id === input.runId
+            && continuation.stage === input.stage
+            && isRegisteredRepair(context, continuation, input.projectId ? { projectId: input.projectId, runId: input.runId } : undefined))
+            continue;
         return { code: outcome.error.code, message: outcome.error.message, details: outcome.error.details ?? {}, invocation_id: row.id };
     }
     return null;
@@ -1097,19 +1340,13 @@ export async function awaitLifecycleInvocation(context, input) {
             continue;
         }
         if (row.status === "expired" || (row.deadline !== null && row.deadline <= Date.now())) {
-            context.db.beginWriteTransaction();
-            try {
+            context.db.writeTransaction(() => {
                 const current = load(context, input.id);
                 if (["issued", "expired"].includes(current.status)) {
                     input.assertCurrent(JSON.parse(current.scope_json));
                     settleUnadmittedInvocation(context, current, receiptTimeout(input.id));
                 }
-                context.db.exec("COMMIT");
-            }
-            catch (error) {
-                context.db.exec("ROLLBACK");
-                throw error;
-            }
+            });
             continue;
         }
         await delay(Math.min(25, Math.max(1, (row.deadline ?? Date.now() + 25) - Date.now())));