stitchkit 0.68.11 → 0.70.0

package/dist/agent-runtime-harness.js

@@ -0,0 +1,704 @@
+import {
+  AgentRuntimeEventSchema,
+  composeAgentPrompt,
+  createAgentRuntime,
+  createAgentRuntimeEventSink
+} from "./index-vy5bjy07.js";
+import {
+  walkContainedFiles
+} from "./index-xbtcszs7.js";
+import {
+  AgentModelDescriptorSchema
+} from "./index-tg3m2ec5.js";
+import"./index-es0h4w26.js";
+import"./index-a59da114.js";
+import"./index-3xnq72rz.js";
+import {
+  defineRuntimeTool
+} from "./index-wwst0td5.js";
+import"./index-qzbg46b6.js";
+import"./index-ktsps64f.js";
+import {
+  AgentMessagePartSchema,
+  AgentSnapshotSchema
+} from "./index-x1th9s8c.js";
+import"./index-22by16v6.js";
+import"./index-cby4ar3v.js";
+import"./index-bd17ytae.js";
+import"./index-vj3vvpaa.js";
+import"./index-0w9abg87.js";
+import"./index-qyrqwr4c.js";
+import"./index-6k1937bx.js";
+
+// src/agent-runtime/harness-contract.ts
+import { z } from "zod";
+var AgentHarnessResourceKindSchema = z.enum(["instruction", "skill", "resource"]);
+var AgentHarnessResourceSchema = z.object({
+  kind: AgentHarnessResourceKindSchema,
+  name: z.string().min(1),
+  text: z.string(),
+  provenance: z.string().min(1)
+}).strict();
+var AgentHarnessResourceDiagnosticSchema = z.object({
+  resource: z.string().min(1),
+  severity: z.enum(["warning", "error"]),
+  message: z.string().min(1)
+}).strict();
+var AgentHarnessLimitsSchema = z.object({
+  maxResources: z.int().positive(),
+  maxResourceBytes: z.int().positive(),
+  maxDiagnostics: z.int().nonnegative()
+}).strict();
+var AgentHarnessAppliedResourceSchema = AgentHarnessResourceSchema.omit({
+  text: true
+});
+var AgentHarnessProfileEventSchema = z.object({
+  schemaVersion: z.literal(1),
+  type: z.literal("profile-applied"),
+  conversationId: z.string().min(1),
+  runId: z.string().min(1),
+  model: AgentModelDescriptorSchema,
+  resources: z.array(AgentHarnessAppliedResourceSchema),
+  diagnostics: z.array(AgentHarnessResourceDiagnosticSchema),
+  toolNames: z.array(z.string().min(1))
+}).strict();
+
+// src/agent-runtime/harness-resources.ts
+var DEFAULT_LIMITS = {
+  maxResources: 64,
+  maxResourceBytes: 1048576,
+  maxDiagnostics: 128
+};
+function resolveHarnessLimits(input) {
+  return AgentHarnessLimitsSchema.parse({ ...DEFAULT_LIMITS, ...input });
+}
+function utf8Bytes(value) {
+  return new TextEncoder().encode(value).byteLength;
+}
+function validateHarnessResources(result, limits) {
+  if (result.resources.length > limits.maxResources) {
+    throw new Error("Agent harness resource count exceeds maxResources");
+  }
+  if (result.diagnostics.length > limits.maxDiagnostics) {
+    throw new Error("Agent harness diagnostic count exceeds maxDiagnostics");
+  }
+  const resources = AgentHarnessResourceSchema.array().parse(result.resources);
+  const diagnostics = AgentHarnessResourceDiagnosticSchema.array().parse(result.diagnostics);
+  const names = new Set;
+  let bytes = 0;
+  for (const resource of resources) {
+    if (names.has(resource.name)) {
+      throw new Error(`Duplicate Agent harness resource: ${resource.name}`);
+    }
+    names.add(resource.name);
+    bytes += utf8Bytes(resource.text);
+    if (bytes > limits.maxResourceBytes) {
+      throw new Error("Agent harness resources exceed maxResourceBytes");
+    }
+  }
+  return { resources, diagnostics };
+}
+function xmlAttribute(value) {
+  return value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function renderHarnessResources(resources) {
+  return resources.map((resource) => `<resource kind="${resource.kind}" name="${xmlAttribute(resource.name)}" provenance="${xmlAttribute(resource.provenance)}">
+${resource.text}
+</resource>`).join(`
+`);
+}
+// src/agent-runtime/harness-file-resources.ts
+import { realpath } from "node:fs/promises";
+import path from "node:path";
+import { z as z2 } from "zod";
+var AgentHarnessFileRootSchema = z2.object({
+  id: z2.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/),
+  path: z2.string().min(1),
+  kind: z2.enum(["instruction", "skill", "resource"])
+}).strict();
+var AgentHarnessFileLimitsSchema = z2.object({
+  maxFiles: z2.int().positive(),
+  maxDepth: z2.int().nonnegative(),
+  maxFileBytes: z2.int().positive(),
+  maxTotalBytes: z2.int().positive()
+}).strict();
+var DEFAULT_LIMITS2 = {
+  maxFiles: 128,
+  maxDepth: 8,
+  maxFileBytes: 262144,
+  maxTotalBytes: 1048576
+};
+function metadata(text, fallbackName) {
+  const match = /^---\s*\n([\s\S]*?)\n---(?:\s*\n|$)/.exec(text.replaceAll(`\r
+`, `
+`));
+  if (!match)
+    throw new Error(`Skill ${fallbackName} requires YAML frontmatter`);
+  const fields = new Map;
+  const lines = (match[1] ?? "").split(`
+`);
+  for (let index = 0;index < lines.length; index += 1) {
+    const line = lines[index] ?? "";
+    const field = /^(name|description):\s*(.*)$/.exec(line);
+    if (!field)
+      continue;
+    const key = field[1] ?? "";
+    if (fields.has(key))
+      throw new Error(`Skill ${fallbackName} repeats ${key} metadata`);
+    const raw = field[2] ?? "";
+    if (raw === ">" || raw === "|") {
+      const block = [];
+      while ((lines[index + 1] ?? "").match(/^\s+/)) {
+        index += 1;
+        block.push((lines[index] ?? "").replace(/^\s+/, ""));
+      }
+      fields.set(key, raw === ">" ? block.join(" ").trim() : block.join(`
+`).trim());
+    } else if (raw.startsWith('"')) {
+      let parsed;
+      try {
+        parsed = JSON.parse(raw);
+      } catch {
+        throw new Error(`Skill ${fallbackName} has invalid quoted ${key} metadata`);
+      }
+      if (typeof parsed !== "string")
+        throw new Error(`Skill ${fallbackName} has non-string ${key} metadata`);
+      fields.set(key, parsed);
+    } else if (raw.startsWith("'") && raw.endsWith("'")) {
+      fields.set(key, raw.slice(1, -1).replaceAll("''", "'"));
+    } else {
+      fields.set(key, raw.trim());
+    }
+  }
+  const name = fields.get("name");
+  const description = fields.get("description");
+  if (!name || !description) {
+    throw new Error(`Skill ${fallbackName} requires name and description metadata`);
+  }
+  return { name, description };
+}
+function safeName(relative) {
+  return relative.split(path.sep).join("/");
+}
+function createAgentHarnessFileResources(config) {
+  const roots = AgentHarnessFileRootSchema.array().min(1).parse(config.roots);
+  const ids = new Set;
+  for (const root of roots) {
+    if (!path.isAbsolute(root.path))
+      throw new Error("Agent harness resource roots must be absolute");
+    if (ids.has(root.id))
+      throw new Error(`Duplicate Agent harness resource root id: ${root.id}`);
+    ids.add(root.id);
+  }
+  const limits = AgentHarnessFileLimitsSchema.parse({ ...DEFAULT_LIMITS2, ...config.limits });
+  let exact = new Map;
+  let loaded;
+  const discover = async () => {
+    const next = new Map;
+    const projected = [];
+    let totalBytes = 0;
+    let fileCount = 0;
+    for (const root of roots) {
+      const resolvedRoot = await realpath(root.path);
+      const files = await walkContainedFiles({
+        root: resolvedRoot,
+        maxDepth: limits.maxDepth,
+        maxFiles: limits.maxFiles - fileCount,
+        readMaxBytes: limits.maxFileBytes
+      });
+      fileCount += files.length;
+      for (const file of files) {
+        if (root.kind === "skill" && path.basename(file.absolute) !== "SKILL.md")
+          continue;
+        const read = file.content;
+        if (!read)
+          throw new Error("Agent harness resource content is unavailable");
+        totalBytes += read.bytes;
+        if (totalBytes > limits.maxTotalBytes) {
+          throw new Error("Agent harness resources exceed maxTotalBytes");
+        }
+        const text = read.text;
+        const provenance = `${root.id}:${safeName(file.relative)}`;
+        const skill = root.kind === "skill" ? metadata(text, provenance) : undefined;
+        const name = skill?.name ?? safeName(file.relative);
+        if (next.has(name))
+          throw new Error(`Duplicate Agent harness resource: ${name}`);
+        const resource = {
+          kind: root.kind,
+          name,
+          text,
+          provenance
+        };
+        next.set(name, resource);
+        projected.push(root.kind === "instruction" ? resource : {
+          ...resource,
+          text: root.kind === "skill" ? `Available skill: ${name} — ${skill?.description ?? ""}. Read it by exact name when needed.` : `Available resource: ${name}. Read it by exact name when needed.`
+        });
+      }
+    }
+    exact = new Map(next);
+    return { resources: Object.freeze([...projected]), diagnostics: [] };
+  };
+  const load = () => {
+    loaded ??= discover();
+    return loaded;
+  };
+  const readResource = defineRuntimeTool({
+    name: "read_resource",
+    description: "Read one exact discovered harness skill or resource by canonical name.",
+    identity: { serviceName: "harness", action: "read-resource", method: "POST" },
+    input: z2.object({ name: z2.string().min(1) }).strict(),
+    output: z2.object({
+      kind: z2.enum(["instruction", "skill", "resource"]),
+      name: z2.string().min(1),
+      text: z2.string(),
+      provenance: z2.string().min(1)
+    }).strict(),
+    transports: ["AGENT"],
+    handler: ({ input }) => {
+      const resource = exact.get(input.name);
+      if (!resource)
+        throw new Error("Harness resource is missing or stale; refresh discovery");
+      return resource;
+    }
+  });
+  return { load, runtimeTools: [readResource] };
+}
+// src/agent-runtime/control-schema.ts
+import { z as z3 } from "zod";
+var AgentControlIdentitySchema = z3.object({ schemaVersion: z3.literal(1), requestId: z3.string().min(1) }).strict();
+var AgentControlRequestSchema = z3.discriminatedUnion("operation", [
+  AgentControlIdentitySchema.extend({
+    operation: z3.literal("attach"),
+    conversationId: z3.string().min(1),
+    access: z3.enum(["observe", "control"])
+  }),
+  AgentControlIdentitySchema.extend({
+    operation: z3.literal("detach"),
+    conversationId: z3.string().min(1)
+  }),
+  AgentControlIdentitySchema.extend({
+    operation: z3.literal("snapshot"),
+    conversationId: z3.string().min(1)
+  }),
+  AgentControlIdentitySchema.extend({
+    operation: z3.literal("submit"),
+    conversationId: z3.string().min(1),
+    idempotencyKey: z3.string().min(1),
+    context: z3.unknown(),
+    parts: z3.array(AgentMessagePartSchema).min(1),
+    metadata: z3.unknown().optional()
+  }),
+  AgentControlIdentitySchema.extend({
+    operation: z3.literal("interrupt"),
+    conversationId: z3.string().min(1),
+    runId: z3.string().min(1)
+  }),
+  AgentControlIdentitySchema.extend({
+    operation: z3.literal("respond-approval"),
+    conversationId: z3.string().min(1),
+    approvalId: z3.string().min(1),
+    approved: z3.boolean(),
+    reason: z3.string().min(1).optional(),
+    context: z3.unknown(),
+    metadata: z3.unknown().optional()
+  })
+]);
+var AgentControlResponseIdentitySchema = z3.object({
+  schemaVersion: z3.literal(1),
+  requestId: z3.string().min(1)
+});
+var AgentControlResponseSchema = z3.discriminatedUnion("outcome", [
+  AgentControlResponseIdentitySchema.extend({
+    outcome: z3.literal("ok"),
+    snapshot: AgentSnapshotSchema.optional(),
+    runId: z3.string().min(1).optional()
+  }).strict(),
+  AgentControlResponseIdentitySchema.extend({
+    outcome: z3.literal("error"),
+    error: z3.object({ code: z3.string().min(1), message: z3.string().min(1) }).strict()
+  }).strict()
+]);
+var AgentControlDeliverySchema = z3.discriminatedUnion("type", [
+  z3.object({
+    schemaVersion: z3.literal(1),
+    type: z3.literal("event"),
+    event: AgentRuntimeEventSchema
+  }).strict(),
+  z3.object({
+    schemaVersion: z3.literal(1),
+    type: z3.literal("resync-required"),
+    conversationId: z3.string().min(1),
+    reason: z3.literal("overflow")
+  }).strict()
+]);
+var AgentMultiSessionCursorSchema = z3.object({
+  conversations: z3.record(z3.string(), z3.object({
+    snapshotVersion: z3.int().nonnegative().optional(),
+    durableEventIds: z3.array(z3.string().min(1)).optional(),
+    runs: z3.record(z3.string(), z3.object({ runtimeEpoch: z3.string().min(1), sequence: z3.int().nonnegative() }).strict())
+  }).strict())
+}).strict();
+
+// src/agent-runtime/harness-control.ts
+function createAgentHarnessControlServer(harness, config = {}) {
+  const connections = new Map;
+  const controllers = new Map;
+  let closed = false;
+  const unsubscribe = harness.subscribe((event) => {
+    for (const connection of connections.values()) {
+      if (connection.attached.has(event.conversationId) && !connection.overflowed) {
+        connection.sink.publish(event);
+      }
+    }
+  });
+  const detach = (connectionId) => {
+    const connection = connections.get(connectionId);
+    if (!connection)
+      return;
+    for (const [conversationId, access] of connection.attached) {
+      if (access === "control" && controllers.get(conversationId) === connectionId) {
+        controllers.delete(conversationId);
+      }
+    }
+    connection.sink.close();
+    connections.delete(connectionId);
+  };
+  return {
+    connect({ id, deliver, onOverflow }) {
+      if (closed)
+        throw new Error("Agent harness control server is closed");
+      if (connections.has(id))
+        throw new Error("Agent harness control connection id is duplicate");
+      const state = {
+        attached: new Map,
+        overflowed: false,
+        sink: createAgentRuntimeEventSink({
+          write: (event) => deliver({ schemaVersion: 1, type: "event", event }),
+          maxPending: config.maxPendingEvents ?? 128,
+          onDrop: ({ event }) => {
+            if (state.overflowed)
+              return;
+            state.overflowed = true;
+            onOverflow({
+              schemaVersion: 1,
+              type: "resync-required",
+              conversationId: event.conversationId,
+              reason: "overflow"
+            });
+            detach(id);
+          }
+        })
+      };
+      connections.set(id, state);
+      return {
+        async request(raw) {
+          const request = AgentControlRequestSchema.parse(raw);
+          const fail = (code, message) => AgentControlResponseSchema.parse({
+            schemaVersion: 1,
+            requestId: request.requestId,
+            outcome: "error",
+            error: { code, message }
+          });
+          if (closed || connections.get(id) !== state)
+            return fail("CONNECTION_CLOSED", "Connection is closed");
+          try {
+            if (request.operation === "attach") {
+              const owner = controllers.get(request.conversationId);
+              if (request.access === "control" && owner && owner !== id) {
+                return fail("LEASE_CONFLICT", "Conversation already has a controller");
+              }
+              const snapshot = await harness.snapshot(request.conversationId);
+              if (request.access === "control")
+                controllers.set(request.conversationId, id);
+              else if (controllers.get(request.conversationId) === id)
+                controllers.delete(request.conversationId);
+              state.attached.set(request.conversationId, request.access);
+              return AgentControlResponseSchema.parse({
+                schemaVersion: 1,
+                requestId: request.requestId,
+                outcome: "ok",
+                snapshot
+              });
+            }
+            if (request.operation === "detach") {
+              if (controllers.get(request.conversationId) === id)
+                controllers.delete(request.conversationId);
+              state.attached.delete(request.conversationId);
+              return AgentControlResponseSchema.parse({
+                schemaVersion: 1,
+                requestId: request.requestId,
+                outcome: "ok"
+              });
+            }
+            if (!state.attached.has(request.conversationId))
+              return fail("NOT_ATTACHED", "Attach before requesting conversation state");
+            if (request.operation === "snapshot") {
+              const snapshot = await harness.snapshot(request.conversationId);
+              return AgentControlResponseSchema.parse({
+                schemaVersion: 1,
+                requestId: request.requestId,
+                outcome: "ok",
+                snapshot
+              });
+            }
+            if (state.attached.get(request.conversationId) !== "control" || controllers.get(request.conversationId) !== id) {
+              return fail("LEASE_REQUIRED", "An active controller lease is required");
+            }
+            if (request.operation === "interrupt") {
+              await harness.interrupt({
+                conversationId: request.conversationId,
+                runId: request.runId
+              });
+              return AgentControlResponseSchema.parse({
+                schemaVersion: 1,
+                requestId: request.requestId,
+                outcome: "ok",
+                snapshot: await harness.snapshot(request.conversationId)
+              });
+            }
+            if (request.operation === "respond-approval") {
+              const ticket2 = await harness.respondToApproval({
+                conversationId: request.conversationId,
+                approvalId: request.approvalId,
+                approved: request.approved,
+                ...request.reason && { reason: request.reason },
+                context: request.context,
+                ...request.metadata !== undefined && { metadata: request.metadata }
+              });
+              const admission2 = await ticket2.admission;
+              return AgentControlResponseSchema.parse({
+                schemaVersion: 1,
+                requestId: request.requestId,
+                outcome: "ok",
+                runId: admission2.runId,
+                snapshot: await harness.snapshot(request.conversationId)
+              });
+            }
+            const ticket = harness.submit({
+              conversationId: request.conversationId,
+              idempotencyKey: request.idempotencyKey,
+              context: request.context,
+              parts: request.parts,
+              ...request.metadata !== undefined && { metadata: request.metadata }
+            });
+            const admission = await ticket.admission;
+            return AgentControlResponseSchema.parse({
+              schemaVersion: 1,
+              requestId: request.requestId,
+              outcome: "ok",
+              runId: admission.runId,
+              snapshot: await harness.snapshot(request.conversationId)
+            });
+          } catch {
+            return fail("REQUEST_REJECTED", "Control request was rejected");
+          }
+        },
+        close() {
+          detach(id);
+        }
+      };
+    },
+    close() {
+      if (closed)
+        return;
+      closed = true;
+      unsubscribe();
+      for (const id of [...connections.keys()])
+        detach(id);
+    }
+  };
+}
+
+// src/agent-runtime/harness.ts
+function activeRunId(snapshot) {
+  const active = snapshot.runs.filter((run2) => run2.state === "running" || run2.state === "interrupt_requested");
+  if (active.length !== 1) {
+    throw new Error("Agent harness prompt requires exactly one active run");
+  }
+  const run = active[0];
+  if (!run)
+    throw new Error("Agent harness active run is unavailable");
+  return run.id;
+}
+function createHeadlessAgentHarness(config) {
+  const {
+    models,
+    resources,
+    tools,
+    promptBudget,
+    estimateResourceTokens,
+    limits: inputLimits,
+    onProfile,
+    onProfileError,
+    publish: applicationPublish,
+    ...runtimeConfig
+  } = config;
+  const limits = resolveHarnessLimits(inputLimits);
+  const pending = new Map;
+  const subscribers = new Set;
+  const emitProfile = async (runId) => {
+    const entry = pending.get(runId);
+    if (!entry?.prompt || !entry.toolNames || entry.emitting)
+      return entry?.emitting;
+    const event = AgentHarnessProfileEventSchema.parse({
+      schemaVersion: 1,
+      type: "profile-applied",
+      conversationId: entry.prompt.conversationId,
+      runId,
+      model: entry.prompt.model.descriptor,
+      resources: entry.prompt.resources.map(({ kind, name, provenance }) => ({
+        kind,
+        name,
+        provenance
+      })),
+      diagnostics: entry.prompt.diagnostics,
+      toolNames: entry.toolNames
+    });
+    const emitting = (async () => {
+      try {
+        await onProfile?.(event);
+      } catch (error) {
+        try {
+          await onProfileError?.({ event, error });
+        } catch {}
+      } finally {
+        pending.delete(runId);
+      }
+    })();
+    entry.emitting = emitting;
+    return emitting;
+  };
+  const publish = async (event) => {
+    try {
+      await applicationPublish?.(event);
+    } finally {
+      for (const subscriber of subscribers) {
+        Promise.resolve(subscriber(event)).catch(() => {});
+      }
+      if (event.type === "terminal")
+        pending.delete(event.runId);
+    }
+  };
+  const runtime = createAgentRuntime({
+    ...runtimeConfig,
+    models,
+    publish,
+    prompt: async ({ context, signal, model, snapshot }) => {
+      const loaded = validateHarnessResources(await resources.load({ context, signal, model, snapshot }), limits);
+      try {
+        await resources.onDiagnostics?.({ context, diagnostics: loaded.diagnostics });
+      } catch {}
+      const runId = activeRunId(snapshot);
+      const entry = pending.get(runId) ?? {};
+      entry.prompt = {
+        conversationId: snapshot.conversationId,
+        model,
+        resources: loaded.resources,
+        diagnostics: loaded.diagnostics
+      };
+      pending.set(runId, entry);
+      await emitProfile(runId);
+      const prompt = composeAgentPrompt([
+        {
+          name: "harness-resources",
+          stability: "dynamic",
+          render: () => renderHarnessResources(loaded.resources),
+          ...estimateResourceTokens && { estimateTokens: estimateResourceTokens }
+        }
+      ]);
+      return prompt({
+        context,
+        signal,
+        budget: await promptBudget({
+          context,
+          contextWindow: model.descriptor.contextWindow
+        })
+      });
+    },
+    tools: async (runContext) => {
+      const mounted = await tools(runContext);
+      const entry = pending.get(runContext.run.id) ?? {};
+      entry.toolNames = Object.keys(mounted).sort();
+      pending.set(runContext.run.id, entry);
+      await emitProfile(runContext.run.id);
+      return mounted;
+    }
+  });
+  const pendingApprovals = async (conversationId) => {
+    const snapshot = await config.store.loadSnapshot(conversationId);
+    const responded = new Set(snapshot.messages.flatMap((message) => message.parts.filter((part) => part.type === "tool-approval-response").map((part) => part.approvalId)));
+    const pendingApprovals2 = [];
+    for (const message of snapshot.messages) {
+      const calls = new Map(message.parts.filter((part) => part.type === "tool-call").map((part) => [part.callId, part]));
+      for (const request of message.parts.filter((part) => part.type === "tool-approval-request")) {
+        if (responded.has(request.approvalId))
+          continue;
+        const call = calls.get(request.callId);
+        if (!call || !message.runId)
+          continue;
+        pendingApprovals2.push({
+          conversationId,
+          runId: message.runId,
+          messageId: message.id,
+          approvalId: request.approvalId,
+          callId: request.callId,
+          toolName: call.toolName,
+          input: call.input,
+          ...request.signature && { signature: request.signature }
+        });
+      }
+    }
+    return pendingApprovals2;
+  };
+  return {
+    ...runtime,
+    snapshot: (conversationId) => config.store.loadSnapshot(conversationId),
+    subscribe(listener) {
+      subscribers.add(listener);
+      return () => subscribers.delete(listener);
+    },
+    pendingApprovals,
+    async respondToApproval(input) {
+      const pending2 = (await pendingApprovals(input.conversationId)).filter((approval) => approval.approvalId === input.approvalId);
+      if (pending2.length !== 1) {
+        throw new Error("Approval request is missing, stale or already answered");
+      }
+      const ticket = runtime.submit({
+        conversationId: input.conversationId,
+        idempotencyKey: `tool-approval:${input.approvalId}`,
+        context: input.context,
+        role: "tool",
+        ...input.metadata !== undefined && { metadata: input.metadata },
+        parts: [
+          {
+            type: "tool-approval-response",
+            approvalId: input.approvalId,
+            approved: input.approved,
+            ...input.reason && { reason: input.reason }
+          }
+        ]
+      });
+      const checkedAdmission = ticket.admission.then(async (admission) => {
+        const response = admission.input.parts.find((part) => part.type === "tool-approval-response");
+        if (!response || response.approvalId !== input.approvalId || response.approved !== input.approved || response.reason !== input.reason) {
+          throw new Error("Approval decision conflicts with the durable decision");
+        }
+        return admission;
+      });
+      return { ...ticket, admission: checkedAdmission };
+    }
+  };
+}
+export {
+  AgentHarnessFileLimitsSchema,
+  AgentHarnessFileRootSchema,
+  AgentHarnessLimitsSchema,
+  AgentHarnessProfileEventSchema,
+  AgentHarnessResourceDiagnosticSchema,
+  AgentHarnessResourceKindSchema,
+  AgentHarnessResourceSchema,
+  createAgentHarnessControlServer,
+  createAgentHarnessFileResources,
+  createHeadlessAgentHarness
+};