autark-cli 0.5.8 → 0.7.1

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,6 +24,7 @@ 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', 'find_leads.md', 'double-down.md', 'check.md', 'followup.md']
 const LEAD_TEMPLATE = {
@@ -226,23 +227,23 @@ async function main() {
   }
   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)
@@ -540,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`)
 }
 
@@ -705,6 +712,99 @@ async function leadAdd(rest) {
   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)
 }
@@ -718,6 +818,19 @@ function leadUsage() {
   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:
@@ -763,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) {
@@ -1061,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) {
@@ -1069,6 +1130,10 @@ async function mailReply(rest, mode) {
   const creds = requireAgentmailCredentials()
   const messageId = required(opts['message-id'] || opts.message_id || opts._[0], '--message-id')
   const body = mailBody(opts)
+  // Reply addresses the SENDER of the target message. Following up on your
+  // own last message therefore self-sends unless you override the recipient.
+  // --to forces who receives the reply (the follow-up case).
+  if (opts.to !== undefined) body.to = listOpt(opts.to, '--to')
   const endpoint = mode === 'reply-all' ? 'reply-all' : 'reply'
   const result = await agentmailRequest('POST', `/inboxes/${encodeURIComponent(creds.inboxId)}/messages/${encodeURIComponent(messageId)}/${endpoint}`, body)
   const action = await maybeLogMailAction(opts, {
@@ -1079,7 +1144,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) {
@@ -1097,17 +1163,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) {
@@ -1181,6 +1248,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
@@ -1616,10 +1705,12 @@ 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> [--to <email>] [--text @reply.txt] [--html @reply.html] [--run-id <id>] [--lead-id <id>]
+              --to overrides the recipient — REQUIRED when following up on your
+              own message (plain reply answers its sender: you)
+  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]
@@ -1653,10 +1744,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 add|template          record sourced v2 leads
+  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
 
@@ -1709,50 +1799,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.8",
-  "description": "CLI for autark \u2014 hypothesis-driven product runbooks. Track products, hypotheses, runs, and actions from the terminal.",
+  "version": "0.7.1",
+  "description": "CLI for autark — hypothesis-driven product runbooks. Track products, hypotheses, runs, and actions from the terminal.",
   "type": "module",
   "license": "MIT",
   "bin": {