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

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @deksden-com/dd-flow-cli
 
+## 0.9.0-beta.143
+
+### Patch Changes
+
+- 60daf29: Keep an early AGY provider rejection as the readiness failure rather than a stream-drain cleanup failure. Preserve strict journal and physical cleanup errors.
+- d86445c: Observe accepted Codex Turns while persisted history is unavailable, preserving exact native outcomes, cancellation identity and conservative tree settlement. Keep RPC errors intact in compact journals.
+
+  Treat successful metadata-only history responses as incomplete in cancellation and final result admission; require exact current Turn item evidence before bypassing retained-output/profile safeguards. Reject incomplete cancellation records and terminal settlement without a valid Turn identity. Prefer native completed output over stale snapshots of the same Turn.
+
+## 0.9.0-beta.142
+
+### Patch Changes
+
+- Wait for the owned OpenCode v2 listener through typed SDK transport startup failures and expose bounded read-only scope inventory batches for validated retirement-proof reuse.
+- Retry no-effect physical confirmation on the same held check, bootstrap or service process before dispatch, without replaying commands or extending exhausted authority.
+- Backfilled from published artifact commit `19ca01d6`: Keep native Session observation stable, use bounded shared Codex read phases, scope check evidence to declared inputs, retain accepted intake/HITL review sources, and reject stale review coverage without productive replay. These changes were already shipped; beta.143 does not count them as new work.
+
 ## 0.9.0-beta.141
 
 ### Patch Changes

package/dist/build-info.json

@@ -1,15 +1,15 @@
 {
   "cli_package": "@deksden-com/dd-flow-cli",
-  "cli_version": "0.9.0-beta.141",
-  "cli_commit": "c370c6e9beaefba2216bbf5bbadac02e4827768f",
-  "built_at": "2026-10-17T22:37:48.634Z",
+  "cli_version": "0.9.0-beta.143",
+  "cli_commit": "2294710b9c9b678193798301d5a81048506d672d",
+  "built_at": "2026-10-20T02:52:47.825Z",
   "built_with_canon": {
     "version": "4.1.2",
-    "commit": "1ddedf9d3f086e046f8e7b194c739ec386e7c8b9",
+    "commit": "a1cfe8b06329c691c314064b6ea6a3da6628cceb",
     "flow_contract": "dd-flow-canonical-2026-08",
-    "repo_root": "/Users/deksden/Documents/_Projects/_worktrees/dd-canon-cp231-release",
-    "memorybank_root": "/Users/deksden/Documents/_Projects/_worktrees/dd-canon-cp231-release/.memory-bank",
-    "flow_root": "/Users/deksden/Documents/_Projects/_worktrees/dd-canon-cp231-release/.memory-bank/dd-flow",
+    "repo_root": "/Users/deksden/Documents/_Projects/_worktrees/dd-canon-plan092",
+    "memorybank_root": "/Users/deksden/Documents/_Projects/_worktrees/dd-canon-plan092/.memory-bank",
+    "flow_root": "/Users/deksden/Documents/_Projects/_worktrees/dd-canon-plan092/.memory-bank/dd-flow",
     "layout": "dot_memory_bank"
   }
 }

package/dist/cli/command-inputs.js

@@ -156,7 +156,7 @@ export const commandInputs = {
     "run control pause": route(0, `${control} request-id`, "grace-ms wait-ms escalate", "force"),
     "run control stop": route(0, `${control} request-id`, "grace-ms wait-ms escalate", "force"),
     "runtime scope fence": route(0, "scope-id request-id"),
-    "runtime scope status": route(0, "scope-id"),
+    "runtime scope status": route(0, "", "scope-id scope-ids-json"),
     "runtime scope stop": route(0, "scope-id request-id"),
     "runtime scope control": route(0, "scope-id request-id mode", "manifest-json", "", "", { mode: ["pause", "stop"] }),
     "runtime scope serve": route(0, "scope-id generation"),

package/dist/cli/command-option-descriptions.js

@@ -143,6 +143,7 @@ export const runtimeOptionDescriptions = {
     schema: "Registered JSON schema name against which the supplied file is validated.",
     "schema-dir": "Explicit schema directory for validation; not a workflow handler registry or permission to execute code.",
     "scope-id": "Exact retained runtime/EVAL scope identity; operations must not affect neighboring scopes.",
+    "scope-ids-json": "Read-only JSON array of 1..16 unique retained scope IDs; returns ordered fresh inventories without fencing or stopping them.",
     "semantic-file": "Stage semantic result artifact; applicable schema and finish checks are selected independently.",
     session: "Physical Session selector for source-backed usage aggregation.",
     "session-id": "Exact retained physical Session identity for registration, status, stop or usage synchronization.",

package/dist/cli/help.js

@@ -169,6 +169,7 @@ never registers a project, selects a model automatically or creates a runtime DB
     ["runtime scope", `Usage:
   dd-flow runtime scope fence --scope-id EVAL_ID --request-id ID --json
   dd-flow runtime scope status --scope-id EVAL_ID --json
+  dd-flow runtime scope status --scope-ids-json '["EVAL_ID","QUAL_ID"]' --json
   dd-flow runtime scope stop --scope-id EVAL_ID --request-id ID --json
   dd-flow runtime scope control --scope-id EVAL_ID --request-id ID --mode pause|stop [--manifest-json JSON] --json
   dd-flow runtime scope resume --scope-id EVAL_ID --request-id ID --generation N --capture-key SHA256 --json

package/dist/cli/run-cli.js

@@ -92,7 +92,7 @@ import { prepareCommandRoute } from "./command-inputs.js";
 import { parseLifecycleCommand } from "../services/lifecycle-command.js";
 import { dispatchRuntimeProcess, prepareRuntimeProcess } from "./runtime-process.js";
 import { reconcileFlowRunHealth } from "../services/run-health.js";
-import { fenceRuntimeBudget, runtimeBudgetStatus, prepareRuntimeScopeControl, prepareRuntimeScopeFence } from "../services/runtime-budget.js";
+import { fenceRuntimeBudget, runtimeBudgetStatus, prepareRuntimeScopeStatus, prepareRuntimeScopeControl, prepareRuntimeScopeFence } from "../services/runtime-budget.js";
 import { stopRuntimeScope } from "../services/runtime-scope-stop.js";
 import { launchRuntimeScopeControl, launchRuntimeScopeResume, prepareRuntimeScopeReconciliation, prepareRuntimeScopeServing, reconcileRuntimeScopeControl, serveRuntimeScopeControl } from "../services/runtime-scope-worker.js";
 import { prepareRuntimeScopeResumeRequest } from "../services/runtime-scope-resume.js";
@@ -1017,6 +1017,8 @@ async function prepareCliInputValue(args, context, io, scopeProjectRoot, respons
             return prepareError(error, { parameter: "from/output" });
         }
     }
+    if (route.key === "runtime scope status")
+        prepareRuntimeScopeStatus(optionalOption(parsed, "scope-id"), optionalOption(parsed, "scope-ids-json"));
     if (["runtime scope fence", "runtime scope stop"].includes(route.key))
         prepareRuntimeScopeFence(requiredOption(parsed, "scope-id"), requiredOption(parsed, "request-id"));
     if (route.key === "runtime scope resume")
@@ -2778,8 +2780,12 @@ async function dispatchRuntime(context, command, parsed, progress, prepared = {}
             return { ok: true, ...await stopRuntimeScope(context, requiredOption(parsed, "scope-id"), requiredOption(parsed, "request-id")) };
         }
         if (parsed.positional.length === 1 && parsed.positional[0] === "status") {
-            if ([...parsed.options.keys()].some(key => key !== "scope-id") || [...parsed.options.values()].some(values => values.length !== 1))
-                throw new AppError("usage", "Usage: dd-flow runtime scope status --scope-id EVAL_ID", 2);
+            if ([...parsed.options.keys()].some(key => !["scope-id", "scope-ids-json"].includes(key)) || parsed.options.size !== 1 || [...parsed.options.values()].some(values => values.length !== 1))
+                throw new AppError("usage", "Use exactly one of --scope-id or --scope-ids-json", 2);
+            const ids = prepareRuntimeScopeStatus(optionalOption(parsed, "scope-id"), optionalOption(parsed, "scope-ids-json"));
+            if (parsed.options.has("scope-ids-json")) {
+                return { ok: true, scopes: ids.map(id => runtimeBudgetStatus(context, id)) };
+            }
             return { ok: true, ...runtimeBudgetStatus(context, requiredOption(parsed, "scope-id")) };
         }
         if (parsed.positional.length !== 1 || parsed.positional[0] !== "fence" || [...parsed.options.keys()].some(key => !["scope-id", "request-id"].includes(key)) || [...parsed.options.values()].some(values => values.length !== 1))

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

@@ -294,7 +294,7 @@ export class Runtime {
     let allowProviderFinalization;
     const providerRegistered = new Promise(resolve => { allowProviderFinalization = resolve; });
     const observationFailure = error => { this.drainingError ??= error; readyReject(error); this.active?.reject(error); };
-    this.nativeDrain = readNativeLines(this.child.stdout, line => { this.buffer = `${line}\n`; return this.draining = this.drain(readyResolve); }, observationFailure);
+    this.nativeDrain = readNativeLines(this.child.stdout, line => { this.buffer = `${line}\n`; return this.draining = this.drain(readyResolve, readyReject); }, observationFailure);
     this.diagnostics = streamNativeDiagnostics(this.child.stderr, chunk => this.journal("stderr", { text: chunk }), observationFailure);
     this.child.on("error", error => { readyReject(error); if (this.active) { this.active.reject(error); this.active = null; } });
     // A dead leader is not yet a finalized tree: stop must also join the
@@ -329,7 +329,7 @@ export class Runtime {
     try { return await Promise.race([this.readyPromise, new Promise((_, reject) => { readyTimer = observedTimeout(() => reject(new DaemonError("agy_init_timeout", "Antigravity init timed out", true)), SETUP_STARTUP_MS, { progress: () => this.lastActivityAt }); })]); }
     finally { clearTimeout(readyTimer); }
   }
-  async drain(readyResolve) { let index; while ((index = this.buffer.indexOf("\n")) >= 0) { const line = this.buffer.slice(0, index).trim(); this.buffer = this.buffer.slice(index + 1); if (!line) continue; let event; try { event = JSON.parse(line); } catch { await this.journal("invalid_json", { line: line.slice(0, 1000) }); continue; }
+  async drain(readyResolve, readyReject) { let index; while ((index = this.buffer.indexOf("\n")) >= 0) { const line = this.buffer.slice(0, index).trim(); this.buffer = this.buffer.slice(index + 1); if (!line) continue; let event; try { event = JSON.parse(line); } catch { await this.journal("invalid_json", { line: line.slice(0, 1000) }); continue; }
     // Record an early provider rejection before journalling: a short-lived
     // child can close while the asynchronous write is still pending.
     if (event.event === "result" && ["ERROR", "CANCELLED"].includes(event.result?.status)) {
@@ -344,7 +344,12 @@ export class Runtime {
     }
     this.observeProviderActivity(event);
     if (event.event === "result" && this.init && !this.startupError) { await this.finishTurn(event.result ?? {}, event.terminal_metadata, event); continue; }
-    await this.journal("provider_event", { event }); if (event.event === "init") { this.init = { conversation_id: event.conversation_id, ...(event.init ?? {}) }; if (!this.init.conversation_id) throw new DaemonError("agy_init_missing", "Antigravity init has no conversation ID"); const requested = { provider: this.config.provider, model: this.config.model, reasoning: this.config.reasoning, mode: this.config.mode, permission_mode: "always-proceed" }; this.profile = assertProfile(requested, observedProfile(this.init, requested)); await observeModel({ journal: this.config.journal, harness: "antigravity-cli", sessionId: this.init.conversation_id, requested, observed: this.profile.observed, source: "native.init" }); await this.persist({ shutdown_state: "running", active_tree: false }); readyResolve(this.init); } else if (event.event === "step_update") this.observeStep(event.step_update ?? {}); else if (event.event === "result") { if (this.startupError) throw this.startupError; await this.finishTurn(event.result ?? {}); } } }
+    await this.journal("provider_event", { event }); if (event.event === "init") { this.init = { conversation_id: event.conversation_id, ...(event.init ?? {}) }; if (!this.init.conversation_id) throw new DaemonError("agy_init_missing", "Antigravity init has no conversation ID"); const requested = { provider: this.config.provider, model: this.config.model, reasoning: this.config.reasoning, mode: this.config.mode, permission_mode: "always-proceed" }; this.profile = assertProfile(requested, observedProfile(this.init, requested)); await observeModel({ journal: this.config.journal, harness: "antigravity-cli", sessionId: this.init.conversation_id, requested, observed: this.profile.observed, source: "native.init" }); await this.persist({ shutdown_state: "running", active_tree: false }); readyResolve(this.init); } else if (event.event === "step_update") this.observeStep(event.step_update ?? {}); else if (event.event === "result") {
+      // A successfully read/journalled provider refusal rejects readiness, not
+      // the stream drain that physical cleanup must still join.
+      if (this.startupError) { readyReject(this.startupError); continue; }
+      await this.finishTurn(event.result ?? {});
+    } } }
   observeStep(step) {
     const sessionId = step.conversation_id ?? this.init?.conversation_id, observation = this.sessionObservations.get(sessionId) ?? {};
     const fresh = Number.isInteger(step.step_index) && step.step_index > (observation.last_step_index ?? -1) && step.step_index > (observation.step_floor ?? -1);

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

@@ -14,7 +14,7 @@ import path from "node:path";
 import { spawn } from "node:child_process";
 import { waitForSettlement } from "./session-settlement.mjs";
 import { errorRecord } from "./operation-errors.mjs";
-import { CODEX_REQUEST_TIMEOUT_MS, LATE_RESPONSE_GRACE_MS, CodexBridge, cancelSessionWithBridge, createSessionWithBridge, inspectSessionWithBridge, promptSessionWithBridge, startSessionWithBridge } from "./dd-codex.mjs";
+import { CODEX_REQUEST_TIMEOUT_MS, LATE_RESPONSE_GRACE_MS, CodexBridge, codexReadPhase, readCodexHistory, retainedCodexTurn, cancelSessionWithBridge, createSessionWithBridge, inspectSessionWithBridge, promptSessionWithBridge, startSessionWithBridge } from "./dd-codex.mjs";
 import { assertDaemonOwnership, assertStartupChild, prepareRuntimeOwner, cleanupFailedDaemonStart, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, scheduleDaemonProcessHeartbeat, registerDaemonProcess, startManagedBridge, stopProcessGroup } from "./managed-daemon.mjs";
 
 export function codexBridgeEnv(config, daemonId) { return { ...config.env, ...managedFlowEnv(config, daemonId) }; }
@@ -28,10 +28,11 @@ 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) {
+const terminalTurn = turn => typeof turn?.id === "string" && turn.id.trim().length > 0 && ["completed", "interrupted", "failed", "cancelled"].includes(turn.status);
+export function settledCodexSession(status, latestTurn, active, historyAvailable = true) {
+  if (latestTurn && !terminalTurn(latestTurn)) return false;
   if (status === "idle") return true;
-  if (status === "notLoaded") return !latestTurn || terminalTurn(latestTurn);
+  if (status === "notLoaded") return terminalTurn(latestTurn) || historyAvailable && !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);
@@ -49,26 +50,46 @@ async function observeCodexSessions(bridge, options, sessions, active, remember
     const observed = await inspectSessionWithBridge(bridge, { ...options, sessionId, turnId: sessionId === options.sessionId ? options.turnId : undefined });
     for (const child of observed.descendants ?? []) { sessions.add(child.provider_session_id); remember(child.provider_session_id); }
     const status = observed.status?.type ?? observed.status;
-    const stored = ["notLoaded", "systemError"].includes(status) ? await bridge.request("thread/turns/list", { threadId: sessionId, limit: 1, sortDirection: "desc", itemsView: "summary" }, 5_000) : null;
-    const settled = settledCodexSession(status, stored?.data?.[0] ?? null, active());
+    const currentId = bridge.currentTurns?.get(sessionId) ?? (sessionId === options.sessionId ? options.turnId : undefined);
+    const retained = retainedCodexTurn(bridge, sessionId, currentId);
+    const compactTurn = observed.thread?.turns?.findLast(turn => !currentId || turn?.id === currentId);
+    const stored = ["notLoaded", "systemError"].includes(status) || currentId && !terminalTurn(retained)
+      ? await readCodexHistory(bridge, "thread/turns/list", { threadId: sessionId, limit: 20, sortDirection: "desc", itemsView: "summary" }, options.readPhase) : null;
+    const hydrated = stored && !stored.available
+      ? await readCodexHistory(bridge, "thread/read", { threadId: sessionId, includeTurns: true }, options.readPhase) : null;
+    const hydratedAvailable = hydrated?.available && Array.isArray(hydrated.result.thread.turns);
+    const hydratedTurn = hydratedAvailable ? hydrated.result.thread.turns.findLast(turn => !currentId || turn?.id === currentId) : null;
+    const malformedHistory = [stored?.result?.data, hydrated?.result?.thread.turns, observed.thread?.turns].some(turns =>
+      turns?.some(turn => typeof turn?.id !== "string" || !turn.id.trim() || !["inProgress", "completed", "interrupted", "failed", "cancelled"].includes(turn.status)));
+    const latest = retained && terminalTurn(retained) ? retained
+      : malformedHistory ? { status: "unknown" }
+      : stored?.result?.data.find(turn => !currentId || turn?.id === currentId) ?? hydratedTurn ?? compactTurn ?? retained
+        ?? (currentId ? { id: currentId, status: "unknown" } : null);
+    const observedStatus = hydrated?.result?.thread.status ?? observed.status;
+    const settled = settledCodexSession(observedStatus?.type ?? observedStatus, latest, active(), (stored?.available ?? true) || hydratedAvailable);
     if (!settled) unsettled.push(sessionId);
-    observations.push({ ...observed, settled });
+    observations.push({ ...observed, status: observedStatus, settled });
   }
   return { sessions: unsettled.reverse(), active: Boolean(active()), observations };
 }
 
 export async function inspectCodexTree(bridge, options, { remember = () => {}, active = () => null } = {}) {
+  options = { ...options, readPhase: options.readPhase ?? codexReadPhase(bridge, options) };
   const sessions = new Set([options.sessionId]);
   const observed = await observeCodexSessions(bridge, options, sessions, active, remember);
   return { ...observed.observations[0], settled: !observed.active && !observed.sessions.length, unsettled_sessions: observed.sessions, tree_session_ids: [...sessions], tree_observations: observed.observations.map(item => ({ provider_session_id: item.provider_session_id, status: item.status, settled: item.settled })) };
 }
 
 export async function cancelCodexTree(bridge, options, { remember = () => {}, active = () => null, timeoutMs = 5_000 } = {}) {
+  // Zero requests one best-effort cancellation/observation pass, not an
+  // invalid zero-length RPC window or permission to skip owned children.
+  const readBudget = timeoutMs === 0 ? CODEX_REQUEST_TIMEOUT_MS : timeoutMs;
+  options = { ...options, readPhase: options.readPhase ?? codexReadPhase(bridge, { ...options, timeoutMs: readBudget, livenessTimeoutMs: readBudget }) };
   const sessions = new Set([options.sessionId]);
   const settlement = await waitForSettlement({
     timeoutMs, knownSessions: () => [...sessions],
     cancel: async sessionId => {
-      try { await cancelSessionWithBridge(bridge, { ...options, sessionId, turnId: null }); }
+      try { await cancelSessionWithBridge(bridge, { ...options, sessionId, turnId: sessionId === options.sessionId ? options.turnId : undefined }); }
       catch (error) { if (error.code !== "turn_not_active") throw error; }
     },
     observe: () => observeCodexSessions(bridge, options, sessions, active, remember)