@pellux/goodvibes-sdk 0.33.20 → 0.33.22

package/dist/platform/knowledge/project-planning/index.d.ts

@@ -2,5 +2,5 @@ export { ProjectPlanningService } from './service.js';
 export type { ProjectPlanningServiceOptions } from './service.js';
 export { PROJECT_PLANNING_CONNECTOR_ID, PROJECT_PLANNING_TAG, projectPlanningCanonicalUri, projectPlanningProjectIdFromPath, projectPlanningSourceId, resolveProjectPlanningSpace, } from './helpers.js';
 export { evaluateProjectPlanningReadiness } from './readiness.js';
-export type { ProjectPlanningAgentAssignment, ProjectPlanningAmbiguity, ProjectPlanningDecision, ProjectPlanningDecisionRecordInput, ProjectPlanningDecisionResult, ProjectPlanningDecisionsResult, ProjectPlanningDecisionStatus, ProjectPlanningDependency, ProjectPlanningEvaluateInput, ProjectPlanningEvaluation, ProjectPlanningGap, ProjectPlanningGapKind, ProjectPlanningGapSeverity, ProjectPlanningGateStatus, ProjectPlanningLanguageArtifact, ProjectPlanningLanguageResult, ProjectPlanningLanguageUpsertInput, ProjectPlanningQuestion, ProjectPlanningQuestionStatus, ProjectPlanningReadiness, ProjectPlanningSpaceInput, ProjectPlanningState, ProjectPlanningStateResult, ProjectPlanningStateUpsertInput, ProjectPlanningStatus, ProjectPlanningTask, ProjectPlanningTaskStatus, ProjectPlanningTerm, ProjectPlanningVerificationGate, } from './types.js';
+export type { ProjectPlanningAgentAssignment, ProjectPlanningAmbiguity, ProjectPlanningDecision, ProjectPlanningDecisionRecordInput, ProjectPlanningDecisionResult, ProjectPlanningDecisionsResult, ProjectPlanningDecisionStatus, ProjectPlanningDependency, ProjectPlanningEvaluateInput, ProjectPlanningEvaluation, ProjectPlanningGap, ProjectPlanningGapKind, ProjectPlanningGapSeverity, ProjectPlanningGateStatus, ProjectPlanningLanguageArtifact, ProjectPlanningLanguageResult, ProjectPlanningLanguageUpsertInput, ProjectPlanningQuestion, ProjectPlanningQuestionStatus, ProjectPlanningReadiness, ProjectPlanningSpaceInput, ProjectPlanningState, ProjectPlanningStateResult, ProjectPlanningStateUpsertInput, ProjectPlanningStatus, ProjectPlanningTask, ProjectPlanningTaskStatus, ProjectPlanningTerm, ProjectPlanningVerificationGate, ProjectWorkPlanArtifact, ProjectWorkPlanClearCompletedInput, ProjectWorkPlanCounts, ProjectWorkPlanMutationResult, ProjectWorkPlanSnapshot, ProjectWorkPlanTask, ProjectWorkPlanTaskCreateInput, ProjectWorkPlanTaskDeleteInput, ProjectWorkPlanTaskGetInput, ProjectWorkPlanTaskListInput, ProjectWorkPlanTaskMutationSource, ProjectWorkPlanTaskReorderInput, ProjectWorkPlanTaskResult, ProjectWorkPlanTaskStatus, ProjectWorkPlanTaskStatusInput, ProjectWorkPlanTaskUpdateInput, } from './types.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/platform/knowledge/project-planning/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/platform/knowledge/project-planning/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AACtD,YAAY,EAAE,6BAA6B,EAAE,MAAM,cAAc,CAAC;AAClE,OAAO,EACL,6BAA6B,EAC7B,oBAAoB,EACpB,2BAA2B,EAC3B,gCAAgC,EAChC,uBAAuB,EACvB,2BAA2B,GAC5B,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,gCAAgC,EAAE,MAAM,gBAAgB,CAAC;AAClE,YAAY,EACV,8BAA8B,EAC9B,wBAAwB,EACxB,uBAAuB,EACvB,kCAAkC,EAClC,6BAA6B,EAC7B,8BAA8B,EAC9B,6BAA6B,EAC7B,yBAAyB,EACzB,4BAA4B,EAC5B,yBAAyB,EACzB,kBAAkB,EAClB,sBAAsB,EACtB,0BAA0B,EAC1B,yBAAyB,EACzB,+BAA+B,EAC/B,6BAA6B,EAC7B,kCAAkC,EAClC,uBAAuB,EACvB,6BAA6B,EAC7B,wBAAwB,EACxB,yBAAyB,EACzB,oBAAoB,EACpB,0BAA0B,EAC1B,+BAA+B,EAC/B,qBAAqB,EACrB,mBAAmB,EACnB,yBAAyB,EACzB,mBAAmB,EACnB,+BAA+B,GAChC,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/platform/knowledge/project-planning/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AACtD,YAAY,EAAE,6BAA6B,EAAE,MAAM,cAAc,CAAC;AAClE,OAAO,EACL,6BAA6B,EAC7B,oBAAoB,EACpB,2BAA2B,EAC3B,gCAAgC,EAChC,uBAAuB,EACvB,2BAA2B,GAC5B,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,gCAAgC,EAAE,MAAM,gBAAgB,CAAC;AAClE,YAAY,EACV,8BAA8B,EAC9B,wBAAwB,EACxB,uBAAuB,EACvB,kCAAkC,EAClC,6BAA6B,EAC7B,8BAA8B,EAC9B,6BAA6B,EAC7B,yBAAyB,EACzB,4BAA4B,EAC5B,yBAAyB,EACzB,kBAAkB,EAClB,sBAAsB,EACtB,0BAA0B,EAC1B,yBAAyB,EACzB,+BAA+B,EAC/B,6BAA6B,EAC7B,kCAAkC,EAClC,uBAAuB,EACvB,6BAA6B,EAC7B,wBAAwB,EACxB,yBAAyB,EACzB,oBAAoB,EACpB,0BAA0B,EAC1B,+BAA+B,EAC/B,qBAAqB,EACrB,mBAAmB,EACnB,yBAAyB,EACzB,mBAAmB,EACnB,+BAA+B,EAC/B,uBAAuB,EACvB,kCAAkC,EAClC,qBAAqB,EACrB,6BAA6B,EAC7B,uBAAuB,EACvB,mBAAmB,EACnB,8BAA8B,EAC9B,8BAA8B,EAC9B,2BAA2B,EAC3B,4BAA4B,EAC5B,iCAAiC,EACjC,+BAA+B,EAC/B,yBAAyB,EACzB,yBAAyB,EACzB,8BAA8B,EAC9B,8BAA8B,GAC/B,MAAM,YAAY,CAAC"}

