@deksden-com/dd-flow-cli 0.9.0-beta.26 → 0.9.0-beta.28

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @deksden-com/dd-flow-cli
 
+## 0.9.0-beta.28
+
+### Patch Changes
+
+- Accept an authoritative terminal Antigravity root result when the provider omits a root Stop hook, while retaining fail-closed behavior for an observed non-idle tree.
+
+## 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

package/dist/build-info.json

@@ -1,11 +1,11 @@
 {
   "cli_package": "@deksden-com/dd-flow-cli",
-  "cli_version": "0.9.0-beta.26",
-  "cli_commit": "ca419f51a8553a6ddb6a8275412a98bfa10bd0d4",
-  "built_at": "2026-09-07T04:40:50.669Z",
+  "cli_version": "0.9.0-beta.28",
+  "cli_commit": "575fa0e034bf7564748628ae4d7d70ffa04be1c9",
+  "built_at": "2026-09-07T08:09:01.885Z",
   "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/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) {
@@ -202,7 +224,11 @@ export class Runtime {
     const assistantText = typeof result?.response === "string" ? result.response : typeof result?.text === "string" ? result.text : null;
     const root = this.init?.conversation_id; const observation = this.sessionObservations.get(root);
     const treeSettled = [...this.descendants.values()].every(child => ["completed", "failed", "cancelled"].includes(child.status));
-    return { harness: "antigravity-cli", runtime_family: "antigravity", provider_session_id: root ?? null, adapter_session_id: root ?? null, cwd: this.config.cwd, profile: this.profile, result, ...(assistantText === null ? {} : { assistant_text: assistantText }), usage: usageSnapshot(result ?? {}, this.toolSnapshot()), usage_ingest: this.usageIngest, descendants: [...this.descendants.values()], transcript_path: observation?.transcript_path ?? null, settled: Boolean(!this.active && result && result.status !== "RUNNING" && treeSettled && (this.descendants.size === 0 || observation?.stop?.fullyIdle === true)) };
+    // A terminal root result is the provider's authoritative end-of-turn
+    // observation when AGY does not emit a root Stop hook.  A received
+    // non-idle Stop still wins, and every discovered child must be terminal.
+    const rootSettled = observation?.stop?.fullyIdle !== false;
+    return { harness: "antigravity-cli", runtime_family: "antigravity", provider_session_id: root ?? null, adapter_session_id: root ?? null, cwd: this.config.cwd, profile: this.profile, result, ...(assistantText === null ? {} : { assistant_text: assistantText }), usage: usageSnapshot(result ?? {}, this.toolSnapshot()), usage_ingest: this.usageIngest, descendants: [...this.descendants.values()], transcript_path: observation?.transcript_path ?? null, settled: Boolean(!this.active && result && result.status !== "RUNNING" && treeSettled && rootSettled) };
   }
   async zeroUsage() { await forwardUsage(this.config, this.init.conversation_id, { usage: {} }, this.toolSnapshot(), []); }
   async prompt(text, assertDispatch = captureDispatchGuard(this)) { if (!text) throw new DaemonError("prompt_required", "prompt is required"); await this.start(); if (this.active) throw new DaemonError("operation_in_progress", "an Antigravity turn is already running"); if (this.lastResult && !this.receipt().settled) throw new DaemonError("tree_not_settled", "the prior Antigravity agent tree is not fully settled"); const root = this.init?.conversation_id; const prior = this.sessionObservations.get(root) ?? {}; this.sessionObservations.set(root, { ...prior, execution_floor: prior.stop?.executionNum ?? prior.execution_floor ?? null, stop: null }); this.lastProviderEvent = null; await this.persist({ active_tree: true }); return await new Promise((resolve, reject) => { assertDispatch(); this.active = { resolve, reject }; this.child.stdin.write(`${JSON.stringify({ event: "user", message: { content: text } })}\n`, error => { if (error) { this.active = null; reject(error); } }); }); }

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.26",
+  "version": "0.9.0-beta.28",
   "description": "Mechanical runtime CLI for dd-flow workflows.",
   "type": "module",
   "bin": {
@@ -22,16 +22,6 @@
     "node": ">=26.0.0",
     "pnpm": ">=10.0.0"
   },
-  "scripts": {
-    "build": "tsc -p tsconfig.build.json && node scripts/generate-build-info.mjs && node scripts/copy-assets.mjs",
-    "typecheck": "tsc --noEmit",
-    "lint": "eslint . --max-warnings=0",
-    "test": "vitest run --pool=forks --no-file-parallelism",
-    "changeset": "changeset",
-    "version-packages": "changeset version",
-    "release": "pnpm run build && changeset publish",
-    "prepublishOnly": "node scripts/verify-release-build.mjs"
-  },
   "devDependencies": {
     "@changesets/cli": "^2.31.0",
     "@eslint/js": "^9.39.1",
@@ -50,5 +40,14 @@
   "publishConfig": {
     "access": "public"
   },
-  "license": "MIT"
-}
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json && node scripts/generate-build-info.mjs && node scripts/copy-assets.mjs",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint . --max-warnings=0",
+    "test": "vitest run --pool=forks --no-file-parallelism",
+    "changeset": "changeset",
+    "version-packages": "changeset version",
+    "release": "pnpm run build && changeset publish"
+  }
+}