@chrisdudek/yg 2.0.0 → 2.1.0

package/README.md

@@ -41,7 +41,7 @@ yg build-context --node orders/order-service
 
 **Diagnostics:**
 
-- `yg preflight [--quick]` — Unified diagnostic report: journal, drift, status, validation
+- `yg preflight [--quick]` — Unified diagnostic report: drift, status, validation
 
 **Reading and analysis:**
 
@@ -61,12 +61,6 @@ yg build-context --node orders/order-service
 - `yg drift-sync --node <path> [--recursive]` — Record current file hash after resolving drift
 - `yg drift-sync --all` — Sync all nodes with mappings in one command
 
-**Session journal:**
-
-- `yg journal-add --note "..." [--target <node-path>]` — Buffer a decision note
-- `yg journal-read` — List pending journal entries
-- `yg journal-archive` — Archive journal after consolidation
-
 **Setup:**
 
 - `yg init --platform <name>` — Initialize `.yggdrasil/` structure (once per repository)

package/dist/bin.js

@@ -54,14 +54,25 @@ import path from "path";
 // src/templates/rules.ts
 var CORE_PROTOCOL = `## CORE PROTOCOL
 
-Yggdrasil is persistent semantic memory stored in \`.yggdrasil/\`. It maps the repository and provides deterministic implementation context for every node. This document is your complete operating manual. Follow it strictly.
+<EXTREMELY-IMPORTANT>
+This is your operating manual for working in a Yggdrasil-managed repository. Every rule below is mandatory \u2014 no skill, plan, workflow, or instruction overrides these requirements.
+
+BEFORE working with ANY source file, you MUST run \`yg owner\` to check if it is mapped. If mapped, you MUST use the graph before reading source. YOU DO NOT HAVE A CHOICE.
+
+This is not negotiable. This is not optional. You cannot rationalize your way out of this.
+</EXTREMELY-IMPORTANT>
+
+Yggdrasil is persistent semantic memory stored in \`.yggdrasil/\`. It maps the repository and provides deterministic implementation context for every node.
 
 ### Quick Start Protocol
 
 \`\`\`
 BEFORE reading, researching, planning, OR modifying ANY mapped file:
   1. yg owner --file <path>
-  2. yg build-context --node <owner>
+  2. Choose the right graph tool for your task:
+     - Understanding how/why it works \u2192 yg build-context --node <owner>
+     - Assessing what is affected by a change \u2192 yg impact --node <owner>
+     - Planning modifications \u2192 both (build-context first, then impact)
   The context package is your primary source of ARCHITECTURAL understanding:
   intent, constraints, relations, rationale. For IMPLEMENTATION precision
   (exact behavior, error handling, await patterns, edge cases) \u2014 verify
@@ -81,6 +92,8 @@ NEVER: modify code without graph coverage.
 NEVER: read mapped source files to understand a component without
        running yg build-context first \u2014 the graph captures intent,
        constraints, and relations that source files cannot.
+NEVER: assess blast radius of a change without running yg impact first
+       \u2014 the graph knows the dependency structure that grep cannot infer.
 NEVER: invent rationale, business rules, or decisions.
 NEVER: auto-resolve drift without asking the user.
 WHEN UNSURE: ask the user. Never guess. Never assume.
@@ -88,7 +101,7 @@ WHEN UNSURE: ask the user. Never guess. Never assume.
 
 ### Five Core Rules
 
-1. **Graph first.** Before reading, researching, planning, or modifying mapped files, run \`yg owner\` and \`yg build-context\`. Always. The context package is your primary source of architectural understanding. For implementation-level precision (exact behavior, error paths, edge cases) \u2014 verify against source code after loading the context package.
+1. **Graph first.** Before reading, researching, planning, or modifying mapped files, run \`yg owner\` and the appropriate graph tool: \`yg build-context\` to understand a component, \`yg impact\` to assess blast radius. The graph is your primary source of architectural understanding. For implementation-level precision (exact behavior, error paths, edge cases) \u2014 verify against source code after loading the context package.
 2. **Code and graph are one.** Code changed \u2192 graph updated in the same response. Graph changed \u2192 source verified in the same response. No exceptions.
 3. **Never invent why.** The graph captures human intent. If you don't know why something was decided, ask. Never hallucinate rationale.
 4. **Always capture why \u2014 especially why NOT.** When the user explains a reason, record it in the graph immediately. When a design choice is made, also record rejected alternatives: "Chose X over Y because Z." Rejected alternatives are the highest-value information \u2014 invisible in code and irrecoverable once forgotten. Conversation evaporates; graph persists.
@@ -96,15 +109,22 @@ WHEN UNSURE: ask the user. Never guess. Never assume.
 
 ### Recognizing Graph-Required Actions
 
-What matters is the ACTION you are performing, not what instructed it. If the action involves understanding mapped code, the graph protocol applies \u2014 whether the instruction came from a skill, a plan, a user message, a workflow step, or your own initiative.
+What matters is the ACTION you are performing, not what instructed it. If the action involves reading, understanding, or modifying mapped code, the graph protocol applies \u2014 whether the instruction came from a skill, a plan, a user message, a brainstorming session, a debugging workflow, or your own initiative. This is not negotiable. You cannot rationalize your way out of this.
 
-**Actions that require \`yg owner\` + \`yg build-context\` first:**
+**Actions that require \`yg owner\` + \`yg build-context\`:**
 
 - Reading or exploring source files to understand a component
 - Proposing approaches, designs, or plans for changing code
 - Reviewing or debugging code
 - Any form of reasoning about how mapped code works or should change
 
+**Actions that require \`yg owner\` + \`yg impact\`:**
+
+- Assessing blast radius before changing or removing a component
+- Finding all dependents of a component
+- Planning cross-cutting refactors or feature removals
+- Scoping work that spans multiple nodes
+
 **Actions that do NOT require yg:**
 
 - Git operations (log, diff, status, blame)
@@ -112,11 +132,22 @@ What matters is the ACTION you are performing, not what instructed it. If the ac
 - Running tests, builds, or linters
 - Working with files that \`yg owner\` reports as unmapped
 
+**Evasion patterns \u2014 if you think any of these, STOP:**
+
+| Thought | Reality |
+|---|---|
+| "The skill/plan says to explore the codebase" | Exploring mapped code = yg owner + graph tool first |
+| "I'm just scoping/searching, not understanding" | Scoping IS a graph action; use yg impact |
+| "The plan step says to read this file" | Reading a mapped file = yg owner first |
+| "I'm brainstorming, not implementing" | Brainstorming about mapped code needs graph context |
+| "I'm only grepping for references" | Grep finds text; yg impact finds structural dependencies. Use both. |
+| "I'll use the graph later when I modify" | Graph-first means BEFORE reading, not before modifying |
+
 ### Failure States
 
 You have broken Yggdrasil if you do any of the following:
 
-- \u274C Worked on a mapped file without running \`yg owner\` + \`yg build-context\` first \u2014 regardless of what instructed the action (skill, plan, user request, workflow step).
+- \u274C Worked on a mapped file without running \`yg owner\` + the appropriate graph tool (\`build-context\` or \`impact\`) first \u2014 regardless of what instructed the action (skill, plan, user request, workflow step).
 - \u274C Modified source code without updating graph artifacts in the same response, or vice versa.
 - \u274C Resolved a code-graph inconsistency or ambiguity without asking the user first.
 - \u274C Created or edited a graph element without reading its schema in \`schemas/\` first.
@@ -161,9 +192,8 @@ var OPERATIONS = `## OPERATIONS
 \`\`\`
 PREFLIGHT (every conversation, before any work):
   - [ ] 1. yg preflight \u2192 read unified report
-  - [ ] 2. If journal entries: consolidate to graph, then yg journal-archive
-  - [ ] 3. If drift: resolve per Drift Resolution, then yg drift-sync per node
-  - [ ] 4. If validation errors: fix, re-run yg validate
+  - [ ] 2. If drift: resolve per Drift Resolution, then yg drift-sync per node
+  - [ ] 3. If validation errors: fix, re-run yg validate
   Exception: read-only requests (explain, analyze) \u2014 skip preflight.
 
 UNDERSTANDING mapped code (questions, research, OR planning):
@@ -174,14 +204,14 @@ UNDERSTANDING mapped code (questions, research, OR planning):
   Raw reads supplement the context package \u2014 they do not replace it.
 
 WRAP-UP (user signals "done", "wrap up", "that's enough"):
-  - [ ] 1. Consolidate journal if used \u2192 yg journal-archive
-  - [ ] 2. yg drift --drifted-only \u2192 resolve
-  - [ ] 3. yg validate \u2192 fix errors
-  - [ ] 4. Report: which nodes and files were changed
+  - [ ] 1. yg drift --drifted-only \u2192 resolve
+  - [ ] 2. yg validate \u2192 fix errors
+  - [ ] 3. Report: which nodes and files were changed
 
 BEFORE ENDING ANY RESPONSE (self-audit):
+  - [ ] Did I interact with mapped code (read, research, or modify)? If yes \u2192 did I use a graph tool BEFORE reading source?
   - [ ] Did I modify source code? If yes \u2192 did I update graph artifacts in this same response?
-  - [ ] If you changed code and did not sync the graph, you have broken the protocol. Do not finish until both are done.
+  - [ ] If you broke either rule, you have broken the protocol. Do not finish until both are fixed.
 \`\`\`
 
 ### Modify Source Code
@@ -319,8 +349,7 @@ var KNOWLEDGE_BASE = `## KNOWLEDGE BASE
   aspects/           \u2190 what must: cross-cutting requirements with rationale and guidance
   flows/             \u2190 why and in what process: business processes with node participation
   schemas/           \u2190 YAML schemas \u2014 read before creating any graph element
