kirograph 0.23.0 → 0.27.0

package/dist/bin/installer/steering.js

@@ -34,53 +34,124 @@ module.exports = __toCommonJS(steering_exports);
 var fs = __toESM(require("fs"));
 var path = __toESM(require("path"));
 var import_caveman = require("./caveman");
-const STEERING_CONTENT = `---
-inclusion: always
+const LEVEL_DESCRIPTIONS = {
+  normal: "Balanced: removes noise, keeps structure.",
+  aggressive: "Compact: groups by category, limits output.",
+  ultra: "Maximum compression: counts and summaries only."
+};
+const LEVEL_EXAMPLES = {
+  normal: `\\\`\\\`\\\`
+kirograph_exec(command: "git status")
+kirograph_exec(command: "npm test")
+kirograph_exec(command: "cargo build")
+kirograph_exec(command: "ls -la src/")
+\\\`\\\`\\\``,
+  aggressive: `\\\`\\\`\\\`
+kirograph_exec(command: "git status", level: "aggressive")
+kirograph_exec(command: "npm test", level: "aggressive")
+kirograph_exec(command: "eslint .", level: "aggressive")
+kirograph_exec(command: "find . -name '*.ts'", level: "aggressive")
+\\\`\\\`\\\``,
+  ultra: `\\\`\\\`\\\`
+kirograph_exec(command: "git status", level: "ultra")
+kirograph_exec(command: "npm test", level: "ultra")
+kirograph_exec(command: "docker ps", level: "ultra")
+kirograph_exec(command: "ls -la src/", level: "ultra")
+\\\`\\\`\\\``
+};
+function buildCompressionSection(level) {
+  return `
 ---
 
-# KiroGraph
+## Shell Compression (\\\`kirograph_exec\\\`)
 
-KiroGraph builds a semantic knowledge graph of your codebase. Use its MCP tools instead of grep/glob/file reads whenever \`.kirograph/\` exists in the project.
+When running shell commands, prefer \\\`kirograph_exec\\\` over raw shell execution for:
+- **git** operations (status, log, diff, push, pull, commit, add, fetch, branch)
+- **GitHub CLI** (gh pr list/view, gh issue list, gh run list)
+- **test runners** (jest, vitest, pytest, cargo test, go test, rspec, minitest, playwright)
+- **linters/build** (eslint, tsc, ruff, clippy, cargo build, prettier, biome, golangci-lint, rubocop, next build)
+- **file listings** (ls, find, tree)
+- **search** (grep, rg/ripgrep: grouped by file)
+- **diff** (diff file1 file2: condensed context)
+- **docker/k8s** (docker ps, images, logs, compose ps, kubectl pods, logs, services)
+- **package managers** (npm/pnpm install/list, pip list/install, bundle install, prisma generate)
+- **AWS CLI** (sts, ec2, lambda, logs, cloudformation, dynamodb, iam, s3, ecs, sqs, sns)
+- **network** (curl, wget: strip progress bars and headers)
 
-## Quick decision guide
+This saves 60-90% of tokens compared to raw output.
 
-| Question | Tool |
-|----------|------|
-| Where do I start on this task? | \`kirograph_context\` |
-| What is this symbol / show me its code | \`kirograph_node\` with \`includeCode: true\` |
-| Find a symbol by name | \`kirograph_search\` |
-| Who calls function X? | \`kirograph_callers\` |
-| What does function X call? | \`kirograph_callees\` |
-| What breaks if I change X? | \`kirograph_impact\` |
-| How are X and Y connected? | \`kirograph_path\` |
-| What extends / implements this type? | \`kirograph_type_hierarchy\` |
-| Which code is never called? | \`kirograph_dead_code\` |
-| Are there import cycles? | \`kirograph_circular_deps\` |
-| What files are indexed? | \`kirograph_files\` |
-| Is the index healthy? | \`kirograph_status\` |
-| What are the most critical symbols? | \`kirograph_hotspots\` |
-| Any unexpected cross-module coupling? | \`kirograph_surprising\` |
-| What changed since the last snapshot? | \`kirograph_diff\` |
-| What packages/layers exist? | \`kirograph_architecture\` |
-| How coupled is package X? | \`kirograph_coupling\` |
-| What does package X depend on? | \`kirograph_package\` |
-| Run a command with token savings | \`kirograph_exec\` |
-| Check token savings stats | \`kirograph_gain\` |
-| What data files are indexed? | \`kirograph_data_list\` |
-| What columns does this dataset have? | \`kirograph_data_describe\` |
-| Query rows with filters | \`kirograph_data_query\` |
-| Aggregate data (sum, avg, count) | \`kirograph_data_aggregate\` |
-| Are there vulnerable dependencies? | \`kirograph_security\` |
-| Which CVEs affect my project? | \`kirograph_vulns\` |
-| Is this vulnerability reachable? | \`kirograph_reachability\` |
-| What licenses do my dependencies use? | \`kirograph_licenses\` |
-| Are dependencies outdated? | \`kirograph_staleness\` |
-| Generate SBOM/VEX | \`kirograph_sbom\` / \`kirograph_vex\` |
-| Add a private CVE | \`kirograph_vuln_add\` |
-| Find structural code patterns? | \`kirograph_live_search\` |
+Compression level: **${level}**: ${LEVEL_DESCRIPTIONS[level]}
 
----
+${LEVEL_EXAMPLES[level]}
 
+**Important:** Error details are always preserved. Failed commands show full diagnostic output regardless of level.
+
+**Do NOT re-run commands:** When \\\`kirograph_exec\\\` returns a result, treat it as the final answer. Never re-run the same command with raw shell execution to "get more details." The compressed output preserves all essential information. If you genuinely need something missing from the output, explain what's missing before making a second call.
+
+Use \\\`kirograph_gain\\\` to check token savings statistics.`;
+}
+function buildSteeringContent(opts) {
+  const cavemanMode = opts?.cavemanMode;
+  const enableCompression = opts?.enableCompression !== false && opts?.shellCompressionLevel !== "off";
+  const shellCompressionLevel = opts?.shellCompressionLevel ?? "normal";
+  const enableArchitecture = opts?.enableArchitecture ?? false;
+  const enableMemory = opts?.enableMemory ?? false;
+  const enableDocs = opts?.enableDocs ?? false;
+  const enableData = opts?.enableData ?? false;
+  const enableSecurity = opts?.enableSecurity ?? false;
+  const enablePatterns = opts?.enablePatterns ?? false;
+  const enableWiki = opts?.enableWiki ?? false;
+  const enableCodeHealth = opts?.enableCodeHealth ?? false;
+  const enableAdvancedAnalysis = opts?.enableAdvancedAnalysis ?? false;
+  const enableAgentUtils = opts?.enableAgentUtils ?? false;
+  const trackCallSites = opts?.trackCallSites ?? false;
+  const guideRows = [
+    "| Where do I start on this task? | `kirograph_context` |",
+    "| What is this symbol / show me its code | `kirograph_node` with `includeCode: true` |",
+    "| Find a symbol by name | `kirograph_search` |",
+    ...trackCallSites ? [
+      "| Who calls function X? | `kirograph_callers` |",
+      "| What does function X call? | `kirograph_callees` |"
+    ] : [],
+    "| What breaks if I change X? | `kirograph_impact` |",
+    "| How are X and Y connected? | `kirograph_path` |",
+    ...enableAdvancedAnalysis ? ["| What extends / implements this type? | `kirograph_type_hierarchy` |"] : [],
+    ...enableCodeHealth ? [
+      "| Which code is never called? | `kirograph_dead_code` |",
+      "| Are there import cycles? | `kirograph_circular_deps` |"
+    ] : [],
+    "| What files are indexed? | `kirograph_files` |",
+    "| Is the index healthy? | `kirograph_status` |",
+    ...enableCodeHealth ? [
+      "| What are the most critical symbols? | `kirograph_hotspots` |",
+      "| Any unexpected cross-module coupling? | `kirograph_surprising` |",
+      "| What changed since the last snapshot? | `kirograph_diff` |"
+    ] : [],
+    ...enableArchitecture ? [
+      "| What packages/layers exist? | `kirograph_architecture` |",
+      "| How coupled is package X? | `kirograph_coupling` |",
+      "| What does package X depend on? | `kirograph_package` |"
+    ] : [],
+    ...enableCompression ? ["| Run a command with token savings | `kirograph_exec` |"] : [],
+    ...enableAgentUtils ? ["| Check token savings stats | `kirograph_gain` |"] : [],
+    ...enableData ? [
+      "| What data files are indexed? | `kirograph_data_list` |",
+      "| What columns does this dataset have? | `kirograph_data_describe` |",
+      "| Query rows with filters | `kirograph_data_query` |",
+      "| Aggregate data (sum, avg, count) | `kirograph_data_aggregate` |"
+    ] : [],
+    ...enableSecurity ? [
+      "| Are there vulnerable dependencies? | `kirograph_security` |",
+      "| Which CVEs affect my project? | `kirograph_vulns` |",
+      "| Is this vulnerability reachable? | `kirograph_reachability` |",
+      "| What licenses do my dependencies use? | `kirograph_licenses` |",
+      "| Are dependencies outdated? | `kirograph_staleness` |",
+      "| Generate SBOM/VEX | `kirograph_sbom` / `kirograph_vex` |",
+      "| Add a private CVE | `kirograph_vuln_add` |"
+    ] : [],
+    ...enablePatterns ? ["| Find structural code patterns? | `kirograph_live_search` |"] : []
+  ];
+  let toolRef = `
 ## Tool reference
 
 ### \`kirograph_context\`: **start here for any code task**
@@ -112,7 +183,9 @@ Returns kind, file, signature, docstring. Add \`includeCode: true\` to get the f
 \`\`\`
 kirograph_node(symbol: "validateToken")
 kirograph_node(symbol: "AuthService", includeCode: true)
-\`\`\`
+\`\`\``;
+  if (trackCallSites) {
+    toolRef += `
 
 ### \`kirograph_callers\`: who calls this?
 
@@ -128,7 +201,9 @@ BFS over outgoing \`calls\` edges (depth 1).
 
 \`\`\`
 kirograph_callees(symbol: "handleRequest")
-\`\`\`
+\`\`\``;
+  }
+  toolRef += `
 
 ### \`kirograph_impact\`: blast radius before a change
 
@@ -144,7 +219,9 @@ BFS shortest path across all edge types.
 
 \`\`\`
 kirograph_path(from: "LoginController", to: "DatabasePool")
-\`\`\`
+\`\`\``;
+  if (enableAdvancedAnalysis) {
+    toolRef += `
 
 ### \`kirograph_type_hierarchy\`: class/interface inheritance
 
@@ -152,7 +229,10 @@ kirograph_path(from: "LoginController", to: "DatabasePool")
 kirograph_type_hierarchy(symbol: "BaseRepository", direction: "down")  // derived types
 kirograph_type_hierarchy(symbol: "PaymentService", direction: "up")    // base types
 kirograph_type_hierarchy(symbol: "IUserStore", direction: "both")      // all
-\`\`\`
+\`\`\``;
+  }
+  if (enableCodeHealth) {
+    toolRef += `
 
 ### \`kirograph_dead_code\`: unreferenced symbols
 
@@ -168,7 +248,9 @@ Runs Tarjan's SCC over import edges. No parameters needed.
 
 \`\`\`
 kirograph_circular_deps()
-\`\`\`
+\`\`\``;
+  }
+  toolRef += `
 
 ### \`kirograph_files\`: indexed file structure
 
@@ -182,7 +264,9 @@ kirograph_files(pattern: "**/*.test.ts")
 
 ### \`kirograph_status\`: index health
 
-Returns file count, symbol count, edge count, embedding coverage, DB size. Call when something feels off.
+Returns file count, symbol count, edge count, embedding coverage, DB size. Call when something feels off.`;
+  if (enableCodeHealth) {
+    toolRef += `
 
 ### \`kirograph_hotspots\`: most-connected symbols
 
@@ -207,7 +291,10 @@ Compares the current graph against a saved snapshot. Shows added/removed symbols
 \`\`\`
 kirograph_diff()                              // vs latest snapshot
 kirograph_diff(snapshot: "pre-refactor")     // vs named snapshot
-\`\`\`
+\`\`\``;
+  }
+  if (enableArchitecture) {
+    toolRef += `
 
 ---
 
@@ -243,34 +330,63 @@ Returns metadata, coupling metrics, outgoing deps, incoming dependents, and file
 \`\`\`
 kirograph_package(package: "auth")
 kirograph_package(package: "src/services", includeFiles: false)
-\`\`\`
+\`\`\``;
+  }
+  let bugFixWorkflow = `**Bug fix or feature:**
+1. \`kirograph_context\`: orient, find entry points.
+2. \`kirograph_node\` with \`includeCode: true\`: read the relevant symbol.`;
+  if (trackCallSites) {
+    bugFixWorkflow += `
+3. \`kirograph_callers\` / \`kirograph_callees\`: trace the call flow.
+4. \`kirograph_impact\`: check blast radius before editing.`;
+  } else {
+    bugFixWorkflow += `
+3. \`kirograph_impact\`: check blast radius before editing.`;
+  }
+  let workflows = `
 
 ---
 
 ## Workflows
 
-**Bug fix or feature:**
-1. \`kirograph_context\`: orient, find entry points.
-2. \`kirograph_node\` with \`includeCode: true\`: read the relevant symbol.
-3. \`kirograph_callers\` / \`kirograph_callees\`: trace the call flow.
-4. \`kirograph_impact\`: check blast radius before editing.
+${bugFixWorkflow}`;
+  if (enableCodeHealth) {
+    workflows += `
 
 **Refactor planning:**
 1. \`kirograph_hotspots\`: identify the most-connected symbols; changing these is risky.
 2. \`kirograph_surprising\`: surface hidden coupling that will break.
 3. \`kirograph_impact\` on specific targets: confirm blast radius.
-4. \`kirograph_diff\` after the refactor: verify the structural change matches intent.
+4. \`kirograph_diff\` after the refactor: verify the structural change matches intent.`;
+  }
+  if (enableArchitecture) {
+    workflows += `
 
 **Architectural review:**
 1. \`kirograph_architecture\`: get the package and layer map.
 2. \`kirograph_coupling\`: find the most stable (high Ca) and most volatile (high instability) packages.
 3. \`kirograph_package\`: drill into any package of interest.
-4. \`kirograph_circular_deps\`: check for import cycles.
+4. \`kirograph_circular_deps\`: check for import cycles.`;
+  }
+  if (enableCodeHealth) {
+    workflows += `
 
 **Code cleanup:**
 1. \`kirograph_dead_code\`: find unreferenced unexported symbols.
 2. \`kirograph_circular_deps\`: find import cycles to untangle.
-3. \`kirograph_surprising\`: find unexpected coupling to decouple.
+3. \`kirograph_surprising\`: find unexpected coupling to decouple.`;
+  }
+  const workflowRows = [
+    ...enableSecurity ? ["| security audit, check vulnerabilities, CVE review | `.kiro/steering/kirograph-security.md` |"] : [],
+    "| code review, review this PR | `.kiro/steering/kirograph-review.md` |",
+    "| debug, trace this bug, root cause | `.kiro/steering/kirograph-debug.md` |",
+    ...enableArchitecture ? ["| architecture, understand structure, package map | `.kiro/steering/kirograph-architecture.md` |"] : [],
+    "| onboard, understand this codebase | `.kiro/steering/kirograph-onboard.md` |",
+    "| refactor, rename, safe refactoring | `.kiro/steering/kirograph-refactor.md` |",
+    ...enableMemory ? ["| memory, recall decisions, conflict detection | `.kiro/steering/kirograph-mem-workflow.md` |"] : [],
+    ...enableWiki ? ["| wiki, update knowledge base, ingest docs | `.kiro/steering/kirograph-wiki-workflow.md` |"] : []
+  ];
+  const workflowSection = `
 
 ---
 
@@ -289,12 +405,7 @@ Read file: .kiro/steering/kirograph-review.md
 
 | User intent | File to load |
 |-------------|-------------|
-| security audit, check vulnerabilities, CVE review | \`.kiro/steering/kirograph-security.md\` *(requires enableSecurity)* |
-| code review, review this PR | \`.kiro/steering/kirograph-review.md\` |
-| debug, trace this bug, root cause | \`.kiro/steering/kirograph-debug.md\` |
-| architecture, understand structure, package map | \`.kiro/steering/kirograph-architecture.md\` *(requires enableArchitecture)* |
-| onboard, understand this codebase | \`.kiro/steering/kirograph-onboard.md\` |
-| refactor, rename, safe refactoring | \`.kiro/steering/kirograph-refactor.md\` |
+${workflowRows.join("\n")}
 
 Each file contains numbered steps, exact tool calls, and an interpretation reference. Follow the steps in order.
 
@@ -302,69 +413,26 @@ Each file contains numbered steps, exact tool calls, and an interpretation refer
 
 ## If \`.kirograph/\` does NOT exist
 
-Ask the user: "This project doesn't have KiroGraph initialized. Run \`kirograph init -i\` to build a code knowledge graph for faster exploration?"
-`;
-const LEVEL_DESCRIPTIONS = {
-  normal: "Balanced: removes noise, keeps structure.",
-  aggressive: "Compact: groups by category, limits output.",
-  ultra: "Maximum compression: counts and summaries only."
-};
-const LEVEL_EXAMPLES = {
-  normal: `\\\`\\\`\\\`
-kirograph_exec(command: "git status")
-kirograph_exec(command: "npm test")
-kirograph_exec(command: "cargo build")
-kirograph_exec(command: "ls -la src/")
-\\\`\\\`\\\``,
-  aggressive: `\\\`\\\`\\\`
-kirograph_exec(command: "git status", level: "aggressive")
-kirograph_exec(command: "npm test", level: "aggressive")
-kirograph_exec(command: "eslint .", level: "aggressive")
-kirograph_exec(command: "find . -name '*.ts'", level: "aggressive")
-\\\`\\\`\\\``,
-  ultra: `\\\`\\\`\\\`
-kirograph_exec(command: "git status", level: "ultra")
-kirograph_exec(command: "npm test", level: "ultra")
-kirograph_exec(command: "docker ps", level: "ultra")
-kirograph_exec(command: "ls -la src/", level: "ultra")
-\\\`\\\`\\\``
-};
-function buildCompressionSection(level) {
-  return `
+Ask the user: "This project doesn't have KiroGraph initialized. Run \`kirograph init -i\` to build a code knowledge graph for faster exploration?"`;
+  let content = `---
+inclusion: always
 ---
 
-## Shell Compression (\\\`kirograph_exec\\\`)
-
-When running shell commands, prefer \\\`kirograph_exec\\\` over raw shell execution for:
-- **git** operations (status, log, diff, push, pull, commit, add, fetch, branch)
-- **GitHub CLI** (gh pr list/view, gh issue list, gh run list)
-- **test runners** (jest, vitest, pytest, cargo test, go test, rspec, minitest, playwright)
-- **linters/build** (eslint, tsc, ruff, clippy, cargo build, prettier, biome, golangci-lint, rubocop, next build)
-- **file listings** (ls, find, tree)
-- **search** (grep, rg/ripgrep: grouped by file)
-- **diff** (diff file1 file2: condensed context)
-- **docker/k8s** (docker ps, images, logs, compose ps, kubectl pods, logs, services)
-- **package managers** (npm/pnpm install/list, pip list/install, bundle install, prisma generate)
-- **AWS CLI** (sts, ec2, lambda, logs, cloudformation, dynamodb, iam, s3, ecs, sqs, sns)
-- **network** (curl, wget: strip progress bars and headers)
-
-This saves 60-90% of tokens compared to raw output.
-
-Compression level: **${level}**: ${LEVEL_DESCRIPTIONS[level]}
+# KiroGraph
 
-${LEVEL_EXAMPLES[level]}
+KiroGraph builds a semantic knowledge graph of your codebase. Use its MCP tools instead of grep/glob/file reads whenever \`.kirograph/\` exists in the project.
 
-**Important:** Error details are always preserved. Failed commands show full diagnostic output regardless of level.
+## Quick decision guide
 
-**Do NOT re-run commands:** When \\\`kirograph_exec\\\` returns a result, treat it as the final answer. Never re-run the same command with raw shell execution to "get more details." The compressed output preserves all essential information. If you genuinely need something missing from the output, explain what's missing before making a second call.
+| Question | Tool |
+|----------|------|
+${guideRows.join("\n")}
 
-Use \\\`kirograph_gain\\\` to check token savings statistics.`;
-}
-function buildSteeringContent(opts) {
-  const cavemanMode = opts?.cavemanMode;
-  const enableCompression = opts?.enableCompression !== false && opts?.shellCompressionLevel !== "off";
-  const shellCompressionLevel = opts?.shellCompressionLevel ?? "normal";
-  let content = STEERING_CONTENT;
+---
+${toolRef}
+${workflows}
+${workflowSection}
+`;
   if (enableCompression && shellCompressionLevel !== "off") {
     const section = buildCompressionSection(shellCompressionLevel);
     content = content.replace(
@@ -372,46 +440,44 @@ function buildSteeringContent(opts) {
       section.trim() + "\n\n---\n\n## If `.kirograph/` does NOT exist"
     );
   }
-  if (!enableCompression) {
-    content = content.replace("| Run a command with token savings | `kirograph_exec` |\n", "");
-    content = content.replace("| Check token savings stats | `kirograph_gain` |\n", "");
-  }
-  if (!opts?.enableSecurity) {
-    content = content.replace("| Are there vulnerable dependencies? | `kirograph_security` |\n", "");
-    content = content.replace("| Which CVEs affect my project? | `kirograph_vulns` |\n", "");
-    content = content.replace("| Is this vulnerability reachable? | `kirograph_reachability` |\n", "");
-    content = content.replace("| What licenses do my dependencies use? | `kirograph_licenses` |\n", "");
-    content = content.replace("| Are dependencies outdated? | `kirograph_staleness` |\n", "");
-    content = content.replace("| Generate SBOM/VEX | `kirograph_sbom` / `kirograph_vex` |\n", "");
-    content = content.replace("| Add a private CVE | `kirograph_vuln_add` |\n", "");
-  }
-  if (!opts?.enablePatterns) {
-    content = content.replace("| Find structural code patterns? | `kirograph_live_search` |\n", "");
-  }
   const caveman = cavemanMode && cavemanMode !== "off" ? import_caveman.CAVEMAN_RULES[cavemanMode] : null;
   if (caveman) {
     content = content.trimEnd() + "\n\n" + caveman + "\n";
   }
-  if (opts?.enableMemory) {
+  if (enableMemory) {
     const memorySection = `
 ## Memory
 
-KiroGraph has persistent memory. Use \`kirograph_mem_search\` to recall past decisions,
-errors, and patterns before making changes. Use \`kirograph_mem_store\` to save important
-observations (architecture decisions, bug root causes, patterns discovered).
+KiroGraph has persistent memory. Use it to recall past decisions and store new ones.
+
+| Question | Tool |
+|----------|------|
+| What did we decide about X? | \`kirograph_mem_search\` |
+| Store a decision / bug fix / pattern | \`kirograph_mem_store\` |
+| Does this contradict something stored? | \`kirograph_mem_conflicts_scan\` |
+| Two observations conflict \u2014 which wins? | \`kirograph_mem_compare\` \u2192 \`kirograph_mem_judge\` |
+| Extract observations from structured text | \`kirograph_mem_capture\` |
+| Which observations need re-evaluation? | \`kirograph_mem_review\` |
+| Mark an observation as still valid | \`kirograph_mem_mark_reviewed\` |
 
-Memory is searchable via hybrid FTS + vector search. Observations are automatically
-linked to code symbols in the graph and surface in \`kirograph_context\` and
-\`kirograph_impact\` results when relevant.
+Memory is searchable via hybrid FTS + vector search. Observations surface automatically in
+\`kirograph_context\` and \`kirograph_impact\` results when linked to relevant code symbols.
 
 **When to store:** After fixing a bug, making an architecture decision, discovering a pattern,
-encountering a non-obvious error, or learning something about the codebase that future sessions
-should know. Keep observations concise \u2014 one fact per store call. A hook will also remind you
+or learning something future sessions should know. One fact per store call. A hook reminds you
 at session end.
+
+**topicKey:** Use a stable semantic key (e.g. \`"architecture/auth-model"\`) when storing a
+decision that may be superseded or revisited. Lets you address the same concept across sessions.
+
+**reviewAfter:** Pass an epoch-ms timestamp when an observation should expire or be re-evaluated
+(e.g. after a planned migration, a library upgrade, or a time-boxed experiment).
+
+For the full conflict-detection workflow, load: \`.kiro/steering/kirograph-mem-workflow.md\`
 `;
     content = content.trimEnd() + "\n\n" + memorySection.trim() + "\n";
   }
-  if (opts?.enableDocs) {
+  if (enableDocs) {
     const docsSection = `
 ## Documentation
 
@@ -432,7 +498,7 @@ and gives you structured navigation instead of raw file content.
 `;
     content = content.trimEnd() + "\n\n" + docsSection.trim() + "\n";
   }
-  if (opts?.enableData) {
+  if (enableData) {
     const dataSection = `
 ## Data
 
@@ -461,7 +527,7 @@ kirograph_data_aggregate(dataset: "data-orders", groupBy: ["region"], metrics: [
 `;
     content = content.trimEnd() + "\n\n" + dataSection.trim() + "\n";
   }
-  if (opts?.enablePatterns) {
+  if (enablePatterns) {
     const patternsSection = `
 ## Pattern Matching
 
@@ -479,7 +545,39 @@ KiroGraph can search for structural code patterns using @ast-grep/napi.
 `;
     content = content.trimEnd() + "\n\n" + patternsSection.trim() + "\n";
   }
-  if (opts?.enableSecurity) {
+  if (enableWiki) {
+    const wikiSection = `
+## Wiki
+
+KiroGraph maintains a structured LLM wiki \u2014 a set of markdown pages that compound knowledge
+across sessions. Use it to look up project decisions, architecture facts, and domain knowledge
+before starting work. Use it to save knowledge that should survive context resets.
+
+**Available tools:**
+- \`kirograph_wiki_ingest\` \u2014 build an ingest prompt for a source text; pass the result to yourself to generate a WIKI_DIFF
+- \`kirograph_wiki_apply_diff\` \u2014 apply a WIKI_DIFF to create or update wiki pages
+- \`kirograph_wiki_search\` \u2014 full-text search over wiki pages
+- \`kirograph_wiki_page\` \u2014 retrieve the full content of a page by slug
+- \`kirograph_wiki_list\` \u2014 list all pages with metadata
+- \`kirograph_wiki_lint\` \u2014 health check: broken links, orphan pages, contradictions
+
+**When to consult the wiki:**
+- Before starting a complex feature or bug fix: \`kirograph_wiki_search(query: "<topic>")\`
+- When the user references a concept you don't recognize from the code graph alone
+- After \`kirograph_context\` returns wiki enrichments (pages above threshold score)
+
+**When to update the wiki:**
+- End of a session that produced durable knowledge (architecture decision, API contract, process)
+- The ingest hook will remind you at agentStop if \`enableWiki: true\` is set
+
+**Quick workflow:**
+1. \`kirograph_wiki_ingest\` \u2014 get the prompt with SCHEMA + MANIFEST + your source text
+2. Generate a \`WIKI_DIFF\` block (create/upsert/append per page)
+3. \`kirograph_wiki_apply_diff\` \u2014 apply it; review any pending conflicts in the response
+`;
+    content = content.trimEnd() + "\n\n" + wikiSection.trim() + "\n";
+  }
+  if (enableSecurity) {
     const securitySection = `
 ## Security
 
@@ -539,132 +637,139 @@ function writeSteering(kiroDir, opts) {
   writeWorkflowSteering(steeringDir, resolvedOpts);
 }
 function writeWorkflowSteering(steeringDir, opts) {
-  const workflows = {
-    "kirograph-review.md": `---
-inclusion: manual
----
-
-# KiroGraph: Code Review Workflow
-
-Follow these steps for a structured, risk-aware code review using the knowledge graph.
-
-## Steps
-
-1. **Understand the change scope**
+  const trackCallSites = opts?.trackCallSites ?? false;
+  const enableCodeHealth = opts?.enableCodeHealth ?? false;
+  const enableArchitecture = opts?.enableArchitecture ?? false;
+  const enableAdvancedAnalysis = opts?.enableAdvancedAnalysis ?? false;
+  const reviewSteps = [
+    `1. **Understand the change scope**
    \`\`\`
    kirograph_context(task: "<describe what changed>")
-   \`\`\`
-
-2. **Analyze blast radius**
+   \`\`\``,
+    `2. **Analyze blast radius**
    For each key symbol that was modified:
    \`\`\`
    kirograph_impact(symbol: "<changed symbol>", depth: 2)
-   \`\`\`
-
-3. **Check test coverage**
+   \`\`\``
+  ];
+  if (trackCallSites) {
+    reviewSteps.push(`3. **Check test coverage**
    \`\`\`
    kirograph_callers(symbol: "<changed symbol>")
    \`\`\`
-   Look for test files among the callers. Flag untested changes.
-
-4. **Look for surprising coupling**
+   Look for test files among the callers. Flag untested changes.`);
+  }
+  if (enableCodeHealth) {
+    const n = reviewSteps.length + 1;
+    reviewSteps.push(`${n}. **Look for surprising coupling**
    \`\`\`
    kirograph_surprising(limit: 10)
-   \`\`\`
-
-5. **Produce findings** grouped by risk level (high/medium/low) with:
+   \`\`\``);
+  }
+  const findingsN = reviewSteps.length + 1;
+  reviewSteps.push(`${findingsN}. **Produce findings** grouped by risk level (high/medium/low) with:
    - What changed and why it matters
    - Test coverage status
    - Suggested improvements
-   - Overall merge recommendation
-`,
-    "kirograph-debug.md": `---
+   - Overall merge recommendation`);
+  fs.writeFileSync(path.join(steeringDir, "kirograph-review.md"), `---
 inclusion: manual
 ---
 
-# KiroGraph: Debug Workflow
+# KiroGraph: Code Review Workflow
 
-Follow these steps to systematically trace and debug issues using the knowledge graph.
+Follow these steps for a structured, risk-aware code review using the knowledge graph.
 
 ## Steps
 
-1. **Find related code**
+${reviewSteps.join("\n\n")}
+`);
+  const debugSteps = [
+    `1. **Find related code**
    \`\`\`
    kirograph_search(query: "<error message or symptom keywords>")
-   \`\`\`
-
-2. **Get full context**
+   \`\`\``,
+    `2. **Get full context**
    \`\`\`
    kirograph_context(task: "<describe the bug>")
-   \`\`\`
-
-3. **Trace the call chain**
+   \`\`\``
+  ];
+  if (trackCallSites) {
+    debugSteps.push(`3. **Trace the call chain**
    \`\`\`
    kirograph_callers(symbol: "<suspected function>")
    kirograph_callees(symbol: "<suspected function>")
-   \`\`\`
-
-4. **Check what changed recently**
+   \`\`\``);
+  }
+  if (enableCodeHealth) {
+    const n = debugSteps.length + 1;
+    debugSteps.push(`${n}. **Check what changed recently**
    \`\`\`
    kirograph_diff()
-   \`\`\`
-
-5. **Understand blast radius**
+   \`\`\``);
+  }
+  const blastN = debugSteps.length + 1;
+  debugSteps.push(`${blastN}. **Understand blast radius**
    \`\`\`
    kirograph_impact(symbol: "<root cause symbol>", depth: 3)
-   \`\`\`
-
-## Tips
-- Check both callers and callees to understand the full context
-- Recent changes (via diff) are the most common source of new issues
-- Use \`kirograph_path\` to trace how two symbols are connected
-`,
-    "kirograph-architecture.md": `---
+   \`\`\``);
+  const debugTips = [];
+  if (trackCallSites) debugTips.push("- Check both callers and callees to understand the full context");
+  if (enableCodeHealth) debugTips.push("- Recent changes (via diff) are the most common source of new issues");
+  debugTips.push("- Use `kirograph_path` to trace how two symbols are connected");
+  fs.writeFileSync(path.join(steeringDir, "kirograph-debug.md"), `---
 inclusion: manual
 ---
 
-# KiroGraph: Architecture Exploration Workflow
+# KiroGraph: Debug Workflow
 
-Follow these steps to understand the high-level structure of the codebase.
+Follow these steps to systematically trace and debug issues using the knowledge graph.
 
 ## Steps
 
-1. **Get project overview**
-   \`\`\`
-   kirograph_status()
-   \`\`\`
-
-2. **View architecture**
-   \`\`\`
-   kirograph_architecture()
-   \`\`\`
+${debugSteps.join("\n\n")}
 
-3. **Check coupling health**
-   \`\`\`
-   kirograph_coupling(sortBy: "instability")
-   \`\`\`
-
-4. **Find core abstractions**
+## Tips
+${debugTips.join("\n")}
+`);
+  const onboardSteps = [
+    `1. **Project overview**
    \`\`\`
-   kirograph_hotspots(limit: 20)
+   kirograph_status()
+   \`\`\``,
+    `2. **File structure**
    \`\`\`
-
-5. **Detect hidden dependencies**
+   kirograph_files(format: "tree", maxDepth: 2)
+   \`\`\``
+  ];
+  if (enableCodeHealth) {
+    onboardSteps.push(`3. **Key entry points**
    \`\`\`
-   kirograph_surprising(limit: 15)
+   kirograph_hotspots(limit: 15)
+   \`\`\``);
+  }
+  if (enableArchitecture) {
+    const n = onboardSteps.length + 1;
+    onboardSteps.push(`${n}. **Architecture layers**
    \`\`\`
-
-6. **Check for cycles**
+   kirograph_architecture()
+   \`\`\``);
+  }
+  const exploreN = onboardSteps.length + 1;
+  onboardSteps.push(`${exploreN}. **Explore a specific area**
    \`\`\`
-   kirograph_circular_deps()
+   kirograph_context(task: "<area you want to understand>")
+   \`\`\``);
+  const symbolN = onboardSteps.length + 1;
+  onboardSteps.push(`${symbolN}. **Understand a key symbol**
    \`\`\`
-
-## Interpretation
-- High Ca (afferent) = load-bearing, risky to change interface
-- High Ce (efferent) = depends on many things, safe to refactor internals
-- Surprising edges = hidden coupling that may break during refactoring
-`,
-    "kirograph-onboard.md": `---
+   kirograph_node(symbol: "<symbol name>", includeCode: true)
+   \`\`\``);
+  const onboardTips = ["- Start broad (status, files) then narrow down"];
+  if (enableCodeHealth) onboardTips[0] = "- Start broad (status, files, hotspots) then narrow down";
+  if (enableAdvancedAnalysis) onboardTips.push("- Use `kirograph_type_hierarchy` to understand inheritance patterns");
+  if (trackCallSites) onboardTips.push("- Use `kirograph_callees` on entry points to trace execution flow");
+  fs.writeFileSync(path.join(steeringDir, "kirograph-onboard.md"), `---
 inclusion: manual
 ---
 
@@ -674,42 +779,49 @@ Follow these steps to quickly understand a new codebase.
 
 ## Steps
 
-1. **Project overview**
-   \`\`\`
-   kirograph_status()
-   \`\`\`
-
-2. **File structure**
-   \`\`\`
-   kirograph_files(format: "tree", maxDepth: 2)
-   \`\`\`
+${onboardSteps.join("\n\n")}
 
-3. **Key entry points**
-   \`\`\`
-   kirograph_hotspots(limit: 15)
-   \`\`\`
-
-4. **Architecture layers**
+## Tips
+${onboardTips.join("\n")}
+`);
+  const refactorSteps = [
+    `1. **Understand what you're changing**
    \`\`\`
-   kirograph_architecture()
+   kirograph_node(symbol: "<target symbol>", includeCode: true)
+   \`\`\``,
+    `2. **Check blast radius**
    \`\`\`
-
-5. **Explore a specific area**
+   kirograph_impact(symbol: "<target symbol>", depth: 3)
+   \`\`\``
+  ];
+  if (trackCallSites) {
+    refactorSteps.push(`3. **Find all callers (rename preview)**
    \`\`\`
-   kirograph_context(task: "<area you want to understand>")
+   kirograph_callers(symbol: "<target symbol>", limit: 50)
+   \`\`\``);
+  }
+  if (enableCodeHealth) {
+    let n = refactorSteps.length + 1;
+    refactorSteps.push(`${n}. **Check for cycles that might complicate the refactor**
    \`\`\`
-
-6. **Understand a key symbol**
+   kirograph_circular_deps()
+   \`\`\``);
+    n++;
+    refactorSteps.push(`${n}. **Find dead code to clean up**
    \`\`\`
-   kirograph_node(symbol: "<symbol name>", includeCode: true)
+   kirograph_dead_code(limit: 30)
+   \`\`\``);
+    n++;
+    refactorSteps.push(`${n}. **Verify after changes**
+   Run \`kirograph sync\` then:
    \`\`\`
-
-## Tips
-- Start broad (status, files, hotspots) then narrow down
-- Use \`kirograph_type_hierarchy\` to understand inheritance patterns
-- Use \`kirograph_callees\` on entry points to trace execution flow
-`,
-    "kirograph-refactor.md": `---
+   kirograph_diff()
+   \`\`\``);
+  }
+  const refactorChecks = ["- Always check `kirograph_impact` before major refactors"];
+  if (trackCallSites) refactorChecks.push("- Use `kirograph_callers` as a rename preview (all locations that reference the symbol)");
+  if (enableCodeHealth) refactorChecks.push("- After changes, use `kirograph_diff` to verify only intended symbols changed");
+  fs.writeFileSync(path.join(steeringDir, "kirograph-refactor.md"), `---
 inclusion: manual
 ---
 
@@ -719,49 +831,59 @@ Follow these steps to plan and execute safe refactoring.
 
 ## Steps
 
-1. **Understand what you're changing**
-   \`\`\`
-   kirograph_node(symbol: "<target symbol>", includeCode: true)
-   \`\`\`
+${refactorSteps.join("\n\n")}
 
-2. **Check blast radius**
+## Safety Checks
+${refactorChecks.join("\n")}
+`);
+  if (enableArchitecture) {
+    const archSteps = [
+      `1. **Get project overview**
    \`\`\`
-   kirograph_impact(symbol: "<target symbol>", depth: 3)
+   kirograph_status()
+   \`\`\``,
+      `2. **View architecture**
    \`\`\`
-
-3. **Find all callers (rename preview)**
+   kirograph_architecture()
+   \`\`\``,
+      `3. **Check coupling health**
    \`\`\`
-   kirograph_callers(symbol: "<target symbol>", limit: 50)
+   kirograph_coupling(sortBy: "instability")
+   \`\`\``
+    ];
+    if (enableCodeHealth) {
+      let n = archSteps.length + 1;
+      archSteps.push(`${n}. **Find core abstractions**
    \`\`\`
-
-4. **Check for cycles that might complicate the refactor**
+   kirograph_hotspots(limit: 20)
+   \`\`\``);
+      n++;
+      archSteps.push(`${n}. **Detect hidden dependencies**
    \`\`\`
-   kirograph_circular_deps()
+   kirograph_surprising(limit: 15)
+   \`\`\``);
+      n++;
+      archSteps.push(`${n}. **Check for cycles**
    \`\`\`
+   kirograph_circular_deps()
+   \`\`\``);
+    }
+    fs.writeFileSync(path.join(steeringDir, "kirograph-architecture.md"), `---
+inclusion: manual
+---
 
-5. **Find dead code to clean up**
-   \`\`\`
-   kirograph_dead_code(limit: 30)
-   \`\`\`
+# KiroGraph: Architecture Exploration Workflow
 
-6. **Verify after changes**
-   Run \`kirograph sync\` then:
-   \`\`\`
-   kirograph_diff()
-   \`\`\`
+Follow these steps to understand the high-level structure of the codebase.
 
-## Safety Checks
-- Always check \`kirograph_impact\` before major refactors
-- Use \`kirograph_callers\` as a rename preview (all locations that reference the symbol)
-- After changes, use \`kirograph_diff\` to verify only intended symbols changed
-`
-  };
-  if (opts?.enableArchitecture) {
-    fs.writeFileSync(path.join(steeringDir, "kirograph-architecture.md"), workflows["kirograph-architecture.md"]);
-  }
-  for (const [filename, content] of Object.entries(workflows)) {
-    if (filename === "kirograph-architecture.md") continue;
-    fs.writeFileSync(path.join(steeringDir, filename), content);
+## Steps
+
+${archSteps.join("\n\n")}
+
+## Interpretation
+- High Ca (afferent) = load-bearing, risky to change interface
+- High Ce (efferent) = depends on many things, safe to refactor internals
+${enableCodeHealth ? "- Surprising edges = hidden coupling that may break during refactoring\n" : ""}`);
   }
   if (opts?.enableSecurity) {
     fs.writeFileSync(path.join(steeringDir, "kirograph-security.md"), `---
@@ -907,10 +1029,230 @@ rule:
 `);
     console.log(`  \u2713 Patterns workflow steering file written`);
   }
+  if (opts?.enableWiki) {
+    fs.writeFileSync(path.join(steeringDir, "kirograph-wiki-workflow.md"), `---
+inclusion: manual
+---
+
+# KiroGraph: Wiki Workflow
+
+Use this workflow when you need to consult or update the project wiki.
+Activate with \`/kirograph-wiki-workflow\` in Kiro IDE or read the file directly.
+
+## When to use
+
+- Before a complex task: look up relevant wiki pages
+- After a session with durable knowledge: ingest it into the wiki
+- After a source file is added: run ingest to capture its content
+- Periodically: run lint to catch broken links or contradictions
+
+## Steps
+
+### 1. Look up existing knowledge before starting work
+
+\`\`\`
+kirograph_wiki_search(query: "<topic or keyword>")
+\`\`\`
+
+Read any relevant pages:
+
+\`\`\`
+kirograph_wiki_page(slug: "<slug from search results>")
+\`\`\`
+
+### 2. Ingest new knowledge (two-tool flow)
+
+**a. Get the ingest prompt:**
+
+\`\`\`
+kirograph_wiki_ingest(source: "<text, notes, or paste from docs>", sourceName: "<descriptive name>")
+\`\`\`
+
+The tool returns a structured prompt containing the wiki SCHEMA, the current MANIFEST, and your source text.
+
+**b. Generate the WIKI_DIFF:**
+
+Pass the returned prompt to yourself. Produce a \`WIKI_DIFF_START ... WIKI_DIFF_END\` block following the schema. Each entry should have a JSON header with \`action\`, \`slug\`, \`title\`, and \`section\` (optional), followed by markdown content.
+
+**c. Apply the diff:**
+
+\`\`\`
+kirograph_wiki_apply_diff(diff: "<the WIKI_DIFF block you generated>")
+\`\`\`
+
+Review the response for any pending conflicts and resolve them.
+
+### 3. List all pages
+
+\`\`\`
+kirograph_wiki_list()
+\`\`\`
+
+### 4. Health check (periodic)
+
+\`\`\`
+kirograph_wiki_lint()
+\`\`\`
+
+Issues to look for:
+- \`broken_link\`: a \`[[slug]]\` reference that points to a non-existent page \u2192 fix the slug or create the page
+- \`orphan\`: a page with no Related section and no incoming links \u2192 add Related or merge into another page
+- \`stale_source\`: a source with no date metadata \u2192 add a date to the source header
+- \`contradiction\`: two pages make semantically opposite claims \u2192 resolve via ingest or manual edit
+
+## WIKI_DIFF format reference
+
+\`\`\`
+WIKI_DIFF_START
+{"action": "create", "slug": "auth-flow", "title": "Authentication Flow"}
+# Authentication Flow
+
+The login flow validates credentials via JWT...
+
+## Related
+- [[user-model]]
+WIKI_DIFF_END
+\`\`\`
+
+Supported actions: \`create\`, \`upsert\` (merge into existing), \`append\` (add to specific section).
+
+For append, include \`"section": "Known Issues"\` in the header.
+
+## Conflict handling
+
+If a diff contradicts an existing page, the tool reports it as a conflict:
+- With \`wikiAutoResolveConflicts: true\`: the newer source wins automatically
+- Without: the conflict is listed in the response \u2014 read both sides and ingest a resolution
+
+## CLI commands
+
+\`\`\`bash
+kirograph wiki search "<query>"
+kirograph wiki page <slug>
+kirograph wiki list
+kirograph wiki lint
+kirograph wiki status
+kirograph wiki reindex
+\`\`\`
+`);
+    console.log(`  \u2713 Wiki workflow steering file written`);
+  }
+  if (opts?.enableMemory) {
+    fs.writeFileSync(path.join(steeringDir, "kirograph-mem-workflow.md"), `---
+inclusion: manual
+---
+
+# KiroGraph: Memory Workflow
+
+Use this workflow to recall past knowledge, store new observations, and keep the memory base
+consistent by detecting and resolving conflicts.
+
+## 1. Recall before acting
+
+Before making an architecture decision or fixing a bug, search what's already known:
+
+\`\`\`
+kirograph_mem_search(query: "<topic or keywords>", kind: "decision")
+kirograph_mem_search(query: "<error symptom>", kind: "error")
+\`\`\`
+
+Results include inline conflict annotations (\u26A1) \u2014 review them before proceeding.
+
+## 2. Store a new observation
+
+After a decision, bug fix, or discovery:
+
+\`\`\`
+kirograph_mem_store(
+  content: "<one concise fact>",
+  kind: "decision" | "error" | "pattern" | "architecture" | "note",
+  topicKey: "<category/slug>",      // optional: stable semantic key for revisitable decisions
+  reviewAfter: <epoch-ms>           // optional: schedule re-evaluation after a migration/upgrade
+)
+\`\`\`
+
+**topicKey examples:** \`"architecture/auth-model"\`, \`"infra/db-choice"\`, \`"pattern/error-handling"\`
+
+## 3. Capture observations from structured text
+
+If you have a markdown block with bullet points under headings like \`## Key Learnings\` or
+\`## Decisions\`, extract them all at once:
+
+\`\`\`
+kirograph_mem_capture(content: "<markdown text>", kind: "decision")
+\`\`\`
+
+## 4. Detect conflicts
+
+After storing related observations, scan for potential contradictions:
+
+\`\`\`
+kirograph_mem_conflicts_scan(limit: 20)
+\`\`\`
+
+Returns candidate pairs ranked by similarity. Review each one.
+
+## 5. Compare two observations
+
+To understand if two observations conflict, are compatible, or one supersedes the other:
+
+\`\`\`
+kirograph_mem_compare(observationA: "<id or topicKey>", observationB: "<id or topicKey>")
+\`\`\`
+
+Returns both observations side by side. Read them, then judge.
+
+## 6. Judge a relation
+
+\`\`\`
+kirograph_mem_judge(
+  relationId: "<id>",
+  relation: "supersedes" | "conflicts_with" | "compatible" | "scoped" | "related" | "not_conflict",
+  confidence: 0.0\u20131.0,
+  reason: "<why>"
+)
+\`\`\`
+
+Use \`supersedes\` when a newer decision replaces an older one. Use \`not_conflict\` to dismiss
+false positives so they don't reappear in scans.
+
+## 7. Review stale observations
+
+Find observations scheduled for re-evaluation:
+
+\`\`\`
+kirograph_mem_review(limit: 20)
+\`\`\`
+
+For each: verify it's still accurate. If valid, mark it reviewed:
+
+\`\`\`
+kirograph_mem_mark_reviewed(id: "<observation-id>")
+\`\`\`
+
+If outdated, store a new observation with the correct information and judge the old one as
+superseded via \`kirograph_mem_judge\`.
+
+## Quick reference
+
+| Situation | Action |
+|-----------|--------|
+| About to make a decision | \`mem_search\` first |
+| Made a decision | \`mem_store\` with \`kind: "decision"\` and \`topicKey\` |
+| Fixed a non-obvious bug | \`mem_store\` with \`kind: "error"\` |
+| Two things seem to contradict | \`mem_compare\` \u2192 \`mem_judge\` |
+| Knowledge base getting stale | \`mem_review\` \u2192 \`mem_mark_reviewed\` |
+| Structured notes to extract | \`mem_capture\` |
+| Regular conflict hygiene | \`mem_conflicts_scan\` |
+`);
+    console.log(`  \u2713 Memory workflow steering file written`);
+  }
   const written = ["review", "debug", "onboard", "refactor"];
   if (opts?.enableArchitecture) written.push("architecture");
   if (opts?.enableSecurity) written.push("security");
   if (opts?.enablePatterns) written.push("patterns");
+  if (opts?.enableMemory) written.push("memory");
+  if (opts?.enableWiki) written.push("wiki");
   console.log(`  \u2713 Workflow steering files written (${written.join(", ")})`);
 }
 // Annotate the CommonJS export names for ESM import in node: