@deksden-com/dd-flow-cli 0.9.0-beta.141 → 0.9.0-beta.143

package/dist/services/accepted-intent.js

@@ -0,0 +1,127 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { AppError } from "../shared/errors.js";
+import { assertPathWithin } from "../storage/paths.js";
+import { acceptStagePacket, prepareStagePacket, resolveStagePublicationPath } from "./stage-report-renderer.js";
+export const acceptedIntentContract = "dd-flow/accepted-intent@1";
+const digest = (bytes) => crypto.createHash("sha256").update(bytes).digest("hex");
+export function acceptedIntentSourceRole(role) { return role === "accepted_intake" || role.startsWith("accepted_hitl:"); }
+export function acceptedIntentReviewFingerprint(sources) {
+    const inputs = sources?.filter(source => acceptedIntentSourceRole(source.role)).map(({ role, sha256 }) => ({ role, sha256 })).sort((a, b) => a.role < b.role ? -1 : a.role > b.role ? 1 : 0);
+    return inputs?.length ? digest(Buffer.from(JSON.stringify(inputs))) : null;
+}
+/** An independent review covers its retained inputs only. An own-stage user
+ * clarification may use the existing coordinator correction, explicitly named
+ * as such; it never retroactively expands the independent review's coverage. */
+export function validateAcceptedIntentReview(context, scope, reviewedSources, contextFingerprint, acknowledgement) {
+    const reviewed = acceptedIntentReviewFingerprint(reviewedSources);
+    if (!reviewed)
+        return null; // Historical source contract has no new authority.
+    if (contextFingerprint !== reviewed)
+        throw new AppError("accepted_intent_review_stale", "Review context does not bind the retained accepted inputs", 1, { stage: scope.stage });
+    const currentSources = prepareAcceptedIntentSources(context, { ...scope, stageDirectory: "intake", marked: true }).sources;
+    const current = acceptedIntentReviewFingerprint(currentSources);
+    const reviewedEvent = Math.max(0, ...(reviewedSources ?? []).filter(source => source.role.startsWith("accepted_hitl:")).map(source => Number(source.role.split(":")[1])));
+    const rows = context.db.all("SELECT id, payload_json FROM audit_events WHERE project_id = ? AND event_type = 'flow_run.stage_resumed' AND json_extract(payload_json, '$.run_id') = ? AND id > ? ORDER BY id LIMIT 256", [scope.projectId, scope.runId, reviewedEvent]);
+    const additions = rows.map(row => ({ id: row.id, ...JSON.parse(row.payload_json) }));
+    const refs = additions.map(answer => answer.pause_id);
+    const evidence = { reviewed_fingerprint: reviewed, current_fingerprint: current, independent_coverage: "reviewed_sources_only", coordinator_clarification_refs: refs,
+        source_event_id: Math.max(reviewedEvent, ...additions.map(answer => answer.id)) };
+    if (current === reviewed) {
+        if (acknowledgement && (acknowledgement.reviewed_fingerprint !== reviewed || acknowledgement.current_fingerprint !== current || acknowledgement.clarification_refs.length))
+            throw new AppError("accepted_intent_review_ack_required", "Accepted-input acknowledgement differs from the retained review", 2, { ...evidence, phase: "prepare", effect: "no_effect", recoverable: true });
+        return evidence;
+    }
+    if (!additions.length || additions.some(answer => answer.stage !== scope.stage))
+        throw new AppError("accepted_intent_review_stale", "Independent review cannot cover newly accepted upstream decisions; use a supported upstream revision", 1, { ...evidence, stage: scope.stage });
+    if (!acknowledgement || acknowledgement.reviewed_fingerprint !== reviewed || acknowledgement.current_fingerprint !== current || JSON.stringify(acknowledgement.clarification_refs) !== JSON.stringify(refs)) {
+        if (scope.decisionFrozen)
+            throw new AppError("accepted_intent_review_stale", "New answer cannot alter an already frozen review decision; use a supported upstream revision", 1, evidence);
+        throw new AppError("accepted_intent_review_ack_required", "Own-stage clarification requires an explicit coordinator acknowledgement, not reuse of old independent coverage", 2, { ...evidence, phase: "prepare", effect: "no_effect", recoverable: true, accepted_intent_acknowledgement: { reviewed_fingerprint: reviewed, current_fingerprint: current, clarification_refs: refs }, instruction: "Apply/classify this clarification through the existing coordinator correction/repair route; include the exact acknowledgement in the decision. Independent review covers only the earlier retained inputs." });
+    }
+    return evidence;
+}
+export function assertAcceptedIntentReviewCurrent(context, scope, evidence) {
+    if (!evidence)
+        return;
+    const row = context.db.get("SELECT MAX(id) AS id FROM audit_events WHERE project_id = ? AND event_type = 'flow_run.stage_resumed' AND json_extract(payload_json, '$.run_id') = ?", [scope.projectId, scope.runId]);
+    if ((row?.id ?? 0) !== evidence.source_event_id)
+        throw new AppError("accepted_intent_review_stale", "Accepted answers changed during review settlement", 1);
+}
+export function assertDeliveredHitlReferences(context, scope, references) {
+    if (!references.length)
+        return;
+    const run = context.db.get("SELECT index_json FROM runs WHERE project_id = ? AND id = ?", [scope.projectId, scope.runId]);
+    if (JSON.parse(run.index_json).accepted_intent_contract !== acceptedIntentContract)
+        return;
+    for (const reference of new Set(references)) {
+        const answered = context.db.get("SELECT id FROM audit_events WHERE project_id = ? AND event_type = 'flow_run.stage_resumed' AND json_extract(payload_json, '$.run_id') = ? AND json_extract(payload_json, '$.pause_id') = ? LIMIT 1", [scope.projectId, scope.runId, reference]);
+        if (!answered)
+            throw new AppError("validation", "Obligation amendment must reference an actually delivered answer in this RUN", 2, { hitl_ref: reference });
+    }
+}
+/** Retain only inputs actually delivered to this RUN, never agent recommendations
+ * or hidden evaluation expectations. Reuse the existing publication custody. */
+export function retainAcceptedIntake(context, scope) {
+    if (!scope.bytes.length || scope.bytes.length > 1024 * 1024)
+        throw new AppError("accepted_intent_source_invalid", "Accepted intake exceeds the bounded source contract", 2);
+    const prepared = prepareStagePacket(scope.file, scope.bytes);
+    context.db.writeTransaction(() => {
+        acceptStagePacket(context, { ...scope, stage: "specify", prepared });
+        const row = context.db.get("SELECT index_json FROM runs WHERE project_id = ? AND id = ?", [scope.projectId, scope.runId]);
+        const index = JSON.parse(row.index_json);
+        index.accepted_intent_contract = acceptedIntentContract;
+        context.db.run("UPDATE runs SET index_json = ? WHERE project_id = ? AND id = ?", [JSON.stringify(index), scope.projectId, scope.runId]);
+    });
+}
+export function prepareAcceptedIntentSources(context, input) {
+    if (!input.marked)
+        return { sources: [], packets: [] };
+    const fail = (reason) => { throw new AppError("accepted_intent_source_gap", "Original accepted input is unavailable; SPECIFY is not a substitute", 1, { reason, run_id: input.runId }); };
+    const rows = context.db.all("SELECT id, payload_json FROM audit_events WHERE project_id = ? AND event_type = 'flow_run.stage_resumed' AND json_extract(payload_json, '$.run_id') = ? ORDER BY id LIMIT 256", [input.projectId, input.runId]);
+    const entries = [{ role: "accepted_intake", file: path.join(input.home, "intake/discussion.md") }, ...rows.flatMap(row => {
+            const value = JSON.parse(row.payload_json);
+            const identity = `accepted_hitl:${String(row.id).padStart(12, "0")}:${value.pause_id}`;
+            return [{ role: `${identity}:0-question`, file: path.join(path.dirname(value.answer_path), "question.md") }, { role: `${identity}:1-answer`, file: value.answer_path }];
+        })];
+    if (entries.length > 256)
+        fail("source_count_exceeds_bound");
+    let total = 0;
+    const retained = entries.map(entry => {
+        const file = resolveStagePublicationPath(context, input.projectId, input.runId, entry.file);
+        const relative = path.relative(input.home, file);
+        if (path.isAbsolute(relative) || relative.startsWith(`..${path.sep}`) || relative === "..")
+            fail("source_outside_run");
+        const suffix = `/${relative.split(path.sep).join("/")}`;
+        const packetRows = 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 substr(json_extract(payload_json, '$.file'), -length(?)) = ? LIMIT 33", [input.projectId, input.runId, suffix, suffix]);
+        if (packetRows.length > 32 || packetRows.some(row => Buffer.byteLength(row.payload_json) > 2 * 1024 * 1024))
+            fail(`unbounded_custody:${relative}`);
+        const candidates = packetRows.map(row => ({ value: JSON.parse(row.payload_json) })).filter(packet => resolveStagePublicationPath(context, input.projectId, input.runId, packet.value.file) === file);
+        if (!candidates.length)
+            fail(`missing_custody:${relative}`);
+        const bytes = Buffer.from(candidates[0].value.base64, "base64"), sha256 = digest(bytes);
+        total += bytes.length;
+        if (!bytes.length || bytes.length > 1024 * 1024 || total > 16 * 1024 * 1024 || candidates.some(packet => packet.value.sha256 !== sha256 || !Buffer.from(packet.value.base64, "base64").equals(bytes) || Buffer.from(packet.value.base64, "base64").toString("base64") !== packet.value.base64))
+            fail(`invalid_custody:${relative}`);
+        // An unavailable or replaced published source is an explicit evidence gap,
+        // rather than silent use of a later summary or arbitrary local file.
+        if (!fs.existsSync(file) || !fs.lstatSync(file).isFile() || fs.statSync(file).size !== bytes.length)
+            fail(`source_unavailable:${relative}`);
+        const actual = path.relative(fs.realpathSync(input.home), fs.realpathSync(file));
+        if (path.isAbsolute(actual) || actual === ".." || actual.startsWith(`..${path.sep}`) || !fs.readFileSync(file).equals(bytes))
+            fail(`source_unavailable:${relative}`);
+        const snapshot = `${input.stageDirectory}/verification/sources/${sha256}/accepted-input.md`;
+        const destination = path.join(input.home, snapshot);
+        try {
+            assertPathWithin(input.home, destination, "accepted_source_snapshot");
+        }
+        catch (error) {
+            if (!(error instanceof AppError) || error.code !== "validation")
+                throw error;
+            throw new AppError("verification_matrix_path_invalid", "Accepted source snapshot escapes its RUN", 1, { path: snapshot });
+        }
+        return { source: { role: entry.role, root: "run", path: snapshot, sha256 }, packet: prepareStagePacket(destination, bytes) };
+    });
+    return { sources: retained.map(item => item.source), packets: [...new Map(retained.map(item => [item.packet.file, item.packet])).values()] };
+}

package/dist/services/check-runner-evidence.js

@@ -224,6 +224,8 @@ export function readRunnerEvidence(root, contract, binding) {
 }
 export function runnerEvidencePass(evidence) { return Boolean(evidence?.completed && !evidence.observation_unknown && evidence.counts.failed === 0 && evidence.failures.length === 0); }
 export function checkRepairDisposition(receipt) {
+    if (receipt.fingerprint_scope != null && receipt.fingerprint_scope !== "check_inputs")
+        return "tooling_blocker";
     if (receipt.status === "running" || receipt.status === "aborted" || receipt.runner_evidence?.observation_unknown)
         return "settlement_required";
     if (receipt.status === "passed")