@overaihq/cli 0.15.1 → 0.16.0

package/dist/index.js

@@ -1591,7 +1591,7 @@ var require_xpath = __commonJS({
       function toString2(x) {
         return x.toString();
       }
-      var join8 = function(s, xs) {
+      var join9 = function(s, xs) {
         return xs.join(s);
       };
       var wrap = function(pref, suf, str) {
@@ -3337,7 +3337,7 @@ var require_xpath = __commonJS({
         return wrap("[", "]", predicate.toString());
       };
       PathExpr.predicatesString = function(predicates) {
-        return join8(
+        return join9(
           "",
           map3(PathExpr.predicateString, predicates)
         );
@@ -4692,7 +4692,7 @@ var require_xpath = __commonJS({
           }
           return acc;
         }, {}, from);
-        var t = join8(
+        var t = join9(
           "",
           map3(function(ch) {
             return ch in cMap ? cMap[ch] : ch;
@@ -13529,7 +13529,7 @@ var require_jsonata = __commonJS({
                 }
                 return result;
               }
-              function join8(strs, separator) {
+              function join9(strs, separator) {
                 if (typeof strs === "undefined") {
                   return void 0;
                 }
@@ -14460,7 +14460,7 @@ var require_jsonata = __commonJS({
                 contains: contains2,
                 replace: replace2,
                 split: split2,
-                join: join8,
+                join: join9,
                 formatNumber,
                 formatBase,
                 number: number4,
@@ -38122,6 +38122,1082 @@ var automationRunState = async (client, runId) => {
   if (data.automationRun == null) throw new Error(`Run ${runId} not found.`);
   return data.automationRun.state ?? {};
 };
+var automationRun = async (client, runId, options) => {
+  const data = await client.graphql(
+    `query SdkAutomationRun($id: String!) {
+      automationRun(id: $id) {
+        id startedAt endedAt errored isCancelled manuallyTriggered version { num }
+      }
+    }`,
+    { id: runId },
+    options
+  );
+  const run2 = data.automationRun;
+  if (run2 == null)
+    throw new Error(
+      `Run ${runId} not found or not accessible in this organization.`
+    );
+  return {
+    id: run2.id,
+    version: run2.version?.num,
+    startedAt: run2.startedAt,
+    endedAt: run2.endedAt,
+    status: run2.errored ? "errored" : run2.isCancelled ? "cancelled" : run2.endedAt == null ? "running" : "ok",
+    manual: run2.manuallyTriggered
+  };
+};
+
+// ../common/src/llm/models.ts
+var DEFAULT_MODEL = "claude-sonnet-5-5";
+var DEFAULT_OPENAI_MODEL = "gpt-6.1-sol";
+var LARGE_SCHEMA_MODELS = [
+  DEFAULT_OPENAI_MODEL,
+  "gemini-4-argon"
+];
+var stripAnthropicThinking = (opts) => {
+  const anthropicOpts = opts?.anthropic;
+  if (!opts || !anthropicOpts || !("thinking" in anthropicOpts)) return opts;
+  const { thinking: _omit, ...rest } = anthropicOpts;
+  return { ...opts, anthropic: rest };
+};
+var bothVertexRegions = (route) => [
+  { ...route, subprocessor: "vertex-global" },
+  { ...route, subprocessor: "vertex-us" }
+];
+var HAIKU_5_5_PRICING = {
+  input: 0.1,
+  output: 0.5,
+  cacheRead: 0.01,
+  cacheWrite: 0.125,
+  longContext: {
+    inputTokenThreshold: 1e5,
+    input: 0.5,
+    output: 2.5,
+    cacheRead: 0.05,
+    cacheWrite: 0.625
+  }
+};
+var GEMINI_FLASH_PROMO_PRICING = {
+  input: 0.75,
+  output: 3.75,
+  cacheRead: 0.075,
+  cacheWrite: 0.75
+};
+var SONNET_5_5_PRICING_PERIODS = [
+  {
+    from: "2026-09-28",
+    through: "2026-10-06",
+    pricing: { input: 2, output: 10, cacheRead: 0.2, cacheWrite: 2.5 }
+  }
+];
+var MODEL_ROUTES = [
+  // Anthropic. Pricing cacheWrite = 1.25x input — the 5-minute-TTL write rate,
+  // which is what applyAnthropicCacheBreakpoints buys (1h TTL would bill 2x).
+  // The 5.5 generation: 1M context, 128K output, vision and tool use.
+  // Current architect default (see DEFAULT_MODEL).
+  {
+    model: "claude-sonnet-5-5",
+    id: "claude-sonnet-5-5",
+    name: "Claude Sonnet 5.5",
+    subprocessor: "anthropic",
+    provider: "anthropic",
+    active: true,
+    pricing: { input: 2, output: 10, cacheRead: 0.1, cacheWrite: 2.5 },
+    pricingPeriods: SONNET_5_5_PRICING_PERIODS
+  },
+  {
+    model: "claude-opus-5-5",
+    id: "claude-opus-5-5",
+    name: "Claude Opus 5.5",
+    subprocessor: "anthropic",
+    provider: "anthropic",
+    active: true,
+    pricing: { input: 4, output: 20, cacheRead: 0.2, cacheWrite: 5 }
+  },
+  {
+    model: "claude-fable-5-1",
+    id: "claude-fable-5-1",
+    name: "Claude Fable 5.1",
+    subprocessor: "anthropic",
+    provider: "anthropic",
+    active: true,
+    pricing: { input: 10, output: 50, cacheRead: 0.25, cacheWrite: 12.5 },
+    providerOptionsTransform: stripAnthropicThinking
+  },
+  {
+    model: "claude-haiku-5-5",
+    id: "claude-haiku-5-5",
+    name: "Claude Haiku 5.5",
+    subprocessor: "anthropic",
+    provider: "anthropic",
+    active: true,
+    pricing: HAIKU_5_5_PRICING
+  },
+  {
+    model: "claude-sonnet-4-6",
+    id: "claude-sonnet-4-6",
+    name: "Claude Sonnet 4.6",
+    subprocessor: "anthropic",
+    provider: "anthropic",
+    active: true,
+    pricing: { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 }
+  },
+  // Superseded by Sonnet 5.5: same input and output price, half the cache-read
+  // rate. Launched 2026-06-30 at a $2/$10 launch rate that Anthropic made
+  // permanent on 2026-08-10, so the announced $3/$15 was never billed and the
+  // row needs no pricing window.
+  {
+    model: "claude-sonnet-5",
+    id: "claude-sonnet-5",
+    name: "Claude Sonnet 5",
+    subprocessor: "anthropic",
+    provider: "anthropic",
+    active: false,
+    pricing: { input: 2, output: 10, cacheRead: 0.2, cacheWrite: 2.5 }
+  },
+  // Superseded by Opus 5.5 (cheaper, newer).
+  {
+    model: "claude-opus-5",
+    id: "claude-opus-5",
+    name: "Claude Opus 5",
+    subprocessor: "anthropic",
+    provider: "anthropic",
+    active: false,
+    pricing: { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 }
+  },
+  // Superseded by Fable 5.1 (same price).
+  {
+    model: "claude-fable-5",
+    id: "claude-fable-5",
+    name: "Claude Fable 5",
+    subprocessor: "anthropic",
+    provider: "anthropic",
+    active: false,
+    pricing: { input: 10, output: 50, cacheRead: 1, cacheWrite: 12.5 },
+    providerOptionsTransform: stripAnthropicThinking
+  },
+  // Superseded by Haiku 5.5 at a tenth of the price. Its "not sooner than
+  // 2026-10-15" retirement date has passed with no deprecation notice yet.
+  {
+    model: "claude-haiku-4-5",
+    id: "claude-haiku-4-5",
+    name: "Claude Haiku 4.5",
+    subprocessor: "anthropic",
+    provider: "anthropic",
+    active: false,
+    pricing: { input: 1, output: 5, cacheRead: 0.1, cacheWrite: 1.25 }
+  },
+  // Superseded by Opus 5 (same price, newer); kept addressable for persisted
+  // automations/agents but dropped from the dropdown.
+  {
+    model: "claude-opus-4-8",
+    id: "claude-opus-4-8",
+    name: "Claude Opus 4.8",
+    subprocessor: "anthropic",
+    provider: "anthropic",
+    active: false,
+    pricing: { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 }
+  },
+  // Opus 4.7 sat between 4.6 and 4.8; kept addressable for any persisted
+  // automations but not surfaced in the dropdown now that 4.8 is out.
+  {
+    model: "claude-opus-4-7",
+    id: "claude-opus-4-7",
+    name: "Claude Opus 4.7",
+    subprocessor: "anthropic",
+    provider: "anthropic",
+    active: false,
+    pricing: { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 }
+  },
+  // $5/$25 since its 2026-02-05 launch (the $15/$75 to $5/$25 cut came with
+  // Opus 4.5); keep in sync with platform.claude.com/docs/.../pricing.
+  {
+    model: "claude-opus-4-6",
+    id: "claude-opus-4-6",
+    name: "Claude Opus 4.6",
+    subprocessor: "anthropic",
+    provider: "anthropic",
+    active: false,
+    pricing: { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 }
+  },
+  // Deprecated 2026-09-30; retires on the direct API 2026-11-30, when
+  // SUNSET_MODEL_REPLACEMENTS moves persisted names to Sonnet 5.5.
+  {
+    model: "claude-sonnet-4-5",
+    id: "claude-sonnet-4-5",
+    name: "Claude Sonnet 4.5",
+    subprocessor: "anthropic",
+    provider: "anthropic",
+    active: false,
+    pricing: { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 }
+  },
+  // OpenAI (docs at developers.openai.com). The 6 line (Astra frontier / Sol
+  // balanced / Luna efficient) supersedes 5.6; 5.6 and older stay addressable
+  // for persisted configs but drop from the dropdown. From 5.6 on, cacheRead =
+  // 10% of input (6.1 Sol: 5%) and cacheWrite = 1.25x input for the default
+  // 30-minute cache; older models bill no cache write, so their cacheWrite
+  // equals input. Above 272K input tokens OpenAI bills the full request at 2x
+  // input and cache rates and 1.5x output.
+  {
+    model: "gpt-6.1-sol",
+    id: "gpt-6.1-sol",
+    name: "GPT 6.1 Sol",
+    subprocessor: "openai",
+    provider: "openai",
+    active: true,
+    pricing: {
+      input: 2,
+      output: 10,
+      cacheRead: 0.1,
+      cacheWrite: 2.5,
+      longContext: {
+        inputTokenThreshold: 272e3,
+        input: 4,
+        output: 15,
+        cacheRead: 0.2,
+        cacheWrite: 5
+      }
+    }
+  },
+  {
+    model: "gpt-6-luna",
+    id: "gpt-6-luna",
+    name: "GPT 6 Luna",
+    subprocessor: "openai",
+    provider: "openai",
+    active: true,
+    pricing: {
+      input: 0.1,
+      output: 0.5,
+      cacheRead: 0.01,
+      cacheWrite: 0.125,
+      longContext: {
+        inputTokenThreshold: 272e3,
+        input: 0.2,
+        output: 0.75,
+        cacheRead: 0.02,
+        cacheWrite: 0.25
+      }
+    }
+  },
+  {
+    model: "gpt-6-astra",
+    id: "gpt-6-astra",
+    name: "GPT 6 Astra",
+    subprocessor: "openai",
+    provider: "openai",
+    active: true,
+    pricing: {
+      input: 10,
+      output: 50,
+      cacheRead: 1,
+      cacheWrite: 12.5,
+      longContext: {
+        inputTokenThreshold: 272e3,
+        input: 20,
+        output: 75,
+        cacheRead: 2,
+        cacheWrite: 25
+      }
+    }
+  },
+  // Superseded a week later by 6.1 Sol at the same price with half the
+  // cache-read rate. Chat Completions serves it only with
+  // `reasoning_effort: none`.
+  {
+    model: "gpt-6-sol",
+    id: "gpt-6-sol",
+    name: "GPT 6 Sol",
+    subprocessor: "openai",
+    provider: "openai",
+    active: false,
+    pricing: {
+      input: 2,
+      output: 10,
+      cacheRead: 0.2,
+      cacheWrite: 2.5,
+      longContext: {
+        inputTokenThreshold: 272e3,
+        input: 4,
+        output: 15,
+        cacheRead: 0.4,
+        cacheWrite: 5
+      }
+    }
+  },
+  // The 5.6 line launched 2026-07-09. OpenAI cut Terra 20% and Luna 80% on
+  // 2026-07-30; each row's window holds the launch rate for usage before the cut.
+  {
+    model: "gpt-5.6-terra",
+    id: "gpt-5.6-terra",
+    name: "GPT 5.6 Terra",
+    subprocessor: "openai",
+    provider: "openai",
+    active: false,
+    pricing: {
+      input: 2,
+      output: 12,
+      cacheRead: 0.2,
+      cacheWrite: 2.5,
+      longContext: {
+        inputTokenThreshold: 272e3,
+        input: 4,
+        output: 18,
+        cacheRead: 0.4,
+        cacheWrite: 5
+      }
+    },
+    pricingPeriods: [
+      {
+        from: "2026-07-09",
+        through: "2026-07-29",
+        pricing: {
+          input: 2.5,
+          output: 15,
+          cacheRead: 0.25,
+          cacheWrite: 3.125,
+          longContext: {
+            inputTokenThreshold: 272e3,
+            input: 5,
+            output: 22.5,
+            cacheRead: 0.5,
+            cacheWrite: 6.25
+          }
+        }
+      }
+    ]
+  },
+  // Sol's $4/$20 promo runs through 2026-11-29; standard rates resume November 30.
+  {
+    model: "gpt-5.6-sol",
+    id: "gpt-5.6-sol",
+    name: "GPT 5.6 Sol",
+    subprocessor: "openai",
+    provider: "openai",
+    active: false,
+    pricing: {
+      input: 5,
+      output: 30,
+      cacheRead: 0.5,
+      cacheWrite: 6.25,
+      longContext: {
+        inputTokenThreshold: 272e3,
+        input: 10,
+        output: 45,
+        cacheRead: 1,
+        cacheWrite: 12.5
+      }
+    },
+    pricingPeriods: [
+      {
+        from: "2026-08-21",
+        through: "2026-11-29",
+        pricing: {
+          input: 4,
+          output: 20,
+          cacheRead: 0.4,
+          cacheWrite: 5,
+          longContext: {
+            inputTokenThreshold: 272e3,
+            input: 8,
+            output: 30,
+            cacheRead: 0.8,
+            cacheWrite: 10
+          }
+        }
+      }
+    ]
+  },
+  {
+    model: "gpt-5.6-luna",
+    id: "gpt-5.6-luna",
+    name: "GPT 5.6 Luna",
+    subprocessor: "openai",
+    provider: "openai",
+    active: false,
+    pricing: {
+      input: 0.2,
+      output: 1.2,
+      cacheRead: 0.02,
+      cacheWrite: 0.25,
+      longContext: {
+        inputTokenThreshold: 272e3,
+        input: 0.4,
+        output: 1.8,
+        cacheRead: 0.04,
+        cacheWrite: 0.5
+      }
+    },
+    pricingPeriods: [
+      {
+        from: "2026-07-09",
+        through: "2026-07-29",
+        pricing: {
+          input: 1,
+          output: 6,
+          cacheRead: 0.1,
+          cacheWrite: 1.25,
+          longContext: {
+            inputTokenThreshold: 272e3,
+            input: 2,
+            output: 9,
+            cacheRead: 0.2,
+            cacheWrite: 2.5
+          }
+        }
+      }
+    ]
+  },
+  {
+    model: "gpt-5.4",
+    id: "gpt-5.4",
+    name: "GPT 5.4",
+    subprocessor: "openai",
+    provider: "openai",
+    active: false,
+    pricing: {
+      input: 2.5,
+      output: 15,
+      cacheRead: 0.25,
+      cacheWrite: 2.5,
+      longContext: {
+        inputTokenThreshold: 272e3,
+        input: 5,
+        output: 22.5,
+        cacheRead: 0.5,
+        cacheWrite: 5
+      }
+    }
+  },
+  // Shuts down 2027-04-01. OpenAI names gpt-6-sol as the replacement; the
+  // sunset entry should point at gpt-6.1-sol.
+  {
+    model: "gpt-5.3-codex",
+    id: "gpt-5.3-codex",
+    name: "GPT 5.3 Codex",
+    subprocessor: "openai",
+    provider: "openai",
+    active: false,
+    pricing: { input: 1.75, output: 14, cacheRead: 0.175, cacheWrite: 1.75 }
+  },
+  {
+    model: "gpt-5.4-mini",
+    id: "gpt-5.4-mini",
+    name: "GPT 5.4 Mini",
+    subprocessor: "openai",
+    provider: "openai",
+    active: false,
+    pricing: { input: 0.75, output: 4.5, cacheRead: 0.075, cacheWrite: 0.75 }
+  },
+  {
+    model: "gpt-5.2",
+    id: "gpt-5.2",
+    name: "GPT 5.2",
+    subprocessor: "openai",
+    provider: "openai",
+    active: false,
+    pricing: { input: 1.75, output: 14, cacheRead: 0.175, cacheWrite: 1.75 }
+  },
+  {
+    model: "gpt-5-mini",
+    id: "gpt-5-mini",
+    name: "GPT 5 Mini",
+    subprocessor: "openai",
+    provider: "openai",
+    active: false,
+    pricing: { input: 0.25, output: 2, cacheRead: 0.025, cacheWrite: 0.25 }
+  },
+  {
+    model: "gpt-5",
+    id: "gpt-5",
+    name: "GPT 5",
+    subprocessor: "openai",
+    provider: "openai",
+    active: false,
+    pricing: { input: 1.25, output: 10, cacheRead: 0.125, cacheWrite: 1.25 }
+  },
+  // Shuts down 2027-01-14; OpenAI's replacement is gpt-6-luna.
+  {
+    model: "gpt-4.1",
+    id: "gpt-4.1",
+    name: "GPT 4.1",
+    subprocessor: "openai",
+    provider: "openai",
+    active: false,
+    pricing: { input: 2, output: 8, cacheRead: 0.5, cacheWrite: 2 }
+  },
+  // Google, native Gemini. Vertex retired the 2.5 generation on 2026-10-20;
+  // those rows stay to price historical usage, and SUNSET_MODEL_REPLACEMENTS
+  // rewrites persisted names onto 3.8 Flash. Pricing cacheWrite mirrors input —
+  // Vertex has no separate cache-write rate. 3.8/3.7/3.6 Flash bill a half-price
+  // promo through 2026-12-31 (see GEMINI_FLASH_PROMO_PRICING).
+  // Current Google default (see DEFAULT_GOOGLE_MODEL); kept in the dropdown so
+  // the default is a first-class selectable option, not a hidden ID.
+  ...bothVertexRegions({
+    model: "gemini-3.8-flash",
+    id: "gemini-3.8-flash",
+    name: "Gemini 3.8 Flash",
+    provider: "google",
+    active: true,
+    pricing: { input: 1.5, output: 7.5, cacheRead: 0.15, cacheWrite: 1.5 },
+    pricingPeriods: [
+      {
+        from: "2026-09-02",
+        through: "2026-12-31",
+        pricing: GEMINI_FLASH_PROMO_PRICING
+      }
+    ]
+  }),
+  // Google's Gemini 4 line, GA 2026-10-13 on Vertex from both `global` and the
+  // `us` multi-region per Google's model page (not probed by direct call here).
+  // The top Google model, Pro-priced, with no long-context tier. 1M context
+  // shared between input and output, 64K output per request. Rejects
+  // `thinking_budget` (we send none); implicit context caching only, no
+  // explicit caches.
+  ...bothVertexRegions({
+    model: "gemini-4-argon",
+    id: "gemini-4-argon",
+    name: "Gemini 4 Argon",
+    provider: "google",
+    active: true,
+    pricing: { input: 4, output: 20, cacheRead: 0.2, cacheWrite: 4 },
+    pricingPeriods: [
+      {
+        from: "2026-10-13",
+        through: "2026-11-30",
+        pricing: { input: 2, output: 10, cacheRead: 0.1, cacheWrite: 2 }
+      }
+    ]
+  }),
+  // Superseded by 3.8 Flash (identical pricing, newer); kept addressable for
+  // persisted automations but dropped from the dropdown. Vertex retires it
+  // 2027-01-28.
+  ...bothVertexRegions({
+    model: "gemini-3.7-flash",
+    id: "gemini-3.7-flash",
+    name: "Gemini 3.7 Flash",
+    provider: "google",
+    active: false,
+    pricing: { input: 1.5, output: 7.5, cacheRead: 0.15, cacheWrite: 1.5 },
+    pricingPeriods: [
+      {
+        from: "2026-08-13",
+        through: "2026-12-31",
+        pricing: GEMINI_FLASH_PROMO_PRICING
+      }
+    ]
+  }),
+  // Still the only Pro-branded id, and still preview: Vertex publishes it under
+  // the `-preview` suffix and serves it from the global endpoint only (preview
+  // models are global-only, hence the single route). Switch to a GA ID without
+  // the suffix if Google promotes it. Gemini 4 Argon is the top Google model.
+  {
+    model: "gemini-3.1-pro-preview",
+    id: "gemini-3.1-pro-preview",
+    name: "Gemini 3.1 Pro (Preview)",
+    subprocessor: "vertex-global",
+    provider: "google",
+    active: true,
+    pricing: {
+      input: 2,
+      output: 12,
+      cacheRead: 0.2,
+      cacheWrite: 2,
+      longContext: {
+        inputTokenThreshold: 2e5,
+        input: 4,
+        output: 18,
+        cacheRead: 0.4,
+        cacheWrite: 4
+      }
+    }
+  },
+  // Superseded by 3.7 Flash (identical pricing, newer); kept addressable for
+  // persisted automations but dropped from the dropdown. Vertex retires it
+  // 2026-11-19 (see SUNSET_MODEL_REPLACEMENTS). Google's `us` multi-region allowlist on 3.6 was lifted
+  // 2026-08-18 (Gemini Enterprise release notes), and the `us` endpoint serves
+  // it — verified by direct call.
+  ...bothVertexRegions({
+    model: "gemini-3.6-flash",
+    id: "gemini-3.6-flash",
+    name: "Gemini 3.6 Flash",
+    provider: "google",
+    active: false,
+    pricing: { input: 1.5, output: 7.5, cacheRead: 0.15, cacheWrite: 1.5 },
+    pricingPeriods: [
+      {
+        from: "2026-08-13",
+        through: "2026-12-31",
+        pricing: GEMINI_FLASH_PROMO_PRICING
+      }
+    ]
+  }),
+  ...bothVertexRegions({
+    model: "gemini-3.5-flash-lite",
+    id: "gemini-3.5-flash-lite",
+    name: "Gemini 3.5 Flash-Lite",
+    provider: "google",
+    active: true,
+    pricing: { input: 0.3, output: 2.5, cacheRead: 0.03, cacheWrite: 0.3 }
+  }),
+  // Superseded by 3.6 Flash (same input rate, cheaper output, ~17% fewer
+  // output tokens); kept addressable for persisted automations but dropped
+  // from the dropdown.
+  ...bothVertexRegions({
+    model: "gemini-3.5-flash",
+    id: "gemini-3.5-flash",
+    name: "Gemini 3.5 Flash",
+    provider: "google",
+    active: false,
+    pricing: { input: 1.5, output: 9, cacheRead: 0.15, cacheWrite: 1.5 }
+  }),
+  // Retired by Vertex 2026-10-20 (see SUNSET_MODEL_REPLACEMENTS); kept to price
+  // historical usage. Never served by the `us` multi-region endpoint, hence the
+  // single global route.
+  {
+    model: "gemini-2.5-pro",
+    id: "gemini-2.5-pro",
+    name: "Gemini 2.5 Pro",
+    subprocessor: "vertex-global",
+    provider: "google",
+    active: false,
+    pricing: {
+      input: 1.25,
+      output: 10,
+      cacheRead: 0.125,
+      cacheWrite: 1.25,
+      longContext: {
+        inputTokenThreshold: 2e5,
+        input: 2.5,
+        output: 15,
+        cacheRead: 0.25,
+        cacheWrite: 2.5
+      }
+    }
+  },
+  {
+    model: "gemini-2.5-flash",
+    id: "gemini-2.5-flash",
+    name: "Gemini 2.5 Flash",
+    subprocessor: "vertex-global",
+    provider: "google",
+    active: false,
+    pricing: { input: 0.3, output: 2.5, cacheRead: 0.03, cacheWrite: 0.3 }
+  },
+  /*
+   * Vertex MaaS (Model-as-a-Service). Open/partner models — GLM (ZAI) —
+   * served over Vertex's OpenAI-compatible Chat Completions endpoint, a
+   * different transport from the native Gemini models above (see
+   * `vertexMaasModel` in common-server/src/llm.ts). IDs are the
+   * `<publisher>/<model>-maas` strings Vertex Model Garden lists. Reuse the
+   * same GOOGLE_VERTEX_* service-account creds — no per-model secret — and are
+   * billed as Vertex usage. These models are region-gated: only `global`
+   * serves them — the `us` multi-region endpoint 404s both, verified by
+   * direct call.
+   *
+   * Pricing: these open models expose no prompt-cache discount on Vertex (nor
+   * on Bedrock — only Anthropic and Nova cache there), so cacheRead and
+   * cacheWrite both mirror input: a cache hit costs the same as fresh input.
+   * Rates are each model's standard published rate.
+   */
+  {
+    model: "glm-5",
+    id: "zai-org/glm-5-maas",
+    name: "GLM 5 (Vertex)",
+    subprocessor: "vertex-global",
+    provider: "vertex-maas",
+    active: true,
+    pricing: { input: 1, output: 3.2, cacheRead: 1, cacheWrite: 1 }
+  },
+  {
+    model: "glm-4.7",
+    id: "zai-org/glm-4.7-maas",
+    name: "GLM 4.7 (Vertex)",
+    subprocessor: "vertex-global",
+    provider: "vertex-maas",
+    active: true,
+    pricing: { input: 0.6, output: 2.2, cacheRead: 0.6, cacheWrite: 0.6 }
+  },
+  /*
+   * Amazon Bedrock. IDs are raw Bedrock model strings: `global.*` prefixes are
+   * global cross-region inference profiles (AWS may process in any commercial
+   * region, at the direct-API price), `us.*` are US-only profiles (+10%, kept
+   * for the ids the enclave clusters persisted), and bare `<publisher>.*` IDs
+   * are single-region foundation models. Auth uses the default AWS credential
+   * chain — ECS task role in deploys, AWS_ACCESS_KEY_ID + AWS_REGION env vars
+   * locally.
+   *
+   * Claude first. These rows share `model` with the Anthropic rows so a
+   * cluster can serve every persisted Claude name from Amazon instead:
+   * `claude-sonnet-4-6` resolves to the Bedrock row wherever
+   * LLM_SUBPROCESSOR_PREFERENCE puts `bedrock` first (see
+   * common-server/src/aiSubprocessors.ts). They are `active: false` because
+   * the dropdown already offers each model once, under its Anthropic-named
+   * row, and the router picks the host. Claude on Bedrock dispatches through
+   * the SDK's native Messages API entry point (common-server/src/llm.ts), so
+   * the same `anthropic.cacheControl` breakpoints and provider options apply
+   * as on the direct route, and pricing — base and cache multipliers — matches
+   * Anthropic's on `global.*` profiles.
+   */
+  // The 5.5 generation, priced at the direct rates: Anthropic's Bedrock page
+  // states `global.*` profiles carry no premium (AWS's per-token table renders
+  // client-side and was not read). Unlike Haiku 4.5's, these ids carry no date
+  // or `-v1:0` suffix.
+  {
+    model: "claude-sonnet-5-5",
+    id: "global.anthropic.claude-sonnet-5-5",
+    name: "Claude Sonnet 5.5 (Bedrock)",
+    subprocessor: "bedrock",
+    provider: "bedrock",
+    active: false,
+    pricing: { input: 2, output: 10, cacheRead: 0.1, cacheWrite: 2.5 },
+    pricingPeriods: SONNET_5_5_PRICING_PERIODS
+  },
+  {
+    model: "claude-opus-5-5",
+    id: "global.anthropic.claude-opus-5-5",
+    name: "Claude Opus 5.5 (Bedrock)",
+    subprocessor: "bedrock",
+    provider: "bedrock",
+    active: false,
+    pricing: { input: 4, output: 20, cacheRead: 0.2, cacheWrite: 5 }
+  },
+  {
+    model: "claude-fable-5-1",
+    id: "global.anthropic.claude-fable-5-1",
+    name: "Claude Fable 5.1 (Bedrock)",
+    subprocessor: "bedrock",
+    provider: "bedrock",
+    active: false,
+    pricing: { input: 10, output: 50, cacheRead: 0.25, cacheWrite: 12.5 },
+    providerOptionsTransform: stripAnthropicThinking
+  },
+  // AWS lists the >100K tier as a separate "Long Context" line.
+  {
+    model: "claude-haiku-5-5",
+    id: "global.anthropic.claude-haiku-5-5",
+    name: "Claude Haiku 5.5 (Bedrock)",
+    subprocessor: "bedrock",
+    provider: "bedrock",
+    active: false,
+    pricing: HAIKU_5_5_PRICING
+  },
+  {
+    model: "claude-sonnet-4-6",
+    id: "global.anthropic.claude-sonnet-4-6",
+    name: "Claude Sonnet 4.6 (Bedrock)",
+    subprocessor: "bedrock",
+    provider: "bedrock",
+    active: false,
+    pricing: { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 }
+  },
+  {
+    model: "claude-sonnet-5",
+    id: "global.anthropic.claude-sonnet-5",
+    name: "Claude Sonnet 5 (Bedrock)",
+    subprocessor: "bedrock",
+    provider: "bedrock",
+    active: false,
+    pricing: { input: 2, output: 10, cacheRead: 0.2, cacheWrite: 2.5 }
+  },
+  {
+    model: "claude-opus-5",
+    id: "global.anthropic.claude-opus-5",
+    name: "Claude Opus 5 (Bedrock)",
+    subprocessor: "bedrock",
+    provider: "bedrock",
+    active: false,
+    pricing: { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 }
+  },
+  {
+    model: "claude-fable-5",
+    id: "global.anthropic.claude-fable-5",
+    name: "Claude Fable 5 (Bedrock)",
+    subprocessor: "bedrock",
+    provider: "bedrock",
+    active: false,
+    pricing: { input: 10, output: 50, cacheRead: 1, cacheWrite: 12.5 },
+    providerOptionsTransform: stripAnthropicThinking
+  },
+  {
+    model: "claude-haiku-4-5",
+    id: "global.anthropic.claude-haiku-4-5-20251001-v1:0",
+    name: "Claude Haiku 4.5 (Bedrock)",
+    subprocessor: "bedrock",
+    provider: "bedrock",
+    active: false,
+    pricing: { input: 1, output: 5, cacheRead: 0.1, cacheWrite: 1.25 }
+  },
+  // Prior-generation rows so a persisted name keeps resolving to the
+  // preferred host rather than quietly staying on the direct route.
+  {
+    model: "claude-opus-4-8",
+    id: "global.anthropic.claude-opus-4-8",
+    name: "Claude Opus 4.8 (Bedrock)",
+    subprocessor: "bedrock",
+    provider: "bedrock",
+    active: false,
+    pricing: { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 }
+  },
+  {
+    model: "claude-opus-4-7",
+    id: "global.anthropic.claude-opus-4-7",
+    name: "Claude Opus 4.7 (Bedrock)",
+    subprocessor: "bedrock",
+    provider: "bedrock",
+    active: false,
+    pricing: { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 }
+  },
+  {
+    model: "claude-opus-4-6",
+    id: "global.anthropic.claude-opus-4-6-v1",
+    name: "Claude Opus 4.6 (Bedrock)",
+    subprocessor: "bedrock",
+    provider: "bedrock",
+    active: false,
+    pricing: { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 }
+  },
+  {
+    model: "claude-sonnet-4-5",
+    id: "global.anthropic.claude-sonnet-4-5-20250929-v1:0",
+    name: "Claude Sonnet 4.5 (Bedrock)",
+    subprocessor: "bedrock",
+    provider: "bedrock",
+    active: false,
+    pricing: { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 }
+  },
+  // US-only profile, kept under its persisted id: the enclave clusters reach
+  // only Bedrock and their saved resources name this string. Ranked behind the
+  // global row so a model name lands there only where global is unreachable.
+  // AWS bills US-pinned profiles 10% over the direct rate.
+  {
+    model: "claude-sonnet-4-5",
+    id: "us.anthropic.claude-sonnet-4-5-20250929-v1:0",
+    name: "Claude Sonnet 4.5 (Bedrock \u2014 US)",
+    subprocessor: "bedrock",
+    provider: "bedrock",
+    active: false,
+    pricing: { input: 3.3, output: 16.5, cacheRead: 0.33, cacheWrite: 4.125 }
+  },
+  // Anthropic retired Opus 4.1 on the direct API 2026-08-05; Bedrock still
+  // serves it, so the enclave's persisted id keeps resolving. Priced at the
+  // legacy $15/$75 — the 4.6 reprice never propagated backwards — plus the
+  // US-pinned 10%.
+  {
+    model: "claude-opus-4-1",
+    id: "us.anthropic.claude-opus-4-1-20250805-v1:0",
+    name: "Claude Opus 4.1 (Bedrock \u2014 US)",
+    subprocessor: "bedrock",
+    provider: "bedrock",
+    active: false,
+    pricing: { input: 16.5, output: 82.5, cacheRead: 1.65, cacheWrite: 20.625 }
+  },
+  // No canonical `-vN:M` suffix — that's how AWS lists Moonshot models. Kimi
+  // on Bedrock gets no prompt-cache discount — Bedrock caching is
+  // Anthropic/Nova only — so cacheRead mirrors input, not the input/10 the
+  // Claude rows assume.
+  {
+    model: "kimi-k2.5",
+    id: "moonshotai.kimi-k2.5",
+    name: "Kimi K2.5 (Bedrock)",
+    subprocessor: "bedrock",
+    provider: "bedrock",
+    active: true,
+    pricing: { input: 0.6, output: 3, cacheRead: 0.6, cacheWrite: 0.6 }
+  },
+  {
+    model: "llama4-maverick",
+    id: "us.meta.llama4-maverick-17b-instruct-v1:0",
+    name: "Llama 4 Maverick (Bedrock)",
+    subprocessor: "bedrock",
+    provider: "bedrock",
+    active: true,
+    pricing: { input: 0.24, output: 0.97, cacheRead: 0.024, cacheWrite: 0.24 }
+  },
+  {
+    model: "llama4-scout",
+    id: "us.meta.llama4-scout-17b-instruct-v1:0",
+    name: "Llama 4 Scout (Bedrock)",
+    subprocessor: "bedrock",
+    provider: "bedrock",
+    active: true,
+    pricing: { input: 0.17, output: 0.66, cacheRead: 0.017, cacheWrite: 0.17 }
+  },
+  // Bedrock no longer recognizes this id (ValidationException on invoke); the
+  // row stays to price historical usage and SUNSET_MODEL_REPLACEMENTS rewrites
+  // persisted names onto Pixtral Large, Mistral's successor in the same family.
+  {
+    model: "mistral-large-2",
+    id: "mistral.mistral-large-2407-v1:0",
+    name: "Mistral Large 2 (Bedrock)",
+    subprocessor: "bedrock",
+    provider: "bedrock",
+    active: false,
+    pricing: { input: 3, output: 9, cacheRead: 0.3, cacheWrite: 3 }
+  },
+  {
+    model: "pixtral-large",
+    id: "mistral.pixtral-large-2502-v1:0",
+    name: "Pixtral Large (Bedrock)",
+    subprocessor: "bedrock",
+    provider: "bedrock",
+    active: true,
+    pricing: { input: 2, output: 6, cacheRead: 0.2, cacheWrite: 2 }
+  },
+  /*
+   * Third-party open-weight hosts — Fireworks, Sail (sailresearch.com), and GMI
+   * Cloud (gmicloud.ai) — serving the GLM 5.3 line. One `model` identity, one route
+   * per host: the hosts genuinely price the same weights differently (Sail's Flash
+   * is 30% under the other two), so the route the org enables decides the bill. All
+   * ship OPT-IN (see OPT_IN_SUBPROCESSORS in policy.ts): every organization starts
+   * with them refused and an admin turns one on from the settings page.
+   *
+   * Registered after Bedrock, at the bottom, on purpose: the default-model walk ranks
+   * top down, and an org that manages to enable ONLY these should get them — putting
+   * them ahead of the hosts most clusters default to would let a fail-open bug flip
+   * everyone's architect onto one silently.
+   *
+   * `active: false` for rollout: hidden from pickers while the opt-in/enterprise wiring
+   * settles, still addressable by the Architect staff override (inactive ids resolve
+   * like any other). Freeing them is a one-line release.
+   *
+   * Pricing per each host's published rates. All bill no separate cache-write premium
+   * (cache fill happens in normal input processing), so cacheWrite is 0 rather than
+   * the mirror-input convention the MaaS/Bedrock rows use (that mirrors "no caching
+   * at all"; these hosts have caching, just no write line item). GMI publishes its
+   * rates inline in the /v1/models catalog (probed 2026-09-12) and applies a
+   * discount_to_user on the account — its rates here are the list rows.
+   *
+   * Fireworks is two routes the way Vertex is: `fireworks` global, and the US-only
+   * endpoint (us.api.fireworks.ai) pinned to `fireworks-us` at the documented +50%
+   * premium. Unlike the dual-region Vertex rows these are DIFFERENT ids — the US
+   * endpoint serves `routers/*-us` names — so an org that refuses global fireworks
+   * must name the US id explicitly; there is no same-id region fallback to land in.
+   *
+   * Sail prices the SAME id by completion window (`metadata.completion_window`:
+   * asap/balanced/flex, flex half of asap) — that is a REQUEST parameter, not a host,
+   * so it can't be a route under this registry (pricing keys off id; one id one price,
+   * enforced by the policy spec). Registered at the asap row's rates; wiring windows
+   * for a lazy lane later means per-request billing, not new routes. Sail is
+   * zero-data-retention by default, SOC 2 / HIPAA, and case-sensitive on model ids —
+   * routes register the lowercase form (what modelFromName dispatches) and the sail
+   * transport restores the canonical wire case (see SAIL_WIRE_IDS in llm.ts).
+   *
+   * Sail is ALSO two routes the way Fireworks is: `sail` global, and `sail-us`, which
+   * pins US residency with a per-request `routing.allowed_countries: ["US"]` flag at
+   * the documented +20% premium. One gateway serves both, so the US rows take
+   * sail-us- prefixed ids (same one-id-one-price constraint as the completion windows)
+   * and the transport strips the prefix and injects the flag.
+   *
+   * GMI is case-sensitive the same way (a lowercase id 400s "No matching target
+   * server found"), and its native ids collide with Sail's (`zai-org/GLM-5.3-Flash`
+   * serves on BOTH hosts) — so gmi routes take gmi- prefixed ids and the transport
+   * restores the wire case (GMI_WIRE_IDS in llm.ts). It also silently TRUNCATES an
+   * over-context prompt by default; the transport overrides that to error. GMI has
+   * no US-only endpoint, so no residency row; and it publishes no zero-retention /
+   * no-training commitment for the shared serverless product — production clusters
+   * don't declare it (LLM_SUBPROCESSORS) until that ships in a DPA.
+   *
+   * GLM-5.3 is NOT on Vertex MaaS (probed 2026-09-12: both `zai-org/glm-5.3-maas`
+   * and a flash variant 404 while `zai-org/glm-5-maas` still serves), and MaaS/Bedrock
+   * expose no prompt-cache discount for open weights anyway — the reason these hosts
+   * exist as a fourth home for the weights.
+   */
+  {
+    model: "glm-5.3-flash",
+    id: "accounts/fireworks/models/glm-5p3-flash",
+    name: "GLM 5.3 Flash (Fireworks)",
+    subprocessor: "fireworks",
+    provider: "fireworks",
+    active: false,
+    pricing: { input: 0.15, output: 0.5, cacheRead: 0.03, cacheWrite: 0 }
+  },
+  {
+    model: "glm-5.3-flash",
+    id: "accounts/fireworks/routers/glm-5p3-flash-us",
+    name: "GLM 5.3 Flash (Fireworks US)",
+    subprocessor: "fireworks-us",
+    provider: "fireworks",
+    active: false,
+    pricing: { input: 0.225, output: 0.75, cacheRead: 0.045, cacheWrite: 0 }
+  },
+  {
+    model: "glm-5.3-flash",
+    id: "zai-org/glm-5.3-flash",
+    name: "GLM 5.3 Flash (Sail)",
+    subprocessor: "sail",
+    provider: "sail",
+    active: false,
+    pricing: { input: 0.105, output: 0.35, cacheRead: 0.021, cacheWrite: 0 }
+  },
+  {
+    model: "glm-5.3-flash",
+    id: "sail-us-zai-org/glm-5.3-flash",
+    name: "GLM 5.3 Flash (Sail \u2014 US)",
+    subprocessor: "sail-us",
+    provider: "sail",
+    active: false,
+    pricing: { input: 0.126, output: 0.42, cacheRead: 0.0252, cacheWrite: 0 }
+  },
+  {
+    model: "glm-5.3-flash",
+    id: "gmi-glm53flash",
+    name: "GLM 5.3 Flash (GMI Cloud)",
+    subprocessor: "gmi",
+    provider: "gmi",
+    active: false,
+    pricing: { input: 0.15, output: 0.5, cacheRead: 0.03, cacheWrite: 0 }
+  },
+  {
+    model: "glm-5.3",
+    id: "accounts/fireworks/models/glm-5p3",
+    name: "GLM 5.3 (Fireworks)",
+    subprocessor: "fireworks",
+    provider: "fireworks",
+    active: false,
+    pricing: { input: 1.4, output: 4.4, cacheRead: 0.26, cacheWrite: 0 }
+  },
+  {
+    model: "glm-5.3",
+    id: "accounts/fireworks/routers/glm-5p3-us",
+    name: "GLM 5.3 (Fireworks US)",
+    subprocessor: "fireworks-us",
+    provider: "fireworks",
+    active: false,
+    pricing: { input: 2.1, output: 6.6, cacheRead: 0.39, cacheWrite: 0 }
+  },
+  {
+    model: "glm-5.3",
+    id: "zai-org/glm-5.3",
+    name: "GLM 5.3 (Sail)",
+    subprocessor: "sail",
+    provider: "sail",
+    active: false,
+    pricing: { input: 0.98, output: 3.08, cacheRead: 0.182, cacheWrite: 0 }
+  },
+  {
+    model: "glm-5.3",
+    id: "sail-us-zai-org/glm-5.3",
+    name: "GLM 5.3 (Sail \u2014 US)",
+    subprocessor: "sail-us",
+    provider: "sail",
+    active: false,
+    pricing: { input: 1.176, output: 3.696, cacheRead: 0.2184, cacheWrite: 0 }
+  },
+  {
+    model: "glm-5.3",
+    id: "gmi-glm53-744b",
+    name: "GLM 5.3 (GMI Cloud)",
+    subprocessor: "gmi",
+    provider: "gmi",
+    active: false,
+    pricing: { input: 1.4, output: 4.4, cacheRead: 0.26, cacheWrite: 0 }
+  }
+];
+var LLM_MODELS = MODEL_ROUTES.filter(
+  (route, index) => MODEL_ROUTES.findIndex((r) => r.id === route.id) === index
+).map(({ id, name: name2, provider, active }) => ({ id, name: name2, provider, active }));
+var ACTIVE_MODEL_IDS = LLM_MODELS.filter((m) => m.active).map((m) => m.id).join(", ");
 
 // ../common/src/agent.ts
 var agentVersionConfigSchema = external_exports.object({
@@ -38141,7 +39217,7 @@ var agentVersionConfigSchema = external_exports.object({
 });
 var defaultAgentVersionConfig = {
   systemPrompt: "You are a helpful assistant.",
-  model: "claude-sonnet-4-6",
+  model: DEFAULT_MODEL,
   temperature: 0.7,
   maxTokens: 4096,
   maxSteps: 20,
@@ -43938,11 +45014,6 @@ var reactDefaultTemplate = `function App() {
 var setSearchParamPayloadSchema = external_exports.object({
   params: external_exports.record(external_exports.string(), external_exports.string().nullable())
 });
-var graphqlRequestPayloadSchema = external_exports.object({
-  document: external_exports.string(),
-  variables: external_exports.record(external_exports.string(), external_exports.unknown()).nullish(),
-  requestId: external_exports.string()
-});
 var llmCompletionPayloadSchema = external_exports.object({
   message: external_exports.string(),
   systemPrompt: external_exports.string().optional(),
@@ -44955,6 +46026,7 @@ var NodeEnum = /* @__PURE__ */ ((NodeEnum2) => {
   NodeEnum2["apsApiRequest"] = "APS_API_REQUEST";
   NodeEnum2["armisAction"] = "ARMIS_ACTION";
   NodeEnum2["attributeChanged"] = "ATTRIBUTE_CHANGED";
+  NodeEnum2["awsAthenaRunQuery"] = "AWS_ATHENA_RUN_QUERY";
   NodeEnum2["awsS3GetObject"] = "AWS_S3_GET_OBJECT";
   NodeEnum2["awsS3ListObjects"] = "AWS_S3_LIST_OBJECTS";
   NodeEnum2["awsS3PutObject"] = "AWS_S3_PUT_OBJECT";
@@ -61265,6 +62337,24 @@ var genericResource = (client, id) => {
 };
 
 // ../sdk/src/runners.ts
+var runAction = async (client, input2) => {
+  const organizationId = await client.organizationId();
+  const res = await client.fetch(
+    `/v2/actions/${organizationId}/${input2.workspaceId}/run`,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        actionId: input2.actionId,
+        inputs: input2.inputs,
+        ...input2.actionRunnerId != null ? { actionRunnerId: input2.actionRunnerId } : {}
+      })
+    }
+  );
+  const raw2 = await res.text();
+  if (!res.ok) throw apiError("action run", res, raw2, organizationId);
+  return JSON.parse(raw2);
+};
 var runnerCollection = (client) => ({
   /*
    * Two steps, same as the webapp: createMachineIdentity mints the identity
@@ -61323,7 +62413,6 @@ var runnerCollection = (client) => ({
 });
 var runnerResource = (client, id) => {
   const enqueueAction = async (actionId, inputs) => {
-    const organizationId = await client.organizationId();
     const data = await client.graphql(
       `query SdkResolveRunner($id: String!) {
       actionRunners(condition: { id: $id }, first: 1) { nodes { workspaceId } }
@@ -61336,17 +62425,12 @@ var runnerResource = (client, id) => {
         `Unknown runner ${id} (or it has no workspace). Try: overai runner list`
       );
     }
-    const res = await client.fetch(
-      `/v2/actions/${organizationId}/${workspaceId}/run`,
-      {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ actionId, inputs, actionRunnerId: id })
-      }
-    );
-    const raw2 = await res.text();
-    if (!res.ok) throw apiError("runner run", res, raw2, organizationId);
-    return JSON.parse(raw2);
+    return runAction(client, {
+      workspaceId,
+      actionId,
+      inputs,
+      actionRunnerId: id
+    });
   };
   return {
     token: async (options) => {
@@ -61905,11 +62989,12 @@ var OverAIClient = class {
    * POST /v2/graphql. Throws with the server's error messages — callers (and
    * agents driving them) need the actual reason, not a status code.
    */
-  async graphql(query, variables) {
+  async graphql(query, variables, options) {
     const res = await this.fetch("/v2/graphql", {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ query, variables })
+      body: JSON.stringify({ query, variables }),
+      signal: options?.signal
     });
     const raw2 = await res.text();
     const body = (() => {
@@ -62015,6 +63100,10 @@ var OverAIClient = class {
       ...agentRun(this, id)
     };
   }
+  /** Completion metadata for one run, independent of its potentially offloaded node state. */
+  automationRun(runId, options) {
+    return automationRun(this, runId, options);
+  }
   /** A run addresses no automation, so its state is read by run id alone. */
   automationRunState(runId) {
     return automationRunState(this, runId);
@@ -62040,6 +63129,10 @@ var OverAIClient = class {
   runner(id) {
     return runnerResource(this, id);
   }
+  /** Runs one automation node's action on a runner, outside any automation. */
+  runAction(input2) {
+    return runAction(this, input2);
+  }
   clusterInfo() {
     return clusterInfo(this);
   }
@@ -62423,6 +63516,25 @@ var readStdin = async (claimant = "stdin") => {
   }
   return Buffer.concat(chunks).toString("utf8");
 };
+var readInputs = async (args) => {
+  const inputs = {};
+  if (args.includes("-")) {
+    const raw2 = (await readStdin()).trim();
+    const [parsed] = resultOfSync(() => JSON.parse(raw2));
+    if (parsed == null || typeof parsed !== "object" || Array.isArray(parsed))
+      throw new Error(`stdin must be a JSON object. Got: ${raw2.slice(0, 120)}`);
+    Object.assign(inputs, parsed);
+  }
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--input") {
+      const pair = args[i + 1] ?? "";
+      const eq = pair.indexOf("=");
+      if (eq <= 0) throw new Error(`--input expects k=v. Got: ${pair}`);
+      inputs[pair.slice(0, eq)] = pair.slice(eq + 1);
+    }
+  }
+  return inputs;
+};
 var readValue = async (value, label) => {
   if (value?.startsWith("@") !== true) return value;
   if (value.startsWith("@@")) return value.slice(1);
@@ -62928,9 +64040,39 @@ var whoami = (args = []) => {
   );
 };
 
+// src/commands/action.ts
+var USAGE = "Usage: overai action run <workspaceId> <ACTION_ID> [--runner <runnerId>] [--input k=v ... | -]\n";
+var runAction2 = async (args) => {
+  const [sub, workspaceId, actionId, ...rest] = args;
+  if (sub !== "run" || workspaceId == null || workspaceId.startsWith("-") || actionId == null || actionId.startsWith("-")) {
+    process.stderr.write(USAGE);
+    process.exitCode = 1;
+    return;
+  }
+  const unknown2 = unknownFlags(
+    rest,
+    ["--runner", "--input", "-", "-o", "--output"],
+    ["--runner", "--input", "-o", "--output"]
+  );
+  if (unknown2.length > 0)
+    throw new Error(
+      `Unknown flag ${unknown2.join(", ")}. See: overai action --help`
+    );
+  const actionRunnerId = flagValue(rest, "--runner");
+  printResult(
+    await cliClient().runAction({
+      workspaceId,
+      actionId,
+      inputs: await readInputs(rest),
+      ...actionRunnerId != null ? { actionRunnerId } : {}
+    }),
+    resolveFormat(flagValue(rest, "-o", "--output"))
+  );
+};
+
 // src/commands/agent.ts
 import { createInterface } from "readline";
-var USAGE = [
+var USAGE2 = [
   "Usage:",
   "  overai agent generate <id> --message <text|@file|@->",
   "  overai agent tools <id> [--version <n>] [-o json|table|csv]",
@@ -63032,7 +64174,7 @@ Conversation: ${conversationId}
 };
 var runAgent = async (args) => {
   const [operation, id] = args;
-  if (id == null) throw new Error(USAGE);
+  if (id == null) throw new Error(USAGE2);
   switch (operation) {
     case "generate":
       await generate(args, id);
@@ -63044,11 +64186,12 @@ var runAgent = async (args) => {
       await chat(args, id);
       return;
     default:
-      throw new Error(USAGE);
+      throw new Error(USAGE2);
   }
 };
 
 // src/commands/automation.ts
+import { setTimeout as sleep } from "timers/promises";
 var runRuns = async (automationId, args) => {
   printResult(
     await cliClient().automation(automationId).runs({
@@ -63067,37 +64210,104 @@ var runState = async (runId, args) => {
     resolveFormat(flagValue(args, "-o", "--output"))
   );
 };
-var runTrigger = async (automationId, args) => {
-  const body = {};
-  if (args.includes("-")) {
-    Object.assign(
-      body,
-      JSON.parse(await readStdin())
+var runTrigger = async (automationId, args) => cliClient().automation(automationId).run(await readInputs(args));
+var waitForRun = async (runId, timeoutSeconds, format2) => {
+  process.stderr.write(`Automation run: ${runId}
+`);
+  const controller = new AbortController();
+  const interrupt = () => {
+    controller.abort(
+      new Error(
+        `Stopped waiting for run ${runId}; the automation was not cancelled.`
+      )
     );
-  }
-  for (let i = 0; i < args.length; i++) {
-    if (args[i] === "--input") {
-      const pair = args[i + 1] ?? "";
-      const eq = pair.indexOf("=");
-      if (eq > 0) body[pair.slice(0, eq)] = pair.slice(eq + 1);
+  };
+  process.once("SIGINT", interrupt);
+  const stopped = new Promise((_resolve, reject2) => {
+    controller.signal.addEventListener(
+      "abort",
+      () => {
+        reject2(controller.signal.reason);
+      },
+      { once: true }
+    );
+  });
+  const timeout = setTimeout(() => {
+    controller.abort(
+      new Error(
+        `Timed out waiting for run ${runId} after ${String(timeoutSeconds)}s; the automation was not cancelled.`
+      )
+    );
+  }, timeoutSeconds * 1e3);
+  try {
+    for (; ; ) {
+      const run2 = await Promise.race([
+        cliClient().automationRun(runId, { signal: controller.signal }),
+        stopped
+      ]);
+      controller.signal.throwIfAborted();
+      if (run2.status === "cancelled" || run2.endedAt != null) {
+        printResult(run2, format2);
+        if (run2.status !== "ok") process.exitCode = 1;
+        return;
+      }
+      await sleep(1e3, void 0, { signal: controller.signal });
     }
+  } catch (error62) {
+    controller.signal.throwIfAborted();
+    throw error62;
+  } finally {
+    clearTimeout(timeout);
+    process.removeListener("SIGINT", interrupt);
   }
-  printResult(
-    await cliClient().automation(automationId).run(body),
-    resolveFormat(flagValue(args, "-o", "--output"))
-  );
 };
 var runAutomation = async (args) => {
   const [sub, id, ...rest] = args;
   if (sub === "runs" && id != null) return runRuns(id, rest);
   if (sub === "state" && id != null) return runState(id, rest);
-  if (sub === "run" && id != null) return runTrigger(id, rest);
+  if ((sub === "run" || sub === "wait") && id != null && !id.startsWith("-")) {
+    const unknown2 = unknownFlags(
+      rest,
+      sub === "run" ? ["--input", "-", "--wait", "--timeout", "-o", "--output"] : ["--timeout", "-o", "--output"],
+      ["--input", "--timeout", "-o", "--output"]
+    );
+    if (unknown2.length > 0)
+      throw new Error(
+        `Unknown flag ${unknown2.join(", ")}. See: overai automation --help`
+      );
+    const waiting = sub === "wait" || rest.includes("--wait");
+    if (rest.includes("--timeout") && !waiting)
+      throw new Error("--timeout requires --wait when starting a run.");
+    const timeout = integerFlag(rest, "--timeout", 300);
+    if (rest.includes("--timeout") && flagValue(rest, "--timeout") == null || timeout <= 0 || // Larger delays overflow Node's signed 32-bit millisecond timer and fire immediately.
+    timeout > 2147483) {
+      throw new Error(
+        "--timeout must be a whole number of seconds between 1 and 2147483."
+      );
+    }
+    const format2 = resolveFormat(flagValue(rest, "-o", "--output"));
+    if (sub === "wait") return waitForRun(id, timeout, format2);
+    const result = await runTrigger(id, rest);
+    if (!waiting) {
+      printResult(result, format2);
+      return;
+    }
+    if (result.automationRunId == null)
+      throw new Error(
+        "The server returned no automationRunId; cannot wait. Check automation runs before retrying the trigger."
+      );
+    return waitForRun(result.automationRunId, timeout, format2);
+  }
   process.stderr.write(
-    "Usage: overai automation runs <automationId> [--limit N] [--failed] [--running]\n       overai automation state <runId> [--node <variableId>]\n       overai automation run <automationId> [--input k=v ... | -]\n"
+    "Usage: overai automation runs <automationId> [--limit N] [--failed] [--running]\n       overai automation state <runId> [--node <variableId>]\n       overai automation run <automationId> [--input k=v ... | -] [--wait] [--timeout seconds]\n       overai automation wait <runId> [--timeout seconds]\nWait defaults to 300 seconds. Timeout or Ctrl-C stops waiting, not the automation.\n"
   );
   process.exitCode = 1;
 };
 
+// src/commands/create.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname3, join as join4 } from "path";
+
 // src/workspace/adapters.ts
 var CLONE_DIRS = {
   function: "functions",
@@ -63240,7 +64450,7 @@ var runList = async (args) => {
   });
   printResult(runners, resolveFormat(flagValue(args, "-o", "--output")));
 };
-var USAGE2 = "Usage: overai runner create <workspaceId> [--name <name>]\n       overai runner token <runnerId> [--note <note>]\n       overai runner run <runnerId> [--interpreter shell|powershell] --code '<code>'\n       overai runner upload <runnerId> --path '<path>'\n       overai runner list [workspaceId] [--limit <n>]\n";
+var USAGE3 = "Usage: overai runner create <workspaceId> [--name <name>]\n       overai runner token <runnerId> [--note <note>]\n       overai runner run <runnerId> [--interpreter shell|powershell] --code '<code>'\n       overai runner upload <runnerId> --path '<path>'\n       overai runner list [workspaceId] [--limit <n>]\n";
 var runRunner = async (args) => {
   const [sub, id, ...rest] = args;
   if (sub === "create" && id != null) return runCreate(id, rest);
@@ -63248,7 +64458,7 @@ var runRunner = async (args) => {
   if (sub === "run" && id != null) return runRun(id, rest);
   if (sub === "upload" && id != null) return runUpload(id, rest);
   if (sub === "list") return runList([id, ...rest].filter((a) => a != null));
-  process.stderr.write(USAGE2);
+  process.stderr.write(USAGE3);
   process.exitCode = 1;
 };
 
@@ -63286,27 +64496,6 @@ var adapterType = {
   "printable-page": "printablePage",
   agent: "agent"
 };
-var addToClone = async (root, manifest, type, id) => {
-  const remote = (await adapterFor(type).fetchAll(manifest.workspaceId)).find(
-    (resource) => resource.id === id
-  );
-  if (remote == null) {
-    throw new Error(
-      `Created ${id}, but could not read it back into the clone.`
-    );
-  }
-  Object.entries(remote.files).forEach(([path, content]) => {
-    writeSynced(root, path, content);
-  });
-  manifest.resources[id] = {
-    type,
-    name: remote.name,
-    files: Object.keys(remote.files),
-    baseVersion: remote.latestVersion,
-    deployedVersion: remote.deployedVersion
-  };
-  writeManifest(root, manifest);
-};
 var runCreate2 = async (args) => {
   const rawType = args[0];
   if (!CREATE_TYPES.includes(rawType)) {
@@ -63315,19 +64504,26 @@ var runCreate2 = async (args) => {
     );
   }
   const type = rawType;
+  const format2 = resolveFormat(flagValue(args, "-o", "--output"));
   const explicitWorkspaceId = flagValue(args, "--workspace");
   const clone2 = (() => {
-    if (explicitWorkspaceId != null) return null;
     try {
+      if (explicitWorkspaceId != null) {
+        const root = findWorkspaceRoot();
+        const manifest = readManifest(root);
+        if (manifest.workspaceId.toLowerCase() !== explicitWorkspaceId.toLowerCase() || manifest.organizationId !== scopedOrgId() || manifest.apiBaseUrl != null && manifest.apiBaseUrl !== apiBaseUrl())
+          return null;
+      }
       return openClone();
     } catch (error62) {
+      if (explicitWorkspaceId != null) return null;
       if (error62 instanceof Error && error62.message.startsWith("Not inside a cloned workspace")) {
         return null;
       }
       throw error62;
     }
   })();
-  const workspaceId = explicitWorkspaceId ?? clone2?.manifest.workspaceId;
+  const workspaceId = clone2?.manifest.workspaceId ?? explicitWorkspaceId;
   if (type !== "workspace" && workspaceId == null) {
     throw new Error(
       "Pass --workspace <id>, or run the command inside a cloned workspace."
@@ -63372,18 +64568,64 @@ var runCreate2 = async (args) => {
     }
     return (await createActionRunner(workspaceId, name2)).actionRunnerId;
   })();
+  const localFiles = [];
+  const result = {
+    type,
+    id,
+    name: name2,
+    workspaceId: type === "workspace" ? id : workspaceId
+  };
   const trackedType = adapterType[type];
-  if (clone2 != null && trackedType != null) {
-    await addToClone(clone2.root, clone2.manifest, trackedType, id);
+  try {
+    if (clone2 != null && trackedType != null) {
+      const adapter = adapterFor(trackedType);
+      const head = await adapter.head(id);
+      const files = await adapter.fetchVersion(id, head.latestVersion, name2);
+      Object.keys(files).forEach((path) => {
+        if (existsSync3(join4(clone2.root, path)) || existsSync3(basePath(clone2.root, path))) {
+          throw new Error(`Local file already exists: ${path}`);
+        }
+      });
+      Object.entries(files).forEach(([path, content]) => {
+        const workingPath = join4(clone2.root, path);
+        mkdirSync3(dirname3(workingPath), { recursive: true });
+        writeFileSync3(workingPath, content, { flag: "wx" });
+        localFiles.push(workingPath);
+        const pristinePath = basePath(clone2.root, path);
+        mkdirSync3(dirname3(pristinePath), { recursive: true });
+        writeFileSync3(pristinePath, content, { flag: "wx" });
+      });
+      const manifest = readManifest(clone2.root);
+      manifest.resources[id] = {
+        type: trackedType,
+        name: name2,
+        files: Object.keys(files),
+        baseVersion: head.latestVersion,
+        deployedVersion: head.deployedVersion
+      };
+      writeManifest(clone2.root, manifest);
+    }
+  } catch (error62) {
+    const message = `Created ${id}, but local sync failed. Do not create it again. Preserve any existing local files, then run overai pull in the matching clone to recover (pull also syncs other resources). ${error62 instanceof Error ? error62.message : String(error62)}`;
+    printResult(
+      {
+        ...result,
+        localFilesWritten: localFiles.length > 0,
+        localFiles,
+        localSyncError: message
+      },
+      format2
+    );
+    throw new Error(message, { cause: error62 });
   }
   printResult(
-    { type, id, name: name2, workspaceId: type === "workspace" ? id : workspaceId },
-    resolveFormat(flagValue(args, "-o", "--output"))
+    { ...result, localFilesWritten: localFiles.length > 0, localFiles },
+    format2
   );
 };
 
 // src/commands/dataFile.ts
-import { openAsBlob, writeFileSync as writeFileSync3 } from "fs";
+import { openAsBlob, writeFileSync as writeFileSync4 } from "fs";
 var runDataFile = async (args) => {
   const [operation, id, path] = args;
   if (id == null || !["upload", "download", "head"].includes(operation ?? "")) {
@@ -63404,7 +64646,7 @@ var runDataFile = async (args) => {
   }
   const response = operation === "head" ? await dataFile.head({ lines: integerFlag(args, "--lines", 50) }) : await dataFile.read();
   const bytes = Buffer.from(await response.arrayBuffer());
-  if (path != null && path !== "-") writeFileSync3(path, bytes);
+  if (path != null && path !== "-") writeFileSync4(path, bytes);
   else process.stdout.write(bytes);
 };
 
@@ -63452,18 +64694,18 @@ var runDataStream = async (args) => {
 import { createHash as createHash3 } from "crypto";
 import { watch } from "fs";
 import { createServer as createServer2 } from "http";
-import { dirname as dirname3, join as join5 } from "path";
+import { dirname as dirname4, join as join6 } from "path";
 
 // src/commands/sync.ts
 import {
-  existsSync as existsSync3,
+  existsSync as existsSync4,
   lstatSync,
-  mkdirSync as mkdirSync3,
+  mkdirSync as mkdirSync4,
   readFileSync as readFileSync5,
   unlinkSync,
-  writeFileSync as writeFileSync4
+  writeFileSync as writeFileSync5
 } from "fs";
-import { join as join4, resolve as resolve3 } from "path";
+import { join as join5, resolve as resolve3 } from "path";
 
 // src/gql.ts
 var gqlRequest = async (query, variables) => {
@@ -63532,39 +64774,39 @@ var runClone = async (args, isShallow = false) => {
   await getAccessToken();
   const workspace = await fetchWorkspace(workspaceId);
   const root = resolve3(dirArg ?? slugify3(workspace.name));
-  const cloneMarker = join4(root, ".overai", "clone-in-progress");
-  if (existsSync3(join4(root, ".overai", "manifest.json"))) {
+  const cloneMarker = join5(root, ".overai", "clone-in-progress");
+  if (existsSync4(join5(root, ".overai", "manifest.json"))) {
     throw new Error(
       `${root} is already a cloned workspace. Use \`overai pull\` to refresh.`
     );
   }
-  const partialCloneWorkspaceId = existsSync3(cloneMarker) ? readFileSync5(cloneMarker, "utf8").trim() : null;
+  const partialCloneWorkspaceId = existsSync4(cloneMarker) ? readFileSync5(cloneMarker, "utf8").trim() : null;
   if (partialCloneWorkspaceId != null && partialCloneWorkspaceId !== workspaceId) {
     throw new Error(
       `${root} contains an incomplete clone of ${partialCloneWorkspaceId}. Retry that workspace or choose another directory.`
     );
   }
-  if (existsSync3(join4(root, "WORKSPACE.md")) && partialCloneWorkspaceId == null) {
+  if (existsSync4(join5(root, "WORKSPACE.md")) && partialCloneWorkspaceId == null) {
     throw new Error(`${root} already contains WORKSPACE.md.`);
   }
   const pending = [{ workspace, root }];
   const seen = /* @__PURE__ */ new Set([workspace.id]);
   const plan = [];
   for (const entry of pending) {
-    const marker = join4(entry.root, ".overai", "clone-in-progress");
-    const completed = existsSync3(join4(entry.root, ".overai", "manifest.json"));
-    if (entry.root !== root && existsSync3(entry.root)) {
+    const marker = join5(entry.root, ".overai", "clone-in-progress");
+    const completed = existsSync4(join5(entry.root, ".overai", "manifest.json"));
+    if (entry.root !== root && existsSync4(entry.root)) {
       if (lstatSync(entry.root).isSymbolicLink())
         throw new Error(`Refusing to clone into symbolic link ${entry.root}.`);
-      const savedId = completed ? readManifest(entry.root).workspaceId : existsSync3(marker) ? readFileSync5(marker, "utf8").trim() : null;
+      const savedId = completed ? readManifest(entry.root).workspaceId : existsSync4(marker) ? readFileSync5(marker, "utf8").trim() : null;
       if (partialCloneWorkspaceId !== workspaceId || savedId !== entry.workspace.id)
         throw new Error(
           `${entry.root} already exists. Choose another clone directory.`
         );
     }
-    if (existsSync3(join4(entry.root, "workspaces")) && lstatSync(join4(entry.root, "workspaces")).isSymbolicLink())
+    if (existsSync4(join5(entry.root, "workspaces")) && lstatSync(join5(entry.root, "workspaces")).isSymbolicLink())
       throw new Error(
-        `Refusing to clone through symbolic link ${join4(entry.root, "workspaces")}.`
+        `Refusing to clone through symbolic link ${join5(entry.root, "workspaces")}.`
       );
     if (!completed) {
       const resourcesByAdapter = await Promise.all(
@@ -63593,7 +64835,7 @@ var runClone = async (args, isShallow = false) => {
       seen.add(child.id);
       pending.push({
         workspace: child,
-        root: join4(
+        root: join5(
           entry.root,
           "workspaces",
           `${slugify3(child.name)}.${child.id}`
@@ -63602,14 +64844,14 @@ var runClone = async (args, isShallow = false) => {
     }
   }
   for (const entry of plan) {
-    mkdirSync3(join4(entry.root, ".overai"), { recursive: true });
-    writeFileSync4(
-      join4(entry.root, ".overai", "clone-in-progress"),
+    mkdirSync4(join5(entry.root, ".overai"), { recursive: true });
+    writeFileSync5(
+      join5(entry.root, ".overai", "clone-in-progress"),
       `${entry.manifest.workspaceId}
 `
     );
-    writeFileSync4(
-      join4(entry.root, "WORKSPACE.md"),
+    writeFileSync5(
+      join5(entry.root, "WORKSPACE.md"),
       entry.description.length === 0 ? "" : `${entry.description.trimEnd()}
 `
     );
@@ -63631,7 +64873,7 @@ var runClone = async (args, isShallow = false) => {
   }
   for (const entry of plan.toReversed()) {
     writeManifest(entry.root, entry.manifest);
-    unlinkSync(join4(entry.root, ".overai", "clone-in-progress"));
+    unlinkSync(join5(entry.root, ".overai", "clone-in-progress"));
   }
   process.stdout.write(
     `
@@ -63752,7 +64994,7 @@ var runPull = async (clone2) => {
         continue;
       }
       if (clone2 != null && Object.keys(remote.files).some(
-        (path) => !resource.files.includes(path) && existsSync3(join4(root, path))
+        (path) => !resource.files.includes(path) && existsSync4(join5(root, path))
       )) {
         incomplete = true;
         process.stdout.write(
@@ -63773,7 +65015,7 @@ var runPull = async (clone2) => {
     }
     for (const remote of remotes) {
       if (manifest.resources[remote.id] != null) continue;
-      if (clone2 != null && Object.keys(remote.files).some((path) => existsSync3(join4(root, path)))) {
+      if (clone2 != null && Object.keys(remote.files).some((path) => existsSync4(join5(root, path)))) {
         incomplete = true;
         process.stdout.write(
           `CONFLICT ${remote.name}: destination files already exist. Kept local.
@@ -64030,7 +65272,7 @@ var runDev = async (args) => {
     }, 100);
   };
   const watchedDirs = [
-    ...new Set(resource.files.map((f) => join5(root, dirname3(f))))
+    ...new Set(resource.files.map((f) => join6(root, dirname4(f))))
   ];
   watchedDirs.forEach((dir) => watch(dir, notifyChange));
   const server = createServer2((req, res) => {
@@ -64228,13 +65470,13 @@ var runGraphql = async (args) => {
 };
 
 // src/commands/integration.ts
-var USAGE3 = "Usage: overai integration configure <id> --config <json|@file|@-> | integration config <id> | integration secret set <id> <KEY> --value <@file|@-> | integration secret unset <id> <KEY>";
+var USAGE4 = "Usage: overai integration configure <id> --config <json|@file|@-> | integration config <id> | integration secret set <id> <KEY> --value <@file|@-> | integration secret unset <id> <KEY>";
 var runIntegration = async (args) => {
   const [operation] = args;
   if (operation === "secret") {
     const [, action, id2, key] = args;
     if (action !== "set" && action !== "unset" || id2 == null || key == null || key.startsWith("-")) {
-      throw new Error(USAGE3);
+      throw new Error(USAGE4);
     }
     const integration2 = cliClient().integration(id2);
     if (action === "set") {
@@ -64263,7 +65505,7 @@ var runIntegration = async (args) => {
   }
   const [, id] = args;
   if (id == null || operation !== "configure" && operation !== "config") {
-    throw new Error(USAGE3);
+    throw new Error(USAGE4);
   }
   const integration = cliClient().integration(id);
   if (operation === "configure") {
@@ -64625,12 +65867,12 @@ var runPrintablePage = async (args) => {
 };
 
 // src/commands/recursiveSync.ts
-import { existsSync as existsSync4, lstatSync as lstatSync2, readdirSync } from "fs";
-import { join as join7, relative } from "path";
+import { existsSync as existsSync5, lstatSync as lstatSync2, readdirSync } from "fs";
+import { join as join8, relative } from "path";
 
 // src/commands/versions.ts
 import { spawnSync } from "child_process";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 var parseRef = (raw2) => {
   if (raw2 === "local" || raw2 === "base") return raw2;
   const [ref] = resultOfSync(() => parseVersionRef(raw2));
@@ -64772,7 +66014,7 @@ var runDiff = async (args, clone2) => {
             "--no-index",
             "--src-prefix=base/",
             "--dst-prefix=local/",
-            join6(".overai", "base", relPath),
+            join7(".overai", "base", relPath),
             missing ? "/dev/null" : relPath
           ],
           { stdio: "inherit", cwd: root }
@@ -64804,15 +66046,15 @@ var runRecursiveSync = async (command2, args) => {
   const local = /* @__PURE__ */ new Map([[origin.manifest.workspaceId, origin]]);
   const folders = [origin];
   for (const folder of folders) {
-    const container = join7(folder.root, "workspaces");
-    if (!existsSync4(container)) continue;
+    const container = join8(folder.root, "workspaces");
+    if (!existsSync5(container)) continue;
     if (lstatSync2(container).isSymbolicLink()) throw new Error(`Refusing symbolic link ${container}.`);
     for (const name2 of readdirSync(container)) {
-      const root = join7(container, name2);
+      const root = join8(container, name2);
       const stat2 = lstatSync2(root);
       if (stat2.isSymbolicLink()) throw new Error(`Refusing symbolic link ${root}.`);
-      if (!stat2.isDirectory() || !existsSync4(join7(root, ".overai/manifest.json"))) continue;
-      if (lstatSync2(join7(root, ".overai")).isSymbolicLink() || lstatSync2(join7(root, ".overai/manifest.json")).isSymbolicLink())
+      if (!stat2.isDirectory() || !existsSync5(join8(root, ".overai/manifest.json"))) continue;
+      if (lstatSync2(join8(root, ".overai")).isSymbolicLink() || lstatSync2(join8(root, ".overai/manifest.json")).isSymbolicLink())
         throw new Error(`Refusing linked clone state in ${root}.`);
       const manifest = readManifest(root);
       if (manifest.organizationId !== origin.manifest.organizationId || local.has(manifest.workspaceId))
@@ -64835,7 +66077,7 @@ var runRecursiveSync = async (command2, args) => {
       if (seen.has(child.id) || child.organizationId !== origin.manifest.organizationId)
         throw new Error(`Invalid workspace hierarchy at ${child.id}. No workspaces synced.`);
       seen.add(child.id);
-      remote.push({ workspace: child, parentId: entry.workspace.id, root: local.get(child.id)?.root ?? join7(entry.root, "workspaces", `${slugify3(child.name)}.${child.id}`) });
+      remote.push({ workspace: child, parentId: entry.workspace.id, root: local.get(child.id)?.root ?? join8(entry.root, "workspaces", `${slugify3(child.name)}.${child.id}`) });
     }
   }
   const failures = [];
@@ -64862,7 +66104,7 @@ Workspace ${label} (${entry.workspace.id})
       if (clone2 == null) {
         if (entry.parentId != null && !available.has(entry.parentId))
           throw new Error("Parent workspace could not be cloned; skipping this child.");
-        if (existsSync4(entry.root))
+        if (existsSync5(entry.root))
           throw new Error("Destination already exists, possibly from an incomplete clone. Local files kept; move the folder aside before retrying.");
         await runClone([entry.workspace.id, entry.root], true);
         available.add(entry.workspace.id);
@@ -65043,12 +66285,12 @@ var runRemote = async (args) => {
 
 // src/commands/update.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync5, readFileSync as readFileSync7 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync7 } from "fs";
 import { fileURLToPath } from "url";
 var PACKAGE_NAME = "@overaihq/cli";
 var packageRootUrl = () => {
   for (const up of ["..", "../..", "../../.."]) {
-    if (existsSync5(new URL(`${up}/package.json`, import.meta.url))) {
+    if (existsSync6(new URL(`${up}/package.json`, import.meta.url))) {
       return new URL(`${up}/`, import.meta.url);
     }
   }
@@ -65074,7 +66316,7 @@ var detectInstaller = () => {
 };
 var runUpdate = async () => {
   const current = cliVersion();
-  if (existsSync5(new URL("src", packageRootUrl()))) {
+  if (existsSync6(new URL("src", packageRootUrl()))) {
     process.stdout.write(
       "Development build \u2014 rebuild from the repo instead of updating from npm.\n"
     );
@@ -65101,7 +66343,7 @@ var runUpdate = async () => {
   const cmp = compareVersions(current, latest);
   if (cmp > 0) {
     process.stdout.write(
-      `overai ${current} is ahead of latest (${latest}) \u2014 likely a @next install; nothing to do.
+      `overai ${current} is ahead of latest (${latest}) \u2014 likely an unreleased build; nothing to do.
 `
     );
     return;
@@ -65743,6 +66985,16 @@ automatic conflict recovery \u2014 incorporate the remote changes and retry.
 
 ## Organization context
 
+\`overai create <type>\` writes the new resource's files when run inside its
+matching workspace clone, including with an explicit \`--workspace\`. It fetches
+only that resource and leaves other local edits untouched. Outside a matching
+clone it creates remotely without creating local files or a clone. The result's
+\`localFilesWritten\` and \`localFiles\` fields report writes and absolute paths.
+If local sync fails after creation, the result includes the created id and
+\`localSyncError\`. Preserve any existing destination files before running
+\`overai pull\` in the matching clone; pull also syncs other resources. Do not
+create the resource again.
+
 Commands in a clone select its org automatically. Outside a clone, put
 --org <ref> before the command (overai --org acme sql ...), or set
 OVERAI_ORG_ID for a whole shell. A ref is an org id, a local alias, or
@@ -65797,6 +67049,14 @@ around a clone-sync mismatch; use the correct workspace folder.
 - \`overai automation run <id> --input k=v\` starts a real run of the DEPLOYED
   version (fire-and-forget, returns automationRunId). Run read-only paths
   first; verify before deploying mutating changes.
+- Add \`--wait --timeout 300\` to start and wait, or use
+  \`overai automation wait <runId> --timeout 300\` for an existing run.
+  Waiting defaults to 300 seconds and returns completion metadata, not node
+  outputs. The run ID prints to stderr immediately; the final summary prints
+  to stdout. Failure, cancellation, and timeout exit nonzero. Timeout or Ctrl-C
+  stops waiting without cancelling the automation. An in-progress credential
+  refresh may finish before the CLI exits. Use \`state\` separately
+  for best-effort node outputs.
 - Console logs from a page are visible in the webapp editor.
 
 ## SQL access
@@ -65814,6 +67074,10 @@ around a clone-sync mismatch; use the correct workspace folder.
   supplied and permitted by organization policy.
 - Give each service its own credential. List, rotate, or revoke it with
   \`overai sql credential list|rotate|revoke\`.
+- A database outside OverAI (e.g. a customer's SQL Server behind their
+  self-hosted runner) is reached through its node's action, not \`sql\`:
+  \`overai action run <workspaceId> MS_SQL_DATABASE_TRANSACTION_REMOTE --runner <runnerId> -\`
+  with the node's inputs as a JSON object on stdin.
 
 ## From a script
 
@@ -66068,7 +67332,8 @@ A node is "runnable" (can be executed) when ALL of these conditions are met:
 1. **Debug mode is enabled** - Users must enable debug mode to run nodes step-by-step
 2. **Parent resolution** - One of the following must be true:
    - The node has NO parents (unconnected nodes can always run in debug mode)
-   - ALL parent nodes have executed and resolved to the correct handle that connects to this node
+   - ALL parent nodes have executed and resolved to the handle that connects to this node
+   - For an **ALWAYS** node: ALL parent nodes have finished, whatever the outcome (success, failure, errored, or skipped), and at least one of them was not skipped
 3. **Loop context** (if applicable) - If the node is inside a loop:
    - The loop node must be in "loop" state (actively iterating)
    - The loop completes when it reaches maxIterations or exhausts items
@@ -66081,6 +67346,15 @@ Nodes connect via "handles" which determine execution flow:
 
 When a parent executes, it resolves to one of these handles. Child nodes only become runnable when their parent resolves to the handle they're connected to.
 
+### Skipped Nodes
+In a deployed run, every node ends in one of: success, failure, errored, or skipped. Skipped is derived from the parents' outcomes wherever state is shown, never recorded, so it appears in run history and while stepping in debug mode: once you run one lane of an IF, the other lane reads as skipped and an ALWAYS after the IF becomes runnable.
+- A node is **skipped** as soon as a parent makes it unreachable: the parent finished as skipped, or finished on a different handle than the one connecting to this node. An **errored** parent skips all its children except an ALWAYS, because no handle is named errored.
+- Skips propagate: a skipped node's children are skipped in turn, down to the end of the lane.
+- **ALWAYS is the join.** It runs once every parent has finished \u2014 succeeded, failed, errored, or skipped \u2014 and at least one of them ran, so an ALWAYS fed by both lanes of an IF runs after the taken lane finishes.
+- An ALWAYS whose every parent was skipped sits inside an untaken lane: it is skipped too, and the skip keeps propagating through it.
+- A parent connected through a loop's **loop** handle never causes a skip, and an ALWAYS entered from the loop counts that as a parent that ran. Inside a loop, each iteration applies these rules on its own.
+- Skipped nodes do not make a run errored. A run with skipped nodes and no errored nodes succeeds.
+
 ### Special Node Types
 - **Event nodes** (timer, webhook, emailReceived, fileUpload): Can always run if debug mode is on. These require a payload to simulate the trigger \u2014 see "Simulating Event Nodes" below.
 - **Loop nodes** (loopArray, loopRange): Execute iteratively, maintaining "loop" state until complete, then always resolve to the **success** handle \u2014 even if some or all iterations errored. A failed iteration does not stop the loop or take a failure path. To react to per-iteration failures, handle errors on the nodes inside the loop, or inspect \`iterations\`. (If any node errored, the run is still marked errored overall, but the loop's success handle still runs.)
@@ -66125,9 +67399,13 @@ var automationsDoc = {
   id: "automations",
   summary: "Automations overview: node model, IF vs legacy IF_ELSE, debugging, webhook/email/run endpoints, SEND_EMAIL, code nodes, Excel input, elements graph rules.",
   body: `
+## Error alerts
+
+When configuring alerts through GraphQL, \`emailRecipients\` is an object: \`{"recipients": ["alerts@example.com"]}\`, not a bare list. Omit \`recipients\` or use an empty array to send no email. Entries must be strings; additional object fields are preserved.
+
 ## Working with Automations
 
-Automations are step-by-step workflows. Automations are initiated by a trigger (timer, email, webhook, file upload) and then proceed to run additional steps or nodes such as \`TYPESCRIPT_CODE\`, \`IF\`, \`SEND_EMAIL\`, \`PARSE_EXCEL\`, \`GENERATE_OBJECT\`, \`GENERATE_TEXT\`. An automation node will run once all of its parent nodes have resolved. Control flow is done through \`LOOP_ARRAY\` and \`LOOP_RANGE\` nodes along with \`IF\`, \`ERROR\`, and \`ALWAYS\`. The \`ALWAYS\` node helps to bring different branches of an \`IF\` node back together. To branch on a condition use the \`IF\` node \u2014 its only input is \`expression\`, a Liquid predicate that renders \`true\` or \`false\` (e.g. \`{{ S1.result.count > 0 }}\`). The \`IF_ELSE\` node is legacy and deprecated: never add it, and replace any existing \`IF_ELSE\` node with an \`IF\` node.
+Automations are step-by-step workflows. Automations are initiated by a trigger (timer, email, webhook, file upload) and then proceed to run additional steps or nodes such as \`TYPESCRIPT_CODE\`, \`IF\`, \`SEND_EMAIL\`, \`PARSE_EXCEL\`, \`GENERATE_OBJECT\`, \`GENERATE_TEXT\`. An automation node will run once all of its parent nodes have resolved. Control flow is done through \`LOOP_ARRAY\` and \`LOOP_RANGE\` nodes along with \`IF\`, \`ERROR\`, and \`ALWAYS\`. The \`ALWAYS\` node helps to bring different branches of an \`IF\` node back together. The untaken branch of an \`IF\` reads as skipped, and \`ALWAYS\` runs once every parent has finished or been skipped and at least one of them ran; an \`ALWAYS\` whose every parent was skipped is skipped too. To branch on a condition use the \`IF\` node \u2014 its only input is \`expression\`, a Liquid predicate that renders \`true\` or \`false\` (e.g. \`{{ S1.result.count > 0 }}\`). The \`IF_ELSE\` node is legacy and deprecated: never add it, and replace any existing \`IF_ELSE\` node with an \`IF\` node.
 
 Besides full runs, an automation can be worked on piece by piece:
 - simulate the trigger event in debug mode (same trigger-specific inputs as a full run \u2014 e.g. \`fileUrl\`, \`method\`/\`body\` \u2014 but it only seeds the EVENT node, without starting a run),
@@ -66147,6 +67425,14 @@ Important nodes:
 - \`SEND_EMAIL\` sends an email from \`noreply@overai.com\` without needing a 3rd party integration. Inside an automation always use this node rather than sending from a \`TYPESCRIPT_CODE\` node \u2014 it is visible on the canvas, configurable without reading code, and re-runnable on its own in debug. Outside an automation (a Function), send with \`env.EMAIL.send(...)\`.
 - \`TYPESCRIPT_CODE\` runs a TypeScript module in a Deno sandbox. Use \`export default async function step(state: StepState, ctx: StepContext, env: Env) { \u2026 }\`; the return value is the node output. Annotate every parameter you declare \u2014 module code is checked with noImplicitAny, so an unannotated one is an error. Read upstream outputs with \`await state.get("S1")\` (fetched on first read, cached for that node's execution; \`undefined\` for a skipped step; rejects for an id not visible from the node) \u2014 \`state.S1\` does not exist. Keep each code node small and focused \u2014 when the logic grows, break it across multiple nodes and let the automation handle orchestration rather than writing one large block.
 
+## Querying Amazon Athena
+
+Use \`AWS_ATHENA_RUN_QUERY\` with an existing AWS integration (credentials and region). Set database/workgroup on the action; catalog defaults to \`AwsDataCatalog\` and workgroup to \`primary\`. Leave the S3 results location empty to use workgroup storage, including managed results. Enforced workgroup settings take precedence. Grant Athena query/status/results/cancel permissions plus catalog, source and results access (and KMS/Lake Formation where applicable).
+
+The action accepts one SQL statement, including writes allowed by AWS permissions. Liquid interpolation is not parameter binding; never interpolate untrusted text into SQL. Results are \`rowData\` arrays aligned with \`columns\`; cells remain strings or null. CSV mode streams to OverAI storage and returns \`fileUrl\`, with \`rowData: null\`; it includes headers and writes null as an empty field. Both modes return column metadata, \`queryId\`, \`bytesScanned\` and \`truncated\`.
+
+Row limit defaults to 0 (unlimited) and applies only to returned rows, not scanned data. Check \`truncated\` before treating output as complete. Inline output is capped at 150 MiB of serialized rows; use CSV for larger results. Set SQL filters/partitions and workgroup scan limits to control costs. The default 60-second timeout covers submission/execution, not download. Cancellation is attempted on timeout or runner abort, but is not guaranteed and does not roll back writes. Re-running a write can repeat it. Customer-hosted runners need a version that includes this action.
+
 ## Excel inside automations
 
 When an automation needs to read an uploaded \`.xlsx\`/\`.xls\` workbook at runtime (e.g. a \`fileUpload\` event), prefer the \`parseExcel\` node over writing TypeScript. It pulls every sheet in one shot and avoids re-deriving brittle parsing code each run.
@@ -66495,13 +67781,13 @@ Generate text or structured objects using LLMs:
 // Generate text. Functions always use non-streaming under the hood, so
 // invalid-PDF / prompt-too-long / rate-limit errors throw with a classified
 // message instead of returning an empty string.
-const text = await env.AI.generateText("Summarize this document", { system: "You are a helpful assistant", model: "claude-sonnet-4-5" });
+const text = await env.AI.generateText("Summarize this document", { system: "You are a helpful assistant", model: "claude-sonnet-5-5" });
 
 // Generate structured object
 const result = await env.AI.generateObject(
   "Extract the key information",
   { type: "object", properties: { title: { type: "string" }, summary: { type: "string" } } },
-  { model: "claude-sonnet-4-5" }
+  { model: "claude-sonnet-5-5" }
 );
 
 // With file attachments \u2014 pass Blobs of images or PDFs alongside the prompt
@@ -66522,7 +67808,9 @@ const transcript = await env.AI.speechToText(fileUrl, { language: "en" });
 
 **Attachment types:** \`image/png\`, \`image/jpeg\`, \`image/gif\`, \`image/webp\`, \`application/pdf\`. The Blob's \`type\` is forwarded as the mediaType \u2014 make sure it's set (e.g. when constructing via \`new Blob([buf], { type: "image/png" })\`).
 
-**generateObject schema limit:** Anthropic models reject schemas with more than 16 nullable or union-typed fields. Prefer non-nullable fields, split into multiple calls, or switch model to \`gpt-5.6-terra\` or \`gemini-3.1-pro-preview\` for larger schemas. Same applies to the agent \`generateObject\` below.
+**Output budgets:** Pass \`maxOutputTokens\` in the options for \`env.AI.generateText\` or \`env.AI.generateObject\` to set a positive integer output limit. Omitted means 16,000 tokens per model call, including each web-search step; this is not a total workflow budget. Provider/model limits still apply, and reasoning tokens can consume the budget. Larger budgets allow longer answers and greater spend. Truncated structured output fails with an error: increase the budget within the model's limit or request a smaller result.
+
+**generateObject schema limit:** Anthropic models reject schemas with more than 16 nullable or union-typed fields. Prefer non-nullable fields, split into multiple calls, or switch model to ${LARGE_SCHEMA_MODELS.map((model) => `\`${model}\``).join(" or ")} for larger schemas. Same applies to the agent \`generateObject\` below.
 
 ## Agent Access
 
@@ -66686,6 +67974,8 @@ Each version has a timeout (ms, default 30000) and memory limit (MB, default 512
 
 ## Error alerts
 
+When configuring alerts through GraphQL, \`emailRecipients\` is an object: \`{"recipients": ["alerts@example.com"]}\`, not a bare list. Omit \`recipients\` or use an empty array to send no email. Entries must be strings; additional object fields are preserved. Functions allow at most 20 recipients.
+
 A function can email recipients when it breaks: the handler throws, times out, or crashes (non-zero exit, output over the size limit, malformed response). A status the handler returns, even a 4xx or 5xx, never alerts \u2014 so catching an error and returning \`new Response(..., { status: 500 })\` silences it. After one alert, later failures send nothing until the cooldown ends (60 minutes by default; 0 sends on every failure). Runs from the function editor never alert, including your \`runFunction\` calls; calls from automations, pages, agents, and HTTP do. The user turns alerts on and picks recipients from the "Alerts" chip in the function's status bar.
 `
 };
@@ -66907,7 +68197,7 @@ var platformApiDoc = {
 
 OverAI's own data model \u2014 organizations, workspaces, identities, workspace membership and roles (\`workspaceIdentityRole\`), automations, functions, pages, integrations, runs, and more \u2014 is queryable over a **v2 GraphQL API** at \`<api_base_url>/v2/graphql\`. Reach for it whenever a build needs to read or manage the platform itself (e.g. "export every user and their workspace permissions", "list automations that failed today"), not just the user's own tables. It is available anywhere the env SDK runs \u2014 code nodes, functions, and pages.
 
-- **From env SDK**: \`env.GRAPHQL.request(query, vars)\`. It authenticates as the **current workspace** and is row-level-security scoped \u2014 it sees only that workspace's data, and an out-of-scope read returns fewer rows with **no error**. Good for reading the workspace you're in; not for org-wide data.
+- **From env SDK**: \`env.GRAPHQL.request(query, vars)\`. It authenticates with the running code's own token \u2014 the workspace in code nodes and functions, the page's selected authorization mode (workspace or viewer) in pages \u2014 and is row-level-security scoped: an out-of-scope read returns fewer rows with **no error**. Good for reading the workspace you're in; not for org-wide data.
 - **For org-wide / cross-workspace reads**, \`env.GRAPHQL\` is not enough. \`fetch()\` \`<api_base_url>/v2/graphql\` directly with an **org-scoped access token** as \`Authorization: Bearer <token>\`. Keep the token out of code: store it in an HTTP integration and read it with \`env.IN<id>.get()\`. Sandboxed \`fetch()\` sends your headers **verbatim** \u2014 nothing rewrites auth headers, and no action runner is involved (runners are only for endpoints the cloud can't reach, e.g. on-prem).
 - It is **v2 PostGraphile**, not the legacy Hasura API: **cursor** pagination (\`first\`/\`after\` + \`pageInfo { hasNextPage endCursor }\`) and connection shapes (\`{ nodes { ... } }\`), never \`limit\`/\`offset\`.
 - The schema is large, so **do not guess field names \u2014 introspect on demand** (introspection is enabled). List top-level queries with \`{ __schema { queryType { fields { name } } } }\`; inspect one type with \`{ __type(name: "Workspace") { fields { name type { name kind ofType { name kind } } } } }\`. Introspect the exact type before writing the query.
@@ -67351,7 +68641,7 @@ declare global {
   /** Filenames over 128 characters are shortened in the middle, preserving both ends. */
   const uploadFile: (file: File, filename: string, disableRandomPrefix?: boolean) => Promise<string>;
   const presignFile: (fileUrl: string, expiresIn?: number) => Promise<string>;
-  const graphqlRequest: (document: string, variables?: Record<string, unknown>) => Promise<Record<string, unknown>>;
+  const graphqlRequest: (document: string, variables?: Record<string, unknown>) => Promise<unknown>; // POSTs to the v2 API (/v2/graphql) with the page's own token, so it sees what the page's authorization mode grants; Hasura-dialect documents are not accepted. Resolves to { data, errors }.
   /** @deprecated Use useLLMText, useLLMObject, or useLLMChat instead. */
   const llmCompletion: (message: string, systemPrompt?: string, model?: string) => Promise<Record<string, unknown>>;
   const callFunction: (functionId: string, options?: { body?: unknown; method?: string; query?: Record<string, string>; path?: string }) => Promise<Response>;
@@ -67451,6 +68741,8 @@ If the warning gives a listed function's spelling, use that spelling instead of
 
 The \`env\` proxy matches the API available in Functions and Automations \u2014 the same code works in all three.
 
+Generic AI calls and hooks (generateText, generateObject, useLLMText, useLLMObject, useLLMChat, and env.AI) accept \`maxOutputTokens\`: a positive integer, default 16,000. It limits each model call, including each web-search step, not the whole conversation. Provider/model limits still apply; reasoning can consume the budget. Larger budgets allow longer answers and greater spend. Truncated structured output fails: increase the budget within the model's limit or request a smaller result. Text/chat keep their existing partial-output behavior.
+
 For AI in React components, prefer the reactive hooks (useLLMText, useLLMObject, useLLMChat, useAgentChat) \u2014 they re-render as the response streams in. In event handlers or imperative code, call generateText/generateObject (or env.AI.*) directly.
 useAgentChat persists every turn server-side for a signed-in viewer: pass a conversationId to resume a past thread (full transcript, tool calls included, loads automatically), or omit it to start fresh and read the new thread's id off the returned conversationId. useAgentConversations(agentId) backs a history sidebar \u2014 call its refresh() after a first send so the newly created thread appears. listAgentConversations, getAgentConversationMessages, createAgentConversation, renameAgentConversation, and deleteAgentConversation are the imperative equivalents. On a public page none of that persistence exists (see Public pages) \u2014 useAgentChat still streams, holding the transcript in memory.
 All AI functions/hooks accept optional File[] attachments for images/PDFs, and webSearch: true to enable web search.
@@ -67769,8 +69061,18 @@ Archived workspaces are hidden from the workspace tree but are not deleted. Arch
 
 Individual resources (pages, automations, functions, tablespaces, integrations, \u2026) can likewise be archived \u2014 there is no hard delete. An archived resource disappears from the side navigation, from all listings and search, but its data is intact \u2014 except an integration's credentials, which archiving deletes, so a restored integration must be reconnected before anything can use it. When the user says a resource is missing or asks where it went, check archived resources before concluding it doesn't exist, and offer to unarchive it. In the UI, archived resources are listed on the Workspace Overview page under the **\u22EF menu \u2192 Show archived resources**, where each row's menu offers **Unarchive**.
 
+Workspace managers can rename a workspace by right-clicking its name in the side nav and choosing **Rename**, or by clicking the name at the top of the workspace page.
+
 Workspace managers can duplicate an active workspace subtree by right-clicking its name in the side nav. The copy uses deployed resource versions, disables automations, and never copies run history or OAuth tokens. Direct grants, non-OAuth integration credentials, and TableSpace rows default on; managers can omit either set of credentials or choose schema-only TableSpaces. Editors and managers can also right-click one TableSpace to duplicate its schemas and optionally its rows. The modal shows progress for each copy phase and reports only items that unexpectedly failed.
 
+On the People page, open a person and click ? beside a workspace to see the direct grant\u2019s creator and creation date, or its parent workspace for inherited access. This is original grant attribution, not necessarily the inviter or the actor behind later role changes. If the record names its recipient as creator, the popover shows only the date; use access history for the recorded source and actor.
+
+## Access and workspace history
+
+Organization admins can open a person on the People page and choose **View access history** for their organization and workspace access changes. The People page\u2019s **\u22EF** menu \u2192 **Organization history** shows history across the organization. Workspace managers and organization admins can open the workspace\u2019s **\u22EF** menu \u2192 **Audit history** for its member access, resource, sharing, and parent-workspace changes. **Filters** narrow the history by **Change type**, **Action**, a **From**/**Through** date range, **Person ID**, or **Resource ID**. Related changes share an operation and are grouped together, without exposing other workspaces the viewer cannot manage.
+
+Entries preserve the actor, source, timestamp, and before/after values. A baseline records existing state when logging begins; it is not proof of earlier roles or an original organization inviter. Unknown attribution stays unknown. History is retained until the organization is deleted. The audit history records access-relevant events only: creation, deletion, workspace moves, sharing, parent links, and access-setting changes. Resource saves and deployments stay in version history.
+
 ## Public Workspaces
 
 A workspace can be marked **public** (Managers only, by clicking the visibility chip next to the workspace name on the Workspace Overview page). When public, every web page in it is reachable at \`/public/<webPageId>\` without a sign-in \u2014 the visitor's iframe runs against an ephemeral workspace token that can read and write every table space the workspace reaches and call its functions, automations and agents. The visitor is not a member; they just see the page.
@@ -68305,11 +69607,11 @@ var runSql = async (args) => {
 };
 
 // src/commands/storage.ts
-import { openAsBlob as openAsBlob3, writeFileSync as writeFileSync5 } from "fs";
-var USAGE4 = "Usage: overai storage upload <path> [--no-random-prefix] | storage download <key> [path|-] | storage exists <key> | storage head <key> [--lines N] | storage presign <key> [--expires-in <seconds>]";
+import { openAsBlob as openAsBlob3, writeFileSync as writeFileSync6 } from "fs";
+var USAGE5 = "Usage: overai storage upload <path> [--no-random-prefix] | storage download <key> [path|-] | storage exists <key> | storage head <key> [--lines N] | storage presign <key> [--expires-in <seconds>]";
 var runStorage = async (args) => {
   const [operation, first2, second] = args;
-  if (operation == null) throw new Error(USAGE4);
+  if (operation == null) throw new Error(USAGE5);
   const storage = cliClient().storage;
   if (operation === "upload") {
     if (first2 == null || first2 === "-") {
@@ -68327,11 +69629,11 @@ var runStorage = async (args) => {
 `);
     return;
   }
-  if (first2 == null) throw new Error(USAGE4);
+  if (first2 == null) throw new Error(USAGE5);
   if (operation === "download") {
     const response = await storage.download(first2);
     const bytes = Buffer.from(await response.arrayBuffer());
-    if (second != null && second !== "-") writeFileSync5(second, bytes);
+    if (second != null && second !== "-") writeFileSync6(second, bytes);
     else process.stdout.write(bytes);
     return;
   }
@@ -68363,7 +69665,7 @@ var runStorage = async (args) => {
     );
     return;
   }
-  throw new Error(USAGE4);
+  throw new Error(USAGE5);
 };
 
 // src/commands/workspace.ts
@@ -68493,7 +69795,7 @@ var shareResource = async (args) => {
   process.stdout.write(`Shared ${what} from ${fromId} into ${to}.
 `);
 };
-var USAGE5 = `Usage:
+var USAGE6 = `Usage:
   overai workspace list [--archived] [--limit <n>]
   overai workspace show [workspaceId]
   overai workspace users [workspaceId]
@@ -68531,13 +69833,13 @@ var runWorkspace = async (args) => {
     await shareResource(args.slice(1));
     return;
   }
-  process.stderr.write(USAGE5);
+  process.stderr.write(USAGE6);
   process.exitCode = 1;
 };
 
 // src/updateCheck.ts
 import { request as httpsRequest } from "https";
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var CHECK_TIMEOUT_MS = 2e3;
 var fetchLatestVersion = (signal) => {
@@ -68578,7 +69880,7 @@ var startUpdateCheck = () => {
   const controller = new AbortController();
   const promise2 = (async () => {
     try {
-      if (existsSync6(new URL("src", packageRootUrl()))) return null;
+      if (existsSync7(new URL("src", packageRootUrl()))) return null;
       const path = fileURLToPath2(import.meta.url);
       if (path.includes("_npx") || path.includes("dlx-")) return null;
       const body = await fetchLatestVersion(controller.signal);
@@ -68646,7 +69948,7 @@ Usage:
                                        agent, integration, action_runner), or
                                        one resource, into a direct child
   overai create <type> [--workspace <id>] [--name <name>]
-                                       Create a complete, usable resource
+                                       Create a resource; write its files in a matching clone
   overai resource show <id>             Show metadata for any resource
   overai resource update <id> [...]     Edit metadata, state, or archive status
   overai resource move <id> --to <workspaceId> [--dry-run]
@@ -68711,7 +70013,9 @@ Workspace sync (edit resources as local files):
 Automations:
   overai automation runs <automationId> [--limit N] [--failed] [--running]
   overai automation state <runId> [--node <variableId>]
-  overai automation run <automationId> [--input k=v ... | -]
+  overai automation run <automationId> [--input k=v ... | -] [--wait] [--timeout seconds]
+  overai automation wait <runId> [--timeout seconds]
+    Wait up to 300 seconds by default. Timeout or Ctrl-C stops waiting, not the run.
 
 Other resources:
   overai agent generate <agentId> --message <text|@file|@->
@@ -68742,6 +70046,13 @@ Self-hosted runners (enabling remote access stays on-device \u2014 not a CLI act
   overai runner upload <runnerId> --path '<path>'
   overai runner list [workspaceId]
 
+Actions (one automation node's action, outside any automation):
+  overai action run <workspaceId> <ACTION_ID> [--runner <runnerId>] [--input k=v ... | -]
+                                       ACTION_ID is a node type, e.g.
+                                       MS_SQL_DATABASE_TRANSACTION_REMOTE; no
+                                       --runner uses the org's cloud runner.
+                                       - reads a JSON object of inputs from stdin
+
 Arguments that carry a document \u2014 the graphql query and --variables, the sql
 statement, runner --code \u2014 also take @<file> to read it from disk, or @- to read
 it from stdin. Prefer that for anything long or quote-heavy: an inline value is
@@ -69019,6 +70330,9 @@ var run = async () => {
     case "runner":
       await runRunner(rest);
       return;
+    case "action":
+      await runAction2(rest);
+      return;
     case "update":
     case "upgrade":
       await runUpdate();