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

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @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

package/dist/build-info.json

@@ -1,15 +1,15 @@
 {
   "cli_package": "@deksden-com/dd-flow-cli",
-  "cli_version": "0.9.0-beta.156",
-  "cli_commit": "1a2bd0ea6d022b22e94f552f1cde1fb8e8b6689e",
-  "built_at": "2026-10-28T07:26:47.345Z",
+  "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;
@@ -728,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";
@@ -796,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`;
 }
@@ -933,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);
@@ -3672,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

@@ -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

@@ -7,6 +7,7 @@ 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",

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"}}}
   }
 }

package/dist/schemas/vnext-protocol-plan.schema.json

@@ -28,7 +28,7 @@
     "decision": {"type": "object", "additionalProperties": false, "required": ["id", "decision", "rationale", "affected_surfaces"], "properties": {"id": {"type": "string", "minLength": 1}, "decision": {"type": "string", "minLength": 1}, "rationale": {"type": "string", "minLength": 1}, "affected_surfaces": {"$ref": "#/$defs/strings"}, "durable_ref": {"type": "string", "minLength": 1}}},
     "documentUpdate": {"type": "object", "additionalProperties": false, "required": ["path", "action", "owner", "reason"], "properties": {"path": {"type": "string", "minLength": 1}, "action": {"enum": ["create", "update"]}, "owner": {"type": "string", "minLength": 1}, "reason": {"type": "string", "minLength": 1}}},
     "spine": {"type": "object", "additionalProperties": false, "required": ["user_outcome", "component_responsibility", "must_preserve", "non_goals", "acceptance_contribution"], "properties": {"user_outcome": {"type": "string", "minLength": 1}, "component_responsibility": {"type": "string", "minLength": 1}, "must_preserve": {"$ref": "#/$defs/strings"}, "non_goals": {"type": "array", "items": {"type": "string", "minLength": 1}}, "acceptance_contribution": {"type": "string", "minLength": 1}}},
-    "execution": {"type": "object", "additionalProperties": false, "required": ["required_read", "discovery_boundary", "planned_write_areas", "stop_conditions"], "properties": {"required_read": {"$ref": "#/$defs/strings", "description": "Mandatory starting sources. This is not a read allowlist."}, "discovery_boundary": {"$ref": "#/$defs/strings", "description": "Likely discovery areas. A worker may inspect other project-local sources when necessary."}, "planned_write_areas": {"type": "array", "items": {"type": "string", "minLength": 1}, "description": "Optional file or directory hints used only to coordinate concurrent Works. They never grant or deny write permission."}, "stop_conditions": {"$ref": "#/$defs/strings", "description": "Semantic contradictions or external blockers that require the worker to stop."}}},
+    "execution": {"type": "object", "additionalProperties": false, "required": ["required_read", "discovery_boundary", "planned_write_areas", "stop_conditions"], "properties": {"required_read": {"$ref": "#/$defs/strings", "description": "Mandatory starting sources. This is not a read allowlist."}, "discovery_boundary": {"$ref": "#/$defs/strings", "description": "Likely discovery areas. A worker may inspect other project-local sources when necessary."}, "planned_write_areas": {"type": "array", "items": {"type": "string", "minLength": 1}, "description": "Optional file or directory hints used only to coordinate concurrent Works. They never grant or deny write permission."}, "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."}}},
     "check": {"type": "object", "additionalProperties": false, "required": ["id", "command", "purpose", "run_at", "availability"], "properties": {"id": {"type": "string", "pattern": "^CHK-[A-Za-z0-9-]+$"}, "command": {"type": "string", "minLength": 1}, "purpose": {"type": "string", "minLength": 1}, "run_at": {"enum": ["work", "code", "readiness", "merge", "release"]}, "availability": {"enum": ["available", "planned"]}, "provided_by": {"type": "string", "pattern": "^P[0-9]+$"}, "definition": {"type": "string", "minLength": 1}, "required_artifacts": {"type": "array", "uniqueItems": true, "items": {"type": "string", "minLength": 1}}, "ports": {"type": "array", "uniqueItems": true, "items": {"type": "string", "pattern": "^[A-Za-z][A-Za-z0-9_]*$"}}, "inputs": {"type": "array", "uniqueItems": true, "items": {"type": "string", "minLength": 1}}, "reuse": {"const": "deterministic"}}, "allOf": [{"if": {"properties": {"availability": {"const": "planned"}}, "required": ["availability"]}, "then": {"required": ["provided_by", "definition"], "properties": {"command": {"pattern": "^@check/"}}}}, {"if": {"properties": {"command": {"pattern": "^@check/"}}}, "then": {"required": ["definition"]}}]},
     "verification": {"type": "object", "additionalProperties": false, "required": ["check_refs"], "properties": {"check_refs": {"type": "array", "minItems": 1, "uniqueItems": true, "items": {"type": "string", "pattern": "^CHK-[A-Za-z0-9-]+$"}}}},
     "item": {"type": "object", "additionalProperties": false, "required": ["id", "title", "summary", "details", "depends_on", "requirement_refs", "semantic_spine", "execution_context", "verification"], "properties": {"id": {"type": "string", "pattern": "^P[0-9]+$"}, "title": {"type": "string", "minLength": 1}, "summary": {"type": "string", "minLength": 1}, "details": {"type": "string", "minLength": 1}, "depends_on": {"type": "array", "uniqueItems": true, "items": {"type": "string", "pattern": "^P[0-9]+$"}}, "requirement_refs": {"$ref": "#/$defs/strings"}, "semantic_spine": {"$ref": "#/$defs/spine"}, "execution_context": {"$ref": "#/$defs/execution"}, "verification": {"$ref": "#/$defs/verification"}}},