@workflow-cannon/workspace-kit 0.15.0 → 0.16.0

package/dist/modules/task-engine/planning-config.d.ts

@@ -0,0 +1,10 @@
+import type { ModuleLifecycleContext } from "../../contracts/module-contract.js";
+export type TaskPersistenceBackend = "json" | "sqlite";
+export declare function getTaskPersistenceBackend(config: Record<string, unknown> | undefined): TaskPersistenceBackend;
+export declare function planningTaskStoreRelativePath(ctx: {
+    effectiveConfig?: Record<string, unknown>;
+}): string | undefined;
+export declare function planningWishlistStoreRelativePath(ctx: {
+    effectiveConfig?: Record<string, unknown>;
+}): string | undefined;
+export declare function planningSqliteDatabaseRelativePath(ctx: ModuleLifecycleContext): string;

package/dist/modules/task-engine/planning-config.js

@@ -0,0 +1,37 @@
+export function getTaskPersistenceBackend(config) {
+    const tasks = config?.tasks;
+    if (!tasks || typeof tasks !== "object" || Array.isArray(tasks)) {
+        return "json";
+    }
+    const b = tasks.persistenceBackend;
+    if (b === "sqlite") {
+        return "sqlite";
+    }
+    return "json";
+}
+export function planningTaskStoreRelativePath(ctx) {
+    const tasks = ctx.effectiveConfig?.tasks;
+    if (!tasks || typeof tasks !== "object" || Array.isArray(tasks)) {
+        return undefined;
+    }
+    const p = tasks.storeRelativePath;
+    return typeof p === "string" && p.trim().length > 0 ? p.trim() : undefined;
+}
+export function planningWishlistStoreRelativePath(ctx) {
+    const tasks = ctx.effectiveConfig?.tasks;
+    if (!tasks || typeof tasks !== "object" || Array.isArray(tasks)) {
+        return undefined;
+    }
+    const p = tasks.wishlistStoreRelativePath;
+    return typeof p === "string" && p.trim().length > 0 ? p.trim() : undefined;
+}
+export function planningSqliteDatabaseRelativePath(ctx) {
+    const tasks = ctx.effectiveConfig?.tasks;
+    if (!tasks || typeof tasks !== "object" || Array.isArray(tasks)) {
+        return ".workspace-kit/tasks/workspace-kit.db";
+    }
+    const p = tasks.sqliteDatabaseRelativePath;
+    return typeof p === "string" && p.trim().length > 0
+        ? p.trim()
+        : ".workspace-kit/tasks/workspace-kit.db";
+}

package/dist/modules/task-engine/planning-open.d.ts

@@ -0,0 +1,16 @@
+import type { ModuleLifecycleContext } from "../../contracts/module-contract.js";
+import { TaskStore } from "./store.js";
+import { WishlistStore } from "./wishlist-store.js";
+import { SqliteDualPlanningStore } from "./sqlite-dual-planning.js";
+export type OpenedPlanningStores = {
+    kind: "json";
+    taskStore: TaskStore;
+    sqliteDual: null;
+    openWishlist: () => Promise<WishlistStore>;
+} | {
+    kind: "sqlite";
+    taskStore: TaskStore;
+    sqliteDual: SqliteDualPlanningStore;
+    openWishlist: () => Promise<WishlistStore>;
+};
+export declare function openPlanningStores(ctx: ModuleLifecycleContext): Promise<OpenedPlanningStores>;

package/dist/modules/task-engine/planning-open.js

@@ -0,0 +1,34 @@
+import { TaskStore } from "./store.js";
+import { WishlistStore } from "./wishlist-store.js";
+import { SqliteDualPlanningStore } from "./sqlite-dual-planning.js";
+import { getTaskPersistenceBackend, planningSqliteDatabaseRelativePath, planningTaskStoreRelativePath, planningWishlistStoreRelativePath } from "./planning-config.js";
+export async function openPlanningStores(ctx) {
+    if (getTaskPersistenceBackend(ctx.effectiveConfig) === "sqlite") {
+        const dual = new SqliteDualPlanningStore(ctx.workspacePath, planningSqliteDatabaseRelativePath(ctx));
+        dual.loadFromDisk();
+        const taskStore = TaskStore.forSqliteDual(dual);
+        await taskStore.load(); // binds task document reference from dual
+        return {
+            kind: "sqlite",
+            sqliteDual: dual,
+            taskStore,
+            openWishlist: async () => {
+                const w = WishlistStore.forSqliteDual(dual);
+                await w.load();
+                return w;
+            }
+        };
+    }
+    const taskStore = TaskStore.forJsonFile(ctx.workspacePath, planningTaskStoreRelativePath(ctx));
+    await taskStore.load();
+    return {
+        kind: "json",
+        sqliteDual: null,
+        taskStore,
+        openWishlist: async () => {
+            const w = WishlistStore.forJsonFile(ctx.workspacePath, planningWishlistStoreRelativePath(ctx));
+            await w.load();
+            return w;
+        }
+    };
+}

