@askexenow/exe-os 0.9.299 → 0.9.301

package/dist/projection-worker-TMKUSVGD.js

@@ -0,0 +1,1084 @@
+import {
+  extractGoalCandidates,
+  inferIntention,
+  inferOntologyEventType,
+  inferOutcome,
+  inferSemanticLabel,
+  ontologyPayload
+} from "./chunk-S73ZAJ2S.js";
+import {
+  processCRMEvent
+} from "./chunk-OO4IFABD.js";
+import {
+  loadConfig
+} from "./chunk-R36FAN53.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-MLKGABMK.js";
+
+// src/lib/projection-worker.ts
+import os from "os";
+import path from "path";
+import { existsSync } from "fs";
+import { createRequire } from "module";
+import { pathToFileURL } from "url";
+var GRAPH_SCHEMA = "graph";
+var prismaPromise = null;
+var ontologySchemaReady = false;
+var filteredSchemaReady = false;
+function loadPrisma() {
+  if (!prismaPromise) {
+    prismaPromise = (async () => {
+      const explicitPath = process.env.EXE_OS_PRISMA_CLIENT_PATH;
+      if (explicitPath) {
+        const mod = await import(pathToFileURL(explicitPath).href);
+        const Ctor = mod.PrismaClient ?? mod.default?.PrismaClient;
+        if (!Ctor) throw new Error(`No PrismaClient at ${explicitPath}`);
+        return new Ctor();
+      }
+      const exeDbRoot = process.env.EXE_DB_ROOT ?? path.join(os.homedir(), "exe-db");
+      const packagePath = path.join(exeDbRoot, "package.json");
+      if (existsSync(packagePath)) {
+        const req = createRequire(packagePath);
+        const entry = req.resolve("@prisma/client");
+        const mod = await import(pathToFileURL(entry).href);
+        const Ctor = mod.PrismaClient ?? mod.default?.PrismaClient;
+        if (!Ctor) throw new Error(`No PrismaClient in ${entry}`);
+        return new Ctor();
+      }
+      const { Pool } = await import("pg");
+      const { pgSslConfig } = await import("./pg-ssl-7JXQFL4I.js");
+      const pool = new Pool({ connectionString: process.env.DATABASE_URL, ...pgSslConfig() });
+      return {
+        async $queryRawUnsafe(query, ...values) {
+          const result = await pool.query(query, values);
+          return result.rows;
+        },
+        async $executeRawUnsafe(query, ...values) {
+          const result = await pool.query(query, values);
+          return result.rowCount ?? 0;
+        },
+        async $disconnect() {
+          await pool.end();
+        }
+      };
+    })();
+  }
+  return prismaPromise;
+}
+function setProjectionWorkerPrismaClientForTests(client) {
+  prismaPromise = client ? Promise.resolve(client) : null;
+}
+function resetProjectionWorkerForTests() {
+  running = false;
+  if (pollTimer) {
+    clearTimeout(pollTimer);
+    pollTimer = null;
+  }
+  consecutivePollErrors = 0;
+  prismaPromise = null;
+  ontologySchemaReady = false;
+  filteredSchemaReady = false;
+  lastWikiApiPushAt = 0;
+}
+function stableId(input) {
+  let h1 = 3735928559;
+  let h2 = 1103547991;
+  for (let i = 0; i < input.length; i++) {
+    const ch = input.charCodeAt(i);
+    h1 = Math.imul(h1 ^ ch, 2654435761);
+    h2 = Math.imul(h2 ^ ch, 1597334677);
+  }
+  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+  let h3 = 305419896;
+  let h4 = 2596069104;
+  for (let i = 0; i < input.length; i++) {
+    const ch = input.charCodeAt(i);
+    h3 = Math.imul(h3 ^ ch, 2246822507);
+    h4 = Math.imul(h4 ^ ch, 3266489909);
+  }
+  h3 = Math.imul(h3 ^ h3 >>> 16, 2654435761) ^ Math.imul(h4 ^ h4 >>> 13, 1597334677);
+  h4 = Math.imul(h4 ^ h4 >>> 16, 2654435761) ^ Math.imul(h3 ^ h3 >>> 13, 1597334677);
+  const a = (h1 >>> 0).toString(16).padStart(8, "0");
+  const b = (h2 >>> 0).toString(16).padStart(8, "0");
+  const c = (h3 >>> 0).toString(16).padStart(8, "0");
+  const d = (h4 >>> 0).toString(16).padStart(8, "0");
+  const hex = a + b + c + d;
+  return hex.slice(0, 8) + "-" + hex.slice(8, 12) + "-4" + hex.slice(13, 16) + "-" + (parseInt(hex[16], 16) & 3 | 8).toString(16) + hex.slice(17, 20) + "-" + hex.slice(20, 32);
+}
+function graphEntityId(name, type) {
+  return stableId(`${name.toLowerCase()}::${type.toLowerCase()}`);
+}
+function normalizeEntityName(name) {
+  return name.trim().replace(/\s+/g, " ").slice(0, 160);
+}
+function addGraphEntity(entities, name, type, properties = {}) {
+  if (typeof name !== "string") return null;
+  const normalized = normalizeEntityName(name);
+  if (!normalized || normalized.length < 2) return null;
+  const id = graphEntityId(normalized, type);
+  if (!entities.has(id)) entities.set(id, { id, name: normalized, type, properties });
+  return id;
+}
+function addGraphRelationship(relationships, sourceId, targetId, type, confidence = 0.7, properties = {}) {
+  if (!sourceId || !targetId || sourceId === targetId) return;
+  const id = graphEntityId(`${sourceId}->${type}->${targetId}`, "relationship");
+  if (!relationships.has(id)) relationships.set(id, { id, sourceId, targetId, type, confidence, properties });
+}
+function deriveLightweightMemoryGraph(payload) {
+  const entities = /* @__PURE__ */ new Map();
+  const relationships = /* @__PURE__ */ new Map();
+  const memoryId = typeof payload.id === "string" ? payload.id : "";
+  const rawText = typeof payload.raw_text === "string" ? payload.raw_text : "";
+  const memoryEntity = addGraphEntity(entities, memoryId || stableId(rawText.slice(0, 256)), "memory", {
+    source: "cloud_sync",
+    version: payload.version
+  });
+  const agentEntity = addGraphEntity(entities, payload.agent_id, "person", { role: payload.agent_role });
+  const projectEntity = addGraphEntity(entities, payload.project_name, "project");
+  const toolEntity = addGraphEntity(entities, payload.tool_name, "tool");
+  const taskEntity = addGraphEntity(entities, payload.task_id, "task");
+  const domainEntity = addGraphEntity(entities, payload.domain, "concept");
+  const memoryTypeEntity = addGraphEntity(entities, payload.memory_type, "concept", { kind: "memory_type" });
+  addGraphRelationship(relationships, agentEntity, projectEntity, "worked_on", 0.8);
+  addGraphRelationship(relationships, agentEntity, toolEntity, "uses", 0.9);
+  addGraphRelationship(relationships, memoryEntity, agentEntity, "created_by", 0.9);
+  addGraphRelationship(relationships, memoryEntity, projectEntity, "part_of", 0.9);
+  addGraphRelationship(relationships, memoryEntity, toolEntity, "uses", 0.8);
+  addGraphRelationship(relationships, memoryEntity, taskEntity, "part_of", 0.8);
+  addGraphRelationship(relationships, memoryEntity, domainEntity, "about", 0.7);
+  addGraphRelationship(relationships, memoryEntity, memoryTypeEntity, "classified_as", 0.7);
+  const pathRegex = /(?:\/[\w .@-]+)+(?:\.[A-Za-z0-9]{1,10})|(?:[\w@.-]+\/)+[\w@.-]+\.(?:ts|tsx|js|jsx|json|md|yml|yaml|sql|py|go|rs|sh|css|html)/g;
+  const fileMatches = new Set((rawText.match(pathRegex) ?? []).slice(0, 8));
+  for (const filePath of fileMatches) {
+    const fileEntity = addGraphEntity(entities, filePath, "file", { source: "raw_text" });
+    addGraphRelationship(relationships, memoryEntity, fileEntity, "references", 0.75);
+    addGraphRelationship(relationships, projectEntity, fileEntity, "uses", 0.55);
+  }
+  const backtickMatches = [...rawText.matchAll(/`([^`\n]{2,80})`/g)].map((m) => m[1]).slice(0, 8);
+  for (const term of backtickMatches) {
+    if (!term || /[\s]{30,}/.test(term)) continue;
+    const conceptEntity = addGraphEntity(entities, term, term.includes("/") || term.includes(".") ? "file" : "concept", { source: "backtick" });
+    addGraphRelationship(relationships, memoryEntity, conceptEntity, "references", 0.65);
+  }
+  return { entities: [...entities.values()], relationships: [...relationships.values()] };
+}
+async function projectMemoryGraph(prisma, payload, memoryId, timestamp) {
+  const graph = deriveLightweightMemoryGraph(payload);
+  if (graph.entities.length === 0) return { entities: 0, relationships: 0 };
+  let entities = 0;
+  let relationships = 0;
+  const actualEntityIds = /* @__PURE__ */ new Map();
+  for (const entity of graph.entities) {
+    const inserted = await prisma.$queryRawUnsafe(
+      `INSERT INTO "${GRAPH_SCHEMA}"."entities" ("id", "name", "type", "first_seen", "last_seen", "properties")
+       VALUES ($1, $2, $3, $4, $4, $5::jsonb)
+       ON CONFLICT ("name", "type") DO UPDATE SET
+         "last_seen" = GREATEST("${GRAPH_SCHEMA}"."entities"."last_seen", EXCLUDED."last_seen"),
+         "properties" = "${GRAPH_SCHEMA}"."entities"."properties" || EXCLUDED."properties"
+       RETURNING "id"`,
+      entity.id,
+      entity.name,
+      entity.type,
+      timestamp,
+      JSON.stringify(entity.properties ?? {})
+    );
+    const actualId = inserted[0]?.id ?? entity.id;
+    actualEntityIds.set(entity.id, actualId);
+    await prisma.$executeRawUnsafe(
+      `INSERT INTO "${GRAPH_SCHEMA}"."entity_memories" ("entity_id", "memory_id")
+       VALUES ($1, $2)
+       ON CONFLICT DO NOTHING`,
+      actualId,
+      memoryId
+    );
+    entities++;
+  }
+  for (const relationship of graph.relationships) {
+    const sourceId = actualEntityIds.get(relationship.sourceId) ?? relationship.sourceId;
+    const targetId = actualEntityIds.get(relationship.targetId) ?? relationship.targetId;
+    const relId = graphEntityId(`${sourceId}->${relationship.type}->${targetId}`, "relationship");
+    await prisma.$executeRawUnsafe(
+      `INSERT INTO "${GRAPH_SCHEMA}"."relationships" ("id", "source_entity_id", "target_entity_id", "type", "weight", "confidence", "timestamp", "properties")
+       VALUES ($1, $2, $3, $4, 1.0, $5, $6, $7::jsonb)
+       ON CONFLICT ("source_entity_id", "target_entity_id", "type")
+       DO UPDATE SET "weight" = LEAST("${GRAPH_SCHEMA}"."relationships"."weight" + 0.1, 2.0),
+         "confidence" = GREATEST("${GRAPH_SCHEMA}"."relationships"."confidence", EXCLUDED."confidence"),
+         "timestamp" = GREATEST("${GRAPH_SCHEMA}"."relationships"."timestamp", EXCLUDED."timestamp"),
+         "properties" = "${GRAPH_SCHEMA}"."relationships"."properties" || EXCLUDED."properties"`,
+      relId,
+      sourceId,
+      targetId,
+      relationship.type,
+      relationship.confidence,
+      timestamp,
+      JSON.stringify(relationship.properties ?? {})
+    );
+    relationships++;
+  }
+  return { entities, relationships };
+}
+async function ensurePostgresOntologySchema(prisma) {
+  if (ontologySchemaReady) return;
+  await prisma.$executeRawUnsafe(`
+    CREATE TABLE IF NOT EXISTS "${GRAPH_SCHEMA}"."agent_sessions" (
+      "id" text PRIMARY KEY,
+      "agent_id" text NOT NULL,
+      "project_name" text,
+      "started_at" timestamp(3) NOT NULL,
+      "last_event_at" timestamp(3) NOT NULL,
+      "event_count" integer NOT NULL DEFAULT 0,
+      "properties" jsonb NOT NULL DEFAULT '{}'::jsonb
+    )`);
+  await prisma.$executeRawUnsafe(`CREATE INDEX IF NOT EXISTS "idx_agent_sessions_agent_time" ON "${GRAPH_SCHEMA}"."agent_sessions" ("agent_id", "started_at")`);
+  await prisma.$executeRawUnsafe(`
+    CREATE TABLE IF NOT EXISTS "${GRAPH_SCHEMA}"."agent_goals" (
+      "id" text PRIMARY KEY,
+      "statement" text NOT NULL,
+      "owner_agent_id" text,
+      "project_name" text,
+      "status" text NOT NULL DEFAULT 'open',
+      "priority" integer NOT NULL DEFAULT 5,
+      "success_criteria" text,
+      "parent_goal_id" text,
+      "due_at" timestamp(3),
+      "achieved_at" timestamp(3),
+      "supersedes_id" text,
+      "created_at" timestamp(3) NOT NULL,
+      "updated_at" timestamp(3) NOT NULL,
+      "source_memory_id" text
+    )`);
+  await prisma.$executeRawUnsafe(`CREATE INDEX IF NOT EXISTS "idx_agent_goals_project_status" ON "${GRAPH_SCHEMA}"."agent_goals" ("project_name", "status", "priority")`);
+  await prisma.$executeRawUnsafe(`
+    CREATE TABLE IF NOT EXISTS "${GRAPH_SCHEMA}"."agent_events" (
+      "id" text PRIMARY KEY,
+      "event_type" text NOT NULL,
+      "occurred_at" timestamp(3) NOT NULL,
+      "sequence_index" integer NOT NULL,
+      "actor_agent_id" text,
+      "agent_role" text,
+      "project_name" text,
+      "session_id" text,
+      "task_id" text,
+      "goal_id" text,
+      "parent_event_id" text,
+      "intention" text,
+      "outcome" text,
+      "evidence_memory_id" text,
+      "impact" text,
+      "payload" jsonb NOT NULL DEFAULT '{}'::jsonb,
+      "created_at" timestamp(3) NOT NULL
+    )`);
+  await prisma.$executeRawUnsafe(`CREATE INDEX IF NOT EXISTS "idx_agent_events_time" ON "${GRAPH_SCHEMA}"."agent_events" ("occurred_at", "sequence_index")`);
+  await prisma.$executeRawUnsafe(`CREATE INDEX IF NOT EXISTS "idx_agent_events_session_seq" ON "${GRAPH_SCHEMA}"."agent_events" ("session_id", "sequence_index")`);
+  await prisma.$executeRawUnsafe(`CREATE INDEX IF NOT EXISTS "idx_agent_events_goal_time" ON "${GRAPH_SCHEMA}"."agent_events" ("goal_id", "occurred_at")`);
+  await prisma.$executeRawUnsafe(`CREATE INDEX IF NOT EXISTS "idx_agent_events_memory" ON "${GRAPH_SCHEMA}"."agent_events" ("evidence_memory_id")`);
+  await prisma.$executeRawUnsafe(`
+    CREATE TABLE IF NOT EXISTS "${GRAPH_SCHEMA}"."agent_goal_links" (
+      "id" text PRIMARY KEY,
+      "goal_id" text NOT NULL,
+      "link_type" text NOT NULL,
+      "target_id" text NOT NULL,
+      "target_type" text NOT NULL,
+      "created_at" timestamp(3) NOT NULL
+    )`);
+  await prisma.$executeRawUnsafe(`CREATE INDEX IF NOT EXISTS "idx_agent_goal_links_goal" ON "${GRAPH_SCHEMA}"."agent_goal_links" ("goal_id", "target_type")`);
+  await prisma.$executeRawUnsafe(`
+    CREATE TABLE IF NOT EXISTS "${GRAPH_SCHEMA}"."agent_semantic_labels" (
+      "id" text PRIMARY KEY,
+      "source_memory_id" text NOT NULL,
+      "event_id" text,
+      "labeler" text NOT NULL,
+      "schema_version" integer NOT NULL DEFAULT 1,
+      "confidence" double precision NOT NULL DEFAULT 0,
+      "labels" jsonb NOT NULL,
+      "created_at" timestamp(3) NOT NULL,
+      "updated_at" timestamp(3) NOT NULL
+    )`);
+  await prisma.$executeRawUnsafe(`CREATE INDEX IF NOT EXISTS "idx_agent_semantic_labels_memory" ON "${GRAPH_SCHEMA}"."agent_semantic_labels" ("source_memory_id", "labeler")`);
+  await prisma.$executeRawUnsafe(`CREATE INDEX IF NOT EXISTS "idx_agent_semantic_labels_event" ON "${GRAPH_SCHEMA}"."agent_semantic_labels" ("event_id")`);
+  await prisma.$executeRawUnsafe(`
+    CREATE TABLE IF NOT EXISTS "${GRAPH_SCHEMA}"."agent_reflection_checkpoints" (
+      "id" text PRIMARY KEY,
+      "project_name" text,
+      "session_id" text,
+      "window_start_at" timestamp(3) NOT NULL,
+      "window_end_at" timestamp(3) NOT NULL,
+      "event_count" integer NOT NULL DEFAULT 0,
+      "goal_count" integer NOT NULL DEFAULT 0,
+      "success_count" integer NOT NULL DEFAULT 0,
+      "failure_count" integer NOT NULL DEFAULT 0,
+      "risk_count" integer NOT NULL DEFAULT 0,
+      "summary" text NOT NULL,
+      "learnings" jsonb NOT NULL DEFAULT '[]'::jsonb,
+      "next_actions" jsonb NOT NULL DEFAULT '[]'::jsonb,
+      "evidence_event_ids" jsonb NOT NULL DEFAULT '[]'::jsonb,
+      "confidence" double precision NOT NULL DEFAULT 0,
+      "created_at" timestamp(3) NOT NULL
+    )`);
+  await prisma.$executeRawUnsafe(`CREATE INDEX IF NOT EXISTS "idx_agent_reflection_project_time" ON "${GRAPH_SCHEMA}"."agent_reflection_checkpoints" ("project_name", "window_end_at")`);
+  await prisma.$executeRawUnsafe(`CREATE INDEX IF NOT EXISTS "idx_agent_reflection_session_time" ON "${GRAPH_SCHEMA}"."agent_reflection_checkpoints" ("session_id", "window_end_at")`);
+  ontologySchemaReady = true;
+}
+async function ensureFilteredSchema(prisma) {
+  if (filteredSchemaReady) return;
+  await prisma.$executeRawUnsafe(`CREATE SCHEMA IF NOT EXISTS filtered`);
+  await prisma.$executeRawUnsafe(`
+    CREATE TABLE IF NOT EXISTS "filtered"."documents" (
+      "id" UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+      "title" TEXT NOT NULL,
+      "content" TEXT NOT NULL,
+      "doc_type" TEXT NOT NULL DEFAULT 'memory',
+      "source" TEXT NOT NULL DEFAULT 'exe-os',
+      "source_id" TEXT,
+      "metadata" JSONB DEFAULT '{}',
+      "created_at" TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+      UNIQUE("source", "source_id")
+    )`);
+  await prisma.$executeRawUnsafe(`
+    CREATE TABLE IF NOT EXISTS "filtered"."contacts" (
+      "id" UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+      "name" TEXT,
+      "phone" TEXT,
+      "email" TEXT,
+      "platform" TEXT NOT NULL DEFAULT 'whatsapp',
+      "platform_id" TEXT,
+      "metadata" JSONB DEFAULT '{}',
+      "first_seen" TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+      "last_seen" TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+      UNIQUE("platform", "platform_id")
+    )`);
+  await prisma.$executeRawUnsafe(`
+    CREATE TABLE IF NOT EXISTS "filtered"."conversations" (
+      "id" UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+      "contact_id" UUID REFERENCES "filtered"."contacts"("id"),
+      "platform" TEXT NOT NULL DEFAULT 'whatsapp',
+      "thread_id" TEXT,
+      "direction" TEXT NOT NULL DEFAULT 'inbound',
+      "content" TEXT NOT NULL,
+      "message_type" TEXT NOT NULL DEFAULT 'text',
+      "metadata" JSONB DEFAULT '{}',
+      "sent_at" TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+      "source_ref" TEXT
+    )`);
+  await selfHealFilteredSchema(prisma);
+  filteredSchemaReady = true;
+}
+async function selfHealFilteredSchema(prisma) {
+  const stmts = [
+    // --- filtered.contacts: ensure new-generation columns ---
+    `ALTER TABLE "filtered"."contacts" ADD COLUMN IF NOT EXISTS "name" TEXT`,
+    `ALTER TABLE "filtered"."contacts" ADD COLUMN IF NOT EXISTS "platform" TEXT DEFAULT 'whatsapp'`,
+    `ALTER TABLE "filtered"."contacts" ADD COLUMN IF NOT EXISTS "platform_id" TEXT`,
+    `ALTER TABLE "filtered"."contacts" ADD COLUMN IF NOT EXISTS "first_seen" TIMESTAMPTZ DEFAULT NOW()`,
+    `ALTER TABLE "filtered"."contacts" ADD COLUMN IF NOT EXISTS "last_seen" TIMESTAMPTZ DEFAULT NOW()`,
+    // Legacy NOT NULL columns the new worker never writes — relax if present.
+    `DO $$ BEGIN
+       IF EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema='filtered' AND table_name='contacts' AND column_name='display_name' AND is_nullable='NO') THEN
+         ALTER TABLE "filtered"."contacts" ALTER COLUMN "display_name" DROP NOT NULL;
+       END IF;
+     END $$`,
+    // Backfill new columns from legacy ones where possible, then enforce upsert key.
+    `DO $$ BEGIN
+       IF EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema='filtered' AND table_name='contacts' AND column_name='display_name') THEN
+         UPDATE "filtered"."contacts" SET
+           "name" = COALESCE("name", "display_name"),
+           "platform" = COALESCE("platform", "source", 'whatsapp'),
+           "platform_id" = COALESCE("platform_id", "source_id", "phone"),
+           "first_seen" = COALESCE("first_seen", "first_seen_at", NOW()),
+           "last_seen" = COALESCE("last_seen", "last_seen_at", NOW())
+         WHERE "platform" IS NULL OR "platform_id" IS NULL;
+       END IF;
+     END $$`,
+    `CREATE UNIQUE INDEX IF NOT EXISTS "contacts_platform_platform_id_uq" ON "filtered"."contacts"("platform", "platform_id")`,
+    // --- filtered.conversations: ensure new-generation columns ---
+    `ALTER TABLE "filtered"."conversations" ADD COLUMN IF NOT EXISTS "thread_id" TEXT`,
+    `ALTER TABLE "filtered"."conversations" ADD COLUMN IF NOT EXISTS "message_type" TEXT DEFAULT 'text'`,
+    `ALTER TABLE "filtered"."conversations" ADD COLUMN IF NOT EXISTS "sent_at" TIMESTAMPTZ DEFAULT NOW()`,
+    `ALTER TABLE "filtered"."conversations" ADD COLUMN IF NOT EXISTS "source_ref" TEXT`,
+    `DO $$ BEGIN
+       IF EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema='filtered' AND table_name='conversations' AND column_name='timestamp' AND is_nullable='NO') THEN
+         ALTER TABLE "filtered"."conversations" ALTER COLUMN "timestamp" DROP NOT NULL;
+       END IF;
+     END $$`,
+    `DO $$ BEGIN
+       IF EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema='filtered' AND table_name='conversations' AND column_name='remote_jid') THEN
+         UPDATE "filtered"."conversations" SET
+           "thread_id" = COALESCE("thread_id", "remote_jid"),
+           "sent_at" = COALESCE("sent_at", "timestamp", NOW())
+         WHERE "thread_id" IS NULL OR "sent_at" IS NULL;
+       END IF;
+     END $$`,
+    // Retire the weak same-second dedup key; keep a plain index for queries.
+    `ALTER TABLE "filtered"."conversations" DROP CONSTRAINT IF EXISTS "conversations_platform_thread_id_sent_at_key"`,
+    `DROP INDEX IF EXISTS "filtered"."conversations_platform_thread_sent_uq"`,
+    `CREATE INDEX IF NOT EXISTS "conversations_platform_thread_sent_idx" ON "filtered"."conversations"("platform", "thread_id", "sent_at")`,
+    `CREATE UNIQUE INDEX IF NOT EXISTS "conversations_platform_source_ref_uq" ON "filtered"."conversations"("platform", "source_ref")`,
+    // --- raw.raw_events: retry-model columns required by the poll loop ---
+    `ALTER TABLE "raw"."raw_events" ADD COLUMN IF NOT EXISTS "retry_count" INTEGER NOT NULL DEFAULT 0`,
+    `ALTER TABLE "raw"."raw_events" ADD COLUMN IF NOT EXISTS "failed_at" TIMESTAMPTZ`,
+    `ALTER TABLE "raw"."raw_events" ADD COLUMN IF NOT EXISTS "error" TEXT`,
+    `ALTER TABLE "raw"."raw_events" ADD COLUMN IF NOT EXISTS "projections" JSONB`
+  ];
+  for (const stmt of stmts) {
+    try {
+      await prisma.$executeRawUnsafe(stmt);
+    } catch (err) {
+      console.error(
+        `[projection-worker] schema self-heal statement failed (continuing): ${err instanceof Error ? err.message.split("\n")[0] : String(err)}`
+      );
+    }
+  }
+}
+async function projectAgenticOntology(prisma, payload, memoryId, timestamp) {
+  await ensurePostgresOntologySchema(prisma);
+  const row = {
+    id: memoryId,
+    agent_id: String(payload.agent_id ?? "system"),
+    agent_role: String(payload.agent_role ?? "ingest"),
+    session_id: String(payload.session_id ?? "projection-worker"),
+    timestamp: timestamp.toISOString(),
+    tool_name: String(payload.tool_name ?? "cloud_sync"),
+    project_name: String(payload.project_name ?? "exe-os"),
+    has_error: payload.has_error ? 1 : 0,
+    raw_text: String(payload.raw_text ?? JSON.stringify(payload)),
+    version: typeof payload.version === "number" ? payload.version : Number(payload.version ?? 0),
+    task_id: typeof payload.task_id === "string" ? payload.task_id : null,
+    intent: typeof payload.intent === "string" ? payload.intent : null,
+    outcome: typeof payload.outcome === "string" ? payload.outcome : null,
+    domain: typeof payload.domain === "string" ? payload.domain : null,
+    trajectory: typeof payload.trajectory === "string" ? payload.trajectory : null
+  };
+  const eventId = stableId(`event:${memoryId}`);
+  const sequence = Number(row.version ?? 0) || Math.floor(timestamp.getTime() / 1e3);
+  const intention = inferIntention(row);
+  const outcome = inferOutcome(row);
+  const now = /* @__PURE__ */ new Date();
+  await prisma.$executeRawUnsafe(
+    `INSERT INTO "${GRAPH_SCHEMA}"."agent_sessions" ("id", "agent_id", "project_name", "started_at", "last_event_at", "event_count", "properties")
+     VALUES ($1, $2, $3, $4, $4, 1, $5::jsonb)
+     ON CONFLICT ("id") DO UPDATE SET "last_event_at" = GREATEST("${GRAPH_SCHEMA}"."agent_sessions"."last_event_at", EXCLUDED."last_event_at"),
+       "event_count" = "${GRAPH_SCHEMA}"."agent_sessions"."event_count" + 1`,
+    row.session_id,
+    row.agent_id,
+    row.project_name,
+    timestamp,
+    JSON.stringify({ agent_role: row.agent_role })
+  );
+  await prisma.$executeRawUnsafe(
+    `INSERT INTO "${GRAPH_SCHEMA}"."agent_events"
+      ("id", "event_type", "occurred_at", "sequence_index", "actor_agent_id", "agent_role", "project_name",
+       "session_id", "task_id", "goal_id", "parent_event_id", "intention", "outcome", "evidence_memory_id",
+       "impact", "payload", "created_at")
+     VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, NULL, NULL, $10, $11, $12, $13, $14::jsonb, $15)
+     ON CONFLICT ("id") DO NOTHING`,
+    eventId,
+    inferOntologyEventType(row),
+    timestamp,
+    sequence,
+    row.agent_id,
+    row.agent_role,
+    row.project_name,
+    row.session_id,
+    row.task_id ?? null,
+    intention,
+    outcome,
+    row.id,
+    row.has_error ? "negative" : outcome === "success_signal" ? "positive" : "neutral",
+    JSON.stringify(ontologyPayload(row)),
+    now
+  );
+  const semantic = inferSemanticLabel(row);
+  await prisma.$executeRawUnsafe(
+    `INSERT INTO "${GRAPH_SCHEMA}"."agent_semantic_labels"
+      ("id", "source_memory_id", "event_id", "labeler", "schema_version", "confidence", "labels", "created_at", "updated_at")
+     VALUES ($1, $2, $3, $4, $5, $6, $7::jsonb, $8, $8)
+     ON CONFLICT ("id") DO UPDATE SET "confidence" = EXCLUDED."confidence",
+       "labels" = EXCLUDED."labels", "updated_at" = EXCLUDED."updated_at"`,
+    stableId(`semantic:${row.id}:${semantic.labeler}:${semantic.schemaVersion}`),
+    row.id,
+    eventId,
+    semantic.labeler,
+    semantic.schemaVersion,
+    semantic.confidence,
+    JSON.stringify(semantic),
+    now
+  );
+  let goals = 0;
+  for (const statement of extractGoalCandidates(row)) {
+    const goalId = stableId(`goal:${row.project_name}:${statement.toLowerCase()}`);
+    await prisma.$executeRawUnsafe(
+      `INSERT INTO "${GRAPH_SCHEMA}"."agent_goals"
+        ("id", "statement", "owner_agent_id", "project_name", "status", "priority", "created_at", "updated_at", "source_memory_id")
+       VALUES ($1, $2, $3, $4, 'open', 5, $5, $5, $6)
+       ON CONFLICT ("id") DO UPDATE SET "updated_at" = EXCLUDED."updated_at"`,
+      goalId,
+      statement,
+      row.agent_id,
+      row.project_name,
+      now,
+      row.id
+    );
+    await prisma.$executeRawUnsafe(
+      `INSERT INTO "${GRAPH_SCHEMA}"."agent_goal_links" ("id", "goal_id", "link_type", "target_id", "target_type", "created_at")
+       VALUES ($1, $2, 'evidence', $3, 'memory', $4)
+       ON CONFLICT ("id") DO NOTHING`,
+      stableId(`goal_link:${goalId}:${row.id}:memory`),
+      goalId,
+      row.id,
+      now
+    );
+    await prisma.$executeRawUnsafe(
+      `INSERT INTO "${GRAPH_SCHEMA}"."agent_goal_links" ("id", "goal_id", "link_type", "target_id", "target_type", "created_at")
+       VALUES ($1, $2, 'event', $3, 'event', $4)
+       ON CONFLICT ("id") DO NOTHING`,
+      stableId(`goal_link:${goalId}:${eventId}:event`),
+      goalId,
+      eventId,
+      now
+    );
+    goals++;
+  }
+  return { events: 1, goals };
+}
+var WIKI_PROJECTABLE_TOOLS = /* @__PURE__ */ new Set(["manual", "auto-decision", "SessionEnd", "AssistantResponse"]);
+var WIKI_MIN_TEXT_LENGTH = 100;
+async function ensureWikiWorkspace(prisma, projectName) {
+  const slug = projectName.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-");
+  const existing = await prisma.$queryRawUnsafe(
+    `SELECT "id" FROM "wiki"."workspaces" WHERE "slug" = $1`,
+    slug
+  );
+  if (existing.length > 0) return existing[0].id;
+  const inserted = await prisma.$queryRawUnsafe(
+    `INSERT INTO "wiki"."workspaces" ("name", "slug", "chat_mode", "updated_at")
+     VALUES ($1, $2, 'chat', NOW())
+     ON CONFLICT ("slug") DO UPDATE SET "name" = EXCLUDED."name"
+     RETURNING "id"`,
+    projectName,
+    slug
+  );
+  return inserted[0].id;
+}
+function isWikiWorthy(payload) {
+  const toolName = String(payload.tool_name ?? "");
+  const rawText = String(payload.raw_text ?? "");
+  const importance = typeof payload.importance === "number" ? payload.importance : 5;
+  const memoryType = String(payload.memory_type ?? "raw");
+  if (memoryType === "decision" || memoryType === "procedure") return true;
+  if (WIKI_PROJECTABLE_TOOLS.has(toolName)) return true;
+  if (importance >= 7 && rawText.length >= WIKI_MIN_TEXT_LENGTH) return true;
+  return false;
+}
+async function projectToWiki(prisma, payload, timestamp) {
+  if (!isWikiWorthy(payload)) return { documents: 0 };
+  const rawText = String(payload.raw_text ?? "");
+  if (rawText.length < WIKI_MIN_TEXT_LENGTH) return { documents: 0 };
+  const projectName = String(payload.project_name ?? "exe-os");
+  const agentId = String(payload.agent_id ?? "system");
+  const toolName = String(payload.tool_name ?? "unknown");
+  const memoryId = String(payload.id ?? "");
+  const docId = memoryId || stableId(rawText.slice(0, 512));
+  const firstLine = rawText.split("\n")[0]?.slice(0, 120)?.replace(/[^a-zA-Z0-9 _-]/g, "") || "untitled";
+  const filename = `${agentId}-${firstLine.slice(0, 80).trim().replace(/\s+/g, "-").toLowerCase()}.md`;
+  const docpath = `${projectName}/${filename}`;
+  const workspaceId = await ensureWikiWorkspace(prisma, projectName);
+  await prisma.$executeRawUnsafe(
+    `INSERT INTO "wiki"."workspace_documents" ("doc_id", "filename", "docpath", "workspace_id", "metadata", "pinned")
+     VALUES ($1, $2, $3, $4, $5, false)
+     ON CONFLICT ("doc_id") DO UPDATE SET
+       "filename" = EXCLUDED."filename",
+       "metadata" = EXCLUDED."metadata"`,
+    docId,
+    filename,
+    docpath,
+    workspaceId,
+    JSON.stringify({
+      agent_id: agentId,
+      tool_name: toolName,
+      memory_type: payload.memory_type ?? "raw",
+      importance: payload.importance ?? 5,
+      timestamp: timestamp.toISOString(),
+      content_preview: rawText.slice(0, 500)
+    })
+  );
+  return { documents: 1 };
+}
+var lastWikiApiPushAt = 0;
+var WIKI_API_MIN_INTERVAL_MS = 500;
+async function pushToWikiApi(payload, _timestamp) {
+  const now = Date.now();
+  if (now - lastWikiApiPushAt < WIKI_API_MIN_INTERVAL_MS) {
+    return false;
+  }
+  try {
+    const { createWikiClient, uploadDocumentToWiki } = await import("./wiki-client-Q4O6EMTP.js");
+    const client = await createWikiClient();
+    if (!client) return false;
+    const rawText = String(payload.raw_text ?? "");
+    const projectName = String(payload.project_name ?? "exe-os");
+    const agentId = String(payload.agent_id ?? "system");
+    const firstLine = rawText.split("\n")[0]?.slice(0, 120) ?? "Untitled";
+    const title = `[${agentId}] ${firstLine}`;
+    const slug = projectName.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-");
+    const result = await uploadDocumentToWiki(client, slug, title, rawText);
+    lastWikiApiPushAt = Date.now();
+    if (!result.success) {
+      process.stderr.write(`[projection-worker] Wiki API push failed: ${result.error}
+`);
+    }
+    return result.success;
+  } catch (err) {
+    process.stderr.write(`[projection-worker] Wiki API push error: ${err instanceof Error ? err.message : String(err)}
+`);
+    return false;
+  }
+}
+function resetLastWikiApiPushAtForTests() {
+  lastWikiApiPushAt = 0;
+}
+var projectionHandlers = {
+  async whatsapp(event, prisma) {
+    const targets = [];
+    const payload = event.payload;
+    await prisma.$executeRawUnsafe(
+      `INSERT INTO "${GRAPH_SCHEMA}"."memory_records" ("id", "agent_id", "agent_role", "session_id", "tool_name", "project_name", "raw_text", "memory_type", "source_type", "intent")
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
+       ON CONFLICT ("id") DO NOTHING`,
+      crypto.randomUUID(),
+      "system",
+      "ingest",
+      "projection-worker",
+      "projection_worker",
+      "exe-os",
+      JSON.stringify(payload),
+      "raw",
+      "whatsapp",
+      event.event_type
+    );
+    targets.push("graph");
+    await ensureFilteredSchema(prisma);
+    const senderName = payload.sender_name ?? payload.contact_name ?? null;
+    const rawSender = payload.from ?? payload.phone ?? null;
+    const threadId = payload.conversation_id ?? payload.chat_id ?? event.source_id;
+    if (rawSender) {
+      const bareSender = rawSender.replace(/@.*$/, "");
+      const phone = !rawSender.endsWith("@lid") && /^\+?\d{6,20}$/.test(bareSender) ? bareSender : null;
+      const name = senderName ?? phone ?? "Unknown (WhatsApp)";
+      const contactResult = await prisma.$queryRawUnsafe(
+        `INSERT INTO "filtered"."contacts" ("name", "phone", "platform", "platform_id", "last_seen")
+         VALUES ($1, $2, 'whatsapp', $3, $4)
+         ON CONFLICT ("platform", "platform_id") DO UPDATE SET
+           "name" = CASE
+             WHEN EXCLUDED."name" IS NOT NULL AND EXCLUDED."name" <> 'Unknown (WhatsApp)' THEN EXCLUDED."name"
+             WHEN "filtered"."contacts"."name" ~ '@(lid|s\\.whatsapp\\.net)$' THEN EXCLUDED."name"
+             ELSE "filtered"."contacts"."name"
+           END,
+           "phone" = COALESCE(EXCLUDED."phone", "filtered"."contacts"."phone"),
+           "last_seen" = GREATEST("filtered"."contacts"."last_seen", EXCLUDED."last_seen")
+         RETURNING "id"`,
+        name,
+        phone,
+        rawSender,
+        event.timestamp
+      );
+      const contactId = contactResult[0]?.id;
+      targets.push("filtered.contacts");
+      const messageContent = payload.message ?? payload.text ?? payload.body ?? JSON.stringify(payload);
+      const direction = payload.direction ?? "inbound";
+      if (contactId && messageContent) {
+        const sourceRef = event.source_id ?? event.id;
+        await prisma.$executeRawUnsafe(
+          `INSERT INTO "filtered"."conversations" ("contact_id", "platform", "thread_id", "direction", "content", "message_type", "sent_at", "source_ref")
+           VALUES ($1::uuid, 'whatsapp', $2, $3, $4, $5, $6, $7)
+           ON CONFLICT ("platform", "source_ref") DO NOTHING`,
+          contactId,
+          threadId,
+          direction,
+          typeof messageContent === "string" ? messageContent : JSON.stringify(messageContent),
+          payload.type ?? "text",
+          event.timestamp,
+          String(sourceRef)
+        );
+        targets.push("filtered.conversations");
+      }
+    }
+    return { targets };
+  },
+  async shopify(event, prisma) {
+    const targets = [];
+    const payload = event.payload;
+    await prisma.$executeRawUnsafe(
+      `INSERT INTO "${GRAPH_SCHEMA}"."memory_records" ("id", "agent_id", "agent_role", "session_id", "tool_name", "project_name", "raw_text", "memory_type", "source_type", "intent")
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
+       ON CONFLICT ("id") DO NOTHING`,
+      crypto.randomUUID(),
+      "system",
+      "ingest",
+      "projection-worker",
+      "projection_worker",
+      "exe-os",
+      JSON.stringify(payload),
+      "raw",
+      "shopify",
+      event.event_type
+    );
+    targets.push("graph");
+    return { targets };
+  },
+  async cloud_sync(event, prisma) {
+    const targets = [];
+    const payload = event.payload;
+    const memoryId = payload.id ?? crypto.randomUUID();
+    await prisma.$executeRawUnsafe(
+      `INSERT INTO "${GRAPH_SCHEMA}"."memory_records" ("id", "agent_id", "agent_role", "session_id", "tool_name", "project_name", "raw_text", "memory_type", "source_type", "intent", "domain")
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
+       ON CONFLICT ("id") DO NOTHING`,
+      memoryId,
+      payload.agent_id ?? "system",
+      payload.agent_role ?? "ingest",
+      payload.session_id ?? "projection-worker",
+      payload.tool_name ?? "cloud_sync",
+      payload.project_name ?? "exe-os",
+      payload.raw_text ?? JSON.stringify(payload),
+      payload.memory_type ?? "raw",
+      "cloud_sync",
+      event.event_type,
+      payload.domain ?? null
+    );
+    targets.push("memory");
+    const graph = await projectMemoryGraph(prisma, payload, memoryId, event.timestamp);
+    if (graph.entities > 0 || graph.relationships > 0) targets.push("graph");
+    const ontology = await projectAgenticOntology(prisma, payload, memoryId, event.timestamp);
+    if (ontology.events > 0) targets.push("ontology");
+    const wiki = await projectToWiki(prisma, payload, event.timestamp);
+    if (wiki.documents > 0) {
+      targets.push("wiki");
+      await pushToWikiApi(payload, event.timestamp);
+    }
+    await ensureFilteredSchema(prisma);
+    const rawText = payload.raw_text ?? "";
+    if (rawText.length > 50) {
+      await prisma.$executeRawUnsafe(
+        `INSERT INTO "filtered"."documents" ("title", "content", "doc_type", "source", "source_id", "metadata", "created_at")
+         VALUES ($1, $2, $3, $4, $5, $6::jsonb, $7)
+         ON CONFLICT ("source", "source_id") DO NOTHING`,
+        rawText.slice(0, 80),
+        rawText,
+        payload.tool_name ?? "memory",
+        "exe-os",
+        memoryId,
+        JSON.stringify({
+          agent_id: payload.agent_id,
+          project_name: payload.project_name
+        }),
+        event.timestamp
+      );
+      targets.push("filtered.documents");
+    }
+    return { targets };
+  },
+  async external_agent(event, prisma) {
+    const targets = [];
+    const payload = event.payload;
+    await prisma.$executeRawUnsafe(
+      `INSERT INTO "${GRAPH_SCHEMA}"."memory_records" ("id", "agent_id", "agent_role", "session_id", "tool_name", "project_name", "raw_text", "memory_type", "source_type", "intent", "domain")
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
+       ON CONFLICT ("id") DO NOTHING`,
+      crypto.randomUUID(),
+      "system",
+      "ingest",
+      "projection-worker",
+      "projection_worker",
+      "exe-os",
+      JSON.stringify(payload),
+      "raw",
+      "external_agent",
+      event.event_type,
+      payload.domain ?? null
+    );
+    targets.push("graph");
+    return { targets };
+  },
+  async erp(event, prisma) {
+    const targets = [];
+    const payload = event.payload;
+    await prisma.$executeRawUnsafe(
+      `INSERT INTO "${GRAPH_SCHEMA}"."memory_records" ("id", "agent_id", "agent_role", "session_id", "tool_name", "project_name", "raw_text", "memory_type", "source_type", "intent", "domain")
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
+       ON CONFLICT ("id") DO NOTHING`,
+      crypto.randomUUID(),
+      "system",
+      "ingest",
+      "projection-worker",
+      "projection_worker",
+      payload.project_name ?? "exe-erp",
+      JSON.stringify(payload),
+      "raw",
+      "erp",
+      event.event_type,
+      payload.domain ?? "business"
+    );
+    targets.push("graph");
+    await ensureFilteredSchema(prisma);
+    const rawText = typeof payload.description === "string" ? payload.description : JSON.stringify(payload);
+    if (rawText.length > 50) {
+      await prisma.$executeRawUnsafe(
+        `INSERT INTO "filtered"."documents" ("title", "content", "doc_type", "source", "source_id", "metadata", "created_at")
+         VALUES ($1, $2, $3, $4, $5, $6::jsonb, $7)
+         ON CONFLICT ("source", "source_id") DO NOTHING`,
+        rawText.length > 80 ? rawText.slice(0, 77) + "..." : rawText,
+        rawText,
+        event.event_type,
+        "erp",
+        event.source_id ?? event.id,
+        JSON.stringify({
+          erp_doctype: payload.doctype,
+          erp_name: payload.name,
+          event_type: event.event_type
+        }),
+        event.timestamp
+      );
+      targets.push("filtered.documents");
+    }
+    const erpPayload = payload;
+    const doctype = String(erpPayload.doctype ?? erpPayload.docType ?? erpPayload.object_type ?? "Unknown");
+    const normalizedObjectType = doctype.charAt(0).toUpperCase() + doctype.slice(1);
+    const triggerEvent = {
+      eventType: event.event_type.replace(/^.*\./, ""),
+      // "sales_order.created" -> "created"
+      objectType: normalizedObjectType,
+      record: erpPayload
+    };
+    try {
+      const logs = await processCRMEvent(triggerEvent);
+      if (logs.length > 0) {
+        targets.push("triggers");
+        process.stderr.write(
+          `[projection-worker] ERP event ${normalizedObjectType}.${triggerEvent.eventType} fired ${logs.length} trigger(s)
+`
+        );
+      }
+    } catch (err) {
+      process.stderr.write(
+        `[projection-worker] ERP trigger evaluation failed: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+    return { targets };
+  }
+};
+var projectionHandlersForTests = projectionHandlers;
+var defaultHandler = async (event, prisma) => {
+  await prisma.$executeRawUnsafe(
+    `INSERT INTO "${GRAPH_SCHEMA}"."memory_records" ("id", "agent_id", "agent_role", "session_id", "tool_name", "project_name", "raw_text", "memory_type", "source_type", "intent")
+     VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
+     ON CONFLICT ("id") DO NOTHING`,
+    crypto.randomUUID(),
+    "system",
+    "ingest",
+    "projection-worker",
+    "projection_worker",
+    "exe-os",
+    JSON.stringify(event.payload),
+    "raw",
+    event.source,
+    event.event_type
+  );
+  return { targets: ["memory"] };
+};
+var BATCH_SIZE = 50;
+var POLL_INTERVAL_MS = 1e4;
+var MAX_POLL_BACKOFF_MS = 5 * 6e4;
+var MAX_PROJECTION_RETRIES = 5;
+function isTruthyEnv(value) {
+  return /^(1|true|yes|on)$/i.test(value ?? "");
+}
+var running = false;
+var pollTimer = null;
+var consecutivePollErrors = 0;
+async function processBatch() {
+  const prisma = await loadPrisma();
+  await ensureFilteredSchema(prisma);
+  const events = await prisma.$queryRawUnsafe(
+    `SELECT "id", "source", "source_id", "event_type", "payload", "metadata", "timestamp"
+     FROM "raw"."raw_events"
+     WHERE "processed_at" IS NULL
+       AND ("failed_at" IS NULL OR (
+         "retry_count" < $2
+         AND "failed_at" < NOW() - make_interval(secs => POWER(2, LEAST("retry_count", 8))::int)
+       ))
+     ORDER BY "timestamp" ASC
+     LIMIT $1`,
+    BATCH_SIZE,
+    MAX_PROJECTION_RETRIES
+  );
+  if (events.length === 0) return 0;
+  let processed = 0;
+  for (const event of events) {
+    try {
+      const handler = projectionHandlers[event.source] ?? defaultHandler;
+      const result = await handler(event, prisma);
+      await prisma.$executeRawUnsafe(
+        `UPDATE "raw"."raw_events"
+         SET "processed_at" = NOW(), "projections" = $1::jsonb
+         WHERE "id" = $2`,
+        JSON.stringify({ targets: [...new Set(result.targets)], skipped: result.skipped }),
+        event.id
+      );
+      processed++;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(
+        `[projection-worker] Error processing event ${event.id}: ${message}
+`
+      );
+      await prisma.$executeRawUnsafe(
+        `UPDATE "raw"."raw_events"
+         SET "failed_at" = NOW(),
+             "retry_count" = COALESCE("retry_count", 0) + 1,
+             "error" = $1,
+             "projections" = $2::jsonb
+         WHERE "id" = $3`,
+        message,
+        JSON.stringify({ error: message }),
+        event.id
+      );
+    }
+  }
+  return processed;
+}
+async function shouldStartProjectionWorker() {
+  try {
+    const config = await loadConfig();
+    const envEnabled = isTruthyEnv(process.env.EXE_CLOUD_SYNC_TO_POSTGRES);
+    if (!envEnabled && config.cloud?.syncToPostgres !== true) {
+      return { start: false, reason: "cloud.syncToPostgres is not enabled" };
+    }
+  } catch (err) {
+    return { start: false, reason: `config unavailable: ${err instanceof Error ? err.message : String(err)}` };
+  }
+  if (!process.env.DATABASE_URL) {
+    return { start: false, reason: "DATABASE_URL is not set" };
+  }
+  const exeDbRoot = process.env.EXE_DB_ROOT ?? path.join(os.homedir(), "exe-db");
+  if (!existsSync(path.join(exeDbRoot, "package.json")) && !process.env.EXE_OS_PRISMA_CLIENT_PATH) {
+    try {
+      await import("pg");
+    } catch {
+      return { start: false, reason: "no exe-db Prisma client or pg adapter available" };
+    }
+  }
+  return { start: true };
+}
+function computeProjectionBackoffMs(errorCount) {
+  if (errorCount <= 0) return POLL_INTERVAL_MS;
+  return Math.min(POLL_INTERVAL_MS * 2 ** Math.min(errorCount, 5), MAX_POLL_BACKOFF_MS);
+}
+function startProjectionWorker() {
+  if (running) return;
+  void (async () => {
+    const decision = await shouldStartProjectionWorker();
+    if (!decision.start) {
+      process.stderr.write(`[projection-worker] Skipped \u2014 ${decision.reason}.
+`);
+      return;
+    }
+    running = true;
+    consecutivePollErrors = 0;
+    process.stderr.write("[projection-worker] Starting...\n");
+    if (isTruthyEnv(process.env.EXE_PROJECTION_REQUEUE_ON_START)) {
+      try {
+        await requeueRetryExhausted({
+          source: process.env.EXE_PROJECTION_REQUEUE_SOURCE || void 0,
+          eventType: process.env.EXE_PROJECTION_REQUEUE_EVENT_TYPE || void 0
+        });
+      } catch (err) {
+        process.stderr.write(
+          `[projection-worker] Requeue-on-start failed (continuing): ${err instanceof Error ? err.message : String(err)}
+`
+        );
+      }
+    }
+    const tick = async () => {
+      if (!running) return;
+      let nextDelay = POLL_INTERVAL_MS;
+      try {
+        const count = await processBatch();
+        consecutivePollErrors = 0;
+        if (count > 0) {
+          process.stderr.write(`[projection-worker] Processed ${count} events.
+`);
+        }
+      } catch (err) {
+        consecutivePollErrors++;
+        nextDelay = computeProjectionBackoffMs(consecutivePollErrors);
+        process.stderr.write(
+          `[projection-worker] Poll error (${consecutivePollErrors}; next retry ${Math.round(nextDelay / 1e3)}s): ${err instanceof Error ? err.message : String(err)}
+`
+        );
+      }
+      if (running) {
+        pollTimer = setTimeout(tick, nextDelay);
+      }
+    };
+    void tick();
+  })();
+}
+function stopProjectionWorker() {
+  running = false;
+  if (pollTimer) {
+    clearTimeout(pollTimer);
+    pollTimer = null;
+  }
+  process.stderr.write("[projection-worker] Stopped.\n");
+}
+async function processProjectionBatch() {
+  return processBatch();
+}
+async function requeueRetryExhausted(opts = {}) {
+  const prisma = await loadPrisma();
+  await ensureFilteredSchema(prisma);
+  const conditions = [
+    `"processed_at" IS NULL`,
+    `"retry_count" >= $1`
+  ];
+  const params = [MAX_PROJECTION_RETRIES];
+  if (opts.source) {
+    params.push(opts.source);
+    conditions.push(`"source" = $${params.length}`);
+  }
+  if (opts.eventType) {
+    params.push(opts.eventType);
+    conditions.push(`"event_type" = $${params.length}`);
+  }
+  const result = await prisma.$executeRawUnsafe(
+    `UPDATE "raw"."raw_events"
+        SET "failed_at" = NULL,
+            "retry_count" = 0,
+            "error" = NULL
+      WHERE ${conditions.join(" AND ")}`,
+    ...params
+  );
+  const count = typeof result === "number" ? result : 0;
+  if (count > 0) {
+    const scope = [opts.source && `source=${opts.source}`, opts.eventType && `event_type=${opts.eventType}`].filter(Boolean).join(" ") || "all sources";
+    process.stderr.write(
+      `[projection-worker] Requeued ${count} retry-exhausted event(s) (${scope}).
+`
+    );
+  }
+  return count;
+}
+export {
+  computeProjectionBackoffMs,
+  processProjectionBatch,
+  projectionHandlersForTests,
+  requeueRetryExhausted,
+  resetLastWikiApiPushAtForTests,
+  resetProjectionWorkerForTests,
+  setProjectionWorkerPrismaClientForTests,
+  shouldStartProjectionWorker,
+  startProjectionWorker,
+  stopProjectionWorker
+};