### Install PlanDB and Configure All Frameworks

Source: https://github.com/agent-field/plandb/blob/main/README.md

This command installs the PlanDB binary and silently configures all detected AI frameworks. It's a convenient option for a complete setup across multiple tools.

```bash
curl -fsSL https://agentfield.ai/plandb/install | bash -s -- --all
```

--------------------------------

### Multi-Agent Setup with Environment Variables

Source: https://github.com/agent-field/plandb/blob/main/experiments/docs-site-claude/cli-reference.html

Example of setting up multiple agents using environment variables for agent ID and database path. Each terminal session can operate independently.

```bash
# Terminal 1 — Agent A
$ export PLANDB_AGENT=agent-a
$ export PLANDB_DB=/shared/project.plandb.db
$ plandb go      # Claims as agent-a
```

```bash
# Terminal 2 — Agent B
$ export PLANDB_AGENT=agent-b
$ export PLANDB_DB=/shared/project.plandb.db
$ plandb go      # Claims a different task as agent-b
```

--------------------------------

### Claim and Start a Task

Source: https://github.com/agent-field/plandb/blob/main/experiments/docs-site-codex/playground.html

Use 'plandb go' to claim and start processing a task that is ready to be worked on.

```bash
plandb go
```

--------------------------------

### Install PlanDB Binary Only

Source: https://github.com/agent-field/plandb/blob/main/README.md

Use this option to download only the PlanDB binary without configuring any AI frameworks. This is useful if you prefer manual setup or are using a framework not automatically supported.

```bash
curl -fsSL https://agentfield.ai/plandb/install | bash -s -- --binary-only
```

--------------------------------

### Start PlanDB HTTP Server

Source: https://github.com/agent-field/plandb/blob/main/experiments/docs-site-claude/cli-reference.html

Starts the HTTP server, providing a REST API and an SSE event stream. The port can be specified.

```bash
$ plandb serve --port 9090
```

--------------------------------

### Install PlanDB with Auto-Configuration

Source: https://github.com/agent-field/plandb/blob/main/README.md

This command downloads the PlanDB binary and automatically configures supported AI frameworks to use it. Re-running the command updates the installation and is idempotent.

```bash
curl -fsSL https://agentfield.ai/plandb/install | bash
```

--------------------------------

### Install PlanDB from Source

Source: https://github.com/agent-field/plandb/blob/main/README.md

Build and install PlanDB directly from its source code using Cargo. This method requires a Rust development environment.

```bash
cargo install --path .
```

--------------------------------

### Core PlanDB workflow example

Source: https://github.com/agent-field/plandb/blob/main/experiments/docs-site-codex/index.html

Demonstrates the fundamental loop of initializing a project, adding tasks with dependencies, executing ready tasks, and completing them.

```bash
plandb init "docs-site"
plandb add "Draft architecture page" --description "Explain place graph and link graph"
plandb add "Build playground" --dep t-architecture --description "Create terminal simulator"
plandb go
plandb done --next
```

--------------------------------

### Claim and Start List Task

Source: https://github.com/agent-field/plandb/blob/main/experiments/02-with-vs-without/with-planq/work-log.md

This snippet demonstrates claiming a task and then starting it, specifically for the 'list' command task. It's a common workflow for initiating a task.

```bash
planq --db .../planq.db --json task next --project p-zyj41z --agent me --claim
planq --db .../planq.db --json task start t-gzfzl3
```

```json
{"id":"t-gzfzl3","status":"claimed"}
{"id":"t-gzfzl3","status":"running"}
```

--------------------------------

### Claim and Start Next Ready Task

Source: https://github.com/agent-field/plandb/blob/main/experiments/docs-site-codex/cli-reference.html

Use the 'go' command to claim and start the next available task in the project. Supports agent specification, project selection, and common output/database flags.

```bash
Usage: plandb go [OPTIONS]

Verified options: --agent, --project, --db, --json, -c/--compact.
```

--------------------------------

### Claim and Start the Next Ready Task

Source: https://github.com/agent-field/plandb/blob/main/experiments/docs-site-claude/cli-reference.html

Use `plandb go` as the preferred agent entry point to atomically claim and start the next ready task. Specify an agent identifier; it also reads the `PLANDB_AGENT` environment variable.

```bash
$ plandb go --agent claude-1
--> t-impl "Implement auth handler" [2/8 - 3 ready - 1 blocked]

upstream:
  t-design --> (structured)

downstream: t-tests "Write auth tests" (receives YOUR result)
```

--------------------------------

### Claim and Start Task

Source: https://github.com/agent-field/plandb/blob/main/experiments/02-with-vs-without/with-planq/work-log.md

This snippet shows a sequence of commands to first claim a task and then immediately start it. It's useful for quickly beginning work on a new task.

```bash
planq --db .../planq.db --json task next --project p-zyj41z --agent me --claim
planq --db .../planq.db --json task start t-sxbyfz
```

```json
{"id":"t-sxbyfz","status":"claimed"}
{"id":"t-sxbyfz","status":"running"}
```

--------------------------------

### Attempt to Start Task (Failed)

Source: https://github.com/agent-field/plandb/blob/main/experiments/02-with-vs-without/with-planq/work-log.md

This command demonstrates an attempt to use the `--start` flag with the `task next` command, which is not a valid option and results in an error.

```bash
planq --db .../planq.db --json task next --project p-zyj41z --agent me --claim --start
```

