@chrisdudek/yg 1.4.3 → 2.0.0

package/dist/bin.js

@@ -4,35 +4,37 @@
 import { Command } from "commander";
 
 // src/cli/init.ts
-import { mkdir as mkdir2, writeFile as writeFile2, readdir, readFile as readFile2, stat } from "fs/promises";
-import path2 from "path";
+import { mkdir as mkdir2, writeFile as writeFile3, readdir as readdir2, readFile as readFile4, stat as stat2 } from "fs/promises";
+import path4 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 = `name: ""
-
-stack:
-  language: ""
-  runtime: ""
+var DEFAULT_CONFIG = `version: "2.0.0"
 
-standards: ""
+name: ""
 
 node_types:
-  - name: module
-  - name: service
-  - name: library
-  - name: infrastructure
+  module:
+    description: "Business logic unit with clear domain responsibility"
+  service:
+    description: "Component providing functionality to other nodes"
+  library:
+    description: "Shared utility code with no domain knowledge"
+  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"
-    structural_context: true
+    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"
-    structural_context: true
+    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"
@@ -136,7 +138,22 @@ Before preflight:
 
 - Verify \`yg\` CLI is available. If not found, inform user and stop.
 - If \`yg preflight\` shows 0 nodes \u2192 enter BOOTSTRAP MODE (see Operations).
-- If drift report shows >10 drifted nodes \u2192 report scope to user, ask which area to prioritize. Do not resolve all at once.`;
+- If drift report shows >10 drifted nodes \u2192 report scope to user, ask which area to prioritize. Do not resolve all at once.
+
+### Delegating to Subagents
+
+When you delegate work to a subagent (any subprocess, tool agent, or spawned assistant), the subagent does NOT inherit your Yggdrasil knowledge. Before any other instruction, the subagent MUST:
+
+1. Read \`.yggdrasil/agent-rules.md\` \u2014 this is the complete operating manual
+2. Follow the Quick Start Protocol from that file before touching any mapped code
+
+Include this as the FIRST instruction in every subagent prompt:
+
+\`\`\`
+BEFORE doing anything else: read .yggdrasil/agent-rules.md and follow its protocol.
+\`\`\`
+
+A subagent that skips this step will read code without graph context, miss architectural constraints, and produce changes that break graph-code consistency.`;
 var OPERATIONS = `## OPERATIONS
 
 ### Conversation Lifecycle
@@ -220,11 +237,11 @@ Per area checklist:
 
 - [ ] 1. \`yg owner --file <path>\` \u2014 confirm no coverage
 - [ ] 2. Determine node granularity \u2014 propose to user if unclear
-- [ ] 3. Create node directory, read \`schemas/node.yaml\`, create \`node.yaml\`
-- [ ] 4. Analyze source \u2014 for each artifact type in \`config.artifacts\`: extract content, do not invent
-- [ ] 5. Identify relations \u2014 add to \`node.yaml\`
+- [ ] 3. Create node directory, read \`schemas/yg-node.yaml\`, create \`yg-node.yaml\`
+- [ ] 4. Analyze source \u2014 for each artifact type in \`yg-config.yaml artifacts\`: extract content, 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 to \`node.yaml\` \`anchors\` field
+- [ ] 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\`
 - [ ] 7. Identify business process participation \u2014 add to flow, ask user if process unclear
 - [ ] 8. \`yg validate\` \u2014 fix errors
 - [ ] 9. \`yg drift-sync --node <path>\`
@@ -274,7 +291,7 @@ When reviewing graph quality (triggered by user or quality improvement):
 - [ ] 1. \`yg build-context --node <path>\`
 - [ ] 2. Read mapped source files
 - [ ] 3. For each claim in graph: verify against source code
-- [ ] 4. For each aspect: verify the pattern holds in THIS node. If it deviates, add \`aspect_exceptions\` in \`node.yaml\`
+- [ ] 4. For each aspect: verify the pattern holds in THIS node. If it deviates, add \`exceptions\` to the aspect entry in \`yg-node.yaml\`
 - [ ] 5. Report inconsistencies
 
 **Step 2 \u2014 Completeness** (catches MISSING information):
@@ -297,7 +314,7 @@ var KNOWLEDGE_BASE = `## KNOWLEDGE BASE
 
 \`\`\`
 .yggdrasil/
-  config.yaml        \u2190 vocabulary, stack, node types, artifact rules, required aspects
+  yg-config.yaml     \u2190 version, vocabulary, node types, artifact rules, 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
@@ -309,15 +326,10 @@ var KNOWLEDGE_BASE = `## KNOWLEDGE BASE
 Key facts:
 
 - **Hierarchy:** nodes nest in \`model/\`. Children inherit parent context. Do not repeat parent content in children.
-- **Aspect id = directory path** under \`aspects/\`. Each aspect has \`aspect.yaml\` + content \`.md\` files. No automatic parent-child \u2014 use \`implies\` explicitly.
+- **Aspect id = directory path** under \`aspects/\`. Each aspect has \`yg-aspect.yaml\` + content \`.md\` files. No automatic parent-child \u2014 use \`implies\` explicitly.
 - **Flows = business processes.** A flow describes what happens in the world, not code sequences. Flow aspects propagate to all participants.
 
-**Node type guidance:**
-
-- \`module\` \u2014 business logic unit with clear domain responsibility
-- \`service\` \u2014 component providing functionality to other nodes
-- \`library\` \u2014 shared utility code with no domain knowledge
-- \`infrastructure\` \u2014 guards, resolvers, middleware, interceptors, validators that intercept or modify request flow. These affect blast radius of changes but are invisible in call graphs. Map them to make blast radius analysis accurate. Key signal: code that runs WITHOUT being explicitly called by business logic (e.g., NestJS guards, Express middleware, GraphQL resolvers).
+**Node type guidance:** Each type in \`yg-config.yaml node_types\` has a \`description\` that tells you when to use it. Check the project's config for the full list and descriptions. Common types: \`module\` (business logic), \`service\` (providing functionality), \`library\` (shared utilities), \`infrastructure\` (guards, middleware, interceptors \u2014 invisible in call graphs but affect blast radius).
 
 ### Artifact Structure
 
@@ -329,26 +341,28 @@ 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.
+
 ### Context Assembly
 
-Run \`yg build-context --node <path>\` to get the deterministic context package for a node. The package assembles global config, hierarchy, own artifacts, aspects, and relational context. It is your architectural map. For implementation-level claims (exact call patterns, error handling, await vs fire-and-forget) \u2014 verify against source code. If the package is insufficient, enrich the graph.
+Run \`yg build-context --node <path>\` to get the deterministic context package for a node. The package assembles global project identity, hierarchy, own artifacts, aspects, and relational context. It is your architectural map. For implementation-level claims (exact call patterns, error handling, await vs fire-and-forget) \u2014 verify against source code. If the package is insufficient, enrich the graph.
 
 ### Information Routing
 
 When you encounter information, route it to the correct location:
 
-- **Specific to this node** \u2192 local node artifact (check \`config.yaml artifacts\` for available types)
-- **Rule for many nodes** \u2192 aspect (\`aspects/<id>/\` with \`aspect.yaml\` + content \`.md\` files). If applies to ALL nodes of a type \u2192 \`node_types[*].required_aspects\` in \`config.yaml\`
-- **Business process** \u2192 flow (\`flows/<name>/\` with \`flow.yaml\` + \`description.md\`). Ask user if process unclear.
+- **Specific to this node** \u2192 local node artifact (check \`yg-config.yaml artifacts\` for available types)
+- **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.
-- **Technology stack or standard** \u2192 \`config.yaml\` under \`stack\` or \`standards\` (+ \`rationale\` field)
-- **Decision (why + why NOT):** one node \u2192 Decisions section of \`internals.md\` with format "Chose X over Y because Z"; category of nodes \u2192 aspect content files; tech choice \u2192 \`config.yaml\` rationale field. Always include rejected alternatives \u2014 they are the highest-value graph content. If the rationale is unknown: record the decision with "rationale: unknown" and note what CAN be observed from the code. Never invent a plausible-sounding rationale.
+- **Technology stack or standard** \u2192 node artifact at the appropriate hierarchy level (e.g., root node's \`responsibility.md\` for single-stack repos, or deployment unit node for monorepos)
+- **Decision (why + why NOT):** one node \u2192 Decisions section of \`internals.md\` with format "Chose X over Y because Z"; category of nodes \u2192 aspect content files; tech choice \u2192 node artifact at the level where the technology applies. Always include rejected alternatives \u2014 they are the highest-value graph content. If the rationale is unknown: record the decision with "rationale: unknown" and note what CAN be observed from the code. Never invent a plausible-sounding rationale.
 
 ### Creating Aspects
 
-- [ ] 1. Read \`schemas/aspect.yaml\`
+- [ ] 1. Read \`schemas/yg-aspect.yaml\`
 - [ ] 2. Create \`aspects/<id>/\` directory
-- [ ] 3. Write \`aspect.yaml\` \u2014 name, optional description, optional implies
+- [ ] 3. Write \`yg-aspect.yaml\` \u2014 name, optional description, optional implies
 - [ ] 4. Write content \`.md\` files: WHAT must be satisfied + WHY (user's words, do not invent)
 - [ ] 5. \`yg validate\`
 
@@ -360,23 +374,23 @@ Test: "Does this requirement apply to more than one node?" Yes \u2192 aspect. No
 - **Architectural:** Structural patterns with rationale (e.g., dual-rollback on provider failure, idempotency via key generation, fire-and-forget dispatch)
 - **Concurrency:** Shared concurrency strategies (e.g., pessimistic locking, retry-on-deadlock, optimistic versioning)
 
-When a node follows an aspect's pattern with exceptions, record exceptions in \`node.yaml\` under \`aspect_exceptions\`. Example: aspect says "fire-and-forget" but this node awaits the publish call. The exception appears in the context package next to the aspect content, preventing abstractions from masking implementation details.
+When a node follows an aspect's pattern with exceptions, record them in the \`exceptions\` field of the aspect entry in \`yg-node.yaml\`. Example: aspect says "fire-and-forget" but this node awaits the publish call \u2014 add \`exceptions: ["awaits publish call instead of fire-and-forget because..."]\`. Exceptions appear in the context package next to the aspect content, preventing abstractions from masking implementation details.
 
 **Aspect lifecycle warning.** Aspects decay CATASTROPHICALLY \u2014 a pattern either exists or it doesn't. When a pattern changes, ALL aspect claims become wrong at once. This differs from other artifacts: \`interface.md\` and \`responsibility.md\` are most stable (~9-year half-life); \`internals.md\` has moderate stability (~2.5-year half-life); aspects are least stable (~2.4-year half-life, binary decay). After any significant feature addition, review ALL aspects touching the affected area. Don't wait for drift \u2014 aspects can be 100% wrong without any mapped file changing.
 
-**Aspect stability tiers.** If an aspect has a \`stability\` field in \`aspect.yaml\`, use it to calibrate review urgency:
+**Aspect stability tiers.** If an aspect has a \`stability\` field in \`yg-aspect.yaml\`, use it to calibrate review urgency:
 
 - \`schema\` \u2014 enforced by data model; review only when data model changes (most stable)
 - \`protocol\` \u2014 contractual pattern; review when contracts or interfaces change
 - \`implementation\` \u2014 specific mechanism; review after ANY significant code change (least stable)
 
-When code anchors (\`anchors\` field in \`node.yaml\`) are present for an aspect, they list code patterns (function names, constants, SQL fragments) evidencing the aspect's implementation in this node. \`yg validate\` checks that each anchor exists in the node's mapped source files \u2014 a missing anchor (W014) signals the aspect may be stale for this node.
+When code anchors (\`anchors\` in an aspect entry in \`yg-node.yaml\`) are present, they list code patterns (function names, constants, SQL fragments) evidencing the aspect's implementation in this node. \`yg validate\` checks that each anchor exists in the node's mapped source files \u2014 a missing anchor (W014) signals the aspect may be stale for this node.
 
 ### Creating Flows
 
-- [ ] 1. Read \`schemas/flow.yaml\`
+- [ ] 1. Read \`schemas/yg-flow.yaml\`
 - [ ] 2. Create \`flows/<name>/\` directory
-- [ ] 3. Write \`flow.yaml\` \u2014 declare participants and flow-level aspects
+- [ ] 3. Write \`yg-flow.yaml\` \u2014 declare participants and flow-level aspects
 - [ ] 4. Write \`description.md\` with required sections: Business context, Trigger, Goal, Participants, Paths (at least Happy path), Invariants across all paths
 - [ ] 5. \`yg validate\`
 
@@ -387,7 +401,7 @@ Test: "Does this describe what happens in the world, or only in the software?" I
 ### Operational Rules
 
 - **English only** for all files in \`.yggdrasil/\`. Conversation can be any language.
-- **Read schemas before creating** any \`node.yaml\`, \`aspect.yaml\`, or \`flow.yaml\`.
+- **Read schemas before creating** any \`yg-node.yaml\`, \`yg-aspect.yaml\`, or \`yg-flow.yaml\`.
 - **Tools read, you write.** The \`yg\` CLI only reads, validates, and manages metadata. You create and edit files manually.
 - **Incremental sync.** Run \`yg drift-sync\` after every 3-5 source file changes. Do not defer to end of task.
 - **Completeness test:** Two checks, both required:
@@ -427,14 +441,14 @@ yg journal-archive                  Archive consolidated journal entries.
 
 | What you have | Where it goes |
 |---|---|
-| Information specific to this node | Local node artifact (check \`config.yaml artifacts\` for types) |
+| Information specific to this node | Local node artifact (check \`yg-config.yaml artifacts\` for types) |
 | Rule that applies to many nodes | Aspect (content \`.md\` files in \`aspects/<id>/\`) |
-| Architectural invariant for a node type | Required aspect in \`config.yaml node_types\` |
-| Business process participation | Flow (\`flow.yaml participants\`) |
+| Architectural invariant for a node type | Required aspect in \`yg-config.yaml node_types\` |
+| Business process participation | Flow (\`yg-flow.yaml participants\`) |
 | Process-level requirement | Flow \`aspects\` + aspect directory |
 | Context shared across a domain | Parent node artifact |
-| Technology stack | \`config.yaml stack\` (+ \`rationale\` field) |
-| Global coding standards | \`config.yaml standards\` |`;
+| Technology stack | Node artifact at appropriate hierarchy level |
+| Coding standards | Node artifact at appropriate hierarchy level |`;
 var AGENT_RULES_CONTENT = [CORE_PROTOCOL, OPERATIONS, KNOWLEDGE_BASE].join("\n\n---\n\n") + "\n";
 
 // src/templates/platform.ts
@@ -677,11 +691,314 @@ function escapeRegex(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
+// src/core/migrator.ts
+import { readFile as readFile2, access } from "fs/promises";
+import path2 from "path";
+import { parse as parseYaml } from "yaml";
+import { gt, valid, compare } from "semver";
+async function detectVersion(yggRoot) {
+  const newConfigPath = path2.join(yggRoot, "yg-config.yaml");
+  try {
+    const content = await readFile2(newConfigPath, "utf-8");
+    const raw = parseYaml(content);
+    if (raw && typeof raw === "object" && typeof raw.version === "string") {
+      return raw.version.trim();
+    }
+    return "1.4.3";
+  } catch {
+  }
+  const oldConfigPath = path2.join(yggRoot, "config.yaml");
+  try {
+    await access(oldConfigPath);
+    return "1.4.3";
+  } catch {
+    return null;
+  }
+}
+async function runMigrations(currentVersion, migrations, yggRoot) {
+  const cVer = valid(currentVersion);
+  if (!cVer) return [];
+  const applicable = migrations.filter((m) => {
+    const mVer = valid(m.to);
+    if (!mVer) return false;
+    return gt(mVer, cVer);
+  }).sort((a, b) => compare(valid(a.to), valid(b.to)));
+  const results = [];
+  for (const migration of applicable) {
+    const result = await migration.run(yggRoot);
+    results.push(result);
+  }
+  return results;
+}
+
+// src/migrations/to-2.0.0.ts
+import { readFile as readFile3, writeFile as writeFile2, rename, readdir, rm, stat } from "fs/promises";
+import path3 from "path";
+import { parse as parseYaml2, stringify as stringifyYaml } from "yaml";
+var KNOWN_TYPE_DESCRIPTIONS = {
+  module: "Business logic unit with clear domain responsibility",
+  service: "Component providing functionality to other nodes",
+  library: "Shared utility code with no domain knowledge",
+  infrastructure: "Guards, middleware, interceptors \u2014 invisible in call graphs but affect blast radius"
+};
+var STANDARD_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"
+  }
+};
+async function migrateTo2(yggRoot) {
+  const actions = [];
+  const warnings = [];
+  const oldConfigPath = path3.join(yggRoot, "config.yaml");
+  const newConfigPath = path3.join(yggRoot, "yg-config.yaml");
+  let configContent;
+  const oldConfigExists = await fileExists(oldConfigPath);
+  if (oldConfigExists) {
+    configContent = await readFile3(oldConfigPath, "utf-8");
+    await rename(oldConfigPath, newConfigPath);
+    actions.push("Renamed config.yaml \u2192 yg-config.yaml");
+  } else {
+    configContent = await readFile3(newConfigPath, "utf-8");
+  }
+  const raw = parseYaml2(configContent);
+  const nodeTypesRaw = raw.node_types;
+  const nodeTypes = {};
+  if (Array.isArray(nodeTypesRaw)) {
+    for (const typeName of nodeTypesRaw) {
+      if (typeof typeName === "string") {
+        const desc = KNOWN_TYPE_DESCRIPTIONS[typeName];
+        if (desc) {
+          nodeTypes[typeName] = { description: desc };
+        } else {
+          nodeTypes[typeName] = { description: "TODO: add description" };
+          warnings.push(`Unknown node type '${typeName}' \u2014 needs a description`);
+        }
+      }
+    }
+    actions.push("Converted node_types from array to object format");
+  } else if (nodeTypesRaw && typeof nodeTypesRaw === "object") {
+    for (const [name, val] of Object.entries(nodeTypesRaw)) {
+      const entry = val;
+      const desc = KNOWN_TYPE_DESCRIPTIONS[name] ?? (typeof entry?.description === "string" ? entry.description : "TODO: add description");
+      nodeTypes[name] = { description: desc };
+      if (entry?.required_aspects) {
+        nodeTypes[name].required_aspects = entry.required_aspects;
+      }
+      if (!KNOWN_TYPE_DESCRIPTIONS[name] && (!entry?.description || entry.description === "TODO: add description")) {
+        warnings.push(`Unknown node type '${name}' \u2014 needs a description`);
+      }
+    }
+  }
+  if (!nodeTypes.infrastructure) {
+    nodeTypes.infrastructure = { description: KNOWN_TYPE_DESCRIPTIONS.infrastructure };
+    actions.push("Added infrastructure node type");
+  }
+  const stackRaw = raw.stack;
+  const standardsRaw = raw.standards;
+  if (stackRaw || standardsRaw) {
+    await migrateStackStandards(yggRoot, stackRaw, standardsRaw, actions);
+  }
+  const newConfig = {
+    version: "2.0.0",
+    name: raw.name,
+    node_types: nodeTypes,
+    artifacts: STANDARD_ARTIFACTS
+  };
+  if (raw.quality) {
+    newConfig.quality = raw.quality;
+  }
+  await writeFile2(newConfigPath, stringifyYaml(newConfig, { lineWidth: 120 }), "utf-8");
+  actions.push("Updated config: version, artifacts, removed stack/standards");
+  const modelDir = path3.join(yggRoot, "model");
+  if (await fileExists(modelDir)) {
+    await renameFilesRecursively(modelDir, "node.yaml", "yg-node.yaml", actions);
+    await transformNodeFiles(modelDir, actions, warnings);
+  }
+  const aspectsDir = path3.join(yggRoot, "aspects");
+  if (await fileExists(aspectsDir)) {
+    await renameFilesRecursively(aspectsDir, "aspect.yaml", "yg-aspect.yaml", actions);
+  }
+  const flowsDir = path3.join(yggRoot, "flows");
+  if (await fileExists(flowsDir)) {
+    await renameFilesRecursively(flowsDir, "flow.yaml", "yg-flow.yaml", actions);
+  }
+  const schemasDir = path3.join(yggRoot, "schemas");
+  if (await fileExists(schemasDir)) {
+    for (const name of ["config.yaml", "node.yaml", "aspect.yaml", "flow.yaml"]) {
+      const oldPath = path3.join(schemasDir, name);
+      const newPath = path3.join(schemasDir, `yg-${name}`);
+      if (await fileExists(oldPath) && !await fileExists(newPath)) {
+        await rename(oldPath, newPath);
+        actions.push(`Renamed schemas/${name} \u2192 yg-${name}`);
+      }
+    }
+  }
+  const driftStatePath = path3.join(yggRoot, ".drift-state");
+  if (await fileExists(driftStatePath)) {
+    await rm(driftStatePath);
+    actions.push("Deleted .drift-state (requires fresh yg drift-sync --all)");
+  }
+  return { actions, warnings };
+}
+async function fileExists(p) {
+  try {
+    await stat(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function migrateStackStandards(yggRoot, stack, standards, actions) {
+  const modelDir = path3.join(yggRoot, "model");
+  if (!await fileExists(modelDir)) return;
+  const lines = [];
+  if (stack && Object.keys(stack).length > 0) {
+    lines.push("## Technology Stack");
+    lines.push("");
+    for (const [key, value] of Object.entries(stack)) {
+      lines.push(`- **${key}:** ${value}`);
+    }
+    lines.push("");
+  }
+  if (standards) {
+    lines.push("## Standards");
+    lines.push("");
+    lines.push(standards);
+    lines.push("");
+  }
+  if (lines.length === 0) return;
+  const rootNodeYgPath = path3.join(modelDir, "yg-node.yaml");
+  const rootNodeOldPath = path3.join(modelDir, "node.yaml");
+  const hasRootNode = await fileExists(rootNodeYgPath) || await fileExists(rootNodeOldPath);
+  if (!hasRootNode) {
+    await writeFile2(rootNodeYgPath, stringifyYaml({ name: "Root", type: "module" }), "utf-8");
+    await writeFile2(path3.join(modelDir, "responsibility.md"), "TBD\n", "utf-8");
+    actions.push("Created root node in model/ for stack/standards migration");
+  }
+  const internalsPath = path3.join(modelDir, "internals.md");
+  const existingInternals = await fileExists(internalsPath) ? await readFile3(internalsPath, "utf-8") : "";
+  const MIGRATION_MARKER = "<!-- migrated-stack-standards-v2 -->";
+  if (existingInternals.includes(MIGRATION_MARKER)) {
+    return;
+  }
+  const markerLine = MIGRATION_MARKER + "\n";
+  const newContent = existingInternals ? existingInternals.trimEnd() + "\n\n" + markerLine + lines.join("\n") : markerLine + lines.join("\n");
+  await writeFile2(internalsPath, newContent, "utf-8");
+  actions.push("Migrated stack/standards to model/internals.md");
+}
+async function renameFilesRecursively(dir, oldName, newName, actions) {
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const fullPath = path3.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await renameFilesRecursively(fullPath, oldName, newName, actions);
+    } else if (entry.name === oldName) {
+      const destPath = path3.join(dir, newName);
+      if (!await fileExists(destPath)) {
+        await rename(fullPath, destPath);
+        actions.push(`Renamed ${oldName} \u2192 ${newName} in ${dir}`);
+      }
+    }
+  }
+}
+async function transformNodeFiles(dir, actions, warnings) {
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const fullPath = path3.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await transformNodeFiles(fullPath, actions, warnings);
+    } else if (entry.name === "yg-node.yaml") {
+      await transformSingleNode(fullPath, actions, warnings);
+    }
+  }
+}
+async function transformSingleNode(filePath, actions, warnings) {
+  const content = await readFile3(filePath, "utf-8");
+  const raw = parseYaml2(content);
+  if (!raw || typeof raw !== "object") {
+    warnings.push(`Skipped ${filePath}: not a valid YAML object`);
+    return;
+  }
+  let changed = false;
+  if (Array.isArray(raw.aspects) && raw.aspects.length > 0 && typeof raw.aspects[0] === "string") {
+    const aspectExceptions = raw.aspect_exceptions ?? {};
+    const anchors = raw.anchors ?? {};
+    raw.aspects = raw.aspects.map((id) => {
+      const entry = { aspect: id };
+      if (aspectExceptions[id]) entry.exceptions = aspectExceptions[id];
+      if (anchors[id]) entry.anchors = anchors[id];
+      return entry;
+    });
+    delete raw.aspect_exceptions;
+    delete raw.anchors;
+    changed = true;
+  }
+  if (raw.tags !== void 0) {
+    delete raw.tags;
+    changed = true;
+  }
+  if (changed) {
+    await writeFile2(filePath, stringifyYaml(raw, { lineWidth: 120 }), "utf-8");
+    actions.push(`Transformed ${path3.basename(path3.dirname(filePath))}/yg-node.yaml`);
+  }
+}
+
+// src/migrations/index.ts
+var MIGRATIONS = [
+  {
+    to: "2.0.0",
+    description: "Rename YAML files to yg-* prefix, restructure config, convert aspects format",
+    run: migrateTo2
+  }
+];
+
 // src/cli/init.ts
 function getGraphSchemasDir() {
-  const currentDir = path2.dirname(fileURLToPath(import.meta.url));
-  const packageRoot = path2.join(currentDir, "..");
-  return path2.join(packageRoot, "graph-schemas");
+  const currentDir = path4.dirname(fileURLToPath(import.meta.url));
+  const packageRoot = path4.join(currentDir, "..");
+  return path4.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"));
+  return pkg2.version;
+}
+async function refreshSchemas(yggRoot) {
+  const schemasDir = path4.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 writeFile3(path4.join(schemasDir, file), content, "utf-8");
+    }
+  } catch {
+  }
 }
 var GITIGNORE_CONTENT = `.journal.yaml
 .drift-state
