@wular/coder 0.4.2 → 0.4.4

package/dist/types-DMGBYB_K.d.ts

@@ -0,0 +1,391 @@
+import * as z from "zod/mini";
+import { SerializedMessage, SerializedThread } from "chat";
+//#region src/core/config.d.ts
+declare const engineSchema: z.ZodMiniEnum<{
+  codex: "codex";
+  claude: "claude";
+  custom: "custom";
+}>;
+declare const effortSchema: z.ZodMiniEnum<{
+  low: "low";
+  medium: "medium";
+  high: "high";
+}>;
+declare const permissionSchema: z.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<{
+    chat: "chat";
+    responses: "responses";
+  }>>;
+  disabled: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+}, z.core.$strict>;
+/** The merged, effective shape (everything present after DEFAULT_CONFIG). */
+declare const mcpEntrySchema: z.ZodMiniObject<{
+  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<{
+    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<{
+  chain: z.ZodMiniArray<z.ZodMiniEnum<{
+    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<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+      }>>;
+      permissions: z.ZodMiniOptional<z.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<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+      }>>;
+      permissions: z.ZodMiniOptional<z.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<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+      }>>;
+      permissions: z.ZodMiniOptional<z.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<{
+      chat: "chat";
+      responses: "responses";
+    }>>;
+    disabled: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+  }, z.core.$strict>, z.ZodMiniObject<{
+    provider: z.ZodMiniEnum<{
+      codex: "codex";
+      claude: "claude";
+    }>;
+    model: z.ZodMiniString<string>;
+    effort: z.ZodMiniOptional<z.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<{
+      low: "low";
+      medium: "medium";
+      high: "high";
+    }>>;
+    permissions: z.ZodMiniOptional<z.ZodMiniEnum<{
+      "read-only": "read-only";
+      "workspace-write": "workspace-write";
+      auto: "auto";
+    }>>;
+    runner: z.ZodMiniOptional<z.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<{
+      allowedTools: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniEnum<{
+        observe: "observe";
+        comment: "comment";
+        write: "write";
+      }>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+      allowedEvents: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
+    }, z.core.$strict>>>;
+  }, z.core.$strict>]>>>;
+  mcp: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniObject<{
+    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<{
+      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>;
+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>;
+/** Flags of `coder mcp add`: a remote `url` or a stdio `command`; env, header and tools are comma lists. */
+interface McpAddOptions {
+  url?: string;
+  transport?: string;
+  header?: string;
+  env?: string;
+  tools?: string;
+  command?: string[];
+  user?: boolean;
+}
+//#endregion
+//#region src/client/types.d.ts
+type RunnerKind = 'local' | 'local-docker' | 'vercel-sandbox' | 'github-actions' | 'http';
+interface RunnerSpec {
+  kind: RunnerKind;
+  name: string;
+  description: string;
+  connect: 'pair' | 'fields';
+  /** One or two sentences on what this kind needs and where to get it. */
+  help?: string;
+  fields: Array<{
+    key: string;
+    label: string;
+    secret?: boolean;
+    placeholder?: string;
+    optional?: boolean;
+    hint?: string;
+  }>;
+  available: boolean;
+  reason?: string;
+}
+interface RunnerRow {
+  id: string;
+  kind: RunnerKind;
+  name: string;
+  scope: 'personal' | 'workspace';
+  default: boolean;
+  online: boolean;
+  lastSeen?: number;
+  config: Record<string, string>;
+  createdAt: number;
+}
+interface RunnerPairing {
+  token: string;
+  expiresAt: number;
+  command: string;
+}
+interface RunnerInput {
+  kind: RunnerKind;
+  name: string;
+  scope: RunnerRow['scope'];
+  config: Record<string, string>;
+}
+interface RunnerUpdate {
+  name?: string;
+  default?: true;
+  config?: Record<string, string>;
+}
+interface RunnerTest {
+  ok: boolean;
+  detail: string;
+  ms: number;
+}
+interface ProbeResult {
+  reachable: boolean;
+  modelListed: boolean | null;
+  /** Model ids the endpoint lists, or null when it has no list. */
+  models: string[] | null;
+  detail: string;
+}
+interface LocalFolder {
+  path: string;
+  name: string;
+  recent?: number;
+  /** The git URL a cloned checkout came from. */
+  url?: string;
+}
+interface LocalFolders {
+  current: LocalFolder;
+  recent: LocalFolder[];
+  /** The machine can open its own folder dialog. */
+  picker: boolean;
+}
+interface TaskTurn {
+  prompt: string;
+  result?: {
+    ok?: boolean;
+    output?: string;
+    diff?: string;
+  } | string;
+  error?: string;
+  finishedAt?: number;
+  /** First log sequence after this turn. */
+  logSeq?: number;
+}
+//#endregion
+//#region src/core/task/log-view.d.ts
+interface TaskLogEntry {
+  at?: string;
+  message?: string;
+  kind?: string;
+  [key: string]: unknown;
+}
+interface TokenUsage {
+  input: number;
+  cachedInput: number;
+  output: number;
+  total: number;
+}
+//#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`). */
+interface McpServerSpec {
+  name: string;
+  command?: string;
+  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. */
+  url?: string;
+  type?: 'stdio' | 'http' | 'sse';
+  headers?: Record<string, string>;
+  /** Tool allowlist; omit or empty for every tool the server offers. */
+  tools?: string[];
+}
+type TaskKind = 'task';
+type TaskStatus = 'queued' | 'running' | 'completed' | 'failed' | 'cancelled';
+/** A persisted task record (task.json). Most fields accrete over the lifecycle. */
+interface Task {
+  id: string;
+  createdAt: string;
+  updatedAt?: string;
+  status: TaskStatus;
+  kind?: TaskKind;
+  name?: string | null;
+  engine?: Engine;
+  prompt?: string;
+  outputSchema?: object;
+  currentPrompt?: string | null;
+  system?: string | null;
+  model?: string | null;
+  effort?: Effort | null;
+  permissions?: Permission;
+  resumeThreadId?: string | null;
+  cwd?: string;
+  background?: boolean;
+  pid?: number | null;
+  dispatchId?: string;
+  threadId?: string | null;
+  turnId?: string | null;
+  steerEndpoint?: string | null;
+  completedAt?: string;
+  resumedAt?: string;
+  error?: string;
+  fallbacks?: Array<{
+    engine: Engine;
+    detail: string;
+    next: Engine;
+  }>;
+  archived?: boolean;
+  archivedAt?: string;
+  autoArchived?: boolean;
+  simulateApproval?: boolean;
+  flowRunId?: string;
+  agentId?: string;
+  source?: string;
+  author?: string;
+  repo?: string;
+  mcp?: McpServerSpec[];
+  nativeMcp?: boolean;
+  addDirs?: string[];
+}
+/** The outcome of running one engine turn. status 0 == success. */
+interface TurnResult {
+  status: number;
+  threadId: string | null;
+  turnId?: string | null;
+  finalMessage?: string;
+  touchedFiles?: string[];
+  tokens?: TokenUsage | null;
+  /** The model that ran the turn (tokens are only comparable per model). */
+  model?: string | null;
+  error?: {
+    message?: string;
+  } | null;
+  [key: string]: unknown;
+}
+/** Whether an engine binary is installed and usable. */
+interface Availability {
+  available: boolean;
+  detail: string;
+}
+/** A persisted approval escalation and its answer, if any. */
+interface Approval {
+  id: string;
+  summary: string;
+  /** Where an escalated command runs. */
+  cwd?: string;
+  createdAt?: string;
+  response?: {
+    decision: 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 { CoderConfig as C, McpConfigEntry as D, McpAddOptions as E, Permission as O, TaskTurn as S, Effort as T, RunnerPairing as _, HelpRow as a, RunnerTest as b, TaskStatus as c, TokenUsage as d, LocalFolder as f, RunnerKind as g, RunnerInput as h, CommandHelpSpec as i, TurnResult as l, ProbeResult as m, Availability as n, McpServerSpec as o, LocalFolders as p, CommandHandler as r, Task as s, Approval as t, TaskLogEntry as u, RunnerRow as v, CustomModelConfig as w, RunnerUpdate as x, RunnerSpec as y };

package/dist/unalias-G3sM8fVw.js

@@ -0,0 +1 @@
+import{i as e}from"./cli-msOzZFXW.js";import{o as t}from"./models-DGPrMV51.js";import{n}from"./add-cdKdz3K0.js";import{t as r}from"./remove-C8Rm8KP-.js";const i=e({name:`model unalias`,help:{usage:`coder model unalias <name> [--workspace]`,summary:`Remove a user-defined alias.`,flags:[[`--workspace`,`target <repo>/.coder/config.json instead of the user file`]]},options:n,args:1,run:({options:e,args:[n],cwd:r})=>t(r,n,e),print:e=>r(`unaliased`,e.unaliased,e.file)});export{i as commandModelUnalias};

package/dist/update-JvgB6Xws.js

@@ -0,0 +1,2 @@
+import{i as e}from"./cli-msOzZFXW.js";import{s as t}from"./models-DGPrMV51.js";import{a as n,i as r,n as i,r as a}from"./add-cdKdz3K0.js";const o=e({name:`model update`,help:{usage:`coder model update <name> [--base-url <url>] [--model <id>] [--env-key VAR]`,summary:`Update a configured custom model. Only the flags you pass change; the endpoint
+is re-probed and the wire protocol re-detected.`,flags:[[`--base-url <url>`,`new API base`],[`--model <id>`,`new provider model id`],[`--env-key <VAR>`,`new API-key env var`],[`--workspace`,`write to <repo>/.coder/config.json instead of the user file`]]},options:i,args:1,run:({options:e,args:[r],cwd:i})=>t(i,r,n(e)),json:a,print:e=>r(e,`updated`)});export{o as commandModelUpdate};

package/dist/upgrade-DN3hXDdo.js

@@ -0,0 +1,2 @@
+import{w as e}from"./dispatch-YW1aqjEg.js";import{i as t}from"./cli-msOzZFXW.js";import{f as n,p as r,t as i}from"./output-BKeyLbvt.js";import{n as a,s as o}from"./args-DEMOfLz2.js";import s from"node:process";const c=t({name:`upgrade`,globalFlags:{json:!1,cwd:!1},help:{usage:`coder upgrade [--cli-only] [--plugins-only] [--codex] [--claude] [--pm <mgr>]`,summary:`Update the coder CLI through whichever package manager installed it, then refresh
+the host plugins to match. Alias: update.`,flags:[[`--cli-only`,`update just the CLI`],[`--plugins-only`,`refresh just the host plugins`],[`--codex`,`limit the refresh to the Agent Skills copy (Codex, Pi, ...)`],[`--claude`,`limit the refresh to the Claude Code plugin`],[`--pm <npm|pnpm|yarn|bun>`,`force a package manager instead of auto-detecting`]]},options:{pm:o,"cli-only":a,"plugins-only":a,codex:a,claude:a},run:({options:t})=>e({...t,cliOnly:t[`cli-only`],pluginsOnly:t[`plugins-only`]},l),print:u});function l(e){s.stdout.write(`${r.bold(`Updating coder CLI`)} ${r.dim(`${e}...`)}\n`)}function u(e){let t=r.bold,a=r.dim,o=(e,n)=>n&&e&&n!==e?`${e} ${a(`->`)} ${t(n)}`:`${n??e??`?`} ${a(`(unchanged)`)}`,c=(e,t)=>`${t.installed?n(`${e} ${o(t.from,t.to)} ${a(`- ${t.note}`)}`):i(`${e} ${t.note}`)}\n`;e.cli&&s.stdout.write(e.cli.changed?`${n(`coder CLI  ${o(e.cli.from,e.cli.to)}`)}\n`:`${n(`coder CLI  ${e.cli.from} ${a(`(already latest)`)}`)}\n`),e.claudePlugin&&s.stdout.write(c(`claude plugin`,e.claudePlugin)),e.agentsSkill&&s.stdout.write(c(`agents skill `,e.agentsSkill))}const d=async()=>(await import(`./refresh-CmBQALAW.js`)).commandRefreshUpdate,f=Object.assign(async e=>e[0]===`refresh`?(await d())(e.slice(1)):c(e),c,{subcommands:{refresh:d}});export{f as commandUpgrade};

package/dist/usage-C1oN2W9c.js

@@ -0,0 +1 @@
+import{i as e,r as t}from"./cli-msOzZFXW.js";import{g as n,p as r}from"./output-BKeyLbvt.js";import{i,n as a,s as o,t as s}from"./args-DEMOfLz2.js";import c from"node:process";const l={server:i,workspace:o,yes:a};function u(e,t){let i=Array.isArray(e.totals)?e.totals.map(e=>({group:t??``,...e})):Object.entries(e.totals).flatMap(([e,t])=>t.map(t=>({group:e,...t})));if(!i.length)return void c.stdout.write(`${r.dim(`No usage in this period.`)}\n`);c.stdout.write(`${n([{header:`by`,value:e=>e.group},{header:`key`,value:e=>e.key,paint:e=>r.cyan(e)},{header:`tasks`,value:e=>String(e.tasks)},{header:`runner ms`,value:e=>String(e.runnerMs)},{header:`tokens`,value:e=>e.tokens===void 0?``:JSON.stringify(e.tokens)}],i,r)}\n`)}const d=e({name:`agent usage`,help:{usage:`coder agent usage [--since 7d|24h|<ms>] [--by agent|installation|engine] [--server [url]] [--json] [--cwd <dir>]`,flags:[[`--since <period|ms>`,`period such as 7d or 24h, or milliseconds since epoch`],[`--by <group>`,`agent, installation, or engine`],t]},options:{...s,...l,since:o,by:o},run:async({options:e,cwd:t})=>{let{agents:n}=await import(`./agent-BcXXkOmD.js`).then(e=>e.t);return n.usage({...e,cwd:t,organization:e.workspace,since:e.since??`7d`})},print:(e,{options:t})=>u(e,t.by)});export{d as commandAgentUsage};

package/dist/usage-DR3wWtYD.js

@@ -0,0 +1 @@
+import{t as e}from"./rolldown-runtime-DT7IzrpZ.js";import{a as t,i as n}from"./load-DDZfByUe.js";import{a as r,d as i,f as a,n as o,u as s}from"./http-DG54kyx4.js";import{y as c}from"./store-qp7UE2ES.js";var l=e({addUsage:()=>f,leaders:()=>m,readUsage:()=>x,readUsageTotals:()=>S,timeZone:()=>d,usageReport:()=>b,usageSummary:()=>_,usageTotals:()=>p});function u(e){return typeof e==`number`?e:!e||typeof e!=`object`||Array.isArray(e)?0:`total`in e&&typeof e.total==`number`?e.total:Object.values(e).reduce((e,t)=>e+u(t),0)}function d(e){if(!e)return`UTC`;try{return new Intl.DateTimeFormat(`en`,{timeZone:e}),e}catch{return`UTC`}}const f=(e,t)=>{e.tasks+=t.tasks,e.runnerMs+=t.runnerMs,e.tokenCount+=t.tokenCount};async function p(e,t){if(e.usageTotals)return e.usageTotals(t);if(t.top){let{top:n,...r}=t,i=(await p(e,{...r,by:`agent`,parts:void 0})).sort((e,t)=>t[n.by]-e[n.by]||e.key.localeCompare(t.key)).slice(0,n.count).map(e=>e.key);return p(e,{...r,parts:i})}let n=d(t.tz),r=new Intl.DateTimeFormat(`en-CA`,{timeZone:n,year:`numeric`,month:`2-digit`,day:`2-digit`}),i=new Set(t.parts),a=new Map;for(let{value:n}of await e.list(`usage`)){if(n.at<t.since||t.until!==void 0&&n.at>=t.until||t.agent&&n.agent!==t.agent)continue;let e=t.by===`agent`?n.agent:t.by===`installation`?n.installationId??`none`:t.by===`engine`?n.engine??`unknown`:r.format(n.at),o={tasks:1,runnerMs:n.runnerElapsedMs,tokenCount:u(n.tokens)},s=a.get(e)??{key:e,tasks:0,runnerMs:0,tokenCount:0};f(s,o),i.has(n.agent)&&(s.parts??={},f(s.parts[n.agent]??={tasks:0,runnerMs:0,tokenCount:0},o)),a.set(e,s)}return[...a.values()].sort((e,t)=>e.key.localeCompare(t.key))}function m(e,t){let n=new Map;for(let r of e)for(let[e,i]of Object.entries(r.parts??{}))n.set(e,(n.get(e)??0)+i[t]);return[...n].sort((e,t)=>t[1]-e[1]||e[0].localeCompare(t[0])).map(([e])=>e)}function h(e,t){if(typeof t==`number`)return(typeof e==`number`?e:0)+t;if(!t||typeof t!=`object`||Array.isArray(t))return e;let n=e&&typeof e==`object`&&!Array.isArray(e)?{...e}:{};for(let[e,r]of Object.entries(t))n[e]=h(n[e],r);return n}function g(e,t){let n=new Map;for(let r of e){let e=t===`agent`?r.agent:t===`installation`?r.installationId??`none`:r.engine??`unknown`,i=n.get(e)??{key:e,tasks:0,runnerMs:0};i.tasks++,i.runnerMs+=r.runnerElapsedMs,r.tokens!==void 0&&(i.tokens=h(i.tokens,r.tokens)),n.set(e,i)}return[...n.values()].sort((e,t)=>e.key.localeCompare(t.key))}function _(e,t,n){let r=e.filter(e=>e.at>=t);return{since:t,totals:n?g(r,n):{agent:g(r,`agent`),installation:g(r,`installation`),engine:g(r,`engine`)}}}const v={tasks:`tasks`,runner:`runnerMs`,tokens:`tokenCount`},y={tokens:e=>e.tokenCount,tasks:e=>e.tasks,runner:e=>e.runnerMs,name:e=>e.key};async function b(e,c){let l=e=>c.searchParams.get(e),u=Number(l(`since`)??0),f=l(`until`)===null?void 0:Number(l(`until`)),h=l(`by`)??`agent`;if(!Number.isFinite(u)||f!==void 0&&!Number.isFinite(f)||![`agent`,`installation`,`engine`,`day`].includes(h))return r({error:`Invalid usage query`},400);let g=l(`parts`)?.split(`,`).filter(Boolean),_=Math.min(Number(l(`top`)??0),8),b=v[l(`sort`)??`tokens`]??`tokenCount`,x=await p(e.store,{by:h,since:u,...f===void 0?{}:{until:f},...l(`agent`)?{agent:l(`agent`)}:{},...h===`day`?{tz:d(l(`tz`))}:{},...g?.length?{parts:g.slice(0,20)}:{},..._>0?{top:{count:_,by:b}}:{}}),S={since:u,...f===void 0?{}:{until:f}};if(h===`agent`){let r=new Set(e.local?(await t(e.local.cwd,e.integrations)).map(e=>e.id):(await e.store.list(`agent`)).map(e=>e.id));for(let e of Object.keys(n()))r.add(e);for(let e of x)r.has(e.key)||(e.deleted=!0)}if(_>0)return r({...S,totals:x,top:m(x,b)});if(!a(c)||h!==`agent`)return r({...S,totals:x});let C=y[l(`sort`)??`tokens`]??y.tokens,w=l(`sort`)===`name`,T=l(`q`)?.trim().toLowerCase(),E=([e,t],[n,r])=>(e<n?-1:+(e>n))*(w?1:-1)||t.localeCompare(r),D=e=>[C(e),e.key],O=o(c),k=x.filter(e=>!T||e.key.toLowerCase().includes(T)).filter(e=>!O||E(D(e),O)>0).sort((e,t)=>E(D(e),D(t))),A=i(c),j=e=>x.reduce((t,n)=>t+e(n),0);return r({...S,...s(k.slice(0,A+1),A,D),summary:{agents:x.length,tasks:j(e=>e.tasks),runnerMs:j(e=>e.runnerMs),tokenCount:j(e=>e.tokenCount)}})}async function x(e,t,n,i){t.local&&await c(t);let a=i.searchParams.get(`installation`),o=await t.store.list(`usage`);return r(a?o.filter(e=>e.value.installationId===a):o)}async function S(e,t,n,i){t.local&&await c(t);let a=Number(i.searchParams.get(`since`)??0),o=i.searchParams.get(`by`);if([`until`,`agent`,`tz`,`parts`,`top`,`cursor`].some(e=>i.searchParams.has(e))||o===`day`)return b(t,i);if(!Number.isFinite(a)||o&&![`agent`,`installation`,`engine`].includes(o))return r({error:`Invalid usage query`},400);let s=(await t.store.list(`usage`)).map(e=>e.value);return r(_(s,a,o))}export{l as a,d as i,x as n,S as r,f as t};

package/dist/watch-DDmHonTf.js

@@ -0,0 +1,5 @@
+import{Kt as e}from"./dispatch-YW1aqjEg.js";import{i as t}from"./cli-msOzZFXW.js";import{_ as n,a as r,b as i,c as a,h as o,l as s,n as c,p as l,s as u,u as d,v as f,y as p}from"./output-BKeyLbvt.js";import{l as m,t as h}from"./args-DEMOfLz2.js";import g from"node:process";const _=t({name:`flow watch`,help:{usage:`coder flow watch [run-id] [--tail <n|all>] [--json]`,summary:`Watch a flow run live: replay its progress lines from the start, then keep
+following while it runs (Ctrl-C detaches; it keeps running). Blocks until it
+finishes; exits 0 on success, 1 otherwise. Defaults to the most recent run.
+For the result alone, prefer \`coder flow result\`. Alias: stream.`,flags:[[`--tail <n|all>`,`replay only the last n events first (default: all)`]],examples:[[`coder flow watch`,`follow the most recent run to completion`]]},options:{...h,tail:m},args:1,run:async({options:e,args:[t]})=>{let{watchRun:n}=await import(`./executor-HWnIIYUL.js`).then(e=>e.b);return N(n(t,{tail:e.tail}),{json:e.json,stream:!0})}}),v=[`⣾`,`⣽`,`⣻`,`⢿`,`⡿`,`⣟`,`⣯`,`⣷`];function y(e,t=!1){let n=l;return t?c(`[${x(e)}]`,10):e===`completed`?n.bold(n.green(`✔`)):e===`failed`||e===`cancelled`||e===`stopped`?n.bold(n.red(`✘`)):e===`running`?n.bold(n.cyan(`●`)):n.dim(`○`)}function b(){return c(`[start]`,10)}function x(e){return e===`completed`?`done`:e===`cancelled`?`failed`:e}function S(e,t){return e??t.replace(/\s+/g,` `).trim().slice(0,60)}function C(e,t,n,r,i,a){let o=l,u=c(t??n,32);return[`${e} ${a?o.bold(u):u}`,o.dim(c(n,24)),o.light(c(i??``,20)),r?o.light(`${s(r.total)} tok`):``].join(` `).trimEnd()}function w(e,t=!1){let n=l;return`${y(e.ok?`completed`:`failed`,t)} ${n.dim(`gate`)} ${n.light(e.cmd)}${e.ok?``:n.dim(` · exit ${e.code}`)}`}function T(e,t,n){let i=l,a=n!==void 0&&n>=1e3?i.dim(` · ${r(n)}`):``;return`${t} ${i.dim(`gate`)} ${i.light(e)}${a}`}function E(e,t=!1){return l.dim(`${`│    `.repeat(e)}${t?`└─`:`├─`}`)}function D(e){return l.dim(`${`│    `.repeat(e)}│ `)}function O(e){return`${`  `.repeat(e.depth)}${e.log?`${c(`[log]`,10)} `:``}${e.body}`}function k(e,t,n=!1){return n?O(e):`${e.log?D(e.depth):E(e.depth,t)} ${e.body}`}function A(e){return l.dim(`${`│    `.repeat(Math.max(0,e))}│`)}var j=class{stream;names=new Map;active=new Map;activeGates=new Map;pending;previews=new Map;frame=0;hasCommitted=!1;timer;tty;region;constructor(e=g.stdout){this.stream=e,this.tty=!!e.isTTY,this.region=new n(e)}emit(e){let t=l;switch(e.kind){case`task-start`:{let t={name:S(e.name,e.prompt),engine:e.engine,depth:e.depth??0};if(this.names.set(e.taskId,t),!this.tty){this.final(t.depth,C(b(),t.name,e.taskId,null,t.engine));return}this.active.set(e.taskId,t),this.spin(!0),this.repaint();return}case`task-end`:{this.active.delete(e.taskId),this.previews.delete(e.taskId),this.idle();let t=this.names.get(e.taskId);this.final(t?.depth??0,C(y(e.status,!this.tty),t?.name??null,e.taskId,e.tokens,t?.engine));return}case`gate-start`:{let t={cmd:e.cmd,depth:e.depth??0,startedAt:Date.now()};if(!this.tty){this.final(t.depth,T(t.cmd,b()));return}this.activeGates.set(e.gateId,t),this.spin(!0),this.repaint();return}case`gate`:e.gateId&&this.activeGates.delete(e.gateId),this.idle(),this.final(e.depth??0,w(e,!this.tty));return;case`log`:for(let n of e.message.split(`
+`))this.final(e.depth??0,t.light(n),!0);return;case`flow-start`:this.final(e.depth-1,t.bold(`flow ${e.name}`));return;case`replay`:this.final(0,t.dim(`replayed ${e.count} steps from journal`),!0)}}done(){this.spin(!1),this.flush(0),this.tty&&this.repaint(),this.region.done()}flush(e){this.pending&&=(this.region.commit(`${k(this.pending,e<this.pending.depth,!this.tty)}\n`),this.hasCommitted=!0,void 0)}final(e,t,n=!1){if(!this.tty){this.region.commit(`${O({depth:e,body:t,log:n})}\n`),this.hasCommitted=!0;return}this.flush(e),this.pending={depth:e,body:t,log:n},this.tty&&this.repaint()}repaint(){let e=[],t=[];if(this.pending){let n=k(this.pending,!1);e.push(n),t.push(n)}let n=this.timer?l.bold(l.cyan(v[this.frame%v.length])):y(`running`);for(let[r,i]of this.active){let a=`${E(i.depth??0)} ${C(n,i.name,r,null,i.engine,!0)}`;(e.length||this.hasCommitted)&&e.push(A(i.depth??0)),e.push(a),t.push(a);let o=this.previews.get(r);o&&e.push(`${D(i.depth??0)} ${l.dim(o)}`)}for(let r of this.activeGates.values()){let i=`${E(r.depth)} ${T(r.cmd,n,Date.now()-r.startedAt)}`;(e.length||this.hasCommitted)&&e.push(A(r.depth)),e.push(i),t.push(i)}let r=(i(this.stream)??1/0)-1,a=e.length<=r?e:t;if(a.length>r){let e=Math.max(0,r-1);a=[l.dim(`… +${a.length-e} more running`),...a.slice(-e)]}this.region.set(a)}refreshPreviews(){for(let t of this.active.keys())try{let n=e(g.cwd(),t,1)[0]?.message?.replace(/\s+/g,` `).trim();if(!n)continue;let r=(p(this.stream)??120)-8;this.previews.set(t,n.length>r?`${n.slice(0,r-1)}…`:n)}catch{}}idle(){!this.active.size&&!this.activeGates.size&&this.spin(!1)}spin(e){e&&!this.timer?this.timer=setInterval(()=>{this.frame++,this.frame%4==0&&this.refreshPreviews(),this.repaint()},120).unref():!e&&this.timer&&(clearInterval(this.timer),this.timer=void 0)}};function M(e,t){if(t){o(e);return}let n=!g.stdout.isTTY,r=n?``:`${l.dim(`└─`)} `;g.stdout.write(`${r}${y(`completed`,n)} run ${l.cyan(e.runId)} completed ${l.dim(`(${e.taskCount} tasks)`)}\n`),g.stdout.write(`\n${a(e.result)}\n`),P(e.tokens)}async function N(e,t){let{runId:n}=e.record,r=!!(t.stream&&t.json);!t.json&&e.record.status===`running`&&g.stderr.write(`${l.dim(`[flow]`)} Run ${l.cyan(n)} started and is waiting to finish. Press Ctrl-C to detach. It keeps running.\n\n`);let i=t.json?()=>{}:f(),a=()=>{i(),r||(g.stderr.write(`\n${l.dim(`[flow] Detached. The run is still going.`)}\n`),g.stderr.write(`\n${u([`Result: coder flow result ${n}`,`Stop it: coder flow stop ${n}`],l)}\n`)),g.exit(130)};g.on(`SIGINT`,a);let s=new j;for await(let n of e.events)r?g.stdout.write(`${JSON.stringify(n)}\n`):t.json||s.emit(n);s.done(),i(),g.off(`SIGINT`,a);let c=e.final();r&&(g.stdout.write(`${JSON.stringify(F(c))}\n`),g.exit(c.status===`completed`?0:1)),c.status===`completed`&&(M({runId:n,name:c.name,status:`completed`,result:c.result,tokens:c.ledger,taskCount:c.taskCount},t.json),g.exit(0)),c.status===`stopped`&&(t.json?o({runId:n,name:c.name,status:`stopped`,taskCount:c.taskCount}):g.stdout.write(`\n${l.dim(`[flow] Run ${n} stopped.`)}\n\n${u([`Resume: coder flow resume ${n}`],l)}\n`),g.exit(1)),g.stdout.write(`\n${l.red(`error:`)} ${c.error??`unknown error`}\n`),g.stdout.write(`\n${u([`Resume: coder flow resume ${n}`],l)}\n`),g.exit(1)}function P(e){let t=Object.keys(e);if(t.length){g.stdout.write(`\n${l.bold(`Tokens:`)}\n`);for(let n of t)g.stdout.write(`  ${l.dim(d(e[n],n))}\n`)}}function F(e){let{steps:t,events:n,...r}=e;return r}export{j as FlowStepRenderer,_ as commandWatch,w as gateLine,T as gateRunningLine,O as paintPlain,N as printFollow,P as printLedger,M as printRunSummary,F as resultJson,y as stepSymbol,S as taskLabel,C as taskLine};

package/dist/watch-DYkC6Q2q.js

@@ -0,0 +1,8 @@
+import{fn as e,jn as t}from"./dispatch-YW1aqjEg.js";import{i as n,r}from"./cli-msOzZFXW.js";import{p as i,y as a}from"./output-BKeyLbvt.js";import{i as o,l as s,n as c,s as l,t as u}from"./args-DEMOfLz2.js";import{a as d,d as f,i as p,l as m,n as h,t as g,u as _}from"./result-oQey_hdw.js";import v from"node:process";import*as y from"zod/mini";const b={server:o,workspace:l,yes:c};function x(e,t){let n=e.level===`sys`?t.dim(`· ${e.line}`):e.level===`err`?t.light(e.line):e.line;v.stdout.write(`${n}\n`)}async function S(n,r,o){if(`attempts`in n.task){for await(let e of n.events)o.json?v.stdout.write(`${JSON.stringify(e,null,2)}\n`):x(e,i);let e=await n.final();o.json||p(e,i),v.exit(0)}let s=n.task,c=o.trim===void 0?500:o.trim===`none`?1/0:o.trim,l=await g.create({cwd:s.cwd??r,startedAt:Date.parse(s.createdAt??``)||void 0,trim:c,explicitTrim:o.trim!==void 0,width:a()});if(!o.json){let t=[...m(s,{status:s.status}),...e.includes(s.status)?[i.dim(`Watching. Press Ctrl-C to stop.`)]:[],...s.prompt?d(s.prompt,i,{truncate:!1}):[],``];v.stdout.write(`${t.join(`
+`)}\n`)}let u=null,y=null,b=e=>{let t=l.render(e);t.length&&v.stdout.write(`${t.join(`
+`)}\n`)};for await(let e of n.events){let t=e;if(t.kind===`usage`&&t.tokens&&(u=t.tokens),o.json){let e=t.kind===`steer`?1/0:c,n=t.message?{...t,message:f(t.message,e,{plain:!0})}:t;v.stdout.write(`${JSON.stringify(n)}\n`);continue}t.kind!==`usage`&&(y&&=(b(y),null),t.kind===`assistant`?y=t:b(t))}let{status:S,result:C,task:w}=await n.final();if(o.json)v.stdout.write(`${JSON.stringify({taskId:s.id,status:S,result:C},null,2)}\n`);else{let e=S===`completed`?`(no final message)`:`(task ${S})`,n=_(w,{tokens:C?.tokens??u,tokenModel:C?.model,files:C?.touchedFiles?.map(e=>t(s.cwd??r,e)),statusChanged:S!==s.status});n.length&&v.stderr.write(`\n${n.join(`
+`)}\n`);let i=h(C,w.error,e),a=y?String(y.message??``):``;v.stdout.write(`\n${i.trim()?i:a}\n`)}v.exit(S===`completed`?0:1)}const C=n({name:`task watch`,help:{usage:`coder task watch [task-id] [--server [url]]`,summary:`Stream a running task's transcript live (for you/debugging), then print its
+final answer. Replays the last line first so the current step is visible;
+--tail <n> replays the last n lines (--tail all for the whole transcript).
+Blocks until it finishes; exits 0 on success, 1 otherwise. For the answer
+alone, prefer \`coder result\`. Alias: stream.`,flags:[[`--tail <n|all>`,`replay the last n log lines first (default: 1)`],[`--trim <n|none>`,`budget for tool output and thinking (default: 1200 chars, 12 lines)`],r],examples:[[`coder task watch`,`follow the most recent task to completion`]]},options:{...u,tail:s,trim:y.optional(y.union([y.literal(`none`),y.coerce.number().check(y.int(),y.positive())],{error:`expected a positive integer or "none"`})),...b},args:1,async run({options:e,args:[t],cwd:n}){let{tasks:r}=await import(`./task-DEp3GHwH.js`).then(e=>e.t);await S(await r.watch(t,{...e,organization:e.workspace}),n,e)}});export{C as commandWatch,x as printLine};

package/dist/wire-DxxfWapP.js

@@ -0,0 +1 @@
+import{Z as e}from"./dispatch-YW1aqjEg.js";import t from"node:process";async function n(n,r,i){let a=n.envKey?t.env[n.envKey]:void 0,o=!1;for(let t of e(n.baseUrl,r))try{let e=await fetch(t,{method:`POST`,headers:{"content-type":`application/json`,...a?{Authorization:`Bearer ${a}`}:{}},body:JSON.stringify(i),signal:AbortSignal.timeout(5e3)});if(o=!0,e.status!==404&&e.status!==405&&e.status!==501)return{baseUrl:t.slice(0,-(r.length+1))}}catch{}return{reachable:o}}async function r(e){let t=await n(e,`responses`,{model:e.model,input:[],stream:!1});if(`baseUrl`in t)return{wireApi:`responses`,baseUrl:t.baseUrl};let r=await n(e,`chat/completions`,{model:e.model,messages:[],stream:!1});return`baseUrl`in r?{wireApi:`chat`,baseUrl:r.baseUrl}:t.reachable||r.reachable?{wireApi:`chat`}:null}export{r as t};

package/dist/worker-C4Lo6rLS.js

@@ -0,0 +1,9 @@
+import{At as e,D as t,Et as n,F as r,Mn as i,P as a,Vt as o,an as s,c,cn as l,dn as u,dt as d,et as f,ft as p,g as m,j as h,lt as g,nn as _,pt as v,q as y,tt as b,x}from"./dispatch-YW1aqjEg.js";import{t as S}from"./chat-bridge-18koyS7c.js";import{t as C}from"./wire-DxxfWapP.js";import w from"node:path";import T from"node:process";import E from"node:fs";function D(e){if(e.resumeThreadId)return e.currentPrompt??e.prompt??``;let t=e.system?`\n-------\n${e.system}`:``;return`<system>
+You are running inside a coder task: do the work yourself, directly.
+Do not load the coder skill (recursive), and never dispatch through the \`coder\` CLI - nested dispatch is disabled.
+When finished, provide a concise implementation result summary.
+Your turn is one-shot: background processes will not re-invoke you after it ends, so verify synchronously before finishing.
+Never run git write operations (commit, checkout, stash, reset, rebase, merge, push, etc.); leave changes uncommitted for the caller to review.${e.agentId?"\nFlows are the exception: run one from your shell with `coder flow run <name> --wait --json --args '<json>'`; it runs as a script in your sandbox.":``}${t}
+</system>
+
+${e.prompt??``}`}function O(e,t){let n=0;return()=>{Date.now()-n>=1e4&&(n=Date.now(),l(e,t))}}function k(e,t,{echo:r}){return i=>{let a=typeof i==`string`?{message:i}:i;n(e,t,a),r&&a.message&&T.stderr.write(`[coder] ${a.message}\n`)}}async function A(e,t,{echo:i}){let o=s(e),l=_(e,t.id),x=b(e),w=k(e,t.id,{echo:i}),E=y[t.permissions??`auto`]??y.auto,A=E.approvalPolicy===`never`?void 0:m({workspaceRoot:o,taskDir:l,mode:E.approvalMode,escalationTimeoutMs:x.approvals.escalationTimeoutMs,allowedNetworkHosts:x.approvals.allowedNetworkHosts,onEvent:r=>{n(e,t.id,r),i&&r.message&&T.stderr.write(`[coder] ${r.message}\n`)}}),j=t.model?x.models?.[t.model]:void 0,N=j&&f(j)?j:void 0;if(N&&!N.wireApi&&t.model){let r=await C(N);r&&(N={...N,...r},x.models[t.model]=N,g(e,t.model,r),n(e,t.id,{kind:`info`,message:`detected wire api for ${t.model}: ${r.wireApi} @ ${N.baseUrl}`}))}if(N?.envKey&&!T.env[N.envKey])throw Error(`Missing environment variable: \`${N.envKey}\`.`);let P=N?await S(N,N.wireApi??`chat`):null,F=v(x,t.model,P??void 0),I=r(e,t);try{let n=await h(e,{prompt:D(t),outputSchema:t.outputSchema,model:F?.model??d(t.model),modelProvider:F?.modelProvider??null,configOverrides:I?{...F?.configOverrides,"shell_environment_policy.set":{[a]:I}}:F?.configOverrides??null,effort:t.effort,sandbox:E.sandbox,approvalPolicy:E.approvalPolicy,networkAccess:p(t.permissions??`auto`,x.engines.codex?.network),approvalsReviewer:E.approvalMode===`auto`?`auto_review`:null,mcpServers:c(t.mcp),nativeMcp:t.nativeMcp??!1,writableRoots:[...E.sandbox===`read-only`?[]:t.addDirs??[],...I?[I]:[]],onApprovalRequest:A,onHeartbeat:O(e,t.id),resumeThreadId:t.resumeThreadId??null,onControlReady:(n,r,i)=>{u(e,t.id,{status:`running`,steerEndpoint:n,threadId:r,turnId:i})},onProgress:n=>{w(n);let r=typeof n==`object`?n.threadId:null,i=typeof n==`object`?n.turnId:null;(r||i)&&u(e,t.id,{status:`running`,...r?{threadId:r}:{},...i?{turnId:i}:{}})}});return u(e,t.id,{status:n.status===0?`completed`:`failed`,threadId:n.threadId,turnId:n.turnId,steerEndpoint:null,completedAt:new Date().toISOString()}),M(e,t,l,n),n}finally{u(e,t.id,{steerEndpoint:null}),await P?.close()}}async function j(e,n,{echo:i}){let o=_(e,n.id),s=b(e),l=k(e,n.id,{echo:i}),d=y[n.permissions??`auto`]??y.auto,f=r(e,n);try{let r=await t(e,{prompt:D(n),outputSchema:n.outputSchema,model:n.model,effort:n.effort,permissions:n.permissions,approvalTaskId:d.approvalMode===`auto`?n.id:null,allowedNetworkHosts:s.approvals.allowedNetworkHosts,additionalDirectories:n.addDirs,...f?{writableDirectories:[f],env:{[a]:f}}:{},mcpServers:c(n.mcp),nativeMcp:n.nativeMcp??!1,taskRoot:o,resumeSessionId:n.resumeThreadId??null,onHeartbeat:O(e,n.id),onSteerReady:t=>{u(e,n.id,{status:`running`,steerEndpoint:t})},onProgress:t=>{l(t),t.threadId&&u(e,n.id,{status:`running`,threadId:t.threadId})}});return u(e,n.id,{status:r.status===0?`completed`:`failed`,threadId:r.threadId,steerEndpoint:null,completedAt:new Date().toISOString()}),M(e,n,o,r),r}finally{u(e,n.id,{steerEndpoint:null})}}function M(e,t,n,r){i(w.join(n,`result.json`),r);let a={at:new Date().toISOString(),prompt:t.currentPrompt??t.prompt??null,...r};E.appendFileSync(w.join(n,`results.jsonl`),`${JSON.stringify(a)}\n`,`utf8`)}function N(e){return e.engine===`claude`?j:A}async function P(t,r){for(let i=0;i<2;){let a=o(t,r);if(!a||a.status===`failed`||a.status===`cancelled`)return;let s=e(t,r);if(s.length===0){i+=1,await new Promise(e=>setTimeout(e,300));continue}i=0;for(let e of s){let i=u(t,r,{status:`running`,currentPrompt:e,resumeThreadId:a.threadId??null});n(t,r,{message:`Running steered follow-up.`});try{await N(i)(t,i,{echo:!1})}catch(e){let i=e instanceof Error?e.message:String(e);u(t,r,{status:`failed`,error:i}),n(t,r,{kind:`error`,message:i});return}}}}async function F(e,t,r){if(t.dispatchId&&!t.resumedAt)try{E.writeFileSync(w.join(_(e,t.id),`start-${t.dispatchId}`),``,{flag:`wx`})}catch(e){if(e.code===`EEXIST`)return;throw e}u(e,t.id,{status:`running`,pid:T.pid});let i=()=>{},a;try{if(i=r(e,t),t.name?.startsWith(`agent:`)){let{startInboxControl:n,applyTaskMessage:r}=await import(`./task-DhZ5vhyY.js`).then(e=>e.d);a=n(_(e,t.id),t.name.slice(6),n=>r(e,o(e,t.id)??t,n))}if(t.simulateApproval){let r=await x(_(e,t.id),{onEvent:r=>n(e,t.id,r)});if(n(e,t.id,{message:`simulated approval: ${r}`}),r===`decline`){u(e,t.id,{status:`cancelled`,completedAt:new Date().toISOString(),error:`simulated approval denied`});return}}await N(t)(e,t,{echo:!1}),await P(e,t.id)}catch(r){let i=r instanceof Error?r.message:String(r);throw u(e,t.id,{status:`failed`,error:i}),n(e,t.id,{kind:`error`,message:i}),r}finally{i(),await a?.close()}}export{F as runWorker};

package/dist/worker-CaNTsqcD.js

@@ -0,0 +1 @@
+import{Vt as e}from"./dispatch-YW1aqjEg.js";import{i as t}from"./cli-msOzZFXW.js";import{i as n}from"./output-BKeyLbvt.js";import{s as r}from"./args-DEMOfLz2.js";import i from"node:process";const a=t({name:`task worker`,options:{cwd:r},args:1,async run({args:[t],cwd:r}){let{startAgentMailbox:a}=await import(`./exec-DgI3boHa.js`).then(e=>e.i),{runWorker:o}=await import(`./worker-C4Lo6rLS.js`),s=e(r,t);s||n(`Worker: task ${t} not found.`),await o(r,s,a).catch(()=>i.exit(1))}});export{a as commandWorker};

package/dist/workflow-7rqzHHWZ.js

@@ -0,0 +1 @@
+import{i as e}from"./cli-msOzZFXW.js";import t from"node:process";const n=e({name:`server workflow`,globalFlags:{json:!1,cwd:!1},help:{usage:`coder server workflow`,summary:`Print the workflow the github-actions runner dispatches. Save it as .github/workflows/coder-agent.yml in every repo the agent runs on, and set RUNNER=github-actions on the server.`,examples:[[`coder server workflow > .github/workflows/coder-agent.yml`,`add it to a repo`]]},options:{},run:async()=>{let{ACTIONS_WORKFLOW_YAML:e}=await import(`./github-actions-CvLya8ve.js`).then(e=>e.r);return e},print:e=>t.stdout.write(e)});export{n as commandServerWorkflow};

package/docs/cli.md

@@ -10,7 +10,7 @@ Every command, grouped by what it acts on. Run `coder <command> --help` for the
 | `coder list`                                 | Recent tasks, running and just stopped. `--running`, `--stopped`, `--archived`, `--limit <n>`. |
 | `coder result [task-id]`                     | Status and final answer. `--wait` blocks until it's ready.                                     |
 | `coder task watch [task-id]`                 | Stream the live transcript.                                                                    |
-| `coder task steer <task-id> "<text>"`        | Continue the task's thread with new instructions, mid-run.                                     |
+| `coder task steer <task-id> "<text>"`        | Continue the task's thread mid-run, or resume a finished or archived task on the same id.      |
 | `coder task ask <task-id> "<question>"`      | Ask about a task without interrupting it.                                                      |
 | `coder task stop <task-id>`                  | Interrupt a running task.                                                                      |
 | `coder task approvals [task-id]`             | Approvals waiting on you, across tasks or for one.                                             |
@@ -33,7 +33,6 @@ Every command, grouped by what it acts on. Run `coder <command> --help` for the
 | `--add-dir <dir>`                  | Give the task another directory beyond `--cwd`. Repeatable.                      |
 | `--output-schema <json>`           | JSON Schema the answer must match.                                               |
 | `--name <name>`                    | Label the task in `list` and `result`.                                           |
-| `--resume <task-id>`               | Continue that task's thread instead of starting fresh.                           |
 | `--server [url]`                   | Run on your Coder server and follow it here. `--repo` and `--runner` pick where. |
 
 ## Flows

package/docs/config.md

@@ -67,7 +67,7 @@ Per-engine defaults, used when a dispatch doesn't override them:
 
 Permission modes are one surface across all engines: read-only can't modify anything, workspace-write stays inside the repo, and auto enables Codex network access plus policy-answered escalations; `engines.codex.network` overrides network access for every mode when set.
 
-A task reaches only its workspace unless you give it more. Pass `--add-dir <dir>` to `coder run` once for each sibling repo or shared folder the task needs. Relative paths resolve against the workspace and each one must already exist. Read-only tasks can read these directories but never write them, while workspace-write and auto tasks can write them just like the workspace. Claude receives them as `--add-dir` and `permissions.additionalDirectories`, so its OS sandbox follows the same rules. Codex already reads everywhere in read-only, and in the other modes it receives them as extra writable roots in the turn's sandbox policy. The directories are saved on the task, `coder result` lists them, and both `--resume` and steering keep them.
+A task reaches only its workspace unless you give it more. Pass `--add-dir <dir>` to `coder run` once for each sibling repo or shared folder the task needs. Relative paths resolve against the workspace and each one must already exist. Read-only tasks can read these directories but never write them, while workspace-write and auto tasks can write them just like the workspace. Claude receives them as `--add-dir` and `permissions.additionalDirectories`, so its OS sandbox follows the same rules. Codex already reads everywhere in read-only, and in the other modes it receives them as extra writable roots in the turn's sandbox policy. The directories are saved on the task, `coder result` lists them, and steering keeps them.
 
 ## `models`
 

package/docs/flows.md

@@ -59,7 +59,7 @@ const r = await task('Explain the auth module', {
 r.output; // final message text
 ```
 
-Options are the same as the `coder run` flags (`engine`, `model`, `effort`, `permissions`, `name`, `system`, `resume`, `cwd`, and `addDirs` for `--add-dir` - see `coder run --help`), plus one of its own:
+Options are the same as the `coder run` flags (`engine`, `model`, `effort`, `permissions`, `name`, `system`, `cwd`, and `addDirs` for `--add-dir` - see `coder run --help`), plus one of its own:
 
 - `returns` - a zod schema for structured output instead of prose. The runtime passes the schema natively, validates the reply (one corrective retry on mismatch), and the parsed value lands on `r.data`:
 
@@ -75,6 +75,17 @@ Returns `{ taskId, status, output, data?, tokens, model }`. If the task fails, `
 
 > Note: unlike the SDK's `task.run()`, which returns a task id right away and leaves waiting to you, the flow `task()` waits for the result in one call, and inside a run it is journaled and concurrency-limited.
 
+### `steer(taskId, text, opts?)`
+
+Give a task this run started one more turn on its own thread, under the same task id, and await it. It mirrors `coder task steer --wait`, with the same `model`, `effort` and `permissions` overrides:
+
+```ts
+const draft = await task('Draft the migration for the new orders table.');
+const fixed = await steer(draft.taskId, 'Now add the down migration.');
+```
+
+Returns the same shape as `task()` without `data`, throws if the turn fails, and is journaled like `task()`.
+
 ### `gate(cmd, opts?)`
 
 A deterministic shell checkpoint. Gates are never agents: they run the command and return `{ ok, code, output }`. A failing gate does not throw, because a failed gate is a decision point, not an error:

package/docs/mcp.md

@@ -1,6 +1,6 @@
 # MCP
 
-Give tasks tools of your own: an MCP server is saved once under `mcp` in `.coder/config.json`, then attached to a task by name. Nothing attaches unless asked, so the default run stays lean.
+Give tasks tools of your own: an MCP server is saved once under `mcp` in `.coder/config.json`, then attached to a task by name. Nothing attaches unless asked, so the default run stays lean. `--mcp all` also loads your engine's own MCP servers and connectors.
 
 ```sh
 coder mcp add docs -- npx -y docs-mcp                       # stdio server: the command after --

package/docs/sdk.md

@@ -26,7 +26,7 @@ SDK functions never print and never call `process.exit`; results come back as ty
 | `coder run "<text>"`                                                                   | `task.run(prompt, opts?)`                                                                                                                                                                                                                             |
 | `coder list`                                                                           | `task.list(opts?)`                                                                                                                                                                                                                                    |
 | `coder result [id] [--wait] [--tail N] [--turns]`                                      | `task.result(id?, { wait?, tail? })` - returns `turns` (one entry per finished turn) alongside `result`                                                                                                                                               |
-| `coder task steer <id> "<text>"`                                                       | `task.steer(id, text)`                                                                                                                                                                                                                                |
+| `coder task steer <id> "<text>"`                                                       | `task.steer(id, text, { model?, effort?, permissions?, wait? })` - live, or resumes a finished or archived task on the same id                                                                                                                        |
 | `coder task ask <id> "<question>"`                                                     | `task.ask(id, question, { model?, effort? })` - read-only sidecar answer; the task's thread is never touched                                                                                                                                          |
 | `coder task stop <id>`                                                                 | `task.stop(id)`                                                                                                                                                                                                                                       |
 | `coder task watch [id] [--tail N]`                                                     | `task.stream(id?, { tail? })` - async iterable of progress events                                                                                                                                                                                     |

package/migrations/0000_initial.sql

@@ -209,6 +209,12 @@ CREATE TABLE "coder"."task_log" (
 	CONSTRAINT "task_log_taskId_seq_unique" UNIQUE("task_id","seq")
 );
 --> statement-breakpoint
+CREATE TABLE "coder"."task_tombstone" (
+	"organization_id" text NOT NULL,
+	"public_id" text NOT NULL,
+	"deleted_at" timestamp with time zone NOT NULL
+);
+--> statement-breakpoint
 CREATE TABLE "coder"."usage" (
 	"id" bigserial PRIMARY KEY NOT NULL,
 	"organization_id" text NOT NULL,
@@ -246,7 +252,9 @@ CREATE INDEX "platform_link_user_id_index" ON "coder"."platform_link" USING btre
 CREATE INDEX "secret_organization_id_kind_index" ON "coder"."secret" USING btree ("organization_id","kind");--> statement-breakpoint
 CREATE INDEX "task_public_id_index" ON "coder"."task" USING btree ("public_id");--> statement-breakpoint
 CREATE INDEX "task_organization_id_created_at_public_id_index" ON "coder"."task" USING btree ("organization_id","created_at" DESC NULLS LAST,"public_id" DESC NULLS LAST);--> statement-breakpoint
+CREATE INDEX "task_organization_id_updated_at_index" ON "coder"."task" USING btree ("organization_id","updated_at");--> statement-breakpoint
 CREATE INDEX "task_organization_id_index" ON "coder"."task" USING btree ("organization_id") WHERE "coder"."task"."status" = 'queued';--> statement-breakpoint
 CREATE INDEX "task_status_created_at_index" ON "coder"."task" USING btree ("status","created_at");--> statement-breakpoint
 CREATE INDEX "task_inbox_task_id_generation_seq_index" ON "coder"."task_inbox" USING btree ("task_id","generation","seq");--> statement-breakpoint
+CREATE INDEX "task_tombstone_organization_id_deleted_at_index" ON "coder"."task_tombstone" USING btree ("organization_id","deleted_at");--> statement-breakpoint
 CREATE INDEX "usage_organization_id_at_index" ON "coder"."usage" USING btree ("organization_id","at");