---
title: Project Tracker — AI Operating Guide
version: 1.7.0
updated: 2026-10-08
canonical_url: https://app.project-tracker.ai/mcp/prompt.md
version_url: https://app.project-tracker.ai/mcp/prompt/version
---

# Project Tracker — AI Operating Guide

You have the **`project-tracker`** MCP server available. Project Tracker (PT) is a
lightweight tracker — **projects → items (stories/tasks)** with a Kanban board, a
value/effort plan view, a per-user schedule/timeline, and, for entitled keys, the
**Leader/Follower (L/F) orchestration tier**. Every tool call is made **as your
connected identity** — the same identity, permissions, and audit trail as the REST
API. There is no separate service account.

Read this guide once at the start of a session, then work from it.

## Staying current

This guide is **versioned** (see `version:` in the front matter). The MCP server
reports the current version in its connect-time **instructions** — if that's newer
than the one you last read, **re-read this guide**.
- Cheap check: `GET https://app.project-tracker.ai/mcp/prompt/version` → `{"version": "…"}`.
- Full guide: `GET https://app.project-tracker.ai/mcp/prompt.md`.

## Core model

- **Project** — a grouping with a short key (e.g. `PT`, `WEB`); keys are namespaced per owner.
- **Item** — a `story`, `task`, or `bug` (or `epic`, on projects with the tier enabled), keyed `PROJ-123`. Has `status` (backlog · todo · blocked · in_progress · review · done), `priority`, `labels`, `value`/`effort`/`desirability` (1–5), `assignee` (the accountable **human** — a project member), optional `parentKey`, `blockedBy[]` (a **hard** scheduling gate) and `dependsOn[]` (a **soft** structural "rests on / needs" edge — does not gate scheduling; powers the reverse "what depends on X" lookup so a shared mechanism gets built once).
- **Item types are not interchangeable** — see *Ticket-writing discipline* below. A **story** describes a need, a **task** does a piece of work, an **epic** groups stories, a **bug** is something built-and-wrong.
- **Claim vs owner:** `claimedBy` is a transient worker soft-claim (multi-AI safety); `assignee` is the accountable human. They're different fields.
- **Thread** — a cross-project **coordination** effort (see below). References tickets and child threads; owns no work of its own.
- **Provenance** — a ticket can carry `commit_refs` (code that changed it), `entity_refs` (Cornerstone entities it cites/produces), and `comments` (append-only human discourse, distinct from the AI `changeLog`).
- **Full data model** — every record, field, enum and relationship: `GET https://coordinator.instructedintelligence.com/api/docs/model` (markdown, generated from the database models; the OpenAPI schemas at `/api/docs/json` share the source).

## Working on an item (the discipline)

