@deksden-com/dd-flow-cli 0.9.0-beta.16 → 0.9.0-beta.160

package/dist/harness-runtime/lib/managed-flow-env.mjs

@@ -0,0 +1,15 @@
+/** Final native overlay: launch-bound routing, never inherited invocation authority. */
+export function managedFlowEnv(config, daemonId = config.daemonId) {
+  const managed = !config.noFlow && Boolean(config.ddFlowHome && config.ddFlowBin && daemonId);
+  return {
+    DD_FLOW_DAEMON_ID: managed ? daemonId : undefined,
+    DD_FLOW_HOME: managed ? config.ddFlowHome : undefined,
+    DD_FLOW_BIN: managed ? config.ddFlowBin : undefined,
+    DD_FLOW_RESOURCE_HOME: config.resourceHome ?? undefined,
+    DD_FLOW_RUNTIME_OWNER: managed && config.runtime_owner ? JSON.stringify(config.runtime_owner) : undefined,
+    DD_FLOW_INVOCATION_SCOPE: undefined, DD_FLOW_CURRENT_INVOCATION: undefined,
+    DD_FLOW_SESSION_ID: undefined, DD_FLOW_WORK_ID: undefined, DD_FLOW_CONTROLLER_TOKEN: undefined,
+    DD_FLOW_CONTROL_TOKEN: undefined, DD_FLOW_SCOPE_CONTROL_TOKEN: undefined,
+    DD_FLOW_HOOK_DEADLINE_AT: undefined,
+  };
+}

package/dist/harness-runtime/lib/model-observations.mjs

