@springbrand/agent-runtime 0.2.0-alpha.72 → 0.3.0-alpha.2

package/src/harness/session-harness.ts

@@ -0,0 +1,481 @@
+import {
+  AgentHarness,
+  type AgentMessage,
+  type AgentHarness as PiAgentHarness,
+  type AgentHarnessOptions,
+  type AgentLane,
+  type DriveOutcome,
+  type DriveOptions,
+  type OpenOperation,
+  type OperationRequest,
+} from "@earendil-works/pi-agent-core";
+import type { Context } from "@earendil-works/pi-agent-core/harness/context";
+import type { Entry, SettledAssistantMessage } from "@earendil-works/pi-agent-core/harness/session";
+import {
+  isModelStreamStallMessage,
+  isOpenRouterServerToolTimeout,
+  isRecoverableAssistantError,
+} from "../models";
+import { projectToolOutputForModel } from "../context/memory/budget/gate";
+
+export interface SessionHarnessLimits {
+  /** Complete model turns committed before one Worker instance releases. */
+  modelTurnsPerSlice?: number;
+  /** Complete working turns allowed before the no-tool final response. */
+  maxModelTurns?: number;
+  /** Maximum text turns allowed after the working or Tool failure budget. */
+  maxWrapUpModelTurns?: number;
+  wrapUpInstruction?: string;
+}
+
+export interface SessionHarnessOptions<TContext extends object | undefined>
+  extends AgentHarnessOptions<TContext> {
+  limits?: SessionHarnessLimits;
+  modelToolResultExemptions?: readonly string[];
+  /** Base provider Session identity, retained except after a server Tool timeout. */
+  modelSessionId?: string;
+}
+
+export type SessionHarnessRunResult = DriveOutcome | {
+  kind: "released";
+  operationId: string;
+  reason: "slice" | "budget" | "tool-failure" | "approval" | "interaction";
+};
+
+const DEFAULT_MODEL_TURNS_PER_SLICE = 30;
+const DEFAULT_MAX_MODEL_TURNS = 300;
+const DEFAULT_MAX_WRAP_UP_MODEL_TURNS = 2;
+const RECOVERY_MAX_FAILURES = 5;
+const STALL_MAX_FAILURES = 3;
+const SERVER_TOOL_TIMEOUT_MAX_FAILURES = 2;
+const DEFAULT_WRAP_UP_INSTRUCTION =
+  "Finish this request now without using tools. Summarize the completed work and any remaining limitation.";
+const TOOL_FAILURE_WRAP_UP_INSTRUCTION =
+  "This turn reached its tool failure limit. Stop calling tools now. Reply with a final message that explains what failed and the exact next step the user should take. Do not start new work.";
+const MAX_TOOL_RETRIES = 3;
+const TURN_FAILURE_CEILING = 8;
+
+function canonicalJson(value: unknown): string {
+  if (Array.isArray(value)) {
+    return `[${value.map(canonicalJson).join(",")}]`;
+  }
+  if (value !== null && typeof value === "object") {
+    return `{${Object.entries(value)
+      .filter(([, item]) => item !== undefined)
+      .sort(([left], [right]) => left.localeCompare(right))
+      .map(([key, item]) => `${JSON.stringify(key)}:${canonicalJson(item)}`)
+      .join(",")}}`;
+  }
+  return JSON.stringify(value) ?? "null";
+}
+
+function toolCallKey(toolName: string, args: unknown): string {
+  return `${toolName}\0${canonicalJson(args)}`;
+}
+
+function projectToolResultsForModel(
+  messages: readonly AgentMessage[],
+  exemptions: ReadonlySet<string>,
+): AgentMessage[] {
+  let changed = false;
+  const projected = messages.map((message) => {
+    if (
+      message.role !== "toolResult" ||
+      exemptions.has(message.toolName)
+    ) return message;
+    const payload = { content: message.content, details: message.details };
+    const next = projectToolOutputForModel(payload) as typeof payload;
+    if (next === payload) return message;
+    changed = true;
+    return { ...message, content: next.content, details: next.details };
+  });
+  return changed ? projected : [...messages];
+}
+
+function deferred<T>(): {
+  promise: Promise<T>;
+  resolve(value: T): void;
+} {
+  let resolve!: (value: T) => void;
+  const promise = new Promise<T>((done) => {
+    resolve = done;
+  });
+  return { promise, resolve };
+}
+
+function positiveInteger(value: number | undefined, fallback: number): number {
+  const resolved = value ?? fallback;
+  if (!Number.isInteger(resolved) || resolved <= 0) {
+    throw new Error("Harness model turn limits must be positive integers");
+  }
+  return resolved;
+}
+
+/**
+ * The only adapter that owns a live Pi AgentHarness for a Session.
+ *
+ * Submission and Cloudflare lifecycle code may accept, drive, abort, watch, or
+ * close through this object. It deliberately does not know how Host config or
+ * business repositories are loaded.
+ */
+export class SessionHarness<TContext extends object | undefined> {
+  private _openOperation: OpenOperation | null;
+  private readonly modelTurnsPerSlice: number;
+  private readonly maxModelTurns: number;
+  private readonly maxWrapUpModelTurns: number;
+  private readonly modelSessionId: string | undefined;
+  private readonly wrapUpInstruction: string;
+  private readonly configuredToolNames: string[];
+  private readonly modelToolResultExemptions: ReadonlySet<string>;
+  private readonly toolFailures = new Map<string, number>();
+  private totalToolFailures = 0;
+  private toolFailureWrapUp = false;
+  private toolFailureWrapUpAt: number | undefined;
+  private operationStartTip: string | null = null;
+  private turnsAtOpen = 0;
+  private wrappingUp = false;
+  private releaseReason:
+    | "slice"
+    | "budget"
+    | "tool-failure"
+    | "approval"
+    | "interaction"
+    | undefined;
+  private readonly releaseRequest = deferred<"approval" | "interaction">();
+  private readonly activeTools = new Set<string>();
+  private readonly toolsIdle = new Set<() => void>();
+
+  private constructor(
+    readonly harness: PiAgentHarness<TContext>,
+    readonly lane: AgentLane,
+    openOperation: OpenOperation | null,
+    options: SessionHarnessOptions<TContext>,
+  ) {
+    this._openOperation = openOperation;
+    this.modelTurnsPerSlice = positiveInteger(
+      options.limits?.modelTurnsPerSlice,
+      DEFAULT_MODEL_TURNS_PER_SLICE,
+    );
+    this.maxModelTurns = positiveInteger(
+      options.limits?.maxModelTurns,
+      DEFAULT_MAX_MODEL_TURNS,
+    );
+    this.maxWrapUpModelTurns = positiveInteger(
+      options.limits?.maxWrapUpModelTurns,
+      DEFAULT_MAX_WRAP_UP_MODEL_TURNS,
+    );
+    this.modelSessionId = options.modelSessionId;
+    this.wrapUpInstruction = options.limits?.wrapUpInstruction ??
+      DEFAULT_WRAP_UP_INSTRUCTION;
+    this.configuredToolNames = options.activeToolNames ??
+      (options.tools ?? []).map(({ name }) => name);
+    this.modelToolResultExemptions = new Set(
+      options.modelToolResultExemptions ?? [],
+    );
+  }
+
+  private async operationEntries(context: Context): Promise<Entry[]> {
+    const entries = await this.lane.findEntries({
+      ...(this.operationStartTip === null ? {} : { stopAtId: this.operationStartTip }),
+      type: "message",
+      order: "oldestFirst",
+    }, context);
+    return entries.filter(({ id }) => id !== this.operationStartTip);
+  }
+
+  private async restoreToolGovernance(context: Context): Promise<void> {
+    this.toolFailures.clear();
+    this.totalToolFailures = 0;
+    this.toolFailureWrapUp = false;
+    this.toolFailureWrapUpAt = undefined;
+    let turns = 0;
+    for (const entry of await this.operationEntries(context)) {
+      if (entry.type !== "message") continue;
+      const message = entry.message;
+      if (message.role === "assistant") {
+        turns += 1;
+        continue;
+      }
+      this.recordCanonicalToolOutcome(entry);
+      if (this.toolFailureWrapUp) this.toolFailureWrapUpAt ??= turns;
+    }
+  }
+
+  private recordCanonicalToolOutcome(entry: Entry): void {
+    if (entry.type !== "message" || entry.message.role !== "toolResult") return;
+    const message = entry.message;
+    if (entry.toolExecution?.status === "executed") {
+      this.recordToolOutcome(message.toolName, entry.toolExecution.args, message.isError);
+    } else if (entry.toolExecution?.status === "blocked" && entry.toolExecution.args !== undefined) {
+      const key = toolCallKey(message.toolName, entry.toolExecution.args);
+      if ((this.toolFailures.get(key) ?? 0) >= MAX_TOOL_RETRIES) this.toolFailureWrapUp = true;
+    }
+  }
+
+  private recordToolOutcome(toolName: string, args: unknown, isError: boolean): void {
+    const key = toolCallKey(toolName, args);
+    if (!isError) {
+      this.toolFailures.delete(key);
+      return;
+    }
+    this.toolFailures.set(key, (this.toolFailures.get(key) ?? 0) + 1);
+    this.totalToolFailures += 1;
+    if (this.totalToolFailures >= TURN_FAILURE_CEILING) this.toolFailureWrapUp = true;
+  }
+
+  private async shouldRetry(
+    message: SettledAssistantMessage,
+    context: Context,
+    recovery: boolean,
+  ): Promise<boolean> {
+    const stalled = isModelStreamStallMessage(message.errorMessage);
+    const serverToolTimeout = isOpenRouterServerToolTimeout(message);
+    if (!recovery && !stalled && !serverToolTimeout && !isRecoverableAssistantError(message)) return false;
+    const failures = 1 + (await this.operationEntries(context)).filter((entry) =>
+      entry.type === "message" && entry.message.role === "assistant" && entry.message.stopReason === "error"
+    ).length;
+    return failures < (stalled ? STALL_MAX_FAILURES
+      : serverToolTimeout ? SERVER_TOOL_TIMEOUT_MAX_FAILURES : RECOVERY_MAX_FAILURES);
+  }
+
+  private async shouldFinishRun(context: Context): Promise<boolean> {
+    const wrapUpAt = Math.min(this.maxModelTurns, this.toolFailureWrapUpAt ?? Infinity);
+    return await this.completedModelTurns(context) >= wrapUpAt + this.maxWrapUpModelTurns;
+  }
+
+  get openOperation(): OpenOperation | null {
+    return this._openOperation;
+  }
+
+  static async open<TContext extends object | undefined>(
+    options: SessionHarnessOptions<TContext>,
+    context: Context,
+  ): Promise<SessionHarness<TContext>> {
+    const {
+      limits: _limits,
+      modelToolResultExemptions: _modelToolResultExemptions,
+      modelSessionId: _modelSessionId,
+      ...harnessOptions
+    } = options;
+    let runtime!: SessionHarness<TContext>;
+    const { harness, open } = await AgentHarness.create({
+      ...harnessOptions,
+      retry: options.retry ?? { enabled: true, maxRetries: RECOVERY_MAX_FAILURES - 1, baseDelayMs: 1_000 },
+      recoveryPolicy: async (event, policyContext) =>
+        await runtime.shouldRetry(event.message, policyContext, event.recovery) &&
+        (options.recoveryPolicy === undefined || await options.recoveryPolicy(event, policyContext)),
+      shouldFinishRun: async (event, policyContext) =>
+        await runtime.shouldFinishRun(policyContext) ||
+        (options.shouldFinishRun !== undefined && await options.shouldFinishRun(event, policyContext)),
+    }, context);
+    const foreign = open.find((operation) => operation.lane !== "main");
+    if (foreign) {
+      await harness.close(context);
+      throw new Error(`Unexpected open Harness lane: ${foreign.lane}`);
+    }
+    if (open.length > 1) {
+      await harness.close(context);
+      throw new Error("Session has multiple open operations on the main lane");
+    }
+    runtime = new SessionHarness(
+      harness,
+      await harness.lane("main", context),
+      open[0] ?? null,
+      options,
+    );
+    await runtime.install(context);
+    return runtime;
+  }
+
+  private async install(context: Context): Promise<void> {
+    if (this._openOperation) {
+      const watch = await this.lane.watch(context);
+      this.operationStartTip = watch.snapshot.operation?.fromTipId ?? null;
+      watch.unsubscribe();
+      await this.restoreToolGovernance(context);
+      this.turnsAtOpen = await this.completedModelTurns(context);
+      if (this.turnsAtOpen >= this.maxModelTurns) {
+        this.wrappingUp = true;
+      }
+      if (this.wrappingUp || this.toolFailureWrapUp) {
+        await this.lane.setActiveTools([], context);
+      }
+    }
+    this.harness.hooks.on("before_request", async (event, requestContext) => {
+      if (event.step !== "assistant") return;
+      const resets = (await this.operationEntries(requestContext)).filter((entry) =>
+        entry.type === "message" && entry.message.role === "assistant" && isOpenRouterServerToolTimeout(entry.message)
+      ).length;
+      if (resets > 0) {
+        return { streamOptions: { sessionId: `${this.modelSessionId ?? event.runId}:server-tool-recovery:${resets}` } };
+      }
+      if (this.modelSessionId !== undefined) return { streamOptions: { sessionId: this.modelSessionId } };
+    });
+    this.harness.hooks.on("transform_context", (event) => {
+      const messages = projectToolResultsForModel(
+        event.messages,
+        this.modelToolResultExemptions,
+      );
+      const instruction = this.toolFailureWrapUp
+        ? TOOL_FAILURE_WRAP_UP_INSTRUCTION
+        : this.wrappingUp
+          ? this.wrapUpInstruction
+          : undefined;
+      return {
+        messages: instruction
+          ? [...messages, {
+              role: "user" as const,
+              content: instruction,
+              timestamp: 1,
+            }]
+          : messages,
+      };
+    });
+    this.harness.hooks.on("before_tool", (event) => {
+      if (this.toolFailureWrapUp) {
+        return {
+          block: {
+            reason: "This turn reached its tool failure limit. Stop calling tools now.",
+            terminate: true,
+          },
+        };
+      }
+      if (
+        (this.toolFailures.get(toolCallKey(event.toolName, event.args)) ?? 0) <
+          MAX_TOOL_RETRIES
+      ) return;
+      this.toolFailureWrapUp = true;
+      return {
+        block: {
+          reason:
+            `This exact ${event.toolName} call has already failed ${MAX_TOOL_RETRIES} times — change the input or approach instead of retrying it verbatim.`,
+        },
+      };
+    });
+    this.harness.events.on("entry_added", (event) => {
+      if (event.lane === this.lane.name) this.recordCanonicalToolOutcome(event.entry);
+    });
+    this.harness.events.on("turn_end", async (_event, eventContext) => {
+      const total = await this.completedModelTurns(eventContext);
+      if (this.toolFailureWrapUp && this.toolFailureWrapUpAt === undefined) {
+        this.toolFailureWrapUpAt = total;
+        this.releaseReason = "tool-failure";
+      } else if (this.wrappingUp || this.toolFailureWrapUp) {
+        return;
+      } else if (total >= this.maxModelTurns) {
+        this.releaseReason = "budget";
+      } else if (total - this.turnsAtOpen >= this.modelTurnsPerSlice) {
+        this.releaseReason = "slice";
+      } else {
+        return;
+      }
+      await this.harness.close(eventContext);
+    });
+    this.harness.events.on("tool_start", (event) => {
+      this.activeTools.add(event.toolCallId);
+    });
+    this.harness.events.on("tool_end", (event) => {
+      this.activeTools.delete(event.toolCallId);
+      if (this.activeTools.size === 0) {
+        for (const resolve of this.toolsIdle) resolve();
+        this.toolsIdle.clear();
+      }
+    });
+  }
+
+  /** Ask the active drive to detach after already-started parallel Tools settle. */
+  requestHumanRelease(reason: "approval" | "interaction"): void {
+    this.releaseRequest.resolve(reason);
+  }
+
+  private async waitForToolsToSettle(): Promise<void> {
+    if (this.activeTools.size === 0) return;
+    await new Promise<void>((resolve) => this.toolsIdle.add(resolve));
+  }
+
+  private async completedModelTurns(context: Context): Promise<number> {
+    return (await this.operationEntries(context)).filter((entry) =>
+      entry.type === "message" && entry.message.role === "assistant"
+    ).length;
+  }
+
+  async run(
+    request: OperationRequest | undefined,
+    context: Context,
+    driveOptions: Omit<DriveOptions, "operationId"> = {},
+  ): Promise<SessionHarnessRunResult> {
+    let operationId = this.openOperation?.operationId;
+    if (request) {
+      if (operationId) {
+        throw new Error(`Harness operation ${operationId} is already open`);
+      }
+      this.operationStartTip = await this.lane.getTipId(context);
+      this.turnsAtOpen = 0;
+      this.wrappingUp = false;
+      this.toolFailures.clear();
+      this.totalToolFailures = 0;
+      this.toolFailureWrapUp = false;
+      this.toolFailureWrapUpAt = undefined;
+      this.releaseReason = undefined;
+      await this.lane.setActiveTools(this.configuredToolNames, context);
+      const admission = await this.lane.accept(request, context);
+      if (!admission.ok) throw admission.error;
+      operationId = admission.value.operationId;
+      this._openOperation = {
+        lane: "main",
+        operationId,
+        kind: admission.value.kind,
+        startedAt: admission.value.startedAt,
+      };
+    }
+    if (!operationId) throw new Error("No Harness operation to drive");
+    try {
+      const driving = this.lane.drive({ ...driveOptions, operationId }, context);
+      const winner = await Promise.race([
+        driving.then((result) => ({ kind: "drive" as const, result })),
+        this.releaseRequest.promise.then((reason) => ({
+          kind: "release" as const,
+          reason,
+        })),
+      ]);
+      if (winner.kind === "release") {
+        this.releaseReason = winner.reason;
+        await this.waitForToolsToSettle();
+        await this.harness.close(context);
+        await driving.catch(() => undefined);
+        return { kind: "released", operationId, reason: winner.reason };
+      }
+      const result = winner.result;
+      if (!result.ok) throw result.error;
+      if (result.value.kind === "settled") {
+        this._openOperation = null;
+      }
+      return result.value;
+    } catch (error) {
+      if (
+        this.releaseReason && error instanceof Error &&
+        error.name === "HarnessClosed"
+      ) {
+        return { kind: "released", operationId, reason: this.releaseReason };
+      }
+      throw error;
+    }
+  }
+
+  async requestAbort(operationId: string, context: Context): Promise<boolean> {
+    const result = await this.lane.requestAbort(operationId, context);
+    if (!result.ok) throw result.error;
+    return result.value.newlyRequested;
+  }
+
+  close(context: Context): Promise<void> {
+    return this.harness.close(context);
+  }
+}
+
+export function openSessionHarness<TContext extends object | undefined>(
+  options: SessionHarnessOptions<TContext>,
+  context: Context,
+): Promise<SessionHarness<TContext>> {
+  return SessionHarness.open(options, context);
+}

