lific 1.6.0

Lific's full MCP schema fits in roughly 3,000 tokens. It uses human-readable identifiers (APP-42, not UUIDs), runs as a single binary with an embedded SQLite database, and includes a web UI for when you want to look at things yourself.

Install

cargo install lific

Or grab a binary from the releases page.

Quickstart

lific init     # creates lific.toml + lific.db
lific start    # starts on port 3456

On first run, Lific generates an API key and prints it to the console. It won't be shown again. This key is used for MCP and API access.

Open http://localhost:3456 to use the web UI. The first account you create is the admin.

The CLI also works directly against the database. No server or auth required:

lific project list
lific issue list --project APP
lific issue create --project APP --title "Fix login bug" --priority high
lific issue get APP-42
lific issue update APP-42 --status done
lific search "authentication" --project APP

Add --json to any command for machine-readable output.

Connecting AI tools

Point your MCP client at the server. Replace your-api-key with the key from first run (or create one with lific key create --name my-key).

Remote (network):

{
  "lific": {
    "type": "remote",
    "url": "http://localhost:3456/mcp",
    "headers": {
      "Authorization": "Bearer your-api-key"
    }
  }
}

Local (stdio, no network):

{
  "lific": {
    "type": "local",
    "command": ["lific", "--db", "path/to/lific.db", "mcp"]
  }
}

Go to Settings > Connected Tools in the web UI. Pick your tool, click Connect, and paste the generated config snippet. Supported tools: OpenCode, Cursor, Claude Code, Claude Desktop, Codex.

Each connection creates a bot identity tied to your account. Changes show up attributed to you, tagged with which tool made them.

MCP tools

Everything uses human-readable identifiers: project="APP" not project_id=7.

Workable filter: list_issues(project="APP", workable=true) returns only issues with all blockers resolved. One call can answer "what can I work on right now?"

Plans

An agent's plan shouldn't die when its context does. A plan is an ordered, arbitrarily-nestable tree of steps that persists across sessions and compaction — start a new session and the plan is still there, ready to resume.

• Steps can mirror issues. Link a step to an issue and the two stay in sync: close the issue and the step checks itself; mark the step done and the issue closes. Reopen the issue and the step reopens, with a note of why.
• Authored in one call. create_plan builds a full nested tree at once; get_plan rehydrates it for the next session; edit_plan_step and update_plan_step keep it current.
• First-class in the UI. A Plans tab sits alongside Issues, Board, Modules, and Pages — a real tree view with done toggles, per-step markdown notes, issue chips, and an activity timeline.
• Fully tracked. Every plan and step change lands in the audit log, including the issue-driven cascades.

Issues stay flat and lateral; the hierarchy lives on the plan. It's the difference between an issue tracker and a project planner.

Features

Configuration

lific init generates this:

[server]
host = "0.0.0.0"
port = 3456

[database]
path = "lific.db"

[backup]
enabled = true
dir = "backups"
interval_minutes = 60
retain = 24

[log]
level = "info"

CLI flags (--db, --port, --host) override config values.

Building from source

Requirements

• Rust 1.88+ required
• Bun optional, only needed if you want the web UI

SQLite is bundled via rusqlite and compiled into the binary. No system SQLite required.

API-only build (no web UI)

git clone https://github.com/VoidNullable/lific
cd lific
mkdir -p web/dist
cargo build --release

The mkdir -p web/dist creates the empty directory that rust-embed expects at compile time. The resulting binary has full functionality (MCP, REST API, CLI, OAuth, backups) but visiting the web UI will return a message pointing you to build the frontend.

Full build (with web UI)

git clone https://github.com/VoidNullable/lific
cd lific
cd web && bun install && bun run build && cd ..
cargo build --release

The frontend is a Svelte 5 SPA built with Vite. bun run build outputs static files to web/dist/, which cargo build embeds into the binary. The final binary is fully self-contained with no runtime dependencies.

Contributing

Issues and PRs welcome. If you're planning something big, open an issue first so we can talk about it before you put in the work.

License

Apache-2.0