@@ -0,0 +1,113 @@
+import { createHash } from "node:crypto";
+import { mkdir, open, readFile } from "node:fs/promises";
+import path from "node:path";
+import { withRunnerLock } from "./runner-lock.mjs";
+
+const text = value => typeof value === "string" && value.trim() ? value.trim() : null;
+const fields = ["provider", "model", "reasoning", "mode", "permission_mode"];
+const observationScope = source => JSON.stringify([source?.channel ?? null, source?.scope ?? null, source?.attempt_id ?? null, source?.turn_id ?? null, source?.non_asserting === true]);
+export const observedFields = value => Object.fromEntries(fields.map(key => [key, text(value?.[key])]));
+export const modelObservationFile = journal => path.join(path.dirname(journal), "model-observations.jsonl");
+
+/** Routing is allowed. Permission/autonomy changes remain integrity failures.
+ * Missing native fields are unknown, never proof that the request was applied. */
+export function checkObservedProfile(requested, observed, { strict = false, required = [] } = {}) {
+  const unknown = fields.filter(key => requested?.[key] && !observed?.[key]);
+  const changes = fields.filter(key => requested?.[key] && observed?.[key] && requested[key] !== observed[key]);
+  const violations = changes.filter(key => strict || ["mode", "permission_mode"].includes(key));
+  const missing = required.filter(key => !observed?.[key]);
+  if (violations.length || missing.length) throw Object.assign(new Error("native execution profile integrity is not confirmed"), {
+    code: "profile_integrity_violation", details: { requested: observedFields(requested), observed: observedFields(observed), violations, missing }
+  });
+  return { requested: observedFields(requested), observed: observedFields(observed), status: unknown.length ? "incomplete" : changes.length ? "mixed" : "matched", matched: !unknown.length && !changes.length, unknown, changes };
+}
+
+export async function readModelObservations(journal) {
+  try { const text = await readFile(modelObservationFile(journal), "utf8"); return text.slice(0, text.lastIndexOf("\n") + 1).split("\n").filter(Boolean).map(JSON.parse); }
+  catch (error) { if (error.code === "ENOENT") return []; throw error; }
+}
+
+/** Only adapter-verified native facts enter this file. It records changes,
+ * not every tool or token; reading it never requires replaying native history. */
+export async function observeModel({ journal, harness, sessionId, parentSessionId = null, requested = {}, observed = {}, source, evidence = "configured", reason = null, nativeTimestamp = null, previousModel = null, nativeAgentRole = null }) {
+  if (!journal || !sessionId) return null;
+  if (!source || !["configured", "request", "response", "unavailable"].includes(evidence)) throw new Error("model observation requires a native source and evidence level");
+  if (typeof source === "string") source = { channel: source, ...(["configured", "response"].includes(evidence) ? { scope: evidence } : {}) };
+  const file = modelObservationFile(journal), profile = observedFields(observed);
+  await mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
+  return withRunnerLock(file, async () => {
+    const events = await readModelObservations(journal);
+    const replay = source?.event_sha256 ? events.find(item => item.harness === harness && item.session_id === sessionId && observationScope(item.source) === observationScope(source) && item.source?.event_sha256 === source.event_sha256) : null;
+    const previous = events.findLast(item => item.harness === harness && item.session_id === sessionId && observationScope(item.source) === observationScope(source));
+    const normalizedReason = text(reason)?.slice(0, 200) ?? null;
+    const tuple = item => JSON.stringify([observedFields(item.requested), item.observed, item.parent_session_id ?? null, item.source, item.reason, item.evidence, item.native_agent_role ?? null]);
+    const candidate = { requested: observedFields(requested), observed: profile, parent_session_id: parentSessionId, source, reason: normalizedReason, evidence, native_agent_role: nativeAgentRole };
+    if (replay && tuple(replay) === tuple(candidate)) return replay;
+    const conflict = replay ? { code: 'model_observation_identity_conflict', original_id: replay.id } : null;
+    if (conflict) {
+      const recorded = events.find(item => item.evidence_conflict?.original_id === replay.id && tuple(item) === tuple(candidate));
+      if (recorded) return recorded;
+    }
+    if (!conflict && previous && tuple(previous) === tuple(candidate)) return previous;
+    const previousKnown = events.findLast(item => item.harness === harness && item.session_id === sessionId && item.evidence === evidence && item.observed?.model
+      && (item.source?.scope ?? "session") === (source?.scope ?? "session") && (item.source?.attempt_id ?? null) === (source?.attempt_id ?? null));
+    const fromModel = text(previousModel) ?? previousKnown?.observed.model ?? null;
+    const previousRouting = events.findLast(item => item.harness === harness && item.session_id === sessionId && item.evidence === evidence && item.observed?.provider
+      && (item.source?.scope ?? "session") === (source?.scope ?? "session") && (item.source?.attempt_id ?? null) === (source?.attempt_id ?? null));
+    const changed = Boolean(profile.model && fromModel && (profile.model !== fromModel || profile.provider && previousRouting && profile.provider !== previousRouting.observed.provider));
+    const value = { schema_id: "dd-flow/model-observation@1", sequence: events.length + 1,
+      harness, session_id: sessionId, parent_session_id: parentSessionId,
+      kind: changed ? "model_changed" : !profile.model ? "model_observation_unavailable" : "model_observed",
+      previous_model: fromModel, requested: observedFields(requested), observed: profile,
+      source, evidence, reason: normalizedReason, native_timestamp: text(nativeTimestamp), observed_at: new Date().toISOString(),
+      ...(nativeAgentRole ? { native_agent_role: nativeAgentRole } : {}), ...(conflict ? { evidence_conflict: conflict } : {}) };
+    value.id = createHash("sha256").update(JSON.stringify(value)).digest("hex");
+    const handle = await open(file, "a", 0o600);
+    try {
+      const bytes = await readFile(file); const committed = bytes.lastIndexOf(10) + 1;
+      if (committed < bytes.length) await handle.truncate(committed);
+      await handle.write(`${JSON.stringify(value)}\n`); await handle.sync();
+    } finally { await handle.close(); }
+    const directory = await open(path.dirname(file), "r");
+    try { await directory.sync(); } finally { await directory.close(); }
+    return value;
+  });
+}
+
+export function modelAttribution(events, expectedSessions = []) {
+  const sessions = new Map();
+  for (const event of events) {
+    const key = `${event.harness}:${event.session_id}`;
+    const session = sessions.get(key) ?? { harness: event.harness, session_id: event.session_id, parent_session_id: event.parent_session_id, requested: event.requested, observations: [] };
+    session.parent_session_id ??= event.parent_session_id;
+    if (!session.requested || !Object.values(session.requested).some(Boolean)) session.requested = event.requested;
+    session.observations.push(event); sessions.set(key, session);
+  }
+  const observedIds = new Set([...sessions.values()].map(session => session.session_id));
+  const missingSessions = expectedSessions.filter(session => typeof session === "string" ? !observedIds.has(session)
+    : !sessions.has(`${session.harness}:${session.session_id}`));
+  const models = [...new Set(events.map(event => event.observed?.model).filter(Boolean))];
+  const providers = [...new Set(events.map(event => event.observed?.provider).filter(Boolean))];
+  const conflicts = events.filter(event => event.evidence_conflict).map(event => ({ session_id: event.session_id, ...event.evidence_conflict }));
+  for (const session of sessions.values()) {
+    const parents = [...new Set(session.observations.filter(event => !event.source?.non_asserting && Object.hasOwn(event, 'parent_session_id')).map(event => event.parent_session_id))];
+    if (parents.length > 1) conflicts.push({ session_id: session.session_id, code: 'model_observation_parent_conflict' });
+  }
+  const incomplete = conflicts.length > 0 || !events.length || missingSessions.length > 0 || [...sessions.values()].some(session => {
+    const known = session.observations.filter(event => event.observed?.model);
+    if (!known.length) return true;
+    const knownScopes = new Set(known.map(event => `${event.evidence}:${event.source?.scope ?? "session"}:${event.source?.attempt_id ?? ""}:${event.source?.turn_id ?? ""}`));
+    return session.observations.some(event => {
+      if (event.source?.non_asserting) return false;
+      if (["configured", "response"].includes(event.evidence) && !event.observed?.model) return true;
+      if (event.evidence !== "unavailable") return false;
+      const scope = event.source?.scope;
+      return !scope || !knownScopes.has(`configured:${scope}:${event.source?.attempt_id ?? ""}:${event.source?.turn_id ?? ""}`)
+        && !knownScopes.has(`response:${scope}:${event.source?.attempt_id ?? ""}:${event.source?.turn_id ?? ""}`);
+    });
+  });
+  return { models, providers, mixed: models.length > 1 || providers.length > 1 || events.some(event => event.observed?.model && event.requested?.model && event.observed.model !== event.requested.model
+    || event.observed?.provider && event.requested?.provider && event.observed.provider !== event.requested.provider),
+    observation_completeness: incomplete ? "incomplete" : "available_native_sources", transitions: events.filter(event => event.kind === "model_changed"),
+    sessions: [...sessions.values()], missing_sessions: missingSessions, ...(conflicts.length ? { evidence_conflicts: conflicts } : {}), usage_attribution: "session_totals_unattributed_to_model", note: "Native settings/events do not prove undisclosed server routing or per-model token costs." };
+}

