tspl-cli 0.0.0-stage → 0.1.1

package/src/commands/task.command.js

@@ -0,0 +1,475 @@
+'use strict'
+
+const Crypto = require('crypto')
+const Fs = require('fs')
+const { checkbox, confirm, editor, input, select } = require('@inquirer/prompts')
+
+const { selectApproach, renderApproaches } = require('../task/approaches')
+const { request } = require('../api-client')
+const { listTasks, readTask } = require('../config-store')
+const { ENGINES } = require('../engines')
+const { createContext, saveTask } = require('../mcp/server')
+const { findProject } = require('../workspace')
+const { buildBrief, renderBrief } = require('../task/brief')
+const { checkTask, taskText } = require('../task/check')
+const { engineFor, refineTask } = require('../task/refine')
+const { runTask, describeWorkflow } = require('../workflow/controller')
+const { runUntilDone } = require('../workflow/wait')
+const { controllerDeps, renderOutcome, taskUrl } = require('../workflow/runtime')
+
+const TICKET = /^[A-Za-z][A-Za-z0-9]+-\d+$/
+const OTHER = '__other__'
+const EDITABLE = [
+  ['what', 'What should change'],
+  ['ticket', 'Ticket'],
+  ['apps', 'Apps / repos'],
+  ['who', 'Who uses it'],
+  ['where', 'Where (screen, menu)'],
+  ['how', 'How it should work'],
+  ['steps', 'Steps to reproduce'],
+  ['now', 'What happens now'],
+  ['expected', 'What should happen'],
+  ['details', 'Ticket text / details'],
+  ['doneWhen', 'Done-when checks'],
+]
+
+const newId = () => `t-${Date.now().toString(36)}-${Crypto.randomBytes(2).toString('hex')}`
+
+const asList = value => String(value || '').split(',').map(item => item.trim()).filter(Boolean)
+
+const counts = loaded => ({ files: loaded.graph.files.length, repos: loaded.graph.repos.length })
+
+const askOptions = async (question, message) => {
+  const choices = [
+    ...question.options.map(option => ({
+      name: option.description ? `${option.label} — ${option.description}` : option.label,
+      value: option.value === undefined ? option.label : option.value,
+    })),
+    { name: 'Something else', value: OTHER },
+  ]
+  if (question.multiSelect) {
+    const picked = await checkbox({ message, choices, required: true })
+    const values = picked.filter(value => value !== OTHER)
+    if (picked.includes(OTHER)) values.push(...asList(await input({ message: 'Which? (comma separated)' })))
+    return values
+  }
+  const picked = await select({ message, choices })
+  return picked === OTHER ? input({ message: 'Which?' }) : picked
+}
+
+const answer = async (card, question) => {
+  const field = question.target || question.field
+  const message = `${question.header ? `${question.header}: ` : ''}${question.question}`
+  if (field === 'now, expected') {
+    card.now = await input({ message: 'Bug: what happens now?' })
+    card.expected = await input({ message: 'Bug: what should happen instead?' })
+    return
+  }
+  const value = question.options && question.options.length ? await askOptions(question, message) : await input({ message })
+  if (field === 'apps') card.apps = Array.isArray(value) ? value : asList(value)
+  else if (field === 'details') card.details = [card.details, value].filter(Boolean).join('\n')
+  else card[field] = Array.isArray(value) ? value.join(', ') : value
+}
+
+const clarify = async (card, loaded) => {
+  let current = card
+  for (;;) {
+    const result = checkTask(current, loaded)
+    if (result.status === 'ready') return result
+    current = result.card
+    for (const question of result.questions) await answer(current, question)
+  }
+}
+
+const askChecks = async card => {
+  if (card.doneWhen.length) return
+  console.log('\nDone when: the checks that must pass when this is finished. One per line; leave empty to finish.')
+  for (;;) {
+    const check = (await input({ message: `Check ${card.doneWhen.length + 1}:` })).trim()
+    if (!check) return
+    card.doneWhen.push(check)
+  }
+}
+
+const startCard = async (words, options) => {
+  const text = words.join(' ').trim()
+  const card = { ticket: options.ticket || '' }
+  if (TICKET.test(text)) card.ticket = text
+  else card.what = text
+  card.ticket = card.ticket.toUpperCase()
+  if (!card.what) {
+    card.what = await input({ message: card.ticket ? `${card.ticket}: what should change? (the ticket title, or one sentence)` : 'What should change? One or two sentences' })
+  }
+  if (options.file) {
+    card.details = Fs.readFileSync(options.file, 'utf8').trim()
+  } else if (await confirm({ message: 'Paste the ticket description or acceptance criteria? (opens your editor)', default: false })) {
+    card.details = (await editor({ message: 'Ticket text', postfix: '.md' })).trim()
+  }
+  return card
+}
+
+const engineLabel = () => {
+  try {
+    const { name, model } = engineFor('plan')
+    return `${ENGINES[name].label}${model ? ` ${model}` : ''}`
+  } catch (err) {
+    return null
+  }
+}
+
+const refresh = (loaded, task, extra = {}) => {
+  const { brief } = buildBrief(loaded, task, { keywords: task.brief ? task.brief.keywords : [], refined: task.brief ? task.brief.refined : null, ...extra })
+  return { ...task, brief }
+}
+
+const editField = async (task, loaded) => {
+  const field = await select({ message: 'Which field?', choices: EDITABLE.map(([value, name]) => ({ name, value })) })
+  const card = { ...task.card }
+  if (field === 'doneWhen') {
+    card.doneWhen = []
+    await askChecks(card)
+  } else if (field === 'apps') {
+    card.apps = await checkbox({
+      message: 'Which apps / repos?',
+      choices: loaded.graph.repos.map(repo => ({ name: repo.name, value: repo.name, checked: card.apps.includes(repo.name) })),
+    })
+  } else {
+    card[field] = await input({ message: EDITABLE.find(([value]) => value === field)[1], default: card[field] || '' })
+    if (field === 'ticket') card.ticket = card.ticket.toUpperCase()
+  }
+  const result = await clarify(card, loaded)
+  return refresh(loaded, { ...task, card: result.card, assumptions: result.assumptions, summary: result.summary })
+}
+
+const refine = async (task, loaded) => {
+  const label = engineLabel()
+  if (!label) throw new Error('No AI engine is set up on this computer. Run: tspl engines')
+  process.stdout.write(`Asking ${label} once (no files are opened)…`)
+  const found = await refineTask(task, task.brief, { cwd: process.cwd() })
+  process.stdout.write('\r')
+  const tokens = found.usage ? ` · ${found.usage.inputTokens + found.usage.outputTokens} tokens` : ''
+  console.log(`${label} answered in ${(found.ms / 1000).toFixed(1)}s${tokens}`)
+  if (found.note) console.log(`  ${found.note}`)
+  found.questions.forEach(question => console.log(`  Question for you: ${question}`))
+  let card = task.card
+  if (found.doneWhen.length && !card.doneWhen.length) {
+    const picked = await checkbox({
+      message: 'Suggested "done when" checks: keep which?',
+      choices: found.doneWhen.map(check => ({ name: check, value: check, checked: true })),
+    })
+    card = { ...card, doneWhen: picked }
+  }
+  const keywords = found.keywords.length
+    ? await checkbox({
+        message: 'Words the code probably uses: search with which?',
+        choices: found.keywords.map(word => ({ name: word, value: word, checked: true })),
+      })
+    : []
+  const result = await clarify(card, loaded)
+  const refined = { engine: found.engine, model: found.model, at: found.at, note: found.note, usage: found.usage }
+  return refresh(loaded, { ...task, card: result.card, assumptions: result.assumptions, summary: result.summary }, { keywords, refined })
+}
+
+const review = async (task, loaded) => {
+  let current = task
+  for (;;) {
+    console.log(`\n${renderBrief(current, counts(loaded))}`)
+    if (current.assumptions.length) {
+      console.log('\nAssumed (say if wrong):')
+      current.assumptions.forEach(line => console.log(`  - ${line}`))
+    }
+    const label = engineLabel()
+    const action = await select({
+      message: 'What next?',
+      choices: [
+        { name: 'Looks right, save it', value: 'save' },
+        { name: 'Edit a field', value: 'edit' },
+        { name: 'Add words the code probably uses, then search again', value: 'keywords' },
+        ...(label ? [{ name: `Ask ${label} once to suggest words and checks`, value: 'refine' }] : []),
+        { name: 'Cancel (nothing is saved)', value: 'cancel' },
+      ],
+    })
+    if (action === 'save') return current
+    if (action === 'cancel') return null
+    if (action === 'edit') current = await editField(current, loaded)
+    if (action === 'keywords') {
+      const words = asList(await input({ message: 'Words or names (comma separated):', default: current.brief.keywords.join(', ') }))
+      current = refresh(loaded, current, { keywords: words })
+    }
+    if (action === 'refine') {
+      try {
+        current = await refine(current, loaded)
+      } catch (err) {
+        console.log(err.message)
+      }
+    }
+  }
+}
+
+const persist = async (loaded, task) => {
+  const now = new Date().toISOString()
+  const saved = {
+    ...task,
+    status: task.status || 'draft',
+    projectId: loaded.project._id,
+    keywords: task.brief.keywords,
+    basis: task.brief.basis,
+    found: task.brief.files.map(file => `${file.repo}/${file.path}`),
+    confidence: task.brief.confidence.level,
+    createdAt: task.createdAt || now,
+    updatedAt: now,
+  }
+  const shareError = await saveTask(loaded.project._id, saved, true)
+  const refined = task.brief.refined
+  if (!shareError && refined && refined.usage) {
+    await request('POST', `/api/v1/projects/${loaded.project._id}/tasks/${saved.id}/usage`, {
+      sessionId: `refine-${saved.id}-${refined.at}`,
+      step: 'intake',
+      engine: refined.engine,
+      model: refined.model,
+      source: 'tspl task refine',
+      input: refined.usage.inputTokens || 0,
+      cacheRead: refined.usage.cacheReadTokens || 0,
+      output: refined.usage.outputTokens || 0,
+    }).catch(() => null)
+  }
+  console.log(`\nSaved task ${saved.id}.`)
+  if (shareError) console.log(`It is on this computer only: the team could not be reached (${shareError.message}). It is shared the next time tspl talks to the API.`)
+  else console.log('The PM can see it in the tspl console under Plans → New tasks and confirm the scope.')
+  console.log(`\nNext, in your AI tool, in this project folder:  /tspl ${saved.id}`)
+  console.log(`Change it later: tspl task edit ${saved.id}   ·   See it: tspl task show ${saved.id}`)
+}
+
+const create = async (words, options) => {
+  const loaded = await createContext(process.cwd()).load()
+  const card = await startCard(words, options)
+  const result = await clarify(card, loaded)
+  await askChecks(result.card)
+  const ready = await clarify(result.card, loaded)
+  const task = refresh(loaded, { id: newId(), card: ready.card, assumptions: ready.assumptions, summary: ready.summary })
+  if (options.yes) console.log(`\n${renderBrief(task, counts(loaded))}`)
+  const final = options.yes ? task : await review(task, loaded)
+  if (!final) {
+    console.log('Nothing saved.')
+    return
+  }
+  await persist(loaded, final)
+}
+
+const localTask = id => {
+  const task = readTask(id)
+  if (!task.id) throw new Error(`Task ${id} is not on this computer. See it with: tspl task show ${id}`)
+  return task
+}
+
+const edit = async id => {
+  const loaded = await createContext(process.cwd()).load()
+  const task = refresh(loaded, localTask(id))
+  const final = await review(task, loaded)
+  if (!final) {
+    console.log('Nothing changed.')
+    return
+  }
+  await persist(loaded, final)
+}
+
+const show = async id => {
+  const local = readTask(id)
+  if (local.id) {
+    console.log(renderBrief(local))
+    return
+  }
+  const { project } = await findProject(process.cwd())
+  const remote = await request('GET', `/api/v1/projects/${project._id}/tasks/${encodeURIComponent(id)}`)
+  console.log(renderBrief({ ...remote, id: remote.key, summary: taskText(remote.card || {}) }))
+}
+
+const scope = async (id, options) => {
+  const { project } = await findProject(process.cwd())
+  const confirmed = !options.back
+  if (!confirmed && !options.note) throw new Error('Say what is missing or out of scope: --note "…"')
+  const task = await request('POST', `/api/v1/projects/${project._id}/tasks/${encodeURIComponent(id)}/scope`, { confirmed, note: options.note || '' })
+  console.log(confirmed ? `Scope confirmed for ${task.key}. The developer can plan it now: /tspl ${task.key}` : `Scope sent back for ${task.key} with your note.`)
+}
+
+const runWorkflow = async (id, options) => {
+  const controller = new AbortController()
+  const onSignal = () => controller.abort()
+  process.once('SIGINT', onSignal)
+  process.once('SIGTERM', onSignal)
+  try {
+    let stage = options.stage
+    const run = () => {
+      const once = runTask({ cwd: process.cwd(), taskId: id, signal: controller.signal, options: { confirmDelivery: Boolean(options.confirmDelivery), stage, branch: options.branch, base: options.base } }, controllerDeps(process.cwd()))
+      stage = undefined // a retried stage is retried once; later rounds just continue
+      return once
+    }
+    let result
+    if (options.wait) {
+      const { project } = await findProject(process.cwd())
+      result = await runUntilDone({
+        run,
+        fetchTask: () => request('GET', taskUrl(project._id, id)),
+        report: outcome => console.log(renderOutcome(outcome)),
+        log: line => console.log(`\n${line}`),
+        signal: controller.signal,
+      })
+    } else {
+      result = await run()
+      console.log(renderOutcome(result))
+    }
+    process.exitCode = result.stage === 'blocked' ? 1 : 0
+  } catch (err) {
+    if (!controller.signal.aborted) throw err
+    console.log('\nStopped waiting. Run it again any time; it continues where it was.')
+  } finally {
+    process.off('SIGINT', onSignal)
+    process.off('SIGTERM', onSignal)
+  }
+}
+
+const workflowStatus = async id => {
+  const { project } = await findProject(process.cwd())
+  const task = await request('GET', taskUrl(project._id, id))
+  const { lines, next } = describeWorkflow(task)
+  console.log(lines.join('\n'))
+  if (next.length) console.log(`Next: ${next.join('  |  ')}`)
+}
+
+const verify = async (id, options) => {
+  const { project } = await findProject(process.cwd())
+  const criterion = Number(options.check)
+  if (!Number.isInteger(criterion) || criterion < 1) throw new Error('--check needs the number of a done-when item')
+  const task = await request('GET', taskUrl(project._id, id))
+  const text = ((task.card && task.card.doneWhen) || [])[criterion - 1]
+  if (!text) throw new Error(`${id} has no done-when item ${criterion}`)
+  if (!(await confirm({ message: `You checked yourself, on the tested commits, that: "${text}"?`, default: false }))) {
+    console.log('Nothing recorded.')
+    return
+  }
+  const { workflow } = await request('POST', `${taskUrl(project._id, id)}/workflow/verify`, { criterion, actor: 'human', note: options.note || '' })
+  for (const file of options.file || []) {
+    const type = { '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.webp': 'image/webp', '.webm': 'video/webm', '.mp4': 'video/mp4', '.txt': 'text/plain' }[require('path').extname(file).toLowerCase()]
+    if (!type) throw new Error(`${file}: only png, jpg, webp, webm, mp4 or txt files can be attached`)
+    await request('POST', `${taskUrl(project._id, id)}/artifacts`, {
+      name: require('path').basename(file),
+      contentType: type,
+      data: Fs.readFileSync(file).toString('base64'),
+      criterion,
+      headSha: workflow.heads[0] ? workflow.heads[0].headSha : null,
+      caption: options.note || null,
+      source: 'person',
+    })
+    console.log(`Attached ${file} to test case ${criterion}.`)
+  }
+  console.log(`Recorded: done-when ${criterion} checked by you on ${workflow.heads.map(head => `${head.name}@${String(head.headSha).slice(0, 7)}`).join(', ')}. Continue: tspl task run ${id}`)
+}
+
+const remove = async (id, options) => {
+  const { project } = await findProject(process.cwd())
+  if (!options.yes && !(await confirm({ message: `Delete task ${id} for everyone? It disappears from the console and from every list.`, default: false }))) {
+    console.log('Nothing deleted.')
+    return
+  }
+  try {
+    await request('DELETE', taskUrl(project._id, id), { reason: options.reason || '' })
+  } catch (err) {
+    if (err.statusCode !== 404) throw err
+    console.log(`${id} was already deleted or never shared; removing the copy on this computer.`)
+  }
+  const { stopBuild } = require('../task/build')
+  stopBuild(id)
+  require('../config-store').removeTask(id)
+  console.log(`Deleted ${id}. Its branches stay in Git; delete them yourself if you no longer need them.`)
+}
+
+const list = () => {
+  const tasks = listTasks().sort((a, b) => new Date(b.updatedAt || 0) - new Date(a.updatedAt || 0))
+  if (!tasks.length) {
+    console.log('No tasks on this computer yet. Start one: tspl task new "<what should change>"')
+    return
+  }
+  tasks.forEach(task => {
+    const card = task.card || {}
+    console.log(`${task.id.padEnd(18)} ${(task.status || 'draft').padEnd(18)} ${card.ticket ? `${card.ticket} · ` : ''}${card.what || ''}`)
+  })
+}
+
+const chooseApproach = async (taskId, optionId, options) => {
+  const version = Number(options.version)
+  if (!Number.isSafeInteger(version) || version < 1) throw new Error('--version must be a positive integer from the displayed options')
+  const { project } = await findProject(process.cwd())
+  const task = await selectApproach(project._id, taskId, { version, optionId, via: 'cli' })
+  console.log(renderApproaches(task.approaches))
+  console.log(`Continue: tspl task run ${taskId}`)
+}
+
+module.exports = {
+  runWorkflow,
+  register(program) {
+    const task = program.command('task').description('Prepare a task before any AI work: questions, done-when checks and the code it touches (no AI tokens)')
+    task.command('choose <task> <option>')
+      .description('Choose a saved implementation approach before planning')
+      .requiredOption('--version <n>', 'version of the displayed options')
+      .action(chooseApproach)
+    task
+      .command('new [text...]')
+      .description('Start a task from a sentence or a ticket id; saves it for the team')
+      .option('--ticket <id>', 'ticket id, if the text is not one')
+      .option('--file <path>', 'read the ticket text from a file')
+      .option('-y, --yes', 'save without the review menu (scripts)')
+      .action(create)
+    task
+      .command('edit <task>')
+      .description('Change a task on this computer and save it again')
+      .action(edit)
+    task
+      .command('show <task>')
+      .description('Show a task brief: card, done-when checks, files tspl found')
+      .action(show)
+    task
+      .command('list')
+      .description('Tasks on this computer')
+      .action(list)
+    task
+      .command('delete <task>')
+      .alias('rm')
+      .description('Delete a task for everyone (you created it, or you are an owner, admin or PM)')
+      .option('--reason <text>', 'why, kept in the task history')
+      .option('-y, --yes', 'do not ask to confirm')
+      .action(remove)
+    task
+      .command('run <task>')
+      .description('Continue an approved task: code, run the checks, repair, review separately, open draft pull requests, wait for CI. Run it again to resume.')
+      .option('--stage <stage>', 'retry implementing, testing, reviewing, awaiting-delivery, creating-pr or awaiting-ci, then continue')
+      .option('--confirm-delivery', 'confirm pushing the branch and opening draft pull requests (otherwise you are asked)')
+      .option('--base <branch>', 'branch every repo starts from, e.g. master (otherwise you are asked before coding)')
+      .option('--branch <name>', 'name of the new branch to create, e.g. feature/contact-page (otherwise you are asked)')
+      .option('-w, --wait', 'when it stops for an approval, a manual check or CI, wait and continue by itself')
+      .action(runWorkflow)
+    task
+      .command('watch <task>')
+      .description('Same as run --wait: keep going through approvals, manual checks and CI until the task is ready or needs you here')
+      .option('--confirm-delivery', 'confirm pushing the branch and opening draft pull requests (otherwise you are asked)')
+      .option('--base <branch>', 'branch every repo starts from, e.g. master (otherwise you are asked before coding)')
+      .option('--branch <name>', 'name of the new branch to create, e.g. feature/contact-page (otherwise you are asked)')
+      .action((id, options) => runWorkflow(id, { ...options, wait: true }))
+    task
+      .command('status <task>')
+      .description('Where a task is: stage, checks, review, pull requests, and the exact next command')
+      .action(workflowStatus)
+    task
+      .command('verify <task>')
+      .description('Record that you checked a done-when item yourself (only for items no executed check covers)')
+      .requiredOption('--check <n>', 'number of the done-when item')
+      .option('--note <text>', 'what you looked at')
+      .option('--file <paths...>', 'screenshots or a screen recording that show it (png, jpg, webp, webm, mp4)')
+      .action(verify)
+    task
+      .command('scope <task>')
+      .description('Confirm a task scope as PM, or send it back with --back --note "…"')
+      .option('--back', 'send it back instead of confirming')
+      .option('--note <text>', 'what is missing or out of scope')
+      .action(scope)
+  },
+}

