prjct-cli 1.22.0 → 1.24.0

package/core/__tests__/agentic/memory-system.test.ts

@@ -1,281 +0,0 @@
-/**
- * Memory System Tests
- * P3.3: Semantic Memory Database
- */
-
-import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'bun:test'
-import fs from 'node:fs/promises'
-import path from 'node:path'
-import memorySystem from '../../agentic/memory-system'
-import pathManager from '../../infrastructure/path-manager'
-
-let testCounter = 0
-const getTestProjectId = () => `test-memory-${Date.now()}-${++testCounter}`
-
-describe('MemorySystem P3.3', () => {
-  let TEST_PROJECT_ID: string
-  const TEST_GLOBAL_BASE_DIR = path.join(process.cwd(), '.tmp', 'prjct-cli-tests')
-
-  beforeAll(async () => {
-    // Reason: In sandboxed test environments we can't write to "~/.prjct-cli".
-    pathManager.setGlobalBaseDir(TEST_GLOBAL_BASE_DIR)
-    await fs.mkdir(TEST_GLOBAL_BASE_DIR, { recursive: true })
-  })
-
-  beforeEach(() => {
-    TEST_PROJECT_ID = getTestProjectId()
-    memorySystem.resetState()
-  })
-
-  describe('createMemory', () => {
-    it('should create a memory with tags', async () => {
-      const memoryId = await memorySystem.createMemory(TEST_PROJECT_ID, {
-        title: 'Test Memory',
-        content: 'This is test content',
-        tags: ['code_style', 'naming_convention'],
-        userTriggered: true,
-      })
-
-      // UUID format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
-      expect(memoryId).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i)
-
-      const memories = await memorySystem.getAllMemories(TEST_PROJECT_ID)
-      expect(memories.length).toBe(1)
-      expect(memories[0].title).toBe('Test Memory')
-      expect(memories[0].tags).toContain('code_style')
-      expect(memories[0].userTriggered).toBe(true)
-    })
-  })
-
-  describe('updateMemory', () => {
-    it('should update memory content and tags', async () => {
-      const memoryId = await memorySystem.createMemory(TEST_PROJECT_ID, {
-        title: 'Original Title',
-        content: 'Original content',
-        tags: ['code_style'],
-      })
-
-      const updated = await memorySystem.updateMemory(TEST_PROJECT_ID, memoryId, {
-        title: 'Updated Title',
-        content: 'Updated content',
-        tags: ['naming_convention', 'architecture'],
-      })
-
-      expect(updated).toBe(true)
-
-      const memories = await memorySystem.getAllMemories(TEST_PROJECT_ID)
-      const memory = memories.find((m) => m.id === memoryId)
-
-      expect(memory!.title).toBe('Updated Title')
-      expect(memory!.content).toBe('Updated content')
-      expect(memory!.tags).toContain('architecture')
-      expect(memory!.tags).not.toContain('code_style')
-    })
-
-    it('should return false for non-existent memory', async () => {
-      const result = await memorySystem.updateMemory(TEST_PROJECT_ID, 'non_existent_id', {
-        title: 'New Title',
-      })
-      expect(result).toBe(false)
-    })
-  })
-
-  describe('deleteMemory', () => {
-    it('should delete a memory', async () => {
-      const memoryId = await memorySystem.createMemory(TEST_PROJECT_ID, {
-        title: 'To Delete',
-        content: 'Will be deleted',
-        tags: ['test'],
-      })
-
-      const deleted = await memorySystem.deleteMemory(TEST_PROJECT_ID, memoryId)
-      expect(deleted).toBe(true)
-
-      const memories = await memorySystem.getAllMemories(TEST_PROJECT_ID)
-      expect(memories.find((m) => m.id === memoryId)).toBeUndefined()
-    })
-  })
-
-  describe('findByTags', () => {
-    beforeEach(async () => {
-      await memorySystem.createMemory(TEST_PROJECT_ID, {
-        title: 'Memory 1',
-        content: 'Content 1',
-        tags: ['code_style', 'naming_convention'],
-      })
-      await memorySystem.createMemory(TEST_PROJECT_ID, {
-        title: 'Memory 2',
-        content: 'Content 2',
-        tags: ['architecture', 'naming_convention'],
-      })
-      await memorySystem.createMemory(TEST_PROJECT_ID, {
-        title: 'Memory 3',
-        content: 'Content 3',
-        tags: ['commit_style'],
-      })
-    })
-
-    it('should find memories with ANY tag (OR)', async () => {
-      const results = await memorySystem.findByTags(
-        TEST_PROJECT_ID,
-        ['code_style', 'architecture'],
-        false
-      )
-      expect(results.length).toBe(2)
-    })
-
-    it('should find memories with ALL tags (AND)', async () => {
-      const results = await memorySystem.findByTags(
-        TEST_PROJECT_ID,
-        ['naming_convention', 'architecture'],
-        true
-      )
-      expect(results.length).toBe(1)
-      expect(results[0].title).toBe('Memory 2')
-    })
-  })
-
-  describe('searchMemories', () => {
-    beforeEach(async () => {
-      await memorySystem.createMemory(TEST_PROJECT_ID, {
-        title: 'React Hooks Pattern',
-        content: 'Use custom hooks for reusable logic',
-        tags: ['code_style'],
-      })
-      await memorySystem.createMemory(TEST_PROJECT_ID, {
-        title: 'API Design',
-        content: 'REST endpoints follow /api/v1 pattern',
-        tags: ['architecture'],
-      })
-    })
-
-    it('should search by title', async () => {
-      const results = await memorySystem.searchMemories(TEST_PROJECT_ID, 'React')
-      expect(results.length).toBe(1)
-      expect(results[0].title).toContain('React')
-    })
-
-    it('should search by content', async () => {
-      const results = await memorySystem.searchMemories(TEST_PROJECT_ID, 'endpoints')
-      expect(results.length).toBe(1)
-      expect(results[0].content).toContain('endpoints')
-    })
-
-    it('should be case insensitive', async () => {
-      const results = await memorySystem.searchMemories(TEST_PROJECT_ID, 'HOOKS')
-      expect(results.length).toBe(1)
-    })
-  })
-
-  describe('getRelevantMemories', () => {
-    beforeEach(async () => {
-      await memorySystem.createMemory(TEST_PROJECT_ID, {
-        title: 'Commit Style',
-        content: 'Use conventional commits',
-        tags: ['commit_style', 'ship_workflow'],
-        userTriggered: true,
-      })
-      await memorySystem.createMemory(TEST_PROJECT_ID, {
-        title: 'Test Behavior',
-        content: 'Run tests before shipping',
-        tags: ['test_behavior', 'ship_workflow'],
-      })
-      await memorySystem.createMemory(TEST_PROJECT_ID, {
-        title: 'Code Style',
-        content: 'Use TypeScript strict mode',
-        tags: ['code_style'],
-      })
-    })
-
-    it('should return memories relevant to ship command', async () => {
-      const context = { commandName: 'ship', params: {} }
-      const results = await memorySystem.getRelevantMemories(TEST_PROJECT_ID, context, 5)
-
-      expect(results.length).toBeGreaterThan(0)
-      const hasRelevantTags = results.some(
-        (m) => m.tags.includes('commit_style') || m.tags.includes('ship_workflow')
-      )
-      expect(hasRelevantTags).toBe(true)
-    })
-
-    it('should prioritize user triggered memories', async () => {
-      const context = { commandName: 'ship', params: {} }
-      const results = await memorySystem.getRelevantMemories(TEST_PROJECT_ID, context, 5)
-
-      const userTriggeredIndex = results.findIndex((m) => m.userTriggered)
-      expect(userTriggeredIndex).toBeLessThanOrEqual(1)
-    })
-
-    it('should limit results', async () => {
-      const context = { commandName: 'ship', params: {} }
-      const results = await memorySystem.getRelevantMemories(TEST_PROJECT_ID, context, 1)
-      expect(results.length).toBeLessThanOrEqual(1)
-    })
-  })
-
-  describe('autoRemember', () => {
-    it('should create memory from user decision', async () => {
-      await memorySystem.autoRemember(
-        TEST_PROJECT_ID,
-        'commit_footer',
-        'prjct',
-        'User chose prjct footer'
-      )
-
-      const memories = await memorySystem.getAllMemories(TEST_PROJECT_ID)
-      expect(memories.length).toBe(1)
-      expect(memories[0].content).toContain('commit_footer: prjct')
-      expect(memories[0].tags).toContain('commit_style')
-      expect(memories[0].userTriggered).toBe(true)
-    })
-
-    it('should update existing memory instead of creating duplicate', async () => {
-      await memorySystem.autoRemember(TEST_PROJECT_ID, 'commit_footer', 'prjct', 'First choice')
-      await memorySystem.autoRemember(TEST_PROJECT_ID, 'commit_footer', 'claude', 'Changed mind')
-
-      const memories = await memorySystem.getAllMemories(TEST_PROJECT_ID)
-      expect(memories.length).toBe(1)
-      expect(memories[0].content).toContain('commit_footer: claude')
-    })
-  })
-
-  describe('getMemoryStats', () => {
-    it('should return memory statistics', async () => {
-      await memorySystem.createMemory(TEST_PROJECT_ID, {
-        title: 'Memory 1',
-        content: 'Content 1',
-        tags: ['code_style'],
-        userTriggered: true,
-      })
-      await memorySystem.createMemory(TEST_PROJECT_ID, {
-        title: 'Memory 2',
-        content: 'Content 2',
-        tags: ['code_style', 'architecture'],
-      })
-
-      const stats = await memorySystem.getMemoryStats(TEST_PROJECT_ID)
-
-      expect(stats.totalMemories).toBe(2)
-      expect(stats.userTriggered).toBe(1)
-      expect(stats.tagCounts.code_style).toBe(2)
-      expect(stats.tagCounts.architecture).toBe(1)
-    })
-  })
-
-  afterEach(async () => {
-    try {
-      const testPath = pathManager.getGlobalProjectPath(TEST_PROJECT_ID)
-      await fs.rm(testPath, { recursive: true, force: true })
-    } catch (_error) {
-      // Ignore cleanup errors
-    }
-  })
-
-  afterAll(async () => {
-    try {
-      await fs.rm(TEST_GLOBAL_BASE_DIR, { recursive: true, force: true })
-    } catch (_error) {
-      // Ignore cleanup errors
-    }
-  })
-})

