@deksden-com/dd-flow-cli 0.9.0-beta.63 → 0.9.0-beta.64

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @deksden-com/dd-flow-cli
 
+## 0.9.0-beta.64
+
+### Patch Changes
+
+- Reserve SQLite writes explicitly, retain trusted lifecycle outcomes across harnesses,
+  continuously fence failed managed runs, and recover committed Work start packets and
+  replies without repeating effects. Revalidate stage inputs before acceptance and keep
+  the causal failure when adapter, publication or cleanup also fails. Writer contract 2
+  requires fresh campaign and resource homes; historical contract-1 stores are not
+  implicitly upgraded. Recovery-generation Work starts keep separate immutable packets
+  per WorkSession, preserving the interrupted attempt's evidence.
+
 ## 0.9.0-beta.63
 
 ### Patch Changes

package/dist/build-info.json

@@ -1,15 +1,15 @@
 {
   "cli_package": "@deksden-com/dd-flow-cli",
-  "cli_version": "0.9.0-beta.63",
-  "cli_commit": "4975ba184bd847fd34db995cd3d9e1feb3db9f9f",
-  "built_at": "2026-09-14T10:36:19.793Z",
+  "cli_version": "0.9.0-beta.64",
+  "cli_commit": "53046a13b2a4370531d64b380974abbd6bf2383b",
+  "built_at": "2026-09-14T16:28:38.823Z",
   "built_with_canon": {
     "version": "4.1.1",
     "commit": "97f811d33c212ae3497020178b1ed825c7c3ebac",
     "flow_contract": "dd-flow-canonical-2026-08",
-    "repo_root": "/Users/deksden/Documents/_Projects/dd-memorybank",
-    "memorybank_root": "/Users/deksden/Documents/_Projects/dd-memorybank/.memory-bank",
-    "flow_root": "/Users/deksden/Documents/_Projects/dd-memorybank/.memory-bank/dd-flow",
+    "repo_root": "/home/runner/work/dd-flow-cli/dd-flow-cli/dd-memorybank",
+    "memorybank_root": "/home/runner/work/dd-flow-cli/dd-flow-cli/dd-memorybank/.memory-bank",
+    "flow_root": "/home/runner/work/dd-flow-cli/dd-flow-cli/dd-memorybank/.memory-bank/dd-flow",
     "layout": "dot_memory_bank"
   }
 }

package/dist/cli/run-cli.js

@@ -1,6 +1,8 @@
 import fs from "node:fs";
 import path from "node:path";
+import { randomUUID } from "node:crypto";
 import { quote } from "shell-quote";
+import { observeLifecycleCommand } from "../services/lifecycle-invocations.js";
 import { assertLifecycleInvocationCurrent, awaitLifecycleInvocation, issueLifecycleInvocation, lifecycleInvocationScope, settleLifecycleInvocation, settleLifecycleRejection } from "../services/lifecycle-invocations.js";
 import { createContext, createRouterContext } from "../runtime/context.js";
 import { migrateStoreWriter } from "../storage/writer-migration.js";