package/src/harness/submission-operation.ts

@@ -0,0 +1,49 @@
+import type { OperationRequest, OperationResultRecord } from "@earendil-works/pi-agent-core";
+import type { Context } from "@earendil-works/pi-agent-core/harness/context";
+import type { PiCanonicalUserInput } from "../conversation/message/contract";
+import type { StoredSubmission } from "../submission/repository";
+import type { SessionHarness } from "./session-harness";
+
+/** Recover the stable operation before accepting new input or navigating its branch. */
+export async function prepareSubmissionOperation(
+  runtime: SessionHarness<object | undefined>,
+  submission: Pick<StoredSubmission, "submissionId" | "queuedInputJson" | "regenerateMessageId">,
+  regenerationTarget: (messageId: string) => string | null,
+  context: Context,
+): Promise<{ kind: "run"; request?: OperationRequest } | { kind: "settled"; outcome: OperationResultRecord }> {
+  const id = submission.submissionId;
+  const navigationId = `${id}:regenerate`;
+  if (runtime.openOperation?.operationId === navigationId) {
+    const navigation = await runtime.run(undefined, context);
+    if (navigation.kind !== "settled" || navigation.outcome.status !== "completed") {
+      throw new Error("Could not recover the regeneration branch navigation");
+    }
+  }
+  if (runtime.openOperation) {
+    if (runtime.openOperation.operationId !== id) {
+      throw new Error(`Submission ${id} does not own the open Harness operation`);
+    }
+    return { kind: "run" };
+  }
+  const watch = await runtime.lane.watch(context);
+  const previous = watch.snapshot.lastResult;
+  watch.unsubscribe();
+  if (previous?.operationId === id) return { kind: "settled", outcome: previous };
+  if (!submission.queuedInputJson) {
+    throw new Error(`Submission ${id} has no open Harness operation or queued input`);
+  }
+  const prompt = JSON.parse(submission.queuedInputJson) as PiCanonicalUserInput;
+  if (prompt.role !== "user") throw new Error("Queued SpringBrand user message is invalid");
+  if (submission.regenerateMessageId && previous?.operationId !== navigationId) {
+    const navigation = await runtime.run({
+      kind: "navigation",
+      operationId: navigationId,
+      targetId: regenerationTarget(submission.regenerateMessageId),
+      options: { summarize: false },
+    }, context);
+    if (navigation.kind !== "settled" || navigation.outcome.status !== "completed") {
+      throw new Error("Could not navigate to the regeneration branch");
+    }
+  }
+  return { kind: "run", request: { kind: "prompt", operationId: id, prompt } };
+}

