@lotics/cli 0.112.0 → 0.114.0

package/README.md

@@ -156,12 +156,15 @@ The CLI bundles Lotics's own xlsx and docx engines so you can read, write, and e
 ```bash
 # .xlsx
 lotics xlsx read ./report.xlsx                                  # → JSON of sheets, cells, merges
+lotics xlsx read ./report.xlsx --with-format                    # …plus each cell's resolved style
 lotics xlsx write ./out.xlsx '{"sheets":[{"name":"S1","cells":{"A1":"Hi","B1":42}}]}'
 # A cell is a bare value, or an object with numFmt / style / formula:
-lotics xlsx write ./out.xlsx '{"sheets":[{"name":"S1","cells":{
-  "A1":{"value":"Tổng","style":{"fontBold":true}},
-  "B1":{"value":1234567,"numFmt":"#,##0"},
-  "B2":{"formula":"B1*0.1","numFmt":"#,##0"}}}]}'   # unknown cell keys are rejected, not ignored
+lotics xlsx write ./out.xlsx '{"sheets":[{"name":"S1",
+  "colWidths":{"A":34,"B":14}, "rowHeights":{"1":28},
+  "cells":{
+    "A1":{"value":"Tổng","style":{"fontBold":true}},
+    "B1":{"value":1234567,"numFmt":"#,##0"},
+    "B2":{"formula":"B1*0.1","numFmt":"#,##0"}}}]}'  # unknown keys are rejected, not ignored
 lotics xlsx set-cell ./report.xlsx 'Sheet1!A1' '=SUM(B:B)'
 lotics xlsx add-sheet ./report.xlsx 'Summary'
 lotics xlsx merge ./report.xlsx 'Sheet1!A1:C1'

package/dist/src/cli.js

@@ -33334,8 +33334,8 @@ var require_utils2 = __commonJS({
     var { Address } = require_helpers();
     var { Prefix, Postfix, Infix, Operators } = require_operators();
     var Collection = require_collection();
-    var MAX_ROW = 1048576;
-    var MAX_COLUMN = 16384;
+    var MAX_ROW2 = 1048576;
+    var MAX_COLUMN2 = 16384;
     var { NotAllInputParsedException } = require_api();
     var Utils = class {
       constructor(context) {
@@ -33564,7 +33564,7 @@ var require_utils2 = __commonJS({
        // * @return {{ref: {from: {col: number, row: number}, to: {col: number, row: number}}}}
        */
       applyRange(refs) {
-        let res, maxRow = -1, maxCol = -1, minRow = MAX_ROW + 1, minCol = MAX_COLUMN + 1;
+        let res, maxRow = -1, maxCol = -1, minRow = MAX_ROW2 + 1, minCol = MAX_COLUMN2 + 1;
         refs.forEach((ref2) => {
           if (this.isFormulaError(ref2))
             return ref2;
@@ -33574,11 +33574,11 @@ var require_utils2 = __commonJS({
           ref2 = ref2.ref;
           if (ref2.row === void 0) {
             minRow = 1;
-            maxRow = MAX_ROW;
+            maxRow = MAX_ROW2;
           }
           if (ref2.col === void 0) {
             minCol = 1;
-            maxCol = MAX_COLUMN;
+            maxCol = MAX_COLUMN2;
           }
           if (ref2.row > maxRow)
             maxRow = ref2.row;
@@ -34014,8 +34014,8 @@ var require_utils3 = __commonJS({
     var { FormulaHelpers, Types, Address } = require_helpers();
     var { Prefix, Postfix, Infix, Operators } = require_operators();
     var Collection = require_collection();
-    var MAX_ROW = 1048576;
-    var MAX_COLUMN = 16384;
+    var MAX_ROW2 = 1048576;
+    var MAX_COLUMN2 = 16384;
     var Utils = class {
       constructor(context) {
         this.context = context;
@@ -34161,7 +34161,7 @@ var require_utils3 = __commonJS({
        // * @return {{ref: {from: {col: number, row: number}, to: {col: number, row: number}}}}
        */
       applyRange(refs) {
-        let res, maxRow = -1, maxCol = -1, minRow = MAX_ROW + 1, minCol = MAX_COLUMN + 1;
+        let res, maxRow = -1, maxCol = -1, minRow = MAX_ROW2 + 1, minCol = MAX_COLUMN2 + 1;
         refs.forEach((ref2) => {
           if (this.isFormulaError(ref2))
             return ref2;
@@ -34171,11 +34171,11 @@ var require_utils3 = __commonJS({
           ref2 = ref2.ref;
           if (ref2.row === void 0) {
             minRow = 1;
-            maxRow = MAX_ROW;
+            maxRow = MAX_ROW2;
           }
           if (ref2.col === void 0) {
             minCol = 1;
-            maxCol = MAX_COLUMN;
+            maxCol = MAX_COLUMN2;
           }
           if (ref2.row > maxRow)
             maxRow = ref2.row;
@@ -44124,9 +44124,9 @@ var require_load = __commonJS({
 var require_lib4 = __commonJS({
   "../../node_modules/jszip/lib/index.js"(exports2, module2) {
     "use strict";
-    function JSZip4() {
-      if (!(this instanceof JSZip4)) {
-        return new JSZip4();
+    function JSZip5() {
+      if (!(this instanceof JSZip5)) {
+        return new JSZip5();
       }
       if (arguments.length) {
         throw new Error("The constructor with parameters has been removed in JSZip 3.0, please check the upgrade guide.");
@@ -44135,7 +44135,7 @@ var require_lib4 = __commonJS({
       this.comment = null;
       this.root = "";
       this.clone = function() {
-        var newObj = new JSZip4();
+        var newObj = new JSZip5();
         for (var i2 in this) {
           if (typeof this[i2] !== "function") {
             newObj[i2] = this[i2];
@@ -44144,16 +44144,16 @@ var require_lib4 = __commonJS({
         return newObj;
       };
     }
-    JSZip4.prototype = require_object();
-    JSZip4.prototype.loadAsync = require_load();
-    JSZip4.support = require_support();
-    JSZip4.defaults = require_defaults();
-    JSZip4.version = "3.10.1";
-    JSZip4.loadAsync = function(content, options) {
-      return new JSZip4().loadAsync(content, options);
+    JSZip5.prototype = require_object();
+    JSZip5.prototype.loadAsync = require_load();
+    JSZip5.support = require_support();
+    JSZip5.defaults = require_defaults();
+    JSZip5.version = "3.10.1";
+    JSZip5.loadAsync = function(content, options) {
+      return new JSZip5().loadAsync(content, options);
     };
-    JSZip4.external = require_external();
-    module2.exports = JSZip4;
+    JSZip5.external = require_external();
+    module2.exports = JSZip5;
   }
 });
 
@@ -64462,12 +64462,20 @@ var VALID_OPERATORS = {
 var VALID_FILTER_TYPES = Object.keys(VALID_OPERATORS);
 
 // ../shared/src/chat_models.ts
-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 MODEL_TIERS = ["haiku", "sonnet", "opus"];
+var TIER_MODELS = {
+  haiku: "claude-haiku-4-5",
+  sonnet: "claude-sonnet-5",
+  opus: "claude-opus-5"
+};
+var RESOLVED_MODEL_IDS = MODEL_TIERS.map(
+  (tier) => TIER_MODELS[tier]
+);
+var DEFAULT_MODEL_TIER = "sonnet";
+var UTILITY_MODEL_TIER = "haiku";
+var DEFAULT_MODEL_ID = TIER_MODELS[DEFAULT_MODEL_TIER];
+var PICKER_MODEL_TIERS = MODEL_TIERS.filter(
+  (tier) => tier !== UTILITY_MODEL_TIER
 );
 var EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
 
@@ -64927,11 +64935,11 @@ var appAgentDeclarationSchema = zod_default.object({
   workflow_aliases: zod_default.array(zod_default.string().min(1)).optional().describe(
     "Workflows from this app's manifest the agent may invoke via `run_app_workflow`, validated at declare time against the app's own workflows. This is the agent's ENTIRE write surface \u2014 the same declared mutation path the app's UI uses, so table hooks and side-effect harvesting apply. Omit for a read-only agent."
   ),
-  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."
+  model_tier: zod_default.enum(MODEL_TIERS).optional().describe(
+    "Model tier the agent runs on \u2014 `haiku`, `sonnet`, or `opus`. Omit to follow the platform default tier, resolved at run time: the preferred choice. A tier names capability, not a version, so the generation behind it moves with the platform and this declaration never needs a 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."
+    "Reasoning depth for adaptive-thinking tiers \u2014 one of the chosen tier's supported levels (validated against model_tier at declare time). Omit to use the model default; ignored on tiers without adaptive thinking."
   ),
   inputs: zod_default.record(zod_default.string(), appWorkflowInputSchema).optional().describe(
     "Typed input schema for one run. Keys are input names; values declare type + constraints. The server validates the run payload against this before invoking; CLI codegen emits a typed `useAgentRun<alias>` signature. Omit for an untyped payload."
@@ -65070,7 +65078,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).optional(),
+  model_tier: zod_default.enum(MODEL_TIERS).optional(),
   output: agentOutputSpecSchema
 });
 var breakStepSchema = stepBaseSchema.extend({
@@ -69683,8 +69691,6 @@ function walkAgentInvocation(call, scope, stepId, description) {
   const toolsNode = kw.get("tools");
   if (!toolsNode) fail(arg, "agent requires `tools` (use [] for none).");
   const tool_names = readStaticStringArray(toolsNode, "agent `tools`");
-  const modelNode = kw.get("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));
@@ -69692,6 +69698,19 @@ function walkAgentInvocation(call, scope, stepId, description) {
     const detail = outputResult.error.issues.map((i2) => `${i2.path.join(".") || "<root>"}: ${i2.message}`).join("; ");
     fail(outputNode, `Invalid agent \`output\`: ${detail}`);
   }
