@lotics/cli 0.92.0 → 0.94.0

package/README.md

@@ -217,6 +217,14 @@ lotics app workflow set issueInvoice        # push the edited src/workflows/issu
 # authoritative, so the next `app deploy` re-syncs it — keep the manifest current.
 lotics app query set openInvoices           # push package.json#lotics.queries.openInvoices
 
+# Run a bound app agent end-to-end (no deployed UI needed — app row + declaration
+# + member auth). Streams progress to stderr; reports the SETTLED run (structured
+# output / final text) to stdout; exits 0 only when the run completed.
+lotics app agent run app_abc recognize '{"image_file_id":"fil_..."}'
+cat input.json | lotics app agent run app_abc recognize        # inputs via stdin/@file
+lotics app agent run app_abc recognize --json                  # full run summary to stdout
+lotics app agent run app_abc recognize --session cli-123 '{}'  # continue an existing thread
+
 # Dev-link @lotics/ui to packages/ui/src for live HMR (Vite alias; deploy bundles it)
 lotics ui link card                        # monorepo: packages/ui/src found automatically
 lotics ui link card --ui-src /abs/monorepo/packages/ui/src   # external app (e.g. ~/lotics_apps)

package/dist/src/cli.js

@@ -29586,6 +29586,7 @@ var require_lib3 = __commonJS({
 import dns from "node:dns";
 import net2 from "node:net";
 import fs9 from "node:fs";
+import os2 from "node:os";
 import path7 from "node:path";
 import readline from "node:readline";
 
@@ -30198,11 +30199,18 @@ var LoticsClient = class {
    * `async function __workflow(): …` wrapper the server compiles inside, so the
    * local typecheck mirrors the set-time verdict. Mirrors
    * POST /v1/apps/{app_id}/workflows/{alias}/dts.
+   *
+   * `declaration` (the manifest's `{ inputs?, outputs? }`) is posted as the body
+   * `{ declaration }` ONLY when the alias isn't `set` on the server yet — the
+   * server then synthesizes the dts from the declared schemas instead of 400ing
+   * "no workflow alias". A registered alias needs no declaration (the server's
+   * own bound contract wins), so the field is omitted in that case.
    */
-  async getAppWorkflowDts(app_id, alias) {
+  async getAppWorkflowDts(app_id, alias, declaration) {
     return this.request(
       "POST",
-      `/v1/apps/${encodeURIComponent(app_id)}/workflows/${encodeURIComponent(alias)}/dts`
+      `/v1/apps/${encodeURIComponent(app_id)}/workflows/${encodeURIComponent(alias)}/dts`,
+      declaration ? { declaration } : void 0
     );
   }
   /**
@@ -30224,6 +30232,37 @@ var LoticsClient = class {
     if (!res.ok) await this.throwResponseError(res);
     return res;
   }
+  /**
+   * Continue a PARKED (`awaiting_input`) agent run with the user's answer to its
+   * pending `ask_user_choice` — returns the RAW streamed continuation `Response`,
+   * exactly like `appAgentRunStream`. Mirrors
+   * POST /v1/apps/{app_id}/agent-runs/{run_id}/continue.
+   */
+  async appAgentRunContinueStream(app_id, run_id, body, signal) {
+    const res = await fetch(
+      `${this.baseUrl}/v1/apps/${encodeURIComponent(app_id)}/agent-runs/${encodeURIComponent(run_id)}/continue`,
+      {
+        method: "POST",
+        headers: { ...this.buildHeaders(), "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+        signal
+      }
+    );
+    if (!res.ok) await this.throwResponseError(res);
+    return res;
+  }
+  /**
+   * A session's app-agent run history, oldest-first (the run just started is the
+   * last, and its exact id is on the stream response's `x-app-agent-run-id`
+   * header). Transcript excluded; structured `output`/`input` included. Mirrors
+   * GET /v1/apps/{app_id}/agent-runs.
+   */
+  async listAgentRuns(app_id, session_id) {
+    return this.request(
+      "GET",
+      `/v1/apps/${encodeURIComponent(app_id)}/agent-runs?session_id=${encodeURIComponent(session_id)}`
+    );
+  }
   /**
    * Mint a presigned URL for uploading a file into an app. Mirrors
    * POST /v1/apps/{app_id}/files/upload-url.
@@ -30555,6 +30594,16 @@ function upsertProfile(orgId, fields) {
     latest_version: config2.latest_version
   });
 }
+function clearProfileWorkspace(orgId) {
+  const config2 = loadGlobalConfig();
+  const existing = config2?.profiles?.[orgId];
+  if (!existing) return;
+  const { workspace_id: _dropped, ...rest } = existing;
+  saveGlobalConfig({
+    ...config2,
+    profiles: { ...config2.profiles, [orgId]: { ...rest } }
+  });
+}
 function removeProfile(orgId) {
   const config2 = loadGlobalConfig();
   if (!config2?.profiles?.[orgId]) return;
@@ -30653,6 +30702,7 @@ var VERSION = pkg.version;
 import fs4 from "node:fs";
 import path5 from "node:path";
 import { spawn as spawn2 } from "node:child_process";
+import { randomUUID } from "node:crypto";
 import { tmpdir } from "node:os";
 
 // src/starter_template.ts
@@ -31778,14 +31828,14 @@ function buildWrapperPage(args) {
       // protocol expects (stream-chunk* -> stream-end). Mirrors the production
       // host in frontend/features/app_ui/app_iframe_host.tsx.
       const streamingRuns = {};
-      async function handleAgentRun(id, payload) {
+      async function handleAgentRun(id, op, payload) {
         const controller = new AbortController();
         streamingRuns[id] = controller;
         try {
           const res = await fetch("/_agent_run", {
             method: "POST",
             headers: { "content-type": "application/json" },
-            body: JSON.stringify({ app_id: APP_ID, op: "agentRun", payload: payload }),
+            body: JSON.stringify({ app_id: APP_ID, op: op, payload: payload }),
             signal: controller.signal,
           });
           if (!res.ok || !res.body) {
@@ -31793,6 +31843,9 @@ function buildWrapperPage(args) {
             try { detail = JSON.parse(detail).message || detail; } catch (_) {}
             throw new Error(detail || ("HTTP " + res.status));
           }
+          // Forward the run id (poll-recovery / cancel / continue key on it).
+          const runId = res.headers.get("x-app-agent-run-id");
+          if (runId) iframe.contentWindow.postMessage({ id: id, type: "run-id", runId: runId }, VITE_ORIGIN);
           const reader = res.body.getReader();
           const decoder = new TextDecoder();
           for (;;) {
@@ -31826,7 +31879,7 @@ function buildWrapperPage(args) {
         }
         if (typeof msg.op !== "string") return;
         // Streaming agent run \u2014 many messages back, not a single result.
-        if (msg.op === "agentRun") { handleAgentRun(msg.id, msg.payload); return; }
+        if (msg.op === "agentRun" || msg.op === "agentRunContinue") { handleAgentRun(msg.id, msg.op, msg.payload); return; }
         const startedAt = performance.now();
         try {
           const data = msg.op === "upload"
@@ -32065,18 +32118,37 @@ async function startDevServer(args) {
       });
       try {
         const body = await readJson(req);
-        const p = body.payload ?? {};
-        if (typeof p.alias !== "string" || typeof p.session_id !== "string") {
-          throw new Error("agentRun payload must include `alias` and `session_id`");
-        }
-        const upstream = await args.client.appAgentRunStream(
-          body.app_id,
-          p.alias,
-          { session_id: p.session_id, input: p.input ?? {} },
-          ac.signal
-        );
+        let upstream;
+        if (body.op === "agentRunContinue") {
+          const p = body.payload ?? {};
+          if (typeof p.run_id !== "string" || typeof p.tool_call_id !== "string" || typeof p.output !== "object" || p.output === null) {
+            throw new Error("agentRunContinue payload must include `run_id`, `tool_call_id`, and `output`");
+          }
+          upstream = await args.client.appAgentRunContinueStream(
+            body.app_id,
+            p.run_id,
+            { tool_call_id: p.tool_call_id, output: p.output },
+            ac.signal
+          );
+        } else {
+          const p = body.payload ?? {};
+          if (typeof p.alias !== "string" || typeof p.session_id !== "string") {
+            throw new Error("agentRun payload must include `alias` and `session_id`");
+          }
+          upstream = await args.client.appAgentRunStream(
+            body.app_id,
+            p.alias,
+            { session_id: p.session_id, input: p.input ?? {} },
+            ac.signal
+          );
+        }
         if (!upstream.body) throw new Error("agent run returned no stream body");
-        res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-cache, no-transform" });
+        const runId = upstream.headers.get("x-app-agent-run-id");
+        res.writeHead(200, {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache, no-transform",
+          ...runId ? { "x-app-agent-run-id": runId } : {}
+        });
         const reader = upstream.body.getReader();
         for (; ; ) {
           const { value, done } = await reader.read();
@@ -32932,6 +33004,12 @@ var LOTICS_INCLUDE_GLOB = ".lotics/**/*";
 var STALE_LOTICS_INCLUDES = /* @__PURE__ */ new Set([".lotics", "./.lotics", ".lotics/"]);
 var FALLBACK_ENVELOPE_PREFIX = "async function __workflow(): Promise<__WorkflowReturn | void> {\n";
 var FALLBACK_ENVELOPE_SUFFIX = "\n}";
+function toWorkflowDtsDeclaration(d) {
+  return { inputs: d.inputs, outputs: d.outputs };
+}
+function isUnknownWorkflowAliasError(err2) {
+  return err2 instanceof Error && /^400:/.test(err2.message) && /has no workflow alias/i.test(err2.message);
+}
 function workflowFileHeader(alias) {
   const refPath = path5.join("..", "..", WORKFLOW_GLOBALS_DIR, `${alias}.globals.d.ts`).split(path5.sep).join("/");
   return `/// <reference path="${refPath}" />
@@ -32992,9 +33070,9 @@ function stripWorkflowHeader(content) {
   }
   return lines.slice(start + 1).join("\n").replace(/\s+$/, "");
 }
-async function writeWorkflowFiles(client, projectDir, app_id, aliases) {
+async function writeWorkflowFiles(client, projectDir, app_id, workflows) {
   const written = [];
-  for (const alias of aliases) {
+  for (const [alias, declaration] of Object.entries(workflows)) {
     const res = await client.getAppWorkflow(app_id, alias);
     const source = res.error || res.result === null || typeof res.result !== "object" ? null : res.result.source;
     if (typeof source !== "string" || source.trim() === "") {
@@ -33003,15 +33081,26 @@ async function writeWorkflowFiles(client, projectDir, app_id, aliases) {
       );
       continue;
     }
-    const envelope = await fetchWorkflowGlobals(client, projectDir, app_id, alias);
+    const envelope = await fetchWorkflowGlobals(
+      client,
+      projectDir,
+      app_id,
+      alias,
+      toWorkflowDtsDeclaration(declaration)
+    );
     writeWorkflowFile(projectDir, alias, source, envelope);
     written.push(alias);
   }
   return written;
 }
-async function fetchWorkflowGlobals(client, projectDir, app_id, alias) {
+async function fetchWorkflowGlobals(client, projectDir, app_id, alias, declaration) {
   try {
-    const { dts, envelope_prefix, envelope_suffix } = await client.getAppWorkflowDts(app_id, alias);
+    const { dts, envelope_prefix, envelope_suffix } = await fetchWorkflowDts(
+      client,
+      app_id,
+      alias,
+      declaration
+    );
     writeWorkflowGlobals(projectDir, alias, dts);
     return { prefix: envelope_prefix, suffix: envelope_suffix };
   } catch (err2) {
@@ -33021,6 +33110,16 @@ async function fetchWorkflowGlobals(client, projectDir, app_id, alias) {
     return { prefix: FALLBACK_ENVELOPE_PREFIX, suffix: FALLBACK_ENVELOPE_SUFFIX };
   }
 }
+async function fetchWorkflowDts(client, app_id, alias, declaration) {
+  try {
+    return await client.getAppWorkflowDts(app_id, alias);
+  } catch (err2) {
+    if (declaration && isUnknownWorkflowAliasError(err2)) {
+      return client.getAppWorkflowDts(app_id, alias, declaration);
+    }
+    throw err2;
+  }
+}
 function runTar(args, cwd) {
   return new Promise((resolve2, reject2) => {
     const proc = spawn2("tar", args, { cwd, stdio: ["ignore", "ignore", "pipe"] });
@@ -33067,10 +33166,37 @@ function readAppMeta(projectDir) {
     capabilities: pkg2.lotics.capabilities
   };
 }
+var APP_META_KEYS = Object.keys({
+  app_id: true,
+  workspace_id: true,
+  current_version_id: true,
+  version_number: true,
+  workflows: true,
+  queries: true,
+  agents: true,
+  capabilities: true
+});
 function writeAppMeta(projectDir, meta3) {
   const pkgPath2 = path5.join(projectDir, "package.json");
   const pkg2 = JSON.parse(fs4.readFileSync(pkgPath2, "utf-8"));
-  pkg2.lotics = meta3;
+  const existing = pkg2.lotics && typeof pkg2.lotics === "object" ? pkg2.lotics : {};
+  const preserved = {};
+  for (const [key, value] of Object.entries(existing)) {
+    if (!APP_META_KEYS.includes(key)) preserved[key] = value;
+  }
+  pkg2.lotics = { ...meta3, ...preserved };
+  fs4.writeFileSync(pkgPath2, JSON.stringify(pkg2, null, 2) + "\n");
+}
+function writeWorkflowOutputs(projectDir, alias, outputs) {
+  const pkgPath2 = path5.join(projectDir, "package.json");
+  const pkg2 = JSON.parse(fs4.readFileSync(pkgPath2, "utf-8"));
+  const declaration = pkg2.lotics?.workflows?.[alias];
+  if (!declaration) {
+    throw new Error(
+      `package.json#lotics.workflows.${alias} disappeared before the derived-outputs write-back.`
+    );
+  }
+  declaration.outputs = outputs;
   fs4.writeFileSync(pkgPath2, JSON.stringify(pkg2, null, 2) + "\n");
 }
 function ensureAppTsconfig(projectDir) {
@@ -33205,19 +33331,29 @@ async function appCodegen(args) {
       `\u26A0 Could not regenerate .lotics/app_fields.ts (${err2 instanceof Error ? err2.message : String(err2)}). Kept the existing file.`
     );
   }
-  await refreshWorkflowGlobals(args.client, projectDir, meta3.app_id, Object.keys(meta3.workflows ?? {}));
+  await refreshWorkflowGlobals(args.client, projectDir, meta3.app_id, meta3.workflows ?? {});
 }
-async function refreshWorkflowGlobals(client, projectDir, app_id, aliases) {
-  for (const alias of aliases) {
-    const file2 = workflowFilePath(projectDir, alias);
-    if (!fs4.existsSync(file2)) continue;
-    const body = stripWorkflowHeader(fs4.readFileSync(file2, "utf-8"));
-    if (body.trim() === "") continue;
-    const envelope = await fetchWorkflowGlobals(client, projectDir, app_id, alias);
-    writeWorkflowFile(projectDir, alias, body, envelope);
-    console.error(`Refreshed ${path5.relative(projectDir, file2)} + its workflow types`);
+async function refreshWorkflowGlobals(client, projectDir, app_id, workflows) {
+  for (const [alias, declaration] of Object.entries(workflows)) {
+    const refreshed = await refreshWorkflowTypes(
+      client,
+      projectDir,
+      app_id,
+      alias,
+      toWorkflowDtsDeclaration(declaration)
+    );
+    if (refreshed) console.error(`Refreshed workflow types for ${alias}`);
   }
 }
+async function refreshWorkflowTypes(client, projectDir, app_id, alias, declaration) {
+  const file2 = workflowFilePath(projectDir, alias);
+  if (!fs4.existsSync(file2)) return false;
+  const body = stripWorkflowHeader(fs4.readFileSync(file2, "utf-8"));
+  if (body.trim() === "") return false;
+  const envelope = await fetchWorkflowGlobals(client, projectDir, app_id, alias, declaration);
+  writeWorkflowFile(projectDir, alias, body, envelope);
+  return true;
+}
 function stampPulledManifest(projectDir, args) {
   writeAppMeta(projectDir, {
     app_id: args.app_id,
@@ -33380,9 +33516,9 @@ async function appPull(client, args) {
     queries: app.queries ?? {},
     agents: app.agents ?? {}
   });
-  const aliases = Object.keys(app.workflows ?? {});
-  if (aliases.length > 0) {
-    const written = await writeWorkflowFiles(client, targetPath, app.id, aliases);
+  const workflows = app.workflows ?? {};
+  if (Object.keys(workflows).length > 0) {
+    const written = await writeWorkflowFiles(client, targetPath, app.id, workflows);
     if (written.length > 0) {
       console.error(
         `Wrote ${written.length} workflow ${written.length === 1 ? "body" : "bodies"} to ${WORKFLOWS_DIR}/ (${written.join(", ")})`
@@ -33660,6 +33796,96 @@ async function appExecuteWorkflow(client, args) {
   }
   if (status === "error" || cleanupFailed) process.exit(1);
 }
+async function streamAgentTextDeltas(body, onText) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let accumulated = "";
+  try {
+    for (; ; ) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const frames = buffer.split("\n\n");
+      buffer = frames.pop() ?? "";
+      for (const frame of frames) {
+        for (const line of frame.split("\n")) {
+          if (!line.startsWith("data:")) continue;
+          const payload = line.slice(5).trim();
+          if (!payload || payload === "[DONE]") continue;
+          let chunk;
+          try {
+            chunk = JSON.parse(payload);
+          } catch {
+            continue;
+          }
+          if (chunk.type === "text-delta" && chunk.delta) {
+            accumulated += chunk.delta;
+            onText(chunk.delta);
+          }
+        }
+      }
+    }
+  } catch {
+  } finally {
+    reader.releaseLock();
+  }
+  return accumulated;
+}
+var AGENT_RUN_POLL = {
+  intervalMs: 1e3,
+  settleTimeoutMs: 21 * 60 * 1e3,
+  existenceTimeoutMs: 5e3
+};
+var sleep = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
+async function fetchSettledAgentRun(client, appId, sessionId, runId, timing) {
+  const settleDeadline = Date.now() + timing.settleTimeoutMs;
+  const existenceDeadline = Date.now() + timing.existenceTimeoutMs;
+  for (; ; ) {
+    const { runs } = await client.listAgentRuns(appId, sessionId);
+    const target = runId ? runs.find((r) => r.id === runId) : runs[runs.length - 1];
+    if (target) {
+      if (target.status !== "running" || Date.now() >= settleDeadline) return target;
+    } else if (Date.now() >= existenceDeadline) {
+      return void 0;
+    }
+    await sleep(timing.intervalMs);
+  }
+}
+async function appAgentRun(client, args, timing = AGENT_RUN_POLL) {
+  const sessionId = args.sessionId ?? `cli-${randomUUID()}`;
+  const continuing = args.sessionId !== void 0;
+  const res = await client.appAgentRunStream(args.app_id, args.alias, {
+    session_id: sessionId,
+    input: args.input
+  });
+  const runId = res.headers.get("x-app-agent-run-id") ?? void 0;
+  if (res.body) {
+    await streamAgentTextDeltas(res.body, (piece) => process.stderr.write(piece));
+  }
+  const run = await fetchSettledAgentRun(client, args.app_id, sessionId, runId, timing);
+  if (!run) {
+    console.error(`
+Could not find the settled run for session ${sessionId} on ${args.app_id}.`);
+    console.error("The run may still be in progress \u2014 re-check with `lotics run` against the app's agent-runs.");
+    process.exit(1);
+  }
+  if (args.json) {
+    console.log(JSON.stringify(run, null, 2));
+  } else if (run.output !== null && typeof run.output === "object") {
+    console.log(JSON.stringify(run.output, null, 2));
+  } else if (typeof run.output === "string") {
+    console.log(run.output);
+  }
+  console.error(
+    `
+Agent "${args.alias}" run ${run.id} \u2192 ${run.status}${run.error_message ? `: ${run.error_message}` : ""}`
+  );
+  console.error(
+    continuing ? `Session: ${sessionId}` : `Session: ${sessionId}  (fresh \u2014 pass --session ${sessionId} to continue this thread)`
+  );
+  if (run.status !== "completed") process.exit(1);
+}
 async function appWorkflowSet(client, args) {
   const projectDir = process.cwd();
   const meta3 = readAppMeta(projectDir);
@@ -33694,8 +33920,19 @@ async function appWorkflowSet(client, args) {
   const result = res.result ?? {};
   const workflowId = typeof result.workflow_id === "string" ? result.workflow_id : "(unknown)";
   console.error(`Set workflow "${args.alias}" \u2192 ${workflowId}`);
-  if (result.outputs && typeof result.outputs === "object") {
-    console.error(`  result.data schema: ${JSON.stringify(result.outputs)}`);
+  const derivedOutputs = result.outputs !== null && typeof result.outputs === "object" && !Array.isArray(result.outputs) ? result.outputs : null;
+  if (!declaration.outputs && derivedOutputs && Object.keys(derivedOutputs).length > 0) {
+    writeWorkflowOutputs(projectDir, args.alias, derivedOutputs);
+    console.error(
+      `  Wrote the derived result.data schema into package.json#lotics.workflows.${args.alias}.outputs.`
+    );
+    const refreshed = await refreshWorkflowTypes(client, projectDir, meta3.app_id, args.alias, {
+      inputs: declaration.inputs,
+      outputs: derivedOutputs
+    });
+    if (refreshed) console.error(`  Refreshed workflow types for ${args.alias}.`);
+  } else if (derivedOutputs) {
+    console.error(`  result.data schema: ${JSON.stringify(derivedOutputs)}`);
   }
 }
 async function appQuerySet(client, args) {
@@ -33721,12 +33958,12 @@ async function appWorkflowPull(client) {
   const projectDir = process.cwd();
   const meta3 = readAppMeta(projectDir);
   const app = await client.getApp(meta3.app_id);
-  const aliases = Object.keys(app.workflows ?? {});
-  if (aliases.length === 0) {
+  const workflows = app.workflows ?? {};
+  if (Object.keys(workflows).length === 0) {
     console.error(`App ${meta3.app_id} has no bound workflows.`);
     return;
   }
-  const written = await writeWorkflowFiles(client, projectDir, meta3.app_id, aliases);
+  const written = await writeWorkflowFiles(client, projectDir, meta3.app_id, workflows);
   console.error(
     `Wrote ${written.length} workflow ${written.length === 1 ? "body" : "bodies"} to ${WORKFLOWS_DIR}/` + (written.length > 0 ? ` (${written.join(", ")})` : "")
   );
@@ -33891,6 +34128,7 @@ function parseArgs(argv) {
     content: void 0,
     timezone: void 0,
     message: void 0,
+    session: void 0,
     local: false,
     all: false,
     yes: false,
@@ -33952,6 +34190,9 @@ function parseArgs(argv) {
       case "--message":
         flags.message = argv[++i2];
         break;
+      case "--session":
+        flags.session = argv[++i2];
+        break;
       case "--local":
         flags.local = true;
         break;
@@ -34022,6 +34263,36 @@ async function ingestJsonArgs(opts) {
   }
 }
 
+// src/org_commands.ts
+function printWorkspaceList(workspaces, currentId) {
+  for (const ws of workspaces) {
+    const marker = ws.id === currentId ? " (current)" : "";
+    console.error(`  ${ws.id}  ${ws.name}  ${ws.timezone}  ${ws.default_currency}${marker}`);
+  }
+}
+async function validateOrgWorkspacePin(client, orgId, profile) {
+  const pinned = profile.workspace_id;
+  if (!pinned) return;
+  let workspaces;
+  try {
+    workspaces = await client.listWorkspaces();
+  } catch (error51) {
+    const message = error51 instanceof Error ? error51.message : String(error51);
+    console.error(`Could not validate the pinned workspace (${message}) \u2014 keeping ${pinned}.`);
+    return;
+  }
+  if (workspaces.some((w) => w.id === pinned)) return;
+  clearProfileWorkspace(orgId);
+  console.error(`Pinned workspace ${pinned} is no longer in ${profile.org_name} \u2014 cleared the stale pin.`);
+  if (workspaces.length === 0) {
+    console.error("This organization has no workspaces yet.");
+    return;
+  }
+  console.error("Select one with:\n");
+  console.error("  lotics workspace select <id>\n");
+  printWorkspaceList(workspaces);
+}
+
 // src/xlsx.ts
 import fs6 from "node:fs";
 
@@ -47171,13 +47442,50 @@ function unmergeCellsCommand(workbook, sheetIndex, mergeRef) {
     }
   };
 }
+function isInertCell(cell) {
+  return (cell.value === null || cell.value === "") && cell.formula === void 0 && cell.styleIndex === 0 && (cell.originalXfIndex === void 0 || cell.originalXfIndex === 0) && (cell.numFmtCode === "General" || cell.numFmtCode === "") && cell.richText === void 0 && cell.error === void 0 && cell.content.type === "plain" && cell.content.text === "";
+}
+function clampInertCells(sheet) {
+  let minRow = Infinity;
+  let maxRow = 0;
+  let minCol = Infinity;
+  let maxCol = 0;
+  let hasMeaningful = false;
+  for (const [ref, cell] of sheet.cells) {
+    if (isInertCell(cell)) continue;
+    const rc = refToRowColSafe(ref);
+    if (!rc) continue;
+    hasMeaningful = true;
+    if (rc.row < minRow) minRow = rc.row;
+    if (rc.row > maxRow) maxRow = rc.row;
+    if (rc.col < minCol) minCol = rc.col;
+    if (rc.col > maxCol) maxCol = rc.col;
+  }
+  const pruned = /* @__PURE__ */ new Map();
+  for (const [ref, cell] of sheet.cells) {
+    if (!isInertCell(cell)) continue;
+    if (!hasMeaningful) {
+      pruned.set(ref, cell);
+      continue;
+    }
+    const rc = refToRowColSafe(ref);
+    if (!rc) continue;
+    if (rc.row < minRow || rc.row > maxRow || rc.col < minCol || rc.col > maxCol) {
+      pruned.set(ref, cell);
+    }
+  }
+  for (const ref of pruned.keys()) sheet.cells.delete(ref);
+  return pruned;
+}
 function insertRowsCommand(workbook, sheetIndex, at, count) {
   const sheet = workbook.sheets[sheetIndex];
   let mergeSnapshot = [];
+  let inertSnapshot = /* @__PURE__ */ new Map();
   return {
     description: `Insert ${count} row${count > 1 ? "s" : ""} at ${at}`,
     execute() {
       mergeSnapshot = [...sheet.mergedCells];
+      inertSnapshot = clampInertCells(sheet);
       const toMove = [];
       for (const [ref] of sheet.cells) {
         const rc = refToRowColSafe(ref);
@@ -47221,6 +47529,7 @@ function insertRowsCommand(workbook, sheetIndex, at, count) {
         sheet.rowHeights.set(r - count, h);
       }
       for (let r = at; r < at + count; r++) sheet.rowHeights.delete(r);
+      for (const [ref, cell] of inertSnapshot) sheet.cells.set(ref, cell);
       workbook.emit({ type: "rows_deleted", sheet: sheetIndex, at, count });
     }
   };
@@ -47235,10 +47544,12 @@ function deleteRowsCommand(workbook, sheetIndex, at, count) {
     }
   }
   let mergeSnapshot = [];
+  let inertSnapshot = /* @__PURE__ */ new Map();
   return {
     description: `Delete ${count} row${count > 1 ? "s" : ""} at ${at}`,
     execute() {
       mergeSnapshot = [...sheet.mergedCells];
+      inertSnapshot = clampInertCells(sheet);
       for (const ref of snapshot.keys()) sheet.cells.delete(ref);
       const toMove = [];
       for (const [ref] of sheet.cells) {
@@ -47271,6 +47582,7 @@ function deleteRowsCommand(workbook, sheetIndex, at, count) {
       for (const [ref, snap] of snapshot) {
         sheet.set(ref, snap.value, sheet.styles?.get(snap.styleIndex), snap.numFmtCode, snap.formula);
       }
+      for (const [ref, cell] of inertSnapshot) sheet.cells.set(ref, cell);
       workbook.emit({ type: "rows_inserted", sheet: sheetIndex, at, count });
     }
   };
@@ -47278,10 +47590,12 @@ function deleteRowsCommand(workbook, sheetIndex, at, count) {
 function insertColsCommand(workbook, sheetIndex, at, count) {
   const sheet = workbook.sheets[sheetIndex];
   let mergeSnapshot = [];
+  let inertSnapshot = /* @__PURE__ */ new Map();
   return {
     description: `Insert ${count} column${count > 1 ? "s" : ""} at ${at}`,
     execute() {
       mergeSnapshot = [...sheet.mergedCells];
+      inertSnapshot = clampInertCells(sheet);
       const toMove = [];
       for (const [ref] of sheet.cells) {
         const rc = refToRowColSafe(ref);
@@ -47325,6 +47639,7 @@ function insertColsCommand(workbook, sheetIndex, at, count) {
         sheet.colWidths.set(c - count, w);
       }
       for (let c = at; c < at + count; c++) sheet.colWidths.delete(c);
+      for (const [ref, cell] of inertSnapshot) sheet.cells.set(ref, cell);
       workbook.emit({ type: "cols_deleted", sheet: sheetIndex, at, count });
     }
   };
@@ -47339,10 +47654,12 @@ function deleteColsCommand(workbook, sheetIndex, at, count) {
     }
   }
   let mergeSnapshot = [];
+  let inertSnapshot = /* @__PURE__ */ new Map();
   return {
     description: `Delete ${count} column${count > 1 ? "s" : ""} at ${at}`,
     execute() {
       mergeSnapshot = [...sheet.mergedCells];
+      inertSnapshot = clampInertCells(sheet);
       for (const ref of snapshot.keys()) sheet.cells.delete(ref);
       const toMove = [];
       for (const [ref] of sheet.cells) {
@@ -47375,6 +47692,7 @@ function deleteColsCommand(workbook, sheetIndex, at, count) {
       for (const [ref, snap] of snapshot) {
         sheet.set(ref, snap.value, sheet.styles?.get(snap.styleIndex), snap.numFmtCode, snap.formula);
       }
+      for (const [ref, cell] of inertSnapshot) sheet.cells.set(ref, cell);
       workbook.emit({ type: "cols_inserted", sheet: sheetIndex, at, count });
     }
   };
@@ -47597,26 +47915,37 @@ function lazyEngine(workbook) {
     }
   };
 }
-function readToJson(filePath) {
+function readToJson(filePath, filter2) {
   const buffer = fs6.readFileSync(filePath);
   const arrayBuffer = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
   const parsed = parseExcelBuffer(arrayBuffer);
+  let sheets = parsed.sheets;
+  if (filter2?.sheet !== void 0) {
+    const match = sheets.filter((s) => s.name === filter2.sheet);
+    if (match.length === 0) {
+      const names = parsed.sheets.map((s) => `"${s.name}"`).join(", ");
+      fail(`Sheet not found: "${filter2.sheet}". Available: ${names}`);
+    }
+    sheets = match;
+  }
   return {
     activeSheetIndex: parsed.activeSheetIndex,
-    sheets: parsed.sheets.map((s) => ({
+    sheets: sheets.map((s) => ({
       name: s.name,
       totalRowCount: s.totalRowCount,
       truncated: s.truncated,
-      cells: cellsFromParsedRows(s.rows),
+      cells: cellsFromParsedRows(s.rows, filter2?.range),
       merges: s.mergedCells.map((m) => `${rowColToRef(m.startRow, m.startCol)}:${rowColToRef(m.endRow, m.endCol)}`),
       freeze: s.freezePane ? { row: s.freezePane.frozenRows, col: s.freezePane.frozenCols } : void 0
     }))
   };
 }
-function cellsFromParsedRows(rows) {
+function cellsFromParsedRows(rows, range) {
   const out = {};
   for (const row of rows) {
+    if (range && (row.index < range.startRow || row.index > range.endRow)) continue;
     for (const cell of row.cells) {
+      if (range && (cell.column < range.startCol || cell.column > range.endCol)) continue;
       const ref = rowColToRef(row.index, cell.column);
       const value = cell.typedValue ?? cell.value;
       const entry = { value };
@@ -47688,9 +48017,34 @@ function valueToInput(value) {
   if (value === null || value === void 0) return "";
   return String(value);
 }
-function xlsxRead(filePath) {
-  if (!filePath) fail("Usage: lotics xlsx read <file>");
-  const data = readToJson(filePath);
+function readOptionFlag(rest, name) {
+  const i2 = rest.indexOf(name);
+  if (i2 < 0) return void 0;
+  const val = rest[i2 + 1];
+  if (val === void 0 || val.startsWith("--")) fail(`Missing value for ${name}`);
+  return val;
+}
+function splitOptionalSheetRef(spec) {
+  const idx = spec.indexOf("!");
+  if (idx < 0) return { sheet: void 0, ref: spec };
+  return { sheet: spec.slice(0, idx), ref: spec.slice(idx + 1) };
+}
+function xlsxRead(filePath, rest) {
+  if (!filePath) fail("Usage: lotics xlsx read <file> [--sheet <name>] [--range <sheet>!<A1:G60>]");
+  const rangeArg = readOptionFlag(rest, "--range");
+  const sheetArg = readOptionFlag(rest, "--sheet");
+  let filter2;
+  if (rangeArg !== void 0) {
+    const { sheet, ref } = splitOptionalSheetRef(rangeArg);
+    const targetSheet = sheet ?? sheetArg;
+    if (targetSheet === void 0) {
+      fail("--range without a <sheet>! prefix requires --sheet <name>");
+    }
+    filter2 = { sheet: targetSheet, range: parseRange2(ref) };
+  } else if (sheetArg !== void 0) {
+    filter2 = { sheet: sheetArg };
+  }
+  const data = readToJson(filePath, filter2);
   console.log(JSON.stringify(data, null, 2));
 }
 function xlsxWrite(filePath, json2) {
@@ -47927,7 +48281,10 @@ function printXlsxHelp() {
   console.error(`Lotics xlsx commands \u2014 manipulate .xlsx files in place.
 Uses Lotics' own xlsx engine; round-trips faithfully with the Lotics editor and templates.
 
-  lotics xlsx read <file>                          Dump file as JSON (sheets, cells, merges, freeze)
+  lotics xlsx read <file> [--sheet <name>] [--range <sheet>!<A1:G60>]
+                                                   Dump file as JSON (sheets, cells, merges, freeze).
+                                                   --sheet limits to one sheet; --range to a cell window
+                                                   (its <sheet>! prefix is optional when --sheet is given)
   lotics xlsx write <file> '<json>'                Create .xlsx from {"sheets":[{"name","cells":{"A1":...}}]}
   lotics xlsx set-cell <file> <sheet>!<ref> '<v>'  Set cell value (prefix '=' for formula)
   lotics xlsx clear-range <file> <sheet>!<range>   Clear all cells in a range
@@ -47949,7 +48306,7 @@ Edit ops mutate the file atomically (temp file + rename).`);
 async function runXlsxCommand(subcommand, toolArgs, restArgs) {
   switch (subcommand) {
     case "read":
-      return xlsxRead(toolArgs);
+      return xlsxRead(toolArgs, restArgs);
     case "write":
       return xlsxWrite(toolArgs, restArgs[0]);
     case "set-cell":
@@ -67999,7 +68356,7 @@ import { readFileSync as readFileSync2, writeFileSync, existsSync, mkdtempSync,
 import { tmpdir as tmpdir2 } from "node:os";
 import { join, dirname, resolve, extname, basename } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { setTimeout as sleep } from "node:timers/promises";
+import { setTimeout as sleep2 } from "node:timers/promises";
 var HERE = dirname(fileURLToPath2(import.meta.url));
 function fail2(msg) {
   console.error(msg);
@@ -68057,8 +68414,14 @@ async function cdpConnect(wsUrl) {
   });
   return { send, close: () => ws.close() };
 }
+function isStoredFileId(target) {
+  return /^fil_[A-Za-z0-9]+$/.test(target);
+}
+function defaultPreviewOutputPath(filename, cwd) {
+  return join(cwd, basename(filename, extname(filename)) + ".png");
+}
 async function runPreviewCommand(filePath, flags) {
-  if (!filePath) fail2("Usage: lotics preview <file.docx|.xlsx> [--out <file.png>]");
+  if (!filePath) fail2("Usage: lotics preview <file.docx|.xlsx | fil_id> [-o <file.png>]");
   const abs = resolve(filePath);
   if (!existsSync(abs)) fail2(`File not found: ${abs}`);
   const ext = extname(abs).toLowerCase();
@@ -68125,7 +68488,7 @@ async function runPreviewCommand(filePath, flags) {
         const p = parseInt(readFileSync2(portFile, "utf8").split("\n")[0], 10);
         if (p) cdpPort = p;
       }
-      if (!cdpPort) await sleep(100);
+      if (!cdpPort) await sleep2(100);
     }
     if (!cdpPort) throw new Error("Chrome did not expose a debugging port (launch failed?).");
     let target;
@@ -68135,7 +68498,7 @@ async function runPreviewCommand(filePath, flags) {
         target = list.find((t) => t.type === "page");
       } catch {
       }
-      if (!target?.webSocketDebuggerUrl) await sleep(100);
+      if (!target?.webSocketDebuggerUrl) await sleep2(100);
     }
     if (!target?.webSocketDebuggerUrl) throw new Error("No Chrome page target available.");
     const cdp = await cdpConnect(target.webSocketDebuggerUrl);
@@ -68157,7 +68520,7 @@ async function runPreviewCommand(filePath, flags) {
         if (v.warnings?.length) warnings.push(...v.warnings);
         break;
       }
-      await sleep(75);
+      await sleep2(75);
     }
     if (!done) throw new Error("Render timed out (page never signaled completion).");
     if (err2) throw new Error(`Render engine error: ${err2}`);
@@ -68260,6 +68623,10 @@ COMMANDS
   lotics app query set <alias>         Push package.json#lotics.queries.<alias> to
                                        apps.queries via set_app_query (no deploy;
                                        re-synced by the next deploy from the manifest)
+  lotics app agent run <app_id> <alias> '<json>'  Run a bound app agent end-to-end
+                                       (inputs: inline JSON, @file, or stdin; streams
+                                        progress to stderr, reports the settled run;
+                                        --session <id> continues a thread; --json)
   lotics app subdomain <new-subdomain> Rename the app's public <slug>.lotics.app address
   lotics app rename "<new name>"       Rename the app's display name (launcher title)
   lotics app dev [path]                Run the app locally with HMR (RPC forwarded to prod)
@@ -68287,8 +68654,10 @@ COMMANDS
   lotics file download <file_id>       Download a file by ID (alias: lotics download)
   lotics file download record <record_id> <field_key>
                                        Download all files on a record file field
-  lotics file preview <file> [-o png]  Render a .docx/.xlsx to a PNG (frontend engines;
-                                       needs a Chrome/Chromium on the machine)
+  lotics file preview <file|fil_id> [-o png]
+                                       Render a .docx/.xlsx to a PNG \u2014 a local path OR a
+                                       stored file id (downloaded first). Frontend engines;
+                                       needs a Chrome/Chromium on the machine
 
 FLAGS
   --json             Full JSON output (default is human-readable text)
@@ -68495,12 +68864,6 @@ var SOURCE_LABELS = {
   local_pointer: "local .lotics/config.json (pin)",
   global_profile: "global active profile"
 };
-function printWorkspaceList(workspaces, currentId) {
-  for (const ws of workspaces) {
-    const marker = ws.id === currentId ? " (current)" : "";
-    console.error(`  ${ws.id}  ${ws.name}  ${ws.timezone}  ${ws.default_currency}${marker}`);
-  }
-}
 async function resolveWorkspace(client, ctx) {
   if (ctx.workspaceId) {
     client.setWorkspaceId(ctx.workspaceId);
@@ -68654,6 +69017,18 @@ async function main() {
     return;
   }
   if (command === "preview") {
+    if (subcommand && isStoredFileId(subcommand)) {
+      const { client: client2 } = requireClient(flags);
+      const tmpDir = fs9.mkdtempSync(path7.join(os2.tmpdir(), "lotics-preview-"));
+      try {
+        const { path: localPath, filename } = await client2.downloadFileById(subcommand, tmpDir);
+        const output = flags.output ?? defaultPreviewOutputPath(filename, process.cwd());
+        await runPreviewCommand(localPath, { output });
+      } finally {
+        fs9.rmSync(tmpDir, { recursive: true, force: true });
+      }
+      return;
+    }
     await runPreviewCommand(subcommand, flags);
     return;
   }
@@ -68715,6 +69090,7 @@ async function main() {
           console.error("Note: a local pin (.lotics/config.json) overrides the global default in this directory. Use --local to change the pin here.");
         }
       }
+      await validateOrgWorkspacePin(new LoticsClient({ apiKey: profile.api_key }), orgId, profile);
       return;
     }
     if (subcommand && subcommand !== "list") {
@@ -68764,6 +69140,7 @@ async function main() {
     console.error("  lotics app workflow pull                  Rewrite src/workflows/*.ts from the server");
     console.error("  lotics app workflow check [alias]         Typecheck src/workflows bodies locally");
     console.error("  lotics app query set <alias>              Push lotics.queries.<alias> to apps.queries (no deploy)");
+    console.error("  lotics app agent run <app_id> <alias> '<json>'  Run a bound app agent (streams progress, reports the settled run)");
     console.error("  lotics app subdomain <new-subdomain> Rename the app's public <slug>.lotics.app address");
     console.error(`  lotics app rename "<new name>"        Rename the app's display name (launcher title)`);
     console.error("  lotics app dev [path]                Run the app locally with HMR + RPC forwarding");
@@ -69022,6 +69399,42 @@ Available workspaces:`);
       }
       workflowUsage();
     }
+    if (subcommand === "agent") {
+      const action = toolArgs;
+      const agentUsage = () => {
+        console.error("Usage: lotics app agent run <app_id> <alias> ['<json>'|@inputs.json|stdin] [--session <id>] [--json]");
+        console.error("       cat inputs.json | lotics app agent run <app_id> <alias>   (read inputs from stdin)");
+        console.error("Streams the run's progress to stderr; reports the settled run (structured output / text) to stdout.");
+        console.error("--session <id> continues an existing thread; omitted mints a fresh session per run.");
+        process.exit(1);
+      };
+      if (action === "run") {
+        const appId = restArgs[0];
+        const alias = restArgs[1];
+        if (!appId || !alias) {
+          agentUsage();
+        }
+        const ingested = await ingestJsonArgs({
+          rawArg: restArgs[2],
+          stdinIsTTY: process.stdin.isTTY ?? false,
+          readFile: (p) => fs9.readFileSync(p, "utf-8"),
+          readStdin
+        });
+        if (ingested.kind === "error") {
+          console.error(ingested.message);
+          process.exit(1);
+        }
+        await appAgentRun(client, {
+          app_id: appId,
+          alias,
+          input: ingested.args,
+          sessionId: flags.session,
+          json: flags.json
+        });
+        return;
+      }
+      agentUsage();
+    }
     if (subcommand === "query") {
       const action = toolArgs;
       if (action === "set") {

package/dist/src/client.d.ts

@@ -50,6 +50,31 @@ export interface ToolExecuteResult {
     model_output?: string;
     error?: string;
 }
+/**
+ * A settled (or in-flight) app-agent run, the transcript-excluded projection
+ * `GET /v1/apps/{app_id}/agent-runs` returns. `output` is the STRUCTURED result
+ * for a typed agent (an object) or the final text for a free-text agent (a
+ * string); `status` is `running` until the run settles to `completed` / `error`
+ * / `aborted`. The authoritative record `lotics app agent run` reports from
+ * (never the stream).
+ */
+export interface AppAgentRunSummary {
+    id: string;
+    app_id: string;
+    agent_alias: string;
+    session_id: string;
+    status: string;
+    input: Record<string, unknown> | null;
+    output: string | Record<string, unknown> | null;
+    usage: {
+        input_tokens: number;
+        output_tokens: number;
+    } | null;
+    error_message: string | null;
+    triggered_by_member_id: string | null;
+    started_at: string;
+    completed_at: string | null;
+}
 export interface ToolInfo {
     name: string;
     description: string;
@@ -858,8 +883,17 @@ export declare class LoticsClient {
      * `async function __workflow(): …` wrapper the server compiles inside, so the
      * local typecheck mirrors the set-time verdict. Mirrors
      * POST /v1/apps/{app_id}/workflows/{alias}/dts.
+     *
+     * `declaration` (the manifest's `{ inputs?, outputs? }`) is posted as the body
+     * `{ declaration }` ONLY when the alias isn't `set` on the server yet — the
+     * server then synthesizes the dts from the declared schemas instead of 400ing
+     * "no workflow alias". A registered alias needs no declaration (the server's
+     * own bound contract wins), so the field is omitted in that case.
      */
-    getAppWorkflowDts(app_id: string, alias: string): Promise<{
+    getAppWorkflowDts(app_id: string, alias: string, declaration?: {
+        inputs?: Record<string, unknown>;
+        outputs?: Record<string, unknown>;
+    }): Promise<{
         dts: string;
         envelope_prefix: string;
         envelope_suffix: string;
@@ -874,6 +908,25 @@ export declare class LoticsClient {
         session_id: string;
         input: Record<string, unknown>;
     }, signal?: AbortSignal): Promise<Response>;
+    /**
+     * Continue a PARKED (`awaiting_input`) agent run with the user's answer to its
+     * pending `ask_user_choice` — returns the RAW streamed continuation `Response`,
+     * exactly like `appAgentRunStream`. Mirrors
+     * POST /v1/apps/{app_id}/agent-runs/{run_id}/continue.
+     */
+    appAgentRunContinueStream(app_id: string, run_id: string, body: {
+        tool_call_id: string;
+        output: Record<string, unknown>;
+    }, signal?: AbortSignal): Promise<Response>;
+    /**
+     * A session's app-agent run history, oldest-first (the run just started is the
+     * last, and its exact id is on the stream response's `x-app-agent-run-id`
+     * header). Transcript excluded; structured `output`/`input` included. Mirrors
+     * GET /v1/apps/{app_id}/agent-runs.
+     */
+    listAgentRuns(app_id: string, session_id: string): Promise<{
+        runs: AppAgentRunSummary[];
+    }>;
     /**
      * Mint a presigned URL for uploading a file into an app. Mirrors
      * POST /v1/apps/{app_id}/files/upload-url.

package/dist/src/client.js

@@ -608,9 +608,15 @@ export class LoticsClient {
      * `async function __workflow(): …` wrapper the server compiles inside, so the
      * local typecheck mirrors the set-time verdict. Mirrors
      * POST /v1/apps/{app_id}/workflows/{alias}/dts.
+     *
+     * `declaration` (the manifest's `{ inputs?, outputs? }`) is posted as the body
+     * `{ declaration }` ONLY when the alias isn't `set` on the server yet — the
+     * server then synthesizes the dts from the declared schemas instead of 400ing
+     * "no workflow alias". A registered alias needs no declaration (the server's
+     * own bound contract wins), so the field is omitted in that case.
      */
-    async getAppWorkflowDts(app_id, alias) {
-        return this.request("POST", `/v1/apps/${encodeURIComponent(app_id)}/workflows/${encodeURIComponent(alias)}/dts`);
+    async getAppWorkflowDts(app_id, alias, declaration) {
+        return this.request("POST", `/v1/apps/${encodeURIComponent(app_id)}/workflows/${encodeURIComponent(alias)}/dts`, declaration ? { declaration } : undefined);
     }
     /**
      * Open a streaming agent run and return the RAW streamed `Response` (the
@@ -629,6 +635,32 @@ export class LoticsClient {
             await this.throwResponseError(res);
         return res;
     }
+    /**
+     * Continue a PARKED (`awaiting_input`) agent run with the user's answer to its
+     * pending `ask_user_choice` — returns the RAW streamed continuation `Response`,
+     * exactly like `appAgentRunStream`. Mirrors
+     * POST /v1/apps/{app_id}/agent-runs/{run_id}/continue.
+     */
+    async appAgentRunContinueStream(app_id, run_id, body, signal) {
+        const res = await fetch(`${this.baseUrl}/v1/apps/${encodeURIComponent(app_id)}/agent-runs/${encodeURIComponent(run_id)}/continue`, {
+            method: "POST",
+            headers: { ...this.buildHeaders(), "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+            signal,
+        });
+        if (!res.ok)
+            await this.throwResponseError(res);
+        return res;
+    }
+    /**
+     * A session's app-agent run history, oldest-first (the run just started is the
+     * last, and its exact id is on the stream response's `x-app-agent-run-id`
+     * header). Transcript excluded; structured `output`/`input` included. Mirrors
+     * GET /v1/apps/{app_id}/agent-runs.
+     */
+    async listAgentRuns(app_id, session_id) {
+        return this.request("GET", `/v1/apps/${encodeURIComponent(app_id)}/agent-runs?session_id=${encodeURIComponent(session_id)}`);
+    }
     /**
      * Mint a presigned URL for uploading a file into an app. Mirrors
      * POST /v1/apps/{app_id}/files/upload-url.

package/package.json

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