package/src/index.ts

@@ -9,14 +9,13 @@
  * - `Session` 是本项目的聊天会话边界，由一个 `UniversalAgent` facet 承载。
  * - `Turn` 是 Session 中从一次提示被接纳到输出终态的一次执行。
  * - `Host` 是承载 Runtime 的 Cloudflare Agent，并负责提供生命周期、存储和网络边界。
- * - `Kernel` 是 Runtime 内部连接 Cloudflare Agent 生命周期与 Pi 执行的核心实现。
- * - `Pi` 是负责模型、Tool 循环和 canonical transcript 的执行层。
+ * - `Harness` 是 Pi 提供的唯一模型、Tool 与 canonical transcript 执行引擎。
+ * - `Cloudflare adapter` 只连接 Durable Object 生命周期、RPC 和 Harness。
  * - `Workspace` 是 Tool 可以读取或修改的受控文件系统视图。
  * - `Memory` 是可跨 Turn 读取或写入的长期上下文能力。
  * - `Tool` 是模型在 Turn 中可以调用的一项受控能力。
  * - `Tool Candidate` 是尚未完成治理和编译的内部 Tool 定义。
- * - `Tool Settlement` 是 Tool 调用完成后写回模型循环的统一结果。
- * - `Governance` 是对 Tool 可见性、审批和执行条件的集中约束。
+ * - `Tool decision` 是宿主持久化的审批或交互事实；Pi 仍保存执行位置与 Tool 结果。
  * - `Artifact` 是 Runtime 保存并对外引用的结构化执行产物。
  * - `Extension` 是 Pi 在装配期加载、并在 Turn 中参与执行的扩展模块。
  * - `SubAgent` 是由父 Agent 发起、但拥有独立执行上下文的子任务执行者。
