opencastle 0.27.3 → 0.29.0

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

@@ -1,228 +1,11 @@
-import { mkdtempSync, rmSync, readFileSync, existsSync, realpathSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
-import { exportConvoyToNdjson } from './export.js'
-import { createConvoyStore } from './store.js'
-import type { ConvoyStore } from './store.js'
-import type { ConvoyTaskStatus } from './types.js'
+// export.test.ts — exportConvoyToNdjson and exportPipelineToNdjson have been
+// removed from export.ts (see that file for rationale). No tests needed.
 
-vi.mock('../log.js', () => ({
-  appendEvent: vi.fn().mockResolvedValue(undefined),
-}))
+import { describe, it } from 'vitest'
 
-const NOW = '2026-03-08T10:00:00.000Z'
-
-let tmpDir: string
-let store: ConvoyStore
-
-function insertConvoy(id: string, name = 'Test Convoy') {
-  store.insertConvoy({
-    id,
-    name,
-    spec_hash: 'abc123',
-    status: 'done',
-    branch: 'main',
-    created_at: NOW,
-    spec_yaml: 'name: test',
-  })
-  store.updateConvoyStatus(id, 'done', { started_at: NOW, finished_at: NOW })
-}
-
-function insertTask(
-  taskId: string,
-  convoyId: string,
-  phase = 1,
-  status: ConvoyTaskStatus = 'done',
-) {
-  store.insertTask({
-    id: taskId,
-    convoy_id: convoyId,
-    phase,
-    prompt: 'Do something',
-    agent: 'developer',
-    adapter: 'claude-code',
-    model: null,
-    timeout_ms: 1_800_000,
-    status,
-    retries: 0,
-    max_retries: 1,
-    files: null,
-    depends_on: null,
-    gates: null,
-  })
-  if (status !== 'pending') {
-    store.updateTaskStatus(taskId, convoyId, status, {
-      started_at: NOW,
-      finished_at: NOW,
-      retries: 0,
-    })
-  }
-}
-
-function insertEvent(convoyId: string) {
-  store.insertEvent({
-    convoy_id: convoyId,
-    task_id: null,
-    worker_id: null,
-    type: 'convoy.started',
-    data: null,
-    created_at: NOW,
-  })
-}
-
-beforeEach(() => {
-  tmpDir = realpathSync(mkdtempSync(join(tmpdir(), 'convoy-export-test-')))
-  store = createConvoyStore(join(tmpDir, 'convoy.db'))
-})
-
-afterEach(() => {
-  store.close()
-  rmSync(tmpDir, { recursive: true, force: true })
-})
-
-describe('exportConvoyToNdjson', () => {
-  it('creates convoys.ndjson with valid NDJSON', async () => {
-    insertConvoy('c1')
-    insertTask('t1', 'c1')
-    const logsDir = join(tmpDir, 'logs')
-
-    await exportConvoyToNdjson(store, 'c1', logsDir)
-
-    const outFile = join(logsDir, 'convoys.ndjson')
-    expect(existsSync(outFile)).toBe(true)
-    const line = readFileSync(outFile, 'utf8').trimEnd()
-    expect(() => JSON.parse(line)).not.toThrow()
-  })
-
-  it('appends on multiple exports (2 convoys -> 2 lines)', async () => {
-    insertConvoy('c1')
-    insertConvoy('c2', 'Second Convoy')
-    const logsDir = join(tmpDir, 'logs')
-
-    await exportConvoyToNdjson(store, 'c1', logsDir)
-    await exportConvoyToNdjson(store, 'c2', logsDir)
-
-    const content = readFileSync(join(logsDir, 'convoys.ndjson'), 'utf8')
-    const lines = content.trim().split('\n').filter(Boolean)
-    expect(lines).toHaveLength(2)
-    expect(JSON.parse(lines[0]).id).toBe('c1')
-    expect(JSON.parse(lines[1]).id).toBe('c2')
-  })
-
-  it('required fields present', async () => {
-    insertConvoy('c1')
-    insertTask('t1', 'c1', 1, 'done')
-    insertTask('t2', 'c1', 1, 'failed')
-    insertEvent('c1')
-    const logsDir = join(tmpDir, 'logs')
-
-    await exportConvoyToNdjson(store, 'c1', logsDir)
-
-    const record = JSON.parse(readFileSync(join(logsDir, 'convoys.ndjson'), 'utf8').trim())
-    expect(record.id).toBe('c1')
-    expect(record.name).toBe('Test Convoy')
-    expect(record.status).toBe('done')
-    expect(Array.isArray(record.tasks)).toBe(true)
-    expect(record.tasks).toHaveLength(2)
-    expect(record.tasks[0]).toMatchObject({
-      id: 't1',
-      phase: 1,
-      agent: 'developer',
-      adapter: 'claude-code',
-      status: 'done',
-      retries: 0,
-    })
-    expect(record.summary).toMatchObject({ total: 2, done: 1, failed: 1, skipped: 0, timedOut: 0 })
-    expect(record.events_count).toBe(1)
-  })
-
-  it('missing convoy -> no error, no file', async () => {
-    const logsDir = join(tmpDir, 'logs')
-    await expect(exportConvoyToNdjson(store, 'nonexistent', logsDir)).resolves.toBeUndefined()
-    expect(existsSync(join(logsDir, 'convoys.ndjson'))).toBe(false)
-  })
-
-  it('creates directory if missing', async () => {
-    insertConvoy('c1')
-    const logsDir = join(tmpDir, 'deep', 'nested', 'logs')
-
-    await exportConvoyToNdjson(store, 'c1', logsDir)
-
-    expect(existsSync(join(logsDir, 'convoys.ndjson'))).toBe(true)
-  })
-
-  it('respects custom logsDir', async () => {
-    insertConvoy('c1')
-    const customDir = join(tmpDir, 'custom-output')
-
-    await exportConvoyToNdjson(store, 'c1', customDir)
-
-    const outFile = join(customDir, 'convoys.ndjson')
-    expect(existsSync(outFile)).toBe(true)
-    const record = JSON.parse(readFileSync(outFile, 'utf8').trim())
-    expect(record.id).toBe('c1')
-  })
-
-  it('never throws on store error — writes warning to stderr', async () => {
-    const broken = {
-      getConvoy: () => { throw new Error('db exploded') },
-    } as unknown as ConvoyStore
-    const stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true)
-
-    await expect(exportConvoyToNdjson(broken, 'c1', join(tmpDir, 'logs'))).resolves.toBeUndefined()
-    expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining('exportConvoyToNdjson warning'))
-
-    stderrSpy.mockRestore()
-  })
-
-  it('defaults to .opencastle/logs when logsDir is omitted', async () => {
-    insertConvoy('c1')
-    const originalCwd = process.cwd()
-    process.chdir(tmpDir)
-    try {
-      await exportConvoyToNdjson(store, 'c1')
-      const outFile = join(tmpDir, '.opencastle', 'logs', 'convoys.ndjson')
-      expect(existsSync(outFile)).toBe(true)
-    } finally {
-      process.chdir(originalCwd)
-    }
-  })
-
-  it('includes cost fields (prompt_tokens, completion_tokens, total_tokens) per task when present', async () => {
-    insertConvoy('c1')
-    insertTask('t1', 'c1')
-    // Manually set token cost on the task record
-    store.updateTaskStatus('t1', 'c1', 'done', {
-      prompt_tokens: 200,
-      completion_tokens: 100,
-      total_tokens: 300,
-    })
-    // Set convoy-level totals
-    store.updateConvoyStatus('c1', 'done', { total_tokens: 300 })
-    const logsDir = join(tmpDir, 'logs')
-
-    await exportConvoyToNdjson(store, 'c1', logsDir)
-
-    const record = JSON.parse(readFileSync(join(logsDir, 'convoys.ndjson'), 'utf8').trim())
-    expect(record.tasks[0].prompt_tokens).toBe(200)
-    expect(record.tasks[0].completion_tokens).toBe(100)
-    expect(record.tasks[0].total_tokens).toBe(300)
-    expect(record.total_tokens).toBe(300)
-  })
-
-  it('cost fields are null when no usage data recorded', async () => {
-    insertConvoy('c1')
-    insertTask('t1', 'c1')
-    const logsDir = join(tmpDir, 'logs')
-
-    await exportConvoyToNdjson(store, 'c1', logsDir)
-
-    const record = JSON.parse(readFileSync(join(logsDir, 'convoys.ndjson'), 'utf8').trim())
-    expect(record.tasks[0].prompt_tokens).toBeNull()
-    expect(record.tasks[0].completion_tokens).toBeNull()
-    expect(record.tasks[0].total_tokens).toBeNull()
-    expect(record.total_tokens).toBeNull()
-    expect(record.total_cost_usd).toBeNull()
+describe('export', () => {
+  it('export functions removed — data access goes through SQLite store', () => {
+    // The monolithic NDJSON export functions were removed to prevent unbounded
+    // file growth. All convoy/pipeline data is in convoy.db (SQLite).
   })
 })

package/src/cli/convoy/export.ts

@@ -1,106 +1,10 @@
-import { appendFileSync, mkdirSync } from 'node:fs'
-import { resolve } from 'node:path'
-import type { ConvoyStore } from './store.js'
-
-export async function exportPipelineToNdjson(
-  store: ConvoyStore,
-  pipelineId: string,
-  logsDir?: string,
-): Promise<void> {
-  try {
-    const pipeline = store.getPipeline(pipelineId)
-    if (!pipeline) return
-
-    const convoys = store.getConvoysByPipeline(pipelineId)
-
-    const record = {
-      id: pipeline.id,
-      name: pipeline.name,
-      status: pipeline.status,
-      branch: pipeline.branch,
-      created_at: pipeline.created_at,
-      started_at: pipeline.started_at,
-      finished_at: pipeline.finished_at,
-      total_tokens: pipeline.total_tokens,
-      total_cost_usd: pipeline.total_cost_usd,
-      convoy_count: convoys.length,
-      convoys: convoys.map(c => ({
-        id: c.id,
-        name: c.name,
-        status: c.status,
-        started_at: c.started_at,
-        finished_at: c.finished_at,
-        total_tokens: c.total_tokens,
-      })),
-    }
-
-    const dir = logsDir ?? resolve(process.cwd(), '.opencastle', 'logs')
-    mkdirSync(dir, { recursive: true })
-    appendFileSync(resolve(dir, 'pipelines.ndjson'), JSON.stringify(record) + '\n', 'utf8')
-  } catch (err) {
-    process.stderr.write(`[opencastle] exportPipelineToNdjson warning: ${String(err)}\n`)
-  }
-}
-
-export async function exportConvoyToNdjson(
-  store: ConvoyStore,
-  convoyId: string,
-  logsDir?: string,
-): Promise<void> {
-  try {
-    const convoy = store.getConvoy(convoyId)
-    if (!convoy) return
-
-    const tasks = store.getTasksByConvoy(convoyId)
-    const eventsCount = store.getEvents(convoyId).length
-
-    const summary = {
-      total: tasks.length,
-      done: tasks.filter((t) => t.status === 'done').length,
-      failed: tasks.filter((t) => t.status === 'failed').length,
-      skipped: tasks.filter((t) => t.status === 'skipped').length,
-      timedOut: tasks.filter((t) => t.status === 'timed-out').length,
-    }
-
-    const durationSec =
-      convoy.started_at && convoy.finished_at
-        ? Math.round(
-            (new Date(convoy.finished_at).getTime() - new Date(convoy.started_at).getTime()) / 1_000,
-          )
-        : undefined
-
-    const record = {
-      id: convoy.id,
-      name: convoy.name,
-      status: convoy.status,
-      branch: convoy.branch,
-      created_at: convoy.created_at,
-      started_at: convoy.started_at,
-      finished_at: convoy.finished_at,
-      duration_sec: durationSec,
-      summary,
-      tasks: tasks.map((t) => ({
-        id: t.id,
-        phase: t.phase,
-        agent: t.agent,
-        adapter: t.adapter,
-        status: t.status,
-        started_at: t.started_at,
-        finished_at: t.finished_at,
-        retries: t.retries,
-        prompt_tokens: t.prompt_tokens,
-        completion_tokens: t.completion_tokens,
-        total_tokens: t.total_tokens,
-      })),
-      events_count: eventsCount,
-      total_tokens: convoy.total_tokens,
-      total_cost_usd: convoy.total_cost_usd,
-    }
-
-    const dir = logsDir ?? resolve(process.cwd(), '.opencastle', 'logs')
-    mkdirSync(dir, { recursive: true })
-    appendFileSync(resolve(dir, 'convoys.ndjson'), JSON.stringify(record) + '\n', 'utf8')
-  } catch (err) {
-    process.stderr.write(`[opencastle] exportConvoyToNdjson warning: ${String(err)}\n`)
-  }
-}
+// Convoy data exports are handled by the dashboard ETL (src/dashboard/scripts/etl.ts)
+// which reads directly from the SQLite convoy store.
+//
+// Per-convoy event logs are in .opencastle/logs/convoys/{convoy-id}.ndjson
+// (written by the event emitter in events.ts, one file per convoy run).
+//
+// export functions removed to prevent unbounded NDJSON growth.
+// All convoy and pipeline data is queryable from the SQLite store at .opencastle/convoy.db.
+
+export {}

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

@@ -8,14 +8,15 @@ vi.mock('./gates.js', () => ({
   scanForSecrets: vi.fn(() => ({ clean: true, findings: [] })),
 }))
 
-const DISCOVERED_REL = 'DISCOVERED-ISSUES.md'
-const KNOWN_REL = 'KNOWN-ISSUES.md'
+const DISCOVERED_REL = '.opencastle/DISCOVERED-ISSUES.md'
+const KNOWN_REL = '.opencastle/KNOWN-ISSUES.md'
 
 const DISCOVERED_HEADER = '# Discovered Issues\n\n'
 const KNOWN_HEADER = '# Known Issues\n\n'
 
 function makeBase(): string {
   const dir = realpathSync(mkdtempSync(join(tmpdir(), 'issues-test-')))
+  mkdirSync(join(dir, '.opencastle'), { recursive: true })
   return dir
 }
 

package/src/cli/convoy/issues.ts

@@ -3,12 +3,12 @@ import { join } from 'node:path'
 import { scanForSecrets } from './gates.js'
 import type { ConvoyEventEmitter } from './events.js'
 
-const DISCOVERED_PATH = 'DISCOVERED-ISSUES.md'
-const KNOWN_PATH = 'KNOWN-ISSUES.md'
+const DISCOVERED_PATH = '.opencastle/DISCOVERED-ISSUES.md'
+const KNOWN_PATH = '.opencastle/KNOWN-ISSUES.md'
 
 const INJECT_INSTRUCTION =
   'IMPORTANT: After completing your task, if you notice any pre-existing bugs or issues ' +
-  'unrelated to your task, append them to DISCOVERED-ISSUES.md in the format:\n\n' +
+  'unrelated to your task, append them to .opencastle/DISCOVERED-ISSUES.md in the format:\n\n' +
   '### ISSUE: [title]\n' +
   '- **File:** [filepath]\n' +
   '- **Description:** [description]\n' +

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

@@ -747,31 +747,6 @@ describe('getCurrentBranch fallback', () => {
 })
 
 
-describe('NDJSON export', () => {
-  it('writes pipelines.ndjson to logsDir after run', async () => {
-    const factory = makeEngineFactory([makeConvoyResult()])
-    const logsDir = join(tmpDir, 'logs')
-
-    await createPipelineOrchestrator({
-      spec: makePipelineSpec({ depends_on_convoy: ['./a.yaml'] }),
-      specYaml: 'name: pipeline',
-      adapter: makeAdapter(),
-      dbPath,
-      logsDir,
-      _createConvoyEngine: factory,
-    }).run()
-
-    const { existsSync, readFileSync } = await import('node:fs')
-    const ndjsonPath = join(logsDir, 'pipelines.ndjson')
-    expect(existsSync(ndjsonPath)).toBe(true)
-
-    const parsed = JSON.parse(readFileSync(ndjsonPath, 'utf8').trim())
-    expect(parsed.status).toBe('done')
-    expect(typeof parsed.id).toBe('string')
-    expect(Array.isArray(parsed.convoys)).toBe(true)
-  })
-})
-
 // ── 13. Path traversal protection ────────────────────────────────────────────
 
 describe('path traversal protection', () => {

package/src/cli/convoy/pipeline.ts

@@ -12,7 +12,6 @@ import {
   type ConvoyResult,
   type ConvoyEngineOptions,
 } from './engine.js'
-import { exportPipelineToNdjson } from './export.js'
 import type { PipelineStatus } from './types.js'
 import { formatDuration } from '../run/executor.js'
 
@@ -240,15 +239,6 @@ export function createPipelineOrchestrator(
       updateStore.close()
     }
 
-    try {
-      const exportStore = createConvoyStore(dbPath)
-      try {
-        await exportPipelineToNdjson(exportStore, pipelineId, options.logsDir)
-      } finally {
-        exportStore.close()
-      }
-    } catch { /* silent */ }
-
     return {
       pipelineId,
       status: finalStatus,
@@ -407,15 +397,6 @@ export function createPipelineOrchestrator(
       updateStore.close()
     }
 
-    try {
-      const exportStore = createConvoyStore(dbPath)
-      try {
-        await exportPipelineToNdjson(exportStore, pipelineId, options.logsDir)
-      } finally {
-        exportStore.close()
-      }
-    } catch { /* silent */ }
-
     return {
       pipelineId,
       status: finalStatus,

package/src/cli/dashboard.ts

@@ -20,7 +20,6 @@ const MIME_TYPES: Record<string, string> = {
 
 const DATA_FILES = [
   'events.ndjson',
-  'convoys.ndjson',
   'pipelines.ndjson',
   // Legacy individual files — kept for backwards compatibility
   'sessions.ndjson',
@@ -35,6 +34,7 @@ interface DashboardArgs {
   openBrowser: boolean
   seed: boolean
   convoyId?: string
+  help: boolean
 }
 
 export interface DashboardServerOptions {
@@ -51,14 +51,30 @@ export interface DashboardServerResult {
   url: string
 }
 
+const DASHBOARD_HELP = `
+  opencastle dashboard [options]
+
+  Start the observability dashboard server.
+
+  Options:
+    --port <number>    Port to listen on (default: 4300, auto-increments if busy)
+    --no-open          Don't auto-open the browser
+    --seed             Show demo data instead of project logs
+    --convoy <id>      Filter dashboard to a specific convoy
+    --help, -h         Show this help
+`
+
 function parseArgs(args: string[]): DashboardArgs {
   let port = 4300
   let openBrowser = true
   let seed = false
   let convoyId: string | undefined
+  let help = false
 
   for (let i = 0; i < args.length; i++) {
-    if (args[i] === '--port' && args[i + 1]) {
+    if (args[i] === '--help' || args[i] === '-h') {
+      help = true
+    } else if (args[i] === '--port' && args[i + 1]) {
       port = parseInt(args[i + 1], 10)
       i++
     } else if (args[i] === '--no-open') {
@@ -71,7 +87,7 @@ function parseArgs(args: string[]): DashboardArgs {
     }
   }
 
-  return { port, openBrowser, seed, convoyId }
+  return { port, openBrowser, seed, convoyId, help }
 }
 
 function openUrl(url: string): void {
@@ -234,19 +250,28 @@ export default async function dashboard({
   pkgRoot,
   args,
 }: CliContext): Promise<void> {
-  const { port, openBrowser, seed, convoyId } = parseArgs(args)
+  const { port, openBrowser, seed, convoyId, help } = parseArgs(args)
+
+  if (help) {
+    console.log(DASHBOARD_HELP)
+    return
+  }
 
   // Check if any log files exist (for messaging)
   let hasLogs = false
   if (!seed) {
     const projectRoot = process.cwd()
+    const convoyLogsDir2 = resolve(projectRoot, '.opencastle', 'logs')
     const logsDir = resolve(projectRoot, '.github', 'customizations', 'logs')
     const checkFiles = ['events.ndjson', ...DATA_FILES]
-    for (const f of checkFiles) {
-      if (await fileExists(join(logsDir, f))) {
-        hasLogs = true
-        break
+    for (const dir of [convoyLogsDir2, logsDir]) {
+      for (const f of checkFiles) {
+        if (await fileExists(join(dir, f))) {
+          hasLogs = true
+          break
+        }
       }
+      if (hasLogs) break
     }
   }
 

package/src/cli/destroy.ts

@@ -7,10 +7,25 @@ import { removeGitignoreBlock } from './gitignore.js'
 import { confirm, closePrompts, c } from './prompt.js'
 import type { CliContext } from './types.js'
 
+const DESTROY_HELP = `
+  opencastle destroy [options]
+
+  Remove ALL OpenCastle files from your project (reverse of init).
+
+  Options:
+    --dry-run       Preview what would be removed without deleting files
+    --help, -h      Show this help
+`
+
 export default async function destroy({
   pkgRoot: _pkgRoot,
   args,
 }: CliContext): Promise<void> {
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log(DESTROY_HELP)
+    return
+  }
+
   const projectRoot = process.cwd()
   const dryRun = args.includes('--dry-run') || args.includes('--dryRun')
 

package/src/cli/dispute.ts

@@ -0,0 +1,28 @@
+import type { CliContext } from './types.js'
+
+const HELP = `
+  opencastle dispute [options]
+
+  Manage convoy dispute resolution — view, create, and resolve disputes
+  that arise when panel reviews repeatedly block a task.
+
+  Subcommands:
+    list             List all disputes
+    show <id>        Show dispute details
+    resolve <id>     Mark a dispute as resolved
+
+  Options:
+    --convoy <id>    Filter by convoy ID
+    --help, -h       Show this help
+`
+
+export default async function dispute({ args }: CliContext): Promise<void> {
+  if (args.includes('--help') || args.includes('-h') || args.length === 0) {
+    console.log(HELP)
+    return
+  }
+
+  console.error('  ✗ Dispute management is not yet implemented.')
+  console.log(HELP)
+  process.exit(1)
+}

package/src/cli/doctor.ts

@@ -159,7 +159,22 @@ export function checkMcpFromPaths(projectRoot: string, mcpPaths: string[]): Chec
 
 // ── Main doctor command ───────────────────────────────────────
 
-export default async function doctor({ args: _args }: CliContext): Promise<void> {
+const DOCTOR_HELP = `
+  opencastle doctor [options]
+
+  Validate your OpenCastle setup — checks manifest, customizations, skills,
+  logs, MCP configuration, and IDE-specific rules.
+
+  Options:
+    --help, -h      Show this help
+`
+
+export default async function doctor({ args }: CliContext): Promise<void> {
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log(DOCTOR_HELP)
+    return
+  }
+
   const projectRoot = process.cwd();
 
   console.log(`\n  🏰 ${BOLD('OpenCastle Doctor')}\n`);

package/src/cli/eject.ts

@@ -4,10 +4,26 @@ import { readManifest } from './manifest.js'
 import { confirm, closePrompts } from './prompt.js'
 import type { CliContext } from './types.js'
 
+const EJECT_HELP = `
+  opencastle eject [options]
+
+  Remove the OpenCastle dependency while keeping all framework files
+  standalone in your project.
+
+  Options:
+    --dry-run       Preview what would be changed without writing files
+    --help, -h      Show this help
+`
+
 export default async function eject({
   pkgRoot: _pkgRoot,
   args,
 }: CliContext): Promise<void> {
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log(EJECT_HELP)
+    return
+  }
+
   const projectRoot = process.cwd()
   const dryRun = args.includes('--dry-run') || args.includes('--dryRun')
 

package/src/cli/init.ts

@@ -13,7 +13,23 @@ import { IDE_LABELS } from './types.js'
 import type { CliContext, IdeChoice, TechTool, TeamTool, StackConfig } from './types.js'
 import { bootstrapCustomizations } from './bootstrap.js'
 
+const INIT_HELP = `
+  opencastle init [options]
+
+  Set up OpenCastle in your project — copies framework files, configures
+  IDE adapters, and creates the .opencastle/ directory.
+
+  Options:
+    --dry-run       Preview what would be changed without writing files
+    --help, -h      Show this help
+`
+
 export default async function init({ pkgRoot, args }: CliContext): Promise<void> {
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log(INIT_HELP)
+    return
+  }
+
   const projectRoot = process.cwd()
   const dryRun = args.includes('--dry-run') || args.includes('--dryRun')