Command reference

Inspect agent catalog readiness

Usage:
  tallpine agent [command]

Available Commands:
  ls          List supported agents and local auth readiness

List supported agents and local auth readiness

Usage:
  tallpine agent ls [flags]

Aliases:
  ls, list

Flags:
      --json      Output raw agent catalog JSON
      --refresh   Force fresh local install and auth checks before listing

Manage recurring session automations

Usage:
  tallpine automation [command]

Aliases:
  automation, automations

Available Commands:
  create      Create a recurring automation
  delete      Delete an automation and run history
  get         Get an automation
  list        List automations
  runs        List automation run history
  update      Update an automation

Create a recurring automation

Usage:
  tallpine automation create [flags]

Flags:
      --cron string       Supported five-field cron expression
      --disabled          Create disabled
      --harness string    Agent harness (empty uses project default)
      --json              Print JSON
      --kind string       Session kind: worker or orchestrator (default "worker")
      --name string       Display name
      --project string    Project id
      --prompt string     Session task prompt
      --rrule string      RFC 5545 recurrence rule
      --timezone string   IANA timezone (defaults to local zone when available)

Delete an automation and run history

Usage:
  tallpine automation delete <id> [flags]

Aliases:
  delete, rm

Flags:
  -y, --yes    Skip confirmation prompt

Get an automation

Usage:
  tallpine automation get <id> [flags]

Flags:
      --json   Print JSON

List automations

Usage:
  tallpine automation list [flags]

Flags:
      --enabled          Filter by enabled state
      --json             Print JSON
      --project string   Filter by project id

List automation run history

Usage:
  tallpine automation runs <id> [flags]

Flags:
      --cursor string   Opaque page cursor
      --json            Print JSON
      --limit int       Maximum runs (1-100) (default 50)

Update an automation

Usage:
  tallpine automation update <id> [flags]

Flags:
      --cron string       Replace schedule with cron
      --enabled           Enable or disable future dispatch (default true)
      --harness string    Harness; empty uses project default
      --json              Print JSON
      --kind string       Session kind
      --name string       New display name
      --prompt string     New task prompt
      --rrule string      Replace schedule with RRule
      --timezone string   IANA timezone

File, triage and order deferred work for a project. Items start in the inbox when an agent files them; accepted items are open and run in drag order.

Usage:
  tallpine backlog [command]

Available Commands:
  accept      Accept an inbox item into the open list
  add         File a backlog item
  delete      Permanently delete a done or dropped item (and its closed children)
  done        Mark an item done
  drop        Drop an item (kept in the archive)
  edit        Edit an item's title, note, done-when, scope, parent or agent notes
  hold        Hold an item so next skips it
  link        Link an item to a session, pr, issue, artifact, memory, item or blocked-by item
  ls          List backlog items in drag order
  move        Move an item before or after another in the drag order
  next        Show the topmost open, unheld, unblocked, non-parent item
  purge       Permanently delete all done and/or dropped items
  reopen      Reopen a done or dropped item
  run         Run mode: plan and drive "finish the backlog"
  set         Set custom fields on an item (key= clears one)
  show        Show one backlog item with its links
  unhold      Remove an item's hold
  unlink      Remove a link from an item

Accept an inbox item into the open list

Usage:
  tallpine backlog accept <ref> [flags]

Flags:
      --json             Print JSON
      --project string   Project id (default: TALLPINE_PROJECT_ID, current session, or current registered repo)

File a backlog item. With - the title is the first line of stdin and the rest is the note, so a heredoc keeps backticks and quotes literal. Agents file to the inbox; --open (orchestrator and humans) skips it.

Usage:
  tallpine backlog add <title|-> [flags]

Flags:
      --agent-notes string   Tallpine notes
      --done-when string     Acceptance criteria
      --hold string          Hold reason (held items are skipped by next)
      --json                 Print JSON
      --note string          Markdown note
      --open                 Skip the inbox (orchestrator only; humans always create open items)
      --parent string        Parent item ref (one level of nesting only)
      --project string       Project id (default: TALLPINE_PROJECT_ID, current session, or current registered repo)
      --scope string         Publishing scope override: local, pr or pr-merge

Hard-deletes a closed item, its links, and its closed children. Open and inbox items are refused, as is a parent with any open child. Refs are never reused.

Usage:
  tallpine backlog delete <ref> [flags]

Flags:
      --json             Print JSON
      --project string   Project id (default: TALLPINE_PROJECT_ID, current session, or current registered repo)
  -y, --yes              Skip the confirmation prompt

Mark an item done

Usage:
  tallpine backlog done <ref> [flags]

Flags:
      --json             Print JSON
      --project string   Project id (default: TALLPINE_PROJECT_ID, current session, or current registered repo)
      --reason string    Why it closed

Drop an item (kept in the archive)

Usage:
  tallpine backlog drop <ref> [flags]

Flags:
      --json             Print JSON
      --project string   Project id (default: TALLPINE_PROJECT_ID, current session, or current registered repo)
      --reason string    Why it closed

Edit an item's title, note, done-when, scope, parent or agent notes

Usage:
  tallpine backlog edit <ref> [flags]

Flags:
      --agent-notes string   New orchestrator notes
      --done-when string     New acceptance criteria
      --json                 Print JSON
      --no-parent            Detach from the parent
      --note string          New markdown note
      --parent string        Parent item ref
      --project string       Project id (default: TALLPINE_PROJECT_ID, current session, or current registered repo)
      --scope string         Publishing scope: local, pr, pr-merge (empty clears)
      --title string         New title

Hold an item so next skips it

Usage:
  tallpine backlog hold <ref> <reason...> [flags]

Flags:
      --json             Print JSON
      --project string   Project id (default: TALLPINE_PROJECT_ID, current session, or current registered repo)

Link an item to a session, pr, issue, artifact, memory, item or blocked-by item

Usage:
  tallpine backlog link <ref> <kind:value> [flags]

Flags:
      --json             Print JSON
      --project string   Project id (default: TALLPINE_PROJECT_ID, current session, or current registered repo)

List backlog items in drag order

Usage:
  tallpine backlog ls [flags]

Aliases:
  ls, list

Flags:
      --held             Only held items
      --json             Print JSON
      --limit int        Maximum items (default 100)
      --parent string    Only children of this parent ref
      --project string   Project id (default: TALLPINE_PROJECT_ID, current session, or current registered repo)
      --q string         Title substring
      --state string     Only inbox, open, done or dropped items; all includes closed ones
      --unheld           Only unheld items

Move an item before or after another in the drag order

Usage:
  tallpine backlog move <ref> [flags]

Flags:
      --after string     Place directly after this item
      --before string    Place directly before this item
      --json             Print JSON
      --project string   Project id (default: TALLPINE_PROJECT_ID, current session, or current registered repo)

Show the topmost open, unheld, unblocked, non-parent item

Usage:
  tallpine backlog next [flags]

Flags:
      --json             Print JSON
      --parent string    Only children of this parent ref
      --project string   Project id (default: TALLPINE_PROJECT_ID, current session, or current registered repo)

Hard-deletes closed items in bulk. Pick --done and/or --dropped; --older-than keeps recent ones. A parent with an open child is skipped. Use --dry-run to list what would go.

