@askexenow/exe-os 0.9.286 → 0.9.288

package/dist/chunk-O3IESEF6.js

@@ -0,0 +1,85 @@
+import {
+  PLATFORM_PROCEDURES,
+  PLATFORM_PROCEDURE_TITLES
+} from "./chunk-VUH67PT4.js";
+import {
+  getClient
+} from "./chunk-WLDBPKRL.js";
+
+// src/lib/global-procedures.ts
+import { randomUUID } from "crypto";
+var _customerCache = "";
+var _cacheLoaded = false;
+var _platformCache = PLATFORM_PROCEDURES.map((p) => `### ${p.title}
+${p.content}`).join("\n\n");
+async function loadGlobalProcedures() {
+  const client = getClient();
+  const result = await client.execute({
+    sql: "SELECT * FROM company_procedures WHERE active = 1 ORDER BY priority ASC, created_at ASC",
+    args: []
+  });
+  const allRows = result.rows;
+  const customerOnly = allRows.filter((p) => {
+    if (PLATFORM_PROCEDURE_TITLES.has(p.title)) return false;
+    const title = (p.title ?? "").trim();
+    const content = (p.content ?? "").trim();
+    if (!title || title === "(untitled)") return false;
+    if (!content) return false;
+    return true;
+  });
+  const values = customerOnly.filter((p) => p.kind === "value");
+  const procedures = customerOnly.filter((p) => p.kind !== "value");
+  const parts = [];
+  if (values.length > 0) {
+    parts.push("### Company Values\n" + values.map((v) => `- **${v.title}:** ${v.content}`).join("\n"));
+  }
+  if (procedures.length > 0) {
+    parts.push(procedures.map((p) => `### ${p.title}
+${p.content}`).join("\n\n"));
+  }
+  _customerCache = parts.join("\n\n");
+  _cacheLoaded = true;
+  return customerOnly;
+}
+function getGlobalProceduresBlock() {
+  const sections = [];
+  if (_platformCache) sections.push(_platformCache);
+  if (_cacheLoaded && _customerCache) sections.push(_customerCache);
+  if (sections.length === 0) return "";
+  return `## Organization-Wide Procedures (MANDATORY \u2014 supersedes all other rules)
+
+${sections.join("\n\n")}
+`;
+}
+async function storeGlobalProcedure(input) {
+  if (!input.title?.trim() || !input.content?.trim()) {
+    throw new Error("storeGlobalProcedure requires a non-empty title and content");
+  }
+  const id = randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const client = getClient();
+  await client.execute({
+    sql: `INSERT INTO company_procedures (id, title, content, priority, domain, kind, active, created_at, updated_at)
+          VALUES (?, ?, ?, ?, ?, ?, 1, ?, ?)`,
+    args: [id, input.title, input.content, input.priority ?? "p0", input.domain ?? null, input.kind ?? "procedure", now, now]
+  });
+  await loadGlobalProcedures();
+  return id;
+}
+async function deactivateGlobalProcedure(id) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const client = getClient();
+  const result = await client.execute({
+    sql: "UPDATE company_procedures SET active = 0, updated_at = ? WHERE id = ?",
+    args: [now, id]
+  });
+  await loadGlobalProcedures();
+  return result.rowsAffected > 0;
+}
+
+export {
+  loadGlobalProcedures,
+  getGlobalProceduresBlock,
+  storeGlobalProcedure,
+  deactivateGlobalProcedure
+};

package/dist/chunk-OAO2BK25.js