package/dist/harness-runtime/lib/native-children.d.mts

@@ -0,0 +1,34 @@
+export const NATIVE_CHILD_CONTRACT_VERSION: "native-children@2";
+export const NATIVE_TREE_SETTLEMENT_CONTRACT: "native-tree-settlement@2";
+export const NATIVE_SHUTDOWN_CONTRACT: "dd-flow/daemon-shutdown@2";
+export const NATIVE_SHUTDOWN_PHASES: readonly string[];
+export function nativeShutdownConfirmed(receipt: unknown, binding?: { daemonId?: string; generation?: number }): boolean;
+export function nativeExecutionReceipt(receipt: Record<string, unknown>, options?: { daemonId?: string; generation?: number; revision?: number; resources?: Record<string, unknown> }): Record<string, unknown>;
+export type NativeTreeReadiness = "ready" | "owned_children_live" | "inspection_pending" | "unproven";
+export function nativeTreeReadiness(receipt: Record<string, unknown>, binding: { sessionId: string; operationId: string; turnId?: string; requestProof?: unknown; allowDescendants?: boolean }): NativeTreeReadiness;
+export function settledNativeTree(root: string, children: Record<string, unknown>[], settled: boolean, rootSettled?: boolean): Record<string, unknown>;
+export function safeNativeFailure(value: unknown): Record<string, unknown> | undefined;
+export type NativeContinuationReference = { schema_id: "zcode/child-continuation@1"; capability: "dd-flow/managed-provider-recovery@1"; agent_id: string; child_session_id: string; parent_session_id: string; parent_tool_call_id: string; terminal_turn_id: string; started_at: number; ended_at: number; task_id?: string };
+export function nativeContinuationReference(value: unknown, sessionId: string, parentId: string, turnId?: string): NativeContinuationReference | null;
+export type NativeContinuationAdmission = { schema_id: "zcode/child-admission@1"; operation_id?: string; predecessor_turn_id?: string; parent_session_id: string; child_session_id: string; agent_id: string; parent_tool_call_id: string; parent_turn_id: string } & ({ proof_kind?: "message"; message_id: string; delivery: "queued" | "steered" | "resumed_background" } | { proof_kind: "parent_tool_successor"; successor_started_at: number; successor_turn_id: string; native_evidence_sha256: string } | { proof_kind: "parent_tool_admission"; successor_started_at: number; native_evidence_sha256: string });
+export function nativeContinuationAdmission(value: unknown, sessionId: string, parentId: string): NativeContinuationAdmission | null;
+export function nativeContinuationSuccessor(child: NativeChild, predecessorTurnId?: string, predecessorEndedAt?: number): boolean;
+export function nativeContinuationAdmitted(child: NativeChild, predecessorTurnId?: string, predecessorEndedAt?: number): boolean;
+export interface NativeChild {
+  session_id: string;
+  parent_session_id: string;
+  status: "running" | "unknown" | "completed" | "failed" | "cancelled" | "settled_by_root";
+  source: string;
+  provenance?: "root_child" | "parent_mismatch";
+  terminal_turn_id?: string;
+  terminal_observed_at?: string;
+  provider_error?: unknown;
+  recovery_unavailable_reason?: string;
+  continuation_ref?: NativeContinuationReference;
+  continuation_admission?: NativeContinuationAdmission;
+  resumed_from_message_id?: string;
+  current_turn_id?: string;
+  native_source?: "opencode.v2.session.execution" | "agy.result" | "acp.error_response" | "droid.agent_turn_outcome" | "grok.subagent.event" | "zcode.retained-terminal";
+  native_turn_items?: { observed?: boolean; possible_effects?: boolean; pending?: boolean };
+}
+export function normalizeNativeChildren(receipt: Record<string, unknown>, rootSessionId: string): NativeChild[];

package/dist/harness-runtime/lib/native-children.mjs

