prjct-cli 1.7.0 → 1.7.2

package/CHANGELOG.md

@@ -1,5 +1,68 @@
 # Changelog
 
+## [1.7.2] - 2026-02-07
+
+### Bug Fixes
+
+- add missing state machine transitions and dead-end states (PRJ-280) (#141)
+
+
+## [1.7.2] - 2026-02-07
+
+### Bug Fix
+- **Fix state machine completeness: missing transitions and dead-end states (PRJ-280)**: Added missing transitions (`completed → pause`, `paused → ship`, `completed → reopen`), subtask states (`skipped`, `blocked` with reason tracking), migrated `previousTask` to `pausedTasks[]` array with max limit (5) and staleness detection (30 days), and enforced all transitions through the state machine at the storage level.
+
+### Implementation Details
+Added `reopen` command to `WorkflowCommand` type. Updated `getCurrentState()` to detect paused state from `pausedTasks[]` array and legacy `previousTask`. `failSubtask()` now advances to the next subtask instead of halting. New `skipSubtask(reason)` and `blockSubtask(blocker)` methods mark subtasks and advance. `pauseTask()` pushes onto a `pausedTasks[]` array (max 5), `resumeTask()` pops from array or by ID. `getPausedTasksFromState()` handles backward compat by migrating legacy `previousTask` format. All storage mutation methods (`startTask`, `completeTask`, `pauseTask`, `resumeTask`) validate transitions through the state machine before executing.
+
+### Test Plan
+
+#### For QA
+1. Verify `completed → pause`, `paused → ship`, and `completed → reopen` transitions work
+2. Start a task with subtasks, call `failSubtask()` — verify it records reason AND advances to next subtask
+3. Call `skipSubtask(reason)` and `blockSubtask(blocker)` — verify they record reasons and advance
+4. Pause 3+ tasks — verify `pausedTasks[]` array stores all, respects max limit of 5
+5. State.json with old `previousTask` format — verify auto-migration into array
+6. Attempt invalid transition (e.g., `done` from `idle`) — verify error thrown at storage level
+
+#### For Users
+**What changed:** Workflow supports reopening completed tasks, shipping paused tasks directly, and multiple paused tasks. Subtask failures auto-advance instead of halting.
+**Breaking changes:** `previousTask` deprecated in favor of `pausedTasks[]`. Backward compat maintained via auto-migration.
+
+## [1.7.1] - 2026-02-07
+
+### Bug Fixes
+
+- add Zod validation on all storage reads (PRJ-279) (#140)
+
+
+## [1.7.1] - 2026-02-07
+
+### Bug Fix
+- **Add Zod validation on all storage reads (PRJ-279)**: Created `safeRead<T>()` utility that wraps `JSON.parse` + `schema.safeParse()`. All 5 `StorageManager` subclasses (state, queue, ideas, shipped, metrics) now validate reads against their Zod schemas. Corrupted files produce a logged warning + `.backup` file instead of silently crashing downstream.
+
+### Implementation Details
+Created `core/storage/safe-reader.ts` with a `ValidationSchema` interface decoupled from Zod generics to avoid strict type parameter matching. The `StorageManager` base class accepts an optional schema via constructor — subclasses pass their Zod schema with a single import + arg change. `safeRead` returns the raw parsed JSON (not Zod-transformed `result.data`) to preserve extra fields for forward compatibility. Also fixed `ShippedJsonSchema` which used `items` instead of `shipped` (pre-existing schema bug), and made `changes` optional to match actual data.
+
+### Learnings
+- Zod's default `strip` mode silently drops unknown keys from `result.data` — must return raw JSON to preserve extra state.json fields (projectId, stack, domains, etc.)
+- `ShippedJsonSchema` had `items` instead of `shipped` as the array key — pre-existing schema/data mismatch
+- `ValidationSchema` interface avoids Zod generic constraints while still providing type-safe validation
+
+### Test Plan
+
+#### For QA
+1. Create a valid `state.json` — verify it reads correctly with no warnings
+2. Corrupt a storage file with invalid JSON — verify `.backup` is created and defaults returned
+3. Write valid JSON with wrong schema — verify `.backup` and defaults
+4. Add extra fields not in schema — verify they are preserved after read
+5. Run `bun test` — verify all 438 tests pass (16 new for `safeRead`)
+
+#### For Users
+**What changed:** Storage reads are now validated against Zod schemas. Corrupted files no longer cause silent crashes.
+**How to use:** No action needed — automatic.
+**Breaking changes:** None.
+
 ## [1.7.0] - 2026-02-07
 
 ### Features
@@ -7,7 +70,6 @@
 - use relative timestamps to reduce token waste (PRJ-274) (#139)
 - use relative timestamps to reduce token waste (PRJ-274)
 
-
 ## [1.6.16] - 2026-02-07
 
 ### Improvement

package/core/__tests__/storage/safe-reader.test.ts

@@ -0,0 +1,262 @@
+/**
+ * Safe Reader Tests
+ *
+ * Tests for Zod-validated storage reads:
+ * - Valid data passes through
+ * - Corrupted JSON creates .backup + returns null
+ * - Valid JSON with wrong schema creates .backup + returns null
+ * - Missing files return null (no backup)
+ * - Extra fields are preserved (forward compatibility)
+ */
+
+import { afterEach, beforeEach, describe, expect, it } from 'bun:test'
+import fs from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import { z } from 'zod'
+import { safeRead } from '../../storage/safe-reader'
+
+// =============================================================================
+// Test Schema
+// =============================================================================
+
+const TestSchema = z.object({
+  name: z.string(),
+  count: z.number(),
+  items: z.array(z.string()),
+})
+
+type TestData = z.infer<typeof TestSchema>
+
+// =============================================================================
+// Setup
+// =============================================================================
+
+let tmpDir: string
+
+beforeEach(async () => {
+  tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'prjct-safe-reader-test-'))
+})
+
+afterEach(async () => {
+  await fs.rm(tmpDir, { recursive: true, force: true })
+})
+
+// =============================================================================
+// Tests
+// =============================================================================
+
+describe('safeRead', () => {
+  describe('valid data', () => {
+    it('should return validated data for valid JSON matching schema', async () => {
+      const filePath = path.join(tmpDir, 'valid.json')
+      const data: TestData = { name: 'test', count: 42, items: ['a', 'b'] }
+      await fs.writeFile(filePath, JSON.stringify(data, null, 2))
+
+      const result = await safeRead<TestData>(filePath, TestSchema)
+
+      expect(result).toEqual(data)
+    })
+
+    it('should preserve extra fields not in schema', async () => {
+      const filePath = path.join(tmpDir, 'extra-fields.json')
+      const data = {
+        name: 'test',
+        count: 1,
+        items: [],
+        extraField: 'preserved',
+        nested: { deep: true },
+      }
+      await fs.writeFile(filePath, JSON.stringify(data, null, 2))
+
+      const result = await safeRead<typeof data>(filePath, TestSchema)
+
+      expect(result).not.toBeNull()
+      expect(result!.name).toBe('test')
+      expect(result!.extraField).toBe('preserved')
+      expect(result!.nested).toEqual({ deep: true })
+    })
+
+    it('should not create .backup for valid data', async () => {
+      const filePath = path.join(tmpDir, 'no-backup.json')
+      const data: TestData = { name: 'ok', count: 0, items: [] }
+      await fs.writeFile(filePath, JSON.stringify(data))
+
+      await safeRead<TestData>(filePath, TestSchema)
+
+      const backupExists = await fs
+        .access(`${filePath}.backup`)
+        .then(() => true)
+        .catch(() => false)
+      expect(backupExists).toBe(false)
+    })
+  })
+
+  describe('missing files', () => {
+    it('should return null for non-existent file', async () => {
+      const result = await safeRead<TestData>(path.join(tmpDir, 'missing.json'), TestSchema)
+
+      expect(result).toBeNull()
+    })
+
+    it('should not create .backup for missing file', async () => {
+      const filePath = path.join(tmpDir, 'missing.json')
+      await safeRead<TestData>(filePath, TestSchema)
+
+      const backupExists = await fs
+        .access(`${filePath}.backup`)
+        .then(() => true)
+        .catch(() => false)
+      expect(backupExists).toBe(false)
+    })
+  })
+
+  describe('corrupted JSON', () => {
+    it('should return null for malformed JSON', async () => {
+      const filePath = path.join(tmpDir, 'malformed.json')
+      await fs.writeFile(filePath, 'not valid json {{{')
+
+      const result = await safeRead<TestData>(filePath, TestSchema)
+
+      expect(result).toBeNull()
+    })
+
+    it('should create .backup for malformed JSON', async () => {
+      const filePath = path.join(tmpDir, 'malformed.json')
+      const badContent = 'not valid json {{{'
+      await fs.writeFile(filePath, badContent)
+
+      await safeRead<TestData>(filePath, TestSchema)
+
+      const backup = await fs.readFile(`${filePath}.backup`, 'utf-8')
+      expect(backup).toBe(badContent)
+    })
+
+    it('should return null for empty file', async () => {
+      const filePath = path.join(tmpDir, 'empty.json')
+      await fs.writeFile(filePath, '')
+
+      const result = await safeRead<TestData>(filePath, TestSchema)
+
+      expect(result).toBeNull()
+    })
+  })
+
+  describe('valid JSON with wrong schema', () => {
+    it('should return null when required field is missing', async () => {
+      const filePath = path.join(tmpDir, 'missing-field.json')
+      await fs.writeFile(filePath, JSON.stringify({ name: 'test' })) // missing count and items
+
+      const result = await safeRead<TestData>(filePath, TestSchema)
+
+      expect(result).toBeNull()
+    })
+
+    it('should create .backup when schema validation fails', async () => {
+      const filePath = path.join(tmpDir, 'wrong-schema.json')
+      const data = { name: 123, count: 'not a number', items: 'not an array' }
+      await fs.writeFile(filePath, JSON.stringify(data))
+
+      await safeRead<TestData>(filePath, TestSchema)
+
+      const backupExists = await fs
+        .access(`${filePath}.backup`)
+        .then(() => true)
+        .catch(() => false)
+      expect(backupExists).toBe(true)
+    })
+
+    it('should return null when field has wrong type', async () => {
+      const filePath = path.join(tmpDir, 'wrong-type.json')
+      await fs.writeFile(filePath, JSON.stringify({ name: 42, count: 1, items: [] }))
+
+      const result = await safeRead<TestData>(filePath, TestSchema)
+
+      expect(result).toBeNull()
+    })
+
+    it('should return null when array contains wrong types', async () => {
+      const filePath = path.join(tmpDir, 'wrong-array.json')
+      await fs.writeFile(filePath, JSON.stringify({ name: 'test', count: 1, items: [1, 2, 3] }))
+
+      const result = await safeRead<TestData>(filePath, TestSchema)
+
+      expect(result).toBeNull()
+    })
+  })
+
+  describe('optional fields and defaults', () => {
+    it('should handle schema with optional fields', async () => {
+      const OptionalSchema = z.object({
+        name: z.string(),
+        description: z.string().optional(),
+      })
+
+      const filePath = path.join(tmpDir, 'optional.json')
+      await fs.writeFile(filePath, JSON.stringify({ name: 'test' }))
+
+      const result = await safeRead<z.infer<typeof OptionalSchema>>(filePath, OptionalSchema)
+
+      expect(result).not.toBeNull()
+      expect(result!.name).toBe('test')
+      expect(result!.description).toBeUndefined()
+    })
+
+    it('should handle schema with nullable fields', async () => {
+      const NullableSchema = z.object({
+        currentTask: z.object({ id: z.string() }).nullable(),
+        lastUpdated: z.string(),
+      })
+
+      const filePath = path.join(tmpDir, 'nullable.json')
+      await fs.writeFile(filePath, JSON.stringify({ currentTask: null, lastUpdated: '2026-01-01' }))
+
+      const result = await safeRead<z.infer<typeof NullableSchema>>(filePath, NullableSchema)
+
+      expect(result).not.toBeNull()
+      expect(result!.currentTask).toBeNull()
+    })
+  })
+
+  describe('integration with StorageManager pattern', () => {
+    it('should work with real StateJsonSchema', async () => {
+      // Import the actual schema used in production
+      const { StateJsonSchema } = await import('../../schemas/state')
+
+      const filePath = path.join(tmpDir, 'state.json')
+      const stateData = {
+        currentTask: null,
+        lastUpdated: '2026-02-07T00:00:00.000Z',
+        // Extra fields that exist in real state.json but not in schema
+        projectId: 'test-123',
+        stack: { language: 'TypeScript', framework: 'Hono' },
+      }
+      await fs.writeFile(filePath, JSON.stringify(stateData, null, 2))
+
+      const result = await safeRead<typeof stateData>(filePath, StateJsonSchema)
+
+      expect(result).not.toBeNull()
+      expect(result!.currentTask).toBeNull()
+      expect(result!.projectId).toBe('test-123') // Extra field preserved
+    })
+
+    it('should reject corrupted state data', async () => {
+      const { StateJsonSchema } = await import('../../schemas/state')
+
+      const filePath = path.join(tmpDir, 'bad-state.json')
+      // currentTask should be an object or null, not a number
+      const badData = { currentTask: 42, lastUpdated: '2026-02-07' }
+      await fs.writeFile(filePath, JSON.stringify(badData))
+
+      const result = await safeRead(filePath, StateJsonSchema)
+
+      expect(result).toBeNull()
+      // Backup should exist
+      const backupExists = await fs
+        .access(`${filePath}.backup`)
+        .then(() => true)
+        .catch(() => false)
+      expect(backupExists).toBe(true)
+    })
+  })
+})

package/core/__tests__/workflow/state-machine.test.ts

@@ -0,0 +1,216 @@
+/**
+ * State Machine Tests
+ *
+ * Tests for workflow state machine transitions:
+ * - All valid transitions work
+ * - Invalid transitions are rejected
+ * - New transitions: completed→paused, paused→shipped, completed→reopen
+ * - getCurrentState detects paused tasks from pausedTasks array
+ */
+
+import { describe, expect, it } from 'bun:test'
+import type { WorkflowCommand, WorkflowState } from '../../workflow/state-machine'
+import { WorkflowStateMachine } from '../../workflow/state-machine'
+
+const sm = new WorkflowStateMachine()
+
+// =============================================================================
+// getCurrentState
+// =============================================================================
+
+describe('getCurrentState', () => {
+  it('returns idle when no task and no paused tasks', () => {
+    expect(sm.getCurrentState({ currentTask: null })).toBe('idle')
+    expect(sm.getCurrentState({})).toBe('idle')
+  })
+
+  it('returns working for in_progress status', () => {
+    expect(sm.getCurrentState({ currentTask: { status: 'in_progress' } })).toBe('working')
+    expect(sm.getCurrentState({ currentTask: { status: 'working' } })).toBe('working')
+  })
+
+  it('returns completed for completed/done status', () => {
+    expect(sm.getCurrentState({ currentTask: { status: 'completed' } })).toBe('completed')
+    expect(sm.getCurrentState({ currentTask: { status: 'done' } })).toBe('completed')
+  })
+
+  it('returns shipped for shipped status', () => {
+    expect(sm.getCurrentState({ currentTask: { status: 'shipped' } })).toBe('shipped')
+  })
+
+  it('returns paused when currentTask has paused status', () => {
+    expect(sm.getCurrentState({ currentTask: { status: 'paused' } })).toBe('paused')
+  })
+
+  it('returns paused when no currentTask but pausedTasks array has entries', () => {
+    expect(sm.getCurrentState({ currentTask: null, pausedTasks: [{ id: '1' }] })).toBe('paused')
+  })
+
+  it('returns paused when no currentTask but legacy previousTask is paused', () => {
+    expect(sm.getCurrentState({ currentTask: null, previousTask: { status: 'paused' } })).toBe(
+      'paused'
+    )
+  })
+
+  it('returns idle when no currentTask and empty pausedTasks', () => {
+    expect(sm.getCurrentState({ currentTask: null, pausedTasks: [] })).toBe('idle')
+  })
+
+  it('returns working for unknown status when task exists', () => {
+    expect(sm.getCurrentState({ currentTask: { status: 'active' } })).toBe('working')
+    expect(sm.getCurrentState({ currentTask: {} })).toBe('working')
+  })
+})
+
+// =============================================================================
+// canTransition - valid transitions
+// =============================================================================
+
+describe('canTransition - valid', () => {
+  const validTransitions: [WorkflowState, WorkflowCommand][] = [
+    // idle
+    ['idle', 'task'],
+    ['idle', 'next'],
+    // working
+    ['working', 'done'],
+    ['working', 'pause'],
+    // paused
+    ['paused', 'resume'],
+    ['paused', 'task'],
+    ['paused', 'ship'], // NEW: fast-track ship
+    // completed
+    ['completed', 'ship'],
+    ['completed', 'task'],
+    ['completed', 'next'],
+    ['completed', 'pause'], // NEW: reopen for review
+    ['completed', 'reopen'], // NEW: reopen for rework
+    // shipped
+    ['shipped', 'task'],
+    ['shipped', 'next'],
+  ]
+
+  for (const [state, command] of validTransitions) {
+    it(`${state} → ${command} is valid`, () => {
+      const result = sm.canTransition(state, command)
+      expect(result.valid).toBe(true)
+      expect(result.error).toBeUndefined()
+    })
+  }
+})
+
+// =============================================================================
+// canTransition - invalid transitions
+// =============================================================================
+
+describe('canTransition - invalid', () => {
+  const invalidTransitions: [WorkflowState, WorkflowCommand][] = [
+    ['idle', 'done'],
+    ['idle', 'pause'],
+    ['idle', 'resume'],
+    ['idle', 'ship'],
+    ['idle', 'reopen'],
+    ['working', 'task'],
+    ['working', 'ship'],
+    ['working', 'resume'],
+    ['working', 'next'],
+    ['working', 'reopen'],
+    ['paused', 'done'],
+    ['paused', 'pause'],
+    ['paused', 'reopen'],
+    ['shipped', 'done'],
+    ['shipped', 'pause'],
+    ['shipped', 'resume'],
+    ['shipped', 'ship'],
+    ['shipped', 'reopen'],
+  ]
+
+  for (const [state, command] of invalidTransitions) {
+    it(`${state} → ${command} is invalid`, () => {
+      const result = sm.canTransition(state, command)
+      expect(result.valid).toBe(false)
+      expect(result.error).toBeDefined()
+      expect(result.suggestion).toBeDefined()
+    })
+  }
+})
+
+// =============================================================================
+// getNextState
+// =============================================================================
+
+describe('getNextState', () => {
+  it('task → working', () => {
+    expect(sm.getNextState('idle', 'task')).toBe('working')
+    expect(sm.getNextState('paused', 'task')).toBe('working')
+    expect(sm.getNextState('completed', 'task')).toBe('working')
+  })
+
+  it('done → completed', () => {
+    expect(sm.getNextState('working', 'done')).toBe('completed')
+  })
+
+  it('pause → paused', () => {
+    expect(sm.getNextState('working', 'pause')).toBe('paused')
+    expect(sm.getNextState('completed', 'pause')).toBe('paused')
+  })
+
+  it('resume → working', () => {
+    expect(sm.getNextState('paused', 'resume')).toBe('working')
+  })
+
+  it('ship → shipped', () => {
+    expect(sm.getNextState('completed', 'ship')).toBe('shipped')
+    expect(sm.getNextState('paused', 'ship')).toBe('shipped')
+  })
+
+  it('reopen → working', () => {
+    expect(sm.getNextState('completed', 'reopen')).toBe('working')
+  })
+
+  it('next preserves current state', () => {
+    expect(sm.getNextState('idle', 'next')).toBe('idle')
+    expect(sm.getNextState('completed', 'next')).toBe('completed')
+  })
+})
+
+// =============================================================================
+// getValidCommands
+// =============================================================================
+
+describe('getValidCommands', () => {
+  it('idle allows task, next', () => {
+    expect(sm.getValidCommands('idle')).toEqual(['task', 'next'])
+  })
+
+  it('working allows done, pause', () => {
+    expect(sm.getValidCommands('working')).toEqual(['done', 'pause'])
+  })
+
+  it('paused allows resume, task, ship', () => {
+    expect(sm.getValidCommands('paused')).toEqual(['resume', 'task', 'ship'])
+  })
+
+  it('completed allows ship, task, next, pause, reopen', () => {
+    expect(sm.getValidCommands('completed')).toEqual(['ship', 'task', 'next', 'pause', 'reopen'])
+  })
+
+  it('shipped allows task, next', () => {
+    expect(sm.getValidCommands('shipped')).toEqual(['task', 'next'])
+  })
+})
+
+// =============================================================================
+// formatNextSteps
+// =============================================================================
+
+describe('formatNextSteps', () => {
+  it('includes reopen in completed state steps', () => {
+    const steps = sm.formatNextSteps('completed')
+    expect(steps.some((s) => s.includes('reopen'))).toBe(true)
+  })
+
+  it('includes ship in paused state steps', () => {
+    const steps = sm.formatNextSteps('paused')
+    expect(steps.some((s) => s.includes('ship'))).toBe(true)
+  })
+})

package/core/schemas/shipped.ts

@@ -56,7 +56,7 @@ export const ShippedItemSchema = z.object({
   type: ShipTypeSchema,
   agent: z.string().optional(), // "fe+be", "be", "fe"
   description: z.string().optional(),
-  changes: z.array(ShipChangeSchema),
+  changes: z.array(ShipChangeSchema).optional(),
   codeSnippets: z.array(z.string()).optional(),
   commit: CommitInfoSchema.optional(),
   codeMetrics: CodeMetricsSchema.optional(),
@@ -69,7 +69,7 @@ export const ShippedItemSchema = z.object({
 })
 
 export const ShippedJsonSchema = z.object({
-  items: z.array(ShippedItemSchema),
+  shipped: z.array(ShippedItemSchema),
   lastUpdated: z.string(),
 })
 
@@ -104,6 +104,6 @@ export const safeParseShipped = (data: unknown) => ShippedJsonSchema.safeParse(d
 // =============================================================================
 
 export const DEFAULT_SHIPPED: ShippedJson = {
-  items: [],
+  shipped: [],
   lastUpdated: '',
 }

package/core/schemas/state.ts

@@ -24,6 +24,7 @@ export const TaskStatusSchema = z.enum([
   'blocked',
   'paused',
   'failed',
+  'skipped',
 ])
 export const ActivityTypeSchema = z.enum([
   'task_completed',
@@ -59,6 +60,8 @@ export const SubtaskSchema = z.object({
   completedAt: z.string().optional(), // ISO8601
   output: z.string().optional(), // Brief output description
   summary: SubtaskSummarySchema.optional(), // Full summary for context handoff
+  skipReason: z.string().optional(), // Why this subtask was skipped
+  blockReason: z.string().optional(), // What is blocking this subtask
 })
 
 // Subtask progress tracking
@@ -94,7 +97,8 @@ export const PreviousTaskSchema = z.object({
 
 export const StateJsonSchema = z.object({
   currentTask: CurrentTaskSchema.nullable(),
-  previousTask: PreviousTaskSchema.nullable().optional(),
+  previousTask: PreviousTaskSchema.nullable().optional(), // deprecated: use pausedTasks
+  pausedTasks: z.array(PreviousTaskSchema).optional(), // replaces previousTask
   lastUpdated: z.string(),
 })
 
@@ -190,6 +194,7 @@ export const safeParseQueue = (data: unknown) => QueueJsonSchema.safeParse(data)
 
 export const DEFAULT_STATE: StateJson = {
   currentTask: null,
+  pausedTasks: [],
   lastUpdated: '',
 }
 

package/core/storage/ideas-storage.ts

@@ -6,13 +6,14 @@
  */
 
 import { generateUUID } from '../schemas'
+import { IdeasJsonSchema } from '../schemas/ideas'
 import type { Idea, IdeaPriority, IdeaStatus, IdeasJson } from '../types'
 import { getTimestamp, toRelative } from '../utils/date-helper'
 import { StorageManager } from './storage-manager'
 
 class IdeasStorage extends StorageManager<IdeasJson> {
   constructor() {
-    super('ideas.json')
+    super('ideas.json', IdeasJsonSchema)
   }
 
   protected getDefault(): IdeasJson {

package/core/storage/metrics-storage.ts

@@ -18,13 +18,14 @@ import {
   estimateCostSaved,
   formatCost,
   type MetricsJson,
+  MetricsJsonSchema,
 } from '../schemas/metrics'
 import { getTimestamp } from '../utils/date-helper'
 import { StorageManager } from './storage-manager'
 
 class MetricsStorage extends StorageManager<MetricsJson> {
   constructor() {
-    super('metrics.json')
+    super('metrics.json', MetricsJsonSchema)
   }
 
   protected getDefault(): MetricsJson {

package/core/storage/queue-storage.ts

@@ -7,12 +7,13 @@
 
 import { generateUUID } from '../schemas'
 import type { Priority, QueueJson, QueueTask, TaskSection } from '../schemas/state'
+import { QueueJsonSchema } from '../schemas/state'
 import { getTimestamp } from '../utils/date-helper'
 import { StorageManager } from './storage-manager'
 
 class QueueStorage extends StorageManager<QueueJson> {
   constructor() {
-    super('queue.json')
+    super('queue.json', QueueJsonSchema)
   }
 
   protected getDefault(): QueueJson {