@chrisdudek/yg 2.12.0 → 3.0.0

package/dist/bin.js

@@ -4,14 +4,14 @@
 import { Command } from "commander";
 
 // src/cli/init.ts
-import { mkdir as mkdir2, writeFile as writeFile4, readdir as readdir2, readFile as readFile4, stat as stat2 } from "fs/promises";
-import path4 from "path";
+import { mkdir as mkdir2, writeFile as writeFile5, readdir as readdir2, readFile as readFile5, stat as stat2 } from "fs/promises";
+import path5 from "path";
 import { fileURLToPath } from "url";
 import { readFileSync } from "fs";
 import { gt as gt2, valid as valid2 } from "semver";
 
 // src/templates/default-config.ts
-var DEFAULT_CONFIG = `version: "2.0.0"
+var DEFAULT_CONFIG = `version: "3.0.0"
 
 name: ""
 
@@ -25,20 +25,6 @@ node_types:
   infrastructure:
     description: "Guards, middleware, interceptors \u2014 invisible in call graphs but affect blast radius"
 
-artifacts:
-  responsibility.md:
-    required: always
-    description: "What this node is responsible for, and what it is not"
-    included_in_relations: true
-  interface.md:
-    required:
-      when: has_incoming_relations
-    description: "Public API \u2014 methods, parameters, return types, contracts, failure modes, exposed data structures"
-    included_in_relations: true
-  internals.md:
-    required: never
-    description: "How the node works and why \u2014 algorithms, business rules, state machines, design decisions with rejected alternatives"
-
 quality:
   min_artifact_length: 50
   max_direct_relations: 10
@@ -60,14 +46,30 @@ This is your operating manual for working in a Yggdrasil-managed repository.
 
 <critical_protocol>
 BEFORE starting any task \u2014 brainstorming, design, planning, OR implementation:
