@deksden-com/dd-flow-cli 0.9.0-beta.142 → 0.9.0-beta.144

package/dist/harness-runtime/lib/dd-opencode-daemon.mjs

@@ -178,8 +178,26 @@ export async function startDaemon(options) {
 export const stopDaemon = async options => { const timeoutMs = options.timeoutMs ?? 30_000; return await confirmDaemonStopped(() => callDaemon(options.stateDir, "daemon.stop", { cancelTree: options.cancelTree === true }, timeoutMs), locations(options.stateDir).socket, timeoutMs, { readState: () => readState(options.stateDir) }); };
 
 export class Runtime {
-  constructor(paths, state, client, child, providerProcess) { this.paths = paths; this.state = state; this.client = client; this.child = child; this.providerProcess = providerProcess; this.sessions = new Map((state.sessions ?? []).map(x => [x.provider_session_id, x])); this.active = null; this.persisting = Promise.resolve(); }
+  constructor(paths, state, client, child, providerProcess) { this.paths = paths; this.state = state; this.client = client; this.child = child; this.providerProcess = providerProcess; this.sessions = new Map();
+    for (const record of state.sessions ?? []) {
+      if (typeof record?.provider_session_id !== "string" || !record.provider_session_id || this.sessions.has(record.provider_session_id))
+        throw new DaemonError("session_identity_mismatch", "OpenCode retained Session identity is invalid or duplicated");
+      this.sessions.set(record.provider_session_id, record);
+    }
+    this.active = null; this.persisting = Promise.resolve(); }
   persist(patch = {}) { Object.assign(this.state, patch, { pid: process.pid, sessions: [...this.sessions.values()] }); const snapshot = structuredClone(this.state); this.persisting = this.persisting.catch(() => {}).then(() => writeJson(this.paths.state, snapshot)); return this.persisting; }
+  retainSession(info, root) {
+    const id = info.id, parent = info.fork ? null : info.parentID ?? null, retained = this.sessions.get(id);
+    if (typeof id !== "string" || !id || typeof info.directory !== "string" || !path.isAbsolute(info.directory)
+      || retained && ((retained.parent_provider_session_id ?? null) !== parent
+        || retained.adapter_session_id && retained.adapter_session_id !== id
+        || retained.root_provider_session_id && retained.root_provider_session_id !== root))
+      throw new DaemonError("session_identity_mismatch", "OpenCode retained Session identity changed");
+    // Cwd is observed routing authority, not ownership identity: a moved owned
+    // Session must remain observable/cancellable. requireSettled fences dispatch.
+    const record = { provider_session_id: id, adapter_session_id: id, parent_provider_session_id: parent, root_provider_session_id: root, cwd: info.directory };
+    this.sessions.set(id, record); return record;
+  }
   async journal(operation, result) { const line = `${JSON.stringify({ schema_id: "dd-opencode/daemon-event@1", event_id: randomUUID(), observed_at: new Date().toISOString(), operation, active_tree: this.state.active_tree, session_id: result?.provider_session_id ?? null })}\n`; for (const journal of new Set([this.paths.journal, this.state.config.journal].filter(Boolean))) { await mkdir(path.dirname(journal), { recursive: true, mode: 0o700 }); await appendFile(journal, line, { mode: 0o600 }); } }
   async childTree(id, seen = new Set()) {
     if (seen.has(id)) throw new DaemonError("session_identity_mismatch", "OpenCode native topology contains a cycle");
@@ -195,13 +213,11 @@ export class Runtime {
     const parent = info.fork ? null : info.parentID ?? null, existing = this.sessions.get(id);
     if (info.id !== id || !existing && (!parent || !this.sessions.has(parent) || info.fork)
       || existing && (existing.parent_provider_session_id ?? null) !== parent) throw new DaemonError("foreign_session", "OpenCode Session is not in the retained owned tree");
-    const record = { provider_session_id: id, adapter_session_id: id, parent_provider_session_id: parent,
-      root_provider_session_id: parent ? this.sessions.get(parent)?.root_provider_session_id ?? parent : existing?.root_provider_session_id ?? id, cwd: info.directory };
-    this.sessions.set(id, record);
+    const record = this.retainSession(info, parent ? this.sessions.get(parent)?.root_provider_session_id ?? parent : existing?.root_provider_session_id ?? id);
     for (const child of children) {
       const retained = this.sessions.get(child.id);
       if (child.fork || retained && retained.parent_provider_session_id !== child.parentID) throw new DaemonError("session_identity_mismatch", "OpenCode child ancestry changed");
-      this.sessions.set(child.id, { provider_session_id: child.id, parent_provider_session_id: child.parentID, root_provider_session_id: record.root_provider_session_id, cwd: child.directory });
+      this.retainSession(child, record.root_provider_session_id);
     }
     const pending = new Map();
     for (const session of [id, ...children.map(child => child.id)]) {
@@ -287,6 +303,7 @@ export class Runtime {
     if (seen.has(id)) return [];
     const native = await this.client.inspect(id), retained = this.sessions.get(id);
     if (native.id !== id || (retained.parent_provider_session_id ?? null) !== (native.fork ? null : native.parentID ?? null)) throw new DaemonError("session_identity_mismatch", "OpenCode cancellation Session ancestry changed");
+    this.retainSession(native, retained.root_provider_session_id ?? id);
     seen.add(id);
     const errors = []; let children = [];
     try { children = await this.client.children(id); } catch (error) { errors.push({ session_id: id, phase: "children", ...errorPayload(error) }); }
@@ -294,7 +311,7 @@ export class Runtime {
       if (child.parentID !== id || child.fork || this.sessions.has(child.id) && this.sessions.get(child.id).parent_provider_session_id !== id) {
         errors.push({ session_id: child.id, phase: "identity", code: "session_identity_mismatch" }); continue;
       }
-      this.sessions.set(child.id, { provider_session_id: child.id, parent_provider_session_id: id, root_provider_session_id: this.sessions.get(id)?.root_provider_session_id ?? id, cwd: child.directory });
+      this.retainSession(child, this.sessions.get(id)?.root_provider_session_id ?? id);
       try { errors.push(...await this.cancelTree(child.id, seen)); }
       catch (error) { errors.push({ session_id: child.id, phase: "cancel_child", ...errorPayload(error) }); }
     }

package/dist/schemas/code-review-decision.schema.json

@@ -5,6 +5,15 @@
   "additionalProperties": false,
   "required": ["schema_id", "summary", "findings"],
   "properties": {
+    "accepted_intent_acknowledgement": {
+      "type": "object", "additionalProperties": false,
+      "required": ["reviewed_fingerprint", "current_fingerprint", "clarification_refs"],
+      "properties": {
+        "reviewed_fingerprint": {"type": "string", "pattern": "^[a-f0-9]{64}$"},
+        "current_fingerprint": {"type": "string", "pattern": "^[a-f0-9]{64}$"},
+        "clarification_refs": {"type": "array", "uniqueItems": true, "items": {"type": "string", "pattern": "^HITL-[A-Za-z0-9._-]+$"}}
+      }
+    },
     "schema_id": {"const": "dd-flow/code-review-decision@3"},
     "summary": {"type": "string", "minLength": 1},
     "findings": {

package/dist/schemas/flow-run.schema.json

@@ -39,6 +39,7 @@
       }
     },
     "verification_matrix_contract": {"const": "dd-flow/verification-matrix@1"},
+    "accepted_intent_contract": {"const": "dd-flow/accepted-intent@1"},
     "final_check_coverage_contract": {"const": "dd-flow/final-check-coverage@1"},
     "status": {"enum": ["created", "running", "paused", "waiting_for_user", "done", "failed", "blocked", "cancelled", "discarded"]},
     "verdict": {"type": ["string", "null"]},

package/dist/schemas/plan-review-decision.schema.json

@@ -5,6 +5,15 @@
   "additionalProperties": false,
   "required": ["schema_id", "outcome", "summary", "finding_decisions", "correction"],
   "properties": {
+    "accepted_intent_acknowledgement": {
+      "type": "object", "additionalProperties": false,
+      "required": ["reviewed_fingerprint", "current_fingerprint", "clarification_refs"],
+      "properties": {
+        "reviewed_fingerprint": {"type": "string", "pattern": "^[a-f0-9]{64}$"},
+        "current_fingerprint": {"type": "string", "pattern": "^[a-f0-9]{64}$"},
+        "clarification_refs": {"type": "array", "uniqueItems": true, "items": {"type": "string", "pattern": "^HITL-[A-Za-z0-9._-]+$"}}
+      }
+    },
     "schema_id": {"const": "dd-flow/plan-review-decision@4"},
     "outcome": {"enum": ["accepted", "failed", "cancelled"]},
     "summary": {"type": "string", "minLength": 1},

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")