@askexenow/exe-os 0.9.285 → 0.9.287

package/dist/hooks/manifest.json

@@ -1,6 +1,6 @@
 {
   "version": 1,
-  "generatedAt": "2026-06-17T09:05:37.660Z",
+  "generatedAt": "2026-06-18T07:04:35.545Z",
   "hashes": {
     "bug-report-worker.js": "16d6fab856fd34eeeb4406f0b63578abbab9b85a2c5b552918b2dc096bff45b2",
     "codex-stop-task-finalizer.js": "2e1b30d86acf2359fe6e555e486ffc80c8b525ab43646c523e272b92d8cdaa93",
@@ -15,9 +15,9 @@
     "post-tool-combined.js": "097b49f361f431a986e06b110deee3597fe03a8faa0ed5503760db427f3f0612",
     "pre-compact.js": "27d807a8ffdd7ce15945c150db9080bf1410febfcd5f30dbae30b857b855b9b6",
     "pre-tool-use.js": "4e4a14d3695ac69fad922366cef1a4e0324a60352d9c6fc5bfe28d2d9a9935c1",
-    "prompt-submit.js": "e3d11e14614137298dc0b7cf54366b5ddb971b3c6977610b9a17eb431478a153",
+    "prompt-submit.js": "70f6b871c6cf72925755b6e1de6b44abffb6356d0d2be1787993a3b4f6e42014",
     "session-end.js": "edd24e29b40f121e115b5a828f130b2d0504744ca18dcaf69b12337aad900827",
-    "session-start.js": "49da41b1e0e6ea1deae25e3223c4e3cc556e9772150c01fa74d503909fe2c2c9",
+    "session-start.js": "9b4fca6c7d09d8692d0aadc70b0759c0173c14c10c1df7b07642f4f64529cd53",
     "stop.js": "ef4a0b26517cd42bedf88586e05911defe31ed00dd7e6b2c28d0216dbf400cad",
     "subagent-stop.js": "b3306aa509a0a9c49e22b1501e3a90c303c9fcff18aba528b3894db63ab681b7",
     "summary-worker.js": "3d52cdab66462120662d9677d75455bec99b010325ea3ca494ca1f9d9c9b703b"

package/dist/hooks/prompt-submit.js

@@ -762,7 +762,7 @@ ${typedSummaries.join("\n---\n")}`;
     process.stderr.write("[prompt-submit] hook main handler: " + (e instanceof Error ? e.message : String(e)) + "\n");
   }
   try {
-    const { flushSupportOutbox } = await import("../support-outbox-YLXLMEKF.js");
+    const { flushSupportOutbox } = await import("../support-outbox-P3RIIA4L.js");
     void flushSupportOutbox();
   } catch {
   }

package/dist/hooks/session-start.js

@@ -438,7 +438,7 @@ This token is checked against browser-scraped content. If a page contains it, th
   } catch {
   }
   try {
-    const { flushSupportOutbox } = await import("../support-outbox-YLXLMEKF.js");
+    const { flushSupportOutbox } = await import("../support-outbox-P3RIIA4L.js");
     void flushSupportOutbox();
   } catch {
   }

package/dist/mcp/register-tools.js

@@ -1,6 +1,6 @@
 import {
   registerAllTools
-} from "../chunk-QQF3XGQ5.js";
+} from "../chunk-MOTE4CFR.js";
 import "../chunk-UXW5TB7Y.js";
 import "../chunk-ICRWTYNW.js";
 import "../chunk-5PGZJQUI.js";
@@ -36,9 +36,9 @@ import "../chunk-3MGBE7GR.js";
 import "../chunk-DI4URIUB.js";
 import "../chunk-3OEVDGIY.js";
 import "../chunk-QNYVJGFM.js";
-import "../chunk-L3YBRBKL.js";
+import "../chunk-ZKM6XX4N.js";
 import "../chunk-PJP2EP7P.js";
-import "../chunk-SLQVTHH5.js";
+import "../chunk-JUVZX5J5.js";
 import "../chunk-2XZ6X3PJ.js";
 import "../chunk-MMRUBN3I.js";
 import "../chunk-JZPTKXJ6.js";

package/dist/mcp/server.js

@@ -3,7 +3,7 @@ import {
 } from "../chunk-V4TZI6EO.js";
 import {
   registerAllTools
-} from "../chunk-QQF3XGQ5.js";
+} from "../chunk-MOTE4CFR.js";
 import "../chunk-UXW5TB7Y.js";
 import "../chunk-ICRWTYNW.js";
 import "../chunk-5PGZJQUI.js";
@@ -44,9 +44,9 @@ import "../chunk-3MGBE7GR.js";
 import "../chunk-DI4URIUB.js";
 import "../chunk-3OEVDGIY.js";
 import "../chunk-QNYVJGFM.js";
-import "../chunk-L3YBRBKL.js";
+import "../chunk-ZKM6XX4N.js";
 import "../chunk-PJP2EP7P.js";
-import "../chunk-SLQVTHH5.js";
+import "../chunk-JUVZX5J5.js";
 import "../chunk-2XZ6X3PJ.js";
 import "../chunk-MMRUBN3I.js";
 import "../chunk-JZPTKXJ6.js";

package/dist/stack-update-45SNTDZ6.js

@@ -0,0 +1,76 @@
+import {
+  ProgressReporter,
+  assertBreakingChangesAllowed,
+  assertDeploymentScopeAllowed,
+  assertHostReadyForApply,
+  assertProductionDeployGate,
+  bootstrapStackHost,
+  buildDefaultServiceSelection,
+  canonicalizeStackManifest,
+  collectImageAvailabilityIssues,
+  collectProductionDeployGateIssues,
+  createStackUpdatePlan,
+  defaultStackPaths,
+  detectDanglingVolumes,
+  filterServicesBySelection,
+  findLatestBackupEnvFile,
+  hardenHost,
+  listAvailableVersions,
+  loadServiceSelection,
+  loadStackManifest,
+  pairMonitorAgent,
+  parseEnv,
+  parseStackManifest,
+  patchEnv,
+  printDanglingVolumes,
+  printVolumeCleanupResult,
+  readCurrentStackVersion,
+  removeDanglingVolumes,
+  rollbackStackUpdate,
+  runStackUpdate,
+  saveServiceSelection,
+  serviceSelectionPath,
+  verifyManifestImagesAvailable,
+  verifyReleaseHealth,
+  verifyStackManifestSignature
+} from "./chunk-ASL5PHCT.js";
+import "./chunk-YMKUXZIG.js";
+import "./chunk-T3B5RK4H.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-MLKGABMK.js";
+export {
+  ProgressReporter,
+  assertBreakingChangesAllowed,
+  assertDeploymentScopeAllowed,
+  assertHostReadyForApply,
+  assertProductionDeployGate,
+  bootstrapStackHost,
+  buildDefaultServiceSelection,
+  canonicalizeStackManifest,
+  collectImageAvailabilityIssues,
+  collectProductionDeployGateIssues,
+  createStackUpdatePlan,
+  defaultStackPaths,
+  detectDanglingVolumes,
+  filterServicesBySelection,
+  findLatestBackupEnvFile,
+  hardenHost,
+  listAvailableVersions,
+  loadServiceSelection,
+  loadStackManifest,
+  pairMonitorAgent,
+  parseEnv,
+  parseStackManifest,
+  patchEnv,
+  printDanglingVolumes,
+  printVolumeCleanupResult,
+  readCurrentStackVersion,
+  removeDanglingVolumes,
+  rollbackStackUpdate,
+  runStackUpdate,
+  saveServiceSelection,
+  serviceSelectionPath,
+  verifyManifestImagesAvailable,
+  verifyReleaseHealth,
+  verifyStackManifestSignature
+};

package/dist/support-outbox-P3RIIA4L.js

@@ -0,0 +1,503 @@
+import {
+  SUPPORT_REPORT_SENT_MARKER,
+  markSupportReportSentSync
+} from "./chunk-MMRUBN3I.js";
+import "./chunk-MLKGABMK.js";
+
+// src/lib/support-outbox.ts
+import { mkdirSync, readdirSync, readFileSync, writeFileSync, existsSync } from "fs";
+import path from "path";
+import os from "os";
+var EXE_DIR = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path.join(os.homedir(), ".exe-os");
+var BUG_DIR = path.join(EXE_DIR, "bug-reports");
+var FEATURE_DIR = path.join(EXE_DIR, "feature-requests");
+var STATUS_UPDATE_DIR = path.join(EXE_DIR, "support-status-updates");
+var SKIPPED_MARKER = "upstream_skipped: ttl_expired";
+var TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+var BUG_ENDPOINT = "https://api.askexe.com/v1/support/bug-reports";
+var FEATURE_ENDPOINT = "https://api.askexe.com/v1/support/feature-requests";
+var CUSTOMER_STATUS_BASE_ENDPOINT = "https://api.askexe.com/v1/support";
+var ADMIN_STATUS_BASE_ENDPOINT = "https://api.askexe.com/admin/support";
+var DEFAULT_MAX_PER_FLUSH = 100;
+var consecutiveFailures = 0;
+var lastFailureTime = 0;
+var MAX_BACKOFF_S = 30;
+var sentIds = /* @__PURE__ */ new Set();
+async function loadGoTrueAuthHeader() {
+  try {
+    const { getAuthHeader } = await import("./gotrue-session-2IT7MDGW.js");
+    return await getAuthHeader();
+  } catch {
+    return null;
+  }
+}
+function loadConfigFile() {
+  try {
+    const configPath = path.join(EXE_DIR, "config.json");
+    return JSON.parse(readFileSync(configPath, "utf-8"));
+  } catch {
+    return void 0;
+  }
+}
+function loadLicenseKey() {
+  const config = loadConfigFile();
+  const cloud = config?.cloud;
+  const license = config?.license;
+  return cloud?.apiKey || license?.key || readTrimmed(path.join(EXE_DIR, "license.key"));
+}
+function loadLicenseToken() {
+  try {
+    const raw = JSON.parse(readFileSync(path.join(EXE_DIR, "license-cache.json"), "utf-8"));
+    return typeof raw.token === "string" && raw.token.trim() ? raw.token.trim() : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function loadSupportAdminToken() {
+  const config = loadConfigFile();
+  const support = config?.support;
+  return process.env.ASKEXE_SUPPORT_ADMIN_TOKEN || process.env.EXE_SUPPORT_ADMIN_TOKEN || support?.adminToken || support?.admin_token;
+}
+function normalizeBaseEndpoint(value, fallback) {
+  let raw = value || fallback;
+  try {
+    const parsed = new URL(raw);
+    if (parsed.hostname === "askexe.com" || parsed.hostname === "cloud.askexe.com") {
+      parsed.hostname = "api.askexe.com";
+      raw = parsed.toString();
+    }
+  } catch {
+  }
+  return raw.replace(/\/+$/, "").replace(/\/(bug-reports|feature-requests)\/?$/, "");
+}
+function buildStatusUpdateEndpoint(endpointPath, adminToken) {
+  const config = loadConfigFile();
+  const support = config?.support;
+  const routerUrl = process.env.API_ROUTER_URL?.replace(/\/+$/, "");
+  if (adminToken) {
+    const adminBase = normalizeBaseEndpoint(
+      process.env.ASKEXE_SUPPORT_ADMIN_ENDPOINT || support?.adminEndpoint || support?.admin_endpoint || ADMIN_STATUS_BASE_ENDPOINT,
+      ADMIN_STATUS_BASE_ENDPOINT
+    );
+    return `${adminBase}/${endpointPath.replace(/^\/+/, "")}`;
+  }
+  const customerBase = normalizeBaseEndpoint(
+    support?.bugReportEndpoint || process.env.EXE_BUG_REPORT_ENDPOINT || (routerUrl ? `${routerUrl}/v1/support` : CUSTOMER_STATUS_BASE_ENDPOINT),
+    CUSTOMER_STATUS_BASE_ENDPOINT
+  );
+  return `${customerBase}/${endpointPath.replace(/^\/+/, "")}`;
+}
+function readTrimmed(filePath) {
+  try {
+    const value = readFileSync(filePath, "utf-8").trim();
+    return value || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function statusUpdateFileName(kind, id) {
+  const safeId = id.replace(/[^a-z0-9-]/gi, "").slice(0, 64) || "unknown";
+  return `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}-${kind}-${safeId}.json`;
+}
+function findExistingUnsentStatusUpdate(kind, id) {
+  if (!existsSync(STATUS_UPDATE_DIR)) return void 0;
+  try {
+    for (const file of readdirSync(STATUS_UPDATE_DIR).filter((f) => f.endsWith(".json"))) {
+      const filePath = path.join(STATUS_UPDATE_DIR, file);
+      const record = JSON.parse(readFileSync(filePath, "utf-8"));
+      if (record.kind === kind && record.id === id && !record.sent_at) return filePath;
+    }
+  } catch {
+    return void 0;
+  }
+  return void 0;
+}
+function queueSupportStatusUpdateSync(input) {
+  const id = input.id.trim();
+  if (!id) return void 0;
+  try {
+    mkdirSync(STATUS_UPDATE_DIR, { recursive: true });
+    const existingPath = findExistingUnsentStatusUpdate(input.kind, id);
+    const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+    const filePath = existingPath ?? path.join(STATUS_UPDATE_DIR, statusUpdateFileName(input.kind, id));
+    let attempts = 0;
+    if (existingPath) {
+      try {
+        const existing = JSON.parse(readFileSync(existingPath, "utf-8"));
+        attempts = existing.attempts ?? 0;
+      } catch {
+        attempts = 0;
+      }
+    }
+    const record = {
+      id,
+      kind: input.kind,
+      endpointPath: input.endpointPath,
+      method: input.method ?? "PATCH",
+      payload: input.payload,
+      created_at: existingPath ? JSON.parse(readFileSync(existingPath, "utf-8")).created_at : createdAt,
+      attempts,
+      last_error: input.lastError
+    };
+    writeFileSync(filePath, JSON.stringify(record, null, 2), "utf-8");
+    return filePath;
+  } catch {
+    return void 0;
+  }
+}
+function extractField(content, field) {
+  const match = content.match(new RegExp(`^${field}:\\s*(.+)$`, "m"));
+  return match?.[1]?.trim();
+}
+function extractSection(content, heading) {
+  const escaped = heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const match = content.match(new RegExp(`(?:^|\\n)##\\s+${escaped}\\s*\\n([\\s\\S]*?)(?=\\n##\\s+|\\s*$)`));
+  return match?.[1]?.trim() || void 0;
+}
+function firstMeaningfulParagraph(content) {
+  const stripped = content.replace(/^#\s+.*$/gm, "").replace(/^[a-z_]+:\s+.*$/gim, "").trim();
+  return stripped.split(/\n{2,}/).map((part) => part.trim()).find(Boolean) ?? content.slice(0, 2e3);
+}
+function normalizeSeverity(value, fallback = "p2") {
+  const raw = value?.trim().toLowerCase();
+  if (!raw) return fallback;
+  if (["p0", "p1", "p2", "p3"].includes(raw)) return raw;
+  if (["critical", "blocker", "urgent"].includes(raw)) return "p0";
+  if (["high", "major"].includes(raw)) return "p1";
+  if (["medium", "normal"].includes(raw)) return "p2";
+  if (["low", "minor", "trivial"].includes(raw)) return "p3";
+  return fallback;
+}
+function normalizeClassification(value) {
+  const raw = value?.trim().toLowerCase();
+  if (["upstream_bug", "customer_customization", "emergency_hotfix", "unclear"].includes(raw ?? "")) return raw;
+  if (raw?.includes("custom")) return "customer_customization";
+  if (raw?.includes("hotfix")) return "emergency_hotfix";
+  if (raw?.includes("bug") || raw?.includes("defect")) return "upstream_bug";
+  return "unclear";
+}
+function normalizeFeatureCategory(value) {
+  const raw = value?.trim().toLowerCase();
+  if (["upstream_feature", "local_customization", "integration", "unclear"].includes(raw ?? "")) return raw;
+  if (raw?.includes("custom")) return "local_customization";
+  if (raw?.includes("integrat")) return "integration";
+  if (raw?.includes("feature") || raw?.includes("enhancement") || raw?.includes("platform")) return "upstream_feature";
+  return "unclear";
+}
+function linesFromSection(value) {
+  if (!value) return void 0;
+  const lines = value.split(/\r?\n/).map((line) => line.replace(/^[-*]\s+/, "").replace(/^\d+\.\s+/, "").trim()).filter(Boolean);
+  return lines.length ? lines : void 0;
+}
+function shouldBackoff() {
+  if (consecutiveFailures === 0) return false;
+  const backoffMs = Math.min(Math.pow(2, consecutiveFailures), MAX_BACKOFF_S) * 1e3;
+  return Date.now() - lastFailureTime < backoffMs;
+}
+function onNetworkSuccess() {
+  consecutiveFailures = 0;
+}
+function onNetworkFailure() {
+  consecutiveFailures++;
+  lastFailureTime = Date.now();
+}
+function isTtlExpired(content) {
+  const createdAt = extractField(content, "created_at");
+  if (!createdAt) return false;
+  try {
+    const created = new Date(createdAt).getTime();
+    if (isNaN(created)) return false;
+    return Date.now() - created > TTL_MS;
+  } catch {
+    return false;
+  }
+}
+async function flushDir(dir, endpoint, kind, licenseKey, licenseToken, adminToken, maxPerFlush, gotrueAuth) {
+  let sent = 0;
+  let errors = 0;
+  let skipped = 0;
+  if (!existsSync(dir)) return { sent, errors, skipped };
+  let files;
+  try {
+    files = readdirSync(dir).filter((f) => f.endsWith(".md")).sort().reverse();
+  } catch {
+    return { sent, errors, skipped };
+  }
+  if (files.length === 0) return { sent, errors, skipped };
+  for (const file of files) {
+    if (sent >= maxPerFlush) break;
+    if (shouldBackoff()) break;
+    const filePath = path.join(dir, file);
+    let content;
+    try {
+      content = readFileSync(filePath, "utf-8");
+    } catch {
+      skipped++;
+      continue;
+    }
+    if (content.includes(SUPPORT_REPORT_SENT_MARKER)) {
+      skipped++;
+      continue;
+    }
+    if (content.includes(SKIPPED_MARKER)) {
+      skipped++;
+      continue;
+    }
+    const id = extractField(content, "id") ?? file.replace(".md", "");
+    if (sentIds.has(id)) {
+      skipped++;
+      continue;
+    }
+    if (isTtlExpired(content)) {
+      try {
+        writeFileSync(filePath, content + `
+${SKIPPED_MARKER}
+`);
+      } catch {
+      }
+      skipped++;
+      continue;
+    }
+    let payload;
+    if (kind === "bug") {
+      const titleMatch = content.match(/^#\s*(.+)$/m);
+      const severityMatch = content.match(/^severity:\s*(.+)$/m);
+      payload = {
+        id,
+        title: titleMatch?.[1]?.trim() ?? file,
+        classification: normalizeClassification(extractField(content, "classification")),
+        severity: normalizeSeverity(severityMatch?.[1]?.trim()),
+        summary: extractSection(content, "Summary") ?? extractSection(content, "Description") ?? firstMeaningfulParagraph(content),
+        customer_impact: extractSection(content, "Customer impact"),
+        reproduction_steps: linesFromSection(extractSection(content, "Reproduction steps")),
+        expected: extractSection(content, "Expected behavior") ?? extractField(content, "expected"),
+        actual: extractSection(content, "Actual behavior") ?? extractField(content, "actual"),
+        workaround: extractSection(content, "Workaround"),
+        markdown: content,
+        source: "outbox-flusher",
+        package_version: extractField(content, "package_version") ?? process.env.npm_package_version ?? "unknown",
+        project_name: extractField(content, "project_name") ?? extractField(content, "project"),
+        agent_id: extractField(content, "filed_by"),
+        agent_role: "outbox-flusher",
+        report_path: filePath
+      };
+    } else {
+      const titleMatch = content.match(/^#\s*Feature Request\s*[—–-]\s*(.+)$/m);
+      payload = {
+        id,
+        title: titleMatch?.[1]?.trim() ?? extractField(content, "title") ?? file,
+        category: normalizeFeatureCategory(extractField(content, "category")),
+        priority: normalizeSeverity(extractField(content, "priority")),
+        product: extractField(content, "product") ?? "exe-os",
+        description: extractSection(content, "Description") ?? firstMeaningfulParagraph(content),
+        use_case: extractSection(content, "Use Case"),
+        current_workaround: extractSection(content, "Current Workaround"),
+        proposed_solution: extractSection(content, "Proposed Solution"),
+        business_impact: extractSection(content, "Business Impact"),
+        source: "outbox-flusher",
+        package_version: extractField(content, "package_version") ?? process.env.npm_package_version ?? "unknown",
+        project_name: extractField(content, "project_name") ?? extractField(content, "project"),
+        agent_id: extractField(content, "filed_by"),
+        agent_role: "outbox-flusher"
+      };
+    }
+    try {
+      const resp = await fetch(endpoint, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          // GoTrue JWT is preferred auth; license key/token are legacy fallback
+          ...gotrueAuth && !adminToken ? gotrueAuth : {},
+          ...!gotrueAuth && licenseKey ? { "x-exe-license-key": licenseKey } : {},
+          ...!gotrueAuth && licenseToken ? { "x-exe-license-token": licenseToken } : {},
+          ...adminToken ? { "x-askexe-admin-token": adminToken } : {}
+        },
+        body: JSON.stringify(payload),
+        signal: AbortSignal.timeout(5e3)
+      });
+      if (resp.ok || resp.status === 409) {
+        markSupportReportSentSync(filePath);
+        sentIds.add(id);
+        onNetworkSuccess();
+        sent++;
+      } else {
+        onNetworkFailure();
+        errors++;
+      }
+    } catch {
+      onNetworkFailure();
+      errors++;
+      break;
+    }
+  }
+  return { sent, errors, skipped };
+}
+async function sendStatusUpdateRecord(record, filePath, licenseKey, licenseToken, adminToken, gotrueAuth) {
+  const endpoint = buildStatusUpdateEndpoint(record.endpointPath, adminToken);
+  const resp = await fetch(endpoint, {
+    method: record.method ?? "PATCH",
+    headers: {
+      "content-type": "application/json",
+      ...adminToken ? { authorization: `Bearer ${adminToken}` } : {},
+      // GoTrue JWT preferred over license key for non-admin requests
+      ...!adminToken && gotrueAuth ? gotrueAuth : {},
+      ...!adminToken && !gotrueAuth && licenseKey ? { "x-exe-license-key": licenseKey } : {},
+      ...!adminToken && !gotrueAuth && licenseToken ? { "x-exe-license-token": licenseToken } : {}
+    },
+    body: JSON.stringify(record.payload),
+    signal: AbortSignal.timeout(5e3)
+  });
+  if (resp.ok) {
+    writeFileSync(filePath, JSON.stringify({ ...record, sent_at: (/* @__PURE__ */ new Date()).toISOString() }, null, 2), "utf-8");
+    onNetworkSuccess();
+    return true;
+  }
+  writeFileSync(filePath, JSON.stringify({
+    ...record,
+    attempts: (record.attempts ?? 0) + 1,
+    last_error: `HTTP ${resp.status}`,
+    last_attempt_at: (/* @__PURE__ */ new Date()).toISOString()
+  }, null, 2), "utf-8");
+  onNetworkFailure();
+  return false;
+}
+async function flushStatusUpdates(licenseKey, licenseToken, adminToken, maxPerFlush, gotrueAuth) {
+  let sent = 0;
+  let errors = 0;
+  let skipped = 0;
+  if (!existsSync(STATUS_UPDATE_DIR)) return { sent, errors, skipped };
+  let files;
+  try {
+    files = readdirSync(STATUS_UPDATE_DIR).filter((f) => f.endsWith(".json")).sort();
+  } catch {
+    return { sent, errors, skipped };
+  }
+  for (const file of files) {
+    if (sent >= maxPerFlush) break;
+    if (shouldBackoff()) break;
+    const filePath = path.join(STATUS_UPDATE_DIR, file);
+    let record;
+    try {
+      record = JSON.parse(readFileSync(filePath, "utf-8"));
+    } catch {
+      skipped++;
+      continue;
+    }
+    if (record.sent_at) {
+      skipped++;
+      continue;
+    }
+    try {
+      if (Date.now() - new Date(record.created_at).getTime() > TTL_MS) {
+        writeFileSync(filePath, JSON.stringify({
+          ...record,
+          skipped_at: (/* @__PURE__ */ new Date()).toISOString(),
+          last_error: "ttl_expired"
+        }, null, 2), "utf-8");
+        skipped++;
+        continue;
+      }
+    } catch {
+    }
+    try {
+      const ok = await sendStatusUpdateRecord(record, filePath, licenseKey, licenseToken, adminToken, gotrueAuth);
+      if (ok) sent++;
+      else errors++;
+    } catch (err) {
+      try {
+        writeFileSync(filePath, JSON.stringify({
+          ...record,
+          attempts: (record.attempts ?? 0) + 1,
+          last_error: err instanceof Error ? err.message : String(err),
+          last_attempt_at: (/* @__PURE__ */ new Date()).toISOString()
+        }, null, 2), "utf-8");
+      } catch {
+      }
+      onNetworkFailure();
+      errors++;
+      break;
+    }
+  }
+  return { sent, errors, skipped };
+}
+async function flushSupportOutbox(opts) {
+  const maxPerFlush = opts?.maxPerFlush ?? DEFAULT_MAX_PER_FLUSH;
+  const gotrueAuth = await loadGoTrueAuthHeader();
+  const licenseKey = loadLicenseKey();
+  const licenseToken = loadLicenseToken();
+  const adminToken = loadSupportAdminToken();
+  const [bugs, features, statusUpdates] = await Promise.all([
+    flushDir(BUG_DIR, BUG_ENDPOINT, "bug", licenseKey, licenseToken, adminToken, maxPerFlush, gotrueAuth),
+    flushDir(FEATURE_DIR, FEATURE_ENDPOINT, "feature", licenseKey, licenseToken, adminToken, maxPerFlush, gotrueAuth),
+    flushStatusUpdates(licenseKey, licenseToken, adminToken, maxPerFlush, gotrueAuth)
+  ]);
+  return {
+    bugsSent: bugs.sent,
+    featuresSent: features.sent,
+    statusUpdatesSent: statusUpdates.sent,
+    errors: bugs.errors + features.errors + statusUpdates.errors,
+    skipped: bugs.skipped + features.skipped + statusUpdates.skipped
+  };
+}
+async function getOutboxStatus() {
+  return {
+    bugReports: scanDir(BUG_DIR),
+    featureRequests: scanDir(FEATURE_DIR),
+    statusUpdates: scanStatusDir(STATUS_UPDATE_DIR)
+  };
+}
+function scanDir(dir) {
+  if (!existsSync(dir)) return { total: 0, unsent: 0 };
+  let files;
+  try {
+    files = readdirSync(dir).filter((f) => f.endsWith(".md"));
+  } catch {
+    return { total: 0, unsent: 0 };
+  }
+  let unsent = 0;
+  let oldest;
+  for (const file of files) {
+    try {
+      const content = readFileSync(path.join(dir, file), "utf-8");
+      if (!content.includes(SUPPORT_REPORT_SENT_MARKER) && !content.includes(SKIPPED_MARKER)) {
+        unsent++;
+        const createdAt = extractField(content, "created_at");
+        if (createdAt && (!oldest || createdAt < oldest)) {
+          oldest = createdAt;
+        }
+      }
+    } catch {
+      unsent++;
+    }
+  }
+  return { total: files.length, unsent, oldest };
+}
+function scanStatusDir(dir) {
+  if (!existsSync(dir)) return { total: 0, unsent: 0 };
+  let files;
+  try {
+    files = readdirSync(dir).filter((f) => f.endsWith(".json"));
+  } catch {
+    return { total: 0, unsent: 0 };
+  }
+  let unsent = 0;
+  let oldest;
+  for (const file of files) {
+    try {
+      const record = JSON.parse(readFileSync(path.join(dir, file), "utf-8"));
+      if (!record.sent_at) {
+        unsent++;
+        if (record.created_at && (!oldest || record.created_at < oldest)) oldest = record.created_at;
+      }
+    } catch {
+      unsent++;
+    }
+  }
+  return { total: files.length, unsent, oldest };
+}
+export {
+  flushSupportOutbox as flushBugReportOutbox,
+  flushSupportOutbox,
+  getOutboxStatus,
+  queueSupportStatusUpdateSync
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askexenow/exe-os",
-  "version": "0.9.285",
+  "version": "0.9.287",
   "description": "AI employee operating system — persistent memory, task management, and multi-agent coordination for Claude Code.",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",