Usage:
  tallpine backlog purge [flags]

Flags:
      --done                Purge done items
      --dropped             Purge dropped items
      --dry-run             List what would be deleted without deleting
      --json                Print JSON
      --older-than string   Only items closed more than this long ago, in days (for example 30d)
      --project string      Project id (default: TALLPINE_PROJECT_ID, current session, or current registered repo)
  -y, --yes                 Skip the confirmation prompt

Reopen a done or dropped item

Usage:
  tallpine backlog reopen <ref> [flags]

Flags:
      --json             Print JSON
      --project string   Project id (default: TALLPINE_PROJECT_ID, current session, or current registered repo)

Run mode keeps one durable run per project: the plan (lanes of items, a model each), every item's progress, and the end summary. The orchestrator writes the plan and the progress; the Backlog page reads them. On by default; TALLPINE_BACKLOG_RUN=off on the daemon turns it off.

Usage:
  tallpine backlog run [command]

Available Commands:
  finish      End the run with your summary (landed / waiting on the owner / held)
  item        Record one planned item's progress
  pause       Pause a running run (for example at the usage limit)
  plan        Save the run's plan (replaces the previous one)
  resume      Resume a paused run
  start       Create a run for all open items, some items, or one parent's children
  status      Show a run (default: the open run) with its plan and progress
  stop        Finish the work in flight and start nothing new

End the run. Refuses while an item is still active or in review. The page adds cost and elapsed time per item from the usage ledgers; write the narrative only.

Usage:
  tallpine backlog run finish <run> (--summary <text> | --summary-file <file|->) [flags]

Flags:
      --json                  Print JSON
      --project string        Project id (default: TALLPINE_PROJECT_ID, current session, or current registered repo)
      --summary string        Summary text
      --summary-file string   Read the summary from a file, or - for stdin

Record progress. active needs a free slot (at most 3 items are active per project) and a running run. needs_you needs --question: one specific question for the owner. held needs --reason. A second failed holds the item.

Usage:
  tallpine backlog run item <run> <item> --status queued|active|in_review|needs_you|landed|held|failed [flags]

Flags:
      --json              Print JSON
      --project string    Project id (default: TALLPINE_PROJECT_ID, current session, or current registered repo)
      --question string   The one question for the owner (needs_you)
      --reason string     Why it is held or failed
      --status string     New status

Pause a running run (for example at the usage limit)

Usage:
  tallpine backlog run pause <run> [flags]

Flags:
      --json               Print JSON
      --project string     Project id (default: TALLPINE_PROJECT_ID, current session, or current registered repo)
      --reason string      Why, for example the Claude 5-hour usage limit
      --resume-at string   When the limit resets (RFC 3339), shown on the run card

Save the plan as JSON: {"lanes":[[{"ref":"B12","model":"opus"},{"ref":"B14","model":"sonnet"}],[{"ref":"B13","model":"haiku"}]]}. Lanes run in parallel, items inside a lane in order. A blocked item must follow its blocker in the same lane. Parents are not planned; plan their children. The first plan starts the run.

Usage:
  tallpine backlog run plan <run> --file <plan.json|-> [flags]

Flags:
      --file string      Plan JSON file, or - for stdin
      --json             Print JSON
      --project string   Project id (default: TALLPINE_PROJECT_ID, current session, or current registered repo)

Resume a paused run

Usage:
  tallpine backlog run resume <run> [flags]

Flags:
      --json             Print JSON
      --project string   Project id (default: TALLPINE_PROJECT_ID, current session, or current registered repo)

Create a run. Only one run is open per project. Name the publishing scope the owner chose for this run: local (commit in the worktree), pr (green and reviewed PR) or pr-merge (merged PR).

Usage:
  tallpine backlog run start --scope local|pr|pr-merge (--all | --parent <ref> | <ref>...) [flags]

Flags:
      --all              Every open item
      --json             Print JSON
      --parent string    Run the children of this parent item
      --project string   Project id (default: TALLPINE_PROJECT_ID, current session, or current registered repo)
      --scope string     Publishing scope for the run: local, pr or pr-merge

Show a run's state, lanes, every item's status, cost and elapsed time. Check it at the start of every turn while a run is open.

Usage:
  tallpine backlog run status [<run>] [flags]

Flags:
      --json             Print JSON
      --project string   Project id (default: TALLPINE_PROJECT_ID, current session, or current registered repo)

Finish the work in flight and start nothing new

Usage:
  tallpine backlog run stop <run> [flags]

Flags:
      --json             Print JSON
      --project string   Project id (default: TALLPINE_PROJECT_ID, current session, or current registered repo)

Set custom fields on an item (key= clears one)

Usage:
  tallpine backlog set <ref> key=value... [flags]

Flags:
      --json             Print JSON
      --project string   Project id (default: TALLPINE_PROJECT_ID, current session, or current registered repo)

Show one backlog item with its links

Usage:
  tallpine backlog show <ref> [flags]

Flags:
      --json             Print JSON
      --project string   Project id (default: TALLPINE_PROJECT_ID, current session, or current registered repo)

Remove an item's hold

Usage:
  tallpine backlog unhold <ref> [flags]

Flags:
      --json             Print JSON
      --project string   Project id (default: TALLPINE_PROJECT_ID, current session, or current registered repo)

Remove a link from an item

Usage:
  tallpine backlog unlink <ref> <kind:value> [flags]

Flags:
      --json             Print JSON
      --project string   Project id (default: TALLPINE_PROJECT_ID, current session, or current registered repo)

Inspect and control the target-isolated browser owned by the current Tallpine session.

The desktop app must be open. Commands operate the same live page the user sees,
including while the Browser panel is hidden.

Usage:
  tallpine browser [command]

Available Commands:
  act            Resolve an element by description and act on it, snapshotting and retrying automatically
  check          Check a checkbox or switch
  click          Click an element reference from the latest snapshot
  console        Print captured browser console
  dblclick       Double-click an element reference from the latest snapshot
  devtools       Open and control Chromium's DevTools for the active page
  dialog         Inspect or handle a page dialog
  drag           Drag one element onto another
  errors         Print captured browser errors
  fill           Replace the value of a form control
  focus          Focus an element reference from the latest snapshot
  frame          Switch automation into a frame or back to the main document
  get            Read a page or element property
  highlight      Visually highlight an element without changing page state
  hover          Move the pointer over an element
  network        Temporarily capture sanitized network request metadata
  open           Open a URL in this session's browser
  press          Press a key or modifier chord such as Enter or Control+A
  screenshot     Capture the current page to a PNG file
  scroll         Scroll the page in one direction
  scrollintoview Scroll an element reference into view
  select         Select an option value
  snapshot       Print a compact accessibility snapshot with actionable element refs
  status         Show whether the desktop browser runtime is connected
  tab            Create, select, or close a browser tab
  tabs           List this session's browser tabs
  type           Type text at the current cursor position in a form control
  uncheck        Uncheck a checkbox or switch
  unhighlight    Remove the current element highlight
  viewport       emulate a fixed viewport size for the page (or reset it)
  wait           Wait for page load, DOM stability, time, text, selector, or URL state

