autark-cli 0.1.7 → 0.1.9

package/autark.mjs

@@ -9,20 +9,149 @@ import fs from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
 import process from 'node:process'
+import { spawn, spawnSync as childSpawnSync } from 'node:child_process'
 
 const API = process.env.AUTARK_API_URL || 'https://autark-api.kushalsokke.workers.dev'
 const AGENTMAIL_API = process.env.AGENTMAIL_API_URL || 'https://api.agentmail.to/v0'
 const AUTARK_HOME = process.env.AUTARK_HOME || path.join(os.homedir(), '.autark')
 const CREDS_PATH = process.env.AUTARK_CREDENTIALS || path.join(AUTARK_HOME, 'credentials.json')
 
+// Constants used by `autark update` — hoisted before main() runs because
+// async function bodies execute synchronously until their first await; main()
+// dispatches to update() which references these in its first synchronous
+// loop, so they need to be initialized at module-load time before the
+// main().catch() call below.
+const RAW_RUNTIME_BASE = process.env.AUTARK_RUNTIME_RAW_BASE
+  || 'https://autark.kushalsm.com/runtime'
+const SKILL_NAMES = ['autark', 'plumcake', 'chrome-relay', 'email', 'outreach', 'email-finder']
+const ECOSYSTEM_CLIS = ['autark-cli', 'plumcake-cli', 'chrome-relay']
+const PROGRAM_FILES = ['start.md', 'double-down.md', 'check.md', 'followup.md']
+
 const args = process.argv.slice(2)