package/core/__tests__/agentic/plan-mode.test.ts

@@ -1,386 +0,0 @@
-/**
- * Plan Mode Tests
- * P3.4: Plan Mode + Approval Flow
- */
-
-import { beforeEach, describe, expect, it } from 'bun:test'
-import planMode, { PLAN_STATUS } from '../../agentic/plan-mode'
-import type { ApprovalContext, ProposedPlan } from '../../types'
-
-// Helper to create complete ProposedPlan objects
-const createPlan = (overrides: Partial<ProposedPlan> = {}): ProposedPlan => ({
-  summary: 'Test summary',
-  approach: 'Test approach',
-  steps: [],
-  affectedFiles: [],
-  ...overrides,
-})
-
-// Helper to create complete ApprovalContext objects
-const createApprovalContext = (overrides: Partial<ApprovalContext> = {}): ApprovalContext => ({
-  changedFiles: [],
-  filesToDelete: [],
-  operation: 'modify_files',
-  warnings: [],
-  ...overrides,
-})
-
-describe('PlanMode P3.4', () => {
-  const TEST_PROJECT_ID = 'test-plan-mode'
-
-  beforeEach(() => {
-    planMode.activePlans.clear()
-  })
-
-  describe('requiresPlanning', () => {
-    it('should return true for feature command', () => {
-      expect(planMode.requiresPlanning('feature')).toBe(true)
-    })
-
-    it('should return true for spec command', () => {
-      expect(planMode.requiresPlanning('spec')).toBe(true)
-    })
-
-    it('should return false for now command', () => {
-      expect(planMode.requiresPlanning('now')).toBe(false)
-    })
-
-    it('should return false for done command', () => {
-      expect(planMode.requiresPlanning('done')).toBe(false)
-    })
-  })
-
-  describe('isDestructive', () => {
-    it('should return true for ship command', () => {
-      expect(planMode.isDestructive('ship')).toBe(true)
-    })
-
-    it('should return true for cleanup command', () => {
-      expect(planMode.isDestructive('cleanup')).toBe(true)
-    })
-
-    it('should return false for feature command', () => {
-      expect(planMode.isDestructive('feature')).toBe(false)
-    })
-  })
-
-  describe('isToolAllowedInPlanning', () => {
-    it('should allow Read in planning mode', () => {
-      expect(planMode.isToolAllowedInPlanning('Read')).toBe(true)
-    })
-
-    it('should allow Glob in planning mode', () => {
-      expect(planMode.isToolAllowedInPlanning('Glob')).toBe(true)
-    })
-
-    it('should not allow Write in planning mode', () => {
-      expect(planMode.isToolAllowedInPlanning('Write')).toBe(false)
-    })
-
-    it('should not allow Bash in planning mode', () => {
-      expect(planMode.isToolAllowedInPlanning('Bash')).toBe(false)
-    })
-  })
-
-  describe('getAllowedTools', () => {
-    it('should filter to read-only tools in planning mode', () => {
-      const templateTools = ['Read', 'Write', 'Glob', 'Bash', 'Grep']
-      const allowed = planMode.getAllowedTools(true, templateTools)
-
-      expect(allowed).toContain('Read')
-      expect(allowed).toContain('Glob')
-      expect(allowed).toContain('Grep')
-      expect(allowed).not.toContain('Write')
-      expect(allowed).not.toContain('Bash')
-    })
-
-    it('should return all template tools when not in planning mode', () => {
-      const templateTools = ['Read', 'Write', 'Glob', 'Bash']
-      const allowed = planMode.getAllowedTools(false, templateTools)
-
-      expect(allowed).toEqual(templateTools)
-    })
-  })
-
-  describe('startPlanning', () => {
-    it('should create a new plan with correct initial state', () => {
-      const plan = planMode.startPlanning(TEST_PROJECT_ID, 'feature', {
-        description: 'Add dark mode',
-      })
-
-      // UUID format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
-      expect(plan.id).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i)
-      expect(plan.projectId).toBe(TEST_PROJECT_ID)
-      expect(plan.command).toBe('feature')
-      expect(plan.status).toBe(PLAN_STATUS.GATHERING)
-      expect(plan.gatheredInfo).toEqual([])
-    })
-
-    it('should store plan in activePlans', () => {
-      planMode.startPlanning(TEST_PROJECT_ID, 'feature', {})
-
-      expect(planMode.getActivePlan(TEST_PROJECT_ID)).not.toBeNull()
-    })
-  })
-
-  describe('isInPlanningMode', () => {
-    it('should return true when gathering info', () => {
-      planMode.startPlanning(TEST_PROJECT_ID, 'feature', {})
-
-      expect(planMode.isInPlanningMode(TEST_PROJECT_ID)).toBe(true)
-    })
-
-    it('should return true when pending approval', () => {
-      planMode.startPlanning(TEST_PROJECT_ID, 'feature', {})
-      planMode.proposePlan(TEST_PROJECT_ID, createPlan())
-
-      expect(planMode.isInPlanningMode(TEST_PROJECT_ID)).toBe(true)
-    })
-
-    it('should return false when no active plan', () => {
-      expect(planMode.isInPlanningMode('non-existent-project')).toBe(false)
-    })
-
-    it('should return false when plan is executing', () => {
-      planMode.startPlanning(TEST_PROJECT_ID, 'feature', {})
-      planMode.proposePlan(TEST_PROJECT_ID, createPlan({ steps: [{ description: 'Step 1' }] }))
-      planMode.approvePlan(TEST_PROJECT_ID)
-      planMode.startExecution(TEST_PROJECT_ID)
-
-      expect(planMode.isInPlanningMode(TEST_PROJECT_ID)).toBe(false)
-    })
-  })
-
-  describe('recordGatheredInfo', () => {
-    it('should add info to gatheredInfo array', () => {
-      planMode.startPlanning(TEST_PROJECT_ID, 'feature', {})
-      planMode.recordGatheredInfo(TEST_PROJECT_ID, {
-        type: 'file_content',
-        source: 'src/index.js',
-        data: 'content',
-        gatheredAt: new Date().toISOString(),
-      })
-
-      const plan = planMode.getActivePlan(TEST_PROJECT_ID)
-      expect(plan!.gatheredInfo.length).toBe(1)
-      expect(plan!.gatheredInfo[0].type).toBe('file_content')
-    })
-  })
-
-  describe('proposePlan', () => {
-    it('should set status to pending approval', () => {
-      planMode.startPlanning(TEST_PROJECT_ID, 'feature', {})
-      planMode.proposePlan(
-        TEST_PROJECT_ID,
-        createPlan({
-          summary: 'Add dark mode feature',
-          approach: 'CSS variables with theme context',
-          steps: [{ description: 'Create theme context' }, { description: 'Add toggle' }],
-        })
-      )
-
-      const plan = planMode.getActivePlan(TEST_PROJECT_ID)
-      expect(plan!.status).toBe(PLAN_STATUS.PENDING_APPROVAL)
-    })
-
-    it('should return formatted plan for display', () => {
-      planMode.startPlanning(TEST_PROJECT_ID, 'feature', {})
-      const formatted = planMode.proposePlan(
-        TEST_PROJECT_ID,
-        createPlan({
-          summary: 'Test plan',
-          approach: 'Test approach',
-          steps: [{ description: 'Step 1' }],
-        })
-      )
-
-      expect(formatted!.summary).toBe('Test plan')
-      expect(formatted!.approach).toBe('Test approach')
-      expect(formatted!.requiresConfirmation).toBe(true)
-    })
-  })
-
-  describe('approvePlan', () => {
-    it('should change status to approved', () => {
-      planMode.startPlanning(TEST_PROJECT_ID, 'feature', {})
-      planMode.proposePlan(TEST_PROJECT_ID, createPlan({ steps: [{ description: 'Step 1' }] }))
-      const result = planMode.approvePlan(TEST_PROJECT_ID)
-
-      expect(result!.approved).toBe(true)
-      const plan = planMode.getActivePlan(TEST_PROJECT_ID)
-      expect(plan!.status).toBe(PLAN_STATUS.APPROVED)
-    })
-
-    it('should convert proposed steps to executable steps', () => {
-      planMode.startPlanning(TEST_PROJECT_ID, 'feature', {})
-      planMode.proposePlan(
-        TEST_PROJECT_ID,
-        createPlan({
-          steps: [{ description: 'Step 1' }, { description: 'Step 2' }],
-        })
-      )
-      const result = planMode.approvePlan(TEST_PROJECT_ID)
-
-      expect(result!.steps.length).toBe(2)
-      expect(result!.steps[0].status).toBe('pending')
-    })
-
-    it('should return null if not pending approval', () => {
-      planMode.startPlanning(TEST_PROJECT_ID, 'feature', {})
-      const result = planMode.approvePlan(TEST_PROJECT_ID)
-
-      expect(result).toBeNull()
-    })
-  })
-
-  describe('rejectPlan', () => {
-    it('should mark plan as rejected', () => {
-      planMode.startPlanning(TEST_PROJECT_ID, 'feature', {})
-      planMode.proposePlan(TEST_PROJECT_ID, createPlan())
-      const result = planMode.rejectPlan(TEST_PROJECT_ID, 'Not the right approach')
-
-      expect(result!.rejected).toBe(true)
-      expect(result!.reason).toBe('Not the right approach')
-    })
-
-    it('should clear active plan after rejection', () => {
-      planMode.startPlanning(TEST_PROJECT_ID, 'feature', {})
-      planMode.proposePlan(TEST_PROJECT_ID, createPlan())
-      planMode.rejectPlan(TEST_PROJECT_ID)
-
-      expect(planMode.getActivePlan(TEST_PROJECT_ID)).toBeNull()
-    })
-  })
-
-  describe('execution flow', () => {
-    beforeEach(() => {
-      planMode.startPlanning(TEST_PROJECT_ID, 'feature', {})
-      planMode.proposePlan(
-        TEST_PROJECT_ID,
-        createPlan({
-          steps: [
-            { description: 'Step 1', tool: 'Write' },
-            { description: 'Step 2', tool: 'Bash' },
-          ],
-        })
-      )
-      planMode.approvePlan(TEST_PROJECT_ID)
-    })
-
-    it('should start execution and return first step', () => {
-      const step = planMode.startExecution(TEST_PROJECT_ID)
-
-      expect(step!.stepNumber).toBe(1)
-      expect(step!.totalSteps).toBe(2)
-      expect(step!.progress).toBe(0)
-    })
-
-    it('should advance to next step on completion', () => {
-      planMode.startExecution(TEST_PROJECT_ID)
-      const nextStep = planMode.completeStep(TEST_PROJECT_ID, { success: true })
-
-      expect(nextStep!.stepNumber).toBe(2)
-      expect(nextStep!.progress).toBe(50)
-    })
-
-    it('should complete plan when all steps done', () => {
-      planMode.startExecution(TEST_PROJECT_ID)
-      planMode.completeStep(TEST_PROJECT_ID)
-      const result = planMode.completeStep(TEST_PROJECT_ID)
-
-      expect(result).toBeNull()
-      expect(planMode.getActivePlan(TEST_PROJECT_ID)).toBeNull()
-    })
-  })
-
-  describe('abortPlan', () => {
-    it('should abort and clear active plan', () => {
-      planMode.startPlanning(TEST_PROJECT_ID, 'feature', {})
-      planMode.proposePlan(TEST_PROJECT_ID, createPlan({ steps: [{ description: 'Step 1' }] }))
-      planMode.approvePlan(TEST_PROJECT_ID)
-      planMode.startExecution(TEST_PROJECT_ID)
-
-      const result = planMode.abortPlan(TEST_PROJECT_ID, 'User cancelled')
-
-      expect(result!.aborted).toBe(true)
-      expect(result!.reason).toBe('User cancelled')
-      expect(planMode.getActivePlan(TEST_PROJECT_ID)).toBeNull()
-    })
-  })
-
-  describe('generateApprovalPrompt', () => {
-    it('should generate ship approval prompt', () => {
-      const prompt = planMode.generateApprovalPrompt(
-        'ship',
-        createApprovalContext({
-          branch: 'feature/dark-mode',
-          changedFiles: [
-            { path: 'a.js', action: 'modify' },
-            { path: 'b.js', action: 'modify' },
-          ],
-          commitMessage: 'Add dark mode',
-          operation: 'git_push',
-        })
-      )
-
-      expect(prompt.title).toBe('Ship Confirmation')
-      expect(prompt.details).toContain('Branch: feature/dark-mode')
-      expect(prompt.options.length).toBe(3)
-    })
-
-    it('should generate cleanup approval prompt', () => {
-      const prompt = planMode.generateApprovalPrompt(
-        'cleanup',
-        createApprovalContext({
-          filesToDelete: ['temp.js'],
-          linesOfCode: 50,
-          operation: 'delete_files',
-        })
-      )
-
-      expect(prompt.title).toBe('Cleanup Confirmation')
-      expect(prompt.message).toContain('delete')
-    })
-
-    it('should generate default prompt for unknown commands', () => {
-      const prompt = planMode.generateApprovalPrompt('unknown', createApprovalContext())
-
-      expect(prompt.title).toBe('Confirmation Required')
-      expect(prompt.options.length).toBe(2)
-    })
-  })
-
-  describe('formatStatus', () => {
-    it('should format gathering status', () => {
-      planMode.startPlanning(TEST_PROJECT_ID, 'feature', {})
-      const status = planMode.formatStatus(TEST_PROJECT_ID)
-
-      expect(status).toContain('🔍')
-      expect(status).toContain('feature')
-      expect(status).toContain('gathering')
-    })
-
-    it('should show progress during execution', () => {
-      planMode.startPlanning(TEST_PROJECT_ID, 'feature', {})
-      planMode.proposePlan(
-        TEST_PROJECT_ID,
-        createPlan({
-          steps: [{ description: 'Step 1' }, { description: 'Step 2' }],
-        })
-      )
-      planMode.approvePlan(TEST_PROJECT_ID)
-      planMode.startExecution(TEST_PROJECT_ID)
-
-      const status = planMode.formatStatus(TEST_PROJECT_ID)
-
-      expect(status).toContain('⚡')
-      expect(status).toContain('Progress')
-    })
-
-    it('should return message for no active plan', () => {
-      const status = planMode.formatStatus('non-existent')
-
-      expect(status).toBe('No active plan')
-    })
-  })
-})