-  .drift-state       \u2190 generated by CLI; never edit manually
-  .journal.yaml      \u2190 generated by CLI; never edit manually
+  .drift-state/      \u2190 generated by CLI; never edit manually
 \`\`\`
 
 Key facts:
@@ -413,7 +442,7 @@ Test: "Does this describe what happens in the world, or only in the software?" I
 ### CLI Reference
 
 \`\`\`
-yg preflight [--quick]              Unified diagnostic: journal + drift + status + validate.
+yg preflight [--quick]              Unified diagnostic: drift + status + validate.
 yg owner --file <path>              Find the node that owns this file.
 yg build-context --node <path>      Assemble context package for this node.
 yg tree [--root <path>] [--depth N] Print graph structure.
@@ -431,10 +460,6 @@ yg drift [--scope <path>|all] [--drifted-only] [--limit <n>]
                                     Detect source and graph drift (bidirectional).
 yg drift-sync --node <path> [--recursive] | --all
                                     Record file hashes as new baseline.
-yg journal-read                     Read pending journal entries.
-yg journal-add --note "<content>" [--target <node_path>]
-                                    Add a journal entry.
-yg journal-archive                  Archive consolidated journal entries.
 \`\`\`
 
 ### Quick Routing Table
@@ -1000,10 +1025,7 @@ async function refreshSchemas(yggRoot) {
   } catch {
   }
 }
-var GITIGNORE_CONTENT = `.journal.yaml
-.drift-state
-journals-archive/
-`;
+var GITIGNORE_CONTENT = ``;
 function registerInitCommand(program2) {
   program2.command("init").description("Initialize Yggdrasil graph in current project").option(
     "--platform <name>",
@@ -2374,13 +2396,13 @@ function checkMappingOverlap(graph) {
 async function checkMappingPathsExist(graph) {
   const issues = [];
   const projectRoot = path11.dirname(graph.rootPath);
-  const { access: access5 } = await import("fs/promises");
+  const { access: access4 } = await import("fs/promises");
   for (const [nodePath, node] of graph.nodes) {
     const mappingPaths = normalizeMappingPaths(node.meta.mapping);
     for (const mp of mappingPaths) {
       const absPath = path11.join(projectRoot, mp);
       try {
-        await access5(absPath);
+        await access4(absPath);
       } catch {
         issues.push({
           severity: "warning",
@@ -2943,13 +2965,90 @@ ${errors.length} errors, ${warnings.length} warnings.
 import chalk2 from "chalk";
 
 // src/io/drift-state-store.ts
-import { readFile as readFile14, writeFile as writeFile4 } from "fs/promises";
+import { readFile as readFile14, writeFile as writeFile4, stat as stat5, readdir as readdir6, mkdir as mkdir3, rm as rm2 } from "fs/promises";
 import path12 from "path";
 import { parse as yamlParse } from "yaml";
-var DRIFT_STATE_FILE = ".drift-state";
+var DRIFT_STATE_DIR = ".drift-state";
+function nodeStatePath(yggRoot, nodePath) {
+  return path12.join(yggRoot, DRIFT_STATE_DIR, `${nodePath}.json`);
+}
+async function scanJsonFiles(dir, baseDir) {
+  const results = [];
+  let entries;
+  try {
+    entries = await readdir6(dir, { withFileTypes: true });
+  } catch {
+    return results;
+  }
+  for (const entry of entries) {
+    const fullPath = path12.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      const nested = await scanJsonFiles(fullPath, baseDir);
+      results.push(...nested);
+    } else if (entry.isFile() && entry.name.endsWith(".json")) {
+      const relPath = path12.relative(baseDir, fullPath);
+      const nodePath = relPath.replace(/\\/g, "/").replace(/\.json$/, "");
+      results.push(nodePath);
+    }
+  }
+  return results;
+}
+async function removeEmptyParents(filePath, stopDir) {
+  let dir = path12.dirname(filePath);
+  while (dir !== stopDir && dir.startsWith(stopDir)) {
+    try {
+      const entries = await readdir6(dir);
+      if (entries.length === 0) {
+        await rm2(dir, { recursive: true });
+        dir = path12.dirname(dir);
+      } else {
+        break;
+      }
+    } catch {
+      break;
+    }
+  }
+}
+async function readNodeDriftState(yggRoot, nodePath) {
+  try {
+    const filePath = nodeStatePath(yggRoot, nodePath);
+    const content = await readFile14(filePath, "utf-8");
+    const parsed = JSON.parse(content);
+    return parsed;
+  } catch {
+    return void 0;
+  }
+}
+async function writeNodeDriftState(yggRoot, nodePath, nodeState) {
+  const filePath = nodeStatePath(yggRoot, nodePath);
+  await mkdir3(path12.dirname(filePath), { recursive: true });
+  const content = JSON.stringify(nodeState, null, 2) + "\n";
+  await writeFile4(filePath, content, "utf-8");
+}
+async function garbageCollectDriftState(yggRoot, validNodePaths) {
+  const driftDir = path12.join(yggRoot, DRIFT_STATE_DIR);
+  const allNodePaths = await scanJsonFiles(driftDir, driftDir);
+  const removed = [];
+  for (const nodePath of allNodePaths) {
+    if (!validNodePaths.has(nodePath)) {
+      const filePath = nodeStatePath(yggRoot, nodePath);
+      await rm2(filePath);
+      await removeEmptyParents(filePath, driftDir);
+      removed.push(nodePath);
+    }
+  }
+  return removed.sort();
+}
 async function readDriftState(yggRoot) {
+  const driftPath = path12.join(yggRoot, DRIFT_STATE_DIR);
+  let driftStat;
   try {
-    const content = await readFile14(path12.join(yggRoot, DRIFT_STATE_FILE), "utf-8");
+    driftStat = await stat5(driftPath);
+  } catch {
+    return {};
+  }
+  if (driftStat.isFile()) {
+    const content = await readFile14(driftPath, "utf-8");
     let raw;
     try {
       raw = JSON.parse(content);
@@ -2957,24 +3056,31 @@ async function readDriftState(yggRoot) {
       raw = yamlParse(content);
     }
     if (!raw || typeof raw !== "object") return {};
-    const state = {};
+    const state2 = {};
     for (const [key, value] of Object.entries(raw)) {
       if (typeof value === "object" && value !== null && "hash" in value) {
-        state[key] = value;
+        state2[key] = value;
       }
     }
-    return state;
-  } catch {
-    return {};
+    await rm2(driftPath);
+    for (const [nodePath, nodeState] of Object.entries(state2)) {
+      await writeNodeDriftState(yggRoot, nodePath, nodeState);
+    }
+    return state2;
   }
-}
-async function writeDriftState(yggRoot, state) {
-  const content = JSON.stringify(state);
-  await writeFile4(path12.join(yggRoot, DRIFT_STATE_FILE), content, "utf-8");
+  const nodePaths = await scanJsonFiles(driftPath, driftPath);
+  const state = {};
+  for (const nodePath of nodePaths) {
+    const nodeState = await readNodeDriftState(yggRoot, nodePath);
+    if (nodeState) {
+      state[nodePath] = nodeState;
+    }
+  }
+  return state;
 }
 
 // src/utils/hash.ts
-import { readFile as readFile15, readdir as readdir6, stat as stat5 } from "fs/promises";
+import { readFile as readFile15, readdir as readdir7, stat as stat6 } from "fs/promises";
 import path13 from "path";
 import { createHash } from "crypto";
 import { createRequire } from "module";
@@ -3014,7 +3120,7 @@ async function hashTrackedFiles(projectRoot, trackedFiles, storedFileData, exclu
   for (const tf of trackedFiles) {
     const absPath = path13.join(projectRoot, tf.path);
     try {
-      const st = await stat5(absPath);
+      const st = await stat6(absPath);
       if (st.isDirectory()) {
         const dirEntries = await collectDirectoryFilePaths(absPath, absPath, {
           projectRoot,
@@ -3068,7 +3174,7 @@ async function collectDirectoryFilePaths(directoryPath, rootDirectoryPath, optio
     stack = [...stack, { basePath: directoryPath, matcher: localMatcher }];
   } catch {
   }
-  const entries = await readdir6(directoryPath, { withFileTypes: true });
+  const entries = await readdir7(directoryPath, { withFileTypes: true });
   const dirs = [];
   const files = [];
   for (const entry of entries) {
@@ -3083,7 +3189,7 @@ async function collectDirectoryFilePaths(directoryPath, rootDirectoryPath, optio
       gitignoreStack: stack
     }))),
     Promise.all(files.map(async (f) => {
-      const fileStat = await stat5(f);
+      const fileStat = await stat6(f);
       return {
         relPath: path13.relative(rootDirectoryPath, f),
         absPath: f,
@@ -3316,18 +3422,15 @@ async function syncDriftState(graph, nodePath) {
   if (!node.meta.mapping) throw new Error(`Node has no mapping: ${nodePath}`);
   const trackedFiles = collectTrackedFiles(node, graph);
   const excludePrefixes = getChildMappingExclusions(graph, nodePath);
-  const existingState = await readDriftState(graph.rootPath);
-  const existingEntry = existingState[nodePath];
+  const existingEntry = await readNodeDriftState(graph.rootPath, nodePath);
   const storedFileData = existingEntry?.files ? { hashes: existingEntry.files, mtimes: existingEntry.mtimes ?? {} } : void 0;
   const { canonicalHash, fileHashes, fileMtimes } = await hashTrackedFiles(projectRoot, trackedFiles, storedFileData, excludePrefixes);
   const previousHash = existingEntry?.hash;
-  existingState[nodePath] = { hash: canonicalHash, files: fileHashes, mtimes: fileMtimes };
-  for (const key of Object.keys(existingState)) {
-    if (!graph.nodes.has(key)) {
-      delete existingState[key];
-    }
-  }
-  await writeDriftState(graph.rootPath, existingState);
+  await writeNodeDriftState(graph.rootPath, nodePath, {
+    hash: canonicalHash,
+    files: fileHashes,
+    mtimes: fileMtimes
+  });
   return { previousHash, currentHash: canonicalHash };
 }
 
@@ -3509,6 +3612,14 @@ function registerDriftSyncCommand(program2) {
 `
         );
       }