```text
error: unexpected argument '--start' found
Usage: planq task next --project <PROJECT> --agent <AGENT> --claim
```

--------------------------------

### PlanDB Help and Utility Commands

Source: https://github.com/agent-field/plandb/blob/main/experiments/docs-site-codex/playground.html

Access help documentation, clear the terminal, or start the tutorial mode.

```bash
plandb help
```

```bash
clear
```

```bash
tutorial start
```

--------------------------------

### Development Setup Commands

Source: https://github.com/agent-field/plandb/blob/main/CONTRIBUTING.md

Clone the repository, build the project, run tests, and execute functional tests. Requires Rust 1.75+.

```bash
git clone https://github.com/Agent-Field/plandb.git
cd plandb
cargo build
cargo test
bash tests/functional_test.sh
```

--------------------------------

### Claim and Start the Next Ready Task

Source: https://github.com/agent-field/plandb/blob/main/experiments/docs-site-gemini/reference.html

Claims and starts the next available task in the project. Allows specifying an agent identifier.

```bash
plandb go [OPTIONS]

Options:
      --agent <AGENT>      Agent identifier (default: 'default')
```

--------------------------------

### plandb serve

Source: https://github.com/agent-field/plandb/blob/main/experiments/docs-site-claude/cli-reference.html

Starts an HTTP server with a REST API and SSE event stream.

```APIDOC
## `plandb serve`

### Description
Start HTTP server with REST API and SSE event stream.

### Usage
```bash
$ plandb serve --port 9090
```

### Options
#### `-p, --port`
* **Type**: int
* **Default**: 8484
* **Description**: Port to listen on.
```

--------------------------------

### Claim and Start a Task

Source: https://github.com/agent-field/plandb/blob/main/experiments/02-with-vs-without/with-planq/work-log.md

This sequence claims a task for the current agent and then starts its execution. The output shows the task status changing to 'claimed' and then 'running'.

```bash
planq --db .../planq.db --json task next --project p-zyj41z --agent me --claim
planq --db .../planq.db --json task start t-30g296
```

--------------------------------

### Start PlanDB MCP Server

Source: https://github.com/agent-field/plandb/blob/main/experiments/docs-site-claude/cli-reference.html

Starts the MCP server, which uses stdio for JSON-RPC communication, enabling integration with tools like Claude Code, Cursor, and Windsurf.

```bash
$ plandb mcp
```

--------------------------------

### Execute Tasks in PlanDB

Source: https://github.com/agent-field/plandb/blob/main/experiments/docs-site-claude/index.html

Use 'plandb go' to start the execution of tasks. The system will begin with tasks that have no unmet dependencies.

```bash
$ plandb go

➔ t-design-api "Design API" running
```

--------------------------------

### Initialize PlanDB Project

Source: https://github.com/agent-field/plandb/blob/main/experiments/docs-site-claude/getting-started.html

Starts a new PlanDB project by creating a local SQLite database. The project name is used for display and filtering.

```bash
$ plandb init "my-project"

Created project p-my-project

Database: .plandb.db

Run `plandb add` to create your first task.
```

--------------------------------

### PlanDB Command Line Usage Examples

Source: https://github.com/agent-field/plandb/blob/main/README.md

Examples of common PlanDB CLI commands for managing tasks, dependencies, and project status. These commands are used to interact with the PlanDB system for various project management operations.

```bash
plandb use t-backend
```

```bash
plandb add --description "..."
```

```bash
--dep t-schema
```

```bash
plandb status --detail
```

```bash
plandb go
```

```bash
plandb split --into "A, B, C"
```

```bash
plandb context --kind discovery
```

```bash
plandb critical-path
```

```bash
plandb search "query"
```

```bash
--pre "..." --post "..."
```

--------------------------------

### Initialize and Add Tasks with PlanDB CLI

Source: https://github.com/agent-field/plandb/blob/main/README.md

Use 'plandb init' to start a new project and 'plandb add' to define tasks with details like kind, dependencies, and descriptions. Tasks can be claimed and marked as done using 'plandb go' and 'plandb done'.

```bash
plandb init "auth-system"
plandb add "Design schema" --as schema --kind research \
  --description "Define user/session tables, auth flows, token format"
plandb add "Build API" --as api --kind code --dep t-schema \
  --description "Implement endpoints: register, login, refresh, logout"
plandb add "Write tests" --as tests --kind test --dep t-schema \
  --description "Integration tests for all auth endpoints"
plandb add "Deploy" --as deploy --kind shell --dep t-api --dep t-tests \
  --description "Docker build, push, deploy to staging"

plandb go            # claims "Design schema" (only task with no blockers)
plandb done --next   # completes it → "Build API" and "Write tests" both become ready
```

--------------------------------

### Start a Claimed Task

Source: https://github.com/agent-field/plandb/blob/main/experiments/docs-site-claude/cli-reference.html

Transition a task that has already been claimed to the 'running' status.

```bash
$ plandb task start t-review
```

--------------------------------

### Claim and Start Tests Task

Source: https://github.com/agent-field/plandb/blob/main/experiments/02-with-vs-without/with-planq/work-log.md

This command sequence claims a task for running tests and then starts its execution. The output shows the task status changing to 'claimed' and then 'running'.

```bash
planq --db .../planq.db --json task next --project p-zyj41z --agent me --claim
planq --db .../planq.db --json task start t-b6zyyz
```

--------------------------------

