@elevasis/sdk 1.15.0 → 1.16.0

package/dist/cli.cjs

@@ -289,8 +289,8 @@ var require_main = __commonJS({
         const shortPaths = [];
         for (const filePath of optionPaths) {
           try {
-            const relative = path3.relative(process.cwd(), filePath);
-            shortPaths.push(relative);
+            const relative2 = path3.relative(process.cwd(), filePath);
+            shortPaths.push(relative2);
           } catch (e) {
             if (debug) {
               _debug(`Failed to load ${filePath} ${e.message}`);
@@ -5246,7 +5246,7 @@ var require_buffer_list = __commonJS({
         }
       }, {
         key: "join",
-        value: function join5(s) {
+        value: function join6(s) {
           if (this.length === 0) return "";
           var p = this.head;
           var ret = "" + p.data;
@@ -6623,14 +6623,14 @@ var require_async_iterator = __commonJS({
       };
     }
     function readAndResolve(iter) {
-      var resolve3 = iter[kLastResolve];
-      if (resolve3 !== null) {
+      var resolve5 = iter[kLastResolve];
+      if (resolve5 !== null) {
         var data = iter[kStream].read();
         if (data !== null) {
           iter[kLastPromise] = null;
           iter[kLastResolve] = null;
           iter[kLastReject] = null;
-          resolve3(createIterResult(data, false));
+          resolve5(createIterResult(data, false));
         }
       }
     }
@@ -6638,13 +6638,13 @@ var require_async_iterator = __commonJS({
       process.nextTick(readAndResolve, iter);
     }
     function wrapForNext(lastPromise, iter) {
-      return function(resolve3, reject) {
+      return function(resolve5, reject) {
         lastPromise.then(function() {
           if (iter[kEnded]) {
-            resolve3(createIterResult(void 0, true));
+            resolve5(createIterResult(void 0, true));
             return;
           }
-          iter[kHandlePromise](resolve3, reject);
+          iter[kHandlePromise](resolve5, reject);
         }, reject);
       };
     }
@@ -6664,12 +6664,12 @@ var require_async_iterator = __commonJS({
           return Promise.resolve(createIterResult(void 0, true));
         }
         if (this[kStream].destroyed) {
-          return new Promise(function(resolve3, reject) {
+          return new Promise(function(resolve5, reject) {
             process.nextTick(function() {
               if (_this[kError]) {
                 reject(_this[kError]);
               } else {
-                resolve3(createIterResult(void 0, true));
+                resolve5(createIterResult(void 0, true));
               }
             });
           });
@@ -6692,13 +6692,13 @@ var require_async_iterator = __commonJS({
       return this;
     }), _defineProperty(_Object$setPrototypeO, "return", function _return() {
       var _this2 = this;
-      return new Promise(function(resolve3, reject) {
+      return new Promise(function(resolve5, reject) {
         _this2[kStream].destroy(null, function(err) {
           if (err) {
             reject(err);
             return;
           }
-          resolve3(createIterResult(void 0, true));
+          resolve5(createIterResult(void 0, true));
         });
       });
     }), _Object$setPrototypeO), AsyncIteratorPrototype);
@@ -6720,15 +6720,15 @@ var require_async_iterator = __commonJS({
         value: stream._readableState.endEmitted,
         writable: true
       }), _defineProperty(_Object$create, kHandlePromise, {
-        value: function value(resolve3, reject) {
+        value: function value(resolve5, reject) {
           var data = iterator[kStream].read();
           if (data) {
             iterator[kLastPromise] = null;
             iterator[kLastResolve] = null;
             iterator[kLastReject] = null;
-            resolve3(createIterResult(data, false));
+            resolve5(createIterResult(data, false));
           } else {
-            iterator[kLastResolve] = resolve3;
+            iterator[kLastResolve] = resolve5;
             iterator[kLastReject] = reject;
           }
         },
@@ -6747,12 +6747,12 @@ var require_async_iterator = __commonJS({
           iterator[kError] = err;
           return;
         }
-        var resolve3 = iterator[kLastResolve];
-        if (resolve3 !== null) {
+        var resolve5 = iterator[kLastResolve];
+        if (resolve5 !== null) {
           iterator[kLastPromise] = null;
           iterator[kLastResolve] = null;
           iterator[kLastReject] = null;
-          resolve3(createIterResult(void 0, true));
+          resolve5(createIterResult(void 0, true));
         }
         iterator[kEnded] = true;
       });
@@ -6767,7 +6767,7 @@ var require_async_iterator = __commonJS({
 var require_from = __commonJS({
   "../../node_modules/.pnpm/readable-stream@3.6.2/node_modules/readable-stream/lib/internal/streams/from.js"(exports2, module2) {
     "use strict";
-    function asyncGeneratorStep(gen, resolve3, reject, _next, _throw, key, arg) {
+    function asyncGeneratorStep(gen, resolve5, reject, _next, _throw, key, arg) {
       try {
         var info = gen[key](arg);
         var value = info.value;
@@ -6776,7 +6776,7 @@ var require_from = __commonJS({
         return;
       }
       if (info.done) {
-        resolve3(value);
+        resolve5(value);
       } else {
         Promise.resolve(value).then(_next, _throw);
       }
@@ -6784,13 +6784,13 @@ var require_from = __commonJS({
     function _asyncToGenerator(fn) {
       return function() {
         var self2 = this, args = arguments;
-        return new Promise(function(resolve3, reject) {
+        return new Promise(function(resolve5, reject) {
           var gen = fn.apply(self2, args);
           function _next(value) {
-            asyncGeneratorStep(gen, resolve3, reject, _next, _throw, "next", value);
+            asyncGeneratorStep(gen, resolve5, reject, _next, _throw, "next", value);
           }
           function _throw(err) {
-            asyncGeneratorStep(gen, resolve3, reject, _next, _throw, "throw", err);
+            asyncGeneratorStep(gen, resolve5, reject, _next, _throw, "throw", err);
           }
           _next(void 0);
         });
@@ -23012,8 +23012,8 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 var import_dotenv = __toESM(require_main(), 1);
-var import_fs2 = require("fs");
-var import_path3 = require("path");
+var import_fs4 = require("fs");
+var import_path4 = require("path");
 
 // ../../node_modules/.pnpm/commander@11.1.0/node_modules/commander/esm.mjs
 var import_index = __toESM(require_commander(), 1);
@@ -24039,6 +24039,7 @@ function ora(options) {
 // src/cli/commands/deploy.ts
 var import_path2 = require("path");
 var import_promises = require("fs/promises");
+var import_fs2 = require("fs");
 
 // ../../node_modules/.pnpm/zod@4.1.12/node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -36610,6 +36611,1145 @@ var DateRangeSchema = external_exports.object({
   endDate: external_exports.string().datetime()
 });
 
+// ../core/src/organization-model/icons.ts
+var ORGANIZATION_MODEL_ICON_TOKENS = [
+  "nav.dashboard",
+  "nav.sales",
+  "nav.crm",
+  "nav.lead-gen",
+  "nav.projects",
+  "nav.operations",
+  "nav.monitoring",
+  "nav.knowledge",
+  "nav.settings",
+  "nav.admin",
+  "nav.archive",
+  "knowledge.playbook",
+  "knowledge.strategy",
+  "knowledge.reference",
+  "feature.dashboard",
+  "feature.sales",
+  "feature.crm",
+  "feature.finance",
+  "feature.lead-gen",
+  "feature.platform",
+  "feature.projects",
+  "feature.operations",
+  "feature.knowledge",
+  "feature.monitoring",
+  "feature.settings",
+  "feature.admin",
+  "feature.archive",
+  "feature.seo",
+  "resource.agent",
+  "resource.workflow",
+  "resource.integration",
+  "resource.database",
+  "resource.user",
+  "resource.team",
+  "integration.gmail",
+  "integration.google-sheets",
+  "integration.attio",
+  "surface.dashboard",
+  "surface.overview",
+  "surface.command-view",
+  "surface.command-queue",
+  "surface.pipeline",
+  "surface.lists",
+  "surface.resources",
+  "surface.settings",
+  "status.success",
+  "status.error",
+  "status.warning",
+  "status.info",
+  "status.pending",
+  "action.approve",
+  "action.reject",
+  "action.retry",
+  "action.edit",
+  "action.view",
+  "action.launch",
+  "action.message",
+  "action.escalate",
+  "action.promote",
+  "action.submit",
+  "action.email"
+];
+var CustomIconTokenSchema = external_exports.string().trim().max(80).regex(/^custom\.[a-z0-9]+(?:[-._][a-z0-9]+)*$/, "Custom icon tokens must start with custom.");
+var OrganizationModelBuiltinIconTokenSchema = external_exports.enum(ORGANIZATION_MODEL_ICON_TOKENS);
+var OrganizationModelIconTokenSchema = external_exports.union([
+  OrganizationModelBuiltinIconTokenSchema,
+  CustomIconTokenSchema
+]);
+
+// ../core/src/organization-model/domains/shared.ts
+var ModelIdSchema = external_exports.string().trim().min(1).max(100).regex(/^[a-z0-9]+(?:[-._][a-z0-9]+)*$/, "IDs must be lowercase and use -, _, or . separators");
+var LabelSchema = external_exports.string().trim().min(1).max(120);
+var DescriptionSchema = external_exports.string().trim().min(1).max(2e3);
+var ColorTokenSchema = external_exports.string().trim().min(1).max(50);
+var IconNameSchema = OrganizationModelIconTokenSchema;
+var PathSchema = external_exports.string().trim().startsWith("/").max(300);
+var ReferenceIdsSchema = external_exports.array(ModelIdSchema).default([]);
+var DisplayMetadataSchema = external_exports.object({
+  label: LabelSchema,
+  description: DescriptionSchema.optional(),
+  color: ColorTokenSchema.optional(),
+  icon: IconNameSchema.optional()
+});
+var TechStackEntrySchema = external_exports.object({
+  /** Name of the external platform (e.g. "HubSpot", "Stripe", "Notion"). */
+  platform: external_exports.string().trim().min(1).max(200),
+  /** Free-form description of what this integration is used for. */
+  purpose: external_exports.string().trim().min(1).max(500),
+  /**
+   * Health of the credential backing this integration.
+   * - configured: credential present and valid
+   * - pending: not yet set up
+   * - expired: credential existed but has lapsed
+   * - missing: expected but not present
+   */
+  credentialStatus: external_exports.enum(["configured", "pending", "expired", "missing"]),
+  /**
+   * Whether this integration is the primary system of record for its domain
+   * (e.g. HubSpot is SoR for contacts). Defaults to false.
+   */
+  isSystemOfRecord: external_exports.boolean().default(false)
+});
+var ResourceMappingSchema = DisplayMetadataSchema.extend({
+  id: ModelIdSchema,
+  resourceId: external_exports.string().trim().min(1).max(255),
+  resourceType: external_exports.enum(["workflow", "agent", "trigger", "integration", "external", "human_checkpoint"]),
+  featureIds: ReferenceIdsSchema,
+  entityIds: ReferenceIdsSchema,
+  surfaceIds: ReferenceIdsSchema,
+  capabilityIds: ReferenceIdsSchema,
+  /** Optional tech-stack metadata for external-SaaS integrations. */
+  techStack: TechStackEntrySchema.optional()
+});
+
+// ../core/src/organization-model/domains/features.ts
+var NodeIdPathSchema = external_exports.string().trim().min(1).max(100).regex(/^([a-z0-9-]+)(\.[a-z0-9-]+)*$/, "Node IDs must be lowercase dotted paths");
+var NodeIdStringSchema = external_exports.string().trim().min(1).max(200).regex(/^[a-z]+:([a-z0-9-]+)(\.[a-z0-9-]+)*$/, "Node references must use kind:dotted-path");
+var UiPositionSchema = external_exports.enum(["sidebar-primary", "sidebar-bottom"]);
+var FeatureSchema = external_exports.object({
+  id: NodeIdPathSchema,
+  label: LabelSchema,
+  description: DescriptionSchema.optional(),
+  enabled: external_exports.boolean().default(true),
+  path: PathSchema.optional(),
+  icon: IconNameSchema.optional(),
+  color: ColorTokenSchema.optional(),
+  uiPosition: UiPositionSchema.optional(),
+  requiresAdmin: external_exports.boolean().optional(),
+  devOnly: external_exports.boolean().optional()
+});
+
+// ../core/src/organization-model/domains/branding.ts
+var OrganizationModelBrandingSchema = external_exports.object({
+  organizationName: LabelSchema,
+  productName: LabelSchema,
+  shortName: external_exports.string().trim().min(1).max(40),
+  description: DescriptionSchema.optional(),
+  logos: external_exports.object({
+    light: external_exports.string().trim().min(1).max(2048).optional(),
+    dark: external_exports.string().trim().min(1).max(2048).optional()
+  }).default({})
+});
+var DEFAULT_ORGANIZATION_MODEL_BRANDING = {
+  organizationName: "Default Organization",
+  productName: "Elevasis",
+  shortName: "Elevasis",
+  logos: {}
+};
+
+// ../core/src/organization-model/domains/sales.ts
+var SalesStageSemanticClassSchema = external_exports.enum(["open", "active", "nurturing", "closed_won", "closed_lost"]);
+var SalesStageSchema = DisplayMetadataSchema.extend({
+  id: ModelIdSchema,
+  order: external_exports.number().int().min(0),
+  semanticClass: SalesStageSemanticClassSchema,
+  surfaceIds: ReferenceIdsSchema,
+  resourceIds: ReferenceIdsSchema
+});
+var SalesPipelineSchema = external_exports.object({
+  id: ModelIdSchema,
+  label: external_exports.string().trim().min(1).max(120),
+  description: DescriptionSchema.optional(),
+  entityId: ModelIdSchema,
+  stages: external_exports.array(SalesStageSchema).min(1)
+});
+var OrganizationModelSalesSchema = external_exports.object({
+  entityId: ModelIdSchema,
+  defaultPipelineId: ModelIdSchema,
+  pipelines: external_exports.array(SalesPipelineSchema).min(1)
+});
+var DEFAULT_ORGANIZATION_MODEL_SALES = {
+  entityId: "crm.deal",
+  defaultPipelineId: "default",
+  pipelines: [
+    {
+      id: "default",
+      label: "Default Pipeline",
+      entityId: "crm.deal",
+      stages: [
+        {
+          id: "interested",
+          label: "Interested",
+          color: "blue",
+          order: 1,
+          semanticClass: "open",
+          surfaceIds: ["crm.pipeline"],
+          resourceIds: []
+        },
+        {
+          id: "proposal",
+          label: "Proposal",
+          color: "yellow",
+          order: 2,
+          semanticClass: "active",
+          surfaceIds: ["crm.pipeline"],
+          resourceIds: []
+        },
+        {
+          id: "closing",
+          label: "Closing",
+          color: "lime",
+          order: 3,
+          semanticClass: "active",
+          surfaceIds: ["crm.pipeline"],
+          resourceIds: []
+        },
+        {
+          id: "closed_won",
+          label: "Closed Won",
+          color: "green",
+          order: 4,
+          semanticClass: "closed_won",
+          surfaceIds: ["crm.pipeline"],
+          resourceIds: []
+        },
+        {
+          id: "closed_lost",
+          label: "Closed Lost",
+          color: "red",
+          order: 5,
+          semanticClass: "closed_lost",
+          surfaceIds: ["crm.pipeline"],
+          resourceIds: []
+        },
+        {
+          id: "nurturing",
+          label: "Nurturing",
+          color: "grape",
+          order: 6,
+          semanticClass: "nurturing",
+          surfaceIds: ["crm.pipeline"],
+          resourceIds: []
+        }
+      ]
+    }
+  ]
+};
+
+// ../core/src/organization-model/domains/projects.ts
+var ProjectsDomainStateSchema = DisplayMetadataSchema.extend({
+  id: ModelIdSchema,
+  order: external_exports.number().int().min(0)
+});
+var OrganizationModelProjectsSchema = external_exports.object({
+  projectEntityId: ModelIdSchema,
+  milestoneEntityId: ModelIdSchema,
+  taskEntityId: ModelIdSchema,
+  projectStatuses: external_exports.array(ProjectsDomainStateSchema).min(1),
+  milestoneStatuses: external_exports.array(ProjectsDomainStateSchema).min(1),
+  taskStatuses: external_exports.array(ProjectsDomainStateSchema).min(1)
+});
+var DEFAULT_ORGANIZATION_MODEL_PROJECTS = {
+  projectEntityId: "delivery.project",
+  milestoneEntityId: "delivery.milestone",
+  taskEntityId: "delivery.task",
+  projectStatuses: [
+    { id: "active", label: "Active", order: 1 },
+    { id: "on_track", label: "On Track", order: 2 },
+    { id: "at_risk", label: "At Risk", order: 3 },
+    { id: "blocked", label: "Blocked", order: 4 },
+    { id: "paused", label: "Paused", order: 5 },
+    { id: "completed", label: "Completed", order: 6 }
+  ],
+  milestoneStatuses: [
+    { id: "upcoming", label: "Upcoming", order: 1 },
+    { id: "in_progress", label: "In Progress", order: 2 },
+    { id: "blocked", label: "Blocked", order: 3 },
+    { id: "overdue", label: "Overdue", order: 4 },
+    { id: "completed", label: "Completed", order: 5 }
+  ],
+  taskStatuses: [
+    { id: "planned", label: "Planned", order: 1 },
+    { id: "in_progress", label: "In Progress", order: 2 },
+    { id: "blocked", label: "Blocked", order: 3 },
+    { id: "submitted", label: "Submitted", order: 4 },
+    { id: "approved", label: "Approved", order: 5 },
+    { id: "revision_requested", label: "Revision Requested", order: 6 },
+    { id: "rejected", label: "Rejected", order: 7 },
+    { id: "cancelled", label: "Cancelled", order: 8 },
+    { id: "completed", label: "Completed", order: 9 }
+  ]
+};
+
+// ../core/src/organization-model/domains/prospecting.ts
+var ProspectingLifecycleStageSchema = DisplayMetadataSchema.extend({
+  id: ModelIdSchema,
+  order: external_exports.number().int().min(0)
+});
+var ProspectingBuildTemplateStepSchema = DisplayMetadataSchema.extend({
+  id: ModelIdSchema,
+  primaryEntity: external_exports.enum(["company", "contact"]),
+  outputs: external_exports.array(external_exports.enum(["company", "contact", "export"])).min(1),
+  stageKey: ModelIdSchema,
+  dependsOn: external_exports.array(ModelIdSchema).optional(),
+  dependencyMode: external_exports.literal("per-record-eligibility"),
+  capabilityKey: ModelIdSchema,
+  defaultBatchSize: external_exports.number().int().positive(),
+  maxBatchSize: external_exports.number().int().positive()
+}).refine((step) => step.defaultBatchSize <= step.maxBatchSize, {
+  message: "defaultBatchSize must be less than or equal to maxBatchSize",
+  path: ["defaultBatchSize"]
+});
+var ProspectingBuildTemplateSchema = DisplayMetadataSchema.extend({
+  id: ModelIdSchema,
+  steps: external_exports.array(ProspectingBuildTemplateStepSchema).min(1)
+});
+var OrganizationModelProspectingSchema = external_exports.object({
+  listEntityId: ModelIdSchema,
+  companyEntityId: ModelIdSchema,
+  contactEntityId: ModelIdSchema,
+  description: DescriptionSchema.optional(),
+  companyStages: external_exports.array(ProspectingLifecycleStageSchema).min(1),
+  contactStages: external_exports.array(ProspectingLifecycleStageSchema).min(1),
+  defaultBuildTemplateId: ModelIdSchema,
+  buildTemplates: external_exports.array(ProspectingBuildTemplateSchema).min(1)
+});
+var DEFAULT_ORGANIZATION_MODEL_PROSPECTING = {
+  listEntityId: "leadgen.list",
+  companyEntityId: "leadgen.company",
+  contactEntityId: "leadgen.contact",
+  companyStages: [
+    { id: "populated", label: "Populated", order: 1 },
+    { id: "extracted", label: "Extracted", order: 2 },
+    { id: "qualified", label: "Qualified", order: 3 }
+  ],
+  contactStages: [
+    { id: "discovered", label: "Discovered", order: 1 },
+    { id: "verified", label: "Verified", order: 2 },
+    { id: "personalized", label: "Personalized", order: 3 },
+    { id: "uploaded", label: "Uploaded", order: 4 }
+  ],
+  defaultBuildTemplateId: "local-services",
+  buildTemplates: [
+    {
+      id: "local-services",
+      label: "Local Services Prospecting",
+      description: "Curated local-services list build using company sourcing, website analysis, qualification, contact discovery, verification, personalization, and review.",
+      steps: [
+        {
+          id: "source-companies",
+          label: "Source companies",
+          primaryEntity: "company",
+          outputs: ["company"],
+          stageKey: "populated",
+          dependencyMode: "per-record-eligibility",
+          capabilityKey: "lead-gen.company.source",
+          defaultBatchSize: 100,
+          maxBatchSize: 250
+        },
+        {
+          id: "analyze-websites",
+          label: "Analyze websites",
+          primaryEntity: "company",
+          outputs: ["company"],
+          stageKey: "extracted",
+          dependsOn: ["source-companies"],
+          dependencyMode: "per-record-eligibility",
+          capabilityKey: "lead-gen.company.website-extract",
+          defaultBatchSize: 50,
+          maxBatchSize: 100
+        },
+        {
+          id: "qualify-companies",
+          label: "Qualify companies",
+          primaryEntity: "company",
+          outputs: ["company"],
+          stageKey: "qualified",
+          dependsOn: ["analyze-websites"],
+          dependencyMode: "per-record-eligibility",
+          capabilityKey: "lead-gen.company.qualify",
+          defaultBatchSize: 100,
+          maxBatchSize: 250
+        },
+        {
+          id: "find-contacts",
+          label: "Find contacts",
+          primaryEntity: "contact",
+          outputs: ["contact"],
+          stageKey: "discovered",
+          dependsOn: ["qualify-companies"],
+          dependencyMode: "per-record-eligibility",
+          capabilityKey: "lead-gen.contact.discover",
+          defaultBatchSize: 50,
+          maxBatchSize: 100
+        },
+        {
+          id: "verify-emails",
+          label: "Verify emails",
+          primaryEntity: "contact",
+          outputs: ["contact"],
+          stageKey: "verified",
+          dependsOn: ["find-contacts"],
+          dependencyMode: "per-record-eligibility",
+          capabilityKey: "lead-gen.contact.verify-email",
+          defaultBatchSize: 100,
+          maxBatchSize: 500
+        },
+        {
+          id: "personalize",
+          label: "Personalize",
+          primaryEntity: "contact",
+          outputs: ["contact"],
+          stageKey: "personalized",
+          dependsOn: ["verify-emails"],
+          dependencyMode: "per-record-eligibility",
+          capabilityKey: "lead-gen.contact.personalize",
+          defaultBatchSize: 25,
+          maxBatchSize: 100
+        },
+        {
+          id: "review",
+          label: "Review",
+          primaryEntity: "contact",
+          outputs: ["export"],
+          stageKey: "uploaded",
+          dependsOn: ["personalize"],
+          dependencyMode: "per-record-eligibility",
+          capabilityKey: "lead-gen.review.outreach-ready",
+          defaultBatchSize: 25,
+          maxBatchSize: 100
+        }
+      ]
+    },
+    {
+      id: "dtc-subscription-apollo-clickup",
+      label: "DTC Subscription Apollo Export",
+      description: "Prospecting pipeline for DTC subscription or subscription-ready brands where Apollo is the source and contact-enrichment layer, Elevasis handles company research and fit scoring, and approved leads export as an approved lead list.",
+      steps: [
+        {
+          id: "import-apollo-search",
+          label: "Import Apollo search",
+          description: "Pull companies and seed contact data from a predefined Apollo search or list.",
+          primaryEntity: "company",
+          outputs: ["company", "contact"],
+          stageKey: "populated",
+          dependencyMode: "per-record-eligibility",
+          capabilityKey: "lead-gen.company.apollo-import",
+          defaultBatchSize: 250,
+          maxBatchSize: 1e3
+        },
+        {
+          id: "analyze-websites",
+          label: "Analyze websites",
+          description: "Extract subscription, product, retention, and tech-stack signals from each brand website.",
+          primaryEntity: "company",
+          outputs: ["company"],
+          stageKey: "extracted",
+          dependsOn: ["import-apollo-search"],
+          dependencyMode: "per-record-eligibility",
+          capabilityKey: "lead-gen.company.website-extract",
+          defaultBatchSize: 50,
+          maxBatchSize: 100
+        },
+        {
+          id: "score-dtc-fit",
+          label: "Score DTC fit",
+          description: "Classify subscription potential, consumable-product fit, retention maturity, and disqualifiers.",
+          primaryEntity: "company",
+          outputs: ["company"],
+          stageKey: "qualified",
+          dependsOn: ["analyze-websites"],
+          dependencyMode: "per-record-eligibility",
+          capabilityKey: "lead-gen.company.dtc-subscription-qualify",
+          defaultBatchSize: 100,
+          maxBatchSize: 250
+        },
+        {
+          id: "enrich-decision-makers",
+          label: "Enrich decision-makers",
+          description: "Use Apollo to find qualified contacts such as founders, retention leads, lifecycle leads, and marketing owners.",
+          primaryEntity: "contact",
+          outputs: ["contact"],
+          stageKey: "discovered",
+          dependsOn: ["score-dtc-fit"],
+          dependencyMode: "per-record-eligibility",
+          capabilityKey: "lead-gen.contact.apollo-decision-maker-enrich",
+          defaultBatchSize: 100,
+          maxBatchSize: 250
+        },
+        {
+          id: "verify-emails",
+          label: "Verify emails",
+          description: "Verify deliverability before the QC and handoff step.",
+          primaryEntity: "contact",
+          outputs: ["contact"],
+          stageKey: "verified",
+          dependsOn: ["enrich-decision-makers"],
+          dependencyMode: "per-record-eligibility",
+          capabilityKey: "lead-gen.contact.verify-email",
+          defaultBatchSize: 250,
+          maxBatchSize: 500
+        },
+        {
+          id: "review-and-export",
+          label: "Review and export",
+          description: "Operator QC approves or rejects leads, then approved records are exported as a lead list.",
+          primaryEntity: "company",
+          outputs: ["export"],
+          stageKey: "uploaded",
+          dependsOn: ["verify-emails"],
+          dependencyMode: "per-record-eligibility",
+          capabilityKey: "lead-gen.export.list",
+          defaultBatchSize: 100,
+          maxBatchSize: 250
+        }
+      ]
+    }
+  ]
+};
+
+// ../core/src/organization-model/domains/navigation.ts
+var SurfaceTypeSchema = external_exports.enum(["page", "dashboard", "graph", "detail", "list", "settings"]);
+var SurfaceDefinitionSchema = external_exports.object({
+  id: ModelIdSchema,
+  label: LabelSchema,
+  path: PathSchema,
+  surfaceType: SurfaceTypeSchema,
+  description: DescriptionSchema.optional(),
+  enabled: external_exports.boolean().default(true),
+  devOnly: external_exports.boolean().optional(),
+  icon: IconNameSchema.optional(),
+  featureId: ModelIdSchema.optional(),
+  featureIds: ReferenceIdsSchema,
+  entityIds: ReferenceIdsSchema,
+  resourceIds: ReferenceIdsSchema,
+  capabilityIds: ReferenceIdsSchema,
+  parentId: ModelIdSchema.optional()
+});
+var NavigationGroupSchema = external_exports.object({
+  id: ModelIdSchema,
+  label: LabelSchema,
+  placement: external_exports.string().trim().min(1).max(50),
+  surfaceIds: external_exports.array(ModelIdSchema).default([])
+});
+var OrganizationModelNavigationSchema = external_exports.object({
+  defaultSurfaceId: ModelIdSchema.optional(),
+  surfaces: external_exports.array(SurfaceDefinitionSchema).default([]),
+  groups: external_exports.array(NavigationGroupSchema).default([])
+});
+
+// ../core/src/organization-model/domains/identity.ts
+var BusinessHoursDaySchema = external_exports.object({
+  open: external_exports.string().trim().regex(/^\d{2}:\d{2}$/, "Expected HH:MM format"),
+  close: external_exports.string().trim().regex(/^\d{2}:\d{2}$/, "Expected HH:MM format")
+});
+var BusinessHoursSchema = external_exports.object({
+  monday: BusinessHoursDaySchema.optional(),
+  tuesday: BusinessHoursDaySchema.optional(),
+  wednesday: BusinessHoursDaySchema.optional(),
+  thursday: BusinessHoursDaySchema.optional(),
+  friday: BusinessHoursDaySchema.optional(),
+  saturday: BusinessHoursDaySchema.optional(),
+  sunday: BusinessHoursDaySchema.optional()
+}).default({});
+var IdentityDomainSchema = external_exports.object({
+  /** Why the organization exists — one or two plain-language sentences. */
+  mission: external_exports.string().trim().max(1e3).default(""),
+  /** Long-term direction the organization is moving toward. */
+  vision: external_exports.string().trim().max(1e3).default(""),
+  /** Legal registered name of the entity. */
+  legalName: external_exports.string().trim().max(200).default(""),
+  /**
+   * Type of legal entity (e.g. "LLC", "Corporation", "Sole Proprietor",
+   * "Non-profit"). Free-form string so it covers any jurisdiction.
+   */
+  entityType: external_exports.string().trim().max(100).default(""),
+  /**
+   * Primary jurisdiction of registration or operation
+   * (e.g. "United States – Delaware", "Canada – Ontario").
+   */
+  jurisdiction: external_exports.string().trim().max(200).default(""),
+  /**
+   * Industry category — broad classification (e.g. "Marketing Agency",
+   * "Software / SaaS", "Professional Services").
+   */
+  industryCategory: external_exports.string().trim().max(200).default(""),
+  /**
+   * Geographic focus — where the organization primarily operates or serves
+   * (e.g. "North America", "Global", "Southeast Asia").
+   */
+  geographicFocus: external_exports.string().trim().max(200).default(""),
+  /**
+   * IANA timezone identifier for the organization's primary operating timezone
+   * (e.g. "America/Los_Angeles", "Europe/London", "UTC").
+   */
+  timeZone: external_exports.string().trim().max(100).default("UTC"),
+  /** Typical operating hours per day of week. Empty object means not configured. */
+  businessHours: BusinessHoursSchema,
+  /**
+   * Long-form markdown capturing client context, problem narrative, and domain
+   * background. Populated by /setup; surfaced to agents as organizational context.
+   * Optional — many projects have no external client.
+   */
+  clientBrief: external_exports.string().trim().default("")
+});
+var DEFAULT_ORGANIZATION_MODEL_IDENTITY = {
+  mission: "",
+  vision: "",
+  legalName: "",
+  entityType: "",
+  jurisdiction: "",
+  industryCategory: "",
+  geographicFocus: "",
+  timeZone: "UTC",
+  businessHours: {},
+  clientBrief: ""
+};
+
+// ../core/src/organization-model/domains/customers.ts
+var FirmographicsSchema = external_exports.object({
+  /** Industry vertical (e.g. "Marketing Agency", "Legal", "Real Estate"). */
+  industry: external_exports.string().trim().max(200).optional(),
+  /**
+   * Company headcount band (e.g. "1–10", "11–50", "51–200", "200+").
+   * Free-form string to accommodate any band notation.
+   */
+  companySize: external_exports.string().trim().max(100).optional(),
+  /**
+   * Primary geographic region the segment operates in or is targeted from
+   * (e.g. "North America", "Europe", "Global").
+   */
+  region: external_exports.string().trim().max(200).optional()
+});
+var CustomerSegmentSchema = external_exports.object({
+  /** Stable unique identifier for the segment (e.g. "segment-smb-agencies"). */
+  id: external_exports.string().trim().min(1).max(100),
+  /** Human-readable name shown to agents and in UI (e.g. "SMB Marketing Agencies"). */
+  name: external_exports.string().trim().max(200).default(""),
+  /** One or two sentences describing who this segment is. */
+  description: external_exports.string().trim().max(2e3).default(""),
+  /**
+   * The primary job(s) this segment is trying to get done — the goal they hire
+   * a product/service to accomplish. Plain-language narrative or bullet list.
+   */
+  jobsToBeDone: external_exports.string().trim().max(2e3).default(""),
+  /**
+   * Pains — frustrations, obstacles, and risks the segment experiences
+   * when trying to accomplish their jobs-to-be-done.
+   */
+  pains: external_exports.array(external_exports.string().trim().max(500)).default([]),
+  /**
+   * Gains — outcomes and benefits the segment desires; positive motivators
+   * beyond merely resolving pains.
+   */
+  gains: external_exports.array(external_exports.string().trim().max(500)).default([]),
+  /** Firmographic profile for targeting and filtering. */
+  firmographics: FirmographicsSchema.default({}),
+  /**
+   * Value proposition — one or two sentences stating why this organization's
+   * offering is uniquely suited for this segment's needs.
+   */
+  valueProp: external_exports.string().trim().max(2e3).default("")
+});
+var CustomersDomainSchema = external_exports.object({
+  segments: external_exports.array(CustomerSegmentSchema).default([])
+});
+var DEFAULT_ORGANIZATION_MODEL_CUSTOMERS = {
+  segments: []
+};
+
+// ../core/src/organization-model/domains/offerings.ts
+var PricingModelSchema = external_exports.enum(["one-time", "subscription", "usage-based", "custom"]);
+var ProductSchema = external_exports.object({
+  /** Stable unique identifier for the product (e.g. "product-starter-plan"). */
+  id: external_exports.string().trim().min(1).max(100),
+  /** Human-readable name shown to agents and in UI (e.g. "Starter Plan"). */
+  name: external_exports.string().trim().max(200).default(""),
+  /** One or two sentences describing what this product/service delivers. */
+  description: external_exports.string().trim().max(2e3).default(""),
+  /**
+   * How this product is priced:
+   * - "one-time" — single purchase (setup fee, project fee)
+   * - "subscription" — recurring (monthly/annual SaaS, retainer)
+   * - "usage-based" — metered by consumption (API calls, seats)
+   * - "custom" — negotiated or bespoke pricing
+   */
+  pricingModel: PricingModelSchema.default("custom"),
+  /** Base price amount (≥ 0). Currency unit defined by `currency`. */
+  price: external_exports.number().min(0).default(0),
+  /**
+   * ISO 4217 currency code (e.g. "USD", "EUR", "GBP").
+   * Free-form string to accommodate any currency; defaults to "USD".
+   */
+  currency: external_exports.string().trim().max(10).default("USD"),
+  /**
+   * IDs of customer segments this product targets.
+   * Each id must reference a declared `customers.segments[].id`.
+   * Cross-reference enforced in `OrganizationModelSchema.superRefine()`.
+   */
+  targetSegmentIds: external_exports.array(external_exports.string().trim().min(1)).default([]),
+  /**
+   * Optional: ID of the platform feature responsible for delivering this product.
+   * When present, must reference a declared `features[].id`.
+   * Cross-reference enforced in `OrganizationModelSchema.superRefine()`.
+   */
+  deliveryFeatureId: external_exports.string().trim().min(1).optional()
+});
+var OfferingsDomainSchema = external_exports.object({
+  products: external_exports.array(ProductSchema).default([])
+});
+var DEFAULT_ORGANIZATION_MODEL_OFFERINGS = {
+  products: []
+};
+
+// ../core/src/organization-model/domains/roles.ts
+var RoleSchema = external_exports.object({
+  /** Stable unique identifier for the role (e.g. "role-ceo", "role-head-of-sales"). */
+  id: external_exports.string().trim().min(1).max(100),
+  /** Human-readable title shown to agents and in UI (e.g. "CEO", "Head of Sales"). */
+  title: external_exports.string().trim().min(1).max(200),
+  /**
+   * List of responsibilities this role owns — plain-language descriptions of
+   * what the person in this role is accountable for delivering.
+   * Defaults to empty array so minimal role definitions stay concise.
+   */
+  responsibilities: external_exports.array(external_exports.string().trim().max(500)).default([]),
+  /**
+   * Optional: ID of another role this role reports to.
+   * When present, must reference another `roles[].id` in the same organization.
+   * Cross-reference enforced in `OrganizationModelSchema.superRefine()`.
+   * Absence indicates a top-level role (no reporting line).
+   */
+  reportsToId: external_exports.string().trim().min(1).max(100).optional(),
+  /**
+   * Optional: name or email of the person currently holding this role.
+   * Free-form string — supports "Alice Johnson", "alice@example.com", or
+   * any human-readable identifier. Not validated against any user registry.
+   */
+  heldBy: external_exports.string().trim().max(200).optional()
+});
+var RolesDomainSchema = external_exports.object({
+  roles: external_exports.array(RoleSchema).default([])
+});
+var DEFAULT_ORGANIZATION_MODEL_ROLES = {
+  roles: []
+};
+
+// ../core/src/organization-model/domains/goals.ts
+var KeyResultSchema = external_exports.object({
+  /** Stable unique identifier for the measurable outcome (e.g. "kr-revenue-q1"). */
+  id: external_exports.string().trim().min(1).max(100),
+  /** Plain-language description of this measurable outcome (e.g. "Increase trial-to-paid conversion"). */
+  description: external_exports.string().trim().min(1).max(500),
+  /**
+   * What is being measured — the metric name (e.g. "monthly revenue", "NPS score",
+   * "trial-to-paid conversion rate"). Free-form string.
+   */
+  targetMetric: external_exports.string().trim().min(1).max(200),
+  /** Current measured value. Defaults to 0 when not yet tracked. */
+  currentValue: external_exports.number().default(0),
+  /**
+   * Target value to reach for this measurable outcome to be considered achieved.
+   * Optional — omit if the outcome is directional (e.g. "reduce churn") without
+   * a hard numeric target.
+   */
+  targetValue: external_exports.number().optional()
+});
+var ISO_DATE_REGEX = /^\d{4}-\d{2}-\d{2}$/;
+var ObjectiveSchema = external_exports.object({
+  /** Stable unique identifier for the goal (e.g. "goal-grow-arr-q1-2026"). */
+  id: external_exports.string().trim().min(1).max(100),
+  /** Plain-language description of what the organization wants to achieve. */
+  description: external_exports.string().trim().min(1).max(1e3),
+  /**
+   * Start of the period this goal is active for — ISO 8601 date string (YYYY-MM-DD).
+   * Must be strictly before `periodEnd`.
+   */
+  periodStart: external_exports.string().regex(ISO_DATE_REGEX, "periodStart must be an ISO date string (YYYY-MM-DD)"),
+  /**
+   * End of the period this goal is active for — ISO 8601 date string (YYYY-MM-DD).
+   * Must be strictly after `periodStart`.
+   * Enforced via `OrganizationModelSchema.superRefine()`.
+   */
+  periodEnd: external_exports.string().regex(ISO_DATE_REGEX, "periodEnd must be an ISO date string (YYYY-MM-DD)"),
+  /**
+   * List of measurable outcomes that define success for this goal.
+   * Defaults to empty array so goals can be declared before outcomes are defined.
+   */
+  keyResults: external_exports.array(KeyResultSchema).default([])
+});
+var GoalsDomainSchema = external_exports.object({
+  objectives: external_exports.array(ObjectiveSchema).default([])
+});
+var DEFAULT_ORGANIZATION_MODEL_GOALS = {
+  objectives: []
+};
+
+// ../core/src/organization-model/domains/operations.ts
+var OperationSemanticClassSchema = external_exports.enum(["queue", "executions", "sessions", "notifications", "schedules"]);
+var OperationEntrySchema = external_exports.object({
+  id: external_exports.string().trim().min(1).max(100),
+  label: external_exports.string().trim().min(1).max(120),
+  semanticClass: OperationSemanticClassSchema,
+  /** Optional reference to the feature that owns this runtime entity. */
+  featureId: external_exports.string().trim().min(1).max(100).optional(),
+  /**
+   * Optional pointer to the status semanticClass values that apply to this
+   * entity — ties operations back to the statuses domain for vibe rendering.
+   */
+  supportedStatusSemanticClass: external_exports.array(external_exports.string().trim().min(1).max(80)).optional()
+});
+var OperationsDomainSchema = external_exports.object({
+  entries: external_exports.array(OperationEntrySchema).default([])
+});
+var DEFAULT_ORGANIZATION_MODEL_OPERATIONS = {
+  entries: [
+    // --- queue (HITL command queue) ---
+    {
+      id: "operations.queue",
+      label: "HITL Queue",
+      semanticClass: "queue",
+      featureId: "operations",
+      supportedStatusSemanticClass: ["queue"]
+    },
+    // --- executions (workflow / agent executions) ---
+    {
+      id: "operations.executions",
+      label: "Executions",
+      semanticClass: "executions",
+      featureId: "operations",
+      supportedStatusSemanticClass: ["execution"]
+    },
+    // --- sessions (agent conversation sessions) ---
+    {
+      id: "operations.sessions",
+      label: "Sessions",
+      semanticClass: "sessions",
+      featureId: "operations"
+    },
+    // --- notifications (platform in-app notifications) ---
+    {
+      id: "operations.notifications",
+      label: "Notifications",
+      semanticClass: "notifications",
+      featureId: "monitoring"
+    },
+    // --- schedules (task scheduler) ---
+    {
+      id: "operations.schedules",
+      label: "Schedules",
+      semanticClass: "schedules",
+      featureId: "operations",
+      supportedStatusSemanticClass: ["schedule", "schedule.run"]
+    }
+  ]
+};
+
+// ../core/src/organization-model/domains/statuses.ts
+var StatusSemanticClassSchema = external_exports.enum([
+  "delivery.task",
+  "delivery.project",
+  "delivery.milestone",
+  "queue",
+  "execution",
+  "schedule",
+  "schedule.run",
+  "request"
+]);
+var StatusEntrySchema = external_exports.object({
+  id: external_exports.string().trim().min(1).max(100),
+  label: external_exports.string().trim().min(1).max(120),
+  semanticClass: StatusSemanticClassSchema,
+  category: external_exports.string().trim().min(1).max(80).optional()
+});
+var StatusesDomainSchema = external_exports.object({
+  entries: external_exports.array(StatusEntrySchema).default([])
+});
+var DEFAULT_ORGANIZATION_MODEL_STATUSES = {
+  entries: [
+    // --- delivery.task (TaskStatus — 9 values) ---
+    { id: "delivery.task.planned", label: "Planned", semanticClass: "delivery.task", category: "delivery" },
+    { id: "delivery.task.in_progress", label: "In Progress", semanticClass: "delivery.task", category: "delivery" },
+    { id: "delivery.task.blocked", label: "Blocked", semanticClass: "delivery.task", category: "delivery" },
+    { id: "delivery.task.submitted", label: "Submitted", semanticClass: "delivery.task", category: "delivery" },
+    { id: "delivery.task.approved", label: "Approved", semanticClass: "delivery.task", category: "delivery" },
+    {
+      id: "delivery.task.revision_requested",
+      label: "Revision Requested",
+      semanticClass: "delivery.task",
+      category: "delivery"
+    },
+    { id: "delivery.task.rejected", label: "Rejected", semanticClass: "delivery.task", category: "delivery" },
+    { id: "delivery.task.cancelled", label: "Cancelled", semanticClass: "delivery.task", category: "delivery" },
+    { id: "delivery.task.completed", label: "Completed", semanticClass: "delivery.task", category: "delivery" },
+    // --- delivery.project (ProjectStatus — 6 values) ---
+    { id: "delivery.project.active", label: "Active", semanticClass: "delivery.project", category: "delivery" },
+    { id: "delivery.project.on_track", label: "On Track", semanticClass: "delivery.project", category: "delivery" },
+    { id: "delivery.project.at_risk", label: "At Risk", semanticClass: "delivery.project", category: "delivery" },
+    { id: "delivery.project.blocked", label: "Blocked", semanticClass: "delivery.project", category: "delivery" },
+    { id: "delivery.project.paused", label: "Paused", semanticClass: "delivery.project", category: "delivery" },
+    { id: "delivery.project.completed", label: "Completed", semanticClass: "delivery.project", category: "delivery" },
+    // --- delivery.milestone (MilestoneStatus — 5 values) ---
+    {
+      id: "delivery.milestone.upcoming",
+      label: "Upcoming",
+      semanticClass: "delivery.milestone",
+      category: "delivery"
+    },
+    {
+      id: "delivery.milestone.in_progress",
+      label: "In Progress",
+      semanticClass: "delivery.milestone",
+      category: "delivery"
+    },
+    {
+      id: "delivery.milestone.blocked",
+      label: "Blocked",
+      semanticClass: "delivery.milestone",
+      category: "delivery"
+    },
+    { id: "delivery.milestone.overdue", label: "Overdue", semanticClass: "delivery.milestone", category: "delivery" },
+    {
+      id: "delivery.milestone.completed",
+      label: "Completed",
+      semanticClass: "delivery.milestone",
+      category: "delivery"
+    },
+    // --- queue (QueueTaskStatus — 5 values, maps hitl/command-queue tasks) ---
+    { id: "queue.pending", label: "Pending", semanticClass: "queue", category: "queue" },
+    { id: "queue.processing", label: "Processing", semanticClass: "queue", category: "queue" },
+    { id: "queue.completed", label: "Completed", semanticClass: "queue", category: "queue" },
+    { id: "queue.failed", label: "Failed", semanticClass: "queue", category: "queue" },
+    { id: "queue.expired", label: "Expired", semanticClass: "queue", category: "queue" },
+    // --- execution (ExecutionStatus — 5 values) ---
+    { id: "execution.pending", label: "Pending", semanticClass: "execution", category: "execution" },
+    { id: "execution.running", label: "Running", semanticClass: "execution", category: "execution" },
+    { id: "execution.completed", label: "Completed", semanticClass: "execution", category: "execution" },
+    { id: "execution.failed", label: "Failed", semanticClass: "execution", category: "execution" },
+    { id: "execution.warning", label: "Warning", semanticClass: "execution", category: "execution" },
+    // --- schedule (schedule status — 4 values) ---
+    { id: "schedule.active", label: "Active", semanticClass: "schedule", category: "schedule" },
+    { id: "schedule.paused", label: "Paused", semanticClass: "schedule", category: "schedule" },
+    { id: "schedule.completed", label: "Completed", semanticClass: "schedule", category: "schedule" },
+    { id: "schedule.cancelled", label: "Cancelled", semanticClass: "schedule", category: "schedule" },
+    // --- schedule.run (schedule run status — 4 values) ---
+    { id: "schedule.run.running", label: "Running", semanticClass: "schedule.run", category: "schedule" },
+    { id: "schedule.run.completed", label: "Completed", semanticClass: "schedule.run", category: "schedule" },
+    { id: "schedule.run.failed", label: "Failed", semanticClass: "schedule.run", category: "schedule" },
+    { id: "schedule.run.cancelled", label: "Cancelled", semanticClass: "schedule.run", category: "schedule" },
+    // --- request (RequestStatus — 4 values, maps reported_requests) ---
+    { id: "request.open", label: "Open", semanticClass: "request", category: "request" },
+    { id: "request.investigating", label: "Investigating", semanticClass: "request", category: "request" },
+    { id: "request.resolved", label: "Resolved", semanticClass: "request", category: "request" },
+    { id: "request.wont_fix", label: "Won't Fix", semanticClass: "request", category: "request" }
+  ]
+};
+
+// ../core/src/organization-model/domains/knowledge.ts
+var KnowledgeLinkSchema = external_exports.object({
+  nodeId: NodeIdStringSchema
+});
+var OrgKnowledgeKindSchema = external_exports.enum(["playbook", "strategy", "reference"]);
+var OrgKnowledgeNodeSchema = external_exports.object({
+  id: ModelIdSchema,
+  kind: OrgKnowledgeKindSchema,
+  title: external_exports.string().trim().min(1).max(200),
+  summary: external_exports.string().trim().min(1).max(1e3),
+  icon: IconNameSchema.optional(),
+  /** Raw MDX string. Phase 2 will introduce a structured block format. */
+  body: external_exports.string().trim().min(1),
+  /**
+   * Graph links to other OM nodes this knowledge node governs.
+   * Each link emits a `governs` edge: knowledge-node -> target node.
+   */
+  links: external_exports.array(KnowledgeLinkSchema).default([]),
+  /** Identifiers of the roles or members who own this knowledge node. */
+  ownerIds: external_exports.array(ModelIdSchema).default([]),
+  /** ISO date string (YYYY-MM-DD or full ISO 8601) of last meaningful update. */
+  updatedAt: external_exports.string().trim().min(1).max(50)
+});
+var KnowledgeDomainSchema = external_exports.object({
+  nodes: external_exports.array(OrgKnowledgeNodeSchema).default([])
+});
+
+// ../core/src/organization-model/schema.ts
+var OrganizationModelSchemaBase = external_exports.object({
+  version: external_exports.literal(1).default(1),
+  features: external_exports.array(FeatureSchema).default([]),
+  branding: OrganizationModelBrandingSchema,
+  navigation: OrganizationModelNavigationSchema.default({ surfaces: [], groups: [] }),
+  sales: OrganizationModelSalesSchema,
+  prospecting: OrganizationModelProspectingSchema,
+  projects: OrganizationModelProjectsSchema,
+  identity: IdentityDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_IDENTITY),
+  customers: CustomersDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_CUSTOMERS),
+  offerings: OfferingsDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_OFFERINGS),
+  roles: RolesDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_ROLES),
+  goals: GoalsDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_GOALS),
+  statuses: StatusesDomainSchema.default({ entries: [] }),
+  operations: OperationsDomainSchema.default({ entries: [] }),
+  knowledge: KnowledgeDomainSchema.default({ nodes: [] })
+});
+function addIssue(ctx, path3, message) {
+  ctx.addIssue({
+    code: external_exports.ZodIssueCode.custom,
+    path: path3,
+    message
+  });
+}
+function collectIds(items, ctx, collectionPath, label) {
+  const itemsById = /* @__PURE__ */ new Map();
+  items.forEach((item, index) => {
+    if (itemsById.has(item.id)) {
+      addIssue(ctx, [...collectionPath, index, "id"], `${label} id "${item.id}" must be unique`);
+      return;
+    }
+    itemsById.set(item.id, item);
+  });
+  return itemsById;
+}
+var LEGACY_FEATURE_ALIASES = /* @__PURE__ */ new Map([
+  ["crm", "sales.crm"],
+  ["lead-gen", "sales.lead-gen"],
+  ["submitted-requests", "monitoring.submitted-requests"]
+]);
+function hasFeature(featuresById, featureId) {
+  return featuresById.has(featureId) || featuresById.has(LEGACY_FEATURE_ALIASES.get(featureId) ?? "");
+}
+var OrganizationModelSchema = OrganizationModelSchemaBase.superRefine((model, ctx) => {
+  const featuresById = collectIds(model.features, ctx, ["features"], "Feature");
+  model.features.forEach((feature, featureIndex) => {
+    const segments = feature.id.split(".");
+    if (segments.length > 1) {
+      const parentId = segments.slice(0, -1).join(".");
+      if (!featuresById.has(parentId)) {
+        addIssue(
+          ctx,
+          ["features", featureIndex, "id"],
+          `Feature "${feature.id}" references unknown parent "${parentId}"`
+        );
+      }
+    }
+    const hasChildren = model.features.some(
+      (candidate) => candidate.id.startsWith(`${feature.id}.`) && candidate.id !== feature.id
+    );
+    if (hasChildren && feature.enabled) {
+      const hasEnabledDescendant = model.features.some(
+        (candidate) => candidate.id.startsWith(`${feature.id}.`) && candidate.enabled
+      );
+      if (!hasEnabledDescendant) {
+        addIssue(
+          ctx,
+          ["features", featureIndex, "enabled"],
+          `Feature "${feature.id}" is enabled but has no enabled descendants`
+        );
+      }
+    }
+  });
+  const segmentsById = new Map(model.customers.segments.map((seg) => [seg.id, seg]));
+  model.offerings.products.forEach((product, productIndex) => {
+    product.targetSegmentIds.forEach((segmentId, segmentIndex) => {
+      if (!segmentsById.has(segmentId)) {
+        addIssue(
+          ctx,
+          ["offerings", "products", productIndex, "targetSegmentIds", segmentIndex],
+          `Product "${product.id}" references unknown customer segment "${segmentId}"`
+        );
+      }
+    });
+    if (product.deliveryFeatureId !== void 0 && !hasFeature(featuresById, product.deliveryFeatureId)) {
+      addIssue(
+        ctx,
+        ["offerings", "products", productIndex, "deliveryFeatureId"],
+        `Product "${product.id}" references unknown delivery feature "${product.deliveryFeatureId}"`
+      );
+    }
+  });
+  model.goals.objectives.forEach((objective, index) => {
+    if (objective.periodEnd <= objective.periodStart) {
+      addIssue(
+        ctx,
+        ["goals", "objectives", index, "periodEnd"],
+        `Goal "${objective.id}" has periodEnd "${objective.periodEnd}" which must be strictly after periodStart "${objective.periodStart}"`
+      );
+    }
+  });
+  const rolesById = new Map(model.roles.roles.map((role) => [role.id, role]));
+  model.roles.roles.forEach((role, roleIndex) => {
+    if (role.reportsToId !== void 0 && !rolesById.has(role.reportsToId)) {
+      addIssue(
+        ctx,
+        ["roles", "roles", roleIndex, "reportsToId"],
+        `Role "${role.id}" references unknown reportsToId "${role.reportsToId}"`
+      );
+    }
+  });
+});
+
+// ../core/src/organization-model/graph/schema.ts
+var OrganizationGraphNodeKindSchema = external_exports.enum([
+  "organization",
+  "feature",
+  "surface",
+  "entity",
+  "capability",
+  "resource",
+  "knowledge"
+]);
+var OrganizationGraphEdgeKindSchema = external_exports.enum([
+  "contains",
+  "references",
+  "exposes",
+  "maps_to",
+  "operates-on",
+  "uses",
+  "governs"
+]);
+var OrganizationGraphNodeSchema = external_exports.object({
+  id: external_exports.string().trim().min(1).max(200),
+  kind: OrganizationGraphNodeKindSchema,
+  label: LabelSchema,
+  sourceId: external_exports.string().trim().min(1).max(255).optional(),
+  description: DescriptionSchema.optional(),
+  icon: IconNameSchema.optional(),
+  enabled: external_exports.boolean().optional(),
+  featureId: external_exports.string().trim().min(1).max(100).optional(),
+  resourceType: external_exports.enum(["workflow", "agent", "trigger", "integration", "external", "human_checkpoint"]).optional()
+});
+var OrganizationGraphEdgeSchema = external_exports.object({
+  id: external_exports.string().trim().min(1).max(250),
+  kind: OrganizationGraphEdgeKindSchema,
+  sourceId: external_exports.string().trim().min(1).max(200),
+  targetId: external_exports.string().trim().min(1).max(200),
+  label: external_exports.string().trim().min(1).max(120).optional(),
+  relationshipType: external_exports.enum(["triggers", "uses", "approval"]).optional()
+});
+var OrganizationGraphSchema = external_exports.object({
+  version: external_exports.literal(1),
+  organizationModelVersion: OrganizationModelSchema.shape.version,
+  nodes: external_exports.array(OrganizationGraphNodeSchema),
+  edges: external_exports.array(OrganizationGraphEdgeSchema)
+});
+var BuildOrganizationGraphInputSchema = external_exports.object({
+  organizationModel: OrganizationModelSchema,
+  commandViewData: external_exports.unknown().optional()
+});
+
 // ../core/src/platform/registry/reserved.ts
 var RESERVED_RESOURCE_IDS = /* @__PURE__ */ new Set(["command-center-assistant"]);
 var SYSTEM_RESOURCE_IDS = Array.from(RESERVED_RESOURCE_IDS);
@@ -39549,11 +40689,11 @@ function serializeOrganization(resources) {
 }
 function buildEdges(resources) {
   const edges = [];
-  let edgeId = 0;
+  let edgeId2 = 0;
   for (const [resourceId, declaration] of Object.entries(resources.relationships ?? {})) {
     for (const agentId of declaration.triggers?.agents ?? []) {
       edges.push({
-        id: `edge-${edgeId++}`,
+        id: `edge-${edgeId2++}`,
         source: resourceId,
         target: agentId,
         relationship: "triggers"
@@ -39561,7 +40701,7 @@ function buildEdges(resources) {
     }
     for (const workflowId of declaration.triggers?.workflows ?? []) {
       edges.push({
-        id: `edge-${edgeId++}`,
+        id: `edge-${edgeId2++}`,
         source: resourceId,
         target: workflowId,
         relationship: "triggers"
@@ -39569,7 +40709,7 @@ function buildEdges(resources) {
     }
     for (const integrationId of declaration.uses?.integrations ?? []) {
       edges.push({
-        id: `edge-${edgeId++}`,
+        id: `edge-${edgeId2++}`,
         source: resourceId,
         target: integrationId,
         relationship: "uses"
@@ -39579,7 +40719,7 @@ function buildEdges(resources) {
   for (const external of resources.externalResources ?? []) {
     for (const workflowId of external.triggers?.workflows ?? []) {
       edges.push({
-        id: `edge-${edgeId++}`,
+        id: `edge-${edgeId2++}`,
         source: external.resourceId,
         target: workflowId,
         relationship: "triggers"
@@ -39587,7 +40727,7 @@ function buildEdges(resources) {
     }
     for (const agentId of external.triggers?.agents ?? []) {
       edges.push({
-        id: `edge-${edgeId++}`,
+        id: `edge-${edgeId2++}`,
         source: external.resourceId,
         target: agentId,
         relationship: "triggers"
@@ -39595,7 +40735,7 @@ function buildEdges(resources) {
     }
     for (const integrationId of external.uses?.integrations ?? []) {
       edges.push({
-        id: `edge-${edgeId++}`,
+        id: `edge-${edgeId2++}`,
         source: external.resourceId,
         target: integrationId,
         relationship: "uses"
@@ -39605,7 +40745,7 @@ function buildEdges(resources) {
   for (const humanCheckpoint of resources.humanCheckpoints ?? []) {
     for (const agentId of humanCheckpoint.requestedBy?.agents ?? []) {
       edges.push({
-        id: `edge-${edgeId++}`,
+        id: `edge-${edgeId2++}`,
         source: agentId,
         target: humanCheckpoint.resourceId,
         relationship: "approval"
@@ -39613,7 +40753,7 @@ function buildEdges(resources) {
     }
     for (const workflowId of humanCheckpoint.requestedBy?.workflows ?? []) {
       edges.push({
-        id: `edge-${edgeId++}`,
+        id: `edge-${edgeId2++}`,
         source: workflowId,
         target: humanCheckpoint.resourceId,
         relationship: "approval"
@@ -39621,7 +40761,7 @@ function buildEdges(resources) {
     }
     for (const agentId of humanCheckpoint.routesTo?.agents ?? []) {
       edges.push({
-        id: `edge-${edgeId++}`,
+        id: `edge-${edgeId2++}`,
         source: humanCheckpoint.resourceId,
         target: agentId,
         relationship: "triggers"
@@ -39629,7 +40769,7 @@ function buildEdges(resources) {
     }
     for (const workflowId of humanCheckpoint.routesTo?.workflows ?? []) {
       edges.push({
-        id: `edge-${edgeId++}`,
+        id: `edge-${edgeId2++}`,
         source: humanCheckpoint.resourceId,
         target: workflowId,
         relationship: "triggers"
@@ -40241,49 +41381,517 @@ var ResourceRegistry = class {
     }
     return cache.commandView;
   }
-  /**
-   * List resources that have UI interfaces configured
-   * Used by Execution Runner Catalog UI
-   *
-   * @param organizationName - Organization name
-   * @param environment - Optional environment filter ('dev' or 'prod')
-   * @returns Array of resources with interfaces
-   */
-  listExecutable(organizationName, environment) {
-    const cache = this.serializedCache.get(organizationName);
-    if (!cache) {
-      return [];
+};
+
+// ../core/src/organization-model/defaults.ts
+var DEFAULT_ORGANIZATION_MODEL_KNOWLEDGE = {
+  nodes: []
+};
+var DEFAULT_ORGANIZATION_MODEL = {
+  version: 1,
+  features: [
+    {
+      id: "dashboard",
+      label: "Dashboard",
+      enabled: true,
+      path: "/",
+      icon: "feature.dashboard",
+      uiPosition: "sidebar-primary"
+    },
+    {
+      id: "identity",
+      label: "Identity",
+      description: "Company identity, positioning, and market context",
+      enabled: true,
+      color: "indigo"
+    },
+    {
+      id: "platform",
+      label: "Platform",
+      description: "Elevasis platform architecture, capabilities, and implementation patterns",
+      enabled: true,
+      color: "cyan",
+      icon: "feature.platform"
+    },
+    {
+      id: "finance",
+      label: "Finance",
+      description: "Finance operations, accounting, billing, reconciliation, and tax prep",
+      enabled: true,
+      color: "green",
+      icon: "feature.finance"
+    },
+    {
+      id: "sales",
+      label: "Sales",
+      description: "Revenue workflows and customer acquisition",
+      enabled: true,
+      color: "blue",
+      icon: "feature.sales",
+      uiPosition: "sidebar-primary"
+    },
+    {
+      id: "sales.crm",
+      label: "CRM",
+      description: "Relationship pipeline and deal management",
+      enabled: true,
+      color: "blue",
+      icon: "feature.crm",
+      path: "/crm"
+    },
+    {
+      id: "sales.lead-gen",
+      label: "Lead Gen",
+      description: "Prospecting, qualification, and outreach preparation",
+      enabled: true,
+      color: "cyan",
+      icon: "feature.lead-gen",
+      path: "/lead-gen"
+    },
+    {
+      id: "projects",
+      label: "Projects",
+      description: "Projects, milestones, and client work execution",
+      enabled: true,
+      color: "orange",
+      icon: "feature.projects",
+      path: "/projects",
+      uiPosition: "sidebar-primary"
+    },
+    {
+      id: "operations",
+      label: "Operations",
+      description: "Operational resources, topology, and orchestration visibility",
+      enabled: true,
+      color: "violet",
+      icon: "feature.operations",
+      uiPosition: "sidebar-primary"
+    },
+    {
+      id: "knowledge.command-view",
+      label: "Command View",
+      enabled: true,
+      path: "/knowledge/command-view",
+      devOnly: true
+    },
+    {
+      id: "operations.overview",
+      label: "Overview",
+      enabled: true,
+      path: "/operations"
+    },
+    {
+      id: "operations.resources",
+      label: "Resources",
+      enabled: true,
+      path: "/operations/resources"
+    },
+    {
+      id: "operations.command-queue",
+      label: "Command Queue",
+      enabled: true,
+      path: "/operations/command-queue"
+    },
+    {
+      id: "operations.sessions",
+      label: "Sessions",
+      enabled: false,
+      path: "/operations/sessions"
+    },
+    {
+      id: "operations.task-scheduler",
+      label: "Task Scheduler",
+      enabled: true,
+      path: "/operations/task-scheduler"
+    },
+    {
+      id: "monitoring",
+      label: "Monitoring",
+      enabled: true,
+      uiPosition: "sidebar-primary"
+    },
+    {
+      id: "monitoring.activity-log",
+      label: "Activity Log",
+      enabled: true,
+      path: "/monitoring/activity-log"
+    },
+    {
+      id: "monitoring.execution-logs",
+      label: "Execution Logs",
+      enabled: true,
+      path: "/monitoring/execution-logs"
+    },
+    {
+      id: "monitoring.execution-health",
+      label: "Execution Health",
+      enabled: true,
+      path: "/monitoring/execution-health"
+    },
+    {
+      id: "monitoring.cost-analytics",
+      label: "Cost Analytics",
+      enabled: false,
+      path: "/monitoring/cost-analytics"
+    },
+    {
+      id: "monitoring.notifications",
+      label: "Notifications",
+      enabled: true,
+      path: "/monitoring/notifications"
+    },
+    {
+      id: "monitoring.submitted-requests",
+      label: "Submitted Requests",
+      enabled: true,
+      path: "/monitoring/requests"
+    },
+    {
+      id: "settings",
+      label: "Settings",
+      enabled: true,
+      icon: "feature.settings",
+      uiPosition: "sidebar-bottom"
+    },
+    {
+      id: "settings.account",
+      label: "Account",
+      enabled: true,
+      path: "/settings/account"
+    },
+    {
+      id: "settings.appearance",
+      label: "Appearance",
+      enabled: true,
+      path: "/settings/appearance"
+    },
+    {
+      id: "settings.roles",
+      label: "My Roles",
+      enabled: true,
+      path: "/settings/roles"
+    },
+    {
+      id: "settings.organization",
+      label: "Organization",
+      enabled: true,
+      path: "/settings/organization"
+    },
+    {
+      id: "settings.credentials",
+      label: "Credentials",
+      enabled: true,
+      path: "/settings/credentials"
+    },
+    {
+      id: "settings.api-keys",
+      label: "API Keys",
+      enabled: true,
+      path: "/settings/api-keys"
+    },
+    {
+      id: "settings.webhooks",
+      label: "Webhooks",
+      enabled: true,
+      path: "/settings/webhooks"
+    },
+    {
+      id: "settings.deployments",
+      label: "Deployments",
+      enabled: true,
+      path: "/settings/deployments"
+    },
+    {
+      id: "admin",
+      label: "Admin",
+      enabled: true,
+      path: "/admin",
+      icon: "feature.admin",
+      uiPosition: "sidebar-bottom",
+      requiresAdmin: true
+    },
+    {
+      id: "admin.system-health",
+      label: "System Health",
+      enabled: true,
+      path: "/admin/system-health"
+    },
+    {
+      id: "admin.organizations",
+      label: "Organizations",
+      enabled: true,
+      path: "/admin/organizations"
+    },
+    {
+      id: "admin.users",
+      label: "Users",
+      enabled: true,
+      path: "/admin/users"
+    },
+    {
+      id: "admin.design-showcase",
+      label: "Design Showcase",
+      enabled: true,
+      path: "/admin/design-showcase"
+    },
+    {
+      id: "admin.debug",
+      label: "Debug",
+      enabled: true,
+      path: "/admin/debug"
+    },
+    {
+      id: "archive",
+      label: "Archive",
+      enabled: true,
+      path: "/archive",
+      icon: "feature.archive",
+      uiPosition: "sidebar-bottom",
+      devOnly: true
+    },
+    {
+      id: "archive.agent-chat",
+      label: "Agent Chat",
+      enabled: true,
+      path: "/archive/agent-chat"
+    },
+    {
+      id: "archive.execution-runner",
+      label: "Execution Runner",
+      enabled: true,
+      path: "/archive/execution-runner"
+    },
+    {
+      id: "seo",
+      label: "SEO",
+      enabled: false,
+      path: "/seo"
+    },
+    {
+      id: "knowledge",
+      label: "Knowledge",
+      description: "Operational knowledge, playbooks, and strategy docs",
+      enabled: true,
+      color: "teal",
+      icon: "feature.knowledge",
+      uiPosition: "sidebar-primary"
+    },
+    {
+      id: "knowledge.base",
+      label: "Knowledge Base",
+      enabled: true,
+      path: "/knowledge"
     }
-    const results = [];
-    cache.definitions.workflows.forEach((serializedWorkflow, resourceId) => {
-      if (!serializedWorkflow.interface) return;
-      if (environment && serializedWorkflow.config.status !== environment) return;
-      results.push({
-        resourceId,
-        resourceName: serializedWorkflow.config.name,
-        resourceType: "workflow",
-        description: serializedWorkflow.config.description,
-        status: serializedWorkflow.config.status,
-        version: serializedWorkflow.config.version,
-        interface: serializedWorkflow.interface
-      });
-    });
-    cache.definitions.agents.forEach((serializedAgent, resourceId) => {
-      if (!serializedAgent.interface) return;
-      if (environment && serializedAgent.config.status !== environment) return;
-      results.push({
-        resourceId,
-        resourceName: serializedAgent.config.name,
-        resourceType: "agent",
-        description: serializedAgent.config.description,
-        status: serializedAgent.config.status,
-        version: serializedAgent.config.version,
-        interface: serializedAgent.interface
-      });
+  ],
+  branding: DEFAULT_ORGANIZATION_MODEL_BRANDING,
+  navigation: { surfaces: [], groups: [] },
+  sales: DEFAULT_ORGANIZATION_MODEL_SALES,
+  prospecting: DEFAULT_ORGANIZATION_MODEL_PROSPECTING,
+  projects: DEFAULT_ORGANIZATION_MODEL_PROJECTS,
+  identity: DEFAULT_ORGANIZATION_MODEL_IDENTITY,
+  customers: DEFAULT_ORGANIZATION_MODEL_CUSTOMERS,
+  offerings: DEFAULT_ORGANIZATION_MODEL_OFFERINGS,
+  roles: DEFAULT_ORGANIZATION_MODEL_ROLES,
+  goals: DEFAULT_ORGANIZATION_MODEL_GOALS,
+  statuses: DEFAULT_ORGANIZATION_MODEL_STATUSES,
+  operations: DEFAULT_ORGANIZATION_MODEL_OPERATIONS,
+  knowledge: DEFAULT_ORGANIZATION_MODEL_KNOWLEDGE
+};
+
+// ../core/src/organization-model/graph/build.ts
+function nodeId(kind, sourceId) {
+  return kind === "organization" ? "organization-model" : `${kind}:${sourceId ?? ""}`;
+}
+function edgeId(kind, sourceId, targetId, variant) {
+  return variant ? `edge:${kind}:${variant}:${sourceId}:${targetId}` : `edge:${kind}:${sourceId}:${targetId}`;
+}
+function pushUniqueNode(nodes, seen, node) {
+  if (seen.has(node.id)) return;
+  seen.add(node.id);
+  nodes.push(node);
+}
+function pushUniqueEdge(edges, seen, edge) {
+  if (seen.has(edge.id)) return;
+  seen.add(edge.id);
+  edges.push(edge);
+}
+function upsertResourceNode(nodes, seen, resourceNodesById, node) {
+  const existing = resourceNodesById.get(node.id);
+  if (existing) {
+    if (!existing.label || existing.label === existing.sourceId) {
+      existing.label = node.label;
+    }
+    if (!existing.description && node.description) {
+      existing.description = node.description;
+    }
+    if (!existing.sourceId && node.sourceId) {
+      existing.sourceId = node.sourceId;
+    }
+    if (!existing.resourceType && node.resourceType) {
+      existing.resourceType = node.resourceType;
+    }
+    return existing;
+  }
+  resourceNodesById.set(node.id, node);
+  pushUniqueNode(nodes, seen, node);
+  return node;
+}
+function ensureResourceNode(nodes, seen, resourceNodesById, resourceId) {
+  const existing = resourceNodesById.get(nodeId("resource", resourceId));
+  if (existing) return existing;
+  return upsertResourceNode(nodes, seen, resourceNodesById, {
+    id: nodeId("resource", resourceId),
+    kind: "resource",
+    label: resourceId,
+    sourceId: resourceId
+  });
+}
+function normalizeCommandViewResourceType(resourceType) {
+  return resourceType === "human" ? "human_checkpoint" : resourceType;
+}
+function collectCommandViewResources(commandViewData) {
+  return [
+    ...commandViewData.workflows,
+    ...commandViewData.agents,
+    ...commandViewData.triggers,
+    ...commandViewData.integrations,
+    ...commandViewData.externalResources,
+    ...commandViewData.humanCheckpoints
+  ];
+}
+function pushResourceLinks(edges, edgeIds, resourceNodeId, links) {
+  for (const link of links ?? []) {
+    pushUniqueEdge(edges, edgeIds, {
+      id: edgeId(link.kind, resourceNodeId, link.nodeId),
+      kind: link.kind,
+      sourceId: resourceNodeId,
+      targetId: link.nodeId
     });
-    return results;
   }
-};
+}
+function buildOrganizationGraph(input) {
+  const parsed = BuildOrganizationGraphInputSchema.parse(input);
+  const organizationModel = parsed.organizationModel;
+  const commandViewData = parsed.commandViewData;
+  const nodes = [];
+  const edges = [];
+  const nodeIds = /* @__PURE__ */ new Set();
+  const edgeIds = /* @__PURE__ */ new Set();
+  const resourceNodesById = /* @__PURE__ */ new Map();
+  const organizationNode = {
+    id: nodeId("organization"),
+    kind: "organization",
+    label: "Organization Model"
+  };
+  pushUniqueNode(nodes, nodeIds, organizationNode);
+  for (const feature of [...organizationModel.features].sort((a, b) => a.id.localeCompare(b.id))) {
+    const id = nodeId("feature", feature.id);
+    pushUniqueNode(nodes, nodeIds, {
+      id,
+      kind: "feature",
+      label: feature.label,
+      sourceId: feature.id,
+      description: feature.description,
+      icon: feature.icon,
+      enabled: feature.enabled,
+      featureId: feature.id
+    });
+    pushUniqueEdge(edges, edgeIds, {
+      id: edgeId("contains", organizationNode.id, id),
+      kind: "contains",
+      sourceId: organizationNode.id,
+      targetId: id
+    });
+    const parentId = feature.id.includes(".") ? feature.id.slice(0, feature.id.lastIndexOf(".")) : void 0;
+    if (parentId) {
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId("contains", nodeId("feature", parentId), id),
+        kind: "contains",
+        sourceId: nodeId("feature", parentId),
+        targetId: id
+      });
+    }
+  }
+  for (const node of [...organizationModel.knowledge?.nodes ?? []].sort((a, b) => a.id.localeCompare(b.id))) {
+    const id = nodeId("knowledge", node.id);
+    pushUniqueNode(nodes, nodeIds, {
+      id,
+      kind: "knowledge",
+      label: node.title,
+      sourceId: node.id,
+      description: node.summary,
+      icon: node.icon
+    });
+    pushUniqueEdge(edges, edgeIds, {
+      id: edgeId("contains", organizationNode.id, id),
+      kind: "contains",
+      sourceId: organizationNode.id,
+      targetId: id
+    });
+    for (const link of node.links) {
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId("governs", id, link.nodeId),
+        kind: "governs",
+        sourceId: id,
+        targetId: link.nodeId
+      });
+    }
+  }
+  if (commandViewData) {
+    const commandViewResources = collectCommandViewResources(commandViewData).sort(
+      (a, b) => a.resourceId.localeCompare(b.resourceId)
+    );
+    for (const resource of commandViewResources) {
+      const id = nodeId("resource", resource.resourceId);
+      const resourceNode = upsertResourceNode(nodes, nodeIds, resourceNodesById, {
+        id,
+        kind: "resource",
+        label: resource.name,
+        sourceId: resource.resourceId,
+        description: resource.description,
+        resourceType: normalizeCommandViewResourceType(resource.type)
+      });
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId("contains", organizationNode.id, resourceNode.id),
+        kind: "contains",
+        sourceId: organizationNode.id,
+        targetId: resourceNode.id
+      });
+      pushResourceLinks(edges, edgeIds, resourceNode.id, resource.links);
+    }
+    for (const relationship of [...commandViewData.edges].sort((a, b) => a.id.localeCompare(b.id))) {
+      const sourceNode = ensureResourceNode(nodes, nodeIds, resourceNodesById, relationship.source);
+      const targetNode = ensureResourceNode(nodes, nodeIds, resourceNodesById, relationship.target);
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId("contains", organizationNode.id, sourceNode.id),
+        kind: "contains",
+        sourceId: organizationNode.id,
+        targetId: sourceNode.id
+      });
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId("contains", organizationNode.id, targetNode.id),
+        kind: "contains",
+        sourceId: organizationNode.id,
+        targetId: targetNode.id
+      });
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId("references", sourceNode.id, targetNode.id, relationship.relationship),
+        kind: "references",
+        sourceId: sourceNode.id,
+        targetId: targetNode.id,
+        label: relationship.relationship,
+        relationshipType: relationship.relationship
+      });
+    }
+  }
+  const graph = {
+    version: 1,
+    organizationModelVersion: organizationModel.version,
+    nodes,
+    edges
+  };
+  return OrganizationGraphSchema.parse(graph);
+}
 
 // src/cli/config.ts
 var import_fs = require("fs");
@@ -40481,7 +42089,7 @@ function wrapAction(commandName, fn) {
 // package.json
 var package_default = {
   name: "@elevasis/sdk",
-  version: "1.15.0",
+  version: "1.16.0",
   description: "SDK for building Elevasis organization resources",
   type: "module",
   bin: {
@@ -40499,6 +42107,10 @@ var package_default = {
     "./test-utils": {
       types: "./dist/test-utils/index.d.ts",
       import: "./dist/test-utils/index.js"
+    },
+    "./node": {
+      types: "./dist/node/index.d.ts",
+      import: "./dist/node/index.js"
     }
   },
   files: [
@@ -40510,10 +42122,12 @@ var package_default = {
     "dist/types/worker/adapters/",
     "dist/test-utils/index.js",
     "dist/test-utils/index.d.ts",
+    "dist/node/",
     "dist/cli.cjs",
     "reference/"
   ],
   scripts: {
+    lint: "eslint src --max-warnings 0",
     build: `node -e "require('fs').rmSync('dist',{recursive:true,force:true})" && tsc -p tsconfig.core-dts.json && tsc -p tsconfig.build.json && tsup && rollup -c rollup.dts.config.mjs && esbuild src/cli/index.ts --bundle --platform=node --outfile=dist/cli.cjs --format=cjs --external:esbuild --banner:js="#!/usr/bin/env node" && node scripts/copy-reference-docs.mjs && node ../../scripts/monorepo/generate-reference-artifacts.js`,
     "type-check": "tsc --noEmit",
     "check-types": "pnpm type-check",
@@ -40521,13 +42135,16 @@ var package_default = {
     "test:bundle": "pnpm test"
   },
   dependencies: {
-    esbuild: "^0.25.0"
+    "@mdx-js/mdx": "^3.1.1",
+    esbuild: "^0.25.0",
+    "remark-gfm": "^4.0.1"
   },
   peerDependencies: {
     zod: "^4.1.0"
   },
   devDependencies: {
     "@repo/core": "workspace:*",
+    "@repo/eslint-config": "workspace:*",
     "@repo/typescript-config": "workspace:*",
     "@types/node": "^22.0.0",
     chalk: "^5.3.0",
@@ -40551,6 +42168,70 @@ function getEsbuild() {
   const consumerRequire = (0, import_module.createRequire)(resolvePackageRelative("package.json"));
   return consumerRequire("esbuild");
 }
+function resolveBareSpecifier(specifier, importer) {
+  try {
+    const importerRequire = (0, import_module.createRequire)(importer);
+    return importerRequire.resolve(specifier);
+  } catch {
+  }
+  const match = specifier.match(/^((?:@[^/]+\/)?[^/]+)(\/.*)?$/);
+  if (!match) return null;
+  const pkgName = match[1];
+  const subpath = match[2] ? `.${match[2]}` : ".";
+  let dir = (0, import_path2.dirname)(importer);
+  while (true) {
+    const candidate = (0, import_path2.resolve)(dir, "node_modules", pkgName, "package.json");
+    if ((0, import_fs2.existsSync)(candidate)) {
+      const pkgJson = JSON.parse((0, import_fs2.readFileSync)(candidate, "utf-8"));
+      const exportsField = pkgJson.exports;
+      if (!exportsField) return null;
+      const target = pickExportsTarget(exportsField, subpath);
+      if (target) {
+        return (0, import_path2.resolve)((0, import_path2.dirname)(candidate), target);
+      }
+      return null;
+    }
+    const parent = (0, import_path2.dirname)(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function pickExportsTarget(exportsField, subpath) {
+  if (typeof exportsField === "string") {
+    return subpath === "." ? exportsField : null;
+  }
+  const entry = exportsField[subpath];
+  if (!entry) return null;
+  if (typeof entry === "string") return entry;
+  if (typeof entry === "object" && entry !== null) {
+    const conditions = entry;
+    for (const key of ["import", "default", "node", "require", "types"]) {
+      const value = conditions[key];
+      if (typeof value === "string") return value;
+      if (value && typeof value === "object") {
+        const nested = pickExportsTarget(value, ".");
+        if (nested) return nested;
+      }
+    }
+  }
+  return null;
+}
+function createBundleWorkspaceTsPlugin() {
+  return {
+    name: "bundle-workspace-ts",
+    setup(build) {
+      build.onResolve({ filter: /^[^./]/ }, (args) => {
+        if (args.kind === "entry-point") return null;
+        if (!args.importer) return null;
+        const resolved = resolveBareSpecifier(args.path, args.importer);
+        if (resolved && (0, import_path2.isAbsolute)(resolved) && /\.tsx?$/.test(resolved)) {
+          return { path: resolved, external: false };
+        }
+        return null;
+      });
+    }
+  };
+}
 async function loadTsModule(filePath) {
   const esbuild = getEsbuild();
   const absPath = resolvePackageRelative(filePath);
@@ -40563,6 +42244,8 @@ async function loadTsModule(filePath) {
       format: "esm",
       outfile: tmpOut,
       packages: "external",
+      loader: { ".ts": "ts", ".tsx": "tsx" },
+      plugins: [createBundleWorkspaceTsPlugin()],
       logLevel: "silent"
     });
     const fileUrl = `file:///${tmpOut.replace(/\\/g, "/")}`;
@@ -40933,7 +42616,7 @@ async function pollForCompletion(resourceId, executionId, apiUrl) {
     if (interrupted) {
       return;
     }
-    await new Promise((resolve3) => setTimeout(resolve3, POLL_INTERVAL_MS));
+    await new Promise((resolve5) => setTimeout(resolve5, POLL_INTERVAL_MS));
     if (interrupted) {
       return;
     }
@@ -41551,10 +43234,10 @@ Credential renamed successfully!`));
 var import_readline = require("readline");
 function confirm(message) {
   const rl = (0, import_readline.createInterface)({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve3) => {
+  return new Promise((resolve5) => {
     rl.question(message, (answer) => {
       rl.close();
-      resolve3(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+      resolve5(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
     });
   });
 }
@@ -42766,9 +44449,522 @@ function registerProjectCommands(program3) {
   registerNoteDelete(program3);
 }
 
-// src/cli/commands/request/request.ts
+// ../core/src/knowledge/queries.ts
+function toGraphNodeId(omNodeId) {
+  return `knowledge:${omNodeId}`;
+}
+function buildKnowledgeSourceIdMap(graph) {
+  const map2 = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) {
+    if (node.kind === "knowledge" && node.sourceId) {
+      map2.set(node.id, node.sourceId);
+    }
+  }
+  return map2;
+}
+function byFeature(graph, featureId, knowledgeNodes) {
+  const targetGraphNodeId = `feature:${featureId}`;
+  const governingKnowledgeNodeIds = /* @__PURE__ */ new Set();
+  for (const edge of graph.edges) {
+    if (edge.kind === "governs" && edge.targetId === targetGraphNodeId && edge.sourceId.startsWith("knowledge:")) {
+      governingKnowledgeNodeIds.add(edge.sourceId);
+    }
+  }
+  const sourceIdMap = buildKnowledgeSourceIdMap(graph);
+  const matchingOmIds = /* @__PURE__ */ new Set();
+  for (const graphNodeId of governingKnowledgeNodeIds) {
+    const omId = sourceIdMap.get(graphNodeId);
+    if (omId) matchingOmIds.add(omId);
+  }
+  return knowledgeNodes.filter((n) => matchingOmIds.has(n.id));
+}
+function byKind(_graph, kind, knowledgeNodes) {
+  return knowledgeNodes.filter((n) => n.kind === kind);
+}
+function byOwner(_graph, ownerId, knowledgeNodes) {
+  return knowledgeNodes.filter((n) => n.ownerIds.includes(ownerId));
+}
+function governs(graph, nodeId2) {
+  const graphNodeId = nodeId2.startsWith("knowledge:") ? nodeId2 : toGraphNodeId(nodeId2);
+  const results = [];
+  for (const edge of graph.edges) {
+    if (edge.kind === "governs" && edge.sourceId === graphNodeId) {
+      results.push(edge.targetId);
+    }
+  }
+  return results;
+}
+function governedBy(graph, nodeId2) {
+  const targetId = nodeId2.startsWith("feature:") || nodeId2.startsWith("knowledge:") || nodeId2.startsWith("resource:") ? nodeId2 : `feature:${nodeId2}`;
+  const results = [];
+  for (const edge of graph.edges) {
+    if (edge.kind === "governs" && edge.targetId === targetId) {
+      results.push(edge.sourceId);
+    }
+  }
+  return results;
+}
+function parsePath(pathString) {
+  if (!pathString || typeof pathString !== "string") {
+    throw new Error("parsePath: path must be a non-empty string");
+  }
+  if (!pathString.startsWith("/")) {
+    throw new Error(`parsePath: path must start with "/", got: "${pathString}"`);
+  }
+  const normalized = pathString.replace(/\/+$/, "");
+  const segments = normalized.split("/").filter((s) => s.length > 0);
+  if (segments.length === 0) {
+    throw new Error(`parsePath: path resolves to root with no mount: "${pathString}"`);
+  }
+  const [first, ...rest] = segments;
+  if (first === "by-feature") {
+    if (rest.length === 0) {
+      throw new Error(`parsePath: /by-feature requires a featureId argument, got: "${pathString}"`);
+    }
+    return { mount: "by-feature", args: [rest.join("/")] };
+  }
+  if (first === "by-kind") {
+    if (rest.length === 0) {
+      throw new Error(`parsePath: /by-kind requires a kind argument, got: "${pathString}"`);
+    }
+    return { mount: "by-kind", args: [rest[0]] };
+  }
+  if (first === "by-owner") {
+    if (rest.length === 0) {
+      throw new Error(`parsePath: /by-owner requires an ownerId argument, got: "${pathString}"`);
+    }
+    return { mount: "by-owner", args: [rest.join("/")] };
+  }
+  if (first === "graph") {
+    if (rest.length < 2) {
+      throw new Error(`parsePath: /graph requires <nodeId>/<verb> (governs|governed-by), got: "${pathString}"`);
+    }
+    const graphNodeId = rest.slice(0, -1).join("/");
+    const verb = rest[rest.length - 1];
+    if (verb !== "governs" && verb !== "governed-by") {
+      throw new Error(
+        `parsePath: /graph/<nodeId> verb must be "governs" or "governed-by", got: "${verb}" in "${pathString}"`
+      );
+    }
+    return { mount: "graph", args: [graphNodeId, verb] };
+  }
+  if (segments.length === 1) {
+    return { mount: "node", args: [first] };
+  }
+  throw new Error(
+    `parsePath: unrecognized path pattern "${pathString}". Supported: /by-feature/<id>, /by-kind/<kind>, /by-owner/<id>, /graph/<nodeId>/governs, /graph/<nodeId>/governed-by, /<nodeId>`
+  );
+}
+
+// ../core/src/knowledge/format.ts
+function formatText(results) {
+  if (results.length === 0) {
+    return "(no results)";
+  }
+  const kindWidth = Math.max(...results.map((n) => n.kind.length), 8);
+  const idWidth = Math.max(...results.map((n) => n.id.length), 4);
+  const header = `${"KIND".padEnd(kindWidth)}  ${"ID".padEnd(idWidth)}  TITLE`;
+  const divider = "-".repeat(header.length + 20);
+  const rows = results.map((n) => {
+    const summary = n.summary.length > 80 ? n.summary.slice(0, 77) + "..." : n.summary;
+    return `${n.kind.padEnd(kindWidth)}  ${n.id.padEnd(idWidth)}  ${n.title}  \u2014  ${summary}`;
+  });
+  return [header, divider, ...rows].join("\n");
+}
+function formatJson(input) {
+  const envelope = {
+    path: input.path,
+    mount: input.parsed.mount,
+    args: input.parsed.args,
+    results: input.results
+  };
+  return JSON.stringify(envelope, null, 2);
+}
+function formatIdsOnly(results) {
+  if (results.length === 0) return "";
+  const ids = results.map((r) => typeof r === "string" ? r : r.id);
+  return ids.join("\n");
+}
+
+// src/cli/commands/knowledge/load-org-model.ts
+var import_path3 = require("path");
+var import_fs3 = require("fs");
+var import_module2 = require("module");
+var ORG_MODEL_REL_PATH = "core/config/organization-model.ts";
+function getEsbuild2(startDir) {
+  const consumerRequire = (0, import_module2.createRequire)((0, import_path3.resolve)(startDir, "package.json"));
+  return consumerRequire("esbuild");
+}
+async function loadOrgModel(projectRoot) {
+  const orgModelPath = (0, import_path3.resolve)(projectRoot, ORG_MODEL_REL_PATH);
+  if (!(0, import_fs3.existsSync)(orgModelPath)) {
+    return DEFAULT_ORGANIZATION_MODEL;
+  }
+  let pkgDir = projectRoot;
+  while (!(0, import_fs3.existsSync)((0, import_path3.resolve)(pkgDir, "package.json"))) {
+    const parent = (0, import_path3.resolve)(pkgDir, "..");
+    if (parent === pkgDir) break;
+    pkgDir = parent;
+  }
+  let esbuild;
+  try {
+    esbuild = getEsbuild2(pkgDir);
+  } catch {
+    return DEFAULT_ORGANIZATION_MODEL;
+  }
+  const tmpOut = (0, import_path3.resolve)(projectRoot, `.elevasis-knowledge-tmp-${Date.now()}.mjs`);
+  try {
+    await esbuild.build({
+      entryPoints: [orgModelPath],
+      bundle: true,
+      platform: "node",
+      format: "esm",
+      outfile: tmpOut,
+      packages: "external",
+      logLevel: "silent"
+    });
+    const fileUrl = `file:///${tmpOut.replace(/\\/g, "/")}`;
+    const mod = await import(fileUrl);
+    const model = mod["organizationModel"] ?? mod["canonicalOrganizationModel"] ?? mod["default"];
+    if (model && typeof model === "object" && "features" in model) {
+      return model;
+    }
+  } catch {
+  } finally {
+    try {
+      const { unlinkSync: unlinkSync3 } = await import("fs");
+      unlinkSync3(tmpOut);
+    } catch {
+    }
+  }
+  return DEFAULT_ORGANIZATION_MODEL;
+}
+
+// src/cli/commands/knowledge/ls.ts
+function registerKnowledgeLs(program3) {
+  program3.command("knowledge:ls <path>").description(
+    "List knowledge nodes for a Knowledge Map path\n  Examples:\n    elevasis-sdk knowledge:ls /by-kind/playbook\n    elevasis-sdk knowledge:ls /by-feature/sales.crm\n    elevasis-sdk knowledge:ls /by-owner/role.ops-lead\n    elevasis-sdk knowledge:ls /graph/knowledge.outreach-playbook/governs\n    elevasis-sdk knowledge:ls /graph/feature:sales.crm/governed-by"
+  ).option("--json", "Print wrapped JSON envelope { path, mount, args, results }").option("--ids-only", "Print one ID per line (for piping)").action(
+    wrapAction("knowledge:ls", async (pathArg, options) => {
+      let parsed;
+      try {
+        parsed = parsePath(pathArg);
+      } catch (err) {
+        process.stderr.write(`knowledge:ls: invalid path: ${err instanceof Error ? err.message : String(err)}
+`);
+        process.exit(1);
+      }
+      const projectRoot = getProjectRoot();
+      const model = await loadOrgModel(projectRoot);
+      const graph = buildOrganizationGraph({ organizationModel: model });
+      const knowledgeNodes = model.knowledge?.nodes ?? [];
+      let results;
+      switch (parsed.mount) {
+        case "by-feature": {
+          const featureId = parsed.args[0].replace(/\//g, ".");
+          results = byFeature(graph, featureId, knowledgeNodes);
+          break;
+        }
+        case "by-kind": {
+          const kind = parsed.args[0];
+          results = byKind(graph, kind, knowledgeNodes);
+          break;
+        }
+        case "by-owner": {
+          const ownerId = parsed.args[0];
+          results = byOwner(graph, ownerId, knowledgeNodes);
+          break;
+        }
+        case "graph": {
+          const nodeId2 = parsed.args[0];
+          const verb = parsed.args[1];
+          if (verb === "governs") {
+            results = governs(graph, nodeId2);
+          } else {
+            results = governedBy(graph, nodeId2);
+          }
+          break;
+        }
+        case "node": {
+          const nodeId2 = parsed.args[0];
+          const node = knowledgeNodes.find((n) => n.id === nodeId2);
+          results = node ? [node] : [];
+          break;
+        }
+        default: {
+          results = [];
+        }
+      }
+      if (options.json) {
+        process.stdout.write(formatJson({ path: pathArg, parsed, results }) + "\n");
+      } else if (options.idsOnly) {
+        const out = formatIdsOnly(results);
+        if (out) process.stdout.write(out + "\n");
+      } else {
+        process.stdout.write(formatText(results) + "\n");
+      }
+    })
+  );
+}
+
+// src/cli/commands/knowledge/cat.ts
+function registerKnowledgeCat(program3) {
+  program3.command("knowledge:cat <id>").description(
+    "Print the raw MDX body of a knowledge node\n  Example: elevasis-sdk knowledge:cat knowledge.outreach-playbook\n  Use --json for structured output"
+  ).option("--json", "Return structured JSON: { id, kind, title, summary, body, links, ownerIds, updatedAt }").action(
+    wrapAction("knowledge:cat", async (id, options) => {
+      const projectRoot = getProjectRoot();
+      const model = await loadOrgModel(projectRoot);
+      const knowledgeNodes = model.knowledge?.nodes ?? [];
+      const node = knowledgeNodes.find((n) => n.id === id);
+      if (!node) {
+        process.stderr.write(`knowledge:cat: node not found: "${id}"
+`);
+        process.exit(1);
+      }
+      if (options.json) {
+        process.stdout.write(
+          JSON.stringify(
+            {
+              id: node.id,
+              kind: node.kind,
+              title: node.title,
+              summary: node.summary,
+              body: node.body,
+              links: node.links,
+              ownerIds: node.ownerIds,
+              updatedAt: node.updatedAt
+            },
+            null,
+            2
+          ) + "\n"
+        );
+      } else {
+        process.stdout.write(node.body + "\n");
+      }
+    })
+  );
+}
+
+// src/cli/commands/knowledge/graph.ts
+function registerKnowledgeGraph(program3) {
+  program3.command("knowledge:graph <id>").description(
+    "Show outgoing and incoming edges for a knowledge node\n  Example: elevasis-sdk knowledge:graph knowledge.outreach-playbook\n  Accepts bare OM node id or graph node id (knowledge:<id>)"
+  ).option("--json", "Print JSON: { nodeId, outgoing: string[], incoming: string[] }").option("--ids-only", "Print one edge ID per line (outgoing first, then incoming)").action(
+    wrapAction("knowledge:graph", async (id, options) => {
+      const projectRoot = getProjectRoot();
+      const model = await loadOrgModel(projectRoot);
+      const graph = buildOrganizationGraph({ organizationModel: model });
+      const outgoing = governs(graph, id);
+      const incoming = governedBy(graph, id);
+      if (options.json) {
+        process.stdout.write(
+          JSON.stringify(
+            {
+              nodeId: id,
+              outgoing,
+              incoming
+            },
+            null,
+            2
+          ) + "\n"
+        );
+      } else if (options.idsOnly) {
+        const lines = [...outgoing, ...incoming];
+        if (lines.length > 0) {
+          process.stdout.write(lines.join("\n") + "\n");
+        }
+      } else {
+        const nodeLabel = id.startsWith("knowledge:") ? id : `knowledge:${id}`;
+        const lines = [`Graph edges for ${nodeLabel}`, ""];
+        if (outgoing.length === 0 && incoming.length === 0) {
+          lines.push("  (no edges)");
+        } else {
+          lines.push(`Outgoing (governs) \u2014 ${outgoing.length} edge${outgoing.length !== 1 ? "s" : ""}`);
+          if (outgoing.length === 0) {
+            lines.push("  (none)");
+          } else {
+            for (const t of outgoing) {
+              lines.push(`  -> ${t}`);
+            }
+          }
+          lines.push("");
+          lines.push(`Incoming (governed-by) \u2014 ${incoming.length} edge${incoming.length !== 1 ? "s" : ""}`);
+          if (incoming.length === 0) {
+            lines.push("  (none)");
+          } else {
+            for (const s of incoming) {
+              lines.push(`  <- ${s}`);
+            }
+          }
+        }
+        process.stdout.write(lines.join("\n") + "\n");
+      }
+    })
+  );
+}
+
+// src/cli/commands/knowledge/generate.ts
+var import_node_fs3 = require("node:fs");
+var import_node_path3 = require("node:path");
+
+// src/knowledge-codegen.ts
 var import_node_fs2 = require("node:fs");
 var import_node_path2 = require("node:path");
+function listMdxFiles(directory) {
+  return (0, import_node_fs2.readdirSync)(directory, { withFileTypes: true }).flatMap((entry) => {
+    const path3 = (0, import_node_path2.join)(directory, entry.name);
+    if (entry.isDirectory()) return listMdxFiles(path3);
+    return entry.isFile() && (0, import_node_path2.extname)(entry.name) === ".mdx" ? [path3] : [];
+  });
+}
+function parseScalar(value) {
+  const trimmed = value.trim();
+  const quoted = trimmed.match(/^['"]([\s\S]*)['"]$/);
+  return quoted ? quoted[1] : trimmed;
+}
+function parseFrontmatter(raw, filePath) {
+  const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+  if (!match) throw new Error(`[knowledge-node-codegen] Missing frontmatter in ${filePath}`);
+  const frontmatter = {};
+  const lines = match[1].split(/\r?\n/);
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (!line.trim()) continue;
+    const pair = line.match(/^([A-Za-z][A-Za-z0-9]*):(?:\s*(.*))?$/);
+    if (!pair) throw new Error(`[knowledge-node-codegen] Invalid frontmatter line in ${filePath}: ${line}`);
+    const key = pair[1];
+    const inlineValue = pair[2]?.trim() ?? "";
+    if (inlineValue) {
+      frontmatter[key] = parseScalar(inlineValue);
+      continue;
+    }
+    const values = [];
+    while (index + 1 < lines.length && /^\s+-\s+/.test(lines[index + 1])) {
+      index += 1;
+      values.push(parseScalar(lines[index].replace(/^\s+-\s+/, "")));
+    }
+    frontmatter[key] = values;
+  }
+  return { frontmatter, body: match[2].trim() };
+}
+function assertString(frontmatter, key, filePath) {
+  const value = frontmatter[key];
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`[knowledge-node-codegen] ${filePath} frontmatter requires string "${key}"`);
+  }
+  return value.trim();
+}
+function optionalString(frontmatter, key, filePath) {
+  const value = frontmatter[key];
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`[knowledge-node-codegen] ${filePath} frontmatter "${key}" must be a nonempty string`);
+  }
+  return value.trim();
+}
+function assertKind(value, filePath) {
+  if (value === "playbook" || value === "strategy" || value === "reference") return value;
+  throw new Error(`[knowledge-node-codegen] ${filePath} has invalid kind "${value}"`);
+}
+function optionalStringArray(frontmatter, key, filePath) {
+  const value = frontmatter[key];
+  if (value === void 0) return [];
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) {
+    throw new Error(`[knowledge-node-codegen] ${filePath} frontmatter "${key}" must be a string array`);
+  }
+  return value.map((entry) => entry.trim()).filter(Boolean);
+}
+function readKnowledgeNodeMdx(filePath) {
+  const raw = (0, import_node_fs2.readFileSync)(filePath, "utf8");
+  const { frontmatter, body } = parseFrontmatter(raw, filePath);
+  return {
+    id: assertString(frontmatter, "id", filePath),
+    kind: assertKind(assertString(frontmatter, "kind", filePath), filePath),
+    title: assertString(frontmatter, "title", filePath),
+    summary: assertString(frontmatter, "description", filePath),
+    icon: optionalString(frontmatter, "icon", filePath),
+    body,
+    links: optionalStringArray(frontmatter, "links", filePath).map((nodeId2) => ({ nodeId: nodeId2 })),
+    ownerIds: optionalStringArray(frontmatter, "ownerIds", filePath),
+    updatedAt: assertString(frontmatter, "updatedAt", filePath)
+  };
+}
+function generateKnowledgeNodesTs(options) {
+  const exportedName = options.exportedName ?? "mdxKnowledgeNodes";
+  const typeImport = options.typeImportPath ? [`import type { OrgKnowledgeNode } from '${options.typeImportPath}'`, ""] : [];
+  const typeSatisfies = options.typeImportPath ? " satisfies OrgKnowledgeNode[]" : "";
+  return [
+    "// @generated by generate-knowledge-nodes -- DO NOT EDIT",
+    "// Regenerate: elevasis-sdk knowledge:generate",
+    `// Source: ${options.sourceLabel ?? "knowledge/nodes/**/*.mdx"}`,
+    "",
+    ...typeImport,
+    `export const ${exportedName} = ${JSON.stringify(options.nodes, null, 2)}${typeSatisfies}`,
+    ""
+  ].join("\n");
+}
+function generateKnowledgeNodes(options) {
+  const files = listMdxFiles(options.sourceDir).sort(
+    (a, b) => (0, import_node_path2.relative)(options.sourceDir, a).localeCompare((0, import_node_path2.relative)(options.sourceDir, b))
+  );
+  const nodes = files.map(readKnowledgeNodeMdx);
+  const ids = /* @__PURE__ */ new Set();
+  for (const node of nodes) {
+    if (ids.has(node.id)) throw new Error(`[knowledge-node-codegen] Duplicate knowledge node id: ${node.id}`);
+    ids.add(node.id);
+  }
+  (0, import_node_fs2.mkdirSync)((0, import_node_path2.dirname)(options.outputPath), { recursive: true });
+  (0, import_node_fs2.writeFileSync)(
+    options.outputPath,
+    generateKnowledgeNodesTs({
+      nodes,
+      typeImportPath: options.typeImportPath,
+      exportedName: options.exportedName,
+      sourceLabel: options.sourceLabel
+    }),
+    "utf8"
+  );
+  return { nodes, outputPath: options.outputPath };
+}
+
+// src/cli/commands/knowledge/generate.ts
+function registerKnowledgeGenerate(program3) {
+  program3.command("knowledge:generate").description(
+    "Generate OrganizationModel knowledge nodes from MDX source files\n  Example: elevasis-sdk knowledge:generate"
+  ).option("--source <path>", "MDX source directory relative to project root", "core/config/knowledge/nodes").option("--output <path>", "Generated TS file relative to project root", "core/config/knowledge/_generated/nodes.ts").action(
+    wrapAction("knowledge:generate", async (options) => {
+      const projectRoot = getProjectRoot();
+      const sourceDir = (0, import_node_path3.resolve)(projectRoot, options.source ?? "core/config/knowledge/nodes");
+      const outputPath = (0, import_node_path3.resolve)(projectRoot, options.output ?? "core/config/knowledge/_generated/nodes.ts");
+      if (!(0, import_node_fs3.existsSync)(sourceDir)) {
+        process.stderr.write(`knowledge:generate: source directory not found: ${sourceDir}
+`);
+        process.exitCode = 1;
+        return;
+      }
+      const result = generateKnowledgeNodes({
+        sourceDir,
+        outputPath,
+        sourceLabel: options.source ?? "core/config/knowledge/nodes"
+      });
+      process.stdout.write(`Generated ${result.nodes.length} knowledge node(s): ${result.outputPath}
+`);
+    })
+  );
+}
+
+// src/cli/commands/knowledge/index.ts
+function registerKnowledgeCommands(program3) {
+  registerKnowledgeGenerate(program3);
+  registerKnowledgeLs(program3);
+  registerKnowledgeCat(program3);
+  registerKnowledgeGraph(program3);
+}
+
+// src/cli/commands/request/request.ts
+var import_node_fs4 = require("node:fs");
+var import_node_path4 = require("node:path");
 
 // ../core/src/requests/api-schemas.ts
 var RequestSeverityEnum = external_exports.enum(["critical", "warning", "info"]);
@@ -42829,7 +45025,7 @@ function registerRequestCommands(program3) {
         throw new Error("Provide --input <json> or --input-file <path>");
       }
       const resolvedInputFile = options.inputFile ? resolveProjectRelative(options.inputFile) : void 0;
-      const raw = resolvedInputFile ? JSON.parse((0, import_node_fs2.readFileSync)(resolvedInputFile, "utf8")) : JSON.parse(options.input);
+      const raw = resolvedInputFile ? JSON.parse((0, import_node_fs4.readFileSync)(resolvedInputFile, "utf8")) : JSON.parse(options.input);
       const parsed = CreateRequestInputSchema.safeParse(raw);
       if (!parsed.success) {
         const issues = parsed.error.issues.map((i) => `  - ${i.path.join(".") || "(root)"}: ${i.message}`).join("\n");
@@ -42850,10 +45046,10 @@ ${issues}`);
         console.log(JSON.stringify(result, null, 2));
       }
       if (options.cleanupInput && resolvedInputFile) {
-        const tmpDir = (0, import_node_path2.join)(getProjectRoot(), "tmp");
+        const tmpDir = (0, import_node_path4.join)(getProjectRoot(), "tmp");
         if (resolvedInputFile.startsWith(tmpDir + "/") || resolvedInputFile.startsWith(tmpDir + "\\")) {
           try {
-            (0, import_node_fs2.unlinkSync)(resolvedInputFile);
+            (0, import_node_fs4.unlinkSync)(resolvedInputFile);
           } catch {
           }
         } else {
@@ -42869,8 +45065,8 @@ ${issues}`);
 
 // src/cli/commands/ui/ui-switcher.ts
 var import_node_child_process = require("node:child_process");
-var import_node_fs3 = __toESM(require("node:fs"), 1);
-var import_node_path3 = __toESM(require("node:path"), 1);
+var import_node_fs5 = __toESM(require("node:fs"), 1);
+var import_node_path5 = __toESM(require("node:path"), 1);
 function run(command, args, cwd) {
   (0, import_node_child_process.execFileSync)(command, args, {
     cwd,
@@ -42879,10 +45075,10 @@ function run(command, args, cwd) {
   });
 }
 function readJson(filePath) {
-  return JSON.parse(import_node_fs3.default.readFileSync(filePath, "utf8"));
+  return JSON.parse(import_node_fs5.default.readFileSync(filePath, "utf8"));
 }
 function writeJson(filePath, value) {
-  import_node_fs3.default.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}
+  import_node_fs5.default.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}
 `);
 }
 function requireDependencies(packageJson, filePath) {
@@ -42892,8 +45088,8 @@ function requireDependencies(packageJson, filePath) {
   return packageJson.dependencies;
 }
 function resolveExistingDir(label, dir) {
-  const resolved = import_node_path3.default.resolve(dir);
-  if (!import_node_fs3.default.existsSync(resolved) || !import_node_fs3.default.statSync(resolved).isDirectory()) {
+  const resolved = import_node_path5.default.resolve(dir);
+  if (!import_node_fs5.default.existsSync(resolved) || !import_node_fs5.default.statSync(resolved).isDirectory()) {
     throw new Error(`${label} not found: ${resolved}`);
   }
   return resolved;
@@ -42901,8 +45097,8 @@ function resolveExistingDir(label, dir) {
 function findRepoRootFromProject(projectRoot) {
   let dir = projectRoot;
   while (true) {
-    if (import_node_fs3.default.existsSync(import_node_path3.default.join(dir, "packages", "ui", "package.json"))) return dir;
-    const parent = import_node_path3.default.dirname(dir);
+    if (import_node_fs5.default.existsSync(import_node_path5.default.join(dir, "packages", "ui", "package.json"))) return dir;
+    const parent = import_node_path5.default.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
@@ -42915,13 +45111,13 @@ function resolveUiPackageRoot(projectRoot, explicitRoot) {
       "Could not find packages/ui from this Elevasis project. Pass --ui-package-root <path> from a monorepo checkout."
     );
   }
-  return import_node_path3.default.join(repoRoot, "packages", "ui");
+  return import_node_path5.default.join(repoRoot, "packages", "ui");
 }
 function removeLocalUiTarballs(templateTmpDir) {
-  if (!import_node_fs3.default.existsSync(templateTmpDir)) return;
-  for (const entry of import_node_fs3.default.readdirSync(templateTmpDir)) {
+  if (!import_node_fs5.default.existsSync(templateTmpDir)) return;
+  for (const entry of import_node_fs5.default.readdirSync(templateTmpDir)) {
     if (entry.startsWith("elevasis-ui-") && entry.endsWith(".tgz")) {
-      import_node_fs3.default.rmSync(import_node_path3.default.join(templateTmpDir, entry), { force: true });
+      import_node_fs5.default.rmSync(import_node_path5.default.join(templateTmpDir, entry), { force: true });
     }
   }
 }
@@ -42941,29 +45137,29 @@ function useLocalUi(options = {}) {
   const projectRoot = getProjectRoot();
   const repoRoot = findRepoRootFromProject(projectRoot);
   const uiPackageRoot = resolveUiPackageRoot(projectRoot, options.uiPackageRoot);
-  const commandRoot = repoRoot ?? import_node_path3.default.dirname(import_node_path3.default.dirname(uiPackageRoot));
-  const templateUiPackageJsonPath = import_node_path3.default.join(projectRoot, "ui", "package.json");
-  const templateTmpDir = import_node_path3.default.join(projectRoot, "tmp");
-  const uiPackageJsonPath = import_node_path3.default.join(uiPackageRoot, "package.json");
-  const uiPackageBackupPath = import_node_path3.default.join(uiPackageRoot, "package.json.local-pack.bak");
-  if (!import_node_fs3.default.existsSync(templateUiPackageJsonPath)) {
+  const commandRoot = repoRoot ?? import_node_path5.default.dirname(import_node_path5.default.dirname(uiPackageRoot));
+  const templateUiPackageJsonPath = import_node_path5.default.join(projectRoot, "ui", "package.json");
+  const templateTmpDir = import_node_path5.default.join(projectRoot, "tmp");
+  const uiPackageJsonPath = import_node_path5.default.join(uiPackageRoot, "package.json");
+  const uiPackageBackupPath = import_node_path5.default.join(uiPackageRoot, "package.json.local-pack.bak");
+  if (!import_node_fs5.default.existsSync(templateUiPackageJsonPath)) {
     throw new Error(`Template UI package.json not found: ${templateUiPackageJsonPath}`);
   }
-  import_node_fs3.default.mkdirSync(templateTmpDir, { recursive: true });
+  import_node_fs5.default.mkdirSync(templateTmpDir, { recursive: true });
   removeLocalUiTarballs(templateTmpDir);
   run("pnpm", ["--filter", "@repo/ui", "build:publish"], commandRoot);
   try {
-    const raw = import_node_fs3.default.readFileSync(uiPackageJsonPath, "utf8");
-    import_node_fs3.default.writeFileSync(uiPackageBackupPath, raw);
+    const raw = import_node_fs5.default.readFileSync(uiPackageJsonPath, "utf8");
+    import_node_fs5.default.writeFileSync(uiPackageBackupPath, raw);
     writeJson(uiPackageJsonPath, prepareUiPackageForPack(JSON.parse(raw)));
     run("pnpm", ["-C", uiPackageRoot, "pack", "--pack-destination", templateTmpDir], commandRoot);
   } finally {
-    if (import_node_fs3.default.existsSync(uiPackageBackupPath)) {
-      import_node_fs3.default.copyFileSync(uiPackageBackupPath, uiPackageJsonPath);
-      import_node_fs3.default.rmSync(uiPackageBackupPath, { force: true });
+    if (import_node_fs5.default.existsSync(uiPackageBackupPath)) {
+      import_node_fs5.default.copyFileSync(uiPackageBackupPath, uiPackageJsonPath);
+      import_node_fs5.default.rmSync(uiPackageBackupPath, { force: true });
     }
   }
-  const tarballName = import_node_fs3.default.readdirSync(templateTmpDir).find((entry) => entry.startsWith("elevasis-ui-") && entry.endsWith(".tgz"));
+  const tarballName = import_node_fs5.default.readdirSync(templateTmpDir).find((entry) => entry.startsWith("elevasis-ui-") && entry.endsWith(".tgz"));
   if (!tarballName) {
     throw new Error(`Failed to create local @elevasis/ui tarball in ${templateTmpDir}`);
   }
@@ -42971,20 +45167,20 @@ function useLocalUi(options = {}) {
   requireDependencies(templateUiPackageJson, templateUiPackageJsonPath)["@elevasis/ui"] = `file:../tmp/${tarballName}`;
   writeJson(templateUiPackageJsonPath, templateUiPackageJson);
   run("pnpm", ["-C", projectRoot, "install"], commandRoot);
-  console.log(`${import_node_path3.default.basename(projectRoot)}/ui now uses local @elevasis/ui tarball: ${tarballName}`);
+  console.log(`${import_node_path5.default.basename(projectRoot)}/ui now uses local @elevasis/ui tarball: ${tarballName}`);
 }
 function usePublishedUi(options = {}) {
   const projectRoot = getProjectRoot();
   const repoRoot = findRepoRootFromProject(projectRoot);
   const commandRoot = repoRoot ?? projectRoot;
-  const templateUiPackageJsonPath = import_node_path3.default.join(projectRoot, "ui", "package.json");
-  const templateTmpDir = import_node_path3.default.join(projectRoot, "tmp");
+  const templateUiPackageJsonPath = import_node_path5.default.join(projectRoot, "ui", "package.json");
+  const templateTmpDir = import_node_path5.default.join(projectRoot, "tmp");
   const uiPackageRoot = options.version ? void 0 : resolveUiPackageRoot(projectRoot, options.uiPackageRoot);
-  const uiVersion = options.version ?? readJson(import_node_path3.default.join(uiPackageRoot, "package.json")).version;
+  const uiVersion = options.version ?? readJson(import_node_path5.default.join(uiPackageRoot, "package.json")).version;
   if (!uiVersion) {
     throw new Error("Could not determine @elevasis/ui version. Pass --version <version>.");
   }
-  if (!import_node_fs3.default.existsSync(templateUiPackageJsonPath)) {
+  if (!import_node_fs5.default.existsSync(templateUiPackageJsonPath)) {
     throw new Error(`Template UI package.json not found: ${templateUiPackageJsonPath}`);
   }
   const templateUiPackageJson = readJson(templateUiPackageJsonPath);
@@ -42992,7 +45188,7 @@ function usePublishedUi(options = {}) {
   writeJson(templateUiPackageJsonPath, templateUiPackageJson);
   removeLocalUiTarballs(templateTmpDir);
   run("pnpm", ["-C", projectRoot, "install"], commandRoot);
-  console.log(`${import_node_path3.default.basename(projectRoot)}/ui restored to published @elevasis/ui ^${uiVersion}`);
+  console.log(`${import_node_path5.default.basename(projectRoot)}/ui restored to published @elevasis/ui ^${uiVersion}`);
 }
 
 // src/cli/commands/ui/ui.ts
@@ -43010,8 +45206,8 @@ function registerUiCommands(program3) {
 }
 
 // src/cli/commands/doctor.ts
-var import_node_fs4 = require("node:fs");
-var import_node_path4 = __toESM(require("node:path"), 1);
+var import_node_fs6 = require("node:fs");
+var import_node_path6 = __toESM(require("node:path"), 1);
 function ok(label, detail) {
   console.log(`${source_default.green("[OK]")}   ${source_default.bold(label)}: ${detail}`);
 }
@@ -43047,8 +45243,8 @@ function registerDoctorCommand(program3) {
       printSummary(failCount);
       process.exit(1);
     }
-    const envPath2 = import_node_path4.default.join(projectRoot, ".env");
-    const envExists = (0, import_node_fs4.existsSync)(envPath2);
+    const envPath2 = import_node_path6.default.join(projectRoot, ".env");
+    const envExists = (0, import_node_fs6.existsSync)(envPath2);
     if (!envExists) {
       fail(".env", `Not found at ${envPath2}. Create it from .env.example and fill in ELEVASIS_PLATFORM_KEY.`);
       if (isVerbose) verbose(`Checked: ${envPath2}`);
@@ -43137,7 +45333,7 @@ function printSummary(failCount) {
 
 // src/cli/index.ts
 var PREFLIGHT_SKIP_FLAGS = /* @__PURE__ */ new Set(["--help", "-h", "--version", "-V"]);
-var LOCAL_PROJECT_COMMANDS = /* @__PURE__ */ new Set(["ui:use-local", "ui:use-published"]);
+var LOCAL_PROJECT_COMMANDS = /* @__PURE__ */ new Set(["ui:use-local", "ui:use-published", "knowledge:generate"]);
 function shouldSkipPreflight() {
   const args = process.argv.slice(2);
   if (args.length === 0) return true;
@@ -43159,8 +45355,8 @@ function runPreflight() {
     process.exit(1);
   }
   if (isLocalProjectCommand()) return;
-  const envPath2 = (0, import_path3.join)(projectRoot, ".env");
-  if (!(0, import_fs2.existsSync)(envPath2)) {
+  const envPath2 = (0, import_path4.join)(projectRoot, ".env");
+  if (!(0, import_fs4.existsSync)(envPath2)) {
     process.stderr.write(source_default.red(`No \`.env\` found at \`${envPath2}\`. Set \`ELEVASIS_PLATFORM_KEY\`.
 `));
     process.stderr.write(
@@ -43199,6 +45395,10 @@ Commands:
   elevasis-sdk project:list [--search <query>]      List projects with optional search
   elevasis-sdk project:resolve <query>              Resolve a project ID from a name or UUID
   elevasis-sdk project:work <query>                 Open a lifecycle-aware project work brief
+  elevasis-sdk knowledge:generate                   Generate knowledge nodes from MDX files
+  elevasis-sdk knowledge:ls <path>                  List knowledge nodes for a path
+  elevasis-sdk knowledge:cat <id>                   Print raw MDX body of a knowledge node
+  elevasis-sdk knowledge:graph <id>                 Show outgoing and incoming edges for a node
   elevasis-sdk request:submit -f <path>             Submit a structured request report
   elevasis-sdk ui:use-local                         Use a local @elevasis/ui tarball
   elevasis-sdk ui:use-published                     Restore published @elevasis/ui
@@ -43222,6 +45422,7 @@ registerCredsCommand(program2);
 registerErrorCommand(program2);
 registerRenameCommand(program2);
 registerProjectCommands(program2);
+registerKnowledgeCommands(program2);
 registerRequestCommands(program2);
 registerUiCommands(program2);
 registerDoctorCommand(program2);