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

package/dist/services/controller-result-authority.js

@@ -5,6 +5,7 @@ import { isObservationLoss } from "../harness-runtime/lib/operation-errors.mjs";
 import { terminalProviderRecovery } from "../harness-runtime/lib/provider-overload-policy.mjs";
 import { getVnextFanoutStatus } from "./vnext-fanout.js";
 import { normalizeNativeChildren, nativeTreeReadiness } from "../harness-runtime/lib/native-children.mjs";
+import { failureDecisionReady } from "./controller-work-failure.js";
 /** Disappearance from a truncated child list is not retirement evidence. */
 export function acceptedChildrenRetired(expected, receipt, sessionId, operationId) {
     const children = normalizeNativeChildren(receipt, sessionId);
@@ -37,16 +38,18 @@ export function acceptedTechnicalWorkControl(context, row, controlId) {
         const guard = context.db.get("SELECT recovery_id,generation,status,capture_path FROM run_recovery_guards WHERE project_id=? AND run_id=? ORDER BY generation DESC LIMIT 1", [row.project_id, row.run_id]);
         if (!guard || guard.recovery_id !== control.recovery_id || guard.status !== "sealed" || !guard.capture_path || guard.generation <= row.generation)
             return false;
-        const events = context.db.all("SELECT data_json FROM run_controller_events WHERE controller_id=? AND event_type='technical_dependency_paused' AND json_extract(data_json,'$.control_id')=?", [row.controller_id, controlId]);
-        if (events.length !== 1)
-            return false;
-        const event = JSON.parse(events[0].data_json);
-        if (event.schema_id !== "dd-flow/controller-dependency@1" || event.request_id !== control.request_id || event.generation !== row.generation || typeof event.source_operation_id !== "string")
-            return false;
+        const events = context.db.all("SELECT data_json FROM run_controller_events WHERE controller_id=? AND event_type='technical_dependency_paused' AND json_extract(data_json,'$.control_id')=?", [row.controller_id, controlId]).map(item => JSON.parse(item.data_json));
         const state = JSON.parse(row.state_json), session = state.current_session === null ? null : state.sessions?.[state.current_session];
-        if (!session?.id || !session.owner?.owner_id || event.state_dir !== session.state_dir)
+        if (!session?.id || !session.owner?.owner_id || !events.length || events.some(event => event.schema_id !== "dd-flow/controller-dependency@1"
+            || event.request_id !== control.request_id || event.generation !== row.generation || event.state_dir !== session.state_dir
+            || event.source_operation_id !== undefined && (typeof event.source_operation_id !== "string" || !event.source_operation_id)))
+            return false;
+        // Concurrent observers may add unbound notes to the same immutable control.
+        // They do not revoke one exact accepted source; conflicting sources still do.
+        const sources = [...new Set(events.flatMap(event => event.source_operation_id ? [event.source_operation_id] : []))];
+        if (sources.length !== 1)
             return false;
-        const op = context.db.get("SELECT generation,status,input_json FROM run_controller_operations WHERE controller_id=? AND operation_id=?", [row.controller_id, event.source_operation_id]);
+        const op = context.db.get("SELECT generation,status,input_json FROM run_controller_operations WHERE controller_id=? AND operation_id=?", [row.controller_id, sources[0]]);
         if (!op || op.generation !== row.generation || !["outcome_unknown", "completed"].includes(op.status))
             return false;
         const input = JSON.parse(op.input_json), expected = input.obligation;
@@ -84,6 +87,8 @@ export function controllerObligationAccepted(context, row, expected) {
     const stage = [...stages].reverse().find(item => item.stage === expected.stage && (item.attempt ?? "try-001") === expected.attempt);
     if (!stage || stageCycle(context, row.project_id, row.run_id, expected.stage) !== expected.cycle)
         return false;
+    if (expected.action === "failure_resolution")
+        return Boolean(expected.failure_resolution && failureDecisionReady(expected.failure_resolution));
     if (["done", "skipped"].includes(stage.status))
         return true;
     if (expected.action === "resume")

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

@@ -108,7 +108,7 @@ export function isRetryableLifecycleRejection(code, details = {}) {
         return details.recoverable !== false;
     if (["work_checks_failed", "code_gate_failed", "code_review_gate_failed", "merge_gate_failed"].includes(code))
         return Array.isArray(details.failures) && details.failures.length > 0 && details.failures.every(receipt => checkDiagnosisDisposition(receipt) === "diagnosis_required");
-    return details.recoverable === true || ["review_repair_incomplete", "plan_review_incomplete", "semantic_result_invalid",
+    return details.recoverable === true || ["work_contract_incomplete", "review_repair_incomplete", "plan_review_incomplete", "semantic_result_invalid",
         "review_evidence_invalid", "evidence_obligation_unknown", "invalid_evidence_ref",
         "evidence_ref_missing", "evidence_line_out_of_range", "document_update_missing",
         "document_update_not_materialized", "review_repair_no_change"].includes(code)
@@ -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") {
@@ -765,18 +776,23 @@ function invocationRecoverySnapshot(context, scope) {
 }
 /** Resolve authority, never reconstruct it from an old prompt or issue on read. */
 export function currentStageFinishCommand(context, stage) {
+    return currentStageFinishAuthority(context, stage)?.command ?? null;
+}
+/** Observation of an existing attempt is not permission to dispatch it again. */
+export function currentStageFinishAuthority(context, stage) {
     const scope = context.env.DD_FLOW_INVOCATION_SCOPE;
     if (!scope || !context.db.get("SELECT 1 FROM sqlite_master WHERE name='lifecycle_invocations'"))
         return null;
-    const rows = context.db.all("SELECT * FROM lifecycle_invocations WHERE scope_json = ? AND status = 'issued'", [scope])
+    const rows = context.db.all("SELECT * FROM lifecycle_invocations WHERE scope_json = ? AND status IN ('issued','observed','executing')", [scope])
         .filter(row => {
         const parsed = invocation(row.command);
-        return parsed.operation === "stage_finish" && commandOption(parsed, "stage") === stage
-            && (row.deadline === null || row.deadline > Date.now());
+        return parsed.operation === "stage_finish" && commandOption(parsed, "stage") === stage;
     });
     if (rows.length > 1)
         throw new AppError("invocation_ambiguous", "Stage has multiple current finish authorities", 1, { stage });
-    return rows[0] ? publicInvocationCommand(context, rows[0], rows[0].command) : null;
+    const row = rows[0];
+    return row ? { id: row.id, status: row.status, command: row.status === "issued" && (row.deadline === null || row.deadline > Date.now())
+            ? publicInvocationCommand(context, row, row.command) : null } : null;
 }
 export function managedInvocationContext(context, input) {
     const env = { ...context.env, DD_FLOW_CURRENT_INVOCATION: undefined, DD_FLOW_INVOCATION_SCOPE: undefined };
@@ -1876,7 +1892,8 @@ export function observedLifecycleInvocation(context, command, scopeConstraint, c
     const retainedId = suppliedId && context.db.get("SELECT id FROM lifecycle_invocations WHERE id = ?", [suppliedId]) ? suppliedId : undefined;
     // `issued` is a rendezvous, not authority: the CLI still blocks in
     // awaitLifecycleInvocation until the native observer commits the receipt.
-    const matching = context.db.all("SELECT * FROM lifecycle_invocations WHERE status IN ('issued','observed','executing','settled') ORDER BY rowid DESC")
+    const history = context.db.all("SELECT * FROM lifecycle_invocations WHERE status IN ('issued','observed','executing','settled') ORDER BY rowid DESC");
+    const matching = history
         .filter(row => {
         try {
             const explicitId = retainedId;
@@ -1896,7 +1913,7 @@ export function observedLifecycleInvocation(context, command, scopeConstraint, c
         }
     });
     const identity = correlation?.identity;
-    const matches = lifecycleCandidates(matching, identity ? JSON.stringify([identity.daemonId, identity.rootSessionId, identity.sessionId, identity.parentSessionId, identity.toolCallId]) : undefined, true);
+    const matches = lifecycleCandidates(matching, identity ? JSON.stringify([identity.daemonId, identity.rootSessionId, identity.sessionId, identity.parentSessionId, identity.toolCallId]) : undefined, true, history);
     if (!matches.length)
         return null;
     if (matches.length !== 1)
@@ -1905,8 +1922,9 @@ export function observedLifecycleInvocation(context, command, scopeConstraint, c
 }
 /** A new native call may consume a successor, but never a historical result.
  * Exact native delivery replays its immutable assignment. CLI lookup without
- * native correlation remains ambiguous when history and a successor coexist. */
-function lifecycleCandidates(rows, identity, lookup = false) {
+ * native correlation may use a uniquely bound committed successor, not an
+ * arbitrary newest/active row. Unrelated history remains ambiguous. */
+function lifecycleCandidates(rows, identity, lookup = false, history = rows) {
     if (identity) {
         const replay = rows.filter(row => {
             if (!row.identity_json)
@@ -1927,6 +1945,26 @@ function lifecycleCandidates(rows, identity, lookup = false) {
             return replay;
     }
     const active = rows.filter(row => row.status !== "settled");
+    if (lookup && !identity && active.length === 1 && (active[0].status === "issued" || active[0].identity_json && active[0].event_key)) {
+        const current = active[0];
+        const leadsToCurrent = (row, seen = new Set()) => {
+            if (row.id === current.id)
+                return true;
+            if (row.status !== "settled" || seen.has(row.id))
+                return false;
+            seen.add(row.id);
+            try {
+                const next = JSON.parse(row.outcome_json ?? "null")?.successor_invocation_id;
+                const successor = history.find(candidate => candidate.id === next && candidate.scope_json === current.scope_json);
+                return Boolean(successor && leadsToCurrent(successor, seen));
+            }
+            catch {
+                return false;
+            }
+        };
+        if (rows.every(row => leadsToCurrent(row)))
+            return active;
+    }
     return (!lookup || identity) && active.length ? active : rows;
 }
 /** Restore private assignment arguments without discarding the provider's
@@ -1961,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;
@@ -1971,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 };
@@ -1998,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;
         });
     }
@@ -2023,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);
@@ -2033,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
@@ -2157,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;
 }