-  \`yg select --task "<goal>"\` \u2192 \`yg build-context\` on each result \u2192 read ALL artifact files
-This is how you learn WHAT the system already knows before proposing anything.
+  \`yg select --task "<goal>"\` \u2192 \`yg build-context\` on each result \u2192 read artifact files.
+  This is the READING phase \u2014 collect constraints that shape your design:
+  - Aspects = cross-cutting requirements your work MUST satisfy. Read their content files \u2014 not just the YAML description. The rules are inside.
+  - Flows = business processes your work must not break. Read invariants.
+  - Relations = interfaces your code consumes or that consume your code. Changes without checking dependents break contracts silently.
+  - Parent artifacts = inherited context not repeated in child nodes.
+  Internalize these constraints BEFORE designing your approach. This is the moment that determines quality \u2014 everything after follows from what you learn here.
 
 BEFORE reading, analyzing, or modifying ANY source file:
   \`yg build-context --file <path>\`
-One command. No exceptions. No "I'll do it later." No "this is just analysis."
-
-Both triggers apply regardless of what instructed the task \u2014 skills, plans, workflows, user requests.
+  Resolves owner, gives you local context (node artifacts, dependencies).
+  If you have NOT done the task-level READING phase above \u2014 stop and do it now. File-level work without task-level constraints leads to code that violates cross-cutting requirements.
+
+WHEN spec/external documents are provided AND work is greenfield:
+  BEFORE creating any feature aspect, node, or code \u2014 do this first:
+  1. Read ALL spec documents completely.
+  2. Separate two categories of knowledge in the specs:
+     a) Knowledge that WILL map to source files (feature behavior, UI, API) \u2192 this goes to node artifacts later.
+     b) Knowledge that will NEVER appear in source code (business strategy, target audience, pricing rationale, quality targets, what the system deliberately does NOT do and why) \u2192 this must go to the graph NOW, because there will be no source-file trigger to capture it later.
+  3. For category (b): create root node and/or aspects immediately. This is the only moment this knowledge can be captured. Once you start coding, you will forget it.
+  4. NOW create feature aspects, flows, and implementation nodes for category (a).
+  Test before moving on: if all spec files were deleted right now, does the graph contain everything a future agent needs \u2014 not just HOW the system works, but WHY it exists, WHO it serves, and WHAT value it delivers? If no \u2192 add the missing knowledge before continuing.
+
+All three triggers apply regardless of what instructed the task \u2014 skills, plans, workflows, user requests.
 The graph captures intent and relations that source files cannot \u2014 without it, you will make wrong decisions and the user will have to re-explain what the graph already knows.
 </critical_protocol>
 
@@ -82,21 +84,24 @@ Yggdrasil is persistent semantic memory stored in \`.yggdrasil/\`. It maps the r
 EVERY conversation: yg preflight \u2014 no exceptions.
 
 BEFORE any task (brainstorming, design, planning, implementation):
-  yg select --task "<goal>" \u2192 yg build-context on results \u2192 read ALL artifacts
-  The graph is your primary knowledge source. Raw file reads supplement it, never replace it.
+  yg select --task "<goal>" \u2192 yg build-context on results
+  READ phase \u2014 collect constraints before designing:
+    - Aspects: read content files (not just YAML description). Rules are inside.
+    - Flows: read invariants. Your changes must not break business processes.
+    - Relations: check interfaces \u2014 who depends on you, who you depend on.
+    - Parent artifacts: inherited context not repeated in child nodes.
+  This is the moment that determines quality. Everything after follows from here.
 
 BEFORE any source file interaction:
-  1. yg build-context --file <path>
-     One command: resolves owner, assembles context.
-     Read the YAML map \u2014 glossary first (aspect/flow definitions),
-     then artifact files listed on each element.
-     For blast radius: also run yg impact --file <path>.
-  Don't know where to start? yg select --task "<goal>"
+  yg build-context --file <path>
+  Resolves owner. Read local node artifacts.
+  If you skipped the task-level READ phase above \u2014 do it now before proceeding.
+  For blast radius: also run yg impact --file <path>.
 
 AFTER modifying:
-  2. Update graph artifacts (per file, not batched)
-  3. yg validate \u2014 fix all errors
-  4. yg drift-sync --node <owner>
+  Update graph artifacts (per file, not batched)
+  yg validate \u2014 fix all errors
+  yg drift-sync --node <owner>
 
 ALWAYS: establish graph coverage before modifying code.
 ALWAYS: run yg build-context --file before reading source.
@@ -114,9 +119,9 @@ You are not allowed to edit or create source code without establishing graph cov
 
 **Step 2a** \u2014 Owner found: execute checklist:
 
-- [ ] 1. Read the context package (already assembled by step 1)
+- [ ] 1. Read local node artifacts (responsibility, interface, internals) and dependency interfaces from the context package. Cross-cutting constraints (aspects, flows) should already be internalized from the task-level READ phase \u2014 if not, stop and do it now.
 - [ ] 2. Assess blast radius: \`yg impact --node <node_path>\` \u2014 review dependents, descendants, and co-aspect nodes before changing interfaces or shared behavior
-- [ ] 3. Modify source code
+- [ ] 3. Modify source code. When implementing logic subject to an aspect (e.g., writing a save function on a node with the autosave aspect), re-read that aspect's content file NOW \u2014 don't rely on memory from the task-level READ phase. Aspect rules are specific (exact timings, error handling patterns, UI details) and fade from working memory. Read them at the moment you need them.
 - [ ] 4. Sync graph artifacts \u2014 edit artifact files to reflect the changes (after each file, not batched \u2014 context is freshest immediately after the change). If the node's purpose changed, update \`description\` in \`yg-node.yaml\`.
 - [ ] 4b. If you split, merged, or renamed a node: run \`yg flows\` and update any flow \`nodes\` lists that referenced the old node path to point to the correct child/new nodes.
 - [ ] 5. Run \`yg validate\` \u2014 fix all errors (if unfixable after 3 attempts \u2192 stop, report to user)
@@ -134,12 +139,14 @@ You are not allowed to edit or create source code without establishing graph cov
 
 *Greenfield (new code):* Only Option A. Blackbox is forbidden for new code. Follow the graph-first workflow:
 
+0. **If spec/external documents exist:** route ALL knowledge from specs to the graph per the Information Routing table BEFORE any feature work. Use the appropriate location for each piece of knowledge \u2014 root node, aspects, flows, or node artifacts depending on its nature.
 1. Create aspects first (cross-cutting requirements the new code must satisfy)
 2. Create flows if the code participates in a business process
 3. Create nodes with full artifacts \u2014 description in \`yg-node.yaml\`, responsibility, interface, internals
 4. Review the context package (\`yg build-context\`) \u2014 it is now the behavioral specification
-5. Implement code that satisfies the specification
-6. The graph specifies WHAT and WHY; the code implements HOW (framework APIs, library choices)
+5. Implement code that satisfies the specification. Every source file must be mapped \u2014 including shared utilities, types, and helpers.
+6. After implementing each node, write \`internals.md\` with a ## Decisions section. Record every design choice: "Chose X over Y because Z." This is required in greenfield \u2014 not optional. Every node has design decisions (data model shape, algorithm, library, UI pattern). If you made a choice between alternatives, document it now \u2014 you will not remember later.
+7. The graph specifies WHAT and WHY; the code implements HOW (framework APIs, library choices)
 
 **Node sizing rule:** One node per cohesive feature area, NOT per directory. If a node would map >10 source files or cover >3 distinct user workflows, split it into child nodes. Example: an admin panel should be \`admin/blog\`, \`admin/gallery\`, \`admin/clients\`, \`admin/orders\` \u2014 not one \`admin-pages\` node. The CLI enforces this with W017, but plan granularity upfront rather than splitting after the fact.
 
@@ -194,13 +201,15 @@ Result: graph is stale, next agent asks user the same questions
 User: "Here are the spec docs. Implement the admin blog editor."
 
 1. Read ALL spec docs (blog-editor.md, autosave.md, user-persona.md, version-history.md)
-2. Extract cross-cutting patterns \u2192 create aspects (admin-ux-rules, autosave, version-history) if they don't exist
-3. Create flow if the blog participates in a business process
-4. Create node admin/blog with artifacts populated from spec (responsibility, interface, internals)
-5. Run yg build-context \u2192 the context package is now the behavioral specification
-6. Implement code that satisfies the specification
-7. Update artifacts with any implementation details that emerged during coding
-8. yg validate, yg drift-sync
+2. Route all knowledge from spec docs to the graph per Information Routing table \u2014 business context to root node artifacts, cross-cutting requirements to aspects, business processes to flows, feature specs to node artifacts
+3. Extract cross-cutting patterns \u2192 create aspects (admin-ux-rules, autosave, version-history) if they don't exist
+4. Create flow if the blog participates in a business process
+5. Create node admin/blog with artifacts populated from spec (responsibility, interface, internals)
+6. Run yg build-context \u2192 the context package is now the behavioral specification
+7. Implement code that satisfies the specification
+8. Update artifacts with any implementation details that emerged during coding
+9. yg validate, yg drift-sync
+Test: if spec files disappeared today, does the graph contain everything a future agent needs to understand the system?
 
 </example_correct>
 
@@ -208,13 +217,13 @@ User: "Here are the spec docs. Implement the admin blog editor."
 
 User: "Here are the spec docs. Implement the admin blog editor."
 
-1. Read blog-editor.md spec
-2. Implement all the code \u2190 WRONG: spec knowledge not captured in graph
-3. Create node admin-pages, map 20 admin files \u2190 WRONG: too wide, W017
+1. Read spec docs
+2. Create aspects and flow for the blog feature \u2190 INCOMPLETE: knowledge from spec docs not routed to graph per Information Routing table
+3. Create node admin/blog, implement code
 4. Write responsibility.md summarizing what the code does \u2190 WRONG: describes code, not spec intent
-5. Business context (persona, UX rules, autosave rationale) lost \u2190 WRONG: spec was input, not persisted
+5. Knowledge from spec docs lost \u2190 WRONG: spec treated as consumed input, not persisted to graph
 
-Result: graph mirrors code but misses WHY. Next agent reads graph, understands HOW but not WHO it's for or WHAT UX rules govern it.
+Result: graph mirrors code structure but misses everything spec docs contained that has no corresponding source file. Future agent must re-read spec files or ask the user.
 
 </example_wrong>
 
@@ -301,7 +310,7 @@ var REFERENCE = `## REFERENCE
 
 \`\`\`
 .yggdrasil/
-  yg-config.yaml     \u2190 version, vocabulary, node types, artifact rules, required aspects
+  yg-config.yaml     \u2190 version, vocabulary, node types, required aspects
   model/             \u2190 what exists: nodes, hierarchy, relations, file mappings
   aspects/           \u2190 what must: cross-cutting requirements with rationale and guidance
   flows/             \u2190 why and in what process: business processes with node participation
@@ -327,7 +336,7 @@ Three artifacts capture node knowledge at three levels:
 
 **Enrichment priority (when adding incrementally):** \`interface.md\` first (highest cross-module ROI \u2014 contracts enable other nodes to reason about interactions), then \`responsibility.md\` (identity and boundaries), then \`internals.md\` (depth for complex nodes). A node with only \`interface.md\` provides more cross-module value than one with only \`internals.md\`.
 
-Projects can define additional artifact types in \`yg-config.yaml\` under \`artifacts\`. Each custom artifact has a \`description\` (tells you what to write), a \`required\` condition (\`always\`, \`never\`, \`when: has_incoming_relations\`, \`when: has_aspect:<id>\`), and an \`included_in_relations\` flag (if true, included in dependency context packages for structural relations). The three standard artifacts are always present in config. Check \`yg-config.yaml\` to see all defined artifacts for the project.
+These three artifacts are built into the CLI and are not configurable. \`responsibility.md\` is always required, \`interface.md\` is required when the node has incoming relations, and \`internals.md\` is always optional.
 
 ### Context Assembly
 
@@ -342,9 +351,14 @@ Projects can define additional artifact types in \`yg-config.yaml\` under \`arti
 
 All artifact paths are relative to \`.yggdrasil/\` \u2014 construct full path as \`.yggdrasil/<path>\`.
 
-**Default mode (paths-only):** Use for all graph operations. Read the YAML map first \u2014 start with the \`glossary\` to understand aspects and flows, then the \`node\` section for the target. Read artifact files inline on each element using the Read tool. For quick orientation (scoping, blast radius assessment), the map alone is sufficient. For implementation or modification, read all artifact files before changing code.
+**Default mode (paths-only):** Use for all graph operations. Read the YAML map, then read artifact files with purpose:
+
+1. **Glossary first** \u2014 defines aspects and flows. Aspects are constraints your implementation must satisfy (not background reading). Flows are business processes whose invariants you must not break.
+2. **Node section** \u2014 your target's own artifacts. Read before modifying.
+3. **Hierarchy** \u2014 parent artifacts contain inherited requirements not repeated in child nodes.
+4. **Dependencies** \u2014 interfaces you consume or that consume you. Read before changing contracts.
 
-The glossary at the top defines all aspects and flows \u2014 read it first to understand IDs used throughout.
+A typical context package is ~8K tokens (less than a single source file). Read ALL artifact files listed \u2014 the cost is low, the risk of skipping is high (violating constraints you didn't know about).
 
 **Full mode (\`--full\`):** Use only when you cannot read files individually \u2014 e.g., when pasting context into a prompt, sharing with a user, or when you have no Read tool available.
 
@@ -354,7 +368,7 @@ Artifact paths are stable identifiers within a session. When building context fo
 
 When you encounter information, route it to the correct location:
 
-- **Specific to this node** \u2192 local node artifact (check \`yg-config.yaml artifacts\` for available types)
+- **Specific to this node** \u2192 local node artifact (\`responsibility.md\`, \`interface.md\`, or \`internals.md\` depending on the knowledge type)
 - **Rule for many nodes** \u2192 aspect (\`aspects/<id>/\` with \`yg-aspect.yaml\` + content \`.md\` files). If applies to ALL nodes of a type \u2192 \`node_types.<type>.required_aspects\` in \`yg-config.yaml\`
 - **Business process** \u2192 flow (\`flows/<name>/\` with \`yg-flow.yaml\` + \`description.md\`). Ask user if process unclear.
 - **Shared across a domain** \u2192 parent node artifact. Children receive it through hierarchy.
@@ -465,6 +479,7 @@ yg owner --file <path>              Find the node that owns this file (quick che
 yg build-context --file <path>      Resolve owner + assemble context in one step.
 yg build-context --node <path>      Assemble context map for a known node.
 yg build-context --node <path> --full  Same map + file contents appended below separator.
+yg build-context --file <path> --self  Own artifacts only (no hierarchy/deps/aspects/flows).
 yg tree [--root <path>] [--depth N] Print graph structure.
 yg aspects                          List aspects with metadata (YAML output).
 yg flows                            List flows with metadata (YAML output).
@@ -489,7 +504,7 @@ yg drift-sync --node <path> [--recursive] | --all
 
 | What you have | Where it goes |
 |---|---|
-| Information specific to this node | Local node artifact (check \`yg-config.yaml artifacts\` for types) |
+| Information specific to this node | Local node artifact (\`responsibility.md\`, \`interface.md\`, or \`internals.md\`) |
 | Rule that applies to many nodes | Aspect (content \`.md\` files in \`aspects/<id>/\`) |
 | Architectural invariant for a node type | Required aspect in \`yg-config.yaml node_types\` |
 | Business process participation | Flow (\`yg-flow.yaml nodes\`) |
@@ -564,11 +579,15 @@ What matters is the ACTION you are performing, not what instructed it. If the ac
 | "Flows can wait until I understand the full system" | Flows capture business processes from specs. Create them BEFORE implementing \u2014 they are part of the specification, not an afterthought. |
 | "I split the node but the flow still works" | Flow participants reference specific node paths. After a split, old paths are stale. Run \`yg flows\` and update. |
 | "This is just CRUD, not a business process" | A user performing a sequence of steps toward a goal IS a business process \u2014 even single-actor workflows (publish blog, manage portfolio, fulfill order). Create a flow. |
+| "The context package is too large to read" | A typical context package is ~8K tokens \u2014 less than one source file. Read ALL of it. |
+| "I have a plan, I don't need graph context" | A plan is not a substitute for graph context. Plans capture task steps; the graph captures cross-cutting aspects, flows, and conventions that plans may not repeat. Always run \`build-context\`. |
+| "The user told me what to do, that's my plan" | A verbal instruction is not a written plan. And even a written plan does not exempt you from the graph protocol. |
 
 ### Failure States
 
 You have broken Yggdrasil if you do any of the following:
 
+- \u274C Started brainstorming, design, or planning without running \`yg select --task\` and reading graph context first. The graph contains aspects, flows, and conventions that MUST inform design decisions.
 - \u274C Worked on a source file without running \`yg build-context --file\` first \u2014 regardless of what instructed the action (skill, plan, user request, workflow step).
 - \u274C Modified source code without updating graph artifacts before moving to the next file, or vice versa.
 - \u274C Batched graph updates to "do later" \u2014 deferred = forgotten. Update after EACH file.
@@ -598,7 +617,7 @@ Per area checklist:
 - [ ] 2. Determine node granularity \u2014 propose to user if unclear
 - [ ] 3. Create node directory, read \`schemas/yg-node.yaml\`, create \`yg-node.yaml\`
 - [ ] 3b. Write \`description\` in \`yg-node.yaml\` \u2014 a short summary of what the node does
-- [ ] 4. Analyze source \u2014 for each artifact type in \`yg-config.yaml artifacts\`: extract content, do not invent
+- [ ] 4. Analyze source \u2014 write \`responsibility.md\`, \`interface.md\`, and \`internals.md\` from code analysis, do not invent
 - [ ] 5. Identify relations \u2014 add to \`yg-node.yaml\`
 - [ ] 6. Identify cross-cutting requirements \u2014 add matching aspects, create if needed
 - [ ] 6b. For each aspect on the node: identify 2-5 code anchors (function names, constants) that evidence the pattern \u2192 add as \`anchors\` in the aspect entry in \`yg-node.yaml\`
@@ -1220,38 +1239,73 @@ async function transformSingleNode(filePath, actions, warnings) {
   }
 }
 
+// src/migrations/to-3.0.0.ts
+import { readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
+import path4 from "path";
+import { parse as parseYaml3, stringify as stringifyYaml2 } from "yaml";
+var STANDARD_ARTIFACT_NAMES = /* @__PURE__ */ new Set([
+  "responsibility.md",
+  "interface.md",
+  "internals.md"
+]);
+async function migrateTo3(yggRoot) {
+  const actions = [];
+  const warnings = [];
+  const configPath = path4.join(yggRoot, "yg-config.yaml");
+  const content = await readFile4(configPath, "utf-8");
+  const raw = parseYaml3(content);
+  if (raw.artifacts && typeof raw.artifacts === "object") {
+    const artifactKeys = Object.keys(raw.artifacts);
+    const custom = artifactKeys.filter((k) => !STANDARD_ARTIFACT_NAMES.has(k));
+    if (custom.length > 0) {
+      warnings.push(
+        `Custom artifacts removed from config: ${custom.join(", ")}. Files remain on disk but CLI will ignore them.`
+      );
+    }
+    delete raw.artifacts;
+    await writeFile4(configPath, stringifyYaml2(raw, { lineWidth: 0 }), "utf-8");
+    actions.push("Removed artifacts section from yg-config.yaml");
+  }
+  return { actions, warnings };
+}
+
 // src/migrations/index.ts
 var MIGRATIONS = [
   {
     to: "2.0.0",
     description: "Rename YAML files to yg-* prefix, restructure config, convert aspects format",
     run: migrateTo2
+  },
+  {
+    to: "3.0.0",
+    description: "Remove artifacts section from config (now hardcoded in CLI)",
+    run: migrateTo3
   }
 ];
 
 // src/cli/init.ts
 function getGraphSchemasDir() {
-  const currentDir = path4.dirname(fileURLToPath(import.meta.url));
-  const packageRoot = path4.join(currentDir, "..");
-  return path4.join(packageRoot, "graph-schemas");
+  const currentDir = path5.dirname(fileURLToPath(import.meta.url));
+  const packageRoot = path5.join(currentDir, "..");
+  return path5.join(packageRoot, "graph-schemas");
 }
 function getCliVersion() {
-  const currentDir = path4.dirname(fileURLToPath(import.meta.url));
-  const packageRoot = path4.join(currentDir, "..");
-  const pkg2 = JSON.parse(readFileSync(path4.join(packageRoot, "package.json"), "utf-8"));
+  const currentDir = path5.dirname(fileURLToPath(import.meta.url));
+  const packageRoot = path5.join(currentDir, "..");
+  const pkg2 = JSON.parse(readFileSync(path5.join(packageRoot, "package.json"), "utf-8"));
   return pkg2.version;
 }
 async function refreshSchemas(yggRoot) {
-  const schemasDir = path4.join(yggRoot, "schemas");
+  const schemasDir = path5.join(yggRoot, "schemas");
   await mkdir2(schemasDir, { recursive: true });
   const graphSchemasDir = getGraphSchemasDir();
   try {
     const entries = await readdir2(graphSchemasDir, { withFileTypes: true });
     const schemaFiles = entries.filter((e) => e.isFile()).map((e) => e.name);
     for (const file of schemaFiles) {
-      const srcPath = path4.join(graphSchemasDir, file);
-      const content = await readFile4(srcPath, "utf-8");
-      await writeFile4(path4.join(schemasDir, file), content, "utf-8");
+      const srcPath = path5.join(graphSchemasDir, file);
+      const content = await readFile5(srcPath, "utf-8");
+      await writeFile5(path5.join(schemasDir, file), content, "utf-8");
     }
   } catch {
   }
@@ -1264,7 +1318,7 @@ function registerInitCommand(program2) {
     "generic"
   ).option("--upgrade", "Refresh rules only (when .yggdrasil/ already exists)").action(async (options) => {
     const projectRoot = process.cwd();
-    const yggRoot = path4.join(projectRoot, ".yggdrasil");
+    const yggRoot = path5.join(projectRoot, ".yggdrasil");
     let upgradeMode = false;
     try {
       const statResult = await stat2(yggRoot);
@@ -1327,23 +1381,23 @@ function registerInitCommand(program2) {
       await refreshSchemas(yggRoot);
       const rulesPath2 = await installRulesForPlatform(projectRoot, platform);
       process.stdout.write("\u2713 Rules refreshed.\n");
-      process.stdout.write(`  ${path4.relative(projectRoot, rulesPath2)}
+      process.stdout.write(`  ${path5.relative(projectRoot, rulesPath2)}
 `);
       return;
     }