Flags:
      --json   print the structured response as JSON

Snapshots, finds the best-matching element for <instruction> against role/name/text
(no LLM call — deterministic matching, same as reading a snapshot yourself), and performs
--action on it (default click). Retries once on a stale reference. If the match is
ambiguous or absent, returns the candidates or snapshot instead of guessing — fall back
to a manual snapshot/click, retry with --nth, or refine the instruction.

Usage:
  tallpine browser act <instruction> [flags]

Flags:
      --action string               verb to perform on the matched element (click, dblclick, focus, hover, fill, type, check, uncheck) (default "click")
      --expect-dialog               wait for a pending confirm or prompt dialog after dispatch
      --expect-dom-change           wait for the accessibility snapshot to change after dispatch
      --expect-navigation           wait for a main-frame or in-page navigation after dispatch
      --expect-text string          wait for this page text after dispatch
      --expect-url string           wait for a URL containing this value after dispatch
      --nth int                     0-based index to disambiguate when multiple candidates match equally
      --postcondition-timeout int   postcondition timeout in milliseconds (default 10000)
      --value string                text to fill/type; required when --action is fill or type

Global Flags:
      --json   print the structured response as JSON

Check a checkbox or switch

Usage:
  tallpine browser check <ref> [flags]

Flags:

Global Flags:
      --json   print the structured response as JSON

Click an element reference from the latest snapshot

Usage:
  tallpine browser click <ref> [flags]

Flags:
      --human   approach the element along a curved, human-like pointer path

Global Flags:
      --json   print the structured response as JSON

Print captured browser console

Usage:
  tallpine browser console [flags]

Flags:

Global Flags:
      --json   print the structured response as JSON

Double-click an element reference from the latest snapshot

Usage:
  tallpine browser dblclick <ref> [flags]

Flags:

Global Flags:
      --json   print the structured response as JSON

Open and control Chromium's DevTools for the active page

Usage:
  tallpine browser devtools [flags]
  tallpine browser devtools [command]

Available Commands:
  close       Close Chromium DevTools
  open        Open the real Chromium DevTools frontend

Flags:

Global Flags:
      --json   print the structured response as JSON

Close Chromium DevTools

Usage:
  tallpine browser devtools close [flags]

Flags:

Global Flags:
      --json   print the structured response as JSON

Open the real Chromium DevTools frontend

Usage:
  tallpine browser devtools open [flags]

Flags:

Global Flags:
      --json   print the structured response as JSON

Inspect or handle a page dialog

Usage:
  tallpine browser dialog [command]

Available Commands:
  accept      Accept a dialog, optionally supplying prompt text
  dismiss     dismiss the current page dialog
  status      status the current page dialog

Flags:

Global Flags:
      --json   print the structured response as JSON

Accept a dialog, optionally supplying prompt text

Usage:
  tallpine browser dialog accept [text] [flags]

Flags:

Global Flags:
      --json   print the structured response as JSON

dismiss the current page dialog

Usage:
  tallpine browser dialog dismiss [flags]

Flags:

Global Flags:
      --json   print the structured response as JSON

status the current page dialog

Usage:
  tallpine browser dialog status [flags]

Flags:

Global Flags:
      --json   print the structured response as JSON

Drag one element onto another

Usage:
  tallpine browser drag <source-ref> <target-ref> [flags]

Flags:
      --human   move along a curved, human-like pointer path

Global Flags:
      --json   print the structured response as JSON

Print captured browser errors

Usage:
  tallpine browser errors [flags]

Flags:

Global Flags:
      --json   print the structured response as JSON

Replace the value of a form control

Usage:
  tallpine browser fill <ref> <text> [flags]

Flags:

Global Flags:
      --json   print the structured response as JSON

Focus an element reference from the latest snapshot

Usage:
  tallpine browser focus <ref> [flags]

Flags:

Global Flags:
      --json   print the structured response as JSON

Switch automation into a frame or back to the main document

Usage:
  tallpine browser frame <ref|main> [flags]

Flags:

Global Flags:
      --json   print the structured response as JSON

Read url, title, or text from the page, or text, value, or checked from an element reference.

Usage:
  tallpine browser get <property> [ref] [flags]

Flags:

Global Flags:
      --json   print the structured response as JSON

Visually highlight an element without changing page state

Usage:
  tallpine browser highlight <ref> [flags]

Flags:

Global Flags:
      --json   print the structured response as JSON

Move the pointer over an element

Usage:
  tallpine browser hover <ref> [flags]

Flags:

Global Flags:
      --json   print the structured response as JSON

Temporarily capture sanitized network request metadata

Usage:
  tallpine browser network [command]

Available Commands:
  clear       Clear retained requests without changing capture state
  list        List captured sanitized request metadata
  start       Start bounded metadata-only capture on the active tab
  status      Show capture state without enabling it
  stop        Stop capture and list the retained requests

Flags:

Global Flags:
      --json   print the structured response as JSON

Clear retained requests without changing capture state

Usage:
  tallpine browser network clear [flags]

Flags:

Global Flags:
      --json   print the structured response as JSON

List captured sanitized request metadata

Usage:
  tallpine browser network list [flags]

Flags:

Global Flags:
      --json   print the structured response as JSON

Start bounded metadata-only capture on the active tab

Usage:
  tallpine browser network start [flags]

Flags:
      --duration int   capture duration in seconds (maximum 300) (default 60)

Global Flags:
      --json   print the structured response as JSON

Show capture state without enabling it

Usage:
  tallpine browser network status [flags]

Flags:

Global Flags:
      --json   print the structured response as JSON

Stop capture and list the retained requests

Usage:
  tallpine browser network stop [flags]

Flags:

Global Flags:
      --json   print the structured response as JSON

Open a URL in this session's browser

Usage:
  tallpine browser open <url> [flags]

Flags:

Global Flags:
      --json   print the structured response as JSON

Press a key or modifier chord such as Enter or Control+A

Usage:
  tallpine browser press <key> [flags]

Flags:

Global Flags:
      --json   print the structured response as JSON

Capture the current page to a PNG file. JSON output writes the file and returns compact metadata.
To return inline base64 image data instead, omit the path and use --base64 with --json.
With --annotate, interactive elements are numbered in the image and the matching
snapshot refs are listed alongside it.

Usage:
  tallpine browser screenshot [path] [flags]

Flags:
      --annotate   number interactive elements in the image and list their snapshot refs
      --base64     include inline base64 image data in JSON output (cannot be used with a path)

Global Flags:
      --json   print the structured response as JSON

Scroll the page in one direction

Usage:
  tallpine browser scroll <up|down|left|right> [flags]

Flags:
      --amount int   scroll distance in CSS pixels (default 600)

Global Flags:
      --json   print the structured response as JSON

Scroll an element reference into view

Usage:
  tallpine browser scrollintoview <ref> [flags]

Flags:

Global Flags:
      --json   print the structured response as JSON

Select an option value

Usage:
  tallpine browser select <ref> <value> [flags]

Flags:

Global Flags:
      --json   print the structured response as JSON

Print a compact accessibility snapshot with actionable element refs.

With --delta, the first call returns the full tree and later calls return only
"unchanged" or the changes since the snapshot you last received. Use --delta --full
to get the full tree again.