-main().catch(err => {
-  console.error(err.message)
-  process.exit(1)
-})
+main()
+  .then(() => maybeNudge())
+  .catch(err => {
+    console.error(err.message)
+    maybeNudge()
+    process.exit(1)
+  })
+
+// ============================================================== nudge
+// Tail-print "[autark] update available" on stderr at the end of every
+// command if the cached cloud state doesn't match local. The actual check
+// runs in a detached child so it doesn't slow down the current command
+// (the result lands in the cache for the NEXT invocation to read).
+//
+// Disable in `autark update` itself (don't nudge the user to do the thing
+// they're already doing) and when AUTARK_NO_NUDGE=1.
+
+const NUDGE_CACHE = path.join(
+  process.env.AUTARK_HOME || path.join(os.homedir(), '.autark'),
+  'runtime',
+  'update-check.json',
+)
+const NUDGE_TTL_MS = 24 * 60 * 60 * 1000  // 24h
+
+function maybeNudge() {
+  try {
+    if (process.env.AUTARK_NO_NUDGE === '1') return
+    // The first arg group governs whether we print. update / login / logout
+    // don't need a nudge (login/logout aren't authenticated yet; update is
+    // already the action).
+    const group = args[0]
+    if (group === 'update' || group === 'login' || group === 'logout' || group === 'help'
+        || group === '--help' || group === '-h' || group === '--version' || !group) return
+
+    // Schedule a detached refresh — this exits immediately, the child
+    // writes to the cache file in the background.
+    scheduleBackgroundRefresh()
+
+    // Read whatever's in the cache RIGHT NOW (possibly stale) and decide
+    // whether to print. The cache holds the cloud state from the previous
+    // refresh; first invocation sees no cache and prints nothing.
+    const cache = readNudgeCache()
+    if (!cache) return
+    const localVersion = readLocalVersion()
+    const localInbox   = (loadCredentials() || {}).agentmail_email || ''
+    const localCliVer  = readInstalledVersion('autark-cli') || '0.0.0'
+
+    const runtimeBehind = cache.runtime_version  && cache.runtime_version !== localVersion
+    const inboxBehind   = cache.agentmail_email && cache.agentmail_email !== localInbox
+    const cliBehind     = cache.autark_cli_latest && cmpVersions(localCliVer, cache.autark_cli_latest) < 0
+
+    if (runtimeBehind || inboxBehind || cliBehind) {
+      // Throttle: at most one nudge per CLI session (which is one
+      // invocation, so always true). Mark cache.nudged_at so future
+      // ticks within the same minute don't re-print (rapid agent loops).
+      const now = Date.now()
+      if (!cache.nudged_at || (now - cache.nudged_at) > 60_000) {
+        const reasons = []
+        if (cliBehind)     reasons.push(`cli ${localCliVer} → ${cache.autark_cli_latest}`)
+        if (runtimeBehind) reasons.push(`runtime ${localVersion?.slice(0, 8) || '<none>'} → ${cache.runtime_version?.slice(0, 8) || '?'}`)
+        if (inboxBehind)   reasons.push('inbox')
+        process.stderr.write(`[autark] update available (${reasons.join(', ')}) — run: autark update\n`)
+        cache.nudged_at = now
+        writeNudgeCache(cache)
+      }
+    }
+  } catch {
+    // Nudge errors are silent. The CLI does its real work; this is decoration.
+  }
+}
+
+function readNudgeCache() {
+  try {
+    if (!fs.existsSync(NUDGE_CACHE)) return null
+    return JSON.parse(fs.readFileSync(NUDGE_CACHE, 'utf8'))
+  } catch { return null }
+}
+
+function writeNudgeCache(obj) {
+  try {
+    fs.mkdirSync(path.dirname(NUDGE_CACHE), { recursive: true })
+    fs.writeFileSync(NUDGE_CACHE, JSON.stringify(obj))
+  } catch {}
+}
+
+function scheduleBackgroundRefresh() {
+  try {
+    const cache = readNudgeCache()
+    const now = Date.now()
+    if (cache?.fetched_at && (now - cache.fetched_at) < NUDGE_TTL_MS) return
+    // Spawn a detached child that fetches /v1/me + npm latest, writes the
+    // cache, exits. Doesn't block the parent.
+    const child = spawn(
+      process.argv[0],
+      [process.argv[1], '__nudge_refresh__'],
+      { detached: true, stdio: 'ignore', env: { ...process.env, AUTARK_NO_NUDGE: '1' } },
+    )
+    child.unref()
+  } catch {}
+}
+
+// Invoked by scheduleBackgroundRefresh as a detached child. Refreshes the
+// cache then exits. Hidden internal subcommand — not in the usage doc.
+async function nudgeRefresh() {
+  try {
+    const creds = loadCredentials() || {}
+    if (!creds.token) return
+    const me = await api('GET', '/v1/me')
+    const cliLatest = await fetchNpmLatest('autark-cli')
+    const cache = readNudgeCache() || {}
+    writeNudgeCache({
+      ...cache,
+      runtime_version:    me.runtime_version,
+      agentmail_email:    me.agentmail_email,
+      autark_cli_latest:  cliLatest,
+      fetched_at:         Date.now(),
+    })
+  } catch {}
+}
 
 async function main() {
   const [group, command, ...rest] = args
+  // Hidden subcommand used by the background nudge refresh.
+  if (group === '__nudge_refresh__') return nudgeRefresh()
   if (!group || group === 'help' || group === '--help' || group === '-h') return usage()
 
   if (group === 'login') {
@@ -57,6 +186,8 @@ async function main() {
     return context([command, ...rest].filter(Boolean))
   }
   if (group === 'mail') return mail(command, rest)
+  if (group === 'settings') return settings(command, rest)
+  if (group === 'update') return update(rest)
 
   usage()
   process.exit(1)
@@ -100,6 +231,285 @@ async function me() {
   console.log(`${result.email}  (${result.id})`)
 }
 
+// ============================================================== settings
+// Account-wide settings the agent reads at run start.
+
+async function settings(command, rest) {
+  if (!command || command === 'show') return settingsShow(rest)
+  if (command === '--help' || command === '-h') return settingsUsage()
+  throw new Error(`unknown settings subcommand: ${command}`)
+}
+
+async function settingsShow(rest) {
+  const opts = parseArgs(rest)
+  const result = await api('GET', '/v1/settings')
+  const s = result?.settings || {}
+  if (opts.json) {
+    console.log(JSON.stringify(s, null, 2))
+    return
+  }
+  // Plain key=value output the prompt can grep against. Empty values render
+  // as `<unset>` so the agent can branch.
+  const fmt = (v) => (v === null || v === undefined || v === '') ? '<unset>' : v
+  console.log(`scheduler_link    ${fmt(s.scheduler_link)}`)
+  console.log(`personal_link     ${fmt(s.personal_link)}`)
+  console.log(`agentmail_email   ${fmt(s.agentmail_email)}`)
+  console.log(`custom_domain     ${fmt(s.custom_domain)}`)
+  console.log(`domain_status     ${fmt(s.custom_domain_status)}`)
+}
+
+function settingsUsage() {
+  console.log('usage:')
+  console.log('  autark settings show [--json]   account-wide settings (scheduler link, inbox, custom domain)')
+}
+
+// ================================================================ update
+// `autark update` — keep the laptop in sync with the cloud canon.
+//
+// Steps (see docs/autark-update.md):
+//   0. Self-update the CLI ecosystem (autark-cli + plumcake-cli + chrome-relay)
+//      via pnpm. Re-exec autark if its own version moved.
+//   1. GET /v1/me — compare runtime_version + agentmail_email against local.
+//   2. If runtime_version differs: curl the canonical files from the repo,
+//      refresh the 6 kstack skills via pnpm dlx, reload launchd, stamp the
+//      new version into ~/.autark/runtime/version.txt.
+//   3. If agentmail_email differs: POST /v1/inbox/rotate to re-mint a fresh
+//      inbox-scoped key, rewrite credentials.json.
+//
+// Rollback on partial failure: the version stamp is only written if every
+// step succeeded. "Either fully on version X or fully on version Y."
+//
+// AUTARK_UPDATE_DRY_RUN=1 prints what would happen, doesn't execute.
+// AUTARK_UPDATE_OFFLINE=1 skips the self-update step (for tests).
+// AUTARK_HOME overrides the install root (for sandbox tests).
+
+async function update(rest) {
+  const opts = parseArgs(rest)
+  const dryRun = !!process.env.AUTARK_UPDATE_DRY_RUN || !!opts['dry-run']
+  const skipSelfUpdate = !!process.env.AUTARK_UPDATE_OFFLINE
+  const log = (msg) => console.log(msg)
+  const sub = (msg) => console.log(`  ${msg}`)
+
+  log('autark update')
+
+  // ---- Step 0: self-update CLI ecosystem ---------------------------------
+  if (!skipSelfUpdate) {
+    log('checking CLI ecosystem versions…')
+    const upgrades = []
+    for (const pkg of ECOSYSTEM_CLIS) {
+      const installed = readInstalledVersion(pkg)
+      const latest = await fetchNpmLatest(pkg)
+      if (!latest) { sub(`! ${pkg}: could not reach npm registry, skipping`); continue }
+      if (!installed || cmpVersions(installed, latest) < 0) {
+        upgrades.push({ pkg, installed, latest })
+        sub(`${pkg}: ${installed || '(not installed)'} → ${latest}`)
+      } else {
+        sub(`${pkg}: ${installed} (current)`)
+      }
+    }
+
+    if (upgrades.length && !dryRun) {
+      log(`upgrading ${upgrades.length} CLI(s) via pnpm…`)
+      const args = ['add', '-g', ...upgrades.map((u) => `${u.pkg}@latest`)]
+      const res = await spawnSync('pnpm', args)
+      if (res.status !== 0) {
+        console.error('  pnpm add -g failed; aborting (rollback). Stay on previous version.')
+        process.exit(2)
+      }
+      // chrome-relay's npm package ships with a native-host installer that
+      // registers the host with Chrome at the OS level. Refresh after upgrade.
+      if (upgrades.some((u) => u.pkg === 'chrome-relay')) {
+        sub('refreshing chrome-relay native host…')
+        await spawnSync('chrome-relay', ['install'])  // non-fatal if it fails
+      }
+      // If autark-cli itself was upgraded, re-exec with the new binary so the
+      // rest of the run uses the new code.
+      if (upgrades.some((u) => u.pkg === 'autark-cli')) {
+        sub('re-exec autark with new binary…')
+        const child = spawn(process.argv[0], process.argv.slice(1), {
+          stdio: 'inherit',
+          env: { ...process.env, AUTARK_UPDATE_OFFLINE: '1' },  // don't re-self-update
+        })
+        child.on('exit', (code) => process.exit(code ?? 0))
+        return  // hand off to child
+      }
+    }
+  }
+
+  // ---- Step 1+2: compare /v1/me + refresh runtime + credentials ---------
+  log('fetching /v1/me…')
+  const me = await api('GET', '/v1/me')
+  const localVersion = readLocalVersion()
+  const localInbox = (loadCredentials() || {}).agentmail_email || ''
+
+  const runtimeBehind = me.runtime_version && me.runtime_version !== localVersion
+  const inboxBehind   = me.agentmail_email && me.agentmail_email !== localInbox
+
+  sub(`runtime_version  local=${localVersion || '<none>'}  cloud=${me.runtime_version}  ${runtimeBehind ? '→ refresh' : 'ok'}`)
+  sub(`agentmail_email  local=${localInbox || '<none>'}  cloud=${me.agentmail_email}  ${inboxBehind ? '→ rotate' : 'ok'}`)
+
+  if (!runtimeBehind && !inboxBehind) {
+    log('already up to date')
+    return
+  }
+  if (dryRun) {
+    log(`(dry-run) would refresh runtime=${runtimeBehind} inbox=${inboxBehind}`)
+    return
+  }
+
+  // Refresh runtime files + skills (all-or-nothing for rollback safety).
+  if (runtimeBehind) {
+    try {
+      log('refreshing runtime files…')
+      await refreshRuntimeFiles()
+      log('refreshing kstack skills…')
+      await refreshSkills()
+      log('reloading launchd…')
+      await reloadLaunchd()
+      // Only stamp the version AFTER every step succeeded.
+      writeLocalVersion(me.runtime_version)
+      sub(`stamped ~/.autark/runtime/version.txt → ${me.runtime_version}`)
+    } catch (e) {
+      console.error(`  runtime refresh failed: ${e.message}`)
+      console.error('  rolled back: version stamp NOT written. Re-run autark update.')
+      process.exit(2)
+    }
+  }
+
+  // Rotate credentials (separate from runtime refresh — independent stream).
+  if (inboxBehind) {
+    log('rotating AgentMail credentials…')
+    const rotated = await api('POST', '/v1/inbox/rotate', {})
+    saveCredentials({
+      ...loadCredentials(),
+      agentmail_email:    rotated.agentmail_email,
+      agentmail_inbox_id: rotated.agentmail_inbox_id,
+      agentmail_token:    rotated.agentmail_token,
+      rotated_at:         new Date().toISOString(),
+    })
+    sub(`new inbox: ${rotated.agentmail_email}`)
+  }
+
+  log(`autark updated → ${me.runtime_version}`)
+}
+
+// -----------------------------------------------------------------------
+// update() helpers — kept inline because they're only used by `autark update`.
+
+function readInstalledVersion(pkg) {
+  // Locate the global pnpm install path and read package.json's version.
+  try {
+    const child = childSpawnSync('pnpm', ['root', '-g'], { encoding: 'utf8' })
+    if (child.status !== 0) return null
+    const root = child.stdout.toString().trim()
+    const pj = path.join(root, pkg, 'package.json')
+    if (!fs.existsSync(pj)) return null
+    return JSON.parse(fs.readFileSync(pj, 'utf8')).version || null
+  } catch {
+    return null
+  }
+}
+
+async function fetchNpmLatest(pkg) {
+  try {
+    const res = await fetch(`https://registry.npmjs.org/${encodeURIComponent(pkg)}/latest`)
+    if (!res.ok) return null
+    const j = await res.json()
+    return j?.version || null
+  } catch {
+    return null
+  }
+}
+
+// Tiny semver compare — handles N.N.N strings. Returns -1/0/1.
+function cmpVersions(a, b) {
+  const pa = String(a).split('.').map((n) => parseInt(n, 10) || 0)
+  const pb = String(b).split('.').map((n) => parseInt(n, 10) || 0)
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const x = pa[i] || 0, y = pb[i] || 0
+    if (x !== y) return x < y ? -1 : 1
+  }
+  return 0
+}
+
+function readLocalVersion() {
+  const p = path.join(AUTARK_HOME, 'runtime', 'version.txt')
+  if (!fs.existsSync(p)) return ''
+  return fs.readFileSync(p, 'utf8').trim()
+}
+
+function writeLocalVersion(v) {
+  const p = path.join(AUTARK_HOME, 'runtime', 'version.txt')
+  fs.mkdirSync(path.dirname(p), { recursive: true })
+  fs.writeFileSync(p, v + '\n')
+}
+
+async function curlFile(url, dest) {
+  const res = await fetch(url)
+  if (!res.ok) throw new Error(`${res.status} fetching ${url}`)
+  const body = await res.text()
+  fs.mkdirSync(path.dirname(dest), { recursive: true })
+  fs.writeFileSync(dest, body)
+}
+
+async function refreshRuntimeFiles() {
+  const runtime = path.join(AUTARK_HOME, 'runtime')
+  fs.mkdirSync(path.join(runtime, 'programs'), { recursive: true })
+  await curlFile(`${RAW_RUNTIME_BASE}/agent_keepalive.py`, path.join(runtime, 'agent_keepalive.py'))
+  fs.chmodSync(path.join(runtime, 'agent_keepalive.py'), 0o755)
+  for (const f of PROGRAM_FILES) {
+    await curlFile(`${RAW_RUNTIME_BASE}/programs/${f}`, path.join(runtime, 'programs', f))
+  }
+  const agentSh = path.join(AUTARK_HOME, 'agent.sh')
+  await curlFile(`${RAW_RUNTIME_BASE}/agent.sh`, agentSh)
+  fs.chmodSync(agentSh, 0o755)
+}
+
+async function refreshSkills() {
+  for (const name of SKILL_NAMES) {
+    const res = await spawnSync('pnpm', ['dlx', '--silent', 'skills', 'add', `kiluazen/skills@${name}`, '-y', '-g'])
+    if (res.status !== 0) throw new Error(`skill ${name} install failed`)
+  }
+}
+
+async function reloadLaunchd() {
+  if (process.platform !== 'darwin') return
+  // Safety: only touch launchd when AUTARK_HOME is the canonical install
+  // location. Sandbox tests (AUTARK_HOME=/tmp/...) must never rewrite the
+  // global plist — it would point launchd at a tempdir that disappears.
+  const canonicalHome = path.join(os.homedir(), '.autark')
+  if (path.resolve(AUTARK_HOME) !== path.resolve(canonicalHome)) {
+    return
+  }
+  const plist = path.join(os.homedir(), 'Library', 'LaunchAgents', 'com.autark.runner.plist')
+  if (!fs.existsSync(plist)) return  // user hasn't installed launchd unit
+  // Re-render plist from template (template was refreshed alongside agent.sh).
+  const tmplUrl = `${RAW_RUNTIME_BASE}/com.autark.runner.plist.tmpl`
+  const tmplRes = await fetch(tmplUrl)
+  if (tmplRes.ok) {
+    const tmpl = await tmplRes.text()
+    const agentSh = path.join(AUTARK_HOME, 'agent.sh')
+    const agentLog = path.join(AUTARK_HOME, 'agent.log')
+    const rendered = tmpl
+      .replaceAll('${HOME_AUTARK}', AUTARK_HOME)
+      .replaceAll('${AGENT_SH}', agentSh)
+      .replaceAll('${AGENT_LOG}', agentLog)
+    fs.writeFileSync(plist, rendered)
+  }
+  await spawnSync('launchctl', ['unload', plist])
+  await spawnSync('launchctl', ['load', plist])
+}
+
+// Promise-wrapped spawn — returns { status: number }. stdio inherited so the
+// user sees pnpm's output. Used for self-update + skills refresh.
+function spawnSync(cmd, args) {
+  return new Promise((resolve) => {
+    const child = spawn(cmd, args, { stdio: 'inherit' })
+    child.on('exit', (code) => resolve({ status: code ?? 0 }))
+    child.on('error', () => resolve({ status: 1 }))
+  })
+}
+
 // =========================================================== products
 
 async function productUpsert(rest) {
@@ -458,30 +868,92 @@ async function context(rest) {
   return printHypothesisContext(await api('GET', `/v1/context/${encodeURIComponent(productSlug)}/${encodeURIComponent(code)}`))
 }
 
+// Output shape: a structured key-block (one fact per line, stable dotted-path
+// keys) first, then a `---` separator, then the narrative prose. Agents can
+// `grep '^action\.[a-f0-9]+\.meeting_link_sent_at'` for clean structured
+// access; the narrative is still there for context.
+
+function kv(k, v) {
+  if (v === undefined || v === null || v === '') return
+  // Single line, value as-is. No quoting — values with spaces are fine; the
+  // first whitespace run after the key marks the boundary.
+  console.log(`${k.padEnd(40)} ${v}`)
+}
+
+function actionShortId(id) {
+  return String(id || '').slice(0, 8)
+}
+
 function printProductContext(r) {
-  console.log(`# ${r.product.slug} — ${r.product.name}`)
-  console.log(`id: ${r.product.id}`)
-  if (r.product.tagline) console.log(`> ${r.product.tagline}`)
-  if (r.product.url)     console.log(`> ${r.product.url}`)
-  console.log(`\n## Brief\n`)
+  // ---- structured key-block ----
+  kv('product.id', r.product.id)
+  kv('product.slug', r.product.slug)
+  kv('product.name', r.product.name)
+  kv('product.tagline', r.product.tagline)
+  kv('product.url', r.product.url)
+  kv('product.visibility', r.product.visibility)
+  kv('product.hypothesis_count', (r.hypotheses || []).length)
+  for (const h of (r.hypotheses || [])) {
+    kv(`hypothesis.${h.code}.id`, h.id)
+    kv(`hypothesis.${h.code}.title`, h.title)
+    kv(`hypothesis.${h.code}.status`, h.status)
+    kv(`hypothesis.${h.code}.run_count`, h.run_count)
+  }
+  console.log('---')
+  // ---- narrative ----
+  console.log(`# ${r.product.slug} — ${r.product.name}\n`)
+  if (r.product.tagline) console.log(`> ${r.product.tagline}\n`)
+  console.log(`## Brief\n`)
   console.log(r.product.brief?.trim() || '(no brief set — owner can add one at https://autark.kushalsm.com)')
-  console.log(`\n## Hypotheses (${r.hypotheses.length})\n`)
-  if (!r.hypotheses.length) {
-    console.log('(none yet — create one with: autark hypothesis create --product-id <product_id> --md @hyp.md)')
+  if (!r.hypotheses?.length) {
+    console.log(`\n## Hypotheses\n\n(none yet — create one with: autark hypothesis create --product-id <product_id> --md @hyp.md)`)
   } else {
+    console.log(`\n## Hypotheses (${r.hypotheses.length})\n`)
     for (const h of r.hypotheses) {
-      console.log(`- [${h.status}] ${h.code}  id=${h.id}  — ${h.title}  (runs: ${h.run_count})`)
+      console.log(`- [${h.status}] ${h.code} — ${h.title}  (runs: ${h.run_count})`)
     }
   }
 }
 
 function printHypothesisContext(result) {
+  // ---- structured key-block ----
+  kv('product.id', result.product.id)
+  kv('product.slug', result.product.slug)
+  kv('hypothesis.id', result.hypothesis.id)
+  kv('hypothesis.code', result.hypothesis.code)
+  kv('hypothesis.title', result.hypothesis.title)
+  kv('hypothesis.status', result.hypothesis.status)
+  for (const run of (result.runs || [])) {
+    const shortRun = actionShortId(run.id)
+    kv(`run.${shortRun}.id`, run.id)
+    kv(`run.${shortRun}.run_number`, run.run_number)
+    kv(`run.${shortRun}.started_at`, run.started_at)
+    if (run.finished_at) kv(`run.${shortRun}.finished_at`, run.finished_at)
+    for (const a of (run.actions || [])) {
+      const shortA = actionShortId(a.id)
+      kv(`action.${shortA}.id`, a.id)
+      kv(`action.${shortA}.run_id`, run.id)
+      kv(`action.${shortA}.channel`, a.channel)
+      kv(`action.${shortA}.title`, a.title)
+      if (a.url)                 kv(`action.${shortA}.url`, a.url)
+      if (a.recipient)           kv(`action.${shortA}.recipient`, a.recipient)
+      if (a.agentmail_thread_id) kv(`action.${shortA}.agentmail_thread_id`, a.agentmail_thread_id)
+      if (a.agentmail_inbox_id)  kv(`action.${shortA}.agentmail_inbox_id`, a.agentmail_inbox_id)
+      if (a.occurred_at)         kv(`action.${shortA}.occurred_at`, a.occurred_at)
+      // Spread well-known metadata keys to their own lines for greppability.
+      const md = a.metadata || {}
+      for (const [mk, mv] of Object.entries(md)) {
+        if (typeof mv === 'string' || typeof mv === 'number' || typeof mv === 'boolean') {
+          kv(`action.${shortA}.metadata.${mk}`, mv)
+        }
+      }
+    }
+  }
+  console.log('---')
+  // ---- narrative ----
   console.log(`# ${result.product.slug}/${result.hypothesis.code} — ${result.hypothesis.title}\n`)
-  console.log(`product_id: ${result.product.id}`)
-  console.log(`hypothesis_id: ${result.hypothesis.id}`)
-  console.log(`Status: ${result.hypothesis.status}\n`)
   console.log(result.hypothesis.hypothesis_md)
-  for (const run of result.runs) {
+  for (const run of (result.runs || [])) {
     console.log(`\n\n## Run ${run.run_number}  (${run.id})`)
     console.log(`started: ${run.started_at}${run.finished_at ? `   finished: ${run.finished_at}` : '   (in progress)'}`)
     if (run.actions?.length) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autark-cli",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "CLI for autark — hypothesis-driven product runbooks. Track products, hypotheses, runs, and actions from the terminal.",
   "type": "module",
   "license": "MIT",
@@ -19,4 +19,4 @@
   "engines": {
     "node": ">=18"
   }
-}
+}