@zabaca/lattice 1.1.1 → 1.2.0

package/commands/research.md

@@ -8,7 +8,7 @@ Research the topic "$ARGUMENTS" by first checking existing documentation, then p
 
 ## Configuration
 
-**⚠️ CRITICAL: All documentation lives in `~/.lattice/docs/`**
+**CRITICAL: All documentation lives in `~/.lattice/docs/`**
 
 | Path | Purpose |
 |------|---------|
@@ -21,22 +21,37 @@ Research the topic "$ARGUMENTS" by first checking existing documentation, then p
 
 ## Process
 
-### Step 1: Search Existing Research
+### Step 1: Create or Find Question
 
-Run semantic search to find related documents:
+First, search to see if this question (or similar) already exists:
 
 ```bash
-lattice search "$ARGUMENTS" --limit 10
+lattice search "$ARGUMENTS" --limit 5
+```
+
+Look for results with `[Question]` label and high similarity (>70%).
+
+**If similar question exists:** Use that existing question (don't duplicate).
+
+**If no similar question:** Create the question entity:
+
+```bash
+lattice question:add "$ARGUMENTS"
 ```
 
-### Step 2: Review Search Results
+This ensures the question is tracked regardless of whether we find an answer.
 
-Review the top results from the semantic search:
+### Step 2: Search for Answers
 
-1. **Read top results** regardless of path - high similarity may indicate related content
-2. **Path/title matching** is a bonus signal, not a filter
-3. **Don't dismiss** high-similarity docs just because path doesn't match query
-4. Use judgment after reading - the doc content determines relevance, not the filename
+Search for documents that might answer this question:
+
+```bash
+lattice search "$ARGUMENTS" --limit 10
+```
+
+Review results focusing on:
+- Documents (`[Document]` label) with relevant content
+- High similarity scores (>40% often indicates relevance)
 
 **Calibration notes:**
 - Exact topic matches often show 30-40% similarity
@@ -48,13 +63,21 @@ For each promising result:
 - Check if it answers the user's question
 - Note relevant sections
 
-### Step 3: Present Findings to User
+### Step 3: Present Findings and Link Answer
 
 Summarize what you found in existing docs:
 - What topics are covered
 - Quote relevant sections if helpful
 - Identify gaps in existing research
 
+**If existing documentation answers the question:**
+
+Link the question to the answering document:
+
+```bash
+lattice question:link "$ARGUMENTS" --doc {path-to-doc}
+```
+
 Ask the user: **"Does this existing research cover your question?"**
 
 ### Step 4: Ask About New Research
@@ -148,23 +171,43 @@ What this research addresses.
 **2. Update** `~/.lattice/docs/{topic-name}/README.md`:
 - Add new row to the Documents table
 
-### Step 8: Confirmation
+### Step 8: Sync and Link Question
+
+After creating files, sync to the knowledge graph:
+
+```bash
+lattice sync
+```
+
+This will:
+- Add documents to the graph
+- Extract entities automatically via AI
+- Generate embeddings for semantic search
 
-After creating files, confirm:
+Then link the question to the new document:
+
+```bash
+lattice question:link "$ARGUMENTS" --doc ~/.lattice/docs/{topic-name}/{research-filename}.md
+```
+
+### Step 9: Confirmation
+
+Confirm to the user:
+- Question entity created/found
 - Topic directory path
-- README.md created/updated
-- Research file created with name
-- Remind user to run `/graph-sync` to sync to knowledge graph
+- Research file created
+- Question linked to document via ANSWERED_BY
+- Sync completed
 
 ## Important Notes
 
-- **Do NOT** auto-run graph sync - use `/graph-sync` separately
 - **Always create README.md** for new topics (lightweight index)
 - **Always create separate research file** (never put research content in README)
 - Use kebab-case for all directory and file names
 - Always cite sources with URLs
 - Cross-link to related research topics when relevant
 - **No frontmatter needed** - AI extracts entities automatically during sync
+- **Questions track user intent** - even if a doc exists, the question helps future discovery
 
 ## File Structure Standard
 
@@ -177,3 +220,12 @@ After creating files, confirm:
 ```
 
 This structure allows topics to grow organically while keeping README as a clean navigation index.
+
+## Question Commands Reference
+
+| Command | Purpose |
+|---------|---------|
+| `lattice question:add "question"` | Create a question entity |
+| `lattice question:add "question" --answered-by path` | Create and link in one step |
+| `lattice question:link "question" --doc path` | Link question to answering doc |
+| `lattice question:unanswered` | List questions without answers |

package/dist/main.js

@@ -38,7 +38,38 @@ import {
   tool
 } from "@anthropic-ai/claude-agent-sdk";
 import { Injectable, Logger } from "@nestjs/common";
+import { z as z2 } from "zod";
+
+// src/graph/graph.types.ts
 import { z } from "zod";
+var EntityTypeSchema = z.enum([
+  "Topic",
+  "Technology",
+  "Concept",
+  "Tool",
+  "Process",
+  "Person",
+  "Organization",
+  "Document",
+  "Question"
+]);
+var RelationTypeSchema = z.enum(["REFERENCES", "ANSWERED_BY"]);
+var EntitySchema = z.object({
+  name: z.string().min(1),
+  type: EntityTypeSchema,
+  description: z.string().optional()
+});
+var RelationshipSchema = z.object({
+  source: z.string().min(1),
+  relation: RelationTypeSchema,
+  target: z.string().min(1)
+});
+var GraphMetadataSchema = z.object({
+  importance: z.enum(["high", "medium", "low"]).optional(),
+  domain: z.string().optional()
+});
+
+// src/sync/entity-extractor.service.ts
 function validateExtraction(input, _filePath) {
   const errors = [];
   const { entities, relationships } = input ?? {};
@@ -65,26 +96,17 @@ function createValidationServer(filePath) {
     version: "1.0.0",
     tools: [
       tool("validate_extraction", "Validate your extracted entities and relationships. Call this to check your work before finishing.", {
-        entities: z.array(z.object({
-          name: z.string().min(1),
-          type: z.enum([
-            "Topic",
-            "Technology",
-            "Concept",
-            "Tool",
-            "Process",
-            "Person",
-            "Organization",
-            "Document"
-          ]),
-          description: z.string().min(1)
+        entities: z2.array(z2.object({
+          name: z2.string().min(1),
+          type: EntityTypeSchema,
+          description: z2.string().min(1)
         })),
-        relationships: z.array(z.object({
-          source: z.string().min(1),
-          relation: z.enum(["REFERENCES"]),
-          target: z.string().min(1)
+        relationships: z2.array(z2.object({
+          source: z2.string().min(1),
+          relation: RelationTypeSchema,
+          target: z2.string().min(1)
         })),
-        summary: z.string().min(10)
+        summary: z2.string().min(10)
       }, async (args) => {
         const errors = validateExtraction(args, filePath);
         if (errors.length === 0) {
@@ -210,15 +232,17 @@ Extract the following and call the validation tool with EXACTLY this schema:
 ### 1. Entities (array of 3-10 objects)
 Each entity must have:
 - "name": string (entity name)
-- "type": one of "Topic", "Technology", "Concept", "Tool", "Process", "Person", "Organization", "Document"
+- "type": one of "Topic", "Technology", "Concept", "Tool", "Process", "Person", "Organization", "Document", "Question"
 - "description": string (brief description)
 
 ### 2. Relationships (array of objects)
 Each relationship must have:
 - "source": "this" (for document-to-entity) or an entity name
-- "relation": "REFERENCES" (IMPORTANT: use "relation", not "type")
+- "relation": "REFERENCES" or "ANSWERED_BY" (IMPORTANT: use "relation", not "type")
 - "target": an entity name from your entities list
 
+Use ANSWERED_BY when a Question entity is answered by this document (source: Question name, target: "this").
+
 ### 3. Summary
 A 50-100 word summary of the document's main purpose and key concepts.
 
@@ -405,7 +429,7 @@ function ensureLatticeHome() {
 // src/commands/init.command.ts
 var __filename2 = fileURLToPath(import.meta.url);
 var __dirname2 = path.dirname(__filename2);
-var COMMANDS = ["research.md", "graph-sync.md", "entity-extract.md"];
+var COMMANDS = ["research.md", "entity-extract.md"];
 var SITE_TEMPLATE_FILES = [
   "astro.config.ts",
   "package.json",
@@ -465,9 +489,13 @@ OBSIDIAN_VAULT_DIR=docs
       console.log();
       console.log("Claude Code slash commands:");
       console.log("  /research <topic>    - AI-assisted research workflow");
-      console.log("  /graph-sync          - Extract entities and sync to graph");
       console.log("  /entity-extract      - Extract entities from a document");
       console.log();
+      console.log("Question tracking:");
+      console.log("  lattice question:add <question>      - Add a question");
+      console.log("  lattice question:link <q> --doc <p>  - Link question to answer");
+      console.log("  lattice question:unanswered          - List unanswered questions");
+      console.log();
       if (!(await fs.readFile(envPath, "utf-8")).includes("pa-")) {
         console.log(`\u26A0\uFE0F  Add your Voyage API key to: ${envPath}`);
         console.log();
@@ -513,7 +541,7 @@ OBSIDIAN_VAULT_DIR=docs
         await fs.mkdir(path.dirname(targetPath), { recursive: true });
         await fs.copyFile(sourcePath, targetPath);
         copied++;
-      } catch (err) {}
+      } catch (_err) {}
     }
     if (copied > 0) {
       console.log(`\u2705 Site template: ${copied} file(s) installed`);
@@ -557,7 +585,7 @@ OBSIDIAN_VAULT_DIR=docs
         await fs.copyFile(sourcePath, targetPath);
         installed.push(file);
         copied++;
-      } catch (err) {}
+      } catch (_err) {}
     }
     if (copied > 0) {
       console.log(`\u2705 Claude commands: ${copied} installed to ${targetDir}`);
@@ -1081,18 +1109,18 @@ import { readFile as readFile3, writeFile } from "fs/promises";
 import { Injectable as Injectable5 } from "@nestjs/common";
 
 // src/schemas/manifest.schemas.ts
-import { z as z2 } from "zod";
-var ManifestEntrySchema = z2.object({
-  contentHash: z2.string(),
-  frontmatterHash: z2.string(),
-  lastSynced: z2.string(),
-  entityCount: z2.number().int().nonnegative(),
-  relationshipCount: z2.number().int().nonnegative()
+import { z as z3 } from "zod";
+var ManifestEntrySchema = z3.object({
+  contentHash: z3.string(),
+  frontmatterHash: z3.string(),
+  lastSynced: z3.string(),
+  entityCount: z3.number().int().nonnegative(),
+  relationshipCount: z3.number().int().nonnegative()
 });
-var SyncManifestSchema = z2.object({
-  version: z2.string(),
-  lastSync: z2.string(),
-  documents: z2.record(z2.string(), ManifestEntrySchema)
+var SyncManifestSchema = z3.object({
+  version: z3.string(),
+  lastSync: z3.string(),
+  documents: z3.record(z3.string(), ManifestEntrySchema)
 });
 
 // src/sync/manifest.service.ts
@@ -1184,15 +1212,15 @@ import { Injectable as Injectable6, Logger as Logger3 } from "@nestjs/common";
 import { ConfigService as ConfigService2 } from "@nestjs/config";
 
 // src/schemas/config.schemas.ts
-import { z as z3 } from "zod";
-var DuckDBConfigSchema = z3.object({
-  embeddingDimensions: z3.coerce.number().int().positive().default(512)
+import { z as z4 } from "zod";
+var DuckDBConfigSchema = z4.object({
+  embeddingDimensions: z4.coerce.number().int().positive().default(512)
 });
-var EmbeddingConfigSchema = z3.object({
-  provider: z3.enum(["openai", "voyage", "nomic", "mock"]).default("voyage"),
-  apiKey: z3.string().optional(),
-  model: z3.string().min(1).default("voyage-3.5-lite"),
-  dimensions: z3.coerce.number().int().positive().default(512)
+var EmbeddingConfigSchema = z4.object({
+  provider: z4.enum(["openai", "voyage", "nomic", "mock"]).default("voyage"),
+  apiKey: z4.string().optional(),
+  model: z4.string().min(1).default("voyage-3.5-lite"),
+  dimensions: z4.coerce.number().int().positive().default(512)
 });
 
 // src/embedding/embedding.types.ts
@@ -1285,17 +1313,17 @@ class OpenAIEmbeddingProvider {
 }
 
 // src/schemas/embedding.schemas.ts
-import { z as z4 } from "zod";
-var VoyageEmbeddingResponseSchema = z4.object({
-  object: z4.string(),
-  data: z4.array(z4.object({
-    object: z4.string(),
-    embedding: z4.array(z4.number()),
-    index: z4.number().int().nonnegative()
+import { z as z5 } from "zod";
+var VoyageEmbeddingResponseSchema = z5.object({
+  object: z5.string(),
+  data: z5.array(z5.object({
+    object: z5.string(),
+    embedding: z5.array(z5.number()),
+    index: z5.number().int().nonnegative()
   })),
-  model: z4.string(),
-  usage: z4.object({
-    total_tokens: z4.number().int().nonnegative()
+  model: z5.string(),
+  usage: z5.object({
+    total_tokens: z5.number().int().nonnegative()
   })
 });
 
@@ -1606,8 +1634,8 @@ import { glob } from "glob";
 
 // src/utils/frontmatter.ts
 import matter from "gray-matter";
-import { z as z5 } from "zod";
-var EntityTypeSchema = z5.enum([
+import { z as z6 } from "zod";
+var EntityTypeSchema2 = z6.enum([
   "Topic",
   "Technology",
   "Concept",
@@ -1617,20 +1645,20 @@ var EntityTypeSchema = z5.enum([
   "Organization",
   "Document"
 ]);
-var RelationTypeSchema = z5.enum(["REFERENCES"]);
-var EntitySchema = z5.object({
-  name: z5.string().min(1),
-  type: EntityTypeSchema,
-  description: z5.string().min(1)
+var RelationTypeSchema2 = z6.enum(["REFERENCES"]);
+var EntitySchema2 = z6.object({
+  name: z6.string().min(1),
+  type: EntityTypeSchema2,
+  description: z6.string().min(1)
 });
-var RelationshipSchema = z5.object({
-  source: z5.string().min(1),
-  relation: RelationTypeSchema,
-  target: z5.string().min(1)
+var RelationshipSchema2 = z6.object({
+  source: z6.string().min(1),
+  relation: RelationTypeSchema2,
+  target: z6.string().min(1)
 });
-var GraphMetadataSchema = z5.object({
-  importance: z5.enum(["high", "medium", "low"]).optional(),
-  domain: z5.string().optional()
+var GraphMetadataSchema2 = z6.object({
+  importance: z6.enum(["high", "medium", "low"]).optional(),
+  domain: z6.string().optional()
 });
 var validateDateFormat = (dateStr) => {
   const match = dateStr.match(/^(\d{4})-(\d{2})-(\d{2})$/);
@@ -1650,16 +1678,16 @@ var validateDateFormat = (dateStr) => {
   }
   return day <= daysInMonth[month - 1];
 };
-var FrontmatterSchema = z5.object({
-  created: z5.string().refine(validateDateFormat, "Date must be in YYYY-MM-DD format"),
-  updated: z5.string().refine(validateDateFormat, "Date must be in YYYY-MM-DD format"),
-  status: z5.enum(["draft", "ongoing", "complete"]).optional(),
-  topic: z5.string().optional(),
-  tags: z5.array(z5.string()).optional(),
-  summary: z5.string().optional(),
-  entities: z5.array(EntitySchema).optional(),
-  relationships: z5.array(RelationshipSchema).optional(),
-  graph: GraphMetadataSchema.optional()
+var FrontmatterSchema = z6.object({
+  created: z6.string().refine(validateDateFormat, "Date must be in YYYY-MM-DD format"),
+  updated: z6.string().refine(validateDateFormat, "Date must be in YYYY-MM-DD format"),
+  status: z6.enum(["draft", "ongoing", "complete"]).optional(),
+  topic: z6.string().optional(),
+  tags: z6.array(z6.string()).optional(),
+  summary: z6.string().optional(),
+  entities: z6.array(EntitySchema2).optional(),
+  relationships: z6.array(RelationshipSchema2).optional(),
+  graph: GraphMetadataSchema2.optional()
 }).passthrough();
 function parseFrontmatter(content) {
   try {
@@ -1775,7 +1803,7 @@ class DocumentParserService {
     if (!fm?.graph) {
       return;
     }
-    const result = GraphMetadataSchema.safeParse(fm.graph);
+    const result = GraphMetadataSchema2.safeParse(fm.graph);
     return result.success ? result.data : undefined;
   }
   computeHash(content) {
@@ -3197,13 +3225,244 @@ SqlCommand = __legacyDecorateClassTS([
     typeof GraphService === "undefined" ? Object : GraphService
   ])
 ], SqlCommand);
+// src/commands/question.command.ts
+import { Injectable as Injectable16 } from "@nestjs/common";
+import { Command as Command6, CommandRunner as CommandRunner6, Option as Option4 } from "nest-commander";
+function escapeSql(value) {
+  return value.replace(/'/g, "''");
+}
+
+class QuestionAddCommand extends CommandRunner6 {
+  graphService;
+  embeddingService;
+  constructor(graphService, embeddingService) {
+    super();
+    this.graphService = graphService;
+    this.embeddingService = embeddingService;
+  }
+  async run(inputs, options) {
+    const questionText = inputs[0];
+    if (!questionText) {
+      console.error("Error: Question text is required");
+      console.error('Usage: lattice question:add "your question"');
+      process.exit(1);
+    }
+    try {
+      await this.graphService.upsertNode("Question", {
+        name: questionText,
+        text: questionText,
+        createdAt: new Date().toISOString()
+      });
+      const embedding = await this.embeddingService.generateEmbedding(`Question: ${questionText}`);
+      await this.graphService.updateNodeEmbedding("Question", questionText, embedding);
+      console.log(`
+\u2705 Added question: "${questionText}"`);
+      if (options.answeredBy) {
+        const docResult = await this.graphService.query(`
+					SELECT name FROM nodes
+					WHERE label = 'Document' AND name = '${escapeSql(options.answeredBy)}'
+				`);
+        if (docResult.resultSet.length === 0) {
+          console.log(`
+\u26A0\uFE0F  Document not found: ${options.answeredBy}`);
+          console.log("   Run 'lattice sync' first to add documents to the graph.");
+          console.log(`   Question was created but not linked.
+`);
+          process.exit(0);
+        }
+        await this.graphService.upsertRelationship("Question", questionText, "ANSWERED_BY", "Document", options.answeredBy, {});
+        console.log(`   Linked to: ${options.answeredBy}`);
+      }
+      console.log();
+      process.exit(0);
+    } catch (error) {
+      console.error("Error:", error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  }
+  parseAnsweredBy(value) {
+    return value;
+  }
+}
+__legacyDecorateClassTS([
+  Option4({
+    flags: "--answered-by <path>",
+    description: "Immediately link to a document that answers this question"
+  }),
+  __legacyMetadataTS("design:type", Function),
+  __legacyMetadataTS("design:paramtypes", [
+    String
+  ]),
+  __legacyMetadataTS("design:returntype", String)
+], QuestionAddCommand.prototype, "parseAnsweredBy", null);
+QuestionAddCommand = __legacyDecorateClassTS([
+  Injectable16(),
+  Command6({
+    name: "question:add",
+    arguments: "<question>",
+    description: "Add a new question to the knowledge graph"
+  }),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof GraphService === "undefined" ? Object : GraphService,
+    typeof EmbeddingService === "undefined" ? Object : EmbeddingService
+  ])
+], QuestionAddCommand);
+
+class QuestionLinkCommand extends CommandRunner6 {
+  graphService;
+  embeddingService;
+  constructor(graphService, embeddingService) {
+    super();
+    this.graphService = graphService;
+    this.embeddingService = embeddingService;
+  }
+  async run(inputs, options) {
+    const questionText = inputs[0];
+    if (!questionText) {
+      console.error("Error: Question text is required");
+      console.error('Usage: lattice question:link "your question" --doc path/to/doc.md');
+      process.exit(1);
+    }
+    if (!options.doc) {
+      console.error("Error: --doc flag is required");
+      console.error('Usage: lattice question:link "your question" --doc path/to/doc.md');
+      process.exit(1);
+    }
+    try {
+      const existingQuestions = await this.graphService.query(`
+				SELECT name FROM nodes
+				WHERE label = 'Question' AND name = '${escapeSql(questionText)}'
+			`);
+      if (existingQuestions.resultSet.length === 0) {
+        await this.graphService.upsertNode("Question", {
+          name: questionText,
+          text: questionText,
+          createdAt: new Date().toISOString()
+        });
+        const embedding = await this.embeddingService.generateEmbedding(`Question: ${questionText}`);
+        await this.graphService.updateNodeEmbedding("Question", questionText, embedding);
+        console.log(`
+\u2705 Created question: "${questionText}"`);
+      }
+      const existingDocs = await this.graphService.query(`
+				SELECT name FROM nodes
+				WHERE label = 'Document' AND name = '${escapeSql(options.doc)}'
+			`);
+      if (existingDocs.resultSet.length === 0) {
+        console.error(`
+\u274C Document not found in graph: ${options.doc}`);
+        console.error(`   Run 'lattice sync' first to add documents to the graph.
+`);
+        process.exit(1);
+      }
+      await this.graphService.upsertRelationship("Question", questionText, "ANSWERED_BY", "Document", options.doc, {});
+      console.log(`
+\u2705 Linked: "${questionText}"`);
+      console.log(`        \u2192 ${options.doc}
+`);
+      process.exit(0);
+    } catch (error) {
+      console.error("Error:", error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  }
+  parseDoc(value) {
+    return value;
+  }
+}
+__legacyDecorateClassTS([
+  Option4({
+    flags: "-d, --doc <path>",
+    description: "Path to the document that answers this question"
+  }),
+  __legacyMetadataTS("design:type", Function),
+  __legacyMetadataTS("design:paramtypes", [
+    String
+  ]),
+  __legacyMetadataTS("design:returntype", String)
+], QuestionLinkCommand.prototype, "parseDoc", null);
+QuestionLinkCommand = __legacyDecorateClassTS([
+  Injectable16(),
+  Command6({
+    name: "question:link",
+    arguments: "<question>",
+    description: "Link a question to a document via ANSWERED_BY relationship"
+  }),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof GraphService === "undefined" ? Object : GraphService,
+    typeof EmbeddingService === "undefined" ? Object : EmbeddingService
+  ])
+], QuestionLinkCommand);
+
+class QuestionUnansweredCommand extends CommandRunner6 {
+  graphService;
+  constructor(graphService) {
+    super();
+    this.graphService = graphService;
+  }
+  async run() {
+    try {
+      const result = await this.graphService.query(`
+				SELECT
+					q.name as question,
+					q.properties->>'createdAt' as created_at,
+					q.created_at as db_created_at
+				FROM nodes q
+				WHERE q.label = 'Question'
+					AND NOT EXISTS (
+						SELECT 1 FROM relationships r
+						WHERE r.source_label = 'Question'
+							AND r.source_name = q.name
+							AND r.relation_type = 'ANSWERED_BY'
+					)
+				ORDER BY COALESCE(q.properties->>'createdAt', q.created_at::VARCHAR) DESC
+			`);
+      console.log(`
+=== Unanswered Questions ===
+`);
+      if (result.resultSet.length === 0) {
+        console.log(`No unanswered questions found.
+`);
+        console.log(`Add questions with: lattice question:add "your question"
+`);
+        process.exit(0);
+      }
+      result.resultSet.forEach((row, idx) => {
+        const [question, createdAt, dbCreatedAt] = row;
+        const displayDate = createdAt || dbCreatedAt || "unknown";
+        console.log(`${idx + 1}. ${question}`);
+        console.log(`   Created: ${displayDate}`);
+      });
+      console.log(`
+Total: ${result.resultSet.length} unanswered question(s)
+`);
+      console.log("To link a question to an answer:");
+      console.log(`  lattice question:link "question text" --doc path/to/doc.md
+`);
+      process.exit(0);
+    } catch (error) {
+      console.error("Error:", error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  }
+}
+QuestionUnansweredCommand = __legacyDecorateClassTS([
+  Injectable16(),
+  Command6({
+    name: "question:unanswered",
+    description: "List all questions without ANSWERED_BY relationships"
+  }),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof GraphService === "undefined" ? Object : GraphService
+  ])
+], QuestionUnansweredCommand);
 // src/commands/site.command.ts
 import { spawn } from "child_process";
 import { existsSync as existsSync6, readFileSync as readFileSync2, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
 import * as path2 from "path";
-import { Injectable as Injectable16 } from "@nestjs/common";
-import { Command as Command6, CommandRunner as CommandRunner6, Option as Option4 } from "nest-commander";
-class SiteCommand extends CommandRunner6 {
+import { Injectable as Injectable17 } from "@nestjs/common";
+import { Command as Command7, CommandRunner as CommandRunner7, Option as Option5 } from "nest-commander";
+class SiteCommand extends CommandRunner7 {
   getPidFile() {
     return path2.join(getLatticeHome(), "site.pid");
   }
@@ -3336,7 +3595,7 @@ class SiteCommand extends CommandRunner6 {
       }
       unlinkSync(pidFile);
       console.log(`\u2705 Killed Lattice site process (PID: ${pid})`);
-    } catch (err) {
+    } catch (_err) {
       try {
         unlinkSync(pidFile);
       } catch {}
@@ -3357,7 +3616,7 @@ class SiteCommand extends CommandRunner6 {
   }
 }
 __legacyDecorateClassTS([
-  Option4({
+  Option5({
     flags: "-b, --build",
     description: "Build the site without starting the server"
   }),
@@ -3366,7 +3625,7 @@ __legacyDecorateClassTS([
   __legacyMetadataTS("design:returntype", Boolean)
 ], SiteCommand.prototype, "parseBuild", null);
 __legacyDecorateClassTS([
-  Option4({
+  Option5({
     flags: "-d, --dev",
     description: "Run in development mode (hot reload, no search)"
   }),
@@ -3375,7 +3634,7 @@ __legacyDecorateClassTS([
   __legacyMetadataTS("design:returntype", Boolean)
 ], SiteCommand.prototype, "parseDev", null);
 __legacyDecorateClassTS([
-  Option4({
+  Option5({
     flags: "-p, --port <port>",
     description: "Port to run the server on (default: 4321)"
   }),
@@ -3386,7 +3645,7 @@ __legacyDecorateClassTS([
   __legacyMetadataTS("design:returntype", String)
 ], SiteCommand.prototype, "parsePort", null);
 __legacyDecorateClassTS([
-  Option4({
+  Option5({
     flags: "-k, --kill",
     description: "Kill the running Lattice site process"
   }),
@@ -3395,16 +3654,16 @@ __legacyDecorateClassTS([
   __legacyMetadataTS("design:returntype", Boolean)
 ], SiteCommand.prototype, "parseKill", null);
 SiteCommand = __legacyDecorateClassTS([
-  Injectable16(),
-  Command6({
+  Injectable17(),
+  Command7({
     name: "site",
     description: "Build and run the Lattice documentation site"
   })
 ], SiteCommand);
 // src/commands/status.command.ts
-import { Injectable as Injectable17 } from "@nestjs/common";
-import { Command as Command7, CommandRunner as CommandRunner7, Option as Option5 } from "nest-commander";
-class StatusCommand extends CommandRunner7 {
+import { Injectable as Injectable18 } from "@nestjs/common";
+import { Command as Command8, CommandRunner as CommandRunner8, Option as Option6 } from "nest-commander";
+class StatusCommand extends CommandRunner8 {
   syncService;
   dbChangeDetector;
   constructor(syncService, dbChangeDetector) {
@@ -3470,7 +3729,7 @@ class StatusCommand extends CommandRunner7 {
   }
 }
 __legacyDecorateClassTS([
-  Option5({
+  Option6({
     flags: "-v, --verbose",
     description: "Show all documents including unchanged"
   }),
@@ -3479,8 +3738,8 @@ __legacyDecorateClassTS([
   __legacyMetadataTS("design:returntype", Boolean)
 ], StatusCommand.prototype, "parseVerbose", null);
 StatusCommand = __legacyDecorateClassTS([
-  Injectable17(),
-  Command7({
+  Injectable18(),
+  Command8({
     name: "status",
     description: "Show documents that need syncing (new or updated)"
   }),
@@ -3492,11 +3751,11 @@ StatusCommand = __legacyDecorateClassTS([
 // src/commands/sync.command.ts
 import { watch } from "fs";
 import { join as join4 } from "path";
-import { Injectable as Injectable19 } from "@nestjs/common";
-import { Command as Command8, CommandRunner as CommandRunner8, Option as Option6 } from "nest-commander";
+import { Injectable as Injectable20 } from "@nestjs/common";
+import { Command as Command9, CommandRunner as CommandRunner9, Option as Option7 } from "nest-commander";
 
 // src/sync/graph-validator.service.ts
-import { Injectable as Injectable18, Logger as Logger9 } from "@nestjs/common";
+import { Injectable as Injectable19, Logger as Logger9 } from "@nestjs/common";
 class GraphValidatorService {
   graph;
   logger = new Logger9(GraphValidatorService.name);
@@ -3645,14 +3904,14 @@ class GraphValidatorService {
   }
 }
 GraphValidatorService = __legacyDecorateClassTS([
-  Injectable18(),
+  Injectable19(),
   __legacyMetadataTS("design:paramtypes", [
     typeof GraphService === "undefined" ? Object : GraphService
   ])
 ], GraphValidatorService);
 
 // src/commands/sync.command.ts
-class SyncCommand extends CommandRunner8 {
+class SyncCommand extends CommandRunner9 {
   syncService;
   graphService;
   _graphValidator;
@@ -3667,7 +3926,7 @@ class SyncCommand extends CommandRunner8 {
   async safeExit(code) {
     try {
       await this.graphService.checkpoint();
-    } catch (error) {
+    } catch (_error) {
       console.error("Warning: checkpoint failed during exit");
     }
     process.exit(code);
@@ -3925,7 +4184,7 @@ class SyncCommand extends CommandRunner8 {
   }
 }
 __legacyDecorateClassTS([
-  Option6({
+  Option7({
     flags: "-f, --force",
     description: "Force re-sync specified documents (requires paths to be specified)"
   }),
@@ -3934,7 +4193,7 @@ __legacyDecorateClassTS([
   __legacyMetadataTS("design:returntype", Boolean)
 ], SyncCommand.prototype, "parseForce", null);
 __legacyDecorateClassTS([
-  Option6({
+  Option7({
     flags: "-d, --dry-run",
     description: "Show what would change without applying"
   }),
@@ -3943,7 +4202,7 @@ __legacyDecorateClassTS([
   __legacyMetadataTS("design:returntype", Boolean)
 ], SyncCommand.prototype, "parseDryRun", null);
 __legacyDecorateClassTS([
-  Option6({
+  Option7({
     flags: "-v, --verbose",
     description: "Show detailed output"
   }),
@@ -3952,7 +4211,7 @@ __legacyDecorateClassTS([
   __legacyMetadataTS("design:returntype", Boolean)
 ], SyncCommand.prototype, "parseVerbose", null);
 __legacyDecorateClassTS([
-  Option6({
+  Option7({
     flags: "-w, --watch",
     description: "Watch for file changes and sync automatically"
   }),
@@ -3961,7 +4220,7 @@ __legacyDecorateClassTS([
   __legacyMetadataTS("design:returntype", Boolean)
 ], SyncCommand.prototype, "parseWatch", null);
 __legacyDecorateClassTS([
-  Option6({
+  Option7({
     flags: "--diff",
     description: "Show only changed documents (alias for --dry-run)"
   }),
@@ -3970,7 +4229,7 @@ __legacyDecorateClassTS([
   __legacyMetadataTS("design:returntype", Boolean)
 ], SyncCommand.prototype, "parseDiff", null);
 __legacyDecorateClassTS([
-  Option6({
+  Option7({
     flags: "--skip-cascade",
     description: "Skip cascade analysis (faster for large repos)"
   }),
@@ -3979,7 +4238,7 @@ __legacyDecorateClassTS([
   __legacyMetadataTS("design:returntype", Boolean)
 ], SyncCommand.prototype, "parseSkipCascade", null);
 __legacyDecorateClassTS([
-  Option6({
+  Option7({
     flags: "--no-embeddings",
     description: "Disable embedding generation during sync"
   }),
@@ -3988,7 +4247,7 @@ __legacyDecorateClassTS([
   __legacyMetadataTS("design:returntype", Boolean)
 ], SyncCommand.prototype, "parseNoEmbeddings", null);
 __legacyDecorateClassTS([
-  Option6({
+  Option7({
     flags: "--skip-extraction",
     description: "Skip AI entity extraction (sync without re-extracting entities)"
   }),
@@ -3997,8 +4256,8 @@ __legacyDecorateClassTS([
   __legacyMetadataTS("design:returntype", Boolean)
 ], SyncCommand.prototype, "parseSkipExtraction", null);
 SyncCommand = __legacyDecorateClassTS([
-  Injectable19(),
-  Command8({
+  Injectable20(),
+  Command9({
     name: "sync",
     arguments: "[paths...]",
     description: "Synchronize documents to the knowledge graph"
@@ -4037,7 +4296,7 @@ GraphModule = __legacyDecorateClassTS([
 import { Module as Module3 } from "@nestjs/common";
 
 // src/query/query.service.ts
-import { Injectable as Injectable20, Logger as Logger10 } from "@nestjs/common";
+import { Injectable as Injectable21, Logger as Logger10 } from "@nestjs/common";
 class QueryService {
   graphService;
   logger = new Logger10(QueryService.name);
@@ -4050,7 +4309,7 @@ class QueryService {
   }
 }
 QueryService = __legacyDecorateClassTS([
-  Injectable20(),
+  Injectable21(),
   __legacyMetadataTS("design:paramtypes", [
     typeof GraphService === "undefined" ? Object : GraphService
   ])
@@ -4124,7 +4383,10 @@ AppModule = __legacyDecorateClassTS([
       OntologyCommand,
       InitCommand,
       MigrateCommand,
-      SiteCommand
+      SiteCommand,
+      QuestionAddCommand,
+      QuestionLinkCommand,
+      QuestionUnansweredCommand
     ]
   })
 ], AppModule);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zabaca/lattice",
-	"version": "1.1.1",
+	"version": "1.2.0",
 	"description": "Human-initiated, AI-powered knowledge graph for markdown documentation",
 	"type": "module",
 	"bin": {

package/commands/graph-sync.md

@@ -1,87 +0,0 @@
----
-description: Sync modified docs to knowledge graph
-model: sonnet
----
-
-Sync modified documents in `~/.lattice/docs/` to the knowledge graph.
-
-## Configuration
-
-**⚠️ CRITICAL: All documentation lives in `~/.lattice/docs/`**
-
-| Path | Purpose |
-|------|---------|
-| `~/.lattice/docs/` | Root documentation directory (ALWAYS use this) |
-| `~/.lattice/docs/{topic}/` | Topic directories |
-| `~/.lattice/docs/{topic}/*.md` | Research documents |
-
-**NEVER use project-local `docs/` directories. ALWAYS use absolute path `~/.lattice/docs/`.**
-
-## Process
-
-### Step 1: Check What Needs Syncing
-
-Run the status command to identify modified documents:
-
-```bash
-lattice status
-```
-
-This will show:
-- **New** documents not yet in the graph
-- **Updated** documents that have changed since last sync
-
-If no documents need syncing, report that and exit.
-
-### Step 2: Sync to Graph
-
-Run sync to process all changed documents:
-
-```bash
-lattice sync
-```
-
-This will automatically:
-- **Extract entities** using AI (Claude Haiku) for each new/updated document
-- **Generate embeddings** for semantic search
-- **Create entity relationships** in the graph
-- **Update the sync manifest** with new hashes
-
-The sync command includes built-in rate limiting (500ms between extractions) to avoid API throttling.
-
-### Step 3: Report Results
-
-Summarize what was processed:
-- Number of documents synced
-- Entities extracted per document
-- Graph sync statistics (added, updated, unchanged)
-- Any errors encountered
-
-## Example Output
-
-```
-## Graph Sync
-
-lattice status:
-- 3 documents need syncing (2 new, 1 updated)
-
-lattice sync:
-- ~/.lattice/docs/american-holidays/README.md → 4 entities extracted
-- ~/.lattice/docs/american-holidays/thanksgiving-vs-christmas.md → 8 entities extracted
-- ~/.lattice/docs/bun-nestjs/notes.md → 5 entities extracted
-
-Summary:
-- Added: 2
-- Updated: 1
-- Unchanged: 126
-- Duration: 3.2s
-```
-
-## Important Notes
-
-- **AI extraction is automatic** - no need for manual `/entity-extract` calls
-- **Incremental sync** - only processes changed documents
-- **Self-correcting** - Claude validates extractions and fixes errors automatically
-- **Safe to run frequently** - won't duplicate or corrupt data
-- **No frontmatter required** - documents are plain markdown
-- **Batch syncing** - run once after multiple research sessions for efficiency