Daisy - Personal Productivity System

Daisy is a personal productivity system you operate by talking to an AI agent. Your tasks live in a plain todo.txt file, your work log in daily markdown journals, your projects in one markdown file each — and an agent (Claude Code, Cursor) reads and maintains all of it for you:

Daisy, start a new day
Daisy, add a task: review the deploy pipeline +infra
Daisy, done "deploy pipeline"
Daisy, log Shipped the fix after pairing with ~mel
Daisy, how's +website going?

Every file is plain text in a git repository. Every change the system makes is a commit. There is no database, no daemon, no app — just files, scripts, and prompts.

What You Get

• A memory. The journal records what you actually did, day by day, with the agent logging proactively as you work. Weeks later, "what did I do about X?" has an answer.
• A trusted task list. One canonical todo.txt with four priority levels — now, next, soon, someday — synced into a daily today.md working view.
• Context that survives. Project files hold the why and how — goals, decisions, open questions — so neither you nor the agent starts cold. Work tickets stay what they should be: communication, not memory.
• Plans that outlive a session. For larger changes, a PLAN.md records research, steps, and decisions; an interrupted session resumes from verified state instead of vibes.
• A system that learns. Corrections you give the agent are recorded and periodically compiled back into its instructions — mistakes get fixed structurally, not re-corrected forever.

Philosophy

Plain text, forever. Tasks, journals, projects, and plans are markdown and todo.txt in git. Greppable, diffable, portable, and readable in fifty years. No tool lock-in — delete Daisy and your data remains legible.

AI-native, not AI-flavored. Most productivity tools added an assistant to a GUI. Daisy inverts this: the agent is the interface, and the system is designed for it — file formats with strict, machine-checkable invariants; workflows as scripts the agent invokes; instructions compiled per-context. You talk; the agent runs daisy new-day, edits todo.txt, commits.

Scripts for mechanism, prompts for judgment. Anything that must be exact (archiving a day, rotating journals, marking tasks done) is a shell script with tests. Anything that requires judgment (what to log, how to prioritize, when to ask) is prompt-driven. The agent is never trusted with format-critical mechanics, and scripts are never asked to make judgment calls.

Multiple contexts, concurrent use. A "home" is one context's data — tasks, journal, projects. One machine can run separate personal and work homes, and several workspaces can share a home at once. Home resolution is stateless and every mutation ends in a git commit, so concurrent sessions interleave in the log instead of fighting over state. See daisy/docs/home-management.md.

A feedback loop, not a rulebook. When the agent gets something wrong, daisy feedback records it. Periodically, daisy optimize has an LLM rewrite the relevant prompt's rules from the accumulated feedback — trained on an 80/20 split, shown as a diff, applied only on approval. The system's instructions are a living artifact shaped by how it actually fails. See daisy/docs/resources/prompt-learning-loop.md.

Why Prompts, Not Skills?

Standard practice for extending an agent is the skill: a self-contained, portable capability you install once and share anywhere. Daisy instead keeps almost everything as prompts — instruction files compiled per-home into the agent's context. This is deliberate, and it was tested the hard way: Daisy once split its capabilities into skills, then converted nearly all of them back. Today the system runs ten prompts and exactly one skill.

The criterion that emerged: who owns a capability's evolution?

• If your feedback loop owns it — corrections come from your own daisy feedback entries, and it reads or writes files Daisy owns (todo.txt, today.md, journal, projects) — it's a prompt. The optimize loop can only reach prompts, so putting such a capability in a skill freezes it outside the learning system.
• If an upstream source owns it — a vendor's published skill set, a spec that doesn't change based on how your sessions go — it's a skill. Local feedback should never fork it from its source.

Portability is a symptom, not the criterion: every skill is portable, but "portable-looking" capabilities kept turning out to be things only the local feedback loop would ever refine. The principle underneath: separate what learns from what doesn't. Full argument and worked examples: daisy/docs/prompts-vs-skills.md.

Prompts are also loaded frugally — most are lazy: only a short trigger stub sits in the agent's context, and the full prompt is read on demand when its trigger fires. See "AGENTS.md Build System" in AGENTS.md.

Install

1. Clone or Download

