opencastle 0.31.7 → 0.32.1

package/src/cli/convoy/artifacts.test.ts

@@ -0,0 +1,201 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { mkdtempSync, rmSync, existsSync } from 'node:fs'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+import {
+  getArtifactDir,
+  writeArtifact,
+  listArtifacts,
+  readArtifact,
+  extractArtifactRefs,
+  pruneArtifacts,
+} from './artifacts.js'
+
+describe('artifacts', () => {
+  let tmpDir: string
+
+  beforeEach(() => {
+    tmpDir = mkdtempSync(join(tmpdir(), 'artifacts-test-'))
+    vi.spyOn(process, 'cwd').mockReturnValue(tmpDir)
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+    rmSync(tmpDir, { recursive: true, force: true })
+  })
+
+  describe('writeArtifact', () => {
+    it('creates file in correct directory structure', () => {
+      const artifact = writeArtifact('convoy-1', 'task-1', 'report.md', '# Report\nContent here', 'report')
+      expect(artifact.path).toContain('convoy-1')
+      expect(artifact.path).toContain('task-1')
+      expect(artifact.path).toContain('report.md')
+      expect(existsSync(artifact.path)).toBe(true)
+    })
+
+    it('creates .meta.json sidecar', () => {
+      const artifact = writeArtifact('convoy-1', 'task-1', 'report.md', '# Report\nContent here', 'report')
+      const metaPath = artifact.path + '.meta.json'
+      expect(existsSync(metaPath)).toBe(true)
+    })
+
+    it('returns Artifact with correct metadata', () => {
+      const content = '# Report\nLine 2'
+      const artifact = writeArtifact('convoy-1', 'task-1', 'report.md', content, 'report')
+      expect(artifact.task_id).toBe('task-1')
+      expect(artifact.convoy_id).toBe('convoy-1')
+      expect(artifact.filename).toBe('report.md')
+      expect(artifact.type).toBe('report')
+      expect(artifact.size_bytes).toBe(Buffer.byteLength(content, 'utf8'))
+      expect(artifact.summary).toBe('# Report')
+    })
+
+    it('summary is truncated to 120 chars when first line is long', () => {
+      const longFirstLine = 'A'.repeat(200)
+      const content = longFirstLine + '\nSecond line'
+      const artifact = writeArtifact('convoy-1', 'task-1', 'long.md', content, 'report')
+      expect(artifact.summary.length).toBe(120)
+    })
+  })
+
+  describe('listArtifacts', () => {
+    it('returns refs for all files in task dir excluding .meta.json', () => {
+      writeArtifact('convoy-1', 'task-1', 'report.md', '# Report', 'report')
+      writeArtifact('convoy-1', 'task-1', 'migration.sql', 'ALTER TABLE users', 'code')
+      const refs = listArtifacts('convoy-1', 'task-1')
+      expect(refs).toHaveLength(2)
+      const filenames = refs.map(r => r.filename)
+      expect(filenames).toContain('report.md')
+      expect(filenames).toContain('migration.sql')
+    })
+
+    it('returns empty array when dir does not exist', () => {
+      const refs = listArtifacts('nonexistent-convoy', 'nonexistent-task')
+      expect(refs).toHaveLength(0)
+    })
+
+    it('populates summary from .meta.json sidecar', () => {
+      writeArtifact('convoy-1', 'task-1', 'diff.patch', 'diff --git a/file.ts\nchanges here', 'diff')
+      const refs = listArtifacts('convoy-1', 'task-1')
+      expect(refs[0].summary).toBe('diff --git a/file.ts')
+    })
+  })
+
+  describe('readArtifact', () => {
+    it('returns file content', () => {
+      const content = '# Report\nDetailed content here'
+      const artifact = writeArtifact('convoy-1', 'task-1', 'report.md', content, 'report')
+      const ref = { task_id: 'task-1', filename: 'report.md', summary: '# Report', path: artifact.path }
+      expect(readArtifact(ref)).toBe(content)
+    })
+  })
+
+  describe('extractArtifactRefs', () => {
+    it('parses [ARTIFACT: filename] summary pattern correctly', () => {
+      writeArtifact('convoy-1', 'task-1', 'report.md', '# Report', 'report')
+      const output = 'I completed the work.\n[ARTIFACT: report.md] Full analysis report\nSee the artifact for details.'
+      const refs = extractArtifactRefs('task-1', 'convoy-1', output)
+      expect(refs).toHaveLength(1)
+      expect(refs[0].filename).toBe('report.md')
+      expect(refs[0].summary).toBe('Full analysis report')
+    })
+
+    it('parses multiple artifacts in one output', () => {
+      writeArtifact('convoy-1', 'task-1', 'report.md', '# Report', 'report')
+      writeArtifact('convoy-1', 'task-1', 'migration.sql', 'ALTER TABLE', 'code')
+      const output = '[ARTIFACT: report.md] Analysis report\n[ARTIFACT: migration.sql] Database migration script'
+      const refs = extractArtifactRefs('task-1', 'convoy-1', output)
+      expect(refs).toHaveLength(2)
+    })
+
+    it('logs warning to stderr for referenced but missing artifacts', () => {
+      const stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true)
+      const output = '[ARTIFACT: missing.md] A report that does not exist on disk'
+      const refs = extractArtifactRefs('task-1', 'convoy-1', output)
+      expect(refs).toHaveLength(0)
+      expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining('[artifacts] Warning'))
+    })
+
+    it('returns empty array when no artifact patterns found', () => {
+      const refs = extractArtifactRefs('task-1', 'convoy-1', 'No artifacts here, just a normal response.')
+      expect(refs).toHaveLength(0)
+    })
+  })
+
+  describe('pruneArtifacts', () => {
+    it('removes convoy dirs beyond keepCount', () => {
+      writeArtifact('convoy-a', 'task-1', 'file.md', 'content', 'report')
+      writeArtifact('convoy-b', 'task-1', 'file.md', 'content', 'report')
+      writeArtifact('convoy-c', 'task-1', 'file.md', 'content', 'report')
+      const result = pruneArtifacts(1)
+      expect(result.removed).toBe(2)
+      expect(result.freed_bytes).toBeGreaterThan(0)
+    })
+
+    it('returns zero removed when within keepCount', () => {
+      writeArtifact('convoy-1', 'task-1', 'file.md', 'content', 'report')
+      writeArtifact('convoy-2', 'task-1', 'file.md', 'content', 'report')
+      const result = pruneArtifacts(5)
+      expect(result.removed).toBe(0)
+      expect(result.freed_bytes).toBe(0)
+    })
+
+    it('returns zero when no artifacts directory exists', () => {
+      const result = pruneArtifacts(10)
+      expect(result.removed).toBe(0)
+      expect(result.freed_bytes).toBe(0)
+    })
+
+    it('returns correct freed bytes count', () => {
+      const content = 'A'.repeat(1000)
+      writeArtifact('convoy-old1', 'task-1', 'large.md', content, 'report')
+      writeArtifact('convoy-old2', 'task-1', 'large.md', content, 'report')
+      writeArtifact('convoy-new', 'task-1', 'large.md', content, 'report')
+      const result = pruneArtifacts(1)
+      expect(result.removed).toBe(2)
+      expect(result.freed_bytes).toBeGreaterThan(0)
+    })
+  })
+
+  describe('round-trip', () => {
+    it('write → list → read produces identical content', () => {
+      const content = '# Report\nLine 2\nLine 3'
+      writeArtifact('convoy-1', 'task-1', 'report.md', content, 'report')
+      const refs = listArtifacts('convoy-1', 'task-1')
+      expect(refs).toHaveLength(1)
+      const retrieved = readArtifact(refs[0])
+      expect(retrieved).toBe(content)
+    })
+  })
+
+  describe('path sanitization', () => {
+    it('rejects filenames with ..', () => {
+      expect(() => writeArtifact('convoy-1', 'task-1', '../evil.ts', 'content', 'code')).toThrow()
+    })
+
+    it('rejects filenames with /', () => {
+      expect(() => writeArtifact('convoy-1', 'task-1', 'sub/evil.ts', 'content', 'code')).toThrow()
+    })
+
+    it('rejects convoy IDs with path traversal', () => {
+      expect(() => writeArtifact('../evil', 'task-1', 'file.md', 'content', 'report')).toThrow()
+    })
+
+    it('rejects task IDs with backslash', () => {
+      expect(() => writeArtifact('convoy-1', 'task\\evil', 'file.md', 'content', 'report')).toThrow()
+    })
+  })
+
+  describe('getArtifactDir', () => {
+    it('returns path ending with trailing slash', () => {
+      const dir = getArtifactDir('convoy-1', 'task-1')
+      expect(dir.endsWith('/')).toBe(true)
+    })
+
+    it('includes convoy-id and task-id in path', () => {
+      const dir = getArtifactDir('convoy-abc', 'task-xyz')
+      expect(dir).toContain('convoy-abc')
+      expect(dir).toContain('task-xyz')
+    })
+  })
+})

