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

package/dist/services/external-work-launch.js

@@ -93,10 +93,16 @@ export async function launchExternalWork(context, input) {
     const common = ["--dd-flow-bin", flowExecutable, "--state-dir", root, "--journal", journal, "--cwd", isolatedWorkspace ?? run.workspace_root, "--provider", resolved.worker.provider, "--model", resolved.worker.model, "--reasoning", resolved.worker.reasoning, "--mode", resolved.worker.mode, "--permission", resolved.worker.permission, "--project-root", run.project_root, "--dd-flow-home", context.ddFlowHome, ...harnessRuntimeArguments(context.ddFlowHome, runtimeHarness(resolved.worker)), "--json"];
     const evidence = (value) => fs.appendFileSync(journal, `${JSON.stringify({ type: "adapter_call", at: context.now(), ...value })}\n`);
     try {
-        const call = (args, timeoutMs, id = `${operationId}:${args[0]}.${args[1]}`) => runHarnessAdapter({ executable, args, env: runtimeContext.env, operationId: id, runtimeOwner, ...(timeoutMs ? { timeoutMs } : {}), ...(input.signal ? { signal: input.signal } : {}), ...(input.progress ? { progress: input.progress } : {}), onEvidence: evidence });
+        const call = (args, timeoutMs, id = `${operationId}:${args[0]}.${args[1]}`) => runHarnessAdapter({ executable, args, harness: runtimeHarness(resolved.worker), env: runtimeContext.env, operationId: id, runtimeOwner, ...(timeoutMs !== undefined ? { timeoutMs } : {}), ...(input.signal ? { signal: input.signal } : {}), ...(input.progress ? { progress: input.progress } : {}), onEvidence: evidence, onNativeOutcome: value => {
+                if (args[0] !== "session" || args[1] !== "create")
+                    return;
+                const nativeId = adapterSessionId(value);
+                if (nativeId)
+                    context.db.run("UPDATE work_launches SET provider_session_id = ?, adapter_receipt_json = ?, updated_at = ? WHERE operation_id = ?", [nativeId, JSON.stringify({ create: value, settlement_pending: true }), context.now(), operationId]);
+            } });
         await call(["daemon", "start", ...common]);
         assertRunMutationAllowed(context, work.project_id, work.run_id, generation);
-        const created = await call(["session", "create", ...common], runtimeHarness(resolved.worker) === "zcode-acp" ? 180_000 : undefined);
+        const created = await call(["session", "create", ...common]);
         const sessionId = adapterSessionId(created);
         if (!sessionId)
             throw new AppError("harness_adapter_invalid", "Harness adapter did not return a typed Session id", 1, { work_id: work.work_id, harness: runtimeHarness(resolved.worker) });
@@ -111,20 +117,28 @@ export async function launchExternalWork(context, input) {
         const promptFile = path.join(root, "launch.md");
         fs.writeFileSync(promptFile, `Start the assigned Work now. Your first tool call must be this exact standalone command:\n\n${workStartCommand(runtimeContext, work)}\n\nUse the packet returned by that command. Do not claim another Work or run this command more than once.\n\n${lifecycleRetryInstruction}${isolatedWorkspace ? `\n\nThe review copy has no .git. Read the captured status/diff or gitless note in ${path.join(isolatedWorkspace, ".dd-flow", "review-evidence")}; do not run Git inside the copy.\n` : "\n"}`);
         const promptOperationId = `${operationId}:session.prompt`;
-        const promptDeadline = Date.now() + 45 * 60_000;
+        context.db.run("UPDATE work_launches SET adapter_receipt_json = ?, updated_at = ? WHERE operation_id = ? AND status = 'launching'", [JSON.stringify({ create: created, progress_policy: "native-inactivity@1" }), context.now(), operationId]);
         let prompted;
         try {
-            prompted = await call(["session", "prompt", "--session-id", sessionId, "--prompt-file", promptFile, ...common], 45 * 60_000);
+            prompted = await call(["session", "prompt", "--session-id", sessionId, "--prompt-file", promptFile, ...common], null);
         }
         catch (error) {
             if (runtimeHarness(resolved.worker) !== "codex-desktop")
                 throw error;
             const retained = context.db.get("SELECT adapter_receipt_json FROM work_launches WHERE operation_id = ?", [operationId]);
             const capacityIntents = retained?.adapter_receipt_json ? JSON.parse(retained.adapter_receipt_json).capacity_intents ?? [] : [];
+            const capacityFailures = retained?.adapter_receipt_json ? JSON.parse(retained.adapter_receipt_json).capacity_failures ?? [] : [];
+            const retainCapacity = () => {
+                const changed = context.db.run("UPDATE work_launches SET adapter_receipt_json = ?, updated_at = ? WHERE operation_id = ? AND status = 'launching'", [JSON.stringify({ create: created, progress_policy: "native-inactivity@1", capacity_intents: capacityIntents, capacity_failures: capacityFailures }), context.now(), operationId]);
+                if (changed.changes !== 1)
+                    throw new AppError("capacity_continuation_blocked", "External Work launch owner changed", 1);
+            };
             const resumed = await continueCodexCapacity({ error, sessionId, operationId: promptOperationId, allowSettledDescendants: true,
-                ...(input.signal ? { signal: input.signal } : {}), deadline: promptDeadline,
+                ...(input.signal ? { signal: input.signal } : {}),
                 continuationText: `Continue only Work ${work.work_id} in RUN ${work.run_id}, Stage ${stage ?? "current"}, in the same Session. Inspect its current durable state and the retained Work packet. Never repeat Work start or a completed tool, accepted answer, check or lifecycle command. Use only the current exact issued successor and finish at the original Work boundary.`,
                 retainedIntents: () => capacityIntents,
+                retainedFailures: () => capacityFailures,
+                retainFailure: (_id, refusal) => { capacityFailures.push(refusal); retainCapacity(); },
                 inspectOperation: id => call(["daemon", "operation", "--state-dir", root, "--operation-id", id, "--json"], 30_000, `${id}:capacity-observe`),
                 inspectSession: turnId => call(["session", "inspect", "--session-id", sessionId, ...(turnId ? ["--turn-id", turnId] : []), ...common], 30_000, `${operationId}:capacity-inspect`),
                 assertCurrent: () => {
@@ -141,9 +155,7 @@ export async function launchExternalWork(context, input) {
                 },
                 retainIntent: intent => {
                     capacityIntents.push(intent);
-                    const changed = context.db.run("UPDATE work_launches SET adapter_receipt_json = ?, updated_at = ? WHERE operation_id = ? AND status = 'launching'", [JSON.stringify({ create: created, capacity_intent: intent, capacity_intents: capacityIntents }), context.now(), operationId]);
-                    if (changed.changes !== 1)
-                        throw new AppError("capacity_continuation_blocked", "External Work launch owner changed", 1);
+                    retainCapacity();
                 },
                 prompt: (id, text, ordinal) => {
                     const file = path.join(root, `capacity-${ordinal}.md`);
@@ -153,7 +165,7 @@ export async function launchExternalWork(context, input) {
                     }
                     else
                         fs.writeFileSync(file, text, { flag: "wx", mode: 0o600 });
-                    return call(["session", "prompt", "--session-id", sessionId, "--prompt-file", file, ...common], Math.max(1, promptDeadline - Date.now()), id);
+                    return call(["session", "prompt", "--session-id", sessionId, "--prompt-file", file, ...common], null, id);
                 } });
             if (!resumed)
                 throw error;

package/dist/services/harness-adapter.js

@@ -2,8 +2,14 @@ import { spawn } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { AppError } from "../shared/errors.js";
-import { recoveryRpcTimeout } from "./recovery-observation-budget.js";
+import { AppError, errorRecord } from "../shared/errors.js";
+import { stopProcessGroup } from "../harness-runtime/lib/managed-daemon.mjs";
+import { recoveryObservationBudget, recoveryRpcTimeout, withRecoveryObservation } from "./recovery-observation-budget.js";
+import { ObservationClock, validateObservationDuration } from "../harness-runtime/lib/observation-clock.mjs";
+import { canonicalNativeOperation, nativeOperationWait } from "../harness-runtime/lib/adapter-timeouts.mjs";
+import { readOperationProgress, readOperationRecord, readOperationWaiting, suspendOperationClock } from "../harness-runtime/lib/operation-progress.mjs";
+import { recoverDaemonReply } from "../harness-runtime/lib/daemon-observation.mjs";
+import { isObservationLoss } from "../harness-runtime/lib/operation-errors.mjs";
 const maxAdapterOutputBytes = 1_000_000;
 /** Native hooks need a real executable, not a PATH-dependent shell expression. */
 export function prepareHarnessFlowExecutable(context, stateDir) {
@@ -36,11 +42,50 @@ export function prepareHarnessFlowExecutable(context, stateDir) {
     }
     return executable;
 }
-/** Runs one harness command with the lifecycle guarantees shared by agent services. */
 export function runHarnessAdapter(input) {
+    const index = input.args.indexOf("--state-dir"), stateDir = index >= 0 ? input.args[index + 1] : undefined;
+    const operation = canonicalNativeOperation(input.harness ?? "", `${input.args[0]}.${input.args[1]}`);
+    const boundOperation = ["session.create", "session.fork", "session.start", "session.resume"].includes(operation);
+    const binding = { operation, ...(input.runtimeOwner ? { owner_id: input.runtimeOwner.owner_id } : {}) };
+    let retainedOutcome;
+    const onOutcome = (value) => {
+        const fingerprint = JSON.stringify(value);
+        if (fingerprint !== retainedOutcome) {
+            input.onNativeOutcome?.(value);
+            retainedOutcome = fingerprint;
+        }
+    };
+    const dispatched = runAdapterTransport(input, stateDir, binding);
+    return dispatched.catch(async (error) => {
+        if (!stateDir || !boundOperation || input.signal?.aborted || !(isObservationLoss(error) || isObservationLoss(error?.details?.cause)))
+            throw error;
+        try {
+            return await recoverDaemonReply(stateDir, input.operationId, { timeoutMs: recoveryRpcTimeout(30_000), ...(input.signal ? { signal: input.signal } : {}), ...(error?.observationClock ? { observationClock: error.observationClock } : {}), binding, onOutcome,
+                // Reconcile only original bookkeeping. Work/MERGE share this path and
+                // must not replay creation merely because its release receipt is pending.
+                onPendingSettlement: async (retained) => {
+                    input.signal?.throwIfAborted();
+                    await withRecoveryObservation(recoveryObservationBudget(retained), () => runAdapterTransport({ ...input, args: ["daemon", "operation", "settle", "--state-dir", stateDir, "--operation-id", input.operationId, "--json"], operationId: `${input.operationId}:settlement`, timeoutMs: recoveryRpcTimeout(30_000) }, stateDir, {}), true);
+                }
+            });
+        }
+        catch (recovery) {
+            if (recovery && typeof recovery === "object")
+                Object.assign(recovery, { cause: error });
+            throw recovery;
+        }
+    });
+}
+function runAdapterTransport(input, stateDir, binding = {}) {
     // `null` is deliberate: a productive Turn has no adapter-wall-clock limit.
     // Preserve it instead of treating it like an omitted short control request.
-    const timeoutMs = recoveryRpcTimeout(input.timeoutMs === undefined ? 120_000 : input.timeoutMs);
+    if (input.timeoutMs != null)
+        validateObservationDuration(input.timeoutMs);
+    const operation = canonicalNativeOperation(input.harness ?? "", `${input.args[0]}.${input.args[1]}`);
+    const productive = input.harness !== undefined && nativeOperationWait(input.harness, operation) === "native-work";
+    const timeoutMs = recoveryRpcTimeout(productive ? null : input.timeoutMs === undefined ? 120_000 : input.timeoutMs);
+    if (timeoutMs !== null)
+        validateObservationDuration(timeoutMs);
     if (!input.operationId.trim())
         throw new AppError("operation_id_required", "Harness calls require a scoped operation id", 2);
     // The current adapter transport uses this name; its identity is runtime-owned,
@@ -64,18 +109,33 @@ export function runHarnessAdapter(input) {
         let outputTooLarge = false;
         let timedOut = false;
         let aborted = false;
-        let killTimer;
+        let cleanup;
+        let pendingDiagnostic = "", droppingDiagnostic = false, progressCursor = 0;
+        let prettyDiagnostic = "", retainedError;
+        const phases = new Set();
+        let operationSequence = 0;
+        let diagnosticReads = Promise.resolve();
+        const clock = timeoutMs === null ? null : new ObservationClock({ timeoutMs });
+        clock?.sample(progressCursor);
         let settled = false;
         let callbackError;
         let spawnError;
-        const terminate = (signal) => { try {
-            if (detached && child.pid)
-                process.kill(-child.pid, signal);
-            else
-                child.kill(signal);
-        }
-        catch { /* The process already settled. */ } };
-        const stopTransport = () => { terminate("SIGTERM"); killTimer ??= setTimeout(() => terminate("SIGKILL"), 5_000); };
+        const stopTransport = () => {
+            cleanup ??= stopProcessGroup(child, 5_000, { detached }).catch(error => {
+                if (timer)
+                    clearInterval(timer);
+                if (heartbeat)
+                    clearInterval(heartbeat);
+                input.signal?.removeEventListener("abort", abort);
+                const details = { cleanup_error: errorRecord(error) };
+                if (callbackError instanceof Error) {
+                    Object.assign(callbackError, { cleanup_error: details.cleanup_error, details: { ...callbackError.details, ...details } });
+                    reject(callbackError);
+                }
+                else
+                    reject(new AppError(outputTooLarge ? "harness_adapter_output_limit" : timedOut ? "harness_adapter_timeout" : aborted ? "harness_adapter_aborted" : "harness_adapter_cleanup_unconfirmed", "Adapter transport cleanup could not be confirmed", 1, details));
+            });
+        };
         const deliver = (callback) => {
             try {
                 const result = callback();
@@ -91,7 +151,43 @@ export function runHarnessAdapter(input) {
             }
         };
         const heartbeat = input.progress && input.progressMessage ? setInterval(() => deliver(() => input.progress?.(`${input.progressMessage}; waiting for adapter completion`)), 15_000) : undefined;
-        const timer = timeoutMs === null ? undefined : setTimeout(() => { timedOut = true; stopTransport(); }, timeoutMs);
+        let observing = false;
+        const timer = timeoutMs === null ? undefined : setInterval(async () => {
+            if (settled || cleanup)
+                return;
+            if (observing)
+                return;
+            observing = true;
+            // Helper phase progress must never replenish its owner's independent
+            // physical-settlement episode. ALS retains that existing budget here.
+            try {
+                recoveryRpcTimeout(timeoutMs);
+            }
+            catch (error) {
+                callbackError ??= error;
+                stopTransport();
+                observing = false;
+                return;
+            }
+            try {
+                const waiting = stateDir && await readOperationWaiting(stateDir, input.operationId, binding);
+                if (settled || cleanup)
+                    return;
+                if (waiting)
+                    suspendOperationClock(clock);
+                else if (clock.sample(progressCursor)) {
+                    timedOut = true;
+                    stopTransport();
+                }
+            }
+            catch (error) {
+                callbackError ??= error;
+                stopTransport();
+            }
+            finally {
+                observing = false;
+            }
+        }, Math.max(1, Math.min(1000, timeoutMs / 4)));
         const abort = () => { aborted = true; stopTransport(); };
         if (input.signal?.aborted)
             abort();
@@ -106,22 +202,96 @@ export function runHarnessAdapter(input) {
             }
             return current + chunk;
         };
+        const observeDiagnostic = (line) => {
+            if (prettyDiagnostic === null) {
+                if (line.trimEnd() === "}")
+                    prettyDiagnostic = "";
+                return;
+            }
+            const candidate = prettyDiagnostic ? `${prettyDiagnostic}\n${line}` : line;
+            if (candidate.length > 64_000) {
+                prettyDiagnostic = null;
+                return;
+            }
+            let value;
+            try {
+                value = JSON.parse(candidate);
+                prettyDiagnostic = "";
+            }
+            catch {
+                prettyDiagnostic = prettyDiagnostic || line.trimStart().startsWith("{") ? candidate : "";
+                return;
+            }
+            if (!value || typeof value !== "object" || Array.isArray(value))
+                return;
+            if (value.kind === "operation_progress" && stateDir && value.operation_id === input.operationId) {
+                // The diagnostic is only a wake-up: durable, bound evidence owns liveness.
+                diagnosticReads = diagnosticReads.then(async () => {
+                    const record = await readOperationProgress(stateDir, input.operationId, binding);
+                    if (!record || record.sequence <= operationSequence)
+                        return;
+                    const requested = await readOperationRecord(stateDir, input.operationId, "requested.json");
+                    if (!requested)
+                        throw new AppError("operation_progress_invalid", "Operation request disappeared while observing progress", 1);
+                    for (const key of ["daemon_id", "params_sha256", "generation"])
+                        binding[key] ??= requested[key] ?? null;
+                    operationSequence = record.sequence;
+                    clock?.sample(++progressCursor, Date.parse(record.observed_at));
+                }).catch(error => { callbackError ??= error; if (!settled)
+                    stopTransport(); });
+                return;
+            }
+            const cause = adapterCause(candidate);
+            if (typeof cause.code === "string")
+                retainedError = cause;
+            if (clock && !(stateDir && ["session.create", "session.fork", "session.start", "session.resume", "session.prompt"].includes(operation))
+                && ["native_hook_phase", "process_maintenance_phase"].includes(String(value.kind))
+                && typeof value.phase === "string" && /^[a-z_]{1,48}$/.test(value.phase)
+                && !["heartbeat", "poll", "elapsed", "wait", "waiting", "status"].includes(value.phase)) {
+                const marker = JSON.stringify([value.kind, value.phase, value.operation_id ?? value.process_id]);
+                if (!phases.has(marker)) {
+                    phases.add(marker);
+                    clock.sample(++progressCursor);
+                }
+            }
+        };
         child.stdout.setEncoding("utf8").on("data", (chunk) => { stdout = append(stdout, chunk); });
-        child.stderr.setEncoding("utf8").on("data", (chunk) => { stderr = append(stderr, chunk); });
+        // Diagnostics have no lifetime quota. Stream to the existing evidence sink
+        // and carry only a bounded tail in the disposable RPC receipt.
+        child.stderr.setEncoding("utf8").on("data", (chunk) => {
+            stderr = (stderr + chunk).slice(-64_000);
+            for (const piece of chunk.split(/(?<=\n)/)) {
+                if (!droppingDiagnostic)
+                    pendingDiagnostic += piece;
+                if (pendingDiagnostic.length > 64_000) {
+                    prettyDiagnostic = prettyDiagnostic || pendingDiagnostic.trimStart().startsWith("{") ? null : "";
+                    pendingDiagnostic = "";
+                    droppingDiagnostic = true;
+                }
+                if (!piece.endsWith("\n"))
+                    continue;
+                if (!droppingDiagnostic)
+                    observeDiagnostic(pendingDiagnostic);
+                pendingDiagnostic = "";
+                droppingDiagnostic = false;
+            }
+            if (input.onEvidence)
+                deliver(() => evidence({ type: "adapter_diagnostic", stderr: chunk }));
+        });
         child.once("error", (error) => { spawnError = error; });
-        child.once("close", (status, signal) => {
+        child.once("close", async (status, signal) => {
             if (settled)
                 return;
             settled = true;
             if (timer)
-                clearTimeout(timer);
+                clearInterval(timer);
             input.signal?.removeEventListener("abort", abort);
             if (heartbeat)
                 clearInterval(heartbeat);
-            if (killTimer) {
-                clearTimeout(killTimer);
-                terminate("SIGKILL");
-            }
+            await cleanup;
+            if (!droppingDiagnostic && pendingDiagnostic)
+                observeDiagnostic(pendingDiagnostic);
+            await diagnosticReads;
             const progressFailure = callbackError;
             deliver(() => evidence({ status, signal, timed_out: timedOut, aborted, stdout, stderr, ...(spawnError ? { error: spawnError.message } : {}) }));
             if (spawnError)
@@ -129,11 +299,11 @@ export function runHarnessAdapter(input) {
             if (outputTooLarge)
                 return reject(new AppError("harness_adapter_output_limit", "Harness adapter exceeded the bounded reply limit", 1, { executable: input.executable, args: input.args.slice(0, 3), max_output_bytes: maxAdapterOutputBytes }));
             if (timedOut)
-                return reject(new AppError("harness_adapter_timeout", "Harness adapter call timed out", 1, { executable: input.executable, args: input.args.slice(0, 3), timeout_ms: timeoutMs }));
+                return reject(Object.assign(new AppError("harness_adapter_timeout", "Harness adapter call timed out", 1, { executable: input.executable, args: input.args.slice(0, 3), timeout_ms: timeoutMs }), { observationClock: clock }));
             if (aborted)
                 return reject(new AppError("harness_adapter_aborted", "Harness adapter call was cancelled", 1, { executable: input.executable, args: input.args.slice(0, 3) }));
             if (status !== 0)
-                return reject(progressFailure ?? new AppError("harness_adapter_failed", "Harness adapter call failed", 1, { executable: input.executable, args: input.args.slice(0, 3), status, signal, stderr, cause: adapterCause(stdout, stderr), ...(callbackError ? { evidence_error: String(callbackError) } : {}) }));
+                return reject(progressFailure ?? new AppError("harness_adapter_failed", "Harness adapter call failed", 1, { executable: input.executable, args: input.args.slice(0, 3), status, signal, stderr, cause: adapterCause(stdout, stderr, retainedError ? JSON.stringify(retainedError) : ""), ...(callbackError ? { evidence_error: String(callbackError) } : {}) }));
             if (callbackError)
                 return reject(callbackError);
             try {
@@ -158,9 +328,9 @@ function adapterCause(...outputs) {
                 const value = JSON.parse(line);
                 const nested = value.error && typeof value.error === "object" && !Array.isArray(value.error) ? value.error : null;
                 const code = typeof nested?.code === "string" ? nested.code : typeof value.code === "string" ? value.code : null;
-                const message = typeof nested?.message === "string" ? nested.message : typeof value.error === "string" ? value.error : code;
+                const message = typeof nested?.message === "string" ? nested.message : typeof value.error === "string" ? value.error : typeof value.message === "string" ? value.message : code;
                 if (code)
-                    return { code, message, ...(nested?.details ?? value.details ? { details: nested?.details ?? value.details } : {}), ...((nested?.retryable ?? value.retryable) === true ? { retryable: true } : {}) };
+                    return errorRecord({ ...(nested ?? value), code, message });
             }
             catch { /* Adapter diagnostics need not be JSON. */ }
         }

package/dist/services/hooks.js

@@ -12,7 +12,7 @@ import { appendAudit } from "./audit.js";
 import { prepareTextFile, prepareJsonText, prepareError } from "../cli/input-preparation.js";
 import { nativeSessionIdentity, storageSessionId } from "./session-identity.js";
 import { assertRecoveryHookCurrent } from "./run-recovery.js";
-import { observeLifecycleInvocation, observedLifecycleInvocation } from "./lifecycle-invocations.js";
+import { observeLifecycleInvocation, observedLifecycleInvocation, managedNativeInvocationScope } from "./lifecycle-invocations.js";
 import { commandHasOption, commandOption, commandPosition, shellSuffixOffset, parseLifecycleCommand, lifecycleCommandFromPayload, continuationCommand } from "./lifecycle-command.js";
 import { registerProject, requireProjectByRoot } from "./projects.js";
 import { activeFlowSessionsForProject, recordFlowSessionObservation } from "./sessions.js";
@@ -398,6 +398,8 @@ export function handleCodexHook(context, input) {
         protocol_id: null
     };
     if (!lifecycle) {
+        if (providerSessionId)
+            assignedLifecycleCwd(context, project.root, null, providerSessionId, command, stringValue(payload.cwd));
         const persisted = context.db.writeTransaction(() => persist());
         return { ...common, observed: persisted.inserted, duplicate: !persisted.inserted };
     }
@@ -406,10 +408,13 @@ export function handleCodexHook(context, input) {
         const toolCallId = stringValue(payload.tool_use_id) ?? stringValue(payload.event_id) ?? stringValue(payload.delivery_id) ?? stringValue(payload.id);
         if (!daemonId || !rootProviderSessionId || !providerSessionId || !toolCallId)
             throw new AppError("codex_identity_missing", "Managed Codex lifecycle hook has no complete native invocation identity", 1, { invocation_id: invocationId });
+        const executionCwd = assignedLifecycleCwd(context, project.root, lifecycle, providerSessionId, command, stringValue(payload.cwd), { daemonId, rootSessionId: rootProviderSessionId, sessionId: providerSessionId, parentSessionId: parentProviderSessionId, toolCallId }, "codex-desktop");
         const receipt = observeLifecycleInvocation(context, {
             ...(invocationId ? { id: invocationId } : {}),
             command,
             harness: "codex-desktop",
+            projectId: project.id,
+            ...(executionCwd ? { executionCwd } : {}),
             identity: { daemonId, rootSessionId: rootProviderSessionId, sessionId: providerSessionId, parentSessionId: parentProviderSessionId, toolCallId },
             recordReceipt: scope => { persist(scope); return eventKey; }
         });
@@ -493,17 +498,17 @@ export function handleZcodeEvent(context, input) {
     if (toolName !== "Bash" && toolName !== "bash" && toolName !== "execute")
         return { ok: true, observed: false, reason: "non_bash_tool" };
     const command = stringValue(rawInput.command) ?? stringValue(rawInput.cmd);
-    const parsed = command ? parseLifecycleCommand(command) : { kind: "none" };
-    if (parsed.kind === "none" && !parsed.unresolved)
+    const parsed = command ? parseLifecycleCommand(command) : { kind: "none", participation: "none" };
+    if (parsed.participation === "none" || parsed.participation === "unproven")
         return { ok: true, observed: false, reason: "acp_evidence_only" };
-    if (parsed.kind === "none")
-        throw new AppError("lifecycle_shell_syntax_invalid", "Shell participation could not be proven", 1, { reason: parsed.reason, effect: "unknown", recoverable: false });
+    if (parsed.kind === "none" && !continuationCommand(command))
+        throw new AppError("lifecycle_shell_syntax_invalid", "Known lifecycle shell execution is unsupported", 1, { reason: parsed.reason, effect: "unknown", recoverable: false });
     const controlled = objectRecord(objectRecord(notification._meta).ddZcode);
     const providerSessionId = stringValue(native.childSessionId) ?? stringValue(controlled.rootProviderSessionId);
     return recordZcodeLifecycle(context, { projectRoot: input.projectRoot, stdin: JSON.stringify({
             session_id: providerSessionId, tool_use_id: update.toolCallId, tool_name: toolName, tool_input: rawInput,
             agent_id: native.agentId, _meta: { ddZcode: controlled }
-        }) }, commandOption(parsed.invocation, "invocation-id"));
+        }) }, parsed.kind !== "none" ? commandOption(parsed.invocation, "invocation-id") : undefined);
 }
 /**
  * Accept the synchronous native ZCode PreToolUse callback. Invocation-ID
@@ -576,12 +581,17 @@ function recordZcodeLifecycle(context, input, invocationId, nativePreTool = fals
         const result = { ok: true, observed: inserted, duplicate: !inserted, event_key: eventKey, harness: "zcode-acp", session: nativeSessionIdentity("zcode-acp", providerSessionId), ...(parentProviderSessionId ? { parent_session: nativeSessionIdentity("zcode-acp", parentProviderSessionId) } : {}), daemon_id: daemonId };
         return { ...result, hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "allow", updatedInput: { ...rawInput, command: rewritten } } };
     };
-    if (!lifecycle)
+    if (!lifecycle) {
+        assignedLifecycleCwd(context, expectedRoot, null, providerSessionId, command, observedCwd ?? undefined);
         return context.db.writeTransaction(() => persist());
+    }
     let persistedResult;
+    const executionCwd = assignedLifecycleCwd(context, expectedRoot, lifecycle, providerSessionId, command, observedCwd ?? undefined, { daemonId, rootSessionId: rootProviderSessionId, sessionId: providerSessionId, parentSessionId: parentProviderSessionId ?? null, toolCallId: toolUseId }, "zcode-acp");
     const receipt = observeLifecycleInvocation(context, {
         ...(invocationId ? { id: invocationId } : {}), command,
         harness: "zcode-acp",
+        projectId: project.id,
+        ...(executionCwd ? { executionCwd } : {}),
         identity: { daemonId, rootSessionId: rootProviderSessionId, sessionId: providerSessionId, parentSessionId: parentProviderSessionId ?? null, toolCallId: toolUseId },
         recordReceipt: scope => { persistedResult = persist(scope); return eventKey; }
     });
@@ -668,11 +678,15 @@ export function handleGrokEvent(context, input) {
     };
     const result = (inserted) => ({ ok: true, observed: inserted, duplicate: !inserted, event_key: eventKey, session: nativeSessionIdentity("grok-acp", providerSessionId),
         ...(isChild ? { parent_session: nativeSessionIdentity("grok-acp", stringValue(ddGrok.parentProviderSessionId) ?? rootProviderSessionId) } : {}), daemon_id: daemonId ?? null });
-    if (!lifecycle)
+    if (!lifecycle) {
+        assignedLifecycleCwd(context, expectedRoot, null, providerSessionId, command, observedCwd ?? undefined);
         return { ...result(context.db.writeTransaction(() => persist())), hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "allow", updatedInput: { ...rawInput, command: commandWithHookEvent(command, eventKey) } } };
+    }
     let inserted = false;
+    const executionCwd = assignedLifecycleCwd(context, expectedRoot, lifecycle, providerSessionId, command, observedCwd ?? undefined, { daemonId: daemonId ?? "", rootSessionId: rootProviderSessionId, sessionId: providerSessionId, parentSessionId, toolCallId: eventKey }, "grok-acp");
     const receipt = observeLifecycleInvocation(context, {
         command, harness: "grok-acp", projectId: project.id,
+        ...(executionCwd ? { executionCwd } : {}),
         identity: { daemonId: daemonId ?? "", rootSessionId: rootProviderSessionId, sessionId: providerSessionId, parentSessionId, toolCallId: eventKey },
         recordReceipt: scope => { inserted = persist(scope); return eventKey; }
     });
@@ -695,12 +709,35 @@ export function handleDroidEvent(context, input) {
     return handleControlledToolEvent(context, input, event, "droid-cli");
 }
 /** Stable project identity is not the native Session's execution workspace. */
+function assignedLifecycleCwd(context, projectRoot, facts, providerSessionId, command, observedCwd, identity, harness) {
+    const auxiliary = continuationCommand(command);
+    if ((!facts && !auxiliary) || facts?.analysis.supported === false)
+        return undefined;
+    const proven = identity && harness ? managedNativeInvocationScope(context, projectRoot, identity, harness) : null;
+    const constraint = proven ?? (identity ? { projectRoot, daemonId: identity.daemonId, rootSessionId: identity.rootSessionId } : undefined);
+    const issuedRunId = facts && !facts.runId && !facts.workId && !facts.bootstrapStageStart && constraint ? observedLifecycleInvocation(context, command, constraint, identity ? { identity } : undefined)?.scope.runId : null;
+    if (facts?.invocation.operation.startsWith("stage_") && !facts.bootstrapStageStart && !facts.runId && !issuedRunId)
+        throw new AppError("invocation_assignment_missing", "Short lifecycle call has no unique issued RUN assignment; its workspace cannot be inferred", 1, { phase: "prepare", effect: "no_effect", recoverable: false });
+    const expected = controlledLifecycleCwd(context, projectRoot, facts, providerSessionId, auxiliary, issuedRunId);
+    // Unknown CLI targets have no assigned workspace. Recording their native
+    // observation must not turn the stable identity root into cwd authority.
+    if (!expected)
+        return undefined;
+    const route = facts?.invocation.expectedCwd ?? auxiliary?.expectedCwd;
+    if (route && resolveProjectRoot(route) !== expected)
+        throw new AppError("invocation_directory_mismatch", "Literal lifecycle route differs from the assigned workspace", 1, { expected, actual: route, actual_provenance: "shell_literal_route", phase: "prepare", effect: "no_effect", recoverable: false });
+    if (!route && observedCwd && resolveProjectRoot(observedCwd) !== expected)
+        throw new AppError("invocation_directory_mismatch", "Native lifecycle directory differs from the assigned workspace", 1, { expected, actual: observedCwd, actual_provenance: "native_tool_cwd", phase: "prepare", effect: "no_effect", recoverable: false });
+    // ACP without native cwd still binds assigned authority; CLI confirms the
+    // physical process directory, rather than inventing native observation.
+    return expected;
+}
 function controlledLifecycleCwd(context, projectRoot, facts, providerSessionId, auxiliary, issuedRunId) {
     if (facts?.bootstrapStageStart)
         return projectRoot;
     const project = context.db.get("SELECT id FROM projects WHERE root = ?", [projectRoot]);
     if (!project)
-        return projectRoot;
+        return undefined;
     if (facts?.invocation.operation === "merge_apply" || facts?.invocation.operation === "merge_repair") {
         const requestId = commandPosition(facts.invocation, 0);
         const request = requestId && context.db.get("SELECT target_workspace FROM merge_requests WHERE project_id = ? AND merge_request_id = ?", [project.id, requestId]);
@@ -716,13 +753,15 @@ function controlledLifecycleCwd(context, projectRoot, facts, providerSessionId,
             if (!(error instanceof AppError) || !["not_found", "ambiguous_work_alias"].includes(error.code))
                 throw error;
         }
+        if (!work)
+            return undefined;
     }
     const reference = work?.run_id ?? facts?.runId ?? auxiliary?.args.options.get("run")?.[0] ?? auxiliary?.args.positional[2] ?? issuedRunId;
     if (!reference)
-        return projectRoot;
+        return undefined;
     const run = context.db.get("SELECT id, run_root, workspace_root FROM runs WHERE project_id = ? AND (id = ? OR short_id = ?)", [project.id, reference, reference]);
     if (!run)
-        return projectRoot; // Hook ingress does not validate a mistyped CLI target.
+        return undefined; // Hook ingress does not validate a mistyped CLI target.
     if (work) {
         // PROTOCOLIZE provisions the feature checkout after its coordinator
         // Session has launched in the stable project root. Its transition Work
@@ -809,13 +848,17 @@ function handleControlledToolEvent(context, input, event, harness) {
     // Syntax refusal precedes assignment/cwd lookup: an unsupported AST cannot
     // supply a route or execution authority, including a short public Stage call.
     const shellRefusal = lifecycle?.analysis.supported === false;
+    const nativeIdentity = { daemonId, rootSessionId: nativeParentId ?? providerSessionId, sessionId: providerSessionId, parentSessionId: nativeParentId ?? null, toolCallId: toolCallId };
+    const provenScope = lifecycle && !shellRefusal ? managedNativeInvocationScope(context, expectedRoot, nativeIdentity, harness) : null;
     const issuedRunId = lifecycle && !lifecycle.runId && !lifecycle.workId && !lifecycle.bootstrapStageStart
-        ? observedLifecycleInvocation(context, command, daemonId)?.scope.runId : null;
+        ? observedLifecycleInvocation(context, command, provenScope ?? { projectRoot: expectedRoot, daemonId, rootSessionId: nativeIdentity.rootSessionId }, { identity: nativeIdentity })?.scope.runId : null;
     if (!shellRefusal && lifecycle && lifecycle.invocation.operation.startsWith("stage_") && !lifecycle.bootstrapStageStart && !lifecycle.runId && !issuedRunId) {
         throw new AppError("invocation_assignment_missing", "Short lifecycle call has no unique issued RUN assignment; its workspace cannot be inferred", 1, { effect: "no_effect", recoverable: false });
     }
-    const expectedCwd = shellRefusal ? observedCwd : controlledLifecycleCwd(context, expectedRoot, lifecycle, providerSessionId, auxiliary, issuedRunId);
-    const executionRoute = shellRefusal ? undefined : lifecycle?.invocation.expectedCwd;
+    // These controlled platforms additionally qualify their native launch
+    // route against the stable project root when no CLI target is assigned.
+    const expectedCwd = shellRefusal ? observedCwd : controlledLifecycleCwd(context, expectedRoot, lifecycle, providerSessionId, auxiliary, issuedRunId) ?? expectedRoot;
+    const executionRoute = shellRefusal ? undefined : lifecycle?.invocation.expectedCwd ?? auxiliary?.expectedCwd;
     if (executionRoute && resolveProjectRoot(executionRoute) !== expectedCwd) {
         throw new AppError(`${errorPrefix}_directory_mismatch`, "Literal shell cd route does not match the assigned lifecycle workspace", 1, { expected: expectedCwd, actual: executionRoute, actual_provenance: "shell_literal_route", effect: "no_effect", recoverable: false });
     }
@@ -854,13 +897,14 @@ function handleControlledToolEvent(context, input, event, harness) {
         return inserted;
     };
     const result = (inserted) => ({ ok: true, observed: inserted, duplicate: !inserted, event_key: baseKey, phase, harness, session: nativeSessionIdentity(harness, providerSessionId), ...(nativeParentId ? { parent_session: nativeSessionIdentity(harness, nativeParentId) } : {}), daemon_id: daemonId });
-    if ((agy || shellRefusal) && lifecycle) {
+    if (lifecycle) {
         let inserted = false;
         const receipt = observeLifecycleInvocation(context, {
-            command, harness, projectId: project.id, ...(!shellRefusal && (agy || executionRoute) ? { executionCwd: expectedCwd } : {}), identity: { daemonId, rootSessionId: nativeParentId ?? providerSessionId, sessionId: providerSessionId, parentSessionId: nativeParentId ?? null, toolCallId: toolCallId },
+            command, harness, projectId: project.id, ...(!shellRefusal ? { executionCwd: expectedCwd } : {}), identity: { daemonId, rootSessionId: nativeParentId ?? providerSessionId, sessionId: providerSessionId, parentSessionId: nativeParentId ?? null, toolCallId: toolCallId },
             recordReceipt: scope => { inserted = persist(scope); return baseKey; }
         });
-        return { ...result(inserted), ...(receipt.invocationId ? { invocation_id: receipt.invocationId } : {}) };
+        const admitted = { ...result(inserted), ...(receipt.invocationId ? { invocation_id: receipt.invocationId } : {}) };
+        return agy || shellRefusal ? admitted : { ...admitted, hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "allow", updatedInput: { ...rawInput, command: commandWithHookEvent(command, baseKey) } } };
     }
     const inserted = context.db.writeTransaction(() => persist());
     return agy ? result(inserted) : { ...result(inserted), hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "allow", updatedInput: { ...rawInput, command: commandWithHookEvent(command, baseKey) } } };
@@ -968,8 +1012,8 @@ export function analyzeLifecycleShellCommand(command, includeSessionRegister = f
 }
 function lifecycleFacts(command) {
     const analysis = parseLifecycleCommand(command);
-    if (analysis.kind === "none" && analysis.unresolved)
-        throw new AppError("lifecycle_shell_syntax_invalid", "Shell participation could not be proven; use a literal issued command", 1, { phase: "prepare", effect: "no_effect", recoverable: true, disposition: "pre_cli_shell_refusal", reason: analysis.reason });
+    if (analysis.kind === "none" && analysis.unresolved && ["lifecycle", "auxiliary"].includes(analysis.participation))
+        throw new AppError("lifecycle_shell_syntax_invalid", "Known lifecycle execution is unsupported; use a literal issued command", 1, { phase: "prepare", effect: "no_effect", recoverable: true, disposition: "pre_cli_shell_refusal", reason: analysis.reason });
     if (analysis.kind === "none")
         return null;
     const invocation = analysis.invocation;
@@ -1431,8 +1475,8 @@ function commandHook(command, statusMessage) {
 }
 function hookCommand(event) {
     const args = `codex hook handle --event ${event} --json`;
-    const handler = `if [ -n "\${DD_FLOW_BIN:-}" ]; then "$DD_FLOW_BIN" ${args}; else PATH="\${DD_FLOW_HOME:+\${DD_FLOW_HOME}/bin:}\${PATH}:\${HOME}/Library/pnpm:/opt/homebrew/bin:/usr/local/bin" dd-flow ${args}; fi`;
-    return `/bin/bash -c 'log_dir="\${DD_FLOW_HOME:-\${HOME}/.dd-flow}/logs"; mkdir -p "$log_dir"; log="$log_dir/codex-hook.log"; printf "%s event=${event} phase=start pid=%s\\n" "$(date -u +%Y-%m-%dT%H:%M:%SZ)" "$$" >>"$log"; ${handler} 2> >(tee -a "$log" >&2); status=$?; printf "%s event=${event} phase=finish pid=%s exit=%s\\n" "$(date -u +%Y-%m-%dT%H:%M:%SZ)" "$$" "$status" >>"$log"; exit "$status"'`;
+    const handler = `if [ -n "\${DD_FLOW_BIN:-}" ]; then "$DD_FLOW_BIN" ${args}; else dd-flow ${args}; fi`;
+    return `/bin/bash -c 'export PATH="\${DD_FLOW_HOME:+\${DD_FLOW_HOME}/bin:}\${PATH}:\${HOME}/Library/pnpm:/opt/homebrew/bin:/usr/local/bin"; log_dir="\${DD_FLOW_HOME:-\${HOME}/.dd-flow}/logs"; mkdir -p "$log_dir"; log="$log_dir/codex-hook.log"; printf "%s event=${event} phase=start pid=%s\\n" "$(date -u +%Y-%m-%dT%H:%M:%SZ)" "$$" >>"$log"; ${handler} 2> >(tee -a "$log" >&2); status=$?; printf "%s event=${event} phase=finish pid=%s exit=%s\\n" "$(date -u +%Y-%m-%dT%H:%M:%SZ)" "$$" "$status" >>"$log"; exit "$status"'`;
 }
 function resolveHookTarget(target) {
     if (!target || target === "isolated") {