### Tool-Calling GPT Interaction Example

Source: https://github.com/agent-field/plandb/blob/main/experiments/mini-gpt-rust/README.md

Example interaction demonstrating the GPT model's tool-calling capabilities. The model learns to invoke tools like 'calc' for arithmetic operations and provide relevant replies.

```text
[user] what is 12 plus 7 [end]
[call] calc(12,7,add) [end]
[result] 19 [end]
[reply] the answer is 19 [end]

```

--------------------------------

### Start Task

Source: https://github.com/agent-field/plandb/blob/main/experiments/02-with-vs-without/with-planq/work-log.md

Mark a claimed task as running. This command requires the task ID.

```bash
planq --db .../planq.db --json task start t-lxr7wz
```

```json
{"id":"t-lxr7wz","status":"running"}
```

--------------------------------

### Execute Mini-GPT Rust Project

Source: https://github.com/agent-field/plandb/blob/main/README.md

Navigate to the project directory and run the Rust executable to start the mini-GPT demo. This command is used after cloning the repository and setting up the environment.

```bash
cd experiments/mini-gpt-rust && cargo run --release -- --demo
```

--------------------------------

### Mini-GPT Agent Demo Output Example

Source: https://github.com/agent-field/plandb/blob/main/experiments/mini-gpt-rust/README.md

Illustrates the output of the tool-calling agent demo, showing model decisions for tool calls or direct replies.

```text
Q: what is 12 plus 7
T [call] calc(12,7,add) [end]         
= 19

Q: hello
R [reply] hello how can i help [end]  

Q: what time is it in utc
T [call] time(utc) [end]              
= 14:30 utc
```

--------------------------------

### Claim and Start Export Task

Source: https://github.com/agent-field/plandb/blob/main/experiments/02-with-vs-without/with-planq/work-log.md

This command sequence claims a task for exporting data and then starts its execution. The output indicates the task status changes to 'claimed' and then 'running'.

```bash
planq --db .../planq.db --json task next --project p-zyj41z --agent me --claim
planq --db .../planq.db --json task start t-ejn5de
```

--------------------------------

### Claim and Start List Task with Tag

Source: https://github.com/agent-field/plandb/blob/main/experiments/02-with-vs-without/with-planq/work-log.md

This sequence claims a task for the 'list' command with a tag filter and then starts its execution. The output shows the task status updates.

```bash
planq --db .../planq.db --json task next --project p-zyj41z --agent me --claim
planq --db .../planq.db --json task start t-fmaqsy
```

--------------------------------

### plandb mcp

Source: https://github.com/agent-field/plandb/blob/main/experiments/docs-site-claude/cli-reference.html

Starts the MCP server for integration with Claude Code, Cursor, and Windsurf.

```APIDOC
## `plandb mcp`

### Description
Start MCP server (stdio JSON-RPC) for Claude Code, Cursor, and Windsurf integration.

### Usage
```bash
$ plandb mcp
```

### Notes
No additional options beyond global flags. The server reads/writes on stdin/stdout using the MCP protocol.
```

--------------------------------

### Start Working on Tasks

Source: https://github.com/agent-field/plandb/blob/main/experiments/docs-site-gemini/guide.html

Begin working on your agent mission by claiming the next available task. PlanDB automatically selects and assigns a task that is ready to run.

```bash
$ plandb go
```

--------------------------------

### Get Task Overview

Source: https://github.com/agent-field/plandb/blob/main/experiments/02-with-vs-without/with-planq/work-log.md

View a summary of all tasks within a project, including total counts, dependencies, and ready tasks.

```bash
planq --db .../planq.db --json task overview --project p-zyj41z
```

```json
{"total":9,"dependencies":14,"ready":["t-lxr7wz"]}
```

--------------------------------

### Execute the next ready task in the graph

Source: https://github.com/agent-field/plandb/blob/main/experiments/docs-site-codex/index.html

Run 'plandb go' to claim and start executing the next available task whose dependencies have been met. The output shows the task being processed.

```bash
plandb go
→ t-api "Design API" [1 ready]
```

--------------------------------

### Claim and Start the Next Ready Task

Source: https://github.com/agent-field/plandb/blob/main/experiments/docs-site-codex/getting-started.html

Use 'plandb go' to claim and begin working on the next task whose dependencies have been met. This command prevents multiple agents from claiming the same task.

```bash
$ plandb go
→ t-checklist "Design launch checklist" [1/3 · 1 ready]
```

--------------------------------

### Cross-Level Dependencies Example

Source: https://github.com/agent-field/plandb/blob/main/docs/ARCHITECTURE.md

Illustrates dependencies that cross containment boundaries and different depths within the project structure.

```text
Backend/t-schema ──feeds_into──> Frontend/t-components    (cross-branch)
Backend/t-api ──feeds_into──> t-deploy                     (depth 2 → depth 0)
Frontend/t-pages ──blocks──> t-deploy                      (depth 2 → depth 0)
```

--------------------------------

### Start Working on a Task

Source: https://github.com/agent-field/plandb/blob/main/experiments/docs-site-claude/getting-started.html

Claims the highest-priority ready task, marks it as running, and displays its context. This atomic claim prevents concurrent task grabbing.

```bash
$ plandb go

→ t-001 "Design schema" [1/3 · 1 ready · 2 blocked]

downstream:

t-004 "Build API endpoints" (receives YOUR result)
```

--------------------------------

### Get Full Task Overview