Usage:
  tallpine browser snapshot [flags]

Flags:
      --delta         return the full tree once, then only unchanged or the changes since your last snapshot
      --full          with --delta, return the full tree and reset the delta baseline
      --interactive   include only actionable elements

Global Flags:
      --json   print the structured response as JSON

Show whether the desktop browser runtime is connected

Usage:
  tallpine browser status [flags]

Flags:

Global Flags:
      --json   print the structured response as JSON

Create, select, or close a browser tab

Usage:
  tallpine browser tab [command]

Available Commands:
  close       Close a browser tab, defaulting to the active tab
  new         Open a new tab, optionally navigating to a URL
  select      Make a browser tab active

Flags:

Global Flags:
      --json   print the structured response as JSON

Close a browser tab, defaulting to the active tab

Usage:
  tallpine browser tab close [tab-id] [flags]

Flags:

Global Flags:
      --json   print the structured response as JSON

Open a new tab, optionally navigating to a URL

Usage:
  tallpine browser tab new [url] [flags]

Flags:

Global Flags:
      --json   print the structured response as JSON

Make a browser tab active

Usage:
  tallpine browser tab select <tab-id> [flags]

Flags:

Global Flags:
      --json   print the structured response as JSON

List this session's browser tabs

Usage:
  tallpine browser tabs [flags]

Flags:

Global Flags:
      --json   print the structured response as JSON

Type text at the current cursor position in a form control

Usage:
  tallpine browser type <ref> <text> [flags]

Flags:

Global Flags:
      --json   print the structured response as JSON

Uncheck a checkbox or switch

Usage:
  tallpine browser uncheck <ref> [flags]

Flags:

Global Flags:
      --json   print the structured response as JSON

Remove the current element highlight

Usage:
  tallpine browser unhighlight [flags]

Flags:

Global Flags:
      --json   print the structured response as JSON

emulate a fixed viewport size for the page (or reset it)

Usage:
  tallpine browser viewport <width>x<height>|reset [flags]