git clone <repo-url> daisy
cd daisy

2. Install

./daisy.sh install

This will:

• Create a ~/bin/daisy symlink
• Add DAISY_ROOT and DAISY_DEFAULT_HOME to your shell rc file (.zshenv, .bashrc, etc.)
• Interactively select a default home (or create one)
• Configure Claude Code permissions for daisy and $DAISY_ROOT

Then reload your shell: source ~/.zshenv (or open a new terminal).

3. Initialize Daisy in a Workspace

cd /path/to/your/project
daisy init work

This creates:

• .daisy/ directory with symlinks to that home's tasks, journal, and projects
• .cursor/rules/daisy.md so agents automatically discover daisy
• .daisy/ entries in .gitignore

4. Verify

daisy healthcheck

Confirms DAISY_ROOT/DAISY_HOME resolve correctly, required files exist, and every script's own health check passes. Run daisy healthcheck --force any time to bypass the per-session cache.

5. Start Using Daisy

With the cursor rule installed, just say:

Daisy, start a new day

The agent will:

• Read .daisy/AGENTS.md automatically
• Archive yesterday's work (and rotate journal.md if it's grown past 5 entries)
• Create fresh today.md with prioritized tasks

Usage

Just address Daisy by name in any initialized workspace:

Daisy, start a new day
Daisy, done [task]
Daisy, log [message]
Daisy, what are my tasks?

CLI Commands

Every command also accepts --help/-h as its sole argument to print its own usage.

daisy build [home]            # Rebuild AGENTS.md for a home
daisy check-secrets           # Check which secrets/tokens are configured
daisy clean [-f]              # Remove Daisy from the current workspace
daisy commit "message"        # Stage and commit changes under home/
daisy done "task pattern"     # Mark task complete
daisy eval [<case>]           # List, display, or record an eval case result
daisy feedback "message"      # Record a prompt failure for optimization
daisy files                   # Show resolved real paths for every home file
daisy healthcheck [--force]   # System validation
daisy help                    # Show command list
daisy init work               # Initialize Daisy in a new workspace
daisy init personal           # Switch workspace to a different home
daisy install                 # Set up ~/bin/daisy and shell environment
daisy list                    # List active prompts and installed skills
daisy log Did thing A         # Add log entry (no quoting needed)
daisy new-day                 # Start a new day
daisy new-week                # Start a new week
daisy optimize [--workflow <n>] # Run prompt learning loop on collected feedback
daisy plan-archive            # Archive the active Daisy plan
daisy plan-new "<description>" # Create a new Daisy plan and symlink PLAN.md
daisy plan-pickup <path>      # Promote a spec draft into a tracked plan
daisy projects [--archived]   # List active or archived projects
daisy rotate                  # Rotate journal.md into archive window files (automatic; rarely needed by hand)
daisy status                  # Quick workspace summary
daisy tasks [--all|--done|--todo] "+project"  # Search todo.txt/done.txt (read-only)
daisy test [name-substring]   # Run the hermetic daisy/scripts test suite

Working Practices

Mechanics live in the CLI; these are the design choices behind daily use:

• Projects over tickets. A +tag in todo.txt captures what; a project file in projects/{name}.md captures why and how. External trackers receive one-way status pushes; your project file remains the source of truth for your own understanding. See daisy/docs/projects.md.
• Bounded journals. new-day/new-week archive today.md into journal.md losslessly; rotation keeps journal.md at the last 5 entries and distributes the rest into rolling and permanent archive files. See daisy/docs/logging.md.
• Plan before large changes. /daisy plan scaffolds Research → Goal → Steps → Decisions before any implementation; /daisy execute works through it step by step; /daisy resume picks up an interrupted session from verified state. See daisy/docs/plan.md.
• Concurrency by design. No locks: stateless home resolution plus commit-per-mutation lets sessions interleave. The honest limit: two processes writing the same file at the same instant are unprotected — low-probability for one person across a few sessions, but a real gap, not a guarantee.

Optional: API Authentication

For API integrations (Webex, JIRA, GitHub) when MCP servers are unavailable, copy $DAISY_ROOT/daisy/templates/env.sh.template to .env.sh in your workspace, fill in tokens, and verify with daisy healthcheck. MCP servers handle authentication automatically; .env.sh is only a fallback.

