@workflow-cannon/workspace-kit 0.15.0 → 0.16.1

package/README.md

@@ -1,136 +1,85 @@
 AI agents: `./.ai/` is the authoritative source of truth; read all files there before any analysis, planning, or code changes, and follow `./.ai/` over `README.md`, `./docs/`, and conflicting existing code patterns.
 
-# Workflow Cannon
-
-Workflow Cannon is the canonical home of `@workflow-cannon/workspace-kit` and the operational docs that drive its evolution.
-
-It is built for developers using VS Code who want safe, reproducible, package-first workflow automation with clear release evidence.
-
-## Table of Contents
-
-- [What This Repository Is](#what-this-repository-is)
-- [Big-Picture Vision](#big-picture-vision)
-- [Current Status](#current-status)
-- [Goals](#goals)
-- [Package](#package)
-- [Repository Map](#repository-map)
-- [Documentation Index](#documentation-index)
-- [License](#license)
-
-## What This Repository Is
+<div align="center">
+  <img src="title_image.png" alt="Workflow Cannon" width="720" />
+</div>
 
-Workflow Cannon is the source of truth for:
-
-- The `@workflow-cannon/workspace-kit` package
-- Maintainer planning and execution artifacts
-- Consumer validation and release-readiness evidence
-
-Guiding characteristics:
+# Workflow Cannon
 
-- Package-first delivery and verification
-- Deterministic, auditable workflows
-- Safe-by-default operations (validation, traceability, rollback-friendly changes)
+**[`@workflow-cannon/workspace-kit`](https://www.npmjs.com/package/@workflow-cannon/workspace-kit)** — CLI, task engine, and workflow contracts for repos that want deterministic, policy-governed automation with clear evidence.
 
-## Big-Picture Vision
+## Quick start (clone this repo)
 
-Workflow Cannon is evolving from a package and docs repository into a developer workflow platform that can:
+**Needs:** Node.js **22+** (see CI), **pnpm 10** (see `packageManager` in `package.json`).
 
-- model planning, tasks, policy, and execution as first-class, versioned contracts
-- run repeatable workflows with deterministic outcomes and evidence capture
-- continuously improve itself based on observed friction and outcome data
+```bash
+git clone https://github.com/NJLaPrell/workflow-cannon.git
+cd workflow-cannon
+pnpm install
+pnpm run build
+```
 
-The long-term direction in this repository is to close the loop between:
+Verify the kit sees your workspace:
 
-1. **What happened** (transcripts, diffs, run artifacts, diagnostics)
-2. **What should change** (recommendations to templates, rules, process, and config)
-3. **What gets adopted** (human-reviewed approvals, policy checks, safe rollout)
+```bash
+node dist/cli.js doctor
+node dist/cli.js --help
+```
 
-### Enhancement Engine (automatic learning and correction)
+Try **read-only** task-engine queries:
 
-The Improvement/Enhancement Engine is intended to detect weak spots in workflows and rules, then generate high-signal fixes with supporting evidence. Instead of hard-coding static process forever, the system should learn from real usage patterns and propose better defaults.
+```bash
+node dist/cli.js run list-tasks '{}'
+node dist/cli.js run get-next-actions '{}'
+```
 
-In practice, this means:
+**Developing:** after edits, `pnpm run build` then `pnpm test` (or `pnpm run phase5-gates` before larger changes). If `workspace-kit` is not on your `PATH`, use `node dist/cli.js …` from the repo root (same as above).
 
-- detect recurring failure patterns, manual rework, and template drift
-- emit recommendation items with confidence, deduping, and provenance
-- route recommendations through an approval queue (`accept`, `decline`, `accept edited`)
-- apply approved changes through guarded automation (dry-run, diff, rollback-ready)
-- measure post-change outcomes so future recommendations improve over time
+## Quick start (use the package in another project)
 
-This keeps automation adaptive without sacrificing safety, governance, or developer trust.
+```bash
+npm install @workflow-cannon/workspace-kit
+npx workspace-kit --help
+```
 
-## Current Status
+Or with pnpm: `pnpm add @workflow-cannon/workspace-kit` then `pnpm exec workspace-kit --help`.
 
-**Release and phase truth:** see `docs/maintainers/ROADMAP.md` and `docs/maintainers/data/workspace-kit-status.yaml`. **Task queue:** `.workspace-kit/tasks/state.json` (ids and `status` are authoritative for execution).
+## What this repo contains
 
-- **Phases 0–7** are complete through **`v0.9.0`** (see roadmap for slice ids).
-- **Phase 8** ships maintainer/onboarding hardening (`v0.10.0`): policy denial clarity, runbooks, and doc alignment for CLI vs `run` approval.
-- **Phase 9–10** ship agent/onboarding parity (`v0.11.0`): interactive policy opt-in, strict response-template mode, Agent CLI map (`docs/maintainers/AGENT-CLI-MAP.md`), and CLI-first Cursor guidance.
-- **Phase 11** ships architectural review follow-up hardening (`v0.12.0`): policy/session denial edge tests, persistence concurrency semantics, release doc-sweep checklist, and runtime path audit note.
-- **Phase 12** ships Cursor-native thin-client extension delivery (`v0.13.0`): dashboard/tasks/config UI flows, extension test suite, and operator/security docs.
-- **Phase 13** is the active queue: Task Engine lifecycle tightening (`T311+`).
+| Area | What |
+| --- | --- |
+| **CLI** | `workspace-kit` — `doctor`, `config`, `run <module-command>` (see `workspace-kit run` with no args for the list). |
+| **Task engine** | Canonical queue in `.workspace-kit/tasks/state.json`; lifecycle via `run-transition`. Wishlist ideation uses ids `W###` (see [`docs/maintainers/runbooks/wishlist-workflow.md`](docs/maintainers/runbooks/wishlist-workflow.md)). |
+| **Docs** | Maintainer process, roadmap, and changelog under `docs/maintainers/`. |
+| **Cursor extension** (optional) | Thin UI in `extensions/cursor-workflow-cannon/` — build with `pnpm run ui:prepare`. |
 
-Historical note: this file’s milestone list is not the live queue—always check task state for **`ready`** work.
+There is **no** built-in IDE slash command like `/qt` from this package; editor integrations are **your** config (e.g. `.cursor/commands/`), while **`workspace-kit`** is the supported CLI.
 
-## Goals
+## Policy and approvals (read this before mutating state)
 
-- Keep package implementation and release operations centralized here.
-- Preserve independent consumer validation and update cadence.
-- Grow modular capabilities for planning, tasking, configuration, policy, and improvement.
-- Build a human-governed enhancement loop that learns from usage and recommends better workflows/rules.
-- Maintain deterministic and auditable behavior as system complexity increases.
+Sensitive `workspace-kit run` commands require JSON **`policyApproval`** in the third CLI argument. Chat approval is not enough. Env-based approval applies to `init` / `upgrade` / `config`, not the `run` path.
 
-## Package
+- **Human guide:** [`docs/maintainers/POLICY-APPROVAL.md`](docs/maintainers/POLICY-APPROVAL.md)
+- **Copy-paste table:** [`docs/maintainers/AGENT-CLI-MAP.md`](docs/maintainers/AGENT-CLI-MAP.md)
 
-Install:
+## Project status and roadmap
 
-```bash
-npm install @workflow-cannon/workspace-kit
-```
+Release cadence, phase history, and strategic decisions: [`docs/maintainers/ROADMAP.md`](docs/maintainers/ROADMAP.md). **Live execution queue:** `.workspace-kit/tasks/state.json` (`status` and `id` are authoritative — not this README’s milestone bullets).
 
-### How to run the CLI (this repo and consumers)
+Snapshot: [`docs/maintainers/data/workspace-kit-status.yaml`](docs/maintainers/data/workspace-kit-status.yaml).
 
-There is **no** IDE slash command like `/qt` defined by this package unless your own editor config adds one. Supported entrypoints:
+## Where to go next
 
-| Context | Command |
+| Goal | Start here |
 | --- | --- |
-| **Installed package** | `npx @workflow-cannon/workspace-kit --help` or `pnpm exec workspace-kit --help` when the package is a dependency |
-| **Developing this repo** | `pnpm run build` then `node dist/cli.js --help` or `pnpm exec workspace-kit --help` if linked |
-| **Transcript helpers** | `pnpm run transcript:sync` / `pnpm run transcript:ingest` (see maintainer runbooks) |
-
-Mutating commands require policy approval: **`docs/maintainers/POLICY-APPROVAL.md`** (JSON **`policyApproval`** for `workspace-kit run`, env for `config`/`init`/`upgrade`).
-
-## Repository Map
-
-- `README.md` - project entry point
-- `.ai/PRINCIPLES.md` - project goals and decision principles (canonical AI)
-- `docs/maintainers/ROADMAP.md` - roadmap and decision log
-- `.workspace-kit/tasks/state.json` - execution tracking
-- `docs/maintainers/ARCHITECTURE.md` - architecture direction
-- `docs/maintainers/DECISIONS.md` - focused design/decision notes
-- `docs/maintainers/RELEASING.md` - release checklist and validation expectations
-- `.ai/module-build.md` - canonical AI module build guidance
-- `docs/maintainers/` - maintainer process and boundary docs
-- `docs/maintainers/module-build-guide.md` - human-readable module build guidance
-- `docs/adr/` - ADR templates and records
-
-## Documentation Index
-
-- Project goals and decision principles: `.ai/PRINCIPLES.md`
-- Strategy and long-range direction: `docs/maintainers/ROADMAP.md`
-- Active execution tasks: `.workspace-kit/tasks/state.json`
-- Glossary and agent-guidance terms: `docs/maintainers/TERMS.md`
-- Architecture direction: `docs/maintainers/ARCHITECTURE.md`
-- Project decisions: `docs/maintainers/DECISIONS.md`
-- Governance policy surface: `docs/maintainers/GOVERNANCE.md`
-- Release process and gates: `docs/maintainers/RELEASING.md`
-- Policy / approval surfaces: `docs/maintainers/POLICY-APPROVAL.md`
-- Canonical changelog: `docs/maintainers/CHANGELOG.md` (`CHANGELOG.md` at repo root is pointer-only)
-- Canonical AI module build guidance: `.ai/module-build.md`
-- Human module build guide: `docs/maintainers/module-build-guide.md`
-- Security, support, and governance: `docs/maintainers/SECURITY.md`, `docs/maintainers/SUPPORT.md`, `docs/maintainers/GOVERNANCE.md`
-- AI behavior rules and command wrappers: `.cursor/rules/`, `.cursor/commands/`
+| Goals, trade-offs, gates | [`.ai/PRINCIPLES.md`](.ai/PRINCIPLES.md) |
+| Roadmap & versions | [`docs/maintainers/ROADMAP.md`](docs/maintainers/ROADMAP.md) |
+| Changelog | [`docs/maintainers/CHANGELOG.md`](docs/maintainers/CHANGELOG.md) |
+| Release process | [`docs/maintainers/RELEASING.md`](docs/maintainers/RELEASING.md) |
+| Glossary | [`docs/maintainers/TERMS.md`](docs/maintainers/TERMS.md) |
+| Architecture | [`docs/maintainers/ARCHITECTURE.md`](docs/maintainers/ARCHITECTURE.md) |
+| Agent/CLI execution | [`docs/maintainers/AGENTS.md`](docs/maintainers/AGENTS.md) |
 
 ## License
 
-Licensed under MIT. See `LICENSE`.
+MIT. See [`LICENSE`](LICENSE).

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/approvals/review-runtime.js

@@ -1,15 +1,7 @@
 import { appendLineageEvent } from "../../core/lineage-store.js";
-import { TaskStore } from "../task-engine/store.js";
+import { openPlanningStores } from "../task-engine/planning-open.js";
 import { TransitionService } from "../task-engine/service.js";
 import { appendDecisionRecord, computeDecisionFingerprint, readDecisionFingerprints } from "./decisions-store.js";
-function taskStoreRelativePath(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;
-}
 function getEvidenceKey(task) {
     const m = task.metadata;
     const k = m && typeof m.evidenceKey === "string" ? m.evidenceKey : "";
@@ -24,8 +16,8 @@ export async function runReviewItem(ctx, args, actor) {
     if (decision === "accept_edited" && !(typeof args.editedSummary === "string" && args.editedSummary.trim())) {
         return { ok: false, code: "invalid-args", message: "accept_edited requires non-empty editedSummary" };
     }
-    const store = new TaskStore(ctx.workspacePath, taskStoreRelativePath(ctx));
-    await store.load();
+    const planning = await openPlanningStores(ctx);
+    const store = planning.taskStore;
     const task = store.getTask(taskId);
     if (!task) {
         return { ok: false, code: "task-not-found", message: `Task '${taskId}' not found` };

package/dist/modules/improvement/generate-recommendations-runtime.js

@@ -1,17 +1,9 @@
 import { randomUUID } from "node:crypto";
-import { TaskStore } from "../task-engine/store.js";
+import { openPlanningStores } from "../task-engine/planning-open.js";
 import { appendLineageEvent } from "../../core/lineage-store.js";
 import { loadImprovementState, saveImprovementState } from "./improvement-state.js";
 import { ingestAgentTranscripts, ingestConfigMutations, ingestGitDiffBetweenTags, ingestPolicyDenials, ingestTaskTransitionFriction, taskIdForEvidenceKey } from "./ingest.js";
 import { priorityForTier } from "./confidence.js";
-function taskStoreRelativePath(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;
-}
 function hasEvidenceKey(tasks, key) {
     return tasks.some((t) => {
         const m = t.metadata;
@@ -48,8 +40,8 @@ export function getMaxRecommendationCandidatesPerRun(ctx) {
 }
 export async function runGenerateRecommendations(ctx, args) {
     const runId = randomUUID();
-    const store = new TaskStore(ctx.workspacePath, taskStoreRelativePath(ctx));
-    await store.load();
+    const planning = await openPlanningStores(ctx);
+    const store = planning.taskStore;
     const state = await loadImprovementState(ctx.workspacePath);
     const transcriptsRoot = resolveTranscriptArchivePath(ctx, args);
     const fromTag = typeof args.fromTag === "string" ? args.fromTag.trim() : 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/dist/modules/task-engine/index.d.ts

@@ -8,4 +8,6 @@ export { readWorkspaceStatusSnapshot } from "./dashboard-status.js";
 export { WishlistStore } from "./wishlist-store.js";
 export type { WishlistItem, WishlistStatus, WishlistStoreDocument } from "./wishlist-types.js";
 export { validateWishlistIntakePayload, validateWishlistUpdatePayload, buildWishlistItemFromIntake, WISHLIST_ID_RE } from "./wishlist-validation.js";
+export { openPlanningStores } from "./planning-open.js";
+export { getTaskPersistenceBackend, planningSqliteDatabaseRelativePath, planningTaskStoreRelativePath, planningWishlistStoreRelativePath } from "./planning-config.js";
 export declare const taskEngineModule: WorkflowModule;