package/src/cli/convoy/artifacts.ts

@@ -0,0 +1,186 @@
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from 'node:fs'
+import { basename, join } from 'node:path'
+
+// ── Types ─────────────────────────────────────────────────────────────────────
+
+export interface Artifact {
+  task_id: string
+  convoy_id: string
+  filename: string
+  type: 'report' | 'code' | 'data' | 'diff' | 'log' | 'other'
+  size_bytes: number
+  summary: string
+  path: string
+}
+
+export interface ArtifactRef {
+  task_id: string
+  filename: string
+  summary: string
+  path: string
+}
+
+interface ArtifactMeta {
+  type: Artifact['type']
+  summary: string
+  size_bytes: number
+  created_at: string
+}
+
+// ── Sanitization ──────────────────────────────────────────────────────────────
+
+function sanitizeSegment(input: string): string {
+  if (input.includes('..') || input.includes('/') || input.includes('\\')) {
+    throw new Error(`Invalid path segment "${input}": path traversal characters not allowed`)
+  }
+  return input.replace(/[^a-zA-Z0-9\-_.]/g, '')
+}
+
+// ── Core ──────────────────────────────────────────────────────────────────────
+
+export function getArtifactDir(convoyId: string, taskId: string): string {
+  const safeConvoyId = sanitizeSegment(convoyId)
+  const safeTaskId = sanitizeSegment(taskId)
+  return join(process.cwd(), '.opencastle', 'artifacts', safeConvoyId, safeTaskId) + '/'
+}
+
+export function writeArtifact(
+  convoyId: string,
+  taskId: string,
+  filename: string,
+  content: string,
+  type: Artifact['type'],
+): Artifact {
+  const safeFilename = sanitizeSegment(filename)
+  const dir = getArtifactDir(convoyId, taskId)
+  mkdirSync(dir, { recursive: true })
+
+  const filePath = join(dir, safeFilename)
+  writeFileSync(filePath, content, 'utf8')
+
+  const size_bytes = Buffer.byteLength(content, 'utf8')
+  const firstLine = content.split('\n')[0] ?? ''
+  const summary = firstLine.slice(0, 120)
+
+  const meta: ArtifactMeta = { type, summary, size_bytes, created_at: new Date().toISOString() }
+  writeFileSync(join(dir, safeFilename + '.meta.json'), JSON.stringify(meta, null, 2), 'utf8')
+
+  return { task_id: taskId, convoy_id: convoyId, filename: safeFilename, type, size_bytes, summary, path: filePath }
+}
+
+export function listArtifacts(convoyId: string, taskId: string): ArtifactRef[] {
+  const dir = getArtifactDir(convoyId, taskId)
+  if (!existsSync(dir)) return []
+
+  const refs: ArtifactRef[] = []
+  for (const entry of readdirSync(dir)) {
+    if (entry.endsWith('.meta.json')) continue
+
+    const filePath = join(dir, entry)
+    const metaPath = join(dir, entry + '.meta.json')
+
+    let summary = ''
+    if (existsSync(metaPath)) {
+      try {
+        const meta = JSON.parse(readFileSync(metaPath, 'utf8')) as ArtifactMeta
+        summary = meta.summary
+      } catch { /* fallback */ }
+    }
+    if (!summary) {
+      try {
+        const firstLine = readFileSync(filePath, 'utf8').split('\n')[0] ?? ''
+        summary = firstLine.slice(0, 120)
+      } catch { /* non-critical */ }
+    }
+
+    refs.push({ task_id: taskId, filename: entry, summary, path: filePath })
+  }
+
+  return refs
+}
+
+export function readArtifact(ref: ArtifactRef): string {
+  return readFileSync(ref.path, 'utf8')
+}
+
+export function extractArtifactRefs(taskId: string, convoyId: string, output: string): ArtifactRef[] {
+  const pattern = /\[ARTIFACT:\s*([^\]]+)\]\s*(.+)/g
+  const refs: ArtifactRef[] = []
+  let match: RegExpExecArray | null
+
+  while ((match = pattern.exec(output)) !== null) {
+    // Use basename to prevent path traversal from untrusted agent output
+    const filename = basename(match[1].trim())
+    const summary = match[2].trim()
+
+    if (!filename || filename === '..') {
+      process.stderr.write('[artifacts] Warning: invalid artifact filename from agent output\n')
+      continue
+    }
+
+    const dir = getArtifactDir(convoyId, taskId)
+    const filePath = join(dir, filename)
+
+    if (!existsSync(filePath)) {
+      process.stderr.write(`[artifacts] Warning: referenced artifact not found: ${filePath}\n`)
+      continue
+    }
+
+    refs.push({ task_id: taskId, filename, summary, path: filePath })
+  }
+
+  return refs
+}
+
+export function pruneArtifacts(keepCount: number): { removed: number; freed_bytes: number } {
+  const artifactsRoot = join(process.cwd(), '.opencastle', 'artifacts')
+  if (!existsSync(artifactsRoot)) return { removed: 0, freed_bytes: 0 }
+
+  const convoyDirs = readdirSync(artifactsRoot)
+    .map(name => {
+      const dirPath = join(artifactsRoot, name)
+      try {
+        return { name, path: dirPath, mtime: statSync(dirPath).mtime.getTime() }
+      } catch {
+        return { name, path: dirPath, mtime: 0 }
+      }
+    })
+    .sort((a, b) => b.mtime - a.mtime)
+
+  const toRemove = convoyDirs.slice(keepCount)
+  let removed = 0
+  let freed_bytes = 0
+
+  for (const dir of toRemove) {
+    try {
+      freed_bytes += calcDirSize(dir.path)
+      rmSync(dir.path, { recursive: true, force: true })
+      removed++
+    } catch { /* non-critical */ }
+  }
+
+  return { removed, freed_bytes }
+}
+
+function calcDirSize(dirPath: string): number {
+  let total = 0
+  try {
+    for (const entry of readdirSync(dirPath)) {
+      const p = join(dirPath, entry)
+      try {
+        const s = statSync(p)
+        if (s.isDirectory()) total += calcDirSize(p)
+        else total += s.size
+      } catch { /* skip */ }
+    }
+  } catch { /* skip */ }
+  return total
+}