Flags:
      --dpr float   device pixel ratio (default: the display's)
      --mobile      emulate a mobile device (meta viewport, touch)

Global Flags:
      --json   print the structured response as JSON

Wait for page load, DOM stability, time, text, selector, or URL state

Usage:
  tallpine browser wait [flags]

Flags:
      --dom-stable int         wait until the DOM has not mutated for this many milliseconds
      --load                   wait until the current page finishes loading
      --ms int                 wait for a fixed number of milliseconds
      --selector string        wait until this CSS selector exists
      --selector-gone string   wait until this CSS selector no longer exists
      --text string            wait until visible page text contains this value
      --text-gone string       wait until visible page text no longer contains this value
      --timeout int            condition timeout in milliseconds (default 10000)
      --url string             wait until the current URL contains this value

Global Flags:
      --json   print the structured response as JSON

Run a cleanup pass now: worktrees of terminated sessions whose work is merged or pushed (never ones with uncommitted changes, an operation in progress, stashes, unpushed commits, or used by a live session) and artifacts of sessions that ended longer ago than the retention window. Artifacts (version history, tool directories and deliverables) only go with --confirm-artifacts, unless the policy's autoPrune/autoDeliverables is on.

The daemon also runs a light pass hourly and a full pass daily while automatic cleanup is on (see `tallpine cleanup policy`). Its first scheduled pass is a dry run that only reports.

Usage:
  tallpine cleanup [flags]
  tallpine cleanup [command]

Examples:
  # See what a pass would remove
  tallpine cleanup --dry-run

  # Run a full pass without the prompt
  tallpine cleanup --yes

  # Also remove the artifact history of long-finished sessions and archive their deliverables
  tallpine cleanup --confirm-artifacts --yes

Available Commands:
  history     List recent cleanup runs and what each freed
  policy      Show or change the cleanup policy
  status      Show the cleanup policy, the last run and when the next passes are due

Flags:
      --confirm-artifacts   Archive or delete (per policy) deliverables of sessions past retention
      --dry-run             Report what would be removed without removing anything
      --json                Output the run report as JSON
      --light               Run the light pass (worktrees, session temp dirs and containers) instead of the full pass
  -y, --yes                 Skip the confirmation prompt

List recent cleanup runs and what each freed

Usage:
  tallpine cleanup history [flags]

Flags:
      --include-dry-runs   Include dry runs
      --json               Output as JSON
      --limit int          Number of runs to show (1-200) (default 20)

Show the cleanup policy, or change it with --set key=value (repeatable). Keys: automatic, worktrees.enabled, worktrees.retentionDays, worktrees.requireMerged, artifacts.enabled, artifacts.retentionDays, artifacts.autoPrune, artifacts.deliverableAction (archive|delete), artifacts.autoDeliverables, sessionTemp.enabled, harnessCaches.enabled, harnessCaches.retentionDays, systemTemp.enabled, systemTemp.minAgeDays, goBuildCache.enabled, containers.enabled, containers.volumeRetentionDays, branches.enabled, branches.mergedRetentionDays, branches.staleRetentionDays, branches.deleteRemote. Set systemTemp.patterns with the API or Settings.

Usage:
  tallpine cleanup policy [flags]

Examples:
  tallpine cleanup policy
  tallpine cleanup policy --set artifacts.retentionDays=14 --set worktrees.retentionDays=0

Flags:
      --json              Output as JSON
      --set stringArray   Change one setting, key=value (repeatable)

Show the cleanup policy, the last run and when the next passes are due

Usage:
  tallpine cleanup status [flags]

Flags:
      --json   Output as JSON

Create reusable project Cues or list existing Cues. Editing and deleting Cues is available in the desktop app.

Usage:
  tallpine cue [command]

Aliases:
  cue, cues

Available Commands:
  create      Create a command or agent Cue
  list        List a project's Cues

Create a command or agent Cue

Usage:
  tallpine cue create [flags]

Flags:
      --command string   Exact shell command for a command Cue
      --json             Print JSON
      --name string      Cue name
      --project string   Project id (default: TALLPINE_PROJECT_ID, current session, or current registered repo)
      --prompt string    Reusable agent instruction for an agent Cue

List a project's Cues

Usage:
  tallpine cue list [flags]

Aliases:
  list, ls

Flags:
      --json             Print JSON, including Cue definitions
      --project string   Project id (default: TALLPINE_PROJECT_ID, current session, or current registered repo)

Developer utilities

Usage:
  tallpine dev [command]

Available Commands:
  import-projects Copy project registry data into the current Tallpine data dir

Copy active project registry rows from the normal Tallpine data dir into the current TALLPINE_DATA_DIR. This copies only project metadata, project config, and workspace child repo registry; sessions and runtime state are never copied.

The target daemon must be running because the import is executed through the daemon HTTP API. Use --dry-run to report planned changes without writing.

Usage:
  tallpine dev import-projects [flags]

Flags:
      --dry-run                Report planned changes without writing
      --from-data-dir string   Tallpine data dir to read (default ~/.tallpine/data)
      --json                   Output the import report as JSON

Run local Tallpine health checks

Usage:
  tallpine doctor [flags]

Flags:
      --json   Output health checks as JSON

Import data from another install

Usage:
  tallpine import [command]

Available Commands:
  ao          Import projects and settings from the official Agent Orchestrator

Import registered projects (path, kind, workspace child repos, repo URLs, default branch and the full per-project config) and, with --settings, the global non-secret settings that map one-to-one, from an official Agent Orchestrator install (~/.ao/data) into this one.

The official install is only ever READ: its database is cloned (copy-on-write) into this product's own data dir and the clone is read, so the official app can keep running. Sessions, chat history, reports, artifacts, browser data and every token or secret are never imported.

Harnesses this product no longer ships are normalized to claude-code with a warning. The command is idempotent: re-running updates changed projects and skips unchanged ones. Use --dry-run to print the plan, and --project <id> (repeatable) to migrate gradually.

Usage:
  tallpine import ao [flags]

Examples:
  tallpine import ao --dry-run
  tallpine import ao --project my-app --project my-lib
  tallpine import ao --all --settings

Flags:
      --all                    Import every active project (required for a real run without --project)
      --dry-run                Print the plan without writing anything
      --from-data-dir string   Official data dir to read (default ~/.ao/data)
      --json                   Output the report as JSON
      --project stringArray    Source project id to import (repeatable)
      --settings               Also import the global settings that map one-to-one

Prints what merged in the last 24h, what is in flight per lane, and which in-flight PRs touch the same files (with merge-order advice). Run it before `gh pr merge` so same-area PRs from other lanes merge one at a time. Changed files come from the provider and are capped, so a huge PR may show only part of its paths.

Usage:
  tallpine merges [flags]

Flags:
      --json             Print JSON
      --project string   Project id (default: TALLPINE_PROJECT_ID, current session, or current registered repo)

Renames the old state root to the new one, rewrites path columns in the database, repairs git worktrees and copies Claude project dirs for live sessions. The old app, daemon and tmux server must be stopped. The run is resumable: rerun it after a failure.

--dry-run lists every action and changes nothing.

Usage:
  tallpine migrate-from-vo [flags]

Flags:
      --copy-harness-history   Copy Claude project dirs for live sessions (default true)
      --dry-run                List every action without changing anything
      --rollback               Move the new home back to the old one and repair worktrees (used by release-local rollback)
      --stop-orphans           SIGTERM leftover processes running out of the old data/tmp (orphaned test binaries) before checking; nothing else is signalled

Manage orchestrator sessions

Usage:
  tallpine orchestrator [command]

Available Commands:
  end         End a lane: remove its orchestrator and hand its workers to the default one
  handoff     Replace this orchestrator with a fresh one that continues from a state note
  ls          List orchestrator sessions
  new         Start an orchestrator, optionally bound to a lane

Fully removes a lane orchestrator: stops it and deletes its worktree, branch, artifacts and session record. Its live workers move to the project's default orchestrator (started if none runs) and are told. The backlog item is left as it is. Refused, changing nothing, when the orchestrator's worktree has uncommitted or unpushed changes. Name it with --lane <ref> or --session <id>.

Usage:
  tallpine orchestrator end [flags]

Flags:
      --json             Print JSON
      --lane string      Top-level backlog item ref (e.g. B12) of the lane to end
      --project string   Project id (default: TALLPINE_PROJECT_ID, current session, or current registered repo)
      --session string   Lane orchestrator session id to end

Starts a fresh orchestrator for the project, seeded to read --note and continue, then retires this one (its history stays readable). Workers keep running and report to the new orchestrator. The note must be a file in this orchestrator's artifact directory.

Usage:
  tallpine orchestrator handoff [flags]

Flags:
      --json             Output as JSON
      --note string      State note file in this orchestrator's artifact directory (default: its newest note)
      --session string   Orchestrator session id (default: $TALLPINE_SESSION_ID)

List orchestrator sessions

Usage:
  tallpine orchestrator ls [flags]

Aliases:
  ls, list

Flags:
      --json   Output as JSON

Starts the project's orchestrator, or returns the running one. With --lane <ref> it starts (or returns) the orchestrator that owns that top-level backlog item: workers it spawns join the lane and their reports come to this orchestrator only. Without --lane it is the project's default orchestrator, which also receives work that has no lane.

Usage:
  tallpine orchestrator new [flags]

Flags:
      --json             Print JSON
      --lane string      Top-level backlog item ref (e.g. B12) this orchestrator owns
      --project string   Project id (default: TALLPINE_PROJECT_ID, current session, or current registered repo)

Show the enterprise agent policy

Usage:
  tallpine policy [command]

Available Commands:
  show        Show the effective agent policy and which layer sets each setting

Shows every agent policy rule's settings, their effective values and the layer that set them (managed, env, project, user or default). A setting set by managed config or a TALLPINE_AGENT_* variable is locked and cannot be changed in Settings. With --project it shows the policy as it applies to that project, including its overrides. See docs/agent-policy.md.

Usage:
  tallpine policy show [flags]

Flags:
      --json             Output as JSON
      --project string   Show the policy as it applies to this project
      --session string   Show the policy decision this session's latest launch was made under, and what it changed

Manage pull requests

Usage:
  tallpine pr [command]

Available Commands:
  land             Run the orchestrator merge checklist and squash-merge a worker's PR
  merge            Merge a pull request
  resolve-comments Resolve review threads on a pull request (by comment or thread id)

Land a worker's PR in one step (orchestrator only). Run from a checkout of the PR's repository.

1. Finds the head of the latest approved review of the worker's PR.
2. If the PR head differs, accepts it only when the rebased patch equals the
   approved patch (git diff <old-base> <approved-head> vs <new-base> <pr-head>,
   with index lines and hunk line numbers normalized); otherwise refuses.
3. Refuses unless GitHub mergeStateStatus is CLEAN.
4. Merges via the daemon (POST prs/<n>/merge), pinned to the head.
5. --kill-worker terminates the worker session after the merge.

--dry-run prints the decision and changes nothing.

Usage:
  tallpine pr land <pr-number> [flags]

Flags:
      --allow-overlap    land a rebased PR even when main changed files the PR also touches
      --dry-run          print the decision without merging
      --kill-worker      terminate the worker session after a successful merge
      --session string   worker session that owns the PR

Merge a tracked pull request by number.

The daemon only merges the exact head the caller saw. Unless --url and
--expected-sha are given, the CLI looks the PR up among tracked sessions and
pins the merge to the head SHA of the latest Tallpine-approved review of that PR; it
refuses when there is none. Pass --expected-sha to merge a head you reviewed
yourself. If the same number is tracked in several repositories, pass --url to
disambiguate.

Usage:
  tallpine pr merge <pr-number> [flags]

Flags:
      --expected-sha string   head SHA the merge is pinned to (default: head of the latest Tallpine-approved review)
      --url string            PR URL (default: looked up from tracked sessions)

Resolve review threads on a pull request (by comment or thread id)

Usage:
  tallpine pr resolve-comments <pr-number> [comment-id...] [flags]

Open a URL in the desktop browser panel for the current session.

With no argument it opens the workspace's static entry point, falling
back to this session's existing preview target when no entry point exists.
A workspace-root-relative Markdown or HTML path opens through Tallpine's isolated
file preview. Use `tallpine preview start` for a configured dev server and
`tallpine preview clear` to empty the panel.

Usage:
  tallpine preview [url] [flags]
  tallpine preview [command]

Examples:
  tallpine preview
  tallpine preview README.md
  tallpine preview http://localhost:5173
  tallpine preview start
  tallpine preview start web
  tallpine preview status
  tallpine preview stop
  tallpine preview clear

Available Commands:
  clear       Clear the desktop browser panel for the current session
  start       Start a session-owned dev server from .ao/launch.json and open its preview
  status      Show this session's managed preview server status and recent logs
  stop        Stop this session's managed preview server

Clear the desktop browser panel for the current session

Usage:
  tallpine preview clear [flags]

Start a session-owned dev server from .ao/launch.json and open its preview

Usage:
  tallpine preview start [configuration] [flags]

Flags:
      --json   print JSON

Show this session's managed preview server status and recent logs

Usage:
  tallpine preview status [flags]

Flags:
      --json   print JSON

Stop this session's managed preview server

Usage:
  tallpine preview stop [flags]

Flags:
      --json   print JSON

Manage projects

Usage:
  tallpine project [command]

Available Commands:
  add         Register a local git repo as a project
  get         Fetch one registered project
  ls          List registered projects
  rm          Remove a registered project
  set-config  Set the per-project config

Register a local git repo as a project so sessions can be spawned in it.

The path must be an existing git repository on disk. With --as-workspace, the path may be a parent folder containing direct child git repositories; Tallpine initializes/adopts the parent as the root repo and gitignores children.

Usage:
  tallpine project add [flags]

Flags:
      --as-workspace                Register a parent folder as a workspace project (root-as-repo plus direct child repos)
      --id string                   Project id (default: derived by the daemon from the path)
      --name string                 Display name
      --orchestrator-agent string   Default orchestrator session agent
      --path string                 Absolute path to the local git repo (required)
      --worker-agent string         Default worker session agent

Fetch one registered project

Usage:
  tallpine project get <id> [flags]

Flags:
      --json   Output project as JSON

List registered projects

Usage:
  tallpine project ls [flags]

Aliases:
  ls, list

Flags:
      --json   Output projects as JSON

Remove a registered project

Usage:
  tallpine project rm <id> [flags]

Aliases:
  rm, remove, delete

Flags:
      --json   Output removal result as JSON
  -y, --yes    Skip confirmation prompt

Update a project's per-project config (branch, session prefix, env, symlinks, post-create, rules, agent model/permissions, role overrides, tracker intake, reviewers). The config is resolved when a session spawns.

Field flags MERGE into the existing config: only the flags you pass change, and every other field (including ones this CLI has no flag for) is kept. A scalar flag given an empty value (e.g. --canonical-repo-url "") removes that field; --env merges by key; --symlink, --post-create and --reviewer replace their whole list (pass one empty value to clear it); --tracker-intake=false disables intake and --no-ci=false clears the no-CI merge gate.

The merge reads the config and writes it back in two requests with no revision check, so a concurrent config change (another set-config or a settings save) made in between is overwritten.

--config-json REPLACES the whole config with the given object (overriding field flags), and --clear removes all config.

Usage:
  tallpine project set-config <id> [flags]

Flags:
      --agent-rules string            Project-specific standing instructions for worker sessions
      --agent-rules-file string       Repo-relative file containing worker standing instructions
      --canonical-repo-url string     Explicit upstream HTTPS repository URL for PR claims (same provider, host, and port as origin)
      --clear                         Clear all config
      --config-json string            Full config as a JSON object; replaces the entire config (overrides field flags)
      --default-branch string         Base branch for new worktrees; auto infers each repository's Git default
      --default-session-mode string   Interface for new worker sessions: tui or chat (empty clears; not the reasoning effort in agentConfig.mode)
      --env stringArray               Env var KEY=VALUE forwarded into sessions (repeatable)
      --github-user string            Signed-in gh account to use for this project (default: auto-pick the account that can push to the repo)
      --json                          Output the updated project as JSON
      --model string                  Agent model override (e.g. claude-opus-4-5)
      --no-ci                         Declare that the project has no CI: when the provider reports no checks for a PR head, an approved Tallpine review of that exact head is the merge gate (failing or pending checks still block); --no-ci=false restores the default
      --orchestrator-agent string     Harness override for orchestrator sessions
      --orchestrator-rules string     Project-specific standing instructions for orchestrator sessions
      --permission string             Permission mode: default, accept-edits, auto, bypass-permissions
      --post-create stringArray       Command to run after workspace creation (repeatable)
      --reviewer stringArray          Reviewer harness that reviews worker PRs (repeatable; e.g. claude-code)
      --session-prefix string         Displayed session-id prefix
      --symlink stringArray           Repo-relative path to symlink into workspaces (repeatable)
      --tracker-assignee string       Issue assignee required for intake eligibility
      --tracker-intake                Opt this project into issue intake (GitHub or GitLab; provider inferred from git origin). Inert unless the daemon also has TALLPINE_TRACKER_INTAKE=on
      --tracker-repo string           Provider-native repo for issue intake (owner/repo or group/subgroup/repo; default: derive from git origin)
      --unset-env stringArray         Env var KEY to remove from the project's env (repeatable)
      --worker-agent string           Harness override for worker sessions

Manage this machine's remote listener

Usage:
  tallpine remote-host [command]

Available Commands:
  disable     disable this machine's authenticated remote listener
  enable      enable this machine's authenticated remote listener
  status      status this machine's authenticated remote listener

disable this machine's authenticated remote listener

Usage:
  tallpine remote-host disable [flags]

enable this machine's authenticated remote listener

Usage:
  tallpine remote-host enable [flags]

Flags:
      --tunnel        Start Tallpine's managed Cloudflare tunnel for access beyond the LAN
      --tunnel-only   Bind only to loopback and start Tallpine's managed Cloudflare tunnel

status this machine's authenticated remote listener

Usage:
  tallpine remote-host status [flags]

Show a chart, table, diagram, or mockup inline in the current chat session's
thread, above your final reply. Call it before that reply, and do not announce
or restate the page in it.

The file must be one self-contained HTML document (inline <style> and <script>,
at most 1 MiB). Remote https:// resources such as a CDN chart library load
as-is; relative URLs do not resolve. A local image given by absolute path
(src="/abs/shot.png", CSS url(/abs/bg.webp), or a JS string) is put into
the page, up to 10 MiB each. Tallpine stores its own copy, so write the file
outside the repository.

Style with the theme variables Tallpine injects on :root, which follow light/dark
live: --background --foreground --muted --muted-foreground --card
--card-foreground --popover --border --border-strong --primary
--primary-foreground --accent --accent-foreground --success --warning
--destructive --code --link --chart-1..--chart-6 --radius --font-sans --font-mono.
Use a fluid width with no outer padding, card, or border; give charts fixed
pixel heights; never size html/body with 100vh. Chat sessions only: in a
terminal session use `tallpine preview` instead.

Run `tallpine render --check <file>` first: the Tallpine desktop app returns a
screenshot, the page's content height, and its console messages.

Usage:
  tallpine render <file.html> [flags]

Examples:
  tallpine render --check "$TMPDIR/turns-by-day.html" --width 390
  tallpine render "$TMPDIR/turns-by-day.html" --title "Turns by day" --height 420

Flags:
      --artifact       also keep the page as a session artifact; only when the user asks to keep it
      --check          screenshot the page in the Tallpine desktop app instead of publishing it
      --height int     first-paint frame height in CSS pixels, 80-2000; the frame then fits the page (default 400)
      --out string     with --check: PNG path to write (default: a new file in the temp directory)
      --title string   short name for the page (required unless --check)
      --width int      with --check: viewport width in CSS pixels, 240-1600; use 390 for phones (default 720)

Report worker progress to the orchestrator

Usage:
  tallpine report <free-form text> [flags]

Flags:
      --artifact stringArray      Attach an opaque artifact reference (repeatable)
      --checkpoint                Report a checkpoint
      --defer stringArray         File a follow-up you will not do now as an inbox backlog item (repeatable, at most 3, 1-200 characters each)
      --done                      Report that work is done
      --needs-input               Report that input is needed
      --note string               Structured state note
      --pr-created stringArray    Attach a created GitHub PR or GitLab MR (repeatable)
      --pr-reviewed stringArray   Attach a reviewed GitHub PR or GitLab MR (repeatable)
      --stuck                     Report that work is stuck

Manage Tallpine code reviews of a worker's PR

Usage:
  tallpine review [command]

Available Commands:
  cancel      Cancel every running review for a worker's PR (default: this session)
  ls          List reviews for a worker session (default: this session)
  submit      Record a reviewer's result for a worker's PR
  trigger     Start a Tallpine review of a worker's PR (default: this session's PR)
  wait        Block until a worker's review reaches a verdict

