autark-cli 0.5.7 → 0.7.0

package/README.md

@@ -2,7 +2,7 @@
 
 CLI for [autark](https://autark.sh) — hypothesis-driven product runbooks.
 
-A product has hypotheses. Each hypothesis has runs. Each run logs actions (emails sent, posts made, replies received). The dashboard shows it all.
+A product has hypotheses. Each hypothesis frames leads — deduped people with a concrete angle, sourced by runs. The dashboard shows it all.
 
 ## Install
 
@@ -29,7 +29,7 @@ autark context chrome-relay
 
 autark hypothesis create --product-id <product_id> --md @./H01.md --code H01 --title "..."
 autark run start --hypothesis-id <hypothesis_id>
-autark log action --run-id <run_id> --channel github --title "..." --url https://github.com/...
+autark lead add --hypothesis-id <hypothesis_id> --run-id <run_id> --input @/tmp/lead.json
 autark run finish --run-id <run_id> --narrative @./narrative.md
 ```
 

package/autark.mjs

@@ -24,8 +24,25 @@ const CREDS_PATH = process.env.AUTARK_CREDENTIALS || path.join(AUTARK_HOME, 'cre
 const RAW_RUNTIME_BASE = process.env.AUTARK_RUNTIME_RAW_BASE
   || 'https://autark.sh/runtime'
 const SKILL_NAMES = ['autark', 'plumcake', 'chrome-relay', 'email', 'outreach', 'email-finder']
+const SKILL_AGENTS = ['claude-code', 'codex', 'pi', 'opencode']
 const ECOSYSTEM_CLIS = ['autark-cli', 'plumcake-cli', 'chrome-relay']
-const PROGRAM_FILES = ['start.md', 'double-down.md', 'check.md', 'followup.md']
+const PROGRAM_FILES = ['start.md', 'find_leads.md', 'double-down.md', 'check.md', 'followup.md']
+const LEAD_TEMPLATE = {
+  person: {
+    full_name: 'Itay Rosen',
+    primary_email: 'itay@example.com',
+    email_status: 'guessed',
+    handles: {
+      github: 'itayrosen',
+      twitter: 'itayrosen',
+    },
+    headline: 'Maintainer of parallel-browser-mcp',
+    source: 'github',
+  },
+  lead: {
+    angle: 'Maintains a browser automation MCP project, so he is likely to care about real-browser access for agents.',
+  },
+}
 
 // ============================================================ address reject
 // Two address shapes are bad enough to refuse at the CLI boundary, regardless
@@ -208,20 +225,25 @@ async function main() {
     if (command === 'unpause') return hypothesisPause(rest, 'active')
     if (!command || command === '--help' || command === '-h') return hypothesisUsage()
   }
+  if (group === 'lead') {
+    if (command === 'add')      return leadAdd(rest)
+    if (command === 'list')     return leadList(rest)
+    if (command === 'show')     return leadShow(rest)
+    if (command === 'status')   return leadStatus(rest)
+    if (command === 'template') return leadTemplate()
+    if (!command || command === 'help' || command === '--help' || command === '-h') return leadUsage()
+  }
+  if (group === 'touch') {
+    if (command === 'add')    return touchAdd(rest)
+    if (command === 'mute')   return touchMute(rest, true)
+    if (command === 'unmute') return touchMute(rest, false)
+    if (!command || command === '--help' || command === '-h') return touchUsage()
+  }
   if (group === 'run') {
     if (command === 'start')  return runStart(rest)
     if (command === 'finish') return runFinish(rest)
     if (!command || command === '--help' || command === '-h') return runUsage()
   }
-  if (group === 'log') {
-    if (command === 'action') return logAction(rest)
-    if (!command || command === '--help' || command === '-h') return logUsage()
-  }
-  if (group === 'action') {
-    if (command === 'escalate')   return actionEscalate(rest)
-    if (command === 'unescalate') return actionEscalate(rest, { clear: true })
-    if (!command || command === '--help' || command === '-h') return actionUsage()
-  }
   if (group === 'feedback') {
     if (command === 'record') return feedbackRecord(rest)
     if (command === 'delete') return feedbackDelete(rest)
@@ -519,7 +541,13 @@ async function refreshRuntimeFiles() {
 async function refreshSkills() {
   // skills CLI switched from `-s name,name` to positional `name name`.
   // The old comma-separated form silently matches nothing.
-  const res = await spawnSync('pnpm', ['dlx', '--silent', 'skills', 'add', 'kiluazen/kstack', ...SKILL_NAMES, '-y', '-g'])
+  // Target only the agents we actually run — without -a the skills CLI
+  // sprays all ~71 known hosts and reports noisy failures for hosts that
+  // reject global installs (e.g. PromptScript).
+  // Like the skill names, agents must be repeated flags — `-a a,b` is read
+  // as one (invalid) agent name.
+  const agentFlags = SKILL_AGENTS.flatMap((a) => ['-a', a])
+  const res = await spawnSync('pnpm', ['dlx', '--silent', 'skills', 'add', 'kiluazen/kstack', ...SKILL_NAMES, ...agentFlags, '-y', '-g'])
   if (res.status !== 0) throw new Error(`kstack skills install failed`)
 }
 
@@ -655,6 +683,175 @@ async function hypothesisStatus(rest) {
   console.log(`${label} → ${result.status}`)
 }
 
+// =============================================================== v2 leads
+
+async function leadAdd(rest) {
+  const opts = parseArgs(rest)
+  const payload = parseJsonValue(readValue(required(opts.input, '--input @lead.json')), '--input')
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) throw new Error('--input must be a JSON object')
+  if (!payload.lead || typeof payload.lead !== 'object' || !String(payload.lead.angle || '').trim()) {
+    throw new Error('lead.angle is required in --input JSON')
+  }
+
+  let hypId = opts['hypothesis-id'] || opts.hypothesis_id
+  if (!hypId) {
+    const ref = opts.hypothesis || opts._[0]
+    if (ref) {
+      const [productSlug, code] = splitHypothesisRef(ref)
+      const ctx = await api('GET', `/v1/context/${encodeURIComponent(productSlug)}/${encodeURIComponent(code)}`)
+      hypId = ctx.hypothesis?.id
+    }
+  }
+  if (!hypId) throw new Error('pass --hypothesis-id <id> or --hypothesis <slug/Hxx>')
+
+  const body = {
+    ...payload,
+    source_run_id: opts['run-id'] || opts.run_id || opts.run || payload.source_run_id || undefined,
+  }
+  const result = await api('POST', `/v1/hypotheses/${encodeURIComponent(hypId)}/leads`, body)
+  console.log(JSON.stringify(result))
+}
+
+async function leadStatus(rest) {
+  const opts = parseArgs(rest)
+  const id = required(opts['lead-id'] || opts.lead_id || opts._[0], 'lead id')
+  const status = required(opts.status, '--status (sourced|ready|contacted|replied|done|dead)')
+  const result = await api('PATCH', `/v1/leads/${encodeURIComponent(id)}/status`, { status })
+  console.log(JSON.stringify(result))
+}
+
+// The agent's front door: one compact line per lead, id first, filtered by
+// status. "Who replied?" = `autark lead list <slug> --status replied`.
+async function leadList(rest) {
+  const opts = parseArgs(rest)
+  const product = required(opts.product || opts._[0], 'product slug')
+  const status = opts.status || ''
+  const qs = `?product=${encodeURIComponent(product)}${status ? `&status=${encodeURIComponent(status)}` : ''}`
+  const data = await api('GET', `/v1/leads${qs}`)
+  if (opts.json) { console.log(JSON.stringify(data, null, 2)); return }
+  if (!data.leads.length) { console.log(`no leads${status ? ` with status ${status}` : ''} in ${product}`); return }
+  for (const l of data.leads) {
+    const who = [l.full_name, l.email && `<${l.email}>`].filter(Boolean).join(' ')
+    console.log(`${l.lead_id}  ${l.status}${l.hypothesis ? `  ${l.hypothesis}` : ''}  ${who}`)
+    if (l.replied_at) console.log(`  replied_at=${l.replied_at}${l.last_in_at ? `  last_in=${l.last_in_at}` : ''}`)
+    if (l.thread_ref) console.log(`  thread=${l.thread_ref}  inbox=${l.inbox_ref || ''}`)
+    if (l.angle)      console.log(`  angle: ${l.angle.length > 140 ? l.angle.slice(0, 140) + '…' : l.angle}`)
+  }
+  console.error(`${data.count} lead(s). Next: autark lead show <id> · autark mail thread <thread> · autark mail reply --lead-id <id>`)
+}
+
+async function leadShow(rest) {
+  const opts = parseArgs(rest)
+  const id = required(opts['lead-id'] || opts.lead_id || opts._[0], 'lead id')
+  const lead = await api('GET', `/v1/leads/${encodeURIComponent(id)}`)
+  console.log(JSON.stringify(lead, null, 2))
+}
+
+// muted=true marks an inbound touch as a non-reply (ticket bot, autoresponder).
+// The worker recomputes the lead verdict in the same write and the reply sweep
+// skips muted touches, so the judgment sticks. --action-id targets a v1 action
+// row instead (legacy bridge; the replies tab filters those at render).
+async function touchMute(rest, muted) {
+  const opts = parseArgs(rest)
+  const actionId = opts['action-id'] || opts.action_id
+  if (actionId) {
+    const result = await api('PATCH', `/v1/actions/${encodeURIComponent(actionId)}/mute`, { muted })
+    console.log(JSON.stringify(result))
+    return
+  }
+  const id = required(opts['touch-id'] || opts.touch_id || opts._[0], 'touch id (or --action-id for v1 rows)')
+  const result = await api('PATCH', `/v1/touches/${encodeURIComponent(id)}/mute`, { muted })
+  console.log(JSON.stringify(result))
+}
+
+async function touchAdd(rest) {
+  const opts = parseArgs(rest)
+  const leadId = required(opts['lead-id'] || opts.lead_id, '--lead-id')
+  const channel = required(opts.channel, '--channel')
+  const result = await api('POST', `/v1/leads/${encodeURIComponent(leadId)}/touches`, {
+    channel,
+    direction:   opts.direction === 'in' ? 'in' : 'out',
+    thread_ref:  opts['thread-ref'] || opts.thread_ref || undefined,
+    inbox_ref:   opts['inbox-ref'] || opts.inbox_ref || undefined,
+    summary:     opts.summary || undefined,
+    occurred_at: opts['occurred-at'] || opts.occurred_at || undefined,
+    status:      opts.status || undefined,
+  })
+  console.log(JSON.stringify(result))
+}
+
+function touchUsage() {
+  console.log(`autark touch
+
+  add --lead-id <id> --channel <c>
+      [--direction out|in]        # default out
+      [--thread-ref <ref>]        # AgentMail thread id or public URL of YOUR comment
+      [--summary "<one line>"]
+      [--occurred-at <iso>]
+      [--status <s>]              # override the automatic advance
+
+One row per outreach interaction, recorded against an explicit lead id —
+the CLI never guesses which lead an interaction belongs to. Writing the
+touch advances lead.status in the same transaction (out: ready→contacted,
+in: →replied) unless --status overrides it.
+
+Email is a special case: \`autark mail send --lead-id <id>\` records the
+touch automatically — do not call \`touch add\` for the same send.
+
+  mute <touch-id>             mark an inbound touch as a non-reply (bot,
+                              autoresponder); lead verdict recomputes and
+                              the reply sweep respects the judgment
+  mute --action-id <id>       same, for a legacy v1 action row
+  unmute <touch-id>           reverse it`)
+}
+
+function leadTemplate() {
+  printJson(LEAD_TEMPLATE)
+}
+
+function leadUsage() {
+  console.log(`autark lead
+
+  template
+      print a minimal JSON payload for lead add
+
+  add --hypothesis-id <id> --input @/tmp/lead.json [--run-id <id>]
+  add --hypothesis <slug>/<H01> --input @/tmp/lead.json [--run-id <id>]
+
+  list <slug> [--status replied|contacted|ready|...] [--json]
+      the front door: one line per lead, ids first, newest replies on top.
+      "who replied?" = lead list <slug> --status replied
+
+  show <lead-id>
+      person + bet + status + the ordered touch log with ids — run this
+      when handed a lead link, before replying or muting
+
+  status <lead-id> --status sourced|ready|contacted|replied|done|dead
+      explicit status write — normally NOT needed: sending via
+      \`autark mail send --lead-id\` or \`autark touch add\` advances
+      status automatically in the same transaction
+
+lead add records one sourced lead: person identity + the angle connecting that
+person to the hypothesis. It sends one ID-first request to the worker and
+prints exactly one compact JSON object to stdout:
+
+  {"person_id":"...","lead_id":"...","person_existed":false,"lead_existed":false}
+
+Minimum payload:
+
+${JSON.stringify(LEAD_TEMPLATE, null, 2)}
+
+Required:
+  - lead.angle
+  - enough person identity to dedupe: primary_email, a supported handle, or full_name
+
+Optional person fields:
+  email_status, headline, source, bio, signals
+
+find_leads should write /tmp/lead-N.json and call lead add with --input @file.
+No outreach is sent and no touch rows are written.`)
+}
+
 // =============================================================== runs
 
 async function runStart(rest) {
@@ -679,59 +876,6 @@ async function runFinish(rest) {
   console.log(`${result.id}  finished_at=${result.finished_at}`)
 }
 
-// ============================================================ actions
-
-async function logAction(rest) {
-  const opts = parseArgs(rest)
-  const run = required(opts['run-id'] || opts.run_id || opts.run, '--run-id')
-  const channel = required(opts.channel, '--channel')
-  const title   = required(opts.title, '--title')
-  const needsHuman = Boolean(opts['needs-human'] || opts.needs_human || opts.escalate)
-  const escalationReason = opts['escalation-reason'] || opts.escalation_reason || opts.reason || undefined
-
-  // Merge `our_comment_id` into metadata if passed as a sugar flag. This is
-  // the per-channel anchor the reply-state cron uses to detect engagement on
-  // OUR specific comment (vs the parent we were replying to). Always pass
-  // it when you posted a comment somewhere we can re-fetch — github issue/PR
-  // comments, gists, HN replies, Substack comments, Reddit comments.
-  const meta = opts.metadata ? JSON.parse(readValue(opts.metadata)) : undefined
-  const ourCommentId = opts['our-comment-id'] || opts.our_comment_id
-  const metadata = ourCommentId
-    ? { ...(meta || {}), our_comment_id: String(ourCommentId) }
-    : meta
-
-  const result = await api('POST', `/v1/runs/${encodeURIComponent(run)}/actions`, {
-    channel,
-    title,
-    url:                  opts.url || undefined,
-    agentmail_thread_id:  opts['agentmail-thread-id'] || opts['thread-id'] || opts.thread_id || undefined,
-    agentmail_inbox_id:   opts['agentmail-inbox-id'] || opts.inbox_id || opts.agentmail_inbox_id || undefined,
-    recipient:            opts.recipient || undefined,
-    metadata,
-    needs_human:          needsHuman || undefined,
-    escalation_reason:    needsHuman ? escalationReason : undefined,
-    occurred_at:          opts['occurred-at'] || opts.occurred_at || undefined,
-  })
-  console.log(result.id)
-}
-
-// ============================================================ action escalate
-
-async function actionEscalate(rest, { clear = false } = {}) {
-  const opts = parseArgs(rest)
-  const id = required(opts['action-id'] || opts.action_id || opts._[0], 'action id')
-  const reason = opts.reason || opts._.slice(1).join(' ') || undefined
-  const body = { needs_human: !clear }
-  if (!clear) body.reason = reason || ''
-  const result = await api('PATCH', `/v1/actions/${encodeURIComponent(id)}/escalate`, body)
-  console.log(`${result.id}  needs_human=${result.needs_human}${result.escalation_reason ? `  reason="${result.escalation_reason}"` : ''}`)
-}
-
-function actionUsage() {
-  console.log(`autark action escalate <action-id> [--reason "<one-line why>"]
-autark action unescalate <action-id>`)
-}
-
 // ============================================================ product pause
 
 async function productPause(rest, fixedStatus) {
@@ -977,7 +1121,8 @@ async function mailSend(rest) {
     response: result,
   })
   noteAutoLog(action, opts)
-  printJson({ ...result, autark_action_id: action?.id })
+  const touch = await maybeLogMailTouch(opts, { kind: 'send', subject, response: result })
+  printJson({ ...result, autark_action_id: action?.id, autark_touch_id: touch?.touch_id, autark_lead_status: touch?.status })
 }
 
 async function mailReply(rest, mode) {
@@ -995,7 +1140,8 @@ async function mailReply(rest, mode) {
     metadata: { message_id: messageId },
   })
   noteAutoLog(action, opts)