@@ -38,21 +37,21 @@
  * Snapshot 不允许替换已选集合，但不承诺把每个 Port 的内部对象深冻结。
  *
  * 正常调用顺序是 `assemble → validate → freeze → guard → commit`。
- * Runtime 独占跨能力校验和原子提交。
+ * Config 装配独占跨能力校验，Harness 独占执行状态提交。
  *
  * @packageDocumentation
  */
-export * from "./kernel/bindings";
-export * from "./kernel/extensions";
-export * from "./kernel/profile";
-export * from "./kernel/receipts";
-export * from "./kernel/runtime-config";
+export * from "./config/ports";
+export * from "./context/extension/contracts";
+export * from "./config/profile";
+export * from "./submission/contracts";
+export * from "./config/runtime-config";
 export * from "./telemetry";
-export type { RuntimeAssemblyView } from "./kernel/runtime-assembly-view";
-export * from "./runtime-agent";
-export type { ToolInteractionResponsePreparation } from "./runtime";
-export * from "./kernel/state";
-export * from "./workspace-versioning";
+export type { RuntimeAssemblyView } from "./config/assembly-view";
+export * from "./adapter/cloudflare/define-agent";
+export type { ToolInteractionResponsePreparation } from "./adapter/cloudflare/agent";
+export * from "./conversation/state";
+export * from "./tools/workspace-versioning";
 export * from "./lib/execution-level";
 export type {
   RuntimeAssemblyInput,
@@ -61,8 +60,8 @@ export type {
   RuntimeProfileContribution,
   RuntimeSkillContribution,
   RuntimeToolSurfacePolicy,
-} from "./runtime-assembler";
-export { assembleRuntimeSnapshot } from "./runtime-assembler";
+} from "./config/assembler";
+export { assembleRuntimeSnapshot } from "./config/assembler";
 export type {
   ResolvedConnectors,
   ResolvedResources,
@@ -71,7 +70,7 @@ export type {
   RuntimeSkillBodyTransform,
   RuntimeToolBindings,
   ToolAssemblyResult,
-} from "./runtime-definition";
+} from "./config/definition";
 export type { ModelOption } from "./lib/model-catalog";
 export {
   assembleSubagentPrompt,
@@ -85,66 +84,62 @@ export type {
 } from "./lib/host-actions";
 export {
   AGENT_TYPES,
-} from "./layers/orchestration/subagents/agent-types/registry";
+} from "./tools/subagent-types/registry";
 export type {
   AgentType,
-} from "./layers/orchestration/subagents/agent-types/contract";
-export { withProviderRetry } from "./pi/runtime-adapter";
-export { compilePiTools } from "./pi/tool";
+} from "./tools/subagent-types/contract";
 export type {
-  CompilePiToolsOptions,
   PiToolCandidate,
-  SettledPiToolCall,
   ToolExposureMode,
-} from "./pi/tool";
-export { basePiToolCandidates } from "./pi/tool";
-export { createPiDeclaredToolCandidate } from "./pi/tool";
+} from "./tools";
+export { basePiToolCandidates } from "./tools";
+export { createPiDeclaredToolCandidate } from "./tools";
 export type {
   PiDeclaredTool,
   PiDeclaredToolCallContext,
   PiDeclaredToolPolicy,
-} from "./pi/tool";
-export { memoryPiToolCandidate } from "./pi/tool";
-export { GET_TIME_TOOL_NAME, getTimePiToolCandidate } from "./pi/tool";
-export { schedulePiToolCandidates } from "./pi/tool";
+} from "./tools";
+export { memoryPiToolCandidate } from "./tools";
+export { GET_TIME_TOOL_NAME, getTimePiToolCandidate } from "./tools";
+export { schedulePiToolCandidates } from "./tools";
 export {
   sandboxPiToolCandidates,
   workspaceRevisionPiToolCandidate,
   workspacePiToolCandidates,
-} from "./pi/tool";
-export { subagentPiToolCandidates } from "./pi/tool";
-export { skillPiToolCandidates } from "./pi/tool";
-export type { PiSkillBinding } from "./pi/tool";
+} from "./tools";
+export { subagentPiToolCandidates } from "./tools";
+export { skillPiToolCandidates } from "./tools";
+export type { PiSkillBinding } from "./tools";
 export {
   BROWSER_EXECUTE_TOOL_NAME,
   browserExecutionPiToolCandidate,
   codeExecutionPiToolCandidate,
-} from "./pi/tool";
+} from "./tools";
 export {
   createBrowserExecutionFactory,
   createWorkspaceCodeExecutionFactory,
-} from "./pi/tool";
+} from "./tools";
 export {
   assemblePiExtensions,
   loadPiExtension,
-} from "./pi/assembly";
+} from "./context";
 export type {
   TemporaryAgentApprovalDecision,
   TemporaryAgentApprovalRequest,
   TemporaryAgentLaunch,
   TemporaryAgentRequest,
   TemporaryAgentRunContext,
-} from "./layers/orchestration/temporary-agent/core";
-export { TEMPORARY_AGENT_LAUNCH_KEY } from "./layers/orchestration/temporary-agent/core";
+} from "./tools/temporary-agent/core";
+export { TEMPORARY_AGENT_LAUNCH_KEY } from "./tools/temporary-agent/core";
 export {
   temporaryAgentExtensionIsSafe,
   temporaryAgentToolAllowed,
-} from "./layers/orchestration/temporary-agent/runner";
+} from "./tools/temporary-agent/runner";
 export {
   createTemporaryAgentWorkspace,
-} from "./layers/orchestration/temporary-agent/workspace";
+} from "./tools/temporary-agent/workspace";
 export {
   createPiModels,
   modelRequestUrl,
   resolvePiModel,
-} from "./pi/runtime-adapter/models";
+} from "./models";