@critical-path/svelte 0.13.0 → 0.14.0

package/CHANGELOG.md

@@ -1,10 +1,36 @@
 # @critical-path/svelte
 
+## 0.14.0
+
+### Minor Changes
+
+- 9c31e8d: Introduce comprehensive Task Metrics, Inferred Actuals, Progress Inference, Earned Value Management (EVM), and Time-Series Progress History Curve Profiling.
+  - **Inferred Actuals**: Automatic start/completion auto-stamping on workflow transitions with fallback inference from activity logs, plus automatic completion timestamp clearing on task re-open.
+  - **Reality Delta**: Multi-dimensional variance analysis comparing planned estimates to logged hours (`effortVarianceHours`, `durationVarianceHours`, `accuracyRatio`, `isOverdue`, `isOverEstimate`).
+  - **Progress Inference**: Deterministic priority waterfall resolving completion progress across explicit values, checklist/todo completion ratios, logged effort, and elapsed schedule time.
+  - **Earned Value Management (EVM)**: Task-level PV, EV, AC, CV, SV, CPI, and SPI calculations.
+  - **Time-Series History & Curve Shapes**: Historical timeline reconstruction from activity logs with piecewise interpolation curve classification (`linear`, `s_curve`, `early_surge`, `late_rush`, `stalled`).
+  - **Full-Stack Integration**: REST endpoints (`/tasks/:id/metrics`, `/tasks/:id/progress-history`), Client SDK methods, React `useTaskMetrics` hook, Svelte 5 `TaskMetricsState`, and MCP tools (`get_task_metrics`, `get_task_progress_history`).
+
+### Patch Changes
+
+- Updated dependencies [9c31e8d]
+  - @critical-path/core@0.17.0
+  - @critical-path/client@0.11.0
+  - @critical-path/mcp@0.4.0
+
+## 0.13.1
+
+### Patch Changes
+
+- Updated dependencies [b4b2c98]
+  - @critical-path/mcp@0.3.1
+
 ## 0.13.0
 
 ### Minor Changes
 
-- e2a7eef: Introduce Bret Victor's Ladder of Abstraction and Critical Path Method (CPM) timeline synthesis to the framework data model:
+- e2a7eef: Introduce Ladder of Abstraction and Critical Path Method (CPM) timeline synthesis to the framework data model:
   - **Core Domain**: Multi-scale timeline synthesis model across Macro phase rollups, Standard CPM Gantt schedule (early/late bounds, float/slack calculation, bottleneck identification), and Concrete grounding (deliverables, file attachments, daily effort distribution, and reality deltas). Added `calculateCriticalPath`, `getTimelineLadder`, and `getTaskLadder` to `CriticalPathEngine`.
   - **Server Router**: HTTP endpoints `GET /projects/:id/critical-path`, `GET /projects/:id/ladder`, and `GET /tasks/:id/ladder`.
   - **Client SDK**: `CriticalPathClient` methods `calculateCriticalPath`, `getTimelineLadder`, and `getTaskLadder`.

package/README.md