File Structure

Daisy Repo

daisy/                          # Repository root ($DAISY_ROOT)
├── AGENTS.md                   # System architecture & internal specs (auto-applied by Cursor/Claude Code)
├── README.md                   # This file
├── daisy.sh                    # CLI entry point (symlinked to ~/bin/daisy)
├── daisy/                      # Distributable system files
│   ├── scripts/                # daisy-init, new-day, new-week, rotate, done, log,
│   │                           # feedback, optimize, eval, build-prompt, create-home,
│   │                           # healthcheck, common, commit, check-secrets, files,
│   │                           # list, tasks, projects, plan-new, plan-pickup,
│   │                           # plan-archive, test
│   ├── templates/
│   │   ├── journal-day.md      # Daily today.md template
│   │   ├── journal-week.md     # Weekly today.md template (adds retrospective)
│   │   ├── project.md          # Template for project files
│   │   ├── plan.md             # Template for PLAN.md
│   │   ├── env.sh.template     # Environment variables template
│   │   ├── cursor-rule.mdc, cursor-rule-logging.mdc, cursor-rule-plan.mdc
│   │   ├── claude-command.md
│   │   └── home/               # Template for new homes (tasks/, journal/, feedback/, projects/, plans/)
│   └── docs/                   # Detailed reference documentation
│       ├── task-format.md, task-sync.md, todotxt.md, templates.md
│       ├── workflows.md, logging.md, projects.md, home-management.md
│       ├── plan.md, praxis.md, retrospective.md, github.md
│       ├── prompts-vs-skills.md, examples.md, test-cases.md
│       └── resources/          # External-talk summaries informing the design
├── home/
│   ├── {home-name}/            # One directory per home
│   │   ├── AGENTS.md           # Generated prompt (git-ignored; rebuild with `daisy build`)
│   │   ├── include.txt         # Which prompts load into AGENTS.md, and how
│   │   ├── prompts/            # Home-specific prompt augmentations
│   │   ├── journal/            # today.md, journal.md, rotated archive files
│   │   ├── tasks/              # todo.txt, done.txt, alias.txt
│   │   ├── projects/           # One file per active project, plus _archive/
│   │   ├── feedback/           # feedback.md, archive.md
│   │   └── plans/              # PLAN.md history, plus archive/
├── prompts/                    # Shared prompts (daisy.md, plan.md, retrospective.md, git.md, ...)
│   └── evals/                  # Eval cases for the optimize loop
└── skills/                     # Upstream-owned capabilities (see Why Prompts, Not Skills?)

Workspace Layout (after daisy init work)

workspace/
├── .daisy/
│   ├── home                 # "work" (plain text)
│   ├── AGENTS.md            # generated prompt for this home
│   ├── tasks/                → daisy/home/work/tasks/
│   ├── today.md              → daisy/home/work/journal/today.md
│   ├── journal.md            → daisy/home/work/journal/journal.md
│   ├── projects/             → daisy/home/work/projects/
│   └── plans/                → daisy/home/work/plans/
├── .cursor/rules/
│   └── daisy.md
└── PLAN.md                   → .daisy/plans/{current}.plan.md (only while a plan is active)

Run daisy files any time to print every one of these paths, fully resolved, for the active home.

Different workspaces can use different homes concurrently.

Todo.txt Format Quick Reference

(A) 2026-01-16 High priority task +Project @context
(B) 2026-01-16 Medium priority task +PROJ-5678 @jira
2026-01-16 Inbox task (needs prioritization)
(C) 2026-01-16 Normal task @github
(D) 2026-01-16 Someday task +backlog

Priority levels:

• (A) - Now (do today)
• (B) - Next (this week)
• (C) - Soon (default for most tasks)
• (D) - Someday (backlog)
• No priority - Inbox (needs triage)

See daisy/docs/todotxt.md for complete format specification.

See Also

• AI Workflow Guide - User-focused workflows and commands
• Admin Guide - Internal architecture and specifications
• Prompts vs. Skills - The ownership-of-evolution criterion in full
• Detailed Examples - Interaction walkthroughs
• Todo.txt Specification - Format reference