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

package/dist/services/review-fix-handoff.js

@@ -0,0 +1,82 @@
+import { createHash } from "node:crypto";
+import { AppError } from "../shared/errors.js";
+import { resolveProjectRoot } from "../storage/paths.js";
+import { requireProjectByRoot } from "./projects.js";
+import { readFlowRunExecutionBundle } from "./runs.js";
+import { readAcceptedStageData } from "./stage-report-renderer.js";
+import { readReviewFixSourceIntake, assertReviewFixSourceIntakeCustody } from "./review-fix-intake-custody.js";
+import { readPreparedMemoryFlowUserInputs } from "./memory-flow-user-inputs.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { assertReviewFixStageScope, validateReviewFixStageResult } from "./review-fix-stage-results.js";
+function refuse(reason) {
+    throw new AppError("review_fix_handoff_invalid", "Handoff requires accepted scope review and unchanged original user inputs", 2, { reason, effect: "no_effect" });
+}
+/** Prepare an SQL-fenced raw packet for the ordinary Stage settlement writer.
+ * No files, RUNs, PRTs or specifications are created. A ready scope is not
+ * authorization to formalize; the user must separately request that action.
+ */
+export function prepareReviewFixHandoff(context, input) {
+    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
+    const scope = { projectId: project.id, runId: input.runId };
+    const bundle = readFlowRunExecutionBundle(context, input);
+    if (!bundle || bundle.manifest.flow_id !== "review-fix")
+        refuse("review_fix_bundle_required");
+    const source = readReviewFixSourceIntake(context, input, bundle);
+    const read = (reader) => {
+        const intake = readAcceptedStageData(reader, { ...scope, stage: "intake" });
+        const reviewed = readAcceptedStageData(reader, { ...scope, stage: "scope-review" });
+        const users = readPreparedMemoryFlowUserInputs(reader, scope, "review-fix", bundle);
+        return { intake, reviewed, users };
+    };
+    const original = context.db.readSnapshot(() => read(context));
+    let prior;
+    try {
+        prior = JSON.parse(original.intake.bytes.toString("utf8"));
+    }
+    catch {
+        return refuse("accepted_intake_invalid");
+    }
+    if (original.intake.data_schema_id !== "dd-flow/review-fix-stage-result@1"
+        || original.reviewed.data_schema_id !== "dd-flow/review-fix-stage-result@1"
+        || prior?.schema_id !== "dd-flow/review-fix-stage-result@1" || prior.flow_id !== "review-fix"
+        || prior.run_id !== input.runId || prior.stage !== "intake" || prior.intake_sha256 !== source.sha256
+        || prior.input_sha256 !== original.intake.input_sha256 || !original.reviewed.input_sha256)
+        refuse("accepted_intake_invalid");
+    const reviewed = validateReviewFixStageResult(original.reviewed.bytes, bundle.descriptor.stageBlob("scope-review", "result_schema"), {
+        runId: input.runId, stage: "scope-review", inputSha256: original.reviewed.input_sha256, intakeSha256: source.sha256,
+        snapshotSha256: prior.snapshot_sha256, userInputsSha256: hybridDigest(original.users),
+        findingIds: source.intake.selected_findings.map(finding => finding.id),
+        predecessors: [{ stage: "intake", ...original.intake.result }],
+        userSources: original.users.sources.map(item => {
+            if (!["request", "question", "answer"].includes(item.role))
+                return refuse("invalid_user_input_role");
+            return { root: item.root, path: item.path, sha256: item.sha256, role: item.role };
+        })
+    });
+    assertReviewFixStageScope(reviewed, prior);
+    const disposition = reviewed.details.review.some(item => item.verdict === "revise") ? "needs_scope"
+        : reviewed.details.decisions.some(item => item.disposition === "approved") ? "ready"
+            : reviewed.details.decisions.some(item => item.disposition === "deferred") ? "deferred" : "declined";
+    const bytes = Buffer.from(JSON.stringify({ schema_id: "dd-flow/review-fix-handoff@1", run_id: input.runId,
+        disposition, formalization_authorized: false, next_entry: disposition === "ready" ? "vnext/start.md" : null,
+        source_intake: source.intake, user_inputs: original.users,
+        scope: reviewed.details, accepted_review: { ...original.reviewed.result, authority_sha256: original.reviewed.authority_sha256 }
+    }));
+    // Keep this packet within the existing Stage reader envelope; never truncate
+    // original messages or findings to make an oversized handoff appear valid.
+    if (bytes.length > 4 * 1024 * 1024)
+        refuse("handoff_exceeds_bound");
+    return {
+        path: `${bundle.descriptor.stage("handoff").directory}/raw-intake.json`, bytes,
+        sha256: createHash("sha256").update(bytes).digest("hex"),
+        assertCustody(writer) {
+            assertReviewFixSourceIntakeCustody(writer, scope, bundle, source.sha256);
+            const current = read(writer);
+            if (!current.intake.bytes.equals(original.intake.bytes) || !current.reviewed.bytes.equals(original.reviewed.bytes)
+                || current.intake.authority_sha256 !== original.intake.authority_sha256
+                || current.reviewed.authority_sha256 !== original.reviewed.authority_sha256
+                || hybridDigest(current.users) !== hybridDigest(original.users))
+                refuse("accepted_handoff_changed");
+        }
+    };
+}

