@lucern/pack-host 0.1.0-alpha.2

package/dist/registry.js

@@ -0,0 +1,1710 @@
+import { z } from 'zod';
+
+// src/dependencyResolution.ts
+function toIssue(code, message, path, severity = "error") {
+  return {
+    code,
+    severity,
+    message,
+    path
+  };
+}
+function buildManifestMap(manifests) {
+  return new Map(manifests.map((manifest) => [manifest.key, manifest]));
+}
+function walkDependencyClosure(manifestKey, manifestsByKey, path, closure, issues) {
+  const manifest = manifestsByKey.get(manifestKey);
+  if (!manifest) {
+    return;
+  }
+  for (const dependency of manifest.dependencies) {
+    if (!manifestsByKey.has(dependency)) {
+      issues.push(
+        toIssue(
+          "PACK_DEPENDENCY_MISSING",
+          `Pack "${manifestKey}" depends on unknown pack "${dependency}".`,
+          `dependencies:${manifestKey}`
+        )
+      );
+      continue;
+    }
+    if (path.includes(dependency)) {
+      const cycle = [...path, dependency].join(" -> ");
+      issues.push(
+        toIssue(
+          "PACK_DEPENDENCY_CYCLE",
+          `Cycle detected: ${cycle}`,
+          `dependencies:${manifestKey}`
+        )
+      );
+      continue;
+    }
+    if (closure.has(dependency)) {
+      continue;
+    }
+    closure.add(dependency);
+    walkDependencyClosure(
+      dependency,
+      manifestsByKey,
+      [...path, dependency],
+      closure,
+      issues
+    );
+  }
+}
+function resolvePackDependencyGraph(manifests) {
+  const issues = [];
+  const manifestsByKey = buildManifestMap(manifests);
+  const indegree = /* @__PURE__ */ new Map();
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const manifest of manifests) {
+    indegree.set(manifest.key, indegree.get(manifest.key) ?? 0);
+    adjacency.set(manifest.key, []);
+  }
+  for (const manifest of manifests) {
+    for (const dependency of manifest.dependencies) {
+      if (!manifestsByKey.has(dependency)) {
+        issues.push(
+          toIssue(
+            "PACK_DEPENDENCY_MISSING",
+            `Pack "${manifest.key}" depends on unknown pack "${dependency}".`,
+            `dependencies:${manifest.key}`
+          )
+        );
+        continue;
+      }
+      const dependencyDependents = adjacency.get(dependency) ?? [];
+      dependencyDependents.push(manifest.key);
+      adjacency.set(dependency, dependencyDependents);
+      indegree.set(manifest.key, (indegree.get(manifest.key) ?? 0) + 1);
+    }
+  }
+  const queue = [...indegree.entries()].filter(([, value]) => value === 0).map(([packKey]) => packKey).sort();
+  const orderedPackKeys = [];
+  while (queue.length > 0) {
+    const nextKey = queue.shift();
+    if (!nextKey) {
+      break;
+    }
+    orderedPackKeys.push(nextKey);
+    const dependents = adjacency.get(nextKey) ?? [];
+    for (const dependent of dependents) {
+      const current = indegree.get(dependent) ?? 0;
+      const updated = current - 1;
+      indegree.set(dependent, updated);
+      if (updated === 0) {
+        queue.push(dependent);
+      }
+    }
+    queue.sort();
+  }
+  if (orderedPackKeys.length !== manifestsByKey.size) {
+    const unresolved = [...indegree.entries()].filter(([, value]) => value > 0).map(([key]) => key).sort();
+    issues.push(
+      toIssue(
+        "PACK_DEPENDENCY_CYCLE",
+        `Dependency graph is not acyclic; unresolved packs: ${unresolved.join(", ")}`,
+        "dependencies"
+      )
+    );
+  }
+  const dependencyClosureByPack = {};
+  for (const manifest of manifests) {
+    const closure = /* @__PURE__ */ new Set();
+    walkDependencyClosure(
+      manifest.key,
+      manifestsByKey,
+      [manifest.key],
+      closure,
+      issues
+    );
+    dependencyClosureByPack[manifest.key] = [...closure].sort();
+  }
+  return {
+    orderedPackKeys,
+    dependencyClosureByPack,
+    issues,
+    valid: issues.every((issue) => issue.severity !== "error")
+  };
+}
+
+// src/lifecycle.ts
+var DEFAULT_ALLOWED_LIFECYCLES = [
+  "active",
+  "beta",
+  "experimental"
+];
+function toSet(values) {
+  return new Set(values ?? []);
+}
+function evaluatePackEnablement(packKey, registry, policy = {}) {
+  const manifest = registry[packKey];
+  if (!manifest) {
+    return {
+      packKey,
+      allowed: false,
+      reason: "pack_not_found",
+      missingDependencies: []
+    };
+  }
+  const allowedLifecycles = new Set(
+    policy.allowedLifecycles ?? DEFAULT_ALLOWED_LIFECYCLES
+  );
+  if (!allowedLifecycles.has(manifest.lifecycle)) {
+    return {
+      packKey,
+      allowed: false,
+      reason: "lifecycle_blocked",
+      missingDependencies: []
+    };
+  }
+  const requireExplicitEntitlement = policy.requireExplicitEntitlement ?? false;
+  if (requireExplicitEntitlement) {
+    const entitled = /* @__PURE__ */ new Set([
+      ...toSet(policy.tenantEntitledPackKeys),
+      ...toSet(policy.workspaceEntitledPackKeys)
+    ]);
+    if (!entitled.has(packKey)) {
+      return {
+        packKey,
+        allowed: false,
+        reason: "license_missing",
+        missingDependencies: []
+      };
+    }
+  }
+  const missingDependencies = manifest.dependencies.filter(
+    (dependency) => !registry[dependency]
+  );
+  if (missingDependencies.length > 0) {
+    return {
+      packKey,
+      allowed: false,
+      reason: "dependency_missing",
+      missingDependencies
+    };
+  }
+  const installed = toSet(policy.installedPackKeys);
+  if (installed.size > 0) {
+    const notInstalled = manifest.dependencies.filter(
+      (dependency) => !installed.has(dependency)
+    );
+    if (notInstalled.length > 0) {
+      return {
+        packKey,
+        allowed: false,
+        reason: "dependency_not_installed",
+        missingDependencies: notInstalled
+      };
+    }
+  }
+  const enabled = toSet(policy.enabledPackKeys);
+  if (enabled.size > 0) {
+    const notEnabled = manifest.dependencies.filter(
+      (dependency) => !enabled.has(dependency)
+    );
+    if (notEnabled.length > 0) {
+      return {
+        packKey,
+        allowed: false,
+        reason: "dependency_not_enabled",
+        missingDependencies: notEnabled
+      };
+    }
+  }
+  return {
+    packKey,
+    allowed: true,
+    reason: "allowed",
+    missingDependencies: []
+  };
+}
+function evaluateCatalogEnablement(registry, policy = {}) {
+  return Object.keys(registry).sort().map((packKey) => evaluatePackEnablement(packKey, registry, policy));
+}
+
+// src/contracts.ts
+function normalizeStringArray(values) {
+  const normalized = values.map((value) => value.trim()).filter((value) => value.length > 0);
+  return Array.from(new Set(normalized));
+}
+function defineAppPackManifest(manifest) {
+  const sharedServices = (manifest.sharedServices ?? []).map((integration) => ({
+    ...integration,
+    contracts: normalizeStringArray(integration.contracts)
+  }));
+  return {
+    ...manifest,
+    dependencies: normalizeStringArray(manifest.dependencies),
+    capabilityFlags: normalizeStringArray(manifest.capabilityFlags),
+    sharedServices
+  };
+}
+
+// src/manifests/chat-v1.ts
+var chatV1Manifest = defineAppPackManifest({
+  key: "chat-v1",
+  name: "Chat",
+  version: "1.0.0",
+  lifecycle: "active",
+  category: "conversation",
+  description: "Core conversational runtime, streaming orchestration, and tool invocation shell.",
+  dependencies: [],
+  capabilityFlags: [
+    "chat.streaming",
+    "chat.history",
+    "tool.invocation",
+    "slash.commands",
+    "voice.mode"
+  ],
+  routeNamespace: {
+    web: ["/(chat)/chat", "/(chat)/chat/[id]"],
+    api: [
+      "/(chat)/api/chat",
+      "/(chat)/api/coach",
+      "/(chat)/api/history",
+      "/(chat)/api/suggestions",
+      "/(chat)/api/vote"
+    ]
+  },
+  surfaces: {
+    components: [
+      "components/chat/*",
+      "components/chat/sidebars/*",
+      "components/chat/viewers/*"
+    ],
+    convex: ["convex/chats.ts", "convex/messages.ts", "convex/chatState.ts"],
+    tools: ["lib/ai/tools/project-tools.ts"]
+  },
+  policyProfile: {
+    audiences: ["internal", "lp", "public"],
+    rules: [
+      { resource: "project", actions: ["read", "summarize"] },
+      {
+        resource: "tool_action",
+        actions: ["read", "mutate"],
+        notes: "Mutation tools must pass server-side policy checks."
+      },
+      { resource: "artifact", actions: ["read", "summarize"] }
+    ]
+  },
+  dataContract: {
+    requiredNodeTypes: ["belief", "question", "evidence", "theme", "deal"],
+    requiredEdgeTypes: ["informs", "answers", "belongs_to"],
+    requiredTables: ["chats", "messages", "chatState", "projects"],
+    projectionBehavior: "inherits_policy"
+  },
+  templates: {
+    workflows: ["chat/default", "chat/voice-mode"],
+    prompts: ["chat/main-system-prompt", "chat/voice-mode-style"],
+    reports: [],
+    uiLabels: ["chat", "assistant", "conversation"]
+  },
+  testSuite: {
+    parity: ["chat-streaming-parity", "slash-command-parity"],
+    policy: ["chat-context-filtering", "tool-deny-enforcement"],
+    contract: ["chat-pack-contract-v1"]
+  }
+});
+
+// src/manifests/deals-v1.ts
+var dealsV1Manifest = defineAppPackManifest({
+  key: "deals-v1",
+  name: "Deals",
+  version: "1.0.0",
+  lifecycle: "beta",
+  category: "domain",
+  description: "Deal diligence application using shared reasoning graph primitives with deal-calibrated workflows.",
+  dependencies: [
+    "chat-v1",
+    "documents-v1",
+    "news-v1",
+    "decisions-v1"
+  ],
+  capabilityFlags: [
+    "deal.lifecycle",
+    "diligence.workflow",
+    "deal.risk-assessment",
+    "decision.integration"
+  ],
+  routeNamespace: {
+    web: ["/(projects)/projects", "/(projects)/projects/[projectId]"],
+    api: ["/api/research/*", "/api/tasks/*", "/api/reports/*"]
+  },
+  surfaces: {
+    components: [
+      "app/(projects)/projects/page.tsx",
+      "components/project/*",
+      "components/workspace/views/*"
+    ],
+    convex: ["convex/projects.ts", "convex/epistemicDecisions.ts"],
+    tools: [
+      "lib/ai/tools/navigation-tools.ts",
+      "lib/ai/tools/decision-tools.ts"
+    ]
+  },
+  policyProfile: {
+    audiences: ["internal", "lp"],
+    rules: [
+      { resource: "project", actions: ["read", "summarize", "mutate"] },
+      { resource: "node", actions: ["read", "summarize", "mutate"] },
+      { resource: "artifact", actions: ["read", "summarize", "export"] },
+      { resource: "tool_action", actions: ["read", "mutate"] }
+    ]
+  },
+  dataContract: {
+    requiredNodeTypes: ["deal", "belief", "question", "evidence", "decision"],
+    requiredEdgeTypes: [
+      "evaluates",
+      "informs",
+      "depends_on",
+      "based_on_belief"
+    ],
+    requiredTables: [
+      "projects",
+      "epistemicNodes",
+      "epistemicEdges",
+      "decisionEvents"
+    ],
+    projectionBehavior: "projection_required"
+  },
+  templates: {
+    workflows: ["deals/diligence-default", "deals/ic-prep"],
+    prompts: ["deals/main-system-prompt", "deals/risk-ledger-draft"],
+    reports: ["deal-memo", "knowledge-map"],
+    uiLabels: ["deal", "diligence", "investment_case", "ic_readiness"]
+  },
+  testSuite: {
+    parity: ["deal-workflow-parity"],
+    policy: ["deal-data-audience-filtering"],
+    contract: ["deals-pack-contract-v1"]
+  },
+  sharedServices: [
+    {
+      service: "decision-kernel",
+      mode: "required",
+      contracts: ["decision-kernel-v1"]
+    },
+    {
+      service: "knowledge-compiler",
+      mode: "required",
+      contracts: ["knowledge-compiler-v1"]
+    }
+  ]
+});
+
+// src/manifests/decisions-v1.ts
+var decisionsV1Manifest = defineAppPackManifest({
+  key: "decisions-v1",
+  name: "Decisions",
+  version: "1.0.0",
+  lifecycle: "beta",
+  category: "decision",
+  description: "Graph-native decision workflow with belief-level voting, risk ledgers, and snapshot locking.",
+  dependencies: ["epistemic-algorithms-v1"],
+  capabilityFlags: [
+    "decision.workflow",
+    "belief.level-voting",
+    "risk.ledger",
+    "decision.snapshot"
+  ],
+  routeNamespace: {
+    web: ["/(projects)/projects/[projectId]/decisions"],
+    api: ["/api/thesis-audit/*", "/api/reports/*"]
+  },
+  surfaces: {
+    components: ["app/(projects)/projects/[projectId]/decisions/page.tsx"],
+    convex: ["convex/epistemicDecisions.ts", "convex/convictionEngine.ts"],
+    tools: [
+      "lib/ai/tools/decision-tools.ts",
+      "lib/ai/tools/conviction-tools.ts"
+    ]
+  },
+  policyProfile: {
+    audiences: ["internal", "lp"],
+    rules: [
+      { resource: "project", actions: ["read", "summarize", "mutate"] },
+      { resource: "node", actions: ["read", "summarize", "mutate"] },
+      { resource: "edge", actions: ["read", "mutate"] },
+      { resource: "artifact", actions: ["read", "export"] }
+    ]
+  },
+  dataContract: {
+    requiredNodeTypes: ["decision", "belief", "question", "evidence", "theme"],
+    requiredEdgeTypes: [
+      "based_on_belief",
+      "based_on_question",
+      "informed_by_theme",
+      "blocked_by_contradiction"
+    ],
+    requiredTables: [
+      "epistemicNodes",
+      "epistemicEdges",
+      "decisionEvents",
+      "beliefVotes",
+      "decisionRiskLedger",
+      "decisionSnapshots"
+    ],
+    projectionBehavior: "projection_required"
+  },
+  templates: {
+    workflows: ["decisions/pre-ic", "decisions/in-ic", "decisions/post-ic"],
+    prompts: [
+      "decisions/main-system-prompt",
+      "decisions/risk-ledger-assistant"
+    ],
+    reports: ["decision-brief", "ic-memo"],
+    uiLabels: ["decision", "risk_ledger", "vote_map", "snapshot"]
+  },
+  testSuite: {
+    parity: ["decision-flow-parity"],
+    policy: ["decision-lineage-visibility"],
+    contract: ["decisions-pack-contract-v1"]
+  },
+  sharedServices: [
+    {
+      service: "decision-kernel",
+      mode: "required",
+      contracts: ["decision-kernel-v1"]
+    },
+    {
+      service: "knowledge-compiler",
+      mode: "required",
+      contracts: ["knowledge-compiler-v1"]
+    }
+  ]
+});
+
+// src/manifests/documents-v1.ts
+var documentsV1Manifest = defineAppPackManifest({
+  key: "documents-v1",
+  name: "Documents",
+  version: "1.0.0",
+  lifecycle: "active",
+  category: "documents",
+  description: "Document upload, extraction, annotation, and conversion into graph-grounded evidence.",
+  dependencies: ["chat-v1"],
+  capabilityFlags: [
+    "document.ingestion",
+    "document.extraction",
+    "document.annotation",
+    "document.rag"
+  ],
+  routeNamespace: {
+    web: [
+      "/(projects)/projects/[projectId]/documents",
+      "/(projects)/projects/[projectId]/documents/[documentId]"
+    ],
+    api: ["/api/documents/*", "/api/rag/document", "/api/rag/extract-pdf"]
+  },
+  surfaces: {
+    components: ["components/documents/*", "components/document/*"],
+    convex: [
+      "convex/projectDocuments.ts",
+      "convex/documents.ts",
+      "convex/documentAnnotations.ts",
+      "convex/projectDocumentsActions.ts"
+    ],
+    tools: ["lib/ai/tools/create-document.ts"]
+  },
+  policyProfile: {
+    audiences: ["internal", "lp"],
+    rules: [
+      { resource: "artifact", actions: ["read", "summarize", "mutate"] },
+      { resource: "project", actions: ["read", "summarize", "mutate"] },
+      { resource: "tool_action", actions: ["read", "mutate"] }
+    ]
+  },
+  dataContract: {
+    requiredNodeTypes: ["source", "excerpt", "evidence", "synthesis"],
+    requiredEdgeTypes: ["extracted_from", "based_on", "informs"],
+    requiredTables: [
+      "projectDocuments",
+      "projectDocumentsSyncLog",
+      "documentAnnotations",
+      "epistemicNodes"
+    ],
+    projectionBehavior: "inherits_policy"
+  },
+  templates: {
+    workflows: [
+      "documents/upload-extract-link",
+      "documents/annotate-to-evidence"
+    ],
+    prompts: ["documents/extraction", "documents/summarization"],
+    reports: [],
+    uiLabels: ["documents", "annotations", "excerpts", "sources"]
+  },
+  testSuite: {
+    parity: ["documents-page-parity"],
+    policy: ["document-access-enforcement"],
+    contract: ["documents-pack-contract-v1"]
+  }
+});
+
+// src/manifests/epistemic-algorithms-v1.ts
+var epistemicAlgorithmsV1Manifest = defineAppPackManifest({
+  key: "epistemic-algorithms-v1",
+  name: "Epistemic Algorithms",
+  version: "1.0.0",
+  lifecycle: "active",
+  category: "analytics",
+  description: "Reasoning quality engines: contradiction detection, conviction dynamics, and graph intelligence analytics.",
+  dependencies: ["graph-visualization-v1", "chat-v1"],
+  capabilityFlags: [
+    "contradiction.detection",
+    "conviction.analytics",
+    "reasoning.depth",
+    "bias.detection"
+  ],
+  routeNamespace: {
+    web: [
+      "/(projects)/projects/[projectId]/contradictions",
+      "/(projects)/projects/[projectId]/thesis-audit"
+    ],
+    api: ["/api/thesis-audit", "/api/graph-explain", "/api/lucern/*"]
+  },
+  surfaces: {
+    components: ["components/epistemic/*", "components/contradiction/*"],
+    convex: [
+      "convex/contradictions.ts",
+      "convex/convictionEngine.ts",
+      "convex/graphIntelligence.ts",
+      "convex/thesisAuditAgents.ts"
+    ],
+    tools: ["lib/ai/tools/graph-intelligence-tools.ts"]
+  },
+  policyProfile: {
+    audiences: ["internal", "lp"],
+    rules: [
+      { resource: "node", actions: ["read", "summarize"] },
+      { resource: "edge", actions: ["read", "summarize"] },
+      { resource: "artifact", actions: ["read", "summarize", "export"] }
+    ]
+  },
+  dataContract: {
+    requiredNodeTypes: ["belief", "question", "evidence", "theme", "decision"],
+    requiredEdgeTypes: [
+      "informs",
+      "contradicts",
+      "depends_on",
+      "strengthened_by",
+      "weakened_by",
+      "collapses_if"
+    ],
+    requiredTables: [
+      "contradictions",
+      "beliefConfidence",
+      "epistemicAudit",
+      "graphAnalysisResults"
+    ],
+    projectionBehavior: "inherits_policy"
+  },
+  templates: {
+    workflows: ["epistemic/contradiction-resolution", "epistemic/thesis-audit"],
+    prompts: [
+      "graph-intelligence/full-guide",
+      "graph-intelligence/bias-detection"
+    ],
+    reports: ["knowledge_map"],
+    uiLabels: [
+      "contradiction",
+      "conviction",
+      "thesis_audit",
+      "epistemic_health"
+    ]
+  },
+  testSuite: {
+    parity: ["epistemic-algorithm-output-parity"],
+    policy: ["epistemic-output-scope-filtering"],
+    contract: ["epistemic-algorithms-pack-contract-v1"]
+  },
+  sharedServices: [
+    {
+      service: "knowledge-compiler",
+      mode: "required",
+      contracts: ["knowledge-compiler-v1"]
+    }
+  ]
+});
+
+// src/manifests/graph-visualization-v1.ts
+var graphVisualizationV1Manifest = defineAppPackManifest({
+  key: "graph-visualization-v1",
+  name: "Graph Visualization",
+  version: "1.0.0",
+  lifecycle: "active",
+  category: "graph",
+  description: "Interactive graph explorer for node/edge traversal, neighborhood inspection, and query rendering.",
+  dependencies: ["chat-v1"],
+  capabilityFlags: [
+    "graph.rendering",
+    "graph.query",
+    "graph.highlighting",
+    "graph.neighborhood"
+  ],
+  routeNamespace: {
+    web: ["/(projects)/projects/[projectId]/graph"],
+    api: ["/api/graph", "/api/graph-query", "/api/graph-suggestions"]
+  },
+  surfaces: {
+    components: [
+      "app/(projects)/projects/[projectId]/graph/components/*",
+      "components/workspace/views/ProjectHomeView.tsx"
+    ],
+    convex: ["convex/epistemicQueries.ts", "convex/neo4jQueries.ts"],
+    tools: [
+      "lib/ai/tools/knowledge-graph-tools.ts",
+      "lib/ai/tools/cypher-tools.ts"
+    ]
+  },
+  policyProfile: {
+    audiences: ["internal", "lp"],
+    rules: [
+      { resource: "node", actions: ["read", "summarize"] },
+      { resource: "edge", actions: ["read", "summarize"] },
+      { resource: "tool_action", actions: ["read"] }
+    ]
+  },
+  dataContract: {
+    requiredNodeTypes: [
+      "belief",
+      "question",
+      "evidence",
+      "theme",
+      "deal",
+      "decision"
+    ],
+    requiredEdgeTypes: ["informs", "answers", "belongs_to", "depends_on"],
+    requiredTables: ["epistemicNodes", "epistemicEdges"],
+    projectionBehavior: "inherits_policy"
+  },
+  templates: {
+    workflows: ["graph/query-and-traverse"],
+    prompts: [
+      "graph-intelligence/query",
+      "graph-intelligence/suggestions-extraction"
+    ],
+    reports: [],
+    uiLabels: ["graph", "nodes", "edges", "lineage"]
+  },
+  testSuite: {
+    parity: ["graph-query-parity", "graph-render-parity"],
+    policy: ["graph-node-visibility-filtering"],
+    contract: ["graph-visualization-pack-contract-v1"]
+  }
+});
+
+// src/manifests/news-v1.ts
+var newsV1Manifest = defineAppPackManifest({
+  key: "news-v1",
+  name: "News",
+  version: "1.0.0",
+  lifecycle: "active",
+  category: "news",
+  description: "News ingestion, curation, and contextual linkage into the reasoning graph.",
+  dependencies: ["chat-v1"],
+  capabilityFlags: [
+    "news.search",
+    "news.ingestion",
+    "news.curation",
+    "news.graph-linkage"
+  ],
+  routeNamespace: {
+    web: [
+      "/(projects)/projects/[projectId]/news-v3",
+      "/(projects)/projects/[projectId]/news-v3/[articleId]"
+    ],
+    api: ["/api/news/search", "/api/intelligence/smart-news-search"]
+  },
+  surfaces: {
+    components: ["components/news/*"],
+    convex: [
+      "convex/projectNews.ts",
+      "convex/newsArticles.ts",
+      "convex/newsCurationJobs.ts",
+      "convex/articleCache.ts"
+    ],
+    tools: ["lib/ai/tools/research-tools.ts"]
+  },
+  policyProfile: {
+    audiences: ["internal", "lp", "public"],
+    rules: [
+      { resource: "project", actions: ["read", "summarize", "mutate"] },
+      { resource: "artifact", actions: ["read", "summarize", "export"] },
+      { resource: "node", actions: ["read", "summarize"] }
+    ]
+  },
+  dataContract: {
+    requiredNodeTypes: ["source", "evidence", "synthesis", "theme", "deal"],
+    requiredEdgeTypes: ["extracted_from", "informs", "belongs_to"],
+    requiredTables: [
+      "projectNews",
+      "savedNewsArticles",
+      "newsCurationJobs",
+      "articleCache",
+      "epistemicNodes"
+    ],
+    projectionBehavior: "inherits_policy"
+  },
+  templates: {
+    workflows: ["news/search-import-curate", "news/evidence-linking"],
+    prompts: ["news/summary", "news/relevance-scoring"],
+    reports: ["news-digest"],
+    uiLabels: ["news", "articles", "curation", "signals"]
+  },
+  testSuite: {
+    parity: ["news-v3-parity"],
+    policy: ["news-audience-redaction"],
+    contract: ["news-pack-contract-v1"]
+  },
+  sharedServices: [
+    {
+      service: "knowledge-compiler",
+      mode: "required",
+      contracts: ["knowledge-compiler-v1"]
+    }
+  ]
+});
+
+// src/manifests/philosophy-mode-v1.ts
+var philosophyModeV1Manifest = defineAppPackManifest({
+  key: "philosophy-mode-v1",
+  name: "Philosophy Mode",
+  version: "1.0.0",
+  lifecycle: "active",
+  category: "domain",
+  description: "Investor worldview extraction, archetype synthesis, and philosophy profile management.",
+  dependencies: ["chat-v1", "user-profiles-v1"],
+  capabilityFlags: [
+    "philosophy.extraction",
+    "philosophy.profiles",
+    "archetype.classification",
+    "worldview.synthesis"
+  ],
+  routeNamespace: {
+    web: ["/(chat)/chat/[id]"],
+    api: [
+      "/api/philosophy/detect",
+      "/api/philosophy/extract",
+      "/api/philosophy/get-profile",
+      "/api/philosophy/ingest",
+      "/api/philosophy/synthesize"
+    ]
+  },
+  surfaces: {
+    components: [
+      "components/chat/sidebars/PhilosophyModeSidebar.tsx",
+      "components/philosophy/ArchetypeDisplay.tsx"
+    ],
+    convex: [
+      "convex/philosophy.ts",
+      "convex/philosophyQueries.ts",
+      "convex/projectPhilosophy.ts"
+    ],
+    tools: ["lib/ai/tools/philosophy-tools.ts"]
+  },
+  policyProfile: {
+    audiences: ["internal"],
+    rules: [
+      { resource: "user_profile", actions: ["read", "mutate"] },
+      { resource: "project", actions: ["read", "summarize"] },
+      { resource: "tool_action", actions: ["read", "mutate"] }
+    ]
+  },
+  dataContract: {
+    requiredNodeTypes: ["belief", "question", "theme"],
+    requiredEdgeTypes: ["belongs_to", "relates_to_thesis"],
+    requiredTables: [
+      "marketPhilosophyProfiles",
+      "marketPhilosophyAtoms",
+      "marketPhilosophyContent",
+      "philosophyUploads"
+    ],
+    projectionBehavior: "inherits_policy"
+  },
+  templates: {
+    workflows: ["philosophy/conversation-to-profile"],
+    prompts: [
+      "philosophy/deep-thinker",
+      "philosophy/welcome-back",
+      "philosophy/detect-philosophical-statement",
+      "philosophy/content-classifier",
+      "philosophy/atom-extractor",
+      "philosophy/summarize-investor-profile",
+      "philosophy/team-aggregator",
+      "philosophy/market-synthesis",
+      "thematic/extractor"
+    ],
+    reports: [],
+    uiLabels: ["philosophy_mode", "investor_worldview", "archetype"]
+  },
+  testSuite: {
+    parity: ["philosophy-profile-parity"],
+    policy: ["philosophy-profile-isolation"],
+    contract: ["philosophy-pack-contract-v1"]
+  }
+});
+
+// src/manifests/task-management-v1.ts
+var taskManagementV1Manifest = defineAppPackManifest({
+  key: "task-management-v1",
+  name: "Task Management",
+  version: "1.0.0",
+  lifecycle: "active",
+  category: "operations",
+  description: "Operational task system linked to beliefs, questions, worktrees, and AI-assisted execution.",
+  dependencies: ["chat-v1"],
+  capabilityFlags: [
+    "task.lifecycle",
+    "task.assignment",
+    "task.attachments",
+    "task.ai-execution",
+    "task.evidence-capture"
+  ],
+  routeNamespace: {
+    web: ["/(projects)/projects/[projectId]/tasks"],
+    api: [
+      "/api/tasks/execute",
+      "/api/tasks/execute-workflow",
+      "/api/tasks/refresh-call-script"
+    ]
+  },
+  surfaces: {
+    components: ["components/task/*"],
+    convex: [
+      "convex/tasks.ts",
+      "convex/_taskHelpers.ts",
+      "convex/_taskQueryLogic.ts"
+    ],
+    tools: ["lib/ai/tools/task-tools.ts"]
+  },
+  policyProfile: {
+    audiences: ["internal", "lp"],
+    rules: [
+      { resource: "task", actions: ["read", "mutate", "admin"] },
+      { resource: "project", actions: ["read", "summarize", "mutate"] },
+      { resource: "tool_action", actions: ["read", "mutate"] },
+      { resource: "artifact", actions: ["read", "summarize", "mutate"] }
+    ]
+  },
+  dataContract: {
+    requiredNodeTypes: ["belief", "question", "evidence", "synthesis"],
+    requiredEdgeTypes: ["informs", "tests", "belongs_to"],
+    requiredTables: ["tasks", "projects", "epistemicNodes", "epistemicEdges"],
+    projectionBehavior: "inherits_policy"
+  },
+  templates: {
+    workflows: [
+      "tasks/research-plan",
+      "tasks/execution-loop",
+      "tasks/evidence-capture"
+    ],
+    prompts: ["tasks/call-script", "tasks/research-plan-generator"],
+    reports: [],
+    uiLabels: ["tasks", "assignee", "checklist", "workflow_status"]
+  },
+  testSuite: {
+    parity: ["task-management-parity"],
+    policy: ["task-project-access-enforcement"],
+    contract: ["task-management-pack-contract-v1"]
+  }
+});
+
+// src/manifests/team-analysis-v1.ts
+var teamAnalysisV1Manifest = defineAppPackManifest({
+  key: "team-analysis-v1",
+  name: "Team Analysis",
+  version: "1.0.0",
+  lifecycle: "active",
+  category: "analytics",
+  description: "Team-level behavioral analytics, archetype distribution, and comparative operating patterns.",
+  dependencies: ["user-profiles-v1"],
+  capabilityFlags: [
+    "team.analytics",
+    "team.behavioral-summary",
+    "team.archetype-distribution",
+    "team.activity-heatmap"
+  ],
+  routeNamespace: {
+    web: ["/(team)/team"],
+    api: ["/api/coaching/*"]
+  },
+  surfaces: {
+    components: ["components/charts/*", "components/coaching/*"],
+    convex: [
+      "convex/users.ts",
+      "convex/userAnalytics.ts",
+      "convex/projectCards.ts"
+    ],
+    tools: []
+  },
+  policyProfile: {
+    audiences: ["internal", "tenant_admin"],
+    rules: [
+      { resource: "team_analytics", actions: ["read", "admin"] },
+      { resource: "user_profile", actions: ["read"] },
+      { resource: "project", actions: ["read"] }
+    ]
+  },
+  dataContract: {
+    requiredNodeTypes: ["belief", "question", "evidence"],
+    requiredEdgeTypes: ["informs", "tests"],
+    requiredTables: [
+      "users",
+      "userEpistemicJourney",
+      "epistemicAudit",
+      "proposalEvents",
+      "biSuggestions",
+      "beliefConfidence",
+      "contradictions",
+      "worktrees",
+      "tasks"
+    ],
+    projectionBehavior: "none"
+  },
+  templates: {
+    workflows: ["team/behavioral-summary", "team/coverage-gap-analysis"],
+    prompts: ["coaching/team-summary", "coaching/team-recommendations"],
+    reports: ["team-operating-review"],
+    uiLabels: ["team", "behavior", "distribution", "coverage"]
+  },
+  testSuite: {
+    parity: ["team-page-parity"],
+    policy: ["team-analytics-admin-scope"],
+    contract: ["team-analysis-pack-contract-v1"]
+  },
+  sharedServices: [
+    {
+      service: "knowledge-compiler",
+      mode: "required",
+      contracts: ["knowledge-compiler-v1"]
+    }
+  ]
+});
+
+// src/manifests/themes-v1.ts
+var themesV1Manifest = defineAppPackManifest({
+  key: "themes-v1",
+  name: "Themes",
+  version: "1.0.0",
+  lifecycle: "active",
+  category: "domain",
+  description: "Thematic research lifecycle built on graph primitives, worktree workflows, and conviction analytics.",
+  dependencies: [
+    "chat-v1",
+    "epistemic-algorithms-v1",
+    "news-v1",
+    "documents-v1"
+  ],
+  capabilityFlags: [
+    "theme.lifecycle",
+    "belief.question.evidence",
+    "thesis.development",
+    "reporting"
+  ],
+  routeNamespace: {
+    web: [
+      "/(projects)/projects",
+      "/(projects)/projects/[projectId]",
+      "/(projects)/projects/[projectId]/beliefs-v2",
+      "/(projects)/projects/[projectId]/questions",
+      "/(projects)/projects/[projectId]/research",
+      "/(projects)/projects/[projectId]/reports"
+    ],
+    api: ["/api/research/*", "/api/reports/*", "/api/questions/*"]
+  },
+  surfaces: {
+    components: [
+      "components/project/*",
+      "components/belief/*",
+      "components/question/*",
+      "components/research/*",
+      "components/reports/*"
+    ],
+    convex: [
+      "convex/themes.ts",
+      "convex/projects.ts",
+      "convex/thematicWorkflow.ts",
+      "convex/reports.ts"
+    ],
+    tools: [
+      "lib/ai/tools/belief-tools.ts",
+      "lib/ai/tools/question-tools.ts",
+      "lib/ai/tools/navigation-tools.ts"
+    ]
+  },
+  policyProfile: {
+    audiences: ["internal", "lp", "public"],
+    rules: [
+      { resource: "project", actions: ["read", "summarize", "mutate"] },
+      { resource: "node", actions: ["read", "summarize", "mutate"] },
+      { resource: "edge", actions: ["read", "mutate"] },
+      { resource: "report_section", actions: ["read", "summarize", "export"] }
+    ]
+  },
+  dataContract: {
+    requiredNodeTypes: ["theme", "belief", "question", "evidence", "synthesis"],
+    requiredEdgeTypes: ["belongs_to", "relates_to_thesis", "informs", "tests"],
+    requiredTables: [
+      "projects",
+      "epistemicNodes",
+      "epistemicEdges",
+      "reports",
+      "reportSections",
+      "reportTemplates"
+    ],
+    projectionBehavior: "projection_required"
+  },
+  templates: {
+    workflows: ["themes/default-lifecycle", "themes/worktree-thesis-loop"],
+    prompts: [
+      "thematic/extractor",
+      "reports/thematic-long-form/thesis-statement",
+      "reports/thematic-long-form/belief-map"
+    ],
+    reports: ["thematic-long-form", "knowledge-map"],
+    uiLabels: ["theme", "belief", "question", "evidence", "conviction"]
+  },
+  testSuite: {
+    parity: ["themes-v1-parity-against-current"],
+    policy: ["theme-compilation-entitlement-filtering"],
+    contract: ["themes-pack-contract-v1"]
+  },
+  sharedServices: [
+    {
+      service: "knowledge-compiler",
+      mode: "required",
+      contracts: ["knowledge-compiler-v1"]
+    }
+  ]
+});
+
+// src/manifests/user-profiles-v1.ts
+var userProfilesV1Manifest = defineAppPackManifest({
+  key: "user-profiles-v1",
+  name: "User Profiles",
+  version: "1.0.0",
+  lifecycle: "active",
+  category: "identity",
+  description: "Individual cognition and operating profile layer including journey progression, archetypes, and behavioral telemetry.",
+  dependencies: [],
+  capabilityFlags: [
+    "user.profile",
+    "user.journey",
+    "user.analytics",
+    "voice.preferences"
+  ],
+  routeNamespace: {
+    web: ["/(team)/team/[userId]"],
+    api: ["/api/philosophy/get-profile", "/api/mobile/v1/session"]
+  },
+  surfaces: {
+    components: [
+      "components/user/*",
+      "components/philosophy/ArchetypeDisplay.tsx"
+    ],
+    convex: [
+      "convex/users.ts",
+      "convex/userJourney.ts",
+      "convex/userSessions.ts",
+      "convex/userAnalytics.ts"
+    ],
+    tools: []
+  },
+  policyProfile: {
+    audiences: ["internal", "tenant_admin"],
+    rules: [
+      {
+        resource: "user_profile",
+        actions: ["read", "mutate"],
+        notes: "Users can edit self; tenant admins can read broader profiles."
+      },
+      { resource: "project", actions: ["read"] },
+      { resource: "team_analytics", actions: ["read"] }
+    ]
+  },
+  dataContract: {
+    requiredNodeTypes: [],
+    requiredEdgeTypes: [],
+    requiredTables: [
+      "users",
+      "userEpistemicJourney",
+      "userSessions",
+      "investorProfiles",
+      "investorProfileAtoms",
+      "voiceProfiles",
+      "userVoiceSettings",
+      "archetypeHistory"
+    ],
+    projectionBehavior: "none"
+  },
+  templates: {
+    workflows: ["user/profile-synthesis", "user/journey-update"],
+    prompts: ["coaching/user-eval", "philosophy/profile-synthesis"],
+    reports: ["user-profile-summary"],
+    uiLabels: ["profile", "journey", "archetype", "calibration"]
+  },
+  testSuite: {
+    parity: ["user-profile-page-parity"],
+    policy: ["user-profile-self-vs-admin-access"],
+    contract: ["user-profiles-pack-contract-v1"]
+  },
+  sharedServices: [
+    {
+      service: "knowledge-compiler",
+      mode: "required",
+      contracts: ["knowledge-compiler-v1"]
+    }
+  ]
+});
+
+// src/manifests/index.ts
+var allAppPackManifests = [
+  philosophyModeV1Manifest,
+  chatV1Manifest,
+  graphVisualizationV1Manifest,
+  epistemicAlgorithmsV1Manifest,
+  themesV1Manifest,
+  dealsV1Manifest,
+  decisionsV1Manifest,
+  newsV1Manifest,
+  documentsV1Manifest,
+  userProfilesV1Manifest,
+  teamAnalysisV1Manifest,
+  taskManagementV1Manifest
+];
+var manifestKeyPattern = /^[a-z0-9]+(?:-[a-z0-9]+)*-v[0-9]+$/;
+var semverPattern = /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/;
+var appPackManifestSchema = z.object({
+  key: z.string().regex(manifestKeyPattern),
+  name: z.string().min(1),
+  version: z.string().regex(semverPattern),
+  lifecycle: z.enum(["active", "beta", "experimental"]),
+  category: z.enum([
+    "conversation",
+    "research",
+    "graph",
+    "analytics",
+    "workflow",
+    "decision",
+    "news",
+    "documents",
+    "identity",
+    "operations",
+    "domain"
+  ]),
+  description: z.string().min(1),
+  dependencies: z.array(z.string().min(1)),
+  capabilityFlags: z.array(z.string().min(1)),
+  routeNamespace: z.object({
+    web: z.array(z.string().min(1)),
+    api: z.array(z.string().min(1))
+  }),
+  surfaces: z.object({
+    components: z.array(z.string().min(1)),
+    convex: z.array(z.string().min(1)),
+    tools: z.array(z.string().min(1))
+  }),
+  policyProfile: z.object({
+    audiences: z.array(z.string().min(1)).min(1),
+    rules: z.array(
+      z.object({
+        resource: z.enum([
+          "project",
+          "node",
+          "edge",
+          "artifact",
+          "report_section",
+          "tool_action",
+          "task",
+          "user_profile",
+          "team_analytics"
+        ]),
+        actions: z.array(z.enum(["read", "summarize", "export", "mutate", "admin"])).min(1),
+        notes: z.string().optional()
+      })
+    ).min(1)
+  }),
+  dataContract: z.object({
+    requiredNodeTypes: z.array(z.string().min(1)),
+    requiredEdgeTypes: z.array(z.string().min(1)),
+    requiredTables: z.array(z.string().min(1)).min(1),
+    projectionBehavior: z.enum([
+      "none",
+      "inherits_policy",
+      "projection_required"
+    ])
+  }),
+  templates: z.object({
+    workflows: z.array(z.string().min(1)),
+    prompts: z.array(z.string().min(1)),
+    reports: z.array(z.string().min(1)),
+    uiLabels: z.array(z.string().min(1))
+  }),
+  testSuite: z.object({
+    parity: z.array(z.string().min(1)).min(1),
+    policy: z.array(z.string().min(1)).min(1),
+    contract: z.array(z.string().min(1)).min(1)
+  }),
+  sharedServices: z.array(
+    z.object({
+      service: z.enum([
+        "decision-kernel",
+        "knowledge-compiler",
+        "learning-loop"
+      ]),
+      mode: z.enum(["required", "optional"]),
+      contracts: z.array(z.string().min(1)).min(1)
+    })
+  )
+});
+function toIssue2(code, message, path, severity = "error") {
+  return {
+    code,
+    severity,
+    message,
+    path
+  };
+}
+function collectDuplicateValues(values) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const value of values) {
+    counts.set(value, (counts.get(value) ?? 0) + 1);
+  }
+  return [...counts.entries()].filter(([, count]) => count > 1).map(([value]) => value).sort();
+}
+function collectUnknownValues(values, knownValues) {
+  const known = new Set(knownValues);
+  return values.filter((value) => !known.has(value));
+}
+function validateManifestShape(manifest) {
+  const parsed = appPackManifestSchema.safeParse(manifest);
+  if (parsed.success) {
+    return [];
+  }
+  return parsed.error.issues.map(
+    (issue) => toIssue2(
+      "PACK_MANIFEST_SCHEMA_INVALID",
+      issue.message,
+      issue.path.join(".") || "(root)"
+    )
+  );
+}
+function validateManifestUniqueness(manifest) {
+  const issues = [];
+  const duplicateDependencies = collectDuplicateValues(manifest.dependencies);
+  if (duplicateDependencies.length > 0) {
+    issues.push(
+      toIssue2(
+        "PACK_DEPENDENCIES_DUPLICATE",
+        `Duplicate dependencies declared: ${duplicateDependencies.join(", ")}`,
+        "dependencies"
+      )
+    );
+  }
+  if (manifest.dependencies.includes(manifest.key)) {
+    issues.push(
+      toIssue2(
+        "PACK_DEPENDENCY_SELF_REFERENCE",
+        `Pack "${manifest.key}" cannot depend on itself.`,
+        "dependencies"
+      )
+    );
+  }
+  const duplicateCapabilities = collectDuplicateValues(
+    manifest.capabilityFlags
+  );
+  if (duplicateCapabilities.length > 0) {
+    issues.push(
+      toIssue2(
+        "PACK_CAPABILITIES_DUPLICATE",
+        `Duplicate capability flags declared: ${duplicateCapabilities.join(", ")}`,
+        "capabilityFlags"
+      )
+    );
+  }
+  const duplicateWebRoutes = collectDuplicateValues(
+    manifest.routeNamespace.web
+  );
+  if (duplicateWebRoutes.length > 0) {
+    issues.push(
+      toIssue2(
+        "PACK_WEB_ROUTES_DUPLICATE",
+        `Duplicate web routes declared: ${duplicateWebRoutes.join(", ")}`,
+        "routeNamespace.web"
+      )
+    );
+  }
+  const duplicateApiRoutes = collectDuplicateValues(
+    manifest.routeNamespace.api
+  );
+  if (duplicateApiRoutes.length > 0) {
+    issues.push(
+      toIssue2(
+        "PACK_API_ROUTES_DUPLICATE",
+        `Duplicate api routes declared: ${duplicateApiRoutes.join(", ")}`,
+        "routeNamespace.api"
+      )
+    );
+  }
+  const duplicateServices = collectDuplicateValues(
+    manifest.sharedServices.map((integration) => integration.service)
+  );
+  if (duplicateServices.length > 0) {
+    issues.push(
+      toIssue2(
+        "PACK_SHARED_SERVICE_DUPLICATE",
+        `Duplicate shared-service integrations declared: ${duplicateServices.join(", ")}`,
+        "sharedServices"
+      )
+    );
+  }
+  return issues;
+}
+function validateManifestDictionary(manifest, dictionary) {
+  if (!dictionary) {
+    return [];
+  }
+  const issues = [];
+  const unknownNodeTypes = collectUnknownValues(
+    manifest.dataContract.requiredNodeTypes,
+    dictionary.nodeTypes
+  );
+  const unknownEdgeTypes = collectUnknownValues(
+    manifest.dataContract.requiredEdgeTypes,
+    dictionary.edgeTypes
+  );
+  const unknownTables = collectUnknownValues(
+    manifest.dataContract.requiredTables,
+    dictionary.tables
+  );
+  if (unknownNodeTypes.length > 0) {
+    issues.push(
+      toIssue2(
+        "PACK_UNKNOWN_NODE_TYPES",
+        `Unknown required node types: ${unknownNodeTypes.join(", ")}`,
+        "dataContract.requiredNodeTypes"
+      )
+    );
+  }
+  if (unknownEdgeTypes.length > 0) {
+    issues.push(
+      toIssue2(
+        "PACK_UNKNOWN_EDGE_TYPES",
+        `Unknown required edge types: ${unknownEdgeTypes.join(", ")}`,
+        "dataContract.requiredEdgeTypes"
+      )
+    );
+  }
+  if (unknownTables.length > 0) {
+    issues.push(
+      toIssue2(
+        "PACK_UNKNOWN_TABLES",
+        `Unknown required tables: ${unknownTables.join(", ")}`,
+        "dataContract.requiredTables"
+      )
+    );
+  }
+  return issues;
+}
+function validateAppPackManifest(manifest, dictionary) {
+  const issues = [
+    ...validateManifestShape(manifest),
+    ...validateManifestUniqueness(manifest),
+    ...validateManifestDictionary(manifest, dictionary)
+  ];
+  return {
+    manifestKey: manifest.key,
+    valid: issues.every((issue) => issue.severity !== "error"),
+    issues
+  };
+}
+
+// src/namespacePolicy.ts
+var PACK_NAMESPACE_COLLISION_ALLOWLIST = [
+  {
+    surface: "web",
+    namespace: "/(chat)/chat/[id]",
+    allowedPackKeys: ["chat-v1", "philosophy-mode-v1"],
+    rationale: "Philosophy mode extends the chat surface and intentionally shares the chat detail route."
+  },
+  {
+    surface: "web",
+    namespace: "/(projects)/projects",
+    allowedPackKeys: ["deals-v1", "themes-v1"],
+    rationale: "Deals and themes intentionally share the topic index shell mounted under the legacy /projects customer-zero shell."
+  },
+  {
+    surface: "web",
+    namespace: "/(projects)/projects/[projectId]",
+    allowedPackKeys: ["deals-v1", "themes-v1"],
+    rationale: "Deals and themes intentionally share topic detail shell routing while the outer customer-zero shell still uses legacy project path segments."
+  },
+  {
+    surface: "api",
+    namespace: "/api/philosophy/get-profile",
+    allowedPackKeys: ["philosophy-mode-v1", "user-profiles-v1"],
+    rationale: "User profiles and philosophy mode share profile retrieval endpoint for compatibility."
+  },
+  {
+    surface: "api",
+    namespace: "/api/research/*",
+    allowedPackKeys: ["deals-v1", "themes-v1"],
+    rationale: "Deals and themes share research API namespace until productized API gateway split."
+  },
+  {
+    surface: "api",
+    namespace: "/api/reports/*",
+    allowedPackKeys: ["deals-v1", "decisions-v1", "themes-v1"],
+    rationale: "Domain packs intentionally consume shared report compiler endpoints in the same namespace."
+  }
+];
+function toIssue3(code, message, path, severity = "error") {
+  return {
+    code,
+    severity,
+    message,
+    path
+  };
+}
+function normalizeKeySet(values) {
+  return [...new Set(values)].sort().join("|");
+}
+function detectNamespaceCollisions(manifests) {
+  const collisions = [];
+  for (const surface of ["web", "api"]) {
+    const namespaceToPacks = /* @__PURE__ */ new Map();
+    for (const manifest of manifests) {
+      const namespaces = manifest.routeNamespace[surface];
+      for (const namespace of namespaces) {
+        const existing = namespaceToPacks.get(namespace) ?? [];
+        existing.push(manifest.key);
+        namespaceToPacks.set(namespace, existing);
+      }
+    }
+    for (const [namespace, packKeys] of namespaceToPacks.entries()) {
+      if (packKeys.length <= 1) {
+        continue;
+      }
+      collisions.push({
+        surface,
+        namespace,
+        packKeys: [...new Set(packKeys)].sort()
+      });
+    }
+  }
+  return collisions.sort((left, right) => {
+    if (left.surface !== right.surface) {
+      return left.surface.localeCompare(right.surface);
+    }
+    return left.namespace.localeCompare(right.namespace);
+  });
+}
+function validatePackNamespacePolicies(manifests) {
+  const issues = [];
+  const collisions = detectNamespaceCollisions(manifests);
+  const allowlistByKey = /* @__PURE__ */ new Map();
+  for (const entry of PACK_NAMESPACE_COLLISION_ALLOWLIST) {
+    const key = `${entry.surface}:${entry.namespace}`;
+    if (allowlistByKey.has(key)) {
+      issues.push(
+        toIssue3(
+          "PACK_NAMESPACE_ALLOWLIST_DUPLICATE",
+          `Duplicate allowlist entry for ${key}.`,
+          "namespacePolicy.allowlist"
+        )
+      );
+      continue;
+    }
+    allowlistByKey.set(key, entry);
+  }
+  for (const collision of collisions) {
+    const key = `${collision.surface}:${collision.namespace}`;
+    const allowlistEntry = allowlistByKey.get(key);
+    if (!allowlistEntry) {
+      issues.push(
+        toIssue3(
+          "PACK_NAMESPACE_COLLISION_UNAPPROVED",
+          `Unapproved ${collision.surface} namespace collision for "${collision.namespace}" across packs: ${collision.packKeys.join(", ")}`,
+          `namespacePolicy.${collision.surface}`
+        )
+      );
+      continue;
+    }
+    const collidedSet = normalizeKeySet(collision.packKeys);
+    const allowedSet = normalizeKeySet(allowlistEntry.allowedPackKeys);
+    if (collidedSet !== allowedSet) {
+      issues.push(
+        toIssue3(
+          "PACK_NAMESPACE_COLLISION_MISMATCH",
+          `Collision set mismatch for "${collision.namespace}". collided=${collidedSet} allowlist=${allowedSet}`,
+          `namespacePolicy.${collision.surface}`
+        )
+      );
+    }
+  }
+  return issues;
+}
+
+// src/serviceContracts.ts
+function hasSharedService(manifest, service) {
+  return manifest.sharedServices.some(
+    (integration) => integration.service === service
+  );
+}
+function hasDecisionIntegrationSignals(manifest) {
+  if (manifest.category === "decision") {
+    return true;
+  }
+  return manifest.capabilityFlags.some(
+    (flag) => flag.startsWith("decision.") || flag.includes("decision.integration")
+  );
+}
+function hasReportIntegrationSignals(manifest) {
+  if (manifest.templates.reports.length > 0) {
+    return true;
+  }
+  return manifest.routeNamespace.api.some(
+    (namespace) => namespace.includes("/api/reports")
+  );
+}
+function hasLearningIntegrationSignals(manifest) {
+  return manifest.capabilityFlags.some(
+    (flag) => flag.startsWith("learning.") || flag.includes("policy.injection") || flag.includes("adaptive-learning")
+  );
+}
+function validatePackSharedServiceContracts(manifests) {
+  const issues = [];
+  for (const manifest of manifests) {
+    if (hasReportIntegrationSignals(manifest) && !hasSharedService(manifest, "knowledge-compiler")) {
+      issues.push({
+        packKey: manifest.key,
+        service: "knowledge-compiler",
+        severity: "error",
+        code: "PACK_REPORT_SERVICE_MISSING",
+        message: "Pack declares report outputs/routes but is missing knowledge-compiler shared service integration."
+      });
+    }
+    if (hasDecisionIntegrationSignals(manifest) && !hasSharedService(manifest, "decision-kernel")) {
+      issues.push({
+        packKey: manifest.key,
+        service: "decision-kernel",
+        severity: "error",
+        code: "PACK_DECISION_SERVICE_MISSING",
+        message: "Pack declares decision behavior but is missing decision-kernel shared service integration."
+      });
+    }
+    if (hasLearningIntegrationSignals(manifest) && !hasSharedService(manifest, "learning-loop")) {
+      issues.push({
+        packKey: manifest.key,
+        service: "learning-loop",
+        severity: "error",
+        code: "PACK_LEARNING_SERVICE_MISSING",
+        message: "Pack declares adaptive learning behavior but is missing learning-loop shared service integration."
+      });
+    }
+  }
+  return issues;
+}
+
+// src/runtime.ts
+function toIssue4(code, message, path, severity = "error") {
+  return {
+    code,
+    severity,
+    message,
+    path
+  };
+}
+function validateRegistryIdentity(manifests) {
+  const issues = [];
+  const keyCounts = /* @__PURE__ */ new Map();
+  const identityCounts = /* @__PURE__ */ new Map();
+  for (const manifest of manifests) {
+    keyCounts.set(manifest.key, (keyCounts.get(manifest.key) ?? 0) + 1);
+    const identity = `${manifest.key}@${manifest.version}`;
+    identityCounts.set(identity, (identityCounts.get(identity) ?? 0) + 1);
+  }
+  for (const [key, count] of keyCounts.entries()) {
+    if (count > 1) {
+      issues.push(
+        toIssue4(
+          "PACK_KEY_DUPLICATE",
+          `Duplicate pack key registered: ${key}`,
+          "registry.keys"
+        )
+      );
+    }
+  }
+  for (const [identity, count] of identityCounts.entries()) {
+    if (count > 1) {
+      issues.push(
+        toIssue4(
+          "PACK_VERSION_DUPLICATE",
+          `Duplicate pack identity registered: ${identity}`,
+          "registry.versions"
+        )
+      );
+    }
+  }
+  return issues;
+}
+function validatePackRegistry(manifests, dictionary) {
+  const manifestResults = manifests.map(
+    (manifest) => validateAppPackManifest(manifest, dictionary)
+  );
+  const dependencyResult = resolvePackDependencyGraph(manifests);
+  const sharedServiceIssues = validatePackSharedServiceContracts(manifests).map(
+    (issue) => toIssue4(
+      issue.code,
+      `[${issue.packKey}] ${issue.message}`,
+      `sharedServices:${issue.packKey}`,
+      issue.severity
+    )
+  );
+  const namespaceIssues = validatePackNamespacePolicies(manifests);
+  const issues = [
+    ...validateRegistryIdentity(manifests),
+    ...manifestResults.flatMap((result) => result.issues),
+    ...dependencyResult.issues,
+    ...sharedServiceIssues,
+    ...namespaceIssues
+  ];
+  return {
+    valid: issues.every((issue) => issue.severity !== "error"),
+    manifestResults,
+    dependencyOrder: dependencyResult.orderedPackKeys,
+    dependencyClosureByPack: dependencyResult.dependencyClosureByPack,
+    issues
+  };
+}
+
+// src/registry.ts
+var appPackRegistry = allAppPackManifests.reduce(
+  (acc, manifest) => {
+    acc[manifest.key] = manifest;
+    return acc;
+  },
+  {}
+);
+function getAppPackManifest(key) {
+  return appPackRegistry[key] ?? null;
+}
+function listAppPackManifests() {
+  return allAppPackManifests;
+}
+function getDependencyClosure(packKey) {
+  const resolution = resolvePackDependencyGraph(allAppPackManifests);
+  return resolution.dependencyClosureByPack[packKey] ?? [];
+}
+function validateAppPackRegistry(dictionary) {
+  return validatePackRegistry(allAppPackManifests, dictionary);
+}
+function evaluateAppPackEnablement(policy = {}) {
+  return evaluateCatalogEnablement(appPackRegistry, policy);
+}
+
+export { appPackRegistry, evaluateAppPackEnablement, getAppPackManifest, getDependencyClosure, listAppPackManifests, validateAppPackRegistry };
+//# sourceMappingURL=registry.js.map
+//# sourceMappingURL=registry.js.map