package/src/cli/convoy/compaction.test.ts

@@ -0,0 +1,245 @@
+import { describe, it, expect, afterEach } from 'vitest'
+import { mkdtempSync, rmSync, existsSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import {
+  shouldCompact,
+  generateCompactionPrompt,
+  parseCompactionSummary,
+  saveCompaction,
+  loadCompaction,
+  buildContinuationPrompt,
+  canCompact,
+  getMaxCompactions,
+  getCompactionDir,
+  MODEL_CONTEXT_WINDOWS,
+  type CompactionSummary,
+} from './compaction.js'
+import type { CompactionConfig } from './types.js'
+
+const baseConfig: CompactionConfig = {
+  enabled: true,
+  token_threshold_pct: 70,
+  summary_max_tokens: 4096,
+}
+
+describe('shouldCompact', () => {
+  it('returns false when config.enabled is false', () => {
+    expect(shouldCompact(150_000, 'claude-sonnet-4-6', { ...baseConfig, enabled: false })).toBe(false)
+  })
+
+  it('returns false below threshold', () => {
+    // 69% of 200_000 = 138_000
+    expect(shouldCompact(138_000, 'claude-sonnet-4-6', baseConfig)).toBe(false)
+  })
+
+  it('returns true at exactly the threshold', () => {
+    // 70% of 200_000 = 140_000
+    expect(shouldCompact(140_000, 'claude-sonnet-4-6', baseConfig)).toBe(true)
+  })
+
+  it('returns true above threshold', () => {
+    expect(shouldCompact(180_000, 'claude-sonnet-4-6', baseConfig)).toBe(true)
+  })
+
+  it('uses DEFAULT_CONTEXT_WINDOW (128_000) for unknown model', () => {
+    // 70% of 128_000 = 89_600
+    expect(shouldCompact(90_000, 'unknown-model-xyz', baseConfig)).toBe(true)
+    expect(shouldCompact(88_000, 'unknown-model-xyz', baseConfig)).toBe(false)
+  })
+
+  it('uses correct window for gpt-5-mini (128_000)', () => {
+    expect(MODEL_CONTEXT_WINDOWS['gpt-5-mini']).toBe(128_000)
+    expect(shouldCompact(90_000, 'gpt-5-mini', baseConfig)).toBe(true)
+  })
+})
+
+describe('generateCompactionPrompt', () => {
+  it('returns a string containing COMPACTION_SUMMARY marker', () => {
+    const prompt = generateCompactionPrompt('task-42')
+    expect(prompt).toContain('COMPACTION_SUMMARY')
+    expect(prompt).toContain('Context Compaction Required')
+    expect(typeof prompt).toBe('string')
+  })
+
+  it('includes JSON structure placeholders', () => {
+    const prompt = generateCompactionPrompt('task-1')
+    expect(prompt).toContain('"phase"')
+    expect(prompt).toContain('"completed_steps"')
+    expect(prompt).toContain('"pending_steps"')
+  })
+})
+
+describe('parseCompactionSummary', () => {
+  it('parses valid summary from agent output', () => {
+    const output = [
+      'Some output text',
+      '',
+      '<!-- COMPACTION_SUMMARY',
+      '{',
+      '  "phase": "implementation",',
+      '  "completed_steps": ["created types", "wrote tests"],',
+      '  "pending_steps": ["integrate with engine"],',
+      '  "key_decisions": ["used valibot for validation"],',
+      '  "files_modified": ["src/foo.ts"],',
+      '  "artifact_refs": [".opencastle/artifacts/convoy-1/task-1/report.md"]',
+      '}',
+      '-->',
+      '',
+      'More text',
+    ].join('\n')
+    const result = parseCompactionSummary(output, 'task-1', 'convoy-1')
+    expect(result).not.toBeNull()
+    expect(result!.task_id).toBe('task-1')
+    expect(result!.convoy_id).toBe('convoy-1')
+    expect(result!.phase).toBe('implementation')
+    expect(result!.completed_steps).toEqual(['created types', 'wrote tests'])
+    expect(result!.pending_steps).toEqual(['integrate with engine'])
+    expect(result!.key_decisions).toEqual(['used valibot for validation'])
+    expect(result!.files_modified).toEqual(['src/foo.ts'])
+    expect(result!.artifact_refs).toEqual(['.opencastle/artifacts/convoy-1/task-1/report.md'])
+    expect(typeof result!.timestamp).toBe('string')
+  })
+
+  it('returns null when no COMPACTION_SUMMARY marker found', () => {
+    const result = parseCompactionSummary('just some output without the marker', 'task-1', 'convoy-1')
+    expect(result).toBeNull()
+  })
+
+  it('returns null for invalid JSON inside the marker', () => {
+    const output = '<!-- COMPACTION_SUMMARY\nnot valid json\n-->'
+    const result = parseCompactionSummary(output, 'task-1', 'convoy-1')
+    expect(result).toBeNull()
+  })
+
+  it('uses empty arrays for missing or non-array fields', () => {
+    const output = '<!-- COMPACTION_SUMMARY\n{"phase": "testing"}\n-->'
+    const result = parseCompactionSummary(output, 'task-1', 'convoy-1')
+    expect(result).not.toBeNull()
+    expect(result!.completed_steps).toEqual([])
+    expect(result!.pending_steps).toEqual([])
+    expect(result!.files_modified).toEqual([])
+  })
+})
+
+describe('saveCompaction / loadCompaction', () => {
+  let tmpDir: string
+
+  afterEach(() => {
+    if (tmpDir && existsSync(tmpDir)) {
+      rmSync(tmpDir, { recursive: true, force: true })
+    }
+  })
+
+  it('saves and restores a compaction summary', () => {
+    tmpDir = mkdtempSync(join(tmpdir(), 'compaction-test-'))
+    const summary: CompactionSummary = {
+      task_id: 'task-1',
+      convoy_id: 'convoy-abc',
+      phase: 'testing',
+      completed_steps: ['step A'],
+      pending_steps: ['step B'],
+      key_decisions: ['chose approach X'],
+      files_modified: ['src/foo.ts'],
+      artifact_refs: [],
+      timestamp: new Date().toISOString(),
+    }
+
+    const origCwd = process.cwd()
+    process.chdir(tmpDir)
+    try {
+      const savedPath = saveCompaction('convoy-abc', 'task-1', summary, 1)
+      expect(existsSync(savedPath)).toBe(true)
+      const loaded = loadCompaction(savedPath)
+      expect(loaded).not.toBeNull()
+      expect(loaded!.task_id).toBe('task-1')
+      expect(loaded!.phase).toBe('testing')
+      expect(loaded!.completed_steps).toEqual(['step A'])
+    } finally {
+      process.chdir(origCwd)
+    }
+  })
+
+  it('returns null for a non-existent path', () => {
+    const result = loadCompaction('/tmp/definitely-does-not-exist-abc123.json')
+    expect(result).toBeNull()
+  })
+})
+
+describe('buildContinuationPrompt', () => {
+  let tmpDir: string
+
+  afterEach(() => {
+    if (tmpDir && existsSync(tmpDir)) {
+      rmSync(tmpDir, { recursive: true, force: true })
+    }
+  })
+
+  it('includes original prompt, summary, and isolation preamble', () => {
+    tmpDir = mkdtempSync(join(tmpdir(), 'compaction-test-'))
+    const origCwd = process.cwd()
+    process.chdir(tmpDir)
+    try {
+      const summary: CompactionSummary = {
+        task_id: 'task-1',
+        convoy_id: 'convoy-abc',
+        phase: 'integration',
+        completed_steps: ['wrote types'],
+        pending_steps: ['update engine'],
+        key_decisions: ['decided to reuse store'],
+        files_modified: ['src/types.ts'],
+        artifact_refs: [],
+        timestamp: new Date().toISOString(),
+      }
+      const savedPath = saveCompaction('convoy-abc', 'task-1', summary, 1)
+      const result = buildContinuationPrompt('Do the remaining work', savedPath, '## Isolation preamble\n')
+      expect(result).toContain('## Isolation preamble')
+      expect(result).toContain('Do the remaining work')
+      expect(result).toContain('Continuation from Compacted Context')
+      expect(result).toContain('wrote types')
+      expect(result).toContain('update engine')
+    } finally {
+      process.chdir(origCwd)
+    }
+  })
+
+  it('handles missing summary file gracefully', () => {
+    const result = buildContinuationPrompt(
+      'Do the work',
+      '/tmp/missing-summary-def456.json',
+      '## Preamble\n',
+    )
+    expect(result).toContain('Do the work')
+    expect(result).toContain('## Preamble')
+    expect(result).not.toContain('Continuation from Compacted Context')
+  })
+})
+
+describe('canCompact', () => {
+  it('returns true below max (3)', () => {
+    expect(canCompact(0)).toBe(true)
+    expect(canCompact(1)).toBe(true)
+    expect(canCompact(2)).toBe(true)
+  })
+
+  it('returns false at max (3)', () => {
+    expect(canCompact(3)).toBe(false)
+    expect(canCompact(4)).toBe(false)
+  })
+})
+
+describe('getMaxCompactions', () => {
+  it('returns 3', () => {
+    expect(getMaxCompactions()).toBe(3)
+  })
+})
+
+describe('getCompactionDir', () => {
+  it('returns path inside .opencastle/artifacts/{convoyId}/{taskId}', () => {
+    const result = getCompactionDir('convoy-abc', 'task-1')
+    expect(result).toContain('.opencastle')
+    expect(result).toContain('artifacts')
+    expect(result).toContain('convoy-abc')
+    expect(result).toContain('task-1')
+  })
+})