@@ -84,6 +86,8 @@ export async function runCli(args, io = defaultIo, env = process.env) {
     const progress = progressForCommand(output.args);
     let heartbeat;
     let invocationSettlement;
+    let settleHook;
+    let diagnosticHome;
     try {
         if (output.args.length === 1 && output.args[0] === "--version") {
             const payload = getCliVersionReport();
@@ -130,17 +134,22 @@ export async function runCli(args, io = defaultIo, env = process.env) {
         const dispatchContext = routed?.inProcess
             ? createContext({ ...env, DD_FLOW_ENGINE_MODE: "1", DD_FLOW_ENGINE_HOME: "in-process", DD_FLOW_ROUTED_FROM: getCliVersionReport().cli.version }, databaseModeForCommand(output.args, classification))
             : createContext({ ...env }, databaseModeForCommand(output.args, classification));
+        diagnosticHome = dispatchContext.ddFlowHome;
         preflightCliCompatibility(dispatchContext, output.args, env, scopeProjectRoot);
         dispatchContext.env.DD_FLOW_INVOCATION_READONLY = classification.mode === "read_only_diagnostics" ? "1" : undefined;
         let dispatchArgs = output.args;
+        settleHook = observeLifecycleCommand(dispatchContext, quote(["dd-flow", ...dispatchArgs]));
         let retainedOutcome;
         const invocationId = optionalOption(parseArgs(output.args.slice(2)), "invocation-id");
         if (invocationId) {
             const command = quote(["dd-flow", ...output.args]);
             const admission = await awaitLifecycleInvocation(dispatchContext, { id: invocationId, command,
                 assertCurrent: scope => assertLifecycleInvocationCurrent(dispatchContext, scope, command) });
-            if (admission.replay)
+            if (admission.replay) {
                 retainedOutcome = admission.outcome;
+                settleHook = undefined;
+                delete dispatchContext.observeLifecycleHook;
+            }
             else {
                 invocationSettlement = { context: dispatchContext, id: invocationId };
                 dispatchArgs = [...output.args, "--hook-event-id", admission.eventKey];
@@ -152,7 +161,12 @@ export async function runCli(args, io = defaultIo, env = process.env) {
             const error = retainedOutcome.error;
             throw new AppError(error.code, error.message, error.exitCode, error.details);
         }
+        if (!retainedOutcome)
+            settleHook = observeLifecycleCommand(dispatchContext, quote(["dd-flow", ...dispatchArgs]));
         const result = retainedOutcome ? retainedOutcome.result : await dispatch(dispatchArgs, dispatchContext, io, scopeProjectRoot, classification, output);
+        const completedHook = settleHook;
+        settleHook = undefined;
+        completedHook?.({ result });
         if (invocationSettlement) {
             const completed = invocationSettlement;
             invocationSettlement = undefined;
@@ -175,10 +189,23 @@ export async function runCli(args, io = defaultIo, env = process.env) {
             io.stdout.write(renderHumanResult(output.args, payload));
         return completedCommandExitCode(payload);
     }
-    catch (error) {
+    catch (caught) {
+        const error = isAppError(caught) ? caught : new AppError("unexpected", caught instanceof Error ? caught.message : String(caught), 1, { effect: "unknown", cause: { code: caught?.code ?? null, sqlite_extended_code: caught?.errcode ?? null } });
+        if (diagnosticHome && (!isAppError(caught) || error.code === "storage_write_failed")) {
+            try {
+                const directory = path.join(diagnosticHome, "diagnostics", "cli");
+                fs.mkdirSync(directory, { recursive: true });
+                const artifact = path.join(directory, `${randomUUID()}.json`);
+                fs.writeFileSync(artifact, JSON.stringify({ code: error.code, message: error.message, details: error.details, stack: caught instanceof Error ? caught.stack : null }), { flag: "wx", mode: 0o600 });
+                error.details.diagnostic_artifact = artifact;
+            }
+            catch (secondary) {
+                io.stderr.write(`CLI diagnostic persistence failed: ${String(secondary)}\n`);
+            }
+        }
         if (heartbeat)
             clearInterval(heartbeat);
-        if (invocationSettlement) {
+        if (invocationSettlement && error.details.effect !== "committed") {
             try {
                 if (isAppError(error))
                     settleLifecycleRejection(invocationSettlement.context, invocationSettlement.id, { code: error.code, message: error.message, exitCode: error.exitCode, details: error.details });
@@ -189,6 +216,14 @@ export async function runCli(args, io = defaultIo, env = process.env) {
                 io.stderr.write(`Invocation settlement persistence failed: ${String(persistenceError)}\n`);
             }
         }
+        if (settleHook) {
+            try {
+                settleHook({ error: isAppError(error) ? error : { code: "unexpected", message: String(error), details: {} } });
+            }
+            catch (persistence) {
+                io.stderr.write(`${JSON.stringify({ primary: String(error), lifecycle_persistence_error: String(persistence) })}\n`);
+            }
+        }
         const payload = isAppError(error)
             ? { ok: false, error: { code: error.code, message: error.message, details: error.details } }
             : { ok: false, error: { code: "unexpected", message: String(error) } };
@@ -196,7 +231,13 @@ export async function runCli(args, io = defaultIo, env = process.env) {
         if (output.progressJsonl)
             writeProgressJsonl(io, "failed", payload.error.message, { code: payload.error.code });
         const errorPayload = attachProgress(payload, progress, output);
-        const visible = writeResponseFile(errorPayload, output);
+        let visible = errorPayload;
+        try {
+            visible = writeResponseFile(errorPayload, output);
+        }
+        catch (publication) {
+            error.details.response_publication_error = { code: publication?.code ?? "response_publication_failed", message: publication instanceof Error ? publication.message : String(publication) };
+        }
         if (output.json && output.progressJsonl)
             writeJson(io.stdout, errorPayload);
         else if (output.json)

package/dist/harness-runtime/lib/native-hook-command.mjs

@@ -28,6 +28,7 @@ export async function invokeNativeHook({ bin, args, payload, home, timeoutMs = 1
   });
   let result;
   try { result = JSON.parse(output); } catch { throw Object.assign(new Error("Invalid native hook JSON response"), { code: "native_hook_response_invalid" }); }
+  if (result?.ok === false && typeof result.error?.code === "string") throw Object.assign(new Error(result.error.message ?? "Native hook failed"), { code: result.error.code, details: result.error.details });
   if (!result || typeof result !== "object" || Array.isArray(result) || result.ok === false) throw Object.assign(new Error("Native hook did not return a successful protocol object"), { code: "native_hook_response_invalid" });
   return result;
 }

package/dist/harness-runtime/lib/process-json.mjs

@@ -30,22 +30,31 @@ export async function commandJson(bin, args, { cwd, env = {}, input = null, onPr
     const executable = bin === "dd-flow" && typeof env.DD_FLOW_BIN === "string" ? env.DD_FLOW_BIN : bin;
     const target = processTarget(executable, [...args, "--json"]);
     const child = spawn(target.command, target.args, { cwd, env: { ...process.env, ...env }, stdio: [input === null ? "ignore" : "pipe", "pipe", "pipe"] });
-    let stdout = ""; let stderr = ""; let pendingStderr = "";
+    let stdout = ""; let stderr = ""; let pendingStderr = ""; let settled = false; let progressError = null;
+    const finish = (error, value) => { if (settled) return; settled = true; error ? reject(error) : resolve(value); };
+    const deliverProgress = (line) => {
+      let value; try { value = JSON.parse(line); } catch { return; }
+      if (typeof onProgress !== "function" || progressError) return;
+      try { const returned = onProgress(value); if (returned && typeof returned.then === "function") { Promise.resolve(returned).catch(() => {}); throw failure("commandJson onProgress must be synchronous", "progress_callback_async"); } }
+      catch (error) { progressError = error; child.kill("SIGKILL"); }
+    };
     child.stdout.setEncoding("utf8").on("data", (data) => { stdout += data; });
     child.stderr.setEncoding("utf8").on("data", (data) => {
       stderr += data; pendingStderr += data;
       for (;;) {
         const end = pendingStderr.indexOf("\n"); if (end < 0) break;
         const line = pendingStderr.slice(0, end); pendingStderr = pendingStderr.slice(end + 1);
-        if (typeof onProgress === "function") { try { onProgress(JSON.parse(line)); } catch { /* Ordinary diagnostics stay in stderr evidence. */ } }
+        deliverProgress(line);
       }
     });
-    child.on("error", reject);
+    child.once("error", (error) => finish(progressError ?? error));
     if (input !== null) child.stdin.end(input);
     child.on("close", (status) => {
-      if (status !== 0) return reject(reportedFailure(stdout, stderr, `${executable} exited ${status}`));
-      try { resolve(JSON.parse(stdout.trim())); }
-      catch (error) { reject(failure(`${bin} returned invalid JSON: ${error.message}`, "flow_reconciliation_failed")); }
+      if (pendingStderr) deliverProgress(pendingStderr);
+      if (progressError) return finish(progressError);
+      if (status !== 0) return finish(reportedFailure(stdout, stderr, `${executable} exited ${status}`));
+      try { const value = JSON.parse(stdout.trim()); if (value?.ok === false) { const error = value.error && typeof value.error === "object" ? value.error : value; if (typeof error.code === "string") return finish(reportedError(error, `${bin} returned an error envelope`)); } finish(null, value); }
+      catch (error) { finish(failure(`${bin} returned invalid JSON: ${error.message}`, "flow_reconciliation_failed")); }
     });
   });
 }

package/dist/services/cleanup.js

@@ -184,7 +184,7 @@ export function cleanupApply(context, input) {
     validateNoDestructiveSurprises(context, plan, input.force);
     const now = context.now();
     const results = [];
-    context.db.exec("BEGIN IMMEDIATE");
+    context.db.beginWriteTransaction();
     try {
         for (const action of plan.actions) {
             results.push(applyAction(context, action, reason, input.force, now));

package/dist/services/code-checks.js

@@ -291,7 +291,7 @@ export function reconcileUnfinishedChecks(context, input) {
     return reconciled;
 }
 function reserveOrReuseReceipt(context, input) {
-    context.db.exec("BEGIN IMMEDIATE");
+    context.db.beginWriteTransaction();
     try {
         assertRunMutationAllowed(context, input.projectId, input.runId, input.generation);
         const prior = latestApplicableReceipt(context, input);

package/dist/services/eval-snapshots.js

@@ -405,7 +405,7 @@ function detachSnapshotRuntimeOwners(context, snapshot, manifest) {
         fs.writeFileSync(file, `${JSON.stringify({ schema_id: "dd-flow/snapshot-runtime-lineage@1", source_snapshot: snapshot, source_manifest_sha256: fileHash(path.join(snapshot, "snapshot.json")), source_runtime: manifest.dd_flow_home, restored_runtime: context.ddFlowHome, run_id: manifest.run_id, run_tables: runTables, resource_tables: resourceTables }, null, 2)}\n`, { flag: "wx", mode: 0o600 });
         syncPath(file);
         syncPath(directory);
-        context.db.exec("BEGIN IMMEDIATE");
+        context.db.beginWriteTransaction();
         try {
             context.db.run("UPDATE sessions SET metadata_json = json_set(metadata_json, '$.snapshot_import', json(?))", [JSON.stringify({ lineage_file: file, lineage_sha256: fileHash(file) })]);
             for (const table of detachedTables)
@@ -439,7 +439,7 @@ function detachSnapshotRuntimeOwners(context, snapshot, manifest) {
 }
 function rebaseRuntime(context, oldRoot, newRoot, oldWorkspace, newWorkspace, oldHome, newHome, recovery = false) {
     context.db.exec("PRAGMA foreign_keys = OFF");
-    context.db.exec("BEGIN IMMEDIATE");
+    context.db.beginWriteTransaction();
     try {
         context.db.run("UPDATE projects SET root = ?", [newRoot]);
         context.db.run("UPDATE runs SET project_root = ?, workspace_root = ?", [newRoot, newWorkspace]);

package/dist/services/harness-adapter.js

@@ -53,13 +53,19 @@ export function runHarnessAdapter(input) {
         env.DD_FLOW_RUNTIME_OWNER = JSON.stringify({ ...input.runtimeOwner, adapter_executable: input.executable });
     }
     return new Promise((resolve, reject) => {
+        if (input.signal?.aborted)
+            return reject(new AppError("harness_adapter_aborted", "Harness adapter call was cancelled before dispatch", 1));
         const detached = process.platform !== "win32";
         const child = spawn(input.executable, input.args, { env, ...(input.cwd ? { cwd: input.cwd } : {}), detached, stdio: ["ignore", "pipe", "pipe"] });
         let stdout = "";
         let stderr = "";
         let outputTooLarge = false;
         let timedOut = false;
+        let aborted = false;
         let killTimer;
+        let settled = false;
+        let callbackError;
+        let spawnError;
         const terminate = (signal) => { try {
             if (detached && child.pid)
                 process.kill(-child.pid, signal);
@@ -67,39 +73,73 @@ export function runHarnessAdapter(input) {
                 child.kill(signal);
         }
         catch { /* The process already settled. */ } };
-        const heartbeat = input.progress && input.progressMessage ? setInterval(() => input.progress?.(`${input.progressMessage}; waiting for adapter completion`), 15_000) : undefined;
-        const timer = setTimeout(() => { timedOut = true; terminate("SIGTERM"); killTimer = setTimeout(() => terminate("SIGKILL"), 5_000); }, timeoutMs);
+        const stopTransport = () => { terminate("SIGTERM"); killTimer ??= setTimeout(() => terminate("SIGKILL"), 5_000); };
+        const deliver = (callback) => {
+            try {
+                const result = callback();
+                if (result && typeof result.then === "function") {
+                    void Promise.resolve(result).catch(() => { });
+                    throw new AppError("progress_callback_async", "Harness callbacks must be synchronous", 1);
+                }
+            }
+            catch (error) {
+                callbackError ??= error;
+                if (!settled)
+                    stopTransport();
+            }
+        };
+        const heartbeat = input.progress && input.progressMessage ? setInterval(() => deliver(() => input.progress?.(`${input.progressMessage}; waiting for adapter completion`)), 15_000) : undefined;
+        const timer = setTimeout(() => { timedOut = true; stopTransport(); }, timeoutMs);
+        const abort = () => { aborted = true; stopTransport(); };
+        if (input.signal?.aborted)
+            abort();
+        else
+            input.signal?.addEventListener("abort", abort, { once: true });
         const evidence = (value) => input.onEvidence?.({ operation_id: input.operationId, executable: input.executable, args: input.args, ...value, at: new Date().toISOString() });
         const append = (current, chunk) => {
             if (Buffer.byteLength(current) + Buffer.byteLength(chunk) > maxAdapterOutputBytes) {
                 outputTooLarge = true;
-                terminate("SIGTERM");
+                stopTransport();
                 return current;
             }
             return current + chunk;
         };
         child.stdout.setEncoding("utf8").on("data", (chunk) => { stdout = append(stdout, chunk); });
         child.stderr.setEncoding("utf8").on("data", (chunk) => { stderr = append(stderr, chunk); });
-        child.once("error", (error) => { clearTimeout(timer); if (heartbeat)
-            clearInterval(heartbeat); if (killTimer)
-            clearTimeout(killTimer); evidence({ status: null, error: error.message }); reject(new AppError("harness_adapter_failed", "Harness adapter call failed", 1, { executable: input.executable, args: input.args.slice(0, 3), error: error.message })); });
+        child.once("error", (error) => { spawnError = error; });
         child.once("close", (status, signal) => {
+            if (settled)
+                return;
+            settled = true;
             clearTimeout(timer);
+            input.signal?.removeEventListener("abort", abort);
             if (heartbeat)
                 clearInterval(heartbeat);
-            if (killTimer)
+            if (killTimer) {
                 clearTimeout(killTimer);
-            evidence({ status, signal, timed_out: timedOut, stdout, stderr });
+                terminate("SIGKILL");
+            }
+            const progressFailure = callbackError;
+            deliver(() => evidence({ status, signal, timed_out: timedOut, aborted, stdout, stderr, ...(spawnError ? { error: spawnError.message } : {}) }));
+            if (spawnError)
+                return reject(new AppError("harness_adapter_failed", "Harness adapter call failed", 1, { cause: adapterCause(spawnError.message), ...(callbackError ? { evidence_error: String(callbackError) } : {}) }));
             if (outputTooLarge)
                 return reject(new AppError("harness_adapter_output_limit", "Harness adapter exceeded the bounded reply limit", 1, { executable: input.executable, args: input.args.slice(0, 3), max_output_bytes: maxAdapterOutputBytes }));
             if (timedOut)
                 return reject(new AppError("harness_adapter_timeout", "Harness adapter call timed out", 1, { executable: input.executable, args: input.args.slice(0, 3), timeout_ms: timeoutMs }));
+            if (aborted)
+                return reject(new AppError("harness_adapter_aborted", "Harness adapter call was cancelled", 1, { executable: input.executable, args: input.args.slice(0, 3) }));
             if (status !== 0)
-                return reject(new AppError("harness_adapter_failed", "Harness adapter call failed", 1, { executable: input.executable, args: input.args.slice(0, 3), status, signal, stderr }));
+                return reject(progressFailure ?? new AppError("harness_adapter_failed", "Harness adapter call failed", 1, { executable: input.executable, args: input.args.slice(0, 3), status, signal, stderr, cause: adapterCause(stdout, stderr), ...(callbackError ? { evidence_error: String(callbackError) } : {}) }));
+            if (callbackError)
+                return reject(callbackError);
             try {
                 const reply = JSON.parse(stdout);
                 if (!reply || typeof reply !== "object" || Array.isArray(reply))
                     throw new Error("not object");
+                const value = reply;
+                if (value.ok === false && typeof value.error?.code === "string")
+                    return reject(new AppError("harness_adapter_failed", "Harness adapter reported a runtime failure", 1, { cause: adapterCause(stdout) }));
                 resolve(reply);
             }
             catch {
@@ -108,6 +148,18 @@ export function runHarnessAdapter(input) {
         });
     });
 }
+function adapterCause(...outputs) {
+    for (const output of outputs)
+        for (const line of [output.trim(), ...output.trim().split("\n").reverse()]) {
+            try {
+                const value = JSON.parse(line);
+                if (typeof value.error?.code === "string")
+                    return { ...value.error, message: typeof value.error.message === "string" ? value.error.message : value.error.code };
+            }
+            catch { /* Adapter diagnostics need not be JSON. */ }
+        }
+    return { message: outputs.map(output => output.trim()).filter(Boolean).join("\n") || "adapter process failed" };
+}
 export function adapterSessionId(value) {
     if (!value || typeof value !== "object")
         return null;

package/dist/services/hooks.js

@@ -879,6 +879,31 @@ function lifecycleMatchKey(facts, projectRoot) {
         return workLifecycleMatchKey("work_fail", workId, projectRoot);
     return null;
 }
+/** Observe exact immutable command attribution before reading model-supplied
+ * result files. This does not claim or authorize the lifecycle mutation. */
+export function observeCommandHook(context, command) {
+    const facts = lifecycleFacts(command);
+    if (!facts || facts.analysis.kind !== "standalone" || !facts.commandProjectRoot)
+        return;
+    const project = context.db.get("SELECT id FROM projects WHERE root = ?", [resolveProjectRoot(facts.commandProjectRoot)]);
+    if (!project)
+        return; // Bootstrap has not registered a project yet.
+    const matchKey = lifecycleMatchKey(facts, facts.commandProjectRoot);
+    if (!matchKey)
+        return;
+    let key = commandOption(facts.invocation, "hook-event-id");
+    if (!key) {
+        try {
+            key = findRecentMatchingHookEvent(context, { projectId: project.id, matchKey, errorCode: "trusted_session_binding_required", operation: facts.invocation.operation }).eventKey;
+        }
+        catch {
+            return;
+        } // Dispatch still owns its mandatory admission error.
+    }
+    const event = context.db.get("SELECT id FROM hook_events WHERE project_id = ? AND event_key = ? AND match_key = ? AND status = 'observed'", [project.id, key, matchKey]);
+    if (event)
+        context.observeLifecycleHook?.(project.id, event.id);
+}
 export function stageLifecycleMatchKey(operation, runId, stage, projectRoot, workId) {
     return crypto.createHash("sha256").update(JSON.stringify({ operation, run_id: runId, stage, project_root: resolveProjectRoot(projectRoot), ...(workId ? { work_id: workId } : {}) })).digest("hex");
 }
@@ -935,6 +960,7 @@ export function hookSessionIdentity(context, projectId, eventKey) {
      WHERE he.project_id = ? AND he.event_key = ?`, [projectId, eventKey]);
     if (!event?.session_id)
         throw new AppError("hook_event_not_found", "stage start requires a trusted PreToolUse hook event", 1, { event_key: eventKey });
+    context.observeLifecycleHook?.(projectId, event.id);
     return {
         hookEventId: event.id,
         harness: event.harness,

package/dist/services/lanes.js

@@ -515,7 +515,7 @@ function ensureQueuedLaneWaiter(context, input) {
 function tryAcquireQueuedLaneLock(context, input) {
     expireStaleLocks(context, input.projectId);
     expireStaleWaiters(context, input.projectId);
-    context.db.exec("BEGIN IMMEDIATE");
+    context.db.beginWriteTransaction();
     try {
         const existingLock = activeLaneLock(context, input.projectId, input.lane);
         if (existingLock?.worker_id === input.workerId) {