1. `get_item` first — if it's already `in_progress` under another worker, back off (or `force`).
2. `get_item_context` — resolved repo path / branch / notes.
3. Claim it: `move_item { key, status: "in_progress", claimedBy: "<your-worker-id>" }`.
4. Do the work; **append** to `changeLog` (never overwrite `description`/`notes`); include file paths.
5. After committing, `attach_commit { key, sha, repo, url }` — the structured ticket→code link (don't just paste the SHA into the changelog).
6. Move to `review` (or `done` for trivial work). For risky field edits, pass `expectedVersion` (optimistic concurrency → 409 on stale).

Assignment / moves / watched-changes send email — **don't churn them**. `delete_item`
is a soft-delete; pair with `restore_item` / `list_items({deleted:true})`.

## Walking lists

Every list loads one page at a time. No tool returns everything, and you should never ask for
everything: ask for a page, read what you need, and fetch more only if the task needs it.

A list response starts with the paging fields, then the rows:

```
{ "total": 1340, "returned": 200, "offset": 0, "limit": 200, "has_more": true,
  "next_offset": 200, "note": "PARTIAL: 200 of 1340 items ...", "items": [ ... ] }
```

- `total` is how many rows match your filters. `returned` is how many are in this response.
- `next_offset` is there only when more rows remain. If you see it, you do **not** have the whole
  list. Call again with the same arguments and `offset` set to `next_offset`. Stop when it is absent.
- Before you say "there are N" or "nothing else is open", check `total` and `has_more`. Count from
  `total`, not from the rows you happen to hold.
- Use filters (`project`, `status`, `type`, `label`, `search`) to get a small answer, in preference
  to paging through a large one.
- List rows are short. To read one ticket in full (description, change log, comments), call
  `get_item`. Do not use `full: true` to read a whole project.
- If rows are added or removed while you walk, a row can shift between pages. If `total` changed
  between pages and the answer matters, walk again.

| Tool | Rows under | Default page | Maximum |
|---|---|---|---|
| `list_items`, `get_board`, `get_matrix` | `items` / the status arrays / `cells` | 200 | 500 |
| the same three with `full: true` | complete items | 20 | 50 |
| `list_projects` (`full: true`) | `projects` | 200 (20) | 500 (50) |
| `list_threads` | `threads` | 50 | 200 |
| `get_activity_feed`, `get_item_timeline` | `events` | 100 | 500 |
| `list_members`, `list_org_members` | `members` | 200 | 500 |

Asking for more than the maximum returns the maximum.

**The board.** `get_board` pages across all columns and fills them in this order: in_progress,
review, blocked, todo, backlog, done. `counts` gives the true size of every column. A column that
is empty on a page that has `next_offset` may simply not have been reached: check `counts`.

**Lists inside one record** are paged with their own names, in the same way:

- `get_item` returns the 50 most recent change log entries and the 50 most recent comments.
  `changeLogTotal` / `commentsTotal` say how many exist. `changeLogNextOffset` /
  `commentsNextOffset` appear when older ones remain: pass that value as `changeLogOffset` /
  `commentsOffset` to read further back. Maximum 200 per call.
- `get_thread` returns up to 200 referenced tickets and 50 child threads. `itemsTotal`,
  `itemsNextOffset` and `itemsOffset` work the same way (likewise `childThreads…`). `rollup` always
  covers the whole thread.

**Getting everything out.** Everything you can see is reachable page by page:

```
list_items { project: "WEB", includeAllDone: true }     # every live item, done of any age included
list_items { project: "WEB", deleted: true }            # deleted items (the trash)
get_item   { key: "WEB-12" }                            # one item in full; page its trails as above
get_item   { key: "WEB-9", deleted: true }              # a deleted item in full
list_threads {}  then  get_thread { key: "THR-3" }      # threads and what each one references
get_activity_feed { project: "WEB" }                    # who did what, when
```

Without `includeAllDone`, `list_items` and `get_board` leave out `done` tickets not updated in the
last two weeks, and `total` does not count them. Walk each list to the end with `next_offset`.

## Ticket-writing discipline

Keep the item types distinct — a board that mixes descriptions and doings becomes a
specification pretending to be a plan (this discipline came out of a real board where
the same code got built three times because three tickets each implied it):

- **story** — *describes* a need, feature, rule, or defect. Stays true after the work is done. A story is a specification, not a plan. **Write the need, not the solution** — naming a design pre-empts the architecture.
- **task** — *does* something and finishes: writes code, runs an analysis, gets an answer from a third party.
- **epic** — *groups* stories (needs the project's `hierarchyEnabled` tier).
- **bug** — something is **built and wrong** (distinct from *missing*, which is a story).

Rules when you file or update tickets:
1. **One idea per ticket** — an em-dash welding two thoughts is usually two stories, and it won't close cleanly.
2. **Don't close a story you didn't deliver the tasks for.** A story closes when its delivering tasks are done. If you believe it's finished, add a `changeLog` note and leave the status — closing a description doesn't make it true.
3. **Check before you file** — search for an existing story that already describes it; add to that one. Use `dependsOn` when several tickets rest on one shared mechanism, so it's built once.
4. **Use `bug` for built-and-wrong**, not for missing behaviour.

## Close gates — closing is where completeness is enforced

Because a long-running session never re-reads docs, the load-bearing rules are enforced
**at the close call itself** — a refusal is the only channel that reaches you at the moment
you flip a ticket to `done`. Three things can gate or ride a close:

- **`released` (informational)** — closing a ticket returns a `released` object listing still-open tickets it **blocked** (each flagged `nowUnblocked` when this was their last blocker) and tickets that **soft-depend** on it. Check it and pick up / re-surface anything now actionable.
- **Successor gate** — an item flagged `requiresSuccessor` **cannot** reach `done` (409, `requiresSuccessor:true`) until you pass one of: `successor` (inline `{title,…}` → creates + links the follow-on in one gesture), `successorKey` (link an existing ticket), or `dismissSuccessor` (a positive "no follow-on needed, because…" reason). Use it for a decision/spike/diagnosis whose answer implies build work — "answered" and "actioned" are different states.
- **Definition-of-Done gate** — if the project has a `definitionOfDone` (opt-in criteria like code/tests/UI/data-write), closing a **story or bug** is refused (409, `dodRequired:true`, `unaddressed:[…]`) until you pass a `dod` attestation addressing **every** criterion: `[{key, state:"met"|"na"|"waived", reason?}]` (waived needs a reason). This is what stops a ticket being marked done with the UI, tests, or the data-write silently missing. Tasks/epics are exempt.

All three are enforced identically on `update_item` and `move_item`, and gated closes are **rejected on bulk** (bulk can't carry a per-item successor/dod — close those individually). Find shipped-but-forgotten work with `list_items({ deliveredOpen: true })` (has a commit, still open).

## Tool families

- **Projects:** `list_projects` (SLIM by default — key/name/status/color + the canonical* routing fields; enough to read `canonicalTenant` for every project in one bounded call, `full:true` for everything — PT-233), `create_project`, `update_project` (incl. `canonicalTenant` to route a project's knowledge to a Cornerstone tenant — see *Connecting a project to Cornerstone*; `hierarchyEnabled` to switch on the `epic` tier; and `definitionOfDone` to set the per-project close gate), `list_members` (call before assigning/@mentioning — assignment is member-scoped).
- **People and sharing:** `create_project { private }` / `update_project { teamId: "everyone" | private }` (who a project is shared with), `share_project` (share an existing project with everyone in the organization — owner, an editor collaborator or an organization admin), `add_collaborator` / `remove_collaborator` (one person's access to one project), `list_org_members` (the people in your organization and its admins), `set_org_admin`. See *Who sees what*.
- **Items:** `list_items` (paged; filters incl. `deliveredOpen` = shipped-but-still-open; see *Walking lists*), `get_item`, `get_item_context`, `create_item`, `update_item`, `move_item`, `delete_item`, `restore_item`, `bulk_update_items` (also sets `type` + `parentKey` — the one-call board **reshape**: retype tickets and file them under epics), `get_board`, `get_matrix`, `get_item_timeline` (PT-247 — an item's structured activity + auto-derived time: time-in-status/cycle/lead/age, "how long did this sit in review"), `get_activity_feed` (PT-247 — a project's "who did what, when", paged, filter by actor/action/date).
- **Provenance:** `attach_commit` (ticket → git commit; idempotent on sha+repo), `attach_entity_ref` (ticket → Cornerstone entity, relationship `informed_by`/`produces`/`supersedes`/`cites`). Both require editItemFields on the project.
- **Onboarding and offboarding (admin only):** `create_org` (create a customer's organization — it must exist before anyone can be put in it), `provision_user` (create a person's account inside their organization by org slug — no welcome email, they sign in through II), `create_project { owner }` (create a project that belongs to that person, in their org, without you on it), and `deactivate_user` (close a person's account by email when their access is revoked). See *Onboarding a customer person*.
- **Threads:** `create_thread`, `get_thread`, `list_threads`, `add_to_thread` / `remove_from_thread` (a `ref` is a ticket key like `PT-1` **or** a child-thread key like `THR-2` — disambiguated by shape), `close_thread`, `delegate_thread`, `get_thread_rollup`.

## Who sees what

A person sees a project when one of these is true, and only ever inside their own organization:

- they **own** it;
- it is **shared with a team they are in**. An organization that shares by default has an
  **Everyone** team that all its people are in automatically, so a project shared with Everyone is
  seen by the whole organization;
- they are a **collaborator** on it (added one by one, with a role: viewer, commenter or editor).

**Where an organization shares by default, new projects are shared with everyone in it.**
`create_project` with nothing extra puts the project on the Everyone team, so a new colleague sees
the organization's work the first time they sign in. Say `private: true` for a project only you and
the people you add can see. Before creating a project, think about which one the person means; if it
is personal or sensitive (pay, HR, a client matter), ask or use `private: true`.

Sharing by default is a setting of each organization. Organizations created for a customer have it
on. An organization with it **off** has no Everyone team: a new project there is visible only to its
owner (as it always was), and `teamId: "everyone"` / `share_project` answer 409 saying so. The
`teamId` on the project that `create_project` returns tells you which happened: set means shared,
absent means private. A Coordinator admin switches it on.

```
create_project { key: "OPS", name: "Operations" }                  # the whole organization sees it
create_project { key: "HR",  name: "HR", private: true }           # only you, until you add people
share_project  { key: "OLD" }                                      # share an existing project
update_project { key: "OPS", private: true }                       # stop sharing it
add_collaborator { key: "HR", email: "sam@example.com", role: "viewer" }
```

- **Existing projects did not change.** A project created before this stays exactly as visible as
  it was. `share_project { key }` shares it with the whole organization in one step. The owner can
  call it, and so can a collaborator with the editor role, so it does not depend on the owner being
  around. If you cannot see a project at all, you cannot share it: ask its owner.
- **Private means private.** A project with no team is seen by its owner and its collaborators and
  nobody else, organization admins included.
- **Organization admins.** Some people are admins of their organization (`list_org_members` shows
  who). An admin can see every *shared* project in their organization, whichever team it is on, add
  or remove its collaborators, and change who it is shared with. That is who to ask when a project's
  owner is away. An admin is not the owner: they cannot delete a project, or change its settings or
  where its work is filed (`canonicalTenant`, `canonicalProject`). An admin can make a colleague an
  admin with `set_org_admin`; the last admin cannot be demoted.
- **The Everyone team looks after itself.** People join it when they are added to the organization
  and leave it when their account is closed. It cannot be renamed, deleted or edited by hand; the
  team tools refuse and say why.
- **Nobody outside the organization sees its projects.** That includes Instructed Intelligence's own
  admins and support staff: their role manages accounts and organizations, and gives no access to
  what is in a customer's projects. So if someone cannot see a project, the fix is always inside
  their own organization (the owner, or an organization admin), never a request to II.
- **Seeing nothing?** `list_projects` returning `[]` means nothing has been shared with you yet, or
  your account is not in an organization. Ask the owner of the project you need to run
  `share_project`, or one of your organization's admins (`list_org_members`) to add you.

## Onboarding a customer person (admin only)

A customer person can be onboarded entirely over MCP. Their only action is setting their II
sign-in password; they never need to open Coordinator first.

```
create_org     { name: "Blue Bear Storage", org: "blue-bear", canonical_tenant: "<their tenant uuid>" }
provision_user { email: "edward@example.com", name: "Edward", org: "blue-bear", org_admin: true }
create_project { key: "BBS", name: "BBS Finance", owner: "edward@example.com",
                 canonicalTenant: "<their tenant uuid>", canonicalProject: "<their project uuid>" }
```

- **The organization comes first.** `create_org` is step one for a new customer: a person can only
  be put in an organization that exists, and a person with no organization sees nothing. `org` is
  the II sign-in org **slug** (lowercase letters, digits, hyphens; 3–40) and must match the value
  in their ii-signin `orgs` claim exactly, because sign-in finds the organization by it. It cannot
  be changed later. `canonical_tenant` is the customer's Cornerstone knowledge tenant: where the
  organization's closed work is filed when a project names no tenant of its own.
- `create_org` is idempotent: an existing slug returns the same organization (`created: false`) and
  is **not renamed**. A `canonical_tenant` is filled in only while the organization has none; a
  **different** one is **refused (409)**, because re-pointing would file one customer's work into
  another's knowledge base. Changing it on purpose is `PATCH /ii-admin/tenants/{id}`, not a retry.
- In `provision_user`, `org` is that same slug. It must already exist (404 otherwise). The account
  gets no Coordinator password and no email; their first II sign-in links to it by verified email.
- `provision_user` is idempotent: re-running returns the same account. An account still sitting in
  the default (II) organization is moved into the named org (`moved: true`). It is **refused (409)**
  for someone already in a different customer organization, for an admin, and for a deactivated
  account (restore that one instead).
- **Make the first person an organization admin** (`org_admin: true`), so the customer can manage
  its own projects and people from then on. II cannot see a customer's projects, so without an
  admin of their own they would be stuck whenever a project's owner is away. `set_org_admin` changes
  it later.
- Every provisioned person joins their organization's **Everyone** team, so they see whatever the
  organization shares with everyone from their first sign-in. A new organization shares by default.
  See *Who sees what*.
- If II sign-in calls the organization something other than its slug, pass those names as
  `claim_slugs` on `create_org`, or sign-in will not match its people to it.
- `owner` on `create_project` makes the project **theirs**: they own it, it lives in **their**
  organization (so its work routes to their tenant, not yours) and **you are not added to it**.
  Without `owner`, a project you create is yours and lands in your org — the mistake this exists to
  prevent. Non-admins get 403. It is shared with everyone in **their** organization unless you add
  `private: true`.

**Offboarding.** When a person's access is revoked, close their account here too:

```
deactivate_user { email: "edward@example.com" }
```

Revoking someone in II sign-in does not close their Coordinator account or their API keys; this
does. It is a soft-delete: they can no longer sign in, their API keys and sessions are revoked, and
their tickets and history keep their author. It is idempotent (`already_deactivated: true` on a
repeat), 404 for an unknown email, and **refused (409) for a Coordinator admin** so an offboarding
run can never lock the operators out. There is no reactivate tool on purpose: restoring a person is
an admin's decision in Admin → Users, and their old API keys stay revoked.

**Once a second organization exists, nothing is placed in an organization by default.** A person or
project with no organization sees, and is seen by, nothing until placed in one. So always name the
organization: `provision_user { org }`, and `create_project { owner }` for a customer's project.

## Connecting a project to Cornerstone

A project declares which **Cornerstone tenant** its work canonically routes to. That is what sends
capture, episodes and events to the right knowledge base rather than a default one.

```
update_project { key: "WEB", canonicalTenant: "<tenant-uuid>" }
```

- Settable on `create_project` **and** `update_project` — it is not create-only, so an existing
  project can be connected at any time.
- `""` clears it (→ *undecided*). `list_projects` returns it, so read it back rather than assuming it stuck.
- Get the id from Cornerstone's `list_tenants`.

**Three states, not two (PT-235).** The field distinguishes *undecided* from *deliberately none*:
- **absent / `""`** — undecided: work here should route somewhere and nobody has said where → **ask**.
- **`"none"`** — deliberately no tenant (a sandbox, demo, static wrapper): work here has no knowledge home → **route to the fallback WITHOUT asking**. Set `canonicalTenant: "none"` to say this; don't leave it blank and answer the question forever.
- **a tenant UUID** — route there.

**It is a TENANT id, not a Cornerstone project id.** Both are UUIDs and look identical. PT now
**validates on write (PT-208)**: a non-UUID that isn't `"none"` is rejected, and once the Cornerstone
lookup is wired a UUID that isn't one of your tenants is rejected with a message naming the likely
mistake (you pasted a *project* id). So a wrong id fails loudly at the point of the mistake rather than
routing silently nowhere.

**Targeting a Cornerstone project (PT-206).** A project may also set `canonicalProject` — the Cornerstone
*project* (UUID) within `canonicalTenant` to route to. Omit it for the tenant's default project (the old
behaviour); set it to land this project's capture in a specific project on a multi-project tenant. Only
meaningful alongside a declared tenant; clearing the tenant clears it. PT emits it on the `pt.item.*`
event as `tenant_project` — a consumer that honours it routes to the project (that consumer wiring is
Cornerstone's side). Like the tenant, only the UUID shape is validated today; resolving a project *key*
awaits the Cornerstone lookup.

**Not the same as `attach_entity_ref`.** `canonicalTenant` is project-level routing; the entity ref
records that one ticket cites or produces one specific piece of knowledge. Complementary, not
alternatives.

## Threads — cross-project coordination

A **thread** is a named effort with **one owner**, a goal, and a soft target date. It
holds **references** to tickets (in any project) and to **child threads** (a multilevel
DAG — cycles are rejected server-side); it owns no tickets of its own. Roll-up is a
live recursive query over descendants (`get_thread_rollup` → counts by status).

Use a thread to coordinate a cross-cutting effort **without inventing a programme**.
Discipline is baked in — respect it: **exactly one owner** (delegation via
`delegate_thread` is the right to act, *not* shared ownership); a **soft target date**
by convention; a soft warning past 3 concurrent owned threads; and **no ceremony
surfaces** (no stand-ups/burndowns/PI planning). A ticket referenced by a thread stays
owned by its project — reference, not containment. `get_item`'s reverse lookup is
`GET /api/items/:key/threads` (which threads cite this ticket).

## Leader/Follower tier (only if your key is entitled)

These tools appear **only when your key carries the `lf` entitlement** — a core key
never sees them. They **spend real inference**, so treat them with care.

- `set_contract` / `set_task_type` — stamp a follower ticket's acceptance contract (the machine-checkable definition of done) + routing signal.
- `get_verification_context` / `get_item_tree` — the cheap read a verifier uses.
- `dispatch_follower` — RUN a follower step (async-safe: a long job returns `{status:"running", run_id}`; poll `get_item` for `dispatchRun` + `output`; `dry_run` previews the grounded prompt; a running job returns 409, `force` overrides).
- `get_leader_plan` — the leader's reconcile-once view of a project (ready / blocked / running / wouldDispatch, Quick-Wins first). Read-only.
- `reconcile_project` — run the leader on a project and, if it's `autonomous` **or** you pass `execute:true`, wave-dispatch the ready set. Without `execute` on a `plan-review` project it's a no-op preview.

**Autonomy is the gate.** A project is `plan-review` (default — a human approves each
wave via `execute:true`) or `autonomous` (dispatches without asking). Prefer showing
the plan and waiting for a "go" unless told to run autonomously.

## Changelog

- **1.7.0** (2026-10-08) — every list is paged (PT-269). List tools take `limit` and `offset` and return `total`, `returned`, `has_more` and, when more remain, `next_offset`. **`list_items`, `list_projects`, `list_threads`, `list_members` and `list_org_members` no longer return a bare array**: the rows are under `items` / `projects` / `threads` / `members`. `get_board` and `get_matrix` keep their shape and add the paging fields (`get_board` also adds `counts`); `get_matrix` is now slim by default (`full: true` for complete items). `get_item` returns the 50 most recent change log entries and comments by default, with `changeLogOffset` / `commentsOffset` to read further back, and `deleted: true` to read an item in the trash. `get_thread` pages its tickets and child threads; `get_item_timeline` and `get_activity_feed` take `offset`; `get_item_tree` pages its children. A response with `next_offset` is never the whole list. See *Walking lists*.
- **1.6.0** (2026-10-05) — who sees what (PT-266). **In an organization that shares by default, new projects are shared with everyone in it**; `create_project { private: true }` keeps one to you and the people you add. Sharing by default is per organization: on for organizations created for a customer, off elsewhere until an admin switches it on (there, nothing changes). `share_project` shares an existing project in one step (owner, an editor collaborator or an organization admin); `update_project { private: true }` unshares it. New tools: `share_project`, `add_collaborator`, `remove_collaborator`, `list_org_members`, `set_org_admin`. A sharing organization has an Everyone team that its people join automatically. Organization admins can see every shared (never private) project in their organization and manage who is on it, without becoming its owner. `provision_user` takes `org_admin`; `create_org` takes `claim_slugs`. Existing projects are unchanged. See *Who sees what*.
- **1.5.0** (2026-10-05) — organizations over MCP, and offboarding (PT-265): new admin-only `create_org` (create a customer's organization by II sign-in slug, optionally with its Cornerstone tenant; idempotent; never re-points an existing tenant) and `deactivate_user` (close a person's account by email; revokes API keys and sessions; never an admin). Onboarding now starts with `create_org`. Once a deployment holds more than one organization, nothing is defaulted into one: an org-less person or project sees nothing. See *Onboarding a customer person*.
- **1.4.0** (2026-09-29) — onboarding a customer person over MCP (PT-264): new admin-only `provision_user` (account created in their organization by slug; idempotent; never moves someone between customer orgs) and `create_project { owner }` (the project belongs to that person and their org; the admin is not on it). See *Onboarding a customer person*.
- **1.3.5** (2026-09-28) — points to the generated data-model reference, `GET /api/docs/model` (PT-260): every record, field, enum and relationship, from the same source as the OpenAPI component schemas. No behaviour change.
- **1.3.4** (2026-09-07) — the activity/audit log (PT-247): `get_item_timeline` (an item's structured events + auto-derived time — time-in-status, cycle, lead, age; no human-entered durations) and `get_activity_feed` (a project's who-did-what-when, paged, filterable). Every event names the accountable human and, for AI work, which agent.
- **1.3.3** (2026-08-28) — `canonicalProject` (PT-206): a project can now route to a specific Cornerstone *project* within its tenant, not just the tenant's default. Set via create/update_project; emitted on `pt.item.*` as `tenant_project`. Closes the "no way to target a Cornerstone project" gap.
- **1.3.2** (2026-08-28) — `canonicalTenant` now has **three states** (PT-235): absent = *undecided* (ask), `"none"` = *deliberately no tenant* (route to fallback without asking), a UUID = route there. And it's **validated on write** (PT-208): a non-UUID that isn't `"none"` is rejected, and — once the Cornerstone lookup is wired — a UUID that isn't one of your tenants is rejected naming the likely mistake (a project id, not a tenant id). A wrong id now fails loudly instead of routing silently nowhere.
- **1.3.1** (2026-08-28) — `list_projects` is now **slim by default** (routing/orientation fields; `full:true` for everything). The full list at estate scale exceeded the tool-result token cap and made the routing read (`canonicalTenant` per project) impossible to complete in one call (PT-233).
- **1.3.0** (2026-08-28) — the ticket-writing discipline (story *describes* / task *does* / epic *groups* / **bug** = built-and-wrong; don't close a story you didn't deliver) and the three **close gates**: the `released` nudge (what a close unblocks), the **successor gate** (`requiresSuccessor` → `successor`/`successorKey`/`dismissSuccessor`, PT-222), and the per-project **Definition of Done** gate (`definitionOfDone` → `dod` attestation, PT-231). Adds the **`bug`** type, `dependsOn` (soft dependency), `list_items({deliveredOpen})`, and `bulk_update_items` board **reshape** (`type` + `parentKey`). These are enforced at the close call because a months-long session never re-reads docs — a refusal is the only channel that reaches it.
- **1.2.0** (2026-08-13) — documents `canonicalTenant` (project → Cornerstone tenant routing), which has existed since PT-178 but was never in this guide, so no session could discover it. States the two traps: it is a tenant id rather than a Cornerstone project id and is not validated, and targeting a Cornerstone *project* is not currently possible (PT-206).
- **1.1.0** (2026-08-09) — Threads (cross-project coordination primitive) + provenance tools (`attach_commit`, `attach_entity_ref`) + the opt-in `epic` tier (`update_project { hierarchyEnabled }`). Added the working-discipline step to `attach_commit` after committing.
- **1.0.0** (2026-08-04) — first hosted-guide release; documents the core model, the working discipline, and the L/F tier.
