@lotics/cli 0.95.0 → 0.96.0

package/dist/src/cli.js

@@ -45377,8 +45377,9 @@ function buildStarterTemplate(args) {
             "react-native-svg": "^15.0.0",
             "react-native-web": "^0.21.0",
             // In-app routing for the scaffolded list→detail example. The app owns
-            // its routing; the SDK's `isEmbedded()` picks memory vs browser history.
-            "react-router-dom": "^7.0.0"
+            // its routing; the SDK's `isEmbedded()` picks memory vs browser history. `react-router` is the
+            // canonical package (react-router-dom is a shim over it).
+            "react-router": "^8.3.0"
           },
           devDependencies: {
             "@testing-library/react": "^16.1.0",
@@ -45619,12 +45620,9 @@ export default defineConfig({
             // react-router hooks and the Router context never matches
             // ("useNavigate() may be used only in the context of a <Router>").
             "@lotics/app-sdk/router",
-            // react-router-dom (App's router) also ships compiled dist JS \u2014 pin it
+            // react-router (App's router) also ships compiled dist JS \u2014 pin it
             // into the shared chunk so its hooks don't split the react instance
             // ("Invalid hook call") when a test renders the routed App tree.
-            "react-router-dom",
-            // v7: react-router-dom is a thin wrapper \u2014 the actual context
-            // lives in react-router; both must ride the shared chunk.
             "react-router",
           ],
           esbuildOptions: {
@@ -45708,7 +45706,7 @@ mount(
       // A single-screen app can delete the router and render one Screen directly.
       content: `import type { ReactNode } from "react";
 import { View } from "react-native";
-import { useNavigate, useParams } from "react-router-dom";
+import { useNavigate, useParams } from "react-router";
 import { AppRouter } from "@lotics/app-sdk/router";
 import { useAiContext } from "@lotics/app-sdk";
 import { Card } from "@lotics/ui/card";
@@ -62046,6 +62044,14 @@ var runtimeKeySchema = zod_default.enum([
   "organization_id",
   "now",
   "change_origin",
+  // PARKED — accepted in stored ASTs, rejected for new saves at parse (see
+  // `PARKED_RUNTIME_KEYS` in walk_workflow_expression.ts). It is the OWNER's
+  // principal (a workflow runs under owner authority), so it can't answer the
+  // caller-authorization question anyone reads it for; the generated `.d.ts`
+  // omits it and the docs point at `current_member_in_any_group` /
+  // `runtime.triggered_by_member_id` instead. The entry stays so any stored
+  // AST keeps validating and executing — drop it only once a prod probe shows
+  // zero references (`workflows.steps_v2::text LIKE '%execution_principal%'`).
   "execution_principal",
   "triggered_by_member_id"
 ]);
@@ -64433,9 +64439,13 @@ for (const [operation, fieldTypes] of Object.entries(OPERATION_FIELD_TYPES)) {
 var AGGREGATABLE_FIELD_TYPES = new Set(FIELD_TYPE_OPERATIONS.keys());
 
 // ../shared/src/chat_models.ts
-var CHAT_MODEL_IDS = ["claude-haiku-4-5", "claude-sonnet-5", "claude-opus-4-8"];
-var LEGACY_CHAT_MODEL_IDS = ["claude-sonnet-4-6"];
+var CHAT_MODEL_IDS = ["claude-haiku-4-5", "claude-sonnet-5", "claude-opus-5"];
+var LEGACY_CHAT_MODEL_IDS = [];
 var ACCEPTED_CHAT_MODEL_IDS = [...CHAT_MODEL_IDS, ...LEGACY_CHAT_MODEL_IDS];
+var UTILITY_MODEL_ID = "claude-haiku-4-5";
+var PICKER_MODEL_IDS = CHAT_MODEL_IDS.filter(
+  (id) => id !== UTILITY_MODEL_ID
+);
 var EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
 
 // ../shared/src/schemas/apps.ts
@@ -64869,7 +64879,9 @@ var appAgentDeclarationSchema = zod_default.object({
   knowledge_doc_ids: zod_default.array(zod_default.string().min(1)).optional().describe(
     "Knowledge docs the agent may read, validated at declare time against the app owner's `use` access. Small docs are inlined into the agent's system prompt each run; a doc too large to inline requires the code tools (code_exec) in tool_names and is read by staging it into a code run. Omit for an agent that needs no knowledge."
   ),
-  model_id: zod_default.string().min(1).describe("Chat model id the agent runs on. Validated against ACCEPTED_CHAT_MODEL_IDS at run time."),
+  model_id: zod_default.string().min(1).optional().describe(
+    "Chat model id the agent runs on, validated against ACCEPTED_CHAT_MODEL_IDS. Omit to follow the platform default chat model, resolved at run time \u2014 the preferred choice: the agent tracks model generations with no per-app rewrite. Pin only a deliberate, tested choice."
+  ),
   effort_level: zod_default.enum(EFFORT_LEVELS).optional().describe(
     "Reasoning depth for adaptive-thinking models \u2014 one of the chosen model's supported levels (validated against model_id at declare time). Omit to use the model default; ignored on models without adaptive thinking."
   ),
@@ -65010,7 +65022,7 @@ var agentStepSchema = stepBaseSchema.extend({
   instructions: zod_default.string().min(1),
   input: zod_default.record(zod_default.string(), toolInputValueSchema),
   tool_names: zod_default.array(zod_default.string().min(1)),
-  model_id: zod_default.string().min(1),
+  model_id: zod_default.string().min(1).optional(),
   output: agentOutputSpecSchema
 });
 var breakStepSchema = stepBaseSchema.extend({
@@ -65516,10 +65528,10 @@ function reverse(arr) {
   }
   return [...arr].reverse();
 }
-function slice(arr, start, end) {
-  if (arr == null) return [];
-  if (!Array.isArray(arr)) {
-    throw new Error("slice: expected array, got " + typeof arr);
+function slice(collection, start, end) {
+  if (collection == null) return [];
+  if (!Array.isArray(collection) && typeof collection !== "string") {
+    throw new Error("slice: expected array or string, got " + typeof collection);
   }
   if (typeof start !== "number") {
     throw new Error("slice: start must be a number");
@@ -65527,7 +65539,7 @@ function slice(arr, start, end) {
   if (end != null && typeof end !== "number") {
     throw new Error("slice: end must be a number");
   }
-  return arr.slice(start, end);
+  return collection.slice(start, end);
 }
 function first2(arr) {
   if (arr == null) return void 0;
@@ -65565,17 +65577,17 @@ function nth(arr, index) {
   }
   return arr[index];
 }
-function at(arr, index) {
-  if (arr == null) return void 0;
-  if (!Array.isArray(arr)) {
-    throw new Error("at: expected array, got " + typeof arr);
+function at(collection, index) {
+  if (collection == null) return void 0;
+  if (!Array.isArray(collection) && typeof collection !== "string") {
+    throw new Error("at: expected array or string, got " + typeof collection);
   }
   if (typeof index !== "number") {
     throw new Error("at: index must be a number");
   }
-  const resolved = index < 0 ? arr.length + index : index;
-  if (resolved < 0 || resolved >= arr.length) return void 0;
-  return arr[resolved];
+  const resolved = index < 0 ? collection.length + index : index;
+  if (resolved < 0 || resolved >= collection.length) return void 0;
+  return collection[resolved];
 }
 function size(arr) {
   if (arr == null) return 0;
@@ -65747,10 +65759,28 @@ function list(...items) {
   }
   return items;
 }
-function concat(...arrays) {
-  if (arrays.length === 0) {
-    throw new Error("concat: expected at least one array argument");
+function concat(...values3) {
+  if (values3.length === 0) {
+    throw new Error("concat: expected at least one array or string argument");
+  }
+  if (typeof values3.find((value) => value != null) === "string") {
+    return concatStrings(values3);
+  }
+  return concatArrays(values3);
+}
+function concatStrings(values3) {
+  let out = "";
+  for (let i2 = 0; i2 < values3.length; i2++) {
+    const value = values3[i2];
+    if (value == null) continue;
+    if (typeof value !== "string") {
+      throw new Error(`concat: argument ${i2} expected string, got ${typeof value}`);
+    }
+    out += value;
   }
+  return out;
+}
+function concatArrays(arrays) {
   let total = 0;
   for (let i2 = 0; i2 < arrays.length; i2++) {
     const arr = arrays[i2];
@@ -67133,6 +67163,18 @@ function isRuntimeKey(name) {
   return RUNTIME_KEYS.has(name);
 }
 var CURRENT_MEMBER_IN_ANY_GROUP = "current_member_in_any_group";
+var PARKED_RUNTIME_KEYS = /* @__PURE__ */ new Map([
+  [
+    "execution_principal",
+    `runtime.execution_principal is not readable \u2014 a workflow runs under the OWNER's authority, so it never answers "is the person who triggered this allowed?". Authorize the caller with ${CURRENT_MEMBER_IN_ANY_GROUP}(["grp_\u2026"]) or read runtime.triggered_by_member_id.`
+  ]
+]);
+function parkedRuntimeKeyConstruct(key) {
+  return `${key}_read`;
+}
+var READABLE_RUNTIME_KEYS = Array.from(RUNTIME_KEYS).filter(
+  (key) => !PARKED_RUNTIME_KEYS.has(key)
+);
 var INLINE_HELPERS = [
   "formatCurrency",
   "randomNumber",
@@ -67164,11 +67206,22 @@ var HELPER_MENU = [
   `date \u2014 ${Object.keys(getDateExpressionFunctions()).sort().join(", ")}`,
   `other \u2014 ${[...INLINE_HELPERS].sort().join(", ")}`
 ].join("; ");
+var MAX_INLINE_EXPANSIONS = 1e3;
+function makeInlineState() {
+  return {
+    args: /* @__PURE__ */ new Map(),
+    stack: [],
+    budget: { remaining: MAX_INLINE_EXPANSIONS },
+    used: /* @__PURE__ */ new Set()
+  };
+}
 function makeScope(init = {}) {
   return {
     stepIds: init.stepIds ?? /* @__PURE__ */ new Set(),
     foreachBinds: init.foreachBinds ?? [],
     toolNames: init.toolNames ?? /* @__PURE__ */ new Set(),
+    functions: init.functions ?? /* @__PURE__ */ new Map(),
+    inline: init.inline ?? makeInlineState(),
     lambdaParams: init.lambdaParams ?? [],
     loopDepth: init.loopDepth ?? 0,
     lexicalBindings: init.lexicalBindings ?? [/* @__PURE__ */ new Set()],
@@ -67199,7 +67252,7 @@ var CALLBACK_HELPERS = /* @__PURE__ */ new Set([
   "intersectionBy",
   "reduce"
 ]);
-var LAMBDA_POSITION_HINT = `Function expressions are not supported here. Lambdas are legal only INLINE as a callback argument to ${[...CALLBACK_HELPERS].sort().join(" / ")} \u2014 write the lambda directly in the call, e.g. pluck(rows, (r) => r.qty * r.price). Binding one to a name (const f = (x) => ...) or calling one directly is not supported: inline it at each call site.`;
+var LAMBDA_POSITION_HINT = `Function expressions are not supported here. A lambda \u2014 either \`(x) => <expr>\` or \`function (x) { return <expr>; }\` \u2014 is legal only INLINE as a callback argument to ${[...CALLBACK_HELPERS].sort().join(" / ")}, e.g. pluck(rows, (r) => r.qty * r.price). To NAME reusable logic, declare it at the top level instead: \`function toLine(l = {}) { return { ... }; }\` \u2014 every parameter needs a default, and the body is inlined at each call site. Binding a lambda to a name (const f = (x) => ...) or calling one directly stays unsupported.`;
 var BINARY_OPS = {
   // Both equality forms work as in JS: `==`/`!=` are loose (coercing), `===`/
   // `!==` are strict. The author picks the semantics; we don't second-guess.
@@ -67244,7 +67297,46 @@ var NAMESPACE_HELPERS = /* @__PURE__ */ new Map([
   ["Object", /* @__PURE__ */ new Map([["keys", "keys"], ["values", "values"], ["entries", "entries"]])],
   ["Number", /* @__PURE__ */ new Map([["parseFloat", "toNumber"]])]
 ]);
+var METHOD_FORM_NAMES = /* @__PURE__ */ new Set([
+  // String.prototype
+  "trim",
+  "toUpperCase",
+  "toLowerCase",
+  "replace",
+  "replaceAll",
+  "split",
+  "substring",
+  "padStart",
+  "padEnd",
+  "startsWith",
+  "endsWith",
+  // String.prototype + Array.prototype
+  "includes",
+  "slice",
+  "at",
+  "concat",
+  // Array.prototype
+  "join",
+  "reverse",
+  "map",
+  "filter",
+  "find",
+  "some",
+  "every",
+  "reduce",
+  // Number.prototype / Object.prototype
+  "toFixed",
+  "toString"
+]);
+var METHOD_FORM_MENU = [...METHOD_FORM_NAMES].sort().join(", ");
 var PROPERTY_HELPERS = /* @__PURE__ */ new Map([["length", "length"]]);
+var RESERVED_CALLABLE_NAMES = /* @__PURE__ */ new Set([
+  ...HELPER_ALIASES.keys(),
+  ...REJECTED_HELPERS.keys(),
+  ...NAMESPACE_HELPERS.keys(),
+  "Math",
+  "Boolean"
+]);
 var MAX_EXPRESSION_DEPTH = 500;
 function walkExpression(node, scope) {
   const depth = scope.depth + 1;
@@ -67300,7 +67392,7 @@ function walkExpressionNode(node, scope) {
       return walkObjectLiteral(node, scope);
     case "ArrowFunctionExpression":
     case "FunctionExpression":
-      fail(node, LAMBDA_POSITION_HINT);
+      fail(node, LAMBDA_POSITION_HINT, "lambda_position");
     case "AssignmentExpression":
       fail(node, 'Assignment is only allowed for "const x = await tool(...)" tool-call bindings.');
     case "UpdateExpression":
@@ -67488,10 +67580,14 @@ function walkObjectLiteral(node, scope) {
 function walkHelperCall(node, scope) {
   const callee = node.callee;
   if (callee.type === "ArrowFunctionExpression" || callee.type === "FunctionExpression") {
-    fail(callee, LAMBDA_POSITION_HINT);
+    fail(callee, LAMBDA_POSITION_HINT, "lambda_position");
   }
   if (node.type === "OptionalCallExpression" && node.optional === true) {
-    fail(node, "Optional calls (`x?.()`) are not supported. Use `?.` on member access only.");
+    fail(
+      node,
+      "Optional calls (`x?.()`) are not supported. Use `?.` on member access only.",
+      "optional_call"
+    );
   }
   if ((callee.type === "MemberExpression" || callee.type === "OptionalMemberExpression") && callee.object.type === "Identifier" && callee.object.name === "Math" && !callee.computed && callee.property.type === "Identifier") {
     const mathFn = callee.property.name;
@@ -67600,6 +67696,17 @@ function isOptionalChainGuard(e) {
   return e.kind === "ternary" && e.then.kind === "lit" && e.then.value === null && e.cond.kind === "call" && e.cond.fn === "isNull";
 }
 function buildHelperCall(node, rawFn, receiver, scope) {
+  const declared = scope.functions.get(rawFn);
+  if (declared) {
+    if (receiver !== null) {
+      fail(
+        node,
+        `"${rawFn}" is a function declared in this workflow \u2014 call it as ${rawFn}(x), not as a method.`,
+        "function_method_form"
+      );
+    }
+    return inlineFunctionCall(node, declared, scope);
+  }
   const rejected = REJECTED_HELPERS.get(rawFn);
   if (rejected) fail(node, rejected.message, rejected.construct);
   const fn = HELPER_ALIASES.get(rawFn) ?? rawFn;
@@ -67610,6 +67717,8 @@ function buildHelperCall(node, rawFn, receiver, scope) {
     fail(node, `${fn} is a reserved identifier and cannot be called.`);
   }
   if (isRuntimeKey(fn) && !isHelper(fn)) {
+    const parked = PARKED_RUNTIME_KEYS.get(fn);
+    if (parked) fail(node, parked, parkedRuntimeKeyConstruct(fn));
     fail(node, `${fn} is a runtime key, not a helper. Read it as runtime.${fn}.`);
   }
   if (!isHelper(fn)) {
@@ -67619,6 +67728,13 @@ function buildHelperCall(node, rawFn, receiver, scope) {
       "unknown_helper"
     );
   }
+  if (receiver !== null && !METHOD_FORM_NAMES.has(rawFn)) {
+    fail(
+      node,
+      `"${rawFn}" has no method form \u2014 call it as ${fn}(x), with the receiver as the first argument. The method form works only for helper names that are also real JS methods: ${METHOD_FORM_MENU}.`,
+      "helper_method_form"
+    );
+  }
   if (fn === "filter") {
     const predNode = node.arguments.length > 0 ? node.arguments[node.arguments.length - 1] : void 0;
     if (predNode && predNode.type === "Identifier" && predNode.name === "Boolean") {
@@ -67645,11 +67761,11 @@ function walkHelperArg(arg, fn, scope) {
       "spread_element"
     );
   }
-  if (arg.type === "ArrowFunctionExpression") {
+  if (arg.type === "ArrowFunctionExpression" || arg.type === "FunctionExpression") {
     if (!CALLBACK_HELPERS.has(fn)) {
       fail(
         arg,
-        `Arrow functions are not supported as arguments to "${fn}". Callbacks work on ${[...CALLBACK_HELPERS].sort().join(" / ")}.`,
+        `Callback functions are not supported as arguments to "${fn}". Callbacks work on ${[...CALLBACK_HELPERS].sort().join(" / ")}.`,
         "lambda_not_allowed"
       );
     }
@@ -67659,7 +67775,15 @@ function walkHelperArg(arg, fn, scope) {
 }
 function walkLambda(node, scope) {
   if (node.async) {
-    fail(node, "Async arrow functions are not supported in callbacks.");
+    fail(node, "Async callbacks are not supported \u2014 a callback body must be a pure, synchronous expression.");
+  }
+  if (node.type === "FunctionExpression") {
+    if (node.generator) {
+      fail(node, "Generator functions (`function*`) are not supported.", "generator_function");
+    }
+    if (node.id) {
+      fail(node.id, `Named function expressions are not supported as callbacks \u2014 drop the name "${node.id.name}".`);
+    }
   }
   const params = [];
   for (const p of node.params) {
@@ -67672,6 +67796,12 @@ function walkLambda(node, scope) {
     if (scope.toolNames.has(p.name) || isHelper(p.name)) {
       fail(p, `Lambda parameter "${p.name}" collides with a tool or helper.`);
     }
+    if (scope.functions.has(p.name)) {
+      fail(p, `Lambda parameter "${p.name}" collides with a function declared in this workflow.`);
+    }
+    if (scope.inline.args.has(p.name)) {
+      fail(p, `Lambda parameter "${p.name}" collides with an enclosing function's parameter.`);
+    }
     if (scope.stepIds.has(p.name)) {
       fail(p, `Lambda parameter "${p.name}" collides with a step id.`);
     }
@@ -67683,20 +67813,177 @@ function walkLambda(node, scope) {
     }
     params.push(p.name);
   }
-  if (node.body.type === "BlockStatement") {
-    fail(
-      node.body,
-      "Lambda body must be a single expression \u2014 block bodies (`(x) => { ... }`) are not supported. Fold the branches into one expression: use a ternary (`x => x.qty > 0 ? x.qty : 0`) or nested helper calls.",
-      "block_body_lambda"
-    );
-  }
+  const bodyExpr = lambdaBodyExpression(node);
   const innerScope = {
     ...scope,
     lambdaParams: [...scope.lambdaParams, ...params]
   };
-  const body = walkExpression(node.body, innerScope);
+  const body = walkExpression(bodyExpr, innerScope);
   return { kind: "lambda", params, body };
 }
+function lambdaBodyExpression(node) {
+  if (node.body.type !== "BlockStatement") {
+    return node.body;
+  }
+  const statements = node.body.body;
+  const only = statements.length === 1 ? statements[0] : null;
+  if (only && only.type === "ReturnStatement" && only.argument) {
+    return only.argument;
+  }
+  fail(
+    node.body,
+    "Lambda body must reduce to a single expression \u2014 either `(x) => <expr>` or a block whose only statement is `return <expr>`. Fold the branches into one expression: use a ternary (`x => x.qty > 0 ? x.qty : 0`) or nested helper calls.",
+    "block_body_lambda"
+  );
+}
+function failFunctionDeclaration(node, why) {
+  fail(
+    node,
+    `${why} A workflow function must be a single-expression helper declared at the top level: \`function name(p = <default>) { return <expr>; }\` \u2014 it is inlined at every call site.
+For logic that doesn't fit that shape, choose one:
+  - bind step: \`const tag = record.Score > 80 ? "hot" : "cold";\` \u2014 compute once, reference by name in later steps.
+  - inline expression: write the logic directly at each call site (often shorter than extracting).
+  - separate workflow: factor the steps out and invoke from this workflow via a tool call.`,
+    "function_declaration"
+  );
+}
+function failUnusedFunction(node, name) {
+  fail(
+    node,
+    `Function "${name}" is declared but never called. A declaration is inlined at its call sites and erased from the saved workflow, so an uncalled one would disappear with its body never checked \u2014 call it, or delete it.`,
+    "function_unused"
+  );
+}
+function collectFunctionDeclarations(body, toolNames) {
+  const functions = /* @__PURE__ */ new Map();
+  for (const stmt of body) {
+    if (stmt.type !== "FunctionDeclaration") continue;
+    if (stmt.async) {
+      failFunctionDeclaration(stmt, "Async functions are not supported.");
+    }
+    if (stmt.generator) {
+      fail(stmt, "Generator functions (`function*`) are not supported.", "generator_function");
+    }
+    if (!stmt.id) {
+      failFunctionDeclaration(stmt, "A function declaration must be named.");
+    }
+    const name = stmt.id.name;
+    assertFunctionName(stmt.id, name, `Function "${name}"`, toolNames);
+    if (functions.has(name)) {
+      fail(stmt.id, `Function "${name}" is already declared in this workflow.`);
+    }
+    const params = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const p of stmt.params) {
+      if (p.type === "Identifier") {
+        fail(
+          p,
+          `Parameter "${p.name}" of function "${name}" needs a default value \u2014 write \`${p.name} = <default>\`. The subset has no type annotations, so the default is what gives the parameter a type; without it the save-time type check reports an implicit \`any\`.`,
+          "function_param_no_default"
+        );
+      }
+      if (p.type !== "AssignmentPattern" || p.left.type !== "Identifier") {
+        fail(
+          p,
+          `Parameters of function "${name}" must be plain names with a default (\`p = <default>\`) \u2014 destructuring and rest are not supported.`,
+          "function_param_shape"
+        );
+      }
+      const paramName = p.left.name;
+      assertFunctionName(p.left, paramName, `Parameter "${paramName}"`, toolNames);
+      if (seen.has(paramName)) {
+        fail(p.left, `Parameter "${paramName}" of function "${name}" is declared twice.`);
+      }
+      seen.add(paramName);
+      params.push({ name: paramName, defaultNode: p.right, node: p.left });
+    }
+    const statements = stmt.body.body;
+    const only = statements.length === 1 ? statements[0] : null;
+    if (!only || only.type !== "ReturnStatement" || !only.argument) {
+      failFunctionDeclaration(
+        stmt.body,
+        `The body of "${name}" must be exactly one \`return <expression>;\`.`
+      );
+    }
+    functions.set(name, { name, params, body: only.argument, node: stmt });
+  }
+  for (const fn of functions.values()) {
+    for (const p of fn.params) {
+      if (functions.has(p.name)) {
+        fail(p.node, `Parameter "${p.name}" of function "${fn.name}" collides with a function declared in this workflow.`);
+      }
+    }
+  }
+  return functions;
+}
+function assertFunctionName(node, name, label, toolNames) {
+  if (RESERVED_ROOTS.has(name)) {
+    fail(node, `${label} uses the reserved identifier "${name}".`);
+  }
+  if (toolNames.has(name)) {
+    fail(node, `${label} collides with the tool "${name}".`);
+  }
+  if (isHelper(name)) {
+    fail(node, `${label} collides with the built-in helper "${name}".`);
+  }
+  if (RESERVED_CALLABLE_NAMES.has(name)) {
+    fail(node, `${label} collides with "${name}", which the subset already gives a meaning.`);
+  }
+}
+function inlineFunctionCall(node, decl, scope) {
+  if (scope.inline.stack.includes(decl.name)) {
+    fail(
+      node,
+      `Function "${decl.name}" is recursive (${[...scope.inline.stack, decl.name].join(" \u2192 ")}). Inlined functions cannot recurse \u2014 express the repetition with a loop step or a helper such as reduce.`,
+      "function_recursion"
+    );
+  }
+  if (scope.inline.budget.remaining <= 0) {
+    fail(
+      node,
+      `This workflow expands to too many inlined function calls (max ${MAX_INLINE_EXPANSIONS}). Reduce nesting between functions, or inline the logic by hand.`,
+      "function_expansion_limit"
+    );
+  }
+  scope.inline.budget.remaining -= 1;
+  scope.inline.used.add(decl.name);
+  if (node.arguments.length > decl.params.length) {
+    fail(
+      node,
+      `Function "${decl.name}" takes ${decl.params.length} argument(s), but ${node.arguments.length} were passed.`,
+      "function_arity"
+    );
+  }
+  const emptyScope = functionBodyScope(scope, decl.name, /* @__PURE__ */ new Map());
+  const args = /* @__PURE__ */ new Map();
+  for (let i2 = 0; i2 < decl.params.length; i2++) {
+    const p = decl.params[i2];
+    const argNode = node.arguments[i2];
+    args.set(
+      p.name,
+      argNode === void 0 ? walkExpression(p.defaultNode, emptyScope) : walkHelperArg(argNode, decl.name, scope)
+    );
+  }
+  return walkExpression(decl.body, functionBodyScope(scope, decl.name, args));
+}
+function functionBodyScope(scope, name, args) {
+  return {
+    stepIds: /* @__PURE__ */ new Set(),
+    foreachBinds: [],
+    toolNames: scope.toolNames,
+    functions: scope.functions,
+    inline: {
+      args,
+      stack: [...scope.inline.stack, name],
+      budget: scope.inline.budget,
+      used: scope.inline.used
+    },
+    lambdaParams: [],
+    loopDepth: 0,
+    lexicalBindings: [/* @__PURE__ */ new Set()],
+    depth: scope.depth
+  };
+}
 function flattenChain(node, scope) {
   let cur = node;
   const reverse2 = [];
@@ -67786,7 +68073,30 @@ function walkRead(node, scope) {
   if (chain2.segments.length === 0 && scope.toolNames.has(chain2.rootName)) {
     fail(node, `Tools may only be invoked, not referenced. Write "const x = await ${chain2.rootName}({...})".`);
   }
+  if (scope.functions.has(chain2.rootName)) {
+    fail(
+      node,
+      `Function "${chain2.rootName}" may only be called, not referenced. Write ${chain2.rootName}(...).`,
+      "function_as_value"
+    );
+  }
   const root = chain2.rootName;
+  const inlined = scope.inline.args.get(root);
+  if (inlined !== void 0) {
+    if (chain2.segments.length === 0) return inlined;
+    if (inlined.kind !== "read") {
+      fail(
+        node,
+        `Cannot read a property off parameter "${root}" \u2014 the argument passed at the call site is a computed value, not a record or binding. Bind it first (\`const x = <expr>;\`) and pass the binding.`,
+        "function_arg_not_read"
+      );
+    }
+    const base = inlined;
+    return wrapOptionalGuards(chain2, (segments) => ({
+      ...base,
+      path: [...base.path, ...classifyRecordPath(segments)]
+    }));
+  }
   if (root === "record" || root === "prev_record") {
     return readFromRecord(
       root === "record" ? "trigger_record" : "trigger_record_prev",
@@ -67803,6 +68113,13 @@ function walkRead(node, scope) {
     return readFromRuntime(chain2);
   }
   if (root === "index") {
+    if (scope.inline.stack.length > 0) {
+      fail(
+        node,
+        "index is not readable inside a function \u2014 it belongs to the enclosing loop, so an inlined body would mean something different at each call site. Pass it as a parameter.",
+        "function_reads_index"
+      );
+    }
     if (chain2.segments.length > 0) {
       fail(node, "index has no properties.");
     }
@@ -67831,6 +68148,7 @@ function walkRead(node, scope) {
     "runtime",
     "trigger",
     "index",
+    ...scope.inline.args.keys(),
     ...lexicalNames,
     ...Array.from(scope.lambdaParams),
     ...Array.from(scope.foreachBinds),
@@ -67880,7 +68198,20 @@ function readFromChanges(chain2) {
     return { kind: "read", source: { from: "trigger_changes" }, path: path8 };
   });
 }
+var TRIGGER_RECORD_VIEWS = /* @__PURE__ */ new Map([
+  ["data", "trigger_record"],
+  ["prev_data", "trigger_record_prev"],
+  ["changes", "trigger_changes"]
+]);
 function readFromTrigger(chain2) {
+  const head = chain2.segments[0];
+  const view = head && (head.kind === "dot" || head.kind === "bracket-string") ? TRIGGER_RECORD_VIEWS.get(head.key) : void 0;
+  if (head && view !== void 0) {
+    const rest = chain2.segments.slice(1);
+    const segments = head.optional === true && rest.length > 0 ? [{ ...rest[0], optional: true }, ...rest.slice(1)] : rest;
+    const lowered = { ...chain2, segments };
+    return view === "trigger_changes" ? readFromChanges(lowered) : readFromRecord(view, lowered);
+  }
   return wrapOptionalGuards(chain2, (segments) => {
     const path8 = [];
     for (const seg of segments) {
@@ -67907,10 +68238,13 @@ function readFromRuntime(chain2) {
     if (first3.kind !== "dot" && first3.kind !== "bracket-string") {
       fail(first3.node, "runtime is keyed by name (runtime.timezone, runtime.now, ...).");
     }
-    if (!isRuntimeKey(first3.key)) {
-      fail(first3.node, `Unknown runtime key "${first3.key}". Allowed: ${Array.from(RUNTIME_KEYS).join(", ")}.`);
+    const key = first3.key ?? "";
+    if (!isRuntimeKey(key)) {
+      fail(first3.node, `Unknown runtime key "${key}". Allowed: ${READABLE_RUNTIME_KEYS.join(", ")}.`);
     }
-    const source = { from: "runtime", key: first3.key };
+    const parked = PARKED_RUNTIME_KEYS.get(key);
+    if (parked) fail(first3.node, parked, parkedRuntimeKeyConstruct(key));
+    const source = { from: "runtime", key };
     const path8 = [];
     for (const seg of segments.slice(1)) {
       if (seg.kind === "bracket-number") {
@@ -68101,14 +68435,25 @@ function parseWorkflowJs(source, opts) {
   }
 }
 function walkProgram(body, scope, stepIds, opts) {
+  const functions = collectFunctionDeclarations(body, opts.toolNames ?? /* @__PURE__ */ new Set());
+  const progScope = { ...scope, functions };
   let synthetic = 0;
   const steps = [];
   for (const stmt of body) {
-    steps.push(...walkStatement(stmt, scope, stepIds, opts, () => `_s${synthetic++}`, 1));
+    if (stmt.type === "FunctionDeclaration") continue;
+    steps.push(...walkStatement(stmt, progScope, stepIds, opts, () => `_s${synthetic++}`, 1));
+  }
+  for (const fn of functions.values()) {
+    if (!progScope.inline.used.has(fn.name)) failUnusedFunction(fn.node, fn.name);
   }
   return steps;
 }
 var MAX_STATEMENT_DEPTH = 500;
+function assertNoFunctionCollision(node, name, scope, label) {
+  if (scope.functions.has(name)) {
+    fail(node, `${label} "${name}" collides with a function declared in this workflow.`);
+  }
+}
 function walkStatement(stmt, scope, stepIds, opts, nextSyntheticId, depth) {
   if (depth > MAX_STATEMENT_DEPTH) {
     fail(stmt, `Workflow nesting is too deep (max ${MAX_STATEMENT_DEPTH} levels).`, "depth_limit");
@@ -68117,6 +68462,9 @@ function walkStatement(stmt, scope, stepIds, opts, nextSyntheticId, depth) {
 }
 function walkStatementInner(stmt, scope, stepIds, opts, nextSyntheticId, depth) {
   const { id: explicitId, description } = readLeadingComments(stmt);
+  if (explicitId !== void 0) {
+    assertNoFunctionCollision(stmt, explicitId, scope, "Step id");
+  }
   switch (stmt.type) {
     case "VariableDeclaration":
       return walkConstBinding(stmt, scope, stepIds, opts, explicitId, description, nextSyntheticId);
@@ -68177,10 +68525,9 @@ function walkStatementInner(stmt, scope, stepIds, opts, nextSyntheticId, depth)
     case "ReturnStatement":
       return [walkReturnStatement(stmt, scope, explicitId ?? nextSyntheticId(), description)];
     case "FunctionDeclaration":
-      fail(
+      failFunctionDeclaration(
         stmt,
-        'Function declarations are not supported. For reusable logic, choose one:\n  - bind step: `const tag = record.Score > 80 ? "hot" : "cold";` \u2014 compute once, reference by name in later steps.\n  - inline expression: write the logic directly at each call site (often shorter than extracting).\n  - separate workflow: factor the steps out and invoke from this workflow via a tool call.\nIf you were translating a JS helper habit, the bind step usually fits \u2014 workflows already let you name an expression for reuse.',
-        "function_declaration"
+        "A function declared inside a block is not supported."
       );
     case "ClassDeclaration":
       fail(stmt, "Class declarations are not allowed.");
@@ -68243,6 +68590,7 @@ function walkConstDeclarator(decl, scope, stepIds, opts, explicitId, description
   if (opts.toolNames && opts.toolNames.has(id) || isHelper(id)) {
     fail(decl.id, `Cannot bind to "${id}" \u2014 name collides with a tool or helper.`);
   }
+  assertNoFunctionCollision(decl.id, id, scope, "Binding");
   if (stepIds.has(id)) {
     fail(decl.id, `Step id "${id}" is already used.`);
   }
@@ -68419,6 +68767,7 @@ function walkPatternBinding(decl, scope, stepIds, opts, explicitId, description,
     if (opts.toolNames && opts.toolNames.has(entry.name) || isHelper(entry.name)) {
       fail(entry.node, `Cannot bind to "${entry.name}" \u2014 name collides with a tool or helper.`);
     }
+    assertNoFunctionCollision(entry.node, entry.name, scope, "Binding");
     if (stepIds.has(entry.name)) {
       fail(entry.node, `Step id "${entry.name}" is already used.`);
     }
@@ -68462,6 +68811,7 @@ function walkLetDeclaration(stmt, scope, stepIds, opts, explicitId, description)
         if (opts.toolNames && opts.toolNames.has(name2) || isHelper(name2)) {
           fail(entry.node, `let binding "${name2}" collides with a tool or helper.`);
         }
+        assertNoFunctionCollision(entry.node, name2, scope, "let binding");
         if (stepIds.has(name2)) {
           fail(entry.node, `let binding "${name2}" collides with a step id.`);
         }
@@ -68492,6 +68842,7 @@ function walkLetDeclaration(stmt, scope, stepIds, opts, explicitId, description)
     if (opts.toolNames && opts.toolNames.has(name) || isHelper(name)) {
       fail(decl.id, `let binding "${name}" collides with a tool or helper.`);
     }
+    assertNoFunctionCollision(decl.id, name, scope, "let binding");
     if (stepIds.has(name)) {
       fail(decl.id, `let binding "${name}" collides with a step id.`);
     }
@@ -68822,15 +69173,13 @@ function walkForOf(stmt, scope, stepIds, opts, stepId, description, nextSyntheti
   if (opts.toolNames && opts.toolNames.has(bindName) || isHelper(bindName)) {
     fail(decl.id, `Foreach bind name "${bindName}" collides with a tool or helper.`);
   }
+  assertNoFunctionCollision(decl.id, bindName, scope, "Foreach bind name");
   const items = walkForOfRight(stmt.right, scope);
   const innerScope = {
-    stepIds: scope.stepIds,
+    ...scope,
     foreachBinds: [...scope.foreachBinds, bindName],
-    toolNames: scope.toolNames,
-    lambdaParams: scope.lambdaParams,
     loopDepth: scope.loopDepth + 1,
-    lexicalBindings: [...scope.lexicalBindings, /* @__PURE__ */ new Set()],
-    depth: scope.depth
+    lexicalBindings: [...scope.lexicalBindings, /* @__PURE__ */ new Set()]
   };
   if (stmt.body.type !== "BlockStatement") {
     fail(stmt.body, "for-of body must be a { ... } block.");
@@ -68844,6 +69193,7 @@ function walkForOf(stmt, scope, stepIds, opts, stepId, description, nextSyntheti
       if (opts.toolNames && opts.toolNames.has(entry.name) || isHelper(entry.name)) {
         fail(entry.node, `Cannot bind to "${entry.name}" \u2014 name collides with a tool or helper.`);
       }
+      assertNoFunctionCollision(entry.node, entry.name, scope, "Binding");
       if (stepIds.has(entry.name)) {
         fail(entry.node, `Step id "${entry.name}" is already used.`);
       }
@@ -69026,6 +69376,7 @@ function walkTry(stmt, scope, stepIds, opts, stepId, description, nextSyntheticI
   if (opts.toolNames && opts.toolNames.has(errorBinding) || isHelper(errorBinding)) {
     fail(handler.param, `Catch binding "${errorBinding}" collides with a tool or helper.`);
   }
+  assertNoFunctionCollision(handler.param, errorBinding, scope, "Catch binding");
   if (stepIds.has(errorBinding)) {
     fail(handler.param, `Catch binding "${errorBinding}" collides with an existing step id.`);
   }
@@ -69285,8 +69636,7 @@ function walkAgentInvocation(call, scope, stepId, description) {
   if (!toolsNode) fail(arg, "agent requires `tools` (use [] for none).");
   const tool_names = readStaticStringArray(toolsNode, "agent `tools`");
   const modelNode = kw.get("model");
-  if (!modelNode) fail(arg, "agent requires `model`.");
-  const model_id = readStaticString(modelNode, "agent `model`");
+  const model_id = modelNode ? readStaticString(modelNode, "agent `model`") : void 0;
   const outputNode = kw.get("output");
   if (!outputNode) fail(arg, "agent requires `output`.");
   const outputResult = agentOutputSpecSchema.safeParse(walkStaticJsonLiteral(outputNode));
@@ -69301,7 +69651,7 @@ function walkAgentInvocation(call, scope, stepId, description) {
     instructions,
     input,
     tool_names,
-    model_id,
+    ...model_id !== void 0 ? { model_id } : {},
     output: outputResult.data
   };
 }
@@ -69402,6 +69752,133 @@ function readLeadingComments(stmt) {
   return { id, description };
 }
 
+// ../shared/src/rewrite_accumulator_appends.ts
+function rewriteAccumulatorAppends(tsApi, source) {
+  const file2 = tsApi.createSourceFile(
+    "/checked_source.ts",
+    source,
+    tsApi.ScriptTarget.ES2022,
+    true
+  );
+  const seeded = emptyArrayLetNames(tsApi, file2);
+  if (seeded.size === 0) return source;
+  const edits = [];
+  const visit = (node) => {
+    if (tsApi.isExpressionStatement(node)) collectAppendEdits(tsApi, node, file2, seeded, edits);
+    tsApi.forEachChild(node, visit);
+  };
+  tsApi.forEachChild(file2, visit);
+  if (edits.length === 0) return source;
+  return applyEdits(source, edits);
+}
+function emptyArrayLetNames(tsApi, file2) {
+  const names = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    if (tsApi.isVariableDeclarationList(node) && (node.flags & tsApi.NodeFlags.Let) !== 0) {
+      for (const decl of node.declarations) {
+        if (!tsApi.isIdentifier(decl.name)) continue;
+        if (decl.type) continue;
+        const init = decl.initializer;
+        if (init && tsApi.isArrayLiteralExpression(init) && init.elements.length === 0) {
+          names.add(decl.name.text);
+        }
+      }
+    }
+    tsApi.forEachChild(node, visit);
+  };
+  tsApi.forEachChild(file2, visit);
+  return names;
+}
+function collectAppendEdits(tsApi, stmt, file2, seeded, edits) {
+  const expr = stmt.expression;
+  if (!tsApi.isBinaryExpression(expr)) return;
+  if (expr.operatorToken.kind !== tsApi.SyntaxKind.EqualsToken) return;
+  const target = expr.left;
+  if (!tsApi.isIdentifier(target) || !seeded.has(target.text)) return;
+  const name = target.text;
+  const start = expr.getStart(file2);
+  const rhs = expr.right;
+  if (tsApi.isArrayLiteralExpression(rhs)) {
+    const [head, ...rest] = rhs.elements;
+    if (!head || !tsApi.isSpreadElement(head)) return;
+    if (!tsApi.isIdentifier(head.expression) || head.expression.text !== name) return;
+    if (rest.length === 0 || rest.some((e) => tsApi.isSpreadElement(e))) return;
+    pushEdits(edits, file2, {
+      start,
+      firstItem: rest[0],
+      lastItem: rest[rest.length - 1],
+      closeEnd: rhs.getEnd(),
+      tokens: [name, ".push("]
+    });
+    return;
+  }
+  if (!tsApi.isCallExpression(rhs)) return;
+  if (!tsApi.isIdentifier(rhs.expression) || rhs.expression.text !== "concat") return;
+  if (rhs.arguments.length !== 2) return;
+  const [selfArg, appended] = rhs.arguments;
+  if (!tsApi.isIdentifier(selfArg) || selfArg.text !== name) return;
+  if (tsApi.isSpreadElement(appended)) return;
+  if (!tsApi.isArrayLiteralExpression(appended)) return;
+  const items = appended.elements;
+  if (items.length === 0 || items.some((e) => tsApi.isSpreadElement(e))) return;
+  pushEdits(edits, file2, {
+    start,
+    firstItem: items[0],
+    lastItem: items[items.length - 1],
+    closeEnd: rhs.getEnd(),
+    tokens: [name, ".push("]
+  });
+}
+function pushEdits(edits, file2, plan) {
+  const headStart = plan.start;
+  const headEnd = plan.firstItem.getStart(file2);
+  const tailStart = plan.lastItem.getEnd();
+  const headText = fillRegion(plan.tokens, file2.text.slice(headStart, headEnd));
+  const tailText = fillRegion([")"], file2.text.slice(tailStart, plan.closeEnd));
+  if (headText === null || tailText === null) return;
+  edits.push(
+    { start: headStart, end: headEnd, text: headText },
+    { start: tailStart, end: plan.closeEnd, text: tailText }
+  );
+}
+function applyEdits(source, edits) {
+  const ordered = [...edits].sort((a, b) => a.start - b.start);
+  const parts = [];
+  let cursor = 0;
+  for (const edit of ordered) {
+    parts.push(source.slice(cursor, edit.start), edit.text);
+    cursor = edit.end;
+  }
+  parts.push(source.slice(cursor));
+  return parts.join("");
+}
+function fillRegion(tokens, original) {
+  const chars = original.split("").map((c) => c === "\n" || c === "\r" ? c : " ");
+  let cursor = 0;
+  for (const token of tokens) {
+    const at2 = findPlaceableWindow(chars, cursor, token.length);
+    if (at2 === null) return null;
+    for (let i2 = 0; i2 < token.length; i2++) chars[at2 + i2] = token[i2];
+    cursor = at2 + token.length;
+  }
+  return chars.join("");
+}
+function findPlaceableWindow(chars, from, width) {
+  for (let i2 = from; i2 + width <= chars.length; i2++) {
+    let ok = true;
+    for (let j = 0; j < width; j++) {
+      const c = chars[i2 + j];
+      if (c === "\n" || c === "\r") {
+        ok = false;
+        i2 += j;
+        break;
+      }
+    }
+    if (ok) return i2;
+  }
+  return null;
+}
+
 // src/workflow_envelope.ts
 var FALLBACK_ENVELOPE_PREFIX = "async function __workflow(): Promise<__WorkflowReturn | void> {\n";
 var FALLBACK_ENVELOPE_SUFFIX = "\n}";
@@ -69489,9 +69966,16 @@ function checkOneWorkflowBody(tsApi, input) {
   const offset = bodyLineOffset(wrapped);
   const subset = subsetIssues(stripWorkflowHeader(wrapped), offset);
   if (subset) return subset;
+  const options = workflowCheckCompilerOptions(tsApi);
   const program = tsApi.createProgram({
     rootNames: [input.globalsPath, input.bodyPath],
-    options: workflowCheckCompilerOptions(tsApi)
+    options,
+    host: createCheckedSourceHost(
+      tsApi,
+      options,
+      input.bodyPath,
+      rewriteAccumulatorAppends(tsApi, wrapped)
+    )
   });
   const bodyFile = program.getSourceFile(input.bodyPath);
   if (!bodyFile) {
@@ -69523,6 +70007,17 @@ function checkOneWorkflowBody(tsApi, input) {
   }
   return issues;
 }
+function createCheckedSourceHost(tsApi, options, bodyPath, bodyText) {
+  const base = tsApi.createCompilerHost(options, false);
+  const key = (fileName) => base.getCanonicalFileName(path4.resolve(fileName).replace(/\\/g, "/"));
+  const bodyKey = key(bodyPath);
+  return {
+    ...base,
+    getSourceFile: (fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile) => key(fileName) === bodyKey ? tsApi.createSourceFile(fileName, bodyText, languageVersionOrOptions, true) : base.getSourceFile(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile),
+    readFile: (fileName) => key(fileName) === bodyKey ? bodyText : base.readFile(fileName),
+    fileExists: (fileName) => key(fileName) === bodyKey ? true : base.fileExists(fileName)
+  };
+}
 function checkWorkflowBodies(tsApi, aliases) {
   return aliases.map(({ alias, input }) => ({
     alias,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lotics/cli",
-  "version": "0.95.0",
+  "version": "0.96.0",
   "description": "Lotics SDK and CLI for AI agents",
   "type": "module",
   "bin": {