@@ -0,0 +1,81 @@
+// src/bin/fast-db-init.ts
+async function fastDbInit() {
+  const { isInitialized, getClient, setExternalClient } = await import("./lib/database.js");
+  if (isInitialized()) {
+    return getClient();
+  }
+  const forceDirect = process.env.EXE_DB_DIRECT === "1" || process.env.EXE_DB_READONLY === "1" || process.env.EXE_SKIP_DAEMON === "1";
+  if (!forceDirect) {
+    try {
+      const { connectEmbedDaemon, sendDaemonRequest, isClientConnected, disconnectClient } = await import("./lib/exe-daemon-client.js");
+      const { deserializeResultSet } = await import("./daemon-protocol-XW2OLNBS.js");
+      await Promise.race([
+        connectEmbedDaemon(),
+        new Promise((_, reject) => setTimeout(() => reject(new Error("Daemon socket timeout (2s)")), 2e3))
+      ]);
+      if (isClientConnected()) {
+        const daemonClient = {
+          async execute(stmt) {
+            const sql = typeof stmt === "string" ? stmt : stmt.sql;
+            const args = typeof stmt === "string" ? [] : Array.isArray(stmt.args) ? stmt.args : [];
+            const resp = await sendDaemonRequest({ type: "db-execute", sql, args });
+            if (resp.error) throw new Error(String(resp.error));
+            if (resp.db) return deserializeResultSet(resp.db);
+            throw new Error("Unexpected daemon response");
+          },
+          async batch(stmts, mode) {
+            const statements = stmts.map((s) => {
+              const sql = typeof s === "string" ? s : s.sql;
+              const args = typeof s === "string" ? [] : Array.isArray(s.args) ? s.args : [];
+              return { sql, args };
+            });
+            const resp = await sendDaemonRequest({ type: "db-batch", statements, mode: mode ?? "deferred" });
+            if (resp.error) throw new Error(String(resp.error));
+            const batchResults = resp["db-batch"];
+            if (batchResults) return batchResults.map(deserializeResultSet);
+            throw new Error("Unexpected daemon batch response");
+          },
+          async transaction(_mode) {
+            throw new Error("Transactions not supported via daemon socket");
+          },
+          async executeMultiple(_sql) {
+            throw new Error("executeMultiple not supported via daemon socket");
+          },
+          async migrate(_stmts) {
+            throw new Error("migrate not supported via daemon socket");
+          },
+          sync() {
+            return Promise.resolve(void 0);
+          },
+          close() {
+          },
+          get closed() {
+            return false;
+          },
+          get protocol() {
+            return "file";
+          }
+        };
+        try {
+          await daemonClient.execute("SELECT 1");
+        } catch {
+          try {
+            disconnectClient();
+          } catch {
+          }
+          throw new Error("Daemon socket validation failed");
+        }
+        setExternalClient(daemonClient);
+        return daemonClient;
+      }
+    } catch {
+    }
+  }
+  const { initStore } = await import("./lib/store.js");
+  await initStore({ lightweight: true });
+  return getClient();
+}
+
+export {
+  fastDbInit
+};

package/dist/chunk-OFY7RGLL.js

