@deksden-com/dd-flow-cli 0.9.0-beta.156 → 0.9.0-beta.158

package/dist/services/controller-work-failure.js

@@ -0,0 +1,198 @@
+import fs from "node:fs";
+import path from "node:path";
+import { AppError } from "../shared/errors.js";
+import { publishImmutableInput } from "../storage/immutable-input.js";
+import { prepareAgentOutputFile } from "../storage/agent-output.js";
+import { parseLifecycleCommand } from "./lifecycle-command.js";
+import { stageAttempt, stageCycle, stageWorkIds } from "./stage-work-graph.js";
+import { assertRunMutationAllowed } from "./run-recovery.js";
+import { appendEvent, digest } from "./run-controller-state.js";
+import { retryWork } from "./work-registry.js";
+import { blockStageForRuntime } from "./stage-blocker.js";
+import { pauseStageForUser } from "./stage-pause.js";
+/** SQL settlement provenance, never the worker's prose, distinguishes a semantic refusal. */
+export function explicitWorkFailure(context, projectId, runId, workId) {
+    const work = context.db.get("SELECT w.status,w.result,w.parent_work_id,w.payload_json,r.run_root FROM works w JOIN runs r ON r.project_id=w.project_id AND r.id=w.run_id WHERE w.project_id=? AND w.run_id=? AND w.work_id=?", [projectId, runId, workId]);
+    if (!work || work.status !== "failed" || !work.parent_work_id || work.result === null || !work.run_root)
+        return null;
+    const payload = JSON.parse(work.payload_json ?? "null");
+    if (typeof payload?.kind === "string" && /^(memory|interactive)/.test(payload.kind))
+        return null;
+    if (!context.db.get("SELECT 1 FROM sqlite_schema WHERE name='audit_events'") || !context.db.get("SELECT 1 FROM sqlite_schema WHERE name='lifecycle_invocations'"))
+        return null;
+    const resultHash = digestBytes(work.result);
+    const receipts = context.db.all(`SELECT a.payload_json,l.command,l.status AS invocation_status FROM audit_events a JOIN lifecycle_invocations l ON l.id=json_extract(a.payload_json,'$.invocation_id')
+    WHERE a.project_id=? AND a.event_type='lifecycle.work_settlement' AND json_extract(a.payload_json,'$.run_id')=? AND json_extract(a.payload_json,'$.work_id')=? ORDER BY a.rowid DESC`, [projectId, runId, workId]);
+    for (const row of receipts) {
+        const receipt = JSON.parse(row.payload_json), parsed = parseLifecycleCommand(row.command);
+        if (row.invocation_status !== "settled" || parsed.kind !== "standalone" || parsed.invocation.operation !== "work_fail" || receipt.result_sha256 !== resultHash || receipt.response?.status !== "failed")
+            continue;
+        if (!context.db.get("SELECT 1 FROM work_sessions WHERE id=? AND work_id=? AND status='failed'", [receipt.work_session_id, workId]))
+            continue;
+        return { work_id: workId, work_session_id: receipt.work_session_id, parent_work_id: work.parent_work_id, result_sha256: resultHash, primary_reason: work.result, result_ref: path.join(work.run_root, "works", workId, "result.json") };
+    }
+    return null;
+}
+import { createHash } from "node:crypto";
+const digestBytes = (text) => createHash("sha256").update(text).digest("hex");
+function events(context, row, type) {
+    return context.db.all(`SELECT e.data_json FROM run_controller_events e JOIN run_controllers c ON c.controller_id=e.controller_id WHERE c.project_id=? AND c.run_id=? AND e.event_type=? ORDER BY e.rowid`, [row.project_id, row.run_id, type]).map(e => JSON.parse(e.data_json));
+}
+export function prepareWorkFailureResolution(context, row, stage, failure) {
+    if (!stageWorkIds(context, row.project_id, row.run_id, stage).has(failure.work_id))
+        throw new AppError("work_failure_scope_changed", "Failed Work no longer belongs to this Stage", 1);
+    const current = explicitWorkFailure(context, row.project_id, row.run_id, failure.work_id);
+    if (!current || current.work_session_id !== failure.work_session_id || current.result_sha256 !== failure.result_sha256)
+        throw new AppError("work_failure_scope_changed", "Failed Work receipt changed before resolution", 1);
+    const attempt = stageAttempt(context, row.project_id, row.run_id, stage), cycle = stageCycle(context, row.project_id, row.run_id, stage);
+    const episode = digest([row.project_id, row.run_id, stage, attempt, cycle, failure.work_id, failure.work_session_id, failure.result_sha256]);
+    const run = context.db.get("SELECT run_root FROM runs WHERE project_id=? AND id=?", [row.project_id, row.run_id]);
+    const round = events(context, row, "work_failure_action_applied").filter(e => e.episode_id === episode).length;
+    const root = path.join(run.run_root, "work-failure-resolutions", episode, `round-${round}`);
+    const resolution = { ...failure, episode_id: episode, stage, attempt, cycle, decision_file: path.join(root, "decision-input.json"), accepted_file: path.join(root, "decision.json"), diagnostic_file: path.join(root, "failure.json"),
+        retry_used: events(context, row, "work_failure_action_reserved").some(e => e.action === "retry" && e.work_id === failure.work_id) };
+    fs.mkdirSync(root, { recursive: true });
+    publishImmutableInput(resolution.diagnostic_file, Buffer.from(JSON.stringify({ schema_id: "work-failure-context@1", ...failure, episode_id: episode, stage, attempt, cycle, packet: path.join(run.run_root, "works", failure.work_id, "starts") }, null, 2)), "work_failure_context_changed");
+    if (!fs.existsSync(resolution.decision_file)) {
+        prepareAgentOutputFile(resolution.decision_file);
+        fs.writeFileSync(resolution.decision_file, "", { flag: "wx", mode: 0o600 });
+    }
+    return resolution;
+}
+const text = (value) => typeof value === "string" && value.trim().length > 0;
+export function readFailureDecision(resolution) {
+    const file = fs.existsSync(resolution.accepted_file) ? resolution.accepted_file : resolution.decision_file;
+    const stat = fs.lstatSync(file);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 1024 * 1024)
+        throw new AppError("work_failure_decision_invalid", "Expected a regular decision JSON file", 2);
+    let value;
+    try {
+        value = JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch {
+        throw new AppError("work_failure_decision_invalid", "Write one complete decision JSON object", 2);
+    }
+    const keys = ["schema_id", "episode_id", "action", "reason", "evidence_refs", "correction", "blocker", "question"];
+    if (!value || Array.isArray(value) || typeof value !== "object" || Object.keys(value).some(k => !keys.includes(k)) || value.schema_id !== "work-failure-decision@1" || value.episode_id !== resolution.episode_id || !["retry", "block", "pause", "fail"].includes(value.action) || !text(value.reason) || !Array.isArray(value.evidence_refs) || !value.evidence_refs.length || !value.evidence_refs.every(text)
+        || value.action === "retry" && !text(value.correction) || value.action === "pause" && !text(value.question)
+        || value.action === "block" && (!value.blocker || !["engine", "harness", "environment"].includes(value.blocker.kind) || !text(value.blocker.code) || !text(value.blocker.summary) || typeof value.blocker.retryable !== "boolean" || Object.keys(value.blocker).some(k => !["kind", "code", "summary", "retryable"].includes(k)))
+        || value.action !== "retry" && value.correction !== undefined || value.action !== "pause" && value.question !== undefined || value.action !== "block" && value.blocker !== undefined)
+        throw new AppError("work_failure_decision_invalid", "Decision must match its episode and selected action", 2, { episode_id: resolution.episode_id });
+    return value;
+}
+export function failureDecisionReady(resolution) { try {
+    readFailureDecision(resolution);
+    return true;
+}
+catch {
+    return false;
+} }
+export function workFailureResolutionPrompt(resolution, diagnostic) {
+    return [`Resolve only the retained explicit worker refusal in ${resolution.diagnostic_file}. Read that complete file and its Work packet/results.`,
+        "Current implementation is a baseline, not a requirement. Necessary project-local cross-layer corrections are allowed within accepted scope; planned write areas are hints. A worker-authored stop condition cannot silently cancel accepted intent. Do not edit product files, call lifecycle commands, spawn children or run checks in this decision Turn.",
+        `Write the decision to this precreated absolute file: ${resolution.decision_file}. No other writes. Return after writing it.`,
+        `Use schema_id=work-failure-decision@1, episode_id=${resolution.episode_id}, action=retry|block|pause|fail, nonempty reason and evidence_refs[]. For retry include concrete correction; for block include blocker {kind:engine|harness|environment,code,summary,retryable:boolean}; for pause include question. No extra fields.`,
+        resolution.retry_used ? "The one automatic corrective attempt has already been consumed. Select block/pause/fail; another retry cannot be applied automatically." : "Select retry if the Work can be completed in accepted scope; a fresh worker receives your correction. Select pause only for genuinely missing user intent, block for a proven technical dependency, fail only for an explained terminal outcome.",
+        "An unsupported exact browser key sequence does not prove all UI work is impossible and selectOption is not keyboard evidence. Preserve unverified mandatory criteria and original requirements.", diagnostic ? `Correct only the rejected decision: ${diagnostic}` : ""].filter(Boolean).join("\n\n");
+}
+export function acceptFailureDecision(context, row, resolution, assertOwner) {
+    assertOwner();
+    const decision = readFailureDecision(resolution), bytes = Buffer.from(JSON.stringify(decision));
+    publishImmutableInput(resolution.accepted_file, bytes, "work_failure_decision_changed");
+    context.db.writeTransaction(() => { assertOwner(); if (!events(context, row, "work_failure_decision_accepted").some(e => e.decision_ref === resolution.accepted_file))
+        appendEvent(context, row.controller_id, "work_failure_decision_accepted", { episode_id: resolution.episode_id, work_id: resolution.work_id, decision_ref: resolution.accepted_file, decision }); });
+    return decision;
+}
+export function workFailureDiagnostic(resolution, decision) {
+    return { source: "explicit_work_failure", episode_id: resolution.episode_id, work_id: resolution.work_id, work_session_id: resolution.work_session_id, result_ref: resolution.diagnostic_file, primary_reason: resolution.primary_reason, ...(decision ? { disposition: decision } : {}) };
+}
+/** Repair file-before-event and mutation-before-ack crash windows before HITL delivery. */
+export async function reconcilePendingWorkFailure(context, row, state, continuationKind, projectRoot, assertOwner, writerSettled) {
+    const resolution = state.work_failure;
+    if (!resolution || resolution.deferred || !fs.existsSync(resolution.accepted_file) || continuationKind === "terminal")
+        return "none";
+    const session = state.current_session === null ? undefined : state.sessions[state.current_session];
+    if (!session)
+        throw new AppError("work_failure_scope_changed", "Failure resolution lost its coordinator", 1);
+    if (!await writerSettled(session))
+        return "waiting";
+    const decision = acceptFailureDecision(context, row, resolution, assertOwner);
+    applyWorkFailureDecision(context, row, resolution, decision, projectRoot, assertOwner);
+    delete state.work_failure;
+    state.last_continuation = null;
+    return "applied";
+}
+/** Reserve first; a committed retry is recovered through its start authority, never replayed blindly. */
+export function applyWorkFailureDecision(context, row, resolution, decision, projectRoot, assertOwner) {
+    assertOwner();
+    assertRunMutationAllowed(context, row.project_id, row.run_id, row.generation);
+    const index = JSON.parse(context.db.get("SELECT index_json FROM runs WHERE project_id=? AND id=?", [row.project_id, row.run_id])?.index_json ?? "{}");
+    if (resolution.stage !== index.current_stage
+        || resolution.attempt !== stageAttempt(context, row.project_id, row.run_id, resolution.stage) || resolution.cycle !== stageCycle(context, row.project_id, row.run_id, resolution.stage)
+        || !stageWorkIds(context, row.project_id, row.run_id, resolution.stage).has(resolution.work_id))
+        throw new AppError("work_failure_scope_changed", "Failure resolution belongs to a stale Stage attempt", 1);
+    const applied = events(context, row, "work_failure_action_applied").find(e => e.decision_ref === resolution.accepted_file);
+    if (applied)
+        return applied;
+    const reserved = events(context, row, "work_failure_action_reserved").find(e => e.decision_ref === resolution.accepted_file);
+    const current = context.db.get("SELECT status,current_start_invocation_id FROM works WHERE project_id=? AND run_id=? AND work_id=?", [row.project_id, row.run_id, resolution.work_id]);
+    if (!current)
+        throw new AppError("work_failure_scope_changed", "Work disappeared before resolution", 1);
+    let action = decision.action;
+    const used = events(context, row, "work_failure_action_reserved").some(e => e.action === "retry" && e.work_id === resolution.work_id && e.decision_ref !== resolution.accepted_file);
+    const retainedDecision = events(context, row, "work_failure_decision_accepted").find(e => e.decision_ref === resolution.accepted_file);
+    if (!retainedDecision || JSON.stringify(retainedDecision.decision) !== JSON.stringify(decision))
+        throw new AppError("work_failure_scope_changed", "Failure decision was not accepted or changed after acceptance", 1);
+    const exhausted = action === "retry" && used;
+    if (exhausted)
+        action = "block";
+    if (!reserved) {
+        if (current.status !== "failed" || explicitWorkFailure(context, row.project_id, row.run_id, resolution.work_id)?.work_session_id !== resolution.work_session_id)
+            throw new AppError("work_failure_scope_changed", "Failure changed before action reservation", 1);
+        context.db.writeTransaction(() => { assertOwner(); appendEvent(context, row.controller_id, "work_failure_action_reserved", { episode_id: resolution.episode_id, work_id: resolution.work_id, work_session_id: resolution.work_session_id, action, decision_ref: resolution.accepted_file }); });
+    }
+    else if (reserved.action !== action)
+        throw new AppError("work_failure_scope_changed", "Reserved failure action differs", 1);
+    let receipt;
+    if (action === "retry") {
+        receipt = retryWork(context, resolution.work_id, decision.reason, { episode_id: resolution.episode_id, decision_ref: resolution.accepted_file, correction: decision.correction, failed_result_sha256: resolution.result_sha256 });
+    }
+    else if (action === "fail")
+        throw new AppError("work_failure_unresolved", decision.reason, 1, workFailureDiagnostic(resolution, decision));
+    else {
+        const coordinator = context.db.get("SELECT status FROM works WHERE project_id=? AND run_id=? AND work_id=?", [row.project_id, row.run_id, resolution.parent_work_id]);
+        const blocker = exhausted ? { kind: "engine", code: "work_resolution_exhausted", summary: JSON.stringify(workFailureDiagnostic(resolution, decision)), retryable: false } : decision.blocker;
+        const boundBlocker = blocker ? { ...blocker, summary: `${blocker.summary}\n[work-failure:${resolution.episode_id}:${digest(resolution.accepted_file)}]` } : undefined;
+        if (coordinator?.status === "paused" && reserved) {
+            const stage = index.stage_runs?.find((s) => s.stage === resolution.stage);
+            const matches = action === "pause" ? stage?.pause?.work_id === resolution.parent_work_id && typeof stage.pause.question_path === "string" && fs.readFileSync(stage.pause.question_path, "utf8") === decision.question
+                : stage?.blocker?.work_id === resolution.parent_work_id && stage.blocker.code === boundBlocker?.code && stage.blocker.kind === boundBlocker?.kind && stage.blocker.summary === boundBlocker?.summary;
+            if (!matches)
+                throw new AppError("work_failure_scope_changed", "Coordinator pause belongs to another failure action", 1);
+            receipt = { ok: true, reconciled: true, outcome: action === "pause" ? "paused" : "blocked", run_id: row.run_id, stage: resolution.stage, work_id: resolution.parent_work_id, ...(boundBlocker ? { blocker: boundBlocker } : {}) };
+        }
+        else {
+            if (coordinator?.status !== "running")
+                throw new AppError("work_failure_scope_changed", "Failure resolution needs the running coordinator Work", 1);
+            const scope = { projectRoot, runId: row.run_id, stage: resolution.stage, workId: resolution.parent_work_id };
+            receipt = action === "pause" ? pauseStageForUser(context, { ...scope, question: decision.question }) : blockStageForRuntime(context, { ...scope, ...boundBlocker });
+        }
+    }
+    const outcome = { episode_id: resolution.episode_id, decision_ref: resolution.accepted_file, stage: resolution.stage, attempt: resolution.attempt, cycle: resolution.cycle, work_id: resolution.work_id, work_session_id: resolution.work_session_id, action, receipt };
+    context.db.writeTransaction(() => { assertOwner(); appendEvent(context, row.controller_id, "work_failure_action_applied", outcome); });
+    return outcome;
+}
+/** Match only this current bound block; an old unrelated pause must not be hidden. */
+export function workFailureBlockActive(context, row, index) {
+    const stage = index.current_stage;
+    const blocker = index.stage_runs?.find(s => s.stage === stage)?.blocker;
+    if (!stage || !blocker)
+        return false;
+    return events(context, row, "work_failure_action_applied").some(e => {
+        const receipt = e.receipt;
+        if (!receipt)
+            return false;
+        return e.action === "block" && e.stage === stage && e.attempt === stageAttempt(context, row.project_id, row.run_id, stage) && e.cycle === stageCycle(context, row.project_id, row.run_id, stage)
+            && receipt?.work_id === blocker.work_id && receipt.blocker?.summary === blocker.summary && receipt.blocker?.code === blocker.code && receipt.blocker?.kind === blocker.kind;
+    });
+}