@@ -0,0 +1,265 @@
+export const NATIVE_CHILD_CONTRACT_VERSION = "native-children@2";
+export const NATIVE_TREE_SETTLEMENT_CONTRACT = "native-tree-settlement@2";
+export const NATIVE_SHUTDOWN_CONTRACT = "dd-flow/daemon-shutdown@2";
+export const NATIVE_SHUTDOWN_PHASES = Object.freeze(["execution", "owned_resources", "provider", "daemon_resource"]);
+import { errorRecord } from "./operation-errors.mjs";
+import { safeProviderError } from "./provider-overload-policy.mjs";
+import { streamRequestKey } from "./provider-overload-policy.mjs";
+const liveStatus = value => ["active", "running", "inprogress", "pending", "streaming", "busy"].includes(String(typeof value === "object" && value ? value.type : value).toLowerCase());
+
+/** One current receipt only. Producers, not status ranks, establish freshness. */
+export function nativeTreeReadiness(receipt, { sessionId, operationId, turnId, requestProof, allowDescendants = true } = {}) {
+  if (receipt?.native_settlement?.contract !== NATIVE_TREE_SETTLEMENT_CONTRACT || receipt.native_settlement.scope !== "required_execution") return "unproven";
+  if (!receipt || typeof sessionId !== "string" || !sessionId || typeof operationId !== "string" || !operationId || receipt.provider_session_id !== sessionId
+    || turnId !== undefined && receipt.terminal_turn_id !== undefined && receipt.terminal_turn_id !== turnId) return "unproven";
+  const requestKey = requestProof?.kind === "stream_request" ? streamRequestKey(requestProof) : null;
+  if (requestProof?.kind === "stream_request" && (!requestKey || requestProof.operation_id !== operationId
+    || streamRequestKey(receipt.terminal_metadata?.request_proof) !== requestKey)) return "unproven";
+  const pending = receipt.native_settlement;
+  if (pending?.state === "inspection_pending") {
+    const clock = pending.observation_clock;
+    return receipt.settled === false && pending.confirmed === false && pending.operation_id === operationId
+      && pending.provider_session_id === sessionId && requestKey && pending.request_key === requestKey
+      && clock?.policy === "operation-progress@1" && Number.isFinite(clock.started_at)
+      && Number.isSafeInteger(clock.timeout_ms) && clock.timeout_ms > 0 && clock.timeout_ms <= 2147483647
+      && Number.isFinite(clock.elapsed_ms) && clock.elapsed_ms >= 0 && clock.elapsed_ms < clock.timeout_ms
+      && Number.isSafeInteger(clock.gaps) && clock.gaps >= 0
+      && typeof clock.uncertain === "boolean"
+      && Number.isFinite(clock.uncertainty_elapsed_ms) && clock.uncertainty_elapsed_ms >= 0
+      && (clock.observed_at === null || Number.isFinite(clock.observed_at))
+      && clock.observation_lost === false ? "inspection_pending" : "unproven";
+  }
+  if (receipt.native_turn_items?.pending === true) return "unproven";
+  const ids = receipt.tree_session_ids, observations = receipt.tree_observations, unsettled = receipt.unsettled_sessions;
+  if (!Array.isArray(ids) || !ids.length || ids[0] !== sessionId || ids.some(id => typeof id !== "string" || !id)
+    || new Set(ids).size !== ids.length || !allowDescendants && ids.length !== 1
+    || !Array.isArray(observations) || observations.length !== ids.length
+    || !ids.every(id => observations.filter(item => item?.provider_session_id === id).length === 1)
+    || observations.some(item => !item || typeof item !== "object" || Array.isArray(item) || typeof item.settled !== "boolean" || item.settled === true && liveStatus(item.status)) || !Array.isArray(unsettled)
+    || new Set(unsettled).size !== unsettled.length) return "unproven";
+  // A producer's tree list cannot silently omit another positively observed
+  // owned child. Normalize the same receipt, not a second historical ledger.
+  try {
+    const children = normalizeNativeChildren(receipt, sessionId);
+    if (children.some(child => !ids.includes(child.session_id) || !ids.includes(child.parent_session_id) || child.parent_session_id === child.session_id)) return "unproven";
+    for (const child of children) {
+      let parent = child.parent_session_id;
+      const visited = new Set([child.session_id]);
+      while (parent !== sessionId) {
+        if (visited.has(parent)) return "unproven";
+        visited.add(parent); parent = children.find(item => item.session_id === parent)?.parent_session_id;
+        if (!parent) return "unproven";
+      }
+    }
+  } catch { return "unproven"; }
+  const live = observations.filter(item => !item.settled);
+  if (unsettled.length !== live.length || !live.every(item => unsettled.includes(item.provider_session_id))) return "unproven";
+  const settlement = receipt.settlement;
+  const budgetSettled = !settlement || settlement.state === "not_required"
+    || settlement.state === "settled" && settlement.operation_ids?.includes(operationId) === true;
+  if (receipt.settled === true && receipt.native_settled !== false && pending?.confirmed !== false && !live.length && budgetSettled) return "ready";
+  const root = observations.find(item => item.provider_session_id === sessionId);
+  const knownLive = live.length > 0 && live.every(item => item.provider_session_id !== sessionId && liveStatus(item.status));
+  return allowDescendants && receipt.settled === false && root.settled === true && knownLive
+    && (!settlement || settlement.state === "not_required" || settlement.state === "pending" && settlement.reason === "tree_unsettled")
+    ? "owned_children_live" : "unproven";
+}
+
+function nativeFailure(code, message, exitCode, details) { return Object.assign(new Error(message), { code, exitCode, details }); }
+
+/** Control settlement is not native settlement; explicit uncertainty wins. */
+export function nativeShutdownConfirmed(receipt, { daemonId, generation } = {}) {
+  const proof = receipt?.schema_id === NATIVE_SHUTDOWN_CONTRACT ? receipt : receipt?.shutdown_proof;
+  const result = receipt?.schema_id === NATIVE_SHUTDOWN_CONTRACT ? receipt.result : receipt;
+  return Boolean(proof?.schema_id === NATIVE_SHUTDOWN_CONTRACT && typeof proof.daemon_id === "string" && proof.daemon_id
+    && (daemonId === undefined || proof.daemon_id === daemonId) && Number.isSafeInteger(proof.generation) && proof.generation >= 0
+    && (generation === undefined || proof.generation === generation)
+    && Array.isArray(proof.required_phases) && new Set(proof.required_phases).size === proof.required_phases.length
+    && NATIVE_SHUTDOWN_PHASES.every(phase => proof.required_phases.includes(phase))
+    && proof.required_phases.every(phase => typeof phase === "string" && proof.phases?.[phase] === true)
+    && result?.daemon_id === proof.daemon_id && result.shutdown_contract === NATIVE_SHUTDOWN_CONTRACT
+    && result.clean === true && result.stopped === true && result.physical_stopped === true
+    && result.native_settled === true && result.settled === true && result.native_settlement?.confirmed !== false
+    && result.resource_retirement?.confirmed !== false);
+}
+
+/** Scope metadata does not manufacture readiness or physical cleanup. */
+export function nativeExecutionReceipt(receipt, { daemonId, generation = 0, revision = 0, resources } = {}) {
+  if (receipt.native_settlement?.contract !== undefined && receipt.native_settlement.contract !== NATIVE_TREE_SETTLEMENT_CONTRACT
+    || receipt.native_settlement?.scope !== undefined && receipt.native_settlement.scope !== "required_execution")
+    throw Object.assign(new Error("historical native proof requires fresh execution observation"), { code: "native_contract_mismatch" });
+  if ((resources?.entries ?? []).some(item => item.owner_daemon_id !== undefined && item.owner_daemon_id !== daemonId
+    || item.generation !== undefined && item.generation !== generation)) throw Object.assign(new Error("native resource belongs to another owner"), { code: "native_resource_owner_mismatch" });
+  const owner = { owner_daemon_id: daemonId ?? null, generation, revision };
+  return { ...receipt,
+    native_settlement: { ...receipt.native_settlement, contract: NATIVE_TREE_SETTLEMENT_CONTRACT, scope: "required_execution", ...owner },
+    native_resources: { observed_at: new Date().toISOString(), coverage: "unsupported", ...resources,
+      schema_id: "native-resources@1", ...owner,
+      entries: (resources?.entries ?? []).map(item => ({ ...item, owner_daemon_id: owner.owner_daemon_id, generation: owner.generation })) }
+  };
+}
+
+/** Project a positively settled native tree, never infer it from missing activity. */
+export function settledNativeTree(root, children, settled, rootSettled = false) {
+  if (settled !== true && rootSettled !== true || typeof root !== "string" || !root || !Array.isArray(children)) return {};
+  const ids = children.map(child => child.provider_session_id ?? child.session_id ?? child.childSessionId ?? child.sessionId);
+  if (ids.some(id => typeof id !== "string" || !id || id === root) || new Set(ids).size !== ids.length) return {};
+  const observations = [{ provider_session_id: root, status: "idle", settled: true }, ...children.map((child, index) => {
+    const status = String(child.status ?? child.state ?? "unknown").toLowerCase();
+    const terminal = settled === true || ["completed", "success", "succeeded", "failed", "cancelled", "canceled", "settled_by_root"].includes(status);
+    return { provider_session_id: ids[index], status: terminal ? "idle" : liveStatus(status) ? "running" : "unknown", settled: terminal };
+  })];
+  return { native_settlement: { contract: NATIVE_TREE_SETTLEMENT_CONTRACT, scope: "required_execution" }, tree_session_ids: [root, ...ids], unsettled_sessions: observations.filter(item => !item.settled).map(item => item.provider_session_id), tree_observations: observations };
+}
+
+/** Retain typed failure facts, never provider headers, request bodies or free-form messages. */
+export function safeNativeFailure(value, depth = 0) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+  const result = {};
+  for (const key of ["type", "code", "source", "reason", "errorPhase", "exceptionKind", "providerId", "modelId", "providerKind", "transport", "retryable", "willRetry", "statusCode", "resets_at", "retryAfterMs", "resetAt"]) {
+    const scalar = value[key];
+    if (typeof scalar === "boolean" || typeof scalar === "number" && Number.isFinite(scalar)
+      || typeof scalar === "string" && scalar.length <= 256 && /^[\w.:/ -]+$/.test(scalar)) result[key] = scalar;
+  }
+  // Timing metadata is not an identifier: HTTP dates contain commas and an
+  // invalid value must reach the policy as invalid, not disappear into default backoff.
+  const timing = safeProviderError(value);
+  if (Object.hasOwn(timing, "retryAfter")) result.retryAfter = timing.retryAfter;
+  if (Object.hasOwn(timing, "retry_after")) result.retry_after = timing.retry_after;
+  if (Object.hasOwn(timing, "retryAfterMs")) result.retryAfterMs = timing.retryAfterMs;
+  if (timing.headers) result.headers = timing.headers;
+  if (typeof value.codexErrorInfo === "string" && /^[\w-]{1,128}$/.test(value.codexErrorInfo)) result.codexErrorInfo = value.codexErrorInfo;
+  else if (value.codexErrorInfo && typeof value.codexErrorInfo.code === "string" && /^[\w-]{1,128}$/.test(value.codexErrorInfo.code)) result.codexErrorInfo = { code: value.codexErrorInfo.code };
+  const attribution = depth === 0 && value.attribution && safeNativeFailure(value.attribution, 1);
+  if (attribution && Object.keys(attribution).length) result.attribution = attribution;
+  return Object.keys(result).length ? result : undefined;
+}
+
+
+/** Normalize provider-observed topology only; never parse assistant prose. */
+export function nativeContinuationReference(value, sessionId, parentId, turnId) {
+  if (value?.schema_id !== "zcode/child-continuation@1" || value.capability !== "dd-flow/managed-provider-recovery@1"
+    || value.child_session_id !== sessionId || value.parent_session_id !== parentId || value.terminal_turn_id !== turnId
+    || !/^agent_[\w-]{1,200}$/.test(value.agent_id ?? "") || ![value.parent_tool_call_id, value.terminal_turn_id].every(item => typeof item === "string" && item.length > 0 && item.length <= 256)
+    || !Number.isSafeInteger(value.started_at) || !Number.isSafeInteger(value.ended_at) || value.started_at <= 0 || value.ended_at < value.started_at) return null;
+  return { schema_id: value.schema_id, capability: value.capability, agent_id: value.agent_id, child_session_id: sessionId, parent_session_id: parentId,
+    parent_tool_call_id: value.parent_tool_call_id, terminal_turn_id: turnId, started_at: value.started_at, ended_at: value.ended_at,
+    ...(typeof value.task_id === "string" && value.task_id.length <= 256 ? { task_id: value.task_id } : {}) };
+}
+export function nativeContinuationAdmission(value, sessionId, parentId) {
+  const keys = ["parent_tool_call_id", "parent_turn_id", "agent_id"];
+  if (value?.schema_id !== "zcode/child-admission@1" || value.child_session_id !== sessionId || value.parent_session_id !== parentId
+    || !keys.every(key => typeof value[key] === "string" && value[key].length > 0 && value[key].length <= 512)) return null;
+  const successorProof = value.proof_kind === "parent_tool_successor";
+  const parentAdmission = successorProof || value.proof_kind === "parent_tool_admission";
+  if (parentAdmission ? !Number.isSafeInteger(value.successor_started_at) || value.successor_started_at <= 0 || successorProof && (typeof value.successor_turn_id !== "string" || !value.successor_turn_id || value.successor_turn_id.length > 512) || !/^[a-f0-9]{64}$/.test(value.native_evidence_sha256 ?? "")
+    : value.proof_kind !== undefined && value.proof_kind !== "message" || typeof value.message_id !== "string" || !value.message_id || value.message_id.length > 512 || !["queued", "steered", "resumed_background"].includes(value.delivery)) return null;
+  return Object.fromEntries(["schema_id", "child_session_id", "parent_session_id", ...keys,
+    ...(parentAdmission ? ["proof_kind", "successor_started_at", "native_evidence_sha256", ...(successorProof ? ["successor_turn_id"] : [])] : ["message_id", "delivery"]),
+    ...["operation_id", "predecessor_turn_id"].filter(key => typeof value[key] === "string" && value[key].length > 0 && value[key].length <= 512)].map(key => [key, value[key]]));
+}
+export function nativeContinuationSuccessor(child, predecessorTurnId, predecessorEndedAt) {
+  const admission = child?.continuation_admission, turn = child?.current_turn_id ?? child?.terminal_turn_id;
+  if (!admission?.operation_id || admission.predecessor_turn_id !== predecessorTurnId || typeof turn !== "string" || turn === predecessorTurnId) return false;
+  if (admission.proof_kind === "parent_tool_admission") return false;
+  return admission.proof_kind === "parent_tool_successor"
+    ? Number.isSafeInteger(predecessorEndedAt) && admission.successor_started_at > predecessorEndedAt && admission.successor_turn_id === turn
+    : child.resumed_from_message_id === admission.message_id;
+}
+export function nativeContinuationAdmitted(child, predecessorTurnId, predecessorEndedAt) {
+  const admission = child?.continuation_admission;
+  return Boolean(admission?.proof_kind === "parent_tool_admission" && (child.status === "running" || child.status === "failed" && child.terminal_turn_id === predecessorTurnId) && admission.operation_id
+    && admission.predecessor_turn_id === predecessorTurnId && Number.isSafeInteger(predecessorEndedAt) && admission.successor_started_at > predecessorEndedAt);
+}
+export function normalizeNativeChildren(receipt, rootSessionId) {
+  const candidates = [];
+  const object = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+  receipt = object(receipt);
+  const list = (value) => Array.isArray(value) ? value : [];
+  const text = (value, keys) => { for (const key of keys) if (typeof value[key] === "string" && value[key]) return value[key]; return null; };
+  const settledTree = new Set(
+    list(receipt.tree_observations)
+      .filter(value => object(value).settled === true)
+      .map(value => text(object(value), ["provider_session_id", "session_id"]))
+      .filter(id => id !== null)
+  );
+  const unsettledTree = new Set(list(receipt.tree_observations).filter(value => object(value).settled === false)
+    .map(value => text(object(value), ["provider_session_id", "session_id"])).filter(Boolean));
+  const add = (raw, source, scopedParent = null, fallback = "unknown") => {
+    const value = object(raw);
+    const id = text(value, ["provider_session_id", "session_id", "sessionId", "childSessionId", "conversation_id", "conversationId", "id", "subagentId"]);
+    const parent = text(value, ["parent_provider_session_id", "parent_session_id", "parentSessionId", "parentID", "parentId"]) ?? scopedParent;
+    if (!id) return;
+    const outcomeError = object(value.outcome_error);
+    if (typeof outcomeError.code === "string") {
+      const record = errorRecord(outcomeError);
+      throw Object.assign(nativeFailure(record.code, record.message, 1, record.details), record, { details: { ...object(record.details), session_id: id, source } });
+    }
+    const state = String(value.status ?? value.state ?? fallback).toLowerCase();
+    if (state === "lost") throw nativeFailure("native_child_outcome_lost", "Native child ended without a recoverable outcome", 1, { session_id: id, parent_session_id: parent, source, native_status: state });
+    // Provider idle means no current activity, not a Work result. Only an
+    // explicit terminal result or a separately proven root settlement may be
+    // terminal here; unknown states stay unknown for reconciliation.
+    const status = ["completed", "complete", "done", "success", "succeeded"].includes(state) ? "completed" : state === "settled_by_root" ? "settled_by_root" : ["failed", "error"].includes(state) ? "failed" : ["cancelled", "canceled", "interrupted"].includes(state) ? "cancelled" : liveStatus(state) ? "running" : fallback;
+    const rootChild = parent === rootSessionId;
+    const settled = rootChild && status === "unknown" && settledTree.has(id) ? "settled_by_root" : status;
+    if ((unsettledTree.has(id) || value.native_turn_items?.pending === true) && ["completed", "failed", "cancelled", "settled_by_root"].includes(settled)
+      || settledTree.has(id) && (unsettledTree.has(id) || status === "running" || value.native_turn_items?.pending === true))
+      throw nativeFailure("native_child_observation_conflict", "Current child outcome contradicts tree observation", 1, { session_id: id, source });
+    candidates.push({ session_id: id, parent_session_id: parent ?? "", status: settled, source, ...(rootChild ? {} : { provenance: "parent_mismatch" }),
+      ...(text(value, ["terminal_turn_id"]) ? { terminal_turn_id: text(value, ["terminal_turn_id"]) } : {}),
+      ...(text(value, ["terminal_observed_at"]) ? { terminal_observed_at: text(value, ["terminal_observed_at"]) } : {}),
+      ...(value.provider_error !== undefined ? { provider_error: value.provider_error } : {}),
+      ...(typeof value.recovery_unavailable_reason === "string" && /^[a-z][a-z0-9_]{0,127}$/.test(value.recovery_unavailable_reason) ? { recovery_unavailable_reason: value.recovery_unavailable_reason } : {}),
+      ...(nativeContinuationReference(value.continuation_ref, id, parent, value.terminal_turn_id) ? { continuation_ref: nativeContinuationReference(value.continuation_ref, id, parent, value.terminal_turn_id) } : {}),
+      ...(nativeContinuationAdmission(value.continuation_admission, id, parent) ? { continuation_admission: nativeContinuationAdmission(value.continuation_admission, id, parent) } : {}),
+      ...(text(value, ["resumed_from_message_id"]) ? { resumed_from_message_id: text(value, ["resumed_from_message_id"]) } : {}),
+      ...(text(value, ["current_turn_id"]) ? { current_turn_id: text(value, ["current_turn_id"]) } : {}),
+      ...(["opencode.v2.session.execution", "agy.result", "acp.error_response", "droid.agent_turn_outcome", "grok.subagent.event", "zcode.retained-terminal"].includes(value.native_source) ? { native_source: value.native_source } : {}),
+      ...(value.native_turn_items && typeof value.native_turn_items === "object" ? { native_turn_items: value.native_turn_items } : {}) });
+  };
+  for (const value of list(receipt.descendants)) add(value, "adapter.descendants");
+  for (const value of list(receipt.children)) add(value, "opencode.session.children");
+  const subagents = object(object(receipt.evidence).subagents ?? receipt.subagents);
+  for (const value of list(subagents.running)) add(value, "zcode/session/subagents", rootSessionId, "running");
+  for (const value of list(subagents.completed)) add(value, "zcode/session/subagents", rootSessionId, "completed");
+  for (const value of list(object(subagents.ended).items)) {
+    const status = String(object(value).status ?? "unknown");
+    if (!["success", "failed", "cancelled", "lost"].includes(status)) throw nativeFailure("native_child_outcome_unavailable", "ZCode ended child has no recognized native outcome", 1, { child: value });
+    add(value, "zcode/session/subagents", rootSessionId);
+  }
+  const unique = new Map();
+  const terminal = value => ["completed", "failed", "cancelled", "settled_by_root"].includes(value);
+  for (const child of candidates) {
+    const previous = unique.get(child.session_id);
+    const successor = (current, old) => current.parent_session_id === old.parent_session_id
+      && (nativeContinuationSuccessor(current, old.terminal_turn_id, old.continuation_ref?.ended_at) || nativeContinuationAdmitted(current, old.terminal_turn_id, old.continuation_ref?.ended_at));
+    if (previous && successor(child, previous)) { unique.set(child.session_id, child); continue; }
+    if (previous && successor(previous, child)) continue;
+    if (previous && (terminal(previous.status) && child.native_turn_items?.pending === true
+      || terminal(child.status) && previous.native_turn_items?.pending === true))
+      throw nativeFailure("native_child_observation_conflict", "Current child outcome contradicts pending native items", 1, { session_id: child.session_id, observations: [previous, child] });
+    if (previous && previous.parent_session_id !== child.parent_session_id) {
+      // Keep the contradictory parent visible to the existing provenance gate,
+      // independently of input order or which source happened to say success.
+      const foreign = [previous, child].filter(item => item.parent_session_id !== rootSessionId).sort((a, b) => a.parent_session_id.localeCompare(b.parent_session_id))[0];
+      unique.set(child.session_id, { ...foreign, provenance: "parent_mismatch" });
+      continue;
+    }
+    if (previous && terminal(previous.status) && terminal(child.status) && previous.status !== child.status && ![previous.status, child.status].includes("settled_by_root")) throw nativeFailure("native_child_outcome_conflict", "Native child has contradictory terminal outcomes", 1, { session_id: child.session_id, observations: [previous, child] });
+    if (previous && (previous.status === "running" && terminal(child.status) || child.status === "running" && terminal(previous.status)))
+      throw nativeFailure("native_child_observation_conflict", "Current child has both active and terminal facts", 1, { session_id: child.session_id, observations: [previous, child] });
+    if (previous && previous.status === child.status && previous.terminal_turn_id && child.terminal_turn_id && previous.terminal_turn_id !== child.terminal_turn_id)
+      throw nativeFailure("native_child_turn_conflict", "Native child has contradictory terminal Turn identities", 1, { session_id: child.session_id, observations: [previous, child] });
+    if (previous && previous.status === child.status) {
+      unique.set(child.session_id, { ...previous, ...child,
+        ...(child.terminal_turn_id ?? previous.terminal_turn_id ? { terminal_turn_id: child.terminal_turn_id ?? previous.terminal_turn_id } : {}),
+        ...(child.provider_error ?? previous.provider_error ? { provider_error: child.provider_error ?? previous.provider_error } : {}),
+        ...(child.native_turn_items ?? previous.native_turn_items ? { native_turn_items: { ...previous.native_turn_items, ...child.native_turn_items,
+          ...([previous.native_turn_items, child.native_turn_items].some(items => items?.pending === true) ? { pending: true } : {}) } } : {}) });
+      continue;
+    }
+    if (!previous || previous.status === "unknown" || previous.status === "settled_by_root" && terminal(child.status)) unique.set(child.session_id, child);
+  }
+  return [...unique.values()].sort((left, right) => left.session_id.localeCompare(right.session_id));
+}

