@workflow-cannon/workspace-kit 0.14.0 → 0.15.0

package/dist/modules/index.d.ts

@@ -7,3 +7,5 @@ export { workspaceConfigModule } from "./workspace-config/index.js";
 export { planningModule } from "./planning/index.js";
 export { taskEngineModule, TaskStore, TransitionService, TaskEngineError, TransitionValidator, isTransitionAllowed, getTransitionAction, resolveTargetState, getAllowedTransitionsFrom, stateValidityGuard, dependencyCheckGuard, getNextActions } from "./task-engine/index.js";
 export type { TaskEntity, TaskStatus, TaskPriority, TaskStoreDocument, TransitionEvidence, TransitionGuard, TransitionContext, GuardResult, TaskEngineErrorCode, TaskAdapter, TaskAdapterCapability, NextActionSuggestion, BlockingAnalysisEntry } from "./task-engine/index.js";
+export type { WishlistItem, WishlistStatus, WishlistStoreDocument } from "./task-engine/index.js";
+export { WishlistStore, validateWishlistIntakePayload, validateWishlistUpdatePayload, buildWishlistItemFromIntake, WISHLIST_ID_RE } from "./task-engine/index.js";

package/dist/modules/index.js

@@ -5,3 +5,4 @@ export { computeHeuristicConfidence, HEURISTIC_1_ADMISSION_THRESHOLD, shouldAdmi
 export { workspaceConfigModule } from "./workspace-config/index.js";
 export { planningModule } from "./planning/index.js";
 export { taskEngineModule, TaskStore, TransitionService, TaskEngineError, TransitionValidator, isTransitionAllowed, getTransitionAction, resolveTargetState, getAllowedTransitionsFrom, stateValidityGuard, dependencyCheckGuard, getNextActions } from "./task-engine/index.js";
+export { WishlistStore, validateWishlistIntakePayload, validateWishlistUpdatePayload, buildWishlistItemFromIntake, WISHLIST_ID_RE } from "./task-engine/index.js";

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

@@ -5,4 +5,7 @@ export { TransitionService } from "./service.js";
 export { TaskEngineError, TransitionValidator, isTransitionAllowed, getTransitionAction, resolveTargetState, getAllowedTransitionsFrom, stateValidityGuard, dependencyCheckGuard } from "./transitions.js";
 export { getNextActions } from "./suggestions.js";
 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 declare const taskEngineModule: WorkflowModule;

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

@@ -5,11 +5,15 @@ import { TransitionService } from "./service.js";
 import { TaskEngineError, getAllowedTransitionsFrom } from "./transitions.js";
 import { getNextActions } from "./suggestions.js";
 import { readWorkspaceStatusSnapshot } from "./dashboard-status.js";
+import { WishlistStore } from "./wishlist-store.js";
+import { buildWishlistItemFromIntake, validateWishlistIntakePayload, validateWishlistUpdatePayload, WISHLIST_ID_RE } from "./wishlist-validation.js";
 export { TaskStore } from "./store.js";
 export { TransitionService } from "./service.js";
 export { TaskEngineError, TransitionValidator, isTransitionAllowed, getTransitionAction, resolveTargetState, getAllowedTransitionsFrom, stateValidityGuard, dependencyCheckGuard } from "./transitions.js";
 export { getNextActions } from "./suggestions.js";
 export { readWorkspaceStatusSnapshot } from "./dashboard-status.js";
+export { WishlistStore } from "./wishlist-store.js";
+export { validateWishlistIntakePayload, validateWishlistUpdatePayload, buildWishlistItemFromIntake, WISHLIST_ID_RE } from "./wishlist-validation.js";
 function taskStorePath(ctx) {
     const tasks = ctx.effectiveConfig?.tasks;
     if (!tasks || typeof tasks !== "object" || Array.isArray(tasks)) {
@@ -18,6 +22,14 @@ function taskStorePath(ctx) {
     const p = tasks.storeRelativePath;
     return typeof p === "string" && p.trim().length > 0 ? p.trim() : undefined;
 }
+function wishlistStorePath(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;
+}
 const TASK_ID_RE = /^T\d+$/;
 const MUTABLE_TASK_FIELDS = new Set([
     "title",
@@ -35,6 +47,72 @@ const MUTABLE_TASK_FIELDS = new Set([
 function nowIso() {
     return new Date().toISOString();
 }
+function parseConversionDecomposition(raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        return { ok: false, message: "convert-wishlist requires 'decomposition' object" };
+    }
+    const o = raw;
+    const rationale = typeof o.rationale === "string" ? o.rationale.trim() : "";
+    const boundaries = typeof o.boundaries === "string" ? o.boundaries.trim() : "";
+    const dependencyIntent = typeof o.dependencyIntent === "string" ? o.dependencyIntent.trim() : "";
+    if (!rationale || !boundaries || !dependencyIntent) {
+        return {
+            ok: false,
+            message: "decomposition requires non-empty rationale, boundaries, and dependencyIntent"
+        };
+    }
+    return { ok: true, value: { rationale, boundaries, dependencyIntent } };
+}
+function buildTaskFromConversionPayload(row, timestamp) {
+    const id = typeof row.id === "string" ? row.id.trim() : "";
+    if (!TASK_ID_RE.test(id)) {
+        return { ok: false, message: "Each converted task requires 'id' matching T<number>" };
+    }
+    const title = typeof row.title === "string" ? row.title.trim() : "";
+    if (!title) {
+        return { ok: false, message: `Task '${id}' requires non-empty title` };
+    }
+    const phase = typeof row.phase === "string" ? row.phase.trim() : "";
+    if (!phase) {
+        return { ok: false, message: `Task '${id}' requires 'phase' for workable tasks` };
+    }
+    const type = typeof row.type === "string" && row.type.trim() ? row.type.trim() : "workspace-kit";
+    const priority = typeof row.priority === "string" && ["P1", "P2", "P3"].includes(row.priority)
+        ? row.priority
+        : undefined;
+    const approach = typeof row.approach === "string" ? row.approach.trim() : "";
+    if (!approach) {
+        return { ok: false, message: `Task '${id}' requires 'approach'` };
+    }
+    const technicalScope = Array.isArray(row.technicalScope)
+        ? row.technicalScope.filter((x) => typeof x === "string")
+        : [];
+    const acceptanceCriteria = Array.isArray(row.acceptanceCriteria)
+        ? row.acceptanceCriteria.filter((x) => typeof x === "string")
+        : [];
+    if (technicalScope.length === 0) {
+        return { ok: false, message: `Task '${id}' requires non-empty technicalScope array` };
+    }
+    if (acceptanceCriteria.length === 0) {
+        return { ok: false, message: `Task '${id}' requires non-empty acceptanceCriteria array` };
+    }
+    const task = {
+        id,
+        title,
+        type,
+        status: "proposed",
+        createdAt: timestamp,
+        updatedAt: timestamp,
+        priority,
+        dependsOn: Array.isArray(row.dependsOn) ? row.dependsOn.filter((x) => typeof x === "string") : undefined,
+        unblocks: Array.isArray(row.unblocks) ? row.unblocks.filter((x) => typeof x === "string") : undefined,
+        phase,
+        approach,
+        technicalScope,
+        acceptanceCriteria
+    };
+    return { ok: true, task };
+}
 function mutationEvidence(mutationType, taskId, actor, details) {
     return {
         mutationId: `${mutationType}-${taskId}-${nowIso()}-${crypto.randomUUID().slice(0, 8)}`,
@@ -81,6 +159,11 @@ export const taskEngineModule = {
                     file: "update-task.md",
                     description: "Update mutable task fields without lifecycle bypass."
                 },
+                {
+                    name: "update-wishlist",
+                    file: "update-wishlist.md",
+                    description: "Update mutable fields on an open Wishlist item."
+                },
                 {
                     name: "archive-task",
                     file: "archive-task.md",
@@ -126,6 +209,21 @@ export const taskEngineModule = {
                     file: "create-task-from-plan.md",
                     description: "Promote planning output into a canonical task."
                 },
+                {
+                    name: "convert-wishlist",
+                    file: "convert-wishlist.md",
+                    description: "Convert a Wishlist item into one or more phased tasks and close the wishlist item."
+                },
+                {
+                    name: "create-wishlist",
+                    file: "create-wishlist.md",
+                    description: "Create a Wishlist ideation item with strict required fields (separate namespace from tasks)."
+                },
+                {
+                    name: "get-wishlist",
+                    file: "get-wishlist.md",
+                    description: "Retrieve a single Wishlist item by ID."
+                },
                 {
                     name: "get-task",
                     file: "get-task.md",
@@ -136,6 +234,11 @@ export const taskEngineModule = {
                     file: "list-tasks.md",
                     description: "List tasks with optional status/phase filters."
                 },
+                {
+                    name: "list-wishlist",
+                    file: "list-wishlist.md",
+                    description: "List Wishlist items (ideation-only; not part of task execution queues)."
+                },
                 {
                     name: "get-ready-queue",
                     file: "get-ready-queue.md",
@@ -463,6 +566,15 @@ export const taskEngineModule = {
                 phase: t.phase ?? null
             }));
             const blockedTop = suggestion.blockingAnalysis.slice(0, 15);
+            const wishlistStore = new WishlistStore(ctx.workspacePath, wishlistStorePath(ctx));
+            try {
+                await wishlistStore.load();
+            }
+            catch {
+                /* wishlist store optional */
+            }
+            const wishlistItems = wishlistStore.getAllItems();
+            const wishlistOpenCount = wishlistItems.filter((i) => i.status === "open").length;
             const data = {
                 schemaVersion: 1,
                 taskStoreLastUpdated: store.getLastUpdated(),
@@ -470,6 +582,12 @@ export const taskEngineModule = {
                 stateSummary: suggestion.stateSummary,
                 readyQueueTop: readyTop,
                 readyQueueCount: suggestion.readyQueue.length,
+                executionPlanningScope: "tasks-only",
+                wishlist: {
+                    schemaVersion: 1,
+                    openCount: wishlistOpenCount,
+                    totalCount: wishlistItems.length
+                },
                 blockedSummary: {
                     count: suggestion.blockingAnalysis.length,
                     top: blockedTop
@@ -507,7 +625,7 @@ export const taskEngineModule = {
                 ok: true,
                 code: "tasks-listed",
                 message: `Found ${tasks.length} tasks`,
-                data: { tasks, count: tasks.length }
+                data: { tasks, count: tasks.length, scope: "tasks-only" }
             };
         }
         if (command.name === "get-ready-queue") {
@@ -523,7 +641,7 @@ export const taskEngineModule = {
                 ok: true,
                 code: "ready-queue-retrieved",
                 message: `${ready.length} tasks in ready queue`,
-                data: { tasks: ready, count: ready.length }
+                data: { tasks: ready, count: ready.length, scope: "tasks-only" }
             };
         }
         if (command.name === "get-next-actions") {
@@ -535,7 +653,7 @@ export const taskEngineModule = {
                 message: suggestion.suggestedNext
                     ? `Suggested next: ${suggestion.suggestedNext.id} — ${suggestion.suggestedNext.title}`
                     : "No tasks in ready queue",
-                data: suggestion
+                data: { ...suggestion, scope: "tasks-only" }
             };
         }
         if (command.name === "get-task-summary") {
@@ -545,6 +663,7 @@ export const taskEngineModule = {
                 ok: true,
                 code: "task-summary",
                 data: {
+                    scope: "tasks-only",
                     stateSummary: suggestion.stateSummary,
                     readyQueueCount: suggestion.readyQueue.length,
                     suggestedNext: suggestion.suggestedNext
@@ -565,10 +684,203 @@ export const taskEngineModule = {
                 code: "blocked-summary",
                 data: {
                     blockedCount: suggestion.blockingAnalysis.length,
-                    blockedItems: suggestion.blockingAnalysis
+                    blockedItems: suggestion.blockingAnalysis,
+                    scope: "tasks-only"
                 }
             };
         }
+        if (command.name === "create-wishlist") {
+            const wishlistStore = new WishlistStore(ctx.workspacePath, wishlistStorePath(ctx));
+            await wishlistStore.load();
+            const raw = args;
+            const v = validateWishlistIntakePayload(raw);
+            if (!v.ok) {
+                return { ok: false, code: "invalid-task-schema", message: v.errors.join(" ") };
+            }
+            const ts = nowIso();
+            const item = buildWishlistItemFromIntake(raw, ts);
+            try {
+                wishlistStore.addItem(item);
+            }
+            catch (err) {
+                if (err instanceof TaskEngineError) {
+                    return { ok: false, code: err.code, message: err.message };
+                }
+                throw err;
+            }
+            await wishlistStore.save();
+            return {
+                ok: true,
+                code: "wishlist-created",
+                message: `Created wishlist '${item.id}'`,
+                data: { item }
+            };
+        }
+        if (command.name === "list-wishlist") {
+            const wishlistStore = new WishlistStore(ctx.workspacePath, wishlistStorePath(ctx));
+            await wishlistStore.load();
+            const statusFilter = typeof args.status === "string" ? args.status : undefined;
+            let items = wishlistStore.getAllItems();
+            if (statusFilter && ["open", "converted", "cancelled"].includes(statusFilter)) {
+                items = items.filter((i) => i.status === statusFilter);
+            }
+            return {
+                ok: true,
+                code: "wishlist-listed",
+                message: `Found ${items.length} wishlist items`,
+                data: { items, count: items.length, scope: "wishlist-only" }
+            };
+        }
+        if (command.name === "get-wishlist") {
+            const wishlistId = typeof args.wishlistId === "string" && args.wishlistId.trim().length > 0
+                ? args.wishlistId.trim()
+                : typeof args.id === "string" && args.id.trim().length > 0
+                    ? args.id.trim()
+                    : "";
+            if (!wishlistId) {
+                return { ok: false, code: "invalid-task-schema", message: "get-wishlist requires 'wishlistId' or 'id'" };
+            }
+            const wishlistStore = new WishlistStore(ctx.workspacePath, wishlistStorePath(ctx));
+            await wishlistStore.load();
+            const item = wishlistStore.getItem(wishlistId);
+            if (!item) {
+                return { ok: false, code: "task-not-found", message: `Wishlist item '${wishlistId}' not found` };
+            }
+            return {
+                ok: true,
+                code: "wishlist-retrieved",
+                data: { item }
+            };
+        }
+        if (command.name === "update-wishlist") {
+            const wishlistId = typeof args.wishlistId === "string" ? args.wishlistId.trim() : "";
+            const updates = typeof args.updates === "object" && args.updates !== null ? args.updates : undefined;
+            if (!wishlistId || !updates) {
+                return { ok: false, code: "invalid-task-schema", message: "update-wishlist requires wishlistId and updates" };
+            }
+            const wishlistStore = new WishlistStore(ctx.workspacePath, wishlistStorePath(ctx));
+            await wishlistStore.load();
+            const existing = wishlistStore.getItem(wishlistId);
+            if (!existing) {
+                return { ok: false, code: "task-not-found", message: `Wishlist item '${wishlistId}' not found` };
+            }
+            if (existing.status !== "open") {
+                return { ok: false, code: "invalid-transition", message: "Only open wishlist items can be updated" };
+            }
+            const uv = validateWishlistUpdatePayload(updates);
+            if (!uv.ok) {
+                return { ok: false, code: "invalid-task-schema", message: uv.errors.join(" ") };
+            }
+            const merged = { ...existing, updatedAt: nowIso() };
+            const mutable = [
+                "title",
+                "problemStatement",
+                "expectedOutcome",
+                "impact",
+                "constraints",
+                "successSignals",
+                "requestor",
+                "evidenceRef"
+            ];
+            for (const key of mutable) {
+                if (key in updates && typeof updates[key] === "string") {
+                    merged[key] = updates[key].trim();
+                }
+            }
+            wishlistStore.updateItem(merged);
+            await wishlistStore.save();
+            return {
+                ok: true,
+                code: "wishlist-updated",
+                message: `Updated wishlist '${wishlistId}'`,
+                data: { item: merged }
+            };
+        }
+        if (command.name === "convert-wishlist") {
+            const wishlistId = typeof args.wishlistId === "string" ? args.wishlistId.trim() : "";
+            if (!wishlistId || !WISHLIST_ID_RE.test(wishlistId)) {
+                return {
+                    ok: false,
+                    code: "invalid-task-schema",
+                    message: "convert-wishlist requires wishlistId matching W<number>"
+                };
+            }
+            const dec = parseConversionDecomposition(args.decomposition);
+            if (!dec.ok) {
+                return { ok: false, code: "invalid-task-schema", message: dec.message };
+            }
+            const tasksRaw = args.tasks;
+            if (!Array.isArray(tasksRaw) || tasksRaw.length === 0) {
+                return {
+                    ok: false,
+                    code: "invalid-task-schema",
+                    message: "convert-wishlist requires non-empty tasks array"
+                };
+            }
+            const wishlistStore = new WishlistStore(ctx.workspacePath, wishlistStorePath(ctx));
+            await wishlistStore.load();
+            const wlItem = wishlistStore.getItem(wishlistId);
+            if (!wlItem) {
+                return { ok: false, code: "task-not-found", message: `Wishlist item '${wishlistId}' not found` };
+            }
+            if (wlItem.status !== "open") {
+                return {
+                    ok: false,
+                    code: "invalid-transition",
+                    message: "Only open wishlist items can be converted"
+                };
+            }
+            const actor = typeof args.actor === "string"
+                ? args.actor
+                : ctx.resolvedActor !== undefined
+                    ? ctx.resolvedActor
+                    : undefined;
+            const timestamp = nowIso();
+            const built = [];
+            for (const row of tasksRaw) {
+                if (!row || typeof row !== "object" || Array.isArray(row)) {
+                    return { ok: false, code: "invalid-task-schema", message: "Each task must be an object" };
+                }
+                const bt = buildTaskFromConversionPayload(row, timestamp);
+                if (!bt.ok) {
+                    return { ok: false, code: "invalid-task-schema", message: bt.message };
+                }
+                if (store.getTask(bt.task.id)) {
+                    return {
+                        ok: false,
+                        code: "duplicate-task-id",
+                        message: `Task '${bt.task.id}' already exists`
+                    };
+                }
+                built.push(bt.task);
+            }
+            for (const t of built) {
+                store.addTask(t);
+                store.addMutationEvidence(mutationEvidence("create-task", t.id, actor, {
+                    initialStatus: t.status,
+                    source: "convert-wishlist",
+                    wishlistId
+                }));
+            }
+            const convertedIds = built.map((t) => t.id);
+            const updatedWishlist = {
+                ...wlItem,
+                status: "converted",
+                updatedAt: timestamp,
+                convertedAt: timestamp,
+                convertedToTaskIds: convertedIds,
+                conversionDecomposition: dec.value
+            };
+            wishlistStore.updateItem(updatedWishlist);
+            await store.save();
+            await wishlistStore.save();
+            return {
+                ok: true,
+                code: "wishlist-converted",
+                message: `Converted wishlist '${wishlistId}' to tasks: ${convertedIds.join(", ")}`,
+                data: { wishlist: updatedWishlist, createdTasks: built }
+            };
+        }
         return {
             ok: false,
             code: "unsupported-command",

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

@@ -0,0 +1,14 @@
+import type { WishlistItem } from "./wishlist-types.js";
+export declare class WishlistStore {
+    private document;
+    private readonly filePath;
+    constructor(workspacePath: string, storeRelativePath?: string);
+    load(): Promise<void>;
+    save(): Promise<void>;
+    getAllItems(): WishlistItem[];
+    getItem(id: string): WishlistItem | undefined;
+    addItem(item: WishlistItem): void;
+    updateItem(item: WishlistItem): void;
+    getFilePath(): string;
+    getLastUpdated(): string;
+}

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

@@ -0,0 +1,86 @@
+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";
+function emptyWishlistDoc() {
+    return {
+        schemaVersion: 1,
+        items: [],
+        lastUpdated: new Date().toISOString()
+    };
+}
+export class WishlistStore {
+    document;
+    filePath;
+    constructor(workspacePath, storeRelativePath) {
+        this.filePath = path.resolve(workspacePath, storeRelativePath ?? DEFAULT_WISHLIST_PATH);
+        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");
+            }
+            this.document = parsed;
+        }
+        catch (err) {
+            if (err.code === "ENOENT") {
+                this.document = emptyWishlistDoc();
+                return;
+            }
+            if (err instanceof TaskEngineError)
+                throw err;
+            throw new TaskEngineError("storage-read-error", `Failed to read wishlist store: ${err.message}`);
+        }
+    }
+    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}`);
+        }
+    }
+    getAllItems() {
+        return [...this.document.items];
+    }
+    getItem(id) {
+        return this.document.items.find((i) => i.id === id);
+    }
+    addItem(item) {
+        if (this.document.items.some((i) => i.id === item.id)) {
+            throw new TaskEngineError("duplicate-task-id", `Wishlist item '${item.id}' already exists`);
+        }
+        this.document.items.push({ ...item });
+    }
+    updateItem(item) {
+        const idx = this.document.items.findIndex((i) => i.id === item.id);
+        if (idx === -1) {
+            throw new TaskEngineError("task-not-found", `Wishlist item '${item.id}' not found`);
+        }
+        this.document.items[idx] = { ...item };
+    }
+    getFilePath() {
+        return this.filePath;
+    }
+    getLastUpdated() {
+        return this.document.lastUpdated;
+    }
+}

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

@@ -0,0 +1,33 @@
+/**
+ * Wishlist items live in a separate namespace from Task Engine tasks (`T###`).
+ * They are ideation-only until converted into canonical tasks via `convert-wishlist`.
+ */
+export type WishlistStatus = "open" | "converted" | "cancelled";
+/** Recorded when a wishlist item is converted into one or more tasks. */
+export type WishlistConversionDecomposition = {
+    rationale: string;
+    boundaries: string;
+    dependencyIntent: string;
+};
+export type WishlistItem = {
+    id: string;
+    status: WishlistStatus;
+    title: string;
+    problemStatement: string;
+    expectedOutcome: string;
+    impact: string;
+    constraints: string;
+    successSignals: string;
+    requestor: string;
+    evidenceRef: string;
+    createdAt: string;
+    updatedAt: string;
+    convertedAt?: string;
+    convertedToTaskIds?: string[];
+    conversionDecomposition?: WishlistConversionDecomposition;
+};
+export type WishlistStoreDocument = {
+    schemaVersion: 1;
+    items: WishlistItem[];
+    lastUpdated: string;
+};

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

@@ -0,0 +1,5 @@
+/**
+ * Wishlist items live in a separate namespace from Task Engine tasks (`T###`).
+ * They are ideation-only until converted into canonical tasks via `convert-wishlist`.
+ */
+export {};

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

@@ -0,0 +1,16 @@
+import type { WishlistItem } from "./wishlist-types.js";
+/** Wishlist identifiers use a dedicated namespace: `W` + digits (e.g. `W1`, `W42`). */
+export declare const WISHLIST_ID_RE: RegExp;
+export type WishlistValidationResult = {
+    ok: true;
+} | {
+    ok: false;
+    errors: string[];
+};
+/**
+ * Validates intake fields for creating or replacing content on an open wishlist item.
+ * Wishlist items never carry a Task Engine `phase`; reject if present.
+ */
+export declare function validateWishlistIntakePayload(args: Record<string, unknown>): WishlistValidationResult;
+export declare function buildWishlistItemFromIntake(args: Record<string, unknown>, timestamp: string): Omit<WishlistItem, "convertedAt" | "convertedToTaskIds" | "conversionDecomposition">;
+export declare function validateWishlistUpdatePayload(updates: Record<string, unknown>): WishlistValidationResult;

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

@@ -0,0 +1,96 @@
+/** Wishlist identifiers use a dedicated namespace: `W` + digits (e.g. `W1`, `W42`). */
+export const WISHLIST_ID_RE = /^W\d+$/;
+const REQUIRED_STRING_FIELDS = [
+    "title",
+    "problemStatement",
+    "expectedOutcome",
+    "impact",
+    "constraints",
+    "successSignals",
+    "requestor",
+    "evidenceRef"
+];
+function nonEmptyString(v, label) {
+    if (typeof v !== "string" || v.trim().length === 0) {
+        return null;
+    }
+    return v.trim();
+}
+/**
+ * Validates intake fields for creating or replacing content on an open wishlist item.
+ * Wishlist items never carry a Task Engine `phase`; reject if present.
+ */
+export function validateWishlistIntakePayload(args) {
+    const errors = [];
+    if ("phase" in args && args.phase !== undefined) {
+        errors.push("Wishlist items must not include 'phase'; only canonical tasks are phased.");
+    }
+    const id = typeof args.id === "string" ? args.id.trim() : "";
+    if (!id) {
+        errors.push("Wishlist 'id' is required.");
+    }
+    else if (!WISHLIST_ID_RE.test(id)) {
+        errors.push(`Wishlist 'id' must match ${WISHLIST_ID_RE.source} (e.g. W1).`);
+    }
+    for (const key of REQUIRED_STRING_FIELDS) {
+        const s = nonEmptyString(args[key], key);
+        if (s === null) {
+            errors.push(`Wishlist '${key}' is required and must be a non-empty string.`);
+        }
+    }
+    if (errors.length > 0) {
+        return { ok: false, errors };
+    }
+    return { ok: true };
+}
+export function buildWishlistItemFromIntake(args, timestamp) {
+    const id = args.id.trim();
+    const item = {
+        id,
+        status: "open",
+        title: args.title.trim(),
+        problemStatement: args.problemStatement.trim(),
+        expectedOutcome: args.expectedOutcome.trim(),
+        impact: args.impact.trim(),
+        constraints: args.constraints.trim(),
+        successSignals: args.successSignals.trim(),
+        requestor: args.requestor.trim(),
+        evidenceRef: args.evidenceRef.trim(),
+        createdAt: timestamp,
+        updatedAt: timestamp
+    };
+    return item;
+}
+export function validateWishlistUpdatePayload(updates) {
+    if ("phase" in updates && updates.phase !== undefined) {
+        return { ok: false, errors: ["Wishlist updates cannot set 'phase'."] };
+    }
+    const errors = [];
+    const allowed = new Set([
+        "title",
+        "problemStatement",
+        "expectedOutcome",
+        "impact",
+        "constraints",
+        "successSignals",
+        "requestor",
+        "evidenceRef"
+    ]);
+    for (const key of Object.keys(updates)) {
+        if (!allowed.has(key)) {
+            errors.push(`Cannot update unknown or immutable wishlist field '${key}'.`);
+        }
+    }
+    for (const key of REQUIRED_STRING_FIELDS) {
+        if (key in updates) {
+            const s = nonEmptyString(updates[key], key);
+            if (s === null) {
+                errors.push(`Wishlist '${key}' must be a non-empty string when provided.`);
+            }
+        }
+    }
+    if (errors.length > 0) {
+        return { ok: false, errors };
+    }
+    return { ok: true };
+}

package/package.json

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