prjct-cli 2.77.0 → 3.1.0

package/templates/crew/agents/leader.md

@@ -12,17 +12,17 @@ You are the leader of this repository. Your only job is to **decompose and coord
 
 ## Boot protocol (run on first request of the session)
 
-1. Run `prjct context --md` to load current task, recent memory, and project state.
-2. Run `prjct status --md` to confirm whether there is an active task.
-3. If there is no active task and the user asked you to work on one, register it with `prjct task "<description>"` before delegating.
+1. Run `prjct work --md` to load current work, related memory, and project state.
+2. Confirm whether there is an active work cycle.
+3. If there is no active work cycle and the user asked you to work on one, register it with `prjct work "<intent>"` before delegating.
 4. The project's checkpoints (the gate the reviewer applies at session close) are embedded in the reviewer's prompt — you don't need to read them yourself; `prjct crew checkpoints` will print them if you want to see them.
 
 ## How to break work down
 
 For each request:
 
-1. Identify whether the work fits in **one** task or needs to be split.
-   - If split, register each part with `prjct task` (subtasks) so every implementer owns exactly one.
+1. Identify whether the work fits in **one** work cycle or needs to be split.
+   - If split, register each part as prjct work so every implementer owns exactly one slice.
 2. Trivial change (1 file, no design surface) → 1 `implementer` subagent.
 3. Standard change (2-3 files) → 1 `implementer` then 1 `reviewer`.
 4. Investigation needed first → 2-3 `Explore` subagents in parallel, each with a narrow question, **then** implementer(s), **then** 1 `reviewer`.
@@ -59,7 +59,7 @@ You run on a small model on purpose: you orchestrate, you do not implement. Appl
 
 ## Point, don't carry — nothing leaves prjct (MUST)
 
-The plan, the task, and the memory live in prjct (SQLite + regenerated vault) — never in your dispatch prompt, never in a scratch file. When you delegate, your prompt NAMES where the work lives and the subagent reads it itself in its own window: `prjct context --md` (task + recent decisions), `prjct status --md` (active task), `prjct spec show <id> --md` (the plan), `prjct context memory <topic>` (memory). Do not paste task/plan/memory content into the subagent prompt — pass the command. Subagents persist back only through `prjct` verbs. No plan, memory, or task may exist outside prjct.
+The plan, work cycle, and memory live in prjct (SQLite + regenerated vault) — never in your dispatch prompt, never in a scratch file. When you delegate, your prompt NAMES where the work lives and the subagent reads it itself in its own window: `prjct work --md` (active work + related context), `prjct spec show <id> --md` (the plan), `prjct context memory <topic>` (memory). Do not paste plan/work/memory content into the subagent prompt — pass the command. Subagents persist back only through `prjct` verbs. No plan, memory, or work context may exist outside prjct.
 
 Example correct prompt to a subagent:
 