package/dist/harness-runtime/lib/native-hook-command.d.mts

@@ -0,0 +1,8 @@
+export function invokeNativeHook(input: { bin: string; args: string[]; nodeBin?: string; payload: unknown; home?: string | undefined; cwd?: string; env?: NodeJS.ProcessEnv; timeoutMs?: number }): Promise<Record<string, unknown> & { timing?: Record<string, number> }>;
+export function isStandaloneWorkStart(command: unknown): boolean;
+export function hookBudget(timeoutMs?: number, deadlineAt?: number | null): { deadlineAt: number; remaining(phase: string, maximum?: number): number; run<T>(action: () => T | Promise<T>, phase: string): Promise<T> };
+export function readNativeHookInput(stream: NodeJS.ReadStream, budget: { remaining(phase: string): number }, maxBytes?: number): Promise<string>;
+export function acceptNativeHookRequest(stateDir: string, binding: Record<string, unknown>, current?: { requests: Map<string, { binding: Record<string, unknown> }>; accepting?: Map<string, Promise<Record<string, unknown>>> } | null): Promise<Record<string, unknown>>;
+export function writeNativeHookFailure(stateDir: string, binding: Record<string, unknown> | undefined, error: unknown): Promise<void>;
+export function readNativeHookFailures(stateDir: string, requests: Map<string, { current: unknown; binding: Record<string, unknown> }>, current: unknown, reject: (error: Error & { code?: string; details?: Record<string, unknown> }) => void | Promise<void>): Promise<void>;
+export function runBoundedCommand(input: { bin: string; args: string[]; nodeBin?: string; input?: string | null; cwd?: string; env?: NodeJS.ProcessEnv; timeoutMs?: number; timeoutCode?: string; inheritDeadline?: boolean; cleanupWithinBudget?: boolean; maintenanceProgress?: { action: string; processId: string | null; startupMs?: number; inactivityMs: number } | null; signal?: AbortSignal }): Promise<string>;