package/dist/services/review-fix-intake-custody.js

@@ -0,0 +1,17 @@
+import { assertDiagnosticRepairSourceIntakeCustody, prepareDiagnosticRepairSourceIntake, readDiagnosticRepairSourceIntake } from "./diagnostic-repair-source-intake.js";
+import { readMemoryFlowUserInputs } from "./memory-flow-user-inputs.js";
+// Preserve this flow's own capsule identity; shared transport grants no approval.
+export function assertReviewFixSourceIntakeCustody(context, scope, bundle, expectedSha256) {
+    return assertDiagnosticRepairSourceIntakeCustody(context, scope, bundle, expectedSha256, "review-fix");
+}
+export function prepareReviewFixSourceIntake(context, input) {
+    return prepareDiagnosticRepairSourceIntake(context, input, "review-fix");
+}
+export function readReviewFixSourceIntake(context, input, retainedBundle) {
+    return readDiagnosticRepairSourceIntake(context, input, "review-fix", retainedBundle);
+}
+/** Original request and all delivered answers, not an agent's replacement spec.
+ * Reading these bytes neither accepts scope nor authorizes SDLC formalization. */
+export function readReviewFixUserInputs(context, input, retainedBundle) {
+    return readMemoryFlowUserInputs(context, input, "review-fix", retainedBundle);
+}

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

@@ -0,0 +1,43 @@
+import { AppError } from "../shared/errors.js";
+import { reviewFixStages } from "../domain/review-fix-flow.js";
+import { readFlowRunExecutionBundle, assertPreparedRunBundleSqlAuthority } from "./runs.js";
+import { requireProjectByRoot } from "./projects.js";
+import { resolveProjectRoot } from "../storage/paths.js";
+import { readReviewFixSourceIntake, assertReviewFixSourceIntakeCustody } from "./review-fix-intake-custody.js";
+import { PreparedDescriptorStageStart } from "./descriptor-stage-start.js";
+import { PreparedDescriptorStageCoordinator } from "./descriptor-stage-coordinator.js";
+import { readDiagnosticSnapshot, readDiagnosticSnapshotCustody } from "./diagnostic-snapshot.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+/** Internal family entry. Generic runtime owns attempts, Work and coordinator;
+ * this does not register a public flow or authorize a downstream SDLC start. */
+export function readReviewFixStageScope(context, input, historical = false) {
+    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
+    const bundle = readFlowRunExecutionBundle(context, input);
+    if (!bundle || bundle.manifest.flow_id !== "review-fix" || !reviewFixStages.includes(input.stage))
+        throw new AppError("review_fix_stage_invalid", "Review-fix requires its registered three-stage flow and retained intake", 2, { reason: "review_fix_stage_required", effect: "no_effect" });
+    bundle.descriptor.stage(input.stage);
+    const source = readReviewFixSourceIntake(context, input, bundle);
+    const scope = { projectId: project.id, runId: input.runId, stage: input.stage };
+    const run = assertPreparedRunBundleSqlAuthority(context, scope, bundle);
+    const replay = historical && JSON.parse(run.index_json).stage_runs.some((stage) => stage.stage === input.stage && stage.status === "done");
+    const frozen = bundle.execution.snapshot().scope;
+    const snapshotSelection = { projectId: project.id, projectRoot: frozen.projectRoot, sourceRoot: frozen.projectRoot,
+        requestId: frozen.requestId, flowId: "review-fix" };
+    const snapshot = (replay ? readDiagnosticSnapshotCustody : readDiagnosticSnapshot)(context, snapshotSelection, input.runId);
+    if (!snapshot || snapshot.root !== frozen.workspace)
+        throw new AppError("review_fix_stage_invalid", "Review-fix requires its unchanged private source snapshot", 2, { reason: "snapshot_required", effect: "no_effect" });
+    return { bundle, source, scope, run, replay, snapshot, snapshotSelection,
+        assertCustody(writer) {
+            assertReviewFixSourceIntakeCustody(writer, scope, bundle, source.sha256);
+            if (hybridDigest(readDiagnosticSnapshotCustody(writer, snapshotSelection, input.runId)) !== hybridDigest(snapshot))
+                throw new AppError("review_fix_stage_invalid", "Review-fix source snapshot custody changed", 2, { reason: "snapshot_changed", effect: "no_effect" });
+        }
+    };
+}
+export function startReviewFixStage(context, input) {
+    const selected = readReviewFixStageScope(context, input), { source } = selected;
+    const fence = selected.assertCustody;
+    const start = PreparedDescriptorStageStart.prepare(context, input).apply(context, fence);
+    const coordinator = PreparedDescriptorStageCoordinator.prepare(context, input).apply(context, fence);
+    return { ...start, ...coordinator, intake_sha256: source.sha256, source_intake: source.reference };
+}

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