Source: https://github.com/agent-field/plandb/blob/main/experiments/docs-site-claude/cli-reference.html

Provides a comprehensive overview of the entire project, including all tasks, their dependencies, and a summary of their progress. This is useful for understanding the overall project status.

```bash
plandb task overview
```

--------------------------------

### Composite Task Auto-Completion Example

Source: https://github.com/agent-field/plandb/blob/main/docs/ARCHITECTURE.md

Demonstrates how composite tasks automatically complete when all their child tasks are done, cascading completion upwards.

```text
t-schema [done] ─┐
t-api [done]     ├─ Backend [auto-completes] ─┐
t-auth [done]    ─┘                            │
                                                ├─ Build App [auto-completes]

t-components [done] ─┐                         │
t-pages [done]      ─┘ Frontend [auto-completes]┘
```

--------------------------------

### Example PlanDB Command for Hooks

Source: https://github.com/agent-field/plandb/blob/main/experiments/product-iteration/GOALS.md

Demonstrates how to use pre- and post-hooks with PlanDB add commands. Hooks are shell commands executed before claiming or after completing a task, enabling automated actions like context gathering or sub-agent spawning.

```bash
plandb add "task" --pre-hook "plandb search 'related work'" --post-hook "plandb context add --type decision"
```

--------------------------------

### Create Project with Planq CLI

Source: https://github.com/agent-field/plandb/blob/main/experiments/01-fibonacci-api/experiment-log.md

Initializes a new project in Planq, specifying the database file, output format, project name, and a description. The output confirms the project creation with its unique ID and status.

```bash
"/Users/santoshkumarradha/Documents/agentfield/code/planq/target/release/planq" --db "/Users/santoshkumarradha/Documents/agentfield/code/planq/experiments/01-fibonacci-api/planq.db" --json project create "fibonacci-api" --description "Flask Fibonacci REST API with tests"
```

```json
{
  "id": "proj_01KJWCN1YV7BZFW9M68DG5W2YG",
  "name": "fibonacci-api",
  "description": "Flask Fibonacci REST API with tests",
  "status": "active"
}
```

--------------------------------

### Project Status Output Example

Source: https://github.com/agent-field/plandb/blob/main/experiments/02-with-vs-without/with-planq/work-log.md

This JSON output provides a summary of the project's task status, including totals and counts for different task states.

```json
{"tasks_total":9,"tasks_done":3,"tasks_ready":3,"tasks_pending":3}
```

--------------------------------

### Get Task Overview with PlanQ CLI

Source: https://github.com/agent-field/plandb/blob/main/experiments/01-fibonacci-api/experiment-log.md

Retrieve an overview of tasks within a specific project. This command is useful for verifying task statuses and dependencies.

```bash
"/Users/.../planq" --db "/Users/.../planq.db" task overview --project "proj_01KJWCN1YV7BZFW9M68DG5W2YG"
```

--------------------------------

### Initialize Project and Add Tasks with Dependencies

Source: https://github.com/agent-field/plandb/blob/main/examples/PLANDB_PROMPT.md

Initialize a new project and add several tasks with descriptions, kinds, and dependencies. This demonstrates setting up a project structure for an AI agent's documentation site.

```bash
plandb init "docs-site"
plandb add "Design layout" --as layout --kind research \
  --description "Define page structure, navigation, color scheme, typography"
plandb add "Build landing" --as landing --kind code --dep t-layout \
  --description "Create index.html with hero section, feature list, install instructions"
plandb add "Build CLI ref" --as cli-ref --kind code --dep t-layout \
  --description "Generate CLI reference page from plandb --help output"
plandb add "Build playground" --as playground --kind code --dep t-layout \
  --description "Interactive terminal UI with simulated PlanDB commands"
plandb add "Polish + ship" --as polish --kind code --dep t-landing --dep t-cli-ref --dep t-playground \
  --description "Navigation, responsive layout, cross-linking, final QA"
```

--------------------------------

### Initialize and Add Tasks with Dependencies

Source: https://github.com/agent-field/plandb/blob/main/experiments/product-iteration/phase-2-optimization/improved-prompt-v1.md

Demonstrates initializing a project and adding tasks with descriptions and dependencies using the PlanDB CLI. Use this to set up a new project and define its initial task structure.

```bash
plandb init "auth-system"
plandb add "Design schema" --as schema --kind research \
  --description "Define user/session tables, auth flows, token format"
plandb add "Build API" --as api --kind code --dep t-schema \
  --description "Implement endpoints from schema: register, login, refresh, logout"
plandb add "Write tests" --as tests --kind test --dep t-schema \
  --description "Integration tests for all auth endpoints"
plandb add "Deploy" --as deploy --kind shell --dep t-api --dep t-tests \
  --description "Docker build, push, deploy to staging"
plandb status --detail
plandb critical-path
```

--------------------------------

### Initialize a New PlanDB Project

Source: https://github.com/agent-field/plandb/blob/main/experiments/docs-site-gemini/reference.html

Initializes a new project with a specified name and an optional description.

```bash
plandb init [OPTIONS] <NAME>

Arguments:
  <NAME>  Project name

Options:
      --description <DESCRIPTION>  Optional description of the project's goal
```

--------------------------------

### Initialize a New Project

Source: https://github.com/agent-field/plandb/blob/main/experiments/docs-site-claude/cli-reference.html

Use `plandb init` to create a new project and set it as the default. You can optionally provide a description for the project's goal.