package/dist/modules/task-engine/sqlite-dual-planning.d.ts

@@ -0,0 +1,21 @@
+import type { TaskStoreDocument } from "./types.js";
+import type { WishlistStoreDocument } from "./wishlist-types.js";
+/** Single-file SQLite backing for task + wishlist JSON documents (atomic convert-wishlist). */
+export declare class SqliteDualPlanningStore {
+    private db;
+    readonly dbPath: string;
+    private _taskDoc;
+    private _wishlistDoc;
+    constructor(workspacePath: string, databaseRelativePath: string);
+    get taskDocument(): TaskStoreDocument;
+    get wishlistDocument(): WishlistStoreDocument;
+    getDisplayPath(): string;
+    private ensureDb;
+    /** Load documents from an existing database file; otherwise start empty (no file created). */
+    loadFromDisk(): void;
+    /** Replace in-memory documents (used by migrate). */
+    seedFromDocuments(taskDoc: TaskStoreDocument, wishlistDoc: WishlistStoreDocument): void;
+    persistSync(): void;
+    /** Run synchronous work inside one SQLite transaction and flush both blobs at the end. */
+    withTransaction(work: () => void): void;
+}

package/dist/modules/task-engine/sqlite-dual-planning.js

@@ -0,0 +1,137 @@
+import fs from "node:fs";
+import path from "node:path";
+import Database from "better-sqlite3";
+import { TaskEngineError } from "./transitions.js";
+const DDL = `
+CREATE TABLE IF NOT EXISTS workspace_planning_state (
+  id INTEGER PRIMARY KEY CHECK (id = 1),
+  task_store_json TEXT NOT NULL,
+  wishlist_store_json TEXT NOT NULL
+);
+`;
+function emptyTaskStoreDocument() {
+    return {
+        schemaVersion: 1,
+        tasks: [],
+        transitionLog: [],
+        mutationLog: [],
+        lastUpdated: new Date().toISOString()
+    };
+}
+function emptyWishlistDocument() {
+    return {
+        schemaVersion: 1,
+        items: [],
+        lastUpdated: new Date().toISOString()
+    };
+}
+/** Single-file SQLite backing for task + wishlist JSON documents (atomic convert-wishlist). */
+export class SqliteDualPlanningStore {
+    db = null;
+    dbPath;
+    _taskDoc;
+    _wishlistDoc;
+    constructor(workspacePath, databaseRelativePath) {
+        this.dbPath = path.resolve(workspacePath, databaseRelativePath);
+        this._taskDoc = emptyTaskStoreDocument();
+        this._wishlistDoc = emptyWishlistDocument();
+    }
+    get taskDocument() {
+        return this._taskDoc;
+    }
+    get wishlistDocument() {
+        return this._wishlistDoc;
+    }
+    getDisplayPath() {
+        return this.dbPath;
+    }
+    ensureDb() {
+        if (!this.db) {
+            const dir = path.dirname(this.dbPath);
+            fs.mkdirSync(dir, { recursive: true });
+            this.db = new Database(this.dbPath);
+            this.db.pragma("journal_mode = WAL");
+            this.db.exec(DDL);
+        }
+        return this.db;
+    }
+    /** Load documents from an existing database file; otherwise start empty (no file created). */
+    loadFromDisk() {
+        if (!fs.existsSync(this.dbPath)) {
+            this._taskDoc = emptyTaskStoreDocument();
+            this._wishlistDoc = emptyWishlistDocument();
+            return;
+        }
+        const db = this.ensureDb();
+        const row = db
+            .prepare("SELECT task_store_json, wishlist_store_json FROM workspace_planning_state WHERE id = 1")
+            .get();
+        if (!row) {
+            this._taskDoc = emptyTaskStoreDocument();
+            this._wishlistDoc = emptyWishlistDocument();
+            return;
+        }
+        try {
+            const taskParsed = JSON.parse(row.task_store_json);
+            const wishParsed = JSON.parse(row.wishlist_store_json);
+            if (taskParsed.schemaVersion !== 1) {
+                throw new TaskEngineError("storage-read-error", `Unsupported task store schema in SQLite: ${taskParsed.schemaVersion}`);
+            }
+            if (wishParsed.schemaVersion !== 1) {
+                throw new TaskEngineError("storage-read-error", `Unsupported wishlist schema in SQLite: ${wishParsed.schemaVersion}`);
+            }
+            if (!Array.isArray(taskParsed.mutationLog)) {
+                taskParsed.mutationLog = [];
+            }
+            if (!Array.isArray(wishParsed.items)) {
+                throw new TaskEngineError("storage-read-error", "Wishlist items missing in SQLite row");
+            }
+            this._taskDoc = taskParsed;
+            this._wishlistDoc = wishParsed;
+        }
+        catch (err) {
+            if (err instanceof TaskEngineError) {
+                throw err;
+            }
+            throw new TaskEngineError("storage-read-error", `Failed to parse SQLite planning row: ${err.message}`);
+        }
+    }
+    /** Replace in-memory documents (used by migrate). */
+    seedFromDocuments(taskDoc, wishlistDoc) {
+        this._taskDoc = taskDoc;
+        this._wishlistDoc = wishlistDoc;
+    }
+    persistSync() {
+        this._taskDoc.lastUpdated = new Date().toISOString();
+        this._wishlistDoc.lastUpdated = new Date().toISOString();
+        const db = this.ensureDb();
+        const t = JSON.stringify(this._taskDoc);
+        const w = JSON.stringify(this._wishlistDoc);
+        const exists = db.prepare("SELECT 1 AS ok FROM workspace_planning_state WHERE id = 1").get();
+        if (exists) {
+            db.prepare("UPDATE workspace_planning_state SET task_store_json = ?, wishlist_store_json = ? WHERE id = 1").run(t, w);
+        }
+        else {
+            db.prepare("INSERT INTO workspace_planning_state (id, task_store_json, wishlist_store_json) VALUES (1, ?, ?)").run(t, w);
+        }
+    }
+    /** Run synchronous work inside one SQLite transaction and flush both blobs at the end. */
+    withTransaction(work) {
+        const db = this.ensureDb();
+        const txn = db.transaction(() => {
+            work();
+            this._taskDoc.lastUpdated = new Date().toISOString();
+            this._wishlistDoc.lastUpdated = new Date().toISOString();
+            const t = JSON.stringify(this._taskDoc);
+            const w = JSON.stringify(this._wishlistDoc);
+            const exists = db.prepare("SELECT 1 AS ok FROM workspace_planning_state WHERE id = 1").get();
+            if (exists) {
+                db.prepare("UPDATE workspace_planning_state SET task_store_json = ?, wishlist_store_json = ? WHERE id = 1").run(t, w);
+            }
+            else {
+                db.prepare("INSERT INTO workspace_planning_state (id, task_store_json, wishlist_store_json) VALUES (1, ?, ?)").run(t, w);
+            }
+        });
+        txn();
+    }
+}

