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

package/dist/cli.js

@@ -53,12 +53,26 @@ if (args[0] === "upgrade" || args[0] === "flow" && args[1] === "mb-upgrade") {
     const { runMemoryUpgradeCli } = await import("./cli/memory-upgrade.js");
     process.exit(await runMemoryUpgradeCli(args, process.env));
 }
-if (args[0] === "review" || args[0] === "flow" && ["mb-audit", "project-review"].includes(args[1] ?? "")) {
+if (args[0] === "review" || args[0] === "flow" && ["mb-audit", "project-review", "mb-distill", "review-fix"].includes(args[1] ?? "")) {
     publishSetup('ingress_entered');
     const { runDiagnosticCli } = await import("./cli/diagnostic.js");
     publishSetup('imports_ready');
     process.exit(await runDiagnosticCli(args, process.env));
 }
+if (args[0] === "flow" && args[1] === "mb-fix") {
+    publishSetup('ingress_entered');
+    const { runMemoryFixCli } = await import("./cli/memory-fix.js");
+    publishSetup('imports_ready');
+    process.exit(await runMemoryFixCli(args, process.env));
+}
+if (args[0] === "flow" && args[1] === "interactive") {
+    const { runInteractiveCli } = await import("./cli/interactive.js");
+    process.exit(await runInteractiveCli(args, process.env));
+}
+if (args[0] === "flow" && ["release", "deploy", "publish"].includes(args[1] ?? "")) {
+    const { runDeliveryCli } = await import("./cli/delivery.js");
+    process.exit(await runDeliveryCli(args, process.env));
+}
 if (args.slice(0, 3).join(" ") === "runtime storage admit") {
     const { runMemoryStorageAdmissionCli } = await import("./cli/memory-storage-admission.js");
     process.exit(runMemoryStorageAdmissionCli(args));
@@ -75,10 +89,10 @@ if (args.slice(0, 3).join(" ") === "runtime flow admit") {
     const { runMemoryFlowAdmissionCli } = await import("./cli/memory-flow-admission.js");
     process.exit(await runMemoryFlowAdmissionCli(args));
 }
-const managedHook = Boolean(process.env.DD_FLOW_CODEX_STATE_DIR) && args.slice(0, 3).join(" ") === "codex hook handle";
+const codexHook = args.slice(0, 3).join(" ") === "codex hook handle";
 const exitCode = isRuntimeMaintenanceIngress(args, process.env)
     ? await runRuntimeMaintenanceIngress(args)
-    : managedHook
+    : codexHook
         ? await (await import("./cli/hook-ingress.js")).runHookIngress(args)
         : isNativeHookIngress(args)
             ? await (await import("./cli/native-hook-ingress.js")).runNativeHookIngress(args)

package/dist/domain/delivery-flows.js

@@ -0,0 +1,8 @@
+export const deliveryFlowStages = {
+    release: ["preflight", "version-decision", "prepare", "verify", "publish", "finish"],
+    deploy: ["preflight", "target-decision", "prepare", "deploy", "verify", "finish"],
+    publish: ["preflight", "target-decision", "prepare", "verify", "publish", "finish"]
+};
+export function isDeliveryFlow(value) {
+    return typeof value === "string" && Object.hasOwn(deliveryFlowStages, value);
+}

package/dist/domain/distill-flow.js

@@ -0,0 +1,20 @@
+/** Distillation's semantic catalog, not executable handler registration. */
+export const distillStages = ["preflight", "extract", "review", "promote", "verify", "finish"];
+const domain = [
+    "structure-navigation", "delivery-protocols", "deferrals-closure", "scenarios-evidence", "ui-guides",
+    "system-adr-contracts", "engineering-code-standards", "operations-release", "agent-workflow-prompts", "templates-metadata"
+];
+const process = [
+    "user-intent-intake", "project-grounding", "flow-routing", "planning-decomposition", "execution-orchestration",
+    "implementation-context-coding", "debugging-failure-recovery", "review-verification-testing", "evidence-acceptance-closure",
+    "delivery-release-operations", "memory-documentation-lifecycle", "memory-freshness-self-improvement"
+];
+export const distillAspects = Object.freeze([
+    ...domain.map((name, index) => aspect("domain", name, index)),
+    ...process.map((name, index) => aspect("process", name, index))
+]);
+function aspect(lens, name, index) {
+    const number = String(index + 1).padStart(2, "0");
+    return Object.freeze({ id: `${lens}-${number}`, lens, name,
+        criterion: `support/dd-flow/mb-distill/${lens === "domain" ? "aspects" : "process-aspects"}/${number}-${name}.md` });
+}

package/dist/domain/interactive-flow.js

@@ -0,0 +1 @@
+export const interactiveStages = ["preflight", "interactive", "consolidation", "hardening", "review", "integration"];

package/dist/domain/memory-fix-flow.js

@@ -0,0 +1,2 @@
+/** Semantic contract only; executable admission belongs to registered handlers. */
+export const memoryFixStages = ["intake", "repair", "verify", "review", "finish"];

package/dist/domain/review-fix-flow.js

@@ -0,0 +1,2 @@
+/** Scope intake only. Handoff never allocates or authorizes an SDLC RUN. */
+export const reviewFixStages = ["intake", "scope-review", "handoff"];

package/dist/domain/source-snapshot-flows.js

@@ -0,0 +1,4 @@
+import { isDiagnosticFlow } from "./diagnostic-flows.js";
+export function isSourceSnapshotFlow(id) {
+    return id === "mb-distill" || id === "review-fix" || isDiagnosticFlow(id);
+}

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

@@ -17,22 +17,37 @@ async function hook(options) {
   try {
   const observationMs = budget.remaining("observation");
   const identity = await callDaemon(options["state-dir"], "hook.observe", { event, payload, daemonId: options["daemon-id"], deadlineAt: budget.deadlineAt }, observationMs, requestId);
+  if (identity.fastAck === true) {
+    const binding = identity.nativeHookBinding, args = payload.toolCall?.args ?? {};
+    if (event !== "PreToolUse" || binding?.native_admission !== "assigned_work_start" || binding.source_harness !== "antigravity-cli"
+      || binding.daemon_id !== options["daemon-id"] || binding.provider_session_id !== payload.conversationId
+      || binding.native_command !== (args.command ?? args.cmd ?? args.CommandLine)) throw Object.assign(new Error("Deferred native callback binding differs"), { code: "native_hook_unproven" });
+    return { decision: "allow" };
+  }
   if (identity.stale) return event === "PreToolUse" ? { decision: "deny", reason: "agy_stale_hook" } : {};
-  if (event === "PreToolUse" || event === "PostToolUse") {
+  if (!identity.observationOnly && (event === "PreToolUse" || event === "PostToolUse")) {
     const phase = event === "PreToolUse" ? "before" : "after", args = payload.toolCall?.args ?? {};
     const normalized = { schema_id: "dd-flow/agy-tool-event@1", event_id: identity.event_id, phase, daemon_id: identity.daemon_id, launch_cwd: identity.launch_cwd, conversation_id: payload.conversationId, parent_conversation_id: identity.parent_conversation_id, execution_num: payload.executionNum, step_index: payload.stepIdx, tool: payload.toolCall?.name, input: args, workspace_paths: payload.workspacePaths, transcript_path: payload.transcriptPath, model: payload.modelName, profile: identity.profile, ...(phase === "after" ? { error: payload.error ?? "" } : {}) };
     await invokeNativeHook({ bin: options["dd-flow-bin"] ?? identity.dd_flow_bin,
       args: ["agy", "event", "handle", "--project-root", options["project-root"] ?? identity.project_root, "--json"],
       payload: normalized, home: options["dd-flow-home"] ?? identity.dd_flow_home, timeoutMs: budget.remaining("admission") });
   }
+  // A successful callback can retire its exact observation request. This is
+  // best-effort housekeeping: lost IPC neither denies the native tool nor
+  // invents an execution result; the daemon retains the request if uncertain.
+  try { await callDaemon(options["state-dir"], "hook.complete", { daemonId: options["daemon-id"], requestId }, Math.min(500, budget.remaining("retirement"))); }
+  catch { /* The request remains available for a late failure receipt. */ }
   return event === "PreToolUse" ? { decision: "allow" } : {};
   } catch (error) {
     // A failed socket cannot be used to report its own failure. The daemon
     // reads only receipts matching request IDs it actually accepted this turn.
     const correctable = event === "PreToolUse" && error.code === "lifecycle_shell_syntax_invalid" && error.details?.effect === "no_effect"
       && error.details?.recoverable === true && error.details?.disposition === "pre_cli_shell_refusal";
-    try { await budget.run(() => writeJsonAtomic(path.join(options["state-dir"], "hook-failures", `${requestId}.json`), { request_id: requestId, observed_at: new Date().toISOString(), code: error.code ?? "agy_hook_rejected", message: error.message,
-      details: { ...error.details, effect: correctable ? "no_effect" : "unknown", ...(correctable ? { native_pre_cli_refusal: true } : {}) } }, () => budget.remaining("failure_receipt_commit")), "failure_receipt"); }
+    // The operation deadline may already be exhausted. It cannot be reused to
+    // persist the failure caused by that deadline: the daemon consumes only a
+    // receipt for a request it actually registered for its current turn.
+    try { await writeJsonAtomic(path.join(options["state-dir"], "hook-failures", `${requestId}.json`), { request_id: requestId, observed_at: new Date().toISOString(), code: error.code ?? "agy_hook_rejected", message: error.message,
+      details: { ...error.details, effect: correctable ? "no_effect" : "unknown", ...(correctable ? { native_pre_cli_refusal: true } : {}) } }); }
     catch (storage) { process.stderr.write(`${JSON.stringify({ code: error.code, receipt_error: storage.message })}\n`); }
     throw error;
   }

package/dist/harness-runtime/bin/dd-grok.mjs

@@ -10,15 +10,25 @@ function parse(argv) { const positional = []; const options = {}; for (let index
 function common(options, operation) { return { bin: options["grok-bin"], journal: options.journal, stateDir: options["state-dir"], cwd: options.cwd, sessionId: options["session-id"], model: options.model, reasoning: options.reasoning, mode: options.mode ?? "bypassPermissions", authPath: options["auth-path"], authMethodId: options["auth-method-id"], ddFlowBin: options["dd-flow-bin"], ddFlowHome: options["dd-flow-home"], projectRoot: options["project-root"], sessionArchive: options["session-archive"], noFlow: options["no-flow"] === true, ...adapterTimeoutOptions(options, operation) }; }
 async function hook(options) {
   const budget = hookBudget();
-  const stdin = await readNativeHookInput(process.stdin, budget); const payload = JSON.parse(stdin || "{}"); const identity = await callDaemon(options["state-dir"], "hook.resolve", { sessionId: payload.sessionId ?? payload.session_id, payload }, budget.remaining("identity"));
+  const stdin = await readNativeHookInput(process.stdin, budget); const payload = JSON.parse(stdin || "{}"); const identity = await callDaemon(options["state-dir"], "hook.resolve", { sessionId: payload.sessionId ?? payload.session_id, payload, hookDeadlineAt: budget.deadlineAt }, budget.remaining("identity"));
+  const binding = identity.nativeHookBinding, input = payload.tool_input ?? payload.toolInput;
+  // Only the daemon's exact, retained child delivery can use this short ACK;
+  // the issued CLI command still verifies its assignment and materializes it.
+  if (identity.fastAck === true && binding?.source_harness === "grok-acp" && binding.request_id
+    && binding.provider_session_id === (payload.sessionId ?? payload.session_id)
+    && binding.provider_session_id !== binding.root_provider_session_id
+    && binding.native_command === (input?.command ?? input?.cmd)) return { decision: "continue" };
   const enriched = { ...payload, _meta: { ...(payload._meta ?? {}), ddGrok: identity } }; const args = ["grok", "event", "handle", "--project-root", options["project-root"], "--json"]; const command = options["dd-flow-bin"];
   try { return await invokeNativeHook({ bin: command, args, home: options["dd-flow-home"], payload: enriched, timeoutMs: budget.remaining("admission") }); }
   catch (error) {
     if (identity.nativeHookBinding) error.details = { ...error.details, native_hook_binding: identity.nativeHookBinding };
-    try {
-      await writeNativeHookFailure(options["state-dir"], identity.nativeHookBinding, error, budget);
-      if (identity.nativeHookBinding) await callDaemon(options["state-dir"], "hook.failed", { requestId: identity.nativeHookBinding.request_id }, budget.remaining("failure_notification"));
-    } catch (storage) { process.stderr.write(`${JSON.stringify({ code: error.code, receipt_error: storage.message })}\n`); }
+    let storageError;
+    try { await writeNativeHookFailure(options["state-dir"], identity.nativeHookBinding, error); }
+    catch (storage) { storageError = storage; process.stderr.write(`${JSON.stringify({ code: error.code, receipt_error: storage.message })}\n`); }
+    if (identity.nativeHookBinding && storageError?.code !== "native_hook_identity_conflict") try {
+      await callDaemon(options["state-dir"], "hook.failed", { requestId: identity.nativeHookBinding.request_id,
+        ...(storageError ? { binding: identity.nativeHookBinding, failure: errorRecord(error) } : {}) }, storageError ? 5_000 : budget.remaining("failure_notification"));
+    } catch { /* The durable receipt is polled by the owner or retained for reconciliation. */ }
     throw error;
   }
 }

package/dist/harness-runtime/bin/dd-zcode.mjs

@@ -34,18 +34,26 @@ function common(options, operation) {
 async function hook(options) {
   const budget = hookBudget();
   const payload = JSON.parse((await readNativeHookInput(process.stdin, budget)) || "{}");
-  const identity = await callDaemon(options["state-dir"], "hook.resolve", { sessionId: payload.session_id ?? payload.sessionId, payload }, budget.remaining("identity"));
+  const identity = await callDaemon(options["state-dir"], "hook.resolve", { sessionId: payload.session_id ?? payload.sessionId, payload, hookDeadlineAt: budget.deadlineAt }, budget.remaining("identity"));
+  const binding = identity.nativeHookBinding, input = payload.tool_input ?? payload.toolInput;
+  // This only acknowledges an already retained child delivery. The actual
+  // Work CLI still materializes and validates its issued invocation via CAS.
+  if (identity.fastAck === true && binding?.source_harness === "zcode-acp" && binding.request_id
+    && binding.provider_session_id === (payload.session_id ?? payload.sessionId)
+    && binding.provider_session_id !== binding.root_provider_session_id
+    && binding.native_command === (input?.command ?? input?.cmd)) return {};
   const command = options["dd-flow-bin"]; const args = ["zcode", "hook", "handle", "--project-root", options["project-root"], "--json"];
 
   try { return await invokeNativeHook({ bin: command, args, home: options["dd-flow-home"], timeoutMs: budget.remaining("admission"), payload: { ...payload, _meta: { ...(payload._meta ?? {}), ddZcode: identity } } }); }
   catch (error) {
     if (identity.nativeHookBinding) error.details = { ...error.details, native_hook_binding: identity.nativeHookBinding };
-    try {
-      // Evidence shares the original deadline; an expired admission cannot
-      // start a new independent failure-report window.
-      await writeNativeHookFailure(options["state-dir"], identity.nativeHookBinding, error, budget);
-      if (identity.nativeHookBinding) await callDaemon(options["state-dir"], "hook.failed", { requestId: identity.nativeHookBinding.request_id }, budget.remaining("failure_notification"));
-    } catch (storage) { process.stderr.write(`${JSON.stringify({ code: error.code, receipt_error: storage.message })}\n`); }
+    let storageError;
+    try { await writeNativeHookFailure(options["state-dir"], identity.nativeHookBinding, error); }
+    catch (storage) { storageError = storage; process.stderr.write(`${JSON.stringify({ code: error.code, receipt_error: storage.message })}\n`); }
+    if (identity.nativeHookBinding && storageError?.code !== "native_hook_identity_conflict") try {
+      await callDaemon(options["state-dir"], "hook.failed", { requestId: identity.nativeHookBinding.request_id,
+        ...(storageError ? { binding: identity.nativeHookBinding, failure: errorRecord(error) } : {}) }, storageError ? 5_000 : budget.remaining("failure_notification"));
+    } catch { /* The durable receipt is polled by the owner or retained for reconciliation. */ }
     throw error;
   }
 }

package/dist/harness-runtime/lib/agy-error-boundary.mjs

@@ -6,14 +6,22 @@ import { agyTerminalEnvelope, ownedAgyOutput } from "./agy-terminal-envelope.mjs
 export function recoveredAgyErrorBoundary(text, error, floor = -1, source = null, sessionId = null) {
   let rows;
   try { rows = text.trim().split("\n").filter(Boolean).map(JSON.parse); } catch { return null; }
+  const reducer = createAgyErrorBoundary(error, floor, source, sessionId);
+  for (const row of rows) reducer.add(row);
+  return reducer.finish();
+}
+
+/** Stateful equivalent for an owned, validated JSONL snapshot. */
+export function createAgyErrorBoundary(error, floor = -1, source = null, sessionId = null) {
   let previous = -1, lastError = null, boundary = null, invocation = null, call = null;
-  const launches = new Map();
-  for (const row of rows) {
-    if (!Number.isInteger(row.step_index) || row.step_index <= previous) return null;
+  const launches = new Map(); let invalid = false;
+  function add(row) {
+    if (invalid) return;
+    if (!Number.isInteger(row.step_index) || row.step_index <= previous) { invalid = true; return; }
     previous = row.step_index;
-    if (row.step_index <= (floor ?? -1)) continue;
-    if (row.type === "USER_INPUT") { lastError = null; boundary = null; invocation = null; call = null; launches.clear(); continue; }
-    if (row.type === "ERROR_MESSAGE") { lastError = row; boundary = null; invocation = null; continue; }
+    if (row.step_index <= (floor ?? -1)) return;
+    if (row.type === "USER_INPUT") { lastError = null; boundary = null; invocation = null; call = null; launches.clear(); return; }
+    if (row.type === "ERROR_MESSAGE") { lastError = row; boundary = null; invocation = null; return; }
     if (Array.isArray(row.tool_calls)) {
       invocation = null;
       call = row.tool_calls.length === 1 ? row.tool_calls[0] : null;
@@ -29,7 +37,7 @@ export function recoveredAgyErrorBoundary(text, error, floor = -1, source = null
     if (row.type === 'GENERIC' && row.status === 'RUNNING') {
       const task = row.content?.match(/^Created At: [^\n]+\nTool is running as a background task with task id: ([\w-]+\/task-\d+)\n/);
       if (task && invocation && (!sessionId || task[1].startsWith(`${sessionId}/`))) launches.set(task[1], launches.has(task[1]) ? null : { invocation, step: row.step_index });
-      call = null; invocation = null; continue;
+      call = null; invocation = null; return;
     }
     const envelope = agyTerminalEnvelope(row, call);
     let launchStep = null;
@@ -38,11 +46,11 @@ export function recoveredAgyErrorBoundary(text, error, floor = -1, source = null
       invocation = launch && launch.step < row.step_index ? launch.invocation : null;
       launchStep = launch?.step ?? null;
     }
-    if (!lastError || envelope?.exit_code !== 0) continue;
+    if (!lastError || envelope?.exit_code !== 0) return;
     const retained = envelope.output_reference && source && sessionId ? ownedAgyOutput(envelope.output_reference, source, sessionId, envelope.task_id) : null;
     const full = retained ? agyTerminalEnvelope({ type: 'GENERIC', status: 'DONE', content: retained.text }) : null;
     const output = (retained ? full?.exit_code === 0 ? full.output : null : envelope.output)?.replaceAll("\r", "");
-    if (!output) continue;
+    if (!output) return;
     for (const match of output.matchAll(/^\s*\{/gm)) {
       let receipt;
       const candidate = output.slice(match.index).trim();
@@ -74,6 +82,6 @@ export function recoveredAgyErrorBoundary(text, error, floor = -1, source = null
       }
     }
   }
-  return boundary && lastError?.error === error ? boundary : null;
+  return { add, finish: () => !invalid && boundary && lastError?.error === error ? boundary : null };
 }
 

package/dist/harness-runtime/lib/agy-native-inspection.mjs

@@ -160,14 +160,23 @@ async function agyNativeRequest({ endpoint, sessionId, cwd, remainingMs, signal,
   if (!/^127\.0\.0\.1:\d+$/.test(endpoint?.target ?? '') || Number(endpoint.target.split(':')[1]) < 1 || Number(endpoint.target.split(':')[1]) > 65535) throw invalid('native_endpoint_nonloopback');
   if (!Number.isFinite(remainingMs) || remainingMs < 1) throw invalid('observation_budget_exhausted');
   const deadline = Date.now() + remainingMs;
-  const client = new Client(endpoint.target, grpc.credentials.createInsecure(), { 'grpc.max_receive_message_length': 1024 * 1024, 'grpc.max_send_message_length': 64 * 1024, 'grpc.enable_retries': 0 });
+  const client = new Client(endpoint.target, grpc.credentials.createInsecure(), { 'grpc.max_receive_message_length': -1, 'grpc.max_send_message_length': 64 * 1024, 'grpc.enable_retries': 0 });
   let active;
   const headers = new grpc.Metadata();
   if (typeof csrfToken === 'string' && csrfToken) headers.set('x-codeium-csrf-token', csrfToken);
   const abort = () => active?.cancel();
+  // Native error details may contain request or authentication material. Keep
+  // the method and numeric status for diagnosis without copying those bytes.
+  const grpcError = (name, error) => {
+    const code = Number.isInteger(error?.code) ? error.code : null;
+    const failure = invalid(`grpc_${code ?? 'unknown'}`);
+    failure.details.grpc_method = agyNativeService[name].path;
+    failure.details.grpc_code = code;
+    return failure;
+  };
   const unary = (name, request) => new Promise((resolve, reject) => {
     if (signal?.aborted) return reject(invalid('inspection_cancelled'));
-    active = client[name](request, headers, { deadline }, (error, value) => error ? reject(invalid(`grpc_${error.code ?? 'unknown'}`)) : value ? resolve(value) : reject(invalid('grpc_message_missing')));
+    active = client[name](request, headers, { deadline }, (error, value) => error ? reject(grpcError(name, error)) : value ? resolve(value) : reject(invalid('grpc_message_missing')));
   });
   signal?.addEventListener('abort', abort, { once: true });
   try {
@@ -191,7 +200,7 @@ async function agyNativeRequest({ endpoint, sessionId, cwd, remainingMs, signal,
           const snapshot = JSON.parse(JSON.stringify(update, (key, value) => key.startsWith('$') ? undefined : value));
           done = true; resolve({ ...snapshot, observed_at: new Date().toISOString(), method: agyNativeService.state.path }); active.cancel();
         });
-        active.on('error', error => { if (!done) { done = true; reject(invalid(`grpc_${error.code ?? 'unknown'}`)); } });
+        active.on('error', error => { if (!done) { done = true; reject(grpcError('state', error)); } });
         active.on('end', () => { if (!done) { done = true; reject(invalid('native_state_snapshot_missing')); } });
       });
     }

package/dist/harness-runtime/lib/agy-native-inventory.mjs

@@ -0,0 +1,19 @@
+// A new StreamAgentStateUpdates subscription starts with a full snapshot.
+// An omitted protobuf update is an empty list; a partial indexed list is not.
+export const agyNativeFullList = (update, key) => !update ||
+  Array.isArray(update[key]) && update.totalLength === update[key].length &&
+  update.indices?.length === update.totalLength && update.indices.every((value, offset) => value === offset);
+
+export function agyNativeInventory(snapshot, sessionId) {
+  if (snapshot?.conversationId !== sessionId || !snapshot.trajectoryId || snapshot.error ||
+    snapshot.method !== '/exa.language_server_pb.LanguageServerService/StreamAgentStateUpdates' ||
+    !agyNativeFullList(snapshot.backgroundTasksUpdate, 'backgroundTasks') ||
+    !agyNativeFullList(snapshot.pendingAgentMessagesUpdate, 'pendingAgentMessages'))
+    throw Object.assign(new Error('AGY native task inventory is incomplete or unbound'), { code: 'native_resources_unproven' });
+  const tasks = snapshot.backgroundTasksUpdate?.backgroundTasks?.map(item => item.taskSnapshot) ?? [];
+  if (tasks.some(task => !task || typeof task.taskId !== 'string' || !task.taskId.startsWith(`${sessionId}/task-`) || !/\/task-\d+$/.test(task.taskId) || !task.toolName) ||
+    new Set(tasks.map(task => task.taskId)).size !== tasks.length)
+    throw Object.assign(new Error('AGY native task identity is unproven'), { code: 'native_resources_unproven' });
+  return { tasks, messages: snapshot.pendingAgentMessagesUpdate?.pendingAgentMessages ?? [],
+    idle: snapshot.fullyIdle === true && snapshot.status === 1 && snapshot.executorLoopStatus === 1 && snapshot.hasActiveChildren !== true };
+}

package/dist/harness-runtime/lib/agy-terminal-envelope.mjs

@@ -2,6 +2,7 @@ import { constants, openSync, closeSync, fstatSync, lstatSync, readSync, realpat
 import { fileURLToPath } from 'node:url';
 import path from 'node:path';
 import { createHash } from 'node:crypto';
+import { StringDecoder } from 'node:string_decoder';
 
 const taskId = '[\\w-]+/task-\\d+';
 
@@ -18,16 +19,22 @@ export function ownedAgyOutput(reference, source, sessionId, ownerTask = null) {
       if (!number || ![`steps/${number}/output.txt`, `tasks/task-${number}.log`].includes(relative)) return null;
     }
     const before = lstatSync(file);
-    if (!before.isFile() || before.size > 2 * 1024 * 1024) return null;
+    if (!before.isFile()) return null;
     fd = openSync(file, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
     const stat = fstatSync(fd);
     if (!stat.isFile() || stat.ino !== before.ino || stat.dev !== before.dev) return null;
-    const bytes = Buffer.alloc(stat.size);
-    let offset = 0;
-    while (offset < bytes.length) { const count = readSync(fd, bytes, offset, bytes.length - offset, offset); if (!count) return null; offset += count; }
+    const bytes = Buffer.allocUnsafe(64 * 1024), decoder = new StringDecoder('utf8'), hash = createHash('sha256');
+    let offset = 0, text = '';
+    while (offset < stat.size) {
+      const count = readSync(fd, bytes, 0, Math.min(bytes.length, stat.size - offset), offset); if (!count) return null;
+      const chunk = bytes.subarray(0, count); hash.update(chunk); text += decoder.write(chunk); offset += count;
+    }
+    text += decoder.end();
     const after = fstatSync(fd);
-    if (stat.size !== after.size || stat.mtimeMs !== after.mtimeMs) return null;
-    return { text: bytes.toString('utf8'), sha256: createHash('sha256').update(bytes).digest('hex'), locator: reference };
+    const finalPath = lstatSync(file);
+    if (!finalPath.isFile() || finalPath.dev !== stat.dev || finalPath.ino !== stat.ino || realpathSync(file) !== file
+      || stat.size !== after.size || stat.mtimeMs !== after.mtimeMs || stat.ctimeMs !== after.ctimeMs) return null;
+    return { text, sha256: hash.digest('hex'), locator: reference };
   } catch { return null; }
   finally { if (fd !== undefined) closeSync(fd); }
 }

package/dist/harness-runtime/lib/agy-transcript-stream.mjs

@@ -0,0 +1,54 @@
+import { createHash } from 'node:crypto';
+import { StringDecoder } from 'node:string_decoder';
+
+// The caller opens and validates the owned no-symlink handle and must discard
+// tentative callback results if this function rejects. One complete JSONL
+// record, rather than the whole transcript, is the largest retained value.
+export async function readAgyTranscriptSnapshot(handle, { locator, assertIdentity, onRecord, onProgress }) {
+  if (typeof assertIdentity !== 'function' || typeof onRecord !== 'function') throw new TypeError('snapshot requires owner validation and a record consumer');
+  const original = await handle.stat();
+  const unchanged = async () => {
+    const current = await handle.stat();
+    if (!current.isFile() || current.dev !== original.dev || current.ino !== original.ino || current.size !== original.size
+      || current.mtimeMs !== original.mtimeMs || current.ctimeMs !== original.ctimeMs) throw new Error('agy_transcript_snapshot_changed');
+    await assertIdentity(current);
+  };
+  if (!original.isFile()) throw new Error('agy_transcript_snapshot_changed');
+  await unchanged();
+  const buffer = Buffer.allocUnsafe(64 * 1024), digest = createHash('sha256');
+  let offset = 0, complete = 0, completeHash = digest.copy();
+  while (offset < original.size) {
+    const { bytesRead } = await handle.read(buffer, 0, Math.min(buffer.length, original.size - offset), offset);
+    if (!bytesRead) throw new Error('agy_transcript_snapshot_changed');
+    const chunk = buffer.subarray(0, bytesRead), lastNewline = chunk.lastIndexOf(10);
+    if (lastNewline >= 0) {
+      digest.update(chunk.subarray(0, lastNewline + 1));
+      complete = offset + lastNewline + 1; completeHash = digest.copy();
+      digest.update(chunk.subarray(lastNewline + 1));
+    } else digest.update(chunk);
+    offset += bytesRead;
+    await onProgress?.(`digest:${original.dev}:${original.ino}:${original.size}:${original.mtimeMs}:${offset}`);
+  }
+  const source = { locator, byte_start: 0, byte_end: complete, sha256: completeHash.digest('hex') };
+  await unchanged();
+  const decoder = new StringDecoder('utf8'); let pending = '', line = 0;
+  offset = 0;
+  while (offset < complete) {
+    const { bytesRead } = await handle.read(buffer, 0, Math.min(buffer.length, complete - offset), offset);
+    if (!bytesRead) throw new Error('agy_transcript_snapshot_changed');
+    pending += decoder.write(buffer.subarray(0, bytesRead)); offset += bytesRead;
+    await onProgress?.(`records:${source.sha256}:${offset}`);
+    let newline;
+    while ((newline = pending.indexOf('\n')) >= 0) {
+      const text = pending.slice(0, newline); pending = pending.slice(newline + 1); line += 1;
+      if (!text.trim()) continue;
+      let record;
+      try { record = JSON.parse(text); } catch { throw new Error('agy_transcript_invalid_record'); }
+      await onRecord(record, { ...source, line });
+    }
+  }
+  pending += decoder.end();
+  if (pending) throw new Error('agy_transcript_snapshot_changed');
+  await unchanged();
+  return { source, partial_tail: complete !== original.size };
+}

package/dist/harness-runtime/lib/daemon-observation.d.mts

@@ -1,2 +1,3 @@
 export function recoverDaemonReply(root: string, id: string, options?: { timeoutMs?: number | null; signal?: AbortSignal; binding?: Record<string, unknown>; onProgress?: (value: Record<string, unknown>) => void; onOutcome?: (value: Record<string, unknown>) => void; onPendingSettlement?: (value: Record<string, unknown>) => Promise<void>; observationClock?: import("./observation-clock.mjs").ObservationClock }): Promise<Record<string, unknown>>;
 export function retainedDaemonReply(root: string, id: string, binding?: Record<string, unknown>): Promise<{ ready: boolean; outcome: unknown; value?: unknown; settlement?: Record<string, unknown> | null; reason?: string } | null>;
+export function withDaemonProgressObserver<T>(observer: (value: Record<string, unknown>) => void, action: () => Promise<T>): Promise<T>;

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

@@ -1,13 +1,17 @@
 import net from 'node:net';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { randomUUID } from 'node:crypto';
 import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { hashJson, writeJsonAtomic } from './runner-events.mjs';
 import { ObservationClock } from './observation-clock.mjs';
 import { canonicalNativeOperation, nativeOperationWait, validateDaemonWait } from './adapter-timeouts.mjs';
-import { assertNativeLine, retainNativeReplyBuffer } from './native-streams.mjs';
+import { assertNativeLine } from './native-streams.mjs';
 import { operationDirectory, readOperationRecord, readOperationProgress, readOperationWaiting, suspendOperationClock } from './operation-progress.mjs';
 
 const productive = new Set(['session.create', 'session.prompt', 'session.start', 'session.fork', 'session.resume']);
+const progressObserver = new AsyncLocalStorage();
+export const withDaemonProgressObserver = (observer, action) => progressObserver.run(observer, action);
 const fault = (code, message, details) => Object.assign(new Error(message), { code, retryable: false, details });
 export async function retainedDaemonReply(root, id, binding = {}) {
   const requested = await readOperationRecord(root, id, 'requested.json');
@@ -84,9 +88,12 @@ export async function callDaemonObserved({ stateDir, socket, request, responseSc
   validateDaemonWait(harness, request.operation, timeoutMs);
   assertNativeLine(JSON.stringify(request), 'request');
   const durable = productive.has(request.operation);
+  const verification = request.operation === 'hook.verify' && request.params?.binding?.native_admission === 'assigned_work_start';
+  if (verification) request = { ...request, id: randomUUID() }; // Read-only proof is fresh, never a replay of prior authority.
+  const observable = durable || verification, onProgress = progressObserver.getStore();
   const binding = { operation: request.operation, params_sha256: hashJson({ operation: request.operation, params: request.params ?? {} }) };
   let initialDaemon;
-  if (durable) try {
+  if (observable) try {
     const state = JSON.parse(await readFile(path.join(stateDir,'daemon.json'),'utf8'));
     initialDaemon = state.daemon_id ?? state.config?.daemonId ?? null;
     binding.owner_id = state.config?.runtime_owner?.owner_id ?? null;
@@ -119,12 +126,13 @@ export async function callDaemonObserved({ stateDir, socket, request, responseSc
       if (done || polling) return pollFlight; polling = true;
       pollFlight = (async () => {
       try {
-        const progress = durable ? await readOperationProgress(stateDir, request.id, { ...binding, ...(frozenDaemon === undefined ? {} : { daemon_id: frozenDaemon }) }) : null;
+        const progress = observable ? await readOperationProgress(stateDir, request.id, { ...binding, ...(frozenDaemon === undefined ? {} : { daemon_id: frozenDaemon }) }) : null;
         if (done) return;
         if (progress && progress.sequence > lastSequence) {
           frozenDaemon ??= progress.daemon_id; lastSequence = progress.sequence;
           binding.generation ??= progress.generation;
           latestProgress = {cursor:progress.sequence,observed_at:Date.parse(progress.observed_at)};
+          if (verification && progress.phase === 'verification_progress') onProgress?.(progress);
           process.stderr.write(`${JSON.stringify({ kind: 'operation_progress', ...progress })}\n`);
         }
         if (durable && disconnected) {
@@ -148,7 +156,7 @@ export async function callDaemonObserved({ stateDir, socket, request, responseSc
     client.on('end', () => lost(fault('daemon_connection_closed', 'daemon closed before reply')));
     client.on('close', () => lost(fault('daemon_connection_closed', 'daemon closed before reply')));
     client.on('data', chunk => { void (async () => {
-      buffer += chunk; if (!retainNativeReplyBuffer(buffer, finish)) return;
+      buffer += chunk;
       const at = buffer.indexOf('\n'); if (at < 0) return;
       try {
         const response = JSON.parse(buffer.slice(0, at));

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

@@ -4,7 +4,7 @@ import { mkdir, readFile, readdir, link, unlink, open } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
 import path from "node:path";
 import { hashJson, writeJsonAtomic } from "./runner-events.mjs";
-import { errorRecord, isObservationLoss, isProvenShellCorrection, reportedError } from "./operation-errors.mjs";
+import { errorRecord, isNativeHookObservationLoss, isObservationLoss, isProvenShellCorrection, reportedError } from "./operation-errors.mjs";
 import { assertDaemonOwnership, budgetObservationScope, releaseBudgetObservation, completeBudgetOperation, stopProcessGroup } from "./managed-daemon.mjs";
 import { processSnapshot } from "./process-snapshot.mjs";
 import { NATIVE_SHUTDOWN_CONTRACT, NATIVE_SHUTDOWN_PHASES } from "./native-children.mjs";
@@ -90,6 +90,12 @@ export async function completeDaemonShutdown(root, state, persist, prepare, phas
     commitDaemonShutdown(root);
     if (reconcileResources && !shutdown.phases.owned_resources) {
       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.
+      if (shutdown.phases.native_resources_reconciled) {
+        shutdown = { ...shutdown, phases: { ...shutdown.phases, native_resources_reconciled: false } };
+        await persist({ shutdown });
+      }
       const resources = await reconcileResources();
       const prior = shutdown.result?.native_resources;
       if ((state.daemon_id ?? state.config?.daemonId) !== daemonId || state.native_execution_revision !== revision
@@ -98,7 +104,9 @@ export async function completeDaemonShutdown(root, state, persist, prepare, phas
         || resources.generation !== prior?.generation || resources.revision !== prior?.revision || !Array.isArray(resources.entries)
         || resources.entries.some(item => item.owner_daemon_id !== daemonId || item.generation !== resources.generation))
         throw Object.assign(new Error('native resource reconciliation lost its owner/execution fence'), { code: 'native_resources_unproven' });
-      shutdown = { ...shutdown, result: { ...shutdown.result, native_resources: resources } };
+      shutdown = { ...shutdown, phases: { ...shutdown.phases, native_resources_reconciled: true },
+        native_resource_reconciliation: { daemon_id: daemonId, dispatch_generation: generation, native_revision: revision },
+        result: { ...shutdown.result, native_resources: resources } };
       await persist({ shutdown });
     }
     for (const [phase, action] of phases) {
@@ -249,8 +257,12 @@ export async function inspectDaemonOperation(root, id) {
     catch (error) { hookDiagnostics.push({ code: "native_hook_receipt_invalid", message: error.message, request_id: binding.request_id, effect: "unknown", receipt_bound: false }); continue; }
     if (failure?.request_id !== binding.request_id || typeof failure.code !== "string" || typeof failure.message !== "string") continue;
     if (binding.command_sha256 && JSON.stringify(failure.native_hook_binding) !== JSON.stringify(binding)) continue;
-    const correction = isProvenShellCorrection(failure);
-    (correction ? hookCorrections : hookFailures).push({ ...errorRecord(failure), observed_at: failure.observed_at ?? null, details: { ...failure.details, native_hook_binding: binding, effect: correction ? "no_effect" : "unknown" } });
+    // AGY can observe a callback while a newer prompt is active without
+    // knowing the native creator. Keep its original refusal as diagnostic,
+    // never as this operation's primary failure or automatic correction.
+    const unconfirmedCreator = binding.native_creator === "unconfirmed";
+    const correction = !unconfirmedCreator && isProvenShellCorrection(failure);
+    (unconfirmedCreator ? hookDiagnostics : correction ? hookCorrections : isNativeHookObservationLoss(failure) ? hookDiagnostics : hookFailures).push({ ...errorRecord(failure), observed_at: failure.observed_at ?? null, details: { ...failure.details, native_hook_binding: binding, effect: correction ? "no_effect" : "unknown" } });
   }
   hookFailures.sort((a, b) => String(a.observed_at ?? "").localeCompare(String(b.observed_at ?? "")));
   // Admission failure is causal evidence, not proof that the native tree stopped.
@@ -342,6 +354,8 @@ export async function durableDaemonDispatch(root, request, action, observe) {
     return settlement.state === "not_required" || !result || typeof result !== "object" || Array.isArray(result) ? result : { ...result, settlement };
   }
   const control = ["daemon.stop", "session.cancel"].includes(request.operation);
+  if (request.operation === 'hook.verify' && request.params?.binding?.native_admission === 'assigned_work_start')
+    return await journalDispatch(root, request, () => withOperationProgress(root, request.id, action), false);
   if (!productive.has(request.operation) && !control) return await action();
   const generation = dispatchGenerations.get(root) ?? 0;
   // Once retirement is committed there is no productive dispatch to cancel.
@@ -397,7 +411,7 @@ export async function durableDaemonStart(options, action) {
   return await journalDispatch(root, request, () => action(options));
 }
 
-async function journalDispatch(root, request, action) {
+async function journalDispatch(root, request, action, allowReplay = true) {
   const directory = location(root, request.id), fingerprint = hashJson({ operation: request.operation, params: request.params ?? {} });
   await mkdir(directory, { recursive: true, mode: 0o700 });
   // Publish a complete request atomically and exclusively. Writing directly with
@@ -411,6 +425,7 @@ async function journalDispatch(root, request, action) {
     await link(temporary, path.join(directory, "requested.json"));
   } catch (error) {
     if (error.code !== "EEXIST") throw error;
+    if (!allowReplay) throw Object.assign(new Error('Native verification requires a fresh observation'), { code: 'operation_conflict' });
     const saved = await inspectDaemonOperation(root, request.id);
     if (saved.params_sha256 !== fingerprint || (saved.invocation_sha256 ?? null) !== (request.invocation_sha256 ?? null)) throw Object.assign(new Error("operation id was reused with different parameters or invocation"), { code: "operation_conflict", details: { operation_id: request.id } });
     if (saved.state === "completed") return saved.result;

package/dist/harness-runtime/lib/dd-agy-daemon.d.mts

@@ -4,3 +4,4 @@ export declare function qualifyAgyHooks(projectRoot: string, options?: { stateDi
   workspaceHooksSha256: string;
   workspaceHooksInstalled: string;
 }>;
+export declare function callDaemon(stateDir: string, operation: string, params?: Record<string, unknown>, timeoutMs?: number): Promise<Record<string, unknown>>;