-  printJson({ ...result, autark_action_id: action?.id })
+  const touch = await maybeLogMailTouch(opts, { kind: mode, subject: opts.subject, response: result })
+  printJson({ ...result, autark_action_id: action?.id, autark_touch_id: touch?.touch_id, autark_lead_status: touch?.status })
 }
 
 async function mailForward(rest) {
@@ -1013,17 +1159,18 @@ async function mailForward(rest) {
     metadata: { message_id: messageId },
   })
   noteAutoLog(action, opts)
-  printJson({ ...result, autark_action_id: action?.id })
+  const touch = await maybeLogMailTouch(opts, { kind: 'forward', subject: opts.subject, response: result })
+  printJson({ ...result, autark_action_id: action?.id, autark_touch_id: touch?.touch_id, autark_lead_status: touch?.status })
 }
 
-// Explicit human-readable cue so agents (and humans) see that the action
-// landed in autark and don't follow up with a redundant `autark log action`
-// for the same send. Stays on stderr so JSON consumers piping stdout aren't
-// affected. Only fires when --run-id was passed and the log succeeded.
+// Explicit human-readable cue so agents (and humans) see that the send was
+// recorded against the run — no separate logging step is needed or possible.
+// Stays on stderr so JSON consumers piping stdout aren't affected. Only
+// fires when --run-id was passed and the log succeeded.
 function noteAutoLog(action, opts) {
   if (!action?.id) return
   const runId = opts['run-id'] || opts.run_id || opts.run
-  console.error(`autark: auto-logged action ${action.id} (run ${runId}) — do NOT run \`autark log action\` for this`)
+  console.error(`autark: send recorded as ${action.id} on run ${runId} — nothing else to log`)
 }
 
 async function mailThreads(rest) {
@@ -1097,6 +1244,28 @@ function mailBody(opts, base = {}) {
   return body
 }
 
+// v2: when --lead-id is passed, the send is recorded as a touch on that lead
+// and the lead's status advances (ready → contacted) in the same worker
+// transact. The send IS the bookkeeping — no separate status command needed.
+async function maybeLogMailTouch(opts, { kind, subject, response }) {
+  const leadId = opts['lead-id'] || opts.lead_id
+  if (!leadId) return null
+  const threadId = response?.thread_id
+  if (!threadId) throw new Error('AgentMail response missing thread_id; refusing to log email touch')
+  // inbox_ref tells the reply sweep which inbox owns the thread — stamped
+  // from the sending credentials so it survives later inbox rotation.
+  const creds = requireAgentmailCredentials()
+  const touch = await api('POST', `/v1/leads/${encodeURIComponent(leadId)}/touches`, {
+    channel: 'email',
+    direction: 'out',
+    thread_ref: threadId,
+    inbox_ref: creds.inboxId,
+    summary: subject ? `${kind}: ${subject}` : kind,
+  })
+  console.error(`autark: touch ${touch.touch_id} on lead ${touch.lead_id} — status ${touch.status}${touch.status_changed ? ' (advanced)' : ''}`)
+  return touch
+}
+
 async function maybeLogMailAction(opts, { kind, defaultTitle, recipient, subject, response, metadata = {} }) {
   const runId = opts['run-id'] || opts.run_id || opts.run
   if (!runId) return null
@@ -1214,6 +1383,9 @@ function printProductContext(r) {
   kv('product.url', r.product.url)
   kv('product.visibility', r.product.visibility)
   kv('product.hypothesis_count', (r.hypotheses || []).length)
+  kv('product.person_count', r.product.person_count || (r.people || []).length || 0)
+  kv('product.lead_count', r.product.lead_count || (r.leads || []).length || 0)
+  kv('product.ready_lead_count', r.product.ready_lead_count || (r.leads || []).filter((l) => l.status === 'ready').length || 0)
   // Product-level operator feedback (newest first). Append-only + timestamped,
   // so each entry is a distinct nudge — re-read these every run.
   kv('product.feedback_count', (r.feedback || []).length)
@@ -1229,6 +1401,8 @@ function printProductContext(r) {
     kv(`hypothesis.${h.code}.run_count`, h.run_count)
     kv(`hypothesis.${h.code}.action_count`, h.action_count)
     kv(`hypothesis.${h.code}.reply_count`, h.reply_count)
+    kv(`hypothesis.${h.code}.lead_count`, h.lead_count || (h.leads || []).length || 0)
+    kv(`hypothesis.${h.code}.ready_lead_count`, h.ready_lead_count || (h.leads || []).filter((l) => l.status === 'ready').length || 0)
     if (h.needs_human_count) kv(`hypothesis.${h.code}.needs_human_count`, h.needs_human_count)
     const actions = (h.runs || []).flatMap((run) => run.actions || [])
     const by = channelBreakdown(actions)
@@ -1237,6 +1411,16 @@ function printProductContext(r) {
       kv(`hypothesis.${h.code}.channel.${ch}.replied`, by[ch].replied)
     }
   }
+  for (const lead of (r.leads || [])) {
+    const shortL = actionShortId(lead.id)
+    kv(`lead.${shortL}.id`, lead.id)
+    kv(`lead.${shortL}.status`, lead.status)
+    kv(`lead.${shortL}.hypothesis_code`, lead.hypothesis_code)
+    kv(`lead.${shortL}.person_name`, lead.person?.full_name)
+    kv(`lead.${shortL}.person_email`, lead.person?.primary_email)
+    kv(`lead.${shortL}.headline`, lead.person?.headline)
+    kv(`lead.${shortL}.angle`, lead.angle)
+  }
   console.log('---')
   // ---- narrative ----
   console.log(`# ${r.product.slug} — ${r.product.name}\n`)
@@ -1261,7 +1445,18 @@ function printProductContext(r) {
         .map((ch) => `${ch} ${by[ch].replied}/${by[ch].sent}`)
         .join('  ')
       const tail = channelSummary ? `  — replies/sends by channel: ${channelSummary}` : ''
-      console.log(`- [${h.status}] ${h.code} — ${h.title}  (runs: ${h.run_count}, actions: ${h.action_count || 0}, replies: ${h.reply_count || 0})${tail}`)
+      console.log(`- [${h.status}] ${h.code} — ${h.title}  (runs: ${h.run_count}, actions: ${h.action_count || 0}, replies: ${h.reply_count || 0}, leads: ${h.lead_count || 0})${tail}`)
+    }
+  }
+  if (r.leads?.length) {
+    console.log(`\n## Recent leads (${r.leads.length})\n`)
+    for (const lead of r.leads) {
+      const person = lead.person || {}
+      const label = person.full_name || person.primary_email || Object.entries(person.handles || {})[0]?.join(':') || lead.person_id || 'unknown person'
+      const hyp = lead.hypothesis_code ? `${lead.hypothesis_code} ` : ''
+      const headline = person.headline ? ` — ${person.headline}` : ''
+      console.log(`- [${lead.status}] ${hyp}${label}${headline}`)
+      if (lead.angle) console.log(`  angle: ${lead.angle}`)
     }
   }
 }
@@ -1274,6 +1469,8 @@ function printHypothesisContext(result) {
   kv('hypothesis.code', result.hypothesis.code)
   kv('hypothesis.title', result.hypothesis.title)
   kv('hypothesis.status', result.hypothesis.status)
+  kv('hypothesis.lead_count', result.hypothesis.lead_count || (result.leads || []).length || 0)
+  kv('hypothesis.ready_lead_count', result.hypothesis.ready_lead_count || (result.leads || []).filter((l) => l.status === 'ready').length || 0)
   // Feedback — operator nudges left on this hypothesis, oldest first. The
   // worker returns them; previously the CLI silently dropped them, so agents
   // never saw the operator's running corrections. Now surface them up top
@@ -1297,9 +1494,11 @@ function printHypothesisContext(result) {
   }
   for (const run of (result.runs || [])) {
     const shortRun = actionShortId(run.id)
+    const runLeads = (result.leads || []).filter((l) => l.source_run_id === run.id)
     kv(`run.${shortRun}.id`, run.id)
     kv(`run.${shortRun}.run_number`, run.run_number)
     kv(`run.${shortRun}.started_at`, run.started_at)
+    kv(`run.${shortRun}.lead_count`, runLeads.length)
     if (run.finished_at) kv(`run.${shortRun}.finished_at`, run.finished_at)
     for (const a of (run.actions || [])) {
       const shortA = actionShortId(a.id)
@@ -1326,6 +1525,16 @@ function printHypothesisContext(result) {
       }
     }
   }
+  for (const lead of (result.leads || [])) {
+    const shortL = actionShortId(lead.id)
+    kv(`lead.${shortL}.id`, lead.id)
+    kv(`lead.${shortL}.status`, lead.status)
+    kv(`lead.${shortL}.source_run_id`, lead.source_run_id)
+    kv(`lead.${shortL}.person_name`, lead.person?.full_name)
+    kv(`lead.${shortL}.person_email`, lead.person?.primary_email)
+    kv(`lead.${shortL}.headline`, lead.person?.headline)
+    kv(`lead.${shortL}.angle`, lead.angle)
+  }
   console.log('---')
   // ---- narrative ----
   console.log(`# ${result.product.slug}/${result.hypothesis.code} — ${result.hypothesis.title}\n`)
@@ -1338,9 +1547,21 @@ function printHypothesisContext(result) {
       console.log(`- [${when}]${tag} ${f.text}`)
     }
   }
+  if (result.leads?.length) {
+    console.log(`\n\n## Leads (${result.leads.length})\n`)
+    for (const lead of result.leads) {
+      const person = lead.person || {}
+      const label = person.full_name || person.primary_email || Object.entries(person.handles || {})[0]?.join(':') || lead.person_id || 'unknown person'
+      const headline = person.headline ? ` — ${person.headline}` : ''
+      const runTag = lead.source_run_id ? `  (run ${actionShortId(lead.source_run_id)})` : ''
+      console.log(`- [${lead.status}] ${label}${headline}${runTag}`)
+      if (lead.angle) console.log(`  angle: ${lead.angle}`)
+    }
+  }
   for (const run of (result.runs || [])) {
+    const runLeads = (result.leads || []).filter((l) => l.source_run_id === run.id)
     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)'}`)
+    console.log(`started: ${run.started_at}${run.finished_at ? `   finished: ${run.finished_at}` : '   (in progress)'}${runLeads.length ? `   leads sourced: ${runLeads.length}` : ''}`)
     if (run.actions?.length) {
       console.log(`\nActions:`)
       for (const a of run.actions) {
@@ -1423,6 +1644,14 @@ function readValue(value) {
   return String(value)
 }
 
+function parseJsonValue(value, label = 'json') {
+  try {
+    return JSON.parse(value)
+  } catch (e) {
+    throw new Error(`${label} must be valid JSON: ${e.message}`)
+  }
+}
+
 function listOpt(value, label) {
   if (value === undefined || value === null || value === '') {
     if (label) throw new Error(`${label} is required`)
@@ -1472,10 +1701,10 @@ function mailUsage() {
   console.log(`autark mail
 
   setup       --prefix <name> [--force]
-  send        --to <email[,email]> --subject <s> [--text @body.txt] [--html @body.html] [--cc <e>] [--bcc <e>] [--reply-to <e>] [--label <l>] [--attachment <a>] [--run-id <id>] [--dry-run]
-  reply       --message-id <id> [--text @reply.txt] [--html @reply.html] [--run-id <id>]
-  reply-all   --message-id <id> [--text @reply.txt] [--html @reply.html] [--run-id <id>]
-  forward     --message-id <id> --to <email> [--text @body.txt] [--html @body.html] [--run-id <id>]
+  send        --to <email[,email]> --subject <s> [--text @body.txt] [--html @body.html] [--cc <e>] [--bcc <e>] [--reply-to <e>] [--label <l>] [--attachment <a>] [--run-id <id>] [--lead-id <id>] [--dry-run]
+  reply       --message-id <id> [--text @reply.txt] [--html @reply.html] [--run-id <id>] [--lead-id <id>]
+  reply-all   --message-id <id> [--text @reply.txt] [--html @reply.html] [--run-id <id>] [--lead-id <id>]
+  forward     --message-id <id> --to <email> [--text @body.txt] [--html @body.html] [--run-id <id>] [--lead-id <id>]
   threads     [--limit N]
   thread      <thread_id>
   messages    [--limit N]
@@ -1509,9 +1738,9 @@ function usage() {
   product pause|unpause      stop / resume cron on a product
   hypothesis create|status   create or update hypotheses
   hypothesis pause|unpause   stop / resume work on a hypothesis
+  lead list|add|show|status  the sheet: list by status / record / inspect / set
+  touch add|mute|unmute      record an interaction / judge a non-reply
   run start|finish           start / finish a run
-  log action                 record one outreach touch
-  action escalate            flag an action for human attention
   feedback record|delete     leave a free-text nudge on a hypothesis or product
   context [<slug>|...]       pull product or hypothesis context
 
@@ -1564,50 +1793,6 @@ function runUsage() {
          → seals the run with the narrative blob`)
 }
 
-function logUsage() {
-  console.log(`autark log
-
-  action --run-id <id> --channel <c> --title <t>
-         [--url <u>]                          # github / reddit / hn / blog / gist / linkedin
-         [--agentmail-thread-id <uuid>]       # email
-         [--agentmail-inbox-id <email>]       # email — defaults to your inbox
-         [--recipient <email>]                # email
-         [--our-comment-id <id>]              # see "Always capture our_comment_id" below
-         [--metadata @./meta.json]            # any other channel-specific extras
-         [--escalate --reason "<why>"]        # flag this action as needs_human
-
-One row per external touch. Body content stays in AgentMail/GitHub/etc;
-this just records the pointer + the title agents see on the dashboard.
-
-  Log the URL of YOUR comment, not the parent
-
-  The reply-state cron parses the comment id out of the --url you log to
-  detect "did anyone reply to you?". Most channels' URLs already contain
-  the id; you just have to log the permalink of your OWN comment, not the
-  issue/post URL you replied to.
-
-    github (issue or PR comment):
-      use the response's html_url, ends in #issuecomment-<id>
-        NEW_URL=$(gh api repos/<o>/<r>/issues/<n>/comments \\
-          -X POST -f body=@body.md --jq .html_url)
-
-    gist:
-      ends in #gistcomment-<id>
-
-    hn:
-      .../item?id=<your_new_item_id> (your id, not the parent's)
-
-    reddit:
-      .../r/<sub>/comments/<thread>/<title>/<your_comment_id>/
-
-    substack:
-      Substack permalinks don't always include the comment id, so for
-      this channel use --our-comment-id <id> from the response body.
-
-  Escape hatch: --our-comment-id <id> tucks the id into metadata. Use it
-  when the URL pattern can't encode the comment (Substack, edge HN cases).`)
-}
-
 function contextUsage() {
   console.log(`autark context
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "autark-cli",
-  "version": "0.5.7",
-  "description": "CLI for autark \u2014 hypothesis-driven product runbooks. Track products, hypotheses, runs, and actions from the terminal.",
+  "version": "0.7.0",
+  "description": "CLI for autark — hypothesis-driven product runbooks. Track products, hypotheses, runs, and actions from the terminal.",
   "type": "module",
   "license": "MIT",
   "bin": {