package/dist/services/lifecycle-invocations.js

@@ -600,6 +600,9 @@ export function observeLifecycleCommand(context, command, nativeEvent) {
                 }
                 if (error && parsed.kind === "standalone" && hookOnlyCorrection && error.details.recoverable !== false) {
                     const signature = preparationRejectionSignature(new AppError(error.code, error.message, 1, error.details));
+                    const inputKey = preparationInputKey(parsed.invocation, error.details);
+                    if (inputKey)
+                        error.details.input_key = inputKey;
                     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') = ?
@@ -607,8 +610,9 @@ export function observeLifecycleCommand(context, command, nativeEvent) {
           AND json_extract(outcome_json, '$.harness') = ? AND json_extract(outcome_json, '$.session_id') = ?
           AND json_type(outcome_json, '$.stage') IS NOT NULL AND json_type(outcome_json, '$.attempt') IS NOT NULL
           AND json_extract(outcome_json, '$.stage') IS ? AND json_extract(outcome_json, '$.attempt') IS ?
-          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, correlationKey,
-                        anchor.harness, anchor.session_id, anchor.stage ?? null, anchor.attempt ?? null, signature]);
+          AND json_extract(outcome_json, '$.error.details.hook_retry_signature') = ?
+          AND (? IS NULL OR json_extract(outcome_json, '$.error.details.input_key') = ?) LIMIT 1`, [anchor.project_id, anchor.hook_event_id, anchor.run_id, anchor.generation, anchor.operation, correlationKey,
+                        anchor.harness, anchor.session_id, anchor.stage ?? null, anchor.attempt ?? null, signature, inputKey ?? null, inputKey ?? null]);
                     if (!repeated) {
                         const argv = parsed.invocation.argv.filter((value, index, all) => !/^--(?:hook-event-id|invocation-id)(?:=|$)/.test(value)
                             && !/^--(?:hook-event-id|invocation-id)$/.test(all[index - 1] ?? ""));
@@ -619,8 +623,15 @@ export function observeLifecycleCommand(context, command, nativeEvent) {
                     }
                     else {
                         error.details.recoverable = false;
-                        error.details.repeated_without_progress = true;
-                        record.disposition = "fatal";
+                        delete error.details.retry_command;
+                        delete error.details.retry_instruction;
+                        if (inputKey)
+                            error.details.repeated_without_progress = true;
+                        else
+                            error.details.input_binding_unavailable = true;
+                        // An unread file is not evidence of unchanged contents. Withhold
+                        // automatic correction locally; do not turn that ignorance into fatal.
+                        record.disposition = inputKey ? "fatal" : "pending_continuation";
                     }
                 }
                 if (error && !auxiliary && record.disposition === "fatal") {
@@ -1988,6 +1999,8 @@ export function resolveObservedLifecycleArgs(context, id, actualArgs) {
             const inline = argv.findIndex(value => value.startsWith(`--${publicKey}=`));
             if (inline >= 0)
                 argv[inline] = `--${publicKey}=${commandOption(actual, publicKey)}`;
+            else
+                argv.push(`--${publicKey}`, commandOption(actual, publicKey));
         }
     }
     return argv;
@@ -1998,24 +2011,47 @@ 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 command = commandWithObservedWorkSemantics(row, argv);
+    if (command === row.command)
+        return;
+    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 });
+    }
+}
+function commandWithObservedWorkSemantics(row, argv) {
     const parsed = invocation(row.command);
     if (!["work_fail", "work_finish"].includes(parsed.operation))
-        return;
+        return row.command;
     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}` : ""}`;
+    // CLI dispatch removes presentation options. Update only the public semantic
+    // value, retaining the issued transport, response destination and shell suffix.
+    const actual = invocation(`${executable} ${quote(argv)}`);
+    const semanticKey = parsed.operation === "work_fail" ? "reason" : "result-file";
+    const retainedArgs = [...parsed.argv];
+    const value = commandOption(actual, semanticKey);
+    if (value !== undefined) {
+        const index = retainedArgs.findIndex(arg => arg === `--${semanticKey}` || arg.startsWith(`--${semanticKey}=`));
+        if (index >= 0) {
+            if (retainedArgs[index] === `--${semanticKey}`)
+                retainedArgs[index + 1] = value;
+            else
+                retainedArgs[index] = `--${semanticKey}=${value}`;
+        }
+        else
+            retainedArgs.push(`--${semanticKey}`, value);
+    }
+    const command = `${prefix ? `${prefix} ` : ""}${executable} ${quote(retainedArgs)}${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 });
-    }
+    return command;
 }
