@chrisdudek/yg 0.1.0 → 0.2.0

package/dist/bin.js

@@ -28,25 +28,33 @@ artifacts:
   responsibility.md:
     required: always
     description: "What this node is responsible for, and what it is not"
+    structural_context: true
   interface.md:
     required:
       when: has_incoming_relations
     description: "Public API \u2014 methods, parameters, return types, contracts"
     structural_context: true
+  logic.md:
+    required: never
+    description: "Algorithmic flow, control flow, branching logic, decision trees \u2014 the 'how' of execution"
   constraints.md:
     required: never
     description: "Validation rules, business rules, invariants"
+    structural_context: true
   errors.md:
     required:
       when: has_incoming_relations
-    description: "Error conditions, codes, recovery behavior"
+    description: "Failure modes, edge cases, error conditions, recovery behavior"
     structural_context: true
+  model.md:
+    required: never
+    description: "Data structures, schemas, entities, type definitions \u2014 the shape of data this node owns or manages"
   state.md:
     required: never
     description: "State machines, lifecycle, transitions"
   decisions.md:
     required: never
-    description: "Local design decisions and rationale"
+    description: "Local design decisions and rationale \u2014 choices specific to this node, not system-wide"
 
 knowledge_categories:
   - name: decisions
@@ -60,8 +68,8 @@ quality:
   min_artifact_length: 50
   max_direct_relations: 10
   context_budget:
-    warning: 5000
-    error: 10000
+    warning: 10000
+    error: 20000
   knowledge_staleness_days: 90
 `;
 
@@ -79,6 +87,16 @@ THIS PROMPT IS YOUR ENTIRE OPERATING MANUAL. Read it carefully. Follow it strict
 
 ---
 
+## 0. ATOMIC INVARIANT \u2014 OVERRIDES EVERYTHING
+
+**CODE \u2194 GRAPH ARE ONE.**
+- Code changed \u2192 graph artifacts MUST be updated IN THE SAME RESPONSE. No exceptions.
+- Graph changed \u2192 source files MUST be verified/updated IN THE SAME RESPONSE. No exceptions.
+- There is NO "code-only" response. There is NO "graph-only" response (unless explicitly a dry-run plan).
+- If you complete a response and one side is changed but the other is not, you have VIOLATED the core contract of Yggdrasil.
+
+---
+
 ## 1. CORE PRINCIPLES (NON-NEGOTIABLE)
 
 1. **Graph First, Always:** Before answering a question, modifying code, or planning a feature, you MUST consult the graph.
@@ -88,6 +106,20 @@ THIS PROMPT IS YOUR ENTIRE OPERATING MANUAL. Read it carefully. Follow it strict
 5. **Tools Read, You Write:** The \`yg\` CLI tools only read, validate, and manage metadata. YOU must create and edit graph directories, \`.yaml\` files, and \`.md\` artifacts manually.
 6. **English Only for Artifacts:** All graph artifact files (filenames from \`config.artifacts\`, in the same directory as \`node.yaml\`) MUST be written in English. Conversation can be in the user's language.
 7. **Never Touch Operational Metadata:** NEVER manually edit \`.yggdrasil/.drift-state\` or \`.yggdrasil/.journal.yaml\`.
+8. **Ask, Never Infer:** If graph and code diverge in a way with multiple valid resolutions, or if a required decision is ambiguous \u2014 STOP. State the ambiguity. List interpretations. Ask the user to decide. Never silently choose. Never patch without confirmation.
+
+---
+
+## 1.5 FAILURE STATES
+
+You have fundamentally broken Yggdrasil if you do any of the following:
+- \u274C You modified source code without updating graph artifacts in the SAME response.
+- \u274C You modified graph files without verifying/updating source code alignment in the SAME response.
+- \u274C You resolved a code\u2194graph inconsistency without asking the user first.
+- \u274C You created or edited a graph element without reading its schema in \`.yggdrasil/templates/\`.
+- \u274C You ran \`yg drift-sync\` before updating graph artifacts.
+- \u274C You ran \`yg drift-sync\` after a graph-only change without verifying source files.
+- \u274C You used Blackbox coverage for greenfield/new code.
 
 ---
 
@@ -96,15 +128,15 @@ THIS PROMPT IS YOUR ENTIRE OPERATING MANUAL. Read it carefully. Follow it strict
 You do not need explicit "session" commands. Follow these conversational triggers:
 
 ### A. Preflight (First message of the conversation)
-Always execute these commands before doing anything else:
+Always execute these commands before doing anything else. *(Exception: If the user's request is clearly read-only, like "explain this", run ONLY step 1).*
 1. \`yg journal-read\` -> If entries exist, consolidate them into the graph, then \`yg journal-archive\`.
 2. \`yg drift\` -> If divergence is detected, present states (\`ok\`, \`drift\`, \`missing\`, \`unmaterialized\`). Ask the user: Absorb (update graph) or Reject (re-materialize code from graph)?
 3. \`yg status\` -> Report graph health.
 4. \`yg validate\` -> If W008 stale-knowledge appears, update the knowledge artifacts to reflect current node state.
 
-### B. Wrap-up (User signals closing the topic)
-Triggered by phrases like: "ko\u0144czymy", "wrap up", "to tyle", "gotowe".
-**Note: The graph should ALREADY be up to date. Do not wait for wrap-up to update graph artifacts.**
+### B. Session Verification (Wrap-up)
+Triggered by phrases like: "we're done", "wrap up", "that's enough", "done".
+**Note: The graph should ALREADY be up to date. If the graph requires massive updates at this stage, YOU HAVE FAILED.**
 1. If iterative journal mode was used: consolidate notes to the graph, then \`yg journal-archive\`.
 2. \`yg drift\` -> Check if files changed manually during the conversation.
 3. \`yg validate\` -> Fix any structural errors.
@@ -112,64 +144,66 @@ Triggered by phrases like: "ko\u0144czymy", "wrap up", "to tyle", "gotowe".
 
 ---
 
-## 3. WORKFLOW: MODIFYING OR CREATING FILES
+## 3. WORKFLOW: MODIFYING OR CREATING FILES (Code-First)
 
 You are NOT ALLOWED to edit or create source code without establishing graph coverage first.
 
 **Step 1: Check coverage** -> Run \`yg owner --file <path>\`
 
 **Step 2: If Owner FOUND (The Execution Checklist)**
-Whenever you write or edit source code, you MUST output this exact checklist in your response to the user, and execute each step BEFORE finishing your turn. This forces you to remember the graph:
-
-- [x] 1. Read Specification (ran \`yg build-context\`)
-- [x] 2. Modify Source Code
-- [x] 3. Sync Graph Artifacts (manually edit the node's artifact files \u2014 filenames from \`config.artifacts\` \u2014 IMMEDIATELY to match new code behavior)
-- [x] 4. Baseline Hash (ran \`yg drift-sync\` ONLY AFTER updating the graph)
+Whenever you write or edit source code, you MUST output this exact checklist in your response to the user, and execute each step BEFORE finishing your turn:
 
-*If you do not print this checklist and check off step 3, you have failed the core directive of Yggdrasil.*
+- [ ] 1. Read Specification (ran \`yg build-context\`)
+- [ ] 2. Modify Source Code
+- [ ] 3. Sync Graph Artifacts (manually edit the node's artifact files IMMEDIATELY to match new code behavior)
+- [ ] 4. Baseline Hash (ran \`yg drift-sync\` ONLY AFTER updating the graph)
 
 **Step 3: If Owner NOT FOUND (Uncovered Area)**
-STOP. Do not modify the code. First determine: **Is this greenfield (empty or new code to be created)?**
-
-*   **If GREENFIELD (empty directory, new project, code not yet written):** Do NOT offer blackbox. Use Option 1 only \u2014 create proper nodes (reverse engineering or upfront design) before implementing. Blackbox is forbidden for new code.
-*   **If EXISTING CODE (legacy, third-party, shipped-but-unmapped):** Present the user with 3 options and wait for their decision:
-    *   **Option 1: Reverse Engineering:** Create/extend standard nodes to map the area fully before modifying.
-    *   **Option 2: Blackbox Coverage:** Create a \`blackbox: true\` node at a user-chosen granularity to establish ownership without deep semantic exploration.
-    *   **Option 3: Abort/Change Plan:** Do not touch the file.
+STOP. Do not modify the code. First determine: **Is this greenfield or existing code?**
 
+* **If GREENFIELD (empty directory, new project):** Do NOT offer blackbox. Create proper nodes (reverse engineering or upfront design) before implementing.
+* **If PARTIALLY MAPPED (file is unmapped, but lives inside a mapped module):** Stop and ask the user if this file should be added to the existing node or if a new node is required.
+* **If EXISTING CODE (legacy, third-party):** Present the user with 3 options and wait:
+  * **Option 1: Reverse Engineering:** Create/extend standard nodes to map the area fully before modifying.
+  * **Option 2: Blackbox Coverage:** Create a \`blackbox: true\` node to establish ownership without deep semantic exploration.
+  * **Option 3: Abort/Change Plan:** Do not touch the file.
 
 ---
 
-## 4. WORKFLOW: MODIFYING THE GRAPH & BLAST RADIUS
-
-When adding features or changing architecture, update the graph FIRST.
+## 4. WORKFLOW: MODIFYING THE GRAPH & BLAST RADIUS (Graph-First)
 
-**DO NOT DEFER GRAPH UPDATES:**
-*   **DO NOT wait for the user to confirm if a change is "final".** The graph must evolve continuously with your code edits.
-*   **Default Behavior:** If iterative journal mode is OFF, you MUST write structural and semantic changes directly to the graph files (\`node.yaml\`, artifacts or other files like aspects or flows, etc.) IMMEDIATELY. Suppress your innate safety bias to wait for permission.
+When adding features, changing architecture, or doing graph-first design:
 
 1. **Check Blast Radius:** Before modifying a node that others depend on, run \`yg impact --node <node_path> --simulate\`. Report the impact to the user.
 2. **Read Config & Templates:**
-    *   Check \`.yggdrasil/config.yaml\` for allowed \`node_types\` and \`tags\`.
-    *   **CRITICAL:** ALWAYS read the required schema files in \`.yggdrasil/templates/\` (e.g., \`node.yaml\`, \`service.yaml\`) to know the exact fields and structure before creating or editing any graph file.
+   * Check \`.yggdrasil/config.yaml\` for allowed \`node_types\` and \`tags\`.
+   * **CRITICAL:** ALWAYS read the schema in \`.yggdrasil/templates/\` for the element type (node.yaml, aspect.yaml, flow.yaml, knowledge.yaml) before creating or editing it.
 3. **Validate & Fix:** Run \`yg validate\`. You must fix all E-codes (Errors).
-4. **Token Economy & W-codes (Warnings):**
-    *   If you see \`W005 budget-warning\` or \`W006 budget-error\`, the context package is too large. You MUST consider splitting the node or reducing dependencies.
-    *   If you see \`W008 stale-knowledge\`, the semantic memory is outdated compared to the code. Update the knowledge artifacts.
-    *   **Smallest Viable Scope:** Prefer \`scope: nodes\` over \`scope: tags\`. Prefer tags over \`scope: global\`. Global scope costs token budget in EVERY context package.
+4. **Token Economy & W-codes:**
+   * W005/W006: Context package too large. Consider splitting the node.
+   * W008: Stale semantic memory. Update knowledge artifacts.
 
-**Journaling (Iterative Mode):**
-*   **Default:** Write changes directly to graph files immediately.
-*   **Opt-in:** ONLY if the user says "tryb iteracyjny" or "u\u017Cyj journala", use \`yg journal-add --note "..."\` to buffer intent during fast ping-pong changes.
+**Graph Modification Checklist**
+Whenever you change the graph structure or semantics, you MUST output and execute this exact checklist:
+
+- [ ] 1. Read schema from \`.yggdrasil/templates/\` (node.yaml, aspect.yaml, flow.yaml, or knowledge.yaml for the element type)
+- [ ] 2. Edit graph files (\`node.yaml\`, artifacts)
+- [ ] 3. Verify corresponding source files exist and their behavior matches updated artifacts
+- [ ] 4. Validate (ran \`yg validate\` \u2014 fix all Errors)
+- [ ] 5. Baseline Hash (ran \`yg drift-sync\` ONLY AFTER steps 2-3 are confirmed)
+
+**Journaling (Iterative Mode Scope):**
+* **Default:** Write changes directly to graph files immediately. Do not defer.
+* **Opt-in:** ONLY if the user says "use iterative mode" or "use journal". Once activated, it remains active for the ENTIRE conversation until wrap-up. Use \`yg journal-add --note "..."\` to buffer intent.
 
 ---
 
 ## 5. PATH CONVENTIONS (CRITICAL)
 
 To avoid broken references (\`E004\`, \`E005\`), use correct relative paths:
-*   **Node paths** (used in CLI, relations, flow nodes): Relative to \`.yggdrasil/model/\` (e.g., \`orders/order-service\`).
-*   **File paths** (used in mapping, \`yg owner\`): Relative to the repository root (e.g., \`src/modules/orders/order.service.ts\`).
-*   **Knowledge paths** (used in node explicit refs): Relative to \`.yggdrasil/knowledge/\` (e.g., \`decisions/001-event-sourcing\`).
+* **Node paths** (used in CLI, relations, flow nodes): Relative to \`.yggdrasil/model/\` (e.g., \`orders/order-service\`).
+* **File paths** (used in mapping, \`yg owner\`): Relative to the repository root (e.g., \`src/modules/orders/order.service.ts\`).
+* **Knowledge paths** (used in node explicit refs): Relative to \`.yggdrasil/knowledge/\` (e.g., \`decisions/001-event-sourcing\`).
 
 ---
 
@@ -177,35 +211,84 @@ To avoid broken references (\`E004\`, \`E005\`), use correct relative paths:
 
 The graph lives entirely under \`.yggdrasil/\`. You NEVER guess structure. You MUST ALWAYS read the corresponding schema reference in \`.yggdrasil/templates/\` before creating or editing any graph file.
 
-*   **\`.yggdrasil/config.yaml\`**: The ONLY config file. Defines \`node_types\`, \`tags\`, \`artifacts\`, \`knowledge_categories\`, and quality thresholds. Read this before any graph work.
-*   **\`.yggdrasil/templates/\`**: The SINGLE place for all templates and schemas.
-    *   Contains node-type templates (e.g., \`service.yaml\`, \`module.yaml\`) with suggested artifacts and guidance.
-    *   Contains schema references (\`node.yaml\`, \`aspect.yaml\`, \`flow.yaml\`, \`knowledge.yaml\`) showing exact file structures.
-*   **\`.yggdrasil/model/\`**: Node tree. Each node is a directory with \`node.yaml\` and artifact files (filenames from \`config.artifacts\`; required ones depend on config).
-*   **\`.yggdrasil/aspects/\`**: Cross-cutting rules. Directory contains \`aspect.yaml\` (binds via \`tag: <name>\`) and \`.md\` content.
-*   **\`.yggdrasil/flows/\`**: End-to-end processes. Directory contains \`flow.yaml\` (lists \`nodes: [paths]\` and \`knowledge: [paths]\`) and \`.md\` content.
-*   **\`.yggdrasil/knowledge/\`**: Repo-wide wisdom (\`decisions/\`, \`patterns/\`, \`invariants/\`). Directory contains \`knowledge.yaml\` and \`.md\` content.
+* **\`.yggdrasil/config.yaml\`**: Defines \`node_types\`, \`tags\`, \`artifacts\`, \`knowledge_categories\`.
+* **\`.yggdrasil/templates/\`**: Schemas for each graph layer \u2014 \`node.yaml\`, \`aspect.yaml\`, \`flow.yaml\`, \`knowledge.yaml\`.
+* **\`.yggdrasil/model/\`**: Node tree. Each node is a directory with \`node.yaml\` and artifact files.
+* **\`.yggdrasil/aspects/\`**: Cross-cutting rules. Directory contains \`aspect.yaml\` and \`.md\` content.
+* **\`.yggdrasil/flows/\`**: End-to-end processes. Directory contains \`flow.yaml\` and \`.md\` content.
+* **\`.yggdrasil/knowledge/\`**: Repo-wide wisdom. Directory contains \`knowledge.yaml\` and \`.md\` content.
 
 ---
 
-## 7. CLI TOOLS REFERENCE (\`yg\`)
+## 7. CONTEXT ASSEMBLY & KNOWLEDGE DECONSTRUCTION (HOW TO MAP FILES)
+
+Your ultimate goal when describing a file or node is **Context Reproducibility**. A future agent reading ONLY the output of \`yg build-context\` for this node must be able to perfectly reconstruct the source code's behavior, constraints, environment, and purpose.
+
+However, you must NOT dump all knowledge into a single file. Yggdrasil's context package is **multi-layered** and hierarchically assembled. When you map existing code or design new code, you must deconstruct the knowledge and place it at the correct abstraction layer so the engine can mechanically reassemble it.
+
+### CRITICAL RULE: CAPTURE INTENT, BUT NEVER INVENT IT
+The graph is not just a structural map; it is the semantic meaning of the system. Code explains "what" and "how". The graph MUST explain "WHY". 
+
+1. **ALWAYS Capture the User's "Why":** If the user explains the business reason, intent, or rationale behind a request (e.g., "We need to do X because Y"), you MUST permanently record this reasoning in the relevant graph artifacts (e.g., \`responsibility.md\`, \`constraints.md\`, \`decisions.md\`). Do not let the conversation context evaporate.
+2. **NEVER Invent the "Why":** Files that imply human judgment (like \`decisions.md\` or \`knowledge/invariants\`) must reflect ACTUAL human choices. 
+3. **NO Hallucinations:** You MUST NEVER infer or hallucinate a rationale, an architectural decision, or a business rule. 
+4. **Ask if Missing:** If the user requests a significant architectural or business logic change but does not provide the rationale, you MUST ask them "Why are we making this change?" before documenting the decision in the graph.
+
+When mapping a file, execute this mental routing:
+
+### Layer 1: Unit Identity (Local Node Artifacts)
+* **What goes here:** Things exclusively true for this specific node.
+* **Routing:** **DO NOT ASSUME FILE NAMES.** You MUST read \`.yggdrasil/config.yaml\` (the \`artifacts\` section) to see the exact allowed filenames for the current project and their requirement conditions (e.g., \`required: always\` vs \`when: has_incoming_relations\`). Write local node knowledge ONLY into these configured files next to \`node.yaml\`.
+* **logic.md:** Algorithmic flow, control flow, branching logic, decision trees \u2014 the "how" of execution. Create when the node has non-trivial logic that cannot be inferred from interface alone. Extract from source; do not invent.
+* **model.md:** Data structures, schemas, entities, type definitions \u2014 the shape of data this node owns. Create when the node manages non-trivial data structures. Extract from source types/interfaces; do not invent fields.
+
+**Subagents:** When mapping a node (reverse engineering or graph-first), if the source code contains non-trivial logic (branching, control flow, algorithms, workflows), create \`logic.md\` for that node. Document: control flow, branching conditions, decision trees, sequencing. Follow Layer 1 routing. Do not invent \u2014 extract only what is implemented.
+
+### Layer 2: Surroundings (Relations & Flows)
+* **What goes here:** How this node interacts with others. You must not duplicate external interfaces locally.
+* **Routing:**
+  * If it calls another module: Add an outgoing structural \`relation\` in \`node.yaml\`. (The engine will automatically fetch the target's structural-context artifacts: responsibility, interface, constraints, errors).
+  * If it participates in an end-to-end process: Do not explain the whole process locally. Ensure the node is listed in \`.yggdrasil/flows/<flow_name>/flow.yaml\`. The engine will attach the flow knowledge automatically.
+
+### Layer 3: Domain Context (Hierarchy)
+* **What goes here:** Business rules shared by a family of nodes.
+* **Routing:** Do not repeat module-wide rules in every child node. Place the child node directory *inside* a parent Module Node directory. Write the shared rules in the parent's configured artifacts. The engine inherently passes parent context to children.
+
+### Layer 4: Cross-Cutting Rules (Aspects)
+* **What goes here:** Horizontal requirements like logging, auth, rate-limiting, or specific frameworks.
+* **Routing:** Do NOT write generic rules like "This node must log all errors" in local artifacts. Instead, read \`config.yaml\` for available \`tags\`. Add the relevant tag (e.g., \`requires-audit\`) to \`node.yaml\`. The engine will automatically attach the aspect knowledge.
+
+### Layer 5: Long-Term Memory (Knowledge Elements)
+* **What goes here:** Global architectural decisions, design patterns, and systemic invariants.
+* **Routing:** Read \`config.yaml\` (the \`knowledge_categories\` section) to know what categories exist.
+  * If the file implements a standard pattern: Do not describe the pattern locally. Add a \`knowledge\` reference in \`node.yaml\` to the existing pattern.
+  * If the file reveals an undocumented global invariant or decision: Ask the user to confirm it. If confirmed, create it under \`.yggdrasil/knowledge/<category>/\` so all future nodes inherit it.
+
+**THE COMPLETENESS CHECK:**
+Before finishing a mapping, ask yourself: *"If I delete the source file and give another agent ONLY the output of \`yg build-context\`, can they recreate it perfectly based on the configured artifacts, AND will they understand EXACTLY WHY this code exists and why it was designed this way?"* 
+- If no -> You missed a local constraint, a relation, or you failed to capture the user's provided rationale.
+- If yes, but the local files are bloated -> You failed to deconstruct knowledge into Tags, Aspects, Flows, and Hierarchy. Fix the routing.
+
+---
+
+## 8. CLI TOOLS REFERENCE (\`yg\`)
 
 Always use these exact commands.
 
-*   \`yg owner --file <file_path>\` -> Find owning node.
-*   \`yg build-context --node <node_path>\` -> Assemble strict specification.
-*   \`yg tree [--root <node_path>] [--depth N]\` -> Print graph structure.
-*   \`yg deps --node <node_path> [--type structural|event|all]\` -> Show dependencies.
-*   \`yg impact --node <node_path> --simulate\` -> Simulate blast radius.
-*   \`yg status\` -> Graph health metrics.
-*   \`yg validate [--scope <node_path>|all]\` -> Compile/check graph. Run after EVERY graph edit.
-*   \`yg drift [--scope <node_path>|all]\` -> Check code vs graph baseline.
-*   \`yg drift-sync --node <node_path>\` -> Save current file hash as new baseline. Run ONLY after ensuring graph artifacts match the code.
+* \`yg owner --file <file_path>\` -> Find owning node.
+* \`yg build-context --node <node_path>\` -> Assemble strict specification.
+* \`yg tree [--root <node_path>] [--depth N]\` -> Print graph structure.
+* \`yg deps --node <node_path> [--type structural|event|all]\` -> Show dependencies.
+* \`yg impact --node <node_path> --simulate\` -> Simulate blast radius.
+* \`yg status\` -> Graph health metrics.
+* \`yg validate [--scope <node_path>|all]\` -> Compile/check graph. Run after EVERY graph edit.
+* \`yg drift [--scope <node_path>|all]\` -> Check code vs graph baseline.
+* \`yg drift-sync --node <node_path>\` -> Save current file hash as new baseline. Run ONLY after ensuring graph artifacts match the code.
 
 *(Iterative mode only)*
-*   \`yg journal-read\`
-*   \`yg journal-add --note "<content>" [--target <node_path>]\`
-*   \`yg journal-archive\`
+* \`yg journal-read\`
+* \`yg journal-add --note "<content>" [--target <node_path>]\`
+* \`yg journal-archive\`
 `;
 
 // src/templates/platform.ts