+  const modelNode = kw.get("model");
+  let model_tier;
+  if (modelNode) {
+    const literal2 = readStaticString(modelNode, "agent `model`");
+    const tier = MODEL_TIERS.includes(literal2) ? literal2 : null;
+    if (!tier) {
+      fail(
+        modelNode,
+        `Unknown agent \`model\` "${literal2}" \u2014 expected one of: ${MODEL_TIERS.join(", ")}.`
+      );
+    }
+    model_tier = tier;
+  }
   return {
     id: stepId,
     description: description ?? "agent",
@@ -69699,7 +69718,7 @@ function walkAgentInvocation(call, scope, stepId, description) {
     instructions,
     input,
     tool_names,
-    ...model_id !== void 0 ? { model_id } : {},
+    ...model_tier !== void 0 ? { model_tier } : {},
     output: outputResult.data
   };
 }
@@ -70239,7 +70258,7 @@ function agentFilePath2(projectDir, alias) {
 }
 var CLI_AGENT_NOTES = [
   "Pulled from the LIVE app row; edit here, then: lotics app agent set <alias>",
-  "The typed fields (inputs/outputs/tool_names/model_id) live in package.json#lotics.agents"
+  "The typed fields (inputs/outputs/tool_names/model_tier) live in package.json#lotics.agents"
 ];
 function writeAgentFile(projectDir, alias, instructions) {
   fs4.mkdirSync(path5.join(projectDir, AGENTS_DIR), { recursive: true });
@@ -71410,7 +71429,7 @@ async function appAgentSet(client, args) {
     process.exit(1);
   }
   console.error(
-    `Set agent "${args.alias}" (${instructions.length} chars of instructions` + (live.model_id ? `, ${live.model_id}` : "") + `). Typed fields left as they are.`
+    `Set agent "${args.alias}" (${instructions.length} chars of instructions` + (live.model_tier ? `, ${live.model_tier}` : "") + `). Typed fields left as they are.`
   );
 }
 async function appWorkflowSet(client, args) {
@@ -83163,6 +83182,8 @@ function buildSheetXml(sheet, styles, ssIndex, isActive, xfMap, numFmtMap, dxfMa
     }
     arr.push({ col: rc.col, cell });
   }
+  for (const rowNum of sheet.rowHeights.keys()) if (!rowMap.has(rowNum)) rowMap.set(rowNum, []);
+  for (const rowNum of sheet.hiddenRows) if (!rowMap.has(rowNum)) rowMap.set(rowNum, []);
   const sortedRows = Array.from(rowMap.keys()).sort((a, b) => a - b);
   for (const rowNum of sortedRows) {
     const cells = rowMap.get(rowNum);
@@ -83319,11 +83340,12 @@ function buildSheetXml(sheet, styles, ssIndex, isActive, xfMap, numFmtMap, dxfMa
     }
   }
   let dimensionRef = "A1";
