@soleri/core 9.3.0 → 9.4.0

package/src/packs/index.ts

@@ -4,7 +4,9 @@
 
 export {
   packManifestSchema,
+  PACK_TIERS,
   type PackManifest,
+  type PackTier as ManifestPackTier,
   type PackStatus,
   type InstalledPack,
   type InstallResult,
@@ -14,7 +16,7 @@ export {
 export { PackInstaller } from './pack-installer.js';
 
 export { PackLockfile, inferPackType } from './lockfile.js';
-export type { LockEntry, PackType, PackSource, LockfileData } from './lockfile.js';
+export type { LockEntry, PackType, PackSource, PackTier, LockfileData } from './lockfile.js';
 
 export { resolvePack, checkNpmVersion, checkVersionCompat } from './resolver.js';
 export type { ResolvedPack, ResolveOptions } from './resolver.js';

package/src/packs/lockfile.ts

@@ -39,10 +39,13 @@ export interface LockEntry {
   facadesRegistered: boolean;
   /** Compatible @soleri/core version range (from manifest "soleri" field) */
   soleriRange?: string;
+  /** Pack tier: default (ships with engine), community (free), premium (unlocked today) */
+  tier?: PackTier;
 }
 
 export type PackType = 'hooks' | 'skills' | 'knowledge' | 'domain' | 'bundle';
 export type PackSource = 'built-in' | 'local' | 'npm';
+export type PackTier = 'default' | 'community' | 'premium';
 
 export interface LockfileData {
   /** Lockfile format version */

package/src/packs/types.ts

@@ -23,11 +23,20 @@ import { z } from 'zod';
 // MANIFEST SCHEMA
 // =============================================================================
 
+// ---------------------------------------------------------------------------
+// Pack Tiers — determines visibility, licensing, and install behavior
+// ---------------------------------------------------------------------------
+
+export const PACK_TIERS = ['default', 'community', 'premium'] as const;
+export type PackTier = (typeof PACK_TIERS)[number];
+
 export const packManifestSchema = z.object({
   id: z.string().regex(/^[a-z0-9-]+$/, 'Pack ID must be lowercase alphanumeric with hyphens'),
   name: z.string().min(1),
   version: z.string().regex(/^\d+\.\d+\.\d+$/, 'Version must be semver (x.y.z)'),
   description: z.string().optional().default(''),
+  /** Pack tier: 'default' (ships with engine), 'community' (free, npm), 'premium' (unlocked today, gated later) */
+  tier: z.enum(PACK_TIERS).optional().default('community'),
   /** Domains this pack covers */
   domains: z.array(z.string()).optional().default([]),
   /** Minimum engine version required (semver range) */

package/src/planning/plan-lifecycle.ts

@@ -232,7 +232,13 @@ export interface IterateChanges {
   objective?: string;
   scope?: string;
   decisions?: (string | PlanDecision)[];
-  addTasks?: Array<{ title: string; description: string }>;
+  addTasks?: Array<{
+    title: string;
+    description: string;
+    phase?: string;
+    milestone?: string;
+    parentTaskId?: string;
+  }>;
   removeTasks?: string[];
   approach?: string;
   context?: string;
@@ -240,26 +246,61 @@ export interface IterateChanges {
   tool_chain?: string[];
   flow?: string;
   target_mode?: string;
+  alternatives?: import('./planner-types.js').PlanAlternative[];
 }
 
 /**
  * Apply iteration changes to a plan (mutates in place).
  * Caller is responsible for status validation and persistence.
+ * Returns the number of fields actually mutated (0 = no-op).
  */
-export function applyIteration(plan: Plan, changes: IterateChanges): void {
+export function applyIteration(plan: Plan, changes: IterateChanges): number {
   const now = Date.now();
-  if (changes.objective !== undefined) plan.objective = changes.objective;
-  if (changes.scope !== undefined) plan.scope = changes.scope;
-  if (changes.decisions !== undefined) plan.decisions = changes.decisions;
-  if (changes.approach !== undefined) plan.approach = changes.approach;
-  if (changes.context !== undefined) plan.context = changes.context;
-  if (changes.success_criteria !== undefined) plan.success_criteria = changes.success_criteria;
-  if (changes.tool_chain !== undefined) plan.tool_chain = changes.tool_chain;
-  if (changes.flow !== undefined) plan.flow = changes.flow;
-  if (changes.target_mode !== undefined) plan.target_mode = changes.target_mode;
+  let mutated = 0;
+  if (changes.objective !== undefined) {
+    plan.objective = changes.objective;
+    mutated++;
+  }
+  if (changes.scope !== undefined) {
+    plan.scope = changes.scope;
+    mutated++;
+  }
+  if (changes.decisions !== undefined) {
+    plan.decisions = changes.decisions;
+    mutated++;
+  }
+  if (changes.approach !== undefined) {
+    plan.approach = changes.approach;
+    mutated++;
+  }
+  if (changes.context !== undefined) {
+    plan.context = changes.context;
+    mutated++;
+  }
+  if (changes.success_criteria !== undefined) {
+    plan.success_criteria = changes.success_criteria;
+    mutated++;
+  }
+  if (changes.tool_chain !== undefined) {
+    plan.tool_chain = changes.tool_chain;
+    mutated++;
+  }
+  if (changes.flow !== undefined) {
+    plan.flow = changes.flow;
+    mutated++;
+  }
+  if (changes.target_mode !== undefined) {
+    plan.target_mode = changes.target_mode;
+    mutated++;
+  }
+  if (changes.alternatives !== undefined) {
+    plan.alternatives = changes.alternatives;
+    mutated++;
+  }
   if (changes.removeTasks?.length) {
     const removeSet = new Set(changes.removeTasks);
     plan.tasks = plan.tasks.filter((t) => !removeSet.has(t.id));
+    mutated++;
   }
   if (changes.addTasks?.length) {
     const maxIndex = plan.tasks.reduce((max, t) => {
@@ -267,16 +308,24 @@ export function applyIteration(plan: Plan, changes: IterateChanges): void {
       return isNaN(num) ? max : Math.max(max, num);
     }, 0);
     for (let i = 0; i < changes.addTasks.length; i++) {
+      const t = changes.addTasks[i];
       plan.tasks.push({
         id: `task-${maxIndex + i + 1}`,
-        title: changes.addTasks[i].title,
-        description: changes.addTasks[i].description,
+        title: t.title,
+        description: t.description,
         status: 'pending' as TaskStatus,
+        ...(t.phase !== undefined && { phase: t.phase }),
+        ...(t.milestone !== undefined && { milestone: t.milestone }),
+        ...(t.parentTaskId !== undefined && { parentTaskId: t.parentTaskId }),
         updatedAt: now,
       });
     }
+    mutated++;
   }
-  plan.updatedAt = now;
+  if (mutated > 0) {
+    plan.updatedAt = now;
+  }
+  return mutated;
 }
 
 /**
@@ -308,7 +357,13 @@ export function createPlanObject(params: {
   objective: string;
   scope: string;
   decisions?: (string | PlanDecision)[];
-  tasks?: Array<{ title: string; description: string }>;
+  tasks?: Array<{
+    title: string;
+    description: string;
+    phase?: string;
+    milestone?: string;
+    parentTaskId?: string;
+  }>;
   approach?: string;
   context?: string;
   success_criteria?: string[];
@@ -325,13 +380,7 @@ export function createPlanObject(params: {
     scope: params.scope,
     status: params.initialStatus ?? 'draft',
     decisions: params.decisions ?? [],
-    tasks: (params.tasks ?? []).map((t, i) => ({
-      id: `task-${i + 1}`,
-      title: t.title,
-      description: t.description,
-      status: 'pending' as TaskStatus,
-      updatedAt: now,
-    })),
+    tasks: (params.tasks ?? []).map((t, i) => (Object.assign({id:`task-${i+1}`,title:t.title,description:t.description,status:`pending` as TaskStatus}, t.phase!==undefined&&{phase:t.phase}, t.milestone!==undefined&&{milestone:t.milestone}, t.parentTaskId!==undefined&&{parentTaskId:t.parentTaskId}, {updatedAt:now}))),
     ...(params.approach !== undefined && { approach: params.approach }),
     ...(params.context !== undefined && { context: params.context }),
     ...(params.success_criteria !== undefined && { success_criteria: params.success_criteria }),
@@ -352,6 +401,9 @@ export function applySplitTasks(
     description: string;
     dependsOn?: string[];
     acceptanceCriteria?: string[];
+    phase?: string;
+    milestone?: string;
+    parentTaskId?: string;
   }>,
 ): void {
   const now = Date.now();
@@ -362,6 +414,9 @@ export function applySplitTasks(
     status: 'pending' as TaskStatus,
     dependsOn: t.dependsOn,
     ...(t.acceptanceCriteria && { acceptanceCriteria: t.acceptanceCriteria }),
+    ...(t.phase !== undefined && { phase: t.phase }),
+    ...(t.milestone !== undefined && { milestone: t.milestone }),
+    ...(t.parentTaskId !== undefined && { parentTaskId: t.parentTaskId }),
     updatedAt: now,
   }));
   const taskIds = new Set(plan.tasks.map((t) => t.id));
@@ -372,6 +427,9 @@ export function applySplitTasks(
           throw new Error(`Task '${task.id}' depends on unknown task '${dep}'`);
       }
     }
+    if (task.parentTaskId && !taskIds.has(task.parentTaskId)) {
+      throw new Error(`Task '${task.id}' references unknown parent task '${task.parentTaskId}'`);
+    }
   }
   plan.updatedAt = now;
 }

package/src/planning/planner-types.ts

@@ -66,6 +66,12 @@ export interface PlanTask {
   status: TaskStatus;
   /** Optional dependency IDs — tasks that must complete before this one. */
   dependsOn?: string[];
+  /** Phase this task belongs to (e.g., "wave-1", "discovery", "implementation"). */
+  phase?: string;
+  /** Milestone this task contributes to (e.g., "v1.0", "mvp", "beta"). */
+  milestone?: string;
+  /** Parent task ID — enables sub-task hierarchy within a plan. */
+  parentTaskId?: string;
   /** Evidence submitted for task acceptance criteria. */
   evidence?: TaskEvidence[];
   /** Whether this task has been verified (all evidence checked + reviews passed). */

package/src/planning/planner.ts

@@ -235,15 +235,17 @@ export class Planner {
     );
   }
 
-  iterate(planId: string, changes: IterateChanges): Plan {
+  iterate(planId: string, changes: IterateChanges): { plan: Plan; mutated: number } {
     const plan = this.requirePlan(planId);
     if (plan.status !== 'draft' && plan.status !== 'brainstorming')
       throw new Error(
         `Cannot iterate plan in '${plan.status}' status — must be 'draft' or 'brainstorming'`,
       );
-    applyIteration(plan, changes);
-    this.save();
-    return plan;
+    const mutated = applyIteration(plan, changes);
+    if (mutated > 0) {
+      this.save();
+    }
+    return { plan, mutated };
   }
 
   splitTasks(
@@ -253,6 +255,9 @@ export class Planner {
       description: string;
       dependsOn?: string[];
       acceptanceCriteria?: string[];
+      phase?: string;
+      milestone?: string;
+      parentTaskId?: string;
     }>,
   ): Plan {
     const plan = this.requirePlan(planId);
@@ -445,6 +450,71 @@ export class Planner {
     return toArchive;
   }
 
+  /**
+   * Close stale plans — plans in non-terminal states older than the given threshold.
+   * For draft/approved: uses 30 min TTL by default.
+   * For executing/reconciling: uses olderThanMs parameter (24h default).
+   * Returns the list of closed plan IDs.
+   */
+  closeStale(olderThanMs?: number): {
+    closedIds: string[];
+    closedPlans: Array<{ id: string; previousStatus: string; reason: string }>;
+  } {
+    const now = Date.now();
+    const forceAll = olderThanMs === 0;
+    const defaultTtl = forceAll ? 0 : 30 * 60 * 1000; // 30 minutes for draft/approved
+    const executingTtl = forceAll ? 0 : (olderThanMs ?? 24 * 60 * 60 * 1000); // 24h default for executing/reconciling
+    const closed: Array<{ id: string; previousStatus: string; reason: string }> = [];
+
+    for (const plan of this.store.plans) {
+      // Skip terminal states
+      if (plan.status === 'completed' || plan.status === 'archived') continue;
+
+      const age = now - plan.updatedAt;
+      let shouldClose = false;
+      let reason = '';
+
+      if (plan.status === 'draft' || plan.status === 'approved') {
+        // Short TTL for draft/approved — these should move quickly
+        if (age >= defaultTtl) {
+          shouldClose = true;
+          reason = `ttl-expired (${plan.status}, age: ${Math.round(age / 60000)}min)`;
+        }
+      } else if (
+        plan.status === 'executing' ||
+        plan.status === 'validating' ||
+        plan.status === 'reconciling' ||
+        plan.status === 'brainstorming'
+      ) {
+        // Longer TTL for active states
+        if (age >= executingTtl) {
+          shouldClose = true;
+          reason = `stale-closed (${plan.status}, age: ${Math.round(age / 3600000)}h)`;
+        }
+      }
+
+      if (shouldClose) {
+        const previousStatus = plan.status;
+        // Force transition to completed (bypass FSM since these are stale)
+        plan.status = 'completed';
+        plan.updatedAt = now;
+        if (!plan.reconciliation) {
+          plan.reconciliation = {
+            planId: plan.id,
+            accuracy: 0,
+            driftItems: [],
+            summary: `Auto-closed: ${reason}`,
+            reconciledAt: now,
+          };
+        }
+        closed.push({ id: plan.id, previousStatus, reason });
+      }
+    }
+
+    if (closed.length > 0) this.save();
+    return { closedIds: closed.map((c) => c.id), closedPlans: closed };
+  }
+
   stats(): {
     total: number;
     byStatus: Record<PlanStatus, number>;

package/src/planning/task-complexity-assessor.test.ts

@@ -0,0 +1,302 @@
+import { describe, it, expect } from 'vitest';
+import {
+  assessTaskComplexity,
+  type AssessmentInput,
+  type AssessmentResult,
+} from './task-complexity-assessor.js';
+
+// ─── Helpers ────────────────────────────────────────────────────────
+
+function assess(partial: Partial<AssessmentInput> & { prompt: string }): AssessmentResult {
+  return assessTaskComplexity(partial);
+}
+
+function signalByName(result: AssessmentResult, name: string) {
+  return result.signals.find((s) => s.name === name);
+}
+
+// ─── Simple Tasks ───────────────────────────────────────────────────
+
+describe('assessTaskComplexity — simple tasks', () => {
+  it('classifies "rename variable X" as simple', () => {
+    const result = assess({ prompt: 'rename variable X to Y' });
+    expect(result.classification).toBe('simple');
+    expect(result.score).toBeLessThan(40);
+  });
+
+  it('classifies "fix typo in README" as simple', () => {
+    const result = assess({ prompt: 'fix typo in README' });
+    expect(result.classification).toBe('simple');
+    expect(result.score).toBeLessThan(40);
+  });
+
+  it('classifies "add CSS class" as simple', () => {
+    const result = assess({ prompt: 'add CSS class to the header' });
+    expect(result.classification).toBe('simple');
+    expect(result.score).toBeLessThan(40);
+  });
+
+  it('classifies single-file estimate as simple', () => {
+    const result = assess({ prompt: 'update button color', filesEstimated: 1 });
+    expect(result.classification).toBe('simple');
+    expect(signalByName(result, 'file-count')!.triggered).toBe(false);
+  });
+
+  it('classifies task with 2 files as simple', () => {
+    const result = assess({ prompt: 'update two files', filesEstimated: 2 });
+    expect(result.classification).toBe('simple');
+    expect(signalByName(result, 'file-count')!.triggered).toBe(false);
+  });
+});
+
+// ─── Complex Tasks ──────────────────────────────────────────────────
+
+describe('assessTaskComplexity — complex tasks', () => {
+  it('classifies "add authentication" touching multiple files as complex', () => {
+    const result = assess({ prompt: 'add authentication to the API', filesEstimated: 4 });
+    expect(result.classification).toBe('complex');
+    expect(result.score).toBeGreaterThanOrEqual(40);
+  });
+
+  it('classifies "refactor the vault module" as complex via cross-cutting when combined with files', () => {
+    const result = assess({ prompt: 'refactor across the vault module', filesEstimated: 5 });
+    expect(result.classification).toBe('complex');
+    expect(result.score).toBeGreaterThanOrEqual(40);
+  });
+
+  it('classifies "migrate database schema" touching multiple files as complex', () => {
+    const result = assess({ prompt: 'migrate database schema to v2', filesEstimated: 3 });
+    expect(result.classification).toBe('complex');
+    expect(signalByName(result, 'cross-cutting-keywords')!.triggered).toBe(true);
+    expect(signalByName(result, 'file-count')!.triggered).toBe(true);
+  });
+
+  it('classifies many-file task with design decision as complex', () => {
+    const result = assess({
+      prompt: 'how should we update styles across the app',
+      filesEstimated: 5,
+    });
+    expect(result.classification).toBe('complex');
+    expect(result.score).toBeGreaterThanOrEqual(40);
+    expect(signalByName(result, 'file-count')!.triggered).toBe(true);
+  });
+
+  it('classifies task with design decision as complex', () => {
+    const result = assess({
+      prompt: 'how should we structure the new cache layer',
+      filesEstimated: 3,
+    });
+    expect(result.classification).toBe('complex');
+    expect(signalByName(result, 'design-decisions-needed')!.triggered).toBe(true);
+  });
+
+  it('classifies task with new dependency as complex', () => {
+    const result = assess({
+      prompt: 'add a new package for rate limiting and install it',
+      filesEstimated: 3,
+    });
+    expect(result.classification).toBe('complex');
+    expect(signalByName(result, 'new-dependencies')!.triggered).toBe(true);
+  });
+});
+
+// ─── Edge Cases ─────────────────────────────────────────────────────
+
+describe('assessTaskComplexity — edge cases', () => {
+  it('handles empty prompt as simple', () => {
+    const result = assess({ prompt: '' });
+    expect(result.classification).toBe('simple');
+    expect(result.score).toBe(0);
+  });
+
+  it('clamps score to 0 minimum (negative weights only)', () => {
+    const result = assess({
+      prompt: 'do the thing',
+      hasParentPlan: true,
+    });
+    expect(result.score).toBe(0);
+    expect(result.classification).toBe('simple');
+  });
+
+  it('clamps score to 100 maximum', () => {
+    const result = assess({
+      prompt:
+        'add authentication, migrate the DB, install new package, how should we design this, refactor across all modules',
+      filesEstimated: 10,
+      domains: ['vault', 'brain', 'planning'],
+    });
+    expect(result.score).toBeLessThanOrEqual(100);
+    expect(result.score).toBeGreaterThanOrEqual(0);
+  });
+
+  it('parent context reduces complexity', () => {
+    const withoutParent = assess({
+      prompt: 'add authorization to the API',
+      filesEstimated: 4,
+    });
+    const withParent = assess({
+      prompt: 'add authorization to the API',
+      filesEstimated: 4,
+      hasParentPlan: true,
+    });
+    expect(withParent.score).toBeLessThan(withoutParent.score);
+    expect(signalByName(withParent, 'approach-already-described')!.triggered).toBe(true);
+  });
+
+  it('parentIssueContext also reduces complexity', () => {
+    const result = assess({
+      prompt: 'add authorization to the API',
+      filesEstimated: 4,
+      parentIssueContext: 'Use middleware pattern as described in RFC-42',
+    });
+    expect(signalByName(result, 'approach-already-described')!.triggered).toBe(true);
+  });
+
+  it('borderline score at exactly 40 is complex', () => {
+    // file-count (25) + new-dependencies (15) = 40
+    const result = assess({
+      prompt: 'install the redis package',
+      filesEstimated: 3,
+    });
+    expect(result.score).toBe(40);
+    expect(result.classification).toBe('complex');
+  });
+
+  it('borderline score at 39 is simple', () => {
+    // file-count (25) + new-dependencies (15) + approach-described (-15) = 25
+    const result = assess({
+      prompt: 'install the redis package',
+      filesEstimated: 3,
+      hasParentPlan: true,
+    });
+    expect(result.score).toBeLessThan(40);
+    expect(result.classification).toBe('simple');
+  });
+});
+
+// ─── Individual Signals ─────────────────────────────────────────────
+
+describe('assessTaskComplexity — individual signals', () => {
+  describe('file-count signal', () => {
+    it('triggers at 3 files', () => {
+      const result = assess({ prompt: 'task', filesEstimated: 3 });
+      expect(signalByName(result, 'file-count')!.triggered).toBe(true);
+      expect(signalByName(result, 'file-count')!.weight).toBe(25);
+    });
+
+    it('does not trigger at 2 files', () => {
+      const result = assess({ prompt: 'task', filesEstimated: 2 });
+      expect(signalByName(result, 'file-count')!.triggered).toBe(false);
+    });
+
+    it('does not trigger when no estimate provided', () => {
+      const result = assess({ prompt: 'task' });
+      expect(signalByName(result, 'file-count')!.triggered).toBe(false);
+    });
+  });
+
+  describe('cross-cutting-keywords signal', () => {
+    it.each([
+      'add authentication',
+      'implement authorization',
+      'migrate the database',
+      'refactor across modules',
+      'handle cross-cutting concerns',
+    ])('triggers for: "%s"', (prompt) => {
+      const result = assess({ prompt });
+      expect(signalByName(result, 'cross-cutting-keywords')!.triggered).toBe(true);
+    });
+
+    it('does not trigger for benign text', () => {
+      const result = assess({ prompt: 'fix button alignment' });
+      expect(signalByName(result, 'cross-cutting-keywords')!.triggered).toBe(false);
+    });
+  });
+
+  describe('new-dependencies signal', () => {
+    it.each([
+      'add dependency for caching',
+      'install redis',
+      'new package for validation',
+      'npm install lodash',
+    ])('triggers for: "%s"', (prompt) => {
+      const result = assess({ prompt });
+      expect(signalByName(result, 'new-dependencies')!.triggered).toBe(true);
+    });
+
+    it('does not trigger for normal text', () => {
+      const result = assess({ prompt: 'update existing code' });
+      expect(signalByName(result, 'new-dependencies')!.triggered).toBe(false);
+    });
+  });
+
+  describe('design-decisions-needed signal', () => {
+    it.each([
+      'how should we handle caching',
+      'which approach for the API',
+      'design decision on storage',
+      'architectural decision for events',
+      'evaluate the trade-off between speed and accuracy',
+    ])('triggers for: "%s"', (prompt) => {
+      const result = assess({ prompt });
+      expect(signalByName(result, 'design-decisions-needed')!.triggered).toBe(true);
+    });
+  });
+
+  describe('approach-already-described signal', () => {
+    it('triggers with hasParentPlan', () => {
+      const result = assess({ prompt: 'task', hasParentPlan: true });
+      const signal = signalByName(result, 'approach-already-described')!;
+      expect(signal.triggered).toBe(true);
+      expect(signal.weight).toBe(-15);
+    });
+
+    it('triggers with parentIssueContext', () => {
+      const result = assess({ prompt: 'task', parentIssueContext: 'Steps described here' });
+      expect(signalByName(result, 'approach-already-described')!.triggered).toBe(true);
+    });
+
+    it('does not trigger with empty parentIssueContext', () => {
+      const result = assess({ prompt: 'task', parentIssueContext: '   ' });
+      expect(signalByName(result, 'approach-already-described')!.triggered).toBe(false);
+    });
+  });
+
+  describe('multi-domain signal', () => {
+    it('triggers with 2+ domains', () => {
+      const result = assess({ prompt: 'task', domains: ['vault', 'brain'] });
+      expect(signalByName(result, 'multi-domain')!.triggered).toBe(true);
+      expect(signalByName(result, 'multi-domain')!.weight).toBe(5);
+    });
+
+    it('does not trigger with single domain', () => {
+      const result = assess({ prompt: 'task', domains: ['vault'] });
+      expect(signalByName(result, 'multi-domain')!.triggered).toBe(false);
+    });
+
+    it('does not trigger with no domains', () => {
+      const result = assess({ prompt: 'task' });
+      expect(signalByName(result, 'multi-domain')!.triggered).toBe(false);
+    });
+  });
+});
+
+// ─── Reasoning Output ───────────────────────────────────────────────
+
+describe('assessTaskComplexity — reasoning', () => {
+  it('includes signal names in reasoning when triggered', () => {
+    const result = assess({ prompt: 'migrate the database', filesEstimated: 5 });
+    expect(result.reasoning).toContain('cross-cutting-keywords');
+    expect(result.reasoning).toContain('file-count');
+  });
+
+  it('provides fallback reasoning when nothing triggers', () => {
+    const result = assess({ prompt: 'fix typo' });
+    expect(result.reasoning).toContain('No complexity signals detected');
+  });
+
+  it('always returns 6 signals', () => {
+    const result = assess({ prompt: 'anything' });
+    expect(result.signals).toHaveLength(6);
+  });
+});