package/src/commands/usage.command.js

@@ -0,0 +1,105 @@
+'use strict'
+
+const Fs = require('fs')
+const Path = require('path')
+
+const { request } = require('../api-client')
+const { readLinks, readActive, listTasks } = require('../config-store')
+
+const PLANNING = ['draft', 'plan-review', 'pm-review', 'approved', 'changes-requested']
+const RECENT_HOURS = 24
+
+const readStdin = () =>
+  new Promise(resolve => {
+    let data = ''
+    process.stdin.setEncoding('utf8')
+    process.stdin.on('data', chunk => { data += chunk })
+    process.stdin.on('end', () => resolve(data))
+    process.stdin.on('error', () => resolve(data))
+  })
+
+const real = file => {
+  try {
+    return Fs.realpathSync(file)
+  } catch (err) {
+    return file
+  }
+}
+
+const inside = (dir, parent) => Boolean(parent) && (dir === parent || dir.startsWith(`${parent}${Path.sep}`))
+
+const parseTranscript = file => {
+  const byMessage = new Map()
+  let model = null
+  Fs.readFileSync(file, 'utf8').split('\n').forEach(line => {
+    if (!line.trim()) return
+    let entry
+    try {
+      entry = JSON.parse(line)
+    } catch (err) {
+      return
+    }
+    const message = entry && entry.type === 'assistant' ? entry.message : null
+    if (!message || !message.usage) return
+    byMessage.set(message.id || entry.uuid, message.usage)
+    if (message.model) model = message.model
+  })
+  const totals = { calls: byMessage.size, input: 0, cacheWrite: 0, cacheRead: 0, output: 0, model }
+  byMessage.forEach(usage => {
+    totals.input += usage.input_tokens || 0
+    totals.cacheWrite += usage.cache_creation_input_tokens || 0
+    totals.cacheRead += usage.cache_read_input_tokens || 0
+    totals.output += usage.output_tokens || 0
+  })
+  return totals
+}
+
+const pickTask = cwd => {
+  const dir = real(cwd)
+  const building = Object.entries(readActive()).find(([, build]) => build.repos.some(repo => inside(dir, real(repo.path))))
+  if (building) return { projectId: building[1].projectId, taskId: building[0], step: 'build' }
+  const link = Object.values(readLinks()).find(entry => inside(dir, real(entry.folder)) || Object.values(entry.repos || {}).some(repo => inside(dir, real(repo.path))))
+  if (!link) return null
+  const since = Date.now() - RECENT_HOURS * 3600 * 1000
+  const task = listTasks()
+    .filter(item => String(item.projectId) === String(link.projectId) && PLANNING.includes(item.status) && new Date(item.updatedAt || 0).getTime() > since)
+    .sort((a, b) => new Date(b.updatedAt || 0) - new Date(a.updatedAt || 0))[0]
+  return task ? { projectId: link.projectId, taskId: task.id, step: 'plan' } : null
+}
+
+const record = async () => {
+  let input
+  try {
+    input = JSON.parse((await readStdin()) || '{}')
+  } catch (err) {
+    return
+  }
+  if (!input.transcript_path || !Fs.existsSync(input.transcript_path)) return
+  const totals = parseTranscript(input.transcript_path)
+  if (!totals.calls) return
+  const target = pickTask(input.cwd || process.cwd())
+  if (!target) return
+  try {
+    await request('POST', `/api/v1/projects/${target.projectId}/tasks/${target.taskId}/usage`, {
+      sessionId: input.session_id || Path.basename(input.transcript_path, '.jsonl'),
+      step: target.step,
+      engine: 'claude',
+      model: totals.model,
+      source: 'claude-code',
+      input: totals.input,
+      cacheWrite: totals.cacheWrite,
+      cacheRead: totals.cacheRead,
+      output: totals.output,
+    })
+  } catch (err) {
+    if (process.env.TSPL_DEBUG) process.stderr.write(`tspl usage: ${err.message}\n`)
+  }
+}
+
+module.exports = {
+  parseTranscript,
+  pickTask,
+  register(program) {
+    program.command('usage', { hidden: true }).description('Record AI usage for the current task (called by the AI tool when a turn ends)').action(record)
+  },
+}