@@ -694,10 +1011,10 @@ function registerInitCommand(program2) {
     "generic"
   ).option("--upgrade", "Refresh rules only (when .yggdrasil/ already exists)").action(async (options) => {
     const projectRoot = process.cwd();
-    const yggRoot = path2.join(projectRoot, ".yggdrasil");
+    const yggRoot = path4.join(projectRoot, ".yggdrasil");
     let upgradeMode = false;
     try {
-      const statResult = await stat(yggRoot);
+      const statResult = await stat2(yggRoot);
       if (!statResult.isDirectory()) {
         process.stderr.write("Error: .yggdrasil exists but is not a directory.\n");
         process.exit(1);
@@ -721,25 +1038,58 @@ function registerInitCommand(program2) {
       process.exit(1);
     }
     if (upgradeMode) {
+      const projectVersion = await detectVersion(yggRoot);
+      if (!projectVersion) {
+        process.stderr.write("Error: No Yggdrasil project found. Run `yg init` first.\n");
+        process.exit(1);
+      }
+      const cliVersion = getCliVersion();
+      if (valid2(projectVersion) && valid2(cliVersion) && gt2(projectVersion, cliVersion)) {
+        process.stderr.write(
+          `Warning: Project version (${projectVersion}) is newer than CLI (${cliVersion}). Upgrade your CLI.
+`
+        );
+        process.exit(1);
+      }
+      if (valid2(projectVersion) && valid2(cliVersion) && gt2(cliVersion, projectVersion)) {
+        process.stdout.write(`Migrating from ${projectVersion} to ${cliVersion}...
+
+`);
+        const results = await runMigrations(projectVersion, MIGRATIONS, yggRoot);
+        for (const result of results) {
+          for (const action of result.actions) {
+            process.stdout.write(`  \u2713 ${action}
+`);
+          }
+          for (const warning of result.warnings) {
+            process.stdout.write(`  \u26A0 ${warning}
+`);
+          }
+        }
+        if (results.length > 0) {
+          process.stdout.write("\n");
+        }
+      }
+      await refreshSchemas(yggRoot);
       const rulesPath2 = await installRulesForPlatform(projectRoot, platform);
       process.stdout.write("\u2713 Rules refreshed.\n");
-      process.stdout.write(`  ${path2.relative(projectRoot, rulesPath2)}
+      process.stdout.write(`  ${path4.relative(projectRoot, rulesPath2)}
 `);
       return;
     }
-    await mkdir2(path2.join(yggRoot, "model"), { recursive: true });
-    await mkdir2(path2.join(yggRoot, "aspects"), { recursive: true });
-    await mkdir2(path2.join(yggRoot, "flows"), { recursive: true });
-    const schemasDir = path2.join(yggRoot, "schemas");
+    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(schemasDir, { recursive: true });
     const graphSchemasDir = getGraphSchemasDir();
     try {
-      const entries = await readdir(graphSchemasDir, { withFileTypes: true });
+      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 = path2.join(graphSchemasDir, file);
-        const content = await readFile2(srcPath, "utf-8");
-        await writeFile2(path2.join(schemasDir, file), content, "utf-8");
+        const srcPath = path4.join(graphSchemasDir, file);
+        const content = await readFile4(srcPath, "utf-8");
+        await writeFile3(path4.join(schemasDir, file), content, "utf-8");
       }
     } catch (err) {
       process.stderr.write(
@@ -747,95 +1097,94 @@ function registerInitCommand(program2) {
 `
       );
     }
-    await writeFile2(path2.join(yggRoot, "config.yaml"), DEFAULT_CONFIG, "utf-8");
-    await writeFile2(path2.join(yggRoot, ".gitignore"), GITIGNORE_CONTENT, "utf-8");
+    await writeFile3(path4.join(yggRoot, "yg-config.yaml"), DEFAULT_CONFIG, "utf-8");
+    await writeFile3(path4.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");
-    process.stdout.write("  .yggdrasil/config.yaml\n");
+    process.stdout.write("  .yggdrasil/yg-config.yaml\n");
     process.stdout.write("  .yggdrasil/.gitignore\n");
     process.stdout.write("  .yggdrasil/model/\n");
     process.stdout.write("  .yggdrasil/aspects/\n");
     process.stdout.write("  .yggdrasil/flows/\n");
-    process.stdout.write("  .yggdrasil/schemas/ (config, node, aspect, flow)\n");
-    process.stdout.write(`  ${path2.relative(projectRoot, rulesPath)} (rules)
+    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("Next steps:\n");
-    process.stdout.write("  1. Edit .yggdrasil/config.yaml \u2014 set name, stack, standards\n");
+    process.stdout.write("  1. Edit .yggdrasil/yg-config.yaml \u2014 set name and configure node types\n");
     process.stdout.write("  2. Create nodes under .yggdrasil/model/\n");
     process.stdout.write("  3. Run: yg validate\n");
   });
 }
 
 // src/core/graph-loader.ts
-import { readdir as readdir3, readFile as readFile9 } from "fs/promises";
-import path7 from "path";
+import { readdir as readdir4, readFile as readFile11 } from "fs/promises";
+import path9 from "path";
 
 // src/io/config-parser.ts
-import { readFile as readFile3 } from "fs/promises";
-import { parse as parseYaml } from "yaml";
+import { readFile as readFile5 } from "fs/promises";
+import { parse as parseYaml3 } from "yaml";
 var DEFAULT_QUALITY = {
   min_artifact_length: 50,
   max_direct_relations: 10,
   context_budget: { warning: 1e4, error: 2e4 }
 };
 async function parseConfig(filePath) {
-  const content = await readFile3(filePath, "utf-8");
-  const raw = parseYaml(content);
+  const content = await readFile5(filePath, "utf-8");
+  const raw = parseYaml3(content);
   if (!raw || typeof raw !== "object") {
-    throw new Error(`config.yaml: file is empty or not a valid YAML mapping`);
+    throw new Error(`yg-config.yaml: file is empty or not a valid YAML mapping`);
   }
+  const version = typeof raw.version === "string" ? raw.version.trim() : void 0;
   if (!raw.name || typeof raw.name !== "string" || raw.name.trim() === "") {
-    throw new Error(`config.yaml: missing or invalid 'name' field`);
+    throw new Error(`yg-config.yaml: missing or invalid 'name' field`);
   }
   const nodeTypesRaw = raw.node_types;
-  if (!Array.isArray(nodeTypesRaw) || nodeTypesRaw.length === 0) {
-    throw new Error(`config.yaml: 'node_types' must be a non-empty array`);
+  if (!nodeTypesRaw || typeof nodeTypesRaw !== "object" || Array.isArray(nodeTypesRaw) || Object.keys(nodeTypesRaw).length === 0) {
+    throw new Error(`yg-config.yaml: 'node_types' must be a non-empty object`);
   }
-  const nodeTypes = nodeTypesRaw.map((item) => {
-    if (typeof item === "string") {
-      return { name: item };
-    }
-    if (typeof item === "object" && item !== null && "name" in item && typeof item.name === "string") {
-      const obj = item;
-      const requiredAspects = Array.isArray(obj.required_aspects) ? obj.required_aspects.filter((t) => typeof t === "string") : Array.isArray(obj.required_tags) ? obj.required_tags.filter((t) => typeof t === "string") : void 0;
-      return {
-        name: obj.name,
-        required_aspects: requiredAspects && requiredAspects.length > 0 ? requiredAspects : void 0
-      };
+  const nodeTypes = {};
+  for (const [typeName, val] of Object.entries(nodeTypesRaw)) {
+    const entry = val;
+    if (!entry || typeof entry !== "object" || typeof entry.description !== "string" || entry.description.trim() === "") {
+      throw new Error(
+        `yg-config.yaml: node_types.${typeName} must have a non-empty 'description' string`
+      );
     }
-    throw new Error(
-      `config.yaml: node_types entry must be string or { name, required_aspects? }`
-    );
-  });
+    const requiredAspects = Array.isArray(entry.required_aspects) ? entry.required_aspects.filter((t) => typeof t === "string") : void 0;
+    nodeTypes[typeName] = {
+      description: entry.description,
+      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(`config.yaml: 'artifacts' must be a non-empty object`);
+    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 === "node.yaml") {
-      throw new Error(`config.yaml: artifact name 'node.yaml' is reserved`);
+    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(`config.yaml: artifact '${key}' has invalid 'required' field`);
+      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(
-          `config.yaml: artifact '${key}' has invalid 'required.when': must be has_incoming_relations, has_outgoing_relations, or has_aspect:<name>`
+          `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 ?? "",
-      structural_context: a.structural_context ?? false
+      included_in_relations: a.included_in_relations ?? false
     };
   }
   const qualityRaw = raw.quality;
@@ -849,13 +1198,12 @@ async function parseConfig(filePath) {
   } : DEFAULT_QUALITY;
   if (quality.context_budget.error < quality.context_budget.warning) {
     throw new Error(
-      `config.yaml: quality.context_budget.error (${quality.context_budget.error}) must be >= warning (${quality.context_budget.warning})`
+      `yg-config.yaml: quality.context_budget.error (${quality.context_budget.error}) must be >= warning (${quality.context_budget.warning})`
     );
   }
   return {
+    version,
     name: raw.name.trim(),
-    stack: raw.stack ?? {},
-    standards: typeof raw.standards === "string" ? raw.standards : "",
     node_types: nodeTypes,
     artifacts: artifactsMap,
     quality
@@ -863,8 +1211,8 @@ async function parseConfig(filePath) {
 }
 
 // src/io/node-parser.ts
-import { readFile as readFile4 } from "fs/promises";
-import { parse as parseYaml2 } from "yaml";
+import { readFile as readFile6 } from "fs/promises";
+import { parse as parseYaml4 } from "yaml";
 var RELATION_TYPES = [
   "uses",
   "calls",
@@ -877,120 +1225,103 @@ function isValidRelationType(t) {
   return typeof t === "string" && RELATION_TYPES.includes(t);
 }
 async function parseNodeYaml(filePath) {
-  const content = await readFile4(filePath, "utf-8");
-  const raw = parseYaml2(content);
+  const content = await readFile6(filePath, "utf-8");
+  const raw = parseYaml4(content);
   if (!raw || typeof raw !== "object") {
-    throw new Error(`node.yaml at ${filePath}: file is empty or not a valid YAML mapping`);
+    throw new Error(`yg-node.yaml at ${filePath}: file is empty or not a valid YAML mapping`);
   }
   if (!raw.name || typeof raw.name !== "string" || raw.name.trim() === "") {
-    throw new Error(`node.yaml at ${filePath}: missing or empty 'name'`);
+    throw new Error(`yg-node.yaml at ${filePath}: missing or empty 'name'`);
   }
   if (!raw.type || typeof raw.type !== "string" || raw.type.trim() === "") {
-    throw new Error(`node.yaml at ${filePath}: missing or empty 'type'`);
+    throw new Error(`yg-node.yaml at ${filePath}: missing or empty 'type'`);
   }
   const relations = parseRelations(raw.relations, filePath);
   const mapping = parseMapping(raw.mapping, filePath);
-  const aspects = parseStringArray(raw.aspects) ?? parseStringArray(raw.tags);
-  const aspectExceptions = parseAspectExceptions(raw.aspect_exceptions, aspects, filePath);
-  const anchors = parseAnchors(raw.anchors, filePath);
+  const aspects = parseAspects(raw.aspects, filePath);
   return {
     name: raw.name.trim(),
     type: raw.type.trim(),
     aspects,
-    aspect_exceptions: aspectExceptions,
     blackbox: raw.blackbox ?? false,
     relations: relations.length > 0 ? relations : void 0,
-    mapping,
-    anchors
+    mapping
   };
 }
-function parseAnchors(raw, filePath) {
-  if (raw === void 0 || raw === null) return void 0;
-  if (typeof raw !== "object" || Array.isArray(raw)) {
-    throw new Error(
-      `node.yaml at ${filePath}: 'anchors' must be an object mapping aspect ids to arrays of strings`
-    );
-  }
-  const obj = raw;
-  const entries = Object.entries(obj);
-  if (entries.length === 0) return void 0;
-  const result = {};
-  for (const [key, value] of entries) {
-    if (!Array.isArray(value) || value.length === 0) {
-      throw new Error(
-        `node.yaml at ${filePath}: 'anchors.${key}' must be a non-empty array of strings`
-      );
-    }
-    const strings = value.filter((v) => typeof v === "string");
-    if (strings.length === 0) {
-      throw new Error(
-        `node.yaml at ${filePath}: 'anchors.${key}' must be a non-empty array of strings`
-      );
-    }
-    result[key] = strings;
-  }
-  return result;
-}
-function parseAspectExceptions(raw, aspects, filePath) {
+function parseAspects(raw, filePath) {
   if (raw === void 0 || raw === null) return void 0;
   if (!Array.isArray(raw)) {
-    throw new Error(`node.yaml at ${filePath}: 'aspect_exceptions' must be an array`);
+    throw new Error(`yg-node.yaml at ${filePath}: 'aspects' must be an array`);
   }
   if (raw.length === 0) return void 0;
-  const aspectSet = new Set(aspects ?? []);
   const result = [];
+  const seenAspects = /* @__PURE__ */ new Set();
   for (let i = 0; i < raw.length; i++) {
     const item = raw[i];
     if (typeof item !== "object" || item === null) {
-      throw new Error(`node.yaml at ${filePath}: aspect_exceptions[${i}] must be an object`);
+      throw new Error(`yg-node.yaml at ${filePath}: aspects[${i}] must be an object with 'aspect' key`);
     }
     const obj = item;
     if (typeof obj.aspect !== "string" || obj.aspect.trim() === "") {
       throw new Error(
-        `node.yaml at ${filePath}: aspect_exceptions[${i}].aspect must be a non-empty string`
-      );
-    }
-    if (typeof obj.note !== "string" || obj.note.trim() === "") {
-      throw new Error(
-        `node.yaml at ${filePath}: aspect_exceptions[${i}].note must be a non-empty string`
+        `yg-node.yaml at ${filePath}: aspects[${i}].aspect must be a non-empty string`
       );
     }
     const aspectId = obj.aspect.trim();
-    if (!aspectSet.has(aspectId)) {
+    if (seenAspects.has(aspectId)) {
       throw new Error(
-        `node.yaml at ${filePath}: aspect_exceptions[${i}].aspect "${aspectId}" is not in this node's aspects list`
+        `yg-node.yaml at ${filePath}: duplicate aspect '${aspectId}' in aspects list`
       );
     }
-    result.push({ aspect: aspectId, note: obj.note.trim() });
+    seenAspects.add(aspectId);
+    const entry = { aspect: aspectId };
+    if (obj.exceptions !== void 0 && obj.exceptions !== null) {
+      if (!Array.isArray(obj.exceptions)) {
+        throw new Error(
+          `yg-node.yaml at ${filePath}: aspects[${i}].exceptions must be an array of strings`
+        );
+      }
+      const exceptions = obj.exceptions.filter((e) => typeof e === "string" && e.trim() !== "");
+      if (exceptions.length > 0) {
+        entry.exceptions = exceptions;
+      }
+    }
+    if (obj.anchors !== void 0 && obj.anchors !== null) {
+      if (!Array.isArray(obj.anchors)) {
+        throw new Error(
+          `yg-node.yaml at ${filePath}: aspects[${i}].anchors must be an array of strings`
+        );
+      }
+      const anchors = obj.anchors.filter((a) => typeof a === "string" && a.trim() !== "");
+      if (anchors.length > 0) {
+        entry.anchors = anchors;
+      }
+    }
+    result.push(entry);
   }
   return result.length > 0 ? result : void 0;
 }
-function parseStringArray(val) {
-  if (!Array.isArray(val)) return void 0;
-  const arr = val.filter((v) => typeof v === "string");
-  return arr.length > 0 ? arr : void 0;
-}
 function parseRelations(raw, filePath) {
   if (raw === void 0) return [];
   if (!Array.isArray(raw)) {
-    throw new Error(`node.yaml at ${filePath}: 'relations' must be an array`);
+    throw new Error(`yg-node.yaml at ${filePath}: 'relations' must be an array`);
   }
   const result = [];
   for (let index = 0; index < raw.length; index++) {
     const r = raw[index];
     if (typeof r !== "object" || r === null) {
-      throw new Error(`node.yaml at ${filePath}: relations[${index}] must be an object`);
+      throw new Error(`yg-node.yaml at ${filePath}: relations[${index}] must be an object`);
     }
     const obj = r;
     const target = obj.target;
     const type = obj.type;
     if (typeof target !== "string" || target.trim() === "") {
       throw new Error(
-        `node.yaml at ${filePath}: relations[${index}].target must be a non-empty string`
+        `yg-node.yaml at ${filePath}: relations[${index}].target must be a non-empty string`
       );
     }
     if (!isValidRelationType(type)) {
-      throw new Error(`node.yaml at ${filePath}: relations[${index}].type is invalid`);
+      throw new Error(`yg-node.yaml at ${filePath}: relations[${index}].type is invalid`);
     }
     const rel = {
       target: target.trim(),
@@ -1012,10 +1343,10 @@ function parseRelations(raw, filePath) {
 function validateRelativePath(pathValue, filePath, fieldName) {
   const normalized = pathValue.trim();
   if (normalized === "") {
-    throw new Error(`node.yaml at ${filePath}: '${fieldName}' must be non-empty`);
+    throw new Error(`yg-node.yaml at ${filePath}: '${fieldName}' must be non-empty`);
   }
   if (normalized.startsWith("/")) {
-    throw new Error(`node.yaml at ${filePath}: '${fieldName}' must be relative to repository root`);
+    throw new Error(`yg-node.yaml at ${filePath}: '${fieldName}' must be relative to repository root`);
   }
   return normalized;
 }
@@ -1025,35 +1356,35 @@ function parseMapping(rawMapping, filePath) {
   if (Array.isArray(obj.paths) && obj.paths.length > 0) {
     const paths = obj.paths.filter((p) => typeof p === "string").map((p) => validateRelativePath(p, filePath, "mapping.paths[]"));
     if (paths.length === 0) {
-      throw new Error(`node.yaml at ${filePath}: mapping.paths must be a non-empty array`);
+      throw new Error(`yg-node.yaml at ${filePath}: mapping.paths must be a non-empty array`);
     }
     return { paths };
   }
   if (obj.paths !== void 0 || obj.type !== void 0 || obj.path !== void 0) {
     throw new Error(
-      `node.yaml at ${filePath}: mapping must have paths (array of file/directory paths)`
+      `yg-node.yaml at ${filePath}: mapping must have paths (array of file/directory paths)`
     );
   }
   return void 0;
 }
 
 // src/io/aspect-parser.ts
-import { readFile as readFile6 } from "fs/promises";
-import { parse as parseYaml3 } from "yaml";
+import { readFile as readFile8 } from "fs/promises";
+import { parse as parseYaml5 } from "yaml";
 
 // src/io/artifact-reader.ts
-import { readFile as readFile5, readdir as readdir2 } from "fs/promises";
-import path3 from "path";
-async function readArtifacts(dirPath, excludeFiles = ["node.yaml"], includeFiles) {
-  const entries = await readdir2(dirPath, { withFileTypes: true });
+import { readFile as readFile7, readdir as readdir3 } from "fs/promises";
+import path5 from "path";
+async function readArtifacts(dirPath, excludeFiles = ["yg-node.yaml"], includeFiles) {
+  const entries = await readdir3(dirPath, { withFileTypes: true });
   const artifacts = [];
   const includeSet = includeFiles && includeFiles.length > 0 ? new Set(includeFiles) : null;
   for (const entry of entries) {
     if (!entry.isFile()) continue;
     if (excludeFiles.includes(entry.name)) continue;
     if (includeSet && !includeSet.has(entry.name)) continue;
-    const filePath = path3.join(dirPath, entry.name);
-    const content = await readFile5(filePath, "utf-8");
+    const filePath = path5.join(dirPath, entry.name);
+    const content = await readFile7(filePath, "utf-8");
     artifacts.push({ filename: entry.name, content });
   }
   artifacts.sort((a, b) => a.filename.localeCompare(b.filename));
@@ -1067,8 +1398,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 readFile6(aspectYamlPath, "utf-8");
-  const raw = parseYaml3(content);
+  const content = await readFile8(aspectYamlPath, "utf-8");
+  const raw = parseYaml5(content);
   if (!raw || typeof raw !== "object") {
     throw new Error(`Aspect file ${aspectYamlPath}: file is empty or not a valid YAML mapping`);
   }
@@ -1076,7 +1407,7 @@ async function parseAspect(aspectDir, aspectYamlPath, id) {
     throw new Error(`Aspect file ${aspectYamlPath}: missing or empty 'name'`);
   }
   const description = typeof raw.description === "string" ? raw.description.trim() : void 0;
-  const artifacts = await readArtifacts(aspectDir, ["aspect.yaml"]);
+  const artifacts = await readArtifacts(aspectDir, ["yg-aspect.yaml"]);
   let implies;
   if (raw.implies !== void 0) {
     if (!Array.isArray(raw.implies)) {
@@ -1104,37 +1435,37 @@ async function parseAspect(aspectDir, aspectYamlPath, id) {
 }
 
 // src/io/flow-parser.ts
-import { readFile as readFile7 } from "fs/promises";
-import path4 from "path";
-import { parse as parseYaml4 } from "yaml";
+import { readFile as readFile9 } from "fs/promises";
+import path6 from "path";
+import { parse as parseYaml6 } from "yaml";
 async function parseFlow(flowDir, flowYamlPath) {
-  const content = await readFile7(flowYamlPath, "utf-8");
-  const raw = parseYaml4(content);
+  const content = await readFile9(flowYamlPath, "utf-8");
+  const raw = parseYaml6(content);
   if (!raw || typeof raw !== "object") {
-    throw new Error(`flow.yaml at ${flowYamlPath}: file is empty or not a valid YAML mapping`);
+    throw new Error(`yg-flow.yaml at ${flowYamlPath}: file is empty or not a valid YAML mapping`);
   }
   if (!raw.name || typeof raw.name !== "string" || raw.name.trim() === "") {
-    throw new Error(`flow.yaml at ${flowYamlPath}: missing or empty 'name'`);
+    throw new Error(`yg-flow.yaml at ${flowYamlPath}: missing or empty 'name'`);
   }
   const nodes = raw.nodes;
   if (!Array.isArray(nodes) || nodes.length === 0) {
-    throw new Error(`flow.yaml at ${flowYamlPath}: 'nodes' must be a non-empty array`);
+    throw new Error(`yg-flow.yaml at ${flowYamlPath}: 'nodes' must be a non-empty array`);
   }
   const nodePaths = nodes.filter((n) => typeof n === "string");
   if (nodePaths.length === 0) {
-    throw new Error(`flow.yaml at ${flowYamlPath}: 'nodes' must contain string node paths`);
+    throw new Error(`yg-flow.yaml at ${flowYamlPath}: 'nodes' must contain string node paths`);
   }
   let aspects;
   if (raw.aspects !== void 0) {
     if (!Array.isArray(raw.aspects)) {
-      throw new Error(`flow.yaml at ${flowYamlPath}: 'aspects' must be an array of strings`);
+      throw new Error(`yg-flow.yaml at ${flowYamlPath}: 'aspects' must be an array of strings`);
     }
     const aspectTags = raw.aspects.filter((a) => typeof a === "string");
     aspects = aspectTags.length > 0 ? aspectTags : [];
   }
-  const artifacts = await readArtifacts(flowDir, ["flow.yaml"]);
+  const artifacts = await readArtifacts(flowDir, ["yg-flow.yaml"]);
   return {
-    path: path4.basename(flowDir),
+    path: path6.basename(flowDir),
     name: raw.name.trim(),
     nodes: nodePaths,
     ...aspects !== void 0 && { aspects },
@@ -1143,27 +1474,28 @@ async function parseFlow(flowDir, flowYamlPath) {
 }
 
 // src/io/schema-parser.ts
-import { readFile as readFile8 } from "fs/promises";
-import path5 from "path";
-import { parse as parseYaml5 } from "yaml";
+import { readFile as readFile10 } from "fs/promises";
+import path7 from "path";
+import { parse as parseYaml7 } from "yaml";
 async function parseSchema(filePath) {
-  const content = await readFile8(filePath, "utf-8");
-  parseYaml5(content);
-  const schemaType = path5.basename(filePath, path5.extname(filePath));
+  const content = await readFile10(filePath, "utf-8");
+  parseYaml7(content);
+  const rawName = path7.basename(filePath, path7.extname(filePath));
+  const schemaType = rawName.startsWith("yg-") ? rawName.slice(3) : rawName;
   return { schemaType };
 }
 
 // src/utils/paths.ts
-import path6 from "path";
+import path8 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { stat as stat2 } from "fs/promises";
+import { stat as stat3 } from "fs/promises";
 async function findYggRoot(projectRoot) {
-  let current = path6.resolve(projectRoot);
-  const root = path6.parse(current).root;
+  let current = path8.resolve(projectRoot);
+  const root = path8.parse(current).root;
   while (true) {
-    const yggPath = path6.join(current, ".yggdrasil");
+    const yggPath = path8.join(current, ".yggdrasil");
     try {
-      const st = await stat2(yggPath);
+      const st = await stat3(yggPath);
       if (!st.isDirectory()) {
         throw new Error(
           `.yggdrasil exists but is not a directory (${yggPath}). Run 'yg init' in a clean location.`
@@ -1175,7 +1507,7 @@ async function findYggRoot(projectRoot) {
         if (current === root) {
           throw new Error(`No .yggdrasil/ directory found. Run 'yg init' first.`, { cause: err });
         }
-        current = path6.dirname(current);
+        current = path8.dirname(current);
         continue;
       }
       throw err;
@@ -1191,27 +1523,25 @@ function normalizeProjectRelativePath(projectRoot, rawPath) {
   if (normalizedInput.length === 0) {
     throw new Error("Path cannot be empty");
   }
-  const absolute = path6.resolve(projectRoot, normalizedInput);
-  const relative = path6.relative(projectRoot, absolute);
-  const isOutside = relative.startsWith("..") || path6.isAbsolute(relative);
+  const absolute = path8.resolve(projectRoot, normalizedInput);
+  const relative = path8.relative(projectRoot, absolute);
+  const isOutside = relative.startsWith("..") || path8.isAbsolute(relative);
   if (isOutside) {
     throw new Error(`Path is outside project root: ${rawPath}`);
   }
-  return relative.split(path6.sep).join("/");
+  return relative.split(path8.sep).join("/");
 }
 function projectRootFromGraph(yggRootPath) {
-  return path6.dirname(yggRootPath);
+  return path8.dirname(yggRootPath);
 }
 
 // src/core/graph-loader.ts
 function toModelPath(absolutePath, modelDir) {
-  return path7.relative(modelDir, absolutePath).split(path7.sep).join("/");
+  return path9.relative(modelDir, absolutePath).split(path9.sep).join("/");
 }
 var FALLBACK_CONFIG = {
   name: "",
-  stack: {},
-  standards: "",
-  node_types: [],
+  node_types: {},
   artifacts: {}
 };
 async function loadGraph(projectRoot, options = {}) {
@@ -1219,14 +1549,14 @@ async function loadGraph(projectRoot, options = {}) {
   let configError;
   let config = FALLBACK_CONFIG;
   try {
-    config = await parseConfig(path7.join(yggRoot, "config.yaml"));
+    config = await parseConfig(path9.join(yggRoot, "yg-config.yaml"));
   } catch (error) {
     if (!options.tolerateInvalidConfig) {
       throw error;
     }
     configError = error.message;
   }
-  const modelDir = path7.join(yggRoot, "model");
+  const modelDir = path9.join(yggRoot, "model");
   const nodes = /* @__PURE__ */ new Map();
   const nodeParseErrors = [];
   const artifactFilenames = Object.keys(config.artifacts ?? {});
@@ -1240,9 +1570,9 @@ async function loadGraph(projectRoot, options = {}) {
     }
     throw err;
   }
-  const aspects = await loadAspects(path7.join(yggRoot, "aspects"));
-  const flows = await loadFlows(path7.join(yggRoot, "flows"));
-  const schemas = await loadSchemas(path7.join(yggRoot, "schemas"));
+  const aspects = await loadAspects(path9.join(yggRoot, "aspects"));
+  const flows = await loadFlows(path9.join(yggRoot, "flows"));
+  const schemas = await loadSchemas(path9.join(yggRoot, "schemas"));
   return {
     config,
     configError,
@@ -1255,18 +1585,18 @@ async function loadGraph(projectRoot, options = {}) {
   };
 }
 async function scanModelDirectory(dirPath, modelDir, parent, nodes, nodeParseErrors, artifactFilenames) {
-  const entries = await readdir3(dirPath, { withFileTypes: true });
-  const hasNodeYaml = entries.some((e) => e.isFile() && e.name === "node.yaml");
+  const entries = await readdir4(dirPath, { withFileTypes: true });
+  const hasNodeYaml = entries.some((e) => e.isFile() && e.name === "yg-node.yaml");
   if (!hasNodeYaml && dirPath !== modelDir) {
     return;
   }
   if (hasNodeYaml) {
     const graphPath = toModelPath(dirPath, modelDir);
-    const nodeYamlPath = path7.join(dirPath, "node.yaml");
+    const nodeYamlPath = path9.join(dirPath, "yg-node.yaml");
     let meta;
     let nodeYamlRaw;
     try {
-      nodeYamlRaw = await readFile9(nodeYamlPath, "utf-8");
+      nodeYamlRaw = await readFile11(nodeYamlPath, "utf-8");
       meta = await parseNodeYaml(nodeYamlPath);
     } catch (err) {
       nodeParseErrors.push({
@@ -1275,7 +1605,7 @@ async function scanModelDirectory(dirPath, modelDir, parent, nodes, nodeParseErr
       });
       return;
     }
-    const artifacts = await readArtifacts(dirPath, ["node.yaml"], artifactFilenames);
+    const artifacts = await readArtifacts(dirPath, ["yg-node.yaml"], artifactFilenames);
     const node = {
       path: graphPath,
       meta,
@@ -1292,7 +1622,7 @@ async function scanModelDirectory(dirPath, modelDir, parent, nodes, nodeParseErr
       if (!entry.isDirectory()) continue;
       if (entry.name.startsWith(".")) continue;
       await scanModelDirectory(
-        path7.join(dirPath, entry.name),
+        path9.join(dirPath, entry.name),
         modelDir,
         node,
         nodes,
@@ -1305,7 +1635,7 @@ async function scanModelDirectory(dirPath, modelDir, parent, nodes, nodeParseErr
       if (!entry.isDirectory()) continue;
       if (entry.name.startsWith(".")) continue;
       await scanModelDirectory(
-        path7.join(dirPath, entry.name),
+        path9.join(dirPath, entry.name),
         modelDir,
         null,
         nodes,
@@ -1325,28 +1655,28 @@ async function loadAspects(aspectsDir) {
   }
 }
 async function scanAspectsDirectory(dirPath, aspectsRoot, aspects) {
-  const entries = await readdir3(dirPath, { withFileTypes: true });
-  const hasAspectYaml = entries.some((e) => e.isFile() && e.name === "aspect.yaml");
+  const entries = await readdir4(dirPath, { withFileTypes: true });
+  const hasAspectYaml = entries.some((e) => e.isFile() && e.name === "yg-aspect.yaml");
   if (hasAspectYaml) {
-    const id = path7.relative(aspectsRoot, dirPath).split(path7.sep).join("/");
-    const aspectYamlPath = path7.join(dirPath, "aspect.yaml");
+    const id = path9.relative(aspectsRoot, dirPath).split(path9.sep).join("/");
+    const aspectYamlPath = path9.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(path7.join(dirPath, entry.name), aspectsRoot, aspects);
+    await scanAspectsDirectory(path9.join(dirPath, entry.name), aspectsRoot, aspects);
   }
 }
 async function loadFlows(flowsDir) {
   try {
-    const entries = await readdir3(flowsDir, { withFileTypes: true });
+    const entries = await readdir4(flowsDir, { withFileTypes: true });
     const flows = [];
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const flowYamlPath = path7.join(flowsDir, entry.name, "flow.yaml");
-      const flow = await parseFlow(path7.join(flowsDir, entry.name), flowYamlPath);
+      const flowYamlPath = path9.join(flowsDir, entry.name, "yg-flow.yaml");
+      const flow = await parseFlow(path9.join(flowsDir, entry.name), flowYamlPath);
       flows.push(flow);
     }
     return flows;
@@ -1356,12 +1686,12 @@ async function loadFlows(flowsDir) {
 }
 async function loadSchemas(schemasDir) {
   try {
-    const entries = await readdir3(schemasDir, { withFileTypes: true });
+    const entries = await readdir4(schemasDir, { withFileTypes: true });
     const schemas = [];
     for (const entry of entries) {
       if (!entry.isFile()) continue;
       if (!entry.name.endsWith(".yaml") && !entry.name.endsWith(".yml")) continue;
-      const s = await parseSchema(path7.join(schemasDir, entry.name));
+      const s = await parseSchema(path9.join(schemasDir, entry.name));
       schemas.push(s);
     }
     return schemas;
@@ -1371,8 +1701,8 @@ async function loadSchemas(schemasDir) {
 }
 
 // src/core/context-builder.ts
-import { readFile as readFile10 } from "fs/promises";
-import path8 from "path";
+import { readFile as readFile12 } from "fs/promises";
+import path10 from "path";
 
 // src/utils/tokens.ts
 function estimateTokens(text) {
@@ -1421,8 +1751,9 @@ async function buildContext(graph, nodePath) {
   }
   const aspectsToInclude = resolveAspects(allAspectIds, graph.aspects);
   for (const aspect of aspectsToInclude) {
-    const exception = node.meta.aspect_exceptions?.find((e) => e.aspect === aspect.id);
-    layers.push(buildAspectLayer(aspect, exception?.note));
+    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);
@@ -1479,18 +1810,7 @@ function resolveAspects(aspectIds, aspects) {
   return expandedIds.map((id) => idToAspect.get(id)).filter((a) => a !== void 0);
 }
 function buildGlobalLayer(config) {
-  let content = `**Project:** ${config.name}
-
-`;
-  content += `**Stack:**
-`;
-  for (const [key, value] of Object.entries(config.stack)) {
-    content += `- ${key}: ${value}
-`;
-  }
-  content += `
-**Standards:**
-${config.standards || "(none)"}
+  const content = `**Project:** ${config.name}
 `;
   return { type: "global", label: "Global Context", content };
 }
@@ -1502,7 +1822,7 @@ function buildHierarchyLayer(ancestor, config, graph) {
   const filtered = filterArtifactsByConfig(ancestor.artifacts, config);
   const content = filtered.map((a) => `### ${a.filename}
 ${a.content}`).join("\n\n");
-  const nodeAspects = ancestor.meta.aspects ?? [];
+  const nodeAspects = (ancestor.meta.aspects ?? []).map((a) => a.aspect);
   const expanded = expandAspects(nodeAspects, graph.aspects);
   const attrs = expanded.length > 0 ? { aspects: expanded.join(",") } : void 0;
   return {
@@ -1515,16 +1835,16 @@ ${a.content}`).join("\n\n");
 async function buildOwnLayer(node, config, graphRootPath, graph) {
   const parts = [];
   if (node.nodeYamlRaw) {
-    parts.push(`### node.yaml
+    parts.push(`### yg-node.yaml
 ${node.nodeYamlRaw.trim()}`);
   } else {
-    const nodeYamlPath = path8.join(graphRootPath, "model", node.path, "node.yaml");
+    const nodeYamlPath = path10.join(graphRootPath, "model", node.path, "yg-node.yaml");
     try {
-      const nodeYamlContent = await readFile10(nodeYamlPath, "utf-8");
-      parts.push(`### node.yaml
+      const nodeYamlContent = await readFile12(nodeYamlPath, "utf-8");
+      parts.push(`### yg-node.yaml
 ${nodeYamlContent.trim()}`);
     } catch {
-      parts.push(`### node.yaml
+      parts.push(`### yg-node.yaml
 (not found)`);
     }
   }
@@ -1534,7 +1854,7 @@ ${nodeYamlContent.trim()}`);
 ${a.content}`);
   }
   const content = parts.join("\n\n");
-  const nodeAspects = node.meta.aspects ?? [];
+  const nodeAspects = (node.meta.aspects ?? []).map((a) => a.aspect);
   const expanded = expandAspects(nodeAspects, graph.aspects);
   const attrs = expanded.length > 0 ? { aspects: expanded.join(",") } : void 0;
   return {
@@ -1556,7 +1876,7 @@ function buildStructuralRelationLayer(target, relation, config) {
 
 `;
   }
-  const structuralArtifactFilenames = Object.entries(config.artifacts ?? {}).filter(([, c]) => c.structural_context).map(([filename]) => filename);
+  const structuralArtifactFilenames = Object.entries(config.artifacts ?? {}).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;
@@ -1671,10 +1991,10 @@ function collectAncestors(node) {
 function collectEffectiveAspectIds(graph, nodePath) {
   const node = graph.nodes.get(nodePath);
   if (!node) return /* @__PURE__ */ new Set();
-  const raw = new Set(node.meta.aspects ?? []);
+  const raw = new Set((node.meta.aspects ?? []).map((a) => a.aspect));
   let ancestor = node.parent;
   while (ancestor) {
-    for (const id of ancestor.meta.aspects ?? []) raw.add(id);
+    for (const entry of ancestor.meta.aspects ?? []) raw.add(entry.aspect);
     ancestor = ancestor.parent;
   }
   const ancestorPaths = /* @__PURE__ */ new Set([nodePath, ...collectAncestors(node).map((a) => a.path)]);
@@ -1687,8 +2007,11 @@ function collectEffectiveAspectIds(graph, nodePath) {
 }
 
 // src/core/validator.ts
-import { readdir as readdir4, readFile as readFile11, stat as stat3 } from "fs/promises";
-import path9 from "path";
+import { readdir as readdir5, readFile as readFile13, stat as stat4 } from "fs/promises";
+import path11 from "path";
+function getAspectIds(aspects) {
+  return (aspects ?? []).map((a) => a.aspect);
+}
 var RESERVED_DIRS = /* @__PURE__ */ new Set();
 async function validate(graph, scope = "all") {
   const issues = [];
@@ -1717,7 +2040,6 @@ async function validate(graph, scope = "all") {
     issues.push(...checkImpliedAspectsExist(graph));
     issues.push(...checkImpliesNoCycles(graph));
     issues.push(...checkRequiredAspectsCoverage(graph));
-    issues.push(...checkAspectExceptions(graph));
     issues.push(...await checkAnchorPresence(graph));
     issues.push(...checkRequiredArtifacts(graph));
     issues.push(...checkInvalidArtifactConditions(graph));
@@ -1766,7 +2088,7 @@ async function validate(graph, scope = "all") {
 }
 function checkNodeTypes(graph) {
   const issues = [];
-  const allowedTypes = new Set((graph.config.node_types ?? []).map((t) => t.name));
+  const allowedTypes = new Set(Object.keys(graph.config.node_types ?? {}));
   for (const [nodePath, node] of graph.nodes) {
     if (!allowedTypes.has(node.meta.type)) {
       issues.push({
@@ -1833,7 +2155,7 @@ function checkAspectsDefined(graph) {
   const issues = [];
   const validAspectIds = new Set(graph.aspects.map((a) => a.id));
   for (const [nodePath, node] of graph.nodes) {
-    for (const aspectId of node.meta.aspects ?? []) {
+    for (const aspectId of getAspectIds(node.meta.aspects)) {
       if (!validAspectIds.has(aspectId)) {
         issues.push({
           severity: "error",
@@ -1937,16 +2259,16 @@ function checkImpliesNoCycles(graph) {
 function checkRequiredAspectsCoverage(graph) {
   const issues = [];
   const typeConfig = new Map(
-    (graph.config.node_types ?? []).map((t) => [t.name, t.required_aspects ?? []])
+    Object.entries(graph.config.node_types ?? {}).map(([name, cfg]) => [name, cfg.required_aspects ?? []])
   );
   for (const [nodePath, node] of graph.nodes) {
     if (node.meta.blackbox) continue;
     const requiredAspects = typeConfig.get(node.meta.type);
     if (!requiredAspects || requiredAspects.length === 0) continue;
-    const nodeAspects = node.meta.aspects ?? [];
+    const nodeAspectIds = getAspectIds(node.meta.aspects);
     let effectiveAspects;
     try {
-      effectiveAspects = resolveAspects(nodeAspects, graph.aspects);
+      effectiveAspects = resolveAspects(nodeAspectIds, graph.aspects);
     } catch {
       continue;
     }
@@ -1965,24 +2287,6 @@ function checkRequiredAspectsCoverage(graph) {
   }
   return issues;
 }
-function checkAspectExceptions(graph) {
-  const issues = [];
-  for (const [nodePath, node] of graph.nodes) {
-    for (const exception of node.meta.aspect_exceptions ?? []) {
-      const nodeAspects = node.meta.aspects ?? [];
-      if (!nodeAspects.includes(exception.aspect)) {
-        issues.push({
-          severity: "error",
-          code: "E018",
-          rule: "invalid-aspect-exception",
-          message: `aspect_exceptions references aspect '${exception.aspect}' which is not in this node's aspects list (${nodeAspects.join(", ") || "none"})`,
-          nodePath
-        });
-      }
-    }
-  }
-  return issues;
-}
 function checkNoCycles(graph) {
   const WHITE = 0;
   const GRAY = 1;
@@ -2069,14 +2373,14 @@ function checkMappingOverlap(graph) {
 }
 async function checkMappingPathsExist(graph) {
   const issues = [];
-  const projectRoot = path9.dirname(graph.rootPath);
-  const { access: access4 } = await import("fs/promises");
+  const projectRoot = path11.dirname(graph.rootPath);
+  const { access: access5 } = await import("fs/promises");
   for (const [nodePath, node] of graph.nodes) {
     const mappingPaths = normalizeMappingPaths(node.meta.mapping);
     for (const mp of mappingPaths) {
-      const absPath = path9.join(projectRoot, mp);
+      const absPath = path11.join(projectRoot, mp);
       try {
-        await access4(absPath);
+        await access5(absPath);
       } catch {
         issues.push({
           severity: "warning",
@@ -2116,7 +2420,7 @@ function artifactRequiredReason(graph, nodePath, node, required) {
   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 ?? []).includes(aspectId) ? `node has aspect '${aspectId}'` : null;
+    return (node.meta.aspects ?? []).some((a) => a.aspect === aspectId) ? `node has aspect '${aspectId}'` : null;
   }
   return null;
 }
@@ -2307,7 +2611,7 @@ function checkSchemas(graph) {
         severity: "warning",
         code: "W010",
         rule: "missing-schema",
-        message: `Schema '${required}.yaml' missing from .yggdrasil/schemas/`
+        message: `Schema 'yg-${required}.yaml' missing from .yggdrasil/schemas/`
       });
     }
   }
@@ -2315,11 +2619,11 @@ function checkSchemas(graph) {
 }
 async function checkDirectoriesHaveNodeYaml(graph) {
   const issues = [];
-  const modelDir = path9.join(graph.rootPath, "model");
+  const modelDir = path11.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 = path9.basename(dirPath);
+    const entries = await readdir5(dirPath, { withFileTypes: true });
+    const hasNodeYaml = entries.some((e) => e.isFile() && e.name === "yg-node.yaml");
+    const dirName = path11.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("."));
@@ -2330,7 +2634,7 @@ async function checkDirectoriesHaveNodeYaml(graph) {
           severity: "error",
           code: "E015",
           rule: "missing-node-yaml",
-          message: `Directory '${graphPath}' has files but no node.yaml`,
+          message: `Directory '${graphPath}' has files but no yg-node.yaml`,
           nodePath: graphPath
         });
       } else if (hasSubdirs) {
@@ -2338,7 +2642,7 @@ async function checkDirectoriesHaveNodeYaml(graph) {
           severity: "warning",
           code: "W013",
           rule: "directory-without-node",
-          message: `Directory '${graphPath}' has subdirectories but no node.yaml \u2014 consider creating a node`,
+          message: `Directory '${graphPath}' has subdirectories but no yg-node.yaml \u2014 consider creating a node`,
           nodePath: graphPath
         });
       }
@@ -2347,15 +2651,15 @@ async function checkDirectoriesHaveNodeYaml(graph) {
       if (!entry.isDirectory()) continue;
       if (RESERVED_DIRS.has(entry.name)) continue;
       if (entry.name.startsWith(".")) continue;
-      await scanDir(path9.join(dirPath, entry.name), [...segments, entry.name]);
+      await scanDir(path11.join(dirPath, entry.name), [...segments, entry.name]);
     }
   }
   try {
-    const rootEntries = await readdir4(modelDir, { withFileTypes: true });
+    const rootEntries = await readdir5(modelDir, { withFileTypes: true });
     for (const entry of rootEntries) {
       if (!entry.isDirectory()) continue;
       if (entry.name.startsWith(".")) continue;
-      await scanDir(path9.join(modelDir, entry.name), [entry.name]);
+      await scanDir(path11.join(modelDir, entry.name), [entry.name]);
     }
   } catch {
   }
@@ -2365,14 +2669,14 @@ async function expandMappingToFiles(projectRoot, mappingPaths) {
   const files = [];
   async function collectFiles(absPath) {
     try {
-      const s = await stat3(absPath);
+      const s = await stat4(absPath);
       if (s.isFile()) {
         files.push(absPath);
       } else if (s.isDirectory()) {
-        const entries = await readdir4(absPath, { withFileTypes: true });
+        const entries = await readdir5(absPath, { withFileTypes: true });
         for (const entry of entries) {
           if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-          const entryPath = path9.join(absPath, entry.name);
+          const entryPath = path11.join(absPath, entry.name);
           if (entry.isFile()) {
             files.push(entryPath);
           } else if (entry.isDirectory()) {
@@ -2384,28 +2688,16 @@ async function expandMappingToFiles(projectRoot, mappingPaths) {
     }
   }
   for (const mp of mappingPaths) {
-    await collectFiles(path9.join(projectRoot, mp));
+    await collectFiles(path11.join(projectRoot, mp));
   }
   return files;
 }
 async function checkAnchorPresence(graph) {
   const issues = [];
-  const projectRoot = path9.dirname(graph.rootPath);
+  const projectRoot = path11.dirname(graph.rootPath);
   for (const [nodePath, node] of graph.nodes) {
-    const anchors = node.meta.anchors;
-    if (!anchors) continue;
-    const nodeAspects = new Set(node.meta.aspects ?? []);
-    for (const aspectId of Object.keys(anchors)) {
-      if (!nodeAspects.has(aspectId)) {
-        issues.push({
-          severity: "error",
-          code: "E019",
-          rule: "invalid-anchor-ref",
-          message: `anchors references aspect '${aspectId}' which is not in this node's aspects list (${[...nodeAspects].join(", ") || "none"})`,
-          nodePath
-        });
-      }
-    }
+    const aspectsWithAnchors = (node.meta.aspects ?? []).filter((a) => a.anchors && a.anchors.length > 0);
+    if (aspectsWithAnchors.length === 0) continue;
     const mappingPaths = normalizeMappingPaths(node.meta.mapping);
     if (mappingPaths.length === 0) continue;
     const sourceFiles = await expandMappingToFiles(projectRoot, mappingPaths);
@@ -2413,21 +2705,20 @@ async function checkAnchorPresence(graph) {
     const fileContents = [];
     for (const filePath of sourceFiles) {
       try {
-        const content = await readFile11(filePath, "utf-8");
+        const content = await readFile13(filePath, "utf-8");
         fileContents.push(content);
       } catch {
       }
     }
-    for (const [aspectId, anchorList] of Object.entries(anchors)) {
-      if (!nodeAspects.has(aspectId)) continue;
-      for (const anchor of anchorList) {
+    for (const entry of aspectsWithAnchors) {
+      for (const anchor of entry.anchors) {
         const found = fileContents.some((content) => content.includes(anchor));
         if (!found) {
           issues.push({
             severity: "warning",
             code: "W014",
             rule: "anchor-not-found",
-            message: `Anchor '${anchor}' for aspect '${aspectId}' not found in mapped source files`,
+            message: `Anchor '${anchor}' for aspect '${entry.aspect}' not found in mapped source files`,
             nodePath
           });
         }
@@ -2652,13 +2943,13 @@ ${errors.length} errors, ${warnings.length} warnings.
 import chalk2 from "chalk";
 
 // src/io/drift-state-store.ts
-import { readFile as readFile12, writeFile as writeFile3 } from "fs/promises";
-import path10 from "path";
+import { readFile as readFile14, writeFile as writeFile4 } from "fs/promises";
+import path12 from "path";
 import { parse as yamlParse } from "yaml";
 var DRIFT_STATE_FILE = ".drift-state";
 async function readDriftState(yggRoot) {
   try {
-    const content = await readFile12(path10.join(yggRoot, DRIFT_STATE_FILE), "utf-8");
+    const content = await readFile14(path12.join(yggRoot, DRIFT_STATE_FILE), "utf-8");
     let raw;
     try {
       raw = JSON.parse(content);
@@ -2679,24 +2970,24 @@ async function readDriftState(yggRoot) {
 }
 async function writeDriftState(yggRoot, state) {
   const content = JSON.stringify(state);
-  await writeFile3(path10.join(yggRoot, DRIFT_STATE_FILE), content, "utf-8");
+  await writeFile4(path12.join(yggRoot, DRIFT_STATE_FILE), content, "utf-8");
 }
 
 // src/utils/hash.ts
-import { readFile as readFile13, readdir as readdir5, stat as stat4 } from "fs/promises";
-import path11 from "path";
+import { readFile as readFile15, readdir as readdir6, stat as stat5 } from "fs/promises";
+import path13 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 readFile13(filePath);
+  const content = await readFile15(filePath);
   return createHash("sha256").update(content).digest("hex");
 }
 async function loadRootGitignoreStack(projectRoot) {
   if (!projectRoot) return [];
   try {
-    const content = await readFile13(path11.join(projectRoot, ".gitignore"), "utf-8");
+    const content = await readFile15(path13.join(projectRoot, ".gitignore"), "utf-8");
     const matcher = ignoreFactory();
     matcher.add(content);
     return [{ basePath: projectRoot, matcher }];
@@ -2706,7 +2997,7 @@ async function loadRootGitignoreStack(projectRoot) {
 }
 function isIgnoredByStack(candidatePath, stack) {
   for (const { basePath, matcher } of stack) {
-    const relativePath = path11.relative(basePath, candidatePath);
+    const relativePath = path13.relative(basePath, candidatePath);
     if (relativePath === "" || relativePath.startsWith("..")) continue;
     if (matcher.ignores(relativePath) || matcher.ignores(relativePath + "/")) return true;
   }
@@ -2721,9 +3012,9 @@ async function hashTrackedFiles(projectRoot, trackedFiles, storedFileData, exclu
   const gitignoreStack = await loadRootGitignoreStack(projectRoot);
   const allFiles = [];
   for (const tf of trackedFiles) {
-    const absPath = path11.join(projectRoot, tf.path);
+    const absPath = path13.join(projectRoot, tf.path);
     try {
-      const st = await stat4(absPath);
+      const st = await stat5(absPath);
       if (st.isDirectory()) {
         const dirEntries = await collectDirectoryFilePaths(absPath, absPath, {
           projectRoot,
@@ -2731,7 +3022,7 @@ async function hashTrackedFiles(projectRoot, trackedFiles, storedFileData, exclu
         });
         for (const entry of dirEntries) {
           allFiles.push({
-            relPath: path11.join(tf.path, entry.relPath).replace(/\\/g, "/"),
+            relPath: path13.join(tf.path, entry.relPath).replace(/\\/g, "/"),
             absPath: entry.absPath,
             mtimeMs: entry.mtimeMs
           });
@@ -2771,17 +3062,17 @@ async function hashTrackedFiles(projectRoot, trackedFiles, storedFileData, exclu
 async function collectDirectoryFilePaths(directoryPath, rootDirectoryPath, options) {
   let stack = options.gitignoreStack ?? [];
   try {
-    const localContent = await readFile13(path11.join(directoryPath, ".gitignore"), "utf-8");
+    const localContent = await readFile15(path13.join(directoryPath, ".gitignore"), "utf-8");
     const localMatcher = ignoreFactory();
     localMatcher.add(localContent);
     stack = [...stack, { basePath: directoryPath, matcher: localMatcher }];
   } catch {
   }
-  const entries = await readdir5(directoryPath, { withFileTypes: true });
+  const entries = await readdir6(directoryPath, { withFileTypes: true });
   const dirs = [];
   const files = [];
   for (const entry of entries) {
-    const absoluteChildPath = path11.join(directoryPath, entry.name);
+    const absoluteChildPath = path13.join(directoryPath, entry.name);
     if (isIgnoredByStack(absoluteChildPath, stack)) continue;
     if (entry.isDirectory()) dirs.push(absoluteChildPath);
     else if (entry.isFile()) files.push(absoluteChildPath);
@@ -2792,9 +3083,9 @@ async function collectDirectoryFilePaths(directoryPath, rootDirectoryPath, optio
       gitignoreStack: stack
     }))),
     Promise.all(files.map(async (f) => {
-      const fileStat = await stat4(f);
+      const fileStat = await stat5(f);
       return {
-        relPath: path11.relative(rootDirectoryPath, f),
+        relPath: path13.relative(rootDirectoryPath, f),
         absPath: f,
         mtimeMs: fileStat.mtimeMs
       };
@@ -2807,14 +3098,14 @@ async function collectDirectoryFilePaths(directoryPath, rootDirectoryPath, optio
 }
 
 // src/core/context-files.ts
-import path12 from "path";
+import path14 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 = path12.dirname(graph.rootPath);
-  const yggPrefix = path12.relative(projectRoot, graph.rootPath);
-  const yggPrefixNormalized = yggPrefix.split(path12.sep).join("/");
+  const projectRoot = path14.dirname(graph.rootPath);
+  const yggPrefix = path14.relative(projectRoot, graph.rootPath);
+  const yggPrefixNormalized = yggPrefix.split(path14.sep).join("/");
   const configArtifactKeys = new Set(Object.keys(graph.config.artifacts ?? {}));
   function addFile(filePath, category) {
     if (seen.has(filePath)) return;
@@ -2825,7 +3116,7 @@ function collectTrackedFiles(node, graph) {
     return [yggPrefixNormalized, ...segments].join("/");
   }
   function addNodeFiles(n) {
-    addFile(graphPath("model", n.path, "node.yaml"), "graph");
+    addFile(graphPath("model", n.path, "yg-node.yaml"), "graph");
     for (const art of n.artifacts) {
       if (configArtifactKeys.has(art.filename)) {
         addFile(graphPath("model", n.path, art.filename), "graph");
@@ -2838,12 +3129,12 @@ function collectTrackedFiles(node, graph) {
     addNodeFiles(ancestor);
   }
   const allAspectIds = /* @__PURE__ */ new Set();
-  for (const id of node.meta.aspects ?? []) {
-    allAspectIds.add(id);
+  for (const entry of node.meta.aspects ?? []) {
+    allAspectIds.add(entry.aspect);
   }
   for (const ancestor of ancestors) {
-    for (const id of ancestor.meta.aspects ?? []) {
-      allAspectIds.add(id);
+    for (const entry of ancestor.meta.aspects ?? []) {
+      allAspectIds.add(entry.aspect);
     }
   }
   const participatingFlows = collectParticipatingFlows2(graph, node, ancestors);
@@ -2854,7 +3145,7 @@ function collectTrackedFiles(node, graph) {
   }
   const resolvedAspects = resolveAspects(allAspectIds, graph.aspects);
   for (const aspect of resolvedAspects) {
-    addFile(graphPath("aspects", aspect.id, "aspect.yaml"), "graph");
+    addFile(graphPath("aspects", aspect.id, "yg-aspect.yaml"), "graph");
     for (const art of aspect.artifacts) {
       addFile(graphPath("aspects", aspect.id, art.filename), "graph");
     }
@@ -2863,7 +3154,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.structural_context).map(([filename]) => filename);
+    const structuralFilenames = Object.entries(graph.config.artifacts ?? {}).filter(([, c]) => c.included_in_relations).map(([filename]) => filename);
     const structuralArts = structuralFilenames.filter(
       (filename) => target.artifacts.some((a) => a.filename === filename)
     );
@@ -2880,7 +3171,7 @@ function collectTrackedFiles(node, graph) {
     }
   }
   for (const flow of participatingFlows) {
-    addFile(graphPath("flows", flow.path, "flow.yaml"), "graph");
+    addFile(graphPath("flows", flow.path, "yg-flow.yaml"), "graph");
     for (const art of flow.artifacts) {
       addFile(graphPath("flows", flow.path, art.filename), "graph");
     }
@@ -2897,8 +3188,8 @@ function collectParticipatingFlows2(graph, node, ancestors) {
 }
 
 // src/core/drift-detector.ts
-import { access } from "fs/promises";
-import path13 from "path";
+import { access as access2 } from "fs/promises";
+import path15 from "path";
 function getChildMappingExclusions(graph, nodePath) {
   const node = graph.nodes.get(nodePath);
   if (!node) return [];
@@ -2920,7 +3211,7 @@ function getChildMappingExclusions(graph, nodePath) {
   return exclusions;
 }
 async function detectDrift(graph, filterNodePath) {
-  const projectRoot = path13.dirname(graph.rootPath);
+  const projectRoot = path15.dirname(graph.rootPath);
   const driftState = await readDriftState(graph.rootPath);
   const entries = [];
   for (const [nodePath, node] of graph.nodes) {
@@ -3002,16 +3293,16 @@ async function detectDrift(graph, filterNodePath) {
   };
 }
 function categorizeFile(filePath, _rootPath, projectRoot) {
-  const yggPrefix = path13.relative(projectRoot, _rootPath);
-  const normalizedPrefix = yggPrefix.split(path13.sep).join("/");
+  const yggPrefix = path15.relative(projectRoot, _rootPath);
+  const normalizedPrefix = yggPrefix.split(path15.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 = path13.join(projectRoot, mp);
+    const absPath = path15.join(projectRoot, mp);
     try {
-      await access(absPath);
+      await access2(absPath);
       return false;
     } catch {
     }
@@ -3019,7 +3310,7 @@ async function allPathsMissing(projectRoot, mappingPaths) {
   return true;
 }
 async function syncDriftState(graph, nodePath) {
-  const projectRoot = path13.dirname(graph.rootPath);
+  const projectRoot = path15.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}`);
@@ -3334,10 +3625,10 @@ function registerTreeCommand(program2) {
       let roots;
       let showProjectName;
       if (options.root?.trim()) {
-        const path18 = options.root.trim().replace(/\/$/, "");
-        const node = graph.nodes.get(path18);
+        const path20 = options.root.trim().replace(/\/$/, "");
+        const node = graph.nodes.get(path20);
         if (!node) {
-          process.stderr.write(`Error: path '${path18}' not found
+          process.stderr.write(`Error: path '${path20}' not found
 `);
           process.exit(1);
         }
@@ -3381,8 +3672,8 @@ function printNode(node, prefix, isLast, depth, maxDepth) {
 }
 
 // src/cli/owner.ts
-import path14 from "path";
-import { access as access2 } from "fs/promises";
+import path16 from "path";
+import { access as access3 } from "fs/promises";
 function normalizeForMatch(inputPath) {
   return inputPath.replace(/\\/g, "/").replace(/\/+$/, "");
 }
@@ -3411,14 +3702,14 @@ function registerOwnerCommand(program2) {
       const graph = await loadGraph(cwd);
       const repoRoot = projectRootFromGraph(graph.rootPath);
       const rawPath = options.file.trim();
-      const absolute = path14.resolve(cwd, rawPath);
-      const repoRelative = path14.relative(repoRoot, absolute).split(path14.sep).join("/");
+      const absolute = path16.resolve(cwd, rawPath);
+      const repoRelative = path16.relative(repoRoot, absolute).split(path16.sep).join("/");
       const result = findOwner(graph, repoRoot, repoRelative);
       if (!result.nodePath) {
-        const absPath = path14.resolve(repoRoot, result.file);
+        const absPath = path16.resolve(repoRoot, result.file);
         let exists = true;
         try {
-          await access2(absPath);
+          await access3(absPath);
         } catch {
           exists = false;
         }
@@ -3449,7 +3740,7 @@ function registerOwnerCommand(program2) {
 
 // src/core/dependency-resolver.ts
 import { execSync } from "child_process";
-import path15 from "path";
+import path17 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) {
@@ -3524,9 +3815,9 @@ function registerDepsCommand(program2) {
 }
 
 // src/core/graph-from-git.ts
-import { mkdtemp, rm } from "fs/promises";
+import { mkdtemp, rm as rm2 } from "fs/promises";
 import { tmpdir } from "os";
-import path16 from "path";
+import path18 from "path";
 import { execSync as execSync2 } from "child_process";
 async function loadGraphFromRef(projectRoot, ref = "HEAD") {
   const yggPath = ".yggdrasil";
@@ -3537,8 +3828,8 @@ async function loadGraphFromRef(projectRoot, ref = "HEAD") {
     return null;
   }
   try {
-    tmpDir = await mkdtemp(path16.join(tmpdir(), "ygg-git-"));
-    const archivePath = path16.join(tmpDir, "archive.tar");
+    tmpDir = await mkdtemp(path18.join(tmpdir(), "ygg-git-"));
+    const archivePath = path18.join(tmpDir, "archive.tar");
     execSync2(`git archive ${ref} ${yggPath} -o "${archivePath}"`, {
       cwd: projectRoot,
       stdio: "pipe"
@@ -3550,7 +3841,7 @@ async function loadGraphFromRef(projectRoot, ref = "HEAD") {
     return null;
   } finally {
     if (tmpDir) {
-      await rm(tmpDir, { recursive: true, force: true });
+      await rm2(tmpDir, { recursive: true, force: true });
     }
   }
 }
@@ -3608,14 +3899,14 @@ function buildTransitiveChains(targetNode, direct, allDependents, reverse) {
   }
   const chains = [];
   for (const node of transitiveOnly) {
-    const path18 = [];
+    const path20 = [];
     let current = node;
     while (current) {
-      path18.unshift(current);
+      path20.unshift(current);
       current = parent.get(current);
     }
-    if (path18.length >= 3) {
-      chains.push(path18.slice(1).map((p) => `<- ${p}`).join(" "));
+    if (path20.length >= 3) {
+      chains.push(path20.slice(1).map((p) => `<- ${p}`).join(" "));
     }
   }
   return chains.sort();
@@ -3685,14 +3976,14 @@ async function handleAspectImpact(graph, aspectId, simulate) {
     const effective = collectEffectiveAspectIds(graph, nodePath);
     if (effective.has(aspectId)) {
       const node = graph.nodes.get(nodePath);
-      const ownAspects = new Set(node.meta.aspects ?? []);
-      if (ownAspects.has(aspectId)) {
+      const ownAspectIds = new Set((node.meta.aspects ?? []).map((a) => a.aspect));
+      if (ownAspectIds.has(aspectId)) {
         affected.push({ path: nodePath, source: "own" });
       } else {
         let fromHierarchy = false;
         let anc = node.parent;
         while (anc) {
-          if ((anc.meta.aspects ?? []).includes(aspectId)) {
+          if ((anc.meta.aspects ?? []).some((a) => a.aspect === aspectId)) {
             fromHierarchy = true;
             break;
           }
@@ -4037,16 +4328,16 @@ function registerFlowsCommand(program2) {
 }
 
 // src/io/journal-store.ts
-import { readFile as readFile14, writeFile as writeFile4, mkdir as mkdir3, rename, access as access3 } from "fs/promises";
-import { parse as parseYaml6, stringify as stringifyYaml } from "yaml";
-import path17 from "path";
+import { readFile as readFile16, writeFile as writeFile5, mkdir as mkdir3, rename as rename2, access as access4 } from "fs/promises";
+import { parse as parseYaml8, stringify as stringifyYaml2 } from "yaml";
+import path19 from "path";
 var JOURNAL_FILE = ".journal.yaml";
 var ARCHIVE_DIR = "journals-archive";
 async function readJournal(yggRoot) {
-  const filePath = path17.join(yggRoot, JOURNAL_FILE);
+  const filePath = path19.join(yggRoot, JOURNAL_FILE);
   try {
-    const content = await readFile14(filePath, "utf-8");
-    const raw = parseYaml6(content);
+    const content = await readFile16(filePath, "utf-8");
+    const raw = parseYaml8(content);
     const entries = raw.entries ?? [];
     return Array.isArray(entries) ? entries : [];
   } catch {
@@ -4058,27 +4349,27 @@ 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 = path17.join(yggRoot, JOURNAL_FILE);
-  const content = stringifyYaml({ entries });
-  await writeFile4(filePath, content, "utf-8");
+  const filePath = path19.join(yggRoot, JOURNAL_FILE);
+  const content = stringifyYaml2({ entries });
+  await writeFile5(filePath, content, "utf-8");
   return entry;
 }
 async function archiveJournal(yggRoot) {
-  const journalPath = path17.join(yggRoot, JOURNAL_FILE);
+  const journalPath = path19.join(yggRoot, JOURNAL_FILE);
   try {
-    await access3(journalPath);
+    await access4(journalPath);
   } catch {
     return null;
   }
   const entries = await readJournal(yggRoot);
   if (entries.length === 0) return null;
-  const archiveDir = path17.join(yggRoot, ARCHIVE_DIR);
+  const archiveDir = path19.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 = path17.join(archiveDir, archiveName);
-  await rename(journalPath, archivePath);
+  const archivePath = path19.join(archiveDir, archiveName);
+  await rename2(journalPath, archivePath);
   return { archiveName, entryCount: entries.length };
 }
 
@@ -4232,12 +4523,12 @@ function registerPreflightCommand(program2) {
 }
 
 // src/bin.ts
-import { readFileSync } from "fs";
+import { readFileSync as readFileSync2 } from "fs";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { dirname, join } from "path";
 var __filename = fileURLToPath3(import.meta.url);
 var __dirname = dirname(__filename);
-var pkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8"));
+var pkg = JSON.parse(readFileSync2(join(__dirname, "..", "package.json"), "utf-8"));
 var program = new Command();
 program.name("yg").description("Yggdrasil \u2014 architectural knowledge infrastructure for AI agents").version(pkg.version);
 registerInitCommand(program);