Projects

A project is the durable home for a codebase across everything you do in partyline — its machines, runs, context threads, and the standing guardrails your agents build within. It's the join key that ties a repo on your laptop to the runs on the board and the shared memory your agents read.

The label

Every project has a label — a short slug (e.g. checkout-web) that machines advertise and runs point at. It's the key that joins machines, runs, and threads, so the board knows which machine can build which project.

$ ptln project

lists your team's projects. Create one:

$ ptln project new "checkout-web" --team acme

Inspect a project's promoted facts (its canon):

$ ptln project show <id>

Manage the display name, description, and repository on the web at partyline.sh/projects. + New project there creates a project with no repo attached — useful as an umbrella for other projects, or as a pure planning container.

Umbrella projects

A project can contain other projects — one level deep. On a repo project's page, set Part of to put it inside an umbrella; the umbrella's page lists its repos under Repos in this project.

The point is planning: a planning session on any repo inside an umbrella plans into the umbrella's single context thread — one memory and one plan for a multi-repo product, instead of a plan per repo. Repo-less projects (created with + New project) are the natural umbrellas.

Tasks still know where they build. In an umbrella, the Planning agent assigns each task the repo it builds in, and Start/Promote pre-select that repo — so a cross-repo plan still dispatches each task to the right codebase.

Context & planning

Every context thread belongs to a project. The project page's Context & planning panel lists its threads, and Planning agent defaults into the project's own thread — created automatically the first time you plan, titled after the project. Attach an existing thread to a project (or detach it) from the thread's own page; only the thread owner can.

Guardrails your agents build within

A project carries standing guidance — your stack, your conventions, what "done" means — that's injected into every run in that project. Set it up once and every agent that builds a task reads it, so you're not restating "use server components, always add a migration, never touch the auth module" on each task.

There's also a planning instructions field that steers the interview for every plan made in the project — appended to the default prompt, never replacing it.

Base branch

Every run forks from and every PR targets the project's base branch — one setting, read for both, so a run can never build off one branch and open its PR against another. It defaults to main; point it at develop (or a release branch) in project settings and the whole pipeline follows.

The branch must exist on the remote: a run against a base the remote doesn't have fails loudly with that reason rather than silently falling back to main — building against the wrong base is the kind of mistake you want stopped, not papered over. Needs CLI ≥ 0.15.0 on the daemon; older daemons keep using main.

Engine and model, per phase

Project settings pin an engine and model for each phase — planning, building, review. Engines are a closed set (claude · codex · gemini · opencode · goose · antigravity); models are free-form and belong to the engine you picked. Blank = the machine's registered default (ptln daemon add-project --engine), and a per-run override on Start beats both.

Antigravity is interactive/planning-only — it can't run headless build or review jobs, so those selects don't offer it. The other limits (codex needs bash, gemini needs a trusted project dir, daemons need CLI ≥ 0.10.0) live in which engine builds.

Projects and shared context

Projects are the substrate for Context Threads: every thread belongs to a project, and durable facts a thread accumulates can graduate into the project's canon, so they outlive any single thread. Deleting a project removes the definition only — machines keep advertising the label, and graduated context survives.

Next: Context Threads · Build & Ship · Planning agent.