sqlew 5.2.0 → 5.2.1

package/dist/tests/utils/db-schema.js

@@ -36,9 +36,9 @@ export async function disconnectDb(db) {
 export async function dropAllTables(db, type) {
     if (type === 'sqlite') {
         // SQLite: Get all tables and views, then drop them
-        const objects = await db.raw(`
-      SELECT name, type FROM sqlite_master
-      WHERE type IN ('table', 'view') AND name NOT LIKE 'sqlite_%'
+        const objects = await db.raw(`
+      SELECT name, type FROM sqlite_master
+      WHERE type IN ('table', 'view') AND name NOT LIKE 'sqlite_%'
     `);
         await db.raw('PRAGMA foreign_keys = OFF');
         for (const row of objects) {
@@ -55,19 +55,19 @@ export async function dropAllTables(db, type) {
         // MySQL/MariaDB: Drop all views first, then tables
         await db.raw('SET FOREIGN_KEY_CHECKS=0');
         // Drop views
-        const views = await db.raw(`
-      SELECT TABLE_NAME
-      FROM INFORMATION_SCHEMA.TABLES
-      WHERE TABLE_SCHEMA = 'mcp_test' AND TABLE_TYPE = 'VIEW'
+        const views = await db.raw(`
+      SELECT TABLE_NAME
+      FROM INFORMATION_SCHEMA.TABLES
+      WHERE TABLE_SCHEMA = 'mcp_test' AND TABLE_TYPE = 'VIEW'
     `);
         for (const row of views[0]) {
             await db.raw(`DROP VIEW IF EXISTS ??`, [row.TABLE_NAME]);
         }
         // Drop tables
-        const tables = await db.raw(`
-      SELECT TABLE_NAME
-      FROM INFORMATION_SCHEMA.TABLES
-      WHERE TABLE_SCHEMA = 'mcp_test' AND TABLE_TYPE = 'BASE TABLE'
+        const tables = await db.raw(`
+      SELECT TABLE_NAME
+      FROM INFORMATION_SCHEMA.TABLES
+      WHERE TABLE_SCHEMA = 'mcp_test' AND TABLE_TYPE = 'BASE TABLE'
     `);
         for (const row of tables[0]) {
             await db.raw(`DROP TABLE IF EXISTS ??`, [row.TABLE_NAME]);
@@ -85,30 +85,30 @@ export async function dropAllTables(db, type) {
  */
 export async function getTables(db, type) {
     if (type === 'sqlite') {
-        const result = await db.raw(`
-      SELECT name FROM sqlite_master
-      WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name != 'knex_migrations'
-      ORDER BY name
+        const result = await db.raw(`
+      SELECT name FROM sqlite_master
+      WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name != 'knex_migrations'
+      ORDER BY name
     `);
         return result.map((r) => r.name);
     }
     else if (type === 'mysql' || type === 'mariadb') {
-        const result = await db.raw(`
-      SELECT TABLE_NAME
-      FROM INFORMATION_SCHEMA.TABLES
-      WHERE TABLE_SCHEMA = 'mcp_test'
-        AND TABLE_TYPE = 'BASE TABLE'
-        AND TABLE_NAME != 'knex_migrations'
-      ORDER BY TABLE_NAME
+        const result = await db.raw(`
+      SELECT TABLE_NAME
+      FROM INFORMATION_SCHEMA.TABLES
+      WHERE TABLE_SCHEMA = 'mcp_test'
+        AND TABLE_TYPE = 'BASE TABLE'
+        AND TABLE_NAME != 'knex_migrations'
+      ORDER BY TABLE_NAME
     `);
         return result[0].map((r) => r.TABLE_NAME);
     }
     else if (type === 'postgresql') {
-        const result = await db.raw(`
-      SELECT tablename
-      FROM pg_tables
-      WHERE schemaname = 'public' AND tablename != 'knex_migrations'
-      ORDER BY tablename
+        const result = await db.raw(`
+      SELECT tablename
+      FROM pg_tables
+      WHERE schemaname = 'public' AND tablename != 'knex_migrations'
+      ORDER BY tablename
     `);
         return result.rows.map((r) => r.tablename);
     }
@@ -161,15 +161,15 @@ export async function getFKConstraints(db, type, tableName) {
         }
     }
     else if (type === 'mysql' || type === 'mariadb') {
-        const result = await db.raw(`
-      SELECT
-        COLUMN_NAME,
-        REFERENCED_TABLE_NAME,
-        REFERENCED_COLUMN_NAME
-      FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE
-      WHERE TABLE_SCHEMA = 'mcp_test'
-        AND TABLE_NAME = ?
-        AND REFERENCED_TABLE_NAME IS NOT NULL
+        const result = await db.raw(`
+      SELECT
+        COLUMN_NAME,
+        REFERENCED_TABLE_NAME,
+        REFERENCED_COLUMN_NAME
+      FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE
+      WHERE TABLE_SCHEMA = 'mcp_test'
+        AND TABLE_NAME = ?
+        AND REFERENCED_TABLE_NAME IS NOT NULL
     `, [tableName]);
         for (const fk of result[0]) {
             constraints.push({
@@ -181,18 +181,18 @@ export async function getFKConstraints(db, type, tableName) {
         }
     }
     else if (type === 'postgresql') {
-        const result = await db.raw(`
-      SELECT
-        kcu.column_name,
-        ccu.table_name AS referenced_table,
-        ccu.column_name AS referenced_column
-      FROM information_schema.table_constraints AS tc
-      JOIN information_schema.key_column_usage AS kcu
-        ON tc.constraint_name = kcu.constraint_name
-      JOIN information_schema.constraint_column_usage AS ccu
-        ON ccu.constraint_name = tc.constraint_name
-      WHERE tc.constraint_type = 'FOREIGN KEY'
-        AND tc.table_name = ?
+        const result = await db.raw(`
+      SELECT
+        kcu.column_name,
+        ccu.table_name AS referenced_table,
+        ccu.column_name AS referenced_column
+      FROM information_schema.table_constraints AS tc
+      JOIN information_schema.key_column_usage AS kcu
+        ON tc.constraint_name = kcu.constraint_name
+      JOIN information_schema.constraint_column_usage AS ccu
+        ON ccu.constraint_name = tc.constraint_name
+      WHERE tc.constraint_type = 'FOREIGN KEY'
+        AND tc.table_name = ?
     `, [tableName]);
         for (const fk of result.rows) {
             constraints.push({

package/dist/tests/utils/test-helpers.js

@@ -92,9 +92,9 @@ export async function disconnectDb(db) {
 export async function dropAllTables(db, type) {
     if (type === 'sqlite') {
         // SQLite: Get all tables and views, then drop them
-        const objects = await db.raw(`
-      SELECT name, type FROM sqlite_master
-      WHERE type IN ('table', 'view') AND name NOT LIKE 'sqlite_%'
+        const objects = await db.raw(`
+      SELECT name, type FROM sqlite_master
+      WHERE type IN ('table', 'view') AND name NOT LIKE 'sqlite_%'
     `);
         await db.raw('PRAGMA foreign_keys = OFF');
         for (const row of objects) {
@@ -109,18 +109,18 @@ export async function dropAllTables(db, type) {
     }
     else if (type === 'mysql' || type === 'mariadb') {
         await db.raw('SET FOREIGN_KEY_CHECKS=0');
-        const views = await db.raw(`
-      SELECT TABLE_NAME
-      FROM INFORMATION_SCHEMA.TABLES
-      WHERE TABLE_SCHEMA = 'mcp_test' AND TABLE_TYPE = 'VIEW'
+        const views = await db.raw(`
+      SELECT TABLE_NAME
+      FROM INFORMATION_SCHEMA.TABLES
+      WHERE TABLE_SCHEMA = 'mcp_test' AND TABLE_TYPE = 'VIEW'
     `);
         for (const row of views[0]) {
             await db.raw(`DROP VIEW IF EXISTS ??`, [row.TABLE_NAME]);
         }
-        const tables = await db.raw(`
-      SELECT TABLE_NAME
-      FROM INFORMATION_SCHEMA.TABLES
-      WHERE TABLE_SCHEMA = 'mcp_test' AND TABLE_TYPE = 'BASE TABLE'
+        const tables = await db.raw(`
+      SELECT TABLE_NAME
+      FROM INFORMATION_SCHEMA.TABLES
+      WHERE TABLE_SCHEMA = 'mcp_test' AND TABLE_TYPE = 'BASE TABLE'
     `);
         for (const row of tables[0]) {
             await db.raw(`DROP TABLE IF EXISTS ??`, [row.TABLE_NAME]);
@@ -138,30 +138,30 @@ export async function dropAllTables(db, type) {
  */
 export async function getTables(db, type) {
     if (type === 'sqlite') {
-        const result = await db.raw(`
-      SELECT name FROM sqlite_master
-      WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name != 'knex_migrations'
-      ORDER BY name
+        const result = await db.raw(`
+      SELECT name FROM sqlite_master
+      WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name != 'knex_migrations'
+      ORDER BY name
     `);
         return result.map((r) => r.name);
     }
     else if (type === 'mysql' || type === 'mariadb') {
-        const result = await db.raw(`
-      SELECT TABLE_NAME
-      FROM INFORMATION_SCHEMA.TABLES
-      WHERE TABLE_SCHEMA = 'mcp_test'
-        AND TABLE_TYPE = 'BASE TABLE'
-        AND TABLE_NAME != 'knex_migrations'
-      ORDER BY TABLE_NAME
+        const result = await db.raw(`
+      SELECT TABLE_NAME
+      FROM INFORMATION_SCHEMA.TABLES
+      WHERE TABLE_SCHEMA = 'mcp_test'
+        AND TABLE_TYPE = 'BASE TABLE'
+        AND TABLE_NAME != 'knex_migrations'
+      ORDER BY TABLE_NAME
     `);
         return result[0].map((r) => r.TABLE_NAME);
     }
     else if (type === 'postgresql') {
-        const result = await db.raw(`
-      SELECT tablename
-      FROM pg_tables
-      WHERE schemaname = 'public' AND tablename != 'knex_migrations'
-      ORDER BY tablename
+        const result = await db.raw(`
+      SELECT tablename
+      FROM pg_tables
+      WHERE schemaname = 'public' AND tablename != 'knex_migrations'
+      ORDER BY tablename
     `);
         return result.rows.map((r) => r.tablename);
     }
@@ -214,15 +214,15 @@ export async function getFKConstraints(db, type, tableName) {
         }
     }
     else if (type === 'mysql' || type === 'mariadb') {
-        const result = await db.raw(`
-      SELECT
-        COLUMN_NAME,
-        REFERENCED_TABLE_NAME,
-        REFERENCED_COLUMN_NAME
-      FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE
-      WHERE TABLE_SCHEMA = 'mcp_test'
-        AND TABLE_NAME = ?
-        AND REFERENCED_TABLE_NAME IS NOT NULL
+        const result = await db.raw(`
+      SELECT
+        COLUMN_NAME,
+        REFERENCED_TABLE_NAME,
+        REFERENCED_COLUMN_NAME
+      FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE
+      WHERE TABLE_SCHEMA = 'mcp_test'
+        AND TABLE_NAME = ?
+        AND REFERENCED_TABLE_NAME IS NOT NULL
     `, [tableName]);
         for (const fk of result[0]) {
             constraints.push({
@@ -234,18 +234,18 @@ export async function getFKConstraints(db, type, tableName) {
         }
     }
     else if (type === 'postgresql') {
-        const result = await db.raw(`
-      SELECT
-        kcu.column_name,
-        ccu.table_name AS referenced_table,
-        ccu.column_name AS referenced_column
-      FROM information_schema.table_constraints AS tc
-      JOIN information_schema.key_column_usage AS kcu
-        ON tc.constraint_name = kcu.constraint_name
-      JOIN information_schema.constraint_column_usage AS ccu
-        ON ccu.constraint_name = tc.constraint_name
-      WHERE tc.constraint_type = 'FOREIGN KEY'
-        AND tc.table_name = ?
+        const result = await db.raw(`
+      SELECT
+        kcu.column_name,
+        ccu.table_name AS referenced_table,
+        ccu.column_name AS referenced_column
+      FROM information_schema.table_constraints AS tc
+      JOIN information_schema.key_column_usage AS kcu
+        ON tc.constraint_name = kcu.constraint_name
+      JOIN information_schema.constraint_column_usage AS ccu
+        ON ccu.constraint_name = tc.constraint_name
+      WHERE tc.constraint_type = 'FOREIGN KEY'
+        AND tc.table_name = ?
     `, [tableName]);
         for (const fk of result.rows) {
             constraints.push({

package/dist/tools/constraints/actions/get.js

@@ -86,11 +86,11 @@ export async function getConstraints(params, adapter) {
                 'c.priority',
                 knex.raw(`${db.dateFunction('c.ts')} as created_at`),
                 // Tags subquery
-                knex.raw(`(
-          SELECT ${db.stringAgg('t2.name', ',')}
-          FROM t_constraint_tags ct2
-          JOIN m_tags t2 ON ct2.tag_id = t2.id
-          WHERE ct2.constraint_id = c.id
+                knex.raw(`(
+          SELECT ${db.stringAgg('t2.name', ',')}
+          FROM t_constraint_tags ct2
+          JOIN m_tags t2 ON ct2.tag_id = t2.id
+          WHERE ct2.constraint_id = c.id
         ) as tags`),
             ]);
             // Convert priority integer to string and parse tags

package/dist/utils/project-root.d.ts

@@ -4,6 +4,7 @@
  * Determines the project root directory with correct priority order:
  * 0. CLAUDE_PROJECT_DIR environment variable (Claude Code / Grok Build hooks)
  * 0b. GROK_WORKSPACE_ROOT environment variable (Grok Build hooks / MCP)
+ * 0c. CODEX_CWD environment variable (Codex hooks / MCP)
  * 1. SQLEW_PROJECT_ROOT environment variable (MCP client can set this)
  * 2. CLI --db-path argument (absolute path) → use dirname
  * 3. CLI --config-path argument (absolute path) → use dirname

package/dist/utils/project-root.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"project-root.d.ts","sourceRoot":"","sources":["../../src/utils/project-root.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAIH,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,GAAE,kBAAuB,GAAG,MAAM,CAiD7E;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAiB1D"}
+{"version":3,"file":"project-root.d.ts","sourceRoot":"","sources":["../../src/utils/project-root.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAIH,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,GAAE,kBAAuB,GAAG,MAAM,CAuD7E;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAiB1D"}

package/dist/utils/project-root.js

@@ -4,6 +4,7 @@
  * Determines the project root directory with correct priority order:
  * 0. CLAUDE_PROJECT_DIR environment variable (Claude Code / Grok Build hooks)
  * 0b. GROK_WORKSPACE_ROOT environment variable (Grok Build hooks / MCP)
+ * 0c. CODEX_CWD environment variable (Codex hooks / MCP)
  * 1. SQLEW_PROJECT_ROOT environment variable (MCP client can set this)
  * 2. CLI --db-path argument (absolute path) → use dirname
  * 3. CLI --config-path argument (absolute path) → use dirname
@@ -72,6 +73,11 @@ export function determineProjectRoot(options = {}) {
     if (grokWorkspaceRoot && path.isAbsolute(grokWorkspaceRoot)) {
         return grokWorkspaceRoot.replace(/\\/g, '/');
     }
+    // Priority 0c: CODEX_CWD (Codex hooks inject workspace cwd)
+    const codexCwd = process.env.CODEX_CWD;
+    if (codexCwd && path.isAbsolute(codexCwd)) {
+        return codexCwd.replace(/\\/g, '/');
+    }
     // Priority 1: SQLEW_PROJECT_ROOT environment variable
     // MCP clients (Junie, Claude Desktop, etc.) can set this to specify project directory
     const envProjectRoot = process.env.SQLEW_PROJECT_ROOT;

package/dist/utils/project-root.js.map

@@ -1 +1 @@
-{"version":3,"file":"project-root.js","sourceRoot":"","sources":["../../src/utils/project-root.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"project-root.js","sourceRoot":"","sources":["../../src/utils/project-root.ts"],"names":[],"mappings":"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"}

package/docs/ADR_CONCEPTS.md

@@ -1,152 +1,152 @@
-# Decisions & Constraints for AI Development
-
-Persistent design context — decisions and constraints recorded as structured data — gives AI agents architectural memory across sessions. sqlew makes this zero-effort: plan normally, and hooks capture your decisions automatically.
-
-## Why Persistent Design Context Matters
-
-Research shows that recording design intent dramatically improves LLM code generation:
-
-- **22.4% reduction** in overall development time
-- **80% of tasks** completed faster with design intent available
-- **50%+ improvement** in feature-addition and architectural-change tasks
-- **137% increase** in design decision references by final tasks — AI learns to leverage past context more over time
-
-> Kitayama, S. (2026). *Rediscovering Architectural Decision Records: How Persistent Design Context Improves LLM Code Generation*. [DOI](https://doi.org/10.36227/techrxiv.177205025.54351571/v1)
->
-> Blog post: [Recording Design Intent for AI Efficiency](https://blog.sqlew.io/recording-design-intent-for-ai-efficiency)
-
-## Key Benefits for AI-Driven Development
-
-### Persistent Architectural Memory
-- **Zero context loss** – AI agents remember every architectural decision across sessions
-- **Rationale preservation** – Never forget WHY a decision was made, not just WHAT
-- **Alternative tracking** – Document rejected options to prevent circular debates
-- **Evolution history** – See how decisions changed over time with full version history
-
-### Prevent Architectural Drift
-- **Constraint enforcement** – Define architectural rules once, AI follows them forever
-- **Pattern consistency** – AI generates code matching established patterns automatically
-- **Anti-pattern prevention** – Document "what NOT to do" as enforceable constraints
-- **Regression prevention** – AI won't reintroduce previously rejected approaches
-
-### Intelligent Decision Discovery
-- **Three-tier duplicate detection** – Gentle nudge (35-44), hard block (45-59), or auto-update (60+) based on similarity score
-- **Similarity detection** – AI identifies duplicate or related decisions before creating new ones
-- **Context-aware search** – Query by layer, tags, or relationships to find relevant decisions
-- **Conflict detection** – Find decisions that contradict or supersede each other
-
-### Extreme Efficiency
-- **60-75% token reduction** – Query only relevant decisions instead of reading full files
-- **Millisecond queries** – 2-50ms response times even with thousands of decisions
-- **Scalable architecture** – Perform well with large decision histories
-
-## How sqlew Works
-
-```mermaid
-flowchart LR
-    subgraph Claude Code
-        A[Plan Mode] -->|Create Plan| B[User Approval]
-        B -->|ExitPlanMode| C[Hook Triggered]
-    end
-
-    subgraph sqlew
-        C -->|Enqueue| D[Queue File]
-        D -->|QueueWatcher| E[(SQL Database)]
-    end
-
-    subgraph Next Session
-        F[AI Agent] -->|Query| E
-        E -->|Past Decisions| F
-    end
-```
-
-**Zero-effort knowledge accumulation:**
-1. You plan your work normally in Claude Code
-2. Hooks automatically capture decisions
-3. Next session, AI queries past decisions via SQL
-
-## Core Concepts
-
-**Decisions** capture architectural choices with full context:
-- **What** was decided (the decision itself)
-- **Why** it was chosen (rationale, trade-offs)
-- **What else** was considered (alternatives rejected)
-- **Impact** on the system (consequences, affected components)
-
-**Constraints** define architectural principles and rules:
-- **Performance requirements** (response time limits, throughput goals)
-- **Technology choices** ("must use PostgreSQL", "avoid microservices")
-- **Coding standards** ("async/await only", "no any types")
-- **Security policies** (authentication patterns, data handling rules)
-
-**Lifecycle tracking:**
-- **Status evolution** tracks decision lifecycle (draft → active → deprecated)
-- **Auto-capture via Hooks** records decisions automatically from Plan Mode
-
-```mermaid
-erDiagram
-    DECISION ||--o{ TAG : has
-    DECISION {
-        string key
-        string value
-        string layer
-        string status
-        timestamp updated
-    }
-    CONSTRAINT ||--o{ TAG : has
-    CONSTRAINT {
-        string text
-        string category
-        int priority
-    }
-    TAG {
-        string name
-    }
-```
-
-## SQL vs Markdown
-
-| Traditional approach (Markdown) | sqlew approach (SQL) |
-|--------------------------------|---------------------|
-| Read entire files | Query specific decisions |
-| Manual duplicate checking | Automatic similarity detection |
-| Text parsing required | Structured, typed data |
-| Linear token scaling | Constant-time lookups |
-| File-based organization | Relational queries with JOINs |
-
-### Why SQL?
-
-Traditional text-based records force AI to:
-- Read complete files even for simple queries
-- Parse unstructured text to find relationships
-- Manually detect duplicate or conflicting decisions
-
-sqlew's **SQL-backed decision repository** enables AI to:
-- Query by layer, tags, status in milliseconds (2-50ms)
-- Join decisions with constraints
-- Leverage similarity algorithms to prevent duplicates
-- Scale to thousands of decisions without context explosion
-
-**Token efficiency**: 60-75% reduction compared to reading Markdown files
-
-### Why RDBMS + MCP?
-
-**RDBMS (Relational Database)** provides efficient structured queries:
-- **Indexed searches** – Find decisions by tags/layers in milliseconds, not seconds
-- **JOIN operations** – Query related decisions and constraints in a single operation
-- **Transaction support** – ACID guarantees ensure data integrity across concurrent AI agents
-- **Scalability** – Handle thousands of decisions without performance degradation
-
-**MCP (Model Context Protocol)** enables seamless AI integration:
-- **Seamless DB connection** – AI agents access the database through a standardized protocol without direct DB setup
-- **Self-documenting tools** – Tool descriptions teach AI how to use each operation, no manual onboarding needed
-- **Type safety** – Structured parameters prevent errors and guide correct usage
-- **Cross-session persistence** – Decisions survive beyond individual chat sessions
-
-**Together**: AI agents gain SQL-powered decision capabilities without managing databases directly.
-
-## References
-
-- Kitayama, S. (2026). *Rediscovering Architectural Decision Records: How Persistent Design Context Improves LLM Code Generation*. [DOI](https://doi.org/10.36227/techrxiv.177205025.54351571/v1)
-- Blog: [Recording Design Intent for AI Efficiency](https://blog.sqlew.io/recording-design-intent-for-ai-efficiency)
-- The concept of Architecture Decision Records was originally proposed by Michael Nygard in 2011.
+# Decisions & Constraints for AI Development
+
+Persistent design context — decisions and constraints recorded as structured data — gives AI agents architectural memory across sessions. sqlew makes this zero-effort: plan normally, and hooks capture your decisions automatically.
+
+## Why Persistent Design Context Matters
+
+Research shows that recording design intent dramatically improves LLM code generation:
+
+- **22.4% reduction** in overall development time
+- **80% of tasks** completed faster with design intent available
+- **50%+ improvement** in feature-addition and architectural-change tasks
+- **137% increase** in design decision references by final tasks — AI learns to leverage past context more over time
+
+> Kitayama, S. (2026). *Rediscovering Architectural Decision Records: How Persistent Design Context Improves LLM Code Generation*. [DOI](https://doi.org/10.36227/techrxiv.177205025.54351571/v1)
+>
+> Blog post: [Recording Design Intent for AI Efficiency](https://blog.sqlew.io/recording-design-intent-for-ai-efficiency)
+
+## Key Benefits for AI-Driven Development
+
+### Persistent Architectural Memory
+- **Zero context loss** – AI agents remember every architectural decision across sessions
+- **Rationale preservation** – Never forget WHY a decision was made, not just WHAT
+- **Alternative tracking** – Document rejected options to prevent circular debates
+- **Evolution history** – See how decisions changed over time with full version history
+
+### Prevent Architectural Drift
+- **Constraint enforcement** – Define architectural rules once, AI follows them forever
+- **Pattern consistency** – AI generates code matching established patterns automatically
+- **Anti-pattern prevention** – Document "what NOT to do" as enforceable constraints
+- **Regression prevention** – AI won't reintroduce previously rejected approaches
+
+### Intelligent Decision Discovery
+- **Three-tier duplicate detection** – Gentle nudge (35-44), hard block (45-59), or auto-update (60+) based on similarity score
+- **Similarity detection** – AI identifies duplicate or related decisions before creating new ones
+- **Context-aware search** – Query by layer, tags, or relationships to find relevant decisions
+- **Conflict detection** – Find decisions that contradict or supersede each other
+
+### Extreme Efficiency
+- **60-75% token reduction** – Query only relevant decisions instead of reading full files
+- **Millisecond queries** – 2-50ms response times even with thousands of decisions
+- **Scalable architecture** – Perform well with large decision histories
+
+## How sqlew Works
+
+```mermaid
+flowchart LR
+    subgraph Claude Code
+        A[Plan Mode] -->|Create Plan| B[User Approval]
+        B -->|ExitPlanMode| C[Hook Triggered]
+    end
+
+    subgraph sqlew
+        C -->|Enqueue| D[Queue File]
+        D -->|QueueWatcher| E[(SQL Database)]
+    end
+
+    subgraph Next Session
+        F[AI Agent] -->|Query| E
+        E -->|Past Decisions| F
+    end
+```
+
+**Zero-effort knowledge accumulation:**
+1. You plan your work normally in Claude Code
+2. Hooks automatically capture decisions
+3. Next session, AI queries past decisions via SQL
+
+## Core Concepts
+
+**Decisions** capture architectural choices with full context:
+- **What** was decided (the decision itself)
+- **Why** it was chosen (rationale, trade-offs)
+- **What else** was considered (alternatives rejected)
+- **Impact** on the system (consequences, affected components)
+
+**Constraints** define architectural principles and rules:
+- **Performance requirements** (response time limits, throughput goals)
+- **Technology choices** ("must use PostgreSQL", "avoid microservices")
+- **Coding standards** ("async/await only", "no any types")
+- **Security policies** (authentication patterns, data handling rules)
+
+**Lifecycle tracking:**
+- **Status evolution** tracks decision lifecycle (draft → active → deprecated)
+- **Auto-capture via Hooks** records decisions automatically from Plan Mode
+
+```mermaid
+erDiagram
+    DECISION ||--o{ TAG : has
+    DECISION {
+        string key
+        string value
+        string layer
+        string status
+        timestamp updated
+    }
+    CONSTRAINT ||--o{ TAG : has
+    CONSTRAINT {
+        string text
+        string category
+        int priority
+    }
+    TAG {
+        string name
+    }
+```
+
+## SQL vs Markdown
+
+| Traditional approach (Markdown) | sqlew approach (SQL) |
+|--------------------------------|---------------------|
+| Read entire files | Query specific decisions |
+| Manual duplicate checking | Automatic similarity detection |
+| Text parsing required | Structured, typed data |
+| Linear token scaling | Constant-time lookups |
+| File-based organization | Relational queries with JOINs |
+
+### Why SQL?
+
+Traditional text-based records force AI to:
+- Read complete files even for simple queries
+- Parse unstructured text to find relationships
+- Manually detect duplicate or conflicting decisions
+
+sqlew's **SQL-backed decision repository** enables AI to:
+- Query by layer, tags, status in milliseconds (2-50ms)
+- Join decisions with constraints
+- Leverage similarity algorithms to prevent duplicates
+- Scale to thousands of decisions without context explosion
+
+**Token efficiency**: 60-75% reduction compared to reading Markdown files
+
+### Why RDBMS + MCP?
+
+**RDBMS (Relational Database)** provides efficient structured queries:
+- **Indexed searches** – Find decisions by tags/layers in milliseconds, not seconds
+- **JOIN operations** – Query related decisions and constraints in a single operation
+- **Transaction support** – ACID guarantees ensure data integrity across concurrent AI agents
+- **Scalability** – Handle thousands of decisions without performance degradation
+
+**MCP (Model Context Protocol)** enables seamless AI integration:
+- **Seamless DB connection** – AI agents access the database through a standardized protocol without direct DB setup
+- **Self-documenting tools** – Tool descriptions teach AI how to use each operation, no manual onboarding needed
+- **Type safety** – Structured parameters prevent errors and guide correct usage
+- **Cross-session persistence** – Decisions survive beyond individual chat sessions
+
+**Together**: AI agents gain SQL-powered decision capabilities without managing databases directly.
+
+## References
+
+- Kitayama, S. (2026). *Rediscovering Architectural Decision Records: How Persistent Design Context Improves LLM Code Generation*. [DOI](https://doi.org/10.36227/techrxiv.177205025.54351571/v1)
+- Blog: [Recording Design Intent for AI Efficiency](https://blog.sqlew.io/recording-design-intent-for-ai-efficiency)
+- The concept of Architecture Decision Records was originally proposed by Michael Nygard in 2011.