@deksden-com/dd-flow-cli 0.9.0-beta.97 → 0.9.0-beta.98

package/dist/build-info.json

@@ -1,8 +1,8 @@
 {
   "cli_package": "@deksden-com/dd-flow-cli",
-  "cli_version": "0.9.0-beta.97",
-  "cli_commit": "4d478c7dd9549a5b81ed5cd77d4f04befebf6f1c",
-  "built_at": "2026-09-22T15:35:15.503Z",
+  "cli_version": "0.9.0-beta.98",
+  "cli_commit": "a06d4c113d22f31d344bfdf5b740ce5371da8ae2",
+  "built_at": "2026-09-22T19:40:49.454Z",
   "built_with_canon": {
     "version": "4.1.1",
     "commit": "678daa038287c948ada5b2d785a6dcc925c7b891",

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

@@ -276,7 +276,7 @@ export class Runtime {
     // child can close while the asynchronous write is still pending.
     if (!this.init && event.event === "result" && event.result?.status === "ERROR") this.startupError = new DaemonError("agy_provider_rejected", String(event.result.error ?? "Antigravity rejected the Session before initialization"), false, { provider_result: event.result });
     this.observeProviderActivity(event); 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 ?? {}); } } }
-  observeStep(step) { const sessionId = step.conversation_id ?? this.init?.conversation_id; const observation = this.sessionObservations.get(sessionId) ?? {}; if (Number.isInteger(step.step_index) && step.step_index > (observation.last_step_index ?? -1)) this.childActivity(sessionId); if (Number.isInteger(step.step_index)) this.sessionObservations.set(sessionId, { ...observation, last_step_index: Math.max(observation.last_step_index ?? -1, step.step_index) }); this.toolObservations.add(agyToolObservation(step, this.init?.conversation_id)); for (const child of step.subagent_info?.subagents ?? []) if (child.conversation_id) { const prior = this.descendants.get(child.conversation_id); this.descendants.set(child.conversation_id, { ...prior, provider_session_id: child.conversation_id, parent_provider_session_id: this.init?.conversation_id ?? null, role: child.role ?? null, subagent_type: child.type_name ?? null, log_uri: child.log_uri ?? null, workspace_uris: child.workspace_uris ?? [], status: prior?.status ?? "unknown" }); } }
+  observeStep(step) { const sessionId = step.conversation_id ?? this.init?.conversation_id; const observation = this.sessionObservations.get(sessionId) ?? {}; if (Number.isInteger(step.step_index) && step.step_index > (observation.last_step_index ?? -1)) this.childActivity(sessionId); if (Number.isInteger(step.step_index)) this.sessionObservations.set(sessionId, { ...observation, last_step_index: Math.max(observation.last_step_index ?? -1, step.step_index) }); this.toolObservations.add(agyToolObservation(step, this.init?.conversation_id)); for (const child of step.subagent_info?.subagents ?? []) if (child.conversation_id) { const prior = this.descendants.get(child.conversation_id); this.descendants.set(child.conversation_id, { ...prior, provider_session_id: child.conversation_id, parent_provider_session_id: sessionId ?? null, role: child.role ?? null, subagent_type: child.type_name ?? null, log_uri: child.log_uri ?? null, workspace_uris: child.workspace_uris ?? [], status: prior?.status ?? "unknown" }); } }
   toolSnapshot() { const summary = this.toolObservations.summary(); const failures_by_name = {}; for (const event of this.toolObservations.calls.values()) if (event.status === "failed") failures_by_name[event.name] = (failures_by_name[event.name] ?? 0) + 1; return { ...summary, by_name: summary.by_tool, failures_by_name }; }
   async finishTurn(result) {
     if (result.status === "RUNNING") { await this.persist({ active_tree: true }); return; }
@@ -341,7 +341,7 @@ export class Runtime {
     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.state.unclaimed_activity && (!this.active || terminalPending) && result && ["SUCCESS", "ERROR", "CANCELLED"].includes(result.status) && treeSettled && rootSettled) };
   }
   async zeroUsage() { await forwardUsage(this.config, this.init.conversation_id, { usage: {} }, this.toolSnapshot(), []); }
