@lucern/pack-host 1.0.0 → 1.0.2

package/dist/index.js

@@ -269,12 +269,18 @@ var chatV1Manifest = defineAppPackManifest({
   },
   surfaces: {
     components: [
-      "components/chat/*",
-      "components/chat/sidebars/*",
-      "components/chat/viewers/*"
+      "apps/web/components/lucern/dev/chat-debug-panel.tsx",
+      "apps/web/app/lucern/packs/_components/pack-try-it-panel.tsx"
     ],
-    convex: ["convex/chats.ts", "convex/messages.ts", "convex/chatState.ts"],
-    tools: ["lib/ai/tools/project-tools.ts"]
+    convex: [
+      "packages/reasoning-kernel/src/adapters/events.ts",
+      "services/master-control/convex/tools.ts",
+      "services/master-control/convex/toolAccess.ts"
+    ],
+    tools: [
+      "packages/mcp/src/handlers/functionSurface.ts",
+      "packages/server-core/src/mcp-context-tools.ts"
+    ]
   },
   policyProfile: {
     audiences: ["internal", "lp", "public"],
@@ -291,7 +297,12 @@ var chatV1Manifest = defineAppPackManifest({
   dataContract: {
     requiredNodeTypes: ["belief", "question", "evidence", "theme", "deal"],
     requiredEdgeTypes: ["informs", "answers", "belongs_to"],
-    requiredTables: ["chats", "messages", "chatState", "projects"],
+    requiredTables: [
+      "agentMessages",
+      "platformAgentRuns",
+      "platformAgentRunToolCalls",
+      "epistemicNodes"
+    ],
     projectionBehavior: "inherits_policy"
   },
   templates: {
@@ -333,14 +344,17 @@ var dealsV1Manifest = defineAppPackManifest({
   },
   surfaces: {
     components: [
-      "app/(projects)/projects/page.tsx",
-      "components/project/*",
-      "components/workspace/views/*"
+      "apps/web/app/lucern/tenant/workspaces/page.tsx",
+      "apps/web/app/lucern/tenant/_components/workspaces/*"
+    ],
+    convex: [
+      "packages/reasoning-kernel/src/adapters/topics.ts",
+      "packages/reasoning-kernel/src/adapters/decisions.ts",
+      "services/master-control/convex/workspaces.ts"
     ],
-    convex: ["convex/projects.ts", "convex/epistemicDecisions.ts"],
     tools: [
-      "lib/ai/tools/navigation-tools.ts",
-      "lib/ai/tools/decision-tools.ts"
+      "packages/server-core/src/domain/topics.ts",
+      "packages/server-core/src/domain/worktrees.ts"
     ]
   },
   policyProfile: {
@@ -361,7 +375,7 @@ var dealsV1Manifest = defineAppPackManifest({
       "based_on_belief"
     ],
     requiredTables: [
-      "projects",
+      "topics",
       "epistemicNodes",
       "epistemicEdges",
       "decisionEvents"
@@ -413,11 +427,18 @@ var decisionsV1Manifest = defineAppPackManifest({
     api: ["/api/thesis-audit/*", "/api/reports/*"]
   },
   surfaces: {
-    components: ["app/(projects)/projects/[projectId]/decisions/page.tsx"],
-    convex: ["convex/epistemicDecisions.ts", "convex/convictionEngine.ts"],
+    components: [
+      "apps/web/app/lucern/tenant/policy/page.tsx",
+      "apps/web/app/lucern/mc/policy/page.tsx"
+    ],
+    convex: [
+      "packages/reasoning-kernel/src/adapters/decisions.ts",
+      "packages/reasoning-kernel/src/adapters/questionsConvictionMutations.ts",
+      "packages/reasoning-kernel/src/adapters/beliefs.confidence.ts"
+    ],
     tools: [
-      "lib/ai/tools/decision-tools.ts",
-      "lib/ai/tools/conviction-tools.ts"
+      "packages/mcp/src/handlers/judgments.ts",
+      "packages/server-core/src/policy/index.ts"
     ]
   },
   policyProfile: {
@@ -498,14 +519,19 @@ var documentsV1Manifest = defineAppPackManifest({
     api: ["/api/documents/*", "/api/rag/document", "/api/rag/extract-pdf"]
   },
   surfaces: {
-    components: ["components/documents/*", "components/document/*"],
+    components: [
+      "apps/web/app/lucern/tenant/_components/workspaces/workspace-pack-panel.tsx",
+      "apps/web/app/lucern/packs/_components/pack-detail-page.tsx"
+    ],
     convex: [
-      "convex/projectDocuments.ts",
-      "convex/documents.ts",
-      "convex/documentAnnotations.ts",
-      "convex/projectDocumentsActions.ts"
+      "packages/reasoning-kernel/src/adapters/evidence.ts",
+      "packages/reasoning-kernel/src/adapters/evidenceCreate.ts",
+      "packages/reasoning-kernel/src/adapters/epistemicSources.ts"
     ],
-    tools: ["lib/ai/tools/create-document.ts"]
+    tools: [
+      "packages/server-core/src/domain/sources.ts",
+      "packages/mcp/src/handlers/evidence.ts"
+    ]
   },
   policyProfile: {
     audiences: ["internal", "lp"],
@@ -518,12 +544,7 @@ var documentsV1Manifest = defineAppPackManifest({
   dataContract: {
     requiredNodeTypes: ["source", "excerpt", "evidence", "synthesis"],
     requiredEdgeTypes: ["derived_from", "based_on", "informs"],
-    requiredTables: [
-      "projectDocuments",
-      "projectDocumentsSyncLog",
-      "documentAnnotations",
-      "epistemicNodes"
-    ],
+    requiredTables: ["researchJobs", "epistemicNodes", "epistemicEdges"],
     projectionBehavior: "inherits_policy"
   },
   templates: {
@@ -565,14 +586,19 @@ var epistemicAlgorithmsV1Manifest = defineAppPackManifest({
     api: ["/api/thesis-audit", "/api/graph-explain", "/api/lucern/*"]
   },
   surfaces: {
-    components: ["components/epistemic/*", "components/contradiction/*"],
+    components: [
+      "apps/web/app/lucern/tenant/_components/graph/*",
+      "apps/web/lib/platform/react/components/ContradictionList.ts"
+    ],
     convex: [
-      "convex/contradictions.ts",
-      "convex/convictionEngine.ts",
-      "convex/graphIntelligence.ts",
-      "convex/thesisAuditAgents.ts"
+      "packages/reasoning-kernel/src/adapters/contradictions.ts",
+      "packages/reasoning-kernel/src/adapters/graphIntelligence.ts",
+      "packages/reasoning-kernel/src/adapters/graphAnalysisResults.ts"
     ],
-    tools: ["lib/ai/tools/graph-intelligence-tools.ts"]
+    tools: [
+      "packages/mcp/src/handlers/contradictions.ts",
+      "packages/server-core/src/graph-analysis.ts"
+    ]
   },
   policyProfile: {
     audiences: ["internal", "lp"],
@@ -649,13 +675,17 @@ var graphVisualizationV1Manifest = defineAppPackManifest({
   },
   surfaces: {
     components: [
-      "app/(projects)/projects/[projectId]/graph/components/*",
-      "components/workspace/views/ProjectHomeView.tsx"
+      "apps/web/app/lucern/tenant/_components/graph/*",
+      "apps/web/app/lucern/tenant/graph/page.tsx"
+    ],
+    convex: [
+      "packages/reasoning-kernel/src/adapters/edgesQueries.ts",
+      "packages/reasoning-kernel/src/adapters/nodesQueries.ts",
+      "packages/reasoning-kernel/src/adapters/neo4jQueries.ts"
     ],
-    convex: ["convex/epistemicQueries.ts", "convex/neo4jQueries.ts"],
     tools: [
-      "lib/ai/tools/knowledge-graph-tools.ts",
-      "lib/ai/tools/cypher-tools.ts"
+      "packages/mcp/src/handlers/graph.ts",
+      "packages/server-core/src/mcp-graph-tools.ts"
     ]
   },
   policyProfile: {
@@ -718,14 +748,19 @@ var newsV1Manifest = defineAppPackManifest({
     api: ["/api/news/search", "/api/intelligence/smart-news-search"]
   },
   surfaces: {
-    components: ["components/news/*"],
+    components: [
+      "apps/web/app/lucern/packs/_components/pack-detail-page.tsx",
+      "apps/web/app/lucern/packs/_components/pack-catalog-page.tsx"
+    ],
     convex: [
-      "convex/projectNews.ts",
-      "convex/newsArticles.ts",
-      "convex/newsCurationJobs.ts",
-      "convex/articleCache.ts"
+      "packages/reasoning-kernel/src/adapters/evidence.ts",
+      "packages/reasoning-kernel/src/adapters/epistemicSources.ts",
+      "packages/server-core/src/domain/sources.ts"
     ],
-    tools: ["lib/ai/tools/research-tools.ts"]
+    tools: [
+      "packages/server-core/src/sources.ts",
+      "packages/mcp/src/handlers/evidence.ts"
+    ]
   },
   policyProfile: {
     audiences: ["internal", "lp", "public"],
@@ -738,13 +773,7 @@ var newsV1Manifest = defineAppPackManifest({
   dataContract: {
     requiredNodeTypes: ["source", "evidence", "synthesis", "theme", "deal"],
     requiredEdgeTypes: ["derived_from", "informs", "belongs_to"],
-    requiredTables: [
-      "projectNews",
-      "savedNewsArticles",
-      "newsCurationJobs",
-      "articleCache",
-      "epistemicNodes"
-    ],
+    requiredTables: ["researchJobs", "epistemicNodes", "epistemicEdges"],
     projectionBehavior: "inherits_policy"
   },
   templates: {
@@ -794,15 +823,18 @@ var philosophyModeV1Manifest = defineAppPackManifest({
   },
   surfaces: {
     components: [
-      "components/chat/sidebars/PhilosophyModeSidebar.tsx",
-      "components/philosophy/ArchetypeDisplay.tsx"
+      "apps/web/app/lucern/tenant/_components/people/*",
+      "apps/web/app/lucern/tenant/people/page.tsx"
     ],
     convex: [
-      "convex/philosophy.ts",
-      "convex/philosophyQueries.ts",
-      "convex/projectPhilosophy.ts"
+      "services/master-control/convex/userSessions.ts",
+      "packages/reasoning-kernel/src/adapters/ontologies.ts",
+      "packages/reasoning-kernel/src/adapters/topics.ts"
     ],
-    tools: ["lib/ai/tools/philosophy-tools.ts"]
+    tools: [
+      "packages/server-core/src/domain/ontologies.ts",
+      "packages/mcp/src/handlers/observations.ts"
+    ]
   },
   policyProfile: {
     audiences: ["internal"],
@@ -815,12 +847,7 @@ var philosophyModeV1Manifest = defineAppPackManifest({
   dataContract: {
     requiredNodeTypes: ["belief", "question", "theme"],
     requiredEdgeTypes: ["belongs_to", "relates_to_thesis"],
-    requiredTables: [
-      "marketPhilosophyProfiles",
-      "marketPhilosophyAtoms",
-      "marketPhilosophyContent",
-      "philosophyUploads"
-    ],
+    requiredTables: ["users", "epistemicNodes", "epistemicEdges"],
     projectionBehavior: "inherits_policy"
   },
   templates: {
@@ -846,6 +873,91 @@ var philosophyModeV1Manifest = defineAppPackManifest({
   }
 });
 
+// src/manifests/sprints-v1.ts
+var worktreesV1Manifest = defineAppPackManifest({
+  key: "sprints-v1",
+  name: "Worktrees",
+  version: "1.0.0",
+  lifecycle: "active",
+  category: "workflow",
+  description: "Structured research execution workflow with phases, scoring, and worktree-linked tasks.",
+  dependencies: ["chat-v1"],
+  capabilityFlags: [
+    "worktree.lifecycle",
+    "worktree.phase-navigation",
+    "worktree.scoring",
+    "worktree.workspace"
+  ],
+  routeNamespace: {
+    web: [
+      "/(projects)/topics/[topicId]/worktrees",
+      "/(projects)/topics/[topicId]/worktrees/[worktreeId]"
+    ],
+    api: [
+      "/api/sprint/assess-beliefs",
+      "/api/sprint/generate-thesis",
+      "/api/sprint/refine-thesis",
+      "/api/sprint/welcome"
+    ]
+  },
+  surfaces: {
+    components: [
+      "apps/web/app/lucern/tenant/_components/workspaces/*",
+      "apps/web/app/lucern/tenant/workspaces/page.tsx"
+    ],
+    convex: [
+      "packages/reasoning-kernel/src/adapters/worktrees.ts",
+      "modules/tasks/src/v1/engine/tasks.ts",
+      "packages/reasoning-kernel/src/adapters/questions.ts"
+    ],
+    tools: [
+      "packages/mcp/src/handlers/worktrees.ts",
+      "packages/server-core/src/worktrees.ts"
+    ]
+  },
+  policyProfile: {
+    audiences: ["internal", "lp"],
+    rules: [
+      { resource: "project", actions: ["read", "summarize", "mutate"] },
+      { resource: "task", actions: ["read", "mutate"] },
+      { resource: "tool_action", actions: ["read", "mutate"] }
+    ]
+  },
+  dataContract: {
+    requiredNodeTypes: ["belief", "question", "evidence", "theme"],
+    requiredEdgeTypes: ["tests", "informs", "belongs_to", "depends_on"],
+    requiredTables: [
+      "worktrees",
+      "workflowDefinitions",
+      "workflowStages",
+      "tasks"
+    ],
+    projectionBehavior: "inherits_policy"
+  },
+  templates: {
+    workflows: [
+      "worktree/hypothesis-formation",
+      "worktree/cluster-mapping",
+      "worktree/question-validation"
+    ],
+    prompts: ["worktree/main-system-prompt", "worktree/research-task-planning"],
+    reports: ["sprint_thesis"],
+    uiLabels: ["worktree", "phase", "conviction", "thesis"]
+  },
+  testSuite: {
+    parity: ["worktree-lifecycle-parity"],
+    policy: ["worktree-tool-enforcement"],
+    contract: ["worktrees-pack-contract-v1"]
+  },
+  sharedServices: [
+    {
+      service: "knowledge-compiler",
+      mode: "required",
+      contracts: ["knowledge-compiler-v1"]
+    }
+  ]
+});
+
 // src/manifests/task-management-v1.ts
 var taskManagementV1Manifest = defineAppPackManifest({
   key: "task-management-v1",
@@ -871,13 +983,19 @@ var taskManagementV1Manifest = defineAppPackManifest({
     ]
   },
   surfaces: {
-    components: ["components/task/*"],
+    components: [
+      "apps/web/app/lucern/tenant/tools/page.tsx",
+      "apps/web/app/lucern/tenant/_components/tools/*"
+    ],
     convex: [
-      "convex/tasks.ts",
-      "convex/_taskHelpers.ts",
-      "convex/_taskQueryLogic.ts"
+      "modules/tasks/src/v1/engine/tasks.ts",
+      "modules/tasks/src/v1/engine/tasks.queries.ts",
+      "modules/tasks/src/v1/engine/tasks.mutations.ts"
     ],
-    tools: ["lib/ai/tools/task-tools.ts"]
+    tools: [
+      "packages/mcp/src/handlers/tasks.ts",
+      "packages/server-core/src/tasks.ts"
+    ]
   },
   policyProfile: {
     audiences: ["internal", "lp"],
@@ -891,7 +1009,13 @@ var taskManagementV1Manifest = defineAppPackManifest({
   dataContract: {
     requiredNodeTypes: ["belief", "question", "evidence", "synthesis"],
     requiredEdgeTypes: ["informs", "tests", "belongs_to"],
-    requiredTables: ["tasks", "projects", "epistemicNodes", "epistemicEdges"],
+    requiredTables: [
+      "tasks",
+      "topics",
+      "worktrees",
+      "epistemicNodes",
+      "epistemicEdges"
+    ],
     projectionBehavior: "inherits_policy"
   },
   templates: {
@@ -931,13 +1055,19 @@ var teamAnalysisV1Manifest = defineAppPackManifest({
     api: ["/api/coaching/*"]
   },
   surfaces: {
-    components: ["components/charts/*", "components/coaching/*"],
+    components: [
+      "apps/web/app/lucern/mc/analytics/page.tsx",
+      "apps/web/app/lucern/tenant/_components/people/*"
+    ],
     convex: [
-      "convex/users.ts",
-      "convex/userAnalytics.ts",
-      "convex/projectCards.ts"
+      "services/master-control/convex/identity.ts",
+      "services/master-control/convex/groups.ts",
+      "packages/reasoning-kernel/src/adapters/telemetry.ts"
     ],
-    tools: []
+    tools: [
+      "packages/server-core/src/identity.ts",
+      "packages/mcp/src/handlers/observations.ts"
+    ]
   },
   policyProfile: {
     audiences: ["internal", "tenant_admin"],
@@ -952,13 +1082,10 @@ var teamAnalysisV1Manifest = defineAppPackManifest({
     requiredEdgeTypes: ["informs", "tests"],
     requiredTables: [
       "users",
-      "userEpistemicJourney",
       "epistemicAudit",
-      "proposalEvents",
-      "biSuggestions",
       "beliefConfidence",
       "contradictions",
-      "worktrees",
+      "calibrationScores",
       "tasks"
     ],
     projectionBehavior: "none"
@@ -1016,22 +1143,19 @@ var themesV1Manifest = defineAppPackManifest({
   },
   surfaces: {
     components: [
-      "components/project/*",
-      "components/belief/*",
-      "components/question/*",
-      "components/research/*",
-      "components/reports/*"
+      "apps/web/app/lucern/tenant/_components/graph/*",
+      "apps/web/app/lucern/tenant/_components/workspaces/*"
     ],
     convex: [
-      "convex/themes.ts",
-      "convex/projects.ts",
-      "convex/thematicWorkflow.ts",
-      "convex/reports.ts"
+      "packages/reasoning-kernel/src/adapters/topics.ts",
+      "packages/reasoning-kernel/src/adapters/beliefs.ts",
+      "packages/reasoning-kernel/src/adapters/questions.ts",
+      "packages/reasoning-kernel/src/adapters/evidence.ts"
     ],
     tools: [
-      "lib/ai/tools/belief-tools.ts",
-      "lib/ai/tools/question-tools.ts",
-      "lib/ai/tools/navigation-tools.ts"
+      "packages/mcp/src/handlers/beliefs.ts",
+      "packages/mcp/src/handlers/questions.ts",
+      "packages/mcp/src/handlers/evidence.ts"
     ]
   },
   policyProfile: {
@@ -1047,12 +1171,11 @@ var themesV1Manifest = defineAppPackManifest({
     requiredNodeTypes: ["theme", "belief", "question", "evidence", "synthesis"],
     requiredEdgeTypes: ["belongs_to", "relates_to_thesis", "informs", "tests"],
     requiredTables: [
-      "projects",
+      "topics",
       "epistemicNodes",
       "epistemicEdges",
-      "reports",
-      "reportSections",
-      "reportTemplates"
+      "workflowDefinitions",
+      "workflowStages"
     ],
     projectionBehavior: "projection_required"
   },
@@ -1101,16 +1224,15 @@ var userProfilesV1Manifest = defineAppPackManifest({
   },
   surfaces: {
     components: [
-      "components/user/*",
-      "components/philosophy/ArchetypeDisplay.tsx"
+      "apps/web/app/lucern/tenant/_components/people/*",
+      "apps/web/app/lucern/tenant/people/page.tsx"
     ],
     convex: [
-      "convex/users.ts",
-      "convex/userJourney.ts",
-      "convex/userSessions.ts",
-      "convex/userAnalytics.ts"
+      "services/master-control/convex/identity.ts",
+      "services/master-control/convex/userSessions.ts",
+      "services/master-control/convex/groups.ts"
     ],
-    tools: []
+    tools: ["packages/server-core/src/identity.ts"]
   },
   policyProfile: {
     audiences: ["internal", "tenant_admin"],
@@ -1129,13 +1251,10 @@ var userProfilesV1Manifest = defineAppPackManifest({
     requiredEdgeTypes: [],
     requiredTables: [
       "users",
-      "userEpistemicJourney",
       "userSessions",
-      "investorProfiles",
-      "investorProfileAtoms",
-      "voiceProfiles",
-      "userVoiceSettings",
-      "archetypeHistory"
+      "principals",
+      "principalIdentityAliases",
+      "calibrationScores"
     ],
     projectionBehavior: "none"
   },
@@ -1163,6 +1282,7 @@ var userProfilesV1Manifest = defineAppPackManifest({
 var allAppPackManifests = [
   philosophyModeV1Manifest,
   chatV1Manifest,
+  worktreesV1Manifest,
   graphVisualizationV1Manifest,
   epistemicAlgorithmsV1Manifest,
   themesV1Manifest,
@@ -1767,330 +1887,676 @@ function defineDomainPack(input) {
   };
 }
 
-// src/domain-pack/validation.ts
-function issue(code, message, path, severity = "error") {
-  return { code, severity, message, path };
+// src/domain-pack/authoring.core.ts
+var DOMAIN_PACK_MANIFEST_KIND = "lucern-domain-pack-manifest";
+var CURRENT_MANIFEST_VERSION = "1.0.0";
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
 }
-var KEBAB_CASE = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
-var SEMVER = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
-var SHAPING_QUESTION_TYPES = /* @__PURE__ */ new Set([
-  "validation",
-  "falsification",
-  "assumption_probe",
-  "counterfactual",
-  "scope",
-  "comparison",
-  "mechanism",
-  "general"
-]);
-var RUNTIME_TARGETS = /* @__PURE__ */ new Set(["claude-code", "codex", "hybrid", "portable"]);
-var ONTOLOGY_PROVISION_MODES = /* @__PURE__ */ new Set(["bind", "seed", "extend"]);
-function validateStringArray(values, path, label) {
+function dedupeStrings2(values) {
   if (!values) {
-    return [];
+    return void 0;
   }
-  return values.flatMap((value, index) => {
-    if (!value?.trim()) {
-      return [
-        issue(
-          "INVALID_SHAPING_CONDITION",
-          `${label} must not contain empty strings`,
-          `${path}[${index}]`
-        )
-      ];
-    }
-    return [];
-  });
+  return Array.from(
+    new Set(values.map((value) => value.trim()).filter((value) => value.length))
+  );
 }
-function validateRuntimeTargets(values, path) {
-  const issues = validateStringArray(values, path, "runtimeTargets");
-  for (const [index, value] of (values || []).entries()) {
-    if (!RUNTIME_TARGETS.has(value)) {
-      issues.push(
-        issue(
-          "INVALID_RUNTIME_TARGET",
-          `Unsupported runtime target "${value}"`,
-          `${path}[${index}]`
-        )
-      );
-    }
-  }
-  return issues;
+function normalizeRuntimeTargets2(values) {
+  return values ? dedupeStrings2(values) : void 0;
 }
-function validatePromptBinding(prompt, index) {
-  const path = `operatingSystem.prompts[${index}]`;
-  const issues = [];
-  if (!prompt.promptId?.trim()) {
-    issues.push(
-      issue(
-        "MISSING_PROMPT_ID",
-        "prompt binding requires promptId",
-        `${path}.promptId`
-      )
-    );
-  }
-  if (!prompt.ref?.trim()) {
-    issues.push(
-      issue("MISSING_PROMPT_REF", "prompt binding requires ref", `${path}.ref`)
-    );
+function normalizeFrameworks(frameworks) {
+  if (!frameworks) {
+    return void 0;
   }
-  issues.push(
-    ...validateRuntimeTargets(prompt.runtimeTargets, `${path}.runtimeTargets`)
-  );
-  return issues;
+  return frameworks.map((framework) => ({
+    ...framework,
+    frameworkId: framework.frameworkId.trim(),
+    version: framework.version.trim(),
+    versionConstraint: framework.versionConstraint?.trim(),
+    runtimeTargets: normalizeRuntimeTargets2(framework.runtimeTargets)
+  }));
 }
-function validateToolBinding(tool, index) {
-  const path = `operatingSystem.tools[${index}]`;
-  const issues = [];
-  if (!tool.toolId?.trim()) {
-    issues.push(
-      issue("MISSING_TOOL_ID", "tool binding requires toolId", `${path}.toolId`)
-    );
+function normalizeSchemaExtensions(extensions) {
+  if (!extensions) {
+    return void 0;
   }
-  if (!tool.entrypoint?.trim()) {
-    issues.push(
-      issue(
-        "MISSING_TOOL_ENTRYPOINT",
-        "tool binding requires entrypoint",
-        `${path}.entrypoint`
-      )
-    );
+  return extensions.map((extension) => ({
+    ...extension,
+    extensionId: extension.extensionId.trim(),
+    target: extension.target,
+    description: extension.description.trim(),
+    version: extension.version.trim(),
+    extends: extension.extends?.trim()
+  }));
+}
+function normalizeOntologyExtensions(extensions) {
+  if (!extensions) {
+    return void 0;
   }
-  issues.push(
-    ...validateRuntimeTargets(tool.runtimeTargets, `${path}.runtimeTargets`)
-  );
-  return issues;
+  return extensions.map((extension) => ({
+    ...extension,
+    extensionId: extension.extensionId.trim(),
+    ontologyId: extension.ontologyId.trim(),
+    baseVersionConstraint: extension.baseVersionConstraint.trim(),
+    entityTypes: extension.entityTypes?.map((entityType) => ({
+      ...entityType,
+      value: entityType.value.trim(),
+      label: entityType.label.trim(),
+      description: entityType.description?.trim(),
+      subtypes: dedupeStrings2(entityType.subtypes)
+    })),
+    edgeTypes: extension.edgeTypes?.map((edgeType) => ({
+      ...edgeType,
+      value: edgeType.value.trim(),
+      label: edgeType.label.trim(),
+      description: edgeType.description?.trim(),
+      sourceTypes: dedupeStrings2(edgeType.sourceTypes),
+      targetTypes: dedupeStrings2(edgeType.targetTypes)
+    }))
+  }));
 }
-function validateSetupAsset(asset, index) {
-  const path = `operatingSystem.setupAssets[${index}]`;
-  const issues = [];
-  if (!asset.assetId?.trim()) {
-    issues.push(
-      issue(
-        "MISSING_SETUP_ASSET_ID",
-        "setup asset requires assetId",
-        `${path}.assetId`
-      )
-    );
+function normalizeLineage(lineage) {
+  if (!lineage) {
+    return { mode: "root" };
   }
-  if (!asset.path?.trim()) {
-    issues.push(
-      issue(
-        "MISSING_SETUP_ASSET_PATH",
-        "setup asset requires path",
-        `${path}.path`
-      )
-    );
+  return {
+    mode: lineage.mode,
+    parentPackId: lineage.parentPackId?.trim(),
+    parentVersion: lineage.parentVersion?.trim(),
+    parentManifestDigest: lineage.parentManifestDigest?.trim(),
+    supersedesPackId: lineage.supersedesPackId?.trim(),
+    notes: lineage.notes?.trim()
+  };
+}
+function normalizeMetadata(metadata) {
+  if (!metadata) {
+    return void 0;
   }
-  issues.push(
-    ...validateRuntimeTargets(asset.runtimeTargets, `${path}.runtimeTargets`)
-  );
-  return issues;
+  return {
+    description: metadata.description?.trim(),
+    owner: metadata.owner?.trim(),
+    tags: dedupeStrings2(metadata.tags)
+  };
 }
-function validateQuestionTemplate(template, index) {
-  const path = `inquiryShaping.questionTemplates[${index}]`;
-  const issues = [];
-  if (!template.templateId?.trim()) {
-    issues.push(
-      issue(
-        "MISSING_SHAPING_TEMPLATE_ID",
-        "question template requires templateId",
-        `${path}.templateId`
-      )
-    );
+function toDomainPack(pack) {
+  return defineDomainPack(pack);
+}
+function defineDomainPackAuthoringManifest(input) {
+  return {
+    kind: input.kind ?? DOMAIN_PACK_MANIFEST_KIND,
+    manifestVersion: input.manifestVersion?.trim() || CURRENT_MANIFEST_VERSION,
+    pack: toDomainPack(input.pack),
+    frameworks: normalizeFrameworks(input.frameworks),
+    schemaExtensions: normalizeSchemaExtensions(input.schemaExtensions),
+    ontologyExtensions: normalizeOntologyExtensions(input.ontologyExtensions),
+    lineage: normalizeLineage(input.lineage),
+    metadata: normalizeMetadata(input.metadata)
+  };
+}
+function countManifestArtifacts(manifest) {
+  if (!manifest) {
+    return {
+      topicRoots: 0,
+      workflows: 0,
+      gates: 0,
+      artifacts: 0,
+      roles: 0,
+      prompts: 0,
+      tools: 0,
+      setupAssets: 0,
+      installProfiles: 0,
+      frameworks: 0,
+      schemaExtensions: 0,
+      ontologyExtensions: 0
+    };
   }
-  if (!template.template?.trim()) {
-    issues.push(
-      issue(
-        "MISSING_SHAPING_TEMPLATE",
-        "question template requires template text",
-        `${path}.template`
-      )
-    );
+  return {
+    topicRoots: manifest.pack.topicRoots.length,
+    workflows: manifest.pack.workflows.length,
+    gates: manifest.pack.gates.length,
+    artifacts: manifest.pack.artifacts.length,
+    roles: manifest.pack.roles.length,
+    prompts: manifest.pack.operatingSystem?.prompts?.length ?? 0,
+    tools: manifest.pack.operatingSystem?.tools?.length ?? 0,
+    setupAssets: manifest.pack.operatingSystem?.setupAssets?.length ?? 0,
+    installProfiles: manifest.pack.operatingSystem?.installProfiles?.length ?? 0,
+    frameworks: manifest.frameworks?.length ?? 0,
+    schemaExtensions: manifest.schemaExtensions?.length ?? 0,
+    ontologyExtensions: manifest.ontologyExtensions?.length ?? 0
+  };
+}
+function sortJsonValue(value) {
+  if (Array.isArray(value)) {
+    return value.map(sortJsonValue);
   }
-  if (!SHAPING_QUESTION_TYPES.has(template.questionType)) {
-    issues.push(
-      issue(
-        "INVALID_SHAPING_QUESTION_TYPE",
-        `Unsupported questionType "${template.questionType}"`,
-        `${path}.questionType`
-      )
+  if (isPlainObject(value)) {
+    return Object.fromEntries(
+      Object.entries(value).filter(([, entryValue]) => entryValue !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([key, entryValue]) => [key, sortJsonValue(entryValue)])
     );
   }
-  issues.push(
-    ...validateStringArray(
-      template.whenObjectiveIncludes,
-      `${path}.whenObjectiveIncludes`,
-      "whenObjectiveIncludes"
-    )
-  );
-  return issues;
+  return value;
 }
-function validateTaskTemplate(template, index) {
-  const path = `inquiryShaping.taskTemplates[${index}]`;
-  const issues = [];
-  if (!template.templateId?.trim()) {
-    issues.push(
-      issue(
-        "MISSING_TASK_GENERATOR_ID",
-        "task template requires templateId",
-        `${path}.templateId`
-      )
-    );
+function toYamlScalar(value) {
+  if (value === null) {
+    return "null";
   }
-  if (!template.title?.trim()) {
-    issues.push(
-      issue(
-        "MISSING_TASK_GENERATOR_TITLE",
-        "task template requires title",
-        `${path}.title`
-      )
-    );
+  if (typeof value === "boolean" || typeof value === "number") {
+    return String(value);
   }
-  issues.push(
-    ...validateStringArray(
-      template.whenObjectiveIncludes,
-      `${path}.whenObjectiveIncludes`,
-      "whenObjectiveIncludes"
-    )
-  );
-  issues.push(
-    ...validateStringArray(
-      template.whenQuestionTypes,
-      `${path}.whenQuestionTypes`,
-      "whenQuestionTypes"
-    )
-  );
-  for (const [questionTypeIndex, questionType] of (template.whenQuestionTypes || []).entries()) {
-    if (!SHAPING_QUESTION_TYPES.has(questionType)) {
-      issues.push(
-        issue(
-          "INVALID_TASK_GENERATOR_QUESTION_TYPE",
-          `Unsupported whenQuestionTypes value "${questionType}"`,
-          `${path}.whenQuestionTypes[${questionTypeIndex}]`
-        )
-      );
+  return JSON.stringify(String(value));
+}
+function renderYaml(value, indent = 0) {
+  const prefix = " ".repeat(indent);
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return [`${prefix}[]`];
+    }
+    return value.flatMap((entry) => {
+      if (Array.isArray(entry) || isPlainObject(entry)) {
+        return [`${prefix}-`, ...renderYaml(entry, indent + 2)];
+      }
+      return [`${prefix}- ${toYamlScalar(entry)}`];
+    });
+  }
+  if (isPlainObject(value)) {
+    const entries = Object.entries(value);
+    if (entries.length === 0) {
+      return [`${prefix}{}`];
     }
+    return entries.flatMap(([key, entryValue]) => {
+      if (entryValue === void 0) {
+        return [];
+      }
+      if (Array.isArray(entryValue)) {
+        if (entryValue.length === 0) {
+          return [`${prefix}${key}: []`];
+        }
+        return [`${prefix}${key}:`, ...renderYaml(entryValue, indent + 2)];
+      }
+      if (isPlainObject(entryValue)) {
+        if (Object.keys(entryValue).length === 0) {
+          return [`${prefix}${key}: {}`];
+        }
+        return [`${prefix}${key}:`, ...renderYaml(entryValue, indent + 2)];
+      }
+      return [`${prefix}${key}: ${toYamlScalar(entryValue)}`];
+    });
   }
-  return issues;
+  return [`${prefix}${toYamlScalar(value)}`];
 }
-function validateFrameworkHint(hint, index) {
-  const path = `inquiryShaping.frameworkHints[${index}]`;
-  const issues = [];
-  if (!hint.frameworkName?.trim()) {
-    issues.push(
-      issue(
-        "MISSING_FRAMEWORK_HOOK_NAME",
-        "framework hint requires frameworkName",
-        `${path}.frameworkName`
-      )
-    );
+function countIndent(line) {
+  return line.length - line.trimStart().length;
+}
+function parseYamlScalar(raw) {
+  const value = raw.trim();
+  if (value === "null") {
+    return null;
   }
-  if (hint.boost != null && (!Number.isFinite(hint.boost) || hint.boost < 0)) {
-    issues.push(
-      issue(
-        "INVALID_FRAMEWORK_HOOK_BOOST",
-        "framework hint boost must be a non-negative number",
-        `${path}.boost`
-      )
-    );
+  if (value === "true") {
+    return true;
   }
-  issues.push(
-    ...validateStringArray(
-      hint.whenObjectiveIncludes,
-      `${path}.whenObjectiveIncludes`,
-      "whenObjectiveIncludes"
-    )
-  );
-  issues.push(
-    ...validateStringArray(
-      hint.whenQuestionTypes,
-      `${path}.whenQuestionTypes`,
-      "whenQuestionTypes"
-    )
-  );
-  for (const [questionTypeIndex, questionType] of (hint.whenQuestionTypes || []).entries()) {
-    if (!SHAPING_QUESTION_TYPES.has(questionType)) {
-      issues.push(
-        issue(
-          "INVALID_FRAMEWORK_HOOK_QUESTION_TYPE",
-          `Unsupported whenQuestionTypes value "${questionType}"`,
-          `${path}.whenQuestionTypes[${questionTypeIndex}]`
-        )
-      );
+  if (value === "false") {
+    return false;
+  }
+  if (/^-?\d+(?:\.\d+)?$/.test(value)) {
+    return Number(value);
+  }
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    if (value.startsWith("'")) {
+      return value.slice(1, -1).replace(/''/g, "'");
     }
+    return JSON.parse(value);
   }
-  return issues;
+  if (value === "[]") {
+    return [];
+  }
+  if (value === "{}") {
+    return {};
+  }
+  return value;
 }
-function validateTopicTemplate(template, index, knownTopicSlugs) {
-  const path = `operatingSystem.topicTemplates[${index}]`;
+function splitYamlKeyValue(trimmed) {
+  const separatorIndex = trimmed.indexOf(":");
+  if (separatorIndex === -1) {
+    throw new Error(`Invalid YAML mapping entry: ${trimmed}`);
+  }
+  const key = trimmed.slice(0, separatorIndex).trim();
+  const value = trimmed.slice(separatorIndex + 1).trim();
+  return { key, value: value.length ? value : null };
+}
+function parseYamlDocument(text) {
+  const rawLines = text.replace(/\r\n/g, "\n").split("\n").map((line) => line.replace(/\t/g, "  "));
+  const lines = rawLines.filter((line) => {
+    const trimmed = line.trim();
+    return trimmed.length > 0 && trimmed !== "---" && trimmed !== "...";
+  });
+  let index = 0;
+  function parseBlock(indent) {
+    if (index >= lines.length) {
+      return {};
+    }
+    const currentLine = lines[index];
+    const currentIndent = countIndent(currentLine);
+    if (currentIndent < indent) {
+      return {};
+    }
+    if (currentLine.trimStart().startsWith("-")) {
+      return parseArray(indent);
+    }
+    return parseObject(indent);
+  }
+  function parseArray(indent) {
+    const items = [];
+    while (index < lines.length) {
+      const line = lines[index];
+      const currentIndent = countIndent(line);
+      if (currentIndent < indent) {
+        break;
+      }
+      if (currentIndent !== indent) {
+        throw new Error(`Invalid YAML indentation near: ${line.trim()}`);
+      }
+      const trimmed = line.trimStart();
+      if (!trimmed.startsWith("-")) {
+        break;
+      }
+      const rest = trimmed.slice(1).trimStart();
+      index += 1;
+      if (!rest.length) {
+        items.push(parseBlock(indent + 2));
+        continue;
+      }
+      items.push(parseYamlScalar(rest));
+    }
+    return items;
+  }
+  function parseObject(indent) {
+    const objectValue = {};
+    while (index < lines.length) {
+      const line = lines[index];
+      const currentIndent = countIndent(line);
+      if (currentIndent < indent) {
+        break;
+      }
+      if (currentIndent !== indent) {
+        throw new Error(`Invalid YAML indentation near: ${line.trim()}`);
+      }
+      const trimmed = line.trim();
+      if (trimmed.startsWith("-")) {
+        break;
+      }
+      const { key, value } = splitYamlKeyValue(trimmed);
+      index += 1;
+      objectValue[key] = value === null ? parseBlock(indent + 2) : parseYamlScalar(value);
+    }
+    return objectValue;
+  }
+  return parseBlock(0);
+}
+function detectDomainPackManifestFormat(source, explicitFormat) {
+  if (explicitFormat) {
+    return explicitFormat;
+  }
+  const trimmed = source.trim();
+  if (trimmed.startsWith("{")) {
+    return "json";
+  }
+  return "yaml";
+}
+function serializeDomainPackAuthoringManifest(manifest, format = "json") {
+  const canonicalValue = sortJsonValue(manifest);
+  if (format === "json") {
+    return `${JSON.stringify(canonicalValue, null, 2)}
+`;
+  }
+  return `${renderYaml(canonicalValue).join("\n")}
+`;
+}
+function parseDomainPackAuthoringManifest(source, format) {
+  const detectedFormat = detectDomainPackManifestFormat(source, format);
+  const parsed = detectedFormat === "json" ? JSON.parse(source) : parseYamlDocument(source);
+  if (!isPlainObject(parsed)) {
+    throw new Error("Domain pack manifest must parse to an object.");
+  }
+  if (!("pack" in parsed)) {
+    throw new Error("Domain pack manifest requires a top-level pack object.");
+  }
+  return defineDomainPackAuthoringManifest({
+    kind: parsed.kind,
+    manifestVersion: parsed.manifestVersion,
+    pack: parsed.pack,
+    frameworks: parsed.frameworks,
+    schemaExtensions: parsed.schemaExtensions,
+    ontologyExtensions: parsed.ontologyExtensions,
+    lineage: parsed.lineage,
+    metadata: parsed.metadata
+  });
+}
+
+// src/domain-pack/validation.ts
+function issue(code, message, path, severity = "error") {
+  return { code, severity, message, path };
+}
+var KEBAB_CASE = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
+var SEMVER = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+var SHAPING_QUESTION_TYPES = /* @__PURE__ */ new Set([
+  "validation",
+  "falsification",
+  "assumption_probe",
+  "counterfactual",
+  "scope",
+  "comparison",
+  "mechanism",
+  "general"
+]);
+var RUNTIME_TARGETS = /* @__PURE__ */ new Set(["claude-code", "codex", "hybrid", "portable"]);
+var ONTOLOGY_PROVISION_MODES = /* @__PURE__ */ new Set(["bind", "seed", "extend"]);
+function validateStringArray(values, path, label) {
+  if (!values) {
+    return [];
+  }
+  return values.flatMap((value, index) => {
+    if (!value?.trim()) {
+      return [
+        issue(
+          "INVALID_SHAPING_CONDITION",
+          `${label} must not contain empty strings`,
+          `${path}[${index}]`
+        )
+      ];
+    }
+    return [];
+  });
+}
+function validateRuntimeTargets(values, path) {
+  const issues = validateStringArray(values, path, "runtimeTargets");
+  for (const [index, value] of (values || []).entries()) {
+    if (!RUNTIME_TARGETS.has(value)) {
+      issues.push(
+        issue(
+          "INVALID_RUNTIME_TARGET",
+          `Unsupported runtime target "${value}"`,
+          `${path}[${index}]`
+        )
+      );
+    }
+  }
+  return issues;
+}
+function validatePromptBinding(prompt, index) {
+  const path = `operatingSystem.prompts[${index}]`;
   const issues = [];
-  if (!template.slug?.trim()) {
+  if (!prompt.promptId?.trim()) {
     issues.push(
       issue(
-        "MISSING_TOPIC_TEMPLATE_SLUG",
-        "topic template requires slug",
-        `${path}.slug`
+        "MISSING_PROMPT_ID",
+        "prompt binding requires promptId",
+        `${path}.promptId`
       )
     );
-  } else if (!KEBAB_CASE.test(template.slug)) {
+  }
+  if (!prompt.ref?.trim()) {
     issues.push(
-      issue(
-        "INVALID_TOPIC_TEMPLATE_SLUG",
-        `topic template slug "${template.slug}" must be kebab-case`,
-        `${path}.slug`
-      )
+      issue("MISSING_PROMPT_REF", "prompt binding requires ref", `${path}.ref`)
     );
   }
-  if (!template.name?.trim()) {
+  issues.push(
+    ...validateRuntimeTargets(prompt.runtimeTargets, `${path}.runtimeTargets`)
+  );
+  return issues;
+}
+function validateToolBinding(tool, index) {
+  const path = `operatingSystem.tools[${index}]`;
+  const issues = [];
+  if (!tool.toolId?.trim()) {
+    issues.push(
+      issue("MISSING_TOOL_ID", "tool binding requires toolId", `${path}.toolId`)
+    );
+  }
+  if (!tool.entrypoint?.trim()) {
     issues.push(
       issue(
-        "MISSING_TOPIC_TEMPLATE_NAME",
-        "topic template requires name",
-        `${path}.name`
+        "MISSING_TOOL_ENTRYPOINT",
+        "tool binding requires entrypoint",
+        `${path}.entrypoint`
       )
     );
   }
-  if (!template.description?.trim()) {
+  issues.push(
+    ...validateRuntimeTargets(tool.runtimeTargets, `${path}.runtimeTargets`)
+  );
+  return issues;
+}
+function validateSetupAsset(asset, index) {
+  const path = `operatingSystem.setupAssets[${index}]`;
+  const issues = [];
+  if (!asset.assetId?.trim()) {
     issues.push(
       issue(
-        "MISSING_TOPIC_TEMPLATE_DESCRIPTION",
-        "topic template requires description",
-        `${path}.description`
+        "MISSING_SETUP_ASSET_ID",
+        "setup asset requires assetId",
+        `${path}.assetId`
       )
     );
   }
-  if (template.parentSlug && !knownTopicSlugs.has(template.parentSlug)) {
+  if (!asset.path?.trim()) {
     issues.push(
       issue(
-        "UNKNOWN_TOPIC_PARENT",
-        `topic template references unknown parent "${template.parentSlug}"`,
-        `${path}.parentSlug`
+        "MISSING_SETUP_ASSET_PATH",
+        "setup asset requires path",
+        `${path}.path`
       )
     );
   }
+  issues.push(
+    ...validateRuntimeTargets(asset.runtimeTargets, `${path}.runtimeTargets`)
+  );
   return issues;
 }
-function validateInstallProfile(profile, index, knownPromptIds, knownToolIds, knownAssetIds, knownTopicSlugs) {
-  const path = `operatingSystem.installProfiles[${index}]`;
+function validateQuestionTemplate(template, index) {
+  const path = `inquiryShaping.questionTemplates[${index}]`;
   const issues = [];
-  if (!profile.profileId?.trim()) {
+  if (!template.templateId?.trim()) {
     issues.push(
       issue(
-        "MISSING_INSTALL_PROFILE_ID",
-        "install profile requires profileId",
-        `${path}.profileId`
+        "MISSING_SHAPING_TEMPLATE_ID",
+        "question template requires templateId",
+        `${path}.templateId`
       )
     );
   }
-  if (!profile.name?.trim()) {
+  if (!template.template?.trim()) {
     issues.push(
       issue(
-        "MISSING_INSTALL_PROFILE_NAME",
-        "install profile requires name",
-        `${path}.name`
-      )
-    );
+        "MISSING_SHAPING_TEMPLATE",
+        "question template requires template text",
+        `${path}.template`
+      )
+    );
+  }
+  if (!SHAPING_QUESTION_TYPES.has(template.questionType)) {
+    issues.push(
+      issue(
+        "INVALID_SHAPING_QUESTION_TYPE",
+        `Unsupported questionType "${template.questionType}"`,
+        `${path}.questionType`
+      )
+    );
+  }
+  issues.push(
+    ...validateStringArray(
+      template.whenObjectiveIncludes,
+      `${path}.whenObjectiveIncludes`,
+      "whenObjectiveIncludes"
+    )
+  );
+  return issues;
+}
+function validateTaskTemplate(template, index) {
+  const path = `inquiryShaping.taskTemplates[${index}]`;
+  const issues = [];
+  if (!template.templateId?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_TASK_GENERATOR_ID",
+        "task template requires templateId",
+        `${path}.templateId`
+      )
+    );
+  }
+  if (!template.title?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_TASK_GENERATOR_TITLE",
+        "task template requires title",
+        `${path}.title`
+      )
+    );
+  }
+  issues.push(
+    ...validateStringArray(
+      template.whenObjectiveIncludes,
+      `${path}.whenObjectiveIncludes`,
+      "whenObjectiveIncludes"
+    )
+  );
+  issues.push(
+    ...validateStringArray(
+      template.whenQuestionTypes,
+      `${path}.whenQuestionTypes`,
+      "whenQuestionTypes"
+    )
+  );
+  for (const [questionTypeIndex, questionType] of (template.whenQuestionTypes || []).entries()) {
+    if (!SHAPING_QUESTION_TYPES.has(questionType)) {
+      issues.push(
+        issue(
+          "INVALID_TASK_GENERATOR_QUESTION_TYPE",
+          `Unsupported whenQuestionTypes value "${questionType}"`,
+          `${path}.whenQuestionTypes[${questionTypeIndex}]`
+        )
+      );
+    }
+  }
+  return issues;
+}
+function validateFrameworkHint(hint, index) {
+  const path = `inquiryShaping.frameworkHints[${index}]`;
+  const issues = [];
+  if (!hint.frameworkName?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_FRAMEWORK_HOOK_NAME",
+        "framework hint requires frameworkName",
+        `${path}.frameworkName`
+      )
+    );
+  }
+  if (hint.boost != null && (!Number.isFinite(hint.boost) || hint.boost < 0)) {
+    issues.push(
+      issue(
+        "INVALID_FRAMEWORK_HOOK_BOOST",
+        "framework hint boost must be a non-negative number",
+        `${path}.boost`
+      )
+    );
+  }
+  issues.push(
+    ...validateStringArray(
+      hint.whenObjectiveIncludes,
+      `${path}.whenObjectiveIncludes`,
+      "whenObjectiveIncludes"
+    )
+  );
+  issues.push(
+    ...validateStringArray(
+      hint.whenQuestionTypes,
+      `${path}.whenQuestionTypes`,
+      "whenQuestionTypes"
+    )
+  );
+  for (const [questionTypeIndex, questionType] of (hint.whenQuestionTypes || []).entries()) {
+    if (!SHAPING_QUESTION_TYPES.has(questionType)) {
+      issues.push(
+        issue(
+          "INVALID_FRAMEWORK_HOOK_QUESTION_TYPE",
+          `Unsupported whenQuestionTypes value "${questionType}"`,
+          `${path}.whenQuestionTypes[${questionTypeIndex}]`
+        )
+      );
+    }
+  }
+  return issues;
+}
+function validateTopicTemplate(template, index, knownTopicSlugs) {
+  const path = `operatingSystem.topicTemplates[${index}]`;
+  const issues = [];
+  if (!template.slug?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_TOPIC_TEMPLATE_SLUG",
+        "topic template requires slug",
+        `${path}.slug`
+      )
+    );
+  } else if (!KEBAB_CASE.test(template.slug)) {
+    issues.push(
+      issue(
+        "INVALID_TOPIC_TEMPLATE_SLUG",
+        `topic template slug "${template.slug}" must be kebab-case`,
+        `${path}.slug`
+      )
+    );
+  }
+  if (!template.name?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_TOPIC_TEMPLATE_NAME",
+        "topic template requires name",
+        `${path}.name`
+      )
+    );
+  }
+  if (!template.description?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_TOPIC_TEMPLATE_DESCRIPTION",
+        "topic template requires description",
+        `${path}.description`
+      )
+    );
+  }
+  if (template.parentSlug && !knownTopicSlugs.has(template.parentSlug)) {
+    issues.push(
+      issue(
+        "UNKNOWN_TOPIC_PARENT",
+        `topic template references unknown parent "${template.parentSlug}"`,
+        `${path}.parentSlug`
+      )
+    );
+  }
+  return issues;
+}
+function validateInstallProfile(profile, index, knownPromptIds, knownToolIds, knownAssetIds, knownTopicSlugs) {
+  const path = `operatingSystem.installProfiles[${index}]`;
+  const issues = [];
+  if (!profile.profileId?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_INSTALL_PROFILE_ID",
+        "install profile requires profileId",
+        `${path}.profileId`
+      )
+    );
+  }
+  if (!profile.name?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_INSTALL_PROFILE_NAME",
+        "install profile requires name",
+        `${path}.name`
+      )
+    );
   }
   if (!profile.description?.trim()) {
     issues.push(
@@ -2539,16 +3005,18 @@ function validateDomainPack(pack) {
   };
 }
 
-// src/domain-pack/authoring.ts
-var DOMAIN_PACK_MANIFEST_KIND = "lucern-domain-pack-manifest";
-var CURRENT_MANIFEST_VERSION = "1.0.0";
+// src/domain-pack/authoring.validation.ts
 var KEBAB_CASE2 = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
 var SEMVER2 = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
 var LEGACY_PUBLIC_KEYS = /* @__PURE__ */ new Set([
   "project",
   "projects",
   "projectId",
-  "projectIds"
+  "projectIds",
+  "sprint",
+  "sprints",
+  "sprintId",
+  "sprintIds"
 ]);
 var SCHEMA_EXTENSION_TARGETS = /* @__PURE__ */ new Set([
   "artifact",
@@ -2589,435 +3057,122 @@ function emptyCounts() {
     ontologyExtensions: 0
   };
 }
-function isPlainObject(value) {
+function isPlainObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
 }
 function describeParseFailure(error) {
   return error instanceof Error ? error.message : "Manifest parse failed.";
 }
-function dedupeStrings2(values) {
-  if (!values) {
-    return void 0;
-  }
-  return Array.from(
-    new Set(values.map((value) => value.trim()).filter((value) => value.length))
-  );
-}
-function normalizeRuntimeTargets2(values) {
-  return values ? dedupeStrings2(values) : void 0;
+function asToolDefinition(tool) {
+  return tool;
 }
-function normalizeFrameworks(frameworks) {
-  if (!frameworks) {
-    return void 0;
+function detectDomainPackManifestFormat2(source, explicitFormat) {
+  if (explicitFormat) {
+    return explicitFormat;
   }
-  return frameworks.map((framework) => ({
-    ...framework,
-    frameworkId: framework.frameworkId.trim(),
-    version: framework.version.trim(),
-    versionConstraint: framework.versionConstraint?.trim(),
-    runtimeTargets: normalizeRuntimeTargets2(framework.runtimeTargets)
-  }));
-}
-function normalizeSchemaExtensions(extensions) {
-  if (!extensions) {
-    return void 0;
+  const trimmed = source.trim();
+  if (trimmed.startsWith("{")) {
+    return "json";
   }
-  return extensions.map((extension) => ({
-    ...extension,
-    extensionId: extension.extensionId.trim(),
-    target: extension.target,
-    description: extension.description.trim(),
-    version: extension.version.trim(),
-    extends: extension.extends?.trim()
-  }));
+  return "yaml";
 }
-function normalizeOntologyExtensions(extensions) {
-  if (!extensions) {
-    return void 0;
+function validateFrameworks(frameworks) {
+  if (!frameworks) {
+    return [];
   }
-  return extensions.map((extension) => ({
-    ...extension,
-    extensionId: extension.extensionId.trim(),
-    ontologyId: extension.ontologyId.trim(),
-    baseVersionConstraint: extension.baseVersionConstraint.trim(),
-    entityTypes: extension.entityTypes?.map((entityType) => ({
-      ...entityType,
-      value: entityType.value.trim(),
-      label: entityType.label.trim(),
-      description: entityType.description?.trim(),
-      subtypes: dedupeStrings2(entityType.subtypes)
-    })),
-    edgeTypes: extension.edgeTypes?.map((edgeType) => ({
-      ...edgeType,
-      value: edgeType.value.trim(),
-      label: edgeType.label.trim(),
-      description: edgeType.description?.trim(),
-      sourceTypes: dedupeStrings2(edgeType.sourceTypes),
-      targetTypes: dedupeStrings2(edgeType.targetTypes)
-    }))
-  }));
-}
-function normalizeLineage(lineage) {
-  if (!lineage) {
-    return { mode: "root" };
-  }
-  return {
-    mode: lineage.mode,
-    parentPackId: lineage.parentPackId?.trim(),
-    parentVersion: lineage.parentVersion?.trim(),
-    parentManifestDigest: lineage.parentManifestDigest?.trim(),
-    supersedesPackId: lineage.supersedesPackId?.trim(),
-    notes: lineage.notes?.trim()
-  };
-}
-function normalizeMetadata(metadata) {
-  if (!metadata) {
-    return void 0;
-  }
-  return {
-    description: metadata.description?.trim(),
-    owner: metadata.owner?.trim(),
-    tags: dedupeStrings2(metadata.tags)
-  };
-}
-function toDomainPack(pack) {
-  return defineDomainPack(pack);
-}
-function defineDomainPackAuthoringManifest(input) {
-  return {
-    kind: input.kind ?? DOMAIN_PACK_MANIFEST_KIND,
-    manifestVersion: input.manifestVersion?.trim() || CURRENT_MANIFEST_VERSION,
-    pack: toDomainPack(input.pack),
-    frameworks: normalizeFrameworks(input.frameworks),
-    schemaExtensions: normalizeSchemaExtensions(input.schemaExtensions),
-    ontologyExtensions: normalizeOntologyExtensions(input.ontologyExtensions),
-    lineage: normalizeLineage(input.lineage),
-    metadata: normalizeMetadata(input.metadata)
-  };
-}
-function countManifestArtifacts(manifest) {
-  if (!manifest) {
-    return emptyCounts();
-  }
-  return {
-    topicRoots: manifest.pack.topicRoots.length,
-    workflows: manifest.pack.workflows.length,
-    gates: manifest.pack.gates.length,
-    artifacts: manifest.pack.artifacts.length,
-    roles: manifest.pack.roles.length,
-    prompts: manifest.pack.operatingSystem?.prompts?.length ?? 0,
-    tools: manifest.pack.operatingSystem?.tools?.length ?? 0,
-    setupAssets: manifest.pack.operatingSystem?.setupAssets?.length ?? 0,
-    installProfiles: manifest.pack.operatingSystem?.installProfiles?.length ?? 0,
-    frameworks: manifest.frameworks?.length ?? 0,
-    schemaExtensions: manifest.schemaExtensions?.length ?? 0,
-    ontologyExtensions: manifest.ontologyExtensions?.length ?? 0
-  };
-}
-function sortJsonValue(value) {
-  if (Array.isArray(value)) {
-    return value.map(sortJsonValue);
-  }
-  if (isPlainObject(value)) {
-    return Object.fromEntries(
-      Object.entries(value).filter(([, entryValue]) => entryValue !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([key, entryValue]) => [key, sortJsonValue(entryValue)])
-    );
-  }
-  return value;
-}
-function toYamlScalar(value) {
-  if (value === null) {
-    return "null";
-  }
-  if (typeof value === "boolean" || typeof value === "number") {
-    return String(value);
-  }
-  return JSON.stringify(String(value));
-}
-function renderYaml(value, indent = 0) {
-  const prefix = " ".repeat(indent);
-  if (Array.isArray(value)) {
-    if (value.length === 0) {
-      return [`${prefix}[]`];
+  const issues = [];
+  const seen = /* @__PURE__ */ new Set();
+  frameworks.forEach((framework, index) => {
+    const path = `frameworks[${index}]`;
+    if (!framework.frameworkId) {
+      issues.push(
+        issue2(
+          "MISSING_FRAMEWORK_ID",
+          "frameworkId is required",
+          `${path}.frameworkId`,
+          "framework"
+        )
+      );
+    } else if (!KEBAB_CASE2.test(framework.frameworkId)) {
+      issues.push(
+        issue2(
+          "INVALID_FRAMEWORK_ID",
+          `frameworkId "${framework.frameworkId}" must be kebab-case`,
+          `${path}.frameworkId`,
+          "framework"
+        )
+      );
+    } else if (seen.has(framework.frameworkId)) {
+      issues.push(
+        issue2(
+          "DUPLICATE_FRAMEWORK_ID",
+          `Duplicate frameworkId "${framework.frameworkId}"`,
+          `${path}.frameworkId`,
+          "framework"
+        )
+      );
+    } else {
+      seen.add(framework.frameworkId);
     }
-    return value.flatMap((entry) => {
-      if (Array.isArray(entry) || isPlainObject(entry)) {
-        return [`${prefix}-`, ...renderYaml(entry, indent + 2)];
-      }
-      return [`${prefix}- ${toYamlScalar(entry)}`];
-    });
-  }
-  if (isPlainObject(value)) {
-    const entries = Object.entries(value);
-    if (entries.length === 0) {
-      return [`${prefix}{}`];
+    if (!framework.version) {
+      issues.push(
+        issue2(
+          "MISSING_FRAMEWORK_VERSION",
+          "version is required",
+          `${path}.version`,
+          "framework"
+        )
+      );
+    } else if (!SEMVER2.test(framework.version)) {
+      issues.push(
+        issue2(
+          "INVALID_FRAMEWORK_VERSION",
+          `framework version "${framework.version}" must be valid semver`,
+          `${path}.version`,
+          "framework"
+        )
+      );
     }
-    return entries.flatMap(([key, entryValue]) => {
-      if (entryValue === void 0) {
-        return [];
-      }
-      if (Array.isArray(entryValue)) {
-        if (entryValue.length === 0) {
-          return [`${prefix}${key}: []`];
-        }
-        return [`${prefix}${key}:`, ...renderYaml(entryValue, indent + 2)];
-      }
-      if (isPlainObject(entryValue)) {
-        if (Object.keys(entryValue).length === 0) {
-          return [`${prefix}${key}: {}`];
-        }
-        return [`${prefix}${key}:`, ...renderYaml(entryValue, indent + 2)];
-      }
-      return [`${prefix}${key}: ${toYamlScalar(entryValue)}`];
-    });
-  }
-  return [`${prefix}${toYamlScalar(value)}`];
-}
-function countIndent(line) {
-  return line.length - line.trimStart().length;
+  });
+  return issues;
 }
-function parseYamlScalar(raw) {
-  const value = raw.trim();
-  if (value === "null") {
-    return null;
-  }
-  if (value === "true") {
-    return true;
-  }
-  if (value === "false") {
-    return false;
-  }
-  if (/^-?\d+(?:\.\d+)?$/.test(value)) {
-    return Number(value);
-  }
-  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-    if (value.startsWith("'")) {
-      return value.slice(1, -1).replace(/''/g, "'");
-    }
-    return JSON.parse(value);
-  }
-  if (value === "[]") {
+function validateSchemaExtensions(extensions) {
+  if (!extensions) {
     return [];
   }
-  if (value === "{}") {
-    return {};
-  }
-  return value;
-}
-function splitYamlKeyValue(trimmed) {
-  const separatorIndex = trimmed.indexOf(":");
-  if (separatorIndex === -1) {
-    throw new Error(`Invalid YAML mapping entry: ${trimmed}`);
-  }
-  const key = trimmed.slice(0, separatorIndex).trim();
-  const value = trimmed.slice(separatorIndex + 1).trim();
-  return { key, value: value.length ? value : null };
-}
-function parseYamlDocument(text) {
-  const rawLines = text.replace(/\r\n/g, "\n").split("\n").map((line) => line.replace(/\t/g, "  "));
-  const lines = rawLines.filter((line) => {
-    const trimmed = line.trim();
-    return trimmed.length > 0 && trimmed !== "---" && trimmed !== "...";
-  });
-  let index = 0;
-  function parseBlock(indent) {
-    if (index >= lines.length) {
-      return {};
-    }
-    const currentLine = lines[index];
-    const currentIndent = countIndent(currentLine);
-    if (currentIndent < indent) {
-      return {};
-    }
-    if (currentLine.trimStart().startsWith("-")) {
-      return parseArray(indent);
-    }
-    return parseObject(indent);
-  }
-  function parseArray(indent) {
-    const items = [];
-    while (index < lines.length) {
-      const line = lines[index];
-      const currentIndent = countIndent(line);
-      if (currentIndent < indent) {
-        break;
-      }
-      if (currentIndent !== indent) {
-        throw new Error(`Invalid YAML indentation near: ${line.trim()}`);
-      }
-      const trimmed = line.trimStart();
-      if (!trimmed.startsWith("-")) {
-        break;
-      }
-      const rest = trimmed.slice(1).trimStart();
-      index += 1;
-      if (!rest.length) {
-        items.push(parseBlock(indent + 2));
-        continue;
-      }
-      items.push(parseYamlScalar(rest));
-    }
-    return items;
-  }
-  function parseObject(indent) {
-    const objectValue = {};
-    while (index < lines.length) {
-      const line = lines[index];
-      const currentIndent = countIndent(line);
-      if (currentIndent < indent) {
-        break;
-      }
-      if (currentIndent !== indent) {
-        throw new Error(`Invalid YAML indentation near: ${line.trim()}`);
-      }
-      const trimmed = line.trim();
-      if (trimmed.startsWith("-")) {
-        break;
-      }
-      const { key, value } = splitYamlKeyValue(trimmed);
-      index += 1;
-      objectValue[key] = value === null ? parseBlock(indent + 2) : parseYamlScalar(value);
-    }
-    return objectValue;
-  }
-  return parseBlock(0);
-}
-function detectDomainPackManifestFormat(source, explicitFormat) {
-  if (explicitFormat) {
-    return explicitFormat;
-  }
-  const trimmed = source.trim();
-  if (trimmed.startsWith("{")) {
-    return "json";
-  }
-  return "yaml";
-}
-function serializeDomainPackAuthoringManifest(manifest, format = "json") {
-  const canonicalValue = sortJsonValue(manifest);
-  if (format === "json") {
-    return `${JSON.stringify(canonicalValue, null, 2)}
-`;
-  }
-  return `${renderYaml(canonicalValue).join("\n")}
-`;
-}
-function parseDomainPackAuthoringManifest(source, format) {
-  const detectedFormat = detectDomainPackManifestFormat(source, format);
-  const parsed = detectedFormat === "json" ? JSON.parse(source) : parseYamlDocument(source);
-  if (!isPlainObject(parsed)) {
-    throw new Error("Domain pack manifest must parse to an object.");
-  }
-  if (!("pack" in parsed)) {
-    throw new Error("Domain pack manifest requires a top-level pack object.");
-  }
-  return defineDomainPackAuthoringManifest({
-    kind: parsed.kind,
-    manifestVersion: parsed.manifestVersion,
-    pack: parsed.pack,
-    frameworks: parsed.frameworks,
-    schemaExtensions: parsed.schemaExtensions,
-    ontologyExtensions: parsed.ontologyExtensions,
-    lineage: parsed.lineage,
-    metadata: parsed.metadata
-  });
-}
-function validateFrameworks(frameworks) {
-  if (!frameworks) {
-    return [];
-  }
-  const issues = [];
-  const seen = /* @__PURE__ */ new Set();
-  frameworks.forEach((framework, index) => {
-    const path = `frameworks[${index}]`;
-    if (!framework.frameworkId) {
-      issues.push(
-        issue2(
-          "MISSING_FRAMEWORK_ID",
-          "frameworkId is required",
-          `${path}.frameworkId`,
-          "framework"
-        )
-      );
-    } else if (!KEBAB_CASE2.test(framework.frameworkId)) {
-      issues.push(
-        issue2(
-          "INVALID_FRAMEWORK_ID",
-          `frameworkId "${framework.frameworkId}" must be kebab-case`,
-          `${path}.frameworkId`,
-          "framework"
-        )
-      );
-    } else if (seen.has(framework.frameworkId)) {
-      issues.push(
-        issue2(
-          "DUPLICATE_FRAMEWORK_ID",
-          `Duplicate frameworkId "${framework.frameworkId}"`,
-          `${path}.frameworkId`,
-          "framework"
-        )
-      );
-    } else {
-      seen.add(framework.frameworkId);
-    }
-    if (!framework.version) {
-      issues.push(
-        issue2(
-          "MISSING_FRAMEWORK_VERSION",
-          "version is required",
-          `${path}.version`,
-          "framework"
-        )
-      );
-    } else if (!SEMVER2.test(framework.version)) {
-      issues.push(
-        issue2(
-          "INVALID_FRAMEWORK_VERSION",
-          `framework version "${framework.version}" must be valid semver`,
-          `${path}.version`,
-          "framework"
-        )
-      );
-    }
-  });
-  return issues;
-}
-function validateSchemaExtensions(extensions) {
-  if (!extensions) {
-    return [];
-  }
-  const issues = [];
-  const seen = /* @__PURE__ */ new Set();
-  extensions.forEach((extension, index) => {
-    const path = `schemaExtensions[${index}]`;
-    if (!extension.extensionId) {
-      issues.push(
-        issue2(
-          "MISSING_SCHEMA_EXTENSION_ID",
-          "extensionId is required",
-          `${path}.extensionId`,
-          "schema-extension"
-        )
-      );
-    } else if (!KEBAB_CASE2.test(extension.extensionId)) {
-      issues.push(
-        issue2(
-          "INVALID_SCHEMA_EXTENSION_ID",
-          `extensionId "${extension.extensionId}" must be kebab-case`,
-          `${path}.extensionId`,
-          "schema-extension"
-        )
-      );
-    } else if (seen.has(extension.extensionId)) {
-      issues.push(
-        issue2(
-          "DUPLICATE_SCHEMA_EXTENSION_ID",
-          `Duplicate schema extension "${extension.extensionId}"`,
-          `${path}.extensionId`,
-          "schema-extension"
-        )
-      );
-    } else {
-      seen.add(extension.extensionId);
+  const issues = [];
+  const seen = /* @__PURE__ */ new Set();
+  extensions.forEach((extension, index) => {
+    const path = `schemaExtensions[${index}]`;
+    if (!extension.extensionId) {
+      issues.push(
+        issue2(
+          "MISSING_SCHEMA_EXTENSION_ID",
+          "extensionId is required",
+          `${path}.extensionId`,
+          "schema-extension"
+        )
+      );
+    } else if (!KEBAB_CASE2.test(extension.extensionId)) {
+      issues.push(
+        issue2(
+          "INVALID_SCHEMA_EXTENSION_ID",
+          `extensionId "${extension.extensionId}" must be kebab-case`,
+          `${path}.extensionId`,
+          "schema-extension"
+        )
+      );
+    } else if (seen.has(extension.extensionId)) {
+      issues.push(
+        issue2(
+          "DUPLICATE_SCHEMA_EXTENSION_ID",
+          `Duplicate schema extension "${extension.extensionId}"`,
+          `${path}.extensionId`,
+          "schema-extension"
+        )
+      );
+    } else {
+      seen.add(extension.extensionId);
     }
     if (!SCHEMA_EXTENSION_TARGETS.has(extension.target)) {
       issues.push(
@@ -3049,7 +3204,7 @@ function validateSchemaExtensions(extensions) {
         )
       );
     }
-    if (!isPlainObject(extension.schema)) {
+    if (!isPlainObject2(extension.schema)) {
       issues.push(
         issue2(
           "INVALID_SCHEMA_EXTENSION_SCHEMA",
@@ -3131,85 +3286,89 @@ function validateOntologyExtensions(extensions) {
       );
     }
     const entityTypeValues = /* @__PURE__ */ new Set();
-    extension.entityTypes?.forEach((entityType, entityTypeIndex) => {
-      const entityPath = `${path}.entityTypes[${entityTypeIndex}]`;
-      if (!entityType.value || !KEBAB_CASE2.test(entityType.value)) {
-        issues.push(
-          issue2(
-            "INVALID_ONTOLOGY_ENTITY_VALUE",
-            "entity extension value must be kebab-case",
-            `${entityPath}.value`,
-            "ontology-extension"
-          )
-        );
-      } else if (entityTypeValues.has(entityType.value)) {
-        issues.push(
-          issue2(
-            "DUPLICATE_ONTOLOGY_ENTITY_VALUE",
-            `Duplicate entity extension value "${entityType.value}"`,
-            `${entityPath}.value`,
-            "ontology-extension"
-          )
-        );
-      } else {
-        entityTypeValues.add(entityType.value);
-      }
-      if (!entityType.label) {
-        issues.push(
-          issue2(
-            "MISSING_ONTOLOGY_ENTITY_LABEL",
-            "entity extension label is required",
-            `${entityPath}.label`,
-            "ontology-extension"
-          )
-        );
+    extension.entityTypes?.forEach(
+      (entityType, entityTypeIndex) => {
+        const entityPath = `${path}.entityTypes[${entityTypeIndex}]`;
+        if (!entityType.value || !KEBAB_CASE2.test(entityType.value)) {
+          issues.push(
+            issue2(
+              "INVALID_ONTOLOGY_ENTITY_VALUE",
+              "entity extension value must be kebab-case",
+              `${entityPath}.value`,
+              "ontology-extension"
+            )
+          );
+        } else if (entityTypeValues.has(entityType.value)) {
+          issues.push(
+            issue2(
+              "DUPLICATE_ONTOLOGY_ENTITY_VALUE",
+              `Duplicate entity extension value "${entityType.value}"`,
+              `${entityPath}.value`,
+              "ontology-extension"
+            )
+          );
+        } else {
+          entityTypeValues.add(entityType.value);
+        }
+        if (!entityType.label) {
+          issues.push(
+            issue2(
+              "MISSING_ONTOLOGY_ENTITY_LABEL",
+              "entity extension label is required",
+              `${entityPath}.label`,
+              "ontology-extension"
+            )
+          );
+        }
       }
-    });
+    );
     const edgeTypeValues = /* @__PURE__ */ new Set();
-    extension.edgeTypes?.forEach((edgeType, edgeTypeIndex) => {
-      const edgePath = `${path}.edgeTypes[${edgeTypeIndex}]`;
-      if (!edgeType.value || !KEBAB_CASE2.test(edgeType.value)) {
-        issues.push(
-          issue2(
-            "INVALID_ONTOLOGY_EDGE_VALUE",
-            "edge extension value must be kebab-case",
-            `${edgePath}.value`,
-            "ontology-extension"
-          )
-        );
-      } else if (edgeTypeValues.has(edgeType.value)) {
-        issues.push(
-          issue2(
-            "DUPLICATE_ONTOLOGY_EDGE_VALUE",
-            `Duplicate edge extension value "${edgeType.value}"`,
-            `${edgePath}.value`,
-            "ontology-extension"
-          )
-        );
-      } else {
-        edgeTypeValues.add(edgeType.value);
-      }
-      if (!edgeType.label) {
-        issues.push(
-          issue2(
-            "MISSING_ONTOLOGY_EDGE_LABEL",
-            "edge extension label is required",
-            `${edgePath}.label`,
-            "ontology-extension"
-          )
-        );
-      }
-      if (edgeType.constraintSeverity && !ONTOLOGY_CONSTRAINT_SEVERITIES.has(edgeType.constraintSeverity)) {
-        issues.push(
-          issue2(
-            "INVALID_ONTOLOGY_EDGE_SEVERITY",
-            `Unsupported constraint severity "${edgeType.constraintSeverity}"`,
-            `${edgePath}.constraintSeverity`,
-            "ontology-extension"
-          )
-        );
+    extension.edgeTypes?.forEach(
+      (edgeType, edgeTypeIndex) => {
+        const edgePath = `${path}.edgeTypes[${edgeTypeIndex}]`;
+        if (!edgeType.value || !KEBAB_CASE2.test(edgeType.value)) {
+          issues.push(
+            issue2(
+              "INVALID_ONTOLOGY_EDGE_VALUE",
+              "edge extension value must be kebab-case",
+              `${edgePath}.value`,
+              "ontology-extension"
+            )
+          );
+        } else if (edgeTypeValues.has(edgeType.value)) {
+          issues.push(
+            issue2(
+              "DUPLICATE_ONTOLOGY_EDGE_VALUE",
+              `Duplicate edge extension value "${edgeType.value}"`,
+              `${edgePath}.value`,
+              "ontology-extension"
+            )
+          );
+        } else {
+          edgeTypeValues.add(edgeType.value);
+        }
+        if (!edgeType.label) {
+          issues.push(
+            issue2(
+              "MISSING_ONTOLOGY_EDGE_LABEL",
+              "edge extension label is required",
+              `${edgePath}.label`,
+              "ontology-extension"
+            )
+          );
+        }
+        if (edgeType.constraintSeverity && !ONTOLOGY_CONSTRAINT_SEVERITIES.has(edgeType.constraintSeverity)) {
+          issues.push(
+            issue2(
+              "INVALID_ONTOLOGY_EDGE_SEVERITY",
+              `Unsupported constraint severity "${edgeType.constraintSeverity}"`,
+              `${edgePath}.constraintSeverity`,
+              "ontology-extension"
+            )
+          );
+        }
       }
-    });
+    );
   });
   return issues;
 }
@@ -3328,7 +3487,7 @@ function scanLegacyPublicKeys(value, path = "") {
     });
     return issues;
   }
-  if (!isPlainObject(value)) {
+  if (!isPlainObject2(value)) {
     return issues;
   }
   Object.entries(value).forEach(([key, entryValue]) => {
@@ -3427,7 +3586,7 @@ function validateDomainPackAuthoringManifest(manifest) {
   );
 }
 function validateDomainPackAuthoringManifestSource(source, format) {
-  const detectedFormat = detectDomainPackManifestFormat(source, format);
+  const detectedFormat = detectDomainPackManifestFormat2(source, format);
   try {
     const manifest = parseDomainPackAuthoringManifest(source, detectedFormat);
     return evaluateDomainPackAuthoringManifest(manifest, detectedFormat);
@@ -3577,26 +3736,44 @@ function createDomainPackAuthoringTools() {
     additionalProperties: false
   };
   return {
-    validate: {
+    validate: asToolDefinition({
       name: AUTHORING_TOOL_NAMES.validate,
       description: "Validate a domain pack authoring manifest and return structural, lineage, terminology, and extension issues.",
       inputSchema,
       execute: (args) => validateDomainPackAuthoringManifestSource(args.manifestText, args.format)
-    },
-    preview: {
+    }),
+    preview: asToolDefinition({
       name: AUTHORING_TOOL_NAMES.preview,
       description: "Preview a domain pack manifest with canonical JSON/YAML renderings, runtime targets, and publication readiness.",
       inputSchema,
       execute: (args) => previewDomainPackAuthoringManifestSource(args.manifestText, args.format)
-    },
-    publish: {
+    }),
+    publish: asToolDefinition({
       name: AUTHORING_TOOL_NAMES.publish,
       description: "Build a publication-ready domain pack artifact when validation passes, including remix/fork lineage metadata.",
       inputSchema,
       execute: (args) => publishDomainPackAuthoringManifestSource(args.manifestText, args.format)
-    }
+    })
   };
 }
+var domainPackAuthoringValidation = {
+  validateDomainPackAuthoringManifest,
+  validateDomainPackAuthoringManifestSource,
+  previewDomainPackAuthoringManifest,
+  previewDomainPackAuthoringManifestSource,
+  publishDomainPackAuthoringManifest,
+  publishDomainPackAuthoringManifestSource,
+  createDomainPackAuthoringTools
+};
+
+// src/domain-pack/authoring.ts
+var validateDomainPackAuthoringManifest2 = domainPackAuthoringValidation.validateDomainPackAuthoringManifest;
+var validateDomainPackAuthoringManifestSource2 = domainPackAuthoringValidation.validateDomainPackAuthoringManifestSource;
+var previewDomainPackAuthoringManifest2 = domainPackAuthoringValidation.previewDomainPackAuthoringManifest;
+var previewDomainPackAuthoringManifestSource2 = domainPackAuthoringValidation.previewDomainPackAuthoringManifestSource;
+var publishDomainPackAuthoringManifest2 = domainPackAuthoringValidation.publishDomainPackAuthoringManifest;
+var publishDomainPackAuthoringManifestSource2 = domainPackAuthoringValidation.publishDomainPackAuthoringManifestSource;
+var createDomainPackAuthoringTools2 = domainPackAuthoringValidation.createDomainPackAuthoringTools;
 
 // src/domain-pack/ontology/software-entities-v1.ts
 var SOFTWARE_ENTITIES_V1 = {
@@ -4211,578 +4388,8 @@ var DEVELOPER_REASONING_PACK = defineDomainPack({
   methodologyPackId: "developer"
 });
 
-// src/domain-pack/packs/engineering-accelerator.ts
-var ENGINEERING_ACCELERATOR_PACK = defineDomainPack({
-  packId: "engineering-accelerator",
-  name: "Engineering Accelerator",
-  version: "1.0.0",
-  ontologyBindings: [
-    {
-      ontologyId: "software-entities",
-      versionConstraint: "^1.0.0",
-      required: true,
-      provisionMode: "seed",
-      seedRef: "packages/pack-host/src/domain-pack/ontology/software-entities-v1.ts",
-      requiredEntityTypes: [
-        "repository",
-        "service",
-        "module",
-        "workflow",
-        "incident",
-        "migration",
-        "decision_record",
-        "agent"
-      ],
-      requiredEdgeTypes: [
-        "depends_on",
-        "owns",
-        "calls",
-        "blocks",
-        "reviews",
-        "mitigates",
-        "supersedes"
-      ]
-    }
-  ],
-  topicRoots: [
-    {
-      slug: "migrations",
-      name: "Migrations",
-      description: "Schema, API, and runtime migrations with blast-radius, rollback, and parity memory",
-      ontologyId: "software-entities"
-    },
-    {
-      slug: "reviews",
-      name: "Reviews",
-      description: "Pull-request and change-review workflows grounded in prior rationale and regressions",
-      ontologyId: "software-entities"
-    },
-    {
-      slug: "incidents",
-      name: "Incidents",
-      description: "Incident response driven by competing hypotheses, contradictions, and mitigations",
-      ontologyId: "software-entities"
-    },
-    {
-      slug: "architecture",
-      name: "Architecture",
-      description: "Architecture decisions, interface trade-offs, and precedent-aware rationale recall",
-      ontologyId: "software-entities"
-    },
-    {
-      slug: "decision-memory",
-      name: "Decision Memory",
-      description: "Cross-cutting rationale recall, failed attempts, and analog reuse across engineering work",
-      ontologyId: "software-entities"
-    }
-  ],
-  workflows: [
-    {
-      workflowId: "migration-readiness",
-      name: "Migration Readiness",
-      description: "Recall similar migrations, map blast radius, and define rollback before rollout",
-      steps: [
-        {
-          stepId: "recall-history",
-          name: "Recall History",
-          description: "Compile analogous migrations, prior rationale, failed attempts, and compatibility constraints",
-          requiredRoles: ["context-compiler", "migration-owner"],
-          produces: ["memory-brief"],
-          gateId: "memory-grounded"
-        },
-        {
-          stepId: "plan-rollout",
-          name: "Plan Rollout",
-          description: "Define blast radius, sequencing, rollback, and verification checkpoints",
-          requiredRoles: ["migration-owner", "critic"],
-          produces: ["migration-plan"],
-          gateId: "rollback-ready"
-        },
-        {
-          stepId: "verify-rollout",
-          name: "Verify Rollout",
-          description: "Confirm canary, rollback, and parity checks are explicit before execution",
-          requiredRoles: ["reviewer"],
-          produces: ["verification-checklist"],
-          gateId: "verification-covered"
-        }
-      ],
-      requiredArtifacts: [
-        "memory-brief",
-        "migration-plan",
-        "verification-checklist"
-      ],
-      gateCheckpoints: [
-        "memory-grounded",
-        "rollback-ready",
-        "verification-covered"
-      ]
-    },
-    {
-      workflowId: "pull-request-review",
-      name: "Pull Request Review",
-      description: "Use prior rationale, regressions, and verification history to review risky changes faster",
-      steps: [
-        {
-          stepId: "recall-review-context",
-          name: "Recall Review Context",
-          description: "Load earlier decisions, similar diffs, failed attempts, and relevant incidents",
-          requiredRoles: ["context-compiler", "reviewer"],
-          produces: ["review-context"],
-          gateId: "memory-grounded"
-        },
-        {
-          stepId: "inspect-diff",
-          name: "Inspect Diff",
-          description: "Surface risk areas, stale assumptions, and regressions that should block approval",
-          requiredRoles: ["reviewer", "critic"],
-          produces: ["review-findings"],
-          gateId: "review-risks-surfaced"
-        },
-        {
-          stepId: "verify-changes",
-          name: "Verify Changes",
-          description: "Tie approval to explicit typecheck, test, and integration evidence",
-          requiredRoles: ["reviewer"],
-          produces: ["verification-checklist"],
-          gateId: "verification-covered"
-        }
-      ],
-      requiredArtifacts: [
-        "review-context",
-        "review-findings",
-        "verification-checklist"
-      ],
-      gateCheckpoints: [
-        "memory-grounded",
-        "review-risks-surfaced",
-        "verification-covered"
-      ]
-    },
-    {
-      workflowId: "incident-response",
-      name: "Incident Response",
-      description: "Treat incidents as contradiction-heavy reasoning tasks before committing to a root cause",
-      steps: [
-        {
-          stepId: "collect-signal",
-          name: "Collect Signal",
-          description: "Assemble symptoms, recent changes, precedent incidents, and active hypotheses",
-          requiredRoles: ["context-compiler", "incident-commander"],
-          produces: ["incident-brief"],
-          gateId: "memory-grounded"
-        },
-        {
-          stepId: "surface-contradictions",
-          name: "Surface Contradictions",
-          description: "Make competing explanations explicit before mitigation narrows the search space",
-          requiredRoles: ["incident-commander", "critic"],
-          produces: ["contradiction-report"],
-          gateId: "contradictions-surfaced"
-        },
-        {
-          stepId: "plan-mitigation",
-          name: "Plan Mitigation",
-          description: "Choose mitigations with owners, reversibility, and verification paths",
-          requiredRoles: ["incident-commander", "reviewer"],
-          produces: ["mitigation-plan"],
-          gateId: "verification-covered"
-        }
-      ],
-      requiredArtifacts: [
-        "incident-brief",
-        "contradiction-report",
-        "mitigation-plan"
-      ],
-      gateCheckpoints: [
-        "memory-grounded",
-        "contradictions-surfaced",
-        "verification-covered"
-      ]
-    },
-    {
-      workflowId: "architecture-decision",
-      name: "Architecture Decision",
-      description: "Ground architecture choices in cited precedent, explicit alternatives, and follow-up risk",
-      steps: [
-        {
-          stepId: "recall-precedent",
-          name: "Recall Precedent",
-          description: "Gather analogous decisions, trade-offs, reversals, and evidence already in the graph",
-          requiredRoles: ["context-compiler", "architect"],
-          produces: ["decision-brief"],
-          gateId: "memory-grounded"
-        },
-        {
-          stepId: "compare-options",
-          name: "Compare Options",
-          description: "Contrast viable paths, show what changes, and surface objections early",
-          requiredRoles: ["architect", "critic"],
-          produces: ["decision-brief"],
-          gateId: "decision-rationale-citable"
-        },
-        {
-          stepId: "record-decision",
-          name: "Record Decision",
-          description: "Capture the chosen path, cited rationale, and follow-up risks for later recall",
-          requiredRoles: ["architect"],
-          produces: ["decision-record"]
-        }
-      ],
-      requiredArtifacts: ["decision-brief", "decision-record"],
-      gateCheckpoints: ["memory-grounded", "decision-rationale-citable"]
-    }
-  ],
-  gates: [
-    {
-      gateId: "memory-grounded",
-      name: "Memory Grounded",
-      description: "The workflow is anchored in prior rationale, analogs, and failure memory before action",
-      criteria: [
-        {
-          criterionId: "precedent-cited",
-          description: "At least one prior change, incident, or decision is cited",
-          metric: "precedent_citations",
-          threshold: 1,
-          operator: "gte"
-        },
-        {
-          criterionId: "failure-log-checked",
-          description: "Relevant failed attempts or incident history were checked",
-          metric: "failure_log_checked",
-          threshold: 1,
-          operator: "eq"
-        }
-      ],
-      severity: "blocking"
-    },
-    {
-      gateId: "rollback-ready",
-      name: "Rollback Ready",
-      description: "Risky migrations cannot proceed without explicit rollback and blast-radius coverage",
-      criteria: [
-        {
-          criterionId: "blast-radius-scoped",
-          description: "Blast radius is enumerated for the proposed change",
-          metric: "blast_radius_scoped",
-          threshold: 1,
-          operator: "eq"
-        },
-        {
-          criterionId: "rollback-path-defined",
-          description: "Rollback path is explicit and reversible",
-          metric: "rollback_path_defined",
-          threshold: 1,
-          operator: "eq"
-        }
-      ],
-      severity: "blocking"
-    },
-    {
-      gateId: "review-risks-surfaced",
-      name: "Review Risks Surfaced",
-      description: "Review must explain what could regress and why approval is still justified",
-      criteria: [
-        {
-          criterionId: "risk-areas-documented",
-          description: "Risk areas and likely regressions are called out explicitly",
-          metric: "risk_areas_documented",
-          threshold: 1,
-          operator: "gte"
-        },
-        {
-          criterionId: "prior-regressions-checked",
-          description: "Reviewer checked analogous regressions or incidents",
-          metric: "prior_regressions_checked",
-          threshold: 1,
-          operator: "eq"
-        }
-      ],
-      severity: "blocking"
-    },
-    {
-      gateId: "contradictions-surfaced",
-      name: "Contradictions Surfaced",
-      description: "Incidents should preserve competing hypotheses long enough to avoid false certainty",
-      criteria: [
-        {
-          criterionId: "multiple-hypotheses",
-          description: "At least two plausible hypotheses remain visible",
-          metric: "competing_hypotheses_count",
-          threshold: 2,
-          operator: "gte"
-        },
-        {
-          criterionId: "contradictions-reviewed",
-          description: "Relevant contradictions or tensions were reviewed",
-          metric: "contradictions_reviewed",
-          threshold: 1,
-          operator: "gte"
-        }
-      ],
-      severity: "blocking"
-    },
-    {
-      gateId: "decision-rationale-citable",
-      name: "Decision Rationale Citable",
-      description: "Architecture choices should cite prior rationale and compare viable alternatives",
-      criteria: [
-        {
-          criterionId: "options-compared",
-          description: "At least two options are compared before choosing one",
-          metric: "options_compared",
-          threshold: 2,
-          operator: "gte"
-        },
-        {
-          criterionId: "prior-decisions-cited",
-          description: "Decision cites prior beliefs, ADRs, or incidents",
-          metric: "prior_decisions_cited",
-          threshold: 1,
-          operator: "gte"
-        }
-      ],
-      severity: "blocking"
-    },
-    {
-      gateId: "verification-covered",
-      name: "Verification Covered",
-      description: "Approval, rollout, and mitigation all require named verification paths",
-      criteria: [
-        {
-          criterionId: "checks-defined",
-          description: "At least one explicit verification path is named",
-          metric: "verification_paths_defined",
-          threshold: 1,
-          operator: "gte"
-        },
-        {
-          criterionId: "owners-named",
-          description: "Owners or on-call responsibility are explicit",
-          metric: "owner_count",
-          threshold: 1,
-          operator: "gte"
-        }
-      ],
-      severity: "blocking"
-    }
-  ],
-  artifacts: [
-    {
-      artifactId: "memory-brief",
-      name: "Memory Brief",
-      description: "A reusable brief of analogous changes, prior rationale, failed attempts, and contradictions",
-      stage: "recall-history",
-      contentSchema: {
-        type: "object",
-        properties: {
-          analogousChanges: { type: "array", items: { type: "string" } },
-          priorDecisions: { type: "array", items: { type: "string" } },
-          failedAttempts: { type: "array", items: { type: "string" } },
-          contradictions: { type: "array", items: { type: "string" } }
-        },
-        required: ["analogousChanges", "priorDecisions"]
-      },
-      requiredFields: ["analogousChanges", "priorDecisions"]
-    },
-    {
-      artifactId: "migration-plan",
-      name: "Migration Plan",
-      description: "Blast radius, rollback path, rollout checkpoints, and verification plan",
-      stage: "plan-rollout",
-      contentSchema: {
-        type: "object",
-        properties: {
-          blastRadius: { type: "array", items: { type: "string" } },
-          rollbackPlan: { type: "string" },
-          verificationPath: { type: "array", items: { type: "string" } },
-          canarySteps: { type: "array", items: { type: "string" } }
-        },
-        required: ["blastRadius", "rollbackPlan", "verificationPath"]
-      },
-      requiredFields: ["blastRadius", "rollbackPlan", "verificationPath"]
-    },
-    {
-      artifactId: "verification-checklist",
-      name: "Verification Checklist",
-      description: "Named checks, owners, and pass/fail criteria for rollout or approval",
-      stage: "verify-rollout",
-      contentSchema: {
-        type: "object",
-        properties: {
-          checks: { type: "array", items: { type: "string" } },
-          owners: { type: "array", items: { type: "string" } },
-          passCriteria: { type: "array", items: { type: "string" } }
-        },
-        required: ["checks", "owners"]
-      },
-      requiredFields: ["checks", "owners"]
-    },
-    {
-      artifactId: "review-context",
-      name: "Review Context",
-      description: "Prior rationale, related diffs, incidents, and failure history relevant to a review",
-      stage: "recall-review-context",
-      contentSchema: {
-        type: "object",
-        properties: {
-          rationaleLinks: { type: "array", items: { type: "string" } },
-          analogousDiffs: { type: "array", items: { type: "string" } },
-          relatedIncidents: { type: "array", items: { type: "string" } }
-        },
-        required: ["rationaleLinks"]
-      },
-      requiredFields: ["rationaleLinks"]
-    },
-    {
-      artifactId: "review-findings",
-      name: "Review Findings",
-      description: "What could regress, what evidence was checked, and whether the change should be blocked",
-      stage: "inspect-diff",
-      contentSchema: {
-        type: "object",
-        properties: {
-          findings: { type: "array", items: { type: "string" } },
-          regressionsChecked: { type: "array", items: { type: "string" } },
-          blockReason: { type: "string" }
-        },
-        required: ["findings", "regressionsChecked"]
-      },
-      requiredFields: ["findings", "regressionsChecked"]
-    },
-    {
-      artifactId: "incident-brief",
-      name: "Incident Brief",
-      description: "Signals, recent changes, competing hypotheses, and precedent incidents",
-      stage: "collect-signal",
-      contentSchema: {
-        type: "object",
-        properties: {
-          symptoms: { type: "array", items: { type: "string" } },
-          recentChanges: { type: "array", items: { type: "string" } },
-          competingHypotheses: { type: "array", items: { type: "string" } },
-          precedentIncidents: { type: "array", items: { type: "string" } }
-        },
-        required: ["symptoms", "competingHypotheses"]
-      },
-      requiredFields: ["symptoms", "competingHypotheses"]
-    },
-    {
-      artifactId: "contradiction-report",
-      name: "Contradiction Report",
-      description: "Active contradictions, why they matter, and what evidence could collapse them",
-      stage: "surface-contradictions",
-      contentSchema: {
-        type: "object",
-        properties: {
-          contradictions: { type: "array", items: { type: "string" } },
-          likelyRootCauses: { type: "array", items: { type: "string" } },
-          missingEvidence: { type: "array", items: { type: "string" } }
-        },
-        required: ["contradictions", "likelyRootCauses"]
-      },
-      requiredFields: ["contradictions", "likelyRootCauses"]
-    },
-    {
-      artifactId: "mitigation-plan",
-      name: "Mitigation Plan",
-      description: "Chosen mitigation, rollback path, and verification ownership for an incident",
-      stage: "plan-mitigation",
-      contentSchema: {
-        type: "object",
-        properties: {
-          mitigationSteps: { type: "array", items: { type: "string" } },
-          rollbackPlan: { type: "string" },
-          owners: { type: "array", items: { type: "string" } }
-        },
-        required: ["mitigationSteps", "owners"]
-      },
-      requiredFields: ["mitigationSteps", "owners"]
-    },
-    {
-      artifactId: "decision-brief",
-      name: "Decision Brief",
-      description: "Options, cited precedent, trade-offs, and objections for an architecture decision",
-      stage: "compare-options",
-      contentSchema: {
-        type: "object",
-        properties: {
-          options: { type: "array", items: { type: "string" } },
-          citedPrecedent: { type: "array", items: { type: "string" } },
-          objections: { type: "array", items: { type: "string" } }
-        },
-        required: ["options", "citedPrecedent"]
-      },
-      requiredFields: ["options", "citedPrecedent"]
-    },
-    {
-      artifactId: "decision-record",
-      name: "Decision Record",
-      description: "Chosen path, why it won, what it supersedes, and what follow-up remains open",
-      stage: "record-decision",
-      contentSchema: {
-        type: "object",
-        properties: {
-          decision: { type: "string" },
-          rationale: { type: "array", items: { type: "string" } },
-          supersedes: { type: "array", items: { type: "string" } },
-          followUps: { type: "array", items: { type: "string" } }
-        },
-        required: ["decision", "rationale"]
-      },
-      requiredFields: ["decision", "rationale"]
-    }
-  ],
-  roles: [
-    {
-      roleId: "context-compiler",
-      name: "Context Compiler",
-      description: "Compiles prior rationale, analogs, and failure memory into reusable first-hour context",
-      perspective: "History-first, evidence-weighted context assembly",
-      optimizesFor: "recall quality and anti-repetition coverage",
-      mayBlock: false
-    },
-    {
-      roleId: "migration-owner",
-      name: "Migration Owner",
-      description: "Scopes rollout blast radius, rollback, sequencing, and compatibility risk",
-      perspective: "Operational caution with explicit rollback discipline",
-      optimizesFor: "safe rollout planning",
-      mayBlock: false
-    },
-    {
-      roleId: "reviewer",
-      name: "Reviewer",
-      description: "Evaluates risky changes against prior regressions, evidence, and missing checks",
-      perspective: "Evidence-backed change approval with regression awareness",
-      optimizesFor: "defect prevention and clear approval rationale",
-      mayBlock: true
-    },
-    {
-      roleId: "incident-commander",
-      name: "Incident Commander",
-      description: "Maintains multiple plausible explanations while driving mitigation decisions",
-      perspective: "Fast, reversible action without collapsing uncertainty too early",
-      optimizesFor: "time-to-mitigation with preserved reasoning integrity",
-      mayBlock: false
-    },
-    {
-      roleId: "architect",
-      name: "Architect",
-      description: "Turns competing options into explicit decisions with cited precedent and follow-up risk",
-      perspective: "Trade-off clarity and long-term maintainability",
-      optimizesFor: "decision quality and rationale reuse",
-      mayBlock: false
-    },
-    {
-      roleId: "critic",
-      name: "Critic",
-      description: "Finds weak assumptions, missing rollback paths, and untested contradictions",
-      perspective: "Skeptical, adversarial, and detail-oriented",
-      optimizesFor: "early detection of brittle plans",
-      mayBlock: true
-    }
-  ],
+// src/domain-pack/packs/engineering-accelerator-tail.ts
+var ENGINEERING_ACCELERATOR_TAIL = {
   inquiryShaping: {
     questionTemplates: [
       {
@@ -5269,229 +4876,804 @@ var ENGINEERING_ACCELERATOR_PACK = defineDomainPack({
         parentSlug: "migrations",
         ontologyId: "software-entities"
       },
-      {
-        slug: "review-briefs",
-        name: "Review Briefs",
-        description: "Diff-scoped risk briefs grounded in prior regressions and rationale",
-        parentSlug: "reviews",
-        ontologyId: "software-entities"
+      {
+        slug: "review-briefs",
+        name: "Review Briefs",
+        description: "Diff-scoped risk briefs grounded in prior regressions and rationale",
+        parentSlug: "reviews",
+        ontologyId: "software-entities"
+      },
+      {
+        slug: "regression-history",
+        name: "Regression History",
+        description: "Past regressions and approval misses that should influence current reviews",
+        parentSlug: "reviews",
+        ontologyId: "software-entities"
+      },
+      {
+        slug: "active-incidents",
+        name: "Active Incidents",
+        description: "Current incidents with competing hypotheses, mitigations, and contradictions",
+        parentSlug: "incidents",
+        ontologyId: "software-entities"
+      },
+      {
+        slug: "incident-postmortems",
+        name: "Incident Postmortems",
+        description: "Resolved incidents with preserved rationale and follow-up learnings",
+        parentSlug: "incidents",
+        ontologyId: "software-entities"
+      },
+      {
+        slug: "adrs",
+        name: "Architecture Decision Records",
+        description: "Citable architecture records with precedent, objections, and supersessions",
+        parentSlug: "architecture",
+        ontologyId: "software-entities"
+      },
+      {
+        slug: "interface-contracts",
+        name: "Interface Contracts",
+        description: "APIs, boundaries, and contract deltas that architecture work depends on",
+        parentSlug: "architecture",
+        ontologyId: "software-entities"
+      },
+      {
+        slug: "failed-attempts",
+        name: "Failed Attempts",
+        description: "Anti-repetition log for engineering decisions and implementation dead ends",
+        parentSlug: "decision-memory",
+        ontologyId: "software-entities"
+      },
+      {
+        slug: "rationale-recall",
+        name: "Rationale Recall",
+        description: "Recalled rationale snippets and analogs worth citing before new work",
+        parentSlug: "decision-memory",
+        ontologyId: "software-entities"
+      }
+    ],
+    installProfiles: [
+      {
+        profileId: "claude-code",
+        name: "Claude Code Engineering Kit",
+        description: "Installs Claude-native hooks, commands, agent catalog, and first-hour engineering prompts on top of Lucern.",
+        runtimeTarget: "claude-code",
+        promptIds: [
+          "claude-quick-reference",
+          "build-command",
+          "architect-command",
+          "pipeline-command",
+          "pr-command",
+          "lucern-generate-questions",
+          "lucern-contradiction-analysis"
+        ],
+        toolIds: [
+          "start-investigation",
+          "record-scope-learning",
+          "record-attempt",
+          "pipeline-snapshot",
+          "session-init",
+          "tool-log",
+          "build-bash-gate",
+          "lucern-cli-init",
+          "kit-install"
+        ],
+        assetIds: [
+          "claude-instructions",
+          "mcp-config",
+          "kit-manifest",
+          "lucern-launcher",
+          "lucern-shell-wrapper",
+          "lucern-cli-script",
+          "claude-settings",
+          "permission-gate-hook",
+          "inbox-check-hook",
+          "prompt-router-hook",
+          "writeback-gate-hook",
+          "build-command-doc",
+          "architect-command-doc",
+          "pipeline-command-doc",
+          "pr-command-doc",
+          "claude-agent-catalog",
+          "claude-skill-catalog",
+          "hooks-doc",
+          "setup-ui"
+        ],
+        defaultTopicSlugs: [
+          "migrations",
+          "reviews",
+          "incidents",
+          "architecture",
+          "decision-memory"
+        ]
+      },
+      {
+        profileId: "codex",
+        name: "Codex Engineering Kit",
+        description: "Installs the Codex bridge, Lucern MCP wiring, and the same pack-level workflows without Claude-specific hooks.",
+        runtimeTarget: "codex",
+        promptIds: [
+          "build-command",
+          "architect-command",
+          "pipeline-command",
+          "pr-command",
+          "lucern-generate-questions",
+          "lucern-contradiction-analysis"
+        ],
+        toolIds: [
+          "start-investigation",
+          "record-scope-learning",
+          "record-attempt",
+          "pipeline-snapshot",
+          "lucern-cli-init",
+          "kit-install"
+        ],
+        assetIds: [
+          "codex-bridge",
+          "mcp-config",
+          "kit-manifest",
+          "lucern-launcher",
+          "lucern-shell-wrapper",
+          "lucern-cli-script",
+          "build-command-doc",
+          "architect-command-doc",
+          "pipeline-command-doc",
+          "pr-command-doc",
+          "claude-skill-catalog",
+          "skills-sync-script",
+          "hooks-doc",
+          "setup-ui"
+        ],
+        defaultTopicSlugs: [
+          "migrations",
+          "reviews",
+          "incidents",
+          "architecture",
+          "decision-memory"
+        ]
+      },
+      {
+        profileId: "hybrid",
+        name: "Hybrid Engineering Kit",
+        description: "Installs both Claude and Codex entry surfaces against one Lucern-native engineering operating system.",
+        runtimeTarget: "hybrid",
+        promptIds: [
+          "claude-quick-reference",
+          "build-command",
+          "architect-command",
+          "pipeline-command",
+          "pr-command",
+          "lucern-generate-questions",
+          "lucern-contradiction-analysis"
+        ],
+        toolIds: [
+          "start-investigation",
+          "record-scope-learning",
+          "record-attempt",
+          "pipeline-snapshot",
+          "session-init",
+          "tool-log",
+          "build-bash-gate",
+          "lucern-cli-init",
+          "kit-install"
+        ],
+        assetIds: [
+          "claude-instructions",
+          "codex-bridge",
+          "mcp-config",
+          "kit-manifest",
+          "lucern-launcher",
+          "lucern-shell-wrapper",
+          "lucern-cli-script",
+          "claude-settings",
+          "permission-gate-hook",
+          "inbox-check-hook",
+          "prompt-router-hook",
+          "writeback-gate-hook",
+          "build-command-doc",
+          "architect-command-doc",
+          "pipeline-command-doc",
+          "pr-command-doc",
+          "claude-agent-catalog",
+          "claude-skill-catalog",
+          "skills-sync-script",
+          "hooks-doc",
+          "setup-ui"
+        ],
+        defaultTopicSlugs: [
+          "migrations",
+          "reviews",
+          "incidents",
+          "architecture",
+          "decision-memory"
+        ]
+      }
+    ]
+  },
+  appPackKeys: [
+    "chat-v1",
+    "documents-v1",
+    "epistemic-algorithms-v1",
+    "graph-visualization-v1",
+    "task-management-v1"
+  ],
+  methodologyPackId: "developer"
+};
+
+// src/domain-pack/packs/engineering-accelerator.ts
+var ENGINEERING_ACCELERATOR_PACK = defineDomainPack({
+  packId: "engineering-accelerator",
+  name: "Engineering Accelerator",
+  version: "1.0.0",
+  ontologyBindings: [
+    {
+      ontologyId: "software-entities",
+      versionConstraint: "^1.0.0",
+      required: true,
+      provisionMode: "seed",
+      seedRef: "packages/pack-host/src/domain-pack/ontology/software-entities-v1.ts",
+      requiredEntityTypes: [
+        "repository",
+        "service",
+        "module",
+        "workflow",
+        "incident",
+        "migration",
+        "decision_record",
+        "agent"
+      ],
+      requiredEdgeTypes: [
+        "depends_on",
+        "owns",
+        "calls",
+        "blocks",
+        "reviews",
+        "mitigates",
+        "supersedes"
+      ]
+    }
+  ],
+  topicRoots: [
+    {
+      slug: "migrations",
+      name: "Migrations",
+      description: "Schema, API, and runtime migrations with blast-radius, rollback, and parity memory",
+      ontologyId: "software-entities"
+    },
+    {
+      slug: "reviews",
+      name: "Reviews",
+      description: "Pull-request and change-review workflows grounded in prior rationale and regressions",
+      ontologyId: "software-entities"
+    },
+    {
+      slug: "incidents",
+      name: "Incidents",
+      description: "Incident response driven by competing hypotheses, contradictions, and mitigations",
+      ontologyId: "software-entities"
+    },
+    {
+      slug: "architecture",
+      name: "Architecture",
+      description: "Architecture decisions, interface trade-offs, and precedent-aware rationale recall",
+      ontologyId: "software-entities"
+    },
+    {
+      slug: "decision-memory",
+      name: "Decision Memory",
+      description: "Cross-cutting rationale recall, failed attempts, and analog reuse across engineering work",
+      ontologyId: "software-entities"
+    }
+  ],
+  workflows: [
+    {
+      workflowId: "migration-readiness",
+      name: "Migration Readiness",
+      description: "Recall similar migrations, map blast radius, and define rollback before rollout",
+      steps: [
+        {
+          stepId: "recall-history",
+          name: "Recall History",
+          description: "Compile analogous migrations, prior rationale, failed attempts, and compatibility constraints",
+          requiredRoles: ["context-compiler", "migration-owner"],
+          produces: ["memory-brief"],
+          gateId: "memory-grounded"
+        },
+        {
+          stepId: "plan-rollout",
+          name: "Plan Rollout",
+          description: "Define blast radius, sequencing, rollback, and verification checkpoints",
+          requiredRoles: ["migration-owner", "critic"],
+          produces: ["migration-plan"],
+          gateId: "rollback-ready"
+        },
+        {
+          stepId: "verify-rollout",
+          name: "Verify Rollout",
+          description: "Confirm canary, rollback, and parity checks are explicit before execution",
+          requiredRoles: ["reviewer"],
+          produces: ["verification-checklist"],
+          gateId: "verification-covered"
+        }
+      ],
+      requiredArtifacts: [
+        "memory-brief",
+        "migration-plan",
+        "verification-checklist"
+      ],
+      gateCheckpoints: [
+        "memory-grounded",
+        "rollback-ready",
+        "verification-covered"
+      ]
+    },
+    {
+      workflowId: "pull-request-review",
+      name: "Pull Request Review",
+      description: "Use prior rationale, regressions, and verification history to review risky changes faster",
+      steps: [
+        {
+          stepId: "recall-review-context",
+          name: "Recall Review Context",
+          description: "Load earlier decisions, similar diffs, failed attempts, and relevant incidents",
+          requiredRoles: ["context-compiler", "reviewer"],
+          produces: ["review-context"],
+          gateId: "memory-grounded"
+        },
+        {
+          stepId: "inspect-diff",
+          name: "Inspect Diff",
+          description: "Surface risk areas, stale assumptions, and regressions that should block approval",
+          requiredRoles: ["reviewer", "critic"],
+          produces: ["review-findings"],
+          gateId: "review-risks-surfaced"
+        },
+        {
+          stepId: "verify-changes",
+          name: "Verify Changes",
+          description: "Tie approval to explicit typecheck, test, and integration evidence",
+          requiredRoles: ["reviewer"],
+          produces: ["verification-checklist"],
+          gateId: "verification-covered"
+        }
+      ],
+      requiredArtifacts: [
+        "review-context",
+        "review-findings",
+        "verification-checklist"
+      ],
+      gateCheckpoints: [
+        "memory-grounded",
+        "review-risks-surfaced",
+        "verification-covered"
+      ]
+    },
+    {
+      workflowId: "incident-response",
+      name: "Incident Response",
+      description: "Treat incidents as contradiction-heavy reasoning tasks before committing to a root cause",
+      steps: [
+        {
+          stepId: "collect-signal",
+          name: "Collect Signal",
+          description: "Assemble symptoms, recent changes, precedent incidents, and active hypotheses",
+          requiredRoles: ["context-compiler", "incident-commander"],
+          produces: ["incident-brief"],
+          gateId: "memory-grounded"
+        },
+        {
+          stepId: "surface-contradictions",
+          name: "Surface Contradictions",
+          description: "Make competing explanations explicit before mitigation narrows the search space",
+          requiredRoles: ["incident-commander", "critic"],
+          produces: ["contradiction-report"],
+          gateId: "contradictions-surfaced"
+        },
+        {
+          stepId: "plan-mitigation",
+          name: "Plan Mitigation",
+          description: "Choose mitigations with owners, reversibility, and verification paths",
+          requiredRoles: ["incident-commander", "reviewer"],
+          produces: ["mitigation-plan"],
+          gateId: "verification-covered"
+        }
+      ],
+      requiredArtifacts: [
+        "incident-brief",
+        "contradiction-report",
+        "mitigation-plan"
+      ],
+      gateCheckpoints: [
+        "memory-grounded",
+        "contradictions-surfaced",
+        "verification-covered"
+      ]
+    },
+    {
+      workflowId: "architecture-decision",
+      name: "Architecture Decision",
+      description: "Ground architecture choices in cited precedent, explicit alternatives, and follow-up risk",
+      steps: [
+        {
+          stepId: "recall-precedent",
+          name: "Recall Precedent",
+          description: "Gather analogous decisions, trade-offs, reversals, and evidence already in the graph",
+          requiredRoles: ["context-compiler", "architect"],
+          produces: ["decision-brief"],
+          gateId: "memory-grounded"
+        },
+        {
+          stepId: "compare-options",
+          name: "Compare Options",
+          description: "Contrast viable paths, show what changes, and surface objections early",
+          requiredRoles: ["architect", "critic"],
+          produces: ["decision-brief"],
+          gateId: "decision-rationale-citable"
+        },
+        {
+          stepId: "record-decision",
+          name: "Record Decision",
+          description: "Capture the chosen path, cited rationale, and follow-up risks for later recall",
+          requiredRoles: ["architect"],
+          produces: ["decision-record"]
+        }
+      ],
+      requiredArtifacts: ["decision-brief", "decision-record"],
+      gateCheckpoints: ["memory-grounded", "decision-rationale-citable"]
+    }
+  ],
+  gates: [
+    {
+      gateId: "memory-grounded",
+      name: "Memory Grounded",
+      description: "The workflow is anchored in prior rationale, analogs, and failure memory before action",
+      criteria: [
+        {
+          criterionId: "precedent-cited",
+          description: "At least one prior change, incident, or decision is cited",
+          metric: "precedent_citations",
+          threshold: 1,
+          operator: "gte"
+        },
+        {
+          criterionId: "failure-log-checked",
+          description: "Relevant failed attempts or incident history were checked",
+          metric: "failure_log_checked",
+          threshold: 1,
+          operator: "eq"
+        }
+      ],
+      severity: "blocking"
+    },
+    {
+      gateId: "rollback-ready",
+      name: "Rollback Ready",
+      description: "Risky migrations cannot proceed without explicit rollback and blast-radius coverage",
+      criteria: [
+        {
+          criterionId: "blast-radius-scoped",
+          description: "Blast radius is enumerated for the proposed change",
+          metric: "blast_radius_scoped",
+          threshold: 1,
+          operator: "eq"
+        },
+        {
+          criterionId: "rollback-path-defined",
+          description: "Rollback path is explicit and reversible",
+          metric: "rollback_path_defined",
+          threshold: 1,
+          operator: "eq"
+        }
+      ],
+      severity: "blocking"
+    },
+    {
+      gateId: "review-risks-surfaced",
+      name: "Review Risks Surfaced",
+      description: "Review must explain what could regress and why approval is still justified",
+      criteria: [
+        {
+          criterionId: "risk-areas-documented",
+          description: "Risk areas and likely regressions are called out explicitly",
+          metric: "risk_areas_documented",
+          threshold: 1,
+          operator: "gte"
+        },
+        {
+          criterionId: "prior-regressions-checked",
+          description: "Reviewer checked analogous regressions or incidents",
+          metric: "prior_regressions_checked",
+          threshold: 1,
+          operator: "eq"
+        }
+      ],
+      severity: "blocking"
+    },
+    {
+      gateId: "contradictions-surfaced",
+      name: "Contradictions Surfaced",
+      description: "Incidents should preserve competing hypotheses long enough to avoid false certainty",
+      criteria: [
+        {
+          criterionId: "multiple-hypotheses",
+          description: "At least two plausible hypotheses remain visible",
+          metric: "competing_hypotheses_count",
+          threshold: 2,
+          operator: "gte"
+        },
+        {
+          criterionId: "contradictions-reviewed",
+          description: "Relevant contradictions or tensions were reviewed",
+          metric: "contradictions_reviewed",
+          threshold: 1,
+          operator: "gte"
+        }
+      ],
+      severity: "blocking"
+    },
+    {
+      gateId: "decision-rationale-citable",
+      name: "Decision Rationale Citable",
+      description: "Architecture choices should cite prior rationale and compare viable alternatives",
+      criteria: [
+        {
+          criterionId: "options-compared",
+          description: "At least two options are compared before choosing one",
+          metric: "options_compared",
+          threshold: 2,
+          operator: "gte"
+        },
+        {
+          criterionId: "prior-decisions-cited",
+          description: "Decision cites prior beliefs, ADRs, or incidents",
+          metric: "prior_decisions_cited",
+          threshold: 1,
+          operator: "gte"
+        }
+      ],
+      severity: "blocking"
+    },
+    {
+      gateId: "verification-covered",
+      name: "Verification Covered",
+      description: "Approval, rollout, and mitigation all require named verification paths",
+      criteria: [
+        {
+          criterionId: "checks-defined",
+          description: "At least one explicit verification path is named",
+          metric: "verification_paths_defined",
+          threshold: 1,
+          operator: "gte"
+        },
+        {
+          criterionId: "owners-named",
+          description: "Owners or on-call responsibility are explicit",
+          metric: "owner_count",
+          threshold: 1,
+          operator: "gte"
+        }
+      ],
+      severity: "blocking"
+    }
+  ],
+  artifacts: [
+    {
+      artifactId: "memory-brief",
+      name: "Memory Brief",
+      description: "A reusable brief of analogous changes, prior rationale, failed attempts, and contradictions",
+      stage: "recall-history",
+      contentSchema: {
+        type: "object",
+        properties: {
+          analogousChanges: { type: "array", items: { type: "string" } },
+          priorDecisions: { type: "array", items: { type: "string" } },
+          failedAttempts: { type: "array", items: { type: "string" } },
+          contradictions: { type: "array", items: { type: "string" } }
+        },
+        required: ["analogousChanges", "priorDecisions"]
+      },
+      requiredFields: ["analogousChanges", "priorDecisions"]
+    },
+    {
+      artifactId: "migration-plan",
+      name: "Migration Plan",
+      description: "Blast radius, rollback path, rollout checkpoints, and verification plan",
+      stage: "plan-rollout",
+      contentSchema: {
+        type: "object",
+        properties: {
+          blastRadius: { type: "array", items: { type: "string" } },
+          rollbackPlan: { type: "string" },
+          verificationPath: { type: "array", items: { type: "string" } },
+          canarySteps: { type: "array", items: { type: "string" } }
+        },
+        required: ["blastRadius", "rollbackPlan", "verificationPath"]
       },
-      {
-        slug: "regression-history",
-        name: "Regression History",
-        description: "Past regressions and approval misses that should influence current reviews",
-        parentSlug: "reviews",
-        ontologyId: "software-entities"
+      requiredFields: ["blastRadius", "rollbackPlan", "verificationPath"]
+    },
+    {
+      artifactId: "verification-checklist",
+      name: "Verification Checklist",
+      description: "Named checks, owners, and pass/fail criteria for rollout or approval",
+      stage: "verify-rollout",
+      contentSchema: {
+        type: "object",
+        properties: {
+          checks: { type: "array", items: { type: "string" } },
+          owners: { type: "array", items: { type: "string" } },
+          passCriteria: { type: "array", items: { type: "string" } }
+        },
+        required: ["checks", "owners"]
       },
-      {
-        slug: "active-incidents",
-        name: "Active Incidents",
-        description: "Current incidents with competing hypotheses, mitigations, and contradictions",
-        parentSlug: "incidents",
-        ontologyId: "software-entities"
+      requiredFields: ["checks", "owners"]
+    },
+    {
+      artifactId: "review-context",
+      name: "Review Context",
+      description: "Prior rationale, related diffs, incidents, and failure history relevant to a review",
+      stage: "recall-review-context",
+      contentSchema: {
+        type: "object",
+        properties: {
+          rationaleLinks: { type: "array", items: { type: "string" } },
+          analogousDiffs: { type: "array", items: { type: "string" } },
+          relatedIncidents: { type: "array", items: { type: "string" } }
+        },
+        required: ["rationaleLinks"]
       },
-      {
-        slug: "incident-postmortems",
-        name: "Incident Postmortems",
-        description: "Resolved incidents with preserved rationale and follow-up learnings",
-        parentSlug: "incidents",
-        ontologyId: "software-entities"
+      requiredFields: ["rationaleLinks"]
+    },
+    {
+      artifactId: "review-findings",
+      name: "Review Findings",
+      description: "What could regress, what evidence was checked, and whether the change should be blocked",
+      stage: "inspect-diff",
+      contentSchema: {
+        type: "object",
+        properties: {
+          findings: { type: "array", items: { type: "string" } },
+          regressionsChecked: { type: "array", items: { type: "string" } },
+          blockReason: { type: "string" }
+        },
+        required: ["findings", "regressionsChecked"]
       },
-      {
-        slug: "adrs",
-        name: "Architecture Decision Records",
-        description: "Citable architecture records with precedent, objections, and supersessions",
-        parentSlug: "architecture",
-        ontologyId: "software-entities"
+      requiredFields: ["findings", "regressionsChecked"]
+    },
+    {
+      artifactId: "incident-brief",
+      name: "Incident Brief",
+      description: "Signals, recent changes, competing hypotheses, and precedent incidents",
+      stage: "collect-signal",
+      contentSchema: {
+        type: "object",
+        properties: {
+          symptoms: { type: "array", items: { type: "string" } },
+          recentChanges: { type: "array", items: { type: "string" } },
+          competingHypotheses: { type: "array", items: { type: "string" } },
+          precedentIncidents: { type: "array", items: { type: "string" } }
+        },
+        required: ["symptoms", "competingHypotheses"]
       },
-      {
-        slug: "interface-contracts",
-        name: "Interface Contracts",
-        description: "APIs, boundaries, and contract deltas that architecture work depends on",
-        parentSlug: "architecture",
-        ontologyId: "software-entities"
+      requiredFields: ["symptoms", "competingHypotheses"]
+    },
+    {
+      artifactId: "contradiction-report",
+      name: "Contradiction Report",
+      description: "Active contradictions, why they matter, and what evidence could collapse them",
+      stage: "surface-contradictions",
+      contentSchema: {
+        type: "object",
+        properties: {
+          contradictions: { type: "array", items: { type: "string" } },
+          likelyRootCauses: { type: "array", items: { type: "string" } },
+          missingEvidence: { type: "array", items: { type: "string" } }
+        },
+        required: ["contradictions", "likelyRootCauses"]
       },
-      {
-        slug: "failed-attempts",
-        name: "Failed Attempts",
-        description: "Anti-repetition log for engineering decisions and implementation dead ends",
-        parentSlug: "decision-memory",
-        ontologyId: "software-entities"
+      requiredFields: ["contradictions", "likelyRootCauses"]
+    },
+    {
+      artifactId: "mitigation-plan",
+      name: "Mitigation Plan",
+      description: "Chosen mitigation, rollback path, and verification ownership for an incident",
+      stage: "plan-mitigation",
+      contentSchema: {
+        type: "object",
+        properties: {
+          mitigationSteps: { type: "array", items: { type: "string" } },
+          rollbackPlan: { type: "string" },
+          owners: { type: "array", items: { type: "string" } }
+        },
+        required: ["mitigationSteps", "owners"]
       },
-      {
-        slug: "rationale-recall",
-        name: "Rationale Recall",
-        description: "Recalled rationale snippets and analogs worth citing before new work",
-        parentSlug: "decision-memory",
-        ontologyId: "software-entities"
-      }
-    ],
-    installProfiles: [
-      {
-        profileId: "claude-code",
-        name: "Claude Code Engineering Kit",
-        description: "Installs Claude-native hooks, commands, agent catalog, and first-hour engineering prompts on top of Lucern.",
-        runtimeTarget: "claude-code",
-        promptIds: [
-          "claude-quick-reference",
-          "build-command",
-          "architect-command",
-          "pipeline-command",
-          "pr-command",
-          "lucern-generate-questions",
-          "lucern-contradiction-analysis"
-        ],
-        toolIds: [
-          "start-investigation",
-          "record-scope-learning",
-          "record-attempt",
-          "pipeline-snapshot",
-          "session-init",
-          "tool-log",
-          "build-bash-gate",
-          "lucern-cli-init",
-          "kit-install"
-        ],
-        assetIds: [
-          "claude-instructions",
-          "mcp-config",
-          "kit-manifest",
-          "lucern-launcher",
-          "lucern-shell-wrapper",
-          "lucern-cli-script",
-          "claude-settings",
-          "permission-gate-hook",
-          "inbox-check-hook",
-          "prompt-router-hook",
-          "writeback-gate-hook",
-          "build-command-doc",
-          "architect-command-doc",
-          "pipeline-command-doc",
-          "pr-command-doc",
-          "claude-agent-catalog",
-          "claude-skill-catalog",
-          "hooks-doc",
-          "setup-ui"
-        ],
-        defaultTopicSlugs: [
-          "migrations",
-          "reviews",
-          "incidents",
-          "architecture",
-          "decision-memory"
-        ]
+      requiredFields: ["mitigationSteps", "owners"]
+    },
+    {
+      artifactId: "decision-brief",
+      name: "Decision Brief",
+      description: "Options, cited precedent, trade-offs, and objections for an architecture decision",
+      stage: "compare-options",
+      contentSchema: {
+        type: "object",
+        properties: {
+          options: { type: "array", items: { type: "string" } },
+          citedPrecedent: { type: "array", items: { type: "string" } },
+          objections: { type: "array", items: { type: "string" } }
+        },
+        required: ["options", "citedPrecedent"]
       },
-      {
-        profileId: "codex",
-        name: "Codex Engineering Kit",
-        description: "Installs the Codex bridge, Lucern MCP wiring, and the same pack-level workflows without Claude-specific hooks.",
-        runtimeTarget: "codex",
-        promptIds: [
-          "build-command",
-          "architect-command",
-          "pipeline-command",
-          "pr-command",
-          "lucern-generate-questions",
-          "lucern-contradiction-analysis"
-        ],
-        toolIds: [
-          "start-investigation",
-          "record-scope-learning",
-          "record-attempt",
-          "pipeline-snapshot",
-          "lucern-cli-init",
-          "kit-install"
-        ],
-        assetIds: [
-          "codex-bridge",
-          "mcp-config",
-          "kit-manifest",
-          "lucern-launcher",
-          "lucern-shell-wrapper",
-          "lucern-cli-script",
-          "build-command-doc",
-          "architect-command-doc",
-          "pipeline-command-doc",
-          "pr-command-doc",
-          "claude-skill-catalog",
-          "skills-sync-script",
-          "hooks-doc",
-          "setup-ui"
-        ],
-        defaultTopicSlugs: [
-          "migrations",
-          "reviews",
-          "incidents",
-          "architecture",
-          "decision-memory"
-        ]
+      requiredFields: ["options", "citedPrecedent"]
+    },
+    {
+      artifactId: "decision-record",
+      name: "Decision Record",
+      description: "Chosen path, why it won, what it supersedes, and what follow-up remains open",
+      stage: "record-decision",
+      contentSchema: {
+        type: "object",
+        properties: {
+          decision: { type: "string" },
+          rationale: { type: "array", items: { type: "string" } },
+          supersedes: { type: "array", items: { type: "string" } },
+          followUps: { type: "array", items: { type: "string" } }
+        },
+        required: ["decision", "rationale"]
       },
-      {
-        profileId: "hybrid",
-        name: "Hybrid Engineering Kit",
-        description: "Installs both Claude and Codex entry surfaces against one Lucern-native engineering operating system.",
-        runtimeTarget: "hybrid",
-        promptIds: [
-          "claude-quick-reference",
-          "build-command",
-          "architect-command",
-          "pipeline-command",
-          "pr-command",
-          "lucern-generate-questions",
-          "lucern-contradiction-analysis"
-        ],
-        toolIds: [
-          "start-investigation",
-          "record-scope-learning",
-          "record-attempt",
-          "pipeline-snapshot",
-          "session-init",
-          "tool-log",
-          "build-bash-gate",
-          "lucern-cli-init",
-          "kit-install"
-        ],
-        assetIds: [
-          "claude-instructions",
-          "codex-bridge",
-          "mcp-config",
-          "kit-manifest",
-          "lucern-launcher",
-          "lucern-shell-wrapper",
-          "lucern-cli-script",
-          "claude-settings",
-          "permission-gate-hook",
-          "inbox-check-hook",
-          "prompt-router-hook",
-          "writeback-gate-hook",
-          "build-command-doc",
-          "architect-command-doc",
-          "pipeline-command-doc",
-          "pr-command-doc",
-          "claude-agent-catalog",
-          "claude-skill-catalog",
-          "skills-sync-script",
-          "hooks-doc",
-          "setup-ui"
-        ],
-        defaultTopicSlugs: [
-          "migrations",
-          "reviews",
-          "incidents",
-          "architecture",
-          "decision-memory"
-        ]
-      }
-    ]
-  },
-  appPackKeys: [
-    "chat-v1",
-    "documents-v1",
-    "epistemic-algorithms-v1",
-    "graph-visualization-v1",
-    "task-management-v1"
+      requiredFields: ["decision", "rationale"]
+    }
   ],
-  methodologyPackId: "developer"
+  roles: [
+    {
+      roleId: "context-compiler",
+      name: "Context Compiler",
+      description: "Compiles prior rationale, analogs, and failure memory into reusable first-hour context",
+      perspective: "History-first, evidence-weighted context assembly",
+      optimizesFor: "recall quality and anti-repetition coverage",
+      mayBlock: false
+    },
+    {
+      roleId: "migration-owner",
+      name: "Migration Owner",
+      description: "Scopes rollout blast radius, rollback, sequencing, and compatibility risk",
+      perspective: "Operational caution with explicit rollback discipline",
+      optimizesFor: "safe rollout planning",
+      mayBlock: false
+    },
+    {
+      roleId: "reviewer",
+      name: "Reviewer",
+      description: "Evaluates risky changes against prior regressions, evidence, and missing checks",
+      perspective: "Evidence-backed change approval with regression awareness",
+      optimizesFor: "defect prevention and clear approval rationale",
+      mayBlock: true
+    },
+    {
+      roleId: "incident-commander",
+      name: "Incident Commander",
+      description: "Maintains multiple plausible explanations while driving mitigation decisions",
+      perspective: "Fast, reversible action without collapsing uncertainty too early",
+      optimizesFor: "time-to-mitigation with preserved reasoning integrity",
+      mayBlock: false
+    },
+    {
+      roleId: "architect",
+      name: "Architect",
+      description: "Turns competing options into explicit decisions with cited precedent and follow-up risk",
+      perspective: "Trade-off clarity and long-term maintainability",
+      optimizesFor: "decision quality and rationale reuse",
+      mayBlock: false
+    },
+    {
+      roleId: "critic",
+      name: "Critic",
+      description: "Finds weak assumptions, missing rollback paths, and untested contradictions",
+      perspective: "Skeptical, adversarial, and detail-oriented",
+      optimizesFor: "early detection of brittle plans",
+      mayBlock: true
+    }
+  ],
+  ...ENGINEERING_ACCELERATOR_TAIL
 });
 
 // src/domain-pack/packs/index.ts
@@ -5515,6 +5697,6 @@ var listShapingContributions = shapingContributionRegistry.list.bind(
   shapingContributionRegistry
 );
 
-export { DEVELOPER_REASONING_PACK, ENGINEERING_ACCELERATOR_PACK, PACK_NAMESPACE_COLLISION_ALLOWLIST, SOFTWARE_ENTITIES_V1, allAppPackManifests, appPackRegistry, buildShapingContribution, chatV1Manifest, createDomainPackAuthoringTools, createShapingContributionRegistry, dealsV1Manifest, decisionsV1Manifest, defineAppPackManifest, defineDomainPack, defineDomainPackAuthoringManifest, detectNamespaceCollisions, documentsV1Manifest, epistemicAlgorithmsV1Manifest, evaluateAppPackEnablement, evaluateCatalogEnablement, evaluatePackEnablement, getAppPackManifest, getDependencyClosure, getDomainPack, getShapingContribution, graphVisualizationV1Manifest, listAppPackManifests, listDomainPacks, listShapingContributions, newsV1Manifest, parseDomainPackAuthoringManifest, philosophyModeV1Manifest, previewDomainPackAuthoringManifest, previewDomainPackAuthoringManifestSource, publishDomainPackAuthoringManifest, publishDomainPackAuthoringManifestSource, resolvePackDependencyGraph, serializeDomainPackAuthoringManifest, taskManagementV1Manifest, teamAnalysisV1Manifest, themesV1Manifest, userProfilesV1Manifest, validateAppPackManifest, validateAppPackRegistry, validateDomainPack, validateDomainPackAuthoringManifest, validateDomainPackAuthoringManifestSource, validatePackNamespacePolicies, validatePackRegistry, validatePackSharedServiceContracts, validateShapingContribution };
+export { DEVELOPER_REASONING_PACK, ENGINEERING_ACCELERATOR_PACK, PACK_NAMESPACE_COLLISION_ALLOWLIST, SOFTWARE_ENTITIES_V1, allAppPackManifests, appPackRegistry, buildShapingContribution, chatV1Manifest, createDomainPackAuthoringTools2 as createDomainPackAuthoringTools, createShapingContributionRegistry, dealsV1Manifest, decisionsV1Manifest, defineAppPackManifest, defineDomainPack, defineDomainPackAuthoringManifest, detectNamespaceCollisions, documentsV1Manifest, epistemicAlgorithmsV1Manifest, evaluateAppPackEnablement, evaluateCatalogEnablement, evaluatePackEnablement, getAppPackManifest, getDependencyClosure, getDomainPack, getShapingContribution, graphVisualizationV1Manifest, listAppPackManifests, listDomainPacks, listShapingContributions, newsV1Manifest, parseDomainPackAuthoringManifest, philosophyModeV1Manifest, previewDomainPackAuthoringManifest2 as previewDomainPackAuthoringManifest, previewDomainPackAuthoringManifestSource2 as previewDomainPackAuthoringManifestSource, publishDomainPackAuthoringManifest2 as publishDomainPackAuthoringManifest, publishDomainPackAuthoringManifestSource2 as publishDomainPackAuthoringManifestSource, resolvePackDependencyGraph, serializeDomainPackAuthoringManifest, taskManagementV1Manifest, teamAnalysisV1Manifest, themesV1Manifest, userProfilesV1Manifest, validateAppPackManifest, validateAppPackRegistry, validateDomainPack, validateDomainPackAuthoringManifest2 as validateDomainPackAuthoringManifest, validateDomainPackAuthoringManifestSource2 as validateDomainPackAuthoringManifestSource, validatePackNamespacePolicies, validatePackRegistry, validatePackSharedServiceContracts, validateShapingContribution, worktreesV1Manifest };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map