```bash
$ plandb init "auth-system" --description "JWT-based authentication service"
Created project p-auth-system (set as default)
```

--------------------------------

### PlanDB CLI: Introspection Commands

Source: https://github.com/agent-field/plandb/blob/main/experiments/product-iteration/phase-2-optimization/improved-prompt-v1.md

Provides examples of commands used to inspect the task graph, including status, critical path, bottlenecks, and task dependencies.

```bash
# Introspection
plandb status --detail                   # Dependency tree with progress
plandb critical-path                     # Longest chain to completion
plandb bottlenecks                       # What's blocking the most work
plandb what-unlocks t-xxx                # Impact of completing a task
plandb list --status ready               # Tasks safe to parallelize NOW
```

--------------------------------

### Conventional Commit Message Examples

Source: https://github.com/agent-field/plandb/blob/main/CONTRIBUTING.md

Examples of commit messages following the Conventional Commits specification. Use these prefixes to categorize changes.

```text
feat: add new command
fix: handle edge case in batch import
refactor: simplify context store lookup
docs: update README
ci: add clippy check
test: add functional test for hooks
```

--------------------------------

### Initialize and Add Tasks with PlanDB CLI

Source: https://github.com/agent-field/plandb/blob/main/experiments/docs-site-gemini/index.html

Initialize a new PlanDB project and add tasks with descriptions using the PlanDB CLI.

```bash
$ plandb init "my-project"
$ plandb add "implement feature" --description "..."
$ plandb go
```

--------------------------------

### Claim and Start Tag Task

Source: https://github.com/agent-field/plandb/blob/main/experiments/02-with-vs-without/with-planq/work-log.md

This command sequence claims a task related to tagging and then starts its processing. The output confirms the task has been claimed and is now running.

```bash
planq --db .../planq.db --json task next --project p-zyj41z --agent me --claim
planq --db .../planq.db --json task start t-rv6ozk
```

--------------------------------

### Work on Subtasks in Parallel

Source: https://github.com/agent-field/plandb/blob/main/experiments/docs-site-claude/architecture.html

After splitting a task, agents can work on the newly created subtasks. This example shows multiple agents (worker-1, worker-2, worker-3) picking up and working on subtasks concurrently.

```bash
# Work on children (or dispatch to parallel agents)
$ PLANDB_AGENT=worker-1 plandb go
$ PLANDB_AGENT=worker-2 plandb go
$ PLANDB_AGENT=worker-3 plandb go
```

--------------------------------

### Claim and Start Stats Task

Source: https://github.com/agent-field/plandb/blob/main/experiments/02-with-vs-without/with-planq/work-log.md

This sequence claims a task for generating statistics and then starts its processing. The output shows the task status updates from claimed to running.

```bash
planq --db .../planq.db --json task next --project p-zyj41z --agent me --claim
planq --db .../planq.db --json task start t-dlwtj6
```

--------------------------------

### Initialize PlanDB Project

Source: https://github.com/agent-field/plandb/blob/main/experiments/docs-site-codex/cli-reference.html

Use the 'init' command to create a new PlanDB project and set it as the default. Supports common flags for description, database path, JSON output, and compact mode.

```bash
Usage: plandb init [OPTIONS] <NAME>

Arguments: <NAME> project name.

Verified options: --description, --db, --json, -c/--compact.
```

--------------------------------

### Create Project with Planq

Source: https://github.com/agent-field/plandb/blob/main/experiments/02-with-vs-without/with-planq/work-log.md

Use this command to create a new project in Planq. Specify the database path and a name for the project.

```bash
planq --db .../planq.db --json project create quicknote
```

```json
{"id":"p-zyj41z","name":"quicknote","status":"active"}
```

--------------------------------

### Initialize a PlanDB Project

Source: https://github.com/agent-field/plandb/blob/main/experiments/docs-site-claude/index.html

Use 'plandb init' to create a new project. This command initializes the project structure and creates a project directory.

```bash
$ plandb init 'my-project'

Created project p-my-project
```

--------------------------------

### GPT Language Model Output Example

Source: https://github.com/agent-field/plandb/blob/main/experiments/mini-gpt-rust/README.md

Example output from the character-level GPT model trained on embedded Shakespeare text. Demonstrates coherent English generation after approximately 2 minutes of CPU training.

```text
Seed: "the "
the duke of york and the king of france...

```

--------------------------------

### Discover Planq CLI Help

Source: https://github.com/agent-field/plandb/blob/main/experiments/01-fibonacci-api/experiment-log.md

Use the --help flag to understand the available commands and options for the Planq CLI and its subcommands like 'task', 'project', and 'artifact'. This helps in understanding the CLI's structure before executing commands.

```bash
"/Users/santoshkumarradha/Documents/agentfield/code/planq/target/release/planq" --help
```

```text
Planq task DAG CLI
Usage: planq [OPTIONS] <COMMAND>
Commands: project, task, artifact, events, mcp, serve, help
Options: --db <DB>, --json, -h/--help, -V/--version
```

```bash
"/Users/santoshkumarradha/Documents/agentfield/code/planq/target/release/planq" task --help
```

```text
Usage: planq task [OPTIONS] <COMMAND>
Commands: create, create-batch, list, get, next, claim, start, heartbeat, progress,
done, fail, cancel, approve, add-dep, remove-dep, update, decompose, overview, help
```