package/dist/platform/knowledge/project-planning/service.d.ts

@@ -1,12 +1,16 @@
 import { KnowledgeStore } from '../store.js';
-import type { ProjectPlanningDecisionRecordInput, ProjectPlanningDecisionResult, ProjectPlanningDecisionsResult, ProjectPlanningEvaluateInput, ProjectPlanningEvaluation, ProjectPlanningLanguageResult, ProjectPlanningLanguageUpsertInput, ProjectPlanningSpaceInput, ProjectPlanningStateResult, ProjectPlanningStateUpsertInput, ProjectPlanningStatus } from './types.js';
+import type { RuntimeEventBus } from '../../runtime/events/index.js';
+import type { ProjectPlanningDecisionRecordInput, ProjectPlanningDecisionResult, ProjectPlanningDecisionsResult, ProjectPlanningEvaluateInput, ProjectPlanningEvaluation, ProjectPlanningLanguageResult, ProjectPlanningLanguageUpsertInput, ProjectPlanningSpaceInput, ProjectPlanningStateResult, ProjectPlanningStateUpsertInput, ProjectPlanningStatus, ProjectWorkPlanClearCompletedInput, ProjectWorkPlanMutationResult, ProjectWorkPlanSnapshot, ProjectWorkPlanTaskCreateInput, ProjectWorkPlanTaskDeleteInput, ProjectWorkPlanTaskGetInput, ProjectWorkPlanTaskListInput, ProjectWorkPlanTaskReorderInput, ProjectWorkPlanTaskResult, ProjectWorkPlanTaskStatusInput, ProjectWorkPlanTaskUpdateInput } from './types.js';
 export interface ProjectPlanningServiceOptions {
     readonly defaultProjectId?: string | undefined;
+    readonly runtimeBus?: RuntimeEventBus | null | undefined;
 }
 export declare class ProjectPlanningService {
     private readonly store;
     private readonly defaultProjectId;
+    private runtimeBus;
     constructor(store: KnowledgeStore, options?: ProjectPlanningServiceOptions);
+    attachRuntimeBus(runtimeBus: RuntimeEventBus | null | undefined): void;
     status(input?: ProjectPlanningSpaceInput): Promise<ProjectPlanningStatus>;
     getState(input?: ProjectPlanningSpaceInput & {
         readonly planningId?: string | undefined;
@@ -17,9 +21,25 @@ export declare class ProjectPlanningService {
     recordDecision(input: ProjectPlanningDecisionRecordInput): Promise<ProjectPlanningDecisionResult>;
     getLanguage(input?: ProjectPlanningSpaceInput): Promise<ProjectPlanningLanguageResult>;
     upsertLanguage(input: ProjectPlanningLanguageUpsertInput): Promise<ProjectPlanningLanguageResult>;
+    getWorkPlanSnapshot(input?: ProjectWorkPlanTaskListInput): Promise<ProjectWorkPlanSnapshot>;
+    getWorkPlanTask(input: ProjectWorkPlanTaskGetInput): Promise<ProjectWorkPlanTaskResult>;
+    createWorkPlanTask(input: ProjectWorkPlanTaskCreateInput): Promise<ProjectWorkPlanMutationResult>;
+    updateWorkPlanTask(input: ProjectWorkPlanTaskUpdateInput): Promise<ProjectWorkPlanMutationResult>;
+    setWorkPlanTaskStatus(input: ProjectWorkPlanTaskStatusInput): Promise<ProjectWorkPlanMutationResult>;
+    reorderWorkPlanTasks(input: ProjectWorkPlanTaskReorderInput): Promise<ProjectWorkPlanSnapshot>;
+    deleteWorkPlanTask(input: ProjectWorkPlanTaskDeleteInput): Promise<ProjectWorkPlanMutationResult>;
+    clearCompletedWorkPlanTasks(input?: ProjectWorkPlanClearCompletedInput): Promise<ProjectWorkPlanMutationResult>;
     private resolveSpace;
     private sourcesForSpace;
     private getArtifactSource;
+    private getWorkPlanArtifact;
+    private saveWorkPlanArtifact;
+    private syncPlanningStateTasksToWorkPlan;
     private upsertArtifactSource;
+    private emitWorkPlanTaskCreated;
+    private emitWorkPlanTaskUpdated;
+    private emitWorkPlanTaskStatusChanged;
+    private emitWorkPlanTaskDeleted;
+    private emitWorkPlanSnapshotInvalidated;
 }
 //# sourceMappingURL=service.d.ts.map

package/dist/platform/knowledge/project-planning/service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../../src/platform/knowledge/project-planning/service.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAa7C,OAAO,KAAK,EAEV,kCAAkC,EAClC,6BAA6B,EAC7B,8BAA8B,EAC9B,4BAA4B,EAC5B,yBAAyB,EAEzB,6BAA6B,EAC7B,kCAAkC,EAClC,yBAAyB,EAEzB,0BAA0B,EAC1B,+BAA+B,EAC/B,qBAAqB,EACtB,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAChD;AAED,qBAAa,sBAAsB;IAI/B,OAAO,CAAC,QAAQ,CAAC,KAAK;IAHxB,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAS;gBAGvB,KAAK,EAAE,cAAc,EACtC,OAAO,GAAE,6BAAkC;IAKvC,MAAM,CAAC,KAAK,GAAE,yBAA8B,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAyB7E,QAAQ,CAAC,KAAK,GAAE,yBAAyB,GAAG;QAAE,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;KAAO,GAAG,OAAO,CAAC,0BAA0B,CAAC;IAenI,WAAW,CAAC,KAAK,EAAE,+BAA+B,GAAG,OAAO,CAAC,0BAA0B,CAAC;IAgBxF,QAAQ,CAAC,KAAK,GAAE,4BAAiC,GAAG,OAAO,CAAC,yBAAyB,CAAC;IAWtF,aAAa,CAAC,KAAK,GAAE,yBAA8B,GAAG,OAAO,CAAC,8BAA8B,CAAC;IAgB7F,cAAc,CAAC,KAAK,EAAE,kCAAkC,GAAG,OAAO,CAAC,6BAA6B,CAAC;IA2BjG,WAAW,CAAC,KAAK,GAAE,yBAA8B,GAAG,OAAO,CAAC,6BAA6B,CAAC;IAc1F,cAAc,CAAC,KAAK,EAAE,kCAAkC,GAAG,OAAO,CAAC,6BAA6B,CAAC;IA2BvG,OAAO,CAAC,YAAY;IAIpB,OAAO,CAAC,eAAe;IAOvB,OAAO,CAAC,iBAAiB;YASX,oBAAoB;CAyBnC"}
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../../src/platform/knowledge/project-planning/service.ts"],"names":[],"mappings":"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"}

package/dist/platform/knowledge/project-planning/service.js

@@ -1,13 +1,20 @@
+import { randomUUID } from 'node:crypto';
 import { knowledgeSpaceMetadata, normalizeProjectId, } from '../spaces.js';
 import { KnowledgeStore } from '../store.js';
+import { emitWorkPlanSnapshotInvalidated, emitWorkPlanTaskCreated, emitWorkPlanTaskDeleted, emitWorkPlanTaskStatusChanged, emitWorkPlanTaskUpdated, } from '../../runtime/emitters/index.js';
 import { PROJECT_PLANNING_CONNECTOR_ID, PROJECT_PLANNING_TAG, projectPlanningArtifactSummary, projectPlanningCanonicalUri, projectPlanningSourceId, readPlanningMetadataObject, resolveProjectPlanningSpace, stablePlanningId, } from './helpers.js';
 import { evaluateProjectPlanningReadiness } from './readiness.js';
 export class ProjectPlanningService {
     store;
     defaultProjectId;
+    runtimeBus;
     constructor(store, options = {}) {
         this.store = store;
         this.defaultProjectId = normalizeProjectId(options.defaultProjectId ?? 'default');
+        this.runtimeBus = options.runtimeBus ?? null;
+    }
+    attachRuntimeBus(runtimeBus) {
+        this.runtimeBus = runtimeBus ?? null;
     }
     async status(input = {}) {
         await this.store.init();
@@ -22,12 +29,18 @@ export class ProjectPlanningService {
                 states: sources.filter((source) => artifactKind(source) === 'state').length,
                 decisions: sources.filter((source) => artifactKind(source) === 'decision').length,
                 languageArtifacts: sources.filter((source) => artifactKind(source) === 'language').length,
+                workPlans: sources.filter((source) => artifactKind(source) === 'work-plan').length,
+                workPlanTasks: sources
+                    .filter((source) => artifactKind(source) === 'work-plan')
+                    .reduce((count, source) => count + (readWorkPlan(source)?.tasks.length ?? 0), 0),
             },
             capabilities: [
                 'project-scoped-storage',
                 'planning-state-validation',
                 'project-language-artifacts',
                 'decision-records',
+                'durable-work-plan-tasks',
+                'work-plan-transition-events',
                 'agent-task-graph-metadata',
                 'passive-daemon-only',
             ],
@@ -54,6 +67,7 @@ export class ProjectPlanningService {
         const evaluation = evaluateProjectPlanningReadiness(state);
         const normalized = evaluation.state;
         const source = await this.upsertArtifactSource(space, 'state', normalized.id, normalized);
+        await this.syncPlanningStateTasksToWorkPlan(space, normalized);
         return {
             ok: true,
             projectId: space.projectId,
@@ -152,6 +166,205 @@ export class ProjectPlanningService {
             source,
         };
     }
+    async getWorkPlanSnapshot(input = {}) {
+        await this.store.init();
+        const space = this.resolveSpace(input);
+        const workPlan = this.getWorkPlanArtifact(space, normalizeWorkPlanId(input.workPlanId));
+        return snapshotFromWorkPlan(space, workPlan, {
+            status: input.status,
+            parentTaskId: input.parentTaskId,
+            chainId: input.chainId,
+            owner: input.owner,
+            limit: input.limit,
+        });
+    }
+    async getWorkPlanTask(input) {
+        await this.store.init();
+        const snapshot = await this.getWorkPlanSnapshot(input);
+        return {
+            ok: true,
+            projectId: snapshot.projectId,
+            knowledgeSpaceId: snapshot.knowledgeSpaceId,
+            workPlanId: snapshot.workPlanId,
+            task: snapshot.tasks.find((task) => task.taskId === input.taskId) ?? null,
+            snapshot,
+        };
+    }
+    async createWorkPlanTask(input) {
+        await this.store.init();
+        const space = this.resolveSpace(input);
+        const workPlanId = normalizeWorkPlanId(input.workPlanId);
+        const existing = this.getWorkPlanArtifact(space, workPlanId);
+        const now = Date.now();
+        const task = normalizeWorkPlanTask(input.task, {
+            projectId: space.projectId,
+            knowledgeSpaceId: space.knowledgeSpaceId,
+            now,
+            fallbackOrder: nextWorkPlanOrder(existing.tasks),
+        });
+        if (existing.tasks.some((entry) => entry.taskId === task.taskId)) {
+            throw new Error(`Work plan task already exists: ${task.taskId}`);
+        }
+        const workPlan = await this.saveWorkPlanArtifact(space, {
+            ...existing,
+            tasks: sortWorkPlanTasks([...existing.tasks, task]),
+            updatedAt: now,
+        });
+        const snapshot = snapshotFromWorkPlan(space, workPlan);
+        this.emitWorkPlanTaskCreated(snapshot, task);
+        return {
+            ok: true,
+            projectId: space.projectId,
+            knowledgeSpaceId: space.knowledgeSpaceId,
+            workPlanId,
+            task,
+            snapshot,
+        };
+    }
+    async updateWorkPlanTask(input) {
+        await this.store.init();
+        const space = this.resolveSpace(input);
+        const workPlanId = normalizeWorkPlanId(input.workPlanId);
+        const existing = this.getWorkPlanArtifact(space, workPlanId);
+        const previousTask = existing.tasks.find((task) => task.taskId === input.taskId);
+        if (!previousTask)
+            throw new Error(`Work plan task not found: ${input.taskId}`);
+        const now = Date.now();
+        const task = normalizeWorkPlanTask({
+            ...previousTask,
+            ...input.patch,
+            metadata: {
+                ...(previousTask.metadata ?? {}),
+                ...(input.patch.metadata ?? {}),
+            },
+            taskId: previousTask.taskId,
+            createdAt: previousTask.createdAt,
+            updatedAt: now,
+        }, {
+            projectId: space.projectId,
+            knowledgeSpaceId: space.knowledgeSpaceId,
+            now,
+            fallbackOrder: previousTask.order,
+        });
+        const workPlan = await this.saveWorkPlanArtifact(space, {
+            ...existing,
+            tasks: sortWorkPlanTasks(existing.tasks.map((entry) => entry.taskId === input.taskId ? task : entry)),
+            updatedAt: now,
+        });
+        const snapshot = snapshotFromWorkPlan(space, workPlan);
+        this.emitWorkPlanTaskUpdated(snapshot, task, previousTask);
+        if (previousTask.status !== task.status) {
+            this.emitWorkPlanTaskStatusChanged(snapshot, task, previousTask);
+        }
+        return {
+            ok: true,
+            projectId: space.projectId,
+            knowledgeSpaceId: space.knowledgeSpaceId,
+            workPlanId,
+            task,
+            previousTask,
+            snapshot,
+        };
+    }
+    async setWorkPlanTaskStatus(input) {
+        return this.updateWorkPlanTask({
+            projectId: input.projectId,
+            knowledgeSpaceId: input.knowledgeSpaceId,
+            workPlanId: input.workPlanId,
+            taskId: input.taskId,
+            patch: {
+                status: normalizeWorkPlanStatus(input.status),
+                ...(input.source ? { source: input.source } : {}),
+                metadata: {
+                    ...(input.reason ? { statusReason: input.reason } : {}),
+                },
+            },
+        });
+    }
+    async reorderWorkPlanTasks(input) {
+        await this.store.init();
+        const space = this.resolveSpace(input);
+        const workPlanId = normalizeWorkPlanId(input.workPlanId);
+        const existing = this.getWorkPlanArtifact(space, workPlanId);
+        const previousById = new Map(existing.tasks.map((task) => [task.taskId, task]));
+        const orderById = new Map(input.orderedTaskIds.map((taskId, index) => [taskId, index]));
+        for (const taskId of orderById.keys()) {
+            if (!previousById.has(taskId))
+                throw new Error(`Work plan task not found: ${taskId}`);
+        }
+        const now = Date.now();
+        const tasks = sortWorkPlanTasks(existing.tasks.map((task) => ({
+            ...task,
+            order: orderById.get(task.taskId) ?? task.order + input.orderedTaskIds.length,
+            updatedAt: orderById.has(task.taskId) ? now : task.updatedAt,
+        })));
+        const workPlan = await this.saveWorkPlanArtifact(space, {
+            ...existing,
+            tasks,
+            updatedAt: now,
+        });
+        const snapshot = snapshotFromWorkPlan(space, workPlan);
+        for (const task of tasks) {
+            const previousTask = previousById.get(task.taskId);
+            if (previousTask && previousTask.order !== task.order) {
+                this.emitWorkPlanTaskUpdated(snapshot, task, previousTask, true);
+            }
+        }
+        this.emitWorkPlanSnapshotInvalidated(snapshot, 'reordered');
+        return snapshot;
+    }
+    async deleteWorkPlanTask(input) {
+        await this.store.init();
+        const space = this.resolveSpace(input);
+        const workPlanId = normalizeWorkPlanId(input.workPlanId);
+        const existing = this.getWorkPlanArtifact(space, workPlanId);
+        const deletedTask = existing.tasks.find((task) => task.taskId === input.taskId);
+        if (!deletedTask)
+            throw new Error(`Work plan task not found: ${input.taskId}`);
+        const now = Date.now();
+        const workPlan = await this.saveWorkPlanArtifact(space, {
+            ...existing,
+            tasks: existing.tasks.filter((task) => task.taskId !== input.taskId),
+            updatedAt: now,
+        });
+        const snapshot = snapshotFromWorkPlan(space, workPlan);
+        this.emitWorkPlanTaskDeleted(snapshot, deletedTask);
+        return {
+            ok: true,
+            projectId: space.projectId,
+            knowledgeSpaceId: space.knowledgeSpaceId,
+            workPlanId,
+            deletedTask,
+            snapshot,
+        };
+    }
+    async clearCompletedWorkPlanTasks(input = {}) {
+        await this.store.init();
+        const space = this.resolveSpace(input);
+        const workPlanId = normalizeWorkPlanId(input.workPlanId);
+        const existing = this.getWorkPlanArtifact(space, workPlanId);
+        const statuses = new Set(input.statuses?.length ? input.statuses.map(normalizeWorkPlanStatus) : ['done']);
+        const cleared = existing.tasks.filter((task) => statuses.has(task.status));
+        const now = Date.now();
+        const workPlan = await this.saveWorkPlanArtifact(space, {
+            ...existing,
+            tasks: existing.tasks.filter((task) => !statuses.has(task.status)),
+            updatedAt: now,
+        });
+        const snapshot = snapshotFromWorkPlan(space, workPlan);
+        for (const task of cleared) {
+            this.emitWorkPlanTaskDeleted(snapshot, task, true);
+        }
+        this.emitWorkPlanSnapshotInvalidated(snapshot, 'cleared-completed');
+        return {
+            ok: true,
+            projectId: space.projectId,
+            knowledgeSpaceId: space.knowledgeSpaceId,
+            workPlanId,
+            clearedTaskIds: cleared.map((task) => task.taskId),
+            snapshot,
+        };
+    }
     resolveSpace(input = {}) {
         return resolveProjectPlanningSpace(input, this.defaultProjectId);
     }
@@ -165,6 +378,75 @@ export class ProjectPlanningService {
         const sourceId = projectPlanningSourceId(spaceId, kind, id);
         return this.store.getSource(sourceId) ?? this.store.getSourceByCanonicalUri(projectPlanningCanonicalUri(spaceId, kind, id));
     }
+    getWorkPlanArtifact(space, workPlanId) {
+        const source = this.getArtifactSource(space.knowledgeSpaceId, 'work-plan', workPlanId);
+        const value = source?.metadata.value;
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+            return normalizeWorkPlanArtifact(value, space, workPlanId);
+        }
+        const now = Date.now();
+        return {
+            id: workPlanId,
+            projectId: space.projectId,
+            knowledgeSpaceId: space.knowledgeSpaceId,
+            tasks: [],
+            createdAt: now,
+            updatedAt: now,
+        };
+    }
+    async saveWorkPlanArtifact(space, workPlan) {
+        const normalized = normalizeWorkPlanArtifact(workPlan, space, workPlan.id);
+        await this.upsertArtifactSource(space, 'work-plan', normalized.id, normalized);
+        return normalized;
+    }
+    async syncPlanningStateTasksToWorkPlan(space, state) {
+        for (const [index, task] of state.tasks.entries()) {
+            if (!task.title?.trim())
+                continue;
+            const taskId = normalizeWorkPlanTaskId(`planning-${state.id}-${task.id || task.title}`);
+            const workPlanTask = {
+                taskId,
+                title: task.title,
+                notes: task.why,
+                owner: task.recommendedAgent,
+                status: workPlanStatusFromPlanningTask(task),
+                priority: task.needsReview ? 10 : 0,
+                order: index,
+                source: 'planning',
+                tags: [
+                    'planning',
+                    ...(task.needsReview ? ['needs-review'] : []),
+                    ...(task.blockedOnUserInput ? ['blocked-on-user-input'] : []),
+                ],
+                originSurface: 'daemon',
+                metadata: {
+                    planningId: state.id,
+                    planningTaskId: task.id,
+                    dependencies: task.dependencies ?? [],
+                    likelyFiles: task.likelyFiles ?? [],
+                    verification: task.verification ?? [],
+                    canRunConcurrently: task.canRunConcurrently === true,
+                },
+            };
+            try {
+                await this.createWorkPlanTask({
+                    projectId: space.projectId,
+                    knowledgeSpaceId: space.knowledgeSpaceId,
+                    task: workPlanTask,
+                });
+            }
+            catch (error) {
+                if (!(error instanceof Error) || !error.message.includes('already exists'))
+                    throw error;
+                await this.updateWorkPlanTask({
+                    projectId: space.projectId,
+                    knowledgeSpaceId: space.knowledgeSpaceId,
+                    taskId,
+                    patch: workPlanTask,
+                });
+            }
+        }
+    }
     async upsertArtifactSource(space, kind, id, value) {
         const spaceId = space.knowledgeSpaceId;
         return this.store.upsertSource({
@@ -185,6 +467,67 @@ export class ProjectPlanningService {
             }),
         });
     }
+    emitWorkPlanTaskCreated(snapshot, task) {
+        if (!this.runtimeBus)
+            return;
+        emitWorkPlanTaskCreated(this.runtimeBus, workPlanEmitterContext(snapshot), {
+            projectId: snapshot.projectId,
+            knowledgeSpaceId: snapshot.knowledgeSpaceId,
+            workPlanId: snapshot.workPlanId,
+            task,
+        });
+        this.emitWorkPlanSnapshotInvalidated(snapshot, 'task-created');
+    }
+    emitWorkPlanTaskUpdated(snapshot, task, previousTask, skipSnapshotInvalidation = false) {
+        if (!this.runtimeBus)
+            return;
+        emitWorkPlanTaskUpdated(this.runtimeBus, workPlanEmitterContext(snapshot), {
+            projectId: snapshot.projectId,
+            knowledgeSpaceId: snapshot.knowledgeSpaceId,
+            workPlanId: snapshot.workPlanId,
+            task,
+            previousTask,
+        });
+        if (!skipSnapshotInvalidation)
+            this.emitWorkPlanSnapshotInvalidated(snapshot, 'task-updated');
+    }
+    emitWorkPlanTaskStatusChanged(snapshot, task, previousTask) {
+        if (!this.runtimeBus)
+            return;
+        emitWorkPlanTaskStatusChanged(this.runtimeBus, workPlanEmitterContext(snapshot), {
+            projectId: snapshot.projectId,
+            knowledgeSpaceId: snapshot.knowledgeSpaceId,
+            workPlanId: snapshot.workPlanId,
+            taskId: task.taskId,
+            status: task.status,
+            previousStatus: previousTask.status,
+            task,
+        });
+    }
+    emitWorkPlanTaskDeleted(snapshot, task, skipSnapshotInvalidation = false) {
+        if (!this.runtimeBus)
+            return;
+        emitWorkPlanTaskDeleted(this.runtimeBus, workPlanEmitterContext(snapshot), {
+            projectId: snapshot.projectId,
+            knowledgeSpaceId: snapshot.knowledgeSpaceId,
+            workPlanId: snapshot.workPlanId,
+            taskId: task.taskId,
+            task,
+        });
+        if (!skipSnapshotInvalidation)
+            this.emitWorkPlanSnapshotInvalidated(snapshot, 'task-deleted');
+    }
+    emitWorkPlanSnapshotInvalidated(snapshot, reason) {
+        if (!this.runtimeBus)
+            return;
+        emitWorkPlanSnapshotInvalidated(this.runtimeBus, workPlanEmitterContext(snapshot), {
+            projectId: snapshot.projectId,
+            knowledgeSpaceId: snapshot.knowledgeSpaceId,
+            workPlanId: snapshot.workPlanId,
+            reason,
+            snapshot,
+        });
+    }
 }
 function normalizeState(input, projectId, knowledgeSpaceId) {
     const now = Date.now();
@@ -213,6 +556,158 @@ function normalizeState(input, projectId, knowledgeSpaceId) {
         metadata: readPlanningMetadataObject(input.metadata),
     };
 }
+function normalizeWorkPlanArtifact(input, space, workPlanId) {
+    const now = Date.now();
+    const createdAt = typeof input.createdAt === 'number' ? input.createdAt : now;
+    const tasks = Array.isArray(input.tasks)
+        ? input.tasks.map((task, index) => normalizeWorkPlanTask(task, {
+            projectId: space.projectId,
+            knowledgeSpaceId: space.knowledgeSpaceId,
+            now,
+            fallbackOrder: index,
+        }))
+        : [];
+    return {
+        id: normalizeWorkPlanId(input.id ?? workPlanId),
+        projectId: space.projectId,
+        knowledgeSpaceId: space.knowledgeSpaceId,
+        tasks: sortWorkPlanTasks(tasks),
+        createdAt,
+        updatedAt: typeof input.updatedAt === 'number' ? input.updatedAt : now,
+        ...(input.metadata ? { metadata: readPlanningMetadataObject(input.metadata) } : {}),
+    };
+}
+function normalizeWorkPlanTask(input, options) {
+    const title = typeof input.title === 'string' ? input.title.trim() : '';
+    if (!title)
+        throw new Error('Work plan task title is required.');
+    const status = normalizeWorkPlanStatus(input.status ?? 'pending');
+    const createdAt = typeof input.createdAt === 'number' ? input.createdAt : options.now;
+    return {
+        taskId: normalizeWorkPlanTaskId(input.taskId ?? `task-${randomUUID().slice(0, 12)}`),
+        projectId: options.projectId,
+        knowledgeSpaceId: options.knowledgeSpaceId,
+        title,
+        ...(typeof input.notes === 'string' ? { notes: input.notes } : {}),
+        ...(typeof input.owner === 'string' && input.owner.trim() ? { owner: input.owner.trim() } : {}),
+        status,
+        ...(typeof input.priority === 'number' && Number.isFinite(input.priority) ? { priority: input.priority } : {}),
+        order: typeof input.order === 'number' && Number.isFinite(input.order) ? input.order : options.fallbackOrder,
+        ...(typeof input.source === 'string' && input.source.trim() ? { source: input.source.trim() } : {}),
+        tags: stringList(input.tags),
+        ...(typeof input.parentTaskId === 'string' && input.parentTaskId.trim() ? { parentTaskId: normalizeWorkPlanTaskId(input.parentTaskId) } : {}),
+        ...(typeof input.chainId === 'string' && input.chainId.trim() ? { chainId: input.chainId.trim() } : {}),
+        ...(typeof input.phaseId === 'string' && input.phaseId.trim() ? { phaseId: input.phaseId.trim() } : {}),
+        ...(typeof input.agentId === 'string' && input.agentId.trim() ? { agentId: input.agentId.trim() } : {}),
+        ...(typeof input.turnId === 'string' && input.turnId.trim() ? { turnId: input.turnId.trim() } : {}),
+        ...(typeof input.decisionId === 'string' && input.decisionId.trim() ? { decisionId: input.decisionId.trim() } : {}),
+        ...(typeof input.sourceMessageId === 'string' && input.sourceMessageId.trim() ? { sourceMessageId: input.sourceMessageId.trim() } : {}),
+        linkedArtifactIds: stringList(input.linkedArtifactIds),
+        linkedSourceIds: stringList(input.linkedSourceIds),
+        linkedNodeIds: stringList(input.linkedNodeIds),
+        ...(typeof input.originSurface === 'string' && input.originSurface.trim() ? { originSurface: input.originSurface.trim() } : {}),
+        createdAt,
+        updatedAt: typeof input.updatedAt === 'number' ? input.updatedAt : options.now,
+        ...(status === 'done' || status === 'failed' || status === 'cancelled'
+            ? { completedAt: typeof input.completedAt === 'number' ? input.completedAt : options.now }
+            : {}),
+        ...(input.metadata ? { metadata: readPlanningMetadataObject(input.metadata) } : {}),
+    };
+}
+function normalizeWorkPlanId(value) {
+    return typeof value === 'string' && value.trim().length > 0
+        ? stablePlanningId('work-plan', value)
+        : 'current';
+}
+function normalizeWorkPlanTaskId(value) {
+    return typeof value === 'string' && value.trim().length > 0
+        ? stablePlanningId('task', value)
+        : `task-${randomUUID().slice(0, 12)}`;
+}
+function normalizeWorkPlanStatus(value) {
+    if (value === 'pending'
+        || value === 'in_progress'
+        || value === 'blocked'
+        || value === 'done'
+        || value === 'failed'
+        || value === 'cancelled') {
+        return value;
+    }
+    if (value === 'in-progress')
+        return 'in_progress';
+    if (value === 'completed')
+        return 'done';
+    throw new Error(`Invalid work plan task status: ${String(value)}`);
+}
+function workPlanStatusFromPlanningTask(task) {
+    if (task.status === 'in-progress')
+        return 'in_progress';
+    if (task.status === 'blocked')
+        return 'blocked';
+    if (task.status === 'completed')
+        return 'done';
+    if (task.blockedOnUserInput === true)
+        return 'blocked';
+    return 'pending';
+}
+function stringList(value) {
+    if (!Array.isArray(value))
+        return [];
+    return [...new Set(value.filter((entry) => typeof entry === 'string' && entry.trim().length > 0).map((entry) => entry.trim()))];
+}
+function nextWorkPlanOrder(tasks) {
+    return tasks.reduce((max, task) => Math.max(max, task.order), -1) + 1;
+}
+function sortWorkPlanTasks(tasks) {
+    return [...tasks].sort((a, b) => a.order - b.order || a.createdAt - b.createdAt || a.taskId.localeCompare(b.taskId));
+}
+function snapshotFromWorkPlan(space, workPlan, filter = {}) {
+    const tasks = sortWorkPlanTasks(workPlan.tasks).filter((task) => {
+        if (filter.status && task.status !== filter.status)
+            return false;
+        if (filter.parentTaskId && task.parentTaskId !== filter.parentTaskId)
+            return false;
+        if (filter.chainId && task.chainId !== filter.chainId)
+            return false;
+        if (filter.owner && task.owner !== filter.owner)
+            return false;
+        return true;
+    });
+    const limit = typeof filter.limit === 'number' && Number.isFinite(filter.limit) && filter.limit > 0
+        ? Math.floor(filter.limit)
+        : undefined;
+    return {
+        ok: true,
+        projectId: space.projectId,
+        knowledgeSpaceId: space.knowledgeSpaceId,
+        workPlanId: workPlan.id,
+        tasks: limit ? tasks.slice(0, limit) : tasks,
+        counts: countWorkPlanTasks(workPlan.tasks),
+        updatedAt: workPlan.updatedAt,
+    };
+}
+function countWorkPlanTasks(tasks) {
+    const counts = {
+        total: tasks.length,
+        pending: 0,
+        in_progress: 0,
+        blocked: 0,
+        done: 0,
+        failed: 0,
+        cancelled: 0,
+    };
+    for (const task of tasks) {
+        counts[task.status] += 1;
+    }
+    return counts;
+}
+function workPlanEmitterContext(snapshot) {
+    return {
+        traceId: `project-planning:work-plan:${snapshot.workPlanId}:${snapshot.updatedAt}`,
+        sessionId: `project:${snapshot.projectId}`,
+        source: 'project-planning.work-plan',
+    };
+}
 function normalizePlanningId(value) {
     return typeof value === 'string' && value.trim().length > 0
         ? stablePlanningId('plan', value)
@@ -236,7 +731,7 @@ function arrayOfObjectsOrStrings(value) {
 }
 function artifactKind(source) {
     const kind = source.metadata.planningArtifactKind;
-    return kind === 'state' || kind === 'decision' || kind === 'language' ? kind : null;
+    return kind === 'state' || kind === 'decision' || kind === 'language' || kind === 'work-plan' ? kind : null;
 }
 function readState(source) {
     const value = source.metadata.value;
@@ -250,10 +745,16 @@ function readLanguage(source) {
     const value = source.metadata.value;
     return value && typeof value === 'object' ? value : null;
 }
+function readWorkPlan(source) {
+    const value = source.metadata.value;
+    return value && typeof value === 'object' ? value : null;
+}
 function titleForArtifact(kind, value) {
     if (kind === 'state')
         return `Planning: ${value.goal || 'Current plan'}`;
     if (kind === 'decision')
         return `Decision: ${value.title}`;
+    if (kind === 'work-plan')
+        return 'Project Work Plan';
     return 'Project Language';
 }