-  if (sortedRows.length > 0) {
+  const cellRows = sortedRows.filter((rowNum) => rowMap.get(rowNum).length > 0);
+  if (cellRows.length > 0) {
     let minCol = Infinity, maxCol = 0;
-    const minRow = sortedRows[0];
-    const maxRow = sortedRows[sortedRows.length - 1];
-    for (const rowNum of sortedRows) {
+    const minRow = cellRows[0];
+    const maxRow = cellRows[cellRows.length - 1];
+    for (const rowNum of cellRows) {
       const cells = rowMap.get(rowNum);
       for (const { col } of cells) {
         if (col < minCol) minCol = col;
@@ -92919,6 +92941,9 @@ function adjustMergedCellsForColDelete(sheet, atCol, count) {
 
 // src/xlsx.ts
 var SIMPLE_CELL_KEYS = /* @__PURE__ */ new Set(["value", "formula", "numFmt", "style"]);
+var SIMPLE_SHEET_KEYS = /* @__PURE__ */ new Set(["name", "cells", "merges", "freeze", "colWidths", "rowHeights"]);
+var MAX_COLUMN = 16384;
+var MAX_ROW = 1048576;
 function loadFile(filePath) {
   if (!fs6.existsSync(filePath)) fail2(`File not found: ${filePath}`);
   const buffer = fs6.readFileSync(filePath);
@@ -92970,7 +92995,7 @@ function lazyEngine(workbook) {
     }
   };
 }
-function readToJson(filePath, filter3) {
+function readToJson(filePath, filter3, opts) {
   const buffer = fs6.readFileSync(filePath);
   const arrayBuffer = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
   const parsed = parseExcelBuffer(arrayBuffer);
@@ -92989,13 +93014,13 @@ function readToJson(filePath, filter3) {
       name: s.name,
       totalRowCount: s.totalRowCount,
       truncated: s.truncated,
-      cells: cellsFromParsedRows(s.rows, filter3?.range),
+      cells: cellsFromParsedRows(s.rows, filter3?.range, opts?.withFormat === true),
       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, range2) {
+function cellsFromParsedRows(rows, range2, withFormat = false) {
   const out = {};
   for (const row of rows) {
     if (range2 && (row.index < range2.startRow || row.index > range2.endRow)) continue;
@@ -93005,6 +93030,8 @@ function cellsFromParsedRows(rows, range2) {
       const value2 = cell.typedValue ?? cell.value;
       const entry = { value: value2 };
       if (cell.formula) entry.formula = cell.formula;
+      if (cell.numFmtCode && cell.numFmtCode !== "General") entry.numFmt = cell.numFmtCode;
+      if (withFormat && cell.style && Object.keys(cell.style).length > 0) entry.style = cell.style;
       out[ref2] = entry;
     }
   }
@@ -93025,6 +93052,10 @@ function buildWorkbookFromJson(input) {
 }
 function validateSimpleSheet(s, index) {
   if (!s || typeof s !== "object") fail2(`sheets[${index}] must be an object`);
+  const unknown2 = Object.keys(s).filter((k) => !SIMPLE_SHEET_KEYS.has(k));
+  if (unknown2.length > 0) {
+    fail2(`sheets[${index}] has unknown propert${unknown2.length > 1 ? "ies" : "y"}: ${unknown2.join(", ")}. Supported: ${[...SIMPLE_SHEET_KEYS].join(", ")}.`);
+  }
   if (typeof s.name !== "string" || s.name === "") fail2(`sheets[${index}].name must be a non-empty string`);
   if (s.cells !== void 0 && (typeof s.cells !== "object" || s.cells === null || Array.isArray(s.cells))) {
     fail2(`sheets[${index}].cells must be an object keyed by cell ref (e.g. {"A1": "value"})`);
@@ -93038,6 +93069,23 @@ function validateSimpleSheet(s, index) {
       fail2(`sheets[${index}].freeze.row and .col must be numbers`);
     }
   }
+  validateDimensionMap(s.colWidths, `sheets[${index}].colWidths`, "column letter within A..XFD", (k) => {
+    const coord = /^[A-Za-z]+$/.test(k) ? refToRowCol(`${k.toUpperCase()}1`) : void 0;
+    return coord !== void 0 && coord.col <= MAX_COLUMN;
+  });
+  validateDimensionMap(s.rowHeights, `sheets[${index}].rowHeights`, `row number within 1..${MAX_ROW}`, (k) => /^[0-9]+$/.test(k) && Number(k) >= 1 && Number(k) <= MAX_ROW);
+}
+function validateDimensionMap(map3, label, keyHint, keyOk) {
+  if (map3 === void 0) return;
+  if (typeof map3 !== "object" || map3 === null || Array.isArray(map3)) {
+    fail2(`${label} must be an object keyed by ${keyHint}`);
+  }
+  for (const [key, value2] of Object.entries(map3)) {
+    if (!keyOk(key)) fail2(`${label} key "${key}" must be a ${keyHint}`);
+    if (typeof value2 !== "number" || !Number.isFinite(value2) || value2 <= 0) {
+      fail2(`${label}["${key}"] must be a positive number`);
+    }
+  }
 }
 function applySheetCells(workbook, sheetIndex, def) {
   const sheet = workbook.sheets[sheetIndex];
@@ -93070,6 +93118,20 @@ function applySheetCells(workbook, sheetIndex, def) {
   if (def.freeze) {
     sheet.freeze = { row: def.freeze.row, col: def.freeze.col };
   }
+  if (def.colWidths) {
+    for (const [letter, width] of Object.entries(def.colWidths)) {
+      const coord = refToRowCol(`${letter.toUpperCase()}1`);
+      if (!coord) fail2(`Invalid column in sheet "${def.name}".colWidths: ${letter}`);
+      sheet.colWidths.set(coord.col, width);
+    }
+  }
+  if (def.rowHeights) {
+    for (const [rowKey, height] of Object.entries(def.rowHeights)) {
+      const row = Number(rowKey);
+      if (!Number.isInteger(row) || row < 1) fail2(`Invalid row in sheet "${def.name}".rowHeights: ${rowKey}`);
+      sheet.rowHeights.set(row, height);
+    }
+  }
 }
 function normalizeSimpleCell(raw, sheetName, ref2) {
   if (raw && typeof raw === "object" && !Array.isArray(raw)) {
@@ -93100,9 +93162,10 @@ function splitOptionalSheetRef(spec) {
   return { sheet: spec.slice(0, idx), ref: spec.slice(idx + 1) };
 }
 function xlsxRead(filePath, rest2) {
-  if (!filePath) fail2("Usage: lotics xlsx read <file> [--sheet <name>] [--range <sheet>!<A1:G60>]");
+  if (!filePath) fail2("Usage: lotics xlsx read <file> [--sheet <name>] [--range <sheet>!<A1:G60>] [--with-format]");
   const rangeArg = readOptionFlag(rest2, "--range");
   const sheetArg = readOptionFlag(rest2, "--sheet");
+  const withFormat = rest2.includes("--with-format");
   let filter3;
   if (rangeArg !== void 0) {
     const { sheet, ref: ref2 } = splitOptionalSheetRef(rangeArg);
@@ -93114,7 +93177,7 @@ function xlsxRead(filePath, rest2) {
   } else if (sheetArg !== void 0) {
     filter3 = { sheet: sheetArg };
   }
-  const data2 = readToJson(filePath, filter3);
+  const data2 = readToJson(filePath, filter3, { withFormat });
   console.log(JSON.stringify(data2, null, 2));
 }
 function xlsxWrite(filePath, json2) {
@@ -93351,14 +93414,17 @@ 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> [--sheet <name>] [--range <sheet>!<A1:G60>]
+  lotics xlsx read <file> [--sheet <name>] [--range <sheet>!<A1:G60>] [--with-format]
                                                    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)
+                                                   A cell carries numFmt when it has one; --with-format
+                                                   adds the resolved style (always present, hence a flag)
   lotics xlsx write <file> '<json>'                Create .xlsx from {"sheets":[{"name","cells":{"A1":...}}]}
                                                    A cell is a bare value, or {value|formula, numFmt, style}:
                                                    {"A1":{"value":1234,"numFmt":"#,##0 \\"\u20AB\\"","style":{"fontBold":true}}}
-                                                   Unknown cell properties are rejected, not ignored.
+                                                   A sheet also takes merges, freeze, colWidths ({"A":34}),
+                                                   rowHeights ({"1":44}). Unknown properties are rejected.
   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
   lotics xlsx merge <file> <sheet>!<range>         Merge a range into one cell
@@ -95352,7 +95418,7 @@ function parseLegacyDoc(bytes) {
 }
 
 // ../ooxml/src/document.ts
-var import_jszip = __toESM(require_lib4(), 1);
+var import_jszip2 = __toESM(require_lib4(), 1);
 
 // ../ooxml/node_modules/fast-xml-parser/src/util.js
 var nameStartChar2 = ":A-Za-z_\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD";
@@ -98031,6 +98097,14 @@ async function docModelToDocx(model) {
   return doc;
 }
 
+// ../ooxml/src/opc.ts
+var import_jszip = __toESM(require_lib4(), 1);
+function dropFolderEntries(zip) {
+  for (const [path8, entry] of Object.entries(zip.files)) {
+    if (entry.dir) delete zip.files[path8];
+  }
+}
+
 // ../ooxml/src/document.ts
 var DOCUMENT_ATTRS = {
   "@_xmlns:wpc": "http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas",
@@ -98040,6 +98114,10 @@ var DOCUMENT_ATTRS = {
   "@_xmlns:m": "http://schemas.openxmlformats.org/officeDocument/2006/math",
   "@_xmlns:v": "urn:schemas-microsoft-com:vml",
   "@_xmlns:wp": "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing",
+  // Declared because mc:Ignorable below names it. Markup Compatibility (ECMA-376 Part 3) requires
+  // every prefix listed there to be a declared namespace prefix; an undeclared one made Word
+  // report unreadable content and offer to repair EVERY document this package wrote.
+  "@_xmlns:wp14": "http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing",
   "@_xmlns:w10": "urn:schemas-microsoft-com:office:word",
   "@_xmlns:w": "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
   "@_xmlns:w14": "http://schemas.microsoft.com/office/word/2010/wordml",
@@ -98135,7 +98213,7 @@ async function loadDocxFromBuffer(buffer) {
   if (isLegacyDoc(buffer)) {
     return docxFromLegacyDoc(buffer);
   }
-  const zip = await import_jszip.default.loadAsync(buffer);
+  const zip = await import_jszip2.default.loadAsync(buffer);
   const docFile = zip.file("word/document.xml");
   if (!docFile) {
     throw new Error("Invalid .docx: missing word/document.xml");
@@ -98168,19 +98246,30 @@ function withTrailingParagraph(body) {
   out.splice(lastBlock + 1, 0, { "w:p": [] });
   return out;
 }
+function pruneIgnorable(attrs) {
+  const listed = (attrs["@_mc:Ignorable"] ?? "").split(/\s+/).filter(Boolean);
+  if (listed.length === 0) return attrs;
+  const kept = listed.filter((prefix) => `@_xmlns:${prefix}` in attrs);
+  if (kept.length === listed.length) return attrs;
+  const next = { ...attrs };
+  if (kept.length === 0) delete next["@_mc:Ignorable"];
+  else next["@_mc:Ignorable"] = kept.join(" ");
+  return next;
+}
 async function saveDocxToBuffer(doc) {
   const bodyChildren = withTrailingParagraph(doc.bodyElements);
   const documentEl = {
     "w:document": [{ "w:body": bodyChildren }],
-    ":@": { ...doc.documentAttrs }
+    ":@": pruneIgnorable(doc.documentAttrs)
   };
   const xml = buildXml([documentEl]);
   doc.zip.file("word/document.xml", xml);
+  dropFolderEntries(doc.zip);
   const buffer = await doc.zip.generateAsync({ type: "nodebuffer", compression: "DEFLATE" });
   return buffer;
 }
 function createBlankDocx(opts) {
-  const zip = new import_jszip.default();
+  const zip = new import_jszip2.default();
   zip.file("[Content_Types].xml", CONTENT_TYPES_XML);
   zip.file("_rels/.rels", RELS_XML);
   zip.file("word/_rels/document.xml.rels", DOCUMENT_RELS_XML);
@@ -98239,9 +98328,9 @@ async function ensureContentTypeOverride(doc, partName, contentType) {
 }
 
 // ../docx/src/parse/parser.ts
-var import_jszip2 = __toESM(require_lib4(), 1);
+var import_jszip3 = __toESM(require_lib4(), 1);
 async function parseDocx(buffer) {
-  const zip = await import_jszip2.default.loadAsync(buffer);
+  const zip = await import_jszip3.default.loadAsync(buffer);
   const parts = /* @__PURE__ */ new Map();
   const filePromises = [];
   zip.forEach((path8, file2) => {
@@ -98376,7 +98465,7 @@ function parseOpaqueRunChild(el) {
 }
 
 // ../docx/src/serialize/serializer.ts
-var import_jszip3 = __toESM(require_lib4(), 1);
+var import_jszip4 = __toESM(require_lib4(), 1);
 
 // ../docx/src/serialize/default_parts.ts
 var encoder = new TextEncoder();
@@ -98490,7 +98579,7 @@ function fillDefaultParts(parts) {
 
 // ../docx/src/serialize/serializer.ts
 async function serializeDocx(doc) {
-  const zip = new import_jszip3.default();
+  const zip = new import_jszip4.default();
   const parts = fillDefaultParts(new Map(doc.parts));
   for (const [path8, bytes] of parts) {
     if (path8 === "word/document.xml") continue;
@@ -98498,6 +98587,7 @@ async function serializeDocx(doc) {
   }
   const documentXml = serializeDocumentXml(doc);
   zip.file("word/document.xml", documentXml);
+  dropFolderEntries(zip);
   const out = await zip.generateAsync({
     type: "uint8array",
     compression: "DEFLATE"

package/dist/src/client.d.ts

@@ -233,7 +233,7 @@ export declare class LoticsClient {
         agents?: Record<string, {
             instructions?: string;
             tool_names?: string[];
-            model_id?: string;
+            model_tier?: string;
             inputs?: Record<string, unknown>;
             outputs?: Record<string, unknown>;
         }> | null;

package/docs/cli_reference.md

@@ -29,7 +29,7 @@ Per-command syntax, flags, contracts, and gotchas for the public `lotics` CLI. S
 | `lotics knowledge update <id> [--from <file.md> \| --content <str>] [--name <n>] [--description <d>]` | Call `update_knowledge` with **only** the provided fields (a body from --from/--content becomes `content`; the tool diffs + CASes the content change internally, so the CLI passes no `expected_content_file_id`). At least one field required; --from and --content are mutually exclusive. |
 | `lotics knowledge rm <id>` | Archive the doc via `delete_knowledge` (`{ knowledge_doc_id }`). The REST execute path does not gate `needsApproval`, so this runs unattended. |
 | `lotics app create <name> [path]` | Scaffold a Vite+React+TS custom-code app project; POST /v1/apps; npm install; vite build; upload as v1 |
-| `lotics app pull <app_id> [path]` | Download source archive from R2 (presigned), extract, npm install, stamp package.json's `lotics` field. With no `[path]`: refresh the cwd IN PLACE when it's already this app's own project (its manifest `app_id` matches — the documented `cd <app> && lotics app pull` flow), else clone into an `<name>/` subdir; this avoids the stray nested `./<name>/` subdir a pull-from-inside-the-app used to drop. — `workflows` and `agents` are sourced from the live App row (NOT the archived manifest), so `set_app_workflow` / `set_app_agent` authoring survives the pull. Regenerates `.lotics/app_{workflows,queries,agents}.d.ts` so `useWorkflow` / `useQuery` / `useAgentRun` stay typed, AND the runtime `.lotics/app_fields.ts` (the same linked-vs-bespoke branch `app codegen` runs, off the app row already fetched — see that row for the two forms). That one is not optional: `app deploy` tars source with `--exclude=.lotics`, so no archive can carry it, and a pulled project whose `src/` imports `F`/`OPT` would fail to build with `Could not resolve "../../.lotics/app_fields"` until `app codegen` was run by hand. The write NAMES the form and the reason, because an in-place pull can FLIP a project between them (`opctl app publish` links an origin, `package eject` unlinks it) and that changes what the module does at load. Skipped under `--view-as` (the schema is read as that member and silently drops tables they cannot see — a narrowed `F` map compiles and then throws at runtime, worse than the missing module). A binding/schema fetch failure is non-fatal and names the right recovery for what is on disk: an existing file is kept, an ABSENT one warns about the build error and points at `app codegen`. Pull GENERATES but never RECONCILES `.lotics/` — deleting a companion whose alias the manifest no longer declares is `app codegen`'s alone, since pull's authority is the server's alias set and a declared-but-not-yet-`set` alias is supported. Also writes one `src/workflows/<alias>.ts` per bound workflow (faithful body from `get_app_workflow`) and one `src/agents/<alias>.md` per bound agent (its instructions, straight off the live row) — so the prose an author actually edits lives in a file, and pull always overwrites it from live, leaving no second copy to drift. A legacy workflow alias with no rendered source, or an agent with no instructions, warns and is skipped. The stamped `lotics.agents` map carries the TYPED half only (`inputs`/`outputs`/`tool_names`/`model_id`/…) — an agent's prose lives solely in its `.md`, so there is never a second local copy to desync; a stale `instructions` left by an older CLI is inert and disappears on the next pull |
+| `lotics app pull <app_id> [path]` | Download source archive from R2 (presigned), extract, npm install, stamp package.json's `lotics` field. With no `[path]`: refresh the cwd IN PLACE when it's already this app's own project (its manifest `app_id` matches — the documented `cd <app> && lotics app pull` flow), else clone into an `<name>/` subdir; this avoids the stray nested `./<name>/` subdir a pull-from-inside-the-app used to drop. — `workflows` and `agents` are sourced from the live App row (NOT the archived manifest), so `set_app_workflow` / `set_app_agent` authoring survives the pull. Regenerates `.lotics/app_{workflows,queries,agents}.d.ts` so `useWorkflow` / `useQuery` / `useAgentRun` stay typed, AND the runtime `.lotics/app_fields.ts` (the same linked-vs-bespoke branch `app codegen` runs, off the app row already fetched — see that row for the two forms). That one is not optional: `app deploy` tars source with `--exclude=.lotics`, so no archive can carry it, and a pulled project whose `src/` imports `F`/`OPT` would fail to build with `Could not resolve "../../.lotics/app_fields"` until `app codegen` was run by hand. The write NAMES the form and the reason, because an in-place pull can FLIP a project between them (`opctl app publish` links an origin, `package eject` unlinks it) and that changes what the module does at load. Skipped under `--view-as` (the schema is read as that member and silently drops tables they cannot see — a narrowed `F` map compiles and then throws at runtime, worse than the missing module). A binding/schema fetch failure is non-fatal and names the right recovery for what is on disk: an existing file is kept, an ABSENT one warns about the build error and points at `app codegen`. Pull GENERATES but never RECONCILES `.lotics/` — deleting a companion whose alias the manifest no longer declares is `app codegen`'s alone, since pull's authority is the server's alias set and a declared-but-not-yet-`set` alias is supported. Also writes one `src/workflows/<alias>.ts` per bound workflow (faithful body from `get_app_workflow`) and one `src/agents/<alias>.md` per bound agent (its instructions, straight off the live row) — so the prose an author actually edits lives in a file, and pull always overwrites it from live, leaving no second copy to drift. A legacy workflow alias with no rendered source, or an agent with no instructions, warns and is skipped. The stamped `lotics.agents` map carries the TYPED half only (`inputs`/`outputs`/`tool_names`/`model_tier`/…) — an agent's prose lives solely in its `.md`, so there is never a second local copy to desync; a stale `instructions` left by an older CLI is inert and disappears on the next pull |
 | `lotics app deploy -m <message>` | **`-m` is REQUIRED** (CLI errors without a non-empty message) — each deploy is a version row read back by `lotics app versions`, so a blank message loses the audit trail. npm run build; tar source + dist; POST /v1/apps/{id}/versions multipart. Carries code + capabilities only — **neither queries nor workflow/agent bindings are a deploy concern** (`set_app_workflow` / `remove_app_workflow` own `apps.workflows`; the manifest's `workflows` map is a pulled reflection, read by `useWorkflow` codegen and by `app workflow set`, never written by a deploy). Deploy DOES send the manifest's `lotics.workflows` alias KEYS (not the bindings) as `workflow_aliases`, recorded on the version row so `remove_app_workflow` can refuse to unbind an alias the served version still declares. It also reports any `lotics.queries` alias whose declaration DIFFERS from the app's, naming both recoveries (`app query set --all` to push yours, `app pull` to adopt the app's) — a deploy no longer writes them, so the two are allowed to drift. After a successful deploy it **warns loudly about any alias the source CALLS that is NOT bound on the server** (a `getApp` diff via `warnIfUnboundAliases`) — since deploy never binds them, that would otherwise throw only at the app's first `useWorkflow` / `useAgentRun` call; the warning points to `lotics app workflow set` / `set_app_agent`. Advisory only (never fails the deploy). |
 | `lotics app versions [app_id]` | `GET /v1/apps/{id}/versions` — print deploy history newest-first (version number, timestamp, deployer name, build status, the `-m` message; `*` marks the currently-served version). app_id from the local manifest, or pass one to inspect any app without pulling it. Admin-only server-side (mirrors deploy + source download). Answers "what shipped, when, by whom" — e.g. whether a fix was live at an incident's time. The deploy pipeline already persisted all of this in `app_versions`; this is the read surface. Title → stderr, table → stdout (pipeable). |
 | `lotics app codegen [path]` | Regenerate `.lotics/*` from the manifest + workspace schema **without a deploy**. The three `.d.ts` companions (`app_{workflows,queries,agents}.d.ts`) are always rewritten (synchronous, no network). When credentials resolve, also rewrites the **runtime** `.lotics/app_fields.ts` — **branched on whether the app is a package installation** (`getApp().package_id` set, from `generate_package_fields.ts`): a **linked/published** app emits the BINDING form (`F`/`OPT`/`ROLE` resolved from the installation's LIVE binding — via `appBinding` / the `binding` RPC — at module load through `getAppBinding()` + top-level await, so the source stays portable across every install); a **bespoke** app emits the BAKED form (`generate_app_fields.ts`) — a real `.ts` exporting `F` (table→field→`"fld_…"`) + `OPT` (table→select-field→option→`"opt_…"`) keyed by display-name aliases, for the tables the app's queries reference (+ optional `package.json#lotics.codegen.tables` allowlist). Both forms share the `F`/`OPT` shape (contract aliases derive from the same slugified display names), so a published origin's deployed source compiles unchanged. Writing the BINDING form also heals the project's vitest setup (`ensureAppVitestSetup`, folded into the same write boundary): the binding form awaits `getAppBinding()` (a network call) at module load, so without a stub `npm test` fails to collect any test that imports the app graph — the heal writes `vitest.setup.ts` (mocks only `getAppBinding`, returning an echo binding: any alias → a self-identifying `fld:test:…`/`opt:test:…`/`grp:test:…` id) if absent, and warns the one-liner to add to `vite.config.ts`'s `test.setupFiles` if the wiring is missing (TS source isn't safely munged, mirroring `ensureAppTsconfig`'s JSONC-tsconfig warn). New scaffolds ship both. Also refreshes each bound workflow's `.lotics/workflows/<alias>.globals.d.ts` + re-wraps its EXISTING `src/workflows/<alias>.ts` body in the current envelope (strips + re-wraps; never re-fetches the body, so local edits survive). **`.lotics/` is reconciled to the manifest, not merely added to** — a `<alias>.globals.d.ts` whose alias the manifest no longer declares is DELETED (that directory is read as the app's alias inventory, so a companion for a binding nobody can reach misreports what the app has). Only that exact filename shape is removed; anything else in the directory is left alone. The reconcile runs before the credential branch, so it happens offline too. The authored counterpart is never deleted — a `src/workflows/<alias>.ts` the manifest does not declare is NAMED instead (`check` and `set` both take their alias set from the manifest, so editing an undeclared body is a silent no-op). A getApp / binding / schema / dts-fetch failure is non-fatal (warns, keeps the last-generated files). **Re-silvers `package.json#lotics.agents`** from the live app row whenever its `inputs`/`outputs` disagree, then rewrites the agent `.d.ts` from the refreshed block: that block is a mirror AND the offline seed for `useAgentRun` typings, so a stale copy types the app against an agent that does not exist. Refreshing here makes the divergence self-healing on a command already in the loop and keeps the remedy off `app pull` (which rewrites `src/workflows/*.ts` and would eat uncommitted body edits). The write is surgical and order-preserving (`orderedLike`), so it changes only the fields that actually differ. A hand edit to that block is therefore reverted — it never changed the agent anyway; to change one, `set_app_agent`. |
@@ -45,7 +45,7 @@ Per-command syntax, flags, contracts, and gotchas for the public `lotics` CLI. S
 | `lotics app rename "<new name>"` | Change the app's display name (launcher/title) via the `update_app` tool. app_id comes from the local `package.json` manifest; the public address (`subdomain`) and code (`deploy`) are unchanged. |
 | `lotics app dev [path] [--port=N] [--vite-port=N] [--view-as=<member_id>]` | Spawn Vite dev server + an RPC-forwarding HTTP server. The wrapper page embeds the iframe with `sandbox="allow-scripts allow-same-origin"` matching production; postMessage ops (query / workflow / members / context / upload / openExternal / urlState / agentRun) are forwarded to api.lotics.ai using the CLI's API key — file bytes move in **both** directions through the dev server's own relays, never browser↔storage: dev runs against the PROD bucket, whose CORS admits `https://*.lotics.app` and not `http://localhost:<port>`, so a direct browser transfer is blocked — no upload could complete and no preview engine (PDF/Word/Excel all FETCH the bytes) could read a file. `upload` mints a presigned URL and PUTs it **to `PUT /_upload/<file_id>`** (`dev/upload_relay.ts`) from the wrapper page — same-origin, so no preflight and no CORS — and Node forwards it on; every presigned `url`/`thumbnail_url`/`preview_url` on a **file object** in an RPC result is rewritten to **`GET /_file/<token>`** (`dev/file_relay.ts`, absolute — the iframe would resolve a relative path against Vite), which streams the bytes back with `Range` passthrough (206s intact, so PDF seeking works) and an `Access-Control-Allow-Origin` for the Vite origin (the one cross-origin hop left is OUR response to allow). Neither relay ever takes a destination from the client — it gets a `file_id`/token and transfers only to/from a URL it minted or observed itself, so there is no client-controlled target and no SSRF surface. A URL in a record's own text cell is NOT rewritten. Production is unchanged (direct-to-storage, no bytes through the API server); `openExternal` and `urlState.get/set` are handled locally (the latter read/write the wrapper page's own address bar — `set` writes in place via `replaceState` and browser back/forward broadcast a `url-state` message back, so `useUrlState` survives refresh and is shareable in the dev loop; in-app *routing* is the app's own (the iframe owns its url via `@lotics/app-sdk/router`), and the wrapper bakes the saved screen (`_loc`) into the iframe src on load so a refresh restores it, mirroring production); `agentRun` (streaming) is proxied through `POST /_agent_run`, which opens the run's SSE with the CLI key and pipes chunks back to the iframe (`stream-chunk`* → `stream-end`), so `useAgentRun` works in the dev loop just like production; `context` resolves the viewer (`member_id` from `cli/whoami` + `comments_enabled` from the local manifest) and fetches the installation's stored `config` live from the app row, so `useConfig()` renders the same values as production. `--view-as` (global flag; also `LOTICS_VIEW_AS`) threads `x-view-as-member-id` so `is_current_member` + `context` resolve to that member — **admin key only** (the server 403s a non-admin), writes stay attributed to the key owner. Hot reload via Vite; full DevTools / Playwright access via plain localhost. The dev-optimizer pre-bundle list (`optimizeDeps.include`, load-bearing for dev) is imported from `@lotics/ui/vite` (`loticsOptimizeDeps`) rather than hardcoded in the scaffold, so it tracks the installed `@lotics/ui` and can never go stale. Binds **loopback only** (`127.0.0.1`) — `/_rpc` dispatches with the developer's API key, so a socket on every interface would hand anyone on the network full read/write on the workspace. |
 | `LOTICS_UI_SRC=<abs path to packages/ui/src>` (env, not a command) | Dev-link `@lotics/ui` to a monorepo checkout for the length of ONE command, **for every tool at once**. The app's `vite.config.ts` gets its whole `resolve` block from the kit (`resolve: loticsResolve()` — `@lotics/ui/vite`), which reads the variable at call time and adds the `@lotics/ui/*` → working-copy alias, so kit edits go live under `lotics app dev` (HMR) and bundle under `lotics app deploy`. In the same breath, every command that regenerates types (`create`/`pull`/`dev`/`deploy`/`codegen`, all via `writeAppDts`) writes **`.lotics/tsconfig.link.json`** — the matching `paths`, which the app's `tsconfig.json` `extends` — so `tsc`, vitest, eslint and your EDITOR resolve the same copy Vite does. Unset ⇒ every one of them goes back to `node_modules`, and the generated file is rewritten inert. **Why `paths` and not `npm link`:** the kit ships un-built `.tsx`, so a kit file outside `node_modules` resolves its OWN `react`/`react-native` from the monorepo — two copies in one program and every shared type stops matching ("Two different types with this name exist, but they are unrelated"). The generated file therefore also pins every peer @lotics/ui declares to the APP's copy, types-package first (`react` → `@types/react`; pinning the runtime package instead strands tsc on a `.js` with no declarations). The pin set is derived from the installed kit's `peerDependencies`, so it tracks the kit rather than rotting. **Nothing hand-written is touched** — the generated file lives in `.lotics/` (the CLI's own dir) and no config is edited by regex, which is what the deleted `lotics ui link` did when it twice destroyed the load-bearing `react-native` alias along with the array's closing bracket. Identical for a monorepo app and an EXTERNAL one (e.g. `~/lotics_apps`). `app deploy` still warns whenever the variable is set — that the bundle carries kit code from your working copy, or that the app's config predates `loticsResolve()` and never reads it, so the PUBLISHED kit is going out. An app whose `tsconfig.json` already `extends` something else is told rather than rewritten: add `./.lotics/tsconfig.link.json` to the array yourself. |
-| `lotics xlsx <subcmd>` | Local .xlsx read/write/edit using the bundled `@lotics/xlsx` engine (no auth, no network). 14 named subcommands (read, write, set-cell, clear-range, merge, unmerge, add-sheet, delete-sheet, rename-sheet, insert-rows, delete-rows, insert-cols, delete-cols, set-style) + `batch` for applying multiple of the same 14 ops in a single parse/export cycle. `read` also takes `--sheet <name>` (limit output to one sheet — unknown name fails with the available list) and `--range <sheet>!<A1:G60>` (limit to a cell window; the `<sheet>!` prefix is optional when `--sheet` supplies the sheet, a single cell like `S1!B2` is a 1×1 window) to trim a large workbook's JSON — the output shape is unchanged, only the `sheets` array and each sheet's `cells` map are filtered. Atomic in-place write (temp file + rename). |
+| `lotics xlsx <subcmd>` | Local .xlsx read/write/edit using the bundled `@lotics/xlsx` engine (no auth, no network). 14 named subcommands (read, write, set-cell, clear-range, merge, unmerge, add-sheet, delete-sheet, rename-sheet, insert-rows, delete-rows, insert-cols, delete-cols, set-style) + `batch` for applying multiple of the same 14 ops in a single parse/export cycle. `read` also takes `--sheet <name>` (limit output to one sheet — unknown name fails with the available list) and `--range <sheet>!<A1:G60>` (limit to a cell window; the `<sheet>!` prefix is optional when `--sheet` supplies the sheet, a single cell like `S1!B2` is a 1×1 window) to trim a large workbook's JSON — the output shape is unchanged, only the `sheets` array and each sheet's `cells` map are filtered. **`read` reports formatting back, so a generated file is verifiable through this path** rather than by unzipping OOXML: each cell carries `numFmt` when the file gave it one, and `--with-format` adds the resolved `style`. The asymmetry is deliberate — a parsed cell's style is *never* absent (every cell resolves to at least a font — size, name, colour), so emitting it by default would put three noise keys on every plain cell and make “is this styled?” unanswerable by presence; `numFmt` is genuinely absent on an unformatted cell, so it needs no flag. **`write` takes sheet-level `colWidths` (`{"A":34}`) and `rowHeights` (`{"1":44}`)** — without them every column is the default width and a human-facing workbook is unreadable no matter what the cells say. Both are written *pinned* (`customWidth`/`customHeight`), so Excel does not auto-fit them away, and both apply to a row/column that holds no cells (a spacer row's height survives). Keys are a bare column letter and a bare row number, bounded by Excel's grid (`A`…`XFD`, `1`…`1048576`): a key outside it, or a cell ref like `A1` where a column letter belongs, is **rejected** rather than resolved to something adjacent — past the grid the reference is written into the file verbatim, addressing a cell that cannot exist. Unknown **sheet** properties are rejected on the same terms as unknown cell properties — a silently-ignored `columnWidths` typo is a file that looks written and is not. Atomic in-place write (temp file + rename). |
 | `lotics docx <subcmd>` | Local .docx read/write/edit using the bundled `@lotics/docx` engine (OOXML round-trip surface only — no ProseMirror baggage). Subcommands: read, write, append-paragraph, insert-paragraph, delete-block, replace-text, batch. A legacy `.doc` (Word 97–2003 OLE2 binary) is detected in `loadFile` and routed through `@lotics/ooxml`'s `loadDocxFromBuffer` (which re-emits it as real OOXML) before reading — so `lotics docx read` works on a `.doc`, not just a `.docx`. Opaque blocks (tables, custom XML) preserved verbatim. Atomic in-place write. **`replace-text` matches across run boundaries** — Word splits a run at every formatting change, so a `{{marker}}` routinely lands split — and reads straight THROUGH marks that occupy no place in the sentence (`w:proofErr`, `w:footnoteReference`, endnote/comment refs + ranges, `w:bookmarkStart`/`End`, `w:lastRenderedPageBreak`). `w:proofErr` is the one that decides whether this works in practice — Word brackets every word its dictionary rejects, so on non-English text it lands between nearly every pair of runs. It still refuses to join across anything that occupies space in the text — `w:br`, `w:tab`, `w:sym`, a drawing, or any tag not on that allowlist — because the joined string does not represent the glyph and a match there would rewrite text the caller never saw. The SAME rule applies inside a table cell as outside it — both run one `replaceInParagraph` over paragraphs found at any depth, so a marker split by a line break is refused in both rather than rewritten in the cell and skipped in the body under a success message. Zero matches is always a hard error, never a silent no-op, and when the words ARE on the page the error names the block and the splitting mark (`The text IS present at block 1, split by w:br …`) rather than claiming the text is absent. |
 | `lotics file preview <file\|fil_id> [-o out.png]` | (also `lotics preview`) Render a .docx/.xlsx to a PNG using the SAME engines the frontend FilePreview uses (`@lotics/docx` `loadDocxIntoElement` / `@lotics/xlsx` `drawSpreadsheet`) — so what you see matches an operator. Accepts a **local path** OR a stored **`fil_…` id** (`isStoredFileId` — a bare id, no extension): an id is first downloaded to a temp dir via `downloadFileById` (the `signed_url` presign path — same authority as `lotics file download`), rendered, then the transient source is removed; with no `-o` the PNG lands in cwd under the stored file's base name (`defaultPreviewOutputPath`). Drives a headless Chrome over **CDP with only Node built-ins** (`WebSocket`/`fetch`/`http`/`child_process`) — zero npm deps, the CLI stays a single bundled binary. The browser render logic is a separate esbuild **browser** bundle shipped at `dist/render_page.js` (built by `build_cli.mjs`, excluded from the node `tsgo`), served over a throwaway localhost http server and screenshotted full-page. **Requires a Chrome/Chromium on the machine** — detected from `CHROME_PATH`/`LOTICS_CHROME`, then Playwright's installed chromium, then system paths — inherent to rendering these browser formats; a clear "install a browser" error otherwise. PDFs need no render (open them directly). |
 

package/package.json

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