@deksden-com/dd-flow-cli 0.9.0-beta.25 → 0.9.0-beta.27

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @deksden-com/dd-flow-cli
 
+## 0.9.0-beta.27
+
+### Patch Changes
+
+- Resume retained native sessions from their active coordinator WorkSession, preserving the root launch record and rejecting lifecycle receipts from retired daemons.
+- Propagate Antigravity lifecycle hooks to direct native children while preserving workspace hooks, and settle confirmed Codex system-error turns without losing provider failure evidence.
+
+## 0.9.0-beta.26
+
+### Patch Changes
+
+- Reject interactive terminal input for Work and Stage result submission before routing or lifecycle dispatch. Require a pipe, input redirection, or result file so long JSON cannot be truncated by terminal input limits while progress appears to run indefinitely.
+
 ## 0.9.0-beta.25
 
 ### Patch Changes

package/dist/build-info.json

@@ -1,11 +1,11 @@
 {
   "cli_package": "@deksden-com/dd-flow-cli",
-  "cli_version": "0.9.0-beta.25",
-  "cli_commit": "73e454ebdded3258c2c567e3495724b93ef528b6",
-  "built_at": "2026-09-07T04:06:44.087Z",
+  "cli_version": "0.9.0-beta.27",
+  "cli_commit": "f619ffc1750da72ea36703933265005be43a5401",
+  "built_at": "2026-09-07T07:04:13.513Z",
   "built_with_canon": {
     "version": "4.0.6",
-    "commit": "2aafb30d23e3f646b736b7ead25438cab97b16bf",
+    "commit": "c6fc50cb3b5526ea0162ee4454d1ee36f17be2da",
     "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",

package/dist/cli/run-cli.js

@@ -78,6 +78,10 @@ export async function runCli(args, io = defaultIo, env = process.env) {
             io.stdout.write(`${help}\n`);
             return 0;
         }
+        if (io.stdin?.isTTY && ["work", "stage"].includes(output.args[0] ?? "") && output.args[1] === "finish"
+            && hasOption(parseArgs(output.args.slice(2)), "result-stdin")) {
+            throw new AppError("usage", "--result-stdin requires non-interactive input. Pipe or redirect the complete JSON into this command, or use --result-file; interactive terminals can truncate long JSON and wait indefinitely for EOF.", 2);
+        }
         const classification = classifyCliOperation(output.args, env);
         if (requiresExplicitUpgradeAuthorization(output.args) && classification.mode !== "mb_upgrade") {
             throw new AppError("upgrade_authorization_required", "This mb-upgrade command requires the explicit mb-upgrade authorization marker and allowlisted target context", 1, {

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

@@ -45,8 +45,30 @@ async function prepare(paths, config) {
     PostToolUse: [{ matcher: "*", hooks: [{ type: "command", command: command.replace("__EVENT__", "PostToolUse"), timeout: 30 }] }],
     Stop: [{ type: "command", command: command.replace("__EVENT__", "Stop"), timeout: 30 }]
   } };
+  // Antigravity's process-level configuration is not inherited by native
+  // subagents. Put the same handlers in the isolated workspace discovery
+  // root before the first Session is created, preserving unrelated hooks.
+  const workspaceConfig = path.join(config.projectRoot, ".agents");
+  await mkdir(workspaceConfig, { recursive: true, mode: 0o700 });
+  const workspaceHooks = path.join(workspaceConfig, "hooks.json");
+  let existing = {};
+  try {
+    const parsed = JSON.parse(await readFile(workspaceHooks, "utf8"));
+    if (!parsed || Array.isArray(parsed) || typeof parsed !== "object") throw new Error("not an object");
+    existing = parsed;
+  } catch (error) {
+    if (error.code !== "ENOENT") throw new DaemonError("workspace_hooks_invalid", `cannot install Antigravity lifecycle hooks: ${error.message}`);
+  }
+  const workspace = { ...existing };
+  const isManagedHandler = handler => typeof handler?.command === "string" && handler.command.includes(config.entryPath) && handler.command.includes("hook handle");
+  for (const [event, handlers] of Object.entries(hooks["dd-flow"])) {
+    const retained = Array.isArray(existing[event]) ? existing[event].filter(item => Array.isArray(item?.hooks) ? !item.hooks.some(isManagedHandler) : !isManagedHandler(item)) : [];
+    workspace[event] = [...retained, ...handlers];
+  }
+  await writeJson(workspaceHooks, workspace);
   await writeJson(path.join(paths.config, "hooks.json"), hooks);
   config.hooksSha256 = createHash("sha256").update(JSON.stringify(hooks)).digest("hex");
+  config.workspaceHooksPath = workspaceHooks;
 }
 
 export async function callDaemon(stateDir, operation, params = {}, timeoutMs = 30_000) {

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

@@ -20,6 +20,14 @@ async function readState(file) { try { return JSON.parse(await readFile(file, "u
 async function writeState(file, value) { const temp = `${file}.${process.pid}.tmp`; await writeFile(temp, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 }); await rename(temp, file); }
 async function removeSocket(socket) { try { const info = await lstat(socket); if (!info.isSocket()) throw Object.assign(new Error("refusing to remove non-socket daemon path"), { code: "unsafe_socket" }); await unlink(socket); } catch (error) { if (error.code !== "ENOENT") throw error; } }
 const errorPayload = errorRecord;
+const terminalTurn = turn => ["completed", "interrupted", "failed", "cancelled"].includes(turn?.status);
+export function settledCodexSession(status, latestTurn, active) {
+  if (status === "idle") return true;
+  if (status === "notLoaded") return !latestTurn || terminalTurn(latestTurn);
+  // `systemError` alone is not evidence that the provider stopped. A current
+  // terminal Turn plus no daemon operation is the narrow settled case.
+  return status === "systemError" && !active && terminalTurn(latestTurn);
+}
 
 export async function callDaemon(stateDir, operation, params = {}, timeoutMs = 30_000) {
   const target = locations(stateDir); const request = { schema_id: requestSchema, id: process.env.DD_EVAL_OPERATION_ID ?? randomUUID(), operation, params };
@@ -69,9 +77,8 @@ export async function serveDaemon(stateDir) {
             const observed = await inspectSessionWithBridge(bridge, { ...state.config, sessionId });
             for (const child of observed.descendants ?? []) sessions.add(child.provider_session_id);
             const status = observed.status?.type ?? observed.status;
-            const stored = status === "notLoaded" ? await bridge.request("thread/turns/list", { threadId: sessionId, limit: 1, sortDirection: "desc", itemsView: "summary" }, 5_000) : null;
-            const terminalUnloaded = status === "notLoaded" && Array.isArray(stored?.data) && (stored.data.length === 0 || ["completed", "interrupted", "failed", "cancelled"].includes(stored.data[0]?.status));
-            if (status !== "idle" && !terminalUnloaded) unsettled.push(sessionId);
+            const stored = ["notLoaded", "systemError"].includes(status) ? await bridge.request("thread/turns/list", { threadId: sessionId, limit: 1, sortDirection: "desc", itemsView: "summary" }, 5_000) : null;
+            if (!settledCodexSession(status, stored?.data?.[0] ?? null, active)) unsettled.push(sessionId);
           }
           return { sessions: unsettled.reverse(), active: Boolean(active), active_operation: active };
         },

package/dist/harness-runtime/lib/dd-codex.mjs

@@ -9,7 +9,7 @@ import { observeModel } from "./model-observations.mjs";
 // Minimal JSON-RPC wrapper around the public Codex app-server protocol.  It is
 // intentionally one-shot: the provider owns durable Threads, while the caller
 // owns the runner journal and can safely resume after a process restart.
-function fail(message, code) { const error = new Error(message); if (code) error.code = code; throw error; }
+function fail(message, code, details) { const error = new Error(message); if (code) error.code = code; if (details) error.details = details; throw error; }
 function required(value, label) { if (typeof value !== "string" || !value.trim()) fail(`${label} is required`); return value.trim(); }
 function absolute(value, label) { const resolved = path.resolve(required(value, label)); if (!path.isAbsolute(resolved)) fail(`${label} must be absolute`); return resolved; }
 function now() { return new Date().toISOString(); }
@@ -305,7 +305,7 @@ function terminalTurn(value, turnId, bridge) {
   const observed = bridge.turns.get(turnId);
   if (observed?.status === "completed") value = observed.value;
   const turn = value?.turn ?? value;
-  if (turn?.status && turn.status !== "completed") fail(`Codex turn ${turnId ?? "unknown"} ended as ${turn.status}`, "turn_interrupted");
+  if (turn?.status && turn.status !== "completed") fail(`Codex turn ${turnId ?? "unknown"} ended as ${turn.status}`, "turn_interrupted", { turn_id: turn.id ?? turnId ?? null, terminal_status: turn.status, provider_error: turn.error ?? turn.codexErrorInfo ?? null });
   return value;
 }
 

package/dist/services/run-recovery.js

@@ -68,7 +68,10 @@ export function assertRecoveryHookCurrent(context, projectId, runId, identity) {
     const generation = assertRunMutationAllowed(context, projectId, runId);
     if (!generation)
         return;
-    const retired = identity.daemonId && (context.db.get(`SELECT ws.id FROM work_sessions ws JOIN works w ON w.work_id = ws.work_id JOIN hook_events he ON he.project_id = w.project_id AND he.event_key = ws.hook_event_id WHERE w.project_id = ? AND w.run_id = ? AND ws.status = 'interrupted' AND he.daemon_id = ? LIMIT 1`, [projectId, runId, identity.daemonId]) || context.db.get("SELECT b.recovery_id FROM run_recovery_bindings b JOIN run_recovery_guards g ON g.recovery_id = b.recovery_id WHERE g.project_id = ? AND g.run_id = ? AND b.daemon_id = ? AND b.status = 'abandoned' LIMIT 1", [projectId, runId, identity.daemonId]));
+    const current = identity.daemonId && context.db.get("SELECT b.recovery_id FROM run_recovery_bindings b JOIN run_recovery_guards g ON g.recovery_id = b.recovery_id WHERE g.project_id = ? AND g.run_id = ? AND g.status = 'recovered' AND b.status = 'accepted' AND b.daemon_id = ? LIMIT 1", [projectId, runId, identity.daemonId]);
+    if (current)
+        return;
+    const retired = identity.daemonId && (context.db.get(`SELECT ws.id FROM work_sessions ws JOIN works w ON w.work_id = ws.work_id JOIN hook_events he ON he.project_id = w.project_id AND he.event_key = ws.hook_event_id WHERE w.project_id = ? AND w.run_id = ? AND he.daemon_id = ? LIMIT 1`, [projectId, runId, identity.daemonId]) || context.db.get("SELECT b.recovery_id FROM run_recovery_bindings b JOIN run_recovery_guards g ON g.recovery_id = b.recovery_id WHERE g.project_id = ? AND g.run_id = ? AND b.daemon_id = ? AND b.status = 'abandoned' LIMIT 1", [projectId, runId, identity.daemonId]));
     if (!identity.daemonId || retired)
         throw new AppError("recovery_daemon_stale", "Lifecycle receipt belongs to an unidentified or retired recovery daemon", 1, { run_id: runId, generation, daemon_id: identity.daemonId });
 }
@@ -155,9 +158,12 @@ export function resumeRunRecovery(context, input) {
     }
     if (guard.status !== "sealed" || !guard.capture_path)
         throw new AppError("recovery_capture_required", "Recovery must be sealed and captured before it can resume", 1, { recovery_id: guard.recovery_id, status: guard.status });
-    // The root coordinator keeps its same native Session and receives a recovery
-    // prompt from the eval runner. Only delegated Work is returned to the ready
-    // graph and therefore gets a fresh, addressable recovery packet.
+    // The coordinator keeps its same native Session and receives a recovery
+    // prompt from the eval runner. A root Work may have recorded its launch as
+    // complete while its currently active Stage Work owns that Session, so bind
+    // the active WorkSession rather than assuming the root row is still running.
+    // Only delegated Work is returned to the ready graph and therefore gets a
+    // fresh, addressable recovery packet.
     verifyRecoverySnapshot(guard.capture_path, { runId: run.id, recoveryId: guard.recovery_id, projectRoot: run.project_root, workspaceRoot: run.workspace_root });
     const now = context.now();
     let running = [];
@@ -168,14 +174,14 @@ export function resumeRunRecovery(context, input) {
             throw new AppError("recovery_state_changed", "Recovery state changed before its resume transaction", 1, { recovery_id: guard.recovery_id });
         if (!input.daemonId?.trim() || !input.harness?.trim() || !input.nativeSessionId?.trim())
             throw new AppError("recovery_identity_required", "Recovery requires the replacement daemon and retained native Session identity", 1);
-        const owner = context.db.get(`SELECT w.work_id, ws.id, ws.session_id FROM works w JOIN work_sessions ws ON ws.work_id = w.work_id JOIN sessions s ON s.project_id = w.project_id AND s.session_id = ws.session_id WHERE w.project_id = ? AND w.run_id = ? AND w.parent_work_id IS NULL AND w.status IN ('running', 'paused') AND ws.status = 'running' AND s.harness = ? AND s.provider_session_id = ? ORDER BY ws.created_at DESC LIMIT 1`, [project.id, run.id, input.harness, input.nativeSessionId]);
+        const owner = context.db.get(`SELECT w.work_id, ws.id, ws.session_id FROM works w JOIN work_sessions ws ON ws.work_id = w.work_id JOIN sessions s ON s.project_id = w.project_id AND s.session_id = ws.session_id WHERE w.project_id = ? AND w.run_id = ? AND w.status IN ('running', 'paused') AND ws.status = 'running' AND s.harness = ? AND s.provider_session_id = ? ORDER BY ws.created_at DESC LIMIT 1`, [project.id, run.id, input.harness, input.nativeSessionId]);
         if (!owner)
-            throw new AppError("recovery_owner_missing", "Recovery must retain the root coordinator's native Session", 1, { run_id: run.id });
+            throw new AppError("recovery_owner_missing", "Recovery must retain an active coordinator WorkSession in its native Session", 1, { run_id: run.id });
         if (context.db.get("SELECT id FROM hook_events WHERE project_id = ? AND daemon_id = ? LIMIT 1", [project.id, input.daemonId]) || context.db.get("SELECT b.recovery_id FROM run_recovery_bindings b JOIN run_recovery_guards g ON g.recovery_id = b.recovery_id WHERE g.project_id = ? AND b.daemon_id = ? LIMIT 1", [project.id, input.daemonId]))
             throw new AppError("recovery_daemon_stale", "Replacement daemon already has historical lifecycle authority in this project", 1);
         const packet = rootRecoveryPacket(context, run, guard, owner);
         context.db.run("INSERT INTO run_recovery_bindings (recovery_id, work_id, prior_work_session_id, session_id, harness, provider_session_id, daemon_id, status, created_at, packet_json, packet_sha256) VALUES (?, ?, ?, ?, ?, ?, ?, 'prepared', ?, ?, ?)", [guard.recovery_id, owner.work_id, owner.id, owner.session_id, input.harness, input.nativeSessionId, input.daemonId, now, packet, crypto.createHash("sha256").update(packet).digest("hex")]);
-        running = context.db.all("SELECT work_id, started_at, status FROM works WHERE project_id = ? AND run_id = ? AND parent_work_id IS NOT NULL AND (status = 'running' OR (status = 'created' AND EXISTS (SELECT 1 FROM work_recovery_segments s WHERE s.work_id = works.work_id AND s.status = 'prepared'))) ORDER BY work_id", [project.id, run.id]);
+        running = context.db.all("SELECT work_id, started_at, status FROM works WHERE project_id = ? AND run_id = ? AND work_id <> ? AND parent_work_id IS NOT NULL AND (status = 'running' OR (status = 'created' AND EXISTS (SELECT 1 FROM work_recovery_segments s WHERE s.work_id = works.work_id AND s.status = 'prepared'))) ORDER BY work_id", [project.id, run.id, owner.work_id]);
         for (const work of running)
             context.db.run("UPDATE work_recovery_segments SET status = 'superseded', updated_at = ? WHERE work_id = ? AND status = 'prepared'", [now, work.work_id]);
         for (const work of running) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deksden-com/dd-flow-cli",
-  "version": "0.9.0-beta.25",
+  "version": "0.9.0-beta.27",
   "description": "Mechanical runtime CLI for dd-flow workflows.",
   "type": "module",
   "bin": {