```bash
"/Users/santoshkumarradha/Documents/agentfield/code/planq/target/release/planq" project --help
```

```text
Usage: planq project [OPTIONS] <COMMAND>
Commands: create, list, status, dag, help
```

```bash
"/Users/santoshkumarradha/Documents/agentfield/code/planq/target/release/planq" task create --help
```

```text
Usage: planq task create [OPTIONS] --project <PROJECT> --title <TITLE>
Options include: --description, --priority, --dep, --kind, --parent, ...
```

```bash
"/Users/santoshkumarradha/Documents/agentfield/code/planq/target/release/planq" task claim --help
```

```text
Usage: planq task claim [OPTIONS] --agent <AGENT> <TASK_ID>
```

```bash
"/Users/santoshkumarradha/Documents/agentfield/code/planq/target/release/planq" task update --help
```

```text
Usage: planq task update [OPTIONS] <TASK_ID>
```

```bash
"/Users/santoshkumarradha/Documents/agentfield/code/planq/target/release/planq" task next --help
```

```text
Usage: planq task next [OPTIONS] --project <PROJECT> --agent <AGENT>
```

```bash
"/Users/santoshkumarradha/Documents/agentfield/code/planq/target/release/planq" task start --help
```

```text
Usage: planq task start [OPTIONS] <TASK_ID>
```

```bash
"/Users/santoshkumarradha/Documents/agentfield/code/planq/target/release/planq" task done --help
```

```text
Usage: planq task done [OPTIONS] <TASK_ID>
```

```bash
"/Users/santoshkumarradha/Documents/agentfield/code/planq/target/release/planq" project create --help
```

```text
Usage: planq project create [OPTIONS] <NAME>
```

--------------------------------

### GET /health

Source: https://github.com/agent-field/plandb/blob/main/experiments/product-iteration/phase-2-optimization/test-improved-prompt/API_DESIGN.md

Checks the health status of the Calculator API.

```APIDOC
## GET /health

### Description
Checks the health status of the Calculator API.

### Method
GET

### Endpoint
/health

### Response
#### Success Response (200 OK)
- **status** (string) - The health status of the service, typically "ok".

#### Response Example
```json
{
  "status": "ok"
}
```
```

--------------------------------

### Run Pre-trained Mini-GPT Model Demo

Source: https://github.com/agent-field/plandb/blob/main/experiments/mini-gpt-rust/README.md

Instantly run the pre-trained tool-calling agent demo without any training. This loads weights from 'weights/' and processes sample queries.

```bash
cargo run --release -- --demo
```

--------------------------------

### PlanDB Directory Structure

Source: https://github.com/agent-field/plandb/blob/main/experiments/product-iteration/GOALS.md

Illustrates the directory structure for PlanDB product iteration experiments, including directories for goals, findings, and phased development of features like core loop validation, agent ergonomics, and new features such as context store and hooks.

```bash
experiments/product-iteration/
├── GOALS.md                 ← this file
├── FINDINGS.md              ← accumulated findings from experiments
├── phase-1-validation/      ← existing feature validation
│   ├── test-core-loop/      ← each test scenario is a directory
│   ├── test-decomposition/
│   ├── test-multi-agent/
│   └── ...
├── phase-2-optimization/    ← agent ergonomics improvements
└── phase-3-features/        ← new feature prototypes
    ├── context-store/
    ├── bm25-search/
    ├── hooks/
    └── session-continuity/
```

--------------------------------

### Running Task Status Output

Source: https://github.com/agent-field/plandb/blob/main/experiments/02-with-vs-without/with-planq/work-log.md

This JSON output indicates that a task has started running.

```json
{"id":"t-30g296","status":"running"}
```

--------------------------------

### Task Done Output Example

Source: https://github.com/agent-field/plandb/blob/main/experiments/02-with-vs-without/with-planq/work-log.md

This JSON output indicates that a task has been marked as 'done'.

```json
{"id":"t-gzfzl3","status":"done"}
```

--------------------------------

### Get Next Task

Source: https://github.com/agent-field/plandb/blob/main/experiments/01-fibonacci-api/experiment-log.md

Fetches the next available task for an agent within a project.

```bash
"/Users/.../planq" --db "/Users/.../planq.db" --json task next --project "proj_01KJWCN1YV7BZFW9M68DG5W2YG" --agent "ai-agent-1"
```

--------------------------------

### Claim Task

Source: https://github.com/agent-field/plandb/blob/main/experiments/02-with-vs-without/with-planq/work-log.md

Claim a task to indicate that you are starting to work on it. This changes the task status to 'claimed'.

```bash
planq --db .../planq.db --json task next --project p-zyj41z --agent me --claim
```

```json
{"id":"t-lxr7wz","status":"claimed"}
```

--------------------------------

### Running Tests Task Status Output

Source: https://github.com/agent-field/plandb/blob/main/experiments/02-with-vs-without/with-planq/work-log.md

This JSON output indicates that the tests task has started running.

```json
{"id":"t-b6zyyz","status":"running"}
```

--------------------------------

### Running Export Task Status Output

Source: https://github.com/agent-field/plandb/blob/main/experiments/02-with-vs-without/with-planq/work-log.md

This JSON output indicates that the export task has started running.

```json
{"id":"t-ejn5de","status":"running"}
```

--------------------------------

### List Available PlanDB Integration Platforms

Source: https://github.com/agent-field/plandb/blob/main/experiments/docs-site-claude/cli-reference.html

