@askexenow/exe-os 0.9.339 → 0.9.341

package/dist/bin/orchestration-metrics.js

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 import {
   fastDbInit
-} from "../chunk-UFAXZ2PY.js";
+} from "../chunk-7YORGTXC.js";
 import {
   formatOrchestrationMetrics,
   getOrchestrationMetrics
-} from "../chunk-FUIIVSW6.js";
-import "../chunk-HEPR6QTL.js";
+} from "../chunk-WH7XN5ER.js";
+import "../chunk-RWSLVYTE.js";
 import "../chunk-2I23RPSI.js";
-import "../chunk-ATOU6CYR.js";
+import "../chunk-BV6GBSRP.js";
 import "../chunk-PNQDP3OA.js";
 import "../chunk-H73TUI4Y.js";
 import "../chunk-7HLWBYH7.js";

package/dist/bin/postgres-agentic-reflection-backfill.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import {
   buildReflectionCheckpoint
-} from "../chunk-KTY7I7UH.js";
+} from "../chunk-4FJZ6SO7.js";
 import {
   pgSslConfig
 } from "../chunk-EQSQ4HBW.js";
-import "../chunk-D3QASX2W.js";
+import "../chunk-C2SRRCRK.js";
 import {
   politeBatchPause,
   startManagedJob

package/dist/bin/postgres-agentic-semantic-backfill.js

@@ -5,7 +5,7 @@ import {
 import {
   inferSemanticLabel,
   stableId
-} from "../chunk-D3QASX2W.js";
+} from "../chunk-C2SRRCRK.js";
 import {
   politeBatchPause,
   startManagedJob

package/dist/bin/reconcile-backlog.js

@@ -0,0 +1,484 @@
+#!/usr/bin/env node
+import "../chunk-MLKGABMK.js";
+
+// src/bin/reconcile-backlog.ts
+import { existsSync, readFileSync } from "fs";
+import path from "path";
+import { homedir } from "os";
+import { fileURLToPath } from "url";
+
+// src/lib/backlog-reconcile.ts
+import { execFileSync } from "child_process";
+function defaultGitRunner(args, cwd) {
+  try {
+    const stdout = execFileSync("git", args, {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 2e4,
+      maxBuffer: 32 * 1024 * 1024
+    });
+    return { stdout, ok: true, code: 0 };
+  } catch (err) {
+    const e = err;
+    const stdout = e.stdout ? e.stdout.toString() : "";
+    return { stdout, ok: false, code: typeof e.status === "number" ? e.status : 1 };
+  }
+}
+var FIELD_SEP = "";
+var DEFAULT_BRANCH_REFS = ["origin/main", "main", "origin/master", "master"];
+function resolveReachability(runGit, repoPath, sha, defaultBranchRefs = DEFAULT_BRANCH_REFS) {
+  const tagRes = runGit(["tag", "--contains", sha], repoPath);
+  const tags = tagRes.stdout.split("\n").map((s) => s.trim()).filter(Boolean);
+  if (tags.length > 0) {
+    const versionTag = tags.find((t) => /v?\d+\.\d+/.test(t)) ?? tags[0];
+    return { reachable: true, tag: versionTag };
+  }
+  for (const ref of defaultBranchRefs) {
+    const anc = runGit(["merge-base", "--is-ancestor", sha, ref], repoPath);
+    if (anc.ok && anc.code === 0) return { reachable: true };
+  }
+  return { reachable: false };
+}
+function findIdMatches(runGit, repoPath, repoName, id, defaultBranchRefs = DEFAULT_BRANCH_REFS) {
+  const idShort = id.slice(0, 8).toLowerCase();
+  if (!/^[0-9a-f]{8}/.test(idShort)) return [];
+  const res = runGit(
+    ["log", "--all", "--no-color", "-i", `--format=%H${FIELD_SEP}%s`, "--grep", idShort, "--grep", id],
+    repoPath
+  );
+  if (!res.ok || !res.stdout.trim()) return [];
+  const matches = [];
+  for (const line of res.stdout.split("\n")) {
+    if (!line.trim()) continue;
+    const sepIdx = line.indexOf(FIELD_SEP);
+    const sha = (sepIdx >= 0 ? line.slice(0, sepIdx) : line).trim();
+    const subject = sepIdx >= 0 ? line.slice(sepIdx + 1).trim() : "";
+    if (!/^[0-9a-f]{7,40}$/.test(sha)) continue;
+    const reach = resolveReachability(runGit, repoPath, sha, defaultBranchRefs);
+    matches.push({
+      repo: repoName,
+      commit: sha.slice(0, 10),
+      fullCommit: sha,
+      subject,
+      tag: reach.tag,
+      releaseReachable: reach.reachable
+    });
+  }
+  return matches;
+}
+function gitGrepHit(runGit, repoPath, token) {
+  if (!token) return false;
+  const res = runGit(["grep", "-l", "-i", "-F", token, "HEAD"], repoPath);
+  return res.ok && res.stdout.trim().length > 0;
+}
+function pickKeyword(title) {
+  const stop = /* @__PURE__ */ new Set([
+    "the",
+    "and",
+    "for",
+    "with",
+    "that",
+    "this",
+    "from",
+    "into",
+    "when",
+    "should",
+    "support",
+    "feature",
+    "request",
+    "bug",
+    "report",
+    "please",
+    "would",
+    "could",
+    "make",
+    "able",
+    "user",
+    "users",
+    "system",
+    "using",
+    "based",
+    "which",
+    "there"
+  ]);
+  const tokens = (title.toLowerCase().match(/[a-z][a-z0-9_-]{4,}/g) ?? []).filter((t) => !stop.has(t));
+  if (tokens.length === 0) return void 0;
+  return tokens.sort((a, b) => b.length - a.length)[0];
+}
+function classifyRecord(record, matches, keywordHit = false) {
+  const idShort = record.id.slice(0, 8);
+  const releaseReachable = matches.filter((m) => m.releaseReachable);
+  if (releaseReachable.length > 0) {
+    const ev = releaseReachable.map((m) => `${m.repo}@${m.commit}${m.tag ? ` (tag ${m.tag})` : " (default branch)"}`).join(", ");
+    return {
+      record,
+      verdict: "SHIPPED",
+      evidence: releaseReachable,
+      rawMatches: matches,
+      reason: `id ${idShort} found in ${releaseReachable.length} release-reachable commit(s): ${ev}`
+    };
+  }
+  if (matches.length > 0) {
+    const where = matches.map((m) => `${m.repo}@${m.commit}`).join(", ");
+    return {
+      record,
+      verdict: "UNKNOWN",
+      evidence: [],
+      rawMatches: matches,
+      reason: `id ${idShort} found only on unmerged branch(es) \u2014 not reachable from a release tag or the default branch; refusing to auto-close (${where})`
+    };
+  }
+  if (keywordHit) {
+    return {
+      record,
+      verdict: "UNKNOWN",
+      evidence: [],
+      rawMatches: [],
+      reason: `no commit references id ${idShort}, but a title keyword appears in code \u2014 manual verification required (keyword-only signal never auto-closes)`
+    };
+  }
+  return {
+    record,
+    verdict: "STILL_OPEN",
+    evidence: [],
+    rawMatches: [],
+    reason: `no commit references id ${idShort}`
+  };
+}
+function pickShippedVersion(evidence, fallback) {
+  const tag = evidence.map((m) => m.tag).find((t) => Boolean(t));
+  if (tag) return tag.replace(/^v/, "");
+  return fallback;
+}
+function buildEvidenceText(evidence) {
+  return "Auto-reconciled: already shipped in code. Evidence: " + evidence.map((m) => `${m.repo}@${m.commit}${m.tag ? ` (release ${m.tag})` : " (default branch)"} \u2014 ${m.subject}`).join("; ");
+}
+async function reconcile(opts, deps) {
+  const all = await deps.fetchOpenRecords();
+  const records = typeof opts.limit === "number" && opts.limit >= 0 ? all.slice(0, opts.limit) : all;
+  const results = [];
+  let closed = 0;
+  let closeFailed = 0;
+  for (const record of records) {
+    const { matches, keywordHit } = await deps.matchRecord(record);
+    const cls = classifyRecord(record, matches, keywordHit);
+    let applied = null;
+    if (opts.apply && cls.verdict === "SHIPPED" && cls.evidence.length > 0) {
+      const version = pickShippedVersion(cls.evidence, opts.shippedVersion);
+      const evidenceText = buildEvidenceText(cls.evidence);
+      const r = await deps.applyShipped(record, cls.evidence, version, evidenceText);
+      applied = { ...r, version };
+      if (r.ok) closed++;
+      else closeFailed++;
+    }
+    results.push({ ...cls, applied });
+  }
+  const summary = {
+    total: results.length,
+    shipped: results.filter((r) => r.verdict === "SHIPPED").length,
+    stillOpen: results.filter((r) => r.verdict === "STILL_OPEN").length,
+    unknown: results.filter((r) => r.verdict === "UNKNOWN").length
+  };
+  return { apply: opts.apply, results, summary, closed, closeFailed };
+}
+
+// src/bin/reconcile-backlog.ts
+var STACK_REPOS = [
+  "exe-os",
+  "exe-crm",
+  "exe-wiki",
+  "exe-gateway",
+  "exe-monitor",
+  "exe-chat",
+  "exe-erp",
+  "exe-build",
+  "exe-auth",
+  "exe-db",
+  "exe-create"
+];
+var REPO_ALIASES = {
+  "exe-crm": ["exe-crm", "openclaw"],
+  "exe-wiki": ["exe-wiki", "ink"]
+};
+function exeOsRoot() {
+  let dir = path.dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 8; i++) {
+    if (existsSync(path.join(dir, "package.json"))) {
+      try {
+        const pkg = JSON.parse(readFileSync(path.join(dir, "package.json"), "utf8"));
+        if (pkg.name?.includes("exe-os")) return dir;
+      } catch {
+      }
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return path.join(homedir(), "exe-os");
+}
+function isGitRepo(dir) {
+  return existsSync(path.join(dir, ".git"));
+}
+function resolveStackRepos(filter) {
+  const root = exeOsRoot();
+  const bases = Array.from(/* @__PURE__ */ new Set([path.dirname(root), homedir()]));
+  const wanted = filter && filter.length > 0 ? filter : STACK_REPOS;
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const name of wanted) {
+    const candidates = REPO_ALIASES[name] ?? [name];
+    for (const base of bases) {
+      let found;
+      for (const cand of candidates) {
+        const p = path.join(base, cand);
+        if (existsSync(p) && isGitRepo(p)) {
+          found = p;
+          break;
+        }
+      }
+      if (found && !seen.has(name)) {
+        seen.add(name);
+        out.push({ name, path: found });
+        break;
+      }
+    }
+  }
+  return out;
+}
+async function buildSupportHandlers() {
+  const tools = /* @__PURE__ */ new Map();
+  const fake = {
+    registerTool(name, _config, handler) {
+      tools.set(name, handler);
+    }
+  };
+  const { registerListFeatureRequests, registerListBugReports } = await import("../support-inbox-Z77ACQUY.js");
+  const { registerUpdateFeatureRequest, registerUpdateBugReport } = await import("../update-support-VPBD5SD2.js");
+  registerListFeatureRequests(fake);
+  registerListBugReports(fake);
+  registerUpdateFeatureRequest(fake);
+  registerUpdateBugReport(fake);
+  return tools;
+}
+function textOf(result) {
+  const r = result;
+  return r?.content?.[0]?.text ?? "";
+}
+function extractRecords(text, kind) {
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch {
+    return [];
+  }
+  const obj = data ?? {};
+  const arr = Array.isArray(data) ? data : obj.items ?? obj.feature_requests ?? obj.bug_reports ?? obj.results ?? obj.data ?? [];
+  if (!Array.isArray(arr)) return [];
+  return arr.filter((x) => Boolean(x) && typeof x === "object" && "id" in x).map((x) => ({
+    id: String(x.id),
+    kind,
+    title: String(x.title ?? x.summary ?? x.id),
+    status: x.status ? String(x.status) : void 0
+  }));
+}
+function readPackageVersion() {
+  let dir = path.dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 8; i++) {
+    try {
+      const parsed = JSON.parse(readFileSync(path.join(dir, "package.json"), "utf8"));
+      if (parsed.version) return parsed.version;
+    } catch {
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return "unknown";
+}
+function parseArgs(argv) {
+  const flags = { apply: false, json: false, help: false, repos: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--apply") flags.apply = true;
+    else if (a === "--dry-run") flags.apply = false;
+    else if (a === "--json") flags.json = true;
+    else if (a === "--help" || a === "-h") flags.help = true;
+    else if (a === "--limit") {
+      const n = parseInt(argv[++i] ?? "", 10);
+      if (!Number.isNaN(n)) flags.limit = n;
+    } else if (a?.startsWith("--limit=")) {
+      const n = parseInt(a.slice(8), 10);
+      if (!Number.isNaN(n)) flags.limit = n;
+    } else if (a === "--repo") {
+      const v = argv[++i];
+      if (v) flags.repos.push(...v.split(",").map((s) => s.trim()).filter(Boolean));
+    } else if (a?.startsWith("--repo=")) {
+      flags.repos.push(...a.slice(7).split(",").map((s) => s.trim()).filter(Boolean));
+    }
+  }
+  return flags;
+}
+var ICON = { SHIPPED: "\u{1F7E2}", STILL_OPEN: "\u{1F535}", UNKNOWN: "\u{1F7E0}" };
+function renderRow(row) {
+  const icon = ICON[row.verdict] ?? "\u2754";
+  const head = `${icon} ${row.verdict.padEnd(10)} ${row.record.kind.padEnd(7)} ${row.record.id.slice(0, 8)} \u2014 ${row.record.title}`;
+  const lines = [head, `      ${row.reason}`];
+  if (row.applied) {
+    lines.push(`      ${row.applied.ok ? "\u2705 closed" : "\u274C close failed"} (v${row.applied.version}): ${row.applied.detail.split("\n")[0]}`);
+  }
+  return lines.join("\n");
+}
+function renderReport(report) {
+  const lines = ["", "exe-os reconcile-backlog", ""];
+  lines.push(report.apply ? "Mode: APPLY \u2014 SHIPPED records with concrete commit evidence will be closed." : "Mode: report-only (dry-run) \u2014 nothing will be closed. Use --apply to close SHIPPED records.");
+  lines.push("");
+  for (const row of report.results) lines.push(renderRow(row), "");
+  const s = report.summary;
+  lines.push(`Summary: ${s.total} open record(s) \u2014 \u{1F7E2} ${s.shipped} shipped, \u{1F7E0} ${s.unknown} unknown, \u{1F535} ${s.stillOpen} still-open`);
+  if (report.apply) lines.push(`Closed: ${report.closed}  Close-failed: ${report.closeFailed}`);
+  else if (s.shipped > 0) lines.push(`Re-run with --apply to close the ${s.shipped} shipped record(s).`);
+  lines.push("");
+  return lines.join("\n");
+}
+function printHelp() {
+  console.log(`
+exe-os reconcile-backlog \u2014 detect support records already shipped in code
+
+Usage:
+  exe-os reconcile-backlog [--apply] [--dry-run] [--limit <n>] [--repo <name>] [--json]
+
+Modes:
+  (default)     Report-only. Classifies each OPEN feature/bug and closes nothing.
+  --apply       Close SHIPPED records that have concrete, release-reachable commit
+                evidence, via the existing shipped transition. Never closes
+                UNKNOWN / STILL_OPEN / keyword-only matches.
+
+Options:
+  --dry-run     Explicit report-only (the default).
+  --limit <n>   Process at most n records.
+  --repo <name> Restrict the git scan to one or more stack repos (comma-separated
+                or repeat the flag). Default: all locally-present stack repos.
+  --json        Machine-readable output.
+  -h, --help    Show this help.
+
+Verdicts:
+  \u{1F7E2} SHIPPED     id in a commit reachable from a release tag or the default branch
+  \u{1F7E0} UNKNOWN     id only on an unmerged branch (guard: never closed), or a title
+                 keyword hit (manual review; never closed)
+  \u{1F535} STILL_OPEN  no evidence found
+
+Requires an AskExe support admin token (ASKEXE_SUPPORT_ADMIN_TOKEN) to list the inbox.
+`);
+}
+function buildDeps(handlers, repos, runGit) {
+  const listFeatures = handlers.get("list_feature_requests");
+  const listBugs = handlers.get("list_bug_reports");
+  const updateFeature = handlers.get("update_feature_request");
+  const updateBug = handlers.get("update_bug_report");
+  return {
+    async fetchOpenRecords() {
+      const records = [];
+      if (listFeatures) {
+        const out = await listFeatures({ status: "open", limit: 100 }, {});
+        records.push(...extractRecords(textOf(out), "feature"));
+      }
+      if (listBugs) {
+        const out = await listBugs({ status: "open", limit: 100 }, {});
+        records.push(...extractRecords(textOf(out), "bug"));
+      }
+      return records;
+    },
+    async matchRecord(record) {
+      const matches = [];
+      for (const repo of repos) {
+        matches.push(...findIdMatches(runGit, repo.path, repo.name, record.id));
+      }
+      let keywordHit = false;
+      if (matches.length === 0) {
+        const token = pickKeyword(record.title);
+        if (token) keywordHit = repos.some((r) => gitGrepHit(runGit, r.path, token));
+      }
+      return { matches, keywordHit };
+    },
+    async applyShipped(record, _evidence, version, evidenceText) {
+      const handler = record.kind === "feature" ? updateFeature : updateBug;
+      if (!handler) return { ok: false, detail: "update handler unavailable" };
+      const args = record.kind === "feature" ? { id: record.id, status: "shipped", shipped_version: version, notes: evidenceText, send_upstream: true } : { id: record.id, status: "closed", fix_version: version, notes: evidenceText, send_upstream: true };
+      try {
+        const out = await handler(args, {});
+        const r = out;
+        return { ok: !r?.isError, detail: textOf(out) || "updated" };
+      } catch (err) {
+        return { ok: false, detail: err instanceof Error ? err.message : String(err) };
+      }
+    }
+  };
+}
+async function main(argv = process.argv.slice(2)) {
+  const flags = parseArgs(argv);
+  if (flags.help) {
+    printHelp();
+    return 0;
+  }
+  const repos = resolveStackRepos(flags.repos);
+  if (repos.length === 0) {
+    console.error("reconcile-backlog: no stack repos found locally to scan. Expected siblings like ~/exe-os, ~/exe-crm.");
+    return 1;
+  }
+  let handlers;
+  try {
+    handlers = await buildSupportHandlers();
+  } catch (err) {
+    console.error(`reconcile-backlog: failed to load support tools: ${err instanceof Error ? err.message : String(err)}`);
+    return 1;
+  }
+  const deps = buildDeps(handlers, repos, defaultGitRunner);
+  let report;
+  try {
+    report = await reconcile(
+      { apply: flags.apply, limit: flags.limit, shippedVersion: readPackageVersion() },
+      deps
+    );
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (/admin token/i.test(msg)) {
+      console.error(
+        "reconcile-backlog: AskExe support admin token not configured. This tool is AskExe-internal \u2014 set ASKEXE_SUPPORT_ADMIN_TOKEN (or config.support.adminToken) to list the inbox."
+      );
+      return 1;
+    }
+    console.error(`reconcile-backlog: ${msg}`);
+    return 1;
+  }
+  if (flags.json) {
+    console.log(JSON.stringify(report, null, 2));
+  } else {
+    console.log(renderReport(report));
+    if (repos.length > 0 && !flags.json) {
+      console.error(`Scanned repos: ${repos.map((r) => r.name).join(", ")}`);
+    }
+  }
+  return report.apply && report.closeFailed > 0 ? 1 : 0;
+}
+var isDirectRun = (() => {
+  try {
+    return process.argv[1] === fileURLToPath(import.meta.url);
+  } catch {
+    return false;
+  }
+})();
+if (isDirectRun && !process.env.VITEST) {
+  main().then((code) => {
+    process.exitCode = code;
+  }).catch((err) => {
+    console.error(err instanceof Error ? err.stack ?? err.message : String(err));
+    process.exitCode = 1;
+  });
+}
+export {
+  extractRecords,
+  main,
+  parseArgs,
+  resolveStackRepos
+};

package/dist/bin/registry-proxy.js

@@ -2,7 +2,7 @@
 import {
   registryProxyOptionsFromEnv,
   runRegistryProxy
-} from "../chunk-ZIVEA3NB.js";
+} from "../chunk-BR4423AS.js";
 import {
   isMainModule
 } from "../chunk-6Y4B3QF6.js";

package/dist/bin/scan-tasks.js

@@ -1,43 +1,43 @@
 #!/usr/bin/env node
 import {
   queryTaskRows
-} from "../chunk-PLRIJALF.js";
-import "../chunk-OFX5B2S7.js";
-import "../chunk-B76TSEP3.js";
-import "../chunk-RLRT2BVM.js";
+} from "../chunk-KKOLHBNC.js";
+import "../chunk-ATKW3SYL.js";
+import "../chunk-BJOBR6P2.js";
+import "../chunk-6D2PI4QD.js";
+import "../chunk-E23LNUWJ.js";
 import "../chunk-4JERP7NT.js";
 import "../chunk-EIKATSE4.js";
-import "../chunk-E23LNUWJ.js";
-import "../chunk-UIV2WPBT.js";
-import "../chunk-SSTLTIF3.js";
+import "../chunk-HNLXMD2V.js";
 import "../chunk-RMOBQ6A5.js";
 import "../chunk-54QCG45Y.js";
-import "../chunk-FUIIVSW6.js";
-import "../chunk-65SVQELL.js";
+import "../chunk-SSTLTIF3.js";
+import "../chunk-WH7XN5ER.js";
+import "../chunk-GFDGDFBF.js";
 import "../chunk-NGP6LSV2.js";
-import "../chunk-MW2GJJ53.js";
+import "../chunk-2UGGBIDL.js";
 import {
   getSessionRuntime
 } from "../chunk-CVYC6DUW.js";
-import "../chunk-2233TQCA.js";
+import "../chunk-LLU6WZLK.js";
 import "../chunk-HCJCW7X4.js";
 import "../chunk-OPU3NYOO.js";
-import "../chunk-7TS64TBG.js";
+import "../chunk-UU4UINUX.js";
 import "../chunk-AFNRE2RV.js";
 import "../chunk-3NGZ4PL7.js";
 import "../chunk-NLEW62VC.js";
 import "../chunk-HYZV25LY.js";
 import "../chunk-GJV3WDWM.js";
 import "../chunk-MP2AFCGL.js";
-import "../chunk-HEPR6QTL.js";
+import "../chunk-RWSLVYTE.js";
 import "../chunk-2I23RPSI.js";
-import "../chunk-ATOU6CYR.js";
+import "../chunk-BV6GBSRP.js";
 import "../chunk-PNQDP3OA.js";
 import "../chunk-H73TUI4Y.js";
 import "../chunk-7HLWBYH7.js";
 import "../chunk-FXU7JOXK.js";
-import "../chunk-XACL67CS.js";
-import "../chunk-5Z5NATNS.js";
+import "../chunk-7SEC2AG5.js";
+import "../chunk-PPZOWQHP.js";
 import "../chunk-7Y5UDEVM.js";
 import "../chunk-SHIICYJW.js";
 import {
@@ -86,7 +86,7 @@ function checkMcpHealth() {
   }
 }
 async function scanFromDb(agentId, tmuxSession, projectName) {
-  const { fastDbInit } = await import("../fast-db-init-QQB6IVWV.js");
+  const { fastDbInit } = await import("../fast-db-init-JKJEEHUI.js");
   try {
     await fastDbInit();
   } catch (err) {

package/dist/bin/setup.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   runSetupWizard
-} from "../chunk-Z7OZP3ET.js";
+} from "../chunk-HSYJ6DZ2.js";
 import "../chunk-TPHCZDE3.js";
 import "../chunk-Z42MXYWW.js";
 import "../chunk-7Y5UDEVM.js";

package/dist/bin/shard-migrate.js

@@ -8,17 +8,17 @@ import {
 import {
   disposeStore,
   initStore
-} from "../chunk-H37HHX3E.js";
+} from "../chunk-EDH54E5A.js";
 import "../chunk-CHCA3ZM2.js";
 import "../chunk-OTVEIJUQ.js";
-import "../chunk-HHIBOU3P.js";
-import "../chunk-Y25OJWOQ.js";
+import "../chunk-7LF5DS3A.js";
+import "../chunk-RP5GETX5.js";
 import "../chunk-MP2AFCGL.js";
 import {
   getClient
-} from "../chunk-HEPR6QTL.js";
+} from "../chunk-RWSLVYTE.js";
 import "../chunk-2I23RPSI.js";
-import "../chunk-ATOU6CYR.js";
+import "../chunk-BV6GBSRP.js";
 import "../chunk-PNQDP3OA.js";
 import "../chunk-H73TUI4Y.js";
 import "../chunk-7HLWBYH7.js";