@workflow-cannon/workspace-kit 0.16.0 → 0.16.1

package/dist/cli/doctor-planning-issues.d.ts

@@ -0,0 +1,6 @@
+export type DoctorPlanningIssue = {
+    path: string;
+    reason: string;
+};
+/** Resolve layered config and run SQLite planning persistence checks for `workspace-kit doctor`. */
+export declare function collectDoctorPlanningPersistenceIssues(cwd: string): Promise<DoctorPlanningIssue[]>;

package/dist/cli/doctor-planning-issues.js

@@ -0,0 +1,37 @@
+import { ModuleRegistry } from "../core/module-registry.js";
+import { resolveWorkspaceConfigWithLayers } from "../core/workspace-kit-config.js";
+import { validatePlanningPersistenceForDoctor } from "../modules/task-engine/doctor-planning-persistence.js";
+import { documentationModule } from "../modules/documentation/index.js";
+import { taskEngineModule } from "../modules/task-engine/index.js";
+import { approvalsModule } from "../modules/approvals/index.js";
+import { planningModule } from "../modules/planning/index.js";
+import { improvementModule } from "../modules/improvement/index.js";
+import { workspaceConfigModule } from "../modules/workspace-config/index.js";
+const defaultRegistryModules = [
+    workspaceConfigModule,
+    documentationModule,
+    taskEngineModule,
+    approvalsModule,
+    planningModule,
+    improvementModule
+];
+/** Resolve layered config and run SQLite planning persistence checks for `workspace-kit doctor`. */
+export async function collectDoctorPlanningPersistenceIssues(cwd) {
+    try {
+        const registry = new ModuleRegistry(defaultRegistryModules);
+        const { effective } = await resolveWorkspaceConfigWithLayers({
+            workspacePath: cwd,
+            registry,
+            invocationConfig: {}
+        });
+        return validatePlanningPersistenceForDoctor(cwd, effective);
+    }
+    catch (err) {
+        return [
+            {
+                path: "workspace-config",
+                reason: `config-resolution-failed: ${err.message}`
+            }
+        ];
+    }
+}

package/dist/cli.js

@@ -5,6 +5,7 @@ import { pathToFileURL } from "node:url";
 import { AGENT_CLI_MAP_HUMAN_DOC, appendPolicyTrace, parsePolicyApprovalFromEnv, resolveActorWithFallback } from "./core/policy.js";
 import { runWorkspaceConfigCli } from "./core/config-cli.js";
 import { handleRunCommand } from "./cli/run-command.js";
+import { collectDoctorPlanningPersistenceIssues } from "./cli/doctor-planning-issues.js";
 const EXIT_SUCCESS = 0;
 const EXIT_VALIDATION_FAILURE = 1;
 const EXIT_USAGE_ERROR = 2;
@@ -606,6 +607,7 @@ export async function runCli(args, options = {}) {
             });
         }
     }