Cancel every running review for a worker's PR (default: this session)

Usage:
  tallpine review cancel [worker-session-id] [flags]

Aliases:
  cancel, stop

Flags:
      --session string   Worker session id (or pass it as the positional argument)

List reviews for a worker session (default: this session)

Usage:
  tallpine review ls [worker-session-id] [flags]

Aliases:
  ls, list

Flags:
      --json   Output reviews as JSON

Record a reviewer's result for a worker's PR

Usage:
  tallpine review submit [worker-session-id] [flags]

Flags:
      --body string        Review body: a path to a Markdown file, or - to read from stdin (so nothing is written into the worktree)
      --review-id string   Id of the GitHub PR review just posted (the .id from the gh api POST that created the review)
      --reviews string     JSON review results array or object: a path, or - to read from stdin
      --run string         Review run id (required)
      --session string     Worker session id (or pass it as the positional argument)
      --verdict string     Review verdict: approved or changes_requested (required)

Start an independent Tallpine reviewer on the worker session's open PR heads.

With no session argument the calling Tallpine session is reviewed, so a worker can
request a review of its own PR. Tallpine fetches the session's PRs fresh from the
provider first, so the pass reviews the commit really on the PR. Right after
opening a PR, pass --pr <url>: Tallpine attaches it to the session if it does not
track it yet (never taking it from another active session) and reviews only it. Pass --head <sha> (for example the SHA you just pushed) to refuse, with the
actual head named, when the PR is not at that commit.