@@ -0,0 +1,176 @@
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { AppError } from "../shared/errors.js";
+import { entityReferenceVariants } from "../shared/entity-references.js";
+import { reviewFixStages } from "../domain/review-fix-flow.js";
+import { readReviewFixStageScope, startReviewFixStage } from "./review-fix-stage-entry.js";
+import { readDescriptorStageInput } from "./descriptor-stage-coordinator.js";
+import { PreparedDescriptorStageSettlement, readAcceptedDescriptorStageSettlement } from "./descriptor-stage-settlement.js";
+import { PreparedDescriptorRunSettlement } from "./descriptor-run-settlement.js";
+import { readAcceptedStageData, prepareStagePacket, acceptStagePacket, prepareStageReport, acceptStageReport, publishStagePacket, publishStageReport, resolveStagePublicationPath } from "./stage-report-renderer.js";
+import { readPreparedMemoryFlowUserInputs } from "./memory-flow-user-inputs.js";
+import { assertReviewFixStageScope, validateReviewFixStageResult, reviewFixHandoffDisposition } from "./review-fix-stage-results.js";
+import { prepareReviewFixHandoff } from "./review-fix-handoff.js";
+import { assertDiagnosticSessionIndependence } from "./diagnostic-work-collection.js";
+import { readDiagnosticSnapshot } from "./diagnostic-snapshot.js";
+import { stageLifecycleMatchKey } from "./hooks.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+const hash = (bytes) => createHash("sha256").update(bytes).digest("hex");
+function refuse(reason) {
+    throw new AppError("review_fix_stage_invalid", "Review-fix requires original scope, independent review and a raw handoff", 2, { reason, effect: "no_effect" });
+}
+export const reviewFixStageHandlers = Object.freeze(reviewFixStages.map(stage => Object.freeze({ flowId: "review-fix", stage,
+    entryId: "review-fix-stage-entry", finishId: "review-fix-stage-finish", entry: startReviewFixStage, finish: finishReviewFixStage })));
+/** Read retained raw bytes for terminal replay, never recapture newer messages. */
+function readHandoff(context, scope, attempt, file) {
+    const rows = context.db.all("SELECT payload_json FROM audit_events WHERE project_id=? AND event_type='flow_run.stage_packet' AND json_extract(payload_json,'$.run_id')=? AND json_extract(payload_json,'$.stage')='handoff' AND json_extract(payload_json,'$.attempt')=? LIMIT 33", [scope.projectId, scope.runId, attempt]);
+    if (rows.length > 32)
+        refuse("handoff_custody_invalid");
+    const packets = rows.map(row => {
+        if (Buffer.byteLength(row.payload_json) > 6 * 1024 * 1024)
+            refuse("handoff_exceeds_bound");
+        return JSON.parse(row.payload_json);
+    }).filter(packet => typeof packet.file === "string" && resolveStagePublicationPath(context, scope.projectId, scope.runId, packet.file) === file);
+    if (!packets.length)
+        return null;
+    if (packets.length !== 1 || typeof packets[0].base64 !== "string")
+        refuse("accepted_handoff_missing");
+    const bytes = Buffer.from(packets[0].base64, "base64");
+    if (!bytes.length || bytes.length > 4 * 1024 * 1024 || bytes.toString("base64") !== packets[0].base64 || hash(bytes) !== packets[0].sha256)
+        refuse("accepted_handoff_changed");
+    return { bytes, sha256: hash(bytes) };
+}
+/** Generic Stage/RUN settlement remains the sole lifecycle owner. This handler
+ * writes only retained runtime packets/reports, never project files or SDLC. */
+export function finishReviewFixStage(context, input) {
+    if (!input.bytes.length || input.bytes.length > 1024 * 1024)
+        refuse("result_exceeds_bound");
+    const selected = readReviewFixStageScope(context, input, true), { bundle, source, scope, replay, snapshot } = selected;
+    const packet = readDescriptorStageInput(context, scope, bundle, true, true);
+    const stage = input.stage;
+    const previousStage = stage === "scope-review" ? "intake" : stage === "handoff" ? "scope-review" : null;
+    const previous = previousStage ? readAcceptedStageData(context, { ...scope, stage: previousStage }) : null;
+    const prior = previous ? JSON.parse(previous.bytes.toString("utf8")) : null;
+    if (previous && (packet.input.predecessor?.stage !== previousStage || hybridDigest(packet.input.predecessor.result) !== hybridDigest(previous.result)))
+        refuse("predecessor_changed");
+    const bytes = Buffer.from(input.bytes);
+    let result;
+    const users = !replay ? readPreparedMemoryFlowUserInputs(context, scope, "review-fix", bundle) : null;
+    if (replay) {
+        const accepted = readAcceptedStageData(context, scope);
+        if (!accepted.bytes.equals(bytes))
+            refuse("accepted_result_changed");
+        result = JSON.parse(accepted.bytes.toString("utf8"));
+    }
+    else {
+        result = validateReviewFixStageResult(bytes, bundle.descriptor.stageBlob(stage, "result_schema"), {
+            runId: input.runId, stage, inputSha256: packet.inputSha256, intakeSha256: source.sha256,
+            snapshotSha256: snapshot.source_sha256, userInputsSha256: hybridDigest(users),
+            findingIds: source.intake.selected_findings.map(finding => finding.id), predecessors: previous ? [{ stage: previousStage, ...previous.result }] : [],
+            userSources: users.sources.map(item => {
+                if (!["request", "question", "answer"].includes(item.role))
+                    return refuse("invalid_user_input_role");
+                return { root: item.root, path: item.path, sha256: item.sha256, role: item.role };
+            })
+        });
+        if (source.intake.limitations.some(item => !result.details.limitations.includes(item)))
+            refuse("source_limitations_missing");
+        if (prior)
+            assertReviewFixStageScope(result, prior);
+    }
+    const settlement = PreparedDescriptorStageSettlement.prepare(context, input);
+    const keys = (name) => entityReferenceVariants(input.runId).map(ref => stageLifecycleMatchKey("stage_finish", ref, name, input.projectRoot));
+    const intakeKeys = stage !== "intake" ? keys("intake") : [];
+    const reviewKeys = stage === "handoff" ? keys("scope-review") : [];
+    const readOwners = (reader) => {
+        const physical = (id) => {
+            const session = reader.db.get("SELECT harness,provider_session_id FROM sessions WHERE project_id=? AND run_id=? AND session_id=?", [scope.projectId, scope.runId, id]);
+            if (!session?.harness || !session.provider_session_id)
+                refuse("physical_owner_missing");
+            return session;
+        };
+        const intake = stage !== "intake" ? readAcceptedDescriptorStageSettlement(reader, { ...scope, stage: "intake" }, bundle, intakeKeys) : null;
+        const review = stage === "handoff" ? readAcceptedDescriptorStageSettlement(reader, { ...scope, stage: "scope-review" }, bundle, reviewKeys) : null;
+        if (intake)
+            assertDiagnosticSessionIndependence([physical(review ? review.binding.sessionId : settlement.coordinatorSessionId())], [physical(intake.binding.sessionId)]);
+        return { intake, review };
+    };
+    const owners = context.db.readSnapshot(() => readOwners(context));
+    const handoff = stage === "handoff" && !replay ? prepareReviewFixHandoff(context, input) : null;
+    const reportRoot = path.join(packet.runRoot, bundle.descriptor.stage(stage).directory), handoffFile = path.join(reportRoot, "raw-intake.json");
+    const retained = stage === "handoff" && replay ? readHandoff(context, scope, packet.attempt, handoffFile) : null;
+    if (stage === "handoff" && replay && !retained)
+        refuse("accepted_handoff_missing");
+    const raw = handoff ?? retained;
+    const rawPacket = handoff ? prepareStagePacket(handoffFile, handoff.bytes) : null;
+    const report = stage === "handoff" && raw ? prepareStageReport({ run_id: input.runId, stage, verdict: "completed", summary: result.summary,
+        review_fix: { disposition: reviewFixHandoffDisposition(result), formalization_authorized: false,
+            source: source.intake.source, source_intake: source.reference, unselected_ids: source.intake.unselected_ids,
+            scope: result.details, raw_intake: { root: "run", path: `${bundle.descriptor.stage(stage).directory}/raw-intake.json`, sha256: raw.sha256 } },
+        semantic: { next_action: "No repair or SDLC was started. Ready scope requires a separate explicit user formalization through vnext/start.md; deferred/declined/needs_scope remain honest outcomes." }
+    }) : null;
+    if (report && Buffer.byteLength(JSON.stringify(report.bytes)) > 7 * 1024 * 1024)
+        refuse("terminal_report_exceeds_bound");
+    if (!replay && hybridDigest(readDiagnosticSnapshot(context, selected.snapshotSelection, input.runId)) !== hybridDigest(snapshot))
+        refuse("snapshot_changed");
+    const fence = (writer) => {
+        selected.assertCustody(writer);
+        if (previous && hybridDigest(readAcceptedStageData(writer, { ...scope, stage: previousStage })) !== hybridDigest(previous))
+            refuse("predecessor_changed");
+        if (hybridDigest(readOwners(writer)) !== hybridDigest(owners))
+            refuse("review_owner_changed");
+        if (users && hybridDigest(readPreparedMemoryFlowUserInputs(writer, scope, "review-fix", bundle)) !== hybridDigest(users))
+            refuse("delivered_inputs_changed");
+        handoff?.assertCustody(writer);
+        if (rawPacket && !replay) {
+            const existing = readHandoff(writer, scope, packet.attempt, handoffFile);
+            if (existing && !existing.bytes.equals(rawPacket.bytes))
+                refuse("accepted_handoff_changed");
+            if (!existing)
+                acceptStagePacket(writer, { ...scope, prepared: rawPacket });
+        }
+        if (retained && hybridDigest(readHandoff(writer, scope, packet.attempt, handoffFile)) !== hybridDigest(retained))
+            refuse("accepted_handoff_changed");
+        if (report) {
+            const rows = writer.db.all("SELECT payload_json FROM audit_events WHERE project_id=? AND event_type='flow_run.stage_report' AND json_extract(payload_json,'$.run_id')=? AND json_extract(payload_json,'$.stage')='handoff' AND json_extract(payload_json,'$.attempt')=? LIMIT 2", [scope.projectId, scope.runId, packet.attempt]);
+            if (rows.length > 1 || rows.some(row => Buffer.byteLength(row.payload_json) > 8 * 1024 * 1024))
+                refuse("terminal_report_custody_invalid");
+            if (rows.length) {
+                const stored = JSON.parse(rows[0].payload_json);
+                if (stored.sha256 !== report.sha256 || hybridDigest(stored.bytes) !== hybridDigest(report.bytes)
+                    || resolveStagePublicationPath(writer, scope.projectId, scope.runId, stored.root) !== reportRoot)
+                    refuse("terminal_report_changed");
+            }
+            else {
+                if (replay)
+                    refuse("accepted_terminal_report_missing");
+                acceptStageReport(writer, { ...scope, root: reportRoot, prepared: report });
+            }
+        }
+    };
+    let acceptedStage = false;
+    try {
+        const accepted = settlement.apply(context, fence);
+        acceptedStage = true;
+        if (stage !== "handoff")
+            return accepted;
+        const complete = PreparedDescriptorRunSettlement.prepare(context, input).apply(context, fence);
+        publishStagePacket(context, scope.projectId, scope.runId, stage, handoffFile);
+        publishStageReport(context, scope.projectId, scope.runId, stage, reportRoot);
+        return { ...accepted, ...complete, disposition: reviewFixHandoffDisposition(result), formalization_authorized: false,
+            handoff: handoffFile, reports: ["json", "md", "html"].map(extension => path.join(reportRoot, `stage-report.${extension}`)) };
+    }
+    catch (error) {
+        if (stage !== "handoff")
+            throw error;
+        if (!acceptedStage) {
+            try {
+                acceptedStage = readAcceptedStageData(context, scope).bytes.equals(bytes);
+            }
+            catch { /* Not committed. */ }
+        }
+        if (!acceptedStage)
+            throw error;
+        throw new AppError("review_fix_handoff_pending", "Accepted handoff needs projection or RUN settlement reconciliation", 1, { effect: "committed", run_id: input.runId, next_action: "reconcile_accepted_handoff", cause: error instanceof AppError ? error.code : "handoff_settlement_failed" });
+    }
+}

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

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

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

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

package/dist/services/run-control.js

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