-    await mkdir2(path4.join(yggRoot, "model"), { recursive: true });
-    await mkdir2(path4.join(yggRoot, "aspects"), { recursive: true });
-    await mkdir2(path4.join(yggRoot, "flows"), { recursive: true });
-    const schemasDir = path4.join(yggRoot, "schemas");
+    await mkdir2(path5.join(yggRoot, "model"), { recursive: true });
+    await mkdir2(path5.join(yggRoot, "aspects"), { recursive: true });
+    await mkdir2(path5.join(yggRoot, "flows"), { recursive: true });
+    const schemasDir = path5.join(yggRoot, "schemas");
     await mkdir2(schemasDir, { recursive: true });
     const graphSchemasDir = getGraphSchemasDir();
     try {
       const entries = await readdir2(graphSchemasDir, { withFileTypes: true });
       const schemaFiles = entries.filter((e) => e.isFile()).map((e) => e.name);
       for (const file of schemaFiles) {
-        const srcPath = path4.join(graphSchemasDir, file);
-        const content = await readFile4(srcPath, "utf-8");
-        await writeFile4(path4.join(schemasDir, file), content, "utf-8");
+        const srcPath = path5.join(graphSchemasDir, file);
+        const content = await readFile5(srcPath, "utf-8");
+        await writeFile5(path5.join(schemasDir, file), content, "utf-8");
       }
     } catch (err) {
       process.stderr.write(
@@ -1351,8 +1405,8 @@ function registerInitCommand(program2) {
 `
       );
     }
-    await writeFile4(path4.join(yggRoot, "yg-config.yaml"), DEFAULT_CONFIG, "utf-8");
-    await writeFile4(path4.join(yggRoot, ".gitignore"), GITIGNORE_CONTENT, "utf-8");
+    await writeFile5(path5.join(yggRoot, "yg-config.yaml"), DEFAULT_CONFIG, "utf-8");
+    await writeFile5(path5.join(yggRoot, ".gitignore"), GITIGNORE_CONTENT, "utf-8");
     const rulesPath = await installRulesForPlatform(projectRoot, platform);
     process.stdout.write("\u2713 Yggdrasil initialized.\n\n");
     process.stdout.write("Created:\n");
@@ -1362,7 +1416,7 @@ function registerInitCommand(program2) {
     process.stdout.write("  .yggdrasil/aspects/\n");
     process.stdout.write("  .yggdrasil/flows/\n");
     process.stdout.write("  .yggdrasil/schemas/ (yg-config, yg-node, yg-aspect, yg-flow)\n");
-    process.stdout.write(`  ${path4.relative(projectRoot, rulesPath)} (rules)
+    process.stdout.write(`  ${path5.relative(projectRoot, rulesPath)} (rules)
 
 `);
     process.stdout.write("Next steps:\n");
@@ -1373,20 +1427,39 @@ function registerInitCommand(program2) {
 }
 
 // src/core/graph-loader.ts
-import { readdir as readdir4, readFile as readFile11 } from "fs/promises";
-import path9 from "path";
+import { readdir as readdir4, readFile as readFile12 } from "fs/promises";
+import path10 from "path";
+
+// src/model/types.ts
+var STANDARD_ARTIFACTS2 = {
+  "responsibility.md": {
+    required: "always",
+    description: "What this node is responsible for, and what it is not",
+    included_in_relations: true
+  },
+  "interface.md": {
+    required: { when: "has_incoming_relations" },
+    description: "Public API \u2014 methods, parameters, return types, contracts, failure modes",
+    included_in_relations: true
+  },
+  "internals.md": {
+    required: "never",
+    description: "How the node works and why \u2014 algorithms, business rules, design decisions",
+    included_in_relations: false
+  }
+};
 
 // src/io/config-parser.ts
-import { readFile as readFile5 } from "fs/promises";
-import { parse as parseYaml3 } from "yaml";
+import { readFile as readFile6 } from "fs/promises";
+import { parse as parseYaml4 } from "yaml";
 var DEFAULT_QUALITY = {
   min_artifact_length: 50,
   max_direct_relations: 10,
   context_budget: { warning: 1e4, error: 2e4, own_warning: void 0 }
 };
 async function parseConfig(filePath) {
-  const content = await readFile5(filePath, "utf-8");
-  const raw = parseYaml3(content);
+  const content = await readFile6(filePath, "utf-8");
+  const raw = parseYaml4(content);
   if (!raw || typeof raw !== "object") {
     throw new Error(`yg-config.yaml: file is empty or not a valid YAML mapping`);
   }
@@ -1412,35 +1485,6 @@ async function parseConfig(filePath) {
       required_aspects: requiredAspects && requiredAspects.length > 0 ? requiredAspects : void 0
     };
   }
-  const artifacts = raw.artifacts;
-  if (!artifacts || typeof artifacts !== "object" || Array.isArray(artifacts) || Object.keys(artifacts).length === 0) {
-    throw new Error(`yg-config.yaml: 'artifacts' must be a non-empty object`);
-  }
-  const artifactsMap = {};
-  for (const [key, val] of Object.entries(artifacts)) {
-    if (key === "yg-node.yaml") {
-      throw new Error(`yg-config.yaml: artifact name 'yg-node.yaml' is reserved`);
-    }
-    const a = val;
-    const required = a.required;
-    if (required !== "always" && required !== "never" && (typeof required !== "object" || !required || !("when" in required))) {
-      throw new Error(`yg-config.yaml: artifact '${key}' has invalid 'required' field`);
-    }
-    if (typeof required === "object" && required && "when" in required) {
-      const when = required.when;
-      const validWhen = when === "has_incoming_relations" || when === "has_outgoing_relations" || typeof when === "string" && (when.startsWith("has_aspect:") || when.startsWith("has_tag:"));
-      if (!validWhen) {
-        throw new Error(
-          `yg-config.yaml: artifact '${key}' has invalid 'required.when': must be has_incoming_relations, has_outgoing_relations, or has_aspect:<name>`
-        );
-      }
-    }
-    artifactsMap[key] = {
-      required,
-      description: a.description ?? "",
-      included_in_relations: a.included_in_relations ?? false
-    };
-  }
   const qualityRaw = raw.quality;
   const quality = qualityRaw ? {
     min_artifact_length: qualityRaw.min_artifact_length ?? DEFAULT_QUALITY.min_artifact_length,
@@ -1463,14 +1507,13 @@ async function parseConfig(filePath) {
     version,
     name: raw.name.trim(),
     node_types: nodeTypes,
-    artifacts: artifactsMap,
     quality
   };
 }
 
 // src/io/node-parser.ts
-import { readFile as readFile6 } from "fs/promises";
-import { parse as parseYaml4 } from "yaml";
+import { readFile as readFile7 } from "fs/promises";
+import { parse as parseYaml5 } from "yaml";
 var RELATION_TYPES = [
   "uses",
   "calls",
@@ -1483,8 +1526,8 @@ function isValidRelationType(t) {
   return typeof t === "string" && RELATION_TYPES.includes(t);
 }
 async function parseNodeYaml(filePath) {
-  const content = await readFile6(filePath, "utf-8");
-  const raw = parseYaml4(content);
+  const content = await readFile7(filePath, "utf-8");
+  const raw = parseYaml5(content);
   if (!raw || typeof raw !== "object") {
     throw new Error(`yg-node.yaml at ${filePath}: file is empty or not a valid YAML mapping`);
   }
@@ -1629,12 +1672,12 @@ function parseMapping(rawMapping, filePath) {
 }
 
 // src/io/aspect-parser.ts
-import { readFile as readFile8 } from "fs/promises";
-import { parse as parseYaml5 } from "yaml";
+import { readFile as readFile9 } from "fs/promises";
+import { parse as parseYaml6 } from "yaml";
 
 // src/io/artifact-reader.ts
-import { readFile as readFile7, readdir as readdir3 } from "fs/promises";
-import path5 from "path";
+import { readFile as readFile8, readdir as readdir3 } from "fs/promises";
+import path6 from "path";
 async function readArtifacts(dirPath, excludeFiles = ["yg-node.yaml"], includeFiles) {
   const entries = await readdir3(dirPath, { withFileTypes: true });
   const artifacts = [];
@@ -1643,8 +1686,8 @@ async function readArtifacts(dirPath, excludeFiles = ["yg-node.yaml"], includeFi
     if (!entry.isFile()) continue;
     if (excludeFiles.includes(entry.name)) continue;
     if (includeSet && !includeSet.has(entry.name)) continue;
-    const filePath = path5.join(dirPath, entry.name);
-    const content = await readFile7(filePath, "utf-8");
+    const filePath = path6.join(dirPath, entry.name);
+    const content = await readFile8(filePath, "utf-8");
     artifacts.push({ filename: entry.name, content });
   }
   artifacts.sort((a, b) => a.filename.localeCompare(b.filename));
@@ -1658,8 +1701,8 @@ async function parseAspect(aspectDir, aspectYamlPath, id) {
   if (!idTrimmed) {
     throw new Error(`Aspect id must be non-empty (relative path in aspects/)`);
   }
-  const content = await readFile8(aspectYamlPath, "utf-8");
-  const raw = parseYaml5(content);
+  const content = await readFile9(aspectYamlPath, "utf-8");
+  const raw = parseYaml6(content);
   if (!raw || typeof raw !== "object") {
     throw new Error(`Aspect file ${aspectYamlPath}: file is empty or not a valid YAML mapping`);
   }
@@ -1695,12 +1738,12 @@ async function parseAspect(aspectDir, aspectYamlPath, id) {
 }
 
 // src/io/flow-parser.ts
-import { readFile as readFile9 } from "fs/promises";
-import path6 from "path";
-import { parse as parseYaml6 } from "yaml";
+import { readFile as readFile10 } from "fs/promises";
+import path7 from "path";
+import { parse as parseYaml7 } from "yaml";
 async function parseFlow(flowDir, flowYamlPath) {
-  const content = await readFile9(flowYamlPath, "utf-8");
-  const raw = parseYaml6(content);
+  const content = await readFile10(flowYamlPath, "utf-8");
+  const raw = parseYaml7(content);
   if (!raw || typeof raw !== "object") {
     throw new Error(`yg-flow.yaml at ${flowYamlPath}: file is empty or not a valid YAML mapping`);
   }
@@ -1730,7 +1773,7 @@ async function parseFlow(flowDir, flowYamlPath) {
   }
   const artifacts = await readArtifacts(flowDir, ["yg-flow.yaml"]);
   return {
-    path: path6.basename(flowDir),
+    path: path7.basename(flowDir),
     name: raw.name.trim(),
     description,
     nodes: nodePaths,
@@ -1740,26 +1783,26 @@ async function parseFlow(flowDir, flowYamlPath) {
 }
 
 // src/io/schema-parser.ts
-import { readFile as readFile10 } from "fs/promises";
-import path7 from "path";
-import { parse as parseYaml7 } from "yaml";
+import { readFile as readFile11 } from "fs/promises";
+import path8 from "path";
+import { parse as parseYaml8 } from "yaml";
 async function parseSchema(filePath) {
-  const content = await readFile10(filePath, "utf-8");
-  parseYaml7(content);
-  const rawName = path7.basename(filePath, path7.extname(filePath));
+  const content = await readFile11(filePath, "utf-8");
+  parseYaml8(content);
+  const rawName = path8.basename(filePath, path8.extname(filePath));
   const schemaType = rawName.startsWith("yg-") ? rawName.slice(3) : rawName;
   return { schemaType };
 }
 
 // src/utils/paths.ts
-import path8 from "path";
+import path9 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { stat as stat3 } from "fs/promises";
 async function findYggRoot(projectRoot) {
-  let current = path8.resolve(projectRoot);
-  const root = path8.parse(current).root;
+  let current = path9.resolve(projectRoot);
+  const root = path9.parse(current).root;
   while (true) {
-    const yggPath = path8.join(current, ".yggdrasil");
+    const yggPath = path9.join(current, ".yggdrasil");
     try {
       const st = await stat3(yggPath);
       if (!st.isDirectory()) {
@@ -1773,7 +1816,7 @@ async function findYggRoot(projectRoot) {
         if (current === root) {
           throw new Error(`No .yggdrasil/ directory found. Run 'yg init' first.`, { cause: err });
         }
-        current = path8.dirname(current);
+        current = path9.dirname(current);
         continue;
       }
       throw err;
@@ -1789,43 +1832,42 @@ function normalizeProjectRelativePath(projectRoot, rawPath) {
   if (normalizedInput.length === 0) {
     throw new Error("Path cannot be empty");
   }
-  const absolute = path8.resolve(projectRoot, normalizedInput);
-  const relative = path8.relative(projectRoot, absolute);
-  const isOutside = relative.startsWith("..") || path8.isAbsolute(relative);
+  const absolute = path9.resolve(projectRoot, normalizedInput);
+  const relative = path9.relative(projectRoot, absolute);
+  const isOutside = relative.startsWith("..") || path9.isAbsolute(relative);
   if (isOutside) {
     throw new Error(`Path is outside project root: ${rawPath}`);
   }
-  return relative.split(path8.sep).join("/");
+  return relative.split(path9.sep).join("/");
 }
 function projectRootFromGraph(yggRootPath) {
-  return path8.dirname(yggRootPath);
+  return path9.dirname(yggRootPath);
 }
 
 // src/core/graph-loader.ts
 function toModelPath(absolutePath, modelDir) {
-  return path9.relative(modelDir, absolutePath).split(path9.sep).join("/");
+  return path10.relative(modelDir, absolutePath).split(path10.sep).join("/");
 }
 var FALLBACK_CONFIG = {
   name: "",
-  node_types: {},
-  artifacts: {}
+  node_types: {}
 };
 async function loadGraph(projectRoot, options = {}) {
   const yggRoot = await findYggRoot(projectRoot);
   let configError;
   let config = FALLBACK_CONFIG;
   try {
-    config = await parseConfig(path9.join(yggRoot, "yg-config.yaml"));
+    config = await parseConfig(path10.join(yggRoot, "yg-config.yaml"));
   } catch (error) {
     if (!options.tolerateInvalidConfig) {
       throw error;
     }
     configError = error.message;
   }
-  const modelDir = path9.join(yggRoot, "model");
+  const modelDir = path10.join(yggRoot, "model");
   const nodes = /* @__PURE__ */ new Map();
   const nodeParseErrors = [];
-  const artifactFilenames = Object.keys(config.artifacts ?? {});
+  const artifactFilenames = Object.keys(STANDARD_ARTIFACTS2);
   try {
     await scanModelDirectory(modelDir, modelDir, null, nodes, nodeParseErrors, artifactFilenames);
   } catch (err) {
@@ -1836,9 +1878,9 @@ async function loadGraph(projectRoot, options = {}) {
     }
     throw err;
   }
-  const aspects = await loadAspects(path9.join(yggRoot, "aspects"));
-  const flows = await loadFlows(path9.join(yggRoot, "flows"));
-  const schemas = await loadSchemas(path9.join(yggRoot, "schemas"));
+  const aspects = await loadAspects(path10.join(yggRoot, "aspects"));
+  const flows = await loadFlows(path10.join(yggRoot, "flows"));
+  const schemas = await loadSchemas(path10.join(yggRoot, "schemas"));
   return {
     config,
     configError,
@@ -1858,11 +1900,11 @@ async function scanModelDirectory(dirPath, modelDir, parent, nodes, nodeParseErr
   }
   if (hasNodeYaml) {
     const graphPath = toModelPath(dirPath, modelDir);
-    const nodeYamlPath = path9.join(dirPath, "yg-node.yaml");
+    const nodeYamlPath = path10.join(dirPath, "yg-node.yaml");
     let meta;
     let nodeYamlRaw;
     try {
-      nodeYamlRaw = await readFile11(nodeYamlPath, "utf-8");
+      nodeYamlRaw = await readFile12(nodeYamlPath, "utf-8");
       meta = await parseNodeYaml(nodeYamlPath);
     } catch (err) {
       nodeParseErrors.push({
@@ -1888,7 +1930,7 @@ async function scanModelDirectory(dirPath, modelDir, parent, nodes, nodeParseErr
       if (!entry.isDirectory()) continue;
       if (entry.name.startsWith(".")) continue;
       await scanModelDirectory(
-        path9.join(dirPath, entry.name),
+        path10.join(dirPath, entry.name),
         modelDir,
         node,
         nodes,
@@ -1901,7 +1943,7 @@ async function scanModelDirectory(dirPath, modelDir, parent, nodes, nodeParseErr
       if (!entry.isDirectory()) continue;
       if (entry.name.startsWith(".")) continue;
       await scanModelDirectory(
-        path9.join(dirPath, entry.name),
+        path10.join(dirPath, entry.name),
         modelDir,
         null,
         nodes,
@@ -1924,15 +1966,15 @@ async function scanAspectsDirectory(dirPath, aspectsRoot, aspects) {
   const entries = await readdir4(dirPath, { withFileTypes: true });
   const hasAspectYaml = entries.some((e) => e.isFile() && e.name === "yg-aspect.yaml");
   if (hasAspectYaml) {
-    const id = path9.relative(aspectsRoot, dirPath).split(path9.sep).join("/");
-    const aspectYamlPath = path9.join(dirPath, "yg-aspect.yaml");
+    const id = path10.relative(aspectsRoot, dirPath).split(path10.sep).join("/");
+    const aspectYamlPath = path10.join(dirPath, "yg-aspect.yaml");
     const aspect = await parseAspect(dirPath, aspectYamlPath, id);
     aspects.push(aspect);
   }
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     if (entry.name.startsWith(".")) continue;
-    await scanAspectsDirectory(path9.join(dirPath, entry.name), aspectsRoot, aspects);
+    await scanAspectsDirectory(path10.join(dirPath, entry.name), aspectsRoot, aspects);
   }
 }
 async function loadFlows(flowsDir) {
@@ -1945,8 +1987,8 @@ async function loadFlows(flowsDir) {
   const flows = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const flowYamlPath = path9.join(flowsDir, entry.name, "yg-flow.yaml");
-    const flow = await parseFlow(path9.join(flowsDir, entry.name), flowYamlPath);
+    const flowYamlPath = path10.join(flowsDir, entry.name, "yg-flow.yaml");
+    const flow = await parseFlow(path10.join(flowsDir, entry.name), flowYamlPath);
     flows.push(flow);
   }
   return flows;
@@ -1958,7 +2000,7 @@ async function loadSchemas(schemasDir) {
     for (const entry of entries) {
       if (!entry.isFile()) continue;
       if (!entry.name.endsWith(".yaml") && !entry.name.endsWith(".yml")) continue;
-      const s = await parseSchema(path9.join(schemasDir, entry.name));
+      const s = await parseSchema(path10.join(schemasDir, entry.name));
       schemas.push(s);
     }
     return schemas;
@@ -1968,8 +2010,8 @@ async function loadSchemas(schemasDir) {
 }
 
 // src/core/context-builder.ts
-import { readFile as readFile12 } from "fs/promises";
-import path10 from "path";
+import { readFile as readFile13 } from "fs/promises";
+import path11 from "path";
 
 // src/utils/tokens.ts
 function estimateTokens(text) {
@@ -1980,48 +2022,53 @@ function estimateTokens(text) {
 var STRUCTURAL_RELATION_TYPES = /* @__PURE__ */ new Set(["uses", "calls", "extends", "implements"]);
 var EVENT_RELATION_TYPES = /* @__PURE__ */ new Set(["emits", "listens"]);
 var YG_YAML_FILES = /* @__PURE__ */ new Set(["yg-node.yaml", "yg-aspect.yaml", "yg-flow.yaml"]);
-async function buildContext(graph, nodePath) {
+async function buildContext(graph, nodePath, options) {
   const node = graph.nodes.get(nodePath);
   if (!node) {
     throw new Error(`Node not found: ${nodePath}`);
   }
+  const selfOnly = options?.selfOnly ?? false;
   const layers = [];
   layers.push(buildGlobalLayer(graph.config));
   const ancestors = collectAncestors(node);
-  for (const ancestor of ancestors) {
-    layers.push(buildHierarchyLayer(ancestor, graph.config, graph));
+  if (!selfOnly) {
+    for (const ancestor of ancestors) {
+      layers.push(buildHierarchyLayer(ancestor, graph.config, graph));
+    }
   }
   layers.push(await buildOwnLayer(node, graph.config, graph.rootPath, graph));
-  const ancestorPaths = new Set(ancestors.map((a) => a.path));
-  for (const relation of node.meta.relations ?? []) {
-    const target = graph.nodes.get(relation.target);
-    if (!target) {
-      throw new Error(`Broken relation: ${nodePath} -> ${relation.target} (target not found)`);
+  if (!selfOnly) {
+    const ancestorPaths = new Set(ancestors.map((a) => a.path));
+    for (const relation of node.meta.relations ?? []) {
+      const target = graph.nodes.get(relation.target);
+      if (!target) {
+        throw new Error(`Broken relation: ${nodePath} -> ${relation.target} (target not found)`);
+      }
+      if (ancestorPaths.has(relation.target)) continue;
+      if (STRUCTURAL_RELATION_TYPES.has(relation.type)) {
+        layers.push(buildStructuralRelationLayer(target, relation));
+      } else if (EVENT_RELATION_TYPES.has(relation.type)) {
+        layers.push(buildEventRelationLayer(target, relation));
+      }
     }
-    if (ancestorPaths.has(relation.target)) continue;
-    if (STRUCTURAL_RELATION_TYPES.has(relation.type)) {
-      layers.push(buildStructuralRelationLayer(target, relation, graph.config));
-    } else if (EVENT_RELATION_TYPES.has(relation.type)) {
-      layers.push(buildEventRelationLayer(target, relation));
+    for (const flow of collectParticipatingFlows(graph, node)) {
+      layers.push(buildFlowLayer(flow, graph));
     }
-  }
-  for (const flow of collectParticipatingFlows(graph, node)) {
-    layers.push(buildFlowLayer(flow, graph));
-  }
-  const allAspectIds = /* @__PURE__ */ new Set();
-  for (const l of layers) {
-    const aspects = l.attrs?.aspects;
-    if (aspects) {
-      for (const id of aspects.split(",").map((t) => t.trim()).filter(Boolean)) {
-        allAspectIds.add(id);
+    const allAspectIds = /* @__PURE__ */ new Set();
+    for (const l of layers) {
+      const aspects = l.attrs?.aspects;
+      if (aspects) {
+        for (const id of aspects.split(",").map((t) => t.trim()).filter(Boolean)) {
+          allAspectIds.add(id);
+        }
       }
     }
-  }
-  const aspectsToInclude = resolveAspects(allAspectIds, graph.aspects);
-  for (const aspect of aspectsToInclude) {
-    const entry = node.meta.aspects?.find((a) => a.aspect === aspect.id);
-    const exceptionNote = entry?.exceptions?.join("; ");
-    layers.push(buildAspectLayer(aspect, exceptionNote));
+    const aspectsToInclude = resolveAspects(allAspectIds, graph.aspects);
+    for (const aspect of aspectsToInclude) {
+      const entry = node.meta.aspects?.find((a) => a.aspect === aspect.id);
+      const exceptionNote = entry?.exceptions?.join("; ");
+      layers.push(buildAspectLayer(aspect, exceptionNote));
+    }
   }
   const fullText = layers.map((l) => l.content).join("\n\n");
   const tokenCount = estimateTokens(fullText);
@@ -2082,12 +2129,12 @@ function buildGlobalLayer(config) {
 `;
   return { type: "global", label: "Global Context", content };
 }
-function filterArtifactsByConfig(artifacts, config) {
-  const allowed = new Set(Object.keys(config.artifacts ?? {}));
+function filterByStandardArtifacts(artifacts) {
+  const allowed = new Set(Object.keys(STANDARD_ARTIFACTS2));
   return artifacts.filter((a) => allowed.has(a.filename));
 }
 function buildHierarchyLayer(ancestor, config, graph) {
-  const filtered = filterArtifactsByConfig(ancestor.artifacts, config);
+  const filtered = filterByStandardArtifacts(ancestor.artifacts);
   const content = filtered.map((a) => `### ${a.filename}
 ${a.content}`).join("\n\n");
   const nodeAspects = (ancestor.meta.aspects ?? []).map((a) => a.aspect);
@@ -2106,9 +2153,9 @@ async function buildOwnLayer(node, config, graphRootPath, graph) {
     parts.push(`### yg-node.yaml
 ${node.nodeYamlRaw.trim()}`);
   } else {
-    const nodeYamlPath = path10.join(graphRootPath, "model", node.path, "yg-node.yaml");
+    const nodeYamlPath = path11.join(graphRootPath, "model", node.path, "yg-node.yaml");
     try {
-      const nodeYamlContent = await readFile12(nodeYamlPath, "utf-8");
+      const nodeYamlContent = await readFile13(nodeYamlPath, "utf-8");
       parts.push(`### yg-node.yaml
 ${nodeYamlContent.trim()}`);
     } catch {
@@ -2116,7 +2163,7 @@ ${nodeYamlContent.trim()}`);
 (not found)`);
     }
   }
-  const filtered = filterArtifactsByConfig(node.artifacts, config);
+  const filtered = filterByStandardArtifacts(node.artifacts);
   for (const a of filtered) {
     parts.push(`### ${a.filename}
 ${a.content}`);
@@ -2132,7 +2179,7 @@ ${a.content}`);
     attrs
   };
 }
-function buildStructuralRelationLayer(target, relation, config) {
+function buildStructuralRelationLayer(target, relation) {
   let content = "";
   if (relation.consumes?.length) {
     content += `Consumes: ${relation.consumes.join(", ")}
@@ -2144,7 +2191,7 @@ function buildStructuralRelationLayer(target, relation, config) {
 
 `;
   }
-  const structuralArtifactFilenames = Object.entries(config.artifacts ?? {}).filter(([, c]) => c.included_in_relations).map(([filename]) => filename);
+  const structuralArtifactFilenames = Object.entries(STANDARD_ARTIFACTS2).filter(([, c]) => c.included_in_relations).map(([filename]) => filename);
   const structuralArts = structuralArtifactFilenames.map((filename) => {
     const art = target.artifacts.find((a) => a.filename === filename);
     return art ? { filename: art.filename, content: art.content } : null;
@@ -2153,7 +2200,7 @@ function buildStructuralRelationLayer(target, relation, config) {
     content += structuralArts.map((a) => `### ${a.filename}
 ${a.content}`).join("\n\n");
   } else {
-    const filtered = filterArtifactsByConfig(target.artifacts, config);
+    const filtered = filterByStandardArtifacts(target.artifacts);
     content += filtered.map((a) => `### ${a.filename}
 ${a.content}`).join("\n\n");
   }
@@ -2258,8 +2305,8 @@ function collectAncestors(node) {
 }
 function collectDependencyAncestors(target, config, graph) {
   const ancestors = collectAncestors(target);
-  const structuralFilenames = Object.entries(config.artifacts ?? {}).filter(([, c]) => c.included_in_relations).map(([filename]) => filename);
-  const configArtifactKeys = [...Object.keys(config.artifacts ?? {})];
+  const structuralFilenames = Object.entries(STANDARD_ARTIFACTS2).filter(([, c]) => c.included_in_relations).map(([filename]) => filename);
+  const configArtifactKeys = [...Object.keys(STANDARD_ARTIFACTS2)];
   return ancestors.map((ancestor) => {
     const nodeAspects = (ancestor.meta.aspects ?? []).map((a) => a.aspect);
     const expanded = expandAspects(nodeAspects, graph.aspects);
@@ -2327,7 +2374,7 @@ function computeBudgetBreakdown(pkg2, graph) {
   const total = own + hierarchy + aspects + flows + dependencies;
   return { own, hierarchy, aspects, flows, dependencies, total };
 }
-function toContextMapOutput(pkg2, graph) {
+function toContextMapOutput(pkg2, graph, options) {
   const node = graph.nodes.get(pkg2.nodePath);
   const config = graph.config;
   const nodeAspects = (node.meta.aspects ?? []).map((entry) => {
@@ -2336,48 +2383,51 @@ function toContextMapOutput(pkg2, graph) {
     if (entry.exceptions?.length) ref.exceptions = entry.exceptions;
     return ref;
   });
-  const participatingFlows = collectParticipatingFlows(graph, node);
+  const selfOnly = options?.selfOnly ?? false;
+  const participatingFlows = selfOnly ? [] : collectParticipatingFlows(graph, node);
   const flowRefs = participatingFlows.map((f) => {
     const ref = { path: f.path };
     if (f.aspects?.length) ref.aspects = f.aspects;
     return ref;
   });
   const ancestors = collectAncestors(node);
-  const hierarchyRefs = ancestors.map((a) => {
+  const hierarchyRefs = selfOnly ? [] : ancestors.map((a) => {
     const nodeAspectIds = (a.meta.aspects ?? []).map((e) => e.aspect);
     const expanded = expandAspects(nodeAspectIds, graph.aspects);
     return { path: a.path, name: a.meta.name, type: a.meta.type, description: a.meta.description, aspects: expanded, files: buildNodeFiles(a, config, `model/${a.path}`) };
   });
-  const ancestorPaths = new Set(ancestors.map((a) => a.path));
   const depRefs = [];
-  for (const relation of node.meta.relations ?? []) {
-    const target = graph.nodes.get(relation.target);
-    if (!target) continue;
-    if (ancestorPaths.has(relation.target)) continue;
-    const depAncestors = collectAncestors(target);
-    const depHierarchy = depAncestors.map((a) => {
-      const ids = (a.meta.aspects ?? []).map((e) => e.aspect);
-      const expanded = expandAspects(ids, graph.aspects);
-      const ancestorNode = graph.nodes.get(a.path);
-      return { path: a.path, name: a.meta.name, type: a.meta.type, description: a.meta.description, aspects: expanded, files: ancestorNode ? buildDepNodeFiles(ancestorNode, config, `model/${a.path}`) : [] };
-    });
-    const depEffectiveAspects = [...collectEffectiveAspectIds(graph, target.path)];
-    const ref = {
-      path: target.path,
-      name: target.meta.name,
-      type: target.meta.type,
-      description: target.meta.description,
-      relation: relation.type,
-      aspects: depEffectiveAspects,
-      hierarchy: depHierarchy,
-      files: buildDepNodeFiles(target, config, `model/${target.path}`)
-    };
-    if (relation.consumes?.length) ref.consumes = relation.consumes;
-    if (relation.failure) ref.failure = relation.failure;
-    if (relation.event_name) ref["event-name"] = relation.event_name;
-    depRefs.push(ref);
+  if (!selfOnly) {
+    const ancestorPaths = new Set(ancestors.map((a) => a.path));
+    for (const relation of node.meta.relations ?? []) {
+      const target = graph.nodes.get(relation.target);
+      if (!target) continue;
+      if (ancestorPaths.has(relation.target)) continue;
+      const depAncestors = collectAncestors(target);
+      const depHierarchy = depAncestors.map((a) => {
+        const ids = (a.meta.aspects ?? []).map((e) => e.aspect);
+        const expanded = expandAspects(ids, graph.aspects);
+        const ancestorNode = graph.nodes.get(a.path);
+        return { path: a.path, name: a.meta.name, type: a.meta.type, description: a.meta.description, aspects: expanded, files: ancestorNode ? buildDepNodeFiles(ancestorNode, config, `model/${a.path}`) : [] };
+      });
+      const depEffectiveAspects = [...collectEffectiveAspectIds(graph, target.path)];
+      const ref = {
+        path: target.path,
+        name: target.meta.name,
+        type: target.meta.type,
+        description: target.meta.description,
+        relation: relation.type,
+        aspects: depEffectiveAspects,
+        hierarchy: depHierarchy,
+        files: buildDepNodeFiles(target, config, `model/${target.path}`)
+      };
+      if (relation.consumes?.length) ref.consumes = relation.consumes;
+      if (relation.failure) ref.failure = relation.failure;
+      if (relation.event_name) ref["event-name"] = relation.event_name;
+      depRefs.push(ref);
+    }
   }
-  const glossary = buildGlossary(node, depRefs, graph);
+  const glossary = selfOnly ? { aspects: {}, flows: {} } : buildGlossary(node, depRefs, graph);
   const breakdown = computeBudgetBreakdown(pkg2, graph);
   const warningThreshold = config.quality?.context_budget?.warning ?? 1e4;
   const errorThreshold = config.quality?.context_budget?.error ?? 2e4;
@@ -2400,13 +2450,13 @@ function toContextMapOutput(pkg2, graph) {
     glossary
   };
 }
-function buildNodeFiles(node, config, prefix) {
-  const configKeys = Object.keys(config.artifacts ?? {});
+function buildNodeFiles(node, _config, prefix) {
+  const configKeys = Object.keys(STANDARD_ARTIFACTS2);
   return configKeys.filter((f) => !YG_YAML_FILES.has(f) && node.artifacts.some((a) => a.filename === f)).map((f) => `${prefix}/${f}`);
 }
-function buildDepNodeFiles(node, config, prefix) {
-  const structural = Object.entries(config.artifacts ?? {}).filter(([, c]) => c.included_in_relations).map(([f]) => f);
-  const filenames = structural.length > 0 ? structural : Object.keys(config.artifacts ?? {});
+function buildDepNodeFiles(node, _config, prefix) {
+  const structural = Object.entries(STANDARD_ARTIFACTS2).filter(([, c]) => c.included_in_relations).map(([f]) => f);
+  const filenames = structural.length > 0 ? structural : Object.keys(STANDARD_ARTIFACTS2);
   return filenames.filter((f) => !YG_YAML_FILES.has(f) && node.artifacts.some((a) => a.filename === f)).map((f) => `${prefix}/${f}`);
 }
 function buildGlossary(node, dependencies, graph) {
@@ -2511,8 +2561,8 @@ ${file.content}
 }
 
 // src/core/validator.ts
-import { readdir as readdir5, readFile as readFile13, stat as stat4 } from "fs/promises";
-import path11 from "path";
+import { readdir as readdir5, readFile as readFile14, stat as stat4 } from "fs/promises";
+import path12 from "path";
 function getAspectIds(aspects) {
   return (aspects ?? []).map((a) => a.aspect);
 }
@@ -2546,7 +2596,6 @@ async function validate(graph, scope = "all") {
     issues.push(...checkRequiredAspectsCoverage(graph));
     issues.push(...await checkAnchorPresence(graph));
     issues.push(...checkRequiredArtifacts(graph));
-    issues.push(...checkInvalidArtifactConditions(graph));
     issues.push(...await checkContextBudget(graph));
     issues.push(...checkHighFanOut(graph));
     issues.push(...checkMissingDescriptions(graph));
@@ -2879,12 +2928,12 @@ function checkMappingOverlap(graph) {
 }
 async function checkMappingPathsExist(graph) {
   const issues = [];
-  const projectRoot = path11.dirname(graph.rootPath);
+  const projectRoot = path12.dirname(graph.rootPath);
   const { access: access4 } = await import("fs/promises");
   for (const [nodePath, node] of graph.nodes) {
     const mappingPaths = normalizeMappingPaths(node.meta.mapping);
     for (const mp of mappingPaths) {
-      const absPath = path11.join(projectRoot, mp);
+      const absPath = path12.join(projectRoot, mp);
       try {
         await access4(absPath);
       } catch {
@@ -2919,15 +2968,6 @@ function artifactRequiredReason(graph, nodePath, node, required) {
     const sources = getIncomingRelationSources(graph, nodePath);
     return sources.length > 0 ? `${sources.length} incoming relation(s): ${sources.join(", ")}` : null;
   }
-  if (when === "has_outgoing_relations") {
-    const count = node.meta.relations?.length ?? 0;
-    return count > 0 ? `${count} outgoing relation(s)` : null;
-  }
-  if (when.startsWith("has_aspect:") || when.startsWith("has_tag:")) {
-    const prefix = when.startsWith("has_aspect:") ? "has_aspect:" : "has_tag:";
-    const aspectId = when.slice(prefix.length);
-    return (node.meta.aspects ?? []).some((a) => a.aspect === aspectId) ? `node has aspect '${aspectId}'` : null;
-  }
   return null;
 }
 function getIncomingRelations(graph, nodePath) {
@@ -2944,7 +2984,7 @@ function getIncomingRelations(graph, nodePath) {
 }
 function checkRequiredArtifacts(graph) {
   const issues = [];
-  const artifacts = graph.config.artifacts ?? {};
+  const artifacts = STANDARD_ARTIFACTS2;
   for (const [nodePath, node] of graph.nodes) {
     for (const [filename, config] of Object.entries(artifacts)) {
       const hasArtifact = node.artifacts.some((a) => a.filename === filename);
@@ -3000,30 +3040,6 @@ function checkFlowAspectIds(graph) {
   }
   return issues;
 }
-function checkInvalidArtifactConditions(graph) {
-  const issues = [];
-  const validAspectIds = new Set(graph.aspects.map((a) => a.id));
-  const artifacts = graph.config.artifacts ?? {};
-  for (const [artifactName, config] of Object.entries(artifacts)) {
-    const required = config.required;
-    if (typeof required === "object" && required && "when" in required) {
-      const when = required.when;
-      if (when.startsWith("has_aspect:") || when.startsWith("has_tag:")) {
-        const prefix = when.startsWith("has_aspect:") ? "has_aspect:" : "has_tag:";
-        const aspectId = when.slice(prefix.length);
-        if (!validAspectIds.has(aspectId)) {
-          issues.push({
-            severity: "error",
-            code: "E013",
-            rule: "invalid-artifact-condition",
-            message: `Artifact '${artifactName}' condition has_aspect:${aspectId} has no corresponding aspect in aspects/`
-          });
-        }
-      }
-    }
-  }
-  return issues;
-}
 async function checkShallowArtifacts(graph) {
   const issues = [];
   const minLen = graph.config.quality?.min_artifact_length ?? 50;
@@ -3045,7 +3061,7 @@ async function checkShallowArtifacts(graph) {
 async function checkWideNodes(graph) {
   const issues = [];
   const maxFiles = graph.config.quality?.max_mapping_source_files ?? 10;
-  const projectRoot = path11.dirname(graph.rootPath);
+  const projectRoot = path12.dirname(graph.rootPath);
   for (const [nodePath, node] of graph.nodes) {
     if (node.meta.blackbox) continue;
     const mappingPaths = normalizeMappingPaths(node.meta.mapping);
@@ -3148,11 +3164,11 @@ function checkSchemas(graph) {
 }
 async function checkDirectoriesHaveNodeYaml(graph) {
   const issues = [];
-  const modelDir = path11.join(graph.rootPath, "model");
+  const modelDir = path12.join(graph.rootPath, "model");
   async function scanDir(dirPath, segments) {
     const entries = await readdir5(dirPath, { withFileTypes: true });
     const hasNodeYaml = entries.some((e) => e.isFile() && e.name === "yg-node.yaml");
-    const dirName = path11.basename(dirPath);
+    const dirName = path12.basename(dirPath);
     if (RESERVED_DIRS.has(dirName)) return;
     const hasFiles = entries.some((e) => e.isFile());
     const hasSubdirs = entries.some((e) => e.isDirectory() && !RESERVED_DIRS.has(e.name) && !e.name.startsWith("."));
@@ -3180,7 +3196,7 @@ async function checkDirectoriesHaveNodeYaml(graph) {
       if (!entry.isDirectory()) continue;
       if (RESERVED_DIRS.has(entry.name)) continue;
       if (entry.name.startsWith(".")) continue;
-      await scanDir(path11.join(dirPath, entry.name), [...segments, entry.name]);
+      await scanDir(path12.join(dirPath, entry.name), [...segments, entry.name]);
     }
   }
   try {
@@ -3188,7 +3204,7 @@ async function checkDirectoriesHaveNodeYaml(graph) {
     for (const entry of rootEntries) {
       if (!entry.isDirectory()) continue;
       if (entry.name.startsWith(".")) continue;
-      await scanDir(path11.join(modelDir, entry.name), [entry.name]);
+      await scanDir(path12.join(modelDir, entry.name), [entry.name]);
     }
   } catch {
   }
@@ -3205,7 +3221,7 @@ async function expandMappingToFiles(projectRoot, mappingPaths) {
         const entries = await readdir5(absPath, { withFileTypes: true });
         for (const entry of entries) {
           if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-          const entryPath = path11.join(absPath, entry.name);
+          const entryPath = path12.join(absPath, entry.name);
           if (entry.isFile()) {
             files.push(entryPath);
           } else if (entry.isDirectory()) {
@@ -3217,13 +3233,13 @@ async function expandMappingToFiles(projectRoot, mappingPaths) {
     }
   }
   for (const mp of mappingPaths) {
-    await collectFiles(path11.join(projectRoot, mp));
+    await collectFiles(path12.join(projectRoot, mp));
   }
   return files;
 }
 async function checkAnchorPresence(graph) {
   const issues = [];
-  const projectRoot = path11.dirname(graph.rootPath);
+  const projectRoot = path12.dirname(graph.rootPath);
   for (const [nodePath, node] of graph.nodes) {
     const aspectsWithAnchors = (node.meta.aspects ?? []).filter((a) => a.anchors && a.anchors.length > 0);
     if (aspectsWithAnchors.length === 0) continue;
@@ -3234,7 +3250,7 @@ async function checkAnchorPresence(graph) {
     const fileContents = [];
     for (const filePath of sourceFiles) {
       try {
-        const content = await readFile13(filePath, "utf-8");
+        const content = await readFile14(filePath, "utf-8");
         fileContents.push(content);
       } catch {
       }
@@ -3343,7 +3359,7 @@ function checkMissingDescriptions(graph) {
 }
 
 // src/cli/owner.ts
-import path12 from "path";
+import path13 from "path";
 import { access as access2 } from "fs/promises";
 function normalizeForMatch(inputPath) {
   return inputPath.replace(/\\/g, "/").replace(/\/+$/, "");
@@ -3373,11 +3389,11 @@ function registerOwnerCommand(program2) {
       const graph = await loadGraph(cwd);
       const repoRoot = projectRootFromGraph(graph.rootPath);
       const rawPath = options.file.trim();
-      const absolute = path12.resolve(cwd, rawPath);
-      const repoRelative = path12.relative(repoRoot, absolute).split(path12.sep).join("/");
+      const absolute = path13.resolve(cwd, rawPath);
+      const repoRelative = path13.relative(repoRoot, absolute).split(path13.sep).join("/");
       const result = findOwner(graph, repoRoot, repoRelative);
       if (!result.nodePath) {
-        const absPath = path12.resolve(repoRoot, result.file);
+        const absPath = path13.resolve(repoRoot, result.file);
         let exists = true;
         try {
           await access2(absPath);
@@ -3430,7 +3446,7 @@ function collectRelevantNodePaths(graph, nodePath) {
   return relevant;
 }
 function registerBuildCommand(program2) {
-  program2.command("build-context").description("Assemble a context package for one node").option("--node <node-path>", "Node path relative to .yggdrasil/model/").option("--file <file-path>", "Source file path \u2014 resolves owner node automatically").option("--full", "Include artifact file contents in output").action(async (options) => {
+  program2.command("build-context").description("Assemble a context package for one node").option("--node <node-path>", "Node path relative to .yggdrasil/model/").option("--file <file-path>", "Source file path \u2014 resolves owner node automatically").option("--full", "Include artifact file contents in output").option("--self", "Only include the node\u2019s own artifacts (no hierarchy, dependencies, aspects, flows)").action(async (options) => {
     try {
       if (!options.node && !options.file) {
         process.stderr.write("Error: either '--node <path>' or '--file <path>' is required\n");
@@ -3478,8 +3494,8 @@ function registerBuildCommand(program2) {
         process.stderr.write(msg);
         process.exit(1);
       }
-      const pkg2 = await buildContext(graph, nodePath);
-      const mapOutput = toContextMapOutput(pkg2, graph);
+      const pkg2 = await buildContext(graph, nodePath, { selfOnly: options.self });
+      const mapOutput = toContextMapOutput(pkg2, graph, { selfOnly: options.self });
       let output = formatContextYaml(mapOutput);
       if (options.full) {
         const seen = /* @__PURE__ */ new Set();
@@ -3601,12 +3617,12 @@ ${errors.length} errors, ${warnings.length} warnings.
 import chalk2 from "chalk";
 
 // src/io/drift-state-store.ts
-import { readFile as readFile14, writeFile as writeFile5, stat as stat5, readdir as readdir6, mkdir as mkdir3, rm as rm2 } from "fs/promises";
-import path13 from "path";
+import { readFile as readFile15, writeFile as writeFile6, stat as stat5, readdir as readdir6, mkdir as mkdir3, rm as rm2 } from "fs/promises";
+import path14 from "path";
 import { parse as yamlParse } from "yaml";
 var DRIFT_STATE_DIR = ".drift-state";
 function nodeStatePath(yggRoot, nodePath) {
-  return path13.join(yggRoot, DRIFT_STATE_DIR, `${nodePath}.json`);
+  return path14.join(yggRoot, DRIFT_STATE_DIR, `${nodePath}.json`);
 }
 async function scanJsonFiles(dir, baseDir) {
   const results = [];
@@ -3617,12 +3633,12 @@ async function scanJsonFiles(dir, baseDir) {
     return results;
   }
   for (const entry of entries) {
-    const fullPath = path13.join(dir, entry.name);
+    const fullPath = path14.join(dir, entry.name);
     if (entry.isDirectory()) {
       const nested = await scanJsonFiles(fullPath, baseDir);
       results.push(...nested);
     } else if (entry.isFile() && entry.name.endsWith(".json")) {
-      const relPath = path13.relative(baseDir, fullPath);
+      const relPath = path14.relative(baseDir, fullPath);
       const nodePath = relPath.replace(/\\/g, "/").replace(/\.json$/, "");
       results.push(nodePath);
     }
@@ -3630,13 +3646,13 @@ async function scanJsonFiles(dir, baseDir) {
   return results;
 }
 async function removeEmptyParents(filePath, stopDir) {
-  let dir = path13.dirname(filePath);
+  let dir = path14.dirname(filePath);
   while (dir !== stopDir && dir.startsWith(stopDir)) {
     try {
       const entries = await readdir6(dir);
       if (entries.length === 0) {
         await rm2(dir, { recursive: true });
-        dir = path13.dirname(dir);
+        dir = path14.dirname(dir);
       } else {
         break;
       }
@@ -3648,7 +3664,7 @@ async function removeEmptyParents(filePath, stopDir) {
 async function readNodeDriftState(yggRoot, nodePath) {
   try {
     const filePath = nodeStatePath(yggRoot, nodePath);
-    const content = await readFile14(filePath, "utf-8");
+    const content = await readFile15(filePath, "utf-8");
     const parsed = JSON.parse(content);
     return parsed;
   } catch {
@@ -3657,12 +3673,12 @@ async function readNodeDriftState(yggRoot, nodePath) {
 }
 async function writeNodeDriftState(yggRoot, nodePath, nodeState) {
   const filePath = nodeStatePath(yggRoot, nodePath);
-  await mkdir3(path13.dirname(filePath), { recursive: true });
+  await mkdir3(path14.dirname(filePath), { recursive: true });
   const content = JSON.stringify(nodeState, null, 2) + "\n";
-  await writeFile5(filePath, content, "utf-8");
+  await writeFile6(filePath, content, "utf-8");
 }
 async function garbageCollectDriftState(yggRoot, validNodePaths) {
-  const driftDir = path13.join(yggRoot, DRIFT_STATE_DIR);
+  const driftDir = path14.join(yggRoot, DRIFT_STATE_DIR);
   const allNodePaths = await scanJsonFiles(driftDir, driftDir);
   const removed = [];
   for (const nodePath of allNodePaths) {
@@ -3676,7 +3692,7 @@ async function garbageCollectDriftState(yggRoot, validNodePaths) {
   return removed.sort();
 }
 async function readDriftState(yggRoot) {
-  const driftPath = path13.join(yggRoot, DRIFT_STATE_DIR);
+  const driftPath = path14.join(yggRoot, DRIFT_STATE_DIR);
   let driftStat;
   try {
     driftStat = await stat5(driftPath);
@@ -3684,7 +3700,7 @@ async function readDriftState(yggRoot) {
     return {};
   }
   if (driftStat.isFile()) {
-    const content = await readFile14(driftPath, "utf-8");
+    const content = await readFile15(driftPath, "utf-8");
     let raw;
     try {
       raw = JSON.parse(content);
@@ -3716,20 +3732,20 @@ async function readDriftState(yggRoot) {
 }
 
 // src/utils/hash.ts
-import { readFile as readFile15, readdir as readdir7, stat as stat6 } from "fs/promises";
-import path14 from "path";
+import { readFile as readFile16, readdir as readdir7, stat as stat6 } from "fs/promises";
+import path15 from "path";
 import { createHash } from "crypto";
 import { createRequire } from "module";
 var require2 = createRequire(import.meta.url);
 var ignoreFactory = require2("ignore");
 async function hashFile(filePath) {
-  const content = await readFile15(filePath);
+  const content = await readFile16(filePath);
   return createHash("sha256").update(content).digest("hex");
 }
 async function loadRootGitignoreStack(projectRoot) {
   if (!projectRoot) return [];
   try {
-    const content = await readFile15(path14.join(projectRoot, ".gitignore"), "utf-8");
+    const content = await readFile16(path15.join(projectRoot, ".gitignore"), "utf-8");
     const matcher = ignoreFactory();
     matcher.add(content);
     return [{ basePath: projectRoot, matcher }];
@@ -3739,7 +3755,7 @@ async function loadRootGitignoreStack(projectRoot) {
 }
 function isIgnoredByStack(candidatePath, stack) {
   for (const { basePath, matcher } of stack) {
-    const relativePath = path14.relative(basePath, candidatePath);
+    const relativePath = path15.relative(basePath, candidatePath);
     if (relativePath === "" || relativePath.startsWith("..")) continue;
     if (matcher.ignores(relativePath) || matcher.ignores(relativePath + "/")) return true;
   }
@@ -3754,7 +3770,7 @@ async function hashTrackedFiles(projectRoot, trackedFiles, storedFileData, exclu
   const gitignoreStack = await loadRootGitignoreStack(projectRoot);
   const allFiles = [];
   for (const tf of trackedFiles) {
-    const absPath = path14.join(projectRoot, tf.path);
+    const absPath = path15.join(projectRoot, tf.path);
     try {
       const st = await stat6(absPath);
       if (st.isDirectory()) {
@@ -3764,7 +3780,7 @@ async function hashTrackedFiles(projectRoot, trackedFiles, storedFileData, exclu
         });
         for (const entry of dirEntries) {
           allFiles.push({
-            relPath: path14.join(tf.path, entry.relPath).replace(/\\/g, "/"),
+            relPath: path15.join(tf.path, entry.relPath).replace(/\\/g, "/"),
             absPath: entry.absPath,
             mtimeMs: entry.mtimeMs
           });
@@ -3804,7 +3820,7 @@ async function hashTrackedFiles(projectRoot, trackedFiles, storedFileData, exclu
 async function collectDirectoryFilePaths(directoryPath, rootDirectoryPath, options) {
   let stack = options.gitignoreStack ?? [];
   try {
-    const localContent = await readFile15(path14.join(directoryPath, ".gitignore"), "utf-8");
+    const localContent = await readFile16(path15.join(directoryPath, ".gitignore"), "utf-8");
     const localMatcher = ignoreFactory();
     localMatcher.add(localContent);
     stack = [...stack, { basePath: directoryPath, matcher: localMatcher }];
@@ -3814,7 +3830,7 @@ async function collectDirectoryFilePaths(directoryPath, rootDirectoryPath, optio
   const dirs = [];
   const files = [];
   for (const entry of entries) {
-    const absoluteChildPath = path14.join(directoryPath, entry.name);
+    const absoluteChildPath = path15.join(directoryPath, entry.name);
     if (isIgnoredByStack(absoluteChildPath, stack)) continue;
     if (entry.isDirectory()) dirs.push(absoluteChildPath);
     else if (entry.isFile()) files.push(absoluteChildPath);
@@ -3827,7 +3843,7 @@ async function collectDirectoryFilePaths(directoryPath, rootDirectoryPath, optio
     Promise.all(files.map(async (f) => {
       const fileStat = await stat6(f);
       return {
-        relPath: path14.relative(rootDirectoryPath, f),
+        relPath: path15.relative(rootDirectoryPath, f),
         absPath: f,
         mtimeMs: fileStat.mtimeMs
       };
@@ -3840,15 +3856,15 @@ async function collectDirectoryFilePaths(directoryPath, rootDirectoryPath, optio
 }
 
 // src/core/context-files.ts
-import path15 from "path";
+import path16 from "path";
 var STRUCTURAL_RELATION_TYPES2 = /* @__PURE__ */ new Set(["uses", "calls", "extends", "implements"]);
 function collectTrackedFiles(node, graph) {
   const seen = /* @__PURE__ */ new Set();
   const result = [];
-  const projectRoot = path15.dirname(graph.rootPath);
-  const yggPrefix = path15.relative(projectRoot, graph.rootPath);
-  const yggPrefixNormalized = yggPrefix.split(path15.sep).join("/");
-  const configArtifactKeys = new Set(Object.keys(graph.config.artifacts ?? {}));
+  const projectRoot = path16.dirname(graph.rootPath);
+  const yggPrefix = path16.relative(projectRoot, graph.rootPath);
+  const yggPrefixNormalized = yggPrefix.split(path16.sep).join("/");
+  const configArtifactKeys = new Set(Object.keys(STANDARD_ARTIFACTS2));
   function addFile(filePath, category) {
     if (seen.has(filePath)) return;
     seen.add(filePath);
@@ -3896,7 +3912,7 @@ function collectTrackedFiles(node, graph) {
     if (!STRUCTURAL_RELATION_TYPES2.has(relation.type)) continue;
     const target = graph.nodes.get(relation.target);
     if (!target) continue;
-    const structuralFilenames = Object.entries(graph.config.artifacts ?? {}).filter(([, c]) => c.included_in_relations).map(([filename]) => filename);
+    const structuralFilenames = Object.entries(STANDARD_ARTIFACTS2).filter(([, c]) => c.included_in_relations).map(([filename]) => filename);
     const structuralArts = structuralFilenames.filter(
       (filename) => target.artifacts.some((a) => a.filename === filename)
     );
@@ -3925,7 +3941,7 @@ function collectTrackedFiles(node, graph) {
     if (relation.type !== "emits" && relation.type !== "listens") continue;
     const target = graph.nodes.get(relation.target);
     if (!target) continue;
-    const structuralFilenames = Object.entries(graph.config.artifacts ?? {}).filter(([, c]) => c.included_in_relations).map(([filename]) => filename);
+    const structuralFilenames = Object.entries(STANDARD_ARTIFACTS2).filter(([, c]) => c.included_in_relations).map(([filename]) => filename);
     const filterFilenames = structuralFilenames.length > 0 ? structuralFilenames : [...configArtifactKeys];
     for (const filename of filterFilenames) {
       if (target.artifacts.some((a) => a.filename === filename)) {
@@ -3960,7 +3976,7 @@ function collectParticipatingFlows2(graph, node, ancestors) {
 
 // src/core/drift-detector.ts
 import { access as access3 } from "fs/promises";
-import path16 from "path";
+import path17 from "path";
 function getChildMappingExclusions(graph, nodePath) {
   const node = graph.nodes.get(nodePath);
   if (!node) return [];
@@ -3982,7 +3998,7 @@ function getChildMappingExclusions(graph, nodePath) {
   return exclusions;
 }
 async function detectDrift(graph, filterNodePath) {
-  const projectRoot = path16.dirname(graph.rootPath);
+  const projectRoot = path17.dirname(graph.rootPath);
   const driftState = await readDriftState(graph.rootPath);
   const entries = [];
   for (const [nodePath, node] of graph.nodes) {
@@ -4065,14 +4081,14 @@ async function detectDrift(graph, filterNodePath) {
   };
 }
 function categorizeFile(filePath, _rootPath, projectRoot) {
-  const yggPrefix = path16.relative(projectRoot, _rootPath);
-  const normalizedPrefix = yggPrefix.split(path16.sep).join("/");
+  const yggPrefix = path17.relative(projectRoot, _rootPath);
+  const normalizedPrefix = yggPrefix.split(path17.sep).join("/");
   const normalizedFilePath = filePath.replace(/\\/g, "/");
   return normalizedFilePath.startsWith(normalizedPrefix) ? "graph" : "source";
 }
 async function allPathsMissing(projectRoot, mappingPaths) {
   for (const mp of mappingPaths) {
-    const absPath = path16.join(projectRoot, mp);
+    const absPath = path17.join(projectRoot, mp);
     try {
       await access3(absPath);
       return false;
@@ -4082,7 +4098,7 @@ async function allPathsMissing(projectRoot, mappingPaths) {
   return true;
 }
 async function syncDriftState(graph, nodePath) {
-  const projectRoot = path16.dirname(graph.rootPath);
+  const projectRoot = path17.dirname(graph.rootPath);
   const node = graph.nodes.get(nodePath);
   if (!node) throw new Error(`Node not found: ${nodePath}`);
   if (!node.meta.mapping) throw new Error(`Node has no mapping: ${nodePath}`);
@@ -4097,7 +4113,7 @@ async function syncDriftState(graph, nodePath) {
   if (previousHash && previousHash !== canonicalHash && existingEntry?.files) {
     let hasSourceChange = false;
     let hasGraphChange = false;
-    const yggPrefix = path16.relative(projectRoot, graph.rootPath).split(path16.sep).join("/");
+    const yggPrefix = path17.relative(projectRoot, graph.rootPath).split(path17.sep).join("/");
     for (const [filePath, hash] of Object.entries(fileHashes)) {
       const storedHash = existingEntry.files[filePath];
       if (storedHash && storedHash === hash) continue;
@@ -4363,7 +4379,7 @@ function registerStatusCommand(program2) {
       const warningCount = validation.issues.filter(
         (issue) => issue.severity === "warning"
       ).length;
-      const configuredArtifactTypes = Object.keys(graph.config.artifacts ?? {});
+      const configuredArtifactTypes = Object.keys(STANDARD_ARTIFACTS2);
       const totalSlots = graph.nodes.size * configuredArtifactTypes.length;
       let filledSlots = 0;
       let mappedNodeCount = 0;
@@ -4437,10 +4453,10 @@ function registerTreeCommand(program2) {
       let roots;
       let showProjectName;
       if (options.root?.trim()) {
-        const path19 = options.root.trim().replace(/\/$/, "");
-        const node = graph.nodes.get(path19);
+        const path20 = options.root.trim().replace(/\/$/, "");
+        const node = graph.nodes.get(path20);
         if (!node) {
-          process.stderr.write(`Error: path '${path19}' not found
+          process.stderr.write(`Error: path '${path20}' not found
 `);
           process.exit(1);
         }
@@ -4485,7 +4501,7 @@ function printNode(node, prefix, isLast, depth, maxDepth) {
 
 // src/core/dependency-resolver.ts
 import { execSync } from "child_process";
-import path17 from "path";
+import path18 from "path";
 var STRUCTURAL_RELATION_TYPES3 = /* @__PURE__ */ new Set(["uses", "calls", "extends", "implements"]);
 var EVENT_RELATION_TYPES2 = /* @__PURE__ */ new Set(["emits", "listens"]);
 function filterRelationType(relType, filter) {
@@ -4562,7 +4578,7 @@ function registerDepsCommand(program2) {
 // src/core/graph-from-git.ts
 import { mkdtemp, rm as rm3 } from "fs/promises";
 import { tmpdir } from "os";
-import path18 from "path";
+import path19 from "path";
 import { execSync as execSync2 } from "child_process";
 async function loadGraphFromRef(projectRoot, ref = "HEAD") {
   const yggPath = ".yggdrasil";
@@ -4573,8 +4589,8 @@ async function loadGraphFromRef(projectRoot, ref = "HEAD") {
     return null;
   }
   try {
-    tmpDir = await mkdtemp(path18.join(tmpdir(), "ygg-git-"));
-    const archivePath = path18.join(tmpDir, "archive.tar");
+    tmpDir = await mkdtemp(path19.join(tmpdir(), "ygg-git-"));
+    const archivePath = path19.join(tmpDir, "archive.tar");
     execSync2(`git archive ${ref} ${yggPath} -o "${archivePath}"`, {
       cwd: projectRoot,
       stdio: "pipe"
@@ -4644,14 +4660,14 @@ function buildTransitiveChains(targetNode, direct, allDependents, reverse) {
   }
   const chains = [];
   for (const node of transitiveOnly) {
-    const path19 = [];
+    const path20 = [];
     let current = node;
     while (current) {
-      path19.unshift(current);
+      path20.unshift(current);
       current = parent.get(current);
     }
-    if (path19.length >= 3) {
-      chains.push(path19.slice(1).map((p) => `<- ${p}`).join(" "));
+    if (path20.length >= 3) {
+      chains.push(path20.slice(1).map((p) => `<- ${p}`).join(" "));
     }
   }
   return chains.sort();
@@ -4695,14 +4711,14 @@ function collectIndirectDependents(graph, directlyAffected) {
     }
     for (const [node] of parent) {
       if (directSet.has(node)) continue;
-      const path19 = [node];
+      const path20 = [node];
       let current = node;
       while (parent.has(current)) {
         current = parent.get(current);
-        path19.push(current);
+        path20.push(current);
       }
-      const chain = path19.map((p) => `<- ${p}`).join(" ");
-      const depth = path19.length;
+      const chain = path20.map((p) => `<- ${p}`).join(" ");
+      const depth = path20.length;
       const existing = bestChain.get(node);
       if (!existing || depth < existing.depth) {
         bestChain.set(node, { chain, depth });