+    issues.push(...(await collectDoctorPlanningPersistenceIssues(cwd)));
     if (issues.length > 0) {
         writeError("workspace-kit doctor failed validation.");
         for (const issue of issues) {
@@ -615,6 +617,7 @@ export async function runCli(args, options = {}) {
     }
     writeLine("workspace-kit doctor passed.");
     writeLine("All canonical workspace-kit contract files are present and parseable JSON.");
+    writeLine("Effective workspace config resolved; task planning persistence checks passed (including SQLite when configured).");
     writeLine(`Next: workspace-kit run — list module commands; see ${AGENT_CLI_MAP_HUMAN_DOC} for tier/policy copy-paste.`);
     return EXIT_SUCCESS;
 }

package/dist/core/config-metadata.js

@@ -16,6 +16,46 @@ const REGISTRY = {
         exposure: "public",
         writableLayers: ["project", "user"]
     },
+    "tasks.wishlistStoreRelativePath": {
+        key: "tasks.wishlistStoreRelativePath",
+        type: "string",
+        description: "Relative path (from workspace root) to the Wishlist JSON store when persistenceBackend is json.",
+        default: ".workspace-kit/wishlist/state.json",
+        domainScope: "project",
+        owningModule: "task-engine",
+        sensitive: false,
+        requiresRestart: false,
+        requiresApproval: false,
+        exposure: "public",
+        writableLayers: ["project", "user"]
+    },
+    "tasks.persistenceBackend": {
+        key: "tasks.persistenceBackend",
+        type: "string",
+        description: "Task + wishlist persistence: json (default) or sqlite.",
+        default: "json",
+        allowedValues: ["json", "sqlite"],
+        domainScope: "project",
+        owningModule: "task-engine",
+        sensitive: false,
+        requiresRestart: false,
+        requiresApproval: false,
+        exposure: "public",
+        writableLayers: ["project", "user"]
+    },
+    "tasks.sqliteDatabaseRelativePath": {
+        key: "tasks.sqliteDatabaseRelativePath",
+        type: "string",
+        description: "Relative path (from workspace root) to the SQLite file when persistenceBackend is sqlite.",
+        default: ".workspace-kit/tasks/workspace-kit.db",
+        domainScope: "project",
+        owningModule: "task-engine",
+        sensitive: false,
+        requiresRestart: false,
+        requiresApproval: false,
+        exposure: "public",
+        writableLayers: ["project", "user"]
+    },
     "policy.extraSensitiveModuleCommands": {
         key: "policy.extraSensitiveModuleCommands",
         type: "array",
@@ -315,10 +355,25 @@ export function validatePersistedConfigDocument(data, label) {
         }
         const t = tasks;
         for (const k of Object.keys(t)) {
-            if (k !== "storeRelativePath") {
+            if (k !== "storeRelativePath" &&
+                k !== "wishlistStoreRelativePath" &&
+                k !== "persistenceBackend" &&
+                k !== "sqliteDatabaseRelativePath") {
                 throw new Error(`config-invalid(${label}): unknown tasks.${k}`);
             }
         }
+        if (t.storeRelativePath !== undefined) {
+            validateValueForMetadata(REGISTRY["tasks.storeRelativePath"], t.storeRelativePath);
+        }
+        if (t.wishlistStoreRelativePath !== undefined) {
+            validateValueForMetadata(REGISTRY["tasks.wishlistStoreRelativePath"], t.wishlistStoreRelativePath);
+        }
+        if (t.persistenceBackend !== undefined) {
+            validateValueForMetadata(REGISTRY["tasks.persistenceBackend"], t.persistenceBackend);
+        }
+        if (t.sqliteDatabaseRelativePath !== undefined) {
+            validateValueForMetadata(REGISTRY["tasks.sqliteDatabaseRelativePath"], t.sqliteDatabaseRelativePath);
+        }
     }
     const policy = data.policy;
     if (policy !== undefined) {

package/dist/modules/task-engine/doctor-planning-persistence.d.ts

@@ -0,0 +1,9 @@
+export type DoctorPlanningIssue = {
+    path: string;
+    reason: string;
+};
+/**
+ * When effective config selects SQLite for task/wishlist persistence, verify the DB file exists
+ * and can be opened read-only; if a planning row is present, validate embedded JSON schemaVersion.
+ */
+export declare function validatePlanningPersistenceForDoctor(workspacePath: string, effectiveConfig: Record<string, unknown>): DoctorPlanningIssue[];

package/dist/modules/task-engine/doctor-planning-persistence.js

@@ -0,0 +1,77 @@
+import fs from "node:fs";
+import path from "node:path";
+import Database from "better-sqlite3";
+import { getTaskPersistenceBackend, planningSqliteDatabaseRelativePath } from "./planning-config.js";
+/**
+ * When effective config selects SQLite for task/wishlist persistence, verify the DB file exists
+ * and can be opened read-only; if a planning row is present, validate embedded JSON schemaVersion.
+ */
+export function validatePlanningPersistenceForDoctor(workspacePath, effectiveConfig) {
+    const issues = [];
+    if (getTaskPersistenceBackend(effectiveConfig) !== "sqlite") {
+        return issues;
+    }
+    const ctx = { workspacePath, effectiveConfig };
+    const dbRel = planningSqliteDatabaseRelativePath(ctx);
+    const dbAbs = path.resolve(workspacePath, dbRel);
+    const relDisplay = path.relative(workspacePath, dbAbs) || dbAbs;
+    if (!fs.existsSync(dbAbs)) {
+        issues.push({
+            path: relDisplay,
+            reason: "sqlite-planning-db-missing (tasks.persistenceBackend is sqlite; run migrate-task-persistence json-to-sqlite or fix tasks.sqliteDatabaseRelativePath)"
+        });
+        return issues;
+    }
+    let db;
+    try {
+        db = new Database(dbAbs, { readonly: true });
+    }
+    catch (err) {
+        issues.push({
+            path: relDisplay,
+            reason: `sqlite-open-failed: ${err.message}`
+        });
+        return issues;
+    }
+    try {
+        const row = db
+            .prepare("SELECT task_store_json, wishlist_store_json FROM workspace_planning_state WHERE id = 1")
+            .get();
+        if (row) {
+            try {
+                const taskDoc = JSON.parse(row.task_store_json);
+                if (taskDoc.schemaVersion !== 1) {
+                    issues.push({
+                        path: relDisplay,
+                        reason: `sqlite-task_store_json: unsupported schemaVersion (expected 1, got ${taskDoc.schemaVersion})`
+                    });
+                }
+            }
+            catch {
+                issues.push({ path: relDisplay, reason: "sqlite-task_store_json: invalid JSON" });
+            }
+            try {
+                const wishDoc = JSON.parse(row.wishlist_store_json);
+                if (wishDoc.schemaVersion !== 1) {
+                    issues.push({
+                        path: relDisplay,
+                        reason: `sqlite-wishlist_store_json: unsupported schemaVersion (expected 1, got ${wishDoc.schemaVersion})`
+                    });
+                }
+            }
+            catch {
+                issues.push({ path: relDisplay, reason: "sqlite-wishlist_store_json: invalid JSON" });
+            }
+        }
+    }
+    catch (err) {
+        issues.push({
+            path: relDisplay,
+            reason: `sqlite-schema-invalid: ${err.message}`
+        });
+    }
+    finally {
+        db.close();
+    }
+    return issues;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workflow-cannon/workspace-kit",
-  "version": "0.16.0",
+  "version": "0.16.1",
   "private": false,
   "packageManager": "pnpm@10.0.0",
   "license": "MIT",