The reviewer defaults to the session's reviewer
choice, then the project's reviewer config, then the project's default worker
agent and model; --agent, --model, and --effort override it for this pass only.

A head that is already being reviewed, or already has a review, is not reviewed
again: the command fails and says why. Pass --rerun to review the same commit
again, or to add a different --agent alongside one that is still running.

The worker session's review auto-inject is turned on so the reviewer's inline
review comments are delivered to the worker; pass --no-inject to leave
that setting unchanged. Tallpine's review is internal: an approval is not a GitHub
approval and does not authorize merging.

Usage:
  tallpine review trigger [worker-session-id] [flags]

Aliases:
  trigger, execute, restart

Flags:
      --effort string    Reviewer reasoning effort for this pass only
      --harness string   Reviewer agent / --agent for this pass only (e.g. claude-code, codex)
      --head string      Expected PR head commit SHA (full or abbreviated); refuses if the provider reports a different head
      --model string     Reviewer model for this pass only
      --no-inject        Leave the session's review auto-inject setting unchanged
      --pr string        Review only this pull request URL, attaching it to the session if Tallpine does not track it yet (default: every eligible PR on the session)
      --rerun            Review heads that already have a review again, or add another reviewer alongside a running one
      --session string   Worker session id (or pass it positionally; default: this Tallpine session)

Block until every review pass on the worker's PR head has ended, then print the verdict.
Exit status: 0 approved, 10 changes requested, 11 failed or cancelled without a verdict, 12 timed out, 13 no review run for the open PR's current head.
Waits on the session's open PRs only; --pr N picks one. Prints one line per PR: verdict, PR number, head SHA.

Usage:
  tallpine review wait [worker-session-id] [flags]

Flags:
      --pr int             Wait on this PR number only
      --session string     Worker session id (or pass it as the positional argument)
      --timeout duration   Give up after this long (exit status 12) (default 30m0s)

Send a message to a running agent session and report what happened to it:
"delivered" (written to the session; for a terminal that does not prove the
agent has read it), "queued for next turn" (accepted, but the
agent will only see it after its current turn or an interface transition) or
"duplicate" (a message with that id was already accepted), with a delivery id
when one exists. A message the agent cannot take right now is
refused with an error instead of being silently dropped.

Usage:
  tallpine send [flags]

Flags:
      --client-message-id string   Stable steering delivery handle
      --message string             Message body (required unless --recover-only)
      --recover-only               Recover a steering result without contacting the provider
      --session string             Session id (required)
      --steer                      Steer an active Chat turn, or start the next turn when idle

Manage agent sessions

Usage:
  tallpine session [command]

Available Commands:
  approvals    List a worker's pending permission prompts with the exact command or tool input
  approve      Approve a worker's pending permission prompt (orchestrator, when the project allows it)
  claim-pr     Attach an existing PR to a session
  cleanup      Clean up terminated sessions
  deny         Deny a worker's pending permission prompt (orchestrator, when the project allows it)
  exit-agent   Exit an agent without terminating its Tallpine session
  get          Fetch one session
  history      Print a session's turns, newest first (defaults to the current session)
  kill         Terminate a session
  ls           List sessions
  rename       Rename a session
  restore      Restore a terminated session or resume an exited agent
  resume-agent Resume an exited agent in its existing Tallpine session
  task         Manage a session agent's background tasks
  top          Show memory used by each live session, largest first
  usage        Print a session's cumulative token usage by model (defaults to the current session)

List a worker's pending permission prompts with the exact command or tool input

Usage:
  tallpine session approvals <session> [flags]

Flags:
      --json   Output as JSON

Approve a worker's pending permission prompt (orchestrator, when the project allows it)

Usage:
  tallpine session approve <session> <requestId> [flags]

Flags:
      --note string   Short reason recorded in the audit trail

Attach an existing PR to a session. When session-id is omitted, the current session is read from TALLPINE_SESSION_ID.

Claiming updates PR ownership metadata only; it does not check out the PR branch. Verify the workspace branch and HEAD before editing.

