@jango-blockchained/hoox-cli 0.9.4 → 0.9.5

package/dist/index.js

@@ -24114,798 +24114,1186 @@ var init_config2 = __esm(() => {
   init_config_service();
 });
 
-// src/services/kv/kv-sync-service.ts
-var exports_kv_sync_service = {};
-__export(exports_kv_sync_service, {
-  KvSyncService: () => KvSyncService
-});
+// src/services/cloudflare/cloudflare-service.ts
+import path3 from "path";
 
-class KvSyncService {
-  async resolveNamespaceId(namespaceId) {
-    if (namespaceId)
-      return namespaceId;
+class CloudflareService {
+  cwd;
+  homeDir;
+  configService;
+  constructor(cwd, homeDir, configService) {
+    this.cwd = cwd ?? process.cwd();
+    this.homeDir = homeDir;
+    this.configService = configService ?? (this.homeDir ? new ConfigService(undefined, this.homeDir) : undefined);
+  }
+  resolveWorkerPath(workerPath) {
+    if (this.configService) {
+      const workerName = path3.basename(workerPath);
+      return this.configService.getWorkerPath(workerName);
+    }
+    if (this.homeDir) {
+      const workerName = path3.basename(workerPath);
+      return path3.join(this.homeDir, ".hoox", "workers", workerName);
+    }
+    return path3.resolve(this.cwd, workerPath);
+  }
+  async runWrangler(args, cwd) {
     try {
-      const proc = Bun.spawn(["wrangler", "kv", "namespace", "list"], {
+      const proc = Bun.spawn(["wrangler", ...args], {
+        cwd: cwd ?? this.cwd,
         stdout: "pipe",
         stderr: "pipe"
       });
       const stdout2 = await new Response(proc.stdout).text();
+      const stderr = await new Response(proc.stderr).text();
       const exitCode = await proc.exited;
       if (exitCode === 0) {
-        try {
-          const namespaces = JSON.parse(stdout2);
-          const configKv = namespaces.find((n3) => n3.title === "CONFIG_KV");
-          if (configKv)
-            return configKv.id;
-        } catch {}
+        return { ok: true, value: stdout2.trim() };
       }
-    } catch {}
-    throw new Error("Could not resolve CONFIG_KV namespace ID. Provide --namespace-id flag.");
+      return {
+        ok: false,
+        error: stderr.trim() || `wrangler exited with code ${exitCode}`
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const hint = /ENOENT|not found/i.test(message) ? "Install wrangler with `bun add -g wrangler` (or `npm i -g wrangler`), then run `wrangler login`." : undefined;
+      return {
+        ok: false,
+        error: hint ? `Failed to spawn wrangler: ${message}
+\u21B3 hint: ${hint}` : `Failed to spawn wrangler: ${message}`
+      };
+    }
   }
-  async list(namespaceId) {
-    const proc = Bun.spawn(["wrangler", "kv", "key", "list", "--namespace-id", namespaceId], { stdout: "pipe", stderr: "pipe" });
-    const stdout2 = await new Response(proc.stdout).text();
-    const exitCode = await proc.exited;
-    if (exitCode !== 0) {
-      throw new Error(`Failed to list KV keys: ${stdout2.trim() || `exit ${exitCode}`}`);
+  async whoami() {
+    return this.runWrangler(["whoami"]);
+  }
+  async deploy(workerPath, env) {
+    const resolvedPath = this.resolveWorkerPath(workerPath);
+    const args = ["deploy"];
+    if (env) {
+      args.push("--env", env);
     }
-    try {
-      const parsed = JSON.parse(stdout2);
-      return parsed;
-    } catch {
-      return stdout2.split(`
-`).filter(Boolean).map((name) => ({ name: name.trim() }));
+    const result = await this.runWrangler(args, resolvedPath);
+    if (!result.ok) {
+      return result;
+    }
+    const url2 = this.extractUrl(result.value);
+    const output = result.value;
+    const deployResult = { url: url2, rawOutput: output };
+    const pathParts = workerPath.split("/");
+    deployResult.name = pathParts[pathParts.length - 1];
+    const sizeMatch = output.match(/Total Upload:\s*([\d.]+)\s*([KMGT]?i?B)/i);
+    if (sizeMatch) {
+      deployResult.size = `${sizeMatch[1]} ${sizeMatch[2]}`;
+    }
+    const startupMatch = output.match(/Worker Startup Time:\s*(\d+)\s*ms/i);
+    if (startupMatch) {
+      deployResult.startupTime = `${startupMatch[1]} ms`;
+    }
+    const versionMatch = output.match(/Current Version ID:\s*([a-f0-9-]{36,})/i);
+    if (versionMatch) {
+      deployResult.versionId = versionMatch[1];
     }
+    return { ok: true, value: deployResult };
   }
-  async get(namespaceId, key) {
-    const proc = Bun.spawn(["wrangler", "kv", "key", "get", "--namespace-id", namespaceId, key], { stdout: "pipe", stderr: "pipe" });
-    const stdout2 = await new Response(proc.stdout).text();
-    const stderr = await new Response(proc.stderr).text();
-    const exitCode = await proc.exited;
-    if (exitCode !== 0) {
-      if (stderr.includes("not found"))
-        return null;
-      throw new Error(`Failed to get key "${key}": ${stderr.trim() || `exit ${exitCode}`}`);
+  async versionsList(workerName) {
+    const result = await this.runWrangler([
+      "versions",
+      "list",
+      "--name",
+      workerName,
+      "--json"
+    ]);
+    if (!result.ok) {
+      return result;
+    }
+    try {
+      const parsed = JSON.parse(result.value);
+      if (!Array.isArray(parsed)) {
+        return {
+          ok: false,
+          error: `Expected array from wrangler versions list, got ${typeof parsed}`
+        };
+      }
+      const versions2 = parsed.map((v) => ({
+        id: String(v.id ?? ""),
+        number: typeof v.number === "number" ? v.number : undefined,
+        created_on: typeof v.metadata === "object" && v.metadata !== null ? String(v.metadata.created_on ?? "") : undefined,
+        author: typeof v.metadata === "object" && v.metadata !== null ? String(v.metadata.author ?? "") : undefined,
+        message: typeof v.metadata === "object" && v.metadata !== null ? String(v.metadata.message ?? "") : undefined,
+        source: typeof v.metadata === "object" && v.metadata !== null ? String(v.metadata.source ?? "") : undefined
+      }));
+      return { ok: true, value: versions2 };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        ok: false,
+        error: `Failed to parse versions list: ${message}`
+      };
     }
-    return stdout2.trim() || null;
   }
-  async set(namespaceId, key, value) {
-    const proc = Bun.spawn(["wrangler", "kv", "key", "put", "--namespace-id", namespaceId, key], { stdout: "pipe", stderr: "pipe", stdin: "pipe" });
-    proc.stdin.write(value + `
-`);
-    proc.stdin.end();
-    const [, stderr] = await Promise.all([
-      new Response(proc.stdout).text(),
-      new Response(proc.stderr).text()
+  async versionsRollback(workerName, versionId) {
+    return this.runWrangler([
+      "versions",
+      "rollback",
+      "--name",
+      workerName,
+      "--version-id",
+      versionId
     ]);
-    const exitCode = await proc.exited;
-    if (exitCode !== 0) {
-      throw new Error(`Failed to set key "${key}": ${stderr.trim() || `exit ${exitCode}`}`);
+  }
+  async dev(workerPath, port) {
+    const devPort = port ?? 8787;
+    const resolvedPath = this.resolveWorkerPath(workerPath);
+    try {
+      Bun.spawn(["wrangler", "dev", "--port", String(devPort)], {
+        cwd: resolvedPath,
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      return { ok: true, value: { port: devPort } };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { ok: false, error: `Failed to start dev server: ${message}` };
     }
   }
-  async delete(namespaceId, key) {
-    const proc = Bun.spawn(["wrangler", "kv", "key", "delete", "--namespace-id", namespaceId, key], { stdout: "pipe", stderr: "pipe" });
-    const exitCode = await proc.exited;
-    const stderr = await new Response(proc.stderr).text();
-    if (exitCode !== 0) {
-      throw new Error(`Failed to delete key "${key}": ${stderr.trim() || `exit ${exitCode}`}`);
+  async tail(workerName) {
+    return this.runWrangler(["tail", workerName]);
+  }
+  async d1List() {
+    return this.runWrangler(["d1", "list", "--json"]);
+  }
+  async d1Create(name) {
+    return this.runWrangler(["d1", "create", name]);
+  }
+  async d1Delete(name) {
+    return this.runWrangler(["d1", "delete", name]);
+  }
+  async d1Execute(name, sql, remote = true) {
+    const args = ["d1", "execute", name, "--command", sql];
+    if (remote)
+      args.push("--remote");
+    const result = await this.runWrangler(args);
+    if (!result.ok)
+      return result;
+    const extracted = extractJsonArray(result.value);
+    if (extracted === null) {
+      return {
+        ok: false,
+        error: `wrangler d1 execute returned non-JSON output: ${result.value.slice(0, 200)}`
+      };
     }
+    return { ok: true, value: extracted };
   }
-  static getManifest() {
-    return {
-      namespace: "CONFIG_KV",
-      keys: [
-        {
-          key: "webhook:tradingview:ip_check_enabled",
-          type: "boolean",
-          default: "false",
-          description: "Enable TradingView IP allowlist check"
-        },
-        {
-          key: "webhook:allowed_ips",
-          type: "string",
-          default: "",
-          description: "Comma-separated allowed IPs for webhook"
-        },
-        {
-          key: "routing:dynamic:enabled",
-          type: "boolean",
-          default: "false",
-          description: "Enable dynamic routing"
-        },
-        {
-          key: "trade:max_daily_drawdown_percent",
-          type: "number",
-          default: "10",
-          description: "Max daily loss percentage before halt"
-        },
-        {
-          key: "trade:kill_switch",
-          type: "boolean",
-          default: "false",
-          description: "Emergency stop all trading"
-        },
-        {
-          key: "trade:watermark:{exchange}:{symbol}:{side}",
-          type: "number",
-          default: "",
-          description: "Per-market watermark (template key)",
-          secret: true
-        },
-        {
-          key: "agent:openai_key",
-          type: "string",
-          default: "",
-          description: "OpenAI API key for AI agent",
-          secret: true
-        },
-        {
-          key: "agent:anthropic_key",
-          type: "string",
-          default: "",
-          description: "Anthropic API key for AI agent",
-          secret: true
-        },
-        {
-          key: "agent:google_key",
-          type: "string",
-          default: "",
-          description: "Google AI API key for agent",
-          secret: true
-        },
-        {
-          key: "agent:azure_api_key",
-          type: "string",
-          default: "",
-          description: "Azure OpenAI API key",
-          secret: true
-        },
-        {
-          key: "agent:azure_endpoint",
-          type: "string",
-          default: "",
-          description: "Azure OpenAI endpoint",
-          secret: true
-        },
-        {
-          key: "email:scan_subject",
-          type: "string",
-          default: "",
-          description: "Email subject filter for signal scanning"
-        },
-        {
-          key: "email:coin_pattern",
-          type: "string",
-          default: "",
-          description: "Regex pattern to extract coin from email"
-        },
-        {
-          key: "email:action_pattern",
-          type: "string",
-          default: "",
-          description: "Regex pattern to extract action from email"
-        },
-        {
-          key: "email:quantity_multiplier",
-          type: "number",
-          default: "1",
-          description: "Multiplier for email signal quantity"
-        },
-        {
-          key: "email:use_imap",
-          type: "boolean",
-          default: "false",
-          description: "Use IMAP for email scanning"
-        }
-      ]
-    };
+  async kvList() {
+    return this.runWrangler(["kv", "namespace", "list"]);
   }
-  static getManifestKeys() {
-    return KvSyncService.getManifest().keys;
+  async kvCreate(name) {
+    return this.runWrangler(["kv", "namespace", "create", name]);
   }
-}
-
-// src/services/schema/schema-service.ts
-var exports_schema_service = {};
-__export(exports_schema_service, {
-  SchemaService: () => SchemaService
-});
-import { readFileSync as readFileSync4, existsSync as existsSync6 } from "fs";
-import { resolve as resolve4 } from "path";
-
-class SchemaService {
-  projectRoot;
-  constructor(projectRoot = process.cwd()) {
-    this.projectRoot = projectRoot;
+  async kvDelete(id) {
+    return this.runWrangler([
+      "kv",
+      "namespace",
+      "delete",
+      "--namespace-id",
+      id
+    ]);
   }
-  getWorkerNames() {
-    return WORKER_NAMES;
+  async r2List() {
+    return this.runWrangler(["r2", "bucket", "list"]);
   }
-  getManifest(name) {
-    return WORKER_MANIFESTS[name];
+  async r2Create(name) {
+    return this.runWrangler(["r2", "bucket", "create", name]);
   }
-  validateWorker(name) {
-    const manifest = WORKER_MANIFESTS[name];
-    if (!manifest) {
+  async r2Delete(name) {
+    return this.runWrangler(["r2", "bucket", "delete", name]);
+  }
+  async queueList() {
+    return this.runWrangler(["queues", "list"]);
+  }
+  async queueCreate(name) {
+    return this.runWrangler(["queues", "create", name]);
+  }
+  async queueDelete(name) {
+    return this.runWrangler(["queues", "delete", name]);
+  }
+  async vectorizeList() {
+    return this.runWrangler(["vectorize", "list", "--json"]);
+  }
+  async vectorizeCreate(name, dimensions = 768, metric = "cosine") {
+    return this.runWrangler([
+      "vectorize",
+      "create",
+      name,
+      "--dimensions",
+      String(dimensions),
+      "--metric",
+      metric
+    ]);
+  }
+  async vectorizeDelete(name) {
+    return this.runWrangler(["vectorize", "delete", name]);
+  }
+  async analyticsList() {
+    return this.runWrangler(["analytics", "dataset", "list"]);
+  }
+  async analyticsCreate(_name) {
+    return {
+      ok: false,
+      error: `Analytics datasets cannot be created via wrangler. ` + `Please use the Cloudflare Dashboard: ` + `https://dash.cloudflare.com/?to=/:account/analytics`
+    };
+  }
+  async secretList(workerName) {
+    const result = await this.runWrangler([
+      "secret",
+      "list",
+      "--name",
+      workerName
+    ]);
+    if (!result.ok)
+      return result;
+    const extracted = extractJsonArray(result.value);
+    if (extracted === null) {
       return {
-        worker: name,
-        passed: false,
-        errors: [
-          {
-            worker: name,
-            severity: "error",
-            message: `Unknown worker "${name}"`
-          }
-        ]
+        ok: false,
+        error: `wrangler secret list returned non-JSON output: ${result.value.slice(0, 200)}`
       };
     }
-    const workersDir = resolve4(this.projectRoot, "workers");
-    const rootWranglerPath = resolve4(this.projectRoot, "wrangler.jsonc");
-    const workerWranglerPath = resolve4(workersDir, name, "wrangler.jsonc");
-    const devVarsPath = resolve4(workersDir, name, ".dev.vars");
-    const errors4 = [];
-    const isHooxProject = existsSync6(resolve4(this.projectRoot, "wrangler.jsonc")) || existsSync6(resolve4(this.projectRoot, "workers"));
+    return { ok: true, value: extracted };
+  }
+  async secretPut(workerName, secretName, value) {
     try {
-      const wranglerContent = readFileSync4(workerWranglerPath, "utf-8");
-      errors4.push(...validateWranglerJsonc(name, manifest, wranglerContent));
-    } catch (e) {
-      const isErrnoException = e instanceof Error && "code" in e;
-      const isEnoent = isErrnoException && e.code === "ENOENT";
-      const errMessage = e instanceof Error ? e.message : String(e);
-      const message = isEnoent && !isHooxProject ? `Cannot read ${workerWranglerPath}: File not found. Are you in the Hoox project root directory?` : `Cannot read ${workerWranglerPath}: ${errMessage}`;
-      errors4.push({
-        worker: name,
-        severity: "error",
-        message
+      const proc = Bun.spawn(["wrangler", "secret", "put", secretName, "--name", workerName], {
+        cwd: this.cwd,
+        stdout: "pipe",
+        stderr: "pipe",
+        stdin: "pipe"
       });
+      proc.stdin.write(value + `
+`);
+      proc.stdin.end();
+      const stdout2 = await new Response(proc.stdout).text();
+      const stderr = await new Response(proc.stderr).text();
+      const exitCode = await proc.exited;
+      if (exitCode === 0) {
+        return { ok: true, value: stdout2.trim() };
+      }
+      return {
+        ok: false,
+        error: stderr.trim() || `wrangler exited with code ${exitCode}`
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { ok: false, error: `Failed to set secret: ${message}` };
     }
-    try {
-      const rootContent = readFileSync4(rootWranglerPath, "utf-8");
-      errors4.push(...validateRootSecrets(name, manifest, rootContent));
-    } catch (e) {
-      const errMessage = e instanceof Error ? e.message : String(e);
-      errors4.push({
-        worker: name,
-        severity: "warning",
-        message: `Cannot read root wrangler.jsonc: ${errMessage}`
-      });
+  }
+  async secretDelete(workerName, secretName) {
+    return this.runWrangler([
+      "secret",
+      "delete",
+      secretName,
+      "--name",
+      workerName
+    ]);
+  }
+  async zonesList() {
+    const token = process.env.CLOUDFLARE_API_TOKEN;
+    if (!token) {
+      return {
+        ok: false,
+        error: "CLOUDFLARE_API_TOKEN environment variable is not set. Set it or run `wrangler login`."
+      };
     }
     try {
-      const devVarsContent = readFileSync4(devVarsPath, "utf-8");
-      errors4.push(...validateDevVars(name, manifest, devVarsContent));
-    } catch (e) {
-      const errMessage = e instanceof Error ? e.message : String(e);
-      errors4.push({
-        worker: name,
-        severity: "warning",
-        message: `Cannot read ${devVarsPath}: ${errMessage}`
+      const response = await fetch("https://api.cloudflare.com/client/v4/zones?per_page=50", {
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "Content-Type": "application/json"
+        }
       });
+      const json2 = await response.json();
+      if (!response.ok || !json2.success) {
+        const errorMsg = json2.errors?.map((e) => e.message).join("; ") || `HTTP ${response.status}`;
+        return { ok: false, error: `Failed to list zones: ${errorMsg}` };
+      }
+      const lines = json2.result.map((z2) => `${z2.name} (${z2.id})`);
+      return { ok: true, value: lines.join(`
+`) };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { ok: false, error: `Cloudflare API request failed: ${message}` };
     }
-    return {
-      worker: name,
-      passed: errors4.filter((e) => e.severity === "error").length === 0,
-      errors: errors4
-    };
   }
-  validateAll() {
-    return WORKER_NAMES.map((name) => this.validateWorker(name));
-  }
-}
-var init_schema_service = __esm(() => {
-  init_src();
-});
-
-// src/commands/trace/trace-service.ts
-var exports_trace_service = {};
-__export(exports_trace_service, {
-  TraceService: () => TraceService
-});
-function getCredentials2() {
-  const token = process.env.CLOUDFLARE_API_TOKEN;
-  const accountId = process.env.CLOUDFLARE_ACCOUNT_ID;
-  if (!token) {
-    throw new CLIError("CLOUDFLARE_API_TOKEN environment variable is not set. Set it or run `wrangler login`.", 1 /* ERROR */);
-  }
-  if (!accountId) {
-    throw new CLIError("CLOUDFLARE_ACCOUNT_ID environment variable is not set.", 1 /* ERROR */);
+  extractUrl(stdout2) {
+    for (const line of stdout2.split(`
+`)) {
+      const trimmed = line.trim();
+      const match = trimmed.match(/(https?:\/\/[^\s]+(?:workers\.dev|cloudflareworkers\.com)[^\s]*)/);
+      if (match)
+        return match[1];
+    }
+    return;
   }
-  return { token, accountId };
 }
-async function cfApi2(method, path6, body, query) {
-  const { token } = getCredentials2();
-  let url2 = `${CF_API_BASE2}${path6}`;
-  if (query) {
-    const params = new URLSearchParams;
-    for (const [k, v] of Object.entries(query)) {
-      if (v !== undefined)
-        params.set(k, String(v));
+function extractJsonArray(raw) {
+  const first = raw.indexOf("[");
+  if (first === -1)
+    return null;
+  let depth = 0;
+  let inString = false;
+  let escape = false;
+  for (let i2 = first;i2 < raw.length; i2++) {
+    const ch = raw[i2];
+    if (escape) {
+      escape = false;
+      continue;
     }
-    const qs = params.toString();
-    if (qs)
-      url2 += `?${qs}`;
-  }
-  try {
-    const response = await fetch(url2, {
-      method,
-      headers: {
-        Authorization: `Bearer ${token}`,
-        "Content-Type": "application/json"
-      },
-      body: body !== undefined ? JSON.stringify(body) : undefined
-    });
-    const json2 = await response.json();
-    if (!response.ok || !json2.success) {
-      const errorMsg = json2.errors?.map((e) => e.message).join("; ") || `HTTP ${response.status}`;
-      throw new CLIError(`Cloudflare API error: ${errorMsg}`, 1 /* ERROR */);
+    if (inString) {
+      if (ch === "\\")
+        escape = true;
+      else if (ch === '"')
+        inString = false;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      continue;
+    }
+    if (ch === "[")
+      depth++;
+    else if (ch === "]") {
+      depth--;
+      if (depth === 0)
+        return raw.slice(first, i2 + 1);
     }
-    return json2.result;
-  } catch (err) {
-    if (err instanceof CLIError)
-      throw err;
-    const message = err instanceof Error ? err.message : String(err);
-    throw new CLIError(`Cloudflare API request failed: ${message}`, 1 /* ERROR */);
   }
+  return null;
 }
+var init_cloudflare_service = __esm(() => {
+  init_config2();
+});
 
-class TraceService {
-  accountId;
-  constructor() {
-    const { accountId } = getCredentials2();
-    this.accountId = accountId;
+// src/services/kv/kv-sync-service.ts
+var exports_kv_sync_service = {};
+__export(exports_kv_sync_service, {
+  stripWranglerStdoutNoise: () => stripWranglerStdoutNoise,
+  KvSyncService: () => KvSyncService
+});
+function stripWranglerStdoutNoise(raw) {
+  const lines = raw.split(`
+`);
+  const cleaned = lines.filter((line) => {
+    const t2 = line.trim();
+    if (!t2)
+      return false;
+    if (t2.startsWith("There is a newer version of Wrangler"))
+      return false;
+    if (t2.includes("update available"))
+      return false;
+    if (t2.startsWith("\u26C5"))
+      return false;
+    if (/^[\u2500\-\u2550]{3,}$/.test(t2))
+      return false;
+    if (t2.startsWith("\u25B2 [WARNING]") || t2.startsWith("\u2718 [ERROR]"))
+      return false;
+    return true;
+  });
+  return cleaned.join(`
+`).trim();
+}
+
+class KvSyncService {
+  async resolveNamespaceId(namespaceId) {
+    if (namespaceId)
+      return namespaceId;
+    try {
+      const proc = Bun.spawn(["wrangler", "kv", "namespace", "list"], {
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const stdout2 = await new Response(proc.stdout).text();
+      const exitCode = await proc.exited;
+      if (exitCode === 0) {
+        try {
+          const jsonText = extractJsonArray(stdout2) ?? stripWranglerStdoutNoise(stdout2);
+          const namespaces = JSON.parse(jsonText);
+          const configKv = namespaces.find((n3) => n3.title === "CONFIG_KV");
+          if (configKv)
+            return configKv.id;
+        } catch {}
+      }
+    } catch {}
+    throw new Error("Could not resolve CONFIG_KV namespace ID. Provide --namespace-id flag.");
   }
-  async query(request) {
-    const path6 = `/accounts/${this.accountId}/workers/observability/telemetry/query`;
-    const result = await cfApi2("POST", path6, request);
-    if (request.view === "events") {
-      const events = result.events?.events ?? [];
-      return { success: true, events };
+  async list(namespaceId) {
+    const proc = Bun.spawn(["wrangler", "kv", "key", "list", "--namespace-id", namespaceId], { stdout: "pipe", stderr: "pipe" });
+    const stdout2 = await new Response(proc.stdout).text();
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+      throw new Error(`Failed to list KV keys: ${stdout2.trim() || `exit ${exitCode}`}`);
     }
-    if (request.view === "calculations") {
-      const metrics = (result.calculations ?? []).map((c3) => ({
-        calculations: (c3.aggregates ?? []).map((a3) => ({
-          alias: c3.calculation,
-          value: typeof a3.value === "number" ? a3.value : Number(a3.value ?? 0)
-        })),
-        groupBy: c3.groupBy
-      }));
-      return { success: true, metrics };
+    try {
+      const parsed = JSON.parse(stdout2);
+      return parsed;
+    } catch {
+      return stdout2.split(`
+`).filter(Boolean).map((name) => ({ name: name.trim() }));
     }
-    return { success: true };
   }
-  async queryEvents(options) {
-    const filters = [];
-    if (options.service) {
-      filters.push({
-        key: "$metadata.service",
-        operation: "eq",
-        type: "string",
-        value: options.service
-      });
-    }
-    if (options.trigger) {
-      filters.push({
-        key: "$metadata.trigger",
-        operation: "includes",
-        type: "string",
-        value: options.trigger
-      });
-    }
-    if (options.level) {
-      filters.push({
-        key: "$metadata.level",
-        operation: "eq",
-        type: "string",
-        value: options.level
-      });
+  async get(namespaceId, key) {
+    const proc = Bun.spawn(["wrangler", "kv", "key", "get", "--namespace-id", namespaceId, key], { stdout: "pipe", stderr: "pipe" });
+    const stdout2 = await new Response(proc.stdout).text();
+    const stderr = await new Response(proc.stderr).text();
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+      if (stderr.includes("not found"))
+        return null;
+      throw new Error(`Failed to get key "${key}": ${stderr.trim() || `exit ${exitCode}`}`);
     }
-    const now = Date.now();
-    const oneHourAgo = now - 60 * 60 * 1000;
-    const request = {
-      view: "events",
-      queryId: "trace-events",
-      limit: options.limit ?? 50,
-      parameters: {
-        filters
-      },
-      timeframe: {
-        from: options.from ?? oneHourAgo,
-        to: options.to ?? now
-      }
-    };
-    return this.query(request);
+    const cleaned = stripWranglerStdoutNoise(stdout2);
+    return cleaned.length > 0 ? cleaned : null;
   }
-  async queryMetrics(options) {
-    const filters = [];
-    if (options.service) {
-      filters.push({
-        key: "$metadata.service",
-        operation: "eq",
-        type: "string",
-        value: options.service
-      });
+  async set(namespaceId, key, value) {
+    const proc = Bun.spawn(["wrangler", "kv", "key", "put", "--namespace-id", namespaceId, key], { stdout: "pipe", stderr: "pipe", stdin: "pipe" });
+    proc.stdin.write(value + `
+`);
+    proc.stdin.end();
+    const [, stderr] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text()
+    ]);
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+      throw new Error(`Failed to set key "${key}": ${stderr.trim() || `exit ${exitCode}`}`);
     }
-    const calculations = (options.calculations ?? [{ operator: "count" }]).map((c3) => ({
-      operator: c3.operator,
-      key: c3.key,
-      keyType: c3.key ? "number" : undefined,
-      alias: c3.alias ?? c3.operator
-    }));
-    const groupBys = options.groupBy ? [{ type: "string", value: options.groupBy }] : [];
-    const now = Date.now();
-    const oneHourAgo = now - 60 * 60 * 1000;
-    const request = {
-      view: "calculations",
-      queryId: "trace-metrics",
-      parameters: {
-        filters,
-        calculations,
-        groupBys
-      },
-      timeframe: {
-        from: options.from ?? oneHourAgo,
-        to: options.to ?? now
-      }
-    };
-    return this.query(request);
   }
-  async listKeys(options) {
-    const path6 = `/accounts/${this.accountId}/workers/observability/telemetry/keys`;
-    const body = {
-      needle: options?.needle ? { value: options.needle, isRegex: false, matchCase: false } : undefined,
-      limit: options?.limit ?? 100
-    };
-    const raw = await cfApi2("POST", path6, body);
-    return { keys: raw };
-  }
-  async listValues(options) {
-    const path6 = `/accounts/${this.accountId}/workers/observability/telemetry/values`;
-    const now = Date.now();
-    const oneHourAgo = now - 60 * 60 * 1000;
-    const body = {
-      key: options.key,
-      type: options.type ?? "string",
-      datasets: [],
-      limit: options.limit ?? 50,
-      timeframe: {
-        from: options.from ?? oneHourAgo,
-        to: options.to ?? now
-      }
-    };
-    const raw = await cfApi2("POST", path6, body);
-    return { values: raw.map((v) => v.value) };
-  }
-  async listDestinations() {
-    const path6 = `/accounts/${this.accountId}/workers/observability/destinations`;
-    return cfApi2("GET", path6);
-  }
-  async createDestination(input) {
-    const path6 = `/accounts/${this.accountId}/workers/observability/destinations`;
-    return cfApi2("POST", path6, input);
-  }
-  async deleteDestination(slug) {
-    const path6 = `/accounts/${this.accountId}/workers/observability/destinations/${slug}`;
-    await cfApi2("DELETE", path6);
-  }
-  async getUsage(options) {
-    const path6 = `/accounts/${this.accountId}/workers/observability/usage`;
-    const now = Date.now();
-    const sevenDaysAgo = now - 7 * 24 * 60 * 60 * 1000;
-    const raw = await cfApi2("GET", path6, undefined, {
-      from: options?.from ?? sevenDaysAgo,
-      to: options?.to ?? now
-    });
-    const byWorker = {};
-    for (const row of raw.breakdown ?? []) {
-      byWorker[row.service] = (byWorker[row.service] ?? 0) + row.count;
+  async delete(namespaceId, key) {
+    const proc = Bun.spawn(["wrangler", "kv", "key", "delete", "--namespace-id", namespaceId, key], { stdout: "pipe", stderr: "pipe" });
+    const exitCode = await proc.exited;
+    const stderr = await new Response(proc.stderr).text();
+    if (exitCode !== 0) {
+      throw new Error(`Failed to delete key "${key}": ${stderr.trim() || `exit ${exitCode}`}`);
     }
-    return {
-      eventCount: raw.events,
-      from: new Date(options?.from ?? sevenDaysAgo).toISOString(),
-      to: new Date(options?.to ?? now).toISOString(),
-      byWorker
-    };
   }
-  async prepareLiveTail(options) {
-    const path6 = `/accounts/${this.accountId}/workers/observability/telemetry/live-tail`;
-    const body = {
-      filters: options?.service ? [
+  static getManifest() {
+    return {
+      namespace: "CONFIG_KV",
+      keys: [
         {
-          key: "$metadata.service",
-          operation: "eq",
+          key: "webhook:tradingview:ip_check_enabled",
+          type: "boolean",
+          default: "false",
+          description: "Enable TradingView IP allowlist check"
+        },
+        {
+          key: "webhook:allowed_ips",
           type: "string",
-          value: options.service
+          default: "",
+          description: "Comma-separated allowed IPs for webhook"
+        },
+        {
+          key: "routing:dynamic:enabled",
+          type: "boolean",
+          default: "false",
+          description: "Enable dynamic routing"
+        },
+        {
+          key: "trade:max_daily_drawdown_percent",
+          type: "number",
+          default: "10",
+          description: "Max daily loss percentage before halt"
+        },
+        {
+          key: "trade:kill_switch",
+          type: "boolean",
+          default: "false",
+          description: "Emergency stop all trading"
+        },
+        {
+          key: "trade:watermark:{exchange}:{symbol}:{side}",
+          type: "number",
+          default: "",
+          description: "Per-market watermark (template key)",
+          secret: true
+        },
+        {
+          key: "agent:openai_key",
+          type: "string",
+          default: "",
+          description: "OpenAI API key for AI agent",
+          secret: true
+        },
+        {
+          key: "agent:anthropic_key",
+          type: "string",
+          default: "",
+          description: "Anthropic API key for AI agent",
+          secret: true
+        },
+        {
+          key: "agent:google_key",
+          type: "string",
+          default: "",
+          description: "Google AI API key for agent",
+          secret: true
+        },
+        {
+          key: "agent:azure_api_key",
+          type: "string",
+          default: "",
+          description: "Azure OpenAI API key",
+          secret: true
+        },
+        {
+          key: "agent:azure_endpoint",
+          type: "string",
+          default: "",
+          description: "Azure OpenAI endpoint",
+          secret: true
+        },
+        {
+          key: "email:scan_subject",
+          type: "string",
+          default: "",
+          description: "Email subject filter for signal scanning"
+        },
+        {
+          key: "email:coin_pattern",
+          type: "string",
+          default: "",
+          description: "Regex pattern to extract coin from email"
+        },
+        {
+          key: "email:action_pattern",
+          type: "string",
+          default: "",
+          description: "Regex pattern to extract action from email"
+        },
+        {
+          key: "email:quantity_multiplier",
+          type: "number",
+          default: "1",
+          description: "Multiplier for email signal quantity"
+        },
+        {
+          key: "email:use_imap",
+          type: "boolean",
+          default: "false",
+          description: "Use IMAP for email scanning"
         }
-      ] : []
+      ]
     };
-    return cfApi2("POST", path6, body);
   }
-  async liveTailHeartbeat(sessionId) {
-    const path6 = `/accounts/${this.accountId}/workers/observability/telemetry/live-tail/heartbeat`;
-    await cfApi2("POST", path6, { sessionId });
+  static getManifestKeys() {
+    return KvSyncService.getManifest().keys;
   }
 }
-var CF_API_BASE2 = "https://api.cloudflare.com/client/v4";
-var init_trace_service = __esm(() => {
-  init_errors4();
+var init_kv_sync_service = __esm(() => {
+  init_cloudflare_service();
 });
 
-// src/index.ts
-import { readFileSync as readFileSync8 } from "fs";
-
-// ../../node_modules/.bun/commander@15.0.0/node_modules/commander/lib/error.js
-class CommanderError extends Error {
-  constructor(exitCode, code, message) {
-    super(message);
-    Error.captureStackTrace(this, this.constructor);
-    this.name = this.constructor.name;
-    this.code = code;
-    this.exitCode = exitCode;
-    this.nestedError = undefined;
-  }
-}
-
-class InvalidArgumentError extends CommanderError {
-  constructor(message) {
-    super(1, "commander.invalidArgument", message);
-    Error.captureStackTrace(this, this.constructor);
-    this.name = this.constructor.name;
-  }
-}
+// src/services/schema/schema-service.ts
+var exports_schema_service = {};
+__export(exports_schema_service, {
+  SchemaService: () => SchemaService
+});
+import { readFileSync as readFileSync4, existsSync as existsSync7 } from "fs";
+import { resolve as resolve4 } from "path";
 
-// ../../node_modules/.bun/commander@15.0.0/node_modules/commander/lib/argument.js
-class Argument {
-  constructor(name, description) {
-    this.description = description || "";
-    this.variadic = false;
-    this.parseArg = undefined;
-    this.defaultValue = undefined;
-    this.defaultValueDescription = undefined;
-    this.argChoices = undefined;
-    switch (name[0]) {
-      case "<":
-        this.required = true;
-        this._name = name.slice(1, -1);
-        break;
-      case "[":
-        this.required = false;
-        this._name = name.slice(1, -1);
-        break;
-      default:
-        this.required = true;
-        this._name = name;
-        break;
-    }
-    if (this._name.endsWith("...")) {
-      this.variadic = true;
-      this._name = this._name.slice(0, -3);
-    }
-  }
-  name() {
-    return this._name;
+class SchemaService {
+  projectRoot;
+  constructor(projectRoot = process.cwd()) {
+    this.projectRoot = projectRoot;
   }
-  _collectValue(value, previous) {
-    if (previous === this.defaultValue || !Array.isArray(previous)) {
-      return [value];
-    }
-    previous.push(value);
-    return previous;
+  getWorkerNames() {
+    return WORKER_NAMES;
   }
-  default(value, description) {
-    this.defaultValue = value;
-    this.defaultValueDescription = description;
-    return this;
+  getManifest(name) {
+    return WORKER_MANIFESTS[name];
   }
-  argParser(fn) {
-    this.parseArg = fn;
-    return this;
-  }
-  choices(values) {
-    this.argChoices = values.slice();
-    this.parseArg = (arg, previous) => {
-      if (!this.argChoices.includes(arg)) {
-        throw new InvalidArgumentError(`Allowed choices are ${this.argChoices.join(", ")}.`);
-      }
-      if (this.variadic) {
-        return this._collectValue(arg, previous);
-      }
-      return arg;
+  validateWorker(name) {
+    const manifest = WORKER_MANIFESTS[name];
+    if (!manifest) {
+      return {
+        worker: name,
+        passed: false,
+        errors: [
+          {
+            worker: name,
+            severity: "error",
+            message: `Unknown worker "${name}"`
+          }
+        ]
+      };
+    }
+    const workersDir = resolve4(this.projectRoot, "workers");
+    const rootWranglerPath = resolve4(this.projectRoot, "wrangler.jsonc");
+    const workerWranglerPath = resolve4(workersDir, name, "wrangler.jsonc");
+    const devVarsPath = resolve4(workersDir, name, ".dev.vars");
+    const errors4 = [];
+    const isHooxProject = existsSync7(resolve4(this.projectRoot, "wrangler.jsonc")) || existsSync7(resolve4(this.projectRoot, "workers"));
+    try {
+      const wranglerContent = readFileSync4(workerWranglerPath, "utf-8");
+      errors4.push(...validateWranglerJsonc(name, manifest, wranglerContent));
+    } catch (e) {
+      const isErrnoException = e instanceof Error && "code" in e;
+      const isEnoent = isErrnoException && e.code === "ENOENT";
+      const errMessage = e instanceof Error ? e.message : String(e);
+      const message = isEnoent && !isHooxProject ? `Cannot read ${workerWranglerPath}: File not found. Are you in the Hoox project root directory?` : `Cannot read ${workerWranglerPath}: ${errMessage}`;
+      errors4.push({
+        worker: name,
+        severity: "error",
+        message
+      });
+    }
+    try {
+      const rootContent = readFileSync4(rootWranglerPath, "utf-8");
+      errors4.push(...validateRootSecrets(name, manifest, rootContent));
+    } catch (e) {
+      const errMessage = e instanceof Error ? e.message : String(e);
+      errors4.push({
+        worker: name,
+        severity: "warning",
+        message: `Cannot read root wrangler.jsonc: ${errMessage}`
+      });
+    }
+    try {
+      const devVarsContent = readFileSync4(devVarsPath, "utf-8");
+      errors4.push(...validateDevVars(name, manifest, devVarsContent));
+    } catch (e) {
+      const errMessage = e instanceof Error ? e.message : String(e);
+      errors4.push({
+        worker: name,
+        severity: "warning",
+        message: `Cannot read ${devVarsPath}: ${errMessage}`
+      });
+    }
+    return {
+      worker: name,
+      passed: errors4.filter((e) => e.severity === "error").length === 0,
+      errors: errors4
     };
-    return this;
   }
-  argRequired() {
-    this.required = true;
-    return this;
-  }
-  argOptional() {
-    this.required = false;
-    return this;
+  validateAll() {
+    return WORKER_NAMES.map((name) => this.validateWorker(name));
   }
 }
-function humanReadableArgName(arg) {
-  const nameOutput = arg.name() + (arg.variadic === true ? "..." : "");
-  return arg.required ? "<" + nameOutput + ">" : "[" + nameOutput + "]";
-}
-
-// ../../node_modules/.bun/commander@15.0.0/node_modules/commander/lib/command.js
-import { EventEmitter } from "events";
-import childProcess from "child_process";
-import path from "path";
-import fs from "fs";
-import process2 from "process";
-import { stripVTControlCharacters as stripVTControlCharacters2 } from "util";
-
-// ../../node_modules/.bun/commander@15.0.0/node_modules/commander/lib/help.js
-import { stripVTControlCharacters } from "util";
+var init_schema_service = __esm(() => {
+  init_src();
+});
 
-class Help {
-  constructor() {
-    this.helpWidth = undefined;
-    this.minWidthToWrap = 40;
-    this.sortSubcommands = false;
-    this.sortOptions = false;
-    this.showGlobalOptions = false;
+// src/commands/trace/trace-service.ts
+var exports_trace_service = {};
+__export(exports_trace_service, {
+  TraceService: () => TraceService
+});
+function getCredentials2() {
+  const token = process.env.CLOUDFLARE_API_TOKEN;
+  const accountId = process.env.CLOUDFLARE_ACCOUNT_ID;
+  if (!token) {
+    throw new CLIError("CLOUDFLARE_API_TOKEN environment variable is not set. Set it or run `wrangler login`.", 1 /* ERROR */);
   }
-  prepareContext(contextOptions) {
-    this.helpWidth = this.helpWidth ?? contextOptions.helpWidth ?? 80;
+  if (!accountId) {
+    throw new CLIError("CLOUDFLARE_ACCOUNT_ID environment variable is not set.", 1 /* ERROR */);
   }
-  visibleCommands(cmd) {
-    const visibleCommands = cmd.commands.filter((cmd2) => !cmd2._hidden);
-    const helpCommand = cmd._getHelpCommand();
-    if (helpCommand && !helpCommand._hidden) {
-      visibleCommands.push(helpCommand);
+  return { token, accountId };
+}
+async function cfApi2(method, path6, body, query) {
+  const { token } = getCredentials2();
+  let url2 = `${CF_API_BASE2}${path6}`;
+  if (query) {
+    const params = new URLSearchParams;
+    for (const [k, v] of Object.entries(query)) {
+      if (v !== undefined)
+        params.set(k, String(v));
     }
-    if (this.sortSubcommands) {
-      visibleCommands.sort((a, b) => {
-        return a.name().localeCompare(b.name());
-      });
+    const qs = params.toString();
+    if (qs)
+      url2 += `?${qs}`;
+  }
+  try {
+    const response = await fetch(url2, {
+      method,
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json"
+      },
+      body: body !== undefined ? JSON.stringify(body) : undefined
+    });
+    const json2 = await response.json();
+    if (!response.ok || !json2.success) {
+      const errorMsg = json2.errors?.map((e) => e.message).join("; ") || `HTTP ${response.status}`;
+      throw new CLIError(`Cloudflare API error: ${errorMsg}`, 1 /* ERROR */);
     }
-    return visibleCommands;
+    return json2.result;
+  } catch (err) {
+    if (err instanceof CLIError)
+      throw err;
+    const message = err instanceof Error ? err.message : String(err);
+    throw new CLIError(`Cloudflare API request failed: ${message}`, 1 /* ERROR */);
   }
-  compareOptions(a, b) {
-    const getSortKey = (option) => {
-      return option.short ? option.short.replace(/^-/, "") : option.long.replace(/^--/, "");
-    };
-    return getSortKey(a).localeCompare(getSortKey(b));
+}
+
+class TraceService {
+  accountId;
+  constructor() {
+    const { accountId } = getCredentials2();
+    this.accountId = accountId;
   }
-  visibleOptions(cmd) {
-    const visibleOptions = cmd.options.filter((option) => !option.hidden);
-    const helpOption = cmd._getHelpOption();
-    if (helpOption && !helpOption.hidden) {
-      const removeShort = helpOption.short && cmd._findOption(helpOption.short);
-      const removeLong = helpOption.long && cmd._findOption(helpOption.long);
-      if (!removeShort && !removeLong) {
-        visibleOptions.push(helpOption);
-      } else if (helpOption.long && !removeLong) {
-        visibleOptions.push(cmd.createOption(helpOption.long, helpOption.description));
-      } else if (helpOption.short && !removeShort) {
-        visibleOptions.push(cmd.createOption(helpOption.short, helpOption.description));
-      }
+  async query(request) {
+    const path6 = `/accounts/${this.accountId}/workers/observability/telemetry/query`;
+    const result = await cfApi2("POST", path6, request);
+    if (request.view === "events") {
+      const events = result.events?.events ?? [];
+      return { success: true, events };
     }
-    if (this.sortOptions) {
-      visibleOptions.sort(this.compareOptions);
+    if (request.view === "calculations") {
+      const metrics = (result.calculations ?? []).map((c3) => ({
+        calculations: (c3.aggregates ?? []).map((a3) => ({
+          alias: c3.calculation,
+          value: typeof a3.value === "number" ? a3.value : Number(a3.value ?? 0)
+        })),
+        groupBy: c3.groupBy
+      }));
+      return { success: true, metrics };
     }
-    return visibleOptions;
+    return { success: true };
   }
-  visibleGlobalOptions(cmd) {
-    if (!this.showGlobalOptions)
-      return [];
-    const globalOptions = [];
-    for (let ancestorCmd = cmd.parent;ancestorCmd; ancestorCmd = ancestorCmd.parent) {
-      const visibleOptions = ancestorCmd.options.filter((option) => !option.hidden);
-      globalOptions.push(...visibleOptions);
-    }
-    if (this.sortOptions) {
-      globalOptions.sort(this.compareOptions);
+  async queryEvents(options) {
+    const filters = [];
+    if (options.service) {
+      filters.push({
+        key: "$metadata.service",
+        operation: "eq",
+        type: "string",
+        value: options.service
+      });
     }
-    return globalOptions;
-  }
-  visibleArguments(cmd) {
-    if (cmd._argsDescription) {
-      cmd.registeredArguments.forEach((argument) => {
-        argument.description = argument.description || cmd._argsDescription[argument.name()] || "";
+    if (options.trigger) {
+      filters.push({
+        key: "$metadata.trigger",
+        operation: "includes",
+        type: "string",
+        value: options.trigger
       });
     }
-    if (cmd.registeredArguments.find((argument) => argument.description)) {
-      return cmd.registeredArguments;
+    if (options.level) {
+      filters.push({
+        key: "$metadata.level",
+        operation: "eq",
+        type: "string",
+        value: options.level
+      });
     }
-    return [];
-  }
-  subcommandTerm(cmd) {
-    const args = cmd.registeredArguments.map((arg) => humanReadableArgName(arg)).join(" ");
-    return cmd._name + (cmd._aliases[0] ? "|" + cmd._aliases[0] : "") + (cmd.options.length ? " [options]" : "") + (args ? " " + args : "");
-  }
-  optionTerm(option) {
-    return option.flags;
-  }
-  argumentTerm(argument) {
-    return argument.name();
+    const now = Date.now();
+    const oneHourAgo = now - 60 * 60 * 1000;
+    const request = {
+      view: "events",
+      queryId: "trace-events",
+      limit: options.limit ?? 50,
+      parameters: {
+        filters
+      },
+      timeframe: {
+        from: options.from ?? oneHourAgo,
+        to: options.to ?? now
+      }
+    };
+    return this.query(request);
   }
-  longestSubcommandTermLength(cmd, helper) {
-    return helper.visibleCommands(cmd).reduce((max, command) => {
-      return Math.max(max, this.displayWidth(helper.styleSubcommandTerm(helper.subcommandTerm(command))));
-    }, 0);
+  async queryMetrics(options) {
+    const filters = [];
+    if (options.service) {
+      filters.push({
+        key: "$metadata.service",
+        operation: "eq",
+        type: "string",
+        value: options.service
+      });
+    }
+    const calculations = (options.calculations ?? [{ operator: "count" }]).map((c3) => ({
+      operator: c3.operator,
+      key: c3.key,
+      keyType: c3.key ? "number" : undefined,
+      alias: c3.alias ?? c3.operator
+    }));
+    const groupBys = options.groupBy ? [{ type: "string", value: options.groupBy }] : [];
+    const now = Date.now();
+    const oneHourAgo = now - 60 * 60 * 1000;
+    const request = {
+      view: "calculations",
+      queryId: "trace-metrics",
+      parameters: {
+        filters,
+        calculations,
+        groupBys
+      },
+      timeframe: {
+        from: options.from ?? oneHourAgo,
+        to: options.to ?? now
+      }
+    };
+    return this.query(request);
   }
-  longestOptionTermLength(cmd, helper) {
-    return helper.visibleOptions(cmd).reduce((max, option) => {
-      return Math.max(max, this.displayWidth(helper.styleOptionTerm(helper.optionTerm(option))));
-    }, 0);
+  async listKeys(options) {
+    const path6 = `/accounts/${this.accountId}/workers/observability/telemetry/keys`;
+    const body = {
+      needle: options?.needle ? { value: options.needle, isRegex: false, matchCase: false } : undefined,
+      limit: options?.limit ?? 100
+    };
+    const raw = await cfApi2("POST", path6, body);
+    return { keys: raw };
   }
-  longestGlobalOptionTermLength(cmd, helper) {
-    return helper.visibleGlobalOptions(cmd).reduce((max, option) => {
-      return Math.max(max, this.displayWidth(helper.styleOptionTerm(helper.optionTerm(option))));
-    }, 0);
+  async listValues(options) {
+    const path6 = `/accounts/${this.accountId}/workers/observability/telemetry/values`;
+    const now = Date.now();
+    const oneHourAgo = now - 60 * 60 * 1000;
+    const body = {
+      key: options.key,
+      type: options.type ?? "string",
+      datasets: [],
+      limit: options.limit ?? 50,
+      timeframe: {
+        from: options.from ?? oneHourAgo,
+        to: options.to ?? now
+      }
+    };
+    const raw = await cfApi2("POST", path6, body);
+    return { values: raw.map((v) => v.value) };
   }
-  longestArgumentTermLength(cmd, helper) {
-    return helper.visibleArguments(cmd).reduce((max, argument) => {
-      return Math.max(max, this.displayWidth(helper.styleArgumentTerm(helper.argumentTerm(argument))));
-    }, 0);
+  async listDestinations() {
+    const path6 = `/accounts/${this.accountId}/workers/observability/destinations`;
+    return cfApi2("GET", path6);
   }
-  commandUsage(cmd) {
-    let cmdName = cmd._name;
-    if (cmd._aliases[0]) {
-      cmdName = cmdName + "|" + cmd._aliases[0];
-    }
-    let ancestorCmdNames = "";
-    for (let ancestorCmd = cmd.parent;ancestorCmd; ancestorCmd = ancestorCmd.parent) {
-      ancestorCmdNames = ancestorCmd.name() + " " + ancestorCmdNames;
+  async createDestination(input) {
+    const path6 = `/accounts/${this.accountId}/workers/observability/destinations`;
+    return cfApi2("POST", path6, input);
+  }
+  async deleteDestination(slug) {
+    const path6 = `/accounts/${this.accountId}/workers/observability/destinations/${slug}`;
+    await cfApi2("DELETE", path6);
+  }
+  async getUsage(options) {
+    const path6 = `/accounts/${this.accountId}/workers/observability/usage`;
+    const now = Date.now();
+    const sevenDaysAgo = now - 7 * 24 * 60 * 60 * 1000;
+    const raw = await cfApi2("GET", path6, undefined, {
+      from: options?.from ?? sevenDaysAgo,
+      to: options?.to ?? now
+    });
+    const byWorker = {};
+    for (const row of raw.breakdown ?? []) {
+      byWorker[row.service] = (byWorker[row.service] ?? 0) + row.count;
     }
-    return ancestorCmdNames + cmdName + " " + cmd.usage();
+    return {
+      eventCount: raw.events,
+      from: new Date(options?.from ?? sevenDaysAgo).toISOString(),
+      to: new Date(options?.to ?? now).toISOString(),
+      byWorker
+    };
   }
-  commandDescription(cmd) {
-    return cmd.description();
+  async prepareLiveTail(options) {
+    const path6 = `/accounts/${this.accountId}/workers/observability/telemetry/live-tail`;
+    const body = {
+      filters: options?.service ? [
+        {
+          key: "$metadata.service",
+          operation: "eq",
+          type: "string",
+          value: options.service
+        }
+      ] : []
+    };
+    return cfApi2("POST", path6, body);
   }
-  subcommandDescription(cmd) {
-    return cmd.summary() || cmd.description();
+  async liveTailHeartbeat(sessionId) {
+    const path6 = `/accounts/${this.accountId}/workers/observability/telemetry/live-tail/heartbeat`;
+    await cfApi2("POST", path6, { sessionId });
   }
-  optionDescription(option) {
-    const extraInfo = [];
-    if (option.argChoices) {
-      extraInfo.push(`choices: ${option.argChoices.map((choice) => JSON.stringify(choice)).join(", ")}`);
-    }
-    if (option.defaultValue !== undefined) {
-      const showDefault = option.required || option.optional || option.isBoolean() && typeof option.defaultValue === "boolean";
-      if (showDefault) {
-        extraInfo.push(`default: ${option.defaultValueDescription || JSON.stringify(option.defaultValue)}`);
-      }
-    }
-    if (option.presetArg !== undefined && option.optional) {
-      extraInfo.push(`preset: ${JSON.stringify(option.presetArg)}`);
-    }
-    if (option.envVar !== undefined) {
-      extraInfo.push(`env: ${option.envVar}`);
-    }
-    if (extraInfo.length > 0) {
-      const extraDescription = `(${extraInfo.join(", ")})`;
-      if (option.description) {
-        return `${option.description} ${extraDescription}`;
-      }
-      return extraDescription;
-    }
-    return option.description;
+}
+var CF_API_BASE2 = "https://api.cloudflare.com/client/v4";
+var init_trace_service = __esm(() => {
+  init_errors4();
+});
+
+// src/index.ts
+import { readFileSync as readFileSync8 } from "fs";
+
+// ../../node_modules/.bun/commander@15.0.0/node_modules/commander/lib/error.js
+class CommanderError extends Error {
+  constructor(exitCode, code, message) {
+    super(message);
+    Error.captureStackTrace(this, this.constructor);
+    this.name = this.constructor.name;
+    this.code = code;
+    this.exitCode = exitCode;
+    this.nestedError = undefined;
   }
-  argumentDescription(argument) {
-    const extraInfo = [];
-    if (argument.argChoices) {
-      extraInfo.push(`choices: ${argument.argChoices.map((choice) => JSON.stringify(choice)).join(", ")}`);
+}
+
+class InvalidArgumentError extends CommanderError {
+  constructor(message) {
+    super(1, "commander.invalidArgument", message);
+    Error.captureStackTrace(this, this.constructor);
+    this.name = this.constructor.name;
+  }
+}
+
+// ../../node_modules/.bun/commander@15.0.0/node_modules/commander/lib/argument.js
+class Argument {
+  constructor(name, description) {
+    this.description = description || "";
+    this.variadic = false;
+    this.parseArg = undefined;
+    this.defaultValue = undefined;
+    this.defaultValueDescription = undefined;
+    this.argChoices = undefined;
+    switch (name[0]) {
+      case "<":
+        this.required = true;
+        this._name = name.slice(1, -1);
+        break;
+      case "[":
+        this.required = false;
+        this._name = name.slice(1, -1);
+        break;
+      default:
+        this.required = true;
+        this._name = name;
+        break;
     }
-    if (argument.defaultValue !== undefined) {
-      extraInfo.push(`default: ${argument.defaultValueDescription || JSON.stringify(argument.defaultValue)}`);
+    if (this._name.endsWith("...")) {
+      this.variadic = true;
+      this._name = this._name.slice(0, -3);
     }
-    if (extraInfo.length > 0) {
-      const extraDescription = `(${extraInfo.join(", ")})`;
-      if (argument.description) {
-        return `${argument.description} ${extraDescription}`;
-      }
-      return extraDescription;
+  }
+  name() {
+    return this._name;
+  }
+  _collectValue(value, previous) {
+    if (previous === this.defaultValue || !Array.isArray(previous)) {
+      return [value];
     }
-    return argument.description;
+    previous.push(value);
+    return previous;
   }
-  formatItemList(heading, items, helper) {
-    if (items.length === 0)
-      return [];
-    return [helper.styleTitle(heading), ...items, ""];
+  default(value, description) {
+    this.defaultValue = value;
+    this.defaultValueDescription = description;
+    return this;
   }
-  groupItems(unsortedItems, visibleItems, getGroup) {
+  argParser(fn) {
+    this.parseArg = fn;
+    return this;
+  }
+  choices(values) {
+    this.argChoices = values.slice();
+    this.parseArg = (arg, previous) => {
+      if (!this.argChoices.includes(arg)) {
+        throw new InvalidArgumentError(`Allowed choices are ${this.argChoices.join(", ")}.`);
+      }
+      if (this.variadic) {
+        return this._collectValue(arg, previous);
+      }
+      return arg;
+    };
+    return this;
+  }
+  argRequired() {
+    this.required = true;
+    return this;
+  }
+  argOptional() {
+    this.required = false;
+    return this;
+  }
+}
+function humanReadableArgName(arg) {
+  const nameOutput = arg.name() + (arg.variadic === true ? "..." : "");
+  return arg.required ? "<" + nameOutput + ">" : "[" + nameOutput + "]";
+}
+
+// ../../node_modules/.bun/commander@15.0.0/node_modules/commander/lib/command.js
+import { EventEmitter } from "events";
+import childProcess from "child_process";
+import path from "path";
+import fs from "fs";
+import process2 from "process";
+import { stripVTControlCharacters as stripVTControlCharacters2 } from "util";
+
+// ../../node_modules/.bun/commander@15.0.0/node_modules/commander/lib/help.js
+import { stripVTControlCharacters } from "util";
+
+class Help {
+  constructor() {
+    this.helpWidth = undefined;
+    this.minWidthToWrap = 40;
+    this.sortSubcommands = false;
+    this.sortOptions = false;
+    this.showGlobalOptions = false;
+  }
+  prepareContext(contextOptions) {
+    this.helpWidth = this.helpWidth ?? contextOptions.helpWidth ?? 80;
+  }
+  visibleCommands(cmd) {
+    const visibleCommands = cmd.commands.filter((cmd2) => !cmd2._hidden);
+    const helpCommand = cmd._getHelpCommand();
+    if (helpCommand && !helpCommand._hidden) {
+      visibleCommands.push(helpCommand);
+    }
+    if (this.sortSubcommands) {
+      visibleCommands.sort((a, b) => {
+        return a.name().localeCompare(b.name());
+      });
+    }
+    return visibleCommands;
+  }
+  compareOptions(a, b) {
+    const getSortKey = (option) => {
+      return option.short ? option.short.replace(/^-/, "") : option.long.replace(/^--/, "");
+    };
+    return getSortKey(a).localeCompare(getSortKey(b));
+  }
+  visibleOptions(cmd) {
+    const visibleOptions = cmd.options.filter((option) => !option.hidden);
+    const helpOption = cmd._getHelpOption();
+    if (helpOption && !helpOption.hidden) {
+      const removeShort = helpOption.short && cmd._findOption(helpOption.short);
+      const removeLong = helpOption.long && cmd._findOption(helpOption.long);
+      if (!removeShort && !removeLong) {
+        visibleOptions.push(helpOption);
+      } else if (helpOption.long && !removeLong) {
+        visibleOptions.push(cmd.createOption(helpOption.long, helpOption.description));
+      } else if (helpOption.short && !removeShort) {
+        visibleOptions.push(cmd.createOption(helpOption.short, helpOption.description));
+      }
+    }
+    if (this.sortOptions) {
+      visibleOptions.sort(this.compareOptions);
+    }
+    return visibleOptions;
+  }
+  visibleGlobalOptions(cmd) {
+    if (!this.showGlobalOptions)
+      return [];
+    const globalOptions = [];
+    for (let ancestorCmd = cmd.parent;ancestorCmd; ancestorCmd = ancestorCmd.parent) {
+      const visibleOptions = ancestorCmd.options.filter((option) => !option.hidden);
+      globalOptions.push(...visibleOptions);
+    }
+    if (this.sortOptions) {
+      globalOptions.sort(this.compareOptions);
+    }
+    return globalOptions;
+  }
+  visibleArguments(cmd) {
+    if (cmd._argsDescription) {
+      cmd.registeredArguments.forEach((argument) => {
+        argument.description = argument.description || cmd._argsDescription[argument.name()] || "";
+      });
+    }
+    if (cmd.registeredArguments.find((argument) => argument.description)) {
+      return cmd.registeredArguments;
+    }
+    return [];
+  }
+  subcommandTerm(cmd) {
+    const args = cmd.registeredArguments.map((arg) => humanReadableArgName(arg)).join(" ");
+    return cmd._name + (cmd._aliases[0] ? "|" + cmd._aliases[0] : "") + (cmd.options.length ? " [options]" : "") + (args ? " " + args : "");
+  }
+  optionTerm(option) {
+    return option.flags;
+  }
+  argumentTerm(argument) {
+    return argument.name();
+  }
+  longestSubcommandTermLength(cmd, helper) {
+    return helper.visibleCommands(cmd).reduce((max, command) => {
+      return Math.max(max, this.displayWidth(helper.styleSubcommandTerm(helper.subcommandTerm(command))));
+    }, 0);
+  }
+  longestOptionTermLength(cmd, helper) {
+    return helper.visibleOptions(cmd).reduce((max, option) => {
+      return Math.max(max, this.displayWidth(helper.styleOptionTerm(helper.optionTerm(option))));
+    }, 0);
+  }
+  longestGlobalOptionTermLength(cmd, helper) {
+    return helper.visibleGlobalOptions(cmd).reduce((max, option) => {
+      return Math.max(max, this.displayWidth(helper.styleOptionTerm(helper.optionTerm(option))));
+    }, 0);
+  }
+  longestArgumentTermLength(cmd, helper) {
+    return helper.visibleArguments(cmd).reduce((max, argument) => {
+      return Math.max(max, this.displayWidth(helper.styleArgumentTerm(helper.argumentTerm(argument))));
+    }, 0);
+  }
+  commandUsage(cmd) {
+    let cmdName = cmd._name;
+    if (cmd._aliases[0]) {
+      cmdName = cmdName + "|" + cmd._aliases[0];
+    }
+    let ancestorCmdNames = "";
+    for (let ancestorCmd = cmd.parent;ancestorCmd; ancestorCmd = ancestorCmd.parent) {
+      ancestorCmdNames = ancestorCmd.name() + " " + ancestorCmdNames;
+    }
+    return ancestorCmdNames + cmdName + " " + cmd.usage();
+  }
+  commandDescription(cmd) {
+    return cmd.description();
+  }
+  subcommandDescription(cmd) {
+    return cmd.summary() || cmd.description();
+  }
+  optionDescription(option) {
+    const extraInfo = [];
+    if (option.argChoices) {
+      extraInfo.push(`choices: ${option.argChoices.map((choice) => JSON.stringify(choice)).join(", ")}`);
+    }
+    if (option.defaultValue !== undefined) {
+      const showDefault = option.required || option.optional || option.isBoolean() && typeof option.defaultValue === "boolean";
+      if (showDefault) {
+        extraInfo.push(`default: ${option.defaultValueDescription || JSON.stringify(option.defaultValue)}`);
+      }
+    }
+    if (option.presetArg !== undefined && option.optional) {
+      extraInfo.push(`preset: ${JSON.stringify(option.presetArg)}`);
+    }
+    if (option.envVar !== undefined) {
+      extraInfo.push(`env: ${option.envVar}`);
+    }
+    if (extraInfo.length > 0) {
+      const extraDescription = `(${extraInfo.join(", ")})`;
+      if (option.description) {
+        return `${option.description} ${extraDescription}`;
+      }
+      return extraDescription;
+    }
+    return option.description;
+  }
+  argumentDescription(argument) {
+    const extraInfo = [];
+    if (argument.argChoices) {
+      extraInfo.push(`choices: ${argument.argChoices.map((choice) => JSON.stringify(choice)).join(", ")}`);
+    }
+    if (argument.defaultValue !== undefined) {
+      extraInfo.push(`default: ${argument.defaultValueDescription || JSON.stringify(argument.defaultValue)}`);
+    }
+    if (extraInfo.length > 0) {
+      const extraDescription = `(${extraInfo.join(", ")})`;
+      if (argument.description) {
+        return `${argument.description} ${extraDescription}`;
+      }
+      return extraDescription;
+    }
+    return argument.description;
+  }
+  formatItemList(heading, items, helper) {
+    if (items.length === 0)
+      return [];
+    return [helper.styleTitle(heading), ...items, ""];
+  }
+  groupItems(unsortedItems, visibleItems, getGroup) {
     const result = new Map;
     unsortedItems.forEach((item) => {
       const group = getGroup(item);
@@ -26983,608 +27371,254 @@ function colorizeCell(value, colorizeStatus) {
   ].includes(lower)) {
     return `${theme.success(icons.success)} ${theme.text(v)}`;
   }
-  if (["warn", "warning", "degraded", "partial", "pending"].includes(lower)) {
-    return `${theme.warning(icons.warning)} ${theme.text(v)}`;
-  }
-  if ([
-    "err",
-    "error",
-    "fail",
-    "failed",
-    "down",
-    "unreachable",
-    "disabled"
-  ].includes(lower)) {
-    return `${theme.error(icons.error)} ${theme.text(v)}`;
-  }
-  return value;
-}
-function formatJson(data, opts) {
-  const json2 = opts?.quiet ? JSON.stringify(data) : JSON.stringify(data, null, 2);
-  process.stdout.write(`${json2}
-`);
-}
-function formatKeyValue(pairs, opts = {}) {
-  if (opts.quiet)
-    return;
-  if (opts.json) {
-    process.stdout.write(JSON.stringify(pairs, null, 2) + `
-`);
-    return;
-  }
-  const maxKeyLen = Math.max(...Object.keys(pairs).map((k) => stripAnsi(k).length), 0);
-  for (const [key, value] of Object.entries(pairs)) {
-    const paddedKey = key.padEnd(maxKeyLen);
-    process.stdout.write(`  ${theme.key(paddedKey)} ${theme.textMuted(":")} ${value}
-`);
-  }
-}
-function getFormatOptions(cmd) {
-  const opts = cmd.optsWithGlobals();
-  return {
-    json: Boolean(opts.json),
-    quiet: Boolean(opts.quiet),
-    noColor: Boolean(opts.color === false)
-  };
-}
-function formatCompletion(message, opts = {}) {
-  if (opts.json || opts.quiet)
-    return;
-  if (process.exitCode && process.exitCode !== 0)
-    return;
-  if (!isRichMode(opts))
-    return;
-  const parts = [theme.success(icons.success), theme.text(message)];
-  if (opts.durationMs !== undefined) {
-    parts.push(theme.textMuted(formatDuration3(opts.durationMs)));
-  }
-  process.stdout.write(`${parts.join(" ")}
-`);
-  if (opts.suggestion) {
-    const reason = opts.suggestion.reason ? ` ${theme.textMuted(`(${opts.suggestion.reason})`)}` : "";
-    process.stdout.write(`  ${theme.textMuted("\u2192")} ${theme.textMuted("next:")} ${theme.accent(opts.suggestion.command)}${reason}
-`);
-  }
-}
-
-// src/utils/error-handler.ts
-init_errors4();
-
-// src/utils/string.ts
-function levenshtein(a2, b) {
-  if (a2 === b)
-    return 0;
-  if (a2.length === 0)
-    return b.length;
-  if (b.length === 0)
-    return a2.length;
-  const [s, t] = a2.length <= b.length ? [a2, b] : [b, a2];
-  const m = s.length;
-  const n = t.length;
-  let prev = new Array(m + 1);
-  for (let i = 0;i <= m; i++)
-    prev[i] = i;
-  let curr = new Array(m + 1);
-  for (let j = 1;j <= n; j++) {
-    curr[0] = j;
-    for (let i = 1;i <= m; i++) {
-      const cost = s.charCodeAt(i - 1) === t.charCodeAt(j - 1) ? 0 : 1;
-      curr[i] = Math.min(curr[i - 1] + 1, prev[i] + 1, prev[i - 1] + cost);
-    }
-    [prev, curr] = [curr, prev];
-  }
-  return prev[m];
-}
-
-// src/utils/error-handler.ts
-var SUGGESTION_THRESHOLD = 2;
-function collectCommandNames(cmd, acc = new Set) {
-  for (const sub of cmd.commands) {
-    if (sub.name() && !sub.hidden) {
-      acc.add(sub.name());
-      collectCommandNames(sub, acc);
-    }
-  }
-  return acc;
-}
-function suggestForCommand(program2, unknown2) {
-  if (unknown2.length < 2)
-    return;
-  const normalized = unknown2.replace(/s$/, "");
-  const candidates = collectCommandNames(program2);
-  let best;
-  for (const candidate of candidates) {
-    const d = Math.min(levenshtein(unknown2, candidate), levenshtein(normalized, candidate));
-    if (d > SUGGESTION_THRESHOLD)
-      continue;
-    if (!best || d < best.dist) {
-      best = { name: candidate, dist: d };
-    }
-  }
-  return best?.name;
-}
-function withErrorHandling(handler, options) {
-  return async (...args) => {
-    try {
-      await handler(...args);
-    } catch (error51) {
-      const service = options?.service ?? "cli";
-      if (error51 instanceof CLIError) {
-        formatError2(error51, options?.opts);
-        process.exitCode = error51.code;
-        return;
-      } else if (error51 instanceof Error) {
-        formatError2(`[${service}] ${error51.message}`, options?.opts);
-        process.exitCode = 1 /* ERROR */;
-        return;
-      } else {
-        formatError2(`[${service}] Unknown error: ${String(error51)}`, options?.opts);
-        process.exitCode = 4 /* CommandFailed */;
-        return;
-      }
-    }
-  };
-}
-
-// src/utils/help-formatter.ts
-function renderHelp(cmd, helper) {
-  const subcommands = cmd.commands.filter((c) => !c._hidden).map((c) => ({ name: c.name(), desc: c.description() ?? "" }));
-  const blocks = [];
-  const argNames = cmd.registeredArguments.map((a2) => a2.name()).join(" ");
-  const titleName = argNames ? `${cmd.name()} ${argNames}` : cmd.name();
-  blocks.push(theme.heading(` ${titleName}`));
-  if (cmd.description()) {
-    blocks.push(` ${theme.textMuted(cmd.description())}`);
-  }
-  blocks.push(theme.textFaint("\u2500".repeat(60)));
-  const usageLine = buildUsage(cmd);
-  blocks.push(headerLine("Usage"));
-  blocks.push(`   ${theme.accent(usageLine)}`);
-  const options = cmd.options.filter((o) => !o.hidden);
-  if (options.length > 0) {
-    blocks.push("");
-    blocks.push(headerLine("Options"));
-    const flagWidth = Math.max(...options.map((o) => o.flags.length));
-    for (const o of options) {
-      const padded = o.flags.padEnd(flagWidth);
-      const desc = o.description ? theme.textMuted(o.description) : "";
-      blocks.push(`   ${theme.text(padded)}  ${desc}`);
-    }
-  }
-  if (subcommands.length > 0) {
-    blocks.push("");
-    blocks.push(headerLine("Commands"));
-    const nameWidth = Math.max(...subcommands.map((s) => s.name.length));
-    for (const s of subcommands) {
-      const padded = s.name.padEnd(nameWidth);
-      blocks.push(`   ${theme.text(padded)}  ${theme.textMuted(s.desc)}`);
-    }
-  }
-  const afterText = captureHelpEvent(cmd, "afterHelp");
-  if (afterText.trim()) {
-    blocks.push("");
-    blocks.push(headerLine("Examples"));
-    blocks.push(`   ${theme.textMuted(afterText.trim())}`);
-  }
-  const out = blocks.join(`
-`) + `
-`;
-  return isRichMode() ? out : stripAnsi(out);
-}
-function headerLine(text) {
-  return ` ${theme.textSubtle(text)}`;
-}
-function buildUsage(cmd) {
-  const parts = [];
-  let c = cmd;
-  while (c && c.name()) {
-    parts.unshift(c.name());
-    c = c.parent;
-  }
-  for (const arg of cmd.registeredArguments) {
-    parts.push(arg.name());
-  }
-  return `${parts.join(" ")} [options]`;
-}
-function captureHelpEvent(cmd, eventName) {
-  const parts = [];
-  const context = {
-    error: false,
-    command: cmd,
-    write: (str) => {
-      parts.push(str);
-    }
-  };
-  const emitter = cmd;
-  emitter.emit(eventName, context);
-  return parts.join("");
-}
-
-// src/utils/completion.ts
-var SUGGEST_NEXT = {
-  init: { command: "hoox setup", reason: "provision infrastructure" },
-  setup: { command: "hoox deploy all", reason: "ship to Cloudflare" },
-  "deploy all": { command: "hoox check health", reason: "verify the deploy" },
-  "check health": { command: "hoox monitor status", reason: "keep watching" },
-  "monitor kill-switch off": {
-    command: "hoox check health",
-    reason: "re-enable trading"
-  }
-};
-function suggestNextCommand(commandPath) {
-  return SUGGEST_NEXT[commandPath];
-}
-function getCmdPath(cmd) {
-  const parts = [];
-  let current2 = cmd;
-  while (current2 && current2.name() && current2.parent) {
-    parts.unshift(current2.name());
-    current2 = current2.parent;
-  }
-  return parts.join(" ");
-}
-
-// src/commands/init/init-command.ts
-init_dist4();
-init_src();
-
-// src/services/cloudflare/cloudflare-service.ts
-init_config2();
-import path3 from "path";
-
-class CloudflareService {
-  cwd;
-  homeDir;
-  configService;
-  constructor(cwd, homeDir, configService) {
-    this.cwd = cwd ?? process.cwd();
-    this.homeDir = homeDir;
-    this.configService = configService ?? (this.homeDir ? new ConfigService(undefined, this.homeDir) : undefined);
-  }
-  resolveWorkerPath(workerPath) {
-    if (this.configService) {
-      const workerName = path3.basename(workerPath);
-      return this.configService.getWorkerPath(workerName);
-    }
-    if (this.homeDir) {
-      const workerName = path3.basename(workerPath);
-      return path3.join(this.homeDir, ".hoox", "workers", workerName);
-    }
-    return path3.resolve(this.cwd, workerPath);
-  }
-  async runWrangler(args, cwd) {
-    try {
-      const proc = Bun.spawn(["wrangler", ...args], {
-        cwd: cwd ?? this.cwd,
-        stdout: "pipe",
-        stderr: "pipe"
-      });
-      const stdout2 = await new Response(proc.stdout).text();
-      const stderr = await new Response(proc.stderr).text();
-      const exitCode = await proc.exited;
-      if (exitCode === 0) {
-        return { ok: true, value: stdout2.trim() };
-      }
-      return {
-        ok: false,
-        error: stderr.trim() || `wrangler exited with code ${exitCode}`
-      };
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      const hint = /ENOENT|not found/i.test(message) ? "Install wrangler with `bun add -g wrangler` (or `npm i -g wrangler`), then run `wrangler login`." : undefined;
-      return {
-        ok: false,
-        error: hint ? `Failed to spawn wrangler: ${message}
-\u21B3 hint: ${hint}` : `Failed to spawn wrangler: ${message}`
-      };
-    }
-  }
-  async whoami() {
-    return this.runWrangler(["whoami"]);
-  }
-  async deploy(workerPath, env) {
-    const resolvedPath = this.resolveWorkerPath(workerPath);
-    const args = ["deploy"];
-    if (env) {
-      args.push("--env", env);
-    }
-    const result = await this.runWrangler(args, resolvedPath);
-    if (!result.ok) {
-      return result;
-    }
-    const url2 = this.extractUrl(result.value);
-    const output = result.value;
-    const deployResult = { url: url2, rawOutput: output };
-    const pathParts = workerPath.split("/");
-    deployResult.name = pathParts[pathParts.length - 1];
-    const sizeMatch = output.match(/Total Upload:\s*([\d.]+)\s*([KMGT]?i?B)/i);
-    if (sizeMatch) {
-      deployResult.size = `${sizeMatch[1]} ${sizeMatch[2]}`;
-    }
-    const startupMatch = output.match(/Worker Startup Time:\s*(\d+)\s*ms/i);
-    if (startupMatch) {
-      deployResult.startupTime = `${startupMatch[1]} ms`;
-    }
-    const versionMatch = output.match(/Current Version ID:\s*([a-f0-9-]{36,})/i);
-    if (versionMatch) {
-      deployResult.versionId = versionMatch[1];
-    }
-    return { ok: true, value: deployResult };
-  }
-  async versionsList(workerName) {
-    const result = await this.runWrangler([
-      "versions",
-      "list",
-      "--name",
-      workerName,
-      "--json"
-    ]);
-    if (!result.ok) {
-      return result;
-    }
-    try {
-      const parsed = JSON.parse(result.value);
-      if (!Array.isArray(parsed)) {
-        return {
-          ok: false,
-          error: `Expected array from wrangler versions list, got ${typeof parsed}`
-        };
-      }
-      const versions2 = parsed.map((v) => ({
-        id: String(v.id ?? ""),
-        number: typeof v.number === "number" ? v.number : undefined,
-        created_on: typeof v.metadata === "object" && v.metadata !== null ? String(v.metadata.created_on ?? "") : undefined,
-        author: typeof v.metadata === "object" && v.metadata !== null ? String(v.metadata.author ?? "") : undefined,
-        message: typeof v.metadata === "object" && v.metadata !== null ? String(v.metadata.message ?? "") : undefined,
-        source: typeof v.metadata === "object" && v.metadata !== null ? String(v.metadata.source ?? "") : undefined
-      }));
-      return { ok: true, value: versions2 };
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      return {
-        ok: false,
-        error: `Failed to parse versions list: ${message}`
-      };
-    }
-  }
-  async versionsRollback(workerName, versionId) {
-    return this.runWrangler([
-      "versions",
-      "rollback",
-      "--name",
-      workerName,
-      "--version-id",
-      versionId
-    ]);
-  }
-  async dev(workerPath, port) {
-    const devPort = port ?? 8787;
-    const resolvedPath = this.resolveWorkerPath(workerPath);
-    try {
-      Bun.spawn(["wrangler", "dev", "--port", String(devPort)], {
-        cwd: resolvedPath,
-        stdout: "pipe",
-        stderr: "pipe"
-      });
-      return { ok: true, value: { port: devPort } };
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      return { ok: false, error: `Failed to start dev server: ${message}` };
-    }
-  }
-  async tail(workerName) {
-    return this.runWrangler(["tail", workerName]);
-  }
-  async d1List() {
-    return this.runWrangler(["d1", "list", "--json"]);
-  }
-  async d1Create(name) {
-    return this.runWrangler(["d1", "create", name]);
-  }
-  async d1Delete(name) {
-    return this.runWrangler(["d1", "delete", name]);
-  }
-  async d1Execute(name, sql, remote = true) {
-    const args = ["d1", "execute", name, "--command", sql];
-    if (remote)
-      args.push("--remote");
-    const result = await this.runWrangler(args);
-    if (!result.ok)
-      return result;
-    const extracted = extractJsonArray(result.value);
-    if (extracted === null) {
-      return {
-        ok: false,
-        error: `wrangler d1 execute returned non-JSON output: ${result.value.slice(0, 200)}`
-      };
-    }
-    return { ok: true, value: extracted };
-  }
-  async kvList() {
-    return this.runWrangler(["kv", "namespace", "list"]);
-  }
-  async kvCreate(name) {
-    return this.runWrangler(["kv", "namespace", "create", name]);
-  }
-  async kvDelete(id) {
-    return this.runWrangler([
-      "kv",
-      "namespace",
-      "delete",
-      "--namespace-id",
-      id
-    ]);
-  }
-  async r2List() {
-    return this.runWrangler(["r2", "bucket", "list"]);
-  }
-  async r2Create(name) {
-    return this.runWrangler(["r2", "bucket", "create", name]);
-  }
-  async r2Delete(name) {
-    return this.runWrangler(["r2", "bucket", "delete", name]);
-  }
-  async queueList() {
-    return this.runWrangler(["queues", "list"]);
+  if (["warn", "warning", "degraded", "partial", "pending"].includes(lower)) {
+    return `${theme.warning(icons.warning)} ${theme.text(v)}`;
   }
-  async queueCreate(name) {
-    return this.runWrangler(["queues", "create", name]);
+  if ([
+    "err",
+    "error",
+    "fail",
+    "failed",
+    "down",
+    "unreachable",
+    "disabled"
+  ].includes(lower)) {
+    return `${theme.error(icons.error)} ${theme.text(v)}`;
   }
-  async queueDelete(name) {
-    return this.runWrangler(["queues", "delete", name]);
+  return value;
+}
+function formatJson(data, opts) {
+  const json2 = opts?.quiet ? JSON.stringify(data) : JSON.stringify(data, null, 2);
+  process.stdout.write(`${json2}
+`);
+}
+function formatKeyValue(pairs, opts = {}) {
+  if (opts.quiet)
+    return;
+  if (opts.json) {
+    process.stdout.write(JSON.stringify(pairs, null, 2) + `
+`);
+    return;
   }
-  async vectorizeList() {
-    return this.runWrangler(["vectorize", "list", "--json"]);
+  const maxKeyLen = Math.max(...Object.keys(pairs).map((k) => stripAnsi(k).length), 0);
+  for (const [key, value] of Object.entries(pairs)) {
+    const paddedKey = key.padEnd(maxKeyLen);
+    process.stdout.write(`  ${theme.key(paddedKey)} ${theme.textMuted(":")} ${value}
+`);
   }
-  async vectorizeCreate(name, dimensions = 768, metric = "cosine") {
-    return this.runWrangler([
-      "vectorize",
-      "create",
-      name,
-      "--dimensions",
-      String(dimensions),
-      "--metric",
-      metric
-    ]);
+}
+function getFormatOptions(cmd) {
+  const opts = cmd.optsWithGlobals();
+  return {
+    json: Boolean(opts.json),
+    quiet: Boolean(opts.quiet),
+    noColor: Boolean(opts.color === false)
+  };
+}
+function formatCompletion(message, opts = {}) {
+  if (opts.json || opts.quiet)
+    return;
+  if (process.exitCode && process.exitCode !== 0)
+    return;
+  if (!isRichMode(opts))
+    return;
+  const parts = [theme.success(icons.success), theme.text(message)];
+  if (opts.durationMs !== undefined) {
+    parts.push(theme.textMuted(formatDuration3(opts.durationMs)));
   }
-  async vectorizeDelete(name) {
-    return this.runWrangler(["vectorize", "delete", name]);
+  process.stdout.write(`${parts.join(" ")}
+`);
+  if (opts.suggestion) {
+    const reason = opts.suggestion.reason ? ` ${theme.textMuted(`(${opts.suggestion.reason})`)}` : "";
+    process.stdout.write(`  ${theme.textMuted("\u2192")} ${theme.textMuted("next:")} ${theme.accent(opts.suggestion.command)}${reason}
+`);
   }
-  async analyticsList() {
-    return this.runWrangler(["analytics", "dataset", "list"]);
+}
+
+// src/utils/error-handler.ts
+init_errors4();
+
+// src/utils/string.ts
+function levenshtein(a2, b) {
+  if (a2 === b)
+    return 0;
+  if (a2.length === 0)
+    return b.length;
+  if (b.length === 0)
+    return a2.length;
+  const [s, t] = a2.length <= b.length ? [a2, b] : [b, a2];
+  const m = s.length;
+  const n = t.length;
+  let prev = new Array(m + 1);
+  for (let i = 0;i <= m; i++)
+    prev[i] = i;
+  let curr = new Array(m + 1);
+  for (let j = 1;j <= n; j++) {
+    curr[0] = j;
+    for (let i = 1;i <= m; i++) {
+      const cost = s.charCodeAt(i - 1) === t.charCodeAt(j - 1) ? 0 : 1;
+      curr[i] = Math.min(curr[i - 1] + 1, prev[i] + 1, prev[i - 1] + cost);
+    }
+    [prev, curr] = [curr, prev];
   }
-  async analyticsCreate(_name) {
-    return {
-      ok: false,
-      error: `Analytics datasets cannot be created via wrangler. ` + `Please use the Cloudflare Dashboard: ` + `https://dash.cloudflare.com/?to=/:account/analytics`
-    };
+  return prev[m];
+}
+
+// src/utils/error-handler.ts
+var SUGGESTION_THRESHOLD = 2;
+function collectCommandNames(cmd, acc = new Set) {
+  for (const sub of cmd.commands) {
+    if (sub.name() && !sub.hidden) {
+      acc.add(sub.name());
+      collectCommandNames(sub, acc);
+    }
   }
-  async secretList(workerName) {
-    const result = await this.runWrangler([
-      "secret",
-      "list",
-      "--name",
-      workerName
-    ]);
-    if (!result.ok)
-      return result;
-    const extracted = extractJsonArray(result.value);
-    if (extracted === null) {
-      return {
-        ok: false,
-        error: `wrangler secret list returned non-JSON output: ${result.value.slice(0, 200)}`
-      };
+  return acc;
+}
+function suggestForCommand(program2, unknown2) {
+  if (unknown2.length < 2)
+    return;
+  const normalized = unknown2.replace(/s$/, "");
+  const candidates = collectCommandNames(program2);
+  let best;
+  for (const candidate of candidates) {
+    const d = Math.min(levenshtein(unknown2, candidate), levenshtein(normalized, candidate));
+    if (d > SUGGESTION_THRESHOLD)
+      continue;
+    if (!best || d < best.dist) {
+      best = { name: candidate, dist: d };
     }
-    return { ok: true, value: extracted };
   }
-  async secretPut(workerName, secretName, value) {
+  return best?.name;
+}
+function withErrorHandling(handler, options) {
+  return async (...args) => {
     try {
-      const proc = Bun.spawn(["wrangler", "secret", "put", secretName, "--name", workerName], {
-        cwd: this.cwd,
-        stdout: "pipe",
-        stderr: "pipe",
-        stdin: "pipe"
-      });
-      proc.stdin.write(value + `
-`);
-      proc.stdin.end();
-      const stdout2 = await new Response(proc.stdout).text();
-      const stderr = await new Response(proc.stderr).text();
-      const exitCode = await proc.exited;
-      if (exitCode === 0) {
-        return { ok: true, value: stdout2.trim() };
+      await handler(...args);
+    } catch (error51) {
+      const service = options?.service ?? "cli";
+      if (error51 instanceof CLIError) {
+        formatError2(error51, options?.opts);
+        process.exitCode = error51.code;
+        return;
+      } else if (error51 instanceof Error) {
+        formatError2(`[${service}] ${error51.message}`, options?.opts);
+        process.exitCode = 1 /* ERROR */;
+        return;
+      } else {
+        formatError2(`[${service}] Unknown error: ${String(error51)}`, options?.opts);
+        process.exitCode = 4 /* CommandFailed */;
+        return;
       }
-      return {
-        ok: false,
-        error: stderr.trim() || `wrangler exited with code ${exitCode}`
-      };
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      return { ok: false, error: `Failed to set secret: ${message}` };
     }
+  };
+}
+
+// src/utils/help-formatter.ts
+function renderHelp(cmd, helper) {
+  const subcommands = cmd.commands.filter((c) => !c._hidden).map((c) => ({ name: c.name(), desc: c.description() ?? "" }));
+  const blocks = [];
+  const argNames = cmd.registeredArguments.map((a2) => a2.name()).join(" ");
+  const titleName = argNames ? `${cmd.name()} ${argNames}` : cmd.name();
+  blocks.push(theme.heading(` ${titleName}`));
+  if (cmd.description()) {
+    blocks.push(` ${theme.textMuted(cmd.description())}`);
   }
-  async secretDelete(workerName, secretName) {
-    return this.runWrangler([
-      "secret",
-      "delete",
-      secretName,
-      "--name",
-      workerName
-    ]);
-  }
-  async zonesList() {
-    const token = process.env.CLOUDFLARE_API_TOKEN;
-    if (!token) {
-      return {
-        ok: false,
-        error: "CLOUDFLARE_API_TOKEN environment variable is not set. Set it or run `wrangler login`."
-      };
+  blocks.push(theme.textFaint("\u2500".repeat(60)));
+  const usageLine = buildUsage(cmd);
+  blocks.push(headerLine("Usage"));
+  blocks.push(`   ${theme.accent(usageLine)}`);
+  const options = cmd.options.filter((o) => !o.hidden);
+  if (options.length > 0) {
+    blocks.push("");
+    blocks.push(headerLine("Options"));
+    const flagWidth = Math.max(...options.map((o) => o.flags.length));
+    for (const o of options) {
+      const padded = o.flags.padEnd(flagWidth);
+      const desc = o.description ? theme.textMuted(o.description) : "";
+      blocks.push(`   ${theme.text(padded)}  ${desc}`);
     }
-    try {
-      const response = await fetch("https://api.cloudflare.com/client/v4/zones?per_page=50", {
-        headers: {
-          Authorization: `Bearer ${token}`,
-          "Content-Type": "application/json"
-        }
-      });
-      const json2 = await response.json();
-      if (!response.ok || !json2.success) {
-        const errorMsg = json2.errors?.map((e) => e.message).join("; ") || `HTTP ${response.status}`;
-        return { ok: false, error: `Failed to list zones: ${errorMsg}` };
-      }
-      const lines = json2.result.map((z2) => `${z2.name} (${z2.id})`);
-      return { ok: true, value: lines.join(`
-`) };
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      return { ok: false, error: `Cloudflare API request failed: ${message}` };
+  }
+  if (subcommands.length > 0) {
+    blocks.push("");
+    blocks.push(headerLine("Commands"));
+    const nameWidth = Math.max(...subcommands.map((s) => s.name.length));
+    for (const s of subcommands) {
+      const padded = s.name.padEnd(nameWidth);
+      blocks.push(`   ${theme.text(padded)}  ${theme.textMuted(s.desc)}`);
     }
   }
-  extractUrl(stdout2) {
-    for (const line of stdout2.split(`
-`)) {
-      const trimmed = line.trim();
-      const match = trimmed.match(/(https?:\/\/[^\s]+(?:workers\.dev|cloudflareworkers\.com)[^\s]*)/);
-      if (match)
-        return match[1];
-    }
-    return;
+  const afterText = captureHelpEvent(cmd, "afterHelp");
+  if (afterText.trim()) {
+    blocks.push("");
+    blocks.push(headerLine("Examples"));
+    blocks.push(`   ${theme.textMuted(afterText.trim())}`);
   }
+  const out = blocks.join(`
+`) + `
+`;
+  return isRichMode() ? out : stripAnsi(out);
 }
-function extractJsonArray(raw) {
-  const first = raw.indexOf("[");
-  if (first === -1)
-    return null;
-  let depth = 0;
-  let inString = false;
-  let escape = false;
-  for (let i2 = first;i2 < raw.length; i2++) {
-    const ch = raw[i2];
-    if (escape) {
-      escape = false;
-      continue;
-    }
-    if (inString) {
-      if (ch === "\\")
-        escape = true;
-      else if (ch === '"')
-        inString = false;
-      continue;
-    }
-    if (ch === '"') {
-      inString = true;
-      continue;
-    }
-    if (ch === "[")
-      depth++;
-    else if (ch === "]") {
-      depth--;
-      if (depth === 0)
-        return raw.slice(first, i2 + 1);
+function headerLine(text) {
+  return ` ${theme.textSubtle(text)}`;
+}
+function buildUsage(cmd) {
+  const parts = [];
+  let c = cmd;
+  while (c && c.name()) {
+    parts.unshift(c.name());
+    c = c.parent;
+  }
+  for (const arg of cmd.registeredArguments) {
+    parts.push(arg.name());
+  }
+  return `${parts.join(" ")} [options]`;
+}
+function captureHelpEvent(cmd, eventName) {
+  const parts = [];
+  const context = {
+    error: false,
+    command: cmd,
+    write: (str) => {
+      parts.push(str);
     }
+  };
+  const emitter = cmd;
+  emitter.emit(eventName, context);
+  return parts.join("");
+}
+
+// src/utils/completion.ts
+var SUGGEST_NEXT = {
+  init: { command: "hoox setup", reason: "provision infrastructure" },
+  setup: { command: "hoox deploy all", reason: "ship to Cloudflare" },
+  "deploy all": { command: "hoox check health", reason: "verify the deploy" },
+  "check health": { command: "hoox monitor status", reason: "keep watching" },
+  "monitor kill-switch off": {
+    command: "hoox check health",
+    reason: "re-enable trading"
   }
-  return null;
+};
+function suggestNextCommand(commandPath) {
+  return SUGGEST_NEXT[commandPath];
+}
+function getCmdPath(cmd) {
+  const parts = [];
+  let current2 = cmd;
+  while (current2 && current2.name() && current2.parent) {
+    parts.unshift(current2.name());
+    current2 = current2.parent;
+  }
+  return parts.join(" ");
 }
+
+// src/commands/init/init-command.ts
+init_dist4();
+init_src();
+
+// src/services/cloudflare/index.ts
+init_cloudflare_service();
+
 // src/commands/init/init-command.ts
 init_errors4();
 
@@ -30832,7 +30866,7 @@ async function doUpdateInternalUrls(fmt) {
 }
 async function doKvConfig(fmt) {
   try {
-    const { KvSyncService: KvSyncService2 } = await Promise.resolve().then(() => exports_kv_sync_service);
+    const { KvSyncService: KvSyncService2 } = await Promise.resolve().then(() => (init_kv_sync_service(), exports_kv_sync_service));
     const kvSync = new KvSyncService2;
     process.stdout.write(`${theme.info("Resolving CONFIG_KV namespace...")}
 `);
@@ -32054,6 +32088,10 @@ EXAMPLES:
     await handleGenerateDevVars(opts);
   }, { service: "env" }));
 }
+
+// src/services/kv/index.ts
+init_kv_sync_service();
+
 // src/commands/config/kv-command.ts
 init_errors4();
 async function resolveNs(cmd) {
@@ -33419,12 +33457,75 @@ async function handleSetup(opts) {
     process.exitCode = 1 /* ERROR */;
   }
 }
+var HEALTH_PROBE_TIMEOUT_MS = 8000;
+function resolveWorkerBaseUrl(workerName, global) {
+  if (workerName === "hoox") {
+    const envUrl = process.env.HOOX_GATEWAY_URL;
+    if (envUrl && envUrl.length > 0) {
+      return envUrl.replace(/\/+$/, "");
+    }
+  }
+  const prefix = global.subdomain_prefix;
+  if (prefix && prefix.length > 0) {
+    return `https://${workerName}.${prefix}.workers.dev`;
+  }
+  const accountId = global.cloudflare_account_id || process.env.CLOUDFLARE_ACCOUNT_ID;
+  if (accountId && accountId.length > 0) {
+    return `https://${workerName}.${accountId}.workers.dev`;
+  }
+  throw new Error(`Cannot resolve URL for worker "${workerName}". Set global.subdomain_prefix or cloudflare_account_id in wrangler.jsonc (or HOOX_GATEWAY_URL for the gateway).`);
+}
+async function probeWorkerHealth(workerName, baseUrl, timeoutMs = HEALTH_PROBE_TIMEOUT_MS) {
+  const url2 = `${baseUrl.replace(/\/+$/, "")}/health`;
+  const started = Date.now();
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await fetch(url2, {
+      method: "GET",
+      signal: controller.signal,
+      headers: { Accept: "application/json" }
+    });
+    const responseTime = Date.now() - started;
+    if (res.ok) {
+      return {
+        worker: workerName,
+        status: "healthy",
+        connectivity: true,
+        responseTime,
+        url: url2
+      };
+    }
+    return {
+      worker: workerName,
+      status: res.status >= 500 ? "down" : "degraded",
+      connectivity: true,
+      responseTime,
+      url: url2,
+      error: `HTTP ${res.status}`
+    };
+  } catch (err) {
+    const responseTime = Date.now() - started;
+    const aborted2 = err instanceof Error && err.name === "AbortError" || typeof err === "object" && err !== null && "name" in err && err.name === "AbortError";
+    const message = aborted2 ? `Timeout after ${timeoutMs}ms` : err instanceof Error ? err.message : String(err);
+    return {
+      worker: workerName,
+      status: "down",
+      connectivity: false,
+      responseTime,
+      url: url2,
+      error: message
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
 async function handleHealth(opts, autoFix) {
   const results = [];
   try {
     const configService = new ConfigService;
     await configService.load();
-    const cf = new CloudflareService;
+    const global = configService.getGlobal();
     const enabledWorkers = configService.listEnabledWorkers();
     if (enabledWorkers.length === 0) {
       formatSuccess("No enabled workers to check", opts);
@@ -33434,14 +33535,8 @@ async function handleHealth(opts, autoFix) {
       title: `Probe ${workerName}`,
       run: async () => {
         try {
-          const tailResult = await cf.tail(workerName);
-          const healthy = tailResult.ok;
-          return {
-            worker: workerName,
-            status: healthy ? "healthy" : "degraded",
-            connectivity: healthy,
-            error: tailResult.ok ? undefined : tailResult.error ?? "Unknown error"
-          };
+          const baseUrl = resolveWorkerBaseUrl(workerName, global);
+          return await probeWorkerHealth(workerName, baseUrl);
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);
           return {
@@ -33468,6 +33563,7 @@ async function handleHealth(opts, autoFix) {
       const rows = results.map((r2) => ({
         Worker: r2.worker,
         Status: r2.status,
+        Latency: r2.responseTime != null ? `${r2.responseTime}ms` : "-",
         Connectivity: r2.connectivity ? "connected" : "failed",
         Error: r2.error ?? "-"
       }));
@@ -33796,10 +33892,11 @@ EXAMPLES:
   }, { service: "check" }));
   checkCmd.command("health").summary("Check worker connectivity and responsiveness").description(`Run health checks on all enabled workers to verify they are running and responsive.
 
-Each worker is probed to verify:
-  - Worker is deployed to Cloudflare
-  - Worker is responding to requests
-  - No critical errors in recent logs
+Each worker is probed with a short HTTP GET to /health (default timeout 8s):
+  - Worker URL from global.subdomain_prefix (or account id)
+  - healthy  \u2192 HTTP 2xx from /health
+  - degraded \u2192 reachable but non-2xx (e.g. 4xx)
+  - down     \u2192 timeout, DNS, or network error
 
 OPTIONS:
   --fix    Attempt automatic repair for detected issues (informational)
@@ -34285,6 +34382,7 @@ function registerTestCommand(program2) {
   }, { service: "test" }));
 }
 // src/commands/waf/waf-command.ts
+init_cloudflare_service();
 init_errors4();
 var CF_API_BASE = "https://api.cloudflare.com/client/v4";
 function getCredentials() {
@@ -34818,14 +34916,22 @@ init_dist4();
 
 // src/services/db/db-service.ts
 init_config2();
+init_cloudflare_service();
+import { existsSync as existsSync6 } from "fs";
 import { join as join7 } from "path";
+var D1_WRANGLER_CONFIG_CANDIDATES = [
+  "workers/d1-worker/wrangler.jsonc",
+  "workers/trade-worker/wrangler.jsonc"
+];
 
 class DbService {
   configService;
   homeDir;
-  constructor(configService, homeDir) {
+  wranglerConfigPath;
+  constructor(configService, homeDir, wranglerConfigPath) {
     this.configService = configService ?? new ConfigService;
     this.homeDir = homeDir;
+    this.wranglerConfigPath = wranglerConfigPath ?? process.env.HOOX_WRANGLER_CONFIG;
   }
   resolveDefaultSchemaPath() {
     if (this.homeDir) {
@@ -34897,7 +35003,8 @@ class DbService {
   }
   static parseTableNames(output) {
     try {
-      const parsed = JSON.parse(output);
+      const jsonText = extractJsonArray(output) ?? output;
+      const parsed = JSON.parse(jsonText);
       if (Array.isArray(parsed) && parsed.length > 0) {
         const first = parsed[0];
         if (first.results && Array.isArray(first.results)) {
@@ -34908,8 +35015,19 @@ class DbService {
     return output.split(`
 `).map((l2) => l2.trim()).filter(Boolean);
   }
+  resolveWranglerConfigPath() {
+    if (this.wranglerConfigPath)
+      return this.wranglerConfigPath;
+    for (const candidate of D1_WRANGLER_CONFIG_CANDIDATES) {
+      if (existsSync6(candidate))
+        return candidate;
+    }
+    return;
+  }
   async runWrangler(args) {
-    const proc = Bun.spawn(["wrangler", ...args], {
+    const configPath = this.resolveWranglerConfigPath();
+    const fullArgs = configPath && !args.includes("-c") && !args.includes("--config") ? [...args, "-c", configPath] : args;
+    const proc = Bun.spawn(["wrangler", ...fullArgs], {
       stdout: "pipe",
       stderr: "pipe"
     });
@@ -34917,7 +35035,8 @@ class DbService {
     const stderr = await new Response(proc.stderr).text();
     const exitCode = await proc.exited;
     if (exitCode !== 0) {
-      throw new Error(stderr.trim() || `wrangler exited with code ${exitCode}`);
+      const detail = stderr.trim() || stdout2.trim() || `wrangler exited with code ${exitCode}`;
+      throw new Error(detail);
     }
     return stdout2.trim();
   }
@@ -35151,6 +35270,7 @@ EXAMPLES:
   }, { service: "db" }));
 }
 // src/commands/monitor/monitor-command.ts
+init_kv_sync_service();
 init_errors4();
 function assertSafeInteger(value, name, max) {
   if (!Number.isInteger(value) || value < 0 || value > max || !Number.isSafeInteger(value)) {
@@ -35219,7 +35339,11 @@ function parseWranglerQueuesJson(raw) {
   const cleaned = raw.trim();
   if (!cleaned)
     return [];
-  const parsed = JSON.parse(cleaned);
+  const firstBracket = cleaned.indexOf("[");
+  const firstBrace = cleaned.indexOf("{");
+  const start = firstBracket === -1 ? firstBrace : firstBrace === -1 ? firstBracket : Math.min(firstBracket, firstBrace);
+  const payload = start >= 0 ? cleaned.slice(start) : cleaned;
+  const parsed = JSON.parse(payload);
   if (Array.isArray(parsed)) {
     return parsed;
   }
@@ -35228,9 +35352,37 @@ function parseWranglerQueuesJson(raw) {
   }
   return [];
 }
+function parseWranglerQueuesTable(raw) {
+  const queues = [];
+  for (const line of raw.split(`
+`)) {
+    if (!line.includes("\u2502"))
+      continue;
+    if (/[\u250C\u2514\u251C\u2500\u252C\u2534\u253C]/.test(line))
+      continue;
+    const cells = line.split("\u2502").map((c3) => c3.trim()).filter((c3) => c3.length > 0);
+    if (cells.length < 2)
+      continue;
+    if (cells[0] === "id" || cells[0] === "name")
+      continue;
+    if (!/^[0-9a-f-]{16,}$/i.test(cells[0]))
+      continue;
+    const producers = cells[4] !== undefined && cells[4] !== "" ? Number(cells[4]) : undefined;
+    const consumers = cells[5] !== undefined && cells[5] !== "" ? Number(cells[5]) : undefined;
+    queues.push({
+      queue_id: cells[0],
+      queue_name: cells[1],
+      created_on: cells[2],
+      modified_on: cells[3],
+      producers_total_count: Number.isFinite(producers) ? producers : undefined,
+      consumers_total_count: Number.isFinite(consumers) ? consumers : undefined
+    });
+  }
+  return queues;
+}
 async function doMonitorQueueDepth(fmt) {
   try {
-    const proc = Bun.spawn(["wrangler", "queues", "list", "--json"], {
+    const proc = Bun.spawn(["wrangler", "queues", "list"], {
       stdout: "pipe",
       stderr: "pipe"
     });
@@ -35241,22 +35393,20 @@ async function doMonitorQueueDepth(fmt) {
       throw new Error(stderr.trim() || `wrangler exited with code ${exitCode}`);
     }
     if (fmt.json) {
-      const queues = parseWranglerQueuesJson(stdout2);
+      let queues;
+      try {
+        queues = parseWranglerQueuesJson(stdout2);
+        if (queues.length === 0) {
+          queues = parseWranglerQueuesTable(stdout2);
+        }
+      } catch {
+        queues = parseWranglerQueuesTable(stdout2);
+      }
       process.stdout.write(JSON.stringify({ queues }, null, 2) + `
 `);
       return;
     }
-    const procHuman = Bun.spawn(["wrangler", "queues", "list"], {
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    const stdoutHuman = await new Response(procHuman.stdout).text();
-    const stderrHuman = await new Response(procHuman.stderr).text();
-    const exitHuman = await procHuman.exited;
-    if (exitHuman !== 0) {
-      throw new Error(stderrHuman.trim() || `wrangler exited with code ${exitHuman}`);
-    }
-    process.stdout.write(stdoutHuman + `
+    process.stdout.write(stdout2 + `
 `);
   } catch (err) {
     formatError2(err instanceof Error ? err.message : String(err), fmt);
@@ -35640,7 +35790,9 @@ class RepairService {
     }
   }
 }
+
 // src/commands/repair/repair-command.ts
+init_kv_sync_service();
 init_errors4();
 async function handleCheck(fmt, options = {}) {
   try {
@@ -35649,10 +35801,23 @@ async function handleCheck(fmt, options = {}) {
       installDeps: Boolean(options.installDeps),
       typecheck: options.typecheck !== false
     });
-    if (result.allPassed) {
-      formatSuccess("All checks passed", fmt);
+    if (fmt.json) {
+      process.stdout.write(JSON.stringify(result, null, 2) + `
+`);
     } else {
-      formatError2(new CLIError(`${result.failedCount} check(s) failed`, 1 /* ERROR */), fmt);
+      const rows = result.steps.map((s) => ({
+        Step: s.step,
+        Status: s.success ? "ok" : "fail",
+        Detail: s.message ?? s.error ?? "-"
+      }));
+      formatTable(rows, fmt);
+      if (result.allPassed) {
+        formatSuccess(`All ${result.passedCount} check(s) passed`, fmt);
+      } else {
+        formatError2(new CLIError(`${result.failedCount} of ${result.steps.length} check(s) failed`, 1 /* ERROR */), fmt);
+      }
+    }
+    if (!result.allPassed) {
       process.exitCode = 1 /* ERROR */;
     }
   } catch (err) {
@@ -35930,22 +36095,56 @@ function registerSchemaCommand(program2) {
 }
 // src/commands/tui/tui-command.ts
 import { spawn } from "child_process";
-import { resolve as resolve6, dirname as dirname2 } from "path";
+import { createRequire } from "module";
+import { resolve as resolve6, dirname as dirname2, join as join8 } from "path";
 import { fileURLToPath } from "url";
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync8 } from "fs";
 init_errors4();
 var __dirname2 = dirname2(fileURLToPath(import.meta.url));
-function resolveTUIEntry() {
+var require2 = createRequire(import.meta.url);
+var TUI_PKG = "@jango-blockchained/hoox-tui";
+function collectTuiCandidates() {
   const candidates = [
     resolve6(__dirname2, "../../../../tui/src/main.tsx"),
+    resolve6(__dirname2, "../../../../tui/dist/main.js"),
+    resolve6(__dirname2, "../../../tui/src/main.tsx"),
+    resolve6(__dirname2, "../../../tui/dist/main.js"),
     resolve6(process.cwd(), "packages/tui/src/main.tsx"),
-    resolve6(process.cwd(), "../tui/src/main.tsx")
+    resolve6(process.cwd(), "packages/tui/dist/main.js"),
+    resolve6(process.cwd(), "../tui/src/main.tsx"),
+    resolve6(process.cwd(), "../tui/dist/main.js")
   ];
+  pushPackageEntries(candidates, require2);
+  try {
+    const cwdRequire = createRequire(join8(process.cwd(), "package.json"));
+    pushPackageEntries(candidates, cwdRequire);
+  } catch {}
+  return candidates;
+}
+function pushPackageEntries(candidates, req) {
+  try {
+    const pkgJsonPath = req.resolve(`${TUI_PKG}/package.json`);
+    const root = dirname2(pkgJsonPath);
+    candidates.push(join8(root, "src/main.tsx"), join8(root, "dist/main.js"), join8(root, "src/main.ts"));
+  } catch {}
+}
+function resolveTUIEntry() {
+  const candidates = collectTuiCandidates();
   for (const path6 of candidates) {
-    if (existsSync7(path6))
+    if (existsSync8(path6))
       return path6;
   }
-  throw new CLIError("Could not find TUI entry point. Ensure packages/tui/src/main.tsx exists.", 1 /* ERROR */);
+  throw new CLIError([
+    "Could not find the Hoox TUI entry point.",
+    "",
+    "Fix options:",
+    "  \u2022 From the monorepo: ensure packages/tui/src/main.tsx exists",
+    `  \u2022 Or install the package: bun add -g ${TUI_PKG}`,
+    "  \u2022 Or from a project: bun add -d " + TUI_PKG,
+    "",
+    "Then re-run: hoox tui"
+  ].join(`
+`), 1 /* ERROR */);
 }
 function registerTUICommand(program2) {
   program2.command("tui").description("Launch the OpenTUI terminal operations center").option("--fps <number>", "Target frames per second", "30").option("--no-mouse", "Disable mouse support").action(withErrorHandling(async (options) => {
@@ -36812,7 +37011,20 @@ EXAMPLES:
       to: options.to
     }, fmt);
   }, { service: "trace" }));
-  const destinationsCmd = traceCmd.command("destinations").summary("Manage OTLP export destinations");
+  const destinationsCmd = traceCmd.command("destinations").summary("Manage OTLP export destinations").description(`List and manage OTLP export destinations.
+
+SUBCOMMANDS:
+  list              List destinations (default when no subcommand given)
+  add <name> <url>  Add a destination
+  remove <slug>     Remove a destination
+
+EXAMPLES:
+  hoox trace destinations                      List (default)
+  hoox trace destinations list
+  hoox trace destinations add honeycomb https://api.honeycomb.io/1/traces`).action(withErrorHandling(async (_options, cmd) => {
+    const fmt = getFormatOptions(cmd);
+    await handleDestinationsList(fmt);
+  }, { service: "trace" }));
   destinationsCmd.command("list").summary("List OTLP export destinations").description(`List all configured OTLP export destinations.
 
 Destinations allow exporting traces (and logs) to third-party observability
@@ -37534,137 +37746,24 @@ function registerCompletionCommand(program2) {
     }
   }));
 }
-// src/commands/pine/pine-command.ts
-import { resolve as resolve7 } from "path";
-var PINE_WORKER_DIR = resolve7(process.cwd(), "workers/pine-worker");
-async function spawnPineScript(script, args = []) {
-  const proc = Bun.spawn(["bun", "run", script, ...args], {
-    cwd: PINE_WORKER_DIR,
-    stdio: ["inherit", "inherit", "inherit"]
-  });
-  return await proc.exited;
-}
-function registerPineCommand(program2) {
-  const pineCmd = program2.command("pine").summary("Pine Script strategy tooling (backtest, data, export)").description(`Manage Pine Script strategies, data, and chart exports.
-
-SUBCOMMANDS:
-  download          Download OHLCV historical data from Binance
-  backtest <file>   Run a Pine Script against local historical data
-  export <file>     Export per-bar chart data as CSV or JSON
-  bundle            Bundle built-in Pine libraries for deployment
-
-Data is stored under workers/pine-worker/data/ and consumed by the
-pine-worker at runtime.
-
-EXAMPLES:
-  hoox pine download                               Default: BTCUSDT 1d 365d
-  hoox pine download --all                         All default symbols
-  hoox pine download -s ETHUSDT --tf 1h -d 30     Custom download
-  hoox pine backtest ../grid.pine -s BTCUSDT       Run a strategy
-  hoox pine export ../grid.pine --csv              Export chart data as CSV
-  hoox pine bundle                                 Bundle libraries for deploy`);
-  pineCmd.command("download").summary("Download OHLCV historical data from Binance").description(`Fetch historical klines from Binance and store as compressed JSON Lines
-under workers/pine-worker/data/{SYMBOL}/{TIMEFRAME}/{YYYY}.jsonl.gz.
-
-OPTIONS:
-  -s, --symbol     Symbol to download (default: BTCUSDT)
-  --tf             Timeframe: 1m, 3m, 5m, 15m, 30m, 1h, 2h, 4h, 6h,
-                   8h, 12h, 1d, 3d, 1w, 1M (default: 1d)
-  -d, --days       Days of history to fetch (default: 365)
-  -a, --all        Download all default symbols (BTC, ETH, SOL, BNB,
-                   XRP, ADA, DOGE, AVAX)
-
-EXAMPLES:
-  hoox pine download
-  hoox pine download --all
-  hoox pine download -s ETHUSDT --tf 1h -d 30`).option("-s, --symbol <symbol>", "Symbol to download", "BTCUSDT").option("--tf <timeframe>", "Timeframe interval", "1d").option("-d, --days <days>", "Days of history to fetch", "365").option("-a, --all", "Download all default symbols").action(withErrorHandling(async (opts) => {
-    const args = [];
-    if (opts.all) {
-      args.push("--all");
-    } else {
-      args.push("--symbol", opts.symbol);
-      args.push("--tf", opts.tf);
-      if (opts.days !== "365")
-        args.push("--days", opts.days);
-    }
-    process.exitCode = await spawnPineScript("scripts/download-data.ts", args);
-  }, { service: "pine" }));
-  pineCmd.command("backtest <script-path>").summary("Run a Pine Script against local historical data").description(`Execute a Pine Script strategy against historical OHLCV data and
-print trade events (entries, exits, orders) to stdout.
-
-ARGUMENTS:
-  script-path    Path to the .pine script file
-
-OPTIONS:
-  -s, --symbol   Trading symbol (default: BTCUSDT)
-  --tf           Timeframe (default: 5m)
-  -b, --bars     Number of bars to evaluate (default: 864)
-
-EXAMPLES:
-  hoox pine backtest ../grid.pine
-  hoox pine backtest ../grid.pine -s ETHUSDT --tf 15m -b 500`).option("-s, --symbol <symbol>", "Trading symbol", "BTCUSDT").option("--tf <timeframe>", "Timeframe", "5m").option("-b, --bars <bars>", "Number of bars to evaluate", "864").action(withErrorHandling(async (scriptPath, opts) => {
-    process.exitCode = await spawnPineScript("scripts/run-backtest.ts", [
-      scriptPath,
-      opts.symbol,
-      opts.tf,
-      opts.bars
-    ]);
-  }, { service: "pine" }));
-  pineCmd.command("export <script-path>").summary("Export per-bar chart data (TradingView-style)").description(`Run a Pine Script and export per-bar OHLCV + plot values as
-CSV or JSON \u2014 matching TradingView's "Export chart data" layout.
-
-ARGUMENTS:
-  script-path    Path to the .pine script file
-
-OPTIONS:
-  -s, --symbol   Trading symbol (default: BTCUSDT)
-  --tf           Timeframe (default: 1d)
-  -b, --bars     Number of bars to evaluate (default: 500)
-  --csv          Export as CSV (default: JSON)
-
-Output files are written to the current directory:
-  {SYMBOL}_{TIMEFRAME}_chart.csv   or   {SYMBOL}_{TIMEFRAME}_chart.json
-
-EXAMPLES:
-  hoox pine export ../grid.pine
-  hoox pine export ../grid.pine -s ETHUSDT --csv
-  hoox pine export ../grid.pine --tf 1h -b 200`).option("-s, --symbol <symbol>", "Trading symbol", "BTCUSDT").option("--tf <timeframe>", "Timeframe", "1d").option("-b, --bars <bars>", "Number of bars to evaluate", "500").option("--csv", "Export as CSV (default: JSON)").action(withErrorHandling(async (scriptPath, opts) => {
-    const args = [scriptPath, opts.symbol, opts.tf, opts.bars];
-    if (opts.csv)
-      args.push("--csv");
-    process.exitCode = await spawnPineScript("scripts/export-chart.ts", args);
-  }, { service: "pine" }));
-  pineCmd.command("bundle").summary("Bundle built-in Pine libraries for deployment").description(`Embed libraries/*.pine files into src/module/bundled-libraries.ts
-so library imports work in the Cloudflare Worker runtime.
-
-This runs automatically as a prebuild step before deploy, but can
-also be run manually after updating library files.
-
-EXAMPLES:
-  hoox pine bundle`).action(withErrorHandling(async () => {
-    process.exitCode = await spawnPineScript("scripts/bundle-libraries.ts");
-  }, { service: "pine" }));
-  pineCmd.action(() => {
-    pineCmd.help();
-  });
-}
 // src/ui/banner.ts
-import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname3, join as join8 } from "path";
-var TAGLINE = "Cloudflare Workers Platform";
+import { dirname as dirname3, join as join9 } from "path";
 var ORANGE = ansis_default.hex("#ff7f2a");
 var AMBER = ansis_default.hex("#ffb722");
 var INDIGO = ansis_default.hex("#818cf8");
 var INDIGO_SOFT = ansis_default.hex("#a5b4fc");
 var ZINC = ansis_default.hex("#a1a1aa");
 var ZINC_FAINT = ansis_default.hex("#52525b");
+var ZINC_SOFT = ansis_default.hex("#71717a");
+var TAGLINE = "Cloudflare Workers Platform";
 function findCliVersion() {
   const PKG_NAME = "@jango-blockchained/hoox-cli";
   let dir = dirname3(fileURLToPath2(import.meta.url));
   for (let i2 = 0;i2 < 5; i2++) {
-    const pkgPath = join8(dir, "package.json");
-    if (existsSync8(pkgPath)) {
+    const pkgPath = join9(dir, "package.json");
+    if (existsSync9(pkgPath)) {
       try {
         const pkg = JSON.parse(readFileSync7(pkgPath, "utf-8"));
         if (pkg.name === PKG_NAME)
@@ -37680,107 +37779,35 @@ function findCliVersion() {
 }
 var VERSION = findCliVersion();
 var DISCLAIMER2 = "DISCLAIMER: Trading cryptocurrencies involves substantial risk of loss. Use at your own risk.";
-var LOGO_GRID = [
-  "          /\\          ",
-  "         /##\\         ",
-  "        /####\\        ",
-  "       // ## \\\\       ",
-  "      // #### \\\\      ",
-  "     //        \\\\     ",
-  "    //-  ####  -\\\\    ",
-  "    \\\\-  ####  -//    ",
-  "     \\\\        //     ",
-  "      \\\\ #### //      ",
-  "       \\\\ ## //       ",
-  "        \\####/        ",
-  "         \\##/         ",
-  "          \\/          "
-];
-var LOGO_W = LOGO_GRID[0].length;
-function cellRole(ch) {
-  if (ch === "#" || ch === "\u2588")
-    return "solid";
-  if (ch === " " || ch === "")
-    return "empty";
-  return "outline";
-}
-function displayChar(ch) {
-  if (ch === "#")
-    return "\u2588";
-  if (ch === "/")
-    return "\u2571";
-  if (ch === "\\")
-    return "\u2572";
-  if (ch === "-" || ch === "_")
-    return "\u2500";
-  return ch;
-}
-function colorLogoLine(raw, row, phase, mode) {
-  let out = "";
-  for (let col = 0;col < raw.length; col++) {
-    const enc = raw[col];
-    const role = cellRole(enc);
-    if (role === "empty") {
-      out += " ";
-      continue;
-    }
-    const ch = displayChar(enc);
-    if (mode === "assemble") {
-      const solidReady = phase >= 0.15;
-      const outlineReady = phase >= 0.5;
-      if (role === "solid" && !solidReady) {
-        out += ZINC_FAINT("\xB7");
-        continue;
-      }
-      if (role === "outline" && !outlineReady) {
-        out += " ";
-        continue;
-      }
-      if (role === "solid" && phase < 0.45) {
-        out += ZINC(ch);
-        continue;
-      }
-      if (role === "outline" && phase < 0.75) {
-        out += ZINC_FAINT(ch);
-        continue;
-      }
-    }
-    if (mode === "shimmer") {
-      const t2 = (phase * 1.5 + (col + row) * 0.07) % 1;
-      if (t2 < 0.12) {
-        out += (role === "solid" ? AMBER : INDIGO_SOFT)(ch);
-      } else if (t2 < 0.3) {
-        out += (role === "solid" ? ORANGE : INDIGO)(ch);
-      } else {
-        out += role === "solid" ? ansis_default.hex("#e4e4e7")(ch) : INDIGO.dim(ch);
-      }
-      continue;
-    }
-    out += role === "solid" ? ansis_default.hex("#fafafa")(ch) : ansis_default.hex("#a1a1aa")(ch);
-  }
-  return out;
-}
-function renderLogoBlock(phase, mode) {
-  return LOGO_GRID.map((line, row) => colorLogoLine(line, row, phase, mode));
-}
 var WORDMARK = [
-  "\u2588\u2588\u2557  \u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557  \u2588\u2588\u2557",
-  "\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2550\u2588\u2588\u2557\u255A\u2588\u2588\u2557\u2588\u2588\u2554\u255D",
-  "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2554\u255D ",
-  "\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551 \u2588\u2588\u2554\u2588\u2588\u2557 ",
-  "\u2588\u2588\u2551  \u2588\u2588\u2551\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2554\u255D \u2588\u2588\u2557",
-  "\u255A\u2550\u255D  \u255A\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D  \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u255D  \u255A\u2550\u255D"
+  " _   _  ___   _____  _  ",
+  "| | | |/ _ \\ / _ \\ \\/ / ",
+  "| |_| | (_) | (_) >  <  ",
+  " \\___/ \\___/ \\___/_/\\_\\ "
 ];
+var WORD_W = WORDMARK[0].length;
 function colorWordmark(phase, mode) {
   return WORDMARK.map((line, row) => {
-    if (mode === "assemble" && phase < 0.7) {
-      const reveal = Math.max(0, (phase - 0.5) / 0.35);
-      if (reveal <= 0)
-        return ZINC_FAINT(line.replace(/[^\s]/g, "\xB7"));
-      if (reveal < 1)
-        return ZINC(line);
-    }
-    if (mode === "shimmer") {
+    if (mode === "assemble") {
+      const local = Math.max(0, Math.min(1, phase));
+      const cut = Math.floor(local * line.length);
+      let out = "";
+      for (let col = 0;col < line.length; col++) {
+        const ch = line[col];
+        if (ch === " ") {
+          out += " ";
+          continue;
+        }
+        if (col > cut)
+          out += ZINC_FAINT("\xB7");
+        else if (local < 0.85)
+          out += ZINC(ch);
+        else
+          out += theme.heading(ch);
+      }
+      return out;
+    }
+    if (mode === "pulse") {
       let out = "";
       for (let col = 0;col < line.length; col++) {
         const ch = line[col];
@@ -37788,36 +37815,32 @@ function colorWordmark(phase, mode) {
           out += " ";
           continue;
         }
-        const t2 = (phase * 1.2 + col * 0.04 + row * 0.05) % 1;
-        out += t2 < 0.2 ? INDIGO_SOFT(ch) : INDIGO.bold(ch);
+        const t2 = (phase * 1.5 + col * 0.05 + row * 0.06) % 1;
+        if (t2 < 0.12)
+          out += AMBER(ch);
+        else if (t2 < 0.25)
+          out += ORANGE(ch);
+        else if (t2 < 0.4)
+          out += INDIGO_SOFT(ch);
+        else
+          out += INDIGO.bold(ch);
       }
       return out;
     }
     return theme.heading(line);
   });
 }
-var BANNER_PAD = " ";
+var PAD = " ";
 function composeFrame(phase, mode) {
-  const logo = renderLogoBlock(phase, mode);
   const word = colorWordmark(phase, mode);
-  const gap = "   ";
-  const wordH = word.length;
-  const logoH = logo.length;
-  const topPad = Math.floor((logoH - wordH) / 2);
-  const contentW = LOGO_W + gap.length + (WORDMARK[0]?.length ?? 0);
-  const lines = [];
-  for (let i2 = 0;i2 < logoH; i2++) {
-    const left = logo[i2];
-    const wi = i2 - topPad;
-    const right = wi >= 0 && wi < wordH ? word[wi] : " ".repeat(WORDMARK[0].length);
-    lines.push(BANNER_PAD + left + gap + right);
-  }
-  const rule = ZINC_FAINT("\u2500".repeat(contentW + 2));
-  const meta3 = BANNER_PAD + ZINC(TAGLINE) + "  " + ZINC_FAINT("\xB7") + "  " + INDIGO_SOFT(`v${VERSION}`);
-  const metaVis = stripAnsi(meta3).length;
-  const metaPad = Math.max(0, Math.floor((contentW + 2 - metaVis) / 2));
-  const metaLine = " ".repeat(metaPad) + meta3.trimStart();
-  return [BANNER_PAD + rule, ...lines, BANNER_PAD + rule, metaLine].join(`
+  const contentW = WORD_W;
+  const body = word.map((line) => PAD + line);
+  const rule = PAD + ZINC_FAINT("\u2500".repeat(contentW));
+  const metaInner = ZINC_SOFT(TAGLINE) + "  " + ZINC_FAINT("\xB7") + "  " + INDIGO_SOFT(`v${VERSION}`);
+  const metaVis = stripAnsi(metaInner).length;
+  const metaPad = Math.max(0, Math.floor((contentW - metaVis) / 2));
+  const meta3 = PAD + " ".repeat(metaPad) + metaInner;
+  return [rule, ...body, rule, meta3].join(`
 `);
 }
 function canAnimate() {
@@ -37844,12 +37867,12 @@ async function animateBanner(options) {
 `);
     return lineCount;
   }
-  const durationMs = options?.durationMs ?? 900;
+  const durationMs = options?.durationMs ?? 800;
   const assembleMs = Math.floor(durationMs * 0.55);
-  const shimmerMs = durationMs - assembleMs;
-  const fps = 24;
+  const pulseMs = durationMs - assembleMs;
+  const fps = 28;
   const assembleFrames = Math.max(6, Math.round(assembleMs / 1000 * fps));
-  const shimmerFrames = Math.max(4, Math.round(shimmerMs / 1000 * fps));
+  const pulseFrames = Math.max(4, Math.round(pulseMs / 1000 * fps));
   let wroteLines = 0;
   const writeFrame = (frame) => {
     const lines = frame.split(`
@@ -37873,14 +37896,14 @@ async function animateBanner(options) {
   process.stdout.write("\x1B[?25l");
   try {
     for (let i2 = 0;i2 < assembleFrames; i2++) {
-      const phase = i2 / (assembleFrames - 1);
+      const phase = i2 / Math.max(1, assembleFrames - 1);
       writeFrame(composeFrame(phase, "assemble"));
       await sleep2(assembleMs / assembleFrames);
     }
-    for (let i2 = 0;i2 < shimmerFrames; i2++) {
-      const phase = i2 / Math.max(1, shimmerFrames - 1);
-      writeFrame(composeFrame(phase, "shimmer"));
-      await sleep2(shimmerMs / shimmerFrames);
+    for (let i2 = 0;i2 < pulseFrames; i2++) {
+      const phase = i2 / Math.max(1, pulseFrames - 1);
+      writeFrame(composeFrame(phase, "pulse"));
+      await sleep2(pulseMs / pulseFrames);
     }
     writeFrame(finalFrame);
   } finally {
@@ -38358,7 +38381,6 @@ registerSetupCommand(program2);
 registerTraceCommand(program2);
 registerPerfCommand(program2);
 registerCompletionCommand(program2);
-registerPineCommand(program2);
 async function main() {
   try {
     const hasArgs = process.argv.slice(2).length > 0;