+      if (options.all) {
+        const validPaths = new Set(nodesToSync);
+        const removed = await garbageCollectDriftState(graph.rootPath, validPaths);
+        for (const r of removed) {
+          process.stdout.write(chalk3.dim(`Removed orphaned drift state: ${r}
+`));
+        }
+      }
     } catch (error) {
       process.stderr.write(`Error: ${error.message}
 `);
@@ -3625,10 +3736,10 @@ function registerTreeCommand(program2) {
       let roots;
       let showProjectName;
       if (options.root?.trim()) {
-        const path20 = options.root.trim().replace(/\/$/, "");
-        const node = graph.nodes.get(path20);
+        const path19 = options.root.trim().replace(/\/$/, "");
+        const node = graph.nodes.get(path19);
         if (!node) {
-          process.stderr.write(`Error: path '${path20}' not found
+          process.stderr.write(`Error: path '${path19}' not found
 `);
           process.exit(1);
         }
@@ -3815,7 +3926,7 @@ function registerDepsCommand(program2) {
 }
 
 // src/core/graph-from-git.ts
-import { mkdtemp, rm as rm2 } from "fs/promises";
+import { mkdtemp, rm as rm3 } from "fs/promises";
 import { tmpdir } from "os";
 import path18 from "path";
 import { execSync as execSync2 } from "child_process";
@@ -3841,7 +3952,7 @@ async function loadGraphFromRef(projectRoot, ref = "HEAD") {
     return null;
   } finally {
     if (tmpDir) {
-      await rm2(tmpDir, { recursive: true, force: true });
+      await rm3(tmpDir, { recursive: true, force: true });
     }
   }
 }
@@ -3899,14 +4010,14 @@ function buildTransitiveChains(targetNode, direct, allDependents, reverse) {
   }
   const chains = [];
   for (const node of transitiveOnly) {
-    const path20 = [];
+    const path19 = [];
     let current = node;
     while (current) {
-      path20.unshift(current);
+      path19.unshift(current);
       current = parent.get(current);
     }
-    if (path20.length >= 3) {
-      chains.push(path20.slice(1).map((p) => `<- ${p}`).join(" "));
+    if (path19.length >= 3) {
+      chains.push(path19.slice(1).map((p) => `<- ${p}`).join(" "));
     }
   }
   return chains.sort();
@@ -4327,131 +4438,12 @@ function registerFlowsCommand(program2) {
   });
 }
 
-// src/io/journal-store.ts
-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 = path19.join(yggRoot, JOURNAL_FILE);
-  try {
-    const content = await readFile16(filePath, "utf-8");
-    const raw = parseYaml8(content);
-    const entries = raw.entries ?? [];
-    return Array.isArray(entries) ? entries : [];
-  } catch {
-    return [];
-  }
-}
-async function appendJournalEntry(yggRoot, note, target) {
-  const entries = await readJournal(yggRoot);
-  const at = (/* @__PURE__ */ new Date()).toISOString();
-  const entry = target ? { at, target, note } : { at, note };
-  entries.push(entry);
-  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 = path19.join(yggRoot, JOURNAL_FILE);
-  try {
-    await access4(journalPath);
-  } catch {
-    return null;
-  }
-  const entries = await readJournal(yggRoot);
-  if (entries.length === 0) return null;
-  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 = path19.join(archiveDir, archiveName);
-  await rename2(journalPath, archivePath);
-  return { archiveName, entryCount: entries.length };
-}
-
-// src/cli/journal-add.ts
-function registerJournalAddCommand(program2) {
-  program2.command("journal-add").description("Add a note to the session journal").requiredOption("--note <text>", "Note content").option("--target <node-path>", "Node path this note relates to").action(async (options) => {
-    try {
-      const projectRoot = process.cwd();
-      const yggRoot = await findYggRoot(projectRoot);
-      await appendJournalEntry(yggRoot, options.note, options.target);
-      const entries = await readJournal(yggRoot);
-      process.stdout.write(`Note added to journal (${entries.length} entries total)
-`);
-    } catch (error) {
-      process.stderr.write(`Error: ${error.message}
-`);
-      process.exit(1);
-    }
-  });
-}
-
-// src/cli/journal-read.ts
-function registerJournalReadCommand(program2) {
-  program2.command("journal-read").description("List pending journal entries").action(async () => {
-    try {
-      const projectRoot = process.cwd();
-      const yggRoot = await findYggRoot(projectRoot);
-      const entries = await readJournal(yggRoot);
-      if (entries.length === 0) {
-        process.stdout.write("Session journal: empty (clean state)\n");
-        return;
-      }
-      process.stdout.write(`Session journal (${entries.length} entries):
-
-`);
-      for (const e of entries) {
-        const date = e.at.slice(0, 19).replace("T", " ");
-        const target = e.target ? ` ${e.target}` : "";
-        process.stdout.write(`[${date}]${target}
-  ${e.note}
-
-`);
-      }
-    } catch (error) {
-      process.stderr.write(`Error: ${error.message}
-`);
-      process.exit(1);
-    }
-  });
-}
-
-// src/cli/journal-archive.ts
-function registerJournalArchiveCommand(program2) {
-  program2.command("journal-archive").description("Archive journal after consolidating notes to graph").action(async () => {
-    try {
-      const projectRoot = process.cwd();
-      const yggRoot = await findYggRoot(projectRoot);
-      const result = await archiveJournal(yggRoot);
-      if (!result) {
-        process.stdout.write("No active journal - nothing to archive.\n");
-        return;
-      }
-      process.stdout.write(
-        `Archived journal (${result.entryCount} entries) -> journals-archive/${result.archiveName}
-`
-      );
-    } catch (error) {
-      process.stderr.write(`Error: ${error.message}
-`);
-      process.exit(1);
-    }
-  });
-}
-
 // src/cli/preflight.ts
 function registerPreflightCommand(program2) {
-  program2.command("preflight").description("Unified diagnostic report: journal, drift, status, validation").option("--quick", "Skip drift detection for faster results").action(async (options) => {
+  program2.command("preflight").description("Unified diagnostic report: drift, status, validation").option("--quick", "Skip drift detection for faster results").action(async (options) => {
     try {
       const cwd = process.cwd();
       const graph = await loadGraph(cwd);
-      const yggRoot = await findYggRoot(cwd);
-      const journalEntries = await readJournal(yggRoot);
       const driftedEntries = options.quick ? [] : (await detectDrift(graph)).entries.filter((e) => e.status !== "ok");
       const nodeCount = graph.nodes.size;
       const aspectCount = graph.aspects.length;
@@ -4466,16 +4458,6 @@ function registerPreflightCommand(program2) {
       const lines = [];
       lines.push("=== Preflight Report ===");
       lines.push("");
-      if (journalEntries.length === 0) {
-        lines.push("Journal:    clean");
-      } else {
-        lines.push(`Journal:    ${journalEntries.length} pending entries`);
-        for (const entry of journalEntries) {
-          const target = entry.target ? ` [${entry.target}]` : "";
-          lines.push(`            - ${entry.note}${target}`);
-        }
-      }
-      lines.push("");
       if (options.quick) {
         lines.push("Drift:      skipped (--quick)");
       } else if (driftedEntries.length === 0) {
@@ -4512,7 +4494,7 @@ function registerPreflightCommand(program2) {
       }
       lines.push("");
       process.stdout.write(lines.join("\n"));
-      const hasIssues = journalEntries.length > 0 || !options.quick && driftedEntries.length > 0 || errors.length > 0;
+      const hasIssues = !options.quick && driftedEntries.length > 0 || errors.length > 0;
       process.exit(hasIssues ? 1 : 0);
     } catch (error) {
       process.stderr.write(`Error: ${error.message}
@@ -4543,9 +4525,6 @@ registerDepsCommand(program);
 registerImpactCommand(program);
 registerAspectsCommand(program);
 registerFlowsCommand(program);
-registerJournalAddCommand(program);
-registerJournalReadCommand(program);
-registerJournalArchiveCommand(program);
 registerPreflightCommand(program);
 program.parse();
 //# sourceMappingURL=bin.js.map