@reporting-bi/cli 0.1.1 → 0.1.3

package/dist/index.js

@@ -2032,9 +2032,9 @@ var require_stringify = __commonJS({
       }
     };
     var isArray = Array.isArray;
-    var push2 = Array.prototype.push;
+    var push3 = Array.prototype.push;
     var pushToArray = function(arr, valueOrArray) {
-      push2.apply(arr, isArray(valueOrArray) ? valueOrArray : [valueOrArray]);
+      push3.apply(arr, isArray(valueOrArray) ? valueOrArray : [valueOrArray]);
     };
     var toISO = Date.prototype.toISOString;
     var defaultFormat = formats["default"];
@@ -2602,7 +2602,7 @@ var require_service = __commonJS({
       return mod && mod.__esModule ? mod : { "default": mod };
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.Service = exports2.ServiceAuthException = exports2.ServiceException = exports2.serializeRequestParams = void 0;
+    exports2.Service = exports2.ServiceAuthException = exports2.ServiceEvent = exports2.ServiceException = exports2.serializeRequestParams = void 0;
     var qs_1 = __importDefault(require_lib());
     var cache_1 = require_cache();
     function isObject2(value) {
@@ -2624,16 +2624,23 @@ var require_service = __commonJS({
     }
     exports2.serializeRequestParams = serializeRequestParams;
     var ServiceException = class extends Error {
-      constructor(data) {
-        super(data.message);
-        this.data = data;
+      constructor(args) {
+        super(args?.data?.message || "Unknown error");
+        Object.assign(this, args);
       }
     };
     exports2.ServiceException = ServiceException;
+    var ServiceEvent2 = class extends Event {
+      constructor(name, args) {
+        super(name);
+        Object.assign(this, args);
+      }
+    };
+    exports2.ServiceEvent = ServiceEvent2;
     var ServiceAuthException = class extends Error {
     };
     exports2.ServiceAuthException = ServiceAuthException;
-    var Service2 = class {
+    var Service2 = class extends EventTarget {
       get a() {
         return this.accountingProvider?.a;
       }
@@ -2646,6 +2653,7 @@ var require_service = __commonJS({
         return this._cache;
       }
       constructor(options) {
+        super();
         this.accountingProvider = null;
         this.tokenProvider = null;
         this._cache = null;
@@ -2654,7 +2662,7 @@ var require_service = __commonJS({
           this.options.baseUrl = `https://${this.options.baseUrl}`;
         }
       }
-      createUrl(path5 = "", params) {
+      createUrl(path7 = "", params) {
         if (this.options.xdebugSession) {
           params = params || {};
           params.XDEBUG_SESSION = this.options.xdebugSession === true ? "1" : this.options.xdebugSession.toString();
@@ -2662,10 +2670,12 @@ var require_service = __commonJS({
         if (this.options.params && Object.keys(this.options.params).length > 0) {
           params = { ...this.options.params, ...params };
         }
-        const queryString = params ? "?" + serializeRequestParams(params) : "";
+        let queryString = params ? serializeRequestParams(params) : "";
+        if (queryString)
+          queryString = `?${queryString}`;
         const a = params && params.accounting ? params.accounting.toString() : this.a ? this.a.toString() : null;
-        path5 = path5.replace(/^\//, "");
-        const parts = [this.options.baseUrl, a, this.options.name, path5];
+        path7 = path7.replace(/^\//, "");
+        const parts = [this.options.baseUrl, a, this.options.name, path7];
         return parts.filter((p) => p != null && p !== "").join("/") + queryString;
       }
       async createHeaders(headers) {
@@ -2691,7 +2701,7 @@ var require_service = __commonJS({
           error48 = { status: response.status, message: "Unknown error", error: "unknown" };
         }
         if (this.options.throwExceptions) {
-          throw new ServiceException(error48);
+          throw new ServiceException({ data: error48, url: response.url });
         }
       }
       async handleResponse(response, parse3) {
@@ -2706,28 +2716,32 @@ var require_service = __commonJS({
           return await response.text();
         }
       }
-      async getRaw(path5, params, options) {
-        return fetch(this.createUrl(path5, params), {
+      async getRaw(path7, params, options) {
+        const url2 = this.createUrl(path7, params);
+        this.dispatchEvent(new ServiceEvent2("beforeRequest", { url: url2, params, options, method: "GET" }));
+        return fetch(url2, {
           headers: await this.createHeaders(options?.headers),
           credentials: this.credentials
         });
       }
-      async get(path5, params, options) {
+      async get(path7, params, options) {
         if (options?.cache) {
-          const cachedData = this.cache.get({ path: path5, params });
+          const cachedData = this.cache.get({ path: path7, params });
           if (cachedData)
             return cachedData;
         }
-        const response = await this.getRaw(path5, params, options);
+        const response = await this.getRaw(path7, params, options);
         const responseData = await this.handleResponse(response, options?.parseResponse);
         if (options?.cache && responseData) {
-          this.cache.set({ path: path5, params }, responseData);
+          this.cache.set({ path: path7, params }, responseData);
         }
         return responseData;
       }
-      async postRaw(path5, data, params, options) {
+      async postRaw(path7, data, params, options) {
+        const url2 = this.createUrl(path7, params);
+        this.dispatchEvent(new ServiceEvent2("beforeRequest", { url: url2, params, options, method: "POST" }));
         const json3 = isObject2(data) || Array.isArray(data);
-        return fetch(this.createUrl(path5, params), {
+        return fetch(url2, {
           method: "POST",
           body: json3 ? JSON.stringify(data) : data,
           headers: await this.createHeaders({
@@ -2737,24 +2751,28 @@ var require_service = __commonJS({
           credentials: this.credentials
         });
       }
-      async post(path5, data, params, options) {
-        const response = await this.postRaw(path5, data, params, options);
+      async post(path7, data, params, options) {
+        const response = await this.postRaw(path7, data, params, options);
         return this.handleResponse(response);
       }
-      async deleteRaw(path5, params, options) {
-        return fetch(this.createUrl(path5, params), {
+      async deleteRaw(path7, params, options) {
+        const url2 = this.createUrl(path7, params);
+        this.dispatchEvent(new ServiceEvent2("beforeRequest", { url: url2, params, options, method: "DELETE" }));
+        return fetch(url2, {
           method: "DELETE",
           headers: await this.createHeaders(options?.headers),
           credentials: this.credentials
         });
       }
-      async delete(path5, params, options) {
-        const response = await this.deleteRaw(path5, params, options);
+      async delete(path7, params, options) {
+        const response = await this.deleteRaw(path7, params, options);
         return this.handleResponse(response);
       }
-      async putRaw(path5, data, params, options) {
+      async putRaw(path7, data, params, options) {
+        const url2 = this.createUrl(path7, params);
+        this.dispatchEvent(new ServiceEvent2("beforeRequest", { url: url2, params, options, method: "PUT" }));
         const json3 = isObject2(data) || Array.isArray(data);
-        return fetch(this.createUrl(path5, params), {
+        return fetch(url2, {
           method: "PUT",
           body: json3 ? JSON.stringify(data) : data,
           headers: await this.createHeaders({
@@ -2764,8 +2782,8 @@ var require_service = __commonJS({
           credentials: this.credentials
         });
       }
-      async put(path5, data, params, options) {
-        const response = await this.putRaw(path5, data, params, options);
+      async put(path7, data, params, options) {
+        const response = await this.putRaw(path7, data, params, options);
         return this.handleResponse(response);
       }
     };
@@ -5752,7 +5770,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve4.call(this, root, ref);
+      let _sch = resolve5.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a2 = root.localRefs) === null || _a2 === void 0 ? void 0 : _a2[ref];
         const { schemaId } = this.opts;
@@ -5779,7 +5797,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve4(root, ref) {
+    function resolve5(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -5994,8 +6012,8 @@ var require_utils2 = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path5) {
-      let input = path5;
+    function removeDotSegments(path7) {
+      let input = path7;
       const output2 = [];
       let nextSlash = -1;
       let len = 0;
@@ -6194,8 +6212,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path5, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path5 && path5 !== "/" ? path5 : void 0;
+        const [path7, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path7 && path7 !== "/" ? path7 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -6354,55 +6372,55 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve4(baseURI, relativeURI, options) {
+    function resolve5(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const resolved = resolveComponent(parse3(baseURI, schemelessOptions), parse3(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
       return serialize(resolved, schemelessOptions);
     }
-    function resolveComponent(base, relative2, options, skipNormalization) {
+    function resolveComponent(base, relative4, options, skipNormalization) {
       const target = {};
       if (!skipNormalization) {
         base = parse3(serialize(base, options), options);
-        relative2 = parse3(serialize(relative2, options), options);
+        relative4 = parse3(serialize(relative4, options), options);
       }
       options = options || {};
-      if (!options.tolerant && relative2.scheme) {
-        target.scheme = relative2.scheme;
-        target.userinfo = relative2.userinfo;
-        target.host = relative2.host;
-        target.port = relative2.port;
-        target.path = removeDotSegments(relative2.path || "");
-        target.query = relative2.query;
+      if (!options.tolerant && relative4.scheme) {
+        target.scheme = relative4.scheme;
+        target.userinfo = relative4.userinfo;
+        target.host = relative4.host;
+        target.port = relative4.port;
+        target.path = removeDotSegments(relative4.path || "");
+        target.query = relative4.query;
       } else {
-        if (relative2.userinfo !== void 0 || relative2.host !== void 0 || relative2.port !== void 0) {
-          target.userinfo = relative2.userinfo;
-          target.host = relative2.host;
-          target.port = relative2.port;
-          target.path = removeDotSegments(relative2.path || "");
-          target.query = relative2.query;
+        if (relative4.userinfo !== void 0 || relative4.host !== void 0 || relative4.port !== void 0) {
+          target.userinfo = relative4.userinfo;
+          target.host = relative4.host;
+          target.port = relative4.port;
+          target.path = removeDotSegments(relative4.path || "");
+          target.query = relative4.query;
         } else {
-          if (!relative2.path) {
+          if (!relative4.path) {
             target.path = base.path;
-            if (relative2.query !== void 0) {
-              target.query = relative2.query;
+            if (relative4.query !== void 0) {
+              target.query = relative4.query;
             } else {
               target.query = base.query;
             }
           } else {
-            if (relative2.path[0] === "/") {
-              target.path = removeDotSegments(relative2.path);
+            if (relative4.path[0] === "/") {
+              target.path = removeDotSegments(relative4.path);
             } else {
               if ((base.userinfo !== void 0 || base.host !== void 0 || base.port !== void 0) && !base.path) {
-                target.path = "/" + relative2.path;
+                target.path = "/" + relative4.path;
               } else if (!base.path) {
-                target.path = relative2.path;
+                target.path = relative4.path;
               } else {
-                target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative2.path;
+                target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative4.path;
               }
               target.path = removeDotSegments(target.path);
             }
-            target.query = relative2.query;
+            target.query = relative4.query;
           }
           target.userinfo = base.userinfo;
           target.host = base.host;
@@ -6410,7 +6428,7 @@ var require_fast_uri = __commonJS({
         }
         target.scheme = base.scheme;
       }
-      target.fragment = relative2.fragment;
+      target.fragment = relative4.fragment;
       return target;
     }
     function equal(uriA, uriB, options) {
@@ -6581,7 +6599,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize,
-      resolve: resolve4,
+      resolve: resolve5,
       resolveComponent,
       equal,
       serialize,
@@ -9557,12 +9575,12 @@ var require_dist2 = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list7, fs8, exportName) {
+    function addFormats(ajv, list7, fs10, exportName) {
       var _a2;
       var _b;
       (_a2 = (_b = ajv.opts.code).formats) !== null && _a2 !== void 0 ? _a2 : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list7)
-        ajv.addFormat(f, fs8[f]);
+        ajv.addFormat(f, fs10[f]);
     }
     module2.exports = exports2 = formatsPlugin;
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -9962,6 +9980,12 @@ async function createService(name, options) {
     ap.a = accounting2;
     service.accountingProvider = ap;
   }
+  if (process.argv.includes("--verbose")) {
+    service.addEventListener("beforeRequest", (e) => {
+      const ev = e;
+      console.error(`${ev.method} ${decodeURIComponent(ev.url || "")}`);
+    });
+  }
   return service;
 }
 function getFields(flags, defaults) {
@@ -10146,8 +10170,8 @@ var callback_default = `<!DOCTYPE html>
 `;
 
 // src/commands/login.ts
-function renderCallback(status3, title, message) {
-  return callback_default.replace("{{status}}", status3).replace("{{title}}", title).replace("{{message}}", message);
+function renderCallback(status4, title, message) {
+  return callback_default.replace("{{status}}", status4).replace("{{title}}", title).replace("{{message}}", message);
 }
 function openBrowser(url2) {
   const platform = process.platform;
@@ -10191,12 +10215,12 @@ async function login(args) {
   }
 }
 function getAuthorizationCode(domain2) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     let timeout;
     const done = (result) => {
       clearTimeout(timeout);
       server.close();
-      resolve4(result);
+      resolve5(result);
     };
     const server = http.createServer((req, res) => {
       const url2 = new URL(req.url || "", "http://localhost");
@@ -10331,7 +10355,579 @@ async function use(args) {
 }
 
 // src/commands/wiki.ts
+var fs6 = __toESM(require("node:fs"));
+
+// src/commands/wiki-sync.ts
+var fs5 = __toESM(require("node:fs"));
+var path4 = __toESM(require("node:path"));
+
+// src/manifest.ts
 var fs3 = __toESM(require("node:fs"));
+var path2 = __toESM(require("node:path"));
+var crypto2 = __toESM(require("node:crypto"));
+var RPBI_DIR = ".rpbi";
+var CONFIG_FILE = "config.json";
+var INDEX_FILE = "index.json";
+function computeHash(content2) {
+  return crypto2.createHash("sha256").update(content2, "utf-8").digest("hex");
+}
+function getConfigPath(dir) {
+  return path2.join(dir, RPBI_DIR, CONFIG_FILE);
+}
+function getIndexPath(dir) {
+  return path2.join(dir, RPBI_DIR, INDEX_FILE);
+}
+function readConfig(dir) {
+  try {
+    const data = fs3.readFileSync(getConfigPath(dir), "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+function writeConfig(dir, config2) {
+  const rpbiDir = path2.join(dir, RPBI_DIR);
+  fs3.mkdirSync(rpbiDir, { recursive: true });
+  fs3.writeFileSync(
+    path2.join(rpbiDir, CONFIG_FILE),
+    JSON.stringify(config2, null, 2)
+  );
+}
+function readIndex(dir) {
+  try {
+    const data = fs3.readFileSync(getIndexPath(dir), "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return [];
+  }
+}
+function writeIndex(dir, index) {
+  const rpbiDir = path2.join(dir, RPBI_DIR);
+  fs3.mkdirSync(rpbiDir, { recursive: true });
+  fs3.writeFileSync(
+    path2.join(rpbiDir, INDEX_FILE),
+    JSON.stringify(index, null, 2)
+  );
+}
+function findProjectRoot(startDir) {
+  let dir = path2.resolve(startDir);
+  while (true) {
+    if (fs3.existsSync(getConfigPath(dir))) return dir;
+    const parent = path2.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+// src/commands/sync-core.ts
+var fs4 = __toESM(require("node:fs"));
+var path3 = __toESM(require("node:path"));
+function writeFileSync4(filePath, content2) {
+  fs4.mkdirSync(path3.dirname(filePath), { recursive: true });
+  fs4.writeFileSync(filePath, content2);
+}
+function walkDir(dir, root, knownPaths, result) {
+  const entries = fs4.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = path3.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      walkDir(full, root, knownPaths, result);
+    } else if (!entry.name.startsWith(".")) {
+      const rel = path3.relative(root, full).replace(/\\/g, "/");
+      if (!knownPaths.has(rel)) {
+        result.push(rel);
+      }
+    }
+  }
+}
+function detectModifiedFiles(root, index, getPath, computeCurrentHash, getStoredHash) {
+  const modified = [];
+  for (const entry of index) {
+    const relPath = getPath(entry);
+    const absPath = path3.join(root, relPath);
+    if (!fs4.existsSync(absPath)) {
+      modified.push(relPath);
+      continue;
+    }
+    if (computeCurrentHash(absPath) !== getStoredHash(entry)) {
+      modified.push(relPath);
+    }
+  }
+  return modified;
+}
+function detectNewFiles(root, index, getPath) {
+  const newFiles = [];
+  const knownPaths = new Set(index.map((e) => getPath(e)));
+  const entries = fs4.readdirSync(root, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+    walkDir(path3.join(root, entry.name), root, knownPaths, newFiles);
+  }
+  return newFiles;
+}
+async function watch2(type, flags, pushFn) {
+  const startDir = flags.dir || ".";
+  const root = findProjectRoot(startDir);
+  if (!root) {
+    console.error(`No .rpbi/config.json found. Run "rpbi ${type} pull" first.`);
+    process.exit(1);
+  }
+  const debounceMs = parseInt(flags.debounce || "500");
+  console.log(`Watching ${root} for changes...`);
+  console.log("Press Ctrl+C to stop.\n");
+  const pending = /* @__PURE__ */ new Map();
+  const watcher = fs4.watch(root, { recursive: true }, (_event, filename) => {
+    if (!filename) return;
+    const relPath = filename.replace(/\\/g, "/");
+    if (relPath.startsWith(".rpbi/") || relPath.startsWith(".")) return;
+    const existing = pending.get(relPath);
+    if (existing) clearTimeout(existing);
+    pending.set(relPath, setTimeout(async () => {
+      pending.delete(relPath);
+      try {
+        await pushFn(flags, [relPath]);
+      } catch (err) {
+        console.error(`Watch push failed for ${relPath}: ${err instanceof Error ? err.message : err}`);
+      }
+    }, debounceMs));
+  });
+  process.on("SIGINT", () => {
+    watcher.close();
+    console.log("\nWatch stopped.");
+    process.exit(0);
+  });
+  await new Promise(() => {
+  });
+}
+function printLocalStatus(label, root, config2, flags, modified, newFiles) {
+  const deleted = modified.filter((f) => !fs4.existsSync(path3.join(root, f)));
+  const changed = modified.filter((f) => fs4.existsSync(path3.join(root, f)));
+  if (flags.json === "true") {
+    console.log(JSON.stringify({ modified: changed, new: newFiles, deleted }));
+    return;
+  }
+  console.log(`${label} workspace: ${root}`);
+  console.log(`Domain: ${config2?.domain} | Accounting: ${config2?.accounting}`);
+  if (config2?.pulledAt) console.log(`Pulled at: ${config2.pulledAt}`);
+  console.log("");
+  if (changed.length === 0 && newFiles.length === 0 && deleted.length === 0) {
+    console.log("No changes.");
+    return;
+  }
+  if (changed.length > 0) {
+    console.log("Modified:");
+    for (const f of changed) console.log(`  M ${f}`);
+  }
+  if (newFiles.length > 0) {
+    console.log("New (untracked):");
+    for (const f of newFiles) console.log(`  + ${f}`);
+  }
+  if (deleted.length > 0) {
+    console.log("Deleted locally:");
+    for (const f of deleted) console.log(`  - ${f}`);
+  }
+}
+function printRemoteStatus(label, root, config2, flags, result) {
+  const { modifiedLocally, modifiedOnServer, conflict, new: newFiles, localOnly, serverOnly } = result;
+  if (flags.json === "true") {
+    console.log(JSON.stringify(result));
+    return;
+  }
+  console.log(`${label} workspace: ${root}`);
+  console.log(`Domain: ${config2?.domain} | Accounting: ${config2?.accounting}`);
+  console.log("");
+  const total = modifiedLocally.length + modifiedOnServer.length + conflict.length + newFiles.length + localOnly.length + serverOnly.length;
+  if (total === 0) {
+    console.log("In sync with server.");
+    return;
+  }
+  if (conflict.length > 0) {
+    console.log("Conflict (changed locally AND on server):");
+    for (const f of conflict) console.log(`  ! ${f}`);
+  }
+  if (modifiedLocally.length > 0) {
+    console.log("Modified locally:");
+    for (const f of modifiedLocally) console.log(`  M ${f}`);
+  }
+  if (modifiedOnServer.length > 0) {
+    console.log("Modified on server:");
+    for (const f of modifiedOnServer) console.log(`  S ${f}`);
+  }
+  if (newFiles.length > 0) {
+    console.log("New (untracked):");
+    for (const f of newFiles) console.log(`  + ${f}`);
+  }
+  if (localOnly.length > 0) {
+    console.log("Local only (deleted on server):");
+    for (const f of localOnly) console.log(`  - ${f}`);
+  }
+  if (serverOnly.length > 0) {
+    console.log("Server only (not pulled):");
+    for (const f of serverOnly) console.log(`  \u2193 ${f}`);
+  }
+}
+
+// src/commands/wiki-sync.ts
+var SYNC_LANGS = ["cs", "en"];
+function pageToRelPath(page) {
+  const name = page.name || "untitled";
+  return `${page.lang}/${name}.md`;
+}
+function fileToRelPath(file2) {
+  const filename = file2.filename || "untitled";
+  return `${file2.lang}/${filename}`;
+}
+function pathToLangAndName(relPath) {
+  const parts = relPath.split("/");
+  const lang = parts[0];
+  const rest = parts.slice(1).join("/");
+  return { lang, name: rest };
+}
+function isPageFile(relPath) {
+  return relPath.endsWith(".md");
+}
+function computeFileHash(absPath) {
+  const buf = fs5.readFileSync(absPath);
+  return computeHash(buf.toString("base64"));
+}
+function computePageHash(absPath) {
+  const content2 = fs5.readFileSync(absPath, "utf-8");
+  return computeHash(content2);
+}
+async function pull(flags) {
+  const dir = path4.resolve(flags.dir || ".");
+  const conn = getActiveConnection(dir);
+  if (!conn) {
+    console.error('Not logged in. Run "rpbi login" first.');
+    process.exit(1);
+  }
+  const wikiService = await createService("wiki", { cwd: dir });
+  const langs = flags.langs ? flags.langs.split(",") : SYNC_LANGS;
+  console.log(`Pulling wiki to ${dir}...`);
+  const index = [];
+  for (const lang of langs) {
+    console.log(`Pulling pages for language: ${lang}`);
+    const pages = await wikiService.get("pages", {
+      fields: ["id_wiki_page", "name", "lang", "date_created"],
+      where: { lang }
+    }) || [];
+    console.log(`  Found ${pages.length} pages`);
+    let pulled = 0;
+    for (const page of pages) {
+      if (!page.id_wiki_page || !page.name) continue;
+      const relPath = pageToRelPath({ ...page, lang });
+      const absPath = path4.join(dir, relPath);
+      try {
+        const content2 = await wikiService.get(
+          `pageContent/${lang}/${page.id_wiki_page}`,
+          void 0,
+          { parseResponse: false }
+        ) || "";
+        writeFileSync4(absPath, content2);
+        index.push({
+          path: relPath,
+          type: "page",
+          id: page.id_wiki_page,
+          lang,
+          hash: computeHash(content2),
+          serverDate: page.date_created
+        });
+        pulled++;
+        if (pulled % 50 === 0) console.log(`    ${pulled}/${pages.length} pages...`);
+      } catch (err) {
+        console.error(`  Failed to pull ${relPath}: ${err instanceof Error ? err.message : err}`);
+      }
+    }
+    console.log(`  Pulled ${pulled} pages`);
+  }
+  console.log("Pulling files...");
+  const files = await wikiService.get("files", {
+    fields: ["id_wiki_file", "filename", "size", "lang", "date_created"]
+  }) || [];
+  console.log(`  Found ${files.length} files`);
+  let pulledFiles = 0;
+  for (const file2 of files) {
+    if (!file2.id_wiki_file || !file2.filename) continue;
+    const lang = file2.lang || "cs";
+    const relPath = fileToRelPath({ ...file2, lang });
+    const absPath = path4.join(dir, relPath);
+    try {
+      const response = await wikiService.getRaw(`download/${file2.id_wiki_file}`);
+      if (!response.ok) throw new Error(`HTTP ${response.status}`);
+      const buf = Buffer.from(await response.arrayBuffer());
+      writeFileSync4(absPath, buf);
+      index.push({
+        path: relPath,
+        type: "file",
+        id: file2.id_wiki_file,
+        lang,
+        hash: computeHash(buf.toString("base64")),
+        serverDate: file2.date_created
+      });
+      pulledFiles++;
+    } catch (err) {
+      console.error(`  Failed to pull ${relPath}: ${err instanceof Error ? err.message : err}`);
+    }
+  }
+  console.log(`  Pulled ${pulledFiles} files`);
+  writeConfig(dir, {
+    domain: conn.domain,
+    accounting: conn.tokens.accounting,
+    type: "wiki",
+    pulledAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  writeIndex(dir, index);
+  console.log(`Done. Pulled ${index.length} items to ${dir}`);
+}
+async function push(flags, files) {
+  const startDir = flags.dir || ".";
+  const root = findProjectRoot(startDir);
+  if (!root) {
+    console.error('No .rpbi/config.json found. Run "rpbi wiki pull" first.');
+    process.exit(1);
+  }
+  const index = readIndex(root);
+  const indexMap = new Map(index.map((e) => [e.path, e]));
+  const wikiService = await createService("wiki", { cwd: root });
+  const force = flags.force === "true";
+  let filesToPush;
+  if (files.length > 0) {
+    filesToPush = files.map((f) => path4.relative(root, path4.resolve(f)).replace(/\\/g, "/"));
+  } else {
+    filesToPush = [
+      ...detectModifiedFiles2(root, index),
+      ...detectNewFiles2(root, index)
+    ];
+  }
+  if (filesToPush.length === 0) {
+    console.log("Nothing to push.");
+    return;
+  }
+  console.log(`Pushing ${filesToPush.length} file(s)...`);
+  for (const relPath of filesToPush) {
+    const absPath = path4.join(root, relPath);
+    if (!fs5.existsSync(absPath)) {
+      const entry2 = indexMap.get(relPath);
+      if (entry2) {
+        try {
+          if (entry2.type === "page") {
+            await wikiService.delete(`page/${entry2.lang}/${entry2.id}`);
+          } else {
+            await wikiService.delete(`file/${entry2.id}`);
+          }
+          const idx = index.indexOf(entry2);
+          if (idx !== -1) index.splice(idx, 1);
+          indexMap.delete(relPath);
+          console.log(`  Deleted: ${relPath}`);
+        } catch (err) {
+          console.error(`  Failed to delete ${relPath}: ${err instanceof Error ? err.message : err}`);
+        }
+      } else {
+        console.log(`  Skipping ${relPath} (file not found, not in index)`);
+      }
+      continue;
+    }
+    const entry = indexMap.get(relPath);
+    const { lang, name } = pathToLangAndName(relPath);
+    if (isPageFile(relPath)) {
+      const localContent = fs5.readFileSync(absPath, "utf-8");
+      const pageName = name.replace(/\.md$/, "");
+      if (entry) {
+        if (!force) {
+          try {
+            const serverContent = await wikiService.get(
+              `pageContent/${entry.lang}/${entry.id}`,
+              void 0,
+              { parseResponse: false }
+            ) || "";
+            const serverHash = computeHash(serverContent);
+            if (serverHash !== entry.hash) {
+              console.error(`  CONFLICT: ${relPath} was modified on server. Use --force to overwrite.`);
+              continue;
+            }
+          } catch {
+          }
+        }
+        const updated = await wikiService.post("page", {
+          id_wiki_page: entry.id,
+          lang: entry.lang,
+          name: pageName,
+          content: localContent
+        });
+        entry.hash = computeHash(localContent);
+        if (updated?.date_created) entry.serverDate = updated.date_created;
+        console.log(`  Updated: ${relPath}`);
+      } else {
+        const result = await wikiService.post("page", {
+          lang,
+          name: pageName,
+          content: localContent
+        });
+        if (result?.id_wiki_page) {
+          index.push({
+            path: relPath,
+            type: "page",
+            id: result.id_wiki_page,
+            lang,
+            hash: computeHash(localContent),
+            serverDate: result.date_created
+          });
+          console.log(`  Created: ${relPath} (page #${result.id_wiki_page})`);
+        } else {
+          console.error(`  Failed to create page for ${relPath}`);
+        }
+      }
+    } else {
+      const buf = fs5.readFileSync(absPath);
+      const b64Content = buf.toString("base64");
+      if (entry) {
+        const updated = await wikiService.post("file", {
+          id_wiki_file: entry.id,
+          filename: name,
+          content: b64Content,
+          lang: entry.lang
+        });
+        entry.hash = computeHash(b64Content);
+        if (updated?.date_created) entry.serverDate = updated.date_created;
+        console.log(`  Updated: ${relPath}`);
+      } else {
+        const result = await wikiService.post("file", {
+          lang,
+          filename: name,
+          content: b64Content
+        });
+        if (result?.id_wiki_file) {
+          index.push({
+            path: relPath,
+            type: "file",
+            id: result.id_wiki_file,
+            lang,
+            hash: computeHash(b64Content),
+            serverDate: result.date_created
+          });
+          console.log(`  Created: ${relPath} (file #${result.id_wiki_file})`);
+        } else {
+          console.error(`  Failed to create file for ${relPath}`);
+        }
+      }
+    }
+  }
+  writeIndex(path4.resolve(root), index);
+  console.log("Push complete.");
+}
+function detectModifiedFiles2(root, index) {
+  const typeMap = new Map(index.map((e) => [path4.join(root, e.path), e.type]));
+  return detectModifiedFiles(
+    root,
+    index,
+    (e) => e.path,
+    (absPath) => typeMap.get(absPath) === "page" ? computePageHash(absPath) : computeFileHash(absPath),
+    (e) => e.hash
+  );
+}
+function detectNewFiles2(root, index) {
+  return detectNewFiles(root, index, (e) => e.path);
+}
+async function status2(flags) {
+  const startDir = flags.dir || ".";
+  const root = findProjectRoot(startDir);
+  if (!root) {
+    console.error('No .rpbi/config.json found. Run "rpbi wiki pull" first.');
+    process.exit(1);
+  }
+  const config2 = readConfig(root);
+  const index = readIndex(root);
+  if (flags.remote === "true") {
+    return statusRemote(root, config2, index, flags);
+  }
+  const modified = detectModifiedFiles2(root, index);
+  const newFiles = detectNewFiles2(root, index);
+  printLocalStatus("Wiki", root, config2, flags, modified, newFiles);
+}
+async function statusRemote(root, config2, index, flags) {
+  const wikiService = await createService("wiki", { cwd: root });
+  const langs = flags.langs ? flags.langs.split(",") : SYNC_LANGS;
+  const localPages = /* @__PURE__ */ new Map();
+  const localFiles = /* @__PURE__ */ new Map();
+  for (const entry of index) {
+    if (entry.type === "page") localPages.set(entry.path, entry);
+    else localFiles.set(entry.path, entry);
+  }
+  const modifiedLocally = [];
+  const modifiedOnServer = [];
+  const conflict = [];
+  const localOnly = [];
+  const serverOnly = [];
+  for (const lang of langs) {
+    const serverPages = await wikiService.get("pages", {
+      fields: ["id_wiki_page", "name", "lang", "date_created"],
+      where: { lang }
+    }) || [];
+    const serverPagePaths = /* @__PURE__ */ new Set();
+    for (const page of serverPages) {
+      if (!page.id_wiki_page || !page.name) continue;
+      const relPath = pageToRelPath({ ...page, lang });
+      serverPagePaths.add(relPath);
+      const localEntry = localPages.get(relPath);
+      if (!localEntry) {
+        serverOnly.push(relPath);
+      } else {
+        const absPath = path4.join(root, relPath);
+        const localChanged = fs5.existsSync(absPath) && computePageHash(absPath) !== localEntry.hash;
+        const serverChanged = page.date_created != null && localEntry.serverDate != null && page.date_created !== localEntry.serverDate;
+        if (localChanged && serverChanged) {
+          conflict.push(relPath);
+        } else if (localChanged) {
+          modifiedLocally.push(relPath);
+        } else if (serverChanged) {
+          modifiedOnServer.push(relPath);
+        }
+      }
+    }
+    for (const [relPath, entry] of localPages) {
+      if (entry.lang === lang && !serverPagePaths.has(relPath)) {
+        localOnly.push(relPath);
+      }
+    }
+  }
+  const serverFiles = await wikiService.get("files", {
+    fields: ["id_wiki_file", "filename", "lang", "date_created"]
+  }) || [];
+  const serverFilePaths = /* @__PURE__ */ new Set();
+  for (const file2 of serverFiles) {
+    if (!file2.id_wiki_file || !file2.filename) continue;
+    const lang = file2.lang || "cs";
+    const relPath = fileToRelPath({ ...file2, lang });
+    serverFilePaths.add(relPath);
+    const localEntry = localFiles.get(relPath);
+    if (!localEntry) {
+      serverOnly.push(relPath);
+    } else {
+      const absPath = path4.join(root, relPath);
+      const localChanged = fs5.existsSync(absPath) && computeFileHash(absPath) !== localEntry.hash;
+      const serverChanged = file2.date_created != null && localEntry.serverDate != null && file2.date_created !== localEntry.serverDate;
+      if (localChanged && serverChanged) {
+        conflict.push(relPath);
+      } else if (localChanged) {
+        modifiedLocally.push(relPath);
+      } else if (serverChanged) {
+        modifiedOnServer.push(relPath);
+      }
+    }
+  }
+  for (const [relPath] of localFiles) {
+    if (!serverFilePaths.has(relPath)) {
+      localOnly.push(relPath);
+    }
+  }
+  const newFiles = detectNewFiles2(root, index);
+  printRemoteStatus("Wiki", root, config2, flags, { modifiedLocally, modifiedOnServer, conflict, new: newFiles, localOnly, serverOnly });
+}
+function watch3(flags) {
+  return watch2("wiki", flags, push);
+}
+
+// src/commands/wiki.ts
 var DEFAULT_LANG = "cs";
 async function list2(flags) {
   const service = await createService("wiki");
@@ -10357,17 +10953,17 @@ async function search(query, flags) {
 }
 async function readContent(flags) {
   if (flags.file) {
-    return fs3.readFileSync(flags.file, "utf-8");
+    return fs6.readFileSync(flags.file, "utf-8");
   }
   if (flags.content) {
     return flags.content;
   }
   if (!process.stdin.isTTY) {
-    return new Promise((resolve4) => {
+    return new Promise((resolve5) => {
       let data = "";
       process.stdin.setEncoding("utf-8");
       process.stdin.on("data", (chunk) => data += chunk);
-      process.stdin.on("end", () => resolve4(data));
+      process.stdin.on("end", () => resolve5(data));
     });
   }
   console.error("No content provided. Use --file, --content, or pipe to stdin.");
@@ -10424,76 +11020,26 @@ async function wiki(args) {
         process.exit(1);
       }
       return del(rest[0], flags);
+    case "pull":
+      return pull(flags);
+    case "push":
+      return push(flags, rest);
+    case "status":
+      return status2(flags);
+    case "watch":
+      return watch3(flags);
     default:
-      console.log("Usage: rpbi wiki <list|get|read|search|save|delete> [options]");
+      console.log("Usage: rpbi wiki <list|get|read|search|save|delete|pull|push|status|watch> [options]");
       break;
   }
 }
 
 // src/commands/etl.ts
-var fs6 = __toESM(require("node:fs"));
+var fs8 = __toESM(require("node:fs"));
 
 // src/commands/etl-sync.ts
-var fs5 = __toESM(require("node:fs"));
-var path3 = __toESM(require("node:path"));
-
-// src/manifest.ts
-var fs4 = __toESM(require("node:fs"));
-var path2 = __toESM(require("node:path"));
-var crypto2 = __toESM(require("node:crypto"));
-var RPBI_DIR = ".rpbi";
-var CONFIG_FILE = "config.json";
-var INDEX_FILE = "index.json";
-function computeHash(content2) {
-  return crypto2.createHash("sha256").update(content2, "utf-8").digest("hex");
-}
-function getConfigPath(dir) {
-  return path2.join(dir, RPBI_DIR, CONFIG_FILE);
-}
-function getIndexPath(dir) {
-  return path2.join(dir, RPBI_DIR, INDEX_FILE);
-}
-function readConfig(dir) {
-  try {
-    const data = fs4.readFileSync(getConfigPath(dir), "utf-8");
-    return JSON.parse(data);
-  } catch {
-    return null;
-  }
-}
-function writeConfig(dir, config2) {
-  const rpbiDir = path2.join(dir, RPBI_DIR);
-  fs4.mkdirSync(rpbiDir, { recursive: true });
-  fs4.writeFileSync(
-    path2.join(rpbiDir, CONFIG_FILE),
-    JSON.stringify(config2, null, 2)
-  );
-}
-function readIndex(dir) {
-  try {
-    const data = fs4.readFileSync(getIndexPath(dir), "utf-8");
-    return JSON.parse(data);
-  } catch {
-    return [];
-  }
-}
-function writeIndex(dir, index) {
-  const rpbiDir = path2.join(dir, RPBI_DIR);
-  fs4.mkdirSync(rpbiDir, { recursive: true });
-  fs4.writeFileSync(
-    path2.join(rpbiDir, INDEX_FILE),
-    JSON.stringify(index, null, 2)
-  );
-}
-function findEtlRoot(startDir) {
-  let dir = path2.resolve(startDir);
-  while (true) {
-    if (fs4.existsSync(getConfigPath(dir))) return dir;
-    const parent = path2.dirname(dir);
-    if (parent === dir) return null;
-    dir = parent;
-  }
-}
+var fs7 = __toESM(require("node:fs"));
+var path5 = __toESM(require("node:path"));
 
 // src/yaml.ts
 function toYaml(data, indent = 0) {
@@ -10622,10 +11168,6 @@ function threadToMetaPath(thread) {
   const segments = getFilePath(thread.description || "", ".yaml");
   return [".rpbi", "threads", typeToDirName(thread.type), ...segments].join("/");
 }
-function writeFileSync4(filePath, content2) {
-  fs5.mkdirSync(path3.dirname(filePath), { recursive: true });
-  fs5.writeFileSync(filePath, content2, "utf-8");
-}
 function stripFields(obj, excludeFields) {
   const result = {};
   for (const [key, value] of Object.entries(obj)) {
@@ -10635,8 +11177,8 @@ function stripFields(obj, excludeFields) {
   }
   return result;
 }
-async function pull(flags) {
-  const dir = path3.resolve(flags.dir || ".");
+async function pull2(flags) {
+  const dir = path5.resolve(flags.dir || ".");
   const conn = getActiveConnection(dir);
   if (!conn) {
     console.error('Not logged in. Run "rpbi login" first.');
@@ -10646,7 +11188,7 @@ async function pull(flags) {
   const defService = await createService("definition", { cwd: dir });
   console.log(`Pulling ETL threads to ${dir}...`);
   const threads = await etlService.get("threads", {
-    fields: ["id_thread", "description", "type", "enabled", "ord_num", "module"],
+    fields: ["id_thread", "description", "type", "enabled", "ord_num", "module", "date_created"],
     order: [["type", "asc"], ["description", "asc"]]
   }) || [];
   console.log(`Found ${threads.length} threads`);
@@ -10655,7 +11197,7 @@ async function pull(flags) {
   for (const thread of threads) {
     if (!thread.id_thread || !thread.type || !thread.description) continue;
     const relPath = threadToRelPath(thread);
-    const absPath = path3.join(dir, relPath);
+    const absPath = path5.join(dir, relPath);
     try {
       const content2 = await etlService.get(
         `threadContent/${thread.id_thread}`,
@@ -10667,7 +11209,8 @@ async function pull(flags) {
         path: relPath,
         id_thread: thread.id_thread,
         hash: computeHash(content2),
-        type: thread.type
+        type: thread.type,
+        serverDate: thread.date_created
       });
       pulled++;
       if (pulled % 50 === 0) console.log(`  ${pulled}/${threads.length} threads...`);
@@ -10686,7 +11229,7 @@ async function pull(flags) {
       const cleaned = params.map((p) => stripFields(p, PARAMETER_EXCLUDE_FIELDS));
       const optimized = optimizeForLlm(cleaned);
       if (!optimized || !Array.isArray(optimized) || optimized.length === 0) continue;
-      const paramPath = path3.join(dir, threadToParamPath(thread));
+      const paramPath = path5.join(dir, threadToParamPath(thread));
       writeFileSync4(paramPath, toYaml(optimized) + "\n");
     } catch {
     }
@@ -10700,7 +11243,7 @@ async function pull(flags) {
       const cleaned = stripFields(full, THREAD_EXCLUDE_FIELDS);
       const optimized = optimizeForLlm(cleaned);
       if (!optimized || Object.keys(optimized).length === 0) continue;
-      const metaPath = path3.join(dir, threadToMetaPath(thread));
+      const metaPath = path5.join(dir, threadToMetaPath(thread));
       writeFileSync4(metaPath, toYaml(optimized) + "\n");
     } catch {
     }
@@ -10716,9 +11259,9 @@ async function pull(flags) {
   writeIndex(dir, index);
   console.log(`Done. Pulled ${pulled} threads to ${dir}`);
 }
-async function push(flags, files) {
+async function push2(flags, files) {
   const startDir = flags.dir || ".";
-  const root = findEtlRoot(startDir);
+  const root = findProjectRoot(startDir);
   if (!root) {
     console.error('No .rpbi/config.json found. Run "rpbi etl pull" first.');
     process.exit(1);
@@ -10729,9 +11272,9 @@ async function push(flags, files) {
   const force = flags.force === "true";
   let filesToPush;
   if (files.length > 0) {
-    filesToPush = files.map((f) => path3.relative(root, path3.resolve(f)).replace(/\\/g, "/"));
+    filesToPush = files.map((f) => path5.relative(root, path5.resolve(f)).replace(/\\/g, "/"));
   } else {
-    filesToPush = detectModifiedFiles(root, index);
+    filesToPush = detectModifiedFiles3(root, index);
   }
   if (filesToPush.length === 0) {
     console.log("Nothing to push.");
@@ -10739,12 +11282,25 @@ async function push(flags, files) {
   }
   console.log(`Pushing ${filesToPush.length} file(s)...`);
   for (const relPath of filesToPush) {
-    const absPath = path3.join(root, relPath);
-    if (!fs5.existsSync(absPath)) {
-      console.log(`  Skipping ${relPath} (file not found)`);
+    const absPath = path5.join(root, relPath);
+    if (!fs7.existsSync(absPath)) {
+      const entry2 = indexMap.get(relPath);
+      if (entry2) {
+        try {
+          await etlService.delete(`threads/${entry2.id_thread}`);
+          const idx = index.indexOf(entry2);
+          if (idx !== -1) index.splice(idx, 1);
+          indexMap.delete(relPath);
+          console.log(`  Deleted: ${relPath}`);
+        } catch (err) {
+          console.error(`  Failed to delete ${relPath}: ${err instanceof Error ? err.message : err}`);
+        }
+      } else {
+        console.log(`  Skipping ${relPath} (file not found, not in index)`);
+      }
       continue;
     }
-    const localContent = fs5.readFileSync(absPath, "utf-8");
+    const localContent = fs7.readFileSync(absPath, "utf-8");
     const entry = indexMap.get(relPath);
     if (entry) {
       if (!force) {
@@ -10764,6 +11320,11 @@ async function push(flags, files) {
       }
       await etlService.post(`threadContent/${entry.id_thread}`, localContent);
       entry.hash = computeHash(localContent);
+      try {
+        const meta3 = await etlService.get(`threads/${entry.id_thread}`, { fields: ["date_created"] });
+        if (meta3?.date_created) entry.serverDate = meta3.date_created;
+      } catch {
+      }
       console.log(`  Updated: ${relPath}`);
     } else {
       const parts = relPath.split("/");
@@ -10785,7 +11346,8 @@ async function push(flags, files) {
           path: relPath,
           id_thread: newThread.id_thread,
           hash: computeHash(localContent),
-          type
+          type,
+          serverDate: newThread.date_created
         });
         console.log(`  Created: ${relPath} (thread #${newThread.id_thread})`);
       } else {
@@ -10793,18 +11355,18 @@ async function push(flags, files) {
       }
     }
   }
-  writeIndex(path3.resolve(root), index);
+  writeIndex(path5.resolve(root), index);
   console.log("Push complete.");
 }
 async function pullContext(dir, etlService, defService) {
-  const contextDir = path3.join(dir, ".rpbi", "context");
+  const contextDir = path5.join(dir, ".rpbi", "context");
   console.log("Pulling context (schema & modules)...");
   try {
     const modules2 = await defService.get("accountingModules");
     if (modules2) {
       const optimized = optimizeForLlm(modules2);
       writeFileSync4(
-        path3.join(contextDir, "modules.json"),
+        path5.join(contextDir, "modules.json"),
         JSON.stringify(optimized, null, 2)
       );
     }
@@ -10819,7 +11381,7 @@ async function pullContext(dir, etlService, defService) {
         if (!name) continue;
         const optimized = optimizeForLlm(item);
         writeFileSync4(
-          path3.join(contextDir, dirPath, `${name}.json`),
+          path5.join(contextDir, dirPath, `${name}.json`),
           JSON.stringify(optimized, null, 2)
         );
       }
@@ -10828,84 +11390,83 @@ async function pullContext(dir, etlService, defService) {
   }
 }
 async function context(flags) {
-  const dir = path3.resolve(flags.dir || ".");
+  const dir = path5.resolve(flags.dir || ".");
   const etlService = await createService("etl", { cwd: dir });
   const defService = await createService("definition", { cwd: dir });
   await pullContext(dir, etlService, defService);
   console.log("Context pull complete.");
 }
-function detectModifiedFiles(root, index) {
-  const modified = [];
-  for (const entry of index) {
-    const absPath = path3.join(root, entry.path);
-    if (!fs5.existsSync(absPath)) {
-      modified.push(entry.path);
-      continue;
-    }
-    const content2 = fs5.readFileSync(absPath, "utf-8");
-    if (computeHash(content2) !== entry.hash) {
-      modified.push(entry.path);
-    }
-  }
-  return modified;
-}
-function detectNewFiles(root, index) {
-  const newFiles = [];
-  const knownPaths = new Set(index.map((e) => e.path));
-  const entries = fs5.readdirSync(root, { withFileTypes: true });
-  for (const entry of entries) {
-    if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-    walkDir(path3.join(root, entry.name), root, knownPaths, newFiles);
-  }
-  return newFiles;
+function detectModifiedFiles3(root, index) {
+  return detectModifiedFiles(
+    root,
+    index,
+    (e) => e.path,
+    (absPath) => computeHash(fs7.readFileSync(absPath, "utf-8")),
+    (e) => e.hash
+  );
 }
-function walkDir(dir, root, knownPaths, result) {
-  const entries = fs5.readdirSync(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const full = path3.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      walkDir(full, root, knownPaths, result);
-    } else if (entry.name.endsWith(".sql")) {
-      const rel = path3.relative(root, full).replace(/\\/g, "/");
-      if (!knownPaths.has(rel)) {
-        result.push(rel);
-      }
-    }
-  }
+function detectNewFiles3(root, index) {
+  return detectNewFiles(root, index, (e) => e.path);
 }
-async function status2(flags) {
+async function status3(flags) {
   const startDir = flags.dir || ".";
-  const root = findEtlRoot(startDir);
+  const root = findProjectRoot(startDir);
   if (!root) {
     console.error('No .rpbi/config.json found. Run "rpbi etl pull" first.');
     process.exit(1);
   }
   const config2 = readConfig(root);
   const index = readIndex(root);
-  console.log(`ETL workspace: ${root}`);
-  console.log(`Domain: ${config2?.domain} | Accounting: ${config2?.accounting}`);
-  console.log(`Pulled at: ${config2?.pulledAt}`);
-  console.log("");
-  const modified = detectModifiedFiles(root, index);
-  const newFiles = detectNewFiles(root, index);
-  const deleted = modified.filter((f) => !fs5.existsSync(path3.join(root, f)));
-  const changed = modified.filter((f) => fs5.existsSync(path3.join(root, f)));
-  if (changed.length === 0 && newFiles.length === 0 && deleted.length === 0) {
-    console.log("No changes.");
-    return;
-  }
-  if (changed.length > 0) {
-    console.log("Modified:");
-    for (const f of changed) console.log(`  M ${f}`);
+  if (flags.remote === "true") {
+    return statusRemote2(root, config2, index, flags);
   }
-  if (newFiles.length > 0) {
-    console.log("New (untracked):");
-    for (const f of newFiles) console.log(`  + ${f}`);
+  const modified = detectModifiedFiles3(root, index);
+  const newFiles = detectNewFiles3(root, index);
+  printLocalStatus("ETL", root, config2, flags, modified, newFiles);
+}
+async function statusRemote2(root, config2, index, flags) {
+  const etlService = await createService("etl", { cwd: root });
+  const indexMap = new Map(index.map((e) => [e.path, e]));
+  const threads = await etlService.get("threads", {
+    fields: ["id_thread", "description", "type", "date_created"],
+    order: [["type", "asc"], ["description", "asc"]]
+  }) || [];
+  const modifiedLocally = [];
+  const modifiedOnServer = [];
+  const conflict = [];
+  const localOnly = [];
+  const serverOnly = [];
+  const serverPaths = /* @__PURE__ */ new Set();
+  for (const thread of threads) {
+    if (!thread.id_thread || !thread.type || !thread.description) continue;
+    const relPath = threadToRelPath(thread);
+    serverPaths.add(relPath);
+    const localEntry = indexMap.get(relPath);
+    if (!localEntry) {
+      serverOnly.push(relPath);
+    } else {
+      const absPath = path5.join(root, relPath);
+      const localChanged = fs7.existsSync(absPath) && computeHash(fs7.readFileSync(absPath, "utf-8")) !== localEntry.hash;
+      const serverChanged = thread.date_created != null && localEntry.serverDate != null && thread.date_created !== localEntry.serverDate;
+      if (localChanged && serverChanged) {
+        conflict.push(relPath);
+      } else if (localChanged) {
+        modifiedLocally.push(relPath);
+      } else if (serverChanged) {
+        modifiedOnServer.push(relPath);
+      }
+    }
   }
-  if (deleted.length > 0) {
-    console.log("Deleted locally:");
-    for (const f of deleted) console.log(`  - ${f}`);
+  for (const entry of index) {
+    if (!serverPaths.has(entry.path)) {
+      localOnly.push(entry.path);
+    }
   }
+  const newFiles = detectNewFiles3(root, index);
+  printRemoteStatus("ETL", root, config2, flags, { modifiedLocally, modifiedOnServer, conflict, new: newFiles, localOnly, serverOnly });
+}
+function watch4(flags) {
+  return watch2("etl", flags, push2);
 }
 
 // src/commands/etl.ts
@@ -10929,7 +11490,7 @@ async function exec2(id, flags) {
   const service = await createService("etl", { cwd: flags.dir || "." });
   let body = void 0;
   if (flags.file) {
-    body = fs6.readFileSync(flags.file, "utf-8");
+    body = fs8.readFileSync(flags.file, "utf-8");
   } else if (flags.sql) {
     body = flags.sql;
   }
@@ -10972,15 +11533,17 @@ async function etl(args) {
       }
       return search2(rest[0], flags);
     case "pull":
-      return pull(flags);
+      return pull2(flags);
     case "push":
-      return push(flags, rest);
+      return push2(flags, rest);
     case "context":
       return context(flags);
     case "status":
-      return status2(flags);
+      return status3(flags);
+    case "watch":
+      return watch4(flags);
     default:
-      console.log("Usage: rpbi etl <list|get|content|exec|search|pull|push|context|status> [options]");
+      console.log("Usage: rpbi etl <list|get|content|exec|search|pull|push|context|status|watch> [options]");
       break;
   }
 }
@@ -11684,8 +12247,8 @@ function getErrorMap() {
 
 // ../../.yarn/cache/zod-npm-4.3.6-a096e305e6-860d25a81a.zip/node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path5, errorMaps, issueData } = params;
-  const fullPath = [...path5, ...issueData.path || []];
+  const { data, path: path7, errorMaps, issueData } = params;
+  const fullPath = [...path7, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -11739,18 +12302,18 @@ var ParseStatus = class _ParseStatus {
     if (this.value !== "aborted")
       this.value = "aborted";
   }
-  static mergeArray(status3, results) {
+  static mergeArray(status4, results) {
     const arrayValue = [];
     for (const s of results) {
       if (s.status === "aborted")
         return INVALID;
       if (s.status === "dirty")
-        status3.dirty();
+        status4.dirty();
       arrayValue.push(s.value);
     }
-    return { status: status3.value, value: arrayValue };
+    return { status: status4.value, value: arrayValue };
   }
-  static async mergeObjectAsync(status3, pairs) {
+  static async mergeObjectAsync(status4, pairs) {
     const syncPairs = [];
     for (const pair of pairs) {
       const key = await pair.key;
@@ -11760,9 +12323,9 @@ var ParseStatus = class _ParseStatus {
         value
       });
     }
-    return _ParseStatus.mergeObjectSync(status3, syncPairs);
+    return _ParseStatus.mergeObjectSync(status4, syncPairs);
   }
-  static mergeObjectSync(status3, pairs) {
+  static mergeObjectSync(status4, pairs) {
     const finalObject = {};
     for (const pair of pairs) {
       const { key, value } = pair;
@@ -11771,14 +12334,14 @@ var ParseStatus = class _ParseStatus {
       if (value.status === "aborted")
         return INVALID;
       if (key.status === "dirty")
-        status3.dirty();
+        status4.dirty();
       if (value.status === "dirty")
-        status3.dirty();
+        status4.dirty();
       if (key.value !== "__proto__" && (typeof value.value !== "undefined" || pair.alwaysSet)) {
         finalObject[key.value] = value.value;
       }
     }
-    return { status: status3.value, value: finalObject };
+    return { status: status4.value, value: finalObject };
   }
 };
 var INVALID = Object.freeze({
@@ -11800,11 +12363,11 @@ var errorUtil;
 
 // ../../.yarn/cache/zod-npm-4.3.6-a096e305e6-860d25a81a.zip/node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path5, key) {
+  constructor(parent, value, path7, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path5;
+    this._path = path7;
     this._key = key;
   }
   get path() {
@@ -12238,7 +12801,7 @@ var ZodString = class _ZodString2 extends ZodType {
       });
       return INVALID;
     }
-    const status3 = new ParseStatus();
+    const status4 = new ParseStatus();
     let ctx = void 0;
     for (const check2 of this._def.checks) {
       if (check2.kind === "min") {
@@ -12252,7 +12815,7 @@ var ZodString = class _ZodString2 extends ZodType {
             exact: false,
             message: check2.message
           });
-          status3.dirty();
+          status4.dirty();
         }
       } else if (check2.kind === "max") {
         if (input.data.length > check2.value) {
@@ -12265,7 +12828,7 @@ var ZodString = class _ZodString2 extends ZodType {
             exact: false,
             message: check2.message
           });
-          status3.dirty();
+          status4.dirty();
         }
       } else if (check2.kind === "length") {
         const tooBig = input.data.length > check2.value;
@@ -12291,7 +12854,7 @@ var ZodString = class _ZodString2 extends ZodType {
               message: check2.message
             });
           }
-          status3.dirty();
+          status4.dirty();
         }
       } else if (check2.kind === "email") {
         if (!emailRegex.test(input.data)) {
@@ -12301,7 +12864,7 @@ var ZodString = class _ZodString2 extends ZodType {
             code: ZodIssueCode.invalid_string,
             message: check2.message
           });
-          status3.dirty();
+          status4.dirty();
         }
       } else if (check2.kind === "emoji") {
         if (!emojiRegex) {
@@ -12314,7 +12877,7 @@ var ZodString = class _ZodString2 extends ZodType {
             code: ZodIssueCode.invalid_string,
             message: check2.message
           });
-          status3.dirty();
+          status4.dirty();
         }
       } else if (check2.kind === "uuid") {
         if (!uuidRegex.test(input.data)) {
@@ -12324,7 +12887,7 @@ var ZodString = class _ZodString2 extends ZodType {
             code: ZodIssueCode.invalid_string,
             message: check2.message
           });
-          status3.dirty();
+          status4.dirty();
         }
       } else if (check2.kind === "nanoid") {
         if (!nanoidRegex.test(input.data)) {
@@ -12334,7 +12897,7 @@ var ZodString = class _ZodString2 extends ZodType {
             code: ZodIssueCode.invalid_string,
             message: check2.message
           });
-          status3.dirty();
+          status4.dirty();
         }
       } else if (check2.kind === "cuid") {
         if (!cuidRegex.test(input.data)) {
@@ -12344,7 +12907,7 @@ var ZodString = class _ZodString2 extends ZodType {
             code: ZodIssueCode.invalid_string,
             message: check2.message
           });
-          status3.dirty();
+          status4.dirty();
         }
       } else if (check2.kind === "cuid2") {
         if (!cuid2Regex.test(input.data)) {
@@ -12354,7 +12917,7 @@ var ZodString = class _ZodString2 extends ZodType {
             code: ZodIssueCode.invalid_string,
             message: check2.message
           });
-          status3.dirty();
+          status4.dirty();
         }
       } else if (check2.kind === "ulid") {
         if (!ulidRegex.test(input.data)) {
@@ -12364,7 +12927,7 @@ var ZodString = class _ZodString2 extends ZodType {
             code: ZodIssueCode.invalid_string,
             message: check2.message
           });
-          status3.dirty();
+          status4.dirty();
         }
       } else if (check2.kind === "url") {
         try {
@@ -12376,7 +12939,7 @@ var ZodString = class _ZodString2 extends ZodType {
             code: ZodIssueCode.invalid_string,
             message: check2.message
           });
-          status3.dirty();
+          status4.dirty();
         }
       } else if (check2.kind === "regex") {
         check2.regex.lastIndex = 0;
@@ -12388,7 +12951,7 @@ var ZodString = class _ZodString2 extends ZodType {
             code: ZodIssueCode.invalid_string,
             message: check2.message
           });
-          status3.dirty();
+          status4.dirty();
         }
       } else if (check2.kind === "trim") {
         input.data = input.data.trim();
@@ -12400,7 +12963,7 @@ var ZodString = class _ZodString2 extends ZodType {
             validation: { includes: check2.value, position: check2.position },
             message: check2.message
           });
-          status3.dirty();
+          status4.dirty();
         }
       } else if (check2.kind === "toLowerCase") {
         input.data = input.data.toLowerCase();
@@ -12414,7 +12977,7 @@ var ZodString = class _ZodString2 extends ZodType {
             validation: { startsWith: check2.value },
             message: check2.message
           });
-          status3.dirty();
+          status4.dirty();
         }
       } else if (check2.kind === "endsWith") {
         if (!input.data.endsWith(check2.value)) {
@@ -12424,7 +12987,7 @@ var ZodString = class _ZodString2 extends ZodType {
             validation: { endsWith: check2.value },
             message: check2.message
           });
-          status3.dirty();
+          status4.dirty();
         }
       } else if (check2.kind === "datetime") {
         const regex = datetimeRegex(check2);
@@ -12435,7 +12998,7 @@ var ZodString = class _ZodString2 extends ZodType {
             validation: "datetime",
             message: check2.message
           });
-          status3.dirty();
+          status4.dirty();
         }
       } else if (check2.kind === "date") {
         const regex = dateRegex;
@@ -12446,7 +13009,7 @@ var ZodString = class _ZodString2 extends ZodType {
             validation: "date",
             message: check2.message
           });
-          status3.dirty();
+          status4.dirty();
         }
       } else if (check2.kind === "time") {
         const regex = timeRegex(check2);
@@ -12457,7 +13020,7 @@ var ZodString = class _ZodString2 extends ZodType {
             validation: "time",
             message: check2.message
           });
-          status3.dirty();
+          status4.dirty();
         }
       } else if (check2.kind === "duration") {
         if (!durationRegex.test(input.data)) {
@@ -12467,7 +13030,7 @@ var ZodString = class _ZodString2 extends ZodType {
             code: ZodIssueCode.invalid_string,
             message: check2.message
           });
-          status3.dirty();
+          status4.dirty();
         }
       } else if (check2.kind === "ip") {
         if (!isValidIP(input.data, check2.version)) {
@@ -12477,7 +13040,7 @@ var ZodString = class _ZodString2 extends ZodType {
             code: ZodIssueCode.invalid_string,
             message: check2.message
           });
-          status3.dirty();
+          status4.dirty();
         }
       } else if (check2.kind === "jwt") {
         if (!isValidJWT(input.data, check2.alg)) {
@@ -12487,7 +13050,7 @@ var ZodString = class _ZodString2 extends ZodType {
             code: ZodIssueCode.invalid_string,
             message: check2.message
           });
-          status3.dirty();
+          status4.dirty();
         }
       } else if (check2.kind === "cidr") {
         if (!isValidCidr(input.data, check2.version)) {
@@ -12497,7 +13060,7 @@ var ZodString = class _ZodString2 extends ZodType {
             code: ZodIssueCode.invalid_string,
             message: check2.message
           });
-          status3.dirty();
+          status4.dirty();
         }
       } else if (check2.kind === "base64") {
         if (!base64Regex.test(input.data)) {
@@ -12507,7 +13070,7 @@ var ZodString = class _ZodString2 extends ZodType {
             code: ZodIssueCode.invalid_string,
             message: check2.message
           });
-          status3.dirty();
+          status4.dirty();
         }
       } else if (check2.kind === "base64url") {
         if (!base64urlRegex.test(input.data)) {
@@ -12517,13 +13080,13 @@ var ZodString = class _ZodString2 extends ZodType {
             code: ZodIssueCode.invalid_string,
             message: check2.message
           });
-          status3.dirty();
+          status4.dirty();
         }
       } else {
         util.assertNever(check2);
       }
     }
-    return { status: status3.value, value: input.data };
+    return { status: status4.value, value: input.data };
   }
   _regex(regex, validation, message) {
     return this.refinement((data) => regex.test(data), {
@@ -12799,7 +13362,7 @@ var ZodNumber = class _ZodNumber extends ZodType {
       return INVALID;
     }
     let ctx = void 0;
-    const status3 = new ParseStatus();
+    const status4 = new ParseStatus();
     for (const check2 of this._def.checks) {
       if (check2.kind === "int") {
         if (!util.isInteger(input.data)) {
@@ -12810,7 +13373,7 @@ var ZodNumber = class _ZodNumber extends ZodType {
             received: "float",
             message: check2.message
           });
-          status3.dirty();
+          status4.dirty();
         }
       } else if (check2.kind === "min") {
         const tooSmall = check2.inclusive ? input.data < check2.value : input.data <= check2.value;
@@ -12824,7 +13387,7 @@ var ZodNumber = class _ZodNumber extends ZodType {
             exact: false,
             message: check2.message
           });
-          status3.dirty();
+          status4.dirty();
         }
       } else if (check2.kind === "max") {
         const tooBig = check2.inclusive ? input.data > check2.value : input.data >= check2.value;
@@ -12838,7 +13401,7 @@ var ZodNumber = class _ZodNumber extends ZodType {
             exact: false,
             message: check2.message
           });
-          status3.dirty();
+          status4.dirty();
         }
       } else if (check2.kind === "multipleOf") {
         if (floatSafeRemainder(input.data, check2.value) !== 0) {
@@ -12848,7 +13411,7 @@ var ZodNumber = class _ZodNumber extends ZodType {
             multipleOf: check2.value,
             message: check2.message
           });
-          status3.dirty();
+          status4.dirty();
         }
       } else if (check2.kind === "finite") {
         if (!Number.isFinite(input.data)) {
@@ -12857,13 +13420,13 @@ var ZodNumber = class _ZodNumber extends ZodType {
             code: ZodIssueCode.not_finite,
             message: check2.message
           });
-          status3.dirty();
+          status4.dirty();
         }
       } else {
         util.assertNever(check2);
       }
     }
-    return { status: status3.value, value: input.data };
+    return { status: status4.value, value: input.data };
   }
   gte(value, message) {
     return this.setLimit("min", value, true, errorUtil.toString(message));
@@ -13028,7 +13591,7 @@ var ZodBigInt = class _ZodBigInt extends ZodType {
       return this._getInvalidInput(input);
     }
     let ctx = void 0;
-    const status3 = new ParseStatus();
+    const status4 = new ParseStatus();
     for (const check2 of this._def.checks) {
       if (check2.kind === "min") {
         const tooSmall = check2.inclusive ? input.data < check2.value : input.data <= check2.value;
@@ -13041,7 +13604,7 @@ var ZodBigInt = class _ZodBigInt extends ZodType {
             inclusive: check2.inclusive,
             message: check2.message
           });
-          status3.dirty();
+          status4.dirty();
         }
       } else if (check2.kind === "max") {
         const tooBig = check2.inclusive ? input.data > check2.value : input.data >= check2.value;
@@ -13054,7 +13617,7 @@ var ZodBigInt = class _ZodBigInt extends ZodType {
             inclusive: check2.inclusive,
             message: check2.message
           });
-          status3.dirty();
+          status4.dirty();
         }
       } else if (check2.kind === "multipleOf") {
         if (input.data % check2.value !== BigInt(0)) {
@@ -13064,13 +13627,13 @@ var ZodBigInt = class _ZodBigInt extends ZodType {
             multipleOf: check2.value,
             message: check2.message
           });
-          status3.dirty();
+          status4.dirty();
         }
       } else {
         util.assertNever(check2);
       }
     }
-    return { status: status3.value, value: input.data };
+    return { status: status4.value, value: input.data };
   }
   _getInvalidInput(input) {
     const ctx = this._getOrReturnCtx(input);
@@ -13228,7 +13791,7 @@ var ZodDate = class _ZodDate extends ZodType {
       });
       return INVALID;
     }
-    const status3 = new ParseStatus();
+    const status4 = new ParseStatus();
     let ctx = void 0;
     for (const check2 of this._def.checks) {
       if (check2.kind === "min") {
@@ -13242,7 +13805,7 @@ var ZodDate = class _ZodDate extends ZodType {
             minimum: check2.value,
             type: "date"
           });
-          status3.dirty();
+          status4.dirty();
         }
       } else if (check2.kind === "max") {
         if (input.data.getTime() > check2.value) {
@@ -13255,14 +13818,14 @@ var ZodDate = class _ZodDate extends ZodType {
             maximum: check2.value,
             type: "date"
           });
-          status3.dirty();
+          status4.dirty();
         }
       } else {
         util.assertNever(check2);
       }
     }
     return {
-      status: status3.value,
+      status: status4.value,
       value: new Date(input.data.getTime())
     };
   }
@@ -13448,7 +14011,7 @@ ZodVoid.create = (params) => {
 };
 var ZodArray = class _ZodArray extends ZodType {
   _parse(input) {
-    const { ctx, status: status3 } = this._processInputParams(input);
+    const { ctx, status: status4 } = this._processInputParams(input);
     const def2 = this._def;
     if (ctx.parsedType !== ZodParsedType.array) {
       addIssueToContext(ctx, {
@@ -13471,7 +14034,7 @@ var ZodArray = class _ZodArray extends ZodType {
           exact: true,
           message: def2.exactLength.message
         });
-        status3.dirty();
+        status4.dirty();
       }
     }
     if (def2.minLength !== null) {
@@ -13484,7 +14047,7 @@ var ZodArray = class _ZodArray extends ZodType {
           exact: false,
           message: def2.minLength.message
         });
-        status3.dirty();
+        status4.dirty();
       }
     }
     if (def2.maxLength !== null) {
@@ -13497,20 +14060,20 @@ var ZodArray = class _ZodArray extends ZodType {
           exact: false,
           message: def2.maxLength.message
         });
-        status3.dirty();
+        status4.dirty();
       }
     }
     if (ctx.common.async) {
       return Promise.all([...ctx.data].map((item, i) => {
         return def2.type._parseAsync(new ParseInputLazyPath(ctx, item, ctx.path, i));
       })).then((result2) => {
-        return ParseStatus.mergeArray(status3, result2);
+        return ParseStatus.mergeArray(status4, result2);
       });
     }
     const result = [...ctx.data].map((item, i) => {
       return def2.type._parseSync(new ParseInputLazyPath(ctx, item, ctx.path, i));
     });
-    return ParseStatus.mergeArray(status3, result);
+    return ParseStatus.mergeArray(status4, result);
   }
   get element() {
     return this._def.type;
@@ -13599,7 +14162,7 @@ var ZodObject = class _ZodObject extends ZodType {
       });
       return INVALID;
     }
-    const { status: status3, ctx } = this._processInputParams(input);
+    const { status: status4, ctx } = this._processInputParams(input);
     const { shape, keys: shapeKeys } = this._getCached();
     const extraKeys = [];
     if (!(this._def.catchall instanceof ZodNever && this._def.unknownKeys === "strip")) {
@@ -13634,7 +14197,7 @@ var ZodObject = class _ZodObject extends ZodType {
             code: ZodIssueCode.unrecognized_keys,
             keys: extraKeys
           });
-          status3.dirty();
+          status4.dirty();
         }
       } else if (unknownKeys === "strip") {
       } else {
@@ -13668,10 +14231,10 @@ var ZodObject = class _ZodObject extends ZodType {
         }
         return syncPairs;
       }).then((syncPairs) => {
-        return ParseStatus.mergeObjectSync(status3, syncPairs);
+        return ParseStatus.mergeObjectSync(status4, syncPairs);
       });
     } else {
-      return ParseStatus.mergeObjectSync(status3, pairs);
+      return ParseStatus.mergeObjectSync(status4, pairs);
     }
   }
   get shape() {
@@ -14149,7 +14712,7 @@ function mergeValues(a, b) {
 }
 var ZodIntersection = class extends ZodType {
   _parse(input) {
-    const { status: status3, ctx } = this._processInputParams(input);
+    const { status: status4, ctx } = this._processInputParams(input);
     const handleParsed = (parsedLeft, parsedRight) => {
       if (isAborted(parsedLeft) || isAborted(parsedRight)) {
         return INVALID;
@@ -14162,9 +14725,9 @@ var ZodIntersection = class extends ZodType {
         return INVALID;
       }
       if (isDirty(parsedLeft) || isDirty(parsedRight)) {
-        status3.dirty();
+        status4.dirty();
       }
-      return { status: status3.value, value: merged.data };
+      return { status: status4.value, value: merged.data };
     };
     if (ctx.common.async) {
       return Promise.all([
@@ -14202,7 +14765,7 @@ ZodIntersection.create = (left, right, params) => {
 };
 var ZodTuple = class _ZodTuple extends ZodType {
   _parse(input) {
-    const { status: status3, ctx } = this._processInputParams(input);
+    const { status: status4, ctx } = this._processInputParams(input);
     if (ctx.parsedType !== ZodParsedType.array) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
@@ -14230,7 +14793,7 @@ var ZodTuple = class _ZodTuple extends ZodType {
         exact: false,
         type: "array"
       });
-      status3.dirty();
+      status4.dirty();
     }
     const items = [...ctx.data].map((item, itemIndex) => {
       const schema = this._def.items[itemIndex] || this._def.rest;
@@ -14240,10 +14803,10 @@ var ZodTuple = class _ZodTuple extends ZodType {
     }).filter((x) => !!x);
     if (ctx.common.async) {
       return Promise.all(items).then((results) => {
-        return ParseStatus.mergeArray(status3, results);
+        return ParseStatus.mergeArray(status4, results);
       });
     } else {
-      return ParseStatus.mergeArray(status3, items);
+      return ParseStatus.mergeArray(status4, items);
     }
   }
   get items() {
@@ -14275,7 +14838,7 @@ var ZodRecord = class _ZodRecord extends ZodType {
     return this._def.valueType;
   }
   _parse(input) {
-    const { status: status3, ctx } = this._processInputParams(input);
+    const { status: status4, ctx } = this._processInputParams(input);
     if (ctx.parsedType !== ZodParsedType.object) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
@@ -14295,9 +14858,9 @@ var ZodRecord = class _ZodRecord extends ZodType {
       });
     }
     if (ctx.common.async) {
-      return ParseStatus.mergeObjectAsync(status3, pairs);
+      return ParseStatus.mergeObjectAsync(status4, pairs);
     } else {
-      return ParseStatus.mergeObjectSync(status3, pairs);
+      return ParseStatus.mergeObjectSync(status4, pairs);
     }
   }
   get element() {
@@ -14328,7 +14891,7 @@ var ZodMap = class extends ZodType {
     return this._def.valueType;
   }
   _parse(input) {
-    const { status: status3, ctx } = this._processInputParams(input);
+    const { status: status4, ctx } = this._processInputParams(input);
     if (ctx.parsedType !== ZodParsedType.map) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
@@ -14355,11 +14918,11 @@ var ZodMap = class extends ZodType {
             return INVALID;
           }
           if (key.status === "dirty" || value.status === "dirty") {
-            status3.dirty();
+            status4.dirty();
           }
           finalMap.set(key.value, value.value);
         }
-        return { status: status3.value, value: finalMap };
+        return { status: status4.value, value: finalMap };
       });
     } else {
       const finalMap = /* @__PURE__ */ new Map();
@@ -14370,11 +14933,11 @@ var ZodMap = class extends ZodType {
           return INVALID;
         }
         if (key.status === "dirty" || value.status === "dirty") {
-          status3.dirty();
+          status4.dirty();
         }
         finalMap.set(key.value, value.value);
       }
-      return { status: status3.value, value: finalMap };
+      return { status: status4.value, value: finalMap };
     }
   }
 };
@@ -14388,7 +14951,7 @@ ZodMap.create = (keyType, valueType, params) => {
 };
 var ZodSet = class _ZodSet extends ZodType {
   _parse(input) {
-    const { status: status3, ctx } = this._processInputParams(input);
+    const { status: status4, ctx } = this._processInputParams(input);
     if (ctx.parsedType !== ZodParsedType.set) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
@@ -14408,7 +14971,7 @@ var ZodSet = class _ZodSet extends ZodType {
           exact: false,
           message: def2.minSize.message
         });
-        status3.dirty();
+        status4.dirty();
       }
     }
     if (def2.maxSize !== null) {
@@ -14421,7 +14984,7 @@ var ZodSet = class _ZodSet extends ZodType {
           exact: false,
           message: def2.maxSize.message
         });
-        status3.dirty();
+        status4.dirty();
       }
     }
     const valueType = this._def.valueType;
@@ -14431,10 +14994,10 @@ var ZodSet = class _ZodSet extends ZodType {
         if (element.status === "aborted")
           return INVALID;
         if (element.status === "dirty")
-          status3.dirty();
+          status4.dirty();
         parsedSet.add(element.value);
       }
-      return { status: status3.value, value: parsedSet };
+      return { status: status4.value, value: parsedSet };
     }
     const elements = [...ctx.data.values()].map((item, i) => valueType._parse(new ParseInputLazyPath(ctx, item, ctx.path, i)));
     if (ctx.common.async) {
@@ -14765,15 +15328,15 @@ var ZodEffects = class extends ZodType {
     return this._def.schema._def.typeName === ZodFirstPartyTypeKind.ZodEffects ? this._def.schema.sourceType() : this._def.schema;
   }
   _parse(input) {
-    const { status: status3, ctx } = this._processInputParams(input);
+    const { status: status4, ctx } = this._processInputParams(input);
     const effect = this._def.effect || null;
     const checkCtx = {
       addIssue: (arg) => {
         addIssueToContext(ctx, arg);
         if (arg.fatal) {
-          status3.abort();
+          status4.abort();
         } else {
-          status3.dirty();
+          status4.dirty();
         }
       },
       get path() {
@@ -14785,7 +15348,7 @@ var ZodEffects = class extends ZodType {
       const processed = effect.transform(ctx.data, checkCtx);
       if (ctx.common.async) {
         return Promise.resolve(processed).then(async (processed2) => {
-          if (status3.value === "aborted")
+          if (status4.value === "aborted")
             return INVALID;
           const result = await this._def.schema._parseAsync({
             data: processed2,
@@ -14796,12 +15359,12 @@ var ZodEffects = class extends ZodType {
             return INVALID;
           if (result.status === "dirty")
             return DIRTY(result.value);
-          if (status3.value === "dirty")
+          if (status4.value === "dirty")
             return DIRTY(result.value);
           return result;
         });
       } else {
-        if (status3.value === "aborted")
+        if (status4.value === "aborted")
           return INVALID;
         const result = this._def.schema._parseSync({
           data: processed,
@@ -14812,7 +15375,7 @@ var ZodEffects = class extends ZodType {
           return INVALID;
         if (result.status === "dirty")
           return DIRTY(result.value);
-        if (status3.value === "dirty")
+        if (status4.value === "dirty")
           return DIRTY(result.value);
         return result;
       }
@@ -14837,17 +15400,17 @@ var ZodEffects = class extends ZodType {
         if (inner.status === "aborted")
           return INVALID;
         if (inner.status === "dirty")
-          status3.dirty();
+          status4.dirty();
         executeRefinement(inner.value);
-        return { status: status3.value, value: inner.value };
+        return { status: status4.value, value: inner.value };
       } else {
         return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((inner) => {
           if (inner.status === "aborted")
             return INVALID;
           if (inner.status === "dirty")
-            status3.dirty();
+            status4.dirty();
           return executeRefinement(inner.value).then(() => {
-            return { status: status3.value, value: inner.value };
+            return { status: status4.value, value: inner.value };
           });
         });
       }
@@ -14865,13 +15428,13 @@ var ZodEffects = class extends ZodType {
         if (result instanceof Promise) {
           throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`);
         }
-        return { status: status3.value, value: result };
+        return { status: status4.value, value: result };
       } else {
         return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((base) => {
           if (!isValid(base))
             return INVALID;
           return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({
-            status: status3.value,
+            status: status4.value,
             value: result
           }));
         });
@@ -15050,7 +15613,7 @@ var ZodBranded = class extends ZodType {
 };
 var ZodPipeline = class _ZodPipeline extends ZodType {
   _parse(input) {
-    const { status: status3, ctx } = this._processInputParams(input);
+    const { status: status4, ctx } = this._processInputParams(input);
     if (ctx.common.async) {
       const handleAsync = async () => {
         const inResult = await this._def.in._parseAsync({
@@ -15061,7 +15624,7 @@ var ZodPipeline = class _ZodPipeline extends ZodType {
         if (inResult.status === "aborted")
           return INVALID;
         if (inResult.status === "dirty") {
-          status3.dirty();
+          status4.dirty();
           return DIRTY(inResult.value);
         } else {
           return this._def.out._parseAsync({
@@ -15081,7 +15644,7 @@ var ZodPipeline = class _ZodPipeline extends ZodType {
       if (inResult.status === "aborted")
         return INVALID;
       if (inResult.status === "dirty") {
-        status3.dirty();
+        status4.dirty();
         return {
           status: "dirty",
           value: inResult.value
@@ -15728,10 +16291,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path5) {
-  if (!path5)
+function getElementAtPath(obj, path7) {
+  if (!path7)
     return obj;
-  return path5.reduce((acc, key) => acc?.[key], obj);
+  return path7.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -16114,11 +16677,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path5, issues) {
+function prefixIssues(path7, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path5);
+    iss.path.unshift(path7);
     return iss;
   });
 }
@@ -16301,7 +16864,7 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error49, path5 = []) => {
+  const processError = (error49, path7 = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -16311,7 +16874,7 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path5, ...issue2.path];
+        const fullpath = [...path7, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -16343,8 +16906,8 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path5 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path5) {
+  const path7 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path7) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -28750,13 +29313,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path5 = ref.slice(1).split("/").filter(Boolean);
-  if (path5.length === 0) {
+  const path7 = ref.slice(1).split("/").filter(Boolean);
+  if (path7.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path5[0] === defsKey) {
-    const key = path5[1];
+  if (path7[0] === defsKey) {
+    const key = path7[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -30677,8 +31240,8 @@ var UrlElicitationRequiredError = class extends McpError {
 };
 
 // ../../.yarn/__virtual__/@modelcontextprotocol-sdk-virtual-4beea6215a/0/cache/@modelcontextprotocol-sdk-npm-1.26.0-380479a6f8-b4098789d9.zip/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/interfaces.js
-function isTerminal(status3) {
-  return status3 === "completed" || status3 === "failed" || status3 === "cancelled";
+function isTerminal(status4) {
+  return status4 === "completed" || status4 === "failed" || status4 === "cancelled";
 }
 
 // ../../.yarn/__virtual__/zod-to-json-schema-virtual-00ec010bf6/0/cache/zod-to-json-schema-npm-3.25.1-850d9216b4-711b30e34d.zip/node_modules/zod-to-json-schema/dist/esm/Options.js
@@ -32501,7 +33064,7 @@ var Protocol = class {
           return;
         }
         const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
-        await new Promise((resolve4) => setTimeout(resolve4, pollInterval));
+        await new Promise((resolve5) => setTimeout(resolve5, pollInterval));
         options?.signal?.throwIfAborted();
       }
     } catch (error48) {
@@ -32518,7 +33081,7 @@ var Protocol = class {
    */
   request(request, resultSchema, options) {
     const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve5, reject) => {
       const earlyReject = (error48) => {
         reject(error48);
       };
@@ -32596,7 +33159,7 @@ var Protocol = class {
           if (!parseResult.success) {
             reject(parseResult.error);
           } else {
-            resolve4(parseResult.data);
+            resolve5(parseResult.data);
           }
         } catch (error48) {
           reject(error48);
@@ -32857,12 +33420,12 @@ var Protocol = class {
       }
     } catch {
     }
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve5, reject) => {
       if (signal.aborted) {
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
         return;
       }
-      const timeoutId = setTimeout(resolve4, interval);
+      const timeoutId = setTimeout(resolve5, interval);
       signal.addEventListener("abort", () => {
         clearTimeout(timeoutId);
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
@@ -32891,8 +33454,8 @@ var Protocol = class {
         }
         return task;
       },
-      storeTaskResult: async (taskId, status3, result) => {
-        await taskStore.storeTaskResult(taskId, status3, result, sessionId);
+      storeTaskResult: async (taskId, status4, result) => {
+        await taskStore.storeTaskResult(taskId, status4, result, sessionId);
         const task = await taskStore.getTask(taskId, sessionId);
         if (task) {
           const notification = TaskStatusNotificationSchema.parse({
@@ -32908,15 +33471,15 @@ var Protocol = class {
       getTaskResult: (taskId) => {
         return taskStore.getTaskResult(taskId, sessionId);
       },
-      updateTaskStatus: async (taskId, status3, statusMessage) => {
+      updateTaskStatus: async (taskId, status4, statusMessage) => {
         const task = await taskStore.getTask(taskId, sessionId);
         if (!task) {
           throw new McpError(ErrorCode.InvalidParams, `Task "${taskId}" not found - it may have been cleaned up`);
         }
         if (isTerminal(task.status)) {
-          throw new McpError(ErrorCode.InvalidParams, `Cannot update task "${taskId}" from terminal status "${task.status}" to "${status3}". Terminal states (completed, failed, cancelled) cannot transition to other states.`);
+          throw new McpError(ErrorCode.InvalidParams, `Cannot update task "${taskId}" from terminal status "${task.status}" to "${status4}". Terminal states (completed, failed, cancelled) cannot transition to other states.`);
         }
-        await taskStore.updateTaskStatus(taskId, status3, statusMessage, sessionId);
+        await taskStore.updateTaskStatus(taskId, status4, statusMessage, sessionId);
         const updatedTask = await taskStore.getTask(taskId, sessionId);
         if (updatedTask) {
           const notification = TaskStatusNotificationSchema.parse({
@@ -33821,7 +34384,7 @@ var McpServer = class {
     let task = createTaskResult.task;
     const pollInterval = task.pollInterval ?? 5e3;
     while (task.status !== "completed" && task.status !== "failed" && task.status !== "cancelled") {
-      await new Promise((resolve4) => setTimeout(resolve4, pollInterval));
+      await new Promise((resolve5) => setTimeout(resolve5, pollInterval));
       const updatedTask = await extra.taskStore.getTask(taskId);
       if (!updatedTask) {
         throw new McpError(ErrorCode.InternalError, `Task ${taskId} not found during polling`);
@@ -34464,12 +35027,12 @@ var StdioServerTransport = class {
     this.onclose?.();
   }
   send(message) {
-    return new Promise((resolve4) => {
+    return new Promise((resolve5) => {
       const json3 = serializeMessage(message);
       if (this._stdout.write(json3)) {
-        resolve4();
+        resolve5();
       } else {
-        this._stdout.once("drain", resolve4);
+        this._stdout.once("drain", resolve5);
       }
     });
   }
@@ -34509,7 +35072,7 @@ function text(data) {
 async function mcp() {
   const server = new McpServer({
     name: "reporting-bi",
-    version: "0.1.1"
+    version: "0.1.3"
   });
   server.tool(
     "status",
@@ -34960,9 +35523,11 @@ function init(args) {
     process.exit(1);
   }
   const existing = readConfig(process.cwd());
+  const type = flags.type || existing?.type;
   const config2 = {
     domain: domain2,
     accounting: flags.accounting ? parseInt(flags.accounting) : existing?.accounting ?? creds.connections[domain2].accounting ?? 0,
+    ...type && { type },
     ...existing?.pulledAt && { pulledAt: existing.pulledAt }
   };
   writeConfig(process.cwd(), config2);
@@ -34972,20 +35537,20 @@ function init(args) {
 }
 
 // src/autoupdate.ts
-var fs7 = __toESM(require("node:fs"));
-var path4 = __toESM(require("node:path"));
+var fs9 = __toESM(require("node:fs"));
+var path6 = __toESM(require("node:path"));
 var os3 = __toESM(require("node:os"));
 var https = __toESM(require("node:https"));
 var import_node_child_process3 = require("node:child_process");
-var CONFIG_DIR2 = path4.join(os3.homedir(), ".config", "reporting-bi");
-var UPDATE_CHECK_FILE = path4.join(CONFIG_DIR2, "update-check.json");
+var CONFIG_DIR2 = path6.join(os3.homedir(), ".config", "reporting-bi");
+var UPDATE_CHECK_FILE = path6.join(CONFIG_DIR2, "update-check.json");
 var CHECK_INTERVAL = 60 * 60 * 1e3;
 var PACKAGE_NAME = "@reporting-bi/cli";
 var INSTALL_PREFIX = detectPrefix();
 function detectPrefix() {
   try {
-    const realPath = fs7.realpathSync(process.argv[1]);
-    const libIndex = realPath.indexOf(path4.join("lib", "node_modules"));
+    const realPath = fs9.realpathSync(process.argv[1]);
+    const libIndex = realPath.indexOf(path6.join("lib", "node_modules"));
     if (libIndex > 0) {
       const prefix = realPath.slice(0, libIndex - 1);
       if (prefix !== "/usr" && prefix !== "/usr/local") return prefix;
@@ -35000,36 +35565,36 @@ function npmInstallCmd(version2) {
 }
 function loadUpdateCheck() {
   try {
-    return JSON.parse(fs7.readFileSync(UPDATE_CHECK_FILE, "utf-8"));
+    return JSON.parse(fs9.readFileSync(UPDATE_CHECK_FILE, "utf-8"));
   } catch {
     return { lastCheck: 0 };
   }
 }
 function saveUpdateCheck(data) {
-  fs7.mkdirSync(CONFIG_DIR2, { recursive: true });
-  fs7.writeFileSync(UPDATE_CHECK_FILE, JSON.stringify(data, null, 2));
+  fs9.mkdirSync(CONFIG_DIR2, { recursive: true });
+  fs9.writeFileSync(UPDATE_CHECK_FILE, JSON.stringify(data, null, 2));
 }
 function fetchLatestVersion() {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     const req = https.get(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`, { timeout: 5e3 }, (res) => {
       if (res.statusCode !== 200) {
         res.resume();
-        return resolve4(null);
+        return resolve5(null);
       }
       let body = "";
       res.on("data", (chunk) => body += chunk);
       res.on("end", () => {
         try {
-          resolve4(JSON.parse(body).version ?? null);
+          resolve5(JSON.parse(body).version ?? null);
         } catch {
-          resolve4(null);
+          resolve5(null);
         }
       });
     });
-    req.on("error", () => resolve4(null));
+    req.on("error", () => resolve5(null));
     req.on("timeout", () => {
       req.destroy();
-      resolve4(null);
+      resolve5(null);
     });
   });
 }
@@ -35053,8 +35618,8 @@ async function checkForUpdate() {
     saveUpdateCheck({ lastCheck: now });
     const latest = await fetchLatestVersion();
     if (!latest) return;
-    if (!isNewer(latest, "0.1.1")) return;
-    console.log(`\x1B[33mUpdating ${PACKAGE_NAME} ${"0.1.1"} \u2192 ${latest}...\x1B[0m`);
+    if (!isNewer(latest, "0.1.3")) return;
+    console.log(`\x1B[33mUpdating ${PACKAGE_NAME} ${"0.1.3"} \u2192 ${latest}...\x1B[0m`);
     (0, import_node_child_process3.execSync)(npmInstallCmd(latest), { stdio: "inherit" });
     console.log(`\x1B[32mUpdated to ${latest}.\x1B[0m`);
   } catch {
@@ -35066,11 +35631,11 @@ async function forceUpdate() {
     console.error("Could not fetch latest version from npm.");
     process.exit(1);
   }
-  if (!isNewer(latest, "0.1.1")) {
-    console.log(`Already up to date (${"0.1.1"}).`);
+  if (!isNewer(latest, "0.1.3")) {
+    console.log(`Already up to date (${"0.1.3"}).`);
     return;
   }
-  console.log(`Updating ${PACKAGE_NAME} ${"0.1.1"} \u2192 ${latest}...`);
+  console.log(`Updating ${PACKAGE_NAME} ${"0.1.3"} \u2192 ${latest}...`);
   (0, import_node_child_process3.execSync)(npmInstallCmd(latest), { stdio: "inherit" });
   console.log(`\x1B[32mUpdated to ${latest}.\x1B[0m`);
   saveUpdateCheck({ lastCheck: Date.now() });
@@ -35086,7 +35651,7 @@ Commands:
   logout [domain]                       Logout and revoke tokens (default: active connection)
   use <domain> [--accounting <id>]      Switch active connection and/or set accounting
   status                                Show all connections and active status
-  init [--connection <domain>] [--accounting <id>]  Initialize .rpbi/config.json in current directory
+  init [--connection <domain>] [--accounting <id>] [--type etl|wiki]  Initialize .rpbi/config.json in current directory
   update                                Force update to latest version from npm
   mcp                                   Start MCP server (for AI agents, stdio transport)
 
@@ -35101,8 +35666,9 @@ ETL:
   etl search <query>                    Search threads
   etl pull [--dir <path>] [--no-context]  Pull all ETL threads, parameters, metadata & schema to local files
   etl push [files...] [--dir <path>] [--force]  Push modified/new .sql files back to server
-  etl status [--dir <path>]             Show local changes (modified, new, deleted)
+  etl status [--dir <path>] [--remote] [--json]  Show local changes (--remote compares with server)
   etl context [--dir <path>]            Pull context only (schema & modules)
+  etl watch [--dir <path>] [--debounce <ms>]  Watch for file changes and auto-push (default debounce: 500ms)
 
 Jobs:
   jobs list                             List available jobs
@@ -35152,6 +35718,10 @@ Wiki:
   wiki search <query>                   Search pages
   wiki save [id] [--lang cs] [--name n] Save/create a page (content from --file, --content, or stdin)
   wiki delete <id> [--lang cs]          Delete a page
+  wiki pull [--dir <path>] [--langs cs,en]  Pull all wiki pages & files to local directory
+  wiki push [files...] [--dir <path>] [--force]  Push modified/new pages & files back to server
+  wiki status [--dir <path>] [--remote] [--json]  Show local changes (--remote compares with server)
+  wiki watch [--dir <path>] [--debounce <ms>]  Watch for file changes and auto-push (default debounce: 500ms)
 
 Global options:
   --json                                Output raw JSON instead of table format
@@ -35160,6 +35730,7 @@ Global options:
   --limit <n>                           Limit to N results
   --sort <col>[,col2,...]               Sort by columns (prefix with - for desc)
   --filter <expression>                 Filter results (server-side where clause)
+  --verbose                             Show API request URLs for debugging
 
 Default domain: https://reporting.bi
 Default language: cs
@@ -35202,13 +35773,19 @@ Examples:
   rpbi wiki search "query"
   rpbi wiki save 42 --file ./page.md
   cat doc.md | rpbi wiki save 42
+  rpbi wiki pull
+  rpbi wiki push
+  rpbi wiki status --remote
+
+  rpbi etl watch
+  rpbi wiki watch --debounce 1000
 `;
 
 // src/index.ts
 (async () => {
   const [command, ...args] = process.argv.slice(2);
   if (command === "--version" || command === "-v") {
-    console.log("0.1.1");
+    console.log("0.1.3");
     return;
   }
   await checkForUpdate();