openpond 0.2.0 → 0.2.1

package/dist/chunks/chunk-X6F4LBTQ.js

@@ -1,832 +0,0 @@
-import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
-import {
-  acquireFileLock,
-  assertHomeCompatible,
-  atomicWriteFile,
-  readJsonFile,
-  readOptionalFile,
-  withFileLock
-} from "./chunk-4KA25HUP.js";
-import {
-  PersistenceError,
-  resolveOpenPondHome,
-  storagePaths,
-  withOpenPondHome
-} from "./chunk-ZNQEROWP.js";
-import {
-  external_exports
-} from "./chunk-FQS2QL5F.js";
-
-// ../server/src/runtime/home-runtime-owner.ts
-import path from "node:path";
-import { AsyncLocalStorage } from "node:async_hooks";
-import { promises as fs } from "node:fs";
-var startupDisposers = new AsyncLocalStorage();
-function onStartupFailure(dispose, replacesEarlier = false) {
-  const disposers = startupDisposers.getStore();
-  if (!disposers) return;
-  if (replacesEarlier) disposers.length = 0;
-  disposers.push(dispose);
-}
-async function ownHomeRuntime(home, start) {
-  await assertHomeCompatible(home);
-  let release;
-  try {
-    release = await acquireFileLock(path.join(storagePaths(home).runtime, "server-owner"), 100);
-  } catch (error) {
-    if (error instanceof PersistenceError && error.issue.code === "STORAGE_BUSY") {
-      const endpoint = await readJsonFile(path.join(storagePaths(home).runtime, "endpoint.json"), () => null);
-      throw new PersistenceError({
-        code: "RUNTIME_ALREADY_RUNNING",
-        path: home,
-        message: "An OpenPond runtime already owns this home.",
-        action: endpoint?.url ? `Connect to the existing runtime at ${endpoint.url}, or stop it before starting another.` : "Stop the existing runtime before starting another with this home."
-      });
-    }
-    throw error;
-  }
-  const disposers = [];
-  try {
-    const runtime = await withOpenPondHome(home, () => startupDisposers.run(disposers, start)), close = runtime.close.bind(runtime);
-    disposers.length = 0;
-    let closing;
-    return { ...runtime, close: () => closing ??= (async () => {
-      try {
-        await withOpenPondHome(home, close);
-      } finally {
-        await fs.rm(path.join(storagePaths(home).runtime, "endpoint.json"), { force: true });
-        await release();
-      }
-    })() };
-  } catch (error) {
-    try {
-      for (const dispose of disposers.reverse()) await Promise.resolve().then(() => withOpenPondHome(home, dispose)).catch(() => void 0);
-      await fs.rm(path.join(storagePaths(home).runtime, "endpoint.json"), { force: true });
-    } finally {
-      await release();
-    }
-    throw error;
-  }
-}
-async function publishRuntimeEndpoint(home, url, serverId) {
-  await atomicWriteFile(path.join(storagePaths(home).runtime, "endpoint.json"), JSON.stringify({ schemaVersion: "openpond.runtimeEndpoint.v1", pid: process.pid, url, serverId }));
-}
-
-// ../../packages/agent-runtime/dist/compaction.js
-function agentCompactionDecision(input) {
-  if (!input.maxContextTokens || !input.usableContextTokens) {
-    return {
-      shouldCompact: false,
-      projectedTokens: input.projectedTokens,
-      thresholdTokens: Number.MAX_SAFE_INTEGER,
-      usableContextTokens: 0,
-      maxContextTokens: 0,
-      tokenSource: "heuristic"
-    };
-  }
-  const triggerRatio = Math.max(0.01, Math.min(1, (input.triggerPercent ?? 85) / 100));
-  const thresholdTokens = Math.max(1, Math.floor(input.usableContextTokens * triggerRatio));
-  return {
-    shouldCompact: input.projectedTokens >= thresholdTokens,
-    projectedTokens: input.projectedTokens,
-    thresholdTokens,
-    usableContextTokens: input.usableContextTokens,
-    maxContextTokens: input.maxContextTokens,
-    tokenSource: "heuristic"
-  };
-}
-async function runAgentCompaction(host) {
-  await host.started();
-  try {
-    return await host.compact();
-  } catch (error) {
-    await host.failed(error);
-    throw error;
-  }
-}
-async function runAgentCompactionProgram(input) {
-  const projectionEvents = input.host.projectEvents(input.events);
-  const selection = input.host.selectEvents(projectionEvents, input.maxContextTokens);
-  const { summaryEvents, preservedEvents, preservedEventIds } = selection;
-  if (summaryEvents.length === 0) {
-    throw new Error("There is not enough prior context to compact.");
-  }
-  const summaryRecords = input.host.normalizeRecords(summaryEvents);
-  const preservedRecords = input.host.normalizeRecords(preservedEvents);
-  const fileLedger = input.host.buildFileLedger(input.host.normalizeRecords(projectionEvents));
-  const serialized = input.host.serializeRecords(summaryRecords, input.host.inputCharBudget(input.maxContextTokens));
-  if (!serialized.text.trim()) {
-    throw new Error("There is not enough prior context to compact.");
-  }
-  const messages = input.host.buildSummaryMessages({
-    serializedHistory: serialized.text,
-    fileLedger
-  });
-  const startedAtMs = Date.now();
-  const summary = (await input.host.streamSummary({
-    model: input.model,
-    messages,
-    signal: input.signal
-  })).trim();
-  const durationMs = Date.now() - startedAtMs;
-  if (!summary)
-    throw new Error("Compaction summary was empty.");
-  const projection = input.host.estimateProjection({
-    events: projectionEvents,
-    preservedEvents,
-    summary
-  });
-  const metrics = input.host.createMetrics({
-    sourceEvents: projectionEvents.length,
-    summarizedEvents: summaryEvents.length,
-    preservedEvents: preservedEvents.length,
-    sourceRecords: serialized.sourceRecordCount,
-    includedRecords: serialized.includedRecordCount,
-    omittedRecords: serialized.omittedRecordCount,
-    preservedRecords: preservedRecords.length,
-    truncatedRecords: serialized.truncatedRecordCount,
-    summaryInputTruncated: serialized.inputTruncated,
-    sourceSelectionStrategy: serialized.selectionStrategy,
-    summaryInputChars: serialized.inputChars,
-    retainedTailTokens: selection.retainedTailTokens,
-    retainedTailBudgetTokens: selection.retainedTailBudgetTokens,
-    finalProviderContextTokens: projection.inputTokensAfter,
-    durationMs,
-    fileLedgerEntries: fileLedger.length,
-    splitTurnId: selection.splitTurnId
-  });
-  return {
-    summary,
-    model: input.model,
-    compactedThroughEventId: projectionEvents[projectionEvents.length - 1]?.id ?? null,
-    compactedThroughTurnId: input.host.lastTurnId(projectionEvents),
-    preservedFromEventId: preservedEvents[0]?.id ?? null,
-    preservedEventIds,
-    preservedResourceRefs: input.host.durableResourceRefs(input.events),
-    sourceEventCount: summaryEvents.length,
-    preservedEventCount: preservedEvents.length,
-    fileLedger,
-    inputTokensBefore: projection.inputTokensBefore,
-    inputTokensAfter: projection.inputTokensAfter,
-    maxContextTokens: input.maxContextTokens,
-    tokenSource: "heuristic",
-    metrics
-  };
-}
-
-// ../../packages/agent-runtime/dist/canonical.js
-import { createHash } from "node:crypto";
-function canonicalJson(value) {
-  if (value === null || typeof value === "boolean" || typeof value === "string") {
-    return value;
-  }
-  if (typeof value === "number") {
-    if (!Number.isFinite(value))
-      throw new Error("Canonical JSON cannot encode a non-finite number.");
-    return value;
-  }
-  if (Array.isArray(value))
-    return value.map(canonicalJson);
-  if (typeof value === "object") {
-    const output = {};
-    for (const key of Object.keys(value).sort()) {
-      const member = value[key];
-      if (member !== void 0)
-        output[key] = canonicalJson(member);
-    }
-    return output;
-  }
-  throw new Error(`Canonical JSON cannot encode ${typeof value}.`);
-}
-function canonicalHash(value) {
-  return createHash("sha256").update(JSON.stringify(canonicalJson(value)), "utf8").digest("hex");
-}
-
-// ../../packages/agent-runtime/dist/events.js
-var AgentEventNameSchema = external_exports.enum([
-  "thread.started",
-  "thread.resumed",
-  "turn.started",
-  "turn.steered",
-  "turn.interrupted",
-  "turn.completed",
-  "turn.failed",
-  "item.started",
-  "item.delta",
-  "item.completed",
-  "assistant.reasoning.delta",
-  "assistant.delta",
-  "tool.started",
-  "tool.completed",
-  "approval.requested",
-  "approval.resolved",
-  "user_input.requested",
-  "user_input.resolved",
-  "compaction.started",
-  "compaction.completed",
-  "harness.admitted",
-  "harness.refiner.queued",
-  "harness.refiner.started",
-  "harness.refiner.completed",
-  "harness.refiner.failed",
-  "diagnostic"
-]);
-var CanonicalAgentEventSchema = external_exports.object({
-  sequence: external_exports.number().int().nonnegative(),
-  name: AgentEventNameSchema,
-  source: external_exports.enum(["runtime", "provider", "tool", "host", "refiner"]),
-  status: external_exports.string().trim().min(1).nullable().default(null),
-  threadId: external_exports.string().trim().min(1),
-  turnId: external_exports.string().trim().min(1).nullable().default(null),
-  callId: external_exports.string().trim().min(1).nullable().default(null),
-  output: external_exports.string().nullable().default(null),
-  error: external_exports.string().nullable().default(null),
-  data: external_exports.record(external_exports.string(), external_exports.unknown()).default({})
-}).strict();
-function canonicalEventHash(event) {
-  return canonicalHash(CanonicalAgentEventSchema.parse(event));
-}
-
-// ../../packages/agent-runtime/dist/protocol.js
-var AGENT_PROTOCOL_VERSION = "2026-08-26";
-var AGENT_RPC_METHODS = [
-  "initialize",
-  "initialized",
-  "runtime/capabilities",
-  "thread/start",
-  "thread/resume",
-  "thread/read",
-  "turn/start",
-  "turn/steer",
-  "turn/interrupt",
-  "approval/resolve",
-  "userInput/resolve",
-  "harness/inspect",
-  "harness/proposalReview",
-  "harness/review",
-  "harness/acceptEvaluationReview",
-  "harness/materializeEvaluationTaskset",
-  "harness/runEvaluationBaseline",
-  "harness/validate",
-  "harness/backgroundReview",
-  "harness/diff",
-  "harness/rollback",
-  "refiner/inspect",
-  "refiner/update",
-  "refiner/activate",
-  "refiner/rollback"
-];
-var JsonRpcRequestSchema = external_exports.object({
-  jsonrpc: external_exports.literal("2.0"),
-  id: external_exports.union([external_exports.string(), external_exports.number()]),
-  method: external_exports.string().trim().min(1),
-  params: external_exports.unknown().optional()
-}).strict();
-var JsonRpcNotificationSchema = external_exports.object({
-  jsonrpc: external_exports.literal("2.0"),
-  method: external_exports.string().trim().min(1),
-  params: external_exports.unknown().optional()
-}).strict();
-var JsonRpcSuccessSchema = external_exports.object({
-  jsonrpc: external_exports.literal("2.0"),
-  id: external_exports.union([external_exports.string(), external_exports.number()]),
-  result: external_exports.unknown()
-}).strict();
-var JsonRpcErrorSchema = external_exports.object({
-  jsonrpc: external_exports.literal("2.0"),
-  id: external_exports.union([external_exports.string(), external_exports.number(), external_exports.null()]),
-  error: external_exports.object({
-    code: external_exports.number().int(),
-    message: external_exports.string(),
-    data: external_exports.unknown().optional()
-  }).strict()
-}).strict();
-var AgentProtocolEnvelopeSchema = external_exports.union([
-  JsonRpcRequestSchema,
-  JsonRpcNotificationSchema,
-  JsonRpcSuccessSchema,
-  JsonRpcErrorSchema
-]);
-var InitializeParamsSchema = external_exports.object({
-  protocolVersion: external_exports.string().trim().min(1),
-  client: external_exports.object({
-    name: external_exports.string().trim().min(1),
-    version: external_exports.string().trim().min(1)
-  }).strict(),
-  capabilities: external_exports.record(external_exports.string(), external_exports.unknown()).default({})
-}).strict();
-var AgentJsonRpcDispatcher = class {
-  #host;
-  #initializeParams = null;
-  #initialized = false;
-  constructor(host) {
-    this.#host = host;
-  }
-  get initialized() {
-    return this.#initialized;
-  }
-  async handle(value) {
-    const notification = JsonRpcNotificationSchema.safeParse(value);
-    if (notification.success && !("id" in value)) {
-      if (notification.data.method === "initialized") {
-        if (!this.#initializeParams)
-          throw new JsonRpcDispatchError(-32002, "initialize must be called first");
-        this.#initialized = true;
-      }
-      return null;
-    }
-    const parsed = JsonRpcRequestSchema.safeParse(value);
-    if (!parsed.success)
-      return jsonRpcError(null, -32600, "Invalid Request", parsed.error.flatten());
-    const request = parsed.data;
-    try {
-      const result = await this.#dispatch(request.method, request.params);
-      return { jsonrpc: "2.0", id: request.id, result };
-    } catch (error) {
-      const dispatchError = error instanceof JsonRpcDispatchError ? error : new JsonRpcDispatchError(-32603, error instanceof Error ? error.message : String(error));
-      return jsonRpcError(request.id, dispatchError.code, dispatchError.message, dispatchError.data);
-    }
-  }
-  async #dispatch(method, params) {
-    if (method === "initialize") {
-      const input = InitializeParamsSchema.parse(params);
-      if (input.protocolVersion !== AGENT_PROTOCOL_VERSION) {
-        throw new JsonRpcDispatchError(-32001, "Incompatible agent protocol version", {
-          requested: input.protocolVersion,
-          supported: AGENT_PROTOCOL_VERSION
-        });
-      }
-      this.#initializeParams = input;
-      return {
-        protocolVersion: AGENT_PROTOCOL_VERSION,
-        server: { name: "openpond-app-server", version: "1" },
-        capabilities: await this.#host.capabilities()
-      };
-    }
-    if (!this.#initialized)
-      throw new JsonRpcDispatchError(-32002, "initialized notification is required");
-    switch (method) {
-      case "runtime/capabilities":
-        return this.#host.capabilities(params);
-      case "thread/start":
-        return this.#host.threadStart(params);
-      case "thread/resume":
-        return this.#host.threadResume(params);
-      case "thread/read":
-        return this.#host.threadRead(params);
-      case "turn/start":
-        return this.#host.turnStart(params);
-      case "turn/steer":
-        return this.#host.turnSteer(params);
-      case "turn/interrupt":
-        return this.#host.turnInterrupt(params);
-      case "approval/resolve":
-        return this.#host.approvalResolve(params);
-      case "userInput/resolve":
-        return this.#host.userInputResolve(params);
-      case "harness/inspect":
-        return this.#host.harnessInspect(params);
-      case "harness/proposalReview":
-        return this.#host.harnessProposalReview(params);
-      case "harness/review":
-        return this.#host.harnessReview(params);
-      case "harness/acceptEvaluationReview":
-        return this.#host.harnessAcceptEvaluationReview(params);
-      case "harness/materializeEvaluationTaskset":
-        return this.#host.harnessMaterializeEvaluationTaskset(params);
-      case "harness/runEvaluationBaseline":
-        return this.#host.harnessRunEvaluationBaseline(params);
-      case "harness/validate":
-        return this.#host.harnessValidate(params);
-      case "harness/backgroundReview":
-        return this.#host.harnessBackgroundReview(params);
-      case "harness/diff":
-        return this.#host.harnessDiff(params);
-      case "harness/rollback":
-        return this.#host.harnessRollback(params);
-      case "refiner/inspect":
-        return this.#host.refinerInspect(params);
-      case "refiner/update":
-        return this.#host.refinerUpdate(params);
-      case "refiner/activate":
-        return this.#host.refinerActivate(params);
-      case "refiner/rollback":
-        return this.#host.refinerRollback(params);
-      default:
-        throw new JsonRpcDispatchError(-32601, `Method not found: ${method}`);
-    }
-  }
-};
-var JsonRpcDispatchError = class extends Error {
-  code;
-  data;
-  constructor(code, message, data) {
-    super(message);
-    this.code = code;
-    this.data = data;
-  }
-};
-function jsonRpcError(id, code, message, data) {
-  return {
-    jsonrpc: "2.0",
-    id,
-    error: { code, message, ...data === void 0 ? {} : { data } }
-  };
-}
-
-// ../../packages/agent-runtime/dist/jsonl.js
-import { once } from "node:events";
-import { createInterface } from "node:readline";
-async function runAgentJsonlServer(input) {
-  const dispatcher = new AgentJsonRpcDispatcher(input.host);
-  let writeChain = Promise.resolve();
-  const pendingNotifications = [];
-  const write = (message) => {
-    writeChain = writeChain.then(async () => {
-      if (!input.writable.write(`${JSON.stringify(message)}
-`))
-        await once(input.writable, "drain");
-    });
-    return writeChain;
-  };
-  const flushPendingNotifications = () => {
-    if (!dispatcher.initialized || pendingNotifications.length === 0)
-      return;
-    for (const notification of pendingNotifications.splice(0))
-      void write(notification);
-  };
-  const unsubscribe = input.host.subscribe?.((notification) => {
-    if (!dispatcher.initialized) {
-      pendingNotifications.push(notification);
-      return;
-    }
-    void write(notification);
-  });
-  const inFlight = /* @__PURE__ */ new Set();
-  const lines = createInterface({ input: input.readable, crlfDelay: Infinity });
-  try {
-    for await (const line of lines) {
-      if (!line.trim())
-        continue;
-      let parsed;
-      try {
-        parsed = JSON.parse(line);
-      } catch {
-        await write({
-          jsonrpc: "2.0",
-          id: null,
-          error: { code: -32700, message: "Parse error" }
-        });
-        continue;
-      }
-      const operation = (async () => {
-        const response = await dispatcher.handle(parsed);
-        if (response)
-          await write(response);
-        flushPendingNotifications();
-      })();
-      const method = parsed && typeof parsed === "object" && "method" in parsed ? parsed.method : null;
-      if (method === "initialize" || method === "initialized") {
-        await operation;
-        continue;
-      }
-      inFlight.add(operation);
-      void operation.finally(() => inFlight.delete(operation));
-    }
-    await Promise.all(inFlight);
-    await writeChain;
-  } finally {
-    unsubscribe?.();
-  }
-}
-
-// ../../packages/agent-runtime/dist/provider-loop.js
-async function* providerRoundSequence(input) {
-  if (!Number.isInteger(input.maxRounds) || input.maxRounds < 1) {
-    throw new Error("Provider maxRounds must be a positive integer.");
-  }
-  for (let index = 0; index < input.maxRounds; index += 1) {
-    if (input.signal.aborted)
-      throw input.signal.reason ?? new Error("Provider loop interrupted.");
-    yield {
-      index,
-      requestId: `${input.turnId}:model:${index}`,
-      signal: input.signal
-    };
-  }
-}
-async function runProviderRoundLoop(input) {
-  for await (const round of providerRoundSequence(input)) {
-    const decision = await input.runRound(round);
-    if (decision.type === "complete")
-      return decision.result;
-  }
-  return input.onExhausted();
-}
-async function runProviderRound(input) {
-  let text = "";
-  let reasoningText = "";
-  let usage;
-  let continuation = null;
-  let finishReason;
-  const toolCallBatches = [];
-  try {
-    for await (const delta of input.stream) {
-      await input.onDelta?.(delta);
-      if (input.signal.aborted) {
-        throw input.signal.reason ?? new Error("Provider round interrupted.");
-      }
-      if (delta.text)
-        text += delta.text;
-      if (delta.reasoningText)
-        reasoningText += delta.reasoningText;
-      if (delta.usage !== void 0)
-        usage = delta.usage;
-      if (delta.continuation !== void 0)
-        continuation = delta.continuation;
-      if (delta.toolCalls)
-        toolCallBatches.push([...delta.toolCalls]);
-      if (delta.finishReason !== void 0)
-        finishReason = delta.finishReason;
-    }
-    const result = {
-      text,
-      reasoningText,
-      usage,
-      continuation,
-      toolCallBatches,
-      finishReason
-    };
-    await input.onCompleted?.(result);
-    return result;
-  } catch (error) {
-    await input.onFailed?.(error);
-    throw error;
-  }
-}
-
-// ../../packages/agent-runtime/dist/service.js
-var ThreadIdParamsSchema = external_exports.object({ threadId: external_exports.string().trim().min(1) }).passthrough();
-var ThreadStartParamsSchema = external_exports.object({ session: external_exports.unknown() }).strict();
-var TurnParamsSchema = ThreadIdParamsSchema.extend({ input: external_exports.unknown() });
-var InterruptParamsSchema = ThreadIdParamsSchema.extend({ reason: external_exports.string().trim().min(1).optional() });
-var ApprovalParamsSchema = external_exports.object({ approvalId: external_exports.string().trim().min(1), input: external_exports.unknown() }).strict();
-function createAgentRuntimeService(ports) {
-  const run = async (method, threadId, operation) => {
-    const startedAt = performance.now();
-    ports.telemetry?.({ method, phase: "started", threadId, durationMs: null, errorClass: null });
-    try {
-      const result = await operation();
-      ports.telemetry?.({
-        method,
-        phase: "completed",
-        threadId,
-        durationMs: performance.now() - startedAt,
-        errorClass: null
-      });
-      return result;
-    } catch (error) {
-      ports.telemetry?.({
-        method,
-        phase: "failed",
-        threadId,
-        durationMs: performance.now() - startedAt,
-        errorClass: error instanceof Error ? error.name : "UnknownError"
-      });
-      throw error;
-    }
-  };
-  const threadRead = async (params, method = "thread/read") => {
-    const { threadId } = ThreadIdParamsSchema.parse(params);
-    return run(method, threadId, async () => {
-      const [thread, turns, events] = await Promise.all([
-        ports.readThread(threadId),
-        ports.listTurns(threadId),
-        ports.listEvents(threadId)
-      ]);
-      return { thread, turns, events };
-    });
-  };
-  return {
-    capabilities: (params) => run("runtime/capabilities", null, () => ports.capabilities(params)),
-    threadStart: async (params) => run("thread/start", null, async () => ({
-      thread: await ports.createThread(ThreadStartParamsSchema.parse(params).session)
-    })),
-    threadResume: (params) => threadRead(params, "thread/resume"),
-    threadRead,
-    turnStart: async (params) => {
-      const input = TurnParamsSchema.parse(params);
-      return run("turn/start", input.threadId, async () => ({
-        turn: await ports.startTurn(input.threadId, input.input)
-      }));
-    },
-    turnSteer: async (params) => {
-      const input = TurnParamsSchema.parse(params);
-      return run("turn/steer", input.threadId, async () => {
-        if (ports.isTurnActive(input.threadId)) {
-          await ports.waitForTurnSettlement(input.threadId);
-        }
-        return { turn: await ports.startTurn(input.threadId, input.input) };
-      });
-    },
-    turnInterrupt: async (params) => {
-      const input = InterruptParamsSchema.parse(params);
-      return run("turn/interrupt", input.threadId, async () => ({
-        turn: await ports.interruptTurn(input.threadId, input.reason)
-      }));
-    },
-    approvalResolve: async (params) => {
-      const input = ApprovalParamsSchema.parse(params);
-      return run("approval/resolve", null, async () => ({
-        approval: await ports.resolveApproval(input.approvalId, input.input)
-      }));
-    },
-    userInputResolve: async (params) => {
-      const input = TurnParamsSchema.parse(params);
-      return run("userInput/resolve", input.threadId, async () => {
-        if (ports.isTurnActive(input.threadId)) {
-          await ports.waitForTurnSettlement(input.threadId);
-        }
-        return { turn: await ports.startTurn(input.threadId, input.input) };
-      });
-    },
-    harnessInspect: () => run("harness/inspect", null, () => ports.inspectHarness()),
-    harnessProposalReview: (params) => run("harness/proposalReview", null, () => ports.reviewHarnessProposal(params)),
-    harnessReview: (params) => run("harness/review", null, () => ports.reviewHarness(params)),
-    harnessAcceptEvaluationReview: (params) => run("harness/acceptEvaluationReview", null, () => ports.acceptHarnessEvaluationReview(params)),
-    harnessMaterializeEvaluationTaskset: (params) => run("harness/materializeEvaluationTaskset", null, () => ports.materializeHarnessEvaluationTaskset(params)),
-    harnessRunEvaluationBaseline: (params) => run("harness/runEvaluationBaseline", null, () => ports.runHarnessEvaluationBaseline(params)),
-    harnessValidate: () => run("harness/validate", null, () => ports.validateHarness()),
-    harnessBackgroundReview: (params) => run("harness/backgroundReview", null, () => ports.updateHarnessBackgroundReview(params)),
-    harnessDiff: (params) => run("harness/diff", null, () => ports.diffHarness(params)),
-    harnessRollback: (params) => run("harness/rollback", null, () => ports.rollbackHarness(params)),
-    refinerInspect: () => run("refiner/inspect", null, () => ports.inspectRefiner()),
-    refinerUpdate: (params) => run("refiner/update", null, () => ports.updateRefiner(params)),
-    refinerActivate: (params) => run("refiner/activate", null, () => ports.activateRefiner(params)),
-    refinerRollback: (params) => run("refiner/rollback", null, () => ports.rollbackRefiner(params)),
-    subscribe: ports.subscribeEvents && ports.eventNotification ? (listener) => ports.subscribeEvents((event) => listener(ports.eventNotification(event))) : void 0
-  };
-}
-
-// ../../packages/agent-runtime/dist/snapshots.js
-var HashSchema = external_exports.string().regex(/^[a-f0-9]{64}$/);
-var AgentEffectiveSurfaceSchema = external_exports.object({
-  harnessReleaseHash: HashSchema,
-  instructionsHash: HashSchema,
-  skillHashes: external_exports.record(external_exports.string(), HashSchema),
-  agentAssetHashes: external_exports.record(external_exports.string(), HashSchema),
-  toolCatalogHash: HashSchema,
-  memoryRevision: external_exports.number().int().nonnegative().nullable()
-}).strict();
-var AgentCheckpointSchema = external_exports.object({
-  protocolVersion: external_exports.string().trim().min(1),
-  threadId: external_exports.string().trim().min(1),
-  turnId: external_exports.string().trim().min(1),
-  harnessReleaseHash: HashSchema,
-  toolCatalogHash: HashSchema,
-  context: external_exports.record(external_exports.string(), external_exports.unknown()),
-  pendingInteraction: external_exports.record(external_exports.string(), external_exports.unknown()).nullable(),
-  usage: external_exports.record(external_exports.string(), external_exports.unknown())
-}).strict();
-function checkpointHash(checkpoint) {
-  return canonicalHash(AgentCheckpointSchema.parse(checkpoint));
-}
-function materializeAgentPrompt(input) {
-  return [
-    input.system,
-    ...input.harnessInstructions,
-    ...input.skillInstructions,
-    ...input.hostInstructions ?? []
-  ].map((part) => part.trim()).filter(Boolean).join("\n\n");
-}
-
-// ../../packages/agent-runtime/dist/tools.js
-function createAgentToolCatalogProjection(definitions) {
-  const names = /* @__PURE__ */ new Set();
-  const tools = [...definitions].map((definition) => {
-    const name = definition.name.trim();
-    if (!name)
-      throw new Error("Agent tool names cannot be empty.");
-    if (names.has(name))
-      throw new Error(`Duplicate agent tool: ${name}.`);
-    names.add(name);
-    if (!definition.unavailableReason && !definition.executorAvailable) {
-      throw new Error(`Agent tool ${name} is declared as available without an executor.`);
-    }
-    return { ...definition, name };
-  }).sort((left, right) => left.name.localeCompare(right.name));
-  const modelTools = tools.filter((tool) => !tool.unavailableReason).map((tool) => ({
-    name: tool.name,
-    description: tool.description,
-    inputSchema: tool.inputSchema
-  }));
-  const capabilities = tools.map((tool) => ({
-    name: tool.name,
-    displayLabel: tool.displayLabel ?? tool.name,
-    placement: tool.placement,
-    available: !tool.unavailableReason,
-    unavailableReason: tool.unavailableReason ?? null
-  }));
-  return {
-    byName: new Map(tools.map((tool) => [tool.name, tool])),
-    tools,
-    modelTools,
-    capabilities,
-    hash: canonicalHash({ modelTools, capabilities })
-  };
-}
-async function executeProjectedAgentTool(catalog, input) {
-  const definition = catalog.byName.get(input.name);
-  if (!definition)
-    throw new Error(`Unknown agent tool: ${input.name}.`);
-  if (definition.unavailableReason) {
-    throw new Error(`Agent tool ${input.name} is unavailable: ${definition.unavailableReason}`);
-  }
-  if (!definition.execute)
-    throw new Error(`Agent tool ${input.name} has no executor.`);
-  const validated = definition.validateArguments ? definition.validateArguments(input.arguments) : input.arguments;
-  return definition.execute(validated, input.context);
-}
-
-// ../../packages/app-server/dist/index.js
-function createAppServer(input) {
-  return attachAppServer({
-    runtime: createAgentRuntimeService(input.ports),
-    close: input.close
-  });
-}
-function attachAppServer(input) {
-  let closed = false;
-  return {
-    runtime: input.runtime,
-    close: async () => {
-      if (closed)
-        return;
-      closed = true;
-      await input.close?.();
-    }
-  };
-}
-async function runAppServerJsonl(input) {
-  try {
-    await runAgentJsonlServer({
-      host: input.appServer.runtime,
-      readable: input.readable,
-      writable: input.writable
-    });
-  } finally {
-    await input.appServer.close();
-  }
-}
-
-// ../server/src/paths.ts
-import { randomBytes } from "node:crypto";
-function appDataDir() {
-  return resolveOpenPondHome();
-}
-function providersConfigPath(storeDir) {
-  return storagePaths(storeDir).config;
-}
-function providerSecretsConfigPath(storeDir) {
-  return storagePaths(storeDir).credentials;
-}
-function providerSecretsKeyPath(storeDir) {
-  return storagePaths(storeDir).key;
-}
-async function ensureCapabilityToken(storeDir) {
-  const tokenFile = storagePaths(storeDir).token;
-  return withFileLock(tokenFile, async () => {
-    const existing = (await readOptionalFile(tokenFile))?.trim();
-    const token = process.env.OPENPOND_APP_TOKEN || existing || randomBytes(32).toString("base64url");
-    if (token !== existing) await atomicWriteFile(tokenFile, token);
-    return { token, tokenFile };
-  });
-}
-
-export {
-  onStartupFailure,
-  ownHomeRuntime,
-  publishRuntimeEndpoint,
-  canonicalHash,
-  agentCompactionDecision,
-  runAgentCompaction,
-  runAgentCompactionProgram,
-  CanonicalAgentEventSchema,
-  canonicalEventHash,
-  AGENT_PROTOCOL_VERSION,
-  AGENT_RPC_METHODS,
-  runProviderRoundLoop,
-  runProviderRound,
-  AgentCheckpointSchema,
-  checkpointHash,
-  materializeAgentPrompt,
-  createAgentToolCatalogProjection,
-  executeProjectedAgentTool,
-  createAppServer,
-  runAppServerJsonl,
-  appDataDir,
-  providersConfigPath,
-  providerSecretsConfigPath,
-  providerSecretsKeyPath,
-  ensureCapabilityToken
-};