@@ -138,7 +138,7 @@ Combines threaded comments with inline attachments (`attachment.commentId === co
 {/each}
 ```
 
-### 4. Bret Victor's Ladder of Abstraction (`TimelineLadderState`)
+### 4. Ladder of Abstraction (`TimelineLadderState`)
 
 Fluidly traverse between Macro phase health, Standard Gantt tasks with CPM critical paths, and Concrete deliverables/effort using Svelte 5 Runes:
 

package/dist/index.d.ts

@@ -13,4 +13,5 @@ export * from './task-transitions-state.svelte.js';
 export * from './webmcp-state.svelte.js';
 export * from './critical-path-state.svelte.js';
 export * from './timeline-ladder-state.svelte.js';
+export * from './task-metrics-state.svelte.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,KAAK,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAE/E,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,aAAa,GAAG,kBAAkB,CAEnF;AAED,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,uCAAuC,CAAC;AACtD,cAAc,0BAA0B,CAAC;AACzC,cAAc,oCAAoC,CAAC;AACnD,cAAc,0BAA0B,CAAC;AACzC,cAAc,iCAAiC,CAAC;AAChD,cAAc,mCAAmC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,KAAK,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAE/E,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,aAAa,GAAG,kBAAkB,CAEnF;AAED,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,uCAAuC,CAAC;AACtD,cAAc,0BAA0B,CAAC;AACzC,cAAc,oCAAoC,CAAC;AACnD,cAAc,0BAA0B,CAAC;AACzC,cAAc,iCAAiC,CAAC;AAChD,cAAc,mCAAmC,CAAC;AAClD,cAAc,gCAAgC,CAAC"}

package/dist/index.js

@@ -4004,7 +4004,7 @@ var $ = [
 	{
 		name: "get_timeline_ladder",
 		title: "Get Timeline Ladder of Abstraction",
-		description: "Retrieve Bret Victor Ladder of Abstraction for a project timeline across macro phase envelopes, standard Gantt tasks & CPM, and concrete deliverables/time/attachments.",
+		description: "Retrieve Ladder of Abstraction for a project timeline across macro phase envelopes, standard Gantt tasks & CPM, and concrete deliverables/time/attachments.",
 		zodSchema: Z({
 			projectId: X().optional().describe("Project ID (falls back to ambient context if omitted)"),
 			level: Q([
@@ -4058,7 +4058,7 @@ var $ = [
 	{
 		name: "get_task_ladder",
 		title: "Get Task Ladder View",
-		description: "Retrieve multi-scale Bret Victor ladder view for a single task, connecting its macro phase, standard CPM timeline position, and concrete work evidence.",
+		description: "Retrieve multi-scale ladder view for a single task, connecting its macro phase, standard CPM timeline position, and concrete work evidence.",
 		zodSchema: Z({ taskId: X().describe("The task ID") }),
 		inputSchema: {
 			type: "object",
@@ -4071,6 +4071,40 @@ var $ = [
 		},
 		annotations: { readOnlyHint: !0 },
 		execute: async (e, t) => t.getTaskLadder(e.taskId)
+	},
+	{
+		name: "get_task_metrics",
+		title: "Get Task Metrics",
+		description: "Retrieve multi-dimensional task metrics including inferred actuals, active working duration, effort/duration/schedule variances, progress inference, and Earned Value Management (EVM) metrics.",
+		zodSchema: Z({ taskId: X().describe("The task ID") }),
+		inputSchema: {
+			type: "object",
+			properties: { taskId: {
+				type: "string",
+				description: "The task ID"
+			} },
+			required: ["taskId"],
+			additionalProperties: !1
+		},
+		annotations: { readOnlyHint: !0 },
+		execute: async (e, t) => t.getTaskMetrics(e.taskId)
+	},
+	{
+		name: "get_task_progress_history",
+		title: "Get Task Progress History",
+		description: "Retrieve time-series progress data points and curve shape classification (linear, s_curve, early_surge, late_rush, stalled) for a task.",
+		zodSchema: Z({ taskId: X().describe("The task ID") }),
+		inputSchema: {
+			type: "object",
+			properties: { taskId: {
+				type: "string",
+				description: "The task ID"
+			} },
+			required: ["taskId"],
+			additionalProperties: !1
+		},
+		annotations: { readOnlyHint: !0 },
+		execute: async (e, t) => t.getTaskProgressHistory(e.taskId)
 	}
 ];
 new Map($.map((e) => [e.name, e]));
@@ -4330,9 +4364,121 @@ function vt(e, t, n) {
 	return new _t(e, t, n);
 }
 //#endregion
+//#region src/task-metrics-state.svelte.ts
+var yt = class {
+	client;
+	taskId;
+	#e = t.state(null);
+	get metrics() {
+		return t.get(this.#e);
+	}
+	set metrics(e) {
+		t.set(this.#e, e, !0);
+	}
+	#t = t.state(null);
+	get history() {
+		return t.get(this.#t);
+	}
+	set history(e) {
+		t.set(this.#t, e, !0);
+	}
+	#n = t.state(!1);
+	get loading() {
+		return t.get(this.#n);
+	}
+	set loading(e) {
+		t.set(this.#n, e, !0);
+	}
+	#r = t.state(null);
+	get error() {
+		return t.get(this.#r);
+	}
+	set error(e) {
+		t.set(this.#r, e, !0);
+	}
+	#i = t.derived(() => this.metrics?.inferredActuals ?? null);
+	get inferredActuals() {
+		return t.get(this.#i);
+	}
+	set inferredActuals(e) {
+		t.set(this.#i, e);
+	}
+	#a = t.derived(() => this.metrics?.realityDelta ?? null);
+	get realityDelta() {
+		return t.get(this.#a);
+	}
+	set realityDelta(e) {
+		t.set(this.#a, e);
+	}
+	#o = t.derived(() => this.metrics?.progress ?? null);
+	get progress() {
+		return t.get(this.#o);
+	}
+	set progress(e) {
+		t.set(this.#o, e);
+	}
+	#s = t.derived(() => this.metrics?.evm ?? null);
+	get evm() {
+		return t.get(this.#s);
+	}
+	set evm(e) {
+		t.set(this.#s, e);
+	}
+	#c = t.derived(() => this.history?.curveProfile ?? null);
+	get curveProfile() {
+		return t.get(this.#c);
+	}
+	set curveProfile(e) {
+		t.set(this.#c, e);
+	}
+	constructor(e, t) {
+		this.client = e, this.taskId = t;
+	}
+	async fetchMetrics() {
+		this.loading = !0, this.error = null;
+		try {
+			return this.metrics = await this.client.getTaskMetrics(this.taskId), this.metrics;
+		} catch (e) {
+			return this.error = e instanceof Error ? e : Error(String(e)), null;
+		} finally {
+			this.loading = !1;
+		}
+	}
+	async fetchHistory() {
+		this.loading = !0, this.error = null;
+		try {
+			return this.history = await this.client.getTaskProgressHistory(this.taskId), this.history;
+		} catch (e) {
+			return this.error = e instanceof Error ? e : Error(String(e)), null;
+		} finally {
+			this.loading = !1;
+		}
+	}
+	async fetchAll() {
+		this.loading = !0, this.error = null;
+		try {
+			let [e, t] = await Promise.all([this.client.getTaskMetrics(this.taskId), this.client.getTaskProgressHistory(this.taskId)]);
+			return this.metrics = e, this.history = t, {
+				metrics: e,
+				history: t
+			};
+		} catch (e) {
+			return this.error = e instanceof Error ? e : Error(String(e)), {
+				metrics: null,
+				history: null
+			};
+		} finally {
+			this.loading = !1;
+		}
+	}
+};
+function bt(e, t) {
+	return new yt(e, t);
+}
+//#endregion
 //#region src/index.ts
-function yt(t) {
+function xt(t) {
 	return new e(t);
 }
 //#endregion
-export { ne as AttachmentState, ee as CommentState, ht as CriticalPathState, oe as DeliverableState, ce as DeliverableSummaryState, ue as KanbanState, r as ProjectState, ie as TaskActivityState, a as TaskState, fe as TaskTransitionsState, _t as TimelineLadderState, pt as WebMcpState, s as WorkflowState, re as createAttachmentState, te as createCommentState, yt as createCriticalPathClient, gt as createCriticalPathState, se as createDeliverableState, le as createDeliverableSummaryState, de as createKanbanState, i as createProjectState, ae as createTaskActivityState, o as createTaskState, pe as createTaskTransitionsState, vt as createTimelineLadderState, mt as createWebMcpState, c as createWorkflowState };
+export { ne as AttachmentState, ee as CommentState, ht as CriticalPathState, oe as DeliverableState, ce as DeliverableSummaryState, ue as KanbanState, r as ProjectState, ie as TaskActivityState, yt as TaskMetricsState, a as TaskState, fe as TaskTransitionsState, _t as TimelineLadderState, pt as WebMcpState, s as WorkflowState, re as createAttachmentState, te as createCommentState, xt as createCriticalPathClient, gt as createCriticalPathState, se as createDeliverableState, le as createDeliverableSummaryState, de as createKanbanState, i as createProjectState, ae as createTaskActivityState, bt as createTaskMetricsState, o as createTaskState, pe as createTaskTransitionsState, vt as createTimelineLadderState, mt as createWebMcpState, c as createWorkflowState };

package/dist/task-metrics-state.svelte.d.ts

@@ -0,0 +1,24 @@
+import type { CriticalPathClient } from '@critical-path/client';
+import type { TaskMetrics, TaskProgressHistory, TaskInferredActuals, RealityDelta, TaskProgressInference, TaskEVM, ProgressCurveProfile } from '@critical-path/core';
+export declare class TaskMetricsState {
+    private client;
+    taskId: string;
+    metrics: TaskMetrics | null;
+    history: TaskProgressHistory | null;
+    loading: boolean;
+    error: Error | null;
+    inferredActuals: TaskInferredActuals | null;
+    realityDelta: RealityDelta | null;
+    progress: TaskProgressInference | null;
+    evm: TaskEVM | null;
+    curveProfile: ProgressCurveProfile | null;
+    constructor(client: CriticalPathClient, taskId: string);
+    fetchMetrics(): Promise<TaskMetrics | null>;
+    fetchHistory(): Promise<TaskProgressHistory | null>;
+    fetchAll(): Promise<{
+        metrics: TaskMetrics | null;
+        history: TaskProgressHistory | null;
+    }>;
+}
+export declare function createTaskMetricsState(client: CriticalPathClient, taskId: string): TaskMetricsState;
+//# sourceMappingURL=task-metrics-state.svelte.d.ts.map

package/dist/task-metrics-state.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-metrics-state.svelte.d.ts","sourceRoot":"","sources":["../src/task-metrics-state.svelte.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,KAAK,EACV,WAAW,EACX,mBAAmB,EACnB,mBAAmB,EACnB,YAAY,EACZ,qBAAqB,EACrB,OAAO,EACP,oBAAoB,EACrB,MAAM,qBAAqB,CAAC;AAE7B,qBAAa,gBAAgB;IAazB,OAAO,CAAC,MAAM;IACP,MAAM,EAAE,MAAM;IAbvB,OAAO,qBAAoC;IAC3C,OAAO,6BAA4C;IACnD,OAAO,UAA0B;IACjC,KAAK,eAA8B;IAEnC,eAAe,6BAA+E;IAC9F,YAAY,sBAAqE;IACjF,QAAQ,+BAA0E;IAClF,GAAG,iBAAuD;IAC1D,YAAY,8BAA6E;gBAG/E,MAAM,EAAE,kBAAkB,EAC3B,MAAM,EAAE,MAAM;IAGjB,YAAY,IAAI,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC;IAc3C,YAAY,IAAI,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC;IAcnD,QAAQ,IAAI,OAAO,CAAC;QAAE,OAAO,EAAE,WAAW,GAAG,IAAI,CAAC;QAAC,OAAO,EAAE,mBAAmB,GAAG,IAAI,CAAA;KAAE,CAAC;CAkBhG;AAED,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,kBAAkB,EAC1B,MAAM,EAAE,MAAM,GACb,gBAAgB,CAElB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@critical-path/svelte",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "Svelte 5 Runes state and reactive integrations for Critical Path headless project management framework",
   "author": "Jack James",
   "license": "MIT",
@@ -18,9 +18,9 @@
     }
   },
   "dependencies": {
-    "@critical-path/mcp": "0.3.0",
-    "@critical-path/client": "0.10.0",
-    "@critical-path/core": "0.16.0"
+    "@critical-path/client": "0.11.0",
+    "@critical-path/mcp": "0.4.0",
+    "@critical-path/core": "0.17.0"
   },
   "peerDependencies": {
     "svelte": "^5.0.0"

package/src/index.test.ts

@@ -26,7 +26,9 @@ import {
   CriticalPathState,
   createCriticalPathState,
   TimelineLadderState,
-  createTimelineLadderState
+  createTimelineLadderState,
+  TaskMetricsState,
+  createTaskMetricsState
 } from './index.js';
 import type { CriticalPathClient } from '@critical-path/client';
 import type {
@@ -660,6 +662,79 @@ describe('@critical-path/svelte Svelte 5 Runes Test Suite', () => {
       expect(mockClient.getTimelineLadder).toHaveBeenCalledWith('proj_ladder', { level: 'macro' });
     });
   });
+
+  describe('TaskMetricsState', () => {
+    it('fetches metrics and progress history and derives subfields', async () => {
+      const mockMetrics = {
+        taskId: 'task_1',
+        inferredActuals: {
+          actualStartDate: '2026-09-01T00:00:00Z',
+          actualEndDate: '2026-09-05T00:00:00Z',
+          isStartDateInferred: false,
+          isEndDateInferred: true,
+          activeWorkingHours: 96
+        },
+        realityDelta: {
+          estimatedHours: 20,
+          loggedHours: 15,
+          varianceHours: -5,
+          effortVarianceHours: -5,
+          accuracyRatio: 0.75,
+          isOverdue: false,
+          isOverEstimate: false
+        },
+        progress: {
+          progressPercentage: 75,
+          source: 'explicit' as const,
+          isExplicit: true,
+          breakdown: { explicitProgress: 75 }
+        },
+        evm: {
+          plannedValue: 20,
+          earnedValue: 15,
+          actualCost: 15,
+          costVariance: 0,
+          scheduleVariance: -5,
+          costPerformanceIndex: 1.0,
+          schedulePerformanceIndex: 0.75
+        }
+      };
+
+      const mockHistory = {
+        taskId: 'task_1',
+        points: [
+          { timestamp: '2026-09-01T00:00:00Z', progress: 0, status: 'todo', semanticStatus: 'not_started' as const, action: 'task.created' },
+          { timestamp: '2026-09-05T00:00:00Z', progress: 75, status: 'in_progress', semanticStatus: 'in_progress' as const, action: 'task.updated' }
+        ],
+        curveProfile: 'linear' as const
+      };
+
+      const mockClient = {
+        getTaskMetrics: vi.fn().mockResolvedValue(mockMetrics),
+        getTaskProgressHistory: vi.fn().mockResolvedValue(mockHistory)
+      } as unknown as CriticalPathClient;
+
+      const state = createTaskMetricsState(mockClient, 'task_1');
+      expect(state.metrics).toBeNull();
+      expect(state.history).toBeNull();
+      expect(state.inferredActuals).toBeNull();
+      expect(state.realityDelta).toBeNull();
+      expect(state.progress).toBeNull();
+      expect(state.evm).toBeNull();
+      expect(state.curveProfile).toBeNull();
+
+      await state.fetchAll();
+      expect(mockClient.getTaskMetrics).toHaveBeenCalledWith('task_1');
+      expect(mockClient.getTaskProgressHistory).toHaveBeenCalledWith('task_1');
+      expect(state.metrics).toEqual(mockMetrics);
+      expect(state.history).toEqual(mockHistory);
+      expect(state.inferredActuals?.activeWorkingHours).toBe(96);
+      expect(state.realityDelta?.effortVarianceHours).toBe(-5);
+      expect(state.progress?.progressPercentage).toBe(75);
+      expect(state.evm?.costPerformanceIndex).toBe(1.0);
+      expect(state.curveProfile).toBe('linear');
+    });
+  });
 });
 
 

package/src/index.ts

@@ -17,5 +17,6 @@ export * from './task-transitions-state.svelte.js';
 export * from './webmcp-state.svelte.js';
 export * from './critical-path-state.svelte.js';
 export * from './timeline-ladder-state.svelte.js';
+export * from './task-metrics-state.svelte.js';
 
 

package/src/task-metrics-state.svelte.ts

@@ -0,0 +1,83 @@
+/// <reference types="svelte" />
+import type { CriticalPathClient } from '@critical-path/client';
+import type {
+  TaskMetrics,
+  TaskProgressHistory,
+  TaskInferredActuals,
+  RealityDelta,
+  TaskProgressInference,
+  TaskEVM,
+  ProgressCurveProfile
+} from '@critical-path/core';
+
+export class TaskMetricsState {
+  metrics = $state<TaskMetrics | null>(null);
+  history = $state<TaskProgressHistory | null>(null);
+  loading = $state<boolean>(false);
+  error = $state<Error | null>(null);
+
+  inferredActuals = $derived<TaskInferredActuals | null>(this.metrics?.inferredActuals ?? null);
+  realityDelta = $derived<RealityDelta | null>(this.metrics?.realityDelta ?? null);
+  progress = $derived<TaskProgressInference | null>(this.metrics?.progress ?? null);
+  evm = $derived<TaskEVM | null>(this.metrics?.evm ?? null);
+  curveProfile = $derived<ProgressCurveProfile | null>(this.history?.curveProfile ?? null);
+
+  constructor(
+    private client: CriticalPathClient,
+    public taskId: string
+  ) {}
+
+  async fetchMetrics(): Promise<TaskMetrics | null> {
+    this.loading = true;
+    this.error = null;
+    try {
+      this.metrics = await this.client.getTaskMetrics(this.taskId);
+      return this.metrics;
+    } catch (err) {
+      this.error = err instanceof Error ? err : new Error(String(err));
+      return null;
+    } finally {
+      this.loading = false;
+    }
+  }
+
+  async fetchHistory(): Promise<TaskProgressHistory | null> {
+    this.loading = true;
+    this.error = null;
+    try {
+      this.history = await this.client.getTaskProgressHistory(this.taskId);
+      return this.history;
+    } catch (err) {
+      this.error = err instanceof Error ? err : new Error(String(err));
+      return null;
+    } finally {
+      this.loading = false;
+    }
+  }
+
+  async fetchAll(): Promise<{ metrics: TaskMetrics | null; history: TaskProgressHistory | null }> {
+    this.loading = true;
+    this.error = null;
+    try {
+      const [m, h] = await Promise.all([
+        this.client.getTaskMetrics(this.taskId),
+        this.client.getTaskProgressHistory(this.taskId)
+      ]);
+      this.metrics = m;
+      this.history = h;
+      return { metrics: m, history: h };
+    } catch (err) {
+      this.error = err instanceof Error ? err : new Error(String(err));
+      return { metrics: null, history: null };
+    } finally {
+      this.loading = false;
+    }
+  }
+}
+
+export function createTaskMetricsState(
+  client: CriticalPathClient,
+  taskId: string
+): TaskMetricsState {
+  return new TaskMetricsState(client, taskId);
+}