Usage:
  tallpine session claim-pr [<session-id>] <pr-ref> [flags]

Examples:
  # From inside a Tallpine worker session
  tallpine session claim-pr 88

  # Target a session explicitly
  tallpine session claim-pr mer-3 88

Flags:
      --json             Output as JSON
      --no-takeover      Refuse if another active session owns the PR
  -p, --project string   Project id to scope the lookup

Clean up terminated sessions by reclaiming eligible workspaces. Dirty worktrees are skipped by the daemon.

Usage:
  tallpine session cleanup [flags]

Flags:
      --dry-run          Preview which sessions would be cleaned without removing anything
  -p, --project string   Filter by project ID
  -y, --yes              Skip confirmation prompt

Deny a worker's pending permission prompt (orchestrator, when the project allows it)

Usage:
  tallpine session deny <session> <requestId> [flags]

Flags:
      --note string   Short reason recorded in the audit trail

Exit an agent without terminating its Tallpine session

Usage:
  tallpine session exit-agent <id> [flags]

Flags:
      --json             Output as JSON
  -p, --project string   Project id to scope the lookup

Fetch one session

Usage:
  tallpine session get <id> [flags]

Flags:
      --json             Output as JSON
  -p, --project string   Project id to scope the lookup

Print a session's turns, newest first (defaults to the current session)

Usage:
  tallpine session history [id] [flags]

Flags:
      --limit int    Turns to print (at most 50) (default 10)
      --offset int   Number of newest turns to skip

Terminate a session

Usage:
  tallpine session kill <id> [flags]

Flags:
  -p, --project string   Project id to scope the lookup

List sessions

Usage:
  tallpine session ls [flags]

Flags:
  -a, --all                  Include orchestrator sessions
      --include-terminated   Include terminated sessions
      --json                 Output as JSON
  -p, --project string       Filter by project ID

Rename a session

Usage:
  tallpine session rename <id> <name> [flags]

Flags:
  -p, --project string   Project id to scope the lookup

Restore a terminated session or resume an exited agent

Usage:
  tallpine session restore <id> [flags]

Flags:
  -p, --project string   Project id to scope the lookup

Resume an exited agent in its existing Tallpine session

Usage:
  tallpine session resume-agent <id> [flags]

Flags:
      --json             Output as JSON
  -p, --project string   Project id to scope the lookup

Manage a session agent's background tasks

Usage:
  tallpine session task [command]

Available Commands:
  stop        Stop one background task of a session's agent

Stop a background task (a background command or monitor) the session's agent is running. A worker may stop its own tasks; an orchestrator may also stop those of its project's workers. The task ids are in `tallpine session get <session> --json` under backgroundTasks.

Usage:
  tallpine session task stop <session> <taskId> [flags]

Show resident memory of each live session's process tree, largest first. Free memory with `tallpine session kill <id>` or `tallpine session cleanup`.

Usage:
  tallpine session top [flags]

Flags:
  -a, --all              Include orchestrator sessions
      --json             Output as JSON
  -p, --project string   Filter by project ID

Print a session's cumulative token usage by model (defaults to the current session)

Usage:
  tallpine session usage [id] [flags]

Flags:
      --json   Print machine-readable JSON

Spawn an agent session in a registered project, or a standalone worker with --standalone.

The session runs the chosen agent in a
fresh isolated workspace. Git projects use worktrees; standalone agents use a Tallpine-managed plain directory.

Usage:
  tallpine spawn [flags]

Flags:
      --backlog string            Backlog item ref (e.g. B12) to work on: its title, note, done-when and agent notes join the task, and the session is linked to it
      --branch string             Branch for git project sessions (default: tp/<session-id>/root; unsupported for standalone or Scratch sessions)
      --claim-pr string           Claim PR ownership metadata only for the spawned session; does not check out the PR branch
      --effort string             Reasoning effort override for this session only (e.g. low, medium, high); empty defers to the agent/model default
      --force                     With --backlog, start the item even if it is held
      --harness string            Agent harness / --agent: claude-code, codex, kiro, deepseek-harness (default: project worker.agent; orchestrator spawns default to project orchestrator.agent; required if the project has none)
      --issue string              Issue id to associate with the session
      --kind string               Session role: worker or orchestrator (default: worker)
      --mode string               Initial session interface: chat (structured agent connection) or tui (the agent's native terminal). Omitted uses the daemon default; compatible sessions can switch later.
      --model string              Agent model override for this session only (e.g. sonnet, gpt-5.6-sol); overrides project/role config without changing it
      --name string               Display name shown in the sidebar (required, max 100 characters)
      --no-takeover               Refuse if another active session owns the claimed PR (requires --claim-pr)
      --output string             Deliverable for the session: artifact asks the agent to write a file in its artifact directory instead of opening a PR (default: ordinary task)
      --project string            Project id to spawn the session in (default: TALLPINE_PROJECT_ID or the current registered repo)
      --prompt string             Initial prompt for the agent
      --skip-agent-check          Skip CLI readiness warnings (the daemon still validates launch readiness)
      --standalone                Spawn a projectless worker in a Tallpine-managed plain directory (requires --agent)
      --tracker-provider string   Issue tracker provider: github or gitlab (default: github) (default "github")

Fetch (if needed) and open the Tallpine desktop app.

The desktop app now owns the daemon, state, and updates. `tallpine start` no
longer runs a daemon: it resolves the installed app (or downloads the
latest release), opens it, and exits.

Usage:
  tallpine start [flags]

Flags:
      --allow-unverified-signer   DEV ONLY: install even though this build has no expected Team ID (env TALLPINE_ALLOW_UNVERIFIED_SIGNER=1)
      --json                      Output start result as JSON
      --release-version string    Install this release tag instead of the latest (env TALLPINE_RELEASE_VERSION)

Show Tallpine daemon status

Usage:
  tallpine status [flags]

Flags:
      --json   Output status as JSON

Stop the Tallpine daemon. Agents keep running and the next daemon adopts them,
as a restart does. With --stop-agents the daemon first stops every agent's processes;
each session sleeps and resumes its conversation on its next message.

Usage:
  tallpine stop [flags]

Flags:
      --json               Output stop result as JSON
      --stop-agents        Also stop every agent's processes; sessions sleep and resume on their next message
      --timeout duration   How long to wait for daemon shutdown (default 10s)

Update this Mac's Tallpine to the newest origin/main commit with a
passing local CI row. Owner only: agent sessions (workers, orchestrators) are
refused by the daemon. The update runs as a detached job that quits and
relaunches the app and daemon, rolls back automatically if the new daemon is
not healthy, and records its result (see 'tallpine update status').

Usage:
  tallpine update [command]

Available Commands:
  start       Start the detached update job for a CI-passed commit (default: the newest)
  status      Show the installed commit, the newest CI-passed commit and the last update result

Start the detached update job for a CI-passed commit (default: the newest)

Usage:
  tallpine update start [commit] [flags]

Flags:
      --allow-downgrade   install a commit older than the installed one

Show the installed commit, the newest CI-passed commit and the last update result

Usage:
  tallpine update status [flags]

Print version information

Usage:
  tallpine version [flags]