package/dist/modules/task-engine/store.d.ts

@@ -1,8 +1,17 @@
-import type { TaskEntity, TaskMutationEvidence, TransitionEvidence } from "./types.js";
+import type { TaskEntity, TaskMutationEvidence, TaskStoreDocument, TransitionEvidence } from "./types.js";
+import type { SqliteDualPlanningStore } from "./sqlite-dual-planning.js";
+export declare const DEFAULT_TASK_STORE_PATH = ".workspace-kit/tasks/state.json";
+export type TaskStorePersistence = {
+    loadDocument: () => Promise<TaskStoreDocument>;
+    saveDocument: (doc: TaskStoreDocument) => Promise<void>;
+    pathLabel: string;
+};
 export declare class TaskStore {
     private document;
-    private readonly filePath;
-    constructor(workspacePath: string, storePath?: string);
+    private readonly persistence;
+    constructor(persistence: TaskStorePersistence);
+    static forJsonFile(workspacePath: string, storeRelativePath?: string): TaskStore;
+    static forSqliteDual(dual: SqliteDualPlanningStore): TaskStore;
     load(): Promise<void>;
     save(): Promise<void>;
     getAllTasks(): TaskEntity[];

package/dist/modules/task-engine/store.js

@@ -2,7 +2,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import crypto from "node:crypto";
 import { TaskEngineError } from "./transitions.js";
-const DEFAULT_STORE_PATH = ".workspace-kit/tasks/state.json";
+export const DEFAULT_TASK_STORE_PATH = ".workspace-kit/tasks/state.json";
 function emptyStore() {
     return {
         schemaVersion: 1,
@@ -14,49 +14,73 @@ function emptyStore() {
 }
 export class TaskStore {
     document;
-    filePath;
-    constructor(workspacePath, storePath) {
-        this.filePath = path.resolve(workspacePath, storePath ?? DEFAULT_STORE_PATH);
+    persistence;
+    constructor(persistence) {
+        this.persistence = persistence;
         this.document = emptyStore();
     }
-    async load() {
-        try {
-            const raw = await fs.readFile(this.filePath, "utf8");
-            const parsed = JSON.parse(raw);
-            if (parsed.schemaVersion !== 1) {
-                throw new TaskEngineError("storage-read-error", `Unsupported schema version: ${parsed.schemaVersion}`);
-            }
-            this.document = parsed;
-            if (!Array.isArray(this.document.mutationLog)) {
-                this.document.mutationLog = [];
+    static forJsonFile(workspacePath, storeRelativePath) {
+        const filePath = path.resolve(workspacePath, storeRelativePath ?? DEFAULT_TASK_STORE_PATH);
+        return new TaskStore({
+            pathLabel: filePath,
+            loadDocument: async () => {
+                try {
+                    const raw = await fs.readFile(filePath, "utf8");
+                    const parsed = JSON.parse(raw);
+                    if (parsed.schemaVersion !== 1) {
+                        throw new TaskEngineError("storage-read-error", `Unsupported schema version: ${parsed.schemaVersion}`);
+                    }
+                    if (!Array.isArray(parsed.mutationLog)) {
+                        parsed.mutationLog = [];
+                    }
+                    return parsed;
+                }
+                catch (err) {
+                    if (err.code === "ENOENT") {
+                        return emptyStore();
+                    }
+                    if (err instanceof TaskEngineError) {
+                        throw err;
+                    }
+                    throw new TaskEngineError("storage-read-error", `Failed to read task store: ${err.message}`);
+                }
+            },
+            saveDocument: async (doc) => {
+                const dir = path.dirname(filePath);
+                const tmpPath = `${filePath}.${crypto.randomUUID().slice(0, 8)}.tmp`;
+                try {
+                    await fs.mkdir(dir, { recursive: true });
+                    await fs.writeFile(tmpPath, JSON.stringify(doc, null, 2) + "\n", "utf8");
+                    await fs.rename(tmpPath, filePath);
+                }
+                catch (err) {
+                    try {
+                        await fs.unlink(tmpPath);
+                    }
+                    catch {
+                        /* cleanup best-effort */
+                    }
+                    throw new TaskEngineError("storage-write-error", `Failed to write task store: ${err.message}`);
+                }
             }
-        }
-        catch (err) {
-            if (err.code === "ENOENT") {
-                this.document = emptyStore();
-                return;
+        });
+    }
+    static forSqliteDual(dual) {
+        return new TaskStore({
+            pathLabel: `${dual.getDisplayPath()}#task_engine`,
+            loadDocument: async () => dual.taskDocument,
+            saveDocument: async (doc) => {
+                dual.seedFromDocuments(doc, dual.wishlistDocument);
+                dual.persistSync();
             }
-            if (err instanceof TaskEngineError)
-                throw err;
-            throw new TaskEngineError("storage-read-error", `Failed to read task store: ${err.message}`);
-        }
+        });
+    }
+    async load() {
+        this.document = await this.persistence.loadDocument();
     }
     async save() {
         this.document.lastUpdated = new Date().toISOString();
-        const dir = path.dirname(this.filePath);
-        const tmpPath = `${this.filePath}.${crypto.randomUUID().slice(0, 8)}.tmp`;
-        try {
-            await fs.mkdir(dir, { recursive: true });
-            await fs.writeFile(tmpPath, JSON.stringify(this.document, null, 2) + "\n", "utf8");
-            await fs.rename(tmpPath, this.filePath);
-        }
-        catch (err) {
-            try {
-                await fs.unlink(tmpPath);
-            }
-            catch { /* cleanup best-effort */ }
-            throw new TaskEngineError("storage-write-error", `Failed to write task store: ${err.message}`);
-        }
+        await this.persistence.saveDocument(this.document);
     }
     getAllTasks() {
         return [...this.document.tasks];
@@ -99,7 +123,7 @@ export class TaskStore {
         this.document.tasks = tasks.map((t) => ({ ...t }));
     }
     getFilePath() {
-        return this.filePath;
+        return this.persistence.pathLabel;
     }
     getLastUpdated() {
         return this.document.lastUpdated;

package/dist/modules/task-engine/wishlist-store.d.ts

@@ -1,8 +1,17 @@
-import type { WishlistItem } from "./wishlist-types.js";
+import type { WishlistItem, WishlistStoreDocument } from "./wishlist-types.js";
+import type { SqliteDualPlanningStore } from "./sqlite-dual-planning.js";
+export declare const DEFAULT_WISHLIST_PATH = ".workspace-kit/wishlist/state.json";
+export type WishlistStorePersistence = {
+    loadDocument: () => Promise<WishlistStoreDocument>;
+    saveDocument: (doc: WishlistStoreDocument) => Promise<void>;
+    pathLabel: string;
+};
 export declare class WishlistStore {
     private document;
-    private readonly filePath;
-    constructor(workspacePath: string, storeRelativePath?: string);
+    private readonly persistence;
+    constructor(persistence: WishlistStorePersistence);
+    static forJsonFile(workspacePath: string, storeRelativePath?: string): WishlistStore;
+    static forSqliteDual(dual: SqliteDualPlanningStore): WishlistStore;
     load(): Promise<void>;
     save(): Promise<void>;
     getAllItems(): WishlistItem[];

package/dist/modules/task-engine/wishlist-store.js

@@ -2,7 +2,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import crypto from "node:crypto";
 import { TaskEngineError } from "./transitions.js";
-const DEFAULT_WISHLIST_PATH = ".workspace-kit/wishlist/state.json";
+export const DEFAULT_WISHLIST_PATH = ".workspace-kit/wishlist/state.json";
 function emptyWishlistDoc() {
     return {
         schemaVersion: 1,
@@ -12,51 +12,73 @@ function emptyWishlistDoc() {
 }
 export class WishlistStore {
     document;
-    filePath;
-    constructor(workspacePath, storeRelativePath) {
-        this.filePath = path.resolve(workspacePath, storeRelativePath ?? DEFAULT_WISHLIST_PATH);
+    persistence;
+    constructor(persistence) {
+        this.persistence = persistence;
         this.document = emptyWishlistDoc();
     }
-    async load() {
-        try {
-            const raw = await fs.readFile(this.filePath, "utf8");
-            const parsed = JSON.parse(raw);
-            if (parsed.schemaVersion !== 1) {
-                throw new TaskEngineError("storage-read-error", `Unsupported wishlist schema version: ${parsed.schemaVersion}`);
-            }
-            if (!Array.isArray(parsed.items)) {
-                throw new TaskEngineError("storage-read-error", "Wishlist store 'items' must be an array");
+    static forJsonFile(workspacePath, storeRelativePath) {
+        const filePath = path.resolve(workspacePath, storeRelativePath ?? DEFAULT_WISHLIST_PATH);
+        return new WishlistStore({
+            pathLabel: filePath,
+            loadDocument: async () => {
+                try {
+                    const raw = await fs.readFile(filePath, "utf8");
+                    const parsed = JSON.parse(raw);
+                    if (parsed.schemaVersion !== 1) {
+                        throw new TaskEngineError("storage-read-error", `Unsupported wishlist schema version: ${parsed.schemaVersion}`);
+                    }
+                    if (!Array.isArray(parsed.items)) {
+                        throw new TaskEngineError("storage-read-error", "Wishlist store 'items' must be an array");
+                    }
+                    return parsed;
+                }
+                catch (err) {
+                    if (err.code === "ENOENT") {
+                        return emptyWishlistDoc();
+                    }
+                    if (err instanceof TaskEngineError) {
+                        throw err;
+                    }
+                    throw new TaskEngineError("storage-read-error", `Failed to read wishlist store: ${err.message}`);
+                }
+            },
+            saveDocument: async (doc) => {
+                const dir = path.dirname(filePath);
+                const tmpPath = `${filePath}.${crypto.randomUUID().slice(0, 8)}.tmp`;
+                try {
+                    await fs.mkdir(dir, { recursive: true });
+                    await fs.writeFile(tmpPath, JSON.stringify(doc, null, 2) + "\n", "utf8");
+                    await fs.rename(tmpPath, filePath);
+                }
+                catch (err) {
+                    try {
+                        await fs.unlink(tmpPath);
+                    }
+                    catch {
+                        /* cleanup best-effort */
+                    }
+                    throw new TaskEngineError("storage-write-error", `Failed to write wishlist store: ${err.message}`);
+                }
             }
-            this.document = parsed;
-        }
-        catch (err) {
-            if (err.code === "ENOENT") {
-                this.document = emptyWishlistDoc();
-                return;
+        });
+    }
+    static forSqliteDual(dual) {
+        return new WishlistStore({
+            pathLabel: `${dual.getDisplayPath()}#wishlist`,
+            loadDocument: async () => dual.wishlistDocument,
+            saveDocument: async (doc) => {
+                dual.seedFromDocuments(dual.taskDocument, doc);
+                dual.persistSync();
             }
-            if (err instanceof TaskEngineError)
-                throw err;
-            throw new TaskEngineError("storage-read-error", `Failed to read wishlist store: ${err.message}`);
-        }
+        });
+    }
+    async load() {
+        this.document = await this.persistence.loadDocument();
     }
     async save() {
         this.document.lastUpdated = new Date().toISOString();
-        const dir = path.dirname(this.filePath);
-        const tmpPath = `${this.filePath}.${crypto.randomUUID().slice(0, 8)}.tmp`;
-        try {
-            await fs.mkdir(dir, { recursive: true });
-            await fs.writeFile(tmpPath, JSON.stringify(this.document, null, 2) + "\n", "utf8");
-            await fs.rename(tmpPath, this.filePath);
-        }
-        catch (err) {
-            try {
-                await fs.unlink(tmpPath);
-            }
-            catch {
-                /* cleanup best-effort */
-            }
-            throw new TaskEngineError("storage-write-error", `Failed to write wishlist store: ${err.message}`);
-        }
+        await this.persistence.saveDocument(this.document);
     }
     getAllItems() {
         return [...this.document.items];
@@ -78,7 +100,7 @@ export class WishlistStore {
         this.document.items[idx] = { ...item };
     }
     getFilePath() {
-        return this.filePath;
+        return this.persistence.pathLabel;
     }
     getLastUpdated() {
         return this.document.lastUpdated;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workflow-cannon/workspace-kit",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "private": false,
   "packageManager": "pnpm@10.0.0",
   "license": "MIT",
@@ -41,6 +41,7 @@
     "ui:watch": "cd extensions/cursor-workflow-cannon && npm run watch"
   },
   "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^25.5.0",
     "typescript": "^5.9.3"
   },
@@ -48,5 +49,13 @@
     "dist",
     "src/modules/documentation",
     "package.json"
-  ]
+  ],
+  "dependencies": {
+    "better-sqlite3": "^12.8.0"
+  },
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "better-sqlite3"
+    ]
+  }
 }

package/src/modules/documentation/README.md

@@ -24,6 +24,7 @@ Files under `templates/`; `documentType` is the filename (basename). Keep this l
 - `AGENTS.md`
 - `ARCHITECTURE.md`
 - `PRINCIPLES.md`
+- `README.md`
 - `RELEASING.md`
 - `ROADMAP.md`
 - `SECURITY.md`

package/src/modules/documentation/instructions/document-project.md

@@ -18,6 +18,7 @@ All `.md` files under `sources.templatesRoot` (default `src/modules/documentatio
 - `AGENTS.md`
 - `ARCHITECTURE.md`
 - `PRINCIPLES.md`
+- `README.md`
 - `RELEASING.md`
 - `ROADMAP.md`
 - `SECURITY.md`

package/src/modules/documentation/instructions/generate-document.md

@@ -8,6 +8,7 @@ Generate a single document for both canonical AI and human-readable surfaces usi
   - `AGENTS.md`
   - `ARCHITECTURE.md`
   - `PRINCIPLES.md`
+  - `README.md`
   - `RELEASING.md`
   - `ROADMAP.md`
   - `SECURITY.md`