@svashevchenko/ez-know 0.1.0

package/dist/server.js

@@ -0,0 +1,3357 @@
+// packages/mcp/src/run.ts
+import { McpServer, StdioServerTransport } from "@modelcontextprotocol/server";
+
+// packages/core/src/knowledge/schema.ts
+import { extendZodWithOpenApi } from "@asteasolutions/zod-to-openapi";
+import { z } from "zod/v4";
+extendZodWithOpenApi(z);
+var confidenceSchema = z.object({
+  score: z.number().min(0).max(1),
+  level: z.enum(["Low", "Medium", "High"]),
+  reason: z.string().optional()
+});
+var certaintySchema = z.enum([
+  "confirmed",
+  "direct_evidence",
+  "inferred",
+  "weak_inference",
+  "unknown"
+]);
+var withConfidenceSchema = z.object({
+  certainty: certaintySchema,
+  confidence: confidenceSchema,
+  evidence_ids: z.array(z.string()),
+  questions: z.array(z.string())
+});
+var evidenceSchema = z.object({
+  id: z.string(),
+  source_type: z.enum([
+    "code",
+    "test",
+    "ui_text",
+    "translation",
+    "api",
+    "route",
+    "schema",
+    "comment",
+    "documentation",
+    "repowise_search",
+    "human",
+    "increment_description",
+    "git_diff"
+  ]),
+  description: z.string(),
+  location: z.object({
+    path: z.string().optional(),
+    symbol: z.string().optional(),
+    route: z.string().optional(),
+    api: z.string().optional(),
+    query: z.string().optional()
+  }).optional(),
+  supports: z.array(z.string()),
+  excerpt: z.string().optional(),
+  confidence: confidenceSchema
+});
+var domainSchema = withConfidenceSchema.extend({
+  id: z.string(),
+  name: z.string(),
+  purpose: z.string(),
+  why_it_exists: z.string().optional(),
+  entity_ids: z.array(z.string()),
+  capability_ids: z.array(z.string())
+});
+var entityTechnicalRepresentationSchema = z.object({
+  kind: z.enum([
+    "type",
+    "api",
+    "route",
+    "database",
+    "ui_label",
+    "translation",
+    "unknown"
+  ]),
+  name: z.string(),
+  location_hint: z.string().optional()
+});
+var entitySchema = withConfidenceSchema.extend({
+  id: z.string(),
+  name: z.string(),
+  business_definition: z.string(),
+  description: z.string(),
+  purpose: z.string().optional(),
+  aliases: z.array(z.string()),
+  ambiguous_terms: z.array(z.string()),
+  technical_representations: z.array(entityTechnicalRepresentationSchema),
+  domain_ids: z.array(z.string()),
+  state_values: z.array(z.string()).optional(),
+  relationship_ids: z.array(z.string()),
+  capability_ids: z.array(z.string()),
+  feature_ids: z.array(z.string()),
+  rule_ids: z.array(z.string())
+});
+var relationshipSchema = withConfidenceSchema.extend({
+  id: z.string(),
+  from_entity_id: z.string(),
+  to_entity_id: z.string(),
+  relationship_type: z.enum([
+    "has_many",
+    "has_one",
+    "belongs_to",
+    "depends_on",
+    "references",
+    "transitions_to",
+    "unknown"
+  ]),
+  description: z.string()
+});
+var capabilitySchema = withConfidenceSchema.extend({
+  id: z.string(),
+  name: z.string(),
+  description: z.string(),
+  why_it_exists: z.string().optional(),
+  domain_ids: z.array(z.string()),
+  entity_ids: z.array(z.string()),
+  parent_capability_ids: z.array(z.string()),
+  child_capability_ids: z.array(z.string()),
+  feature_ids: z.array(z.string())
+});
+var featureSchema = withConfidenceSchema.extend({
+  id: z.string(),
+  name: z.string(),
+  description: z.string(),
+  purpose: z.string().optional(),
+  why_it_exists: z.string().optional(),
+  domain_ids: z.array(z.string()),
+  capability_ids: z.array(z.string()),
+  entity_ids: z.array(z.string()),
+  rule_ids: z.array(z.string()),
+  constraint_ids: z.array(z.string())
+});
+var ruleConditionSchema = z.object({
+  subject: z.string(),
+  field: z.string().optional(),
+  operator: z.enum([
+    "equals",
+    "not_equals",
+    "contains",
+    "not_contains",
+    "exists",
+    "not_exists",
+    "greater_than",
+    "less_than",
+    "succeeds",
+    "fails",
+    "unknown"
+  ]),
+  value: z.unknown().optional()
+});
+var ruleTriggerSchema = z.object({
+  actor: z.string(),
+  action: z.string(),
+  subject: z.string().optional(),
+  field: z.string().optional(),
+  operator: z.enum([
+    "equals",
+    "not_equals",
+    "contains",
+    "not_contains",
+    "exists",
+    "not_exists",
+    "greater_than",
+    "less_than",
+    "succeeds",
+    "fails",
+    "unknown"
+  ]).optional(),
+  value: z.unknown().optional()
+});
+var ruleEffectSchema = z.object({
+  effect: z.enum([
+    "allow_action",
+    "disallow_action",
+    "hide_action",
+    "disable_action",
+    "require_action",
+    "show_message",
+    "change_state",
+    "calculate_value",
+    "unknown"
+  ]),
+  action: z.string().optional(),
+  message: z.string().optional(),
+  target_state: z.string().optional(),
+  value: z.unknown().optional()
+});
+var businessRuleSchema = withConfidenceSchema.extend({
+  id: z.string(),
+  name: z.string(),
+  statement: z.string(),
+  rule_type: z.enum([
+    "validation",
+    "permission",
+    "state_transition",
+    "visibility",
+    "workflow",
+    "calculation",
+    "integration",
+    "integration_behavior",
+    "data_consistency",
+    "acceptance_criterion",
+    "unknown"
+  ]),
+  behavior_type: z.enum([
+    "allow",
+    "disallow",
+    "require",
+    "calculate",
+    "show",
+    "hide",
+    "transition",
+    "notify",
+    "block",
+    "default",
+    "unknown"
+  ]),
+  applies_to: z.object({
+    domain_ids: z.array(z.string()).optional(),
+    entity_ids: z.array(z.string()).optional(),
+    capability_ids: z.array(z.string()).optional(),
+    feature_ids: z.array(z.string()).optional()
+  }),
+  condition: z.object({
+    given: z.array(ruleConditionSchema),
+    when: z.array(ruleTriggerSchema),
+    then: z.array(ruleEffectSchema)
+  }).optional(),
+  enforcement: z.object({
+    level: z.enum([
+      "ui",
+      "api",
+      "backend",
+      "database",
+      "external_system",
+      "unknown"
+    ]),
+    description: z.string().optional()
+  }).optional(),
+  related_constraint_ids: z.array(z.string()),
+  rationale_ids: z.array(z.string())
+});
+var constraintSchema = withConfidenceSchema.extend({
+  id: z.string(),
+  name: z.string(),
+  description: z.string(),
+  constraint_type: z.enum([
+    "business",
+    "technical",
+    "regulatory",
+    "compliance",
+    "integration",
+    "legacy",
+    "architecture",
+    "infrastructure",
+    "performance",
+    "security",
+    "operational",
+    "data_model",
+    "unknown"
+  ]),
+  cause: z.object({
+    source: z.string(),
+    source_type: z.enum([
+      "external_system",
+      "database",
+      "framework",
+      "infrastructure",
+      "architecture",
+      "policy",
+      "regulation",
+      "business_process",
+      "legacy_code",
+      "unknown"
+    ]),
+    description: z.string()
+  }).optional(),
+  impact: z.object({
+    affected_change_types: z.array(z.string()),
+    severity: z.enum(["low", "medium", "high", "critical", "unknown"]),
+    description: z.string()
+  }).optional(),
+  applies_to: z.object({
+    domain_ids: z.array(z.string()).optional(),
+    entity_ids: z.array(z.string()).optional(),
+    capability_ids: z.array(z.string()).optional(),
+    feature_ids: z.array(z.string()).optional(),
+    business_rule_ids: z.array(z.string()).optional()
+  }),
+  workaround: z.object({
+    exists: z.enum(["yes", "no", "unknown"]),
+    description: z.string().optional()
+  }).optional(),
+  removability: z.object({
+    can_be_removed_by_refactor: z.enum(["yes", "no", "partially", "unknown"]),
+    requires: z.array(z.string()),
+    risk: z.enum(["low", "medium", "high", "critical", "unknown"])
+  }).optional()
+});
+var rationaleSchema = withConfidenceSchema.extend({
+  id: z.string(),
+  statement: z.string(),
+  explains: z.array(z.string())
+});
+var questionSchema = z.object({
+  id: z.string(),
+  question: z.string(),
+  category: z.enum([
+    "rationale",
+    "business_rule",
+    "constraint",
+    "terminology",
+    "domain_boundary",
+    "lifecycle",
+    "permission",
+    "legacy",
+    "ownership",
+    "enforcement"
+  ]),
+  reason: z.string(),
+  impact: z.string().optional(),
+  related_ids: z.array(z.string()),
+  evidence_ids: z.array(z.string()),
+  priority: z.enum(["low", "medium", "high"]),
+  status: z.enum(["open", "answered", "obsolete"]),
+  answer: z.string().nullable().optional(),
+  answered_by: z.string().nullable().optional(),
+  answered_at: z.string().nullable().optional()
+});
+var conflictSchema = z.object({
+  id: z.string(),
+  type: z.enum([
+    "domain_boundary",
+    "terminology",
+    "rule_conflict",
+    "rationale_conflict",
+    "entity_duplicate",
+    "relationship_conflict"
+  ]),
+  description: z.string(),
+  related_ids: z.array(z.string()),
+  evidence_ids: z.array(z.string()),
+  status: z.enum(["needs_human_input", "resolved", "obsolete"]),
+  questions: z.array(z.string()),
+  resolution: z.string().optional(),
+  resolved_by_evidence_id: z.string().optional()
+});
+var knowledgeCollectionSchemas = {
+  domains: z.array(domainSchema),
+  entities: z.array(entitySchema),
+  relationships: z.array(relationshipSchema),
+  capabilities: z.array(capabilitySchema),
+  features: z.array(featureSchema),
+  business_rules: z.array(businessRuleSchema),
+  constraints: z.array(constraintSchema),
+  rationales: z.array(rationaleSchema),
+  evidence: z.array(evidenceSchema),
+  questions: z.array(questionSchema),
+  conflicts: z.array(conflictSchema)
+};
+
+// packages/core/src/knowledge/extraction-registry.ts
+var KNOWLEDGE_EXTRACTION_TYPE_REGISTRY = {
+  domains: {
+    collection: "domains",
+    title: "Domains",
+    storageFile: "domain.json",
+    idConvention: {
+      pattern: "domain.<domain-slug>",
+      prefix: "domain",
+      example: "domain.orders"
+    },
+    schemaName: "Domain",
+    schema: domainSchema,
+    guideFilePath: "packages/core/src/knowledge/guides/domains.md",
+    aliases: []
+  },
+  entities: {
+    collection: "entities",
+    title: "Entities",
+    storageFile: "entities.json",
+    idConvention: {
+      pattern: "entity.<domain-slug>.<entity-slug>",
+      prefix: "entity",
+      example: "entity.orders.order"
+    },
+    schemaName: "Entity",
+    schema: entitySchema,
+    guideFilePath: "packages/core/src/knowledge/guides/entities.md",
+    aliases: []
+  },
+  relationships: {
+    collection: "relationships",
+    title: "Relationships",
+    storageFile: "relationships.json",
+    idConvention: {
+      pattern: "rel.<domain-slug>.<relationship-slug>",
+      prefix: "rel",
+      example: "rel.orders.order-has-items"
+    },
+    schemaName: "EntityRelationship",
+    schema: relationshipSchema,
+    guideFilePath: "packages/core/src/knowledge/guides/relationships.md",
+    aliases: ["entity-relationships"]
+  },
+  capabilities: {
+    collection: "capabilities",
+    title: "Capabilities",
+    storageFile: "capabilities.json",
+    idConvention: {
+      pattern: "cap.<domain-slug>.<capability-slug>",
+      prefix: "cap",
+      example: "cap.orders.order-lifecycle"
+    },
+    schemaName: "Capability",
+    schema: capabilitySchema,
+    guideFilePath: "packages/core/src/knowledge/guides/capabilities.md",
+    aliases: []
+  },
+  features: {
+    collection: "features",
+    title: "Features",
+    storageFile: "features.json",
+    idConvention: {
+      pattern: "feature.<domain-slug>.<feature-slug>",
+      prefix: "feature",
+      example: "feature.orders.cancel-order"
+    },
+    schemaName: "Feature",
+    schema: featureSchema,
+    guideFilePath: "packages/core/src/knowledge/guides/features.md",
+    aliases: []
+  },
+  business_rules: {
+    collection: "business_rules",
+    title: "Business Rules",
+    storageFile: "business-rules.json",
+    idConvention: {
+      pattern: "rule.<domain-slug>.<rule-slug>",
+      prefix: "rule",
+      example: "rule.orders.no-direct-cancel-paid-order"
+    },
+    schemaName: "BusinessRule",
+    schema: businessRuleSchema,
+    guideFilePath: "packages/core/src/knowledge/guides/business-rules.md",
+    aliases: ["business-rules"]
+  },
+  constraints: {
+    collection: "constraints",
+    title: "Constraints",
+    storageFile: "constraints.json",
+    idConvention: {
+      pattern: "constraint.<domain-slug>.<constraint-slug>",
+      prefix: "constraint",
+      example: "constraint.orders.erp-sync-one-way"
+    },
+    schemaName: "Constraint",
+    schema: constraintSchema,
+    guideFilePath: "packages/core/src/knowledge/guides/constraints.md",
+    aliases: []
+  },
+  rationales: {
+    collection: "rationales",
+    title: "Rationales",
+    storageFile: "rationales.json",
+    idConvention: {
+      pattern: "why.<domain-slug>.<rationale-slug>",
+      prefix: "why",
+      example: "why.orders.refund-required-for-paid-order"
+    },
+    schemaName: "Rationale",
+    schema: rationaleSchema,
+    guideFilePath: "packages/core/src/knowledge/guides/rationales.md",
+    aliases: []
+  },
+  evidence: {
+    collection: "evidence",
+    title: "Evidence",
+    storageFile: "evidence.json",
+    idConvention: {
+      pattern: "ev.<domain-slug>.<evidence-slug>",
+      prefix: "ev",
+      example: "ev.orders.cancel-disabled-paid"
+    },
+    schemaName: "Evidence",
+    schema: evidenceSchema,
+    guideFilePath: "packages/core/src/knowledge/guides/evidence.md",
+    aliases: []
+  },
+  questions: {
+    collection: "questions",
+    title: "Questions",
+    storageFile: "questions.json",
+    idConvention: {
+      pattern: "q.<domain-slug>.<question-slug>",
+      prefix: "q",
+      example: "q.orders.paid-cancel-rationale"
+    },
+    schemaName: "Question",
+    schema: questionSchema,
+    guideFilePath: "packages/core/src/knowledge/guides/questions.md",
+    aliases: []
+  },
+  conflicts: {
+    collection: "conflicts",
+    title: "Conflicts",
+    storageFile: "conflicts.json",
+    idConvention: {
+      pattern: "conflict.<domain-slug>.<conflict-slug>",
+      prefix: "conflict",
+      example: "conflict.invoice-domain"
+    },
+    schemaName: "Conflict",
+    schema: conflictSchema,
+    guideFilePath: "packages/core/src/knowledge/guides/conflicts.md",
+    aliases: []
+  }
+};
+var KNOWLEDGE_EXTRACTION_TYPES = Object.values(
+  KNOWLEDGE_EXTRACTION_TYPE_REGISTRY
+);
+var KNOWLEDGE_EXTRACTION_TYPE_LOOKUP = new Map(
+  KNOWLEDGE_EXTRACTION_TYPES.flatMap((definition) => [
+    [definition.collection, definition],
+    ...definition.aliases.map((alias) => [alias, definition])
+  ])
+);
+function listKnowledgeExtractionTypes() {
+  return KNOWLEDGE_EXTRACTION_TYPES.slice();
+}
+function getKnowledgeExtractionTypeDefinition(type) {
+  const normalized = type.trim().toLowerCase().replace(/-/g, "_");
+  const exactMatch = KNOWLEDGE_EXTRACTION_TYPE_LOOKUP.get(normalized);
+  if (exactMatch) {
+    return exactMatch;
+  }
+  return KNOWLEDGE_EXTRACTION_TYPE_LOOKUP.get(type.trim().toLowerCase());
+}
+function requireKnowledgeExtractionTypeDefinition(type) {
+  const definition = getKnowledgeExtractionTypeDefinition(type);
+  if (!definition) {
+    throw new Error(
+      `Unsupported extraction type "${type}". Supported types: ${KNOWLEDGE_EXTRACTION_TYPES.map(
+        (entry) => entry.collection
+      ).join(", ")}`
+    );
+  }
+  return definition;
+}
+function buildKnowledgeExtractionSchemaUri(type) {
+  return `ez-know://extraction/schema/${requireKnowledgeExtractionTypeDefinition(type).collection}`;
+}
+function buildKnowledgeExtractionGuideUri(type) {
+  return `ez-know://extraction/guide/${requireKnowledgeExtractionTypeDefinition(type).collection}`;
+}
+
+// packages/core/src/knowledge/extraction-resources.ts
+import { readFile } from "node:fs/promises";
+import { z as z2 } from "zod/v4";
+var KNOWLEDGE_EXTRACTION_TYPES_RESOURCE_URI = "ez-know://extraction/types";
+var KNOWLEDGE_EXTRACTION_SCHEMA_RESOURCE_URI = "ez-know://extraction/schema/{type}";
+var KNOWLEDGE_EXTRACTION_GUIDE_RESOURCE_URI = "ez-know://extraction/guide/{type}";
+function createKnowledgeExtractionTypeResource(definition) {
+  return {
+    collection: definition.collection,
+    title: definition.title,
+    aliases: definition.aliases.slice(),
+    storageFile: definition.storageFile,
+    idConvention: { ...definition.idConvention },
+    schemaUri: buildKnowledgeExtractionSchemaUri(definition.collection),
+    guideUri: buildKnowledgeExtractionGuideUri(definition.collection)
+  };
+}
+function buildKnowledgeExtractionTypeIndexDocument() {
+  const supportedTypes = listKnowledgeExtractionTypes().map(
+    createKnowledgeExtractionTypeResource
+  );
+  return {
+    resource: {
+      uri: KNOWLEDGE_EXTRACTION_TYPES_RESOURCE_URI,
+      title: "Knowledge Extraction Types",
+      description: "Canonical registry of knowledge types supported by the extraction workflow."
+    },
+    source: {
+      kind: "registry",
+      count: supportedTypes.length
+    },
+    supportedTypes
+  };
+}
+function buildKnowledgeExtractionSchemaDocument(type) {
+  const definition = requireKnowledgeExtractionTypeDefinition(type);
+  const resource = createKnowledgeExtractionTypeResource(definition);
+  return {
+    resource: {
+      uri: resource.schemaUri,
+      title: `${definition.title} Extraction Schema`,
+      description: "Runtime JSON Schema view of the canonical knowledge object model."
+    },
+    source: {
+      kind: "runtime-zod",
+      collection: definition.collection,
+      schemaName: definition.schemaName,
+      storageFile: definition.storageFile,
+      guideUri: resource.guideUri
+    },
+    type: resource,
+    schema: z2.toJSONSchema(definition.schema)
+  };
+}
+async function readKnowledgeExtractionGuideMarkdown(type) {
+  const definition = requireKnowledgeExtractionTypeDefinition(type);
+  const guideFileName = definition.guideFilePath.split("/").pop();
+  if (!guideFileName) {
+    throw new Error(
+      `Invalid guide file path for extraction type "${definition.collection}".`
+    );
+  }
+  const guideUrl = new URL(`./guides/${guideFileName}`, import.meta.url);
+  const markdown = await readFile(guideUrl, "utf8");
+  return {
+    definition,
+    markdown
+  };
+}
+async function buildKnowledgeExtractionGuideDocument(type) {
+  const definition = requireKnowledgeExtractionTypeDefinition(type);
+  const resource = createKnowledgeExtractionTypeResource(definition);
+  const { markdown } = await readKnowledgeExtractionGuideMarkdown(type);
+  return {
+    resource: {
+      uri: resource.guideUri,
+      title: `${definition.title} Extraction Guide`,
+      description: "Checked-in Markdown guidance for extracting this knowledge type."
+    },
+    source: {
+      kind: "checked-in-markdown",
+      filePath: definition.guideFilePath
+    },
+    type: resource,
+    markdown
+  };
+}
+function listKnowledgeExtractionResourceTypes() {
+  return listKnowledgeExtractionTypes().map(
+    createKnowledgeExtractionTypeResource
+  );
+}
+
+// packages/core/src/knowledge/loader.ts
+import { existsSync } from "node:fs";
+import { readFile as readFile2 } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { z as z3 } from "zod/v4";
+
+// packages/core/src/knowledge/root.ts
+import { resolve } from "node:path";
+function resolveKnowledgeRootFromEnv(envValue, cwd = process.cwd()) {
+  return envValue ? resolve(cwd, envValue) : resolve(cwd, "ez-know");
+}
+
+// packages/core/src/knowledge/loader.ts
+var COLLECTION_SCHEMAS = {
+  domains: z3.array(domainSchema),
+  entities: z3.array(entitySchema),
+  relationships: z3.array(relationshipSchema),
+  capabilities: z3.array(capabilitySchema),
+  features: z3.array(featureSchema),
+  business_rules: z3.array(businessRuleSchema),
+  constraints: z3.array(constraintSchema),
+  rationales: z3.array(rationaleSchema),
+  evidence: z3.array(evidenceSchema),
+  questions: z3.array(questionSchema),
+  conflicts: z3.array(conflictSchema)
+};
+var COLLECTION_DEFINITIONS = KNOWLEDGE_EXTRACTION_TYPE_REGISTRY;
+var KnowledgeStoreLoadError = class extends Error {
+  diagnostics;
+  constructor(message, diagnostics) {
+    super(message);
+    this.name = "KnowledgeStoreLoadError";
+    this.diagnostics = diagnostics;
+  }
+};
+function resolveKnowledgeRoot(envValue, cwd = process.cwd()) {
+  return resolveKnowledgeRootFromEnv(envValue, cwd);
+}
+async function discoverDomainFolders(rootDir) {
+  const { readdir: readdir3 } = await import("node:fs/promises");
+  const discovered = [];
+  const entries = await readdir3(rootDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory() && !entry.name.startsWith(".")) {
+      discovered.push(join(rootDir, entry.name));
+    }
+  }
+  discovered.sort((left, right) => left.localeCompare(right));
+  return discovered;
+}
+function readDiagnostic(kind, path, message, id) {
+  return {
+    kind,
+    path,
+    id,
+    message
+  };
+}
+async function readCanonicalFile(filePath, schema) {
+  let raw;
+  try {
+    raw = await readFile2(filePath, "utf8");
+  } catch (error) {
+    throw new KnowledgeStoreLoadError(
+      `Failed to read canonical knowledge file: ${filePath}`,
+      [
+        readDiagnostic(
+          "missing_domain_file",
+          filePath,
+          `Unable to read canonical file: ${filePath}`
+        )
+      ]
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new KnowledgeStoreLoadError(
+      `Invalid JSON in canonical knowledge file: ${filePath}`,
+      [readDiagnostic("invalid_json", filePath, `Invalid JSON in ${filePath}`)]
+    );
+  }
+  try {
+    return schema.parse(parsed);
+  } catch (error) {
+    throw new KnowledgeStoreLoadError(
+      `Invalid knowledge schema in canonical file: ${filePath}`,
+      [
+        readDiagnostic(
+          "invalid_shape",
+          filePath,
+          `Invalid canonical file shape in ${filePath}`
+        )
+      ]
+    );
+  }
+}
+function validateIdPrefix(collection, id, domainSlug) {
+  const definition = COLLECTION_DEFINITIONS[collection];
+  if (collection === "domains") {
+    const expectedId = `domain.${domainSlug}`;
+    if (id !== expectedId) {
+      return `Expected ${id} to equal ${expectedId}`;
+    }
+    return void 0;
+  }
+  const expectedPrefix = `${definition.idConvention.prefix}.${domainSlug}.`;
+  if (!id.startsWith(expectedPrefix)) {
+    return `Expected ${id} to start with ${expectedPrefix}`;
+  }
+  return void 0;
+}
+function getDomainId(domainSlug) {
+  return `domain.${domainSlug}`;
+}
+function emptyStore(rootDir) {
+  return {
+    rootDir,
+    sourceFiles: [],
+    domains: [],
+    entities: [],
+    relationships: [],
+    capabilities: [],
+    features: [],
+    business_rules: [],
+    constraints: [],
+    rationales: [],
+    evidence: [],
+    questions: [],
+    conflicts: [],
+    byCollection: {
+      domains: /* @__PURE__ */ new Map(),
+      entities: /* @__PURE__ */ new Map(),
+      relationships: /* @__PURE__ */ new Map(),
+      capabilities: /* @__PURE__ */ new Map(),
+      features: /* @__PURE__ */ new Map(),
+      business_rules: /* @__PURE__ */ new Map(),
+      constraints: /* @__PURE__ */ new Map(),
+      rationales: /* @__PURE__ */ new Map(),
+      evidence: /* @__PURE__ */ new Map(),
+      questions: /* @__PURE__ */ new Map(),
+      conflicts: /* @__PURE__ */ new Map()
+    },
+    byId: /* @__PURE__ */ new Map(),
+    reverseReferences: /* @__PURE__ */ new Map(),
+    diagnostics: []
+  };
+}
+function addRecord(store, collection, record2, diagnostics) {
+  if (store.byId.has(record2.id)) {
+    diagnostics.push(
+      readDiagnostic(
+        "duplicate_id",
+        void 0,
+        `Duplicate knowledge id detected: ${record2.id}`,
+        record2.id
+      )
+    );
+    return;
+  }
+  store.byId.set(record2.id, record2);
+  store.byCollection[collection].set(record2.id, record2);
+  store[collection].push(record2);
+}
+function validateFolderRecordIds(collection, records, domainSlug, diagnostics) {
+  for (const record2 of records) {
+    const message = validateIdPrefix(collection, record2.id, domainSlug);
+    if (message) {
+      diagnostics.push(
+        readDiagnostic("invalid_domain_id", void 0, message, record2.id)
+      );
+    }
+  }
+}
+function collectReferenceIds(record2) {
+  if ("relationship_type" in record2) {
+    return [
+      record2.from_entity_id,
+      record2.to_entity_id
+    ];
+  }
+  if ("business_definition" in record2) {
+    const entity = record2;
+    return [
+      ...entity.domain_ids,
+      ...entity.relationship_ids,
+      ...entity.capability_ids,
+      ...entity.feature_ids,
+      ...entity.rule_ids
+    ];
+  }
+  if ("behavior_type" in record2) {
+    const rule = record2;
+    return [
+      ...rule.applies_to.domain_ids ?? [],
+      ...rule.applies_to.entity_ids ?? [],
+      ...rule.applies_to.capability_ids ?? [],
+      ...rule.applies_to.feature_ids ?? [],
+      ...rule.related_constraint_ids,
+      ...rule.rationale_ids
+    ];
+  }
+  if ("constraint_type" in record2) {
+    const constraint = record2;
+    return [
+      ...constraint.applies_to.domain_ids ?? [],
+      ...constraint.applies_to.entity_ids ?? [],
+      ...constraint.applies_to.capability_ids ?? [],
+      ...constraint.applies_to.feature_ids ?? [],
+      ...constraint.applies_to.business_rule_ids ?? []
+    ];
+  }
+  if ("parent_capability_ids" in record2) {
+    const capability = record2;
+    return [
+      ...capability.domain_ids,
+      ...capability.entity_ids,
+      ...capability.parent_capability_ids,
+      ...capability.child_capability_ids,
+      ...capability.feature_ids
+    ];
+  }
+  if ("rule_ids" in record2 && "constraint_ids" in record2) {
+    const feature = record2;
+    return [
+      ...feature.domain_ids,
+      ...feature.capability_ids,
+      ...feature.entity_ids,
+      ...feature.rule_ids,
+      ...feature.constraint_ids
+    ];
+  }
+  if ("entity_ids" in record2 && "capability_ids" in record2 && "why_it_exists" in record2 && !("business_definition" in record2) && !("parent_capability_ids" in record2) && !("constraint_ids" in record2) && !("rule_ids" in record2)) {
+    const domain = record2;
+    return [...domain.entity_ids, ...domain.capability_ids];
+  }
+  if ("explains" in record2) {
+    return record2.explains;
+  }
+  if ("source_type" in record2) {
+    return record2.supports;
+  }
+  if ("priority" in record2) {
+    const question = record2;
+    return [...question.related_ids, ...question.evidence_ids];
+  }
+  const conflict = record2;
+  return [
+    ...conflict.related_ids,
+    ...conflict.evidence_ids,
+    ...conflict.questions
+  ];
+}
+function buildReverseReferences(store) {
+  for (const record2 of store.byId.values()) {
+    const references = collectReferenceIds(record2);
+    for (const referenceId of references) {
+      const reverse = store.reverseReferences.get(referenceId) ?? [];
+      reverse.push(record2.id);
+      store.reverseReferences.set(referenceId, reverse);
+    }
+  }
+}
+function validateReferences(store, diagnostics) {
+  for (const record2 of store.byId.values()) {
+    for (const referenceId of collectReferenceIds(record2)) {
+      if (!store.byId.has(referenceId)) {
+        diagnostics.push(
+          readDiagnostic(
+            "invalid_reference",
+            void 0,
+            `Unknown reference id "${referenceId}" from record "${record2.id}"`,
+            record2.id
+          )
+        );
+      }
+    }
+  }
+}
+function finalizeStore(store, diagnostics) {
+  store.diagnostics = diagnostics;
+  if (diagnostics.length > 0) {
+    throw new KnowledgeStoreLoadError(
+      diagnostics.map((diagnostic) => diagnostic.message).join("; "),
+      diagnostics
+    );
+  }
+  return store;
+}
+async function loadKnowledgeStoreFromRoot(rootDir) {
+  if (!existsSync(rootDir)) {
+    throw new KnowledgeStoreLoadError(
+      `Knowledge root does not exist: ${rootDir}`,
+      [
+        readDiagnostic(
+          "missing_root",
+          rootDir,
+          `Knowledge root does not exist: ${rootDir}`
+        )
+      ]
+    );
+  }
+  const diagnostics = [];
+  const store = emptyStore(rootDir);
+  const domainFolders = await discoverDomainFolders(rootDir);
+  const sourceFiles = [];
+  for (const domainFolder of domainFolders) {
+    const domainSlug = basename(domainFolder);
+    const domainFile = join(
+      domainFolder,
+      COLLECTION_DEFINITIONS.domains.storageFile
+    );
+    if (!existsSync(domainFile)) {
+      diagnostics.push(
+        readDiagnostic(
+          "missing_domain_file",
+          domainFile,
+          `Missing canonical domain file: ${domainFile}`
+        )
+      );
+      continue;
+    }
+    const domain = await readCanonicalFile(
+      domainFile,
+      domainSchema
+    );
+    sourceFiles.push(domainFile);
+    validateFolderRecordIds("domains", [domain], domainSlug, diagnostics);
+    const domainId = getDomainId(domainSlug);
+    if (domain.id !== domainId) {
+      diagnostics.push(
+        readDiagnostic(
+          "invalid_domain_id",
+          domainFile,
+          `Domain id "${domain.id}" must match folder slug "${domainSlug}"`,
+          domain.id
+        )
+      );
+    }
+    addRecord(store, "domains", domain, diagnostics);
+    for (const collection of Object.keys(
+      COLLECTION_DEFINITIONS
+    )) {
+      if (collection === "domains") {
+        continue;
+      }
+      const fileName = COLLECTION_DEFINITIONS[collection].storageFile;
+      const filePath = join(domainFolder, fileName);
+      if (!existsSync(filePath)) {
+        continue;
+      }
+      const parsed = await readCanonicalFile(
+        filePath,
+        COLLECTION_SCHEMAS[collection]
+      );
+      sourceFiles.push(filePath);
+      validateFolderRecordIds(
+        collection,
+        parsed,
+        domainSlug,
+        diagnostics
+      );
+      for (const record2 of parsed) {
+        addRecord(store, collection, record2, diagnostics);
+      }
+    }
+  }
+  store.sourceFiles = sourceFiles.sort(
+    (left, right) => left.localeCompare(right)
+  );
+  buildReverseReferences(store);
+  validateReferences(store, diagnostics);
+  return finalizeStore(store, diagnostics);
+}
+async function loadKnowledgeStoreFromEnv(envValue, cwd = process.cwd()) {
+  const rootDir = resolveKnowledgeRoot(envValue, cwd);
+  if (!rootDir || !existsSync(rootDir)) {
+    return void 0;
+  }
+  return loadKnowledgeStoreFromRoot(rootDir);
+}
+
+// packages/core/src/knowledge/patch/storage.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { mkdir, readFile as readFile3, readdir, writeFile } from "node:fs/promises";
+import { isAbsolute, join as join3, normalize, resolve as resolve4, sep } from "node:path";
+import "zod/v4";
+
+// packages/core/src/knowledge/patch/constants.ts
+var KNOWLEDGE_PATCH_SCHEMA_VERSION = 1;
+var KNOWLEDGE_PATCH_FOLDER_NAME = ".patches";
+var SUPPORTED_OPERATION_TYPES = Object.keys(
+  KNOWLEDGE_EXTRACTION_TYPE_REGISTRY
+);
+var supportedOperationTypeSet = new Set(
+  SUPPORTED_OPERATION_TYPES
+);
+
+// packages/core/src/knowledge/patch/paths.ts
+import { join as join2 } from "node:path";
+function getKnowledgeRoot(envValue, cwd = process.cwd()) {
+  return resolveKnowledgeRootFromEnv(envValue, cwd);
+}
+function resolveKnowledgePatchRoot(envValue, cwd = process.cwd()) {
+  return join2(getKnowledgeRoot(envValue, cwd), KNOWLEDGE_PATCH_FOLDER_NAME);
+}
+function resolveKnowledgePatchDirectory(envValue, patchId, cwd = process.cwd()) {
+  return join2(resolveKnowledgePatchRoot(envValue, cwd), patchId);
+}
+function resolveKnowledgeRoot2(envValue, cwd = process.cwd()) {
+  return getKnowledgeRoot(envValue, cwd);
+}
+function patchMetadataPath(patchDir) {
+  return join2(patchDir, "patch.json");
+}
+function patchOperationsPath(patchDir) {
+  return join2(patchDir, "operations.json");
+}
+
+// packages/core/src/knowledge/patch/schemas.ts
+import { z as z4 } from "zod/v4";
+var patchStatusSchema = z4.enum(["draft", "closed"]);
+var canonicalOperationTypeSchema = z4.string().trim().min(1).superRefine((value, ctx) => {
+  if (!supportedOperationTypeSet.has(value)) {
+    ctx.addIssue({
+      code: "custom",
+      message: `Unsupported patch operation type "${value}". Supported types: ${SUPPORTED_OPERATION_TYPES.join(
+        ", "
+      )}`
+    });
+  }
+}).transform((value) => value);
+var knowledgePatchMetadataSchema = z4.object({
+  id: z4.string().min(1),
+  title: z4.string().trim().min(1),
+  description: z4.string().trim().min(1).optional(),
+  status: patchStatusSchema,
+  rootFolder: z4.string().trim().min(1),
+  omittedFiles: z4.array(
+    z4.object({
+      path: z4.string().trim().min(1),
+      reason: z4.string().trim().min(1)
+    })
+  ),
+  schemaVersion: z4.literal(KNOWLEDGE_PATCH_SCHEMA_VERSION),
+  createdAt: z4.string().datetime({ offset: true }),
+  updatedAt: z4.string().datetime({ offset: true }),
+  closedAt: z4.string().datetime({ offset: true }).optional()
+});
+var operationBaseSchema = z4.object({
+  id: z4.string().min(1),
+  type: canonicalOperationTypeSchema,
+  domain: z4.string().trim().min(1)
+});
+var knowledgePatchCreateOperationSchema = operationBaseSchema.extend({
+  kind: z4.literal("create"),
+  payload: z4.record(z4.string(), z4.unknown())
+});
+var knowledgePatchUpdateOperationSchema = operationBaseSchema.extend({
+  kind: z4.literal("update"),
+  targetId: z4.string().min(1),
+  payload: z4.record(z4.string(), z4.unknown())
+});
+var knowledgePatchDeleteOperationSchema = operationBaseSchema.extend({
+  kind: z4.literal("delete"),
+  targetId: z4.string().min(1),
+  reason: z4.string().trim().min(1)
+});
+var knowledgePatchOperationSchema = z4.discriminatedUnion("kind", [
+  knowledgePatchCreateOperationSchema,
+  knowledgePatchUpdateOperationSchema,
+  knowledgePatchDeleteOperationSchema
+]);
+var knowledgePatchOperationsEnvelopeSchema = z4.object({
+  schemaVersion: z4.literal(KNOWLEDGE_PATCH_SCHEMA_VERSION),
+  operations: z4.array(knowledgePatchOperationSchema)
+});
+var knowledgePatchDiagnosticSchema = z4.object({
+  severity: z4.enum(["error", "critical"]),
+  code: z4.string(),
+  message: z4.string(),
+  patchId: z4.string().optional(),
+  operationId: z4.string().optional(),
+  targetId: z4.string().optional(),
+  path: z4.array(z4.union([z4.string(), z4.number()])).optional(),
+  supportedTypes: z4.array(z4.string()).optional()
+});
+var knowledgePatchValidationResultSchema = z4.object({
+  valid: z4.boolean(),
+  fingerprint: z4.string().optional(),
+  diagnostics: z4.array(knowledgePatchDiagnosticSchema),
+  operationCount: z4.number().int().nonnegative(),
+  appliedOperationIds: z4.array(z4.string()),
+  affectedFiles: z4.array(z4.string())
+});
+var knowledgePatchApplyApprovalSchema = z4.object({
+  approved: z4.boolean(),
+  validationFingerprint: z4.string().min(1)
+});
+var createPatchInputSchema = z4.object({
+  title: z4.string().trim().min(1),
+  description: z4.string().trim().min(1).optional(),
+  rootFolder: z4.string().trim().min(1),
+  omittedFiles: z4.array(
+    z4.object({
+      path: z4.string().trim().min(1),
+      reason: z4.string().trim().min(1)
+    })
+  ).optional()
+});
+var addOperationInputSchema = z4.discriminatedUnion("kind", [
+  knowledgePatchCreateOperationSchema.omit({ id: true }).extend({
+    id: z4.string().min(1).optional()
+  }),
+  knowledgePatchUpdateOperationSchema.omit({ id: true }).extend({
+    id: z4.string().min(1).optional()
+  }),
+  knowledgePatchDeleteOperationSchema.omit({ id: true }).extend({
+    id: z4.string().min(1).optional()
+  })
+]);
+var updateOperationInputSchema = z4.object({
+  operationId: z4.string().min(1),
+  operation: addOperationInputSchema
+});
+var updatePatchMetadataInputSchema = z4.object({
+  rootFolder: z4.string().trim().min(1).optional(),
+  omittedFiles: z4.array(
+    z4.object({
+      path: z4.string().trim().min(1),
+      reason: z4.string().trim().min(1)
+    })
+  )
+});
+var knowledgePatchToolInputSchema = z4.discriminatedUnion("action", [
+  z4.object({
+    action: z4.literal("create"),
+    patch: createPatchInputSchema
+  }),
+  z4.object({
+    action: z4.literal("list")
+  }),
+  z4.object({
+    action: z4.literal("get"),
+    patchId: z4.string().min(1)
+  }),
+  z4.object({
+    action: z4.literal("add_operation"),
+    patchId: z4.string().min(1),
+    operation: addOperationInputSchema
+  }),
+  z4.object({
+    action: z4.literal("update_operation"),
+    patchId: z4.string().min(1),
+    update: updateOperationInputSchema
+  }),
+  z4.object({
+    action: z4.literal("update_metadata"),
+    patchId: z4.string().min(1),
+    metadata: updatePatchMetadataInputSchema
+  }),
+  z4.object({
+    action: z4.literal("delete_operation"),
+    patchId: z4.string().min(1),
+    operationId: z4.string().min(1)
+  }),
+  z4.object({
+    action: z4.literal("validate"),
+    patchId: z4.string().min(1)
+  }),
+  z4.object({
+    action: z4.literal("close"),
+    patchId: z4.string().min(1)
+  })
+]);
+var knowledgePatchApplyToolInputSchema = z4.object({
+  patchId: z4.string().min(1),
+  approval: knowledgePatchApplyApprovalSchema
+});
+
+// packages/core/src/knowledge/patch/utils.ts
+import { createHash, randomUUID } from "node:crypto";
+function buildDiagnostic(diagnostic) {
+  return knowledgePatchDiagnosticSchema.parse(diagnostic);
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function slugifyPatchTitle(title) {
+  const normalized = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return normalized || "patch";
+}
+function buildPatchId(title) {
+  return `${slugifyPatchTitle(title)}-${randomUUID().slice(0, 8)}`;
+}
+function buildOperationId() {
+  return `op_${randomUUID().slice(0, 10)}`;
+}
+function sha256(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+
+// packages/core/src/knowledge/patch/storage.ts
+async function ensurePatchRoot(rootDir) {
+  await mkdir(rootDir, { recursive: true });
+}
+async function writeJsonFile(filePath, value) {
+  await writeFile(filePath, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+}
+async function readJsonFile(filePath, schema) {
+  const raw = await readFile3(filePath, "utf8");
+  const parsed = JSON.parse(raw);
+  return schema.parse(parsed);
+}
+function normalizeRootFolder(rootFolder, cwd = process.cwd()) {
+  return resolve4(cwd, rootFolder);
+}
+function normalizeRepositoryRelativePath(inputPath) {
+  const trimmed = inputPath.trim().replaceAll("\\", "/");
+  if (!trimmed) {
+    throw new Error("Omitted file path must not be empty.");
+  }
+  if (isAbsolute(trimmed)) {
+    throw new Error(
+      `Omitted file path "${inputPath}" must be repository-relative.`
+    );
+  }
+  const normalized = normalize(trimmed).replaceAll(sep, "/");
+  if (normalized === "." || normalized === ".." || normalized.startsWith("../")) {
+    throw new Error(
+      `Omitted file path "${inputPath}" must stay within the repository root.`
+    );
+  }
+  return normalized;
+}
+function normalizeOmittedFiles(omittedFiles) {
+  return (omittedFiles ?? []).map((entry) => ({
+    path: normalizeRepositoryRelativePath(entry.path),
+    reason: entry.reason.trim()
+  }));
+}
+async function loadPatchStateByDir(patchDir) {
+  const patch = await readJsonFile(
+    patchMetadataPath(patchDir),
+    knowledgePatchMetadataSchema
+  );
+  const envelope = await readJsonFile(
+    patchOperationsPath(patchDir),
+    knowledgePatchOperationsEnvelopeSchema
+  );
+  return {
+    patch,
+    operations: envelope.operations
+  };
+}
+async function readKnowledgePatch(envValue, patchId, cwd = process.cwd()) {
+  const patchDir = resolveKnowledgePatchDirectory(envValue, patchId, cwd);
+  return loadPatchStateByDir(patchDir);
+}
+function assertDraftPatch(patch) {
+  if (patch.status !== "draft") {
+    throw new Error(`Patch "${patch.id}" is closed and cannot be modified.`);
+  }
+}
+async function savePatchState(patchDir, state) {
+  const envelope = {
+    schemaVersion: KNOWLEDGE_PATCH_SCHEMA_VERSION,
+    operations: state.operations
+  };
+  await writeJsonFile(patchMetadataPath(patchDir), state.patch);
+  await writeJsonFile(patchOperationsPath(patchDir), envelope);
+}
+async function createKnowledgePatch(envValue, input, cwd = process.cwd()) {
+  const patchRoot = resolveKnowledgePatchRoot(envValue, cwd);
+  await ensurePatchRoot(patchRoot);
+  const patchInput = createPatchInputSchema.parse(input);
+  const patchId = buildPatchId(patchInput.title);
+  const timestamp = nowIso();
+  const patch = {
+    id: patchId,
+    title: patchInput.title,
+    description: patchInput.description,
+    status: "draft",
+    rootFolder: normalizeRootFolder(patchInput.rootFolder, cwd),
+    omittedFiles: normalizeOmittedFiles(patchInput.omittedFiles),
+    schemaVersion: KNOWLEDGE_PATCH_SCHEMA_VERSION,
+    createdAt: timestamp,
+    updatedAt: timestamp
+  };
+  const patchDir = join3(patchRoot, patchId);
+  await mkdir(patchDir, { recursive: true });
+  await savePatchState(patchDir, { patch, operations: [] });
+  return readKnowledgePatch(envValue, patchId, cwd);
+}
+async function listKnowledgePatches(envValue, cwd = process.cwd()) {
+  const patchRoot = resolveKnowledgePatchRoot(envValue, cwd);
+  if (!existsSync2(patchRoot)) {
+    return [];
+  }
+  const entries = await readdir(patchRoot, { withFileTypes: true });
+  const summaries = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const patchDir = join3(patchRoot, entry.name);
+    const state = await loadPatchStateByDir(patchDir);
+    summaries.push({
+      id: state.patch.id,
+      status: state.patch.status,
+      title: state.patch.title,
+      description: state.patch.description,
+      rootFolder: state.patch.rootFolder,
+      omittedFiles: state.patch.omittedFiles,
+      operationCount: state.operations.length,
+      createdAt: state.patch.createdAt,
+      updatedAt: state.patch.updatedAt
+    });
+  }
+  summaries.sort(
+    (left, right) => left.createdAt === right.createdAt ? left.id.localeCompare(right.id) : left.createdAt.localeCompare(right.createdAt)
+  );
+  return summaries;
+}
+async function addKnowledgePatchOperation(envValue, patchId, input, cwd = process.cwd()) {
+  const patchDir = resolveKnowledgePatchDirectory(envValue, patchId, cwd);
+  const state = await loadPatchStateByDir(patchDir);
+  assertDraftPatch(state.patch);
+  const operation = knowledgePatchOperationSchema.parse({
+    ...input,
+    id: input.id ?? buildOperationId()
+  });
+  state.operations.push(operation);
+  state.patch.updatedAt = nowIso();
+  await savePatchState(patchDir, state);
+  return state;
+}
+async function updateKnowledgePatchMetadata(envValue, patchId, input, cwd = process.cwd()) {
+  const patchDir = resolveKnowledgePatchDirectory(envValue, patchId, cwd);
+  const state = await loadPatchStateByDir(patchDir);
+  assertDraftPatch(state.patch);
+  const metadata = updatePatchMetadataInputSchema.parse(input);
+  const nextMetadata = {
+    omittedFiles: normalizeOmittedFiles(metadata.omittedFiles)
+  };
+  if (metadata.rootFolder) {
+    nextMetadata.rootFolder = normalizeRootFolder(metadata.rootFolder, cwd);
+  }
+  state.patch = knowledgePatchMetadataSchema.parse({
+    ...state.patch,
+    ...nextMetadata,
+    updatedAt: nowIso()
+  });
+  await savePatchState(patchDir, state);
+  return state;
+}
+async function updateKnowledgePatchOperation(envValue, patchId, input, cwd = process.cwd()) {
+  const patchDir = resolveKnowledgePatchDirectory(envValue, patchId, cwd);
+  const state = await loadPatchStateByDir(patchDir);
+  assertDraftPatch(state.patch);
+  const update = updateOperationInputSchema.parse(input);
+  const index = state.operations.findIndex(
+    (operation) => operation.id === update.operationId
+  );
+  if (index === -1) {
+    throw new Error(
+      `Patch "${patchId}" does not contain operation "${update.operationId}".`
+    );
+  }
+  state.operations[index] = knowledgePatchOperationSchema.parse({
+    ...update.operation,
+    id: update.operation.id ?? update.operationId
+  });
+  state.patch.updatedAt = nowIso();
+  await savePatchState(patchDir, state);
+  return state;
+}
+async function deleteKnowledgePatchOperation(envValue, patchId, operationId, cwd = process.cwd()) {
+  const patchDir = resolveKnowledgePatchDirectory(envValue, patchId, cwd);
+  const state = await loadPatchStateByDir(patchDir);
+  assertDraftPatch(state.patch);
+  const nextOperations = state.operations.filter(
+    (operation) => operation.id !== operationId
+  );
+  if (nextOperations.length === state.operations.length) {
+    throw new Error(
+      `Patch "${patchId}" does not contain operation "${operationId}".`
+    );
+  }
+  state.operations = nextOperations;
+  state.patch.updatedAt = nowIso();
+  await savePatchState(patchDir, state);
+  return state;
+}
+async function closeKnowledgePatch(envValue, patchId, cwd = process.cwd()) {
+  const patchDir = resolveKnowledgePatchDirectory(envValue, patchId, cwd);
+  const state = await loadPatchStateByDir(patchDir);
+  assertDraftPatch(state.patch);
+  const timestamp = nowIso();
+  state.patch.status = "closed";
+  state.patch.updatedAt = timestamp;
+  state.patch.closedAt = timestamp;
+  await savePatchState(patchDir, state);
+  return state;
+}
+
+// packages/core/src/knowledge/patch/simulation.ts
+function cloneStoreState(store) {
+  const byCollection = Object.fromEntries(
+    SUPPORTED_OPERATION_TYPES.map((collection) => [
+      collection,
+      new Map(store.byCollection[collection])
+    ])
+  );
+  return {
+    byCollection,
+    byId: new Map(store.byId)
+  };
+}
+function validateRecordIdForDomain(type, id, domain) {
+  const definition = KNOWLEDGE_EXTRACTION_TYPE_REGISTRY[type];
+  if (type === "domains") {
+    const expectedId = `domain.${domain}`;
+    return id === expectedId ? void 0 : `Expected domain record id "${id}" to equal "${expectedId}".`;
+  }
+  const expectedPrefix = `${definition.idConvention.prefix}.${domain}.`;
+  return id.startsWith(expectedPrefix) ? void 0 : `Expected record id "${id}" to start with "${expectedPrefix}".`;
+}
+function collectReferenceIds2(record2) {
+  if ("relationship_type" in record2) {
+    return [
+      record2.from_entity_id,
+      record2.to_entity_id
+    ];
+  }
+  if ("business_definition" in record2) {
+    const entity = record2;
+    return [
+      ...entity.domain_ids,
+      ...entity.relationship_ids,
+      ...entity.capability_ids,
+      ...entity.feature_ids,
+      ...entity.rule_ids
+    ];
+  }
+  if ("behavior_type" in record2) {
+    const rule = record2;
+    return [
+      ...rule.applies_to.domain_ids ?? [],
+      ...rule.applies_to.entity_ids ?? [],
+      ...rule.applies_to.capability_ids ?? [],
+      ...rule.applies_to.feature_ids ?? [],
+      ...rule.related_constraint_ids,
+      ...rule.rationale_ids
+    ];
+  }
+  if ("constraint_type" in record2) {
+    const constraint = record2;
+    return [
+      ...constraint.applies_to.domain_ids ?? [],
+      ...constraint.applies_to.entity_ids ?? [],
+      ...constraint.applies_to.capability_ids ?? [],
+      ...constraint.applies_to.feature_ids ?? [],
+      ...constraint.applies_to.business_rule_ids ?? []
+    ];
+  }
+  if ("parent_capability_ids" in record2) {
+    const capability = record2;
+    return [
+      ...capability.domain_ids,
+      ...capability.entity_ids,
+      ...capability.parent_capability_ids,
+      ...capability.child_capability_ids,
+      ...capability.feature_ids
+    ];
+  }
+  if ("rule_ids" in record2 && "constraint_ids" in record2) {
+    const feature = record2;
+    return [
+      ...feature.domain_ids,
+      ...feature.capability_ids,
+      ...feature.entity_ids,
+      ...feature.rule_ids,
+      ...feature.constraint_ids
+    ];
+  }
+  if ("entity_ids" in record2 && "capability_ids" in record2 && "why_it_exists" in record2 && !("business_definition" in record2) && !("parent_capability_ids" in record2) && !("constraint_ids" in record2) && !("rule_ids" in record2)) {
+    const domain = record2;
+    return [...domain.entity_ids, ...domain.capability_ids];
+  }
+  if ("explains" in record2) {
+    return record2.explains;
+  }
+  if ("source_type" in record2) {
+    return record2.supports;
+  }
+  if ("priority" in record2) {
+    const question = record2;
+    return [...question.related_ids, ...question.evidence_ids];
+  }
+  const conflict = record2;
+  return [
+    ...conflict.related_ids,
+    ...conflict.evidence_ids,
+    ...conflict.questions,
+    ...conflict.resolved_by_evidence_id ? [conflict.resolved_by_evidence_id] : []
+  ];
+}
+function inferDomainFromRecordId(recordId) {
+  const [, domain] = recordId.split(".");
+  return domain;
+}
+function inferDomainForRecord(record2) {
+  return inferDomainFromRecordId(record2.id);
+}
+function parsePatchRecord(operation, diagnostics) {
+  const definition = KNOWLEDGE_EXTRACTION_TYPE_REGISTRY[operation.type];
+  if (operation.kind === "delete") {
+    return void 0;
+  }
+  const parsed = definition.schema.safeParse(operation.payload);
+  if (!parsed.success) {
+    diagnostics.push(
+      buildDiagnostic({
+        severity: "error",
+        code: "invalid_payload",
+        message: `Operation "${operation.id}" payload is invalid for type "${operation.type}".`,
+        operationId: operation.id,
+        path: ["operations", operation.id, "payload"]
+      })
+    );
+    return void 0;
+  }
+  return parsed.data;
+}
+function simulateKnowledgePatch(store, operations, patchId) {
+  const state = cloneStoreState(store);
+  const diagnostics = [];
+  const deleteTargets = [];
+  const appliedOperationIds = [];
+  for (const operation of operations) {
+    if (!supportedOperationTypeSet.has(operation.type)) {
+      diagnostics.push(
+        buildDiagnostic({
+          severity: "error",
+          code: "invalid_type",
+          message: `Unsupported patch operation type "${operation.type}".`,
+          patchId,
+          operationId: operation.id,
+          supportedTypes: SUPPORTED_OPERATION_TYPES
+        })
+      );
+      continue;
+    }
+    if (operation.kind === "delete") {
+      const existing = state.byCollection[operation.type].get(
+        operation.targetId
+      );
+      if (!existing) {
+        diagnostics.push(
+          buildDiagnostic({
+            severity: "error",
+            code: "missing_target",
+            message: `Delete target "${operation.targetId}" does not exist in "${operation.type}".`,
+            patchId,
+            operationId: operation.id,
+            targetId: operation.targetId
+          })
+        );
+        continue;
+      }
+      state.byCollection[operation.type].delete(operation.targetId);
+      state.byId.delete(operation.targetId);
+      deleteTargets.push(operation.targetId);
+      appliedOperationIds.push(operation.id);
+      continue;
+    }
+    const parsedRecord = parsePatchRecord(operation, diagnostics);
+    if (!parsedRecord) {
+      continue;
+    }
+    const idMessage = validateRecordIdForDomain(
+      operation.type,
+      parsedRecord.id,
+      operation.domain
+    );
+    if (idMessage) {
+      diagnostics.push(
+        buildDiagnostic({
+          severity: "error",
+          code: "invalid_id_convention",
+          message: idMessage,
+          patchId,
+          operationId: operation.id,
+          targetId: parsedRecord.id
+        })
+      );
+      continue;
+    }
+    if (operation.kind === "create" && state.byId.has(parsedRecord.id)) {
+      diagnostics.push(
+        buildDiagnostic({
+          severity: "error",
+          code: "duplicate_id",
+          message: `Create operation would duplicate existing id "${parsedRecord.id}".`,
+          patchId,
+          operationId: operation.id,
+          targetId: parsedRecord.id
+        })
+      );
+      continue;
+    }
+    if (operation.kind === "update") {
+      if (parsedRecord.id !== operation.targetId) {
+        diagnostics.push(
+          buildDiagnostic({
+            severity: "error",
+            code: "update_target_mismatch",
+            message: `Update payload id "${parsedRecord.id}" must match target "${operation.targetId}".`,
+            patchId,
+            operationId: operation.id,
+            targetId: operation.targetId
+          })
+        );
+        continue;
+      }
+      if (!state.byCollection[operation.type].has(operation.targetId)) {
+        diagnostics.push(
+          buildDiagnostic({
+            severity: "error",
+            code: "missing_target",
+            message: `Update target "${operation.targetId}" does not exist in "${operation.type}".`,
+            patchId,
+            operationId: operation.id,
+            targetId: operation.targetId
+          })
+        );
+        continue;
+      }
+    }
+    state.byCollection[operation.type].set(parsedRecord.id, parsedRecord);
+    state.byId.set(parsedRecord.id, parsedRecord);
+    appliedOperationIds.push(operation.id);
+  }
+  for (const record2 of state.byId.values()) {
+    for (const referenceId of collectReferenceIds2(record2)) {
+      if (!state.byId.has(referenceId)) {
+        diagnostics.push(
+          buildDiagnostic({
+            severity: "error",
+            code: "invalid_reference",
+            message: `Record "${record2.id}" references unknown id "${referenceId}".`,
+            patchId,
+            targetId: record2.id
+          })
+        );
+      }
+    }
+  }
+  const inboundReferenceMap = /* @__PURE__ */ new Map();
+  for (const record2 of state.byId.values()) {
+    for (const referenceId of collectReferenceIds2(record2)) {
+      const inbound = inboundReferenceMap.get(referenceId) ?? [];
+      inbound.push(record2.id);
+      inboundReferenceMap.set(referenceId, inbound);
+    }
+  }
+  for (const deleteTarget of deleteTargets) {
+    const inbound = inboundReferenceMap.get(deleteTarget) ?? [];
+    if (inbound.length > 0) {
+      diagnostics.push(
+        buildDiagnostic({
+          severity: "error",
+          code: "delete_has_inbound_references",
+          message: `Delete target "${deleteTarget}" still has inbound references from: ${inbound.join(
+            ", "
+          )}`,
+          patchId,
+          targetId: deleteTarget
+        })
+      );
+    }
+  }
+  return {
+    state,
+    diagnostics,
+    appliedOperationIds,
+    deleteTargets
+  };
+}
+
+// packages/core/src/knowledge/effective-state.ts
+function toSimulationStore(rootDir, sourceFiles, state) {
+  const store = {
+    rootDir,
+    sourceFiles,
+    domains: [...state.byCollection.domains.values()],
+    entities: [...state.byCollection.entities.values()],
+    relationships: [...state.byCollection.relationships.values()],
+    capabilities: [...state.byCollection.capabilities.values()],
+    features: [...state.byCollection.features.values()],
+    business_rules: [...state.byCollection.business_rules.values()],
+    constraints: [...state.byCollection.constraints.values()],
+    rationales: [...state.byCollection.rationales.values()],
+    evidence: [...state.byCollection.evidence.values()],
+    questions: [...state.byCollection.questions.values()],
+    conflicts: [...state.byCollection.conflicts.values()],
+    byCollection: state.byCollection,
+    byId: state.byId,
+    reverseReferences: /* @__PURE__ */ new Map(),
+    diagnostics: []
+  };
+  for (const record2 of store.byId.values()) {
+    for (const referenceId of collectReferenceIds2(record2)) {
+      const reverse = store.reverseReferences.get(referenceId) ?? [];
+      reverse.push(record2.id);
+      store.reverseReferences.set(referenceId, reverse);
+    }
+  }
+  return store;
+}
+function selectOrderedPatches(patches, options) {
+  const visiblePatches = options.includeAllStatuses ? patches : patches.filter((patch) => patch.status === "draft");
+  if (!options.selectedPatchId) {
+    return visiblePatches;
+  }
+  const selectedIndex = visiblePatches.findIndex(
+    (patch) => patch.id === options.selectedPatchId
+  );
+  if (selectedIndex === -1) {
+    throw new Error(`Patch "${options.selectedPatchId}" was not found.`);
+  }
+  const endIndex = options.includeSelectedPatch === false ? selectedIndex : selectedIndex + 1;
+  return visiblePatches.slice(0, endIndex);
+}
+async function composeEffectiveKnowledgeState(store, envValue, options = {}, cwd = process.cwd()) {
+  const orderedPatches = selectOrderedPatches(
+    await listKnowledgePatches(envValue, cwd),
+    options
+  );
+  let currentState = store;
+  const provenance = /* @__PURE__ */ new Map();
+  const diagnostics = [];
+  for (const patch of orderedPatches) {
+    const patchState = await readKnowledgePatch(envValue, patch.id, cwd);
+    const simulation = simulateKnowledgePatch(
+      currentState,
+      patchState.operations,
+      patch.id
+    );
+    diagnostics.push(...simulation.diagnostics);
+    for (const operationId of simulation.appliedOperationIds) {
+      const operation = patchState.operations.find(
+        (entry) => entry.id === operationId
+      );
+      if (!operation || operation.kind === "delete") {
+        continue;
+      }
+      const recordId = operation.kind === "update" ? operation.targetId : operation.payload.id;
+      const existing = provenance.get(recordId);
+      const patchIds = new Set(existing?.patchIds ?? []);
+      patchIds.add(patch.id);
+      provenance.set(recordId, {
+        patchIds: [...patchIds],
+        patched: true
+      });
+    }
+    currentState = toSimulationStore(
+      store.rootDir,
+      store.sourceFiles,
+      simulation.state
+    );
+  }
+  return {
+    store: currentState,
+    patches: orderedPatches,
+    patchIds: orderedPatches.map((patch) => patch.id),
+    provenance,
+    diagnostics
+  };
+}
+async function loadEffectiveKnowledgeStoreFromRoot(rootDir, options = {}) {
+  const store = await loadKnowledgeStoreFromRoot(rootDir);
+  return composeEffectiveKnowledgeState(store, rootDir, options);
+}
+async function loadEffectiveKnowledgeStoreFromEnv(envValue, cwd = process.cwd(), options = {}) {
+  const store = await loadKnowledgeStoreFromEnv(envValue, cwd);
+  if (!store) {
+    return void 0;
+  }
+  return composeEffectiveKnowledgeState(store, envValue, options, cwd);
+}
+
+// packages/core/src/knowledge/graphql.ts
+import {
+  GraphQLBoolean,
+  GraphQLFloat,
+  GraphQLID,
+  GraphQLList,
+  GraphQLObjectType,
+  GraphQLSchema,
+  GraphQLString,
+  graphql
+} from "graphql";
+function stringifyValue(value) {
+  if (value === void 0 || value === null) {
+    return null;
+  }
+  return typeof value === "string" ? value : JSON.stringify(value);
+}
+var confidenceType = new GraphQLObjectType({
+  name: "Confidence",
+  fields: {
+    score: { type: GraphQLFloat },
+    level: { type: GraphQLString },
+    reason: { type: GraphQLString }
+  }
+});
+var locationType = new GraphQLObjectType({
+  name: "EvidenceLocation",
+  fields: {
+    path: { type: GraphQLString },
+    symbol: { type: GraphQLString },
+    route: { type: GraphQLString },
+    api: { type: GraphQLString },
+    query: { type: GraphQLString }
+  }
+});
+var evidenceType = new GraphQLObjectType({
+  name: "Evidence",
+  fields: () => ({
+    id: { type: GraphQLID },
+    source_type: { type: GraphQLString },
+    description: { type: GraphQLString },
+    location: { type: locationType },
+    supports: { type: new GraphQLList(GraphQLID) },
+    excerpt: { type: GraphQLString },
+    confidence: { type: confidenceType }
+  })
+});
+var entityTechnicalRepresentationType = new GraphQLObjectType({
+  name: "EntityTechnicalRepresentation",
+  fields: {
+    kind: { type: GraphQLString },
+    name: { type: GraphQLString },
+    location_hint: { type: GraphQLString }
+  }
+});
+var entityType = new GraphQLObjectType({
+  name: "Entity",
+  fields: () => ({
+    id: { type: GraphQLID },
+    name: { type: GraphQLString },
+    business_definition: { type: GraphQLString },
+    description: { type: GraphQLString },
+    purpose: { type: GraphQLString },
+    aliases: { type: new GraphQLList(GraphQLString) },
+    ambiguous_terms: { type: new GraphQLList(GraphQLString) },
+    technical_representations: {
+      type: new GraphQLList(entityTechnicalRepresentationType)
+    },
+    domain_ids: { type: new GraphQLList(GraphQLID) },
+    state_values: { type: new GraphQLList(GraphQLString) },
+    relationship_ids: { type: new GraphQLList(GraphQLID) },
+    capability_ids: { type: new GraphQLList(GraphQLID) },
+    feature_ids: { type: new GraphQLList(GraphQLID) },
+    rule_ids: { type: new GraphQLList(GraphQLID) },
+    domains: {
+      type: new GraphQLList(domainType),
+      resolve: (entity, _args, context) => resolveByIds(context, "domains", entity.domain_ids)
+    },
+    relationships: {
+      type: new GraphQLList(entityRelationshipType),
+      resolve: (entity, _args, context) => resolveByIds(context, "relationships", entity.relationship_ids)
+    },
+    capabilities: {
+      type: new GraphQLList(capabilityType),
+      resolve: (entity, _args, context) => resolveByIds(context, "capabilities", entity.capability_ids)
+    },
+    features: {
+      type: new GraphQLList(featureType),
+      resolve: (entity, _args, context) => resolveByIds(context, "features", entity.feature_ids)
+    },
+    business_rules: {
+      type: new GraphQLList(businessRuleType),
+      resolve: (entity, _args, context) => resolveByIds(context, "business_rules", entity.rule_ids)
+    },
+    certainty: { type: GraphQLString },
+    confidence: { type: confidenceType }
+  })
+});
+var ruleConditionType = new GraphQLObjectType({
+  name: "RuleCondition",
+  fields: {
+    subject: { type: GraphQLString },
+    field: { type: GraphQLString },
+    operator: { type: GraphQLString },
+    value: {
+      type: GraphQLString,
+      resolve: (condition) => stringifyValue(condition.value)
+    }
+  }
+});
+var ruleTriggerType = new GraphQLObjectType({
+  name: "RuleTrigger",
+  fields: {
+    actor: { type: GraphQLString },
+    action: { type: GraphQLString },
+    subject: { type: GraphQLString },
+    field: { type: GraphQLString },
+    operator: { type: GraphQLString },
+    value: {
+      type: GraphQLString,
+      resolve: (trigger) => stringifyValue(trigger.value)
+    }
+  }
+});
+var ruleEffectType = new GraphQLObjectType({
+  name: "RuleEffect",
+  fields: {
+    effect: { type: GraphQLString },
+    action: { type: GraphQLString },
+    message: { type: GraphQLString },
+    target_state: { type: GraphQLString },
+    value: {
+      type: GraphQLString,
+      resolve: (effect) => stringifyValue(effect.value)
+    }
+  }
+});
+var businessRuleConditionType = new GraphQLObjectType({
+  name: "BusinessRuleCondition",
+  fields: {
+    given: { type: new GraphQLList(ruleConditionType) },
+    when: { type: new GraphQLList(ruleTriggerType) },
+    then: { type: new GraphQLList(ruleEffectType) }
+  }
+});
+var businessRuleAppliesToType = new GraphQLObjectType({
+  name: "BusinessRuleAppliesTo",
+  fields: {
+    domain_ids: { type: new GraphQLList(GraphQLID) },
+    entity_ids: { type: new GraphQLList(GraphQLID) },
+    capability_ids: { type: new GraphQLList(GraphQLID) },
+    feature_ids: { type: new GraphQLList(GraphQLID) }
+  }
+});
+var businessRuleEnforcementType = new GraphQLObjectType({
+  name: "BusinessRuleEnforcement",
+  fields: {
+    level: { type: GraphQLString },
+    description: { type: GraphQLString }
+  }
+});
+var businessRuleType = new GraphQLObjectType({
+  name: "BusinessRule",
+  fields: () => ({
+    id: { type: GraphQLID },
+    name: { type: GraphQLString },
+    statement: { type: GraphQLString },
+    rule_type: { type: GraphQLString },
+    behavior_type: { type: GraphQLString },
+    applies_to: { type: businessRuleAppliesToType },
+    condition: { type: businessRuleConditionType },
+    enforcement: { type: businessRuleEnforcementType },
+    related_constraint_ids: { type: new GraphQLList(GraphQLID) },
+    rationale_ids: { type: new GraphQLList(GraphQLID) },
+    certainty: { type: GraphQLString },
+    confidence: { type: confidenceType }
+  })
+});
+var constraintCauseType = new GraphQLObjectType({
+  name: "ConstraintCause",
+  fields: {
+    source: { type: GraphQLString },
+    source_type: { type: GraphQLString },
+    description: { type: GraphQLString }
+  }
+});
+var constraintImpactType = new GraphQLObjectType({
+  name: "ConstraintImpact",
+  fields: {
+    affected_change_types: { type: new GraphQLList(GraphQLString) },
+    severity: { type: GraphQLString },
+    description: { type: GraphQLString }
+  }
+});
+var constraintAppliesToType = new GraphQLObjectType({
+  name: "ConstraintAppliesTo",
+  fields: {
+    domain_ids: { type: new GraphQLList(GraphQLID) },
+    entity_ids: { type: new GraphQLList(GraphQLID) },
+    capability_ids: { type: new GraphQLList(GraphQLID) },
+    feature_ids: { type: new GraphQLList(GraphQLID) },
+    business_rule_ids: { type: new GraphQLList(GraphQLID) }
+  }
+});
+var constraintWorkaroundType = new GraphQLObjectType({
+  name: "ConstraintWorkaround",
+  fields: {
+    exists: { type: GraphQLString },
+    description: { type: GraphQLString }
+  }
+});
+var constraintRemovabilityType = new GraphQLObjectType({
+  name: "ConstraintRemovability",
+  fields: {
+    can_be_removed_by_refactor: { type: GraphQLString },
+    requires: { type: new GraphQLList(GraphQLString) },
+    risk: { type: GraphQLString }
+  }
+});
+var constraintType = new GraphQLObjectType({
+  name: "Constraint",
+  fields: () => ({
+    id: { type: GraphQLID },
+    name: { type: GraphQLString },
+    description: { type: GraphQLString },
+    constraint_type: { type: GraphQLString },
+    cause: { type: constraintCauseType },
+    impact: { type: constraintImpactType },
+    applies_to: { type: constraintAppliesToType },
+    workaround: { type: constraintWorkaroundType },
+    removability: { type: constraintRemovabilityType },
+    certainty: { type: GraphQLString },
+    confidence: { type: confidenceType }
+  })
+});
+var rationaleType = new GraphQLObjectType({
+  name: "Rationale",
+  fields: () => ({
+    id: { type: GraphQLID },
+    statement: { type: GraphQLString },
+    explains: { type: new GraphQLList(GraphQLID) },
+    certainty: { type: GraphQLString },
+    confidence: { type: confidenceType }
+  })
+});
+var questionType = new GraphQLObjectType({
+  name: "Question",
+  fields: () => ({
+    id: { type: GraphQLID },
+    question: { type: GraphQLString },
+    category: { type: GraphQLString },
+    reason: { type: GraphQLString },
+    impact: { type: GraphQLString },
+    related_ids: { type: new GraphQLList(GraphQLID) },
+    evidence_ids: { type: new GraphQLList(GraphQLID) },
+    priority: { type: GraphQLString },
+    status: { type: GraphQLString },
+    answer: { type: GraphQLString },
+    answered_by: { type: GraphQLString },
+    answered_at: { type: GraphQLString }
+  })
+});
+var conflictType = new GraphQLObjectType({
+  name: "Conflict",
+  fields: () => ({
+    id: { type: GraphQLID },
+    type: { type: GraphQLString },
+    description: { type: GraphQLString },
+    related_ids: { type: new GraphQLList(GraphQLID) },
+    evidence_ids: { type: new GraphQLList(GraphQLID) },
+    status: { type: GraphQLString },
+    questions: { type: new GraphQLList(GraphQLID) },
+    resolution: { type: GraphQLString },
+    resolved_by_evidence_id: { type: GraphQLID }
+  })
+});
+var domainType = new GraphQLObjectType({
+  name: "Domain",
+  fields: () => ({
+    id: { type: GraphQLID },
+    name: { type: GraphQLString },
+    purpose: { type: GraphQLString },
+    why_it_exists: { type: GraphQLString },
+    entity_ids: { type: new GraphQLList(GraphQLID) },
+    capability_ids: { type: new GraphQLList(GraphQLID) },
+    entities: {
+      type: new GraphQLList(entityType),
+      resolve: (domain, _args, context) => resolveByIds(context, "entities", domain.entity_ids)
+    },
+    capabilities: {
+      type: new GraphQLList(capabilityType),
+      resolve: (domain, _args, context) => resolveByIds(context, "capabilities", domain.capability_ids)
+    },
+    certainty: { type: GraphQLString },
+    confidence: { type: confidenceType }
+  })
+});
+var entityRelationshipType = new GraphQLObjectType({
+  name: "EntityRelationship",
+  fields: () => ({
+    id: { type: GraphQLID },
+    from_entity_id: { type: GraphQLID },
+    to_entity_id: { type: GraphQLID },
+    relationship_type: { type: GraphQLString },
+    description: { type: GraphQLString },
+    from_entity: {
+      type: entityType,
+      resolve: (relationship, _args, context) => resolveByIds(context, "entities", [relationship.from_entity_id])[0] ?? null
+    },
+    to_entity: {
+      type: entityType,
+      resolve: (relationship, _args, context) => resolveByIds(context, "entities", [relationship.to_entity_id])[0] ?? null
+    },
+    certainty: { type: GraphQLString },
+    confidence: { type: confidenceType }
+  })
+});
+var capabilityType = new GraphQLObjectType({
+  name: "Capability",
+  fields: () => ({
+    id: { type: GraphQLID },
+    name: { type: GraphQLString },
+    description: { type: GraphQLString },
+    why_it_exists: { type: GraphQLString },
+    domain_ids: { type: new GraphQLList(GraphQLID) },
+    entity_ids: { type: new GraphQLList(GraphQLID) },
+    parent_capability_ids: { type: new GraphQLList(GraphQLID) },
+    child_capability_ids: { type: new GraphQLList(GraphQLID) },
+    feature_ids: { type: new GraphQLList(GraphQLID) },
+    domains: {
+      type: new GraphQLList(domainType),
+      resolve: (capability, _args, context) => resolveByIds(context, "domains", capability.domain_ids)
+    },
+    entities: {
+      type: new GraphQLList(entityType),
+      resolve: (capability, _args, context) => resolveByIds(context, "entities", capability.entity_ids)
+    },
+    parent_capabilities: {
+      type: new GraphQLList(capabilityType),
+      resolve: (capability, _args, context) => resolveByIds(context, "capabilities", capability.parent_capability_ids)
+    },
+    child_capabilities: {
+      type: new GraphQLList(capabilityType),
+      resolve: (capability, _args, context) => resolveByIds(context, "capabilities", capability.child_capability_ids)
+    },
+    features: {
+      type: new GraphQLList(featureType),
+      resolve: (capability, _args, context) => resolveByIds(context, "features", capability.feature_ids)
+    },
+    certainty: { type: GraphQLString },
+    confidence: { type: confidenceType }
+  })
+});
+var featureType = new GraphQLObjectType({
+  name: "Feature",
+  fields: () => ({
+    id: { type: GraphQLID },
+    name: { type: GraphQLString },
+    description: { type: GraphQLString },
+    purpose: { type: GraphQLString },
+    why_it_exists: { type: GraphQLString },
+    domain_ids: { type: new GraphQLList(GraphQLID) },
+    capability_ids: { type: new GraphQLList(GraphQLID) },
+    entity_ids: { type: new GraphQLList(GraphQLID) },
+    rule_ids: { type: new GraphQLList(GraphQLID) },
+    constraint_ids: { type: new GraphQLList(GraphQLID) },
+    domains: {
+      type: new GraphQLList(domainType),
+      resolve: (feature, _args, context) => resolveByIds(context, "domains", feature.domain_ids)
+    },
+    capabilities: {
+      type: new GraphQLList(capabilityType),
+      resolve: (feature, _args, context) => resolveByIds(context, "capabilities", feature.capability_ids)
+    },
+    entities: {
+      type: new GraphQLList(entityType),
+      resolve: (feature, _args, context) => resolveByIds(context, "entities", feature.entity_ids)
+    },
+    business_rules: {
+      type: new GraphQLList(businessRuleType),
+      resolve: (feature, _args, context) => resolveByIds(context, "business_rules", feature.rule_ids)
+    },
+    constraints: {
+      type: new GraphQLList(constraintType),
+      resolve: (feature, _args, context) => resolveByIds(context, "constraints", feature.constraint_ids)
+    },
+    certainty: { type: GraphQLString },
+    confidence: { type: confidenceType }
+  })
+});
+function resolveCollection(store, collection) {
+  if (!store) {
+    return [];
+  }
+  return store[collection];
+}
+function resolveByIds(store, collection, ids) {
+  if (!store || !ids?.length) {
+    return [];
+  }
+  const typedCollection = store.byCollection[collection];
+  return ids.map((id) => typedCollection.get(id)).filter((item) => item !== void 0);
+}
+var queryType = new GraphQLObjectType({
+  name: "Query",
+  fields: () => ({
+    store_available: {
+      type: GraphQLBoolean,
+      resolve: (_source, _args, context) => Boolean(context)
+    },
+    domains: {
+      type: new GraphQLList(domainType),
+      resolve: (_source, _args, context) => resolveCollection(context, "domains")
+    },
+    domain: {
+      type: domainType,
+      args: {
+        id: { type: GraphQLID }
+      },
+      resolve: (_source, args, context) => context?.byCollection.domains.get(args.id) ?? null
+    },
+    entities: {
+      type: new GraphQLList(entityType),
+      resolve: (_source, _args, context) => resolveCollection(context, "entities")
+    },
+    entity: {
+      type: entityType,
+      args: {
+        id: { type: GraphQLID }
+      },
+      resolve: (_source, args, context) => context?.byCollection.entities.get(args.id) ?? null
+    },
+    relationships: {
+      type: new GraphQLList(entityRelationshipType),
+      resolve: (_source, _args, context) => resolveCollection(context, "relationships")
+    },
+    capabilities: {
+      type: new GraphQLList(capabilityType),
+      resolve: (_source, _args, context) => resolveCollection(context, "capabilities")
+    },
+    capability: {
+      type: capabilityType,
+      args: {
+        id: { type: GraphQLID }
+      },
+      resolve: (_source, args, context) => context?.byCollection.capabilities.get(args.id) ?? null
+    },
+    features: {
+      type: new GraphQLList(featureType),
+      resolve: (_source, _args, context) => resolveCollection(context, "features")
+    },
+    feature: {
+      type: featureType,
+      args: {
+        id: { type: GraphQLID }
+      },
+      resolve: (_source, args, context) => context?.byCollection.features.get(args.id) ?? null
+    },
+    business_rules: {
+      type: new GraphQLList(businessRuleType),
+      resolve: (_source, _args, context) => resolveCollection(context, "business_rules")
+    },
+    business_rule: {
+      type: businessRuleType,
+      args: {
+        id: { type: GraphQLID }
+      },
+      resolve: (_source, args, context) => context?.byCollection.business_rules.get(args.id) ?? null
+    },
+    constraints: {
+      type: new GraphQLList(constraintType),
+      resolve: (_source, _args, context) => resolveCollection(context, "constraints")
+    },
+    constraint: {
+      type: constraintType,
+      args: {
+        id: { type: GraphQLID }
+      },
+      resolve: (_source, args, context) => context?.byCollection.constraints.get(args.id) ?? null
+    },
+    rationales: {
+      type: new GraphQLList(rationaleType),
+      resolve: (_source, _args, context) => resolveCollection(context, "rationales")
+    },
+    rationale: {
+      type: rationaleType,
+      args: {
+        id: { type: GraphQLID }
+      },
+      resolve: (_source, args, context) => context?.byCollection.rationales.get(args.id) ?? null
+    },
+    evidence: {
+      type: new GraphQLList(evidenceType),
+      resolve: (_source, _args, context) => resolveCollection(context, "evidence")
+    },
+    question: {
+      type: questionType,
+      args: {
+        id: { type: GraphQLID }
+      },
+      resolve: (_source, args, context) => context?.byCollection.questions.get(args.id) ?? null
+    },
+    questions: {
+      type: new GraphQLList(questionType),
+      resolve: (_source, _args, context) => resolveCollection(context, "questions")
+    },
+    conflict: {
+      type: conflictType,
+      args: {
+        id: { type: GraphQLID }
+      },
+      resolve: (_source, args, context) => context?.byCollection.conflicts.get(args.id) ?? null
+    },
+    conflicts: {
+      type: new GraphQLList(conflictType),
+      resolve: (_source, _args, context) => resolveCollection(context, "conflicts")
+    }
+  })
+});
+var knowledgeGraphSchema = new GraphQLSchema({
+  query: queryType
+});
+async function executeKnowledgeQuery(store, query, variables, operationName) {
+  if (!store) {
+    return {
+      data: null,
+      errors: [
+        {
+          message: "Knowledge store is not loaded. Set EZ_KNOW_ROOT to the knowledge root to enable querying."
+        }
+      ]
+    };
+  }
+  return graphql({
+    schema: knowledgeGraphSchema,
+    source: query,
+    contextValue: store,
+    variableValues: variables,
+    operationName
+  });
+}
+function buildKnowledgeGraphQLText(result) {
+  return JSON.stringify({
+    data: result.data,
+    errors: result.errors?.map((error) => ({ message: error.message }))
+  });
+}
+
+// packages/core/src/knowledge/patch/apply.ts
+import { existsSync as existsSync3 } from "node:fs";
+import { mkdir as mkdir2, rm, unlink, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname } from "node:path";
+
+// packages/core/src/knowledge/patch/validation.ts
+import { readFile as readFile4, stat } from "node:fs/promises";
+import { join as join4 } from "node:path";
+async function buildSourceFingerprintInput(sourceFiles) {
+  const entries = await Promise.all(
+    sourceFiles.map(async (filePath) => {
+      const [fileStat, content] = await Promise.all([
+        stat(filePath),
+        readFile4(filePath, "utf8")
+      ]);
+      return {
+        path: filePath,
+        size: fileStat.size,
+        mtimeMs: fileStat.mtimeMs,
+        contentHash: sha256(content)
+      };
+    })
+  );
+  entries.sort((left, right) => left.path.localeCompare(right.path));
+  return entries;
+}
+function buildCanonicalPathForCollection(rootDir, domain, type) {
+  return join4(
+    rootDir,
+    domain,
+    KNOWLEDGE_EXTRACTION_TYPE_REGISTRY[type].storageFile
+  );
+}
+function buildAffectedFileList(knowledgeRoot, operations) {
+  const affected = /* @__PURE__ */ new Set();
+  for (const operation of operations) {
+    affected.add(
+      buildCanonicalPathForCollection(
+        knowledgeRoot,
+        operation.domain,
+        operation.type
+      )
+    );
+  }
+  return [...affected].sort((left, right) => left.localeCompare(right));
+}
+function buildCollectionRecordsForDomain(state, type, domain) {
+  const records = [...state.byCollection[type].values()].filter(
+    (record2) => inferDomainForRecord(record2) === domain
+  );
+  records.sort((left, right) => left.id.localeCompare(right.id));
+  return records;
+}
+async function computeValidationResult(knowledgeRoot, patchId, patch, operations) {
+  const effectiveBase = await loadEffectiveKnowledgeStoreFromRoot(
+    knowledgeRoot,
+    {
+      selectedPatchId: patchId,
+      includeSelectedPatch: false
+    }
+  );
+  const simulation = simulateKnowledgePatch(
+    effectiveBase.store,
+    operations,
+    patchId
+  );
+  const affectedFiles = buildAffectedFileList(knowledgeRoot, operations);
+  const diagnostics = [
+    ...effectiveBase.diagnostics,
+    ...simulation.diagnostics
+  ];
+  if (diagnostics.length > 0) {
+    return knowledgePatchValidationResultSchema.parse({
+      valid: false,
+      diagnostics,
+      operationCount: operations.length,
+      appliedOperationIds: simulation.appliedOperationIds,
+      affectedFiles
+    });
+  }
+  const sourceFingerprint = await buildSourceFingerprintInput(
+    effectiveBase.store.sourceFiles
+  );
+  const fingerprint = sha256(
+    JSON.stringify({
+      schemaVersion: KNOWLEDGE_PATCH_SCHEMA_VERSION,
+      patch: {
+        id: patch.id,
+        status: patch.status,
+        updatedAt: patch.updatedAt
+      },
+      operations,
+      sourceFingerprint
+    })
+  );
+  return knowledgePatchValidationResultSchema.parse({
+    valid: true,
+    fingerprint,
+    diagnostics,
+    operationCount: operations.length,
+    appliedOperationIds: simulation.appliedOperationIds,
+    affectedFiles
+  });
+}
+async function validateKnowledgePatch(envValue, patchId, cwd = process.cwd()) {
+  const knowledgeRoot = resolveKnowledgeRoot2(envValue, cwd);
+  const state = await readKnowledgePatch(envValue, patchId, cwd);
+  return computeValidationResult(
+    knowledgeRoot,
+    patchId,
+    state.patch,
+    state.operations
+  );
+}
+
+// packages/core/src/knowledge/patch/apply.ts
+async function writeCanonicalFilesFromSimulation(knowledgeRoot, operations, simulationState) {
+  const plannedWrites = /* @__PURE__ */ new Map();
+  for (const operation of operations) {
+    const filePath = buildCanonicalPathForCollection(
+      knowledgeRoot,
+      operation.domain,
+      operation.type
+    );
+    const records = buildCollectionRecordsForDomain(
+      simulationState,
+      operation.type,
+      operation.domain
+    );
+    if (operation.type === "domains") {
+      if (records.length === 0) {
+        if (existsSync3(filePath)) {
+          await unlink(filePath);
+        }
+        continue;
+      }
+      plannedWrites.set(filePath, `${JSON.stringify(records[0], null, 2)}
+`);
+      continue;
+    }
+    plannedWrites.set(filePath, `${JSON.stringify(records, null, 2)}
+`);
+  }
+  for (const filePath of plannedWrites.keys()) {
+    await mkdir2(dirname(filePath), { recursive: true });
+  }
+  for (const [filePath, content] of plannedWrites.entries()) {
+    await writeFile2(filePath, content, "utf8");
+  }
+}
+async function applyKnowledgePatch(envValue, input, cwd = process.cwd()) {
+  const parsedInput = knowledgePatchApplyToolInputSchema.parse(input);
+  const knowledgeRoot = resolveKnowledgeRoot2(envValue, cwd);
+  const patchDir = resolveKnowledgePatchDirectory(
+    envValue,
+    parsedInput.patchId,
+    cwd
+  );
+  const patchState = await loadPatchStateByDir(patchDir);
+  const validation = await computeValidationResult(
+    knowledgeRoot,
+    patchState.patch.id,
+    patchState.patch,
+    patchState.operations
+  );
+  const diagnostics = [...validation.diagnostics];
+  const pendingPatches = (await listKnowledgePatches(envValue, cwd)).filter(
+    (patch) => patch.status === "draft"
+  );
+  const firstPendingPatchId = pendingPatches[0]?.id;
+  if (firstPendingPatchId !== void 0 && firstPendingPatchId !== patchState.patch.id) {
+    diagnostics.push(
+      buildDiagnostic({
+        severity: "error",
+        code: "apply_out_of_order",
+        message: `Patch "${patchState.patch.id}" cannot be applied while earlier pending patch "${firstPendingPatchId}" still exists.`,
+        patchId: patchState.patch.id
+      })
+    );
+  }
+  if (!parsedInput.approval.approved) {
+    diagnostics.push(
+      buildDiagnostic({
+        severity: "error",
+        code: "approval_required",
+        message: "Patch apply requires explicit approval.",
+        patchId: patchState.patch.id
+      })
+    );
+  }
+  if (firstPendingPatchId !== void 0 && firstPendingPatchId !== patchState.patch.id || !parsedInput.approval.approved || !validation.valid || parsedInput.approval.validationFingerprint !== validation.fingerprint) {
+    if (validation.valid && parsedInput.approval.validationFingerprint !== validation.fingerprint) {
+      diagnostics.push(
+        buildDiagnostic({
+          severity: "error",
+          code: "stale_validation_fingerprint",
+          message: "Patch validation fingerprint is stale. Revalidate before apply.",
+          patchId: patchState.patch.id
+        })
+      );
+    }
+    return {
+      patchId: patchState.patch.id,
+      applied: false,
+      validation,
+      diagnostics,
+      deletedPatch: false
+    };
+  }
+  const store = await loadKnowledgeStoreFromRoot(knowledgeRoot);
+  const simulation = simulateKnowledgePatch(
+    store,
+    patchState.operations,
+    patchState.patch.id
+  );
+  if (simulation.diagnostics.length > 0) {
+    return {
+      patchId: patchState.patch.id,
+      applied: false,
+      validation: {
+        ...validation,
+        valid: false,
+        diagnostics: simulation.diagnostics
+      },
+      diagnostics: simulation.diagnostics,
+      deletedPatch: false
+    };
+  }
+  await writeCanonicalFilesFromSimulation(
+    knowledgeRoot,
+    patchState.operations,
+    simulation.state
+  );
+  try {
+    await loadKnowledgeStoreFromRoot(knowledgeRoot);
+  } catch (error) {
+    const reloadDiagnostics = error instanceof KnowledgeStoreLoadError ? error.diagnostics.map(
+      (diagnostic) => buildDiagnostic({
+        severity: "critical",
+        code: diagnostic.kind,
+        message: diagnostic.message,
+        path: diagnostic.path ? [diagnostic.path] : void 0,
+        targetId: diagnostic.id
+      })
+    ) : [
+      buildDiagnostic({
+        severity: "critical",
+        code: "reload_failed",
+        message: "Canonical knowledge store reload failed after apply.",
+        patchId: patchState.patch.id
+      })
+    ];
+    return {
+      patchId: patchState.patch.id,
+      applied: false,
+      validation,
+      diagnostics: reloadDiagnostics,
+      deletedPatch: false
+    };
+  }
+  await rm(patchDir, { recursive: true, force: true });
+  return {
+    patchId: patchState.patch.id,
+    applied: true,
+    validation,
+    diagnostics: [],
+    deletedPatch: true
+  };
+}
+
+// packages/core/src/knowledge/patch/scope-audit.ts
+import { readdir as readdir2 } from "node:fs/promises";
+import { isAbsolute as isAbsolute2, relative, resolve as resolve5, sep as sep2 } from "node:path";
+import { z as z6 } from "zod/v4";
+var compareScopeWithEvidenceInputSchema = z6.object({
+  patchId: z6.string().min(1),
+  rootFolder: z6.string().trim().min(1).optional()
+});
+var compareScopeWithEvidenceResultSchema = z6.object({
+  patchId: z6.string().min(1),
+  rootFolder: z6.string().min(1),
+  scopeFiles: z6.array(z6.string()),
+  coveredFiles: z6.array(z6.string()),
+  omittedFiles: z6.array(
+    z6.object({
+      path: z6.string(),
+      reason: z6.string()
+    })
+  ),
+  uncoveredFiles: z6.array(z6.string()),
+  outOfRootEvidenceFiles: z6.array(z6.string()),
+  message: z6.string()
+});
+function toPosixPath(value) {
+  return value.replaceAll(sep2, "/");
+}
+function normalizeAuditedRoot(rootFolder) {
+  return resolve5(rootFolder);
+}
+function isPathWithinRoot(rootFolder, filePath) {
+  const relativePath = toPosixPath(relative(rootFolder, filePath));
+  return Boolean(
+    relativePath && relativePath !== ".." && !relativePath.startsWith("../")
+  );
+}
+function normalizePathWithinRoot(rootFolder, filePath, outputRoot = rootFolder) {
+  let candidate;
+  if (isAbsolute2(filePath)) {
+    candidate = resolve5(filePath);
+  } else {
+    const repoRelativeCandidate = resolve5(outputRoot, filePath);
+    candidate = isPathWithinRoot(rootFolder, repoRelativeCandidate) ? repoRelativeCandidate : resolve5(rootFolder, filePath);
+  }
+  const relativePath = toPosixPath(relative(outputRoot, candidate));
+  if (!relativePath || relativePath === ".." || relativePath.startsWith("../")) {
+    return null;
+  }
+  return relativePath;
+}
+async function collectScopeFiles(currentDir, auditedRoot, patchStorageRoot, outputRoot) {
+  if (currentDir === patchStorageRoot) {
+    return [];
+  }
+  const entries = await readdir2(currentDir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const entryPath = resolve5(currentDir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(
+        ...await collectScopeFiles(
+          entryPath,
+          auditedRoot,
+          patchStorageRoot,
+          outputRoot
+        )
+      );
+      continue;
+    }
+    if (!entry.isFile()) {
+      continue;
+    }
+    const normalized = normalizePathWithinRoot(auditedRoot, entryPath, outputRoot);
+    if (normalized) {
+      files.push(normalized);
+    }
+  }
+  return files;
+}
+async function compareScopeWithEvidence(envValue, input, cwd = process.cwd()) {
+  const parsedInput = compareScopeWithEvidenceInputSchema.parse(input);
+  const patchState = await readKnowledgePatch(envValue, parsedInput.patchId, cwd);
+  const auditedRoot = normalizeAuditedRoot(
+    parsedInput.rootFolder ?? patchState.patch.rootFolder
+  );
+  const repositoryRoot = resolve5(cwd);
+  const effectiveState = await loadEffectiveKnowledgeStoreFromRoot(
+    resolveKnowledgeRoot2(envValue, cwd),
+    {
+      selectedPatchId: parsedInput.patchId
+    }
+  );
+  const effectivePatchIds = new Set(effectiveState.patchIds);
+  const coveredFiles = /* @__PURE__ */ new Set();
+  const outOfRootEvidenceFiles = /* @__PURE__ */ new Set();
+  for (const evidence of effectiveState.store.evidence) {
+    const provenance = effectiveState.provenance.get(evidence.id);
+    if (!provenance?.patchIds.some((patchId) => effectivePatchIds.has(patchId))) {
+      continue;
+    }
+    const sourcePath = evidence.location?.path;
+    if (!sourcePath) {
+      continue;
+    }
+    const normalized = normalizePathWithinRoot(
+      auditedRoot,
+      sourcePath,
+      repositoryRoot
+    );
+    if (normalized) {
+      coveredFiles.add(normalized);
+      continue;
+    }
+    outOfRootEvidenceFiles.add(sourcePath);
+  }
+  const omittedFiles = patchState.patch.omittedFiles.map((entry) => ({
+    path: entry.path,
+    reason: entry.reason
+  }));
+  const omittedFileSet = new Set(omittedFiles.map((entry) => entry.path));
+  const patchStorageRoot = resolve5(auditedRoot, KNOWLEDGE_PATCH_FOLDER_NAME);
+  const scopeFiles = (await collectScopeFiles(
+    auditedRoot,
+    auditedRoot,
+    patchStorageRoot,
+    repositoryRoot
+  )).sort((left, right) => left.localeCompare(right));
+  const uncoveredFiles = scopeFiles.filter(
+    (filePath) => !coveredFiles.has(filePath) && !omittedFileSet.has(filePath)
+  );
+  const sortedCoveredFiles = [...coveredFiles].sort(
+    (left, right) => left.localeCompare(right)
+  );
+  const sortedOutOfRootEvidenceFiles = [...outOfRootEvidenceFiles].sort(
+    (left, right) => left.localeCompare(right)
+  );
+  const message = uncoveredFiles.length > 0 ? `Recheck ${uncoveredFiles.length} uncovered file(s): add evidence-backed knowledge or mark them omitted with a reason.` : "Scope audit complete. No uncovered files remain.";
+  return compareScopeWithEvidenceResultSchema.parse({
+    patchId: parsedInput.patchId,
+    rootFolder: auditedRoot,
+    scopeFiles,
+    coveredFiles: sortedCoveredFiles,
+    omittedFiles,
+    uncoveredFiles,
+    outOfRootEvidenceFiles: sortedOutOfRootEvidenceFiles,
+    message
+  });
+}
+
+// packages/core/src/knowledge/patch/index.ts
+async function executeKnowledgePatchAction(envValue, input, cwd = process.cwd()) {
+  switch (input.action) {
+    case "create":
+      return createKnowledgePatch(envValue, input.patch, cwd);
+    case "list":
+      return listKnowledgePatches(envValue, cwd);
+    case "get":
+      return readKnowledgePatch(envValue, input.patchId, cwd);
+    case "add_operation":
+      return addKnowledgePatchOperation(
+        envValue,
+        input.patchId,
+        input.operation,
+        cwd
+      );
+    case "update_operation":
+      return updateKnowledgePatchOperation(
+        envValue,
+        input.patchId,
+        input.update,
+        cwd
+      );
+    case "update_metadata":
+      return updateKnowledgePatchMetadata(
+        envValue,
+        input.patchId,
+        input.metadata,
+        cwd
+      );
+    case "delete_operation":
+      return deleteKnowledgePatchOperation(
+        envValue,
+        input.patchId,
+        input.operationId,
+        cwd
+      );
+    case "validate":
+      return validateKnowledgePatch(envValue, input.patchId, cwd);
+    case "close":
+      return closeKnowledgePatch(envValue, input.patchId, cwd);
+  }
+}
+function buildKnowledgePatchToolText(result) {
+  return JSON.stringify(result, null, 2);
+}
+
+// packages/core/src/knowledge/schema-discovery.ts
+import {
+  isAbstractType,
+  isCompositeType,
+  isListType,
+  isNonNullType,
+  isObjectType,
+  isScalarType,
+  isUnionType
+} from "graphql";
+var KNOWLEDGE_SCHEMA_RESOURCE_URI = "knowledge-schema://schema";
+var KNOWLEDGE_SCHEMA_LOOKUP_URI = "knowledge-schema://lookup/{target}";
+function unwrapType(type) {
+  if (isNonNullType(type) || isListType(type)) {
+    return unwrapType(type.ofType);
+  }
+  if (isObjectType(type) || isScalarType(type) || isUnionType(type) || isAbstractType(type)) {
+    return { name: type.name, composite: type };
+  }
+  return { name: "Unknown", composite: type };
+}
+function describeType(type) {
+  if (isNonNullType(type)) {
+    return `${describeType(type.ofType)}!`;
+  }
+  if (isListType(type)) {
+    return `[${describeType(type.ofType)}]`;
+  }
+  if (isObjectType(type) || isScalarType(type) || isUnionType(type)) {
+    return type.name;
+  }
+  if (isAbstractType(type)) {
+    return type.name;
+  }
+  return "Unknown";
+}
+function formatDefaultValue(value) {
+  if (value === void 0 || value === null) {
+    return null;
+  }
+  return JSON.stringify(value) ?? String(value);
+}
+function summarizeField(field) {
+  const traversedType = unwrapType(field.type).composite;
+  const traversesTo = isCompositeType(traversedType) && !isScalarType(traversedType) ? traversedType.name : null;
+  return {
+    name: field.name,
+    type: describeType(field.type),
+    description: field.description ?? null,
+    arguments: field.args?.map((argument) => ({
+      name: argument.name,
+      type: describeType(argument.type),
+      description: argument.description ?? null,
+      defaultValue: formatDefaultValue(argument.defaultValue)
+    })) ?? [],
+    traversesTo
+  };
+}
+function summarizeObjectType(type) {
+  const fields = Object.values(type.getFields()).map(summarizeField);
+  return {
+    name: type.name,
+    description: type.description ?? null,
+    fields,
+    traversalFields: fields.filter((field) => field.traversesTo !== null).map((field) => field.name)
+  };
+}
+function getObjectTypes(schema) {
+  return Object.values(schema.getTypeMap()).filter((type) => isObjectType(type)).filter((type) => !type.name.startsWith("__")).filter((type) => type.name !== schema.getQueryType()?.name);
+}
+function buildKnowledgeSchemaDiscoveryDocument(schema) {
+  const queryType2 = schema.getQueryType();
+  if (!queryType2) {
+    throw new Error("Knowledge GraphQL schema has no root query type.");
+  }
+  return {
+    resource: {
+      uri: KNOWLEDGE_SCHEMA_RESOURCE_URI,
+      title: "Knowledge GraphQL Schema",
+      description: "Canonical discovery view of the runtime knowledge GraphQL schema."
+    },
+    source: {
+      kind: "runtime-schema",
+      queryType: queryType2.name
+    },
+    rootQuery: summarizeObjectType(queryType2),
+    objectTypes: getObjectTypes(schema).map(summarizeObjectType)
+  };
+}
+function getLookupMetadata(schema, target) {
+  const queryType2 = schema.getQueryType();
+  if (!queryType2) {
+    throw new Error("Knowledge GraphQL schema has no root query type.");
+  }
+  if (target === queryType2.name) {
+    return {
+      resource: {
+        uri: `knowledge-schema://lookup/${target}`,
+        title: `Knowledge schema lookup: ${target}`,
+        description: "Focused lookup of the root query fields and their arguments."
+      },
+      source: {
+        kind: "runtime-schema",
+        queryType: queryType2.name
+      },
+      lookup: {
+        target: queryType2.name,
+        kind: "root-query"
+      },
+      rootQuery: summarizeObjectType(queryType2)
+    };
+  }
+  const rootField = queryType2.getFields()[target];
+  if (rootField) {
+    return {
+      resource: {
+        uri: `knowledge-schema://lookup/${target}`,
+        title: `Knowledge schema lookup: ${target}`,
+        description: "Focused lookup of a single root query field and its arguments."
+      },
+      source: {
+        kind: "runtime-schema",
+        queryType: queryType2.name
+      },
+      lookup: {
+        target,
+        kind: "root-field"
+      },
+      field: summarizeField(rootField),
+      parentType: queryType2.name
+    };
+  }
+  const objectType = schema.getType(target);
+  if (objectType && isObjectType(objectType)) {
+    const typeSummary = summarizeObjectType(objectType);
+    const rootFields = Object.values(queryType2.getFields()).filter((field) => unwrapType(field.type).name === target).map((field) => field.name);
+    return {
+      resource: {
+        uri: `knowledge-schema://lookup/${target}`,
+        title: `Knowledge schema lookup: ${target}`,
+        description: "Focused lookup of a single GraphQL type and its nested traversal fields."
+      },
+      source: {
+        kind: "runtime-schema",
+        queryType: queryType2.name
+      },
+      lookup: {
+        target,
+        kind: "object-type"
+      },
+      type: typeSummary,
+      rootFields
+    };
+  }
+  throw new Error(
+    `Unknown schema lookup target "${target}". Use a root field name, a type name, or "Query".`
+  );
+}
+function buildKnowledgeSchemaLookupDocument(schema, target) {
+  return getLookupMetadata(schema, target);
+}
+function createKnowledgeSchemaResourceText(schema) {
+  return JSON.stringify(buildKnowledgeSchemaDiscoveryDocument(schema), null, 2);
+}
+function createKnowledgeSchemaLookupText(schema, target) {
+  return JSON.stringify(
+    buildKnowledgeSchemaLookupDocument(schema, target),
+    null,
+    2
+  );
+}
+function listKnowledgeSchemaTargets(schema) {
+  const queryType2 = schema.getQueryType();
+  if (!queryType2) {
+    throw new Error("Knowledge GraphQL schema has no root query type.");
+  }
+  const objectTypeNames = getObjectTypes(schema).map((type) => type.name);
+  const rootFieldNames = Object.keys(queryType2.getFields());
+  const targetNames = ["Query", ...rootFieldNames, ...objectTypeNames];
+  return Array.from(new Set(targetNames)).sort(
+    (left, right) => left.localeCompare(right)
+  );
+}
+
+// packages/mcp/src/resources/knowledge-extraction.ts
+import { ResourceTemplate } from "@modelcontextprotocol/server";
+function createJsonResourceContent(uri, text) {
+  return {
+    contents: [
+      {
+        uri,
+        mimeType: "application/json",
+        text
+      }
+    ]
+  };
+}
+function createMarkdownResourceContent(uri, text) {
+  return {
+    contents: [
+      {
+        uri,
+        mimeType: "text/markdown",
+        text
+      }
+    ]
+  };
+}
+function listExtractionTypeNames() {
+  return listKnowledgeExtractionResourceTypes().flatMap((definition) => [
+    definition.collection,
+    ...definition.aliases
+  ]);
+}
+function registerKnowledgeExtractionResources(server) {
+  server.registerResource(
+    "knowledge-extraction-types",
+    KNOWLEDGE_EXTRACTION_TYPES_RESOURCE_URI,
+    {
+      title: "Knowledge Extraction Types",
+      description: "Canonical registry of knowledge types supported by the extraction workflow.",
+      mimeType: "application/json"
+    },
+    async (uri) => createJsonResourceContent(
+      uri.href,
+      JSON.stringify(buildKnowledgeExtractionTypeIndexDocument(), null, 2)
+    )
+  );
+  server.registerResource(
+    "knowledge-extraction-schema",
+    new ResourceTemplate(KNOWLEDGE_EXTRACTION_SCHEMA_RESOURCE_URI, {
+      list: async () => ({
+        resources: listKnowledgeExtractionResourceTypes().map((definition) => ({
+          uri: `ez-know://extraction/schema/${definition.collection}`,
+          name: definition.collection,
+          title: `${definition.title} Extraction Schema`,
+          description: `Runtime schema discovery for ${definition.title.toLowerCase()}.`,
+          mimeType: "application/json"
+        }))
+      }),
+      complete: {
+        type: async (value) => listExtractionTypeNames().filter(
+          (name) => name.toLowerCase().startsWith(value.toLowerCase())
+        )
+      }
+    }),
+    {
+      title: "Knowledge Extraction Schema",
+      description: "Runtime JSON-schema discovery for a supported knowledge type.",
+      mimeType: "application/json"
+    },
+    async (_uri, variables) => {
+      const type = variables.type;
+      if (typeof type !== "string" || type.length === 0) {
+        throw new Error("Resource type is required.");
+      }
+      const document = buildKnowledgeExtractionSchemaDocument(type);
+      return createJsonResourceContent(
+        `ez-know://extraction/schema/${document.type.collection}`,
+        JSON.stringify(document, null, 2)
+      );
+    }
+  );
+  server.registerResource(
+    "knowledge-extraction-guide",
+    new ResourceTemplate(KNOWLEDGE_EXTRACTION_GUIDE_RESOURCE_URI, {
+      list: async () => ({
+        resources: listKnowledgeExtractionResourceTypes().map((definition) => ({
+          uri: `ez-know://extraction/guide/${definition.collection}`,
+          name: definition.collection,
+          title: `${definition.title} Extraction Guide`,
+          description: `Checked-in extraction guidance for ${definition.title.toLowerCase()}.`,
+          mimeType: "text/markdown"
+        }))
+      }),
+      complete: {
+        type: async (value) => listExtractionTypeNames().filter(
+          (name) => name.toLowerCase().startsWith(value.toLowerCase())
+        )
+      }
+    }),
+    {
+      title: "Knowledge Extraction Guide",
+      description: "Checked-in Markdown guidance for a supported knowledge type.",
+      mimeType: "text/markdown"
+    },
+    async (_uri, variables) => {
+      const type = variables.type;
+      if (typeof type !== "string" || type.length === 0) {
+        throw new Error("Resource type is required.");
+      }
+      const document = await buildKnowledgeExtractionGuideDocument(type);
+      return createMarkdownResourceContent(
+        `ez-know://extraction/guide/${document.type.collection}`,
+        document.markdown
+      );
+    }
+  );
+}
+
+// packages/mcp/src/tools/compare-scope-with-evidence.ts
+function registerCompareScopeWithEvidenceTool(server) {
+  server.registerTool(
+    "compare_scope_with_evidence",
+    {
+      title: "Compare Scope With Evidence",
+      description: "Compares a patch evidence footprint against the audited repository root and reports uncovered files that still need review.",
+      inputSchema: compareScopeWithEvidenceInputSchema
+    },
+    async (input) => {
+      const parsedInput = compareScopeWithEvidenceInputSchema.parse(input);
+      const result = await compareScopeWithEvidence(
+        process.env.EZ_KNOW_ROOT,
+        parsedInput
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: buildKnowledgePatchToolText(result)
+          }
+        ]
+      };
+    }
+  );
+}
+
+// packages/mcp/src/tools/knowledge-graph.ts
+import * as z7 from "zod/v4";
+function registerKnowledgeGraphTool(server, getStore) {
+  server.registerTool(
+    "knowledge_graph_query",
+    {
+      title: "Knowledge Graph Query",
+      description: "Executes a GraphQL query against the loaded knowledge store.",
+      inputSchema: z7.object({
+        query: z7.string(),
+        variables: z7.record(z7.string(), z7.unknown()).optional(),
+        operationName: z7.string().optional()
+      })
+    },
+    async ({ query, variables, operationName }) => {
+      const result = await executeKnowledgeQuery(
+        await getStore(),
+        query,
+        variables,
+        operationName
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: buildKnowledgeGraphQLText(result)
+          }
+        ]
+      };
+    }
+  );
+}
+
+// packages/mcp/src/tools/knowledge-patch-apply.ts
+function registerKnowledgePatchApplyTool(server) {
+  server.registerTool(
+    "knowledge_patch_apply",
+    {
+      title: "Knowledge Patch Apply",
+      description: "Applies a validated knowledge patch to canonical files after explicit approval.",
+      inputSchema: knowledgePatchApplyToolInputSchema
+    },
+    async (input) => {
+      const parsedInput = knowledgePatchApplyToolInputSchema.parse(input);
+      const result = await applyKnowledgePatch(
+        process.env.EZ_KNOW_ROOT,
+        parsedInput
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: buildKnowledgePatchToolText(result)
+          }
+        ]
+      };
+    }
+  );
+}
+
+// packages/mcp/src/tools/knowledge-patch.ts
+function registerKnowledgePatchTool(server) {
+  server.registerTool(
+    "knowledge_patch",
+    {
+      title: "Knowledge Patch",
+      description: "Manages draft knowledge patches without mutating canonical knowledge files.",
+      inputSchema: knowledgePatchToolInputSchema
+    },
+    async (input) => {
+      const parsedInput = knowledgePatchToolInputSchema.parse(input);
+      const result = await executeKnowledgePatchAction(
+        process.env.EZ_KNOW_ROOT,
+        parsedInput
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: buildKnowledgePatchToolText(result)
+          }
+        ]
+      };
+    }
+  );
+}
+
+// packages/mcp/src/resources/knowledge-schema.ts
+import { ResourceTemplate as ResourceTemplate2 } from "@modelcontextprotocol/server";
+function createJsonResourceContent2(uri, text) {
+  return {
+    contents: [
+      {
+        uri,
+        mimeType: "application/json",
+        text
+      }
+    ]
+  };
+}
+function registerKnowledgeSchemaResources(server) {
+  server.registerResource(
+    "knowledge-schema",
+    KNOWLEDGE_SCHEMA_RESOURCE_URI,
+    {
+      title: "Knowledge GraphQL Schema",
+      description: "Canonical runtime GraphQL schema discovery payload for the knowledge layer.",
+      mimeType: "application/json"
+    },
+    async (uri) => createJsonResourceContent2(
+      uri.href,
+      createKnowledgeSchemaResourceText(knowledgeGraphSchema)
+    )
+  );
+  server.registerResource(
+    "knowledge-schema-lookup",
+    new ResourceTemplate2(KNOWLEDGE_SCHEMA_LOOKUP_URI, {
+      list: async () => ({
+        resources: listKnowledgeSchemaTargets(knowledgeGraphSchema).map(
+          (target) => ({
+            uri: `knowledge-schema://lookup/${target}`,
+            name: target,
+            title: `Knowledge schema lookup: ${target}`,
+            description: target === "Query" ? "Focused lookup of the root query fields." : `Focused lookup of ${target}.`,
+            mimeType: "application/json"
+          })
+        )
+      }),
+      complete: {
+        target: async (value) => listKnowledgeSchemaTargets(knowledgeGraphSchema).filter(
+          (target) => target.toLowerCase().startsWith(value.toLowerCase())
+        )
+      }
+    }),
+    {
+      title: "Knowledge Schema Lookup",
+      description: "Focused runtime GraphQL schema lookup for a type name, root field, or Query.",
+      mimeType: "application/json"
+    },
+    async (_uri, variables) => {
+      const target = variables.target;
+      if (typeof target !== "string" || target.length === 0) {
+        throw new Error("Resource target is required.");
+      }
+      return createJsonResourceContent2(
+        `knowledge-schema://lookup/${target}`,
+        createKnowledgeSchemaLookupText(knowledgeGraphSchema, target)
+      );
+    }
+  );
+}
+
+// packages/mcp/src/run.ts
+async function startMcpServer() {
+  const server = new McpServer({
+    name: "ez-know",
+    version: "0.1.0"
+  });
+  registerKnowledgeSchemaResources(server);
+  registerKnowledgeExtractionResources(server);
+  registerKnowledgeGraphTool(server, async () => {
+    const effectiveState = await loadEffectiveKnowledgeStoreFromEnv(
+      process.env.EZ_KNOW_ROOT
+    );
+    return effectiveState?.store;
+  });
+  registerKnowledgePatchTool(server);
+  registerKnowledgePatchApplyTool(server);
+  registerCompareScopeWithEvidenceTool(server);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+// src/server.ts
+await startMcpServer();
+//# sourceMappingURL=server.js.map