@opengeni/db 4.4.0-canary.0 → 4.4.0-canary.2

package/dist/chunk-45CP2YKY.js

@@ -0,0 +1,1062 @@
+import {
+  LOSSLESS_CONTENT_CODEC_VERSION,
+  fromPostgresLosslessText,
+  toPostgresLosslessJson,
+  toPostgresLosslessText
+} from "./chunk-S2TZ3F4L.js";
+
+// src/migrate.ts
+import { readdir, readFile } from "fs/promises";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import postgres from "postgres";
+
+// src/skill-metadata-migration.ts
+import { readSkillMetadata } from "@opengeni/contracts";
+var SKILL_METADATA_MIGRATION_MARKER = "-- opengeni:skill-metadata-stage-v1";
+function prepareLegacySkillFolder(files, legacy) {
+  const main = files.find((file) => file.path === "SKILL.md");
+  if (!main) throw new Error(`Skill ${legacy.id} requires SKILL.md before migration`);
+  let content = main.content;
+  if (!/^\s*---(?:\r?\n|$)/u.test(content)) {
+    const slug = legacy.title.normalize("NFKD").toLowerCase().replace(/[^a-z0-9]+/gu, "-").replace(/^-|-$/gu, "");
+    const name = slug && slug.length <= 64 ? slug : `legacy-${legacy.id.replaceAll("-", "")}`;
+    content = `---
+name: ${JSON.stringify(name)}
+description: ${JSON.stringify(legacy.description)}
+---
+${content}`;
+  }
+  const metadata = readSkillMetadata(content);
+  return {
+    files: files.map((file) => file.path === "SKILL.md" ? { ...file, content } : file),
+    ...metadata
+  };
+}
+async function createSkillMetadataMigrationStage(tx) {
+  await tx`CREATE TEMP TABLE skill_metadata_0426 (
+    source_kind text NOT NULL, source_id uuid NOT NULL, account_id uuid NOT NULL,
+    workspace_id uuid, files jsonb NOT NULL, name text NOT NULL, description text NOT NULL
+  ) ON COMMIT DROP`;
+}
+async function stageSkillMetadataMigration(tx) {
+  const sources = await tx`
+    SELECT 'installed' AS source_kind,sf.facet_id AS source_id,i.account_id,i.workspace_id,
+      sf.name AS title,sf.description,
+      coalesce(jsonb_agg(jsonb_build_object('path',ff.path,'content',ff.content) ORDER BY ff.path COLLATE "C")
+        FILTER (WHERE ff.id IS NOT NULL),'[]'::jsonb) AS files
+    FROM capability_plugin_installations i JOIN capability_facets f ON f.plugin_version_id=i.plugin_version_id
+    JOIN capability_skill_facets sf ON sf.facet_id=f.id LEFT JOIN capability_skill_files ff ON ff.skill_facet_id=sf.facet_id
+    WHERE i.status='active'
+    GROUP BY i.account_id,i.workspace_id,sf.facet_id
+    UNION ALL
+    SELECT 'authored',h.id,h.account_id,h.scope_workspace_id,r.title,r.description,
+      coalesce(r.skill_files,jsonb_build_array(jsonb_build_object('path','SKILL.md','content',r.content)))
+    FROM preference_registry_preferences h JOIN preference_registry_revisions r
+      ON r.id=h.active_revision_id AND r.preference_id=h.id AND r.account_id=h.account_id
+    WHERE h.status='active'
+  `;
+  for (const source of sources) {
+    let folder;
+    try {
+      folder = prepareLegacySkillFolder(source.files, {
+        id: source.source_id,
+        title: source.title,
+        description: source.description
+      });
+    } catch (cause) {
+      throw new Error(
+        `Skill ${source.source_kind}:${source.source_id} needs explicit frontmatter repair before 0433`,
+        { cause }
+      );
+    }
+    const [valid] = await tx`SELECT skill_files_valid(${tx.json(folder.files)}) AS valid`;
+    if (!valid?.valid)
+      throw new Error(
+        `Skill ${source.source_id} exceeds the valid folder limits after metadata migration`
+      );
+    await tx`INSERT INTO pg_temp.skill_metadata_0426(source_kind,source_id,account_id,workspace_id,files,name,description)
+      VALUES(${source.source_kind},${source.source_id},${source.account_id},${source.workspace_id},${tx.json(folder.files)},${folder.name},${folder.description})`;
+  }
+}
+
+// src/knowledge-migration.ts
+import { createHash } from "crypto";
+import {
+  KnowledgeSourceSyncAction,
+  knowledgeSourceAgentConfig,
+  StoredKnowledgeEntryContent
+} from "@opengeni/contracts";
+var KNOWLEDGE_MIGRATION_MARKER = "-- opengeni:unified-knowledge-copy-v1";
+function knowledgeMigrationId(kind, id) {
+  const hash = createHash("sha256").update(`opengeni:knowledge:0461:${kind}:${id}`).digest("hex").slice(0, 32);
+  return `${hash.slice(0, 8)}-${hash.slice(8, 12)}-5${hash.slice(13, 16)}-8${hash.slice(17, 20)}-${hash.slice(20)}`;
+}
+async function migrateMemoryEvidence(tx, memory) {
+  const evidence = [];
+  const references = memory.snapshot.source_refs;
+  if (!Array.isArray(references)) return evidence;
+  for (const ref of references) {
+    if (!ref || typeof ref !== "object" || typeof ref.id !== "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(ref.id))
+      continue;
+    let entryId;
+    let passage;
+    if (ref.kind === "memory") {
+      const [found] = await tx`SELECT id FROM knowledge_memories WHERE account_id=${memory.account_id} AND id=${ref.id}`;
+      if (found && found.id !== memory.id) entryId = String(found.id);
+    } else if (ref.kind === "document" || ref.kind === "document_chunk") {
+      const [doc] = ref.kind === "document_chunk" ? await tx`SELECT d.id,d.status FROM document_chunks c JOIN documents d ON d.id=c.document_id AND d.account_id=c.account_id
+            WHERE c.account_id=${memory.account_id} AND c.id=${ref.id}` : await tx`SELECT id,status FROM documents WHERE account_id=${memory.account_id} AND id=${ref.id}`;
+      if (doc) {
+        const [version] = await tx`SELECT id FROM knowledge_document_versions WHERE account_id=${memory.account_id}
+          AND document_id=${doc.id} ORDER BY created_at DESC,id DESC LIMIT 1`;
+        if (version || doc.status === "ready")
+          entryId = knowledgeMigrationId(
+            version ? "document-version" : "document",
+            String(version?.id ?? doc.id)
+          );
+        if (ref.kind === "document_chunk") passage = `Legacy passage ${ref.id}`;
+      }
+    }
+    if (entryId && !evidence.some((item) => item.entryId === entryId && item.location.passage === passage)) {
+      evidence.push({
+        entryId,
+        revisionId: knowledgeMigrationId("revision", entryId),
+        location: passage ? { passage } : {}
+      });
+    }
+  }
+  return evidence;
+}
+async function importEntry(tx, input) {
+  const body = StoredKnowledgeEntryContent.parse(input.body);
+  const revisionId = knowledgeMigrationId("revision", input.id);
+  const outcome = ["active", "approved", "ready"].includes(input.status) ? "published" : input.status === "proposed" ? "pending" : "rejected";
+  const archived = !["active", "approved", "ready", "proposed"].includes(input.status);
+  const migrationActor = { kind: "migration", subjectId: "service:knowledge-migration:0461" };
+  const actor = input.originalActor ?? migrationActor;
+  const batchId = outcome === "pending" ? knowledgeMigrationId(
+    "review-batch",
+    `${input.accountId}:${input.workspaceId}:${input.scope}:${input.subjectId ?? ""}:${input.sessionId ?? input.id}`
+  ) : null;
+  if (batchId)
+    await tx`INSERT INTO knowledge_review_batches(id,account_id,origin_workspace_id,owner_key,session_id,created_at)
+    VALUES(${batchId},${input.accountId},${input.workspaceId},${input.scope === "personal" ? `personal:${input.subjectId}` : `${input.scope}:${input.workspaceId}`},
+      ${input.sessionId ?? null},${input.createdAt}) ON CONFLICT(id) DO NOTHING`;
+  await tx`INSERT INTO knowledge_entries(id,account_id,origin_workspace_id,scope,scope_workspace_id,scope_subject_id,
+    version,published_revision_id,latest_revision_id,archived,legacy_memory_id,legacy_document_id,
+    legacy_scope_type,legacy_scope_role_key,legacy_scope_session_id,legacy_document_version_id,legacy_claim_id,legacy_scope_workspace_id,valid_from,valid_until,created_at,updated_at)
+    VALUES(${input.id},${input.accountId},${input.workspaceId},${input.scope},${input.scope === "workspace" ? input.workspaceId : null},
+      ${input.subjectId},1,${outcome === "published" ? revisionId : null},${revisionId},${archived},${input.memoryId ?? null},${input.documentId ?? null},
+      ${input.legacyScopeType ?? null},${input.roleKey ?? null},${input.scopeSessionId ?? null},${input.legacyDocumentVersionId ?? null},${input.legacyClaimId ?? null},${input.legacyScopeWorkspaceId ?? null},${input.validFrom ?? input.createdAt},
+      ${input.validUntil ?? null},${input.createdAt},${input.createdAt})`;
+  await tx`INSERT INTO knowledge_entry_revisions(id,account_id,entry_id,number,body,body_codec_version,preview,preview_codec_version,
+    actor,created_by_session_id,review_batch_id,legacy_snapshot,created_at)
+    VALUES(${revisionId},${input.accountId},${input.id},1,${tx.json(toPostgresLosslessJson(body))},
+      ${LOSSLESS_CONTENT_CODEC_VERSION},${toPostgresLosslessText(body.content.slice(0, 512))},${LOSSLESS_CONTENT_CODEC_VERSION},
+      ${tx.json(actor)},${input.sessionId ?? null},${batchId},${input.legacySnapshot ? tx.json(input.legacySnapshot) : null},${input.createdAt})`;
+  await tx`INSERT INTO knowledge_entry_decisions(account_id,entry_id,revision_id,version,outcome,actor,created_at)
+    VALUES(${input.accountId},${input.id},${revisionId},1,${outcome},${tx.json(migrationActor)},${input.createdAt})`;
+  await tx`SELECT knowledge_index_revision(${input.accountId},${input.id},${revisionId},
+    ${toPostgresLosslessText(`${body.title}
+${body.content}`)})`;
+}
+async function importGroup(tx, owner, title, sourceKey) {
+  const id = knowledgeMigrationId(
+    "group",
+    `${owner.accountId}:${owner.scope}:${owner.scope === "workspace" ? owner.workspaceId : owner.subjectId ?? ""}:${sourceKey}`
+  );
+  const [existing] = await tx`SELECT id FROM knowledge_entries WHERE id=${id}`;
+  if (!existing)
+    await importEntry(tx, {
+      ...owner,
+      id,
+      status: "ready",
+      createdAt: /* @__PURE__ */ new Date(),
+      body: { title, kind: "group", content: "", groupIds: [], evidence: [], relationships: [] }
+    });
+  return id;
+}
+async function migratePendingLegacySkills(tx) {
+  let after = null;
+  for (; ; ) {
+    const candidates = await tx`
+      SELECT receipt.id,receipt.workspace_id,receipt.account_id,receipt.preference_id,receipt.revision_id,
+        revision.content,revision.title,revision.description,receipt.session_id,head.active_revision_id,head.scope_version
+      FROM company_brain_preference_proposal_receipts receipt
+      JOIN preference_registry_preferences head ON head.id=receipt.preference_id AND head.account_id=receipt.account_id
+      JOIN preference_registry_revisions revision ON revision.id=receipt.revision_id AND revision.preference_id=head.id
+      JOIN knowledge_change_proposals proposal ON proposal.id=receipt.knowledge_proposal_id AND proposal.account_id=receipt.account_id
+      WHERE (${after}::uuid IS NULL OR receipt.id>${after}::uuid)
+        AND revision.skill_files IS NULL AND head.status NOT IN ('rejected','superseded')
+        AND proposal.status='proposed' AND proposal.target_kind='preference'
+        AND head.scope='workspace' AND head.scope_workspace_id=receipt.workspace_id
+        AND proposal.scope_workspace_id=receipt.workspace_id AND proposal.target_scope='workspace'
+        AND coalesce((SELECT review.state FROM knowledge_claim_reviews review WHERE review.claim_id=proposal.claim_id
+          AND review.account_id=receipt.account_id ORDER BY review.review_revision DESC LIMIT 1),'proposed') IN ('proposed','approved')
+        AND NOT EXISTS(SELECT 1 FROM preference_registry_events event WHERE event.preference_id=head.id
+          AND event.new_revision_id=revision.id AND event.type IN ('activated','corrected','rejected'))
+        AND NOT EXISTS(SELECT 1 FROM preference_registry_revisions newer WHERE newer.preference_id=head.id
+          AND newer.revision>revision.revision AND newer.created_by_subject_id<>'service:skill-migration:0433')
+      ORDER BY receipt.id LIMIT 100`;
+    if (!candidates.length) break;
+    for (const candidate of candidates) {
+      const folder = prepareLegacySkillFolder([{ path: "SKILL.md", content: candidate.content }], {
+        id: candidate.preference_id,
+        title: candidate.title,
+        description: candidate.description
+      });
+      const main = folder.files.find((file) => file.path === "SKILL.md").content;
+      const revisionId = knowledgeMigrationId("pending-skill-revision", candidate.id);
+      const operationId = knowledgeMigrationId("pending-skill-operation", candidate.id);
+      await tx`INSERT INTO preference_registry_revisions(id,account_id,preference_id,title,description,content,content_hash,
+        precedence_rank,conflict_strategy,conflicts_with,provenance_source,provenance_source_id,trust,expires_at,
+        created_by_subject_id,corrects_revision_id,skill_files,skill_activation_mode)
+        SELECT ${revisionId}::uuid,account_id,preference_id,${folder.name},${folder.description},${main},
+          ${createHash("sha256").update(main, "utf8").digest("hex")},precedence_rank,conflict_strategy,conflicts_with,
+          provenance_source,provenance_source_id,trust,expires_at,'service:knowledge-migration:0461',id,
+          ${tx.json(folder.files)},'workspace_managed'
+        FROM preference_registry_revisions WHERE id=${candidate.revision_id}::uuid`;
+      await tx`INSERT INTO skill_write_receipts(account_id,workspace_id,operation_id,fingerprint,actor,receipt)
+        VALUES(${candidate.account_id}::uuid,${candidate.workspace_id}::uuid,${operationId}::uuid,
+          ${createHash("sha256").update(operationId).digest("hex")},
+          ${tx.json({
+        kind: "migration",
+        subjectId: "service:knowledge-migration:0461",
+        legacyProposalReceiptId: candidate.id,
+        legacyRevisionId: candidate.revision_id,
+        sessionId: candidate.session_id
+      })},
+          ${tx.json({
+        operationId,
+        skillId: candidate.preference_id,
+        revisionId,
+        outcome: "pending",
+        pendingReason: "approval",
+        replayed: false
+      })})`;
+    }
+    after = candidates.at(-1).id;
+  }
+}
+async function migrateRetainedKnowledge(tx) {
+  await migratePendingLegacySkills(tx);
+  await migrateSourceSchedules(tx);
+  let after = null;
+  for (; ; ) {
+    const memories = await tx`SELECT m.id,m.account_id,m.workspace_id,m.text,m.text_codec_version,m.kind,m.status,m.scope_type,m.scope_subject_id,
+      m.scope_role_key,m.scope_session_id,m.created_by_session_id,
+      (SELECT r.claim_id FROM remember_knowledge_memory_materializations map
+        JOIN remember_knowledge_confirmation_receipts r ON r.id=map.confirmation_receipt_id
+        WHERE map.account_id=m.account_id AND map.memory_id=m.id) AS confirmed_claim_id,m.namespace_key AS namespace,m.labels,m.created_at,m.valid_from,m.valid_until,
+      (to_jsonb(m)-'embedding'-'text') || jsonb_build_object('relationships',coalesce((SELECT jsonb_agg(to_jsonb(edge) ORDER BY edge.id)
+        FROM knowledge_memory_relationships edge WHERE edge.account_id=m.account_id
+          AND (edge.source_memory_id=m.id OR edge.target_memory_id=m.id)),'[]'::jsonb),
+        'lifecycleEvents',coalesce((SELECT jsonb_agg(to_jsonb(event) ORDER BY event.created_at,event.id)
+          FROM knowledge_memory_lifecycle_events event WHERE event.account_id=m.account_id AND event.target_memory_id=m.id),'[]'::jsonb)) AS snapshot,
+      coalesce((SELECT jsonb_agg(jsonb_build_object('entryId',edge.target_memory_id,'relation',
+        CASE edge.relationship_type WHEN 'derived_from' THEN 'depends_on' WHEN 'corrects' THEN 'supersedes' ELSE edge.relationship_type END)
+        ORDER BY edge.id) FROM knowledge_memory_relationships edge
+        WHERE edge.account_id=m.account_id AND edge.source_memory_id=m.id AND edge.removed_at IS NULL),'[]'::jsonb) AS relationships
+      FROM knowledge_memories m WHERE (${after}::uuid IS NULL OR m.id>${after}::uuid) ORDER BY m.id LIMIT 200`;
+    if (!memories.length) break;
+    for (const memory of memories) {
+      const content = fromPostgresLosslessText(memory.text, memory.text_codec_version);
+      const owner = {
+        accountId: memory.account_id,
+        workspaceId: memory.workspace_id,
+        scope: memory.scope_type === "user" ? "personal" : "workspace",
+        subjectId: memory.scope_subject_id
+      };
+      const groupIds = [];
+      if (memory.scope_type === "workspace") {
+        if (memory.namespace && memory.namespace !== "general")
+          groupIds.push(
+            await importGroup(tx, owner, memory.namespace, `namespace:${memory.namespace}`)
+          );
+        for (const label of memory.labels)
+          groupIds.push(await importGroup(tx, owner, label, `label:${label}`));
+      }
+      await importEntry(tx, {
+        ...owner,
+        id: memory.id,
+        memoryId: memory.id,
+        ...memory.confirmed_claim_id ? { legacyClaimId: memory.confirmed_claim_id } : {},
+        legacySnapshot: memory.snapshot,
+        originalActor: {
+          kind: memory.snapshot.created_by_kind,
+          subjectId: memory.snapshot.created_by_subject_id,
+          context: memory.snapshot.created_by_context
+        },
+        status: memory.status,
+        legacyScopeType: memory.scope_type,
+        roleKey: memory.scope_role_key,
+        scopeSessionId: memory.scope_session_id,
+        sessionId: memory.created_by_session_id,
+        createdAt: memory.created_at,
+        validFrom: memory.valid_from,
+        validUntil: memory.valid_until,
+        body: {
+          title: content.split(/\r?\n/u, 1)[0]?.slice(0, 160) || "Imported knowledge",
+          content,
+          kind: memory.kind === "episodic" ? "incident" : memory.kind === "semantic" ? "fact" : memory.kind === "decision" ? "decision" : "note",
+          source: { kind: "manual", externalId: `memory:${memory.id}` },
+          groupIds: [...new Set(groupIds)],
+          evidence: await migrateMemoryEvidence(tx, memory),
+          relationships: memory.relationships.map((relationship) => ({
+            entryId: relationship.entryId,
+            relation: relationship.relation
+          }))
+        }
+      });
+    }
+    after = memories.at(-1).id;
+  }
+  after = null;
+  for (; ; ) {
+    const documents = await tx`SELECT d.id,d.account_id,d.workspace_id,d.file_id,d.base_id,b.name AS base_name,d.title,d.authority_kind,
+      d.authority_subject_id,d.source_uri,d.source_external_id,d.source_version,d.created_at
+      FROM documents d JOIN document_bases b ON b.id=d.base_id AND b.account_id=d.account_id
+      WHERE d.status='ready' AND NOT EXISTS(SELECT 1 FROM knowledge_document_versions v WHERE v.account_id=d.account_id AND v.document_id=d.id)
+        AND (${after}::uuid IS NULL OR d.id>${after}::uuid) ORDER BY d.id LIMIT 50`;
+    if (!documents.length) break;
+    for (const document of documents) {
+      const chunks = await tx`SELECT text FROM document_chunks
+        WHERE account_id=${document.account_id} AND document_id=${document.id} ORDER BY chunk_index`;
+      const owner = {
+        accountId: document.account_id,
+        workspaceId: document.workspace_id,
+        scope: document.authority_kind,
+        subjectId: document.authority_subject_id
+      };
+      const groupIds = document.authority_kind === "workspace" && document.base_name ? [await importGroup(tx, owner, document.base_name, `document-base:${document.base_id}`)] : [];
+      await importEntry(tx, {
+        ...owner,
+        id: knowledgeMigrationId("document", document.id),
+        documentId: document.id,
+        status: "ready",
+        createdAt: document.created_at,
+        body: {
+          title: document.title,
+          kind: "source",
+          // Historical chunks may overlap. Preserve every retained passage;
+          // never claim to have reconstructed missing original full text.
+          content: chunks.map((chunk) => chunk.text).join("\n\n"),
+          groupIds,
+          evidence: [],
+          relationships: [],
+          source: {
+            kind: "file",
+            fileId: document.file_id,
+            documentId: document.id,
+            retention: "passages",
+            ...document.source_uri ? { uri: document.source_uri } : {},
+            ...document.source_external_id ? { externalId: document.source_external_id } : {},
+            ...document.source_version ? { version: document.source_version } : {}
+          }
+        }
+      });
+    }
+    after = documents.at(-1).id;
+  }
+  await importScopedKnowledge(tx);
+  await tx`INSERT INTO knowledge_entry_links(account_id,entry_id,revision_id,ordinal,target_entry_id,relation,target_revision_id)
+    SELECT r.account_id,r.entry_id,r.id,(g.ordinality-1)::integer,g.value::uuid,'group',NULL::uuid
+    FROM knowledge_entry_revisions r CROSS JOIN LATERAL jsonb_array_elements_text(r.body->'groupIds') WITH ORDINALITY g(value,ordinality)
+    UNION ALL
+    SELECT r.account_id,r.entry_id,r.id,jsonb_array_length(r.body->'groupIds')+(l.ordinality-1)::integer,
+      (l.value->>'entryId')::uuid,l.value->>'relation',NULL::uuid
+    FROM knowledge_entry_revisions r CROSS JOIN LATERAL jsonb_array_elements(r.body->'relationships') WITH ORDINALITY l(value,ordinality)
+    UNION ALL
+    SELECT r.account_id,r.entry_id,r.id,jsonb_array_length(r.body->'groupIds')+jsonb_array_length(r.body->'relationships')+(e.ordinality-1)::integer,
+      (e.value->>'entryId')::uuid,'evidence',(e.value->>'revisionId')::uuid
+    FROM knowledge_entry_revisions r CROSS JOIN LATERAL jsonb_array_elements(r.body->'evidence') WITH ORDINALITY e(value,ordinality)`;
+}
+async function importScopedKnowledge(tx) {
+  function owner(row) {
+    return {
+      accountId: row.account_id,
+      // Some organization/user records never had a creating workspace. This
+      // deterministic import origin is provenance only and grants no access.
+      workspaceId: row.scope_workspace_id ?? knowledgeMigrationId("import-origin", row.account_id),
+      scope: row.scope_kind,
+      subjectId: row.scope_subject_id
+    };
+  }
+  function actor(row) {
+    return {
+      kind: row.actor_kind,
+      subjectId: row.actor_subject_id,
+      initiatingHumanSubjectId: row.initiating_human_subject_id
+    };
+  }
+  let after = null;
+  for (; ; ) {
+    const entities = await tx`
+      SELECT e.*,to_jsonb(e) AS snapshot,coalesce((SELECT jsonb_agg(a.alias ORDER BY a.id)
+        FROM knowledge_entity_aliases a WHERE a.account_id=e.account_id AND a.entity_id=e.id),'[]'::jsonb) AS aliases
+      FROM knowledge_entities e WHERE (${after}::uuid IS NULL OR e.id>${after}::uuid)
+        AND (NOT EXISTS(SELECT 1 FROM knowledge_facts f JOIN knowledge_claims c ON c.fact_id=f.id
+          WHERE f.account_id=e.account_id AND (f.subject_entity_id=e.id OR f.object_entity_id=e.id))
+          OR EXISTS(SELECT 1 FROM knowledge_facts f JOIN knowledge_claims c ON c.fact_id=f.id
+            WHERE f.account_id=e.account_id AND (f.subject_entity_id=e.id OR f.object_entity_id=e.id)
+              AND NOT EXISTS(SELECT 1 FROM knowledge_change_proposals p WHERE p.claim_id=c.id AND p.account_id=c.account_id)))
+        ORDER BY e.id LIMIT 200`;
+    if (!entities.length) break;
+    for (const entity of entities)
+      await importEntry(tx, {
+        ...owner(entity),
+        id: knowledgeMigrationId("entity", entity.id),
+        status: "approved",
+        createdAt: entity.created_at,
+        legacyScopeWorkspaceId: entity.scope_workspace_id,
+        originalActor: actor(entity),
+        legacySnapshot: { entity: entity.snapshot, aliases: entity.aliases },
+        body: {
+          title: entity.display_name,
+          kind: "group",
+          content: entity.aliases.join("\n"),
+          groupIds: [],
+          evidence: [],
+          relationships: []
+        }
+      });
+    after = entities.at(-1).id;
+  }
+  after = null;
+  for (; ; ) {
+    const versions = await tx`
+      SELECT v.*,coalesce(d.title,o.external_object_id) AS title,s.source_uri,
+        jsonb_build_object('version',to_jsonb(v),'source',to_jsonb(s),'object',to_jsonb(o),'provider',to_jsonb(p)) AS snapshot
+      FROM knowledge_document_versions v JOIN knowledge_source_objects o ON o.account_id=v.account_id AND o.id=v.object_id
+      JOIN knowledge_sources s ON s.account_id=v.account_id AND s.id=v.source_id
+      JOIN knowledge_providers p ON p.account_id=s.account_id AND p.id=s.provider_id
+      LEFT JOIN documents d ON d.account_id=v.account_id AND d.id=v.document_id
+      WHERE (${after}::uuid IS NULL OR v.id>${after}::uuid) ORDER BY v.id LIMIT 100`;
+    if (!versions.length) break;
+    for (const version of versions) {
+      const chunks = version.document_id ? await tx`SELECT text FROM document_chunks
+        WHERE account_id=${version.account_id} AND document_id=${version.document_id} ORDER BY chunk_index` : [];
+      await importEntry(tx, {
+        ...owner(version),
+        id: knowledgeMigrationId("document-version", version.id),
+        legacyDocumentVersionId: version.id,
+        legacyScopeWorkspaceId: version.scope_workspace_id,
+        status: "ready",
+        createdAt: version.created_at,
+        originalActor: actor(version),
+        legacySnapshot: version.snapshot,
+        body: {
+          title: version.title,
+          kind: "source",
+          content: chunks.map((c) => c.text).join("\n\n"),
+          groupIds: [],
+          evidence: [],
+          relationships: [],
+          source: {
+            kind: version.file_id ? "file" : "connector",
+            externalId: `knowledge-document-version:${version.id}`,
+            version: version.external_version_id,
+            retention: chunks.length ? "passages" : "reference",
+            ...version.file_id ? { fileId: version.file_id } : {},
+            ...version.document_id ? { documentId: version.document_id } : {},
+            ...version.source_uri ? { uri: version.source_uri } : {}
+          }
+        }
+      });
+    }
+    after = versions.at(-1).id;
+  }
+  after = null;
+  for (; ; ) {
+    const claims = await tx`
+      SELECT c.*,f.subject_entity_id,f.object_entity_id,f.predicate_key,f.object_value,
+        subject.display_name AS subject_name,object.display_name AS object_name,
+        coalesce((SELECT state FROM knowledge_claim_reviews r WHERE r.account_id=c.account_id AND r.claim_id=c.id
+          ORDER BY r.review_revision DESC LIMIT 1),'proposed') AS state,
+        jsonb_build_object('claim',to_jsonb(c),'fact',to_jsonb(f),
+          'evidence',coalesce((SELECT jsonb_agg(to_jsonb(e) ORDER BY e.id) FROM knowledge_claim_evidence e
+            WHERE e.account_id=c.account_id AND e.claim_id=c.id),'[]'::jsonb),
+          'reviews',coalesce((SELECT jsonb_agg(to_jsonb(r) ORDER BY r.review_revision) FROM knowledge_claim_reviews r
+            WHERE r.account_id=c.account_id AND r.claim_id=c.id),'[]'::jsonb)) AS snapshot
+      FROM knowledge_claims c JOIN knowledge_facts f ON f.account_id=c.account_id AND f.id=c.fact_id
+      JOIN knowledge_entities subject ON subject.account_id=f.account_id AND subject.id=f.subject_entity_id
+      LEFT JOIN knowledge_entities object ON object.account_id=f.account_id AND object.id=f.object_entity_id
+      WHERE (${after}::uuid IS NULL OR c.id>${after}::uuid)
+        AND NOT EXISTS(SELECT 1 FROM knowledge_entries imported WHERE imported.legacy_claim_id=c.id)
+        AND NOT EXISTS(SELECT 1 FROM knowledge_change_proposals p WHERE p.account_id=c.account_id AND p.claim_id=c.id
+          )
+      ORDER BY c.id LIMIT 100`;
+    if (!claims.length) break;
+    for (const claim of claims) {
+      const retained = await tx`
+        SELECT document_version_id,locator FROM knowledge_claim_evidence WHERE account_id=${claim.account_id}
+          AND claim_id=${claim.id} AND document_version_id IS NOT NULL ORDER BY id`;
+      const relations = await tx`
+        SELECT r.to_claim_id,r.relation_type,(SELECT e.id FROM knowledge_entries e WHERE e.legacy_claim_id=r.to_claim_id) AS imported_entry_id FROM knowledge_claim_relations r
+        WHERE r.account_id=${claim.account_id} AND r.from_claim_id=${claim.id}
+          AND NOT EXISTS(SELECT 1 FROM knowledge_change_proposals p WHERE p.account_id=r.account_id AND p.claim_id=r.to_claim_id ) ORDER BY r.id`;
+      const objectText = claim.object_name ?? (typeof claim.object_value === "string" ? claim.object_value : JSON.stringify(claim.object_value));
+      await importEntry(tx, {
+        ...owner(claim),
+        id: knowledgeMigrationId("claim", claim.id),
+        legacyClaimId: claim.id,
+        legacyScopeWorkspaceId: claim.scope_workspace_id,
+        status: claim.state,
+        createdAt: claim.created_at,
+        validFrom: claim.effective_at,
+        validUntil: claim.expires_at,
+        originalActor: actor(claim),
+        legacySnapshot: claim.snapshot,
+        body: {
+          title: `${claim.subject_name}: ${claim.predicate_key}`,
+          kind: "fact",
+          content: claim.extraction_method === "task-note-promotion-v1" && typeof claim.object_value === "string" ? claim.object_value : `${claim.subject_name} \xB7 ${claim.predicate_key}: ${objectText}`,
+          source: { kind: "manual", externalId: `knowledge-claim:${claim.id}` },
+          groupIds: [knowledgeMigrationId("entity", claim.subject_entity_id)],
+          evidence: retained.map((e) => {
+            const id = knowledgeMigrationId("document-version", e.document_version_id);
+            return {
+              entryId: id,
+              revisionId: knowledgeMigrationId("revision", id),
+              location: e.locator ? { passage: e.locator } : {}
+            };
+          }),
+          relationships: [
+            ...relations.map((r) => ({
+              entryId: r.imported_entry_id ?? knowledgeMigrationId("claim", r.to_claim_id),
+              relation: r.relation_type
+            })),
+            ...claim.object_entity_id ? [
+              {
+                entryId: knowledgeMigrationId("entity", claim.object_entity_id),
+                relation: "related_to"
+              }
+            ] : []
+          ]
+        }
+      });
+    }
+    after = claims.at(-1).id;
+  }
+}
+async function migrateSourceSchedules(tx) {
+  await tx`ALTER TABLE scheduled_tasks NO FORCE ROW LEVEL SECURITY`;
+  await tx`ALTER TABLE scheduled_tasks DISABLE TRIGGER scheduled_task_tombstone_immutable`;
+  const tasks = await tx`SELECT id,account_id,workspace_id,action,authority_revision FROM scheduled_tasks
+    WHERE action->>'kind'='knowledge_source_sync' AND deleted_at IS NULL ORDER BY id`;
+  for (const task of tasks) {
+    const source = KnowledgeSourceSyncAction.parse(task.action);
+    await tx`SELECT set_config('opengeni.account_id',${task.account_id},true),
+      set_config('opengeni.workspace_id',${task.workspace_id},true),
+      set_config('opengeni.subject_id',${source.initiatingSubjectId},true),
+      set_config('opengeni.initiating_human_subject_id',${source.initiatingSubjectId},true)`;
+    await tx`SELECT pg_advisory_xact_lock_shared(hashtextextended('session-tenancy:'||${task.workspace_id}::text,0))`;
+    await tx`SELECT id FROM workspaces WHERE id=${task.workspace_id} FOR UPDATE`;
+    const [authority] = await tx`SELECT id FROM organization_memberships m
+      WHERE m.account_id=${task.account_id} AND m.subject_id=${source.initiatingSubjectId}
+        AND m.status='active' AND m.revoked_at IS NULL
+        AND (m.personal_workspace_id=${task.workspace_id} OR EXISTS(SELECT 1 FROM workspace_memberships w
+          WHERE w.account_id=m.account_id AND w.workspace_id=${task.workspace_id} AND w.subject_id=m.subject_id))`;
+    await tx`UPDATE scheduled_task_runs SET status='failed',completed_at=clock_timestamp(),
+      error='knowledge_source_agent_cutover',updated_at=clock_timestamp()
+      WHERE task_id=${task.id} AND action_kind='knowledge_source_sync' AND status IN ('queued','dispatched')`;
+    await tx`UPDATE knowledge_source_sync_wakes SET completed_at=clock_timestamp()
+      WHERE scheduled_task_id=${task.id} AND completed_at IS NULL`;
+    await tx`UPDATE knowledge_source_sync_states SET lease_id=NULL,lease_until=NULL,
+      buffered_wake=false,buffered_scheduled_task_run_id=NULL,pending_wake_count=0,updated_at=clock_timestamp()
+      WHERE scheduled_task_id=${task.id}`;
+    if (!authority)
+      await tx`UPDATE scheduled_tasks SET status='paused',
+      metadata=jsonb_set(metadata,'{knowledgeSourceSync}',coalesce(metadata->'knowledgeSourceSync','{}'::jsonb)
+        || '{"sourceEnabled":false,"authorityRefreshRequired":true}'::jsonb) WHERE id=${task.id}`;
+    const [updated] = await tx`UPDATE scheduled_tasks SET action='{"kind":"agent_turn"}',
+      agent_config=${JSON.stringify(knowledgeSourceAgentConfig(source))}::jsonb, authority_revision=authority_revision+1,
+      updated_at=clock_timestamp() WHERE id=${task.id} RETURNING authority_revision`;
+    if (!updated) throw new Error("Source schedule disappeared during maintenance");
+    await tx`SELECT freeze_scheduled_task_personal_resources(${task.account_id}::uuid,
+      ${task.workspace_id}::uuid,${task.id}::uuid,${updated.authority_revision}::bigint)`;
+    if (authority)
+      await tx`SELECT record_scheduled_task_revision_authority(${task.account_id}::uuid,
+      ${task.workspace_id}::uuid,${task.id}::uuid,${updated.authority_revision}::bigint)`;
+  }
+  await tx`ALTER TABLE scheduled_tasks ENABLE TRIGGER scheduled_task_tombstone_immutable`;
+  await tx`ALTER TABLE scheduled_tasks FORCE ROW LEVEL SECURITY`;
+  await tx`SELECT set_config('opengeni.account_id','',true),set_config('opengeni.workspace_id','',true),
+    set_config('opengeni.subject_id','',true),set_config('opengeni.initiating_human_subject_id','',true)`;
+}
+
+// src/skill-config-migration.ts
+import { createHash as createHash2 } from "crypto";
+import {
+  StoredCapabilityPack,
+  StoredSessionSkills,
+  validateSkillTextFiles
+} from "@opengeni/contracts";
+function object(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("Expected stored configuration object");
+  return value;
+}
+function convertLegacyConfigSkills(value, identity) {
+  if (!Array.isArray(value)) throw new Error("Expected stored Skill array");
+  const names = /* @__PURE__ */ new Set();
+  const converted = value.map((entry, index) => {
+    const skill = object(entry);
+    if (!Array.isArray(skill.files)) throw new Error("Expected stored Skill folder");
+    const files = skill.files.map((fileEntry) => {
+      const file = object(fileEntry);
+      if (typeof file.path !== "string" || typeof file.content !== "string")
+        throw new Error("Invalid stored Skill text file");
+      if (Object.keys(file).some((key) => key !== "path" && key !== "content"))
+        throw new Error("Unexpected stored Skill file fields");
+      return { path: file.path, content: file.content };
+    });
+    const main = files.find((file) => file.path === "SKILL.md");
+    const plain = main && !/^\s*---(?:\r?\n|$)/u.test(main.content);
+    if (plain && (typeof skill.name !== "string" || typeof skill.description !== "string"))
+      throw new Error("Plain Skill requires historical name and description");
+    const folder = prepareLegacySkillFolder(files, {
+      id: createHash2("sha256").update(`${identity}:${index}`).digest("hex").slice(0, 32),
+      title: typeof skill.name === "string" ? skill.name : "",
+      description: typeof skill.description === "string" ? skill.description : ""
+    });
+    validateSkillTextFiles(folder.files);
+    if (names.has(folder.name)) throw new Error(`Canonical Skill name collision: ${folder.name}`);
+    names.add(folder.name);
+    return plain ? { ...skill, ...folder } : entry;
+  });
+  StoredSessionSkills.parse(converted);
+  return converted;
+}
+function convertLegacyPackConfig(value, identity) {
+  const pack = object(value);
+  const converted = { ...pack };
+  if (pack.skills !== void 0)
+    converted.skills = convertLegacyConfigSkills(pack.skills, identity);
+  if (Array.isArray(pack.automationTemplates))
+    converted.automationTemplates = pack.automationTemplates.map((entry, index) => {
+      const template = object(entry);
+      const sessionTemplate = object(template.sessionTemplate);
+      return {
+        ...template,
+        sessionTemplate: {
+          ...sessionTemplate,
+          ...sessionTemplate.skills !== void 0 ? {
+            skills: convertLegacyConfigSkills(
+              sessionTemplate.skills,
+              `${identity}:template:${index}`
+            )
+          } : {}
+        }
+      };
+    });
+  StoredCapabilityPack.parse(converted);
+  return converted;
+}
+async function assertSkillConfigurationMaintenanceWindow(tx) {
+  const rows = await tx`SELECT c.oid FROM pg_class c
+    WHERE c.oid='sessions'::regclass AND pg_get_userbyid(c.relowner)=current_user
+      AND c.relrowsecurity AND NOT c.relforcerowsecurity
+      AND to_regclass('pg_temp.skill_metadata_0426') IS NOT NULL`;
+  if (rows.length !== 1)
+    throw new Error(
+      "Skill configuration conversion requires the parser-backed maintenance owner window"
+    );
+}
+async function migrateLegacySkillConfigurations(tx) {
+  await assertSkillConfigurationMaintenanceWindow(tx);
+  await tx`SELECT pg_advisory_xact_lock(hashtextextended('session-tenancy:'||workspace_id::text,0))
+    FROM (SELECT DISTINCT workspace_id FROM sessions ORDER BY workspace_id) workspaces`;
+  await tx`LOCK TABLE sessions, workspace_packs, session_turns, automation_triggers,
+    automation_trigger_revisions, automation_runs, automation_trigger_events, automation_run_event_links, pack_installations IN SHARE ROW EXCLUSIVE MODE`;
+  const pinned = await tx`
+    SELECT 'pack-installation' AS kind,id::text,manifest_snapshot AS value FROM pack_installations
+      WHERE status <> 'disabled' AND manifest_snapshot IS NOT NULL
+    UNION ALL SELECT 'automation-current',t.id::text,jsonb_build_object('skills',r.session_template->'skills')
+      FROM automation_triggers t JOIN automation_trigger_revisions r ON r.trigger_id=t.id AND r.revision=t.current_revision
+      WHERE t.status IN ('active','paused') AND r.session_template ? 'skills'
+    UNION ALL SELECT 'automation-run',id::text,jsonb_build_object('skills',accepted_execution->'sessionTemplate'->'skills')
+      FROM automation_runs WHERE status IN ('queued','dispatching') AND accepted_execution->'sessionTemplate' ? 'skills'
+    UNION ALL SELECT 'automation-event',e.id::text,jsonb_build_object('skills',r.session_template->'skills')
+      FROM automation_trigger_events e CROSS JOIN LATERAL jsonb_array_elements(e.matched_trigger_revisions) matched
+      JOIN automation_trigger_revisions r ON r.trigger_id=(matched->>'triggerId')::uuid AND r.revision=(matched->>'revision')::integer
+      WHERE e.status='accepted' AND r.session_template ? 'skills'
+        AND NOT EXISTS (SELECT 1 FROM automation_runs run WHERE run.event_id=e.id AND run.trigger_id=r.trigger_id AND run.trigger_revision=r.revision)
+        AND NOT EXISTS (SELECT 1 FROM automation_run_event_links link WHERE link.event_id=e.id AND link.trigger_id=r.trigger_id)
+  `;
+  const blockers = [];
+  for (const source of pinned) {
+    try {
+      const original = object(source.value);
+      const converted = source.kind === "pack-installation" ? convertLegacyPackConfig(original, source.id) : { ...original, skills: convertLegacyConfigSkills(original.skills, source.id) };
+      if (JSON.stringify(converted) !== JSON.stringify(original))
+        blockers.push(`${source.kind}:${source.id} (plain content)`);
+    } catch {
+      blockers.push(`${source.kind}:${source.id} (invalid content)`);
+    }
+  }
+  const candidates = await tx`
+    SELECT 'session' AS kind,s.id::text,s.account_id,s.workspace_id,s.skills AS original,
+      (s.active_turn_id IS NOT NULL OR EXISTS(SELECT 1 FROM session_turns t WHERE t.session_id=s.id AND t.status NOT IN ('completed','failed','cancelled'))) AS pinned
+      FROM sessions s WHERE s.skills <> '[]'::jsonb
+    UNION ALL SELECT 'workspace-pack',id::text,account_id,workspace_id,manifest,false FROM workspace_packs
+  `;
+  const changes = [];
+  for (const source of candidates) {
+    try {
+      const converted = source.kind === "session" ? convertLegacyConfigSkills(source.original, source.id) : convertLegacyPackConfig(source.original, source.id);
+      if (source.kind === "session") StoredSessionSkills.parse(converted);
+      if (JSON.stringify(source.original) !== JSON.stringify(converted)) {
+        if (source.pinned) blockers.push(`${source.kind}:${source.id} (runnable accepted turn)`);
+        else changes.push({ source, converted });
+      }
+    } catch {
+      blockers.push(`${source.kind}:${source.id} (invalid content or canonical collision)`);
+    }
+  }
+  if (blockers.length)
+    throw new Error(
+      `0433 Skill configuration preflight: ${blockers.length} repair-required sources; drain or explicitly replace pinned sources before retry: ${blockers.slice(0, 30).join(", ")}`
+    );
+  for (const { source, converted } of changes) {
+    const original = tx.json(source.original);
+    const replacement = tx.json(converted);
+    await tx`INSERT INTO skill_config_conversion_receipts(account_id,workspace_id,source_kind,source_id,original_configuration,original_hash,replacement_hash)
+      VALUES(${source.account_id},${source.workspace_id},${source.kind},${source.id},${original},
+        encode(sha256(convert_to(${original}::jsonb::text,'UTF8')),'hex'),encode(sha256(convert_to(${replacement}::jsonb::text,'UTF8')),'hex'))`;
+    const updated = source.kind === "session" ? await tx`UPDATE sessions SET skills=${replacement} WHERE id=${source.id} AND account_id=${source.account_id} AND workspace_id=${source.workspace_id} AND skills=${original} RETURNING id` : await tx`UPDATE workspace_packs SET manifest=${replacement} WHERE id=${source.id} AND account_id=${source.account_id} AND workspace_id=${source.workspace_id} AND manifest=${original} RETURNING id`;
+    if (updated.length !== 1)
+      throw new Error(`0433 Skill configuration CAS conflict: ${source.kind}:${source.id}`);
+  }
+}
+
+// src/migration-runner-settings.ts
+function batchedBackfillTransactionLocalSetting(file) {
+  if (file === "0411_new_session_draft_project_provenance_backfill.sql") {
+    return {
+      guc: "opengeni.new_session_draft_project_provenance_backfill_v1",
+      value: "1"
+    };
+  }
+  return null;
+}
+
+// src/migrate.ts
+var DEFAULT_DATABASE_URL = "postgres://opengeni:opengeni@127.0.0.1:5432/opengeni";
+var DEFAULT_MAX_NESTED_AGENT_DEPTH = 3;
+var MAX_NESTED_AGENT_DEPTH = 2147483647;
+var DEFAULT_APPLICATION_DATABASE_ROLE = "opengeni_app";
+var MIGRATION_APPLICATION_ROLES_SETTING = "opengeni.migration_application_roles";
+var MAX_MIGRATION_APPLICATION_ROLES = 16;
+var batchedBackfillDirective = /^-- opengeni:batched-backfill batch-size=(\d+) lock-timeout=(\d+(?:ms|s|min)) statement-timeout=(\d+(?:ms|s|min))$/;
+var concurrentIndexDirective = /^-- opengeni:concurrent-index lock-timeout=(\d+(?:ms|s|min))$/;
+var concurrentIndexStatement = /^CREATE\s+(?:UNIQUE\s+)?INDEX\s+CONCURRENTLY\s+(?:(IF\s+NOT\s+EXISTS)\s+)?(?:"((?:[^"]|"")+)"|([A-Za-z_][A-Za-z0-9_]*))\s+ON\b/is;
+var governedLegacyConcurrentIndexMigrations = /* @__PURE__ */ new Set([
+  "0066_session_interruption_attempt_lookup.sql",
+  "0070_session_event_type_sequence_lookup.sql",
+  "0071_session_event_monitoring_tail.sql",
+  "0072_sessions_workspace_created_id_idx.sql",
+  "0073_sessions_workspace_updated_id_idx.sql",
+  "0075_sessions_workspace_activity_revision_idx.sql",
+  "0077_session_attempt_latest_lookup.sql"
+]);
+function assertIdentifier(name, value) {
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(value)) {
+    throw new Error(`${name} is not a valid Postgres identifier: ${value}`);
+  }
+  return value;
+}
+function parseConcurrentIndexMigration(file, sqlText) {
+  const lines = sqlText.replaceAll("\r\n", "\n").split("\n");
+  const firstLine = lines[0]?.trim() ?? "";
+  const deploymentPrefixed = /^-- deployment-mode: (?:rolling|maintenance)$/.test(firstLine);
+  const directiveIndex = deploymentPrefixed ? 1 : 0;
+  const directiveLine = lines[directiveIndex]?.trim() ?? "";
+  const directive = concurrentIndexDirective.exec(directiveLine);
+  if (!directive) {
+    if (directiveLine.startsWith("-- opengeni:")) {
+      throw new Error(`Unsupported OpenGeni migration directive in ${file}`);
+    }
+    return null;
+  }
+  const lockTimeout = directive[1];
+  const statement = lines.slice(directiveIndex + 1).join("\n").trim();
+  const withoutTrailingSemicolon = statement.endsWith(";") ? statement.slice(0, -1).trimEnd() : statement;
+  const parsedStatement = concurrentIndexStatement.exec(withoutTrailingSemicolon);
+  if (!parsedStatement || withoutTrailingSemicolon.includes(";")) {
+    throw new Error(
+      `${file}: opengeni:concurrent-index requires exactly one CREATE [UNIQUE] INDEX CONCURRENTLY IF NOT EXISTS statement with an unqualified index name`
+    );
+  }
+  const idempotentInSql = parsedStatement[1] !== void 0;
+  if (!idempotentInSql && !governedLegacyConcurrentIndexMigrations.has(file)) {
+    throw new Error(
+      `${file}: opengeni:concurrent-index requires IF NOT EXISTS; bare statements are supported only for governed historical migrations`
+    );
+  }
+  return {
+    indexName: (parsedStatement[2] ?? parsedStatement[3]).replaceAll('""', '"'),
+    lockTimeout,
+    skipWhenValid: !idempotentInSql,
+    statement
+  };
+}
+function parseBatchedBackfillMigration(file, sqlText) {
+  const lines = sqlText.replaceAll("\r\n", "\n").split("\n");
+  const directiveIndex = /^-- deployment-mode: (?:rolling|maintenance)$/.test(
+    lines[0]?.trim() ?? ""
+  ) ? 1 : 0;
+  const directive = batchedBackfillDirective.exec(lines[directiveIndex]?.trim() ?? "");
+  if (!directive) return null;
+  const statement = lines.slice(directiveIndex + 1).filter((line) => !line.trim().startsWith("--")).join("\n").trim();
+  const withoutTrailingSemicolon = statement.endsWith(";") ? statement.slice(0, -1).trimEnd() : statement;
+  const batchSize = Number(directive[1]);
+  if (!Number.isSafeInteger(batchSize) || batchSize < 1 || batchSize > 1e4 || !/^WITH\b/is.test(withoutTrailingSemicolon) || !/\bUPDATE\b/is.test(withoutTrailingSemicolon) || !/\bRETURNING\b/is.test(withoutTrailingSemicolon) || !new RegExp(`\\bLIMIT\\s+${batchSize}\\b`, "i").test(withoutTrailingSemicolon) || withoutTrailingSemicolon.includes(";")) {
+    throw new Error(
+      `${file}: opengeni:batched-backfill requires one bounded WITH ... UPDATE ... RETURNING statement whose LIMIT matches batch-size`
+    );
+  }
+  return {
+    batchSize,
+    lockTimeout: directive[2],
+    statementTimeout: directive[3],
+    statement
+  };
+}
+async function executeMigrationFile(sql, file, sqlText) {
+  if (sqlText.includes(SKILL_METADATA_MIGRATION_MARKER)) {
+    if (file !== "0433_unified_skill_lifecycle.sql")
+      throw new Error("Skill metadata stage is restricted to migration 0433");
+    const parts = sqlText.split(SKILL_METADATA_MIGRATION_MARKER);
+    if (parts.length !== 2) throw new Error("0433 requires exactly one Skill metadata stage");
+    await sql.begin(async (transaction) => {
+      await createSkillMetadataMigrationStage(transaction);
+      await transaction`SELECT
+        pg_catalog.set_config('opengeni.sandbox_recovery_protocol_v2','1',true),
+        pg_catalog.set_config('opengeni.session_variable_set_attachments_v1','1',true)`;
+      await transaction.unsafe(parts[0]);
+      await stageSkillMetadataMigration(transaction);
+      await migrateLegacySkillConfigurations(transaction);
+      await transaction.unsafe(parts[1]);
+      await transaction`INSERT INTO schema_migrations(name) VALUES(${file}) ON CONFLICT DO NOTHING`;
+    });
+    return;
+  }
+  if (sqlText.includes(KNOWLEDGE_MIGRATION_MARKER)) {
+    if (file !== "0461_unified_knowledge.sql")
+      throw new Error("Knowledge conversion is restricted to migration 0461");
+    const parts = sqlText.split(KNOWLEDGE_MIGRATION_MARKER);
+    if (parts.length !== 2) throw new Error("0461 requires exactly one Knowledge conversion stage");
+    await sql.begin(async (transaction) => {
+      await transaction`CREATE TEMP TABLE knowledge_conversion_0461(completed boolean NOT NULL) ON COMMIT DROP`;
+      await transaction`SELECT
+        pg_catalog.set_config('opengeni.sandbox_recovery_protocol_v2','1',true),
+        pg_catalog.set_config('opengeni.session_variable_set_attachments_v1','1',true)`;
+      await transaction.unsafe(parts[0]);
+      await migrateRetainedKnowledge(transaction);
+      await transaction`INSERT INTO pg_temp.knowledge_conversion_0461 VALUES(true)`;
+      await transaction.unsafe(parts[1]);
+      await transaction`INSERT INTO schema_migrations(name) VALUES(${file}) ON CONFLICT DO NOTHING`;
+    });
+    return;
+  }
+  const batchedBackfill = parseBatchedBackfillMigration(file, sqlText);
+  if (batchedBackfill) {
+    await sql`select set_config('lock_timeout', ${batchedBackfill.lockTimeout}, false)`;
+    await sql`select set_config('statement_timeout', ${batchedBackfill.statementTimeout}, false)`;
+    try {
+      for (; ; ) {
+        const result = await sql.begin(async (transaction) => {
+          const transactionLocalSetting = batchedBackfillTransactionLocalSetting(file);
+          await transaction`select
+            pg_catalog.set_config('opengeni.sandbox_recovery_protocol_v2', '1', true),
+            pg_catalog.set_config(
+              'opengeni.session_variable_set_attachments_v1',
+              '1',
+              true
+            )`;
+          if (transactionLocalSetting) {
+            await transaction`select pg_catalog.set_config(
+              ${transactionLocalSetting.guc},
+              ${transactionLocalSetting.value},
+              true
+            )`;
+          }
+          return await transaction.unsafe(batchedBackfill.statement);
+        });
+        if (result.length === 0) break;
+      }
+    } finally {
+      await sql`select set_config('statement_timeout', '0', false)`;
+      await sql`select set_config('lock_timeout', '0', false)`;
+    }
+    return;
+  }
+  const concurrentIndex = parseConcurrentIndexMigration(file, sqlText);
+  if (!concurrentIndex) {
+    await sql.unsafe(
+      `SELECT
+  pg_catalog.set_config('opengeni.sandbox_recovery_protocol_v2', '1', true),
+  pg_catalog.set_config('opengeni.session_variable_set_attachments_v1', '1', true);
+${file === "0434_ordered_model_history.sql" ? "SET CONSTRAINTS ALL IMMEDIATE;\n" : ""}${sqlText}`
+    );
+    return;
+  }
+  await sql`select set_config('lock_timeout', ${concurrentIndex.lockTimeout}, false)`;
+  try {
+    const [existing] = await sql`
+      select i.indisvalid as valid, i.indisready as ready
+      from pg_catalog.pg_class c
+      join pg_catalog.pg_namespace n on n.oid = c.relnamespace
+      join pg_catalog.pg_index i on i.indexrelid = c.oid
+      where n.nspname = current_schema() and c.relname = ${concurrentIndex.indexName}
+    `;
+    if (existing && (!existing.valid || !existing.ready)) {
+      const quotedIndexName = `"${concurrentIndex.indexName.replaceAll('"', '""')}"`;
+      await sql.unsafe(`DROP INDEX CONCURRENTLY ${quotedIndexName}`);
+    } else if (existing && concurrentIndex.skipWhenValid) {
+      return;
+    }
+    await sql.unsafe(concurrentIndex.statement);
+  } finally {
+    await sql`select set_config('lock_timeout', '0', false)`;
+  }
+}
+function deploymentDepthPolicy(options) {
+  const raw = options === void 0 ? process.env.OPENGENI_MAX_NESTED_AGENT_DEPTH?.trim() || void 0 : options.maxNestedAgentDepth;
+  if (raw === void 0) {
+    return { maxNestedAgentDepth: DEFAULT_MAX_NESTED_AGENT_DEPTH, source: "default" };
+  }
+  const value = typeof raw === "number" ? raw : Number(raw);
+  if (!Number.isSafeInteger(value) || value < 0 || value > MAX_NESTED_AGENT_DEPTH || typeof raw === "string" && !/^(0|[1-9][0-9]*)$/.test(raw)) {
+    throw new Error(
+      `OPENGENI_MAX_NESTED_AGENT_DEPTH must be a non-negative 32-bit integer: ${raw}`
+    );
+  }
+  return { maxNestedAgentDepth: value, source: "deployment" };
+}
+function migrationApplicationRoles(schema, options) {
+  const configured = options?.applicationDatabaseRoles;
+  const environment = process.env.OPENGENI_MIGRATION_APPLICATION_DATABASE_ROLES?.trim();
+  const explicit = configured !== void 0 ? configured : environment ? environment.split(",").map((role) => role.trim()) : void 0;
+  if (!explicit) {
+    const configuredRuntimeRoles = [
+      process.env.OPENGENI_APP_DATABASE_USER?.trim(),
+      process.env.OPENGENI_RUNTIME_DATABASE_ROLE?.trim()
+    ].filter((role) => Boolean(role) && role !== DEFAULT_APPLICATION_DATABASE_ROLE);
+    if (schema || configuredRuntimeRoles.length > 0) {
+      throw new Error(
+        "Pending migrations require the exact application database roles via MigrationRuntimeOptions.applicationDatabaseRoles or OPENGENI_MIGRATION_APPLICATION_DATABASE_ROLES for dedicated-schema or custom-role deployments"
+      );
+    }
+    return [DEFAULT_APPLICATION_DATABASE_ROLE];
+  }
+  if (configured !== void 0 && configured.some((role) => typeof role !== "string" || role !== role.trim())) {
+    throw new Error(
+      "MigrationRuntimeOptions.applicationDatabaseRoles must contain canonical Postgres role names without surrounding whitespace"
+    );
+  }
+  if (explicit.length < 1 || explicit.length > MAX_MIGRATION_APPLICATION_ROLES) {
+    throw new Error(
+      `Migration application database roles must contain 1-${MAX_MIGRATION_APPLICATION_ROLES} entries`
+    );
+  }
+  const normalized = [...new Set(explicit)].sort(
+    (left, right) => Buffer.compare(Buffer.from(left, "utf8"), Buffer.from(right, "utf8"))
+  );
+  if (normalized.length !== explicit.length || normalized.some((role) => role.length === 0 || Buffer.byteLength(role, "utf8") > 63)) {
+    throw new Error(
+      "Migration application database roles must be unique, non-empty Postgres role names of at most 63 UTF-8 bytes"
+    );
+  }
+  return normalized;
+}
+async function persistDeploymentDepthPolicy(sql, policy) {
+  const [relation] = await sql`
+    select to_regclass('nested_agent_depth_configuration') is not null as exists
+  `;
+  if (!relation?.exists) return;
+  await sql`
+    insert into "nested_agent_depth_configuration" (
+      "singleton", "max_nested_agent_depth", "policy_source", "updated_at"
+    ) values (true, ${policy.maxNestedAgentDepth}, ${policy.source}, now())
+    on conflict ("singleton") do update
+    set "max_nested_agent_depth" = excluded."max_nested_agent_depth",
+        "policy_source" = excluded."policy_source",
+        "updated_at" = now()
+    where "nested_agent_depth_configuration"."max_nested_agent_depth"
+            is distinct from excluded."max_nested_agent_depth"
+       or "nested_agent_depth_configuration"."policy_source"
+            is distinct from excluded."policy_source"
+  `;
+}
+async function migrate(databaseUrl = process.env.OPENGENI_MIGRATIONS_DATABASE_URL ?? process.env.OPENGENI_DATABASE_URL ?? DEFAULT_DATABASE_URL, schema = process.env.OPENGENI_DB_SCHEMA?.trim() || void 0, runtimeOptions) {
+  const migrationsDir = join(dirname(fileURLToPath(import.meta.url)), "../drizzle");
+  const files = (await readdir(migrationsDir)).filter((file) => file.endsWith(".sql")).sort();
+  const depthPolicy = deploymentDepthPolicy(runtimeOptions);
+  const sql = postgres(databaseUrl, { max: 1 });
+  try {
+    await sql`SELECT pg_advisory_lock(727458)`;
+    if (schema) {
+      assertIdentifier("OPENGENI_DB_SCHEMA", schema);
+      await sql.unsafe(`CREATE SCHEMA IF NOT EXISTS "${schema}"`);
+      await sql.unsafe(`CREATE SCHEMA IF NOT EXISTS "opengeni_private"`);
+      await sql.unsafe(`SET search_path = "${schema}", "opengeni_private", "public"`);
+    }
+    await sql`select set_config('opengeni.max_nested_agent_depth', ${String(depthPolicy.maxNestedAgentDepth)}, false)`;
+    await sql`select set_config('opengeni.nested_agent_depth_policy_source', ${depthPolicy.source}, false)`;
+    await sql.unsafe(
+      `CREATE TABLE IF NOT EXISTS "schema_migrations" ("name" text PRIMARY KEY, "applied_at" timestamptz NOT NULL DEFAULT now())`
+    );
+    const appliedRows = await sql`SELECT "name" FROM "schema_migrations"`;
+    const applied = new Set(appliedRows.map((row) => row.name));
+    const pendingMigrationSources = /* @__PURE__ */ new Map();
+    for (const file of files) {
+      if (!applied.has(file)) {
+        pendingMigrationSources.set(file, await readFile(join(migrationsDir, file), "utf8"));
+      }
+    }
+    if (Array.from(pendingMigrationSources.values()).some(
+      (source) => source.includes(MIGRATION_APPLICATION_ROLES_SETTING)
+    )) {
+      const applicationRoles = migrationApplicationRoles(schema, runtimeOptions);
+      await sql`select set_config(
+        ${MIGRATION_APPLICATION_ROLES_SETTING},
+        ${JSON.stringify(applicationRoles)},
+        false
+      )`;
+    }
+    for (const file of files) {
+      if (applied.has(file)) {
+        continue;
+      }
+      const sqlText = pendingMigrationSources.get(file);
+      if (sqlText === void 0) {
+        throw new Error(`Pending migration source was not loaded: ${file}`);
+      }
+      await executeMigrationFile(sql, file, sqlText);
+      await sql`INSERT INTO "schema_migrations" ("name") VALUES (${file}) ON CONFLICT DO NOTHING`;
+    }
+    await persistDeploymentDepthPolicy(sql, depthPolicy);
+  } finally {
+    await sql.end();
+  }
+}
+async function runMigrations(adminConnection, targetSchema, runtimeOptions) {
+  await migrate(adminConnection, targetSchema, runtimeOptions);
+}
+if (import.meta.main) {
+  await migrate();
+  console.log("Applied Drizzle SQL migrations.");
+}
+
+export {
+  parseConcurrentIndexMigration,
+  parseBatchedBackfillMigration,
+  executeMigrationFile,
+  migrationApplicationRoles,
+  migrate,
+  runMigrations
+};
+//# sourceMappingURL=chunk-45CP2YKY.js.map