@workflow-cannon/workspace-kit 0.13.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

@@ -1,8 +1,11 @@
 import type { WorkflowModule } from "../../contracts/module-contract.js";
-export type { TaskEntity, TaskStatus, TaskPriority, TaskStoreDocument, TransitionEvidence, TransitionGuard, TransitionContext, GuardResult, TaskEngineError as TaskEngineErrorType, TaskEngineErrorCode, TaskAdapter, TaskAdapterCapability, NextActionSuggestion, BlockingAnalysisEntry } from "./types.js";
+export type { TaskEntity, TaskStatus, TaskPriority, TaskStoreDocument, TransitionEvidence, TransitionGuard, TransitionContext, GuardResult, TaskEngineError as TaskEngineErrorType, TaskEngineErrorCode, TaskAdapter, TaskAdapterCapability, NextActionSuggestion, BlockingAnalysisEntry, TaskMutationEvidence, TaskMutationType } from "./types.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 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

@@ -1,14 +1,19 @@
+import crypto from "node:crypto";
 import { maybeSpawnTranscriptHookAfterCompletion } from "../../core/transcript-completion-hook.js";
 import { TaskStore } from "./store.js";
 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)) {
@@ -17,6 +22,107 @@ 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",
+    "type",
+    "priority",
+    "dependsOn",
+    "unblocks",
+    "phase",
+    "metadata",
+    "ownership",
+    "approach",
+    "technicalScope",
+    "acceptanceCriteria"
+]);
+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)}`,
+        mutationType,
+        taskId,
+        timestamp: nowIso(),
+        actor,
+        details
+    };
+}
 export const taskEngineModule = {
     registration: {
         id: "task-engine",
@@ -43,6 +149,81 @@ export const taskEngineModule = {
                     file: "run-transition.md",
                     description: "Execute a validated task status transition."
                 },
+                {
+                    name: "create-task",
+                    file: "create-task.md",
+                    description: "Create a new task through validated task-engine persistence."
+                },
+                {
+                    name: "update-task",
+                    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",
+                    description: "Archive a task without destructive deletion."
+                },
+                {
+                    name: "add-dependency",
+                    file: "add-dependency.md",
+                    description: "Add a dependency edge between tasks with cycle checks."
+                },
+                {
+                    name: "remove-dependency",
+                    file: "remove-dependency.md",
+                    description: "Remove a dependency edge between tasks."
+                },
+                {
+                    name: "get-dependency-graph",
+                    file: "get-dependency-graph.md",
+                    description: "Get dependency graph data for one task or the full store."
+                },
+                {
+                    name: "get-task-history",
+                    file: "get-task-history.md",
+                    description: "Get transition and mutation history for a task."
+                },
+                {
+                    name: "get-recent-task-activity",
+                    file: "get-recent-task-activity.md",
+                    description: "List recent transition and mutation activity across tasks."
+                },
+                {
+                    name: "get-task-summary",
+                    file: "get-task-summary.md",
+                    description: "Get aggregate task-state summary for active tasks."
+                },
+                {
+                    name: "get-blocked-summary",
+                    file: "get-blocked-summary.md",
+                    description: "Get blocked-task dependency summary for active tasks."
+                },
+                {
+                    name: "create-task-from-plan",
+                    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",
@@ -53,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",
@@ -129,6 +315,123 @@ export const taskEngineModule = {
                 };
             }
         }
+        if (command.name === "create-task" || command.name === "create-task-from-plan") {
+            const actor = typeof args.actor === "string"
+                ? args.actor
+                : ctx.resolvedActor !== undefined
+                    ? ctx.resolvedActor
+                    : undefined;
+            const id = typeof args.id === "string" && args.id.trim().length > 0 ? args.id.trim() : undefined;
+            const title = typeof args.title === "string" && args.title.trim().length > 0 ? args.title.trim() : undefined;
+            const type = typeof args.type === "string" && args.type.trim().length > 0 ? args.type.trim() : "workspace-kit";
+            const status = typeof args.status === "string" ? args.status : "proposed";
+            const priority = typeof args.priority === "string" && ["P1", "P2", "P3"].includes(args.priority)
+                ? args.priority
+                : undefined;
+            if (!id || !title || !TASK_ID_RE.test(id) || !["proposed", "ready"].includes(status)) {
+                return {
+                    ok: false,
+                    code: "invalid-task-schema",
+                    message: "create-task requires id/title, id format T<number>, and status of proposed or ready"
+                };
+            }
+            if (store.getTask(id)) {
+                return { ok: false, code: "duplicate-task-id", message: `Task '${id}' already exists` };
+            }
+            const timestamp = nowIso();
+            const task = {
+                id,
+                title,
+                type,
+                status: status,
+                createdAt: timestamp,
+                updatedAt: timestamp,
+                priority,
+                dependsOn: Array.isArray(args.dependsOn) ? args.dependsOn.filter((x) => typeof x === "string") : undefined,
+                unblocks: Array.isArray(args.unblocks) ? args.unblocks.filter((x) => typeof x === "string") : undefined,
+                phase: typeof args.phase === "string" ? args.phase : undefined,
+                metadata: typeof args.metadata === "object" && args.metadata !== null ? args.metadata : undefined,
+                ownership: typeof args.ownership === "string" ? args.ownership : undefined,
+                approach: typeof args.approach === "string" ? args.approach : undefined,
+                technicalScope: Array.isArray(args.technicalScope) ? args.technicalScope.filter((x) => typeof x === "string") : undefined,
+                acceptanceCriteria: Array.isArray(args.acceptanceCriteria) ? args.acceptanceCriteria.filter((x) => typeof x === "string") : undefined
+            };
+            store.addTask(task);
+            if (command.name === "create-task-from-plan") {
+                const planRef = typeof args.planRef === "string" && args.planRef.trim().length > 0 ? args.planRef.trim() : undefined;
+                if (!planRef) {
+                    return {
+                        ok: false,
+                        code: "invalid-task-schema",
+                        message: "create-task-from-plan requires 'planRef'"
+                    };
+                }
+                task.metadata = { ...(task.metadata ?? {}), planRef };
+                store.updateTask(task);
+            }
+            const evidenceType = command.name === "create-task-from-plan" ? "create-task-from-plan" : "create-task";
+            store.addMutationEvidence(mutationEvidence(evidenceType, id, actor, {
+                initialStatus: task.status,
+                source: command.name
+            }));
+            await store.save();
+            return {
+                ok: true,
+                code: "task-created",
+                message: `Created task '${id}'`,
+                data: { task }
+            };
+        }
+        if (command.name === "update-task") {
+            const taskId = typeof args.taskId === "string" ? args.taskId : undefined;
+            const updates = typeof args.updates === "object" && args.updates !== null ? args.updates : undefined;
+            const actor = typeof args.actor === "string"
+                ? args.actor
+                : ctx.resolvedActor !== undefined
+                    ? ctx.resolvedActor
+                    : undefined;
+            if (!taskId || !updates) {
+                return { ok: false, code: "invalid-task-schema", message: "update-task requires taskId and updates object" };
+            }
+            const task = store.getTask(taskId);
+            if (!task) {
+                return { ok: false, code: "task-not-found", message: `Task '${taskId}' not found` };
+            }
+            const invalidKeys = Object.keys(updates).filter((key) => !MUTABLE_TASK_FIELDS.has(key));
+            if (invalidKeys.length > 0) {
+                return {
+                    ok: false,
+                    code: "invalid-task-update",
+                    message: `update-task cannot mutate immutable fields: ${invalidKeys.join(", ")}`
+                };
+            }
+            const updatedTask = { ...task, ...updates, updatedAt: nowIso() };
+            store.updateTask(updatedTask);
+            store.addMutationEvidence(mutationEvidence("update-task", taskId, actor, { updatedFields: Object.keys(updates) }));
+            await store.save();
+            return { ok: true, code: "task-updated", message: `Updated task '${taskId}'`, data: { task: updatedTask } };
+        }
+        if (command.name === "archive-task") {
+            const taskId = typeof args.taskId === "string" ? args.taskId : undefined;
+            const actor = typeof args.actor === "string"
+                ? args.actor
+                : ctx.resolvedActor !== undefined
+                    ? ctx.resolvedActor
+                    : undefined;
+            if (!taskId) {
+                return { ok: false, code: "invalid-task-schema", message: "archive-task requires taskId" };
+            }
+            const task = store.getTask(taskId);
+            if (!task) {
+                return { ok: false, code: "task-not-found", message: `Task '${taskId}' not found` };
+            }
+            const archivedAt = nowIso();
+            const updatedTask = { ...task, archived: true, archivedAt, updatedAt: archivedAt };
+            store.updateTask(updatedTask);
+            store.addMutationEvidence(mutationEvidence("archive-task", taskId, actor));
+            await store.save();
+            return { ok: true, code: "task-archived", message: `Archived task '${taskId}'`, data: { task: updatedTask } };
+        }
         if (command.name === "get-task") {
             const taskId = typeof args.taskId === "string" ? args.taskId : undefined;
             if (!taskId) {
@@ -165,8 +468,95 @@ export const taskEngineModule = {
                 data: { task, recentTransitions, allowedActions }
             };
         }
+        if (command.name === "add-dependency" || command.name === "remove-dependency") {
+            const taskId = typeof args.taskId === "string" ? args.taskId : undefined;
+            const dependencyTaskId = typeof args.dependencyTaskId === "string" ? args.dependencyTaskId : undefined;
+            const actor = typeof args.actor === "string"
+                ? args.actor
+                : ctx.resolvedActor !== undefined
+                    ? ctx.resolvedActor
+                    : undefined;
+            if (!taskId || !dependencyTaskId) {
+                return {
+                    ok: false,
+                    code: "invalid-task-schema",
+                    message: `${command.name} requires taskId and dependencyTaskId`
+                };
+            }
+            if (taskId === dependencyTaskId) {
+                return { ok: false, code: "dependency-cycle", message: "Task cannot depend on itself" };
+            }
+            const task = store.getTask(taskId);
+            const dep = store.getTask(dependencyTaskId);
+            if (!task || !dep) {
+                return { ok: false, code: "task-not-found", message: "taskId or dependencyTaskId not found" };
+            }
+            const deps = new Set(task.dependsOn ?? []);
+            if (command.name === "add-dependency") {
+                if (deps.has(dependencyTaskId)) {
+                    return { ok: false, code: "duplicate-dependency", message: "Dependency already exists" };
+                }
+                deps.add(dependencyTaskId);
+            }
+            else {
+                deps.delete(dependencyTaskId);
+            }
+            const updatedTask = { ...task, dependsOn: [...deps], updatedAt: nowIso() };
+            store.updateTask(updatedTask);
+            const mutationType = command.name === "add-dependency" ? "add-dependency" : "remove-dependency";
+            store.addMutationEvidence(mutationEvidence(mutationType, taskId, actor, { dependencyTaskId }));
+            await store.save();
+            return {
+                ok: true,
+                code: command.name === "add-dependency" ? "dependency-added" : "dependency-removed",
+                message: `${command.name} applied for '${taskId}'`,
+                data: { task: updatedTask }
+            };
+        }
+        if (command.name === "get-dependency-graph") {
+            const taskId = typeof args.taskId === "string" ? args.taskId : undefined;
+            const tasks = store.getActiveTasks();
+            const nodes = tasks.map((task) => ({ id: task.id, status: task.status }));
+            const edges = tasks.flatMap((task) => (task.dependsOn ?? []).map((depId) => ({ from: task.id, to: depId })));
+            if (!taskId) {
+                return { ok: true, code: "dependency-graph", data: { nodes, edges } };
+            }
+            const task = tasks.find((candidate) => candidate.id === taskId);
+            if (!task) {
+                return { ok: false, code: "task-not-found", message: `Task '${taskId}' not found` };
+            }
+            return {
+                ok: true,
+                code: "dependency-graph",
+                data: {
+                    taskId,
+                    dependsOn: task.dependsOn ?? [],
+                    directDependents: tasks.filter((candidate) => (candidate.dependsOn ?? []).includes(taskId)).map((x) => x.id),
+                    nodes,
+                    edges
+                }
+            };
+        }
+        if (command.name === "get-task-history" || command.name === "get-recent-task-activity") {
+            const limitRaw = args.limit;
+            const limit = typeof limitRaw === "number" && Number.isFinite(limitRaw) && limitRaw > 0
+                ? Math.min(Math.floor(limitRaw), 500)
+                : 50;
+            const taskId = typeof args.taskId === "string" ? args.taskId : undefined;
+            const transitions = store.getTransitionLog().map((entry) => ({ kind: "transition", ...entry }));
+            const mutations = store.getMutationLog().map((entry) => ({ kind: "mutation", ...entry }));
+            const merged = [...transitions, ...mutations]
+                .filter((entry) => (taskId ? entry.taskId === taskId : true))
+                .sort((a, b) => (a.timestamp < b.timestamp ? 1 : -1))
+                .slice(0, limit);
+            return {
+                ok: true,
+                code: command.name === "get-task-history" ? "task-history" : "recent-task-activity",
+                data: { taskId: taskId ?? null, items: merged, count: merged.length }
+            };
+        }
         if (command.name === "dashboard-summary") {
-            const tasks = store.getAllTasks();
+            const tasks = store.getActiveTasks();
             const suggestion = getNextActions(tasks);
             const workspaceStatus = await readWorkspaceStatusSnapshot(ctx.workspacePath);
             const readyTop = suggestion.readyQueue.slice(0, 15).map((t) => ({
@@ -176,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(),
@@ -183,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
@@ -208,7 +613,8 @@ export const taskEngineModule = {
         if (command.name === "list-tasks") {
             const statusFilter = typeof args.status === "string" ? args.status : undefined;
             const phaseFilter = typeof args.phase === "string" ? args.phase : undefined;
-            let tasks = store.getAllTasks();
+            const includeArchived = args.includeArchived === true;
+            let tasks = includeArchived ? store.getAllTasks() : store.getActiveTasks();
             if (statusFilter) {
                 tasks = tasks.filter((t) => t.status === statusFilter);
             }
@@ -219,11 +625,11 @@ 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") {
-            const tasks = store.getAllTasks();
+            const tasks = store.getActiveTasks();
             const ready = tasks
                 .filter((t) => t.status === "ready")
                 .sort((a, b) => {
@@ -235,11 +641,11 @@ 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") {
-            const tasks = store.getAllTasks();
+            const tasks = store.getActiveTasks();
             const suggestion = getNextActions(tasks);
             return {
                 ok: true,
@@ -247,7 +653,232 @@ 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") {
+            const tasks = store.getActiveTasks();
+            const suggestion = getNextActions(tasks);
+            return {
+                ok: true,
+                code: "task-summary",
+                data: {
+                    scope: "tasks-only",
+                    stateSummary: suggestion.stateSummary,
+                    readyQueueCount: suggestion.readyQueue.length,
+                    suggestedNext: suggestion.suggestedNext
+                        ? {
+                            id: suggestion.suggestedNext.id,
+                            title: suggestion.suggestedNext.title,
+                            priority: suggestion.suggestedNext.priority ?? null
+                        }
+                        : null
+                }
+            };
+        }
+        if (command.name === "get-blocked-summary") {
+            const tasks = store.getActiveTasks();
+            const suggestion = getNextActions(tasks);
+            return {
+                ok: true,
+                code: "blocked-summary",
+                data: {
+                    blockedCount: suggestion.blockingAnalysis.length,
+                    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 {

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

@@ -1,4 +1,4 @@
-import type { TaskEntity, TransitionEvidence } from "./types.js";
+import type { TaskEntity, TaskMutationEvidence, TransitionEvidence } from "./types.js";
 export declare class TaskStore {
     private document;
     private readonly filePath;
@@ -6,11 +6,14 @@ export declare class TaskStore {
     load(): Promise<void>;
     save(): Promise<void>;
     getAllTasks(): TaskEntity[];
+    getActiveTasks(): TaskEntity[];
     getTask(id: string): TaskEntity | undefined;
     addTask(task: TaskEntity): void;
     updateTask(task: TaskEntity): void;
     addEvidence(evidence: TransitionEvidence): void;
+    addMutationEvidence(evidence: TaskMutationEvidence): void;
     getTransitionLog(): TransitionEvidence[];
+    getMutationLog(): TaskMutationEvidence[];
     replaceAllTasks(tasks: TaskEntity[]): void;
     getFilePath(): string;
     getLastUpdated(): string;

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

@@ -8,6 +8,7 @@ function emptyStore() {
         schemaVersion: 1,
         tasks: [],
         transitionLog: [],
+        mutationLog: [],
         lastUpdated: new Date().toISOString()
     };
 }
@@ -26,6 +27,9 @@ export class TaskStore {
                 throw new TaskEngineError("storage-read-error", `Unsupported schema version: ${parsed.schemaVersion}`);
             }
             this.document = parsed;
+            if (!Array.isArray(this.document.mutationLog)) {
+                this.document.mutationLog = [];
+            }
         }
         catch (err) {
             if (err.code === "ENOENT") {
@@ -57,6 +61,9 @@ export class TaskStore {
     getAllTasks() {
         return [...this.document.tasks];
     }
+    getActiveTasks() {
+        return this.document.tasks.filter((task) => !task.archived).map((task) => ({ ...task }));
+    }
     getTask(id) {
         return this.document.tasks.find((t) => t.id === id);
     }
@@ -76,9 +83,18 @@ export class TaskStore {
     addEvidence(evidence) {
         this.document.transitionLog.push(evidence);
     }
+    addMutationEvidence(evidence) {
+        if (!Array.isArray(this.document.mutationLog)) {
+            this.document.mutationLog = [];
+        }
+        this.document.mutationLog.push(evidence);
+    }
     getTransitionLog() {
         return [...this.document.transitionLog];
     }
+    getMutationLog() {
+        return [...(this.document.mutationLog ?? [])];
+    }
     replaceAllTasks(tasks) {
         this.document.tasks = tasks.map((t) => ({ ...t }));
     }

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

@@ -7,6 +7,8 @@ export type TaskEntity = {
     title: string;
     createdAt: string;
     updatedAt: string;
+    archived?: boolean;
+    archivedAt?: string;
     priority?: TaskPriority;
     dependsOn?: string[];
     unblocks?: string[];
@@ -47,13 +49,23 @@ export type TaskStoreDocument = {
     schemaVersion: 1;
     tasks: TaskEntity[];
     transitionLog: TransitionEvidence[];
+    mutationLog?: TaskMutationEvidence[];
     lastUpdated: string;
 };
+export type TaskMutationType = "create-task" | "update-task" | "archive-task" | "add-dependency" | "remove-dependency" | "create-task-from-plan";
+export type TaskMutationEvidence = {
+    mutationId: string;
+    mutationType: TaskMutationType;
+    taskId: string;
+    timestamp: string;
+    actor?: string;
+    details?: Record<string, unknown>;
+};
 export type TaskEngineError = {
     code: TaskEngineErrorCode;
     message: string;
 };
-export type TaskEngineErrorCode = "invalid-transition" | "guard-rejected" | "dependency-unsatisfied" | "task-not-found" | "duplicate-task-id" | "invalid-task-schema" | "storage-read-error" | "storage-write-error" | "invalid-adapter" | "import-parse-error";
+export type TaskEngineErrorCode = "invalid-transition" | "guard-rejected" | "dependency-unsatisfied" | "task-not-found" | "duplicate-task-id" | "invalid-task-schema" | "invalid-task-update" | "invalid-task-id-format" | "task-archived" | "dependency-cycle" | "duplicate-dependency" | "storage-read-error" | "storage-write-error" | "invalid-adapter" | "import-parse-error";
 export type TaskAdapter = {
     name: string;
     supports: () => TaskAdapterCapability[];

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.13.0",
+  "version": "0.15.0",
   "private": false,
   "packageManager": "pnpm@10.0.0",
   "license": "MIT",
@@ -36,7 +36,9 @@
     "pre-release-transcript-hook": "pnpm run build && node scripts/pre-release-transcript-hook.mjs",
     "transcript:sync": "node scripts/run-transcript-cli.mjs sync-transcripts",
     "transcript:ingest": "node scripts/run-transcript-cli.mjs ingest-transcripts",
-    "ext:compile": "cd extensions/cursor-workflow-cannon && npm run compile"
+    "ext:compile": "cd extensions/cursor-workflow-cannon && npm run compile",
+    "ui:prepare": "pnpm run build && pnpm run ext:compile",
+    "ui:watch": "cd extensions/cursor-workflow-cannon && npm run watch"
   },
   "devDependencies": {
     "@types/node": "^25.5.0",