@workflow-cannon/workspace-kit 0.18.0 → 0.24.0

package/dist/modules/task-engine/migrate-task-persistence-runtime.js

@@ -2,6 +2,7 @@ import fs from "node:fs/promises";
 import fsSync from "node:fs";
 import path from "node:path";
 import crypto from "node:crypto";
+import { UnifiedStateDb } from "../../core/state/unified-state-db.js";
 import { TaskEngineError } from "./transitions.js";
 import { SqliteDualPlanningStore } from "./sqlite-dual-planning.js";
 import { planningSqliteDatabaseRelativePath, planningTaskStoreRelativePath, planningWishlistStoreRelativePath } from "./planning-config.js";
@@ -32,11 +33,13 @@ async function atomicWriteJson(targetPath, body) {
 }
 export async function runMigrateTaskPersistence(ctx, args) {
     const direction = typeof args.direction === "string" ? args.direction.trim() : "";
-    if (direction !== "json-to-sqlite" && direction !== "sqlite-to-json") {
+    if (direction !== "json-to-sqlite" &&
+        direction !== "sqlite-to-json" &&
+        direction !== "json-to-unified-sqlite") {
         return {
             ok: false,
             code: "invalid-task-schema",
-            message: "migrate-task-persistence requires direction: 'json-to-sqlite' | 'sqlite-to-json'"
+            message: "migrate-task-persistence requires direction: 'json-to-sqlite' | 'sqlite-to-json' | 'json-to-unified-sqlite'"
         };
     }
     const dryRun = args.dryRun === true;
@@ -47,7 +50,7 @@ export async function runMigrateTaskPersistence(ctx, args) {
     const wishPath = path.resolve(ctx.workspacePath, wishRel);
     const dbRel = planningSqliteDatabaseRelativePath(ctx);
     const dual = new SqliteDualPlanningStore(ctx.workspacePath, dbRel);
-    if (direction === "json-to-sqlite") {
+    if (direction === "json-to-sqlite" || direction === "json-to-unified-sqlite") {
         if (fsSync.existsSync(dual.dbPath) && !force) {
             return {
                 ok: false,
@@ -113,7 +116,9 @@ export async function runMigrateTaskPersistence(ctx, args) {
             return {
                 ok: true,
                 code: "migrate-dry-run",
-                message: "Dry run: would import JSON task/wishlist documents into SQLite",
+                message: direction === "json-to-unified-sqlite"
+                    ? "Dry run: would import JSON task/wishlist documents into unified SQLite module state"
+                    : "Dry run: would import JSON task/wishlist documents into SQLite",
                 data: {
                     dbPath: dual.dbPath,
                     taskPath,
@@ -123,6 +128,28 @@ export async function runMigrateTaskPersistence(ctx, args) {
                 }
             };
         }
+        if (direction === "json-to-unified-sqlite") {
+            try {
+                const unified = new UnifiedStateDb(ctx.workspacePath, dbRel);
+                unified.setModuleState("task-engine", 1, {
+                    taskStore: taskDoc,
+                    wishlistStore: wishDoc
+                });
+            }
+            catch (err) {
+                return {
+                    ok: false,
+                    code: "storage-write-error",
+                    message: `Failed to write unified SQLite module state: ${err.message}`
+                };
+            }
+            return {
+                ok: true,
+                code: "migrated-json-to-unified-sqlite",
+                message: `Imported task and wishlist JSON into unified module state at ${dual.dbPath}`,
+                data: { dbPath: dual.dbPath, taskPath, wishPath, moduleId: "task-engine" }
+            };
+        }
         dual.seedFromDocuments(taskDoc, wishDoc);
         try {
             dual.persistSync();

package/dist/modules/task-engine/migrate-wishlist-intake-runtime.d.ts

@@ -0,0 +1,2 @@
+import type { ModuleCommandResult, ModuleLifecycleContext } from "../../contracts/module-contract.js";
+export declare function runMigrateWishlistIntake(ctx: ModuleLifecycleContext, args: Record<string, unknown>): Promise<ModuleCommandResult>;

package/dist/modules/task-engine/migrate-wishlist-intake-runtime.js

@@ -0,0 +1,146 @@
+import fs from "node:fs/promises";
+import fsSync from "node:fs";
+import path from "node:path";
+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";
+import { DEFAULT_TASK_STORE_PATH } from "./store.js";
+import { DEFAULT_WISHLIST_PATH } from "./wishlist-store.js";
+import { allocateNextTaskNumericId, isWishlistIntakeTask, LEGACY_WISHLIST_ID_METADATA_KEY, taskEntityFromWishlistItem } from "./wishlist-intake.js";
+function emptyWishDoc() {
+    return {
+        schemaVersion: 1,
+        items: [],
+        lastUpdated: new Date().toISOString()
+    };
+}
+export async function runMigrateWishlistIntake(ctx, args) {
+    const dryRun = args.dryRun === true;
+    const backend = getTaskPersistenceBackend(ctx.effectiveConfig);
+    if (backend === "sqlite") {
+        return migrateSqlite(ctx, dryRun);
+    }
+    return migrateJson(ctx, dryRun);
+}
+async function migrateJson(ctx, dryRun) {
+    const taskRel = planningTaskStoreRelativePath(ctx) ?? DEFAULT_TASK_STORE_PATH;
+    const wishRel = planningWishlistStoreRelativePath(ctx) ?? DEFAULT_WISHLIST_PATH;
+    const taskPath = path.resolve(ctx.workspacePath, taskRel);
+    const wishPath = path.resolve(ctx.workspacePath, wishRel);
+    const taskStore = TaskStore.forJsonFile(ctx.workspacePath, taskRel);
+    await taskStore.load();
+    const wishStore = WishlistStore.forJsonFile(ctx.workspacePath, wishRel);
+    await wishStore.load();
+    const items = wishStore.getAllItems();
+    if (items.length === 0) {
+        return {
+            ok: true,
+            code: "wishlist-intake-migrate-noop",
+            message: "No legacy wishlist items to migrate (JSON mode)",
+            data: { migratedCount: 0, wishPath, taskPath }
+        };
+    }
+    const tasks = taskStore.getAllTasks();
+    const existingLegacy = new Set(tasks
+        .filter((t) => isWishlistIntakeTask(t))
+        .map((t) => t.metadata?.[LEGACY_WISHLIST_ID_METADATA_KEY])
+        .filter((x) => typeof x === "string"));
+    const toAdd = items.filter((it) => !existingLegacy.has(it.id));
+    if (dryRun) {
+        return {
+            ok: true,
+            code: "migrate-dry-run",
+            message: `Dry run: would migrate ${toAdd.length} wishlist item(s) into tasks and clear ${wishPath}`,
+            data: { wishlistCount: items.length, wouldMigrate: toAdd.length, wishPath, taskPath }
+        };
+    }
+    const now = new Date().toISOString();
+    let working = [...tasks];
+    for (const item of toAdd) {
+        const newId = allocateNextTaskNumericId(working);
+        const entity = taskEntityFromWishlistItem(item, newId, now);
+        working.push(entity);
+        taskStore.addTask(entity);
+    }
+    await taskStore.save();
+    await fs.mkdir(path.dirname(wishPath), { recursive: true });
+    await fs.writeFile(wishPath, `${JSON.stringify(emptyWishDoc(), null, 2)}\n`, "utf8");
+    return {
+        ok: true,
+        code: "wishlist-intake-migrated",
+        message: `Migrated ${toAdd.length} wishlist item(s) to wishlist_intake tasks; cleared ${wishPath}`,
+        data: { migratedCount: toAdd.length, wishPath, taskPath }
+    };
+}
+function migrateSqlite(ctx, dryRun) {
+    const dbRel = planningSqliteDatabaseRelativePath(ctx);
+    const dual = new SqliteDualPlanningStore(ctx.workspacePath, dbRel);
+    if (!fsSync.existsSync(dual.dbPath)) {
+        return {
+            ok: false,
+            code: "storage-read-error",
+            message: `SQLite planning database not found at ${dual.dbPath}`
+        };
+    }
+    dual.loadFromDisk();
+    const wishItems = dual.wishlistDocument.items;
+    const taskDoc = dual.taskDocument;
+    const existingLegacy = new Set(taskDoc.tasks
+        .filter((t) => isWishlistIntakeTask(t))
+        .map((t) => t.metadata?.[LEGACY_WISHLIST_ID_METADATA_KEY])
+        .filter((x) => typeof x === "string"));
+    const toAdd = wishItems.filter((it) => !existingLegacy.has(it.id));
+    const needsWishlistClear = wishItems.length > 0;
+    const needsSchemaShrink = dual.tableShape === "legacy-dual";
+    if (dryRun) {
+        return {
+            ok: true,
+            code: "migrate-dry-run",
+            message: `Dry run: would migrate ${toAdd.length} wishlist row(s), clear wishlist blob when needed, and shrink SQLite schema when applicable`,
+            data: {
+                dbPath: dual.dbPath,
+                wishlistCount: wishItems.length,
+                wouldMigrate: toAdd.length,
+                tableShape: dual.tableShape,
+                needsWishlistClear,
+                needsSchemaShrink
+            }
+        };
+    }
+    if (toAdd.length === 0 && !needsWishlistClear && !needsSchemaShrink) {
+        return {
+            ok: true,
+            code: "wishlist-intake-migrate-noop",
+            message: "No legacy wishlist data and planning SQLite already uses task-only row shape",
+            data: { migratedCount: 0, dbPath: dual.dbPath }
+        };
+    }
+    const now = new Date().toISOString();
+    const store = TaskStore.forSqliteDual(dual);
+    const apply = () => {
+        let working = [...dual.taskDocument.tasks];
+        for (const item of toAdd) {
+            const newId = allocateNextTaskNumericId(working);
+            const entity = taskEntityFromWishlistItem(item, newId, now);
+            working.push(entity);
+            store.addTask(entity);
+        }
+        if (needsWishlistClear) {
+            dual.seedFromDocuments(dual.taskDocument, emptyWishDoc());
+        }
+    };
+    dual.withTransaction(apply);
+    if (needsSchemaShrink) {
+        dual.migrateToTaskOnlyTableSchema();
+    }
+    else {
+        dual.persistSync();
+    }
+    return {
+        ok: true,
+        code: "wishlist-intake-migrated",
+        message: `Migrated ${toAdd.length} wishlist item(s) to tasks; cleared legacy wishlist blob where applicable`,
+        data: { migratedCount: toAdd.length, dbPath: dual.dbPath, schemaShrunk: needsSchemaShrink }
+    };
+}

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

@@ -1,16 +1,9 @@
 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";
+    kind: "json" | "sqlite";
     taskStore: TaskStore;
-    sqliteDual: null;
-    openWishlist: () => Promise<WishlistStore>;
-} | {
-    kind: "sqlite";
-    taskStore: TaskStore;
-    sqliteDual: SqliteDualPlanningStore;
-    openWishlist: () => Promise<WishlistStore>;
+    sqliteDual: SqliteDualPlanningStore | null;
 };
 export declare function openPlanningStores(ctx: ModuleLifecycleContext): Promise<OpenedPlanningStores>;

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

@@ -1,22 +1,16 @@
 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";
+import { getTaskPersistenceBackend, planningSqliteDatabaseRelativePath, planningTaskStoreRelativePath } 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
+        await taskStore.load();
         return {
             kind: "sqlite",
             sqliteDual: dual,
-            taskStore,
-            openWishlist: async () => {
-                const w = WishlistStore.forSqliteDual(dual);
-                await w.load();
-                return w;
-            }
+            taskStore
         };
     }
     const taskStore = TaskStore.forJsonFile(ctx.workspacePath, planningTaskStoreRelativePath(ctx));
@@ -24,11 +18,6 @@ export async function openPlanningStores(ctx) {
     return {
         kind: "json",
         sqliteDual: null,
-        taskStore,
-        openWishlist: async () => {
-            const w = WishlistStore.forJsonFile(ctx.workspacePath, planningWishlistStoreRelativePath(ctx));
-            await w.load();
-            return w;
-        }
+        taskStore
     };
 }

package/dist/modules/task-engine/policy-sensitive-commands.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Policy-gated `workspace-kit run` commands owned by the task-engine module.
+ * Keep in sync with instruction names in `task-engine-internal.ts` / registration.
+ */
+export declare const TASK_ENGINE_POLICY_COMMAND_NAMES: readonly [readonly ["run-transition", "tasks.run-transition"]];

package/dist/modules/task-engine/policy-sensitive-commands.js

@@ -0,0 +1,5 @@
+/**
+ * Policy-gated `workspace-kit run` commands owned by the task-engine module.
+ * Keep in sync with instruction names in `task-engine-internal.ts` / registration.
+ */
+export const TASK_ENGINE_POLICY_COMMAND_NAMES = [["run-transition", "tasks.run-transition"]];

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

@@ -1,14 +1,17 @@
 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). */
+type TableShape = "legacy-dual" | "task-only";
+/** Single-file SQLite backing for task JSON document; legacy rows may include a second wishlist blob until migrated. */
 export declare class SqliteDualPlanningStore {
     private db;
     readonly dbPath: string;
     private _taskDoc;
     private _wishlistDoc;
+    private _tableShape;
     constructor(workspacePath: string, databaseRelativePath: string);
     get taskDocument(): TaskStoreDocument;
     get wishlistDocument(): WishlistStoreDocument;
+    get tableShape(): TableShape;
     getDisplayPath(): string;
     private ensureDb;
     /** Load documents from an existing database file; otherwise start empty (no file created). */
@@ -16,6 +19,12 @@ export declare class SqliteDualPlanningStore {
     /** 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. */
+    /** Run synchronous work inside one SQLite transaction and flush blob(s) at the end. */
     withTransaction(work: () => void): void;
+    /**
+     * Drop legacy `wishlist_store_json` column by recreating the table (task JSON only).
+     * Caller must persist an empty wishlist document first if migrating off legacy data.
+     */
+    migrateToTaskOnlyTableSchema(): void;
 }
+export {};

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

@@ -2,11 +2,10 @@ import fs from "node:fs";
 import path from "node:path";
 import Database from "better-sqlite3";
 import { TaskEngineError } from "./transitions.js";
-const DDL = `
+const TASK_ONLY_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
+  task_store_json TEXT NOT NULL
 );
 `;
 function emptyTaskStoreDocument() {
@@ -25,12 +24,20 @@ function emptyWishlistDocument() {
         lastUpdated: new Date().toISOString()
     };
 }
-/** Single-file SQLite backing for task + wishlist JSON documents (atomic convert-wishlist). */
+function detectTableShape(db) {
+    const rows = db.prepare("PRAGMA table_info(workspace_planning_state)").all();
+    if (rows.some((r) => r.name === "wishlist_store_json")) {
+        return "legacy-dual";
+    }
+    return "task-only";
+}
+/** Single-file SQLite backing for task JSON document; legacy rows may include a second wishlist blob until migrated. */
 export class SqliteDualPlanningStore {
     db = null;
     dbPath;
     _taskDoc;
     _wishlistDoc;
+    _tableShape = "task-only";
     constructor(workspacePath, databaseRelativePath) {
         this.dbPath = path.resolve(workspacePath, databaseRelativePath);
         this._taskDoc = emptyTaskStoreDocument();
@@ -42,16 +49,36 @@ export class SqliteDualPlanningStore {
     get wishlistDocument() {
         return this._wishlistDoc;
     }
+    get tableShape() {
+        return this._tableShape;
+    }
     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);
+        if (this.db) {
+            return this.db;
+        }
+        const dir = path.dirname(this.dbPath);
+        fs.mkdirSync(dir, { recursive: true });
+        const fileExisted = fs.existsSync(this.dbPath);
+        this.db = new Database(this.dbPath);
+        this.db.pragma("journal_mode = WAL");
+        if (!fileExisted) {
+            this.db.exec(TASK_ONLY_DDL);
+            this._tableShape = "task-only";
+        }
+        else {
+            const master = this.db
+                .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='workspace_planning_state'")
+                .get();
+            if (!master) {
+                this.db.exec(TASK_ONLY_DDL);
+                this._tableShape = "task-only";
+            }
+            else {
+                this._tableShape = detectTableShape(this.db);
+            }
         }
         return this.db;
     }
@@ -60,11 +87,48 @@ export class SqliteDualPlanningStore {
         if (!fs.existsSync(this.dbPath)) {
             this._taskDoc = emptyTaskStoreDocument();
             this._wishlistDoc = emptyWishlistDocument();
+            this._tableShape = "task-only";
             return;
         }
         const db = this.ensureDb();
+        this._tableShape = detectTableShape(db);
+        if (this._tableShape === "legacy-dual") {
+            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}`);
+            }
+            return;
+        }
         const row = db
-            .prepare("SELECT task_store_json, wishlist_store_json FROM workspace_planning_state WHERE id = 1")
+            .prepare("SELECT task_store_json FROM workspace_planning_state WHERE id = 1")
             .get();
         if (!row) {
             this._taskDoc = emptyTaskStoreDocument();
@@ -73,21 +137,14 @@ export class SqliteDualPlanningStore {
         }
         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;
+            this._wishlistDoc = emptyWishlistDocument();
         }
         catch (err) {
             if (err instanceof TaskEngineError) {
@@ -105,33 +162,82 @@ export class SqliteDualPlanningStore {
         this._taskDoc.lastUpdated = new Date().toISOString();
         this._wishlistDoc.lastUpdated = new Date().toISOString();
         const db = this.ensureDb();
+        this._tableShape = detectTableShape(db);
         const t = JSON.stringify(this._taskDoc);
-        const w = JSON.stringify(this._wishlistDoc);
+        if (this._tableShape === "legacy-dual") {
+            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);
+            }
+            return;
+        }
         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);
+            db.prepare("UPDATE workspace_planning_state SET task_store_json = ? WHERE id = 1").run(t);
         }
         else {
-            db.prepare("INSERT INTO workspace_planning_state (id, task_store_json, wishlist_store_json) VALUES (1, ?, ?)").run(t, w);
+            db.prepare("INSERT INTO workspace_planning_state (id, task_store_json) VALUES (1, ?)").run(t);
         }
     }
-    /** Run synchronous work inside one SQLite transaction and flush both blobs at the end. */
+    /** Run synchronous work inside one SQLite transaction and flush blob(s) at the end. */
     withTransaction(work) {
         const db = this.ensureDb();
+        this._tableShape = detectTableShape(db);
         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);
+            if (this._tableShape === "legacy-dual") {
+                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);
+                }
             }
             else {
-                db.prepare("INSERT INTO workspace_planning_state (id, task_store_json, wishlist_store_json) VALUES (1, ?, ?)").run(t, w);
+                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 = ? WHERE id = 1").run(t);
+                }
+                else {
+                    db.prepare("INSERT INTO workspace_planning_state (id, task_store_json) VALUES (1, ?)").run(t);
+                }
             }
         });
         txn();
     }
+    /**
+     * Drop legacy `wishlist_store_json` column by recreating the table (task JSON only).
+     * Caller must persist an empty wishlist document first if migrating off legacy data.
+     */
+    migrateToTaskOnlyTableSchema() {
+        const db = this.ensureDb();
+        if (detectTableShape(db) !== "legacy-dual") {
+            this._tableShape = "task-only";
+            return;
+        }
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS workspace_planning_state_new (
+        id INTEGER PRIMARY KEY CHECK (id = 1),
+        task_store_json TEXT NOT NULL
+      );
+    `);
+        const row = db
+            .prepare("SELECT task_store_json FROM workspace_planning_state WHERE id = 1")
+            .get();
+        const taskJson = row?.task_store_json ?? JSON.stringify(emptyTaskStoreDocument());
+        db.prepare("INSERT OR REPLACE INTO workspace_planning_state_new (id, task_store_json) VALUES (1, ?)").run(taskJson);
+        db.exec("DROP TABLE workspace_planning_state");
+        db.exec("ALTER TABLE workspace_planning_state_new RENAME TO workspace_planning_state");
+        this._tableShape = "task-only";
+        this._wishlistDoc = emptyWishlistDocument();
+    }
 }

package/dist/modules/task-engine/strict-task-validation.js

@@ -35,6 +35,9 @@ export function validateTaskEntityForStrictMode(task) {
     if (task.acceptanceCriteria !== undefined && !isStringArray(task.acceptanceCriteria)) {
         return `task '${task.id}' has invalid acceptanceCriteria values`;
     }
+    if (task.type === "wishlist_intake" && task.phase !== undefined && String(task.phase).trim().length > 0) {
+        return `task '${task.id}': wishlist_intake tasks must not set phase (ideation-only until converted)`;
+    }
     const knownTypeValidation = validateKnownTaskTypeRequirements(task);
     if (knownTypeValidation) {
         return `task '${task.id}': ${knownTypeValidation.message}`;

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

@@ -1,3 +1,4 @@
+import { isWishlistIntakeTask } from "./wishlist-intake.js";
 const PRIORITY_ORDER = {
     P1: 0,
     P2: 1,
@@ -40,7 +41,7 @@ function buildBlockingAnalysis(tasks) {
 }
 export function getNextActions(tasks) {
     const readyQueue = tasks
-        .filter((t) => t.status === "ready")
+        .filter((t) => t.status === "ready" && !isWishlistIntakeTask(t))
         .sort((a, b) => priorityRank(a) - priorityRank(b));
     return {
         readyQueue,

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

@@ -0,0 +1,2 @@
+import type { WorkflowModule } from "../../contracts/module-contract.js";
+export declare const taskEngineModule: WorkflowModule;