@@ -0,0 +1,348 @@
+import {
+  getIdentity,
+  loadEmployeesSync
+} from "./chunk-XVDWHYIK.js";
+
+// src/lib/drift-probes.ts
+var DRIFT_THRESHOLD = 80;
+async function getRecentMemories(agentId, limit) {
+  try {
+    const { getClient, isInitialized } = await import("./lib/database.js");
+    if (!isInitialized()) return { count: 0, texts: [] };
+    const client = getClient();
+    const result = await client.execute({
+      sql: `SELECT text FROM memories WHERE agent_id = ? ORDER BY created_at DESC LIMIT ?`,
+      args: [agentId, limit]
+    });
+    const texts = result.rows.map((r) => String(r.text ?? ""));
+    return { count: texts.length, texts };
+  } catch {
+    return { count: 0, texts: [] };
+  }
+}
+async function getDecisionCount(agentId) {
+  try {
+    const { getClient, isInitialized } = await import("./lib/database.js");
+    if (!isInitialized()) return 0;
+    const client = getClient();
+    const result = await client.execute({
+      sql: `SELECT COUNT(*) as cnt FROM memories WHERE agent_id = ? AND memory_type = 'decision'`,
+      args: [agentId]
+    });
+    return Number(result.rows[0]?.cnt ?? 0);
+  } catch {
+    return 0;
+  }
+}
+function probeContinuity(ctx) {
+  const memCount = ctx.recentMemoryCount;
+  let score;
+  let detail;
+  if (memCount >= 20) {
+    score = 95;
+    detail = `${memCount} recent memories \u2014 strong continuity`;
+  } else if (memCount >= 10) {
+    score = 85;
+    detail = `${memCount} recent memories \u2014 adequate continuity`;
+  } else if (memCount >= 3) {
+    score = 70;
+    detail = `${memCount} recent memories \u2014 limited continuity`;
+  } else if (memCount >= 1) {
+    score = 50;
+    detail = `${memCount} recent memories \u2014 weak continuity`;
+  } else {
+    score = 30;
+    detail = "No recent memories \u2014 agent may lack session context";
+  }
+  if (ctx.storedDecisionCount > 0) {
+    score = Math.min(100, score + 5);
+    detail += ` (+${ctx.storedDecisionCount} decisions)`;
+  }
+  return { axis: "continuity", score, detail };
+}
+function probeConsistency(ctx) {
+  if (!ctx.identityBody || ctx.recentMemoryTexts.length === 0) {
+    return {
+      axis: "consistency",
+      score: ctx.identityBody ? 80 : 50,
+      detail: ctx.identityBody ? "No memories to check against identity" : "No identity file \u2014 cannot assess consistency"
+    };
+  }
+  const identityTerms = extractKeyTerms(ctx.identityBody);
+  if (identityTerms.length === 0) {
+    return { axis: "consistency", score: 75, detail: "Identity has no extractable key terms" };
+  }
+  const memoryText = ctx.recentMemoryTexts.join(" ").toLowerCase();
+  let matched = 0;
+  for (const term of identityTerms) {
+    if (memoryText.includes(term.toLowerCase())) matched++;
+  }
+  const ratio = matched / identityTerms.length;
+  const score = Math.round(50 + ratio * 50);
+  const detail = `${matched}/${identityTerms.length} identity terms found in recent memories`;
+  return { axis: "consistency", score, detail };
+}
+function probeRoleFidelity(ctx) {
+  const flags = [];
+  if (!ctx.identityBody) {
+    return {
+      axis: "role-fidelity",
+      score: 40,
+      detail: `No identity file for ${ctx.agent.name}`
+    };
+  }
+  let score = 100;
+  const identityLower = ctx.identityBody.toLowerCase();
+  const rosterRole = ctx.agent.role.toLowerCase();
+  if (!identityLower.includes(rosterRole)) {
+    score -= 15;
+    flags.push(`Identity does not mention role "${ctx.agent.role}"`);
+  }
+  if (!identityLower.includes(ctx.agent.name.toLowerCase())) {
+    score -= 10;
+    flags.push(`Identity does not mention agent name "${ctx.agent.name}"`);
+  }
+  const hasScopeBoundary = identityLower.includes("do not") || identityLower.includes("don't") || identityLower.includes("not your") || identityLower.includes("outside your") || identityLower.includes("you do not");
+  if (!hasScopeBoundary) {
+    score -= 10;
+    flags.push("Identity lacks explicit scope boundaries (what NOT to do)");
+  }
+  if (ctx.agent.systemPrompt) {
+    const promptTerms = extractKeyTerms(ctx.agent.systemPrompt);
+    const identityText = ctx.identityBody.toLowerCase();
+    let promptMatched = 0;
+    for (const term of promptTerms.slice(0, 20)) {
+      if (identityText.includes(term.toLowerCase())) promptMatched++;
+    }
+    const promptRatio = promptTerms.length > 0 ? promptMatched / Math.min(promptTerms.length, 20) : 1;
+    if (promptRatio < 0.3) {
+      score -= 15;
+      flags.push("Identity content diverges significantly from roster systemPrompt");
+    }
+  }
+  if (ctx.recentMemoryTexts.length > 5) {
+    const roleKeywords = extractRoleKeywords(ctx.agent.role);
+    const memoryText = ctx.recentMemoryTexts.join(" ").toLowerCase();
+    let domainHits = 0;
+    for (const kw of roleKeywords) {
+      if (memoryText.includes(kw)) domainHits++;
+    }
+    const domainRatio = roleKeywords.length > 0 ? domainHits / roleKeywords.length : 1;
+    if (domainRatio < 0.2) {
+      score -= 10;
+      flags.push(`Recent work shows little overlap with ${ctx.agent.role} domain keywords`);
+    }
+  }
+  score = Math.max(0, Math.min(100, score));
+  const detail = flags.length > 0 ? flags.join("; ") : "Identity aligns with roster definition";
+  return { axis: "role-fidelity", score, detail };
+}
+function probeWorldModel(ctx) {
+  if (!ctx.identityBody) {
+    return {
+      axis: "world-model",
+      score: 50,
+      detail: "No identity file \u2014 cannot assess org awareness"
+    };
+  }
+  const identityLower = ctx.identityBody.toLowerCase();
+  const flags = [];
+  let score = 100;
+  const otherAgents = ctx.allEmployees.filter((e) => e.name !== ctx.agent.name);
+  let mentionedAgents = 0;
+  for (const other of otherAgents) {
+    if (identityLower.includes(other.name.toLowerCase())) mentionedAgents++;
+  }
+  if (otherAgents.length > 0) {
+    const mentionRatio = mentionedAgents / otherAgents.length;
+    if (mentionRatio < 0.3) {
+      score -= 15;
+      flags.push(`Identity mentions ${mentionedAgents}/${otherAgents.length} team members`);
+    }
+  }
+  const hasReportingChain = identityLower.includes("report") || identityLower.includes("manager") || identityLower.includes("coo") || identityLower.includes("coordinator");
+  if (!hasReportingChain) {
+    score -= 10;
+    flags.push("Identity does not reference reporting chain");
+  }
+  const orgTerms = ["exe-os", "exe-wiki", "exe-crm", "askexe"];
+  let orgMentions = 0;
+  for (const term of orgTerms) {
+    if (identityLower.includes(term)) orgMentions++;
+  }
+  if (orgMentions === 0) {
+    score -= 5;
+    flags.push("Identity does not reference any org products");
+  }
+  score = Math.max(0, Math.min(100, score));
+  const detail = flags.length > 0 ? flags.join("; ") : "Identity reflects org structure";
+  return { axis: "world-model", score, detail };
+}
+function extractKeyTerms(text) {
+  const stopwords = /* @__PURE__ */ new Set([
+    "the",
+    "and",
+    "for",
+    "are",
+    "but",
+    "not",
+    "you",
+    "all",
+    "any",
+    "can",
+    "had",
+    "her",
+    "was",
+    "one",
+    "our",
+    "out",
+    "has",
+    "his",
+    "how",
+    "its",
+    "may",
+    "new",
+    "now",
+    "old",
+    "see",
+    "way",
+    "who",
+    "did",
+    "get",
+    "got",
+    "let",
+    "say",
+    "she",
+    "too",
+    "use",
+    "with",
+    "this",
+    "that",
+    "from",
+    "they",
+    "been",
+    "have",
+    "will",
+    "your",
+    "what",
+    "when",
+    "make",
+    "like",
+    "just",
+    "over",
+    "such",
+    "take",
+    "than",
+    "them",
+    "very",
+    "some",
+    "could",
+    "into",
+    "then",
+    "more",
+    "also",
+    "after",
+    "should",
+    "would",
+    "about",
+    "their",
+    "which",
+    "these",
+    "other",
+    "every",
+    "does",
+    "being",
+    "those",
+    "never",
+    "before",
+    "through"
+  ]);
+  const words = text.replace(/[^\w\s-]/g, " ").split(/\s+/).filter((w) => w.length > 3 && !stopwords.has(w.toLowerCase()));
+  return [...new Set(words.map((w) => w.toLowerCase()))].slice(0, 50);
+}
+function extractRoleKeywords(role) {
+  const roleKeywordMap = {
+    "coo": ["coordinate", "review", "status", "team", "task", "priority", "dispatch"],
+    "cto": ["architecture", "code", "technical", "system", "design", "review", "security"],
+    "cmo": ["marketing", "brand", "content", "design", "seo", "social", "campaign"],
+    "principal engineer": ["code", "implement", "test", "fix", "feature", "refactor", "build"],
+    "staff code reviewer": ["review", "code", "quality", "issue", "fix", "pattern"],
+    "content production specialist": ["video", "image", "render", "content", "produce", "media"],
+    "ai product lead": ["competitive", "analysis", "feature", "product", "research", "repo"]
+  };
+  const normalized = role.toLowerCase();
+  return roleKeywordMap[normalized] ?? normalized.split(/\s+/).filter((w) => w.length > 2);
+}
+async function runDriftProbes(options = {}) {
+  const employees = loadEmployeesSync();
+  const targetAgents = options.agentId ? employees.filter((e) => e.name === options.agentId) : employees;
+  if (targetAgents.length === 0) {
+    return [];
+  }
+  const axes = options.axes ?? ["continuity", "consistency", "role-fidelity", "world-model"];
+  const results = [];
+  for (const agent of targetAgents) {
+    const identity = getIdentity(agent.name);
+    const { count: memCount, texts: memTexts } = await getRecentMemories(agent.name, 50);
+    const decisionCount = await getDecisionCount(agent.name);
+    const ctx = {
+      agent,
+      identityBody: identity?.body ?? null,
+      identityRole: identity?.frontmatter.role ?? null,
+      recentMemoryCount: memCount,
+      recentMemoryTexts: memTexts,
+      storedDecisionCount: decisionCount,
+      allEmployees: employees
+    };
+    const probes = [];
+    const probeFns = {
+      continuity: probeContinuity,
+      consistency: probeConsistency,
+      "role-fidelity": probeRoleFidelity,
+      "world-model": probeWorldModel
+    };
+    for (const axis of axes) {
+      probes.push(probeFns[axis](ctx));
+    }
+    const scores = {
+      continuity: 0,
+      consistency: 0,
+      "role-fidelity": 0,
+      "world-model": 0
+    };
+    for (const probe of probes) {
+      scores[probe.axis] = probe.score;
+    }
+    const weights = {
+      continuity: 0.2,
+      consistency: 0.2,
+      "role-fidelity": 0.35,
+      "world-model": 0.25
+    };
+    let weightedSum = 0;
+    let weightTotal = 0;
+    for (const axis of axes) {
+      weightedSum += scores[axis] * weights[axis];
+      weightTotal += weights[axis];
+    }
+    const overall = Math.round(weightTotal > 0 ? weightedSum / weightTotal : 0);
+    const flags = [];
+    for (const probe of probes) {
+      if (probe.score < DRIFT_THRESHOLD) {
+        flags.push(`${probe.axis} at ${probe.score}% \u2014 ${probe.detail}`);
+      }
+    }
+    results.push({
+      agent: agent.name,
+      scores,
+      overall,
+      drifting: flags.length > 0,
+      flags
+    });
+  }
+  return results;
+}
+
+export {
+  runDriftProbes
+};

