@wular/coder 0.4.11 → 0.4.13

package/dist/{types-C6NAqGqn.d.ts → index-ChcxzFdB.d.ts}

@@ -1,176 +1,176 @@
-import * as z from "zod/mini";
+import { AsyncLocalStorage } from "node:async_hooks";
+import * as z from "zod";
+import * as z$1 from "zod/mini";
 //#region src/core/config.d.ts
-declare const engineSchema: z.ZodMiniEnum<{
+declare const engineSchema: z$1.ZodMiniEnum<{
+  custom: "custom";
   codex: "codex";
   claude: "claude";
-  custom: "custom";
 }>;
-declare const effortSchema: z.ZodMiniEnum<{
+declare const effortSchema: z$1.ZodMiniEnum<{
   low: "low";
   medium: "medium";
   high: "high";
 }>;
-declare const permissionSchema: z.ZodMiniEnum<{
+declare const permissionSchema: z$1.ZodMiniEnum<{
   "read-only": "read-only";
   "workspace-write": "workspace-write";
   auto: "auto";
 }>;
-declare const customModelSchema: z.ZodMiniObject<{
-  baseUrl: z.ZodMiniURL;
-  model: z.ZodMiniString<string>;
-  envKey: z.ZodMiniOptional<z.ZodMiniString<string>>;
-  wireApi: z.ZodMiniOptional<z.ZodMiniEnum<{
+declare const customModelSchema: z$1.ZodMiniObject<{
+  baseUrl: z$1.ZodMiniURL;
+  model: z$1.ZodMiniString<string>;
+  envKey: z$1.ZodMiniOptional<z$1.ZodMiniString<string>>;
+  wireApi: z$1.ZodMiniOptional<z$1.ZodMiniEnum<{
     chat: "chat";
     responses: "responses";
   }>>;
-  disabled: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
-}, z.core.$strict>;
+  contextWindow: z$1.ZodMiniOptional<z$1.ZodMiniNumber<number>>;
+  disabled: z$1.ZodMiniOptional<z$1.ZodMiniBoolean<boolean>>;
+}, z$1.core.$strict>;
 /** The merged, effective shape (everything present after DEFAULT_CONFIG). */
-declare const mcpEntrySchema: z.ZodMiniObject<{
-  connection: z.ZodMiniOptional<z.ZodMiniString<string>>;
-  command: z.ZodMiniOptional<z.ZodMiniString<string>>;
-  args: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
-  env: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
-  url: z.ZodMiniOptional<z.ZodMiniString<string>>;
-  type: z.ZodMiniOptional<z.ZodMiniEnum<{
+declare const mcpEntrySchema: z$1.ZodMiniObject<{
+  connection: z$1.ZodMiniOptional<z$1.ZodMiniString<string>>;
+  command: z$1.ZodMiniOptional<z$1.ZodMiniString<string>>;
+  args: z$1.ZodMiniOptional<z$1.ZodMiniArray<z$1.ZodMiniString<string>>>;
+  env: z$1.ZodMiniOptional<z$1.ZodMiniRecord<z$1.ZodMiniString<string>, z$1.ZodMiniString<string>>>;
+  url: z$1.ZodMiniOptional<z$1.ZodMiniString<string>>;
+  type: z$1.ZodMiniOptional<z$1.ZodMiniEnum<{
     stdio: "stdio";
     http: "http";
-    sse: "sse";
   }>>;
-  headers: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
-  tools: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
-  description: z.ZodMiniOptional<z.ZodMiniString<string>>;
-}, z.core.$strict>;
-declare const effectiveConfigSchema: z.ZodMiniObject<{
-  conversationCompactTokens: z.ZodMiniNumber<number>;
-  chain: z.ZodMiniArray<z.ZodMiniEnum<{
+  headers: z$1.ZodMiniOptional<z$1.ZodMiniRecord<z$1.ZodMiniString<string>, z$1.ZodMiniString<string>>>;
+  tools: z$1.ZodMiniOptional<z$1.ZodMiniArray<z$1.ZodMiniString<string>>>;
+  description: z$1.ZodMiniOptional<z$1.ZodMiniString<string>>;
+}, z$1.core.$strict>;
+declare const effectiveConfigSchema: z$1.ZodMiniObject<{
+  chain: z$1.ZodMiniArray<z$1.ZodMiniEnum<{
+    custom: "custom";
     codex: "codex";
     claude: "claude";
-    custom: "custom";
   }>>;
-  engines: z.ZodMiniObject<{
-    codex: z.ZodMiniOptional<z.ZodMiniObject<{
-      model: z.ZodMiniOptional<z.ZodMiniString<string>>;
-      effort: z.ZodMiniOptional<z.ZodMiniEnum<{
+  engines: z$1.ZodMiniObject<{
+    codex: z$1.ZodMiniOptional<z$1.ZodMiniObject<{
+      model: z$1.ZodMiniOptional<z$1.ZodMiniString<string>>;
+      effort: z$1.ZodMiniOptional<z$1.ZodMiniEnum<{
         low: "low";
         medium: "medium";
         high: "high";
       }>>;
-      permissions: z.ZodMiniOptional<z.ZodMiniEnum<{
+      permissions: z$1.ZodMiniOptional<z$1.ZodMiniEnum<{
         "read-only": "read-only";
         "workspace-write": "workspace-write";
         auto: "auto";
       }>>;
-      network: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
-    }, z.core.$strict>>;
-    claude: z.ZodMiniOptional<z.ZodMiniObject<{
-      model: z.ZodMiniOptional<z.ZodMiniString<string>>;
-      effort: z.ZodMiniOptional<z.ZodMiniEnum<{
+      network: z$1.ZodMiniOptional<z$1.ZodMiniBoolean<boolean>>;
+    }, z$1.core.$strict>>;
+    claude: z$1.ZodMiniOptional<z$1.ZodMiniObject<{
+      model: z$1.ZodMiniOptional<z$1.ZodMiniString<string>>;
+      effort: z$1.ZodMiniOptional<z$1.ZodMiniEnum<{
         low: "low";
         medium: "medium";
         high: "high";
       }>>;
-      permissions: z.ZodMiniOptional<z.ZodMiniEnum<{
+      permissions: z$1.ZodMiniOptional<z$1.ZodMiniEnum<{
         "read-only": "read-only";
         "workspace-write": "workspace-write";
         auto: "auto";
       }>>;
-    }, z.core.$strict>>;
-    custom: z.ZodMiniOptional<z.ZodMiniObject<{
-      model: z.ZodMiniOptional<z.ZodMiniString<string>>;
-      effort: z.ZodMiniOptional<z.ZodMiniEnum<{
+    }, z$1.core.$strict>>;
+    custom: z$1.ZodMiniOptional<z$1.ZodMiniObject<{
+      model: z$1.ZodMiniOptional<z$1.ZodMiniString<string>>;
+      effort: z$1.ZodMiniOptional<z$1.ZodMiniEnum<{
         low: "low";
         medium: "medium";
         high: "high";
       }>>;
-      permissions: z.ZodMiniOptional<z.ZodMiniEnum<{
+      permissions: z$1.ZodMiniOptional<z$1.ZodMiniEnum<{
         "read-only": "read-only";
         "workspace-write": "workspace-write";
         auto: "auto";
       }>>;
-    }, z.core.$strict>>;
-  }, z.core.$strict>;
-  models: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnion<readonly [z.ZodMiniObject<{
-    baseUrl: z.ZodMiniURL;
-    model: z.ZodMiniString<string>;
-    envKey: z.ZodMiniOptional<z.ZodMiniString<string>>;
-    wireApi: z.ZodMiniOptional<z.ZodMiniEnum<{
+    }, z$1.core.$strict>>;
+  }, z$1.core.$strict>;
+  models: z$1.ZodMiniOptional<z$1.ZodMiniRecord<z$1.ZodMiniString<string>, z$1.ZodMiniUnion<readonly [z$1.ZodMiniObject<{
+    baseUrl: z$1.ZodMiniURL;
+    model: z$1.ZodMiniString<string>;
+    envKey: z$1.ZodMiniOptional<z$1.ZodMiniString<string>>;
+    wireApi: z$1.ZodMiniOptional<z$1.ZodMiniEnum<{
       chat: "chat";
       responses: "responses";
     }>>;
-    disabled: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
-  }, z.core.$strict>, z.ZodMiniObject<{
-    provider: z.ZodMiniEnum<{
+    contextWindow: z$1.ZodMiniOptional<z$1.ZodMiniNumber<number>>;
+    disabled: z$1.ZodMiniOptional<z$1.ZodMiniBoolean<boolean>>;
+  }, z$1.core.$strict>, z$1.ZodMiniObject<{
+    provider: z$1.ZodMiniEnum<{
       codex: "codex";
       claude: "claude";
     }>;
-    model: z.ZodMiniString<string>;
-    effort: z.ZodMiniOptional<z.ZodMiniEnum<{
+    model: z$1.ZodMiniString<string>;
+    effort: z$1.ZodMiniOptional<z$1.ZodMiniEnum<{
       low: "low";
       medium: "medium";
       high: "high";
     }>>;
-    disabled: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
-  }, z.core.$strict>, z.ZodMiniObject<{
-    disabled: z.ZodMiniBoolean<boolean>;
-  }, z.core.$strict>]>>>;
-  agents: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniObject<{
-    engine: z.ZodMiniOptional<z.ZodMiniString<string>>;
-    model: z.ZodMiniOptional<z.ZodMiniString<string>>;
-    effort: z.ZodMiniOptional<z.ZodMiniEnum<{
+    disabled: z$1.ZodMiniOptional<z$1.ZodMiniBoolean<boolean>>;
+  }, z$1.core.$strict>, z$1.ZodMiniObject<{
+    disabled: z$1.ZodMiniBoolean<boolean>;
+  }, z$1.core.$strict>]>>>;
+  agents: z$1.ZodMiniOptional<z$1.ZodMiniRecord<z$1.ZodMiniString<string>, z$1.ZodMiniUnion<readonly [z$1.ZodMiniBoolean<boolean>, z$1.ZodMiniObject<{
+    engine: z$1.ZodMiniOptional<z$1.ZodMiniString<string>>;
+    model: z$1.ZodMiniOptional<z$1.ZodMiniString<string>>;
+    effort: z$1.ZodMiniOptional<z$1.ZodMiniEnum<{
       low: "low";
       medium: "medium";
       high: "high";
     }>>;
-    permissions: z.ZodMiniOptional<z.ZodMiniEnum<{
+    permissions: z$1.ZodMiniOptional<z$1.ZodMiniEnum<{
       "read-only": "read-only";
       "workspace-write": "workspace-write";
       auto: "auto";
     }>>;
-    access: z.ZodMiniOptional<z.ZodMiniEnum<{
+    access: z$1.ZodMiniOptional<z$1.ZodMiniEnum<{
       read: "read";
       write: "write";
     }>>;
-    runner: z.ZodMiniOptional<z.ZodMiniEnum<{
+    runner: z$1.ZodMiniOptional<z$1.ZodMiniEnum<{
       local: "local";
       "local-docker": "local-docker";
       "vercel-sandbox": "vercel-sandbox";
       "github-actions": "github-actions";
     }>>;
-    integrations: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniObject<{
-      allowedEvents: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
-    }, z.core.$strict>>>;
-    connections: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
-    disabled: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
-  }, z.core.$strict>]>>>;
-  mcp: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniObject<{
-    connection: z.ZodMiniOptional<z.ZodMiniString<string>>;
-    command: z.ZodMiniOptional<z.ZodMiniString<string>>;
-    args: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
-    env: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
-    url: z.ZodMiniOptional<z.ZodMiniString<string>>;
-    type: z.ZodMiniOptional<z.ZodMiniEnum<{
+    integrations: z$1.ZodMiniOptional<z$1.ZodMiniRecord<z$1.ZodMiniString<string>, z$1.ZodMiniObject<{
+      allowedEvents: z$1.ZodMiniOptional<z$1.ZodMiniArray<z$1.ZodMiniString<string>>>;
+    }, z$1.core.$strict>>>;
+    connections: z$1.ZodMiniOptional<z$1.ZodMiniArray<z$1.ZodMiniString<string>>>;
+    disabled: z$1.ZodMiniOptional<z$1.ZodMiniBoolean<boolean>>;
+  }, z$1.core.$strict>]>>>;
+  mcp: z$1.ZodMiniOptional<z$1.ZodMiniRecord<z$1.ZodMiniString<string>, z$1.ZodMiniObject<{
+    connection: z$1.ZodMiniOptional<z$1.ZodMiniString<string>>;
+    command: z$1.ZodMiniOptional<z$1.ZodMiniString<string>>;
+    args: z$1.ZodMiniOptional<z$1.ZodMiniArray<z$1.ZodMiniString<string>>>;
+    env: z$1.ZodMiniOptional<z$1.ZodMiniRecord<z$1.ZodMiniString<string>, z$1.ZodMiniString<string>>>;
+    url: z$1.ZodMiniOptional<z$1.ZodMiniString<string>>;
+    type: z$1.ZodMiniOptional<z$1.ZodMiniEnum<{
       stdio: "stdio";
       http: "http";
-      sse: "sse";
     }>>;
-    headers: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
-    tools: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
-    description: z.ZodMiniOptional<z.ZodMiniString<string>>;
-  }, z.core.$strict>>>;
-  approvals: z.ZodMiniObject<{
-    escalationTimeoutMs: z.ZodMiniNumber<number>;
-    allowedNetworkHosts: z.ZodMiniArray<z.ZodMiniString<string>>;
-  }, z.core.$strict>;
-}, z.core.$strict>;
-type McpConfigEntry = z.infer<typeof mcpEntrySchema> & {
+    headers: z$1.ZodMiniOptional<z$1.ZodMiniRecord<z$1.ZodMiniString<string>, z$1.ZodMiniString<string>>>;
+    tools: z$1.ZodMiniOptional<z$1.ZodMiniArray<z$1.ZodMiniString<string>>>;
+    description: z$1.ZodMiniOptional<z$1.ZodMiniString<string>>;
+  }, z$1.core.$strict>>>;
+  approvals: z$1.ZodMiniObject<{
+    allowedNetworkHosts: z$1.ZodMiniArray<z$1.ZodMiniString<string>>;
+  }, z$1.core.$strict>;
+}, z$1.core.$strict>;
+type McpConfigEntry = z$1.infer<typeof mcpEntrySchema> & {
   repository?: boolean;
 };
-type Engine = z.infer<typeof engineSchema>;
-type Effort = z.infer<typeof effortSchema>;
-type Permission = z.infer<typeof permissionSchema>;
-type CustomModelConfig = z.infer<typeof customModelSchema>;
-type CoderConfig = z.infer<typeof effectiveConfigSchema>;
+type Engine = z$1.infer<typeof engineSchema>;
+type Effort = z$1.infer<typeof effortSchema>;
+type Permission = z$1.infer<typeof permissionSchema>;
+type CustomModelConfig = z$1.infer<typeof customModelSchema>;
+type CoderConfig = z$1.infer<typeof effectiveConfigSchema>;
 declare const config: {
   /** A config value by dotted key (or the whole effective config). */
   get: (key?: string, opts?: {
@@ -1290,75 +1290,15 @@ interface SerializedThread {
  */
 type ChannelVisibility = "private" | "workspace" | "external" | "unknown";
 //#endregion
-//#region src/agent/types.d.ts
+//#region src/integrations/types.d.ts
+/** Access modes: read-only tools, or tools that also write. */
 type Preset = 'read' | 'write';
-/** Per-integration wiring in a definition. `events` list = default behavior, map = event -> flow. */
-/** Event value in a definition map: a flow name, or options. */
-interface AgentEventOptions {
-  /** Flow to run; omit for the default agent. */
-  flow?: string;
-  /** Regex the event text must match (e.g. keywords on Slack `message`). */
-  match?: string;
-  /** May only narrow the agent's default permission for this event. */
-  permissions?: Permission;
-  /** `requester`: the task acts with the linked requester's own platform token. */
-  actAs?: 'requester';
-}
-interface AgentDefinitionIntegration {
-  events?: string[] | Record<string, string | true | AgentEventOptions>;
-}
-/** What an agent IS: `.coder/agents/<id>/agent.json` beside its system.md. */
-interface AgentDefinition {
-  /** Display name used in replies; defaults to the id. */
-  name?: string;
-  description?: string;
-  engine?: string;
-  runner?: string;
-  model?: string;
-  effort?: Effort;
-  permissions?: Permission;
-  /** Read-only or Read-write on its handles and connections; defaults to `write`. */
-  access?: Preset;
-  /** MCP servers every task of this agent attaches, in the `.mcp.json` entry shape. */
-  mcp?: Record<string, McpConfigEntry>;
-  integrations: Record<string, AgentDefinitionIntegration>;
-}
-/** Per-integration caps in usage: `allowedEvents` intersects the definition's. */
-interface AgentUsageIntegration {
-  allowedEvents?: string[];
-}
-/** How a repo RUNS an agent: one entry under `agents` in .coder/config.json. */
-interface AgentUsage {
-  engine?: string;
-  model?: string;
-  effort?: Effort;
-  permissions?: Permission;
-  /** May only lower the definition's access. */
-  access?: Preset;
-  integrations?: Record<string, AgentUsageIntegration>;
-  /** Connections its tasks may use, by id; absent allows every connection the task is granted. */
-  connections?: string[];
-  /** Off in this workspace; the other settings stay for when it is enabled again. */
-  disabled?: boolean;
-}
-interface Agent {
-  id: string;
-  /** definition.name ?? id. */
-  name: string;
-  definition: AgentDefinition;
-  usage?: AgentUsage;
-  /** Absolute folder path when the agent's body is on disk; remote agents have none. */
-  dir?: string;
-  /** Stored agent body, including system.md, when there is no on-disk folder. */
-  files?: Record<string, string>;
-  builtin: boolean;
-}
-/** A platform event, already typed by its integration. */
-interface AgentEvent {
+/** A platform event, typed by its integration. */
+interface PlatformEvent {
   integration: string;
   /** Catalog name, e.g. `pull_request` or `mention`. */
   type: string;
-  /** `AgentApp.id` the webhook was addressed to. */
+  /** `PlatformApp.id` the webhook was addressed to. */
   appId: string;
   installationId: string;
   deliveryId: string;
@@ -1379,19 +1319,6 @@ interface AgentEvent {
     thread: SerializedThread;
     message?: SerializedMessage;
   };
-  /** Whether the agent must answer: a mention, a 1:1 direct message, or a handle that answers every prompt. */
-  mustReply?: boolean;
-  /** The event's place in its conversation, gathered at dispatch; `more` counts messages past `since`'s cap. */
-  conversation?: {
-    index?: number;
-    since?: SinceMessage[];
-    more?: number;
-    /** Internal acknowledgement watermark of the recorded unseen snapshot. */
-    unseen?: {
-      version: number;
-      epoch?: string;
-    };
-  };
   repo?: {
     owner: string;
     name: string;
@@ -1399,84 +1326,6 @@ interface AgentEvent {
     defaultBranch: string;
   };
 }
-/** Per-installation settings a user sets from the platform (`/setup` in Slack). */
-interface InstallationSettings {
-  model?: string;
-  engine?: string;
-  effort?: string;
-}
-/** Where a task came from: a Coder surface, or the id of the integration whose event started it. */
-type TaskSource = 'dashboard' | 'cli' | 'schedule' | (string & {});
-interface AgentTask {
-  cwd?: string;
-  id: string;
-  name?: string;
-  source: TaskSource;
-  agent: string;
-  /** Flow name, or `default` for the built-in single-task behavior. */
-  flow: string;
-  runner: RunnerKind;
-  /** Registered `http` runner the task routes to. */
-  runnerId?: string;
-  /** Effective permission after host, usage, and event narrowing. */
-  permissions?: Permission;
-  /** The platform event, or for a dashboard or CLI task on a repo, that repo through its install. */
-  event?: AgentEvent;
-  /** What a dashboard or CLI task asks; the newest turn after a continue. */
-  prompt?: string;
-  /** Flow arguments given directly, instead of derived from the event. */
-  args?: Record<string, unknown>;
-  /** Workspace MCP servers the task attaches, by name. */
-  mcp?: string[];
-  /** Connection ids granted when the task was made; secrets are resolved only when it starts. */
-  connections?: string[];
-  /** Handle the task posts as (GitHub `slug[bot]`, Slack bot user), so flows can trust only their own comments. */
-  author?: string;
-  definition: AgentDefinition;
-  /** Frozen id of the credential selected for this task. */
-  credential?: string;
-  /** The engine order for this task; a pinned engine has one entry. */
-  engineChain?: string[];
-  /** Applicable credentials frozen with the engine order, without their values. */
-  engineCredentials?: Record<string, string>;
-  /** Wular user who asked, when known; their personal credential comes first. */
-  requester?: string;
-  /** Stored agent body for runners whose checkout does not contain the agent. */
-  files?: Record<string, string>;
-  usage?: AgentUsage;
-  /** Effective tools per integration the agent declares, by its access mode; every installation of the agent's apps serves them. */
-  tools: Record<string, string[]>;
-  /** Context gathered by the receiver: notes for the turn and who asked. */
-  context?: TaskContext;
-  /** What the platform thread gets when the run fails without an answer. */
-  failureReply?: string;
-  /** The task's dashboard page, linked when the agent returns no reply where one is due. */
-  taskUrl?: string;
-}
-interface TaskContext {
-  outputSchema?: object;
-  /** Earlier turns a dashboard continuation pastes in, oldest first. */
-  messages?: Array<{
-    user: string;
-    text: string;
-    ts: string;
-  }>;
-  /** Completed turns of this task, kept across dashboard continuations. */
-  turns?: TaskTurn[];
-  /** Notes the receiver adds for the agent, such as a missing account connection. */
-  instructions?: string;
-  /** Whether this turn requires a reply. */
-  mustReply?: boolean;
-  /** The last conversation batch each kind admitted, by steer or resume. */
-  admissions?: Partial<Record<'batch' | 'reactions', string>>;
-  /** The Coder account behind the event's actor, when they connected it. */
-  user?: {
-    name: string;
-    email: string;
-  };
-}
-//#endregion
-//#region src/integrations/types.d.ts
 /** A message the agent did not get as a turn, as `since` lists it. */
 interface SinceMessage {
   /** The platform's message id, so a message counts once; not shown to the agent. */
@@ -1552,6 +1401,8 @@ interface ProbeResult {
   modelListed: boolean | null;
   /** Model ids the endpoint lists, or null when it has no list. */
   models: string[] | null;
+  /** Context window in tokens per model id, where the provider reports one. */
+  contextWindows?: Record<string, number>;
   detail: string;
 }
 /** One connection as the dashboard lists it; secrets never leave the server. */
@@ -1600,6 +1451,8 @@ interface TaskTurn {
   finishedAt?: number;
   /** First log sequence after this turn. */
   logSeq?: number;
+  /** The approval whose decision this turn's prompt is: it shows as that decision, not as a prompt. */
+  approval?: string;
 }
 //#endregion
 //#region src/core/task/log-view.d.ts
@@ -1616,6 +1469,52 @@ interface TokenUsage {
   total: number;
 }
 //#endregion
+//#region src/core/task/context/system.d.ts
+/** What whoever built the agent wrote, plus the receiver's notes for this task. */
+interface DeveloperParts {
+  description?: string;
+  instructions?: string;
+  notes?: string;
+}
+/** The parts of a task's system prompt its caller knows: the agent and where it is used. */
+interface AgentPromptParts {
+  developer?: DeveloperParts;
+  /** Conversation tasks: the conversation's platform and its catalog prompt. */
+  platform?: {
+    name: string;
+    prompt?: string;
+  };
+  /** Conversation tasks: the events the agent subscribes to. */
+  events?: string[];
+  /** The agent's access mode. */
+  access?: 'read' | 'write';
+}
+interface SystemPromptParts extends AgentPromptParts {
+  /** The task's MCP servers as the worker renders them on each turn. */
+  servers?: string;
+  /** Who loads their tools on demand: the engine's tool search, or Coder's find_tools and call_tool. */
+  toolSearch?: 'native' | 'coder';
+  /** Coder's task tools this turn has, as the worker serves them. */
+  tools?: string[];
+  cwd?: string;
+  /** A platform event's task, whose final message is a reply in a thread; otherwise a general task. */
+  conversation?: boolean;
+  /** The engine runs on this machine, not on a hosted runner. */
+  local?: boolean;
+  /** The task's scratch folder on the machine it runs on. */
+  scratch?: string;
+  /** Sandboxed commands reach only the hosts they declare (Claude auto). */
+  declareHosts?: boolean;
+  /** The exact actions the user approved for the rest of the task. */
+  approved?: string[];
+  /** The task may write (workspace-write or auto). */
+  writes?: boolean;
+  /** `coder task run --append-system` text and flow instructions. */
+  appendSystem?: string;
+  /** The final message is JSON for a schema, not a summary. */
+  structured?: boolean;
+}
+//#endregion
 //#region src/core/types.d.ts
 /** An extra MCP server attached to a task, with the tools the engine may call. */
 /** One MCP server in the `.mcp.json` entry shape: stdio (`command`) or remote (`url`). */
@@ -1629,9 +1528,9 @@ interface McpServerSpec {
   args?: string[];
   /** Values may hold `${VAR}` placeholders, resolved from the environment at spawn time. */
   env?: Record<string, string>;
-  /** Remote server; `type` defaults to `http` (streamable HTTP), `sse` for legacy servers. */
+  /** Remote server, streamable HTTP. */
   url?: string;
-  type?: 'stdio' | 'http' | 'sse';
+  type?: 'stdio' | 'http';
   headers?: Record<string, string>;
   /** Credential destination supplied by the connection resolver, removed before persistence. */
   credentialFields?: {
@@ -1663,7 +1562,8 @@ interface Task {
   prompt?: string;
   outputSchema?: object;
   currentPrompt?: string | null;
-  system?: string | null;
+  appendSystem?: string | null;
+  promptParts?: Omit<SystemPromptParts, 'servers'>;
   systemPrompt?: string;
   model?: string | null;
   effort?: Effort | null;
@@ -1674,13 +1574,8 @@ interface Task {
   dispatchId?: string;
   threadId?: string | null;
   previousThreadIds?: string[];
-  pendingRollover?: {
-    summary: string;
-    recent: string;
-    exchanges: number;
-  };
-  rollingOver?: boolean;
   steerClosed?: boolean;
+  resumeOwner?: number;
   conversation?: boolean;
   turnId?: string | null;
   steerEndpoint?: string | null;
@@ -1698,7 +1593,6 @@ interface Task {
   archived?: boolean;
   archivedAt?: string;
   autoArchived?: boolean;
-  simulateApproval?: boolean;
   flowRunId?: string;
   agentId?: string;
   source?: string;
@@ -1717,7 +1611,6 @@ interface TurnResult {
   threadId: string | null;
   turnId?: string | null;
   finalMessage?: string;
-  touchedFiles?: string[];
   tokens?: TokenUsage | null;
   contextTokens?: number;
   /** The model that ran the turn (tokens are only comparable per model). */
@@ -1732,33 +1625,589 @@ interface Availability {
   available: boolean;
   detail: string;
 }
-/** A persisted approval escalation and its answer, if any. */
+/** A task's escalation and its answer, if any. */
 interface Approval {
   id: string;
-  summary: string;
-  /** Where an escalated command runs. */
-  cwd?: string;
+  /** One short sentence: what the actions are for. */
+  reason: string;
+  /** The exact commands; one answer covers them all. */
+  actions: string[];
   createdAt?: string;
+  /** `by` names who answered; `deliveredAt` is set once the task has the decision; `closed` when the task was stopped first. */
   response?: {
-    decision: string;
+    decision: 'accept' | 'decline' | 'closed';
+    reason?: string;
+    answeredAt?: string;
+    by?: string;
+    deliveredAt?: string;
   } | null;
   [key: string]: unknown;
 }
-/** A [flag-or-command, description] pair rendered in help tables. */
-type HelpRow = [string, string];
-/** Help metadata for one command. */
-interface CommandHelpSpec {
-  usage: string;
-  summary?: string;
-  flags?: HelpRow[];
-  globalFlags?: HelpRow[];
-  exitCodes?: HelpRow[];
-  examples?: HelpRow[];
-  /** Environment variables the command reads: name → what it does. */
-  env?: HelpRow[];
-  seeAlso?: string;
-}
-/** A subcommand handler. Receives the argv slice after the command name. */
-type CommandHandler = (argv: string[]) => Promise<void> | void;
 //#endregion
-export { type InstallationSettings as A, RunnerUpdate as C, type AgentEvent as D, type AgentDefinition as E, type CustomModelConfig as F, type config as I, TaskContext as M, type TaskSource as N, type AgentTask as O, type CoderConfig as P, type RunnerTest as S, type Agent as T, type RunnerInput as _, type HelpRow as a, type RunnerRow as b, type TaskStatus as c, type TokenUsage as d, type AppSync as f, type ProbeResult as g, type LocalFolders as h, type CommandHelpSpec as i, type Preset as j, type AgentUsage as k, type TurnResult as l, LocalFolder as m, type Availability as n, McpServerSpec as o, ConnectionRow as p, CommandHandler as r, Task as s, Approval as t, TaskLogEntry as u, RunnerKind as v, type TaskTurn as w, type RunnerSpec as x, type RunnerPairing as y };
+//#region src/flow/types.d.ts
+/** Anything with zod's parse shape; the flow runtime never imports zod itself. */
+interface FlowSchema<T> {
+  parse(value: unknown): T;
+}
+interface FlowTaskResult<T = unknown> {
+  taskId: string;
+  status: string;
+  output: string;
+  data?: T;
+  tokens: TokenUsage | null;
+  model: string | null;
+}
+interface GateResult {
+  ok: boolean;
+  code: number;
+  output: string;
+}
+/** Options shared with `coder run`, plus `returns`. */
+interface FlowTaskOptions<T = unknown> {
+  engine?: string;
+  model?: string;
+  effort?: string;
+  permissions?: string;
+  mcp?: string | McpServerSpec[];
+  name?: string;
+  appendSystem?: string;
+  cwd?: string;
+  addDirs?: string[];
+  returns?: FlowSchema<T>;
+}
+/** Overrides for one more turn, as `coder task steer` takes them. */
+interface FlowSteerOptions {
+  model?: string;
+  effort?: string;
+  permissions?: string;
+}
+type FlowRunStatus = 'running' | 'completed' | 'failed' | 'stopped';
+/** An event recorded by the flow runtime and delivered to its hooks and followers. */
+type FlowEvent = {
+  kind: 'task-start';
+  taskId: string;
+  name?: string;
+  prompt: string;
+  engine?: string;
+  depth?: number;
+} | {
+  kind: 'task-end';
+  taskId: string;
+  status: string;
+  tokens: TokenUsage | null;
+} | {
+  kind: 'gate-start';
+  gateId: string;
+  cmd: string;
+  depth?: number;
+} | {
+  kind: 'gate';
+  gateId?: string;
+  cmd: string;
+  ok: boolean;
+  code: number;
+  depth?: number;
+} | {
+  kind: 'log';
+  message: string;
+  depth?: number;
+} | {
+  kind: 'flow-start';
+  name: string;
+  depth: number;
+} | {
+  kind: 'replay';
+  count: number;
+};
+interface JournalEntry {
+  seq: number;
+  kind: 'task' | 'gate' | 'flow';
+  fingerprint: string;
+  result: unknown;
+  taskId?: string;
+  tokens?: TokenUsage | null;
+  startedAt: string;
+  endedAt: string;
+}
+/** flow.json: the persisted run record. */
+interface FlowRecord {
+  runId: string;
+  name: string;
+  script: string;
+  args: unknown;
+  status: FlowRunStatus;
+  startedAt: string;
+  endedAt?: string;
+  /** Orchestrator process while status is running; cleared on every terminal write. */
+  pid?: number;
+  pidStartedAt?: string;
+  concurrency: number;
+  concurrencySet?: boolean;
+  maxTasks: number;
+  taskCount: number;
+  ledger: Record<string, TokenUsage>;
+  result?: unknown;
+  error?: string;
+  /** Hidden from the default list; set by auto-archive or `flow archive`. */
+  archived?: boolean;
+  archivedAt?: string;
+}
+/** One `flow result` step row: a journaled task with its current status. */
+interface FlowStep {
+  taskId: string | null;
+  name: string | null;
+  status: string;
+  tokens: TokenUsage | null;
+}
+interface DiscoveredFlow {
+  name: string;
+  path: string;
+  /** `builtin` flows ship with coder; their `path` is `builtin:<name>`. */
+  scope: 'workspace' | 'global' | 'builtin';
+}
+//#endregion
+//#region src/flow/journal.d.ts
+/**
+ * Prefix-order replay. A call matches the first unconsumed recorded entry with
+ * an identical fingerprint (fingerprint match rather than strict positional
+ * next, so concurrent pipelines resume correctly); a miss runs live. The file
+ * is truncated on construction and rewritten in this run's completion order, so
+ * every run leaves a clean journal for the next resume.
+ */
+declare class Journal {
+  private file;
+  private recorded;
+  private seq;
+  constructor(recorded: JournalEntry[], file: string);
+  private write;
+  /** Recorded result for one of these fingerprints, or null to run live. */
+  replay(...fps: string[]): JournalEntry | null;
+  record(entry: Omit<JournalEntry, 'seq'>): void;
+}
+//#endregion
+//#region src/flow/runtime.d.ts
+/** Progress callbacks a foreground caller can attach to a run. */
+interface FlowHooks {
+  /** Fired once the run is armed, with a stop handle for a SIGINT handler. */
+  onStart?: (h: {
+    runId: string;
+    requestStop: () => void;
+    runningIds: () => string[];
+  }) => void;
+  onEvent?: (event: FlowEvent) => void;
+}
+interface RunContext {
+  runId: string;
+  runDir: string;
+  cwd: string;
+  journal: Journal;
+  semaphore: Semaphore;
+  /** The caller set no concurrency, so the flow's own `concurrency` export applies. */
+  flowConcurrency: boolean;
+  maxTasks: number;
+  dryRun: boolean;
+  ledger: Record<string, TokenUsage>;
+  running: Set<string>;
+  taskCount: number;
+  stopping: boolean;
+  hooks: FlowHooks;
+  /** Caller-owned platform credential; in memory only, never written to flow.json. */
+  integrationToken?: string;
+  connections?: {
+    mcp: Record<string, McpServerSpec>;
+    env: Record<string, string>;
+    ids: string[];
+  };
+  ceiling?: {
+    agent: string;
+    permissions: string;
+  };
+}
+declare class Semaphore {
+  limit: number;
+  private active;
+  private queue;
+  constructor(limit: number);
+  run<T>(fn: () => Promise<T>): Promise<T>;
+}
+/**
+ * Dispatch one coder task and await its result. With a `returns` schema the
+ * reply is validated and `data` is guaranteed (validation failure throws).
+ * Inside a flow run, results are journaled and replayed on resume.
+ */
+declare function task<T>(prompt: string, opts: FlowTaskOptions<T> & {
+  returns: FlowSchema<T>;
+}): Promise<FlowTaskResult<T> & {
+  data: T;
+}>;
+/** Dispatch one coder task and await its result. Mirrors `coder run`. */
+declare function task(prompt: string, opts?: FlowTaskOptions): Promise<FlowTaskResult>;
+/** Continue a task this run started, on the same id, and await the turn. Mirrors `coder task steer --wait`. */
+declare function steer(taskId: string, text: string, opts?: FlowSteerOptions): Promise<FlowTaskResult>;
+/**
+ * Run a shell command as a checkpoint. Never throws. Inspect `ok`/`code`.
+ * output is captured (capped) and journaled for resume.
+ */
+declare function gate(cmd: string, opts?: {
+  cwd?: string;
+}): Promise<GateResult>;
+type Stage = (prev: any, item: any, index: number) => unknown;
+type S<P, T, R> = (prev: P, item: T, index: number) => R | Promise<R>;
+/**
+ * Run each item through the stages independently, with no barrier between
+ * stages. Each stage receives `(prev, item, index)`; a thrown stage drops
+ * that item to `null` and skips its remaining stages.
+ */
+declare function pipeline<T, A>(items: T[], s1: S<T, T, A>): Promise<(A | null)[]>;
+declare function pipeline<T, A, B>(items: T[], s1: S<T, T, A>, s2: S<A, T, B>): Promise<(B | null)[]>;
+declare function pipeline<T, A, B, C>(items: T[], s1: S<T, T, A>, s2: S<A, T, B>, s3: S<B, T, C>): Promise<(C | null)[]>;
+declare function pipeline<T, A, B, C, D>(items: T[], s1: S<T, T, A>, s2: S<A, T, B>, s3: S<B, T, C>, s4: S<C, T, D>): Promise<(D | null)[]>;
+declare function pipeline<T>(items: T[], ...stages: Stage[]): Promise<any[]>;
+/** Emit a progress line to the run's event stream. */
+declare function log(msg: string): void;
+/**
+ * Run another flow inline as a sub-step and return its result. Nesting is one
+ * level deep. A subflow cannot call `flow()` itself.
+ */
+declare function flow(name: string, args?: unknown): Promise<unknown>;
+//#endregion
+//#region src/core/state.d.ts
+interface TurnResultEntry {
+  at?: string;
+  prompt?: string | null;
+  /** Steers the engine took into this turn while it ran. */
+  steers?: string[];
+  lastReply?: string;
+  finalMessage?: string;
+  error?: TurnResult['error'];
+  status?: number;
+  tokens?: TurnResult['tokens'];
+  model?: TurnResult['model'];
+  [key: string]: unknown;
+}
+declare function readTurnResults(cwd: string, taskId: string): TurnResultEntry[];
+//#endregion
+//#region src/flow/executor.d.ts
+interface RunOptions {
+  runId?: string;
+  args?: unknown;
+  concurrency?: number;
+  maxTasks?: number;
+  dryRun?: boolean;
+  cwd?: string;
+  /** Platform credential for built-in integrations; never persisted with the run. */
+  integrationToken?: string;
+  connections?: RunContext['connections'];
+  /** The agent whose permissions cap every task this run starts. */
+  ceiling?: {
+    agent: string;
+    permissions: string;
+  };
+}
+interface RunSummary {
+  runId: string;
+  name: string;
+  status: 'completed';
+  result: unknown;
+  tokens: Record<string, TokenUsage>;
+  taskCount: number;
+}
+interface StopSummary {
+  runId: string;
+  status: FlowRecord['status'];
+  stoppedTasks: string[];
+  keptTasks: string[];
+}
+declare const review$1: {
+  run(options?: ReviewArgs): Promise<ReviewResult & {
+    runId: string;
+  }>;
+};
+//#endregion
+//#region src/flow/runs.d.ts
+/** A run's record with its step rows, trimmed journal and recorded events. */
+type RunResult = FlowRecord & {
+  steps: FlowStep[];
+  journal: Array<Pick<JournalEntry, 'kind' | 'taskId' | 'tokens'>>;
+  events: FlowEvent[];
+};
+type Archived = {
+  runId: string;
+  archived: true;
+};
+type ArchivedAll = {
+  archived: string[];
+  count: number;
+};
+/** Archive one stopped run, or with `allStopped` every one. */
+declare function archiveRuns(runId: string, opts?: {
+  allStopped?: false;
+}): Archived;
+declare function archiveRuns(runId: string | undefined, opts: {
+  allStopped: true;
+}): ArchivedAll;
+declare function archiveRuns(runId?: string, opts?: {
+  allStopped?: boolean;
+}): Archived | ArchivedAll;
+type Deleted = {
+  runId: string;
+  deleted: boolean;
+};
+type DeletedAll = {
+  deleted: string[];
+  count: number;
+};
+/** Delete one stopped run's record (its tasks are left alone), or with `allArchived` every archived one. */
+declare function deleteRuns(runId: string, opts?: {
+  allArchived?: false;
+}): Deleted;
+declare function deleteRuns(runId: string | undefined, opts: {
+  allArchived: true;
+}): DeletedAll;
+declare function deleteRuns(runId?: string, opts?: {
+  allArchived?: boolean;
+}): Deleted | DeletedAll;
+//#endregion
+//#region src/core/errors.d.ts
+/** The run-native-subagent fallback payload the CLI prints on exit 3. */
+interface FallbackPayload {
+  error: string;
+  fallback: {
+    action: 'run-native-subagent';
+    reason: 'no-engine-available';
+    permissions: string;
+    instructions: string;
+    note: string;
+    appendSystem?: string;
+    task: string;
+  };
+}
+/** Recoverable errors with CLI exit codes. */
+type CoderErrorCode = 'nested-dispatch' | 'invalid-option' | 'read-only-unavailable' | 'startup-failed' | 'chain-exhausted' | 'approval-pending' | 'task-failed' | 'flow-failed' |
+/** A Coder server refused or failed a request; `status` carries the HTTP status. */
+'server' |
+/** Sign-in to a server did not complete. */
+'login-failed';
+declare class CoderError extends Error {
+  code: CoderErrorCode;
+  hint?: string | string[];
+  taskId?: string;
+  /** chain-exhausted: the run-native-subagent payload the CLI prints on exit 3. */
+  payload?: FallbackPayload;
+  /** approval-pending: the approval to answer. */
+  approval?: {
+    id: string;
+    reason: string;
+    actions: string[];
+  };
+  /** task-failed (flow task()): the failed task's result. */
+  result?: unknown;
+  /** flow-failed: the run to resume. */
+  runId?: string;
+  /** server: the HTTP status the server answered with. */
+  status?: number;
+  needs?: 'key';
+  constructor(code: CoderErrorCode, message: string, extra?: Partial<Pick<CoderError, 'hint' | 'taskId' | 'payload' | 'approval' | 'result' | 'runId' | 'status' | 'needs'>>);
+}
+//#endregion
+//#region src/core/dispatch.d.ts
+interface TaskResult {
+  taskId: string;
+  status: TaskStatus;
+  result: TurnResult | null;
+  /** The last `tail` progress-log entries; [] at the default tail of 0. */
+  steps: TaskLogEntry[];
+  /** One entry per finished turn (a steered task accretes turns). */
+  turns: TurnResultEntry[];
+  task: Task;
+}
+/** Read a task's state and result.json without waiting. `tail` fills `steps`; `task` is the snapshot to judge by (a wait's), so a next turn starting meanwhile does not hide the finished one's result. */
+declare function readTask(cwd: string, taskId: string, opts?: {
+  tail?: number | 'all';
+  task?: Task;
+}): TaskResult;
+//#endregion
+//#region src/flow/index.d.ts
+/**
+ * The flow's `--args` value. A Proxy over the ALS-bound current args, so a
+ * top-level `import { args }` reflects whichever run is executing.
+ */
+declare const args$1: Record<string, unknown>;
+/** Run and inspect flows programmatically; mirrors `coder flow`. */
+declare const flowSdk: {
+  /** Run a flow and await its result. */
+  run(nameOrPath: string, opts?: RunOptions): Promise<RunSummary>;
+  /** Recent flow runs (mirrors `coder flow list`). */
+  list(opts?: {
+    archived?: boolean;
+    limit?: number | "all";
+  }): FlowRecord[];
+  /** Flows discoverable from a directory (workspace + global). */
+  discover(cwd?: string): DiscoveredFlow[];
+  /** A run's record with its step rows, journal and events (omit the id for the most recent run). `tail` caps steps (default 'all'; 0 → []). */
+  result(runId?: string, opts?: {
+    tail?: number | "all";
+  }): RunResult | null;
+  /** Follow a run live: an async iterable of flow events, ending when the run is terminal. `tail` replays only the last n (default 'all'). */
+  stream(runId?: string, opts?: {
+    tail?: number | "all";
+  }): AsyncGenerator<FlowEvent>;
+  /** Stop a running flow (and, by default, its still-running tasks). */
+  stop(runId?: string, opts?: {
+    keepTasks?: boolean;
+  }): Promise<StopSummary>;
+  /** Continue a stopped or edited run from its journal and await the result. */
+  resume(runId?: string, opts?: RunOptions): Promise<RunSummary>;
+  /** Archive a run (hide it from the default list), or with `allStopped` every stopped one. A running run must be stopped first. */
+  archive: typeof archiveRuns;
+  /** Delete a run's record from disk (its tasks are left alone), or with `allArchived` every archived one. A running run must be stopped first. */
+  delete: typeof deleteRuns;
+};
+//#endregion
+//#region src/flow/builtin/review/index.d.ts
+declare const description = "Review a code change.";
+declare const args: z.ZodObject<{
+  pr: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+  base: z.ZodOptional<z.ZodString>;
+  head: z.ZodOptional<z.ZodString>;
+  since: z.ZodOptional<z.ZodString>;
+  post: z.ZodOptional<z.ZodBoolean>;
+  author: z.ZodOptional<z.ZodString>;
+  path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  engine: z.ZodOptional<z.ZodString>;
+  model: z.ZodOptional<z.ZodString>;
+  effort: z.ZodOptional<z.ZodEnum<{
+    low: "low";
+    medium: "medium";
+    high: "high";
+  }>>;
+  cwd: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ReviewArgs = z.infer<typeof args>;
+/** Tasks at once unless the caller sets a concurrency. */
+declare const concurrency = 4;
+declare const Finding: z.ZodObject<{
+  file: z.ZodString;
+  line: z.ZodNumber;
+  severity: z.ZodEnum<{
+    critical: "critical";
+    major: "major";
+    minor: "minor";
+    nit: "nit";
+  }>;
+  category: z.ZodEnum<{
+    correctness: "correctness";
+    security: "security";
+    reliability: "reliability";
+    performance: "performance";
+    maintainability: "maintainability";
+    testing: "testing";
+    documentation: "documentation";
+  }>;
+  summary: z.ZodString;
+  failure_scenario: z.ZodString;
+}, z.core.$strict>;
+type Finding = z.infer<typeof Finding> & {
+  fingerprint: string;
+};
+interface ReviewSummary {
+  baseSha: string;
+  headSha: string;
+  /** Also covers uncommitted and untracked files on top of `headSha`. */
+  worktree: boolean;
+  files: number;
+  model: string | null;
+  elapsedMs: number;
+  posted?: number;
+  /** Parts left out of the review, such as uninitialized submodules. */
+  warnings?: string[];
+}
+interface ReviewResult {
+  findings: Finding[];
+  summary: ReviewSummary;
+}
+/** A review's findings as the CLI prints them and a task receives them. */
+declare function renderReviewMarkdown(result: ReviewResult & {
+  runId: string;
+}): string;
+/** New-side line ranges per file from a unified diff. */
+declare function changedLines(patch: string): Map<string, Array<[number, number]>>;
+/** Stable finding key from its file, category and neighbouring lines. */
+declare function fingerprint(file: string, text: string, category: string): string;
+/** AGENTS.md / CLAUDE.md, then .coder/review.md, all read at `sha`. */
+declare function repositoryRules(exec: ReviewExec, sha: string): Array<[name: string, text: string]>;
+interface ReviewServices {
+  exec?: ReviewExec;
+  reviewTask?: typeof task;
+  /** Test-only override for the transient task credential. */
+  integrationToken?: string;
+}
+declare function review(a: ReviewArgs, services?: ReviewServices): Promise<ReviewResult>;
+type ReviewExec = (command: string, args: string[], input?: string) => string;
+type ReviewPostFinding = Finding;
+type ReviewPostSummary = Pick<ReviewSummary, 'baseSha' | 'headSha' | 'model' | 'elapsedMs'> & {
+  author: string;
+};
+interface ReviewPostInput {
+  repo: string;
+  pr: number;
+  cwd?: string;
+  findings: ReviewPostFinding[];
+  summary: ReviewPostSummary;
+  since?: string;
+}
+interface ReviewTargetInput {
+  pr: number | string;
+  /** The only repository the target may be in. */
+  repo?: string;
+  cwd?: string;
+  since?: string;
+  author?: string;
+}
+interface ReviewTarget {
+  pr?: {
+    number: number;
+    repo: string;
+    author: string;
+  };
+  baseSha: string;
+  headSha: string;
+  since?: string;
+}
+interface ReviewAuth {
+  /** Installation token from the task context. Omit to use local gh auth. */
+  token?: string;
+  exec?: ReviewExec;
+}
+/** The platform reviews post to; its tool server holds the token. */
+declare const REVIEW_PLATFORM = "github";
+interface ReviewComment {
+  id: number;
+  body?: string | null;
+  user?: {
+    login?: string;
+  } | null;
+}
+declare function reviewCli(cwd?: string, token?: string): ReviewExec;
+declare function parseGithubPr(value: number | string): {
+  number: number;
+  repo?: string;
+};
+declare function reviewFingerprints(comments: Array<{
+  body?: string | null;
+}>): Set<string>;
+declare function lastReviewSummary(comments: Array<{
+  id: number;
+  body?: string | null;
+}>): {
+  id: number;
+  head: string;
+} | undefined;
+declare function ownReviewComments(comments: ReviewComment[], author: string): ReviewComment[];
+/** Resolve and fetch a GitHub pull request for the integration-generic review flow. */
+declare function resolveReviewTarget(input: ReviewTargetInput, auth?: ReviewAuth): ReviewTarget;
+/** Post unseen findings and upsert the sticky summary through GitHub's integration. */
+declare function postReview(input: ReviewPostInput, auth?: ReviewAuth): number;
+//#endregion
+export { type FlowTaskOptions as $, type flowSdk as A, type review$1 as B, renderReviewMarkdown as C, SinceMessage as Ct, type reviewCli as D, McpConfigEntry as Dt, type review as E, Effort as Et, type archiveRuns as F, type pipeline as G, type flow as H, type deleteRuns as I, type DiscoveredFlow as J, type steer as K, type RunOptions as L, readTask as M, type CoderError as N, type reviewFingerprints as O, Permission as Ot, type RunResult as P, type FlowStep as Q, type RunSummary as R, type postReview as S, Preset as St, type resolveReviewTarget as T, CustomModelConfig as Tt, type gate as U, type readTurnResults as V, type log as W, type FlowRecord as X, type FlowEvent as Y, type FlowSteerOptions as Z, type description as _, RunnerSpec as _t, type ReviewExec as a, type TurnResult as at, type ownReviewComments as b, TaskTurn as bt, type ReviewPostSummary as c, AppSync as ct, type ReviewSummary as d, LocalFolders as dt, FlowTaskResult as et, type ReviewTarget as f, ProbeResult as ft, type concurrency as g, RunnerRow as gt, type changedLines as h, RunnerPairing as ht, type ReviewAuth as i, Task as it, type TaskResult as j, type args$1 as k, config as kt, type ReviewResult as l, ConnectionRow as lt, args as m, RunnerKind as mt, type REVIEW_PLATFORM as n, Approval as nt, ReviewPostFinding as o, TaskLogEntry as ot, ReviewTargetInput as p, RunnerInput as pt, task as q, ReviewArgs as r, Availability as rt, ReviewPostInput as s, TokenUsage as st, Finding as t, GateResult as tt, ReviewServices as u, LocalFolder as ut, fingerprint as v, RunnerTest as vt, type repositoryRules as w, CoderConfig as wt, type parseGithubPr as x, PlatformEvent as xt, type lastReviewSummary as y, RunnerUpdate as yt, type StopSummary as z };