@@ -532,7 +615,7 @@ function registerInitCommand(program2) {
     process.stdout.write("  .yggdrasil/flows/\n");
     process.stdout.write("  .yggdrasil/knowledge/ (decisions, patterns, invariants)\n");
     process.stdout.write(
-      "  .yggdrasil/templates/ (module, service, library, node, aspect, flow, knowledge)\n"
+      "  .yggdrasil/templates/ (node, aspect, flow, knowledge)\n"
     );
     process.stdout.write(`  ${path2.relative(projectRoot, rulesPath)} (rules)
 
@@ -546,7 +629,7 @@ function registerInitCommand(program2) {
 
 // src/core/graph-loader.ts
 import { readdir as readdir3 } from "fs/promises";
-import path5 from "path";
+import path6 from "path";
 
 // src/io/config-parser.ts
 import { readFile as readFile3 } from "fs/promises";
@@ -554,7 +637,7 @@ import { parse as parseYaml } from "yaml";
 var DEFAULT_QUALITY = {
   min_artifact_length: 50,
   max_direct_relations: 10,
-  context_budget: { warning: 5e3, error: 1e4 },
+  context_budget: { warning: 1e4, error: 2e4 },
   knowledge_staleness_days: 90
 };
 async function parseConfig(filePath) {
@@ -869,30 +952,24 @@ function parseScope(raw, filePath) {
 
 // src/io/template-parser.ts
 import { readFile as readFile9 } from "fs/promises";
+import path4 from "path";
 import { parse as parseYaml6 } from "yaml";
-async function parseTemplate(filePath) {
+async function parseSchema(filePath) {
   const content = await readFile9(filePath, "utf-8");
-  const raw = parseYaml6(content);
-  if (!raw.node_type || typeof raw.node_type !== "string" || raw.node_type.trim() === "") {
-    throw new Error(`template at ${filePath}: missing or empty 'node_type'`);
-  }
-  const suggestedArtifacts = Array.isArray(raw.suggested_artifacts) ? raw.suggested_artifacts.filter((a) => typeof a === "string") : void 0;
-  return {
-    nodeType: raw.node_type.trim(),
-    suggestedArtifacts: suggestedArtifacts && suggestedArtifacts.length > 0 ? suggestedArtifacts : void 0,
-    guidance: typeof raw.guidance === "string" ? raw.guidance : void 0
-  };
+  parseYaml6(content);
+  const schemaType = path4.basename(filePath, path4.extname(filePath));
+  return { schemaType };
 }
 
 // src/utils/paths.ts
-import path4 from "path";
+import path5 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { stat as stat2 } from "fs/promises";
 async function findYggRoot(projectRoot) {
-  let current = path4.resolve(projectRoot);
-  const root = path4.parse(current).root;
+  let current = path5.resolve(projectRoot);
+  const root = path5.parse(current).root;
   while (true) {
-    const yggPath = path4.join(current, ".yggdrasil");
+    const yggPath = path5.join(current, ".yggdrasil");
     try {
       const st = await stat2(yggPath);
       if (!st.isDirectory()) {
@@ -906,7 +983,7 @@ async function findYggRoot(projectRoot) {
         if (current === root) {
           throw new Error(`No .yggdrasil/ directory found. Run 'yg init' first.`, { cause: err });
         }
-        current = path4.dirname(current);
+        current = path5.dirname(current);
         continue;
       }
       throw err;
@@ -922,18 +999,18 @@ function normalizeProjectRelativePath(projectRoot, rawPath) {
   if (normalizedInput.length === 0) {
     throw new Error("Path cannot be empty");
   }
-  const absolute = path4.resolve(projectRoot, normalizedInput);
-  const relative = path4.relative(projectRoot, absolute);
-  const isOutside = relative.startsWith("..") || path4.isAbsolute(relative);
+  const absolute = path5.resolve(projectRoot, normalizedInput);
+  const relative = path5.relative(projectRoot, absolute);
+  const isOutside = relative.startsWith("..") || path5.isAbsolute(relative);
   if (isOutside) {
     throw new Error(`Path is outside project root: ${rawPath}`);
   }
-  return relative.split(path4.sep).join("/");
+  return relative.split(path5.sep).join("/");
 }
 
 // src/core/graph-loader.ts
 function toModelPath(absolutePath, modelDir) {
-  return path5.relative(modelDir, absolutePath).split(path5.sep).join("/");
+  return path6.relative(modelDir, absolutePath).split(path6.sep).join("/");
 }
 var FALLBACK_CONFIG = {
   name: "",
@@ -949,14 +1026,14 @@ async function loadGraph(projectRoot, options = {}) {
   let configError;
   let config = FALLBACK_CONFIG;
   try {
-    config = await parseConfig(path5.join(yggRoot, "config.yaml"));
+    config = await parseConfig(path6.join(yggRoot, "config.yaml"));
   } catch (error) {
     if (!options.tolerateInvalidConfig) {
       throw error;
     }
     configError = error.message;
   }
-  const modelDir = path5.join(yggRoot, "model");
+  const modelDir = path6.join(yggRoot, "model");
   const nodes = /* @__PURE__ */ new Map();
   const nodeParseErrors = [];
   const artifactFilenames = Object.keys(config.artifacts ?? {});
@@ -970,13 +1047,13 @@ async function loadGraph(projectRoot, options = {}) {
     }
     throw err;
   }
-  const aspects = await loadAspects(path5.join(yggRoot, "aspects"));
-  const flows = await loadFlows(path5.join(yggRoot, "flows"));
+  const aspects = await loadAspects(path6.join(yggRoot, "aspects"));
+  const flows = await loadFlows(path6.join(yggRoot, "flows"));
   const knowledge = await loadKnowledge(
-    path5.join(yggRoot, "knowledge"),
+    path6.join(yggRoot, "knowledge"),
     config.knowledge_categories
   );
-  const templates = await loadTemplates(path5.join(yggRoot, "templates"));
+  const schemas = await loadSchemas(path6.join(yggRoot, "templates"));
   return {
     config,
     configError,
@@ -985,7 +1062,7 @@ async function loadGraph(projectRoot, options = {}) {
     aspects,
     flows,
     knowledge,
-    templates,
+    schemas,
     rootPath: yggRoot
   };
 }
@@ -999,7 +1076,7 @@ async function scanModelDirectory(dirPath, modelDir, parent, nodes, nodeParseErr
     const graphPath = toModelPath(dirPath, modelDir);
     let meta;
     try {
-      meta = await parseNodeYaml(path5.join(dirPath, "node.yaml"));
+      meta = await parseNodeYaml(path6.join(dirPath, "node.yaml"));
     } catch (err) {
       nodeParseErrors.push({
         nodePath: graphPath,
@@ -1023,7 +1100,7 @@ async function scanModelDirectory(dirPath, modelDir, parent, nodes, nodeParseErr
       if (!entry.isDirectory()) continue;
       if (entry.name.startsWith(".")) continue;
       await scanModelDirectory(
-        path5.join(dirPath, entry.name),
+        path6.join(dirPath, entry.name),
         modelDir,
         node,
         nodes,
@@ -1036,7 +1113,7 @@ async function scanModelDirectory(dirPath, modelDir, parent, nodes, nodeParseErr
       if (!entry.isDirectory()) continue;
       if (entry.name.startsWith(".")) continue;
       await scanModelDirectory(
-        path5.join(dirPath, entry.name),
+        path6.join(dirPath, entry.name),
         modelDir,
         null,
         nodes,
@@ -1052,8 +1129,8 @@ async function loadAspects(aspectsDir) {
     const aspects = [];
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const aspectYamlPath = path5.join(aspectsDir, entry.name, "aspect.yaml");
-      const aspect = await parseAspect(path5.join(aspectsDir, entry.name), aspectYamlPath);
+      const aspectYamlPath = path6.join(aspectsDir, entry.name, "aspect.yaml");
+      const aspect = await parseAspect(path6.join(aspectsDir, entry.name), aspectYamlPath);
       aspects.push(aspect);
     }
     return aspects;
@@ -1067,8 +1144,8 @@ async function loadFlows(flowsDir) {
     const flows = [];
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const flowYamlPath = path5.join(flowsDir, entry.name, "flow.yaml");
-      const flow = await parseFlow(path5.join(flowsDir, entry.name), flowYamlPath);
+      const flowYamlPath = path6.join(flowsDir, entry.name, "flow.yaml");
+      const flow = await parseFlow(path6.join(flowsDir, entry.name), flowYamlPath);
       flows.push(flow);
     }
     return flows;
@@ -1084,12 +1161,12 @@ async function loadKnowledge(knowledgeDir, categories) {
     for (const catEntry of catEntries) {
       if (!catEntry.isDirectory()) continue;
       if (!categorySet.has(catEntry.name)) continue;
-      const catPath = path5.join(knowledgeDir, catEntry.name);
+      const catPath = path6.join(knowledgeDir, catEntry.name);
       const itemEntries = await readdir3(catPath, { withFileTypes: true });
       for (const itemEntry of itemEntries) {
         if (!itemEntry.isDirectory()) continue;
-        const itemDir = path5.join(catPath, itemEntry.name);
-        const knowledgeYamlPath = path5.join(itemDir, "knowledge.yaml");
+        const itemDir = path6.join(catPath, itemEntry.name);
+        const knowledgeYamlPath = path6.join(itemDir, "knowledge.yaml");
         const relativePath = `${catEntry.name}/${itemEntry.name}`;
         const item = await parseKnowledge(itemDir, knowledgeYamlPath, catEntry.name, relativePath);
         items.push(item);
@@ -1099,17 +1176,17 @@ async function loadKnowledge(knowledgeDir, categories) {
   }
   return items;
 }
-async function loadTemplates(templatesDir) {
+async function loadSchemas(templatesDir) {
   try {
     const entries = await readdir3(templatesDir, { withFileTypes: true });
-    const templates = [];
+    const schemas = [];
     for (const entry of entries) {
       if (!entry.isFile()) continue;
       if (!entry.name.endsWith(".yaml") && !entry.name.endsWith(".yml")) continue;
-      const t = await parseTemplate(path5.join(templatesDir, entry.name));
-      templates.push(t);
+      const s = await parseSchema(path6.join(templatesDir, entry.name));
+      schemas.push(s);
     }
-    return templates;
+    return schemas;
   } catch {
     return [];
   }
@@ -1117,7 +1194,7 @@ async function loadTemplates(templatesDir) {
 
 // src/core/context-builder.ts
 import { readFile as readFile10 } from "fs/promises";
-import path6 from "path";
+import path7 from "path";
 
 // src/utils/tokens.ts
 function estimateTokens(text) {
@@ -1270,7 +1347,7 @@ ${a.content}`).join("\n\n");
 }
 async function buildOwnLayer(node, config, graphRootPath) {
   const parts = [];
-  const nodeYamlPath = path6.join(graphRootPath, "model", node.path, "node.yaml");
+  const nodeYamlPath = path7.join(graphRootPath, "model", node.path, "node.yaml");
   try {
     const nodeYamlContent = await readFile10(nodeYamlPath, "utf-8");
     parts.push(`### node.yaml
@@ -1387,13 +1464,13 @@ function collectAncestors(node) {
 
 // src/core/validator.ts
 import { readdir as readdir4 } from "fs/promises";
-import path8 from "path";
+import path9 from "path";
 
 // src/utils/git.ts
 import { execSync } from "child_process";
-import path7 from "path";
+import path8 from "path";
 function getLastCommitTimestamp(projectRoot, relativePath) {
-  const normalized = path7.normalize(relativePath).replace(/\\/g, "/");
+  const normalized = path8.normalize(relativePath).replace(/\\/g, "/");
   try {
     const out = execSync(`git log -1 --format=%ct -- "${normalized}"`, {
       cwd: projectRoot,
@@ -1441,8 +1518,8 @@ async function validate(graph, scope = "all") {
     issues.push(...await checkContextBudget(graph));
     issues.push(...checkHighFanOut(graph));
     issues.push(...await checkStaleKnowledge(graph));
-    issues.push(...checkTemplates(graph));
   }
+  issues.push(...checkSchemas(graph));
   issues.push(...checkRelationTargets(graph));
   issues.push(...checkNoCycles(graph));
   issues.push(...checkMappingOverlap(graph));
@@ -1815,7 +1892,7 @@ function checkScopeTagsDefined(graph) {
 async function checkUnknownKnowledgeCategories(graph) {
   const issues = [];
   const categorySet = new Set((graph.config.knowledge_categories ?? []).map((c) => c.name));
-  const knowledgeDir = path8.join(graph.rootPath, "knowledge");
+  const knowledgeDir = path9.join(graph.rootPath, "knowledge");
   const existingDirs = /* @__PURE__ */ new Set();
   try {
     const entries = await readdir4(knowledgeDir, { withFileTypes: true });
@@ -1946,7 +2023,7 @@ async function checkMissingPatternExamples(graph) {
   const issues = [];
   const hasPatterns = (graph.config.knowledge_categories ?? []).some((c) => c.name === "patterns");
   if (!hasPatterns) return issues;
-  const patternsDir = path8.join(graph.rootPath, "knowledge", "patterns");
+  const patternsDir = path9.join(graph.rootPath, "knowledge", "patterns");
   try {
     const entries = await readdir4(patternsDir, { withFileTypes: true });
     const exampleExtensions = /* @__PURE__ */ new Set([
@@ -1962,10 +2039,10 @@ async function checkMissingPatternExamples(graph) {
     ]);
     for (const e of entries) {
       if (!e.isDirectory()) continue;
-      const itemDir = path8.join(patternsDir, e.name);
+      const itemDir = path9.join(patternsDir, e.name);
       const itemEntries = await readdir4(itemDir, { withFileTypes: true });
       const hasExample = itemEntries.some(
-        (f) => f.isFile() && f.name !== "knowledge.yaml" && (f.name.startsWith("example") || exampleExtensions.has(path8.extname(f.name).toLowerCase()))
+        (f) => f.isFile() && f.name !== "knowledge.yaml" && (f.name.startsWith("example") || exampleExtensions.has(path9.extname(f.name).toLowerCase()))
       );
       if (!hasExample) {
         issues.push({
@@ -2016,8 +2093,8 @@ function getNodesInScope(k, graph) {
 async function checkStaleKnowledge(graph) {
   const issues = [];
   const stalenessDays = graph.config.quality?.knowledge_staleness_days ?? 90;
-  const projectRoot = path8.dirname(graph.rootPath);
-  const yggRel = path8.relative(projectRoot, graph.rootPath).replace(/\\/g, "/") || ".yggdrasil";
+  const projectRoot = path9.dirname(graph.rootPath);
+  const yggRel = path9.relative(projectRoot, graph.rootPath).replace(/\\/g, "/") || ".yggdrasil";
   for (const k of graph.knowledge) {
     const scopeNodes = getNodesInScope(k, graph);
     if (scopeNodes.length === 0) continue;
@@ -2096,51 +2173,29 @@ function checkUnpairedEvents(graph) {
   }
   return issues;
 }
-function checkTemplates(graph) {
+var REQUIRED_SCHEMAS = ["node", "aspect", "flow", "knowledge"];
+function checkSchemas(graph) {
   const issues = [];
-  const allowedTypes = new Set(graph.config.node_types ?? []);
-  const allowedArtifacts = new Set(Object.keys(graph.config.artifacts ?? {}));
-  const typeToTemplate = /* @__PURE__ */ new Map();
-  for (const template of graph.templates) {
-    if (!allowedTypes.has(template.nodeType)) {
-      issues.push({
-        severity: "error",
-        code: "E002",
-        rule: "unknown-node-type",
-        message: `Template for '${template.nodeType}' references node_type not in config.node_types (${[...allowedTypes].join(", ")})`
-      });
-    }
-    for (const artifact of template.suggestedArtifacts ?? []) {
-      if (!allowedArtifacts.has(artifact)) {
-        issues.push({
-          severity: "warning",
-          code: "W001",
-          rule: "missing-artifact",
-          message: `Template for '${template.nodeType}' suggests artifact '${artifact}' not defined in config.artifacts`
-        });
-      }
-    }
-    const existing = typeToTemplate.get(template.nodeType);
-    if (existing) {
+  const present = new Set(graph.schemas.map((s) => s.schemaType));
+  for (const required of REQUIRED_SCHEMAS) {
+    if (!present.has(required)) {
       issues.push({
-        severity: "error",
-        code: "E016",
-        rule: "duplicate-template",
-        message: `Multiple templates for node_type '${template.nodeType}'`
+        severity: "warning",
+        code: "W010",
+        rule: "missing-schema",
+        message: `Schema '${required}.yaml' missing from .yggdrasil/templates/`
       });
-    } else {
-      typeToTemplate.set(template.nodeType, template.nodeType);
     }
   }
   return issues;
 }
 async function checkDirectoriesHaveNodeYaml(graph) {
   const issues = [];
-  const modelDir = path8.join(graph.rootPath, "model");
+  const modelDir = path9.join(graph.rootPath, "model");
   async function scanDir(dirPath, segments) {
     const entries = await readdir4(dirPath, { withFileTypes: true });
     const hasNodeYaml = entries.some((e) => e.isFile() && e.name === "node.yaml");
-    const dirName = path8.basename(dirPath);
+    const dirName = path9.basename(dirPath);
     if (RESERVED_DIRS.has(dirName)) return;
     const hasContent = entries.some((e) => e.isFile()) || entries.some((e) => e.isDirectory());
     const graphPath = segments.join("/");
@@ -2157,7 +2212,7 @@ async function checkDirectoriesHaveNodeYaml(graph) {
       if (!entry.isDirectory()) continue;
       if (RESERVED_DIRS.has(entry.name)) continue;
       if (entry.name.startsWith(".")) continue;
-      await scanDir(path8.join(dirPath, entry.name), [...segments, entry.name]);
+      await scanDir(path9.join(dirPath, entry.name), [...segments, entry.name]);
     }
   }
   try {
@@ -2165,7 +2220,7 @@ async function checkDirectoriesHaveNodeYaml(graph) {
     for (const entry of rootEntries) {
       if (!entry.isDirectory()) continue;
       if (entry.name.startsWith(".")) continue;
-      await scanDir(path8.join(modelDir, entry.name), [entry.name]);
+      await scanDir(path9.join(modelDir, entry.name), [entry.name]);
     }
   } catch {
   }
@@ -2330,7 +2385,7 @@ import chalk2 from "chalk";
 // src/io/drift-state-store.ts
 import { readFile as readFile11, writeFile as writeFile3 } from "fs/promises";
 import { parse as parseYaml7, stringify as stringifyYaml } from "yaml";
-import path9 from "path";
+import path10 from "path";
 var DRIFT_STATE_FILE = ".drift-state";
 function getCanonicalHash(entry) {
   return typeof entry === "string" ? entry : entry.hash;
@@ -2339,7 +2394,7 @@ function getFileHashes(entry) {
   return typeof entry === "object" ? entry.files : void 0;
 }
 async function readDriftState(yggRoot) {
-  const filePath = path9.join(yggRoot, DRIFT_STATE_FILE);
+  const filePath = path10.join(yggRoot, DRIFT_STATE_FILE);
   try {
     const content = await readFile11(filePath, "utf-8");
     const raw = parseYaml7(content);
@@ -2360,14 +2415,14 @@ async function readDriftState(yggRoot) {
   }
 }
 async function writeDriftState(yggRoot, state) {
-  const filePath = path9.join(yggRoot, DRIFT_STATE_FILE);
+  const filePath = path10.join(yggRoot, DRIFT_STATE_FILE);
   const content = stringifyYaml(state);
   await writeFile3(filePath, content, "utf-8");
 }
 
 // src/utils/hash.ts
 import { readFile as readFile12, readdir as readdir5, stat as stat3 } from "fs/promises";
-import path10 from "path";
+import path11 from "path";
 import { createHash } from "crypto";
 import { createRequire } from "module";
 var require2 = createRequire(import.meta.url);
@@ -2377,7 +2432,7 @@ async function hashFile(filePath) {
   return createHash("sha256").update(content).digest("hex");
 }
 async function hashPath(targetPath, options = {}) {
-  const projectRoot = options.projectRoot ? path10.resolve(options.projectRoot) : void 0;
+  const projectRoot = options.projectRoot ? path11.resolve(options.projectRoot) : void 0;
   const gitignoreMatcher = await loadGitignoreMatcher(projectRoot);
   const targetStat = await stat3(targetPath);
   if (targetStat.isFile()) {
@@ -2400,7 +2455,7 @@ async function collectDirectoryFileHashes(directoryPath, rootDirectoryPath, opti
   const entries = await readdir5(directoryPath, { withFileTypes: true });
   const result = [];
   for (const entry of entries) {
-    const absoluteChildPath = path10.join(directoryPath, entry.name);
+    const absoluteChildPath = path11.join(directoryPath, entry.name);
     if (isIgnoredPath(absoluteChildPath, options.projectRoot, options.gitignoreMatcher)) {
       continue;
     }
@@ -2412,7 +2467,7 @@ async function collectDirectoryFileHashes(directoryPath, rootDirectoryPath, opti
       );
       for (const nestedEntry of nested) {
         result.push({
-          path: path10.relative(rootDirectoryPath, path10.join(absoluteChildPath, nestedEntry.path)),
+          path: path11.relative(rootDirectoryPath, path11.join(absoluteChildPath, nestedEntry.path)),
           hash: nestedEntry.hash
         });
       }
@@ -2422,7 +2477,7 @@ async function collectDirectoryFileHashes(directoryPath, rootDirectoryPath, opti
       continue;
     }
     result.push({
-      path: path10.relative(rootDirectoryPath, absoluteChildPath),
+      path: path11.relative(rootDirectoryPath, absoluteChildPath),
       hash: await hashFile(absoluteChildPath)
     });
   }
@@ -2433,7 +2488,7 @@ async function loadGitignoreMatcher(projectRoot) {
     return void 0;
   }
   try {
-    const gitignorePath = path10.join(projectRoot, ".gitignore");
+    const gitignorePath = path11.join(projectRoot, ".gitignore");
     const gitignoreContent = await readFile12(gitignorePath, "utf-8");
     const matcher = ignoreFactory();
     matcher.add(gitignoreContent);
@@ -2446,7 +2501,7 @@ function isIgnoredPath(candidatePath, projectRoot, matcher) {
   if (!projectRoot || !matcher) {
     return false;
   }
-  const relativePath = path10.relative(projectRoot, candidatePath);
+  const relativePath = path11.relative(projectRoot, candidatePath);
   if (relativePath === "" || relativePath.startsWith("..")) {
     return false;
   }
@@ -2456,13 +2511,13 @@ function hashString(content) {
   return createHash("sha256").update(content).digest("hex");
 }
 async function perFileHashes(projectRoot, mapping) {
-  const root = path10.resolve(projectRoot);
+  const root = path11.resolve(projectRoot);
   const paths = mapping.paths ?? [];
   if (paths.length === 0) return [];
   const result = [];
   const gitignoreMatcher = await loadGitignoreMatcher(root);
   for (const p of paths) {
-    const absPath = path10.join(root, p);
+    const absPath = path11.join(root, p);
     const st = await stat3(absPath);
     if (st.isFile()) {
       result.push({ path: p, hash: await hashFile(absPath) });
@@ -2473,7 +2528,7 @@ async function perFileHashes(projectRoot, mapping) {
       });
       for (const h of hashes) {
         result.push({
-          path: path10.join(p, h.path).split(path10.sep).join("/"),
+          path: path11.join(p, h.path).split(path11.sep).join("/"),
           hash: h.hash
         });
       }
@@ -2482,12 +2537,12 @@ async function perFileHashes(projectRoot, mapping) {
   return result;
 }
 async function hashForMapping(projectRoot, mapping) {
-  const root = path10.resolve(projectRoot);
+  const root = path11.resolve(projectRoot);
   const paths = mapping.paths ?? [];
   if (paths.length === 0) throw new Error("Invalid mapping for hash: no paths");
   const pairs = [];
   for (const p of paths) {
-    const absPath = path10.join(root, p);
+    const absPath = path11.join(root, p);
     const st = await stat3(absPath);
     if (st.isFile()) {
       pairs.push({ path: p, hash: await hashFile(absPath) });
@@ -2502,9 +2557,9 @@ async function hashForMapping(projectRoot, mapping) {
 
 // src/core/drift-detector.ts
 import { access } from "fs/promises";
-import path11 from "path";
+import path12 from "path";
 async function detectDrift(graph, filterNodePath) {
-  const projectRoot = path11.dirname(graph.rootPath);
+  const projectRoot = path12.dirname(graph.rootPath);
   const driftState = await readDriftState(graph.rootPath);
   const entries = [];
   for (const [nodePath, node] of graph.nodes) {
@@ -2578,7 +2633,7 @@ async function diagnoseChangedFiles(projectRoot, mapping, storedFileHashes) {
 }
 async function allPathsMissing(projectRoot, mappingPaths) {
   for (const mp of mappingPaths) {
-    const absPath = path11.join(projectRoot, mp);
+    const absPath = path12.join(projectRoot, mp);
     try {
       await access(absPath);
       return false;
@@ -2588,7 +2643,7 @@ async function allPathsMissing(projectRoot, mappingPaths) {
   return true;
 }
 async function syncDriftState(graph, nodePath) {
-  const projectRoot = path11.dirname(graph.rootPath);
+  const projectRoot = path12.dirname(graph.rootPath);
   const node = graph.nodes.get(nodePath);
   if (!node) throw new Error(`Node not found: ${nodePath}`);
   const mapping = node.meta.mapping;
@@ -2760,10 +2815,10 @@ function registerTreeCommand(program2) {
       let roots;
       let showProjectName;
       if (options.root?.trim()) {
-        const path15 = options.root.trim().replace(/\/$/, "");
-        const node = graph.nodes.get(path15);
+        const path16 = options.root.trim().replace(/\/$/, "");
+        const node = graph.nodes.get(path16);
         if (!node) {
-          process.stderr.write(`Error: path '${path15}' not found
+          process.stderr.write(`Error: path '${path16}' not found
 `);
           process.exit(1);
         }
@@ -2851,7 +2906,7 @@ function registerOwnerCommand(program2) {
 
 // src/core/dependency-resolver.ts
 import { execSync as execSync2 } from "child_process";
-import path12 from "path";
+import path13 from "path";
 var STRUCTURAL_RELATION_TYPES2 = /* @__PURE__ */ new Set(["uses", "calls", "extends", "implements"]);
 var EVENT_RELATION_TYPES2 = /* @__PURE__ */ new Set(["emits", "listens"]);
 function filterRelationType(relType, filter) {
@@ -2928,7 +2983,7 @@ function registerDepsCommand(program2) {
 // src/core/graph-from-git.ts
 import { mkdtemp, rm } from "fs/promises";
 import { tmpdir } from "os";
-import path13 from "path";
+import path14 from "path";
 import { execSync as execSync3 } from "child_process";
 async function loadGraphFromRef(projectRoot, ref = "HEAD") {
   const yggPath = ".yggdrasil";
@@ -2939,8 +2994,8 @@ async function loadGraphFromRef(projectRoot, ref = "HEAD") {
     return null;
   }
   try {
-    tmpDir = await mkdtemp(path13.join(tmpdir(), "ygg-git-"));
-    const archivePath = path13.join(tmpDir, "archive.tar");
+    tmpDir = await mkdtemp(path14.join(tmpdir(), "ygg-git-"));
+    const archivePath = path14.join(tmpDir, "archive.tar");
     execSync3(`git archive ${ref} ${yggPath} -o "${archivePath}"`, {
       cwd: projectRoot,
       stdio: "pipe"
@@ -3010,14 +3065,14 @@ function buildTransitiveChains(targetNode, direct, transitive, reverse) {
   }
   const chains = [];
   for (const node of transitiveOnly) {
-    const path15 = [];
+    const path16 = [];
     let current = node;
     while (current) {
-      path15.unshift(current);
+      path16.unshift(current);
       current = parent.get(current);
     }
-    if (path15.length >= 2) {
-      chains.push(path15.map((p) => `<- ${p}`).join(" "));
+    if (path16.length >= 2) {
+      chains.push(path16.map((p) => `<- ${p}`).join(" "));
     }
   }
   return chains.sort();
@@ -3069,7 +3124,7 @@ function registerImpactCommand(program2) {
           }
         }
       }
-      const budget = graph.config.quality?.context_budget ?? { warning: 5e3, error: 1e4 };
+      const budget = graph.config.quality?.context_budget ?? { warning: 1e4, error: 2e4 };
       process.stdout.write(`Impact of changes in ${nodePath}:
 
 `);
@@ -3160,11 +3215,11 @@ ${changedLine}${budgetLine}${driftLine}
 // src/io/journal-store.ts
 import { readFile as readFile13, writeFile as writeFile4, mkdir as mkdir3, rename, access as access2 } from "fs/promises";
 import { parse as parseYaml8, stringify as stringifyYaml2 } from "yaml";
-import path14 from "path";
+import path15 from "path";
 var JOURNAL_FILE = ".journal.yaml";
 var ARCHIVE_DIR = "journals-archive";
 async function readJournal(yggRoot) {
-  const filePath = path14.join(yggRoot, JOURNAL_FILE);
+  const filePath = path15.join(yggRoot, JOURNAL_FILE);
   try {
     const content = await readFile13(filePath, "utf-8");
     const raw = parseYaml8(content);
@@ -3179,13 +3234,13 @@ async function appendJournalEntry(yggRoot, note, target) {
   const at = (/* @__PURE__ */ new Date()).toISOString();
   const entry = target ? { at, target, note } : { at, note };
   entries.push(entry);
-  const filePath = path14.join(yggRoot, JOURNAL_FILE);
+  const filePath = path15.join(yggRoot, JOURNAL_FILE);
   const content = stringifyYaml2({ entries });
   await writeFile4(filePath, content, "utf-8");
   return entry;
 }
 async function archiveJournal(yggRoot) {
-  const journalPath = path14.join(yggRoot, JOURNAL_FILE);
+  const journalPath = path15.join(yggRoot, JOURNAL_FILE);
   try {
     await access2(journalPath);
   } catch {
@@ -3193,12 +3248,12 @@ async function archiveJournal(yggRoot) {
   }
   const entries = await readJournal(yggRoot);
   if (entries.length === 0) return null;
-  const archiveDir = path14.join(yggRoot, ARCHIVE_DIR);
+  const archiveDir = path15.join(yggRoot, ARCHIVE_DIR);
   await mkdir3(archiveDir, { recursive: true });
   const now = /* @__PURE__ */ new Date();
   const timestamp = `${now.getUTCFullYear()}${String(now.getUTCMonth() + 1).padStart(2, "0")}${String(now.getUTCDate()).padStart(2, "0")}-${String(now.getUTCHours()).padStart(2, "0")}${String(now.getUTCMinutes()).padStart(2, "0")}${String(now.getUTCSeconds()).padStart(2, "0")}`;
   const archiveName = `.journal.${timestamp}.yaml`;
-  const archivePath = path14.join(archiveDir, archiveName);
+  const archivePath = path15.join(archiveDir, archiveName);
   await rename(journalPath, archivePath);
   return { archiveName, entryCount: entries.length };
 }