-  async prompt(text, assertDispatch = captureDispatchGuard(this)) {
+  async prompt(text, assertDispatch = captureDispatchGuard(this), operationId = null) {
     if (!text) throw new DaemonError("prompt_required", "prompt is required");
     await this.start(); await this.draining;
     if (this.active) throw new DaemonError("operation_in_progress", "an Antigravity turn is already running");
@@ -350,14 +350,14 @@ export class Runtime {
     const reply = new Promise((resolve, reject) => { resolveTurn = resolve; rejectTurn = reject; });
     // Cancellation can reject while admission persistence is still pending.
     void reply.catch(() => {});
-    const current = { resolve: resolveTurn, reject: rejectTurn, generation: ++this.turnGeneration, previousError: this.lastResult?.error ?? null };
+    const current = { resolve: resolveTurn, reject: rejectTurn, generation: ++this.turnGeneration, operationId, previousError: this.lastResult?.error ?? null };
     // Reserve before persistence so different operation IDs cannot overlap.
     this.active = current;
     const root = this.init?.conversation_id, prior = this.sessionObservations.get(root) ?? {};
     this.sessionObservations.set(root, { ...prior, step_floor: prior.last_step_index ?? null, stop: null, last_hook: null });
     this.lastProviderEvent = null;
     try {
-      await this.persist({ active_tree: true });
+      await this.persist({ active_tree: true, last_hook_rejection: null });
       assertDispatch();
       if (this.active !== current) throw new DaemonError("operation_cancelled", "prompt reservation was superseded");
       this.child.stdin.write(`${JSON.stringify({ event: "user", message: { content: text } })}\n`, error => {
@@ -378,8 +378,16 @@ export class Runtime {
     while (!this.descendants.has(conversationId) && Date.now() < deadline) await new Promise(resolve => setTimeout(resolve, 10));
     const child = this.descendants.get(conversationId);
     if (!child) throw new DaemonError("agy_child_identity_unconfirmed", "Antigravity hook has no confirmed native parent", true, { conversation_id: conversationId });
+    if (child.parent_provider_session_id !== this.init?.conversation_id) throw new DaemonError("agy_child_parent_unqualified", "Nested Antigravity worker is not a direct child of the controlled Session", false, { conversation_id: conversationId, parent_conversation_id: child.parent_provider_session_id });
     return child;
   }
+  async rejectHook(error, event, payload) {
+    const current = this.active;
+    const rejection = { code: error.code ?? "agy_hook_rejected", message: error.message ?? String(error), event, conversation_id: payload.conversationId ?? null, tool: payload.toolCall?.name ?? null, daemon_id: this.config.daemonId, operation_id: current?.operationId ?? null, turn_generation: current?.generation ?? null };
+    try { await this.journal("hook_rejected", { rejection }); await this.persist({ last_hook_rejection: rejection }); }
+    catch (storageError) { if (current && this.active === current) { this.active = null; current.reject(storageError); } throw storageError; }
+    if (current && this.active === current) { this.active = null; current.reject(new DaemonError(rejection.code, rejection.message, false, rejection)); }
+  }
   async observeHook(event, payload) { const conversationId = payload.conversationId ?? this.init?.conversation_id; const child = await this.childForHook(conversationId); const prior = this.sessionObservations.get(conversationId) ?? {}; const execution = Number.isInteger(payload.executionNum) ? payload.executionNum : null; const step = Number.isInteger(payload.stepIdx) ? payload.stepIdx : null; const floor = prior.step_floor; const stale = step !== null && ((Number.isInteger(floor) && step <= floor) || (child && Number.isInteger(prior.last_step_index) && step < prior.last_step_index)); if (stale) { await this.journal("stale_hook", { hook_event: event, conversation_id: conversationId, step_index: step }); return { stale: true }; } const fingerprint = createHash("sha256").update(JSON.stringify({ event, payload })).digest("hex"); if (!stale && prior.last_hook !== fingerprint) this.markActivity(); if (conversationId && !stale) this.sessionObservations.set(conversationId, { ...prior, ...(step !== null ? { last_step_index: Math.max(prior.last_step_index ?? -1, step) } : {}), last_hook: fingerprint, ...(event === "PreToolUse" ? { last_pre_hook: fingerprint } : {}), ...(payload.transcriptPath ? { transcript_path: payload.transcriptPath } : {}), ...(event === "Stop" ? { stop: { fullyIdle: payload.fullyIdle === true, terminationReason: payload.terminationReason ?? null, executionNum: payload.executionNum ?? null } } : {}) }); if (!stale && event === "PreToolUse" && prior.last_pre_hook !== fingerprint) this.childActivity(conversationId); if (child && !stale && event === "Stop" && payload.fullyIdle === true) this.descendants.set(conversationId, { ...this.descendants.get(conversationId), tree_settled: true, settlement_evidence: "child_fully_idle_stop" }); const terminalPending = this.active?.terminalResult === this.lastResult; if (!child && !stale && event === "Stop" && payload.fullyIdle === true && (!this.active || terminalPending) && ["SUCCESS", "ERROR", "CANCELLED"].includes(this.lastResult?.status)) for (const [id, descendant] of this.descendants) if (descendant.status === "unknown") this.descendants.set(id, { ...descendant, status: "settled_by_root", settlement_evidence: "root_fully_idle_stop" }); const parent = child?.parent_provider_session_id ?? null;
     const observed = payload.model ? observedProfile(payload) : {};
     await observeModel({ journal: this.config.journal, harness: "antigravity-cli", sessionId: conversationId, parentSessionId: parent, requested: this.config, observed, source: "native.hook", evidence: payload.model ? "configured" : "unavailable", reason: payload.model ? null : "hook_omits_current_model" });
@@ -427,11 +435,14 @@ async function dispatch(runtime, request) {
   if (request.schema_id !== REQUEST_SCHEMA) throw new DaemonError("daemon_protocol_mismatch", "unsupported dd-agy request schema"); const params = request.params ?? {};
   if (request.operation === "daemon.status") return { daemon_id: runtime.config.daemonId, shutdown_state: runtime.state.shutdown_state, active_tree: runtime.state.active_tree, last_activity_at: runtime.lastActivityAt, provider_ready: Boolean(runtime.init && !runtime.exited), pid: process.pid, provider_pid: runtime.child?.pid ?? null, versions: runtime.state.versions, config: runtime.config, sessions: runtime.state.sessions ?? [], receipt: runtime.receipt() };
   if (request.operation === "session.create") { if (params.sessionId) throw new DaemonError("invalid_create", "create does not accept a Session ID"); if (params.prompt) throw new DaemonError("invalid_create", "create does not execute a prompt; use session.prompt"); await runtime.start(); await runtime.zeroUsage(); return runtime.receipt(); }
-  if (request.operation === "session.prompt") { const assertDispatch = captureDispatchGuard(runtime); await runtime.start(params.sessionId ?? null); runtime.requireSessionIdentity(params.sessionId); return await runtime.prompt(params.prompt, assertDispatch); }
+  if (request.operation === "session.prompt") { const assertDispatch = captureDispatchGuard(runtime); await runtime.start(params.sessionId ?? null); runtime.requireSessionIdentity(params.sessionId); return await runtime.prompt(params.prompt, assertDispatch, request.id); }
   if (request.operation === "session.inspect") { runtime.requireSessionIdentity(params.sessionId); return runtime.receipt(); }
   if (request.operation === "session.resume") { await runtime.start(params.sessionId ?? runtime.init?.conversation_id ?? null); runtime.requireSessionIdentity(params.sessionId); return runtime.receipt(); }
   if (request.operation === "session.cancel") { runtime.requireSessionIdentity(params.sessionId); return await runtime.cancel(); }
-  if (request.operation === "hook.observe") return await runtime.observeHook(params.event, params.payload ?? {});
+  if (request.operation === "hook.observe") {
+    try { return await runtime.observeHook(params.event, params.payload ?? {}); }
+    catch (error) { await runtime.rejectHook(error, params.event, params.payload ?? {}); throw error; }
+  }
   if (request.operation === "daemon.stop") { await runtime.close(params.cancelTree === true); await runtime.persist({ shutdown_state: "clean", active_tree: false }); await runtime.finishResource(); setImmediate(() => runtime.server?.close()); return { stopped: true, clean: true, settled: true, daemon_id: runtime.config.daemonId }; }
   throw new DaemonError("unknown_operation", `unknown dd-agy daemon operation: ${request.operation}`);
 }

package/dist/harness-runtime/lib/delegation-instructions.mjs

@@ -54,8 +54,8 @@ export const lifecycleRetryInstruction = "If the CLI rejects the call with effec
 export function workerDelegationTask({ workId, startCommand, launchPolicy }) {
   if (!workId || !startCommand) throw new Error("ready fan-out Work lacks its exact start command");
   const context = launchPolicy === "fresh_agent_required"
-    ? "This Work requires empty, non-inherited conversation context; the coordinator must select the native fresh-child mode before launching it."
-    : "Use inherited context only through the harness's declared native mechanism.";
+    ? "You are the already-selected fresh leaf worker for this Work. Execute its lifecycle start yourself; do not delegate it to another child."
+    : "You are the already-selected worker. Execute this Work yourself; do not delegate it to another child.";
   return [
     `Complete one already-declared Work: ${workId}.`,
     context,

package/dist/services/controller-fanout.js

@@ -31,7 +31,9 @@ export function controllerStageEntryPrompt(stage, command) {
 }
 /** The shared controller owns this former eval-only Work-graph decision. */
 export async function nextControllerFanout(context, input) {
-    const children = input.children.filter(child => child.status !== "settled_by_root");
+    // Tree settlement is not a Work result. Keep these children visible to the
+    // association check, especially when a hook rejected work start before CLI.
+    const children = input.children;
     const observations = { harness_id: input.harness, parent_session_id: input.sessionId, children };
     if (children.length) {
         const observed = observeVnextNativeChildren(context, { ...input, observations });

package/dist/services/eval-snapshots.js

@@ -75,12 +75,13 @@ export function restoreEvalBootstrapSnapshot(_context, input, prepared = prepare
 export function createEvalRunSnapshot(context, input) {
     const { output } = prepareEvalRunSnapshotCreation(context, input);
     const temporary = `${output}.partial-${crypto.randomUUID()}`;
+    let sourceVersion = null;
     try {
         input.boundary?.verify();
-        const sourceVersion = input.boundary ? snapshotSourceVersion(context, input) : null;
+        sourceVersion = input.boundary ? snapshotSourceVersion(context, input) : null;
         const result = captureEvalRunSnapshot(context, { ...input, output: temporary });
         if (input.boundary && sourceVersion) {
-            Object.assign(result, { consistency: "controller_boundary_writer_barrier@1", boundary_capture: { controller_id: input.boundary.controllerId, operation_id: input.boundary.operationId, boundary_key: input.boundary.boundaryKey, source_sha256: sourceVersion, observation: input.boundary.observation } });
+            Object.assign(result, { consistency: "controller_boundary_writer_barrier@1", boundary_capture: { controller_id: input.boundary.controllerId, operation_id: input.boundary.operationId, boundary_key: input.boundary.boundaryKey, source_sha256: sourceVersion.sha256, observation: input.boundary.observation } });
             writeJson(path.join(temporary, "snapshot.json"), Object.fromEntries(Object.entries(result).filter(([key]) => key !== "ok" && key !== "snapshot")));
         }
         if (input.recoveryId) {
@@ -93,8 +94,20 @@ export function createEvalRunSnapshot(context, input) {
             throw new AppError("snapshot_exists", "Snapshot output already exists", 1, { output });
         syncSnapshotTree(temporary);
         if (input.boundary) {
-            if (sourceVersion !== snapshotSourceVersion(context, input))
-                throw new AppError("snapshot_source_changed", "Snapshot source files or Git state changed during boundary capture", 1);
+            if (sourceVersion) {
+                let after;
+                try {
+                    after = snapshotSourceVersion(context, input, sourceVersion.databases);
+                }
+                catch (error) {
+                    if (error.code !== "ENOENT")
+                        throw error;
+                    const missing = error.path;
+                    throw new AppError("snapshot_source_changed", "Snapshot source disappeared during boundary capture", 1, { components: [missing && path.isAbsolute(missing) && isInside(context.ddFlowHome, missing) ? `runtime/${path.relative(context.ddFlowHome, missing)}` : "source_path_disappeared"] });
+                }
+                if (sourceVersion.sha256 !== after.sha256)
+                    throw new AppError("snapshot_source_changed", "Snapshot source files or Git state changed during boundary capture", 1, { components: snapshotSourceChanges(sourceVersion.entries, after.entries), changes: snapshotSourceChangeProofs(sourceVersion.entries, after.entries) });
+            }
             input.boundary.verify();
         }
         fs.renameSync(temporary, output);
@@ -105,6 +118,10 @@ export function createEvalRunSnapshot(context, input) {
         fs.rmSync(temporary, { recursive: true, force: true });
         throw error;
     }
+    finally {
+        for (const db of sourceVersion?.databases.values() ?? [])
+            db.close();
+    }
 }
 export function prepareEvalRunSnapshotCreation(context, input) {
     if (Number(Boolean(input.candidate)) + Number(Boolean(input.incomplete)) + Number(input.stageEntry !== undefined) + Number(input.recoveryId !== undefined) !== 1)
@@ -801,23 +818,101 @@ function snapshotPayloadAllowed(source) {
 function runtimePayloadAllowed(source) {
     return snapshotPayloadAllowed(source) && !["auth.json", "auth.bk", "credentials.json", ".credentials.json", "credentials", ".credentials", "id_rsa", "id_ed25519", "engines", "checkouts"].includes(path.basename(source));
 }
-/** Productive writers are fenced separately. Recheck copied bytes and Git
- * state so an uncoordinated file writer cannot publish a mixed boundary. */
-function snapshotSourceVersion(context, input) {
+function sqliteFile(file) {
+    if (!fs.existsSync(file) || !fs.statSync(file).isFile())
+        return false;
+    const descriptor = fs.openSync(file, "r");
+    try {
+        const header = Buffer.alloc(16);
+        return fs.readSync(descriptor, header, 0, 16, 0) === 16 && header.toString() === "SQLite format 3\0";
+    }
+    finally {
+        fs.closeSync(descriptor);
+    }
+}
+/** A WAL is copied through its SQLite read snapshot, not as raw bytes. */
+function runtimeSnapshotKind(file, excluded) {
+    if (!runtimePayloadAllowed(file) || excluded.includes(file))
+        return "excluded";
+    if (fs.lstatSync(file).isFile()) {
+        if (/-(?:wal|shm|journal)$/.test(file) && sqliteFile(file.replace(/-(?:wal|shm|journal)$/, "")))
+            return "sidecar";
+        if (sqliteFile(file))
+            return "sqlite";
+    }
+    return "ordinary";
+}
+/** Productive writers are fenced separately. Compare exactly the copied
+ * source set; SQLite serialization includes committed WAL pages without
+ * mistaking a physical checkpoint for new logical content. */
+function snapshotSourceVersion(context, input, retainedDatabases) {
+    const databases = retainedDatabases ?? new Map();
     const projectRoot = resolveProjectRoot(input.projectRoot);
     const project = requireProjectByRoot(context, projectRoot);
     const run = context.db.get("SELECT workspace_root FROM runs WHERE project_id = ? AND id = ?", [project.id, input.runId]);
     if (!run)
         throw new AppError("not_found", "Snapshot RUN is not registered", 1);
-    const resources = path.join(context.ddFlowHome, "runtime.sqlite");
-    // Resource heartbeats are not productive writers. Their semantic identities
-    // are rechecked by the owner; each resource DB is copied consistently.
-    const runtimeFilter = (file) => runtimePayloadAllowed(file) && !file.endsWith("-shm") && ![resources, `${resources}-wal`, `${resources}-journal`].includes(file);
-    const roots = [...new Set([projectRoot, run.workspace_root])];
-    return crypto.createHash("sha256").update(JSON.stringify([
-        treeHash(context.ddFlowHome, runtimeFilter), treeModesHash(context.ddFlowHome, runtimeFilter),
-        ...roots.map(root => [treeHash(root, true), treeModesHash(root, true), git(root, ["symbolic-ref", "--quiet", "HEAD"]), gitBytes(root, ["show-ref", "--head"]).toString("base64"), indexEntries(root).toString("base64")])
-    ])).digest("hex");
+    const entries = new Map();
+    const excluded = codexHomeSnapshotExclusions(context, project.id, input.runId);
+    const visit = (directory) => {
+        for (const entry of fs.readdirSync(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+            const file = path.join(directory, entry.name);
+            const kind = runtimeSnapshotKind(file, excluded);
+            if (kind === "excluded" || kind === "sidecar")
+                continue;
+            const key = `runtime/${path.relative(context.ddFlowHome, file)}`;
+            const stat = fs.lstatSync(file);
+            if (stat.isDirectory()) {
+                entries.set(key, "directory");
+                visit(file);
+            }
+            else if (stat.isSymbolicLink())
+                entries.set(key, `link:${fs.readlinkSync(file)}`);
+            else if (kind === "sqlite") {
+                // Resource heartbeats are copied consistently but are not productive
+                // RUN writers; owner identity is fenced by boundary.verify().
+                if (file === path.join(context.ddFlowHome, "runtime.sqlite")) {
+                    entries.set(key, `resource-sqlite:${stat.dev}:${stat.ino}:${stat.mode & 0o111}`);
+                    continue;
+                }
+                let db = databases.get(file);
+                if (!db) {
+                    db = new DatabaseSync(file, { readOnly: true });
+                    databases.set(file, db);
+                }
+                entries.set(key, `sqlite:${crypto.createHash("sha256").update(db.serialize()).digest("hex")}:${stat.dev}:${stat.ino}:${stat.mode & 0o111}`);
+            }
+            else if (stat.isFile())
+                entries.set(key, `file:${crypto.createHash("sha256").update(fs.readFileSync(file)).digest("hex")}:${stat.mode & 0o111}`);
+        }
+    };
+    try {
+        visit(context.ddFlowHome);
+        for (const root of new Set([projectRoot, run.workspace_root]))
+            entries.set(`source/${root}`, JSON.stringify([
+                treeHash(root, true), treeModesHash(root, true), git(root, ["symbolic-ref", "--quiet", "HEAD"]), gitBytes(root, ["show-ref", "--head"]).toString("base64"), indexEntries(root).toString("base64")
+            ]));
+        return { entries, databases, sha256: crypto.createHash("sha256").update(JSON.stringify([...entries].sort(([a], [b]) => a.localeCompare(b)))).digest("hex") };
+    }
+    catch (error) {
+        if (!retainedDatabases)
+            for (const db of databases.values())
+                try {
+                    db.close();
+                }
+                catch { /* Preserve the original source error. */ }
+        throw error;
+    }
+}
+function snapshotSourceChanges(before, after) {
+    return [...new Set([...before.keys(), ...after.keys()])].filter(key => before.get(key) !== after.get(key)).sort().slice(0, 8);
+}
+function snapshotSourceChangeProofs(before, after) {
+    return snapshotSourceChanges(before, after).map(component => ({
+        component,
+        before: before.has(component) ? crypto.createHash("sha256").update(before.get(component)).digest("hex") : null,
+        after: after.has(component) ? crypto.createHash("sha256").update(after.get(component)).digest("hex") : null
+    }));
 }
 /** Managed Codex homes share host configuration, not owned snapshot payload. */
 function codexHomeSnapshotExclusions(context, projectId, runId) {
@@ -856,23 +951,12 @@ function copyRuntimeTree(source, destination, scoped = true, excluded = []) {
     if (isInside(root, physicalPath(destination)))
         throw new AppError("snapshot_output_inside_runtime", "Recovery output must be outside its source artifact tree", 1);
     const databases = [];
-    const sqlite = (file) => {
-        if (!fs.existsSync(file) || !fs.statSync(file).isFile())
-            return false;
-        const descriptor = fs.openSync(file, "r");
-        try {
-            const header = Buffer.alloc(16);
-            return fs.readSync(descriptor, header, 0, 16, 0) === 16 && header.toString() === "SQLite format 3\0";
-        }
-        finally {
-            fs.closeSync(descriptor);
-        }
-    };
     fs.mkdirSync(path.dirname(destination), { recursive: true });
     fs.cpSync(source, destination, {
         recursive: true, verbatimSymlinks: true,
         filter: file => {
-            if (!runtimePayloadAllowed(file) || excluded.includes(file))
+            const kind = runtimeSnapshotKind(file, excluded);
+            if (kind === "excluded" || kind === "sidecar")
                 return false;
             const stat = fs.lstatSync(file);
             if (stat.isSymbolicLink()) {
@@ -883,9 +967,7 @@ function copyRuntimeTree(source, destination, scoped = true, excluded = []) {
             if (!stat.isDirectory() && !stat.isFile())
                 return false;
             if (stat.isFile()) {
-                if (/-(?:wal|shm|journal)$/.test(file) && sqlite(file.replace(/-(?:wal|shm|journal)$/, "")))
-                    return false;
-                if (sqlite(file)) {
+                if (kind === "sqlite") {
                     databases.push(file);
                     return false;
                 }

package/dist/services/run-controller-capture.js

@@ -80,10 +80,11 @@ export async function captureControllerBoundary(context, row, manifest, stage, n
         }
         else {
             let lastPending = "";
+            let lastCaptureMismatch = null;
             for (;;) {
                 if (observationBudget.exhausted()) {
-                    context.db.run("UPDATE run_controller_operations SET receipt_json = json_set(COALESCE(receipt_json, '{}'), '$.recovery_observation', json(?)), updated_at = ? WHERE operation_id = ?", [JSON.stringify(observationBudget.state()), context.now(), operationId]);
-                    throw new AppError("recovery_observation_budget_exhausted", "Boundary capture has no stable settlement within the active observation budget", 1, { recovery_observation: observationBudget.state() });
+                    context.db.run("UPDATE run_controller_operations SET receipt_json = json_set(json_set(COALESCE(receipt_json, '{}'), '$.recovery_observation', json(?)), '$.last_capture_mismatch', json(?)), updated_at = ? WHERE operation_id = ?", [JSON.stringify(observationBudget.state()), JSON.stringify(lastCaptureMismatch), context.now(), operationId]);
+                    throw new AppError("recovery_observation_budget_exhausted", "Boundary capture has no stable settlement within the active observation budget", 1, { recovery_observation: observationBudget.state(), last_capture_mismatch: lastCaptureMismatch });
                 }
                 assertCurrent();
                 let verify = () => { throw new AppError("controller_boundary_unsettled", "Boundary has no stable writer observation", 1); };
@@ -99,14 +100,15 @@ export async function captureControllerBoundary(context, row, manifest, stage, n
                             throw error;
                         observation.settled = false;
                         observation.pending_reasons = [error.code];
+                        lastCaptureMismatch = { code: error.code, components: error.details?.components ?? [], changes: error.details?.changes ?? [] };
                     }
                 }
                 observationBudget.exhausted();
-                const published = { ...observation, recovery_observation: observationBudget.state() };
+                const published = { ...observation, recovery_observation: observationBudget.state(), last_capture_mismatch: lastCaptureMismatch };
                 const pending = digest(observation.pending_reasons);
                 context.db.run("UPDATE run_controller_operations SET receipt_json = ?, updated_at = ? WHERE operation_id = ?", [JSON.stringify(published), context.now(), operationId]);
                 if (pending !== lastPending) {
-                    appendEvent(context, row.controller_id, "boundary_capture_pending", { operation_id: operationId, pending_reasons: observation.pending_reasons });
+                    appendEvent(context, row.controller_id, "boundary_capture_pending", { operation_id: operationId, pending_reasons: observation.pending_reasons, last_capture_mismatch: lastCaptureMismatch });
                     lastPending = pending;
                 }
                 await delay(observationBudget.nextDelay());

package/dist/services/vnext-fanout.js

@@ -158,6 +158,10 @@ export async function reconcileVnextFanout(context, input) {
             issues.push({ code: "child_descendants_unsettled", work_id: link.work_id });
             continue;
         }
+        if (child.status === "settled_by_root") {
+            issues.push({ code: "child_execution_outcome_unconfirmed", work_id: link.work_id, session_id: child.session_id });
+            continue;
+        }
         if (child.status === "completed") {
             issues.push({ code: "execution_ended_without_work_result", work_id: link.work_id, session_id: child.session_id });
             continue;
@@ -178,7 +182,7 @@ export async function reconcileVnextFanout(context, input) {
 export function prepareNativeObservations(observations) {
     const value = observations;
     if (!value || typeof value.harness_id !== "string" || !value.harness_id.trim() || typeof value.parent_session_id !== "string" || !value.parent_session_id.trim() || !Array.isArray(value.children)
-        || value.children.some(child => !child || typeof child.session_id !== "string" || !child.session_id.trim() || typeof child.status !== "string" || !["running", "unknown", "completed", "failed", "cancelled"].includes(child.status)))
+        || value.children.some(child => !child || typeof child.session_id !== "string" || !child.session_id.trim() || typeof child.status !== "string" || !["running", "unknown", "completed", "failed", "cancelled", "settled_by_root"].includes(child.status)))
         throw new AppError("usage", "Expected native observations: harness_id, parent_session_id and children[{session_id,status}]", 2);
     if (new Set(value.children.map(child => child.session_id)).size !== value.children.length)
         throw new AppError("usage", "Native observations must contain each child Session exactly once", 2);

package/dist/services/work-registry.js

@@ -880,6 +880,8 @@ function bindSession(context, work, run, identity, now) {
     });
     if (work.parent_work_id && !parentSession)
         throw new AppError("parent_session_required", "Child Work requires a confirmed parent Work/Session link", 1, { work_id: work.work_id, parent_work_id: work.parent_work_id });
+    if (work.launch_policy === "fresh_agent_required" && inferredParentSession && identity.parentSessionId && identity.parentSessionId !== inferredParentSession)
+        throw new AppError("native_work_parent_mismatch", "Fresh native Work must be started by a direct child of its assigned parent Session", 1, { work_id: work.work_id, effect: "no_effect", ...identityDetails(), observed_provider_parent_session_key: identity.parentSessionId });
     if (work.launch_policy === "fresh_agent_required" && (identity.sessionId === parentSession || context.db.get("SELECT 1 FROM work_sessions ws JOIN works w ON w.work_id = ws.work_id WHERE w.project_id = ? AND w.run_id = ? AND ws.session_id = ? LIMIT 1", [work.project_id, work.run_id, identity.sessionId])))
         throw new AppError("fresh_session_required", "This Work requires a fresh Session in this RUN", 1, { work_id: work.work_id, effect: "no_effect", recoverable: true, handoff_required: true, ...identityDetails() });
     const existing = context.db.get("SELECT session_id, parent_session_id, provider_parent_session_id FROM sessions WHERE project_id = ? AND session_id = ?", [work.project_id, identity.sessionId]);

package/package.json

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