-export function settleLifecyclePreparationRejection(context, id, error) {
+export function settleLifecyclePreparationRejection(context, id, error, preparedCommand) {
     delete error.details.retry_command;
     delete error.details.retry_instruction;
     try {
         return context.db.writeTransaction(() => {
-            const row = load(context, id);
+            let row = load(context, id);
             if (row.status === "settled") {
                 const details = row.outcome_json ? JSON.parse(row.outcome_json)?.error?.details : undefined;
                 return details?.effect === "no_effect" && details.retry_command ? details : { effect: "unknown", recoverable: false };
@@ -2025,22 +2061,41 @@ export function settleLifecyclePreparationRejection(context, id, error) {
             const scope = JSON.parse(row.scope_json);
             if (scope.runId)
                 assertLifecycleInvocationCurrent(context, scope, row.command);
+            if (preparedCommand) {
+                // Only a command already validated before preparation may retain public
+                // Work inputs. This records a no-effect refusal, not admission to execute.
+                checkCommand(row, preparedCommand);
+                const command = commandWithObservedWorkSemantics(row, invocation(preparedCommand).argv);
+                if (command !== row.command)
+                    context.db.run("UPDATE lifecycle_invocations SET command = ?, updated_at = ? WHERE id = ?", [command, context.now(), row.id]);
+                row = { ...row, command };
+            }
+            const parsed = invocation(row.command);
+            if (parsed.operation === "work_finish" && !error.details.work_id) {
+                try {
+                    error.details.work_id = resolveWorkReference(context, commandPosition(parsed, 0) ?? "", { ...(scope.runId ? { runId: scope.runId } : {}) }).work_id;
+                }
+                catch { /* An unresolved target remains its original local preparation error. */ }
+            }
             const signature = preparationRejectionSignature(error);
+            const inputKey = preparationInputKey(parsed, error.details);
             const repeated = context.db.all("SELECT outcome_json FROM lifecycle_invocations WHERE scope_json = ? AND fingerprint = ? AND id <> ? AND status = 'settled'", [row.scope_json, row.fingerprint, row.id])
                 .some(prior => { try {
-                return JSON.parse(prior.outcome_json ?? "null")?.error?.details?.rejection_signature === signature;
+                const details = JSON.parse(prior.outcome_json ?? "null")?.error?.details;
+                return details?.rejection_signature === signature && (!inputKey || details.input_key === inputKey);
             }
             catch {
                 return false;
             } });
             const retryable = !repeated && isRetryableLifecycleRejection(error.code, error.details);
-            const details = { ...error.details, effect: "no_effect", recoverable: retryable, rejection_signature: signature,
+            const details = { ...error.details, effect: "no_effect", recoverable: retryable, rejection_signature: signature, ...(inputKey ? { input_key: inputKey } : {}),
                 ...(repeated ? { repeated_without_progress: true } : {}),
                 ...(retryable ? {
                     retry_command: successorLifecycleInvocationCommand(context, row),
                     retry_instruction: "Correct the reported input, then execute retry_command verbatim in this same Session. The rejected call changed no lifecycle state."
                 } : {}) };
-            context.db.run("UPDATE lifecycle_invocations SET status = 'settled', outcome_json = ?, updated_at = ? WHERE id = ?", [JSON.stringify({ error: { ...errorRecord(error), details } }), context.now(), row.id]);
+            const successor = typeof details.retry_command === "string" ? currentIssuedCommand(context, row.scope_json, details.retry_command, row.id) : null;
+            context.db.run("UPDATE lifecycle_invocations SET status = 'settled', outcome_json = ?, updated_at = ? WHERE id = ?", [JSON.stringify({ error: { ...errorRecord(error), details }, ...(successor ? { successor_invocation_id: successor.id } : {}) }), context.now(), row.id]);
             return details;
         });
     }
@@ -2050,7 +2105,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", "hook_retry_signature", "event_key", "tool_call_id", "controller_turn", "timestamp", "created_at", "updated_at", "repeated_without_progress", "recoverable"]);
+    const omitted = new Set(["retry_command", "retry_instruction", "invocation_id", "hook_event_id", "rejection_signature", "hook_retry_signature", "event_key", "tool_call_id", "controller_turn", "timestamp", "created_at", "updated_at", "repeated_without_progress", "recoverable", "input_key", "input_sha256", "consumed_input_sha256"]);
     const normalize = (value) => {
         if (Array.isArray(value))
             return value.map(normalize);
@@ -2060,6 +2115,16 @@ function preparationRejectionSignature(error) {
     };
     return crypto.createHash("sha256").update(JSON.stringify([error.code, normalize(error.details)])).digest("hex");
 }
+function preparationInputKey(parsed, details) {
+    const publicParsed = invocation(`${launchExpression(parsed)} ${quoteModelFacingArgs(publicInvocationArgs(parsed))}`);
+    const options = [...publicParsed.args.options].filter(([key]) => !["invocation-id", "hook-event-id", "json", "progress-jsonl", "response-file"].includes(key)).sort(([a], [b]) => a.localeCompare(b));
+    const digest = details.consumed_input_sha256 ?? details.input_sha256;
+    const consumed = typeof digest === "string" && /^[a-f0-9]{64}$/.test(digest) ? digest : undefined;
+    // No file read in this layer: an unread body cannot prove unchanged input.
+    if (!consumed && options.some(([key]) => /(?:-file|-stdin)$/.test(key) || key === "data"))
+        return undefined;
+    return crypto.createHash("sha256").update(JSON.stringify([parsed.operation, publicParsed.args.positional, options, consumed ?? null])).digest("hex");
+}
 export function currentLifecycleFailure(context, input) {
     if (input.turn !== undefined) {
         const hooks = context.db.all(`SELECT id, outcome_json FROM hook_events
@@ -2184,7 +2249,7 @@ export async function awaitLifecycleInvocation(context, input) {
                 ? error.details.recoverable !== false
                 : isRetryableLifecycleRejection(error.code, details);
             Object.assign(error.details, { phase: "prepare", effect: "no_effect", recoverable });
-            Object.assign(error.details, settleLifecyclePreparationRejection(context, input.id, error));
+            Object.assign(error.details, settleLifecyclePreparationRejection(context, input.id, error, input.command));
             throw error;
         }
     }

package/dist/services/managed-daemon-binding.js

@@ -2,6 +2,21 @@ import fs from "node:fs";
 import path from "node:path";
 import { AppError } from "../shared/errors.js";
 import { managedProcessRuntimeHome, managedProcessStatus, processTreeIsAlive } from "./managed-processes.js";
+function retainedResourceStopped(resource, daemonId) {
+    if (resource.state !== "stopped" || resource.observation_conflict)
+        return false;
+    if (resource.native_retirement?.method)
+        return true;
+    // Completed native tasks retain an ordered terminal envelope, not a later
+    // stop-RPC receipt. Requiring that RPC after provider exit loses valid proof.
+    const source = resource.native_source, terminal = resource.terminal_source;
+    return Boolean(daemonId && resource.owner_daemon_id === daemonId
+        && resource.provider_session_id && resource.resource_id?.startsWith(`${resource.provider_session_id}/task-`)
+        && source?.locator && source.locator === terminal?.locator
+        && /^[a-f0-9]{64}$/.test(source.sha256 ?? "") && /^[a-f0-9]{64}$/.test(terminal?.sha256 ?? "")
+        && Number.isSafeInteger(source.step_index) && source.step_index >= 0
+        && Number.isSafeInteger(terminal?.step_index) && terminal.step_index > source.step_index);
+}
 /** Native execution and AGY's potentially scheduled writers are separate facts. */
 export function managedExecutionReusable(state, harness) {
     const shutdown = state.shutdown, result = shutdown?.result;
@@ -85,5 +100,30 @@ export function managedDaemonExecutionAbsent(context, input) {
         if (!provider || !managedProviderBelongsToDaemon(provider, binding.process, binding.state))
             return false;
     }
+    // The registry leaders are not the entire native inventory: retain detached
+    // tools and schedules even after their provider endpoint disappears.
+    if (binding.state.native_topology_error || binding.state.native_retirement_notifications?.some(notice => notice.disposition !== "after_owned_native_stop" || notice.owner_daemon_id !== (binding.state.daemon_id ?? binding.state.config?.daemonId)
+        || !Number.isSafeInteger(notice.generation) || notice.revision !== binding.state.native_execution_revision))
+        return false;
+    const nativeResources = [...(binding.state.native_resources_entries ?? []), ...(binding.state.shutdown?.result?.native_resources?.entries ?? [])];
+    const retained = [...(binding.state.owned_processes ?? []), ...(binding.state.shutdown?.owned_processes ?? []),
+        ...nativeResources.filter(resource => resource.pid !== undefined || !retainedResourceStopped(resource, binding.state.daemon_id ?? binding.state.config?.daemonId))];
+    if (nativeResources.some(resource => resource.observation_conflict || resource.owner_daemon_id !== undefined
+        && resource.owner_daemon_id !== (binding.state.daemon_id ?? binding.state.config?.daemonId)))
+        return false;
+    for (const process of retained) {
+        if (!Number.isSafeInteger(process.pid) || process.pid <= 0 || typeof process.started !== "string" || !process.started.trim())
+            return false;
+        if (records.some(record => record.pid === process.pid && record.pid_started_at === process.started))
+            continue;
+        try {
+            globalThis.process.kill(process.pid, 0);
+            return false;
+        }
+        catch (error) {
+            if (error.code !== "ESRCH")
+                return false;
+        }
+    }
     return true;
 }

package/dist/services/run-control.js

@@ -302,16 +302,19 @@ async function reconcileOwnedSessions(context, input, interrupt, boundary) {
         // 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))) {
+        let absenceVersion;
+        if ((boundary || technicalPause || control?.action === "stop") && !interrupt && !conflicts.has(directory) && !unsafeDaemons.has(canonicalPath(directory, false))) {
             try {
-                executionAbsent = managedDaemonExecutionAbsent(physicalContext, { stateDir: directory, projectId: project.id, runId: input.runId });
+                absenceVersion = nativeInventoryVersion(directory);
+                executionAbsent = managedDaemonExecutionAbsent(physicalContext, { stateDir: directory, projectId: project.id, runId: input.runId })
+                    && absenceVersion === nativeInventoryVersion(directory);
             }
             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));
+                nativeVersions.set(directory, absenceVersion);
                 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)) });
@@ -320,34 +323,6 @@ async function reconcileOwnedSessions(context, input, interrupt, boundary) {
                 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")
-            try {
-                const daemonId = state.daemon_id ?? state.config?.daemonId;
-                const daemon = records.filter(record => record.kind.endsWith("-daemon"));
-                const provider = records.filter(record => record.kind.endsWith("-provider"));
-                const operations = retainedDaemonOperations(directory);
-                const owner = state.config?.runtime_owner;
-                if (daemonId && !conflicts.has(directory) && !unsafeDaemons.has(canonicalPath(directory, false))
-                    && state.active_tree === false && !state.active_operation && state.shutdown?.daemon_id === daemonId
-                    && state.shutdown.phases?.tree === true && state.shutdown.phases.provider === true
-                    && daemon.length === 1 && provider.length === 1 && records.length === 2
-                    && daemon[0].id === state.resource_process?.id && daemon[0].lease_token === state.resource_process.lease_token && daemon[0].pid === state.pid
-                    && provider[0].id === state.provider_process?.id && provider[0].lease_token === state.provider_process.lease_token && provider[0].pid === state.provider_pid
-                    && JSON.parse(daemon[0].metadata_json).dispatch_barrier === "run-generation@1"
-                    && records.every(record => record.pid && record.pid_started_at && ["stopped", "failed"].includes(record.state) && record.finished_at && !processTreeIsAlive(record))
-                    && operations.length > 0 && operations.every(operation => ["completed", "failed", "interrupted"].includes(String(operation.state))
-                    && (operation.operation === "daemon.start" ? operation.daemon_id === null && operation.launch?.runtime_owner === JSON.stringify(owner)
-                        : operation.daemon_id === daemonId && ["daemon.stop", "daemon.status", "session.create", "session.prompt", "session.start", "session.fork", "session.resume", "session.cancel", "session.inspect"].includes(String(operation.operation))
-                            && (operation.session_id == null || state.sessions.some(item => (typeof item === "string" ? item : adapterSessionId(item)) === operation.session_id))))) {
-                    nativeVersions.set(directory, nativeInventoryVersion(directory, operations));
-                    closedDaemons.set(directory, { source: "observed_owned_retirement", daemon_id: daemonId, stopped: true, settled: true,
-                        session_ids: state.sessions.map(item => typeof item === "string" ? item : adapterSessionId(item)),
-                        processes: records.map(record => ({ process_id: record.id, pid: record.pid, pid_started_at: record.pid_started_at })) });
-                }
-            }
-            catch { /* Invalid or unfinished evidence remains on the existing recovery path. */ }
         if (!interrupt) {
             try {
                 const nativeOperations = retainedDaemonOperations(directory);
@@ -477,10 +452,17 @@ 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)
+            if (control?.action === "stop" && closedDaemons.get(saved.state_dir)?.source === "owned_execution_absent"
+                && (!["session.create", "session.prompt", "session.start", "session.fork", "session.cancel", "session.resume", "session.inspect", "daemon.start", "daemon.stop"].includes(method)
+                    || !args.includes("--state-dir") || args[args.indexOf("--state-dir") + 1] !== saved.state_dir
+                    || args.includes("--session-id") && !targets.has(JSON.stringify([saved.state_dir, args[args.indexOf("--session-id") + 1]]))))
+                throw new AppError("controller_operation_binding_unknown", "Fenced operation differs from its retained runtime scope", 1);
+            if ((boundary || technicalPause || control?.action === "stop") && closedDaemons.get(saved.state_dir)?.source === "owned_execution_absent"
+                && (control?.action === "stop" || ["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 } };
+                // This completes the settlement observation, not the original unknown
+                // operation. Its retained row/effect remains unknown and is not replayed.
+                return { operation_id: operation.operation_id, status: "completed", receipt: { source: control?.action === "stop" ? "fenced_stop_execution_absent" : "accepted_boundary_execution_absent", native_outcome: "unavailable", original_operation_status: operation.status, semantic_outcome_accepted: false, 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);
@@ -733,7 +715,7 @@ async function reconcileOwnedSessions(context, input, interrupt, boundary) {
         // remaining idempotent resource finish. Unknown outcomes keep their ID.
         if (sessionsSettled) {
             const remainingFinish = state.shutdown_state === "cleanup_failed" && state.active_tree === false
-                && state.shutdown?.daemon_id === daemonId && state.shutdown.phases?.tree === true
+                && state.shutdown?.daemon_id === daemonId && state.shutdown.phases?.execution === true
                 && state.shutdown.required_phases?.includes("daemon_resource")
                 && state.shutdown.phases.daemon_resource !== true
                 && state.shutdown.required_phases.every(phase => phase === "daemon_resource" || state.shutdown.phases[phase] === true);
@@ -922,7 +904,7 @@ async function reconcileOwnedSessions(context, input, interrupt, boundary) {
 }
 export function nativeInventoryVersion(directory, operations = retainedDaemonOperations(directory)) {
     const state = JSON.parse(fs.readFileSync(path.join(directory, "daemon.json"), "utf8"));
-    const keys = ["schema_id", "daemon_id", "config", "pid", "provider_pid", "shutdown_state", "shutdown", "active_operation", "active_tree", "sessions", "descendants", "root_session_id", "resource_process", "provider_process", "owned_processes"];
+    const keys = ["schema_id", "daemon_id", "config", "pid", "provider_pid", "shutdown_state", "shutdown", "active_operation", "active_tree", "sessions", "descendants", "root_session_id", "resource_process", "provider_process", "owned_processes", "native_execution_revision", "unclaimed_activity", "native_resources_entries", "native_topology_error", "native_retirement_notifications", "terminal_observation_pending", "tool_observation_gaps"];
     // Only these native verbs are read-only. Unknown verbs remain guarded.
     const productive = operations.filter(operation => !isObservationOperation(operation.operation));
     const knownSchema = ["dd-opencode/daemon-state@2", "dd-codex/daemon-state@1", "dd-grok/daemon-state@1", "dd-zcode/daemon-state@1", "dd-agy/daemon-state@1", "dd-droid/daemon-state@1"].includes(String(state.schema_id));