@deksden-com/dd-flow-cli 0.9.0-beta.155 → 0.9.0-beta.158

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # @deksden-com/dd-flow-cli
 
+## 0.9.0-beta.158
+
+### Patch Changes
+
+- Resolve proven explicit Work refusals through coordinator retry/block/pause/fail decisions. Retain accepted corrections and launch history, recover lost acceptance/pause acknowledgements, and keep native/provider failures fenced. Align PLAN stop conditions with accepted intent (plan 112).
+- Register focused PLAN/canon verification ownership so release selection never falls back to an unrelated full gate.
+
+## 0.9.0-beta.157
+
+### Patch Changes
+
+- b7555a7: Preserve actionable lifecycle output and actual Work inputs through preparation retries, persist refusal-to-successor links, and allow distinct same-child correction episodes without duplicate dispatch. Reconcile consistent observations of one technical pause without losing its accepted source.
+
+  Retire owned execution after native shutdown failures without fabricating native success. Preserve AGY terminal task evidence and reject capture when native inventory changes during physical observation.
+
+## 0.9.0-beta.156
+
+### Patch Changes
+
+- b59c32b: Preserve current lifecycle successors, restore OpenCode retained child admission, and separate Work correction from technical pause and native resource cleanup. Continue an eligible completed child once per Work without replaying unknown effects or treating descriptive deviations as unfinished obligations.
+
+  Observe a concurrent controller-launch winner instead of rejecting an already accepted duplicate resume; retain physical ownership and launch CAS fences.
+
 ## 0.9.0-beta.155
 
 Versions beta.153 and beta.154 were used by unpublished preparation candidates; this release uses a new immutable identity. Older pending Changesets below reconcile release accounting rather than claim their functionality is new.

package/dist/build-info.json

@@ -1,15 +1,15 @@
 {
   "cli_package": "@deksden-com/dd-flow-cli",
-  "cli_version": "0.9.0-beta.155",
-  "cli_commit": "2bfe677b16b348906e3015dc8db4ca5253824886",
-  "built_at": "2026-10-27T22:16:56.390Z",
+  "cli_version": "0.9.0-beta.158",
+  "cli_commit": "d0da77c661fa63daf690214f177105c0c0892262",
+  "built_at": "2026-10-29T05:58:19.667Z",
   "built_with_canon": {
-    "version": "4.1.3",
-    "commit": "052ffdf0fff642a46485d2decc79bf78b1970d5e",
+    "version": "4.1.4",
+    "commit": "7cc415b3ef3ce37c9624c7cee51023e66f67cd57",
     "flow_contract": "dd-flow-canonical-2026-08",
-    "repo_root": "/Users/deksden/Documents/_Projects/_worktrees/dd-canon-cp260-manifest",
-    "memorybank_root": "/Users/deksden/Documents/_Projects/_worktrees/dd-canon-cp260-manifest/.memory-bank",
-    "flow_root": "/Users/deksden/Documents/_Projects/_worktrees/dd-canon-cp260-manifest/.memory-bank/dd-flow",
+    "repo_root": "/Users/deksden/Documents/_Projects/_worktrees/dd-canon-cp263",
+    "memorybank_root": "/Users/deksden/Documents/_Projects/_worktrees/dd-canon-cp263/.memory-bank",
+    "flow_root": "/Users/deksden/Documents/_Projects/_worktrees/dd-canon-cp263/.memory-bank/dd-flow",
     "layout": "dot_memory_bank"
   }
 }

package/dist/cli/error-output.js

