harnery 0.45.1 → 0.46.0

package/src/core/agents/state/parent-reference.ts

@@ -0,0 +1,179 @@
+import type {
+  CoordinationGenerationViewV3,
+  CoordinationViewV3,
+} from "../../events/v3/coordination-view.ts";
+import { readCoordinationViewV3 } from "../../events/v3/coordination-view.ts";
+import { liveInstanceIdV3, nativeInstanceIdV3 } from "../../events/v3/live-route-observer.ts";
+import {
+  type NativeParentObservation,
+  type NativeParentRequest,
+  readNativeParentReference,
+} from "../../hooks/adapter/native-parent.ts";
+import { resolveName } from "./names.ts";
+import type { AgentParentReference } from "./parent-reference-contract.ts";
+
+export type { AgentParentReference } from "./parent-reference-contract.ts";
+
+export interface AgentParentSubject {
+  instance_id: string;
+  generation_id?: string;
+  v3_generation_id?: string;
+  platform?: string;
+  native_session_id?: string;
+}
+
+export interface AgentParentReferenceOptions {
+  view?: CoordinationViewV3;
+  readNativeParent?: (request: NativeParentRequest) => NativeParentObservation;
+}
+
+/** Display/recipient evidence only. Never use native evidence as a claim or lifecycle waiver. */
+export function resolveAgentParentReference(
+  coordRoot: string,
+  child: AgentParentSubject,
+  options: AgentParentReferenceOptions = {},
+): AgentParentReference {
+  try {
+    const view = options.view ?? readCoordinationViewV3(coordRoot);
+    if (!view.source_complete || !view.authority_safe) return unknown("parent_authority_unsafe");
+    if (
+      child.generation_id &&
+      child.v3_generation_id &&
+      child.generation_id !== child.v3_generation_id
+    ) {
+      return unknown("child_generation_mismatch");
+    }
+    const instance = liveInstanceIdV3(child.instance_id);
+    const generationId = child.generation_id ?? child.v3_generation_id;
+    const generations = [
+      ...Object.values(view.instances),
+      ...Object.values(view.terminal_generations),
+    ];
+    const generation = generationId
+      ? generations.find(
+          (row) => row.generation_id === generationId && row.instance_id === instance,
+        )
+      : view.instances[instance];
+    if (!generation) return unknown("child_generation_unavailable");
+    if (!safe(view, generation)) return unknown("child_authority_unsafe");
+    const canonical = generation.parent_generation_id
+      ? generations.find((row) => row.generation_id === generation.parent_generation_id)
+      : undefined;
+    if (generation.parent_generation_id && !canonical)
+      return unknown("parent_generation_unavailable");
+    if (canonical && cyclic(generations, generation)) {
+      return { state: "conflict", reason: "parent_lineage_cycle" };
+    }
+    const adapter = generation.runtime_attestation.adapter;
+    const platform = adapter.state === "observed" ? adapter.value.id : child.platform;
+    const nativeId = child.native_session_id ?? nativeInstanceIdV3(instance);
+    const native =
+      platform === "codex" && liveInstanceIdV3(nativeId) === instance
+        ? (options.readNativeParent ?? readNativeParentReference)({
+            adapter: platform,
+            native_session_id: nativeId,
+          })
+        : ({ state: "unknown", reason: "native_child_identity_unavailable" } as const);
+    if (canonical) {
+      if (
+        native.state === "none" ||
+        (native.state === "observed" &&
+          liveInstanceIdV3(native.parent_session_id) !== canonical.instance_id)
+      ) {
+        return { state: "conflict", reason: "parent_sources_disagree" };
+      }
+      return reference(coordRoot, view, canonical.instance_id, canonical, "v3-session-link");
+    }
+    if (native.state === "observed") {
+      const parentInstance = liveInstanceIdV3(native.parent_session_id);
+      if (parentInstance === instance)
+        return { state: "conflict", reason: "parent_self_reference" };
+      const parent = recipientGeneration(view, parentInstance);
+      if (parent && cyclic(generations, generation, parent)) {
+        return { state: "conflict", reason: "parent_lineage_cycle" };
+      }
+      return reference(
+        coordRoot,
+        view,
+        parentInstance,
+        parent,
+        "native-session-metadata",
+        native.source_witness,
+      );
+    }
+    return { state: native.state, reason: native.reason };
+  } catch {
+    return unknown("parent_reference_unavailable");
+  }
+}
+
+function reference(
+  root: string,
+  view: CoordinationViewV3,
+  instance: string,
+  parent: CoordinationGenerationViewV3 | undefined,
+  source: "v3-session-link" | "native-session-metadata",
+  witness?: string,
+): AgentParentReference {
+  const native = nativeInstanceIdV3(instance);
+  const name = resolveName(root, native)?.name ?? null;
+  const recipient = recipientGeneration(view, instance);
+  return {
+    state: "verified",
+    relationship: source === "v3-session-link" ? "delegated-child" : "native-child",
+    parent_instance_id: native,
+    parent_v3_instance_id: instance,
+    parent_generation_id: parent?.generation_id ?? null,
+    parent_session_id: parent?.session_id ?? null,
+    parent_name: name,
+    source,
+    ...(witness ? { source_witness: witness } : {}),
+    addressable: Boolean(
+      parent && recipient?.generation_id === parent.generation_id && safe(view, parent) && name,
+    ),
+  };
+}
+
+function recipientGeneration(view: CoordinationViewV3, instance: string) {
+  return (
+    view.instances[instance] ??
+    Object.values(view.terminal_generations)
+      .filter((row) => row.instance_id === instance)
+      .sort(
+        (a, b) =>
+          b.source_position.segment_ordinal - a.source_position.segment_ordinal ||
+          b.source_position.byte_offset - a.source_position.byte_offset,
+      )[0]
+  );
+}
+
+function safe(view: CoordinationViewV3, generation: CoordinationGenerationViewV3): boolean {
+  return !(view.diagnostics_by_generation[generation.generation_id] ?? []).some(
+    (d) => d.authority_blocking,
+  );
+}
+
+function cyclic(
+  generations: CoordinationGenerationViewV3[],
+  child: CoordinationGenerationViewV3,
+  first?: CoordinationGenerationViewV3,
+): boolean {
+  const seen = new Set([child.generation_id]);
+  let cursor = first ?? child;
+  for (let depth = 0; depth <= generations.length; depth++) {
+    if (cursor !== child) {
+      if (seen.has(cursor.generation_id) || cursor.instance_id === child.instance_id) return true;
+      seen.add(cursor.generation_id);
+    }
+    if (!cursor.parent_generation_id) return false;
+    const next = generations.find((g) => g.generation_id === cursor.parent_generation_id);
+    if (!next) return false;
+    if (seen.has(next.generation_id)) return true;
+    cursor = next;
+  }
+  return true;
+}
+
+function unknown(reason: string): AgentParentReference {
+  return { state: "unknown", reason };
+}