Lists all available platforms for which integration prompts can be generated.

```bash
$ plandb prompt --list
```

--------------------------------

### Key PlanDB Commands for Task Management

Source: https://github.com/agent-field/plandb/blob/main/examples/PLANDB_PROMPT.md

Illustrates various commands for adding, splitting, and managing tasks, including context, search, and status checks. Useful for detailed project planning and adaptation.

```bash
plandb add "title" --description "spec" --dep t-upstream [--as custom-id] [--kind code]
plandb split --into "A, B, C"                   # independent subtasks (parallel)
plandb split --into "A > B > C"                 # dependency chain (sequential)
plandb context "what you discovered" --kind discovery  # record project knowledge
plandb search "query"                            # BM25 search across context + tasks
plandb critical-path                             # longest chain — prioritize this
plandb bottlenecks                               # what's blocking the most work
plandb list --status ready                       # tasks safe to parallelize NOW
plandb task insert --after t-a --before t-b --title "X"  # insert missed step
plandb task amend t-xxx --prepend "NOTE: ..."    # annotate future task
plandb what-if cancel t-xxx                      # preview before destructive action
plandb status --detail                           # dependency tree view
plandb status --full                             # compound graph view
```

--------------------------------

### Running Stats Task Status Output

Source: https://github.com/agent-field/plandb/blob/main/experiments/02-with-vs-without/with-planq/work-log.md

This JSON output indicates that the statistics generation task has started running.

```json
{"id":"t-dlwtj6","status":"running"}
```

--------------------------------

### Create Task with Planq CLI (Successful)

Source: https://github.com/agent-field/plandb/blob/main/experiments/01-fibonacci-api/experiment-log.md

Successfully creates a task within a project, specifying its title, description, and priority. The output confirms the task creation with its ID and initial status.

```bash
"/Users/.../planq" --db "/Users/.../planq.db" --json task create --project "proj_01KJWCN1YV7BZFW9M68DG5W2YG" --title "Create Python project scaffold" --description "Set up Flask/pytest project files and dependency manifest." --priority 10
```

```json
{ "id": "task_01KJWCNBYG6A9XGPZN86PEV8H9", "status": "pending" }
```

--------------------------------

### Complete a Task in PlanDB

Source: https://github.com/agent-field/plandb/blob/main/experiments/docs-site-gemini/reference.html

Marks a task as complete. Optionally accepts result data and can automatically claim and start the next task.

```bash
plandb done [OPTIONS] [TASK_ID]

Options:
      --result <RESULT>  Result data (JSON or plain text)
      --next             After completing, claim + start next ready task
```

--------------------------------

### What-If Analysis Command

Source: https://github.com/agent-field/plandb/blob/main/docs/ARCHITECTURE.md

Example of how to use the 'what-if' command to preview the effects of a cancellation operation without making actual changes.

```bash
plandb what-if cancel t-abc
```

--------------------------------

### Core PlanDB Workflow Commands

Source: https://github.com/agent-field/plandb/blob/main/examples/PLANDB_PROMPT.md

Demonstrates the core loop of claiming a task, completing it, and claiming the next. Also shows how to check the status and critical path of the project.

```bash
plandb go                 # claim next ready task (shows upstream context)
# ... do the work ...
plandb done --next        # complete + claim next
plandb status --detail    # reassess: does the plan still make sense?
plandb critical-path      # what should be prioritized?
```

--------------------------------

### Run Fibonacci Tests

Source: https://github.com/agent-field/plandb/blob/main/experiments/product-iteration/phase-1-validation/test-core-loop/README.md

Execute the test suite for the Fibonacci module using pytest. Ensure pytest is installed and configured in your environment.

```bash
pytest
```

--------------------------------

### List Artifacts for a Task

Source: https://github.com/agent-field/plandb/blob/main/experiments/docs-site-claude/cli-reference.html

Use to get a list of all artifacts that have been attached to a specific task. This provides an overview of the data associated with the task.

```bash
plandb artifact list --task t-impl
```

--------------------------------

### PlanDB CLI Entry Point

Source: https://github.com/agent-field/plandb/blob/main/experiments/docs-site-gemini/reference.html

The main entry point for PlanDB. Use subcommands to manage projects and tasks. This tool manages a dependency-aware task graph in SQLite and offers CLI, MCP server, and HTTP API interfaces.

```bash
plandb [OPTIONS] [COMMAND]
```

--------------------------------

### Get Task Status and Complete

Source: https://github.com/agent-field/plandb/blob/main/experiments/01-fibonacci-api/experiment-log.md

Retrieves the current status of a task and then successfully marks it as done. Also checks project status.

```bash
"/Users/.../planq" --db "/Users/.../planq.db" --json task get "task_01KJWCNBYG6A9XGPZN86PEV8H9"
```

```bash
"/Users/.../planq" --db "/Users/.../planq.db" task done "task_01KJWCNBYG6A9XGPZN86PEV8H9"
```

```bash
"/Users/.../planq" --db "/Users/.../planq.db" project status "proj_01KJWCN1YV7BZFW9M68DG5W2YG"
```

--------------------------------

### PlanDB CLI: Adding Tasks

Source: https://github.com/agent-field/plandb/blob/main/experiments/product-iteration/phase-2-optimization/improved-prompt-v1.md

Shows the syntax for adding new tasks to PlanDB, emphasizing the inclusion of a description and optional custom ID and kind.