@@ -22,8 +22,18 @@ export function writePreparationError(io, args, error) {
         io.stderr.write(renderHumanError(payload, args));
 }
 export function renderHumanError(payload, args) {
-    const lines = [`dd-flow: ${payload.error.message}`];
+    const lines = [`dd-flow: ${payload.error.message}`, `code: ${payload.error.code}`];
     const details = recordObject(payload.error.details);
+    for (const key of ["effect", "recoverable", "outcome", "instruction", "retry_instruction", "retry_command", "handoff_required", "work_id", "recovery_instruction"]) {
+        if (details?.[key] !== undefined)
+            lines.push(`${key}: ${String(details[key])}`);
+    }
+    const continuation = recordObject(details?.continuation);
+    if (continuation)
+        for (const key of ["outcome", "instruction", "work_id", "finish_command", "resume_command", "prompt_path"]) {
+            if (continuation[key] !== undefined)
+                lines.push(`continuation.${key}: ${String(continuation[key])}`);
+        }
     const compatibility = recordObject(details?.compatibility);
     const remediation = recordObject(details?.remediation);
     if (compatibility) {

package/dist/cli/input-preparation.js

@@ -1,8 +1,29 @@
 import fs from "node:fs";
 import path from "node:path";
 import crypto from "node:crypto";
+import { AsyncLocalStorage } from "node:async_hooks";
 import { AppError, isAppError } from "../shared/errors.js";
 import { validateSchema } from "../services/schema-validation.js";
+// Observe only bytes already consumed by CLI preparation; never reread a file
+// in a hook or while replaying a retained outcome.
+const consumedInputs = new AsyncLocalStorage();
+export function recordConsumedInput(bytes) {
+    recordConsumedInputDigest(crypto.createHash("sha256").update(bytes).digest("hex"));
+}
+export function recordConsumedInputDigest(digest) { consumedInputs.getStore()?.push(digest); }
+export async function withPreparedInputBinding(prepare) {
+    return consumedInputs.run([], async () => {
+        try {
+            return await prepare();
+        }
+        catch (error) {
+            const inputs = consumedInputs.getStore();
+            if (isAppError(error) && inputs.length)
+                error.details.consumed_input_sha256 = crypto.createHash("sha256").update(JSON.stringify(inputs)).digest("hex");
+            throw error;
+        }
+    });
+}
 export function prepareError(error, input = {}) {
     if (isAppError(error)) {
         // A malformed user input is safely correctable.  A broken schema registry,
@@ -61,7 +82,9 @@ export async function readBoundedUtf8Stream(stream, maxBytes) {
         }
     }
     try {
-        return data + decoder.decode();
+        const text = data + decoder.decode();
+        recordConsumedInput(text);
+        return text;
     }
     catch {
         throw new AppError("validation", "Standard input must contain valid UTF-8", 2);
@@ -76,8 +99,11 @@ export function prepareFileBytes(file, label = "input file", maxBytes) {
         if (!stat.isFile()) {
             throw new AppError("input_file_not_regular", `${label} must be a readable regular file: ${absolute}`, 2, { file: absolute, label });
         }
-        if (maxBytes === undefined)
-            return { file: absolute, bytes: fs.readFileSync(descriptor) };
+        if (maxBytes === undefined) {
+            const bytes = fs.readFileSync(descriptor);
+            recordConsumedInput(bytes);
+            return { file: absolute, bytes };
+        }
         if (!Number.isSafeInteger(maxBytes) || maxBytes < 0)
             throw new AppError("usage", "Invalid input byte bound", 2);
         const oversized = () => new AppError("usage", `${label} exceeds its byte bound`, 2);
@@ -94,7 +120,9 @@ export function prepareFileBytes(file, label = "input file", maxBytes) {
         }
         if (length > maxBytes)
             throw oversized();
-        return { file: absolute, bytes: buffer.subarray(0, length) };
+        const bytes = buffer.subarray(0, length);
+        recordConsumedInput(bytes);
+        return { file: absolute, bytes };
     }
     catch (error) {
         if (error?.code === "ENOENT") {

package/dist/cli/run-cli.js

@@ -5,7 +5,7 @@ import { requiredOption, optionalOption, optionalNumber, optionalPositiveNumber
 import { resolveCommandPaths, resolveCommandProjectRoot } from "../services/command-context.js";
 import { assertAuxiliaryCommandScope, cliManagedInvocationScope, manualRecoveryInvocationScope, assertManualRecoveryInvocationTarget, currentAssignedLifecycle } from "../services/lifecycle-invocations.js";
 import path from "node:path";
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { quote } from "shell-quote";
 import { observeLifecycleCommand, observedLifecycleNativeEvent } from "../services/lifecycle-invocations.js";
 import { verifyCodexHookDelivery } from "../services/codex-hook-delivery.js";
@@ -40,7 +40,7 @@ import { getCanonStatus, registerCanonRoot, resolveCanonRoot, prepareCanonRegist
 import { getRuntimeStatus } from "../services/status.js";
 import { getCliVersionReport } from "../services/build-info.js";
 import { parseCommandArgs } from "../services/lifecycle-command.js";
-import { prepareError, prepareJsonFile, prepareJsonSchema, prepareJsonText, prepareTextFile, prepareFileBytes, readBoundedUtf8Stream } from "./input-preparation.js";
+import { prepareError, prepareJsonFile, prepareJsonSchema, prepareJsonText, prepareTextFile, prepareFileBytes, readBoundedUtf8Stream, recordConsumedInputDigest, withPreparedInputBinding } from "./input-preparation.js";
 import { autoRefreshDashboards, dashboardData, getCmuxStatus, openDashboard, openGlobalDashboard, openProtocolDashboard, refreshAllDashboards, prepareDashboardRefresh, prepareDashboardRender, prepareGlobalDashboardRender, prepareDashboardOptions, refreshDashboard, refreshGlobalDashboard, renderDashboard, renderGlobalDashboard } from "../services/dashboard.js";
 import { dashboardTargetSummary, preferredDashboardCommand, relatedDashboardCommands, resolveDashboardTarget } from "../services/dashboard-targets.js";
 import { getFlowSessionStatus, prepareFlowSessionPayload, registerFlowSession, stopFlowSession, stopMergeWorker, syncFlowSessionUsage } from "../services/sessions.js";
@@ -343,6 +343,10 @@ async function runCliRequest(args, io, env) {
             ? expandLifecycleInvocationArgs(routerContext, boundInvocationArgs, invocationScope, observedOperation)
             : boundInvocationArgs;
         const retainedOutput = observedInvocation ? parseOutputOptions(expandedInvocationArgs) : null;
+        if (retainedOutput?.json)
+            output.json = true;
+        if (retainedOutput?.progressJsonl)
+            output.progressJsonl = true;
         if (retainedOutput?.responseFile)
             output.responseFile = retainedOutput.responseFile;
         let invocationArgs = retainedOutput?.args ?? expandedInvocationArgs;
@@ -408,7 +412,8 @@ async function runCliRequest(args, io, env) {
                             return;
                         nextNativeObservation = Date.now() + 250;
                         const { reconcileRetainedNativeHook } = await import("../services/retained-native-hook.js");
-                        await reconcileRetainedNativeHook(dispatchContext, { scope, invocationId, onProgress });
+                        await reconcileRetainedNativeHook(dispatchContext, { scope, invocationId, onProgress,
+                            onDiagnostic: value => io.stderr.write(`${JSON.stringify({ kind: "native_hook_diagnostic", ...value })}\n`) });
                     } } : {}) });
             if (admission.replay) {
                 retainedOutcome = admission.outcome;
@@ -727,7 +732,7 @@ function attachProgress(result, progress, output) {
     }
     return { ok: true, result, progress };
 }
-function renderHumanResult(args, result) {
+export function renderHumanResult(args, result) {
     const [family, command] = args;
     const record = result && typeof result === "object" && !Array.isArray(result) ? result : {};
     const ok = record.ok === false ? "failed" : "ok";
@@ -795,6 +800,16 @@ function renderHumanResult(args, result) {
         if (run.run_index_path)
             lines.push(`run_index: ${String(run.run_index_path)}`);
     }
+    for (const key of ["outcome", "instruction", "agent_instruction", "next_action", "resume_command", "resume_command_template", "prompt_path"]) {
+        if (record[key] !== undefined && typeof record[key] !== "object")
+            lines.push(`${key}: ${String(record[key])}`);
+    }
+    for (const [name, keys] of [["next", ["finish_command"]], ["repair", ["work_id"]], ["prompt_delivery", ["path", "sha256"]], ["pause", ["user_message", "question_path", "resume_command", "resume_command_template"]]]) {
+        const value = recordObject(record[name]);
+        for (const key of keys)
+            if (value?.[key] !== undefined)
+                lines.push(`${name}.${key}: ${String(value[key])}`);
+    }
     appendFlowGuidanceHuman(lines, record);
     return `${lines.join("\n")}\n`;
 }
@@ -932,7 +947,7 @@ function compositionProposalRetry(context, parsed) {
  * invocation is allowed to claim execution or a stage claims its hook event. */
 async function prepareCliInput(...args) {
     try {
-        return await prepareCliInputValue(...args);
+        return await withPreparedInputBinding(() => prepareCliInputValue(...args));
     }
     catch (error) {
         return prepareError(error);
@@ -3671,11 +3686,14 @@ async function readStdin(stream, maxBytes) {
     let data = "";
     if (maxBytes !== undefined)
         return readBoundedUtf8Stream(stream, maxBytes);
-    stream.setEncoding("utf8");
+    const hash = createHash("sha256"), decoder = new TextDecoder("utf-8", { ignoreBOM: true });
     for await (const chunk of stream) {
-        data += chunk;
+        const bytes = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+        hash.update(bytes);
+        data += decoder.decode(bytes, { stream: true });
     }
-    return data;
+    recordConsumedInputDigest(hash.digest("hex"));
+    return data + decoder.decode();
 }
 function refreshDashboardsAfterMutation(context, args, result, resolvedScope) {
     try {

package/dist/harness-runtime/lib/daemon-operations.mjs

@@ -9,7 +9,7 @@ import { assertDaemonOwnership, budgetObservationScope, releaseBudgetObservation
 import { processSnapshot } from "./process-snapshot.mjs";
 import { NATIVE_SHUTDOWN_CONTRACT, NATIVE_SHUTDOWN_PHASES } from "./native-children.mjs";
 import { readModelObservations, modelAttribution } from "./model-observations.mjs";
-import { publishOperationProgress, publishOperationWaiting, withOperationProgress } from './operation-progress.mjs';
+import { publishOperationProgress, publishOperationWaiting, withOperationProgress, noteOperationProgress } from './operation-progress.mjs';
 import { prepareDaemonRequest } from "./native-request-proof.mjs";
 
 const productive = new Set(["session.create", "session.prompt", "session.start", "session.fork", "session.resume"]);
@@ -65,30 +65,50 @@ function ownedSnapshot(snapshot, rootPid) {
 const mergeProcesses = (...snapshots) => [...new Map(snapshots.flat().map(item => [`${item.pid}:${item.started}`, item])).values()];
 
 /** The same incarnation may retry remaining cleanup, never a native Turn. */
-export async function completeDaemonShutdown(root, state, persist, prepare, phases, reconcileResources) {
+export async function completeDaemonShutdown(root, state, persist, prepare, phases, reconcileResources, { cancelTree = false } = {}) {
   const daemonId = state.daemon_id ?? state.config?.daemonId;
   let shutdown = state.shutdown;
   if (shutdown && shutdown.schema_id !== NATIVE_SHUTDOWN_CONTRACT) throw Object.assign(new Error("shutdown contract mismatch; retain historical owner evidence"), { code: "native_contract_mismatch" });
   if (!shutdown || shutdown.daemon_id !== daemonId) shutdown = { schema_id: NATIVE_SHUTDOWN_CONTRACT, daemon_id: daemonId, generation: dispatchGenerations.get(root) ?? 0, phases: {} };
   shutdown = { ...shutdown, required_phases: [...new Set([...NATIVE_SHUTDOWN_PHASES, ...phases.map(([phase]) => phase)])] };
   try {
-    if (!shutdown.phases.execution) {
+    if (!shutdown.phases.execution && !shutdown.physical_only) {
       // Some native adapters close their provider inside prepare(). Observe
       // ownership first, before that close can reparent a support process.
       const before = ownedSnapshot(await processSnapshot(), state.pid);
       shutdown = { ...shutdown, generation: dispatchGenerations.get(root) ?? shutdown.generation,
         owned_processes: mergeProcesses(shutdown.owned_processes ?? [], before), inventory_complete: state.pid === process.pid };
       await persist({ shutdown });
-      const result = await prepare();
+      let result;
+      try { result = await prepare(); }
+      catch (error) {
+        if (!cancelTree) throw error;
+        // An explicit whole-tree stop owns physical cleanup even when a dead
+        // native endpoint cannot acknowledge idle. Never fabricate execution.
+        shutdown = { ...shutdown, physical_only: true, preparation_error: errorRecord(error) };
+        result = { clean: false, settled: false, native_settled: false,
+          native_resources: { entries: [...(shutdown.result?.native_resources?.entries ?? []), ...(state.native_resources_entries ?? [])] } };
+      }
+      if (cancelTree && (result?.settled !== true || result?.native_settled !== true)) {
+        // Some adapters return the failed native observation after cancelling
+        // their provider instead of throwing it. The endpoint is no more
+        // available in that case; the same physical-only path applies.
+        shutdown = { ...shutdown, physical_only: true };
+        result = { ...result, clean: false, settled: false, native_settled: false,
+          native_resources: { ...result?.native_resources, entries: [...(shutdown.result?.native_resources?.entries ?? []),
+            ...(result?.native_resources?.entries ?? []), ...(state.native_resources_entries ?? [])] } };
+      }
       commitDaemonShutdown(root);
       // Compute ancestry within each snapshot, not across recycled parent PIDs.
       const resources = mergeProcesses(shutdown.owned_processes, ownedSnapshot(await processSnapshot(), state.pid));
-      shutdown = { ...shutdown, phases: { execution: true }, owned_processes: resources,
+      shutdown = { ...shutdown, phases: { ...shutdown.phases, execution: !shutdown.physical_only }, owned_processes: resources,
         inventory_complete: state.pid === process.pid, tree_observed_at: new Date().toISOString(), preparation_clean: result?.clean !== false, result: result ?? {} };
       await persist({ shutdown, shutdown_state: "stopping" });
+      await noteOperationProgress('settlement_started', { cleanup_phase: 'prepare', physical_only: shutdown.physical_only === true });
     }
     commitDaemonShutdown(root);
-    if (reconcileResources && !shutdown.phases.owned_resources) {
+    if (reconcileResources && !shutdown.physical_only && !shutdown.phases.owned_resources) {
+      try {
       const revision = state.native_execution_revision, generation = dispatchGenerations.get(root) ?? shutdown.generation;
       // A fresh attempt cannot reuse a previous inventory while reconciliation
       // is in flight or after the new attempt fails.
@@ -108,6 +128,15 @@ export async function completeDaemonShutdown(root, state, persist, prepare, phas
         native_resource_reconciliation: { daemon_id: daemonId, dispatch_generation: generation, native_revision: revision },
         result: { ...shutdown.result, native_resources: resources } };
       await persist({ shutdown });
+      await noteOperationProgress('native_progress', { cleanup_phase: 'native_resources_reconciled' });
+      } catch (error) {
+        if (!cancelTree || (state.daemon_id ?? state.config?.daemonId) !== daemonId) throw error;
+        shutdown = { ...shutdown, physical_only: true, reconciliation_error: errorRecord(error),
+          result: { ...shutdown.result, clean: false, settled: false, native_settled: false,
+            native_resources: { ...shutdown.result?.native_resources,
+              entries: [...(shutdown.result?.native_resources?.entries ?? []), ...(state.native_resources_entries ?? [])] } } };
+        await persist({ shutdown });
+      }
     }
     for (const [phase, action] of phases) {
       if (phase === "daemon_resource" && !shutdown.phases.owned_resources) {
@@ -120,9 +149,14 @@ export async function completeDaemonShutdown(root, state, persist, prepare, phas
         const remaining = await processSnapshot();
         if ((shutdown.owned_processes ?? []).some(retained => remaining.some(item => item.pid === retained.pid && item.started === retained.started && !item.zombie))) throw Object.assign(new Error("owned resources remain live"), { code: "native_resources_unproven" });
         const nativeResources = shutdown.result?.native_resources;
-        const resourceGap = nativeResources?.entries?.some(resource => resource.observation_conflict === true || resource.state !== "stopped"
-          && !(resource.classification === "required_work" && shutdown.result?.native_settled === true && shutdown.result?.settled === true)
-          && !(shutdown.owned_processes ?? []).some(item => resource.pid === item.pid && resource.started === item.started));
+        const resourceGap = nativeResources?.entries?.some(resource => {
+          if (resource.observation_conflict === true) return true;
+          if (resource.pid !== undefined) return !Number.isSafeInteger(resource.pid) || resource.pid <= 0
+            || typeof resource.started !== 'string' || !resource.started
+            || remaining.some(item => item.pid === resource.pid && !item.zombie);
+          return resource.state !== "stopped"
+            && !(resource.classification === "required_work" && shutdown.result?.native_settled === true && shutdown.result?.settled === true);
+        });
         shutdown = { ...shutdown, phases: { ...shutdown.phases, owned_resources: !resourceGap },
           resource_retirement: { confirmed: !resourceGap, reason: resourceGap ? "native_resource_identity_unproven" : "owned_processes_retired" } };
         await persist({ shutdown });
@@ -132,14 +166,15 @@ export async function completeDaemonShutdown(root, state, persist, prepare, phas
         if (resourceGap) throw Object.assign(new Error("native resource retirement remains unproven"), { code: "native_resources_unproven" });
       }
       if (shutdown.phases[phase]) continue;
-      await action();
+      await action({ physicalOnly: shutdown.physical_only === true });
       shutdown = { ...shutdown, phases: { ...shutdown.phases, [phase]: true } };
       await persist({ shutdown });
+      await noteOperationProgress('native_progress', { cleanup_phase: phase });
     }
     const publishedRevision = state.native_execution_revision;
     const sameRevision = publishedRevision === undefined || publishedRevision === shutdown.result?.native_settlement?.revision;
     const nativeSettled = sameRevision && state.active_tree === false && !state.unclaimed_activity && shutdown.result?.settled === true && shutdown.result?.native_settled === true && shutdown.result?.native_settlement?.confirmed !== false;
-    const physicalStopped = shutdown.required_phases.every(phase => shutdown.phases[phase] === true);
+    const physicalStopped = shutdown.required_phases.filter(phase => phase !== "execution").every(phase => shutdown.phases[phase] === true);
     // Cleanup retries/joining controls advance the control fence, not the old
     // native Turn. Publish the current control generation with retained phases.
     shutdown = { ...shutdown, generation: dispatchGenerations.get(root) ?? shutdown.generation };

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

@@ -25,11 +25,11 @@ import { agyWorkspaceHooks } from "./agy-hooks.mjs";
 import { durableDaemonDispatch, completeDaemonShutdown, assertDaemonDispatch, assertDaemonRestartable, trackDaemonConnections, retireDaemonEndpoint, retireFailedDaemon } from "./daemon-operations.mjs";
 import path from "node:path";
 import { observeModel } from "./model-observations.mjs";
-import { AGY_VERSION_TIMEOUT_MS, AgyError, agyTerminalFailure, agyModelArgs, assertProfile, executable, observedProfile, runAgy, usageSnapshot, managedAgyEnv } from "./dd-agy.mjs";
+import { AGY_VERSION_TIMEOUT_MS, AgyError, agyTerminalFailure, agyErrorDiagnostic, agyModelArgs, assertProfile, executable, observedProfile, runAgy, usageSnapshot, managedAgyEnv } from "./dd-agy.mjs";
 import { agyTerminalEnvelope } from "./agy-terminal-envelope.mjs";
 import { settledNativeTree, nativeExecutionReceipt } from "./native-children.mjs";
 import { retainStartupFailure, prepareRuntimeOwner, cleanupFailedStart, cleanupFailedDaemonStart, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, scheduleDaemonProcessHeartbeat, registerDaemonProcess, stopProcessGroup } from "./managed-daemon.mjs";
-import { readNativeLines, streamNativeDiagnostics, nativeObservationError, admitNativeRequestBuffer } from "./native-streams.mjs";
+import { readNativeLines, nativeObservationError, admitNativeRequestBuffer } from "./native-streams.mjs";
 
 const REQUEST_SCHEMA = "dd-agy/daemon-request@1", RESPONSE_SCHEMA = "dd-agy/daemon-response@1", STATE_SCHEMA = "dd-agy/daemon-state@1";
 class DaemonError extends AgyError {}
@@ -400,7 +400,12 @@ export class Runtime {
     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, readyReject); }, observationFailure);
-    this.diagnostics = streamNativeDiagnostics(this.child.stderr, chunk => this.journal("stderr", { text: chunk }), observationFailure);
+    const diagnosticConnection = this.connectionId;
+    this.diagnostics = readNativeLines(this.child.stderr, async line => {
+      const diagnostic = agyErrorDiagnostic(line);
+      if (diagnostic) await this.journal("provider_error_diagnostic", { ...diagnostic, connection_id: diagnosticConnection });
+      else if (!/^AGY_ERROR\s*[: ]/.test(line)) await this.journal("stderr", { text: line });
+    }, 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
     // pending drain, process-group check and final persistence/lease writes.
@@ -491,7 +496,11 @@ export class Runtime {
           const reducer = createAgyTranscriptFacts(source, child.provider_session_id);
           return { add: reducer.add, finish: () => {
           const facts = reducer.finish();
-          for (const resource of facts.resources) this.nativeResources.set(resource.resource_id, mergeAgyResource(this.nativeResources.get(resource.resource_id), resource));
+          for (const resource of facts.resources) {
+            const prior = this.nativeResources.get(resource.resource_id);
+            this.nativeResources.set(resource.resource_id, { ...mergeAgyResource(prior, resource),
+              owner_daemon_id: prior?.owner_daemon_id ?? this.config.daemonId });
+          }
           if (facts.gap) { this.state.native_topology_error = facts.gap; this.invalidateSettlement(root); }
           for (const discovered of facts.children) {
             const expected = path.join(this.paths.runtime, 'brain', discovered.provider_session_id, '.system_generated', 'logs', 'transcript.jsonl');
@@ -1338,11 +1347,15 @@ async function dispatch(runtime, request) {
     }
     catch (error) { await runtime.recordUnconfirmedHookFailure(error, params.event, params.payload ?? {}, current, request.id); throw error; }
   }
-  if (request.operation === "daemon.stop") return await completeDaemonShutdown(runtime.paths.dir, runtime.state, patch => runtime.persist(patch), () => runtime.prepareStop(params.cancelTree === true), [["provider", () => runtime.close(false)], ["daemon_resource", () => runtime.finishResource()]], async () => {
+  if (request.operation === "daemon.stop") return await completeDaemonShutdown(runtime.paths.dir, runtime.state, patch => runtime.persist(patch), () => runtime.prepareStop(params.cancelTree === true), [["provider", async ({ physicalOnly }) => {
+    if (!physicalOnly) return await runtime.close(false);
+    await stopProcessGroup(runtime.child);
+    await finishDaemonProcess(runtime.config, runtime.providerProcess);
+  }], ["daemon_resource", ({ physicalOnly }) => physicalOnly ? finishDaemonProcess(runtime.config, runtime.state.resource_process) : runtime.finishResource()]], async () => {
     await runtime.retireNativeServices();
     await runtime.captureChildTools();
     return runtime.receipt().native_resources;
-  });
+  }, { cancelTree: params.cancelTree === true });
   throw new DaemonError("unknown_operation", `unknown dd-agy daemon operation: ${request.operation}`);
 }
 import { authorizeRetainedDaemonResume } from "./driver-recovery.mjs";

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

@@ -15,6 +15,23 @@ export class AgyError extends Error {
   constructor(code, message, retryable = false, details) { super(message); this.code = code; this.retryable = retryable; this.details = details; }
 }
 
+// Stderr has no operation/generation identity. Keep it diagnostic-only; never
+// feed these fields into classification or continuation authority.
+export function agyErrorDiagnostic(line) {
+  if (!/^AGY_ERROR\s*[: ]/.test(line)) return null;
+  try {
+    const envelope = JSON.parse(line.replace(/^AGY_ERROR\s*:?\s*/, ""));
+    const native = envelope.error ?? envelope;
+    const fields = {};
+    for (const key of ["status", "error_code", "code_kind", "retryable", "error_id"]) {
+      const value = native?.[key] ?? envelope[key];
+      if (typeof value === "boolean" || typeof value === "number" && Number.isFinite(value)
+        || typeof value === "string" && /^[\w.:-]{1,128}$/.test(value)) fields[key] = value;
+    }
+    return Object.keys(fields).length ? { binding: "unbound", ...fields } : null;
+  } catch { return null; }
+}
+
 export function agyTerminalFailure(result, metadata = {}) {
   let native = typeof result.error === "object" && result.error ? result.error : { message: result.error ?? "Antigravity returned ERROR" };
   if (typeof result.error === "string" && /^AGY_ERROR\s*[: ]/.test(result.error)) {
@@ -33,8 +50,10 @@ export function agyTerminalFailure(result, metadata = {}) {
   const stream = streamRequestKey(metadata.request_proof);
   const proofMissing = result.status === "ERROR" && ["provider_capacity_transient", "provider_rate_limited", "provider_network_transient"].includes(category) && !turn && !stream;
   if (proofMissing) code = "provider_overload_evidence_unavailable";
+  const diagnostic = agyErrorDiagnostic(`AGY_ERROR: ${JSON.stringify(native)}`);
   return new AgyError(code, String(native.message ?? "Antigravity returned ERROR"), ["provider_capacity_transient", "provider_rate_limited", "provider_network_transient"].includes(code), {
     provider_result: result, ...metadata, provider_error: safeProviderError(native), native_source: "agy.result", terminal_status: result.status === "ERROR" ? "failed" : "cancelled",
+    ...(diagnostic ? { native_error_diagnostic: { ...diagnostic, binding: "native_result" } } : {}),
     ...(turn ? { turn_id: turn, native_turn_id: turn } : {}),
     ...(proofMissing ? { provider_category: category, reason: "native_turn_identity_unavailable" } : {}),
     will_retry: native.willRetry === true, native_retry_active: native.willRetry === true

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

@@ -200,7 +200,7 @@ export async function serveDaemon(stateDir) {
         ["provider", () => bridge.close()],
         ["provider_resource", () => finishDaemonProcess(state.config, state.provider_process)],
         ["daemon_resource", () => finishDaemonProcess(state.config, state.resource_process)]
-      ]);
+      ], undefined, { cancelTree: params.cancelTree === true });
     }
     if (["session.create", "session.prompt", "session.start", "session.fork", "session.resume"].includes(operation)) assertDaemonDispatch(paths.dir);
     if (active && !["session.inspect", "session.cancel"].includes(operation)) throw Object.assign(new Error(`${active} is in progress`), { code: "operation_busy", retryable: true });

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

@@ -98,7 +98,7 @@ export async function serveDaemon(stateDir) {
           }],
           ["auth", () => removeDroidAuth(state.config)],
           ["daemon_resource", () => finishDaemonProcess(state.config, state.resource_process)]
-        ]);
+        ], undefined, { cancelTree: params.cancelTree === true });
       }
       catch (error) { if (error.code === "tree_not_settled" && !runtime.closed) stopping = false; throw error; }
     }

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

@@ -541,7 +541,7 @@ export class Runtime {
     const assertDispatch = captureDispatchGuard(this);
     if (["session.create", "session.prompt", "session.fork", "session.archive"].includes(operation)) assertDaemonDispatch(this.paths.dir);
     if (operation === "daemon.ready") return { ready: this.ready, daemon_id: this.state.daemon_id, pid: process.pid, socket: this.paths.socket, versions: this.state.versions, config_isolation: this.state.config_isolation, shutdown_state: this.state.shutdown_state, recovery_status: this.state.recovery_status, auth_status: this.state.auth_status, active_tree: this.state.active_tree, active_operation: this.active, sessions: [...this.sessions.values()], config: this.state.config };
-    if (operation === "daemon.status") { let observationError; if (!this.active && !this.state.shutdown?.phases?.tree) try { await this.refreshTree(); } catch (error) { observationError = errorPayload(error); } return { ...await this.dispatch("daemon.ready", {}), observation_error: observationError ?? this.state.observation_error ?? null }; }
+    if (operation === "daemon.status") { let observationError; if (!this.active && !this.state.shutdown?.phases?.execution && !this.state.shutdown?.physical_only) try { await this.refreshTree(); } catch (error) { observationError = errorPayload(error); } return { ...await this.dispatch("daemon.ready", {}), observation_error: observationError ?? this.state.observation_error ?? null }; }
     if (operation === "hook.resolve") { const sessionId = String(params.sessionId ?? ""); if (!sessionId) throw new DaemonError("hook_identity_missing", "hook has no sessionId"); let session = this.sessions.get(sessionId); if ((!session || session.parent_provider_session_id) && !this.childCreators.has(sessionId) && this.promptCreators.size) { await this.waitForChildCreator(sessionId, params.hookDeadlineAt); session = this.sessions.get(sessionId); } if (!session) { const roots = [...this.sessions.values()].filter((item) => !item.parent_provider_session_id); if (roots.length !== 1) throw new DaemonError("hook_identity_unknown", "unknown hook Session has no unique root"); const observed = await inspectSessionWithBridge(this.bridge, this.options({ sessionId, liveSession: true })); this.track(observed); session = this.sessions.get(sessionId); if (!session || session.root_provider_session_id !== roots[0].provider_session_id) throw new DaemonError("hook_identity_unknown", "hook Session is not a member of the retained native tree"); await this.persist(); } return await this.acceptHook({ daemonId: this.state.daemon_id, rootProviderSessionId: session.root_provider_session_id, parentProviderSessionId: session.parent_provider_session_id ?? null, observedProfile: this.bridge.modelProfiles?.get(sessionId) ?? {} }, sessionId, params.payload); }
     if (operation === "hook.verify") {
       if (params.daemonId !== this.state.daemon_id) throw new DaemonError("native_hook_unproven", "Native hook daemon identity differs");
@@ -594,7 +594,7 @@ export class Runtime {
         ["provider_resource", () => finishDaemonProcess(this.state.config, this.state.provider_process)],
         ["auth", () => unlink(path.join(this.paths.home, "auth.json")).catch(error => { if (error.code !== "ENOENT") throw error; })],
         ["daemon_resource", () => finishDaemonProcess(this.state.config, this.state.resource_process)]
-      ]);
+      ], undefined, { cancelTree: params.cancelTree === true });
     }
     throw new DaemonError("unknown_operation", `unknown daemon operation: ${operation}`);
   }

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

@@ -69,9 +69,9 @@ async function forwardUsage(config, sessionId, snapshot) {
 async function freePort() { return await new Promise((resolve, reject) => { const server = net.createServer(); server.once("error", reject); server.listen(0, "127.0.0.1", () => { const port = server.address().port; server.close(() => resolve(port)); }); }); }
 const errorPayload = errorRecord;
 
-async function writePlugin(paths, config) {
+export async function writePlugin(paths, config) {
   const directory = path.join(paths.config, "opencode", "plugins"); await mkdir(directory, { recursive: true, mode: 0o700 });
-  const source = `import { makeOpenCodePlugin } from ${JSON.stringify(new URL("./opencode-plugin.mjs", import.meta.url).href)};\nexport default makeOpenCodePlugin(${JSON.stringify({ stateDir: paths.dir, daemonId: config.daemonId, version: config.version, ddFlowBin: config.ddFlowBin, nodeBin: process.execPath, ddFlowHome: config.ddFlowHome, projectRoot: config.projectRoot, resourceHome: config.resourceHome, nativeWorkStartAdmission: true })});\n`;
+  const source = `import { makeOpenCodePlugin } from ${JSON.stringify(new URL("./opencode-plugin.mjs", import.meta.url).href)};\nexport default makeOpenCodePlugin(${JSON.stringify({ stateDir: paths.dir, daemonId: config.daemonId, version: config.version, ddFlowBin: config.ddFlowBin, nodeBin: process.execPath, ddFlowHome: config.ddFlowHome, projectRoot: config.projectRoot, resourceHome: config.resourceHome, runtime_owner: config.runtime_owner, noFlow: config.noFlow, nativeWorkStartAdmission: true })});\n`;
   const checksum = createHash("sha256").update(source).digest("hex"); await writeFile(path.join(directory, "dd-flow.js"), source, { mode: 0o600 }); return checksum;
 }
 async function prepare(paths, config, authSource) {
@@ -668,7 +668,7 @@ export class Runtime {
         ["provider", () => stopProcessGroup(this.child)],
         ["provider_resource", () => finishDaemonProcess(this.state.config, this.providerProcess)],
         ["daemon_resource", () => finishDaemonProcess(this.state.config, this.state.resource_process)]
-      ]);
+      ], undefined, { cancelTree: params.cancelTree === true });
     }
     throw new DaemonError("unknown_operation", `unknown daemon operation: ${operation}`);
   }

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

@@ -693,7 +693,7 @@ export class DaemonRuntime {
       ["provider", () => this.bridge.close?.()],
       ["provider_resource", () => finishDaemonProcess(this.state.config, this.state.provider_process)],
       ["daemon_resource", () => finishDaemonProcess(this.state.config, this.state.resource_process)]
-    ]);
+    ], undefined, { cancelTree: params.cancelTree === true });
     throw new DaemonError("unknown_operation", `unknown daemon operation: ${operation}`);
   }
 

package/dist/harness-runtime/lib/delegation-instructions.d.mts

@@ -1,12 +1,13 @@
 export type DelegationWork = { work_id: string; start_command: string; launch_policy?: string };
 export type DelegationInput = { harness: string; stage: string; capacity: number; works?: DelegationWork[]; totalWorks?: number; remainingWorks?: number };
 export function delegationAdapter(harness: string): string | null;
-export function renderNativeChildFollowupInstruction(harness: string, childId: string | { session_id?: unknown; parent_session_id?: unknown; terminal_turn_id?: unknown; continuation_ref?: unknown }): string | null;
+export function renderNativeChildFollowupInstruction(harness: string, childId: string | { session_id?: unknown; parent_session_id?: unknown; terminal_turn_id?: unknown; continuation_ref?: unknown }, options?: { purpose: "work_repair"; context?: string }): string | null;
 export function delegationContract(harness: string): string;
 export const lifecycleRetryInstruction: string;
 export const lifecycleCommandCompletionInstruction: string;
 export const stageLifecycleInstruction: string;
 export const acceptedResultInstruction: string;
+export const workStopConditionInstruction: string;
 export function workerDelegationTask(input: { workId: string; startCommand: string; launchPolicy?: string }): string;
 export function renderDelegationInstructions(input: DelegationInput): string;
 export function renderCapacityInstructions(input: { harness: string; maximum: number }): string;

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

@@ -1,3 +1,6 @@
+// Shared by PLAN, review, CODE and leaf packets; baseline mismatch is work, not a veto.
+export const workStopConditionInstruction = "Current implementation is the starting state, not an additional accepted constraint: fix mismatches with the accepted goal instead of stopping merely because they exist. Necessary project-local changes in another layer are coordination drift, not new scope; preserve ownership and active-writer fences. stop_conditions may be empty and must protect a specific accepted decision, prohibited action or unavailable resource/evidence, never invent a new user prohibition. If an actual accepted-decision conflict or required proof remains unresolved, retain its exact affected action/criterion and evidence for the coordinator; do not hide it or claim completion. An unsupported browser capability limits only its exact recorded operation/environment, not all UI work; continue independent work without substituting semantic selection for keyboard evidence.";
+
 const ADAPTERS = {
   codex: {
     name: "Codex",
@@ -38,12 +41,15 @@ export function delegationAdapter(harness) {
 }
 
 /** Only documented same-child APIs may continue an existing native worker. */
-export function renderNativeChildFollowupInstruction(harness, childId) {
+export function renderNativeChildFollowupInstruction(harness, childId, options = {}) {
   const child = childId && typeof childId === "object" ? childId : null;
   childId = child?.session_id ?? childId;
   if (typeof childId !== "string" || !childId) return null;
   const adapter = delegationAdapter(harness), target = JSON.stringify(childId);
-  const message = JSON.stringify("Continue the same assigned Work after the transient provider failure; do not restart it or repeat committed lifecycle commands.");
+  if (options.purpose === "work_repair" && ["zcode", "antigravity"].includes(adapter)) return null;
+  const message = JSON.stringify(options.purpose === "work_repair"
+    ? `Continue the same assigned Work using this retained correction, not provider recovery. Inspect the original check/result diagnostic, correct the evidenced defect, and use only its issued successor. Do not restart the Work, spawn another child, or repeat committed/pending lifecycle commands.\n${options.context ?? ""}`
+    : "Continue the same assigned Work after the transient provider failure; do not restart it or repeat committed lifecycle commands.");
   if (adapter === "zcode") {
     const ref = child?.continuation_ref;
     if (ref?.schema_id !== "zcode/child-continuation@1" || ref.capability !== "dd-flow/managed-provider-recovery@1" || ref.child_session_id !== childId

package/dist/schemas/code-work-batch.schema.json

@@ -20,6 +20,6 @@
     "documentUpdate": {"type": "object", "additionalProperties": false, "required": ["path", "action", "owner", "reason", "baseline_sha256"], "properties": {"path": {"type": "string", "minLength": 1}, "action": {"enum": ["create", "update"]}, "owner": {"type": "string", "minLength": 1}, "reason": {"type": "string", "minLength": 1}, "baseline_sha256": {"type": ["string", "null"], "pattern": "^[a-f0-9]{64}$"}}},
     "reviewFinding": {"type": "object", "additionalProperties": false, "required": ["finding_ref", "priority", "problem", "impact", "required_outcome", "evidence_refs", "obligation_refs", "decision_reason", "check_refs"], "properties": {"finding_ref": {"type": "string", "minLength": 1}, "priority": {"enum": ["p0", "p1", "p2", "p3"]}, "problem": {"type": "string", "minLength": 1}, "impact": {"type": "string", "minLength": 1}, "required_outcome": {"type": "string", "minLength": 1}, "evidence_refs": {"$ref": "#/$defs/strings"}, "obligation_refs": {"$ref": "#/$defs/strings"}, "decision_reason": {"type": "string", "minLength": 1}, "check_refs": {"$ref": "#/$defs/strings"}}},
     "repair": {"type": "object", "additionalProperties": false, "required": ["origin_work_ids", "verification_check_refs"], "anyOf": [{"required": ["check_receipt_id", "failure_receipt_path"]}, {"required": ["review_findings"]}, {"required": ["semantic_unresolved", "verification_path"]}], "properties": {"origin_work_ids": {"$ref": "#/$defs/strings"}, "check_receipt_id": {"type": "string", "minLength": 1}, "failure_receipt_path": {"type": "string", "minLength": 1}, "review_findings": {"type": "array", "minItems": 1, "items": {"$ref": "#/$defs/reviewFinding"}}, "semantic_unresolved": {"$ref": "#/$defs/strings"}, "verification_path": {"type": "string", "minLength": 1}, "verification_check_refs": {"type": "array", "minItems": 1, "items": {"$ref": "#/$defs/check"}}}},
-    "work": {"type": "object", "additionalProperties": false, "required": ["schema_id", "key", "launch_policy", "source", "task", "semantic_spine", "requirements", "acceptance", "document_updates", "required_read", "discovery_boundary", "planned_write_areas", "checks", "provides_checks", "stop_conditions", "depends_on", "result_schema"], "properties": {"schema_id": {"const": "dd-flow/code-work-packet@5"}, "key": {"type": "string", "minLength": 1}, "launch_policy": {"const": "fresh_agent_required"}, "source": {"$ref": "#/$defs/source"}, "repair": {"$ref": "#/$defs/repair"}, "task": {"type": "string", "minLength": 1}, "semantic_spine": {"$ref": "#/$defs/spine"}, "requirements": {"type": "array", "minItems": 1, "items": {"$ref": "#/$defs/obligation"}}, "acceptance": {"type": "array", "items": {"$ref": "#/$defs/acceptance"}}, "document_updates": {"type": "array", "items": {"$ref": "#/$defs/documentUpdate"}}, "required_read": {"$ref": "#/$defs/strings", "description": "Mandatory starting sources, not a read allowlist."}, "discovery_boundary": {"$ref": "#/$defs/strings", "description": "Likely discovery areas; additional project-local reads are allowed."}, "planned_write_areas": {"type": "array", "items": {"type": "string", "minLength": 1}, "description": "Soft coordination hints only. A worker may change any necessary project file inside the RUN workspace."}, "checks": {"type": "array", "items": {"$ref": "#/$defs/check"}}, "provides_checks": {"type": "array", "items": {"$ref": "#/$defs/check"}}, "stop_conditions": {"$ref": "#/$defs/strings", "description": "Hard semantic or external stop conditions; path prediction drift is not a stop condition."}, "depends_on": {"type": "array", "uniqueItems": true, "items": {"type": "string", "minLength": 1}}, "result_schema": {"const": "dd-flow/code-work-result@3"}}}
+    "work": {"type": "object", "additionalProperties": false, "required": ["schema_id", "key", "launch_policy", "source", "task", "semantic_spine", "requirements", "acceptance", "document_updates", "required_read", "discovery_boundary", "planned_write_areas", "checks", "provides_checks", "stop_conditions", "depends_on", "result_schema"], "properties": {"schema_id": {"const": "dd-flow/code-work-packet@5"}, "key": {"type": "string", "minLength": 1}, "launch_policy": {"const": "fresh_agent_required"}, "source": {"$ref": "#/$defs/source"}, "repair": {"$ref": "#/$defs/repair"}, "task": {"type": "string", "minLength": 1}, "semantic_spine": {"$ref": "#/$defs/spine"}, "requirements": {"type": "array", "minItems": 1, "items": {"$ref": "#/$defs/obligation"}}, "acceptance": {"type": "array", "items": {"$ref": "#/$defs/acceptance"}}, "document_updates": {"type": "array", "items": {"$ref": "#/$defs/documentUpdate"}}, "required_read": {"$ref": "#/$defs/strings", "description": "Mandatory starting sources, not a read allowlist."}, "discovery_boundary": {"$ref": "#/$defs/strings", "description": "Likely discovery areas; additional project-local reads are allowed."}, "planned_write_areas": {"type": "array", "items": {"type": "string", "minLength": 1}, "description": "Soft coordination hints only. A worker may change any necessary project file inside the RUN workspace."}, "checks": {"type": "array", "items": {"$ref": "#/$defs/check"}}, "provides_checks": {"type": "array", "items": {"$ref": "#/$defs/check"}}, "stop_conditions": {"type": "array", "items": {"type": "string", "minLength": 1}, "description": "Optional action-specific accepted-decision, safety or evidence boundaries. An empty list is valid; a mismatch with current implementation or planned paths alone is not a stop condition."}, "depends_on": {"type": "array", "uniqueItems": true, "items": {"type": "string", "minLength": 1}}, "result_schema": {"const": "dd-flow/code-work-result@3"}}}
   }
 }