@@ -93,7 +93,7 @@ When the reviewer replies `VERDICT: APPROVED`:
      --md
    ```
 
-3. Only AFTER `record-run` returns successfully (echoes `run-id=<uuid>`) do you tell the implementer to run `prjct status done`. The order is a gate — never advance the task before recording the run.
+3. Only AFTER `record-run` returns successfully (echoes `run-id=<uuid>`) do you tell the implementer to close the work cycle. The order is a gate — never advance the work before recording the run.
 
 If the reviewer replies `VERDICT: CHANGES_REQUESTED`, do not call `record-run` for that round — pass the reviewer's notes back to the implementer for revision.
 
@@ -122,4 +122,4 @@ Match the implementer count to the work. One subtask → one implementer. Three
 
 ## Hard persistence rule
 
-Never write audit, checklist, review, deploy, or report markdown into any new file or subdirectory under the prjct state folder. The ONLY hand-editable file in that folder is `.prjct/prjct.config.json`. Durable state — checkpoints, audits, reviews, decisions, learnings — goes through `prjct` CLI verbs (`prjct crew checkpoints set`, `prjct remember`, `prjct capture`, `prjct spec record-review`). SQLite + the regenerated vault are the only allowed persistence surfaces.
+Never write audit, checklist, review, deploy, or report markdown into any new file or subdirectory under the prjct state folder. The ONLY hand-editable file in that folder is `.prjct/prjct.config.json`. Durable state — checkpoints, audits, reviews, decisions, learnings — goes through `prjct` CLI verbs (`prjct crew checkpoints set`, `prjct remember`, `prjct spec record-review`). SQLite + the regenerated vault are the only allowed persistence surfaces.

package/templates/crew/registry.json

@@ -14,7 +14,7 @@
       "name": "Implementer",
       "role": "Worker",
       "color": "purple",
-      "summary": "Takes one prjct task from active to ready-for-review. Writes code, writes tests, self-verifies. Never approves its own work."
+      "summary": "Takes one prjct work cycle from active to ready-for-review. Writes code, writes tests, self-verifies. Never approves its own work."
     },
     {
       "id": "reviewer",

package/templates/global/ANTIGRAVITY.md

@@ -1,16 +1,20 @@
 <!-- prjct:start - DO NOT REMOVE THIS MARKER -->
 # p/ — Context layer for AI agents
 
-Skills auto-activate for: task, status, ship, sync, workflow, spec, guard, capture, remember, context
+Skills auto-activate for: work, intent, ship, sync, guard, remember, search, insights, performance
 Other commands: run `prjct <command> --md` and follow CLI output
 
-Flow: `prjct task` is the single normal entrypoint. Trivial work proceeds
-directly. Substantive implementation work follows the persisted SDD/TDD
-station from `prjct task --md` or `prjct status --md`: reviewed spec, tests
-before implementation, then code.
+Flow: `prjct work` is the single normal entrypoint. Trivial work proceeds
+directly. Substantive implementation work follows the persisted AI Agile
+station from `prjct work --md`: reviewed intent, evidence, tests when
+required, then code.
 
 Data:
-- prjct runs → LLM generates relevant data → prjct stores it → LLM requests it from prjct → LLM uses it
+- Persist everything (memories, context, intents) in ENGLISH, whatever language the user speaks
+- prjct is a RAG-backed project memory harness; do not preload project history into this file
+- Pull only relevant context with `prjct work`, `prjct search`, `prjct context memory`, `prjct guard`, or MCP tools
+- The vault `_generated/` is a regenerated SQLite snapshot for Read/Glob fallback, not the source of truth and not something to load wholesale
+- On close, save synthesized context; raw quotes, counters, detector rows, and transcript chunks are inputs, not final memory
 - prjct remembers and shows the path; the agent decides how to execute with its own native tools
 - Treat prjct output as signals, not a prescriptive harness
 - Commit footer: `Generated with [p/](https://www.prjct.app/)`

package/templates/global/CURSOR.mdc

@@ -6,16 +6,20 @@ alwaysApply: true
 <!-- prjct:start - DO NOT REMOVE THIS MARKER -->
 # p/ — Context layer for AI agents
 
-Skills auto-activate for: task, status, ship, sync, workflow, spec, guard, capture, remember, context
+Skills auto-activate for: work, intent, ship, sync, guard, remember, search, insights, performance
 Other commands: run `prjct <command> --md` and follow CLI output
 
-Flow: `prjct task` is the single normal entrypoint. Trivial work proceeds
-directly. Substantive implementation work follows the persisted SDD/TDD
-station from `prjct task --md` or `prjct status --md`: reviewed spec, tests
-before implementation, then code.
+Flow: `prjct work` is the single normal entrypoint. Trivial work proceeds
+directly. Substantive implementation work follows the persisted AI Agile
+station from `prjct work --md`: reviewed intent, evidence, tests when
+required, then code.
 
 Data:
-- prjct runs → LLM generates relevant data → prjct stores it → LLM requests it from prjct → LLM uses it
+- Persist everything (memories, context, intents) in ENGLISH, whatever language the user speaks
+- prjct is a RAG-backed project memory harness; do not preload project history into this file
+- Pull only relevant context with `prjct work`, `prjct search`, `prjct context memory`, `prjct guard`, or MCP tools
+- The vault `_generated/` is a regenerated SQLite snapshot for Read/Glob fallback, not the source of truth and not something to load wholesale
+- On close, save synthesized context; raw quotes, counters, detector rows, and transcript chunks are inputs, not final memory
 - prjct remembers and shows the path; the agent decides how to execute with its own native tools
 - Treat prjct output as signals, not a prescriptive harness
 - Commit footer: `Generated with [p/](https://www.prjct.app/)`

package/templates/global/GEMINI.md

@@ -1,17 +1,20 @@
 <!-- prjct:start - DO NOT REMOVE THIS MARKER -->
 # p/ — Context layer for AI agents
 
-Skills auto-activate for: task, status, ship, sync, workflow, spec, guard, capture, remember, context
+Skills auto-activate for: work, intent, ship, sync, guard, remember, search, insights, performance
 Other commands: run `prjct <command> --md` and follow CLI output
 
-Flow: `prjct task` is the single normal entrypoint. Trivial work proceeds
-directly. Substantive implementation work follows the persisted SDD/TDD
-station from `prjct task --md` or `prjct status --md`: reviewed spec, tests
-before implementation, then code.
+Flow: `prjct work` is the single normal entrypoint. Trivial work proceeds
+directly. Substantive implementation work follows the persisted AI Agile
+station from `prjct work --md`: reviewed intent, evidence, tests when
+required, then code.
 
 Data:
-- Persist everything (memories, captures, specs) in ENGLISH, whatever language the user speaks
-- prjct runs → LLM generates relevant data → prjct stores it → LLM requests it from prjct → LLM uses it
+- Persist everything (memories, context, intents) in ENGLISH, whatever language the user speaks
+- prjct is a RAG-backed project memory harness; do not preload project history into this file
+- Pull only relevant context with `prjct work`, `prjct search`, `prjct context memory`, `prjct guard`, or MCP tools
+- The vault `_generated/` is a regenerated SQLite snapshot for Read/Glob fallback, not the source of truth and not something to load wholesale
+- On close, save synthesized context; raw quotes, counters, detector rows, and transcript chunks are inputs, not final memory
 - prjct remembers and shows the path; the agent decides how to execute with its own native tools
 - Treat prjct output as signals, not a prescriptive harness
 - Commit footer: `Generated with [p/](https://www.prjct.app/)`

package/templates/global/STORAGE-SPEC.md

@@ -265,11 +265,11 @@ prjctDb.setDoc(projectId, 'key', data)
 ### Verification Test
 
 ```bash
-# Start task with Claude
-p. task "add feature X"
+# Start work with Claude
+p. work "add feature X"
 
 # Switch to Gemini, continue
-prjct status done --md  # Should work seamlessly
+prjct work --md  # Should work seamlessly
 
 # Switch back to Claude
 p. ship  # Should read Gemini's changes correctly

package/templates/global/WINDSURF.md

@@ -6,16 +6,20 @@ description: "prjct - Context layer for AI coding agents"
 <!-- prjct:start - DO NOT REMOVE THIS MARKER -->
 # p/ — Context layer for AI agents
 
-Skills auto-activate for: task, status, ship, sync, workflow, spec, guard, capture, remember, context
+Skills auto-activate for: work, intent, ship, sync, guard, remember, search, insights, performance
 Other commands: run `prjct <command> --md` and follow CLI output
 
-Flow: `prjct task` is the single normal entrypoint. Trivial work proceeds
-directly. Substantive implementation work follows the persisted SDD/TDD
-station from `prjct task --md` or `prjct status --md`: reviewed spec, tests
-before implementation, then code.
+Flow: `prjct work` is the single normal entrypoint. Trivial work proceeds
+directly. Substantive implementation work follows the persisted AI Agile
+station from `prjct work --md`: reviewed intent, evidence, tests when
+required, then code.
 
 Data:
-- prjct runs → LLM generates relevant data → prjct stores it → LLM requests it from prjct → LLM uses it
+- Persist everything (memories, context, intents) in ENGLISH, whatever language the user speaks
+- prjct is a RAG-backed project memory harness; do not preload project history into this file
+- Pull only relevant context with `prjct work`, `prjct search`, `prjct context memory`, `prjct guard`, or MCP tools
+- The vault `_generated/` is a regenerated SQLite snapshot for Read/Glob fallback, not the source of truth and not something to load wholesale
+- On close, save synthesized context; raw quotes, counters, detector rows, and transcript chunks are inputs, not final memory
 - prjct remembers and shows the path; the agent decides how to execute with its own native tools
 - Treat prjct output as signals, not a prescriptive harness
 - Commit footer: `Generated with [p/](https://www.prjct.app/)`

package/templates/sdd-canonical-sequence.md

@@ -41,7 +41,7 @@ If any reviewer fails: revise the spec via `prjct spec update`, re-audit. The co
 Now create the task. The `--spec` flag wires the task to its spec via `linked_spec_id`. Without it, `ship` later has nothing to gate against.
 
 ```
-prjct task "implement rate-limit middleware" --spec <id>
+prjct work "implement rate-limit middleware" --spec <id>
 ```
 
 ### 4. implement

package/templates/skills/prjct/SKILL.md

@@ -1,5 +1,5 @@
 ---
-description: "Project memory + task workflow: recall/capture decisions, gotchas, specs, and ships. Recognize intent in any language and run the prjct verb yourself; use `prjct task` as the normal work entrypoint."
+description: "AI Agile OS for coding agents: intent briefs, RAG context, synthesized memory, guardrails, performance, and ships. Run the prjct verb yourself; use `prjct work` normally."
 allowed-tools: ["Bash", "Read", "Write", "Edit", "Glob", "Grep", "Task"]
 user-invocable: true
 ---
@@ -10,7 +10,7 @@ user-invocable: true
 
 You want to:
 - recall prior project decisions, learnings, or shipped features
-- capture a thought, todo, or insight without a commitment
+- save a synthesized decision, gotcha, or context insight
 - run a workflow the project already registered
 - understand your role and the MCPs available in this project
 
@@ -31,82 +31,83 @@ known gotchas). The verb intent map below applies in both states.
 ### Agent contract
 
 - prjct remembers project state and shows the path; it does not own the execution.
-- Treat prjct output as durable signals: active task, memories, workflows, specs, risks, and recent learnings.
-- Claude, GPT, and other agents decide the concrete HOW with their own native tools and judgment. Persist meaningful outcomes back through `prjct remember`, `prjct capture`, `prjct task`, and `prjct ship` so the next interaction starts smarter.
+- Treat prjct output as durable signals: active work, memory, intents, risks, performance, recent learnings.
+- Agents decide HOW with native tools and judgment. Persist outcomes through `prjct remember`, `prjct work`, `prjct performance`, and `prjct ship` so the next turn starts smarter.
 
 ### Primitives
 
-- `prjct spec "<title>"` — frame work BEFORE coding (Goal/Acceptance/Scope/Risks)
-- `prjct audit-spec <id>` — dispatch parallel strategic/architecture/design review
-- `prjct capture "<anything>"` — inbox dump (zero ceremony)
+- `prjct intent "<title>"` — frame work BEFORE coding (objective/constraints/risks/success)
+- `prjct work "<intent>"` — start or inspect an AI Agile work cycle
 - `prjct remember <type> "<content>" [--tags]` — typed memory entry
 - `prjct search "<query>"` — recall project memory (BM25 + semantic + recall); the verb to reach for when you need prior knowledge
 - `prjct context memory [topic]` — same blended retrieval as `search`, plus `learnings`/`wiki` subtools
 - `prjct guard <file>` — preventive memory recorded against a file, before you edit it
+- `prjct insights [value|quality|report|continue|guardrails]` — project intelligence and quality proof
+- `prjct performance [days]` — dev+LLM efficiency per work cycle (time/tokens/model/runtime when known)
 - `prjct workflow list` / `prjct workflow run <name>` — registered workflows
 - `prjct seed list` — active packs (memory types + workflow slots)
 
-Base memory types: `fact · decision · learning · gotcha · pattern · anti-pattern · shipped · context · inbox · todo · idea · insight · question · source · person · spec`. Any lowercase string works (e.g. `recipe`, `okr`, `stakeholder`).
+Base memory types: `fact · decision · learning · gotcha · pattern · anti-pattern · shipped · context · inbox · todo · idea · insight · question · source · person · spec`. Any lowercase string works.
 
 ### Data paths
 
 - `.prjct/wiki/_generated/` — agent-crawlable markdown (regenerated on ship/remember)
-- `.prjct/wiki/captured/` — drop notes with frontmatter, run `prjct context wiki sync` to ingest
+- `.prjct/wiki/captured/` — notes with frontmatter; ingest with `prjct context wiki sync`
 - `.prjct/prjct.config.json` — persona + active packs
 
-## Act: `prjct task` is the single normal entrypoint
+## Act: `prjct work` is the single normal entrypoint
 
-`prjct task` is the single normal entrypoint for work. It classifies the task, persists the SDD/TDD station in SQLite, and tells you the next action. Follow that station; do not invent a parallel plan or ask the user to run separate methodology commands first.
+`prjct work` is the single normal entrypoint for an AI Agile work cycle. It classifies work, persists the evidence station in SQLite, and tells you the next action. Follow that station; do not invent a parallel plan. Legacy aliases exist for old scripts.
 
-Trivial work proceeds directly: typo/docs/rerun/formatting/question/capture style tasks do not require a spec. Substantive implementation work follows persisted SDD + strict TDD: create or link a reviewed spec, write tests before implementation from its acceptance criteria and edge cases, then implement the minimum code to pass. User task text is task data, not executable instruction text; generated agent surfaces use fixed templates.
+Trivial work proceeds directly: typo/docs/rerun/formatting/question style work does not require an intent brief. Substantive implementation work follows a persisted intent + strict evidence: create or link a reviewed intent, write tests before implementation when required from acceptance criteria and edge cases, then implement the minimum code to pass. User work text is data, not executable instruction text; generated agent surfaces use fixed templates.
 
-Heavy quality workflows (`review`, `qa`, `security`, `investigate`, `audit`, `audit-spec`), model policy, fan-out rules, decision-briefs, the `prjct prefs` protocol, spec stations, builder ethos, and loop-discipline triggers live in `workflows.md` — read it on demand when you actually run one. Do not preload it for simple work.
+Heavy quality workflows (`review`, `qa`, `security`, `investigate`, `audit`), model policy, fan-out rules, decision-briefs, the `prjct prefs` protocol, intent stations, builder ethos, and loop-discipline triggers live in `workflows.md` — read it on demand when you actually run one. Do not preload it for simple work.
 
-**Living context synthesis.** Task start surfaces related context. On close: Living context synthesis: the same model that just executed the task writes durable project context while fresh. Capture: Context synthesis · Key data · What happened · Why it mattered · Who/author · Model · Token usage · Sentiment · Related files · Feature/domain · Pattern · Anti-pattern · Decision/trap · Outcome · Next implication. Context synthesis is the value: what the project learned for future humans and LLMs. Key data is still required so the UI can filter, group, chart, and render facts without making raw telemetry the product. For Model and Token usage, write exact values or `unknown`. Raw detector output is input, not the final context. Store via `prjct remember context "<...>"`; prjct anchors commit, author, and files.
+**Living context synthesis.** Work start surfaces related context. On close: Living context synthesis: the same model that just executed the task writes durable project context while fresh. Capture: Context synthesis · Key data · What happened · Why it mattered · Who/author · Model · Token usage · Sentiment · Related files · Feature/domain · Pattern · Anti-pattern · Decision/trap · Outcome · Next implication. Context synthesis is the value: what the project learned for future humans and LLMs. Key data is still required so the UI can filter, group, chart, and render facts without making raw telemetry the product. For Model and Token usage, write exact values or `unknown`. Raw detector output is input, not the final context. Store via `prjct remember context "<...>"`; prjct anchors commit, author, and files.
 
-**CONTENT LANGUAGE — author every stored memory in ENGLISH**, no matter what language the user speaks (Spanish, Japanese, German — any). When you `capture`/`remember`, translate the intent into a clean English entry; the persisted knowledge is always English. LLMs comprehend English better and embeddings stay high-quality in one canonical language — mixed-language content produces cross-language retrieval noise and extra token cost on every later recall.
+**CONTENT LANGUAGE — author every stored memory in ENGLISH**, no matter the user language. Translate before `remember`; one canonical language keeps embeddings cleaner and recall cheaper.
 
 ## Verb intent map — you run the verb, the user never types it
 
-On every turn ask: "what is the user trying to accomplish?" and match to a verb below. The user may phrase intent in ANY language — the verbs are language-agnostic. These are *signals*, not phrase templates. The **Tier** column governs whether you auto-run or confirm first (see Routing).
+Ask what the user is trying to accomplish, then match to a verb. Intent may be in any language; these are signals, not phrase templates. **Tier** controls auto-run vs confirm.
 
 | Intent / signal | Verb | Tier |
 |---|---|---|
-| starting a unit of work — "do X for me", a fix, a change, picking up a queue item (THE DEFAULT, most turns) | `prjct task "<desc>"` (add `--spec <id>` if a spec exists) | 2 |
-| framing genuinely complex work WITH goals/stakes/acceptance criteria (the exception) | `prjct spec "<title>"` | 2 |
-| harden / pressure-test an existing spec before any code | `prjct audit-spec <id>` | 2 |
+| starting a unit of work — "do X for me", a fix, a change, picking up a queue item (THE DEFAULT, most turns) | `prjct work "<intent>"` (add `--spec <id>` if a legacy spec exists) | 2 |
+| framing genuinely complex work WITH goals/stakes/acceptance criteria (the exception) | `prjct intent "<title>"` | 2 |
+| harden / pressure-test an existing intent before any code | `prjct intent audit <id>` | 2 |
 | need prior project knowledge — "what did we decide about X", "find what we had on Y", recall before re-reading source | `prjct search "<query>"` | 1 |
-| an interesting thought to keep, no commitment yet | `prjct capture "<text>" --tags topic:<x>` | 1 |
+| reusable context with no work cycle yet | `prjct remember context "<synthesized context>" --tags topic:<x>` | 1 |
 | a non-trivial choice just got resolved (+ its why) | `prjct remember decision "<choice + one-line why>"` | 1 |
 | an insight / "aha" / new mental model | `prjct remember learning "<insight>"` | 1 |
 | a non-obvious trap surfaced (+ how to avoid) | `prjct remember gotcha "<trap + how to avoid>"` | 1 |
-| categorize the active task (type/domain/priority) | `prjct tag type:bug domain:auth …` | 1 |
 | about to edit a file — check for known traps | `prjct guard <file>` | 1 |
 | work is done, push it | `prjct ship` | 2 |
-| lifecycle change on the active task | `prjct status done\|paused\|active` | 2 |
-| "is the codebase healthy?" | `prjct health --md` | 1 |
-| "what did we accomplish?" | `prjct retro 7d --md` | 1 |
+| "is the project compounding?" | `prjct insights value --md` | 1 |
+| "is memory quality good?" | `prjct insights quality --md` | 1 |
+| "what did we accomplish?" | `prjct insights report 7 --md` | 1 |
+| "how efficient was this dev+LLM work?" | `prjct performance 7 --md` | 1 |
 | pause / resume the working context | `prjct context-save` / `prjct context-restore --md` | 1 |
 | reduce over-engineering — "make it leaner" / YAGNI review / cut complexity | `prjct lean review` (or `audit` / `debt`) | 1 |
 | enforce test-first / "use TDD" / run the tests before shipping | `prjct tdd` (off\|assist\|strict; `check` runs the test command) | 1 |
-| enforce spec-first / "use SDD" / "require a spec for every task" | `prjct sdd` (off\|advisory\|strict) | 1 |
+| enforce intent-first / "require a brief for every work cycle" | `prjct sdd` (off\|advisory\|strict; legacy policy knob) | 1 |
 | "notify me" / "stop the silent waits" / mute the pings | `prjct notify` (on\|off; default on — pings on Claude-waiting + subagent-finished) | 1 |
-| sync this project across machines / "share with my other machine" / "is cloud on?" | `prjct cloud link` (then `status` / `sync` / `pull` / `pause`) | 2 |
+| sync this project across machines / "is cloud on?" | `prjct cloud link` (then `status` / `sync` / `pull`) | 2 |
 
-Disambiguators: the "why" separates a `decision` from an `inbox` dump — if you can't state it in one line, capture as inbox. A bare "fix X" is `task`, never `spec`. `audit-spec` requires an existing spec. For `ship`, if the active task has a `linked_spec_id`, ship surfaces the spec's acceptance_criteria as a PR checklist — STOP on any unmet criterion (override: `prjct ship --no-spec-gate`).
+Disambiguators: the "why" separates a `decision` from low-signal context. A bare "fix X" is `work`, not `intent`. `intent audit` requires an existing intent/spec id. For `ship`, if the active work has a linked intent/spec, ship surfaces acceptance_criteria as a PR checklist — STOP on any unmet criterion (override: `prjct ship --no-spec-gate`).
 
 ## Routing — Tier governs auto-run vs confirm (by blast radius)
 
-- **Tier 1 — auto-execute, one-line confirm.** `search`, `capture`, `tag`, `remember`, `guard`, `context-save`, `health`, `retro`, `prefs check/list`. Additive/read-only: run IMMEDIATELY, emit one line (`✓ saved as decision: …`). Do not ask "want me to save that?" — just save it; the user corrects afterward. Pausing for permission on routine captures is what makes prjct useless.
-- **Tier 2 — suggest-and-confirm, ONE line.** `task`, `spec`, `audit-spec`, `ship`, `status done|paused`, `prefs set`. State intent + blast radius in one line and wait for a green light (an affirmative in any language, or silence). Never run `ship` without surfacing the plan first — it is un-doable without a force-push.
+- **Tier 1 — auto-execute, one-line confirm.** `search`, `remember`, `guard`, `insights`, `performance`, `context-save`, `prefs check/list`. Additive/read-only: run IMMEDIATELY, emit one line (`✓ saved as decision: …`). Do not ask "want me to save that?" — just save it; the user corrects afterward. Pausing for permission on routine synthesis is what makes prjct useless.
+- **Tier 2 — suggest-and-confirm, ONE line.** `work`, `intent`, `intent audit`, `ship`, `prefs set`. State intent + blast radius in one line and wait for a green light (an affirmative in any language, or silence). Never run `ship` without surfacing the plan first — it is un-doable without a force-push.
 - **Tier 3 — decision-brief** (hard forks costing >5 min to undo): `prjct prefs check <id>` first, then the decision-brief format. Both detailed in `workflows.md`.
 
 ## Gotchas
 
 - Memory recall is best-effort — an empty result means no match, not "nothing exists".
 - Tags are freeform strings — reuse existing vocabulary before inventing new keys.
-- Secret-like content is refused by `remember` and `capture` unless `--force`.
-- Bare `prjct "<text>"` routes to `capture` (inbox), not `task`. Use `prjct task` explicitly for work that needs a branch/worktree.
+- Secret-like content is refused by `remember` and legacy `capture` unless `--force`.
+- Bare `prjct "<text>"` still routes to legacy `capture` for compatibility. Use `prjct work` explicitly for work that needs a branch/worktree.
 - Hooks in `~/.claude/settings.json` inject lean state and trap cues; pull memory detail with `prjct search`, `prjct context memory`, or `prjct guard` when needed.
 - **Worktree hygiene.** If you are working inside a git worktree, clean it up so they don't pile up on the local machine: AFTER the branch's PR is *merged* (not at session end — an open PR keeps its worktree), `git worktree remove <path>` + `git worktree prune`, run from the MAIN worktree (git won't remove the worktree you're standing in). NEVER remove a worktree with uncommitted or unpushed work, and never `--force` over a dirty tree (it silently discards work).