all.source | all.source

The agent-native task CLI. Event-sourced, TOON-optimized, built for AI agents and humans alike.

Inspired by beads_rust — the pioneering local-first issue tracker that proved agents can self-manage tasks via CLI. Chronis takes that idea further with event sourcing, temporal history, and token-optimized output.

Install

cargo install chronis

Quick Start

cn init                                    # Create workspace
cn task create "Design auth module" -p p0  # Create a task
cn list --toon                             # Agent-optimized listing
cn ready --toon                            # Show unblocked tasks
cn claim <id> --toon                       # Claim a task
cn done <id> --toon                        # Complete it
cn archive --all-done                      # Clean up
cn sync                                    # Sync via git

TOON: Agent-Native Output

Pass --toon to any command for TOON (Token-Oriented Object Notation) output — the same format used by AllSource's MCP server. ~50% fewer tokens than JSON. No braces, no quotes, no wasted context window.

# Human output: ~180 tokens of box-drawing and padding
cn list
╭──────────┬──────┬──────────────────┬─────┬─────────────╮
│ ID       │ Type │ Title            │ Pri │ Status      │
├──────────┼──────┼──────────────────┼─────┼─────────────┤
│ t-abc1   │ task │ Design auth      │ p0  │ open        │
╰──────────┴──────┴──────────────────┴─────┴─────────────╯

# TOON output: ~60 tokens, same information
cn list --toon
[id|type|title|pri|status|claimed|blocked_by|parent|archived]
t-abc1|task|Design auth|p0|open||||false

Mutations return single-line acks: ok:claimed:t-abc1, ok:done:t-abc1. An entire agent loop — ready, claim, work, done — burns ~20 tokens of CLI overhead instead of 200+.

Commands

cn task create <title>Create a task with -p, --type, --parent, --blocked-by, -d flags

cn list [--status]List tasks (--archived, --all, --toon)

cn readyShow open, unblocked tasks

cn show <id>Task details, children, and event timeline

cn claim <id>Claim a task (--cascade for epics, uses CN_AGENT_ID)

cn done <id>Complete a task (--reason, --cascade)

cn approve <id>Approve a task

cn archiveArchive tasks (--all-done, --done-before, or specific IDs)

cn unarchive <ids>Restore archived tasks

cn dep add/removeManage task dependencies

cn syncGit-based sync (pull, import, export, commit, push)

cn tuiInteractive terminal UI dashboard

cn serveEmbedded web viewer (Axum + HTMX)

All commands accept --toon for agent-optimized output.

Bulk Actions

Cascade operations apply to a task and all its children — close out an entire epic in one command:

cn claim <epic-id> --cascade              # Claim epic + all children
cn done <epic-id> --cascade               # Complete epic + all children
cn done <epic-id> --cascade --reason="Done"

Archiving

Hide completed tasks from default listings without deleting them. Event-sourced — nothing is lost, everything is restorable.

cn archive --all-done            # Archive all completed tasks
cn archive --done-before 30      # Archive tasks done 30+ days ago
cn unarchive t-abc1              # Restore an archived task
cn list --archived               # Show only archived tasks

Git Sync

Sync task state across machines via git. Events are exported to an append-only JSONL file — no merge conflicts, UUID-based dedup prevents duplicates.

cn sync   # pull → import → export → commit → push

Chronis vs beads_rust

Feature	beads_rust	Chronis
Agent output	JSON / human text	TOON (~50% fewer tokens)
Storage	SQLite + JSONL	Event-sourced (WAL + Parquet)
History	Current state only	Full temporal event stream
Cascade ops	Manual scripting	--cascade flag
Archiving	Not available	cn archive --all-done
Approval gates	Not available	cn approve
Git sync	commit && push	Append-only JSONL + UUID dedup
TUI / Web UI	Separate binaries	Built-in (cn tui, cn serve)

Both tools share the same core workflow: ready → claim → done → sync. Migrate with cn migrate-beads.

Architecture

Chronis embeds AllSource Core as a library. Every mutation emits an event into the WAL. A TaskProjection folds events into queryable state in a DashMap (~12µs reads, 469K events/sec throughput).

.chronis/
  wal/            # Write-ahead log (CRC32, fsync)
  storage/        # Parquet columnar storage
  sync/           # Git sync exchange (events.jsonl)
  config.toml     # Workspace config

Source & Docs

Full source, README, and contribution guide on GitHub. Published on crates.io.