package/src/core/agents/state/pidmap.ts

@@ -24,7 +24,7 @@ import {
   writeFileSync,
 } from "node:fs";
 import { dirname, join } from "node:path";
-import { checkPidToken, processStartToken } from "./proc-start.ts";
+import { processStartToken, verifyProcessGeneration } from "./proc-start.ts";
 
 /**
  * Row count that triggers a dead-row sweep on the next write.
@@ -59,7 +59,7 @@ export function parsePidmapRow(row: string): {
  */
 function rowStillNamesItsProcess(pid: number, startToken: string | undefined): boolean {
   if (!pidIsAlive(pid)) return false;
-  return checkPidToken(pid, startToken) !== "mismatch";
+  return verifyProcessGeneration(pid, startToken) !== "different";
 }
 
 function atomicWrite(path: string, content: string): void {

package/src/core/agents/state/proc-start.ts

@@ -34,10 +34,9 @@
 import { spawnSync } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
 import { coordEnv } from "../../../lib/env.ts";
-import { signalProcessWithHandle, windowsProcessStartToken } from "./process-handle.ts";
 
 /** Which probe answers "when did this process start?" on this machine. */
-export type StartTokenProbe = "procfs" | "ps" | "windows";
+export type StartTokenProbe = "procfs" | "ps";
 
 /**
  * The `ps` probe is text formatted by `strftime("%c", localtime(...))`, so its
@@ -61,7 +60,6 @@ let cachedBootId: string | null | undefined;
 export function startTokenProbe(): StartTokenProbe {
   const override = coordEnv("PID_PROBE");
   if (override === "procfs" || override === "ps") return override;
-  if (process.platform === "win32") return "windows";
   if (cachedProbe === undefined) {
     cachedProbe = existsSync("/proc/self/stat") ? "procfs" : "ps";
   }
@@ -104,7 +102,7 @@ export function resetStartTokenCaches(): void {
  * than by splitting the whole line, because comm is the executable name in
  * parentheses and may itself contain spaces and parens. The boot segment is
  * dropped rather than faked when the kernel will not name its boot, which
- * yields the pre-boot-id shape that `tokensAgree` still accepts.
+ * yields the pre-boot-id shape that `verifyProcessGeneration` compares by ticks.
  */
 export function procfsStartToken(pid: number): string | null {
   let stat: string;
@@ -159,19 +157,26 @@ function defaultPsRun(pid: number): { status: number | null; stdout: string } {
  */
 export function processStartToken(pid: number): string | null {
   if (!Number.isFinite(pid) || pid <= 0) return null;
-  const probe = startTokenProbe();
-  return probe === "windows"
-    ? windowsProcessStartToken(pid)
-    : probe === "procfs"
-      ? procfsStartToken(pid)
-      : psStartToken(pid);
+  return startTokenProbe() === "procfs" ? procfsStartToken(pid) : psStartToken(pid);
 }
 
 export type ProcessGenerationVerdict = "same" | "different" | "unknown";
 
 type ReadProcessStartToken = (pid: number) => string | null;
 
-/** A missing or unreadable token never establishes process identity. */
+/**
+ * Does `pid` still name the run that wrote `recordedToken`?
+ *
+ * - `"same"`: both tokens present and equal.
+ * - `"different"`: the pid was recycled. A liveness check cannot see this,
+ *   because a recycled pid is alive.
+ * - `"unknown"`: a token is missing, malformed, or unreadable. Never treat
+ *   this as proof of identity.
+ *
+ * A Linux token written without a boot segment cannot identify a run across
+ * reboots, so it is compared on its tick count: a different count proves a
+ * different run, and an equal count stays unknown.
+ */
 export function verifyProcessGeneration(
   pid: number,
   recordedToken: string | null | undefined,
@@ -184,26 +189,38 @@ export function verifyProcessGeneration(
     !recordedToken.trim()
   )
     return "unknown";
-  // A bootless Linux token cannot identify a process across machine boots.
-  if (/^l\d+$/.test(recordedToken)) return "unknown";
+  let currentToken: string | null;
   try {
-    const currentToken = readToken(pid);
-    if (typeof currentToken !== "string" || !currentToken.trim()) return "unknown";
-    if (/^l\d+$/.test(currentToken)) return "unknown";
-    return currentToken === recordedToken ? "same" : "different";
+    currentToken = readToken(pid);
   } catch {
     return "unknown";
   }
+  if (typeof currentToken !== "string" || !currentToken.trim()) return "unknown";
+  const bootless = (token: string) => /^l\d+$/.test(token);
+  if (
+    recordedToken[0] === "l" &&
+    currentToken[0] === "l" &&
+    (bootless(recordedToken) || bootless(currentToken))
+  )
+    return ticksOf(recordedToken) === ticksOf(currentToken) ? "unknown" : "different";
+  return currentToken === recordedToken ? "same" : "different";
+}
+
+function ticksOf(token: string): string {
+  const dot = token.indexOf(".");
+  return dot === -1 ? token.slice(1) : token.slice(dot + 1);
 }
 
 export interface ProcessGenerationSignalDependencies {
   readToken?: ReadProcessStartToken;
-  signalProcess?: typeof signalProcessWithHandle;
+  kill?: (pid: number, signal: NodeJS.Signals | number) => unknown;
 }
 
 /**
- * Observations may refuse a signal, but only the retained native process handle
- * can authorize it. No numeric-PID effect follows the preliminary token read.
+ * Recheck the process generation immediately before sending the signal.
+ *
+ * The process can still exit and its PID can be reused between the token read
+ * and the signal. Eliminating that race requires a generation-bound OS handle.
  */
 export function signalIfSameGeneration(
   pid: number,
@@ -211,58 +228,13 @@ export function signalIfSameGeneration(
   signal: NodeJS.Signals | number,
   dependencies: ProcessGenerationSignalDependencies = {},
 ): { sent: boolean; verdict: ProcessGenerationVerdict } {
+  const kill = dependencies.kill ?? process.kill;
   const verdict = verifyProcessGeneration(pid, recordedToken, dependencies.readToken);
   if (verdict !== "same") return { sent: false, verdict };
   try {
-    return (dependencies.signalProcess ?? signalProcessWithHandle)(pid, recordedToken!, signal);
+    kill(pid, signal);
+    return { sent: true, verdict };
   } catch {
-    return { sent: false, verdict: "unknown" };
+    return { sent: false, verdict };
   }
 }
-
-/**
- * Do two tokens describe the same run?
- *
- * Equality, plus one concession: a row written before tokens carried a boot
- * segment recorded the tick count alone, so it is compared on the part it
- * actually recorded. Refusing that would call every pre-upgrade row a recycled
- * pid and prune a working machine's live rows the first time the new code ran.
- * Such a row loses its reboot protection until the next write rewrites it,
- * which is a strictly better position than the one it came from.
- */
-export function tokensAgree(recorded: string, current: string): boolean {
-  if (recorded === current) return true;
-  // Only the Linux form has a boot segment to disagree about, and only when
-  // exactly one side carries one is this a shape difference rather than two
-  // genuinely different start instants.
-  if (recorded[0] !== "l" || current[0] !== "l") return false;
-  if (recorded.includes(".") === current.includes(".")) return false;
-  return ticksOf(recorded) === ticksOf(current);
-}
-
-function ticksOf(token: string): string {
-  const dot = token.indexOf(".");
-  return dot === -1 ? token.slice(1) : token.slice(dot + 1);
-}
-
-/**
- * Does `pid` still name the process a row recorded?
- *
- * Three answers, and the difference between the last two matters:
- *
- * - `"match"` — recorded token, current token, same run. The row is trustworthy.
- * - `"mismatch"` — both present and different. The pid was recycled. This is
- *   the case a liveness check cannot see, because a recycled pid is alive.
- * - `"unverified"` — no recorded token (a row written before tokens existed) or
- *   no current one (an unsupported platform). Callers treat this the way they
- *   treated every row previously: trust it if the pid is alive.
- */
-export function checkPidToken(
-  pid: number,
-  recorded: string | undefined,
-): "match" | "mismatch" | "unverified" {
-  if (!recorded) return "unverified";
-  const current = processStartToken(pid);
-  if (!current) return "unverified";
-  return tokensAgree(recorded, current) ? "match" : "mismatch";
-}

package/src/core/agents/state/service-process.ts

@@ -0,0 +1,217 @@
+/**
+ * One owner check for every singleton background service (governor, local
+ * supervisor, legacy resource observer): is the recorded process still the
+ * run that wrote the record, and how is a stop requested?
+ */
+import { randomUUID } from "node:crypto";
+import {
+  closeSync,
+  existsSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { hostname } from "node:os";
+import { dirname } from "node:path";
+import { writePrivateJsonAtomic } from "../../storage/atomic-json.ts";
+import { stateDirMode, stateFileMode } from "../../storage/modes.ts";
+import {
+  type ProcessGenerationSignalDependencies,
+  type ProcessGenerationVerdict,
+  processStartToken,
+  signalIfSameGeneration,
+  verifyProcessGeneration,
+} from "./proc-start.ts";
+
+export interface ServiceProcessDependencies extends ProcessGenerationSignalDependencies {
+  /** Throws ESRCH, or returns false, when the process is gone. */
+  probePid?: (pid: number) => unknown;
+}
+
+export type ServiceLiveness = "running" | "stopped" | "unknown";
+
+export interface ServiceProcessOwner {
+  pid: number;
+  host: string;
+  start_token?: string;
+  state?: string;
+}
+
+/**
+ * A stale heartbeat does not prove that a process has exited. Another host, a
+ * probe error other than ESRCH, or an unverifiable token answers unknown. A
+ * recorded `stopped` state counts only while the generation still matches.
+ */
+export function observeServiceProcess(
+  owner: ServiceProcessOwner,
+  dependencies: ServiceProcessDependencies = {},
+): { generation: ProcessGenerationVerdict; liveness: ServiceLiveness } {
+  if (owner.host !== hostname()) return { generation: "unknown", liveness: "unknown" };
+  try {
+    if ((dependencies.probePid ?? ((pid) => process.kill(pid, 0)))(owner.pid) === false)
+      return { generation: "unknown", liveness: "stopped" };
+  } catch (error) {
+    return {
+      generation: "unknown",
+      liveness: (error as NodeJS.ErrnoException).code === "ESRCH" ? "stopped" : "unknown",
+    };
+  }
+  const generation = verifyProcessGeneration(owner.pid, owner.start_token, dependencies.readToken);
+  return {
+    generation,
+    liveness:
+      generation === "same"
+        ? owner.state === "stopped"
+          ? "stopped"
+          : "running"
+        : generation === "different"
+          ? "stopped"
+          : "unknown",
+  };
+}
+
+/** Refuse a start while another owner runs or cannot be identified. */
+export function serviceStartRefusal(
+  label: string,
+  stopCommand: string,
+  pid: number | undefined,
+  liveness: ServiceLiveness,
+): Error {
+  return new Error(
+    liveness === "running"
+      ? `${label} is already running under pid ${pid}`
+      : `${label} process generation is unknown${pid ? ` for pid ${pid}` : ""}; run \`${stopCommand}\` to write a durable stop request before starting it again`,
+  );
+}
+
+export interface ServiceLease {
+  pid: number;
+  start_token?: string;
+  host: string;
+  nonce: string;
+  created_at?: string;
+}
+
+export function readServiceLease(path: string): ServiceLease | undefined {
+  try {
+    const value = JSON.parse(readFileSync(path, "utf8")) as Partial<ServiceLease>;
+    if (
+      !Number.isSafeInteger(value.pid) ||
+      (value.pid ?? 0) <= 0 ||
+      typeof value.host !== "string" ||
+      !value.host ||
+      typeof value.nonce !== "string" ||
+      !value.nonce
+    )
+      return undefined;
+    return {
+      ...value,
+      start_token: typeof value.start_token === "string" ? value.start_token : undefined,
+    } as ServiceLease;
+  } catch {
+    return undefined;
+  }
+}
+
+/** An absent lease is stopped; an unreadable one cannot be identified. */
+export function serviceLeaseOwner(path: string): {
+  lease?: ServiceLease;
+  liveness: ServiceLiveness;
+} {
+  if (!existsSync(path)) return { liveness: "stopped" };
+  const lease = readServiceLease(path);
+  return { lease, liveness: lease ? observeServiceProcess(lease).liveness : "unknown" };
+}
+
+/**
+ * Take the singleton lease with an exclusive create. A lease whose owner is
+ * proven stopped is replaced; any other owner refuses the start.
+ */
+export function acquireServiceLease(
+  path: string,
+  refuse: (pid: number | undefined, liveness: ServiceLiveness) => Error,
+  fields: Record<string, unknown> = {},
+): { nonce: string; release: () => void } {
+  mkdirSync(dirname(path), { recursive: true, mode: stateDirMode() });
+  for (let attempt = 0; attempt < 2; attempt++) {
+    const startToken = processStartToken(process.pid);
+    const lease = {
+      ...fields,
+      pid: process.pid,
+      ...(startToken ? { start_token: startToken } : {}),
+      host: hostname(),
+      nonce: randomUUID(),
+      created_at: new Date().toISOString(),
+    };
+    try {
+      const fd = openSync(path, "wx", stateFileMode());
+      try {
+        writeFileSync(fd, `${JSON.stringify(lease)}\n`, "utf8");
+      } finally {
+        closeSync(fd);
+      }
+      return {
+        nonce: lease.nonce,
+        release: () => {
+          if (readServiceLease(path)?.nonce !== lease.nonce) return;
+          try {
+            unlinkSync(path);
+          } catch {
+            // A missing lease is already released.
+          }
+        },
+      };
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
+      const owner = serviceLeaseOwner(path);
+      if (owner.liveness !== "stopped") throw refuse(owner.lease?.pid, owner.liveness);
+      try {
+        unlinkSync(path);
+      } catch {
+        // A concurrent starter may have replaced or removed the stale lease.
+      }
+    }
+  }
+  throw new Error(`could not acquire the singleton lease at ${path}`);
+}
+
+export interface ServiceStopFields {
+  signal_sent: boolean;
+  signal_verdict: ProcessGenerationVerdict;
+}
+
+/**
+ * Write the durable stop request, then SIGTERM the owner `status` observed as
+ * running on this host, after a fresh generation check. The request stays for
+ * the daemon either way; `read` reports the state afterward.
+ */
+export function requestServiceStop<
+  S extends {
+    liveness: ServiceLiveness;
+    generation: ProcessGenerationVerdict;
+    record?: ServiceProcessOwner;
+  },
+>(
+  status: S,
+  read: () => S,
+  stopPath: string,
+  dependencies: ServiceProcessDependencies = {},
+  options: { signal?: boolean } = {},
+): S & ServiceStopFields {
+  writePrivateJsonAtomic(stopPath, {
+    requested_at: new Date().toISOString(),
+    requested_by_pid: process.pid,
+  });
+  const signal =
+    options.signal !== false && status.liveness === "running" && status.record?.host === hostname()
+      ? signalIfSameGeneration(
+          status.record.pid,
+          status.record.start_token,
+          "SIGTERM",
+          dependencies,
+        )
+      : { sent: false, verdict: status.generation };
+  return { ...read(), signal_sent: signal.sent, signal_verdict: signal.verdict };
+}

package/src/core/config.ts

@@ -92,6 +92,8 @@ interface HarneryConfig {
     requireGitFinalization?: boolean;
     finalizationRoots?: AgentFinalizationRoot[];
   };
+  /** Admission resource defaults and the heavy-command guard. Project config only. */
+  admission?: unknown;
   /** Host-owned agent instruction settings. */
   instructions?: {
     hostAddendumFile?: unknown;
@@ -633,6 +635,89 @@ export function ripgrepAutoInstall(coordRoot?: string | null): boolean {
   return readConfig(root).tools?.ripgrep?.autoInstall === true;
 }
 
+/** Wait before queueing while Linux memory pressure is high (PSI `full avg10`). */
+export interface AdmissionPressureConfig {
+  psi_full_avg10: number;
+  max_wait_seconds: number;
+}
+
+/** Per-resource defaults for `admission run`; command-line flags win. */
+export interface AdmissionResourceConfig {
+  capacity?: number;
+  timeout_minutes?: number;
+  defer_on_pressure?: AdmissionPressureConfig;
+}
+
+export interface AdmissionProjectConfig {
+  resources: Record<string, AdmissionResourceConfig>;
+  /** Present when the agent hook should wrap heavy shell commands in a slot. */
+  guard?: { resource: string };
+}
+
+function positiveNumber(value: unknown, max: number): number | undefined {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 && value <= max
+    ? value
+    : undefined;
+}
+
+/**
+ * Admission settings from `.harnery/config.jsonc`:
+ *
+ * ```jsonc
+ * "admission": {
+ *   "resources": {
+ *     "build": {
+ *       "capacity": 2,
+ *       "timeout_minutes": 30,
+ *       "defer_on_pressure": { "psi_full_avg10": 40, "max_wait_seconds": 300 }
+ *     }
+ *   },
+ *   "guard": { "resource": "build" }
+ * }
+ * ```
+ *
+ * Project config only, like other machine-shaping policy. Malformed values are
+ * dropped one by one rather than rejecting the whole block. Undefined when the
+ * project declares no admission settings.
+ */
+export function readAdmissionConfig(coordRoot?: string | null): AdmissionProjectConfig | undefined {
+  const root = coordRoot ?? findCoordRoot();
+  if (!root) return undefined;
+  const raw = readProjectConfig(root).admission;
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return undefined;
+  const record = raw as { resources?: unknown; guard?: unknown };
+  const resources: Record<string, AdmissionResourceConfig> = {};
+  if (
+    record.resources &&
+    typeof record.resources === "object" &&
+    !Array.isArray(record.resources)
+  ) {
+    for (const [name, value] of Object.entries(record.resources as Record<string, unknown>)) {
+      if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+      const entry = value as Record<string, unknown>;
+      const capacity = positiveNumber(entry.capacity, 32);
+      const timeout = positiveNumber(entry.timeout_minutes, 1440);
+      const pressure = entry.defer_on_pressure as Record<string, unknown> | undefined;
+      const threshold = positiveNumber(pressure?.psi_full_avg10, 100);
+      const maxWait = positiveNumber(pressure?.max_wait_seconds, 86_400);
+      resources[name] = {
+        ...(capacity !== undefined && Number.isInteger(capacity) ? { capacity } : {}),
+        ...(timeout !== undefined && Number.isInteger(timeout) ? { timeout_minutes: timeout } : {}),
+        ...(threshold !== undefined && maxWait !== undefined
+          ? { defer_on_pressure: { psi_full_avg10: threshold, max_wait_seconds: maxWait } }
+          : {}),
+      };
+    }
+  }
+  const guard = record.guard as { resource?: unknown } | undefined;
+  return {
+    resources,
+    ...(guard && typeof guard.resource === "string" && guard.resource
+      ? { guard: { resource: guard.resource } }
+      : {}),
+  };
+}
+
 /**
  * Whether this repo pins workflow runs to subscription billing:
  * `.harnery/config.jsonc` `{ "workflow": { "subscriptionOnly": true } }`.