```bash
plandb add "title" --description "detailed spec" --dep t-upstream [--as custom-id] [--kind code]
```

--------------------------------

### Running List Task with Tag Status Output

Source: https://github.com/agent-field/plandb/blob/main/experiments/02-with-vs-without/with-planq/work-log.md

This JSON output indicates that a task for the list command with a tag filter has started running.

```json
{"id":"t-fmaqsy","status":"running"}
```

--------------------------------

### Build and Test Commands

Source: https://github.com/agent-field/plandb/blob/main/CLAUDE.md

Standard commands for building the project, running unit and functional tests, and performing code quality checks.

```bash
cargo build            # build
cargo test             # unit tests (8 tests)
bash tests/functional_test.sh  # functional tests (7 scenarios)
cargo clippy           # lints
cargo fmt --check      # formatting
```

--------------------------------

### PlanDB CLI: Task Decomposition

Source: https://github.com/agent-field/plandb/blob/main/experiments/product-iteration/phase-2-optimization/improved-prompt-v1.md

Demonstrates how to split tasks into independent subtasks or sequential chains using the PlanDB CLI.

```bash
# Decomposition
plandb split --into "A, B, C"           # Independent subtasks (parallel)
plandb split --into "A > B > C"         # Dependency chain (sequential)
```

--------------------------------

### Add Dependency Between PlanDB Tasks

Source: https://github.com/agent-field/plandb/blob/main/experiments/docs-site-gemini/reference.html

Establishes a dependency relationship between two existing tasks, specifying which task must complete before another can start.

```bash
plandb task add-dep [OPTIONS] --after <AFTER> <TO_TASK>

Arguments:
  <TO_TASK>  Downstream task (the one that waits)

Options:
      --after <AFTER>  Upstream task (must complete first)
```

--------------------------------

### Pytest Test Run Output

Source: https://github.com/agent-field/plandb/blob/main/experiments/01-fibonacci-api/experiment-log.md

Example output from a successful pytest run, indicating that all tests passed. This confirms the stability of the implemented Fibonacci API.

```text
12 passed in ~0.06-0.07s
```

--------------------------------

### Inspect Task and Dependency Commands

Source: https://github.com/agent-field/plandb/blob/main/experiments/01-fibonacci-api/experiment-log.md

Displays help information for task listing and removal, and lists tasks for a specific project. Also shows help for cancelling tasks.

```bash
"/Users/.../planq" task list --help
```

```bash
"/Users/.../planq" --db "/Users/.../planq.db" --json task list --project "proj_01KJWCN1YV7BZFW9M68DG5W2YG"
```

```bash
"/Users/.../planq" task remove-dep --help
```

```bash
"/Users/.../planq" task cancel --help
```

--------------------------------

### Add a task with dependencies and description

Source: https://github.com/agent-field/plandb/blob/main/experiments/docs-site-codex/index.html

Use 'plandb add' to create a new task, specifying its dependencies, a description, and other metadata. This task will be added to the graph.

```bash
plandb add "Draft docs" --dep t-api --description "Write docs"
created task t-docs
```

--------------------------------

### Get Project Status

Source: https://github.com/agent-field/plandb/blob/main/experiments/02-with-vs-without/with-planq/work-log.md

View the current status of a project, including the total number of tasks, completed tasks, ready tasks, and pending tasks.

```bash
planq --db .../planq.db --json project status p-zyj41z
```

```json
{"tasks_total":9,"tasks_done":1,"tasks_ready":1,"tasks_pending":7}
```

--------------------------------

### plandb task overview

Source: https://github.com/agent-field/plandb/blob/main/experiments/docs-site-claude/cli-reference.html

Provides a full project overview, including all tasks, dependencies, and a progress summary.

```APIDOC
## plandb task overview

### Description
Full project overview: all tasks, dependencies, and progress summary.

### Method
CLI Command

### Endpoint
N/A

### Parameters
#### Options
- **--project** (string) - Optional - Project ID (uses default if not set)
```

--------------------------------

### Add Dependency Between Tasks

Source: https://github.com/agent-field/plandb/blob/main/experiments/docs-site-claude/cli-reference.html

Use to establish a dependency where one task must complete before another can start. Specify the downstream and upstream tasks, and the kind of dependency.

```bash
plandb task add-dep t-tests --after t-impl --kind feeds_into
```

--------------------------------

### Execute Task Lifecycle for Core Logic

Source: https://github.com/agent-field/plandb/blob/main/experiments/01-fibonacci-api/experiment-log.md

Demonstrates the full lifecycle for a core logic task, from claiming to completion.

```bash
"/Users/.../planq" --db "/Users/.../planq.db" --json task next --project "proj_01KJWCN1YV7BZFW9M68DG5W2YG" --agent "ai-agent-1"
```

```bash
"/Users/.../planq" --db "/Users/.../planq.db" --json task claim "task_01KJWCNTZ63J281JGXW08H9CAC" --agent "ai-agent-1"
```

```bash
"/Users/.../planq" --db "/Users/.../planq.db" --json task start "task_01KJWCNTZ63J281JGXW08H9CAC"
```

```bash
"/Users/.../planq" --db "/Users/.../planq.db" task done "task_01KJWCNTZ63J281JGXW08H9CAC"
```

```bash
"/Users/.../planq" --db "/Users/.../planq.db" project status "proj_01KJWCN1YV7BZFW9M68DG5W2YG"
```