@askexenow/exe-os 0.9.312 → 0.9.314

package/dist/{chunk-7ODTYODO.js → chunk-3LGID56M.js}

@@ -11,7 +11,7 @@ var REQUIRED_INFRA = {
 var FORBIDDEN_HOST_SUBSTRINGS = ["askexe.com", "askexenow.com"];
 var CLIENT_FACING_HOST_FIELDS = ["healthHost", "healthUrl"];
 var BYOK_ENFORCEMENT_VARS = ["EXE_ALLOW_DIRECT_PROVIDER_KEYS", "EXE_BILLING_MODE"];
-var BYOK_LEGACY_VARS = ["BYOK_ENABLED"];
+var BYOK_ALIAS_VARS = ["BYOK_ENABLED"];
 function resolveDefaultManifest() {
   let dir = path.dirname(new URL(import.meta.url).pathname);
   for (let i = 0; i < 6; i++) {
@@ -56,11 +56,15 @@ function resolveStack(manifest, requested) {
   const entry = manifest.stacks[version];
   return { version, services: entry?.services ?? {} };
 }
+function isAskExeImage(image) {
+  return image.startsWith("ghcr.io/askexe/") || image.startsWith("update.askexe.com/askexe/");
+}
 function checkDigestPinning(services) {
   const bug = "ee16e7ef (digest-pinning)";
   const offenders = [];
   for (const [name, svc] of Object.entries(services)) {
     if (!svc.image) continue;
+    if (!isAskExeImage(svc.image)) continue;
     const { hasDigest } = parseImageRef(svc.image);
     if (!hasDigest) offenders.push(`${name}=${svc.image}`);
   }
@@ -154,14 +158,13 @@ function checkEnvContract(env, compose) {
     for (const m of compose.text.matchAll(/\$\{?([A-Z][A-Z0-9_]+)/g)) declared.add(m[1]);
   }
   const missingEnforcement = BYOK_ENFORCEMENT_VARS.filter((v) => !declared.has(v));
-  const exposedLegacy = BYOK_LEGACY_VARS.filter((v) => declared.has(v));
-  if (missingEnforcement.length > 0 && exposedLegacy.length > 0) {
+  const aliasDeclared = BYOK_ALIAS_VARS.filter((v) => declared.has(v));
+  if (aliasDeclared.length > 0) {
     return {
       check: "env-contract",
-      status: "fail",
+      status: "pass",
       bug,
-      offenders: [...exposedLegacy.map((v) => `exposes ${v}`), ...missingEnforcement.map((v) => `missing ${v}`)],
-      message: `BYOK env-contract mismatch \u2014 customer surface exposes ${exposedLegacy.join("/")} but billing enforcement reads ${BYOK_ENFORCEMENT_VARS.join("+")} (absent). BYOK can bypass billing.`
+      message: `BYOK enforcement satisfied via alias (${aliasDeclared.join(", ")} \u2192 byok + allow-direct-keys)`
     };
   }
   if (missingEnforcement.length > 0) {
@@ -170,7 +173,7 @@ function checkEnvContract(env, compose) {
       status: "warn",
       bug,
       offenders: missingEnforcement.map((v) => `missing ${v}`),
-      message: `billing enforcement vars not declared: ${missingEnforcement.join(", ")}`
+      message: `billing enforcement vars not declared: ${missingEnforcement.join(", ")} (and no ${BYOK_ALIAS_VARS.join("/")} alias) \u2014 defaults to metered`
     };
   }
   return { check: "env-contract", status: "pass", bug, message: `BYOK enforcement vars present (${BYOK_ENFORCEMENT_VARS.join(", ")})` };

package/dist/chunk-3VVOHFAM.js

@@ -0,0 +1,367 @@
+import {
+  embed
+} from "./chunk-XI7MFALI.js";
+import {
+  reserveVersions,
+  vectorToBlob
+} from "./chunk-BBLO7IAR.js";
+import {
+  getClient
+} from "./chunk-KWFWIJCI.js";
+
+// src/lib/documents.ts
+import crypto from "crypto";
+var WIKI_AGENT_ID = "wiki";
+var WIKI_AGENT_ROLE = "Knowledge";
+var WIKI_TOOL_NAME = "ingest_document";
+var DEFAULT_CHUNK_IMPORTANCE = 5;
+var DEFAULT_CHUNK_CONFIDENCE = 0.7;
+var DEFAULT_CHUNK_STATUS = "active";
+var DEFAULT_SOURCE_TYPE = "upload";
+function deriveMemorySourceType(mime, filename) {
+  const m = mime?.toLowerCase() ?? "";
+  if (m.startsWith("image/")) return "image";
+  if (m.startsWith("audio/")) return "audio";
+  if (m.startsWith("video/")) return "video";
+  if (m === "application/pdf") return "pdf";
+  if (m.startsWith("text/")) return "text";
+  const ext = filename.split(".").pop()?.toLowerCase() ?? "";
+  if (["pdf"].includes(ext)) return "pdf";
+  if (["png", "jpg", "jpeg", "gif", "webp", "svg", "bmp"].includes(ext)) return "image";
+  if (["mp3", "wav", "ogg", "flac", "aac", "m4a"].includes(ext)) return "audio";
+  if (["mp4", "webm", "mov", "avi", "mkv"].includes(ext)) return "video";
+  if (["txt", "md", "csv", "tsv", "log"].includes(ext)) return "text";
+  return "document";
+}
+function rowToWorkspace(row) {
+  return {
+    id: String(row.id),
+    slug: String(row.slug),
+    name: String(row.name),
+    owner_agent_id: row.owner_agent_id == null ? null : String(row.owner_agent_id),
+    created_at: String(row.created_at),
+    metadata: row.metadata == null ? null : String(row.metadata)
+  };
+}
+function rowToDocument(row) {
+  return {
+    id: String(row.id),
+    workspace_id: String(row.workspace_id),
+    filename: String(row.filename),
+    mime: row.mime == null ? null : String(row.mime),
+    source_type: row.source_type == null ? null : String(row.source_type),
+    user_id: row.user_id == null ? null : String(row.user_id),
+    uploaded_at: String(row.uploaded_at),
+    metadata: row.metadata == null ? null : String(row.metadata)
+  };
+}
+async function resolveWorkspace(slug_or_id, name) {
+  const client = getClient();
+  const existing = await client.execute({
+    sql: "SELECT * FROM workspaces WHERE id = ? OR slug = ? LIMIT 1",
+    args: [slug_or_id, slug_or_id]
+  });
+  if (existing.rows.length > 0) {
+    return rowToWorkspace(existing.rows[0]);
+  }
+  const id = crypto.randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const resolvedName = name ?? slug_or_id;
+  await client.execute({
+    sql: `INSERT INTO workspaces (id, slug, name, created_at) VALUES (?, ?, ?, ?)`,
+    args: [id, slug_or_id, resolvedName, now]
+  });
+  return {
+    id,
+    slug: slug_or_id,
+    name: resolvedName,
+    owner_agent_id: null,
+    created_at: now,
+    metadata: null
+  };
+}
+async function listWorkspaces(limit = 50) {
+  const client = getClient();
+  const result = await client.execute({
+    sql: "SELECT * FROM workspaces ORDER BY created_at DESC LIMIT ?",
+    args: [limit]
+  });
+  return result.rows.map((row) => rowToWorkspace(row));
+}
+async function resolveDefaultWorkspaceId(cwd) {
+  const client = getClient();
+  let projectName;
+  try {
+    const { getProjectName } = await import("./project-name-EWG5KAZP.js");
+    projectName = getProjectName(cwd);
+  } catch {
+    return null;
+  }
+  if (!projectName) return null;
+  const match = await client.execute({
+    sql: "SELECT id FROM workspaces WHERE slug = ? OR name = ? ORDER BY created_at DESC LIMIT 1",
+    args: [projectName, projectName]
+  });
+  if (match.rows.length > 0) return String(match.rows[0].id);
+  const all = await client.execute("SELECT id FROM workspaces LIMIT 2");
+  if (all.rows.length === 1) return String(all.rows[0].id);
+  return null;
+}
+async function createDocument(input) {
+  const client = getClient();
+  const id = crypto.randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const metadata = input.metadata != null ? JSON.stringify(input.metadata) : null;
+  await client.execute({
+    sql: `INSERT INTO documents (id, workspace_id, filename, mime, source_type, user_id, uploaded_at, metadata)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+    args: [
+      id,
+      input.workspace_id,
+      input.filename,
+      input.mime ?? null,
+      input.source_type ?? null,
+      input.user_id ?? null,
+      now,
+      metadata
+    ]
+  });
+  return {
+    id,
+    workspace_id: input.workspace_id,
+    filename: input.filename,
+    mime: input.mime ?? null,
+    source_type: input.source_type ?? null,
+    user_id: input.user_id ?? null,
+    uploaded_at: now,
+    metadata
+  };
+}
+async function embedTexts(texts) {
+  const BATCH_SIZE = 50;
+  const results = [];
+  for (let i = 0; i < texts.length; i += BATCH_SIZE) {
+    const batch = texts.slice(i, i + BATCH_SIZE);
+    const settled = await Promise.allSettled(
+      batch.map((text) => embed(text))
+    );
+    results.push(
+      ...settled.map(
+        (result) => result.status === "fulfilled" ? result.value : null
+      )
+    );
+  }
+  return results;
+}
+function buildContextualPrefix(filename, chunks) {
+  const docSummary = chunks.map((c) => c.text).join(" ").slice(0, 200);
+  return chunks.map(
+    (chunk) => `[Document: ${filename}] ${docSummary}
+---
+${chunk.text}`
+  );
+}
+function buildChunkStatement(input) {
+  const hasVector = input.vector !== null;
+  const charOffset = input.chunk.char_offset ?? null;
+  const pageNumber = input.chunk.page_number ?? null;
+  const sql = hasVector ? `INSERT INTO memories
+         (id, agent_id, agent_role, session_id, timestamp, tool_name, project_name,
+          has_error, raw_text, vector, version, importance, status, confidence,
+          last_accessed, workspace_id, document_id, user_id, char_offset, page_number,
+          source_path, source_type, session_scope)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, vector32(?), ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)` : `INSERT INTO memories
+         (id, agent_id, agent_role, session_id, timestamp, tool_name, project_name,
+          has_error, raw_text, vector, version, importance, status, confidence,
+          last_accessed, workspace_id, document_id, user_id, char_offset, page_number,
+          source_path, source_type, session_scope)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`;
+  const prefix = [
+    input.chunkId,
+    WIKI_AGENT_ID,
+    WIKI_AGENT_ROLE,
+    input.documentId,
+    input.uploadedAt,
+    WIKI_TOOL_NAME,
+    input.workspace.slug,
+    0,
+    input.chunk.text
+  ];
+  const suffix = [
+    input.version,
+    DEFAULT_CHUNK_IMPORTANCE,
+    DEFAULT_CHUNK_STATUS,
+    DEFAULT_CHUNK_CONFIDENCE,
+    input.uploadedAt,
+    input.workspace.id,
+    input.documentId,
+    input.userId,
+    charOffset,
+    pageNumber,
+    input.sourcePath,
+    input.sourceType,
+    input.sessionScope
+  ];
+  const args = hasVector ? [...prefix, vectorToBlob(input.vector), ...suffix] : [...prefix, ...suffix];
+  return { sql, args };
+}
+async function ingestDocument(input) {
+  if (input.chunks.length === 0) {
+    throw new Error("ingestDocument: chunks array must not be empty");
+  }
+  const workspace = await resolveWorkspace(input.workspace_id);
+  const fullText = input.chunks.map((c) => c.text).join(" ");
+  const summary = fullText.slice(0, 200).trim();
+  const contextPrefix = `[Document: ${input.filename}] ${summary}
+---
+`;
+  const enrichedChunks = input.chunks.map((chunk) => ({
+    ...chunk,
+    text: `${contextPrefix}${chunk.text}`
+  }));
+  const vectors = await embedTexts(enrichedChunks.map((c) => c.text));
+  const client = getClient();
+  const documentId = crypto.randomUUID();
+  const uploadedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const mime = input.mime ?? null;
+  const sourceType = input.source_type ?? DEFAULT_SOURCE_TYPE;
+  const userId = input.user_id ?? null;
+  const documentMetadata = input.document_metadata != null ? JSON.stringify(input.document_metadata) : null;
+  const chunkIds = input.chunks.map(() => crypto.randomUUID());
+  const versions = await reserveVersions(input.chunks.length);
+  const documentStmt = {
+    sql: `INSERT INTO documents
+            (id, workspace_id, filename, mime, source_type, user_id, uploaded_at, metadata)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+    args: [
+      documentId,
+      workspace.id,
+      input.filename,
+      mime,
+      sourceType,
+      userId,
+      uploadedAt,
+      documentMetadata
+    ]
+  };
+  const memorySourceType = deriveMemorySourceType(input.mime, input.filename);
+  const memorySourcePath = input.filename;
+  let docSessionScope = null;
+  try {
+    const { resolveExeSession } = await import("./lib/tmux-routing.js");
+    docSessionScope = resolveExeSession() ?? null;
+  } catch {
+  }
+  const chunkStmts = enrichedChunks.map(
+    (chunk, index) => buildChunkStatement({
+      chunkId: chunkIds[index],
+      version: versions[index],
+      chunk,
+      vector: vectors[index],
+      documentId,
+      workspace,
+      userId,
+      uploadedAt,
+      sourcePath: memorySourcePath,
+      sourceType: memorySourceType,
+      sessionScope: docSessionScope
+    })
+  );
+  await client.batch([documentStmt, ...chunkStmts], "write");
+  const embedded = vectors.filter((v) => v !== null).length;
+  const originalTexts = input.chunks.map((c) => c.text);
+  import("./doc-graph-extractor-2SRTBTCN.js").then(
+    ({ extractAndStoreDocumentGraph }) => extractAndStoreDocumentGraph(documentId, originalTexts)
+  ).catch((err) => {
+    process.stderr.write(
+      `[documents] Graph extraction failed for ${documentId}: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  });
+  return {
+    document_id: documentId,
+    chunk_ids: chunkIds,
+    embedded,
+    pending_backfill: input.chunks.length - embedded
+  };
+}
+var DEFAULT_LIST_LIMIT = 50;
+var MIN_IMPORTANCE = 1;
+var MAX_IMPORTANCE = 10;
+async function getDocument(id) {
+  const client = getClient();
+  const result = await client.execute({
+    sql: "SELECT * FROM documents WHERE id = ?",
+    args: [id]
+  });
+  if (result.rows.length === 0) return null;
+  return rowToDocument(result.rows[0]);
+}
+async function listDocumentsByWorkspace(workspace_id, limit = DEFAULT_LIST_LIMIT, offset = 0) {
+  const client = getClient();
+  const result = await client.execute({
+    sql: `SELECT d.*, COUNT(m.id) AS chunk_count
+          FROM documents d
+          LEFT JOIN memories m ON m.document_id = d.id
+          WHERE d.workspace_id = ?
+          GROUP BY d.id
+          ORDER BY d.uploaded_at DESC
+          LIMIT ? OFFSET ?`,
+    args: [workspace_id, limit, offset]
+  });
+  return result.rows.map((row) => {
+    const r = row;
+    return {
+      ...rowToDocument(r),
+      chunk_count: Number(r.chunk_count) || 0
+    };
+  });
+}
+async function deleteDocumentAndChunks(id) {
+  const client = getClient();
+  const countResult = await client.execute({
+    sql: "SELECT COUNT(*) AS cnt FROM memories WHERE document_id = ? AND COALESCE(status, 'active') = 'active'",
+    args: [id]
+  });
+  const deletedChunks = Number(countResult.rows[0]?.cnt) || 0;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  await client.batch(
+    [
+      { sql: "UPDATE memories SET status = 'deleted', deleted_at = ? WHERE document_id = ? AND COALESCE(status, 'active') = 'active'", args: [now, id] },
+      { sql: "DELETE FROM documents WHERE id = ?", args: [id] }
+    ],
+    "write"
+  );
+  return { deletedChunks, deletedVectors: deletedChunks };
+}
+async function updateChunksImportance(document_id, importance) {
+  if (!Number.isInteger(importance) || importance < MIN_IMPORTANCE || importance > MAX_IMPORTANCE) {
+    throw new Error(
+      `importance must be an integer between ${MIN_IMPORTANCE} and ${MAX_IMPORTANCE} (got ${importance})`
+    );
+  }
+  const client = getClient();
+  const result = await client.execute({
+    sql: "UPDATE memories SET importance = ? WHERE document_id = ?",
+    args: [importance, document_id]
+  });
+  return Number(result.rowsAffected) || 0;
+}
+
+export {
+  rowToWorkspace,
+  rowToDocument,
+  resolveWorkspace,
+  listWorkspaces,
+  resolveDefaultWorkspaceId,
+  createDocument,
+  buildContextualPrefix,
+  ingestDocument,
+  DEFAULT_LIST_LIMIT,
+  MIN_IMPORTANCE,
+  MAX_IMPORTANCE,
+  getDocument,
+  listDocumentsByWorkspace,
+  deleteDocumentAndChunks,
+  updateChunksImportance
+};

package/dist/{chunk-KSMITUGY.js → chunk-4CVHT2O5.js}

@@ -1,9 +1,9 @@
 import {
   updateTask
-} from "./chunk-EOS7VPVT.js";
+} from "./chunk-AHIUTOZS.js";
 import {
   TASK_ALREADY_CLAIMED_PREFIX
-} from "./chunk-HED6D5KR.js";
+} from "./chunk-HEXJWMFX.js";
 
 // src/mcp/tools/update-task.ts
 import { z } from "zod";
@@ -40,7 +40,7 @@ function registerUpdateTask(server) {
       let callerAgentId;
       let callerSession;
       try {
-        const { getActiveAgent: getAgent } = await import("./active-agent-S5T2YMOR.js");
+        const { getActiveAgent: getAgent } = await import("./active-agent-WFNMZBPP.js");
         callerAgentId = getAgent().agentId;
         const { getAgentContext } = await import("./agent-context-AZTTMUHP.js");
         callerSession = getAgentContext()?.sessionHint || process.env.EXE_SESSION_NAME || process.env.EXE_SESSION || void 0;

package/dist/{chunk-YUBTHJVV.js → chunk-4LTLAVOW.js}

@@ -87,7 +87,7 @@ async function getRetrievalHealth() {
   const coveragePct = totalMemories > 0 ? Math.round(memoriesWithVectors / totalMemories * 100) : null;
   let dbRestore = { hasEvents: false, count: 0, last: null, quarantineFiles: 0 };
   try {
-    const { getDbRestoreHealth } = await import("./db-restore-events-3R7G4FP4.js");
+    const { getDbRestoreHealth } = await import("./db-restore-events-3A57GMLW.js");
     dbRestore = getDbRestoreHealth();
   } catch {
   }

package/dist/{chunk-J3QZPDNH.js → chunk-4YS2MDBF.js}

@@ -1,6 +1,6 @@
 import {
   completeReminder
-} from "./chunk-JNARUXDC.js";
+} from "./chunk-GS67TVCP.js";
 
 // src/mcp/tools/complete-reminder.ts
 import { z } from "zod";

package/dist/{chunk-IRHNV4GY.js → chunk-5KLQCGI5.js}

@@ -24,6 +24,38 @@ var FRONTEND_URLS = {
   "exe-monitor-hub": "http://127.0.0.1:8090"
 };
 var GOTRUE_TOKEN_URL = "http://127.0.0.1:9999/token?grant_type=password";
+function parseComposeServiceNames(composeFile) {
+  const names = /* @__PURE__ */ new Set();
+  if (!existsSync(composeFile)) return names;
+  let raw;
+  try {
+    raw = readFileSync(composeFile, "utf8");
+  } catch {
+    return names;
+  }
+  let inServices = false;
+  for (const line of raw.split(/\r?\n/)) {
+    if (!line.trim() || line.trim().startsWith("#")) continue;
+    const indent = line.length - line.trimStart().length;
+    const trimmed = line.trim();
+    if (indent === 0) {
+      inServices = /^services:\s*$/.test(trimmed);
+      continue;
+    }
+    if (inServices && indent === 2 && /^[a-zA-Z0-9_-]+:\s*$/.test(trimmed)) {
+      names.add(trimmed.replace(/:.*$/, ""));
+    }
+  }
+  return names;
+}
+function filterToDeployed(map, deployed) {
+  if (deployed.size === 0) return map;
+  const out = {};
+  for (const [name, val] of Object.entries(map)) {
+    if (deployed.has(name)) out[name] = val;
+  }
+  return out;
+}
 function loadEnvFile(envPath) {
   if (!existsSync(envPath)) return {};
   const raw = readFileSync(envPath, "utf8");
@@ -137,10 +169,14 @@ async function checkContainersHealthy(composeFile) {
     return { check, status: "fail", message: err instanceof Error ? err.message : String(err) };
   }
 }
-async function checkServiceUrls() {
+async function checkServiceUrls(deployed) {
   const check = "All service URLs respond 200";
+  const urls = filterToDeployed(SERVICE_URLS, deployed);
+  if (Object.keys(urls).length === 0) {
+    return { check, status: "skip", message: "No HTTP services deployed in this selection" };
+  }
   const failures = [];
-  for (const [service, url] of Object.entries(SERVICE_URLS)) {
+  for (const [service, url] of Object.entries(urls)) {
     try {
       const res = await httpGet(url, CHECK_TIMEOUT_MS);
       if (res.status !== 200) {
@@ -153,10 +189,13 @@ async function checkServiceUrls() {
   if (failures.length > 0) {
     return { check, status: "fail", message: failures.join("; ") };
   }
-  return { check, status: "pass", message: `${Object.keys(SERVICE_URLS).length} services responding` };
+  return { check, status: "pass", message: `${Object.keys(urls).length} services responding` };
 }
-async function checkGoTrueLogin(env) {
+async function checkGoTrueLogin(env, deployed) {
   const check = "GoTrue login works";
+  if (deployed.size > 0 && !deployed.has("gotrue")) {
+    return { result: { check, status: "skip", message: "gotrue not deployed in this selection" } };
+  }
   const email = env.GOTRUE_TEST_EMAIL || process.env.GOTRUE_TEST_EMAIL;
   const password = env.GOTRUE_TEST_PASSWORD || process.env.GOTRUE_TEST_PASSWORD;
   if (!email || !password) {
@@ -178,8 +217,11 @@ async function checkGoTrueLogin(env) {
     return { result: { check, status: "fail", message: err instanceof Error ? err.message : String(err) } };
   }
 }
-async function checkWhatsAppConnected() {
+async function checkWhatsAppConnected(deployed) {
   const check = "WhatsApp still connected";
+  if (deployed.size > 0 && !deployed.has("exe-gateway")) {
+    return { check, status: "skip", message: "exe-gateway not deployed in this selection" };
+  }
   try {
     const res = await httpGet(SERVICE_URLS["exe-gateway"], CHECK_TIMEOUT_MS);
     if (res.status !== 200) {
@@ -205,10 +247,14 @@ async function checkWhatsAppConnected() {
     return { check, status: "fail", message: err instanceof Error ? err.message : String(err) };
   }
 }
-async function checkFrontendsLoad() {
+async function checkFrontendsLoad(deployed) {
   const check = "Each frontend loads";
+  const urls = filterToDeployed(FRONTEND_URLS, deployed);
+  if (Object.keys(urls).length === 0) {
+    return { check, status: "skip", message: "No frontends deployed in this selection" };
+  }
   const failures = [];
-  for (const [service, url] of Object.entries(FRONTEND_URLS)) {
+  for (const [service, url] of Object.entries(urls)) {
     try {
       const res = await httpGet(url, CHECK_TIMEOUT_MS);
       if (!res.contentType.includes("text/html")) {
@@ -223,10 +269,13 @@ async function checkFrontendsLoad() {
   if (failures.length > 0) {
     return { check, status: "fail", message: failures.join("; ") };
   }
-  return { check, status: "pass", message: `${Object.keys(FRONTEND_URLS).length} frontends serving HTML` };
+  return { check, status: "pass", message: `${Object.keys(urls).length} frontends serving HTML` };
 }
-async function checkMonitorMetrics() {
+async function checkMonitorMetrics(deployed) {
   const check = "Monitor reports metrics";
+  if (deployed.size > 0 && !deployed.has("exe-monitor-hub")) {
+    return { check, status: "skip", message: "exe-monitor-hub not deployed in this selection" };
+  }
   try {
     const res = await httpGet(SERVICE_URLS["exe-monitor-hub"], CHECK_TIMEOUT_MS);
     if (res.status !== 200) {
@@ -264,15 +313,18 @@ async function checkRawPipeline(env) {
     return { check, status: "fail", message: msg.slice(0, 200) };
   }
 }
-async function checkCrossServiceAuth(jwt) {
+async function checkCrossServiceAuth(jwt, deployed) {
   const check = "Cross-service auth";
   if (!jwt) {
     return { check, status: "skip", message: "No GoTrue JWT available (check 3 skipped or failed)" };
   }
-  const targets = {
+  const targets = filterToDeployed({
     "exe-wiki": "http://127.0.0.1:3001/api/ping",
     "exe-crm": "http://127.0.0.1:3000/healthz"
-  };
+  }, deployed);
+  if (Object.keys(targets).length === 0) {
+    return { check, status: "skip", message: "No JWT-consuming services (wiki/CRM) deployed in this selection" };
+  }
   const failures = [];
   for (const [service, url] of Object.entries(targets)) {
     try {
@@ -295,6 +347,7 @@ async function runVerifyStack(options) {
   const totalTimeout = options?.timeoutMs ?? TOTAL_TIMEOUT_MS;
   const env = loadEnvFile(envFile);
   const results = [];
+  const deployed = parseComposeServiceNames(composeFile);
   const deadline = Date.now() + totalTimeout;
   const addResult = (r) => {
     results.push(r);
@@ -304,20 +357,20 @@ async function runVerifyStack(options) {
   };
   addResult(await checkContainersHealthy(composeFile));
   if (Date.now() > deadline) return summarize(results);
-  addResult(await checkServiceUrls());
+  addResult(await checkServiceUrls(deployed));
   if (Date.now() > deadline) return summarize(results);
-  const goTrueResult = await checkGoTrueLogin(env);
+  const goTrueResult = await checkGoTrueLogin(env, deployed);
   addResult(goTrueResult.result);
   if (Date.now() > deadline) return summarize(results);
-  addResult(await checkWhatsAppConnected());
+  addResult(await checkWhatsAppConnected(deployed));
   if (Date.now() > deadline) return summarize(results);
-  addResult(await checkFrontendsLoad());
+  addResult(await checkFrontendsLoad(deployed));
   if (Date.now() > deadline) return summarize(results);
-  addResult(await checkMonitorMetrics());
+  addResult(await checkMonitorMetrics(deployed));
   if (Date.now() > deadline) return summarize(results);
   addResult(await checkRawPipeline(env));
   if (Date.now() > deadline) return summarize(results);
-  addResult(await checkCrossServiceAuth(goTrueResult.jwt));
+  addResult(await checkCrossServiceAuth(goTrueResult.jwt, deployed));
   return summarize(results);
 }
 function summarize(results) {
@@ -384,5 +437,6 @@ if (isMainModule(import.meta.url) && process.argv[1]?.includes("verify-stack"))
 }
 
 export {
+  parseComposeServiceNames,
   runVerifyStack
 };

package/dist/{chunk-JMHKK7A5.js → chunk-5WFX4JKF.js}

@@ -212,7 +212,7 @@ async function main(args) {
   console.log("[health-gate] Starting rollback...");
   restorePreDeployBackup();
   try {
-    const { rollbackStackUpdate, defaultStackPaths } = await import("./stack-update-TUBZTY7Z.js");
+    const { rollbackStackUpdate, defaultStackPaths } = await import("./stack-update-K6X7ZMQE.js");
     const paths = defaultStackPaths();
     await rollbackStackUpdate({
       manifestRef: paths.manifestRef,

package/dist/{chunk-4BANMHJ5.js → chunk-63PNRWLU.js}

@@ -1,10 +1,10 @@
 import {
   sessionScopeFilter
-} from "./chunk-HED6D5KR.js";
+} from "./chunk-HEXJWMFX.js";
 import {
   getClient,
   getIdentity
-} from "./chunk-SCYWCWKY.js";
+} from "./chunk-KWFWIJCI.js";
 import {
   getEmotionalBaseline
 } from "./chunk-PNQDP3OA.js";
@@ -643,7 +643,7 @@ var DreamingEngine = class {
     }
     let overdueProspective = [];
     try {
-      const { getOverdueProspective, completeProspective } = await import("./prospective-memory-FQSVMCGG.js");
+      const { getOverdueProspective, completeProspective } = await import("./prospective-memory-YHUWPNOO.js");
       const overdue = await getOverdueProspective(agentId);
       overdueProspective = overdue.map((o) => ({
         id: o.id,