package/dist/chunk-OICU3UHF.js

@@ -0,0 +1,181 @@
+import {
+  getClient
+} from "./chunk-XVDWHYIK.js";
+import {
+  loadConfig
+} from "./chunk-CEKZ77KA.js";
+
+// src/lib/reminders.ts
+import crypto from "crypto";
+async function getCloudConfig() {
+  try {
+    const config = await loadConfig();
+    if (config.cloud?.apiKey && config.cloud?.endpoint) {
+      return { apiKey: config.cloud.apiKey, endpoint: config.cloud.endpoint };
+    }
+  } catch {
+  }
+  return null;
+}
+function apiBaseUrl(cloud) {
+  try {
+    const url = new URL(cloud.endpoint);
+    if (url.hostname.startsWith("sync.")) {
+      url.hostname = url.hostname.replace(/^sync\./, "api.");
+      return url.origin;
+    }
+  } catch {
+  }
+  return "https://api.askexe.com";
+}
+async function cloudPushReminder(cloud, text, dueDate) {
+  try {
+    const base = apiBaseUrl(cloud);
+    await fetch(`${base}/v1/reminders`, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${cloud.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ text, due_date: dueDate })
+    });
+  } catch (err) {
+    process.stderr.write(`[reminders] cloud push failed: ${err instanceof Error ? err.message : String(err)}
+`);
+  }
+}
+async function cloudFetchReminders(cloud) {
+  try {
+    const base = apiBaseUrl(cloud);
+    const res = await fetch(`${base}/v1/reminders`, {
+      method: "GET",
+      headers: {
+        "Authorization": `Bearer ${cloud.apiKey}`
+      }
+    });
+    if (!res.ok) return [];
+    const data = await res.json();
+    if (!Array.isArray(data.items)) return [];
+    return data.items.map((r) => ({
+      id: r.id,
+      text: r.text,
+      createdAt: r.created_at,
+      dueDate: r.due_date,
+      completedAt: r.completed_at,
+      source: "cloud"
+    }));
+  } catch (err) {
+    process.stderr.write(`[reminders] cloud fetch failed: ${err instanceof Error ? err.message : String(err)}
+`);
+    return [];
+  }
+}
+async function cloudDeleteReminder(cloud, id) {
+  try {
+    const base = apiBaseUrl(cloud);
+    await fetch(`${base}/v1/reminders/${encodeURIComponent(id)}`, {
+      method: "DELETE",
+      headers: {
+        "Authorization": `Bearer ${cloud.apiKey}`
+      }
+    });
+  } catch (err) {
+    process.stderr.write(`[reminders] cloud delete failed: ${err instanceof Error ? err.message : String(err)}
+`);
+  }
+}
+function dedup(local, cloud) {
+  const localKeys = /* @__PURE__ */ new Set();
+  for (const r of local) {
+    localKeys.add(`${r.text.trim().toLowerCase()}|${r.dueDate ?? ""}`);
+  }
+  const merged = local.map((r) => ({ ...r, source: "local" }));
+  for (const r of cloud) {
+    const key = `${r.text.trim().toLowerCase()}|${r.dueDate ?? ""}`;
+    if (localKeys.has(key)) {
+      const existing = merged.find(
+        (m) => m.text.trim().toLowerCase() === r.text.trim().toLowerCase() && (m.dueDate ?? "") === (r.dueDate ?? "")
+      );
+      if (existing) existing.source = "both";
+    } else {
+      merged.push({ ...r, source: "cloud" });
+    }
+  }
+  return merged;
+}
+async function createReminder(text, dueDate) {
+  const client = getClient();
+  const id = crypto.randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  await client.execute({
+    sql: `INSERT INTO reminders (id, text, created_at, due_date) VALUES (?, ?, ?, ?)`,
+    args: [id, text, now, dueDate ?? null]
+  });
+  const cloud = await getCloudConfig();
+  if (cloud) {
+    cloudPushReminder(cloud, text, dueDate ?? null).catch(() => {
+    });
+  }
+  return { id, text, createdAt: now, dueDate: dueDate ?? null, completedAt: null };
+}
+async function listReminders(includeCompleted = false) {
+  const client = getClient();
+  const sql = includeCompleted ? `SELECT id, text, created_at, due_date, completed_at FROM reminders ORDER BY due_date ASC NULLS LAST LIMIT 500` : `SELECT id, text, created_at, due_date, completed_at FROM reminders WHERE completed_at IS NULL ORDER BY due_date ASC NULLS LAST LIMIT 500`;
+  const result = await client.execute(sql);
+  const local = result.rows.map((row) => ({
+    id: String(row.id),
+    text: String(row.text),
+    createdAt: String(row.created_at),
+    dueDate: row.due_date ? String(row.due_date) : null,
+    completedAt: row.completed_at ? String(row.completed_at) : null
+  }));
+  const cloud = await getCloudConfig();
+  if (cloud) {
+    const cloudReminders = await cloudFetchReminders(cloud);
+    return dedup(local, cloudReminders);
+  }
+  return local;
+}
+async function completeReminder(idOrText) {
+  const client = getClient();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  let result = await client.execute({
+    sql: `SELECT id, text FROM reminders WHERE id = ? AND completed_at IS NULL`,
+    args: [idOrText]
+  });
+  if (result.rows.length === 0) {
+    result = await client.execute({
+      sql: `SELECT id, text FROM reminders WHERE completed_at IS NULL AND text LIKE '%' || ? || '%' LIMIT 1`,
+      args: [idOrText]
+    });
+  }
+  if (result.rows.length === 0) return null;
+  const row = result.rows[0];
+  const id = String(row.id);
+  const text = String(row.text);
+  await client.execute({
+    sql: `UPDATE reminders SET completed_at = ? WHERE id = ?`,
+    args: [now, id]
+  });
+  const cloud = await getCloudConfig();
+  if (cloud) {
+    cloudDeleteReminder(cloud, id).catch(() => {
+    });
+    cloudFetchReminders(cloud).then((cloudReminders) => {
+      for (const cr of cloudReminders) {
+        if (cr.text.trim().toLowerCase() === text.trim().toLowerCase()) {
+          cloudDeleteReminder(cloud, cr.id).catch(() => {
+          });
+        }
+      }
+    }).catch(() => {
+    });
+  }
+  return { id, text, createdAt: "", dueDate: null, completedAt: now };
+}
+
+export {
+  createReminder,
+  listReminders,
+  completeReminder
+};